ip_flow.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: ip_flow.c,v 1.27 2003/12/12 21:17:59 scw Exp $ */
    2 
    3 /*-
    4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by the 3am Software Foundry ("3am").  It was developed by Matt Thomas.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by the NetBSD
   21  *      Foundation, Inc. and its contributors.
   22  * 4. Neither the name of The NetBSD Foundation nor the names of its
   23  *    contributors may be used to endorse or promote products derived
   24  *    from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   36  * POSSIBILITY OF SUCH DAMAGE.
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __KERNEL_RCSID(0, "$NetBSD: ip_flow.c,v 1.27 2003/12/12 21:17:59 scw Exp $");
   41 
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/malloc.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/domain.h>
   47 #include <sys/protosw.h>
   48 #include <sys/socket.h>
   49 #include <sys/socketvar.h>
   50 #include <sys/errno.h>
   51 #include <sys/time.h>
   52 #include <sys/kernel.h>
   53 #include <sys/pool.h>
   54 #include <sys/sysctl.h>
   55 
   56 #include <net/if.h>
   57 #include <net/if_dl.h>
   58 #include <net/route.h>
   59 #include <net/pfil.h>
   60 
   61 #include <netinet/in.h>
   62 #include <netinet/in_systm.h>
   63 #include <netinet/ip.h>
   64 #include <netinet/in_pcb.h>
   65 #include <netinet/in_var.h>
   66 #include <netinet/ip_var.h>
   67 
   68 struct pool ipflow_pool;
   69 
   70 LIST_HEAD(ipflowhead, ipflow);
   71 
   72 #define IPFLOW_TIMER            (5 * PR_SLOWHZ)
   73 #define IPFLOW_HASHSIZE         (1 << IPFLOW_HASHBITS)
   74 
   75 static struct ipflowhead ipflowtable[IPFLOW_HASHSIZE];
   76 static struct ipflowhead ipflowlist;
   77 static int ipflow_inuse;
   78 
   79 #define IPFLOW_INSERT(bucket, ipf) \
   80 do { \
   81         LIST_INSERT_HEAD((bucket), (ipf), ipf_hash); \
   82         LIST_INSERT_HEAD(&ipflowlist, (ipf), ipf_list); \
   83 } while (/*CONSTCOND*/ 0)
   84 
   85 #define IPFLOW_REMOVE(ipf) \
   86 do { \
   87         LIST_REMOVE((ipf), ipf_hash); \
   88         LIST_REMOVE((ipf), ipf_list); \
   89 } while (/*CONSTCOND*/ 0)
   90 
   91 #ifndef IPFLOW_MAX
   92 #define IPFLOW_MAX              256
   93 #endif
   94 int ip_maxflows = IPFLOW_MAX;
   95 
   96 static unsigned
   97 ipflow_hash(
   98         struct in_addr dst,
   99         struct in_addr src,
  100         unsigned tos)
  101 {
  102         unsigned hash = tos;
  103         int idx;
  104         for (idx = 0; idx < 32; idx += IPFLOW_HASHBITS)
  105                 hash += (dst.s_addr >> (32 - idx)) + (src.s_addr >> idx);
  106         return hash & (IPFLOW_HASHSIZE-1);
  107 }
  108 
  109 static struct ipflow *
  110 ipflow_lookup(
  111         const struct ip *ip)
  112 {
  113         unsigned hash;
  114         struct ipflow *ipf;
  115 
  116         hash = ipflow_hash(ip->ip_dst, ip->ip_src, ip->ip_tos);
  117 
  118         ipf = LIST_FIRST(&ipflowtable[hash]);
  119         while (ipf != NULL) {
  120                 if (ip->ip_dst.s_addr == ipf->ipf_dst.s_addr
  121                     && ip->ip_src.s_addr == ipf->ipf_src.s_addr
  122                     && ip->ip_tos == ipf->ipf_tos)
  123                         break;
  124                 ipf = LIST_NEXT(ipf, ipf_hash);
  125         }
  126         return ipf;
  127 }
  128 
  129 void
  130 ipflow_init()
  131 {
  132         int i;
  133 
  134         pool_init(&ipflow_pool, sizeof(struct ipflow), 0, 0, 0, "ipflowpl",
  135             NULL);
  136 
  137         LIST_INIT(&ipflowlist);
  138         for (i = 0; i < IPFLOW_HASHSIZE; i++)
  139                 LIST_INIT(&ipflowtable[i]);
  140 }
  141 
  142 int
  143 ipflow_fastforward(
  144         struct mbuf *m)
  145 {
  146         struct ip *ip, ip_store;
  147         struct ipflow *ipf;
  148         struct rtentry *rt;
  149         struct sockaddr *dst;
  150         int error;
  151         int iplen;
  152 
  153         /*
  154          * Are we forwarding packets?  Big enough for an IP packet?
  155          */
  156         if (!ipforwarding || ipflow_inuse == 0 || m->m_len < sizeof(struct ip))
  157                 return 0;
  158 
  159         /*
  160          * Was packet received as a link-level multicast or broadcast?
  161          * If so, don't try to fast forward..
  162          */
  163         if ((m->m_flags & (M_BCAST|M_MCAST)) != 0)
  164                 return 0;
  165 
  166         /*
  167          * IP header with no option and valid version and length
  168          */
  169         if (IP_HDR_ALIGNED_P(mtod(m, caddr_t)))
  170                 ip = mtod(m, struct ip *);
  171         else {
  172                 memcpy(&ip_store, mtod(m, caddr_t), sizeof(ip_store));
  173                 ip = &ip_store;
  174         }
  175         iplen = ntohs(ip->ip_len);
  176         if (ip->ip_v != IPVERSION || ip->ip_hl != (sizeof(struct ip) >> 2) ||
  177             iplen < sizeof(struct ip) || iplen > m->m_pkthdr.len)
  178                 return 0;
  179         /*
  180          * Find a flow.
  181          */
  182         if ((ipf = ipflow_lookup(ip)) == NULL)
  183                 return 0;
  184 
  185         /*
  186          * Verify the IP header checksum.
  187          */
  188         switch (m->m_pkthdr.csum_flags &
  189                 ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_IPv4) |
  190                  M_CSUM_IPv4_BAD)) {
  191         case M_CSUM_IPv4|M_CSUM_IPv4_BAD:
  192                 return (0);
  193 
  194         case M_CSUM_IPv4:
  195                 /* Checksum was okay. */
  196                 break;
  197 
  198         default:
  199                 /* Must compute it ourselves. */
  200                 if (in_cksum(m, sizeof(struct ip)) != 0)
  201                         return (0);
  202                 break;
  203         }
  204 
  205         /*
  206          * Route and interface still up?
  207          */
  208         rt = ipf->ipf_ro.ro_rt;
  209         if ((rt->rt_flags & RTF_UP) == 0 ||
  210             (rt->rt_ifp->if_flags & IFF_UP) == 0)
  211                 return 0;
  212 
  213         /*
  214          * Packet size OK?  TTL?
  215          */
  216         if (m->m_pkthdr.len > rt->rt_ifp->if_mtu || ip->ip_ttl <= IPTTLDEC)
  217                 return 0;
  218 
  219         /*
  220          * Clear any in-bound checksum flags for this packet.
  221          */
  222         m->m_pkthdr.csum_flags = 0;
  223 
  224         /*
  225          * Everything checks out and so we can forward this packet.
  226          * Modify the TTL and incrementally change the checksum.
  227          *
  228          * This method of adding the checksum works on either endian CPU.
  229          * If htons() is inlined, all the arithmetic is folded; otherwise
  230          * the htons()s are combined by CSE due to the __const__ attribute.
  231          *
  232          * Don't bother using HW checksumming here -- the incremental
  233          * update is pretty fast.
  234          */
  235         ip->ip_ttl -= IPTTLDEC;
  236         if (ip->ip_sum >= (u_int16_t) ~htons(IPTTLDEC << 8))
  237                 ip->ip_sum -= ~htons(IPTTLDEC << 8);
  238         else
  239                 ip->ip_sum += htons(IPTTLDEC << 8);
  240 
  241         /*
  242          * Done modifying the header; copy it back, if necessary.
  243          */
  244         if (IP_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0)
  245                 memcpy(mtod(m, caddr_t), &ip_store, sizeof(ip_store));
  246 
  247         /*
  248          * Trim the packet in case it's too long..
  249          */
  250         if (m->m_pkthdr.len > iplen) {
  251                 if (m->m_len == m->m_pkthdr.len) {
  252                         m->m_len = iplen;
  253                         m->m_pkthdr.len = iplen;
  254                 } else
  255                         m_adj(m, iplen - m->m_pkthdr.len);
  256         }
  257 
  258         /*
  259          * Send the packet on it's way.  All we can get back is ENOBUFS
  260          */
  261         ipf->ipf_uses++;
  262         PRT_SLOW_ARM(ipf->ipf_timer, IPFLOW_TIMER);
  263 
  264         if (rt->rt_flags & RTF_GATEWAY)
  265                 dst = rt->rt_gateway;
  266         else
  267                 dst = &ipf->ipf_ro.ro_dst;
  268 
  269         if ((error = (*rt->rt_ifp->if_output)(rt->rt_ifp, m, dst, rt)) != 0) {
  270                 if (error == ENOBUFS)
  271                         ipf->ipf_dropped++;
  272                 else
  273                         ipf->ipf_errors++;
  274         }
  275         return 1;
  276 }
  277 
  278 static void
  279 ipflow_addstats(
  280         struct ipflow *ipf)
  281 {
  282         ipf->ipf_ro.ro_rt->rt_use += ipf->ipf_uses;
  283         ipstat.ips_cantforward += ipf->ipf_errors + ipf->ipf_dropped;
  284         ipstat.ips_forward += ipf->ipf_uses;
  285         ipstat.ips_fastforward += ipf->ipf_uses;
  286 }
  287 
  288 static void
  289 ipflow_free(
  290         struct ipflow *ipf)
  291 {
  292         int s;
  293         /*
  294          * Remove the flow from the hash table (at elevated IPL).
  295          * Once it's off the list, we can deal with it at normal
  296          * network IPL.
  297          */
  298         s = splnet();
  299         IPFLOW_REMOVE(ipf);
  300         splx(s);
  301         ipflow_addstats(ipf);
  302         RTFREE(ipf->ipf_ro.ro_rt);
  303         ipflow_inuse--;
  304         pool_put(&ipflow_pool, ipf);
  305 }
  306 
  307 struct ipflow *
  308 ipflow_reap(
  309         int just_one)
  310 {
  311         while (just_one || ipflow_inuse > ip_maxflows) {
  312                 struct ipflow *ipf, *maybe_ipf = NULL;
  313                 int s;
  314 
  315                 ipf = LIST_FIRST(&ipflowlist);
  316                 while (ipf != NULL) {
  317                         /*
  318                          * If this no longer points to a valid route
  319                          * reclaim it.
  320                          */
  321                         if ((ipf->ipf_ro.ro_rt->rt_flags & RTF_UP) == 0)
  322                                 goto done;
  323                         /*
  324                          * choose the one that's been least recently
  325                          * used or has had the least uses in the
  326                          * last 1.5 intervals.
  327                          */
  328                         if (maybe_ipf == NULL ||
  329                             ipf->ipf_timer < maybe_ipf->ipf_timer ||
  330                             (ipf->ipf_timer == maybe_ipf->ipf_timer &&
  331                              ipf->ipf_last_uses + ipf->ipf_uses <
  332                                  maybe_ipf->ipf_last_uses +
  333                                  maybe_ipf->ipf_uses))
  334                                 maybe_ipf = ipf;
  335                         ipf = LIST_NEXT(ipf, ipf_list);
  336                 }
  337                 ipf = maybe_ipf;
  338             done:
  339                 /*
  340                  * Remove the entry from the flow table.
  341                  */
  342                 s = splnet();
  343                 IPFLOW_REMOVE(ipf);
  344                 splx(s);
  345                 ipflow_addstats(ipf);
  346                 RTFREE(ipf->ipf_ro.ro_rt);
  347                 if (just_one)
  348                         return ipf;
  349                 pool_put(&ipflow_pool, ipf);
  350                 ipflow_inuse--;
  351         }
  352         return NULL;
  353 }
  354 
  355 void
  356 ipflow_slowtimo(
  357         void)
  358 {
  359         struct ipflow *ipf, *next_ipf;
  360 
  361         ipf = LIST_FIRST(&ipflowlist);
  362         while (ipf != NULL) {
  363                 next_ipf = LIST_NEXT(ipf, ipf_list);
  364                 if (PRT_SLOW_ISEXPIRED(ipf->ipf_timer)) {
  365                         ipflow_free(ipf);
  366                 } else {
  367                         ipf->ipf_last_uses = ipf->ipf_uses;
  368                         ipf->ipf_ro.ro_rt->rt_use += ipf->ipf_uses;
  369                         ipstat.ips_forward += ipf->ipf_uses;
  370                         ipstat.ips_fastforward += ipf->ipf_uses;
  371                         ipf->ipf_uses = 0;
  372                 }
  373                 ipf = next_ipf;
  374         }
  375 }
  376 
  377 void
  378 ipflow_create(
  379         const struct route *ro,
  380         struct mbuf *m)
  381 {
  382         const struct ip *const ip = mtod(m, struct ip *);
  383         struct ipflow *ipf;
  384         unsigned hash;
  385         int s;
  386 
  387         /*
  388          * Don't create cache entries for ICMP messages.
  389          */
  390         if (ip_maxflows == 0 || ip->ip_p == IPPROTO_ICMP)
  391                 return;
  392         /*
  393          * See if an existing flow struct exists.  If so remove it from it's
  394          * list and free the old route.  If not, try to malloc a new one
  395          * (if we aren't at our limit).
  396          */
  397         ipf = ipflow_lookup(ip);
  398         if (ipf == NULL) {
  399                 if (ipflow_inuse >= ip_maxflows) {
  400                         ipf = ipflow_reap(1);
  401                 } else {
  402                         ipf = pool_get(&ipflow_pool, PR_NOWAIT);
  403                         if (ipf == NULL)
  404                                 return;
  405                         ipflow_inuse++;
  406                 }
  407                 bzero((caddr_t) ipf, sizeof(*ipf));
  408         } else {
  409                 s = splnet();
  410                 IPFLOW_REMOVE(ipf);
  411                 splx(s);
  412                 ipflow_addstats(ipf);
  413                 RTFREE(ipf->ipf_ro.ro_rt);
  414                 ipf->ipf_uses = ipf->ipf_last_uses = 0;
  415                 ipf->ipf_errors = ipf->ipf_dropped = 0;
  416         }
  417 
  418         /*
  419          * Fill in the updated information.
  420          */
  421         ipf->ipf_ro = *ro;
  422         ro->ro_rt->rt_refcnt++;
  423         ipf->ipf_dst = ip->ip_dst;
  424         ipf->ipf_src = ip->ip_src;
  425         ipf->ipf_tos = ip->ip_tos;
  426         PRT_SLOW_ARM(ipf->ipf_timer, IPFLOW_TIMER);
  427         ipf->ipf_start = time.tv_sec;
  428         /*
  429          * Insert into the approriate bucket of the flow table.
  430          */
  431         hash = ipflow_hash(ip->ip_dst, ip->ip_src, ip->ip_tos);
  432         s = splnet();
  433         IPFLOW_INSERT(&ipflowtable[hash], ipf);
  434         splx(s);
  435 }
  436 
  437 void
  438 ipflow_invalidate_all(
  439         void)
  440 {
  441         struct ipflow *ipf, *next_ipf;
  442         int s;
  443 
  444         s = splnet();
  445         ipf = LIST_FIRST(&ipflowlist);
  446         for (ipf = LIST_FIRST(&ipflowlist); ipf != NULL; ipf = next_ipf) {
  447                 next_ipf = LIST_NEXT(ipf, ipf_list);
  448                 ipflow_free(ipf);
  449         }
  450         splx(s);
  451 }
Cache object: ab67847d229b90c178f4a47e77998911
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netinet/ip_flow.c

FreeBSD/Linux Kernel Cross Reference
sys/netinet/ip_flow.c
