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