X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/c910b4d9d2451126ae3917b931cd4390c11e1d52..a39ff7e25e19b3a8c3020042a3872ca9ec9659f1:/bsd/net/route.c diff --git a/bsd/net/route.c b/bsd/net/route.c index 4e4fb302e..69fdd5937 100644 --- a/bsd/net/route.c +++ b/bsd/net/route.c @@ -1,8 +1,8 @@ /* - * Copyright (c) 2000-2008 Apple Inc. All rights reserved. + * Copyright (c) 2000-2018 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in @@ -11,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this file. - * + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -22,7 +22,7 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * + * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* @@ -60,25 +60,46 @@ * @(#)route.c 8.2 (Berkeley) 11/15/93 * $FreeBSD: src/sys/net/route.c,v 1.59.2.3 2001/07/29 19:18:02 ume Exp $ */ - + #include +#include #include #include #include #include #include +#include +#include +#include #include #include -#include +#include +#include +#include +#include +#include #include +#include #include #include +#include +#include +#if NECP +#include +#endif /* NECP */ #include #include -#include #include +#include +#include + +#if INET6 +#include +#include +#include +#endif /* INET6 */ #include @@ -87,40 +108,149 @@ #include +#if CONFIG_MACF +#include +#endif + +/* + * Synchronization notes: + * + * Routing entries fall under two locking domains: the global routing table + * lock (rnh_lock) and the per-entry lock (rt_lock); the latter is a mutex that + * resides (statically defined) in the rtentry structure. + * + * The locking domains for routing are defined as follows: + * + * The global routing lock is used to serialize all accesses to the radix + * trees defined by rt_tables[], as well as the tree of masks. This includes + * lookups, insertions and removals of nodes to/from the respective tree. + * It is also used to protect certain fields in the route entry that aren't + * often modified and/or require global serialization (more details below.) + * + * The per-route entry lock is used to serialize accesses to several routing + * entry fields (more details below.) Acquiring and releasing this lock is + * done via RT_LOCK() and RT_UNLOCK() routines. + * + * In cases where both rnh_lock and rt_lock must be held, the former must be + * acquired first in order to maintain lock ordering. It is not a requirement + * that rnh_lock be acquired first before rt_lock, but in case both must be + * acquired in succession, the correct lock ordering must be followed. + * + * The fields of the rtentry structure are protected in the following way: + * + * rt_nodes[] + * + * - Routing table lock (rnh_lock). + * + * rt_parent, rt_mask, rt_llinfo_free, rt_tree_genid + * + * - Set once during creation and never changes; no locks to read. + * + * rt_flags, rt_genmask, rt_llinfo, rt_rmx, rt_refcnt, rt_gwroute + * + * - Routing entry lock (rt_lock) for read/write access. + * + * - Some values of rt_flags are either set once at creation time, + * or aren't currently used, and thus checking against them can + * be done without rt_lock: RTF_GATEWAY, RTF_HOST, RTF_DYNAMIC, + * RTF_DONE, RTF_XRESOLVE, RTF_STATIC, RTF_BLACKHOLE, RTF_ANNOUNCE, + * RTF_USETRAILERS, RTF_WASCLONED, RTF_PINNED, RTF_LOCAL, + * RTF_BROADCAST, RTF_MULTICAST, RTF_IFSCOPE, RTF_IFREF. + * + * rt_key, rt_gateway, rt_ifp, rt_ifa + * + * - Always written/modified with both rnh_lock and rt_lock held. + * + * - May be read freely with rnh_lock held, else must hold rt_lock + * for read access; holding both locks for read is also okay. + * + * - In the event rnh_lock is not acquired, or is not possible to be + * acquired across the operation, setting RTF_CONDEMNED on a route + * entry will prevent its rt_key, rt_gateway, rt_ifp and rt_ifa + * from being modified. This is typically done on a route that + * has been chosen for a removal (from the tree) prior to dropping + * the rt_lock, so that those values will remain the same until + * the route is freed. + * + * When rnh_lock is held rt_setgate(), rt_setif(), and rtsetifa() are + * single-threaded, thus exclusive. This flag will also prevent the + * route from being looked up via rt_lookup(). + * + * rt_genid + * + * - Assumes that 32-bit writes are atomic; no locks. + * + * rt_dlt, rt_output + * + * - Currently unused; no locks. + * + * Operations on a route entry can be described as follows: + * + * CREATE an entry with reference count set to 0 as part of RTM_ADD/RESOLVE. + * + * INSERTION of an entry into the radix tree holds the rnh_lock, checks + * for duplicates and then adds the entry. rtrequest returns the entry + * after bumping up the reference count to 1 (for the caller). + * + * LOOKUP of an entry holds the rnh_lock and bumps up the reference count + * before returning; it is valid to also bump up the reference count using + * RT_ADDREF after the lookup has returned an entry. + * + * REMOVAL of an entry from the radix tree holds the rnh_lock, removes the + * entry but does not decrement the reference count. Removal happens when + * the route is explicitly deleted (RTM_DELETE) or when it is in the cached + * state and it expires. The route is said to be "down" when it is no + * longer present in the tree. Freeing the entry will happen on the last + * reference release of such a "down" route. + * + * RT_ADDREF/RT_REMREF operates on the routing entry which increments/ + * decrements the reference count, rt_refcnt, atomically on the rtentry. + * rt_refcnt is modified only using this routine. The general rule is to + * do RT_ADDREF in the function that is passing the entry as an argument, + * in order to prevent the entry from being freed by the callee. + */ + #define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0) -#define SA(p) ((struct sockaddr *)(p)) -extern void kdp_set_gateway_mac (void *gatewaymac); +extern void kdp_set_gateway_mac(void *gatewaymac); -extern struct domain routedomain; -struct route_cb route_cb; -__private_extern__ struct rtstat rtstat = { 0, 0, 0, 0, 0 }; +__private_extern__ struct rtstat rtstat = { 0, 0, 0, 0, 0, 0 }; struct radix_node_head *rt_tables[AF_MAX+1]; -lck_mtx_t *rt_mtx; /*### global routing tables mutex for now */ -lck_attr_t *rt_mtx_attr; -lck_grp_t *rt_mtx_grp; -lck_grp_attr_t *rt_mtx_grp_attr; +decl_lck_mtx_data(, rnh_lock_data); /* global routing tables mutex */ +lck_mtx_t *rnh_lock = &rnh_lock_data; +static lck_attr_t *rnh_lock_attr; +static lck_grp_t *rnh_lock_grp; +static lck_grp_attr_t *rnh_lock_grp_attr; + +/* Lock group and attribute for routing entry locks */ +static lck_attr_t *rte_mtx_attr; +static lck_grp_t *rte_mtx_grp; +static lck_grp_attr_t *rte_mtx_grp_attr; -lck_mtx_t *route_domain_mtx; /*### global routing tables mutex for now */ int rttrash = 0; /* routes not in table but not freed */ -static unsigned int rte_debug; +unsigned int rte_debug = 0; /* Possible flags for rte_debug */ #define RTD_DEBUG 0x1 /* enable or disable rtentry debug facility */ -#define RTD_TRACE 0x2 /* trace alloc, free and refcnt */ +#define RTD_TRACE 0x2 /* trace alloc, free, refcnt and lock */ #define RTD_NO_FREE 0x4 /* don't free (good to catch corruptions) */ +#define RTE_NAME "rtentry" /* name for zone and rt_lock */ + static struct zone *rte_zone; /* special zone for rtentry */ #define RTE_ZONE_MAX 65536 /* maximum elements in zone */ -#define RTE_ZONE_NAME "rtentry" /* name of rtentry zone */ +#define RTE_ZONE_NAME RTE_NAME /* name of rtentry zone */ #define RTD_INUSE 0xFEEDFACE /* entry is in use */ #define RTD_FREED 0xDEADBEEF /* entry is freed */ -#define RTD_TRSTACK_SIZE 8 /* depth of stack trace */ -#define RTD_REFHIST_SIZE 4 /* refcnt history size */ +#define MAX_SCOPE_ADDR_STR_LEN (MAX_IPv6_STR_LEN + 6) + +/* For gdb */ +__private_extern__ unsigned int ctrace_stack_size = CTRACE_STACK_SIZE; +__private_extern__ unsigned int ctrace_hist_size = CTRACE_HIST_SIZE; /* * Debug variant of rtentry structure. @@ -128,95 +258,83 @@ static struct zone *rte_zone; /* special zone for rtentry */ struct rtentry_dbg { struct rtentry rtd_entry; /* rtentry */ struct rtentry rtd_entry_saved; /* saved rtentry */ - u_int32_t rtd_inuse; /* in use pattern */ - u_int16_t rtd_refhold_cnt; /* # of rtref */ - u_int16_t rtd_refrele_cnt; /* # of rtunref */ + uint32_t rtd_inuse; /* in use pattern */ + uint16_t rtd_refhold_cnt; /* # of rtref */ + uint16_t rtd_refrele_cnt; /* # of rtunref */ + uint32_t rtd_lock_cnt; /* # of locks */ + uint32_t rtd_unlock_cnt; /* # of unlocks */ /* - * Thread and PC stack trace up to RTD_TRSTACK_SIZE - * deep during alloc and free. + * Alloc and free callers. */ - struct thread *rtd_alloc_thread; - void *rtd_alloc_stk_pc[RTD_TRSTACK_SIZE]; - struct thread *rtd_free_thread; - void *rtd_free_stk_pc[RTD_TRSTACK_SIZE]; + ctrace_t rtd_alloc; + ctrace_t rtd_free; /* * Circular lists of rtref and rtunref callers. */ - u_int16_t rtd_refhold_next; - u_int16_t rtd_refrele_next; - struct { - struct thread *th; - void *pc[RTD_TRSTACK_SIZE]; - } rtd_refhold[RTD_REFHIST_SIZE]; - struct { - struct thread *th; - void *pc[RTD_TRSTACK_SIZE]; - } rtd_refrele[RTD_REFHIST_SIZE]; + ctrace_t rtd_refhold[CTRACE_HIST_SIZE]; + ctrace_t rtd_refrele[CTRACE_HIST_SIZE]; + /* + * Circular lists of locks and unlocks. + */ + ctrace_t rtd_lock[CTRACE_HIST_SIZE]; + ctrace_t rtd_unlock[CTRACE_HIST_SIZE]; /* * Trash list linkage */ TAILQ_ENTRY(rtentry_dbg) rtd_trash_link; }; -/* List of trash route entries protected by rt_mtx */ +/* List of trash route entries protected by rnh_lock */ static TAILQ_HEAD(, rtentry_dbg) rttrash_head; +static void rte_lock_init(struct rtentry *); +static void rte_lock_destroy(struct rtentry *); static inline struct rtentry *rte_alloc_debug(void); static inline void rte_free_debug(struct rtentry *); -static void rt_maskedcopy(struct sockaddr *, - struct sockaddr *, struct sockaddr *); +static inline void rte_lock_debug(struct rtentry_dbg *); +static inline void rte_unlock_debug(struct rtentry_dbg *); +static void rt_maskedcopy(const struct sockaddr *, + struct sockaddr *, const struct sockaddr *); static void rtable_init(void **); static inline void rtref_audit(struct rtentry_dbg *); static inline void rtunref_audit(struct rtentry_dbg *); -static struct rtentry *rtalloc1_common_locked(struct sockaddr *, int, u_long, +static struct rtentry *rtalloc1_common_locked(struct sockaddr *, int, uint32_t, unsigned int); static int rtrequest_common_locked(int, struct sockaddr *, struct sockaddr *, struct sockaddr *, int, struct rtentry **, unsigned int); -static void rtalloc_ign_common_locked(struct route *, u_long, unsigned int); -static inline void sa_set_ifscope(struct sockaddr *, unsigned int); -static struct sockaddr *sin_copy(struct sockaddr_in *, struct sockaddr_in *, - unsigned int); -static struct sockaddr *mask_copy(struct sockaddr *, struct sockaddr_in *, - unsigned int); +static struct rtentry *rtalloc1_locked(struct sockaddr *, int, uint32_t); +static void rtalloc_ign_common_locked(struct route *, uint32_t, unsigned int); +static inline void sin6_set_ifscope(struct sockaddr *, unsigned int); +static inline void sin6_set_embedded_ifscope(struct sockaddr *, unsigned int); +static inline unsigned int sin6_get_embedded_ifscope(struct sockaddr *); +static struct sockaddr *ma_copy(int, struct sockaddr *, + struct sockaddr_storage *, unsigned int); +static struct sockaddr *sa_trim(struct sockaddr *, int); static struct radix_node *node_lookup(struct sockaddr *, struct sockaddr *, unsigned int); -static struct radix_node *node_lookup_default(void); +static struct radix_node *node_lookup_default(int); +static struct rtentry *rt_lookup_common(boolean_t, boolean_t, struct sockaddr *, + struct sockaddr *, struct radix_node_head *, unsigned int); static int rn_match_ifscope(struct radix_node *, void *); static struct ifaddr *ifa_ifwithroute_common_locked(int, const struct sockaddr *, const struct sockaddr *, unsigned int); - -__private_extern__ u_long route_generation = 0; -extern int use_routegenid; - -/* - * sockaddr_in with embedded interface scope; this is used internally - * to keep track of scoped route entries in the routing table. The - * fact that such a scope is embedded in the structure is an artifact - * of the current implementation which could change in future. - */ -struct sockaddr_inifscope { - __uint8_t sin_len; - sa_family_t sin_family; - in_port_t sin_port; - struct in_addr sin_addr; - /* - * To avoid possible conflict with an overlaid sockaddr_inarp - * having sin_other set to SIN_PROXY, we use the first 4-bytes - * of sin_zero since sin_srcaddr is one of the unused fields - * in sockaddr_inarp. - */ - union { - char sin_zero[8]; - struct { - __uint32_t ifscope; - } _in_index; - } un; -#define sin_ifscope un._in_index.ifscope -}; - -#define SIN(sa) ((struct sockaddr_in *)(size_t)(sa)) -#define SINIFSCOPE(sa) ((struct sockaddr_inifscope *)(size_t)(sa)) +static struct rtentry *rte_alloc(void); +static void rte_free(struct rtentry *); +static void rtfree_common(struct rtentry *, boolean_t); +static void rte_if_ref(struct ifnet *, int); +static void rt_set_idleref(struct rtentry *); +static void rt_clear_idleref(struct rtentry *); +static void route_event_callback(void *); +static void rt_str4(struct rtentry *, char *, uint32_t, char *, uint32_t); +#if INET6 +static void rt_str6(struct rtentry *, char *, uint32_t, char *, uint32_t); +#endif /* INET6 */ + +uint32_t route_genid_inet = 0; +#if INET6 +uint32_t route_genid_inet6 = 0; +#endif /* INET6 */ #define ASSERT_SINIFSCOPE(sa) { \ if ((sa)->sa_family != AF_INET || \ @@ -224,6 +342,12 @@ struct sockaddr_inifscope { panic("%s: bad sockaddr_in %p\n", __func__, sa); \ } +#define ASSERT_SIN6IFSCOPE(sa) { \ + if ((sa)->sa_family != AF_INET6 || \ + (sa)->sa_len < sizeof (struct sockaddr_in6)) \ + panic("%s: bad sockaddr_in6 %p\n", __func__, sa); \ +} + /* * Argument to leaf-matching routine; at present it is scoped routing * specific but can be expanded in future to include other search filters. @@ -240,248 +364,579 @@ static struct sockaddr sin_def = { sizeof (struct sockaddr_in), AF_INET, { 0, } }; +static struct sockaddr_in6 sin6_def = { + sizeof (struct sockaddr_in6), AF_INET6, 0, 0, IN6ADDR_ANY_INIT, 0 +}; + /* * Interface index (scope) of the primary interface; determined at * the time when the default, non-scoped route gets added, changed - * or deleted. Protected by rt_mtx. + * or deleted. Protected by rnh_lock. */ static unsigned int primary_ifscope = IFSCOPE_NONE; +static unsigned int primary6_ifscope = IFSCOPE_NONE; -#define INET_DEFAULT(dst) \ - ((dst)->sa_family == AF_INET && SIN(dst)->sin_addr.s_addr == 0) +#define INET_DEFAULT(sa) \ + ((sa)->sa_family == AF_INET && SIN(sa)->sin_addr.s_addr == 0) +#define INET6_DEFAULT(sa) \ + ((sa)->sa_family == AF_INET6 && \ + IN6_IS_ADDR_UNSPECIFIED(&SIN6(sa)->sin6_addr)) + +#define SA_DEFAULT(sa) (INET_DEFAULT(sa) || INET6_DEFAULT(sa)) #define RT(r) ((struct rtentry *)r) +#define RN(r) ((struct radix_node *)r) #define RT_HOST(r) (RT(r)->rt_flags & RTF_HOST) +unsigned int rt_verbose = 0; +#if (DEVELOPMENT || DEBUG) +SYSCTL_DECL(_net_route); +SYSCTL_UINT(_net_route, OID_AUTO, verbose, CTLFLAG_RW | CTLFLAG_LOCKED, + &rt_verbose, 0, ""); +#endif /* (DEVELOPMENT || DEBUG) */ + +static void +rtable_init(void **table) +{ + struct domain *dom; + + domain_proto_mtx_lock_assert_held(); + + TAILQ_FOREACH(dom, &domains, dom_entry) { + if (dom->dom_rtattach != NULL) + dom->dom_rtattach(&table[dom->dom_family], + dom->dom_rtoffset); + } +} + +/* + * Called by route_dinit(). + */ +void +route_init(void) +{ + int size; + +#if INET6 + _CASSERT(offsetof(struct route, ro_rt) == + offsetof(struct route_in6, ro_rt)); + _CASSERT(offsetof(struct route, ro_lle) == + offsetof(struct route_in6, ro_lle)); + _CASSERT(offsetof(struct route, ro_srcia) == + offsetof(struct route_in6, ro_srcia)); + _CASSERT(offsetof(struct route, ro_flags) == + offsetof(struct route_in6, ro_flags)); + _CASSERT(offsetof(struct route, ro_dst) == + offsetof(struct route_in6, ro_dst)); +#endif /* INET6 */ + + PE_parse_boot_argn("rte_debug", &rte_debug, sizeof (rte_debug)); + if (rte_debug != 0) + rte_debug |= RTD_DEBUG; + + rnh_lock_grp_attr = lck_grp_attr_alloc_init(); + rnh_lock_grp = lck_grp_alloc_init("route", rnh_lock_grp_attr); + rnh_lock_attr = lck_attr_alloc_init(); + lck_mtx_init(rnh_lock, rnh_lock_grp, rnh_lock_attr); + + rte_mtx_grp_attr = lck_grp_attr_alloc_init(); + rte_mtx_grp = lck_grp_alloc_init(RTE_NAME, rte_mtx_grp_attr); + rte_mtx_attr = lck_attr_alloc_init(); + + lck_mtx_lock(rnh_lock); + rn_init(); /* initialize all zeroes, all ones, mask table */ + lck_mtx_unlock(rnh_lock); + rtable_init((void **)rt_tables); + + if (rte_debug & RTD_DEBUG) + size = sizeof (struct rtentry_dbg); + else + size = sizeof (struct rtentry); + + rte_zone = zinit(size, RTE_ZONE_MAX * size, 0, RTE_ZONE_NAME); + if (rte_zone == NULL) { + panic("%s: failed allocating rte_zone", __func__); + /* NOTREACHED */ + } + zone_change(rte_zone, Z_EXPAND, TRUE); + zone_change(rte_zone, Z_CALLERACCT, FALSE); + zone_change(rte_zone, Z_NOENCRYPT, TRUE); + + TAILQ_INIT(&rttrash_head); +} + /* * Given a route, determine whether or not it is the non-scoped default * route; dst typically comes from rt_key(rt) but may be coming from * a separate place when rt is in the process of being created. */ boolean_t -rt_inet_default(struct rtentry *rt, struct sockaddr *dst) +rt_primary_default(struct rtentry *rt, struct sockaddr *dst) { - return (INET_DEFAULT(dst) && !(rt->rt_flags & RTF_IFSCOPE)); + return (SA_DEFAULT(dst) && !(rt->rt_flags & RTF_IFSCOPE)); } /* - * Set the ifscope of the primary interface; caller holds rt_mtx. + * Set the ifscope of the primary interface; caller holds rnh_lock. */ void -set_primary_ifscope(unsigned int ifscope) +set_primary_ifscope(int af, unsigned int ifscope) { - primary_ifscope = ifscope; + if (af == AF_INET) + primary_ifscope = ifscope; + else + primary6_ifscope = ifscope; } /* - * Return the ifscope of the primary interface; caller holds rt_mtx. + * Return the ifscope of the primary interface; caller holds rnh_lock. */ unsigned int -get_primary_ifscope(void) +get_primary_ifscope(int af) { - return (primary_ifscope); + return (af == AF_INET ? primary_ifscope : primary6_ifscope); } /* - * Embed ifscope into a given a sockaddr_in. + * Set the scope ID of a given a sockaddr_in. */ -static inline void -sa_set_ifscope(struct sockaddr *sa, unsigned int ifscope) +void +sin_set_ifscope(struct sockaddr *sa, unsigned int ifscope) { /* Caller must pass in sockaddr_in */ ASSERT_SINIFSCOPE(sa); - SINIFSCOPE(sa)->sin_ifscope = ifscope; + SINIFSCOPE(sa)->sin_scope_id = ifscope; +} + +/* + * Set the scope ID of given a sockaddr_in6. + */ +static inline void +sin6_set_ifscope(struct sockaddr *sa, unsigned int ifscope) +{ + /* Caller must pass in sockaddr_in6 */ + ASSERT_SIN6IFSCOPE(sa); + + SIN6IFSCOPE(sa)->sin6_scope_id = ifscope; } /* - * Given a sockaddr_in, return the embedded ifscope to the caller. + * Given a sockaddr_in, return the scope ID to the caller. */ unsigned int -sa_get_ifscope(struct sockaddr *sa) +sin_get_ifscope(struct sockaddr *sa) { /* Caller must pass in sockaddr_in */ ASSERT_SINIFSCOPE(sa); - return (SINIFSCOPE(sa)->sin_ifscope); + return (SINIFSCOPE(sa)->sin_scope_id); } /* - * Copy a sockaddr_in src to dst and embed ifscope into dst. + * Given a sockaddr_in6, return the scope ID to the caller. */ -static struct sockaddr * -sin_copy(struct sockaddr_in *src, struct sockaddr_in *dst, unsigned int ifscope) +unsigned int +sin6_get_ifscope(struct sockaddr *sa) +{ + /* Caller must pass in sockaddr_in6 */ + ASSERT_SIN6IFSCOPE(sa); + + return (SIN6IFSCOPE(sa)->sin6_scope_id); +} + +static inline void +sin6_set_embedded_ifscope(struct sockaddr *sa, unsigned int ifscope) +{ + /* Caller must pass in sockaddr_in6 */ + ASSERT_SIN6IFSCOPE(sa); + VERIFY(IN6_IS_SCOPE_EMBED(&(SIN6(sa)->sin6_addr))); + + SIN6(sa)->sin6_addr.s6_addr16[1] = htons(ifscope); +} + +static inline unsigned int +sin6_get_embedded_ifscope(struct sockaddr *sa) +{ + /* Caller must pass in sockaddr_in6 */ + ASSERT_SIN6IFSCOPE(sa); + + return (ntohs(SIN6(sa)->sin6_addr.s6_addr16[1])); +} + +/* + * Copy a sockaddr_{in,in6} src to a dst storage and set scope ID into dst. + * + * To clear the scope ID, pass is a NULL pifscope. To set the scope ID, pass + * in a non-NULL pifscope with non-zero ifscope. Otherwise if pifscope is + * non-NULL and ifscope is IFSCOPE_NONE, the existing scope ID is left intact. + * In any case, the effective scope ID value is returned to the caller via + * pifscope, if it is non-NULL. + */ +struct sockaddr * +sa_copy(struct sockaddr *src, struct sockaddr_storage *dst, + unsigned int *pifscope) { - *dst = *src; - sa_set_ifscope(SA(dst), ifscope); + int af = src->sa_family; + unsigned int ifscope = (pifscope != NULL) ? *pifscope : IFSCOPE_NONE; + + VERIFY(af == AF_INET || af == AF_INET6); + + bzero(dst, sizeof (*dst)); + + if (af == AF_INET) { + bcopy(src, dst, sizeof (struct sockaddr_in)); + if (pifscope == NULL || ifscope != IFSCOPE_NONE) + sin_set_ifscope(SA(dst), ifscope); + } else { + bcopy(src, dst, sizeof (struct sockaddr_in6)); + if (pifscope != NULL && + IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr)) { + unsigned int eifscope; + /* + * If the address contains the embedded scope ID, + * use that as the value for sin6_scope_id as long + * the caller doesn't insist on clearing it (by + * passing NULL) or setting it. + */ + eifscope = sin6_get_embedded_ifscope(SA(dst)); + if (eifscope != IFSCOPE_NONE && ifscope == IFSCOPE_NONE) + ifscope = eifscope; + if (ifscope != IFSCOPE_NONE) { + /* Set ifscope from pifscope or eifscope */ + sin6_set_ifscope(SA(dst), ifscope); + } else { + /* If sin6_scope_id has a value, use that one */ + ifscope = sin6_get_ifscope(SA(dst)); + } + /* + * If sin6_scope_id is set but the address doesn't + * contain the equivalent embedded value, set it. + */ + if (ifscope != IFSCOPE_NONE && eifscope != ifscope) + sin6_set_embedded_ifscope(SA(dst), ifscope); + } else if (pifscope == NULL || ifscope != IFSCOPE_NONE) { + sin6_set_ifscope(SA(dst), ifscope); + } + } + + if (pifscope != NULL) { + *pifscope = (af == AF_INET) ? sin_get_ifscope(SA(dst)) : + sin6_get_ifscope(SA(dst)); + } return (SA(dst)); } /* - * Copy a mask from src to a sockaddr_in dst and embed ifscope into dst. + * Copy a mask from src to a dst storage and set scope ID into dst. */ static struct sockaddr * -mask_copy(struct sockaddr *src, struct sockaddr_in *dst, unsigned int ifscope) +ma_copy(int af, struct sockaddr *src, struct sockaddr_storage *dst, + unsigned int ifscope) { - /* We know dst is at least the size of sockaddr{_in} */ + VERIFY(af == AF_INET || af == AF_INET6); + bzero(dst, sizeof (*dst)); rt_maskedcopy(src, SA(dst), src); /* * The length of the mask sockaddr would need to be adjusted - * to cover the additional sin_ifscope field; when ifscope is - * IFSCOPE_NONE, we'd end up clearing the embedded ifscope on + * to cover the additional {sin,sin6}_ifscope field; when ifscope + * is IFSCOPE_NONE, we'd end up clearing the scope ID field on * the destination mask in addition to extending the length * of the sockaddr, as a side effect. This is okay, as any * trailing zeroes would be skipped by rn_addmask prior to * inserting or looking up the mask in the mask tree. */ - SINIFSCOPE(dst)->sin_ifscope = ifscope; - SINIFSCOPE(dst)->sin_len = - offsetof(struct sockaddr_inifscope, sin_ifscope) + - sizeof (SINIFSCOPE(dst)->sin_ifscope); + if (af == AF_INET) { + SINIFSCOPE(dst)->sin_scope_id = ifscope; + SINIFSCOPE(dst)->sin_len = + offsetof(struct sockaddr_inifscope, sin_scope_id) + + sizeof (SINIFSCOPE(dst)->sin_scope_id); + } else { + SIN6IFSCOPE(dst)->sin6_scope_id = ifscope; + SIN6IFSCOPE(dst)->sin6_len = + offsetof(struct sockaddr_in6, sin6_scope_id) + + sizeof (SIN6IFSCOPE(dst)->sin6_scope_id); + } return (SA(dst)); } /* - * Callback leaf-matching routine for rn_matchaddr_args used - * for looking up an exact match for a scoped route entry. + * Trim trailing zeroes on a sockaddr and update its length. */ -static int -rn_match_ifscope(struct radix_node *rn, void *arg) +static struct sockaddr * +sa_trim(struct sockaddr *sa, int skip) { - struct rtentry *rt = (struct rtentry *)rn; - struct matchleaf_arg *ma = arg; - - if (!(rt->rt_flags & RTF_IFSCOPE) || rt_key(rt)->sa_family != AF_INET) - return (0); + caddr_t cp, base = (caddr_t)sa + skip; + + if (sa->sa_len <= skip) + return (sa); + + for (cp = base + (sa->sa_len - skip); cp > base && cp[-1] == 0; ) + cp--; + + sa->sa_len = (cp - base) + skip; + if (sa->sa_len < skip) { + /* Must not happen, and if so, panic */ + panic("%s: broken logic (sa_len %d < skip %d )", __func__, + sa->sa_len, skip); + /* NOTREACHED */ + } else if (sa->sa_len == skip) { + /* If we end up with all zeroes, then there's no mask */ + sa->sa_len = 0; + } - return (SINIFSCOPE(rt_key(rt))->sin_ifscope == ma->ifscope); + return (sa); } -static void -rtable_init(void **table) +/* + * Called by rtm_msg{1,2} routines to "scrub" socket address structures of + * kernel private information, so that clients of the routing socket will + * not be confused by the presence of the information, or the side effect of + * the increased length due to that. The source sockaddr is not modified; + * instead, the scrubbing happens on the destination sockaddr storage that + * is passed in by the caller. + * + * Scrubbing entails: + * - removing embedded scope identifiers from network mask and destination + * IPv4 and IPv6 socket addresses + * - optionally removing global scope interface hardware addresses from + * link-layer interface addresses when the MAC framework check fails. + */ +struct sockaddr * +rtm_scrub(int type, int idx, struct sockaddr *hint, struct sockaddr *sa, + void *buf, uint32_t buflen, kauth_cred_t *credp) { - struct domain *dom; - for (dom = domains; dom; dom = dom->dom_next) - if (dom->dom_rtattach) - dom->dom_rtattach(&table[dom->dom_family], - dom->dom_rtoffset); -} + struct sockaddr_storage *ss = (struct sockaddr_storage *)buf; + struct sockaddr *ret = sa; -void -route_init(void) -{ - int size; + VERIFY(buf != NULL && buflen >= sizeof (*ss)); + bzero(buf, buflen); - PE_parse_boot_argn("rte_debug", &rte_debug, sizeof (rte_debug)); - if (rte_debug != 0) - rte_debug |= RTD_DEBUG; + switch (idx) { + case RTAX_DST: + /* + * If this is for an AF_INET/AF_INET6 destination address, + * call sa_copy() to clear the scope ID field. + */ + if (sa->sa_family == AF_INET && + SINIFSCOPE(sa)->sin_scope_id != IFSCOPE_NONE) { + ret = sa_copy(sa, ss, NULL); + } else if (sa->sa_family == AF_INET6 && + SIN6IFSCOPE(sa)->sin6_scope_id != IFSCOPE_NONE) { + ret = sa_copy(sa, ss, NULL); + } + break; - rt_mtx_grp_attr = lck_grp_attr_alloc_init(); + case RTAX_NETMASK: { + int skip, af; + /* + * If this is for a mask, we can't tell whether or not there + * is an valid scope ID value, as the span of bytes between + * sa_len and the beginning of the mask (offset of sin_addr in + * the case of AF_INET, or sin6_addr for AF_INET6) may be + * filled with all-ones by rn_addmask(), and hence we cannot + * rely on sa_family. Because of this, we use the sa_family + * of the hint sockaddr (RTAX_{DST,IFA}) as indicator as to + * whether or not the mask is to be treated as one for AF_INET + * or AF_INET6. Clearing the scope ID field involves setting + * it to IFSCOPE_NONE followed by calling sa_trim() to trim + * trailing zeroes from the storage sockaddr, which reverses + * what was done earlier by ma_copy() on the source sockaddr. + */ + if (hint == NULL || + ((af = hint->sa_family) != AF_INET && af != AF_INET6)) + break; /* nothing to do */ - rt_mtx_grp = lck_grp_alloc_init("route", rt_mtx_grp_attr); + skip = (af == AF_INET) ? + offsetof(struct sockaddr_in, sin_addr) : + offsetof(struct sockaddr_in6, sin6_addr); - rt_mtx_attr = lck_attr_alloc_init(); + if (sa->sa_len > skip && sa->sa_len <= sizeof (*ss)) { + bcopy(sa, ss, sa->sa_len); + /* + * Don't use {sin,sin6}_set_ifscope() as sa_family + * and sa_len for the netmask might not be set to + * the corresponding expected values of the hint. + */ + if (hint->sa_family == AF_INET) + SINIFSCOPE(ss)->sin_scope_id = IFSCOPE_NONE; + else + SIN6IFSCOPE(ss)->sin6_scope_id = IFSCOPE_NONE; + ret = sa_trim(SA(ss), skip); - if ((rt_mtx = lck_mtx_alloc_init(rt_mtx_grp, rt_mtx_attr)) == NULL) { - printf("route_init: can't alloc rt_mtx\n"); - return; + /* + * For AF_INET6 mask, set sa_len appropriately unless + * this is requested via systl_dumpentry(), in which + * case we return the raw value. + */ + if (hint->sa_family == AF_INET6 && + type != RTM_GET && type != RTM_GET2) + SA(ret)->sa_len = sizeof (struct sockaddr_in6); + } + break; + } + case RTAX_GATEWAY: { + /* + * Break if the gateway is not AF_LINK type (indirect routes) + * + * Else, if is, check if it is resolved. If not yet resolved + * simply break else scrub the link layer address. + */ + if ((sa->sa_family != AF_LINK) || (SDL(sa)->sdl_alen == 0)) + break; + /* fallthrough */ + } + case RTAX_IFP: { + if (sa->sa_family == AF_LINK && credp) { + struct sockaddr_dl *sdl = SDL(buf); + const void *bytes; + size_t size; + + /* caller should handle worst case: SOCK_MAXADDRLEN */ + VERIFY(buflen >= sa->sa_len); + + bcopy(sa, sdl, sa->sa_len); + bytes = dlil_ifaddr_bytes(sdl, &size, credp); + if (bytes != CONST_LLADDR(sdl)) { + VERIFY(sdl->sdl_alen == size); + bcopy(bytes, LLADDR(sdl), size); + } + ret = (struct sockaddr *)sdl; + } + break; + } + default: + break; } - lck_mtx_lock(rt_mtx); - rn_init(); /* initialize all zeroes, all ones, mask table */ - lck_mtx_unlock(rt_mtx); - rtable_init((void **)rt_tables); - route_domain_mtx = routedomain.dom_mtx; - - if (rte_debug & RTD_DEBUG) - size = sizeof (struct rtentry_dbg); - else - size = sizeof (struct rtentry); + return (ret); +} - rte_zone = zinit(size, RTE_ZONE_MAX * size, 0, RTE_ZONE_NAME); - if (rte_zone == NULL) - panic("route_init: failed allocating rte_zone"); +/* + * Callback leaf-matching routine for rn_matchaddr_args used + * for looking up an exact match for a scoped route entry. + */ +static int +rn_match_ifscope(struct radix_node *rn, void *arg) +{ + struct rtentry *rt = (struct rtentry *)rn; + struct matchleaf_arg *ma = arg; + int af = rt_key(rt)->sa_family; - zone_change(rte_zone, Z_EXPAND, TRUE); + if (!(rt->rt_flags & RTF_IFSCOPE) || (af != AF_INET && af != AF_INET6)) + return (0); - TAILQ_INIT(&rttrash_head); + return (af == AF_INET ? + (SINIFSCOPE(rt_key(rt))->sin_scope_id == ma->ifscope) : + (SIN6IFSCOPE(rt_key(rt))->sin6_scope_id == ma->ifscope)); } /* - * Packet routing routines. + * Atomically increment route generation counter */ void -rtalloc(struct route *ro) +routegenid_update(void) +{ + routegenid_inet_update(); +#if INET6 + routegenid_inet6_update(); +#endif /* INET6 */ +} + +void +routegenid_inet_update(void) +{ + atomic_add_32(&route_genid_inet, 1); +} + +#if INET6 +void +routegenid_inet6_update(void) { - rtalloc_ign(ro, 0UL); + atomic_add_32(&route_genid_inet6, 1); } +#endif /* INET6 */ +/* + * Packet routing routines. + */ void -rtalloc_ign_locked(struct route *ro, u_long ignore) +rtalloc(struct route *ro) { - return (rtalloc_ign_common_locked(ro, ignore, IFSCOPE_NONE)); + rtalloc_ign(ro, 0); } void -rtalloc_scoped_ign_locked(struct route *ro, u_long ignore, unsigned int ifscope) +rtalloc_scoped(struct route *ro, unsigned int ifscope) { - return (rtalloc_ign_common_locked(ro, ignore, ifscope)); + rtalloc_scoped_ign(ro, 0, ifscope); } static void -rtalloc_ign_common_locked(struct route *ro, u_long ignore, +rtalloc_ign_common_locked(struct route *ro, uint32_t ignore, unsigned int ifscope) { struct rtentry *rt; if ((rt = ro->ro_rt) != NULL) { - if (rt->rt_ifp != NULL && rt->rt_flags & RTF_UP) + RT_LOCK_SPIN(rt); + if (rt->rt_ifp != NULL && !ROUTE_UNUSABLE(ro)) { + RT_UNLOCK(rt); return; - rtfree_locked(rt); - ro->ro_rt = NULL; + } + RT_UNLOCK(rt); + ROUTE_RELEASE_LOCKED(ro); /* rnh_lock already held */ } ro->ro_rt = rtalloc1_common_locked(&ro->ro_dst, 1, ignore, ifscope); - if (ro->ro_rt) - ro->ro_rt->generation_id = route_generation; + if (ro->ro_rt != NULL) { + RT_GENID_SYNC(ro->ro_rt); + RT_LOCK_ASSERT_NOTHELD(ro->ro_rt); + } } + void -rtalloc_ign(struct route *ro, u_long ignore) +rtalloc_ign(struct route *ro, uint32_t ignore) { - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); - rtalloc_ign_locked(ro, ignore); - lck_mtx_unlock(rt_mtx); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); + rtalloc_ign_common_locked(ro, ignore, IFSCOPE_NONE); + lck_mtx_unlock(rnh_lock); } -struct rtentry * -rtalloc1_locked(struct sockaddr *dst, int report, u_long ignflags) +void +rtalloc_scoped_ign(struct route *ro, uint32_t ignore, unsigned int ifscope) +{ + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); + rtalloc_ign_common_locked(ro, ignore, ifscope); + lck_mtx_unlock(rnh_lock); +} + +static struct rtentry * +rtalloc1_locked(struct sockaddr *dst, int report, uint32_t ignflags) { return (rtalloc1_common_locked(dst, report, ignflags, IFSCOPE_NONE)); } struct rtentry * -rtalloc1_scoped_locked(struct sockaddr *dst, int report, u_long ignflags, +rtalloc1_scoped_locked(struct sockaddr *dst, int report, uint32_t ignflags, unsigned int ifscope) { return (rtalloc1_common_locked(dst, report, ignflags, ifscope)); } -/* - * Look up the route that matches the address given - * Or, at least try.. Create a cloned route if needed. - */ -static struct rtentry * -rtalloc1_common_locked(struct sockaddr *dst, int report, u_long ignflags, +struct rtentry * +rtalloc1_common_locked(struct sockaddr *dst, int report, uint32_t ignflags, unsigned int ifscope) { struct radix_node_head *rnh = rt_tables[dst->sa_family]; struct rtentry *rt, *newrt = NULL; struct rt_addrinfo info; - u_long nflags; + uint32_t nflags; int err = 0, msgtype = RTM_MISS; if (rnh == NULL) @@ -495,8 +950,10 @@ rtalloc1_common_locked(struct sockaddr *dst, int report, u_long ignflags, if (rt == NULL) goto unreachable; + RT_LOCK_SPIN(rt); newrt = rt; nflags = rt->rt_flags & ~ignflags; + RT_UNLOCK(rt); if (report && (nflags & (RTF_CLONING | RTF_PRCLONING))) { /* * We are apparently adding (report = 0 in delete). @@ -521,6 +978,38 @@ rtalloc1_common_locked(struct sockaddr *dst, int report, u_long ignflags, * reference held during rtrequest. */ rtfree_locked(rt); + + /* + * If the newly created cloned route is a direct host route + * then also check if it is to a router or not. + * If it is, then set the RTF_ROUTER flag on the host route + * for the gateway. + * + * XXX It is possible for the default route to be created post + * cloned route creation of router's IP. + * We can handle that corner case by special handing for RTM_ADD + * of default route. + */ + if ((newrt->rt_flags & (RTF_HOST | RTF_LLINFO)) == + (RTF_HOST | RTF_LLINFO)) { + struct rtentry *defrt = NULL; + struct sockaddr_storage def_key; + + bzero(&def_key, sizeof(def_key)); + def_key.ss_len = rt_key(newrt)->sa_len; + def_key.ss_family = rt_key(newrt)->sa_family; + + defrt = rtalloc1_scoped_locked((struct sockaddr *)&def_key, + 0, 0, newrt->rt_ifp->if_index); + + if (defrt) { + if (equal(rt_key(newrt), defrt->rt_gateway)) { + newrt->rt_flags |= RTF_ROUTER; + } + rtfree_locked(defrt); + } + } + if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) { /* * If the new route specifies it be @@ -538,6 +1027,7 @@ unreachable: * Which basically means "cant get there from here" */ rtstat.rts_unreach++; + miss: if (report) { /* @@ -554,46 +1044,104 @@ done: } struct rtentry * -rtalloc1(struct sockaddr *dst, int report, u_long ignflags) +rtalloc1(struct sockaddr *dst, int report, uint32_t ignflags) { - struct rtentry * entry; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); + struct rtentry *entry; + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); entry = rtalloc1_locked(dst, report, ignflags); - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); return (entry); } -/* - * Remove a reference count from an rtentry. - * If the count gets low enough, take it out of the routing table +struct rtentry * +rtalloc1_scoped(struct sockaddr *dst, int report, uint32_t ignflags, + unsigned int ifscope) +{ + struct rtentry *entry; + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); + entry = rtalloc1_scoped_locked(dst, report, ignflags, ifscope); + lck_mtx_unlock(rnh_lock); + return (entry); +} + +/* + * Remove a reference count from an rtentry. + * If the count gets low enough, take it out of the routing table */ void rtfree_locked(struct rtentry *rt) { - /* - * find the tree for that address family - * Note: in the case of igmp packets, there might not be an rnh - */ + rtfree_common(rt, TRUE); +} + +static void +rtfree_common(struct rtentry *rt, boolean_t locked) +{ struct radix_node_head *rnh; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + LCK_MTX_ASSERT(rnh_lock, locked ? + LCK_MTX_ASSERT_OWNED : LCK_MTX_ASSERT_NOTOWNED); - /* See 3582620 - We hit this during the transition from funnels to locks */ - if (rt == 0) { - printf("rtfree - rt is NULL\n"); + /* + * Atomically decrement the reference count and if it reaches 0, + * and there is a close function defined, call the close function. + */ + RT_LOCK_SPIN(rt); + if (rtunref(rt) > 0) { + RT_UNLOCK(rt); return; } - - rnh = rt_tables[rt_key(rt)->sa_family]; /* - * decrement the reference count by one and if it reaches 0, - * and there is a close function defined, call the close function + * To avoid violating lock ordering, we must drop rt_lock before + * trying to acquire the global rnh_lock. If we are called with + * rnh_lock held, then we already have exclusive access; otherwise + * we do the lock dance. */ - rtunref(rt); - if (rt->rt_refcnt > 0) - return; + if (!locked) { + /* + * Note that we check it again below after grabbing rnh_lock, + * since it is possible that another thread doing a lookup wins + * the race, grabs the rnh_lock first, and bumps up reference + * count in which case the route should be left alone as it is + * still in use. It's also possible that another thread frees + * the route after we drop rt_lock; to prevent the route from + * being freed, we hold an extra reference. + */ + RT_ADDREF_LOCKED(rt); + RT_UNLOCK(rt); + lck_mtx_lock(rnh_lock); + RT_LOCK_SPIN(rt); + if (rtunref(rt) > 0) { + /* We've lost the race, so abort */ + RT_UNLOCK(rt); + goto done; + } + } + + /* + * We may be blocked on other lock(s) as part of freeing + * the entry below, so convert from spin to full mutex. + */ + RT_CONVERT_LOCK(rt); + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + + /* Negative refcnt must never happen */ + if (rt->rt_refcnt != 0) { + panic("rt %p invalid refcnt %d", rt, rt->rt_refcnt); + /* NOTREACHED */ + } + /* Idle refcnt must have been dropped during rtunref() */ + VERIFY(!(rt->rt_flags & RTF_IFREF)); + + /* + * find the tree for that address family + * Note: in the case of igmp packets, there might not be an rnh + */ + rnh = rt_tables[rt_key(rt)->sa_family]; /* * On last reference give the "close method" a chance to cleanup @@ -603,68 +1151,102 @@ rtfree_locked(struct rtentry *rt) * close routine typically issues RTM_DELETE which clears the RTF_UP * flag on the entry so that the code below reclaims the storage. */ - if (rnh && rnh->rnh_close && rt->rt_refcnt == 0) + if (rnh != NULL && rnh->rnh_close != NULL) rnh->rnh_close((struct radix_node *)rt, rnh); /* - * If we are no longer "up" (and ref == 0) - * then we can free the resources associated - * with the route. + * If we are no longer "up" (and ref == 0) then we can free the + * resources associated with the route. */ if (!(rt->rt_flags & RTF_UP)) { - if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)) - panic ("rtfree 2"); + struct rtentry *rt_parent; + struct ifaddr *rt_ifa; + + rt->rt_flags |= RTF_DEAD; + if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)) { + panic("rt %p freed while in radix tree\n", rt); + /* NOTREACHED */ + } /* * the rtentry must have been removed from the routing table - * so it is represented in rttrash.. remove that now. + * so it is represented in rttrash; remove that now. */ - (void) OSDecrementAtomic((SInt32 *)&rttrash); + (void) OSDecrementAtomic(&rttrash); if (rte_debug & RTD_DEBUG) { TAILQ_REMOVE(&rttrash_head, (struct rtentry_dbg *)rt, rtd_trash_link); } -#ifdef DIAGNOSTIC - if (rt->rt_refcnt < 0) { - printf("rtfree: %p not freed (neg refs) cnt=%d\n", - rt, rt->rt_refcnt); - return; - } -#endif - /* * release references on items we hold them on.. * e.g other routes and ifaddrs. */ - if (rt->rt_parent) - rtfree_locked(rt->rt_parent); + if ((rt_parent = rt->rt_parent) != NULL) + rt->rt_parent = NULL; - if(rt->rt_ifa) { - ifafree(rt->rt_ifa); + if ((rt_ifa = rt->rt_ifa) != NULL) rt->rt_ifa = NULL; + + /* + * Now free any attached link-layer info. + */ + if (rt->rt_llinfo != NULL) { + if (rt->rt_llinfo_free != NULL) + (*rt->rt_llinfo_free)(rt->rt_llinfo); + else + R_Free(rt->rt_llinfo); + rt->rt_llinfo = NULL; } + /* Destroy eventhandler lists context */ + eventhandler_lists_ctxt_destroy(&rt->rt_evhdlr_ctxt); + + /* + * Route is no longer in the tree and refcnt is 0; + * we have exclusive access, so destroy it. + */ + RT_UNLOCK(rt); + rte_lock_destroy(rt); + + if (rt_parent != NULL) + rtfree_locked(rt_parent); + + if (rt_ifa != NULL) + IFA_REMREF(rt_ifa); + /* - * The key is separatly alloc'd so free it (see rt_setgate()). + * The key is separately alloc'd so free it (see rt_setgate()). * This also frees the gateway, as they are always malloc'd * together. */ R_Free(rt_key(rt)); + /* + * Free any statistics that may have been allocated + */ + nstat_route_detach(rt); + /* * and the rtentry itself of course */ rte_free(rt); + } else { + /* + * The "close method" has been called, but the route is + * still in the radix tree with zero refcnt, i.e. "up" + * and in the cached state. + */ + RT_UNLOCK(rt); } +done: + if (!locked) + lck_mtx_unlock(rnh_lock); } void rtfree(struct rtentry *rt) { - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); - rtfree_locked(rt); - lck_mtx_unlock(rt_mtx); + rtfree_common(rt, FALSE); } /* @@ -672,38 +1254,43 @@ rtfree(struct rtentry *rt) * the refcount reaches zero. Unless you have really good reason, * use rtfree not rtunref. */ -void +int rtunref(struct rtentry *p) { - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + RT_LOCK_ASSERT_HELD(p); - if (p->rt_refcnt <= 0) - panic("rtunref: bad refcnt %d for rt=%p\n", p->rt_refcnt, p); + if (p->rt_refcnt == 0) { + panic("%s(%p) bad refcnt\n", __func__, p); + /* NOTREACHED */ + } else if (--p->rt_refcnt == 0) { + /* + * Release any idle reference count held on the interface; + * if the route is eligible, still UP and the refcnt becomes + * non-zero at some point in future before it is purged from + * the routing table, rt_set_idleref() will undo this. + */ + rt_clear_idleref(p); + } if (rte_debug & RTD_DEBUG) rtunref_audit((struct rtentry_dbg *)p); - p->rt_refcnt--; + /* Return new value */ + return (p->rt_refcnt); } static inline void rtunref_audit(struct rtentry_dbg *rte) { - if (rte->rtd_inuse != RTD_INUSE) - panic("rtunref: on freed rte=%p\n", rte); - - rte->rtd_refrele_cnt++; + uint16_t idx; - if (rte_debug & RTD_TRACE) { - rte->rtd_refrele[rte->rtd_refrele_next].th = current_thread(); - bzero(rte->rtd_refrele[rte->rtd_refrele_next].pc, - sizeof (rte->rtd_refrele[rte->rtd_refrele_next].pc)); - (void) OSBacktrace(rte->rtd_refrele[rte->rtd_refrele_next].pc, - RTD_TRSTACK_SIZE); - - rte->rtd_refrele_next = - (rte->rtd_refrele_next + 1) % RTD_REFHIST_SIZE; + if (rte->rtd_inuse != RTD_INUSE) { + panic("rtunref: on freed rte=%p\n", rte); + /* NOTREACHED */ } + idx = atomic_add_16_ov(&rte->rtd_refrele_cnt, 1) % CTRACE_HIST_SIZE; + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_refrele[idx]); } /* @@ -712,84 +1299,61 @@ rtunref_audit(struct rtentry_dbg *rte) void rtref(struct rtentry *p) { - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + RT_LOCK_ASSERT_HELD(p); - if (p->rt_refcnt < 0) - panic("rtref: bad refcnt %d for rt=%p\n", p->rt_refcnt, p); + VERIFY((p->rt_flags & RTF_DEAD) == 0); + if (++p->rt_refcnt == 0) { + panic("%s(%p) bad refcnt\n", __func__, p); + /* NOTREACHED */ + } else if (p->rt_refcnt == 1) { + /* + * Hold an idle reference count on the interface, + * if the route is eligible for it. + */ + rt_set_idleref(p); + } if (rte_debug & RTD_DEBUG) rtref_audit((struct rtentry_dbg *)p); - - p->rt_refcnt++; } static inline void rtref_audit(struct rtentry_dbg *rte) { - if (rte->rtd_inuse != RTD_INUSE) - panic("rtref_audit: on freed rte=%p\n", rte); - - rte->rtd_refhold_cnt++; + uint16_t idx; - if (rte_debug & RTD_TRACE) { - rte->rtd_refhold[rte->rtd_refhold_next].th = current_thread(); - bzero(rte->rtd_refhold[rte->rtd_refhold_next].pc, - sizeof (rte->rtd_refhold[rte->rtd_refhold_next].pc)); - (void) OSBacktrace(rte->rtd_refhold[rte->rtd_refhold_next].pc, - RTD_TRSTACK_SIZE); - - rte->rtd_refhold_next = - (rte->rtd_refhold_next + 1) % RTD_REFHIST_SIZE; + if (rte->rtd_inuse != RTD_INUSE) { + panic("rtref_audit: on freed rte=%p\n", rte); + /* NOTREACHED */ } + idx = atomic_add_16_ov(&rte->rtd_refhold_cnt, 1) % CTRACE_HIST_SIZE; + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_refhold[idx]); } void -rtsetifa(struct rtentry *rt, struct ifaddr* ifa) +rtsetifa(struct rtentry *rt, struct ifaddr *ifa) { - if (rt == NULL) - panic("rtsetifa"); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + + RT_LOCK_ASSERT_HELD(rt); if (rt->rt_ifa == ifa) return; + /* Become a regular mutex, just in case */ + RT_CONVERT_LOCK(rt); + /* Release the old ifa */ if (rt->rt_ifa) - ifafree(rt->rt_ifa); + IFA_REMREF(rt->rt_ifa); /* Set rt_ifa */ rt->rt_ifa = ifa; /* Take a reference to the ifa */ if (rt->rt_ifa) - ifaref(rt->rt_ifa); -} - -void -ifafree(struct ifaddr *ifa) -{ - int oldval; - - if (ifa == NULL) - panic("ifafree"); - - oldval = OSAddAtomic(-1, (SInt32 *)&ifa->ifa_refcnt); - - if (oldval == 0) { - if ((ifa->ifa_debug & IFA_ATTACHED) != 0) { - panic("ifa attached to ifp is being freed\n"); - } - FREE(ifa, M_IFADDR); - } -} - -void -ifaref(struct ifaddr *ifa) -{ - if (ifa == NULL) - panic("ifaref"); - - if (OSAddAtomic(1, (SInt32 *)&ifa->ifa_refcnt) == 0xffffffff) - panic("ifaref - reference count rolled over!"); + IFA_ADDREF(rt->rt_ifa); } /* @@ -800,8 +1364,8 @@ ifaref(struct ifaddr *ifa) */ void rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, - struct sockaddr *netmask, int flags, struct sockaddr *src, - struct rtentry **rtp) + struct sockaddr *netmask, int flags, struct sockaddr *src, + struct rtentry **rtp) { struct rtentry *rt = NULL; int error = 0; @@ -809,10 +1373,22 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, struct rt_addrinfo info; struct ifaddr *ifa = NULL; unsigned int ifscope = (ifp != NULL) ? ifp->if_index : IFSCOPE_NONE; - struct sockaddr_in sin; + struct sockaddr_storage ss; + int af = src->sa_family; + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); + /* + * Transform src into the internal routing table form for + * comparison against rt_gateway below. + */ +#if INET6 + if ((af == AF_INET) || (af == AF_INET6)) +#else + if (af == AF_INET) +#endif /* !INET6 */ + src = sa_copy(src, &ss, &ifscope); /* * Verify the gateway is directly reachable; if scoped routing @@ -826,49 +1402,54 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, /* Lookup route to the destination (from the original IP header) */ rt = rtalloc1_scoped_locked(dst, 0, RTF_CLONING|RTF_PRCLONING, ifscope); - - /* Embed scope in src for comparison against rt_gateway below */ - if (ip_doscopedroute && src->sa_family == AF_INET) - src = sin_copy(SIN(src), &sin, ifscope); + if (rt != NULL) + RT_LOCK(rt); /* * If the redirect isn't from our current router for this dst, * it's either old or wrong. If it redirects us to ourselves, * we have a routing loop, perhaps as a result of an interface - * going down recently. + * going down recently. Holding rnh_lock here prevents the + * possibility of rt_ifa/ifa's ifa_addr from changing (e.g. + * in_ifinit), so okay to access ifa_addr without locking. */ - if (!(flags & RTF_DONE) && rt && - (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr, - ifa->ifa_addr))) { + if (!(flags & RTF_DONE) && rt != NULL && + (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr, + ifa->ifa_addr))) { error = EINVAL; } else { - ifafree(ifa); + IFA_REMREF(ifa); if ((ifa = ifa_ifwithaddr(gateway))) { - ifafree(ifa); + IFA_REMREF(ifa); ifa = NULL; error = EHOSTUNREACH; } } - + if (ifa) { - ifafree(ifa); + IFA_REMREF(ifa); ifa = NULL; } - - if (error) + + if (error) { + if (rt != NULL) + RT_UNLOCK(rt); goto done; + } + /* * Create a new entry if we just got back a wildcard entry * or the the lookup failed. This is necessary for hosts * which use routing redirects generated by smart gateways * to dynamically build the routing tables. */ - if ((rt == 0) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2)) + if ((rt == NULL) || (rt_mask(rt) != NULL && rt_mask(rt)->sa_len < 2)) goto create; /* * Don't listen to the redirect if it's * for a route to an interface. */ + RT_LOCK_ASSERT_HELD(rt); if (rt->rt_flags & RTF_GATEWAY) { if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) { /* @@ -877,7 +1458,9 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, * to net; similar to cloned routes, the newly * created host route is scoped as well. */ - create: +create: + if (rt != NULL) + RT_UNLOCK(rt); flags |= RTF_GATEWAY | RTF_DYNAMIC; error = rtrequest_scoped_locked(RTM_ADD, dst, gateway, netmask, flags, NULL, ifscope); @@ -894,14 +1477,23 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, * add the key and gateway (in one malloc'd chunk). */ error = rt_setgate(rt, rt_key(rt), gateway); + RT_UNLOCK(rt); } } else { + RT_UNLOCK(rt); error = EHOSTUNREACH; } done: - if (rt) { - if (rtp && !error) - *rtp = rt; + if (rt != NULL) { + RT_LOCK_ASSERT_NOTHELD(rt); + if (!error) { + /* Enqueue event to refresh flow route entries */ + route_event_enqueue_nwk_wq_entry(rt, NULL, ROUTE_ENTRY_REFRESH, NULL, FALSE); + if (rtp) + *rtp = rt; + else + rtfree_locked(rt); + } else rtfree_locked(rt); } @@ -911,30 +1503,31 @@ out: } else { if (stat != NULL) (*stat)++; - if (use_routegenid) - route_generation++; + + if (af == AF_INET) + routegenid_inet_update(); +#if INET6 + else if (af == AF_INET6) + routegenid_inet6_update(); +#endif /* INET6 */ } + lck_mtx_unlock(rnh_lock); bzero((caddr_t)&info, sizeof(info)); info.rti_info[RTAX_DST] = dst; info.rti_info[RTAX_GATEWAY] = gateway; info.rti_info[RTAX_NETMASK] = netmask; info.rti_info[RTAX_AUTHOR] = src; rt_missmsg(RTM_REDIRECT, &info, flags, error); - lck_mtx_unlock(rt_mtx); } /* * Routing table ioctl interface. */ int -rtioctl(int req, caddr_t data, struct proc *p) +rtioctl(unsigned long req, caddr_t data, struct proc *p) { -#pragma unused(p) -#if INET && MROUTING - return mrt_ioctl(req, data); -#else - return ENXIO; -#endif +#pragma unused(p, req, data) + return (ENXIO); } struct ifaddr * @@ -945,9 +1538,9 @@ ifa_ifwithroute( { struct ifaddr *ifa; - lck_mtx_lock(rt_mtx); + lck_mtx_lock(rnh_lock); ifa = ifa_ifwithroute_locked(flags, dst, gateway); - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); return (ifa); } @@ -974,25 +1567,36 @@ ifa_ifwithroute_scoped_locked(int flags, const struct sockaddr *dst, static struct ifaddr * ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, - const struct sockaddr *gateway, unsigned int ifscope) + const struct sockaddr *gw, unsigned int ifscope) { struct ifaddr *ifa = NULL; struct rtentry *rt = NULL; - struct sockaddr_in dst_in, gw_in; + struct sockaddr_storage dst_ss, gw_ss; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); - if (ip_doscopedroute) { - /* - * Just in case the sockaddr passed in by the caller - * contains embedded scope, make sure to clear it since - * IPv4 interface addresses aren't scoped. - */ - if (dst != NULL && dst->sa_family == AF_INET) - dst = sin_copy(SIN(dst), &dst_in, IFSCOPE_NONE); - if (gateway != NULL && gateway->sa_family == AF_INET) - gateway = sin_copy(SIN(gateway), &gw_in, IFSCOPE_NONE); - } + /* + * Just in case the sockaddr passed in by the caller + * contains a scope ID, make sure to clear it since + * interface addresses aren't scoped. + */ +#if INET6 + if (dst != NULL && + ((dst->sa_family == AF_INET) || + (dst->sa_family == AF_INET6))) +#else + if (dst != NULL && dst->sa_family == AF_INET) +#endif /* !INET6 */ + dst = sa_copy(SA((uintptr_t)dst), &dst_ss, NULL); + +#if INET6 + if (gw != NULL && + ((gw->sa_family == AF_INET) || + (gw->sa_family == AF_INET6))) +#else + if (gw != NULL && gw->sa_family == AF_INET) +#endif /* !INET6 */ + gw = sa_copy(SA((uintptr_t)gw), &gw_ss, NULL); if (!(flags & RTF_GATEWAY)) { /* @@ -1006,35 +1610,45 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, ifa = ifa_ifwithdstaddr(dst); } if (ifa == NULL) - ifa = ifa_ifwithaddr_scoped(gateway, ifscope); + ifa = ifa_ifwithaddr_scoped(gw, ifscope); } else { /* * If we are adding a route to a remote net * or host, the gateway may still be on the * other end of a pt to pt link. */ - ifa = ifa_ifwithdstaddr(gateway); + ifa = ifa_ifwithdstaddr(gw); } if (ifa == NULL) - ifa = ifa_ifwithnet_scoped(gateway, ifscope); + ifa = ifa_ifwithnet_scoped(gw, ifscope); if (ifa == NULL) { /* Workaround to avoid gcc warning regarding const variable */ rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)dst, - 0, 0UL, ifscope); + 0, 0, ifscope); if (rt != NULL) { + RT_LOCK_SPIN(rt); ifa = rt->rt_ifa; - if (ifa != NULL) - ifaref(ifa); - rtunref(rt); + if (ifa != NULL) { + /* Become a regular mutex */ + RT_CONVERT_LOCK(rt); + IFA_ADDREF(ifa); + } + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); rt = NULL; } } + /* + * Holding rnh_lock here prevents the possibility of ifa from + * changing (e.g. in_ifinit), so it is safe to access its + * ifa_addr (here and down below) without locking. + */ if (ifa != NULL && ifa->ifa_addr->sa_family != dst->sa_family) { struct ifaddr *newifa; /* Callee adds reference to newifa upon success */ newifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp); if (newifa != NULL) { - ifafree(ifa); + IFA_REMREF(ifa); ifa = newifa; } } @@ -1044,18 +1658,23 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, * that may not agree with info garnered from the interfaces. * The routing table should carry more precedence than the * interfaces in this matter. Must be careful not to stomp - * on new entries from rtinit, hence (ifa->ifa_addr != gateway). + * on new entries from rtinit, hence (ifa->ifa_addr != gw). */ if ((ifa == NULL || - !equal(ifa->ifa_addr, (struct sockaddr *)(size_t)gateway)) && - (rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)gateway, - 0, 0UL, ifscope)) != NULL) { + !equal(ifa->ifa_addr, (struct sockaddr *)(size_t)gw)) && + (rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)gw, + 0, 0, ifscope)) != NULL) { if (ifa != NULL) - ifafree(ifa); + IFA_REMREF(ifa); + RT_LOCK_SPIN(rt); ifa = rt->rt_ifa; - if (ifa != NULL) - ifaref(ifa); - rtunref(rt); + if (ifa != NULL) { + /* Become a regular mutex */ + RT_CONVERT_LOCK(rt); + IFA_ADDREF(ifa); + } + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); } /* * If an interface scope was specified, the interface index of @@ -1064,17 +1683,15 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, */ if ((flags & RTF_IFSCOPE) && ifa != NULL && ifa->ifa_ifp->if_index != ifscope) { - ifafree(ifa); + IFA_REMREF(ifa); ifa = NULL; } return (ifa); } -#define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) - -static int rt_fixdelete __P((struct radix_node *, void *)); -static int rt_fixchange __P((struct radix_node *, void *)); +static int rt_fixdelete(struct radix_node *, void *); +static int rt_fixchange(struct radix_node *, void *); struct rtfc_arg { struct rtentry *rt0; @@ -1107,7 +1724,7 @@ rtrequest_scoped_locked(int req, struct sockaddr *dst, * Do appropriate manipulations of a routing tree given all the bits of * info needed. * - * Embedding the scope in the radix key is an internal job that should be + * Storing the scope ID in the radix key is an internal job that should be * left to routines in this module. Callers should specify the scope value * to the "scoped" variants of route routines instead of manipulating the * key itself. This is typically done when creating a scoped route, e.g. @@ -1129,64 +1746,86 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, struct radix_node_head *rnh; struct ifaddr *ifa = NULL; struct sockaddr *ndst, *dst = dst0; - struct sockaddr_in sin, mask; -#define senderr(x) { error = x ; goto bad; } + struct sockaddr_storage ss, mask; + struct timeval caltime; + int af = dst->sa_family; + void (*ifa_rtrequest)(int, struct rtentry *, struct sockaddr *); + +#define senderr(x) { error = x; goto bad; } - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); /* * Find the correct routing tree to use for this Address Family */ - if ((rnh = rt_tables[dst->sa_family]) == 0) + if ((rnh = rt_tables[af]) == NULL) senderr(ESRCH); /* * If we are adding a host route then we don't want to put * a netmask in the tree */ if (flags & RTF_HOST) - netmask = 0; + netmask = NULL; /* - * If RTF_IFSCOPE is specified, use a local copy of the destination - * address to embed the scope into. This logic is repeated below + * If Scoped Routing is enabled, use a local copy of the destination + * address to store the scope ID into. This logic is repeated below * in the RTM_RESOLVE handler since the caller does not normally - * specify such a flag during a resolve; instead it passes in the - * route used for cloning for which the scope info is derived from. - * Note also that in the case of RTM_DELETE, the address passed in - * by the caller might already contain the embedded scope info when - * it is the key itself, thus making RTF_IFSCOPE unnecessary; one - * instance where it is explicitly set is inside route_output() - * as part of handling a routing socket request. + * specify such a flag during a resolve, as well as for the handling + * of IPv4 link-local address; instead, it passes in the route used for + * cloning for which the scope info is derived from. Note also that + * in the case of RTM_DELETE, the address passed in by the caller + * might already contain the scope ID info when it is the key itself, + * thus making RTF_IFSCOPE unnecessary; one instance where it is + * explicitly set is inside route_output() as part of handling a + * routing socket request. */ - if (req != RTM_RESOLVE && (flags & RTF_IFSCOPE)) { - /* Scoped routing is for AF_INET only */ - if (dst->sa_family != AF_INET || - (req == RTM_ADD && !ip_doscopedroute)) - senderr(EINVAL); +#if INET6 + if (req != RTM_RESOLVE && ((af == AF_INET) || (af == AF_INET6))) { +#else + if (req != RTM_RESOLVE && af == AF_INET) { +#endif /* !INET6 */ + /* Transform dst into the internal routing table form */ + dst = sa_copy(dst, &ss, &ifscope); - if (ifscope == IFSCOPE_NONE) { - flags &= ~RTF_IFSCOPE; - } else { - /* Embed ifscope into the key (local copy) */ - dst = sin_copy(SIN(dst), &sin, ifscope); + /* Transform netmask into the internal routing table form */ + if (netmask != NULL) + netmask = ma_copy(af, netmask, &mask, ifscope); - /* Embed ifscope into netmask (local copy) */ - if (netmask != NULL) - netmask = mask_copy(netmask, &mask, ifscope); - } + if (ifscope != IFSCOPE_NONE) + flags |= RTF_IFSCOPE; + } else if ((flags & RTF_IFSCOPE) && + (af != AF_INET && af != AF_INET6)) { + senderr(EINVAL); } + if (ifscope == IFSCOPE_NONE) + flags &= ~RTF_IFSCOPE; + switch (req) { - case RTM_DELETE: + case RTM_DELETE: { + struct rtentry *gwrt = NULL; + boolean_t was_router = FALSE; + uint32_t old_rt_refcnt = 0; /* * Remove the item from the tree and return it. * Complain if it is not there and do no more processing. */ - if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == 0) + if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == NULL) senderr(ESRCH); - if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) - panic ("rtrequest delete"); + if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) { + panic("rtrequest delete"); + /* NOTREACHED */ + } rt = (struct rtentry *)rn; + RT_LOCK(rt); + old_rt_refcnt = rt->rt_refcnt; + rt->rt_flags &= ~RTF_UP; + /* + * Release any idle reference count held on the interface + * as this route is no longer externally visible. + */ + rt_clear_idleref(rt); /* * Take an extra reference to handle the deletion of a route * entry whose reference count is already 0; e.g. an expiring @@ -1196,8 +1835,31 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, * will decrement the reference via rtfree_locked() and then * possibly deallocate it. */ - rtref(rt); - rt->rt_flags &= ~RTF_UP; + RT_ADDREF_LOCKED(rt); + + /* + * For consistency, in case the caller didn't set the flag. + */ + rt->rt_flags |= RTF_CONDEMNED; + + /* + * Clear RTF_ROUTER if it's set. + */ + if (rt->rt_flags & RTF_ROUTER) { + was_router = TRUE; + VERIFY(rt->rt_flags & RTF_HOST); + rt->rt_flags &= ~RTF_ROUTER; + } + + /* + * Enqueue work item to invoke callback for this route entry + * + * If the old count is 0, it implies that last reference is being + * removed and there's no one listening for this route event. + */ + if (old_rt_refcnt != 0) + route_event_enqueue_nwk_wq_entry(rt, NULL, + ROUTE_ENTRY_DELETED, NULL, TRUE); /* * Now search what's left of the subtree for any cloned @@ -1205,33 +1867,45 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, */ if ((rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) && rt_mask(rt)) { + RT_UNLOCK(rt); rnh->rnh_walktree_from(rnh, dst, rt_mask(rt), - rt_fixdelete, rt); + rt_fixdelete, rt); + RT_LOCK(rt); + } + + if (was_router) { + struct route_event rt_ev; + route_event_init(&rt_ev, rt, NULL, ROUTE_LLENTRY_DELETED); + RT_UNLOCK(rt); + (void) rnh->rnh_walktree(rnh, + route_event_walktree, (void *)&rt_ev); + RT_LOCK(rt); } /* * Remove any external references we may have. - * This might result in another rtentry being freed if - * we held its last reference. */ - if (rt->rt_gwroute) { - rt = rt->rt_gwroute; - rtfree_locked(rt); - (rt = (struct rtentry *)rn)->rt_gwroute = 0; - } + if ((gwrt = rt->rt_gwroute) != NULL) + rt->rt_gwroute = NULL; /* * give the protocol a chance to keep things in sync. */ - if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest) - ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0)); - ifa = NULL; + if ((ifa = rt->rt_ifa) != NULL) { + IFA_LOCK_SPIN(ifa); + ifa_rtrequest = ifa->ifa_rtrequest; + IFA_UNLOCK(ifa); + if (ifa_rtrequest != NULL) + ifa_rtrequest(RTM_DELETE, rt, NULL); + /* keep reference on rt_ifa */ + ifa = NULL; + } /* * one more rtentry floating around that is not * linked to the routing table. */ - (void) OSIncrementAtomic((SInt32 *)&rttrash); + (void) OSIncrementAtomic(&rttrash); if (rte_debug & RTD_DEBUG) { TAILQ_INSERT_TAIL(&rttrash_head, (struct rtentry_dbg *)rt, rtd_trash_link); @@ -1241,8 +1915,31 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, * If this is the (non-scoped) default route, clear * the interface index used for the primary ifscope. */ - if (rt_inet_default(rt, rt_key(rt))) - set_primary_ifscope(IFSCOPE_NONE); + if (rt_primary_default(rt, rt_key(rt))) { + set_primary_ifscope(rt_key(rt)->sa_family, + IFSCOPE_NONE); + } + +#if NECP + /* + * If this is a change in a default route, update + * necp client watchers to re-evaluate + */ + if (SA_DEFAULT(rt_key(rt))) { + necp_update_all_clients(); + } +#endif /* NECP */ + + RT_UNLOCK(rt); + + /* + * This might result in another rtentry being freed if + * we held its last reference. Do this after the rtentry + * lock is dropped above, as it could lead to the same + * lock being acquired if gwrt is a clone of rt. + */ + if (gwrt != NULL) + rtfree_locked(gwrt); /* * If the caller wants it, then it can have it, @@ -1256,53 +1953,104 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, /* Dereference or deallocate the route */ rtfree_locked(rt); } + if (af == AF_INET) + routegenid_inet_update(); +#if INET6 + else if (af == AF_INET6) + routegenid_inet6_update(); +#endif /* INET6 */ break; - + } case RTM_RESOLVE: - if (ret_nrt == 0 || (rt = *ret_nrt) == 0) + if (ret_nrt == NULL || (rt = *ret_nrt) == NULL) senderr(EINVAL); + /* + * According to the UNIX conformance tests, we need to return + * ENETUNREACH when the parent route is RTF_REJECT. + * However, there isn't any point in cloning RTF_REJECT + * routes, so we immediately return an error. + */ + if (rt->rt_flags & RTF_REJECT) { + if (rt->rt_flags & RTF_HOST) { + senderr(EHOSTUNREACH); + } else { + senderr(ENETUNREACH); + } + } + /* + * If cloning, we have the parent route given by the caller + * and will use its rt_gateway, rt_rmx as part of the cloning + * process below. Since rnh_lock is held at this point, the + * parent's rt_ifa and rt_gateway will not change, and its + * relevant rt_flags will not change as well. The only thing + * that could change are the metrics, and thus we hold the + * parent route's rt_lock later on during the actual copying + * of rt_rmx. + */ ifa = rt->rt_ifa; - ifaref(ifa); + IFA_ADDREF(ifa); flags = rt->rt_flags & ~(RTF_CLONING | RTF_PRCLONING | RTF_STATIC); flags |= RTF_WASCLONED; gateway = rt->rt_gateway; - if ((netmask = rt->rt_genmask) == 0) + if ((netmask = rt->rt_genmask) == NULL) flags |= RTF_HOST; - if (!ip_doscopedroute || dst->sa_family != AF_INET) +#if INET6 + if (af != AF_INET && af != AF_INET6) +#else + if (af != AF_INET) +#endif /* !INET6 */ goto makeroute; + /* * When scoped routing is enabled, cloned entries are * always scoped according to the interface portion of * the parent route. The exception to this are IPv4 - * link local addresses. + * link local addresses, or those routes that are cloned + * from a RTF_PROXY route. For the latter, the clone + * gets to keep the RTF_PROXY flag. */ - if (!IN_LINKLOCAL(ntohl(SIN(dst)->sin_addr.s_addr))) { + if ((af == AF_INET && + IN_LINKLOCAL(ntohl(SIN(dst)->sin_addr.s_addr))) || + (rt->rt_flags & RTF_PROXY)) { + ifscope = IFSCOPE_NONE; + flags &= ~RTF_IFSCOPE; + /* + * These types of cloned routes aren't currently + * eligible for idle interface reference counting. + */ + flags |= RTF_NOIFREF; + } else { if (flags & RTF_IFSCOPE) { - ifscope = sa_get_ifscope(rt_key(rt)); + ifscope = (af == AF_INET) ? + sin_get_ifscope(rt_key(rt)) : + sin6_get_ifscope(rt_key(rt)); } else { ifscope = rt->rt_ifp->if_index; flags |= RTF_IFSCOPE; } - } else { - ifscope = IFSCOPE_NONE; - flags &= ~RTF_IFSCOPE; + VERIFY(ifscope != IFSCOPE_NONE); } - /* Embed or clear ifscope into/from the key (local copy) */ - dst = sin_copy(SIN(dst), &sin, ifscope); + /* + * Transform dst into the internal routing table form, + * clearing out the scope ID field if ifscope isn't set. + */ + dst = sa_copy(dst, &ss, (ifscope == IFSCOPE_NONE) ? + NULL : &ifscope); - /* Embed or clear ifscope into/from netmask (local copy) */ + /* Transform netmask into the internal routing table form */ if (netmask != NULL) - netmask = mask_copy(netmask, &mask, ifscope); + netmask = ma_copy(af, netmask, &mask, ifscope); goto makeroute; case RTM_ADD: - if ((flags & RTF_GATEWAY) && !gateway) + if ((flags & RTF_GATEWAY) && !gateway) { panic("rtrequest: RTF_GATEWAY but no gateway"); - + /* NOTREACHED */ + } if (flags & RTF_IFSCOPE) { ifa = ifa_ifwithroute_scoped_locked(flags, dst0, gateway, ifscope); @@ -1312,18 +2060,48 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, if (ifa == NULL) senderr(ENETUNREACH); makeroute: + /* + * We land up here for both RTM_RESOLVE and RTM_ADD + * when we decide to create a route. + */ if ((rt = rte_alloc()) == NULL) senderr(ENOBUFS); Bzero(rt, sizeof(*rt)); + rte_lock_init(rt); + eventhandler_lists_ctxt_init(&rt->rt_evhdlr_ctxt); + getmicrotime(&caltime); + rt->base_calendartime = caltime.tv_sec; + rt->base_uptime = net_uptime(); + RT_LOCK(rt); rt->rt_flags = RTF_UP | flags; + /* + * Point the generation ID to the tree's. + */ + switch (af) { + case AF_INET: + rt->rt_tree_genid = &route_genid_inet; + break; +#if INET6 + case AF_INET6: + rt->rt_tree_genid = &route_genid_inet6; + break; +#endif /* INET6 */ + default: + break; + } + /* * Add the gateway. Possibly re-malloc-ing the storage for it * also add the rt_gwroute if possible. */ if ((error = rt_setgate(rt, dst, gateway)) != 0) { + int tmp = error; + RT_UNLOCK(rt); + nstat_route_detach(rt); + rte_lock_destroy(rt); rte_free(rt); - senderr(error); + senderr(tmp); } /* @@ -1350,7 +2128,7 @@ makeroute: /* XXX mtu manipulation will be done in rnh_addaddr -- itojun */ rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask, - rnh, rt->rt_nodes); + rnh, rt->rt_nodes); if (rn == 0) { struct rtentry *rt2; /* @@ -1368,14 +2146,16 @@ makeroute: RTF_CLONING | RTF_PRCLONING); } if (rt2 && rt2->rt_parent) { - rtrequest_locked(RTM_DELETE, - (struct sockaddr *)rt_key(rt2), - rt2->rt_gateway, - rt_mask(rt2), rt2->rt_flags, 0); + /* + * rnh_lock is held here, so rt_key and + * rt_gateway of rt2 will not change. + */ + (void) rtrequest_locked(RTM_DELETE, rt_key(rt2), + rt2->rt_gateway, rt_mask(rt2), + rt2->rt_flags, 0); rtfree_locked(rt2); rn = rnh->rnh_addaddr((caddr_t)ndst, - (caddr_t)netmask, - rnh, rt->rt_nodes); + (caddr_t)netmask, rnh, rt->rt_nodes); } else if (rt2) { /* undo the extra ref we got */ rtfree_locked(rt2); @@ -1386,60 +2166,78 @@ makeroute: * If it still failed to go into the tree, * then un-make it (this should be a function) */ - if (rn == 0) { - if (rt->rt_gwroute) - rtfree_locked(rt->rt_gwroute); + if (rn == NULL) { + /* Clear gateway route */ + rt_set_gwroute(rt, rt_key(rt), NULL); if (rt->rt_ifa) { - ifafree(rt->rt_ifa); + IFA_REMREF(rt->rt_ifa); + rt->rt_ifa = NULL; } R_Free(rt_key(rt)); + RT_UNLOCK(rt); + nstat_route_detach(rt); + rte_lock_destroy(rt); rte_free(rt); senderr(EEXIST); } - rt->rt_parent = 0; + rt->rt_parent = NULL; /* - * If we got here from RESOLVE, then we are cloning - * so clone the rest, and note that we - * are a clone (and increment the parent's references) + * If we got here from RESOLVE, then we are cloning so clone + * the rest, and note that we are a clone (and increment the + * parent's references). rnh_lock is still held, which prevents + * a lookup from returning the newly-created route. Hence + * holding and releasing the parent's rt_lock while still + * holding the route's rt_lock is safe since the new route + * is not yet externally visible. */ if (req == RTM_RESOLVE) { - rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */ - if ((*ret_nrt)->rt_flags & (RTF_CLONING | RTF_PRCLONING)) { + RT_LOCK_SPIN(*ret_nrt); + VERIFY((*ret_nrt)->rt_expire == 0 || + (*ret_nrt)->rt_rmx.rmx_expire != 0); + VERIFY((*ret_nrt)->rt_expire != 0 || + (*ret_nrt)->rt_rmx.rmx_expire == 0); + rt->rt_rmx = (*ret_nrt)->rt_rmx; + rt_setexpire(rt, (*ret_nrt)->rt_expire); + if ((*ret_nrt)->rt_flags & + (RTF_CLONING | RTF_PRCLONING)) { rt->rt_parent = (*ret_nrt); - rtref(*ret_nrt); + RT_ADDREF_LOCKED(*ret_nrt); } + RT_UNLOCK(*ret_nrt); } /* * if this protocol has something to add to this then * allow it to do that as well. */ - if (ifa->ifa_rtrequest) - ifa->ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : 0)); - ifafree(ifa); - ifa = 0; + IFA_LOCK_SPIN(ifa); + ifa_rtrequest = ifa->ifa_rtrequest; + IFA_UNLOCK(ifa); + if (ifa_rtrequest != NULL) + ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : NULL)); + IFA_REMREF(ifa); + ifa = NULL; /* - * We repeat the same procedure from rt_setgate() here because - * it doesn't fire when we call it there because the node - * hasn't been added to the tree yet. + * If this is the (non-scoped) default route, record + * the interface index used for the primary ifscope. */ - if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) { - struct rtfc_arg arg; - arg.rnh = rnh; - arg.rt0 = rt; - rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt), - rt_fixchange, &arg); + if (rt_primary_default(rt, rt_key(rt))) { + set_primary_ifscope(rt_key(rt)->sa_family, + rt->rt_ifp->if_index); } +#if NECP /* - * If this is the (non-scoped) default route, record - * the interface index used for the primary ifscope. + * If this is a change in a default route, update + * necp client watchers to re-evaluate */ - if (rt_inet_default(rt, rt_key(rt))) - set_primary_ifscope(rt->rt_ifp->if_index); + if (SA_DEFAULT(rt_key(rt))) { + necp_update_all_clients(); + } +#endif /* NECP */ /* * actually return a resultant rtentry and @@ -1447,32 +2245,74 @@ makeroute: */ if (ret_nrt) { *ret_nrt = rt; - rtref(rt); + RT_ADDREF_LOCKED(rt); + } + + if (af == AF_INET) + routegenid_inet_update(); +#if INET6 + else if (af == AF_INET6) + routegenid_inet6_update(); +#endif /* INET6 */ + + RT_GENID_SYNC(rt); + + /* + * We repeat the same procedures from rt_setgate() here + * because they weren't completed when we called it earlier, + * since the node was embryonic. + */ + if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL) + rt_set_gwroute(rt, rt_key(rt), rt->rt_gwroute); + + if (req == RTM_ADD && + !(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) { + struct rtfc_arg arg; + arg.rnh = rnh; + arg.rt0 = rt; + RT_UNLOCK(rt); + rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt), + rt_fixchange, &arg); + } else { + RT_UNLOCK(rt); } + + nstat_route_new_entry(rt); break; } bad: if (ifa) - ifafree(ifa); + IFA_REMREF(ifa); return (error); } +#undef senderr int -rtrequest( - int req, - struct sockaddr *dst, - struct sockaddr *gateway, - struct sockaddr *netmask, - int flags, - struct rtentry **ret_nrt) +rtrequest(int req, struct sockaddr *dst, struct sockaddr *gateway, + struct sockaddr *netmask, int flags, struct rtentry **ret_nrt) { int error; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); error = rtrequest_locked(req, dst, gateway, netmask, flags, ret_nrt); - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); + return (error); +} + +int +rtrequest_scoped(int req, struct sockaddr *dst, struct sockaddr *gateway, + struct sockaddr *netmask, int flags, struct rtentry **ret_nrt, + unsigned int ifscope) +{ + int error; + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); + error = rtrequest_scoped_locked(req, dst, gateway, netmask, flags, + ret_nrt, ifscope); + lck_mtx_unlock(rnh_lock); return (error); } + /* * Called from rtrequest(RTM_DELETE, ...) to fix up the route's ``family'' * (i.e., the routes related to it by the operation of cloning). This @@ -1486,15 +2326,22 @@ rt_fixdelete(struct radix_node *rn, void *vp) struct rtentry *rt = (struct rtentry *)rn; struct rtentry *rt0 = vp; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + RT_LOCK(rt); if (rt->rt_parent == rt0 && - !(rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) { - return rtrequest_locked(RTM_DELETE, rt_key(rt), - (struct sockaddr *)0, rt_mask(rt), - rt->rt_flags, (struct rtentry **)0); + !(rt->rt_flags & (RTF_CLONING | RTF_PRCLONING))) { + /* + * Safe to drop rt_lock and use rt_key, since holding + * rnh_lock here prevents another thread from calling + * rt_setgate() on this route. + */ + RT_UNLOCK(rt); + return (rtrequest_locked(RTM_DELETE, rt_key(rt), NULL, + rt_mask(rt), rt->rt_flags, NULL)); } - return 0; + RT_UNLOCK(rt); + return (0); } /* @@ -1518,13 +2365,17 @@ rt_fixchange(struct radix_node *rn, void *vp) struct rtentry *rt0 = ap->rt0; struct radix_node_head *rnh = ap->rnh; u_char *xk1, *xm1, *xk2, *xmp; - int i, len, mlen; + int i, len; + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + RT_LOCK(rt); if (!rt->rt_parent || - (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) + (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING))) { + RT_UNLOCK(rt); return (0); + } if (rt->rt_parent == rt0) goto delete_rt; @@ -1539,20 +2390,31 @@ rt_fixchange(struct radix_node *rn, void *vp) xm1 = (u_char *)rt_mask(rt0); xk2 = (u_char *)rt_key(rt); - /* avoid applying a less specific route */ - xmp = (u_char *)rt_mask(rt->rt_parent); - mlen = rt_key(rt->rt_parent)->sa_len; - if (mlen > rt_key(rt0)->sa_len) - return (0); - - for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++) { - if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i]) + /* + * Avoid applying a less specific route; do this only if the parent + * route (rt->rt_parent) is a network route, since otherwise its mask + * will be NULL if it is a cloning host route. + */ + if ((xmp = (u_char *)rt_mask(rt->rt_parent)) != NULL) { + int mlen = rt_mask(rt->rt_parent)->sa_len; + if (mlen > rt_mask(rt0)->sa_len) { + RT_UNLOCK(rt); return (0); + } + + for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++) { + if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i]) { + RT_UNLOCK(rt); + return (0); + } + } } for (i = rnh->rnh_treetop->rn_offset; i < len; i++) { - if ((xk2[i] & xm1[i]) != xk1[i]) + if ((xk2[i] & xm1[i]) != xk1[i]) { + RT_UNLOCK(rt); return (0); + } } /* @@ -1560,17 +2422,84 @@ rt_fixchange(struct radix_node *rn, void *vp) * changed/added under the node's mask. So, get rid of it. */ delete_rt: + /* + * Safe to drop rt_lock and use rt_key, since holding rnh_lock here + * prevents another thread from calling rt_setgate() on this route. + */ + RT_UNLOCK(rt); return (rtrequest_locked(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt), rt->rt_flags, NULL)); } -int -rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) -{ - int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len); - struct radix_node_head *rnh = rt_tables[dst->sa_family]; +/* + * Round up sockaddr len to multiples of 32-bytes. This will reduce + * or even eliminate the need to re-allocate the chunk of memory used + * for rt_key and rt_gateway in the event the gateway portion changes. + * Certain code paths (e.g. IPSec) are notorious for caching the address + * of rt_gateway; this rounding-up would help ensure that the gateway + * portion never gets deallocated (though it may change contents) and + * thus greatly simplifies things. + */ +#define SA_SIZE(x) (-(-((uintptr_t)(x)) & -(32))) + +/* + * Sets the gateway and/or gateway route portion of a route; may be + * called on an existing route to modify the gateway portion. Both + * rt_key and rt_gateway are allocated out of the same memory chunk. + * Route entry lock must be held by caller; this routine will return + * with the lock held. + */ +int +rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) +{ + int dlen = SA_SIZE(dst->sa_len), glen = SA_SIZE(gate->sa_len); + struct radix_node_head *rnh = NULL; + boolean_t loop = FALSE; + + if (dst->sa_family != AF_INET && dst->sa_family != AF_INET6) { + return (EINVAL); + } + + rnh = rt_tables[dst->sa_family]; + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + RT_LOCK_ASSERT_HELD(rt); + + /* + * If this is for a route that is on its way of being removed, + * or is temporarily frozen, reject the modification request. + */ + if (rt->rt_flags & RTF_CONDEMNED) { + return (EBUSY); + } + + /* Add an extra ref for ourselves */ + RT_ADDREF_LOCKED(rt); - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + if (rt->rt_flags & RTF_GATEWAY) { + if ((dst->sa_len == gate->sa_len) && + (dst->sa_family == AF_INET || dst->sa_family == AF_INET6)) { + struct sockaddr_storage dst_ss, gate_ss; + + (void) sa_copy(dst, &dst_ss, NULL); + (void) sa_copy(gate, &gate_ss, NULL); + + loop = equal(SA(&dst_ss), SA(&gate_ss)); + } else { + loop = (dst->sa_len == gate->sa_len && + equal(dst, gate)); + } + } + + /* + * A (cloning) network route with the destination equal to the gateway + * will create an endless loop (see notes below), so disallow it. + */ + if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) == + RTF_GATEWAY) && loop) { + /* Release extra ref */ + RT_REMREF_LOCKED(rt); + return (EADDRNOTAVAIL); + } /* * A host route with the destination equal to the gateway @@ -1578,15 +2507,24 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * table, so disallow it. */ if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) == - (RTF_HOST|RTF_GATEWAY)) && (dst->sa_len == gate->sa_len) && - (bcmp(dst, gate, dst->sa_len) == 0)) { + (RTF_HOST|RTF_GATEWAY)) && loop) { /* * The route might already exist if this is an RTM_CHANGE * or a routing redirect, so try to delete it. */ - if (rt_key(rt)) - rtrequest_locked(RTM_DELETE, rt_key(rt), + if (rt_key(rt) != NULL) { + /* + * Safe to drop rt_lock and use rt_key, rt_gateway, + * since holding rnh_lock here prevents another thread + * from calling rt_setgate() on this route. + */ + RT_UNLOCK(rt); + (void) rtrequest_locked(RTM_DELETE, rt_key(rt), rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL); + RT_LOCK(rt); + } + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return (EADDRNOTAVAIL); } @@ -1598,10 +2536,23 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) struct rtentry *gwrt; unsigned int ifscope; - ifscope = (dst->sa_family == AF_INET) ? - sa_get_ifscope(dst) : IFSCOPE_NONE; + if (dst->sa_family == AF_INET) + ifscope = sin_get_ifscope(dst); + else if (dst->sa_family == AF_INET6) + ifscope = sin6_get_ifscope(dst); + else + ifscope = IFSCOPE_NONE; + RT_UNLOCK(rt); + /* + * Don't ignore RTF_CLONING, since we prefer that rt_gwroute + * points to a clone rather than a cloning route; see above + * check for cloning loop avoidance (dst == gate). + */ gwrt = rtalloc1_scoped_locked(gate, 1, RTF_PRCLONING, ifscope); + if (gwrt != NULL) + RT_LOCK_ASSERT_NOTHELD(gwrt); + RT_LOCK(rt); /* * Cloning loop avoidance: @@ -1618,22 +2569,38 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * for the gateway to be referred to by another route. */ if (gwrt == rt) { - rtunref(gwrt); + RT_REMREF_LOCKED(gwrt); + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return (EADDRINUSE); /* failure */ } - /* If scoped, the gateway route must use the same interface */ + /* + * If scoped, the gateway route must use the same interface; + * we're holding rnh_lock now, so rt_gateway and rt_ifp of gwrt + * should not change and are freely accessible. + */ if (ifscope != IFSCOPE_NONE && (rt->rt_flags & RTF_IFSCOPE) && gwrt != NULL && gwrt->rt_ifp != NULL && gwrt->rt_ifp->if_index != ifscope) { - rtfree_locked(gwrt); + rtfree_locked(gwrt); /* rt != gwrt, no deadlock */ + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return ((rt->rt_flags & RTF_HOST) ? EHOSTUNREACH : ENETUNREACH); } - if (rt->rt_gwroute != NULL) - rtfree_locked(rt->rt_gwroute); - rt->rt_gwroute = gwrt; + /* Check again since we dropped the lock above */ + if (rt->rt_flags & RTF_CONDEMNED) { + if (gwrt != NULL) + rtfree_locked(gwrt); + /* Release extra ref */ + RT_REMREF_LOCKED(rt); + return (EBUSY); + } + + /* Set gateway route; callee adds ref to gwrt if non-NULL */ + rt_set_gwroute(rt, dst, gwrt); /* * In case the (non-scoped) default route gets modified via @@ -1641,8 +2608,20 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * primary ifscope. Also done in rt_setif() to take care * of the non-redirect cases. */ - if (rt_inet_default(rt, dst) && rt->rt_ifp != NULL) - set_primary_ifscope(rt->rt_ifp->if_index); + if (rt_primary_default(rt, dst) && rt->rt_ifp != NULL) { + set_primary_ifscope(dst->sa_family, + rt->rt_ifp->if_index); + } + +#if NECP + /* + * If this is a change in a default route, update + * necp client watchers to re-evaluate + */ + if (SA_DEFAULT(dst)) { + necp_update_all_clients(); + } +#endif /* NECP */ /* * Tell the kernel debugger about the new default gateway @@ -1654,9 +2633,15 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) */ if ((dst->sa_family == AF_INET) && gwrt != NULL && gwrt->rt_gateway->sa_family == AF_LINK && - (gwrt->rt_ifp->if_index == get_primary_ifscope() || - get_primary_ifscope() == IFSCOPE_NONE)) - kdp_set_gateway_mac(SDL(gwrt->rt_gateway)->sdl_data); + (gwrt->rt_ifp->if_index == get_primary_ifscope(AF_INET) || + get_primary_ifscope(AF_INET) == IFSCOPE_NONE)) { + kdp_set_gateway_mac(SDL((void *)gwrt->rt_gateway)-> + sdl_data); + } + + /* Release extra ref from rtalloc1() */ + if (gwrt != NULL) + RT_REMREF(gwrt); } /* @@ -1666,15 +2651,16 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * to the right place. Otherwise, malloc a new block and update * the 'dst' address and point rt_gateway to the right place. */ - if (rt->rt_gateway == NULL || glen > ROUNDUP(rt->rt_gateway->sa_len)) { + if (rt->rt_gateway == NULL || glen > SA_SIZE(rt->rt_gateway->sa_len)) { caddr_t new; /* The underlying allocation is done with M_WAITOK set */ R_Malloc(new, caddr_t, dlen + glen); if (new == NULL) { - if (rt->rt_gwroute != NULL) - rtfree_locked(rt->rt_gwroute); - rt->rt_gwroute = NULL; + /* Clear gateway route */ + rt_set_gwroute(rt, dst, NULL); + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return (ENOBUFS); } @@ -1683,7 +2669,8 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * here to initialize a newly allocated route entry, in * which case rt_key(rt) is NULL (and so does rt_gateway). */ - Bcopy(dst, new, dlen); + bzero(new, dlen + glen); + Bcopy(dst, new, dst->sa_len); R_Free(rt_key(rt)); /* free old block; NULL is okay */ rt->rt_nodes->rn_key = new; rt->rt_gateway = (struct sockaddr *)(new + dlen); @@ -1692,17 +2679,22 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) /* * Copy the new gateway value into the memory chunk. */ - Bcopy(gate, rt->rt_gateway, glen); + Bcopy(gate, rt->rt_gateway, gate->sa_len); /* * For consistency between rt_gateway and rt_key(gwrt). */ if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL && - (rt->rt_gwroute->rt_flags & RTF_IFSCOPE) && - rt->rt_gateway->sa_family == AF_INET && - rt_key(rt->rt_gwroute)->sa_family == AF_INET) { - sa_set_ifscope(rt->rt_gateway, - sa_get_ifscope(rt_key(rt->rt_gwroute))); + (rt->rt_gwroute->rt_flags & RTF_IFSCOPE)) { + if (rt->rt_gateway->sa_family == AF_INET && + rt_key(rt->rt_gwroute)->sa_family == AF_INET) { + sin_set_ifscope(rt->rt_gateway, + sin_get_ifscope(rt_key(rt->rt_gwroute))); + } else if (rt->rt_gateway->sa_family == AF_INET6 && + rt_key(rt->rt_gwroute)->sa_family == AF_INET6) { + sin6_set_ifscope(rt->rt_gateway, + sin6_get_ifscope(rt_key(rt->rt_gwroute))); + } } /* @@ -1714,60 +2706,123 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) struct rtfc_arg arg; arg.rnh = rnh; arg.rt0 = rt; + RT_UNLOCK(rt); rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt), rt_fixchange, &arg); + RT_LOCK(rt); } + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return (0); } -static void -rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst, - struct sockaddr *netmask) +#undef SA_SIZE + +void +rt_set_gwroute(struct rtentry *rt, struct sockaddr *dst, struct rtentry *gwrt) { - u_char *cp1 = (u_char *)src; - u_char *cp2 = (u_char *)dst; - u_char *cp3 = (u_char *)netmask; - u_char *cplim = cp2 + *cp3; - u_char *cplim2 = cp2 + *cp1; + boolean_t gwrt_isrouter; + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + RT_LOCK_ASSERT_HELD(rt); + + if (gwrt != NULL) + RT_ADDREF(gwrt); /* for this routine */ + + /* + * Get rid of existing gateway route; if rt_gwroute is already + * set to gwrt, this is slightly redundant (though safe since + * we held an extra ref above) but makes the code simpler. + */ + if (rt->rt_gwroute != NULL) { + struct rtentry *ogwrt = rt->rt_gwroute; + + VERIFY(rt != ogwrt); /* sanity check */ + rt->rt_gwroute = NULL; + RT_UNLOCK(rt); + rtfree_locked(ogwrt); + RT_LOCK(rt); + VERIFY(rt->rt_gwroute == NULL); + } + + /* + * And associate the new gateway route. + */ + if ((rt->rt_gwroute = gwrt) != NULL) { + RT_ADDREF(gwrt); /* for rt */ + + if (rt->rt_flags & RTF_WASCLONED) { + /* rt_parent might be NULL if rt is embryonic */ + gwrt_isrouter = (rt->rt_parent != NULL && + SA_DEFAULT(rt_key(rt->rt_parent)) && + !RT_HOST(rt->rt_parent)); + } else { + gwrt_isrouter = (SA_DEFAULT(dst) && !RT_HOST(rt)); + } + + /* If gwrt points to a default router, mark it accordingly */ + if (gwrt_isrouter && RT_HOST(gwrt) && + !(gwrt->rt_flags & RTF_ROUTER)) { + RT_LOCK(gwrt); + gwrt->rt_flags |= RTF_ROUTER; + RT_UNLOCK(gwrt); + } + + RT_REMREF(gwrt); /* for this routine */ + } +} - *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */ - cp3 += 2; - if (cplim > cplim2) - cplim = cplim2; - while (cp2 < cplim) - *cp2++ = *cp1++ & *cp3++; - if (cp2 < cplim2) - bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2)); +static void +rt_maskedcopy(const struct sockaddr *src, struct sockaddr *dst, + const struct sockaddr *netmask) +{ + const char *netmaskp = &netmask->sa_data[0]; + const char *srcp = &src->sa_data[0]; + char *dstp = &dst->sa_data[0]; + const char *maskend = (char *)dst + + MIN(netmask->sa_len, src->sa_len); + const char *srcend = (char *)dst + src->sa_len; + + dst->sa_len = src->sa_len; + dst->sa_family = src->sa_family; + + while (dstp < maskend) + *dstp++ = *srcp++ & *netmaskp++; + if (dstp < srcend) + memset(dstp, 0, (size_t)(srcend - dstp)); } /* - * Lookup an AF_INET scoped or non-scoped route depending on the ifscope - * value passed in by the caller (IFSCOPE_NONE implies non-scoped). + * Lookup an AF_INET/AF_INET6 scoped or non-scoped route depending on the + * ifscope value passed in by the caller (IFSCOPE_NONE implies non-scoped). */ static struct radix_node * node_lookup(struct sockaddr *dst, struct sockaddr *netmask, unsigned int ifscope) { - struct radix_node_head *rnh = rt_tables[AF_INET]; + struct radix_node_head *rnh; struct radix_node *rn; - struct sockaddr_in sin, mask; + struct sockaddr_storage ss, mask; + int af = dst->sa_family; struct matchleaf_arg ma = { ifscope }; rn_matchf_t *f = rn_match_ifscope; void *w = &ma; - if (dst->sa_family != AF_INET) + if (af != AF_INET && af != AF_INET6) return (NULL); + rnh = rt_tables[af]; + /* - * Embed ifscope into the search key; for a non-scoped - * search this will clear out any embedded scope value. + * Transform dst into the internal routing table form, + * clearing out the scope ID field if ifscope isn't set. */ - dst = sin_copy(SIN(dst), &sin, ifscope); + dst = sa_copy(dst, &ss, (ifscope == IFSCOPE_NONE) ? NULL : &ifscope); - /* Embed (or clear) ifscope into netmask */ + /* Transform netmask into the internal routing table form */ if (netmask != NULL) - netmask = mask_copy(netmask, &mask, ifscope); + netmask = ma_copy(af, netmask, &mask, ifscope); if (ifscope == IFSCOPE_NONE) f = w = NULL; @@ -1780,13 +2835,41 @@ node_lookup(struct sockaddr *dst, struct sockaddr *netmask, } /* - * Lookup the AF_INET non-scoped default route. + * Lookup the AF_INET/AF_INET6 non-scoped default route. */ static struct radix_node * -node_lookup_default(void) +node_lookup_default(int af) { - struct radix_node_head *rnh = rt_tables[AF_INET]; - return (rnh->rnh_lookup(&sin_def, NULL, rnh)); + struct radix_node_head *rnh; + + VERIFY(af == AF_INET || af == AF_INET6); + rnh = rt_tables[af]; + + return (af == AF_INET ? rnh->rnh_lookup(&sin_def, NULL, rnh) : + rnh->rnh_lookup(&sin6_def, NULL, rnh)); +} + +boolean_t +rt_ifa_is_dst(struct sockaddr *dst, struct ifaddr *ifa) +{ + boolean_t result = FALSE; + + if (ifa == NULL || ifa->ifa_addr == NULL) + return (result); + + IFA_LOCK_SPIN(ifa); + + if (dst->sa_family == ifa->ifa_addr->sa_family && + ((dst->sa_family == AF_INET && + SIN(dst)->sin_addr.s_addr == + SIN(ifa->ifa_addr)->sin_addr.s_addr) || + (dst->sa_family == AF_INET6 && + SA6_ARE_ADDR_EQUAL(SIN6(dst), SIN6(ifa->ifa_addr))))) + result = TRUE; + + IFA_UNLOCK(ifa); + + return (result); } /* @@ -1800,10 +2883,10 @@ node_lookup_default(void) * per-interface route instance. This permits multiple route entries having * the same destination (but not necessarily the same gateway) to exist in * the routing table; each of these entries is specific to the corresponding - * interface. This is made possible by embedding the scope value into the + * interface. This is made possible by storing the scope ID value into the * radix key, thus making each route entry unique. These scoped entries * exist along with the regular, non-scoped entries in the same radix tree - * for a given address family (currently AF_INET only); the scope logically + * for a given address family (AF_INET/AF_INET6); the scope logically * partitions it into multiple per-interface sub-trees. * * When a scoped route lookup is performed, the routing table is searched for @@ -1812,14 +2895,29 @@ node_lookup_default(void) * to the loopback interface). The search rule follows the longest matching * prefix with the additional interface constraint. */ -struct rtentry * -rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, - struct radix_node_head *rnh, unsigned int ifscope) +static struct rtentry * +rt_lookup_common(boolean_t lookup_only, boolean_t coarse, struct sockaddr *dst, + struct sockaddr *netmask, struct radix_node_head *rnh, unsigned int ifscope) { - struct radix_node *rn0, *rn; - boolean_t dontcare = (ifscope == IFSCOPE_NONE); + struct radix_node *rn0, *rn = NULL; + int af = dst->sa_family; + struct sockaddr_storage dst_ss; + struct sockaddr_storage mask_ss; + boolean_t dontcare; +#if (DEVELOPMENT || DEBUG) + char dbuf[MAX_SCOPE_ADDR_STR_LEN], gbuf[MAX_IPv6_STR_LEN]; + char s_dst[MAX_IPv6_STR_LEN], s_netmask[MAX_IPv6_STR_LEN]; +#endif + VERIFY(!coarse || ifscope == IFSCOPE_NONE); - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); +#if INET6 + /* + * While we have rnh_lock held, see if we need to schedule the timer. + */ + if (nd6_sched_timeout_want) + nd6_sched_timeout(NULL, NULL); +#endif /* INET6 */ if (!lookup_only) netmask = NULL; @@ -1827,13 +2925,60 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, /* * Non-scoped route lookup. */ - if (!ip_doscopedroute || dst->sa_family != AF_INET) { - if (lookup_only) - rn = rnh->rnh_lookup(dst, netmask, rnh); +#if INET6 + if (af != AF_INET && af != AF_INET6) { +#else + if (af != AF_INET) { +#endif /* !INET6 */ + rn = rnh->rnh_matchaddr(dst, rnh); + + /* + * Don't return a root node; also, rnh_matchaddr callback + * would have done the necessary work to clear RTPRF_OURS + * for certain protocol families. + */ + if (rn != NULL && (rn->rn_flags & RNF_ROOT)) + rn = NULL; + if (rn != NULL) { + RT_LOCK_SPIN(RT(rn)); + if (!(RT(rn)->rt_flags & RTF_CONDEMNED)) { + RT_ADDREF_LOCKED(RT(rn)); + RT_UNLOCK(RT(rn)); + } else { + RT_UNLOCK(RT(rn)); + rn = NULL; + } + } + return (RT(rn)); + } + + /* Transform dst/netmask into the internal routing table form */ + dst = sa_copy(dst, &dst_ss, &ifscope); + if (netmask != NULL) + netmask = ma_copy(af, netmask, &mask_ss, ifscope); + dontcare = (ifscope == IFSCOPE_NONE); + +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + if (af == AF_INET) + (void) inet_ntop(af, &SIN(dst)->sin_addr.s_addr, + s_dst, sizeof (s_dst)); else - rn = rnh->rnh_matchaddr(dst, rnh); - goto done; + (void) inet_ntop(af, &SIN6(dst)->sin6_addr, + s_dst, sizeof (s_dst)); + + if (netmask != NULL && af == AF_INET) + (void) inet_ntop(af, &SIN(netmask)->sin_addr.s_addr, + s_netmask, sizeof (s_netmask)); + if (netmask != NULL && af == AF_INET6) + (void) inet_ntop(af, &SIN6(netmask)->sin6_addr, + s_netmask, sizeof (s_netmask)); + else + *s_netmask = '\0'; + printf("%s (%d, %d, %s, %s, %u)\n", + __func__, lookup_only, coarse, s_dst, s_netmask, ifscope); } +#endif /* * Scoped route lookup: @@ -1848,10 +2993,13 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, /* * If the caller did not specify a scope, use the primary scope * derived from the system's non-scoped default route. If, for - * any reason, there is no primary interface, return what we have. + * any reason, there is no primary interface, ifscope will be + * set to IFSCOPE_NONE; if the above lookup resulted in a route, + * we'll do a more-specific search below, scoped to the interface + * of that route. */ - if (dontcare && (ifscope = get_primary_ifscope()) == IFSCOPE_NONE) - goto validate; + if (dontcare) + ifscope = get_primary_ifscope(af); /* * Keep the original result if either of the following is true: @@ -1861,11 +3009,24 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, * 2) The route uses the loopback interface, in which case the * destination (host/net) is local/loopback. * - * Otherwise, do a more specified search using the scope. + * Otherwise, do a more specified search using the scope; + * we're holding rnh_lock now, so rt_ifp should not change. */ if (rn != NULL) { struct rtentry *rt = RT(rn); - if (rt->rt_ifp != lo_ifp) { +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf)); + printf("%s unscoped search %p to %s->%s->%s ifa_ifp %s\n", + __func__, rt, + dbuf, gbuf, + (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "", + (rt->rt_ifa->ifa_ifp != NULL) ? + rt->rt_ifa->ifa_ifp->if_xname : ""); + } +#endif + if (!(rt->rt_ifp->if_flags & IFF_LOOPBACK) || + (rt->rt_flags & RTF_GATEWAY)) { if (rt->rt_ifp->if_index != ifscope) { /* * Wrong interface; keep the original result @@ -1873,11 +3034,15 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, * and do a more specific scoped search using * the scope of the found route. Otherwise, * start again from scratch. + * + * For loopback scope we keep the unscoped + * route for local addresses */ rn = NULL; if (dontcare) ifscope = rt->rt_ifp->if_index; - else + else if (ifscope != lo_ifp->if_index || + rt_ifa_is_dst(dst, rt->rt_ifa) == FALSE) rn0 = NULL; } else if (!(rt->rt_flags & RTF_IFSCOPE)) { /* @@ -1897,22 +3062,36 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, * interface scope as the one requested. The following will result * in searching for the longest prefix scoped match. */ - if (rn == NULL) + if (rn == NULL) { rn = node_lookup(dst, netmask, ifscope); - +#if (DEVELOPMENT || DEBUG) + if (rt_verbose && rn != NULL) { + struct rtentry *rt = RT(rn); + + rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf)); + printf("%s scoped search %p to %s->%s->%s ifa %s\n", + __func__, rt, + dbuf, gbuf, + (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "", + (rt->rt_ifa->ifa_ifp != NULL) ? + rt->rt_ifa->ifa_ifp->if_xname : ""); + } +#endif + } /* * Use the original result if either of the following is true: * * 1) The scoped search did not yield any result. - * 2) The result from the scoped search is a scoped default route, + * 2) The caller insists on performing a coarse-grained lookup. + * 3) The result from the scoped search is a scoped default route, * and the original (non-scoped) result is not a default route, * i.e. the original result is a more specific host/net route. - * 3) The scoped search yielded a net route but the original + * 4) The scoped search yielded a net route but the original * result is a host route, i.e. the original result is treated * as a more specific route. */ - if (rn == NULL || (rn0 != NULL && - ((INET_DEFAULT(rt_key(RT(rn))) && !INET_DEFAULT(rt_key(RT(rn0)))) || + if (rn == NULL || coarse || (rn0 != NULL && + ((SA_DEFAULT(rt_key(RT(rn))) && !SA_DEFAULT(rt_key(RT(rn0)))) || (!RT_HOST(rn) && RT_HOST(rn0))))) rn = rn0; @@ -1920,23 +3099,84 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, * If we still don't have a route, use the non-scoped default * route as long as the interface portion satistifes the scope. */ - if (rn == NULL && (rn = node_lookup_default()) != NULL && - RT(rn)->rt_ifp->if_index != ifscope) + if (rn == NULL && (rn = node_lookup_default(af)) != NULL && + RT(rn)->rt_ifp->if_index != ifscope) { rn = NULL; + } -validate: - if (rn != NULL && !lookup_only) - (void) in_validate(rn); + if (rn != NULL) { + /* + * Manually clear RTPRF_OURS using rt_validate() and + * bump up the reference count after, and not before; + * we only get here for AF_INET/AF_INET6. node_lookup() + * has done the check against RNF_ROOT, so we can be sure + * that we're not returning a root node here. + */ + RT_LOCK_SPIN(RT(rn)); + if (rt_validate(RT(rn))) { + RT_ADDREF_LOCKED(RT(rn)); + RT_UNLOCK(RT(rn)); + } else { + RT_UNLOCK(RT(rn)); + rn = NULL; + } + } +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + if (rn == NULL) + printf("%s %u return NULL\n", __func__, ifscope); + else { + struct rtentry *rt = RT(rn); -done: - if (rn != NULL && (rn->rn_flags & RNF_ROOT)) - rn = NULL; - else if (rn != NULL) - rtref(RT(rn)); + rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf)); + printf("%s %u return %p to %s->%s->%s ifa_ifp %s\n", + __func__, ifscope, rt, + dbuf, gbuf, + (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "", + (rt->rt_ifa->ifa_ifp != NULL) ? + rt->rt_ifa->ifa_ifp->if_xname : ""); + } + } +#endif return (RT(rn)); } +struct rtentry * +rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, + struct radix_node_head *rnh, unsigned int ifscope) +{ + return (rt_lookup_common(lookup_only, FALSE, dst, netmask, + rnh, ifscope)); +} + +struct rtentry * +rt_lookup_coarse(boolean_t lookup_only, struct sockaddr *dst, + struct sockaddr *netmask, struct radix_node_head *rnh) +{ + return (rt_lookup_common(lookup_only, TRUE, dst, netmask, + rnh, IFSCOPE_NONE)); +} + +boolean_t +rt_validate(struct rtentry *rt) +{ + RT_LOCK_ASSERT_HELD(rt); + + if ((rt->rt_flags & (RTF_UP | RTF_CONDEMNED)) == RTF_UP) { + int af = rt_key(rt)->sa_family; + + if (af == AF_INET) + (void) in_validate(RN(rt)); + else if (af == AF_INET6) + (void) in6_validate(RN(rt)); + } else { + rt = NULL; + } + + return (rt != NULL); +} + /* * Set up a routing table entry, normally * for an interface. @@ -1945,24 +3185,76 @@ int rtinit(struct ifaddr *ifa, int cmd, int flags) { int error; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED); - lck_mtx_lock(rt_mtx); + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + + lck_mtx_lock(rnh_lock); error = rtinit_locked(ifa, cmd, flags); - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); + return (error); } int rtinit_locked(struct ifaddr *ifa, int cmd, int flags) { - struct rtentry *rt; + struct radix_node_head *rnh; + uint8_t nbuf[128]; /* long enough for IPv6 */ +#if (DEVELOPMENT || DEBUG) + char dbuf[MAX_IPv6_STR_LEN], gbuf[MAX_IPv6_STR_LEN]; + char abuf[MAX_IPv6_STR_LEN]; +#endif + struct rtentry *rt = NULL; struct sockaddr *dst; - struct sockaddr *deldst; - struct mbuf *m = 0; - struct rtentry *nrt = 0; - int error; + struct sockaddr *netmask; + int error = 0; + + /* + * Holding rnh_lock here prevents the possibility of ifa from + * changing (e.g. in_ifinit), so it is safe to access its + * ifa_{dst}addr (here and down below) without locking. + */ + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + + if (flags & RTF_HOST) { + dst = ifa->ifa_dstaddr; + netmask = NULL; + } else { + dst = ifa->ifa_addr; + netmask = ifa->ifa_netmask; + } + + if (dst->sa_len == 0) { + log(LOG_ERR, "%s: %s failed, invalid dst sa_len %d\n", + __func__, rtm2str(cmd), dst->sa_len); + error = EINVAL; + goto done; + } + if (netmask != NULL && netmask->sa_len > sizeof (nbuf)) { + log(LOG_ERR, "%s: %s failed, mask sa_len %d too large\n", + __func__, rtm2str(cmd), dst->sa_len); + error = EINVAL; + goto done; + } + +#if (DEVELOPMENT || DEBUG) + if (dst->sa_family == AF_INET) { + (void) inet_ntop(AF_INET, &SIN(dst)->sin_addr.s_addr, + abuf, sizeof (abuf)); + } +#if INET6 + else if (dst->sa_family == AF_INET6) { + (void) inet_ntop(AF_INET6, &SIN6(dst)->sin6_addr, + abuf, sizeof (abuf)); + } +#endif /* INET6 */ +#endif /* (DEVELOPMENT || DEBUG) */ + + if ((rnh = rt_tables[dst->sa_family]) == NULL) { + error = EINVAL; + goto done; + } - dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr; /* * If it's a delete, check that if it exists, it's on the correct * interface or we might scrub a route to another ifa which would @@ -1974,122 +3266,223 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) * If it's a net, mask off the host bits * (Assuming we have a mask) */ - if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) { - m = m_get(M_DONTWAIT, MT_SONAME); - if (m == NULL) { - return(ENOBUFS); - } - deldst = mtod(m, struct sockaddr *); - rt_maskedcopy(dst, deldst, ifa->ifa_netmask); - dst = deldst; + if (netmask != NULL) { + rt_maskedcopy(dst, SA(nbuf), netmask); + dst = SA(nbuf); } /* - * Get an rtentry that is in the routing tree and - * contains the correct info. (if this fails, can't get there). - * We set "report" to FALSE so that if it doesn't exist, - * it doesn't report an error or clone a route, etc. etc. + * Get an rtentry that is in the routing tree and contains + * the correct info. Note that we perform a coarse-grained + * lookup here, in case there is a scoped variant of the + * subnet/prefix route which we should ignore, as we never + * add a scoped subnet/prefix route as part of adding an + * interface address. */ - rt = rtalloc1_locked(dst, 0, 0UL); - if (rt) { + rt = rt_lookup_coarse(TRUE, dst, NULL, rnh); + if (rt != NULL) { +#if (DEVELOPMENT || DEBUG) + rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf)); +#endif /* * Ok so we found the rtentry. it has an extra reference * for us at this stage. we won't need that so * lop that off now. */ - rtunref(rt); + RT_LOCK(rt); if (rt->rt_ifa != ifa) { /* - * If the interface in the rtentry doesn't match - * the interface we are using, then we don't - * want to delete it, so return an error. - * This seems to be the only point of - * this whole RTM_DELETE clause. + * If the interface address in the rtentry + * doesn't match the interface we are using, + * then we don't want to delete it, so return + * an error. This seems to be the only point + * of this whole RTM_DELETE clause. + */ +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + log(LOG_DEBUG, "%s: not removing " + "route to %s->%s->%s, flags %b, " + "ifaddr %s, rt_ifa 0x%llx != " + "ifa 0x%llx\n", __func__, dbuf, + gbuf, ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), + rt->rt_flags, RTF_BITS, abuf, + (uint64_t)VM_KERNEL_ADDRPERM( + rt->rt_ifa), + (uint64_t)VM_KERNEL_ADDRPERM(ifa)); + } +#endif /* (DEVELOPMENT || DEBUG) */ + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + rt = NULL; + error = ((flags & RTF_HOST) ? + EHOSTUNREACH : ENETUNREACH); + goto done; + } else if (rt->rt_flags & RTF_STATIC) { + /* + * Don't remove the subnet/prefix route if + * this was manually added from above. */ - if (m) - (void) m_free(m); - return (flags & RTF_HOST ? EHOSTUNREACH - : ENETUNREACH); +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + log(LOG_DEBUG, "%s: not removing " + "static route to %s->%s->%s, " + "flags %b, ifaddr %s\n", __func__, + dbuf, gbuf, ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), + rt->rt_flags, RTF_BITS, abuf); + } +#endif /* (DEVELOPMENT || DEBUG) */ + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + rt = NULL; + error = EBUSY; + goto done; } +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + log(LOG_DEBUG, "%s: removing route to " + "%s->%s->%s, flags %b, ifaddr %s\n", + __func__, dbuf, gbuf, + ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), + rt->rt_flags, RTF_BITS, abuf); + } +#endif /* (DEVELOPMENT || DEBUG) */ + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + rt = NULL; } - /* XXX */ -#if 0 - else { - /* - * One would think that as we are deleting, and we know - * it doesn't exist, we could just return at this point - * with an "ELSE" clause, but apparently not.. - */ - lck_mtx_unlock(rt_mtx); - return (flags & RTF_HOST ? EHOSTUNREACH - : ENETUNREACH); - } -#endif } /* * Do the actual request */ - error = rtrequest_locked(cmd, dst, ifa->ifa_addr, ifa->ifa_netmask, - flags | ifa->ifa_flags, &nrt); - if (m) - (void) m_free(m); - /* - * If we are deleting, and we found an entry, then - * it's been removed from the tree.. now throw it away. - */ - if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) { + if ((error = rtrequest_locked(cmd, dst, ifa->ifa_addr, netmask, + flags | ifa->ifa_flags, &rt)) != 0) + goto done; + + VERIFY(rt != NULL); +#if (DEVELOPMENT || DEBUG) + rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf)); +#endif /* (DEVELOPMENT || DEBUG) */ + switch (cmd) { + case RTM_DELETE: /* - * notify any listenning routing agents of the change + * If we are deleting, and we found an entry, then it's + * been removed from the tree. Notify any listening + * routing agents of the change and throw it away. */ - rt_newaddrmsg(cmd, ifa, error, nrt); - if (use_routegenid) - route_generation++; + RT_LOCK(rt); + rt_newaddrmsg(cmd, ifa, error, rt); + RT_UNLOCK(rt); +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + log(LOG_DEBUG, "%s: removed route to %s->%s->%s, " + "flags %b, ifaddr %s\n", __func__, dbuf, gbuf, + ((rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : ""), + rt->rt_flags, RTF_BITS, abuf); + } +#endif /* (DEVELOPMENT || DEBUG) */ rtfree_locked(rt); - } + break; - /* - * We are adding, and we have a returned routing entry. - * We need to sanity check the result. - */ - if (cmd == RTM_ADD && error == 0 && (rt = nrt)) { + case RTM_ADD: /* - * If it came back with an unexpected interface, then it must - * have already existed or something. (XXX) + * We are adding, and we have a returned routing entry. + * We need to sanity check the result. If it came back + * with an unexpected interface, then it must have already + * existed or something. */ + RT_LOCK(rt); if (rt->rt_ifa != ifa) { - if (!(rt->rt_ifa->ifa_ifp->if_flags & - (IFF_POINTOPOINT|IFF_LOOPBACK))) - printf("rtinit: wrong ifa (%p) was (%p)\n", - ifa, rt->rt_ifa); + void (*ifa_rtrequest) + (int, struct rtentry *, struct sockaddr *); +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + if (!(rt->rt_ifa->ifa_ifp->if_flags & + (IFF_POINTOPOINT|IFF_LOOPBACK))) { + log(LOG_ERR, "%s: %s route to %s->%s->%s, " + "flags %b, ifaddr %s, rt_ifa 0x%llx != " + "ifa 0x%llx\n", __func__, rtm2str(cmd), + dbuf, gbuf, ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), rt->rt_flags, + RTF_BITS, abuf, + (uint64_t)VM_KERNEL_ADDRPERM(rt->rt_ifa), + (uint64_t)VM_KERNEL_ADDRPERM(ifa)); + } + + log(LOG_DEBUG, "%s: %s route to %s->%s->%s, " + "flags %b, ifaddr %s, rt_ifa was 0x%llx " + "now 0x%llx\n", __func__, rtm2str(cmd), + dbuf, gbuf, ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), rt->rt_flags, + RTF_BITS, abuf, + (uint64_t)VM_KERNEL_ADDRPERM(rt->rt_ifa), + (uint64_t)VM_KERNEL_ADDRPERM(ifa)); + } +#endif /* (DEVELOPMENT || DEBUG) */ + /* * Ask that the protocol in question * remove anything it has associated with * this route and ifaddr. */ - if (rt->rt_ifa->ifa_rtrequest) - rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0)); + ifa_rtrequest = rt->rt_ifa->ifa_rtrequest; + if (ifa_rtrequest != NULL) + ifa_rtrequest(RTM_DELETE, rt, NULL); /* * Set the route's ifa. */ rtsetifa(rt, ifa); + + if (rt->rt_ifp != ifa->ifa_ifp) { + /* + * Purge any link-layer info caching. + */ + if (rt->rt_llinfo_purge != NULL) + rt->rt_llinfo_purge(rt); + /* + * Adjust route ref count for the interfaces. + */ + if (rt->rt_if_ref_fn != NULL) { + rt->rt_if_ref_fn(ifa->ifa_ifp, 1); + rt->rt_if_ref_fn(rt->rt_ifp, -1); + } + } + /* * And substitute in references to the ifaddr * we are adding. */ rt->rt_ifp = ifa->ifa_ifp; - rt->rt_rmx.rmx_mtu = ifa->ifa_ifp->if_mtu; /*XXX*/ + /* + * If rmx_mtu is not locked, update it + * to the MTU used by the new interface. + */ + if (!(rt->rt_rmx.rmx_locks & RTV_MTU)) + rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; + /* * Now ask the protocol to check if it needs * any special processing in its new form. */ - if (ifa->ifa_rtrequest) - ifa->ifa_rtrequest(RTM_ADD, rt, SA(0)); + ifa_rtrequest = ifa->ifa_rtrequest; + if (ifa_rtrequest != NULL) + ifa_rtrequest(RTM_ADD, rt, NULL); + } else { +#if (DEVELOPMENT || DEBUG) + if (rt_verbose) { + log(LOG_DEBUG, "%s: added route to %s->%s->%s, " + "flags %b, ifaddr %s\n", __func__, dbuf, + gbuf, ((rt->rt_ifp != NULL) ? + rt->rt_ifp->if_xname : ""), rt->rt_flags, + RTF_BITS, abuf); + } +#endif /* (DEVELOPMENT || DEBUG) */ } /* * notify any listenning routing agents of the change */ - rt_newaddrmsg(cmd, ifa, error, nrt); - if (use_routegenid) - route_generation++; + rt_newaddrmsg(cmd, ifa, error, rt); /* * We just wanted to add it; we don't actually need a * reference. This will result in a route that's added @@ -2097,12 +3490,140 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) * RTM_DELETE code will do the necessary step to adjust * the reference count at deletion time. */ - rtunref(rt); + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + break; + + default: + VERIFY(0); + /* NOTREACHED */ } +done: return (error); } -struct rtentry * +static void +rt_set_idleref(struct rtentry *rt) +{ + RT_LOCK_ASSERT_HELD(rt); + + /* + * We currently keep idle refcnt only on unicast cloned routes + * that aren't marked with RTF_NOIFREF. + */ + if (rt->rt_parent != NULL && !(rt->rt_flags & + (RTF_NOIFREF|RTF_BROADCAST | RTF_MULTICAST)) && + (rt->rt_flags & (RTF_UP|RTF_WASCLONED|RTF_IFREF)) == + (RTF_UP|RTF_WASCLONED)) { + rt_clear_idleref(rt); /* drop existing refcnt if any */ + rt->rt_if_ref_fn = rte_if_ref; + /* Become a regular mutex, just in case */ + RT_CONVERT_LOCK(rt); + rt->rt_if_ref_fn(rt->rt_ifp, 1); + rt->rt_flags |= RTF_IFREF; + } +} + +void +rt_clear_idleref(struct rtentry *rt) +{ + RT_LOCK_ASSERT_HELD(rt); + + if (rt->rt_if_ref_fn != NULL) { + VERIFY((rt->rt_flags & (RTF_NOIFREF | RTF_IFREF)) == RTF_IFREF); + /* Become a regular mutex, just in case */ + RT_CONVERT_LOCK(rt); + rt->rt_if_ref_fn(rt->rt_ifp, -1); + rt->rt_flags &= ~RTF_IFREF; + rt->rt_if_ref_fn = NULL; + } +} + +void +rt_set_proxy(struct rtentry *rt, boolean_t set) +{ + lck_mtx_lock(rnh_lock); + RT_LOCK(rt); + /* + * Search for any cloned routes which might have + * been formed from this node, and delete them. + */ + if (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) { + struct radix_node_head *rnh = rt_tables[rt_key(rt)->sa_family]; + + if (set) + rt->rt_flags |= RTF_PROXY; + else + rt->rt_flags &= ~RTF_PROXY; + + RT_UNLOCK(rt); + if (rnh != NULL && rt_mask(rt)) { + rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt), + rt_fixdelete, rt); + } + } else { + RT_UNLOCK(rt); + } + lck_mtx_unlock(rnh_lock); +} + +static void +rte_lock_init(struct rtentry *rt) +{ + lck_mtx_init(&rt->rt_lock, rte_mtx_grp, rte_mtx_attr); +} + +static void +rte_lock_destroy(struct rtentry *rt) +{ + RT_LOCK_ASSERT_NOTHELD(rt); + lck_mtx_destroy(&rt->rt_lock, rte_mtx_grp); +} + +void +rt_lock(struct rtentry *rt, boolean_t spin) +{ + RT_LOCK_ASSERT_NOTHELD(rt); + if (spin) + lck_mtx_lock_spin(&rt->rt_lock); + else + lck_mtx_lock(&rt->rt_lock); + if (rte_debug & RTD_DEBUG) + rte_lock_debug((struct rtentry_dbg *)rt); +} + +void +rt_unlock(struct rtentry *rt) +{ + if (rte_debug & RTD_DEBUG) + rte_unlock_debug((struct rtentry_dbg *)rt); + lck_mtx_unlock(&rt->rt_lock); + +} + +static inline void +rte_lock_debug(struct rtentry_dbg *rte) +{ + uint32_t idx; + + RT_LOCK_ASSERT_HELD((struct rtentry *)rte); + idx = atomic_add_32_ov(&rte->rtd_lock_cnt, 1) % CTRACE_HIST_SIZE; + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_lock[idx]); +} + +static inline void +rte_unlock_debug(struct rtentry_dbg *rte) +{ + uint32_t idx; + + RT_LOCK_ASSERT_HELD((struct rtentry *)rte); + idx = atomic_add_32_ov(&rte->rtd_unlock_cnt, 1) % CTRACE_HIST_SIZE; + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_unlock[idx]); +} + +static struct rtentry * rte_alloc(void) { if (rte_debug & RTD_DEBUG) @@ -2111,7 +3632,7 @@ rte_alloc(void) return ((struct rtentry *)zalloc(rte_zone)); } -void +static void rte_free(struct rtentry *p) { if (rte_debug & RTD_DEBUG) { @@ -2119,12 +3640,62 @@ rte_free(struct rtentry *p) return; } - if (p->rt_refcnt != 0) + if (p->rt_refcnt != 0) { panic("rte_free: rte=%p refcnt=%d non-zero\n", p, p->rt_refcnt); + /* NOTREACHED */ + } zfree(rte_zone, p); } +static void +rte_if_ref(struct ifnet *ifp, int cnt) +{ + struct kev_msg ev_msg; + struct net_event_data ev_data; + uint32_t old; + + /* Force cnt to 1 increment/decrement */ + if (cnt < -1 || cnt > 1) { + panic("%s: invalid count argument (%d)", __func__, cnt); + /* NOTREACHED */ + } + old = atomic_add_32_ov(&ifp->if_route_refcnt, cnt); + if (cnt < 0 && old == 0) { + panic("%s: ifp=%p negative route refcnt!", __func__, ifp); + /* NOTREACHED */ + } + /* + * The following is done without first holding the ifnet lock, + * for performance reasons. The relevant ifnet fields, with + * the exception of the if_idle_flags, are never changed + * during the lifetime of the ifnet. The if_idle_flags + * may possibly be modified, so in the event that the value + * is stale because IFRF_IDLE_NOTIFY was cleared, we'd end up + * sending the event anyway. This is harmless as it is just + * a notification to the monitoring agent in user space, and + * it is expected to check via SIOCGIFGETRTREFCNT again anyway. + */ + if ((ifp->if_idle_flags & IFRF_IDLE_NOTIFY) && cnt < 0 && old == 1) { + bzero(&ev_msg, sizeof (ev_msg)); + bzero(&ev_data, sizeof (ev_data)); + + ev_msg.vendor_code = KEV_VENDOR_APPLE; + ev_msg.kev_class = KEV_NETWORK_CLASS; + ev_msg.kev_subclass = KEV_DL_SUBCLASS; + ev_msg.event_code = KEV_DL_IF_IDLE_ROUTE_REFCNT; + + strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ); + + ev_data.if_family = ifp->if_family; + ev_data.if_unit = ifp->if_unit; + ev_msg.dv[0].data_length = sizeof (struct net_event_data); + ev_msg.dv[0].data_ptr = &ev_data; + + dlil_post_complete_msg(NULL, &ev_msg); + } +} + static inline struct rtentry * rte_alloc_debug(void) { @@ -2133,11 +3704,8 @@ rte_alloc_debug(void) rte = ((struct rtentry_dbg *)zalloc(rte_zone)); if (rte != NULL) { bzero(rte, sizeof (*rte)); - if (rte_debug & RTD_TRACE) { - rte->rtd_alloc_thread = current_thread(); - (void) OSBacktrace(rte->rtd_alloc_stk_pc, - RTD_TRSTACK_SIZE); - } + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_alloc); rte->rtd_inuse = RTD_INUSE; } return ((struct rtentry *)rte); @@ -2148,24 +3716,693 @@ rte_free_debug(struct rtentry *p) { struct rtentry_dbg *rte = (struct rtentry_dbg *)p; - if (p->rt_refcnt != 0) + if (p->rt_refcnt != 0) { panic("rte_free: rte=%p refcnt=%d\n", p, p->rt_refcnt); - - if (rte->rtd_inuse == RTD_FREED) + /* NOTREACHED */ + } + if (rte->rtd_inuse == RTD_FREED) { panic("rte_free: double free rte=%p\n", rte); - else if (rte->rtd_inuse != RTD_INUSE) + /* NOTREACHED */ + } else if (rte->rtd_inuse != RTD_INUSE) { panic("rte_free: corrupted rte=%p\n", rte); - + /* NOTREACHED */ + } bcopy((caddr_t)p, (caddr_t)&rte->rtd_entry_saved, sizeof (*p)); - bzero((caddr_t)p, sizeof (*p)); + /* Preserve rt_lock to help catch use-after-free cases */ + bzero((caddr_t)p, offsetof(struct rtentry, rt_lock)); rte->rtd_inuse = RTD_FREED; - if (rte_debug & RTD_TRACE) { - rte->rtd_free_thread = current_thread(); - (void) OSBacktrace(rte->rtd_free_stk_pc, RTD_TRSTACK_SIZE); - } + if (rte_debug & RTD_TRACE) + ctrace_record(&rte->rtd_free); if (!(rte_debug & RTD_NO_FREE)) zfree(rte_zone, p); } + +void +ctrace_record(ctrace_t *tr) +{ + tr->th = current_thread(); + bzero(tr->pc, sizeof (tr->pc)); + (void) OSBacktrace(tr->pc, CTRACE_STACK_SIZE); +} + +void +route_copyout(struct route *dst, const struct route *src, size_t length) +{ + /* Copy everything (rt, srcif, flags, dst) from src */ + bcopy(src, dst, length); + + /* Hold one reference for the local copy of struct route */ + if (dst->ro_rt != NULL) + RT_ADDREF(dst->ro_rt); + + /* Hold one reference for the local copy of struct lle */ + if (dst->ro_lle != NULL) + LLE_ADDREF(dst->ro_lle); + + /* Hold one reference for the local copy of struct ifaddr */ + if (dst->ro_srcia != NULL) + IFA_ADDREF(dst->ro_srcia); +} + +void +route_copyin(struct route *src, struct route *dst, size_t length) +{ + /* + * No cached route at the destination? + * If none, then remove old references if present + * and copy entire src route. + */ + if (dst->ro_rt == NULL) { + /* + * Ditch the cached link layer reference (dst) + * since we're about to take everything there is in src + */ + if (dst->ro_lle != NULL) + LLE_REMREF(dst->ro_lle); + /* + * Ditch the address in the cached copy (dst) since + * we're about to take everything there is in src. + */ + if (dst->ro_srcia != NULL) + IFA_REMREF(dst->ro_srcia); + /* + * Copy everything (rt, ro_lle, srcia, flags, dst) from src; the + * references to rt and/or srcia were held at the time + * of storage and are kept intact. + */ + bcopy(src, dst, length); + goto done; + } + + /* + * We know dst->ro_rt is not NULL here. + * If the src->ro_rt is the same, update ro_lle, srcia and flags + * and ditch the route in the local copy. + */ + if (dst->ro_rt == src->ro_rt) { + dst->ro_flags = src->ro_flags; + + if (dst->ro_lle != src->ro_lle) { + if (dst->ro_lle != NULL) + LLE_REMREF(dst->ro_lle); + dst->ro_lle = src->ro_lle; + } else if (src->ro_lle != NULL) { + LLE_REMREF(src->ro_lle); + } + + if (dst->ro_srcia != src->ro_srcia) { + if (dst->ro_srcia != NULL) + IFA_REMREF(dst->ro_srcia); + dst->ro_srcia = src->ro_srcia; + } else if (src->ro_srcia != NULL) { + IFA_REMREF(src->ro_srcia); + } + rtfree(src->ro_rt); + goto done; + } + + /* + * If they are dst's ro_rt is not equal to src's, + * and src'd rt is not NULL, then remove old references + * if present and copy entire src route. + */ + if (src->ro_rt != NULL) { + rtfree(dst->ro_rt); + + if (dst->ro_lle != NULL) + LLE_REMREF(dst->ro_lle); + if (dst->ro_srcia != NULL) + IFA_REMREF(dst->ro_srcia); + bcopy(src, dst, length); + goto done; + } + + /* + * Here, dst's cached route is not NULL but source's is. + * Just get rid of all the other cached reference in src. + */ + if (src->ro_srcia != NULL) { + /* + * Ditch src address in the local copy (src) since we're + * not caching the route entry anyway (ro_rt is NULL). + */ + IFA_REMREF(src->ro_srcia); + } + if (src->ro_lle != NULL) { + /* + * Ditch cache lle in the local copy (src) since we're + * not caching the route anyway (ro_rt is NULL). + */ + LLE_REMREF(src->ro_lle); + } +done: + /* This function consumes the references on src */ + src->ro_lle = NULL; + src->ro_rt = NULL; + src->ro_srcia = NULL; +} + +/* + * route_to_gwroute will find the gateway route for a given route. + * + * If the route is down, look the route up again. + * If the route goes through a gateway, get the route to the gateway. + * If the gateway route is down, look it up again. + * If the route is set to reject, verify it hasn't expired. + * + * If the returned route is non-NULL, the caller is responsible for + * releasing the reference and unlocking the route. + */ +#define senderr(e) { error = (e); goto bad; } +errno_t +route_to_gwroute(const struct sockaddr *net_dest, struct rtentry *hint0, + struct rtentry **out_route) +{ + uint64_t timenow; + struct rtentry *rt = hint0, *hint = hint0; + errno_t error = 0; + unsigned int ifindex; + boolean_t gwroute; + + *out_route = NULL; + + if (rt == NULL) + return (0); + + /* + * Next hop determination. Because we may involve the gateway route + * in addition to the original route, locking is rather complicated. + * The general concept is that regardless of whether the route points + * to the original route or to the gateway route, this routine takes + * an extra reference on such a route. This extra reference will be + * released at the end. + * + * Care must be taken to ensure that the "hint0" route never gets freed + * via rtfree(), since the caller may have stored it inside a struct + * route with a reference held for that placeholder. + */ + RT_LOCK_SPIN(rt); + ifindex = rt->rt_ifp->if_index; + RT_ADDREF_LOCKED(rt); + if (!(rt->rt_flags & RTF_UP)) { + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + /* route is down, find a new one */ + hint = rt = rtalloc1_scoped((struct sockaddr *) + (size_t)net_dest, 1, 0, ifindex); + if (hint != NULL) { + RT_LOCK_SPIN(rt); + ifindex = rt->rt_ifp->if_index; + } else { + senderr(EHOSTUNREACH); + } + } + + /* + * We have a reference to "rt" by now; it will either + * be released or freed at the end of this routine. + */ + RT_LOCK_ASSERT_HELD(rt); + if ((gwroute = (rt->rt_flags & RTF_GATEWAY))) { + struct rtentry *gwrt = rt->rt_gwroute; + struct sockaddr_storage ss; + struct sockaddr *gw = (struct sockaddr *)&ss; + + VERIFY(rt == hint); + RT_ADDREF_LOCKED(hint); + + /* If there's no gateway rt, look it up */ + if (gwrt == NULL) { + bcopy(rt->rt_gateway, gw, MIN(sizeof (ss), + rt->rt_gateway->sa_len)); + RT_UNLOCK(rt); + goto lookup; + } + /* Become a regular mutex */ + RT_CONVERT_LOCK(rt); + + /* + * Take gwrt's lock while holding route's lock; + * this is okay since gwrt never points back + * to "rt", so no lock ordering issues. + */ + RT_LOCK_SPIN(gwrt); + if (!(gwrt->rt_flags & RTF_UP)) { + rt->rt_gwroute = NULL; + RT_UNLOCK(gwrt); + bcopy(rt->rt_gateway, gw, MIN(sizeof (ss), + rt->rt_gateway->sa_len)); + RT_UNLOCK(rt); + rtfree(gwrt); +lookup: + lck_mtx_lock(rnh_lock); + gwrt = rtalloc1_scoped_locked(gw, 1, 0, ifindex); + + RT_LOCK(rt); + /* + * Bail out if the route is down, no route + * to gateway, circular route, or if the + * gateway portion of "rt" has changed. + */ + if (!(rt->rt_flags & RTF_UP) || gwrt == NULL || + gwrt == rt || !equal(gw, rt->rt_gateway)) { + if (gwrt == rt) { + RT_REMREF_LOCKED(gwrt); + gwrt = NULL; + } + VERIFY(rt == hint); + RT_REMREF_LOCKED(hint); + hint = NULL; + RT_UNLOCK(rt); + if (gwrt != NULL) + rtfree_locked(gwrt); + lck_mtx_unlock(rnh_lock); + senderr(EHOSTUNREACH); + } + VERIFY(gwrt != NULL); + /* + * Set gateway route; callee adds ref to gwrt; + * gwrt has an extra ref from rtalloc1() for + * this routine. + */ + rt_set_gwroute(rt, rt_key(rt), gwrt); + VERIFY(rt == hint); + RT_REMREF_LOCKED(rt); /* hint still holds a refcnt */ + RT_UNLOCK(rt); + lck_mtx_unlock(rnh_lock); + rt = gwrt; + } else { + RT_ADDREF_LOCKED(gwrt); + RT_UNLOCK(gwrt); + VERIFY(rt == hint); + RT_REMREF_LOCKED(rt); /* hint still holds a refcnt */ + RT_UNLOCK(rt); + rt = gwrt; + } + VERIFY(rt == gwrt && rt != hint); + + /* + * This is an opportunity to revalidate the parent route's + * rt_gwroute, in case it now points to a dead route entry. + * Parent route won't go away since the clone (hint) holds + * a reference to it. rt == gwrt. + */ + RT_LOCK_SPIN(hint); + if ((hint->rt_flags & (RTF_WASCLONED | RTF_UP)) == + (RTF_WASCLONED | RTF_UP)) { + struct rtentry *prt = hint->rt_parent; + VERIFY(prt != NULL); + + RT_CONVERT_LOCK(hint); + RT_ADDREF(prt); + RT_UNLOCK(hint); + rt_revalidate_gwroute(prt, rt); + RT_REMREF(prt); + } else { + RT_UNLOCK(hint); + } + + /* Clean up "hint" now; see notes above regarding hint0 */ + if (hint == hint0) + RT_REMREF(hint); + else + rtfree(hint); + hint = NULL; + + /* rt == gwrt; if it is now down, give up */ + RT_LOCK_SPIN(rt); + if (!(rt->rt_flags & RTF_UP)) { + RT_UNLOCK(rt); + senderr(EHOSTUNREACH); + } + } + + if (rt->rt_flags & RTF_REJECT) { + VERIFY(rt->rt_expire == 0 || rt->rt_rmx.rmx_expire != 0); + VERIFY(rt->rt_expire != 0 || rt->rt_rmx.rmx_expire == 0); + timenow = net_uptime(); + if (rt->rt_expire == 0 || timenow < rt->rt_expire) { + RT_UNLOCK(rt); + senderr(!gwroute ? EHOSTDOWN : EHOSTUNREACH); + } + } + + /* Become a regular mutex */ + RT_CONVERT_LOCK(rt); + + /* Caller is responsible for cleaning up "rt" */ + *out_route = rt; + return (0); + +bad: + /* Clean up route (either it is "rt" or "gwrt") */ + if (rt != NULL) { + RT_LOCK_SPIN(rt); + if (rt == hint0) { + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); + } else { + RT_UNLOCK(rt); + rtfree(rt); + } + } + return (error); +} +#undef senderr + +void +rt_revalidate_gwroute(struct rtentry *rt, struct rtentry *gwrt) +{ + VERIFY(gwrt != NULL); + + RT_LOCK_SPIN(rt); + if ((rt->rt_flags & (RTF_GATEWAY | RTF_UP)) == (RTF_GATEWAY | RTF_UP) && + rt->rt_ifp == gwrt->rt_ifp && rt->rt_gateway->sa_family == + rt_key(gwrt)->sa_family && (rt->rt_gwroute == NULL || + !(rt->rt_gwroute->rt_flags & RTF_UP))) { + boolean_t isequal; + VERIFY(rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)); + + if (rt->rt_gateway->sa_family == AF_INET || + rt->rt_gateway->sa_family == AF_INET6) { + struct sockaddr_storage key_ss, gw_ss; + /* + * We need to compare rt_key and rt_gateway; create + * local copies to get rid of any ifscope association. + */ + (void) sa_copy(rt_key(gwrt), &key_ss, NULL); + (void) sa_copy(rt->rt_gateway, &gw_ss, NULL); + + isequal = equal(SA(&key_ss), SA(&gw_ss)); + } else { + isequal = equal(rt_key(gwrt), rt->rt_gateway); + } + + /* If they are the same, update gwrt */ + if (isequal) { + RT_UNLOCK(rt); + lck_mtx_lock(rnh_lock); + RT_LOCK(rt); + rt_set_gwroute(rt, rt_key(rt), gwrt); + RT_UNLOCK(rt); + lck_mtx_unlock(rnh_lock); + } else { + RT_UNLOCK(rt); + } + } else { + RT_UNLOCK(rt); + } +} + +static void +rt_str4(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen) +{ + VERIFY(rt_key(rt)->sa_family == AF_INET); + + if (ds != NULL) { + (void) inet_ntop(AF_INET, + &SIN(rt_key(rt))->sin_addr.s_addr, ds, dslen); + if (dslen >= MAX_SCOPE_ADDR_STR_LEN && + SINIFSCOPE(rt_key(rt))->sin_scope_id != IFSCOPE_NONE) { + char scpstr[16]; + + snprintf(scpstr, sizeof(scpstr), "@%u", + SINIFSCOPE(rt_key(rt))->sin_scope_id); + + strlcat(ds, scpstr, dslen); + } + } + + if (gs != NULL) { + if (rt->rt_flags & RTF_GATEWAY) { + (void) inet_ntop(AF_INET, + &SIN(rt->rt_gateway)->sin_addr.s_addr, gs, gslen); + } else if (rt->rt_ifp != NULL) { + snprintf(gs, gslen, "link#%u", rt->rt_ifp->if_unit); + } else { + snprintf(gs, gslen, "%s", "link"); + } + } +} + +#if INET6 +static void +rt_str6(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen) +{ + VERIFY(rt_key(rt)->sa_family == AF_INET6); + + if (ds != NULL) { + (void) inet_ntop(AF_INET6, + &SIN6(rt_key(rt))->sin6_addr, ds, dslen); + if (dslen >= MAX_SCOPE_ADDR_STR_LEN && + SIN6IFSCOPE(rt_key(rt))->sin6_scope_id != IFSCOPE_NONE) { + char scpstr[16]; + + snprintf(scpstr, sizeof(scpstr), "@%u", + SIN6IFSCOPE(rt_key(rt))->sin6_scope_id); + + strlcat(ds, scpstr, dslen); + } + } + + if (gs != NULL) { + if (rt->rt_flags & RTF_GATEWAY) { + (void) inet_ntop(AF_INET6, + &SIN6(rt->rt_gateway)->sin6_addr, gs, gslen); + } else if (rt->rt_ifp != NULL) { + snprintf(gs, gslen, "link#%u", rt->rt_ifp->if_unit); + } else { + snprintf(gs, gslen, "%s", "link"); + } + } +} +#endif /* INET6 */ + + +void +rt_str(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen) +{ + switch (rt_key(rt)->sa_family) { + case AF_INET: + rt_str4(rt, ds, dslen, gs, gslen); + break; +#if INET6 + case AF_INET6: + rt_str6(rt, ds, dslen, gs, gslen); + break; +#endif /* INET6 */ + default: + if (ds != NULL) + bzero(ds, dslen); + if (gs != NULL) + bzero(gs, gslen); + break; + } +} + +void route_event_init(struct route_event *p_route_ev, struct rtentry *rt, + struct rtentry *gwrt, int route_ev_code) +{ + VERIFY(p_route_ev != NULL); + bzero(p_route_ev, sizeof(*p_route_ev)); + + p_route_ev->rt = rt; + p_route_ev->gwrt = gwrt; + p_route_ev->route_event_code = route_ev_code; +} + +static void +route_event_callback(void *arg) +{ + struct route_event *p_rt_ev = (struct route_event *)arg; + struct rtentry *rt = p_rt_ev->rt; + eventhandler_tag evtag = p_rt_ev->evtag; + int route_ev_code = p_rt_ev->route_event_code; + + if (route_ev_code == ROUTE_EVHDLR_DEREGISTER) { + VERIFY(evtag != NULL); + EVENTHANDLER_DEREGISTER(&rt->rt_evhdlr_ctxt, route_event, + evtag); + rtfree(rt); + return; + } + + EVENTHANDLER_INVOKE(&rt->rt_evhdlr_ctxt, route_event, rt_key(rt), + route_ev_code, (struct sockaddr *)&p_rt_ev->rt_addr, + rt->rt_flags); + + /* The code enqueuing the route event held a reference */ + rtfree(rt); + /* XXX No reference is taken on gwrt */ +} + +int +route_event_walktree(struct radix_node *rn, void *arg) +{ + struct route_event *p_route_ev = (struct route_event *)arg; + struct rtentry *rt = (struct rtentry *)rn; + struct rtentry *gwrt = p_route_ev->rt; + + LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); + + RT_LOCK(rt); + + /* Return if the entry is pending cleanup */ + if (rt->rt_flags & RTPRF_OURS) { + RT_UNLOCK(rt); + return (0); + } + + /* Return if it is not an indirect route */ + if (!(rt->rt_flags & RTF_GATEWAY)) { + RT_UNLOCK(rt); + return (0); + } + + if (rt->rt_gwroute != gwrt) { + RT_UNLOCK(rt); + return (0); + } + + route_event_enqueue_nwk_wq_entry(rt, gwrt, p_route_ev->route_event_code, + NULL, TRUE); + RT_UNLOCK(rt); + + return (0); +} + +struct route_event_nwk_wq_entry +{ + struct nwk_wq_entry nwk_wqe; + struct route_event rt_ev_arg; +}; + +void +route_event_enqueue_nwk_wq_entry(struct rtentry *rt, struct rtentry *gwrt, + uint32_t route_event_code, eventhandler_tag evtag, boolean_t rt_locked) +{ + struct route_event_nwk_wq_entry *p_rt_ev = NULL; + struct sockaddr *p_gw_saddr = NULL; + + MALLOC(p_rt_ev, struct route_event_nwk_wq_entry *, + sizeof(struct route_event_nwk_wq_entry), + M_NWKWQ, M_WAITOK | M_ZERO); + + /* + * If the intent is to de-register, don't take + * reference, route event registration already takes + * a reference on route. + */ + if (route_event_code != ROUTE_EVHDLR_DEREGISTER) { + /* The reference is released by route_event_callback */ + if (rt_locked) + RT_ADDREF_LOCKED(rt); + else + RT_ADDREF(rt); + } + + p_rt_ev->rt_ev_arg.rt = rt; + p_rt_ev->rt_ev_arg.gwrt = gwrt; + p_rt_ev->rt_ev_arg.evtag = evtag; + + if (gwrt != NULL) + p_gw_saddr = gwrt->rt_gateway; + else + p_gw_saddr = rt->rt_gateway; + + VERIFY(p_gw_saddr->sa_len <= sizeof(p_rt_ev->rt_ev_arg.rt_addr)); + bcopy(p_gw_saddr, &(p_rt_ev->rt_ev_arg.rt_addr), p_gw_saddr->sa_len); + + p_rt_ev->rt_ev_arg.route_event_code = route_event_code; + p_rt_ev->nwk_wqe.func = route_event_callback; + p_rt_ev->nwk_wqe.is_arg_managed = TRUE; + p_rt_ev->nwk_wqe.arg = &p_rt_ev->rt_ev_arg; + nwk_wq_enqueue((struct nwk_wq_entry*)p_rt_ev); +} + +const char * +route_event2str(int route_event) +{ + const char *route_event_str = "ROUTE_EVENT_UNKNOWN"; + switch (route_event) { + case ROUTE_STATUS_UPDATE: + route_event_str = "ROUTE_STATUS_UPDATE"; + break; + case ROUTE_ENTRY_REFRESH: + route_event_str = "ROUTE_ENTRY_REFRESH"; + break; + case ROUTE_ENTRY_DELETED: + route_event_str = "ROUTE_ENTRY_DELETED"; + break; + case ROUTE_LLENTRY_RESOLVED: + route_event_str = "ROUTE_LLENTRY_RESOLVED"; + break; + case ROUTE_LLENTRY_UNREACH: + route_event_str = "ROUTE_LLENTRY_UNREACH"; + break; + case ROUTE_LLENTRY_CHANGED: + route_event_str = "ROUTE_LLENTRY_CHANGED"; + break; + case ROUTE_LLENTRY_STALE: + route_event_str = "ROUTE_LLENTRY_STALE"; + break; + case ROUTE_LLENTRY_TIMEDOUT: + route_event_str = "ROUTE_LLENTRY_TIMEDOUT"; + break; + case ROUTE_LLENTRY_DELETED: + route_event_str = "ROUTE_LLENTRY_DELETED"; + break; + case ROUTE_LLENTRY_EXPIRED: + route_event_str = "ROUTE_LLENTRY_EXPIRED"; + break; + case ROUTE_LLENTRY_PROBED: + route_event_str = "ROUTE_LLENTRY_PROBED"; + break; + case ROUTE_EVHDLR_DEREGISTER: + route_event_str = "ROUTE_EVHDLR_DEREGISTER"; + break; + default: + /* Init'd to ROUTE_EVENT_UNKNOWN */ + break; + } + return route_event_str; +} + +int +route_op_entitlement_check(struct socket *so, + kauth_cred_t cred, + int route_op_type, + boolean_t allow_root) +{ + if (so != NULL) { + if (route_op_type == ROUTE_OP_READ) { + /* + * If needed we can later extend this for more + * granular entitlements and return a bit set of + * allowed accesses. + */ + if (soopt_cred_check(so, PRIV_NET_RESTRICTED_ROUTE_NC_READ, + allow_root) == 0) + return (0); + else + return (-1); + } + } else if (cred != NULL) { + uid_t uid = kauth_cred_getuid(cred); + + /* uid is 0 for root */ + if (uid != 0 || !allow_root) { + if (route_op_type == ROUTE_OP_READ) { + if (priv_check_cred(cred, + PRIV_NET_RESTRICTED_ROUTE_NC_READ, 0) == 0) + return (0); + else + return (-1); + } + } + } + return (-1); +}