[apple/xnu.git] / bsd / nfs / nfs_srvcache.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. 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.
 *
 * 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.
 *
 * 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
 * FreeBSD-Id: nfs_srvcache.c,v 1.15 1997/10/12 20:25:46 phk Exp $
 */

#ifndef NFS_NOSERVER 
/*
 * 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>	/* for dup_sockaddr */

#include <netinet/in.h>
#if ISO
#include <netiso/iso.h>
#endif
#include <nfs/rpcv2.h>
#include <nfs/nfsproto.h>
#include <nfs/nfs.h>
#include <nfs/nfsrvcache.h>

extern struct nfsstats nfsstats;
extern int nfsv2_procid[NFS_NPROCS];
long numnfsrvcache;
static long desirednfsrvcache = 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	NETFAMILY(rp) \
		(((rp)->rc_flag & RC_INETADDR) ? AF_INET : AF_ISO)

/*
 * Static array that defines which nfs rpc's are nonidempotent
 */
static int nonidempotent[NFS_NPROCS] = {
	FALSE,
	FALSE,
	TRUE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	TRUE,
	TRUE,
	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! */
static int nfsv2_repstat[NFS_NPROCS] = {
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	FALSE,
	TRUE,
	TRUE,
	TRUE,
	TRUE,
	FALSE,
	TRUE,
	FALSE,
	FALSE,
};

/*
 * Initialize the server request cache list
 */
void
nfsrv_initcache()
{

	nfsrvhashtbl = hashinit(desirednfsrvcache, M_NFSD, &nfsrvhash);
	TAILQ_INIT(&nfsrvlruhead);
}

/*
 * Look for the request in the cache
 * If found then
 *    return action and optionally reply
 * else
 *    insert it in the cache
 *
 * The rules are as follows:
 * - if in progress, return DROP request
 * - if completed within DELAY of the current time, return DROP it
 * - if completed a longer time ago return REPLY if the reply was cached or
 *   return DOIT
 * Update/add new request at end of lru list
 */
int
nfsrv_getcache(nd, slp, repp)
	register struct nfsrv_descript *nd;
	struct nfssvc_sock *slp;
	struct mbuf **repp;
{
	register struct nfsrvcache *rp;
	struct mbuf *mb;
	struct sockaddr_in *saddr;
	caddr_t bpos;
	int ret;

	/*
	 * 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:
	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)) {
		        NFS_DPF(RC, ("H%03x", rp->rc_xid & 0xfff));
			if ((rp->rc_flag & RC_LOCKED) != 0) {
				rp->rc_flag |= RC_WANTED;
				(void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
				goto loop;
			}
			rp->rc_flag |= RC_LOCKED;
			/* 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_INPROG) {
				nfsstats.srvcache_inproghits++;
				ret = RC_DROPIT;
			} else if (rp->rc_flag & RC_REPSTATUS) {
				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) {
				nfsstats.srvcache_nonidemdonehits++;
				*repp = m_copym(rp->rc_reply, 0, M_COPYALL,
						M_WAIT);
				ret = RC_REPLY;
			} else {
				nfsstats.srvcache_idemdonehits++;
				rp->rc_state = RC_INPROG;
				ret = RC_DOIT;
			}
			rp->rc_flag &= ~RC_LOCKED;
			if (rp->rc_flag & RC_WANTED) {
				rp->rc_flag &= ~RC_WANTED;
				wakeup((caddr_t)rp);
			}
			return (ret);
		}
	}
	nfsstats.srvcache_misses++;
	NFS_DPF(RC, ("M%03x", nd->nd_retxid & 0xfff));
	if (numnfsrvcache < desirednfsrvcache) {
		MALLOC(rp, struct nfsrvcache *, 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);
	}
	TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
	rp->rc_state = RC_INPROG;
	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
 */
void
nfsrv_updatecache(nd, repvalid, repmbuf)
	register struct nfsrv_descript *nd;
	int repvalid;
	struct mbuf *repmbuf;
{
	register struct nfsrvcache *rp;

	if (!nd->nd_nam2)
		return;
loop:
	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)) {
			NFS_DPF(RC, ("U%03x", rp->rc_xid & 0xfff));
			if ((rp->rc_flag & RC_LOCKED) != 0) {
				rp->rc_flag |= RC_WANTED;
				(void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
				goto loop;
			}
			rp->rc_flag |= RC_LOCKED;
			rp->rc_state = RC_DONE;
			/*
			 * 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_reply = m_copym(repmbuf,
						0, M_COPYALL, M_WAIT);
					rp->rc_flag |= RC_REPMBUF;
				}
			}
			rp->rc_flag &= ~RC_LOCKED;
			if (rp->rc_flag & RC_WANTED) {
				rp->rc_flag &= ~RC_WANTED;
				wakeup((caddr_t)rp);
			}
			return;
		}
	}
	NFS_DPF(RC, ("L%03x", nd->nd_retxid & 0xfff));
}

/*
 * 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;
}

#endif /* NFS_NOSERVER */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
e5568f75 A	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
1c79356b	11	*
e5568f75 A	12	* This Original Code and all software distributed under the License are
e5568f75 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
e5568f75 A	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	23	/*
	24	* Copyright (c) 1989, 1993
	25	* The Regents of the University of California. All rights reserved.
	26	*
	27	* This code is derived from software contributed to Berkeley by
	28	* Rick Macklem at The University of Guelph.
	29	*
	30	* Redistribution and use in source and binary forms, with or without
	31	* modification, are permitted provided that the following conditions
	32	* are met:
	33	* 1. Redistributions of source code must retain the above copyright
	34	* notice, this list of conditions and the following disclaimer.
	35	* 2. Redistributions in binary form must reproduce the above copyright
	36	* notice, this list of conditions and the following disclaimer in the
	37	* documentation and/or other materials provided with the distribution.
	38	* 3. All advertising materials mentioning features or use of this software
	39	* must display the following acknowledgement:
	40	* This product includes software developed by the University of
	41	* California, Berkeley and its contributors.
	42	* 4. Neither the name of the University nor the names of its contributors
	43	* may be used to endorse or promote products derived from this software
	44	* without specific prior written permission.
	45	*
	46	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	47	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	48	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	49	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	50	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	51	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	52	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	53	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	54	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	55	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	56	* SUCH DAMAGE.
	57	*
	58	* @(#)nfs_srvcache.c 8.3 (Berkeley) 3/30/95
	59	* FreeBSD-Id: nfs_srvcache.c,v 1.15 1997/10/12 20:25:46 phk Exp $
	60	*/
	61
	62	#ifndef NFS_NOSERVER
	63	/*
	64	* Reference: Chet Juszczak, "Improving the Performance and Correctness
	65	* of an NFS Server", in Proc. Winter 1989 USENIX Conference,
	66	* pages 53-63. San Diego, February 1989.
	67	*/
	68	#include <sys/param.h>
	69	#include <sys/vnode.h>
	70	#include <sys/mount.h>
	71	#include <sys/kernel.h>
	72	#include <sys/systm.h>
	73	#include <sys/proc.h>
	74	#include <sys/mbuf.h>
	75	#include <sys/malloc.h>
	76	#include <sys/socket.h>
	77	#include <sys/socketvar.h> /* for dup_sockaddr */
	78
	79	#include <netinet/in.h>
	80	#if ISO
	81	#include <netiso/iso.h>
	82	#endif
83	#include <nfs/rpcv2.h>
84	#include <nfs/nfsproto.h>
85	#include <nfs/nfs.h>
86	#include <nfs/nfsrvcache.h>
87
88	extern struct nfsstats nfsstats;
89	extern int nfsv2_procid[NFS_NPROCS];
90	long numnfsrvcache;
91	static long desirednfsrvcache = NFSRVCACHESIZ;
92
93	#define NFSRCHASH(xid) \
94	(&nfsrvhashtbl[((xid) + ((xid) >> 24)) & nfsrvhash])
95	LIST_HEAD(nfsrvhash, nfsrvcache) *nfsrvhashtbl;
96	TAILQ_HEAD(nfsrvlru, nfsrvcache) nfsrvlruhead;
97	u_long nfsrvhash;
98
99	#define TRUE 1
100	#define FALSE 0
101
102	#define NETFAMILY(rp) \
103	(((rp)->rc_flag & RC_INETADDR) ? AF_INET : AF_ISO)
104
105	/*
106	* Static array that defines which nfs rpc's are nonidempotent
107	*/
108	static int nonidempotent[NFS_NPROCS] = {
109	FALSE,
110	FALSE,
111	TRUE,
112	FALSE,
113	FALSE,
114	FALSE,
115	FALSE,
116	TRUE,
117	TRUE,
118	TRUE,
119	TRUE,
120	TRUE,
121	TRUE,
122	TRUE,
123	TRUE,
124	TRUE,
125	FALSE,
126	FALSE,
127	FALSE,
128	FALSE,
129	FALSE,
130	FALSE,
131	FALSE,
132	FALSE,
133	FALSE,
134	FALSE,
135	};
136
137	/* True iff the rpc reply is an nfs status ONLY! */
138	static int nfsv2_repstat[NFS_NPROCS] = {
139	FALSE,
140	FALSE,
141	FALSE,
142	FALSE,
143	FALSE,
144	FALSE,
145	FALSE,
146	FALSE,
147	FALSE,
148	FALSE,
149	TRUE,
150	TRUE,
151	TRUE,
152	TRUE,
153	FALSE,
154	TRUE,
155	FALSE,
156	FALSE,
157	};
158
159	/*
160	* Initialize the server request cache list
161	*/
162	void
163	nfsrv_initcache()
164	{
165
166	nfsrvhashtbl = hashinit(desirednfsrvcache, M_NFSD, &nfsrvhash);
167	TAILQ_INIT(&nfsrvlruhead);
168	}
169
170	/*
171	* Look for the request in the cache
172	* If found then
173	* return action and optionally reply
174	* else
175	* insert it in the cache
176	*
177	* The rules are as follows:
178	* - if in progress, return DROP request
179	* - if completed within DELAY of the current time, return DROP it
180	* - if completed a longer time ago return REPLY if the reply was cached or
181	* return DOIT
182	* Update/add new request at end of lru list
183	*/
184	int
185	nfsrv_getcache(nd, slp, repp)
186	register struct nfsrv_descript *nd;
187	struct nfssvc_sock *slp;
188	struct mbuf **repp;
189	{
190	register struct nfsrvcache *rp;
191	struct mbuf *mb;
192	struct sockaddr_in *saddr;
193	caddr_t bpos;
194	int ret;
195
196	/*
197	* Don't cache recent requests for reliable transport protocols.
198	* (Maybe we should for the case of a reconnect, but..)
199	*/
200	if (!nd->nd_nam2)
201	return (RC_DOIT);
202	loop:
203	for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
204	rp = rp->rc_hash.le_next) {
205	if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
206	netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {
207	NFS_DPF(RC, ("H%03x", rp->rc_xid & 0xfff));
208	if ((rp->rc_flag & RC_LOCKED) != 0) {
209	rp->rc_flag \|= RC_WANTED;
210	(void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
211	goto loop;
212	}
213	rp->rc_flag \|= RC_LOCKED;
214	/* If not at end of LRU chain, move it there */
215	if (rp->rc_lru.tqe_next) {
216	TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
217	TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
218	}
219	if (rp->rc_state == RC_UNUSED)
220	panic("nfsrv cache");
221	if (rp->rc_state == RC_INPROG) {
222	nfsstats.srvcache_inproghits++;
223	ret = RC_DROPIT;
224	} else if (rp->rc_flag & RC_REPSTATUS) {
225	nfsstats.srvcache_nonidemdonehits++;
226	nfs_rephead(0, nd, slp, rp->rc_status,
227	0, (u_quad_t *)0, repp, &mb, &bpos);
228	ret = RC_REPLY;
229	} else if (rp->rc_flag & RC_REPMBUF) {
230	nfsstats.srvcache_nonidemdonehits++;
231	*repp = m_copym(rp->rc_reply, 0, M_COPYALL,
232	M_WAIT);
233	ret = RC_REPLY;
234	} else {
235	nfsstats.srvcache_idemdonehits++;
236	rp->rc_state = RC_INPROG;
237	ret = RC_DOIT;
238	}
239	rp->rc_flag &= ~RC_LOCKED;
240	if (rp->rc_flag & RC_WANTED) {
241	rp->rc_flag &= ~RC_WANTED;
242	wakeup((caddr_t)rp);
243	}
244	return (ret);
245	}
246	}
247	nfsstats.srvcache_misses++;
248	NFS_DPF(RC, ("M%03x", nd->nd_retxid & 0xfff));
249	if (numnfsrvcache < desirednfsrvcache) {
250	MALLOC(rp, struct nfsrvcache , sizeof rp, M_NFSD, M_WAITOK);
251	bzero((char )rp, sizeof rp);
252	numnfsrvcache++;
253	rp->rc_flag = RC_LOCKED;
254	} else {
255	rp = nfsrvlruhead.tqh_first;
256	while ((rp->rc_flag & RC_LOCKED) != 0) {
257	rp->rc_flag \|= RC_WANTED;
258	(void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
259	rp = nfsrvlruhead.tqh_first;
260	}
261	rp->rc_flag \|= RC_LOCKED;
262	LIST_REMOVE(rp, rc_hash);
263	TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
264	if (rp->rc_flag & RC_REPMBUF)
265	m_freem(rp->rc_reply);
266	if (rp->rc_flag & RC_NAM)
267	MFREE(rp->rc_nam, mb);
268	rp->rc_flag &= (RC_LOCKED \| RC_WANTED);
269	}
270	TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
271	rp->rc_state = RC_INPROG;
272	rp->rc_xid = nd->nd_retxid;
273	saddr = mtod(nd->nd_nam, struct sockaddr_in *);
274	switch (saddr->sin_family) {
275	case AF_INET:
276	rp->rc_flag \|= RC_INETADDR;
277	rp->rc_inetaddr = saddr->sin_addr.s_addr;
278	break;
279	case AF_ISO:
280	default:
281	rp->rc_flag \|= RC_NAM;
282	rp->rc_nam = m_copym(nd->nd_nam, 0, M_COPYALL, M_WAIT);
283	break;
284	};
285	rp->rc_proc = nd->nd_procnum;
286	LIST_INSERT_HEAD(NFSRCHASH(nd->nd_retxid), rp, rc_hash);
287	rp->rc_flag &= ~RC_LOCKED;
288	if (rp->rc_flag & RC_WANTED) {
289	rp->rc_flag &= ~RC_WANTED;
290	wakeup((caddr_t)rp);
291	}
292	return (RC_DOIT);
293	}
294
295	/*
296	* Update a request cache entry after the rpc has been done
297	*/
298	void
299	nfsrv_updatecache(nd, repvalid, repmbuf)
300	register struct nfsrv_descript *nd;
301	int repvalid;
302	struct mbuf *repmbuf;
303	{
304	register struct nfsrvcache *rp;
305
306	if (!nd->nd_nam2)
307	return;
308	loop:
309	for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
310	rp = rp->rc_hash.le_next) {
311	if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
312	netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {
313	NFS_DPF(RC, ("U%03x", rp->rc_xid & 0xfff));
314	if ((rp->rc_flag & RC_LOCKED) != 0) {
315	rp->rc_flag \|= RC_WANTED;
316	(void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
317	goto loop;
318	}
319	rp->rc_flag \|= RC_LOCKED;
320	rp->rc_state = RC_DONE;
321	/*
322	* If we have a valid reply update status and save
323	* the reply for non-idempotent rpc's.
324	*/
325	if (repvalid && nonidempotent[nd->nd_procnum]) {
326	if ((nd->nd_flag & ND_NFSV3) == 0 &&
327	nfsv2_repstat[nfsv2_procid[nd->nd_procnum]]) {
328	rp->rc_status = nd->nd_repstat;
329	rp->rc_flag \|= RC_REPSTATUS;
330	} else {
331	rp->rc_reply = m_copym(repmbuf,
332	0, M_COPYALL, M_WAIT);
333	rp->rc_flag \|= RC_REPMBUF;
334	}
335	}
336	rp->rc_flag &= ~RC_LOCKED;
337	if (rp->rc_flag & RC_WANTED) {
338	rp->rc_flag &= ~RC_WANTED;
339	wakeup((caddr_t)rp);
340	}
341	return;
342	}
343	}
344	NFS_DPF(RC, ("L%03x", nd->nd_retxid & 0xfff));
345	}
346
347	/*
348	* Clean out the cache. Called when the last nfsd terminates.
349	*/
350	void
351	nfsrv_cleancache()
352	{
353	register struct nfsrvcache rp, nextrp;
354
355	for (rp = nfsrvlruhead.tqh_first; rp != 0; rp = nextrp) {
356	nextrp = rp->rc_lru.tqe_next;
357	LIST_REMOVE(rp, rc_hash);
358	TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
359	_FREE(rp, M_NFSD);
360	}
361	numnfsrvcache = 0;
362	}
363
364	#endif /* NFS_NOSERVER */