zfs/lib/libzpool/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/sysmacros.h>
  30 #include <sys/kmem.h>
  31 #include <sys/pathname.h>
  32 #include <sys/vnode.h>
  33 #include <sys/vfs.h>
  34 #include <sys/vfs_opreg.h>
  35 #include <sys/mntent.h>
  36 #include <sys/mount.h>
  37 #include <sys/cmn_err.h>
  38 #include "fs/fs_subr.h"
  39 #include <sys/zfs_znode.h>
  40 #include <sys/zfs_dir.h>
  41 #include <sys/zil.h>
  42 #include <sys/fs/zfs.h>
  43 #include <sys/dmu.h>
  44 #include <sys/dsl_prop.h>
  45 #include <sys/dsl_dataset.h>
  46 #include <sys/dsl_deleg.h>
  47 #include <sys/spa.h>
  48 #include <sys/zap.h>
  49 #include <sys/varargs.h>
  50 #include <sys/policy.h>
  51 #include <sys/atomic.h>
  52 #include <sys/mkdev.h>
  53 #include <sys/modctl.h>
  54 #include <sys/refstr.h>
  55 #include <sys/zfs_ioctl.h>
  56 #include <sys/zfs_ctldir.h>
  57 #include <sys/zfs_fuid.h>
  58 #include <sys/bootconf.h>
  59 #include <sys/sunddi.h>
  60 #include <sys/dnlc.h>
  61 #include <sys/dmu_objset.h>
  62 #include <sys/spa_boot.h>
  63
  64 int zfsfstype;
  65 vfsops_t *zfs_vfsops = NULL;
  66 static major_t zfs_major;
  67 static minor_t zfs_minor;
  68 static kmutex_t zfs_dev_mtx;
  69
  70 static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr);
  71 static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr);
  72 static int zfs_mountroot(vfs_t *vfsp, enum whymountroot);
  73 static int zfs_root(vfs_t *vfsp, vnode_t **vpp);
  74 static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp);
  75 static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp);
  76 static void zfs_freevfs(vfs_t *vfsp);
  77
  78 static const fs_operation_def_t zfs_vfsops_template[] = {
  79         VFSNAME_MOUNT,          { .vfs_mount = zfs_mount },
  80         VFSNAME_MOUNTROOT,      { .vfs_mountroot = zfs_mountroot },
  81         VFSNAME_UNMOUNT,        { .vfs_unmount = zfs_umount },
  82         VFSNAME_ROOT,           { .vfs_root = zfs_root },
  83         VFSNAME_STATVFS,        { .vfs_statvfs = zfs_statvfs },
  84         VFSNAME_SYNC,           { .vfs_sync = zfs_sync },
  85         VFSNAME_VGET,           { .vfs_vget = zfs_vget },
  86         VFSNAME_FREEVFS,        { .vfs_freevfs = zfs_freevfs },
  87         NULL,                   NULL
  88 };
  89
  90 static const fs_operation_def_t zfs_vfsops_eio_template[] = {
  91         VFSNAME_FREEVFS,        { .vfs_freevfs =  zfs_freevfs },
  92         NULL,                   NULL
  93 };
  94
  95 /*
  96  * We need to keep a count of active fs's.
  97  * This is necessary to prevent our module
  98  * from being unloaded after a umount -f
  99  */
 100 static uint32_t zfs_active_fs_count = 0;
 101
 102 static char *noatime_cancel[] = { MNTOPT_ATIME, NULL };
 103 static char *atime_cancel[] = { MNTOPT_NOATIME, NULL };
 104 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
 105 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
 106
 107 /*
 108  * MO_DEFAULT is not used since the default value is determined
 109  * by the equivalent property.
 110  */
 111 static mntopt_t mntopts[] = {
 112         { MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL },
 113         { MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL },
 114         { MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL },
 115         { MNTOPT_ATIME, atime_cancel, NULL, 0, NULL }
 116 };
 117
 118 static mntopts_t zfs_mntopts = {
 119         sizeof (mntopts) / sizeof (mntopt_t),
 120         mntopts
 121 };
 122
 123 /*ARGSUSED*/
 124 int
 125 zfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
 126 {
 127         /*
 128          * Data integrity is job one.  We don't want a compromised kernel
 129          * writing to the storage pool, so we never sync during panic.
 130          */
 131         if (panicstr)
 132                 return (0);
 133
 134         /*
 135          * SYNC_ATTR is used by fsflush() to force old filesystems like UFS
 136          * to sync metadata, which they would otherwise cache indefinitely.
 137          * Semantically, the only requirement is that the sync be initiated.
 138          * The DMU syncs out txgs frequently, so there's nothing to do.
 139          */
 140         if (flag & SYNC_ATTR)
 141                 return (0);
 142
 143         if (vfsp != NULL) {
 144                 /*
 145                  * Sync a specific filesystem.
 146                  */
 147                 zfsvfs_t *zfsvfs = vfsp->vfs_data;
 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 int
 168 zfs_create_unique_device(dev_t *dev)
 169 {
 170         major_t new_major;
 171
 172         do {
 173                 ASSERT3U(zfs_minor, <=, MAXMIN32);
 174                 minor_t start = zfs_minor;
 175                 do {
 176                         mutex_enter(&zfs_dev_mtx);
 177                         if (zfs_minor >= MAXMIN32) {
 178                                 /*
 179                                  * If we're still using the real major
 180                                  * keep out of /dev/zfs and /dev/zvol minor
 181                                  * number space.  If we're using a getudev()'ed
 182                                  * major number, we can use all of its minors.
 183                                  */
 184                                 if (zfs_major == ddi_name_to_major(ZFS_DRIVER))
 185                                         zfs_minor = ZFS_MIN_MINOR;
 186                                 else
 187                                         zfs_minor = 0;
 188                         } else {
 189                                 zfs_minor++;
 190                         }
 191                         *dev = makedevice(zfs_major, zfs_minor);
 192                         mutex_exit(&zfs_dev_mtx);
 193                 } while (vfs_devismounted(*dev) && zfs_minor != start);
 194                 if (zfs_minor == start) {
 195                         /*
 196                          * We are using all ~262,000 minor numbers for the
 197                          * current major number.  Create a new major number.
 198                          */
 199                         if ((new_major = getudev()) == (major_t)-1) {
 200                                 cmn_err(CE_WARN,
 201                                     "zfs_mount: Can't get unique major "
 202                                     "device number.");
 203                                 return (-1);
 204                         }
 205                         mutex_enter(&zfs_dev_mtx);
 206                         zfs_major = new_major;
 207                         zfs_minor = 0;
 208
 209                         mutex_exit(&zfs_dev_mtx);
 210                 } else {
 211                         break;
 212                 }
 213                 /* CONSTANTCONDITION */
 214         } while (1);
 215
 216         return (0);
 217 }
 218
 219 static void
 220 atime_changed_cb(void *arg, uint64_t newval)
 221 {
 222         zfsvfs_t *zfsvfs = arg;
 223
 224         if (newval == TRUE) {
 225                 zfsvfs->z_atime = TRUE;
 226                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
 227                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
 228         } else {
 229                 zfsvfs->z_atime = FALSE;
 230                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
 231                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
 232         }
 233 }
 234
 235 static void
 236 xattr_changed_cb(void *arg, uint64_t newval)
 237 {
 238         zfsvfs_t *zfsvfs = arg;
 239
 240         if (newval == TRUE) {
 241                 /* XXX locking on vfs_flag? */
 242                 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
 243                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
 244                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
 245         } else {
 246                 /* XXX locking on vfs_flag? */
 247                 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
 248                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
 249                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
 250         }
 251 }
 252
 253 static void
 254 blksz_changed_cb(void *arg, uint64_t newval)
 255 {
 256         zfsvfs_t *zfsvfs = arg;
 257
 258         if (newval < SPA_MINBLOCKSIZE ||
 259             newval > SPA_MAXBLOCKSIZE || !ISP2(newval))
 260                 newval = SPA_MAXBLOCKSIZE;
 261
 262         zfsvfs->z_max_blksz = newval;
 263         zfsvfs->z_vfs->vfs_bsize = newval;
 264 }
 265
 266 static void
 267 readonly_changed_cb(void *arg, uint64_t newval)
 268 {
 269         zfsvfs_t *zfsvfs = arg;
 270
 271         if (newval) {
 272                 /* XXX locking on vfs_flag? */
 273                 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
 274                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
 275                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
 276         } else {
 277                 /* XXX locking on vfs_flag? */
 278                 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
 279                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
 280                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
 281         }
 282 }
 283
 284 static void
 285 devices_changed_cb(void *arg, uint64_t newval)
 286 {
 287         zfsvfs_t *zfsvfs = arg;
 288
 289         if (newval == FALSE) {
 290                 zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES;
 291                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES);
 292                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0);
 293         } else {
 294                 zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES;
 295                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES);
 296                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0);
 297         }
 298 }
 299
 300 static void
 301 setuid_changed_cb(void *arg, uint64_t newval)
 302 {
 303         zfsvfs_t *zfsvfs = arg;
 304
 305         if (newval == FALSE) {
 306                 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
 307                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
 308                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
 309         } else {
 310                 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
 311                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
 312                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
 313         }
 314 }
 315
 316 static void
 317 exec_changed_cb(void *arg, uint64_t newval)
 318 {
 319         zfsvfs_t *zfsvfs = arg;
 320
 321         if (newval == FALSE) {
 322                 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
 323                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
 324                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
 325         } else {
 326                 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
 327                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
 328                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
 329         }
 330 }
 331
 332 /*
 333  * The nbmand mount option can be changed at mount time.
 334  * We can't allow it to be toggled on live file systems or incorrect
 335  * behavior may be seen from cifs clients
 336  *
 337  * This property isn't registered via dsl_prop_register(), but this callback
 338  * will be called when a file system is first mounted
 339  */
 340 static void
 341 nbmand_changed_cb(void *arg, uint64_t newval)
 342 {
 343         zfsvfs_t *zfsvfs = arg;
 344         if (newval == FALSE) {
 345                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
 346                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
 347         } else {
 348                 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
 349                 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
 350         }
 351 }
 352
 353 static void
 354 snapdir_changed_cb(void *arg, uint64_t newval)
 355 {
 356         zfsvfs_t *zfsvfs = arg;
 357
 358         zfsvfs->z_show_ctldir = newval;
 359 }
 360
 361 static void
 362 vscan_changed_cb(void *arg, uint64_t newval)
 363 {
 364         zfsvfs_t *zfsvfs = arg;
 365
 366         zfsvfs->z_vscan = newval;
 367 }
 368
 369 static void
 370 acl_mode_changed_cb(void *arg, uint64_t newval)
 371 {
 372         zfsvfs_t *zfsvfs = arg;
 373
 374         zfsvfs->z_acl_mode = newval;
 375 }
 376
 377 static void
 378 acl_inherit_changed_cb(void *arg, uint64_t newval)
 379 {
 380         zfsvfs_t *zfsvfs = arg;
 381
 382         zfsvfs->z_acl_inherit = newval;
 383 }
 384
 385 static int
 386 zfs_register_callbacks(vfs_t *vfsp)
 387 {
 388         struct dsl_dataset *ds = NULL;
 389         objset_t *os = NULL;
 390         zfsvfs_t *zfsvfs = NULL;
 391         uint64_t nbmand;
 392         int readonly, do_readonly = B_FALSE;
 393         int setuid, do_setuid = B_FALSE;
 394         int exec, do_exec = B_FALSE;
 395         int devices, do_devices = B_FALSE;
 396         int xattr, do_xattr = B_FALSE;
 397         int atime, do_atime = B_FALSE;
 398         int error = 0;
 399
 400         ASSERT(vfsp);
 401         zfsvfs = vfsp->vfs_data;
 402         ASSERT(zfsvfs);
 403         os = zfsvfs->z_os;
 404
 405         /*
 406          * The act of registering our callbacks will destroy any mount
 407          * options we may have.  In order to enable temporary overrides
 408          * of mount options, we stash away the current values and
 409          * restore them after we register the callbacks.
 410          */
 411         if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
 412                 readonly = B_TRUE;
 413                 do_readonly = B_TRUE;
 414         } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
 415                 readonly = B_FALSE;
 416                 do_readonly = B_TRUE;
 417         }
 418         if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
 419                 devices = B_FALSE;
 420                 setuid = B_FALSE;
 421                 do_devices = B_TRUE;
 422                 do_setuid = B_TRUE;
 423         } else {
 424                 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
 425                         devices = B_FALSE;
 426                         do_devices = B_TRUE;
 427                 } else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) {
 428                         devices = B_TRUE;
 429                         do_devices = B_TRUE;
 430                 }
 431
 432                 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
 433                         setuid = B_FALSE;
 434                         do_setuid = B_TRUE;
 435                 } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
 436                         setuid = B_TRUE;
 437                         do_setuid = B_TRUE;
 438                 }
 439         }
 440         if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
 441                 exec = B_FALSE;
 442                 do_exec = B_TRUE;
 443         } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
 444                 exec = B_TRUE;
 445                 do_exec = B_TRUE;
 446         }
 447         if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
 448                 xattr = B_FALSE;
 449                 do_xattr = B_TRUE;
 450         } else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
 451                 xattr = B_TRUE;
 452                 do_xattr = B_TRUE;
 453         }
 454         if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
 455                 atime = B_FALSE;
 456                 do_atime = B_TRUE;
 457         } else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
 458                 atime = B_TRUE;
 459                 do_atime = B_TRUE;
 460         }
 461
 462         /*
 463          * nbmand is a special property.  It can only be changed at
 464          * mount time.
 465          *
 466          * This is weird, but it is documented to only be changeable
 467          * at mount time.
 468          */
 469         if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
 470                 nbmand = B_FALSE;
 471         } else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
 472                 nbmand = B_TRUE;
 473         } else {
 474                 char osname[MAXNAMELEN];
 475
 476                 dmu_objset_name(os, osname);
 477                 if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand,
 478                     NULL)) {
 479                         return (error);
 480                 }
 481         }
 482
 483         /*
 484          * Register property callbacks.
 485          *
 486          * It would probably be fine to just check for i/o error from
 487          * the first prop_register(), but I guess I like to go
 488          * overboard...
 489          */
 490         ds = dmu_objset_ds(os);
 491         error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs);
 492         error = error ? error : dsl_prop_register(ds,
 493             "xattr", xattr_changed_cb, zfsvfs);
 494         error = error ? error : dsl_prop_register(ds,
 495             "recordsize", blksz_changed_cb, zfsvfs);
 496         error = error ? error : dsl_prop_register(ds,
 497             "readonly", readonly_changed_cb, zfsvfs);
 498         error = error ? error : dsl_prop_register(ds,
 499             "devices", devices_changed_cb, zfsvfs);
 500         error = error ? error : dsl_prop_register(ds,
 501             "setuid", setuid_changed_cb, zfsvfs);
 502         error = error ? error : dsl_prop_register(ds,
 503             "exec", exec_changed_cb, zfsvfs);
 504         error = error ? error : dsl_prop_register(ds,
 505             "snapdir", snapdir_changed_cb, zfsvfs);
 506         error = error ? error : dsl_prop_register(ds,
 507             "aclmode", acl_mode_changed_cb, zfsvfs);
 508         error = error ? error : dsl_prop_register(ds,
 509             "aclinherit", acl_inherit_changed_cb, zfsvfs);
 510         error = error ? error : dsl_prop_register(ds,
 511             "vscan", vscan_changed_cb, zfsvfs);
 512         if (error)
 513                 goto unregister;
 514
 515         /*
 516          * Invoke our callbacks to restore temporary mount options.
 517          */
 518         if (do_readonly)
 519                 readonly_changed_cb(zfsvfs, readonly);
 520         if (do_setuid)
 521                 setuid_changed_cb(zfsvfs, setuid);
 522         if (do_exec)
 523                 exec_changed_cb(zfsvfs, exec);
 524         if (do_devices)
 525                 devices_changed_cb(zfsvfs, devices);
 526         if (do_xattr)
 527                 xattr_changed_cb(zfsvfs, xattr);
 528         if (do_atime)
 529                 atime_changed_cb(zfsvfs, atime);
 530
 531         nbmand_changed_cb(zfsvfs, nbmand);
 532
 533         return (0);
 534
 535 unregister:
 536         /*
 537          * We may attempt to unregister some callbacks that are not
 538          * registered, but this is OK; it will simply return ENOMSG,
 539          * which we will ignore.
 540          */
 541         (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs);
 542         (void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs);
 543         (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs);
 544         (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs);
 545         (void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs);
 546         (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs);
 547         (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs);
 548         (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs);
 549         (void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs);
 550         (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
 551             zfsvfs);
 552         (void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs);
 553         return (error);
 554
 555 }
 556
 557 static int
 558 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
 559 {
 560         int error;
 561
 562         error = zfs_register_callbacks(zfsvfs->z_vfs);
 563         if (error)
 564                 return (error);
 565
 566         /*
 567          * Set the objset user_ptr to track its zfsvfs.
 568          */
 569         mutex_enter(&zfsvfs->z_os->os->os_user_ptr_lock);
 570         dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
 571         mutex_exit(&zfsvfs->z_os->os->os_user_ptr_lock);
 572
 573         /*
 574          * If we are not mounting (ie: online recv), then we don't
 575          * have to worry about replaying the log as we blocked all
 576          * operations out since we closed the ZIL.
 577          */
 578         if (mounting) {
 579                 boolean_t readonly;
 580
 581                 /*
 582                  * During replay we remove the read only flag to
 583                  * allow replays to succeed.
 584                  */
 585                 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
 586                 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
 587
 588                 /*
 589                  * Parse and replay the intent log.
 590                  */
 591                 zil_replay(zfsvfs->z_os, zfsvfs, &zfsvfs->z_assign,
 592                     zfs_replay_vector, zfs_unlinked_drain);
 593
 594                 zfs_unlinked_drain(zfsvfs);
 595                 zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */
 596         }
 597
 598         if (!zil_disable)
 599                 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
 600
 601         return (0);
 602 }
 603
 604 static void
 605 zfs_freezfsvfs(zfsvfs_t *zfsvfs)
 606 {
 607         mutex_destroy(&zfsvfs->z_znodes_lock);
 608         mutex_destroy(&zfsvfs->z_online_recv_lock);
 609         list_destroy(&zfsvfs->z_all_znodes);
 610         rrw_destroy(&zfsvfs->z_teardown_lock);
 611         rw_destroy(&zfsvfs->z_teardown_inactive_lock);
 612         rw_destroy(&zfsvfs->z_fuid_lock);
 613         kmem_free(zfsvfs, sizeof (zfsvfs_t));
 614 }
 615
 616 static int
 617 zfs_domount(vfs_t *vfsp, char *osname)
 618 {
 619         dev_t mount_dev;
 620         uint64_t recordsize, readonly;
 621         int error = 0;
 622         int mode;
 623         zfsvfs_t *zfsvfs;
 624         znode_t *zp = NULL;
 625
 626         ASSERT(vfsp);
 627         ASSERT(osname);
 628
 629         /*
 630          * Initialize the zfs-specific filesystem structure.
 631          * Should probably make this a kmem cache, shuffle fields,
 632          * and just bzero up to z_hold_mtx[].
 633          */
 634         zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
 635         zfsvfs->z_vfs = vfsp;
 636         zfsvfs->z_parent = zfsvfs;
 637         zfsvfs->z_assign = TXG_NOWAIT;
 638         zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE;
 639         zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
 640
 641         mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
 642         mutex_init(&zfsvfs->z_online_recv_lock, NULL, MUTEX_DEFAULT, NULL);
 643         list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
 644             offsetof(znode_t, z_link_node));
 645         rrw_init(&zfsvfs->z_teardown_lock);
 646         rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
 647         rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
 648
 649         /* Initialize the generic filesystem structure. */
 650         vfsp->vfs_bcount = 0;
 651         vfsp->vfs_data = NULL;
 652
 653         if (zfs_create_unique_device(&mount_dev) == -1) {
 654                 error = ENODEV;
 655                 goto out;
 656         }
 657         ASSERT(vfs_devismounted(mount_dev) == 0);
 658
 659         if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize,
 660             NULL))
 661                 goto out;
 662
 663         vfsp->vfs_dev = mount_dev;
 664         vfsp->vfs_fstype = zfsfstype;
 665         vfsp->vfs_bsize = recordsize;
 666         vfsp->vfs_flag |= VFS_NOTRUNC;
 667         vfsp->vfs_data = zfsvfs;
 668
 669         if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL))
 670                 goto out;
 671
 672         mode = DS_MODE_OWNER;
 673         if (readonly)
 674                 mode |= DS_MODE_READONLY;
 675
 676         error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
 677         if (error == EROFS) {
 678                 mode = DS_MODE_OWNER | DS_MODE_READONLY;
 679                 error = dmu_objset_open(osname, DMU_OST_ZFS, mode,
 680                     &zfsvfs->z_os);
 681         }
 682
 683         if (error)
 684                 goto out;
 685
 686         if (error = zfs_init_fs(zfsvfs, &zp))
 687                 goto out;
 688
 689         /* The call to zfs_init_fs leaves the vnode held, release it here. */
 690         VN_RELE(ZTOV(zp));
 691
 692         /*
 693          * Set features for file system.
 694          */
 695         zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
 696         if (zfsvfs->z_use_fuids) {
 697                 vfs_set_feature(vfsp, VFSFT_XVATTR);
 698                 vfs_set_feature(vfsp, VFSFT_SYSATTR_VIEWS);
 699                 vfs_set_feature(vfsp, VFSFT_ACEMASKONACCESS);
 700                 vfs_set_feature(vfsp, VFSFT_ACLONCREATE);
 701         }
 702         if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 703                 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
 704                 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
 705                 vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
 706         } else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
 707                 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
 708                 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
 709         }
 710
 711         if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
 712                 uint64_t pval;
 713
 714                 ASSERT(mode & DS_MODE_READONLY);
 715                 atime_changed_cb(zfsvfs, B_FALSE);
 716                 readonly_changed_cb(zfsvfs, B_TRUE);
 717                 if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL))
 718                         goto out;
 719                 xattr_changed_cb(zfsvfs, pval);
 720                 zfsvfs->z_issnap = B_TRUE;
 721         } else {
 722                 error = zfsvfs_setup(zfsvfs, B_TRUE);
 723         }
 724
 725         if (!zfsvfs->z_issnap)
 726                 zfsctl_create(zfsvfs);
 727 out:
 728         if (error) {
 729                 if (zfsvfs->z_os)
 730                         dmu_objset_close(zfsvfs->z_os);
 731                 zfs_freezfsvfs(zfsvfs);
 732         } else {
 733                 atomic_add_32(&zfs_active_fs_count, 1);
 734         }
 735
 736         return (error);
 737 }
 738
 739 void
 740 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
 741 {
 742         objset_t *os = zfsvfs->z_os;
 743         struct dsl_dataset *ds;
 744
 745         /*
 746          * Unregister properties.
 747          */
 748         if (!dmu_objset_is_snapshot(os)) {
 749                 ds = dmu_objset_ds(os);
 750                 VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
 751                     zfsvfs) == 0);
 752
 753                 VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb,
 754                     zfsvfs) == 0);
 755
 756                 VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb,
 757                     zfsvfs) == 0);
 758
 759                 VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb,
 760                     zfsvfs) == 0);
 761
 762                 VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb,
 763                     zfsvfs) == 0);
 764
 765                 VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb,
 766                     zfsvfs) == 0);
 767
 768                 VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb,
 769                     zfsvfs) == 0);
 770
 771                 VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
 772                     zfsvfs) == 0);
 773
 774                 VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb,
 775                     zfsvfs) == 0);
 776
 777                 VERIFY(dsl_prop_unregister(ds, "aclinherit",
 778                     acl_inherit_changed_cb, zfsvfs) == 0);
 779
 780                 VERIFY(dsl_prop_unregister(ds, "vscan",
 781                     vscan_changed_cb, zfsvfs) == 0);
 782         }
 783 }
 784
 785 /*
 786  * Convert a decimal digit string to a uint64_t integer.
 787  */
 788 static int
 789 str_to_uint64(char *str, uint64_t *objnum)
 790 {
 791         uint64_t num = 0;
 792
 793         while (*str) {
 794                 if (*str < '0' || *str > '9')
 795                         return (EINVAL);
 796
 797                 num = num*10 + *str++ - '0';
 798         }
 799
 800         *objnum = num;
 801         return (0);
 802 }
 803
 804 /*
 805  * The boot path passed from the boot loader is in the form of
 806  * "rootpool-name/root-filesystem-object-number'. Convert this
 807  * string to a dataset name: "rootpool-name/root-filesystem-name".
 808  */
 809 static int
 810 zfs_parse_bootfs(char *bpath, char *outpath)
 811 {
 812         char *slashp;
 813         uint64_t objnum;
 814         int error;
 815
 816         if (*bpath == 0 || *bpath == '/')
 817                 return (EINVAL);
 818
 819         (void) strcpy(outpath, bpath);
 820
 821         slashp = strchr(bpath, '/');
 822
 823         /* if no '/', just return the pool name */
 824         if (slashp == NULL) {
 825                 return (0);
 826         }
 827
 828         /* if not a number, just return the root dataset name */
 829         if (str_to_uint64(slashp+1, &objnum)) {
 830                 return (0);
 831         }
 832
 833         *slashp = '\0';
 834         error = dsl_dsobj_to_dsname(bpath, objnum, outpath);
 835         *slashp = '/';
 836
 837         return (error);
 838 }
 839
 840 static int
 841 zfs_mountroot(vfs_t *vfsp, enum whymountroot why)
 842 {
 843         int error = 0;
 844         static int zfsrootdone = 0;
 845         zfsvfs_t *zfsvfs = NULL;
 846         znode_t *zp = NULL;
 847         vnode_t *vp = NULL;
 848         char *zfs_bootfs;
 849         char *zfs_devid;
 850
 851         ASSERT(vfsp);
 852
 853         /*
 854          * The filesystem that we mount as root is defined in the
 855          * boot property "zfs-bootfs" with a format of
 856          * "poolname/root-dataset-objnum".
 857          */
 858         if (why == ROOT_INIT) {
 859                 if (zfsrootdone++)
 860                         return (EBUSY);
 861                 /*
 862                  * the process of doing a spa_load will require the
 863                  * clock to be set before we could (for example) do
 864                  * something better by looking at the timestamp on
 865                  * an uberblock, so just set it to -1.
 866                  */
 867                 clkset(-1);
 868
 869                 if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) {
 870                         cmn_err(CE_NOTE, "spa_get_bootfs: can not get "
 871                             "bootfs name");
 872                         return (EINVAL);
 873                 }
 874                 zfs_devid = spa_get_bootprop("diskdevid");
 875                 error = spa_import_rootpool(rootfs.bo_name, zfs_devid);
 876                 if (zfs_devid)
 877                         spa_free_bootprop(zfs_devid);
 878                 if (error) {
 879                         spa_free_bootprop(zfs_bootfs);
 880                         cmn_err(CE_NOTE, "spa_import_rootpool: error %d",
 881                             error);
 882                         return (error);
 883                 }
 884                 if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) {
 885                         spa_free_bootprop(zfs_bootfs);
 886                         cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d",
 887                             error);
 888                         return (error);
 889                 }
 890
 891                 spa_free_bootprop(zfs_bootfs);
 892
 893                 if (error = vfs_lock(vfsp))
 894                         return (error);
 895
 896                 if (error = zfs_domount(vfsp, rootfs.bo_name)) {
 897                         cmn_err(CE_NOTE, "zfs_domount: error %d", error);
 898                         goto out;
 899                 }
 900
 901                 zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
 902                 ASSERT(zfsvfs);
 903                 if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) {
 904                         cmn_err(CE_NOTE, "zfs_zget: error %d", error);
 905                         goto out;
 906                 }
 907
 908                 vp = ZTOV(zp);
 909                 mutex_enter(&vp->v_lock);
 910                 vp->v_flag |= VROOT;
 911                 mutex_exit(&vp->v_lock);
 912                 rootvp = vp;
 913
 914                 /*
 915                  * Leave rootvp held.  The root file system is never unmounted.
 916                  */
 917
 918                 vfs_add((struct vnode *)0, vfsp,
 919                     (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
 920 out:
 921                 vfs_unlock(vfsp);
 922                 return (error);
 923         } else if (why == ROOT_REMOUNT) {
 924                 readonly_changed_cb(vfsp->vfs_data, B_FALSE);
 925                 vfsp->vfs_flag |= VFS_REMOUNT;
 926
 927                 /* refresh mount options */
 928                 zfs_unregister_callbacks(vfsp->vfs_data);
 929                 return (zfs_register_callbacks(vfsp));
 930
 931         } else if (why == ROOT_UNMOUNT) {
 932                 zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data);
 933                 (void) zfs_sync(vfsp, 0, 0);
 934                 return (0);
 935         }
 936
 937         /*
 938          * if "why" is equal to anything else other than ROOT_INIT,
 939          * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it.
 940          */
 941         return (ENOTSUP);
 942 }
 943
 944 /*ARGSUSED*/
 945 static int
 946 zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
 947 {
 948         char            *osname;
 949         pathname_t      spn;
 950         int             error = 0;
 951         uio_seg_t       fromspace = (uap->flags & MS_SYSSPACE) ?
 952             UIO_SYSSPACE : UIO_USERSPACE;
 953         int             canwrite;
 954
 955         if (mvp->v_type != VDIR)
 956                 return (ENOTDIR);
 957
 958         mutex_enter(&mvp->v_lock);
 959         if ((uap->flags & MS_REMOUNT) == 0 &&
 960             (uap->flags & MS_OVERLAY) == 0 &&
 961             (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
 962                 mutex_exit(&mvp->v_lock);
 963                 return (EBUSY);
 964         }
 965         mutex_exit(&mvp->v_lock);
 966
 967         /*
 968          * ZFS does not support passing unparsed data in via MS_DATA.
 969          * Users should use the MS_OPTIONSTR interface; this means
 970          * that all option parsing is already done and the options struct
 971          * can be interrogated.
 972          */
 973         if ((uap->flags & MS_DATA) && uap->datalen > 0)
 974                 return (EINVAL);
 975
 976         /*
 977          * Get the objset name (the "special" mount argument).
 978          */
 979         if (error = pn_get(uap->spec, fromspace, &spn))
 980                 return (error);
 981
 982         osname = spn.pn_path;
 983
 984         /*
 985          * Check for mount privilege?
 986          *
 987          * If we don't have privilege then see if
 988          * we have local permission to allow it
 989          */
 990         error = secpolicy_fs_mount(cr, mvp, vfsp);
 991         if (error) {
 992                 error = dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr);
 993                 if (error == 0) {
 994                         vattr_t         vattr;
 995
 996                         /*
 997                          * Make sure user is the owner of the mount point
 998                          * or has sufficient privileges.
 999                          */
1000
1001                         vattr.va_mask = AT_UID;
1002
1003                         if (error = VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) {
1004                                 goto out;
1005                         }
1006
1007                         if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 &&
1008                             VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) {
1009                                 error = EPERM;
1010                                 goto out;
1011                         }
1012
1013                         secpolicy_fs_mount_clearopts(cr, vfsp);
1014                 } else {
1015                         goto out;
1016                 }
1017         }
1018
1019         /*
1020          * Refuse to mount a filesystem if we are in a local zone and the
1021          * dataset is not visible.
1022          */
1023         if (!INGLOBALZONE(curproc) &&
1024             (!zone_dataset_visible(osname, &canwrite) || !canwrite)) {
1025                 error = EPERM;
1026                 goto out;
1027         }
1028
1029         /*
1030          * When doing a remount, we simply refresh our temporary properties
1031          * according to those options set in the current VFS options.
1032          */
1033         if (uap->flags & MS_REMOUNT) {
1034                 /* refresh mount options */
1035                 zfs_unregister_callbacks(vfsp->vfs_data);
1036                 error = zfs_register_callbacks(vfsp);
1037                 goto out;
1038         }
1039
1040         error = zfs_domount(vfsp, osname);
1041
1042 out:
1043         pn_free(&spn);
1044         return (error);
1045 }
1046
1047 static int
1048 zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp)
1049 {
1050         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1051         dev32_t d32;
1052         uint64_t refdbytes, availbytes, usedobjs, availobjs;
1053
1054         ZFS_ENTER(zfsvfs);
1055
1056         dmu_objset_space(zfsvfs->z_os,
1057             &refdbytes, &availbytes, &usedobjs, &availobjs);
1058
1059         /*
1060          * The underlying storage pool actually uses multiple block sizes.
1061          * We report the fragsize as the smallest block size we support,
1062          * and we report our blocksize as the filesystem's maximum blocksize.
1063          */
1064         statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT;
1065         statp->f_bsize = zfsvfs->z_max_blksz;
1066
1067         /*
1068          * The following report "total" blocks of various kinds in the
1069          * file system, but reported in terms of f_frsize - the
1070          * "fragment" size.
1071          */
1072
1073         statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT;
1074         statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT;
1075         statp->f_bavail = statp->f_bfree; /* no root reservation */
1076
1077         /*
1078          * statvfs() should really be called statufs(), because it assumes
1079          * static metadata.  ZFS doesn't preallocate files, so the best
1080          * we can do is report the max that could possibly fit in f_files,
1081          * and that minus the number actually used in f_ffree.
1082          * For f_ffree, report the smaller of the number of object available
1083          * and the number of blocks (each object will take at least a block).
1084          */
1085         statp->f_ffree = MIN(availobjs, statp->f_bfree);
1086         statp->f_favail = statp->f_ffree;       /* no "root reservation" */
1087         statp->f_files = statp->f_ffree + usedobjs;
1088
1089         (void) cmpldev(&d32, vfsp->vfs_dev);
1090         statp->f_fsid = d32;
1091
1092         /*
1093          * We're a zfs filesystem.
1094          */
1095         (void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
1096
1097         statp->f_flag = vf_to_stf(vfsp->vfs_flag);
1098
1099         statp->f_namemax = ZFS_MAXNAMELEN;
1100
1101         /*
1102          * We have all of 32 characters to stuff a string here.
1103          * Is there anything useful we could/should provide?
1104          */
1105         bzero(statp->f_fstr, sizeof (statp->f_fstr));
1106
1107         ZFS_EXIT(zfsvfs);
1108         return (0);
1109 }
1110
1111 static int
1112 zfs_root(vfs_t *vfsp, vnode_t **vpp)
1113 {
1114         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1115         znode_t *rootzp;
1116         int error;
1117
1118         ZFS_ENTER(zfsvfs);
1119
1120         error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
1121         if (error == 0)
1122                 *vpp = ZTOV(rootzp);
1123
1124         ZFS_EXIT(zfsvfs);
1125         return (error);
1126 }
1127
1128 /*
1129  * Teardown the zfsvfs::z_os.
1130  *
1131  * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock'
1132  * and 'z_teardown_inactive_lock' held.
1133  */
1134 static int
1135 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
1136 {
1137         znode_t *zp;
1138
1139         rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
1140
1141         if (!unmounting) {
1142                 /*
1143                  * We purge the parent filesystem's vfsp as the parent
1144                  * filesystem and all of its snapshots have their vnode's
1145                  * v_vfsp set to the parent's filesystem's vfsp.  Note,
1146                  * 'z_parent' is self referential for non-snapshots.
1147                  */
1148                 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1149         }
1150
1151         /*
1152          * Close the zil. NB: Can't close the zil while zfs_inactive
1153          * threads are blocked as zil_close can call zfs_inactive.
1154          */
1155         if (zfsvfs->z_log) {
1156                 zil_close(zfsvfs->z_log);
1157                 zfsvfs->z_log = NULL;
1158         }
1159
1160         rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
1161
1162         /*
1163          * If we are not unmounting (ie: online recv) and someone already
1164          * unmounted this file system while we were doing the switcheroo,
1165          * or a reopen of z_os failed then just bail out now.
1166          */
1167         if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
1168                 rw_exit(&zfsvfs->z_teardown_inactive_lock);
1169                 rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1170                 return (EIO);
1171         }
1172
1173         /*
1174          * At this point there are no vops active, and any new vops will
1175          * fail with EIO since we have z_teardown_lock for writer (only
1176          * relavent for forced unmount).
1177          *
1178          * Release all holds on dbufs.
1179          */
1180         mutex_enter(&zfsvfs->z_znodes_lock);
1181         for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
1182             zp = list_next(&zfsvfs->z_all_znodes, zp))
1183                 if (zp->z_dbuf) {
1184                         ASSERT(ZTOV(zp)->v_count > 0);
1185                         zfs_znode_dmu_fini(zp);
1186                 }
1187         mutex_exit(&zfsvfs->z_znodes_lock);
1188
1189         /*
1190          * If we are unmounting, set the unmounted flag and let new vops
1191          * unblock.  zfs_inactive will have the unmounted behavior, and all
1192          * other vops will fail with EIO.
1193          */
1194         if (unmounting) {
1195                 zfsvfs->z_unmounted = B_TRUE;
1196                 rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1197                 rw_exit(&zfsvfs->z_teardown_inactive_lock);
1198         }
1199
1200         /*
1201          * z_os will be NULL if there was an error in attempting to reopen
1202          * zfsvfs, so just return as the properties had already been
1203          * unregistered and cached data had been evicted before.
1204          */
1205         if (zfsvfs->z_os == NULL)
1206                 return (0);
1207
1208         /*
1209          * Unregister properties.
1210          */
1211         zfs_unregister_callbacks(zfsvfs);
1212
1213         /*
1214          * Evict cached data
1215          */
1216         if (dmu_objset_evict_dbufs(zfsvfs->z_os)) {
1217                 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
1218                 (void) dmu_objset_evict_dbufs(zfsvfs->z_os);
1219         }
1220
1221         return (0);
1222 }
1223
1224 /*ARGSUSED*/
1225 static int
1226 zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr)
1227 {
1228         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1229         objset_t *os;
1230         int ret;
1231
1232         ret = secpolicy_fs_unmount(cr, vfsp);
1233         if (ret) {
1234                 ret = dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource),
1235                     ZFS_DELEG_PERM_MOUNT, cr);
1236                 if (ret)
1237                         return (ret);
1238         }
1239
1240         /*
1241          * We purge the parent filesystem's vfsp as the parent filesystem
1242          * and all of its snapshots have their vnode's v_vfsp set to the
1243          * parent's filesystem's vfsp.  Note, 'z_parent' is self
1244          * referential for non-snapshots.
1245          */
1246         (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
1247
1248         /*
1249          * Unmount any snapshots mounted under .zfs before unmounting the
1250          * dataset itself.
1251          */
1252         if (zfsvfs->z_ctldir != NULL &&
1253             (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) {
1254                 return (ret);
1255         }
1256
1257         if (!(fflag & MS_FORCE)) {
1258                 /*
1259                  * Check the number of active vnodes in the file system.
1260                  * Our count is maintained in the vfs structure, but the
1261                  * number is off by 1 to indicate a hold on the vfs
1262                  * structure itself.
1263                  *
1264                  * The '.zfs' directory maintains a reference of its
1265                  * own, and any active references underneath are
1266                  * reflected in the vnode count.
1267                  */
1268                 if (zfsvfs->z_ctldir == NULL) {
1269                         if (vfsp->vfs_count > 1)
1270                                 return (EBUSY);
1271                 } else {
1272                         if (vfsp->vfs_count > 2 ||
1273                             zfsvfs->z_ctldir->v_count > 1)
1274                                 return (EBUSY);
1275                 }
1276         }
1277
1278         vfsp->vfs_flag |= VFS_UNMOUNTED;
1279
1280         VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
1281         os = zfsvfs->z_os;
1282
1283         /*
1284          * z_os will be NULL if there was an error in
1285          * attempting to reopen zfsvfs.
1286          */
1287         if (os != NULL) {
1288                 /*
1289                  * Unset the objset user_ptr.
1290                  */
1291                 mutex_enter(&os->os->os_user_ptr_lock);
1292                 dmu_objset_set_user(os, NULL);
1293                 mutex_exit(&os->os->os_user_ptr_lock);
1294
1295                 /*
1296                  * Finally release the objset
1297                  */
1298                 dmu_objset_close(os);
1299         }
1300
1301         /*
1302          * We can now safely destroy the '.zfs' directory node.
1303          */
1304         if (zfsvfs->z_ctldir != NULL)
1305                 zfsctl_destroy(zfsvfs);
1306
1307         return (0);
1308 }
1309
1310 static int
1311 zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1312 {
1313         zfsvfs_t        *zfsvfs = vfsp->vfs_data;
1314         znode_t         *zp;
1315         uint64_t        object = 0;
1316         uint64_t        fid_gen = 0;
1317         uint64_t        gen_mask;
1318         uint64_t        zp_gen;
1319         int             i, err;
1320
1321         *vpp = NULL;
1322
1323         ZFS_ENTER(zfsvfs);
1324
1325         if (fidp->fid_len == LONG_FID_LEN) {
1326                 zfid_long_t     *zlfid = (zfid_long_t *)fidp;
1327                 uint64_t        objsetid = 0;
1328                 uint64_t        setgen = 0;
1329
1330                 for (i = 0; i < sizeof (zlfid->zf_setid); i++)
1331                         objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);
1332
1333                 for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
1334                         setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);
1335
1336                 ZFS_EXIT(zfsvfs);
1337
1338                 err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
1339                 if (err)
1340                         return (EINVAL);
1341                 ZFS_ENTER(zfsvfs);
1342         }
1343
1344         if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) {
1345                 zfid_short_t    *zfid = (zfid_short_t *)fidp;
1346
1347                 for (i = 0; i < sizeof (zfid->zf_object); i++)
1348                         object |= ((uint64_t)zfid->zf_object[i]) << (8 * i);
1349
1350                 for (i = 0; i < sizeof (zfid->zf_gen); i++)
1351                         fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
1352         } else {
1353                 ZFS_EXIT(zfsvfs);
1354                 return (EINVAL);
1355         }
1356
1357         /* A zero fid_gen means we are in the .zfs control directories */
1358         if (fid_gen == 0 &&
1359             (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) {
1360                 *vpp = zfsvfs->z_ctldir;
1361                 ASSERT(*vpp != NULL);
1362                 if (object == ZFSCTL_INO_SNAPDIR) {
1363                         VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL,
1364                             0, NULL, NULL, NULL, NULL, NULL) == 0);
1365                 } else {
1366                         VN_HOLD(*vpp);
1367                 }
1368                 ZFS_EXIT(zfsvfs);
1369                 return (0);
1370         }
1371
1372         gen_mask = -1ULL >> (64 - 8 * i);
1373
1374         dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
1375         if (err = zfs_zget(zfsvfs, object, &zp)) {
1376                 ZFS_EXIT(zfsvfs);
1377                 return (err);
1378         }
1379         zp_gen = zp->z_phys->zp_gen & gen_mask;
1380         if (zp_gen == 0)
1381                 zp_gen = 1;
1382         if (zp->z_unlinked || zp_gen != fid_gen) {
1383                 dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
1384                 VN_RELE(ZTOV(zp));
1385                 ZFS_EXIT(zfsvfs);
1386                 return (EINVAL);
1387         }
1388
1389         *vpp = ZTOV(zp);
1390         ZFS_EXIT(zfsvfs);
1391         return (0);
1392 }
1393
1394 /*
1395  * Block out VOPs and close zfsvfs_t::z_os
1396  *
1397  * Note, if successful, then we return with the 'z_teardown_lock' and
1398  * 'z_teardown_inactive_lock' write held.
1399  */
1400 int
1401 zfs_suspend_fs(zfsvfs_t *zfsvfs, char *name, int *mode)
1402 {
1403         int error;
1404
1405         if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
1406                 return (error);
1407
1408         *mode = zfsvfs->z_os->os_mode;
1409         dmu_objset_name(zfsvfs->z_os, name);
1410         dmu_objset_close(zfsvfs->z_os);
1411
1412         return (0);
1413 }
1414
1415 /*
1416  * Reopen zfsvfs_t::z_os and release VOPs.
1417  */
1418 int
1419 zfs_resume_fs(zfsvfs_t *zfsvfs, const char *osname, int mode)
1420 {
1421         int err;
1422
1423         ASSERT(RRW_WRITE_HELD(&zfsvfs->z_teardown_lock));
1424         ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
1425
1426         err = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os);
1427         if (err) {
1428                 zfsvfs->z_os = NULL;
1429         } else {
1430                 znode_t *zp;
1431
1432                 VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
1433
1434                 /*
1435                  * Attempt to re-establish all the active znodes with
1436                  * their dbufs.  If a zfs_rezget() fails, then we'll let
1437                  * any potential callers discover that via ZFS_ENTER_VERIFY_VP
1438                  * when they try to use their znode.
1439                  */
1440                 mutex_enter(&zfsvfs->z_znodes_lock);
1441                 for (zp = list_head(&zfsvfs->z_all_znodes); zp;
1442                     zp = list_next(&zfsvfs->z_all_znodes, zp)) {
1443                         (void) zfs_rezget(zp);
1444                 }
1445                 mutex_exit(&zfsvfs->z_znodes_lock);
1446
1447         }
1448
1449         /* release the VOPs */
1450         rw_exit(&zfsvfs->z_teardown_inactive_lock);
1451         rrw_exit(&zfsvfs->z_teardown_lock, FTAG);
1452
1453         if (err) {
1454                 /*
1455                  * Since we couldn't reopen zfsvfs::z_os, force
1456                  * unmount this file system.
1457                  */
1458                 if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0)
1459                         (void) dounmount(zfsvfs->z_vfs, MS_FORCE, CRED());
1460         }
1461         return (err);
1462 }
1463
1464 static void
1465 zfs_freevfs(vfs_t *vfsp)
1466 {
1467         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1468         int i;
1469
1470         for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
1471                 mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1472
1473         zfs_fuid_destroy(zfsvfs);
1474         zfs_freezfsvfs(zfsvfs);
1475
1476         atomic_add_32(&zfs_active_fs_count, -1);
1477 }
1478
1479 /*
1480  * VFS_INIT() initialization.  Note that there is no VFS_FINI(),
1481  * so we can't safely do any non-idempotent initialization here.
1482  * Leave that to zfs_init() and zfs_fini(), which are called
1483  * from the module's _init() and _fini() entry points.
1484  */
1485 /*ARGSUSED*/
1486 static int
1487 zfs_vfsinit(int fstype, char *name)
1488 {
1489         int error;
1490
1491         zfsfstype = fstype;
1492
1493         /*
1494          * Setup vfsops and vnodeops tables.
1495          */
1496         error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops);
1497         if (error != 0) {
1498                 cmn_err(CE_WARN, "zfs: bad vfs ops template");
1499         }
1500
1501         error = zfs_create_op_tables();
1502         if (error) {
1503                 zfs_remove_op_tables();
1504                 cmn_err(CE_WARN, "zfs: bad vnode ops template");
1505                 (void) vfs_freevfsops_by_type(zfsfstype);
1506                 return (error);
1507         }
1508
1509         mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
1510
1511         /*
1512          * Unique major number for all zfs mounts.
1513          * If we run out of 32-bit minors, we'll getudev() another major.
1514          */
1515         zfs_major = ddi_name_to_major(ZFS_DRIVER);
1516         zfs_minor = ZFS_MIN_MINOR;
1517
1518         return (0);
1519 }
1520
1521 void
1522 zfs_init(void)
1523 {
1524         /*
1525          * Initialize .zfs directory structures
1526          */
1527         zfsctl_init();
1528
1529         /*
1530          * Initialize znode cache, vnode ops, etc...
1531          */
1532         zfs_znode_init();
1533 }
1534
1535 void
1536 zfs_fini(void)
1537 {
1538         zfsctl_fini();
1539         zfs_znode_fini();
1540 }
1541
1542 int
1543 zfs_busy(void)
1544 {
1545         return (zfs_active_fs_count != 0);
1546 }
1547
1548 int
1549 zfs_set_version(const char *name, uint64_t newvers)
1550 {
1551         int error;
1552         objset_t *os;
1553         dmu_tx_t *tx;
1554         uint64_t curvers;
1555
1556         /*
1557          * XXX for now, require that the filesystem be unmounted.  Would
1558          * be nice to find the zfsvfs_t and just update that if
1559          * possible.
1560          */
1561
1562         if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
1563                 return (EINVAL);
1564
1565         error = dmu_objset_open(name, DMU_OST_ZFS, DS_MODE_OWNER, &os);
1566         if (error)
1567                 return (error);
1568
1569         error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1570             8, 1, &curvers);
1571         if (error)
1572                 goto out;
1573         if (newvers < curvers) {
1574                 error = EINVAL;
1575                 goto out;
1576         }
1577
1578         tx = dmu_tx_create(os);
1579         dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, 0, ZPL_VERSION_STR);
1580         error = dmu_tx_assign(tx, TXG_WAIT);
1581         if (error) {
1582                 dmu_tx_abort(tx);
1583                 goto out;
1584         }
1585         error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 8, 1,
1586             &newvers, tx);
1587
1588         spa_history_internal_log(LOG_DS_UPGRADE,
1589             dmu_objset_spa(os), tx, CRED(),
1590             "oldver=%llu newver=%llu dataset = %llu", curvers, newvers,
1591             dmu_objset_id(os));
1592         dmu_tx_commit(tx);
1593
1594 out:
1595         dmu_objset_close(os);
1596         return (error);
1597 }
1598
1599 /*
1600  * Read a property stored within the master node.
1601  */
1602 int
1603 zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value)
1604 {
1605         const char *pname;
1606         int error = ENOENT;
1607
1608         /*
1609          * Look up the file system's value for the property.  For the
1610          * version property, we look up a slightly different string.
1611          */
1612         if (prop == ZFS_PROP_VERSION)
1613                 pname = ZPL_VERSION_STR;
1614         else
1615                 pname = zfs_prop_to_name(prop);
1616
1617         if (os != NULL)
1618                 error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value);
1619
1620         if (error == ENOENT) {
1621                 /* No value set, use the default value */
1622                 switch (prop) {
1623                 case ZFS_PROP_VERSION:
1624                         *value = ZPL_VERSION;
1625                         break;
1626                 case ZFS_PROP_NORMALIZE:
1627                 case ZFS_PROP_UTF8ONLY:
1628                         *value = 0;
1629                         break;
1630                 case ZFS_PROP_CASE:
1631                         *value = ZFS_CASE_SENSITIVE;
1632                         break;
1633                 default:
1634                         return (error);
1635                 }
1636                 error = 0;
1637         }
1638         return (error);
1639 }
1640
1641 static vfsdef_t vfw = {
1642         VFSDEF_VERSION,
1643         MNTTYPE_ZFS,
1644         zfs_vfsinit,
1645         VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS|
1646             VSW_XID,
1647         &zfs_mntopts
1648 };
1649
1650 struct modlfs zfs_modlfs = {
1651         &mod_fsops, "ZFS filesystem version " SPA_VERSION_STRING, &vfw
1652 };