Lines Matching refs:ill
147 static void ipsq_flush(ill_t *ill);
153 static ipif_t *ipif_allocate(ill_t *ill, int id, uint_t ire_type,
166 static int ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp,
177 static int ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q);
178 static void ill_dl_down(ill_t *ill);
179 static void ill_down(ill_t *ill);
181 static void ill_free_mib(ill_t *ill);
183 static void ill_phyint_reinit(ill_t *ill);
226 static void ill_dlpi_clear_deferred(ill_t *ill);
309 ill_allocate_mibs(ill_t *ill)
312 if (ill->ill_ip_mib != NULL) {
313 if (ill->ill_isv6)
314 ASSERT(ill->ill_icmp6_mib != NULL);
318 ill->ill_ip_mib = kmem_zalloc(sizeof (*ill->ill_ip_mib),
320 if (ill->ill_ip_mib == NULL) {
325 SET_MIB(ill->ill_ip_mib->ipIfStatsEntrySize,
327 if (ill->ill_isv6) {
328 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv6;
329 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
331 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
333 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
335 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
337 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
340 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv4;
341 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
343 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
345 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
347 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
349 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
353 * For a v4 ill, we are done at this point, because per ill
359 ill->ill_icmp6_mib = kmem_zalloc(sizeof (*ill->ill_icmp6_mib),
361 if (ill->ill_icmp6_mib == NULL) {
362 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
363 ill->ill_ip_mib = NULL;
367 ill->ill_icmp6_mib->ipv6IfIcmpEntrySize =
383 ill_delete(ill_t *ill)
387 ip_stack_t *ipst = ill->ill_ipst;
396 ipsq_flush(ill);
409 * ill.
411 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
416 * ill for the ill_phys_addr.
418 nce_flush(ill, B_TRUE);
421 reset_mrt_ill(ill);
423 update_conn_ill(ill, ipst);
429 ip_purge_allmulti(ill);
432 * If the ill being deleted is under IPMP, boot it out of the illgrp.
434 if (IS_UNDER_IPMP(ill))
435 ipmp_ill_leave_illgrp(ill);
441 ill_down(ill);
444 sctp_update_ill(ill, SCTP_ILL_REMOVE);
448 * ill (we actually walk all that now have stale references).
453 if (ill->ill_isv6)
454 dce_cleanup(ill->ill_phyint->phyint_ifindex, ipst);
461 if (ill->ill_usesrc_grp_next != NULL) {
462 if (ill->ill_usesrc_ifindex == 0) { /* usesrc ILL ? */
463 ill_disband_usesrc_group(ill);
465 prev_ill = ill_prev_usesrc(ill);
467 ill->ill_usesrc_grp_next;
476 ill_t *ill = ipif->ipif_ill;
477 mutex_enter(&ill->ill_lock);
480 ASSERT(ill->ill_ipif_dup_count > 0);
481 ill->ill_ipif_dup_count--;
483 mutex_exit(&ill->ill_lock);
488 * to the closing ill are gone. The wait is done in ip_modclose
491 ill_delete_tail(ill_t *ill)
495 ip_stack_t *ipst = ill->ill_ipst;
497 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
502 ASSERT(ill->ill_ipif_dup_count == 0);
506 * upcall into IP and driver has ill saved as a handle),
508 * let the ill disappear and driver no longer has any reference
509 * to this ill.
511 mutex_enter(&ill->ill_lock);
512 while (ill->ill_state_flags & ILL_DL_UNBIND_IN_PROGRESS)
513 cv_wait(&ill->ill_cv, &ill->ill_lock);
514 mutex_exit(&ill->ill_lock);
515 ASSERT(!(ill->ill_capabilities &
518 if (ill->ill_net_type != IRE_LOOPBACK)
519 qprocsoff(ill->ill_rq);
525 * the ill before we set the ILL_CONDEMNED flag, but not yet
528 ipsq_flush(ill);
533 if (ill->ill_hcksum_capab != NULL) {
534 kmem_free(ill->ill_hcksum_capab, sizeof (ill_hcksum_capab_t));
535 ill->ill_hcksum_capab = NULL;
538 if (ill->ill_zerocopy_capab != NULL) {
539 kmem_free(ill->ill_zerocopy_capab,
541 ill->ill_zerocopy_capab = NULL;
544 if (ill->ill_lso_capab != NULL) {
545 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
546 ill->ill_lso_capab = NULL;
549 if (ill->ill_dld_capab != NULL) {
550 kmem_free(ill->ill_dld_capab, sizeof (ill_dld_capab_t));
551 ill->ill_dld_capab = NULL;
555 if (ill->ill_allowed_ips != NULL) {
556 ASSERT(ill->ill_allowed_ips_cnt > 0);
557 kmem_free(ill->ill_allowed_ips,
558 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
559 ill->ill_allowed_ips = NULL;
560 ill->ill_allowed_ips_cnt = 0;
563 while (ill->ill_ipif != NULL)
564 ipif_free_tail(ill->ill_ipif);
574 * ill references.
578 * If this ill is an IPMP meta-interface, blow away the illgrp. This
582 if (IS_IPMP(ill)) {
583 ipmp_illgrp_destroy(ill->ill_grp);
584 ill->ill_grp = NULL;
587 if (ill->ill_mphysaddr_list != NULL) {
590 mpa = ill->ill_mphysaddr_list;
591 ill->ill_mphysaddr_list = NULL;
603 (void) ill_glist_delete(ill);
605 if (ill->ill_frag_ptr != NULL) {
609 mutex_destroy(&ill->ill_frag_hash_tbl[count].ipfb_lock);
611 mi_free(ill->ill_frag_ptr);
612 ill->ill_frag_ptr = NULL;
613 ill->ill_frag_hash_tbl = NULL;
616 freemsg(ill->ill_nd_lla_mp);
618 mpp = &ill->ill_first_mp_to_free;
632 } while (mpp++ != &ill->ill_last_mp_to_free);
634 ill_free_mib(ill);
637 ill_trace_cleanup(ill);
641 ire_increment_multicast_generation(ipst, ill->ill_isv6);
644 netstack_rele(ill->ill_ipst->ips_netstack);
645 ill->ill_ipst = NULL;
649 ill_free_mib(ill_t *ill)
651 ip_stack_t *ipst = ill->ill_ipst;
658 if (ill->ill_ip_mib != NULL) {
659 if (ill->ill_isv6) {
661 ill->ill_ip_mib);
664 ill->ill_ip_mib);
667 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
668 ill->ill_ip_mib = NULL;
670 if (ill->ill_icmp6_mib != NULL) {
672 ill->ill_icmp6_mib);
673 kmem_free(ill->ill_icmp6_mib, sizeof (*ill->ill_icmp6_mib));
674 ill->ill_icmp6_mib = NULL;
751 * ipif/ill/ire refcnts to drop to zero in bringing down an ipif.
766 * ill needs to wait for the V6 ill to quiesce). So we can't ASSERT
851 * - Called in the M_ERROR or M_HANGUP path on the ill.
858 ipsq_pending_mp_cleanup(ill_t *ill, conn_t *connp)
866 ASSERT(IAM_WRITER_ILL(ill));
867 ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
889 if (mp == NULL && ill->ill_error == 0) {
934 * Called in the conn close path and ill delete path
937 ipsq_xopq_mp_cleanup(ill_t *ill, conn_t *connp)
946 ASSERT(IAM_WRITER_ILL(ill));
950 wq = ill->ill_wq;
959 ipsq = ill->ill_phyint->phyint_ipsq;
963 * queued on the ipsq. If an ill is being unplumbed flush all
1025 ill_t *ill;
1039 ill = connp->conn_oper_pending_ill;
1040 if (ill == NULL) {
1046 * We may not be able to refhold the ill if the ill/ipif
1047 * is changing. But we need to make sure that the ill will
1050 refheld = ill_waiter_inc(ill);
1053 if (ipsq_enter(ill, B_TRUE, NEW_OP)) {
1054 ill_waiter_dcr(ill);
1061 if (!ipsq_pending_mp_cleanup(ill, connp))
1062 ipsq_xopq_mp_cleanup(ill, connp);
1063 ipsq = ill->ill_phyint->phyint_ipsq;
1070 * The ill is also closing and we could not bump up the
1079 ill_waiter_dcr(ill);
1092 ill_t *ill = (ill_t *)arg;
1095 if (connp->conn_dhcpinit_ill == ill) {
1097 ASSERT(ill->ill_dhcpinit != 0);
1098 atomic_dec_32(&ill->ill_dhcpinit);
1099 ill_set_inputfn(ill);
1105 ill_down_ipifs_tail(ill_t *ill)
1110 ASSERT(IAM_WRITER_ILL(ill));
1111 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
1134 * ill_down_start is called when we want to down this ill and bring it up again
1141 ill_t *ill = q->q_ptr;
1144 ASSERT(IAM_WRITER_ILL(ill));
1154 * the state of the ipsq and the ill would reflect no trace of any
1159 (void) ipsq_pending_mp_cleanup(ill, NULL);
1160 ill_dlpi_clear_deferred(ill);
1162 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
1165 ill_down(ill);
1169 * ill (we actually walk all that now have stale references).
1171 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ill->ill_ipst);
1174 if (ill->ill_isv6)
1175 dce_cleanup(ill->ill_phyint->phyint_ifindex, ill->ill_ipst);
1177 ipsq_current_start(ill->ill_phyint->phyint_ipsq, ill->ill_ipif, 0);
1182 mutex_enter(&ill->ill_lock);
1183 if (!ill_is_quiescent(ill)) {
1185 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
1187 mutex_exit(&ill->ill_lock);
1190 mutex_exit(&ill->ill_lock);
1195 ill_down(ill_t *ill)
1198 ip_stack_t *ipst = ill->ill_ipst;
1204 ill_delete_ires(ill);
1206 ire_walk_ill(0, 0, ill_downi, ill, ill);
1208 /* Remove any conn_*_ill depending on this ill */
1209 ipcl_walk(conn_cleanup_ill, (caddr_t)ill, ipst);
1214 mutex_enter(&ill->ill_saved_ire_lock);
1215 mp = ill->ill_saved_ire_mp;
1216 ill->ill_saved_ire_mp = NULL;
1217 ill->ill_saved_ire_cnt = 0;
1218 mutex_exit(&ill->ill_saved_ire_lock);
1224 * 'ill'. (Always called as writer, and may only be called from ire_walk.)
1229 * We also remove references on ire_nce_cache entries that refer to the ill.
1234 ill_t *ill = (ill_t *)ill_arg;
1239 if (nce != NULL && nce->nce_ill == ill)
1246 if (ire->ire_ill == ill) {
1265 /* Remove IRE_IF_CLONE on this ill */
1269 ill_t *ill = (ill_t *)ill_arg;
1272 if (ire->ire_ill == ill)
1278 ill_fastpath_ack(ill_t *ill, mblk_t *mp)
1285 mutex_enter(&ill->ill_lock);
1286 if (ill->ill_dlpi_fastpath_state == IDS_INPROGRESS)
1287 ill->ill_dlpi_fastpath_state = IDS_OK;
1288 mutex_exit(&ill->ill_lock);
1296 nce_fastpath_update(ill, mp);
1308 ill_fastpath_probe(ill_t *ill, mblk_t *dlur_mp)
1316 mutex_enter(&ill->ill_lock);
1317 switch (ill->ill_dlpi_fastpath_state) {
1323 mutex_exit(&ill->ill_lock);
1327 ill->ill_dlpi_fastpath_state = IDS_INPROGRESS;
1332 mutex_exit(&ill->ill_lock);
1347 char *, "DL_IOC_HDR_INFO", ill_t *, ill);
1348 putnext(ill->ill_wq, mp);
1353 ill_capability_probe(ill_t *ill)
1357 ASSERT(IAM_WRITER_ILL(ill));
1359 if (ill->ill_dlpi_capab_state != IDCS_UNKNOWN &&
1360 ill->ill_dlpi_capab_state != IDCS_FAILED)
1368 if (ill->ill_capab_reset_mp != NULL) {
1369 freemsg(ill->ill_capab_reset_mp);
1370 ill->ill_capab_reset_mp = NULL;
1379 ill_capability_send(ill, mp);
1380 ill->ill_dlpi_capab_state = IDCS_PROBE_SENT;
1384 ill_capability_reset(ill_t *ill, boolean_t reneg)
1386 ASSERT(IAM_WRITER_ILL(ill));
1388 if (ill->ill_dlpi_capab_state != IDCS_OK)
1391 ill->ill_dlpi_capab_state = reneg ? IDCS_RENEG : IDCS_RESET_SENT;
1393 ill_capability_send(ill, ill->ill_capab_reset_mp);
1394 ill->ill_capab_reset_mp = NULL;
1400 ill->ill_capabilities &= ~(ILL_CAPAB_HCKSUM | ILL_CAPAB_ZEROCOPY);
1404 ill_capability_reset_alloc(ill_t *ill)
1411 ASSERT(IAM_WRITER_ILL(ill));
1412 ASSERT(ill->ill_capab_reset_mp == NULL);
1414 if (ILL_HCKSUM_CAPABLE(ill)) {
1419 if (ill->ill_capabilities & ILL_CAPAB_ZEROCOPY) {
1424 if (ill->ill_capabilities & ILL_CAPAB_DLD) {
1446 ill_capability_hcksum_reset_fill(ill, mp);
1447 ill_capability_zerocopy_reset_fill(ill, mp);
1448 ill_capability_dld_reset_fill(ill, mp);
1450 ill->ill_capab_reset_mp = mp;
1454 ill_capability_id_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *outers)
1489 if (!dlcapabcheckqid(&id_ic->id_mid, ill->ill_lmod_rq)) {
1497 ill_capability_dispatch(ill, mp, inners);
1501 ill_capability_dld_reset_fill(ill_t *ill, mblk_t *mp)
1505 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
1520 ill_capability_dispatch(ill_t *ill, mblk_t *mp, dl_capability_sub_t *subp)
1523 * If no ipif was brought up over this ill, this DL_CAPABILITY_REQ/ACK
1530 if (!ill->ill_dl_up) {
1532 ill_capability_vrrp_ack(ill, mp, subp);
1538 ill_capability_hcksum_ack(ill, mp, subp);
1541 ill_capability_zerocopy_ack(ill, mp, subp);
1544 ill_capability_dld_ack(ill, mp, subp);
1559 ill_capability_vrrp_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1565 ASSERT(IAM_WRITER_ILL(ill));
1584 * Compare the IP address family and set ILLF_VRRP for the right ill.
1586 if ((vrrp->vrrp_af == AF_INET6 && ill->ill_isv6) ||
1587 (vrrp->vrrp_af == AF_INET && !ill->ill_isv6)) {
1588 ill->ill_flags |= ILLF_VRRP;
1598 ill_capability_hcksum_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1609 ill_hcksum = (ill_hcksum_capab_t **)&ill->ill_hcksum_capab;
1642 if (!dlcapabcheckqid(&ihck->hcksum_mid, ill->ill_lmod_rq)) {
1664 ill->ill_name);
1671 ill->ill_capabilities |= ILL_CAPAB_HCKSUM;
1674 ill->ill_name));
1694 ill->ill_name);
1727 ill_capability_send(ill, nmp);
1731 ill->ill_name, ihck->hcksum_txflags));
1736 ill_capability_hcksum_reset_fill(ill_t *ill, mblk_t *mp)
1741 if (!ILL_HCKSUM_CAPABLE(ill))
1744 ASSERT(ill->ill_hcksum_capab != NULL);
1751 hck_subcap->hcksum_version = ill->ill_hcksum_capab->ill_hcksum_version;
1758 ill_capability_zerocopy_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1769 ill_zerocopy_capab = (ill_zerocopy_capab_t **)&ill->ill_zerocopy_capab;
1794 if (!dlcapabcheckqid(&zc_ic->zerocopy_mid, ill->ill_lmod_rq)) {
1811 ill->ill_name);
1817 "supports Zero-copy version %d\n", ill->ill_name,
1825 ill->ill_capabilities |= ILL_CAPAB_ZEROCOPY;
1837 ill->ill_name);
1858 "to enable zero-copy version %d\n", ill->ill_name,
1865 ill_capability_send(ill, nmp);
1870 ill_capability_zerocopy_reset_fill(ill_t *ill, mblk_t *mp)
1875 if (!(ill->ill_capabilities & ILL_CAPAB_ZEROCOPY))
1878 ASSERT(ill->ill_zerocopy_capab != NULL);
1886 ill->ill_zerocopy_capab->ill_zerocopy_version;
1898 ill_capability_dld_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1905 ASSERT(IAM_WRITER_ILL(ill));
1929 if (!dlcapabcheckqid(&dld_ic->dld_mid, ill->ill_lmod_rq)) {
1941 if ((idc = ill->ill_dld_capab) == NULL) {
1947 ill->ill_name);
1950 ill->ill_dld_capab = idc;
1955 "supports DLD version %d\n", ill->ill_name, DLD_CURRENT_VERSION));
1957 ill_capability_dld_enable(ill);
1975 ill_mac_perim_enter(ill_t *ill, mac_perim_handle_t *mphp)
1977 ill_dld_capab_t *idc = ill->ill_dld_capab;
1986 ill_mac_perim_exit(ill_t *ill, mac_perim_handle_t mph)
1988 ill_dld_capab_t *idc = ill->ill_dld_capab;
1997 ill_mac_perim_held(ill_t *ill)
1999 ill_dld_capab_t *idc = ill->ill_dld_capab;
2006 ill_capability_direct_enable(ill_t *ill)
2008 ill_dld_capab_t *idc = ill->ill_dld_capab;
2013 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2017 direct.di_rx_ch = ill;
2034 ill->ill_flownotify_mh = idd->idd_tx_cb_df(idd->idd_tx_cb_dh,
2035 ill_flow_enable, ill);
2036 ill->ill_capabilities |= ILL_CAPAB_DLD_DIRECT;
2037 DTRACE_PROBE1(direct_on, (ill_t *), ill);
2041 DTRACE_PROBE2(direct_off, (ill_t *), ill, (int), rc);
2046 ill_capability_poll_enable(ill_t *ill)
2048 ill_dld_capab_t *idc = ill->ill_dld_capab;
2052 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2060 poll.poll_ring_ch = ill;
2064 ill->ill_capabilities |= ILL_CAPAB_DLD_POLL;
2065 DTRACE_PROBE1(poll_on, (ill_t *), ill);
2069 DTRACE_PROBE2(poll_off, (ill_t *), ill, (int), rc);
2077 ill_capability_lso_enable(ill_t *ill)
2079 ill_dld_capab_t *idc = ill->ill_dld_capab;
2083 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2085 if (ill->ill_lso_capab == NULL) {
2086 ill->ill_lso_capab = kmem_zalloc(sizeof (ill_lso_capab_t),
2088 if (ill->ill_lso_capab == NULL) {
2091 ill->ill_name);
2099 ill->ill_lso_capab->ill_lso_flags = lso.lso_flags;
2100 ill->ill_lso_capab->ill_lso_max = lso.lso_max;
2101 ill->ill_capabilities |= ILL_CAPAB_LSO;
2103 "has enabled LSO\n ", ill->ill_name));
2105 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
2106 ill->ill_lso_capab = NULL;
2107 DTRACE_PROBE2(lso_off, (ill_t *), ill, (int), rc);
2112 ill_capability_dld_enable(ill_t *ill)
2116 ASSERT(IAM_WRITER_ILL(ill));
2118 if (ill->ill_isv6)
2121 ill_mac_perim_enter(ill, &mph);
2122 if (!ill->ill_isv6) {
2123 ill_capability_direct_enable(ill);
2124 ill_capability_poll_enable(ill);
2125 ill_capability_lso_enable(ill);
2127 ill->ill_capabilities |= ILL_CAPAB_DLD;
2128 ill_mac_perim_exit(ill, mph);
2132 ill_capability_dld_disable(ill_t *ill)
2138 ASSERT(IAM_WRITER_ILL(ill));
2140 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
2143 ill_mac_perim_enter(ill, &mph);
2145 idc = ill->ill_dld_capab;
2146 if ((ill->ill_capabilities & ILL_CAPAB_DLD_DIRECT) != 0) {
2157 mutex_enter(&ill->ill_lock);
2158 ill->ill_capabilities &= ~ILL_CAPAB_DLD_DIRECT;
2159 mutex_exit(&ill->ill_lock);
2160 if (ill->ill_flownotify_mh != NULL) {
2163 ill->ill_flownotify_mh);
2164 ill->ill_flownotify_mh = NULL;
2170 if ((ill->ill_capabilities & ILL_CAPAB_DLD_POLL) != 0) {
2171 ill->ill_capabilities &= ~ILL_CAPAB_DLD_POLL;
2172 ip_squeue_clean_all(ill);
2177 if ((ill->ill_capabilities & ILL_CAPAB_LSO) != 0) {
2178 ASSERT(ill->ill_lso_capab != NULL);
2183 * deallocated when we destroy the ill.
2186 ill->ill_capabilities &= ~ILL_CAPAB_LSO;
2191 ill->ill_capabilities &= ~ILL_CAPAB_DLD;
2192 ill_mac_perim_exit(ill, mph);
2276 ill_t *ill;
2279 ill = (ill_t *)mp->b_prev;
2282 VERIFY(ipsq_enter(ill, B_FALSE, CUR_OP) == B_TRUE);
2284 if (ill->ill_dlpi_capab_state == IDCS_RESET_SENT ||
2285 ill->ill_dlpi_capab_state == IDCS_RENEG) {
2292 reneg = ill->ill_dlpi_capab_state == IDCS_RENEG;
2293 ill_capability_dld_disable(ill);
2294 ill->ill_dlpi_capab_state = IDCS_UNKNOWN;
2296 ill_capability_probe(ill);
2300 if (ill->ill_dlpi_capab_state == IDCS_PROBE_SENT)
2301 ill->ill_dlpi_capab_state = IDCS_OK;
2329 ill_capability_id_ack(ill, mp, subp);
2332 ill_capability_dispatch(ill, mp, subp);
2339 ill_capability_done(ill);
2340 ipsq_exit(ill->ill_phyint->phyint_ipsq);
2348 ill_capability_ack(ill_t *ill, mblk_t *mp)
2350 ip_stack_t *ipst = ill->ill_ipst;
2352 mp->b_prev = (mblk_t *)ill;
2395 ill_frag_timeout(ill_t *ill, time_t dead_interval)
2407 ip_stack_t *ipst = ill->ill_ipst;
2412 iras.ira_ill = iras.ira_rill = ill;
2413 iras.ira_ruifindex = ill->ill_phyint->phyint_ifindex;
2416 ipfb = ill->ill_frag_hash_tbl;
2456 atomic_add_32(&ill->ill_frag_count, -ipf->ipf_count);
2470 if (ill->ill_isv6) {
2485 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2486 ip_drop_input("ipIfStatsReasmFails", ipf->ipf_mp, ill);
2509 ill, ipst);
2510 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2532 ill, ipst);
2533 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2551 ill_frag_prune(ill_t *ill, uint_t max_count)
2563 mutex_enter(&ill->ill_lock);
2565 if (TICK_TO_MSEC(now - ill->ill_last_frag_clean_time) <=
2569 ill->ill_frag_free_num_pkts++;
2572 ill->ill_frag_free_num_pkts = 0;
2574 ill->ill_last_frag_clean_time = now;
2575 mutex_exit(&ill->ill_lock);
2580 if (ill->ill_frag_free_num_pkts != 0) {
2584 ipfb = &ill->ill_frag_hash_tbl[ix];
2587 ill_frag_free_pkts(ill, ipfb, ipfb->ipfb_ipf,
2588 ill->ill_frag_free_num_pkts);
2597 while (ill->ill_frag_count > max_count) {
2604 ipfb = &ill->ill_frag_hash_tbl[ix];
2622 ill_frag_free_pkts(ill, oipfb, ipf, 1);
2632 ill_frag_free_pkts(ill_t *ill, ipfb_t *ipfb, ipf_t *ipf, int free_cnt)
2651 atomic_add_32(&ill->ill_frag_count, -count);
2656 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2657 ip_drop_input("ipIfStatsReasmFails", mp, ill);
2670 ill_forward_set_on_ill(ill_t *ill, boolean_t enable)
2672 ip_stack_t *ipst = ill->ill_ipst;
2674 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2678 (ill->ill_isv6 ? "IPv6" : "IPv4"), ill->ill_name));
2679 mutex_enter(&ill->ill_lock);
2681 ill->ill_flags |= ILLF_ROUTER;
2683 ill->ill_flags &= ~ILLF_ROUTER;
2684 mutex_exit(&ill->ill_lock);
2685 if (ill->ill_isv6)
2686 ill_set_nce_router_flags(ill, enable);
2688 if (ill->ill_ipif != NULL)
2689 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
2693 * Set an ill's ILLF_ROUTER flag appropriately. Send up RTS_IFINFO routing
2697 ill_forward_set(ill_t *ill, boolean_t enable)
2700 ip_stack_t *ipst = ill->ill_ipst;
2702 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2704 if ((enable && (ill->ill_flags & ILLF_ROUTER)) ||
2705 (!enable && !(ill->ill_flags & ILLF_ROUTER)))
2708 if (IS_LOOPBACK(ill))
2711 if (enable && ill->ill_allowed_ips_cnt > 0)
2714 if (IS_IPMP(ill) || IS_UNDER_IPMP(ill)) {
2718 illg = ill->ill_grp;
2719 ill = list_head(&illg->ig_if);
2720 for (; ill != NULL; ill = list_next(&illg->ig_if, ill))
2721 ill_forward_set_on_ill(ill, enable);
2730 ill_forward_set_on_ill(ill, enable);
2735 * Based on the ILLF_ROUTER flag of an ill, make sure all local nce's for
2736 * addresses assigned to the ill have the NCE_F_ISROUTER flag appropriately
2740 ill_set_nce_router_flags(ill_t *ill, boolean_t enable)
2746 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
2750 * the bound underlying ill.
2752 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
2767 * Intializes the context structure and returns the first ill in the list
2776 * necessary under the ill lock.
2783 ill_t *ill;
2805 ill = avl_first(avl_tree);
2807 * ill is guaranteed to be non NULL or ifp should have
2810 ASSERT(ill != NULL);
2811 return (ill);
2820 * returns the next ill in the list. ill_first() must have been called
2826 * necessary under the ill lock.
2832 ill_t *ill;
2837 if ((ill = avl_walk(&lastill->ill_ifptr->illif_avl_by_ppa, lastill,
2839 return (ill);
2899 * use avl tree to locate the ill.
2907 ill_t *ill = NULL;
2950 ill = avl_find(&ifp->illif_avl_by_ppa, (void *) &ppa, NULL);
2951 if (ill != NULL) {
2952 mutex_enter(&ill->ill_lock);
2953 if (ILL_CAN_LOOKUP(ill)) {
2954 ill_refhold_locked(ill);
2955 mutex_exit(&ill->ill_lock);
2956 return (ill);
2958 mutex_exit(&ill->ill_lock);
2977 * We want the ill with the lowest ppa to be on the
3006 * remove ill from the global list.
3009 ill_glist_delete(ill_t *ill)
3014 if (ill == NULL)
3016 ipst = ill->ill_ipst;
3020 * If the ill was never inserted into the AVL tree
3023 if (ill->ill_ifptr != NULL) {
3027 avl_remove(&ill->ill_ifptr->illif_avl_by_ppa, ill);
3029 if (ill->ill_ifptr->illif_ppa_arena != NULL) {
3030 vmem_free(ill->ill_ifptr->illif_ppa_arena,
3031 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3033 if (avl_numnodes(&ill->ill_ifptr->illif_avl_by_ppa) == 0) {
3034 ill_delete_interface_type(ill->ill_ifptr);
3038 * Indicate ill is no longer in the list.
3040 ill->ill_ifptr = NULL;
3041 ill->ill_name_length = 0;
3042 ill->ill_name[0] = '\0';
3043 ill->ill_ppa = UINT_MAX;
3046 /* Generate one last event for this ill. */
3047 ill_nic_event_dispatch(ill, 0, NE_UNPLUMB, ill->ill_name,
3048 ill->ill_name_length);
3050 ASSERT(ill->ill_phyint != NULL);
3051 phyi = ill->ill_phyint;
3052 ill->ill_phyint = NULL;
3059 * the ill, at which point in time we assign phyint_illv4/v6.
3062 if (ill->ill_flags & ILLF_IPV6)
3096 ill_alloc_ppa(ill_if_t *ifp, ill_t *ill)
3135 if (ill->ill_ppa == UINT_MAX) {
3140 ill->ill_ppa = --ppa;
3147 (void *)(uintptr_t)(ill->ill_ppa + 1), /* minaddr */
3148 (void *)(uintptr_t)(ill->ill_ppa + 2), /* maxaddr */
3164 if (ill->ill_ppa == UINT_MAX) {
3168 end = start = ill->ill_ppa;
3174 if (ill->ill_ppa == UINT_MAX)
3181 ill->ill_ppa = start;
3186 * Insert ill into the list of configured ill's. Once this function completes,
3187 * the ill is globally visible and is available through lookups. More precisely
3191 ill_glist_insert(ill_t *ill, char *name, boolean_t isv6)
3199 ip_stack_t *ipst = ill->ill_ipst;
3251 if (ill->ill_ppa == UINT_MAX)
3254 error = ill_alloc_ppa(ill_interface, ill);
3257 ill_delete_interface_type(ill->ill_ifptr);
3277 numtos(ill->ill_ppa, buf);
3285 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3288 ill_delete_interface_type(ill->ill_ifptr);
3294 (void) sprintf(ill->ill_name, "%s%u", name, ill->ill_ppa);
3295 ill->ill_name_length = mi_strlen(ill->ill_name) + 1;
3297 (void) avl_find(&ill_interface->illif_avl_by_ppa, &ill->ill_ppa,
3299 ill->ill_ifptr = ill_interface;
3300 avl_insert(&ill_interface->illif_avl_by_ppa, ill, where);
3302 ill_phyint_reinit(ill);
3308 ipsq_init(ill_t *ill, boolean_t enter)
3316 ill->ill_phyint->phyint_ipsq = ipsq;
3320 ipsq->ipsq_phyint = ill->ill_phyint;
3323 ipsq->ipsq_ipst = ill->ill_ipst; /* No netstack_hold */
3340 ill_init_common(ill_t *ill, queue_t *q, boolean_t isv6, boolean_t is_loopback,
3346 mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, 0);
3347 mutex_init(&ill->ill_saved_ire_lock, NULL, MUTEX_DEFAULT, NULL);
3348 ill->ill_saved_ire_cnt = 0;
3351 ill->ill_max_frag = isv6 ? ip_loopback_mtu_v6plus :
3356 ill->ill_net_type = IRE_LOOPBACK;
3358 ill->ill_rq = q;
3359 ill->ill_wq = WR(q);
3360 ill->ill_ppa = UINT_MAX;
3363 ill->ill_isv6 = isv6;
3372 ill->ill_frag_ptr = frag_ptr;
3373 ill->ill_frag_free_num_pkts = 0;
3374 ill->ill_last_frag_clean_time = 0;
3375 ill->ill_frag_hash_tbl = (ipfb_t *)frag_ptr;
3376 ill->ill_name = (char *)(frag_ptr + ILL_FRAG_HASH_TBL_SIZE);
3378 mutex_init(&ill->ill_frag_hash_tbl[count].ipfb_lock,
3382 ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t));
3383 if (ill->ill_phyint == NULL) {
3388 mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0);
3390 ill->ill_phyint->phyint_illv6 = ill;
3392 ill->ill_phyint->phyint_illv4 = ill;
3395 phyint_flags_init(ill->ill_phyint, DL_LOOP);
3398 list_create(&ill->ill_nce, sizeof (nce_t), offsetof(nce_t, nce_node));
3400 ill_set_inputfn(ill);
3402 if (!ipsq_init(ill, ipsq_enter)) {
3404 mi_free(ill->ill_phyint);
3409 ill->ill_frag_count = 0;
3410 ill->ill_ipf_gen = 0;
3412 rw_init(&ill->ill_mcast_lock, NULL, RW_DEFAULT, NULL);
3413 mutex_init(&ill->ill_mcast_serializer, NULL, MUTEX_DEFAULT, NULL);
3414 ill->ill_global_timer = INFINITY;
3415 ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0;
3416 ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0;
3417 ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS;
3418 ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL;
3424 * here for convenience, this has no effect until the ill is set to do
3427 ill->ill_reachable_time = ND_REACHABLE_TIME;
3428 ill->ill_xmit_count = ND_MAX_MULTICAST_SOLICIT;
3429 ill->ill_max_buf = ND_MAX_Q;
3430 ill->ill_refcnt = 0;
3449 ill_init(queue_t *q, ill_t *ill)
3461 * For now pretend this is a v4 ill. We need to set phyint_ill*
3468 if ((ret = ill_init_common(ill, q, B_FALSE, B_FALSE, B_TRUE)) != 0) {
3473 ill->ill_state_flags |= ILL_LL_SUBNET_PENDING;
3481 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3484 ill_dlpi_send(ill, info_mp);
3494 ill_dls_info(struct sockaddr_dl *sdl, const ill_t *ill)
3499 sdl->sdl_index = ill_get_upper_ifindex(ill);
3500 sdl->sdl_type = ill->ill_type;
3501 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3505 sdl->sdl_alen = ill->ill_phys_addr_length;
3507 if (ill->ill_phys_addr_length != 0 && ill->ill_phys_addr != NULL)
3508 bcopy(ill->ill_phys_addr, &sdl->sdl_data[len], sdl->sdl_alen);
3518 ill_xarp_info(struct sockaddr_dl *sdl, ill_t *ill)
3521 sdl->sdl_index = ill->ill_phyint->phyint_ifindex;
3522 sdl->sdl_type = ill->ill_type;
3523 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3525 sdl->sdl_alen = ill->ill_phys_addr_length;
3676 * Return a pointer to the ill which matches the supplied name. Note that
3677 * the ill name length includes the null termination character. (May be
3687 ill_t *ill;
3697 ill = ill_find_by_name(name, isv6, ipst);
3699 if (ill != NULL)
3700 return (ill);
3710 ill = ill_find_by_name(name, isv6, ipst);
3711 if (ill != NULL) {
3713 return (ill);
3717 ill = (ill_t *)(mi_alloc(sizeof (ill_t) +
3719 if (ill == NULL)
3722 bzero(ill, sizeof (*ill));
3723 ill->ill_ipst = ipst;
3729 ill->ill_zoneid = GLOBAL_ZONEID;
3731 if (ill_init_common(ill, NULL, isv6, B_TRUE, B_FALSE) != 0)
3734 if (!ill_allocate_mibs(ill))
3737 ill->ill_current_frag = ill->ill_max_frag;
3738 ill->ill_mtu = ill->ill_max_frag; /* Initial value */
3739 ill->ill_mc_mtu = ill->ill_mtu;
3742 * by both the ipv4 and ipv6 interfaces. When the ill is removed
3746 ill->ill_name = (char *)ill + sizeof (*ill);
3747 (void) strcpy(ill->ill_name, ipif_loopback_name);
3748 ill->ill_name_length = sizeof (ipif_loopback_name);
3750 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3752 ipif = ipif_allocate(ill, 0L, IRE_LOOPBACK, B_TRUE, B_TRUE, NULL);
3756 ill->ill_flags = ILLF_MULTICAST;
3767 ill->ill_flags |= ILLF_IPV4;
3773 ill->ill_flags |= ILLF_IPV6;
3777 * Chain us in at the end of the ill list. hold the ill
3780 ill_refhold(ill);
3782 ipsq = ill->ill_phyint->phyint_ipsq;
3784 if (ill_glist_insert(ill, "lo", isv6) != 0)
3788 sctp_update_ill(ill, SCTP_ILL_INSERT);
3804 if (ipsq != ill->ill_phyint->phyint_ipsq)
3828 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ill->ill_ipif->ipif_id),
3829 NE_PLUMB, ill->ill_name, ill->ill_name_length);
3830 return (ill);
3832 if (ill != NULL) {
3833 if (ill->ill_phyint != NULL) {
3834 ipsq = ill->ill_phyint->phyint_ipsq;
3839 mi_free(ill->ill_phyint);
3841 ill_free_mib(ill);
3842 if (ill->ill_ipst != NULL)
3843 netstack_rele(ill->ill_ipst->ips_netstack);
3844 mi_free(ill);
3857 ill_t *ill;
3868 ill = ill_lookup_on_ifindex(index, isv6, ipst);
3870 return (ill);
3874 * Return a pointer to the ill which matches the index and IP version type.
3879 ill_t *ill;
3890 ill = isv6 ? phyi->phyint_illv6: phyi->phyint_illv4;
3891 if (ill != NULL) {
3892 mutex_enter(&ill->ill_lock);
3893 if (!ILL_IS_CONDEMNED(ill)) {
3894 ill_refhold_locked(ill);
3895 mutex_exit(&ill->ill_lock);
3897 return (ill);
3899 mutex_exit(&ill->ill_lock);
3916 ill_t *ill;
3921 ill = ill_lookup_on_ifindex_zoneid(ifindex, zoneid, isv6, ipst);
3922 if (ill == NULL)
3924 if (IS_VNI(ill)) {
3925 ill_refrele(ill);
3928 ill_refrele(ill);
4015 * for IPV6_RECVPKTINFO. If IPMP this is the one for the upper ill.
4018 ill_get_upper_ifindex(const ill_t *ill)
4020 if (IS_UNDER_IPMP(ill))
4021 return (ipmp_ill_get_ipmp_ifindex(ill));
4023 return (ill->ill_phyint->phyint_ifindex);
4028 * Obtain a reference to the ill. The ill_refcnt is a dynamic refcnt
4029 * that gives a running thread a reference to the ill. This reference must be
4030 * released by the thread when it is done accessing the ill and related
4032 * such as other structures pointing to an ill. Callers must generally
4033 * check whether an ill can be refheld by using ILL_CAN_LOOKUP macros
4034 * or be sure that the ill is not being deleted or changing state before
4036 * ill won't change any of its critical state such as address, netmask etc.
4039 ill_refhold(ill_t *ill)
4041 mutex_enter(&ill->ill_lock);
4042 ill->ill_refcnt++;
4043 ILL_TRACE_REF(ill);
4044 mutex_exit(&ill->ill_lock);
4048 ill_refhold_locked(ill_t *ill)
4050 ASSERT(MUTEX_HELD(&ill->ill_lock));
4051 ill->ill_refcnt++;
4052 ILL_TRACE_REF(ill);
4057 ill_check_and_refhold(ill_t *ill)
4059 mutex_enter(&ill->ill_lock);
4060 if (!ILL_IS_CONDEMNED(ill)) {
4061 ill_refhold_locked(ill);
4062 mutex_exit(&ill->ill_lock);
4065 mutex_exit(&ill->ill_lock);
4076 ill_refrele(ill_t *ill)
4078 mutex_enter(&ill->ill_lock);
4079 ASSERT(ill->ill_refcnt != 0);
4080 ill->ill_refcnt--;
4081 ILL_UNTRACE_REF(ill);
4082 if (ill->ill_refcnt != 0) {
4083 /* Every ire pointing to the ill adds 1 to ill_refcnt */
4084 mutex_exit(&ill->ill_lock);
4089 ipif_ill_refrele_tail(ill);
4093 * Obtain a weak reference count on the ill. This reference ensures the
4094 * ill won't be freed, but the ill may change any of its critical state
4095 * such as netmask, address etc. Returns an error if the ill has started
4099 ill_waiter_inc(ill_t *ill)
4101 mutex_enter(&ill->ill_lock);
4102 if (ill->ill_state_flags & ILL_CONDEMNED) {
4103 mutex_exit(&ill->ill_lock);
4106 ill->ill_waiters++;
4107 mutex_exit(&ill->ill_lock);
4112 ill_waiter_dcr(ill_t *ill)
4114 mutex_enter(&ill->ill_lock);
4115 ill->ill_waiters--;
4116 if (ill->ill_waiters == 0)
4117 cv_broadcast(&ill->ill_cv);
4118 mutex_exit(&ill->ill_lock);
4132 ip_ll_subnet_defaults(ill_t *ill, mblk_t *mp)
4142 ASSERT(IAM_WRITER_ILL(ill));
4145 * Till the ill is fully up the ill is not globally visible.
4149 ill->ill_mactype = dlia->dl_mac_type;
4156 ill->ill_media = ipm;
4180 ill->ill_bcast_addr_length = brdcst_addr_length;
4181 ill->ill_phys_addr_length = phys_addr_length;
4182 ill->ill_sap_length = sap_length;
4189 min_mtu = ill->ill_isv6 ? IPV6_MIN_MTU : IP_MIN_MTU;
4190 ill->ill_max_frag = MAX(min_mtu, dlia->dl_max_sdu);
4191 ill->ill_current_frag = ill->ill_max_frag;
4192 ill->ill_mtu = ill->ill_max_frag;
4193 ill->ill_mc_mtu = ill->ill_mtu; /* Overridden by DL_NOTE_SDU_SIZE2 */
4195 ill->ill_type = ipm->ip_m_type;
4197 if (!ill->ill_dlpi_style_set) {
4199 ill->ill_needs_attach = 1;
4201 phyint_flags_init(ill->ill_phyint, ill->ill_mactype);
4204 * Allocate the first ipif on this ill. We don't delay it
4207 * At this point we don't know whether the ill is v4 or v6.
4210 * ipif_set_values(). We need to hold the ill lock and
4214 (void) ipif_allocate(ill, 0, IRE_LOCAL,
4216 mutex_enter(&ill->ill_lock);
4217 ASSERT(ill->ill_dlpi_style_set == 0);
4218 ill->ill_dlpi_style_set = 1;
4219 ill->ill_state_flags &= ~ILL_LL_SUBNET_PENDING;
4220 cv_broadcast(&ill->ill_cv);
4221 mutex_exit(&ill->ill_lock);
4225 ASSERT(ill->ill_ipif != NULL);
4231 ill->ill_sap = (ill->ill_isv6) ? ipm->ip_m_ipv6sap : ipm->ip_m_ipv4sap;
4237 ill->ill_flags &= ~(ILLF_MULTICAST | ILLF_NONUD | ILLF_NOARP);
4238 ill->ill_ipif->ipif_flags &= ~(IPIF_BROADCAST | IPIF_POINTOPOINT);
4248 if (ill->ill_bcast_addr_length == 0 && !IS_IPMP(ill)) {
4249 if (ill->ill_bcast_mp != NULL)
4250 freemsg(ill->ill_bcast_mp);
4251 ill->ill_net_type = IRE_IF_NORESOLVER;
4253 ill->ill_bcast_mp = ill_dlur_gen(NULL,
4254 ill->ill_phys_addr_length,
4255 ill->ill_sap,
4256 ill->ill_sap_length);
4258 if (ill->ill_isv6)
4266 ill->ill_flags |= ILLF_NONUD;
4268 ill->ill_flags |= ILLF_NOARP;
4270 if (ill->ill_mactype == SUNW_DL_VNI) {
4271 ill->ill_ipif->ipif_flags |= IPIF_NOXMIT;
4272 } else if (ill->ill_phys_addr_length == 0 ||
4273 ill->ill_mactype == DL_IPV4 ||
4274 ill->ill_mactype == DL_IPV6) {
4281 ill->ill_flags |= ILLF_MULTICAST;
4282 ill->ill_ipif->ipif_flags |= IPIF_POINTOPOINT;
4285 ill->ill_net_type = IRE_IF_RESOLVER;
4286 if (ill->ill_bcast_mp != NULL)
4287 freemsg(ill->ill_bcast_mp);
4288 ill->ill_bcast_mp = ill_dlur_gen(brdcst_addr,
4289 ill->ill_bcast_addr_length, ill->ill_sap,
4290 ill->ill_sap_length);
4296 ill->ill_flags |= ILLF_MULTICAST;
4297 if (!ill->ill_isv6)
4298 ill->ill_ipif->ipif_flags |= IPIF_BROADCAST;
4302 if (ill->ill_mactype == SUNW_DL_IPMP)
4303 ASSERT(ill->ill_phyint->phyint_flags & PHYI_IPMP);
4306 ill->ill_flags &= ~ILLF_COS_ENABLED;
4315 ill->ill_flags |= ILLF_COS_ENABLED;
4319 ill->ill_error = 0;
4407 * The ipif must be up, and its ill must multicast-capable, not
4422 ill_t *ill;
4430 ill = ILL_START_WALK_V6(&ctx, ipst);
4432 ill = ILL_START_WALK_V4(&ctx, ipst);
4434 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4435 mutex_enter(&ill->ill_lock);
4436 if (IS_VNI(ill) || IS_UNDER_IPMP(ill) ||
4437 ILL_IS_CONDEMNED(ill) ||
4438 !(ill->ill_flags & ILLF_MULTICAST)) {
4439 mutex_exit(&ill->ill_lock);
4442 for (ipif = ill->ill_ipif; ipif != NULL;
4466 * belong to the same ill, we've done
4470 if (dep_ipif->ipif_ill != ill)
4480 if (saved_ipif->ipif_ill != ill)
4487 * Before going to the next ill, do a ipif_refhold() on the
4490 if (saved_ipif != NULL && saved_ipif->ipif_ill == ill)
4492 if (dep_ipif != NULL && dep_ipif->ipif_ill == ill)
4494 mutex_exit(&ill->ill_lock);
4522 ill_t *ill;
4528 ill = ipif->ipif_ill;
4529 ill_refhold(ill);
4531 return (ill);
4553 ill_t *ill;
4555 ill = ire_lookup_multi_ill_v4(group, zoneid, ipst, multirtp, setsrcp);
4556 if (ill != NULL)
4557 return (ill);
4570 ill_t *ill;
4580 ill = ILL_START_WALK_V4(&ctx, ipst);
4581 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4582 mutex_enter(&ill->ill_lock);
4583 for (ipif = ill->ill_ipif; ipif != NULL;
4591 mutex_exit(&ill->ill_lock);
4597 mutex_exit(&ill->ill_lock);
4615 ill_t *ill;
4627 ill = ILL_START_WALK_V4(&ctx, ipst);
4628 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4629 if (match_ill != NULL && ill != match_ill &&
4630 (!match_illgrp || !IS_IN_SAME_ILLGRP(ill, match_ill))) {
4633 mutex_enter(&ill->ill_lock);
4634 for (ipif = ill->ill_ipif; ipif != NULL;
4651 mutex_exit(&ill->ill_lock);
4657 mutex_exit(&ill->ill_lock);
4673 * `match_ill' argument is non-NULL, the lookup is restricted to that ill
4717 * ill (or illgrp if `match_ill' is in an IPMP group).
4725 ill_t *ill;
4735 ill = ILL_START_WALK_V4(&ctx, ipst);
4736 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4737 if (match_ill != NULL && ill != match_ill &&
4738 !IS_IN_SAME_ILLGRP(ill, match_ill)) {
4741 mutex_enter(&ill->ill_lock);
4742 for (ipif = ill->ill_ipif; ipif != NULL;
4751 mutex_exit(&ill->ill_lock);
4763 mutex_exit(&ill->ill_lock);
4786 ipif_lookup_remote(ill_t *ill, ipaddr_t addr, zoneid_t zoneid)
4790 ASSERT(!ill->ill_isv6);
4799 mutex_enter(&ill->ill_lock);
4800 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4812 mutex_exit(&ill->ill_lock);
4817 mutex_exit(&ill->ill_lock);
4821 mutex_exit(&ill->ill_lock);
4828 ipif = ipif_get_next_ipif(NULL, ill);
4835 * can be used to determine whether the ill has become quiescent
4838 ill_is_quiescent(ill_t *ill)
4842 ASSERT(MUTEX_HELD(&ill->ill_lock));
4844 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4848 if (!ILL_DOWN_OK(ill) || ill->ill_refcnt != 0) {
4855 ill_is_freeable(ill_t *ill)
4859 ASSERT(MUTEX_HELD(&ill->ill_lock));
4861 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4866 if (!ILL_FREE_OK(ill) || ill->ill_refcnt != 0) {
4880 ill_t *ill;
4887 ill = ipif->ipif_ill;
4888 if (ill->ill_ipif_up_count != 0 || ill->ill_ipif_dup_count != 0 ||
4889 ill->ill_logical_down) {
4893 /* This is the last ipif going down or being deleted on this ill */
4894 if (ill->ill_ire_cnt != 0 || ill->ill_refcnt != 0) {
4914 * The ipif/ill/ire has been refreled. Do the tail processing.
4915 * Determine if the ipif or ill in question has become quiescent and if so
4920 ipif_ill_refrele_tail(ill_t *ill)
4929 ASSERT(MUTEX_HELD(&ill->ill_lock));
4931 if ((ill->ill_state_flags & ILL_CONDEMNED) && ill_is_freeable(ill)) {
4933 cv_broadcast(&ill->ill_cv);
4936 ipsq = ill->ill_phyint->phyint_ipsq;
4946 if (ipif->ipif_ill != ill) /* wait is for another ill; bail */
4959 if (!ill_is_quiescent(ill))
4964 * ILL_FREE is only for loopback; normal ill teardown waits
4968 if (!ill_is_freeable(ill))
4976 ill_refhold_locked(ill); /* for qwriter_ip() call below */
4980 mutex_exit(&ill->ill_lock);
4999 qwriter_ip(ill, ill->ill_rq, mp,
5003 qwriter_ip(ill, ill->ill_rq, mp,
5008 ill_refrele(ill);
5014 qwriter_ip(ill, ill->ill_rq, mp, ipif_all_down_tail, CUR_OP,
5020 qwriter_ip(ill, (connp != NULL ? CONNP_TO_WQ(connp) :
5021 ill->ill_wq), mp, ip_reprocess_ioctl, CUR_OP, B_TRUE);
5032 mutex_exit(&ill->ill_lock);
5228 ill_trace_ref(ill_t *ill)
5230 ASSERT(MUTEX_HELD(&ill->ill_lock));
5232 if (ill->ill_trace_disable)
5235 if (!th_trace_ref(ill, ill->ill_ipst)) {
5236 ill->ill_trace_disable = B_TRUE;
5237 ill_trace_cleanup(ill);
5242 ill_untrace_ref(ill_t *ill)
5244 ASSERT(MUTEX_HELD(&ill->ill_lock));
5246 if (!ill->ill_trace_disable)
5247 th_trace_unref(ill);
5261 * Called when ill is unplumbed or when memory alloc fails. Note that on
5265 ill_trace_cleanup(const ill_t *ill)
5267 th_trace_cleanup(ill, ill->ill_trace_disable);
5282 ill_t *ill;
5284 ill = ipif->ipif_ill;
5285 mutex_enter(&ill->ill_lock);
5288 mutex_exit(&ill->ill_lock);
5300 ill_t *ill;
5302 ill = ipif->ipif_ill;
5304 mutex_enter(&ill->ill_lock);
5309 mutex_exit(&ill->ill_lock);
5314 ipif_ill_refrele_tail(ill);
5318 ipif_get_next_ipif(ipif_t *curr, ill_t *ill)
5322 mutex_enter(&ill->ill_lock);
5323 for (ipif = (curr == NULL ? ill->ill_ipif : curr->ipif_next);
5328 mutex_exit(&ill->ill_lock);
5331 mutex_exit(&ill->ill_lock);
5356 ip_mcast_mapping(ill_t *ill, uchar_t *addr, uchar_t *hwaddr)
5360 if (ill->ill_net_type == IRE_IF_NORESOLVER)
5365 ipm = ip_m_lookup(ill->ill_mactype);
5367 (ill->ill_isv6 && ipm->ip_m_v6mapping == NULL) ||
5368 (!ill->ill_isv6 && ipm->ip_m_v4mapping == NULL)) {
5369 ip0dbg(("no mapping for ill %s mactype 0x%x\n",
5370 ill->ill_name, ill->ill_mactype));
5373 if (ill->ill_isv6)
5374 (*ipm->ip_m_v6mapping)(ill, addr, hwaddr);
5376 (*ipm->ip_m_v4mapping)(ill, addr, hwaddr);
5402 * ill is passed in to associate it with the correct interface.
5407 ipaddr_t src_addr, int flags, ill_t *ill, ire_t **ire_arg,
5446 * If -ifp was specified we restrict ourselves to the ill, otherwise
5450 if (ill != NULL)
5451 ipif = ipif_lookup_addr(gw_addr, ill, ALL_ZONES, ipst);
5563 * are part of an ill have the same index and so the RTA_IFP sockaddr
5565 * interfaces) that belong to the same ill (physical interface).
5596 * Whether or not ill (RTA_IFP) is set, we require that
5605 * we use the ill derived from the gateway address.
5608 * We don't allow RTA_IFP to specify a different ill than the
5612 if (ill == NULL) {
5613 ill = ipif->ipif_ill;
5614 } else if (ill != ipif->ipif_ill) {
5629 IRE_INTERFACE, ill, ALL_ZONES, NULL, match_flags, 0, ipst,
5644 * If the IRE type (as defined by ill->ill_net_type) would be
5653 type = ill->ill_net_type;
5669 ill,
5713 * If RTA_IFP was specified we look on that particular ill.
5715 if (ill != NULL)
5724 gw_ire = ire_ftable_lookup_v4(gw_addr, 0, 0, type, ill,
5749 if (ill == NULL && !(flags & RTF_INDIRECT)) {
5752 ill = gw_ire->ire_ill;
5771 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
5823 ill,
5938 if (ill != NULL) {
5947 ill_save_ire(ill, ire);
5969 * ill is passed in to associate it with the correct interface.
5974 uint_t rtm_addrs, int flags, ill_t *ill, boolean_t ioctl_msg,
6007 * otherwise we use the ill derived from the gateway address.
6018 if (ill != NULL)
6019 ill_match = ill;
6052 * If an ill was passed in, then the lookup is based on an
6056 if (ill != NULL)
6064 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
6091 ill = ire->ire_ill;
6092 if (ill != NULL)
6093 ill_remove_saved_ire(ill, ire);
6337 * (phyint_free()), or interface plumb for an ill type
6531 ill_t *ill;
6551 ill = phyi->phyint_illv4;
6552 if (ill != NULL &&
6553 (ill->ill_dlpi_pending != DL_PRIM_INVAL ||
6554 ill->ill_arl_dlpi_pending))
6557 ill = phyi->phyint_illv6;
6558 if (ill != NULL &&
6559 ill->ill_dlpi_pending != DL_PRIM_INVAL)
6569 * Enter the ipsq corresponding to ill, by waiting synchronously till
6577 * of an ill can also use this option. But we dont' use it currently.
6581 ipsq_enter(ill_t *ill, boolean_t force, int type)
6586 ip_stack_t *ipst = ill->ill_ipst;
6589 * Note that the relationship between ill and ipsq is fixed as long as
6590 * the ill is not ILL_CONDEMNED. Holding ipsq_lock ensures the
6598 mutex_enter(&ill->ill_lock);
6599 if (ill->ill_state_flags & ILL_CONDEMNED) {
6600 mutex_exit(&ill->ill_lock);
6605 ipsq = ill->ill_phyint->phyint_ipsq;
6620 cv_wait(&ill->ill_cv, &ill->ill_lock);
6624 (void) cv_reltimedwait(&ill->ill_cv,
6625 &ill->ill_lock, ENTER_SQ_WAIT_TICKS, TR_CLOCK_TICK);
6628 mutex_exit(&ill->ill_lock);
6641 mutex_exit(&ill->ill_lock);
6655 ipsq_try_enter_internal(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func,
6660 ip_stack_t *ipst = ill->ill_ipst;
6670 mutex_enter(&ill->ill_lock);
6671 ipsq = ill->ill_phyint->phyint_ipsq;
6698 mutex_exit(&ill->ill_lock);
6707 ipsq_enq(ipsq, q, mp, func, type, ill);
6711 mutex_exit(&ill->ill_lock);
6738 * the ipif/ill/ire refcnts to drop to zero. In such a case the ipx_pending_mp
6746 * Try to enter the IPSQ corresponding to `ipif' or `ill' exclusively (`ipif'
6747 * and `ill' cannot both be specified). Returns a pointer to the entered IPSQ
6748 * on success, or NULL on failure. The caller ensures ipif/ill is valid by
6754 ipsq_try_enter(ipif_t *ipif, ill_t *ill, queue_t *q, mblk_t *mp,
6760 /* Only 1 of ipif or ill can be specified */
6761 ASSERT((ipif != NULL) ^ (ill != NULL));
6764 ill = ipif->ipif_ill;
6765 ipst = ill->ill_ipst;
6768 ipsq = ipsq_try_enter_internal(ill, q, mp, func, type, reentry_ok);
6775 * Try to enter the IPSQ corresponding to `ill' as writer. The caller ensures
6776 * ill is valid by refholding it if necessary; we will refrele. If the IPSQ
6780 qwriter_ip(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func, int type,
6785 ipsq = ipsq_try_enter(NULL, ill, q, mp, func, type, reentry_ok);
6788 * Drop the caller's refhold on the ill. This is safe since we either
6790 * IPSQ, in which case we return without accessing ill anymore. This
6794 ill_refrele(ill);
6850 * If 'q' is an ill queue, it is valid, since close of an
6851 * ill will clean up its IPSQ.
6896 ill_t *ill = ipif->ipif_ill;
6919 * on the ill are marked with IPIF_CHANGING since it's unclear which
6930 mutex_enter(&ill->ill_lock);
6934 mutex_exit(&ill->ill_lock);
6937 mutex_enter(&ill->ill_lock);
6939 mutex_exit(&ill->ill_lock);
6966 ill_t *ill = ipif->ipif_ill;
6968 mutex_enter(&ill->ill_lock);
6969 dlpi_pending = ill->ill_dlpi_pending;
6971 ipif = ill->ill_ipif;
6977 mutex_exit(&ill->ill_lock);
6991 * The ill is closing. Flush all messages on the ipsq that originated
6992 * from this ill. Usually there wont' be any messages on the ipsq_xopq_mphead
6993 * for this ill since ipsq_enter could not have entered until then.
6997 ipsq_flush(ill_t *ill)
7003 ipxop_t *ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
7005 ASSERT(IAM_WRITER_ILL(ill));
7014 if (q == ill->ill_rq || q == ill->ill_wq) {
7030 (void) ipsq_pending_mp_cleanup(ill, NULL);
7031 ipsq_xopq_mp_cleanup(ill, NULL);
7050 ill_t *ill;
7059 ill = (ill_t *)q->q_ptr;
7060 isv6 = ill->ill_isv6;
7063 ipst = ill->ill_ipst;
7065 ill = NULL;
7113 if (ill == NULL) {
7115 * Not an ill queue, return EINVAL same as the
7120 ipif = ill->ill_ipif;
7145 if (ipif == NULL && ill != NULL && ill->ill_ipif != NULL &&
7149 * during plumb (on the ill queue before the I_PLINK).
7151 ipif = ill->ill_ipif;
7172 ill_t *ill;
7177 ill = ILL_START_WALK_V4(&ctx, ipst);
7178 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7179 if (IS_UNDER_IPMP(ill))
7181 for (ipif = ill->ill_ipif; ipif != NULL;
7199 ill_t *ill;
7207 ill = ILL_START_WALK_V4(&ctx, ipst);
7209 ill = ILL_START_WALK_V6(&ctx, ipst);
7211 ill = ILL_START_WALK_ALL(&ctx, ipst);
7213 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7214 if (IS_UNDER_IPMP(ill) && !(lifn_flags & LIFC_UNDER_IPMP))
7217 for (ipif = ill->ill_ipif; ipif != NULL;
7228 IS_LOOPBACK(ill) ||
7247 ip_get_lifsrcofnum(ill_t *ill)
7250 ill_t *ill_head = ill;
7251 ip_stack_t *ipst = ill->ill_ipst;
7259 if ((ill->ill_usesrc_ifindex == 0) &&
7260 (ill->ill_usesrc_grp_next != NULL)) {
7261 for (; (ill != NULL) && (ill->ill_usesrc_grp_next != ill_head);
7262 ill = ill->ill_usesrc_grp_next)
7331 ill_t *ill;
7423 ill = ILL_START_WALK_V4(&ctx, ipst);
7424 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7425 if (IS_UNDER_IPMP(ill))
7427 for (ipif = ill->ill_ipif; ipif != NULL;
7471 ill_t *ill, *ill_head;
7538 ill = ill_head = ipif->ipif_ill;
7545 ill = ill->ill_usesrc_grp_next; /* start from next ill */
7546 for (; (ill != NULL) && (ill != ill_head);
7547 ill = ill->ill_usesrc_grp_next) {
7552 ipif = ill->ill_ipif;
7587 ill_t *ill;
7692 ill = ill_first(list, list, &ctx, ipst);
7693 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7694 if (IS_UNDER_IPMP(ill) && !(flags & LIFC_UNDER_IPMP))
7697 for (ipif = ill->ill_ipif; ipif != NULL;
7710 IS_LOOPBACK(ill) ||
7732 lifr->lifr_type = ill->ill_type;
7957 /* With ipmp we most likely look at the ipmp ill here */
8185 ill_t *ill = ipif->ipif_ill;
8210 alength = ill->ill_phys_addr_length;
8238 (alength != ill->ill_phys_addr_length)) {
8265 if (IS_UNDER_IPMP(ill)) {
8269 if (IS_IPMP(ill)) {
8270 ipmp_illgrp_t *illg = ill->ill_grp;
8290 * XXX use IS_IPMP(ill) like ndp_sioc_update?
8292 nce = nce_lookup_v4(ill, &ipaddr);
8352 ipif_t *ipif = ipif_get_next_ipif(NULL, ill);
8367 err = nce_lookup_then_add_v4(ill, lladdr,
8368 ill->ill_phys_addr_length, &ipaddr, flags, ND_UNCHANGED,
8383 if (IS_IPMP(ill) && err == 0) {
8384 entp = ipmp_illgrp_create_arpent(ill->ill_grp,
8385 proxyarp, ipaddr, lladdr, ill->ill_phys_addr_length,
8403 ipmp_illgrp_mark_arpent(ill->ill_grp, entp);
8421 ill_t *ill = NULL;
8470 * find the wrong ill, so we first do an ipif_lookup_addr().
8478 if (ire == NULL || ((ill = ire->ire_ill) == NULL)) {
8483 ASSERT(ire != NULL && ill != NULL);
8484 ipif = ill->ill_ipif;
8501 * Link or unlink the illgrp on IPMP meta-interface `ill' depending on the
8504 * up and thus an ill can join that illgrp.
8520 ip_sioctl_plink_ipmp(ill_t *ill, int ioccmd)
8523 ip_stack_t *ipst = ill->ill_ipst;
8525 ASSERT(IS_IPMP(ill));
8526 ASSERT(IAM_WRITER_ILL(ill));
8534 ipmp_illgrp_link_grp(ill->ill_grp, ill->ill_phyint->phyint_grp);
8543 if (ill->ill_ipif_up_count + ill->ill_ipif_dup_count > 0)
8548 * with an SIOCSLIFGROUPNAME request from an ill trying to
8560 err = ipmp_illgrp_unlink_grp(ill->ill_grp);
8621 ill_t *ill;
8658 ill = arl_to_ill(arl);
8659 if (ill == NULL)
8662 ill = ipwq->q_ptr;
8664 ASSERT(ill != NULL);
8667 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink,
8671 ill_refrele(ill);
8676 ASSERT(IAM_WRITER_ILL(ill));
8677 mutex_enter(&ill->ill_lock);
8679 if (islink && ill->ill_muxid == 0) {
8684 mutex_exit(&ill->ill_lock);
8687 ill_refrele(ill);
8691 mutex_exit(&ill->ill_lock);
8694 ill_refrele(ill);
8698 if (IS_IPMP(ill) && (err = ip_sioctl_plink_ipmp(ill, ioccmd)) != 0)
8703 * the read queue of the module immediately below IP in the ill.
8706 ill->ill_lmod_rq = NULL;
8707 ill->ill_lmod_cnt = 0;
8709 ill->ill_lmod_rq = RD(dwq);
8711 ill->ill_lmod_cnt++;
8714 ill->ill_muxid = islink ? li->l_index : 0;
8722 ipsq_current_start(ipsq, ill->ill_ipif, ioccmd);
8724 * If there's at least one up ipif on this ill, then we're bound to
8729 if (ill->ill_ipif_up_count > 0) {
8731 ill_capability_probe(ill);
8733 ill_capability_reset(ill, B_FALSE);
9207 ip_sioctl_garp_reply(mblk_t *mp, ill_t *ill, void *hwaddr, int flags)
9217 ASSERT(ill != NULL);
9239 storage += ill_xarp_info(&xar->xarp_ha, ill);
9240 if ((ill->ill_phys_addr_length + ill->ill_name_length) >
9260 bcopy((char *)hwaddr, storage, ill->ill_phys_addr_length);
9276 * Executed as a writer on the ill.
9296 ill_t *ill;
9342 ill = ipif->ipif_ill;
9343 ill_refhold(ill);
9371 ill = ill_lookup_on_name(name, B_FALSE, isv6, NULL, ipst);
9374 if (ill == NULL)
9378 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_process_ioctl, NEW_OP,
9385 ill_refrele(ill);
9391 ASSERT(IAM_WRITER_ILL(ill));
9395 for (ipif = ill->ill_ipif; ipif != NULL;
9409 if ((ipif = ipif_allocate(ill, found_sep ? id : -1, IRE_LOCAL,
9415 (void) sprintf(lifr->lifr_name, "%s%c%d", ill->ill_name,
9443 ill_t *ill = ipif->ipif_ill;
9451 ill->ill_name, ipif->ipif_id, (void *)ipif));
9467 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9471 * Mark it condemned. No new ref. will be made to ill.
9473 mutex_enter(&ill->ill_lock);
9474 ill->ill_state_flags |= ILL_CONDEMNED;
9475 for (ipif = ill->ill_ipif; ipif != NULL;
9479 mutex_exit(&ill->ill_lock);
9481 ipif = ill->ill_ipif;
9483 ill_delete(ill);
9485 mutex_enter(&ill->ill_lock);
9487 /* Are any references to this ill active */
9488 if (ill_is_freeable(ill)) {
9489 mutex_exit(&ill->ill_lock);
9491 ill_delete_tail(ill);
9492 mi_free(ill);
9498 mutex_exit(&ill->ill_lock);
9518 ipif = ipif_lookup_addr_exact_v6(&sin6->sin6_addr, ill,
9525 ipif = ipif_lookup_addr_exact(sin->sin_addr.s_addr, ill,
9547 * Can not delete instance zero since it is tied to the ill.
9552 mutex_enter(&ill->ill_lock);
9554 mutex_exit(&ill->ill_lock);
9559 mutex_enter(&ill->ill_lock);
9563 mutex_exit(&ill->ill_lock);
9572 mutex_exit(&ill->ill_lock);
9589 ill_t *ill = ipif->ipif_ill;
9595 ill->ill_name, ipif->ipif_id, (void *)ipif));
9597 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9598 ASSERT(ill->ill_state_flags & ILL_CONDEMNED);
9599 ill_delete_tail(ill);
9600 mi_free(ill);
9622 ill_t *ill;
9638 ill = ipif->ipif_ill;
9641 IN6_IS_ADDR_UNSPECIFIED(&ill->ill_token))
9645 sin6->sin6_addr.s6_addr32[i] |= ill->ill_token.s6_addr32[i];
9678 ill_t *ill;
9686 ill = ipif->ipif_ill;
9696 phyi = ill->ill_phyint;
9708 (ill->ill_flags & ILLF_MULTICAST) &&
9715 * this ill, allow setting :: as the address on ipif:0.
9717 if (ill->ill_flags & ILLF_NOLINKLOCAL) {
9758 if (ill->ill_allowed_ips_cnt > 0) {
9759 for (i = 0; i < ill->ill_allowed_ips_cnt; i++) {
9760 if (IN6_ARE_ADDR_EQUAL(&ill->ill_allowed_ips[i],
9764 if (i == ill->ill_allowed_ips_cnt) {
9806 ill_t *ill = ipif->ipif_ill;
9814 ill->ill_name, ipif->ipif_id, (void *)ipif));
9831 mutex_enter(&ill->ill_lock);
9852 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
9853 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
9862 * tag the ill so that future updates to the interface ID don't result
9869 ill->ill_manual_linklocal = 1;
9881 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ipif->ipif_id),
9885 mutex_exit(&ill->ill_lock);
9898 /* Perhaps ilgs should use this ill */
9899 update_conn_ill(NULL, ill->ill_ipst);
9903 ill_dl_down(ill);
9905 if (need_arp_down && !ill->ill_isv6)
9912 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
10041 ill_t *ill = ipif->ipif_ill;
10046 ip1dbg(("ip_sioctl_dstaddr_tail(%s:%u %p)\n", ill->ill_name,
10065 mutex_enter(&ill->ill_lock);
10077 ill->ill_flags |= ILLF_NONUD;
10091 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
10092 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
10099 * (0th ipif), tag the ill so that future updates to the destination
10105 ill->ill_manual_dst_linklocal = 1;
10111 mutex_exit(&ill->ill_lock);
10126 ill_dl_down(ill);
10188 ill_t *ill = ipif->ipif_ill;
10189 phyint_t *phyi = ill->ill_phyint;
10193 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10195 if (IS_IPMP(ill))
10226 ill_t *ill;
10240 ill = ipif->ipif_ill;
10241 phyi = ill->ill_phyint;
10251 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10257 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10271 if (IS_IPMP(ill) && ((flags ^ intf_flags) & IFF_IPMP_INVALID))
10321 if (IS_UNDER_IPMP(ill)) {
10369 * IPv4 ill, and another for the IPv6 ill). Note that here.
10388 if (ill->ill_usesrc_grp_next != NULL ||
10415 err = ill_forward_set(ill, ((turn_on & ILLF_ROUTER) != 0));
10429 mutex_enter(&ill->ill_lock);
10430 mutex_enter(&ill->ill_phyint->phyint_lock);
10433 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10434 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10437 mutex_exit(&ill->ill_lock);
10438 mutex_exit(&ill->ill_phyint->phyint_lock);
10447 ASSERT(!IS_IPMP(ill));
10449 * It's possible the ill is part of an "anonymous"
10454 if (IS_UNDER_IPMP(ill))
10469 ire_increment_multicast_generation(ill->ill_ipst,
10470 ill->ill_isv6);
10474 mutex_enter(&ill->ill_lock);
10477 mutex_exit(&ill->ill_lock);
10536 ill->ill_logical_down = 1;
10546 * If we can quiesce the ill, then continue. If not, then
10550 ill_down_ipifs(ill, B_TRUE);
10553 mutex_enter(&ill->ill_lock);
10554 if (!ill_is_quiescent(ill)) {
10557 success = ipsq_pending_mp_add(connp, ill->ill_ipif,
10559 mutex_exit(&ill->ill_lock);
10563 mutex_exit(&ill->ill_lock);
10572 ill_t *ill;
10584 ill = ipif->ipif_ill;
10585 phyi = ill->ill_phyint;
10602 mutex_enter(&ill->ill_lock);
10606 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10607 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10615 mutex_exit(&ill->ill_lock);
10627 ASSERT(!IS_IPMP(ill));
10629 * It's possible the ill is part of an "anonymous" IPMP group
10634 if (IS_UNDER_IPMP(ill))
10647 err = ill_up_ipifs(ill, q, mp);
10682 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
10731 ill_t *ill = ipif->ipif_ill;
10732 phyint_t *phyi = ill->ill_phyint;
10737 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10744 mutex_enter(&ill->ill_lock);
10750 ill->ill_flags | phyi->phyint_flags) & 0xffff);
10756 ill->ill_flags | phyi->phyint_flags;
10758 mutex_exit(&ill->ill_lock);
10775 ill_t *ill;
10790 ill = ipif->ipif_ill;
10796 mutex_enter(&ill->ill_lock);
10797 if (mtu > ill->ill_max_frag || mtu < ip_min_mtu) {
10798 mutex_exit(&ill->ill_lock);
10802 if (ill->ill_mc_mtu > mtu)
10803 ill->ill_mc_mtu = mtu;
10809 ill->ill_mtu = mtu;
10810 ill->ill_flags |= ILLF_FIXEDMTU;
10811 mutex_exit(&ill->ill_lock);
10817 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
10822 if (IS_UNDER_IPMP(ill))
10823 ipmp_illgrp_refresh_mtu(ill->ill_grp);
10864 ill_t *ill = ipif->ipif_ill;
10865 ip_stack_t *ipst = ill->ill_ipst;
10867 ip1dbg(("ip_sioctl_brdaddr(%s:%u)\n", ill->ill_name,
10888 ill, ipif->ipif_zoneid, NULL,
11172 * Get the muxid saved in ill for I_PUNLINK.
11266 ill_t *ill = ipif->ipif_ill;
11273 mutex_enter(&ill->ill_lock);
11279 mutex_exit(&ill->ill_lock);
11364 ill_t *ill = ipif->ipif_ill;
11402 if (V6_MASK_EQ(v6addr, v6mask, ill->ill_token) &&
11403 ill->ill_token_length == addrlen)
11423 ill_t *ill = ipif->ipif_ill;
11439 mutex_enter(&ill->ill_lock);
11440 V6_MASK_COPY(v6addr, v6mask, ill->ill_token);
11441 ill->ill_token_length = addrlen;
11442 ill->ill_manual_token = 1;
11445 ipif_setlinklocal(ill->ill_ipif);
11447 mutex_exit(&ill->ill_lock);
11470 ill_t *ill;
11479 ill = ipif->ipif_ill;
11480 if (!ill->ill_isv6)
11485 ASSERT(!IN6_IS_ADDR_V4MAPPED(&ill->ill_token));
11486 sin6->sin6_addr = ill->ill_token;
11487 lifr->lifr_addrlen = ill->ill_token_length;
11500 ill_t *ill = ipif->ipif_ill;
11536 (lir->lir_maxmtu > ill->ill_current_frag ||
11546 mutex_enter(&ill->ill_lock);
11552 ill->ill_user_mtu = lir->lir_maxmtu;
11555 ill->ill_reachable_time = lir->lir_reachtime;
11558 ill->ill_reachable_retrans_time = lir->lir_reachretrans;
11560 ill->ill_max_hops = lir->lir_maxhops;
11561 ill->ill_max_buf = ND_MAX_Q;
11562 if (!(ill->ill_flags & ILLF_FIXEDMTU) && ill->ill_user_mtu != 0) {
11572 ill->ill_mtu = MIN(ill->ill_current_frag, ill->ill_user_mtu);
11573 ill->ill_mc_mtu = MIN(ill->ill_mc_mtu, ill->ill_user_mtu);
11575 mutex_exit(&ill->ill_lock);
11581 if (!(ill->ill_flags & ILLF_FIXEDMTU) && (lir->lir_maxmtu != 0))
11582 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
11587 if (IS_UNDER_IPMP(ill))
11588 ipmp_illgrp_refresh_mtu(ill->ill_grp);
11599 ill_t *ill = ipif->ipif_ill;
11607 lir->lir_maxhops = ill->ill_max_hops;
11608 lir->lir_reachtime = ill->ill_reachable_time;
11609 lir->lir_reachretrans = ill->ill_reachable_retrans_time;
11610 lir->lir_maxmtu = ill->ill_mtu;
11626 ill_t *ill;
11640 ill = ILL_START_WALK_V4(&ctx, ipst);
11641 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
11642 mutex_enter(&ill->ill_lock);
11643 for (ipif = ill->ill_ipif; ipif != NULL;
11668 mutex_exit(&ill->ill_lock);
11676 mutex_exit(&ill->ill_lock);
11774 * Note: remove if sctp_addr.c is redone to not shadow ill/ipif data structures.
11864 is_lifname_valid(ill_t *ill, unsigned int ipif_id)
11866 if (snprintf(NULL, 0, "%s:%d", ill->ill_name, ipif_id) >= LIFNAMSIZ)
11869 if (ipif_id >= ill->ill_ipst->ips_ip_addrs_per_if)
11875 * Insert the ipif, so that the list of ipifs on the ill will be sorted
11883 ill_t *ill;
11892 ill = ipif->ipif_ill;
11893 ASSERT(ill != NULL);
11894 ipst = ill->ill_ipst;
11903 mutex_enter(&ill->ill_lock);
11905 tipifp = &(ill->ill_ipif);
11915 if ((err = is_lifname_valid(ill, id)) != 0) {
11916 mutex_exit(&ill->ill_lock);
11922 } else if ((err = is_lifname_valid(ill, id)) == 0) {
11931 mutex_exit(&ill->ill_lock);
11937 ASSERT(tipifp != &(ill->ill_ipif) || id == 0);
11941 mutex_exit(&ill->ill_lock);
11952 ill_t *ill = ipif->ipif_ill;
11954 ASSERT(RW_WRITE_HELD(&ill->ill_ipst->ips_ill_g_lock));
11956 mutex_enter(&ill->ill_lock);
11957 ipifp = &ill->ill_ipif;
11964 mutex_exit(&ill->ill_lock);
11970 * When ipif_allocate() is called from ip_ll_subnet_defaults, the ill
11973 * when ill becomes part of the global list. At that point ill will
11983 ipif_allocate(ill_t *ill, int id, uint_t ire_type, boolean_t initialize,
11988 ip_stack_t *ipst = ill->ill_ipst;
11990 ip1dbg(("ipif_allocate(%s:%d ill %p)\n",
11991 ill->ill_name, id, (void *)ill));
11992 ASSERT(ire_type == IRE_LOOPBACK || IAM_WRITER_ILL(ill));
12004 ipif->ipif_ill = ill;
12007 * Inherit the zoneid from the ill; for the shared stack instance
12010 ipif->ipif_zoneid = ill->ill_zoneid;
12026 if (ill->ill_name[0] != '\0')
12030 * If this is the zeroth ipif on the IPMP ill, create the illgrp
12032 * per ill). However, do not not link it to the ipmp_grp_t until
12035 if (id == 0 && IS_IPMP(ill)) {
12036 if (ipmp_illgrp_create(ill) == NULL) {
12054 mutex_enter(&ill->ill_lock);
12059 ill->ill_flags |= ILLF_IPV6;
12063 ill->ill_flags |= ILLF_IPV4;
12091 if (ill->ill_bcast_addr_length != 0 || IS_IPMP(ill)) {
12096 ill->ill_flags |= ILLF_MULTICAST;
12100 if (ill->ill_net_type != IRE_LOOPBACK) {
12109 ill->ill_flags |= ILLF_NONUD;
12111 ill->ill_flags |= ILLF_NOARP;
12113 if (ill->ill_phys_addr_length == 0) {
12114 if (IS_VNI(ill)) {
12118 ill->ill_flags |= ILLF_MULTICAST;
12119 if (ill->ill_net_type != IRE_LOOPBACK)
12125 mutex_exit(&ill->ill_lock);
12136 ill_t *ill = ipif->ipif_ill;
12139 ip1dbg(("ipif_arp_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
12143 ill_t *, ill, ipif_t *, ipif);
12151 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
12152 !ill->ill_logical_down && ill->ill_net_type == IRE_IF_RESOLVER) {
12157 if (IS_IPMP(ill))
12158 ipmp_illgrp_refresh_arpent(ill->ill_grp);
12161 err = arp_ll_down(ill);
12185 ill_t *ill = ipif->ipif_ill;
12190 ill->ill_name, ipif->ipif_id, (uint_t)ipif->ipif_flags));
12200 mutex_enter(&ill->ill_lock);
12203 ill->ill_ipif_dup_count--;
12206 mutex_exit(&ill->ill_lock);
12211 if (ill->ill_net_type != IRE_IF_RESOLVER) {
12216 if (ill->ill_isv6)
12231 ill_t *ill = ipif->ipif_ill;
12232 boolean_t isv6 = ill->ill_isv6;
12240 if (ill->ill_net_type != IRE_IF_RESOLVER ||
12277 * Restart duplicate address detection on all interfaces on the given ill.
12288 ill_restart_dad(ill_t *ill, boolean_t went_up)
12292 if (ill == NULL)
12299 if (!ill->ill_isv6 && arp_no_defense) {
12300 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12304 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12317 * and represents the underlying ill in the
12325 if (ipif == ill->ill_ipif) {
12326 ip_rts_ifmsg(ill->ill_ipif,
12344 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12361 ill_up_ipifs_on_ill(ill_t *ill, queue_t *q, mblk_t *mp)
12366 if (ill == NULL)
12369 ASSERT(IAM_WRITER_ILL(ill));
12370 ill->ill_up_ipifs = B_TRUE;
12371 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12382 ill->ill_up_ipifs = B_FALSE;
12388 * bringing the ill down via ill_down_ipifs().
12391 ill_up_ipifs(ill_t *ill, queue_t *q, mblk_t *mp)
12395 ASSERT(IAM_WRITER_ILL(ill));
12397 if (ill->ill_replumbing) {
12398 ill->ill_replumbing = 0;
12403 if (!ill->ill_isv6)
12404 arp_send_replumb_conf(ill);
12406 err = ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv4, q, mp);
12410 return (ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv6, q, mp));
12414 * Bring down any IPIF_UP ipifs on ill. If "logical" is B_TRUE, we bring
12418 ill_down_ipifs(ill_t *ill, boolean_t logical)
12422 ASSERT(IAM_WRITER_ILL(ill));
12424 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12466 ill_t *ill = q->q_ptr;
12467 phyint_t *phyi = ill->ill_phyint;
12469 ip_stack_t *ipst = ill->ill_ipst;
12472 ASSERT(!IS_IPMP(ill) && grp != NULL);
12499 ill_t *ill = ipif->ipif_ill;
12500 ip_stack_t *ipst = ill->ill_ipst;
12501 phyint_t *phyi = ill->ill_phyint;
12509 ASSERT(IAM_WRITER_ILL(ill));
12511 if (ipif->ipif_id != 0 || ill->ill_usesrc_grp_next != NULL ||
12533 if (IS_IPMP(ill)) {
12547 if (IS_UNDER_IPMP(ill)) {
12591 ill_refhold(ill);
12592 qwriter_ip(ill, ill->ill_rq, ipsq_mp, ip_join_illgrps,
12601 if (IS_UNDER_IPMP(ill))
12618 ill_t *ill;
12626 if ((ill = ipif->ipif_bound_ill) == NULL)
12629 (void) strlcpy(lifr->lifr_binding, ill->ill_name, LIFNAMSIZ);
12682 ill_dl_down(ill_t *ill)
12684 DTRACE_PROBE2(ill__downup, char *, "ill_dl_down", ill_t *, ill);
12687 * The ill is down; unbind but stay attached since we're still
12695 mblk_t *mp = ill->ill_unbind_mp;
12697 ip1dbg(("ill_dl_down(%s)\n", ill->ill_name));
12699 if (!ill->ill_replumbing) {
12700 /* Free all ilms for this ill */
12701 update_conn_ill(ill, ill->ill_ipst);
12703 ill_leave_multicast(ill);
12706 ill->ill_unbind_mp = NULL;
12710 ill->ill_name));
12711 mutex_enter(&ill->ill_lock);
12712 ill->ill_state_flags |= ILL_DL_UNBIND_IN_PROGRESS;
12713 mutex_exit(&ill->ill_lock);
12725 if (ill->ill_state_flags & ILL_CONDEMNED)
12726 ill_capability_dld_disable(ill);
12727 ill_capability_reset(ill, B_FALSE);
12728 ill_dlpi_send(ill, mp);
12730 mutex_enter(&ill->ill_lock);
12731 ill->ill_dl_up = 0;
12732 ill_nic_event_dispatch(ill, 0, NE_DOWN, NULL, 0);
12733 mutex_exit(&ill->ill_lock);
12737 ill_dlpi_dispatch(ill_t *ill, mblk_t *mp)
12749 dl_primstr(prim), prim, ill->ill_name));
12755 ill->ill_phys_addr_pend = dlpap->dl_addr_type;
12759 mutex_enter(&ill->ill_lock);
12760 ill->ill_state_flags &= ~ILL_DL_UNBIND_IN_PROGRESS;
12761 mutex_exit(&ill->ill_lock);
12770 mutex_enter(&ill->ill_lock);
12771 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
12773 ill->ill_dlpi_pending = prim;
12777 mutex_exit(&ill->ill_lock);
12779 char *, dl_primstr(prim), ill_t *, ill);
12780 putnext(ill->ill_wq, mp);
12786 ill_dlpi_done(ill, prim);
12806 ill_dlpi_send(ill_t *ill, mblk_t *mp)
12817 if (!IAM_WRITER_ILL(ill)) {
12818 ill_refhold(ill);
12820 qwriter_ip(ill, ill->ill_wq, mp, ill_dlpi_send_writer,
12825 mutex_enter(&ill->ill_lock);
12826 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
12828 mpp = &ill->ill_dlpi_deferred;
12833 "while %s pending\n", ill->ill_name,
12834 dl_primstr(ill->ill_dlpi_pending)));
12837 mutex_exit(&ill->ill_lock);
12840 mutex_exit(&ill->ill_lock);
12841 ill_dlpi_dispatch(ill, mp);
12845 ill_capability_send(ill_t *ill, mblk_t *mp)
12847 ill->ill_capab_pending_cnt++;
12848 ill_dlpi_send(ill, mp);
12852 ill_capability_done(ill_t *ill)
12854 ASSERT(ill->ill_capab_pending_cnt != 0);
12856 ill_dlpi_done(ill, DL_CAPABILITY_REQ);
12858 ill->ill_capab_pending_cnt--;
12859 if (ill->ill_capab_pending_cnt == 0 &&
12860 ill->ill_dlpi_capab_state == IDCS_OK)
12861 ill_capability_reset_alloc(ill);
12868 ill_dlpi_send_deferred(ill_t *ill)
12876 mutex_enter(&ill->ill_lock);
12877 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12878 mp = ill->ill_dlpi_deferred;
12879 ill->ill_dlpi_deferred = NULL;
12880 mutex_exit(&ill->ill_lock);
12885 ill_dlpi_send(ill, mp);
12894 ill_dlpi_clear_deferred(ill_t *ill)
12898 mutex_enter(&ill->ill_lock);
12899 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12900 mp = ill->ill_dlpi_deferred;
12901 ill->ill_dlpi_deferred = NULL;
12902 mutex_exit(&ill->ill_lock);
12914 ill_dlpi_pending(ill_t *ill, t_uscalar_t prim)
12918 mutex_enter(&ill->ill_lock);
12919 if (ill->ill_dlpi_pending == prim) {
12920 mutex_exit(&ill->ill_lock);
12928 if (ill->ill_state_flags & ILL_CONDEMNED) {
12929 mutex_exit(&ill->ill_lock);
12932 pending = ill->ill_dlpi_pending;
12933 mutex_exit(&ill->ill_lock);
12936 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12938 dl_primstr(prim), ill->ill_name);
12940 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12942 dl_primstr(prim), ill->ill_name, dl_primstr(pending));
12948 * Complete the current DLPI operation associated with `prim' on `ill' and
12950 * operations and the ill's current exclusive IPSQ operation has finished
12956 ill_dlpi_done(ill_t *ill, t_uscalar_t prim)
12959 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
12963 mutex_enter(&ill->ill_lock);
12966 ASSERT(ill->ill_dlpi_pending == prim);
12968 ip1dbg(("ill_dlpi_done: %s has completed %s (%u)\n", ill->ill_name,
12969 dl_primstr(ill->ill_dlpi_pending), ill->ill_dlpi_pending));
12971 if ((mp = ill->ill_dlpi_deferred) == NULL) {
12972 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12978 cv_signal(&ill->ill_cv);
12979 mutex_exit(&ill->ill_lock);
12983 ill->ill_dlpi_deferred = mp->b_next;
12985 mutex_exit(&ill->ill_lock);
12987 ill_dlpi_dispatch(ill, mp);
13000 ill_dlpi_queue(ill_t *ill, mblk_t *mp)
13006 mutex_enter(&ill->ill_lock);
13008 mpp = &ill->ill_dlpi_deferred;
13013 mutex_exit(&ill->ill_lock);
13020 * For IPMP we are called on the upper ill, but when send what is queued
13024 ill_dlpi_send_queued(ill_t *ill)
13031 if (IS_IPMP(ill)) {
13032 /* On the upper IPMP ill. */
13033 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13038 ill = release_ill;
13040 mutex_enter(&ill->ill_lock);
13041 while ((mp = ill->ill_dlpi_deferred) != NULL) {
13042 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
13044 mutex_exit(&ill->ill_lock);
13047 ill->ill_dlpi_deferred = mp->b_next;
13049 if (!ill->ill_dl_up) {
13061 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
13063 ill->ill_dlpi_pending = prim;
13065 mutex_exit(&ill->ill_lock);
13068 char *, dl_primstr(prim), ill_t *, ill);
13069 putnext(ill->ill_wq, mp);
13070 mutex_enter(&ill->ill_lock);
13072 mutex_exit(&ill->ill_lock);
13085 * For IPMP we are called on the upper ill, but we queue on the cast_ill.
13088 ill_mcast_queue(ill_t *ill, mblk_t *mp)
13093 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
13095 if (IS_IPMP(ill)) {
13096 /* On the upper IPMP ill. */
13097 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13100 BUMP_MIB(ill->ill_ip_mib, ipIfStatsOutDiscards);
13102 mp, ill);
13106 ill = release_ill;
13109 mutex_enter(&ill->ill_lock);
13111 mpp = &ill->ill_mcast_deferred;
13116 mutex_exit(&ill->ill_lock);
13125 * For IPMP we are called on the upper ill, but when send what is queued
13131 * on the same group for multiple ipif's on the same ill. The
13136 * by IPMP. We do this by passing an ill to ip_output_simple.
13139 ill_mcast_send_queued(ill_t *ill)
13145 if (IS_IPMP(ill)) {
13146 /* On the upper IPMP ill. */
13147 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13155 ill = release_ill;
13163 * Here we set ixa_ifindex. If IPMP it will be the lower ill which
13167 ixas.ixa_ifindex = ill->ill_phyint->phyint_ifindex;
13168 ixas.ixa_ipst = ill->ill_ipst;
13170 mutex_enter(&ill->ill_lock);
13171 while ((mp = ill->ill_mcast_deferred) != NULL) {
13172 ill->ill_mcast_deferred = mp->b_next;
13174 if (!ill->ill_dl_up) {
13182 mutex_enter(&ill->ill_phyint->phyint_lock);
13183 if (IS_UNDER_IPMP(ill) && !ipmp_ill_is_active(ill)) {
13185 * When the ill is getting deactivated, we only want to
13189 mutex_exit(&ill->ill_phyint->phyint_lock);
13193 mutex_exit(&ill->ill_phyint->phyint_lock);
13194 mutex_exit(&ill->ill_lock);
13197 if (ill->ill_isv6) {
13214 mutex_enter(&ill->ill_lock);
13216 mutex_exit(&ill->ill_lock);
13244 * The following members in ill_t track references to the ill.
13246 * uint_t ill_ire_cnt; Number of ires referencing ill
13247 * uint_t ill_ncec_cnt; Number of ncecs referencing ill
13248 * uint_t ill_nce_cnt; Number of nces referencing ill
13249 * uint_t ill_ilm_cnt; Number of ilms referencing ill
13251 * Reference to an ipif or ill can be obtained in any of the following ways.
13254 * Pointers to ipif / ill from other data structures viz ire and conn.
13255 * Implicit reference to the ipif / ill by holding a reference to the ire.
13257 * The ipif/ill lookup functions return a reference held ipif / ill.
13260 * references to the ipif / ill. Pointers from other structures do not
13264 * ill. This is incremented whenever a new ire is created referencing the
13265 * ill. This is done atomically inside ire_add_v[46] where the ire is
13269 * ill_ncec_cnt is the number of ncec's referencing the ill thru ncec_ill.
13275 * ill_nce_cnt is the number of nce's referencing the ill thru nce_ill. This is
13280 * ill_ilm_cnt is the ilm's reference to the ill. It is incremented in
13308 * lookup is done holding the ill_lock. Hence the ill/ipif state flags can't
13311 * until we release the ipsq_lock, even though the ill/ipif state flags
13317 ill_t *ill = ipif->ipif_ill;
13321 ip_stack_t *ipst = ill->ill_ipst;
13325 ip1dbg(("ipif_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
13328 ill_t *, ill, ipif_t *, ipif);
13331 mutex_enter(&ill->ill_lock);
13333 ASSERT(ill->ill_ipif_up_count > 0);
13334 --ill->ill_ipif_up_count;
13335 mutex_exit(&ill->ill_lock);
13344 * Removal of the last ipif from an ill may result in a DL_UNBIND
13349 * sure on new entries will be added until the ill is bound
13353 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13354 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13355 ill->ill_dl_up) {
13356 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
13390 if (ipif_was_up && ill->ill_ipif_up_count == 0) {
13397 if (IS_UNDER_IPMP(ill))
13398 ipmp_ill_refresh_active(ill);
13412 * If this is the last ipif on the ill, we also need to remove
13416 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0)
13417 ire_walk_ill(0, 0, ill_downi, ill, ill);
13441 mutex_enter(&ill->ill_lock);
13445 * to this ill that are still active ?
13448 mutex_exit(&ill->ill_lock);
13454 ip1dbg(("ipif_down: need to wait, adding pending mp %s ill %p",
13455 ill->ill_name, (void *)ill));
13459 * which in turn is called by the last refrele on the ipif/ill/ire.
13465 mutex_exit(&ill->ill_lock);
13470 mutex_exit(&ill->ill_lock);
13479 ill_t *ill = ipif->ipif_ill;
13483 ill_t *, ill, ipif_t *, ipif);
13487 * If this is the last logical interface on the ill
13493 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13494 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13495 ill->ill_dl_up) {
13496 ill_dl_down(ill);
13501 ill->ill_logical_down = 0;
13522 * This flag does not indicate whether the ill stream is in the
13525 * the driver. The state of the ill stream i.e. whether it is
13563 /* Remove pointers to this ill in the multicast routing tables */
13579 * of ipifs hanging off the ill.
13631 * Sets `buf' to an ill name.
13634 ill_get_name(const ill_t *ill, char *buf, int len)
13639 name = ill->ill_name;
13640 name_len = ill->ill_name_length;
13660 ill_t *ill;
13711 * before the slash. ill_lookup_on_name returns a held ill.
13712 * Temporary to check whether ill exists already. If so
13715 ill = ill_lookup_on_name(name, do_alloc, isv6,
13718 if (ill == NULL)
13727 ill_refrele(ill);
13732 mutex_enter(&ill->ill_lock);
13734 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13739 mutex_exit(&ill->ill_lock);
13740 ill_refrele(ill);
13745 mutex_exit(&ill->ill_lock);
13754 ill_refrele(ill);
13761 mutex_exit(&ill->ill_lock);
13762 ill_refrele(ill);
13777 if (ill->ill_net_type == IRE_LOOPBACK && id == 0)
13781 ipif = ipif_allocate(ill, id, ire_type, B_TRUE, B_TRUE, NULL);
13784 mutex_exit(&ill->ill_lock);
13785 ill_refrele(ill);
13801 ill_t *ill;
13851 * before the slash. ill_lookup_on_name returns a held ill.
13852 * Temporary to check whether ill exists already. If so
13855 ill = ill_lookup_on_name(name, B_FALSE, isv6, &did_alloc, ipst);
13858 if (ill == NULL)
13867 ill_refrele(ill);
13875 mutex_enter(&ill->ill_lock);
13877 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13882 mutex_exit(&ill->ill_lock);
13884 ill_refrele(ill);
13894 mutex_exit(&ill->ill_lock);
13902 ill_refrele(ill);
13905 ipsq = ill->ill_phyint->phyint_ipsq;
13908 mutex_exit(&ill->ill_lock);
13909 ipsq_enq(ipsq, q, mp, func, NEW_OP, ill);
13913 ill_refrele(ill);
13921 mutex_exit(&ill->ill_lock);
13922 ill_refrele(ill);
13997 ill_t *ill;
14002 ill = ipif->ipif_ill;
14005 if (!(ill->ill_flags & ILLF_MULTICAST) ||
14024 if (!IS_UNDER_IPMP(ill)) {
14025 ilm = ip_addmulti(&v6allmc, ill, ipif->ipif_zoneid,
14038 * If IPMP we need to put the membership on the upper ill.
14044 if (IS_UNDER_IPMP(ill) &&
14045 (mcast_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL) {
14048 mcast_ill = ill;
14072 if (ipif->ipif_lcl_addr == INADDR_ANY || IS_UNDER_IPMP(ill))
14079 ilm = ip_addmulti(&v6group, ill, ipif->ipif_zoneid, &err);
14115 ill_recover_saved_ire(ill_t *ill)
14118 ip_stack_t *ipst = ill->ill_ipst;
14120 ip1dbg(("ill_recover_saved_ire(%s)", ill->ill_name));
14122 mutex_enter(&ill->ill_saved_ire_lock);
14123 for (mp = ill->ill_saved_ire_mp; mp != NULL; mp = mp->b_cont) {
14131 if (ill->ill_isv6) {
14137 ill,
14148 ill,
14155 mutex_exit(&ill->ill_saved_ire_lock);
14160 if (ill->ill_isv6) {
14175 * If the IRE type (as defined by ill->ill_net_type) is
14179 if (ill->ill_net_type == IRE_LOOPBACK)
14204 mutex_exit(&ill->ill_saved_ire_lock);
14265 * is already up on a different ill, and EADDRINUSE if it's up on the same ill.
14273 ill_t *ill;
14290 ill = ILL_START_WALK_V6(&ctx, ipst);
14292 ill = ILL_START_WALK_V4(&ctx, ipst);
14294 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
14295 for (ipif = ill->ill_ipif; ipif != NULL;
14310 !IS_ON_SAME_LAN(ill, new_ipif->ipif_ill))
14313 ipif->ipif_zoneid != ALL_ZONES && IS_LOOPBACK(ill))
14315 else if (new_ipif->ipif_ill == ill)
14334 ill_t *ill = ipif->ipif_ill;
14339 ip_stack_t *ipst = ill->ill_ipst;
14343 ip1dbg(("ipif_up(%s:%u)\n", ill->ill_name, ipif->ipif_id));
14345 ill_t *, ill, ipif_t *, ipif);
14355 * an ill is special, in that every ill always has one, and that code
14356 * throughout IP deferences ill->ill_ipif without holding any locks.
14358 if (IS_UNDER_IPMP(ill) && ipmp_ipif_is_dataaddr(ipif) &&
14361 ill_t *ipmp_ill = ipmp_illgrp_ipmp_ill(ill->ill_grp);
14368 mutex_enter(&ill->ill_lock);
14370 mutex_exit(&ill->ill_lock);
14373 mutex_exit(&ill->ill_lock);
14380 if ((moveipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14384 if ((stubipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14393 * ill_g_lock held to prevent any ill walker threads from
14405 * Place the ipif on the IPMP ill. If the zeroth ipif on
14406 * the IPMP ill is a stub (0.0.0.0 down address) then we
14420 * on the original ill and fail the operation.
14421 * Since we're writer on the ill, we can be
14425 ipif->ipif_ill = ill;
14427 ipif_transfer(ipif, ill->ill_ipif,
14443 sctp_move_ipif(ipif, ill, ipmp_ill);
14453 ASSERT(ill->ill_move_ipif == NULL);
14454 ill->ill_move_ipif = ipif;
14455 if ((err = ipif_up(ill->ill_ipif, q, mp)) == 0)
14456 ASSERT(ill->ill_move_ipif == NULL);
14458 ill->ill_move_ipif = NULL;
14463 * Bring it up on the IPMP ill.
14469 if (ill->ill_wq != NULL) {
14471 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
14473 if (!ill->ill_dl_up) {
14477 * logical interface on the ill to become "up".
14483 return (ill_dl_up(ill, ipif, mp, q));
14499 mutex_enter(&ill->ill_lock);
14501 mutex_exit(&ill->ill_lock);
14532 err = ill_add_ires(ill);
14539 if (err == 0 && ill->ill_move_ipif != NULL) {
14540 ipif = ill->ill_move_ipif;
14541 ill->ill_move_ipif = NULL;
14548 * Add any IREs tied to the ill. For now this is just an IRE_MULTICAST.
14552 ill_add_ires(ill_t *ill)
14558 if (ill->ill_ire_multicast != NULL)
14564 if (ill->ill_isv6) {
14565 ire = ire_create_v6(&dummy6, 0, 0, IRE_MULTICAST, ill,
14566 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14568 ire = ire_create((uchar_t *)&dummy4, 0, 0, IRE_MULTICAST, ill,
14569 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14574 ill->ill_ire_multicast = ire;
14579 ill_delete_ires(ill_t *ill)
14581 if (ill->ill_ire_multicast != NULL) {
14588 ire_make_condemned(ill->ill_ire_multicast);
14589 ire_refrele_notr(ill->ill_ire_multicast);
14590 ill->ill_ire_multicast = NULL;
14601 ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
14609 DTRACE_PROBE2(ill__downup, char *, "ill_dl_up", ill_t *, ill);
14611 ip1dbg(("ill_dl_up(%s)\n", ill->ill_name));
14612 ASSERT(IAM_WRITER_ILL(ill));
14619 err = ill_add_ires(ill);
14627 ((dl_bind_req_t *)bind_mp->b_rptr)->dl_sap = ill->ill_sap;
14639 * since ill->ill_dl_up was not set, ill_dl_up would be invoked with
14640 * a non-null ill->ill_unbind_mp
14642 if (ill->ill_unbind_mp == NULL) {
14666 if (ill->ill_unbind_mp == NULL)
14667 ill->ill_unbind_mp = unbind_mp;
14669 ill_dlpi_send(ill, bind_mp);
14671 ill_capability_probe(ill);
14683 (strcmp(ill->ill_name, dhcifname) == 0) &&
14695 ip1dbg(("ill_dl_up(%s) FAILED\n", ill->ill_name));
14714 ill_t *ill = ipif->ipif_ill;
14723 ill_t *, ill, ipif_t *, ipif);
14732 * If all other interfaces for this ill are down or DEPRECATED,
14739 for (tmp_ipif = ill->ill_ipif; tmp_ipif;
14751 ip_update_source_selection(ill->ill_ipst);
14753 if (IS_LOOPBACK(ill) || ill->ill_net_type == IRE_IF_NORESOLVER) {
14768 if (ill->ill_net_type != IRE_LOOPBACK)
14772 err = nce_lookup_then_add_v4(ill, NULL,
14773 ill->ill_phys_addr_length, &ipif->ipif_lcl_addr, flags,
14805 if (IS_IPMP(ill))
14806 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
14812 if (ill->ill_ipif_up_count == 1 && !loopback) {
14813 /* Recover any additional IREs entries for this ill */
14814 (void) ill_recover_saved_ire(ill);
14817 if (ill->ill_need_recover_multicast) {
14830 ill_recover_multicast(ill);
14833 if (ill->ill_ipif_up_count == 1) {
14837 if (IS_UNDER_IPMP(ill))
14838 ipmp_ill_refresh_active(ill);
14844 if (IS_IPMP(ill))
14845 ipmp_illgrp_refresh_arpent(ill->ill_grp);
14853 ip_update_source_selection(ill->ill_ipst);
14859 /* Perhaps ilgs should use this ill */
14860 update_conn_ill(NULL, ill->ill_ipst);
14880 ill_t *ill = ipif->ipif_ill;
14881 ip_stack_t *ipst = ill->ill_ipst;
14976 ip1dbg(("ipif_add_ires: ipif 0x%p ill 0x%p "
14978 (void *)ipif, (void *)ill, ill->ill_net_type,
14984 ill->ill_net_type,
14985 ill,
15024 ill->ill_ipif_up_count++;
15031 * Our address may already be up on the same ill. In this case,
15039 ill->ill_ipif_up_count--;
15110 * Only match on ill since we are sharing broadcast addresses.
15138 ill->ill_ipif_up_count--;
15178 ill_t *ill = ipif->ipif_ill;
15179 ip_stack_t *ipst = ill->ill_ipst;
15254 * Find an ipif with a good local address on the ill+zoneid.
15257 ipif_good_addr(ill_t *ill, zoneid_t zoneid)
15261 mutex_enter(&ill->ill_lock);
15262 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15272 if (ill->ill_isv6 ?
15277 mutex_exit(&ill->ill_lock);
15280 mutex_exit(&ill->ill_lock);
15301 * Pick the optimal ipif on `ill' for sending to destination `dst' from zone
15307 * Returns NULL if there is no suitable source address for the ill.
15308 * This only occurs when there is no valid source address for the ill.
15311 ipif_select_source_v4(ill_t *ill, ipaddr_t dst, zoneid_t zoneid,
15319 ip_stack_t *ipst = ill->ill_ipst;
15322 if (ill->ill_usesrc_ifindex != 0 && allow_usesrc) {
15323 usill = ill_lookup_on_ifindex(ill->ill_usesrc_ifindex,
15326 ill = usill; /* Select source from usesrc ILL */
15335 if (IS_UNDER_IPMP(ill)) {
15336 if ((ipmp_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL)
15337 ill = ipmp_ill; /* Select source from IPMP ill */
15360 * Hold the ill_g_lock as reader. This makes sure that no ipif/ill
15361 * can be deleted. But an ipif/ill can get CONDEMNED any time.
15375 * ills since that can't happen on the IPMP ill.
15377 start_ipif = ill->ill_ipif;
15378 if (IS_IPMP(ill) && ill->ill_src_ipif != NULL)
15379 start_ipif = ill->ill_src_ipif;
15386 next_ipif = ill->ill_ipif;
15477 if (IS_IPMP(ill) && ipif != NULL) {
15480 ill->ill_src_ipif = next_ipif;
15482 ill->ill_src_ipif = NULL;
15500 ill->ill_name,
15517 * Pick a source address based on the destination ill and an optional setsrc
15530 * - If usrsrc is set, swap the ill to be the usesrc one.
15531 * - If IPMP is used on the ill, select a random address from the most
15547 ip_select_source_v4(ill_t *ill, ipaddr_t setsrc, ipaddr_t dst,
15562 * addresses use ipif/ill locks and exit those (hence a store memory
15579 ipif = ipif_select_source_v4(ill, dst, zoneid, B_TRUE, ¬ready);
15666 ill_t *ill = ipif->ipif_ill;
15678 irep = ire_create_bcast(ill, 0, zoneid, irep);
15679 irep = ire_create_bcast(ill, INADDR_BROADCAST, zoneid, irep);
15692 irep = ire_create_bcast(ill, addr, zoneid, irep);
15693 irep = ire_create_bcast(ill, ~netmask | addr, zoneid, irep);
15704 irep = ire_create_bcast(ill, addr, zoneid, irep);
15705 irep = ire_create_bcast(ill, ~subnetmask | addr, zoneid, irep);
15720 ill_t *ill = ipif->ipif_ill;
15731 ire = ire_lookup_bcast(ill, 0, zoneid);
15734 ire = ire_lookup_bcast(ill, INADDR_BROADCAST, zoneid);
15749 ire = ire_lookup_bcast(ill, addr, zoneid);
15752 ire = ire_lookup_bcast(ill, ~netmask | addr, zoneid);
15765 ire = ire_lookup_bcast(ill, addr, zoneid);
15768 ire = ire_lookup_bcast(ill, ~subnetmask | addr, zoneid);
15790 ill_t *ill = q->q_ptr;
15809 if (ill != ipif->ipif_ill)
15812 if (ill->ill_name[0] != '\0')
15816 * If there's another ill already with the requested name, ensure
15820 ipst = ill->ill_ipst;
15831 ill->ill_media->ip_m_mac_type) {
15833 "use the same ill name on differing media\n"));
15844 * This ill has not been inserted into the global list.
15852 (!ill->ill_needs_attach && ill->ill_bcast_addr_length == 0))) {
15871 ill->ill_flags |= ILLF_IPV6;
15872 ill->ill_flags &= ~ILLF_IPV4;
15875 ill->ill_flags |= ILLF_NOLINKLOCAL;
15884 if (ill->ill_flags & ILLF_IPV6) {
15885 ill->ill_phyint->phyint_illv6 = ill;
15886 ill->ill_phyint->phyint_illv4 = NULL;
15914 ill_t *ill;
15917 ill = ill_lookup_on_ifindex(index, isv6, ipst);
15918 if (ill != NULL) {
15919 mutex_enter(&ill->ill_lock);
15920 for (ipif = ill->ill_ipif; ipif != NULL;
15929 mutex_exit(&ill->ill_lock);
15930 ill_refrele(ill);
15946 ill_t *ill;
15962 ill = ipif->ipif_ill;
15963 phyi = ill->ill_phyint;
15990 ill_nic_event_dispatch(ill, 0, NE_IFINDEX_CHANGE,
16004 sctp_ill_reindex(ill, old_index);
16008 if (ILL_OTHER(ill))
16009 ip_rts_ifmsg(ILL_OTHER(ill)->ill_ipif, RTSQ_DEFAULT);
16011 /* Perhaps ilgs should use this ill */
16012 update_conn_ill(NULL, ill->ill_ipst);
16212 * Return the number of addresses on `ill' with one or more of the values
16216 ill_flagaddr_cnt(const ill_t *ill, uint64_t set, uint64_t clear)
16221 ASSERT(IAM_WRITER_ILL(ill));
16223 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
16231 * Return the number of migratable addresses on `ill' that are under
16235 ill_appaddr_cnt(const ill_t *ill)
16237 return (ill_flagaddr_cnt(ill, IPIF_DHCPRUNNING | IPIF_ADDRCONF,
16242 * Return the number of point-to-point addresses on `ill'.
16245 ill_ptpaddr_cnt(const ill_t *ill)
16247 return (ill_flagaddr_cnt(ill, IPIF_POINTOPOINT, 0));
16272 ill_t *ill;
16274 for (ill = uill->ill_usesrc_grp_next;
16275 ASSERT(ill), ill->ill_usesrc_grp_next != uill;
16276 ill = ill->ill_usesrc_grp_next)
16278 return (ill);
16293 * ill_usesrc_ifindex matching a target ill. We could also do that with an
16294 * ill walk, but the walker would need to insert in the ioctl response.
16322 ill_t *ill, *tmp_ill;
16339 ill = ill_prev_usesrc(ucill);
16340 ASSERT(ill->ill_usesrc_grp_next != NULL);
16343 if (ill->ill_usesrc_grp_next->ill_usesrc_grp_next == ill) {
16345 ASSERT(ill->ill_usesrc_ifindex == 0);
16346 ill->ill_usesrc_grp_next = NULL;
16348 ill->ill_usesrc_grp_next = ucill->ill_usesrc_grp_next;
16514 ill_t *ill = ipif->ipif_ill;
16520 mutex_enter(&ill->ill_lock);
16525 mutex_exit(&ill->ill_lock);
16557 ill_t *ill;
16563 ill = ((phyint_t *)phyip)->phyint_illv4;
16565 ill = ((phyint_t *)phyip)->phyint_illv6;
16566 ASSERT(ill != NULL);
16568 res = strcmp(ill->ill_name, (char *)name_ptr);
16618 * Attach the ill to the phyint structure which can be shared by both
16619 * IPv4 and IPv6 ill. ill_init allocates a phyint to just hold flags. This
16621 * loopback) where we know the name of the ill. We lookup the ill and if
16626 ill_phyint_reinit(ill_t *ill)
16628 boolean_t isv6 = ill->ill_isv6;
16633 ip_stack_t *ipst = ill->ill_ipst;
16637 phyi_old = ill->ill_phyint;
16638 ASSERT(isv6 || (phyi_old->phyint_illv4 == ill &&
16640 ASSERT(!isv6 || (phyi_old->phyint_illv6 == ill &&
16645 * Now that our ill has a name, set it in the phyint.
16647 (void) strlcpy(ill->ill_phyint->phyint_name, ill->ill_name, LIFNAMSIZ);
16650 ill->ill_name, &where);
16653 * 1. We grabbed the ill_g_lock before inserting this ill into
16655 * this ill and hence the ipsq of this ill is guaranteed to be empty.
16656 * 2. Now locate the other protocol instance of this ill.
16657 * 3. Now grab both ill locks in the right order, and the phyint lock of
16658 * the new ipsq. Holding ill locks + ill_g_lock ensures that the ipsq
16659 * of neither ill can change.
16660 * 4. Merge the phyint and thus the ipsq as well of this ill onto the
16661 * other ill.
16674 GRAB_ILL_LOCKS(ill, ill_other);
16684 phyi->phyint_illv6 = ill;
16687 phyi->phyint_illv4 = ill;
16700 mutex_enter(&ill->ill_lock);
16703 * the ill is not yet visible globally and we
16724 * pending mp is not affected because that is per ill basis.
16726 ill->ill_phyint = phyi;
16732 ill->ill_ip_mib->ipIfStatsIfIndex = ill->ill_phyint->phyint_ifindex;
16733 if (ill->ill_isv6) {
16734 ill->ill_icmp6_mib->ipv6IfIcmpIfIndex =
16735 ill->ill_phyint->phyint_ifindex;
16736 ill->ill_mcast_type = ipst->ips_mld_max_version;
16738 ill->ill_mcast_type = ipst->ips_igmp_max_version;
16752 if (!IS_LOOPBACK(ill)) {
16753 ill_nic_event_dispatch(ill, 0, NE_PLUMB, ill->ill_name,
16754 ill->ill_name_length);
16756 RELEASE_ILL_LOCKS(ill, ill_other);
16769 ip_ifname_notify(ill_t *ill, queue_t *q)
16792 (void) strncpy(lifr->lifr_name, ill->ill_name, LIFNAMSIZ);
16793 lifr->lifr_ppa = ill->ill_ppa;
16794 lifr->lifr_flags = (ill->ill_flags & (ILLF_IPV4|ILLF_IPV6));
16797 char *, "SIOCSLIFNAME", ill_t *, ill);
16802 ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
16805 ip_stack_t *ipst = ill->ill_ipst;
16806 phyint_t *phyi = ill->ill_phyint;
16812 if (IS_IPMP(ill)) {
16823 if (ipmp_grp_lookup(ill->ill_name, ipst) != NULL) {
16827 phyi->phyint_grp = ipmp_grp_create(ill->ill_name, phyi);
16837 ip_ifname_notify(ill, q);
16843 err = ill_dl_phys(ill, ipif, mp, q);
16845 if (ill->ill_isv6) {
16879 ill_t *ill;
16892 ill = (ill_t *)q->q_ptr;
16893 ipst = ill->ill_ipst;
16895 ASSERT(ill->ill_ipst != NULL);
16896 ASSERT(ill->ill_name[0] == '\0');
16897 ASSERT(IAM_WRITER_ILL(ill));
16899 ASSERT(ill->ill_ppa == UINT_MAX);
16901 ill->ill_defend_start = ill->ill_defend_count = 0;
16934 ill->ill_ppa = *new_ppa_ptr;
16937 * which makes the ill globally visible and also merges it with the
16941 ipif = ill->ill_ipif;
16946 if (!(ill->ill_flags & (ILLF_IPV4|ILLF_IPV6)))
16947 ill->ill_flags |= ILLF_IPV4;
16949 ASSERT(ipif->ipif_next == NULL); /* Only one ipif on ill */
16952 if (ill->ill_flags & ILLF_IPV6) {
16954 ill->ill_isv6 = B_TRUE;
16955 ill_set_inputfn(ill);
16956 if (ill->ill_rq != NULL) {
16957 ill->ill_rq->q_qinfo = &iprinitv6;
16966 ill->ill_reachable_retrans_time = ND_RETRANS_TIMER;
16973 !(ill->ill_flags & ILLF_MULTICAST)) {
16974 ill->ill_flags |= ILLF_NONUD;
16977 if (ill->ill_flags & ILLF_NOARP) {
16985 ill->ill_flags &= ~ILLF_NOARP;
16992 ill->ill_flags |= ILLF_ROUTER;
16993 } else if (ill->ill_flags & ILLF_IPV4) {
16994 ill->ill_isv6 = B_FALSE;
16995 ill_set_inputfn(ill);
16996 ill->ill_reachable_retrans_time = ARP_RETRANS_TIMER;
17007 ill->ill_flags |= ILLF_ROUTER;
17010 ASSERT(ill->ill_phyint != NULL);
17016 if (!ill_allocate_mibs(ill))
17023 ill->ill_sap = (ill->ill_isv6) ? ill->ill_media->ip_m_ipv6sap :
17024 ill->ill_media->ip_m_ipv4sap;
17026 ill->ill_ifname_pending = 1;
17027 ill->ill_ifname_pending_err = 0;
17031 * that were joined while this ill was not bound to the DLPI link need
17034 ill->ill_need_recover_multicast = 1;
17036 ill_refhold(ill);
17038 if ((error = ill_glist_insert(ill, interf_name,
17039 (ill->ill_flags & ILLF_IPV6) == ILLF_IPV6)) > 0) {
17040 ill->ill_ppa = UINT_MAX;
17041 ill->ill_name[0] = '\0';
17047 ill_refrele(ill);
17051 ASSERT(ill->ill_name_length <= LIFNAMSIZ);
17063 bcopy(ill->ill_name, interf_name, ill->ill_name_length);
17064 *new_ppa_ptr = ill->ill_ppa;
17073 sctp_update_ill(ill, SCTP_ILL_INSERT);
17076 * ill_glist_insert has made the ill visible globally, and
17083 * ips_ill_g_lock which prevents any ill lookup itself thereby
17086 ipsq = ipsq_try_enter_internal(ill, q, mp, ip_reprocess_ioctl, NEW_OP,
17090 ill_refrele(ill);
17102 error = ipif_set_values_tail(ill, ipif, mp, q);
17108 ill->ill_isv6 = B_FALSE;
17109 ill_set_inputfn(ill);
17141 ill_save_ire(ill_t *ill, ire_t *ire)
17154 ASSERT(!ill->ill_isv6);
17160 ASSERT(ill->ill_isv6);
17171 mutex_enter(&ill->ill_saved_ire_lock);
17172 save_mp->b_cont = ill->ill_saved_ire_mp;
17173 ill->ill_saved_ire_mp = save_mp;
17174 ill->ill_saved_ire_cnt++;
17175 mutex_exit(&ill->ill_saved_ire_lock);
17183 ill_remove_saved_ire(ill_t *ill, ire_t *ire)
17190 mutex_enter(&ill->ill_saved_ire_lock);
17191 for (mpp = &ill->ill_saved_ire_mp; *mpp != NULL;
17196 * On a given ill, the tuple of address, gateway, mask,
17210 if (ill->ill_isv6 ?
17221 ill->ill_saved_ire_cnt--;
17226 mutex_exit(&ill->ill_saved_ire_lock);
17357 ip_ether_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17368 if (ill->ill_phys_addr_length == ETHERADDRL) {
17371 bcopy(ill->ill_phys_addr, addr, 3);
17375 bcopy(ill->ill_phys_addr + 3, addr + 5, 3);
17381 ip_nodef_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17396 ip_ipmp_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17405 ASSERT(IS_IPMP(ill));
17410 (void) strlcpy(ic.ic_ifname, ill->ill_name, LIFNAMSIZ);
17412 if ((zp = zone_find_by_id(ill->ill_zoneid)) != NULL) {
17433 ip_ether_v6_mapping(ill_t *ill, uchar_t *m_ip6addr, uchar_t *m_physaddr)
17435 phyint_t *phyi = ill->ill_phyint;
17443 ill->ill_phys_addr_length != ETHERADDRL) {
17444 ip_mbcast_mapping(ill, m_ip6addr, m_physaddr);
17459 ip_ether_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17461 phyint_t *phyi = ill->ill_phyint;
17469 ill->ill_phys_addr_length != ETHERADDRL) {
17470 ip_mbcast_mapping(ill, m_ipaddr, m_physaddr);
17483 ip_mbcast_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17492 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17493 if (ill->ill_sap_length < 0) {
17498 dlur->dl_dest_addr_offset + ill->ill_sap_length;
17501 bcopy(bphys_addr, m_physaddr, ill->ill_phys_addr_length);
17508 ip_ib_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17512 ASSERT(ill->ill_phys_addr_length == 20);
17514 bcopy(ill->ill_phys_addr + 12, addr, 8);
17545 ip_ib_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17553 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17564 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17565 if (ill->ill_sap_length < 0) {
17569 ill->ill_sap_length;
17580 ip_ib_v6_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17588 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17595 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17596 if (ill->ill_sap_length < 0) {
17600 ill->ill_sap_length;
17617 ip_ipv4_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17619 ASSERT(ill->ill_phys_addr_length == sizeof (ipaddr_t));
17630 ip_ipv6_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17634 ASSERT(ill->ill_phys_addr_length == sizeof (in6_addr_t));
17639 ip_ipv6_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17641 ip_ipv6_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17645 ip_ipv6_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17647 ip_ipv6_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17651 ip_ipv4_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17653 ip_ipv4_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17657 ip_ipv4_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17659 ip_ipv4_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17663 * Lookup an ill and verify that the zoneid has an ipif on that ill.
17664 * Returns an held ill, or NULL.
17670 ill_t *ill;
17673 ill = ill_lookup_on_ifindex(index, isv6, ipst);
17674 if (ill == NULL)
17677 mutex_enter(&ill->ill_lock);
17678 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17685 mutex_exit(&ill->ill_lock);
17686 return (ill);
17688 mutex_exit(&ill->ill_lock);
17689 ill_refrele(ill);
17703 ill_t *ill;
17705 ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
17706 if (ill == NULL)
17709 mutex_enter(&ill->ill_lock);
17710 if (ill->ill_state_flags & ILL_CONDEMNED) {
17711 mutex_exit(&ill->ill_lock);
17712 ill_refrele(ill);
17716 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17725 mutex_exit(&ill->ill_lock);
17726 ill_refrele(ill);
17736 ill_set_inputfn(ill_t *ill)
17738 ip_stack_t *ipst = ill->ill_ipst;
17740 if (ill->ill_isv6) {
17742 ill->ill_inputfn = ill_input_full_v6;
17744 ill->ill_inputfn = ill_input_short_v6;
17747 ill->ill_inputfn = ill_input_full_v4;
17748 else if (ill->ill_dhcpinit != 0)
17749 ill->ill_inputfn = ill_input_full_v4;
17752 ill->ill_inputfn = ill_input_full_v4;
17755 ill->ill_inputfn = ill_input_full_v4;
17757 ill->ill_inputfn = ill_input_short_v4;
17769 ill_t *ill;
17772 ill = ILL_START_WALK_V4(&ctx, ipst);
17773 for (; ill != NULL; ill = ill_next(&ctx, ill))
17774 ill_set_inputfn(ill);
17780 * Set the physical address information for `ill' to the contents of the
17782 * asynchronous if `ill' cannot immediately be quiesced -- in which case
17786 ill_set_phys_addr(ill_t *ill, mblk_t *mp)
17788 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17801 * We need to store up to two copies of `mp' in `ill'. Due to the
17811 ipsq_current_start(ipsq, ill->ill_ipif, 0);
17819 mutex_enter(&ill->ill_lock);
17820 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
17822 mutex_exit(&ill->ill_lock);
17825 * If we can quiesce the ill, then set the address. If not, then
17828 ill_down_ipifs(ill, B_TRUE);
17829 mutex_enter(&ill->ill_lock);
17830 if (!ill_is_quiescent(ill)) {
17832 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
17834 mutex_exit(&ill->ill_lock);
17837 mutex_exit(&ill->ill_lock);
17839 ill_set_phys_addr_tail(ipsq, ill->ill_rq, mp, NULL);
17852 ill_set_allowed_ips(ill_t *ill, mblk_t *mp)
17854 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17863 kmem_free(ill->ill_allowed_ips,
17864 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17865 ill->ill_allowed_ips_cnt = 0;
17866 ill->ill_allowed_ips = NULL;
17867 mutex_enter(&ill->ill_phyint->phyint_lock);
17868 ill->ill_phyint->phyint_flags &= ~PHYI_L3PROTECT;
17869 mutex_exit(&ill->ill_phyint->phyint_lock);
17873 if (ill->ill_allowed_ips != NULL) {
17874 kmem_free(ill->ill_allowed_ips,
17875 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17877 ill->ill_allowed_ips_cnt = mrp->mp_ipaddrcnt;
17878 ill->ill_allowed_ips = kmem_alloc(
17879 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t), KM_SLEEP);
17881 ill->ill_allowed_ips[i] = mrp->mp_ipaddrs[i].ip_addr;
17883 mutex_enter(&ill->ill_phyint->phyint_lock);
17884 ill->ill_phyint->phyint_flags |= PHYI_L3PROTECT;
17885 mutex_exit(&ill->ill_phyint->phyint_lock);
17889 * Once the ill associated with `q' has quiesced, set its physical address
17901 ill_t *ill = q->q_ptr;
17910 addrlen = dlindp->dl_addr_length - ABS(ill->ill_sap_length);
17914 ill_set_ndmp(ill, addrmp, addroff, addrlen);
17919 freemsg(ill->ill_dest_addr_mp);
17920 ill->ill_dest_addr = addrmp->b_rptr + addroff;
17921 ill->ill_dest_addr_mp = addrmp;
17922 if (ill->ill_isv6) {
17923 ill_setdesttoken(ill);
17924 ipif_setdestlinklocal(ill->ill_ipif);
17930 freemsg(ill->ill_phys_addr_mp);
17931 ill->ill_phys_addr = addrmp->b_rptr + addroff;
17932 ill->ill_phys_addr_mp = addrmp;
17933 ill->ill_phys_addr_length = addrlen;
17934 if (ill->ill_isv6)
17935 ill_set_ndmp(ill, addrmp2, addroff, addrlen);
17938 if (ill->ill_isv6) {
17939 ill_setdefaulttoken(ill);
17940 ipif_setlinklocal(ill->ill_ipif);
17951 mutex_enter(&ill->ill_lock);
17952 ill->ill_state_flags &= ~ILL_DOWN_IN_PROGRESS;
17953 mutex_exit(&ill->ill_lock);
17960 status = ill_up_ipifs(ill, q, addrmp);
17969 ill_set_ndmp(ill_t *ill, mblk_t *ndmp, uint_t addroff, uint_t addrlen)
17971 freemsg(ill->ill_nd_lla_mp);
17972 ill->ill_nd_lla = ndmp->b_rptr + addroff;
17973 ill->ill_nd_lla_mp = ndmp;
17974 ill->ill_nd_lla_len = addrlen;
17978 * Replumb the ill.
17981 ill_replumb(ill_t *ill, mblk_t *mp)
17983 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17987 ipsq_current_start(ipsq, ill->ill_ipif, 0);
17990 * If we can quiesce the ill, then continue. If not, then
17993 ill_down_ipifs(ill, B_FALSE);
17995 mutex_enter(&ill->ill_lock);
17996 if (!ill_is_quiescent(ill)) {
17998 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
18000 mutex_exit(&ill->ill_lock);
18003 mutex_exit(&ill->ill_lock);
18005 ill_replumb_tail(ipsq, ill->ill_rq, mp, NULL);
18013 ill_t *ill = q->q_ptr;
18018 freemsg(ill->ill_replumb_mp);
18019 ill->ill_replumb_mp = copyb(mp);
18021 if (ill->ill_replumb_mp == NULL) {
18027 mutex_enter(&ill->ill_lock);
18028 ill->ill_up_ipifs = ipsq_pending_mp_add(NULL, ill->ill_ipif,
18029 ill->ill_rq, ill->ill_replumb_mp, 0);
18030 mutex_exit(&ill->ill_lock);
18032 if (!ill->ill_up_ipifs) {
18037 ill->ill_replumbing = 1;
18038 err = ill_down_ipifs_tail(ill);
18050 ill_dlpi_send(ill, mp);
18059 ASSERT(ill->ill_replumb_mp != NULL);
18063 ill->ill_replumb_mp = ipsq_pending_mp_get(ipsq, &connp);
18065 if (err == 0 && ill->ill_replumb_mp != NULL &&
18066 ill_up_ipifs(ill, q, ill->ill_replumb_mp) == EINPROGRESS) {
18310 ill_nic_event_dispatch(ill_t *ill, lif_if_t lif, nic_event_t event,
18313 ip_stack_t *ipst = ill->ill_ipst;
18321 info->hnei_event.hne_nic = ill->ill_phyint->phyint_ifindex;
18324 info->hnei_event.hne_protocol = ill->ill_isv6 ?
18352 "information for %s (ENOMEM)\n", str, ill->ill_name));
18361 ill_t *ill = ipif->ipif_ill;
18368 ill_t *, ill, ipif_t *, ipif);
18379 ipmp_illgrp_t *illg = ill->ill_grp;
18383 if (IS_IPMP(ill)) {
18398 * We couldn't bind the ipif to an ill
18408 bound_ill = ill;
18416 * because IPMP has rebound an address to this ill: send
18428 err = nce_lookup_then_add_v4(ill,
18443 ill->ill_name));
18458 "for %s:%u\n", ill->ill_name,
18494 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18502 ill_t *ill = ipif->ipif_ill;
18506 ill_t *, ill, ipif_t *, ipif);
18512 first_interface = (ill->ill_ipif_up_count == 0 &&
18513 ill->ill_ipif_dup_count == 0 && !was_dup);
18519 err = arp_ll_up(ill);
18543 arp_bringup_done(ill_t *ill, int err)
18551 ip1dbg(("arp_bringup_done(%s)\n", ill->ill_name));
18553 ASSERT(IAM_WRITER_ILL(ill));
18555 ipsq = ill->ill_phyint->phyint_ipsq;
18573 q = ill->ill_rq;
18593 if ((err == 0) && (ill->ill_up_ipifs)) {
18594 err = ill_up_ipifs(ill, q, mp1);
18601 * to this point, bring it up on the IPMP ill. Otherwise, leave it
18604 if (ill->ill_move_ipif != NULL) {
18605 ipif = ill->ill_move_ipif;
18606 ip1dbg(("bringing up ipif %p on ill %s\n", (void *)ipif,
18608 ill->ill_move_ipif = NULL;
18625 ill_t *, ill, ipif_t *, ipif);
18637 arp_replumb_done(ill_t *ill, int err)
18645 ASSERT(IAM_WRITER_ILL(ill));
18647 ipsq = ill->ill_phyint->phyint_ipsq;
18668 q = ill->ill_rq;
18670 if ((err == 0) && (ill->ill_up_ipifs)) {
18671 err = ill_up_ipifs(ill, q, mp1);
18685 ill_t *, ill, ipif_t *, ipif);
18965 ill_t *ill = ipif->ipif_ill;
18969 ill_t *, ill, ipif_t *, ipif);
18972 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
18974 nce = nce_lookup_v4(ill, &ipif->ipif_lcl_addr);
18991 if (IS_IPMP(ill))
18992 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18995 * Remove all other nces dependent on this ill when the last ipif
18998 if (ill->ill_ipif_up_count == 0) {
18999 ncec_walk(ill, (pfi_t)ncec_delete_per_ill,
19000 (uchar_t *)ill, ill->ill_ipst);
19001 if (IS_UNDER_IPMP(ill))
19002 nce_flush(ill, B_TRUE);
19013 ill_t *ill;
19020 for (ill = usill->ill_usesrc_grp_next; ill != NULL && ill != usill;
19021 ill = ill->ill_usesrc_grp_next) {
19022 if (!IS_UNDER_IPMP(ill) && (ill->ill_flags & ILLF_MULTICAST) &&
19023 !ILL_IS_CONDEMNED(ill)) {
19024 ill_refhold(ill);
19030 return (ill);
19061 ill_t *ill;
19064 ill = ipif->ipif_ill;
19066 if (ill->ill_phys_addr == NULL) {
19069 if (ill->ill_phys_addr_length > sizeof (sock->sa_data)) {
19073 ip1dbg(("ip_sioctl_get_hwaddr(%s)\n", ill->ill_name));
19086 sock->sa_family = arp_hw_type(ill->ill_mactype);
19087 bcopy(ill->ill_phys_addr, &sock->sa_data, ill->ill_phys_addr_length);
19107 ill_t *ill;
19110 ill = ipif->ipif_ill;
19112 if (ill->ill_phys_addr == NULL) {
19115 if (ill->ill_phys_addr_length > sizeof (sock->sdl_data)) {
19119 ip1dbg(("ip_sioctl_get_lifhwaddr(%s)\n", ill->ill_name));
19131 lifr->lifr_type = ill->ill_type;
19134 sock->sdl_index = ill->ill_phyint->phyint_ifindex;
19135 sock->sdl_type = ill->ill_mactype;
19138 sock->sdl_alen = ill->ill_phys_addr_length;
19139 bcopy(ill->ill_phys_addr, sock->sdl_data, ill->ill_phys_addr_length);