Lines Matching refs:rt
404 * route; dst typically comes from rt_key(rt) but may be coming from
405 * a separate place when rt is in the process of being created.
408 rt_primary_default(struct rtentry *rt, struct sockaddr *dst)
410 return (SA_DEFAULT(dst) && !(rt->rt_flags & RTF_IFSCOPE));
715 struct rtentry *rt = (struct rtentry *)rn;
717 int af = rt_key(rt)->sa_family;
719 if (!(rt->rt_flags & RTF_IFSCOPE) || (af != AF_INET && af != AF_INET6))
723 (SINIFSCOPE(rt_key(rt))->sin_scope_id == ma->ifscope) :
724 (SIN6IFSCOPE(rt_key(rt))->sin6_scope_id == ma->ifscope));
804 struct rtentry *rt;
806 if ((rt = ro->ro_rt) != NULL) {
807 RT_LOCK_SPIN(rt);
808 if (rt->rt_ifp != NULL && (rt->rt_flags & RTF_UP) &&
809 rt->generation_id == route_generation) {
810 RT_UNLOCK(rt);
813 RT_UNLOCK(rt);
814 rtfree_locked(rt);
864 struct rtentry *rt, *newrt = NULL;
876 rt = rt_lookup(FALSE, dst, NULL, rnh, ifscope);
877 if (rt == NULL)
880 RT_LOCK_SPIN(rt);
881 newrt = rt;
882 nflags = rt->rt_flags & ~ignflags;
883 RT_UNLOCK(rt);
898 newrt = rt;
907 rtfree_locked(rt);
908 if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
968 rtfree_locked(struct rtentry *rt)
970 rtfree_common(rt, TRUE);
974 rtfree_common(struct rtentry *rt, boolean_t locked)
982 RT_LOCK_SPIN(rt);
983 if (rtunref(rt) > 0) {
984 RT_UNLOCK(rt);
1004 RT_ADDREF_LOCKED(rt);
1005 RT_UNLOCK(rt);
1007 RT_LOCK_SPIN(rt);
1008 RT_REMREF_LOCKED(rt);
1009 if (rt->rt_refcnt > 0) {
1011 RT_UNLOCK(rt);
1020 RT_CONVERT_LOCK(rt);
1025 if (rt->rt_refcnt != 0)
1026 panic("rt %p invalid refcnt %d", rt, rt->rt_refcnt);
1032 rnh = rt_tables[rt_key(rt)->sa_family];
1043 rnh->rnh_close((struct radix_node *)rt, rnh);
1049 if (!(rt->rt_flags & RTF_UP)) {
1053 if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
1054 panic("rt %p freed while in radix tree\n", rt);
1061 TAILQ_REMOVE(&rttrash_head, (struct rtentry_dbg *)rt,
1069 if ((rt_parent = rt->rt_parent) != NULL)
1070 rt->rt_parent = NULL;
1072 if ((rt_ifa = rt->rt_ifa) != NULL)
1073 rt->rt_ifa = NULL;
1078 if (rt->rt_llinfo != NULL) {
1079 if (rt->rt_llinfo_free != NULL)
1080 (*rt->rt_llinfo_free)(rt->rt_llinfo);
1082 R_Free(rt->rt_llinfo);
1083 rt->rt_llinfo = NULL;
1090 RT_UNLOCK(rt);
1103 R_Free(rt_key(rt));
1108 nstat_route_detach(rt);
1113 rte_lock_destroy(rt);
1114 rte_free(rt);
1121 RT_UNLOCK(rt);
1129 rtfree(struct rtentry *rt)
1131 rtfree_common(rt, FALSE);
1198 rtsetifa(struct rtentry *rt, struct ifaddr* ifa)
1202 RT_LOCK_ASSERT_HELD(rt);
1204 if (rt->rt_ifa == ifa)
1208 RT_CONVERT_LOCK(rt);
1211 if (rt->rt_ifa)
1212 IFA_REMREF(rt->rt_ifa);
1215 rt->rt_ifa = ifa;
1218 if (rt->rt_ifa)
1219 IFA_ADDREF(rt->rt_ifa);
1233 struct rtentry *rt = NULL;
1267 rt = rtalloc1_scoped_locked(dst, 0, RTF_CLONING|RTF_PRCLONING, ifscope);
1268 if (rt != NULL)
1269 RT_LOCK(rt);
1279 if (!(flags & RTF_DONE) && rt != NULL &&
1280 (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr,
1298 if (rt != NULL)
1299 RT_UNLOCK(rt);
1309 if ((rt == NULL) || (rt_mask(rt) != NULL && rt_mask(rt)->sa_len < 2))
1315 RT_LOCK_ASSERT_HELD(rt);
1316 if (rt->rt_flags & RTF_GATEWAY) {
1317 if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
1325 if (rt != NULL)
1326 RT_UNLOCK(rt);
1336 rt->rt_flags |= RTF_MODIFIED;
1342 error = rt_setgate(rt, rt_key(rt), gateway);
1343 RT_UNLOCK(rt);
1346 RT_UNLOCK(rt);
1350 if (rt != NULL) {
1351 RT_LOCK_ASSERT_NOTHELD(rt);
1353 *rtp = rt;
1355 rtfree_locked(rt);
1431 struct rtentry *rt = NULL;
1484 rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)dst,
1486 if (rt != NULL) {
1487 RT_LOCK_SPIN(rt);
1488 ifa = rt->rt_ifa;
1491 RT_CONVERT_LOCK(rt);
1494 RT_REMREF_LOCKED(rt);
1495 RT_UNLOCK(rt);
1496 rt = NULL;
1523 (rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)gw,
1527 RT_LOCK_SPIN(rt);
1528 ifa = rt->rt_ifa;
1531 RT_CONVERT_LOCK(rt);
1534 RT_REMREF_LOCKED(rt);
1535 RT_UNLOCK(rt);
1590 * RTF_IFSCOPE flag, callers can simply use its rt_key(rt) to clone it
1602 struct rtentry *rt;
1683 rt = (struct rtentry *)rn;
1694 RT_LOCK(rt);
1695 RT_ADDREF_LOCKED(rt);
1696 rt->rt_flags &= ~RTF_UP;
1701 rt->rt_flags |= RTF_CONDEMNED;
1706 if (rt->rt_flags & RTF_ROUTER) {
1707 VERIFY(rt->rt_flags & RTF_HOST);
1708 rt->rt_flags &= ~RTF_ROUTER;
1715 if ((rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) &&
1716 rt_mask(rt)) {
1717 RT_UNLOCK(rt);
1718 rnh->rnh_walktree_from(rnh, dst, rt_mask(rt),
1719 rt_fixdelete, rt);
1720 RT_LOCK(rt);
1726 if ((gwrt = rt->rt_gwroute) != NULL)
1727 rt->rt_gwroute = NULL;
1732 if ((ifa = rt->rt_ifa) != NULL) {
1737 ifa_rtrequest(RTM_DELETE, rt, NULL);
1749 (struct rtentry_dbg *)rt, rtd_trash_link);
1756 if (rt_primary_default(rt, rt_key(rt))) {
1757 set_primary_ifscope(rt_key(rt)->sa_family,
1760 rt_clear_idleref(rt);
1762 RT_UNLOCK(rt);
1768 * lock being acquired if gwrt is a clone of rt.
1780 *ret_nrt = rt;
1783 rtfree_locked(rt);
1788 if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
1800 ifa = rt->rt_ifa;
1802 flags = rt->rt_flags &
1805 gateway = rt->rt_gateway;
1806 if ((netmask = rt->rt_genmask) == NULL)
1828 (rt->rt_flags & RTF_PROXY)) {
1834 sin_get_ifscope(rt_key(rt)) :
1835 sin6_get_ifscope(rt_key(rt));
1837 ifscope = rt->rt_ifp->if_index;
1870 if ((rt = rte_alloc()) == NULL)
1872 Bzero(rt, sizeof(*rt));
1873 rte_lock_init(rt);
1874 rt->base_calendartime = curr_calendartime.tv_sec;
1875 rt->base_uptime = net_uptime();
1876 RT_LOCK(rt);
1877 rt->rt_flags = RTF_UP | flags;
1883 if ((error = rt_setgate(rt, dst, gateway)) != 0) {
1885 RT_UNLOCK(rt);
1886 nstat_route_detach(rt);
1887 rte_lock_destroy(rt);
1888 rte_free(rt);
1895 ndst = rt_key(rt);
1910 rtsetifa(rt, ifa);
1911 rt->rt_ifp = rt->rt_ifa->ifa_ifp;
1916 rnh, rt->rt_nodes);
1944 rnh, rt->rt_nodes);
1957 rt_set_gwroute(rt, rt_key(rt), NULL);
1958 if (rt->rt_ifa) {
1959 IFA_REMREF(rt->rt_ifa);
1960 rt->rt_ifa = NULL;
1962 R_Free(rt_key(rt));
1963 RT_UNLOCK(rt);
1964 nstat_route_detach(rt);
1965 rte_lock_destroy(rt);
1966 rte_free(rt);
1970 rt->rt_parent = NULL;
1987 rt->rt_rmx = (*ret_nrt)->rt_rmx;
1988 rt_setexpire(rt, (*ret_nrt)->rt_expire);
1990 rt->rt_parent = (*ret_nrt);
1999 if (rt->rt_parent != NULL &&
2000 !(rt->rt_flags & (RTF_BROADCAST | RTF_MULTICAST))) {
2001 rt_set_idleref(rt);
2013 ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : NULL));
2021 if (rt_primary_default(rt, rt_key(rt))) {
2022 set_primary_ifscope(rt_key(rt)->sa_family,
2023 rt->rt_ifp->if_index);
2031 *ret_nrt = rt;
2032 RT_ADDREF_LOCKED(rt);
2040 if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL)
2041 rt_set_gwroute(rt, rt_key(rt), rt->rt_gwroute);
2044 !(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) {
2047 arg.rt0 = rt;
2048 RT_UNLOCK(rt);
2049 rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
2052 RT_UNLOCK(rt);
2055 nstat_route_new_entry(rt);
2101 struct rtentry *rt = (struct rtentry *)rn;
2106 RT_LOCK(rt);
2107 if (rt->rt_parent == rt0 &&
2108 !(rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
2114 RT_UNLOCK(rt);
2115 return (rtrequest_locked(RTM_DELETE, rt_key(rt), NULL,
2116 rt_mask(rt), rt->rt_flags, NULL));
2118 RT_UNLOCK(rt);
2127 * of rt->rt_parent is insufficient; each candidate route must be tested
2138 struct rtentry *rt = (struct rtentry *)rn;
2147 RT_LOCK(rt);
2149 if (!rt->rt_parent ||
2150 (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
2151 RT_UNLOCK(rt);
2155 if (rt->rt_parent == rt0)
2162 len = imin(rt_key(rt0)->sa_len, rt_key(rt)->sa_len);
2166 xk2 = (u_char *)rt_key(rt);
2170 * route (rt->rt_parent) is a network route, since otherwise its mask
2173 if ((xmp = (u_char *)rt_mask(rt->rt_parent)) != NULL) {
2174 int mlen = rt_mask(rt->rt_parent)->sa_len;
2176 RT_UNLOCK(rt);
2182 RT_UNLOCK(rt);
2190 RT_UNLOCK(rt);
2204 RT_UNLOCK(rt);
2205 return (rtrequest_locked(RTM_DELETE, rt_key(rt), NULL,
2206 rt_mask(rt), rt->rt_flags, NULL));
2228 rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate)
2235 RT_LOCK_ASSERT_HELD(rt);
2241 if (rt->rt_flags & RTF_CONDEMNED)
2245 RT_ADDREF_LOCKED(rt);
2247 if (rt->rt_flags & RTF_GATEWAY) {
2266 if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
2269 RT_REMREF_LOCKED(rt);
2278 if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
2284 if (rt_key(rt) != NULL) {
2290 RT_UNLOCK(rt);
2291 (void) rtrequest_locked(RTM_DELETE, rt_key(rt),
2292 rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL);
2293 RT_LOCK(rt);
2296 RT_REMREF_LOCKED(rt);
2304 if (rt->rt_flags & RTF_GATEWAY) {
2315 RT_UNLOCK(rt);
2324 RT_LOCK(rt);
2336 * when we get rt->rt_output(). It implies that a route to
2340 if (gwrt == rt) {
2343 RT_REMREF_LOCKED(rt);
2352 if (ifscope != IFSCOPE_NONE && (rt->rt_flags & RTF_IFSCOPE) &&
2355 rtfree_locked(gwrt); /* rt != gwrt, no deadlock */
2357 RT_REMREF_LOCKED(rt);
2358 return ((rt->rt_flags & RTF_HOST) ?
2363 if (rt->rt_flags & RTF_CONDEMNED) {
2367 RT_REMREF_LOCKED(rt);
2372 rt_set_gwroute(rt, dst, gwrt);
2380 if (rt_primary_default(rt, dst) && rt->rt_ifp != NULL) {
2382 rt->rt_ifp->if_index);
2413 if (rt->rt_gateway == NULL || glen > SA_SIZE(rt->rt_gateway->sa_len)) {
2420 rt_set_gwroute(rt, dst, NULL);
2422 RT_REMREF_LOCKED(rt);
2427 * Copy from 'dst' and not rt_key(rt) because we can get
2429 * which case rt_key(rt) is NULL (and so does rt_gateway).
2433 R_Free(rt_key(rt)); /* free old block; NULL is okay */
2434 rt->rt_nodes->rn_key = new;
2435 rt->rt_gateway = (struct sockaddr *)(new + dlen);
2441 Bcopy(gate, rt->rt_gateway, gate->sa_len);
2446 if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL &&
2447 (rt->rt_gwroute->rt_flags & RTF_IFSCOPE)) {
2448 if (rt->rt_gateway->sa_family == AF_INET &&
2449 rt_key(rt->rt_gwroute)->sa_family == AF_INET) {
2450 sin_set_ifscope(rt->rt_gateway,
2451 sin_get_ifscope(rt_key(rt->rt_gwroute)));
2452 } else if (rt->rt_gateway->sa_family == AF_INET6 &&
2453 rt_key(rt->rt_gwroute)->sa_family == AF_INET6) {
2454 sin6_set_ifscope(rt->rt_gateway,
2455 sin6_get_ifscope(rt_key(rt->rt_gwroute)));
2464 if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
2467 arg.rt0 = rt;
2468 RT_UNLOCK(rt);
2469 rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
2471 RT_LOCK(rt);
2475 RT_REMREF_LOCKED(rt);
2482 rt_set_gwroute(struct rtentry *rt, struct sockaddr *dst, struct rtentry *gwrt)
2487 RT_LOCK_ASSERT_HELD(rt);
2497 if (rt->rt_gwroute != NULL) {
2498 struct rtentry *ogwrt = rt->rt_gwroute;
2500 VERIFY(rt != ogwrt); /* sanity check */
2501 rt->rt_gwroute = NULL;
2502 RT_UNLOCK(rt);
2504 RT_LOCK(rt);
2505 VERIFY(rt->rt_gwroute == NULL);
2511 if ((rt->rt_gwroute = gwrt) != NULL) {
2512 RT_ADDREF(gwrt); /* for rt */
2514 if (rt->rt_flags & RTF_WASCLONED) {
2515 /* rt_parent might be NULL if rt is embryonic */
2516 gwrt_isrouter = (rt->rt_parent != NULL &&
2517 SA_DEFAULT(rt_key(rt->rt_parent)) &&
2518 !RT_HOST(rt->rt_parent));
2520 gwrt_isrouter = (SA_DEFAULT(dst) && !RT_HOST(rt));
2719 struct rtentry *rt = RT(rn);
2720 if (rt->rt_ifp != lo_ifp) {
2721 if (rt->rt_ifp->if_index != ifscope) {
2731 ifscope = rt->rt_ifp->if_index;
2734 } else if (!(rt->rt_flags & RTF_IFSCOPE)) {
2801 rt_validate(struct rtentry *rt)
2803 RT_LOCK_ASSERT_HELD(rt);
2805 if ((rt->rt_flags & (RTF_UP | RTF_CONDEMNED)) == RTF_UP) {
2806 int af = rt_key(rt)->sa_family;
2809 (void) in_validate(RN(rt));
2811 (void) in6_validate(RN(rt));
2813 rt = NULL;
2816 return (rt != NULL);
2837 struct rtentry *rt;
2877 rt = rtalloc1_locked(dst, 0, 0);
2878 if (rt) {
2884 RT_LOCK_SPIN(rt);
2885 if (rt->rt_ifa != ifa) {
2886 RT_REMREF_LOCKED(rt);
2887 RT_UNLOCK(rt);
2900 RT_REMREF_LOCKED(rt);
2901 RT_UNLOCK(rt);
2932 if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) {
2936 RT_LOCK(rt);
2940 RT_UNLOCK(rt);
2941 rtfree_locked(rt);
2948 if (cmd == RTM_ADD && error == 0 && (rt = nrt)) {
2949 RT_LOCK(rt);
2954 if (rt->rt_ifa != ifa) {
2958 if (!(rt->rt_ifa->ifa_ifp->if_flags &
2961 ifa, rt->rt_ifa);
2967 IFA_LOCK_SPIN(rt->rt_ifa);
2968 ifa_rtrequest = rt->rt_ifa->ifa_rtrequest;
2969 IFA_UNLOCK(rt->rt_ifa);
2971 ifa_rtrequest(RTM_DELETE, rt, SA(0));
2975 rtsetifa(rt, ifa);
2977 if (rt->rt_ifp != ifa->ifa_ifp) {
2981 if (rt->rt_llinfo_purge != NULL)
2982 rt->rt_llinfo_purge(rt);
2986 if (rt->rt_if_ref_fn != NULL) {
2987 rt->rt_if_ref_fn(ifa->ifa_ifp, 1);
2988 rt->rt_if_ref_fn(rt->rt_ifp, -1);
2996 rt->rt_ifp = ifa->ifa_ifp;
2997 rt->rt_rmx.rmx_mtu = ifa->ifa_ifp->if_mtu; /*XXX*/
3006 ifa_rtrequest(RTM_ADD, rt, SA(0));
3021 RT_REMREF_LOCKED(rt);
3022 RT_UNLOCK(rt);
3028 rt_expiry(struct rtentry *rt, u_int64_t base, u_int32_t delta)
3038 if (rt->rt_ifp == NULL || rt->rt_ifp->if_want_aggressive_drain == 0)
3047 rt_set_idleref(struct rtentry *rt)
3049 RT_LOCK_ASSERT_HELD(rt);
3051 rt_clear_idleref(rt);
3052 rt->rt_if_ref_fn = rte_if_ref;
3053 rt->rt_if_ref_fn(rt->rt_ifp, 1);
3054 rt->rt_flags |= RTF_IFREF;
3058 rt_clear_idleref(struct rtentry *rt)
3060 RT_LOCK_ASSERT_HELD(rt);
3062 if (rt->rt_if_ref_fn != NULL) {
3063 rt->rt_if_ref_fn(rt->rt_ifp, -1);
3064 rt->rt_flags &= ~RTF_IFREF;
3065 rt->rt_if_ref_fn = NULL;
3070 rt_set_proxy(struct rtentry *rt, boolean_t set)
3073 RT_LOCK(rt);
3078 if (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) {
3079 struct radix_node_head *rnh = rt_tables[rt_key(rt)->sa_family];
3082 rt->rt_flags |= RTF_PROXY;
3084 rt->rt_flags &= ~RTF_PROXY;
3086 RT_UNLOCK(rt);
3087 if (rnh != NULL && rt_mask(rt)) {
3088 rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
3089 rt_fixdelete, rt);
3092 RT_UNLOCK(rt);
3098 rte_lock_init(struct rtentry *rt)
3100 lck_mtx_init(&rt->rt_lock, rte_mtx_grp, rte_mtx_attr);
3104 rte_lock_destroy(struct rtentry *rt)
3106 RT_LOCK_ASSERT_NOTHELD(rt);
3107 lck_mtx_destroy(&rt->rt_lock, rte_mtx_grp);
3111 rt_lock(struct rtentry *rt, boolean_t spin)
3113 RT_LOCK_ASSERT_NOTHELD(rt);
3115 lck_mtx_lock_spin(&rt->rt_lock);
3117 lck_mtx_lock(&rt->rt_lock);
3119 rte_lock_debug((struct rtentry_dbg *)rt);
3123 rt_unlock(struct rtentry *rt)
3125 RT_LOCK_ASSERT_HELD(rt);
3127 rte_unlock_debug((struct rtentry_dbg *)rt);
3128 lck_mtx_unlock(&rt->rt_lock);
3276 /* Copy everything (rt, dst, flags) from ifnet */
3293 * Copy everything (rt, dst, flags) from ip_forward();
3334 struct rtentry *rt = hint0, *hint = hint0;
3341 if (rt == NULL)
3356 RT_LOCK_SPIN(rt);
3357 ifindex = rt->rt_ifp->if_index;
3358 RT_ADDREF_LOCKED(rt);
3359 if (!(rt->rt_flags & RTF_UP)) {
3360 RT_REMREF_LOCKED(rt);
3361 RT_UNLOCK(rt);
3363 hint = rt = rtalloc1_scoped((struct sockaddr *)
3366 RT_LOCK_SPIN(rt);
3367 ifindex = rt->rt_ifp->if_index;
3374 * We have a reference to "rt" by now; it will either
3377 RT_LOCK_ASSERT_HELD(rt);
3378 if ((gwroute = (rt->rt_flags & RTF_GATEWAY))) {
3379 struct rtentry *gwrt = rt->rt_gwroute;
3383 VERIFY(rt == hint);
3386 /* If there's no gateway rt, look it up */
3388 bcopy(rt->rt_gateway, gw, MIN(sizeof (ss),
3389 rt->rt_gateway->sa_len));
3390 RT_UNLOCK(rt);
3394 RT_CONVERT_LOCK(rt);
3399 * to "rt", so no lock ordering issues.
3403 rt->rt_gwroute = NULL;
3405 bcopy(rt->rt_gateway, gw, MIN(sizeof (ss),
3406 rt->rt_gateway->sa_len));
3407 RT_UNLOCK(rt);
3413 RT_LOCK(rt);
3417 * gateway portion of "rt" has changed.
3419 if (!(rt->rt_flags & RTF_UP) || gwrt == NULL ||
3420 gwrt == rt || !equal(gw, rt->rt_gateway)) {
3421 if (gwrt == rt) {
3425 VERIFY(rt == hint);
3428 RT_UNLOCK(rt);
3440 rt_set_gwroute(rt, rt_key(rt), gwrt);
3441 VERIFY(rt == hint);
3442 RT_REMREF_LOCKED(rt); /* hint still holds a refcnt */
3443 RT_UNLOCK(rt);
3445 rt = gwrt;
3449 VERIFY(rt == hint);
3450 RT_REMREF_LOCKED(rt); /* hint still holds a refcnt */
3451 RT_UNLOCK(rt);
3452 rt = gwrt;
3454 VERIFY(rt == gwrt && rt != hint);
3460 * a reference to it. rt == gwrt.
3471 rt_revalidate_gwroute(prt, rt);
3484 /* rt == gwrt; if it is now down, give up */
3485 RT_LOCK_SPIN(rt);
3486 if (!(rt->rt_flags & RTF_UP)) {
3487 RT_UNLOCK(rt);
3492 if (rt->rt_flags & RTF_REJECT) {
3493 VERIFY(rt->rt_expire == 0 || rt->rt_rmx.rmx_expire != 0);
3494 VERIFY(rt->rt_expire != 0 || rt->rt_rmx.rmx_expire == 0);
3496 if (rt->rt_expire == 0 || timenow < rt->rt_expire) {
3497 RT_UNLOCK(rt);
3503 RT_CONVERT_LOCK(rt);
3505 /* Caller is responsible for cleaning up "rt" */
3506 *out_route = rt;
3510 /* Clean up route (either it is "rt" or "gwrt") */
3511 if (rt != NULL) {
3512 RT_LOCK_SPIN(rt);
3513 if (rt == hint0) {
3514 RT_REMREF_LOCKED(rt);
3515 RT_UNLOCK(rt);
3517 RT_UNLOCK(rt);
3518 rtfree(rt);
3526 rt_revalidate_gwroute(struct rtentry *rt, struct rtentry *gwrt)
3528 VERIFY(rt->rt_flags & (RTF_CLONING | RTF_PRCLONING));
3531 RT_LOCK_SPIN(rt);
3532 if ((rt->rt_flags & (RTF_GATEWAY | RTF_UP)) == (RTF_GATEWAY | RTF_UP) &&
3533 rt->rt_ifp == gwrt->rt_ifp && rt->rt_gateway->sa_family ==
3534 rt_key(gwrt)->sa_family && (rt->rt_gwroute == NULL ||
3535 !(rt->rt_gwroute->rt_flags & RTF_UP))) {
3538 if (rt->rt_gateway->sa_family == AF_INET ||
3539 rt->rt_gateway->sa_family == AF_INET6) {
3546 (void) sa_copy(rt->rt_gateway, &gw_ss, NULL);
3550 isequal = equal(rt_key(gwrt), rt->rt_gateway);
3555 RT_UNLOCK(rt);
3557 RT_LOCK(rt);
3558 rt_set_gwroute(rt, rt_key(rt), gwrt);
3559 RT_UNLOCK(rt);
3562 RT_UNLOCK(rt);
3565 RT_UNLOCK(rt);