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 029b5db..d78a109 100644 (file)
--- a/usr/src/sys/nfs/nfs_vfsops.c
+++ b/usr/src/sys/nfs/nfs_vfsops.c
@@ -5,19 +5,22 @@
  * 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.18 (Berkeley) %G%
+ *     @(#)nfs_vfsops.c        7.24 (Berkeley) 6/28/90

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -29,13 +32,14 @@
 #include "errno.h"
 #include "buf.h"
 #include "mbuf.h"
 #include "errno.h"
 #include "buf.h"
 #include "mbuf.h"

-#undef m_data

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

+#include "xdr_subs.h"
+#include "nfsm_subs.h"

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


@@ -44,6 +48,7 @@ int nfs_mount();
 int nfs_start();
 int nfs_unmount();
 int nfs_root();
 int nfs_start();
 int nfs_unmount();
 int nfs_root();

+int nfs_quotactl();

 int nfs_statfs();
 int nfs_sync();
 int nfs_fhtovp();
 int nfs_statfs();
 int nfs_sync();
 int nfs_fhtovp();


@@ -55,6 +60,7 @@ struct vfsops nfs_vfsops = {
        nfs_start,
        nfs_unmount,
        nfs_root,
        nfs_start,
        nfs_unmount,
        nfs_root,

+       nfs_quotactl,

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


@@ -63,6 +69,61 @@ struct vfsops nfs_vfsops = {
 };
 
 static u_char 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


@@ -91,12 +152,12 @@ 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->m_flag & M_UPDATE)
+       if (mp->mnt_flag & MNT_UPDATE)

                return (0);
        if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)))
                return (error);
                return (0);
        if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args)))
                return (error);


@@ -109,21 +170,21 @@ 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,
+       if (error = sockargs(&nam, (caddr_t)args.addr,

                sizeof (struct sockaddr), MT_SONAME))
                return (error);
        args.fh = &nfh;
                sizeof (struct sockaddr), MT_SONAME))
                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;
        char *pth, *hst;
 {
        register struct nfsmount *nmp;


@@ -133,7 +194,7 @@ mountnfs(argp, mp, saddr, pth, hst)
 
        MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK);
        bzero((caddr_t)nmp, sizeof *nmp);
 
        MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK);
        bzero((caddr_t)nmp, sizeof *nmp);

-       mp->m_data = (qaddr_t)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:
        /*
         * Generate a unique nfs mount id. The problem is that a dev number
         * is not unique across multiple systems. The techique is as follows:


@@ -148,8 +209,8 @@ mountnfs(argp, mp, saddr, pth, hst)
         *     simply makes the major dev number tick up. The upper bound is
         *     set to major dev 127 to avoid any sign extention problems
         */
         *     simply makes the major dev number tick up. The upper bound is
         *     set to major dev 127 to avoid any sign extention problems
         */

-       mp->m_stat.f_fsid.val[0] = makedev(nblkdev, 0);
-       mp->m_stat.f_fsid.val[1] = MOUNT_NFS;
+       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);
        if (++nfs_mntid == 0)
                ++nfs_mntid;
        tfsid.val[0] = makedev(nblkdev, nfs_mntid);


@@ -160,10 +221,9 @@ mountnfs(argp, mp, saddr, pth, hst)
        }
        if (major(tfsid.val[0]) > 127) {
                error = ENOENT;
        }
        if (major(tfsid.val[0]) > 127) {
                error = ENOENT;

-               m_freem(saddr);

                goto bad;
        }
                goto bad;
        }

-       mp->m_stat.f_fsid.val[0] = tfsid.val[0];
+       mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];

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


@@ -173,8 +233,9 @@ mountnfs(argp, mp, saddr, pth, hst)
        nmp->nm_wsize = NFS_WSIZE;
        nmp->nm_rsize = NFS_RSIZE;
        bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t));
        nmp->nm_wsize = NFS_WSIZE;
        nmp->nm_rsize = NFS_RSIZE;
        bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t));

-       bcopy(hst, mp->m_stat.f_mntfromname, MNAMELEN);
-       bcopy(pth, mp->m_stat.f_mntonname, MNAMELEN);
+       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;
 
        if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
                nmp->nm_rto = argp->timeo;


@@ -187,7 +248,7 @@ mountnfs(argp, mp, saddr, pth, hst)
                nmp->nm_rttvar = nmp->nm_rto << 1;
        }
 
                nmp->nm_rttvar = nmp->nm_rto << 1;
        }
 

-       if ((argp->flags & NFSMNT_RETRANS) && argp->retrans >= 0) {
+       if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {

                nmp->nm_retry = argp->retrans;
                if (nmp->nm_retry > NFS_MAXREXMIT)
                        nmp->nm_retry = NFS_MAXREXMIT;
                nmp->nm_retry = argp->retrans;
                if (nmp->nm_retry > NFS_MAXREXMIT)
                        nmp->nm_retry = NFS_MAXREXMIT;


@@ -202,6 +263,8 @@ mountnfs(argp, mp, saddr, pth, hst)
                else if (nmp->nm_wsize > NFS_MAXDATA)
                        nmp->nm_wsize = NFS_MAXDATA;
        }
                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;
 
        if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
                nmp->nm_rsize = argp->rsize;


@@ -212,13 +275,15 @@ mountnfs(argp, mp, saddr, pth, hst)
                else if (nmp->nm_rsize > NFS_MAXDATA)
                        nmp->nm_rsize = NFS_MAXDATA;
        }
                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 */
        /* Set up the sockets and per-host congestion */

-       if (error = nfs_connect(nmp, saddr)) {
-               m_freem(saddr);
+       nmp->nm_sotype = argp->sotype;
+       nmp->nm_soproto = argp->proto;
+       if (error = nfs_connect(nmp))

                goto bad;
                goto bad;

-       }

 
 

-       if (error = nfs_statfs(mp, &mp->m_stat))
+       if (error = nfs_statfs(mp, &mp->mnt_stat))

                goto bad;
        /*
         * A reference count is needed on the nfsnode representing the
                goto bad;
        /*
         * A reference count is needed on the nfsnode representing the


@@ -234,32 +299,33 @@ mountnfs(argp, mp, saddr, pth, hst)
         * Unlock it, but keep the reference count.
         */
        nfs_unlock(NFSTOV(np));
         * Unlock it, but keep the reference count.
         */
        nfs_unlock(NFSTOV(np));

-       return (0);

 
 

+       return (0);

 bad:
        nfs_disconnect(nmp);
        FREE(nmp, M_NFSMNT);
 bad:
        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;
        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
         */


@@ -297,6 +363,7 @@ nfs_unmount(mp, flags)
        vrele(vp);
        vput(vp);
        nfs_disconnect(nmp);
        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);
 }


@@ -313,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);


@@ -379,3 +446,18 @@ nfs_start(mp, 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);
+}