Lines Matching refs:ill
229 pfv_t func, void *arg, uchar_t vers, ill_t *ill);
497 ushort_t type, ill_t *ill, zoneid_t zoneid, uint_t flags,
544 error = ire_init_common(ire, type, ill, zoneid, flags, IPV4_VERSION,
627 ushort_t type, ill_t *ill, zoneid_t zoneid, uint_t flags, tsol_gc_t *gc,
640 error = ire_init_v4(ire, addr, mask, gateway, type, ill, zoneid, flags,
655 ire_init_common(ire_t *ire, ushort_t type, ill_t *ill, zoneid_t zoneid,
661 if (ill != NULL) {
662 if (ill->ill_isv6)
697 * all IREs that hold a reference on an ill.
699 * Note that ill_ire_multicast doesn't hold a ref on the ill since
702 ire->ire_ill = ill;
724 ire_create_bcast(ill_t *ill, ipaddr_t addr, zoneid_t zoneid, ire_t **irep)
726 ip_stack_t *ipst = ill->ill_ipst;
728 ASSERT(IAM_WRITER_ILL(ill));
735 ill,
749 ire_lookup_bcast(ill_t *ill, ipaddr_t addr, zoneid_t zoneid)
757 if (IS_UNDER_IPMP(ill))
765 ill,
770 ill->ill_ipst,
819 * Arrange to call the specified function for every IRE that matches the ill.
823 ill_t *ill)
825 uchar_t vers = (ill->ill_isv6 ? IPV6_VERSION : IPV4_VERSION);
827 ire_walk_ill_ipvers(match_flags, ire_type, func, arg, vers, ill);
831 * Walk a particular ill and version.
835 void *arg, uchar_t vers, ill_t *ill)
837 ip_stack_t *ipst = ill->ill_ipst;
843 ill, ALL_ZONES, ipst);
849 ill, ALL_ZONES, ipst);
861 ill_t *ill, zoneid_t zoneid, ip_stack_t *ipst)
970 (dst_ill == ill ||
971 dst_ill != NULL && IS_IN_SAME_ILLGRP(dst_ill, ill)))) {
1005 * Walk the ftable entries that match the ill.
1010 ill_t *ill, zoneid_t zoneid,
1020 ASSERT((!(match_flags & MATCH_IRE_ILL)) || (ill != NULL));
1043 ire_type, ire, ill,
1060 rtfarg.rt_ill = ill;
1096 ill_t *ill;
1098 ill = ire->ire_ill;
1099 if (ill != NULL)
1100 mutex_exit(&ill->ill_lock);
1105 * ire_add_v[46] atomically make sure that the ill associated
1111 ill_t *ill;
1113 ill = ire->ire_ill;
1116 if (ill != NULL) {
1117 mutex_enter(&ill->ill_lock);
1121 * ill's for which the last ipif is going down, or ones which
1124 if ((ill->ill_state_flags &
1131 if (IS_UNDER_IPMP(ill)) {
1133 mutex_enter(&ill->ill_phyint->phyint_lock);
1134 if (!ipmp_ill_is_active(ill) &&
1139 mutex_exit(&ill->ill_phyint->phyint_lock);
1218 * Start the atomic add of the ire. Grab the ill lock,
1644 ill_t *ill;
1686 ill = ire->ire_ill;
1687 if (irb != NULL && ill != NULL) {
1688 mutex_enter(&ill->ill_lock);
1689 ASSERT(ill->ill_ire_cnt != 0);
1690 DTRACE_PROBE3(ill__decr__cnt, (ill_t *), ill,
1692 ill->ill_ire_cnt--;
1693 if (ILL_DOWN_OK(ill)) {
1694 /* Drops the ill lock */
1695 ipif_ill_refrele_tail(ill);
1697 mutex_exit(&ill->ill_lock);
1856 * Note: for match types that match using "ill" passed in, ill
1861 int type, const ill_t *ill, zoneid_t zoneid,
1870 (ill != NULL && !ill->ill_isv6));
1901 * on the usesrc ill.
1904 * on that ill.
1923 * if the ill has a usesrc pointing at vniN
1982 * If asked to match an ill, we *must* match
1984 * any of the ill in the group for data addresses.
1992 if (ire->ire_ill != ill)
1997 * We know that ill is not NULL, but ire_ill could be
2000 if (ire_ill == NULL || !IS_ON_SAME_LAN(ill, ire_ill))
2007 if (!IS_ON_SAME_LAN(ill, ire_ill)) {
2010 ill->ill_phyint->phyint_ifindex))
2033 * Check if the IRE_LOCAL uses the same ill as another route would use.
2040 const ill_t *ill, uint_t *generationp)
2060 if (ill != NULL)
2065 ill, zoneid, tsl, match_flags, IRR_ALLOCATE, 0, ipst, NULL,
2069 ill, zoneid, tsl, match_flags, IRR_ALLOCATE, 0, ipst, NULL,
2078 /* Different ill - ignore IRE_LOCAL */
2130 * gateway address. If ill is non-NULL we also match on it.
2134 ire_gateway_ok_zone_v4(ipaddr_t gateway, zoneid_t zoneid, ill_t *ill,
2141 ASSERT(ill == NULL || !ill->ill_isv6);
2153 * We only use margs for ill, zoneid, and tsl matching in
2157 margs.ift_ill = ill;
2380 * Delete all IREs - assumes that the ill/ipifs have
2447 * in the non-IPMP case, or on the cast-ill in the IPMP bcast/mcast case, or
2448 * on the next available under-ill (selected by the IPMP rotor) in the
2474 * The nce returned will be created such that the nce_ill == ill that
2475 * is passed in. Note that the nce itself may not have ncec_ill == ill
2479 ire_nce_init(ill_t *ill, const void *addr, int ire_type)
2486 ill_t *in_ill = ill;
2491 if (IS_IPMP(ill) ||
2492 ((ire_type & IRE_BROADCAST) && IS_UNDER_IPMP(ill))) {
2493 if ((ill = ipmp_ill_hold_xmit_ill(ill, is_unicast)) == NULL)
2497 ncec_flags = (ill->ill_flags & ILLF_NONUD) ? NCE_F_NONUD : 0;
2501 ASSERT(!ill->ill_isv6);
2509 if (ill->ill_net_type == IRE_IF_NORESOLVER && is_unicast) {
2510 hwaddr = ill->ill_dest_addr;
2514 hwaddr_len = ill->ill_phys_addr_length;
2518 if (!ill->ill_isv6) {
2519 err = nce_lookup_then_add_v4(ill, hwaddr, hwaddr_len, addr,
2522 err = nce_lookup_then_add_v6(ill, hwaddr, hwaddr_len, addr,
2536 ASSERT(!ill->ill_isv6);
2543 DTRACE_PROBE2(nce__init__fail, ill_t *, ill, int, err);
2545 ill_refrele(ill);
2549 * If the ill was an under-ill of an IPMP group, we need to verify
2552 * IS_UNDER_IPMP(), we first need to verify that the ill is an
2553 * under-ill, and since this is being done in the data path, the
2556 rw_enter(&ill->ill_ipst->ips_ill_g_lock, RW_READER);
2557 mutex_enter(&ill->ill_lock);
2558 mutex_enter(&ill->ill_phyint->phyint_lock);
2559 if (need_refrele && IS_UNDER_IPMP(ill) && !ipmp_ill_is_active(ill)) {
2561 * need_refrele implies that the under ill was selected by
2564 * under_ill. However, when we get here, the ill selected by
2567 * it was picked as the outgoing ill. We have to pick an
2570 mutex_exit(&ill->ill_phyint->phyint_lock);
2572 mutex_exit(&ill->ill_lock);
2573 rw_exit(&ill->ill_ipst->ips_ill_g_lock);
2575 ill_refrele(ill);
2576 if ((ill = ipmp_ill_hold_xmit_ill(in_ill, is_unicast)) == NULL)
2580 mutex_exit(&ill->ill_phyint->phyint_lock);
2581 mutex_exit(&ill->ill_lock);
2582 rw_exit(&ill->ill_ipst->ips_ill_g_lock);
2585 ASSERT(nce->nce_ill == ill);
2587 ill_refrele(ill);
2592 arp_nce_init(ill_t *ill, in_addr_t addr4, int ire_type)
2594 return (ire_nce_init(ill, &addr4, ire_type));
2598 ndp_nce_init(ill_t *ill, const in6_addr_t *addr6, int ire_type)
2601 return (ire_nce_init(ill, addr6, ire_type));
2658 * ill unplumb.
2663 ill_t *ill;
2668 ill = ILL_START_WALK_V6(&ctx, ipst);
2670 ill = ILL_START_WALK_V4(&ctx, ipst);
2671 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
2672 if (ILL_IS_CONDEMNED(ill))
2674 if (ill->ill_ire_multicast != NULL)
2675 ire_increment_generation(ill->ill_ire_multicast);
2720 ire_multicast(ill_t *ill)
2722 ire_t *ire = ill->ill_ire_multicast;
2726 ire = ire_blackhole(ill->ill_ipst, ill->ill_isv6);
2762 * it needs an IRE_IF_ALL to get to the ill. Thus
2779 * Find the ill used to send packets. This will be NULL in case
2781 * The returned ill is held; caller needs to do ill_refrele when done.
2786 ill_t *ill;
2793 ill = ire->ire_ill;
2794 if (ill != NULL)
2795 ill_refhold(ill);
2797 return (ill);
3309 * set; so we should create the ncec for the underlying ill.
3318 * but would eventually recover. In the latter case (ill down/replumb),