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