BSD 4_3_Reno release

[unix-history] / usr / src / sys / nfs / nfs_vfsops.c

diff --git a/usr/src/sys/nfs/nfs_vfsops.c b/usr/src/sys/nfs/nfs_vfsops.c
index c270c7e..d78a109 100644 (file)
--- a/usr/src/sys/nfs/nfs_vfsops.c
+++ b/usr/src/sys/nfs/nfs_vfsops.c
@@ -5,46 +5,41 @@
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.
  *
  * This code is derived from software contributed to Berkeley by
  * Rick Macklem at The University of Guelph.
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * Redistribution is only permitted until one year after the first shipment
+ * of 4.4BSD by the Regents.  Otherwise, redistribution and use in source and
+ * binary forms are permitted provided that: (1) source distributions retain
+ * this entire copyright notice and comment, and (2) distributions including
+ * binaries display the following acknowledgement:  This product includes
+ * software developed by the University of California, Berkeley and its
+ * contributors'' in the documentation or other materials provided with the
+ * distribution and in all advertising materials mentioning features or use
+ * of this software.  Neither the name of the University nor the names of
+ * its contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

  *
  *

- *     @(#)nfs_vfsops.c        7.5 (Berkeley) %G%
+ *     @(#)nfs_vfsops.c        7.24 (Berkeley) 6/28/90

  */
 
 #include "param.h"
 #include "signal.h"
 #include "user.h"
 #include "proc.h"
  */
 
 #include "param.h"
 #include "signal.h"
 #include "user.h"
 #include "proc.h"

-#include "uio.h"
-#include "ucred.h"
-#include "../ufs/dir.h"
-#include "namei.h"

 #include "vnode.h"
 #include "mount.h"
 #include "errno.h"
 #include "vnode.h"
 #include "mount.h"
 #include "errno.h"

-#include "malloc.h"
+#include "buf.h"

 #include "mbuf.h"
 #include "mbuf.h"

-#undef m_data

 #include "socket.h"
 #include "socket.h"

-#include "socketvar.h"
-#include "../netinet/in.h"
+#include "systm.h"

 #include "nfsv2.h"
 #include "nfsnode.h"
 #include "nfsmount.h"
 #include "nfs.h"
 #include "nfsv2.h"
 #include "nfsnode.h"
 #include "nfsmount.h"
 #include "nfs.h"

-
-#ifndef shouldbe
-#include "conf.h"
-#endif
+#include "xdr_subs.h"
+#include "nfsm_subs.h"

 
 /*
  * nfs vfs operations.
 
 /*
  * nfs vfs operations.


@@ -53,24 +48,82 @@ int nfs_mount();
 int nfs_start();
 int nfs_unmount();
 int nfs_root();
 int nfs_start();
 int nfs_unmount();
 int nfs_root();

-extern int nfs_statfs();
+int nfs_quotactl();
+int nfs_statfs();

 int nfs_sync();
 int nfs_fhtovp();
 int nfs_vptofh();
 int nfs_sync();
 int nfs_fhtovp();
 int nfs_vptofh();

+int nfs_init();

 
 struct vfsops nfs_vfsops = {
        nfs_mount,
        nfs_start,
        nfs_unmount,
        nfs_root,
 
 struct vfsops nfs_vfsops = {
        nfs_mount,
        nfs_start,
        nfs_unmount,
        nfs_root,

+       nfs_quotactl,

        nfs_statfs,
        nfs_sync,
        nfs_fhtovp,
        nfs_vptofh,
        nfs_statfs,
        nfs_sync,
        nfs_fhtovp,
        nfs_vptofh,

+       nfs_init,

 };
 
 };
 

-extern struct nfsreq nfsreqh;
-static long nfs_mntid;
+static u_char nfs_mntid;
+extern u_long nfs_procids[NFS_NPROCS];
+extern u_long nfs_prog, nfs_vers;
+void nfs_disconnect();
+
+#define TRUE   1
+#define        FALSE   0
+
+/*
+ * nfs statfs call
+ */
+nfs_statfs(mp, sbp)
+       struct mount *mp;
+       register struct statfs *sbp;
+{
+       register struct vnode *vp;
+       register struct nfsv2_statfs *sfp;
+       register caddr_t cp;
+       register long t1;
+       caddr_t bpos, dpos, cp2;
+       u_long xid;
+       int error = 0;
+       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
+       struct nfsmount *nmp;
+       struct ucred *cred;
+       struct nfsnode *np;
+
+       nmp = VFSTONFS(mp);
+       if (error = nfs_nget(mp, &nmp->nm_fh, &np))
+               return (error);
+       vp = NFSTOV(np);
+       nfsstats.rpccnt[NFSPROC_STATFS]++;
+       cred = crget();
+       cred->cr_ngroups = 1;
+       nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH);
+       nfsm_fhtom(vp);
+       nfsm_request(vp, NFSPROC_STATFS, u.u_procp, 0);
+       nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS);
+       sbp->f_type = MOUNT_NFS;
+       sbp->f_flags = nmp->nm_flag;
+       sbp->f_bsize = fxdr_unsigned(long, sfp->sf_tsize);
+       sbp->f_fsize = fxdr_unsigned(long, sfp->sf_bsize);
+       sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks);
+       sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree);
+       sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail);
+       sbp->f_files = 0;
+       sbp->f_ffree = 0;
+       if (sbp != &mp->mnt_stat) {
+               bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
+               bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
+       }
+       nfsm_reqdone;
+       nfs_nput(vp);
+       crfree(cred);
+       return (error);
+}

 
 /*
  * Called by vfs_mountroot when nfs is going to be mounted as root
 
 /*
  * Called by vfs_mountroot when nfs is going to be mounted as root


@@ -90,6 +143,7 @@ nfs_mountroot()
  * doing the sockargs() call because sockargs() allocates an mbuf and
  * an error after that means that I have to release the mbuf.
  */
  * doing the sockargs() call because sockargs() allocates an mbuf and
  * an error after that means that I have to release the mbuf.
  */

+/* ARGSUSED */

 nfs_mount(mp, path, data, ndp)
        struct mount *mp;
        char *path;
 nfs_mount(mp, path, data, ndp)
        struct mount *mp;
        char *path;


@@ -98,11 +152,13 @@ nfs_mount(mp, path, data, ndp)
 {
        int error;
        struct nfs_args args;
 {
        int error;
        struct nfs_args args;

-       struct mbuf *saddr;
+       struct mbuf *nam;

        char pth[MNAMELEN], hst[MNAMELEN];
        int len;
        nfsv2fh_t nfh;
 
        char pth[MNAMELEN], hst[MNAMELEN];
        int len;
        nfsv2fh_t nfh;
 

+       if (mp->mnt_flag & MNT_UPDATE)
+               return (0);

        if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)))
                return (error);
        if (error=copyin((caddr_t)args.fh, (caddr_t)&nfh, sizeof (nfsv2fh_t)))
        if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)))
                return (error);
        if (error=copyin((caddr_t)args.fh, (caddr_t)&nfh, sizeof (nfsv2fh_t)))


@@ -114,174 +170,200 @@ nfs_mount(mp, path, data, ndp)
                return (error);
        bzero(&hst[len], MNAMELEN-len);
        /* sockargs() call must be after above copyin() calls */
                return (error);
        bzero(&hst[len], MNAMELEN-len);
        /* sockargs() call must be after above copyin() calls */

-       if (error = sockargs(&saddr, (caddr_t)args.addr,
-               sizeof (struct sockaddr_in), MT_SONAME))
+       if (error = sockargs(&nam, (caddr_t)args.addr,
+               sizeof (struct sockaddr), MT_SONAME))

                return (error);
        args.fh = &nfh;
                return (error);
        args.fh = &nfh;

-       error = mountnfs(&args, mp, saddr, pth, hst);
+       error = mountnfs(&args, mp, nam, pth, hst);

        return (error);
 }
 
 /*
  * Common code for mount and mountroot
  */
        return (error);
 }
 
 /*
  * Common code for mount and mountroot
  */

-mountnfs(argp, mp, saddr, pth, hst)
+mountnfs(argp, mp, nam, pth, hst)

        register struct nfs_args *argp;
        register struct mount *mp;
        register struct nfs_args *argp;
        register struct mount *mp;

-       register struct mbuf *saddr;
+       struct mbuf *nam;

        char *pth, *hst;
 {
        register struct nfsmount *nmp;
        struct nfsnode *np;
        char *pth, *hst;
 {
        register struct nfsmount *nmp;
        struct nfsnode *np;

-#ifdef notdef
-       struct statfs statf, *sbp;
-#endif

        int error;
        int error;

+       fsid_t tfsid;

 
 

-       nmp = (struct nfsmount *)malloc(sizeof (struct nfsmount), M_NFSMNT,
-           M_WAITOK);
-       mp->m_data = (qaddr_t)nmp;
-       mp->m_fsid.val[0] = ++nfs_mntid;
-       mp->m_fsid.val[1] = MOUNT_NFS;
+       MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK);
+       bzero((caddr_t)nmp, sizeof *nmp);
+       mp->mnt_data = (qaddr_t)nmp;
+       /*
+        * Generate a unique nfs mount id. The problem is that a dev number
+        * is not unique across multiple systems. The techique is as follows:
+        * 1) Set to nblkdev,0 which will never be used otherwise
+        * 2) Generate a first guess as nblkdev,nfs_mntid where nfs_mntid is
+        *      NOT 0
+        * 3) Loop searching the mount list for another one with same id
+        *      If a match, increment val[0] and try again
+        * NB: I increment val[0] { a long } instead of nfs_mntid { a u_char }
+        *      so that nfs is not limited to 255 mount points
+        *     Incrementing the high order bits does no real harm, since it
+        *     simply makes the major dev number tick up. The upper bound is
+        *     set to major dev 127 to avoid any sign extention problems
+        */
+       mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev, 0);
+       mp->mnt_stat.f_fsid.val[1] = MOUNT_NFS;
+       if (++nfs_mntid == 0)
+               ++nfs_mntid;
+       tfsid.val[0] = makedev(nblkdev, nfs_mntid);
+       tfsid.val[1] = MOUNT_NFS;
+       while (getvfs(&tfsid)) {
+               tfsid.val[0]++;
+               nfs_mntid++;
+       }
+       if (major(tfsid.val[0]) > 127) {
+               error = ENOENT;
+               goto bad;
+       }
+       mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];

        nmp->nm_mountp = mp;
        nmp->nm_flag = argp->flags;
        nmp->nm_mountp = mp;
        nmp->nm_flag = argp->flags;

-       nmp->nm_sockaddr = saddr;
-       /* Set up the sockets */
-       if (error = socreate(AF_INET, &nmp->nm_so, SOCK_DGRAM, 0))
-               goto bad;
-       if (error = soconnect(nmp->nm_so, saddr))
-               goto bad;
-printf("sosnd=0x%x sorcv=0x%x\n",&nmp->nm_so->so_snd,&nmp->nm_so->so_rcv);
-       if ((argp->flags & NFSMNT_TIMEO) && argp->timeo >= 1)
-               nmp->nm_timeo = argp->timeo;
-       else
-               nmp->nm_timeo = NFS_TIMEO;
-       if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 0)
-               nmp->nm_retrans = argp->retrans;
-       else
-               nmp->nm_retrans = NFS_RETRANS;
-       if ((argp->flags & NFSMNT_WSIZE) &&
-           argp->wsize <= NFS_MAXDATA && argp->wsize > 0 &&
-          (argp->wsize & 0x1ff) == 0)
-               nmp->nm_wsize = argp->wsize;
-       else
-               nmp->nm_wsize = NFS_WSIZE;
-       if ((argp->flags & NFSMNT_RSIZE) &&
-           argp->rsize <= NFS_MAXDATA && argp->rsize > 0 &&
-          (argp->rsize & 0x1ff) == 0)
-               nmp->nm_rsize = argp->rsize;
-       else
-               nmp->nm_rsize = NFS_RSIZE;
+       nmp->nm_rto = NFS_TIMEO;
+       nmp->nm_rtt = -1;
+       nmp->nm_rttvar = nmp->nm_rto << 1;
+       nmp->nm_retry = NFS_RETRANS;
+       nmp->nm_wsize = NFS_WSIZE;
+       nmp->nm_rsize = NFS_RSIZE;

        bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t));
        bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t));

-       bcopy(pth, nmp->nm_path, MNAMELEN);
-       bcopy(hst, nmp->nm_host, MNAMELEN);
-#ifdef notdef
-       sbp = &statf;
-       /*
-        * Kludge City...
-        * To do an interruptable hard mount, turn it into a soft mount
-        * with a retry limit of one and then repeat it so long as it
-        * times out and there is no pending signal for the process.
-        * It is tempting to just let nfs_statfs() sleep at positive
-        * prio, but then you would long jump out without taking the
-        * mount structure back out of the list.
-        * NB: NFSMNT_INT must NEVER be set for nfs_mountroot(), since
-        * the process context is not yet built!!
-        */
-       if ((argp->flags && NFSMNT_INT) && (argp->flags & NFSMNT_SOFT) == 0) {
-               int savretrans;
+       bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
+       bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
+       nmp->nm_nam = nam;
+
+       if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
+               nmp->nm_rto = argp->timeo;
+               /* NFS timeouts are specified in 1/10 sec. */
+               nmp->nm_rto = (nmp->nm_rto * 10) / NFS_HZ;
+               if (nmp->nm_rto < NFS_MINTIMEO)
+                       nmp->nm_rto = NFS_MINTIMEO;
+               else if (nmp->nm_rto > NFS_MAXTIMEO)
+                       nmp->nm_rto = NFS_MAXTIMEO;
+               nmp->nm_rttvar = nmp->nm_rto << 1;
+       }

 
 

-               nmp->nm_flag |= NFSMNT_SOFT;
-               savretrans = nmp->nm_retrans;
-               nmp->nm_retrans = 1;
-               do {
-                       error = nfs_statfs(mp, sbp);
-               } while (error == ETIMEDOUT && (u.u_procp->p_sig &
-                       (sigmask(SIGINT)|sigmask(SIGQUIT)|sigmask(SIGTERM)|
-                        sigmask(SIGKILL))) == 0);
-               nmp->nm_retrans = savretrans;
-               nmp->nm_flag &= ~NFSMNT_SOFT;
-               if (error)
-                       goto bad;
-       } else if (error = nfs_statfs(mp, sbp))
+       if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
+               nmp->nm_retry = argp->retrans;
+               if (nmp->nm_retry > NFS_MAXREXMIT)
+                       nmp->nm_retry = NFS_MAXREXMIT;
+       }
+
+       if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
+               nmp->nm_wsize = argp->wsize;
+               /* Round down to multiple of blocksize */
+               nmp->nm_wsize &= ~0x1ff;
+               if (nmp->nm_wsize <= 0)
+                       nmp->nm_wsize = 512;
+               else if (nmp->nm_wsize > NFS_MAXDATA)
+                       nmp->nm_wsize = NFS_MAXDATA;
+       }
+       if (nmp->nm_wsize > MAXBSIZE)
+               nmp->nm_wsize = MAXBSIZE;
+
+       if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
+               nmp->nm_rsize = argp->rsize;
+               /* Round down to multiple of blocksize */
+               nmp->nm_rsize &= ~0x1ff;
+               if (nmp->nm_rsize <= 0)
+                       nmp->nm_rsize = 512;
+               else if (nmp->nm_rsize > NFS_MAXDATA)
+                       nmp->nm_rsize = NFS_MAXDATA;
+       }
+       if (nmp->nm_rsize > MAXBSIZE)
+               nmp->nm_rsize = MAXBSIZE;
+       /* Set up the sockets and per-host congestion */
+       nmp->nm_sotype = argp->sotype;
+       nmp->nm_soproto = argp->proto;
+       if (error = nfs_connect(nmp))

                goto bad;
                goto bad;

-       mp->m_fsize = sbp->f_fsize;

 
 

+       if (error = nfs_statfs(mp, &mp->mnt_stat))
+               goto bad;

        /*
        /*

-        * If the block size is not an exact multiple of CLBYTES
-        * use CLBYTES so that paging in ZMAGIC executables doesn't
-        * get sick. (It is used by vinitfod())
+        * A reference count is needed on the nfsnode representing the
+        * remote root.  If this object is not persistent, then backward
+        * traversals of the mount point (i.e. "..") will not work if
+        * the nfsnode gets flushed out of the cache. Ufs does not have
+        * this problem, because one can identify root inodes by their
+        * number == ROOTINO (2).

         */
         */

-       if (sbp->f_bsize >= CLBYTES && claligned(sbp->f_bsize))
-               mp->m_bsize = sbp->f_bsize;
-       else
-               mp->m_bsize = CLBYTES;
-#else
+       if (error = nfs_nget(mp, &nmp->nm_fh, &np))
+               goto bad;

        /*
        /*

-        * Set to CLBYTES so that vinifod() doesn't get confused.
-        * Actually any exact multiple of CLBYTES will do
+        * Unlock it, but keep the reference count.

         */
         */

-       mp->m_bsize = mp->m_fsize = CLBYTES;
-#endif
+       nfs_unlock(NFSTOV(np));
+

        return (0);
 bad:
        return (0);
 bad:

-       m_freem(saddr);
-       free((caddr_t)nmp, M_NFSMNT);
+       nfs_disconnect(nmp);
+       FREE(nmp, M_NFSMNT);
+       m_freem(nam);

        return (error);
 }
 
 /*
  * unmount system call
  */
        return (error);
 }
 
 /*
  * unmount system call
  */

-nfs_unmount(mp, flags)
+nfs_unmount(mp, mntflags)

        struct mount *mp;
        struct mount *mp;

-       int flags;
+       int mntflags;

 {
        register struct nfsmount *nmp;
 {
        register struct nfsmount *nmp;

-       register struct nfsreq *rep;
-       struct nfsreq *rep2;
+       struct nfsnode *np;
+       struct vnode *vp;
+       int flags = 0;

        int error;
        int error;

-       int s;

 
 

-       if (flags & MNT_FORCE)
+       if (mntflags & MNT_FORCE)

                return (EINVAL);
                return (EINVAL);

-       nmp = vfs_to_nfs(mp);
+       if (mntflags & MNT_FORCE)
+               flags |= FORCECLOSE;
+       nmp = VFSTONFS(mp);

        /*
         * Clear out the buffer cache
         */
        /*
         * Clear out the buffer cache
         */

-       bflush(mp);
-       if (binval(mp))
+       mntflushbuf(mp, 0);
+       if (mntinvalbuf(mp))

                return (EBUSY);
        /*
         * Goes something like this..
                return (EBUSY);
        /*
         * Goes something like this..

-        * - Call nfs_nflush() to clear out the nfsnode table
-        * - Flush out lookup cache
+        * - Check for activity on the root vnode (other than ourselves).
+        * - Call vflush() to clear out vnodes for this file system,
+        *   except for the root vnode.
+        * - Decrement reference on the vnode representing remote root.

         * - Close the socket
         * - Free up the data structures
         */
         * - Close the socket
         * - Free up the data structures
         */

-       if (error = nfs_nflush(mp)) {
+       /*
+        * We need to decrement the ref. count on the nfsnode representing
+        * the remote root.  See comment in mountnfs().  The VFS unmount()
+        * has done vput on this vnode, otherwise we would get deadlock!
+        */
+       if (error = nfs_nget(mp, &nmp->nm_fh, &np))
+               return(error);
+       vp = NFSTOV(np);
+       if (vp->v_usecount > 2) {
+               vput(vp);
+               return (EBUSY);
+       }
+       if (error = vflush(mp, vp, flags)) {
+               vput(vp);

                return (error);
        }
        /*
                return (error);
        }
        /*

-        * Scan the request list for any requests left hanging about
+        * Get rid of two reference counts, and unlock it on the second.

         */
         */

-       s = splnet();
-       rep = nfsreqh.r_next;
-       while (rep && rep != &nfsreqh) {
-               if (rep->r_mntp == nmp) {
-                       rep->r_prev->r_next = rep2 = rep->r_next;
-                       rep->r_next->r_prev = rep->r_prev;
-                       m_freem(rep->r_mreq);
-                       if (rep->r_mrep != NULL)
-                               m_freem(rep->r_mrep);
-                       free((caddr_t)rep, M_NFSREQ);
-                       rep = rep2;
-               } else
-                       rep = rep->r_next;
-       }
-       splx(s);
-       soclose(nmp->nm_so);
-       m_freem(nmp->nm_sockaddr);
+       vrele(vp);
+       vput(vp);
+       nfs_disconnect(nmp);
+       m_freem(nmp->nm_nam);

        free((caddr_t)nmp, M_NFSMNT);
        return (0);
 }
        free((caddr_t)nmp, M_NFSMNT);
        return (0);
 }


@@ -298,7 +380,7 @@ nfs_root(mp, vpp)
        struct nfsnode *np;
        int error;
 
        struct nfsnode *np;
        int error;
 

-       nmp = vfs_to_nfs(mp);
+       nmp = VFSTONFS(mp);

        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
                return (error);
        vp = NFSTOV(np);
        if (error = nfs_nget(mp, &nmp->nm_fh, &np))
                return (error);
        vp = NFSTOV(np);


@@ -313,6 +395,7 @@ extern int syncprt;
 /*
  * Flush out the buffer cache
  */
 /*
  * Flush out the buffer cache
  */

+/* ARGSUSED */

 nfs_sync(mp, waitfor)
        struct mount *mp;
        int waitfor;
 nfs_sync(mp, waitfor)
        struct mount *mp;
        int waitfor;


@@ -322,38 +405,59 @@ nfs_sync(mp, waitfor)
        /*
         * Force stale buffer cache information to be flushed.
         */
        /*
         * Force stale buffer cache information to be flushed.
         */

-       bflush(mp);
+       mntflushbuf(mp, waitfor == MNT_WAIT ? B_SYNC : 0);

        return (0);
 }
 
 /*
  * At this point, this should never happen
  */
        return (0);
 }
 
 /*
  * At this point, this should never happen
  */

+/* ARGSUSED */

 nfs_fhtovp(mp, fhp, vpp)
        struct mount *mp;
        struct fid *fhp;
        struct vnode **vpp;
 {
 nfs_fhtovp(mp, fhp, vpp)
        struct mount *mp;
        struct fid *fhp;
        struct vnode **vpp;
 {

+

        return (EINVAL);
 }
 
 /*
  * Vnode pointer to File handle, should never happen either
  */
        return (EINVAL);
 }
 
 /*
  * Vnode pointer to File handle, should never happen either
  */

+/* ARGSUSED */

 nfs_vptofh(mp, fhp, vpp)
        struct mount *mp;
        struct fid *fhp;
        struct vnode **vpp;
 {
 nfs_vptofh(mp, fhp, vpp)
        struct mount *mp;
        struct fid *fhp;
        struct vnode **vpp;
 {

+

        return (EINVAL);
 }
 
 /*
  * Vfs start routine, a no-op.
  */
        return (EINVAL);
 }
 
 /*
  * Vfs start routine, a no-op.
  */

+/* ARGSUSED */

 nfs_start(mp, flags)
        struct mount *mp;
        int flags;
 {
 nfs_start(mp, flags)
        struct mount *mp;
        int flags;
 {

+

        return (0);
 }
        return (0);
 }

+
+/*
+ * Do operations associated with quotas, not supported
+ */
+nfs_quotactl(mp, cmd, uid, arg)
+       struct mount *mp;
+       int cmd;
+       uid_t uid;
+       caddr_t arg;
+{
+#ifdef lint
+       mp = mp; cmd = cmd; uid = uid; arg = arg;
+#endif /* lint */
+       return (EOPNOTSUPP);
+}