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