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          * Use val[1] so as not to interfere with the generally unique
 179          * val[0].
 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          * NOTE: There is no syncer thread for nullfs (flagged in vfsops)
 211          */
 212         mp->mnt_kern_flag |= MNTK_NCALIASED | MNTK_ALL_MPSAFE;
 213
 214         return (0);
 215 fail2:
 216         nlookup_done(&nd);
 217 fail1:
 218         return (error);
 219 }
 220
 221 /*
 222  * Free reference to null layer
 223  */
 224 static int
 225 nullfs_unmount(struct mount *mp, int mntflags)
 226 {
 227         struct null_mount *xmp;
 228
 229         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
 230
 231         /*
 232          * Throw away the null_mount structure
 233          */
 234         xmp = (void *)mp->mnt_data;
 235         mp->mnt_data = 0;
 236         if (xmp->nullm_rootvp) {
 237                 vrele(xmp->nullm_rootvp);
 238                 xmp->nullm_rootvp = NULL;
 239         }
 240         kfree(xmp, M_NULLFSMNT);
 241         return 0;
 242 }
 243
 244 static int
 245 nullfs_root(struct mount *mp, struct vnode **vpp)
 246 {
 247         struct vnode *vp;
 248         int error;
 249
 250         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p)\n", (void *)mp,
 251             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 252
 253         /*
 254          * Return locked reference to root.
 255          */
 256         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
 257         error = vget(vp, LK_EXCLUSIVE | LK_RETRY);
 258         if (error == 0)
 259                 *vpp = vp;
 260         return (error);
 261 }
 262
 263 static int
 264 nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg,
 265                 struct ucred *cred)
 266 {
 267         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, cred);
 268 }
 269
 270 static int
 271 nullfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 272 {
 273         int error;
 274         struct statfs mstat;
 275
 276         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p)\n", (void *)mp,
 277             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp);
 278
 279         bzero(&mstat, sizeof(mstat));
 280
 281         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, cred);
 282         if (error)
 283                 return (error);
 284
 285         /* now copy across the "interesting" information and fake the rest */
 286         sbp->f_type = mstat.f_type;
 287         sbp->f_flags = mstat.f_flags;
 288         sbp->f_bsize = mstat.f_bsize;
 289         sbp->f_iosize = mstat.f_iosize;
 290         sbp->f_blocks = mstat.f_blocks;
 291         sbp->f_bfree = mstat.f_bfree;
 292         sbp->f_bavail = mstat.f_bavail;
 293         sbp->f_files = mstat.f_files;
 294         sbp->f_ffree = mstat.f_ffree;
 295         if (sbp != &mp->mnt_stat) {
 296                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
 297                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
 298                 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
 299         }
 300         return (0);
 301 }
 302
 303 /*
 304  * Implement NFS export tracking
 305  */
 306 static int
 307 nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
 308                 struct ucred **credanonp)
 309 {
 310         struct null_mount *xmp = (void *)mp->mnt_data;
 311         struct netcred *np;
 312         int error;
 313
 314         np = vfs_export_lookup(mp, &xmp->export, nam);
 315         if (np) {
 316                 *extflagsp = np->netc_exflags;
 317                 *credanonp = &np->netc_anon;
 318                 error = 0;
 319         } else {
 320                 error = EACCES;
 321         }
 322         return(error);
 323 #if 0
 324         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam,
 325                 extflagsp, credanonp);
 326 #endif
 327 }
 328
 329 int
 330 nullfs_export(struct mount *mp, int op, const struct export_args *export)
 331 {
 332         struct null_mount *xmp = (void *)mp->mnt_data;
 333         int error;
 334
 335         switch(op) {
 336         case MOUNTCTL_SET_EXPORT:
 337                 error = vfs_export(mp, &xmp->export, export);
 338                 break;
 339         default:
 340                 error = EOPNOTSUPP;
 341                 break;
 342         }
 343         return(error);
 344 }
 345
 346 /*
 347  * Pass through file handle conversion functions.
 348  */
 349 static int
 350 nullfs_vptofh(struct vnode *vp, struct fid *fhp)
 351 {
 352         return VFS_VPTOFH(vp, fhp);
 353 }
 354
 355 /*
 356  * Pass through file handle conversion functions.
 357  *
 358  * NOTE: currently only HAMMER uses rootvp.  HAMMER uses rootvp only
 359  * to enforce PFS isolation.
 360  */
 361 static int
 362 nullfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 363               struct fid *fhp, struct vnode **vpp)
 364 {
 365         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 366
 367         return VFS_FHTOVP(xmp->nullm_vfs, xmp->nullm_rootvp, fhp, vpp);
 368 }
 369
 370 static int
 371 nullfs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
 372                   int attrnamespace, const char *attrname, struct ucred *cred)
 373 {
 374         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd,
 375                               vp, attrnamespace, attrname, cred);
 376 }
 377
 378 static void
 379 nullfs_ncpgen_set(struct mount *mp, struct namecache *ncp)
 380 {
 381         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 382
 383         VFS_NCPGEN_SET(xmp->nullm_vfs, ncp);
 384 }
 385
 386
 387 static int
 388 nullfs_ncpgen_test(struct mount *mp, struct namecache *ncp)
 389 {
 390         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 391
 392         return VFS_NCPGEN_TEST(xmp->nullm_vfs, ncp);
 393 }
 394
 395 static int
 396 nullfs_modifying(struct mount *mp)
 397 {
 398         struct null_mount *xmp = MOUNTTONULLMOUNT(mp);
 399         int error;
 400
 401         if (mp->mnt_flag & MNT_RDONLY)
 402                 error = EROFS;
 403         else if (xmp->nullm_vfs)
 404                 error = VFS_MODIFYING(xmp->nullm_vfs);
 405         else
 406                 error = 0;
 407         return error;
 408 }
 409
 410 static struct vfsops null_vfsops = {
 411         .vfs_flags =            VFSOPSF_NOSYNCERTHR,
 412         .vfs_mount =            nullfs_mount,
 413         .vfs_unmount =          nullfs_unmount,
 414         .vfs_root =             nullfs_root,
 415         .vfs_quotactl =         nullfs_quotactl,
 416         .vfs_statfs =           nullfs_statfs,
 417         .vfs_extattrctl =       nullfs_extattrctl,
 418         .vfs_fhtovp =           nullfs_fhtovp,
 419         .vfs_vptofh =           nullfs_vptofh,
 420         .vfs_ncpgen_set =       nullfs_ncpgen_set,
 421         .vfs_ncpgen_test =      nullfs_ncpgen_test,
 422         .vfs_checkexp =         nullfs_checkexp,
 423         .vfs_modifying =        nullfs_modifying
 424 };
 425
 426 VFS_SET(null_vfsops, null, VFCF_LOOPBACK | VFCF_MPSAFE);
 427 MODULE_VERSION(null, 1);