null_vfsops.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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: releng/5.0/sys/fs/nullfs/null_vfsops.c 103934 2002-09-25 02:28:07Z jeff $
   40  */
   41 
   42 /*
   43  * Null Layer
   44  * (See null_vnops.c for a description of what this does.)
   45  */
   46 
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/kernel.h>
   50 #include <sys/lock.h>
   51 #include <sys/malloc.h>
   52 #include <sys/mount.h>
   53 #include <sys/namei.h>
   54 #include <sys/proc.h>
   55 #include <sys/vnode.h>
   56 
   57 #include <fs/nullfs/null.h>
   58 
   59 static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
   60 
   61 static int      nullfs_fhtovp(struct mount *mp, struct fid *fidp,
   62                                    struct vnode **vpp);
   63 static int      nullfs_checkexp(struct mount *mp, struct sockaddr *nam,
   64                                     int *extflagsp, struct ucred **credanonp);
   65 static int      nullfs_mount(struct mount *mp, struct nameidata *ndp,
   66                                    struct thread *td);
   67 static int      nullfs_quotactl(struct mount *mp, int cmd, uid_t uid,
   68                                      caddr_t arg, struct thread *td);
   69 static int      nullfs_root(struct mount *mp, struct vnode **vpp);
   70 static int      nullfs_start(struct mount *mp, int flags, struct thread *td);
   71 static int      nullfs_statfs(struct mount *mp, struct statfs *sbp,
   72                                    struct thread *td);
   73 static int      nullfs_sync(struct mount *mp, int waitfor,
   74                                  struct ucred *cred, struct thread *td);
   75 static int      nullfs_unmount(struct mount *mp, int mntflags, struct thread *td);
   76 static int      nullfs_vget(struct mount *mp, ino_t ino, int flags,
   77                                  struct vnode **vpp);
   78 static int      nullfs_vptofh(struct vnode *vp, struct fid *fhp);
   79 static int      nullfs_extattrctl(struct mount *mp, int cmd,
   80                                        struct vnode *filename_vp,
   81                                        int namespace, const char *attrname,
   82                                        struct thread *td);
   83 
   84 /*
   85  * Mount null layer
   86  */
   87 static int
   88 nullfs_mount(mp, ndp, td)
   89         struct mount *mp;
   90         struct nameidata *ndp;
   91         struct thread *td;
   92 {
   93         int error = 0;
   94         struct vnode *lowerrootvp, *vp;
   95         struct vnode *nullm_rootvp;
   96         struct null_mount *xmp;
   97         char *target;
   98         size_t size;
   99         int isvnunlocked = 0, len;
  100 
  101         NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
  102 
  103         /*
  104          * Update is a no-op
  105          */
  106         if (mp->mnt_flag & MNT_UPDATE) {
  107                 return (EOPNOTSUPP);
  108                 /* return VFS_MOUNT(MOUNTTONULLMOUNT(mp)->nullm_vfs, path, data, ndp, td);*/
  109         }
  110 
  111         /*
  112          * Get argument
  113          */
  114         error = vfs_getopt(mp->mnt_optnew, "target", (void **)&target, &len);
  115         if (error || target[len - 1] != '\0')
  116                 return (EINVAL);
  117 
  118         /*
  119          * Unlock lower node to avoid deadlock.
  120          * (XXX) VOP_ISLOCKED is needed?
  121          */
  122         if ((mp->mnt_vnodecovered->v_op == null_vnodeop_p) &&
  123                 VOP_ISLOCKED(mp->mnt_vnodecovered, NULL)) {
  124                 VOP_UNLOCK(mp->mnt_vnodecovered, 0, td);
  125                 isvnunlocked = 1;
  126         }
  127         /*
  128          * Find lower node
  129          */
  130         NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF,
  131                 UIO_SYSSPACE, target, td);
  132         error = namei(ndp);
  133         /*
  134          * Re-lock vnode.
  135          */
  136         if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered, NULL))
  137                 vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY, td);
  138 
  139         if (error)
  140                 return (error);
  141         NDFREE(ndp, NDF_ONLY_PNBUF);
  142 
  143         /*
  144          * Sanity check on lower vnode
  145          */
  146         lowerrootvp = ndp->ni_vp;
  147 
  148         vrele(ndp->ni_dvp);
  149         ndp->ni_dvp = NULLVP;
  150 
  151         /*
  152          * Check multi null mount to avoid `lock against myself' panic.
  153          */
  154         if (lowerrootvp == VTONULL(mp->mnt_vnodecovered)->null_lowervp) {
  155                 NULLFSDEBUG("nullfs_mount: multi null mount?\n");
  156                 vput(lowerrootvp);
  157                 return (EDEADLK);
  158         }
  159 
  160         xmp = (struct null_mount *) malloc(sizeof(struct null_mount),
  161                                 M_NULLFSMNT, M_WAITOK); /* XXX */
  162 
  163         /*
  164          * Save reference to underlying FS
  165          */
  166         xmp->nullm_vfs = lowerrootvp->v_mount;
  167 
  168         /*
  169          * Save reference.  Each mount also holds
  170          * a reference on the root vnode.
  171          */
  172         error = null_nodeget(mp, lowerrootvp, &vp);
  173         /*
  174          * Make sure the node alias worked
  175          */
  176         if (error) {
  177                 VOP_UNLOCK(vp, 0, td);
  178                 vrele(lowerrootvp);
  179                 free(xmp, M_NULLFSMNT); /* XXX */
  180                 return (error);
  181         }
  182 
  183         /*
  184          * Keep a held reference to the root vnode.
  185          * It is vrele'd in nullfs_unmount.
  186          */
  187         nullm_rootvp = vp;
  188         nullm_rootvp->v_vflag |= VV_ROOT;
  189         xmp->nullm_rootvp = nullm_rootvp;
  190 
  191         /*
  192          * Unlock the node (either the lower or the alias)
  193          */
  194         VOP_UNLOCK(vp, 0, td);
  195 
  196         if (NULLVPTOLOWERVP(nullm_rootvp)->v_mount->mnt_flag & MNT_LOCAL)
  197                 mp->mnt_flag |= MNT_LOCAL;
  198         mp->mnt_data = (qaddr_t) xmp;
  199         vfs_getnewfsid(mp);
  200 
  201         (void) copystr(target, mp->mnt_stat.f_mntfromname,
  202             MNAMELEN - 1, &size);
  203         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
  204         (void)nullfs_statfs(mp, &mp->mnt_stat, td);
  205         NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
  206                 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
  207         return (0);
  208 }
  209 
  210 /*
  211  * VFS start.  Nothing needed here - the start routine
  212  * on the underlying filesystem will have been called
  213  * when that filesystem was mounted.
  214  */
  215 static int
  216 nullfs_start(mp, flags, td)
  217         struct mount *mp;
  218         int flags;
  219         struct thread *td;
  220 {
  221         return (0);
  222         /* return VFS_START(MOUNTTONULLMOUNT(mp)->nullm_vfs, flags, td); */
  223 }
  224 
  225 /*
  226  * Free reference to null layer
  227  */
  228 static int
  229 nullfs_unmount(mp, mntflags, td)
  230         struct mount *mp;
  231         int mntflags;
  232         struct thread *td;
  233 {
  234         void *mntdata;
  235         int error;
  236         int flags = 0;
  237 
  238         NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
  239 
  240         if (mntflags & MNT_FORCE)
  241                 flags |= FORCECLOSE;
  242 
  243         /* There is 1 extra root vnode reference (nullm_rootvp). */
  244         error = vflush(mp, 1, flags);
  245         if (error)
  246                 return (error);
  247 
  248         /*
  249          * Finally, throw away the null_mount structure
  250          */
  251         mntdata = mp->mnt_data;
  252         mp->mnt_data = 0;
  253         free(mntdata, M_NULLFSMNT);
  254         return 0;
  255 }
  256 
  257 static int
  258 nullfs_root(mp, vpp)
  259         struct mount *mp;
  260         struct vnode **vpp;
  261 {
  262         struct thread *td = curthread;  /* XXX */
  263         struct vnode *vp;
  264 
  265         NULLFSDEBUG("nullfs_root(mp = %p, vp = %p->%p)\n", (void *)mp,
  266             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp,
  267             (void *)NULLVPTOLOWERVP(MOUNTTONULLMOUNT(mp)->nullm_rootvp));
  268 
  269         /*
  270          * Return locked reference to root.
  271          */
  272         vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
  273         VREF(vp);
  274 
  275 #ifdef NULLFS_DEBUG
  276         if (VOP_ISLOCKED(vp, NULL)) {
  277                 Debugger("root vnode is locked.\n");
  278                 vrele(vp);
  279                 return (EDEADLK);
  280         }
  281 #endif
  282         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
  283         *vpp = vp;
  284         return 0;
  285 }
  286 
  287 static int
  288 nullfs_quotactl(mp, cmd, uid, arg, td)
  289         struct mount *mp;
  290         int cmd;
  291         uid_t uid;
  292         caddr_t arg;
  293         struct thread *td;
  294 {
  295         return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, td);
  296 }
  297 
  298 static int
  299 nullfs_statfs(mp, sbp, td)
  300         struct mount *mp;
  301         struct statfs *sbp;
  302         struct thread *td;
  303 {
  304         int error;
  305         struct statfs mstat;
  306 
  307         NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p->%p)\n", (void *)mp,
  308             (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp,
  309             (void *)NULLVPTOLOWERVP(MOUNTTONULLMOUNT(mp)->nullm_rootvp));
  310 
  311         bzero(&mstat, sizeof(mstat));
  312 
  313         error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, td);
  314         if (error)
  315                 return (error);
  316 
  317         /* now copy across the "interesting" information and fake the rest */
  318         sbp->f_type = mstat.f_type;
  319         sbp->f_flags = mstat.f_flags;
  320         sbp->f_bsize = mstat.f_bsize;
  321         sbp->f_iosize = mstat.f_iosize;
  322         sbp->f_blocks = mstat.f_blocks;
  323         sbp->f_bfree = mstat.f_bfree;
  324         sbp->f_bavail = mstat.f_bavail;
  325         sbp->f_files = mstat.f_files;
  326         sbp->f_ffree = mstat.f_ffree;
  327         if (sbp != &mp->mnt_stat) {
  328                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
  329                 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
  330                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
  331         }
  332         return (0);
  333 }
  334 
  335 static int
  336 nullfs_sync(mp, waitfor, cred, td)
  337         struct mount *mp;
  338         int waitfor;
  339         struct ucred *cred;
  340         struct thread *td;
  341 {
  342         /*
  343          * XXX - Assumes no data cached at null layer.
  344          */
  345         return (0);
  346 }
  347 
  348 static int
  349 nullfs_vget(mp, ino, flags, vpp)
  350         struct mount *mp;
  351         ino_t ino;
  352         int flags;
  353         struct vnode **vpp;
  354 {
  355         int error;
  356         error = VFS_VGET(MOUNTTONULLMOUNT(mp)->nullm_vfs, ino, flags, vpp);
  357         if (error)
  358                 return (error);
  359 
  360         return (null_nodeget(mp, *vpp, vpp));
  361 }
  362 
  363 static int
  364 nullfs_fhtovp(mp, fidp, vpp)
  365         struct mount *mp;
  366         struct fid *fidp;
  367         struct vnode **vpp;
  368 {
  369         int error;
  370         error = VFS_FHTOVP(MOUNTTONULLMOUNT(mp)->nullm_vfs, fidp, vpp);
  371         if (error)
  372                 return (error);
  373 
  374         return (null_nodeget(mp, *vpp, vpp));
  375 }
  376 
  377 static int
  378 nullfs_checkexp(mp, nam, extflagsp, credanonp)
  379         struct mount *mp;
  380         struct sockaddr *nam;
  381         int *extflagsp; 
  382         struct ucred **credanonp;
  383 {
  384 
  385         return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam, 
  386                 extflagsp, credanonp);
  387 }
  388 
  389 static int
  390 nullfs_vptofh(vp, fhp)
  391         struct vnode *vp;
  392         struct fid *fhp;
  393 {
  394         return VFS_VPTOFH(NULLVPTOLOWERVP(vp), fhp);
  395 }
  396 
  397 static int                        
  398 nullfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, td)
  399         struct mount *mp;
  400         int cmd;
  401         struct vnode *filename_vp;
  402         int namespace;
  403         const char *attrname;
  404         struct thread *td;            
  405 {
  406         return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, filename_vp,
  407             namespace, attrname, td);
  408 }
  409 
  410 
  411 static struct vfsops null_vfsops = {
  412         NULL,
  413         nullfs_start,
  414         nullfs_unmount,
  415         nullfs_root,
  416         nullfs_quotactl,
  417         nullfs_statfs,
  418         nullfs_sync,
  419         nullfs_vget,
  420         nullfs_fhtovp,
  421         nullfs_checkexp,
  422         nullfs_vptofh,
  423         nullfs_init,
  424         nullfs_uninit,
  425         nullfs_extattrctl,
  426         nullfs_mount,
  427 };
  428 
  429 VFS_SET(null_vfsops, nullfs, VFCF_LOOPBACK);
Cache object: a2be5b8894d464306afae7195c47d1d7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/nullfs/null_vfsops.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/nullfs/null_vfsops.c
