X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/c910b4d9d2451126ae3917b931cd4390c11e1d52..b0d623f7f2ae71ed96e60569f61f9a9a27016e80:/bsd/net/route.c diff --git a/bsd/net/route.c b/bsd/net/route.c index 4e4fb302e..66082731e 100644 --- a/bsd/net/route.c +++ b/bsd/net/route.c @@ -87,6 +87,104 @@ #include +/* + * 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 + * + * - 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. + * + * 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(). + * + * generation_id + * + * - 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)) @@ -97,30 +195,38 @@ struct route_cb route_cb; __private_extern__ struct rtstat rtstat = { 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; +lck_mtx_t *rnh_lock; /* global routing tables mutex */ +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; /* 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 */ +/* 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,66 +234,74 @@ 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 */ +#define atomic_add_16_ov(a, n) \ + ((uint16_t) OSAddAtomic16(n, (volatile SInt16 *)a)) +#define atomic_add_32_ov(a, n) \ + ((uint32_t) OSAddAtomic(n, a)) + +/* 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 inline void rte_lock_debug(struct rtentry_dbg *); +static inline void rte_unlock_debug(struct rtentry_dbg *); static void rt_maskedcopy(struct sockaddr *, struct sockaddr *, 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 void rtalloc_ign_common_locked(struct route *, uint32_t, 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 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 int rn_match_ifscope(struct radix_node *, void *); static struct ifaddr *ifa_ifwithroute_common_locked(int, const struct sockaddr *, const struct sockaddr *, unsigned int); +static struct rtentry *rte_alloc(void); +static void rte_free(struct rtentry *); +static void rtfree_common(struct rtentry *, boolean_t); -__private_extern__ u_long route_generation = 0; -extern int use_routegenid; +uint32_t route_generation = 0; /* * sockaddr_in with embedded interface scope; this is used internally @@ -243,7 +357,7 @@ static struct sockaddr sin_def = { /* * 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; @@ -265,7 +379,7 @@ rt_inet_default(struct rtentry *rt, struct sockaddr *dst) } /* - * 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) @@ -274,7 +388,7 @@ set_primary_ifscope(unsigned int 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) @@ -345,6 +459,94 @@ mask_copy(struct sockaddr *src, struct sockaddr_in *dst, unsigned int ifscope) return (SA(dst)); } +/* + * Trim trailing zeroes on a sockaddr and update its length. + */ +static struct sockaddr * +sa_trim(struct sockaddr *sa, int skip) +{ + 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 (sa); +} + +/* + * Called by rtm_msg{1,2} routines to "scrub" the embedded interface scope + * away from the socket address structure, so that clients of the routing + * socket will not be confused by the presence of the embedded scope, 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. + */ +struct sockaddr * +rtm_scrub_ifscope(int idx, struct sockaddr *hint, struct sockaddr *sa, + struct sockaddr_storage *ss) +{ + struct sockaddr *ret = sa; + + switch (idx) { + case RTAX_DST: + /* + * If this is for an AF_INET destination address, call + * sin_copy() with IFSCOPE_NONE as it does what we need. + */ + if (sa->sa_family == AF_INET && + SINIFSCOPE(sa)->sin_ifscope != IFSCOPE_NONE) { + bzero(ss, sizeof (*ss)); + ret = sin_copy(SIN(sa), SIN(ss), IFSCOPE_NONE); + } + break; + + case RTAX_NETMASK: { + /* + * If this is for a mask, we can't tell whether or not + * there is an embedded interface scope, as the span of + * bytes between sa_len and the beginning of the mask + * (offset of sin_addr in the case of AF_INET) 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. Clearing the embedded + * scope 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 mask_copy() on the source sockaddr. + */ + int skip = offsetof(struct sockaddr_in, sin_addr); + if (sa->sa_len > skip && sa->sa_len <= sizeof (*ss) && + hint != NULL && hint->sa_family == AF_INET) { + bzero(ss, sizeof (*ss)); + bcopy(sa, ss, sa->sa_len); + SINIFSCOPE(ss)->sin_ifscope = IFSCOPE_NONE; + ret = sa_trim(SA(ss), skip); + } + break; + } + default: + break; + } + + return (ret); +} + /* * Callback leaf-matching routine for rn_matchaddr_args used * for looking up an exact match for a scoped route entry. @@ -380,20 +582,22 @@ route_init(void) if (rte_debug != 0) rte_debug |= RTD_DEBUG; - rt_mtx_grp_attr = lck_grp_attr_alloc_init(); - - rt_mtx_grp = lck_grp_alloc_init("route", rt_mtx_grp_attr); - - rt_mtx_attr = lck_attr_alloc_init(); - - if ((rt_mtx = lck_mtx_alloc_init(rt_mtx_grp, rt_mtx_attr)) == NULL) { - printf("route_init: can't alloc rt_mtx\n"); + 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(); + if ((rnh_lock = lck_mtx_alloc_init(rnh_lock_grp, + rnh_lock_attr)) == NULL) { + printf("route_init: can't alloc rnh_lock\n"); return; } - lck_mtx_lock(rt_mtx); + 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(rt_mtx); + lck_mtx_unlock(rnh_lock); rtable_init((void **)rt_tables); route_domain_mtx = routedomain.dom_mtx; @@ -411,60 +615,87 @@ route_init(void) TAILQ_INIT(&rttrash_head); } +/* + * Atomically increment route generation counter + */ +void +routegenid_update(void) +{ + (void) atomic_add_32_ov(&route_generation, 1); +} + /* * Packet routing routines. */ void rtalloc(struct route *ro) { - rtalloc_ign(ro, 0UL); + rtalloc_ign(ro, 0); } void -rtalloc_ign_locked(struct route *ro, u_long ignore) +rtalloc_ign_locked(struct route *ro, uint32_t ignore) { return (rtalloc_ign_common_locked(ro, ignore, IFSCOPE_NONE)); } void -rtalloc_scoped_ign_locked(struct route *ro, u_long ignore, unsigned int ifscope) +rtalloc_scoped_ign_locked(struct route *ro, uint32_t ignore, + unsigned int ifscope) { return (rtalloc_ign_common_locked(ro, ignore, 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 && (rt->rt_flags & RTF_UP) && + rt->generation_id == route_generation) { + RT_UNLOCK(rt); return; + } + RT_UNLOCK(rt); rtfree_locked(rt); ro->ro_rt = NULL; } ro->ro_rt = rtalloc1_common_locked(&ro->ro_dst, 1, ignore, ifscope); - if (ro->ro_rt) + if (ro->ro_rt != NULL) { ro->ro_rt->generation_id = route_generation; + 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); + lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_NOTOWNED); + lck_mtx_lock(rnh_lock); rtalloc_ign_locked(ro, ignore); - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); +} + +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_scoped_ign_locked(ro, ignore, ifscope); + lck_mtx_unlock(rnh_lock); } struct rtentry * -rtalloc1_locked(struct sockaddr *dst, int report, u_long ignflags) +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)); @@ -475,13 +706,13 @@ rtalloc1_scoped_locked(struct sockaddr *dst, int report, u_long ignflags, * Or, at least try.. Create a cloned route if needed. */ static struct rtentry * -rtalloc1_common_locked(struct sockaddr *dst, int report, u_long ignflags, +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 +726,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). @@ -554,13 +787,25 @@ 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); + 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); +} + +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); } @@ -571,29 +816,69 @@ rtalloc1(struct sockaddr *dst, int report, u_long ignflags) 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 - */ - struct radix_node_head *rnh; + rtfree_common(rt, TRUE); +} - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); +static void +rtfree_common(struct rtentry *rt, boolean_t locked) +{ + struct radix_node_head *rnh; - /* 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 the 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); + RT_REMREF_LOCKED(rt); + if (rt->rt_refcnt > 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); + + /* + * 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,49 +888,59 @@ 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"); + panic("rt %p freed while in radix tree\n", rt); /* * 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 + /* + * Route is no longer in the tree and refcnt is 0; + * we have exclusive access, so destroy it. + */ + RT_UNLOCK(rt); /* * release references on items we hold them on.. * e.g other routes and ifaddrs. */ - if (rt->rt_parent) + if (rt->rt_parent != NULL) { rtfree_locked(rt->rt_parent); + rt->rt_parent = NULL; + } - if(rt->rt_ifa) { + if (rt->rt_ifa != NULL) { ifafree(rt->rt_ifa); rt->rt_ifa = NULL; } /* - * The key is separatly alloc'd so free it (see rt_setgate()). + * 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; + } + + /* + * The key is separately alloc'd so free it (see rt_setgate()). * This also frees the gateway, as they are always malloc'd * together. */ @@ -654,17 +949,25 @@ rtfree_locked(struct rtentry *rt) /* * and the rtentry itself of course */ + rte_lock_destroy(rt); 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 +975,34 @@ 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); + + --p->rt_refcnt; 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) { + uint16_t idx; + if (rte->rtd_inuse != RTD_INUSE) panic("rtunref: on freed rte=%p\n", rte); - rte->rtd_refrele_cnt++; - - 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; - } + 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,42 +1011,34 @@ 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); + if (++p->rt_refcnt == 0) + panic("%s(%p) bad refcnt\n", __func__, p); if (rte_debug & RTD_DEBUG) rtref_audit((struct rtentry_dbg *)p); - - p->rt_refcnt++; } static inline void rtref_audit(struct rtentry_dbg *rte) { + uint16_t idx; + if (rte->rtd_inuse != RTD_INUSE) panic("rtref_audit: on freed rte=%p\n", rte); - rte->rtd_refhold_cnt++; - - 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; - } + 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) { - 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; @@ -764,34 +1055,6 @@ rtsetifa(struct rtentry *rt, struct ifaddr* 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!"); -} - /* * Force a routing table entry to the specified * destination to go through the given gateway. @@ -811,8 +1074,8 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, unsigned int ifscope = (ifp != NULL) ? ifp->if_index : IFSCOPE_NONE; struct sockaddr_in sin; - 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); /* * Verify the gateway is directly reachable; if scoped routing @@ -826,6 +1089,8 @@ 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); + if (rt != NULL) + RT_LOCK(rt); /* Embed scope in src for comparison against rt_gateway below */ if (ip_doscopedroute && src->sa_family == AF_INET) @@ -837,7 +1102,7 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, * we have a routing loop, perhaps as a result of an interface * going down recently. */ - if (!(flags & RTF_DONE) && rt && + if (!(flags & RTF_DONE) && rt != NULL && (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr, ifa->ifa_addr))) { error = EINVAL; @@ -849,26 +1114,31 @@ rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway, error = EHOSTUNREACH; } } - + if (ifa) { ifafree(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 +1147,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,12 +1166,15 @@ 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 (rt != NULL) { + RT_LOCK_ASSERT_NOTHELD(rt); if (rtp && !error) *rtp = rt; else @@ -912,22 +1187,22 @@ out: if (stat != NULL) (*stat)++; if (use_routegenid) - route_generation++; + routegenid_update(); } + 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 @@ -945,9 +1220,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); } @@ -980,7 +1255,7 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, struct rtentry *rt = NULL; struct sockaddr_in dst_in, gw_in; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED); if (ip_doscopedroute) { /* @@ -1020,12 +1295,14 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, 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); + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); rt = NULL; } } @@ -1049,13 +1326,15 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, 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) { + 0, 0, ifscope)) != NULL) { if (ifa != NULL) ifafree(ifa); + RT_LOCK_SPIN(rt); ifa = rt->rt_ifa; if (ifa != NULL) ifaref(ifa); - rtunref(rt); + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); } /* * If an interface scope was specified, the interface index of @@ -1071,10 +1350,8 @@ ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst, 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; @@ -1132,7 +1409,7 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, struct sockaddr_in sin, mask; #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 */ @@ -1196,17 +1473,25 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, * will decrement the reference via rtfree_locked() and then * possibly deallocate it. */ - rtref(rt); + RT_LOCK(rt); + RT_ADDREF_LOCKED(rt); rt->rt_flags &= ~RTF_UP; + /* + * For consistency, in case the caller didn't set the flag. + */ + rt->rt_flags |= RTF_CONDEMNED; + /* * Now search what's left of the subtree for any cloned * routes which might have been formed from this node. */ 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_LOCK(rt); } /* @@ -1214,10 +1499,9 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, * 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 (rt->rt_gwroute != NULL) { + rtfree_locked(rt->rt_gwroute); + rt->rt_gwroute = NULL; } /* @@ -1231,7 +1515,7 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, * 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); @@ -1244,6 +1528,8 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, if (rt_inet_default(rt, rt_key(rt))) set_primary_ifscope(IFSCOPE_NONE); + RT_UNLOCK(rt); + /* * If the caller wants it, then it can have it, * but it's up to it to free the rtentry as we won't be @@ -1261,6 +1547,16 @@ rtrequest_common_locked(int req, struct sockaddr *dst0, case RTM_RESOLVE: if (ret_nrt == 0 || (rt = *ret_nrt) == 0) senderr(EINVAL); + /* + * 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); flags = rt->rt_flags & @@ -1315,6 +1611,8 @@ makeroute: if ((rt = rte_alloc()) == NULL) senderr(ENOBUFS); Bzero(rt, sizeof(*rt)); + rte_lock_init(rt); + RT_LOCK(rt); rt->rt_flags = RTF_UP | flags; /* @@ -1322,6 +1620,8 @@ makeroute: * also add the rt_gwroute if possible. */ if ((error = rt_setgate(rt, dst, gateway)) != 0) { + RT_UNLOCK(rt); + rte_lock_destroy(rt); rte_free(rt); senderr(error); } @@ -1368,10 +1668,13 @@ 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, @@ -1387,12 +1690,17 @@ makeroute: * then un-make it (this should be a function) */ if (rn == 0) { - if (rt->rt_gwroute) + if (rt->rt_gwroute) { rtfree_locked(rt->rt_gwroute); + rt->rt_gwroute = NULL; + } if (rt->rt_ifa) { ifafree(rt->rt_ifa); + rt->rt_ifa = NULL; } R_Free(rt_key(rt)); + RT_UNLOCK(rt); + rte_lock_destroy(rt); rte_free(rt); senderr(EEXIST); } @@ -1400,16 +1708,22 @@ makeroute: rt->rt_parent = 0; /* - * 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_LOCK_SPIN(*ret_nrt); rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */ 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); } /* @@ -1421,19 +1735,6 @@ makeroute: ifafree(ifa); ifa = 0; - /* - * 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 (!(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 this is the (non-scoped) default route, record * the interface index used for the primary ifscope. @@ -1447,7 +1748,23 @@ makeroute: */ if (ret_nrt) { *ret_nrt = rt; - rtref(rt); + RT_ADDREF_LOCKED(rt); + } + + /* + * 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 (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) { + 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); } break; } @@ -1467,10 +1784,10 @@ rtrequest( 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); } /* @@ -1486,14 +1803,21 @@ 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); + /* + * 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)); } + RT_UNLOCK(rt); return 0; } @@ -1520,11 +1844,15 @@ rt_fixchange(struct radix_node *rn, void *vp) u_char *xk1, *xm1, *xk2, *xmp; int i, len, mlen; - 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 || - (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) + (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) { + RT_UNLOCK(rt); return (0); + } if (rt->rt_parent == rt0) goto delete_rt; @@ -1542,17 +1870,23 @@ rt_fixchange(struct radix_node *rn, void *vp) /* 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) + if (mlen > rt_key(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]) + 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 +1894,51 @@ 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)); } +/* + * 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 = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len); + int dlen = SA_SIZE(dst->sa_len), glen = SA_SIZE(gate->sa_len); struct radix_node_head *rnh = rt_tables[dst->sa_family]; - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + 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); /* * A host route with the destination equal to the gateway @@ -1584,9 +1952,19 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) * 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); } @@ -1601,7 +1979,11 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) ifscope = (dst->sa_family == AF_INET) ? sa_get_ifscope(dst) : IFSCOPE_NONE; + RT_UNLOCK(rt); gwrt = rtalloc1_scoped_locked(gate, 1, RTF_PRCLONING, ifscope); + if (gwrt != NULL) + RT_LOCK_ASSERT_NOTHELD(gwrt); + RT_LOCK(rt); /* * Cloning loop avoidance: @@ -1618,19 +2000,36 @@ 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); } + /* 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); + } + if (rt->rt_gwroute != NULL) rtfree_locked(rt->rt_gwroute); rt->rt_gwroute = gwrt; @@ -1666,7 +2065,7 @@ 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 */ @@ -1675,6 +2074,8 @@ rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) if (rt->rt_gwroute != NULL) rtfree_locked(rt->rt_gwroute); rt->rt_gwroute = NULL; + /* Release extra ref */ + RT_REMREF_LOCKED(rt); return (ENOBUFS); } @@ -1683,7 +2084,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,7 +2094,7 @@ 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). @@ -1714,13 +2116,19 @@ 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); } +#undef SA_SIZE + static void rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst, struct sockaddr *netmask) @@ -1819,7 +2227,7 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, struct radix_node *rn0, *rn; boolean_t dontcare = (ifscope == IFSCOPE_NONE); - lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED); + lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED); if (!lookup_only) netmask = NULL; @@ -1832,7 +2240,25 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, rn = rnh->rnh_lookup(dst, netmask, rnh); else rn = rnh->rnh_matchaddr(dst, rnh); - goto done; + + /* + * 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)); } /* @@ -1851,7 +2277,7 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, * any reason, there is no primary interface, return what we have. */ if (dontcare && (ifscope = get_primary_ifscope()) == IFSCOPE_NONE) - goto validate; + goto done; /* * Keep the original result if either of the following is true: @@ -1861,7 +2287,8 @@ 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); @@ -1924,15 +2351,26 @@ rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask, RT(rn)->rt_ifp->if_index != ifscope) rn = NULL; -validate: - if (rn != NULL && !lookup_only) - (void) in_validate(rn); - done: - if (rn != NULL && (rn->rn_flags & RNF_ROOT)) - rn = NULL; - else if (rn != NULL) - rtref(RT(rn)); + if (rn != NULL) { + /* + * Manually clear RTPRF_OURS using in_validate() and + * bump up the reference count after, and not before; + * we only get here for AF_INET. 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(rn)->rt_flags & RTF_CONDEMNED)) { + if (!lookup_only) + (void) in_validate(rn); + RT_ADDREF_LOCKED(RT(rn)); + RT_UNLOCK(RT(rn)); + } else { + RT_UNLOCK(RT(rn)); + rn = NULL; + } + } return (RT(rn)); } @@ -1945,10 +2383,10 @@ 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); } @@ -1989,15 +2427,17 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) * We set "report" to FALSE so that if it doesn't exist, * it doesn't report an error or clone a route, etc. etc. */ - rt = rtalloc1_locked(dst, 0, 0UL); + rt = rtalloc1_locked(dst, 0, 0); if (rt) { /* * 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_SPIN(rt); if (rt->rt_ifa != ifa) { + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); /* * If the interface in the rtentry doesn't match * the interface we are using, then we don't @@ -2009,6 +2449,9 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) (void) m_free(m); return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); + } else { + RT_REMREF_LOCKED(rt); + RT_UNLOCK(rt); } } /* XXX */ @@ -2019,7 +2462,7 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) * it doesn't exist, we could just return at this point * with an "ELSE" clause, but apparently not.. */ - lck_mtx_unlock(rt_mtx); + lck_mtx_unlock(rnh_lock); return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); } @@ -2038,11 +2481,13 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) */ if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) { /* - * notify any listenning routing agents of the change + * notify any listening routing agents of the change */ + RT_LOCK(rt); rt_newaddrmsg(cmd, ifa, error, nrt); if (use_routegenid) - route_generation++; + routegenid_update(); + RT_UNLOCK(rt); rtfree_locked(rt); } @@ -2051,6 +2496,7 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) * We need to sanity check the result. */ if (cmd == RTM_ADD && error == 0 && (rt = nrt)) { + RT_LOCK(rt); /* * If it came back with an unexpected interface, then it must * have already existed or something. (XXX) @@ -2089,7 +2535,7 @@ rtinit_locked(struct ifaddr *ifa, int cmd, int flags) */ rt_newaddrmsg(cmd, ifa, error, nrt); if (use_routegenid) - route_generation++; + routegenid_update(); /* * We just wanted to add it; we don't actually need a * reference. This will result in a route that's added @@ -2097,12 +2543,68 @@ 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); } return (error); } -struct rtentry * +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) +{ + RT_LOCK_ASSERT_HELD(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; + + 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; + + 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 +2613,7 @@ rte_alloc(void) return ((struct rtentry *)zalloc(rte_zone)); } -void +static void rte_free(struct rtentry *p) { if (rte_debug & RTD_DEBUG) { @@ -2133,11 +2635,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); @@ -2157,15 +2656,22 @@ rte_free_debug(struct rtentry *p) panic("rte_free: corrupted rte=%p\n", rte); 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); +}