Lines Matching refs:ill
68 static ilm_t *ilm_add(ill_t *ill, const in6_addr_t *group,
81 static int ip_ll_multireq(ill_t *ill, const in6_addr_t *group,
87 ipaddr_t ifaddr, uint_t ifindex, ill_t *ill, mcast_record_t fmode,
90 static mblk_t *ill_create_dl(ill_t *ill, uint32_t dl_primitive,
113 * The access and lookup of the ilm, as well as other ill multicast state,
295 * Note that the caller has already serialized on the ill we care
406 ill_t *ill = ilm->ilm_ill;
456 if (!IS_LOOPBACK(ill)) {
457 if (ill->ill_isv6)
485 ill_t *ill = ilm->ilm_ill;
515 if (!IS_LOOPBACK(ill)) {
516 if (ill->ill_isv6)
531 buf, sizeof (buf)), ill->ill_name));
547 * Create/update the ilm for the group/ill. Used by other parts of IP to
554 * The caller should have already mapped an IPMP under ill to the upper.
557 ip_addmulti(const in6_addr_t *v6group, ill_t *ill, zoneid_t zoneid,
563 mutex_enter(&ill->ill_mcast_serializer);
564 ilm = ip_addmulti_serial(v6group, ill, zoneid, ILGSTAT_NONE,
566 mutex_exit(&ill->ill_mcast_serializer);
571 ill_mcast_send_queued(ill);
572 ill_dlpi_send_queued(ill);
577 * Create/update the ilm for the group/ill. If ILGSTAT_CHANGE is not set
592 * The caller should have already mapped an IPMP under ill to the upper.
595 ip_addmulti_serial(const in6_addr_t *v6group, ill_t *ill, zoneid_t zoneid,
601 ASSERT(MUTEX_HELD(&ill->ill_mcast_serializer));
603 if (ill->ill_isv6) {
614 ASSERT(!IS_UNDER_IPMP(ill));
625 if (IS_UNDER_IPMP(ill)) {
630 rw_enter(&ill->ill_mcast_lock, RW_WRITER);
633 * This is needed since the ill could have been condemned after
637 if (ill->ill_state_flags & ILL_CONDEMNED) {
638 rw_exit(&ill->ill_mcast_lock);
642 ilm = ip_addmulti_impl(v6group, ill, zoneid, ilgstat, ilg_fmode,
644 rw_exit(&ill->ill_mcast_lock);
646 ill_mcast_timer_start(ill->ill_ipst);
651 ip_addmulti_impl(const in6_addr_t *v6group, ill_t *ill, zoneid_t zoneid,
658 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
662 * An ilm is uniquely identified by the tuple of (group, ill) where
663 * `group' is the multicast group address, and `ill' is the interface
667 ilm = ilm_lookup(ill, v6group, zoneid);
684 ilm = ilm_add(ill, v6group, ilgstat, ilg_fmode, ilg_flist, zoneid);
695 if (ilm_numentries(ill, v6group) == 1) {
696 ret = ill_join_allmulti(ill);
699 if (!IS_LOOPBACK(ill)) {
700 if (ill->ill_isv6)
710 if (ilm_numentries(ill, v6group) == 1) {
711 ret = ip_ll_multireq(ill, v6group, DL_ENABMULTI_REQ);
720 buf, sizeof (buf)), ill->ill_name));
735 ip_mphysaddr_add(ill_t *ill, uchar_t *hw_addr)
738 int hw_addr_length = ill->ill_phys_addr_length;
740 mutex_enter(&ill->ill_lock);
741 for (mpa = ill->ill_mphysaddr_list; mpa != NULL; mpa = mpa->mpa_next) {
744 mutex_exit(&ill->ill_lock);
759 (void *)hw_addr, ill->ill_name));
760 mutex_exit(&ill->ill_lock);
765 mpa->mpa_next = ill->ill_mphysaddr_list;
766 ill->ill_mphysaddr_list = mpa;
767 mutex_exit(&ill->ill_lock);
777 ip_mphysaddr_del(ill_t *ill, uchar_t *hw_addr)
780 int hw_addr_length = ill->ill_phys_addr_length;
783 mutex_enter(&ill->ill_lock);
784 for (mpapp = &ill->ill_mphysaddr_list; (mpap = *mpapp) != NULL;
798 " ill_name: %s\n", (void *)hw_addr, ill->ill_name));
805 mutex_exit(&ill->ill_lock);
818 ip_ll_send_multireq(ill_t *ill, const in6_addr_t *v6groupp, t_uscalar_t prim)
826 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
828 if (IS_IPMP(ill)) {
829 /* On the upper IPMP ill. */
830 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
838 ill->ill_name, ill->ill_isv6));
841 ill = release_ill;
844 mp = ill_create_dl(ill, prim, &addrlen, &addroff);
850 mp = ndp_mcastreq(ill, v6groupp, addrlen, addroff, mp);
852 ip0dbg(("null from ndp_mcastreq(ill %s)\n", ill->ill_name));
861 if (!ip_mphysaddr_add(ill, cp)) {
866 mutex_enter(&ill->ill_lock);
868 if (ill->ill_dlpi_multicast_state == IDS_UNKNOWN)
869 ill->ill_dlpi_multicast_state = IDS_INPROGRESS;
870 mutex_exit(&ill->ill_lock);
874 if (!ip_mphysaddr_del(ill, cp)) {
880 ill_dlpi_queue(ill, mp);
892 ip_ll_multireq(ill_t *ill, const in6_addr_t *v6groupp, t_uscalar_t prim)
894 if (ill->ill_net_type != IRE_IF_RESOLVER ||
895 ill->ill_ipif->ipif_flags & IPIF_POINTOPOINT) {
900 if (ill->ill_phyint->phyint_flags & PHYI_MULTI_BCAST) {
904 return (ip_ll_send_multireq(ill, v6groupp, prim));
914 ill_t *ill = ilm->ilm_ill;
918 mutex_enter(&ill->ill_mcast_serializer);
920 mutex_exit(&ill->ill_mcast_serializer);
925 ill_mcast_send_queued(ill);
926 ill_dlpi_send_queued(ill);
940 ill_t *ill = ilm->ilm_ill;
943 ASSERT(MUTEX_HELD(&ill->ill_mcast_serializer));
944 ASSERT(!(IS_UNDER_IPMP(ill)));
946 rw_enter(&ill->ill_mcast_lock, RW_WRITER);
948 rw_exit(&ill->ill_mcast_lock);
949 ill_mcast_timer_start(ill->ill_ipst);
956 ill_t *ill = ilm->ilm_ill;
960 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
980 if (ilm_numentries(ill, &v6group) != 0)
983 ill_leave_allmulti(ill);
988 if (!IS_LOOPBACK(ill)) {
989 if (ill->ill_isv6)
1000 if (ilm_numentries(ill, &v6group) != 0)
1003 error = ip_ll_multireq(ill, &v6group, DL_DISABMULTI_REQ);
1010 ill->ill_name));
1019 ill_join_allmulti(ill_t *ill)
1025 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
1027 if (IS_LOOPBACK(ill))
1030 if (!ill->ill_dl_up) {
1038 if (IS_IPMP(ill)) {
1039 /* On the upper IPMP ill. */
1040 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
1048 ill->ill_name, ill->ill_isv6));
1051 ill = release_ill;
1052 if (!ill->ill_dl_up) {
1053 ill_refrele(ill);
1065 if ((ill->ill_net_type == IRE_IF_RESOLVER) &&
1066 !(ill->ill_phyint->phyint_flags & PHYI_MULTI_BCAST)) {
1067 promiscon_mp = ill_create_dl(ill, DL_PROMISCON_REQ,
1069 if (ill->ill_promiscoff_mp == NULL)
1070 promiscoff_mp = ill_create_dl(ill, DL_PROMISCOFF_REQ,
1073 (ill->ill_promiscoff_mp == NULL && promiscoff_mp == NULL)) {
1080 if (ill->ill_promiscoff_mp == NULL)
1081 ill->ill_promiscoff_mp = promiscoff_mp;
1082 ill_dlpi_queue(ill, promiscon_mp);
1093 ill_leave_allmulti(ill_t *ill)
1098 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
1100 if (IS_LOOPBACK(ill))
1103 if (!ill->ill_dl_up) {
1111 if (IS_IPMP(ill)) {
1112 /* On the upper IPMP ill. */
1113 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
1121 ill->ill_name, ill->ill_isv6));
1124 ill = release_ill;
1125 if (!ill->ill_dl_up)
1135 promiscoff_mp = ill->ill_promiscoff_mp;
1137 ill->ill_promiscoff_mp = NULL;
1138 ill_dlpi_queue(ill, promiscoff_mp);
1148 ill_t *ill;
1152 ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
1153 if (ill == NULL)
1163 if (IS_UNDER_IPMP(ill)) {
1164 ill_refrele(ill);
1167 mutex_enter(&ill->ill_lock);
1168 if (ill->ill_ipallmulti_cnt > 0) {
1170 ASSERT(ill->ill_ipallmulti_ilm != NULL);
1171 ill->ill_ipallmulti_cnt++;
1172 mutex_exit(&ill->ill_lock);
1175 mutex_exit(&ill->ill_lock);
1177 ilm = ip_addmulti(&ipv6_all_zeros, ill, ill->ill_zoneid, &ret);
1180 ill_refrele(ill);
1184 mutex_enter(&ill->ill_lock);
1185 if (ill->ill_ipallmulti_cnt > 0) {
1188 mutex_exit(&ill->ill_lock);
1191 ASSERT(ill->ill_ipallmulti_ilm == NULL);
1192 ill->ill_ipallmulti_ilm = ilm;
1193 ill->ill_ipallmulti_cnt++;
1194 mutex_exit(&ill->ill_lock);
1196 ill_refrele(ill);
1203 ill_t *ill;
1206 ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
1207 if (ill == NULL)
1210 if (IS_UNDER_IPMP(ill)) {
1211 ill_refrele(ill);
1215 mutex_enter(&ill->ill_lock);
1216 if (ill->ill_ipallmulti_cnt == 0) {
1218 mutex_exit(&ill->ill_lock);
1221 ill->ill_ipallmulti_cnt--;
1222 if (ill->ill_ipallmulti_cnt == 0) {
1224 ilm = ill->ill_ipallmulti_ilm;
1225 ill->ill_ipallmulti_ilm = NULL;
1229 mutex_exit(&ill->ill_lock);
1234 ill_refrele(ill);
1243 ip_purge_allmulti(ill_t *ill)
1247 ASSERT(IAM_WRITER_ILL(ill));
1249 mutex_enter(&ill->ill_lock);
1250 ilm = ill->ill_ipallmulti_ilm;
1251 ill->ill_ipallmulti_ilm = NULL;
1252 ill->ill_ipallmulti_cnt = 0;
1253 mutex_exit(&ill->ill_lock);
1265 ill_create_dl(ill_t *ill, uint32_t dl_primitive,
1277 hw_addr_length = ill->ill_phys_addr_length;
1349 ill_recover_multicast(ill_t *ill)
1354 ill->ill_need_recover_multicast = 0;
1356 rw_enter(&ill->ill_mcast_lock, RW_WRITER);
1357 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1363 if (ilm_numentries(ill, &ilm->ilm_v6addr) > 1 &&
1364 ilm_lookup(ill, &ilm->ilm_v6addr, ALL_ZONES) != ilm) {
1372 (void) ill_join_allmulti(ill);
1374 if (ill->ill_isv6)
1379 (void) ip_ll_multireq(ill, &ilm->ilm_v6addr,
1383 rw_exit(&ill->ill_mcast_lock);
1385 ill_mcast_send_queued(ill);
1386 ill_dlpi_send_queued(ill);
1387 ill_mcast_timer_start(ill->ill_ipst);
1399 ill_leave_multicast(ill_t *ill)
1404 ill->ill_need_recover_multicast = 1;
1406 rw_enter(&ill->ill_mcast_lock, RW_WRITER);
1407 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1413 if (ilm_numentries(ill, &ilm->ilm_v6addr) > 1 &&
1414 ilm_lookup(ill, &ilm->ilm_v6addr, ALL_ZONES) != ilm) {
1422 ill_leave_allmulti(ill);
1424 if (ill->ill_isv6)
1429 (void) ip_ll_multireq(ill, &ilm->ilm_v6addr,
1433 rw_exit(&ill->ill_mcast_lock);
1435 ill_mcast_send_queued(ill);
1436 ill_dlpi_send_queued(ill);
1437 ill_mcast_timer_start(ill->ill_ipst);
1442 * Returns true if there is a member on the ill for any zoneid.
1445 ill_hasmembers_v6(ill_t *ill, const in6_addr_t *v6group)
1449 rw_enter(&ill->ill_mcast_lock, RW_READER);
1450 ilm = ilm_lookup(ill, v6group, ALL_ZONES);
1451 rw_exit(&ill->ill_mcast_lock);
1457 * Returns true if there is a member on the ill for any zoneid.
1463 ill_hasmembers_v4(ill_t *ill, ipaddr_t group)
1468 return (ill_hasmembers_v6(ill, &v6group));
1473 * Returns true if there is a member on the ill for any zoneid except skipzone.
1476 ill_hasmembers_otherzones_v6(ill_t *ill, const in6_addr_t *v6group,
1481 rw_enter(&ill->ill_mcast_lock, RW_READER);
1482 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1485 rw_exit(&ill->ill_mcast_lock);
1489 rw_exit(&ill->ill_mcast_lock);
1495 * Returns true if there is a member on the ill for any zoneid except skipzone.
1501 ill_hasmembers_otherzones_v4(ill_t *ill, ipaddr_t group, zoneid_t skipzone)
1506 return (ill_hasmembers_otherzones_v6(ill, &v6group, skipzone));
1521 ill_hasmembers_nextzone_v6(ill_t *ill, const in6_addr_t *v6group,
1526 rw_enter(&ill->ill_mcast_lock, RW_READER);
1527 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1531 rw_exit(&ill->ill_mcast_lock);
1535 rw_exit(&ill->ill_mcast_lock);
1548 ill_hasmembers_nextzone_v4(ill_t *ill, ipaddr_t group, zoneid_t zoneid)
1554 return (ill_hasmembers_nextzone_v6(ill, &v6group, zoneid));
1558 * Find an ilm matching the ill, group, and zoneid.
1561 ilm_lookup(ill_t *ill, const in6_addr_t *v6group, zoneid_t zoneid)
1565 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
1567 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1573 ASSERT(ilm->ilm_ill == ill);
1580 * How many members on this ill?
1581 * Since each shared-IP zone has a separate ilm for the same group/ill
1585 ilm_numentries(ill_t *ill, const in6_addr_t *v6group)
1590 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
1591 for (ilm = ill->ill_ilm; ilm; ilm = ilm->ilm_next) {
1601 ilm_add(ill_t *ill, const in6_addr_t *v6group, ilg_stat_t ilgstat,
1608 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
1625 ilm->ilm_ill = ill;
1626 DTRACE_PROBE3(ill__incr__cnt, (ill_t *), ill,
1628 ill->ill_ilm_cnt++;
1630 ASSERT(ill->ill_ipst);
1631 ilm->ilm_ipst = ill->ill_ipst; /* No netstack_hold */
1633 /* The ill/ipif could have just been marked as condemned */
1639 ilm_cur = ill->ill_ilm;
1640 ilm_ptpn = &ill->ill_ilm;
1681 ill_t *ill = ilm->ilm_ill;
1689 ASSERT(RW_WRITE_HELD(&ill->ill_mcast_lock));
1691 for (ilmp = &ill->ill_ilm; *ilmp != ilm; ilmp = &(*ilmp)->ilm_next)
1696 mutex_enter(&ill->ill_lock);
1698 * if we are the last reference to the ill, we may need to wakeup any
1703 DTRACE_PROBE3(ill__decr__cnt, (ill_t *), ill,
1705 ASSERT(ill->ill_ilm_cnt > 0);
1706 ill->ill_ilm_cnt--;
1707 if (ILL_FREE_OK(ill))
1713 /* drops ill lock */
1714 ipif_ill_refrele_tail(ill);
1716 mutex_exit(&ill->ill_lock);
1721 * Lookup an ill based on the group, ifindex, ifaddr, and zoneid.
1731 ill_t *ill;
1738 ill = ill_lookup_on_ifindex_zoneid(ifindex, zoneid,
1745 ill = NULL;
1747 ill = ipif->ipif_ill;
1748 ill_refhold(ill);
1752 ill = ill_lookup_group_v4(v4group, zoneid, ipst, NULL,
1757 ill = ill_lookup_on_ifindex_zoneid(ifindex, zoneid,
1760 ill = ill_lookup_group_v6(group, zoneid, ipst, NULL,
1764 if (ill == NULL) {
1772 if (IS_UNDER_IPMP(ill) || IS_VNI(ill)) {
1773 ill_refrele(ill);
1777 return (ill);
1781 * Looks up the appropriate ill given an interface index (or interface address)
1795 ill_t *ill = NULL;
1826 ill = ill_mcast_lookup(v6group, ifaddr, ifindex, IPCL_ZONEID(connp),
1828 *illpp = ill;
1919 struct ip_msfilter *imsf, const struct in6_addr *group, ill_t *ill,
1964 mutex_enter(&ill->ill_mcast_serializer);
1974 mutex_exit(&ill->ill_mcast_serializer);
1980 mutex_exit(&ill->ill_mcast_serializer);
1985 ilg->ilg_ill = ill;
1990 * Make sure we have the correct serializer. The ill argument
1994 mutex_exit(&ill->ill_mcast_serializer);
1995 ill = ilg->ilg_ill;
1998 mutex_enter(&ill->ill_mcast_serializer);
2007 mutex_exit(&ill->ill_mcast_serializer);
2012 ill_mcast_send_queued(ill);
2013 ill_dlpi_send_queued(ill);
2025 mutex_exit(&ill->ill_mcast_serializer);
2093 * Now update the ill. We wait to do this until after the ilg
2095 * info for the ill, which involves looking at the status of
2098 ilm = ip_addmulti_serial(group, ill, connp->conn_zoneid, ilgstat,
2154 * will rejoin when the ill comes back; don't report ENETDOWN
2182 mutex_exit(&ill->ill_mcast_serializer);
2183 ill_mcast_send_queued(ill);
2184 ill_dlpi_send_queued(ill);
2213 ill_t *ill;
2216 err = ip_msfilter_ill(connp, mp, ipip, &ill);
2265 err = ip_set_srcfilter(connp, gf, NULL, &v6group, ill,
2297 err = ip_set_srcfilter(connp, gf, imsf, &v6group, ill,
2301 ill_refrele(ill);
2307 * Determine the ill for the SIOC*MSFILTER ioctls
2311 * Finds the ill based on information in the ioctl headers.
2319 ill_t *ill;
2346 ill = ill_mcast_lookup(&v6group, v4addr, 0, IPCL_ZONEID(connp),
2348 if (ill == NULL && v4addr != INADDR_ANY)
2367 ill = ill_mcast_lookup(&v6group, INADDR_ANY, index,
2370 *illp = ill;
2458 ill_t *ill;
2462 err = ip_opt_check(connp, v6group, v6src, ifaddr, ifindex, &ill);
2464 ip1dbg(("ip_opt_add_group: no ill for group %s/"
2476 ill_refrele(ill);
2479 mutex_enter(&ill->ill_mcast_serializer);
2484 * checking the value of ill->ill_grp_pending under the
2491 if (ill->ill_grp_pending || IS_UNDER_IPMP(ill)) {
2492 DTRACE_PROBE2(group__add__on__under, ill_t *, ill,
2494 mutex_exit(&ill->ill_mcast_serializer);
2495 ill_refrele(ill);
2498 err = ilg_add(connp, v6group, ifaddr, ifindex, ill, fmode, v6src);
2499 mutex_exit(&ill->ill_mcast_serializer);
2505 ill_mcast_send_queued(ill);
2506 ill_dlpi_send_queued(ill);
2507 ill_refrele(ill);
2513 * Here we handle ilgs that are still attached to their original ill
2515 * The detached ones might have been attached to some other ill.
2525 ill_t *ill;
2538 &ill);
2539 if (ill != NULL) {
2541 ill_refrele(ill);
2547 /* If the ilg is attached then we serialize using that ill */
2548 ill = ilg->ilg_ill;
2549 if (ill != NULL) {
2550 /* Prevent the ill and ilg from being freed */
2551 ill_refhold(ill);
2554 mutex_enter(&ill->ill_mcast_serializer);
2560 mutex_exit(&ill->ill_mcast_serializer);
2561 ill_refrele(ill);
2582 if (ill != NULL)
2600 if (ill != NULL)
2605 ASSERT(ill != NULL);
2609 if (ill != NULL) {
2610 mutex_exit(&ill->ill_mcast_serializer);
2615 ill_mcast_send_queued(ill);
2616 ill_dlpi_send_queued(ill);
2617 ill_refrele(ill);
2660 * In the normal case below we don't check for the ill existing.
2665 ill_t *ill;
2669 &ill);
2674 if (ill != NULL)
2675 ill_refrele(ill);
2697 uint_t ifindex, ill_t *ill, mcast_record_t fmode, const in6_addr_t *v6src)
2706 if (!(ill->ill_flags & ILLF_MULTICAST))
2710 ASSERT(MUTEX_HELD(&ill->ill_mcast_serializer));
2772 ilg->ilg_ill = ill;
2809 * Now update the ill. We wait to do this until after the ilg
2811 * info for the ill, which involves looking at the status of
2814 ilm = ip_addmulti_serial(v6group, ill, connp->conn_zoneid, ilgstat,
2868 * will rejoin when the ill comes back; don't report ENETDOWN
2889 * Find an IPv4 ilg matching group, ill and source.
2895 ill_t *ill)
2909 if (ilg->ilg_ill != ill)
2912 /* The callers use upper ill for IPMP */
2913 ASSERT(!IS_UNDER_IPMP(ill));
2929 * we have an ilg with matching ill and group; but
2951 * Find an IPv6 ilg matching group, ill, and source
2955 const in6_addr_t *v6src, ill_t *ill)
2967 if (ilg->ilg_ill != ill)
2970 /* The callers use upper ill for IPMP */
2971 ASSERT(!IS_UNDER_IPMP(ill));
2987 * we have an ilg with matching ill and group; but
3066 * proceed with the ilm part of the delete we hold a reference on both the ill
3082 ill_t *ill;
3111 ill = ilg->ilg_ilm->ilm_ill;
3114 * In order to serialize on the ill we try to enter
3119 if (!mutex_tryenter(&ill->ill_mcast_serializer)) {
3120 ill_refhold(ill);
3127 mutex_enter(&ill->ill_mcast_serializer);
3145 mutex_exit(&ill->ill_mcast_serializer);
3150 ill_mcast_send_queued(ill);
3151 ill_dlpi_send_queued(ill);
3153 /* Drop ill reference while we hold no locks */
3154 ill_refrele(ill);
3164 * Attach the ilg to an ilm on the ill. If it fails we leave ilg_ill as NULL so
3168 ilg_attach(conn_t *connp, ilg_t *ilg, ill_t *ill)
3199 ilg->ilg_ill = ill;
3203 ilm = ip_addmulti_serial(&v6group, ill, connp->conn_zoneid, ilgstat,
3234 * Called when an ill is unplumbed to make sure that there are no
3235 * dangling conn references to that ill. In that case ill is non-NULL and
3238 * memberships, in which case ill is NULL.
3244 * first, i.e. it must not refer to any ill/ire and then only set
3253 * then we attempt to reselect the ill and join on it.
3257 * proceed with the ilm part of the delete we hold a reference on both the ill
3261 * Note: if this function is called when new ill/ipif's arrive or change status
3263 * a NULL ilg_ill to an ill/ilm.
3268 ill_t *ill = (ill_t *)arg;
3286 if (ill != NULL)
3287 ilg_check_detach(connp, ill);
3289 ilg_check_reattach(connp, ill);
3299 /* Detach from an ill that is going away */
3301 ilg_check_detach(conn_t *connp, ill_t *ill)
3307 mutex_enter(&ill->ill_mcast_serializer);
3314 if (ilg->ilg_ill != ill)
3317 /* Detach from current ill */
3323 /* Detach this ilg from the ill/ilm */
3341 mutex_exit(&ill->ill_mcast_serializer);
3346 ill_mcast_send_queued(ill);
3347 ill_dlpi_send_queued(ill);
3353 * a better ill to attach them to. oill is non-null if we just detached from
3354 * that ill.
3359 ill_t *ill;
3374 ill = ill_mcast_lookup(&ilg->ilg_v6group, ilg->ilg_ifaddr,
3378 * Make sure the ill is usable for multicast and that
3382 if (ill != NULL &&
3383 (!(ill->ill_flags & ILLF_MULTICAST) || !ill->ill_dl_up)) {
3388 ill_refrele(ill);
3389 ill = NULL;
3395 * Is the ill unchanged, even if both are NULL?
3396 * Did we just detach from that ill?
3398 if (ill == ilg->ilg_ill || (ill != NULL && ill == oill)) {
3399 if (ill != NULL) {
3404 ill_refrele(ill);
3416 * In order to serialize on the ill we try to enter
3435 /* Detach from current ill */
3460 /* Drop ill reference while we hold no locks */
3469 if (ill != NULL) {
3474 ill_refrele(ill);
3481 if (ill != NULL) {
3483 * In order to serialize on the ill we try to enter
3486 if (!mutex_tryenter(&ill->ill_mcast_serializer)) {
3487 /* Already have a refhold on ill */
3491 mutex_enter(&ill->ill_mcast_serializer);
3503 * Attach to the new ill. Can fail in which
3510 ill->ill_name));
3511 ilg_attach(connp, ilg, ill);
3516 mutex_exit(&ill->ill_mcast_serializer);
3522 ill_mcast_send_queued(ill);
3523 ill_dlpi_send_queued(ill);
3524 ill_refrele(ill);
3534 * Called when an ill is unplumbed to make sure that there are no
3535 * dangling conn references to that ill. In that case ill is non-NULL and
3538 * memberships, in which case ill is NULL.
3541 update_conn_ill(ill_t *ill, ip_stack_t *ipst)
3543 ipcl_walk(conn_update_ill, (caddr_t)ill, ipst);