Lines Matching defs:ipif
131 static int ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
133 static int ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
135 static int ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
137 static int ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q,
139 static int ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
141 static int ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t, in6_addr_t,
149 static int ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen,
155 static ire_t **ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep);
156 static void ipif_delete_bcast_ires(ipif_t *ipif);
160 static int ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp);
161 static void ipif_free(ipif_t *ipif);
162 static void ipif_free_tail(ipif_t *ipif);
163 static void ipif_set_default(ipif_t *ipif);
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);
385 ipif_t *ipif;
401 * Walk down the ipif list and remove the logical interfaces
402 * first before removing the main ipif. We can't unplumb
411 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
412 ipif_free(ipif);
474 ipif_non_duplicate(ipif_t *ipif)
476 ill_t *ill = ipif->ipif_ill;
478 if (ipif->ipif_flags & IPIF_DUPLICATE) {
479 ipif->ipif_flags &= ~IPIF_DUPLICATE;
494 ipif_t *ipif;
497 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
498 ipif_non_duplicate(ipif);
499 (void) ipif_down_tail(ipif);
751 * ipif/ill/ire refcnts to drop to zero in bringing down an ipif.
754 ipsq_pending_mp_add(conn_t *connp, ipif_t *ipif, queue_t *q, mblk_t *add_mp,
757 ipxop_t *ipx = ipif->ipif_ill->ill_phyint->phyint_ipsq->ipsq_xop;
759 ASSERT(IAM_WRITER_IPIF(ipif));
760 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
764 * The caller may be using a different ipif than the one passed into
767 * that `ipx_current_ipif == ipif'.
791 ipx->ipx_pending_ipif = ipif;
804 connp->conn_oper_pending_ill = ipif->ipif_ill;
863 ipif_t *ipif;
897 ipif = ipx->ipx_pending_ipif;
917 int, cmd, ill_t *, ipif == NULL ? NULL : ipif->ipif_ill,
918 ipif_t *, ipif);
923 mutex_enter(&ipif->ipif_ill->ill_lock);
924 ipif->ipif_state_flags &= ~IPIF_CHANGING;
925 mutex_exit(&ipif->ipif_ill->ill_lock);
1046 * We may not be able to refhold the ill if the ill/ipif
1107 ipif_t *ipif;
1111 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
1112 ipif_non_duplicate(ipif);
1114 * ipif_down_tail will call arp_ll_down on the last ipif
1117 if ((err = ipif_down_tail(ipif)) != 0)
1142 ipif_t *ipif;
1162 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
1163 (void) ipif_down(ipif, NULL, NULL);
1523 * If no ipif was brought up over this ill, this DL_CAPABILITY_REQ/ACK
2742 ipif_t *ipif;
2746 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
2752 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
3688 ipif_t *ipif;
3752 ipif = ipif_allocate(ill, 0L, IRE_LOOPBACK, B_TRUE, B_TRUE, NULL);
3753 if (ipif == NULL)
3758 ov6addr = ipif->ipif_v6lcl_addr;
3763 IN6_IPADDR_TO_V4MAPPED(inaddr_loopback, &ipif->ipif_v6lcl_addr);
3764 V4MASK_TO_V6(htonl(IN_CLASSA_NET), ipif->ipif_v6net_mask);
3765 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3766 ipif->ipif_v6subnet);
3769 ipif->ipif_v6lcl_addr = ipv6_loopback;
3770 ipif->ipif_v6net_mask = ipv6_all_ones;
3771 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3772 ipif->ipif_v6subnet);
3796 sctp_update_ipif_addr(ipif, ov6addr);
3798 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
4204 * Allocate the first ipif on this ill. We don't delay it
4205 * further as ioctl handling assumes at least one ipif exists.
4406 * Find a mulitcast-capable ipif given an IP instance and zoneid.
4407 * The ipif must be up, and its ill must multicast-capable, not
4424 ipif_t *ipif;
4442 for (ipif = ill->ill_ipif; ipif != NULL;
4443 ipif = ipif->ipif_next) {
4444 if (zoneid != ipif->ipif_zoneid &&
4446 ipif->ipif_zoneid != ALL_ZONES) {
4449 if (!(ipif->ipif_flags & IPIF_UP) ||
4450 IPIF_IS_CONDEMNED(ipif)) {
4459 if (ipif->ipif_flags & IPIF_DEPRECATED) {
4461 dep_ipif = ipif;
4462 } else if (ipif_comp_multi(dep_ipif, ipif,
4472 dep_ipif = ipif;
4477 saved_ipif = ipif;
4479 if (ipif_comp_multi(saved_ipif, ipif, isv6)) {
4482 saved_ipif = ipif;
4521 ipif_t *ipif;
4524 ipif = ipif_lookup_multicast(ipst, zoneid, isv6);
4525 if (ipif == NULL)
4528 ill = ipif->ipif_ill;
4530 ipif_refrele(ipif);
4543 * any multicast capable interface and return it. The returned ipif
4563 * Look for an ipif with the specified interface address and destination.
4569 ipif_t *ipif;
4577 * ipif instead of unnumbered point-to-point ipif.
4583 for (ipif = ill->ill_ipif; ipif != NULL;
4584 ipif = ipif->ipif_next) {
4585 /* Allow the ipif to be down */
4586 if ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
4587 (ipif->ipif_lcl_addr == if_addr) &&
4588 (ipif->ipif_pp_dst_addr == dst)) {
4589 if (!IPIF_IS_CONDEMNED(ipif)) {
4590 ipif_refhold_locked(ipif);
4593 return (ipif);
4601 /* lookup the ipif based on interface address */
4602 ipif = ipif_lookup_addr(if_addr, NULL, ALL_ZONES, ipst);
4603 ASSERT(ipif == NULL || !ipif->ipif_isv6);
4604 return (ipif);
4614 ipif_t *ipif;
4634 for (ipif = ill->ill_ipif; ipif != NULL;
4635 ipif = ipif->ipif_next) {
4637 zoneid != ipif->ipif_zoneid &&
4638 ipif->ipif_zoneid != ALL_ZONES)
4641 if (no_duplicate && !(ipif->ipif_flags & IPIF_UP))
4644 /* Allow the ipif to be down */
4645 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4646 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4647 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4648 (ipif->ipif_pp_dst_addr == addr))) {
4649 if (!IPIF_IS_CONDEMNED(ipif)) {
4650 ipif_refhold_locked(ipif);
4653 return (ipif);
4670 * Lookup an ipif with the specified address. For point-to-point links we
4685 * Lookup an ipif with the specified address. Similar to ipif_lookup_addr,
4712 * Look for an ipif with the specified address. For point-point links
4718 * Return the zoneid for the ipif which matches. ALL_ZONES if no match.
4724 ipif_t *ipif;
4742 for (ipif = ill->ill_ipif; ipif != NULL;
4743 ipif = ipif->ipif_next) {
4744 /* Allow the ipif to be down */
4745 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4746 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4747 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4748 (ipif->ipif_pp_dst_addr == addr)) &&
4749 !(ipif->ipif_state_flags & IPIF_CONDEMNED)) {
4750 zoneid = ipif->ipif_zoneid;
4776 * Look for an ipif that matches the specified remote address i.e. the
4777 * ipif that would receive the specified packet.
4779 * IRE lookup and pick the first ipif corresponding to the source address in the
4781 * Returns: held ipif
4788 ipif_t *ipif;
4793 * Someone could be changing this ipif currently or change it
4800 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4801 if (IPIF_IS_CONDEMNED(ipif))
4803 if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid &&
4804 ipif->ipif_zoneid != ALL_ZONES)
4806 /* Allow the ipif to be down */
4807 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
4808 if ((ipif->ipif_pp_dst_addr == addr) ||
4809 (!(ipif->ipif_flags & IPIF_UNNUMBERED) &&
4810 ipif->ipif_lcl_addr == addr)) {
4811 ipif_refhold_locked(ipif);
4813 return (ipif);
4815 } else if (ipif->ipif_subnet == (addr & ipif->ipif_net_mask)) {
4816 ipif_refhold_locked(ipif);
4818 return (ipif);
4824 * ipif.
4828 ipif = ipif_get_next_ipif(NULL, ill);
4829 return (ipif);
4840 ipif_t *ipif;
4844 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4845 if (ipif->ipif_refcnt != 0)
4857 ipif_t *ipif;
4861 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4862 if (ipif->ipif_refcnt != 0) {
4875 * can be used to determine whether the ipif has become quiescent
4878 ipif_is_quiescent(ipif_t *ipif)
4882 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4884 if (ipif->ipif_refcnt != 0)
4887 ill = ipif->ipif_ill;
4893 /* This is the last ipif going down or being deleted on this ill */
4902 * return true if the ipif can be destroyed: the ipif has to be quiescent
4906 ipif_is_freeable(ipif_t *ipif)
4908 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4909 ASSERT(ipif->ipif_id != 0);
4910 return (ipif->ipif_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
4926 ipif_t *ipif;
4945 ipif = ipx->ipx_pending_ipif;
4946 if (ipif->ipif_ill != ill) /* wait is for another ill; bail */
4951 if (!ipif_is_quiescent(ipif))
4955 if (!ipif_is_freeable(ipif))
5205 ipif_trace_ref(ipif_t *ipif)
5207 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5209 if (ipif->ipif_trace_disable)
5212 if (!th_trace_ref(ipif, ipif->ipif_ill->ill_ipst)) {
5213 ipif->ipif_trace_disable = B_TRUE;
5214 ipif_trace_cleanup(ipif);
5219 ipif_untrace_ref(ipif_t *ipif)
5221 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5223 if (!ipif->ipif_trace_disable)
5224 th_trace_unref(ipif);
5251 * Called when ipif is unplumbed or when memory alloc fails. Note that on
5255 ipif_trace_cleanup(const ipif_t *ipif)
5257 th_trace_cleanup(ipif, ipif->ipif_trace_disable);
5272 ipif_refhold_locked(ipif_t *ipif)
5274 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5275 ipif->ipif_refcnt++;
5276 IPIF_TRACE_REF(ipif);
5280 ipif_refhold(ipif_t *ipif)
5284 ill = ipif->ipif_ill;
5286 ipif->ipif_refcnt++;
5287 IPIF_TRACE_REF(ipif);
5298 ipif_refrele(ipif_t *ipif)
5302 ill = ipif->ipif_ill;
5305 ASSERT(ipif->ipif_refcnt != 0);
5306 ipif->ipif_refcnt--;
5307 IPIF_UNTRACE_REF(ipif);
5308 if (ipif->ipif_refcnt != 0) {
5320 ipif_t *ipif;
5323 for (ipif = (curr == NULL ? ill->ill_ipif : curr->ipif_next);
5324 ipif != NULL; ipif = ipif->ipif_next) {
5325 if (IPIF_IS_CONDEMNED(ipif))
5327 ipif_refhold_locked(ipif);
5329 return (ipif);
5412 ipif_t *ipif = NULL;
5445 * Get the ipif, if any, corresponding to the gw_addr
5451 ipif = ipif_lookup_addr(gw_addr, ill, ALL_ZONES, ipst);
5453 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
5454 if (ipif != NULL) {
5455 if (IS_VNI(ipif->ipif_ill)) {
5456 ipif_refrele(ipif);
5467 if ((ipif != NULL) && (ipif->ipif_ire_type == IRE_LOOPBACK)) {
5476 ipif_refrele(ipif);
5480 "for 0x%x\n", (void *)ipif,
5481 ipif->ipif_ire_type,
5482 ntohl(ipif->ipif_lcl_addr)));
5487 ipif->ipif_ire_type, /* LOOPBACK */
5488 ipif->ipif_ill,
5490 (ipif->ipif_flags & IPIF_PRIVATE) ? RTF_PRIVATE : 0,
5495 ipif_refrele(ipif);
5509 ipif_refrele(ipif);
5520 ipif_refrele(ipif);
5534 if ((flags & RTF_MULTIRT) && ipif != NULL)
5562 * of using the interface index, however, is that all of the ipif's that
5564 * cannot be used to differentiate between ipif's (or logical
5574 * the ipif's corresponding to each of these interface routes can be
5590 if (ipif != NULL)
5591 ipif_refrele(ipif);
5599 if (ipif == NULL)
5609 * one matching the ipif to make sure we can delete the route.
5613 ill = ipif->ipif_ill;
5614 } else if (ill != ipif->ipif_ill) {
5615 ipif_refrele(ipif);
5633 ipif_refrele(ipif);
5675 ipif_refrele(ipif);
5690 ipif_refrele(ipif);
5700 ipif_refrele(ipif);
5738 if (ipif != NULL)
5739 ipif_refrele(ipif);
5744 if (ipif != NULL)
5745 ipif_refrele(ipif);
5775 if (ipif != NULL)
5776 ipif_refrele(ipif);
5793 if (ipif != NULL)
5794 ipif_refrele(ipif);
5808 if (ipif != NULL)
5809 ipif_refrele(ipif);
5839 if (ipif != NULL)
5840 ipif_refrele(ipif);
5868 if (ipif != NULL)
5869 ipif_refrele(ipif);
5880 if (ipif != NULL)
5881 ipif_refrele(ipif);
5923 if (ipif != NULL)
5924 ipif_refrele(ipif);
5962 if (ipif != NULL)
5963 ipif_refrele(ipif);
5978 ipif_t *ipif;
6014 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
6015 if (ipif != NULL) {
6021 ill_match = ipif->ipif_ill;
6024 if (ipif->ipif_ire_type == IRE_LOOPBACK) {
6035 /* Avoid deleting routes created by kernel from an ipif */
6068 if (ipif != NULL) {
6069 ipif_refrele(ipif);
6070 ipif = NULL;
6115 ipif_t *ipif = NULL;
6143 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6148 if (ipif != NULL)
6149 ipif_refrele(ipif);
6167 ipif_t *ipif = NULL;
6195 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6201 if (ipif != NULL)
6202 ipif_refrele(ipif);
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'
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));
6763 if (ipif != NULL)
6764 ill = ipif->ipif_ill;
6890 * Start the current exclusive operation on `ipsq'; associate it with `ipif'
6894 ipsq_current_start(ipsq_t *ipsq, ipif_t *ipif, int ioccmd)
6896 ill_t *ill = ipif->ipif_ill;
6906 ipx->ipx_current_ipif = ipif;
6912 * references to the ipif (so that the references will eventually
6914 * SIOCGLIFFLAGS) from being able to access the ipif until the
6915 * operation has completed and the ipif is again in a stable state.
6917 * For ioctls, IPIF_CHANGING is set on the ipif associated with the
6923 * IPIF_CONDEMNED internally after identifying the right ipif to
6931 ipif = ipif->ipif_ill->ill_ipif;
6932 for (; ipif != NULL; ipif = ipif->ipif_next)
6933 ipif->ipif_state_flags |= IPIF_CHANGING;
6938 ipif->ipif_state_flags |= IPIF_CHANGING;
6956 ipif_t *ipif = ipx->ipx_current_ipif;
6961 * For SIOCLIFREMOVEIF, the ipif has been already been blown away
6966 ill_t *ill = ipif->ipif_ill;
6971 ipif = ill->ill_ipif;
6972 for (; ipif != NULL; ipif = ipif->ipif_next)
6973 ipif->ipif_state_flags &= ~IPIF_CHANGING;
6975 ipif->ipif_state_flags &= ~IPIF_CHANGING;
7036 * and return the associated ipif.
7040 * a held ipif in ci.ci_ipif.
7049 ipif_t *ipif = NULL;
7120 ipif = ill->ill_ipif;
7121 ipif_refhold(ipif);
7128 ipif = ipif_lookup_on_name_async(name, mi_strlen(name),
7130 if (ipif == NULL) {
7138 * Old style [GS]IFCMD does not admit IPv6 ipif
7140 if (ipif != NULL && ipif->ipif_isv6 && ipip->ipi_cmd_type == IF_CMD) {
7141 ipif_refrele(ipif);
7145 if (ipif == NULL && ill != NULL && ill->ill_ipif != NULL &&
7151 ipif = ill->ill_ipif;
7152 ipif_refhold(ipif);
7155 if (ipif == NULL)
7159 int, ipip->ipi_cmd, ill_t *, ipif->ipif_ill, ipif_t *, ipif);
7161 ci->ci_ipif = ipif;
7174 ipif_t *ipif;
7181 for (ipif = ill->ill_ipif; ipif != NULL;
7182 ipif = ipif->ipif_next) {
7183 if (ipif->ipif_zoneid == zoneid ||
7184 ipif->ipif_zoneid == ALL_ZONES)
7200 ipif_t *ipif;
7217 for (ipif = ill->ill_ipif; ipif != NULL;
7218 ipif = ipif->ipif_next) {
7219 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7222 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7225 if (((ipif->ipif_flags &
7229 !(ipif->ipif_flags & IPIF_UP)) &&
7233 if (zoneid != ipif->ipif_zoneid &&
7234 ipif->ipif_zoneid != ALL_ZONES &&
7270 /* Null values are passed in for ipif, sin, and ifreq */
7290 /* Null values are passed in for ipif, sin, and ifreq */
7332 ipif_t *ipif;
7427 for (ipif = ill->ill_ipif; ipif != NULL;
7428 ipif = ipif->ipif_next) {
7429 if (zoneid != ipif->ipif_zoneid &&
7430 ipif->ipif_zoneid != ALL_ZONES)
7441 ipif_get_name(ipif, ifr->ifr_name,
7446 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7472 ipif_t *ipif, *orig_ipif;
7506 ipif = ipif_lookup_on_ifindex(ifindex, isv6, zoneid, ipst);
7507 if (ipif == NULL) {
7508 ip1dbg(("ip_sioctl_get_lifsrcof: no ipif for ifindex %d\n",
7514 numlifs = ip_get_lifsrcofnum(ipif->ipif_ill);
7522 ipif_refrele(ipif);
7529 ipif_refrele(ipif);
7538 ill = ill_head = ipif->ipif_ill;
7539 orig_ipif = ipif;
7552 ipif = ill->ill_ipif;
7553 ipif_get_name(ipif, lifr->lifr_name, sizeof (lifr->lifr_name));
7554 if (ipif->ipif_isv6) {
7558 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
7560 &ipif->ipif_v6net_mask);
7565 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7567 ipif->ipif_net_mask);
7588 ipif_t *ipif;
7697 for (ipif = ill->ill_ipif; ipif != NULL;
7698 ipif = ipif->ipif_next) {
7699 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7703 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7707 if (((ipif->ipif_flags &
7711 !(ipif->ipif_flags & IPIF_UP)) &&
7715 if (zoneid != ipif->ipif_zoneid &&
7716 ipif->ipif_zoneid != ALL_ZONES &&
7730 ipif_get_name(ipif, lifr->lifr_name,
7733 if (ipif->ipif_isv6) {
7738 ipif->ipif_v6lcl_addr;
7741 &ipif->ipif_v6net_mask);
7747 ipif->ipif_lcl_addr;
7750 ipif->ipif_net_mask);
8164 ip_sioctl_tmysite(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8173 ip_sioctl_arp(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8185 ill_t *ill = ipif->ipif_ill;
8352 ipif_t *ipif = ipif_get_next_ipif(NULL, ill);
8353 if (ipif != NULL) {
8354 ip_nce_lookup_and_update(&ipaddr, ipif, ipst,
8356 ipif_refrele(ipif);
8410 * the associated sin and refhold and return the associated ipif via `ci'.
8419 ipif_t *ipif;
8457 ipif = ipif_lookup_on_name(sdl->sdl_data, sdl->sdl_nlen,
8459 if (ipif == NULL)
8461 if (ipif->ipif_id != 0) {
8462 ipif_refrele(ipif);
8468 * of 0: use the IP address to find the ipif. If the IP
8472 ipif = ipif_lookup_addr(sin->sin_addr.s_addr, NULL, ALL_ZONES,
8474 if (ipif == NULL) {
8484 ipif = ill->ill_ipif;
8485 ipif_refhold(ipif);
8490 if (ipif->ipif_ill->ill_net_type != IRE_IF_RESOLVER) {
8491 ipif_refrele(ipif);
8496 ci->ci_ipif = ipif;
8724 * If there's at least one up ipif on this ill, then we're bound to
9268 * If ipif is NULL (i.e. the lookup didn't find one) attempt to create an
9269 * ipif with the specified name.
9277 * So no lock is needed to traverse the ipif chain, or examine the
9293 ipif_t *ipif;
9332 ipif = ipif_lookup_on_name(lifr->lifr_name, namelen, B_TRUE,
9335 if (ipif == NULL) {
9338 /* We created the ipif now and as writer */
9339 ipif_refrele(ipif);
9342 ill = ipif->ipif_ill;
9344 ipif_refrele(ipif);
9395 for (ipif = ill->ill_ipif; ipif != NULL;
9396 ipif = ipif->ipif_next) {
9397 if (ipif->ipif_id == id) {
9409 if ((ipif = ipif_allocate(ill, found_sep ? id : -1, IRE_LOCAL,
9416 IPIF_SEPARATOR_CHAR, ipif->ipif_id);
9422 err = ip_sioctl_addr(ipif, sin, q, mp,
9439 ip_sioctl_removeif(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9443 ill_t *ill = ipif->ipif_ill;
9451 ill->ill_name, ipif->ipif_id, (void *)ipif));
9452 ASSERT(IAM_WRITER_IPIF(ipif));
9463 * ipif->ipif_id != 0 so that the code path for that case is the
9467 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9475 for (ipif = ill->ill_ipif; ipif != NULL;
9476 ipif = ipif->ipif_next) {
9477 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9481 ipif = ill->ill_ipif;
9495 success = ipsq_pending_mp_add(connp, ipif,
9506 if (ipif->ipif_id == 0) {
9510 if (ipif->ipif_isv6) {
9518 ipif = ipif_lookup_addr_exact_v6(&sin6->sin6_addr, ill,
9525 ipif = ipif_lookup_addr_exact(sin->sin_addr.s_addr, ill,
9528 if (ipif == NULL) {
9536 * So update ipx_current_ipif now that ipif points to the
9539 ipsq = ipif->ipif_ill->ill_phyint->phyint_ipsq;
9540 ipsq->ipsq_xop->ipx_current_ipif = ipif;
9543 ipif_refrele(ipif);
9549 if (ipif->ipif_id == 0)
9553 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9556 ipif_free(ipif);
9561 /* Are any references to this ipif active */
9562 if (ipif_is_freeable(ipif)) {
9565 ipif_non_duplicate(ipif);
9566 (void) ipif_down_tail(ipif);
9567 ipif_free_tail(ipif); /* frees ipif */
9570 success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp,
9582 * The ipif is already condemned. So can't find it thru lookups.
9586 ip_sioctl_removeif_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q,
9589 ill_t *ill = ipif->ipif_ill;
9591 ASSERT(IAM_WRITER_IPIF(ipif));
9592 ASSERT(ipif->ipif_state_flags & IPIF_CONDEMNED);
9595 ill->ill_name, ipif->ipif_id, (void *)ipif));
9597 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9604 ipif_non_duplicate(ipif);
9605 (void) ipif_down_tail(ipif);
9606 ipif_free_tail(ipif);
9616 ip_sioctl_prefix(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9626 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9628 ASSERT(IAM_WRITER_IPIF(ipif));
9630 if (!ipif->ipif_isv6)
9638 ill = ipif->ipif_ill;
9647 err = ip_sioctl_addr(ipif, sin, q, mp,
9658 ip_sioctl_prefix_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9662 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9663 return (ip_sioctl_addr_restart(ipif, sin, q, mp, ipip, ifreq));
9672 ip_sioctl_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9682 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9684 ASSERT(IAM_WRITER_IPIF(ipif));
9686 ill = ipif->ipif_ill;
9687 if (ipif->ipif_isv6) {
9702 * However for those ipif's for which link-local address was
9704 * This scenario would arise, when we delete an address on ipif
9707 if (ipif->ipif_id == 0 &&
9709 !(ipif->ipif_flags & (IPIF_POINTOPOINT)) &&
9715 * this ill, allow setting :: as the address on ipif:0.
9730 if ((ipif->ipif_flags & IPIF_UP) &&
9732 (!(ipif->ipif_flags & IPIF_NOLOCAL) ||
9733 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) {
9737 if (!ip_local_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
9749 !ip_addr_ok_v4(addr, ipif->ipif_net_mask))
9773 if (ipif->ipif_flags & IPIF_UP) {
9785 err = ipif_logical_down(ipif, q, mp);
9788 (void) ipif_down_tail(ipif);
9792 err = ip_sioctl_addr_tail(ipif, sin, q, mp, need_up);
9797 ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9806 ill_t *ill = ipif->ipif_ill;
9814 ill->ill_name, ipif->ipif_id, (void *)ipif));
9815 ASSERT(IAM_WRITER_IPIF(ipif));
9818 if (ipif->ipif_recovery_id != 0)
9819 (void) untimeout(ipif->ipif_recovery_id);
9820 ipif->ipif_recovery_id = 0;
9822 if (ipif->ipif_isv6) {
9832 ov6addr = ipif->ipif_v6lcl_addr;
9833 ipif->ipif_v6lcl_addr = v6addr;
9834 sctp_update_ipif_addr(ipif, ov6addr);
9835 ipif->ipif_addr_ready = 0;
9837 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
9849 if (ipif->ipif_flags & IPIF_DUPLICATE) {
9851 ipif->ipif_flags &= ~IPIF_DUPLICATE;
9858 ipif_set_default(ipif);
9861 * If we've just manually set the IPv6 link-local address (0th ipif),
9866 if (ipif->ipif_isv6 && ipif->ipif_id == 0) {
9881 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ipif->ipif_id),
9896 err = ipif_up(ipif, q, mp);
9906 (void) ipif_arp_down(ipif);
9923 ip_sioctl_addr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9927 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9928 ASSERT(IAM_WRITER_IPIF(ipif));
9929 (void) ipif_down_tail(ipif);
9930 return (ip_sioctl_addr_tail(ipif, sin, q, mp, B_TRUE));
9935 ip_sioctl_get_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9942 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9945 * reference to the ipif. So no lock is necessary.
9947 if (ipif->ipif_isv6) {
9950 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
9953 ipif->ipif_ill->ill_phyint->phyint_ifindex;
9957 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
9961 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
9964 ip_mask_to_plen(ipif->ipif_net_mask);
9975 ip_sioctl_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9983 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9984 ASSERT(IAM_WRITER_IPIF(ipif));
9986 if (ipif->ipif_isv6) {
9995 if (!ip_remote_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
10005 !ip_addr_ok_v4(addr, ipif->ipif_net_mask)) {
10012 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6pp_dst_addr, &v6addr))
10015 if (ipif->ipif_flags & IPIF_UP) {
10022 err = ipif_logical_down(ipif, q, mp);
10025 (void) ipif_down_tail(ipif);
10032 err = ip_sioctl_dstaddr_tail(ipif, sin, q, mp, need_up);
10037 ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10041 ill_t *ill = ipif->ipif_ill;
10047 ipif->ipif_id, (void *)ipif));
10050 if (ipif->ipif_recovery_id != 0)
10051 (void) untimeout(ipif->ipif_recovery_id);
10052 ipif->ipif_recovery_id = 0;
10054 if (ipif->ipif_isv6) {
10067 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10074 ipif->ipif_flags |= IPIF_POINTOPOINT;
10075 ipif->ipif_flags &= ~IPIF_BROADCAST;
10076 if (ipif->ipif_isv6)
10088 if (ipif->ipif_flags & IPIF_DUPLICATE) {
10090 ipif->ipif_flags &= ~IPIF_DUPLICATE;
10099 * (0th ipif), tag the ill so that future updates to the destination
10104 if (ipif->ipif_isv6 && ipif->ipif_id == 0)
10108 ipif->ipif_v6pp_dst_addr = v6addr;
10110 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
10122 err = ipif_up(ipif, q, mp);
10127 if (need_arp_down && !ipif->ipif_isv6)
10128 (void) ipif_arp_down(ipif);
10139 ip_sioctl_dstaddr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10143 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10144 (void) ipif_down_tail(ipif);
10145 return (ip_sioctl_dstaddr_tail(ipif, sin, q, mp, B_TRUE));
10150 ip_sioctl_get_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10156 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10159 * change since we hold a reference to the ipif.
10161 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0)
10164 if (ipif->ipif_isv6) {
10168 sin6->sin6_addr = ipif->ipif_v6pp_dst_addr;
10172 sin->sin_addr.s_addr = ipif->ipif_pp_dst_addr;
10185 ip_sioctl_flags_onoff(ipif_t *ipif, uint64_t flags, uint64_t *onp,
10188 ill_t *ill = ipif->ipif_ill;
10193 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10219 ip_sioctl_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10236 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10238 ASSERT(IAM_WRITER_IPIF(ipif));
10240 ill = ipif->ipif_ill;
10251 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10258 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10274 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10336 if ((turn_on & IFF_TEMPORARY) && !(ipif->ipif_isv6))
10342 if ((turn_off & IFF_NOXMIT) && IS_VNI(ipif->ipif_ill))
10358 if (ipif->ipif_id == 0 && ipif->ipif_isv6 &&
10360 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) {
10361 if (ipif_cant_setlinklocal(ipif))
10426 if (!(ipif->ipif_flags & IPIF_UP) &&
10431 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10432 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10476 ipif->ipif_state_flags |= IPIF_SET_LINKLOCAL;
10488 if (ipif->ipif_isv6 &&
10489 ((IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
10490 (!(ipif->ipif_flags & IPIF_NOLOCAL) && !(turn_on & IPIF_NOLOCAL) ||
10491 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) ||
10492 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10493 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6pp_dst_addr)))) {
10501 if (!ipif->ipif_isv6 &&
10502 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10503 ipif->ipif_pp_dst_addr == INADDR_ANY)) {
10512 * done by bring the ipif down, changing the flags and bringing
10533 if (((ipif->ipif_flags | turn_on) & IPIF_UP) &&
10535 if (ipif->ipif_flags & IPIF_UP)
10539 err = ipif_down(ipif, q, mp);
10543 (void) ipif_down_tail(ipif);
10566 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10570 ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q, mblk_t *mp)
10580 ipif->ipif_ill->ill_name, ipif->ipif_id));
10582 ASSERT(IAM_WRITER_IPIF(ipif));
10584 ill = ipif->ipif_ill;
10587 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10604 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10605 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10610 if (ipif->ipif_state_flags & IPIF_SET_LINKLOCAL) {
10612 ipif->ipif_state_flags &= ~IPIF_SET_LINKLOCAL;
10619 (void) ipif_setlinklocal(ipif);
10648 } else if ((flags & IFF_UP) && !(ipif->ipif_flags & IPIF_UP)) {
10656 err = ipif_up(ipif, q, mp);
10672 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
10678 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10691 ip_sioctl_flags_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10700 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10713 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10715 (void) ipif_down_tail(ipif);
10717 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10725 ip_sioctl_get_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10731 ill_t *ill = ipif->ipif_ill;
10735 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10738 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10742 * references to the ipif.
10749 ifr->ifr_flags = ((ipif->ipif_flags |
10755 lifr->lifr_flags = ipif->ipif_flags |
10768 ip_sioctl_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10777 ip1dbg(("ip_sioctl_mtu(%s:%u %p)\n", ipif->ipif_ill->ill_name,
10778 ipif->ipif_id, (void *)ipif));
10787 if (ipif->ipif_id != 0)
10790 ill = ipif->ipif_ill;
10791 if (ipif->ipif_isv6)
10826 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10833 ip_sioctl_get_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10840 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10848 ifr->ifr_metric = ipif->ipif_ill->ill_mtu;
10851 lifr->lifr_mtu = ipif->ipif_ill->ill_mtu;
10859 ip_sioctl_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10864 ill_t *ill = ipif->ipif_ill;
10868 ipif->ipif_id));
10870 ASSERT(IAM_WRITER_IPIF(ipif));
10871 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10874 ASSERT(!(ipif->ipif_isv6)); /* No IPv6 broadcast */
10881 if (ipif->ipif_flags & IPIF_UP) {
10888 ill, ipif->ipif_zoneid, NULL,
10897 * Changing the broadcast addr for this ipif. Since the IRE_BROADCAST
10901 if (addr != ipif->ipif_brd_addr)
10902 IN6_IPADDR_TO_V4MAPPED(addr, &ipif->ipif_v6brd_addr);
10910 ip_sioctl_get_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10914 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10915 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10919 ASSERT(!ipif->ipif_isv6);
10922 sin->sin_addr.s_addr = ipif->ipif_brd_addr;
10931 ip_sioctl_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10938 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10940 ASSERT(IAM_WRITER_IPIF(ipif));
10942 if (ipif->ipif_isv6) {
10966 if (!(ipif->ipif_flags & IPIF_UP) ||
10967 IN6_ARE_ADDR_EQUAL(&v6mask, &ipif->ipif_v6net_mask) ||
10968 (ipif->ipif_flags & IPIF_POINTOPOINT)) {
10969 ipif->ipif_v6net_mask = v6mask;
10970 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10971 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
10972 ipif->ipif_v6net_mask,
10973 ipif->ipif_v6subnet);
10981 err = ipif_logical_down(ipif, q, mp);
10984 (void) ipif_down_tail(ipif);
10985 err = ip_sioctl_netmask_tail(ipif, sin, q, mp);
10990 ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp)
10996 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10998 if (ipif->ipif_isv6) {
11010 ipif->ipif_v6net_mask = v6mask;
11011 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11012 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
11013 ipif->ipif_v6subnet);
11015 err = ipif_up(ipif, q, mp);
11024 if (!ipif->ipif_isv6 && ipif->ipif_ill->ill_wq != NULL) {
11026 ipif_mask_reply(ipif);
11034 ip_sioctl_netmask_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11038 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11039 (void) ipif_down_tail(ipif);
11040 return (ip_sioctl_netmask_tail(ipif, sin, q, mp));
11046 ip_sioctl_get_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11053 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11056 * net mask can't change since we have a reference to the ipif.
11058 if (ipif->ipif_isv6) {
11062 sin6->sin6_addr = ipif->ipif_v6net_mask;
11064 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11068 sin->sin_addr.s_addr = ipif->ipif_net_mask;
11071 ip_mask_to_plen(ipif->ipif_net_mask);
11079 ip_sioctl_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11083 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11089 if (IS_UNDER_IPMP(ipif->ipif_ill))
11101 ipif->ipif_ill->ill_metric = ifr->ifr_metric;
11106 ipif->ipif_ill->ill_metric = lifr->lifr_metric;
11113 ip_sioctl_get_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11118 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11124 ifr->ifr_metric = ipif->ipif_ill->ill_metric;
11129 lifr->lifr_metric = ipif->ipif_ill->ill_metric;
11137 ip_sioctl_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11143 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11150 ipif->ipif_ill->ill_muxid = ifr->ifr_ip_muxid;
11155 ipif->ipif_ill->ill_muxid = lifr->lifr_ip_muxid;
11158 arl_set_muxid(ipif->ipif_ill, arp_muxid);
11164 ip_sioctl_get_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11170 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11174 arp_muxid = arl_get_muxid(ipif->ipif_ill);
11178 ifr->ifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11183 lifr->lifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11194 ip_sioctl_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11204 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11206 ASSERT(IAM_WRITER_IPIF(ipif));
11209 if (ipif->ipif_isv6) {
11240 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6subnet, &v6addr) &&
11241 IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6net_mask, &v6mask))
11244 if (ipif->ipif_flags & IPIF_UP) {
11251 err = ipif_logical_down(ipif, q, mp);
11254 (void) ipif_down_tail(ipif);
11258 err = ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, need_up);
11263 ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t v6addr, in6_addr_t v6mask,
11266 ill_t *ill = ipif->ipif_ill;
11270 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11274 ipif->ipif_v6net_mask = v6mask;
11275 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11276 V6_MASK_COPY(v6addr, ipif->ipif_v6net_mask,
11277 ipif->ipif_v6subnet);
11290 err = ipif_up(ipif, q, mp);
11299 ip_sioctl_subnet_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11308 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11309 (void) ipif_down_tail(ipif);
11312 if (ipif->ipif_isv6) {
11326 return (ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, B_TRUE));
11331 ip_sioctl_get_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11338 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11341 if (ipif->ipif_isv6) {
11344 sin6->sin6_addr = ipif->ipif_v6subnet;
11346 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11350 sin->sin_addr.s_addr = ipif->ipif_subnet;
11351 lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask);
11361 ip_sioctl_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11364 ill_t *ill = ipif->ipif_ill;
11375 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11376 ASSERT(IAM_WRITER_IPIF(ipif));
11380 if (ipif->ipif_id != 0)
11383 if (!ipif->ipif_isv6)
11406 if (ipif->ipif_flags & IPIF_UP) {
11407 err = ipif_logical_down(ipif, q, mp);
11410 (void) ipif_down_tail(ipif);
11413 err = ip_sioctl_token_tail(ipif, sin6, addrlen, q, mp, need_up);
11418 ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen, queue_t *q,
11423 ill_t *ill = ipif->ipif_ill;
11428 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11458 err = ipif_up(ipif, q, mp);
11467 ip_sioctl_get_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11475 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11476 if (ipif->ipif_id != 0)
11479 ill = ipif->ipif_ill;
11497 ip_sioctl_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11500 ill_t *ill = ipif->ipif_ill;
11506 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11508 ASSERT(IAM_WRITER_IPIF(ipif));
11511 if (ipif->ipif_id != 0)
11515 if (ipif->ipif_isv6)
11595 ip_sioctl_get_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11599 ill_t *ill = ipif->ipif_ill;
11602 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11603 if (ipif->ipif_id != 0)
11627 ipif_t *ipif;
11643 for (ipif = ill->ill_ipif; ipif != NULL;
11644 ipif = ipif->ipif_next) {
11645 if (IPIF_IS_CONDEMNED(ipif))
11647 if (!(ipif->ipif_flags & IPIF_UP))
11649 if ((ipif->ipif_subnet & net_mask) ==
11655 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
11657 ipif_refhold_locked(ipif);
11658 fallback_ipif = ipif;
11667 ipif_refhold_locked(ipif);
11672 *ipifp = ipif;
11673 return (ipif->ipif_net_mask);
11773 * Assign a unique id for the ipif. This is used by sctp_addr.c
11774 * Note: remove if sctp_addr.c is redone to not shadow ill/ipif data structures.
11777 ipif_assign_seqid(ipif_t *ipif)
11779 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
11781 ipif->ipif_seqid = atomic_inc_64_nv(&ipst->ips_ipif_g_seqid);
11818 * (unreferenced) ipif. Also, if `sipif' is used by the current xop, then
11832 * Grab all of the locks that protect the ipif in a defined order.
11875 * Insert the ipif, so that the list of ipifs on the ill will be sorted
11876 * with respect to ipif_id. Note that an ipif with an ipif_id of -1 will
11881 ipif_insert(ipif_t *ipif, boolean_t acquire_g_lock)
11889 ASSERT(ipif->ipif_ill->ill_net_type == IRE_LOOPBACK ||
11890 IAM_WRITER_IPIF(ipif));
11892 ill = ipif->ipif_ill;
11904 id = ipif->ipif_id;
11921 ipif->ipif_id = id; /* assign new id */
11923 /* we have a real id; insert ipif in the right place */
11939 ipif->ipif_next = tipif;
11940 *tipifp = ipif;
11949 ipif_remove(ipif_t *ipif)
11952 ill_t *ill = ipif->ipif_ill;
11959 if (*ipifp == ipif) {
11960 *ipifp = ipif->ipif_next;
11987 ipif_t *ipif;
11997 if ((ipif = mi_alloc(sizeof (ipif_t), BPRI_MED)) == NULL) {
12002 *ipif = ipif_zero; /* start clean */
12004 ipif->ipif_ill = ill;
12005 ipif->ipif_id = id; /* could be -1 */
12010 ipif->ipif_zoneid = ill->ill_zoneid;
12012 ipif->ipif_refcnt = 0;
12015 if ((err = ipif_insert(ipif, ire_type != IRE_LOOPBACK)) != 0) {
12016 mi_free(ipif);
12022 id = ipif->ipif_id;
12027 ipif_assign_seqid(ipif);
12030 * If this is the zeroth ipif on the IPMP ill, create the illgrp
12031 * (which must not exist yet because the zeroth ipif is created once
12039 ipif_remove(ipif);
12042 mi_free(ipif);
12050 * We grab ill_lock to protect the flag changes. The ipif is still
12056 ipif->ipif_ire_type = ire_type;
12058 if (ipif->ipif_isv6) {
12067 &ipif->ipif_v6lcl_addr);
12069 &ipif->ipif_v6subnet);
12071 &ipif->ipif_v6net_mask);
12073 &ipif->ipif_v6brd_addr);
12075 &ipif->ipif_v6pp_dst_addr);
12097 if (!ipif->ipif_isv6)
12098 ipif->ipif_flags |= IPIF_BROADCAST;
12101 if (ipif->ipif_isv6)
12115 ipif->ipif_flags |= IPIF_NOXMIT;
12120 ipif->ipif_flags |= IPIF_POINTOPOINT;
12126 return (ipif);
12134 ipif_arp_down(ipif_t *ipif)
12136 ill_t *ill = ipif->ipif_ill;
12139 ip1dbg(("ipif_arp_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
12140 ASSERT(IAM_WRITER_IPIF(ipif));
12143 ill_t *, ill, ipif_t *, ipif);
12144 ipif_nce_down(ipif);
12147 * If this is the last ipif that is going down and there are no
12154 * If this was the last ipif on an IPMP interface, purge any
12183 ipif_resolver_up(ipif_t *ipif, enum ip_resolver_action res_act)
12185 ill_t *ill = ipif->ipif_ill;
12190 ill->ill_name, ipif->ipif_id, (uint_t)ipif->ipif_flags));
12191 ASSERT(IAM_WRITER_IPIF(ipif));
12195 ipif->ipif_addr_ready = 0;
12201 if (ipif->ipif_flags & IPIF_DUPLICATE) {
12202 ipif->ipif_flags &= ~IPIF_DUPLICATE;
12208 if (ipif->ipif_recovery_id != 0)
12209 (void) untimeout(ipif->ipif_recovery_id);
12210 ipif->ipif_recovery_id = 0;
12212 ipif->ipif_addr_ready = 1;
12219 err = ipif_arp_up(ipif, res_act, was_dup);
12228 ipif_nce_start_dad(ipif_t *ipif)
12231 ill_t *ill = ipif->ipif_ill;
12235 ncec = ncec_lookup_illgrp_v6(ipif->ipif_ill,
12236 &ipif->ipif_v6lcl_addr);
12241 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
12242 ipif->ipif_lcl_addr == INADDR_ANY) {
12249 ipif_mask_reply(ipif);
12250 ipif_up_notify(ipif);
12251 ipif->ipif_addr_ready = 1;
12255 IN6_V4MAPPED_TO_IPADDR(&ipif->ipif_v6lcl_addr, v4addr);
12256 ncec = ncec_lookup_illgrp_v4(ipif->ipif_ill, &v4addr);
12260 ip1dbg(("couldn't find ncec for ipif %p leaving !ready\n",
12261 (void *)ipif));
12270 ipif_up_notify(ipif);
12271 ipif->ipif_addr_ready = 1;
12284 * completion or just by default on the first ipif. (If we don't do this, then
12290 ipif_t *ipif;
12304 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12307 if (ipif->ipif_flags & IPIF_UP) {
12308 ipif_nce_start_dad(ipif);
12309 } else if (ipif->ipif_flags & IPIF_DUPLICATE) {
12313 ipif_do_recovery(ipif);
12316 * Unfortunately, the first ipif is "special"
12319 * one ipif is down, we must still notify so
12321 * change. (If the first ipif is up, then
12325 if (ipif == ill->ill_ipif) {
12336 ipif->ipif_addr_ready = 0;
12364 ipif_t *ipif;
12371 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12372 if (ipif->ipif_was_up) {
12373 if (!(ipif->ipif_flags & IPIF_UP))
12374 err = ipif_up(ipif, q, mp);
12375 ipif->ipif_was_up = B_FALSE;
12420 ipif_t *ipif;
12424 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12426 * We go through the ipif_down logic even if the ipif
12431 if (ipif->ipif_flags & IPIF_UP)
12432 ipif->ipif_was_up = B_TRUE;
12435 (void) ipif_logical_down(ipif, NULL, NULL);
12436 ipif_non_duplicate(ipif);
12437 (void) ipif_down_tail(ipif);
12439 (void) ipif_down(ipif, NULL, NULL);
12495 ip_sioctl_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12499 ill_t *ill = ipif->ipif_ill;
12511 if (ipif->ipif_id != 0 || ill->ill_usesrc_grp_next != NULL ||
12615 ip_sioctl_get_binding(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12620 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12622 if (!IS_IPMP(ipif->ipif_ill))
12626 if ((ill = ipif->ipif_bound_ill) == NULL)
12639 ip_sioctl_get_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12644 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12647 if ((grp = ipif->ipif_ill->ill_phyint->phyint_grp) == NULL)
13131 * on the same group for multiple ipif's on the same ill. The
13241 * The following members in ipif_t track references to the ipif.
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
13289 * wait for ipif to be quiescent
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
13315 ipif_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13317 ill_t *ill = ipif->ipif_ill;
13323 ASSERT(IAM_WRITER_IPIF(ipif));
13325 ip1dbg(("ipif_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
13328 ill_t *, ill, ipif_t *, ipif);
13330 if (ipif->ipif_flags & IPIF_UP) {
13332 ipif->ipif_flags &= ~IPIF_UP;
13338 sctp_update_ipif(ipif, SCTP_IPIF_DOWN);
13339 ill_nic_event_dispatch(ipif->ipif_ill,
13340 MAP_IPIF_ID(ipif->ipif_id), NE_LIF_DOWN, NULL, 0);
13344 * Removal of the last ipif from an ill may result in a DL_UNBIND
13362 ipif_multicast_down(ipif);
13370 if (ipif_was_up && !IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
13371 !IN6_IS_ADDR_V4MAPPED_ANY(&ipif->ipif_v6lcl_addr) &&
13372 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
13375 err = ip_srcid_remove(&ipif->ipif_v6lcl_addr,
13376 ipif->ipif_zoneid, ipst);
13384 if (ipif->ipif_isv6)
13385 ipif_delete_ires_v6(ipif);
13387 ipif_delete_ires_v4(ipif);
13402 * neighbor-discovery or arp entries for this interface. The ipif
13404 * that point at the ipif->ipif_ill. At the same time, we also
13409 ipif_nce_down(ipif);
13412 * If this is the last ipif on the ill, we also need to remove
13421 * ipif (we actually walk all that now have stale references).
13443 * Are there any ire's pointing to this ipif that are still active ?
13444 * If this is the last ipif going down, are there any ire's pointing
13447 if (ipif_is_quiescent(ipif)) {
13459 * which in turn is called by the last refrele on the ipif/ill/ire.
13461 success = ipsq_pending_mp_add(connp, ipif, q, mp, IPIF_DOWN);
13477 ipif_down_tail(ipif_t *ipif)
13479 ill_t *ill = ipif->ipif_ill;
13483 ill_t *, ill, ipif_t *, ipif);
13498 if (!ipif->ipif_isv6)
13499 err = ipif_arp_down(ipif);
13503 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
13504 ip_rts_newaddrmsg(RTM_DELETE, 0, ipif, RTSQ_DEFAULT);
13514 ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13517 ill_t *, ipif->ipif_ill, ipif_t *, ipif);
13528 ipif->ipif_ill->ill_logical_down = 1;
13529 return (ipif_down(ipif, q, mp));
13537 ipif_free(ipif_t *ipif)
13539 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13541 ASSERT(IAM_WRITER_IPIF(ipif));
13543 if (ipif->ipif_recovery_id != 0)
13544 (void) untimeout(ipif->ipif_recovery_id);
13545 ipif->ipif_recovery_id = 0;
13551 (void) ipif_down(ipif, NULL, NULL);
13558 if (ipif->ipif_recovery_id != 0)
13559 (void) untimeout(ipif->ipif_recovery_id);
13560 ipif->ipif_recovery_id = 0;
13564 reset_mrt_vif_ipif(ipif);
13565 /* If necessary, clear the cached source ipif rotor. */
13566 if (ipif->ipif_ill->ill_src_ipif == ipif)
13567 ipif->ipif_ill->ill_src_ipif = NULL;
13572 ipif_free_tail(ipif_t *ipif)
13574 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13578 * inserting or removing an ipif from the linked list
13584 ipif_trace_cleanup(ipif);
13588 sctp_update_ipif(ipif, SCTP_IPIF_REMOVE);
13589 ip_rts_newaddrmsg(RTM_FREEADDR, 0, ipif, RTSQ_DEFAULT);
13592 ipif_remove(ipif);
13595 ASSERT(!(ipif->ipif_flags & (IPIF_UP | IPIF_DUPLICATE)));
13596 ASSERT(ipif->ipif_recovery_id == 0);
13597 ASSERT(ipif->ipif_ire_local == NULL);
13598 ASSERT(ipif->ipif_ire_if == NULL);
13601 mi_free(ipif);
13605 * Sets `buf' to an ipif name of the form "ill_name:id", or "ill_name" if "id"
13609 ipif_get_name(const ipif_t *ipif, char *buf, int len)
13616 name = ipif->ipif_ill->ill_name;
13617 name_len = ipif->ipif_ill->ill_name_length;
13618 if (ipif->ipif_id != 0) {
13620 ipif->ipif_id);
13661 ipif_t *ipif;
13667 * If the caller wants to us to create the ipif, make sure we have a
13734 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13735 if (ipif->ipif_id == id) {
13737 zoneid != ipif->ipif_zoneid &&
13738 ipif->ipif_zoneid != ALL_ZONES) {
13743 if (IPIF_CAN_LOOKUP(ipif)) {
13744 ipif_refhold_locked(ipif);
13755 return (ipif);
13781 ipif = ipif_allocate(ill, id, ire_type, B_TRUE, B_TRUE, NULL);
13782 if (ipif != NULL)
13783 ipif_refhold_locked(ipif);
13786 return (ipif);
13802 ipif_t *ipif;
13877 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13878 if (ipif->ipif_id == id) {
13880 zoneid != ipif->ipif_zoneid &&
13881 ipif->ipif_zoneid != ALL_ZONES) {
13890 if (!(IPIF_IS_CHANGING(ipif) ||
13891 IPIF_IS_CONDEMNED(ipif)) ||
13892 IAM_WRITER_IPIF(ipif)) {
13893 ipif_refhold_locked(ipif);
13903 return (ipif);
13904 } else if (q != NULL && !IPIF_IS_CONDEMNED(ipif)) {
13929 * This routine is called whenever a new address comes up on an ipif. If
13937 ipif_mask_reply(ipif_t *ipif)
13942 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13951 ASSERT(!ipif->ipif_isv6);
13953 ASSERT(ipif->ipif_ill->ill_wq != NULL);
13955 if (ipif->ipif_lcl_addr == INADDR_ANY)
13967 ipha->ipha_src = ipif->ipif_lcl_addr;
13968 ipha->ipha_dst = ipif->ipif_brd_addr;
13974 bcopy(&ipif->ipif_net_mask, &icmph[1], IP_ADDR_LEN);
13989 * Join the ipif specific multicast groups.
13994 ipif_multicast_up(ipif_t *ipif)
14000 ASSERT(IAM_WRITER_IPIF(ipif));
14002 ill = ipif->ipif_ill;
14006 ipif->ipif_allhosts_ilm != NULL)
14009 if (ipif->ipif_isv6) {
14013 v6solmc.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3];
14015 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr))
14025 ilm = ip_addmulti(&v6allmc, ill, ipif->ipif_zoneid,
14033 ipif->ipif_allhosts_ilm = ilm;
14040 if (!(ipif->ipif_flags & IPIF_NOLOCAL)) {
14053 ipif->ipif_zoneid, &err);
14061 if ((ilm = ipif->ipif_allhosts_ilm) != NULL) {
14062 ipif->ipif_allhosts_ilm = NULL;
14067 ipif->ipif_solmulti_ilm = ilm;
14072 if (ipif->ipif_lcl_addr == INADDR_ANY || IS_UNDER_IPMP(ill))
14079 ilm = ip_addmulti(&v6group, ill, ipif->ipif_zoneid, &err);
14085 ipif->ipif_allhosts_ilm = ilm;
14094 ipif_multicast_down(ipif_t *ipif)
14096 ASSERT(IAM_WRITER_IPIF(ipif));
14100 if (ipif->ipif_allhosts_ilm != NULL) {
14101 (void) ip_delmulti(ipif->ipif_allhosts_ilm);
14102 ipif->ipif_allhosts_ilm = NULL;
14104 if (ipif->ipif_solmulti_ilm != NULL) {
14105 (void) ip_delmulti(ipif->ipif_solmulti_ilm);
14106 ipif->ipif_solmulti_ilm = NULL;
14213 ipif_set_default(ipif_t *ipif)
14215 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14217 if (!ipif->ipif_isv6) {
14222 if (!ipif->ipif_net_mask) {
14225 v4mask = ip_net_mask(ipif->ipif_lcl_addr);
14226 V4MASK_TO_V6(v4mask, ipif->ipif_v6net_mask);
14228 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14230 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14232 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14233 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14239 if (ipif->ipif_flags & IPIF_BROADCAST) {
14242 v4addr = ipif->ipif_subnet | ~ipif->ipif_net_mask;
14243 IN6_IPADDR_TO_V4MAPPED(v4addr, &ipif->ipif_v6brd_addr);
14250 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6net_mask))
14251 ipif->ipif_v6net_mask = ipv6_all_ones;
14252 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14254 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14256 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14257 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14274 ipif_t *ipif;
14295 for (ipif = ill->ill_ipif; ipif != NULL;
14296 ipif = ipif->ipif_next) {
14297 if ((ipif == new_ipif) ||
14298 !(ipif->ipif_flags & IPIF_UP) ||
14299 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
14300 !IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr,
14306 else if (ipif->ipif_flags & IPIF_POINTOPOINT)
14307 ipif->ipif_flags |= IPIF_UNNUMBERED;
14312 else if (new_ipif->ipif_zoneid != ipif->ipif_zoneid &&
14313 ipif->ipif_zoneid != ALL_ZONES && IS_LOOPBACK(ill))
14326 * Bring up an ipif: bring up arp/ndp, bring up the DLPI stream, and add
14327 * IREs for the ipif.
14332 ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp)
14334 ill_t *ill = ipif->ipif_ill;
14335 boolean_t isv6 = ipif->ipif_isv6;
14341 ASSERT(IAM_WRITER_IPIF(ipif));
14343 ip1dbg(("ipif_up(%s:%u)\n", ill->ill_name, ipif->ipif_id));
14345 ill_t *, ill, ipif_t *, ipif);
14348 if (ipif->ipif_flags & IPIF_UP)
14354 * try to bring it up. One complication is that the zeroth ipif for
14358 if (IS_UNDER_IPMP(ill) && ipmp_ipif_is_dataaddr(ipif) &&
14359 (!ipif->ipif_isv6 || !V6_IPIF_LINKLOCAL(ipif))) {
14364 * The ipif being brought up should be quiesced. If it's not,
14369 if (!ipif_is_quiescent(ipif)) {
14379 if (ipif->ipif_id == 0) {
14392 * Grab or transfer the ipif to move. During the move, keep
14397 if (ipif->ipif_id != 0) {
14398 ipif_remove(ipif);
14400 ipif_transfer(ipif, moveipif, stubipif);
14401 ipif = moveipif;
14405 * Place the ipif on the IPMP ill. If the zeroth ipif on
14409 ipif->ipif_ill = ipmp_ill;
14410 ipif_orig_id = ipif->ipif_id;
14413 ipif_transfer(ipif, ipmp_ill->ill_ipif, NULL);
14414 ipif = ipmp_ill->ill_ipif;
14416 ipif->ipif_id = -1;
14417 if ((err = ipif_insert(ipif, B_FALSE)) != 0) {
14424 ipif->ipif_id = ipif_orig_id;
14425 ipif->ipif_ill = ill;
14427 ipif_transfer(ipif, ill->ill_ipif,
14430 VERIFY(ipif_insert(ipif, B_FALSE) == 0);
14439 * Tell SCTP that the ipif has moved. Note that even if we
14440 * had to allocate a new ipif, the original sequence id was
14443 sctp_move_ipif(ipif, ill, ipmp_ill);
14446 * If the ipif being brought up was on slot zero, then we
14454 ill->ill_move_ipif = ipif;
14465 return (ipif_up(ipif, q, mp));
14483 return (ill_dl_up(ill, ipif, mp, q));
14500 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14511 err = ipif_resolver_up(ipif, Res_act_initial);
14518 err = ipif_ndp_up(ipif, B_TRUE);
14530 ASSERT(!(ipif->ipif_flags & IPIF_DUPLICATE));
14531 ipif->ipif_addr_ready = 1;
14538 err = (isv6 ? ipif_up_done_v6(ipif) : ipif_up_done(ipif));
14540 ipif = ill->ill_move_ipif;
14542 return (ipif_up(ipif, q, mp));
14601 ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
14634 * - multiple ioctls that need to bring the ipif up are encountered,
14655 mutex_enter(&ipif->ipif_ill->ill_lock);
14656 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14657 mutex_exit(&ipif->ipif_ill->ill_lock);
14682 if ((ipif->ipif_flags & IPIF_DHCPRUNNING) &&
14712 ipif_up_done(ipif_t *ipif)
14714 ill_t *ill = ipif->ipif_ill;
14721 ipif->ipif_ill->ill_name, ipif->ipif_id));
14723 ill_t *, ill, ipif_t *, ipif);
14726 if (ipif->ipif_ill->ill_wq == NULL)
14729 ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14735 * address selection gets to take this new ipif into account.
14736 * No need to hold ill_lock while traversing the ipif list since
14744 (tmp_ipif == ipif))
14763 if (V4_PART_OF_V6(ipif->ipif_v6lcl_addr) ==
14765 ipif->ipif_ire_type = IRE_LOOPBACK;
14767 ipif->ipif_ire_type = IRE_LOCAL;
14773 ill->ill_phys_addr_length, &ipif->ipif_lcl_addr, flags,
14777 ipif->ipif_added_nce = 1;
14788 err = ipif_add_ires_v4(ipif, loopback);
14795 (void) ipif_arp_down(ipif);
14798 * Make IPMP aware of the deleted ipif so that
14806 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
14849 ipif_multicast_up(ipif);
14852 !(ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST|IPIF_DEPRECATED)))
14855 if (!loopback && ipif->ipif_addr_ready) {
14857 ipif_mask_reply(ipif);
14868 if (ipif->ipif_addr_ready)
14869 ipif_up_notify(ipif);
14874 * Add the IREs associated with the ipif.
14878 ipif_add_ires_v4(ipif_t *ipif, boolean_t loopback)
14880 ill_t *ill = ipif->ipif_ill;
14892 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14893 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14899 ipif->ipif_ire_type != IRE_LOOPBACK &&
14900 !tsol_check_interface_address(ipif))
14904 err = ip_srcid_insert(&ipif->ipif_v6lcl_addr,
14905 ipif->ipif_zoneid, ipst);
14912 gw = (uchar_t *)&ipif->ipif_lcl_addr;
14918 (uchar_t *)&ipif->ipif_lcl_addr, /* dest address */
14921 ipif->ipif_ire_type, /* LOCAL or LOOPBACK */
14922 ipif->ipif_ill,
14923 ipif->ipif_zoneid,
14924 ((ipif->ipif_flags & IPIF_PRIVATE) ?
14929 " for 0x%x\n", (void *)ipif, (void *)ire_local,
14930 ipif->ipif_ire_type,
14931 ntohl(ipif->ipif_lcl_addr)));
14940 ipif->ipif_ire_type,
14941 ntohl(ipif->ipif_lcl_addr),
14942 (uint_t)ipif->ipif_flags));
14944 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14945 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14946 net_mask = ip_net_mask(ipif->ipif_lcl_addr);
14951 subnet_mask = ipif->ipif_net_mask;
14956 * ipif struct.
14960 V4MASK_TO_V6(subnet_mask, ipif->ipif_v6net_mask);
14961 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
14962 ipif->ipif_v6subnet);
14966 if (!loopback && !(ipif->ipif_flags & IPIF_NOXMIT) &&
14967 ipif->ipif_subnet != INADDR_ANY) {
14970 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14976 ip1dbg(("ipif_add_ires: ipif 0x%p ill 0x%p "
14978 (void *)ipif, (void *)ill, ill->ill_net_type,
14979 ntohl(ipif->ipif_subnet)));
14981 (uchar_t *)&ipif->ipif_subnet,
14983 (uchar_t *)&ipif->ipif_lcl_addr,
14986 ipif->ipif_zoneid,
14987 ((ipif->ipif_flags & IPIF_PRIVATE) ?
15001 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
15002 !(ipif->ipif_flags & IPIF_NOXMIT))
15003 irep = ipif_create_bcast_ires(ipif, irep);
15023 ipif->ipif_flags |= IPIF_UP;
15025 err = ip_addr_availability_check(ipif);
15032 * the ARP entry for our ipif replaced the one for the other
15033 * ipif. So we don't want to delete it (otherwise the other ipif
15040 ipif->ipif_flags &= ~IPIF_UP;
15075 ipif->ipif_ire_local = ire_local;
15077 ipif->ipif_ire_if = ire_if;
15112 if ((ipif->ipif_brd_addr != INADDR_ANY) &&
15113 (ipif->ipif_flags & IPIF_BROADCAST)) {
15116 ire = ire_ftable_lookup_v4(ipif->ipif_brd_addr, 0, 0,
15117 IRE_BROADCAST, ipif->ipif_ill, ALL_ZONES, NULL,
15125 ipif->ipif_v6brd_addr = ipv6_all_zeros;
15126 mutex_enter(&ipif->ipif_ill->ill_lock);
15127 ipif_set_default(ipif);
15128 mutex_exit(&ipif->ipif_ill->ill_lock);
15139 ipif->ipif_flags &= ~IPIF_UP;
15149 ire_local = ipif->ipif_ire_local;
15150 ipif->ipif_ire_local = NULL;
15151 ire_if = ipif->ipif_ire_if;
15152 ipif->ipif_ire_if = NULL;
15169 (void) ip_srcid_remove(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid, ipst);
15176 ipif_delete_ires_v4(ipif_t *ipif)
15178 ill_t *ill = ipif->ipif_ill;
15183 ire = ipif->ipif_ire_local;
15184 ipif->ipif_ire_local = NULL;
15188 * Move count to ipif so we don't loose the count due to
15191 atomic_add_32(&ipif->ipif_ib_pkt_count, ire->ire_ib_pkt_count);
15197 ire = ipif->ipif_ire_if;
15198 ipif->ipif_ire_if = NULL;
15208 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
15209 !(ipif->ipif_flags & IPIF_NOXMIT))
15210 ipif_delete_bcast_ires(ipif);
15222 ipif_t *ipif = NULL;
15232 for (ipif = uill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15233 if (IPIF_IS_CONDEMNED(ipif))
15235 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15237 if (!(ipif->ipif_flags & IPIF_UP))
15239 if (ipif->ipif_zoneid != zoneid)
15241 if (isv6 ? IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15242 ipif->ipif_lcl_addr == INADDR_ANY)
15254 * Find an ipif with a good local address on the ill+zoneid.
15259 ipif_t *ipif;
15262 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15263 if (IPIF_IS_CONDEMNED(ipif))
15265 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15267 if (!(ipif->ipif_flags & IPIF_UP))
15269 if (ipif->ipif_zoneid != zoneid &&
15270 ipif->ipif_zoneid != ALL_ZONES && zoneid != ALL_ZONES)
15273 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15274 ipif->ipif_lcl_addr == INADDR_ANY)
15276 ipif_refhold_locked(ipif);
15278 return (ipif);
15301 * Pick the optimal ipif on `ill' for sending to destination `dst' from zone
15303 * enumeration, and return the highest-rated ipif. If there's a tie, we pick
15316 ipif_t *start_ipif, *next_ipif, *ipif, *best_ipif;
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.
15362 * After selecting the right ipif, under ill_lock make sure ipif is
15363 * not condemned, and increment refcnt. If ipif is CONDEMNED,
15370 * For source address selection, we treat the ipif list as circular
15381 ipif = start_ipif;
15385 if ((next_ipif = ipif->ipif_next) == NULL)
15388 if (IPIF_IS_CONDEMNED(ipif))
15391 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15394 if (ipif->ipif_ill->ill_flags & ILLF_NOACCEPT)
15396 if (!(ipif->ipif_flags & IPIF_UP))
15399 if (!ipif->ipif_addr_ready) {
15406 ipif->ipif_zoneid != zoneid &&
15407 ipif->ipif_zoneid != ALL_ZONES)
15414 if (ipif->ipif_lcl_addr == INADDR_ANY)
15425 src_rhtp = find_tpc(&ipif->ipif_lcl_addr,
15441 samenet = ((ipif->ipif_net_mask & dst) == ipif->ipif_subnet);
15443 if (ipif->ipif_lcl_addr == dst) {
15445 } else if (ipif->ipif_flags & IPIF_DEPRECATED) {
15448 } else if (ipif->ipif_zoneid == ALL_ZONES) {
15457 best_ipif = ipif;
15461 } while ((ipif = next_ipif) != start_ipif);
15463 if ((ipif = best_ipif) != NULL) {
15464 mutex_enter(&ipif->ipif_ill->ill_lock);
15465 if (IPIF_IS_CONDEMNED(ipif)) {
15466 mutex_exit(&ipif->ipif_ill->ill_lock);
15469 ipif_refhold_locked(ipif);
15472 * For IPMP, update the source ipif rotor to the next ipif,
15477 if (IS_IPMP(ill) && ipif != NULL) {
15478 next_ipif = ipif->ipif_next;
15484 mutex_exit(&ipif->ipif_ill->ill_lock);
15496 if (ipif == NULL) {
15507 ipif->ipif_ill->ill_name,
15509 inet_ntop(AF_INET, &ipif->ipif_lcl_addr,
15513 return (ipif);
15552 ipif_t *ipif;
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);
15580 if (ipif == NULL) {
15586 *srcp = ipif->ipif_lcl_addr;
15588 *flagsp = ipif->ipif_flags;
15589 ipif_refrele(ipif);
15595 if_unitsel_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15604 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15653 * Create any IRE_BROADCAST entries for `ipif', and store those entries in
15661 ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep)
15664 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15665 ipaddr_t subnetmask = ipif->ipif_net_mask;
15666 ill_t *ill = ipif->ipif_ill;
15667 zoneid_t zoneid = ipif->ipif_zoneid;
15671 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15672 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15674 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15675 (ipif->ipif_flags & IPIF_NOLOCAL))
15691 addr = netmask & ipif->ipif_subnet;
15703 addr = ipif->ipif_subnet;
15715 ipif_delete_bcast_ires(ipif_t *ipif)
15718 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15719 ipaddr_t subnetmask = ipif->ipif_net_mask;
15720 ill_t *ill = ipif->ipif_ill;
15721 zoneid_t zoneid = ipif->ipif_zoneid;
15724 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15725 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15727 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15728 (ipif->ipif_flags & IPIF_NOLOCAL))
15748 addr = netmask & ipif->ipif_subnet;
15764 addr = ipif->ipif_subnet;
15787 ip_sioctl_slifname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15796 ASSERT(ipif != NULL);
15806 * and previous lookups (ip_extract_lifreq()) found this ipif --
15809 if (ill != ipif->ipif_ill)
15879 ipif->ipif_flags |= IPIF_BROADCAST;
15881 ipif->ipif_flags &= ~IPIF_BROADCAST;
15894 ip_sioctl_slifname_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15903 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15907 * Return a pointer to the ipif which matches the index, IP version type and
15915 ipif_t *ipif = NULL;
15920 for (ipif = ill->ill_ipif; ipif != NULL;
15921 ipif = ipif->ipif_next) {
15922 if (!IPIF_IS_CONDEMNED(ipif) && (zoneid == ALL_ZONES ||
15923 zoneid == ipif->ipif_zoneid ||
15924 ipif->ipif_zoneid == ALL_ZONES)) {
15925 ipif_refhold_locked(ipif);
15932 return (ipif);
15943 ip_sioctl_slifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15951 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
15962 ill = ipif->ipif_ill;
15964 if (ipif->ipif_id != 0 || index == 0 || index > IF_INDEX_MAX) {
16007 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
16018 ip_sioctl_get_lifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16025 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16028 ifr->ifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16030 lifr->lifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16037 ip_sioctl_get_lifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16043 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16046 lifr->lifr_zoneid = ipif->ipif_zoneid;
16055 ip_sioctl_slifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16073 if (ipif->ipif_id == 0 && zoneid != GLOBAL_ZONEID)
16094 if (ipif->ipif_flags & IPIF_UP) {
16101 err = ipif_logical_down(ipif, q, mp);
16104 (void) ipif_down_tail(ipif);
16108 err = ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp, need_up);
16113 ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
16120 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16136 ipif->ipif_zoneid = zoneid;
16139 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
16142 ire_increment_multicast_generation(ipst, ipif->ipif_ill->ill_isv6);
16153 err = ipif_up(ipif, q, mp);
16160 ip_sioctl_slifzone_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16173 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16197 if (ipif->ipif_isv6) {
16198 (void) ipif_up_done_v6(ipif);
16200 (void) ipif_up_done(ipif);
16205 (void) ipif_down_tail(ipif);
16207 return (ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp,
16218 ipif_t *ipif;
16223 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
16224 if ((ipif->ipif_flags & set) && !(ipif->ipif_flags & clear))
16252 ip_sioctl_get_lifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16261 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16262 lifr->lifr_index = ipif->ipif_ill->ill_usesrc_ifindex;
16371 ip_sioctl_slifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16376 ill_t *usesrc_ill, *usesrc_cli_ill = ipif->ipif_ill;
16380 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
16382 ASSERT(IAM_WRITER_IPIF(ipif));
16402 if (usesrc_ill == ipif->ipif_ill) {
16499 /* The refrele on the lifr_name ipif is done by ip_process_ioctl */
16510 ip_sioctl_get_dadstate(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16514 ill_t *ill = ipif->ipif_ill;
16518 * references to the ipif.
16521 if ((ipif->ipif_flags & IPIF_UP) && ipif->ipif_addr_ready == 0)
16802 ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
16843 err = ill_dl_phys(ill, ipif, mp, q);
16880 ipif_t *ipif;
16941 ipif = ill->ill_ipif;
16943 /* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */
16944 ipif_assign_seqid(ipif);
16949 ASSERT(ipif->ipif_next == NULL); /* Only one ipif on ill */
16950 ASSERT((ipif->ipif_flags & IPIF_UP) == 0);
16961 ipif->ipif_v6lcl_addr = ipv6_all_zeros;
16962 ipif->ipif_v6subnet = ipv6_all_zeros;
16963 ipif->ipif_v6net_mask = ipv6_all_zeros;
16964 ipif->ipif_v6brd_addr = ipv6_all_zeros;
16965 ipif->ipif_v6pp_dst_addr = ipv6_all_zeros;
16972 if (ipif->ipif_flags & IPIF_POINTOPOINT ||
16997 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6lcl_addr);
16998 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6subnet);
16999 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6net_mask);
17000 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6brd_addr);
17001 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6pp_dst_addr);
17030 * When the first ipif comes up in ipif_up_done(), multicast groups
17098 ipsq_current_start(ipsq, ipif, SIOCSLIFNAME);
17100 ASSERT(ipsq->ipsq_xop->ipx_current_ipif == ipif);
17102 error = ipif_set_values_tail(ill, ipif, mp, q);
17258 * broadcast is added to the redundant ipif.
17663 * Lookup an ill and verify that the zoneid has an ipif on that ill.
17671 ipif_t *ipif;
17678 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17679 if (IPIF_IS_CONDEMNED(ipif))
17681 if (zoneid != ALL_ZONES && ipif->ipif_zoneid != zoneid &&
17682 ipif->ipif_zoneid != ALL_ZONES)
17702 ipif_t *ipif;
17716 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17717 if (!IPIF_CAN_LOOKUP(ipif))
17719 if (lifidx == ipif->ipif_id) {
17720 ipif_refhold_locked(ipif);
17727 return (ipif);
17957 * ip_rput_dlpi_writer() or arp_bringup_done() when the last ipif is
18056 * remainder of ipif bringup via ill_up_ipifs() will also be done in
18356 ipif_arp_up_done_tail(ipif_t *ipif, enum ip_resolver_action res_act)
18361 ill_t *ill = ipif->ipif_ill;
18368 ill_t *, ill, ipif_t *, ipif);
18369 if (ipif->ipif_lcl_addr != INADDR_ANY) {
18370 addr = &ipif->ipif_lcl_addr;
18373 if ((ipif->ipif_flags & IPIF_UNNUMBERED) || addr == NULL) {
18385 * If we're here via ipif_up(), then the ipif
18390 * ipmp_ill_bind_ipif(), then the ipif has
18394 if ((bound_ill = ipmp_ipif_bound_ill(ipif)) == NULL) {
18395 bound_ill = ipmp_illgrp_add_ipif(illg, ipif);
18398 * We couldn't bind the ipif to an ill
18402 ipif->ipif_addr_ready = 1;
18414 * If this is an initial bring-up (or the ipif was never
18420 if (res_act == Res_act_initial || !ipif->ipif_addr_ready) {
18438 ipif->ipif_added_nce = 1;
18454 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
18459 ipif->ipif_id));
18471 ipif->ipif_addr_ready = 1;
18472 ipif->ipif_added_nce = 1;
18481 if ((ipif->ipif_flags & IPIF_UP) &&
18482 !ipif->ipif_addr_ready)
18483 ipif_up_notify(ipif);
18484 ipif->ipif_addr_ready = 1;
18488 ipif->ipif_addr_ready = 1;
18494 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18499 ipif_arp_up(ipif_t *ipif, enum ip_resolver_action res_act, boolean_t was_dup)
18502 ill_t *ill = ipif->ipif_ill;
18506 ill_t *, ill, ipif_t *, ipif);
18533 (void) ipif_arp_up_done_tail(ipif, res_act);
18546 ipif_t *ipif;
18556 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18558 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18576 if (ipif->ipif_isv6) {
18577 if ((err = ipif_up_done_v6(ipif)) != 0)
18580 err = ipif_arp_up_done_tail(ipif, Res_act_initial);
18582 (err = ipif_up_done(ipif)) != 0) {
18585 (void) ipif_arp_down(ipif);
18600 * If we have a moved ipif to bring up, and everything has succeeded
18605 ipif = ill->ill_move_ipif;
18606 ip1dbg(("bringing up ipif %p on ill %s\n", (void *)ipif,
18607 ipif->ipif_ill->ill_name));
18610 err = ipif_up(ipif, q, mp1);
18625 ill_t *, ill, ipif_t *, ipif);
18640 ipif_t *ipif;
18648 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18650 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18685 ill_t *, ill, ipif_t *, ipif);
18693 ipif_up_notify(ipif_t *ipif)
18695 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
18696 ip_rts_newaddrmsg(RTM_ADD, 0, ipif, RTSQ_DEFAULT);
18697 sctp_update_ipif(ipif, SCTP_IPIF_UP);
18698 ill_nic_event_dispatch(ipif->ipif_ill, MAP_IPIF_ID(ipif->ipif_id),
18712 ip_sioctl_ilb_cmd(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
18963 ipif_nce_down(ipif_t *ipif)
18965 ill_t *ill = ipif->ipif_ill;
18969 ill_t *, ill, ipif_t *, ipif);
18970 if (ipif->ipif_added_nce) {
18971 if (ipif->ipif_isv6)
18972 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
18974 nce = nce_lookup_v4(ill, &ipif->ipif_lcl_addr);
18978 ipif->ipif_added_nce = 0;
18985 ipif->ipif_added_nce = 0;
18992 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18995 * Remove all other nces dependent on this ill when the last ipif
19055 ip_sioctl_get_ifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19063 ASSERT(ipif != NULL);
19064 ill = ipif->ipif_ill;
19101 ip_sioctl_get_lifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19109 ASSERT(ipif != NULL);
19110 ill = ipif->ipif_ill;