BSD 4_4_Lite2 release

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

diff --git a/usr/src/sys/nfs/nfs_srvcache.c b/usr/src/sys/nfs/nfs_srvcache.c
index 858347c..954987b 100644 (file)
--- a/usr/src/sys/nfs/nfs_srvcache.c
+++ b/usr/src/sys/nfs/nfs_srvcache.c
@@ -1,57 +1,84 @@
 /*
 /*

- * Copyright (c) 1989 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * 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 and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. 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.

  *
  *

- *     @(#)nfs_srvcache.c      7.3 (Berkeley) %G%
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)nfs_srvcache.c      8.3 (Berkeley) 3/30/95

  */
 
  */
 

-#include "param.h"
-#include "user.h"
-#include "vnode.h"
-#include "mount.h"
-#include "kernel.h"
-#include "systm.h"
-#include "mbuf.h"
-#include "socket.h"
-#include "socketvar.h"
-#include "netinet/in.h"
-#include "nfsm_subs.h"
-#include "nfsv2.h"
-#include "nfsrvcache.h"
-#include "nfs.h"
+/*
+ * Reference: Chet Juszczak, "Improving the Performance and Correctness
+ *             of an NFS Server", in Proc. Winter 1989 USENIX Conference,
+ *             pages 53-63. San Diego, February 1989.
+ */
+#include <sys/param.h>
+#include <sys/vnode.h>
+#include <sys/mount.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/mbuf.h>
+#include <sys/malloc.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>

 
 

-#if    ((NFSRCHSZ&(NFSRCHSZ-1)) == 0)
-#define        NFSRCHASH(xid)          (((xid)+((xid)>>16))&(NFSRCHSZ-1))
-#else
-#define        NFSRCHASH(xid)          (((unsigned)((xid)+((xid)>>16)))%NFSRCHSZ)
+#include <netinet/in.h>
+#ifdef ISO
+#include <netiso/iso.h>

 #endif
 #endif

+#include <nfs/nfsm_subs.h>
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfs/nfs.h>
+#include <nfs/nfsrvcache.h>
+#include <nfs/nqnfs.h>

 
 

-union rhead {
-       union  rhead *rh_head[2];
-       struct nfsrvcache *rh_chain[2];
-} rhead[NFSRCHSZ];
+extern struct nfsstats nfsstats;
+extern int nfsv2_procid[NFS_NPROCS];
+long numnfsrvcache, desirednfsrvcache = NFSRVCACHESIZ;

 
 

-static struct nfsrvcache nfsrvcachehead;
-static struct nfsrvcache nfsrvcache[NFSRVCACHESIZ];
+#define        NFSRCHASH(xid) \
+       (&nfsrvhashtbl[((xid) + ((xid) >> 24)) & nfsrvhash])
+LIST_HEAD(nfsrvhash, nfsrvcache) *nfsrvhashtbl;
+TAILQ_HEAD(nfsrvlru, nfsrvcache) nfsrvlruhead;
+u_long nfsrvhash;

 
 #define TRUE   1
 #define        FALSE   0
 
 
 #define TRUE   1
 #define        FALSE   0
 

+#define        NETFAMILY(rp) \
+               (((rp)->rc_flag & RC_INETADDR) ? AF_INET : AF_ISO)
+

 /*
  * Static array that defines which nfs rpc's are nonidempotent
  */
 /*
  * Static array that defines which nfs rpc's are nonidempotent
  */


@@ -63,7 +90,6 @@ int nonidempotent[NFS_NPROCS] = {
        FALSE,
        FALSE,
        FALSE,
        FALSE,
        FALSE,
        FALSE,

-       FALSE,

        TRUE,
        TRUE,
        TRUE,
        TRUE,
        TRUE,
        TRUE,


@@ -72,12 +98,21 @@ int nonidempotent[NFS_NPROCS] = {
        TRUE,
        TRUE,
        TRUE,
        TRUE,
        TRUE,
        TRUE,

+       TRUE,
+       FALSE,
+       FALSE,
+       FALSE,
+       FALSE,
+       FALSE,
+       FALSE,
+       FALSE,
+       FALSE,

        FALSE,
        FALSE,
 };
 
 /* True iff the rpc reply is an nfs status ONLY! */
        FALSE,
        FALSE,
 };
 
 /* True iff the rpc reply is an nfs status ONLY! */

-static int repliesstatus[NFS_NPROCS] = {
+static int nfsv2_repstat[NFS_NPROCS] = {

        FALSE,
        FALSE,
        FALSE,
        FALSE,
        FALSE,
        FALSE,


@@ -101,29 +136,12 @@ static int repliesstatus[NFS_NPROCS] = {
 /*
  * Initialize the server request cache list
  */
 /*
  * Initialize the server request cache list
  */

+void

 nfsrv_initcache()
 {
 nfsrv_initcache()
 {

-       register int i;
-       register struct nfsrvcache *rp = nfsrvcache;
-       register struct nfsrvcache *hp = &nfsrvcachehead;
-       register union  rhead *rh = rhead;

 
 

-       for (i = NFSRCHSZ; --i >= 0; rh++) {
-               rh->rh_head[0] = rh;
-               rh->rh_head[1] = rh;
-       }
-       hp->rc_next = hp->rc_prev = hp;
-       for (i = NFSRVCACHESIZ; i-- > 0; ) {
-               rp->rc_state = RC_UNUSED;
-               rp->rc_flag = 0;
-               rp->rc_forw = rp;
-               rp->rc_back = rp;
-               rp->rc_next = hp->rc_next;
-               hp->rc_next->rc_prev = rp;
-               rp->rc_prev = hp;
-               hp->rc_next = rp;
-               rp++;
-       }
+       nfsrvhashtbl = hashinit(desirednfsrvcache, M_NFSD, &nfsrvhash);
+       TAILQ_INIT(&nfsrvlruhead);

 }
 
 /*
 }
 
 /*


@@ -140,52 +158,57 @@ nfsrv_initcache()
  *   return DOIT
  * Update/add new request at end of lru list
  */
  *   return DOIT
  * Update/add new request at end of lru list
  */

-nfsrv_getcache(nam, xid, proc, repp)
-       struct mbuf *nam;
-       u_long xid;
-       int proc;
+int
+nfsrv_getcache(nd, slp, repp)
+       register struct nfsrv_descript *nd;
+       struct nfssvc_sock *slp;

        struct mbuf **repp;
 {
        register struct nfsrvcache *rp;
        struct mbuf **repp;
 {
        register struct nfsrvcache *rp;

-       register union  rhead *rh;
-       register u_long saddr;

        struct mbuf *mb;
        struct mbuf *mb;

+       struct sockaddr_in *saddr;

        caddr_t bpos;
        int ret;
 
        caddr_t bpos;
        int ret;
 

-       rh = &rhead[NFSRCHASH(xid)];
-       saddr = mtod(nam, struct sockaddr_in *)->sin_addr.s_addr;
+       /*
+        * Don't cache recent requests for reliable transport protocols.
+        * (Maybe we should for the case of a reconnect, but..)
+        */
+       if (!nd->nd_nam2)
+               return (RC_DOIT);

 loop:
 loop:

-       for (rp = rh->rh_chain[0]; rp != (struct nfsrvcache *)rh; rp = rp->rc_forw) {
-               if (xid == rp->rc_xid && saddr == rp->rc_saddr &&
-                   proc == rp->rc_proc) {
+       for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
+           rp = rp->rc_hash.le_next) {
+           if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
+               netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {

                        if ((rp->rc_flag & RC_LOCKED) != 0) {
                                rp->rc_flag |= RC_WANTED;
                        if ((rp->rc_flag & RC_LOCKED) != 0) {
                                rp->rc_flag |= RC_WANTED;

-                               sleep((caddr_t)rp, PZERO-1);
+                               (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);

                                goto loop;
                        }
                        rp->rc_flag |= RC_LOCKED;
                                goto loop;
                        }
                        rp->rc_flag |= RC_LOCKED;

-                       put_at_head(rp);
+                       /* If not at end of LRU chain, move it there */
+                       if (rp->rc_lru.tqe_next) {
+                               TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
+                               TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
+                       }

                        if (rp->rc_state == RC_UNUSED)
                                panic("nfsrv cache");
                        if (rp->rc_state == RC_UNUSED)
                                panic("nfsrv cache");

-                       if (rp->rc_state == RC_INPROG ||
-                          (time.tv_sec - rp->rc_timestamp) < RC_DELAY) {
+                       if (rp->rc_state == RC_INPROG) {

                                nfsstats.srvcache_inproghits++;
                                ret = RC_DROPIT;
                        } else if (rp->rc_flag & RC_REPSTATUS) {
                                nfsstats.srvcache_inproghits++;
                                ret = RC_DROPIT;
                        } else if (rp->rc_flag & RC_REPSTATUS) {

-                               nfsstats.srvcache_idemdonehits++;
-                               nfs_rephead(0, xid, rp->rc_status, repp, &mb,
-                                       &bpos);
-                               rp->rc_timestamp = time.tv_sec;
+                               nfsstats.srvcache_nonidemdonehits++;
+                               nfs_rephead(0, nd, slp, rp->rc_status,
+                                  0, (u_quad_t *)0, repp, &mb, &bpos);

                                ret = RC_REPLY;
                        } else if (rp->rc_flag & RC_REPMBUF) {
                                ret = RC_REPLY;
                        } else if (rp->rc_flag & RC_REPMBUF) {

-                               nfsstats.srvcache_idemdonehits++;
-                               *repp = NFSMCOPY(rp->rc_reply, 0, M_COPYALL,
+                               nfsstats.srvcache_nonidemdonehits++;
+                               *repp = m_copym(rp->rc_reply, 0, M_COPYALL,

                                                M_WAIT);
                                                M_WAIT);

-                               rp->rc_timestamp = time.tv_sec;

                                ret = RC_REPLY;
                        } else {
                                ret = RC_REPLY;
                        } else {

-                               nfsstats.srvcache_nonidemdonehits++;
+                               nfsstats.srvcache_idemdonehits++;

                                rp->rc_state = RC_INPROG;
                                ret = RC_DOIT;
                        }
                                rp->rc_state = RC_INPROG;
                                ret = RC_DOIT;
                        }


@@ -198,63 +221,90 @@ loop:
                }
        }
        nfsstats.srvcache_misses++;
                }
        }
        nfsstats.srvcache_misses++;

-       rp = nfsrvcachehead.rc_prev;
-       while ((rp->rc_flag & RC_LOCKED) != 0) {
-               rp->rc_flag |= RC_WANTED;
-               sleep((caddr_t)rp, PZERO-1);
+       if (numnfsrvcache < desirednfsrvcache) {
+               rp = (struct nfsrvcache *)malloc((u_long)sizeof *rp,
+                   M_NFSD, M_WAITOK);
+               bzero((char *)rp, sizeof *rp);
+               numnfsrvcache++;
+               rp->rc_flag = RC_LOCKED;
+       } else {
+               rp = nfsrvlruhead.tqh_first;
+               while ((rp->rc_flag & RC_LOCKED) != 0) {
+                       rp->rc_flag |= RC_WANTED;
+                       (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
+                       rp = nfsrvlruhead.tqh_first;
+               }
+               rp->rc_flag |= RC_LOCKED;
+               LIST_REMOVE(rp, rc_hash);
+               TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
+               if (rp->rc_flag & RC_REPMBUF)
+                       m_freem(rp->rc_reply);
+               if (rp->rc_flag & RC_NAM)
+                       MFREE(rp->rc_nam, mb);
+               rp->rc_flag &= (RC_LOCKED | RC_WANTED);

        }
        }

-       remque(rp);
-       put_at_head(rp);
-       if (rp->rc_flag & RC_REPMBUF)
-               mb = rp->rc_reply;
-       else
-               mb = (struct mbuf *)0;
-       rp->rc_flag = 0;
+       TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);

        rp->rc_state = RC_INPROG;
        rp->rc_state = RC_INPROG;

-       rp->rc_xid = xid;
-       rp->rc_saddr = saddr;
-       rp->rc_proc = proc;
-       insque(rp, rh);
-       if (mb)
-               m_freem(mb);
+       rp->rc_xid = nd->nd_retxid;
+       saddr = mtod(nd->nd_nam, struct sockaddr_in *);
+       switch (saddr->sin_family) {
+       case AF_INET:
+               rp->rc_flag |= RC_INETADDR;
+               rp->rc_inetaddr = saddr->sin_addr.s_addr;
+               break;
+       case AF_ISO:
+       default:
+               rp->rc_flag |= RC_NAM;
+               rp->rc_nam = m_copym(nd->nd_nam, 0, M_COPYALL, M_WAIT);
+               break;
+       };
+       rp->rc_proc = nd->nd_procnum;
+       LIST_INSERT_HEAD(NFSRCHASH(nd->nd_retxid), rp, rc_hash);
+       rp->rc_flag &= ~RC_LOCKED;
+       if (rp->rc_flag & RC_WANTED) {
+               rp->rc_flag &= ~RC_WANTED;
+               wakeup((caddr_t)rp);
+       }

        return (RC_DOIT);
 }
 
 /*
  * Update a request cache entry after the rpc has been done
  */
        return (RC_DOIT);
 }
 
 /*
  * Update a request cache entry after the rpc has been done
  */

-nfsrv_updatecache(nam, xid, proc, repstat, repmbuf)
-       struct mbuf *nam;
-       u_long xid;
-       int proc;
-       int repstat;
+void
+nfsrv_updatecache(nd, repvalid, repmbuf)
+       register struct nfsrv_descript *nd;
+       int repvalid;

        struct mbuf *repmbuf;
 {
        register struct nfsrvcache *rp;
        struct mbuf *repmbuf;
 {
        register struct nfsrvcache *rp;

-       register union  rhead *rh;
-       register u_long saddr;

 
 

-       rh = &rhead[NFSRCHASH(xid)];
-       saddr = mtod(nam, struct sockaddr_in *)->sin_addr.s_addr;
+       if (!nd->nd_nam2)
+               return;

 loop:
 loop:

-       for (rp = rh->rh_chain[0]; rp != (struct nfsrvcache *)rh; rp = rp->rc_forw) {
-               if (xid == rp->rc_xid && saddr == rp->rc_saddr &&
-                   proc == rp->rc_proc) {
+       for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
+           rp = rp->rc_hash.le_next) {
+           if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
+               netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {

                        if ((rp->rc_flag & RC_LOCKED) != 0) {
                                rp->rc_flag |= RC_WANTED;
                        if ((rp->rc_flag & RC_LOCKED) != 0) {
                                rp->rc_flag |= RC_WANTED;

-                               sleep((caddr_t)rp, PZERO-1);
+                               (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);

                                goto loop;
                        }
                        rp->rc_flag |= RC_LOCKED;
                        rp->rc_state = RC_DONE;
                                goto loop;
                        }
                        rp->rc_flag |= RC_LOCKED;
                        rp->rc_state = RC_DONE;

-                       rp->rc_timestamp = time.tv_sec;
-                       if (nonidempotent[proc]) {
-                               if (repliesstatus[proc]) {
-                                       rp->rc_status = repstat;
+                       /*
+                        * If we have a valid reply update status and save
+                        * the reply for non-idempotent rpc's.
+                        */
+                       if (repvalid && nonidempotent[nd->nd_procnum]) {
+                               if ((nd->nd_flag & ND_NFSV3) == 0 &&
+                                 nfsv2_repstat[nfsv2_procid[nd->nd_procnum]]) {
+                                       rp->rc_status = nd->nd_repstat;

                                        rp->rc_flag |= RC_REPSTATUS;
                                } else {
                                        rp->rc_flag |= RC_REPSTATUS;
                                } else {

-                                       rp->rc_reply = NFSMCOPY(repmbuf, 0,
-                                                       M_COPYALL, M_WAIT);
+                                       rp->rc_reply = m_copym(repmbuf,
+                                               0, M_COPYALL, M_WAIT);

                                        rp->rc_flag |= RC_REPMBUF;
                                }
                        }
                                        rp->rc_flag |= RC_REPMBUF;
                                }
                        }


@@ -267,3 +317,20 @@ loop:
                }
        }
 }
                }
        }
 }

+
+/*
+ * Clean out the cache. Called when the last nfsd terminates.
+ */
+void
+nfsrv_cleancache()
+{
+       register struct nfsrvcache *rp, *nextrp;
+
+       for (rp = nfsrvlruhead.tqh_first; rp != 0; rp = nextrp) {
+               nextrp = rp->rc_lru.tqe_next;
+               LIST_REMOVE(rp, rc_hash);
+               TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
+               free(rp, M_NFSD);
+       }
+       numnfsrvcache = 0;
+}