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/nlookup.h>
  56 #include <sys/mountctl.h>
  57 #include "null.h"
  58
  59 extern struct vop_ops null_vnode_vops;
  60
  61 static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
  62
  63 static int      nullfs_root(struct mount *mp, struct vnode **vpp);
  64 static int      nullfs_statfs(struct mount *mp, struct statfs *sbp,
  65                                 struct ucred *cred);
  66
  67 /*
  68  * Mount null layer
  69  */
  70 static int
  71 nullfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
  72 {
  73         int error = 0;
  74         struct null_args args;
  75         struct vnode *rootvp;
  76         struct null_mount *xmp;
  77         size_t size;
  78         struct nlookupdata nd;
  79         fhandle_t fh;
  80
  81         NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
  82
  83         /*
  84          * Get argument
  85          */
  86         error = copyin(data, (caddr_t)&args, sizeof(struct null_args));
  87         if (error)
  88                 return (error);
  89
  90         /*
  91          * XXX: Should we process mount export info ?
  92          * If not, returning zero here is enough as the actual ro/rw update is
  93          * being done in sys_mount().
  94          */
  95         if (mp->mnt_flag & MNT_UPDATE) {
  96                 xmp = MOUNTTONULLMOUNT(mp);
  97                 error = vfs_export(mp, &xmp->export, &args.export);
  98                 return (error);
  99         }
 100
 101         /*
 102          * Find lower node
 103          */
 104         rootvp = NULL;
 105         error = nlookup_init(&nd, args.target, UIO_USERSPACE, NLC_FOLLOW);
 106         if (error)
 107                 goto fail1;
 108         error = nlookup(&nd);
 109         if (error)
 110                 goto fail2;
 111         error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &rootvp);
 112         if (error)
 113                 goto fail2;
 114
 115         xmp = (struct null_mount *) kmalloc(sizeof(struct null_mount),
 116                                 M_NULLFSMNT, M_WAITOK | M_ZERO);
 117
 118         /*
 119          * Save reference to underlying FS
 120          *
 121          * As lite stacking enters the scene, the old way of doing this
 122          * -- via the vnode -- is not good enough anymore.  Use the
 123          * underlying filesystem's namecache handle as our mount point
 124          * root, adjusting the mount to point to us.
 125          *
 126          * NCF_ISMOUNTPT is normally set on the mount point, but we also
 127          * want to set it on the base directory being mounted to prevent
 128          * that directory from being destroyed out from under the nullfs
 129          * mount.
 130          *
 131          * The forwarding mount pointer (xmp->nullm_vfs) must be set to
 132          * the actual target filesystem.  If the target filesystem was
 133          * resolved via a nullfs mount nd.nl_nch.mount will be pointing
 134          * to the nullfs mount structure instead of the target filesystem,
 135          * which would otherwise cause the mount VOPS and VFSOPS to recurse
 136          * endlessly.  If we are mounting via a nullfs mount we inherit
 137          * its read-only state, if set.
 138          */
 139         xmp->nullm_vfs = nd.nl_nch.mount;
 140         if (xmp->nullm_vfs != rootvp->v_mount) {
 141                 if (xmp->nullm_vfs->mnt_flag & MNT_RDONLY)
 142                         mp->mnt_flag |= MNT_RDONLY;
 143                 if (xmp->nullm_vfs->mnt_flag & MNT_NOEXEC)
 144                         mp->mnt_flag |= MNT_NOEXEC;
 145                 xmp->nullm_vfs = rootvp->v_mount;
 146         }
 147
 148         /*
 149          * ncmountpt is the parent glue.  When mounting a nullfs via a nullfs
 150          * we retain the parent nullfs to create a unique chain tuple.
 151          */
 152         mp->mnt_ncmountpt = nd.nl_nch;
 153         cache_changemount(&mp->mnt_ncmountpt, mp);
 154         mp->mnt_ncmountpt.ncp->nc_flag |= NCF_ISMOUNTPT;
 155         cache_unlock(&mp->mnt_ncmountpt);
 156         cache_zero(&nd.nl_nch);
 157         nlookup_done(&nd);
 158
 159         vfs_add_vnodeops(mp, &null_vnode_vops, &mp->mnt_vn_norm_ops);
 160
 161         vn_unlock(rootvp);              /* leave reference intact */
 162
 163         /*
 164          * Keep a held reference to the root vnode.
 165          * It is vrele'd in nullfs_unmount.
 166          */
 167         xmp->nullm_rootvp = rootvp;
 168         /*
 169          * XXX What's the proper safety condition for querying
 170          * the underlying mount? Is this flag tuning necessary
 171          * at all?
 172          */
 173         if (xmp->nullm_vfs->mnt_flag & MNT_LOCAL)
 174                 mp->mnt_flag |= MNT_LOCAL;
 175         mp->mnt_data = (qaddr_t) xmp;
 176
 177         /*
 178          * Try to create a unique but non-random fsid for the nullfs to
 179          * allow it to be exported via NFS.
 180          */
 181         bzero(&fh, sizeof(fh));
 182         fh.fh_fsid = rootvp->v_mount->mnt_stat.f_fsid;
 183         if (VFS_VPTOFH(rootvp, &fh.fh_fid) == 0) {
 184                 fh.fh_fsid.val[1] ^= crc32(&fh.fh_fid, sizeof(fh.fh_fid));
 185                 vfs_setfsid(mp, &fh.fh_fsid);
 186         } else {
 187                 vfs_getnewfsid(mp);
 188         }
 189
 190         (void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
 191                             &size);
 192         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
 193         (void)nullfs_statfs(mp, &mp->mnt_stat, cred);
 194         NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
 195                 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntfromname);
 196
 197         bzero(mp->mnt_stat.f_mntonname, MNAMELEN);
 198         if (path != NULL) {
 199                 (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
 200                         &size);
 201         }
 202
 203         /*
 204          * Set NCALIASED so unmount won't complain about namecache refs
 205          * still existing.
 206          *
 207          * All NULLFS operations are MPSAFE, though it will be short-lived
 208          * if the underlying filesystem is not.
 209          */
 210         mp->mnt_kern_flag |= MNTK_NCALIASED | MNTK_ALL_MPSAFE;
 211         return (0);
 212 fail2:
 213         nlookup_done(&nd);
 214 fail1:
 215         return (error);
 216 }
 217
 218 /*
 219  * Free reference to null layer
 220  */
 221 static int
 222 nullfs_unmount(struct mount *mp, int mntflags)
 223 {
 224         struct null_mount *xmp;
 225
 226         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
 227
 228         /*
 229          * Throw away the null_mount structure
 230          */
 231         xmp = (void *)mp->mnt_data;
 232         mp->mnt_data = 0;
 233         if (xmp->nullm_rootvp) {
 234                 vrele(xmp->nullm_rootvp);
 235                 xmp->nullm_rootvp = NULL;
 236         }
 237         kfree(xmp, M_NULLFSMNT);
 238         return 0;
 239 }
 240
 241 static int
 242 nullfs_root(struct mount *mp, struct vnode **vpp)
 243 {
 244         struct vnode *vp;
 245         int error;
 246
 247         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
 248             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 249
 250         /*
 251          * Return locked reference to root.
 252          */
 253         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
 254         error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
 255         if (error == 0)
 256                 *vpp = vp;
 257         return (error);
 258 }
 259
 260 static int
 261 nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
 262                 struct ucred *cred)
 263 {
 264         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, cred);
 265 }
 266
 267 static int
 268 nullfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 269 {
 270         int error;
 271         struct statfs mstat;
 272
 273         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
 274             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 275
 276         bzero(&mstat, sizeof(mstat));
 277
 278         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, cred);
 279         if (error)
 280                 return (error);
 281
 282         /* now copy across the "interesting" information and fake the rest */
 283         sbp->f_type = mstat.f_type;
 284         sbp->f_flags = mstat.f_flags;
 285         sbp->f_bsize = mstat.f_bsize;
 286         sbp->f_iosize = mstat.f_iosize;
 287         sbp->f_blocks = mstat.f_blocks;
 288         sbp->f_bfree = mstat.f_bfree;
 289         sbp->f_bavail = mstat.f_bavail;
 290         sbp->f_files = mstat.f_files;
 291         sbp->f_ffree = mstat.f_ffree;
 292         if (sbp != &mp->mnt_stat) {
 293                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
 294                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
 295                 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
 296         }
 297         return (0);
 298 }
 299
 300 /*
 301  * Implement NFS export tracking
 302  */
 303 static int
 304 nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
 305                 struct ucred **credanonp)
 306 {
 307         struct null_mount *xmp = (void *)mp->mnt_data;
 308         struct netcred *np;
 309         int error;
 310
 311         np = vfs_export_lookup(mp, &xmp->export, nam);
 312         if (np) {
 313                 *extflagsp = np->netc_exflags;
 314                 *credanonp = &np->netc_anon;
 315                 error = 0;
 316         } else {
 317                 error = EACCES;
 318         }
 319         return(error);
 320 #if 0
 321         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam,
 322                 extflagsp, credanonp);
 323 #endif
 324 }
 325
 326 int
 327 nullfs_export(struct mount *mp, int op, const struct export_args *export)
 328 {
 329         struct null_mount *xmp = (void *)mp->mnt_data;
 330         int error;
 331
 332         switch(op) {
 333         case MOUNTCTL_SET_EXPORT:
 334                 error = vfs_export(mp, &xmp->export, export);
 335                 break;
 336         default:
 337                 error = EOPNOTSUPP;
 338                 break;
 339         }
 340         return(error);
 341 }
 342
 343 /*
 344  * Pass through file handle conversion functions.
 345  */
 346 static int
 347 nullfs_vptofh(struct vnode *vp, struct fid *fhp)
 348 {
 349         return VFS_VPTOFH(vp, fhp);
 350 }
 351
 352 /*
 353  * Pass through file handle conversion functions.
 354  *
 355  * NOTE: currently only HAMMER uses rootvp.  HAMMER uses rootvp only
 356  * to enforce PFS isolation.
 357  */
 358 static int
 359 nullfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 360               struct fid *fhp, struct vnode **vpp)
 361 {
 362         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 363
 364         return VFS_FHTOVP(xmp->nullm_vfs, xmp->nullm_rootvp, fhp, vpp);
 365 }
 366
 367 static int
 368 nullfs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
 369                   int attrnamespace, const char *attrname, struct ucred *cred)
 370 {
 371         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd,
 372                               vp, attrnamespace, attrname, cred);
 373 }
 374
 375
 376 static struct vfsops null_vfsops = {
 377         .vfs_mount =            nullfs_mount,
 378         .vfs_unmount =          nullfs_unmount,
 379         .vfs_root =             nullfs_root,
 380         .vfs_quotactl =         nullfs_quotactl,
 381         .vfs_statfs =           nullfs_statfs,
 382         .vfs_sync =             vfs_stdsync,
 383         .vfs_extattrctl =       nullfs_extattrctl,
 384         .vfs_fhtovp =           nullfs_fhtovp,
 385         .vfs_vptofh =           nullfs_vptofh,
 386         .vfs_checkexp =         nullfs_checkexp
 387 };
 388
 389 VFS_SET(null_vfsops, null, VFCF_LOOPBACK);
 390 MODULE_VERSION(null, 1);