sys/vfs/nullfs/null_vfsops.c

   1 /*
   2  * Copyright (c) 1992, 1993, 1995
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software donated to Berkeley by
   6  * Jan-Simon Pendry.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  *      @(#)null_vfsops.c       8.2 (Berkeley) 1/21/94
  33  *
  34  * @(#)lofs_vfsops.c    1.2 (Berkeley) 6/18/92
  35  * $FreeBSD: src/sys/miscfs/nullfs/null_vfsops.c,v 1.35.2.3 2001/07/26 20:37:11 iedowse Exp $
  36  * $DragonFly: src/sys/vfs/nullfs/null_vfsops.c,v 1.31 2008/09/17 21:44:25 dillon Exp $
  37  */
  38
  39 /*
  40  * Null Layer
  41  * (See null_vnops.c for a description of what this does.)
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/proc.h>
  48 #include <sys/malloc.h>
  49 #include <sys/vnode.h>
  50 #include <sys/mount.h>
  51 #include <sys/namecache.h>
  52 #include <sys/nlookup.h>
  53 #include <sys/mountctl.h>
  54 #include "null.h"
  55
  56 extern struct vop_ops null_vnode_vops;
  57
  58 static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
  59
  60 static int      nullfs_root(struct mount *mp, struct vnode **vpp);
  61 static int      nullfs_statfs(struct mount *mp, struct statfs *sbp,
  62                                 struct ucred *cred);
  63
  64 /*
  65  * Mount null layer
  66  */
  67 static int
  68 nullfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
  69 {
  70         int error = 0;
  71         struct null_args args;
  72         struct vnode *rootvp;
  73         struct null_mount *xmp;
  74         size_t size;
  75         struct nlookupdata nd;
  76         fhandle_t fh;
  77
  78         NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
  79
  80         /*
  81          * Get argument
  82          */
  83         error = copyin(data, (caddr_t)&args, sizeof(struct null_args));
  84         if (error)
  85                 return (error);
  86
  87         /*
  88          * XXX: Should we process mount export info ?
  89          * If not, returning zero here is enough as the actual ro/rw update is
  90          * being done in sys_mount().
  91          */
  92         if (mp->mnt_flag & MNT_UPDATE) {
  93                 xmp = MOUNTTONULLMOUNT(mp);
  94                 error = vfs_export(mp, &xmp->export, &args.export);
  95                 return (error);
  96         }
  97
  98         /*
  99          * Find lower node
 100          */
 101         rootvp = NULL;
 102         error = nlookup_init(&nd, args.target, UIO_USERSPACE, NLC_FOLLOW);
 103         if (error)
 104                 goto fail1;
 105         error = nlookup(&nd);
 106         if (error)
 107                 goto fail2;
 108         error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &rootvp);
 109         if (error)
 110                 goto fail2;
 111
 112         xmp = (struct null_mount *) kmalloc(sizeof(struct null_mount),
 113                                 M_NULLFSMNT, M_WAITOK | M_ZERO);
 114
 115         /*
 116          * Save reference to underlying FS
 117          *
 118          * As lite stacking enters the scene, the old way of doing this
 119          * -- via the vnode -- is not good enough anymore.  Use the
 120          * underlying filesystem's namecache handle as our mount point
 121          * root, adjusting the mount to point to us.
 122          *
 123          * NCF_ISMOUNTPT is normally set on the mount point, but we also
 124          * want to set it on the base directory being mounted to prevent
 125          * that directory from being destroyed out from under the nullfs
 126          * mount.
 127          *
 128          * The forwarding mount pointer (xmp->nullm_vfs) must be set to
 129          * the actual target filesystem.  If the target filesystem was
 130          * resolved via a nullfs mount nd.nl_nch.mount will be pointing
 131          * to the nullfs mount structure instead of the target filesystem,
 132          * which would otherwise cause the mount VOPS and VFSOPS to recurse
 133          * endlessly.  If we are mounting via a nullfs mount we inherit
 134          * its read-only state, if set.
 135          */
 136         xmp->nullm_vfs = nd.nl_nch.mount;
 137         if (xmp->nullm_vfs != rootvp->v_mount) {
 138                 if (xmp->nullm_vfs->mnt_flag & MNT_RDONLY)
 139                         mp->mnt_flag |= MNT_RDONLY;
 140                 if (xmp->nullm_vfs->mnt_flag & MNT_NOEXEC)
 141                         mp->mnt_flag |= MNT_NOEXEC;
 142                 xmp->nullm_vfs = rootvp->v_mount;
 143         }
 144
 145         /*
 146          * ncmountpt is the parent glue.  When mounting a nullfs via a nullfs
 147          * we retain the parent nullfs to create a unique chain tuple.
 148          */
 149         mp->mnt_ncmountpt = nd.nl_nch;
 150         cache_changemount(&mp->mnt_ncmountpt, mp);
 151         mp->mnt_ncmountpt.ncp->nc_flag |= NCF_ISMOUNTPT;
 152         cache_unlock(&mp->mnt_ncmountpt);
 153         cache_zero(&nd.nl_nch);
 154         nlookup_done(&nd);
 155
 156         vfs_add_vnodeops(mp, &null_vnode_vops, &mp->mnt_vn_norm_ops);
 157
 158         vn_unlock(rootvp);              /* leave reference intact */
 159
 160         /*
 161          * Keep a held reference to the root vnode.
 162          * It is vrele'd in nullfs_unmount.
 163          */
 164         xmp->nullm_rootvp = rootvp;
 165         /*
 166          * XXX What's the proper safety condition for querying
 167          * the underlying mount? Is this flag tuning necessary
 168          * at all?
 169          */
 170         if (xmp->nullm_vfs->mnt_flag & MNT_LOCAL)
 171                 mp->mnt_flag |= MNT_LOCAL;
 172         mp->mnt_data = (qaddr_t) xmp;
 173
 174         /*
 175          * Try to create a unique but non-random fsid for the nullfs to
 176          * allow it to be exported via NFS.
 177          */
 178         bzero(&fh, sizeof(fh));
 179         fh.fh_fsid = rootvp->v_mount->mnt_stat.f_fsid;
 180         if (VFS_VPTOFH(rootvp, &fh.fh_fid) == 0) {
 181                 fh.fh_fsid.val[1] ^= crc32(&fh.fh_fid, sizeof(fh.fh_fid));
 182                 vfs_setfsid(mp, &fh.fh_fsid);
 183         } else {
 184                 vfs_getnewfsid(mp);
 185         }
 186
 187         (void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
 188                             &size);
 189         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
 190         (void)nullfs_statfs(mp, &mp->mnt_stat, cred);
 191         NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
 192                 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntfromname);
 193
 194         bzero(mp->mnt_stat.f_mntonname, MNAMELEN);
 195         if (path != NULL) {
 196                 (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
 197                         &size);
 198         }
 199
 200         /*
 201          * Set NCALIASED so unmount won't complain about namecache refs
 202          * still existing.
 203          *
 204          * All NULLFS operations are MPSAFE, though it will be short-lived
 205          * if the underlying filesystem is not.
 206          */
 207         mp->mnt_kern_flag |= MNTK_NCALIASED | MNTK_ALL_MPSAFE;
 208
 209         /*
 210          * And we don't need a syncer thread
 211          */
 212         vn_syncer_thr_stop(mp);
 213         return (0);
 214 fail2:
 215         nlookup_done(&nd);
 216 fail1:
 217         return (error);
 218 }
 219
 220 /*
 221  * Free reference to null layer
 222  */
 223 static int
 224 nullfs_unmount(struct mount *mp, int mntflags)
 225 {
 226         struct null_mount *xmp;
 227
 228         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
 229
 230         /*
 231          * Throw away the null_mount structure
 232          */
 233         xmp = (void *)mp->mnt_data;
 234         mp->mnt_data = 0;
 235         if (xmp->nullm_rootvp) {
 236                 vrele(xmp->nullm_rootvp);
 237                 xmp->nullm_rootvp = NULL;
 238         }
 239         kfree(xmp, M_NULLFSMNT);
 240         return 0;
 241 }
 242
 243 static int
 244 nullfs_root(struct mount *mp, struct vnode **vpp)
 245 {
 246         struct vnode *vp;
 247         int error;
 248
 249         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
 250             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 251
 252         /*
 253          * Return locked reference to root.
 254          */
 255         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
 256         error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
 257         if (error == 0)
 258                 *vpp = vp;
 259         return (error);
 260 }
 261
 262 static int
 263 nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
 264                 struct ucred *cred)
 265 {
 266         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, cred);
 267 }
 268
 269 static int
 270 nullfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 271 {
 272         int error;
 273         struct statfs mstat;
 274
 275         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
 276             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 277
 278         bzero(&mstat, sizeof(mstat));
 279
 280         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, cred);
 281         if (error)
 282                 return (error);
 283
 284         /* now copy across the "interesting" information and fake the rest */
 285         sbp->f_type = mstat.f_type;
 286         sbp->f_flags = mstat.f_flags;
 287         sbp->f_bsize = mstat.f_bsize;
 288         sbp->f_iosize = mstat.f_iosize;
 289         sbp->f_blocks = mstat.f_blocks;
 290         sbp->f_bfree = mstat.f_bfree;
 291         sbp->f_bavail = mstat.f_bavail;
 292         sbp->f_files = mstat.f_files;
 293         sbp->f_ffree = mstat.f_ffree;
 294         if (sbp != &mp->mnt_stat) {
 295                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
 296                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
 297                 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
 298         }
 299         return (0);
 300 }
 301
 302 /*
 303  * Implement NFS export tracking
 304  */
 305 static int
 306 nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
 307                 struct ucred **credanonp)
 308 {
 309         struct null_mount *xmp = (void *)mp->mnt_data;
 310         struct netcred *np;
 311         int error;
 312
 313         np = vfs_export_lookup(mp, &xmp->export, nam);
 314         if (np) {
 315                 *extflagsp = np->netc_exflags;
 316                 *credanonp = &np->netc_anon;
 317                 error = 0;
 318         } else {
 319                 error = EACCES;
 320         }
 321         return(error);
 322 #if 0
 323         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam,
 324                 extflagsp, credanonp);
 325 #endif
 326 }
 327
 328 int
 329 nullfs_export(struct mount *mp, int op, const struct export_args *export)
 330 {
 331         struct null_mount *xmp = (void *)mp->mnt_data;
 332         int error;
 333
 334         switch(op) {
 335         case MOUNTCTL_SET_EXPORT:
 336                 error = vfs_export(mp, &xmp->export, export);
 337                 break;
 338         default:
 339                 error = EOPNOTSUPP;
 340                 break;
 341         }
 342         return(error);
 343 }
 344
 345 /*
 346  * Pass through file handle conversion functions.
 347  */
 348 static int
 349 nullfs_vptofh(struct vnode *vp, struct fid *fhp)
 350 {
 351         return VFS_VPTOFH(vp, fhp);
 352 }
 353
 354 /*
 355  * Pass through file handle conversion functions.
 356  *
 357  * NOTE: currently only HAMMER uses rootvp.  HAMMER uses rootvp only
 358  * to enforce PFS isolation.
 359  */
 360 static int
 361 nullfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 362               struct fid *fhp, struct vnode **vpp)
 363 {
 364         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 365
 366         return VFS_FHTOVP(xmp->nullm_vfs, xmp->nullm_rootvp, fhp, vpp);
 367 }
 368
 369 static int
 370 nullfs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
 371                   int attrnamespace, const char *attrname, struct ucred *cred)
 372 {
 373         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd,
 374                               vp, attrnamespace, attrname, cred);
 375 }
 376
 377 static void
 378 nullfs_ncpgen_set(struct mount *mp, struct namecache *ncp)
 379 {
 380         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 381
 382         VFS_NCPGEN_SET(xmp->nullm_vfs, ncp);
 383 }
 384
 385
 386 static int
 387 nullfs_ncpgen_test(struct mount *mp, struct namecache *ncp)
 388 {
 389         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 390
 391         return VFS_NCPGEN_TEST(xmp->nullm_vfs, ncp);
 392 }
 393
 394
 395 static struct vfsops null_vfsops = {
 396         .vfs_mount =            nullfs_mount,
 397         .vfs_unmount =          nullfs_unmount,
 398         .vfs_root =             nullfs_root,
 399         .vfs_quotactl =         nullfs_quotactl,
 400         .vfs_statfs =           nullfs_statfs,
 401         .vfs_sync =             vfs_stdsync,
 402         .vfs_extattrctl =       nullfs_extattrctl,
 403         .vfs_fhtovp =           nullfs_fhtovp,
 404         .vfs_vptofh =           nullfs_vptofh,
 405         .vfs_ncpgen_set =       nullfs_ncpgen_set,
 406         .vfs_ncpgen_test =      nullfs_ncpgen_test,
 407         .vfs_checkexp =         nullfs_checkexp
 408 };
 409
 410 VFS_SET(null_vfsops, null, VFCF_LOOPBACK);
 411 MODULE_VERSION(null, 1);