The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet6/in6_rmx.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 /*      $FreeBSD$       */
    2 /*      $KAME: in6_rmx.c,v 1.11 2001/07/26 06:53:16 jinmei Exp $        */
    3 
    4 /*
    5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the project nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   32 
   33 /*
   34  * Copyright 1994, 1995 Massachusetts Institute of Technology
   35  *
   36  * Permission to use, copy, modify, and distribute this software and
   37  * its documentation for any purpose and without fee is hereby
   38  * granted, provided that both the above copyright notice and this
   39  * permission notice appear in all copies, that both the above
   40  * copyright notice and this permission notice appear in all
   41  * supporting documentation, and that the name of M.I.T. not be used
   42  * in advertising or publicity pertaining to distribution of the
   43  * software without specific, written prior permission.  M.I.T. makes
   44  * no representations about the suitability of this software for any
   45  * purpose.  It is provided "as is" without express or implied
   46  * warranty.
   47  *
   48  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
   49  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
   50  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   51  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
   52  * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   53  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   54  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   55  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   56  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   57  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   58  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   59  * SUCH DAMAGE.
   60  *
   61  */
   62 
   63 /*
   64  * This code does two things necessary for the enhanced TCP metrics to
   65  * function in a useful manner:
   66  *  1) It marks all non-host routes as `cloning', thus ensuring that
   67  *     every actual reference to such a route actually gets turned
   68  *     into a reference to a host route to the specific destination
   69  *     requested.
   70  *  2) When such routes lose all their references, it arranges for them
   71  *     to be deleted in some random collection of circumstances, so that
   72  *     a large quantity of stale routing data is not kept in kernel memory
   73  *     indefinitely.  See in6_rtqtimo() below for the exact mechanism.
   74  */
   75 
   76 #include <sys/param.h>
   77 #include <sys/systm.h>
   78 #include <sys/kernel.h>
   79 #include <sys/sysctl.h>
   80 #include <sys/queue.h>
   81 #include <sys/socket.h>
   82 #include <sys/socketvar.h>
   83 #include <sys/mbuf.h>
   84 #include <sys/syslog.h>
   85 
   86 #include <net/if.h>
   87 #include <net/route.h>
   88 #include <netinet/in.h>
   89 #include <netinet/ip_var.h>
   90 #include <netinet/in_var.h>
   91 
   92 #include <netinet/ip6.h>
   93 #include <netinet6/ip6_var.h>
   94 
   95 #include <netinet/icmp6.h>
   96 
   97 #include <netinet/tcp.h>
   98 #include <netinet/tcp_seq.h>
   99 #include <netinet/tcp_timer.h>
  100 #include <netinet/tcp_var.h>
  101 
  102 extern int      in6_inithead __P((void **head, int off));
  103 
  104 #define RTPRF_OURS              RTF_PROTO3      /* set on routes we manage */
  105 
  106 /*
  107  * Do what we need to do when inserting a route.
  108  */
  109 static struct radix_node *
  110 in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
  111             struct radix_node *treenodes)
  112 {
  113         struct rtentry *rt = (struct rtentry *)treenodes;
  114         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)rt_key(rt);
  115         struct radix_node *ret;
  116 
  117         /*
  118          * For IPv6, all unicast non-host routes are automatically cloning.
  119          */
  120         if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
  121                 rt->rt_flags |= RTF_MULTICAST;
  122 
  123         if (!(rt->rt_flags & (RTF_HOST | RTF_CLONING | RTF_MULTICAST))) {
  124                 rt->rt_flags |= RTF_PRCLONING;
  125         }
  126 
  127         /*
  128          * A little bit of help for both IPv6 output and input:
  129          *   For local addresses, we make sure that RTF_LOCAL is set,
  130          *   with the thought that this might one day be used to speed up
  131          *   ip_input().
  132          *
  133          * We also mark routes to multicast addresses as such, because
  134          * it's easy to do and might be useful (but this is much more
  135          * dubious since it's so easy to inspect the address).  (This
  136          * is done above.)
  137          *
  138          * XXX
  139          * should elaborate the code.
  140          */
  141         if (rt->rt_flags & RTF_HOST) {
  142                 if (IN6_ARE_ADDR_EQUAL(&satosin6(rt->rt_ifa->ifa_addr)
  143                                         ->sin6_addr,
  144                                        &sin6->sin6_addr)) {
  145                         rt->rt_flags |= RTF_LOCAL;
  146                 }
  147         }
  148 
  149         if (!rt->rt_rmx.rmx_mtu && !(rt->rt_rmx.rmx_locks & RTV_MTU)
  150             && rt->rt_ifp)
  151                 rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
  152 
  153         ret = rn_addroute(v_arg, n_arg, head, treenodes);
  154         if (ret == NULL && rt->rt_flags & RTF_HOST) {
  155                 struct rtentry *rt2;
  156                 /*
  157                  * We are trying to add a host route, but can't.
  158                  * Find out if it is because of an
  159                  * ARP entry and delete it if so.
  160                  */
  161                 rt2 = rtalloc1((struct sockaddr *)sin6, 0,
  162                                 RTF_CLONING | RTF_PRCLONING);
  163                 if (rt2) {
  164                         if (rt2->rt_flags & RTF_LLINFO &&
  165                                 rt2->rt_flags & RTF_HOST &&
  166                                 rt2->rt_gateway &&
  167                                 rt2->rt_gateway->sa_family == AF_LINK) {
  168                                 rtrequest(RTM_DELETE,
  169                                           (struct sockaddr *)rt_key(rt2),
  170                                           rt2->rt_gateway,
  171                                           rt_mask(rt2), rt2->rt_flags, 0);
  172                                 ret = rn_addroute(v_arg, n_arg, head,
  173                                         treenodes);
  174                         }
  175                         RTFREE(rt2);
  176                 }
  177         } else if (ret == NULL && rt->rt_flags & RTF_CLONING) {
  178                 struct rtentry *rt2;
  179                 /*
  180                  * We are trying to add a net route, but can't.
  181                  * The following case should be allowed, so we'll make a
  182                  * special check for this:
  183                  *      Two IPv6 addresses with the same prefix is assigned
  184                  *      to a single interrface.
  185                  *      # ifconfig if0 inet6 3ffe:0501::1 prefix 64 alias (*1)
  186                  *      # ifconfig if0 inet6 3ffe:0501::2 prefix 64 alias (*2)
  187                  *      In this case, (*1) and (*2) want to add the same
  188                  *      net route entry, 3ffe:0501:: -> if0.
  189                  *      This case should not raise an error.
  190                  */
  191                 rt2 = rtalloc1((struct sockaddr *)sin6, 0,
  192                                 RTF_CLONING | RTF_PRCLONING);
  193                 if (rt2) {
  194                         if ((rt2->rt_flags & (RTF_CLONING|RTF_HOST|RTF_GATEWAY))
  195                                         == RTF_CLONING
  196                          && rt2->rt_gateway
  197                          && rt2->rt_gateway->sa_family == AF_LINK
  198                          && rt2->rt_ifp == rt->rt_ifp) {
  199                                 ret = rt2->rt_nodes;
  200                         }
  201                         RTFREE(rt2);
  202                 }
  203         }
  204         return ret;
  205 }
  206 
  207 /*
  208  * This code is the inverse of in6_clsroute: on first reference, if we
  209  * were managing the route, stop doing so and set the expiration timer
  210  * back off again.
  211  */
  212 static struct radix_node *
  213 in6_matroute(void *v_arg, struct radix_node_head *head)
  214 {
  215         struct radix_node *rn = rn_match(v_arg, head);
  216         struct rtentry *rt = (struct rtentry *)rn;
  217 
  218         if (rt && rt->rt_refcnt == 0) { /* this is first reference */
  219                 if (rt->rt_flags & RTPRF_OURS) {
  220                         rt->rt_flags &= ~RTPRF_OURS;
  221                         rt->rt_rmx.rmx_expire = 0;
  222                 }
  223         }
  224         return rn;
  225 }
  226 
  227 SYSCTL_DECL(_net_inet6_ip6);
  228 
  229 static int rtq_reallyold = 60*60;
  230         /* one hour is ``really old'' */
  231 SYSCTL_INT(_net_inet6_ip6, IPV6CTL_RTEXPIRE, rtexpire,
  232         CTLFLAG_RW, &rtq_reallyold , 0, "");
  233                                 
  234 static int rtq_minreallyold = 10;
  235         /* never automatically crank down to less */
  236 SYSCTL_INT(_net_inet6_ip6, IPV6CTL_RTMINEXPIRE, rtminexpire,
  237         CTLFLAG_RW, &rtq_minreallyold , 0, "");
  238                                 
  239 static int rtq_toomany = 128;
  240         /* 128 cached routes is ``too many'' */
  241 SYSCTL_INT(_net_inet6_ip6, IPV6CTL_RTMAXCACHE, rtmaxcache,
  242         CTLFLAG_RW, &rtq_toomany , 0, "");
  243                                 
  244 
  245 /*
  246  * On last reference drop, mark the route as belong to us so that it can be
  247  * timed out.
  248  */
  249 static void
  250 in6_clsroute(struct radix_node *rn, struct radix_node_head *head)
  251 {
  252         struct rtentry *rt = (struct rtentry *)rn;
  253 
  254         if (!(rt->rt_flags & RTF_UP))
  255                 return;         /* prophylactic measures */
  256 
  257         if ((rt->rt_flags & (RTF_LLINFO | RTF_HOST)) != RTF_HOST)
  258                 return;
  259 
  260         if ((rt->rt_flags & (RTF_WASCLONED | RTPRF_OURS))
  261            != RTF_WASCLONED)
  262                 return;
  263 
  264         /*
  265          * As requested by David Greenman:
  266          * If rtq_reallyold is 0, just delete the route without
  267          * waiting for a timeout cycle to kill it.
  268          */
  269         if (rtq_reallyold != 0) {
  270                 rt->rt_flags |= RTPRF_OURS;
  271                 rt->rt_rmx.rmx_expire = time_second + rtq_reallyold;
  272         } else {
  273                 struct rtentry *dummy;
  274 
  275                 /*
  276                  * rtrequest() would recursively call rtfree() without the
  277                  * dummy entry argument, causing duplicated free.
  278                  */
  279                 rtrequest(RTM_DELETE,
  280                           (struct sockaddr *)rt_key(rt),
  281                           rt->rt_gateway, rt_mask(rt),
  282                           rt->rt_flags, &dummy);
  283         }
  284 }
  285 
  286 struct rtqk_arg {
  287         struct radix_node_head *rnh;
  288         int mode;
  289         int updating;
  290         int draining;
  291         int killed;
  292         int found;
  293         time_t nextstop;
  294 };
  295 
  296 /*
  297  * Get rid of old routes.  When draining, this deletes everything, even when
  298  * the timeout is not expired yet.  When updating, this makes sure that
  299  * nothing has a timeout longer than the current value of rtq_reallyold.
  300  */
  301 static int
  302 in6_rtqkill(struct radix_node *rn, void *rock)
  303 {
  304         struct rtqk_arg *ap = rock;
  305         struct rtentry *rt = (struct rtentry *)rn;
  306         int err;
  307 
  308         if (rt->rt_flags & RTPRF_OURS) {
  309                 ap->found++;
  310 
  311                 if (ap->draining || rt->rt_rmx.rmx_expire <= time_second) {
  312                         if (rt->rt_refcnt > 0)
  313                                 panic("rtqkill route really not free");
  314 
  315                         err = rtrequest(RTM_DELETE,
  316                                         (struct sockaddr *)rt_key(rt),
  317                                         rt->rt_gateway, rt_mask(rt),
  318                                         rt->rt_flags, 0);
  319                         if (err) {
  320                                 log(LOG_WARNING, "in6_rtqkill: error %d", err);
  321                         } else {
  322                                 ap->killed++;
  323                         }
  324                 } else {
  325                         if (ap->updating
  326                            && (rt->rt_rmx.rmx_expire - time_second
  327                                > rtq_reallyold)) {
  328                                 rt->rt_rmx.rmx_expire = time_second
  329                                         + rtq_reallyold;
  330                         }
  331                         ap->nextstop = lmin(ap->nextstop,
  332                                             rt->rt_rmx.rmx_expire);
  333                 }
  334         }
  335 
  336         return 0;
  337 }
  338 
  339 #define RTQ_TIMEOUT     60*10   /* run no less than once every ten minutes */
  340 static int rtq_timeout = RTQ_TIMEOUT;
  341 
  342 static void
  343 in6_rtqtimo(void *rock)
  344 {
  345         struct radix_node_head *rnh = rock;
  346         struct rtqk_arg arg;
  347         struct timeval atv;
  348         static time_t last_adjusted_timeout = 0;
  349         int s;
  350 
  351         arg.found = arg.killed = 0;
  352         arg.rnh = rnh;
  353         arg.nextstop = time_second + rtq_timeout;
  354         arg.draining = arg.updating = 0;
  355         s = splnet();
  356         rnh->rnh_walktree(rnh, in6_rtqkill, &arg);
  357         splx(s);
  358 
  359         /*
  360          * Attempt to be somewhat dynamic about this:
  361          * If there are ``too many'' routes sitting around taking up space,
  362          * then crank down the timeout, and see if we can't make some more
  363          * go away.  However, we make sure that we will never adjust more
  364          * than once in rtq_timeout seconds, to keep from cranking down too
  365          * hard.
  366          */
  367         if ((arg.found - arg.killed > rtq_toomany)
  368            && (time_second - last_adjusted_timeout >= rtq_timeout)
  369            && rtq_reallyold > rtq_minreallyold) {
  370                 rtq_reallyold = 2*rtq_reallyold / 3;
  371                 if (rtq_reallyold < rtq_minreallyold) {
  372                         rtq_reallyold = rtq_minreallyold;
  373                 }
  374 
  375                 last_adjusted_timeout = time_second;
  376 #ifdef DIAGNOSTIC
  377                 log(LOG_DEBUG, "in6_rtqtimo: adjusted rtq_reallyold to %d",
  378                     rtq_reallyold);
  379 #endif
  380                 arg.found = arg.killed = 0;
  381                 arg.updating = 1;
  382                 s = splnet();
  383                 rnh->rnh_walktree(rnh, in6_rtqkill, &arg);
  384                 splx(s);
  385         }
  386 
  387         atv.tv_usec = 0;
  388         atv.tv_sec = arg.nextstop;
  389         timeout(in6_rtqtimo, rock, tvtohz(&atv));
  390 }
  391 
  392 /*
  393  * Age old PMTUs.
  394  */
  395 struct mtuex_arg {
  396         struct radix_node_head *rnh;
  397         time_t nextstop;
  398 };
  399 
  400 static int
  401 in6_mtuexpire(struct radix_node *rn, void *rock)
  402 {
  403         struct rtentry *rt = (struct rtentry *)rn;
  404         struct mtuex_arg *ap = rock;
  405 
  406         /* sanity */
  407         if (!rt)
  408                 panic("rt == NULL in in6_mtuexpire");
  409 
  410         if (rt->rt_rmx.rmx_expire && !(rt->rt_flags & RTF_PROBEMTU)) {
  411                 if (rt->rt_rmx.rmx_expire <= time_second) {
  412                         rt->rt_flags |= RTF_PROBEMTU;
  413                 } else {
  414                         ap->nextstop = lmin(ap->nextstop,
  415                                         rt->rt_rmx.rmx_expire);
  416                 }
  417         }
  418 
  419         return 0;
  420 }
  421 
  422 #define MTUTIMO_DEFAULT (60*1)
  423 
  424 static void
  425 in6_mtutimo(void *rock)
  426 {
  427         struct radix_node_head *rnh = rock;
  428         struct mtuex_arg arg;
  429         struct timeval atv;
  430         int s;
  431 
  432         arg.rnh = rnh;
  433         arg.nextstop = time_second + MTUTIMO_DEFAULT;
  434         s = splnet();
  435         rnh->rnh_walktree(rnh, in6_mtuexpire, &arg);
  436         splx(s);
  437 
  438         atv.tv_usec = 0;
  439         atv.tv_sec = arg.nextstop;
  440         if (atv.tv_sec < time_second) {
  441                 printf("invalid mtu expiration time on routing table\n");
  442                 arg.nextstop = time_second + 30;        /* last resort */
  443         }
  444         timeout(in6_mtutimo, rock, tvtohz(&atv));
  445 }
  446 
  447 #if 0
  448 void
  449 in6_rtqdrain()
  450 {
  451         struct radix_node_head *rnh = rt_tables[AF_INET6];
  452         struct rtqk_arg arg;
  453         int s;
  454         arg.found = arg.killed = 0;
  455         arg.rnh = rnh;
  456         arg.nextstop = 0;
  457         arg.draining = 1;
  458         arg.updating = 0;
  459         s = splnet();
  460         rnh->rnh_walktree(rnh, in6_rtqkill, &arg);
  461         splx(s);
  462 }
  463 #endif
  464 
  465 /*
  466  * Initialize our routing tree.
  467  */
  468 int
  469 in6_inithead(void **head, int off)
  470 {
  471         struct radix_node_head *rnh;
  472 
  473         if (!rn_inithead(head, off))
  474                 return 0;
  475 
  476         if (head != (void **)&rt_tables[AF_INET6]) /* BOGUS! */
  477                 return 1;       /* only do this for the real routing table */
  478 
  479         rnh = *head;
  480         rnh->rnh_addaddr = in6_addroute;
  481         rnh->rnh_matchaddr = in6_matroute;
  482         rnh->rnh_close = in6_clsroute;
  483         in6_rtqtimo(rnh);       /* kick off timeout first time */
  484         in6_mtutimo(rnh);       /* kick off timeout first time */
  485         return 1;
  486 }

Cache object: 6e94b4dabba4f8e7af84487c95f95f95


[ 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.