[apple/xnu.git] / bsd / net / hostcache.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 1997 Massachusetts Institute of Technology
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that both the above copyright notice and this
 * permission notice appear in all copies, that both the above
 * copyright notice and this permission notice appear in all
 * supporting documentation, and that the name of M.I.T. not be used
 * in advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.  M.I.T. makes
 * no representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied
 * warranty.
 * 
 * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
 * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
 * SHALL M.I.T. 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.
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/socket.h>

#include <net/hostcache.h>
#include <net/route.h>

MALLOC_DEFINE(M_HOSTCACHE, "hostcache", "per-host cache structure");

static	struct hctable hctable[AF_MAX];
static	int hc_timeout_interval = 120;
static	int hc_maxidle = 1800;

static	int cmpsa(const struct sockaddr *sa1, const struct sockaddr *sa2);
static	void hc_timeout(void *xhct);
static	void maybe_bump_hash(struct hctable *hct);

int
hc_init(int af, struct hccallback *hccb, int init_nelem, int primes)
{
	struct hctable *hct;
	struct hchead *heads;
	u_long nelem;

	hct = &hctable[af];
	nelem = init_nelem;
	if (hct->hct_nentries)
		return 0;

	if (primes) {
		heads = phashinit(init_nelem, M_HOSTCACHE, &nelem);
	} else {
		int i;
		MALLOC(heads, struct hchead *, nelem * sizeof *heads,
		       M_HOSTCACHE, M_WAITOK);
		for (i = 0; i < nelem; i++) {
			LIST_INIT(&heads[i]);
		}
	}
	
	hct->hct_heads = heads;
	hct->hct_nentries = nelem;
	hct->hct_primes = primes;
	timeout(hc_timeout, hct, hc_timeout_interval * hz);
	return 0;
}

struct hcentry *
hc_get(struct sockaddr *sa)
{
	u_long hash;
	struct hcentry *hc;
	struct hctable *hct;
	int s;

	hct = &hctable[sa->sa_family];
	if (hct->hct_nentries == 0)
		return 0;
	hash = hct->hct_cb->hccb_hash(sa, hct->hct_nentries);
	hc = hct->hct_heads[hash].lh_first;
	for (; hc; hc = hc->hc_link.le_next) {
		if (cmpsa(hc->hc_host, sa) == 0)
			break;
	}
	if (hc == 0)
		return 0;
	s = splnet();
	if (hc->hc_rt && (hc->hc_rt->rt_flags & RTF_UP) == 0) {
		RTFREE(hc->hc_rt);
		hc->hc_rt = 0;
	}
	if (hc->hc_rt == 0) {
		hc->hc_rt = rtalloc1(hc->hc_host, 1, 0);
	}
	hc_ref(hc);
	splx(s);
	/* XXX move to front of list? */
	return hc;
}

void
hc_ref(struct hcentry *hc)
{
	int s = splnet();
	if (hc->hc_refcnt++ == 0) {
		hc->hc_hct->hct_idle--;
		hc->hc_hct->hct_active++;
	}
	splx(s);
}

void
hc_rele(struct hcentry *hc)
{
	int s = splnet();
#ifdef DIAGNOSTIC
	printf("hc_rele: %p: negative refcnt!\n", (void *)hc);
#endif
	hc->hc_refcnt--;
	if (hc->hc_refcnt == 0) {
		hc->hc_hct->hct_idle++;
		hc->hc_hct->hct_active--;
		hc->hc_idlesince = mono_time; /* XXX right one? */
	}
	splx(s);
}

/*
 * The user is expected to initialize hc_host with the address and everything
 * else to the appropriate form of `0'.
 */
int
hc_insert(struct hcentry *hc)
{
	struct hcentry *hc2;
	struct hctable *hct;
	u_long hash;
	int s;

	hct = &hctable[hc->hc_host->sa_family];
	hash = hct->hct_cb->hccb_hash(hc->hc_host, hct->hct_nentries);
	
	hc2 = hct->hct_heads[hash].lh_first;
	for (; hc2; hc2 = hc2->hc_link.le_next) {
		if (cmpsa(hc2->hc_host, hc->hc_host) == 0)
			break;
	}
	if (hc2 != 0)
		return EEXIST;
	hc->hc_hct = hct;
	s = splnet();
	LIST_INSERT_HEAD(&hct->hct_heads[hash], hc, hc_link);
	hct->hct_idle++;
	/*
	 * If the table is now more than 75% full, consider bumping it.
	 */
	if (100 * (hct->hct_idle + hct->hct_active) > 75 * hct->hct_nentries)
		maybe_bump_hash(hct);
	splx(s);
	return 0;
}

/*
 * It's not clear to me how much sense this makes as an external interface,
 * since it is expected that the deletion will normally be handled by
 * the cache timeout.
 */
int
hc_delete(struct hcentry *hc)
{
	struct hctable *hct;
	int error, s;

	if (hc->hc_refcnt > 0)
		return 0;

	hct = hc->hc_hct;
	error = hct->hct_cb->hccb_delete(hc);
	if (error)
		return 0;

	s = splnet();
	LIST_REMOVE(hc, hc_link);
	hc->hc_hct->hct_idle--;
	splx(s);
	FREE(hc, M_HOSTCACHE);
	return 0;
}

static void
hc_timeout(void *xhct)
{
	struct hcentry *hc;
	struct hctable *hct;
	int j, s;
	time_t start;

	hct = xhct;
	start = mono_time.tv_sec; /* for simplicity */

	if (hct->hct_idle == 0)
		return;
	for (j = 0; j < hct->hct_nentries; j++) {
		for (hc = hct->hct_heads[j].lh_first; hc; 
		     hc = hc->hc_link.le_next) {
			if (hc->hc_refcnt > 0)
				continue;
			if (hc->hc_idlesince.tv_sec + hc_maxidle <= start) {
				if (hct->hct_cb->hccb_delete(hc))
					continue;
				s = splnet();
				LIST_REMOVE(hc, hc_link);
				hct->hct_idle--;
				splx(s);
			}
		}
	}
	/*
	 * Fiddle something here based on tot_idle...
	 */
	timeout(hc_timeout, xhct, hc_timeout_interval * hz);
}

static int
cmpsa(const struct sockaddr *sa1, const struct sockaddr *sa2)
{
	if (sa1->sa_len != sa2->sa_len)
		return ((int)sa1->sa_len - sa2->sa_len);
	return bcmp(sa1, sa2, sa1->sa_len);
}

static void
maybe_bump_hash(struct hctable *hct)
{
	;			/* XXX fill me in */
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	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.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	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.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright 1997 Massachusetts Institute of Technology
	24	*
	25	* Permission to use, copy, modify, and distribute this software and
	26	* its documentation for any purpose and without fee is hereby
	27	* granted, provided that both the above copyright notice and this
	28	* permission notice appear in all copies, that both the above
	29	* copyright notice and this permission notice appear in all
	30	* supporting documentation, and that the name of M.I.T. not be used
	31	* in advertising or publicity pertaining to distribution of the
	32	* software without specific, written prior permission. M.I.T. makes
	33	* no representations about the suitability of this software for any
	34	* purpose. It is provided "as is" without express or implied
	35	* warranty.
	36	*
	37	* THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
	38	* ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
	39	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	40	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
	41	* SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	42	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	43	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	44	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	45	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	46	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	47	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	48	* SUCH DAMAGE.
	49	*
	50	*/
	51
	52	#include <sys/param.h>
	53	#include <sys/systm.h>
	54	#include <sys/kernel.h>
	55	#include <sys/malloc.h>
	56	#include <sys/socket.h>
	57
	58	#include <net/hostcache.h>
	59	#include <net/route.h>
	60
	61	MALLOC_DEFINE(M_HOSTCACHE, "hostcache", "per-host cache structure");
	62
	63	static struct hctable hctable[AF_MAX];
	64	static int hc_timeout_interval = 120;
65	static int hc_maxidle = 1800;
66
67	static int cmpsa(const struct sockaddr sa1, const struct sockaddr sa2);
68	static void hc_timeout(void *xhct);
69	static void maybe_bump_hash(struct hctable *hct);
70
71	int
72	hc_init(int af, struct hccallback *hccb, int init_nelem, int primes)
73	{
74	struct hctable *hct;
75	struct hchead *heads;
76	u_long nelem;
77
78	hct = &hctable[af];
79	nelem = init_nelem;
80	if (hct->hct_nentries)
81	return 0;
82
83	if (primes) {
84	heads = phashinit(init_nelem, M_HOSTCACHE, &nelem);
85	} else {
86	int i;
87	MALLOC(heads, struct hchead , nelem sizeof *heads,
88	M_HOSTCACHE, M_WAITOK);
89	for (i = 0; i < nelem; i++) {
90	LIST_INIT(&heads[i]);
91	}
92	}
93
94	hct->hct_heads = heads;
95	hct->hct_nentries = nelem;
96	hct->hct_primes = primes;
97	timeout(hc_timeout, hct, hc_timeout_interval * hz);
98	return 0;
99	}
100
101	struct hcentry *
102	hc_get(struct sockaddr *sa)
103	{
104	u_long hash;
105	struct hcentry *hc;
106	struct hctable *hct;
107	int s;
108
109	hct = &hctable[sa->sa_family];
110	if (hct->hct_nentries == 0)
111	return 0;
112	hash = hct->hct_cb->hccb_hash(sa, hct->hct_nentries);
113	hc = hct->hct_heads[hash].lh_first;
114	for (; hc; hc = hc->hc_link.le_next) {
115	if (cmpsa(hc->hc_host, sa) == 0)
116	break;
117	}
118	if (hc == 0)
119	return 0;
120	s = splnet();
121	if (hc->hc_rt && (hc->hc_rt->rt_flags & RTF_UP) == 0) {
122	RTFREE(hc->hc_rt);
123	hc->hc_rt = 0;
124	}
125	if (hc->hc_rt == 0) {
126	hc->hc_rt = rtalloc1(hc->hc_host, 1, 0);
127	}
128	hc_ref(hc);
129	splx(s);
130	/* XXX move to front of list? */
131	return hc;
132	}
133
134	void
135	hc_ref(struct hcentry *hc)
136	{
137	int s = splnet();
138	if (hc->hc_refcnt++ == 0) {
139	hc->hc_hct->hct_idle--;
140	hc->hc_hct->hct_active++;
141	}
142	splx(s);
143	}
144
145	void
146	hc_rele(struct hcentry *hc)
147	{
148	int s = splnet();
149	#ifdef DIAGNOSTIC
150	printf("hc_rele: %p: negative refcnt!\n", (void *)hc);
151	#endif
152	hc->hc_refcnt--;
153	if (hc->hc_refcnt == 0) {
154	hc->hc_hct->hct_idle++;
155	hc->hc_hct->hct_active--;
156	hc->hc_idlesince = mono_time; /* XXX right one? */
157	}
158	splx(s);
159	}
160
161	/*
162	* The user is expected to initialize hc_host with the address and everything
163	* else to the appropriate form of `0'.
164	*/
165	int
166	hc_insert(struct hcentry *hc)
167	{
168	struct hcentry *hc2;
169	struct hctable *hct;
170	u_long hash;
171	int s;
172
173	hct = &hctable[hc->hc_host->sa_family];
174	hash = hct->hct_cb->hccb_hash(hc->hc_host, hct->hct_nentries);
175
176	hc2 = hct->hct_heads[hash].lh_first;
177	for (; hc2; hc2 = hc2->hc_link.le_next) {
178	if (cmpsa(hc2->hc_host, hc->hc_host) == 0)
179	break;
180	}
181	if (hc2 != 0)
182	return EEXIST;
183	hc->hc_hct = hct;
184	s = splnet();
185	LIST_INSERT_HEAD(&hct->hct_heads[hash], hc, hc_link);
186	hct->hct_idle++;
187	/*
188	* If the table is now more than 75% full, consider bumping it.
189	*/
190	if (100 * (hct->hct_idle + hct->hct_active) > 75 * hct->hct_nentries)
191	maybe_bump_hash(hct);
192	splx(s);
193	return 0;
194	}
195
196	/*
197	* It's not clear to me how much sense this makes as an external interface,
198	* since it is expected that the deletion will normally be handled by
199	* the cache timeout.
200	*/
201	int
202	hc_delete(struct hcentry *hc)
203	{
204	struct hctable *hct;
205	int error, s;
206
207	if (hc->hc_refcnt > 0)
208	return 0;
209
210	hct = hc->hc_hct;
211	error = hct->hct_cb->hccb_delete(hc);
212	if (error)
213	return 0;
214
215	s = splnet();
216	LIST_REMOVE(hc, hc_link);
217	hc->hc_hct->hct_idle--;
218	splx(s);
219	FREE(hc, M_HOSTCACHE);
220	return 0;
221	}
222
223	static void
224	hc_timeout(void *xhct)
225	{
226	struct hcentry *hc;
227	struct hctable *hct;
228	int j, s;
229	time_t start;
230
231	hct = xhct;
232	start = mono_time.tv_sec; /* for simplicity */
233
234	if (hct->hct_idle == 0)
235	return;
236	for (j = 0; j < hct->hct_nentries; j++) {
237	for (hc = hct->hct_heads[j].lh_first; hc;
238	hc = hc->hc_link.le_next) {
239	if (hc->hc_refcnt > 0)
240	continue;
241	if (hc->hc_idlesince.tv_sec + hc_maxidle <= start) {
242	if (hct->hct_cb->hccb_delete(hc))
243	continue;
244	s = splnet();
245	LIST_REMOVE(hc, hc_link);
246	hct->hct_idle--;
247	splx(s);
248	}
249	}
250	}
251	/*
252	* Fiddle something here based on tot_idle...
253	*/
254	timeout(hc_timeout, xhct, hc_timeout_interval * hz);
255	}
256
257	static int
258	cmpsa(const struct sockaddr sa1, const struct sockaddr sa2)
259	{
260	if (sa1->sa_len != sa2->sa_len)
261	return ((int)sa1->sa_len - sa2->sa_len);
262	return bcmp(sa1, sa2, sa1->sa_len);
263	}
264
265	static void
266	maybe_bump_hash(struct hctable *hct)
267	{
268	; /* XXX fill me in */
269	}