Home | History | Annotate | Line # | Download | only in net
route.c revision 1.187
      1  1.187     ozaki /*	$NetBSD: route.c,v 1.187 2017/01/17 07:53:06 ozaki-r Exp $	*/
      2   1.18       kml 
      3   1.18       kml /*-
      4  1.106        ad  * Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
      5   1.18       kml  * All rights reserved.
      6   1.18       kml  *
      7   1.18       kml  * This code is derived from software contributed to The NetBSD Foundation
      8   1.18       kml  * by Kevin M. Lahey of the Numerical Aerospace Simulation Facility,
      9   1.18       kml  * NASA Ames Research Center.
     10   1.18       kml  *
     11   1.18       kml  * Redistribution and use in source and binary forms, with or without
     12   1.18       kml  * modification, are permitted provided that the following conditions
     13   1.18       kml  * are met:
     14   1.18       kml  * 1. Redistributions of source code must retain the above copyright
     15   1.18       kml  *    notice, this list of conditions and the following disclaimer.
     16   1.18       kml  * 2. Redistributions in binary form must reproduce the above copyright
     17   1.18       kml  *    notice, this list of conditions and the following disclaimer in the
     18   1.18       kml  *    documentation and/or other materials provided with the distribution.
     19   1.18       kml  *
     20   1.18       kml  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21   1.18       kml  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22   1.18       kml  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23   1.18       kml  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24   1.18       kml  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25   1.18       kml  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26   1.18       kml  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27   1.18       kml  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28   1.18       kml  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29   1.18       kml  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30   1.18       kml  * POSSIBILITY OF SUCH DAMAGE.
     31   1.18       kml  */
     32   1.11       cgd 
     33    1.1       cgd /*
     34   1.25    itojun  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
     35   1.25    itojun  * All rights reserved.
     36   1.65     perry  *
     37   1.25    itojun  * Redistribution and use in source and binary forms, with or without
     38   1.25    itojun  * modification, are permitted provided that the following conditions
     39   1.25    itojun  * are met:
     40   1.25    itojun  * 1. Redistributions of source code must retain the above copyright
     41   1.25    itojun  *    notice, this list of conditions and the following disclaimer.
     42   1.25    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     43   1.25    itojun  *    notice, this list of conditions and the following disclaimer in the
     44   1.25    itojun  *    documentation and/or other materials provided with the distribution.
     45   1.25    itojun  * 3. Neither the name of the project nor the names of its contributors
     46   1.25    itojun  *    may be used to endorse or promote products derived from this software
     47   1.25    itojun  *    without specific prior written permission.
     48   1.65     perry  *
     49   1.25    itojun  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     50   1.25    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     51   1.25    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     52   1.25    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     53   1.25    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     54   1.25    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     55   1.25    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     56   1.25    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     57   1.25    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     58   1.25    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     59   1.25    itojun  * SUCH DAMAGE.
     60   1.25    itojun  */
     61   1.25    itojun 
     62   1.25    itojun /*
     63   1.10   mycroft  * Copyright (c) 1980, 1986, 1991, 1993
     64   1.10   mycroft  *	The Regents of the University of California.  All rights reserved.
     65    1.1       cgd  *
     66    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     67    1.1       cgd  * modification, are permitted provided that the following conditions
     68    1.1       cgd  * are met:
     69    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     70    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     71    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     72    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     73    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     74   1.58       agc  * 3. Neither the name of the University nor the names of its contributors
     75    1.1       cgd  *    may be used to endorse or promote products derived from this software
     76    1.1       cgd  *    without specific prior written permission.
     77    1.1       cgd  *
     78    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     79    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     80    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     81    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     82    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     83    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     84    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     85    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     86    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     87    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     88    1.1       cgd  * SUCH DAMAGE.
     89    1.1       cgd  *
     90   1.17  christos  *	@(#)route.c	8.3 (Berkeley) 1/9/95
     91    1.1       cgd  */
     92   1.50     lukem 
     93  1.149     pooka #ifdef _KERNEL_OPT
     94  1.136       roy #include "opt_inet.h"
     95   1.90    dyoung #include "opt_route.h"
     96  1.175     ozaki #include "opt_net_mpsafe.h"
     97  1.149     pooka #endif
     98   1.90    dyoung 
     99   1.50     lukem #include <sys/cdefs.h>
    100  1.187     ozaki __KERNEL_RCSID(0, "$NetBSD: route.c,v 1.187 2017/01/17 07:53:06 ozaki-r Exp $");
    101    1.2       cgd 
    102    1.5   mycroft #include <sys/param.h>
    103  1.140     ozaki #ifdef RTFLUSH_DEBUG
    104   1.90    dyoung #include <sys/sysctl.h>
    105  1.140     ozaki #endif
    106    1.5   mycroft #include <sys/systm.h>
    107   1.35   thorpej #include <sys/callout.h>
    108    1.5   mycroft #include <sys/proc.h>
    109    1.5   mycroft #include <sys/mbuf.h>
    110    1.5   mycroft #include <sys/socket.h>
    111    1.5   mycroft #include <sys/socketvar.h>
    112    1.5   mycroft #include <sys/domain.h>
    113   1.18       kml #include <sys/kernel.h>
    114    1.5   mycroft #include <sys/ioctl.h>
    115   1.22   thorpej #include <sys/pool.h>
    116  1.119      elad #include <sys/kauth.h>
    117  1.170     ozaki #include <sys/workqueue.h>
    118  1.182     ozaki #include <sys/syslog.h>
    119  1.183     ozaki #include <sys/rwlock.h>
    120  1.183     ozaki #include <sys/mutex.h>
    121  1.183     ozaki #include <sys/cpu.h>
    122    1.1       cgd 
    123    1.5   mycroft #include <net/if.h>
    124  1.114    dyoung #include <net/if_dl.h>
    125    1.5   mycroft #include <net/route.h>
    126    1.1       cgd 
    127    1.5   mycroft #include <netinet/in.h>
    128    1.5   mycroft #include <netinet/in_var.h>
    129    1.1       cgd 
    130   1.90    dyoung #ifdef RTFLUSH_DEBUG
    131   1.90    dyoung #define	rtcache_debug() __predict_false(_rtcache_debug)
    132   1.90    dyoung #else /* RTFLUSH_DEBUG */
    133   1.90    dyoung #define	rtcache_debug() 0
    134   1.90    dyoung #endif /* RTFLUSH_DEBUG */
    135    1.5   mycroft 
    136  1.183     ozaki #ifdef RT_DEBUG
    137  1.183     ozaki #define RT_REFCNT_TRACE(rt)	printf("%s:%d: rt=%p refcnt=%d\n", \
    138  1.183     ozaki 				    __func__, __LINE__, (rt), (rt)->rt_refcnt)
    139  1.183     ozaki #else
    140  1.183     ozaki #define RT_REFCNT_TRACE(rt)	do {} while (0)
    141  1.183     ozaki #endif
    142  1.183     ozaki 
    143  1.183     ozaki #ifdef DEBUG
    144  1.183     ozaki #define dlog(level, fmt, args...)	log(level, fmt, ##args)
    145  1.183     ozaki #else
    146  1.183     ozaki #define dlog(level, fmt, args...)	do {} while (0)
    147  1.183     ozaki #endif
    148  1.183     ozaki 
    149  1.155     ozaki struct rtstat		rtstat;
    150    1.1       cgd 
    151  1.155     ozaki static int		rttrash;	/* routes not in table but not freed */
    152    1.1       cgd 
    153  1.155     ozaki static struct pool	rtentry_pool;
    154  1.155     ozaki static struct pool	rttimer_pool;
    155   1.22   thorpej 
    156  1.155     ozaki static struct callout	rt_timer_ch; /* callout for rt_timer_timer() */
    157  1.177     ozaki static struct workqueue	*rt_timer_wq;
    158  1.177     ozaki static struct work	rt_timer_wk;
    159  1.177     ozaki 
    160  1.177     ozaki static void	rt_timer_init(void);
    161  1.181     ozaki static void	rt_timer_queue_remove_all(struct rttimer_queue *);
    162  1.178     ozaki static void	rt_timer_remove_all(struct rtentry *);
    163  1.177     ozaki static void	rt_timer_timer(void *);
    164   1.35   thorpej 
    165  1.183     ozaki /*
    166  1.183     ozaki  * Locking notes:
    167  1.183     ozaki  * - The routing table is protected by a global rwlock
    168  1.183     ozaki  *   - API: RT_RLOCK and friends
    169  1.183     ozaki  * - rtcaches are protected by a global rwlock
    170  1.183     ozaki  *   - API: RTCACHE_RLOCK and friends
    171  1.183     ozaki  * - References to a rtentry is managed by reference counting and psref
    172  1.183     ozaki  *   - Reference couting is used for temporal reference when a rtentry
    173  1.183     ozaki  *     is fetched from the routing table
    174  1.183     ozaki  *   - psref is used for temporal reference when a rtentry is fetched
    175  1.183     ozaki  *     from a rtcache
    176  1.183     ozaki  *     - struct route (rtcache) has struct psref, so we cannot obtain
    177  1.183     ozaki  *       a reference twice on the same struct route
    178  1.183     ozaki  *   - Befere destroying or updating a rtentry, we have to wait for
    179  1.183     ozaki  *     all references left (see below for details)
    180  1.183     ozaki  *   - APIs
    181  1.183     ozaki  *     - An obtained rtentry via rtalloc1 or rtrequest* must be
    182  1.183     ozaki  *       unreferenced by rt_unref
    183  1.183     ozaki  *     - An obtained rtentry via rtcache_* must be unreferenced by
    184  1.183     ozaki  *       rtcache_unref
    185  1.183     ozaki  *   - TODO: once we get a lockless routing table, we should use only
    186  1.183     ozaki  *           psref for rtentries
    187  1.183     ozaki  * - rtentry destruction
    188  1.183     ozaki  *   - A rtentry is destroyed (freed) only when we call rtrequest(RTM_DELETE)
    189  1.183     ozaki  *   - If a caller of rtrequest grabs a reference of a rtentry, the caller
    190  1.183     ozaki  *     has a responsibility to destroy the rtentry by itself by calling
    191  1.183     ozaki  *     rt_free
    192  1.183     ozaki  *     - If not, rtrequest itself does that
    193  1.183     ozaki  *   - If rt_free is called in softint, the actual destruction routine is
    194  1.183     ozaki  *     deferred to a workqueue
    195  1.183     ozaki  * - rtentry update
    196  1.183     ozaki  *   - When updating a rtentry, RTF_UPDATING flag is set
    197  1.183     ozaki  *   - If a rtentry is set RTF_UPDATING, fetching the rtentry from
    198  1.183     ozaki  *     the routing table or a rtcache results in either of the following
    199  1.183     ozaki  *     cases:
    200  1.183     ozaki  *     - if the caller runs in softint, the caller fails to fetch
    201  1.183     ozaki  *     - otherwise, the caller waits for the update completed and retries
    202  1.183     ozaki  *       to fetch (probably succeed to fetch for the second time)
    203  1.183     ozaki  */
    204  1.183     ozaki 
    205  1.183     ozaki /*
    206  1.183     ozaki  * Global locks for the routing table and rtcaches.
    207  1.183     ozaki  * Locking order: rtcache_lock => rt_lock
    208  1.183     ozaki  */
    209  1.183     ozaki static krwlock_t		rt_lock __cacheline_aligned;
    210  1.183     ozaki #ifdef NET_MPSAFE
    211  1.183     ozaki #define RT_RLOCK()		rw_enter(&rt_lock, RW_READER)
    212  1.183     ozaki #define RT_WLOCK()		rw_enter(&rt_lock, RW_WRITER)
    213  1.183     ozaki #define RT_UNLOCK()		rw_exit(&rt_lock)
    214  1.183     ozaki #define RT_LOCKED()		rw_lock_held(&rt_lock)
    215  1.183     ozaki #define	RT_ASSERT_WLOCK()	KASSERT(rw_write_held(&rt_lock))
    216  1.183     ozaki #else
    217  1.183     ozaki #define RT_RLOCK()		do {} while (0)
    218  1.183     ozaki #define RT_WLOCK()		do {} while (0)
    219  1.183     ozaki #define RT_UNLOCK()		do {} while (0)
    220  1.183     ozaki #define RT_LOCKED()		false
    221  1.183     ozaki #define	RT_ASSERT_WLOCK()	do {} while (0)
    222  1.183     ozaki #endif
    223  1.183     ozaki 
    224  1.183     ozaki static krwlock_t		rtcache_lock __cacheline_aligned;
    225  1.183     ozaki #ifdef NET_MPSAFE
    226  1.183     ozaki #define RTCACHE_RLOCK()		rw_enter(&rtcache_lock, RW_READER)
    227  1.183     ozaki #define RTCACHE_WLOCK()		rw_enter(&rtcache_lock, RW_WRITER)
    228  1.183     ozaki #define RTCACHE_UNLOCK()	rw_exit(&rtcache_lock)
    229  1.183     ozaki #define	RTCACHE_ASSERT_WLOCK()	KASSERT(rw_write_held(&rtcache_lock))
    230  1.183     ozaki #define	RTCACHE_WLOCKED()	rw_write_held(&rtcache_lock)
    231  1.183     ozaki #else
    232  1.183     ozaki #define RTCACHE_RLOCK()		do {} while (0)
    233  1.183     ozaki #define RTCACHE_WLOCK()		do {} while (0)
    234  1.183     ozaki #define RTCACHE_UNLOCK()	do {} while (0)
    235  1.183     ozaki #define	RTCACHE_ASSERT_WLOCK()	do {} while (0)
    236  1.183     ozaki #define	RTCACHE_WLOCKED()	false
    237  1.183     ozaki #endif
    238  1.183     ozaki 
    239  1.183     ozaki /*
    240  1.183     ozaki  * mutex and cv that are used to wait for references to a rtentry left
    241  1.183     ozaki  * before updating the rtentry.
    242  1.183     ozaki  */
    243  1.183     ozaki static struct {
    244  1.183     ozaki 	kmutex_t		lock;
    245  1.183     ozaki 	kcondvar_t		cv;
    246  1.183     ozaki 	bool			ongoing;
    247  1.183     ozaki 	const struct lwp	*lwp;
    248  1.183     ozaki } rt_update_global __cacheline_aligned;
    249  1.183     ozaki 
    250  1.183     ozaki /*
    251  1.183     ozaki  * A workqueue and stuff that are used to defer the destruction routine
    252  1.183     ozaki  * of rtentries.
    253  1.183     ozaki  */
    254  1.183     ozaki static struct {
    255  1.183     ozaki 	struct workqueue	*wq;
    256  1.183     ozaki 	struct work		wk;
    257  1.183     ozaki 	kmutex_t		lock;
    258  1.183     ozaki 	struct rtentry		*queue[10];
    259  1.183     ozaki } rt_free_global __cacheline_aligned;
    260  1.183     ozaki 
    261  1.183     ozaki /* psref for rtentry */
    262  1.183     ozaki static struct psref_class *rt_psref_class __read_mostly;
    263  1.183     ozaki 
    264   1.90    dyoung #ifdef RTFLUSH_DEBUG
    265   1.90    dyoung static int _rtcache_debug = 0;
    266   1.90    dyoung #endif /* RTFLUSH_DEBUG */
    267   1.90    dyoung 
    268  1.119      elad static kauth_listener_t route_listener;
    269  1.119      elad 
    270   1.60      matt static int rtdeletemsg(struct rtentry *);
    271  1.144     ozaki static void rtflushall(int);
    272   1.40    itojun 
    273  1.141     ozaki static void rt_maskedcopy(const struct sockaddr *,
    274  1.141     ozaki     struct sockaddr *, const struct sockaddr *);
    275  1.141     ozaki 
    276  1.144     ozaki static void rtcache_clear(struct route *);
    277  1.168     ozaki static void rtcache_clear_rtentry(int, struct rtentry *);
    278  1.144     ozaki static void rtcache_invalidate(struct dom_rtlist *);
    279  1.144     ozaki 
    280  1.183     ozaki static void rt_ref(struct rtentry *);
    281  1.183     ozaki 
    282  1.183     ozaki static struct rtentry *
    283  1.183     ozaki     rtalloc1_locked(const struct sockaddr *, int, bool);
    284  1.183     ozaki static struct rtentry *
    285  1.183     ozaki     rtcache_validate_locked(struct route *);
    286  1.183     ozaki static void rtcache_free_locked(struct route *);
    287  1.183     ozaki static int rtcache_setdst_locked(struct route *, const struct sockaddr *);
    288  1.183     ozaki 
    289  1.183     ozaki static void rtcache_ref(struct rtentry *, struct route *);
    290  1.183     ozaki 
    291  1.183     ozaki static void rt_update_wait(void);
    292  1.183     ozaki 
    293  1.183     ozaki static bool rt_wait_ok(void);
    294  1.183     ozaki static void rt_wait_refcnt(const char *, struct rtentry *, int);
    295  1.183     ozaki static void rt_wait_psref(struct rtentry *);
    296  1.183     ozaki 
    297  1.162     ozaki #ifdef DDB
    298  1.162     ozaki static void db_print_sa(const struct sockaddr *);
    299  1.162     ozaki static void db_print_ifa(struct ifaddr *);
    300  1.162     ozaki static int db_show_rtentry(struct rtentry *, void *);
    301  1.162     ozaki #endif
    302  1.162     ozaki 
    303   1.90    dyoung #ifdef RTFLUSH_DEBUG
    304  1.118     pooka static void sysctl_net_rtcache_setup(struct sysctllog **);
    305  1.118     pooka static void
    306  1.118     pooka sysctl_net_rtcache_setup(struct sysctllog **clog)
    307   1.90    dyoung {
    308   1.90    dyoung 	const struct sysctlnode *rnode;
    309   1.90    dyoung 
    310   1.90    dyoung 	if (sysctl_createv(clog, 0, NULL, &rnode, CTLFLAG_PERMANENT,
    311   1.90    dyoung 	    CTLTYPE_NODE,
    312   1.90    dyoung 	    "rtcache", SYSCTL_DESCR("Route cache related settings"),
    313  1.128     pooka 	    NULL, 0, NULL, 0, CTL_NET, CTL_CREATE, CTL_EOL) != 0)
    314   1.90    dyoung 		return;
    315   1.90    dyoung 	if (sysctl_createv(clog, 0, &rnode, &rnode,
    316   1.90    dyoung 	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
    317   1.90    dyoung 	    "debug", SYSCTL_DESCR("Debug route caches"),
    318   1.90    dyoung 	    NULL, 0, &_rtcache_debug, 0, CTL_CREATE, CTL_EOL) != 0)
    319   1.90    dyoung 		return;
    320   1.90    dyoung }
    321   1.90    dyoung #endif /* RTFLUSH_DEBUG */
    322   1.90    dyoung 
    323  1.144     ozaki static inline void
    324  1.144     ozaki rt_destroy(struct rtentry *rt)
    325  1.144     ozaki {
    326  1.144     ozaki 	if (rt->_rt_key != NULL)
    327  1.144     ozaki 		sockaddr_free(rt->_rt_key);
    328  1.144     ozaki 	if (rt->rt_gateway != NULL)
    329  1.144     ozaki 		sockaddr_free(rt->rt_gateway);
    330  1.144     ozaki 	if (rt_gettag(rt) != NULL)
    331  1.144     ozaki 		sockaddr_free(rt_gettag(rt));
    332  1.144     ozaki 	rt->_rt_key = rt->rt_gateway = rt->rt_tag = NULL;
    333  1.144     ozaki }
    334  1.144     ozaki 
    335  1.144     ozaki static inline const struct sockaddr *
    336  1.144     ozaki rt_setkey(struct rtentry *rt, const struct sockaddr *key, int flags)
    337  1.144     ozaki {
    338  1.144     ozaki 	if (rt->_rt_key == key)
    339  1.144     ozaki 		goto out;
    340  1.144     ozaki 
    341  1.144     ozaki 	if (rt->_rt_key != NULL)
    342  1.144     ozaki 		sockaddr_free(rt->_rt_key);
    343  1.144     ozaki 	rt->_rt_key = sockaddr_dup(key, flags);
    344  1.144     ozaki out:
    345  1.144     ozaki 	rt->rt_nodes->rn_key = (const char *)rt->_rt_key;
    346  1.144     ozaki 	return rt->_rt_key;
    347  1.144     ozaki }
    348  1.144     ozaki 
    349   1.81     joerg struct ifaddr *
    350   1.81     joerg rt_get_ifa(struct rtentry *rt)
    351   1.81     joerg {
    352   1.81     joerg 	struct ifaddr *ifa;
    353   1.81     joerg 
    354   1.81     joerg 	if ((ifa = rt->rt_ifa) == NULL)
    355   1.81     joerg 		return ifa;
    356   1.81     joerg 	else if (ifa->ifa_getifa == NULL)
    357   1.81     joerg 		return ifa;
    358   1.81     joerg #if 0
    359   1.81     joerg 	else if (ifa->ifa_seqno != NULL && *ifa->ifa_seqno == rt->rt_ifa_seqno)
    360   1.81     joerg 		return ifa;
    361   1.81     joerg #endif
    362   1.81     joerg 	else {
    363   1.94    dyoung 		ifa = (*ifa->ifa_getifa)(ifa, rt_getkey(rt));
    364  1.145       roy 		if (ifa == NULL)
    365  1.145       roy 			return NULL;
    366   1.81     joerg 		rt_replace_ifa(rt, ifa);
    367   1.81     joerg 		return ifa;
    368   1.81     joerg 	}
    369   1.81     joerg }
    370   1.81     joerg 
    371   1.80     joerg static void
    372   1.80     joerg rt_set_ifa1(struct rtentry *rt, struct ifaddr *ifa)
    373   1.80     joerg {
    374   1.80     joerg 	rt->rt_ifa = ifa;
    375   1.80     joerg 	if (ifa->ifa_seqno != NULL)
    376   1.80     joerg 		rt->rt_ifa_seqno = *ifa->ifa_seqno;
    377   1.80     joerg }
    378   1.80     joerg 
    379  1.116       roy /*
    380  1.116       roy  * Is this route the connected route for the ifa?
    381  1.116       roy  */
    382  1.116       roy static int
    383  1.116       roy rt_ifa_connected(const struct rtentry *rt, const struct ifaddr *ifa)
    384  1.116       roy {
    385  1.116       roy 	const struct sockaddr *key, *dst, *odst;
    386  1.116       roy 	struct sockaddr_storage maskeddst;
    387  1.116       roy 
    388  1.116       roy 	key = rt_getkey(rt);
    389  1.116       roy 	dst = rt->rt_flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
    390  1.116       roy 	if (dst == NULL ||
    391  1.116       roy 	    dst->sa_family != key->sa_family ||
    392  1.116       roy 	    dst->sa_len != key->sa_len)
    393  1.116       roy 		return 0;
    394  1.116       roy 	if ((rt->rt_flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
    395  1.116       roy 		odst = dst;
    396  1.116       roy 		dst = (struct sockaddr *)&maskeddst;
    397  1.116       roy 		rt_maskedcopy(odst, (struct sockaddr *)&maskeddst,
    398  1.116       roy 		    ifa->ifa_netmask);
    399  1.116       roy 	}
    400  1.116       roy 	return (memcmp(dst, key, dst->sa_len) == 0);
    401  1.116       roy }
    402  1.116       roy 
    403   1.80     joerg void
    404   1.80     joerg rt_replace_ifa(struct rtentry *rt, struct ifaddr *ifa)
    405   1.80     joerg {
    406  1.116       roy 	if (rt->rt_ifa &&
    407  1.116       roy 	    rt->rt_ifa != ifa &&
    408  1.116       roy 	    rt->rt_ifa->ifa_flags & IFA_ROUTE &&
    409  1.116       roy 	    rt_ifa_connected(rt, rt->rt_ifa))
    410  1.116       roy 	{
    411  1.116       roy 		RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
    412  1.116       roy 		    "replace deleted IFA_ROUTE\n",
    413  1.116       roy 		    (void *)rt->_rt_key, (void *)rt->rt_ifa);
    414  1.116       roy 		rt->rt_ifa->ifa_flags &= ~IFA_ROUTE;
    415  1.116       roy 		if (rt_ifa_connected(rt, ifa)) {
    416  1.116       roy 			RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
    417  1.116       roy 			    "replace added IFA_ROUTE\n",
    418  1.116       roy 			    (void *)rt->_rt_key, (void *)ifa);
    419  1.116       roy 			ifa->ifa_flags |= IFA_ROUTE;
    420  1.116       roy 		}
    421  1.116       roy 	}
    422  1.116       roy 
    423  1.133     rmind 	ifaref(ifa);
    424  1.133     rmind 	ifafree(rt->rt_ifa);
    425   1.80     joerg 	rt_set_ifa1(rt, ifa);
    426   1.80     joerg }
    427   1.80     joerg 
    428   1.80     joerg static void
    429   1.80     joerg rt_set_ifa(struct rtentry *rt, struct ifaddr *ifa)
    430   1.80     joerg {
    431  1.133     rmind 	ifaref(ifa);
    432   1.80     joerg 	rt_set_ifa1(rt, ifa);
    433   1.80     joerg }
    434   1.80     joerg 
    435  1.119      elad static int
    436  1.119      elad route_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
    437  1.119      elad     void *arg0, void *arg1, void *arg2, void *arg3)
    438  1.119      elad {
    439  1.119      elad 	struct rt_msghdr *rtm;
    440  1.119      elad 	int result;
    441  1.119      elad 
    442  1.119      elad 	result = KAUTH_RESULT_DEFER;
    443  1.119      elad 	rtm = arg1;
    444  1.119      elad 
    445  1.120      elad 	if (action != KAUTH_NETWORK_ROUTE)
    446  1.120      elad 		return result;
    447  1.120      elad 
    448  1.119      elad 	if (rtm->rtm_type == RTM_GET)
    449  1.119      elad 		result = KAUTH_RESULT_ALLOW;
    450  1.119      elad 
    451  1.119      elad 	return result;
    452  1.119      elad }
    453  1.119      elad 
    454  1.183     ozaki static void rt_free_work(struct work *, void *);
    455  1.183     ozaki 
    456    1.9   mycroft void
    457  1.124      matt rt_init(void)
    458    1.1       cgd {
    459  1.183     ozaki 	int error;
    460   1.22   thorpej 
    461  1.118     pooka #ifdef RTFLUSH_DEBUG
    462  1.118     pooka 	sysctl_net_rtcache_setup(NULL);
    463  1.118     pooka #endif
    464  1.118     pooka 
    465  1.183     ozaki 	mutex_init(&rt_free_global.lock, MUTEX_DEFAULT, IPL_SOFTNET);
    466  1.183     ozaki 	rt_psref_class = psref_class_create("rtentry", IPL_SOFTNET);
    467  1.183     ozaki 
    468  1.183     ozaki 	error = workqueue_create(&rt_free_global.wq, "rt_free",
    469  1.183     ozaki 	    rt_free_work, NULL, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
    470  1.183     ozaki 	if (error)
    471  1.183     ozaki 		panic("%s: workqueue_create failed (%d)\n", __func__, error);
    472  1.183     ozaki 
    473  1.183     ozaki 	mutex_init(&rt_update_global.lock, MUTEX_DEFAULT, IPL_SOFTNET);
    474  1.183     ozaki 	cv_init(&rt_update_global.cv, "rt_update");
    475  1.183     ozaki 
    476  1.113     pooka 	pool_init(&rtentry_pool, sizeof(struct rtentry), 0, 0, 0, "rtentpl",
    477  1.113     pooka 	    NULL, IPL_SOFTNET);
    478  1.113     pooka 	pool_init(&rttimer_pool, sizeof(struct rttimer), 0, 0, 0, "rttmrpl",
    479  1.113     pooka 	    NULL, IPL_SOFTNET);
    480  1.113     pooka 
    481   1.10   mycroft 	rn_init();	/* initialize all zeroes, all ones, mask table */
    482  1.125    dyoung 	rtbl_init();
    483  1.119      elad 
    484  1.119      elad 	route_listener = kauth_listen_scope(KAUTH_SCOPE_NETWORK,
    485  1.119      elad 	    route_listener_cb, NULL);
    486    1.1       cgd }
    487    1.1       cgd 
    488  1.144     ozaki static void
    489   1.82    dyoung rtflushall(int family)
    490   1.82    dyoung {
    491   1.90    dyoung 	struct domain *dom;
    492   1.90    dyoung 
    493   1.90    dyoung 	if (rtcache_debug())
    494   1.90    dyoung 		printf("%s: enter\n", __func__);
    495   1.90    dyoung 
    496   1.90    dyoung 	if ((dom = pffinddomain(family)) == NULL)
    497   1.90    dyoung 		return;
    498   1.82    dyoung 
    499  1.183     ozaki 	RTCACHE_WLOCK();
    500  1.105    dyoung 	rtcache_invalidate(&dom->dom_rtcache);
    501  1.183     ozaki 	RTCACHE_UNLOCK();
    502   1.82    dyoung }
    503   1.82    dyoung 
    504  1.131     rmind static void
    505   1.82    dyoung rtcache(struct route *ro)
    506   1.82    dyoung {
    507   1.90    dyoung 	struct domain *dom;
    508   1.82    dyoung 
    509  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
    510  1.183     ozaki 
    511  1.114    dyoung 	rtcache_invariants(ro);
    512   1.99    dyoung 	KASSERT(ro->_ro_rt != NULL);
    513  1.105    dyoung 	KASSERT(ro->ro_invalid == false);
    514   1.90    dyoung 	KASSERT(rtcache_getdst(ro) != NULL);
    515   1.82    dyoung 
    516   1.90    dyoung 	if ((dom = pffinddomain(rtcache_getdst(ro)->sa_family)) == NULL)
    517   1.90    dyoung 		return;
    518   1.90    dyoung 
    519   1.90    dyoung 	LIST_INSERT_HEAD(&dom->dom_rtcache, ro, ro_rtcache_next);
    520  1.114    dyoung 	rtcache_invariants(ro);
    521   1.82    dyoung }
    522   1.82    dyoung 
    523  1.158     ozaki #ifdef RT_DEBUG
    524  1.158     ozaki static void
    525  1.158     ozaki dump_rt(const struct rtentry *rt)
    526  1.158     ozaki {
    527  1.158     ozaki 	char buf[512];
    528  1.158     ozaki 
    529  1.158     ozaki 	aprint_normal("rt: ");
    530  1.158     ozaki 	aprint_normal("p=%p ", rt);
    531  1.158     ozaki 	if (rt->_rt_key == NULL) {
    532  1.158     ozaki 		aprint_normal("dst=(NULL) ");
    533  1.158     ozaki 	} else {
    534  1.158     ozaki 		sockaddr_format(rt->_rt_key, buf, sizeof(buf));
    535  1.158     ozaki 		aprint_normal("dst=%s ", buf);
    536  1.158     ozaki 	}
    537  1.158     ozaki 	if (rt->rt_gateway == NULL) {
    538  1.158     ozaki 		aprint_normal("gw=(NULL) ");
    539  1.158     ozaki 	} else {
    540  1.158     ozaki 		sockaddr_format(rt->_rt_key, buf, sizeof(buf));
    541  1.158     ozaki 		aprint_normal("gw=%s ", buf);
    542  1.158     ozaki 	}
    543  1.158     ozaki 	aprint_normal("flags=%x ", rt->rt_flags);
    544  1.158     ozaki 	if (rt->rt_ifp == NULL) {
    545  1.158     ozaki 		aprint_normal("if=(NULL) ");
    546  1.158     ozaki 	} else {
    547  1.158     ozaki 		aprint_normal("if=%s ", rt->rt_ifp->if_xname);
    548  1.158     ozaki 	}
    549  1.158     ozaki 	aprint_normal("\n");
    550  1.158     ozaki }
    551  1.158     ozaki #endif /* RT_DEBUG */
    552  1.158     ozaki 
    553    1.1       cgd /*
    554  1.146     ozaki  * Packet routing routines. If success, refcnt of a returned rtentry
    555  1.146     ozaki  * will be incremented. The caller has to rtfree it by itself.
    556    1.1       cgd  */
    557    1.1       cgd struct rtentry *
    558  1.183     ozaki rtalloc1_locked(const struct sockaddr *dst, int report, bool wait_ok)
    559    1.1       cgd {
    560  1.158     ozaki 	rtbl_t *rtbl;
    561   1.36  augustss 	struct rtentry *rt;
    562  1.159  christos 	int s;
    563    1.1       cgd 
    564  1.183     ozaki retry:
    565  1.159  christos 	s = splsoftnet();
    566  1.158     ozaki 	rtbl = rt_gettable(dst->sa_family);
    567  1.159  christos 	if (rtbl == NULL)
    568  1.158     ozaki 		goto miss;
    569  1.158     ozaki 
    570  1.158     ozaki 	rt = rt_matchaddr(rtbl, dst);
    571  1.159  christos 	if (rt == NULL)
    572  1.158     ozaki 		goto miss;
    573  1.159  christos 
    574  1.183     ozaki 	if (!ISSET(rt->rt_flags, RTF_UP))
    575  1.183     ozaki 		goto miss;
    576  1.183     ozaki 
    577  1.183     ozaki 	if (ISSET(rt->rt_flags, RTF_UPDATING) &&
    578  1.183     ozaki 	    /* XXX updater should be always able to acquire */
    579  1.183     ozaki 	    curlwp != rt_update_global.lwp) {
    580  1.183     ozaki 		bool need_lock = false;
    581  1.183     ozaki 		if (!wait_ok || !rt_wait_ok())
    582  1.183     ozaki 			goto miss;
    583  1.183     ozaki 		RT_UNLOCK();
    584  1.183     ozaki 		splx(s);
    585  1.183     ozaki 
    586  1.183     ozaki 		/* XXX need more proper solution */
    587  1.183     ozaki 		if (RTCACHE_WLOCKED()) {
    588  1.183     ozaki 			RTCACHE_UNLOCK();
    589  1.183     ozaki 			need_lock = true;
    590  1.183     ozaki 		}
    591  1.183     ozaki 
    592  1.183     ozaki 		/* We can wait until the update is complete */
    593  1.183     ozaki 		rt_update_wait();
    594  1.183     ozaki 
    595  1.183     ozaki 		if (need_lock)
    596  1.183     ozaki 			RTCACHE_WLOCK();
    597  1.183     ozaki 		goto retry;
    598  1.183     ozaki 	}
    599  1.183     ozaki 
    600  1.183     ozaki 	rt_ref(rt);
    601  1.183     ozaki 	RT_REFCNT_TRACE(rt);
    602  1.158     ozaki 
    603  1.159  christos 	splx(s);
    604  1.159  christos 	return rt;
    605  1.158     ozaki miss:
    606  1.159  christos 	rtstat.rts_unreach++;
    607  1.158     ozaki 	if (report) {
    608  1.159  christos 		struct rt_addrinfo info;
    609  1.159  christos 
    610  1.160  christos 		memset(&info, 0, sizeof(info));
    611  1.158     ozaki 		info.rti_info[RTAX_DST] = dst;
    612  1.159  christos 		rt_missmsg(RTM_MISS, &info, 0, 0);
    613    1.1       cgd 	}
    614    1.1       cgd 	splx(s);
    615  1.159  christos 	return NULL;
    616    1.1       cgd }
    617    1.1       cgd 
    618  1.183     ozaki struct rtentry *
    619  1.183     ozaki rtalloc1(const struct sockaddr *dst, int report)
    620  1.183     ozaki {
    621  1.183     ozaki 	struct rtentry *rt;
    622  1.183     ozaki 
    623  1.183     ozaki 	RT_RLOCK();
    624  1.183     ozaki 	rt = rtalloc1_locked(dst, report, true);
    625  1.183     ozaki 	RT_UNLOCK();
    626  1.183     ozaki 
    627  1.183     ozaki 	return rt;
    628  1.183     ozaki }
    629  1.183     ozaki 
    630  1.151     ozaki static void
    631  1.183     ozaki rt_ref(struct rtentry *rt)
    632  1.183     ozaki {
    633  1.183     ozaki 
    634  1.183     ozaki 	KASSERT(rt->rt_refcnt >= 0);
    635  1.183     ozaki 	atomic_inc_uint(&rt->rt_refcnt);
    636  1.183     ozaki }
    637  1.183     ozaki 
    638  1.183     ozaki void
    639  1.183     ozaki rt_unref(struct rtentry *rt)
    640  1.183     ozaki {
    641  1.183     ozaki 
    642  1.183     ozaki 	KASSERT(rt != NULL);
    643  1.183     ozaki 	KASSERTMSG(rt->rt_refcnt > 0, "refcnt=%d", rt->rt_refcnt);
    644  1.183     ozaki 
    645  1.183     ozaki 	atomic_dec_uint(&rt->rt_refcnt);
    646  1.183     ozaki 	if (!ISSET(rt->rt_flags, RTF_UP) || ISSET(rt->rt_flags, RTF_UPDATING)) {
    647  1.183     ozaki 		mutex_enter(&rt_free_global.lock);
    648  1.183     ozaki 		cv_broadcast(&rt->rt_cv);
    649  1.183     ozaki 		mutex_exit(&rt_free_global.lock);
    650  1.183     ozaki 	}
    651  1.183     ozaki }
    652  1.183     ozaki 
    653  1.183     ozaki static bool
    654  1.183     ozaki rt_wait_ok(void)
    655  1.151     ozaki {
    656  1.151     ozaki 
    657  1.183     ozaki 	KASSERT(!cpu_intr_p());
    658  1.183     ozaki 	return !cpu_softintr_p();
    659  1.183     ozaki }
    660  1.151     ozaki 
    661  1.183     ozaki void
    662  1.183     ozaki rt_wait_refcnt(const char *title, struct rtentry *rt, int cnt)
    663  1.183     ozaki {
    664  1.183     ozaki 	mutex_enter(&rt_free_global.lock);
    665  1.183     ozaki 	while (rt->rt_refcnt > cnt) {
    666  1.183     ozaki 		dlog(LOG_DEBUG, "%s: %s waiting (refcnt=%d)\n",
    667  1.183     ozaki 		    __func__, title, rt->rt_refcnt);
    668  1.183     ozaki 		cv_wait(&rt->rt_cv, &rt_free_global.lock);
    669  1.183     ozaki 		dlog(LOG_DEBUG, "%s: %s waited (refcnt=%d)\n",
    670  1.183     ozaki 		    __func__, title, rt->rt_refcnt);
    671  1.183     ozaki 	}
    672  1.183     ozaki 	mutex_exit(&rt_free_global.lock);
    673  1.151     ozaki }
    674  1.151     ozaki 
    675    1.9   mycroft void
    676  1.183     ozaki rt_wait_psref(struct rtentry *rt)
    677  1.183     ozaki {
    678  1.183     ozaki 
    679  1.183     ozaki 	psref_target_destroy(&rt->rt_psref, rt_psref_class);
    680  1.183     ozaki 	psref_target_init(&rt->rt_psref, rt_psref_class);
    681  1.183     ozaki }
    682  1.183     ozaki 
    683  1.183     ozaki static void
    684  1.183     ozaki _rt_free(struct rtentry *rt)
    685    1.1       cgd {
    686   1.36  augustss 	struct ifaddr *ifa;
    687   1.10   mycroft 
    688  1.183     ozaki 	/*
    689  1.183     ozaki 	 * Need to avoid a deadlock on rt_wait_refcnt of update
    690  1.183     ozaki 	 * and a conflict on psref_target_destroy of update.
    691  1.183     ozaki 	 */
    692  1.183     ozaki 	rt_update_wait();
    693  1.183     ozaki 
    694  1.183     ozaki 	RT_REFCNT_TRACE(rt);
    695  1.183     ozaki 	KASSERTMSG(rt->rt_refcnt >= 0, "refcnt=%d", rt->rt_refcnt);
    696  1.183     ozaki 	rt_wait_refcnt("free", rt, 0);
    697  1.185     ozaki #ifdef NET_MPSAFE
    698  1.183     ozaki 	psref_target_destroy(&rt->rt_psref, rt_psref_class);
    699  1.185     ozaki #endif
    700  1.183     ozaki 
    701  1.183     ozaki 	rt_assert_inactive(rt);
    702  1.183     ozaki 	rttrash--;
    703  1.183     ozaki 	ifa = rt->rt_ifa;
    704  1.183     ozaki 	rt->rt_ifa = NULL;
    705  1.183     ozaki 	ifafree(ifa);
    706  1.183     ozaki 	rt->rt_ifp = NULL;
    707  1.183     ozaki 	cv_destroy(&rt->rt_cv);
    708  1.183     ozaki 	rt_destroy(rt);
    709  1.183     ozaki 	pool_put(&rtentry_pool, rt);
    710  1.183     ozaki }
    711  1.183     ozaki 
    712  1.183     ozaki static void
    713  1.183     ozaki rt_free_work(struct work *wk, void *arg)
    714  1.183     ozaki {
    715  1.183     ozaki 	int i;
    716  1.183     ozaki 	struct rtentry *rt;
    717  1.183     ozaki 
    718  1.183     ozaki restart:
    719  1.183     ozaki 	mutex_enter(&rt_free_global.lock);
    720  1.183     ozaki 	for (i = 0; i < sizeof(rt_free_global.queue); i++) {
    721  1.183     ozaki 		if (rt_free_global.queue[i] == NULL)
    722  1.183     ozaki 			continue;
    723  1.183     ozaki 		rt = rt_free_global.queue[i];
    724  1.183     ozaki 		rt_free_global.queue[i] = NULL;
    725  1.183     ozaki 		mutex_exit(&rt_free_global.lock);
    726  1.183     ozaki 
    727  1.183     ozaki 		atomic_dec_uint(&rt->rt_refcnt);
    728  1.183     ozaki 		_rt_free(rt);
    729  1.183     ozaki 		goto restart;
    730  1.183     ozaki 	}
    731  1.183     ozaki 	mutex_exit(&rt_free_global.lock);
    732  1.183     ozaki }
    733  1.183     ozaki 
    734  1.183     ozaki void
    735  1.183     ozaki rt_free(struct rtentry *rt)
    736  1.183     ozaki {
    737  1.183     ozaki 
    738  1.132     rmind 	KASSERT(rt->rt_refcnt > 0);
    739  1.183     ozaki 	if (!rt_wait_ok()) {
    740  1.183     ozaki 		int i;
    741  1.183     ozaki 		mutex_enter(&rt_free_global.lock);
    742  1.183     ozaki 		for (i = 0; i < sizeof(rt_free_global.queue); i++) {
    743  1.183     ozaki 			if (rt_free_global.queue[i] == NULL) {
    744  1.183     ozaki 				rt_free_global.queue[i] = rt;
    745  1.183     ozaki 				break;
    746  1.183     ozaki 			}
    747  1.183     ozaki 		}
    748  1.183     ozaki 		KASSERT(i < sizeof(rt_free_global.queue));
    749  1.183     ozaki 		rt_ref(rt);
    750  1.183     ozaki 		mutex_exit(&rt_free_global.lock);
    751  1.183     ozaki 		workqueue_enqueue(rt_free_global.wq, &rt_free_global.wk, NULL);
    752  1.183     ozaki 	} else {
    753  1.183     ozaki 		atomic_dec_uint(&rt->rt_refcnt);
    754  1.183     ozaki 		_rt_free(rt);
    755  1.183     ozaki 	}
    756  1.183     ozaki }
    757  1.183     ozaki 
    758  1.183     ozaki static void
    759  1.183     ozaki rt_update_wait(void)
    760  1.183     ozaki {
    761  1.132     rmind 
    762  1.183     ozaki 	mutex_enter(&rt_update_global.lock);
    763  1.183     ozaki 	while (rt_update_global.ongoing) {
    764  1.183     ozaki 		dlog(LOG_DEBUG, "%s: waiting lwp=%p\n", __func__, curlwp);
    765  1.183     ozaki 		cv_wait(&rt_update_global.cv, &rt_update_global.lock);
    766  1.183     ozaki 		dlog(LOG_DEBUG, "%s: waited lwp=%p\n", __func__, curlwp);
    767    1.1       cgd 	}
    768  1.183     ozaki 	mutex_exit(&rt_update_global.lock);
    769  1.183     ozaki }
    770  1.183     ozaki 
    771  1.183     ozaki int
    772  1.183     ozaki rt_update_prepare(struct rtentry *rt)
    773  1.183     ozaki {
    774  1.183     ozaki 
    775  1.183     ozaki 	dlog(LOG_DEBUG, "%s: updating rt=%p lwp=%p\n", __func__, rt, curlwp);
    776  1.183     ozaki 
    777  1.183     ozaki 	RTCACHE_WLOCK();
    778  1.183     ozaki 	RT_WLOCK();
    779  1.183     ozaki 	/* If the entry is being destroyed, don't proceed the update. */
    780  1.183     ozaki 	if (!ISSET(rt->rt_flags, RTF_UP)) {
    781  1.183     ozaki 		RT_UNLOCK();
    782  1.183     ozaki 		RTCACHE_UNLOCK();
    783  1.183     ozaki 		return -1;
    784  1.183     ozaki 	}
    785  1.183     ozaki 	rt->rt_flags |= RTF_UPDATING;
    786  1.183     ozaki 	RT_UNLOCK();
    787  1.183     ozaki 	RTCACHE_UNLOCK();
    788  1.183     ozaki 
    789  1.183     ozaki 	mutex_enter(&rt_update_global.lock);
    790  1.183     ozaki 	while (rt_update_global.ongoing) {
    791  1.183     ozaki 		dlog(LOG_DEBUG, "%s: waiting ongoing updating rt=%p lwp=%p\n",
    792  1.183     ozaki 		    __func__, rt, curlwp);
    793  1.183     ozaki 		cv_wait(&rt_update_global.cv, &rt_update_global.lock);
    794  1.183     ozaki 		dlog(LOG_DEBUG, "%s: waited ongoing updating rt=%p lwp=%p\n",
    795  1.183     ozaki 		    __func__, rt, curlwp);
    796  1.183     ozaki 	}
    797  1.183     ozaki 	rt_update_global.ongoing = true;
    798  1.183     ozaki 	/* XXX need it to avoid rt_update_wait by updater itself. */
    799  1.183     ozaki 	rt_update_global.lwp = curlwp;
    800  1.183     ozaki 	mutex_exit(&rt_update_global.lock);
    801  1.183     ozaki 
    802  1.183     ozaki 	rt_wait_refcnt("update", rt, 1);
    803  1.183     ozaki 	rt_wait_psref(rt);
    804  1.183     ozaki 
    805  1.183     ozaki 	return 0;
    806  1.183     ozaki }
    807  1.183     ozaki 
    808  1.183     ozaki void
    809  1.183     ozaki rt_update_finish(struct rtentry *rt)
    810  1.183     ozaki {
    811  1.183     ozaki 
    812  1.183     ozaki 	RTCACHE_WLOCK();
    813  1.183     ozaki 	RT_WLOCK();
    814  1.183     ozaki 	rt->rt_flags &= ~RTF_UPDATING;
    815  1.183     ozaki 	RT_UNLOCK();
    816  1.183     ozaki 	RTCACHE_UNLOCK();
    817  1.183     ozaki 
    818  1.183     ozaki 	mutex_enter(&rt_update_global.lock);
    819  1.183     ozaki 	rt_update_global.ongoing = false;
    820  1.183     ozaki 	rt_update_global.lwp = NULL;
    821  1.183     ozaki 	cv_broadcast(&rt_update_global.cv);
    822  1.183     ozaki 	mutex_exit(&rt_update_global.lock);
    823  1.183     ozaki 
    824  1.183     ozaki 	dlog(LOG_DEBUG, "%s: updated rt=%p lwp=%p\n", __func__, rt, curlwp);
    825    1.1       cgd }
    826    1.1       cgd 
    827    1.1       cgd /*
    828    1.1       cgd  * Force a routing table entry to the specified
    829    1.1       cgd  * destination to go through the given gateway.
    830    1.1       cgd  * Normally called as a result of a routing redirect
    831    1.1       cgd  * message from the network layer.
    832    1.1       cgd  *
    833   1.13   mycroft  * N.B.: must be called at splsoftnet
    834    1.1       cgd  */
    835   1.14  christos void
    836   1.60      matt rtredirect(const struct sockaddr *dst, const struct sockaddr *gateway,
    837   1.60      matt 	const struct sockaddr *netmask, int flags, const struct sockaddr *src,
    838   1.60      matt 	struct rtentry **rtp)
    839    1.1       cgd {
    840   1.36  augustss 	struct rtentry *rt;
    841    1.1       cgd 	int error = 0;
    842  1.121    dyoung 	uint64_t *stat = NULL;
    843   1.10   mycroft 	struct rt_addrinfo info;
    844   1.10   mycroft 	struct ifaddr *ifa;
    845  1.173     ozaki 	struct psref psref;
    846    1.1       cgd 
    847    1.1       cgd 	/* verify the gateway is directly reachable */
    848  1.173     ozaki 	if ((ifa = ifa_ifwithnet_psref(gateway, &psref)) == NULL) {
    849    1.1       cgd 		error = ENETUNREACH;
    850    1.8       cgd 		goto out;
    851    1.1       cgd 	}
    852    1.1       cgd 	rt = rtalloc1(dst, 0);
    853    1.1       cgd 	/*
    854    1.1       cgd 	 * If the redirect isn't from our current router for this dst,
    855    1.1       cgd 	 * it's either old or wrong.  If it redirects us to ourselves,
    856    1.1       cgd 	 * we have a routing loop, perhaps as a result of an interface
    857    1.1       cgd 	 * going down recently.
    858    1.1       cgd 	 */
    859   1.10   mycroft 	if (!(flags & RTF_DONE) && rt &&
    860  1.115      yamt 	     (sockaddr_cmp(src, rt->rt_gateway) != 0 || rt->rt_ifa != ifa))
    861    1.1       cgd 		error = EINVAL;
    862  1.173     ozaki 	else {
    863  1.173     ozaki 		int s = pserialize_read_enter();
    864  1.173     ozaki 		struct ifaddr *_ifa;
    865  1.173     ozaki 
    866  1.173     ozaki 		_ifa = ifa_ifwithaddr(gateway);
    867  1.173     ozaki 		if (_ifa != NULL)
    868  1.173     ozaki 			error = EHOSTUNREACH;
    869  1.173     ozaki 		pserialize_read_exit(s);
    870  1.173     ozaki 	}
    871    1.1       cgd 	if (error)
    872    1.1       cgd 		goto done;
    873    1.1       cgd 	/*
    874    1.1       cgd 	 * Create a new entry if we just got back a wildcard entry
    875   1.33     soren 	 * or the lookup failed.  This is necessary for hosts
    876    1.1       cgd 	 * which use routing redirects generated by smart gateways
    877    1.1       cgd 	 * to dynamically build the routing tables.
    878    1.1       cgd 	 */
    879   1.95    dyoung 	if (rt == NULL || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
    880    1.1       cgd 		goto create;
    881    1.1       cgd 	/*
    882    1.1       cgd 	 * Don't listen to the redirect if it's
    883   1.65     perry 	 * for a route to an interface.
    884    1.1       cgd 	 */
    885    1.1       cgd 	if (rt->rt_flags & RTF_GATEWAY) {
    886    1.1       cgd 		if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
    887    1.1       cgd 			/*
    888    1.1       cgd 			 * Changing from route to net => route to host.
    889    1.1       cgd 			 * Create new route, rather than smashing route to net.
    890    1.1       cgd 			 */
    891    1.1       cgd 		create:
    892   1.95    dyoung 			if (rt != NULL)
    893  1.183     ozaki 				rt_unref(rt);
    894    1.1       cgd 			flags |=  RTF_GATEWAY | RTF_DYNAMIC;
    895  1.122    kefren 			memset(&info, 0, sizeof(info));
    896   1.39    itojun 			info.rti_info[RTAX_DST] = dst;
    897   1.39    itojun 			info.rti_info[RTAX_GATEWAY] = gateway;
    898   1.39    itojun 			info.rti_info[RTAX_NETMASK] = netmask;
    899   1.39    itojun 			info.rti_ifa = ifa;
    900   1.39    itojun 			info.rti_flags = flags;
    901   1.39    itojun 			rt = NULL;
    902   1.39    itojun 			error = rtrequest1(RTM_ADD, &info, &rt);
    903   1.39    itojun 			if (rt != NULL)
    904   1.39    itojun 				flags = rt->rt_flags;
    905    1.1       cgd 			stat = &rtstat.rts_dynamic;
    906    1.1       cgd 		} else {
    907    1.1       cgd 			/*
    908    1.1       cgd 			 * Smash the current notion of the gateway to
    909    1.1       cgd 			 * this destination.  Should check about netmask!!!
    910    1.1       cgd 			 */
    911  1.183     ozaki 			/*
    912  1.187     ozaki 			 * FIXME NOMPSAFE: the rtentry is updated with the existence
    913  1.183     ozaki 			 * of refeferences of it.
    914  1.183     ozaki 			 */
    915  1.164     ozaki 			error = rt_setgate(rt, gateway);
    916  1.164     ozaki 			if (error == 0) {
    917  1.164     ozaki 				rt->rt_flags |= RTF_MODIFIED;
    918  1.164     ozaki 				flags |= RTF_MODIFIED;
    919  1.164     ozaki 			}
    920   1.10   mycroft 			stat = &rtstat.rts_newgateway;
    921    1.1       cgd 		}
    922    1.1       cgd 	} else
    923    1.1       cgd 		error = EHOSTUNREACH;
    924    1.1       cgd done:
    925    1.1       cgd 	if (rt) {
    926   1.95    dyoung 		if (rtp != NULL && !error)
    927    1.1       cgd 			*rtp = rt;
    928    1.1       cgd 		else
    929  1.183     ozaki 			rt_unref(rt);
    930    1.1       cgd 	}
    931    1.8       cgd out:
    932    1.1       cgd 	if (error)
    933    1.1       cgd 		rtstat.rts_badredirect++;
    934    1.8       cgd 	else if (stat != NULL)
    935    1.8       cgd 		(*stat)++;
    936   1.95    dyoung 	memset(&info, 0, sizeof(info));
    937   1.10   mycroft 	info.rti_info[RTAX_DST] = dst;
    938   1.10   mycroft 	info.rti_info[RTAX_GATEWAY] = gateway;
    939   1.10   mycroft 	info.rti_info[RTAX_NETMASK] = netmask;
    940   1.10   mycroft 	info.rti_info[RTAX_AUTHOR] = src;
    941   1.10   mycroft 	rt_missmsg(RTM_REDIRECT, &info, flags, error);
    942  1.173     ozaki 	ifa_release(ifa, &psref);
    943    1.1       cgd }
    944    1.1       cgd 
    945    1.1       cgd /*
    946  1.146     ozaki  * Delete a route and generate a message.
    947  1.146     ozaki  * It doesn't free a passed rt.
    948   1.40    itojun  */
    949   1.40    itojun static int
    950   1.60      matt rtdeletemsg(struct rtentry *rt)
    951   1.40    itojun {
    952   1.40    itojun 	int error;
    953   1.40    itojun 	struct rt_addrinfo info;
    954  1.180     ozaki 	struct rtentry *retrt;
    955   1.40    itojun 
    956   1.40    itojun 	/*
    957   1.40    itojun 	 * Request the new route so that the entry is not actually
    958   1.40    itojun 	 * deleted.  That will allow the information being reported to
    959   1.40    itojun 	 * be accurate (and consistent with route_output()).
    960   1.40    itojun 	 */
    961   1.95    dyoung 	memset(&info, 0, sizeof(info));
    962   1.94    dyoung 	info.rti_info[RTAX_DST] = rt_getkey(rt);
    963   1.40    itojun 	info.rti_info[RTAX_NETMASK] = rt_mask(rt);
    964   1.40    itojun 	info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
    965   1.40    itojun 	info.rti_flags = rt->rt_flags;
    966  1.180     ozaki 	error = rtrequest1(RTM_DELETE, &info, &retrt);
    967   1.40    itojun 
    968   1.40    itojun 	rt_missmsg(RTM_DELETE, &info, info.rti_flags, error);
    969   1.40    itojun 
    970   1.95    dyoung 	return error;
    971   1.40    itojun }
    972   1.40    itojun 
    973    1.1       cgd struct ifaddr *
    974  1.173     ozaki ifa_ifwithroute_psref(int flags, const struct sockaddr *dst,
    975  1.173     ozaki 	const struct sockaddr *gateway, struct psref *psref)
    976    1.1       cgd {
    977  1.173     ozaki 	struct ifaddr *ifa = NULL;
    978  1.173     ozaki 
    979    1.1       cgd 	if ((flags & RTF_GATEWAY) == 0) {
    980    1.1       cgd 		/*
    981    1.1       cgd 		 * If we are adding a route to an interface,
    982    1.1       cgd 		 * and the interface is a pt to pt link
    983    1.1       cgd 		 * we should search for the destination
    984    1.1       cgd 		 * as our clue to the interface.  Otherwise
    985    1.1       cgd 		 * we can use the local address.
    986    1.1       cgd 		 */
    987  1.127  christos 		if ((flags & RTF_HOST) && gateway->sa_family != AF_LINK)
    988  1.173     ozaki 			ifa = ifa_ifwithdstaddr_psref(dst, psref);
    989   1.68  christos 		if (ifa == NULL)
    990  1.173     ozaki 			ifa = ifa_ifwithaddr_psref(gateway, psref);
    991    1.1       cgd 	} else {
    992    1.1       cgd 		/*
    993    1.1       cgd 		 * If we are adding a route to a remote net
    994    1.1       cgd 		 * or host, the gateway may still be on the
    995    1.1       cgd 		 * other end of a pt to pt link.
    996    1.1       cgd 		 */
    997  1.173     ozaki 		ifa = ifa_ifwithdstaddr_psref(gateway, psref);
    998    1.1       cgd 	}
    999   1.68  christos 	if (ifa == NULL)
   1000  1.173     ozaki 		ifa = ifa_ifwithnet_psref(gateway, psref);
   1001   1.68  christos 	if (ifa == NULL) {
   1002  1.173     ozaki 		int s;
   1003  1.173     ozaki 		struct rtentry *rt;
   1004  1.173     ozaki 
   1005  1.173     ozaki 		rt = rtalloc1(dst, 0);
   1006   1.68  christos 		if (rt == NULL)
   1007   1.68  christos 			return NULL;
   1008  1.173     ozaki 		/*
   1009  1.173     ozaki 		 * Just in case. May not need to do this workaround.
   1010  1.173     ozaki 		 * Revisit when working on rtentry MP-ification.
   1011  1.173     ozaki 		 */
   1012  1.173     ozaki 		s = pserialize_read_enter();
   1013  1.173     ozaki 		IFADDR_READER_FOREACH(ifa, rt->rt_ifp) {
   1014  1.173     ozaki 			if (ifa == rt->rt_ifa)
   1015  1.173     ozaki 				break;
   1016  1.173     ozaki 		}
   1017  1.173     ozaki 		if (ifa != NULL)
   1018  1.173     ozaki 			ifa_acquire(ifa, psref);
   1019  1.173     ozaki 		pserialize_read_exit(s);
   1020  1.183     ozaki 		rt_unref(rt);
   1021  1.146     ozaki 		if (ifa == NULL)
   1022   1.68  christos 			return NULL;
   1023    1.1       cgd 	}
   1024    1.1       cgd 	if (ifa->ifa_addr->sa_family != dst->sa_family) {
   1025  1.173     ozaki 		struct ifaddr *nifa;
   1026  1.173     ozaki 		int s;
   1027  1.173     ozaki 
   1028  1.173     ozaki 		s = pserialize_read_enter();
   1029  1.173     ozaki 		nifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
   1030  1.173     ozaki 		if (nifa != NULL) {
   1031  1.173     ozaki 			ifa_release(ifa, psref);
   1032  1.173     ozaki 			ifa_acquire(nifa, psref);
   1033  1.173     ozaki 			ifa = nifa;
   1034  1.173     ozaki 		}
   1035  1.173     ozaki 		pserialize_read_exit(s);
   1036    1.1       cgd 	}
   1037   1.95    dyoung 	return ifa;
   1038    1.1       cgd }
   1039    1.1       cgd 
   1040  1.146     ozaki /*
   1041  1.146     ozaki  * If it suceeds and ret_nrt isn't NULL, refcnt of ret_nrt is incremented.
   1042  1.146     ozaki  * The caller has to rtfree it by itself.
   1043  1.146     ozaki  */
   1044    1.9   mycroft int
   1045   1.60      matt rtrequest(int req, const struct sockaddr *dst, const struct sockaddr *gateway,
   1046   1.60      matt 	const struct sockaddr *netmask, int flags, struct rtentry **ret_nrt)
   1047    1.1       cgd {
   1048   1.39    itojun 	struct rt_addrinfo info;
   1049   1.39    itojun 
   1050   1.44   thorpej 	memset(&info, 0, sizeof(info));
   1051   1.39    itojun 	info.rti_flags = flags;
   1052   1.39    itojun 	info.rti_info[RTAX_DST] = dst;
   1053   1.39    itojun 	info.rti_info[RTAX_GATEWAY] = gateway;
   1054   1.39    itojun 	info.rti_info[RTAX_NETMASK] = netmask;
   1055   1.39    itojun 	return rtrequest1(req, &info, ret_nrt);
   1056   1.39    itojun }
   1057   1.39    itojun 
   1058  1.146     ozaki /*
   1059  1.146     ozaki  * It's a utility function to add/remove a route to/from the routing table
   1060  1.146     ozaki  * and tell user processes the addition/removal on success.
   1061  1.146     ozaki  */
   1062  1.146     ozaki int
   1063  1.146     ozaki rtrequest_newmsg(const int req, const struct sockaddr *dst,
   1064  1.146     ozaki 	const struct sockaddr *gateway, const struct sockaddr *netmask,
   1065  1.146     ozaki 	const int flags)
   1066  1.146     ozaki {
   1067  1.146     ozaki 	int error;
   1068  1.146     ozaki 	struct rtentry *ret_nrt = NULL;
   1069  1.146     ozaki 
   1070  1.146     ozaki 	KASSERT(req == RTM_ADD || req == RTM_DELETE);
   1071  1.146     ozaki 
   1072  1.146     ozaki 	error = rtrequest(req, dst, gateway, netmask, flags, &ret_nrt);
   1073  1.146     ozaki 	if (error != 0)
   1074  1.146     ozaki 		return error;
   1075  1.146     ozaki 
   1076  1.146     ozaki 	KASSERT(ret_nrt != NULL);
   1077  1.146     ozaki 
   1078  1.146     ozaki 	rt_newmsg(req, ret_nrt); /* tell user process */
   1079  1.183     ozaki 	if (req == RTM_DELETE)
   1080  1.183     ozaki 		rt_free(ret_nrt);
   1081  1.183     ozaki 	else
   1082  1.183     ozaki 		rt_unref(ret_nrt);
   1083  1.146     ozaki 
   1084  1.146     ozaki 	return 0;
   1085  1.146     ozaki }
   1086  1.146     ozaki 
   1087  1.173     ozaki struct ifnet *
   1088  1.173     ozaki rt_getifp(struct rt_addrinfo *info, struct psref *psref)
   1089   1.39    itojun {
   1090   1.68  christos 	const struct sockaddr *ifpaddr = info->rti_info[RTAX_IFP];
   1091   1.39    itojun 
   1092  1.173     ozaki 	if (info->rti_ifp != NULL)
   1093  1.173     ozaki 		return NULL;
   1094   1.39    itojun 	/*
   1095   1.39    itojun 	 * ifp may be specified by sockaddr_dl when protocol address
   1096   1.39    itojun 	 * is ambiguous
   1097   1.39    itojun 	 */
   1098  1.173     ozaki 	if (ifpaddr != NULL && ifpaddr->sa_family == AF_LINK) {
   1099  1.173     ozaki 		struct ifaddr *ifa;
   1100  1.173     ozaki 		int s = pserialize_read_enter();
   1101  1.173     ozaki 
   1102  1.173     ozaki 		ifa = ifa_ifwithnet(ifpaddr);
   1103  1.173     ozaki 		if (ifa != NULL)
   1104  1.173     ozaki 			info->rti_ifp = if_get_byindex(ifa->ifa_ifp->if_index,
   1105  1.173     ozaki 			    psref);
   1106  1.173     ozaki 		pserialize_read_exit(s);
   1107   1.39    itojun 	}
   1108  1.173     ozaki 
   1109  1.173     ozaki 	return info->rti_ifp;
   1110  1.173     ozaki }
   1111  1.173     ozaki 
   1112  1.173     ozaki struct ifaddr *
   1113  1.173     ozaki rt_getifa(struct rt_addrinfo *info, struct psref *psref)
   1114  1.173     ozaki {
   1115  1.174     ozaki 	struct ifaddr *ifa = NULL;
   1116  1.173     ozaki 	const struct sockaddr *dst = info->rti_info[RTAX_DST];
   1117  1.173     ozaki 	const struct sockaddr *gateway = info->rti_info[RTAX_GATEWAY];
   1118  1.173     ozaki 	const struct sockaddr *ifaaddr = info->rti_info[RTAX_IFA];
   1119  1.173     ozaki 	int flags = info->rti_flags;
   1120  1.173     ozaki 	const struct sockaddr *sa;
   1121  1.173     ozaki 
   1122  1.173     ozaki 	if (info->rti_ifa == NULL && ifaaddr != NULL) {
   1123  1.173     ozaki 		ifa = ifa_ifwithaddr_psref(ifaaddr, psref);
   1124  1.173     ozaki 		if (ifa != NULL)
   1125  1.173     ozaki 			goto got;
   1126  1.173     ozaki 	}
   1127  1.173     ozaki 
   1128  1.173     ozaki 	sa = ifaaddr != NULL ? ifaaddr :
   1129  1.173     ozaki 	    (gateway != NULL ? gateway : dst);
   1130  1.173     ozaki 	if (sa != NULL && info->rti_ifp != NULL)
   1131  1.173     ozaki 		ifa = ifaof_ifpforaddr_psref(sa, info->rti_ifp, psref);
   1132  1.173     ozaki 	else if (dst != NULL && gateway != NULL)
   1133  1.173     ozaki 		ifa = ifa_ifwithroute_psref(flags, dst, gateway, psref);
   1134  1.173     ozaki 	else if (sa != NULL)
   1135  1.173     ozaki 		ifa = ifa_ifwithroute_psref(flags, sa, sa, psref);
   1136  1.173     ozaki 	if (ifa == NULL)
   1137  1.173     ozaki 		return NULL;
   1138  1.173     ozaki got:
   1139  1.145       roy 	if (ifa->ifa_getifa != NULL) {
   1140  1.173     ozaki 		/* FIXME NOMPSAFE */
   1141  1.173     ozaki 		ifa = (*ifa->ifa_getifa)(ifa, dst);
   1142  1.145       roy 		if (ifa == NULL)
   1143  1.173     ozaki 			return NULL;
   1144  1.173     ozaki 		ifa_acquire(ifa, psref);
   1145  1.145       roy 	}
   1146  1.173     ozaki 	info->rti_ifa = ifa;
   1147   1.74    dyoung 	if (info->rti_ifp == NULL)
   1148   1.74    dyoung 		info->rti_ifp = ifa->ifa_ifp;
   1149  1.173     ozaki 	return ifa;
   1150   1.39    itojun }
   1151   1.39    itojun 
   1152  1.146     ozaki /*
   1153  1.146     ozaki  * If it suceeds and ret_nrt isn't NULL, refcnt of ret_nrt is incremented.
   1154  1.146     ozaki  * The caller has to rtfree it by itself.
   1155  1.146     ozaki  */
   1156   1.39    itojun int
   1157   1.60      matt rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt)
   1158   1.39    itojun {
   1159  1.173     ozaki 	int s = splsoftnet(), ss;
   1160  1.125    dyoung 	int error = 0, rc;
   1161  1.158     ozaki 	struct rtentry *rt;
   1162  1.125    dyoung 	rtbl_t *rtbl;
   1163  1.173     ozaki 	struct ifaddr *ifa = NULL, *ifa2 = NULL;
   1164   1.94    dyoung 	struct sockaddr_storage maskeddst;
   1165   1.68  christos 	const struct sockaddr *dst = info->rti_info[RTAX_DST];
   1166   1.68  christos 	const struct sockaddr *gateway = info->rti_info[RTAX_GATEWAY];
   1167   1.68  christos 	const struct sockaddr *netmask = info->rti_info[RTAX_NETMASK];
   1168   1.68  christos 	int flags = info->rti_flags;
   1169  1.173     ozaki 	struct psref psref_ifp, psref_ifa;
   1170  1.173     ozaki 	int bound = 0;
   1171  1.173     ozaki 	struct ifnet *ifp = NULL;
   1172  1.173     ozaki 	bool need_to_release_ifa = true;
   1173  1.183     ozaki 	bool need_unlock = true;
   1174    1.1       cgd #define senderr(x) { error = x ; goto bad; }
   1175    1.1       cgd 
   1176  1.183     ozaki 	RT_WLOCK();
   1177  1.183     ozaki 
   1178  1.173     ozaki 	bound = curlwp_bind();
   1179  1.125    dyoung 	if ((rtbl = rt_gettable(dst->sa_family)) == NULL)
   1180    1.1       cgd 		senderr(ESRCH);
   1181    1.1       cgd 	if (flags & RTF_HOST)
   1182   1.68  christos 		netmask = NULL;
   1183    1.1       cgd 	switch (req) {
   1184    1.1       cgd 	case RTM_DELETE:
   1185   1.63  christos 		if (netmask) {
   1186   1.94    dyoung 			rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
   1187   1.94    dyoung 			    netmask);
   1188   1.94    dyoung 			dst = (struct sockaddr *)&maskeddst;
   1189   1.63  christos 		}
   1190  1.125    dyoung 		if ((rt = rt_lookup(rtbl, dst, netmask)) == NULL)
   1191   1.41    itojun 			senderr(ESRCH);
   1192  1.125    dyoung 		if ((rt = rt_deladdr(rtbl, dst, netmask)) == NULL)
   1193    1.1       cgd 			senderr(ESRCH);
   1194   1.28       erh 		rt->rt_flags &= ~RTF_UP;
   1195  1.116       roy 		if ((ifa = rt->rt_ifa)) {
   1196  1.116       roy 			if (ifa->ifa_flags & IFA_ROUTE &&
   1197  1.116       roy 			    rt_ifa_connected(rt, ifa)) {
   1198  1.116       roy 				RT_DPRINTF("rt->_rt_key = %p, ifa = %p, "
   1199  1.116       roy 				    "deleted IFA_ROUTE\n",
   1200  1.116       roy 				    (void *)rt->_rt_key, (void *)ifa);
   1201  1.116       roy 				ifa->ifa_flags &= ~IFA_ROUTE;
   1202  1.116       roy 			}
   1203  1.116       roy 			if (ifa->ifa_rtrequest)
   1204  1.116       roy 				ifa->ifa_rtrequest(RTM_DELETE, rt, info);
   1205  1.173     ozaki 			ifa = NULL;
   1206  1.116       roy 		}
   1207    1.1       cgd 		rttrash++;
   1208  1.146     ozaki 		if (ret_nrt) {
   1209   1.10   mycroft 			*ret_nrt = rt;
   1210  1.183     ozaki 			rt_ref(rt);
   1211  1.183     ozaki 			RT_REFCNT_TRACE(rt);
   1212  1.183     ozaki 		}
   1213  1.183     ozaki 		RT_UNLOCK();
   1214  1.183     ozaki 		need_unlock = false;
   1215  1.183     ozaki 		rt_timer_remove_all(rt);
   1216  1.183     ozaki 		rtcache_clear_rtentry(dst->sa_family, rt);
   1217  1.183     ozaki 		if (ret_nrt == NULL) {
   1218  1.146     ozaki 			/* Adjust the refcount */
   1219  1.183     ozaki 			rt_ref(rt);
   1220  1.183     ozaki 			RT_REFCNT_TRACE(rt);
   1221  1.183     ozaki 			rt_free(rt);
   1222   1.10   mycroft 		}
   1223    1.1       cgd 		break;
   1224    1.1       cgd 
   1225    1.1       cgd 	case RTM_ADD:
   1226  1.173     ozaki 		if (info->rti_ifa == NULL) {
   1227  1.173     ozaki 			ifp = rt_getifp(info, &psref_ifp);
   1228  1.173     ozaki 			ifa = rt_getifa(info, &psref_ifa);
   1229  1.173     ozaki 			if (ifa == NULL)
   1230  1.173     ozaki 				senderr(ENETUNREACH);
   1231  1.173     ozaki 		} else {
   1232  1.173     ozaki 			/* Caller should have a reference of ifa */
   1233  1.173     ozaki 			ifa = info->rti_ifa;
   1234  1.173     ozaki 			need_to_release_ifa = false;
   1235  1.173     ozaki 		}
   1236   1.22   thorpej 		rt = pool_get(&rtentry_pool, PR_NOWAIT);
   1237   1.68  christos 		if (rt == NULL)
   1238    1.1       cgd 			senderr(ENOBUFS);
   1239  1.109    dyoung 		memset(rt, 0, sizeof(*rt));
   1240   1.10   mycroft 		rt->rt_flags = RTF_UP | flags;
   1241   1.18       kml 		LIST_INIT(&rt->rt_timer);
   1242  1.163     ozaki 
   1243  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1244    1.1       cgd 		if (netmask) {
   1245   1.94    dyoung 			rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
   1246   1.94    dyoung 			    netmask);
   1247   1.96    dyoung 			rt_setkey(rt, (struct sockaddr *)&maskeddst, M_NOWAIT);
   1248   1.94    dyoung 		} else {
   1249   1.96    dyoung 			rt_setkey(rt, dst, M_NOWAIT);
   1250   1.94    dyoung 		}
   1251  1.163     ozaki 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1252  1.163     ozaki 		if (rt_getkey(rt) == NULL ||
   1253  1.163     ozaki 		    rt_setgate(rt, gateway) != 0) {
   1254  1.163     ozaki 			pool_put(&rtentry_pool, rt);
   1255  1.163     ozaki 			senderr(ENOBUFS);
   1256  1.163     ozaki 		}
   1257  1.163     ozaki 
   1258   1.74    dyoung 		rt_set_ifa(rt, ifa);
   1259  1.164     ozaki 		if (info->rti_info[RTAX_TAG] != NULL) {
   1260  1.164     ozaki 			const struct sockaddr *tag;
   1261  1.164     ozaki 			tag = rt_settag(rt, info->rti_info[RTAX_TAG]);
   1262  1.164     ozaki 			if (tag == NULL)
   1263  1.164     ozaki 				senderr(ENOBUFS);
   1264  1.164     ozaki 		}
   1265  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1266  1.173     ozaki 
   1267  1.173     ozaki 		ss = pserialize_read_enter();
   1268  1.173     ozaki 		if (info->rti_info[RTAX_IFP] != NULL) {
   1269  1.173     ozaki 			ifa2 = ifa_ifwithnet(info->rti_info[RTAX_IFP]);
   1270  1.173     ozaki 			if (ifa2 != NULL)
   1271  1.173     ozaki 				rt->rt_ifp = ifa2->ifa_ifp;
   1272  1.173     ozaki 			else
   1273  1.173     ozaki 				rt->rt_ifp = ifa->ifa_ifp;
   1274  1.173     ozaki 		} else
   1275  1.122    kefren 			rt->rt_ifp = ifa->ifa_ifp;
   1276  1.173     ozaki 		pserialize_read_exit(ss);
   1277  1.183     ozaki 		cv_init(&rt->rt_cv, "rtentry");
   1278  1.183     ozaki 		psref_target_init(&rt->rt_psref, rt_psref_class);
   1279  1.173     ozaki 
   1280  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1281  1.125    dyoung 		rc = rt_addaddr(rtbl, rt, netmask);
   1282  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1283  1.125    dyoung 		if (rc != 0) {
   1284  1.173     ozaki 			ifafree(ifa); /* for rt_set_ifa above */
   1285  1.183     ozaki 			cv_destroy(&rt->rt_cv);
   1286   1.94    dyoung 			rt_destroy(rt);
   1287   1.40    itojun 			pool_put(&rtentry_pool, rt);
   1288  1.125    dyoung 			senderr(rc);
   1289   1.27      matt 		}
   1290  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1291    1.1       cgd 		if (ifa->ifa_rtrequest)
   1292   1.39    itojun 			ifa->ifa_rtrequest(req, rt, info);
   1293  1.173     ozaki 		if (need_to_release_ifa)
   1294  1.173     ozaki 			ifa_release(ifa, &psref_ifa);
   1295  1.173     ozaki 		ifa = NULL;
   1296  1.173     ozaki 		if_put(ifp, &psref_ifp);
   1297  1.173     ozaki 		ifp = NULL;
   1298  1.110    dyoung 		RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1299    1.1       cgd 		if (ret_nrt) {
   1300    1.1       cgd 			*ret_nrt = rt;
   1301  1.183     ozaki 			rt_ref(rt);
   1302  1.183     ozaki 			RT_REFCNT_TRACE(rt);
   1303   1.41    itojun 		}
   1304  1.183     ozaki 		RT_UNLOCK();
   1305  1.183     ozaki 		need_unlock = false;
   1306   1.82    dyoung 		rtflushall(dst->sa_family);
   1307    1.1       cgd 		break;
   1308   1.92    dyoung 	case RTM_GET:
   1309   1.94    dyoung 		if (netmask != NULL) {
   1310   1.94    dyoung 			rt_maskedcopy(dst, (struct sockaddr *)&maskeddst,
   1311   1.94    dyoung 			    netmask);
   1312   1.94    dyoung 			dst = (struct sockaddr *)&maskeddst;
   1313   1.94    dyoung 		}
   1314  1.125    dyoung 		if ((rt = rt_lookup(rtbl, dst, netmask)) == NULL)
   1315   1.92    dyoung 			senderr(ESRCH);
   1316   1.92    dyoung 		if (ret_nrt != NULL) {
   1317   1.92    dyoung 			*ret_nrt = rt;
   1318  1.183     ozaki 			rt_ref(rt);
   1319  1.183     ozaki 			RT_REFCNT_TRACE(rt);
   1320   1.92    dyoung 		}
   1321   1.92    dyoung 		break;
   1322    1.1       cgd 	}
   1323    1.1       cgd bad:
   1324  1.173     ozaki 	if (need_to_release_ifa)
   1325  1.173     ozaki 		ifa_release(ifa, &psref_ifa);
   1326  1.173     ozaki 	if_put(ifp, &psref_ifp);
   1327  1.173     ozaki 	curlwp_bindx(bound);
   1328  1.183     ozaki 	if (need_unlock)
   1329  1.183     ozaki 		RT_UNLOCK();
   1330    1.1       cgd 	splx(s);
   1331   1.95    dyoung 	return error;
   1332    1.1       cgd }
   1333    1.1       cgd 
   1334   1.10   mycroft int
   1335   1.94    dyoung rt_setgate(struct rtentry *rt, const struct sockaddr *gate)
   1336   1.10   mycroft {
   1337  1.176     ozaki 	struct sockaddr *new, *old;
   1338   1.94    dyoung 
   1339   1.94    dyoung 	KASSERT(rt->_rt_key != NULL);
   1340  1.110    dyoung 	RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1341   1.94    dyoung 
   1342  1.176     ozaki 	new = sockaddr_dup(gate, M_ZERO | M_NOWAIT);
   1343  1.176     ozaki 	if (new == NULL)
   1344   1.94    dyoung 		return ENOMEM;
   1345  1.176     ozaki 
   1346  1.176     ozaki 	old = rt->rt_gateway;
   1347  1.176     ozaki 	rt->rt_gateway = new;
   1348  1.176     ozaki 	if (old != NULL)
   1349  1.176     ozaki 		sockaddr_free(old);
   1350  1.176     ozaki 
   1351   1.94    dyoung 	KASSERT(rt->_rt_key != NULL);
   1352  1.110    dyoung 	RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1353   1.94    dyoung 
   1354   1.10   mycroft 	if (rt->rt_flags & RTF_GATEWAY) {
   1355  1.183     ozaki 		struct rtentry *gwrt;
   1356  1.183     ozaki 
   1357  1.183     ozaki 		/* XXX we cannot call rtalloc1 if holding the rt lock */
   1358  1.183     ozaki 		if (RT_LOCKED())
   1359  1.183     ozaki 			gwrt = rtalloc1_locked(gate, 1, false);
   1360  1.183     ozaki 		else
   1361  1.183     ozaki 			gwrt = rtalloc1(gate, 1);
   1362   1.27      matt 		/*
   1363   1.27      matt 		 * If we switched gateways, grab the MTU from the new
   1364   1.47    itojun 		 * gateway route if the current MTU, if the current MTU is
   1365   1.47    itojun 		 * greater than the MTU of gateway.
   1366   1.47    itojun 		 * Note that, if the MTU of gateway is 0, we will reset the
   1367   1.47    itojun 		 * MTU of the route to run PMTUD again from scratch. XXX
   1368   1.27      matt 		 */
   1369  1.166     ozaki 		if (gwrt != NULL) {
   1370  1.166     ozaki 			KASSERT(gwrt->_rt_key != NULL);
   1371  1.166     ozaki 			RT_DPRINTF("gwrt->_rt_key = %p\n", gwrt->_rt_key);
   1372  1.166     ozaki 			if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
   1373  1.166     ozaki 			    rt->rt_rmx.rmx_mtu &&
   1374  1.166     ozaki 			    rt->rt_rmx.rmx_mtu > gwrt->rt_rmx.rmx_mtu) {
   1375  1.166     ozaki 				rt->rt_rmx.rmx_mtu = gwrt->rt_rmx.rmx_mtu;
   1376  1.166     ozaki 			}
   1377  1.183     ozaki 			rt_unref(gwrt);
   1378   1.27      matt 		}
   1379   1.10   mycroft 	}
   1380   1.94    dyoung 	KASSERT(rt->_rt_key != NULL);
   1381  1.110    dyoung 	RT_DPRINTF("rt->_rt_key = %p\n", (void *)rt->_rt_key);
   1382   1.10   mycroft 	return 0;
   1383   1.10   mycroft }
   1384   1.10   mycroft 
   1385  1.141     ozaki static void
   1386   1.60      matt rt_maskedcopy(const struct sockaddr *src, struct sockaddr *dst,
   1387   1.60      matt 	const struct sockaddr *netmask)
   1388    1.1       cgd {
   1389   1.94    dyoung 	const char *netmaskp = &netmask->sa_data[0],
   1390   1.94    dyoung 	           *srcp = &src->sa_data[0];
   1391   1.94    dyoung 	char *dstp = &dst->sa_data[0];
   1392  1.126  christos 	const char *maskend = (char *)dst + MIN(netmask->sa_len, src->sa_len);
   1393  1.126  christos 	const char *srcend = (char *)dst + src->sa_len;
   1394   1.94    dyoung 
   1395   1.94    dyoung 	dst->sa_len = src->sa_len;
   1396   1.94    dyoung 	dst->sa_family = src->sa_family;
   1397   1.94    dyoung 
   1398   1.94    dyoung 	while (dstp < maskend)
   1399   1.94    dyoung 		*dstp++ = *srcp++ & *netmaskp++;
   1400   1.94    dyoung 	if (dstp < srcend)
   1401   1.94    dyoung 		memset(dstp, 0, (size_t)(srcend - dstp));
   1402    1.1       cgd }
   1403   1.10   mycroft 
   1404    1.1       cgd /*
   1405  1.135       roy  * Inform the routing socket of a route change.
   1406  1.135       roy  */
   1407  1.135       roy void
   1408  1.154     ozaki rt_newmsg(const int cmd, const struct rtentry *rt)
   1409  1.135       roy {
   1410  1.135       roy 	struct rt_addrinfo info;
   1411  1.135       roy 
   1412  1.135       roy 	memset((void *)&info, 0, sizeof(info));
   1413  1.135       roy 	info.rti_info[RTAX_DST] = rt_getkey(rt);
   1414  1.135       roy 	info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
   1415  1.135       roy 	info.rti_info[RTAX_NETMASK] = rt_mask(rt);
   1416  1.135       roy 	if (rt->rt_ifp) {
   1417  1.135       roy 		info.rti_info[RTAX_IFP] = rt->rt_ifp->if_dl->ifa_addr;
   1418  1.135       roy 		info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
   1419  1.135       roy 	}
   1420  1.135       roy 
   1421  1.135       roy 	rt_missmsg(cmd, &info, rt->rt_flags, 0);
   1422  1.135       roy }
   1423  1.135       roy 
   1424  1.135       roy /*
   1425   1.29  sommerfe  * Set up or tear down a routing table entry, normally
   1426    1.1       cgd  * for an interface.
   1427    1.1       cgd  */
   1428    1.9   mycroft int
   1429   1.60      matt rtinit(struct ifaddr *ifa, int cmd, int flags)
   1430    1.1       cgd {
   1431   1.36  augustss 	struct rtentry *rt;
   1432   1.36  augustss 	struct sockaddr *dst, *odst;
   1433   1.94    dyoung 	struct sockaddr_storage maskeddst;
   1434   1.68  christos 	struct rtentry *nrt = NULL;
   1435    1.1       cgd 	int error;
   1436   1.39    itojun 	struct rt_addrinfo info;
   1437    1.1       cgd 
   1438    1.1       cgd 	dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
   1439    1.1       cgd 	if (cmd == RTM_DELETE) {
   1440    1.1       cgd 		if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
   1441   1.29  sommerfe 			/* Delete subnet route for this interface */
   1442   1.29  sommerfe 			odst = dst;
   1443   1.94    dyoung 			dst = (struct sockaddr *)&maskeddst;
   1444   1.29  sommerfe 			rt_maskedcopy(odst, dst, ifa->ifa_netmask);
   1445    1.1       cgd 		}
   1446   1.14  christos 		if ((rt = rtalloc1(dst, 0)) != NULL) {
   1447  1.146     ozaki 			if (rt->rt_ifa != ifa) {
   1448  1.183     ozaki 				rt_unref(rt);
   1449   1.85    dyoung 				return (flags & RTF_HOST) ? EHOSTUNREACH
   1450   1.85    dyoung 							: ENETUNREACH;
   1451  1.146     ozaki 			}
   1452  1.183     ozaki 			rt_unref(rt);
   1453    1.1       cgd 		}
   1454    1.1       cgd 	}
   1455   1.44   thorpej 	memset(&info, 0, sizeof(info));
   1456   1.39    itojun 	info.rti_ifa = ifa;
   1457   1.39    itojun 	info.rti_flags = flags | ifa->ifa_flags;
   1458   1.39    itojun 	info.rti_info[RTAX_DST] = dst;
   1459   1.39    itojun 	info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
   1460  1.158     ozaki 
   1461   1.39    itojun 	/*
   1462   1.39    itojun 	 * XXX here, it seems that we are assuming that ifa_netmask is NULL
   1463   1.39    itojun 	 * for RTF_HOST.  bsdi4 passes NULL explicitly (via intermediate
   1464   1.39    itojun 	 * variable) when RTF_HOST is 1.  still not sure if i can safely
   1465   1.39    itojun 	 * change it to meet bsdi4 behavior.
   1466   1.39    itojun 	 */
   1467  1.114    dyoung 	if (cmd != RTM_LLINFO_UPD)
   1468  1.114    dyoung 		info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
   1469  1.114    dyoung 	error = rtrequest1((cmd == RTM_LLINFO_UPD) ? RTM_GET : cmd, &info,
   1470  1.114    dyoung 	    &nrt);
   1471  1.153     ozaki 	if (error != 0)
   1472  1.146     ozaki 		return error;
   1473  1.146     ozaki 
   1474  1.153     ozaki 	rt = nrt;
   1475  1.183     ozaki 	RT_REFCNT_TRACE(rt);
   1476  1.146     ozaki 	switch (cmd) {
   1477  1.114    dyoung 	case RTM_DELETE:
   1478  1.146     ozaki 		rt_newmsg(cmd, rt);
   1479  1.183     ozaki 		rt_free(rt);
   1480  1.114    dyoung 		break;
   1481  1.114    dyoung 	case RTM_LLINFO_UPD:
   1482  1.114    dyoung 		if (cmd == RTM_LLINFO_UPD && ifa->ifa_rtrequest != NULL)
   1483  1.114    dyoung 			ifa->ifa_rtrequest(RTM_LLINFO_UPD, rt, &info);
   1484  1.146     ozaki 		rt_newmsg(RTM_CHANGE, rt);
   1485  1.183     ozaki 		rt_unref(rt);
   1486  1.114    dyoung 		break;
   1487  1.114    dyoung 	case RTM_ADD:
   1488  1.183     ozaki 		/*
   1489  1.187     ozaki 		 * FIXME NOMPSAFE: the rtentry is updated with the existence
   1490  1.183     ozaki 		 * of refeferences of it.
   1491  1.183     ozaki 		 */
   1492  1.183     ozaki 		/*
   1493  1.183     ozaki 		 * XXX it looks just reverting rt_ifa replaced by ifa_rtrequest
   1494  1.183     ozaki 		 * called via rtrequest1. Can we just prevent the replacement
   1495  1.183     ozaki 		 * somehow and remove the following code? And also doesn't
   1496  1.183     ozaki 		 * calling ifa_rtrequest(RTM_ADD) replace rt_ifa again?
   1497  1.183     ozaki 		 */
   1498   1.10   mycroft 		if (rt->rt_ifa != ifa) {
   1499   1.17  christos 			printf("rtinit: wrong ifa (%p) was (%p)\n", ifa,
   1500   1.17  christos 				rt->rt_ifa);
   1501  1.114    dyoung 			if (rt->rt_ifa->ifa_rtrequest != NULL) {
   1502  1.114    dyoung 				rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt,
   1503  1.114    dyoung 				    &info);
   1504  1.114    dyoung 			}
   1505   1.74    dyoung 			rt_replace_ifa(rt, ifa);
   1506   1.10   mycroft 			rt->rt_ifp = ifa->ifa_ifp;
   1507  1.114    dyoung 			if (ifa->ifa_rtrequest != NULL)
   1508  1.114    dyoung 				ifa->ifa_rtrequest(RTM_ADD, rt, &info);
   1509   1.10   mycroft 		}
   1510  1.146     ozaki 		rt_newmsg(cmd, rt);
   1511  1.183     ozaki 		rt_unref(rt);
   1512  1.183     ozaki 		RT_REFCNT_TRACE(rt);
   1513  1.114    dyoung 		break;
   1514    1.1       cgd 	}
   1515   1.85    dyoung 	return error;
   1516   1.18       kml }
   1517   1.18       kml 
   1518  1.136       roy /*
   1519  1.136       roy  * Create a local route entry for the address.
   1520  1.136       roy  * Announce the addition of the address and the route to the routing socket.
   1521  1.136       roy  */
   1522  1.136       roy int
   1523  1.136       roy rt_ifa_addlocal(struct ifaddr *ifa)
   1524  1.136       roy {
   1525  1.136       roy 	struct rtentry *rt;
   1526  1.136       roy 	int e;
   1527  1.136       roy 
   1528  1.136       roy 	/* If there is no loopback entry, allocate one. */
   1529  1.136       roy 	rt = rtalloc1(ifa->ifa_addr, 0);
   1530  1.158     ozaki #ifdef RT_DEBUG
   1531  1.158     ozaki 	if (rt != NULL)
   1532  1.158     ozaki 		dump_rt(rt);
   1533  1.158     ozaki #endif
   1534  1.136       roy 	if (rt == NULL || (rt->rt_flags & RTF_HOST) == 0 ||
   1535  1.136       roy 	    (rt->rt_ifp->if_flags & IFF_LOOPBACK) == 0)
   1536  1.152       roy 	{
   1537  1.152       roy 		struct rt_addrinfo info;
   1538  1.152       roy 		struct rtentry *nrt;
   1539  1.152       roy 
   1540  1.152       roy 		memset(&info, 0, sizeof(info));
   1541  1.152       roy 		info.rti_flags = RTF_HOST | RTF_LOCAL;
   1542  1.152       roy 		if (!(ifa->ifa_ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)))
   1543  1.158     ozaki 			info.rti_flags |= RTF_LLDATA;
   1544  1.152       roy 		info.rti_info[RTAX_DST] = ifa->ifa_addr;
   1545  1.152       roy 		info.rti_info[RTAX_GATEWAY] =
   1546  1.152       roy 		    (const struct sockaddr *)ifa->ifa_ifp->if_sadl;
   1547  1.152       roy 		info.rti_ifa = ifa;
   1548  1.152       roy 		nrt = NULL;
   1549  1.152       roy 		e = rtrequest1(RTM_ADD, &info, &nrt);
   1550  1.152       roy 		if (nrt && ifa != nrt->rt_ifa)
   1551  1.152       roy 			rt_replace_ifa(nrt, ifa);
   1552  1.152       roy 		rt_newaddrmsg(RTM_ADD, ifa, e, nrt);
   1553  1.158     ozaki 		if (nrt != NULL) {
   1554  1.158     ozaki #ifdef RT_DEBUG
   1555  1.158     ozaki 			dump_rt(nrt);
   1556  1.158     ozaki #endif
   1557  1.183     ozaki 			rt_unref(nrt);
   1558  1.183     ozaki 			RT_REFCNT_TRACE(nrt);
   1559  1.158     ozaki 		}
   1560  1.152       roy 	} else {
   1561  1.136       roy 		e = 0;
   1562  1.136       roy 		rt_newaddrmsg(RTM_NEWADDR, ifa, 0, NULL);
   1563  1.136       roy 	}
   1564  1.136       roy 	if (rt != NULL)
   1565  1.183     ozaki 		rt_unref(rt);
   1566  1.136       roy 	return e;
   1567  1.136       roy }
   1568  1.136       roy 
   1569  1.136       roy /*
   1570  1.136       roy  * Remove the local route entry for the address.
   1571  1.136       roy  * Announce the removal of the address and the route to the routing socket.
   1572  1.136       roy  */
   1573  1.136       roy int
   1574  1.136       roy rt_ifa_remlocal(struct ifaddr *ifa, struct ifaddr *alt_ifa)
   1575  1.136       roy {
   1576  1.136       roy 	struct rtentry *rt;
   1577  1.136       roy 	int e = 0;
   1578  1.136       roy 
   1579  1.136       roy 	rt = rtalloc1(ifa->ifa_addr, 0);
   1580  1.136       roy 
   1581  1.136       roy 	/*
   1582  1.136       roy 	 * Before deleting, check if a corresponding loopbacked
   1583  1.136       roy 	 * host route surely exists.  With this check, we can avoid
   1584  1.136       roy 	 * deleting an interface direct route whose destination is
   1585  1.136       roy 	 * the same as the address being removed.  This can happen
   1586  1.136       roy 	 * when removing a subnet-router anycast address on an
   1587  1.136       roy 	 * interface attached to a shared medium.
   1588  1.136       roy 	 */
   1589  1.136       roy 	if (rt != NULL &&
   1590  1.136       roy 	    (rt->rt_flags & RTF_HOST) &&
   1591  1.136       roy 	    (rt->rt_ifp->if_flags & IFF_LOOPBACK))
   1592  1.136       roy 	{
   1593  1.136       roy 		/* If we cannot replace the route's ifaddr with the equivalent
   1594  1.136       roy 		 * ifaddr of another interface, I believe it is safest to
   1595  1.136       roy 		 * delete the route.
   1596  1.136       roy 		 */
   1597  1.152       roy 		if (alt_ifa == NULL) {
   1598  1.152       roy 			e = rtdeletemsg(rt);
   1599  1.183     ozaki 			if (e == 0) {
   1600  1.183     ozaki 				rt_unref(rt);
   1601  1.183     ozaki 				rt_free(rt);
   1602  1.183     ozaki 				rt = NULL;
   1603  1.183     ozaki 			}
   1604  1.152       roy 			rt_newaddrmsg(RTM_DELADDR, ifa, 0, NULL);
   1605  1.152       roy 		} else {
   1606  1.136       roy 			rt_replace_ifa(rt, alt_ifa);
   1607  1.136       roy 			rt_newmsg(RTM_CHANGE, rt);
   1608  1.136       roy 		}
   1609  1.136       roy 	} else
   1610  1.136       roy 		rt_newaddrmsg(RTM_DELADDR, ifa, 0, NULL);
   1611  1.136       roy 	if (rt != NULL)
   1612  1.183     ozaki 		rt_unref(rt);
   1613  1.136       roy 	return e;
   1614  1.136       roy }
   1615  1.136       roy 
   1616   1.18       kml /*
   1617   1.18       kml  * Route timer routines.  These routes allow functions to be called
   1618   1.18       kml  * for various routes at any time.  This is useful in supporting
   1619   1.18       kml  * path MTU discovery and redirect route deletion.
   1620   1.18       kml  *
   1621   1.18       kml  * This is similar to some BSDI internal functions, but it provides
   1622   1.18       kml  * for multiple queues for efficiency's sake...
   1623   1.18       kml  */
   1624   1.18       kml 
   1625   1.18       kml LIST_HEAD(, rttimer_queue) rttimer_queue_head;
   1626   1.18       kml static int rt_init_done = 0;
   1627   1.18       kml 
   1628   1.65     perry /*
   1629   1.18       kml  * Some subtle order problems with domain initialization mean that
   1630   1.18       kml  * we cannot count on this being run from rt_init before various
   1631   1.18       kml  * protocol initializations are done.  Therefore, we make sure
   1632   1.18       kml  * that this is run when the first queue is added...
   1633   1.18       kml  */
   1634   1.18       kml 
   1635  1.170     ozaki static void rt_timer_work(struct work *, void *);
   1636  1.170     ozaki 
   1637  1.177     ozaki static void
   1638   1.60      matt rt_timer_init(void)
   1639   1.18       kml {
   1640  1.170     ozaki 	int error;
   1641  1.170     ozaki 
   1642   1.18       kml 	assert(rt_init_done == 0);
   1643   1.18       kml 
   1644  1.183     ozaki 	/* XXX should be in rt_init */
   1645  1.183     ozaki 	rw_init(&rt_lock);
   1646  1.183     ozaki 	rw_init(&rtcache_lock);
   1647  1.183     ozaki 
   1648   1.18       kml 	LIST_INIT(&rttimer_queue_head);
   1649  1.172    martin 	callout_init(&rt_timer_ch, CALLOUT_MPSAFE);
   1650  1.170     ozaki 	error = workqueue_create(&rt_timer_wq, "rt_timer",
   1651  1.170     ozaki 	    rt_timer_work, NULL, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
   1652  1.170     ozaki 	if (error)
   1653  1.170     ozaki 		panic("%s: workqueue_create failed (%d)\n", __func__, error);
   1654  1.172    martin 	callout_reset(&rt_timer_ch, hz, rt_timer_timer, NULL);
   1655   1.18       kml 	rt_init_done = 1;
   1656   1.18       kml }
   1657   1.18       kml 
   1658   1.18       kml struct rttimer_queue *
   1659   1.60      matt rt_timer_queue_create(u_int timeout)
   1660   1.18       kml {
   1661   1.18       kml 	struct rttimer_queue *rtq;
   1662   1.18       kml 
   1663   1.18       kml 	if (rt_init_done == 0)
   1664   1.18       kml 		rt_timer_init();
   1665   1.18       kml 
   1666   1.18       kml 	R_Malloc(rtq, struct rttimer_queue *, sizeof *rtq);
   1667   1.18       kml 	if (rtq == NULL)
   1668   1.85    dyoung 		return NULL;
   1669  1.109    dyoung 	memset(rtq, 0, sizeof(*rtq));
   1670   1.18       kml 
   1671   1.18       kml 	rtq->rtq_timeout = timeout;
   1672   1.24   thorpej 	TAILQ_INIT(&rtq->rtq_head);
   1673  1.183     ozaki 	RT_WLOCK();
   1674   1.18       kml 	LIST_INSERT_HEAD(&rttimer_queue_head, rtq, rtq_link);
   1675  1.183     ozaki 	RT_UNLOCK();
   1676   1.18       kml 
   1677   1.85    dyoung 	return rtq;
   1678   1.18       kml }
   1679   1.18       kml 
   1680   1.18       kml void
   1681   1.60      matt rt_timer_queue_change(struct rttimer_queue *rtq, long timeout)
   1682   1.18       kml {
   1683   1.24   thorpej 
   1684   1.18       kml 	rtq->rtq_timeout = timeout;
   1685   1.18       kml }
   1686   1.18       kml 
   1687  1.177     ozaki static void
   1688  1.181     ozaki rt_timer_queue_remove_all(struct rttimer_queue *rtq)
   1689   1.18       kml {
   1690   1.24   thorpej 	struct rttimer *r;
   1691   1.18       kml 
   1692  1.183     ozaki 	RT_ASSERT_WLOCK();
   1693  1.183     ozaki 
   1694   1.24   thorpej 	while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL) {
   1695   1.18       kml 		LIST_REMOVE(r, rtt_link);
   1696   1.24   thorpej 		TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
   1697  1.183     ozaki 		rt_ref(r->rtt_rt); /* XXX */
   1698  1.183     ozaki 		RT_REFCNT_TRACE(r->rtt_rt);
   1699  1.183     ozaki 		RT_UNLOCK();
   1700  1.181     ozaki 		(*r->rtt_func)(r->rtt_rt, r);
   1701   1.22   thorpej 		pool_put(&rttimer_pool, r);
   1702  1.183     ozaki 		RT_WLOCK();
   1703   1.37    itojun 		if (rtq->rtq_count > 0)
   1704   1.37    itojun 			rtq->rtq_count--;
   1705   1.37    itojun 		else
   1706   1.55    itojun 			printf("rt_timer_queue_remove_all: "
   1707   1.55    itojun 			    "rtq_count reached 0\n");
   1708   1.18       kml 	}
   1709   1.55    itojun }
   1710   1.55    itojun 
   1711   1.55    itojun void
   1712  1.181     ozaki rt_timer_queue_destroy(struct rttimer_queue *rtq)
   1713   1.55    itojun {
   1714   1.55    itojun 
   1715  1.183     ozaki 	RT_WLOCK();
   1716  1.181     ozaki 	rt_timer_queue_remove_all(rtq);
   1717   1.18       kml 	LIST_REMOVE(rtq, rtq_link);
   1718  1.183     ozaki 	RT_UNLOCK();
   1719   1.22   thorpej 
   1720   1.22   thorpej 	/*
   1721   1.22   thorpej 	 * Caller is responsible for freeing the rttimer_queue structure.
   1722   1.22   thorpej 	 */
   1723   1.18       kml }
   1724   1.18       kml 
   1725   1.37    itojun unsigned long
   1726   1.60      matt rt_timer_count(struct rttimer_queue *rtq)
   1727   1.37    itojun {
   1728   1.37    itojun 	return rtq->rtq_count;
   1729   1.37    itojun }
   1730   1.37    itojun 
   1731  1.177     ozaki static void
   1732  1.178     ozaki rt_timer_remove_all(struct rtentry *rt)
   1733   1.18       kml {
   1734   1.24   thorpej 	struct rttimer *r;
   1735   1.18       kml 
   1736  1.183     ozaki 	RT_WLOCK();
   1737   1.24   thorpej 	while ((r = LIST_FIRST(&rt->rt_timer)) != NULL) {
   1738   1.18       kml 		LIST_REMOVE(r, rtt_link);
   1739   1.24   thorpej 		TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
   1740   1.37    itojun 		if (r->rtt_queue->rtq_count > 0)
   1741   1.37    itojun 			r->rtt_queue->rtq_count--;
   1742   1.37    itojun 		else
   1743   1.37    itojun 			printf("rt_timer_remove_all: rtq_count reached 0\n");
   1744   1.38    itojun 		pool_put(&rttimer_pool, r);
   1745   1.18       kml 	}
   1746  1.183     ozaki 	RT_UNLOCK();
   1747   1.18       kml }
   1748   1.18       kml 
   1749   1.65     perry int
   1750   1.60      matt rt_timer_add(struct rtentry *rt,
   1751   1.60      matt 	void (*func)(struct rtentry *, struct rttimer *),
   1752   1.60      matt 	struct rttimer_queue *queue)
   1753   1.18       kml {
   1754   1.24   thorpej 	struct rttimer *r;
   1755   1.18       kml 
   1756  1.156     ozaki 	KASSERT(func != NULL);
   1757  1.183     ozaki 	RT_WLOCK();
   1758   1.24   thorpej 	/*
   1759   1.24   thorpej 	 * If there's already a timer with this action, destroy it before
   1760   1.24   thorpej 	 * we add a new one.
   1761   1.24   thorpej 	 */
   1762   1.85    dyoung 	LIST_FOREACH(r, &rt->rt_timer, rtt_link) {
   1763   1.85    dyoung 		if (r->rtt_func == func)
   1764   1.85    dyoung 			break;
   1765   1.85    dyoung 	}
   1766   1.85    dyoung 	if (r != NULL) {
   1767   1.85    dyoung 		LIST_REMOVE(r, rtt_link);
   1768   1.85    dyoung 		TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
   1769   1.85    dyoung 		if (r->rtt_queue->rtq_count > 0)
   1770   1.85    dyoung 			r->rtt_queue->rtq_count--;
   1771   1.85    dyoung 		else
   1772   1.85    dyoung 			printf("rt_timer_add: rtq_count reached 0\n");
   1773   1.85    dyoung 	} else {
   1774   1.85    dyoung 		r = pool_get(&rttimer_pool, PR_NOWAIT);
   1775  1.183     ozaki 		if (r == NULL) {
   1776  1.183     ozaki 			RT_UNLOCK();
   1777   1.85    dyoung 			return ENOBUFS;
   1778  1.183     ozaki 		}
   1779   1.18       kml 	}
   1780   1.18       kml 
   1781   1.85    dyoung 	memset(r, 0, sizeof(*r));
   1782   1.24   thorpej 
   1783   1.24   thorpej 	r->rtt_rt = rt;
   1784   1.70    kardel 	r->rtt_time = time_uptime;
   1785   1.24   thorpej 	r->rtt_func = func;
   1786   1.24   thorpej 	r->rtt_queue = queue;
   1787   1.24   thorpej 	LIST_INSERT_HEAD(&rt->rt_timer, r, rtt_link);
   1788   1.24   thorpej 	TAILQ_INSERT_TAIL(&queue->rtq_head, r, rtt_next);
   1789   1.37    itojun 	r->rtt_queue->rtq_count++;
   1790   1.65     perry 
   1791  1.183     ozaki 	RT_UNLOCK();
   1792  1.183     ozaki 
   1793   1.95    dyoung 	return 0;
   1794   1.18       kml }
   1795   1.18       kml 
   1796  1.170     ozaki static void
   1797  1.170     ozaki rt_timer_work(struct work *wk, void *arg)
   1798   1.18       kml {
   1799   1.24   thorpej 	struct rttimer_queue *rtq;
   1800   1.24   thorpej 	struct rttimer *r;
   1801   1.21       kml 
   1802  1.183     ozaki 	RT_WLOCK();
   1803   1.85    dyoung 	LIST_FOREACH(rtq, &rttimer_queue_head, rtq_link) {
   1804   1.24   thorpej 		while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL &&
   1805   1.70    kardel 		    (r->rtt_time + rtq->rtq_timeout) < time_uptime) {
   1806   1.24   thorpej 			LIST_REMOVE(r, rtt_link);
   1807   1.24   thorpej 			TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
   1808  1.183     ozaki 			rt_ref(r->rtt_rt); /* XXX */
   1809  1.183     ozaki 			RT_REFCNT_TRACE(r->rtt_rt);
   1810  1.183     ozaki 			RT_UNLOCK();
   1811  1.156     ozaki 			(*r->rtt_func)(r->rtt_rt, r);
   1812   1.24   thorpej 			pool_put(&rttimer_pool, r);
   1813  1.183     ozaki 			RT_WLOCK();
   1814   1.37    itojun 			if (rtq->rtq_count > 0)
   1815   1.37    itojun 				rtq->rtq_count--;
   1816   1.37    itojun 			else
   1817   1.37    itojun 				printf("rt_timer_timer: rtq_count reached 0\n");
   1818   1.18       kml 		}
   1819   1.18       kml 	}
   1820  1.183     ozaki 	RT_UNLOCK();
   1821   1.18       kml 
   1822   1.35   thorpej 	callout_reset(&rt_timer_ch, hz, rt_timer_timer, NULL);
   1823    1.1       cgd }
   1824   1.83     joerg 
   1825  1.177     ozaki static void
   1826  1.170     ozaki rt_timer_timer(void *arg)
   1827  1.170     ozaki {
   1828  1.170     ozaki 
   1829  1.170     ozaki 	workqueue_enqueue(rt_timer_wq, &rt_timer_wk, NULL);
   1830  1.170     ozaki }
   1831  1.170     ozaki 
   1832  1.102    dyoung static struct rtentry *
   1833   1.84     joerg _rtcache_init(struct route *ro, int flag)
   1834   1.84     joerg {
   1835  1.183     ozaki 	struct rtentry *rt;
   1836  1.183     ozaki 
   1837  1.114    dyoung 	rtcache_invariants(ro);
   1838   1.99    dyoung 	KASSERT(ro->_ro_rt == NULL);
   1839  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
   1840   1.84     joerg 
   1841   1.90    dyoung 	if (rtcache_getdst(ro) == NULL)
   1842  1.102    dyoung 		return NULL;
   1843  1.105    dyoung 	ro->ro_invalid = false;
   1844  1.183     ozaki 	rt = rtalloc1(rtcache_getdst(ro), flag);
   1845  1.183     ozaki 	if (rt != NULL && ISSET(rt->rt_flags, RTF_UP)) {
   1846  1.183     ozaki 		ro->_ro_rt = rt;
   1847  1.183     ozaki 		KASSERT(!ISSET(rt->rt_flags, RTF_UPDATING));
   1848  1.183     ozaki 		rtcache_ref(rt, ro);
   1849  1.183     ozaki 		rt_unref(rt);
   1850  1.105    dyoung 		rtcache(ro);
   1851  1.183     ozaki 	} else if (rt != NULL)
   1852  1.183     ozaki 		rt_unref(rt);
   1853  1.103    dyoung 
   1854  1.114    dyoung 	rtcache_invariants(ro);
   1855  1.102    dyoung 	return ro->_ro_rt;
   1856   1.84     joerg }
   1857   1.84     joerg 
   1858  1.102    dyoung struct rtentry *
   1859   1.83     joerg rtcache_init(struct route *ro)
   1860   1.83     joerg {
   1861  1.183     ozaki 	struct rtentry *rt;
   1862  1.183     ozaki 	RTCACHE_WLOCK();
   1863  1.183     ozaki 	rt = _rtcache_init(ro, 1);
   1864  1.183     ozaki 	RTCACHE_UNLOCK();
   1865  1.183     ozaki 	return rt;
   1866   1.83     joerg }
   1867   1.83     joerg 
   1868  1.102    dyoung struct rtentry *
   1869   1.83     joerg rtcache_init_noclone(struct route *ro)
   1870   1.83     joerg {
   1871  1.183     ozaki 	struct rtentry *rt;
   1872  1.183     ozaki 	RTCACHE_WLOCK();
   1873  1.183     ozaki 	rt = _rtcache_init(ro, 0);
   1874  1.183     ozaki 	RTCACHE_UNLOCK();
   1875  1.183     ozaki 	return rt;
   1876   1.83     joerg }
   1877   1.90    dyoung 
   1878  1.102    dyoung struct rtentry *
   1879   1.90    dyoung rtcache_update(struct route *ro, int clone)
   1880   1.90    dyoung {
   1881  1.183     ozaki 	struct rtentry *rt;
   1882  1.183     ozaki 	RTCACHE_WLOCK();
   1883   1.90    dyoung 	rtcache_clear(ro);
   1884  1.183     ozaki 	rt = _rtcache_init(ro, clone);
   1885  1.183     ozaki 	RTCACHE_UNLOCK();
   1886  1.183     ozaki 	return rt;
   1887   1.90    dyoung }
   1888   1.83     joerg 
   1889   1.83     joerg void
   1890  1.183     ozaki rtcache_copy(struct route *new_ro, struct route *old_ro)
   1891   1.83     joerg {
   1892  1.103    dyoung 	struct rtentry *rt;
   1893  1.183     ozaki 	int ret;
   1894  1.103    dyoung 
   1895  1.103    dyoung 	KASSERT(new_ro != old_ro);
   1896  1.114    dyoung 	rtcache_invariants(new_ro);
   1897  1.114    dyoung 	rtcache_invariants(old_ro);
   1898  1.103    dyoung 
   1899  1.183     ozaki 	rt = rtcache_validate(old_ro);
   1900  1.103    dyoung 
   1901  1.183     ozaki 	if (rtcache_getdst(old_ro) == NULL)
   1902  1.183     ozaki 		goto out;
   1903  1.183     ozaki 	ret = rtcache_setdst(new_ro, rtcache_getdst(old_ro));
   1904  1.183     ozaki 	if (ret != 0)
   1905  1.183     ozaki 		goto out;
   1906  1.103    dyoung 
   1907  1.183     ozaki 	RTCACHE_WLOCK();
   1908  1.105    dyoung 	new_ro->ro_invalid = false;
   1909  1.103    dyoung 	if ((new_ro->_ro_rt = rt) != NULL)
   1910   1.86    dyoung 		rtcache(new_ro);
   1911  1.114    dyoung 	rtcache_invariants(new_ro);
   1912  1.183     ozaki 	RTCACHE_UNLOCK();
   1913  1.183     ozaki out:
   1914  1.183     ozaki 	rtcache_unref(rt, old_ro);
   1915  1.183     ozaki 	return;
   1916   1.83     joerg }
   1917   1.83     joerg 
   1918  1.105    dyoung static struct dom_rtlist invalid_routes = LIST_HEAD_INITIALIZER(dom_rtlist);
   1919  1.105    dyoung 
   1920  1.184     ozaki #if defined(RT_DEBUG) && defined(NET_MPSAFE)
   1921  1.183     ozaki static void
   1922  1.183     ozaki rtcache_trace(const char *func, struct rtentry *rt, struct route *ro)
   1923  1.183     ozaki {
   1924  1.183     ozaki 	char dst[64];
   1925  1.183     ozaki 
   1926  1.183     ozaki 	sockaddr_format(ro->ro_sa, dst, 64);
   1927  1.183     ozaki 	printf("trace: %s:\tdst=%s cpu=%d lwp=%p psref=%p target=%p\n", func, dst,
   1928  1.183     ozaki 	    cpu_index(curcpu()), curlwp, &ro->ro_psref, &rt->rt_psref);
   1929  1.183     ozaki }
   1930  1.183     ozaki #define RTCACHE_PSREF_TRACE(rt, ro)	rtcache_trace(__func__, (rt), (ro))
   1931  1.183     ozaki #else
   1932  1.183     ozaki #define RTCACHE_PSREF_TRACE(rt, ro)	do {} while (0)
   1933  1.183     ozaki #endif
   1934  1.183     ozaki 
   1935  1.183     ozaki static void
   1936  1.183     ozaki rtcache_ref(struct rtentry *rt, struct route *ro)
   1937  1.183     ozaki {
   1938  1.183     ozaki 
   1939  1.183     ozaki 	KASSERT(rt != NULL);
   1940  1.183     ozaki 
   1941  1.183     ozaki #ifdef NET_MPSAFE
   1942  1.183     ozaki 	RTCACHE_PSREF_TRACE(rt, ro);
   1943  1.183     ozaki 	ro->ro_bound = curlwp_bind();
   1944  1.183     ozaki 	psref_acquire(&ro->ro_psref, &rt->rt_psref, rt_psref_class);
   1945  1.183     ozaki #endif
   1946  1.183     ozaki }
   1947  1.183     ozaki 
   1948  1.183     ozaki void
   1949  1.183     ozaki rtcache_unref(struct rtentry *rt, struct route *ro)
   1950  1.183     ozaki {
   1951  1.183     ozaki 
   1952  1.183     ozaki 	if (rt == NULL)
   1953  1.183     ozaki 		return;
   1954  1.183     ozaki 
   1955  1.183     ozaki #ifdef NET_MPSAFE
   1956  1.183     ozaki 	psref_release(&ro->ro_psref, &rt->rt_psref, rt_psref_class);
   1957  1.183     ozaki 	curlwp_bindx(ro->ro_bound);
   1958  1.183     ozaki 	RTCACHE_PSREF_TRACE(rt, ro);
   1959  1.183     ozaki #endif
   1960  1.183     ozaki }
   1961  1.183     ozaki 
   1962  1.183     ozaki static struct rtentry *
   1963  1.183     ozaki rtcache_validate_locked(struct route *ro)
   1964  1.183     ozaki {
   1965  1.183     ozaki 	struct rtentry *rt = NULL;
   1966  1.183     ozaki 
   1967  1.183     ozaki retry:
   1968  1.183     ozaki 	rt = ro->_ro_rt;
   1969  1.183     ozaki 	rtcache_invariants(ro);
   1970  1.183     ozaki 
   1971  1.183     ozaki 	if (ro->ro_invalid) {
   1972  1.183     ozaki 		rt = NULL;
   1973  1.183     ozaki 		goto out;
   1974  1.183     ozaki 	}
   1975  1.183     ozaki 
   1976  1.183     ozaki 	RT_RLOCK();
   1977  1.183     ozaki 	if (rt != NULL && (rt->rt_flags & RTF_UP) != 0 && rt->rt_ifp != NULL) {
   1978  1.183     ozaki 		if (ISSET(rt->rt_flags, RTF_UPDATING)) {
   1979  1.183     ozaki 			if (rt_wait_ok()) {
   1980  1.183     ozaki 				RT_UNLOCK();
   1981  1.183     ozaki 				RTCACHE_UNLOCK();
   1982  1.183     ozaki 				/* We can wait until the update is complete */
   1983  1.183     ozaki 				rt_update_wait();
   1984  1.183     ozaki 				RTCACHE_RLOCK();
   1985  1.183     ozaki 				goto retry;
   1986  1.183     ozaki 			} else {
   1987  1.183     ozaki 				rt = NULL;
   1988  1.183     ozaki 			}
   1989  1.183     ozaki 		} else
   1990  1.183     ozaki 			rtcache_ref(rt, ro);
   1991  1.183     ozaki 	} else
   1992  1.183     ozaki 		rt = NULL;
   1993  1.183     ozaki 	RT_UNLOCK();
   1994  1.183     ozaki out:
   1995  1.183     ozaki 	return rt;
   1996  1.183     ozaki }
   1997  1.183     ozaki 
   1998  1.183     ozaki struct rtentry *
   1999  1.183     ozaki rtcache_validate(struct route *ro)
   2000  1.183     ozaki {
   2001  1.183     ozaki 	struct rtentry *rt;
   2002  1.183     ozaki 
   2003  1.183     ozaki 	RTCACHE_RLOCK();
   2004  1.183     ozaki 	rt = rtcache_validate_locked(ro);
   2005  1.183     ozaki 	RTCACHE_UNLOCK();
   2006  1.183     ozaki 	return rt;
   2007  1.183     ozaki }
   2008  1.183     ozaki 
   2009  1.144     ozaki static void
   2010  1.105    dyoung rtcache_invalidate(struct dom_rtlist *rtlist)
   2011   1.83     joerg {
   2012  1.105    dyoung 	struct route *ro;
   2013   1.99    dyoung 
   2014  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
   2015  1.183     ozaki 
   2016  1.105    dyoung 	while ((ro = LIST_FIRST(rtlist)) != NULL) {
   2017  1.114    dyoung 		rtcache_invariants(ro);
   2018  1.105    dyoung 		KASSERT(ro->_ro_rt != NULL);
   2019  1.105    dyoung 		ro->ro_invalid = true;
   2020   1.99    dyoung 		LIST_REMOVE(ro, ro_rtcache_next);
   2021  1.105    dyoung 		LIST_INSERT_HEAD(&invalid_routes, ro, ro_rtcache_next);
   2022  1.114    dyoung 		rtcache_invariants(ro);
   2023   1.84     joerg 	}
   2024  1.105    dyoung }
   2025  1.105    dyoung 
   2026  1.144     ozaki static void
   2027  1.168     ozaki rtcache_clear_rtentry(int family, struct rtentry *rt)
   2028  1.168     ozaki {
   2029  1.168     ozaki 	struct domain *dom;
   2030  1.171   hannken 	struct route *ro, *nro;
   2031  1.168     ozaki 
   2032  1.168     ozaki 	if ((dom = pffinddomain(family)) == NULL)
   2033  1.168     ozaki 		return;
   2034  1.168     ozaki 
   2035  1.183     ozaki 	RTCACHE_WLOCK();
   2036  1.171   hannken 	LIST_FOREACH_SAFE(ro, &dom->dom_rtcache, ro_rtcache_next, nro) {
   2037  1.168     ozaki 		if (ro->_ro_rt == rt)
   2038  1.168     ozaki 			rtcache_clear(ro);
   2039  1.168     ozaki 	}
   2040  1.183     ozaki 	RTCACHE_UNLOCK();
   2041  1.168     ozaki }
   2042  1.168     ozaki 
   2043  1.168     ozaki static void
   2044  1.105    dyoung rtcache_clear(struct route *ro)
   2045  1.105    dyoung {
   2046  1.183     ozaki 
   2047  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
   2048  1.183     ozaki 
   2049  1.114    dyoung 	rtcache_invariants(ro);
   2050  1.105    dyoung 	if (ro->_ro_rt == NULL)
   2051  1.105    dyoung 		return;
   2052  1.105    dyoung 
   2053  1.105    dyoung 	LIST_REMOVE(ro, ro_rtcache_next);
   2054  1.105    dyoung 
   2055  1.105    dyoung 	ro->_ro_rt = NULL;
   2056  1.114    dyoung 	ro->ro_invalid = false;
   2057  1.114    dyoung 	rtcache_invariants(ro);
   2058   1.83     joerg }
   2059   1.83     joerg 
   2060   1.90    dyoung struct rtentry *
   2061  1.183     ozaki rtcache_lookup2(struct route *ro, const struct sockaddr *dst,
   2062  1.183     ozaki     int clone, int *hitp)
   2063   1.90    dyoung {
   2064   1.90    dyoung 	const struct sockaddr *odst;
   2065  1.104    dyoung 	struct rtentry *rt = NULL;
   2066   1.90    dyoung 
   2067  1.183     ozaki 	RTCACHE_RLOCK();
   2068   1.90    dyoung 	odst = rtcache_getdst(ro);
   2069  1.183     ozaki 	if (odst == NULL) {
   2070  1.183     ozaki 		RTCACHE_UNLOCK();
   2071  1.183     ozaki 		RTCACHE_WLOCK();
   2072  1.138     ozaki 		goto miss;
   2073  1.183     ozaki 	}
   2074   1.90    dyoung 
   2075  1.138     ozaki 	if (sockaddr_cmp(odst, dst) != 0) {
   2076  1.183     ozaki 		RTCACHE_UNLOCK();
   2077  1.183     ozaki 		RTCACHE_WLOCK();
   2078  1.183     ozaki 		rtcache_free_locked(ro);
   2079  1.138     ozaki 		goto miss;
   2080  1.138     ozaki 	}
   2081  1.138     ozaki 
   2082  1.183     ozaki 	rt = rtcache_validate_locked(ro);
   2083  1.138     ozaki 	if (rt == NULL) {
   2084  1.183     ozaki 		RTCACHE_UNLOCK();
   2085  1.183     ozaki 		RTCACHE_WLOCK();
   2086   1.91    dyoung 		rtcache_clear(ro);
   2087  1.138     ozaki 		goto miss;
   2088  1.138     ozaki 	}
   2089  1.138     ozaki 
   2090  1.138     ozaki 	rtcache_invariants(ro);
   2091   1.90    dyoung 
   2092  1.183     ozaki 	RTCACHE_UNLOCK();
   2093  1.183     ozaki 	if (hitp != NULL)
   2094  1.183     ozaki 		*hitp = 1;
   2095  1.138     ozaki 	return rt;
   2096  1.138     ozaki miss:
   2097  1.183     ozaki 	if (hitp != NULL)
   2098  1.183     ozaki 		*hitp = 0;
   2099  1.183     ozaki 	if (rtcache_setdst_locked(ro, dst) == 0)
   2100  1.138     ozaki 		rt = _rtcache_init(ro, clone);
   2101   1.90    dyoung 
   2102  1.114    dyoung 	rtcache_invariants(ro);
   2103  1.114    dyoung 
   2104  1.183     ozaki 	RTCACHE_UNLOCK();
   2105  1.104    dyoung 	return rt;
   2106   1.90    dyoung }
   2107   1.90    dyoung 
   2108  1.183     ozaki static void
   2109  1.183     ozaki rtcache_free_locked(struct route *ro)
   2110   1.86    dyoung {
   2111  1.183     ozaki 
   2112  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
   2113   1.86    dyoung 	rtcache_clear(ro);
   2114   1.86    dyoung 	if (ro->ro_sa != NULL) {
   2115   1.86    dyoung 		sockaddr_free(ro->ro_sa);
   2116   1.86    dyoung 		ro->ro_sa = NULL;
   2117   1.86    dyoung 	}
   2118  1.114    dyoung 	rtcache_invariants(ro);
   2119   1.86    dyoung }
   2120   1.86    dyoung 
   2121  1.183     ozaki void
   2122  1.183     ozaki rtcache_free(struct route *ro)
   2123  1.183     ozaki {
   2124  1.183     ozaki 
   2125  1.183     ozaki 	RTCACHE_WLOCK();
   2126  1.183     ozaki 	rtcache_free_locked(ro);
   2127  1.183     ozaki 	RTCACHE_UNLOCK();
   2128  1.183     ozaki }
   2129  1.183     ozaki 
   2130  1.183     ozaki static int
   2131  1.183     ozaki rtcache_setdst_locked(struct route *ro, const struct sockaddr *sa)
   2132   1.83     joerg {
   2133   1.90    dyoung 	KASSERT(sa != NULL);
   2134   1.90    dyoung 
   2135  1.183     ozaki 	RTCACHE_ASSERT_WLOCK();
   2136  1.183     ozaki 
   2137  1.114    dyoung 	rtcache_invariants(ro);
   2138  1.142     ozaki 	if (ro->ro_sa != NULL) {
   2139  1.142     ozaki 		if (ro->ro_sa->sa_family == sa->sa_family) {
   2140  1.142     ozaki 			rtcache_clear(ro);
   2141  1.142     ozaki 			sockaddr_copy(ro->ro_sa, ro->ro_sa->sa_len, sa);
   2142  1.143     ozaki 			rtcache_invariants(ro);
   2143  1.143     ozaki 			return 0;
   2144  1.114    dyoung 		}
   2145  1.143     ozaki 		/* free ro_sa, wrong family */
   2146  1.183     ozaki 		rtcache_free_locked(ro);
   2147  1.142     ozaki 	}
   2148   1.90    dyoung 
   2149  1.107    dyoung 	KASSERT(ro->_ro_rt == NULL);
   2150  1.107    dyoung 
   2151  1.134  christos 	if ((ro->ro_sa = sockaddr_dup(sa, M_ZERO | M_NOWAIT)) == NULL) {
   2152  1.114    dyoung 		rtcache_invariants(ro);
   2153   1.90    dyoung 		return ENOMEM;
   2154  1.107    dyoung 	}
   2155  1.114    dyoung 	rtcache_invariants(ro);
   2156   1.90    dyoung 	return 0;
   2157   1.83     joerg }
   2158   1.92    dyoung 
   2159  1.183     ozaki int
   2160  1.183     ozaki rtcache_setdst(struct route *ro, const struct sockaddr *sa)
   2161  1.183     ozaki {
   2162  1.183     ozaki 	int error;
   2163  1.183     ozaki 
   2164  1.183     ozaki 	RTCACHE_WLOCK();
   2165  1.183     ozaki 	error = rtcache_setdst_locked(ro, sa);
   2166  1.183     ozaki 	RTCACHE_UNLOCK();
   2167  1.183     ozaki 
   2168  1.183     ozaki 	return error;
   2169  1.183     ozaki }
   2170  1.183     ozaki 
   2171  1.123    kefren const struct sockaddr *
   2172  1.123    kefren rt_settag(struct rtentry *rt, const struct sockaddr *tag)
   2173  1.123    kefren {
   2174  1.123    kefren 	if (rt->rt_tag != tag) {
   2175  1.123    kefren 		if (rt->rt_tag != NULL)
   2176  1.123    kefren 			sockaddr_free(rt->rt_tag);
   2177  1.134  christos 		rt->rt_tag = sockaddr_dup(tag, M_ZERO | M_NOWAIT);
   2178  1.123    kefren 	}
   2179  1.169   msaitoh 	return rt->rt_tag;
   2180  1.123    kefren }
   2181  1.123    kefren 
   2182  1.123    kefren struct sockaddr *
   2183  1.167     ozaki rt_gettag(const struct rtentry *rt)
   2184  1.123    kefren {
   2185  1.123    kefren 	return rt->rt_tag;
   2186  1.123    kefren }
   2187  1.162     ozaki 
   2188  1.165     ozaki int
   2189  1.167     ozaki rt_check_reject_route(const struct rtentry *rt, const struct ifnet *ifp)
   2190  1.165     ozaki {
   2191  1.165     ozaki 
   2192  1.165     ozaki 	if ((rt->rt_flags & RTF_REJECT) != 0) {
   2193  1.165     ozaki 		/* Mimic looutput */
   2194  1.165     ozaki 		if (ifp->if_flags & IFF_LOOPBACK)
   2195  1.165     ozaki 			return (rt->rt_flags & RTF_HOST) ?
   2196  1.165     ozaki 			    EHOSTUNREACH : ENETUNREACH;
   2197  1.165     ozaki 		else if (rt->rt_rmx.rmx_expire == 0 ||
   2198  1.165     ozaki 		    time_uptime < rt->rt_rmx.rmx_expire)
   2199  1.165     ozaki 			return (rt->rt_flags & RTF_GATEWAY) ?
   2200  1.165     ozaki 			    EHOSTUNREACH : EHOSTDOWN;
   2201  1.165     ozaki 	}
   2202  1.165     ozaki 
   2203  1.165     ozaki 	return 0;
   2204  1.165     ozaki }
   2205  1.165     ozaki 
   2206  1.182     ozaki void
   2207  1.182     ozaki rt_delete_matched_entries(sa_family_t family, int (*f)(struct rtentry *, void *),
   2208  1.182     ozaki     void *v)
   2209  1.182     ozaki {
   2210  1.182     ozaki 
   2211  1.182     ozaki 	for (;;) {
   2212  1.182     ozaki 		int s;
   2213  1.182     ozaki 		int error;
   2214  1.182     ozaki 		struct rtentry *rt, *retrt = NULL;
   2215  1.182     ozaki 
   2216  1.183     ozaki 		RT_RLOCK();
   2217  1.182     ozaki 		s = splsoftnet();
   2218  1.182     ozaki 		rt = rtbl_search_matched_entry(family, f, v);
   2219  1.182     ozaki 		if (rt == NULL) {
   2220  1.182     ozaki 			splx(s);
   2221  1.183     ozaki 			RT_UNLOCK();
   2222  1.182     ozaki 			return;
   2223  1.182     ozaki 		}
   2224  1.182     ozaki 		rt->rt_refcnt++;
   2225  1.182     ozaki 		splx(s);
   2226  1.183     ozaki 		RT_UNLOCK();
   2227  1.182     ozaki 
   2228  1.182     ozaki 		error = rtrequest(RTM_DELETE, rt_getkey(rt), rt->rt_gateway,
   2229  1.182     ozaki 		    rt_mask(rt), rt->rt_flags, &retrt);
   2230  1.182     ozaki 		if (error == 0) {
   2231  1.182     ozaki 			KASSERT(retrt == rt);
   2232  1.182     ozaki 			KASSERT((retrt->rt_flags & RTF_UP) == 0);
   2233  1.182     ozaki 			retrt->rt_ifp = NULL;
   2234  1.183     ozaki 			rt_unref(rt);
   2235  1.183     ozaki 			rt_free(retrt);
   2236  1.182     ozaki 		} else if (error == ESRCH) {
   2237  1.182     ozaki 			/* Someone deleted the entry already. */
   2238  1.183     ozaki 			rt_unref(rt);
   2239  1.182     ozaki 		} else {
   2240  1.182     ozaki 			log(LOG_ERR, "%s: unable to delete rtentry @ %p, "
   2241  1.182     ozaki 			    "error = %d\n", rt->rt_ifp->if_xname, rt, error);
   2242  1.182     ozaki 			/* XXX how to treat this case? */
   2243  1.182     ozaki 		}
   2244  1.182     ozaki 	}
   2245  1.182     ozaki }
   2246  1.182     ozaki 
   2247  1.183     ozaki int
   2248  1.183     ozaki rt_walktree(sa_family_t family, int (*f)(struct rtentry *, void *), void *v)
   2249  1.183     ozaki {
   2250  1.183     ozaki 	int error;
   2251  1.183     ozaki 
   2252  1.183     ozaki 	RT_RLOCK();
   2253  1.183     ozaki 	error = rtbl_walktree(family, f, v);
   2254  1.183     ozaki 	RT_UNLOCK();
   2255  1.183     ozaki 
   2256  1.183     ozaki 	return error;
   2257  1.183     ozaki }
   2258  1.183     ozaki 
   2259  1.162     ozaki #ifdef DDB
   2260  1.162     ozaki 
   2261  1.162     ozaki #include <machine/db_machdep.h>
   2262  1.162     ozaki #include <ddb/db_interface.h>
   2263  1.162     ozaki #include <ddb/db_output.h>
   2264  1.162     ozaki 
   2265  1.162     ozaki #define	rt_expire rt_rmx.rmx_expire
   2266  1.162     ozaki 
   2267  1.162     ozaki static void
   2268  1.162     ozaki db_print_sa(const struct sockaddr *sa)
   2269  1.162     ozaki {
   2270  1.162     ozaki 	int len;
   2271  1.162     ozaki 	const u_char *p;
   2272  1.162     ozaki 
   2273  1.162     ozaki 	if (sa == NULL) {
   2274  1.162     ozaki 		db_printf("[NULL]");
   2275  1.162     ozaki 		return;
   2276  1.162     ozaki 	}
   2277  1.162     ozaki 
   2278  1.162     ozaki 	p = (const u_char *)sa;
   2279  1.162     ozaki 	len = sa->sa_len;
   2280  1.162     ozaki 	db_printf("[");
   2281  1.162     ozaki 	while (len > 0) {
   2282  1.162     ozaki 		db_printf("%d", *p);
   2283  1.162     ozaki 		p++; len--;
   2284  1.162     ozaki 		if (len) db_printf(",");
   2285  1.162     ozaki 	}
   2286  1.162     ozaki 	db_printf("]\n");
   2287  1.162     ozaki }
   2288  1.162     ozaki 
   2289  1.162     ozaki static void
   2290  1.162     ozaki db_print_ifa(struct ifaddr *ifa)
   2291  1.162     ozaki {
   2292  1.162     ozaki 	if (ifa == NULL)
   2293  1.162     ozaki 		return;
   2294  1.162     ozaki 	db_printf("  ifa_addr=");
   2295  1.162     ozaki 	db_print_sa(ifa->ifa_addr);
   2296  1.162     ozaki 	db_printf("  ifa_dsta=");
   2297  1.162     ozaki 	db_print_sa(ifa->ifa_dstaddr);
   2298  1.162     ozaki 	db_printf("  ifa_mask=");
   2299  1.162     ozaki 	db_print_sa(ifa->ifa_netmask);
   2300  1.162     ozaki 	db_printf("  flags=0x%x,refcnt=%d,metric=%d\n",
   2301  1.162     ozaki 			  ifa->ifa_flags,
   2302  1.162     ozaki 			  ifa->ifa_refcnt,
   2303  1.162     ozaki 			  ifa->ifa_metric);
   2304  1.162     ozaki }
   2305  1.162     ozaki 
   2306  1.162     ozaki /*
   2307  1.162     ozaki  * Function to pass to rt_walktree().
   2308  1.162     ozaki  * Return non-zero error to abort walk.
   2309  1.162     ozaki  */
   2310  1.162     ozaki static int
   2311  1.162     ozaki db_show_rtentry(struct rtentry *rt, void *w)
   2312  1.162     ozaki {
   2313  1.162     ozaki 	db_printf("rtentry=%p", rt);
   2314  1.162     ozaki 
   2315  1.162     ozaki 	db_printf(" flags=0x%x refcnt=%d use=%"PRId64" expire=%"PRId64"\n",
   2316  1.162     ozaki 			  rt->rt_flags, rt->rt_refcnt,
   2317  1.162     ozaki 			  rt->rt_use, (uint64_t)rt->rt_expire);
   2318  1.162     ozaki 
   2319  1.162     ozaki 	db_printf(" key="); db_print_sa(rt_getkey(rt));
   2320  1.162     ozaki 	db_printf(" mask="); db_print_sa(rt_mask(rt));
   2321  1.162     ozaki 	db_printf(" gw="); db_print_sa(rt->rt_gateway);
   2322  1.162     ozaki 
   2323  1.162     ozaki 	db_printf(" ifp=%p ", rt->rt_ifp);
   2324  1.162     ozaki 	if (rt->rt_ifp)
   2325  1.162     ozaki 		db_printf("(%s)", rt->rt_ifp->if_xname);
   2326  1.162     ozaki 	else
   2327  1.162     ozaki 		db_printf("(NULL)");
   2328  1.162     ozaki 
   2329  1.162     ozaki 	db_printf(" ifa=%p\n", rt->rt_ifa);
   2330  1.162     ozaki 	db_print_ifa(rt->rt_ifa);
   2331  1.162     ozaki 
   2332  1.162     ozaki 	db_printf(" gwroute=%p llinfo=%p\n",
   2333  1.162     ozaki 			  rt->rt_gwroute, rt->rt_llinfo);
   2334  1.162     ozaki 
   2335  1.162     ozaki 	return 0;
   2336  1.162     ozaki }
   2337  1.162     ozaki 
   2338  1.162     ozaki /*
   2339  1.162     ozaki  * Function to print all the route trees.
   2340  1.162     ozaki  * Use this from ddb:  "show routes"
   2341  1.162     ozaki  */
   2342  1.162     ozaki void
   2343  1.162     ozaki db_show_routes(db_expr_t addr, bool have_addr,
   2344  1.162     ozaki     db_expr_t count, const char *modif)
   2345  1.162     ozaki {
   2346  1.162     ozaki 	rt_walktree(AF_INET, db_show_rtentry, NULL);
   2347  1.162     ozaki }
   2348  1.162     ozaki #endif
   2349