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