sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.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 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <sys/systm.h>
  29 #include <sys/kernel.h>
  30 #include <sys/sysmacros.h>
  31 #include <sys/kmem.h>
  32 #include <sys/acl.h>
  33 #include <sys/vnode.h>
  34 #include <sys/vfs.h>
  35 #include <sys/mntent.h>
  36 #include <sys/mount.h>
  37 #include <sys/cmn_err.h>
  38 #include <sys/zfs_znode.h>
  39 #include <sys/zfs_dir.h>
  40 #include <sys/zil.h>
  41 #include <sys/fs/zfs.h>
  42 #include <sys/dmu.h>
  43 #include <sys/dsl_prop.h>
  44 #include <sys/dsl_dataset.h>
  45 #include <sys/dsl_deleg.h>
  46 #include <sys/spa.h>
  47 #include <sys/zap.h>
  48 #include <sys/varargs.h>
  49 #include <sys/policy.h>
  50 #include <sys/atomic.h>
  51 #include <sys/zfs_ioctl.h>
  52 #include <sys/zfs_ctldir.h>
  53 #include <sys/zfs_fuid.h>
  54 #include <sys/sunddi.h>
  55 #include <sys/dnlc.h>
  56 #include <sys/dmu_objset.h>
  57 #include <sys/spa_boot.h>
  58 #include <sys/vdev_impl.h>      /* VDEV_BOOT_VERSION */
  59
  60 struct mtx zfs_debug_mtx;
  61 MTX_SYSINIT(zfs_debug_mtx, &zfs_debug_mtx, "zfs_debug", MTX_DEF);
  62
  63 SYSCTL_NODE(_vfs, OID_AUTO, zfs, CTLFLAG_RW, 0, "ZFS file system");
  64
  65 int zfs_super_owner = 0;
  66 SYSCTL_INT(_vfs_zfs, OID_AUTO, super_owner, CTLFLAG_RW, &zfs_super_owner, 0,
  67     "File system owner can perform privileged operation on his file systems");
  68
  69 int zfs_debug_level = 0;
  70 TUNABLE_INT("vfs.zfs.debug", &zfs_debug_level);
  71 SYSCTL_INT(_vfs_zfs, OID_AUTO, debug, CTLFLAG_RW, &zfs_debug_level, 0,
  72     "Debug level");
  73
  74 SYSCTL_NODE(_vfs_zfs, OID_AUTO, version, CTLFLAG_RD, 0, "ZFS versions");
  75 static int zfs_version_acl = ZFS_ACL_VERSION;
  76 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, acl, CTLFLAG_RD, &zfs_version_acl, 0,
  77     "ZFS_ACL_VERSION");
  78 static int zfs_version_dmu_backup_header = DMU_BACKUP_HEADER_VERSION;
  79 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, dmu_backup_header, CTLFLAG_RD,
  80     &zfs_version_dmu_backup_header, 0, "DMU_BACKUP_HEADER_VERSION");
  81 static int zfs_version_dmu_backup_stream = DMU_BACKUP_STREAM_VERSION;
  82 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, dmu_backup_stream, CTLFLAG_RD,
  83     &zfs_version_dmu_backup_stream, 0, "DMU_BACKUP_STREAM_VERSION");
  84 static int zfs_version_spa = SPA_VERSION;
  85 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, spa, CTLFLAG_RD, &zfs_version_spa, 0,
  86     "SPA_VERSION");
  87 static int zfs_version_vdev_boot = VDEV_BOOT_VERSION;
  88 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, vdev_boot, CTLFLAG_RD,
  89     &zfs_version_vdev_boot, 0, "VDEV_BOOT_VERSION");
  90 static int zfs_version_zpl = ZPL_VERSION;
  91 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, zpl, CTLFLAG_RD, &zfs_version_zpl, 0,
  92     "ZPL_VERSION");
  93
  94 static int zfs_mount(vfs_t *vfsp);
  95 static int zfs_umount(vfs_t *vfsp, int fflag);
  96 static int zfs_root(vfs_t *vfsp, int flags, vnode_t **vpp);
  97 static int zfs_statfs(vfs_t *vfsp, struct statfs *statp);
  98 static int zfs_vget(vfs_t *vfsp, ino_t ino, int flags, vnode_t **vpp);
  99 static int zfs_sync(vfs_t *vfsp, int waitfor);
 100 static int zfs_checkexp(vfs_t *vfsp, struct sockaddr *nam, int *extflagsp,
 101     struct ucred **credanonp, int *numsecflavors, int **secflavors);
 102 static int zfs_fhtovp(vfs_t *vfsp, fid_t *fidp, vnode_t **vpp);
 103 static void zfs_objset_close(zfsvfs_t *zfsvfs);
 104 static void zfs_freevfs(vfs_t *vfsp);
 105
 106 static struct vfsops zfs_vfsops = {
 107         .vfs_mount =            zfs_mount,
 108         .vfs_unmount =          zfs_umount,
 109         .vfs_root =             zfs_root,
 110         .vfs_statfs =           zfs_statfs,
 111         .vfs_vget =             zfs_vget,
 112         .vfs_sync =             zfs_sync,
 113         .vfs_checkexp =         zfs_checkexp,
 114         .vfs_fhtovp =           zfs_fhtovp,
 115 };
 116
 117 VFS_SET(zfs_vfsops, zfs, VFCF_JAIL | VFCF_DELEGADMIN);
 118
 119 /*
 120  * We need to keep a count of active fs's.
 121  * This is necessary to prevent our module
 122  * from being unloaded after a umount -f
 123  */
 124 static uint32_t zfs_active_fs_count = 0;
 125
 126 /*ARGSUSED*/
 127 static int
 128 zfs_sync(vfs_t *vfsp, int waitfor)
 129 {
 130
 131         /*
 132          * Data integrity is job one.  We don't want a compromised kernel
 133          * writing to the storage pool, so we never sync during panic.
 134          */
 135         if (panicstr)
 136                 return (0);
 137
 138         if (vfsp != NULL) {
 139                 /*
 140                  * Sync a specific filesystem.
 141                  */
 142                 zfsvfs_t *zfsvfs = vfsp->vfs_data;
 143                 int error;
 144
 145                 error = vfs_stdsync(vfsp, waitfor);
 146                 if (error != 0)
 147                         return (error);
 148
 149                 ZFS_ENTER(zfsvfs);
 150                 if (zfsvfs->z_log != NULL)
 151                         zil_commit(zfsvfs->z_log, UINT64_MAX, 0);
 152                 else
 153                         txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
 154                 ZFS_EXIT(zfsvfs);
 155         } else {
 156                 /*
 157                  * Sync all ZFS filesystems.  This is what happens when you
 158                  * run sync(1M).  Unlike other filesystems, ZFS honors the
 159                  * request by waiting for all pools to commit all dirty data.
 160                  */
 161                 spa_sync_allpools();
 162         }
 163
 164         return (0);
 165 }
 166
 167 static void
 168 atime_changed_cb(void *arg, uint64_t newval)
 169 {
 170         zfsvfs_t *zfsvfs = arg;
 171
 172         if (newval == TRUE) {
 173                 zfsvfs->z_atime = TRUE;
 174                 zfsvfs->z_vfs->vfs_flag &= ~MNT_NOATIME;
 175                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
 176                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
 177         } else {
 178                 zfsvfs->z_atime = FALSE;
 179                 zfsvfs->z_vfs->vfs_flag |= MNT_NOATIME;
 180                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
 181                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
 182         }
 183 }
 184
 185 static void
 186 xattr_changed_cb(void *arg, uint64_t newval)
 187 {
 188         zfsvfs_t *zfsvfs = arg;
 189
 190         if (newval == TRUE) {
 191                 /* XXX locking on vfs_flag? */
 192 #ifdef TODO
 193                 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
 194 #endif
 195                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
 196                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
 197         } else {
 198                 /* XXX locking on vfs_flag? */
 199 #ifdef TODO
 200                 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
 201 #endif
 202                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
 203                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
 204         }
 205 }
 206
 207 static void
 208 blksz_changed_cb(void *arg, uint64_t newval)
 209 {
 210         zfsvfs_t *zfsvfs = arg;
 211
 212         if (newval < SPA_MINBLOCKSIZE ||
 213             newval > SPA_MAXBLOCKSIZE || !ISP2(newval))
 214                 newval = SPA_MAXBLOCKSIZE;
 215
 216         zfsvfs->z_max_blksz = newval;
 217         zfsvfs->z_vfs->vfs_bsize = newval;
 218 }
 219
 220 static void
 221 readonly_changed_cb(void *arg, uint64_t newval)
 222 {
 223         zfsvfs_t *zfsvfs = arg;
 224
 225         if (newval) {
 226                 /* XXX locking on vfs_flag? */
 227                 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
 228                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
 229                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
 230         } else {
 231                 /* XXX locking on vfs_flag? */
 232                 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
 233                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
 234                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
 235         }
 236 }
 237
 238 static void
 239 setuid_changed_cb(void *arg, uint64_t newval)
 240 {
 241         zfsvfs_t *zfsvfs = arg;
 242
 243         if (newval == FALSE) {
 244                 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
 245                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
 246                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
 247         } else {
 248                 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
 249                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
 250                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
 251         }
 252 }
 253
 254 static void
 255 exec_changed_cb(void *arg, uint64_t newval)
 256 {
 257         zfsvfs_t *zfsvfs = arg;
 258
 259         if (newval == FALSE) {
 260                 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
 261                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
 262                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
 263         } else {
 264                 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
 265                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
 266                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
 267         }
 268 }
 269
 270 /*
 271  * The nbmand mount option can be changed at mount time.
 272  * We can't allow it to be toggled on live file systems or incorrect
 273  * behavior may be seen from cifs clients
 274  *
 275  * This property isn't registered via dsl_prop_register(), but this callback
 276  * will be called when a file system is first mounted
 277  */
 278 static void
 279 nbmand_changed_cb(void *arg, uint64_t newval)
 280 {
 281         zfsvfs_t *zfsvfs = arg;
 282         if (newval == FALSE) {
 283                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
 284                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
 285         } else {
 286                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
 287                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
 288         }
 289 }
 290
 291 static void
 292 snapdir_changed_cb(void *arg, uint64_t newval)
 293 {
 294         zfsvfs_t *zfsvfs = arg;
 295
 296         zfsvfs->z_show_ctldir = newval;
 297 }
 298
 299 static void
 300 vscan_changed_cb(void *arg, uint64_t newval)
 301 {
 302         zfsvfs_t *zfsvfs = arg;
 303
 304         zfsvfs->z_vscan = newval;
 305 }
 306
 307 static void
 308 acl_mode_changed_cb(void *arg, uint64_t newval)
 309 {
 310         zfsvfs_t *zfsvfs = arg;
 311
 312         zfsvfs->z_acl_mode = newval;
 313 }
 314
 315 static void
 316 acl_inherit_changed_cb(void *arg, uint64_t newval)
 317 {
 318         zfsvfs_t *zfsvfs = arg;
 319
 320         zfsvfs->z_acl_inherit = newval;
 321 }
 322
 323 static int
 324 zfs_register_callbacks(vfs_t *vfsp)
 325 {
 326         struct dsl_dataset *ds = NULL;
 327         objset_t *os = NULL;
 328         zfsvfs_t *zfsvfs = NULL;
 329         uint64_t nbmand;
 330         int readonly, do_readonly = FALSE;
 331         int setuid, do_setuid = FALSE;
 332         int exec, do_exec = FALSE;
 333         int xattr, do_xattr = FALSE;
 334         int atime, do_atime = FALSE;
 335         int error = 0;
 336
 337         ASSERT(vfsp);
 338         zfsvfs = vfsp->vfs_data;
 339         ASSERT(zfsvfs);
 340         os = zfsvfs->z_os;
 341
 342         /*
 343          * This function can be called for a snapshot when we update snapshot's
 344          * mount point, which isn't really supported.
 345          */
 346         if (dmu_objset_is_snapshot(os))
 347                 return (EOPNOTSUPP);
 348
 349         /*
 350          * The act of registering our callbacks will destroy any mount
 351          * options we may have.  In order to enable temporary overrides
 352          * of mount options, we stash away the current values and
 353          * restore them after we register the callbacks.
 354          */
 355         if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
 356                 readonly = B_TRUE;
 357                 do_readonly = B_TRUE;
 358         } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
 359                 readonly = B_FALSE;
 360                 do_readonly = B_TRUE;
 361         }
 362         if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
 363                 setuid = B_FALSE;
 364                 do_setuid = B_TRUE;
 365         } else {
 366                 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
 367                         setuid = B_FALSE;
 368                         do_setuid = B_TRUE;
 369                 } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
 370                         setuid = B_TRUE;
 371                         do_setuid = B_TRUE;
 372                 }
 373         }
 374         if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
 375                 exec = B_FALSE;
 376                 do_exec = B_TRUE;
 377         } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
 378                 exec = B_TRUE;
 379                 do_exec = B_TRUE;
 380         }
 381         if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
 382                 xattr = B_FALSE;
 383                 do_xattr = B_TRUE;
 384         } else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
 385                 xattr = B_TRUE;
 386                 do_xattr = B_TRUE;
 387         }
 388         if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
 389                 atime = B_FALSE;
 390                 do_atime = B_TRUE;
 391         } else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
 392                 atime = B_TRUE;
 393                 do_atime = B_TRUE;
 394         }
 395
 396         /*
 397          * nbmand is a special property.  It can only be changed at
 398          * mount time.
 399          *
 400          * This is weird, but it is documented to only be changeable
 401          * at mount time.
 402          */
 403         if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
 404                 nbmand = B_FALSE;
 405         } else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
 406                 nbmand = B_TRUE;
 407         } else {
 408                 char osname[MAXNAMELEN];
 409
 410                 dmu_objset_name(os, osname);
 411                 if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand,
 412                     NULL)) {
 413                         return (error);
 414                 }
 415         }
 416
 417         /*
 418          * Register property callbacks.
 419          *
 420          * It would probably be fine to just check for i/o error from
 421          * the first prop_register(), but I guess I like to go
 422          * overboard...
 423          */
 424         ds = dmu_objset_ds(os);
 425         error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);
 426         error = error ? error : dsl_prop_register(ds,
 427             "xattr", xattr_changed_cb, zfsvfs);
 428         error = error ? error : dsl_prop_register(ds,
 429             "recordsize", blksz_changed_cb, zfsvfs);
 430         error = error ? error : dsl_prop_register(ds,
 431             "readonly", readonly_changed_cb, zfsvfs);
 432         error = error ? error : dsl_prop_register(ds,
 433             "setuid", setuid_changed_cb, zfsvfs);
 434         error = error ? error : dsl_prop_register(ds,
 435             "exec", exec_changed_cb, zfsvfs);
 436         error = error ? error : dsl_prop_register(ds,
 437             "snapdir", snapdir_changed_cb, zfsvfs);
 438         error = error ? error : dsl_prop_register(ds,
 439             "aclmode", acl_mode_changed_cb, zfsvfs);
 440         error = error ? error : dsl_prop_register(ds,
 441             "aclinherit", acl_inherit_changed_cb, zfsvfs);
 442         error = error ? error : dsl_prop_register(ds,
 443             "vscan", vscan_changed_cb, zfsvfs);
 444         if (error)
 445                 goto unregister;
 446
 447         /*
 448          * Invoke our callbacks to restore temporary mount options.
 449          */
 450         if (do_readonly)
 451                 readonly_changed_cb(zfsvfs, readonly);
 452         if (do_setuid)
 453                 setuid_changed_cb(zfsvfs, setuid);
 454         if (do_exec)
 455                 exec_changed_cb(zfsvfs, exec);
 456         if (do_xattr)
 457                 xattr_changed_cb(zfsvfs, xattr);
 458         if (do_atime)
 459                 atime_changed_cb(zfsvfs, atime);
 460
 461         nbmand_changed_cb(zfsvfs, nbmand);
 462
 463         return (0);
 464
 465 unregister:
 466         /*
 467          * We may attempt to unregister some callbacks that are not
 468          * registered, but this is OK; it will simply return ENOMSG,
 469          * which we will ignore.
 470          */
 471         (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);
 472         (void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs);
 473         (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);
 474         (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);
 475         (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);
 476         (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);
 477         (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);
 478         (void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs);
 479         (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
 480             zfsvfs);
 481         (void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs);
 482         return (error);
 483
 484 }
 485
 486 static int
 487 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
 488 {
 489         int error;
 490
 491         error = zfs_register_callbacks(zfsvfs->z_vfs);
 492         if (error)
 493                 return (error);
 494
 495         /*
 496          * Set the objset user_ptr to track its zfsvfs.
 497          */
 498         mutex_enter(&zfsvfs->z_os->os->os_user_ptr_lock);
 499         dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
 500         mutex_exit(&zfsvfs->z_os->os->os_user_ptr_lock);
 501
 502         /*
 503          * If we are not mounting (ie: online recv), then we don't
 504          * have to worry about replaying the log as we blocked all
 505          * operations out since we closed the ZIL.
 506          */
 507         if (mounting) {
 508                 boolean_t readonly;
 509
 510                 /*
 511                  * During replay we remove the read only flag to
 512                  * allow replays to succeed.
 513                  */
 514                 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
 515                 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
 516
 517                 /*
 518                  * Parse and replay the intent log.
 519                  */
 520                 zil_replay(zfsvfs->z_os, zfsvfs, &zfsvfs->z_assign,
 521                     zfs_replay_vector, zfs_unlinked_drain);
 522
 523                 zfs_unlinked_drain(zfsvfs);
 524                 zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */
 525         }
 526
 527         if (!zil_disable)
 528                 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
 529
 530         return (0);
 531 }
 532
 533 static void
 534 zfs_freezfsvfs(zfsvfs_t *zfsvfs)
 535 {
 536         mutex_destroy(&zfsvfs->z_znodes_lock);
 537         mutex_destroy(&zfsvfs->z_online_recv_lock);
 538         list_destroy(&zfsvfs->z_all_znodes);
 539         rrw_destroy(&zfsvfs->z_teardown_lock);
 540         rw_destroy(&zfsvfs->z_teardown_inactive_lock);
 541         rw_destroy(&zfsvfs->z_fuid_lock);
 542         kmem_free(zfsvfs, sizeof (zfsvfs_t));
 543 }
 544
 545 static int
 546 zfs_domount(vfs_t *vfsp, char *osname)
 547 {
 548         uint64_t recordsize, readonly;
 549         int error = 0;
 550         int mode;
 551         zfsvfs_t *zfsvfs;
 552         znode_t *zp = NULL;
 553
 554         ASSERT(vfsp);
 555         ASSERT(osname);
 556
 557         /*
 558          * Initialize the zfs-specific filesystem structure.
 559          * Should probably make this a kmem cache, shuffle fields,
 560          * and just bzero up to z_hold_mtx[].
 561          */
 562         zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
 563         zfsvfs->z_vfs = vfsp;
 564         zfsvfs->z_parent = zfsvfs;
 565         zfsvfs->z_assign = TXG_NOWAIT;
 566         zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE;
 567         zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
 568
 569         mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
 570         mutex_init(&zfsvfs->z_online_recv_lock, NULL, MUTEX_DEFAULT, NULL);
 571         list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
 572             offsetof(znode_t, z_link_node));
 573         rrw_init(&zfsvfs->z_teardown_lock);
 574         rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
 575         rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
 576
 577         if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
 578             NULL))
 579                 goto out;
 580         zfsvfs->z_vfs->vfs_bsize = recordsize;
 581
 582         vfsp->vfs_data = zfsvfs;
 583         vfsp->mnt_flag |= MNT_LOCAL;
 584         vfsp->mnt_kern_flag |= MNTK_MPSAFE;
 585         vfsp->mnt_kern_flag |= MNTK_LOOKUP_SHARED;
 586         vfsp->mnt_kern_flag |= MNTK_SHARED_WRITES;
 587
 588         if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL))
 589                 goto out;
 590
 591         mode = DS_MODE_OWNER;
 592         if (readonly)
 593                 mode |= DS_MODE_READONLY;
 594
 595         error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
 596         if (error == EROFS) {
 597                 mode = DS_MODE_OWNER | DS_MODE_READONLY;
 598                 error = dmu_objset_open(osname, DMU_OST_ZFS, mode,
 599                     &zfsvfs->z_os);
 600         }
 601
 602         if (error)
 603                 goto out;
 604
 605         if (error = zfs_init_fs(zfsvfs, &zp))
 606                 goto out;
 607
 608         /*
 609          * Set features for file system.
 610          */
 611         zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
 612         if (zfsvfs->z_use_fuids) {
 613                 vfs_set_feature(vfsp, VFSFT_XVATTR);
 614                 vfs_set_feature(vfsp, VFSFT_SYSATTR_VIEWS);
 615                 vfs_set_feature(vfsp, VFSFT_ACEMASKONACCESS);
 616                 vfs_set_feature(vfsp, VFSFT_ACLONCREATE);
 617         }
 618         if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 619                 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
 620                 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
 621                 vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
 622         } else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
 623                 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
 624                 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
 625         }
 626
 627         if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
 628                 uint64_t pval;
 629
 630                 ASSERT(mode & DS_MODE_READONLY);
 631                 atime_changed_cb(zfsvfs, B_FALSE);
 632                 readonly_changed_cb(zfsvfs, B_TRUE);
 633                 if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL))
 634                         goto out;
 635                 xattr_changed_cb(zfsvfs, pval);
 636                 zfsvfs->z_issnap = B_TRUE;
 637         } else {
 638                 error = zfsvfs_setup(zfsvfs, B_TRUE);
 639         }
 640
 641         vfs_mountedfrom(vfsp, osname);
 642
 643         if (!zfsvfs->z_issnap)
 644                 zfsctl_create(zfsvfs);
 645 out:
 646         if (error) {
 647                 if (zfsvfs->z_os)
 648                         dmu_objset_close(zfsvfs->z_os);
 649                 zfs_freezfsvfs(zfsvfs);
 650         } else {
 651                 atomic_add_32(&zfs_active_fs_count, 1);
 652         }
 653
 654         return (error);
 655 }
 656
 657 void
 658 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
 659 {
 660         objset_t *os = zfsvfs->z_os;
 661         struct dsl_dataset *ds;
 662
 663         /*
 664          * Unregister properties.
 665          */
 666         if (!dmu_objset_is_snapshot(os)) {
 667                 ds = dmu_objset_ds(os);
 668                 VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
 669                     zfsvfs) == 0);
 670
 671                 VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb,
 672                     zfsvfs) == 0);
 673
 674                 VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb,
 675                     zfsvfs) == 0);
 676
 677                 VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb,
 678                     zfsvfs) == 0);
 679
 680                 VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb,
 681                     zfsvfs) == 0);
 682
 683                 VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb,
 684                     zfsvfs) == 0);
 685
 686                 VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
 687                     zfsvfs) == 0);
 688
 689                 VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb,
 690                     zfsvfs) == 0);
 691
 692                 VERIFY(dsl_prop_unregister(ds, "aclinherit",
 693                     acl_inherit_changed_cb, zfsvfs) == 0);
 694
 695                 VERIFY(dsl_prop_unregister(ds, "vscan",
 696                     vscan_changed_cb, zfsvfs) == 0);
 697         }
 698 }
 699
 700 /*ARGSUSED*/
 701 static int
 702 zfs_mount(vfs_t *vfsp)
 703 {
 704         kthread_t       *td = curthread;
 705         vnode_t         *mvp = vfsp->mnt_vnodecovered;
 706         cred_t          *cr = td->td_ucred;
 707         char            *osname;
 708         int             error = 0;
 709         int             canwrite;
 710
 711         if (vfs_getopt(vfsp->mnt_optnew, "from", (void **)&osname, NULL))
 712                 return (EINVAL);
 713
 714         /*
 715          * If full-owner-access is enabled and delegated administration is
 716          * turned on, we must set nosuid.
 717          */
 718         if (zfs_super_owner &&
 719             dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) != ECANCELED) {
 720                 secpolicy_fs_mount_clearopts(cr, vfsp);
 721         }
 722
 723         /*
 724          * Check for mount privilege?
 725          *
 726          * If we don't have privilege then see if
 727          * we have local permission to allow it
 728          */
 729         error = secpolicy_fs_mount(cr, mvp, vfsp);
 730         if (error) {
 731                 error = dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr);
 732                 if (error != 0)
 733                         goto out;
 734
 735                 if (!(vfsp->vfs_flag & MS_REMOUNT)) {
 736                         vattr_t         vattr;
 737
 738                         /*
 739                          * Make sure user is the owner of the mount point
 740                          * or has sufficient privileges.
 741                          */
 742
 743                         vattr.va_mask = AT_UID;
 744
 745                         vn_lock(mvp, LK_SHARED | LK_RETRY);
 746                         if (error = VOP_GETATTR(mvp, &vattr, cr)) {
 747                                 VOP_UNLOCK(mvp, 0);
 748                                 goto out;
 749                         }
 750
 751 #if 0 /* CHECK THIS! Is probably needed for zfs_suser. */
 752                         if (secpolicy_vnode_owner(mvp, cr, vattr.va_uid) != 0 &&
 753                             VOP_ACCESS(mvp, VWRITE, cr, td) != 0) {
 754                                 error = EPERM;
 755                                 goto out;
 756                         }
 757 #else
 758                         if (error = secpolicy_vnode_owner(mvp, cr, vattr.va_uid)) {
 759                                 VOP_UNLOCK(mvp, 0);
 760                                 goto out;
 761                         }
 762
 763                         if (error = VOP_ACCESS(mvp, VWRITE, cr, td)) {
 764                                 VOP_UNLOCK(mvp, 0);
 765                                 goto out;
 766                         }
 767                         VOP_UNLOCK(mvp, 0);
 768 #endif
 769                 }
 770
 771                 secpolicy_fs_mount_clearopts(cr, vfsp);
 772         }
 773
 774         /*
 775          * Refuse to mount a filesystem if we are in a local zone and the
 776          * dataset is not visible.
 777          */
 778         if (!INGLOBALZONE(curthread) &&
 779             (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
 780                 error = EPERM;
 781                 goto out;
 782         }
 783
 784         /*
 785          * When doing a remount, we simply refresh our temporary properties
 786          * according to those options set in the current VFS options.
 787          */
 788         if (vfsp->vfs_flag & MS_REMOUNT) {
 789                 /* refresh mount options */
 790                 zfs_unregister_callbacks(vfsp->vfs_data);
 791                 error = zfs_register_callbacks(vfsp);
 792                 goto out;
 793         }
 794
 795         DROP_GIANT();
 796         error = zfs_domount(vfsp, osname);
 797         PICKUP_GIANT();
 798 out:
 799         return (error);
 800 }
 801
 802 static int
 803 zfs_statfs(vfs_t *vfsp, struct statfs *statp)
 804 {
 805         zfsvfs_t *zfsvfs = vfsp->vfs_data;
 806         uint64_t refdbytes, availbytes, usedobjs, availobjs;
 807
 808         statp->f_version = STATFS_VERSION;
 809
 810         ZFS_ENTER(zfsvfs);
 811
 812         dmu_objset_space(zfsvfs->z_os,
 813             &refdbytes, &availbytes, &usedobjs, &availobjs);
 814
 815         /*
 816          * The underlying storage pool actually uses multiple block sizes.
 817          * We report the fragsize as the smallest block size we support,
 818          * and we report our blocksize as the filesystem's maximum blocksize.
 819          */
 820         statp->f_bsize = zfsvfs->z_vfs->vfs_bsize;
 821         statp->f_iosize = zfsvfs->z_vfs->vfs_bsize;
 822
 823         /*
 824          * The following report "total" blocks of various kinds in the
 825          * file system, but reported in terms of f_frsize - the
 826          * "fragment" size.
 827          */
 828
 829         statp->f_blocks = (refdbytes + availbytes) / statp->f_bsize;
 830         statp->f_bfree = availbytes / statp->f_bsize;
 831         statp->f_bavail = statp->f_bfree; /* no root reservation */
 832
 833         /*
 834          * statvfs() should really be called statufs(), because it assumes
 835          * static metadata.  ZFS doesn't preallocate files, so the best
 836          * we can do is report the max that could possibly fit in f_files,
 837          * and that minus the number actually used in f_ffree.
 838          * For f_ffree, report the smaller of the number of object available
 839          * and the number of blocks (each object will take at least a block).
 840          */
 841         statp->f_ffree = MIN(availobjs, statp->f_bfree);
 842         statp->f_files = statp->f_ffree + usedobjs;
 843
 844         /*
 845          * We're a zfs filesystem.
 846          */
 847         (void) strlcpy(statp->f_fstypename, "zfs", sizeof(statp->f_fstypename));
 848
 849         strlcpy(statp->f_mntfromname, vfsp->mnt_stat.f_mntfromname,
 850             sizeof(statp->f_mntfromname));
 851         strlcpy(statp->f_mntonname, vfsp->mnt_stat.f_mntonname,
 852             sizeof(statp->f_mntonname));
 853
 854         statp->f_namemax = ZFS_MAXNAMELEN;
 855
 856         ZFS_EXIT(zfsvfs);
 857         return (0);
 858 }
 859
 860 static int
 861 zfs_root(vfs_t *vfsp, int flags, vnode_t **vpp)
 862 {
 863         zfsvfs_t *zfsvfs = vfsp->vfs_data;
 864         znode_t *rootzp;
 865         int error;
 866
 867         ZFS_ENTER(zfsvfs);
 868
 869         error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
 870         if (error == 0) {
 871                 *vpp = ZTOV(rootzp);
 872                 error = vn_lock(*vpp, flags);
 873                 (*vpp)->v_vflag |= VV_ROOT;
 874         }
 875
 876         ZFS_EXIT(zfsvfs);
 877         return (error);
 878 }
 879
 880 /*
 881  * Teardown the zfsvfs::z_os.
 882  *
 883  * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock'
 884  * and 'z_teardown_inactive_lock' held.
 885  */
 886 static int
 887 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
 888 {
 889         znode_t *zp;
 890
 891         rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
 892
 893         if (!unmounting) {
 894                 /*
 895                  * We purge the parent filesystem's vfsp as the parent
 896                  * filesystem and all of its snapshots have their vnode's
 897                  * v_vfsp set to the parent's filesystem's vfsp.  Note,
 898                  * 'z_parent' is self referential for non-snapshots.
 899                  */
 900                 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
 901         }
 902
 903         /*
 904          * Close the zil. NB: Can't close the zil while zfs_inactive
 905          * threads are blocked as zil_close can call zfs_inactive.
 906          */
 907         if (zfsvfs->z_log) {
 908                 zil_close(zfsvfs->z_log);
 909                 zfsvfs->z_log = NULL;
 910         }
 911
 912         rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
 913
 914         /*
 915          * If we are not unmounting (ie: online recv) and someone already
 916          * unmounted this file system while we were doing the switcheroo,
 917          * or a reopen of z_os failed then just bail out now.
 918          */
 919         if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
 920                 rw_exit(&zfsvfs->z_teardown_inactive_lock);
 921                 rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
 922                 return (EIO);
 923         }
 924
 925         /*
 926          * At this point there are no vops active, and any new vops will
 927          * fail with EIO since we have z_teardown_lock for writer (only
 928          * relavent for forced unmount).
 929          *
 930          * Release all holds on dbufs.
 931          */
 932         mutex_enter(&zfsvfs->z_znodes_lock);
 933         for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
 934             zp = list_next(&zfsvfs->z_all_znodes, zp))
 935                 if (zp->z_dbuf) {
 936                         ASSERT(ZTOV(zp)->v_count >= 0);
 937                         zfs_znode_dmu_fini(zp);
 938                 }
 939         mutex_exit(&zfsvfs->z_znodes_lock);
 940
 941         /*
 942          * If we are unmounting, set the unmounted flag and let new vops
 943          * unblock.  zfs_inactive will have the unmounted behavior, and all
 944          * other vops will fail with EIO.
 945          */
 946         if (unmounting) {
 947                 zfsvfs->z_unmounted = B_TRUE;
 948                 rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
 949                 rw_exit(&zfsvfs->z_teardown_inactive_lock);
 950
 951 #ifdef __FreeBSD__
 952                 /*
 953                  * Some znodes might not be fully reclaimed, wait for them.
 954                  */
 955                 mutex_enter(&zfsvfs->z_znodes_lock);
 956                 while (list_head(&zfsvfs->z_all_znodes) != NULL) {
 957                         msleep(zfsvfs, &zfsvfs->z_znodes_lock, 0,
 958                             "zteardown", 0);
 959                 }
 960                 mutex_exit(&zfsvfs->z_znodes_lock);
 961 #endif
 962         }
 963
 964         /*
 965          * z_os will be NULL if there was an error in attempting to reopen
 966          * zfsvfs, so just return as the properties had already been
 967          * unregistered and cached data had been evicted before.
 968          */
 969         if (zfsvfs->z_os == NULL)
 970                 return (0);
 971
 972         /*
 973          * Unregister properties.
 974          */
 975         zfs_unregister_callbacks(zfsvfs);
 976
 977         /*
 978          * Evict cached data
 979          */
 980         if (dmu_objset_evict_dbufs(zfsvfs->z_os)) {
 981                 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
 982                 (void) dmu_objset_evict_dbufs(zfsvfs->z_os);
 983         }
 984
 985         return (0);
 986 }
 987
 988 /*ARGSUSED*/
 989 static int
 990 zfs_umount(vfs_t *vfsp, int fflag)
 991 {
 992         zfsvfs_t *zfsvfs = vfsp->vfs_data;
 993         objset_t *os;
 994         cred_t *cr = curthread->td_ucred;
 995         int ret;
 996
 997         if (fflag & MS_FORCE) {
 998                 /* TODO: Force unmount is not well implemented yet, so deny it. */
 999                 ZFS_LOG(0, "Force unmount is experimental - report any problems.");
1000         }
1001
1002         ret = secpolicy_fs_unmount(cr, vfsp);
1003         if (ret) {
1004                 ret = dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
1005                     ZFS_DELEG_PERM_MOUNT, cr);
1006                 if (ret)
1007                         return (ret);
1008         }
1009         /*
1010          * We purge the parent filesystem's vfsp as the parent filesystem
1011          * and all of its snapshots have their vnode's v_vfsp set to the
1012          * parent's filesystem's vfsp.  Note, 'z_parent' is self
1013          * referential for non-snapshots.
1014          */
1015         (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1016
1017         /*
1018          * Unmount any snapshots mounted under .zfs before unmounting the
1019          * dataset itself.
1020          */
1021         if (zfsvfs->z_ctldir != NULL) {
1022                 if ((ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0)
1023                         return (ret);
1024                 ret = vflush(vfsp, 0, 0, curthread);
1025                 ASSERT(ret == EBUSY);
1026                 if (!(fflag & MS_FORCE)) {
1027                         if (zfsvfs->z_ctldir->v_count > 1)
1028                                 return (EBUSY);
1029                         ASSERT(zfsvfs->z_ctldir->v_count == 1);
1030                 }
1031                 zfsctl_destroy(zfsvfs);
1032                 ASSERT(zfsvfs->z_ctldir == NULL);
1033         }
1034
1035         /*
1036          * Flush all the files.
1037          */
1038         ret = vflush(vfsp, 1, (fflag & MS_FORCE) ? FORCECLOSE : 0, curthread);
1039         if (ret != 0) {
1040                 if (!zfsvfs->z_issnap) {
1041                         zfsctl_create(zfsvfs);
1042                         ASSERT(zfsvfs->z_ctldir != NULL);
1043                 }
1044                 return (ret);
1045         }
1046
1047         if (!(fflag & MS_FORCE)) {
1048                 /*
1049                  * Check the number of active vnodes in the file system.
1050                  * Our count is maintained in the vfs structure, but the
1051                  * number is off by 1 to indicate a hold on the vfs
1052                  * structure itself.
1053                  *
1054                  * The '.zfs' directory maintains a reference of its
1055                  * own, and any active references underneath are
1056                  * reflected in the vnode count.
1057                  */
1058                 if (zfsvfs->z_ctldir == NULL) {
1059                         if (vfsp->vfs_count > 1)
1060                                 return (EBUSY);
1061                 } else {
1062                         if (vfsp->vfs_count > 2 ||
1063                             zfsvfs->z_ctldir->v_count > 1)
1064                                 return (EBUSY);
1065                 }
1066         } else {
1067                 MNT_ILOCK(vfsp);
1068                 vfsp->mnt_kern_flag |= MNTK_UNMOUNTF;
1069                 MNT_IUNLOCK(vfsp);
1070         }
1071
1072         VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
1073         os = zfsvfs->z_os;
1074
1075         /*
1076          * z_os will be NULL if there was an error in
1077          * attempting to reopen zfsvfs.
1078          */
1079         if (os != NULL) {
1080                 /*
1081                  * Unset the objset user_ptr.
1082                  */
1083                 mutex_enter(&os->os->os_user_ptr_lock);
1084                 dmu_objset_set_user(os, NULL);
1085                 mutex_exit(&os->os->os_user_ptr_lock);
1086
1087                 /*
1088                  * Finally release the objset
1089                  */
1090                 dmu_objset_close(os);
1091         }
1092
1093         /*
1094          * We can now safely destroy the '.zfs' directory node.
1095          */
1096         if (zfsvfs->z_ctldir != NULL)
1097                 zfsctl_destroy(zfsvfs);
1098         if (zfsvfs->z_issnap) {
1099                 vnode_t *svp = vfsp->mnt_vnodecovered;
1100
1101                 ASSERT(svp->v_count == 2 || svp->v_count == 1);
1102                 if (svp->v_count == 2)
1103                         VN_RELE(svp);
1104         }
1105         zfs_freevfs(vfsp);
1106
1107         return (0);
1108 }
1109
1110 static int
1111 zfs_vget(vfs_t *vfsp, ino_t ino, int flags, vnode_t **vpp)
1112 {
1113         zfsvfs_t        *zfsvfs = vfsp->vfs_data;
1114         znode_t         *zp;
1115         int             err;
1116
1117         /*
1118          * XXXPJD: zfs_zget() can't operate on virtual entires like .zfs/ or
1119          * .zfs/snapshot/ directories, so for now just return EOPNOTSUPP.
1120          * This will make NFS to fall back to using READDIR instead of
1121          * READDIRPLUS.
1122          * Also snapshots are stored in AVL tree, but based on their names,
1123          * not inode numbers, so it will be very inefficient to iterate
1124          * over all snapshots to find the right one.
1125          * Note that OpenSolaris READDIRPLUS implementation does LOOKUP on
1126          * d_name, and not VGET on d_fileno as we do.
1127          */
1128         if (ino == ZFSCTL_INO_ROOT || ino == ZFSCTL_INO_SNAPDIR)
1129                 return (EOPNOTSUPP);
1130
1131         ZFS_ENTER(zfsvfs);
1132         err = zfs_zget(zfsvfs, ino, &zp);
1133         if (err == 0 && zp->z_unlinked) {
1134                 VN_RELE(ZTOV(zp));
1135                 err = EINVAL;
1136         }
1137         if (err != 0)
1138                 *vpp = NULL;
1139         else {
1140                 *vpp = ZTOV(zp);
1141                 vn_lock(*vpp, flags);
1142         }
1143         ZFS_EXIT(zfsvfs);
1144         return (err);
1145 }
1146
1147 static int
1148 zfs_checkexp(vfs_t *vfsp, struct sockaddr *nam, int *extflagsp,
1149     struct ucred **credanonp, int *numsecflavors, int **secflavors)
1150 {
1151         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1152
1153         /*
1154          * If this is regular file system vfsp is the same as
1155          * zfsvfs->z_parent->z_vfs, but if it is snapshot,
1156          * zfsvfs->z_parent->z_vfs represents parent file system
1157          * which we have to use here, because only this file system
1158          * has mnt_export configured.
1159          */
1160         vfsp = zfsvfs->z_parent->z_vfs;
1161
1162         return (vfs_stdcheckexp(zfsvfs->z_parent->z_vfs, nam, extflagsp,
1163             credanonp, numsecflavors, secflavors));
1164 }
1165
1166 CTASSERT(SHORT_FID_LEN <= sizeof(struct fid));
1167 CTASSERT(LONG_FID_LEN <= sizeof(struct fid));
1168
1169 static int
1170 zfs_fhtovp(vfs_t *vfsp, fid_t *fidp, vnode_t **vpp)
1171 {
1172         zfsvfs_t        *zfsvfs = vfsp->vfs_data;
1173         znode_t         *zp;
1174         uint64_t        object = 0;
1175         uint64_t        fid_gen = 0;
1176         uint64_t        gen_mask;
1177         uint64_t        zp_gen;
1178         int             i, err;
1179
1180         *vpp = NULL;
1181
1182         ZFS_ENTER(zfsvfs);
1183
1184         /*
1185          * On FreeBSD we can get snapshot's mount point or its parent file
1186          * system mount point depending if snapshot is already mounted or not.
1187          */
1188         if (zfsvfs->z_parent == zfsvfs && fidp->fid_len == LONG_FID_LEN) {
1189                 zfid_long_t     *zlfid = (zfid_long_t *)fidp;
1190                 uint64_t        objsetid = 0;
1191                 uint64_t        setgen = 0;
1192
1193                 for (i = 0; i < sizeof (zlfid->zf_setid); i++)
1194                         objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
1195
1196                 for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
1197                         setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
1198
1199                 ZFS_EXIT(zfsvfs);
1200
1201                 err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
1202                 if (err)
1203                         return (EINVAL);
1204                 ZFS_ENTER(zfsvfs);
1205         }
1206
1207         if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
1208                 zfid_short_t    *zfid = (zfid_short_t *)fidp;
1209
1210                 for (i = 0; i < sizeof (zfid->zf_object); i++)
1211                         object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
1212
1213                 for (i = 0; i < sizeof (zfid->zf_gen); i++)
1214                         fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
1215         } else {
1216                 ZFS_EXIT(zfsvfs);
1217                 return (EINVAL);
1218         }
1219
1220         /* A zero fid_gen means we are in the .zfs control directories */
1221         if (fid_gen == 0 &&
1222             (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
1223                 *vpp = zfsvfs->z_ctldir;
1224                 ASSERT(*vpp != NULL);
1225                 if (object == ZFSCTL_INO_SNAPDIR) {
1226                         VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL,
1227                             0, NULL, NULL, NULL, NULL, NULL) == 0);
1228                 } else {
1229                         VN_HOLD(*vpp);
1230                 }
1231                 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
1232                 ZFS_EXIT(zfsvfs);
1233                 return (0);
1234         }
1235
1236         gen_mask = -1ULL >> (64 - 8 * i);
1237
1238         dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
1239         if (err = zfs_zget(zfsvfs, object, &zp)) {
1240                 ZFS_EXIT(zfsvfs);
1241                 return (err);
1242         }
1243         zp_gen = zp->z_phys->zp_gen & gen_mask;
1244         if (zp_gen == 0)
1245                 zp_gen = 1;
1246         if (zp->z_unlinked || zp_gen != fid_gen) {
1247                 dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
1248                 VN_RELE(ZTOV(zp));
1249                 ZFS_EXIT(zfsvfs);
1250                 return (EINVAL);
1251         }
1252
1253         *vpp = ZTOV(zp);
1254         vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
1255         vnode_create_vobject(*vpp, zp->z_phys->zp_size, curthread);
1256         ZFS_EXIT(zfsvfs);
1257         return (0);
1258 }
1259
1260 /*
1261  * Block out VOPs and close zfsvfs_t::z_os
1262  *
1263  * Note, if successful, then we return with the 'z_teardown_lock' and
1264  * 'z_teardown_inactive_lock' write held.
1265  */
1266 int
1267 zfs_suspend_fs(zfsvfs_t *zfsvfs, char *name, int *mode)
1268 {
1269         int error;
1270
1271         if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
1272                 return (error);
1273
1274         *mode = zfsvfs->z_os->os_mode;
1275         dmu_objset_name(zfsvfs->z_os, name);
1276         dmu_objset_close(zfsvfs->z_os);
1277
1278         return (0);
1279 }
1280
1281 /*
1282  * Reopen zfsvfs_t::z_os and release VOPs.
1283  */
1284 int
1285 zfs_resume_fs(zfsvfs_t *zfsvfs, const char *osname, int mode)
1286 {
1287         int err;
1288
1289         ASSERT(RRW_WRITE_HELD(&zfsvfs->z_teardown_lock));
1290         ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
1291
1292         err = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
1293         if (err) {
1294                 zfsvfs->z_os = NULL;
1295         } else {
1296                 znode_t *zp;
1297
1298                 VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
1299
1300                 /*
1301                  * Attempt to re-establish all the active znodes with
1302                  * their dbufs.  If a zfs_rezget() fails, then we'll let
1303                  * any potential callers discover that via ZFS_ENTER_VERIFY_VP
1304                  * when they try to use their znode.
1305                  */
1306                 mutex_enter(&zfsvfs->z_znodes_lock);
1307                 for (zp = list_head(&zfsvfs->z_all_znodes); zp;
1308                     zp = list_next(&zfsvfs->z_all_znodes, zp)) {
1309                         (void) zfs_rezget(zp);
1310                 }
1311                 mutex_exit(&zfsvfs->z_znodes_lock);
1312
1313         }
1314
1315         /* release the VOPs */
1316         rw_exit(&zfsvfs->z_teardown_inactive_lock);
1317         rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1318
1319         if (err) {
1320                 /*
1321                  * Since we couldn't reopen zfsvfs::z_os, force
1322                  * unmount this file system.
1323                  */
1324                 if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0)
1325                         (void) dounmount(zfsvfs->z_vfs, MS_FORCE, curthread);
1326         }
1327         return (err);
1328 }
1329
1330 static void
1331 zfs_freevfs(vfs_t *vfsp)
1332 {
1333         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1334         int i;
1335
1336         for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1337                 mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1338
1339         zfs_fuid_destroy(zfsvfs);
1340         zfs_freezfsvfs(zfsvfs);
1341
1342         atomic_add_32(&zfs_active_fs_count, -1);
1343 }
1344
1345 #ifdef __i386__
1346 static int desiredvnodes_backup;
1347 #endif
1348
1349 static void
1350 zfs_vnodes_adjust(void)
1351 {
1352 #ifdef __i386__
1353         int newdesiredvnodes;
1354
1355         desiredvnodes_backup = desiredvnodes;
1356
1357         /*
1358          * We calculate newdesiredvnodes the same way it is done in
1359          * vntblinit(). If it is equal to desiredvnodes, it means that
1360          * it wasn't tuned by the administrator and we can tune it down.
1361          */
1362         newdesiredvnodes = min(maxproc + cnt.v_page_count / 4, 2 *
1363             vm_kmem_size / (5 * (sizeof(struct vm_object) +
1364             sizeof(struct vnode))));
1365         if (newdesiredvnodes == desiredvnodes)
1366                 desiredvnodes = (3 * newdesiredvnodes) / 4;
1367 #endif
1368 }
1369
1370 static void
1371 zfs_vnodes_adjust_back(void)
1372 {
1373
1374 #ifdef __i386__
1375         desiredvnodes = desiredvnodes_backup;
1376 #endif
1377 }
1378
1379 void
1380 zfs_init(void)
1381 {
1382
1383         printf("ZFS filesystem version " SPA_VERSION_STRING "\n");
1384
1385         /*
1386          * Initialize znode cache, vnode ops, etc...
1387          */
1388         zfs_znode_init();
1389
1390         /*
1391          * Initialize .zfs directory structures
1392          */
1393         zfsctl_init();
1394
1395         /*
1396          * Reduce number of vnode. Originally number of vnodes is calculated
1397          * with UFS inode in mind. We reduce it here, because it's too big for
1398          * ZFS/i386.
1399          */
1400         zfs_vnodes_adjust();
1401 }
1402
1403 void
1404 zfs_fini(void)
1405 {
1406         zfsctl_fini();
1407         zfs_znode_fini();
1408         zfs_vnodes_adjust_back();
1409 }
1410
1411 int
1412 zfs_busy(void)
1413 {
1414         return (zfs_active_fs_count != 0);
1415 }
1416
1417 int
1418 zfs_set_version(const char *name, uint64_t newvers)
1419 {
1420         int error;
1421         objset_t *os;
1422         dmu_tx_t *tx;
1423         uint64_t curvers;
1424
1425         /*
1426          * XXX for now, require that the filesystem be unmounted.  Would
1427          * be nice to find the zfsvfs_t and just update that if
1428          * possible.
1429          */
1430
1431         if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
1432                 return (EINVAL);
1433
1434         error = dmu_objset_open(name, DMU_OST_ZFS, DS_MODE_OWNER, &os);
1435         if (error)
1436                 return (error);
1437
1438         error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1439             8, 1, &curvers);
1440         if (error)
1441                 goto out;
1442         if (newvers < curvers) {
1443                 error = EINVAL;
1444                 goto out;
1445         }
1446
1447         tx = dmu_tx_create(os);
1448         dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, 0, ZPL_VERSION_STR);
1449         error = dmu_tx_assign(tx, TXG_WAIT);
1450         if (error) {
1451                 dmu_tx_abort(tx);
1452                 goto out;
1453         }
1454         error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 8, 1,
1455             &newvers, tx);
1456
1457         spa_history_internal_log(LOG_DS_UPGRADE,
1458             dmu_objset_spa(os), tx, CRED(),
1459             "oldver=%llu newver=%llu dataset = %llu", curvers, newvers,
1460             dmu_objset_id(os));
1461         dmu_tx_commit(tx);
1462
1463 out:
1464         dmu_objset_close(os);
1465         return (error);
1466 }
1467 /*
1468  * Read a property stored within the master node.
1469  */
1470 int
1471 zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value)
1472 {
1473         const char *pname;
1474         int error = ENOENT;
1475
1476         /*
1477          * Look up the file system's value for the property.  For the
1478          * version property, we look up a slightly different string.
1479          */
1480         if (prop == ZFS_PROP_VERSION)
1481                 pname = ZPL_VERSION_STR;
1482         else
1483                 pname = zfs_prop_to_name(prop);
1484
1485         if (os != NULL)
1486                 error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value);
1487
1488         if (error == ENOENT) {
1489                 /* No value set, use the default value */
1490                 switch (prop) {
1491                 case ZFS_PROP_VERSION:
1492                         *value = ZPL_VERSION;
1493                         break;
1494                 case ZFS_PROP_NORMALIZE:
1495                 case ZFS_PROP_UTF8ONLY:
1496                         *value = 0;
1497                         break;
1498                 case ZFS_PROP_CASE:
1499                         *value = ZFS_CASE_SENSITIVE;
1500                         break;
1501                 default:
1502                         return (error);
1503                 }
1504                 error = 0;
1505         }
1506         return (error);
1507 }