Lines Matching defs:ire
61 #define IS_DEFAULT_ROUTE_V6(ire) \
62 (((ire)->ire_type & IRE_DEFAULT) || \
63 (((ire)->ire_type & IRE_INTERFACE) && \
64 (IN6_IS_ADDR_UNSPECIFIED(&(ire)->ire_addr_v6))))
75 * Initialize the ire that is specific to IPv6 part and call
80 ire_init_v6(ire_t *ire, const in6_addr_t *v6addr, const in6_addr_t *v6mask,
95 ire->ire_addr_v6 = *v6addr;
97 ire->ire_gateway_addr_v6 = *v6gateway;
105 ire->ire_mask_v6 = ipv6_all_ones;
106 ire->ire_masklen = IPV6_ABITS;
113 ire->ire_mask_v6 = *v6mask;
114 ire->ire_masklen =
115 ip_mask_to_plen_v6(&ire->ire_mask_v6);
127 error = ire_init_common(ire, type, ill, zoneid, flags, IPV6_VERSION,
133 ire->ire_postfragfn = ip_xmit; /* Common case */
135 switch (ire->ire_type) {
137 ire->ire_sendfn = ire_send_local_v6;
138 ire->ire_recvfn = ire_recv_local_v6;
139 ASSERT(ire->ire_ill != NULL);
140 if (ire->ire_ill->ill_flags & ILLF_NOACCEPT)
141 ire->ire_recvfn = ire_recv_noaccept_v6;
144 ire->ire_sendfn = ire_send_local_v6;
145 ire->ire_recvfn = ire_recv_loopback_v6;
148 ire->ire_postfragfn = ip_postfrag_loopcheck;
149 ire->ire_sendfn = ire_send_multicast_v6;
150 ire->ire_recvfn = ire_recv_multicast_v6;
157 ire->ire_sendfn = ire_send_wire_v6;
158 ire->ire_recvfn = ire_recv_forward_v6;
161 if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
162 ire->ire_sendfn = ire_send_noroute_v6;
163 ire->ire_recvfn = ire_recv_noroute_v6;
164 } else if (ire->ire_flags & RTF_MULTIRT) {
165 ire->ire_postfragfn = ip_postfrag_multirt_v6;
166 ire->ire_sendfn = ire_send_multirt_v6;
167 ire->ire_recvfn = ire_recv_multirt_v6;
169 ire->ire_nce_capable = ire_determine_nce_capable(ire);
185 ire_t *ire;
190 ire = kmem_cache_alloc(ire_cache, KM_NOSLEEP);
191 if (ire == NULL) {
195 *ire = ire_null;
197 error = ire_init_v6(ire, v6addr, v6mask, v6gateway,
201 DTRACE_PROBE2(ire__init__v6, ire_t *, ire, int, error);
202 kmem_cache_free(ire_cache, ire);
205 return (ire);
230 ire_t *ire;
233 ire = ire_route_recursive_v6(group, 0, NULL, zoneid, NULL,
235 ASSERT(ire != NULL);
237 if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
238 ire_refrele(ire);
243 *multirtp = (ire->ire_flags & RTF_MULTIRT) != 0;
245 ill = ire_nexthop_ill(ire);
246 ire_refrele(ire);
308 ire_add_v6(ire_t *ire)
316 ip_stack_t *ipst = ire->ire_ipst;
318 ASSERT(ire->ire_ipversion == IPV6_VERSION);
321 V6_MASK_COPY(ire->ire_addr_v6, ire->ire_mask_v6, ire->ire_addr_v6);
323 mask_table_index = ip_mask_to_plen_v6(&ire->ire_mask_v6);
331 ire_delete(ire);
358 IRE_ADDR_MASK_HASH_V6(ire->ire_addr_v6, ire->ire_mask_v6,
362 if (ire->ire_ill != NULL)
365 * Start the atomic add of the ire. Grab the bucket lock and the
368 error = ire_atomic_start(irb_ptr, ire);
370 ire_delete(ire);
380 if (ire->ire_testhidden)
393 if (ire1->ire_zoneid != ire->ire_zoneid)
396 if (ire1->ire_type != ire->ire_type)
406 if (ire_match_args_v6(ire1, &ire->ire_addr_v6,
407 &ire->ire_mask_v6, &ire->ire_gateway_addr_v6,
408 ire->ire_type, ire->ire_ill, ire->ire_zoneid, NULL,
411 * Return the old ire after doing a REFHOLD.
413 * after adding, we return a held ire. This will
418 * so, if the is an IF_CLONE, return the ire without
421 if (ire->ire_type != IRE_IF_CLONE) {
424 ire_t *, ire);
426 ip1dbg(("found dup ire existing %p new %p",
427 (void *)ire1, (void *)ire));
429 ire_atomic_end(irb_ptr, ire);
430 ire_delete(ire);
443 if (ire->ire_type & IRE_IF_CLONE) {
450 ire1->ire_ptpn = &ire->ire_next;
451 ire->ire_next = ire1;
453 ire->ire_ptpn = irep;
456 * a lock. Before we point to the new ire, we want to make
457 * sure the store that sets the ire_next of the new ire
460 * of the new ire gets set after we do "*irep = ire" due
462 * once it accesses the ire_next of the new ire.
467 *irep = ire;
468 ire->ire_bucket = irb_ptr;
480 ire_refhold_locked(ire);
484 if (ire->ire_ill != NULL) {
485 DTRACE_PROBE3(ill__incr__cnt, (ill_t *), ire->ire_ill,
486 (char *), "ire", (void *), ire);
487 ire->ire_ill->ill_ire_cnt++;
488 ASSERT(ire->ire_ill->ill_ire_cnt != 0); /* Wraparound */
490 ire_atomic_end(irb_ptr, ire);
493 ire_flush_cache_v6(ire, IRE_FLUSH_ADD);
495 return (ire);
509 ire_t *ire;
520 for (ire = irb->irb_ire; ire != NULL; ire = ire->ire_next) {
521 if (!(ire->ire_flags & RTF_DYNAMIC))
523 mutex_enter(&ire->ire_lock);
524 gw_addr_v6 = ire->ire_gateway_addr_v6;
525 mutex_exit(&ire->ire_lock);
527 ire_delete(ire);
538 * NOTE : This function is called only if the ire was added
542 ire_delete_v6(ire_t *ire)
545 ip_stack_t *ipst = ire->ire_ipst;
556 ASSERT(ire->ire_refcnt >= 1);
557 ASSERT(ire->ire_ipversion == IPV6_VERSION);
559 ire_flush_cache_v6(ire, IRE_FLUSH_DELETE);
561 if (ire->ire_type == IRE_DEFAULT) {
567 mutex_enter(&ire->ire_lock);
568 gw_addr_v6 = ire->ire_gateway_addr_v6;
569 mutex_exit(&ire->ire_lock);
578 if ((ire->ire_type & IRE_INTERFACE) && ire->ire_dep_children != 0)
579 ire_dep_delete_if_clone(ire);
583 if (ire->ire_dep_parent != NULL) {
584 ire_dep_remove(ire);
586 while (ire->ire_dep_children != NULL)
587 ire_dep_remove(ire->ire_dep_children);
600 ire_flush_cache_v6(ire_t *ire, int flag)
602 ip_stack_t *ipst = ire->ire_ipst;
605 * IRE_IF_CLONE ire's don't provide any new information
609 if (ire->ire_type & IRE_IF_CLONE)
615 * either the old ire and old generation number, or a new ire and new
631 if (ire->ire_type == IRE_DEFAULT && flag == IRE_FLUSH_ADD) {
643 ire_dep_incr_generation(ire);
648 ip_stack_t *ipst = ire->ire_ipst;
652 * Find an IRE which is a shorter match than the ire to be added
656 addr = ire->ire_addr_v6;
657 mask = ire->ire_mask_v6;
660 ire = ire_ftable_lookup_impl_v6(&addr, &mask, NULL, 0, NULL,
662 while (ire != NULL) {
664 irb_increment_generation(ire->ire_bucket);
666 mask = ire->ire_mask_v6;
669 ire_refrele(ire);
670 ire = ire_ftable_lookup_impl_v6(&addr, &mask, NULL, 0,
680 * Matches the arguments passed with the values in the ire.
686 ire_match_args_v6(ire_t *ire, const in6_addr_t *addr, const in6_addr_t *mask,
693 ip_stack_t *ipst = ire->ire_ipst;
695 ASSERT(ire->ire_ipversion == IPV6_VERSION);
706 if (ire->ire_testhidden) {
711 if (zoneid != ALL_ZONES && zoneid != ire->ire_zoneid &&
712 ire->ire_zoneid != ALL_ZONES) {
742 if (ire->ire_type & IRE_LOOPBACK)
745 if (ire->ire_type & IRE_LOCAL)
756 dst_ill = ire->ire_ill;
757 if (ire->ire_type & IRE_ONLINK) {
789 if (dst_ill != NULL && (ire->ire_type & IRE_OFFLINK)) {
808 ire_ill = ire->ire_ill;
810 mutex_enter(&ire->ire_lock);
811 gw_addr_v6 = ire->ire_gateway_addr_v6;
812 mutex_exit(&ire->ire_lock);
826 !(ire->ire_type & IRE_LOCAL)) {
827 if (ire->ire_ill != ill)
851 ASSERT(V6_MASK_EQ(ire->ire_addr_v6, ire->ire_mask_v6,
852 ire->ire_addr_v6));
854 if (V6_MASK_EQ(*addr, *mask, ire->ire_addr_v6) &&
857 !(ire->ire_flags & RTF_INDIRECT)) &&
859 ((!(match_flags & MATCH_IRE_TYPE)) || (ire->ire_type & type)) &&
860 ((!(match_flags & MATCH_IRE_TESTHIDDEN)) || ire->ire_testhidden) &&
862 (IN6_ARE_ADDR_EQUAL(&ire->ire_mask_v6, mask))) &&
865 (tsol_ire_match_gwattr(ire, tsl) == 0))) {
881 ire_t *ire;
893 ire = ire_ftable_lookup_impl_v6(gateway, &ipv6_all_zeros,
899 if (ire != NULL) {
900 ire_refrele(ire);
921 ire_t *ire = NULL;
938 ire = ire_ftable_lookup_impl_v6(addr, mask, gateway, type, ill, zoneid,
940 if (ire == NULL) {
956 if (ire->ire_bucket->irb_ire_cnt > 1 && !(flags & MATCH_IRE_GW)) {
959 IS_DEFAULT_ROUTE_V6(ire))) {
975 next_ire = ire_round_robin(ire->ire_bucket, &margs,
976 xmit_hint, ire, ipst);
978 /* keep ire if next_ire is null */
981 ire_refrele(ire);
982 ire = next_ire;
989 *generationp = ire->ire_generation;
1004 if ((ire->ire_type & IRE_LOCAL) && zoneid != ALL_ZONES &&
1005 ire->ire_zoneid != zoneid && ire->ire_zoneid != ALL_ZONES &&
1007 ire = ire_alt_local(ire, zoneid, tsl, ill, generationp);
1008 ASSERT(ire != NULL);
1011 return (ire);
1015 * Look up a single ire. The caller holds either the read or write lock.
1024 ire_t *ire = NULL;
1045 for (ire = irb_ptr->irb_ire; ire != NULL;
1046 ire = ire->ire_next) {
1047 if (IRE_IS_CONDEMNED(ire))
1049 if (ire_match_args_v6(ire, addr, mask, gateway, type,
1082 for (ire = irb_ptr->irb_ire; ire != NULL;
1083 ire = ire->ire_next) {
1084 if (IRE_IS_CONDEMNED(ire))
1086 if (ire_match_args_v6(ire, addr,
1087 &ire->ire_mask_v6, gateway, type, ill,
1094 ASSERT(ire == NULL);
1095 ip1dbg(("ire_ftable_lookup_v6: returning NULL ire"));
1099 ire_refhold(ire);
1101 return (ire);
1121 ire_t *ire;
1123 ire = ire_ftable_lookup_v6(addr, NULL, NULL, 0, NULL, ALL_ZONES, NULL,
1125 if (ire == NULL) {
1126 ire = ire_reject(ipst, B_TRUE);
1131 return (ire);
1164 ire_route_recursive_impl_v6(ire_t *ire,
1193 if (ire == NULL) {
1194 ire = ire_ftable_lookup_v6(&v6nexthop, 0, 0, ire_type,
1199 ire_refhold(ire);
1206 if (ire == NULL) {
1208 ire = ires[0];
1209 ire_refhold(ire);
1211 ire = ire_reject(ipst, B_TRUE);
1216 /* Need to return the ire with RTF_REJECT|BLACKHOLE */
1217 if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE))
1220 ASSERT(!(ire->ire_type & IRE_MULTICAST)); /* Not in ftable */
1225 if ((ire->ire_type & IRE_IF_CLONE) && !ire_clone_verify(ire)) {
1226 ire_refrele(ire);
1227 ire = NULL;
1240 if ((ire->ire_type & IRE_OFFLINK) &&
1241 !(ire->ire_flags & RTF_INDIRECT)) {
1250 ires[i] = ire;
1255 if ((ire->ire_flags & RTF_SETSRC) &&
1258 &ire->ire_setsrc_addr_v6));
1259 *setsrcp = ire->ire_setsrc_addr_v6;
1263 if (ire->ire_gw_secattr != NULL &&
1265 *gwattrp = ire->ire_gw_secattr;
1274 mutex_enter(&ire->ire_lock);
1275 if (ire->ire_dep_parent != NULL &&
1276 ire->ire_dep_parent->ire_generation ==
1277 ire->ire_dep_parent_generation) {
1278 mutex_exit(&ire->ire_lock);
1279 ire = NULL;
1282 mutex_exit(&ire->ire_lock);
1289 if (ire->ire_nce_capable) {
1290 ire = NULL;
1293 ASSERT(!(ire->ire_type & IRE_IF_CLONE));
1298 if (ire->ire_type & IRE_INTERFACE) {
1301 ASSERT(ire->ire_masklen != IPV6_ABITS);
1316 ire = NULL;
1320 clone = ire_create_if_clone(ire, &v6nexthop,
1328 ire = ire_blackhole(ipst, B_TRUE);
1346 ire = NULL;
1357 * ire->ire_ill, and we want to find the IRE_INTERFACE for
1361 v6nexthop = ire->ire_gateway_addr_v6;
1362 if (ill == NULL && ire->ire_ill != NULL) {
1363 ill = ire->ire_ill;
1368 ire = NULL;
1370 ASSERT(ire == NULL);
1371 ire = ire_reject(ipst, B_TRUE);
1374 ASSERT(ire != NULL);
1391 ASSERT((ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) ||
1399 return (ire);
1402 ASSERT(ire == NULL);
1409 ire = ire_blackhole(ipst, B_TRUE);
1479 ire_t *ire;
1484 ire = ire_ftable_lookup_simple_v6(nexthop, xmit_hint, ipst,
1486 ASSERT(ire != NULL);
1493 mutex_enter(&ire->ire_lock);
1494 if (ire->ire_dep_parent != NULL) {
1495 if (ire->ire_dep_parent->ire_generation ==
1496 ire->ire_dep_parent_generation) {
1497 mutex_exit(&ire->ire_lock);
1498 return (ire);
1500 mutex_exit(&ire->ire_lock);
1502 mutex_exit(&ire->ire_lock);
1508 if (ire->ire_nce_capable)
1509 return (ire);
1513 * Fallback to loop in the normal code starting with the ire
1514 * we found. Normally this would return the same ire.
1516 ire1 = ire_route_recursive_impl_v6(ire, nexthop, 0, NULL, ALL_ZONES,
1519 ire_refrele(ire);