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         /*
 198          * Set NCALIASED so unmount won't complain about namecache refs
 199          * still existing.
 200          *
 201          * All NULLFS operations are MPSAFE, though it will be short-lived
 202          * if the underlying filesystem is not.
 203          */
 204         mp->mnt_kern_flag |= MNTK_NCALIASED | MNTK_ALL_MPSAFE;
 205         return (0);
 206 fail2:
 207         nlookup_done(&nd);
 208 fail1:
 209         return (error);
 210 }
 211
 212 /*
 213  * Free reference to null layer
 214  */
 215 static int
 216 nullfs_unmount(struct mount *mp, int mntflags)
 217 {
 218         struct null_mount *xmp;
 219
 220         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
 221
 222         /*
 223          * Throw away the null_mount structure
 224          */
 225         xmp = (void *)mp->mnt_data;
 226         mp->mnt_data = 0;
 227         if (xmp->nullm_rootvp) {
 228                 vrele(xmp->nullm_rootvp);
 229                 xmp->nullm_rootvp = NULL;
 230         }
 231         kfree(xmp, M_NULLFSMNT);
 232         return 0;
 233 }
 234
 235 static int
 236 nullfs_root(struct mount *mp, struct vnode **vpp)
 237 {
 238         struct vnode *vp;
 239         int error;
 240
 241         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
 242             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 243
 244         /*
 245          * Return locked reference to root.
 246          */
 247         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
 248         error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
 249         if (error == 0)
 250                 *vpp = vp;
 251         return (error);
 252 }
 253
 254 static int
 255 nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
 256                 struct ucred *cred)
 257 {
 258         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, cred);
 259 }
 260
 261 static int
 262 nullfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 263 {
 264         int error;
 265         struct statfs mstat;
 266
 267         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
 268             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 269
 270         bzero(&mstat, sizeof(mstat));
 271
 272         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, cred);
 273         if (error)
 274                 return (error);
 275
 276         /* now copy across the "interesting" information and fake the rest */
 277         sbp->f_type = mstat.f_type;
 278         sbp->f_flags = mstat.f_flags;
 279         sbp->f_bsize = mstat.f_bsize;
 280         sbp->f_iosize = mstat.f_iosize;
 281         sbp->f_blocks = mstat.f_blocks;
 282         sbp->f_bfree = mstat.f_bfree;
 283         sbp->f_bavail = mstat.f_bavail;
 284         sbp->f_files = mstat.f_files;
 285         sbp->f_ffree = mstat.f_ffree;
 286         if (sbp != &mp->mnt_stat) {
 287                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
 288                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
 289         }
 290         return (0);
 291 }
 292
 293 /*
 294  * Implement NFS export tracking
 295  */
 296 static int
 297 nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
 298                 struct ucred **credanonp)
 299 {
 300         struct null_mount *xmp = (void *)mp->mnt_data;
 301         struct netcred *np;
 302         int error;
 303
 304         np = vfs_export_lookup(mp, &xmp->export, nam);
 305         if (np) {
 306                 *extflagsp = np->netc_exflags;
 307                 *credanonp = &np->netc_anon;
 308                 error = 0;
 309         } else {
 310                 error = EACCES;
 311         }
 312         return(error);
 313 #if 0
 314         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam,
 315                 extflagsp, credanonp);
 316 #endif
 317 }
 318
 319 int
 320 nullfs_export(struct mount *mp, int op, const struct export_args *export)
 321 {
 322         struct null_mount *xmp = (void *)mp->mnt_data;
 323         int error;
 324
 325         switch(op) {
 326         case MOUNTCTL_SET_EXPORT:
 327                 error = vfs_export(mp, &xmp->export, export);
 328                 break;
 329         default:
 330                 error = EOPNOTSUPP;
 331                 break;
 332         }
 333         return(error);
 334 }
 335
 336 /*
 337  * Pass through file handle conversion functions.
 338  */
 339 static int
 340 nullfs_vptofh(struct vnode *vp, struct fid *fhp)
 341 {
 342         return VFS_VPTOFH(vp, fhp);
 343 }
 344
 345 /*
 346  * Pass through file handle conversion functions.
 347  *
 348  * NOTE: currently only HAMMER uses rootvp.  HAMMER uses rootvp only
 349  * to enforce PFS isolation.
 350  */
 351 static int
 352 nullfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 353               struct fid *fhp, struct vnode **vpp)
 354 {
 355         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 356
 357         return VFS_FHTOVP(xmp->nullm_vfs, xmp->nullm_rootvp, fhp, vpp);
 358 }
 359
 360 static int
 361 nullfs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
 362                   int attrnamespace, const char *attrname, struct ucred *cred)
 363 {
 364         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd,
 365                               vp, attrnamespace, attrname, cred);
 366 }
 367
 368
 369 static struct vfsops null_vfsops = {
 370         .vfs_mount =            nullfs_mount,
 371         .vfs_unmount =          nullfs_unmount,
 372         .vfs_root =             nullfs_root,
 373         .vfs_quotactl =         nullfs_quotactl,
 374         .vfs_statfs =           nullfs_statfs,
 375         .vfs_sync =             vfs_stdsync,
 376         .vfs_extattrctl =       nullfs_extattrctl,
 377         .vfs_fhtovp =           nullfs_fhtovp,
 378         .vfs_vptofh =           nullfs_vptofh,
 379         .vfs_checkexp =         nullfs_checkexp
 380 };
 381
 382 VFS_SET(null_vfsops, null, VFCF_LOOPBACK);
 383 MODULE_VERSION(null, 1);