module/zfs/zfs_ioctl.c

   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  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #include <sys/types.h>
  26 #include <sys/param.h>
  27 #include <sys/errno.h>
  28 #include <sys/uio.h>
  29 #include <sys/buf.h>
  30 #include <sys/modctl.h>
  31 #include <sys/open.h>
  32 #include <sys/file.h>
  33 #include <sys/kmem.h>
  34 #include <sys/conf.h>
  35 #include <sys/cmn_err.h>
  36 #include <sys/stat.h>
  37 #include <sys/zfs_ioctl.h>
  38 #include <sys/zfs_vfsops.h>
  39 #include <sys/zfs_znode.h>
  40 #include <sys/zap.h>
  41 #include <sys/spa.h>
  42 #include <sys/spa_impl.h>
  43 #include <sys/vdev.h>
  44 #include <sys/priv_impl.h>
  45 #include <sys/dmu.h>
  46 #include <sys/dsl_dir.h>
  47 #include <sys/dsl_dataset.h>
  48 #include <sys/dsl_prop.h>
  49 #include <sys/dsl_deleg.h>
  50 #include <sys/dmu_objset.h>
  51 #include <sys/ddi.h>
  52 #include <sys/sunddi.h>
  53 #include <sys/sunldi.h>
  54 #include <sys/policy.h>
  55 #include <sys/zone.h>
  56 #include <sys/nvpair.h>
  57 #include <sys/pathname.h>
  58 #include <sys/mount.h>
  59 #include <sys/sdt.h>
  60 #include <sys/fs/zfs.h>
  61 #include <sys/zfs_ctldir.h>
  62 #include <sys/zfs_dir.h>
  63 #include <sys/zfs_onexit.h>
  64 #include <sys/zvol.h>
  65 #include <sys/dsl_scan.h>
  66 #include <sharefs/share.h>
  67 #include <sys/dmu_objset.h>
  68
  69 #include "zfs_namecheck.h"
  70 #include "zfs_prop.h"
  71 #include "zfs_deleg.h"
  72 #include "zfs_comutil.h"
  73
  74 extern struct modlfs zfs_modlfs;
  75
  76 extern void zfs_init(void);
  77 extern void zfs_fini(void);
  78
  79 ldi_ident_t zfs_li = NULL;
  80 dev_info_t *zfs_dip;
  81
  82 typedef int zfs_ioc_func_t(zfs_cmd_t *);
  83 typedef int zfs_secpolicy_func_t(zfs_cmd_t *, cred_t *);
  84
  85 typedef enum {
  86         NO_NAME,
  87         POOL_NAME,
  88         DATASET_NAME
  89 } zfs_ioc_namecheck_t;
  90
  91 typedef enum {
  92         POOL_CHECK_NONE         = 1 << 0,
  93         POOL_CHECK_SUSPENDED    = 1 << 1,
  94         POOL_CHECK_READONLY     = 1 << 2
  95 } zfs_ioc_poolcheck_t;
  96
  97 typedef struct zfs_ioc_vec {
  98         zfs_ioc_func_t          *zvec_func;
  99         zfs_secpolicy_func_t    *zvec_secpolicy;
 100         zfs_ioc_namecheck_t     zvec_namecheck;
 101         boolean_t               zvec_his_log;
 102         zfs_ioc_poolcheck_t     zvec_pool_check;
 103 } zfs_ioc_vec_t;
 104
 105 /* This array is indexed by zfs_userquota_prop_t */
 106 static const char *userquota_perms[] = {
 107         ZFS_DELEG_PERM_USERUSED,
 108         ZFS_DELEG_PERM_USERQUOTA,
 109         ZFS_DELEG_PERM_GROUPUSED,
 110         ZFS_DELEG_PERM_GROUPQUOTA,
 111 };
 112
 113 static int zfs_ioc_userspace_upgrade(zfs_cmd_t *zc);
 114 static int zfs_check_settable(const char *name, nvpair_t *property,
 115     cred_t *cr);
 116 static int zfs_check_clearable(char *dataset, nvlist_t *props,
 117     nvlist_t **errors);
 118 static int zfs_fill_zplprops_root(uint64_t, nvlist_t *, nvlist_t *,
 119     boolean_t *);
 120 int zfs_set_prop_nvlist(const char *, zprop_source_t, nvlist_t *, nvlist_t **);
 121
 122 /* _NOTE(PRINTFLIKE(4)) - this is printf-like, but lint is too whiney */
 123 void
 124 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
 125 {
 126         const char *newfile;
 127         char buf[512];
 128         va_list adx;
 129
 130         /*
 131          * Get rid of annoying "../common/" prefix to filename.
 132          */
 133         newfile = strrchr(file, '/');
 134         if (newfile != NULL) {
 135                 newfile = newfile + 1; /* Get rid of leading / */
 136         } else {
 137                 newfile = file;
 138         }
 139
 140         va_start(adx, fmt);
 141         (void) vsnprintf(buf, sizeof (buf), fmt, adx);
 142         va_end(adx);
 143
 144         /*
 145          * To get this data, use the zfs-dprintf probe as so:
 146          * dtrace -q -n 'zfs-dprintf \
 147          *      /stringof(arg0) == "dbuf.c"/ \
 148          *      {printf("%s: %s", stringof(arg1), stringof(arg3))}'
 149          * arg0 = file name
 150          * arg1 = function name
 151          * arg2 = line number
 152          * arg3 = message
 153          */
 154         DTRACE_PROBE4(zfs__dprintf,
 155             char *, newfile, char *, func, int, line, char *, buf);
 156 }
 157
 158 static void
 159 history_str_free(char *buf)
 160 {
 161         kmem_free(buf, HIS_MAX_RECORD_LEN);
 162 }
 163
 164 static char *
 165 history_str_get(zfs_cmd_t *zc)
 166 {
 167         char *buf;
 168
 169         if (zc->zc_history == 0)
 170                 return (NULL);
 171
 172         buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP);
 173         if (copyinstr((void *)(uintptr_t)zc->zc_history,
 174             buf, HIS_MAX_RECORD_LEN, NULL) != 0) {
 175                 history_str_free(buf);
 176                 return (NULL);
 177         }
 178
 179         buf[HIS_MAX_RECORD_LEN -1] = '\0';
 180
 181         return (buf);
 182 }
 183
 184 /*
 185  * Check to see if the named dataset is currently defined as bootable
 186  */
 187 static boolean_t
 188 zfs_is_bootfs(const char *name)
 189 {
 190         objset_t *os;
 191
 192         if (dmu_objset_hold(name, FTAG, &os) == 0) {
 193                 boolean_t ret;
 194                 ret = (dmu_objset_id(os) == spa_bootfs(dmu_objset_spa(os)));
 195                 dmu_objset_rele(os, FTAG);
 196                 return (ret);
 197         }
 198         return (B_FALSE);
 199 }
 200
 201 /*
 202  * zfs_earlier_version
 203  *
 204  *      Return non-zero if the spa version is less than requested version.
 205  */
 206 static int
 207 zfs_earlier_version(const char *name, int version)
 208 {
 209         spa_t *spa;
 210
 211         if (spa_open(name, &spa, FTAG) == 0) {
 212                 if (spa_version(spa) < version) {
 213                         spa_close(spa, FTAG);
 214                         return (1);
 215                 }
 216                 spa_close(spa, FTAG);
 217         }
 218         return (0);
 219 }
 220
 221 /*
 222  * zpl_earlier_version
 223  *
 224  * Return TRUE if the ZPL version is less than requested version.
 225  */
 226 static boolean_t
 227 zpl_earlier_version(const char *name, int version)
 228 {
 229         objset_t *os;
 230         boolean_t rc = B_TRUE;
 231
 232         if (dmu_objset_hold(name, FTAG, &os) == 0) {
 233                 uint64_t zplversion;
 234
 235                 if (dmu_objset_type(os) != DMU_OST_ZFS) {
 236                         dmu_objset_rele(os, FTAG);
 237                         return (B_TRUE);
 238                 }
 239                 /* XXX reading from non-owned objset */
 240                 if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0)
 241                         rc = zplversion < version;
 242                 dmu_objset_rele(os, FTAG);
 243         }
 244         return (rc);
 245 }
 246
 247 static void
 248 zfs_log_history(zfs_cmd_t *zc)
 249 {
 250         spa_t *spa;
 251         char *buf;
 252
 253         if ((buf = history_str_get(zc)) == NULL)
 254                 return;
 255
 256         if (spa_open(zc->zc_name, &spa, FTAG) == 0) {
 257                 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY)
 258                         (void) spa_history_log(spa, buf, LOG_CMD_NORMAL);
 259                 spa_close(spa, FTAG);
 260         }
 261         history_str_free(buf);
 262 }
 263
 264 /*
 265  * Policy for top-level read operations (list pools).  Requires no privileges,
 266  * and can be used in the local zone, as there is no associated dataset.
 267  */
 268 /* ARGSUSED */
 269 static int
 270 zfs_secpolicy_none(zfs_cmd_t *zc, cred_t *cr)
 271 {
 272         return (0);
 273 }
 274
 275 /*
 276  * Policy for dataset read operations (list children, get statistics).  Requires
 277  * no privileges, but must be visible in the local zone.
 278  */
 279 /* ARGSUSED */
 280 static int
 281 zfs_secpolicy_read(zfs_cmd_t *zc, cred_t *cr)
 282 {
 283         if (INGLOBALZONE(curproc) ||
 284             zone_dataset_visible(zc->zc_name, NULL))
 285                 return (0);
 286
 287         return (ENOENT);
 288 }
 289
 290 static int
 291 zfs_dozonecheck_impl(const char *dataset, uint64_t zoned, cred_t *cr)
 292 {
 293         int writable = 1;
 294
 295         /*
 296          * The dataset must be visible by this zone -- check this first
 297          * so they don't see EPERM on something they shouldn't know about.
 298          */
 299         if (!INGLOBALZONE(curproc) &&
 300             !zone_dataset_visible(dataset, &writable))
 301                 return (ENOENT);
 302
 303         if (INGLOBALZONE(curproc)) {
 304                 /*
 305                  * If the fs is zoned, only root can access it from the
 306                  * global zone.
 307                  */
 308                 if (secpolicy_zfs(cr) && zoned)
 309                         return (EPERM);
 310         } else {
 311                 /*
 312                  * If we are in a local zone, the 'zoned' property must be set.
 313                  */
 314                 if (!zoned)
 315                         return (EPERM);
 316
 317                 /* must be writable by this zone */
 318                 if (!writable)
 319                         return (EPERM);
 320         }
 321         return (0);
 322 }
 323
 324 static int
 325 zfs_dozonecheck(const char *dataset, cred_t *cr)
 326 {
 327         uint64_t zoned;
 328
 329         if (dsl_prop_get_integer(dataset, "zoned", &zoned, NULL))
 330                 return (ENOENT);
 331
 332         return (zfs_dozonecheck_impl(dataset, zoned, cr));
 333 }
 334
 335 static int
 336 zfs_dozonecheck_ds(const char *dataset, dsl_dataset_t *ds, cred_t *cr)
 337 {
 338         uint64_t zoned;
 339
 340         rw_enter(&ds->ds_dir->dd_pool->dp_config_rwlock, RW_READER);
 341         if (dsl_prop_get_ds(ds, "zoned", 8, 1, &zoned, NULL)) {
 342                 rw_exit(&ds->ds_dir->dd_pool->dp_config_rwlock);
 343                 return (ENOENT);
 344         }
 345         rw_exit(&ds->ds_dir->dd_pool->dp_config_rwlock);
 346
 347         return (zfs_dozonecheck_impl(dataset, zoned, cr));
 348 }
 349
 350 int
 351 zfs_secpolicy_write_perms(const char *name, const char *perm, cred_t *cr)
 352 {
 353         int error;
 354
 355         error = zfs_dozonecheck(name, cr);
 356         if (error == 0) {
 357                 error = secpolicy_zfs(cr);
 358                 if (error)
 359                         error = dsl_deleg_access(name, perm, cr);
 360         }
 361         return (error);
 362 }
 363
 364 int
 365 zfs_secpolicy_write_perms_ds(const char *name, dsl_dataset_t *ds,
 366     const char *perm, cred_t *cr)
 367 {
 368         int error;
 369
 370         error = zfs_dozonecheck_ds(name, ds, cr);
 371         if (error == 0) {
 372                 error = secpolicy_zfs(cr);
 373                 if (error)
 374                         error = dsl_deleg_access_impl(ds, perm, cr);
 375         }
 376         return (error);
 377 }
 378
 379 /*
 380  * Policy for setting the security label property.
 381  *
 382  * Returns 0 for success, non-zero for access and other errors.
 383  */
 384 static int
 385 zfs_set_slabel_policy(const char *name, char *strval, cred_t *cr)
 386 {
 387         char            ds_hexsl[MAXNAMELEN];
 388         bslabel_t       ds_sl, new_sl;
 389         boolean_t       new_default = FALSE;
 390         uint64_t        zoned;
 391         int             needed_priv = -1;
 392         int             error;
 393
 394         /* First get the existing dataset label. */
 395         error = dsl_prop_get(name, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
 396             1, sizeof (ds_hexsl), &ds_hexsl, NULL);
 397         if (error)
 398                 return (EPERM);
 399
 400         if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
 401                 new_default = TRUE;
 402
 403         /* The label must be translatable */
 404         if (!new_default && (hexstr_to_label(strval, &new_sl) != 0))
 405                 return (EINVAL);
 406
 407         /*
 408          * In a non-global zone, disallow attempts to set a label that
 409          * doesn't match that of the zone; otherwise no other checks
 410          * are needed.
 411          */
 412         if (!INGLOBALZONE(curproc)) {
 413                 if (new_default || !blequal(&new_sl, CR_SL(CRED())))
 414                         return (EPERM);
 415                 return (0);
 416         }
 417
 418         /*
 419          * For global-zone datasets (i.e., those whose zoned property is
 420          * "off", verify that the specified new label is valid for the
 421          * global zone.
 422          */
 423         if (dsl_prop_get_integer(name,
 424             zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
 425                 return (EPERM);
 426         if (!zoned) {
 427                 if (zfs_check_global_label(name, strval) != 0)
 428                         return (EPERM);
 429         }
 430
 431         /*
 432          * If the existing dataset label is nondefault, check if the
 433          * dataset is mounted (label cannot be changed while mounted).
 434          * Get the zfsvfs; if there isn't one, then the dataset isn't
 435          * mounted (or isn't a dataset, doesn't exist, ...).
 436          */
 437         if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) != 0) {
 438                 objset_t *os;
 439                 static char *setsl_tag = "setsl_tag";
 440
 441                 /*
 442                  * Try to own the dataset; abort if there is any error,
 443                  * (e.g., already mounted, in use, or other error).
 444                  */
 445                 error = dmu_objset_own(name, DMU_OST_ZFS, B_TRUE,
 446                     setsl_tag, &os);
 447                 if (error)
 448                         return (EPERM);
 449
 450                 dmu_objset_disown(os, setsl_tag);
 451
 452                 if (new_default) {
 453                         needed_priv = PRIV_FILE_DOWNGRADE_SL;
 454                         goto out_check;
 455                 }
 456
 457                 if (hexstr_to_label(strval, &new_sl) != 0)
 458                         return (EPERM);
 459
 460                 if (blstrictdom(&ds_sl, &new_sl))
 461                         needed_priv = PRIV_FILE_DOWNGRADE_SL;
 462                 else if (blstrictdom(&new_sl, &ds_sl))
 463                         needed_priv = PRIV_FILE_UPGRADE_SL;
 464         } else {
 465                 /* dataset currently has a default label */
 466                 if (!new_default)
 467                         needed_priv = PRIV_FILE_UPGRADE_SL;
 468         }
 469
 470 out_check:
 471         if (needed_priv != -1)
 472                 return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL));
 473         return (0);
 474 }
 475
 476 static int
 477 zfs_secpolicy_setprop(const char *dsname, zfs_prop_t prop, nvpair_t *propval,
 478     cred_t *cr)
 479 {
 480         char *strval;
 481
 482         /*
 483          * Check permissions for special properties.
 484          */
 485         switch (prop) {
 486         case ZFS_PROP_ZONED:
 487                 /*
 488                  * Disallow setting of 'zoned' from within a local zone.
 489                  */
 490                 if (!INGLOBALZONE(curproc))
 491                         return (EPERM);
 492                 break;
 493
 494         case ZFS_PROP_QUOTA:
 495                 if (!INGLOBALZONE(curproc)) {
 496                         uint64_t zoned;
 497                         char setpoint[MAXNAMELEN];
 498                         /*
 499                          * Unprivileged users are allowed to modify the
 500                          * quota on things *under* (ie. contained by)
 501                          * the thing they own.
 502                          */
 503                         if (dsl_prop_get_integer(dsname, "zoned", &zoned,
 504                             setpoint))
 505                                 return (EPERM);
 506                         if (!zoned || strlen(dsname) <= strlen(setpoint))
 507                                 return (EPERM);
 508                 }
 509                 break;
 510
 511         case ZFS_PROP_MLSLABEL:
 512                 if (!is_system_labeled())
 513                         return (EPERM);
 514
 515                 if (nvpair_value_string(propval, &strval) == 0) {
 516                         int err;
 517
 518                         err = zfs_set_slabel_policy(dsname, strval, CRED());
 519                         if (err != 0)
 520                                 return (err);
 521                 }
 522                 break;
 523         }
 524
 525         return (zfs_secpolicy_write_perms(dsname, zfs_prop_to_name(prop), cr));
 526 }
 527
 528 int
 529 zfs_secpolicy_fsacl(zfs_cmd_t *zc, cred_t *cr)
 530 {
 531         int error;
 532
 533         error = zfs_dozonecheck(zc->zc_name, cr);
 534         if (error)
 535                 return (error);
 536
 537         /*
 538          * permission to set permissions will be evaluated later in
 539          * dsl_deleg_can_allow()
 540          */
 541         return (0);
 542 }
 543
 544 int
 545 zfs_secpolicy_rollback(zfs_cmd_t *zc, cred_t *cr)
 546 {
 547         return (zfs_secpolicy_write_perms(zc->zc_name,
 548             ZFS_DELEG_PERM_ROLLBACK, cr));
 549 }
 550
 551 int
 552 zfs_secpolicy_send(zfs_cmd_t *zc, cred_t *cr)
 553 {
 554         spa_t *spa;
 555         dsl_pool_t *dp;
 556         dsl_dataset_t *ds;
 557         char *cp;
 558         int error;
 559
 560         /*
 561          * Generate the current snapshot name from the given objsetid, then
 562          * use that name for the secpolicy/zone checks.
 563          */
 564         cp = strchr(zc->zc_name, '@');
 565         if (cp == NULL)
 566                 return (EINVAL);
 567         error = spa_open(zc->zc_name, &spa, FTAG);
 568         if (error)
 569                 return (error);
 570
 571         dp = spa_get_dsl(spa);
 572         rw_enter(&dp->dp_config_rwlock, RW_READER);
 573         error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
 574         rw_exit(&dp->dp_config_rwlock);
 575         spa_close(spa, FTAG);
 576         if (error)
 577                 return (error);
 578
 579         dsl_dataset_name(ds, zc->zc_name);
 580
 581         error = zfs_secpolicy_write_perms_ds(zc->zc_name, ds,
 582             ZFS_DELEG_PERM_SEND, cr);
 583         dsl_dataset_rele(ds, FTAG);
 584
 585         return (error);
 586 }
 587
 588 static int
 589 zfs_secpolicy_deleg_share(zfs_cmd_t *zc, cred_t *cr)
 590 {
 591         vnode_t *vp;
 592         int error;
 593
 594         if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
 595             NO_FOLLOW, NULL, &vp)) != 0)
 596                 return (error);
 597
 598         /* Now make sure mntpnt and dataset are ZFS */
 599
 600         if (vp->v_vfsp->vfs_fstype != zfsfstype ||
 601             (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
 602             zc->zc_name) != 0)) {
 603                 VN_RELE(vp);
 604                 return (EPERM);
 605         }
 606
 607         VN_RELE(vp);
 608         return (dsl_deleg_access(zc->zc_name,
 609             ZFS_DELEG_PERM_SHARE, cr));
 610 }
 611
 612 int
 613 zfs_secpolicy_share(zfs_cmd_t *zc, cred_t *cr)
 614 {
 615         if (!INGLOBALZONE(curproc))
 616                 return (EPERM);
 617
 618         if (secpolicy_nfs(cr) == 0) {
 619                 return (0);
 620         } else {
 621                 return (zfs_secpolicy_deleg_share(zc, cr));
 622         }
 623 }
 624
 625 int
 626 zfs_secpolicy_smb_acl(zfs_cmd_t *zc, cred_t *cr)
 627 {
 628         if (!INGLOBALZONE(curproc))
 629                 return (EPERM);
 630
 631         if (secpolicy_smb(cr) == 0) {
 632                 return (0);
 633         } else {
 634                 return (zfs_secpolicy_deleg_share(zc, cr));
 635         }
 636 }
 637
 638 static int
 639 zfs_get_parent(const char *datasetname, char *parent, int parentsize)
 640 {
 641         char *cp;
 642
 643         /*
 644          * Remove the @bla or /bla from the end of the name to get the parent.
 645          */
 646         (void) strncpy(parent, datasetname, parentsize);
 647         cp = strrchr(parent, '@');
 648         if (cp != NULL) {
 649                 cp[0] = '\0';
 650         } else {
 651                 cp = strrchr(parent, '/');
 652                 if (cp == NULL)
 653                         return (ENOENT);
 654                 cp[0] = '\0';
 655         }
 656
 657         return (0);
 658 }
 659
 660 int
 661 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
 662 {
 663         int error;
 664
 665         if ((error = zfs_secpolicy_write_perms(name,
 666             ZFS_DELEG_PERM_MOUNT, cr)) != 0)
 667                 return (error);
 668
 669         return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr));
 670 }
 671
 672 static int
 673 zfs_secpolicy_destroy(zfs_cmd_t *zc, cred_t *cr)
 674 {
 675         return (zfs_secpolicy_destroy_perms(zc->zc_name, cr));
 676 }
 677
 678 /*
 679  * Destroying snapshots with delegated permissions requires
 680  * descendent mount and destroy permissions.
 681  * Reassemble the full filesystem@snap name so dsl_deleg_access()
 682  * can do the correct permission check.
 683  *
 684  * Since this routine is used when doing a recursive destroy of snapshots
 685  * and destroying snapshots requires descendent permissions, a successfull
 686  * check of the top level snapshot applies to snapshots of all descendent
 687  * datasets as well.
 688  */
 689 static int
 690 zfs_secpolicy_destroy_snaps(zfs_cmd_t *zc, cred_t *cr)
 691 {
 692         int error;
 693         char *dsname;
 694
 695         dsname = kmem_asprintf("%s@%s", zc->zc_name, zc->zc_value);
 696
 697         error = zfs_secpolicy_destroy_perms(dsname, cr);
 698
 699         strfree(dsname);
 700         return (error);
 701 }
 702
 703 int
 704 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
 705 {
 706         char    parentname[MAXNAMELEN];
 707         int     error;
 708
 709         if ((error = zfs_secpolicy_write_perms(from,
 710             ZFS_DELEG_PERM_RENAME, cr)) != 0)
 711                 return (error);
 712
 713         if ((error = zfs_secpolicy_write_perms(from,
 714             ZFS_DELEG_PERM_MOUNT, cr)) != 0)
 715                 return (error);
 716
 717         if ((error = zfs_get_parent(to, parentname,
 718             sizeof (parentname))) != 0)
 719                 return (error);
 720
 721         if ((error = zfs_secpolicy_write_perms(parentname,
 722             ZFS_DELEG_PERM_CREATE, cr)) != 0)
 723                 return (error);
 724
 725         if ((error = zfs_secpolicy_write_perms(parentname,
 726             ZFS_DELEG_PERM_MOUNT, cr)) != 0)
 727                 return (error);
 728
 729         return (error);
 730 }
 731
 732 static int
 733 zfs_secpolicy_rename(zfs_cmd_t *zc, cred_t *cr)
 734 {
 735         return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr));
 736 }
 737
 738 static int
 739 zfs_secpolicy_promote(zfs_cmd_t *zc, cred_t *cr)
 740 {
 741         char    parentname[MAXNAMELEN];
 742         objset_t *clone;
 743         int error;
 744
 745         error = zfs_secpolicy_write_perms(zc->zc_name,
 746             ZFS_DELEG_PERM_PROMOTE, cr);
 747         if (error)
 748                 return (error);
 749
 750         error = dmu_objset_hold(zc->zc_name, FTAG, &clone);
 751
 752         if (error == 0) {
 753                 dsl_dataset_t *pclone = NULL;
 754                 dsl_dir_t *dd;
 755                 dd = clone->os_dsl_dataset->ds_dir;
 756
 757                 rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
 758                 error = dsl_dataset_hold_obj(dd->dd_pool,
 759                     dd->dd_phys->dd_origin_obj, FTAG, &pclone);
 760                 rw_exit(&dd->dd_pool->dp_config_rwlock);
 761                 if (error) {
 762                         dmu_objset_rele(clone, FTAG);
 763                         return (error);
 764                 }
 765
 766                 error = zfs_secpolicy_write_perms(zc->zc_name,
 767                     ZFS_DELEG_PERM_MOUNT, cr);
 768
 769                 dsl_dataset_name(pclone, parentname);
 770                 dmu_objset_rele(clone, FTAG);
 771                 dsl_dataset_rele(pclone, FTAG);
 772                 if (error == 0)
 773                         error = zfs_secpolicy_write_perms(parentname,
 774                             ZFS_DELEG_PERM_PROMOTE, cr);
 775         }
 776         return (error);
 777 }
 778
 779 static int
 780 zfs_secpolicy_receive(zfs_cmd_t *zc, cred_t *cr)
 781 {
 782         int error;
 783
 784         if ((error = zfs_secpolicy_write_perms(zc->zc_name,
 785             ZFS_DELEG_PERM_RECEIVE, cr)) != 0)
 786                 return (error);
 787
 788         if ((error = zfs_secpolicy_write_perms(zc->zc_name,
 789             ZFS_DELEG_PERM_MOUNT, cr)) != 0)
 790                 return (error);
 791
 792         return (zfs_secpolicy_write_perms(zc->zc_name,
 793             ZFS_DELEG_PERM_CREATE, cr));
 794 }
 795
 796 int
 797 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
 798 {
 799         return (zfs_secpolicy_write_perms(name,
 800             ZFS_DELEG_PERM_SNAPSHOT, cr));
 801 }
 802
 803 static int
 804 zfs_secpolicy_snapshot(zfs_cmd_t *zc, cred_t *cr)
 805 {
 806
 807         return (zfs_secpolicy_snapshot_perms(zc->zc_name, cr));
 808 }
 809
 810 static int
 811 zfs_secpolicy_create(zfs_cmd_t *zc, cred_t *cr)
 812 {
 813         char    parentname[MAXNAMELEN];
 814         int     error;
 815
 816         if ((error = zfs_get_parent(zc->zc_name, parentname,
 817             sizeof (parentname))) != 0)
 818                 return (error);
 819
 820         if (zc->zc_value[0] != '\0') {
 821                 if ((error = zfs_secpolicy_write_perms(zc->zc_value,
 822                     ZFS_DELEG_PERM_CLONE, cr)) != 0)
 823                         return (error);
 824         }
 825
 826         if ((error = zfs_secpolicy_write_perms(parentname,
 827             ZFS_DELEG_PERM_CREATE, cr)) != 0)
 828                 return (error);
 829
 830         error = zfs_secpolicy_write_perms(parentname,
 831             ZFS_DELEG_PERM_MOUNT, cr);
 832
 833         return (error);
 834 }
 835
 836 static int
 837 zfs_secpolicy_umount(zfs_cmd_t *zc, cred_t *cr)
 838 {
 839         int error;
 840
 841         error = secpolicy_fs_unmount(cr, NULL);
 842         if (error) {
 843                 error = dsl_deleg_access(zc->zc_name, ZFS_DELEG_PERM_MOUNT, cr);
 844         }
 845         return (error);
 846 }
 847
 848 /*
 849  * Policy for pool operations - create/destroy pools, add vdevs, etc.  Requires
 850  * SYS_CONFIG privilege, which is not available in a local zone.
 851  */
 852 /* ARGSUSED */
 853 static int
 854 zfs_secpolicy_config(zfs_cmd_t *zc, cred_t *cr)
 855 {
 856         if (secpolicy_sys_config(cr, B_FALSE) != 0)
 857                 return (EPERM);
 858
 859         return (0);
 860 }
 861
 862 /*
 863  * Policy for object to name lookups.
 864  */
 865 /* ARGSUSED */
 866 static int
 867 zfs_secpolicy_diff(zfs_cmd_t *zc, cred_t *cr)
 868 {
 869         int error;
 870
 871         if ((error = secpolicy_sys_config(cr, B_FALSE)) == 0)
 872                 return (0);
 873
 874         error = zfs_secpolicy_write_perms(zc->zc_name, ZFS_DELEG_PERM_DIFF, cr);
 875         return (error);
 876 }
 877
 878 /*
 879  * Policy for fault injection.  Requires all privileges.
 880  */
 881 /* ARGSUSED */
 882 static int
 883 zfs_secpolicy_inject(zfs_cmd_t *zc, cred_t *cr)
 884 {
 885         return (secpolicy_zinject(cr));
 886 }
 887
 888 static int
 889 zfs_secpolicy_inherit(zfs_cmd_t *zc, cred_t *cr)
 890 {
 891         zfs_prop_t prop = zfs_name_to_prop(zc->zc_value);
 892
 893         if (prop == ZPROP_INVAL) {
 894                 if (!zfs_prop_user(zc->zc_value))
 895                         return (EINVAL);
 896                 return (zfs_secpolicy_write_perms(zc->zc_name,
 897                     ZFS_DELEG_PERM_USERPROP, cr));
 898         } else {
 899                 return (zfs_secpolicy_setprop(zc->zc_name, prop,
 900                     NULL, cr));
 901         }
 902 }
 903
 904 static int
 905 zfs_secpolicy_userspace_one(zfs_cmd_t *zc, cred_t *cr)
 906 {
 907         int err = zfs_secpolicy_read(zc, cr);
 908         if (err)
 909                 return (err);
 910
 911         if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
 912                 return (EINVAL);
 913
 914         if (zc->zc_value[0] == 0) {
 915                 /*
 916                  * They are asking about a posix uid/gid.  If it's
 917                  * themself, allow it.
 918                  */
 919                 if (zc->zc_objset_type == ZFS_PROP_USERUSED ||
 920                     zc->zc_objset_type == ZFS_PROP_USERQUOTA) {
 921                         if (zc->zc_guid == crgetuid(cr))
 922                                 return (0);
 923                 } else {
 924                         if (groupmember(zc->zc_guid, cr))
 925                                 return (0);
 926                 }
 927         }
 928
 929         return (zfs_secpolicy_write_perms(zc->zc_name,
 930             userquota_perms[zc->zc_objset_type], cr));
 931 }
 932
 933 static int
 934 zfs_secpolicy_userspace_many(zfs_cmd_t *zc, cred_t *cr)
 935 {
 936         int err = zfs_secpolicy_read(zc, cr);
 937         if (err)
 938                 return (err);
 939
 940         if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
 941                 return (EINVAL);
 942
 943         return (zfs_secpolicy_write_perms(zc->zc_name,
 944             userquota_perms[zc->zc_objset_type], cr));
 945 }
 946
 947 static int
 948 zfs_secpolicy_userspace_upgrade(zfs_cmd_t *zc, cred_t *cr)
 949 {
 950         return (zfs_secpolicy_setprop(zc->zc_name, ZFS_PROP_VERSION,
 951             NULL, cr));
 952 }
 953
 954 static int
 955 zfs_secpolicy_hold(zfs_cmd_t *zc, cred_t *cr)
 956 {
 957         return (zfs_secpolicy_write_perms(zc->zc_name,
 958             ZFS_DELEG_PERM_HOLD, cr));
 959 }
 960
 961 static int
 962 zfs_secpolicy_release(zfs_cmd_t *zc, cred_t *cr)
 963 {
 964         return (zfs_secpolicy_write_perms(zc->zc_name,
 965             ZFS_DELEG_PERM_RELEASE, cr));
 966 }
 967
 968 /*
 969  * Policy for allowing temporary snapshots to be taken or released
 970  */
 971 static int
 972 zfs_secpolicy_tmp_snapshot(zfs_cmd_t *zc, cred_t *cr)
 973 {
 974         /*
 975          * A temporary snapshot is the same as a snapshot,
 976          * hold, destroy and release all rolled into one.
 977          * Delegated diff alone is sufficient that we allow this.
 978          */
 979         int error;
 980
 981         if ((error = zfs_secpolicy_write_perms(zc->zc_name,
 982             ZFS_DELEG_PERM_DIFF, cr)) == 0)
 983                 return (0);
 984
 985         error = zfs_secpolicy_snapshot(zc, cr);
 986         if (!error)
 987                 error = zfs_secpolicy_hold(zc, cr);
 988         if (!error)
 989                 error = zfs_secpolicy_release(zc, cr);
 990         if (!error)
 991                 error = zfs_secpolicy_destroy(zc, cr);
 992         return (error);
 993 }
 994
 995 /*
 996  * Returns the nvlist as specified by the user in the zfs_cmd_t.
 997  */
 998 static int
 999 get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp)
1000 {
1001         char *packed;
1002         int error;
1003         nvlist_t *list = NULL;
1004
1005         /*
1006          * Read in and unpack the user-supplied nvlist.
1007          */
1008         if (size == 0)
1009                 return (EINVAL);
1010
1011         packed = kmem_alloc(size, KM_SLEEP);
1012
1013         if ((error = ddi_copyin((void *)(uintptr_t)nvl, packed, size,
1014             iflag)) != 0) {
1015                 kmem_free(packed, size);
1016                 return (error);
1017         }
1018
1019         if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) {
1020                 kmem_free(packed, size);
1021                 return (error);
1022         }
1023
1024         kmem_free(packed, size);
1025
1026         *nvp = list;
1027         return (0);
1028 }
1029
1030 static int
1031 fit_error_list(zfs_cmd_t *zc, nvlist_t **errors)
1032 {
1033         size_t size;
1034
1035         VERIFY(nvlist_size(*errors, &size, NV_ENCODE_NATIVE) == 0);
1036
1037         if (size > zc->zc_nvlist_dst_size) {
1038                 nvpair_t *more_errors;
1039                 int n = 0;
1040
1041                 if (zc->zc_nvlist_dst_size < 1024)
1042                         return (ENOMEM);
1043
1044                 VERIFY(nvlist_add_int32(*errors, ZPROP_N_MORE_ERRORS, 0) == 0);
1045                 more_errors = nvlist_prev_nvpair(*errors, NULL);
1046
1047                 do {
1048                         nvpair_t *pair = nvlist_prev_nvpair(*errors,
1049                             more_errors);
1050                         VERIFY(nvlist_remove_nvpair(*errors, pair) == 0);
1051                         n++;
1052                         VERIFY(nvlist_size(*errors, &size,
1053                             NV_ENCODE_NATIVE) == 0);
1054                 } while (size > zc->zc_nvlist_dst_size);
1055
1056                 VERIFY(nvlist_remove_nvpair(*errors, more_errors) == 0);
1057                 VERIFY(nvlist_add_int32(*errors, ZPROP_N_MORE_ERRORS, n) == 0);
1058                 ASSERT(nvlist_size(*errors, &size, NV_ENCODE_NATIVE) == 0);
1059                 ASSERT(size <= zc->zc_nvlist_dst_size);
1060         }
1061
1062         return (0);
1063 }
1064
1065 static int
1066 put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
1067 {
1068         char *packed = NULL;
1069         int error = 0;
1070         size_t size;
1071
1072         VERIFY(nvlist_size(nvl, &size, NV_ENCODE_NATIVE) == 0);
1073
1074         if (size > zc->zc_nvlist_dst_size) {
1075                 error = ENOMEM;
1076         } else {
1077                 packed = kmem_alloc(size, KM_SLEEP);
1078                 VERIFY(nvlist_pack(nvl, &packed, &size, NV_ENCODE_NATIVE,
1079                     KM_SLEEP) == 0);
1080                 if (ddi_copyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
1081                     size, zc->zc_iflags) != 0)
1082                         error = EFAULT;
1083                 kmem_free(packed, size);
1084         }
1085
1086         zc->zc_nvlist_dst_size = size;
1087         return (error);
1088 }
1089
1090 static int
1091 getzfsvfs(const char *dsname, zfsvfs_t **zfvp)
1092 {
1093         objset_t *os;
1094         int error;
1095
1096         error = dmu_objset_hold(dsname, FTAG, &os);
1097         if (error)
1098                 return (error);
1099         if (dmu_objset_type(os) != DMU_OST_ZFS) {
1100                 dmu_objset_rele(os, FTAG);
1101                 return (EINVAL);
1102         }
1103
1104         mutex_enter(&os->os_user_ptr_lock);
1105         *zfvp = dmu_objset_get_user(os);
1106         if (*zfvp) {
1107                 VFS_HOLD((*zfvp)->z_vfs);
1108         } else {
1109                 error = ESRCH;
1110         }
1111         mutex_exit(&os->os_user_ptr_lock);
1112         dmu_objset_rele(os, FTAG);
1113         return (error);
1114 }
1115
1116 /*
1117  * Find a zfsvfs_t for a mounted filesystem, or create our own, in which
1118  * case its z_vfs will be NULL, and it will be opened as the owner.
1119  */
1120 static int
1121 zfsvfs_hold(const char *name, void *tag, zfsvfs_t **zfvp, boolean_t writer)
1122 {
1123         int error = 0;
1124
1125         if (getzfsvfs(name, zfvp) != 0)
1126                 error = zfsvfs_create(name, zfvp);
1127         if (error == 0) {
1128                 rrw_enter(&(*zfvp)->z_teardown_lock, (writer) ? RW_WRITER :
1129                     RW_READER, tag);
1130                 if ((*zfvp)->z_unmounted) {
1131                         /*
1132                          * XXX we could probably try again, since the unmounting
1133                          * thread should be just about to disassociate the
1134                          * objset from the zfsvfs.
1135                          */
1136                         rrw_exit(&(*zfvp)->z_teardown_lock, tag);
1137                         return (EBUSY);
1138                 }
1139         }
1140         return (error);
1141 }
1142
1143 static void
1144 zfsvfs_rele(zfsvfs_t *zfsvfs, void *tag)
1145 {
1146         rrw_exit(&zfsvfs->z_teardown_lock, tag);
1147
1148         if (zfsvfs->z_vfs) {
1149                 VFS_RELE(zfsvfs->z_vfs);
1150         } else {
1151                 dmu_objset_disown(zfsvfs->z_os, zfsvfs);
1152                 zfsvfs_free(zfsvfs);
1153         }
1154 }
1155
1156 static int
1157 zfs_ioc_pool_create(zfs_cmd_t *zc)
1158 {
1159         int error;
1160         nvlist_t *config, *props = NULL;
1161         nvlist_t *rootprops = NULL;
1162         nvlist_t *zplprops = NULL;
1163         char *buf;
1164
1165         if (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1166             zc->zc_iflags, &config))
1167                 return (error);
1168
1169         if (zc->zc_nvlist_src_size != 0 && (error =
1170             get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1171             zc->zc_iflags, &props))) {
1172                 nvlist_free(config);
1173                 return (error);
1174         }
1175
1176         if (props) {
1177                 nvlist_t *nvl = NULL;
1178                 uint64_t version = SPA_VERSION;
1179
1180                 (void) nvlist_lookup_uint64(props,
1181                     zpool_prop_to_name(ZPOOL_PROP_VERSION), &version);
1182                 if (version < SPA_VERSION_INITIAL || version > SPA_VERSION) {
1183                         error = EINVAL;
1184                         goto pool_props_bad;
1185                 }
1186                 (void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl);
1187                 if (nvl) {
1188                         error = nvlist_dup(nvl, &rootprops, KM_SLEEP);
1189                         if (error != 0) {
1190                                 nvlist_free(config);
1191                                 nvlist_free(props);
1192                                 return (error);
1193                         }
1194                         (void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS);
1195                 }
1196                 VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1197                 error = zfs_fill_zplprops_root(version, rootprops,
1198                     zplprops, NULL);
1199                 if (error)
1200                         goto pool_props_bad;
1201         }
1202
1203         buf = history_str_get(zc);
1204
1205         error = spa_create(zc->zc_name, config, props, buf, zplprops);
1206
1207         /*
1208          * Set the remaining root properties
1209          */
1210         if (!error && (error = zfs_set_prop_nvlist(zc->zc_name,
1211             ZPROP_SRC_LOCAL, rootprops, NULL)) != 0)
1212                 (void) spa_destroy(zc->zc_name);
1213
1214         if (buf != NULL)
1215                 history_str_free(buf);
1216
1217 pool_props_bad:
1218         nvlist_free(rootprops);
1219         nvlist_free(zplprops);
1220         nvlist_free(config);
1221         nvlist_free(props);
1222
1223         return (error);
1224 }
1225
1226 static int
1227 zfs_ioc_pool_destroy(zfs_cmd_t *zc)
1228 {
1229         int error;
1230         zfs_log_history(zc);
1231         error = spa_destroy(zc->zc_name);
1232         if (error == 0)
1233                 zvol_remove_minors(zc->zc_name);
1234         return (error);
1235 }
1236
1237 static int
1238 zfs_ioc_pool_import(zfs_cmd_t *zc)
1239 {
1240         nvlist_t *config, *props = NULL;
1241         uint64_t guid;
1242         int error;
1243
1244         if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1245             zc->zc_iflags, &config)) != 0)
1246                 return (error);
1247
1248         if (zc->zc_nvlist_src_size != 0 && (error =
1249             get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1250             zc->zc_iflags, &props))) {
1251                 nvlist_free(config);
1252                 return (error);
1253         }
1254
1255         if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 ||
1256             guid != zc->zc_guid)
1257                 error = EINVAL;
1258         else
1259                 error = spa_import(zc->zc_name, config, props, zc->zc_cookie);
1260
1261         if (zc->zc_nvlist_dst != 0) {
1262                 int err;
1263
1264                 if ((err = put_nvlist(zc, config)) != 0)
1265                         error = err;
1266         }
1267
1268         nvlist_free(config);
1269
1270         if (props)
1271                 nvlist_free(props);
1272
1273         return (error);
1274 }
1275
1276 static int
1277 zfs_ioc_pool_export(zfs_cmd_t *zc)
1278 {
1279         int error;
1280         boolean_t force = (boolean_t)zc->zc_cookie;
1281         boolean_t hardforce = (boolean_t)zc->zc_guid;
1282
1283         zfs_log_history(zc);
1284         error = spa_export(zc->zc_name, NULL, force, hardforce);
1285         if (error == 0)
1286                 zvol_remove_minors(zc->zc_name);
1287         return (error);
1288 }
1289
1290 static int
1291 zfs_ioc_pool_configs(zfs_cmd_t *zc)
1292 {
1293         nvlist_t *configs;
1294         int error;
1295
1296         if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
1297                 return (EEXIST);
1298
1299         error = put_nvlist(zc, configs);
1300
1301         nvlist_free(configs);
1302
1303         return (error);
1304 }
1305
1306 static int
1307 zfs_ioc_pool_stats(zfs_cmd_t *zc)
1308 {
1309         nvlist_t *config;
1310         int error;
1311         int ret = 0;
1312
1313         error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
1314             sizeof (zc->zc_value));
1315
1316         if (config != NULL) {
1317                 ret = put_nvlist(zc, config);
1318                 nvlist_free(config);
1319
1320                 /*
1321                  * The config may be present even if 'error' is non-zero.
1322                  * In this case we return success, and preserve the real errno
1323                  * in 'zc_cookie'.
1324                  */
1325                 zc->zc_cookie = error;
1326         } else {
1327                 ret = error;
1328         }
1329
1330         return (ret);
1331 }
1332
1333 /*
1334  * Try to import the given pool, returning pool stats as appropriate so that
1335  * user land knows which devices are available and overall pool health.
1336  */
1337 static int
1338 zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
1339 {
1340         nvlist_t *tryconfig, *config;
1341         int error;
1342
1343         if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1344             zc->zc_iflags, &tryconfig)) != 0)
1345                 return (error);
1346
1347         config = spa_tryimport(tryconfig);
1348
1349         nvlist_free(tryconfig);
1350
1351         if (config == NULL)
1352                 return (EINVAL);
1353
1354         error = put_nvlist(zc, config);
1355         nvlist_free(config);
1356
1357         return (error);
1358 }
1359
1360 /*
1361  * inputs:
1362  * zc_name              name of the pool
1363  * zc_cookie            scan func (pool_scan_func_t)
1364  */
1365 static int
1366 zfs_ioc_pool_scan(zfs_cmd_t *zc)
1367 {
1368         spa_t *spa;
1369         int error;
1370
1371         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1372                 return (error);
1373
1374         if (zc->zc_cookie == POOL_SCAN_NONE)
1375                 error = spa_scan_stop(spa);
1376         else
1377                 error = spa_scan(spa, zc->zc_cookie);
1378
1379         spa_close(spa, FTAG);
1380
1381         return (error);
1382 }
1383
1384 static int
1385 zfs_ioc_pool_freeze(zfs_cmd_t *zc)
1386 {
1387         spa_t *spa;
1388         int error;
1389
1390         error = spa_open(zc->zc_name, &spa, FTAG);
1391         if (error == 0) {
1392                 spa_freeze(spa);
1393                 spa_close(spa, FTAG);
1394         }
1395         return (error);
1396 }
1397
1398 static int
1399 zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
1400 {
1401         spa_t *spa;
1402         int error;
1403
1404         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1405                 return (error);
1406
1407         if (zc->zc_cookie < spa_version(spa) || zc->zc_cookie > SPA_VERSION) {
1408                 spa_close(spa, FTAG);
1409                 return (EINVAL);
1410         }
1411
1412         spa_upgrade(spa, zc->zc_cookie);
1413         spa_close(spa, FTAG);
1414
1415         return (error);
1416 }
1417
1418 static int
1419 zfs_ioc_pool_get_history(zfs_cmd_t *zc)
1420 {
1421         spa_t *spa;
1422         char *hist_buf;
1423         uint64_t size;
1424         int error;
1425
1426         if ((size = zc->zc_history_len) == 0)
1427                 return (EINVAL);
1428
1429         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1430                 return (error);
1431
1432         if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
1433                 spa_close(spa, FTAG);
1434                 return (ENOTSUP);
1435         }
1436
1437         hist_buf = kmem_alloc(size, KM_SLEEP);
1438         if ((error = spa_history_get(spa, &zc->zc_history_offset,
1439             &zc->zc_history_len, hist_buf)) == 0) {
1440                 error = ddi_copyout(hist_buf,
1441                     (void *)(uintptr_t)zc->zc_history,
1442                     zc->zc_history_len, zc->zc_iflags);
1443         }
1444
1445         spa_close(spa, FTAG);
1446         kmem_free(hist_buf, size);
1447         return (error);
1448 }
1449
1450 static int
1451 zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc)
1452 {
1453         int error;
1454
1455         if (error = dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value))
1456                 return (error);
1457
1458         return (0);
1459 }
1460
1461 /*
1462  * inputs:
1463  * zc_name              name of filesystem
1464  * zc_obj               object to find
1465  *
1466  * outputs:
1467  * zc_value             name of object
1468  */
1469 static int
1470 zfs_ioc_obj_to_path(zfs_cmd_t *zc)
1471 {
1472         objset_t *os;
1473         int error;
1474
1475         /* XXX reading from objset not owned */
1476         if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os)) != 0)
1477                 return (error);
1478         if (dmu_objset_type(os) != DMU_OST_ZFS) {
1479                 dmu_objset_rele(os, FTAG);
1480                 return (EINVAL);
1481         }
1482         error = zfs_obj_to_path(os, zc->zc_obj, zc->zc_value,
1483             sizeof (zc->zc_value));
1484         dmu_objset_rele(os, FTAG);
1485
1486         return (error);
1487 }
1488
1489 /*
1490  * inputs:
1491  * zc_name              name of filesystem
1492  * zc_obj               object to find
1493  *
1494  * outputs:
1495  * zc_stat              stats on object
1496  * zc_value             path to object
1497  */
1498 static int
1499 zfs_ioc_obj_to_stats(zfs_cmd_t *zc)
1500 {
1501         objset_t *os;
1502         int error;
1503
1504         /* XXX reading from objset not owned */
1505         if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os)) != 0)
1506                 return (error);
1507         if (dmu_objset_type(os) != DMU_OST_ZFS) {
1508                 dmu_objset_rele(os, FTAG);
1509                 return (EINVAL);
1510         }
1511         error = zfs_obj_to_stats(os, zc->zc_obj, &zc->zc_stat, zc->zc_value,
1512             sizeof (zc->zc_value));
1513         dmu_objset_rele(os, FTAG);
1514
1515         return (error);
1516 }
1517
1518 static int
1519 zfs_ioc_vdev_add(zfs_cmd_t *zc)
1520 {
1521         spa_t *spa;
1522         int error;
1523         nvlist_t *config, **l2cache, **spares;
1524         uint_t nl2cache = 0, nspares = 0;
1525
1526         error = spa_open(zc->zc_name, &spa, FTAG);
1527         if (error != 0)
1528                 return (error);
1529
1530         error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1531             zc->zc_iflags, &config);
1532         (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_L2CACHE,
1533             &l2cache, &nl2cache);
1534
1535         (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_SPARES,
1536             &spares, &nspares);
1537
1538         /*
1539          * A root pool with concatenated devices is not supported.
1540          * Thus, can not add a device to a root pool.
1541          *
1542          * Intent log device can not be added to a rootpool because
1543          * during mountroot, zil is replayed, a seperated log device
1544          * can not be accessed during the mountroot time.
1545          *
1546          * l2cache and spare devices are ok to be added to a rootpool.
1547          */
1548         if (spa_bootfs(spa) != 0 && nl2cache == 0 && nspares == 0) {
1549                 nvlist_free(config);
1550                 spa_close(spa, FTAG);
1551                 return (EDOM);
1552         }
1553
1554         if (error == 0) {
1555                 error = spa_vdev_add(spa, config);
1556                 nvlist_free(config);
1557         }
1558         spa_close(spa, FTAG);
1559         return (error);
1560 }
1561
1562 /*
1563  * inputs:
1564  * zc_name              name of the pool
1565  * zc_nvlist_conf       nvlist of devices to remove
1566  * zc_cookie            to stop the remove?
1567  */
1568 static int
1569 zfs_ioc_vdev_remove(zfs_cmd_t *zc)
1570 {
1571         spa_t *spa;
1572         int error;
1573
1574         error = spa_open(zc->zc_name, &spa, FTAG);
1575         if (error != 0)
1576                 return (error);
1577         error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
1578         spa_close(spa, FTAG);
1579         return (error);
1580 }
1581
1582 static int
1583 zfs_ioc_vdev_set_state(zfs_cmd_t *zc)
1584 {
1585         spa_t *spa;
1586         int error;
1587         vdev_state_t newstate = VDEV_STATE_UNKNOWN;
1588
1589         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1590                 return (error);
1591         switch (zc->zc_cookie) {
1592         case VDEV_STATE_ONLINE:
1593                 error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate);
1594                 break;
1595
1596         case VDEV_STATE_OFFLINE:
1597                 error = vdev_offline(spa, zc->zc_guid, zc->zc_obj);
1598                 break;
1599
1600         case VDEV_STATE_FAULTED:
1601                 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1602                     zc->zc_obj != VDEV_AUX_EXTERNAL)
1603                         zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1604
1605                 error = vdev_fault(spa, zc->zc_guid, zc->zc_obj);
1606                 break;
1607
1608         case VDEV_STATE_DEGRADED:
1609                 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1610                     zc->zc_obj != VDEV_AUX_EXTERNAL)
1611                         zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1612
1613                 error = vdev_degrade(spa, zc->zc_guid, zc->zc_obj);
1614                 break;
1615
1616         default:
1617                 error = EINVAL;
1618         }
1619         zc->zc_cookie = newstate;
1620         spa_close(spa, FTAG);
1621         return (error);
1622 }
1623
1624 static int
1625 zfs_ioc_vdev_attach(zfs_cmd_t *zc)
1626 {
1627         spa_t *spa;
1628         int replacing = zc->zc_cookie;
1629         nvlist_t *config;
1630         int error;
1631
1632         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1633                 return (error);
1634
1635         if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1636             zc->zc_iflags, &config)) == 0) {
1637                 error = spa_vdev_attach(spa, zc->zc_guid, config, replacing);
1638                 nvlist_free(config);
1639         }
1640
1641         spa_close(spa, FTAG);
1642         return (error);
1643 }
1644
1645 static int
1646 zfs_ioc_vdev_detach(zfs_cmd_t *zc)
1647 {
1648         spa_t *spa;
1649         int error;
1650
1651         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1652                 return (error);
1653
1654         error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE);
1655
1656         spa_close(spa, FTAG);
1657         return (error);
1658 }
1659
1660 static int
1661 zfs_ioc_vdev_split(zfs_cmd_t *zc)
1662 {
1663         spa_t *spa;
1664         nvlist_t *config, *props = NULL;
1665         int error;
1666         boolean_t exp = !!(zc->zc_cookie & ZPOOL_EXPORT_AFTER_SPLIT);
1667
1668         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1669                 return (error);
1670
1671         if (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1672             zc->zc_iflags, &config)) {
1673                 spa_close(spa, FTAG);
1674                 return (error);
1675         }
1676
1677         if (zc->zc_nvlist_src_size != 0 && (error =
1678             get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1679             zc->zc_iflags, &props))) {
1680                 spa_close(spa, FTAG);
1681                 nvlist_free(config);
1682                 return (error);
1683         }
1684
1685         error = spa_vdev_split_mirror(spa, zc->zc_string, config, props, exp);
1686
1687         spa_close(spa, FTAG);
1688
1689         nvlist_free(config);
1690         nvlist_free(props);
1691
1692         return (error);
1693 }
1694
1695 static int
1696 zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
1697 {
1698         spa_t *spa;
1699         char *path = zc->zc_value;
1700         uint64_t guid = zc->zc_guid;
1701         int error;
1702
1703         error = spa_open(zc->zc_name, &spa, FTAG);
1704         if (error != 0)
1705                 return (error);
1706
1707         error = spa_vdev_setpath(spa, guid, path);
1708         spa_close(spa, FTAG);
1709         return (error);
1710 }
1711
1712 static int
1713 zfs_ioc_vdev_setfru(zfs_cmd_t *zc)
1714 {
1715         spa_t *spa;
1716         char *fru = zc->zc_value;
1717         uint64_t guid = zc->zc_guid;
1718         int error;
1719
1720         error = spa_open(zc->zc_name, &spa, FTAG);
1721         if (error != 0)
1722                 return (error);
1723
1724         error = spa_vdev_setfru(spa, guid, fru);
1725         spa_close(spa, FTAG);
1726         return (error);
1727 }
1728
1729 static int
1730 zfs_ioc_objset_stats_impl(zfs_cmd_t *zc, objset_t *os)
1731 {
1732         int error = 0;
1733         nvlist_t *nv;
1734
1735         dmu_objset_fast_stat(os, &zc->zc_objset_stats);
1736
1737         if (zc->zc_nvlist_dst != 0 &&
1738             (error = dsl_prop_get_all(os, &nv)) == 0) {
1739                 dmu_objset_stats(os, nv);
1740                 /*
1741                  * NB: zvol_get_stats() will read the objset contents,
1742                  * which we aren't supposed to do with a
1743                  * DS_MODE_USER hold, because it could be
1744                  * inconsistent.  So this is a bit of a workaround...
1745                  * XXX reading with out owning
1746                  */
1747                 if (!zc->zc_objset_stats.dds_inconsistent) {
1748                         if (dmu_objset_type(os) == DMU_OST_ZVOL)
1749                                 VERIFY(zvol_get_stats(os, nv) == 0);
1750                 }
1751                 error = put_nvlist(zc, nv);
1752                 nvlist_free(nv);
1753         }
1754
1755         return (error);
1756 }
1757
1758 /*
1759  * inputs:
1760  * zc_name              name of filesystem
1761  * zc_nvlist_dst_size   size of buffer for property nvlist
1762  *
1763  * outputs:
1764  * zc_objset_stats      stats
1765  * zc_nvlist_dst        property nvlist
1766  * zc_nvlist_dst_size   size of property nvlist
1767  */
1768 static int
1769 zfs_ioc_objset_stats(zfs_cmd_t *zc)
1770 {
1771         objset_t *os = NULL;
1772         int error;
1773
1774         if (error = dmu_objset_hold(zc->zc_name, FTAG, &os))
1775                 return (error);
1776
1777         error = zfs_ioc_objset_stats_impl(zc, os);
1778
1779         dmu_objset_rele(os, FTAG);
1780
1781         return (error);
1782 }
1783
1784 /*
1785  * inputs:
1786  * zc_name              name of filesystem
1787  * zc_nvlist_dst_size   size of buffer for property nvlist
1788  *
1789  * outputs:
1790  * zc_nvlist_dst        received property nvlist
1791  * zc_nvlist_dst_size   size of received property nvlist
1792  *
1793  * Gets received properties (distinct from local properties on or after
1794  * SPA_VERSION_RECVD_PROPS) for callers who want to differentiate received from
1795  * local property values.
1796  */
1797 static int
1798 zfs_ioc_objset_recvd_props(zfs_cmd_t *zc)
1799 {
1800         objset_t *os = NULL;
1801         int error;
1802         nvlist_t *nv;
1803
1804         if (error = dmu_objset_hold(zc->zc_name, FTAG, &os))
1805                 return (error);
1806
1807         /*
1808          * Without this check, we would return local property values if the
1809          * caller has not already received properties on or after
1810          * SPA_VERSION_RECVD_PROPS.
1811          */
1812         if (!dsl_prop_get_hasrecvd(os)) {
1813                 dmu_objset_rele(os, FTAG);
1814                 return (ENOTSUP);
1815         }
1816
1817         if (zc->zc_nvlist_dst != 0 &&
1818             (error = dsl_prop_get_received(os, &nv)) == 0) {
1819                 error = put_nvlist(zc, nv);
1820                 nvlist_free(nv);
1821         }
1822
1823         dmu_objset_rele(os, FTAG);
1824         return (error);
1825 }
1826
1827 static int
1828 nvl_add_zplprop(objset_t *os, nvlist_t *props, zfs_prop_t prop)
1829 {
1830         uint64_t value;
1831         int error;
1832
1833         /*
1834          * zfs_get_zplprop() will either find a value or give us
1835          * the default value (if there is one).
1836          */
1837         if ((error = zfs_get_zplprop(os, prop, &value)) != 0)
1838                 return (error);
1839         VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0);
1840         return (0);
1841 }
1842
1843 /*
1844  * inputs:
1845  * zc_name              name of filesystem
1846  * zc_nvlist_dst_size   size of buffer for zpl property nvlist
1847  *
1848  * outputs:
1849  * zc_nvlist_dst        zpl property nvlist
1850  * zc_nvlist_dst_size   size of zpl property nvlist
1851  */
1852 static int
1853 zfs_ioc_objset_zplprops(zfs_cmd_t *zc)
1854 {
1855         objset_t *os;
1856         int err;
1857
1858         /* XXX reading without owning */
1859         if (err = dmu_objset_hold(zc->zc_name, FTAG, &os))
1860                 return (err);
1861
1862         dmu_objset_fast_stat(os, &zc->zc_objset_stats);
1863
1864         /*
1865          * NB: nvl_add_zplprop() will read the objset contents,
1866          * which we aren't supposed to do with a DS_MODE_USER
1867          * hold, because it could be inconsistent.
1868          */
1869         if (zc->zc_nvlist_dst != 0 &&
1870             !zc->zc_objset_stats.dds_inconsistent &&
1871             dmu_objset_type(os) == DMU_OST_ZFS) {
1872                 nvlist_t *nv;
1873
1874                 VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1875                 if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 &&
1876                     (err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 &&
1877                     (err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 &&
1878                     (err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0)
1879                         err = put_nvlist(zc, nv);
1880                 nvlist_free(nv);
1881         } else {
1882                 err = ENOENT;
1883         }
1884         dmu_objset_rele(os, FTAG);
1885         return (err);
1886 }
1887
1888 static boolean_t
1889 dataset_name_hidden(const char *name)
1890 {
1891         /*
1892          * Skip over datasets that are not visible in this zone,
1893          * internal datasets (which have a $ in their name), and
1894          * temporary datasets (which have a % in their name).
1895          */
1896         if (strchr(name, '$') != NULL)
1897                 return (B_TRUE);
1898         if (strchr(name, '%') != NULL)
1899                 return (B_TRUE);
1900         if (!INGLOBALZONE(curproc) && !zone_dataset_visible(name, NULL))
1901                 return (B_TRUE);
1902         return (B_FALSE);
1903 }
1904
1905 /*
1906  * inputs:
1907  * zc_name              name of filesystem
1908  * zc_cookie            zap cursor
1909  * zc_nvlist_dst_size   size of buffer for property nvlist
1910  *
1911  * outputs:
1912  * zc_name              name of next filesystem
1913  * zc_cookie            zap cursor
1914  * zc_objset_stats      stats
1915  * zc_nvlist_dst        property nvlist
1916  * zc_nvlist_dst_size   size of property nvlist
1917  */
1918 static int
1919 zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
1920 {
1921         objset_t *os;
1922         int error;
1923         char *p;
1924         size_t orig_len = strlen(zc->zc_name);
1925
1926 top:
1927         if (error = dmu_objset_hold(zc->zc_name, FTAG, &os)) {
1928                 if (error == ENOENT)
1929                         error = ESRCH;
1930                 return (error);
1931         }
1932
1933         p = strrchr(zc->zc_name, '/');
1934         if (p == NULL || p[1] != '\0')
1935                 (void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
1936         p = zc->zc_name + strlen(zc->zc_name);
1937
1938         /*
1939          * Pre-fetch the datasets.  dmu_objset_prefetch() always returns 0
1940          * but is not declared void because its called by dmu_objset_find().
1941          */
1942         if (zc->zc_cookie == 0) {
1943                 uint64_t cookie = 0;
1944                 int len = sizeof (zc->zc_name) - (p - zc->zc_name);
1945
1946                 while (dmu_dir_list_next(os, len, p, NULL, &cookie) == 0)
1947                         (void) dmu_objset_prefetch(p, NULL);
1948         }
1949
1950         do {
1951                 error = dmu_dir_list_next(os,
1952                     sizeof (zc->zc_name) - (p - zc->zc_name), p,
1953                     NULL, &zc->zc_cookie);
1954                 if (error == ENOENT)
1955                         error = ESRCH;
1956         } while (error == 0 && dataset_name_hidden(zc->zc_name) &&
1957             !(zc->zc_iflags & FKIOCTL));
1958         dmu_objset_rele(os, FTAG);
1959
1960         /*
1961          * If it's an internal dataset (ie. with a '$' in its name),
1962          * don't try to get stats for it, otherwise we'll return ENOENT.
1963          */
1964         if (error == 0 && strchr(zc->zc_name, '$') == NULL) {
1965                 error = zfs_ioc_objset_stats(zc); /* fill in the stats */
1966                 if (error == ENOENT) {
1967                         /* We lost a race with destroy, get the next one. */
1968                         zc->zc_name[orig_len] = '\0';
1969                         goto top;
1970                 }
1971         }
1972         return (error);
1973 }
1974
1975 /*
1976  * inputs:
1977  * zc_name              name of filesystem
1978  * zc_cookie            zap cursor
1979  * zc_nvlist_dst_size   size of buffer for property nvlist
1980  *
1981  * outputs:
1982  * zc_name              name of next snapshot
1983  * zc_objset_stats      stats
1984  * zc_nvlist_dst        property nvlist
1985  * zc_nvlist_dst_size   size of property nvlist
1986  */
1987 static int
1988 zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
1989 {
1990         objset_t *os;
1991         int error;
1992
1993 top:
1994         if (zc->zc_cookie == 0)
1995                 (void) dmu_objset_find(zc->zc_name, dmu_objset_prefetch,
1996                     NULL, DS_FIND_SNAPSHOTS);
1997
1998         error = dmu_objset_hold(zc->zc_name, FTAG, &os);
1999         if (error)
2000                 return (error == ENOENT ? ESRCH : error);
2001
2002         /*
2003          * A dataset name of maximum length cannot have any snapshots,
2004          * so exit immediately.
2005          */
2006         if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >= MAXNAMELEN) {
2007                 dmu_objset_rele(os, FTAG);
2008                 return (ESRCH);
2009         }
2010
2011         error = dmu_snapshot_list_next(os,
2012             sizeof (zc->zc_name) - strlen(zc->zc_name),
2013             zc->zc_name + strlen(zc->zc_name), &zc->zc_obj, &zc->zc_cookie,
2014             NULL);
2015
2016         if (error == 0) {
2017                 dsl_dataset_t *ds;
2018                 dsl_pool_t *dp = os->os_dsl_dataset->ds_dir->dd_pool;
2019
2020                 /*
2021                  * Since we probably don't have a hold on this snapshot,
2022                  * it's possible that the objsetid could have been destroyed
2023                  * and reused for a new objset. It's OK if this happens during
2024                  * a zfs send operation, since the new createtxg will be
2025                  * beyond the range we're interested in.
2026                  */
2027                 rw_enter(&dp->dp_config_rwlock, RW_READER);
2028                 error = dsl_dataset_hold_obj(dp, zc->zc_obj, FTAG, &ds);
2029                 rw_exit(&dp->dp_config_rwlock);
2030                 if (error) {
2031                         if (error == ENOENT) {
2032                                 /* Racing with destroy, get the next one. */
2033                                 *strchr(zc->zc_name, '@') = '\0';
2034                                 dmu_objset_rele(os, FTAG);
2035                                 goto top;
2036                         }
2037                 } else {
2038                         objset_t *ossnap;
2039
2040                         error = dmu_objset_from_ds(ds, &ossnap);
2041                         if (error == 0)
2042                                 error = zfs_ioc_objset_stats_impl(zc, ossnap);
2043                         dsl_dataset_rele(ds, FTAG);
2044                 }
2045         } else if (error == ENOENT) {
2046                 error = ESRCH;
2047         }
2048
2049         dmu_objset_rele(os, FTAG);
2050         /* if we failed, undo the @ that we tacked on to zc_name */
2051         if (error)
2052                 *strchr(zc->zc_name, '@') = '\0';
2053         return (error);
2054 }
2055
2056 static int
2057 zfs_prop_set_userquota(const char *dsname, nvpair_t *pair)
2058 {
2059         const char *propname = nvpair_name(pair);
2060         uint64_t *valary;
2061         unsigned int vallen;
2062         const char *domain;
2063         char *dash;
2064         zfs_userquota_prop_t type;
2065         uint64_t rid;
2066         uint64_t quota;
2067         zfsvfs_t *zfsvfs;
2068         int err;
2069
2070         if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2071                 nvlist_t *attrs;
2072                 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2073                 if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2074                     &pair) != 0)
2075                         return (EINVAL);
2076         }
2077
2078         /*
2079          * A correctly constructed propname is encoded as
2080          * userquota@<rid>-<domain>.
2081          */
2082         if ((dash = strchr(propname, '-')) == NULL ||
2083             nvpair_value_uint64_array(pair, &valary, &vallen) != 0 ||
2084             vallen != 3)
2085                 return (EINVAL);
2086
2087         domain = dash + 1;
2088         type = valary[0];
2089         rid = valary[1];
2090         quota = valary[2];
2091
2092         err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE);
2093         if (err == 0) {
2094                 err = zfs_set_userquota(zfsvfs, type, domain, rid, quota);
2095                 zfsvfs_rele(zfsvfs, FTAG);
2096         }
2097
2098         return (err);
2099 }
2100
2101 /*
2102  * If the named property is one that has a special function to set its value,
2103  * return 0 on success and a positive error code on failure; otherwise if it is
2104  * not one of the special properties handled by this function, return -1.
2105  *
2106  * XXX: It would be better for callers of the property interface if we handled
2107  * these special cases in dsl_prop.c (in the dsl layer).
2108  */
2109 static int
2110 zfs_prop_set_special(const char *dsname, zprop_source_t source,
2111     nvpair_t *pair)
2112 {
2113         const char *propname = nvpair_name(pair);
2114         zfs_prop_t prop = zfs_name_to_prop(propname);
2115         uint64_t intval;
2116         int err;
2117
2118         if (prop == ZPROP_INVAL) {
2119                 if (zfs_prop_userquota(propname))
2120                         return (zfs_prop_set_userquota(dsname, pair));
2121                 return (-1);
2122         }
2123
2124         if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2125                 nvlist_t *attrs;
2126                 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2127                 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2128                     &pair) == 0);
2129         }
2130
2131         if (zfs_prop_get_type(prop) == PROP_TYPE_STRING)
2132                 return (-1);
2133
2134         VERIFY(0 == nvpair_value_uint64(pair, &intval));
2135
2136         switch (prop) {
2137         case ZFS_PROP_QUOTA:
2138                 err = dsl_dir_set_quota(dsname, source, intval);
2139                 break;
2140         case ZFS_PROP_REFQUOTA:
2141                 err = dsl_dataset_set_quota(dsname, source, intval);
2142                 break;
2143         case ZFS_PROP_RESERVATION:
2144                 err = dsl_dir_set_reservation(dsname, source, intval);
2145                 break;
2146         case ZFS_PROP_REFRESERVATION:
2147                 err = dsl_dataset_set_reservation(dsname, source, intval);
2148                 break;
2149         case ZFS_PROP_VOLSIZE:
2150                 err = zvol_set_volsize(dsname, ddi_driver_major(zfs_dip),
2151                     intval);
2152                 break;
2153         case ZFS_PROP_VERSION:
2154         {
2155                 zfsvfs_t *zfsvfs;
2156
2157                 if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_TRUE)) != 0)
2158                         break;
2159
2160                 err = zfs_set_version(zfsvfs, intval);
2161                 zfsvfs_rele(zfsvfs, FTAG);
2162
2163                 if (err == 0 && intval >= ZPL_VERSION_USERSPACE) {
2164                         zfs_cmd_t *zc;
2165
2166                         zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
2167                         (void) strcpy(zc->zc_name, dsname);
2168                         (void) zfs_ioc_userspace_upgrade(zc);
2169                         kmem_free(zc, sizeof (zfs_cmd_t));
2170                 }
2171                 break;
2172         }
2173
2174         default:
2175                 err = -1;
2176         }
2177
2178         return (err);
2179 }
2180
2181 /*
2182  * This function is best effort. If it fails to set any of the given properties,
2183  * it continues to set as many as it can and returns the first error
2184  * encountered. If the caller provides a non-NULL errlist, it also gives the
2185  * complete list of names of all the properties it failed to set along with the
2186  * corresponding error numbers. The caller is responsible for freeing the
2187  * returned errlist.
2188  *
2189  * If every property is set successfully, zero is returned and the list pointed
2190  * at by errlist is NULL.
2191  */
2192 int
2193 zfs_set_prop_nvlist(const char *dsname, zprop_source_t source, nvlist_t *nvl,
2194     nvlist_t **errlist)
2195 {
2196         nvpair_t *pair;
2197         nvpair_t *propval;
2198         int rv = 0;
2199         uint64_t intval;
2200         char *strval;
2201         nvlist_t *genericnvl;
2202         nvlist_t *errors;
2203         nvlist_t *retrynvl;
2204
2205         VERIFY(nvlist_alloc(&genericnvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2206         VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2207         VERIFY(nvlist_alloc(&retrynvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2208
2209 retry:
2210         pair = NULL;
2211         while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2212                 const char *propname = nvpair_name(pair);
2213                 zfs_prop_t prop = zfs_name_to_prop(propname);
2214                 int err = 0;
2215
2216                 /* decode the property value */
2217                 propval = pair;
2218                 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2219                         nvlist_t *attrs;
2220                         VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2221                         if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2222                             &propval) != 0)
2223                                 err = EINVAL;
2224                 }
2225
2226                 /* Validate value type */
2227                 if (err == 0 && prop == ZPROP_INVAL) {
2228                         if (zfs_prop_user(propname)) {
2229                                 if (nvpair_type(propval) != DATA_TYPE_STRING)
2230                                         err = EINVAL;
2231                         } else if (zfs_prop_userquota(propname)) {
2232                                 if (nvpair_type(propval) !=
2233                                     DATA_TYPE_UINT64_ARRAY)
2234                                         err = EINVAL;
2235                         }
2236                 } else if (err == 0) {
2237                         if (nvpair_type(propval) == DATA_TYPE_STRING) {
2238                                 if (zfs_prop_get_type(prop) != PROP_TYPE_STRING)
2239                                         err = EINVAL;
2240                         } else if (nvpair_type(propval) == DATA_TYPE_UINT64) {
2241                                 const char *unused;
2242
2243                                 VERIFY(nvpair_value_uint64(propval,
2244                                     &intval) == 0);
2245
2246                                 switch (zfs_prop_get_type(prop)) {
2247                                 case PROP_TYPE_NUMBER:
2248                                         break;
2249                                 case PROP_TYPE_STRING:
2250                                         err = EINVAL;
2251                                         break;
2252                                 case PROP_TYPE_INDEX:
2253                                         if (zfs_prop_index_to_string(prop,
2254                                             intval, &unused) != 0)
2255                                                 err = EINVAL;
2256                                         break;
2257                                 default:
2258                                         cmn_err(CE_PANIC,
2259                                             "unknown property type");
2260                                 }
2261                         } else {
2262                                 err = EINVAL;
2263                         }
2264                 }
2265
2266                 /* Validate permissions */
2267                 if (err == 0)
2268                         err = zfs_check_settable(dsname, pair, CRED());
2269
2270                 if (err == 0) {
2271                         err = zfs_prop_set_special(dsname, source, pair);
2272                         if (err == -1) {
2273                                 /*
2274                                  * For better performance we build up a list of
2275                                  * properties to set in a single transaction.
2276                                  */
2277                                 err = nvlist_add_nvpair(genericnvl, pair);
2278                         } else if (err != 0 && nvl != retrynvl) {
2279                                 /*
2280                                  * This may be a spurious error caused by
2281                                  * receiving quota and reservation out of order.
2282                                  * Try again in a second pass.
2283                                  */
2284                                 err = nvlist_add_nvpair(retrynvl, pair);
2285                         }
2286                 }
2287
2288                 if (err != 0)
2289                         VERIFY(nvlist_add_int32(errors, propname, err) == 0);
2290         }
2291
2292         if (nvl != retrynvl && !nvlist_empty(retrynvl)) {
2293                 nvl = retrynvl;
2294                 goto retry;
2295         }
2296
2297         if (!nvlist_empty(genericnvl) &&
2298             dsl_props_set(dsname, source, genericnvl) != 0) {
2299                 /*
2300                  * If this fails, we still want to set as many properties as we
2301                  * can, so try setting them individually.
2302                  */
2303                 pair = NULL;
2304                 while ((pair = nvlist_next_nvpair(genericnvl, pair)) != NULL) {
2305                         const char *propname = nvpair_name(pair);
2306                         int err = 0;
2307
2308                         propval = pair;
2309                         if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2310                                 nvlist_t *attrs;
2311                                 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2312                                 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2313                                     &propval) == 0);
2314                         }
2315
2316                         if (nvpair_type(propval) == DATA_TYPE_STRING) {
2317                                 VERIFY(nvpair_value_string(propval,
2318                                     &strval) == 0);
2319                                 err = dsl_prop_set(dsname, propname, source, 1,
2320                                     strlen(strval) + 1, strval);
2321                         } else {
2322                                 VERIFY(nvpair_value_uint64(propval,
2323                                     &intval) == 0);
2324                                 err = dsl_prop_set(dsname, propname, source, 8,
2325                                     1, &intval);
2326                         }
2327
2328                         if (err != 0) {
2329                                 VERIFY(nvlist_add_int32(errors, propname,
2330                                     err) == 0);
2331                         }
2332                 }
2333         }
2334         nvlist_free(genericnvl);
2335         nvlist_free(retrynvl);
2336
2337         if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
2338                 nvlist_free(errors);
2339                 errors = NULL;
2340         } else {
2341                 VERIFY(nvpair_value_int32(pair, &rv) == 0);
2342         }
2343
2344         if (errlist == NULL)
2345                 nvlist_free(errors);
2346         else
2347                 *errlist = errors;
2348
2349         return (rv);
2350 }
2351
2352 /*
2353  * Check that all the properties are valid user properties.
2354  */
2355 static int
2356 zfs_check_userprops(char *fsname, nvlist_t *nvl)
2357 {
2358         nvpair_t *pair = NULL;
2359         int error = 0;
2360
2361         while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2362                 const char *propname = nvpair_name(pair);
2363                 char *valstr;
2364
2365                 if (!zfs_prop_user(propname) ||
2366                     nvpair_type(pair) != DATA_TYPE_STRING)
2367                         return (EINVAL);
2368
2369                 if (error = zfs_secpolicy_write_perms(fsname,
2370                     ZFS_DELEG_PERM_USERPROP, CRED()))
2371                         return (error);
2372
2373                 if (strlen(propname) >= ZAP_MAXNAMELEN)
2374                         return (ENAMETOOLONG);
2375
2376                 VERIFY(nvpair_value_string(pair, &valstr) == 0);
2377                 if (strlen(valstr) >= ZAP_MAXVALUELEN)
2378                         return (E2BIG);
2379         }
2380         return (0);
2381 }
2382
2383 static void
2384 props_skip(nvlist_t *props, nvlist_t *skipped, nvlist_t **newprops)
2385 {
2386         nvpair_t *pair;
2387
2388         VERIFY(nvlist_alloc(newprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2389
2390         pair = NULL;
2391         while ((pair = nvlist_next_nvpair(props, pair)) != NULL) {
2392                 if (nvlist_exists(skipped, nvpair_name(pair)))
2393                         continue;
2394
2395                 VERIFY(nvlist_add_nvpair(*newprops, pair) == 0);
2396         }
2397 }
2398
2399 static int
2400 clear_received_props(objset_t *os, const char *fs, nvlist_t *props,
2401     nvlist_t *skipped)
2402 {
2403         int err = 0;
2404         nvlist_t *cleared_props = NULL;
2405         props_skip(props, skipped, &cleared_props);
2406         if (!nvlist_empty(cleared_props)) {
2407                 /*
2408                  * Acts on local properties until the dataset has received
2409                  * properties at least once on or after SPA_VERSION_RECVD_PROPS.
2410                  */
2411                 zprop_source_t flags = (ZPROP_SRC_NONE |
2412                     (dsl_prop_get_hasrecvd(os) ? ZPROP_SRC_RECEIVED : 0));
2413                 err = zfs_set_prop_nvlist(fs, flags, cleared_props, NULL);
2414         }
2415         nvlist_free(cleared_props);
2416         return (err);
2417 }
2418
2419 /*
2420  * inputs:
2421  * zc_name              name of filesystem
2422  * zc_value             name of property to set
2423  * zc_nvlist_src{_size} nvlist of properties to apply
2424  * zc_cookie            received properties flag
2425  *
2426  * outputs:
2427  * zc_nvlist_dst{_size} error for each unapplied received property
2428  */
2429 static int
2430 zfs_ioc_set_prop(zfs_cmd_t *zc)
2431 {
2432         nvlist_t *nvl;
2433         boolean_t received = zc->zc_cookie;
2434         zprop_source_t source = (received ? ZPROP_SRC_RECEIVED :
2435             ZPROP_SRC_LOCAL);
2436         nvlist_t *errors = NULL;
2437         int error;
2438
2439         if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2440             zc->zc_iflags, &nvl)) != 0)
2441                 return (error);
2442
2443         if (received) {
2444                 nvlist_t *origprops;
2445                 objset_t *os;
2446
2447                 if (dmu_objset_hold(zc->zc_name, FTAG, &os) == 0) {
2448                         if (dsl_prop_get_received(os, &origprops) == 0) {
2449                                 (void) clear_received_props(os,
2450                                     zc->zc_name, origprops, nvl);
2451                                 nvlist_free(origprops);
2452                         }
2453
2454                         dsl_prop_set_hasrecvd(os);
2455                         dmu_objset_rele(os, FTAG);
2456                 }
2457         }
2458
2459         error = zfs_set_prop_nvlist(zc->zc_name, source, nvl, &errors);
2460
2461         if (zc->zc_nvlist_dst != 0 && errors != NULL) {
2462                 (void) put_nvlist(zc, errors);
2463         }
2464
2465         nvlist_free(errors);
2466         nvlist_free(nvl);
2467         return (error);
2468 }
2469
2470 /*
2471  * inputs:
2472  * zc_name              name of filesystem
2473  * zc_value             name of property to inherit
2474  * zc_cookie            revert to received value if TRUE
2475  *
2476  * outputs:             none
2477  */
2478 static int
2479 zfs_ioc_inherit_prop(zfs_cmd_t *zc)
2480 {
2481         const char *propname = zc->zc_value;
2482         zfs_prop_t prop = zfs_name_to_prop(propname);
2483         boolean_t received = zc->zc_cookie;
2484         zprop_source_t source = (received
2485             ? ZPROP_SRC_NONE            /* revert to received value, if any */
2486             : ZPROP_SRC_INHERITED);     /* explicitly inherit */
2487
2488         if (received) {
2489                 nvlist_t *dummy;
2490                 nvpair_t *pair;
2491                 zprop_type_t type;
2492                 int err;
2493
2494                 /*
2495                  * zfs_prop_set_special() expects properties in the form of an
2496                  * nvpair with type info.
2497                  */
2498                 if (prop == ZPROP_INVAL) {
2499                         if (!zfs_prop_user(propname))
2500                                 return (EINVAL);
2501
2502                         type = PROP_TYPE_STRING;
2503                 } else if (prop == ZFS_PROP_VOLSIZE ||
2504                     prop == ZFS_PROP_VERSION) {
2505                         return (EINVAL);
2506                 } else {
2507                         type = zfs_prop_get_type(prop);
2508                 }
2509
2510                 VERIFY(nvlist_alloc(&dummy, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2511
2512                 switch (type) {
2513                 case PROP_TYPE_STRING:
2514                         VERIFY(0 == nvlist_add_string(dummy, propname, ""));
2515                         break;
2516                 case PROP_TYPE_NUMBER:
2517                 case PROP_TYPE_INDEX:
2518                         VERIFY(0 == nvlist_add_uint64(dummy, propname, 0));
2519                         break;
2520                 default:
2521                         nvlist_free(dummy);
2522                         return (EINVAL);
2523                 }
2524
2525                 pair = nvlist_next_nvpair(dummy, NULL);
2526                 err = zfs_prop_set_special(zc->zc_name, source, pair);
2527                 nvlist_free(dummy);
2528                 if (err != -1)
2529                         return (err); /* special property already handled */
2530         } else {
2531                 /*
2532                  * Only check this in the non-received case. We want to allow
2533                  * 'inherit -S' to revert non-inheritable properties like quota
2534                  * and reservation to the received or default values even though
2535                  * they are not considered inheritable.
2536                  */
2537                 if (prop != ZPROP_INVAL && !zfs_prop_inheritable(prop))
2538                         return (EINVAL);
2539         }
2540
2541         /* the property name has been validated by zfs_secpolicy_inherit() */
2542         return (dsl_prop_set(zc->zc_name, zc->zc_value, source, 0, 0, NULL));
2543 }
2544
2545 static int
2546 zfs_ioc_pool_set_props(zfs_cmd_t *zc)
2547 {
2548         nvlist_t *props;
2549         spa_t *spa;
2550         int error;
2551         nvpair_t *pair;
2552
2553         if (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2554             zc->zc_iflags, &props))
2555                 return (error);
2556
2557         /*
2558          * If the only property is the configfile, then just do a spa_lookup()
2559          * to handle the faulted case.
2560          */
2561         pair = nvlist_next_nvpair(props, NULL);
2562         if (pair != NULL && strcmp(nvpair_name(pair),
2563             zpool_prop_to_name(ZPOOL_PROP_CACHEFILE)) == 0 &&
2564             nvlist_next_nvpair(props, pair) == NULL) {
2565                 mutex_enter(&spa_namespace_lock);
2566                 if ((spa = spa_lookup(zc->zc_name)) != NULL) {
2567                         spa_configfile_set(spa, props, B_FALSE);
2568                         spa_config_sync(spa, B_FALSE, B_TRUE);
2569                 }
2570                 mutex_exit(&spa_namespace_lock);
2571                 if (spa != NULL) {
2572                         nvlist_free(props);
2573                         return (0);
2574                 }
2575         }
2576
2577         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2578                 nvlist_free(props);
2579                 return (error);
2580         }
2581
2582         error = spa_prop_set(spa, props);
2583
2584         nvlist_free(props);
2585         spa_close(spa, FTAG);
2586
2587         return (error);
2588 }
2589
2590 static int
2591 zfs_ioc_pool_get_props(zfs_cmd_t *zc)
2592 {
2593         spa_t *spa;
2594         int error;
2595         nvlist_t *nvp = NULL;
2596
2597         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2598                 /*
2599                  * If the pool is faulted, there may be properties we can still
2600                  * get (such as altroot and cachefile), so attempt to get them
2601                  * anyway.
2602                  */
2603                 mutex_enter(&spa_namespace_lock);
2604                 if ((spa = spa_lookup(zc->zc_name)) != NULL)
2605                         error = spa_prop_get(spa, &nvp);
2606                 mutex_exit(&spa_namespace_lock);
2607         } else {
2608                 error = spa_prop_get(spa, &nvp);
2609                 spa_close(spa, FTAG);
2610         }
2611
2612         if (error == 0 && zc->zc_nvlist_dst != 0)
2613                 error = put_nvlist(zc, nvp);
2614         else
2615                 error = EFAULT;
2616
2617         nvlist_free(nvp);
2618         return (error);
2619 }
2620
2621 /*
2622  * inputs:
2623  * zc_name              name of filesystem
2624  * zc_nvlist_src{_size} nvlist of delegated permissions
2625  * zc_perm_action       allow/unallow flag
2626  *
2627  * outputs:             none
2628  */
2629 static int
2630 zfs_ioc_set_fsacl(zfs_cmd_t *zc)
2631 {
2632         int error;
2633         nvlist_t *fsaclnv = NULL;
2634
2635         if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2636             zc->zc_iflags, &fsaclnv)) != 0)
2637                 return (error);
2638
2639         /*
2640          * Verify nvlist is constructed correctly
2641          */
2642         if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) {
2643                 nvlist_free(fsaclnv);
2644                 return (EINVAL);
2645         }
2646
2647         /*
2648          * If we don't have PRIV_SYS_MOUNT, then validate
2649          * that user is allowed to hand out each permission in
2650          * the nvlist(s)
2651          */
2652
2653         error = secpolicy_zfs(CRED());
2654         if (error) {
2655                 if (zc->zc_perm_action == B_FALSE) {
2656                         error = dsl_deleg_can_allow(zc->zc_name,
2657                             fsaclnv, CRED());
2658                 } else {
2659                         error = dsl_deleg_can_unallow(zc->zc_name,
2660                             fsaclnv, CRED());
2661                 }
2662         }
2663
2664         if (error == 0)
2665                 error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action);
2666
2667         nvlist_free(fsaclnv);
2668         return (error);
2669 }
2670
2671 /*
2672  * inputs:
2673  * zc_name              name of filesystem
2674  *
2675  * outputs:
2676  * zc_nvlist_src{_size} nvlist of delegated permissions
2677  */
2678 static int
2679 zfs_ioc_get_fsacl(zfs_cmd_t *zc)
2680 {
2681         nvlist_t *nvp;
2682         int error;
2683
2684         if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) {
2685                 error = put_nvlist(zc, nvp);
2686                 nvlist_free(nvp);
2687         }
2688
2689         return (error);
2690 }
2691
2692 /*
2693  * Search the vfs list for a specified resource.  Returns a pointer to it
2694  * or NULL if no suitable entry is found. The caller of this routine
2695  * is responsible for releasing the returned vfs pointer.
2696  */
2697 static vfs_t *
2698 zfs_get_vfs(const char *resource)
2699 {
2700         struct vfs *vfsp;
2701         struct vfs *vfs_found = NULL;
2702
2703         vfs_list_read_lock();
2704         vfsp = rootvfs;
2705         do {
2706                 if (strcmp(refstr_value(vfsp->vfs_resource), resource) == 0) {
2707                         VFS_HOLD(vfsp);
2708                         vfs_found = vfsp;
2709                         break;
2710                 }
2711                 vfsp = vfsp->vfs_next;
2712         } while (vfsp != rootvfs);
2713         vfs_list_unlock();
2714         return (vfs_found);
2715 }
2716
2717 /* ARGSUSED */
2718 static void
2719 zfs_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
2720 {
2721         zfs_creat_t *zct = arg;
2722
2723         zfs_create_fs(os, cr, zct->zct_zplprops, tx);
2724 }
2725
2726 #define ZFS_PROP_UNDEFINED      ((uint64_t)-1)
2727
2728 /*
2729  * inputs:
2730  * createprops          list of properties requested by creator
2731  * default_zplver       zpl version to use if unspecified in createprops
2732  * fuids_ok             fuids allowed in this version of the spa?
2733  * os                   parent objset pointer (NULL if root fs)
2734  *
2735  * outputs:
2736  * zplprops     values for the zplprops we attach to the master node object
2737  * is_ci        true if requested file system will be purely case-insensitive
2738  *
2739  * Determine the settings for utf8only, normalization and
2740  * casesensitivity.  Specific values may have been requested by the
2741  * creator and/or we can inherit values from the parent dataset.  If
2742  * the file system is of too early a vintage, a creator can not
2743  * request settings for these properties, even if the requested
2744  * setting is the default value.  We don't actually want to create dsl
2745  * properties for these, so remove them from the source nvlist after
2746  * processing.
2747  */
2748 static int
2749 zfs_fill_zplprops_impl(objset_t *os, uint64_t zplver,
2750     boolean_t fuids_ok, boolean_t sa_ok, nvlist_t *createprops,
2751     nvlist_t *zplprops, boolean_t *is_ci)
2752 {
2753         uint64_t sense = ZFS_PROP_UNDEFINED;
2754         uint64_t norm = ZFS_PROP_UNDEFINED;
2755         uint64_t u8 = ZFS_PROP_UNDEFINED;
2756
2757         ASSERT(zplprops != NULL);
2758
2759         /*
2760          * Pull out creator prop choices, if any.
2761          */
2762         if (createprops) {
2763                 (void) nvlist_lookup_uint64(createprops,
2764                     zfs_prop_to_name(ZFS_PROP_VERSION), &zplver);
2765                 (void) nvlist_lookup_uint64(createprops,
2766                     zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm);
2767                 (void) nvlist_remove_all(createprops,
2768                     zfs_prop_to_name(ZFS_PROP_NORMALIZE));
2769                 (void) nvlist_lookup_uint64(createprops,
2770                     zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8);
2771                 (void) nvlist_remove_all(createprops,
2772                     zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
2773                 (void) nvlist_lookup_uint64(createprops,
2774                     zfs_prop_to_name(ZFS_PROP_CASE), &sense);
2775                 (void) nvlist_remove_all(createprops,
2776                     zfs_prop_to_name(ZFS_PROP_CASE));
2777         }
2778
2779         /*
2780          * If the zpl version requested is whacky or the file system
2781          * or pool is version is too "young" to support normalization
2782          * and the creator tried to set a value for one of the props,
2783          * error out.
2784          */
2785         if ((zplver < ZPL_VERSION_INITIAL || zplver > ZPL_VERSION) ||
2786             (zplver >= ZPL_VERSION_FUID && !fuids_ok) ||
2787             (zplver >= ZPL_VERSION_SA && !sa_ok) ||
2788             (zplver < ZPL_VERSION_NORMALIZATION &&
2789             (norm != ZFS_PROP_UNDEFINED || u8 != ZFS_PROP_UNDEFINED ||
2790             sense != ZFS_PROP_UNDEFINED)))
2791                 return (ENOTSUP);
2792
2793         /*
2794          * Put the version in the zplprops
2795          */
2796         VERIFY(nvlist_add_uint64(zplprops,
2797             zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0);
2798
2799         if (norm == ZFS_PROP_UNDEFINED)
2800                 VERIFY(zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm) == 0);
2801         VERIFY(nvlist_add_uint64(zplprops,
2802             zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0);
2803
2804         /*
2805          * If we're normalizing, names must always be valid UTF-8 strings.
2806          */
2807         if (norm)
2808                 u8 = 1;
2809         if (u8 == ZFS_PROP_UNDEFINED)
2810                 VERIFY(zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8) == 0);
2811         VERIFY(nvlist_add_uint64(zplprops,
2812             zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0);
2813
2814         if (sense == ZFS_PROP_UNDEFINED)
2815                 VERIFY(zfs_get_zplprop(os, ZFS_PROP_CASE, &sense) == 0);
2816         VERIFY(nvlist_add_uint64(zplprops,
2817             zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0);
2818
2819         if (is_ci)
2820                 *is_ci = (sense == ZFS_CASE_INSENSITIVE);
2821
2822         return (0);
2823 }
2824
2825 static int
2826 zfs_fill_zplprops(const char *dataset, nvlist_t *createprops,
2827     nvlist_t *zplprops, boolean_t *is_ci)
2828 {
2829         boolean_t fuids_ok, sa_ok;
2830         uint64_t zplver = ZPL_VERSION;
2831         objset_t *os = NULL;
2832         char parentname[MAXNAMELEN];
2833         char *cp;
2834         spa_t *spa;
2835         uint64_t spa_vers;
2836         int error;
2837
2838         (void) strlcpy(parentname, dataset, sizeof (parentname));
2839         cp = strrchr(parentname, '/');
2840         ASSERT(cp != NULL);
2841         cp[0] = '\0';
2842
2843         if ((error = spa_open(dataset, &spa, FTAG)) != 0)
2844                 return (error);
2845
2846         spa_vers = spa_version(spa);
2847         spa_close(spa, FTAG);
2848
2849         zplver = zfs_zpl_version_map(spa_vers);
2850         fuids_ok = (zplver >= ZPL_VERSION_FUID);
2851         sa_ok = (zplver >= ZPL_VERSION_SA);
2852
2853         /*
2854          * Open parent object set so we can inherit zplprop values.
2855          */
2856         if ((error = dmu_objset_hold(parentname, FTAG, &os)) != 0)
2857                 return (error);
2858
2859         error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, sa_ok, createprops,
2860             zplprops, is_ci);
2861         dmu_objset_rele(os, FTAG);
2862         return (error);
2863 }
2864
2865 static int
2866 zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops,
2867     nvlist_t *zplprops, boolean_t *is_ci)
2868 {
2869         boolean_t fuids_ok;
2870         boolean_t sa_ok;
2871         uint64_t zplver = ZPL_VERSION;
2872         int error;
2873
2874         zplver = zfs_zpl_version_map(spa_vers);
2875         fuids_ok = (zplver >= ZPL_VERSION_FUID);
2876         sa_ok = (zplver >= ZPL_VERSION_SA);
2877
2878         error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, sa_ok,
2879             createprops, zplprops, is_ci);
2880         return (error);
2881 }
2882
2883 /*
2884  * inputs:
2885  * zc_objset_type       type of objset to create (fs vs zvol)
2886  * zc_name              name of new objset
2887  * zc_value             name of snapshot to clone from (may be empty)
2888  * zc_nvlist_src{_size} nvlist of properties to apply
2889  *
2890  * outputs: none
2891  */
2892 static int
2893 zfs_ioc_create(zfs_cmd_t *zc)
2894 {
2895         objset_t *clone;
2896         int error = 0;
2897         zfs_creat_t zct;
2898         nvlist_t *nvprops = NULL;
2899         void (*cbfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx);
2900         dmu_objset_type_t type = zc->zc_objset_type;
2901
2902         switch (type) {
2903
2904         case DMU_OST_ZFS:
2905                 cbfunc = zfs_create_cb;
2906                 break;
2907
2908         case DMU_OST_ZVOL:
2909                 cbfunc = zvol_create_cb;
2910                 break;
2911
2912         default:
2913                 cbfunc = NULL;
2914                 break;
2915         }
2916         if (strchr(zc->zc_name, '@') ||
2917             strchr(zc->zc_name, '%'))
2918                 return (EINVAL);
2919
2920         if (zc->zc_nvlist_src != 0 &&
2921             (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2922             zc->zc_iflags, &nvprops)) != 0)
2923                 return (error);
2924
2925         zct.zct_zplprops = NULL;
2926         zct.zct_props = nvprops;
2927
2928         if (zc->zc_value[0] != '\0') {
2929                 /*
2930                  * We're creating a clone of an existing snapshot.
2931                  */
2932                 zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
2933                 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0) {
2934                         nvlist_free(nvprops);
2935                         return (EINVAL);
2936                 }
2937
2938                 error = dmu_objset_hold(zc->zc_value, FTAG, &clone);
2939                 if (error) {
2940                         nvlist_free(nvprops);
2941                         return (error);
2942                 }
2943
2944                 error = dmu_objset_clone(zc->zc_name, dmu_objset_ds(clone), 0);
2945                 dmu_objset_rele(clone, FTAG);
2946                 if (error) {
2947                         nvlist_free(nvprops);
2948                         return (error);
2949                 }
2950         } else {
2951                 boolean_t is_insensitive = B_FALSE;
2952
2953                 if (cbfunc == NULL) {
2954                         nvlist_free(nvprops);
2955                         return (EINVAL);
2956                 }
2957
2958                 if (type == DMU_OST_ZVOL) {
2959                         uint64_t volsize, volblocksize;
2960
2961                         if (nvprops == NULL ||
2962                             nvlist_lookup_uint64(nvprops,
2963                             zfs_prop_to_name(ZFS_PROP_VOLSIZE),
2964                             &volsize) != 0) {
2965                                 nvlist_free(nvprops);
2966                                 return (EINVAL);
2967                         }
2968
2969                         if ((error = nvlist_lookup_uint64(nvprops,
2970                             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
2971                             &volblocksize)) != 0 && error != ENOENT) {
2972                                 nvlist_free(nvprops);
2973                                 return (EINVAL);
2974                         }
2975
2976                         if (error != 0)
2977                                 volblocksize = zfs_prop_default_numeric(
2978                                     ZFS_PROP_VOLBLOCKSIZE);
2979
2980                         if ((error = zvol_check_volblocksize(
2981                             volblocksize)) != 0 ||
2982                             (error = zvol_check_volsize(volsize,
2983                             volblocksize)) != 0) {
2984                                 nvlist_free(nvprops);
2985                                 return (error);
2986                         }
2987                 } else if (type == DMU_OST_ZFS) {
2988                         int error;
2989
2990                         /*
2991                          * We have to have normalization and
2992                          * case-folding flags correct when we do the
2993                          * file system creation, so go figure them out
2994                          * now.
2995                          */
2996                         VERIFY(nvlist_alloc(&zct.zct_zplprops,
2997                             NV_UNIQUE_NAME, KM_SLEEP) == 0);
2998                         error = zfs_fill_zplprops(zc->zc_name, nvprops,
2999                             zct.zct_zplprops, &is_insensitive);
3000                         if (error != 0) {
3001                                 nvlist_free(nvprops);
3002                                 nvlist_free(zct.zct_zplprops);
3003                                 return (error);
3004                         }
3005                 }
3006                 error = dmu_objset_create(zc->zc_name, type,
3007                     is_insensitive ? DS_FLAG_CI_DATASET : 0, cbfunc, &zct);
3008                 nvlist_free(zct.zct_zplprops);
3009         }
3010
3011         /*
3012          * It would be nice to do this atomically.
3013          */
3014         if (error == 0) {
3015                 error = zfs_set_prop_nvlist(zc->zc_name, ZPROP_SRC_LOCAL,
3016                     nvprops, NULL);
3017                 if (error != 0)
3018                         (void) dmu_objset_destroy(zc->zc_name, B_FALSE);
3019         }
3020         nvlist_free(nvprops);
3021         return (error);
3022 }
3023
3024 /*
3025  * inputs:
3026  * zc_name      name of filesystem
3027  * zc_value     short name of snapshot
3028  * zc_cookie    recursive flag
3029  * zc_nvlist_src[_size] property list
3030  *
3031  * outputs:
3032  * zc_value     short snapname (i.e. part after the '@')
3033  */
3034 static int
3035 zfs_ioc_snapshot(zfs_cmd_t *zc)
3036 {
3037         nvlist_t *nvprops = NULL;
3038         int error;
3039         boolean_t recursive = zc->zc_cookie;
3040
3041         if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
3042                 return (EINVAL);
3043
3044         if (zc->zc_nvlist_src != 0 &&
3045             (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
3046             zc->zc_iflags, &nvprops)) != 0)
3047                 return (error);
3048
3049         error = zfs_check_userprops(zc->zc_name, nvprops);
3050         if (error)
3051                 goto out;
3052
3053         if (!nvlist_empty(nvprops) &&
3054             zfs_earlier_version(zc->zc_name, SPA_VERSION_SNAP_PROPS)) {
3055                 error = ENOTSUP;
3056                 goto out;
3057         }
3058
3059         error = dmu_objset_snapshot(zc->zc_name, zc->zc_value, NULL,
3060             nvprops, recursive, B_FALSE, -1);
3061
3062 out:
3063         nvlist_free(nvprops);
3064         return (error);
3065 }
3066
3067 int
3068 zfs_unmount_snap(const char *name, void *arg)
3069 {
3070         vfs_t *vfsp = NULL;
3071
3072         if (arg) {
3073                 char *snapname = arg;
3074                 char *fullname = kmem_asprintf("%s@%s", name, snapname);
3075                 vfsp = zfs_get_vfs(fullname);
3076                 strfree(fullname);
3077         } else if (strchr(name, '@')) {
3078                 vfsp = zfs_get_vfs(name);
3079         }
3080
3081         if (vfsp) {
3082                 /*
3083                  * Always force the unmount for snapshots.
3084                  */
3085                 int flag = MS_FORCE;
3086                 int err;
3087
3088                 if ((err = vn_vfswlock(vfsp->vfs_vnodecovered)) != 0) {
3089                         VFS_RELE(vfsp);
3090                         return (err);
3091                 }
3092                 VFS_RELE(vfsp);
3093                 if ((err = dounmount(vfsp, flag, kcred)) != 0)
3094                         return (err);
3095         }
3096         return (0);
3097 }
3098
3099 /*
3100  * inputs:
3101  * zc_name              name of filesystem
3102  * zc_value             short name of snapshot
3103  * zc_defer_destroy     mark for deferred destroy
3104  *
3105  * outputs:     none
3106  */
3107 static int
3108 zfs_ioc_destroy_snaps(zfs_cmd_t *zc)
3109 {
3110         int err;
3111
3112         if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
3113                 return (EINVAL);
3114         err = dmu_objset_find(zc->zc_name,
3115             zfs_unmount_snap, zc->zc_value, DS_FIND_CHILDREN);
3116         if (err)
3117                 return (err);
3118         return (dmu_snapshots_destroy(zc->zc_name, zc->zc_value,
3119             zc->zc_defer_destroy));
3120 }
3121
3122 /*
3123  * inputs:
3124  * zc_name              name of dataset to destroy
3125  * zc_objset_type       type of objset
3126  * zc_defer_destroy     mark for deferred destroy
3127  *
3128  * outputs:             none
3129  */
3130 static int
3131 zfs_ioc_destroy(zfs_cmd_t *zc)
3132 {
3133         int err;
3134         if (strchr(zc->zc_name, '@') && zc->zc_objset_type == DMU_OST_ZFS) {
3135                 err = zfs_unmount_snap(zc->zc_name, NULL);
3136                 if (err)
3137                         return (err);
3138         }
3139
3140         err = dmu_objset_destroy(zc->zc_name, zc->zc_defer_destroy);
3141         if (zc->zc_objset_type == DMU_OST_ZVOL && err == 0)
3142                 (void) zvol_remove_minor(zc->zc_name);
3143         return (err);
3144 }
3145
3146 /*
3147  * inputs:
3148  * zc_name      name of dataset to rollback (to most recent snapshot)
3149  *
3150  * outputs:     none
3151  */
3152 static int
3153 zfs_ioc_rollback(zfs_cmd_t *zc)
3154 {
3155         dsl_dataset_t *ds, *clone;
3156         int error;
3157         zfsvfs_t *zfsvfs;
3158         char *clone_name;
3159
3160         error = dsl_dataset_hold(zc->zc_name, FTAG, &ds);
3161         if (error)
3162                 return (error);
3163
3164         /* must not be a snapshot */
3165         if (dsl_dataset_is_snapshot(ds)) {
3166                 dsl_dataset_rele(ds, FTAG);
3167                 return (EINVAL);
3168         }
3169
3170         /* must have a most recent snapshot */
3171         if (ds->ds_phys->ds_prev_snap_txg < TXG_INITIAL) {
3172                 dsl_dataset_rele(ds, FTAG);
3173                 return (EINVAL);
3174         }
3175
3176         /*
3177          * Create clone of most recent snapshot.
3178          */
3179         clone_name = kmem_asprintf("%s/%%rollback", zc->zc_name);
3180         error = dmu_objset_clone(clone_name, ds->ds_prev, DS_FLAG_INCONSISTENT);
3181         if (error)
3182                 goto out;
3183
3184         error = dsl_dataset_own(clone_name, B_TRUE, FTAG, &clone);
3185         if (error)
3186                 goto out;
3187
3188         /*
3189          * Do clone swap.
3190          */
3191         if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
3192                 error = zfs_suspend_fs(zfsvfs);
3193                 if (error == 0) {
3194                         int resume_err;
3195
3196                         if (dsl_dataset_tryown(ds, B_FALSE, FTAG)) {
3197                                 error = dsl_dataset_clone_swap(clone, ds,
3198                                     B_TRUE);
3199                                 dsl_dataset_disown(ds, FTAG);
3200                                 ds = NULL;
3201                         } else {
3202                                 error = EBUSY;
3203                         }
3204                         resume_err = zfs_resume_fs(zfsvfs, zc->zc_name);
3205                         error = error ? error : resume_err;
3206                 }
3207                 VFS_RELE(zfsvfs->z_vfs);
3208         } else {
3209                 if (dsl_dataset_tryown(ds, B_FALSE, FTAG)) {
3210                         error = dsl_dataset_clone_swap(clone, ds, B_TRUE);
3211                         dsl_dataset_disown(ds, FTAG);
3212                         ds = NULL;
3213                 } else {
3214                         error = EBUSY;
3215                 }
3216         }
3217
3218         /*
3219          * Destroy clone (which also closes it).
3220          */
3221         (void) dsl_dataset_destroy(clone, FTAG, B_FALSE);
3222
3223 out:
3224         strfree(clone_name);
3225         if (ds)
3226                 dsl_dataset_rele(ds, FTAG);
3227         return (error);
3228 }
3229
3230 /*
3231  * inputs:
3232  * zc_name      old name of dataset
3233  * zc_value     new name of dataset
3234  * zc_cookie    recursive flag (only valid for snapshots)
3235  *
3236  * outputs:     none
3237  */
3238 static int
3239 zfs_ioc_rename(zfs_cmd_t *zc)
3240 {
3241         boolean_t recursive = zc->zc_cookie & 1;
3242
3243         zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
3244         if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
3245             strchr(zc->zc_value, '%'))
3246                 return (EINVAL);
3247
3248         /*
3249          * Unmount snapshot unless we're doing a recursive rename,
3250          * in which case the dataset code figures out which snapshots
3251          * to unmount.
3252          */
3253         if (!recursive && strchr(zc->zc_name, '@') != NULL &&
3254             zc->zc_objset_type == DMU_OST_ZFS) {
3255                 int err = zfs_unmount_snap(zc->zc_name, NULL);
3256                 if (err)
3257                         return (err);
3258         }
3259         if (zc->zc_objset_type == DMU_OST_ZVOL)
3260                 (void) zvol_remove_minor(zc->zc_name);
3261         return (dmu_objset_rename(zc->zc_name, zc->zc_value, recursive));
3262 }
3263
3264 static int
3265 zfs_check_settable(const char *dsname, nvpair_t *pair, cred_t *cr)
3266 {
3267         const char *propname = nvpair_name(pair);
3268         boolean_t issnap = (strchr(dsname, '@') != NULL);
3269         zfs_prop_t prop = zfs_name_to_prop(propname);
3270         uint64_t intval;
3271         int err;
3272
3273         if (prop == ZPROP_INVAL) {
3274                 if (zfs_prop_user(propname)) {
3275                         if (err = zfs_secpolicy_write_perms(dsname,
3276                             ZFS_DELEG_PERM_USERPROP, cr))
3277                                 return (err);
3278                         return (0);
3279                 }
3280
3281                 if (!issnap && zfs_prop_userquota(propname)) {
3282                         const char *perm = NULL;
3283                         const char *uq_prefix =
3284                             zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA];
3285                         const char *gq_prefix =
3286                             zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA];
3287
3288                         if (strncmp(propname, uq_prefix,
3289                             strlen(uq_prefix)) == 0) {
3290                                 perm = ZFS_DELEG_PERM_USERQUOTA;
3291                         } else if (strncmp(propname, gq_prefix,
3292                             strlen(gq_prefix)) == 0) {
3293                                 perm = ZFS_DELEG_PERM_GROUPQUOTA;
3294                         } else {
3295                                 /* USERUSED and GROUPUSED are read-only */
3296                                 return (EINVAL);
3297                         }
3298
3299                         if (err = zfs_secpolicy_write_perms(dsname, perm, cr))
3300                                 return (err);
3301                         return (0);
3302                 }
3303
3304                 return (EINVAL);
3305         }
3306
3307         if (issnap)
3308                 return (EINVAL);
3309
3310         if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
3311                 /*
3312                  * dsl_prop_get_all_impl() returns properties in this
3313                  * format.
3314                  */
3315                 nvlist_t *attrs;
3316                 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
3317                 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3318                     &pair) == 0);
3319         }
3320
3321         /*
3322          * Check that this value is valid for this pool version
3323          */
3324         switch (prop) {
3325         case ZFS_PROP_COMPRESSION:
3326                 /*
3327                  * If the user specified gzip compression, make sure
3328                  * the SPA supports it. We ignore any errors here since
3329                  * we'll catch them later.
3330                  */
3331                 if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
3332                     nvpair_value_uint64(pair, &intval) == 0) {
3333                         if (intval >= ZIO_COMPRESS_GZIP_1 &&
3334                             intval <= ZIO_COMPRESS_GZIP_9 &&
3335                             zfs_earlier_version(dsname,
3336                             SPA_VERSION_GZIP_COMPRESSION)) {
3337                                 return (ENOTSUP);
3338                         }
3339
3340                         if (intval == ZIO_COMPRESS_ZLE &&
3341                             zfs_earlier_version(dsname,
3342                             SPA_VERSION_ZLE_COMPRESSION))
3343                                 return (ENOTSUP);
3344
3345                         /*
3346                          * If this is a bootable dataset then
3347                          * verify that the compression algorithm
3348                          * is supported for booting. We must return
3349                          * something other than ENOTSUP since it
3350                          * implies a downrev pool version.
3351                          */
3352                         if (zfs_is_bootfs(dsname) &&
3353                             !BOOTFS_COMPRESS_VALID(intval)) {
3354                                 return (ERANGE);
3355                         }
3356                 }
3357                 break;
3358
3359         case ZFS_PROP_COPIES:
3360                 if (zfs_earlier_version(dsname, SPA_VERSION_DITTO_BLOCKS))
3361                         return (ENOTSUP);
3362                 break;
3363
3364         case ZFS_PROP_DEDUP:
3365                 if (zfs_earlier_version(dsname, SPA_VERSION_DEDUP))
3366                         return (ENOTSUP);
3367                 break;
3368
3369         case ZFS_PROP_SHARESMB:
3370                 if (zpl_earlier_version(dsname, ZPL_VERSION_FUID))
3371                         return (ENOTSUP);
3372                 break;
3373
3374         case ZFS_PROP_ACLINHERIT:
3375                 if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
3376                     nvpair_value_uint64(pair, &intval) == 0) {
3377                         if (intval == ZFS_ACL_PASSTHROUGH_X &&
3378                             zfs_earlier_version(dsname,
3379                             SPA_VERSION_PASSTHROUGH_X))
3380                                 return (ENOTSUP);
3381                 }
3382                 break;
3383         }
3384
3385         return (zfs_secpolicy_setprop(dsname, prop, pair, CRED()));
3386 }
3387
3388 /*
3389  * Removes properties from the given props list that fail permission checks
3390  * needed to clear them and to restore them in case of a receive error. For each
3391  * property, make sure we have both set and inherit permissions.
3392  *
3393  * Returns the first error encountered if any permission checks fail. If the
3394  * caller provides a non-NULL errlist, it also gives the complete list of names
3395  * of all the properties that failed a permission check along with the
3396  * corresponding error numbers. The caller is responsible for freeing the
3397  * returned errlist.
3398  *
3399  * If every property checks out successfully, zero is returned and the list
3400  * pointed at by errlist is NULL.
3401  */
3402 static int
3403 zfs_check_clearable(char *dataset, nvlist_t *props, nvlist_t **errlist)
3404 {
3405         zfs_cmd_t *zc;
3406         nvpair_t *pair, *next_pair;
3407         nvlist_t *errors;
3408         int err, rv = 0;
3409
3410         if (props == NULL)
3411                 return (0);
3412
3413         VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3414
3415         zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
3416         (void) strcpy(zc->zc_name, dataset);
3417         pair = nvlist_next_nvpair(props, NULL);
3418         while (pair != NULL) {
3419                 next_pair = nvlist_next_nvpair(props, pair);
3420
3421                 (void) strcpy(zc->zc_value, nvpair_name(pair));
3422                 if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 ||
3423                     (err = zfs_secpolicy_inherit(zc, CRED())) != 0) {
3424                         VERIFY(nvlist_remove_nvpair(props, pair) == 0);
3425                         VERIFY(nvlist_add_int32(errors,
3426                             zc->zc_value, err) == 0);
3427                 }
3428                 pair = next_pair;
3429         }
3430         kmem_free(zc, sizeof (zfs_cmd_t));
3431
3432         if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
3433                 nvlist_free(errors);
3434                 errors = NULL;
3435         } else {
3436                 VERIFY(nvpair_value_int32(pair, &rv) == 0);
3437         }
3438
3439         if (errlist == NULL)
3440                 nvlist_free(errors);
3441         else
3442                 *errlist = errors;
3443
3444         return (rv);
3445 }
3446
3447 static boolean_t
3448 propval_equals(nvpair_t *p1, nvpair_t *p2)
3449 {
3450         if (nvpair_type(p1) == DATA_TYPE_NVLIST) {
3451                 /* dsl_prop_get_all_impl() format */
3452                 nvlist_t *attrs;
3453                 VERIFY(nvpair_value_nvlist(p1, &attrs) == 0);
3454                 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3455                     &p1) == 0);
3456         }
3457
3458         if (nvpair_type(p2) == DATA_TYPE_NVLIST) {
3459                 nvlist_t *attrs;
3460                 VERIFY(nvpair_value_nvlist(p2, &attrs) == 0);
3461                 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3462                     &p2) == 0);
3463         }
3464
3465         if (nvpair_type(p1) != nvpair_type(p2))
3466                 return (B_FALSE);
3467
3468         if (nvpair_type(p1) == DATA_TYPE_STRING) {
3469                 char *valstr1, *valstr2;
3470
3471                 VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0);
3472                 VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0);
3473                 return (strcmp(valstr1, valstr2) == 0);
3474         } else {
3475                 uint64_t intval1, intval2;
3476
3477                 VERIFY(nvpair_value_uint64(p1, &intval1) == 0);
3478                 VERIFY(nvpair_value_uint64(p2, &intval2) == 0);
3479                 return (intval1 == intval2);
3480         }
3481 }
3482
3483 /*
3484  * Remove properties from props if they are not going to change (as determined
3485  * by comparison with origprops). Remove them from origprops as well, since we
3486  * do not need to clear or restore properties that won't change.
3487  */
3488 static void
3489 props_reduce(nvlist_t *props, nvlist_t *origprops)
3490 {
3491         nvpair_t *pair, *next_pair;
3492
3493         if (origprops == NULL)
3494                 return; /* all props need to be received */
3495
3496         pair = nvlist_next_nvpair(props, NULL);
3497         while (pair != NULL) {
3498                 const char *propname = nvpair_name(pair);
3499                 nvpair_t *match;
3500
3501                 next_pair = nvlist_next_nvpair(props, pair);
3502
3503                 if ((nvlist_lookup_nvpair(origprops, propname,
3504                     &match) != 0) || !propval_equals(pair, match))
3505                         goto next; /* need to set received value */
3506
3507                 /* don't clear the existing received value */
3508                 (void) nvlist_remove_nvpair(origprops, match);
3509                 /* don't bother receiving the property */
3510                 (void) nvlist_remove_nvpair(props, pair);
3511 next:
3512                 pair = next_pair;
3513         }
3514 }
3515
3516 #ifdef  DEBUG
3517 static boolean_t zfs_ioc_recv_inject_err;
3518 #endif
3519
3520 /*
3521  * inputs:
3522  * zc_name              name of containing filesystem
3523  * zc_nvlist_src{_size} nvlist of properties to apply
3524  * zc_value             name of snapshot to create
3525  * zc_string            name of clone origin (if DRR_FLAG_CLONE)
3526  * zc_cookie            file descriptor to recv from
3527  * zc_begin_record      the BEGIN record of the stream (not byteswapped)
3528  * zc_guid              force flag
3529  * zc_cleanup_fd        cleanup-on-exit file descriptor
3530  * zc_action_handle     handle for this guid/ds mapping (or zero on first call)
3531  *
3532  * outputs:
3533  * zc_cookie            number of bytes read
3534  * zc_nvlist_dst{_size} error for each unapplied received property
3535  * zc_obj               zprop_errflags_t
3536  * zc_action_handle     handle for this guid/ds mapping
3537  */
3538 static int
3539 zfs_ioc_recv(zfs_cmd_t *zc)
3540 {
3541         file_t *fp;
3542         objset_t *os;
3543         dmu_recv_cookie_t drc;
3544         boolean_t force = (boolean_t)zc->zc_guid;
3545         int fd;
3546         int error = 0;
3547         int props_error = 0;
3548         nvlist_t *errors;
3549         offset_t off;
3550         nvlist_t *props = NULL; /* sent properties */
3551         nvlist_t *origprops = NULL; /* existing properties */
3552         objset_t *origin = NULL;
3553         char *tosnap;
3554         char tofs[ZFS_MAXNAMELEN];
3555         boolean_t first_recvd_props = B_FALSE;
3556
3557         if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
3558             strchr(zc->zc_value, '@') == NULL ||
3559             strchr(zc->zc_value, '%'))
3560                 return (EINVAL);
3561
3562         (void) strcpy(tofs, zc->zc_value);
3563         tosnap = strchr(tofs, '@');
3564         *tosnap++ = '\0';
3565
3566         if (zc->zc_nvlist_src != 0 &&
3567             (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
3568             zc->zc_iflags, &props)) != 0)
3569                 return (error);
3570
3571         fd = zc->zc_cookie;
3572         fp = getf(fd);
3573         if (fp == NULL) {
3574                 nvlist_free(props);
3575                 return (EBADF);
3576         }
3577
3578         VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3579
3580         if (props && dmu_objset_hold(tofs, FTAG, &os) == 0) {
3581                 if ((spa_version(os->os_spa) >= SPA_VERSION_RECVD_PROPS) &&
3582                     !dsl_prop_get_hasrecvd(os)) {
3583                         first_recvd_props = B_TRUE;
3584                 }
3585
3586                 /*
3587                  * If new received properties are supplied, they are to
3588                  * completely replace the existing received properties, so stash
3589                  * away the existing ones.
3590                  */
3591                 if (dsl_prop_get_received(os, &origprops) == 0) {
3592                         nvlist_t *errlist = NULL;
3593                         /*
3594                          * Don't bother writing a property if its value won't
3595                          * change (and avoid the unnecessary security checks).
3596                          *
3597                          * The first receive after SPA_VERSION_RECVD_PROPS is a
3598                          * special case where we blow away all local properties
3599                          * regardless.
3600                          */
3601                         if (!first_recvd_props)
3602                                 props_reduce(props, origprops);
3603                         if (zfs_check_clearable(tofs, origprops,
3604                             &errlist) != 0)
3605                                 (void) nvlist_merge(errors, errlist, 0);
3606                         nvlist_free(errlist);
3607                 }
3608
3609                 dmu_objset_rele(os, FTAG);
3610         }
3611
3612         if (zc->zc_string[0]) {
3613                 error = dmu_objset_hold(zc->zc_string, FTAG, &origin);
3614                 if (error)
3615                         goto out;
3616         }
3617
3618         error = dmu_recv_begin(tofs, tosnap, zc->zc_top_ds,
3619             &zc->zc_begin_record, force, origin, &drc);
3620         if (origin)
3621                 dmu_objset_rele(origin, FTAG);
3622         if (error)
3623                 goto out;
3624
3625         /*
3626          * Set properties before we receive the stream so that they are applied
3627          * to the new data. Note that we must call dmu_recv_stream() if
3628          * dmu_recv_begin() succeeds.
3629          */
3630         if (props) {
3631                 nvlist_t *errlist;
3632
3633                 if (dmu_objset_from_ds(drc.drc_logical_ds, &os) == 0) {
3634                         if (drc.drc_newfs) {
3635                                 if (spa_version(os->os_spa) >=
3636                                     SPA_VERSION_RECVD_PROPS)
3637                                         first_recvd_props = B_TRUE;
3638                         } else if (origprops != NULL) {
3639                                 if (clear_received_props(os, tofs, origprops,
3640                                     first_recvd_props ? NULL : props) != 0)
3641                                         zc->zc_obj |= ZPROP_ERR_NOCLEAR;
3642                         } else {
3643                                 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
3644                         }
3645                         dsl_prop_set_hasrecvd(os);
3646                 } else if (!drc.drc_newfs) {
3647                         zc->zc_obj |= ZPROP_ERR_NOCLEAR;
3648                 }
3649
3650                 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
3651                     props, &errlist);
3652                 (void) nvlist_merge(errors, errlist, 0);
3653                 nvlist_free(errlist);
3654         }
3655
3656         if (fit_error_list(zc, &errors) != 0 || put_nvlist(zc, errors) != 0) {
3657                 /*
3658                  * Caller made zc->zc_nvlist_dst less than the minimum expected
3659                  * size or supplied an invalid address.
3660                  */
3661                 props_error = EINVAL;
3662         }
3663
3664         off = fp->f_offset;
3665         error = dmu_recv_stream(&drc, fp->f_vnode, &off, zc->zc_cleanup_fd,
3666             &zc->zc_action_handle);
3667
3668         if (error == 0) {
3669                 zfsvfs_t *zfsvfs = NULL;
3670
3671                 if (getzfsvfs(tofs, &zfsvfs) == 0) {
3672                         /* online recv */
3673                         int end_err;
3674
3675                         error = zfs_suspend_fs(zfsvfs);
3676                         /*
3677                          * If the suspend fails, then the recv_end will
3678                          * likely also fail, and clean up after itself.
3679                          */
3680                         end_err = dmu_recv_end(&drc);
3681                         if (error == 0)
3682                                 error = zfs_resume_fs(zfsvfs, tofs);
3683                         error = error ? error : end_err;
3684                         VFS_RELE(zfsvfs->z_vfs);
3685                 } else {
3686                         error = dmu_recv_end(&drc);
3687                 }
3688         }
3689
3690         zc->zc_cookie = off - fp->f_offset;
3691         if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
3692                 fp->f_offset = off;
3693
3694 #ifdef  DEBUG
3695         if (zfs_ioc_recv_inject_err) {
3696                 zfs_ioc_recv_inject_err = B_FALSE;
3697                 error = 1;
3698         }
3699 #endif
3700         /*
3701          * On error, restore the original props.
3702          */
3703         if (error && props) {
3704                 if (dmu_objset_hold(tofs, FTAG, &os) == 0) {
3705                         if (clear_received_props(os, tofs, props, NULL) != 0) {
3706                                 /*
3707                                  * We failed to clear the received properties.
3708                                  * Since we may have left a $recvd value on the
3709                                  * system, we can't clear the $hasrecvd flag.
3710                                  */
3711                                 zc->zc_obj |= ZPROP_ERR_NORESTORE;
3712                         } else if (first_recvd_props) {
3713                                 dsl_prop_unset_hasrecvd(os);
3714                         }
3715                         dmu_objset_rele(os, FTAG);
3716                 } else if (!drc.drc_newfs) {
3717                         /* We failed to clear the received properties. */
3718                         zc->zc_obj |= ZPROP_ERR_NORESTORE;
3719                 }
3720
3721                 if (origprops == NULL && !drc.drc_newfs) {
3722                         /* We failed to stash the original properties. */
3723                         zc->zc_obj |= ZPROP_ERR_NORESTORE;
3724                 }
3725
3726                 /*
3727                  * dsl_props_set() will not convert RECEIVED to LOCAL on or
3728                  * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL
3729                  * explictly if we're restoring local properties cleared in the
3730                  * first new-style receive.
3731                  */
3732                 if (origprops != NULL &&
3733                     zfs_set_prop_nvlist(tofs, (first_recvd_props ?
3734                     ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED),
3735                     origprops, NULL) != 0) {
3736                         /*
3737                          * We stashed the original properties but failed to
3738                          * restore them.
3739                          */
3740                         zc->zc_obj |= ZPROP_ERR_NORESTORE;
3741                 }
3742         }
3743 out:
3744         nvlist_free(props);
3745         nvlist_free(origprops);
3746         nvlist_free(errors);
3747         releasef(fd);
3748
3749         if (error == 0)
3750                 error = props_error;
3751
3752         return (error);
3753 }
3754
3755 /*
3756  * inputs:
3757  * zc_name      name of snapshot to send
3758  * zc_cookie    file descriptor to send stream to
3759  * zc_obj       fromorigin flag (mutually exclusive with zc_fromobj)
3760  * zc_sendobj   objsetid of snapshot to send
3761  * zc_fromobj   objsetid of incremental fromsnap (may be zero)
3762  *
3763  * outputs: none
3764  */
3765 static int
3766 zfs_ioc_send(zfs_cmd_t *zc)
3767 {
3768         objset_t *fromsnap = NULL;
3769         objset_t *tosnap;
3770         file_t *fp;
3771         int error;
3772         offset_t off;
3773         dsl_dataset_t *ds;
3774         dsl_dataset_t *dsfrom = NULL;
3775         spa_t *spa;
3776         dsl_pool_t *dp;
3777
3778         error = spa_open(zc->zc_name, &spa, FTAG);
3779         if (error)
3780                 return (error);
3781
3782         dp = spa_get_dsl(spa);
3783         rw_enter(&dp->dp_config_rwlock, RW_READER);
3784         error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
3785         rw_exit(&dp->dp_config_rwlock);
3786         if (error) {
3787                 spa_close(spa, FTAG);
3788                 return (error);
3789         }
3790
3791         error = dmu_objset_from_ds(ds, &tosnap);
3792         if (error) {
3793                 dsl_dataset_rele(ds, FTAG);
3794                 spa_close(spa, FTAG);
3795                 return (error);
3796         }
3797
3798         if (zc->zc_fromobj != 0) {
3799                 rw_enter(&dp->dp_config_rwlock, RW_READER);
3800                 error = dsl_dataset_hold_obj(dp, zc->zc_fromobj, FTAG, &dsfrom);
3801                 rw_exit(&dp->dp_config_rwlock);
3802                 spa_close(spa, FTAG);
3803                 if (error) {
3804                         dsl_dataset_rele(ds, FTAG);
3805                         return (error);
3806                 }
3807                 error = dmu_objset_from_ds(dsfrom, &fromsnap);
3808                 if (error) {
3809                         dsl_dataset_rele(dsfrom, FTAG);
3810                         dsl_dataset_rele(ds, FTAG);
3811                         return (error);
3812                 }
3813         } else {
3814                 spa_close(spa, FTAG);
3815         }
3816
3817         fp = getf(zc->zc_cookie);
3818         if (fp == NULL) {
3819                 dsl_dataset_rele(ds, FTAG);
3820                 if (dsfrom)
3821                         dsl_dataset_rele(dsfrom, FTAG);
3822                 return (EBADF);
3823         }
3824
3825         off = fp->f_offset;
3826         error = dmu_sendbackup(tosnap, fromsnap, zc->zc_obj, fp->f_vnode, &off);
3827
3828         if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
3829                 fp->f_offset = off;
3830         releasef(zc->zc_cookie);
3831         if (dsfrom)
3832                 dsl_dataset_rele(dsfrom, FTAG);
3833         dsl_dataset_rele(ds, FTAG);
3834         return (error);
3835 }
3836
3837 static int
3838 zfs_ioc_inject_fault(zfs_cmd_t *zc)
3839 {
3840         int id, error;
3841
3842         error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
3843             &zc->zc_inject_record);
3844
3845         if (error == 0)
3846                 zc->zc_guid = (uint64_t)id;
3847
3848         return (error);
3849 }
3850
3851 static int
3852 zfs_ioc_clear_fault(zfs_cmd_t *zc)
3853 {
3854         return (zio_clear_fault((int)zc->zc_guid));
3855 }
3856
3857 static int
3858 zfs_ioc_inject_list_next(zfs_cmd_t *zc)
3859 {
3860         int id = (int)zc->zc_guid;
3861         int error;
3862
3863         error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
3864             &zc->zc_inject_record);
3865
3866         zc->zc_guid = id;
3867
3868         return (error);
3869 }
3870
3871 static int
3872 zfs_ioc_error_log(zfs_cmd_t *zc)
3873 {
3874         spa_t *spa;
3875         int error;
3876         size_t count = (size_t)zc->zc_nvlist_dst_size;
3877
3878         if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
3879                 return (error);
3880
3881         error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
3882             &count);
3883         if (error == 0)
3884                 zc->zc_nvlist_dst_size = count;
3885         else
3886                 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
3887
3888         spa_close(spa, FTAG);
3889
3890         return (error);
3891 }
3892
3893 static int
3894 zfs_ioc_clear(zfs_cmd_t *zc)
3895 {
3896         spa_t *spa;
3897         vdev_t *vd;
3898         int error;
3899
3900         /*
3901          * On zpool clear we also fix up missing slogs
3902          */
3903         mutex_enter(&spa_namespace_lock);
3904         spa = spa_lookup(zc->zc_name);
3905         if (spa == NULL) {
3906                 mutex_exit(&spa_namespace_lock);
3907                 return (EIO);
3908         }
3909         if (spa_get_log_state(spa) == SPA_LOG_MISSING) {
3910                 /* we need to let spa_open/spa_load clear the chains */
3911                 spa_set_log_state(spa, SPA_LOG_CLEAR);
3912         }
3913         spa->spa_last_open_failed = 0;
3914         mutex_exit(&spa_namespace_lock);
3915
3916         if (zc->zc_cookie & ZPOOL_NO_REWIND) {
3917                 error = spa_open(zc->zc_name, &spa, FTAG);
3918         } else {
3919                 nvlist_t *policy;
3920                 nvlist_t *config = NULL;
3921
3922                 if (zc->zc_nvlist_src == 0)
3923                         return (EINVAL);
3924
3925                 if ((error = get_nvlist(zc->zc_nvlist_src,
3926                     zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) {
3927                         error = spa_open_rewind(zc->zc_name, &spa, FTAG,
3928                             policy, &config);
3929                         if (config != NULL) {
3930                                 int err;
3931
3932                                 if ((err = put_nvlist(zc, config)) != 0)
3933                                         error = err;
3934                                 nvlist_free(config);
3935                         }
3936                         nvlist_free(policy);
3937                 }
3938         }
3939
3940         if (error)
3941                 return (error);
3942
3943         spa_vdev_state_enter(spa, SCL_NONE);
3944
3945         if (zc->zc_guid == 0) {
3946                 vd = NULL;
3947         } else {
3948                 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
3949                 if (vd == NULL) {
3950                         (void) spa_vdev_state_exit(spa, NULL, ENODEV);
3951                         spa_close(spa, FTAG);
3952                         return (ENODEV);
3953                 }
3954         }
3955
3956         vdev_clear(spa, vd);
3957
3958         (void) spa_vdev_state_exit(spa, NULL, 0);
3959
3960         /*
3961          * Resume any suspended I/Os.
3962          */
3963         if (zio_resume(spa) != 0)
3964                 error = EIO;
3965
3966         spa_close(spa, FTAG);
3967
3968         return (error);
3969 }
3970
3971 /*
3972  * inputs:
3973  * zc_name      name of filesystem
3974  * zc_value     name of origin snapshot
3975  *
3976  * outputs:
3977  * zc_string    name of conflicting snapshot, if there is one
3978  */
3979 static int
3980 zfs_ioc_promote(zfs_cmd_t *zc)
3981 {
3982         char *cp;
3983
3984         /*
3985          * We don't need to unmount *all* the origin fs's snapshots, but
3986          * it's easier.
3987          */
3988         cp = strchr(zc->zc_value, '@');
3989         if (cp)
3990                 *cp = '\0';
3991         (void) dmu_objset_find(zc->zc_value,
3992             zfs_unmount_snap, NULL, DS_FIND_SNAPSHOTS);
3993         return (dsl_dataset_promote(zc->zc_name, zc->zc_string));
3994 }
3995
3996 /*
3997  * Retrieve a single {user|group}{used|quota}@... property.
3998  *
3999  * inputs:
4000  * zc_name      name of filesystem
4001  * zc_objset_type zfs_userquota_prop_t
4002  * zc_value     domain name (eg. "S-1-234-567-89")
4003  * zc_guid      RID/UID/GID
4004  *
4005  * outputs:
4006  * zc_cookie    property value
4007  */
4008 static int
4009 zfs_ioc_userspace_one(zfs_cmd_t *zc)
4010 {
4011         zfsvfs_t *zfsvfs;
4012         int error;
4013
4014         if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
4015                 return (EINVAL);
4016
4017         error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4018         if (error)
4019                 return (error);
4020
4021         error = zfs_userspace_one(zfsvfs,
4022             zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie);
4023         zfsvfs_rele(zfsvfs, FTAG);
4024
4025         return (error);
4026 }
4027
4028 /*
4029  * inputs:
4030  * zc_name              name of filesystem
4031  * zc_cookie            zap cursor
4032  * zc_objset_type       zfs_userquota_prop_t
4033  * zc_nvlist_dst[_size] buffer to fill (not really an nvlist)
4034  *
4035  * outputs:
4036  * zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t)
4037  * zc_cookie    zap cursor
4038  */
4039 static int
4040 zfs_ioc_userspace_many(zfs_cmd_t *zc)
4041 {
4042         zfsvfs_t *zfsvfs;
4043         int bufsize = zc->zc_nvlist_dst_size;
4044
4045         if (bufsize <= 0)
4046                 return (ENOMEM);
4047
4048         int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4049         if (error)
4050                 return (error);
4051
4052         void *buf = kmem_alloc(bufsize, KM_SLEEP);
4053
4054         error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie,
4055             buf, &zc->zc_nvlist_dst_size);
4056
4057         if (error == 0) {
4058                 error = xcopyout(buf,
4059                     (void *)(uintptr_t)zc->zc_nvlist_dst,
4060                     zc->zc_nvlist_dst_size);
4061         }
4062         kmem_free(buf, bufsize);
4063         zfsvfs_rele(zfsvfs, FTAG);
4064
4065         return (error);
4066 }
4067
4068 /*
4069  * inputs:
4070  * zc_name              name of filesystem
4071  *
4072  * outputs:
4073  * none
4074  */
4075 static int
4076 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc)
4077 {
4078         objset_t *os;
4079         int error = 0;
4080         zfsvfs_t *zfsvfs;
4081
4082         if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
4083                 if (!dmu_objset_userused_enabled(zfsvfs->z_os)) {
4084                         /*
4085                          * If userused is not enabled, it may be because the
4086                          * objset needs to be closed & reopened (to grow the
4087                          * objset_phys_t).  Suspend/resume the fs will do that.
4088                          */
4089                         error = zfs_suspend_fs(zfsvfs);
4090                         if (error == 0)
4091                                 error = zfs_resume_fs(zfsvfs, zc->zc_name);
4092                 }
4093                 if (error == 0)
4094                         error = dmu_objset_userspace_upgrade(zfsvfs->z_os);
4095                 VFS_RELE(zfsvfs->z_vfs);
4096         } else {
4097                 /* XXX kind of reading contents without owning */
4098                 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4099                 if (error)
4100                         return (error);
4101
4102                 error = dmu_objset_userspace_upgrade(os);
4103                 dmu_objset_rele(os, FTAG);
4104         }
4105
4106         return (error);
4107 }
4108
4109 /*
4110  * We don't want to have a hard dependency
4111  * against some special symbols in sharefs
4112  * nfs, and smbsrv.  Determine them if needed when
4113  * the first file system is shared.
4114  * Neither sharefs, nfs or smbsrv are unloadable modules.
4115  */
4116 int (*znfsexport_fs)(void *arg);
4117 int (*zshare_fs)(enum sharefs_sys_op, share_t *, uint32_t);
4118 int (*zsmbexport_fs)(void *arg, boolean_t add_share);
4119
4120 int zfs_nfsshare_inited;
4121 int zfs_smbshare_inited;
4122
4123 ddi_modhandle_t nfs_mod;
4124 ddi_modhandle_t sharefs_mod;
4125 ddi_modhandle_t smbsrv_mod;
4126 kmutex_t zfs_share_lock;
4127
4128 static int
4129 zfs_init_sharefs()
4130 {
4131         int error;
4132
4133         ASSERT(MUTEX_HELD(&zfs_share_lock));
4134         /* Both NFS and SMB shares also require sharetab support. */
4135         if (sharefs_mod == NULL && ((sharefs_mod =
4136             ddi_modopen("fs/sharefs",
4137             KRTLD_MODE_FIRST, &error)) == NULL)) {
4138                 return (ENOSYS);
4139         }
4140         if (zshare_fs == NULL && ((zshare_fs =
4141             (int (*)(enum sharefs_sys_op, share_t *, uint32_t))
4142             ddi_modsym(sharefs_mod, "sharefs_impl", &error)) == NULL)) {
4143                 return (ENOSYS);
4144         }
4145         return (0);
4146 }
4147
4148 static int
4149 zfs_ioc_share(zfs_cmd_t *zc)
4150 {
4151         int error;
4152         int opcode;
4153
4154         switch (zc->zc_share.z_sharetype) {
4155         case ZFS_SHARE_NFS:
4156         case ZFS_UNSHARE_NFS:
4157                 if (zfs_nfsshare_inited == 0) {
4158                         mutex_enter(&zfs_share_lock);
4159                         if (nfs_mod == NULL && ((nfs_mod = ddi_modopen("fs/nfs",
4160                             KRTLD_MODE_FIRST, &error)) == NULL)) {
4161                                 mutex_exit(&zfs_share_lock);
4162                                 return (ENOSYS);
4163                         }
4164                         if (znfsexport_fs == NULL &&
4165                             ((znfsexport_fs = (int (*)(void *))
4166                             ddi_modsym(nfs_mod,
4167                             "nfs_export", &error)) == NULL)) {
4168                                 mutex_exit(&zfs_share_lock);
4169                                 return (ENOSYS);
4170                         }
4171                         error = zfs_init_sharefs();
4172                         if (error) {
4173                                 mutex_exit(&zfs_share_lock);
4174                                 return (ENOSYS);
4175                         }
4176                         zfs_nfsshare_inited = 1;
4177                         mutex_exit(&zfs_share_lock);
4178                 }
4179                 break;
4180         case ZFS_SHARE_SMB:
4181         case ZFS_UNSHARE_SMB:
4182                 if (zfs_smbshare_inited == 0) {
4183                         mutex_enter(&zfs_share_lock);
4184                         if (smbsrv_mod == NULL && ((smbsrv_mod =
4185                             ddi_modopen("drv/smbsrv",
4186                             KRTLD_MODE_FIRST, &error)) == NULL)) {
4187                                 mutex_exit(&zfs_share_lock);
4188                                 return (ENOSYS);
4189                         }
4190                         if (zsmbexport_fs == NULL && ((zsmbexport_fs =
4191                             (int (*)(void *, boolean_t))ddi_modsym(smbsrv_mod,
4192                             "smb_server_share", &error)) == NULL)) {
4193                                 mutex_exit(&zfs_share_lock);
4194                                 return (ENOSYS);
4195                         }
4196                         error = zfs_init_sharefs();
4197                         if (error) {
4198                                 mutex_exit(&zfs_share_lock);
4199                                 return (ENOSYS);
4200                         }
4201                         zfs_smbshare_inited = 1;
4202                         mutex_exit(&zfs_share_lock);
4203                 }
4204                 break;
4205         default:
4206                 return (EINVAL);
4207         }
4208
4209         switch (zc->zc_share.z_sharetype) {
4210         case ZFS_SHARE_NFS:
4211         case ZFS_UNSHARE_NFS:
4212                 if (error =
4213                     znfsexport_fs((void *)
4214                     (uintptr_t)zc->zc_share.z_exportdata))
4215                         return (error);
4216                 break;
4217         case ZFS_SHARE_SMB:
4218         case ZFS_UNSHARE_SMB:
4219                 if (error = zsmbexport_fs((void *)
4220                     (uintptr_t)zc->zc_share.z_exportdata,
4221                     zc->zc_share.z_sharetype == ZFS_SHARE_SMB ?
4222                     B_TRUE: B_FALSE)) {
4223                         return (error);
4224                 }
4225                 break;
4226         }
4227
4228         opcode = (zc->zc_share.z_sharetype == ZFS_SHARE_NFS ||
4229             zc->zc_share.z_sharetype == ZFS_SHARE_SMB) ?
4230             SHAREFS_ADD : SHAREFS_REMOVE;
4231
4232         /*
4233          * Add or remove share from sharetab
4234          */
4235         error = zshare_fs(opcode,
4236             (void *)(uintptr_t)zc->zc_share.z_sharedata,
4237             zc->zc_share.z_sharemax);
4238
4239         return (error);
4240
4241 }
4242
4243 ace_t full_access[] = {
4244         {(uid_t)-1, ACE_ALL_PERMS, ACE_EVERYONE, 0}
4245 };
4246
4247 /*
4248  * inputs:
4249  * zc_name              name of containing filesystem
4250  * zc_obj               object # beyond which we want next in-use object #
4251  *
4252  * outputs:
4253  * zc_obj               next in-use object #
4254  */
4255 static int
4256 zfs_ioc_next_obj(zfs_cmd_t *zc)
4257 {
4258         objset_t *os = NULL;
4259         int error;
4260
4261         error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4262         if (error)
4263                 return (error);
4264
4265         error = dmu_object_next(os, &zc->zc_obj, B_FALSE,
4266             os->os_dsl_dataset->ds_phys->ds_prev_snap_txg);
4267
4268         dmu_objset_rele(os, FTAG);
4269         return (error);
4270 }
4271
4272 /*
4273  * inputs:
4274  * zc_name              name of filesystem
4275  * zc_value             prefix name for snapshot
4276  * zc_cleanup_fd        cleanup-on-exit file descriptor for calling process
4277  *
4278  * outputs:
4279  */
4280 static int
4281 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc)
4282 {
4283         char *snap_name;
4284         int error;
4285
4286         snap_name = kmem_asprintf("%s-%016llx", zc->zc_value,
4287             (u_longlong_t)ddi_get_lbolt64());
4288
4289         if (strlen(snap_name) >= MAXNAMELEN) {
4290                 strfree(snap_name);
4291                 return (E2BIG);
4292         }
4293
4294         error = dmu_objset_snapshot(zc->zc_name, snap_name, snap_name,
4295             NULL, B_FALSE, B_TRUE, zc->zc_cleanup_fd);
4296         if (error != 0) {
4297                 strfree(snap_name);
4298                 return (error);
4299         }
4300
4301         (void) strcpy(zc->zc_value, snap_name);
4302         strfree(snap_name);
4303         return (0);
4304 }
4305
4306 /*
4307  * inputs:
4308  * zc_name              name of "to" snapshot
4309  * zc_value             name of "from" snapshot
4310  * zc_cookie            file descriptor to write diff data on
4311  *
4312  * outputs:
4313  * dmu_diff_record_t's to the file descriptor
4314  */
4315 static int
4316 zfs_ioc_diff(zfs_cmd_t *zc)
4317 {
4318         objset_t *fromsnap;
4319         objset_t *tosnap;
4320         file_t *fp;
4321         offset_t off;
4322         int error;
4323
4324         error = dmu_objset_hold(zc->zc_name, FTAG, &tosnap);
4325         if (error)
4326                 return (error);
4327
4328         error = dmu_objset_hold(zc->zc_value, FTAG, &fromsnap);
4329         if (error) {
4330                 dmu_objset_rele(tosnap, FTAG);
4331                 return (error);
4332         }
4333
4334         fp = getf(zc->zc_cookie);
4335         if (fp == NULL) {
4336                 dmu_objset_rele(fromsnap, FTAG);
4337                 dmu_objset_rele(tosnap, FTAG);
4338                 return (EBADF);
4339         }
4340
4341         off = fp->f_offset;
4342
4343         error = dmu_diff(tosnap, fromsnap, fp->f_vnode, &off);
4344
4345         if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4346                 fp->f_offset = off;
4347         releasef(zc->zc_cookie);
4348
4349         dmu_objset_rele(fromsnap, FTAG);
4350         dmu_objset_rele(tosnap, FTAG);
4351         return (error);
4352 }
4353
4354 /*
4355  * Remove all ACL files in shares dir
4356  */
4357 static int
4358 zfs_smb_acl_purge(znode_t *dzp)
4359 {
4360         zap_cursor_t    zc;
4361         zap_attribute_t zap;
4362         zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
4363         int error;
4364
4365         for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
4366             (error = zap_cursor_retrieve(&zc, &zap)) == 0;
4367             zap_cursor_advance(&zc)) {
4368                 if ((error = VOP_REMOVE(ZTOV(dzp), zap.za_name, kcred,
4369                     NULL, 0)) != 0)
4370                         break;
4371         }
4372         zap_cursor_fini(&zc);
4373         return (error);
4374 }
4375
4376 static int
4377 zfs_ioc_smb_acl(zfs_cmd_t *zc)
4378 {
4379         vnode_t *vp;
4380         znode_t *dzp;
4381         vnode_t *resourcevp = NULL;
4382         znode_t *sharedir;
4383         zfsvfs_t *zfsvfs;
4384         nvlist_t *nvlist;
4385         char *src, *target;
4386         vattr_t vattr;
4387         vsecattr_t vsec;
4388         int error = 0;
4389
4390         if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
4391             NO_FOLLOW, NULL, &vp)) != 0)
4392                 return (error);
4393
4394         /* Now make sure mntpnt and dataset are ZFS */
4395
4396         if (vp->v_vfsp->vfs_fstype != zfsfstype ||
4397             (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
4398             zc->zc_name) != 0)) {
4399                 VN_RELE(vp);
4400                 return (EINVAL);
4401         }
4402
4403         dzp = VTOZ(vp);
4404         zfsvfs = dzp->z_zfsvfs;
4405         ZFS_ENTER(zfsvfs);
4406
4407         /*
4408          * Create share dir if its missing.
4409          */
4410         mutex_enter(&zfsvfs->z_lock);
4411         if (zfsvfs->z_shares_dir == 0) {
4412                 dmu_tx_t *tx;
4413
4414                 tx = dmu_tx_create(zfsvfs->z_os);
4415                 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, TRUE,
4416                     ZFS_SHARES_DIR);
4417                 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
4418                 error = dmu_tx_assign(tx, TXG_WAIT);
4419                 if (error) {
4420                         dmu_tx_abort(tx);
4421                 } else {
4422                         error = zfs_create_share_dir(zfsvfs, tx);
4423                         dmu_tx_commit(tx);
4424                 }
4425                 if (error) {
4426                         mutex_exit(&zfsvfs->z_lock);
4427                         VN_RELE(vp);
4428                         ZFS_EXIT(zfsvfs);
4429                         return (error);
4430                 }
4431         }
4432         mutex_exit(&zfsvfs->z_lock);
4433
4434         ASSERT(zfsvfs->z_shares_dir);
4435         if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &sharedir)) != 0) {
4436                 VN_RELE(vp);
4437                 ZFS_EXIT(zfsvfs);
4438                 return (error);
4439         }
4440
4441         switch (zc->zc_cookie) {
4442         case ZFS_SMB_ACL_ADD:
4443                 vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE;
4444                 vattr.va_type = VREG;
4445                 vattr.va_mode = S_IFREG|0777;
4446                 vattr.va_uid = 0;
4447                 vattr.va_gid = 0;
4448
4449                 vsec.vsa_mask = VSA_ACE;
4450                 vsec.vsa_aclentp = &full_access;
4451                 vsec.vsa_aclentsz = sizeof (full_access);
4452                 vsec.vsa_aclcnt = 1;
4453
4454                 error = VOP_CREATE(ZTOV(sharedir), zc->zc_string,
4455                     &vattr, EXCL, 0, &resourcevp, kcred, 0, NULL, &vsec);
4456                 if (resourcevp)
4457                         VN_RELE(resourcevp);
4458                 break;
4459
4460         case ZFS_SMB_ACL_REMOVE:
4461                 error = VOP_REMOVE(ZTOV(sharedir), zc->zc_string, kcred,
4462                     NULL, 0);
4463                 break;
4464
4465         case ZFS_SMB_ACL_RENAME:
4466                 if ((error = get_nvlist(zc->zc_nvlist_src,
4467                     zc->zc_nvlist_src_size, zc->zc_iflags, &nvlist)) != 0) {
4468                         VN_RELE(vp);
4469                         ZFS_EXIT(zfsvfs);
4470                         return (error);
4471                 }
4472                 if (nvlist_lookup_string(nvlist, ZFS_SMB_ACL_SRC, &src) ||
4473                     nvlist_lookup_string(nvlist, ZFS_SMB_ACL_TARGET,
4474                     &target)) {
4475                         VN_RELE(vp);
4476                         VN_RELE(ZTOV(sharedir));
4477                         ZFS_EXIT(zfsvfs);
4478                         nvlist_free(nvlist);
4479                         return (error);
4480                 }
4481                 error = VOP_RENAME(ZTOV(sharedir), src, ZTOV(sharedir), target,
4482                     kcred, NULL, 0);
4483                 nvlist_free(nvlist);
4484                 break;
4485
4486         case ZFS_SMB_ACL_PURGE:
4487                 error = zfs_smb_acl_purge(sharedir);
4488                 break;
4489
4490         default:
4491                 error = EINVAL;
4492                 break;
4493         }
4494
4495         VN_RELE(vp);
4496         VN_RELE(ZTOV(sharedir));
4497
4498         ZFS_EXIT(zfsvfs);
4499
4500         return (error);
4501 }
4502
4503 /*
4504  * inputs:
4505  * zc_name              name of filesystem
4506  * zc_value             short name of snap
4507  * zc_string            user-supplied tag for this hold
4508  * zc_cookie            recursive flag
4509  * zc_temphold          set if hold is temporary
4510  * zc_cleanup_fd        cleanup-on-exit file descriptor for calling process
4511  * zc_sendobj           if non-zero, the objid for zc_name@zc_value
4512  * zc_createtxg         if zc_sendobj is non-zero, snap must have zc_createtxg
4513  *
4514  * outputs:             none
4515  */
4516 static int
4517 zfs_ioc_hold(zfs_cmd_t *zc)
4518 {
4519         boolean_t recursive = zc->zc_cookie;
4520         spa_t *spa;
4521         dsl_pool_t *dp;
4522         dsl_dataset_t *ds;
4523         int error;
4524         minor_t minor = 0;
4525
4526         if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
4527                 return (EINVAL);
4528
4529         if (zc->zc_sendobj == 0) {
4530                 return (dsl_dataset_user_hold(zc->zc_name, zc->zc_value,
4531                     zc->zc_string, recursive, zc->zc_temphold,
4532                     zc->zc_cleanup_fd));
4533         }
4534
4535         if (recursive)
4536                 return (EINVAL);
4537
4538         error = spa_open(zc->zc_name, &spa, FTAG);
4539         if (error)
4540                 return (error);
4541
4542         dp = spa_get_dsl(spa);
4543         rw_enter(&dp->dp_config_rwlock, RW_READER);
4544         error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
4545         rw_exit(&dp->dp_config_rwlock);
4546         spa_close(spa, FTAG);
4547         if (error)
4548                 return (error);
4549
4550         /*
4551          * Until we have a hold on this snapshot, it's possible that
4552          * zc_sendobj could've been destroyed and reused as part
4553          * of a later txg.  Make sure we're looking at the right object.
4554          */
4555         if (zc->zc_createtxg != ds->ds_phys->ds_creation_txg) {
4556                 dsl_dataset_rele(ds, FTAG);
4557                 return (ENOENT);
4558         }
4559
4560         if (zc->zc_cleanup_fd != -1 && zc->zc_temphold) {
4561                 error = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor);
4562                 if (error) {
4563                         dsl_dataset_rele(ds, FTAG);
4564                         return (error);
4565                 }
4566         }
4567
4568         error = dsl_dataset_user_hold_for_send(ds, zc->zc_string,
4569             zc->zc_temphold);
4570         if (minor != 0) {
4571                 if (error == 0) {
4572                         dsl_register_onexit_hold_cleanup(ds, zc->zc_string,
4573                             minor);
4574                 }
4575                 zfs_onexit_fd_rele(zc->zc_cleanup_fd);
4576         }
4577         dsl_dataset_rele(ds, FTAG);
4578
4579         return (error);
4580 }
4581
4582 /*
4583  * inputs:
4584  * zc_name      name of dataset from which we're releasing a user hold
4585  * zc_value     short name of snap
4586  * zc_string    user-supplied tag for this hold
4587  * zc_cookie    recursive flag
4588  *
4589  * outputs:     none
4590  */
4591 static int
4592 zfs_ioc_release(zfs_cmd_t *zc)
4593 {
4594         boolean_t recursive = zc->zc_cookie;
4595
4596         if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
4597                 return (EINVAL);
4598
4599         return (dsl_dataset_user_release(zc->zc_name, zc->zc_value,
4600             zc->zc_string, recursive));
4601 }
4602
4603 /*
4604  * inputs:
4605  * zc_name              name of filesystem
4606  *
4607  * outputs:
4608  * zc_nvlist_src{_size} nvlist of snapshot holds
4609  */
4610 static int
4611 zfs_ioc_get_holds(zfs_cmd_t *zc)
4612 {
4613         nvlist_t *nvp;
4614         int error;
4615
4616         if ((error = dsl_dataset_get_holds(zc->zc_name, &nvp)) == 0) {
4617                 error = put_nvlist(zc, nvp);
4618                 nvlist_free(nvp);
4619         }
4620
4621         return (error);
4622 }
4623
4624 /*
4625  * pool create, destroy, and export don't log the history as part of
4626  * zfsdev_ioctl, but rather zfs_ioc_pool_create, and zfs_ioc_pool_export
4627  * do the logging of those commands.
4628  */
4629 static zfs_ioc_vec_t zfs_ioc_vec[] = {
4630         { zfs_ioc_pool_create, zfs_secpolicy_config, POOL_NAME, B_FALSE,
4631             POOL_CHECK_NONE },
4632         { zfs_ioc_pool_destroy, zfs_secpolicy_config, POOL_NAME, B_FALSE,
4633             POOL_CHECK_NONE },
4634         { zfs_ioc_pool_import, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4635             POOL_CHECK_NONE },
4636         { zfs_ioc_pool_export, zfs_secpolicy_config, POOL_NAME, B_FALSE,
4637             POOL_CHECK_NONE },
4638         { zfs_ioc_pool_configs, zfs_secpolicy_none, NO_NAME, B_FALSE,
4639             POOL_CHECK_NONE },
4640         { zfs_ioc_pool_stats, zfs_secpolicy_read, POOL_NAME, B_FALSE,
4641             POOL_CHECK_NONE },
4642         { zfs_ioc_pool_tryimport, zfs_secpolicy_config, NO_NAME, B_FALSE,
4643             POOL_CHECK_NONE },
4644         { zfs_ioc_pool_scan, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4645             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4646         { zfs_ioc_pool_freeze, zfs_secpolicy_config, NO_NAME, B_FALSE,
4647             POOL_CHECK_READONLY },
4648         { zfs_ioc_pool_upgrade, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4649             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4650         { zfs_ioc_pool_get_history, zfs_secpolicy_config, POOL_NAME, B_FALSE,
4651             POOL_CHECK_NONE },
4652         { zfs_ioc_vdev_add, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4653             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4654         { zfs_ioc_vdev_remove, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4655             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4656         { zfs_ioc_vdev_set_state, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4657             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4658         { zfs_ioc_vdev_attach, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4659             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4660         { zfs_ioc_vdev_detach, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4661             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4662         { zfs_ioc_vdev_setpath, zfs_secpolicy_config, POOL_NAME, B_FALSE,
4663             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4664         { zfs_ioc_vdev_setfru,  zfs_secpolicy_config, POOL_NAME, B_FALSE,
4665             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4666         { zfs_ioc_objset_stats, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4667             POOL_CHECK_SUSPENDED },
4668         { zfs_ioc_objset_zplprops, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4669             POOL_CHECK_NONE },
4670         { zfs_ioc_dataset_list_next, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4671             POOL_CHECK_SUSPENDED },
4672         { zfs_ioc_snapshot_list_next, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4673             POOL_CHECK_SUSPENDED },
4674         { zfs_ioc_set_prop, zfs_secpolicy_none, DATASET_NAME, B_TRUE,
4675             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4676         { zfs_ioc_create, zfs_secpolicy_create, DATASET_NAME, B_TRUE,
4677             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4678         { zfs_ioc_destroy, zfs_secpolicy_destroy, DATASET_NAME, B_TRUE,
4679             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4680         { zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME, B_TRUE,
4681             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4682         { zfs_ioc_rename, zfs_secpolicy_rename, DATASET_NAME, B_TRUE,
4683             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4684         { zfs_ioc_recv, zfs_secpolicy_receive, DATASET_NAME, B_TRUE,
4685             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4686         { zfs_ioc_send, zfs_secpolicy_send, DATASET_NAME, B_TRUE,
4687             POOL_CHECK_NONE },
4688         { zfs_ioc_inject_fault, zfs_secpolicy_inject, NO_NAME, B_FALSE,
4689             POOL_CHECK_NONE },
4690         { zfs_ioc_clear_fault, zfs_secpolicy_inject, NO_NAME, B_FALSE,
4691             POOL_CHECK_NONE },
4692         { zfs_ioc_inject_list_next, zfs_secpolicy_inject, NO_NAME, B_FALSE,
4693             POOL_CHECK_NONE },
4694         { zfs_ioc_error_log, zfs_secpolicy_inject, POOL_NAME, B_FALSE,
4695             POOL_CHECK_NONE },
4696         { zfs_ioc_clear, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4697             POOL_CHECK_NONE },
4698         { zfs_ioc_promote, zfs_secpolicy_promote, DATASET_NAME, B_TRUE,
4699             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4700         { zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, DATASET_NAME,
4701             B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4702         { zfs_ioc_snapshot, zfs_secpolicy_snapshot, DATASET_NAME, B_TRUE,
4703             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4704         { zfs_ioc_dsobj_to_dsname, zfs_secpolicy_diff, POOL_NAME, B_FALSE,
4705             POOL_CHECK_NONE },
4706         { zfs_ioc_obj_to_path, zfs_secpolicy_diff, DATASET_NAME, B_FALSE,
4707             POOL_CHECK_SUSPENDED },
4708         { zfs_ioc_pool_set_props, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4709             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4710         { zfs_ioc_pool_get_props, zfs_secpolicy_read, POOL_NAME, B_FALSE,
4711             POOL_CHECK_NONE },
4712         { zfs_ioc_set_fsacl, zfs_secpolicy_fsacl, DATASET_NAME, B_TRUE,
4713             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4714         { zfs_ioc_get_fsacl, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4715             POOL_CHECK_NONE },
4716         { zfs_ioc_share, zfs_secpolicy_share, DATASET_NAME, B_FALSE,
4717             POOL_CHECK_NONE },
4718         { zfs_ioc_inherit_prop, zfs_secpolicy_inherit, DATASET_NAME, B_TRUE,
4719             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4720         { zfs_ioc_smb_acl, zfs_secpolicy_smb_acl, DATASET_NAME, B_FALSE,
4721             POOL_CHECK_NONE },
4722         { zfs_ioc_userspace_one, zfs_secpolicy_userspace_one, DATASET_NAME,
4723             B_FALSE, POOL_CHECK_NONE },
4724         { zfs_ioc_userspace_many, zfs_secpolicy_userspace_many, DATASET_NAME,
4725             B_FALSE, POOL_CHECK_NONE },
4726         { zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade,
4727             DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4728         { zfs_ioc_hold, zfs_secpolicy_hold, DATASET_NAME, B_TRUE,
4729             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4730         { zfs_ioc_release, zfs_secpolicy_release, DATASET_NAME, B_TRUE,
4731             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4732         { zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4733             POOL_CHECK_SUSPENDED },
4734         { zfs_ioc_objset_recvd_props, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4735             POOL_CHECK_NONE },
4736         { zfs_ioc_vdev_split, zfs_secpolicy_config, POOL_NAME, B_TRUE,
4737             POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4738         { zfs_ioc_next_obj, zfs_secpolicy_read, DATASET_NAME, B_FALSE,
4739             POOL_CHECK_NONE },
4740         { zfs_ioc_diff, zfs_secpolicy_diff, DATASET_NAME, B_FALSE,
4741             POOL_CHECK_NONE },
4742         { zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot, DATASET_NAME,
4743             B_FALSE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY },
4744         { zfs_ioc_obj_to_stats, zfs_secpolicy_diff, DATASET_NAME, B_FALSE,
4745             POOL_CHECK_SUSPENDED }
4746 };
4747
4748 int
4749 pool_status_check(const char *name, zfs_ioc_namecheck_t type,
4750     zfs_ioc_poolcheck_t check)
4751 {
4752         spa_t *spa;
4753         int error;
4754
4755         ASSERT(type == POOL_NAME || type == DATASET_NAME);
4756
4757         if (check & POOL_CHECK_NONE)
4758                 return (0);
4759
4760         error = spa_open(name, &spa, FTAG);
4761         if (error == 0) {
4762                 if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa))
4763                         error = EAGAIN;
4764                 else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa))
4765                         error = EROFS;
4766                 spa_close(spa, FTAG);
4767         }
4768         return (error);
4769 }
4770
4771 /*
4772  * Find a free minor number.
4773  */
4774 minor_t
4775 zfsdev_minor_alloc(void)
4776 {
4777         static minor_t last_minor;
4778         minor_t m;
4779
4780         ASSERT(MUTEX_HELD(&zfsdev_state_lock));
4781
4782         for (m = last_minor + 1; m != last_minor; m++) {
4783                 if (m > ZFSDEV_MAX_MINOR)
4784                         m = 1;
4785                 if (ddi_get_soft_state(zfsdev_state, m) == NULL) {
4786                         last_minor = m;
4787                         return (m);
4788                 }
4789         }
4790
4791         return (0);
4792 }
4793
4794 static int
4795 zfs_ctldev_init(dev_t *devp)
4796 {
4797         minor_t minor;
4798         zfs_soft_state_t *zs;
4799
4800         ASSERT(MUTEX_HELD(&zfsdev_state_lock));
4801         ASSERT(getminor(*devp) == 0);
4802
4803         minor = zfsdev_minor_alloc();
4804         if (minor == 0)
4805                 return (ENXIO);
4806
4807         if (ddi_soft_state_zalloc(zfsdev_state, minor) != DDI_SUCCESS)
4808                 return (EAGAIN);
4809
4810         *devp = makedevice(getemajor(*devp), minor);
4811
4812         zs = ddi_get_soft_state(zfsdev_state, minor);
4813         zs->zss_type = ZSST_CTLDEV;
4814         zfs_onexit_init((zfs_onexit_t **)&zs->zss_data);
4815
4816         return (0);
4817 }
4818
4819 static void
4820 zfs_ctldev_destroy(zfs_onexit_t *zo, minor_t minor)
4821 {
4822         ASSERT(MUTEX_HELD(&zfsdev_state_lock));
4823
4824         zfs_onexit_destroy(zo);
4825         ddi_soft_state_free(zfsdev_state, minor);
4826 }
4827
4828 void *
4829 zfsdev_get_soft_state(minor_t minor, enum zfs_soft_state_type which)
4830 {
4831         zfs_soft_state_t *zp;
4832
4833         zp = ddi_get_soft_state(zfsdev_state, minor);
4834         if (zp == NULL || zp->zss_type != which)
4835                 return (NULL);
4836
4837         return (zp->zss_data);
4838 }
4839
4840 static int
4841 zfsdev_open(dev_t *devp, int flag, int otyp, cred_t *cr)
4842 {
4843         int error = 0;
4844
4845         if (getminor(*devp) != 0)
4846                 return (zvol_open(devp, flag, otyp, cr));
4847
4848         /* This is the control device. Allocate a new minor if requested. */
4849         if (flag & FEXCL) {
4850                 mutex_enter(&zfsdev_state_lock);
4851                 error = zfs_ctldev_init(devp);
4852                 mutex_exit(&zfsdev_state_lock);
4853         }
4854
4855         return (error);
4856 }
4857
4858 static int
4859 zfsdev_close(dev_t dev, int flag, int otyp, cred_t *cr)
4860 {
4861         zfs_onexit_t *zo;
4862         minor_t minor = getminor(dev);
4863
4864         if (minor == 0)
4865                 return (0);
4866
4867         mutex_enter(&zfsdev_state_lock);
4868         zo = zfsdev_get_soft_state(minor, ZSST_CTLDEV);
4869         if (zo == NULL) {
4870                 mutex_exit(&zfsdev_state_lock);
4871                 return (zvol_close(dev, flag, otyp, cr));
4872         }
4873         zfs_ctldev_destroy(zo, minor);
4874         mutex_exit(&zfsdev_state_lock);
4875
4876         return (0);
4877 }
4878
4879 static int
4880 zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
4881 {
4882         zfs_cmd_t *zc;
4883         uint_t vec;
4884         int error, rc;
4885         minor_t minor = getminor(dev);
4886
4887         if (minor != 0 &&
4888             zfsdev_get_soft_state(minor, ZSST_CTLDEV) == NULL)
4889                 return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
4890
4891         vec = cmd - ZFS_IOC;
4892         ASSERT3U(getmajor(dev), ==, ddi_driver_major(zfs_dip));
4893
4894         if (vec >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
4895                 return (EINVAL);
4896
4897         zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
4898
4899         error = ddi_copyin((void *)arg, zc, sizeof (zfs_cmd_t), flag);
4900         if (error != 0)
4901                 error = EFAULT;
4902
4903         if ((error == 0) && !(flag & FKIOCTL))
4904                 error = zfs_ioc_vec[vec].zvec_secpolicy(zc, cr);
4905
4906         /*
4907          * Ensure that all pool/dataset names are valid before we pass down to
4908          * the lower layers.
4909          */
4910         if (error == 0) {
4911                 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
4912                 zc->zc_iflags = flag & FKIOCTL;
4913                 switch (zfs_ioc_vec[vec].zvec_namecheck) {
4914                 case POOL_NAME:
4915                         if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
4916                                 error = EINVAL;
4917                         error = pool_status_check(zc->zc_name,
4918                             zfs_ioc_vec[vec].zvec_namecheck,
4919                             zfs_ioc_vec[vec].zvec_pool_check);
4920                         break;
4921
4922                 case DATASET_NAME:
4923                         if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
4924                                 error = EINVAL;
4925                         error = pool_status_check(zc->zc_name,
4926                             zfs_ioc_vec[vec].zvec_namecheck,
4927                             zfs_ioc_vec[vec].zvec_pool_check);
4928                         break;
4929
4930                 case NO_NAME:
4931                         break;
4932                 }
4933         }
4934
4935         if (error == 0)
4936                 error = zfs_ioc_vec[vec].zvec_func(zc);
4937
4938         rc = ddi_copyout(zc, (void *)arg, sizeof (zfs_cmd_t), flag);
4939         if (error == 0) {
4940                 if (rc != 0)
4941                         error = EFAULT;
4942                 if (zfs_ioc_vec[vec].zvec_his_log)
4943                         zfs_log_history(zc);
4944         }
4945
4946         kmem_free(zc, sizeof (zfs_cmd_t));
4947         return (error);
4948 }
4949
4950 static int
4951 zfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
4952 {
4953         if (cmd != DDI_ATTACH)
4954                 return (DDI_FAILURE);
4955
4956         if (ddi_create_minor_node(dip, "zfs", S_IFCHR, 0,
4957             DDI_PSEUDO, 0) == DDI_FAILURE)
4958                 return (DDI_FAILURE);
4959
4960         zfs_dip = dip;
4961
4962         ddi_report_dev(dip);
4963
4964         return (DDI_SUCCESS);
4965 }
4966
4967 static int
4968 zfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
4969 {
4970         if (spa_busy() || zfs_busy() || zvol_busy())
4971                 return (DDI_FAILURE);
4972
4973         if (cmd != DDI_DETACH)
4974                 return (DDI_FAILURE);
4975
4976         zfs_dip = NULL;
4977
4978         ddi_prop_remove_all(dip);
4979         ddi_remove_minor_node(dip, NULL);
4980
4981         return (DDI_SUCCESS);
4982 }
4983
4984 /*ARGSUSED*/
4985 static int
4986 zfs_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
4987 {
4988         switch (infocmd) {
4989         case DDI_INFO_DEVT2DEVINFO:
4990                 *result = zfs_dip;
4991                 return (DDI_SUCCESS);
4992
4993         case DDI_INFO_DEVT2INSTANCE:
4994                 *result = (void *)0;
4995                 return (DDI_SUCCESS);
4996         }
4997
4998         return (DDI_FAILURE);
4999 }
5000
5001 /*
5002  * OK, so this is a little weird.
5003  *
5004  * /dev/zfs is the control node, i.e. minor 0.
5005  * /dev/zvol/[r]dsk/pool/dataset are the zvols, minor > 0.
5006  *
5007  * /dev/zfs has basically nothing to do except serve up ioctls,
5008  * so most of the standard driver entry points are in zvol.c.
5009  */
5010 static struct cb_ops zfs_cb_ops = {
5011         zfsdev_open,    /* open */
5012         zfsdev_close,   /* close */
5013         zvol_strategy,  /* strategy */
5014         nodev,          /* print */
5015         zvol_dump,      /* dump */
5016         zvol_read,      /* read */
5017         zvol_write,     /* write */
5018         zfsdev_ioctl,   /* ioctl */
5019         nodev,          /* devmap */
5020         nodev,          /* mmap */
5021         nodev,          /* segmap */
5022         nochpoll,       /* poll */
5023         ddi_prop_op,    /* prop_op */
5024         NULL,           /* streamtab */
5025         D_NEW | D_MP | D_64BIT,         /* Driver compatibility flag */
5026         CB_REV,         /* version */
5027         nodev,          /* async read */
5028         nodev,          /* async write */
5029 };
5030
5031 static struct dev_ops zfs_dev_ops = {
5032         DEVO_REV,       /* version */
5033         0,              /* refcnt */
5034         zfs_info,       /* info */
5035         nulldev,        /* identify */
5036         nulldev,        /* probe */
5037         zfs_attach,     /* attach */
5038         zfs_detach,     /* detach */
5039         nodev,          /* reset */
5040         &zfs_cb_ops,    /* driver operations */
5041         NULL,           /* no bus operations */
5042         NULL,           /* power */
5043         ddi_quiesce_not_needed, /* quiesce */
5044 };
5045
5046 static struct modldrv zfs_modldrv = {
5047         &mod_driverops,
5048         "ZFS storage pool",
5049         &zfs_dev_ops
5050 };
5051
5052 static struct modlinkage modlinkage = {
5053         MODREV_1,
5054         (void *)&zfs_modlfs,
5055         (void *)&zfs_modldrv,
5056         NULL
5057 };
5058
5059
5060 uint_t zfs_fsyncer_key;
5061 extern uint_t rrw_tsd_key;
5062
5063 int
5064 _init(void)
5065 {
5066         int error;
5067
5068         spa_init(FREAD | FWRITE);
5069         zfs_init();
5070         zvol_init();
5071
5072         if ((error = mod_install(&modlinkage)) != 0) {
5073                 zvol_fini();
5074                 zfs_fini();
5075                 spa_fini();
5076                 return (error);
5077         }
5078
5079         tsd_create(&zfs_fsyncer_key, NULL);
5080         tsd_create(&rrw_tsd_key, NULL);
5081
5082         error = ldi_ident_from_mod(&modlinkage, &zfs_li);
5083         ASSERT(error == 0);
5084         mutex_init(&zfs_share_lock, NULL, MUTEX_DEFAULT, NULL);
5085
5086         return (0);
5087 }
5088
5089 int
5090 _fini(void)
5091 {
5092         int error;
5093
5094         if (spa_busy() || zfs_busy() || zvol_busy() || zio_injection_enabled)
5095                 return (EBUSY);
5096
5097         if ((error = mod_remove(&modlinkage)) != 0)
5098                 return (error);
5099
5100         zvol_fini();
5101         zfs_fini();
5102         spa_fini();
5103         if (zfs_nfsshare_inited)
5104                 (void) ddi_modclose(nfs_mod);
5105         if (zfs_smbshare_inited)
5106                 (void) ddi_modclose(smbsrv_mod);
5107         if (zfs_nfsshare_inited || zfs_smbshare_inited)
5108                 (void) ddi_modclose(sharefs_mod);
5109
5110         tsd_destroy(&zfs_fsyncer_key);
5111         ldi_ident_release(zfs_li);
5112         zfs_li = NULL;
5113         mutex_destroy(&zfs_share_lock);
5114
5115         return (error);
5116 }
5117
5118 int
5119 _info(struct modinfo *modinfop)
5120 {
5121         return (mod_info(&modlinkage, modinfop));
5122 }