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 0 4879 }; 4880 int i; 4881 4882 VERIFY(nvlist_alloc(&delayprops, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4883 4884 for (nvp = nvlist_next_nvpair(props, NULL); nvp != NULL; 4885 nvp = nvlist_next_nvpair(props, nvp)) { 4886 /* 4887 * strcmp() is safe because zfs_prop_to_name() always returns 4888 * a bounded string. 4889 */ 4890 for (i = 0; delayable[i] != 0; i++) { 4891 if (strcmp(zfs_prop_to_name(delayable[i]), 4892 nvpair_name(nvp)) == 0) { 4893 break; 4894 } 4895 } 4896 if (delayable[i] != 0) { 4897 tmp = nvlist_prev_nvpair(props, nvp); 4898 VERIFY(nvlist_add_nvpair(delayprops, nvp) == 0); 4899 VERIFY(nvlist_remove_nvpair(props, nvp) == 0); 4900 nvp = tmp; 4901 } 4902 } 4903 4904 if (nvlist_empty(delayprops)) { 4905 nvlist_free(delayprops); 4906 delayprops = NULL; 4907 } 4908 return (delayprops); 4909 } 4910 4911 static void 4912 zfs_allow_log_destroy(void *arg) 4913 { 4914 char *poolname = arg; 4915 4916 if (poolname != NULL) 4917 kmem_strfree(poolname); 4918 } 4919 4920 #ifdef ZFS_DEBUG 4921 static boolean_t zfs_ioc_recv_inject_err; 4922 #endif 4923 4924 /* 4925 * nvlist 'errors' is always allocated. It will contain descriptions of 4926 * encountered errors, if any. It's the callers responsibility to free. 4927 */ 4928 static int 4929 zfs_ioc_recv_impl(char *tofs, char *tosnap, char *origin, nvlist_t *recvprops, 4930 nvlist_t *localprops, nvlist_t *hidden_args, boolean_t force, 4931 boolean_t heal, boolean_t resumable, int input_fd, 4932 dmu_replay_record_t *begin_record, uint64_t *read_bytes, 4933 uint64_t *errflags, nvlist_t **errors) 4934 { 4935 dmu_recv_cookie_t drc; 4936 int error = 0; 4937 int props_error = 0; 4938 offset_t off, noff; 4939 nvlist_t *local_delayprops = NULL; 4940 nvlist_t *recv_delayprops = NULL; 4941 nvlist_t *origprops = NULL; /* existing properties */ 4942 nvlist_t *origrecvd = NULL; /* existing received properties */ 4943 boolean_t first_recvd_props = B_FALSE; 4944 boolean_t tofs_was_redacted; 4945 zfs_file_t *input_fp; 4946 4947 *read_bytes = 0; 4948 *errflags = 0; 4949 *errors = fnvlist_alloc(); 4950 off = 0; 4951 4952 if ((input_fp = zfs_file_get(input_fd)) == NULL) 4953 return (SET_ERROR(EBADF)); 4954 4955 noff = off = zfs_file_off(input_fp); 4956 error = dmu_recv_begin(tofs, tosnap, begin_record, force, heal, 4957 resumable, localprops, hidden_args, origin, &drc, input_fp, 4958 &off); 4959 if (error != 0) 4960 goto out; 4961 tofs_was_redacted = dsl_get_redacted(drc.drc_ds); 4962 4963 /* 4964 * Set properties before we receive the stream so that they are applied 4965 * to the new data. Note that we must call dmu_recv_stream() if 4966 * dmu_recv_begin() succeeds. 4967 */ 4968 if (recvprops != NULL && !drc.drc_newfs) { 4969 if (spa_version(dsl_dataset_get_spa(drc.drc_ds)) >= 4970 SPA_VERSION_RECVD_PROPS && 4971 !dsl_prop_get_hasrecvd(tofs)) 4972 first_recvd_props = B_TRUE; 4973 4974 /* 4975 * If new received properties are supplied, they are to 4976 * completely replace the existing received properties, 4977 * so stash away the existing ones. 4978 */ 4979 if (dsl_prop_get_received(tofs, &origrecvd) == 0) { 4980 nvlist_t *errlist = NULL; 4981 /* 4982 * Don't bother writing a property if its value won't 4983 * change (and avoid the unnecessary security checks). 4984 * 4985 * The first receive after SPA_VERSION_RECVD_PROPS is a 4986 * special case where we blow away all local properties 4987 * regardless. 4988 */ 4989 if (!first_recvd_props) 4990 props_reduce(recvprops, origrecvd); 4991 if (zfs_check_clearable(tofs, origrecvd, &errlist) != 0) 4992 (void) nvlist_merge(*errors, errlist, 0); 4993 nvlist_free(errlist); 4994 4995 if (clear_received_props(tofs, origrecvd, 4996 first_recvd_props ? NULL : recvprops) != 0) 4997 *errflags |= ZPROP_ERR_NOCLEAR; 4998 } else { 4999 *errflags |= ZPROP_ERR_NOCLEAR; 5000 } 5001 } 5002 5003 /* 5004 * Stash away existing properties so we can restore them on error unless 5005 * we're doing the first receive after SPA_VERSION_RECVD_PROPS, in which 5006 * case "origrecvd" will take care of that. 5007 */ 5008 if (localprops != NULL && !drc.drc_newfs && !first_recvd_props) { 5009 objset_t *os; 5010 if (dmu_objset_hold(tofs, FTAG, &os) == 0) { 5011 if (dsl_prop_get_all(os, &origprops) != 0) { 5012 *errflags |= ZPROP_ERR_NOCLEAR; 5013 } 5014 dmu_objset_rele(os, FTAG); 5015 } else { 5016 *errflags |= ZPROP_ERR_NOCLEAR; 5017 } 5018 } 5019 5020 if (recvprops != NULL) { 5021 props_error = dsl_prop_set_hasrecvd(tofs); 5022 5023 if (props_error == 0) { 5024 recv_delayprops = extract_delay_props(recvprops); 5025 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED, 5026 recvprops, *errors); 5027 } 5028 } 5029 5030 if (localprops != NULL) { 5031 nvlist_t *oprops = fnvlist_alloc(); 5032 nvlist_t *xprops = fnvlist_alloc(); 5033 nvpair_t *nvp = NULL; 5034 5035 while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) { 5036 if (nvpair_type(nvp) == DATA_TYPE_BOOLEAN) { 5037 /* -x property */ 5038 const char *name = nvpair_name(nvp); 5039 zfs_prop_t prop = zfs_name_to_prop(name); 5040 if (prop != ZPROP_USERPROP) { 5041 if (!zfs_prop_inheritable(prop)) 5042 continue; 5043 } else if (!zfs_prop_user(name)) 5044 continue; 5045 fnvlist_add_boolean(xprops, name); 5046 } else { 5047 /* -o property=value */ 5048 fnvlist_add_nvpair(oprops, nvp); 5049 } 5050 } 5051 5052 local_delayprops = extract_delay_props(oprops); 5053 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, 5054 oprops, *errors); 5055 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, 5056 xprops, *errors); 5057 5058 nvlist_free(oprops); 5059 nvlist_free(xprops); 5060 } 5061 5062 error = dmu_recv_stream(&drc, &off); 5063 5064 if (error == 0) { 5065 zfsvfs_t *zfsvfs = NULL; 5066 zvol_state_handle_t *zv = NULL; 5067 5068 if (getzfsvfs(tofs, &zfsvfs) == 0) { 5069 /* online recv */ 5070 dsl_dataset_t *ds; 5071 int end_err; 5072 boolean_t stream_is_redacted = DMU_GET_FEATUREFLAGS( 5073 begin_record->drr_u.drr_begin. 5074 drr_versioninfo) & DMU_BACKUP_FEATURE_REDACTED; 5075 5076 ds = dmu_objset_ds(zfsvfs->z_os); 5077 error = zfs_suspend_fs(zfsvfs); 5078 /* 5079 * If the suspend fails, then the recv_end will 5080 * likely also fail, and clean up after itself. 5081 */ 5082 end_err = dmu_recv_end(&drc, zfsvfs); 5083 /* 5084 * If the dataset was not redacted, but we received a 5085 * redacted stream onto it, we need to unmount the 5086 * dataset. Otherwise, resume the filesystem. 5087 */ 5088 if (error == 0 && !drc.drc_newfs && 5089 stream_is_redacted && !tofs_was_redacted) { 5090 error = zfs_end_fs(zfsvfs, ds); 5091 } else if (error == 0) { 5092 error = zfs_resume_fs(zfsvfs, ds); 5093 } 5094 error = error ? error : end_err; 5095 zfs_vfs_rele(zfsvfs); 5096 } else if ((zv = zvol_suspend(tofs)) != NULL) { 5097 error = dmu_recv_end(&drc, zvol_tag(zv)); 5098 zvol_resume(zv); 5099 } else { 5100 error = dmu_recv_end(&drc, NULL); 5101 } 5102 5103 /* Set delayed properties now, after we're done receiving. */ 5104 if (recv_delayprops != NULL && error == 0) { 5105 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED, 5106 recv_delayprops, *errors); 5107 } 5108 if (local_delayprops != NULL && error == 0) { 5109 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, 5110 local_delayprops, *errors); 5111 } 5112 } 5113 5114 /* 5115 * Merge delayed props back in with initial props, in case 5116 * we're DEBUG and zfs_ioc_recv_inject_err is set (which means 5117 * we have to make sure clear_received_props() includes 5118 * the delayed properties). 5119 * 5120 * Since zfs_ioc_recv_inject_err is only in DEBUG kernels, 5121 * using ASSERT() will be just like a VERIFY. 5122 */ 5123 if (recv_delayprops != NULL) { 5124 ASSERT(nvlist_merge(recvprops, recv_delayprops, 0) == 0); 5125 nvlist_free(recv_delayprops); 5126 } 5127 if (local_delayprops != NULL) { 5128 ASSERT(nvlist_merge(localprops, local_delayprops, 0) == 0); 5129 nvlist_free(local_delayprops); 5130 } 5131 *read_bytes = off - noff; 5132 5133 #ifdef ZFS_DEBUG 5134 if (zfs_ioc_recv_inject_err) { 5135 zfs_ioc_recv_inject_err = B_FALSE; 5136 error = 1; 5137 } 5138 #endif 5139 5140 /* 5141 * On error, restore the original props. 5142 */ 5143 if (error != 0 && recvprops != NULL && !drc.drc_newfs) { 5144 if (clear_received_props(tofs, recvprops, NULL) != 0) { 5145 /* 5146 * We failed to clear the received properties. 5147 * Since we may have left a $recvd value on the 5148 * system, we can't clear the $hasrecvd flag. 5149 */ 5150 *errflags |= ZPROP_ERR_NORESTORE; 5151 } else if (first_recvd_props) { 5152 dsl_prop_unset_hasrecvd(tofs); 5153 } 5154 5155 if (origrecvd == NULL && !drc.drc_newfs) { 5156 /* We failed to stash the original properties. */ 5157 *errflags |= ZPROP_ERR_NORESTORE; 5158 } 5159 5160 /* 5161 * dsl_props_set() will not convert RECEIVED to LOCAL on or 5162 * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL 5163 * explicitly if we're restoring local properties cleared in the 5164 * first new-style receive. 5165 */ 5166 if (origrecvd != NULL && 5167 zfs_set_prop_nvlist(tofs, (first_recvd_props ? 5168 ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED), 5169 origrecvd, NULL) != 0) { 5170 /* 5171 * We stashed the original properties but failed to 5172 * restore them. 5173 */ 5174 *errflags |= ZPROP_ERR_NORESTORE; 5175 } 5176 } 5177 if (error != 0 && localprops != NULL && !drc.drc_newfs && 5178 !first_recvd_props) { 5179 nvlist_t *setprops; 5180 nvlist_t *inheritprops; 5181 nvpair_t *nvp; 5182 5183 if (origprops == NULL) { 5184 /* We failed to stash the original properties. */ 5185 *errflags |= ZPROP_ERR_NORESTORE; 5186 goto out; 5187 } 5188 5189 /* Restore original props */ 5190 setprops = fnvlist_alloc(); 5191 inheritprops = fnvlist_alloc(); 5192 nvp = NULL; 5193 while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) { 5194 const char *name = nvpair_name(nvp); 5195 const char *source; 5196 nvlist_t *attrs; 5197 5198 if (!nvlist_exists(origprops, name)) { 5199 /* 5200 * Property was not present or was explicitly 5201 * inherited before the receive, restore this. 5202 */ 5203 fnvlist_add_boolean(inheritprops, name); 5204 continue; 5205 } 5206 attrs = fnvlist_lookup_nvlist(origprops, name); 5207 source = fnvlist_lookup_string(attrs, ZPROP_SOURCE); 5208 5209 /* Skip received properties */ 5210 if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) 5211 continue; 5212 5213 if (strcmp(source, tofs) == 0) { 5214 /* Property was locally set */ 5215 fnvlist_add_nvlist(setprops, name, attrs); 5216 } else { 5217 /* Property was implicitly inherited */ 5218 fnvlist_add_boolean(inheritprops, name); 5219 } 5220 } 5221 5222 if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, setprops, 5223 NULL) != 0) 5224 *errflags |= ZPROP_ERR_NORESTORE; 5225 if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, inheritprops, 5226 NULL) != 0) 5227 *errflags |= ZPROP_ERR_NORESTORE; 5228 5229 nvlist_free(setprops); 5230 nvlist_free(inheritprops); 5231 } 5232 out: 5233 zfs_file_put(input_fp); 5234 nvlist_free(origrecvd); 5235 nvlist_free(origprops); 5236 5237 if (error == 0) 5238 error = props_error; 5239 5240 return (error); 5241 } 5242 5243 /* 5244 * inputs: 5245 * zc_name name of containing filesystem (unused) 5246 * zc_nvlist_src{_size} nvlist of properties to apply 5247 * zc_nvlist_conf{_size} nvlist of properties to exclude 5248 * (DATA_TYPE_BOOLEAN) and override (everything else) 5249 * zc_value name of snapshot to create 5250 * zc_string name of clone origin (if DRR_FLAG_CLONE) 5251 * zc_cookie file descriptor to recv from 5252 * zc_begin_record the BEGIN record of the stream (not byteswapped) 5253 * zc_guid force flag 5254 * 5255 * outputs: 5256 * zc_cookie number of bytes read 5257 * zc_obj zprop_errflags_t 5258 * zc_nvlist_dst{_size} error for each unapplied received property 5259 */ 5260 static int 5261 zfs_ioc_recv(zfs_cmd_t *zc) 5262 { 5263 dmu_replay_record_t begin_record; 5264 nvlist_t *errors = NULL; 5265 nvlist_t *recvdprops = NULL; 5266 nvlist_t *localprops = NULL; 5267 char *origin = NULL; 5268 char *tosnap; 5269 char tofs[ZFS_MAX_DATASET_NAME_LEN]; 5270 int error = 0; 5271 5272 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 || 5273 strchr(zc->zc_value, '@') == NULL || 5274 strchr(zc->zc_value, '%')) 5275 return (SET_ERROR(EINVAL)); 5276 5277 (void) strlcpy(tofs, zc->zc_value, sizeof (tofs)); 5278 tosnap = strchr(tofs, '@'); 5279 *tosnap++ = '\0'; 5280 5281 if (zc->zc_nvlist_src != 0 && 5282 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 5283 zc->zc_iflags, &recvdprops)) != 0) 5284 return (error); 5285 5286 if (zc->zc_nvlist_conf != 0 && 5287 (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 5288 zc->zc_iflags, &localprops)) != 0) 5289 return (error); 5290 5291 if (zc->zc_string[0]) 5292 origin = zc->zc_string; 5293 5294 begin_record.drr_type = DRR_BEGIN; 5295 begin_record.drr_payloadlen = 0; 5296 begin_record.drr_u.drr_begin = zc->zc_begin_record; 5297 5298 error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvdprops, localprops, 5299 NULL, zc->zc_guid, B_FALSE, B_FALSE, zc->zc_cookie, &begin_record, 5300 &zc->zc_cookie, &zc->zc_obj, &errors); 5301 nvlist_free(recvdprops); 5302 nvlist_free(localprops); 5303 5304 /* 5305 * Now that all props, initial and delayed, are set, report the prop 5306 * errors to the caller. 5307 */ 5308 if (zc->zc_nvlist_dst_size != 0 && errors != NULL && 5309 (nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 || 5310 put_nvlist(zc, errors) != 0)) { 5311 /* 5312 * Caller made zc->zc_nvlist_dst less than the minimum expected 5313 * size or supplied an invalid address. 5314 */ 5315 error = SET_ERROR(EINVAL); 5316 } 5317 5318 nvlist_free(errors); 5319 5320 return (error); 5321 } 5322 5323 /* 5324 * innvl: { 5325 * "snapname" -> full name of the snapshot to create 5326 * (optional) "props" -> received properties to set (nvlist) 5327 * (optional) "localprops" -> override and exclude properties (nvlist) 5328 * (optional) "origin" -> name of clone origin (DRR_FLAG_CLONE) 5329 * "begin_record" -> non-byteswapped dmu_replay_record_t 5330 * "input_fd" -> file descriptor to read stream from (int32) 5331 * (optional) "force" -> force flag (value ignored) 5332 * (optional) "heal" -> use send stream to heal data corruption 5333 * (optional) "resumable" -> resumable flag (value ignored) 5334 * (optional) "cleanup_fd" -> unused 5335 * (optional) "action_handle" -> unused 5336 * (optional) "hidden_args" -> { "wkeydata" -> value } 5337 * } 5338 * 5339 * outnvl: { 5340 * "read_bytes" -> number of bytes read 5341 * "error_flags" -> zprop_errflags_t 5342 * "errors" -> error for each unapplied received property (nvlist) 5343 * } 5344 */ 5345 static const zfs_ioc_key_t zfs_keys_recv_new[] = { 5346 {"snapname", DATA_TYPE_STRING, 0}, 5347 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5348 {"localprops", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5349 {"origin", DATA_TYPE_STRING, ZK_OPTIONAL}, 5350 {"begin_record", DATA_TYPE_BYTE_ARRAY, 0}, 5351 {"input_fd", DATA_TYPE_INT32, 0}, 5352 {"force", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 5353 {"heal", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 5354 {"resumable", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 5355 {"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 5356 {"action_handle", DATA_TYPE_UINT64, ZK_OPTIONAL}, 5357 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5358 }; 5359 5360 static int 5361 zfs_ioc_recv_new(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 5362 { 5363 dmu_replay_record_t *begin_record; 5364 uint_t begin_record_size; 5365 nvlist_t *errors = NULL; 5366 nvlist_t *recvprops = NULL; 5367 nvlist_t *localprops = NULL; 5368 nvlist_t *hidden_args = NULL; 5369 char *snapname; 5370 char *origin = NULL; 5371 char *tosnap; 5372 char tofs[ZFS_MAX_DATASET_NAME_LEN]; 5373 boolean_t force; 5374 boolean_t heal; 5375 boolean_t resumable; 5376 uint64_t read_bytes = 0; 5377 uint64_t errflags = 0; 5378 int input_fd = -1; 5379 int error; 5380 5381 snapname = fnvlist_lookup_string(innvl, "snapname"); 5382 5383 if (dataset_namecheck(snapname, NULL, NULL) != 0 || 5384 strchr(snapname, '@') == NULL || 5385 strchr(snapname, '%')) 5386 return (SET_ERROR(EINVAL)); 5387 5388 (void) strlcpy(tofs, snapname, sizeof (tofs)); 5389 tosnap = strchr(tofs, '@'); 5390 *tosnap++ = '\0'; 5391 5392 error = nvlist_lookup_string(innvl, "origin", &origin); 5393 if (error && error != ENOENT) 5394 return (error); 5395 5396 error = nvlist_lookup_byte_array(innvl, "begin_record", 5397 (uchar_t **)&begin_record, &begin_record_size); 5398 if (error != 0 || begin_record_size != sizeof (*begin_record)) 5399 return (SET_ERROR(EINVAL)); 5400 5401 input_fd = fnvlist_lookup_int32(innvl, "input_fd"); 5402 5403 force = nvlist_exists(innvl, "force"); 5404 heal = nvlist_exists(innvl, "heal"); 5405 resumable = nvlist_exists(innvl, "resumable"); 5406 5407 /* we still use "props" here for backwards compatibility */ 5408 error = nvlist_lookup_nvlist(innvl, "props", &recvprops); 5409 if (error && error != ENOENT) 5410 return (error); 5411 5412 error = nvlist_lookup_nvlist(innvl, "localprops", &localprops); 5413 if (error && error != ENOENT) 5414 return (error); 5415 5416 error = nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args); 5417 if (error && error != ENOENT) 5418 return (error); 5419 5420 error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvprops, localprops, 5421 hidden_args, force, heal, resumable, input_fd, begin_record, 5422 &read_bytes, &errflags, &errors); 5423 5424 fnvlist_add_uint64(outnvl, "read_bytes", read_bytes); 5425 fnvlist_add_uint64(outnvl, "error_flags", errflags); 5426 fnvlist_add_nvlist(outnvl, "errors", errors); 5427 5428 nvlist_free(errors); 5429 nvlist_free(recvprops); 5430 nvlist_free(localprops); 5431 5432 return (error); 5433 } 5434 5435 typedef struct dump_bytes_io { 5436 zfs_file_t *dbi_fp; 5437 caddr_t dbi_buf; 5438 int dbi_len; 5439 int dbi_err; 5440 } dump_bytes_io_t; 5441 5442 static void 5443 dump_bytes_cb(void *arg) 5444 { 5445 dump_bytes_io_t *dbi = (dump_bytes_io_t *)arg; 5446 zfs_file_t *fp; 5447 caddr_t buf; 5448 5449 fp = dbi->dbi_fp; 5450 buf = dbi->dbi_buf; 5451 5452 dbi->dbi_err = zfs_file_write(fp, buf, dbi->dbi_len, NULL); 5453 } 5454 5455 static int 5456 dump_bytes(objset_t *os, void *buf, int len, void *arg) 5457 { 5458 dump_bytes_io_t dbi; 5459 5460 dbi.dbi_fp = arg; 5461 dbi.dbi_buf = buf; 5462 dbi.dbi_len = len; 5463 5464 #if defined(HAVE_LARGE_STACKS) 5465 dump_bytes_cb(&dbi); 5466 #else 5467 /* 5468 * The vn_rdwr() call is performed in a taskq to ensure that there is 5469 * always enough stack space to write safely to the target filesystem. 5470 * The ZIO_TYPE_FREE threads are used because there can be a lot of 5471 * them and they are used in vdev_file.c for a similar purpose. 5472 */ 5473 spa_taskq_dispatch_sync(dmu_objset_spa(os), ZIO_TYPE_FREE, 5474 ZIO_TASKQ_ISSUE, dump_bytes_cb, &dbi, TQ_SLEEP); 5475 #endif /* HAVE_LARGE_STACKS */ 5476 5477 return (dbi.dbi_err); 5478 } 5479 5480 /* 5481 * inputs: 5482 * zc_name name of snapshot to send 5483 * zc_cookie file descriptor to send stream to 5484 * zc_obj fromorigin flag (mutually exclusive with zc_fromobj) 5485 * zc_sendobj objsetid of snapshot to send 5486 * zc_fromobj objsetid of incremental fromsnap (may be zero) 5487 * zc_guid if set, estimate size of stream only. zc_cookie is ignored. 5488 * output size in zc_objset_type. 5489 * zc_flags lzc_send_flags 5490 * 5491 * outputs: 5492 * zc_objset_type estimated size, if zc_guid is set 5493 * 5494 * NOTE: This is no longer the preferred interface, any new functionality 5495 * should be added to zfs_ioc_send_new() instead. 5496 */ 5497 static int 5498 zfs_ioc_send(zfs_cmd_t *zc) 5499 { 5500 int error; 5501 offset_t off; 5502 boolean_t estimate = (zc->zc_guid != 0); 5503 boolean_t embedok = (zc->zc_flags & 0x1); 5504 boolean_t large_block_ok = (zc->zc_flags & 0x2); 5505 boolean_t compressok = (zc->zc_flags & 0x4); 5506 boolean_t rawok = (zc->zc_flags & 0x8); 5507 boolean_t savedok = (zc->zc_flags & 0x10); 5508 5509 if (zc->zc_obj != 0) { 5510 dsl_pool_t *dp; 5511 dsl_dataset_t *tosnap; 5512 5513 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5514 if (error != 0) 5515 return (error); 5516 5517 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap); 5518 if (error != 0) { 5519 dsl_pool_rele(dp, FTAG); 5520 return (error); 5521 } 5522 5523 if (dsl_dir_is_clone(tosnap->ds_dir)) 5524 zc->zc_fromobj = 5525 dsl_dir_phys(tosnap->ds_dir)->dd_origin_obj; 5526 dsl_dataset_rele(tosnap, FTAG); 5527 dsl_pool_rele(dp, FTAG); 5528 } 5529 5530 if (estimate) { 5531 dsl_pool_t *dp; 5532 dsl_dataset_t *tosnap; 5533 dsl_dataset_t *fromsnap = NULL; 5534 5535 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5536 if (error != 0) 5537 return (error); 5538 5539 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, 5540 FTAG, &tosnap); 5541 if (error != 0) { 5542 dsl_pool_rele(dp, FTAG); 5543 return (error); 5544 } 5545 5546 if (zc->zc_fromobj != 0) { 5547 error = dsl_dataset_hold_obj(dp, zc->zc_fromobj, 5548 FTAG, &fromsnap); 5549 if (error != 0) { 5550 dsl_dataset_rele(tosnap, FTAG); 5551 dsl_pool_rele(dp, FTAG); 5552 return (error); 5553 } 5554 } 5555 5556 error = dmu_send_estimate_fast(tosnap, fromsnap, NULL, 5557 compressok || rawok, savedok, &zc->zc_objset_type); 5558 5559 if (fromsnap != NULL) 5560 dsl_dataset_rele(fromsnap, FTAG); 5561 dsl_dataset_rele(tosnap, FTAG); 5562 dsl_pool_rele(dp, FTAG); 5563 } else { 5564 zfs_file_t *fp; 5565 dmu_send_outparams_t out = {0}; 5566 5567 if ((fp = zfs_file_get(zc->zc_cookie)) == NULL) 5568 return (SET_ERROR(EBADF)); 5569 5570 off = zfs_file_off(fp); 5571 out.dso_outfunc = dump_bytes; 5572 out.dso_arg = fp; 5573 out.dso_dryrun = B_FALSE; 5574 error = dmu_send_obj(zc->zc_name, zc->zc_sendobj, 5575 zc->zc_fromobj, embedok, large_block_ok, compressok, 5576 rawok, savedok, zc->zc_cookie, &off, &out); 5577 5578 zfs_file_put(fp); 5579 } 5580 return (error); 5581 } 5582 5583 /* 5584 * inputs: 5585 * zc_name name of snapshot on which to report progress 5586 * zc_cookie file descriptor of send stream 5587 * 5588 * outputs: 5589 * zc_cookie number of bytes written in send stream thus far 5590 * zc_objset_type logical size of data traversed by send thus far 5591 */ 5592 static int 5593 zfs_ioc_send_progress(zfs_cmd_t *zc) 5594 { 5595 dsl_pool_t *dp; 5596 dsl_dataset_t *ds; 5597 dmu_sendstatus_t *dsp = NULL; 5598 int error; 5599 5600 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5601 if (error != 0) 5602 return (error); 5603 5604 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds); 5605 if (error != 0) { 5606 dsl_pool_rele(dp, FTAG); 5607 return (error); 5608 } 5609 5610 mutex_enter(&ds->ds_sendstream_lock); 5611 5612 /* 5613 * Iterate over all the send streams currently active on this dataset. 5614 * If there's one which matches the specified file descriptor _and_ the 5615 * stream was started by the current process, return the progress of 5616 * that stream. 5617 */ 5618 5619 for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL; 5620 dsp = list_next(&ds->ds_sendstreams, dsp)) { 5621 if (dsp->dss_outfd == zc->zc_cookie && 5622 zfs_proc_is_caller(dsp->dss_proc)) 5623 break; 5624 } 5625 5626 if (dsp != NULL) { 5627 zc->zc_cookie = atomic_cas_64((volatile uint64_t *)dsp->dss_off, 5628 0, 0); 5629 /* This is the closest thing we have to atomic_read_64. */ 5630 zc->zc_objset_type = atomic_cas_64(&dsp->dss_blocks, 0, 0); 5631 } else { 5632 error = SET_ERROR(ENOENT); 5633 } 5634 5635 mutex_exit(&ds->ds_sendstream_lock); 5636 dsl_dataset_rele(ds, FTAG); 5637 dsl_pool_rele(dp, FTAG); 5638 return (error); 5639 } 5640 5641 static int 5642 zfs_ioc_inject_fault(zfs_cmd_t *zc) 5643 { 5644 int id, error; 5645 5646 error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id, 5647 &zc->zc_inject_record); 5648 5649 if (error == 0) 5650 zc->zc_guid = (uint64_t)id; 5651 5652 return (error); 5653 } 5654 5655 static int 5656 zfs_ioc_clear_fault(zfs_cmd_t *zc) 5657 { 5658 return (zio_clear_fault((int)zc->zc_guid)); 5659 } 5660 5661 static int 5662 zfs_ioc_inject_list_next(zfs_cmd_t *zc) 5663 { 5664 int id = (int)zc->zc_guid; 5665 int error; 5666 5667 error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name), 5668 &zc->zc_inject_record); 5669 5670 zc->zc_guid = id; 5671 5672 return (error); 5673 } 5674 5675 static int 5676 zfs_ioc_error_log(zfs_cmd_t *zc) 5677 { 5678 spa_t *spa; 5679 int error; 5680 uint64_t count = zc->zc_nvlist_dst_size; 5681 5682 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 5683 return (error); 5684 5685 error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst, 5686 &count); 5687 if (error == 0) 5688 zc->zc_nvlist_dst_size = count; 5689 else 5690 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa); 5691 5692 spa_close(spa, FTAG); 5693 5694 return (error); 5695 } 5696 5697 static int 5698 zfs_ioc_clear(zfs_cmd_t *zc) 5699 { 5700 spa_t *spa; 5701 vdev_t *vd; 5702 int error; 5703 5704 /* 5705 * On zpool clear we also fix up missing slogs 5706 */ 5707 mutex_enter(&spa_namespace_lock); 5708 spa = spa_lookup(zc->zc_name); 5709 if (spa == NULL) { 5710 mutex_exit(&spa_namespace_lock); 5711 return (SET_ERROR(EIO)); 5712 } 5713 if (spa_get_log_state(spa) == SPA_LOG_MISSING) { 5714 /* we need to let spa_open/spa_load clear the chains */ 5715 spa_set_log_state(spa, SPA_LOG_CLEAR); 5716 } 5717 spa->spa_last_open_failed = 0; 5718 mutex_exit(&spa_namespace_lock); 5719 5720 if (zc->zc_cookie & ZPOOL_NO_REWIND) { 5721 error = spa_open(zc->zc_name, &spa, FTAG); 5722 } else { 5723 nvlist_t *policy; 5724 nvlist_t *config = NULL; 5725 5726 if (zc->zc_nvlist_src == 0) 5727 return (SET_ERROR(EINVAL)); 5728 5729 if ((error = get_nvlist(zc->zc_nvlist_src, 5730 zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) { 5731 error = spa_open_rewind(zc->zc_name, &spa, FTAG, 5732 policy, &config); 5733 if (config != NULL) { 5734 int err; 5735 5736 if ((err = put_nvlist(zc, config)) != 0) 5737 error = err; 5738 nvlist_free(config); 5739 } 5740 nvlist_free(policy); 5741 } 5742 } 5743 5744 if (error != 0) 5745 return (error); 5746 5747 /* 5748 * If multihost is enabled, resuming I/O is unsafe as another 5749 * host may have imported the pool. 5750 */ 5751 if (spa_multihost(spa) && spa_suspended(spa)) 5752 return (SET_ERROR(EINVAL)); 5753 5754 spa_vdev_state_enter(spa, SCL_NONE); 5755 5756 if (zc->zc_guid == 0) { 5757 vd = NULL; 5758 } else { 5759 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE); 5760 if (vd == NULL) { 5761 error = SET_ERROR(ENODEV); 5762 (void) spa_vdev_state_exit(spa, NULL, error); 5763 spa_close(spa, FTAG); 5764 return (error); 5765 } 5766 } 5767 5768 vdev_clear(spa, vd); 5769 5770 (void) spa_vdev_state_exit(spa, spa_suspended(spa) ? 5771 NULL : spa->spa_root_vdev, 0); 5772 5773 /* 5774 * Resume any suspended I/Os. 5775 */ 5776 if (zio_resume(spa) != 0) 5777 error = SET_ERROR(EIO); 5778 5779 spa_close(spa, FTAG); 5780 5781 return (error); 5782 } 5783 5784 /* 5785 * Reopen all the vdevs associated with the pool. 5786 * 5787 * innvl: { 5788 * "scrub_restart" -> when true and scrub is running, allow to restart 5789 * scrub as the side effect of the reopen (boolean). 5790 * } 5791 * 5792 * outnvl is unused 5793 */ 5794 static const zfs_ioc_key_t zfs_keys_pool_reopen[] = { 5795 {"scrub_restart", DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL}, 5796 }; 5797 5798 static int 5799 zfs_ioc_pool_reopen(const char *pool, nvlist_t *innvl, nvlist_t *outnvl) 5800 { 5801 (void) outnvl; 5802 spa_t *spa; 5803 int error; 5804 boolean_t rc, scrub_restart = B_TRUE; 5805 5806 if (innvl) { 5807 error = nvlist_lookup_boolean_value(innvl, 5808 "scrub_restart", &rc); 5809 if (error == 0) 5810 scrub_restart = rc; 5811 } 5812 5813 error = spa_open(pool, &spa, FTAG); 5814 if (error != 0) 5815 return (error); 5816 5817 spa_vdev_state_enter(spa, SCL_NONE); 5818 5819 /* 5820 * If the scrub_restart flag is B_FALSE and a scrub is already 5821 * in progress then set spa_scrub_reopen flag to B_TRUE so that 5822 * we don't restart the scrub as a side effect of the reopen. 5823 * Otherwise, let vdev_open() decided if a resilver is required. 5824 */ 5825 5826 spa->spa_scrub_reopen = (!scrub_restart && 5827 dsl_scan_scrubbing(spa->spa_dsl_pool)); 5828 vdev_reopen(spa->spa_root_vdev); 5829 spa->spa_scrub_reopen = B_FALSE; 5830 5831 (void) spa_vdev_state_exit(spa, NULL, 0); 5832 spa_close(spa, FTAG); 5833 return (0); 5834 } 5835 5836 /* 5837 * inputs: 5838 * zc_name name of filesystem 5839 * 5840 * outputs: 5841 * zc_string name of conflicting snapshot, if there is one 5842 */ 5843 static int 5844 zfs_ioc_promote(zfs_cmd_t *zc) 5845 { 5846 dsl_pool_t *dp; 5847 dsl_dataset_t *ds, *ods; 5848 char origin[ZFS_MAX_DATASET_NAME_LEN]; 5849 char *cp; 5850 int error; 5851 5852 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0'; 5853 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 || 5854 strchr(zc->zc_name, '%')) 5855 return (SET_ERROR(EINVAL)); 5856 5857 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5858 if (error != 0) 5859 return (error); 5860 5861 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds); 5862 if (error != 0) { 5863 dsl_pool_rele(dp, FTAG); 5864 return (error); 5865 } 5866 5867 if (!dsl_dir_is_clone(ds->ds_dir)) { 5868 dsl_dataset_rele(ds, FTAG); 5869 dsl_pool_rele(dp, FTAG); 5870 return (SET_ERROR(EINVAL)); 5871 } 5872 5873 error = dsl_dataset_hold_obj(dp, 5874 dsl_dir_phys(ds->ds_dir)->dd_origin_obj, FTAG, &ods); 5875 if (error != 0) { 5876 dsl_dataset_rele(ds, FTAG); 5877 dsl_pool_rele(dp, FTAG); 5878 return (error); 5879 } 5880 5881 dsl_dataset_name(ods, origin); 5882 dsl_dataset_rele(ods, FTAG); 5883 dsl_dataset_rele(ds, FTAG); 5884 dsl_pool_rele(dp, FTAG); 5885 5886 /* 5887 * We don't need to unmount *all* the origin fs's snapshots, but 5888 * it's easier. 5889 */ 5890 cp = strchr(origin, '@'); 5891 if (cp) 5892 *cp = '\0'; 5893 (void) dmu_objset_find(origin, 5894 zfs_unmount_snap_cb, NULL, DS_FIND_SNAPSHOTS); 5895 return (dsl_dataset_promote(zc->zc_name, zc->zc_string)); 5896 } 5897 5898 /* 5899 * Retrieve a single {user|group|project}{used|quota}@... property. 5900 * 5901 * inputs: 5902 * zc_name name of filesystem 5903 * zc_objset_type zfs_userquota_prop_t 5904 * zc_value domain name (eg. "S-1-234-567-89") 5905 * zc_guid RID/UID/GID 5906 * 5907 * outputs: 5908 * zc_cookie property value 5909 */ 5910 static int 5911 zfs_ioc_userspace_one(zfs_cmd_t *zc) 5912 { 5913 zfsvfs_t *zfsvfs; 5914 int error; 5915 5916 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS) 5917 return (SET_ERROR(EINVAL)); 5918 5919 error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE); 5920 if (error != 0) 5921 return (error); 5922 5923 error = zfs_userspace_one(zfsvfs, 5924 zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie); 5925 zfsvfs_rele(zfsvfs, FTAG); 5926 5927 return (error); 5928 } 5929 5930 /* 5931 * inputs: 5932 * zc_name name of filesystem 5933 * zc_cookie zap cursor 5934 * zc_objset_type zfs_userquota_prop_t 5935 * zc_nvlist_dst[_size] buffer to fill (not really an nvlist) 5936 * 5937 * outputs: 5938 * zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t) 5939 * zc_cookie zap cursor 5940 */ 5941 static int 5942 zfs_ioc_userspace_many(zfs_cmd_t *zc) 5943 { 5944 zfsvfs_t *zfsvfs; 5945 int bufsize = zc->zc_nvlist_dst_size; 5946 5947 if (bufsize <= 0) 5948 return (SET_ERROR(ENOMEM)); 5949 5950 int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE); 5951 if (error != 0) 5952 return (error); 5953 5954 void *buf = vmem_alloc(bufsize, KM_SLEEP); 5955 5956 error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie, 5957 buf, &zc->zc_nvlist_dst_size); 5958 5959 if (error == 0) { 5960 error = xcopyout(buf, 5961 (void *)(uintptr_t)zc->zc_nvlist_dst, 5962 zc->zc_nvlist_dst_size); 5963 } 5964 vmem_free(buf, bufsize); 5965 zfsvfs_rele(zfsvfs, FTAG); 5966 5967 return (error); 5968 } 5969 5970 /* 5971 * inputs: 5972 * zc_name name of filesystem 5973 * 5974 * outputs: 5975 * none 5976 */ 5977 static int 5978 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc) 5979 { 5980 int error = 0; 5981 zfsvfs_t *zfsvfs; 5982 5983 if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) { 5984 if (!dmu_objset_userused_enabled(zfsvfs->z_os)) { 5985 /* 5986 * If userused is not enabled, it may be because the 5987 * objset needs to be closed & reopened (to grow the 5988 * objset_phys_t). Suspend/resume the fs will do that. 5989 */ 5990 dsl_dataset_t *ds, *newds; 5991 5992 ds = dmu_objset_ds(zfsvfs->z_os); 5993 error = zfs_suspend_fs(zfsvfs); 5994 if (error == 0) { 5995 dmu_objset_refresh_ownership(ds, &newds, 5996 B_TRUE, zfsvfs); 5997 error = zfs_resume_fs(zfsvfs, newds); 5998 } 5999 } 6000 if (error == 0) { 6001 mutex_enter(&zfsvfs->z_os->os_upgrade_lock); 6002 if (zfsvfs->z_os->os_upgrade_id == 0) { 6003 /* clear potential error code and retry */ 6004 zfsvfs->z_os->os_upgrade_status = 0; 6005 mutex_exit(&zfsvfs->z_os->os_upgrade_lock); 6006 6007 dsl_pool_config_enter( 6008 dmu_objset_pool(zfsvfs->z_os), FTAG); 6009 dmu_objset_userspace_upgrade(zfsvfs->z_os); 6010 dsl_pool_config_exit( 6011 dmu_objset_pool(zfsvfs->z_os), FTAG); 6012 } else { 6013 mutex_exit(&zfsvfs->z_os->os_upgrade_lock); 6014 } 6015 6016 taskq_wait_id(zfsvfs->z_os->os_spa->spa_upgrade_taskq, 6017 zfsvfs->z_os->os_upgrade_id); 6018 error = zfsvfs->z_os->os_upgrade_status; 6019 } 6020 zfs_vfs_rele(zfsvfs); 6021 } else { 6022 objset_t *os; 6023 6024 /* XXX kind of reading contents without owning */ 6025 error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os); 6026 if (error != 0) 6027 return (error); 6028 6029 mutex_enter(&os->os_upgrade_lock); 6030 if (os->os_upgrade_id == 0) { 6031 /* clear potential error code and retry */ 6032 os->os_upgrade_status = 0; 6033 mutex_exit(&os->os_upgrade_lock); 6034 6035 dmu_objset_userspace_upgrade(os); 6036 } else { 6037 mutex_exit(&os->os_upgrade_lock); 6038 } 6039 6040 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6041 6042 taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id); 6043 error = os->os_upgrade_status; 6044 6045 dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, 6046 FTAG); 6047 } 6048 return (error); 6049 } 6050 6051 /* 6052 * inputs: 6053 * zc_name name of filesystem 6054 * 6055 * outputs: 6056 * none 6057 */ 6058 static int 6059 zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc) 6060 { 6061 objset_t *os; 6062 int error; 6063 6064 error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os); 6065 if (error != 0) 6066 return (error); 6067 6068 if (dmu_objset_userobjspace_upgradable(os) || 6069 dmu_objset_projectquota_upgradable(os)) { 6070 mutex_enter(&os->os_upgrade_lock); 6071 if (os->os_upgrade_id == 0) { 6072 /* clear potential error code and retry */ 6073 os->os_upgrade_status = 0; 6074 mutex_exit(&os->os_upgrade_lock); 6075 6076 dmu_objset_id_quota_upgrade(os); 6077 } else { 6078 mutex_exit(&os->os_upgrade_lock); 6079 } 6080 6081 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6082 6083 taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id); 6084 error = os->os_upgrade_status; 6085 } else { 6086 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6087 } 6088 6089 dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, FTAG); 6090 6091 return (error); 6092 } 6093 6094 static int 6095 zfs_ioc_share(zfs_cmd_t *zc) 6096 { 6097 return (SET_ERROR(ENOSYS)); 6098 } 6099 6100 /* 6101 * inputs: 6102 * zc_name name of containing filesystem 6103 * zc_obj object # beyond which we want next in-use object # 6104 * 6105 * outputs: 6106 * zc_obj next in-use object # 6107 */ 6108 static int 6109 zfs_ioc_next_obj(zfs_cmd_t *zc) 6110 { 6111 objset_t *os = NULL; 6112 int error; 6113 6114 error = dmu_objset_hold(zc->zc_name, FTAG, &os); 6115 if (error != 0) 6116 return (error); 6117 6118 error = dmu_object_next(os, &zc->zc_obj, B_FALSE, 0); 6119 6120 dmu_objset_rele(os, FTAG); 6121 return (error); 6122 } 6123 6124 /* 6125 * inputs: 6126 * zc_name name of filesystem 6127 * zc_value prefix name for snapshot 6128 * zc_cleanup_fd cleanup-on-exit file descriptor for calling process 6129 * 6130 * outputs: 6131 * zc_value short name of new snapshot 6132 */ 6133 static int 6134 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc) 6135 { 6136 char *snap_name; 6137 char *hold_name; 6138 minor_t minor; 6139 6140 zfs_file_t *fp = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor); 6141 if (fp == NULL) 6142 return (SET_ERROR(EBADF)); 6143 6144 snap_name = kmem_asprintf("%s-%016llx", zc->zc_value, 6145 (u_longlong_t)ddi_get_lbolt64()); 6146 hold_name = kmem_asprintf("%%%s", zc->zc_value); 6147 6148 int error = dsl_dataset_snapshot_tmp(zc->zc_name, snap_name, minor, 6149 hold_name); 6150 if (error == 0) 6151 (void) strlcpy(zc->zc_value, snap_name, 6152 sizeof (zc->zc_value)); 6153 kmem_strfree(snap_name); 6154 kmem_strfree(hold_name); 6155 zfs_onexit_fd_rele(fp); 6156 return (error); 6157 } 6158 6159 /* 6160 * inputs: 6161 * zc_name name of "to" snapshot 6162 * zc_value name of "from" snapshot 6163 * zc_cookie file descriptor to write diff data on 6164 * 6165 * outputs: 6166 * dmu_diff_record_t's to the file descriptor 6167 */ 6168 static int 6169 zfs_ioc_diff(zfs_cmd_t *zc) 6170 { 6171 zfs_file_t *fp; 6172 offset_t off; 6173 int error; 6174 6175 if ((fp = zfs_file_get(zc->zc_cookie)) == NULL) 6176 return (SET_ERROR(EBADF)); 6177 6178 off = zfs_file_off(fp); 6179 error = dmu_diff(zc->zc_name, zc->zc_value, fp, &off); 6180 6181 zfs_file_put(fp); 6182 6183 return (error); 6184 } 6185 6186 static int 6187 zfs_ioc_smb_acl(zfs_cmd_t *zc) 6188 { 6189 return (SET_ERROR(ENOTSUP)); 6190 } 6191 6192 /* 6193 * innvl: { 6194 * "holds" -> { snapname -> holdname (string), ... } 6195 * (optional) "cleanup_fd" -> fd (int32) 6196 * } 6197 * 6198 * outnvl: { 6199 * snapname -> error value (int32) 6200 * ... 6201 * } 6202 */ 6203 static const zfs_ioc_key_t zfs_keys_hold[] = { 6204 {"holds", DATA_TYPE_NVLIST, 0}, 6205 {"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 6206 }; 6207 6208 static int 6209 zfs_ioc_hold(const char *pool, nvlist_t *args, nvlist_t *errlist) 6210 { 6211 (void) pool; 6212 nvpair_t *pair; 6213 nvlist_t *holds; 6214 int cleanup_fd = -1; 6215 int error; 6216 minor_t minor = 0; 6217 zfs_file_t *fp = NULL; 6218 6219 holds = fnvlist_lookup_nvlist(args, "holds"); 6220 6221 /* make sure the user didn't pass us any invalid (empty) tags */ 6222 for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL; 6223 pair = nvlist_next_nvpair(holds, pair)) { 6224 char *htag; 6225 6226 error = nvpair_value_string(pair, &htag); 6227 if (error != 0) 6228 return (SET_ERROR(error)); 6229 6230 if (strlen(htag) == 0) 6231 return (SET_ERROR(EINVAL)); 6232 } 6233 6234 if (nvlist_lookup_int32(args, "cleanup_fd", &cleanup_fd) == 0) { 6235 fp = zfs_onexit_fd_hold(cleanup_fd, &minor); 6236 if (fp == NULL) 6237 return (SET_ERROR(EBADF)); 6238 } 6239 6240 error = dsl_dataset_user_hold(holds, minor, errlist); 6241 if (fp != NULL) { 6242 ASSERT3U(minor, !=, 0); 6243 zfs_onexit_fd_rele(fp); 6244 } 6245 return (SET_ERROR(error)); 6246 } 6247 6248 /* 6249 * innvl is not used. 6250 * 6251 * outnvl: { 6252 * holdname -> time added (uint64 seconds since epoch) 6253 * ... 6254 * } 6255 */ 6256 static const zfs_ioc_key_t zfs_keys_get_holds[] = { 6257 /* no nvl keys */ 6258 }; 6259 6260 static int 6261 zfs_ioc_get_holds(const char *snapname, nvlist_t *args, nvlist_t *outnvl) 6262 { 6263 (void) args; 6264 return (dsl_dataset_get_holds(snapname, outnvl)); 6265 } 6266 6267 /* 6268 * innvl: { 6269 * snapname -> { holdname, ... } 6270 * ... 6271 * } 6272 * 6273 * outnvl: { 6274 * snapname -> error value (int32) 6275 * ... 6276 * } 6277 */ 6278 static const zfs_ioc_key_t zfs_keys_release[] = { 6279 {"<snapname>...", DATA_TYPE_NVLIST, ZK_WILDCARDLIST}, 6280 }; 6281 6282 static int 6283 zfs_ioc_release(const char *pool, nvlist_t *holds, nvlist_t *errlist) 6284 { 6285 (void) pool; 6286 return (dsl_dataset_user_release(holds, errlist)); 6287 } 6288 6289 /* 6290 * inputs: 6291 * zc_guid flags (ZEVENT_NONBLOCK) 6292 * zc_cleanup_fd zevent file descriptor 6293 * 6294 * outputs: 6295 * zc_nvlist_dst next nvlist event 6296 * zc_cookie dropped events since last get 6297 */ 6298 static int 6299 zfs_ioc_events_next(zfs_cmd_t *zc) 6300 { 6301 zfs_zevent_t *ze; 6302 nvlist_t *event = NULL; 6303 minor_t minor; 6304 uint64_t dropped = 0; 6305 int error; 6306 6307 zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze); 6308 if (fp == NULL) 6309 return (SET_ERROR(EBADF)); 6310 6311 do { 6312 error = zfs_zevent_next(ze, &event, 6313 &zc->zc_nvlist_dst_size, &dropped); 6314 if (event != NULL) { 6315 zc->zc_cookie = dropped; 6316 error = put_nvlist(zc, event); 6317 nvlist_free(event); 6318 } 6319 6320 if (zc->zc_guid & ZEVENT_NONBLOCK) 6321 break; 6322 6323 if ((error == 0) || (error != ENOENT)) 6324 break; 6325 6326 error = zfs_zevent_wait(ze); 6327 if (error != 0) 6328 break; 6329 } while (1); 6330 6331 zfs_zevent_fd_rele(fp); 6332 6333 return (error); 6334 } 6335 6336 /* 6337 * outputs: 6338 * zc_cookie cleared events count 6339 */ 6340 static int 6341 zfs_ioc_events_clear(zfs_cmd_t *zc) 6342 { 6343 int count; 6344 6345 zfs_zevent_drain_all(&count); 6346 zc->zc_cookie = count; 6347 6348 return (0); 6349 } 6350 6351 /* 6352 * inputs: 6353 * zc_guid eid | ZEVENT_SEEK_START | ZEVENT_SEEK_END 6354 * zc_cleanup zevent file descriptor 6355 */ 6356 static int 6357 zfs_ioc_events_seek(zfs_cmd_t *zc) 6358 { 6359 zfs_zevent_t *ze; 6360 minor_t minor; 6361 int error; 6362 6363 zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze); 6364 if (fp == NULL) 6365 return (SET_ERROR(EBADF)); 6366 6367 error = zfs_zevent_seek(ze, zc->zc_guid); 6368 zfs_zevent_fd_rele(fp); 6369 6370 return (error); 6371 } 6372 6373 /* 6374 * inputs: 6375 * zc_name name of later filesystem or snapshot 6376 * zc_value full name of old snapshot or bookmark 6377 * 6378 * outputs: 6379 * zc_cookie space in bytes 6380 * zc_objset_type compressed space in bytes 6381 * zc_perm_action uncompressed space in bytes 6382 */ 6383 static int 6384 zfs_ioc_space_written(zfs_cmd_t *zc) 6385 { 6386 int error; 6387 dsl_pool_t *dp; 6388 dsl_dataset_t *new; 6389 6390 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 6391 if (error != 0) 6392 return (error); 6393 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &new); 6394 if (error != 0) { 6395 dsl_pool_rele(dp, FTAG); 6396 return (error); 6397 } 6398 if (strchr(zc->zc_value, '#') != NULL) { 6399 zfs_bookmark_phys_t bmp; 6400 error = dsl_bookmark_lookup(dp, zc->zc_value, 6401 new, &bmp); 6402 if (error == 0) { 6403 error = dsl_dataset_space_written_bookmark(&bmp, new, 6404 &zc->zc_cookie, 6405 &zc->zc_objset_type, &zc->zc_perm_action); 6406 } 6407 } else { 6408 dsl_dataset_t *old; 6409 error = dsl_dataset_hold(dp, zc->zc_value, FTAG, &old); 6410 6411 if (error == 0) { 6412 error = dsl_dataset_space_written(old, new, 6413 &zc->zc_cookie, 6414 &zc->zc_objset_type, &zc->zc_perm_action); 6415 dsl_dataset_rele(old, FTAG); 6416 } 6417 } 6418 dsl_dataset_rele(new, FTAG); 6419 dsl_pool_rele(dp, FTAG); 6420 return (error); 6421 } 6422 6423 /* 6424 * innvl: { 6425 * "firstsnap" -> snapshot name 6426 * } 6427 * 6428 * outnvl: { 6429 * "used" -> space in bytes 6430 * "compressed" -> compressed space in bytes 6431 * "uncompressed" -> uncompressed space in bytes 6432 * } 6433 */ 6434 static const zfs_ioc_key_t zfs_keys_space_snaps[] = { 6435 {"firstsnap", DATA_TYPE_STRING, 0}, 6436 }; 6437 6438 static int 6439 zfs_ioc_space_snaps(const char *lastsnap, nvlist_t *innvl, nvlist_t *outnvl) 6440 { 6441 int error; 6442 dsl_pool_t *dp; 6443 dsl_dataset_t *new, *old; 6444 char *firstsnap; 6445 uint64_t used, comp, uncomp; 6446 6447 firstsnap = fnvlist_lookup_string(innvl, "firstsnap"); 6448 6449 error = dsl_pool_hold(lastsnap, FTAG, &dp); 6450 if (error != 0) 6451 return (error); 6452 6453 error = dsl_dataset_hold(dp, lastsnap, FTAG, &new); 6454 if (error == 0 && !new->ds_is_snapshot) { 6455 dsl_dataset_rele(new, FTAG); 6456 error = SET_ERROR(EINVAL); 6457 } 6458 if (error != 0) { 6459 dsl_pool_rele(dp, FTAG); 6460 return (error); 6461 } 6462 error = dsl_dataset_hold(dp, firstsnap, FTAG, &old); 6463 if (error == 0 && !old->ds_is_snapshot) { 6464 dsl_dataset_rele(old, FTAG); 6465 error = SET_ERROR(EINVAL); 6466 } 6467 if (error != 0) { 6468 dsl_dataset_rele(new, FTAG); 6469 dsl_pool_rele(dp, FTAG); 6470 return (error); 6471 } 6472 6473 error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp); 6474 dsl_dataset_rele(old, FTAG); 6475 dsl_dataset_rele(new, FTAG); 6476 dsl_pool_rele(dp, FTAG); 6477 fnvlist_add_uint64(outnvl, "used", used); 6478 fnvlist_add_uint64(outnvl, "compressed", comp); 6479 fnvlist_add_uint64(outnvl, "uncompressed", uncomp); 6480 return (error); 6481 } 6482 6483 /* 6484 * innvl: { 6485 * "fd" -> file descriptor to write stream to (int32) 6486 * (optional) "fromsnap" -> full snap name to send an incremental from 6487 * (optional) "largeblockok" -> (value ignored) 6488 * indicates that blocks > 128KB are permitted 6489 * (optional) "embedok" -> (value ignored) 6490 * presence indicates DRR_WRITE_EMBEDDED records are permitted 6491 * (optional) "compressok" -> (value ignored) 6492 * presence indicates compressed DRR_WRITE records are permitted 6493 * (optional) "rawok" -> (value ignored) 6494 * presence indicates raw encrypted records should be used. 6495 * (optional) "savedok" -> (value ignored) 6496 * presence indicates we should send a partially received snapshot 6497 * (optional) "resume_object" and "resume_offset" -> (uint64) 6498 * if present, resume send stream from specified object and offset. 6499 * (optional) "redactbook" -> (string) 6500 * if present, use this bookmark's redaction list to generate a redacted 6501 * send stream 6502 * } 6503 * 6504 * outnvl is unused 6505 */ 6506 static const zfs_ioc_key_t zfs_keys_send_new[] = { 6507 {"fd", DATA_TYPE_INT32, 0}, 6508 {"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL}, 6509 {"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6510 {"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6511 {"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6512 {"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6513 {"savedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6514 {"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6515 {"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6516 {"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL}, 6517 }; 6518 6519 static int 6520 zfs_ioc_send_new(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl) 6521 { 6522 (void) outnvl; 6523 int error; 6524 offset_t off; 6525 char *fromname = NULL; 6526 int fd; 6527 zfs_file_t *fp; 6528 boolean_t largeblockok; 6529 boolean_t embedok; 6530 boolean_t compressok; 6531 boolean_t rawok; 6532 boolean_t savedok; 6533 uint64_t resumeobj = 0; 6534 uint64_t resumeoff = 0; 6535 char *redactbook = NULL; 6536 6537 fd = fnvlist_lookup_int32(innvl, "fd"); 6538 6539 (void) nvlist_lookup_string(innvl, "fromsnap", &fromname); 6540 6541 largeblockok = nvlist_exists(innvl, "largeblockok"); 6542 embedok = nvlist_exists(innvl, "embedok"); 6543 compressok = nvlist_exists(innvl, "compressok"); 6544 rawok = nvlist_exists(innvl, "rawok"); 6545 savedok = nvlist_exists(innvl, "savedok"); 6546 6547 (void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj); 6548 (void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff); 6549 6550 (void) nvlist_lookup_string(innvl, "redactbook", &redactbook); 6551 6552 if ((fp = zfs_file_get(fd)) == NULL) 6553 return (SET_ERROR(EBADF)); 6554 6555 off = zfs_file_off(fp); 6556 6557 dmu_send_outparams_t out = {0}; 6558 out.dso_outfunc = dump_bytes; 6559 out.dso_arg = fp; 6560 out.dso_dryrun = B_FALSE; 6561 error = dmu_send(snapname, fromname, embedok, largeblockok, 6562 compressok, rawok, savedok, resumeobj, resumeoff, 6563 redactbook, fd, &off, &out); 6564 6565 zfs_file_put(fp); 6566 return (error); 6567 } 6568 6569 static int 6570 send_space_sum(objset_t *os, void *buf, int len, void *arg) 6571 { 6572 (void) os, (void) buf; 6573 uint64_t *size = arg; 6574 6575 *size += len; 6576 return (0); 6577 } 6578 6579 /* 6580 * Determine approximately how large a zfs send stream will be -- the number 6581 * of bytes that will be written to the fd supplied to zfs_ioc_send_new(). 6582 * 6583 * innvl: { 6584 * (optional) "from" -> full snap or bookmark name to send an incremental 6585 * from 6586 * (optional) "largeblockok" -> (value ignored) 6587 * indicates that blocks > 128KB are permitted 6588 * (optional) "embedok" -> (value ignored) 6589 * presence indicates DRR_WRITE_EMBEDDED records are permitted 6590 * (optional) "compressok" -> (value ignored) 6591 * presence indicates compressed DRR_WRITE records are permitted 6592 * (optional) "rawok" -> (value ignored) 6593 * presence indicates raw encrypted records should be used. 6594 * (optional) "resume_object" and "resume_offset" -> (uint64) 6595 * if present, resume send stream from specified object and offset. 6596 * (optional) "fd" -> file descriptor to use as a cookie for progress 6597 * tracking (int32) 6598 * } 6599 * 6600 * outnvl: { 6601 * "space" -> bytes of space (uint64) 6602 * } 6603 */ 6604 static const zfs_ioc_key_t zfs_keys_send_space[] = { 6605 {"from", DATA_TYPE_STRING, ZK_OPTIONAL}, 6606 {"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL}, 6607 {"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6608 {"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6609 {"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6610 {"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6611 {"fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 6612 {"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL}, 6613 {"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6614 {"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6615 {"bytes", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6616 }; 6617 6618 static int 6619 zfs_ioc_send_space(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl) 6620 { 6621 dsl_pool_t *dp; 6622 dsl_dataset_t *tosnap; 6623 dsl_dataset_t *fromsnap = NULL; 6624 int error; 6625 char *fromname = NULL; 6626 char *redactlist_book = NULL; 6627 boolean_t largeblockok; 6628 boolean_t embedok; 6629 boolean_t compressok; 6630 boolean_t rawok; 6631 boolean_t savedok; 6632 uint64_t space = 0; 6633 boolean_t full_estimate = B_FALSE; 6634 uint64_t resumeobj = 0; 6635 uint64_t resumeoff = 0; 6636 uint64_t resume_bytes = 0; 6637 int32_t fd = -1; 6638 zfs_bookmark_phys_t zbm = {0}; 6639 6640 error = dsl_pool_hold(snapname, FTAG, &dp); 6641 if (error != 0) 6642 return (error); 6643 6644 error = dsl_dataset_hold(dp, snapname, FTAG, &tosnap); 6645 if (error != 0) { 6646 dsl_pool_rele(dp, FTAG); 6647 return (error); 6648 } 6649 (void) nvlist_lookup_int32(innvl, "fd", &fd); 6650 6651 largeblockok = nvlist_exists(innvl, "largeblockok"); 6652 embedok = nvlist_exists(innvl, "embedok"); 6653 compressok = nvlist_exists(innvl, "compressok"); 6654 rawok = nvlist_exists(innvl, "rawok"); 6655 savedok = nvlist_exists(innvl, "savedok"); 6656 boolean_t from = (nvlist_lookup_string(innvl, "from", &fromname) == 0); 6657 boolean_t altbook = (nvlist_lookup_string(innvl, "redactbook", 6658 &redactlist_book) == 0); 6659 6660 (void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj); 6661 (void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff); 6662 (void) nvlist_lookup_uint64(innvl, "bytes", &resume_bytes); 6663 6664 if (altbook) { 6665 full_estimate = B_TRUE; 6666 } else if (from) { 6667 if (strchr(fromname, '#')) { 6668 error = dsl_bookmark_lookup(dp, fromname, tosnap, &zbm); 6669 6670 /* 6671 * dsl_bookmark_lookup() will fail with EXDEV if 6672 * the from-bookmark and tosnap are at the same txg. 6673 * However, it's valid to do a send (and therefore, 6674 * a send estimate) from and to the same time point, 6675 * if the bookmark is redacted (the incremental send 6676 * can change what's redacted on the target). In 6677 * this case, dsl_bookmark_lookup() fills in zbm 6678 * but returns EXDEV. Ignore this error. 6679 */ 6680 if (error == EXDEV && zbm.zbm_redaction_obj != 0 && 6681 zbm.zbm_guid == 6682 dsl_dataset_phys(tosnap)->ds_guid) 6683 error = 0; 6684 6685 if (error != 0) { 6686 dsl_dataset_rele(tosnap, FTAG); 6687 dsl_pool_rele(dp, FTAG); 6688 return (error); 6689 } 6690 if (zbm.zbm_redaction_obj != 0 || !(zbm.zbm_flags & 6691 ZBM_FLAG_HAS_FBN)) { 6692 full_estimate = B_TRUE; 6693 } 6694 } else if (strchr(fromname, '@')) { 6695 error = dsl_dataset_hold(dp, fromname, FTAG, &fromsnap); 6696 if (error != 0) { 6697 dsl_dataset_rele(tosnap, FTAG); 6698 dsl_pool_rele(dp, FTAG); 6699 return (error); 6700 } 6701 6702 if (!dsl_dataset_is_before(tosnap, fromsnap, 0)) { 6703 full_estimate = B_TRUE; 6704 dsl_dataset_rele(fromsnap, FTAG); 6705 } 6706 } else { 6707 /* 6708 * from is not properly formatted as a snapshot or 6709 * bookmark 6710 */ 6711 dsl_dataset_rele(tosnap, FTAG); 6712 dsl_pool_rele(dp, FTAG); 6713 return (SET_ERROR(EINVAL)); 6714 } 6715 } 6716 6717 if (full_estimate) { 6718 dmu_send_outparams_t out = {0}; 6719 offset_t off = 0; 6720 out.dso_outfunc = send_space_sum; 6721 out.dso_arg = &space; 6722 out.dso_dryrun = B_TRUE; 6723 /* 6724 * We have to release these holds so dmu_send can take them. It 6725 * will do all the error checking we need. 6726 */ 6727 dsl_dataset_rele(tosnap, FTAG); 6728 dsl_pool_rele(dp, FTAG); 6729 error = dmu_send(snapname, fromname, embedok, largeblockok, 6730 compressok, rawok, savedok, resumeobj, resumeoff, 6731 redactlist_book, fd, &off, &out); 6732 } else { 6733 error = dmu_send_estimate_fast(tosnap, fromsnap, 6734 (from && strchr(fromname, '#') != NULL ? &zbm : NULL), 6735 compressok || rawok, savedok, &space); 6736 space -= resume_bytes; 6737 if (fromsnap != NULL) 6738 dsl_dataset_rele(fromsnap, FTAG); 6739 dsl_dataset_rele(tosnap, FTAG); 6740 dsl_pool_rele(dp, FTAG); 6741 } 6742 6743 fnvlist_add_uint64(outnvl, "space", space); 6744 6745 return (error); 6746 } 6747 6748 /* 6749 * Sync the currently open TXG to disk for the specified pool. 6750 * This is somewhat similar to 'zfs_sync()'. 6751 * For cases that do not result in error this ioctl will wait for 6752 * the currently open TXG to commit before returning back to the caller. 6753 * 6754 * innvl: { 6755 * "force" -> when true, force uberblock update even if there is no dirty data. 6756 * In addition this will cause the vdev configuration to be written 6757 * out including updating the zpool cache file. (boolean_t) 6758 * } 6759 * 6760 * onvl is unused 6761 */ 6762 static const zfs_ioc_key_t zfs_keys_pool_sync[] = { 6763 {"force", DATA_TYPE_BOOLEAN_VALUE, 0}, 6764 }; 6765 6766 static int 6767 zfs_ioc_pool_sync(const char *pool, nvlist_t *innvl, nvlist_t *onvl) 6768 { 6769 (void) onvl; 6770 int err; 6771 boolean_t rc, force = B_FALSE; 6772 spa_t *spa; 6773 6774 if ((err = spa_open(pool, &spa, FTAG)) != 0) 6775 return (err); 6776 6777 if (innvl) { 6778 err = nvlist_lookup_boolean_value(innvl, "force", &rc); 6779 if (err == 0) 6780 force = rc; 6781 } 6782 6783 if (force) { 6784 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_WRITER); 6785 vdev_config_dirty(spa->spa_root_vdev); 6786 spa_config_exit(spa, SCL_CONFIG, FTAG); 6787 } 6788 txg_wait_synced(spa_get_dsl(spa), 0); 6789 6790 spa_close(spa, FTAG); 6791 6792 return (0); 6793 } 6794 6795 /* 6796 * Load a user's wrapping key into the kernel. 6797 * innvl: { 6798 * "hidden_args" -> { "wkeydata" -> value } 6799 * raw uint8_t array of encryption wrapping key data (32 bytes) 6800 * (optional) "noop" -> (value ignored) 6801 * presence indicated key should only be verified, not loaded 6802 * } 6803 */ 6804 static const zfs_ioc_key_t zfs_keys_load_key[] = { 6805 {"hidden_args", DATA_TYPE_NVLIST, 0}, 6806 {"noop", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6807 }; 6808 6809 static int 6810 zfs_ioc_load_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6811 { 6812 (void) outnvl; 6813 int ret; 6814 dsl_crypto_params_t *dcp = NULL; 6815 nvlist_t *hidden_args; 6816 boolean_t noop = nvlist_exists(innvl, "noop"); 6817 6818 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6819 ret = SET_ERROR(EINVAL); 6820 goto error; 6821 } 6822 6823 hidden_args = fnvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS); 6824 6825 ret = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL, 6826 hidden_args, &dcp); 6827 if (ret != 0) 6828 goto error; 6829 6830 ret = spa_keystore_load_wkey(dsname, dcp, noop); 6831 if (ret != 0) 6832 goto error; 6833 6834 dsl_crypto_params_free(dcp, noop); 6835 6836 return (0); 6837 6838 error: 6839 dsl_crypto_params_free(dcp, B_TRUE); 6840 return (ret); 6841 } 6842 6843 /* 6844 * Unload a user's wrapping key from the kernel. 6845 * Both innvl and outnvl are unused. 6846 */ 6847 static const zfs_ioc_key_t zfs_keys_unload_key[] = { 6848 /* no nvl keys */ 6849 }; 6850 6851 static int 6852 zfs_ioc_unload_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6853 { 6854 (void) innvl, (void) outnvl; 6855 int ret = 0; 6856 6857 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6858 ret = (SET_ERROR(EINVAL)); 6859 goto out; 6860 } 6861 6862 ret = spa_keystore_unload_wkey(dsname); 6863 if (ret != 0) 6864 goto out; 6865 6866 out: 6867 return (ret); 6868 } 6869 6870 /* 6871 * Changes a user's wrapping key used to decrypt a dataset. The keyformat, 6872 * keylocation, pbkdf2salt, and pbkdf2iters properties can also be specified 6873 * here to change how the key is derived in userspace. 6874 * 6875 * innvl: { 6876 * "hidden_args" (optional) -> { "wkeydata" -> value } 6877 * raw uint8_t array of new encryption wrapping key data (32 bytes) 6878 * "props" (optional) -> { prop -> value } 6879 * } 6880 * 6881 * outnvl is unused 6882 */ 6883 static const zfs_ioc_key_t zfs_keys_change_key[] = { 6884 {"crypt_cmd", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6885 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 6886 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 6887 }; 6888 6889 static int 6890 zfs_ioc_change_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6891 { 6892 (void) outnvl; 6893 int ret; 6894 uint64_t cmd = DCP_CMD_NONE; 6895 dsl_crypto_params_t *dcp = NULL; 6896 nvlist_t *args = NULL, *hidden_args = NULL; 6897 6898 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6899 ret = (SET_ERROR(EINVAL)); 6900 goto error; 6901 } 6902 6903 (void) nvlist_lookup_uint64(innvl, "crypt_cmd", &cmd); 6904 (void) nvlist_lookup_nvlist(innvl, "props", &args); 6905 (void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args); 6906 6907 ret = dsl_crypto_params_create_nvlist(cmd, args, hidden_args, &dcp); 6908 if (ret != 0) 6909 goto error; 6910 6911 ret = spa_keystore_change_key(dsname, dcp); 6912 if (ret != 0) 6913 goto error; 6914 6915 dsl_crypto_params_free(dcp, B_FALSE); 6916 6917 return (0); 6918 6919 error: 6920 dsl_crypto_params_free(dcp, B_TRUE); 6921 return (ret); 6922 } 6923 6924 static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST]; 6925 6926 static void 6927 zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6928 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck, 6929 boolean_t log_history, zfs_ioc_poolcheck_t pool_check) 6930 { 6931 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST]; 6932 6933 ASSERT3U(ioc, >=, ZFS_IOC_FIRST); 6934 ASSERT3U(ioc, <, ZFS_IOC_LAST); 6935 ASSERT3P(vec->zvec_legacy_func, ==, NULL); 6936 ASSERT3P(vec->zvec_func, ==, NULL); 6937 6938 vec->zvec_legacy_func = func; 6939 vec->zvec_secpolicy = secpolicy; 6940 vec->zvec_namecheck = namecheck; 6941 vec->zvec_allow_log = log_history; 6942 vec->zvec_pool_check = pool_check; 6943 } 6944 6945 /* 6946 * See the block comment at the beginning of this file for details on 6947 * each argument to this function. 6948 */ 6949 void 6950 zfs_ioctl_register(const char *name, zfs_ioc_t ioc, zfs_ioc_func_t *func, 6951 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck, 6952 zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist, 6953 boolean_t allow_log, const zfs_ioc_key_t *nvl_keys, size_t num_keys) 6954 { 6955 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST]; 6956 6957 ASSERT3U(ioc, >=, ZFS_IOC_FIRST); 6958 ASSERT3U(ioc, <, ZFS_IOC_LAST); 6959 ASSERT3P(vec->zvec_legacy_func, ==, NULL); 6960 ASSERT3P(vec->zvec_func, ==, NULL); 6961 6962 /* if we are logging, the name must be valid */ 6963 ASSERT(!allow_log || namecheck != NO_NAME); 6964 6965 vec->zvec_name = name; 6966 vec->zvec_func = func; 6967 vec->zvec_secpolicy = secpolicy; 6968 vec->zvec_namecheck = namecheck; 6969 vec->zvec_pool_check = pool_check; 6970 vec->zvec_smush_outnvlist = smush_outnvlist; 6971 vec->zvec_allow_log = allow_log; 6972 vec->zvec_nvl_keys = nvl_keys; 6973 vec->zvec_nvl_key_count = num_keys; 6974 } 6975 6976 static void 6977 zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6978 zfs_secpolicy_func_t *secpolicy, boolean_t log_history, 6979 zfs_ioc_poolcheck_t pool_check) 6980 { 6981 zfs_ioctl_register_legacy(ioc, func, secpolicy, 6982 POOL_NAME, log_history, pool_check); 6983 } 6984 6985 void 6986 zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6987 zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check) 6988 { 6989 zfs_ioctl_register_legacy(ioc, func, secpolicy, 6990 DATASET_NAME, B_FALSE, pool_check); 6991 } 6992 6993 static void 6994 zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func) 6995 { 6996 zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config, 6997 POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 6998 } 6999 7000 static void 7001 zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 7002 zfs_secpolicy_func_t *secpolicy) 7003 { 7004 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7005 NO_NAME, B_FALSE, POOL_CHECK_NONE); 7006 } 7007 7008 static void 7009 zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc, 7010 zfs_ioc_legacy_func_t *func, zfs_secpolicy_func_t *secpolicy) 7011 { 7012 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7013 DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED); 7014 } 7015 7016 static void 7017 zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func) 7018 { 7019 zfs_ioctl_register_dataset_read_secpolicy(ioc, func, 7020 zfs_secpolicy_read); 7021 } 7022 7023 static void 7024 zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 7025 zfs_secpolicy_func_t *secpolicy) 7026 { 7027 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7028 DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7029 } 7030 7031 static void 7032 zfs_ioctl_init(void) 7033 { 7034 zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT, 7035 zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME, 7036 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7037 zfs_keys_snapshot, ARRAY_SIZE(zfs_keys_snapshot)); 7038 7039 zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY, 7040 zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME, 7041 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7042 zfs_keys_log_history, ARRAY_SIZE(zfs_keys_log_history)); 7043 7044 zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS, 7045 zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME, 7046 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7047 zfs_keys_space_snaps, ARRAY_SIZE(zfs_keys_space_snaps)); 7048 7049 zfs_ioctl_register("send", ZFS_IOC_SEND_NEW, 7050 zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME, 7051 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7052 zfs_keys_send_new, ARRAY_SIZE(zfs_keys_send_new)); 7053 7054 zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE, 7055 zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME, 7056 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7057 zfs_keys_send_space, ARRAY_SIZE(zfs_keys_send_space)); 7058 7059 zfs_ioctl_register("create", ZFS_IOC_CREATE, 7060 zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME, 7061 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7062 zfs_keys_create, ARRAY_SIZE(zfs_keys_create)); 7063 7064 zfs_ioctl_register("clone", ZFS_IOC_CLONE, 7065 zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME, 7066 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7067 zfs_keys_clone, ARRAY_SIZE(zfs_keys_clone)); 7068 7069 zfs_ioctl_register("remap", ZFS_IOC_REMAP, 7070 zfs_ioc_remap, zfs_secpolicy_none, DATASET_NAME, 7071 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7072 zfs_keys_remap, ARRAY_SIZE(zfs_keys_remap)); 7073 7074 zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS, 7075 zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME, 7076 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7077 zfs_keys_destroy_snaps, ARRAY_SIZE(zfs_keys_destroy_snaps)); 7078 7079 zfs_ioctl_register("hold", ZFS_IOC_HOLD, 7080 zfs_ioc_hold, zfs_secpolicy_hold, POOL_NAME, 7081 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7082 zfs_keys_hold, ARRAY_SIZE(zfs_keys_hold)); 7083 zfs_ioctl_register("release", ZFS_IOC_RELEASE, 7084 zfs_ioc_release, zfs_secpolicy_release, POOL_NAME, 7085 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7086 zfs_keys_release, ARRAY_SIZE(zfs_keys_release)); 7087 7088 zfs_ioctl_register("get_holds", ZFS_IOC_GET_HOLDS, 7089 zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME, 7090 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7091 zfs_keys_get_holds, ARRAY_SIZE(zfs_keys_get_holds)); 7092 7093 zfs_ioctl_register("rollback", ZFS_IOC_ROLLBACK, 7094 zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME, 7095 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7096 zfs_keys_rollback, ARRAY_SIZE(zfs_keys_rollback)); 7097 7098 zfs_ioctl_register("bookmark", ZFS_IOC_BOOKMARK, 7099 zfs_ioc_bookmark, zfs_secpolicy_bookmark, POOL_NAME, 7100 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7101 zfs_keys_bookmark, ARRAY_SIZE(zfs_keys_bookmark)); 7102 7103 zfs_ioctl_register("get_bookmarks", ZFS_IOC_GET_BOOKMARKS, 7104 zfs_ioc_get_bookmarks, zfs_secpolicy_read, DATASET_NAME, 7105 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7106 zfs_keys_get_bookmarks, ARRAY_SIZE(zfs_keys_get_bookmarks)); 7107 7108 zfs_ioctl_register("get_bookmark_props", ZFS_IOC_GET_BOOKMARK_PROPS, 7109 zfs_ioc_get_bookmark_props, zfs_secpolicy_read, ENTITY_NAME, 7110 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, zfs_keys_get_bookmark_props, 7111 ARRAY_SIZE(zfs_keys_get_bookmark_props)); 7112 7113 zfs_ioctl_register("destroy_bookmarks", ZFS_IOC_DESTROY_BOOKMARKS, 7114 zfs_ioc_destroy_bookmarks, zfs_secpolicy_destroy_bookmarks, 7115 POOL_NAME, 7116 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7117 zfs_keys_destroy_bookmarks, 7118 ARRAY_SIZE(zfs_keys_destroy_bookmarks)); 7119 7120 zfs_ioctl_register("receive", ZFS_IOC_RECV_NEW, 7121 zfs_ioc_recv_new, zfs_secpolicy_recv, DATASET_NAME, 7122 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7123 zfs_keys_recv_new, ARRAY_SIZE(zfs_keys_recv_new)); 7124 zfs_ioctl_register("load-key", ZFS_IOC_LOAD_KEY, 7125 zfs_ioc_load_key, zfs_secpolicy_load_key, 7126 DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE, 7127 zfs_keys_load_key, ARRAY_SIZE(zfs_keys_load_key)); 7128 zfs_ioctl_register("unload-key", ZFS_IOC_UNLOAD_KEY, 7129 zfs_ioc_unload_key, zfs_secpolicy_load_key, 7130 DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE, 7131 zfs_keys_unload_key, ARRAY_SIZE(zfs_keys_unload_key)); 7132 zfs_ioctl_register("change-key", ZFS_IOC_CHANGE_KEY, 7133 zfs_ioc_change_key, zfs_secpolicy_change_key, 7134 DATASET_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, 7135 B_TRUE, B_TRUE, zfs_keys_change_key, 7136 ARRAY_SIZE(zfs_keys_change_key)); 7137 7138 zfs_ioctl_register("sync", ZFS_IOC_POOL_SYNC, 7139 zfs_ioc_pool_sync, zfs_secpolicy_none, POOL_NAME, 7140 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7141 zfs_keys_pool_sync, ARRAY_SIZE(zfs_keys_pool_sync)); 7142 zfs_ioctl_register("reopen", ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen, 7143 zfs_secpolicy_config, POOL_NAME, POOL_CHECK_SUSPENDED, B_TRUE, 7144 B_TRUE, zfs_keys_pool_reopen, ARRAY_SIZE(zfs_keys_pool_reopen)); 7145 7146 zfs_ioctl_register("channel_program", ZFS_IOC_CHANNEL_PROGRAM, 7147 zfs_ioc_channel_program, zfs_secpolicy_config, 7148 POOL_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, 7149 B_TRUE, zfs_keys_channel_program, 7150 ARRAY_SIZE(zfs_keys_channel_program)); 7151 7152 zfs_ioctl_register("redact", ZFS_IOC_REDACT, 7153 zfs_ioc_redact, zfs_secpolicy_config, DATASET_NAME, 7154 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7155 zfs_keys_redact, ARRAY_SIZE(zfs_keys_redact)); 7156 7157 zfs_ioctl_register("zpool_checkpoint", ZFS_IOC_POOL_CHECKPOINT, 7158 zfs_ioc_pool_checkpoint, zfs_secpolicy_config, POOL_NAME, 7159 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7160 zfs_keys_pool_checkpoint, ARRAY_SIZE(zfs_keys_pool_checkpoint)); 7161 7162 zfs_ioctl_register("zpool_discard_checkpoint", 7163 ZFS_IOC_POOL_DISCARD_CHECKPOINT, zfs_ioc_pool_discard_checkpoint, 7164 zfs_secpolicy_config, POOL_NAME, 7165 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7166 zfs_keys_pool_discard_checkpoint, 7167 ARRAY_SIZE(zfs_keys_pool_discard_checkpoint)); 7168 7169 zfs_ioctl_register("initialize", ZFS_IOC_POOL_INITIALIZE, 7170 zfs_ioc_pool_initialize, zfs_secpolicy_config, POOL_NAME, 7171 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7172 zfs_keys_pool_initialize, ARRAY_SIZE(zfs_keys_pool_initialize)); 7173 7174 zfs_ioctl_register("trim", ZFS_IOC_POOL_TRIM, 7175 zfs_ioc_pool_trim, zfs_secpolicy_config, POOL_NAME, 7176 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7177 zfs_keys_pool_trim, ARRAY_SIZE(zfs_keys_pool_trim)); 7178 7179 zfs_ioctl_register("wait", ZFS_IOC_WAIT, 7180 zfs_ioc_wait, zfs_secpolicy_none, POOL_NAME, 7181 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7182 zfs_keys_pool_wait, ARRAY_SIZE(zfs_keys_pool_wait)); 7183 7184 zfs_ioctl_register("wait_fs", ZFS_IOC_WAIT_FS, 7185 zfs_ioc_wait_fs, zfs_secpolicy_none, DATASET_NAME, 7186 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7187 zfs_keys_fs_wait, ARRAY_SIZE(zfs_keys_fs_wait)); 7188 7189 zfs_ioctl_register("set_bootenv", ZFS_IOC_SET_BOOTENV, 7190 zfs_ioc_set_bootenv, zfs_secpolicy_config, POOL_NAME, 7191 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7192 zfs_keys_set_bootenv, ARRAY_SIZE(zfs_keys_set_bootenv)); 7193 7194 zfs_ioctl_register("get_bootenv", ZFS_IOC_GET_BOOTENV, 7195 zfs_ioc_get_bootenv, zfs_secpolicy_none, POOL_NAME, 7196 POOL_CHECK_SUSPENDED, B_FALSE, B_TRUE, 7197 zfs_keys_get_bootenv, ARRAY_SIZE(zfs_keys_get_bootenv)); 7198 7199 zfs_ioctl_register("zpool_vdev_get_props", ZFS_IOC_VDEV_GET_PROPS, 7200 zfs_ioc_vdev_get_props, zfs_secpolicy_read, POOL_NAME, 7201 POOL_CHECK_NONE, B_FALSE, B_FALSE, zfs_keys_vdev_get_props, 7202 ARRAY_SIZE(zfs_keys_vdev_get_props)); 7203 7204 zfs_ioctl_register("zpool_vdev_set_props", ZFS_IOC_VDEV_SET_PROPS, 7205 zfs_ioc_vdev_set_props, zfs_secpolicy_config, POOL_NAME, 7206 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7207 zfs_keys_vdev_set_props, ARRAY_SIZE(zfs_keys_vdev_set_props)); 7208 7209 /* IOCTLS that use the legacy function signature */ 7210 7211 zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze, 7212 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY); 7213 7214 zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create, 7215 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE); 7216 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN, 7217 zfs_ioc_pool_scan); 7218 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE, 7219 zfs_ioc_pool_upgrade); 7220 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD, 7221 zfs_ioc_vdev_add); 7222 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE, 7223 zfs_ioc_vdev_remove); 7224 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE, 7225 zfs_ioc_vdev_set_state); 7226 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH, 7227 zfs_ioc_vdev_attach); 7228 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH, 7229 zfs_ioc_vdev_detach); 7230 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH, 7231 zfs_ioc_vdev_setpath); 7232 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU, 7233 zfs_ioc_vdev_setfru); 7234 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS, 7235 zfs_ioc_pool_set_props); 7236 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT, 7237 zfs_ioc_vdev_split); 7238 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID, 7239 zfs_ioc_pool_reguid); 7240 7241 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS, 7242 zfs_ioc_pool_configs, zfs_secpolicy_none); 7243 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT, 7244 zfs_ioc_pool_tryimport, zfs_secpolicy_config); 7245 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT, 7246 zfs_ioc_inject_fault, zfs_secpolicy_inject); 7247 zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT, 7248 zfs_ioc_clear_fault, zfs_secpolicy_inject); 7249 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT, 7250 zfs_ioc_inject_list_next, zfs_secpolicy_inject); 7251 7252 /* 7253 * pool destroy, and export don't log the history as part of 7254 * zfsdev_ioctl, but rather zfs_ioc_pool_export 7255 * does the logging of those commands. 7256 */ 7257 zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy, 7258 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7259 zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export, 7260 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7261 7262 zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats, 7263 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE); 7264 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props, 7265 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE); 7266 7267 zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log, 7268 zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED); 7269 zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME, 7270 zfs_ioc_dsobj_to_dsname, 7271 zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED); 7272 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY, 7273 zfs_ioc_pool_get_history, 7274 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7275 7276 zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import, 7277 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE); 7278 7279 zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear, 7280 zfs_secpolicy_config, B_TRUE, POOL_CHECK_READONLY); 7281 7282 zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN, 7283 zfs_ioc_space_written); 7284 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS, 7285 zfs_ioc_objset_recvd_props); 7286 zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ, 7287 zfs_ioc_next_obj); 7288 zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL, 7289 zfs_ioc_get_fsacl); 7290 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS, 7291 zfs_ioc_objset_stats); 7292 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS, 7293 zfs_ioc_objset_zplprops); 7294 zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT, 7295 zfs_ioc_dataset_list_next); 7296 zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT, 7297 zfs_ioc_snapshot_list_next); 7298 zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS, 7299 zfs_ioc_send_progress); 7300 7301 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF, 7302 zfs_ioc_diff, zfs_secpolicy_diff); 7303 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS, 7304 zfs_ioc_obj_to_stats, zfs_secpolicy_diff); 7305 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH, 7306 zfs_ioc_obj_to_path, zfs_secpolicy_diff); 7307 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE, 7308 zfs_ioc_userspace_one, zfs_secpolicy_userspace_one); 7309 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY, 7310 zfs_ioc_userspace_many, zfs_secpolicy_userspace_many); 7311 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND, 7312 zfs_ioc_send, zfs_secpolicy_send); 7313 7314 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop, 7315 zfs_secpolicy_none); 7316 zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy, 7317 zfs_secpolicy_destroy); 7318 zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename, 7319 zfs_secpolicy_rename); 7320 zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv, 7321 zfs_secpolicy_recv); 7322 zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote, 7323 zfs_secpolicy_promote); 7324 zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP, 7325 zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop); 7326 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl, 7327 zfs_secpolicy_set_fsacl); 7328 7329 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share, 7330 zfs_secpolicy_share, POOL_CHECK_NONE); 7331 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl, 7332 zfs_secpolicy_smb_acl, POOL_CHECK_NONE); 7333 zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE, 7334 zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade, 7335 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7336 zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT, 7337 zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot, 7338 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7339 7340 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_NEXT, zfs_ioc_events_next, 7341 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7342 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_CLEAR, zfs_ioc_events_clear, 7343 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7344 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_SEEK, zfs_ioc_events_seek, 7345 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7346 7347 zfs_ioctl_init_os(); 7348 } 7349 7350 /* 7351 * Verify that for non-legacy ioctls the input nvlist 7352 * pairs match against the expected input. 7353 * 7354 * Possible errors are: 7355 * ZFS_ERR_IOC_ARG_UNAVAIL An unrecognized nvpair was encountered 7356 * ZFS_ERR_IOC_ARG_REQUIRED A required nvpair is missing 7357 * ZFS_ERR_IOC_ARG_BADTYPE Invalid type for nvpair 7358 */ 7359 static int 7360 zfs_check_input_nvpairs(nvlist_t *innvl, const zfs_ioc_vec_t *vec) 7361 { 7362 const zfs_ioc_key_t *nvl_keys = vec->zvec_nvl_keys; 7363 boolean_t required_keys_found = B_FALSE; 7364 7365 /* 7366 * examine each input pair 7367 */ 7368 for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL); 7369 pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) { 7370 char *name = nvpair_name(pair); 7371 data_type_t type = nvpair_type(pair); 7372 boolean_t identified = B_FALSE; 7373 7374 /* 7375 * check pair against the documented names and type 7376 */ 7377 for (int k = 0; k < vec->zvec_nvl_key_count; k++) { 7378 /* if not a wild card name, check for an exact match */ 7379 if ((nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) == 0 && 7380 strcmp(nvl_keys[k].zkey_name, name) != 0) 7381 continue; 7382 7383 identified = B_TRUE; 7384 7385 if (nvl_keys[k].zkey_type != DATA_TYPE_ANY && 7386 nvl_keys[k].zkey_type != type) { 7387 return (SET_ERROR(ZFS_ERR_IOC_ARG_BADTYPE)); 7388 } 7389 7390 if (nvl_keys[k].zkey_flags & ZK_OPTIONAL) 7391 continue; 7392 7393 required_keys_found = B_TRUE; 7394 break; 7395 } 7396 7397 /* allow an 'optional' key, everything else is invalid */ 7398 if (!identified && 7399 (strcmp(name, "optional") != 0 || 7400 type != DATA_TYPE_NVLIST)) { 7401 return (SET_ERROR(ZFS_ERR_IOC_ARG_UNAVAIL)); 7402 } 7403 } 7404 7405 /* verify that all required keys were found */ 7406 for (int k = 0; k < vec->zvec_nvl_key_count; k++) { 7407 if (nvl_keys[k].zkey_flags & ZK_OPTIONAL) 7408 continue; 7409 7410 if (nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) { 7411 /* at least one non-optional key is expected here */ 7412 if (!required_keys_found) 7413 return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED)); 7414 continue; 7415 } 7416 7417 if (!nvlist_exists(innvl, nvl_keys[k].zkey_name)) 7418 return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED)); 7419 } 7420 7421 return (0); 7422 } 7423 7424 static int 7425 pool_status_check(const char *name, zfs_ioc_namecheck_t type, 7426 zfs_ioc_poolcheck_t check) 7427 { 7428 spa_t *spa; 7429 int error; 7430 7431 ASSERT(type == POOL_NAME || type == DATASET_NAME || 7432 type == ENTITY_NAME); 7433 7434 if (check & POOL_CHECK_NONE) 7435 return (0); 7436 7437 error = spa_open(name, &spa, FTAG); 7438 if (error == 0) { 7439 if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa)) 7440 error = SET_ERROR(EAGAIN); 7441 else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa)) 7442 error = SET_ERROR(EROFS); 7443 spa_close(spa, FTAG); 7444 } 7445 return (error); 7446 } 7447 7448 int 7449 zfsdev_getminor(zfs_file_t *fp, minor_t *minorp) 7450 { 7451 zfsdev_state_t *zs, *fpd; 7452 7453 ASSERT(!MUTEX_HELD(&zfsdev_state_lock)); 7454 7455 fpd = zfs_file_private(fp); 7456 if (fpd == NULL) 7457 return (SET_ERROR(EBADF)); 7458 7459 mutex_enter(&zfsdev_state_lock); 7460 7461 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7462 7463 if (zs->zs_minor == -1) 7464 continue; 7465 7466 if (fpd == zs) { 7467 *minorp = fpd->zs_minor; 7468 mutex_exit(&zfsdev_state_lock); 7469 return (0); 7470 } 7471 } 7472 7473 mutex_exit(&zfsdev_state_lock); 7474 7475 return (SET_ERROR(EBADF)); 7476 } 7477 7478 void * 7479 zfsdev_get_state(minor_t minor, enum zfsdev_state_type which) 7480 { 7481 zfsdev_state_t *zs; 7482 7483 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7484 if (zs->zs_minor == minor) { 7485 smp_rmb(); 7486 switch (which) { 7487 case ZST_ONEXIT: 7488 return (zs->zs_onexit); 7489 case ZST_ZEVENT: 7490 return (zs->zs_zevent); 7491 case ZST_ALL: 7492 return (zs); 7493 } 7494 } 7495 } 7496 7497 return (NULL); 7498 } 7499 7500 /* 7501 * Find a free minor number. The zfsdev_state_list is expected to 7502 * be short since it is only a list of currently open file handles. 7503 */ 7504 static minor_t 7505 zfsdev_minor_alloc(void) 7506 { 7507 static minor_t last_minor = 0; 7508 minor_t m; 7509 7510 ASSERT(MUTEX_HELD(&zfsdev_state_lock)); 7511 7512 for (m = last_minor + 1; m != last_minor; m++) { 7513 if (m > ZFSDEV_MAX_MINOR) 7514 m = 1; 7515 if (zfsdev_get_state(m, ZST_ALL) == NULL) { 7516 last_minor = m; 7517 return (m); 7518 } 7519 } 7520 7521 return (0); 7522 } 7523 7524 int 7525 zfsdev_state_init(void *priv) 7526 { 7527 zfsdev_state_t *zs, *zsprev = NULL; 7528 minor_t minor; 7529 boolean_t newzs = B_FALSE; 7530 7531 ASSERT(MUTEX_HELD(&zfsdev_state_lock)); 7532 7533 minor = zfsdev_minor_alloc(); 7534 if (minor == 0) 7535 return (SET_ERROR(ENXIO)); 7536 7537 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7538 if (zs->zs_minor == -1) 7539 break; 7540 zsprev = zs; 7541 } 7542 7543 if (!zs) { 7544 zs = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP); 7545 newzs = B_TRUE; 7546 } 7547 7548 zfsdev_private_set_state(priv, zs); 7549 7550 zfs_onexit_init((zfs_onexit_t **)&zs->zs_onexit); 7551 zfs_zevent_init((zfs_zevent_t **)&zs->zs_zevent); 7552 7553 /* 7554 * In order to provide for lock-free concurrent read access 7555 * to the minor list in zfsdev_get_state(), new entries 7556 * must be completely written before linking them into the 7557 * list whereas existing entries are already linked; the last 7558 * operation must be updating zs_minor (from -1 to the new 7559 * value). 7560 */ 7561 if (newzs) { 7562 zs->zs_minor = minor; 7563 membar_producer(); 7564 zsprev->zs_next = zs; 7565 } else { 7566 membar_producer(); 7567 zs->zs_minor = minor; 7568 } 7569 7570 return (0); 7571 } 7572 7573 void 7574 zfsdev_state_destroy(void *priv) 7575 { 7576 zfsdev_state_t *zs = zfsdev_private_get_state(priv); 7577 7578 ASSERT(zs != NULL); 7579 ASSERT3S(zs->zs_minor, >, 0); 7580 7581 /* 7582 * The last reference to this zfsdev file descriptor is being dropped. 7583 * We don't have to worry about lookup grabbing this state object, and 7584 * zfsdev_state_init() will not try to reuse this object until it is 7585 * invalidated by setting zs_minor to -1. Invalidation must be done 7586 * last, with a memory barrier to ensure ordering. This lets us avoid 7587 * taking the global zfsdev state lock around destruction. 7588 */ 7589 zfs_onexit_destroy(zs->zs_onexit); 7590 zfs_zevent_destroy(zs->zs_zevent); 7591 zs->zs_onexit = NULL; 7592 zs->zs_zevent = NULL; 7593 membar_producer(); 7594 zs->zs_minor = -1; 7595 } 7596 7597 long 7598 zfsdev_ioctl_common(uint_t vecnum, zfs_cmd_t *zc, int flag) 7599 { 7600 int error, cmd; 7601 const zfs_ioc_vec_t *vec; 7602 char *saved_poolname = NULL; 7603 uint64_t max_nvlist_src_size; 7604 size_t saved_poolname_len = 0; 7605 nvlist_t *innvl = NULL; 7606 fstrans_cookie_t cookie; 7607 hrtime_t start_time = gethrtime(); 7608 7609 cmd = vecnum; 7610 error = 0; 7611 if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0])) 7612 return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL)); 7613 7614 vec = &zfs_ioc_vec[vecnum]; 7615 7616 /* 7617 * The registered ioctl list may be sparse, verify that either 7618 * a normal or legacy handler are registered. 7619 */ 7620 if (vec->zvec_func == NULL && vec->zvec_legacy_func == NULL) 7621 return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL)); 7622 7623 zc->zc_iflags = flag & FKIOCTL; 7624 max_nvlist_src_size = zfs_max_nvlist_src_size_os(); 7625 if (zc->zc_nvlist_src_size > max_nvlist_src_size) { 7626 /* 7627 * Make sure the user doesn't pass in an insane value for 7628 * zc_nvlist_src_size. We have to check, since we will end 7629 * up allocating that much memory inside of get_nvlist(). This 7630 * prevents a nefarious user from allocating tons of kernel 7631 * memory. 7632 * 7633 * Also, we return EINVAL instead of ENOMEM here. The reason 7634 * being that returning ENOMEM from an ioctl() has a special 7635 * connotation; that the user's size value is too small and 7636 * needs to be expanded to hold the nvlist. See 7637 * zcmd_expand_dst_nvlist() for details. 7638 */ 7639 error = SET_ERROR(EINVAL); /* User's size too big */ 7640 7641 } else if (zc->zc_nvlist_src_size != 0) { 7642 error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 7643 zc->zc_iflags, &innvl); 7644 if (error != 0) 7645 goto out; 7646 } 7647 7648 /* 7649 * Ensure that all pool/dataset names are valid before we pass down to 7650 * the lower layers. 7651 */ 7652 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0'; 7653 switch (vec->zvec_namecheck) { 7654 case POOL_NAME: 7655 if (pool_namecheck(zc->zc_name, NULL, NULL) != 0) 7656 error = SET_ERROR(EINVAL); 7657 else 7658 error = pool_status_check(zc->zc_name, 7659 vec->zvec_namecheck, vec->zvec_pool_check); 7660 break; 7661 7662 case DATASET_NAME: 7663 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0) 7664 error = SET_ERROR(EINVAL); 7665 else 7666 error = pool_status_check(zc->zc_name, 7667 vec->zvec_namecheck, vec->zvec_pool_check); 7668 break; 7669 7670 case ENTITY_NAME: 7671 if (entity_namecheck(zc->zc_name, NULL, NULL) != 0) { 7672 error = SET_ERROR(EINVAL); 7673 } else { 7674 error = pool_status_check(zc->zc_name, 7675 vec->zvec_namecheck, vec->zvec_pool_check); 7676 } 7677 break; 7678 7679 case NO_NAME: 7680 break; 7681 } 7682 /* 7683 * Ensure that all input pairs are valid before we pass them down 7684 * to the lower layers. 7685 * 7686 * The vectored functions can use fnvlist_lookup_{type} for any 7687 * required pairs since zfs_check_input_nvpairs() confirmed that 7688 * they exist and are of the correct type. 7689 */ 7690 if (error == 0 && vec->zvec_func != NULL) { 7691 error = zfs_check_input_nvpairs(innvl, vec); 7692 if (error != 0) 7693 goto out; 7694 } 7695 7696 if (error == 0) { 7697 cookie = spl_fstrans_mark(); 7698 error = vec->zvec_secpolicy(zc, innvl, CRED()); 7699 spl_fstrans_unmark(cookie); 7700 } 7701 7702 if (error != 0) 7703 goto out; 7704 7705 /* legacy ioctls can modify zc_name */ 7706 /* 7707 * Can't use kmem_strdup() as we might truncate the string and 7708 * kmem_strfree() would then free with incorrect size. 7709 */ 7710 saved_poolname_len = strlen(zc->zc_name) + 1; 7711 saved_poolname = kmem_alloc(saved_poolname_len, KM_SLEEP); 7712 7713 strlcpy(saved_poolname, zc->zc_name, saved_poolname_len); 7714 saved_poolname[strcspn(saved_poolname, "/@#")] = '\0'; 7715 7716 if (vec->zvec_func != NULL) { 7717 nvlist_t *outnvl; 7718 int puterror = 0; 7719 spa_t *spa; 7720 nvlist_t *lognv = NULL; 7721 7722 ASSERT(vec->zvec_legacy_func == NULL); 7723 7724 /* 7725 * Add the innvl to the lognv before calling the func, 7726 * in case the func changes the innvl. 7727 */ 7728 if (vec->zvec_allow_log) { 7729 lognv = fnvlist_alloc(); 7730 fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL, 7731 vec->zvec_name); 7732 if (!nvlist_empty(innvl)) { 7733 fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL, 7734 innvl); 7735 } 7736 } 7737 7738 outnvl = fnvlist_alloc(); 7739 cookie = spl_fstrans_mark(); 7740 error = vec->zvec_func(zc->zc_name, innvl, outnvl); 7741 spl_fstrans_unmark(cookie); 7742 7743 /* 7744 * Some commands can partially execute, modify state, and still 7745 * return an error. In these cases, attempt to record what 7746 * was modified. 7747 */ 7748 if ((error == 0 || 7749 (cmd == ZFS_IOC_CHANNEL_PROGRAM && error != EINVAL)) && 7750 vec->zvec_allow_log && 7751 spa_open(zc->zc_name, &spa, FTAG) == 0) { 7752 if (!nvlist_empty(outnvl)) { 7753 size_t out_size = fnvlist_size(outnvl); 7754 if (out_size > zfs_history_output_max) { 7755 fnvlist_add_int64(lognv, 7756 ZPOOL_HIST_OUTPUT_SIZE, out_size); 7757 } else { 7758 fnvlist_add_nvlist(lognv, 7759 ZPOOL_HIST_OUTPUT_NVL, outnvl); 7760 } 7761 } 7762 if (error != 0) { 7763 fnvlist_add_int64(lognv, ZPOOL_HIST_ERRNO, 7764 error); 7765 } 7766 fnvlist_add_int64(lognv, ZPOOL_HIST_ELAPSED_NS, 7767 gethrtime() - start_time); 7768 (void) spa_history_log_nvl(spa, lognv); 7769 spa_close(spa, FTAG); 7770 } 7771 fnvlist_free(lognv); 7772 7773 if (!nvlist_empty(outnvl) || zc->zc_nvlist_dst_size != 0) { 7774 int smusherror = 0; 7775 if (vec->zvec_smush_outnvlist) { 7776 smusherror = nvlist_smush(outnvl, 7777 zc->zc_nvlist_dst_size); 7778 } 7779 if (smusherror == 0) 7780 puterror = put_nvlist(zc, outnvl); 7781 } 7782 7783 if (puterror != 0) 7784 error = puterror; 7785 7786 nvlist_free(outnvl); 7787 } else { 7788 cookie = spl_fstrans_mark(); 7789 error = vec->zvec_legacy_func(zc); 7790 spl_fstrans_unmark(cookie); 7791 } 7792 7793 out: 7794 nvlist_free(innvl); 7795 if (error == 0 && vec->zvec_allow_log) { 7796 char *s = tsd_get(zfs_allow_log_key); 7797 if (s != NULL) 7798 kmem_strfree(s); 7799 (void) tsd_set(zfs_allow_log_key, kmem_strdup(saved_poolname)); 7800 } 7801 if (saved_poolname != NULL) 7802 kmem_free(saved_poolname, saved_poolname_len); 7803 7804 return (error); 7805 } 7806 7807 int 7808 zfs_kmod_init(void) 7809 { 7810 int error; 7811 7812 if ((error = zvol_init()) != 0) 7813 return (error); 7814 7815 spa_init(SPA_MODE_READ | SPA_MODE_WRITE); 7816 zfs_init(); 7817 7818 zfs_ioctl_init(); 7819 7820 mutex_init(&zfsdev_state_lock, NULL, MUTEX_DEFAULT, NULL); 7821 zfsdev_state_list = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP); 7822 zfsdev_state_list->zs_minor = -1; 7823 7824 if ((error = zfsdev_attach()) != 0) 7825 goto out; 7826 7827 tsd_create(&zfs_fsyncer_key, NULL); 7828 tsd_create(&rrw_tsd_key, rrw_tsd_destroy); 7829 tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy); 7830 7831 return (0); 7832 out: 7833 zfs_fini(); 7834 spa_fini(); 7835 zvol_fini(); 7836 7837 return (error); 7838 } 7839 7840 void 7841 zfs_kmod_fini(void) 7842 { 7843 zfsdev_state_t *zs, *zsnext = NULL; 7844 7845 zfsdev_detach(); 7846 7847 mutex_destroy(&zfsdev_state_lock); 7848 7849 for (zs = zfsdev_state_list; zs != NULL; zs = zsnext) { 7850 zsnext = zs->zs_next; 7851 if (zs->zs_onexit) 7852 zfs_onexit_destroy(zs->zs_onexit); 7853 if (zs->zs_zevent) 7854 zfs_zevent_destroy(zs->zs_zevent); 7855 kmem_free(zs, sizeof (zfsdev_state_t)); 7856 } 7857 7858 zfs_ereport_taskq_fini(); /* run before zfs_fini() on Linux */ 7859 zfs_fini(); 7860 spa_fini(); 7861 zvol_fini(); 7862 7863 tsd_destroy(&zfs_fsyncer_key); 7864 tsd_destroy(&rrw_tsd_key); 7865 tsd_destroy(&zfs_allow_log_key); 7866 } 7867 7868 ZFS_MODULE_PARAM(zfs, zfs_, max_nvlist_src_size, ULONG, ZMOD_RW, 7869 "Maximum size in bytes allowed for src nvlist passed with ZFS ioctls"); 7870 7871 ZFS_MODULE_PARAM(zfs, zfs_, history_output_max, ULONG, ZMOD_RW, 7872 "Maximum size in bytes of ZFS ioctl output that will be logged"); 7873