Return to nfs_vfsops.c CVS log

Up to [Net/2] / Net2 / nfs

Annotation of Net2/nfs/nfs_vfsops.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1989 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * This code is derived from software contributed to Berkeley by
        !             6:  * Rick Macklem at The University of Guelph.
        !             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:  *     @(#)nfs_vfsops.c        7.31 (Berkeley) 5/6/91
        !            37:  */
        !            38: 
        !            39: #include "param.h"
        !            40: #include "conf.h"
        !            41: #include "ioctl.h"
        !            42: #include "signal.h"
        !            43: #include "proc.h"
        !            44: #include "namei.h"
        !            45: #include "vnode.h"
        !            46: #include "mount.h"
        !            47: #include "buf.h"
        !            48: #include "mbuf.h"
        !            49: #include "socket.h"
        !            50: #include "systm.h"
        !            51: 
        !            52: #include "../net/if.h"
        !            53: #include "../net/route.h"
        !            54: #include "../netinet/in.h"
        !            55: 
        !            56: #include "nfsv2.h"
        !            57: #include "nfsnode.h"
        !            58: #include "nfsmount.h"
        !            59: #include "nfs.h"
        !            60: #include "xdr_subs.h"
        !            61: #include "nfsm_subs.h"
        !            62: #include "nfsdiskless.h"
        !            63: 
        !            64: /*
        !            65:  * nfs vfs operations.
        !            66:  */
        !            67: struct vfsops nfs_vfsops = {
        !            68:        nfs_mount,
        !            69:        nfs_start,
        !            70:        nfs_unmount,
        !            71:        nfs_root,
        !            72:        nfs_quotactl,
        !            73:        nfs_statfs,
        !            74:        nfs_sync,
        !            75:        nfs_fhtovp,
        !            76:        nfs_vptofh,
        !            77:        nfs_init,
        !            78: };
        !            79: 
        !            80: static u_char nfs_mntid;
        !            81: extern u_long nfs_procids[NFS_NPROCS];
        !            82: extern u_long nfs_prog, nfs_vers;
        !            83: struct nfs_diskless nfs_diskless;
        !            84: void nfs_disconnect();
        !            85: 
        !            86: #define TRUE   1
        !            87: #define        FALSE   0
        !            88: 
        !            89: /*
        !            90:  * nfs statfs call
        !            91:  */
        !            92: nfs_statfs(mp, sbp, p)
        !            93:        struct mount *mp;
        !            94:        register struct statfs *sbp;
        !            95:        struct proc *p;
        !            96: {
        !            97:        register struct vnode *vp;
        !            98:        register struct nfsv2_statfs *sfp;
        !            99:        register caddr_t cp;
        !           100:        register long t1;
        !           101:        caddr_t bpos, dpos, cp2;
        !           102:        u_long xid;
        !           103:        int error = 0;
        !           104:        struct mbuf *mreq, *mrep, *md, *mb, *mb2;
        !           105:        struct nfsmount *nmp;
        !           106:        struct ucred *cred;
        !           107:        struct nfsnode *np;
        !           108: 
        !           109:        nmp = VFSTONFS(mp);
        !           110:        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
        !           111:                return (error);
        !           112:        vp = NFSTOV(np);
        !           113:        nfsstats.rpccnt[NFSPROC_STATFS]++;
        !           114:        cred = crget();
        !           115:        cred->cr_ngroups = 1;
        !           116:        nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH);
        !           117:        nfsm_fhtom(vp);
        !           118:        nfsm_request(vp, NFSPROC_STATFS, p, 0);
        !           119:        nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS);
        !           120:        sbp->f_type = MOUNT_NFS;
        !           121:        sbp->f_flags = nmp->nm_flag;
        !           122:        sbp->f_bsize = fxdr_unsigned(long, sfp->sf_tsize);
        !           123:        sbp->f_fsize = fxdr_unsigned(long, sfp->sf_bsize);
        !           124:        sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks);
        !           125:        sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree);
        !           126:        sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail);
        !           127:        sbp->f_files = 0;
        !           128:        sbp->f_ffree = 0;
        !           129:        if (sbp != &mp->mnt_stat) {
        !           130:                bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
        !           131:                bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
        !           132:        }
        !           133:        nfsm_reqdone;
        !           134:        nfs_nput(vp);
        !           135:        crfree(cred);
        !           136:        return (error);
        !           137: }
        !           138: 
        !           139: /*
        !           140:  * Mount a remote root fs via. nfs. This depends on the info in the
        !           141:  * nfs_diskless structure that has been filled in properly by some primary
        !           142:  * bootstrap.
        !           143:  * It goes something like this:
        !           144:  * - do enough of "ifconfig" by calling ifioctl() so that the system
        !           145:  *   can talk to the server
        !           146:  * - If nfs_diskless.mygateway is filled in, use that address as
        !           147:  *   a default gateway.
        !           148:  *   (This is done the 4.3 way with rtioctl() and should be changed)
        !           149:  * - hand craft the swap nfs vnode hanging off a fake mount point
        !           150:  * - build the rootfs mount point and call mountnfs() to do the rest.
        !           151:  */
        !           152: nfs_mountroot()
        !           153: {
        !           154:        register struct mount *mp;
        !           155:        register struct mbuf *m;
        !           156:        struct socket *so;
        !           157:        struct vnode *vp;
        !           158:        int error;
        !           159: 
        !           160:        /*
        !           161:         * Do enough of ifconfig(8) so that critical net interface can
        !           162:         * talk to the server.
        !           163:         */
        !           164:        if (socreate(nfs_diskless.myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0))
        !           165:                panic("nfs ifconf");
        !           166:        if (ifioctl(so, SIOCAIFADDR, &nfs_diskless.myif))
        !           167:                panic("nfs ifconf2");
        !           168:        soclose(so);
        !           169: 
        !           170:        /*
        !           171:         * If the gateway field is filled in, set it as the default route.
        !           172:         */
        !           173: #ifdef COMPAT_43
        !           174:        if (nfs_diskless.mygateway.sa_family == AF_INET) {
        !           175:                struct ortentry rt;
        !           176:                struct sockaddr_in *sin;
        !           177: 
        !           178:                sin = (struct sockaddr_in *) &rt.rt_dst;
        !           179:                sin->sin_len = sizeof (struct sockaddr_in);
        !           180:                sin->sin_family = AF_INET;
        !           181:                sin->sin_addr.s_addr = 0;       /* default */
        !           182:                bcopy((caddr_t)&nfs_diskless.mygateway, (caddr_t)&rt.rt_gateway,
        !           183:                        sizeof (struct sockaddr_in));
        !           184:                rt.rt_flags = (RTF_UP | RTF_GATEWAY);
        !           185:                if (rtioctl(SIOCADDRT, (caddr_t)&rt))
        !           186:                        panic("nfs root route");
        !           187:        }
        !           188: #endif /* COMPAT_43 */
        !           189: 
        !           190:        /*
        !           191:         * If swapping to an nfs node (indicated by swdevt[0].sw_dev == NODEV):
        !           192:         * Create a fake mount point just for the swap vnode so that the
        !           193:         * swap file can be on a different server from the rootfs.
        !           194:         */
        !           195:        if (swdevt[0].sw_dev == NODEV) {
        !           196:                mp = (struct mount *)malloc((u_long)sizeof(struct mount),
        !           197:                        M_MOUNT, M_NOWAIT);
        !           198:                if (mp == NULL)
        !           199:                        panic("nfs root mount");
        !           200:                mp->mnt_op = &nfs_vfsops;
        !           201:                mp->mnt_flag = 0;
        !           202:                mp->mnt_exroot = 0;
        !           203:                mp->mnt_mounth = NULLVP;
        !           204:        
        !           205:                /*
        !           206:                 * Set up the diskless nfs_args for the swap mount point
        !           207:                 * and then call mountnfs() to mount it.
        !           208:                 * Since the swap file is not the root dir of a file system,
        !           209:                 * hack it to a regular file.
        !           210:                 */
        !           211:                nfs_diskless.swap_args.fh = (nfsv2fh_t *)nfs_diskless.swap_fh;
        !           212:                MGET(m, MT_SONAME, M_DONTWAIT);
        !           213:                if (m == NULL)
        !           214:                        panic("nfs root mbuf");
        !           215:                bcopy((caddr_t)&nfs_diskless.swap_saddr, mtod(m, caddr_t),
        !           216:                        nfs_diskless.swap_saddr.sa_len);
        !           217:                m->m_len = nfs_diskless.swap_saddr.sa_len;
        !           218:                if (mountnfs(&nfs_diskless.swap_args, mp, m, "/swap",
        !           219:                        nfs_diskless.swap_hostnam, &vp))
        !           220:                        panic("nfs swap");
        !           221:                vp->v_type = VREG;
        !           222:                vp->v_flag = 0;
        !           223:                swapdev_vp = vp;
        !           224:                VREF(vp);
        !           225:                swdevt[0].sw_vp = vp;
        !           226:        }
        !           227: 
        !           228:        /*
        !           229:         * Create the rootfs mount point.
        !           230:         */
        !           231:        mp = (struct mount *)malloc((u_long)sizeof(struct mount),
        !           232:                M_MOUNT, M_NOWAIT);
        !           233:        if (mp == NULL)
        !           234:                panic("nfs root mount2");
        !           235:        mp->mnt_op = &nfs_vfsops;
        !           236:        mp->mnt_flag = MNT_RDONLY;
        !           237:        mp->mnt_exroot = 0;
        !           238:        mp->mnt_mounth = NULLVP;
        !           239: 
        !           240:        /*
        !           241:         * Set up the root fs args and call mountnfs() to do the rest.
        !           242:         */
        !           243:        nfs_diskless.root_args.fh = (nfsv2fh_t *)nfs_diskless.root_fh;
        !           244:        MGET(m, MT_SONAME, M_DONTWAIT);
        !           245:        if (m == NULL)
        !           246:                panic("nfs root mbuf2");
        !           247:        bcopy((caddr_t)&nfs_diskless.root_saddr, mtod(m, caddr_t),
        !           248:                nfs_diskless.root_saddr.sa_len);
        !           249:        m->m_len = nfs_diskless.root_saddr.sa_len;
        !           250:        if (mountnfs(&nfs_diskless.root_args, mp, m, "/",
        !           251:                nfs_diskless.root_hostnam, &vp))
        !           252:                panic("nfs root");
        !           253:        if (vfs_lock(mp))
        !           254:                panic("nfs root2");
        !           255:        rootfs = mp;
        !           256:        mp->mnt_next = mp;
        !           257:        mp->mnt_prev = mp;
        !           258:        mp->mnt_vnodecovered = NULLVP;
        !           259:        vfs_unlock(mp);
        !           260:        rootvp = vp;
        !           261:        inittodr((time_t)0);    /* There is no time in the nfs fsstat so ?? */
        !           262:        return (0);
        !           263: }
        !           264: 
        !           265: /*
        !           266:  * VFS Operations.
        !           267:  *
        !           268:  * mount system call
        !           269:  * It seems a bit dumb to copyinstr() the host and path here and then
        !           270:  * bcopy() them in mountnfs(), but I wanted to detect errors before
        !           271:  * doing the sockargs() call because sockargs() allocates an mbuf and
        !           272:  * an error after that means that I have to release the mbuf.
        !           273:  */
        !           274: /* ARGSUSED */
        !           275: nfs_mount(mp, path, data, ndp, p)
        !           276:        struct mount *mp;
        !           277:        char *path;
        !           278:        caddr_t data;
        !           279:        struct nameidata *ndp;
        !           280:        struct proc *p;
        !           281: {
        !           282:        int error;
        !           283:        struct nfs_args args;
        !           284:        struct mbuf *nam;
        !           285:        struct vnode *vp;
        !           286:        char pth[MNAMELEN], hst[MNAMELEN];
        !           287:        u_int len;
        !           288:        nfsv2fh_t nfh;
        !           289: 
        !           290:        if (mp->mnt_flag & MNT_UPDATE)
        !           291:                return (0);
        !           292:        if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)))
        !           293:                return (error);
        !           294:        if (error = copyin((caddr_t)args.fh, (caddr_t)&nfh, sizeof (nfsv2fh_t)))
        !           295:                return (error);
        !           296:        if (error = copyinstr(path, pth, MNAMELEN-1, &len))
        !           297:                return (error);
        !           298:        bzero(&pth[len], MNAMELEN - len);
        !           299:        if (error = copyinstr(args.hostname, hst, MNAMELEN-1, &len))
        !           300:                return (error);
        !           301:        bzero(&hst[len], MNAMELEN - len);
        !           302:        /* sockargs() call must be after above copyin() calls */
        !           303:        if (error = sockargs(&nam, (caddr_t)args.addr,
        !           304:                sizeof (struct sockaddr), MT_SONAME))
        !           305:                return (error);
        !           306:        args.fh = &nfh;
        !           307:        error = mountnfs(&args, mp, nam, pth, hst, &vp);
        !           308:        return (error);
        !           309: }
        !           310: 
        !           311: /*
        !           312:  * Common code for mount and mountroot
        !           313:  */
        !           314: mountnfs(argp, mp, nam, pth, hst, vpp)
        !           315:        register struct nfs_args *argp;
        !           316:        register struct mount *mp;
        !           317:        struct mbuf *nam;
        !           318:        char *pth, *hst;
        !           319:        struct vnode **vpp;
        !           320: {
        !           321:        register struct nfsmount *nmp;
        !           322:        struct proc *p = curproc;               /* XXX */
        !           323:        struct nfsnode *np;
        !           324:        int error;
        !           325:        fsid_t tfsid;
        !           326: 
        !           327:        MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK);
        !           328:        bzero((caddr_t)nmp, sizeof *nmp);
        !           329:        mp->mnt_data = (qaddr_t)nmp;
        !           330:        /*
        !           331:         * Generate a unique nfs mount id. The problem is that a dev number
        !           332:         * is not unique across multiple systems. The techique is as follows:
        !           333:         * 1) Set to nblkdev,0 which will never be used otherwise
        !           334:         * 2) Generate a first guess as nblkdev,nfs_mntid where nfs_mntid is
        !           335:         *      NOT 0
        !           336:         * 3) Loop searching the mount list for another one with same id
        !           337:         *      If a match, increment val[0] and try again
        !           338:         * NB: I increment val[0] { a long } instead of nfs_mntid { a u_char }
        !           339:         *      so that nfs is not limited to 255 mount points
        !           340:         *     Incrementing the high order bits does no real harm, since it
        !           341:         *     simply makes the major dev number tick up. The upper bound is
        !           342:         *     set to major dev 127 to avoid any sign extention problems
        !           343:         */
        !           344:        mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev, 0);
        !           345:        mp->mnt_stat.f_fsid.val[1] = MOUNT_NFS;
        !           346:        if (++nfs_mntid == 0)
        !           347:                ++nfs_mntid;
        !           348:        tfsid.val[0] = makedev(nblkdev, nfs_mntid);
        !           349:        tfsid.val[1] = MOUNT_NFS;
        !           350:        while (rootfs && getvfs(&tfsid)) {
        !           351:                tfsid.val[0]++;
        !           352:                nfs_mntid++;
        !           353:        }
        !           354:        if (major(tfsid.val[0]) > 127) {
        !           355:                error = ENOENT;
        !           356:                goto bad;
        !           357:        }
        !           358:        mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
        !           359:        nmp->nm_mountp = mp;
        !           360:        nmp->nm_flag = argp->flags;
        !           361:        nmp->nm_rto = NFS_TIMEO;
        !           362:        nmp->nm_rtt = -1;
        !           363:        nmp->nm_rttvar = nmp->nm_rto << 1;
        !           364:        nmp->nm_retry = NFS_RETRANS;
        !           365:        nmp->nm_wsize = NFS_WSIZE;
        !           366:        nmp->nm_rsize = NFS_RSIZE;
        !           367:        bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t));
        !           368:        bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
        !           369:        bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
        !           370:        nmp->nm_nam = nam;
        !           371: 
        !           372:        if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
        !           373:                nmp->nm_rto = argp->timeo;
        !           374:                /* NFS timeouts are specified in 1/10 sec. */
        !           375:                nmp->nm_rto = (nmp->nm_rto * 10) / NFS_HZ;
        !           376:                if (nmp->nm_rto < NFS_MINTIMEO)
        !           377:                        nmp->nm_rto = NFS_MINTIMEO;
        !           378:                else if (nmp->nm_rto > NFS_MAXTIMEO)
        !           379:                        nmp->nm_rto = NFS_MAXTIMEO;
        !           380:                nmp->nm_rttvar = nmp->nm_rto << 1;
        !           381:        }
        !           382: 
        !           383:        if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
        !           384:                nmp->nm_retry = argp->retrans;
        !           385:                if (nmp->nm_retry > NFS_MAXREXMIT)
        !           386:                        nmp->nm_retry = NFS_MAXREXMIT;
        !           387:        }
        !           388: 
        !           389:        if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
        !           390:                nmp->nm_wsize = argp->wsize;
        !           391:                /* Round down to multiple of blocksize */
        !           392:                nmp->nm_wsize &= ~0x1ff;
        !           393:                if (nmp->nm_wsize <= 0)
        !           394:                        nmp->nm_wsize = 512;
        !           395:                else if (nmp->nm_wsize > NFS_MAXDATA)
        !           396:                        nmp->nm_wsize = NFS_MAXDATA;
        !           397:        }
        !           398:        if (nmp->nm_wsize > MAXBSIZE)
        !           399:                nmp->nm_wsize = MAXBSIZE;
        !           400: 
        !           401:        if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
        !           402:                nmp->nm_rsize = argp->rsize;
        !           403:                /* Round down to multiple of blocksize */
        !           404:                nmp->nm_rsize &= ~0x1ff;
        !           405:                if (nmp->nm_rsize <= 0)
        !           406:                        nmp->nm_rsize = 512;
        !           407:                else if (nmp->nm_rsize > NFS_MAXDATA)
        !           408:                        nmp->nm_rsize = NFS_MAXDATA;
        !           409:        }
        !           410:        if (nmp->nm_rsize > MAXBSIZE)
        !           411:                nmp->nm_rsize = MAXBSIZE;
        !           412:        /* Set up the sockets and per-host congestion */
        !           413:        nmp->nm_sotype = argp->sotype;
        !           414:        nmp->nm_soproto = argp->proto;
        !           415:        if (error = nfs_connect(nmp))
        !           416:                goto bad;
        !           417: 
        !           418:        if (error = nfs_statfs(mp, &mp->mnt_stat, p))
        !           419:                goto bad;
        !           420:        /*
        !           421:         * A reference count is needed on the nfsnode representing the
        !           422:         * remote root.  If this object is not persistent, then backward
        !           423:         * traversals of the mount point (i.e. "..") will not work if
        !           424:         * the nfsnode gets flushed out of the cache. Ufs does not have
        !           425:         * this problem, because one can identify root inodes by their
        !           426:         * number == ROOTINO (2).
        !           427:         */
        !           428:        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
        !           429:                goto bad;
        !           430:        /*
        !           431:         * Unlock it, but keep the reference count.
        !           432:         */
        !           433:        nfs_unlock(NFSTOV(np));
        !           434:        *vpp = NFSTOV(np);
        !           435: 
        !           436:        return (0);
        !           437: bad:
        !           438:        nfs_disconnect(nmp);
        !           439:        FREE(nmp, M_NFSMNT);
        !           440:        m_freem(nam);
        !           441:        return (error);
        !           442: }
        !           443: 
        !           444: /*
        !           445:  * unmount system call
        !           446:  */
        !           447: nfs_unmount(mp, mntflags, p)
        !           448:        struct mount *mp;
        !           449:        int mntflags;
        !           450:        struct proc *p;
        !           451: {
        !           452:        register struct nfsmount *nmp;
        !           453:        struct nfsnode *np;
        !           454:        struct vnode *vp;
        !           455:        int error, flags = 0;
        !           456:        extern int doforce;
        !           457: 
        !           458:        if (mntflags & MNT_FORCE) {
        !           459:                if (!doforce || mp == rootfs)
        !           460:                        return (EINVAL);
        !           461:                flags |= FORCECLOSE;
        !           462:        }
        !           463:        nmp = VFSTONFS(mp);
        !           464:        /*
        !           465:         * Clear out the buffer cache
        !           466:         */
        !           467:        mntflushbuf(mp, 0);
        !           468:        if (mntinvalbuf(mp))
        !           469:                return (EBUSY);
        !           470:        /*
        !           471:         * Goes something like this..
        !           472:         * - Check for activity on the root vnode (other than ourselves).
        !           473:         * - Call vflush() to clear out vnodes for this file system,
        !           474:         *   except for the root vnode.
        !           475:         * - Decrement reference on the vnode representing remote root.
        !           476:         * - Close the socket
        !           477:         * - Free up the data structures
        !           478:         */
        !           479:        /*
        !           480:         * We need to decrement the ref. count on the nfsnode representing
        !           481:         * the remote root.  See comment in mountnfs().  The VFS unmount()
        !           482:         * has done vput on this vnode, otherwise we would get deadlock!
        !           483:         */
        !           484:        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
        !           485:                return(error);
        !           486:        vp = NFSTOV(np);
        !           487:        if (vp->v_usecount > 2) {
        !           488:                vput(vp);
        !           489:                return (EBUSY);
        !           490:        }
        !           491:        if (error = vflush(mp, vp, flags)) {
        !           492:                vput(vp);
        !           493:                return (error);
        !           494:        }
        !           495:        /*
        !           496:         * Get rid of two reference counts, and unlock it on the second.
        !           497:         */
        !           498:        vrele(vp);
        !           499:        vput(vp);
        !           500:        nfs_disconnect(nmp);
        !           501:        m_freem(nmp->nm_nam);
        !           502:        free((caddr_t)nmp, M_NFSMNT);
        !           503:        return (0);
        !           504: }
        !           505: 
        !           506: /*
        !           507:  * Return root of a filesystem
        !           508:  */
        !           509: nfs_root(mp, vpp)
        !           510:        struct mount *mp;
        !           511:        struct vnode **vpp;
        !           512: {
        !           513:        register struct vnode *vp;
        !           514:        struct nfsmount *nmp;
        !           515:        struct nfsnode *np;
        !           516:        int error;
        !           517: 
        !           518:        nmp = VFSTONFS(mp);
        !           519:        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
        !           520:                return (error);
        !           521:        vp = NFSTOV(np);
        !           522:        vp->v_type = VDIR;
        !           523:        vp->v_flag = VROOT;
        !           524:        *vpp = vp;
        !           525:        return (0);
        !           526: }
        !           527: 
        !           528: extern int syncprt;
        !           529: 
        !           530: /*
        !           531:  * Flush out the buffer cache
        !           532:  */
        !           533: /* ARGSUSED */
        !           534: nfs_sync(mp, waitfor)
        !           535:        struct mount *mp;
        !           536:        int waitfor;
        !           537: {
        !           538:        if (syncprt)
        !           539:                bufstats();
        !           540:        /*
        !           541:         * Force stale buffer cache information to be flushed.
        !           542:         */
        !           543:        mntflushbuf(mp, waitfor == MNT_WAIT ? B_SYNC : 0);
        !           544:        return (0);
        !           545: }
        !           546: 
        !           547: /*
        !           548:  * At this point, this should never happen
        !           549:  */
        !           550: /* ARGSUSED */
        !           551: nfs_fhtovp(mp, fhp, vpp)
        !           552:        struct mount *mp;
        !           553:        struct fid *fhp;
        !           554:        struct vnode **vpp;
        !           555: {
        !           556: 
        !           557:        return (EINVAL);
        !           558: }
        !           559: 
        !           560: /*
        !           561:  * Vnode pointer to File handle, should never happen either
        !           562:  */
        !           563: /* ARGSUSED */
        !           564: nfs_vptofh(vp, fhp)
        !           565:        struct vnode *vp;
        !           566:        struct fid *fhp;
        !           567: {
        !           568: 
        !           569:        return (EINVAL);
        !           570: }
        !           571: 
        !           572: /*
        !           573:  * Vfs start routine, a no-op.
        !           574:  */
        !           575: /* ARGSUSED */
        !           576: nfs_start(mp, flags, p)
        !           577:        struct mount *mp;
        !           578:        int flags;
        !           579:        struct proc *p;
        !           580: {
        !           581: 
        !           582:        return (0);
        !           583: }
        !           584: 
        !           585: /*
        !           586:  * Do operations associated with quotas, not supported
        !           587:  */
        !           588: nfs_quotactl(mp, cmd, uid, arg, p)
        !           589:        struct mount *mp;
        !           590:        int cmd;
        !           591:        uid_t uid;
        !           592:        caddr_t arg;
        !           593:        struct proc *p;
        !           594: {
        !           595: #ifdef lint
        !           596:        mp = mp; cmd = cmd; uid = uid; arg = arg;
        !           597: #endif /* lint */
        !           598:        return (EOPNOTSUPP);
        !           599: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.