sys/net/hostcache.c

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