![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hostcache.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to hostcache.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.