/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1990 Mentat Inc. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * This file contains the interface control functions for IP. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define _SUN_TPI_VERSION 2 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* for various inet/mi.h and inet/nd.h needs */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* The character which tells where the ill_name ends */ #define IPIF_SEPARATOR_CHAR ':' /* IP ioctl function table entry */ typedef struct ipft_s { int ipft_cmd; pfi_t ipft_pfi; int ipft_min_size; int ipft_flags; } ipft_t; #define IPFT_F_NO_REPLY 0x1 /* IP ioctl does not expect any reply */ #define IPFT_F_SELF_REPLY 0x2 /* ioctl callee does the ioctl reply */ typedef struct ip_sock_ar_s { union { area_t ip_sock_area; ared_t ip_sock_ared; areq_t ip_sock_areq; } ip_sock_ar_u; queue_t *ip_sock_ar_q; } ip_sock_ar_t; static int nd_ill_forward_get(queue_t *, mblk_t *, caddr_t, cred_t *); static int nd_ill_forward_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *ioc_cr); static boolean_t ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask); static ip_m_t *ip_m_lookup(t_uscalar_t mac_type); static int ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, boolean_t need_up); static int ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, boolean_t need_up); static int ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid, queue_t *q, mblk_t *mp, boolean_t need_up); static int ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q, mblk_t *mp, boolean_t need_up); static int ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp); static int ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t, in6_addr_t, queue_t *q, mblk_t *mp, boolean_t need_up); static int ip_sioctl_arp_common(ill_t *ill, queue_t *q, mblk_t *mp, sin_t *sin, boolean_t x_arp_ioctl, boolean_t if_arp_ioctl); static ipaddr_t ip_subnet_mask(ipaddr_t addr, ipif_t **); static void ip_wput_ioctl(queue_t *q, mblk_t *mp); static void ipsq_flush(ill_t *ill); static void ipsq_clean_all(ill_t *ill); static void ipsq_clean_ring(ill_t *ill, ill_rx_ring_t *rx_ring); static int ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen, queue_t *q, mblk_t *mp, boolean_t need_up); static void ipsq_delete(ipsq_t *); static ipif_t *ipif_allocate(ill_t *ill, int id, uint_t ire_type, boolean_t initialize); static void ipif_check_bcast_ires(ipif_t *test_ipif); static void ipif_down_delete_ire(ire_t *ire, char *ipif); static void ipif_delete_cache_ire(ire_t *, char *); static int ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp); static void ipif_down_tail(ipif_t *ipif); static void ipif_free(ipif_t *ipif); static void ipif_free_tail(ipif_t *ipif); static void ipif_mask_reply(ipif_t *); static void ipif_mtu_change(ire_t *ire, char *ipif_arg); static void ipif_multicast_down(ipif_t *ipif); static void ipif_recreate_interface_routes(ipif_t *old_ipif, ipif_t *ipif); static void ipif_set_default(ipif_t *ipif); static int ipif_set_values(queue_t *q, mblk_t *mp, char *interf_name, uint_t *ppa); static int ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q); static ipif_t *ipif_lookup_on_name(char *name, size_t namelen, boolean_t do_alloc, boolean_t *exists, boolean_t isv6, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error); static int ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp); static void ipif_update_other_ipifs(ipif_t *old_ipif, ill_group_t *illgrp); static int ill_alloc_ppa(ill_if_t *, ill_t *); static int ill_arp_off(ill_t *ill); static int ill_arp_on(ill_t *ill); static void ill_delete_interface_type(ill_if_t *); static int ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q); static void ill_down(ill_t *ill); static void ill_downi(ire_t *ire, char *ill_arg); static void ill_downi_mrtun_srcif(ire_t *ire, char *ill_arg); static void ill_down_tail(ill_t *ill); static void ill_free_mib(ill_t *ill); static void ill_glist_delete(ill_t *); static boolean_t ill_has_usable_ipif(ill_t *); static int ill_lock_ipsq_ills(ipsq_t *sq, ill_t **list, int); static void ill_nominate_bcast_rcv(ill_group_t *illgrp); static void ill_phyint_free(ill_t *ill); static void ill_phyint_reinit(ill_t *ill); static void ill_set_nce_router_flags(ill_t *, boolean_t); static void ill_signal_ipsq_ills(ipsq_t *, boolean_t); static boolean_t ill_split_ipsq(ipsq_t *cur_sq); static void ill_stq_cache_delete(ire_t *, char *); static boolean_t ip_ether_v6intfid(uint_t, uint8_t *, in6_addr_t *); static boolean_t ip_nodef_v6intfid(uint_t, uint8_t *, in6_addr_t *); static boolean_t ip_ether_v6mapinfo(uint_t, uint8_t *, uint8_t *, uint32_t *, in6_addr_t *); static boolean_t ip_ether_v4mapinfo(uint_t, uint8_t *, uint8_t *, uint32_t *, ipaddr_t *); static boolean_t ip_ib_v6intfid(uint_t, uint8_t *, in6_addr_t *); static boolean_t ip_ib_v6mapinfo(uint_t, uint8_t *, uint8_t *, uint32_t *, in6_addr_t *); static boolean_t ip_ib_v4mapinfo(uint_t, uint8_t *, uint8_t *, uint32_t *, ipaddr_t *); static void ipif_save_ire(ipif_t *, ire_t *); static void ipif_remove_ire(ipif_t *, ire_t *); static void ip_cgtp_bcast_add(ire_t *, ire_t *); static void ip_cgtp_bcast_delete(ire_t *); /* * Per-ill IPsec capabilities management. */ static ill_ipsec_capab_t *ill_ipsec_capab_alloc(void); static void ill_ipsec_capab_free(ill_ipsec_capab_t *); static void ill_ipsec_capab_add(ill_t *, uint_t, boolean_t); static void ill_ipsec_capab_delete(ill_t *, uint_t); static boolean_t ill_ipsec_capab_resize_algparm(ill_ipsec_capab_t *, int); static void ill_capability_proto(ill_t *, int, mblk_t *); static void ill_capability_dispatch(ill_t *, mblk_t *, dl_capability_sub_t *, boolean_t); static void ill_capability_id_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static void ill_capability_mdt_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static void ill_capability_mdt_reset(ill_t *, mblk_t **); static void ill_capability_ipsec_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static void ill_capability_ipsec_reset(ill_t *, mblk_t **); static void ill_capability_hcksum_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static void ill_capability_hcksum_reset(ill_t *, mblk_t **); static void ill_capability_zerocopy_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static void ill_capability_zerocopy_reset(ill_t *, mblk_t **); static void ill_capability_dls_ack(ill_t *, mblk_t *, dl_capability_sub_t *); static mac_resource_handle_t ill_ring_add(void *, mac_resource_t *); static void ill_capability_dls_reset(ill_t *, mblk_t **); static void ill_capability_dls_disable(ill_t *); static void illgrp_cache_delete(ire_t *, char *); static void illgrp_delete(ill_t *ill); static void illgrp_reset_schednext(ill_t *ill); static ill_t *ill_prev_usesrc(ill_t *); static int ill_relink_usesrc_ills(ill_t *, ill_t *, uint_t); static void ill_disband_usesrc_group(ill_t *); static void conn_cleanup_stale_ire(conn_t *, caddr_t); /* * if we go over the memory footprint limit more than once in this msec * interval, we'll start pruning aggressively. */ int ip_min_frag_prune_time = 0; /* * max # of IPsec algorithms supported. Limited to 1 byte by PF_KEY * and the IPsec DOI */ #define MAX_IPSEC_ALGS 256 #define BITSPERBYTE 8 #define BITS(type) (BITSPERBYTE * (long)sizeof (type)) #define IPSEC_ALG_ENABLE(algs, algid) \ ((algs)[(algid) / BITS(ipsec_capab_elem_t)] |= \ (1 << ((algid) % BITS(ipsec_capab_elem_t)))) #define IPSEC_ALG_IS_ENABLED(algid, algs) \ ((algs)[(algid) / BITS(ipsec_capab_elem_t)] & \ (1 << ((algid) % BITS(ipsec_capab_elem_t)))) typedef uint8_t ipsec_capab_elem_t; /* * Per-algorithm parameters. Note that at present, only encryption * algorithms have variable keysize (IKE does not provide a way to negotiate * auth algorithm keysize). * * All sizes here are in bits. */ typedef struct { uint16_t minkeylen; uint16_t maxkeylen; } ipsec_capab_algparm_t; /* * Per-ill capabilities. */ struct ill_ipsec_capab_s { ipsec_capab_elem_t *encr_hw_algs; ipsec_capab_elem_t *auth_hw_algs; uint32_t algs_size; /* size of _hw_algs in bytes */ /* algorithm key lengths */ ipsec_capab_algparm_t *encr_algparm; uint32_t encr_algparm_size; uint32_t encr_algparm_end; }; /* * List of AH and ESP IPsec acceleration capable ills */ typedef struct ipsec_capab_ill_s { uint_t ill_index; boolean_t ill_isv6; struct ipsec_capab_ill_s *next; } ipsec_capab_ill_t; static ipsec_capab_ill_t *ipsec_capab_ills_ah; static ipsec_capab_ill_t *ipsec_capab_ills_esp; krwlock_t ipsec_capab_ills_lock; /* * The field values are larger than strictly necessary for simple * AR_ENTRY_ADDs but the padding lets us accomodate the socket ioctls. */ static area_t ip_area_template = { AR_ENTRY_ADD, /* area_cmd */ sizeof (ip_sock_ar_t) + (IP_ADDR_LEN*2) + sizeof (struct sockaddr_dl), /* area_name_offset */ /* area_name_length temporarily holds this structure length */ sizeof (area_t), /* area_name_length */ IP_ARP_PROTO_TYPE, /* area_proto */ sizeof (ip_sock_ar_t), /* area_proto_addr_offset */ IP_ADDR_LEN, /* area_proto_addr_length */ sizeof (ip_sock_ar_t) + IP_ADDR_LEN, /* area_proto_mask_offset */ 0, /* area_flags */ sizeof (ip_sock_ar_t) + IP_ADDR_LEN + IP_ADDR_LEN, /* area_hw_addr_offset */ /* Zero length hw_addr_length means 'use your idea of the address' */ 0 /* area_hw_addr_length */ }; /* * AR_ENTRY_ADD/DELETE templates have been added for IPv6 external resolver * support */ static area_t ip6_area_template = { AR_ENTRY_ADD, /* area_cmd */ sizeof (ip_sock_ar_t) + (IPV6_ADDR_LEN*2) + sizeof (sin6_t), /* area_name_offset */ /* area_name_length temporarily holds this structure length */ sizeof (area_t), /* area_name_length */ IP_ARP_PROTO_TYPE, /* area_proto */ sizeof (ip_sock_ar_t), /* area_proto_addr_offset */ IPV6_ADDR_LEN, /* area_proto_addr_length */ sizeof (ip_sock_ar_t) + IPV6_ADDR_LEN, /* area_proto_mask_offset */ 0, /* area_flags */ sizeof (ip_sock_ar_t) + IPV6_ADDR_LEN + IPV6_ADDR_LEN, /* area_hw_addr_offset */ /* Zero length hw_addr_length means 'use your idea of the address' */ 0 /* area_hw_addr_length */ }; static ared_t ip_ared_template = { AR_ENTRY_DELETE, sizeof (ared_t) + IP_ADDR_LEN, sizeof (ared_t), IP_ARP_PROTO_TYPE, sizeof (ared_t), IP_ADDR_LEN }; static ared_t ip6_ared_template = { AR_ENTRY_DELETE, sizeof (ared_t) + IPV6_ADDR_LEN, sizeof (ared_t), IP_ARP_PROTO_TYPE, sizeof (ared_t), IPV6_ADDR_LEN }; /* * A template for an IPv6 AR_ENTRY_QUERY template has not been created, as * as the areq doesn't include an IP address in ill_dl_up() (the only place a * areq is used). */ static areq_t ip_areq_template = { AR_ENTRY_QUERY, /* cmd */ sizeof (areq_t)+(2*IP_ADDR_LEN), /* name offset */ sizeof (areq_t), /* name len (filled by ill_arp_alloc) */ IP_ARP_PROTO_TYPE, /* protocol, from arps perspective */ sizeof (areq_t), /* target addr offset */ IP_ADDR_LEN, /* target addr_length */ 0, /* flags */ sizeof (areq_t) + IP_ADDR_LEN, /* sender addr offset */ IP_ADDR_LEN, /* sender addr length */ 6, /* xmit_count */ 1000, /* (re)xmit_interval in milliseconds */ 4 /* max # of requests to buffer */ /* anything else filled in by the code */ }; static arc_t ip_aru_template = { AR_INTERFACE_UP, sizeof (arc_t), /* Name offset */ sizeof (arc_t) /* Name length (set by ill_arp_alloc) */ }; static arc_t ip_ard_template = { AR_INTERFACE_DOWN, sizeof (arc_t), /* Name offset */ sizeof (arc_t) /* Name length (set by ill_arp_alloc) */ }; static arc_t ip_aron_template = { AR_INTERFACE_ON, sizeof (arc_t), /* Name offset */ sizeof (arc_t) /* Name length (set by ill_arp_alloc) */ }; static arc_t ip_aroff_template = { AR_INTERFACE_OFF, sizeof (arc_t), /* Name offset */ sizeof (arc_t) /* Name length (set by ill_arp_alloc) */ }; static arma_t ip_arma_multi_template = { AR_MAPPING_ADD, sizeof (arma_t) + 3*IP_ADDR_LEN + IP_MAX_HW_LEN, /* Name offset */ sizeof (arma_t), /* Name length (set by ill_arp_alloc) */ IP_ARP_PROTO_TYPE, sizeof (arma_t), /* proto_addr_offset */ IP_ADDR_LEN, /* proto_addr_length */ sizeof (arma_t) + IP_ADDR_LEN, /* proto_mask_offset */ sizeof (arma_t) + 2*IP_ADDR_LEN, /* proto_extract_mask_offset */ ACE_F_PERMANENT | ACE_F_MAPPING, /* flags */ sizeof (arma_t) + 3*IP_ADDR_LEN, /* hw_addr_offset */ IP_MAX_HW_LEN, /* hw_addr_length */ 0, /* hw_mapping_start */ }; static ipft_t ip_ioctl_ftbl[] = { { IP_IOC_IRE_DELETE, ip_ire_delete, sizeof (ipid_t), 0 }, { IP_IOC_IRE_DELETE_NO_REPLY, ip_ire_delete, sizeof (ipid_t), IPFT_F_NO_REPLY }, { IP_IOC_IRE_ADVISE_NO_REPLY, ip_ire_advise, sizeof (ipic_t), IPFT_F_NO_REPLY }, { IP_IOC_RTS_REQUEST, ip_rts_request, 0, IPFT_F_SELF_REPLY }, { 0 } }; /* Simple ICMP IP Header Template */ static ipha_t icmp_ipha = { IP_SIMPLE_HDR_VERSION, 0, 0, 0, 0, 0, IPPROTO_ICMP }; /* Flag descriptors for ip_ipif_report */ static nv_t ipif_nv_tbl[] = { { IPIF_UP, "UP" }, { IPIF_BROADCAST, "BROADCAST" }, { ILLF_DEBUG, "DEBUG" }, { PHYI_LOOPBACK, "LOOPBACK" }, { IPIF_POINTOPOINT, "POINTOPOINT" }, { ILLF_NOTRAILERS, "NOTRAILERS" }, { PHYI_RUNNING, "RUNNING" }, { ILLF_NOARP, "NOARP" }, { PHYI_PROMISC, "PROMISC" }, { PHYI_ALLMULTI, "ALLMULTI" }, { PHYI_INTELLIGENT, "INTELLIGENT" }, { ILLF_MULTICAST, "MULTICAST" }, { PHYI_MULTI_BCAST, "MULTI_BCAST" }, { IPIF_UNNUMBERED, "UNNUMBERED" }, { IPIF_DHCPRUNNING, "DHCP" }, { IPIF_PRIVATE, "PRIVATE" }, { IPIF_NOXMIT, "NOXMIT" }, { IPIF_NOLOCAL, "NOLOCAL" }, { IPIF_DEPRECATED, "DEPRECATED" }, { IPIF_PREFERRED, "PREFERRED" }, { IPIF_TEMPORARY, "TEMPORARY" }, { IPIF_ADDRCONF, "ADDRCONF" }, { PHYI_VIRTUAL, "VIRTUAL" }, { ILLF_ROUTER, "ROUTER" }, { ILLF_NONUD, "NONUD" }, { IPIF_ANYCAST, "ANYCAST" }, { ILLF_NORTEXCH, "NORTEXCH" }, { ILLF_IPV4, "IPV4" }, { ILLF_IPV6, "IPV6" }, { IPIF_MIPRUNNING, "MIP" }, { IPIF_NOFAILOVER, "NOFAILOVER" }, { PHYI_FAILED, "FAILED" }, { PHYI_STANDBY, "STANDBY" }, { PHYI_INACTIVE, "INACTIVE" }, { PHYI_OFFLINE, "OFFLINE" }, }; static uchar_t ip_six_byte_all_ones[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; static ip_m_t ip_m_tbl[] = { { DL_ETHER, IFT_ETHER, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_ether_v6intfid }, { DL_CSMACD, IFT_ISO88023, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_nodef_v6intfid }, { DL_TPB, IFT_ISO88024, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_nodef_v6intfid }, { DL_TPR, IFT_ISO88025, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_nodef_v6intfid }, { DL_FDDI, IFT_FDDI, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_ether_v6intfid }, { DL_IB, IFT_IB, ip_ib_v4mapinfo, ip_ib_v6mapinfo, ip_ib_v6intfid }, { SUNW_DL_VNI, IFT_OTHER, NULL, NULL, NULL}, { DL_OTHER, IFT_OTHER, ip_ether_v4mapinfo, ip_ether_v6mapinfo, ip_nodef_v6intfid } }; static ill_t ill_null; /* Empty ILL for init. */ char ipif_loopback_name[] = "lo0"; static char *ipv4_forward_suffix = ":ip_forwarding"; static char *ipv6_forward_suffix = ":ip6_forwarding"; static kstat_t *loopback_ksp = NULL; static sin6_t sin6_null; /* Zero address for quick clears */ static sin_t sin_null; /* Zero address for quick clears */ static uint_t ill_index = 1; /* Used to assign interface indicies */ /* When set search for unused index */ static boolean_t ill_index_wrap = B_FALSE; /* When set search for unused ipif_seqid */ static ipif_t ipif_zero; uint_t ipif_src_random; /* * For details on the protection offered by these locks please refer * to the notes under the Synchronization section at the start of ip.c */ krwlock_t ill_g_lock; /* The global ill_g_lock */ kmutex_t ip_addr_avail_lock; /* Address availability check lock */ ipsq_t *ipsq_g_head; /* List of all ipsq's on the system */ krwlock_t ill_g_usesrc_lock; /* Protects usesrc related fields */ /* * illgrp_head/ifgrp_head is protected by IP's perimeter. */ static ill_group_t *illgrp_head_v4; /* Head of IPv4 ill groups */ ill_group_t *illgrp_head_v6; /* Head of IPv6 ill groups */ ill_g_head_t ill_g_heads[MAX_G_HEADS]; /* ILL List Head */ /* * ppa arena is created after these many * interfaces have been plumbed. */ uint_t ill_no_arena = 12; #pragma align CACHE_ALIGN_SIZE(phyint_g_list) static phyint_list_t phyint_g_list; /* start of phyint list */ /* * Reflects value of FAILBACK variable in IPMP config file * /etc/default/mpathd. Default value is B_TRUE. * Set to B_FALSE if user disabled failback by configuring "FAILBACK=no" * in.mpathd uses SIOCSIPMPFAILBACK ioctl to pass this information to kernel. */ static boolean_t ipmp_enable_failback = B_TRUE; /* * Enable soft rings if ip_squeue_soft_ring or ip_squeue_fanout * is set and ip_soft_rings_cnt > 0. ip_squeue_soft_ring is * set through platform specific code (Niagara/Ontario). */ #define SOFT_RINGS_ENABLED() (ip_soft_rings_cnt ? \ (ip_squeue_soft_ring || ip_squeue_fanout) : B_FALSE) #define ILL_CAPAB_DLS (ILL_CAPAB_SOFT_RING | ILL_CAPAB_POLL) static uint_t ipif_rand(void) { ipif_src_random = ipif_src_random * 1103515245 + 12345; return ((ipif_src_random >> 16) & 0x7fff); } /* * Allocate per-interface mibs. Only used for ipv6. * Returns true if ok. False otherwise. * ipsq may not yet be allocated (loopback case ). */ static boolean_t ill_allocate_mibs(ill_t *ill) { ASSERT(ill->ill_isv6); /* Already allocated? */ if (ill->ill_ip6_mib != NULL) { ASSERT(ill->ill_icmp6_mib != NULL); return (B_TRUE); } ill->ill_ip6_mib = kmem_zalloc(sizeof (*ill->ill_ip6_mib), KM_NOSLEEP); if (ill->ill_ip6_mib == NULL) { return (B_FALSE); } ill->ill_icmp6_mib = kmem_zalloc(sizeof (*ill->ill_icmp6_mib), KM_NOSLEEP); if (ill->ill_icmp6_mib == NULL) { kmem_free(ill->ill_ip6_mib, sizeof (*ill->ill_ip6_mib)); ill->ill_ip6_mib = NULL; return (B_FALSE); } /* * The ipv6Ifindex and ipv6IfIcmpIndex will be assigned later * after the phyint merge occurs in ipif_set_values -> ill_glist_insert * -> ill_phyint_reinit */ return (B_TRUE); } /* * Common code for preparation of ARP commands. Two points to remember: * 1) The ill_name is tacked on at the end of the allocated space so * the templates name_offset field must contain the total space * to allocate less the name length. * * 2) The templates name_length field should contain the *template* * length. We use it as a parameter to bcopy() and then write * the real ill_name_length into the name_length field of the copy. * (Always called as writer.) */ mblk_t * ill_arp_alloc(ill_t *ill, uchar_t *template, caddr_t addr) { arc_t *arc = (arc_t *)template; char *cp; int len; mblk_t *mp; uint_t name_length = ill->ill_name_length; uint_t template_len = arc->arc_name_length; len = arc->arc_name_offset + name_length; mp = allocb(len, BPRI_HI); if (mp == NULL) return (NULL); cp = (char *)mp->b_rptr; mp->b_wptr = (uchar_t *)&cp[len]; if (template_len) bcopy(template, cp, template_len); if (len > template_len) bzero(&cp[template_len], len - template_len); mp->b_datap->db_type = M_PROTO; arc = (arc_t *)cp; arc->arc_name_length = name_length; cp = (char *)arc + arc->arc_name_offset; bcopy(ill->ill_name, cp, name_length); if (addr) { area_t *area = (area_t *)mp->b_rptr; cp = (char *)area + area->area_proto_addr_offset; bcopy(addr, cp, area->area_proto_addr_length); if (area->area_cmd == AR_ENTRY_ADD) { cp = (char *)area; len = area->area_proto_addr_length; if (area->area_proto_mask_offset) cp += area->area_proto_mask_offset; else cp += area->area_proto_addr_offset + len; while (len-- > 0) *cp++ = (char)~0; } } return (mp); } /* * Completely vaporize a lower level tap and all associated interfaces. * ill_delete is called only out of ip_close when the device control * stream is being closed. */ void ill_delete(ill_t *ill) { ipif_t *ipif; ill_t *prev_ill; /* * ill_delete may be forcibly entering the ipsq. The previous * ioctl may not have completed and may need to be aborted. * ipsq_flush takes care of it. If we don't need to enter the * the ipsq forcibly, the 2nd invocation of ipsq_flush in * ill_delete_tail is sufficient. */ ipsq_flush(ill); /* * Nuke all interfaces. ipif_free will take down the interface, * remove it from the list, and free the data structure. * Walk down the ipif list and remove the logical interfaces * first before removing the main ipif. We can't unplumb * zeroth interface first in the case of IPv6 as reset_conn_ill * -> ip_ll_delmulti_v6 de-references ill_ipif for checking * POINTOPOINT. * * If ill_ipif was not properly initialized (i.e low on memory), * then no interfaces to clean up. In this case just clean up the * ill. */ for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) ipif_free(ipif); /* * Used only by ill_arp_on and ill_arp_off, which are writers. * So nobody can be using this mp now. Free the mp allocated for * honoring ILLF_NOARP */ freemsg(ill->ill_arp_on_mp); ill->ill_arp_on_mp = NULL; /* Clean up msgs on pending upcalls for mrouted */ reset_mrt_ill(ill); /* * ipif_free -> reset_conn_ipif will remove all multicast * references for IPv4. For IPv6, we need to do it here as * it points only at ills. */ reset_conn_ill(ill); /* * ill_down will arrange to blow off any IRE's dependent on this * ILL, and shut down fragmentation reassembly. */ ill_down(ill); /* Let SCTP know, so that it can remove this from its list. */ sctp_update_ill(ill, SCTP_ILL_REMOVE); /* * If an address on this ILL is being used as a source address then * clear out the pointers in other ILLs that point to this ILL. */ rw_enter(&ill_g_usesrc_lock, RW_WRITER); if (ill->ill_usesrc_grp_next != NULL) { if (ill->ill_usesrc_ifindex == 0) { /* usesrc ILL ? */ ill_disband_usesrc_group(ill); } else { /* consumer of the usesrc ILL */ prev_ill = ill_prev_usesrc(ill); prev_ill->ill_usesrc_grp_next = ill->ill_usesrc_grp_next; } } rw_exit(&ill_g_usesrc_lock); } /* * ill_delete_tail is called from ip_modclose after all references * to the closing ill are gone. The wait is done in ip_modclose */ void ill_delete_tail(ill_t *ill) { mblk_t **mpp; ipif_t *ipif; for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) ipif_down_tail(ipif); /* * If polling capability is enabled (which signifies direct * upcall into IP and driver has ill saved as a handle), * we need to make sure that unbind has completed before we * let the ill disappear and driver no longer has any reference * to this ill. */ mutex_enter(&ill->ill_lock); while (ill->ill_state_flags & ILL_DL_UNBIND_IN_PROGRESS) cv_wait(&ill->ill_cv, &ill->ill_lock); mutex_exit(&ill->ill_lock); /* * Clean up polling and soft ring capabilities */ if (ill->ill_capabilities & (ILL_CAPAB_POLL|ILL_CAPAB_SOFT_RING)) ill_capability_dls_disable(ill); /* * Send the detach if there's one to send (i.e., if we're above a * style 2 DLPI driver). */ if (ill->ill_detach_mp != NULL) { ill_dlpi_send(ill, ill->ill_detach_mp); ill->ill_detach_mp = NULL; } if (ill->ill_net_type != IRE_LOOPBACK) qprocsoff(ill->ill_rq); /* * We do an ipsq_flush once again now. New messages could have * landed up from below (M_ERROR or M_HANGUP). Similarly ioctls * could also have landed up if an ioctl thread had looked up * the ill before we set the ILL_CONDEMNED flag, but not yet * enqueued the ioctl when we did the ipsq_flush last time. */ ipsq_flush(ill); /* * Free capabilities. */ if (ill->ill_ipsec_capab_ah != NULL) { ill_ipsec_capab_delete(ill, DL_CAPAB_IPSEC_AH); ill_ipsec_capab_free(ill->ill_ipsec_capab_ah); ill->ill_ipsec_capab_ah = NULL; } if (ill->ill_ipsec_capab_esp != NULL) { ill_ipsec_capab_delete(ill, DL_CAPAB_IPSEC_ESP); ill_ipsec_capab_free(ill->ill_ipsec_capab_esp); ill->ill_ipsec_capab_esp = NULL; } if (ill->ill_mdt_capab != NULL) { kmem_free(ill->ill_mdt_capab, sizeof (ill_mdt_capab_t)); ill->ill_mdt_capab = NULL; } if (ill->ill_hcksum_capab != NULL) { kmem_free(ill->ill_hcksum_capab, sizeof (ill_hcksum_capab_t)); ill->ill_hcksum_capab = NULL; } if (ill->ill_zerocopy_capab != NULL) { kmem_free(ill->ill_zerocopy_capab, sizeof (ill_zerocopy_capab_t)); ill->ill_zerocopy_capab = NULL; } if (ill->ill_dls_capab != NULL) { CONN_DEC_REF(ill->ill_dls_capab->ill_unbind_conn); ill->ill_dls_capab->ill_unbind_conn = NULL; kmem_free(ill->ill_dls_capab, sizeof (ill_dls_capab_t) + (sizeof (ill_rx_ring_t) * ILL_MAX_RINGS)); ill->ill_dls_capab = NULL; } ASSERT(!(ill->ill_capabilities & ILL_CAPAB_POLL)); while (ill->ill_ipif != NULL) ipif_free_tail(ill->ill_ipif); ill_down_tail(ill); /* * We have removed all references to ilm from conn and the ones joined * within the kernel. * * We don't walk conns, mrts and ires because * * 1) reset_conn_ill and reset_mrt_ill cleans up conns and mrts. * 2) ill_down ->ill_downi walks all the ires and cleans up * ill references. */ ASSERT(ilm_walk_ill(ill) == 0); /* * Take us out of the list of ILLs. ill_glist_delete -> ill_phyint_free * could free the phyint. No more reference to the phyint after this * point. */ (void) ill_glist_delete(ill); rw_enter(&ip_g_nd_lock, RW_WRITER); if (ill->ill_ndd_name != NULL) nd_unload(&ip_g_nd, ill->ill_ndd_name); rw_exit(&ip_g_nd_lock); if (ill->ill_frag_ptr != NULL) { uint_t count; for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) { mutex_destroy(&ill->ill_frag_hash_tbl[count].ipfb_lock); } mi_free(ill->ill_frag_ptr); ill->ill_frag_ptr = NULL; ill->ill_frag_hash_tbl = NULL; } if (ill->ill_nd_lla_mp != NULL) freemsg(ill->ill_nd_lla_mp); /* Free all retained control messages. */ mpp = &ill->ill_first_mp_to_free; do { while (mpp[0]) { mblk_t *mp; mblk_t *mp1; mp = mpp[0]; mpp[0] = mp->b_next; for (mp1 = mp; mp1 != NULL; mp1 = mp1->b_cont) { mp1->b_next = NULL; mp1->b_prev = NULL; } freemsg(mp); } } while (mpp++ != &ill->ill_last_mp_to_free); ill_free_mib(ill); ILL_TRACE_CLEANUP(ill); } static void ill_free_mib(ill_t *ill) { if (ill->ill_ip6_mib != NULL) { kmem_free(ill->ill_ip6_mib, sizeof (*ill->ill_ip6_mib)); ill->ill_ip6_mib = NULL; } if (ill->ill_icmp6_mib != NULL) { kmem_free(ill->ill_icmp6_mib, sizeof (*ill->ill_icmp6_mib)); ill->ill_icmp6_mib = NULL; } } /* * Concatenate together a physical address and a sap. * * Sap_lengths are interpreted as follows: * sap_length == 0 ==> no sap * sap_length > 0 ==> sap is at the head of the dlpi address * sap_length < 0 ==> sap is at the tail of the dlpi address */ static void ill_dlur_copy_address(uchar_t *phys_src, uint_t phys_length, t_scalar_t sap_src, t_scalar_t sap_length, uchar_t *dst) { uint16_t sap_addr = (uint16_t)sap_src; if (sap_length == 0) { if (phys_src == NULL) bzero(dst, phys_length); else bcopy(phys_src, dst, phys_length); } else if (sap_length < 0) { if (phys_src == NULL) bzero(dst, phys_length); else bcopy(phys_src, dst, phys_length); bcopy(&sap_addr, (char *)dst + phys_length, sizeof (sap_addr)); } else { bcopy(&sap_addr, dst, sizeof (sap_addr)); if (phys_src == NULL) bzero((char *)dst + sap_length, phys_length); else bcopy(phys_src, (char *)dst + sap_length, phys_length); } } /* * Generate a dl_unitdata_req mblk for the device and address given. * addr_length is the length of the physical portion of the address. * If addr is NULL include an all zero address of the specified length. * TRUE? In any case, addr_length is taken to be the entire length of the * dlpi address, including the absolute value of sap_length. */ mblk_t * ill_dlur_gen(uchar_t *addr, uint_t addr_length, t_uscalar_t sap, t_scalar_t sap_length) { dl_unitdata_req_t *dlur; mblk_t *mp; t_scalar_t abs_sap_length; /* absolute value */ abs_sap_length = ABS(sap_length); mp = ip_dlpi_alloc(sizeof (*dlur) + addr_length + abs_sap_length, DL_UNITDATA_REQ); if (mp == NULL) return (NULL); dlur = (dl_unitdata_req_t *)mp->b_rptr; /* HACK: accomodate incompatible DLPI drivers */ if (addr_length == 8) addr_length = 6; dlur->dl_dest_addr_length = addr_length + abs_sap_length; dlur->dl_dest_addr_offset = sizeof (*dlur); dlur->dl_priority.dl_min = 0; dlur->dl_priority.dl_max = 0; ill_dlur_copy_address(addr, addr_length, sap, sap_length, (uchar_t *)&dlur[1]); return (mp); } /* * Add the 'mp' to the list of pending mp's headed by ill_pending_mp * Return an error if we already have 1 or more ioctls in progress. * This is used only for non-exclusive ioctls. Currently this is used * for SIOC*ARP and SIOCGTUNPARAM ioctls. Most set ioctls are exclusive * and thus need to use ipsq_pending_mp_add. */ boolean_t ill_pending_mp_add(ill_t *ill, conn_t *connp, mblk_t *add_mp) { ASSERT(MUTEX_HELD(&ill->ill_lock)); ASSERT((add_mp->b_next == NULL) && (add_mp->b_prev == NULL)); /* * M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls. */ ASSERT((add_mp->b_datap->db_type == M_IOCDATA) || (add_mp->b_datap->db_type == M_IOCTL)); ASSERT(MUTEX_HELD(&connp->conn_lock)); /* * Return error if the conn has started closing. The conn * could have finished cleaning up the pending mp list, * If so we should not add another mp to the list negating * the cleanup. */ if (connp->conn_state_flags & CONN_CLOSING) return (B_FALSE); /* * Add the pending mp to the head of the list, chained by b_next. * Note down the conn on which the ioctl request came, in b_prev. * This will be used to later get the conn, when we get a response * on the ill queue, from some other module (typically arp) */ add_mp->b_next = (void *)ill->ill_pending_mp; add_mp->b_queue = CONNP_TO_WQ(connp); ill->ill_pending_mp = add_mp; if (connp != NULL) connp->conn_oper_pending_ill = ill; return (B_TRUE); } /* * Retrieve the ill_pending_mp and return it. We have to walk the list * of mblks starting at ill_pending_mp, and match based on the ioc_id. */ mblk_t * ill_pending_mp_get(ill_t *ill, conn_t **connpp, uint_t ioc_id) { mblk_t *prev = NULL; mblk_t *curr = NULL; uint_t id; conn_t *connp; /* * When the conn closes, conn_ioctl_cleanup needs to clean * up the pending mp, but it does not know the ioc_id and * passes in a zero for it. */ mutex_enter(&ill->ill_lock); if (ioc_id != 0) *connpp = NULL; /* Search the list for the appropriate ioctl based on ioc_id */ for (prev = NULL, curr = ill->ill_pending_mp; curr != NULL; prev = curr, curr = curr->b_next) { id = ((struct iocblk *)curr->b_rptr)->ioc_id; connp = Q_TO_CONN(curr->b_queue); /* Match based on the ioc_id or based on the conn */ if ((id == ioc_id) || (ioc_id == 0 && connp == *connpp)) break; } if (curr != NULL) { /* Unlink the mblk from the pending mp list */ if (prev != NULL) { prev->b_next = curr->b_next; } else { ASSERT(ill->ill_pending_mp == curr); ill->ill_pending_mp = curr->b_next; } /* * conn refcnt must have been bumped up at the start of * the ioctl. So we can safely access the conn. */ ASSERT(CONN_Q(curr->b_queue)); *connpp = Q_TO_CONN(curr->b_queue); curr->b_next = NULL; curr->b_queue = NULL; } mutex_exit(&ill->ill_lock); return (curr); } /* * Add the pending mp to the list. There can be only 1 pending mp * in the list. Any exclusive ioctl that needs to wait for a response * from another module or driver needs to use this function to set * the ipsq_pending_mp to the ioctl mblk and wait for the response from * the other module/driver. This is also used while waiting for the * ipif/ill/ire refcnts to drop to zero in bringing down an ipif. */ boolean_t ipsq_pending_mp_add(conn_t *connp, ipif_t *ipif, queue_t *q, mblk_t *add_mp, int waitfor) { ipsq_t *ipsq; ASSERT(IAM_WRITER_IPIF(ipif)); ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); ASSERT((add_mp->b_next == NULL) && (add_mp->b_prev == NULL)); /* * M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls, * M_ERROR/M_HANGUP from driver */ ASSERT((DB_TYPE(add_mp) == M_IOCDATA) || (DB_TYPE(add_mp) == M_IOCTL) || (DB_TYPE(add_mp) == M_ERROR) || (DB_TYPE(add_mp) == M_HANGUP)); ipsq = ipif->ipif_ill->ill_phyint->phyint_ipsq; if (connp != NULL) { ASSERT(MUTEX_HELD(&connp->conn_lock)); /* * Return error if the conn has started closing. The conn * could have finished cleaning up the pending mp list, * If so we should not add another mp to the list negating * the cleanup. */ if (connp->conn_state_flags & CONN_CLOSING) return (B_FALSE); } mutex_enter(&ipsq->ipsq_lock); ipsq->ipsq_pending_ipif = ipif; /* * Note down the queue in b_queue. This will be returned by * ipsq_pending_mp_get. Caller will then use these values to restart * the processing */ add_mp->b_next = NULL; add_mp->b_queue = q; ipsq->ipsq_pending_mp = add_mp; ipsq->ipsq_waitfor = waitfor; /* * ipsq_current_ipif is needed to restart the operation from * ipif_ill_refrele_tail when the last reference to the ipi/ill * is gone. Since this is not an ioctl ipsq_current_ipif has not * been set until now. */ if (DB_TYPE(add_mp) == M_ERROR || DB_TYPE(add_mp) == M_HANGUP) { ASSERT(ipsq->ipsq_current_ipif == NULL); ipsq->ipsq_current_ipif = ipif; ipsq->ipsq_last_cmd = DB_TYPE(add_mp); } if (connp != NULL) connp->conn_oper_pending_ill = ipif->ipif_ill; mutex_exit(&ipsq->ipsq_lock); return (B_TRUE); } /* * Retrieve the ipsq_pending_mp and return it. There can be only 1 mp * queued in the list. */ mblk_t * ipsq_pending_mp_get(ipsq_t *ipsq, conn_t **connpp) { mblk_t *curr = NULL; mutex_enter(&ipsq->ipsq_lock); *connpp = NULL; if (ipsq->ipsq_pending_mp == NULL) { mutex_exit(&ipsq->ipsq_lock); return (NULL); } /* There can be only 1 such excl message */ curr = ipsq->ipsq_pending_mp; ASSERT(curr != NULL && curr->b_next == NULL); ipsq->ipsq_pending_ipif = NULL; ipsq->ipsq_pending_mp = NULL; ipsq->ipsq_waitfor = 0; mutex_exit(&ipsq->ipsq_lock); if (CONN_Q(curr->b_queue)) { /* * This mp did a refhold on the conn, at the start of the ioctl. * So we can safely return a pointer to the conn to the caller. */ *connpp = Q_TO_CONN(curr->b_queue); } else { *connpp = NULL; } curr->b_next = NULL; curr->b_prev = NULL; return (curr); } /* * Cleanup the ioctl mp queued in ipsq_pending_mp * - Called in the ill_delete path * - Called in the M_ERROR or M_HANGUP path on the ill. * - Called in the conn close path. */ boolean_t ipsq_pending_mp_cleanup(ill_t *ill, conn_t *connp) { mblk_t *mp; ipsq_t *ipsq; queue_t *q; ipif_t *ipif; ASSERT(IAM_WRITER_ILL(ill)); ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); /* * If connp is null, unconditionally clean up the ipsq_pending_mp. * This happens in M_ERROR/M_HANGUP. We need to abort the current ioctl * even if it is meant for another ill, since we have to enqueue * a new mp now in ipsq_pending_mp to complete the ipif_down. * If connp is non-null we are called from the conn close path. */ mp = ipsq->ipsq_pending_mp; if (mp == NULL || (connp != NULL && mp->b_queue != CONNP_TO_WQ(connp))) { mutex_exit(&ipsq->ipsq_lock); return (B_FALSE); } /* Now remove from the ipsq_pending_mp */ ipsq->ipsq_pending_mp = NULL; q = mp->b_queue; mp->b_next = NULL; mp->b_prev = NULL; mp->b_queue = NULL; /* If MOVE was in progress, clear the move_in_progress fields also. */ ill = ipsq->ipsq_pending_ipif->ipif_ill; if (ill->ill_move_in_progress) { ILL_CLEAR_MOVE(ill); } else if (ill->ill_up_ipifs) { ill_group_cleanup(ill); } ipif = ipsq->ipsq_pending_ipif; ipsq->ipsq_pending_ipif = NULL; ipsq->ipsq_waitfor = 0; ipsq->ipsq_current_ipif = NULL; mutex_exit(&ipsq->ipsq_lock); if (DB_TYPE(mp) == M_IOCTL || DB_TYPE(mp) == M_IOCDATA) { ip_ioctl_finish(q, mp, ENXIO, connp != NULL ? CONN_CLOSE : NO_COPYOUT, connp != NULL ? ipif : NULL, NULL); } else { /* * IP-MT XXX In the case of TLI/XTI bind / optmgmt this can't * be just inet_freemsg. we have to restart it * otherwise the thread will be stuck. */ inet_freemsg(mp); } return (B_TRUE); } /* * The ill is closing. Cleanup all the pending mps. Called exclusively * towards the end of ill_delete. The refcount has gone to 0. So nobody * knows this ill, and hence nobody can add an mp to this list */ static void ill_pending_mp_cleanup(ill_t *ill) { mblk_t *mp; queue_t *q; ASSERT(IAM_WRITER_ILL(ill)); mutex_enter(&ill->ill_lock); /* * Every mp on the pending mp list originating from an ioctl * added 1 to the conn refcnt, at the start of the ioctl. * So bump it down now. See comments in ip_wput_nondata() */ while (ill->ill_pending_mp != NULL) { mp = ill->ill_pending_mp; ill->ill_pending_mp = mp->b_next; mutex_exit(&ill->ill_lock); q = mp->b_queue; ASSERT(CONN_Q(q)); mp->b_next = NULL; mp->b_prev = NULL; mp->b_queue = NULL; ip_ioctl_finish(q, mp, ENXIO, NO_COPYOUT, NULL, NULL); mutex_enter(&ill->ill_lock); } ill->ill_pending_ipif = NULL; mutex_exit(&ill->ill_lock); } /* * Called in the conn close path and ill delete path */ static void ipsq_xopq_mp_cleanup(ill_t *ill, conn_t *connp) { ipsq_t *ipsq; mblk_t *prev; mblk_t *curr; mblk_t *next; queue_t *q; mblk_t *tmp_list = NULL; ASSERT(IAM_WRITER_ILL(ill)); if (connp != NULL) q = CONNP_TO_WQ(connp); else q = ill->ill_wq; ipsq = ill->ill_phyint->phyint_ipsq; /* * Cleanup the ioctl mp's queued in ipsq_xopq_pending_mp if any. * In the case of ioctl from a conn, there can be only 1 mp * queued on the ipsq. If an ill is being unplumbed, only messages * related to this ill are flushed, like M_ERROR or M_HANGUP message. * ioctls meant for this ill form conn's are not flushed. They will * be processed during ipsq_exit and will not find the ill and will * return error. */ mutex_enter(&ipsq->ipsq_lock); for (prev = NULL, curr = ipsq->ipsq_xopq_mphead; curr != NULL; curr = next) { next = curr->b_next; if (curr->b_queue == q || curr->b_queue == RD(q)) { /* Unlink the mblk from the pending mp list */ if (prev != NULL) { prev->b_next = curr->b_next; } else { ASSERT(ipsq->ipsq_xopq_mphead == curr); ipsq->ipsq_xopq_mphead = curr->b_next; } if (ipsq->ipsq_xopq_mptail == curr) ipsq->ipsq_xopq_mptail = prev; /* * Create a temporary list and release the ipsq lock * New elements are added to the head of the tmp_list */ curr->b_next = tmp_list; tmp_list = curr; } else { prev = curr; } } mutex_exit(&ipsq->ipsq_lock); while (tmp_list != NULL) { curr = tmp_list; tmp_list = curr->b_next; curr->b_next = NULL; curr->b_prev = NULL; curr->b_queue = NULL; if (DB_TYPE(curr) == M_IOCTL || DB_TYPE(curr) == M_IOCDATA) { ip_ioctl_finish(q, curr, ENXIO, connp != NULL ? CONN_CLOSE : NO_COPYOUT, NULL, NULL); } else { /* * IP-MT XXX In the case of TLI/XTI bind / optmgmt * this can't be just inet_freemsg. we have to * restart it otherwise the thread will be stuck. */ inet_freemsg(curr); } } } /* * This conn has started closing. Cleanup any pending ioctl from this conn. * STREAMS ensures that there can be at most 1 ioctl pending on a stream. */ void conn_ioctl_cleanup(conn_t *connp) { mblk_t *curr; ipsq_t *ipsq; ill_t *ill; boolean_t refheld; /* * Is any exclusive ioctl pending ? If so clean it up. If the * ioctl has not yet started, the mp is pending in the list headed by * ipsq_xopq_head. If the ioctl has started the mp could be present in * ipsq_pending_mp. If the ioctl timed out in the streamhead but * is currently executing now the mp is not queued anywhere but * conn_oper_pending_ill is null. The conn close will wait * till the conn_ref drops to zero. */ mutex_enter(&connp->conn_lock); ill = connp->conn_oper_pending_ill; if (ill == NULL) { mutex_exit(&connp->conn_lock); return; } curr = ill_pending_mp_get(ill, &connp, 0); if (curr != NULL) { mutex_exit(&connp->conn_lock); CONN_DEC_REF(connp); inet_freemsg(curr); return; } /* * We may not be able to refhold the ill if the ill/ipif * is changing. But we need to make sure that the ill will * not vanish. So we just bump up the ill_waiter count. */ refheld = ill_waiter_inc(ill); mutex_exit(&connp->conn_lock); if (refheld) { if (ipsq_enter(ill, B_TRUE)) { ill_waiter_dcr(ill); /* * Check whether this ioctl has started and is * pending now in ipsq_pending_mp. If it is not * found there then check whether this ioctl has * not even started and is in the ipsq_xopq list. */ if (!ipsq_pending_mp_cleanup(ill, connp)) ipsq_xopq_mp_cleanup(ill, connp); ipsq = ill->ill_phyint->phyint_ipsq; ipsq_exit(ipsq, B_TRUE, B_TRUE); return; } } /* * The ill is also closing and we could not bump up the * ill_waiter_count or we could not enter the ipsq. Leave * the cleanup to ill_delete */ mutex_enter(&connp->conn_lock); while (connp->conn_oper_pending_ill != NULL) cv_wait(&connp->conn_refcv, &connp->conn_lock); mutex_exit(&connp->conn_lock); if (refheld) ill_waiter_dcr(ill); } /* * ipcl_walk function for cleaning up conn_*_ill fields. */ static void conn_cleanup_ill(conn_t *connp, caddr_t arg) { ill_t *ill = (ill_t *)arg; ire_t *ire; mutex_enter(&connp->conn_lock); if (connp->conn_multicast_ill == ill) { /* Revert to late binding */ connp->conn_multicast_ill = NULL; connp->conn_orig_multicast_ifindex = 0; } if (connp->conn_incoming_ill == ill) connp->conn_incoming_ill = NULL; if (connp->conn_outgoing_ill == ill) connp->conn_outgoing_ill = NULL; if (connp->conn_outgoing_pill == ill) connp->conn_outgoing_pill = NULL; if (connp->conn_nofailover_ill == ill) connp->conn_nofailover_ill = NULL; if (connp->conn_xmit_if_ill == ill) connp->conn_xmit_if_ill = NULL; if (connp->conn_ire_cache != NULL) { ire = connp->conn_ire_cache; /* * ip_newroute creates IRE_CACHE with ire_stq coming from * interface X and ipif coming from interface Y, if interface * X and Y are part of the same IPMPgroup. Thus whenever * interface X goes down, remove all references to it by * checking both on ire_ipif and ire_stq. */ if ((ire->ire_ipif != NULL && ire->ire_ipif->ipif_ill == ill) || (ire->ire_type == IRE_CACHE && ire->ire_stq == ill->ill_wq)) { connp->conn_ire_cache = NULL; mutex_exit(&connp->conn_lock); ire_refrele_notr(ire); return; } } mutex_exit(&connp->conn_lock); } /* ARGSUSED */ void ipif_all_down_tail(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg) { ill_t *ill = q->q_ptr; ipif_t *ipif; ASSERT(IAM_WRITER_IPSQ(ipsq)); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) ipif_down_tail(ipif); ill_down_tail(ill); freemsg(mp); ipsq->ipsq_current_ipif = NULL; } /* * ill_down_start is called when we want to down this ill and bring it up again * It is called when we receive an M_ERROR / M_HANGUP. In this case we shut down * all interfaces, but don't tear down any plumbing. */ boolean_t ill_down_start(queue_t *q, mblk_t *mp) { ill_t *ill; ipif_t *ipif; ill = q->q_ptr; ASSERT(IAM_WRITER_ILL(ill)); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) (void) ipif_down(ipif, NULL, NULL); ill_down(ill); (void) ipsq_pending_mp_cleanup(ill, NULL); mutex_enter(&ill->ill_lock); /* * Atomically test and add the pending mp if references are * still active. */ if (!ill_is_quiescent(ill)) { /* * Get rid of any pending mps and cleanup. Call will * not fail since we are passing a null connp. */ (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq, mp, ILL_DOWN); mutex_exit(&ill->ill_lock); return (B_FALSE); } mutex_exit(&ill->ill_lock); return (B_TRUE); } static void ill_down(ill_t *ill) { /* Blow off any IREs dependent on this ILL. */ ire_walk(ill_downi, (char *)ill); mutex_enter(&ire_mrtun_lock); if (ire_mrtun_count != 0) { mutex_exit(&ire_mrtun_lock); ire_walk_ill_mrtun(0, 0, ill_downi_mrtun_srcif, (char *)ill, NULL); } else { mutex_exit(&ire_mrtun_lock); } /* * If any interface based forwarding table exists * Blow off the ires there dependent on this ill */ mutex_enter(&ire_srcif_table_lock); if (ire_srcif_table_count > 0) { mutex_exit(&ire_srcif_table_lock); ire_walk_srcif_table_v4(ill_downi_mrtun_srcif, (char *)ill); } else { mutex_exit(&ire_srcif_table_lock); } /* Remove any conn_*_ill depending on this ill */ ipcl_walk(conn_cleanup_ill, (caddr_t)ill); if (ill->ill_group != NULL) { illgrp_delete(ill); } } static void ill_down_tail(ill_t *ill) { int i; /* Destroy ill_srcif_table if it exists */ /* Lock not reqd really because nobody should be able to access */ mutex_enter(&ill->ill_lock); if (ill->ill_srcif_table != NULL) { ill->ill_srcif_refcnt = 0; for (i = 0; i < IP_SRCIF_TABLE_SIZE; i++) { rw_destroy(&ill->ill_srcif_table[i].irb_lock); } kmem_free(ill->ill_srcif_table, IP_SRCIF_TABLE_SIZE * sizeof (irb_t)); ill->ill_srcif_table = NULL; ill->ill_srcif_refcnt = 0; ill->ill_mrtun_refcnt = 0; } mutex_exit(&ill->ill_lock); } /* * ire_walk routine used to delete every IRE that depends on queues * associated with 'ill'. (Always called as writer.) */ static void ill_downi(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; /* * ip_newroute creates IRE_CACHE with ire_stq coming from * interface X and ipif coming from interface Y, if interface * X and Y are part of the same IPMP group. Thus whenever interface * X goes down, remove all references to it by checking both * on ire_ipif and ire_stq. */ if ((ire->ire_ipif != NULL && ire->ire_ipif->ipif_ill == ill) || (ire->ire_type == IRE_CACHE && ire->ire_stq == ill->ill_wq)) { ire_delete(ire); } } /* * A seperate routine for deleting revtun and srcif based routes * are needed because the ires only deleted when the interface * is unplumbed. Also these ires have ire_in_ill non-null as well. * we want to keep mobile IP specific code separate. */ static void ill_downi_mrtun_srcif(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; ASSERT(ire->ire_in_ill != NULL); if ((ire->ire_in_ill != NULL && ire->ire_in_ill == ill) || (ire->ire_stq == ill->ill_wq) || (ire->ire_stq == ill->ill_rq)) { ire_delete(ire); } } /* * Remove ire/nce from the fastpath list. */ void ill_fastpath_nack(ill_t *ill) { if (ill->ill_isv6) { nce_fastpath_list_dispatch(ill, NULL, NULL); } else { ire_fastpath_list_dispatch(ill, NULL, NULL); } } /* Consume an M_IOCACK of the fastpath probe. */ void ill_fastpath_ack(ill_t *ill, mblk_t *mp) { mblk_t *mp1 = mp; /* * If this was the first attempt turn on the fastpath probing. */ mutex_enter(&ill->ill_lock); if (ill->ill_dlpi_fastpath_state == IDMS_INPROGRESS) ill->ill_dlpi_fastpath_state = IDMS_OK; mutex_exit(&ill->ill_lock); /* Free the M_IOCACK mblk, hold on to the data */ mp = mp->b_cont; freeb(mp1); if (mp == NULL) return; if (mp->b_cont != NULL) { /* * Update all IRE's or NCE's that are waiting for * fastpath update. */ if (ill->ill_isv6) { /* * update nce's in the fastpath list. */ nce_fastpath_list_dispatch(ill, ndp_fastpath_update, mp); } else { /* * update ire's in the fastpath list. */ ire_fastpath_list_dispatch(ill, ire_fastpath_update, mp); /* * Check if we need to traverse reverse tunnel table. * Since there is only single ire_type (IRE_MIPRTUN) * in the table, we don't need to match on ire_type. * We have to check ire_mrtun_count and not the * ill_mrtun_refcnt since ill_mrtun_refcnt is set * on the incoming ill and here we are dealing with * outgoing ill. */ mutex_enter(&ire_mrtun_lock); if (ire_mrtun_count != 0) { mutex_exit(&ire_mrtun_lock); ire_walk_ill_mrtun(MATCH_IRE_WQ, IRE_MIPRTUN, (void (*)(ire_t *, void *)) ire_fastpath_update, mp, ill); } else { mutex_exit(&ire_mrtun_lock); } } mp1 = mp->b_cont; freeb(mp); mp = mp1; } else { ip0dbg(("ill_fastpath_ack: no b_cont\n")); } freeb(mp); } /* * Throw an M_IOCTL message downstream asking "do you know fastpath?" * The data portion of the request is a dl_unitdata_req_t template for * what we would send downstream in the absence of a fastpath confirmation. */ int ill_fastpath_probe(ill_t *ill, mblk_t *dlur_mp) { struct iocblk *ioc; mblk_t *mp; if (dlur_mp == NULL) return (EINVAL); mutex_enter(&ill->ill_lock); switch (ill->ill_dlpi_fastpath_state) { case IDMS_FAILED: /* * Driver NAKed the first fastpath ioctl - assume it doesn't * support it. */ mutex_exit(&ill->ill_lock); return (ENOTSUP); case IDMS_UNKNOWN: /* This is the first probe */ ill->ill_dlpi_fastpath_state = IDMS_INPROGRESS; break; default: break; } mutex_exit(&ill->ill_lock); if ((mp = mkiocb(DL_IOC_HDR_INFO)) == NULL) return (EAGAIN); mp->b_cont = copyb(dlur_mp); if (mp->b_cont == NULL) { freeb(mp); return (EAGAIN); } ioc = (struct iocblk *)mp->b_rptr; ioc->ioc_count = msgdsize(mp->b_cont); putnext(ill->ill_wq, mp); return (0); } void ill_capability_probe(ill_t *ill) { /* * Do so only if negotiation is enabled, capabilities are unknown, * and a capability negotiation is not already in progress. */ if (ill->ill_capab_state != IDMS_UNKNOWN && ill->ill_capab_state != IDMS_RENEG) return; ill->ill_capab_state = IDMS_INPROGRESS; ip1dbg(("ill_capability_probe: starting capability negotiation\n")); ill_capability_proto(ill, DL_CAPABILITY_REQ, NULL); } void ill_capability_reset(ill_t *ill) { mblk_t *sc_mp = NULL; mblk_t *tmp; /* * Note here that we reset the state to UNKNOWN, and later send * down the DL_CAPABILITY_REQ without first setting the state to * INPROGRESS. We do this in order to distinguish the * DL_CAPABILITY_ACK response which may come back in response to * a "reset" apart from the "probe" DL_CAPABILITY_REQ. This would * also handle the case where the driver doesn't send us back * a DL_CAPABILITY_ACK in response, since the "probe" routine * requires the state to be in UNKNOWN anyway. In any case, all * features are turned off until the state reaches IDMS_OK. */ ill->ill_capab_state = IDMS_UNKNOWN; /* * Disable sub-capabilities and request a list of sub-capability * messages which will be sent down to the driver. Each handler * allocates the corresponding dl_capability_sub_t inside an * mblk, and links it to the existing sc_mp mblk, or return it * as sc_mp if it's the first sub-capability (the passed in * sc_mp is NULL). Upon returning from all capability handlers, * sc_mp will be pulled-up, before passing it downstream. */ ill_capability_mdt_reset(ill, &sc_mp); ill_capability_hcksum_reset(ill, &sc_mp); ill_capability_zerocopy_reset(ill, &sc_mp); ill_capability_ipsec_reset(ill, &sc_mp); ill_capability_dls_reset(ill, &sc_mp); /* Nothing to send down in order to disable the capabilities? */ if (sc_mp == NULL) return; tmp = msgpullup(sc_mp, -1); freemsg(sc_mp); if ((sc_mp = tmp) == NULL) { cmn_err(CE_WARN, "ill_capability_reset: unable to send down " "DL_CAPABILITY_REQ (ENOMEM)\n"); return; } ip1dbg(("ill_capability_reset: resetting negotiated capabilities\n")); ill_capability_proto(ill, DL_CAPABILITY_REQ, sc_mp); } /* * Request or set new-style hardware capabilities supported by DLS provider. */ static void ill_capability_proto(ill_t *ill, int type, mblk_t *reqp) { mblk_t *mp; dl_capability_req_t *capb; size_t size = 0; uint8_t *ptr; if (reqp != NULL) size = MBLKL(reqp); mp = ip_dlpi_alloc(sizeof (dl_capability_req_t) + size, type); if (mp == NULL) { freemsg(reqp); return; } ptr = mp->b_rptr; capb = (dl_capability_req_t *)ptr; ptr += sizeof (dl_capability_req_t); if (reqp != NULL) { capb->dl_sub_offset = sizeof (dl_capability_req_t); capb->dl_sub_length = size; bcopy(reqp->b_rptr, ptr, size); ptr += size; mp->b_cont = reqp->b_cont; freeb(reqp); } ASSERT(ptr == mp->b_wptr); ill_dlpi_send(ill, mp); } static void ill_capability_id_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *outers) { dl_capab_id_t *id_ic; uint_t sub_dl_cap = outers->dl_cap; dl_capability_sub_t *inners; uint8_t *capend; ASSERT(sub_dl_cap == DL_CAPAB_ID_WRAPPER); /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(outers + 1) + outers->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_id_ack: " "malformed sub-capability too long for mblk"); return; } id_ic = (dl_capab_id_t *)(outers + 1); if (outers->dl_length < sizeof (*id_ic) || (inners = &id_ic->id_subcap, inners->dl_length > (outers->dl_length - sizeof (*inners)))) { cmn_err(CE_WARN, "ill_capability_id_ack: malformed " "encapsulated capab type %d too long for mblk", inners->dl_cap); return; } if (!dlcapabcheckqid(&id_ic->id_mid, ill->ill_lmod_rq)) { ip1dbg(("ill_capability_id_ack: mid token for capab type %d " "isn't as expected; pass-thru module(s) detected, " "discarding capability\n", inners->dl_cap)); return; } /* Process the encapsulated sub-capability */ ill_capability_dispatch(ill, mp, inners, B_TRUE); } /* * Process Multidata Transmit capability negotiation ack received from a * DLS Provider. isub must point to the sub-capability (DL_CAPAB_MDT) of a * DL_CAPABILITY_ACK message. */ static void ill_capability_mdt_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub) { mblk_t *nmp = NULL; dl_capability_req_t *oc; dl_capab_mdt_t *mdt_ic, *mdt_oc; ill_mdt_capab_t **ill_mdt_capab; uint_t sub_dl_cap = isub->dl_cap; uint8_t *capend; ASSERT(sub_dl_cap == DL_CAPAB_MDT); ill_mdt_capab = (ill_mdt_capab_t **)&ill->ill_mdt_capab; /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(isub + 1) + isub->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_mdt_ack: " "malformed sub-capability too long for mblk"); return; } mdt_ic = (dl_capab_mdt_t *)(isub + 1); if (mdt_ic->mdt_version != MDT_VERSION_2) { cmn_err(CE_CONT, "ill_capability_mdt_ack: " "unsupported MDT sub-capability (version %d, expected %d)", mdt_ic->mdt_version, MDT_VERSION_2); return; } if (!dlcapabcheckqid(&mdt_ic->mdt_mid, ill->ill_lmod_rq)) { ip1dbg(("ill_capability_mdt_ack: mid token for MDT " "capability isn't as expected; pass-thru module(s) " "detected, discarding capability\n")); return; } if (mdt_ic->mdt_flags & DL_CAPAB_MDT_ENABLE) { if (*ill_mdt_capab == NULL) { *ill_mdt_capab = kmem_zalloc(sizeof (ill_mdt_capab_t), KM_NOSLEEP); if (*ill_mdt_capab == NULL) { cmn_err(CE_WARN, "ill_capability_mdt_ack: " "could not enable MDT version %d " "for %s (ENOMEM)\n", MDT_VERSION_2, ill->ill_name); return; } } ip1dbg(("ill_capability_mdt_ack: interface %s supports " "MDT version %d (%d bytes leading, %d bytes trailing " "header spaces, %d max pld bufs, %d span limit)\n", ill->ill_name, MDT_VERSION_2, mdt_ic->mdt_hdr_head, mdt_ic->mdt_hdr_tail, mdt_ic->mdt_max_pld, mdt_ic->mdt_span_limit)); (*ill_mdt_capab)->ill_mdt_version = MDT_VERSION_2; (*ill_mdt_capab)->ill_mdt_on = 1; /* * Round the following values to the nearest 32-bit; ULP * may further adjust them to accomodate for additional * protocol headers. We pass these values to ULP during * bind time. */ (*ill_mdt_capab)->ill_mdt_hdr_head = roundup(mdt_ic->mdt_hdr_head, 4); (*ill_mdt_capab)->ill_mdt_hdr_tail = roundup(mdt_ic->mdt_hdr_tail, 4); (*ill_mdt_capab)->ill_mdt_max_pld = mdt_ic->mdt_max_pld; (*ill_mdt_capab)->ill_mdt_span_limit = mdt_ic->mdt_span_limit; ill->ill_capabilities |= ILL_CAPAB_MDT; } else { uint_t size; uchar_t *rptr; size = sizeof (dl_capability_req_t) + sizeof (dl_capability_sub_t) + sizeof (dl_capab_mdt_t); if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) { cmn_err(CE_WARN, "ill_capability_mdt_ack: " "could not enable MDT for %s (ENOMEM)\n", ill->ill_name); return; } rptr = nmp->b_rptr; /* initialize dl_capability_req_t */ oc = (dl_capability_req_t *)nmp->b_rptr; oc->dl_sub_offset = sizeof (dl_capability_req_t); oc->dl_sub_length = sizeof (dl_capability_sub_t) + sizeof (dl_capab_mdt_t); nmp->b_rptr += sizeof (dl_capability_req_t); /* initialize dl_capability_sub_t */ bcopy(isub, nmp->b_rptr, sizeof (*isub)); nmp->b_rptr += sizeof (*isub); /* initialize dl_capab_mdt_t */ mdt_oc = (dl_capab_mdt_t *)nmp->b_rptr; bcopy(mdt_ic, mdt_oc, sizeof (*mdt_ic)); nmp->b_rptr = rptr; ip1dbg(("ill_capability_mdt_ack: asking interface %s " "to enable MDT version %d\n", ill->ill_name, MDT_VERSION_2)); /* set ENABLE flag */ mdt_oc->mdt_flags |= DL_CAPAB_MDT_ENABLE; /* nmp points to a DL_CAPABILITY_REQ message to enable MDT */ ill_dlpi_send(ill, nmp); } } static void ill_capability_mdt_reset(ill_t *ill, mblk_t **sc_mp) { mblk_t *mp; dl_capab_mdt_t *mdt_subcap; dl_capability_sub_t *dl_subcap; int size; if (!ILL_MDT_CAPABLE(ill)) return; ASSERT(ill->ill_mdt_capab != NULL); /* * Clear the capability flag for MDT but retain the ill_mdt_capab * structure since it's possible that another thread is still * referring to it. The structure only gets deallocated when * we destroy the ill. */ ill->ill_capabilities &= ~ILL_CAPAB_MDT; size = sizeof (*dl_subcap) + sizeof (*mdt_subcap); mp = allocb(size, BPRI_HI); if (mp == NULL) { ip1dbg(("ill_capability_mdt_reset: unable to allocate " "request to disable MDT\n")); return; } mp->b_wptr = mp->b_rptr + size; dl_subcap = (dl_capability_sub_t *)mp->b_rptr; dl_subcap->dl_cap = DL_CAPAB_MDT; dl_subcap->dl_length = sizeof (*mdt_subcap); mdt_subcap = (dl_capab_mdt_t *)(dl_subcap + 1); mdt_subcap->mdt_version = ill->ill_mdt_capab->ill_mdt_version; mdt_subcap->mdt_flags = 0; mdt_subcap->mdt_hdr_head = 0; mdt_subcap->mdt_hdr_tail = 0; if (*sc_mp != NULL) linkb(*sc_mp, mp); else *sc_mp = mp; } /* * Send a DL_NOTIFY_REQ to the specified ill to enable * DL_NOTE_PROMISC_ON/OFF_PHYS notifications. * Invoked by ill_capability_ipsec_ack() before enabling IPsec hardware * acceleration. * Returns B_TRUE on success, B_FALSE if the message could not be sent. */ static boolean_t ill_enable_promisc_notify(ill_t *ill) { mblk_t *mp; dl_notify_req_t *req; IPSECHW_DEBUG(IPSECHW_PKT, ("ill_enable_promisc_notify:\n")); mp = ip_dlpi_alloc(sizeof (dl_notify_req_t), DL_NOTIFY_REQ); if (mp == NULL) return (B_FALSE); req = (dl_notify_req_t *)mp->b_rptr; req->dl_notifications = DL_NOTE_PROMISC_ON_PHYS | DL_NOTE_PROMISC_OFF_PHYS; ill_dlpi_send(ill, mp); return (B_TRUE); } /* * Allocate an IPsec capability request which will be filled by our * caller to turn on support for one or more algorithms. */ static mblk_t * ill_alloc_ipsec_cap_req(ill_t *ill, dl_capability_sub_t *isub) { mblk_t *nmp; dl_capability_req_t *ocap; dl_capab_ipsec_t *ocip; dl_capab_ipsec_t *icip; uint8_t *ptr; icip = (dl_capab_ipsec_t *)(isub + 1); /* * The first time around, we send a DL_NOTIFY_REQ to enable * PROMISC_ON/OFF notification from the provider. We need to * do this before enabling the algorithms to avoid leakage of * cleartext packets. */ if (!ill_enable_promisc_notify(ill)) return (NULL); /* * Allocate new mblk which will contain a new capability * request to enable the capabilities. */ nmp = ip_dlpi_alloc(sizeof (dl_capability_req_t) + sizeof (dl_capability_sub_t) + isub->dl_length, DL_CAPABILITY_REQ); if (nmp == NULL) return (NULL); ptr = nmp->b_rptr; /* initialize dl_capability_req_t */ ocap = (dl_capability_req_t *)ptr; ocap->dl_sub_offset = sizeof (dl_capability_req_t); ocap->dl_sub_length = sizeof (dl_capability_sub_t) + isub->dl_length; ptr += sizeof (dl_capability_req_t); /* initialize dl_capability_sub_t */ bcopy(isub, ptr, sizeof (*isub)); ptr += sizeof (*isub); /* initialize dl_capab_ipsec_t */ ocip = (dl_capab_ipsec_t *)ptr; bcopy(icip, ocip, sizeof (*icip)); nmp->b_wptr = (uchar_t *)(&ocip->cip_data[0]); return (nmp); } /* * Process an IPsec capability negotiation ack received from a DLS Provider. * isub must point to the sub-capability (DL_CAPAB_IPSEC_AH or * DL_CAPAB_IPSEC_ESP) of a DL_CAPABILITY_ACK message. */ static void ill_capability_ipsec_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub) { dl_capab_ipsec_t *icip; dl_capab_ipsec_alg_t *ialg; /* ptr to input alg spec. */ dl_capab_ipsec_alg_t *oalg; /* ptr to output alg spec. */ uint_t cipher, nciphers; mblk_t *nmp; uint_t alg_len; boolean_t need_sadb_dump; uint_t sub_dl_cap = isub->dl_cap; ill_ipsec_capab_t **ill_capab; uint64_t ill_capab_flag; uint8_t *capend, *ciphend; boolean_t sadb_resync; ASSERT(sub_dl_cap == DL_CAPAB_IPSEC_AH || sub_dl_cap == DL_CAPAB_IPSEC_ESP); if (sub_dl_cap == DL_CAPAB_IPSEC_AH) { ill_capab = (ill_ipsec_capab_t **)&ill->ill_ipsec_capab_ah; ill_capab_flag = ILL_CAPAB_AH; } else { ill_capab = (ill_ipsec_capab_t **)&ill->ill_ipsec_capab_esp; ill_capab_flag = ILL_CAPAB_ESP; } /* * If the ill capability structure exists, then this incoming * DL_CAPABILITY_ACK is a response to a "renegotiation" cycle. * If this is so, then we'd need to resynchronize the SADB * after re-enabling the offloaded ciphers. */ sadb_resync = (*ill_capab != NULL); /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(isub + 1) + isub->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "malformed sub-capability too long for mblk"); return; } /* * There are two types of acks we process here: * 1. acks in reply to a (first form) generic capability req * (no ENABLE flag set) * 2. acks in reply to a ENABLE capability req. * (ENABLE flag set) * * We process the subcapability passed as argument as follows: * 1 do initializations * 1.1 initialize nmp = NULL * 1.2 set need_sadb_dump to B_FALSE * 2 for each cipher in subcapability: * 2.1 if ENABLE flag is set: * 2.1.1 update per-ill ipsec capabilities info * 2.1.2 set need_sadb_dump to B_TRUE * 2.2 if ENABLE flag is not set: * 2.2.1 if nmp is NULL: * 2.2.1.1 allocate and initialize nmp * 2.2.1.2 init current pos in nmp * 2.2.2 copy current cipher to current pos in nmp * 2.2.3 set ENABLE flag in nmp * 2.2.4 update current pos * 3 if nmp is not equal to NULL, send enable request * 3.1 send capability request * 4 if need_sadb_dump is B_TRUE * 4.1 enable promiscuous on/off notifications * 4.2 call ill_dlpi_send(isub->dlcap) to send all * AH or ESP SA's to interface. */ nmp = NULL; oalg = NULL; need_sadb_dump = B_FALSE; icip = (dl_capab_ipsec_t *)(isub + 1); ialg = (dl_capab_ipsec_alg_t *)(&icip->cip_data[0]); nciphers = icip->cip_nciphers; ciphend = (uint8_t *)(ialg + icip->cip_nciphers); if (ciphend > capend) { cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "too many ciphers for sub-capability len"); return; } for (cipher = 0; cipher < nciphers; cipher++) { alg_len = sizeof (dl_capab_ipsec_alg_t); if (ialg->alg_flag & DL_CAPAB_ALG_ENABLE) { /* * TBD: when we provide a way to disable capabilities * from above, need to manage the request-pending state * and fail if we were not expecting this ACK. */ IPSECHW_DEBUG(IPSECHW_CAPAB, ("ill_capability_ipsec_ack: got ENABLE ACK\n")); /* * Update IPsec capabilities for this ill */ if (*ill_capab == NULL) { IPSECHW_DEBUG(IPSECHW_CAPAB, ("ill_capability_ipsec_ack: " "allocating ipsec_capab for ill\n")); *ill_capab = ill_ipsec_capab_alloc(); if (*ill_capab == NULL) { cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "could not enable IPsec Hardware " "acceleration for %s (ENOMEM)\n", ill->ill_name); return; } } ASSERT(ialg->alg_type == DL_CAPAB_IPSEC_ALG_AUTH || ialg->alg_type == DL_CAPAB_IPSEC_ALG_ENCR); if (ialg->alg_prim >= MAX_IPSEC_ALGS) { cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "malformed IPsec algorithm id %d", ialg->alg_prim); continue; } if (ialg->alg_type == DL_CAPAB_IPSEC_ALG_AUTH) { IPSEC_ALG_ENABLE((*ill_capab)->auth_hw_algs, ialg->alg_prim); } else { ipsec_capab_algparm_t *alp; IPSEC_ALG_ENABLE((*ill_capab)->encr_hw_algs, ialg->alg_prim); if (!ill_ipsec_capab_resize_algparm(*ill_capab, ialg->alg_prim)) { cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "no space for IPsec alg id %d", ialg->alg_prim); continue; } alp = &((*ill_capab)->encr_algparm[ ialg->alg_prim]); alp->minkeylen = ialg->alg_minbits; alp->maxkeylen = ialg->alg_maxbits; } ill->ill_capabilities |= ill_capab_flag; /* * indicate that a capability was enabled, which * will be used below to kick off a SADB dump * to the ill. */ need_sadb_dump = B_TRUE; } else { IPSECHW_DEBUG(IPSECHW_CAPAB, ("ill_capability_ipsec_ack: enabling alg 0x%x\n", ialg->alg_prim)); if (nmp == NULL) { nmp = ill_alloc_ipsec_cap_req(ill, isub); if (nmp == NULL) { /* * Sending the PROMISC_ON/OFF * notification request failed. * We cannot enable the algorithms * since the Provider will not * notify IP of promiscous mode * changes, which could lead * to leakage of packets. */ cmn_err(CE_WARN, "ill_capability_ipsec_ack: " "could not enable IPsec Hardware " "acceleration for %s (ENOMEM)\n", ill->ill_name); return; } /* ptr to current output alg specifier */ oalg = (dl_capab_ipsec_alg_t *)nmp->b_wptr; } /* * Copy current alg specifier, set ENABLE * flag, and advance to next output alg. * For now we enable all IPsec capabilities. */ ASSERT(oalg != NULL); bcopy(ialg, oalg, alg_len); oalg->alg_flag |= DL_CAPAB_ALG_ENABLE; nmp->b_wptr += alg_len; oalg = (dl_capab_ipsec_alg_t *)nmp->b_wptr; } /* move to next input algorithm specifier */ ialg = (dl_capab_ipsec_alg_t *) ((char *)ialg + alg_len); } if (nmp != NULL) /* * nmp points to a DL_CAPABILITY_REQ message to enable * IPsec hardware acceleration. */ ill_dlpi_send(ill, nmp); if (need_sadb_dump) /* * An acknowledgement corresponding to a request to * enable acceleration was received, notify SADB. */ ill_ipsec_capab_add(ill, sub_dl_cap, sadb_resync); } /* * Given an mblk with enough space in it, create sub-capability entries for * DL_CAPAB_IPSEC_{AH,ESP} types which consist of previously-advertised * offloaded ciphers (both AUTH and ENCR) with their enable flags cleared, * in preparation for the reset the DL_CAPABILITY_REQ message. */ static void ill_fill_ipsec_reset(uint_t nciphers, int stype, uint_t slen, ill_ipsec_capab_t *ill_cap, mblk_t *mp) { dl_capab_ipsec_t *oipsec; dl_capab_ipsec_alg_t *oalg; dl_capability_sub_t *dl_subcap; int i, k; ASSERT(nciphers > 0); ASSERT(ill_cap != NULL); ASSERT(mp != NULL); ASSERT(MBLKTAIL(mp) >= sizeof (*dl_subcap) + sizeof (*oipsec) + slen); /* dl_capability_sub_t for "stype" */ dl_subcap = (dl_capability_sub_t *)mp->b_wptr; dl_subcap->dl_cap = stype; dl_subcap->dl_length = sizeof (dl_capab_ipsec_t) + slen; mp->b_wptr += sizeof (dl_capability_sub_t); /* dl_capab_ipsec_t for "stype" */ oipsec = (dl_capab_ipsec_t *)mp->b_wptr; oipsec->cip_version = 1; oipsec->cip_nciphers = nciphers; mp->b_wptr = (uchar_t *)&oipsec->cip_data[0]; /* create entries for "stype" AUTH ciphers */ for (i = 0; i < ill_cap->algs_size; i++) { for (k = 0; k < BITSPERBYTE; k++) { if ((ill_cap->auth_hw_algs[i] & (1 << k)) == 0) continue; oalg = (dl_capab_ipsec_alg_t *)mp->b_wptr; bzero((void *)oalg, sizeof (*oalg)); oalg->alg_type = DL_CAPAB_IPSEC_ALG_AUTH; oalg->alg_prim = k + (BITSPERBYTE * i); mp->b_wptr += sizeof (dl_capab_ipsec_alg_t); } } /* create entries for "stype" ENCR ciphers */ for (i = 0; i < ill_cap->algs_size; i++) { for (k = 0; k < BITSPERBYTE; k++) { if ((ill_cap->encr_hw_algs[i] & (1 << k)) == 0) continue; oalg = (dl_capab_ipsec_alg_t *)mp->b_wptr; bzero((void *)oalg, sizeof (*oalg)); oalg->alg_type = DL_CAPAB_IPSEC_ALG_ENCR; oalg->alg_prim = k + (BITSPERBYTE * i); mp->b_wptr += sizeof (dl_capab_ipsec_alg_t); } } } /* * Macro to count number of 1s in a byte (8-bit word). The total count is * accumulated into the passed-in argument (sum). We could use SPARCv9's * POPC instruction, but our macro is more flexible for an arbitrary length * of bytes, such as {auth,encr}_hw_algs. These variables are currently * 256-bits long (MAX_IPSEC_ALGS), so if we know for sure that the length * stays that way, we can reduce the number of iterations required. */ #define COUNT_1S(val, sum) { \ uint8_t x = val & 0xff; \ x = (x & 0x55) + ((x >> 1) & 0x55); \ x = (x & 0x33) + ((x >> 2) & 0x33); \ sum += (x & 0xf) + ((x >> 4) & 0xf); \ } /* ARGSUSED */ static void ill_capability_ipsec_reset(ill_t *ill, mblk_t **sc_mp) { mblk_t *mp; ill_ipsec_capab_t *cap_ah = ill->ill_ipsec_capab_ah; ill_ipsec_capab_t *cap_esp = ill->ill_ipsec_capab_esp; uint64_t ill_capabilities = ill->ill_capabilities; int ah_cnt = 0, esp_cnt = 0; int ah_len = 0, esp_len = 0; int i, size = 0; if (!(ill_capabilities & (ILL_CAPAB_AH | ILL_CAPAB_ESP))) return; ASSERT(cap_ah != NULL || !(ill_capabilities & ILL_CAPAB_AH)); ASSERT(cap_esp != NULL || !(ill_capabilities & ILL_CAPAB_ESP)); /* Find out the number of ciphers for AH */ if (cap_ah != NULL) { for (i = 0; i < cap_ah->algs_size; i++) { COUNT_1S(cap_ah->auth_hw_algs[i], ah_cnt); COUNT_1S(cap_ah->encr_hw_algs[i], ah_cnt); } if (ah_cnt > 0) { size += sizeof (dl_capability_sub_t) + sizeof (dl_capab_ipsec_t); /* dl_capab_ipsec_t contains one dl_capab_ipsec_alg_t */ ah_len = (ah_cnt - 1) * sizeof (dl_capab_ipsec_alg_t); size += ah_len; } } /* Find out the number of ciphers for ESP */ if (cap_esp != NULL) { for (i = 0; i < cap_esp->algs_size; i++) { COUNT_1S(cap_esp->auth_hw_algs[i], esp_cnt); COUNT_1S(cap_esp->encr_hw_algs[i], esp_cnt); } if (esp_cnt > 0) { size += sizeof (dl_capability_sub_t) + sizeof (dl_capab_ipsec_t); /* dl_capab_ipsec_t contains one dl_capab_ipsec_alg_t */ esp_len = (esp_cnt - 1) * sizeof (dl_capab_ipsec_alg_t); size += esp_len; } } if (size == 0) { ip1dbg(("ill_capability_ipsec_reset: capabilities exist but " "there's nothing to reset\n")); return; } mp = allocb(size, BPRI_HI); if (mp == NULL) { ip1dbg(("ill_capability_ipsec_reset: unable to allocate " "request to disable IPSEC Hardware Acceleration\n")); return; } /* * Clear the capability flags for IPSec HA but retain the ill * capability structures since it's possible that another thread * is still referring to them. The structures only get deallocated * when we destroy the ill. * * Various places check the flags to see if the ill is capable of * hardware acceleration, and by clearing them we ensure that new * outbound IPSec packets are sent down encrypted. */ ill->ill_capabilities &= ~(ILL_CAPAB_AH | ILL_CAPAB_ESP); /* Fill in DL_CAPAB_IPSEC_AH sub-capability entries */ if (ah_cnt > 0) { ill_fill_ipsec_reset(ah_cnt, DL_CAPAB_IPSEC_AH, ah_len, cap_ah, mp); ASSERT(mp->b_rptr + size >= mp->b_wptr); } /* Fill in DL_CAPAB_IPSEC_ESP sub-capability entries */ if (esp_cnt > 0) { ill_fill_ipsec_reset(esp_cnt, DL_CAPAB_IPSEC_ESP, esp_len, cap_esp, mp); ASSERT(mp->b_rptr + size >= mp->b_wptr); } /* * At this point we've composed a bunch of sub-capabilities to be * encapsulated in a DL_CAPABILITY_REQ and later sent downstream * by the caller. Upon receiving this reset message, the driver * must stop inbound decryption (by destroying all inbound SAs) * and let the corresponding packets come in encrypted. */ if (*sc_mp != NULL) linkb(*sc_mp, mp); else *sc_mp = mp; } static void ill_capability_dispatch(ill_t *ill, mblk_t *mp, dl_capability_sub_t *subp, boolean_t encapsulated) { boolean_t legacy = B_FALSE; /* * If this DL_CAPABILITY_ACK came in as a response to our "reset" * DL_CAPABILITY_REQ, ignore it during this cycle. We've just * instructed the driver to disable its advertised capabilities, * so there's no point in accepting any response at this moment. */ if (ill->ill_capab_state == IDMS_UNKNOWN) return; /* * Note that only the following two sub-capabilities may be * considered as "legacy", since their original definitions * do not incorporate the dl_mid_t module ID token, and hence * may require the use of the wrapper sub-capability. */ switch (subp->dl_cap) { case DL_CAPAB_IPSEC_AH: case DL_CAPAB_IPSEC_ESP: legacy = B_TRUE; break; } /* * For legacy sub-capabilities which don't incorporate a queue_t * pointer in their structures, discard them if we detect that * there are intermediate modules in between IP and the driver. */ if (!encapsulated && legacy && ill->ill_lmod_cnt > 1) { ip1dbg(("ill_capability_dispatch: unencapsulated capab type " "%d discarded; %d module(s) present below IP\n", subp->dl_cap, ill->ill_lmod_cnt)); return; } switch (subp->dl_cap) { case DL_CAPAB_IPSEC_AH: case DL_CAPAB_IPSEC_ESP: ill_capability_ipsec_ack(ill, mp, subp); break; case DL_CAPAB_MDT: ill_capability_mdt_ack(ill, mp, subp); break; case DL_CAPAB_HCKSUM: ill_capability_hcksum_ack(ill, mp, subp); break; case DL_CAPAB_ZEROCOPY: ill_capability_zerocopy_ack(ill, mp, subp); break; case DL_CAPAB_POLL: if (!SOFT_RINGS_ENABLED()) ill_capability_dls_ack(ill, mp, subp); break; case DL_CAPAB_SOFT_RING: if (SOFT_RINGS_ENABLED()) ill_capability_dls_ack(ill, mp, subp); break; default: ip1dbg(("ill_capability_dispatch: unknown capab type %d\n", subp->dl_cap)); } } /* * As part of negotiating polling capability, the driver tells us * the default (or normal) blanking interval and packet threshold * (the receive timer fires if blanking interval is reached or * the packet threshold is reached). * * As part of manipulating the polling interval, we always use our * estimated interval (avg service time * number of packets queued * on the squeue) but we try to blank for a minimum of * rr_normal_blank_time * rr_max_blank_ratio. We disable the * packet threshold during this time. When we are not in polling mode * we set the blank interval typically lower, rr_normal_pkt_cnt * * rr_min_blank_ratio but up the packet cnt by a ratio of * rr_min_pkt_cnt_ratio so that we are still getting chains if * possible although for a shorter interval. */ #define RR_MAX_BLANK_RATIO 20 #define RR_MIN_BLANK_RATIO 10 #define RR_MAX_PKT_CNT_RATIO 3 #define RR_MIN_PKT_CNT_RATIO 3 /* * These can be tuned via /etc/system. */ int rr_max_blank_ratio = RR_MAX_BLANK_RATIO; int rr_min_blank_ratio = RR_MIN_BLANK_RATIO; int rr_max_pkt_cnt_ratio = RR_MAX_PKT_CNT_RATIO; int rr_min_pkt_cnt_ratio = RR_MIN_PKT_CNT_RATIO; static mac_resource_handle_t ill_ring_add(void *arg, mac_resource_t *mrp) { ill_t *ill = (ill_t *)arg; mac_rx_fifo_t *mrfp = (mac_rx_fifo_t *)mrp; ill_rx_ring_t *rx_ring; int ip_rx_index; ASSERT(mrp != NULL); if (mrp->mr_type != MAC_RX_FIFO) { return (NULL); } ASSERT(ill != NULL); ASSERT(ill->ill_dls_capab != NULL); mutex_enter(&ill->ill_lock); for (ip_rx_index = 0; ip_rx_index < ILL_MAX_RINGS; ip_rx_index++) { rx_ring = &ill->ill_dls_capab->ill_ring_tbl[ip_rx_index]; ASSERT(rx_ring != NULL); if (rx_ring->rr_ring_state == ILL_RING_FREE) { time_t normal_blank_time = mrfp->mrf_normal_blank_time; uint_t normal_pkt_cnt = mrfp->mrf_normal_pkt_count; bzero(rx_ring, sizeof (ill_rx_ring_t)); rx_ring->rr_blank = mrfp->mrf_blank; rx_ring->rr_handle = mrfp->mrf_arg; rx_ring->rr_ill = ill; rx_ring->rr_normal_blank_time = normal_blank_time; rx_ring->rr_normal_pkt_cnt = normal_pkt_cnt; rx_ring->rr_max_blank_time = normal_blank_time * rr_max_blank_ratio; rx_ring->rr_min_blank_time = normal_blank_time * rr_min_blank_ratio; rx_ring->rr_max_pkt_cnt = normal_pkt_cnt * rr_max_pkt_cnt_ratio; rx_ring->rr_min_pkt_cnt = normal_pkt_cnt * rr_min_pkt_cnt_ratio; rx_ring->rr_ring_state = ILL_RING_INUSE; mutex_exit(&ill->ill_lock); DTRACE_PROBE2(ill__ring__add, (void *), ill, (int), ip_rx_index); return ((mac_resource_handle_t)rx_ring); } } /* * We ran out of ILL_MAX_RINGS worth rx_ring structures. If * we have devices which can overwhelm this limit, ILL_MAX_RING * should be made configurable. Meanwhile it cause no panic because * driver will pass ip_input a NULL handle which will make * IP allocate the default squeue and Polling mode will not * be used for this ring. */ cmn_err(CE_NOTE, "Reached maximum number of receiving rings (%d) " "for %s\n", ILL_MAX_RINGS, ill->ill_name); mutex_exit(&ill->ill_lock); return (NULL); } static boolean_t ill_capability_dls_init(ill_t *ill) { ill_dls_capab_t *ill_dls = ill->ill_dls_capab; conn_t *connp; size_t sz; if (ill->ill_capabilities & ILL_CAPAB_SOFT_RING) { if (ill_dls == NULL) { cmn_err(CE_PANIC, "ill_capability_dls_init: " "soft_ring enabled for ill=%s (%p) but data " "structs uninitialized\n", ill->ill_name, (void *)ill); } return (B_TRUE); } else if (ill->ill_capabilities & ILL_CAPAB_POLL) { if (ill_dls == NULL) { cmn_err(CE_PANIC, "ill_capability_dls_init: " "polling enabled for ill=%s (%p) but data " "structs uninitialized\n", ill->ill_name, (void *)ill); } return (B_TRUE); } if (ill_dls != NULL) { ill_rx_ring_t *rx_ring = ill_dls->ill_ring_tbl; /* Soft_Ring or polling is being re-enabled */ connp = ill_dls->ill_unbind_conn; ASSERT(rx_ring != NULL); bzero((void *)ill_dls, sizeof (ill_dls_capab_t)); bzero((void *)rx_ring, sizeof (ill_rx_ring_t) * ILL_MAX_RINGS); ill_dls->ill_ring_tbl = rx_ring; ill_dls->ill_unbind_conn = connp; return (B_TRUE); } if ((connp = ipcl_conn_create(IPCL_TCPCONN, KM_NOSLEEP)) == NULL) return (B_FALSE); sz = sizeof (ill_dls_capab_t); sz += sizeof (ill_rx_ring_t) * ILL_MAX_RINGS; ill_dls = kmem_zalloc(sz, KM_NOSLEEP); if (ill_dls == NULL) { cmn_err(CE_WARN, "ill_capability_dls_init: could not " "allocate dls_capab for %s (%p)\n", ill->ill_name, (void *)ill); CONN_DEC_REF(connp); return (B_FALSE); } /* Allocate space to hold ring table */ ill_dls->ill_ring_tbl = (ill_rx_ring_t *)&ill_dls[1]; ill->ill_dls_capab = ill_dls; ill_dls->ill_unbind_conn = connp; return (B_TRUE); } /* * ill_capability_dls_disable: disable soft_ring and/or polling * capability. Since any of the rings might already be in use, need * to call ipsq_clean_all() which gets behind the squeue to disable * direct calls if necessary. */ static void ill_capability_dls_disable(ill_t *ill) { ill_dls_capab_t *ill_dls = ill->ill_dls_capab; if (ill->ill_capabilities & ILL_CAPAB_DLS) { ipsq_clean_all(ill); ill_dls->ill_tx = NULL; ill_dls->ill_tx_handle = NULL; ill_dls->ill_dls_change_status = NULL; ill_dls->ill_dls_bind = NULL; ill_dls->ill_dls_unbind = NULL; } ASSERT(!(ill->ill_capabilities & ILL_CAPAB_DLS)); } static void ill_capability_dls_capable(ill_t *ill, dl_capab_dls_t *idls, dl_capability_sub_t *isub) { uint_t size; uchar_t *rptr; dl_capab_dls_t dls, *odls; ill_dls_capab_t *ill_dls; mblk_t *nmp = NULL; dl_capability_req_t *ocap; uint_t sub_dl_cap = isub->dl_cap; if (!ill_capability_dls_init(ill)) return; ill_dls = ill->ill_dls_capab; /* Copy locally to get the members aligned */ bcopy((void *)idls, (void *)&dls, sizeof (dl_capab_dls_t)); /* Get the tx function and handle from dld */ ill_dls->ill_tx = (ip_dld_tx_t)dls.dls_tx; ill_dls->ill_tx_handle = (void *)dls.dls_tx_handle; if (sub_dl_cap == DL_CAPAB_SOFT_RING) { ill_dls->ill_dls_change_status = (ip_dls_chg_soft_ring_t)dls.dls_ring_change_status; ill_dls->ill_dls_bind = (ip_dls_bind_t)dls.dls_ring_bind; ill_dls->ill_dls_unbind = (ip_dls_unbind_t)dls.dls_ring_unbind; ill_dls->ill_dls_soft_ring_cnt = ip_soft_rings_cnt; } size = sizeof (dl_capability_req_t) + sizeof (dl_capability_sub_t) + isub->dl_length; if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) { cmn_err(CE_WARN, "ill_capability_dls_capable: could " "not allocate memory for CAPAB_REQ for %s (%p)\n", ill->ill_name, (void *)ill); return; } /* initialize dl_capability_req_t */ rptr = nmp->b_rptr; ocap = (dl_capability_req_t *)rptr; ocap->dl_sub_offset = sizeof (dl_capability_req_t); ocap->dl_sub_length = sizeof (dl_capability_sub_t) + isub->dl_length; rptr += sizeof (dl_capability_req_t); /* initialize dl_capability_sub_t */ bcopy(isub, rptr, sizeof (*isub)); rptr += sizeof (*isub); odls = (dl_capab_dls_t *)rptr; rptr += sizeof (dl_capab_dls_t); /* initialize dl_capab_dls_t to be sent down */ dls.dls_rx_handle = (uintptr_t)ill; dls.dls_rx = (uintptr_t)ip_input; dls.dls_ring_add = (uintptr_t)ill_ring_add; if (sub_dl_cap == DL_CAPAB_SOFT_RING) { dls.dls_ring_cnt = ip_soft_rings_cnt; dls.dls_ring_assign = (uintptr_t)ip_soft_ring_assignment; dls.dls_flags = SOFT_RING_ENABLE; } else { dls.dls_flags = POLL_ENABLE; ip1dbg(("ill_capability_dls_capable: asking interface %s " "to enable polling\n", ill->ill_name)); } bcopy((void *)&dls, (void *)odls, sizeof (dl_capab_dls_t)); ASSERT(nmp->b_wptr == (nmp->b_rptr + size)); /* * nmp points to a DL_CAPABILITY_REQ message to * enable either soft_ring or polling */ ill_dlpi_send(ill, nmp); } static void ill_capability_dls_reset(ill_t *ill, mblk_t **sc_mp) { mblk_t *mp; dl_capab_dls_t *idls; dl_capability_sub_t *dl_subcap; int size; if (!(ill->ill_capabilities & ILL_CAPAB_DLS)) return; ASSERT(ill->ill_dls_capab != NULL); size = sizeof (*dl_subcap) + sizeof (*idls); mp = allocb(size, BPRI_HI); if (mp == NULL) { ip1dbg(("ill_capability_dls_reset: unable to allocate " "request to disable soft_ring\n")); return; } mp->b_wptr = mp->b_rptr + size; dl_subcap = (dl_capability_sub_t *)mp->b_rptr; dl_subcap->dl_length = sizeof (*idls); if (ill->ill_capabilities & ILL_CAPAB_SOFT_RING) dl_subcap->dl_cap = DL_CAPAB_SOFT_RING; else dl_subcap->dl_cap = DL_CAPAB_POLL; idls = (dl_capab_dls_t *)(dl_subcap + 1); if (ill->ill_capabilities & ILL_CAPAB_SOFT_RING) idls->dls_flags = SOFT_RING_DISABLE; else idls->dls_flags = POLL_DISABLE; if (*sc_mp != NULL) linkb(*sc_mp, mp); else *sc_mp = mp; } /* * Process a soft_ring/poll capability negotiation ack received * from a DLS Provider.isub must point to the sub-capability * (DL_CAPAB_SOFT_RING/DL_CAPAB_POLL) of a DL_CAPABILITY_ACK message. */ static void ill_capability_dls_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub) { dl_capab_dls_t *idls; uint_t sub_dl_cap = isub->dl_cap; uint8_t *capend; ASSERT(sub_dl_cap == DL_CAPAB_SOFT_RING || sub_dl_cap == DL_CAPAB_POLL); if (ill->ill_isv6) return; /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(isub + 1) + isub->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_dls_ack: " "malformed sub-capability too long for mblk"); return; } /* * There are two types of acks we process here: * 1. acks in reply to a (first form) generic capability req * (dls_flag will be set to SOFT_RING_CAPABLE or POLL_CAPABLE) * 2. acks in reply to a SOFT_RING_ENABLE or POLL_ENABLE * capability req. */ idls = (dl_capab_dls_t *)(isub + 1); if (!dlcapabcheckqid(&idls->dls_mid, ill->ill_lmod_rq)) { ip1dbg(("ill_capability_dls_ack: mid token for dls " "capability isn't as expected; pass-thru " "module(s) detected, discarding capability\n")); if (ill->ill_capabilities & ILL_CAPAB_DLS) { /* * This is a capability renegotitation case. * The interface better be unusable at this * point other wise bad things will happen * if we disable direct calls on a running * and up interface. */ ill_capability_dls_disable(ill); } return; } switch (idls->dls_flags) { default: /* Disable if unknown flag */ case SOFT_RING_DISABLE: case POLL_DISABLE: ill_capability_dls_disable(ill); break; case SOFT_RING_CAPABLE: case POLL_CAPABLE: /* * If the capability was already enabled, its safe * to disable it first to get rid of stale information * and then start enabling it again. */ ill_capability_dls_disable(ill); ill_capability_dls_capable(ill, idls, isub); break; case SOFT_RING_ENABLE: case POLL_ENABLE: mutex_enter(&ill->ill_lock); if (sub_dl_cap == DL_CAPAB_SOFT_RING && !(ill->ill_capabilities & ILL_CAPAB_SOFT_RING)) { ASSERT(ill->ill_dls_capab != NULL); ill->ill_capabilities |= ILL_CAPAB_SOFT_RING; } if (sub_dl_cap == DL_CAPAB_POLL && !(ill->ill_capabilities & ILL_CAPAB_POLL)) { ASSERT(ill->ill_dls_capab != NULL); ill->ill_capabilities |= ILL_CAPAB_POLL; ip1dbg(("ill_capability_dls_ack: interface %s " "has enabled polling\n", ill->ill_name)); } mutex_exit(&ill->ill_lock); break; } } /* * Process a hardware checksum offload capability negotiation ack received * from a DLS Provider.isub must point to the sub-capability (DL_CAPAB_HCKSUM) * of a DL_CAPABILITY_ACK message. */ static void ill_capability_hcksum_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub) { dl_capability_req_t *ocap; dl_capab_hcksum_t *ihck, *ohck; ill_hcksum_capab_t **ill_hcksum; mblk_t *nmp = NULL; uint_t sub_dl_cap = isub->dl_cap; uint8_t *capend; ASSERT(sub_dl_cap == DL_CAPAB_HCKSUM); ill_hcksum = (ill_hcksum_capab_t **)&ill->ill_hcksum_capab; /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(isub + 1) + isub->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_hcksum_ack: " "malformed sub-capability too long for mblk"); return; } /* * There are two types of acks we process here: * 1. acks in reply to a (first form) generic capability req * (no ENABLE flag set) * 2. acks in reply to a ENABLE capability req. * (ENABLE flag set) */ ihck = (dl_capab_hcksum_t *)(isub + 1); if (ihck->hcksum_version != HCKSUM_VERSION_1) { cmn_err(CE_CONT, "ill_capability_hcksum_ack: " "unsupported hardware checksum " "sub-capability (version %d, expected %d)", ihck->hcksum_version, HCKSUM_VERSION_1); return; } if (!dlcapabcheckqid(&ihck->hcksum_mid, ill->ill_lmod_rq)) { ip1dbg(("ill_capability_hcksum_ack: mid token for hardware " "checksum capability isn't as expected; pass-thru " "module(s) detected, discarding capability\n")); return; } #define CURR_HCKSUM_CAPAB \ (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 | \ HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM) if ((ihck->hcksum_txflags & HCKSUM_ENABLE) && (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB)) { /* do ENABLE processing */ if (*ill_hcksum == NULL) { *ill_hcksum = kmem_zalloc(sizeof (ill_hcksum_capab_t), KM_NOSLEEP); if (*ill_hcksum == NULL) { cmn_err(CE_WARN, "ill_capability_hcksum_ack: " "could not enable hcksum version %d " "for %s (ENOMEM)\n", HCKSUM_CURRENT_VERSION, ill->ill_name); return; } } (*ill_hcksum)->ill_hcksum_version = ihck->hcksum_version; (*ill_hcksum)->ill_hcksum_txflags = ihck->hcksum_txflags; ill->ill_capabilities |= ILL_CAPAB_HCKSUM; ip1dbg(("ill_capability_hcksum_ack: interface %s " "has enabled hardware checksumming\n ", ill->ill_name)); } else if (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB) { /* * Enabling hardware checksum offload * Currently IP supports {TCP,UDP}/IPv4 * partial and full cksum offload and * IPv4 header checksum offload. * Allocate new mblk which will * contain a new capability request * to enable hardware checksum offload. */ uint_t size; uchar_t *rptr; size = sizeof (dl_capability_req_t) + sizeof (dl_capability_sub_t) + isub->dl_length; if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) { cmn_err(CE_WARN, "ill_capability_hcksum_ack: " "could not enable hardware cksum for %s (ENOMEM)\n", ill->ill_name); return; } rptr = nmp->b_rptr; /* initialize dl_capability_req_t */ ocap = (dl_capability_req_t *)nmp->b_rptr; ocap->dl_sub_offset = sizeof (dl_capability_req_t); ocap->dl_sub_length = sizeof (dl_capability_sub_t) + isub->dl_length; nmp->b_rptr += sizeof (dl_capability_req_t); /* initialize dl_capability_sub_t */ bcopy(isub, nmp->b_rptr, sizeof (*isub)); nmp->b_rptr += sizeof (*isub); /* initialize dl_capab_hcksum_t */ ohck = (dl_capab_hcksum_t *)nmp->b_rptr; bcopy(ihck, ohck, sizeof (*ihck)); nmp->b_rptr = rptr; ASSERT(nmp->b_wptr == (nmp->b_rptr + size)); /* Set ENABLE flag */ ohck->hcksum_txflags &= CURR_HCKSUM_CAPAB; ohck->hcksum_txflags |= HCKSUM_ENABLE; /* * nmp points to a DL_CAPABILITY_REQ message to enable * hardware checksum acceleration. */ ill_dlpi_send(ill, nmp); } else { ip1dbg(("ill_capability_hcksum_ack: interface %s has " "advertised %x hardware checksum capability flags\n", ill->ill_name, ihck->hcksum_txflags)); } } static void ill_capability_hcksum_reset(ill_t *ill, mblk_t **sc_mp) { mblk_t *mp; dl_capab_hcksum_t *hck_subcap; dl_capability_sub_t *dl_subcap; int size; if (!ILL_HCKSUM_CAPABLE(ill)) return; ASSERT(ill->ill_hcksum_capab != NULL); /* * Clear the capability flag for hardware checksum offload but * retain the ill_hcksum_capab structure since it's possible that * another thread is still referring to it. The structure only * gets deallocated when we destroy the ill. */ ill->ill_capabilities &= ~ILL_CAPAB_HCKSUM; size = sizeof (*dl_subcap) + sizeof (*hck_subcap); mp = allocb(size, BPRI_HI); if (mp == NULL) { ip1dbg(("ill_capability_hcksum_reset: unable to allocate " "request to disable hardware checksum offload\n")); return; } mp->b_wptr = mp->b_rptr + size; dl_subcap = (dl_capability_sub_t *)mp->b_rptr; dl_subcap->dl_cap = DL_CAPAB_HCKSUM; dl_subcap->dl_length = sizeof (*hck_subcap); hck_subcap = (dl_capab_hcksum_t *)(dl_subcap + 1); hck_subcap->hcksum_version = ill->ill_hcksum_capab->ill_hcksum_version; hck_subcap->hcksum_txflags = 0; if (*sc_mp != NULL) linkb(*sc_mp, mp); else *sc_mp = mp; } static void ill_capability_zerocopy_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub) { mblk_t *nmp = NULL; dl_capability_req_t *oc; dl_capab_zerocopy_t *zc_ic, *zc_oc; ill_zerocopy_capab_t **ill_zerocopy_capab; uint_t sub_dl_cap = isub->dl_cap; uint8_t *capend; ASSERT(sub_dl_cap == DL_CAPAB_ZEROCOPY); ill_zerocopy_capab = (ill_zerocopy_capab_t **)&ill->ill_zerocopy_capab; /* * Note: range checks here are not absolutely sufficient to * make us robust against malformed messages sent by drivers; * this is in keeping with the rest of IP's dlpi handling. * (Remember, it's coming from something else in the kernel * address space) */ capend = (uint8_t *)(isub + 1) + isub->dl_length; if (capend > mp->b_wptr) { cmn_err(CE_WARN, "ill_capability_zerocopy_ack: " "malformed sub-capability too long for mblk"); return; } zc_ic = (dl_capab_zerocopy_t *)(isub + 1); if (zc_ic->zerocopy_version != ZEROCOPY_VERSION_1) { cmn_err(CE_CONT, "ill_capability_zerocopy_ack: " "unsupported ZEROCOPY sub-capability (version %d, " "expected %d)", zc_ic->zerocopy_version, ZEROCOPY_VERSION_1); return; } if (!dlcapabcheckqid(&zc_ic->zerocopy_mid, ill->ill_lmod_rq)) { ip1dbg(("ill_capability_zerocopy_ack: mid token for zerocopy " "capability isn't as expected; pass-thru module(s) " "detected, discarding capability\n")); return; } if ((zc_ic->zerocopy_flags & DL_CAPAB_VMSAFE_MEM) != 0) { if (*ill_zerocopy_capab == NULL) { *ill_zerocopy_capab = kmem_zalloc(sizeof (ill_zerocopy_capab_t), KM_NOSLEEP); if (*ill_zerocopy_capab == NULL) { cmn_err(CE_WARN, "ill_capability_zerocopy_ack: " "could not enable Zero-copy version %d " "for %s (ENOMEM)\n", ZEROCOPY_VERSION_1, ill->ill_name); return; } } ip1dbg(("ill_capability_zerocopy_ack: interface %s " "supports Zero-copy version %d\n", ill->ill_name, ZEROCOPY_VERSION_1)); (*ill_zerocopy_capab)->ill_zerocopy_version = zc_ic->zerocopy_version; (*ill_zerocopy_capab)->ill_zerocopy_flags = zc_ic->zerocopy_flags; ill->ill_capabilities |= ILL_CAPAB_ZEROCOPY; } else { uint_t size; uchar_t *rptr; size = sizeof (dl_capability_req_t) + sizeof (dl_capability_sub_t) + sizeof (dl_capab_zerocopy_t); if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) { cmn_err(CE_WARN, "ill_capability_zerocopy_ack: " "could not enable zerocopy for %s (ENOMEM)\n", ill->ill_name); return; } rptr = nmp->b_rptr; /* initialize dl_capability_req_t */ oc = (dl_capability_req_t *)rptr; oc->dl_sub_offset = sizeof (dl_capability_req_t); oc->dl_sub_length = sizeof (dl_capability_sub_t) + sizeof (dl_capab_zerocopy_t); rptr += sizeof (dl_capability_req_t); /* initialize dl_capability_sub_t */ bcopy(isub, rptr, sizeof (*isub)); rptr += sizeof (*isub); /* initialize dl_capab_zerocopy_t */ zc_oc = (dl_capab_zerocopy_t *)rptr; *zc_oc = *zc_ic; ip1dbg(("ill_capability_zerocopy_ack: asking interface %s " "to enable zero-copy version %d\n", ill->ill_name, ZEROCOPY_VERSION_1)); /* set VMSAFE_MEM flag */ zc_oc->zerocopy_flags |= DL_CAPAB_VMSAFE_MEM; /* nmp points to a DL_CAPABILITY_REQ message to enable zcopy */ ill_dlpi_send(ill, nmp); } } static void ill_capability_zerocopy_reset(ill_t *ill, mblk_t **sc_mp) { mblk_t *mp; dl_capab_zerocopy_t *zerocopy_subcap; dl_capability_sub_t *dl_subcap; int size; if (!(ill->ill_capabilities & ILL_CAPAB_ZEROCOPY)) return; ASSERT(ill->ill_zerocopy_capab != NULL); /* * Clear the capability flag for Zero-copy but retain the * ill_zerocopy_capab structure since it's possible that another * thread is still referring to it. The structure only gets * deallocated when we destroy the ill. */ ill->ill_capabilities &= ~ILL_CAPAB_ZEROCOPY; size = sizeof (*dl_subcap) + sizeof (*zerocopy_subcap); mp = allocb(size, BPRI_HI); if (mp == NULL) { ip1dbg(("ill_capability_zerocopy_reset: unable to allocate " "request to disable Zero-copy\n")); return; } mp->b_wptr = mp->b_rptr + size; dl_subcap = (dl_capability_sub_t *)mp->b_rptr; dl_subcap->dl_cap = DL_CAPAB_ZEROCOPY; dl_subcap->dl_length = sizeof (*zerocopy_subcap); zerocopy_subcap = (dl_capab_zerocopy_t *)(dl_subcap + 1); zerocopy_subcap->zerocopy_version = ill->ill_zerocopy_capab->ill_zerocopy_version; zerocopy_subcap->zerocopy_flags = 0; if (*sc_mp != NULL) linkb(*sc_mp, mp); else *sc_mp = mp; } /* * Consume a new-style hardware capabilities negotiation ack. * Called from ip_rput_dlpi_writer(). */ void ill_capability_ack(ill_t *ill, mblk_t *mp) { dl_capability_ack_t *capp; dl_capability_sub_t *subp, *endp; if (ill->ill_capab_state == IDMS_INPROGRESS) ill->ill_capab_state = IDMS_OK; capp = (dl_capability_ack_t *)mp->b_rptr; if (capp->dl_sub_length == 0) /* no new-style capabilities */ return; /* make sure the driver supplied correct dl_sub_length */ if ((sizeof (*capp) + capp->dl_sub_length) > MBLKL(mp)) { ip0dbg(("ill_capability_ack: bad DL_CAPABILITY_ACK, " "invalid dl_sub_length (%d)\n", capp->dl_sub_length)); return; } #define SC(base, offset) (dl_capability_sub_t *)(((uchar_t *)(base))+(offset)) /* * There are sub-capabilities. Process the ones we know about. * Loop until we don't have room for another sub-cap header.. */ for (subp = SC(capp, capp->dl_sub_offset), endp = SC(subp, capp->dl_sub_length - sizeof (*subp)); subp <= endp; subp = SC(subp, sizeof (dl_capability_sub_t) + subp->dl_length)) { switch (subp->dl_cap) { case DL_CAPAB_ID_WRAPPER: ill_capability_id_ack(ill, mp, subp); break; default: ill_capability_dispatch(ill, mp, subp, B_FALSE); break; } } #undef SC } /* * This routine is called to scan the fragmentation reassembly table for * the specified ILL for any packets that are starting to smell. * dead_interval is the maximum time in seconds that will be tolerated. It * will either be the value specified in ip_g_frag_timeout, or zero if the * ILL is shutting down and it is time to blow everything off. * * It returns the number of seconds (as a time_t) that the next frag timer * should be scheduled for, 0 meaning that the timer doesn't need to be * re-started. Note that the method of calculating next_timeout isn't * entirely accurate since time will flow between the time we grab * current_time and the time we schedule the next timeout. This isn't a * big problem since this is the timer for sending an ICMP reassembly time * exceeded messages, and it doesn't have to be exactly accurate. * * This function is * sometimes called as writer, although this is not required. */ time_t ill_frag_timeout(ill_t *ill, time_t dead_interval) { ipfb_t *ipfb; ipfb_t *endp; ipf_t *ipf; ipf_t *ipfnext; mblk_t *mp; time_t current_time = gethrestime_sec(); time_t next_timeout = 0; uint32_t hdr_length; mblk_t *send_icmp_head; mblk_t *send_icmp_head_v6; ipfb = ill->ill_frag_hash_tbl; if (ipfb == NULL) return (B_FALSE); endp = &ipfb[ILL_FRAG_HASH_TBL_COUNT]; /* Walk the frag hash table. */ for (; ipfb < endp; ipfb++) { send_icmp_head = NULL; send_icmp_head_v6 = NULL; mutex_enter(&ipfb->ipfb_lock); while ((ipf = ipfb->ipfb_ipf) != 0) { time_t frag_time = current_time - ipf->ipf_timestamp; time_t frag_timeout; if (frag_time < dead_interval) { /* * There are some outstanding fragments * that will timeout later. Make note of * the time so that we can reschedule the * next timeout appropriately. */ frag_timeout = dead_interval - frag_time; if (next_timeout == 0 || frag_timeout < next_timeout) { next_timeout = frag_timeout; } break; } /* Time's up. Get it out of here. */ hdr_length = ipf->ipf_nf_hdr_len; ipfnext = ipf->ipf_hash_next; if (ipfnext) ipfnext->ipf_ptphn = ipf->ipf_ptphn; *ipf->ipf_ptphn = ipfnext; mp = ipf->ipf_mp->b_cont; for (; mp; mp = mp->b_cont) { /* Extra points for neatness. */ IP_REASS_SET_START(mp, 0); IP_REASS_SET_END(mp, 0); } mp = ipf->ipf_mp->b_cont; ill->ill_frag_count -= ipf->ipf_count; ASSERT(ipfb->ipfb_count >= ipf->ipf_count); ipfb->ipfb_count -= ipf->ipf_count; ASSERT(ipfb->ipfb_frag_pkts > 0); ipfb->ipfb_frag_pkts--; /* * We do not send any icmp message from here because * we currently are holding the ipfb_lock for this * hash chain. If we try and send any icmp messages * from here we may end up via a put back into ip * trying to get the same lock, causing a recursive * mutex panic. Instead we build a list and send all * the icmp messages after we have dropped the lock. */ if (ill->ill_isv6) { BUMP_MIB(ill->ill_ip6_mib, ipv6ReasmFails); if (hdr_length != 0) { mp->b_next = send_icmp_head_v6; send_icmp_head_v6 = mp; } else { freemsg(mp); } } else { BUMP_MIB(&ip_mib, ipReasmFails); if (hdr_length != 0) { mp->b_next = send_icmp_head; send_icmp_head = mp; } else { freemsg(mp); } } freeb(ipf->ipf_mp); } mutex_exit(&ipfb->ipfb_lock); /* * Now need to send any icmp messages that we delayed from * above. */ while (send_icmp_head_v6 != NULL) { mp = send_icmp_head_v6; send_icmp_head_v6 = send_icmp_head_v6->b_next; mp->b_next = NULL; icmp_time_exceeded_v6(ill->ill_wq, mp, ICMP_REASSEMBLY_TIME_EXCEEDED, B_FALSE, B_FALSE); } while (send_icmp_head != NULL) { mp = send_icmp_head; send_icmp_head = send_icmp_head->b_next; mp->b_next = NULL; icmp_time_exceeded(ill->ill_wq, mp, ICMP_REASSEMBLY_TIME_EXCEEDED); } } /* * A non-dying ILL will use the return value to decide whether to * restart the frag timer, and for how long. */ return (next_timeout); } /* * This routine is called when the approximate count of mblk memory used * for the specified ILL has exceeded max_count. */ void ill_frag_prune(ill_t *ill, uint_t max_count) { ipfb_t *ipfb; ipf_t *ipf; size_t count; /* * If we are here within ip_min_frag_prune_time msecs remove * ill_frag_free_num_pkts oldest packets from each bucket and increment * ill_frag_free_num_pkts. */ mutex_enter(&ill->ill_lock); if (TICK_TO_MSEC(lbolt - ill->ill_last_frag_clean_time) <= (ip_min_frag_prune_time != 0 ? ip_min_frag_prune_time : msec_per_tick)) { ill->ill_frag_free_num_pkts++; } else { ill->ill_frag_free_num_pkts = 0; } ill->ill_last_frag_clean_time = lbolt; mutex_exit(&ill->ill_lock); /* * free ill_frag_free_num_pkts oldest packets from each bucket. */ if (ill->ill_frag_free_num_pkts != 0) { int ix; for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) { ipfb = &ill->ill_frag_hash_tbl[ix]; mutex_enter(&ipfb->ipfb_lock); if (ipfb->ipfb_ipf != NULL) { ill_frag_free_pkts(ill, ipfb, ipfb->ipfb_ipf, ill->ill_frag_free_num_pkts); } mutex_exit(&ipfb->ipfb_lock); } } /* * While the reassembly list for this ILL is too big, prune a fragment * queue by age, oldest first. Note that the per ILL count is * approximate, while the per frag hash bucket counts are accurate. */ while (ill->ill_frag_count > max_count) { int ix; ipfb_t *oipfb = NULL; uint_t oldest = UINT_MAX; count = 0; for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) { ipfb = &ill->ill_frag_hash_tbl[ix]; mutex_enter(&ipfb->ipfb_lock); ipf = ipfb->ipfb_ipf; if (ipf != NULL && ipf->ipf_gen < oldest) { oldest = ipf->ipf_gen; oipfb = ipfb; } count += ipfb->ipfb_count; mutex_exit(&ipfb->ipfb_lock); } /* Refresh the per ILL count */ ill->ill_frag_count = count; if (oipfb == NULL) { ill->ill_frag_count = 0; break; } if (count <= max_count) return; /* Somebody beat us to it, nothing to do */ mutex_enter(&oipfb->ipfb_lock); ipf = oipfb->ipfb_ipf; if (ipf != NULL) { ill_frag_free_pkts(ill, oipfb, ipf, 1); } mutex_exit(&oipfb->ipfb_lock); } } /* * free 'free_cnt' fragmented packets starting at ipf. */ void ill_frag_free_pkts(ill_t *ill, ipfb_t *ipfb, ipf_t *ipf, int free_cnt) { size_t count; mblk_t *mp; mblk_t *tmp; ipf_t **ipfp = ipf->ipf_ptphn; ASSERT(MUTEX_HELD(&ipfb->ipfb_lock)); ASSERT(ipfp != NULL); ASSERT(ipf != NULL); while (ipf != NULL && free_cnt-- > 0) { count = ipf->ipf_count; mp = ipf->ipf_mp; ipf = ipf->ipf_hash_next; for (tmp = mp; tmp; tmp = tmp->b_cont) { IP_REASS_SET_START(tmp, 0); IP_REASS_SET_END(tmp, 0); } ill->ill_frag_count -= count; ASSERT(ipfb->ipfb_count >= count); ipfb->ipfb_count -= count; ASSERT(ipfb->ipfb_frag_pkts > 0); ipfb->ipfb_frag_pkts--; freemsg(mp); BUMP_MIB(&ip_mib, ipReasmFails); } if (ipf) ipf->ipf_ptphn = ipfp; ipfp[0] = ipf; } #define ND_FORWARD_WARNING "The :ip*_forwarding ndd variables are " \ "obsolete and may be removed in a future release of Solaris. Use " \ "ifconfig(1M) to manipulate the forwarding status of an interface." /* * For obsolete per-interface forwarding configuration; * called in response to ND_GET. */ /* ARGSUSED */ static int nd_ill_forward_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *ioc_cr) { ill_t *ill = (ill_t *)cp; cmn_err(CE_WARN, ND_FORWARD_WARNING); (void) mi_mpprintf(mp, "%d", (ill->ill_flags & ILLF_ROUTER) != 0); return (0); } /* * For obsolete per-interface forwarding configuration; * called in response to ND_SET. */ /* ARGSUSED */ static int nd_ill_forward_set(queue_t *q, mblk_t *mp, char *valuestr, caddr_t cp, cred_t *ioc_cr) { long value; int retval; cmn_err(CE_WARN, ND_FORWARD_WARNING); if (ddi_strtol(valuestr, NULL, 10, &value) != 0 || value < 0 || value > 1) { return (EINVAL); } rw_enter(&ill_g_lock, RW_READER); retval = ill_forward_set(q, mp, (value != 0), cp); rw_exit(&ill_g_lock); return (retval); } /* * Set an ill's ILLF_ROUTER flag appropriately. If the ill is part of an * IPMP group, make sure all ill's in the group adopt the new policy. Send * up RTS_IFINFO routing socket messages for each interface whose flags we * change. */ /* ARGSUSED */ int ill_forward_set(queue_t *q, mblk_t *mp, boolean_t enable, caddr_t cp) { ill_t *ill = (ill_t *)cp; ill_group_t *illgrp; ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ill_g_lock)); if ((enable && (ill->ill_flags & ILLF_ROUTER)) || (!enable && !(ill->ill_flags & ILLF_ROUTER)) || (ill->ill_phyint->phyint_flags & PHYI_LOOPBACK)) return (EINVAL); /* * If the ill is in an IPMP group, set the forwarding policy on all * members of the group to the same value. */ illgrp = ill->ill_group; if (illgrp != NULL) { ill_t *tmp_ill; for (tmp_ill = illgrp->illgrp_ill; tmp_ill != NULL; tmp_ill = tmp_ill->ill_group_next) { ip1dbg(("ill_forward_set: %s %s forwarding on %s", (enable ? "Enabling" : "Disabling"), (tmp_ill->ill_isv6 ? "IPv6" : "IPv4"), tmp_ill->ill_name)); mutex_enter(&tmp_ill->ill_lock); if (enable) tmp_ill->ill_flags |= ILLF_ROUTER; else tmp_ill->ill_flags &= ~ILLF_ROUTER; mutex_exit(&tmp_ill->ill_lock); if (tmp_ill->ill_isv6) ill_set_nce_router_flags(tmp_ill, enable); /* Notify routing socket listeners of this change. */ ip_rts_ifmsg(tmp_ill->ill_ipif); } } else { ip1dbg(("ill_forward_set: %s %s forwarding on %s", (enable ? "Enabling" : "Disabling"), (ill->ill_isv6 ? "IPv6" : "IPv4"), ill->ill_name)); mutex_enter(&ill->ill_lock); if (enable) ill->ill_flags |= ILLF_ROUTER; else ill->ill_flags &= ~ILLF_ROUTER; mutex_exit(&ill->ill_lock); if (ill->ill_isv6) ill_set_nce_router_flags(ill, enable); /* Notify routing socket listeners of this change. */ ip_rts_ifmsg(ill->ill_ipif); } return (0); } /* * Based on the ILLF_ROUTER flag of an ill, make sure all local nce's for * addresses assigned to the ill have the NCE_F_ISROUTER flag appropriately * set or clear. */ static void ill_set_nce_router_flags(ill_t *ill, boolean_t enable) { ipif_t *ipif; nce_t *nce; for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { nce = ndp_lookup(ill, &ipif->ipif_v6lcl_addr, B_FALSE); if (nce != NULL) { mutex_enter(&nce->nce_lock); if (enable) nce->nce_flags |= NCE_F_ISROUTER; else nce->nce_flags &= ~NCE_F_ISROUTER; mutex_exit(&nce->nce_lock); NCE_REFRELE(nce); } } } /* * Given an ill with a _valid_ name, add the ip_forwarding ndd variable * for this ill. Make sure the v6/v4 question has been answered about this * ill. The creation of this ndd variable is only for backwards compatibility. * The preferred way to control per-interface IP forwarding is through the * ILLF_ROUTER interface flag. */ static int ill_set_ndd_name(ill_t *ill) { char *suffix; ASSERT(IAM_WRITER_ILL(ill)); if (ill->ill_isv6) suffix = ipv6_forward_suffix; else suffix = ipv4_forward_suffix; ill->ill_ndd_name = ill->ill_name + ill->ill_name_length; bcopy(ill->ill_name, ill->ill_ndd_name, ill->ill_name_length - 1); /* * Copies over the '\0'. * Note that strlen(suffix) is always bounded. */ bcopy(suffix, ill->ill_ndd_name + ill->ill_name_length - 1, strlen(suffix) + 1); /* * Use of the nd table requires holding the reader lock. * Modifying the nd table thru nd_load/nd_unload requires * the writer lock. */ rw_enter(&ip_g_nd_lock, RW_WRITER); if (!nd_load(&ip_g_nd, ill->ill_ndd_name, nd_ill_forward_get, nd_ill_forward_set, (caddr_t)ill)) { /* * If the nd_load failed, it only meant that it could not * allocate a new bunch of room for further NDD expansion. * Because of that, the ill_ndd_name will be set to 0, and * this interface is at the mercy of the global ip_forwarding * variable. */ rw_exit(&ip_g_nd_lock); ill->ill_ndd_name = NULL; return (ENOMEM); } rw_exit(&ip_g_nd_lock); return (0); } /* * Intializes the context structure and returns the first ill in the list * cuurently start_list and end_list can have values: * MAX_G_HEADS Traverse both IPV4 and IPV6 lists. * IP_V4_G_HEAD Traverse IPV4 list only. * IP_V6_G_HEAD Traverse IPV6 list only. */ /* * We don't check for CONDEMNED ills here. Caller must do that if * necessary under the ill lock. */ ill_t * ill_first(int start_list, int end_list, ill_walk_context_t *ctx) { ill_if_t *ifp; ill_t *ill; avl_tree_t *avl_tree; ASSERT(RW_LOCK_HELD(&ill_g_lock)); ASSERT(end_list <= MAX_G_HEADS && start_list >= 0); /* * setup the lists to search */ if (end_list != MAX_G_HEADS) { ctx->ctx_current_list = start_list; ctx->ctx_last_list = end_list; } else { ctx->ctx_last_list = MAX_G_HEADS - 1; ctx->ctx_current_list = 0; } while (ctx->ctx_current_list <= ctx->ctx_last_list) { ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list); if (ifp != (ill_if_t *) &IP_VX_ILL_G_LIST(ctx->ctx_current_list)) { avl_tree = &ifp->illif_avl_by_ppa; ill = avl_first(avl_tree); /* * ill is guaranteed to be non NULL or ifp should have * not existed. */ ASSERT(ill != NULL); return (ill); } ctx->ctx_current_list++; } return (NULL); } /* * returns the next ill in the list. ill_first() must have been called * before calling ill_next() or bad things will happen. */ /* * We don't check for CONDEMNED ills here. Caller must do that if * necessary under the ill lock. */ ill_t * ill_next(ill_walk_context_t *ctx, ill_t *lastill) { ill_if_t *ifp; ill_t *ill; ASSERT(RW_LOCK_HELD(&ill_g_lock)); ASSERT(lastill->ill_ifptr != (ill_if_t *) &IP_VX_ILL_G_LIST(ctx->ctx_current_list)); if ((ill = avl_walk(&lastill->ill_ifptr->illif_avl_by_ppa, lastill, AVL_AFTER)) != NULL) { return (ill); } /* goto next ill_ifp in the list. */ ifp = lastill->ill_ifptr->illif_next; /* make sure not at end of circular list */ while (ifp == (ill_if_t *)&IP_VX_ILL_G_LIST(ctx->ctx_current_list)) { if (++ctx->ctx_current_list > ctx->ctx_last_list) return (NULL); ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list); } return (avl_first(&ifp->illif_avl_by_ppa)); } /* * Check interface name for correct format which is name+ppa. * name can contain characters and digits, the right most digits * make up the ppa number. use of octal is not allowed, name must contain * a ppa, return pointer to the start of ppa. * In case of error return NULL. */ static char * ill_get_ppa_ptr(char *name) { int namelen = mi_strlen(name); int len = namelen; name += len; while (len > 0) { name--; if (*name < '0' || *name > '9') break; len--; } /* empty string, all digits, or no trailing digits */ if (len == 0 || len == (int)namelen) return (NULL); name++; /* check for attempted use of octal */ if (*name == '0' && len != (int)namelen - 1) return (NULL); return (name); } /* * use avl tree to locate the ill. */ static ill_t * ill_find_by_name(char *name, boolean_t isv6, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error) { char *ppa_ptr = NULL; int len; uint_t ppa; ill_t *ill = NULL; ill_if_t *ifp; int list; ipsq_t *ipsq; if (error != NULL) *error = 0; /* * get ppa ptr */ if (isv6) list = IP_V6_G_HEAD; else list = IP_V4_G_HEAD; if ((ppa_ptr = ill_get_ppa_ptr(name)) == NULL) { if (error != NULL) *error = ENXIO; return (NULL); } len = ppa_ptr - name + 1; ppa = stoi(&ppa_ptr); ifp = IP_VX_ILL_G_LIST(list); while (ifp != (ill_if_t *)&IP_VX_ILL_G_LIST(list)) { /* * match is done on len - 1 as the name is not null * terminated it contains ppa in addition to the interface * name. */ if ((ifp->illif_name_len == len) && bcmp(ifp->illif_name, name, len - 1) == 0) { break; } else { ifp = ifp->illif_next; } } if (ifp == (ill_if_t *)&IP_VX_ILL_G_LIST(list)) { /* * Even the interface type does not exist. */ if (error != NULL) *error = ENXIO; return (NULL); } ill = avl_find(&ifp->illif_avl_by_ppa, (void *) &ppa, NULL); if (ill != NULL) { /* * The block comment at the start of ipif_down * explains the use of the macros used below */ GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); if (ILL_CAN_LOOKUP(ill)) { ill_refhold_locked(ill); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); return (ill); } else if (ILL_CAN_WAIT(ill, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); *error = EINPROGRESS; return (NULL); } mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); } if (error != NULL) *error = ENXIO; return (NULL); } /* * comparison function for use with avl. */ static int ill_compare_ppa(const void *ppa_ptr, const void *ill_ptr) { uint_t ppa; uint_t ill_ppa; ASSERT(ppa_ptr != NULL && ill_ptr != NULL); ppa = *((uint_t *)ppa_ptr); ill_ppa = ((const ill_t *)ill_ptr)->ill_ppa; /* * We want the ill with the lowest ppa to be on the * top. */ if (ill_ppa < ppa) return (1); if (ill_ppa > ppa) return (-1); return (0); } /* * remove an interface type from the global list. */ static void ill_delete_interface_type(ill_if_t *interface) { ASSERT(RW_WRITE_HELD(&ill_g_lock)); ASSERT(interface != NULL); ASSERT(avl_numnodes(&interface->illif_avl_by_ppa) == 0); avl_destroy(&interface->illif_avl_by_ppa); if (interface->illif_ppa_arena != NULL) vmem_destroy(interface->illif_ppa_arena); remque(interface); mi_free(interface); } /* * remove ill from the global list. */ static void ill_glist_delete(ill_t *ill) { if (ill == NULL) return; rw_enter(&ill_g_lock, RW_WRITER); /* * If the ill was never inserted into the AVL tree * we skip the if branch. */ if (ill->ill_ifptr != NULL) { /* * remove from AVL tree and free ppa number */ avl_remove(&ill->ill_ifptr->illif_avl_by_ppa, ill); if (ill->ill_ifptr->illif_ppa_arena != NULL) { vmem_free(ill->ill_ifptr->illif_ppa_arena, (void *)(uintptr_t)(ill->ill_ppa+1), 1); } if (avl_numnodes(&ill->ill_ifptr->illif_avl_by_ppa) == 0) { ill_delete_interface_type(ill->ill_ifptr); } /* * Indicate ill is no longer in the list. */ ill->ill_ifptr = NULL; ill->ill_name_length = 0; ill->ill_name[0] = '\0'; ill->ill_ppa = UINT_MAX; } ill_phyint_free(ill); rw_exit(&ill_g_lock); } /* * allocate a ppa, if the number of plumbed interfaces of this type are * less than ill_no_arena do a linear search to find a unused ppa. * When the number goes beyond ill_no_arena switch to using an arena. * Note: ppa value of zero cannot be allocated from vmem_arena as it * is the return value for an error condition, so allocation starts at one * and is decremented by one. */ static int ill_alloc_ppa(ill_if_t *ifp, ill_t *ill) { ill_t *tmp_ill; uint_t start, end; int ppa; if (ifp->illif_ppa_arena == NULL && (avl_numnodes(&ifp->illif_avl_by_ppa) + 1 > ill_no_arena)) { /* * Create an arena. */ ifp->illif_ppa_arena = vmem_create(ifp->illif_name, (void *)1, UINT_MAX - 1, 1, NULL, NULL, NULL, 0, VM_SLEEP | VMC_IDENTIFIER); /* allocate what has already been assigned */ for (tmp_ill = avl_first(&ifp->illif_avl_by_ppa); tmp_ill != NULL; tmp_ill = avl_walk(&ifp->illif_avl_by_ppa, tmp_ill, AVL_AFTER)) { ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena, 1, /* size */ 1, /* align/quantum */ 0, /* phase */ 0, /* nocross */ (void *)((uintptr_t)tmp_ill->ill_ppa + 1), /* minaddr */ (void *)((uintptr_t)tmp_ill->ill_ppa + 2), /* maxaddr */ VM_NOSLEEP|VM_FIRSTFIT); if (ppa == 0) { ip1dbg(("ill_alloc_ppa: ppa allocation" " failed while switching")); vmem_destroy(ifp->illif_ppa_arena); ifp->illif_ppa_arena = NULL; break; } } } if (ifp->illif_ppa_arena != NULL) { if (ill->ill_ppa == UINT_MAX) { ppa = (int)(uintptr_t)vmem_alloc(ifp->illif_ppa_arena, 1, VM_NOSLEEP|VM_FIRSTFIT); if (ppa == 0) return (EAGAIN); ill->ill_ppa = --ppa; } else { ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena, 1, /* size */ 1, /* align/quantum */ 0, /* phase */ 0, /* nocross */ (void *)(uintptr_t)(ill->ill_ppa + 1), /* minaddr */ (void *)(uintptr_t)(ill->ill_ppa + 2), /* maxaddr */ VM_NOSLEEP|VM_FIRSTFIT); /* * Most likely the allocation failed because * the requested ppa was in use. */ if (ppa == 0) return (EEXIST); } return (0); } /* * No arena is in use and not enough (>ill_no_arena) interfaces have * been plumbed to create one. Do a linear search to get a unused ppa. */ if (ill->ill_ppa == UINT_MAX) { end = UINT_MAX - 1; start = 0; } else { end = start = ill->ill_ppa; } tmp_ill = avl_find(&ifp->illif_avl_by_ppa, (void *)&start, NULL); while (tmp_ill != NULL && tmp_ill->ill_ppa == start) { if (start++ >= end) { if (ill->ill_ppa == UINT_MAX) return (EAGAIN); else return (EEXIST); } tmp_ill = avl_walk(&ifp->illif_avl_by_ppa, tmp_ill, AVL_AFTER); } ill->ill_ppa = start; return (0); } /* * Insert ill into the list of configured ill's. Once this function completes, * the ill is globally visible and is available through lookups. More precisely * this happens after the caller drops the ill_g_lock. */ static int ill_glist_insert(ill_t *ill, char *name, boolean_t isv6) { ill_if_t *ill_interface; avl_index_t where = 0; int error; int name_length; int index; boolean_t check_length = B_FALSE; ASSERT(RW_WRITE_HELD(&ill_g_lock)); name_length = mi_strlen(name) + 1; if (isv6) index = IP_V6_G_HEAD; else index = IP_V4_G_HEAD; ill_interface = IP_VX_ILL_G_LIST(index); /* * Search for interface type based on name */ while (ill_interface != (ill_if_t *)&IP_VX_ILL_G_LIST(index)) { if ((ill_interface->illif_name_len == name_length) && (strcmp(ill_interface->illif_name, name) == 0)) { break; } ill_interface = ill_interface->illif_next; } /* * Interface type not found, create one. */ if (ill_interface == (ill_if_t *)&IP_VX_ILL_G_LIST(index)) { ill_g_head_t ghead; /* * allocate ill_if_t structure */ ill_interface = (ill_if_t *)mi_zalloc(sizeof (ill_if_t)); if (ill_interface == NULL) { return (ENOMEM); } (void) strcpy(ill_interface->illif_name, name); ill_interface->illif_name_len = name_length; avl_create(&ill_interface->illif_avl_by_ppa, ill_compare_ppa, sizeof (ill_t), offsetof(struct ill_s, ill_avl_byppa)); /* * link the structure in the back to maintain order * of configuration for ifconfig output. */ ghead = ill_g_heads[index]; insque(ill_interface, ghead.ill_g_list_tail); } if (ill->ill_ppa == UINT_MAX) check_length = B_TRUE; error = ill_alloc_ppa(ill_interface, ill); if (error != 0) { if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0) ill_delete_interface_type(ill->ill_ifptr); return (error); } /* * When the ppa is choosen by the system, check that there is * enough space to insert ppa. if a specific ppa was passed in this * check is not required as the interface name passed in will have * the right ppa in it. */ if (check_length) { /* * UINT_MAX - 1 should fit in 10 chars, alloc 12 chars. */ char buf[sizeof (uint_t) * 3]; /* * convert ppa to string to calculate the amount of space * required for it in the name. */ numtos(ill->ill_ppa, buf); /* Do we have enough space to insert ppa ? */ if ((mi_strlen(name) + mi_strlen(buf) + 1) > LIFNAMSIZ) { /* Free ppa and interface type struct */ if (ill_interface->illif_ppa_arena != NULL) { vmem_free(ill_interface->illif_ppa_arena, (void *)(uintptr_t)(ill->ill_ppa+1), 1); } if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0) { ill_delete_interface_type(ill->ill_ifptr); } return (EINVAL); } } (void) sprintf(ill->ill_name, "%s%u", name, ill->ill_ppa); ill->ill_name_length = mi_strlen(ill->ill_name) + 1; (void) avl_find(&ill_interface->illif_avl_by_ppa, &ill->ill_ppa, &where); ill->ill_ifptr = ill_interface; avl_insert(&ill_interface->illif_avl_by_ppa, ill, where); ill_phyint_reinit(ill); return (0); } /* Initialize the per phyint (per IPMP group) ipsq used for serialization */ static boolean_t ipsq_init(ill_t *ill) { ipsq_t *ipsq; /* Init the ipsq and impicitly enter as writer */ ill->ill_phyint->phyint_ipsq = kmem_zalloc(sizeof (ipsq_t), KM_NOSLEEP); if (ill->ill_phyint->phyint_ipsq == NULL) return (B_FALSE); ipsq = ill->ill_phyint->phyint_ipsq; ipsq->ipsq_phyint_list = ill->ill_phyint; ill->ill_phyint->phyint_ipsq_next = NULL; mutex_init(&ipsq->ipsq_lock, NULL, MUTEX_DEFAULT, 0); ipsq->ipsq_refs = 1; ipsq->ipsq_writer = curthread; ipsq->ipsq_reentry_cnt = 1; #ifdef ILL_DEBUG ipsq->ipsq_depth = getpcstack((pc_t *)ipsq->ipsq_stack, IP_STACK_DEPTH); #endif (void) strcpy(ipsq->ipsq_name, ill->ill_name); return (B_TRUE); } /* * ill_init is called by ip_open when a device control stream is opened. * It does a few initializations, and shoots a DL_INFO_REQ message down * to the driver. The response is later picked up in ip_rput_dlpi and * used to set up default mechanisms for talking to the driver. (Always * called as writer.) * * If this function returns error, ip_open will call ip_close which in * turn will call ill_delete to clean up any memory allocated here that * is not yet freed. */ int ill_init(queue_t *q, ill_t *ill) { int count; dl_info_req_t *dlir; mblk_t *info_mp; uchar_t *frag_ptr; /* * The ill is initialized to zero by mi_alloc*(). In addition * some fields already contain valid values, initialized in * ip_open(), before we reach here. */ mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, 0); ill->ill_rq = q; ill->ill_wq = WR(q); info_mp = allocb(MAX(sizeof (dl_info_req_t), sizeof (dl_info_ack_t)), BPRI_HI); if (info_mp == NULL) return (ENOMEM); /* * Allocate sufficient space to contain our fragment hash table and * the device name. */ frag_ptr = (uchar_t *)mi_zalloc(ILL_FRAG_HASH_TBL_SIZE + 2 * LIFNAMSIZ + 5 + strlen(ipv6_forward_suffix)); if (frag_ptr == NULL) { freemsg(info_mp); return (ENOMEM); } ill->ill_frag_ptr = frag_ptr; ill->ill_frag_free_num_pkts = 0; ill->ill_last_frag_clean_time = 0; ill->ill_frag_hash_tbl = (ipfb_t *)frag_ptr; ill->ill_name = (char *)(frag_ptr + ILL_FRAG_HASH_TBL_SIZE); for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) { mutex_init(&ill->ill_frag_hash_tbl[count].ipfb_lock, NULL, MUTEX_DEFAULT, NULL); } ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t)); if (ill->ill_phyint == NULL) { freemsg(info_mp); mi_free(frag_ptr); return (ENOMEM); } mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0); /* * For now pretend this is a v4 ill. We need to set phyint_ill* * at this point because of the following reason. If we can't * enter the ipsq at some point and cv_wait, the writer that * wakes us up tries to locate us using the list of all phyints * in an ipsq and the ills from the phyint thru the phyint_ill*. * If we don't set it now, we risk a missed wakeup. */ ill->ill_phyint->phyint_illv4 = ill; ill->ill_ppa = UINT_MAX; ill->ill_fastpath_list = &ill->ill_fastpath_list; if (!ipsq_init(ill)) { freemsg(info_mp); mi_free(frag_ptr); mi_free(ill->ill_phyint); return (ENOMEM); } ill->ill_state_flags |= ILL_LL_SUBNET_PENDING; /* Frag queue limit stuff */ ill->ill_frag_count = 0; ill->ill_ipf_gen = 0; ill->ill_global_timer = INFINITY; ill->ill_mcast_type = IGMP_V3_ROUTER; /* == MLD_V2_ROUTER */ ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0; ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0; ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS; ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL; /* * Initialize IPv6 configuration variables. The IP module is always * opened as an IPv4 module. Instead tracking down the cases where * it switches to do ipv6, we'll just initialize the IPv6 configuration * here for convenience, this has no effect until the ill is set to do * IPv6. */ ill->ill_reachable_time = ND_REACHABLE_TIME; ill->ill_reachable_retrans_time = ND_RETRANS_TIMER; ill->ill_xmit_count = ND_MAX_MULTICAST_SOLICIT; ill->ill_max_buf = ND_MAX_Q; ill->ill_refcnt = 0; /* Send down the Info Request to the driver. */ info_mp->b_datap->db_type = M_PCPROTO; dlir = (dl_info_req_t *)info_mp->b_rptr; info_mp->b_wptr = (uchar_t *)&dlir[1]; dlir->dl_primitive = DL_INFO_REQ; ill->ill_dlpi_pending = DL_PRIM_INVAL; qprocson(q); ill_dlpi_send(ill, info_mp); return (0); } /* * ill_dls_info * creates datalink socket info from the device. */ int ill_dls_info(struct sockaddr_dl *sdl, ipif_t *ipif) { size_t length; ill_t *ill = ipif->ipif_ill; sdl->sdl_family = AF_LINK; sdl->sdl_index = ill->ill_phyint->phyint_ifindex; sdl->sdl_type = ipif->ipif_type; (void) ipif_get_name(ipif, sdl->sdl_data, sizeof (sdl->sdl_data)); length = mi_strlen(sdl->sdl_data); ASSERT(length < 256); sdl->sdl_nlen = (uchar_t)length; sdl->sdl_alen = ill->ill_phys_addr_length; mutex_enter(&ill->ill_lock); if (ill->ill_phys_addr_length != 0 && ill->ill_phys_addr != NULL) { bcopy(ill->ill_phys_addr, &sdl->sdl_data[length], ill->ill_phys_addr_length); } mutex_exit(&ill->ill_lock); sdl->sdl_slen = 0; return (sizeof (struct sockaddr_dl)); } /* * ill_xarp_info * creates xarp info from the device. */ static int ill_xarp_info(struct sockaddr_dl *sdl, ill_t *ill) { sdl->sdl_family = AF_LINK; sdl->sdl_index = ill->ill_phyint->phyint_ifindex; sdl->sdl_type = ill->ill_type; (void) ipif_get_name(ill->ill_ipif, sdl->sdl_data, sizeof (sdl->sdl_data)); sdl->sdl_nlen = (uchar_t)mi_strlen(sdl->sdl_data); sdl->sdl_alen = ill->ill_phys_addr_length; sdl->sdl_slen = 0; return (sdl->sdl_nlen); } static int loopback_kstat_update(kstat_t *ksp, int rw) { kstat_named_t *kn = KSTAT_NAMED_PTR(ksp); if (rw == KSTAT_WRITE) return (EACCES); kn[0].value.ui32 = loopback_packets; kn[1].value.ui32 = loopback_packets; return (0); } /* * Has ifindex been plumbed already. */ static boolean_t phyint_exists(uint_t index) { phyint_t *phyi; ASSERT(RW_LOCK_HELD(&ill_g_lock)); /* * Indexes are stored in the phyint - a common structure * to both IPv4 and IPv6. */ phyi = avl_find(&phyint_g_list.phyint_list_avl_by_index, (void *) &index, NULL); return (phyi != NULL); } /* * Assign a unique interface index for the phyint. */ static boolean_t phyint_assign_ifindex(phyint_t *phyi) { uint_t starting_index; ASSERT(phyi->phyint_ifindex == 0); if (!ill_index_wrap) { phyi->phyint_ifindex = ill_index++; if (ill_index == 0) { /* Reached the uint_t limit Next time wrap */ ill_index_wrap = B_TRUE; } return (B_TRUE); } /* * Start reusing unused indexes. Note that we hold the ill_g_lock * at this point and don't want to call any function that attempts * to get the lock again. */ starting_index = ill_index++; for (; ill_index != starting_index; ill_index++) { if (ill_index != 0 && !phyint_exists(ill_index)) { /* found unused index - use it */ phyi->phyint_ifindex = ill_index; return (B_TRUE); } } /* * all interface indicies are inuse. */ return (B_FALSE); } /* * Return a pointer to the ill which matches the supplied name. Note that * the ill name length includes the null termination character. (May be * called as writer.) * If do_alloc and the interface is "lo0" it will be automatically created. * Cannot bump up reference on condemned ills. So dup detect can't be done * using this func. */ ill_t * ill_lookup_on_name(char *name, boolean_t do_alloc, boolean_t isv6, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error, boolean_t *did_alloc) { ill_t *ill; ipif_t *ipif; kstat_named_t *kn; boolean_t isloopback; ipsq_t *old_ipsq; isloopback = mi_strcmp(name, ipif_loopback_name) == 0; rw_enter(&ill_g_lock, RW_READER); ill = ill_find_by_name(name, isv6, q, mp, func, error); rw_exit(&ill_g_lock); if (ill != NULL || (error != NULL && *error == EINPROGRESS)) return (ill); /* * Couldn't find it. Does this happen to be a lookup for the * loopback device and are we allowed to allocate it? */ if (!isloopback || !do_alloc) return (NULL); rw_enter(&ill_g_lock, RW_WRITER); ill = ill_find_by_name(name, isv6, q, mp, func, error); if (ill != NULL || (error != NULL && *error == EINPROGRESS)) { rw_exit(&ill_g_lock); return (ill); } /* Create the loopback device on demand */ ill = (ill_t *)(mi_alloc(sizeof (ill_t) + sizeof (ipif_loopback_name), BPRI_MED)); if (ill == NULL) goto done; *ill = ill_null; mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, NULL); ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t)); if (ill->ill_phyint == NULL) goto done; if (isv6) ill->ill_phyint->phyint_illv6 = ill; else ill->ill_phyint->phyint_illv4 = ill; mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0); ill->ill_max_frag = IP_LOOPBACK_MTU; /* Add room for tcp+ip headers */ if (isv6) { ill->ill_isv6 = B_TRUE; ill->ill_max_frag += IPV6_HDR_LEN + 20; /* for TCP */ if (!ill_allocate_mibs(ill)) goto done; } else { ill->ill_max_frag += IP_SIMPLE_HDR_LENGTH + 20; } ill->ill_max_mtu = ill->ill_max_frag; /* * ipif_loopback_name can't be pointed at directly because its used * by both the ipv4 and ipv6 interfaces. When the ill is removed * from the glist, ill_glist_delete() sets the first character of * ill_name to '\0'. */ ill->ill_name = (char *)ill + sizeof (*ill); (void) strcpy(ill->ill_name, ipif_loopback_name); ill->ill_name_length = sizeof (ipif_loopback_name); /* Set ill_name_set for ill_phyint_reinit to work properly */ ill->ill_global_timer = INFINITY; ill->ill_mcast_type = IGMP_V3_ROUTER; /* == MLD_V2_ROUTER */ ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0; ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0; ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS; ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL; /* No resolver here. */ ill->ill_net_type = IRE_LOOPBACK; /* Initialize the ipsq */ if (!ipsq_init(ill)) goto done; ill->ill_phyint->phyint_ipsq->ipsq_writer = NULL; ill->ill_phyint->phyint_ipsq->ipsq_reentry_cnt--; ASSERT(ill->ill_phyint->phyint_ipsq->ipsq_reentry_cnt == 0); #ifdef ILL_DEBUG ill->ill_phyint->phyint_ipsq->ipsq_depth = 0; #endif ipif = ipif_allocate(ill, 0L, IRE_LOOPBACK, B_TRUE); if (ipif == NULL) goto done; ill->ill_flags = ILLF_MULTICAST; /* Set up default loopback address and mask. */ if (!isv6) { ipaddr_t inaddr_loopback = htonl(INADDR_LOOPBACK); IN6_IPADDR_TO_V4MAPPED(inaddr_loopback, &ipif->ipif_v6lcl_addr); ipif->ipif_v6src_addr = ipif->ipif_v6lcl_addr; V4MASK_TO_V6(htonl(IN_CLASSA_NET), ipif->ipif_v6net_mask); V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); ill->ill_flags |= ILLF_IPV4; } else { ipif->ipif_v6lcl_addr = ipv6_loopback; ipif->ipif_v6src_addr = ipif->ipif_v6lcl_addr; ipif->ipif_v6net_mask = ipv6_all_ones; V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); ill->ill_flags |= ILLF_IPV6; } /* * Chain us in at the end of the ill list. hold the ill * before we make it globally visible. 1 for the lookup. */ ill->ill_refcnt = 0; ill_refhold(ill); ill->ill_frag_count = 0; ill->ill_frag_free_num_pkts = 0; ill->ill_last_frag_clean_time = 0; old_ipsq = ill->ill_phyint->phyint_ipsq; if (ill_glist_insert(ill, "lo", isv6) != 0) cmn_err(CE_PANIC, "cannot insert loopback interface"); /* Let SCTP know so that it can add this to its list */ sctp_update_ill(ill, SCTP_ILL_INSERT); /* Let SCTP know about this IPIF, so that it can add it to its list */ sctp_update_ipif(ipif, SCTP_IPIF_INSERT); /* * If the ipsq was changed in ill_phyint_reinit free the old ipsq. */ if (old_ipsq != ill->ill_phyint->phyint_ipsq) { /* Loopback ills aren't in any IPMP group */ ASSERT(!(old_ipsq->ipsq_flags & IPSQ_GROUP)); ipsq_delete(old_ipsq); } /* * Delay this till the ipif is allocated as ipif_allocate * de-references ill_phyint for getting the ifindex. We * can't do this before ipif_allocate because ill_phyint_reinit * -> phyint_assign_ifindex expects ipif to be present. */ mutex_enter(&ill->ill_phyint->phyint_lock); ill->ill_phyint->phyint_flags |= PHYI_LOOPBACK | PHYI_VIRTUAL; mutex_exit(&ill->ill_phyint->phyint_lock); if (loopback_ksp == NULL) { /* Export loopback interface statistics */ loopback_ksp = kstat_create("lo", 0, ipif_loopback_name, "net", KSTAT_TYPE_NAMED, 2, 0); if (loopback_ksp != NULL) { loopback_ksp->ks_update = loopback_kstat_update; kn = KSTAT_NAMED_PTR(loopback_ksp); kstat_named_init(&kn[0], "ipackets", KSTAT_DATA_UINT32); kstat_named_init(&kn[1], "opackets", KSTAT_DATA_UINT32); kstat_install(loopback_ksp); } } if (error != NULL) *error = 0; *did_alloc = B_TRUE; rw_exit(&ill_g_lock); return (ill); done: if (ill != NULL) { if (ill->ill_phyint != NULL) { ipsq_t *ipsq; ipsq = ill->ill_phyint->phyint_ipsq; if (ipsq != NULL) kmem_free(ipsq, sizeof (ipsq_t)); mi_free(ill->ill_phyint); } ill_free_mib(ill); mi_free(ill); } rw_exit(&ill_g_lock); if (error != NULL) *error = ENOMEM; return (NULL); } /* * Return a pointer to the ill which matches the index and IP version type. */ ill_t * ill_lookup_on_ifindex(uint_t index, boolean_t isv6, queue_t *q, mblk_t *mp, ipsq_func_t func, int *err) { ill_t *ill; ipsq_t *ipsq; phyint_t *phyi; ASSERT((q == NULL && mp == NULL && func == NULL && err == NULL) || (q != NULL && mp != NULL && func != NULL && err != NULL)); if (err != NULL) *err = 0; /* * Indexes are stored in the phyint - a common structure * to both IPv4 and IPv6. */ rw_enter(&ill_g_lock, RW_READER); phyi = avl_find(&phyint_g_list.phyint_list_avl_by_index, (void *) &index, NULL); if (phyi != NULL) { ill = isv6 ? phyi->phyint_illv6: phyi->phyint_illv4; if (ill != NULL) { /* * The block comment at the start of ipif_down * explains the use of the macros used below */ GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); if (ILL_CAN_LOOKUP(ill)) { ill_refhold_locked(ill); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); rw_exit(&ill_g_lock); return (ill); } else if (ILL_CAN_WAIT(ill, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); rw_exit(&ill_g_lock); mutex_exit(&ill->ill_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); *err = EINPROGRESS; return (NULL); } RELEASE_CONN_LOCK(q); mutex_exit(&ill->ill_lock); } } rw_exit(&ill_g_lock); if (err != NULL) *err = ENXIO; return (NULL); } /* * Obtain a reference to the ill. The ill_refcnt is a dynamic refcnt * that gives a running thread a reference to the ill. This reference must be * released by the thread when it is done accessing the ill and related * objects. ill_refcnt can not be used to account for static references * such as other structures pointing to an ill. Callers must generally * check whether an ill can be refheld by using ILL_CAN_LOOKUP macros * or be sure that the ill is not being deleted or changing state before * calling the refhold functions. A non-zero ill_refcnt ensures that the * ill won't change any of its critical state such as address, netmask etc. */ void ill_refhold(ill_t *ill) { mutex_enter(&ill->ill_lock); ill->ill_refcnt++; ILL_TRACE_REF(ill); mutex_exit(&ill->ill_lock); } void ill_refhold_locked(ill_t *ill) { ASSERT(MUTEX_HELD(&ill->ill_lock)); ill->ill_refcnt++; ILL_TRACE_REF(ill); } int ill_check_and_refhold(ill_t *ill) { mutex_enter(&ill->ill_lock); if (ILL_CAN_LOOKUP(ill)) { ill_refhold_locked(ill); mutex_exit(&ill->ill_lock); return (0); } mutex_exit(&ill->ill_lock); return (ILL_LOOKUP_FAILED); } /* * Must not be called while holding any locks. Otherwise if this is * the last reference to be released, there is a chance of recursive mutex * panic due to ill_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying * to restart an ioctl. */ void ill_refrele(ill_t *ill) { mutex_enter(&ill->ill_lock); ASSERT(ill->ill_refcnt != 0); ill->ill_refcnt--; ILL_UNTRACE_REF(ill); if (ill->ill_refcnt != 0) { /* Every ire pointing to the ill adds 1 to ill_refcnt */ mutex_exit(&ill->ill_lock); return; } /* Drops the ill_lock */ ipif_ill_refrele_tail(ill); } /* * Obtain a weak reference count on the ill. This reference ensures the * ill won't be freed, but the ill may change any of its critical state * such as netmask, address etc. Returns an error if the ill has started * closing. */ boolean_t ill_waiter_inc(ill_t *ill) { mutex_enter(&ill->ill_lock); if (ill->ill_state_flags & ILL_CONDEMNED) { mutex_exit(&ill->ill_lock); return (B_FALSE); } ill->ill_waiters++; mutex_exit(&ill->ill_lock); return (B_TRUE); } void ill_waiter_dcr(ill_t *ill) { mutex_enter(&ill->ill_lock); ill->ill_waiters--; if (ill->ill_waiters == 0) cv_broadcast(&ill->ill_cv); mutex_exit(&ill->ill_lock); } /* * Named Dispatch routine to produce a formatted report on all ILLs. * This report is accessed by using the ndd utility to "get" ND variable * "ip_ill_status". */ /* ARGSUSED */ int ip_ill_report(queue_t *q, mblk_t *mp, caddr_t arg, cred_t *ioc_cr) { ill_t *ill; ill_walk_context_t ctx; (void) mi_mpprintf(mp, "ILL " MI_COL_HDRPAD_STR /* 01234567[89ABCDEF] */ "rq " MI_COL_HDRPAD_STR /* 01234567[89ABCDEF] */ "wq " MI_COL_HDRPAD_STR /* 01234567[89ABCDEF] */ "upcnt mxfrg err name"); /* 12345 12345 123 xxxxxxxx */ rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_ALL(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { (void) mi_mpprintf(mp, MI_COL_PTRFMT_STR MI_COL_PTRFMT_STR MI_COL_PTRFMT_STR "%05u %05u %03d %s", (void *)ill, (void *)ill->ill_rq, (void *)ill->ill_wq, ill->ill_ipif_up_count, ill->ill_max_frag, ill->ill_error, ill->ill_name); } rw_exit(&ill_g_lock); return (0); } /* * Named Dispatch routine to produce a formatted report on all IPIFs. * This report is accessed by using the ndd utility to "get" ND variable * "ip_ipif_status". */ /* ARGSUSED */ int ip_ipif_report(queue_t *q, mblk_t *mp, caddr_t arg, cred_t *ioc_cr) { char buf1[INET6_ADDRSTRLEN]; char buf2[INET6_ADDRSTRLEN]; char buf3[INET6_ADDRSTRLEN]; char buf4[INET6_ADDRSTRLEN]; char buf5[INET6_ADDRSTRLEN]; char buf6[INET6_ADDRSTRLEN]; char buf[LIFNAMSIZ]; ill_t *ill; ipif_t *ipif; nv_t *nvp; uint64_t flags; zoneid_t zoneid; ill_walk_context_t ctx; (void) mi_mpprintf(mp, "IPIF metric mtu in/out/forward name zone flags...\n" "\tlocal address\n" "\tsrc address\n" "\tsubnet\n" "\tmask\n" "\tbroadcast\n" "\tp-p-dst"); ASSERT(q->q_next == NULL); zoneid = Q_TO_CONN(q)->conn_zoneid; /* IP is a driver */ rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_ALL(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) { if (zoneid != GLOBAL_ZONEID && zoneid != ipif->ipif_zoneid) continue; (void) mi_mpprintf(mp, MI_COL_PTRFMT_STR "%04u %05u %u/%u/%u %s %d", (void *)ipif, ipif->ipif_metric, ipif->ipif_mtu, ipif->ipif_ib_pkt_count, ipif->ipif_ob_pkt_count, ipif->ipif_fo_pkt_count, ipif_get_name(ipif, buf, sizeof (buf)), ipif->ipif_zoneid); flags = ipif->ipif_flags | ipif->ipif_ill->ill_flags | ipif->ipif_ill->ill_phyint->phyint_flags; /* Tack on text strings for any flags. */ nvp = ipif_nv_tbl; for (; nvp < A_END(ipif_nv_tbl); nvp++) { if (nvp->nv_value & flags) (void) mi_mpprintf_nr(mp, " %s", nvp->nv_name); } (void) mi_mpprintf(mp, "\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s", inet_ntop(AF_INET6, &ipif->ipif_v6lcl_addr, buf1, sizeof (buf1)), inet_ntop(AF_INET6, &ipif->ipif_v6src_addr, buf2, sizeof (buf2)), inet_ntop(AF_INET6, &ipif->ipif_v6subnet, buf3, sizeof (buf3)), inet_ntop(AF_INET6, &ipif->ipif_v6net_mask, buf4, sizeof (buf4)), inet_ntop(AF_INET6, &ipif->ipif_v6brd_addr, buf5, sizeof (buf5)), inet_ntop(AF_INET6, &ipif->ipif_v6pp_dst_addr, buf6, sizeof (buf6))); } } rw_exit(&ill_g_lock); return (0); } /* * ip_ll_subnet_defaults is called when we get the DL_INFO_ACK back from the * driver. We construct best guess defaults for lower level information that * we need. If an interface is brought up without injection of any overriding * information from outside, we have to be ready to go with these defaults. * When we get the first DL_INFO_ACK (from ip_open() sending a DL_INFO_REQ) * we primarely want the dl_provider_style. * The subsequent DL_INFO_ACK is received after doing a DL_ATTACH and DL_BIND * at which point we assume the other part of the information is valid. */ void ip_ll_subnet_defaults(ill_t *ill, mblk_t *mp) { uchar_t *brdcst_addr; uint_t brdcst_addr_length, phys_addr_length; t_scalar_t sap_length; dl_info_ack_t *dlia; ip_m_t *ipm; dl_qos_cl_sel1_t *sel1; ASSERT(IAM_WRITER_ILL(ill)); /* * Till the ill is fully up ILL_CHANGING will be set and * the ill is not globally visible. So no need for a lock. */ dlia = (dl_info_ack_t *)mp->b_rptr; ill->ill_mactype = dlia->dl_mac_type; ipm = ip_m_lookup(dlia->dl_mac_type); if (ipm == NULL) { ipm = ip_m_lookup(DL_OTHER); ASSERT(ipm != NULL); } ill->ill_media = ipm; /* * When the new DLPI stuff is ready we'll pull lengths * from dlia. */ if (dlia->dl_version == DL_VERSION_2) { brdcst_addr_length = dlia->dl_brdcst_addr_length; brdcst_addr = mi_offset_param(mp, dlia->dl_brdcst_addr_offset, brdcst_addr_length); if (brdcst_addr == NULL) { brdcst_addr_length = 0; } sap_length = dlia->dl_sap_length; phys_addr_length = dlia->dl_addr_length - ABS(sap_length); ip1dbg(("ip: bcast_len %d, sap_len %d, phys_len %d\n", brdcst_addr_length, sap_length, phys_addr_length)); } else { brdcst_addr_length = 6; brdcst_addr = ip_six_byte_all_ones; sap_length = -2; phys_addr_length = brdcst_addr_length; } ill->ill_bcast_addr_length = brdcst_addr_length; ill->ill_phys_addr_length = phys_addr_length; ill->ill_sap_length = sap_length; ill->ill_max_frag = dlia->dl_max_sdu; ill->ill_max_mtu = ill->ill_max_frag; ill->ill_type = ipm->ip_m_type; if (!ill->ill_dlpi_style_set) { if (dlia->dl_provider_style == DL_STYLE2) ill->ill_needs_attach = 1; /* * Allocate the first ipif on this ill. We don't delay it * further as ioctl handling assumes atleast one ipif to * be present. * * At this point we don't know whether the ill is v4 or v6. * We will know this whan the SIOCSLIFNAME happens and * the correct value for ill_isv6 will be assigned in * ipif_set_values(). We need to hold the ill lock and * clear the ILL_LL_SUBNET_PENDING flag and atomically do * the wakeup. */ (void) ipif_allocate(ill, 0, IRE_LOCAL, dlia->dl_provider_style == DL_STYLE2 ? B_FALSE : B_TRUE); mutex_enter(&ill->ill_lock); ASSERT(ill->ill_dlpi_style_set == 0); ill->ill_dlpi_style_set = 1; ill->ill_state_flags &= ~ILL_LL_SUBNET_PENDING; cv_broadcast(&ill->ill_cv); mutex_exit(&ill->ill_lock); freemsg(mp); return; } ASSERT(ill->ill_ipif != NULL); /* * We know whether it is IPv4 or IPv6 now, as this is the * second DL_INFO_ACK we are recieving in response to the * DL_INFO_REQ sent in ipif_set_values. */ if (ill->ill_isv6) ill->ill_sap = IP6_DL_SAP; else ill->ill_sap = IP_DL_SAP; /* * Set ipif_mtu which is used to set the IRE's * ire_max_frag value. The driver could have sent * a different mtu from what it sent last time. No * need to call ipif_mtu_change because IREs have * not yet been created. */ ill->ill_ipif->ipif_mtu = ill->ill_max_mtu; /* * Clear all the flags that were set based on ill_bcast_addr_length * and ill_phys_addr_length (in ipif_set_values) as these could have * changed now and we need to re-evaluate. */ ill->ill_flags &= ~(ILLF_MULTICAST | ILLF_NONUD | ILLF_NOARP); ill->ill_ipif->ipif_flags &= ~(IPIF_BROADCAST | IPIF_POINTOPOINT); /* * Free ill_resolver_mp and ill_bcast_mp as things could have * changed now. */ if (ill->ill_bcast_addr_length == 0) { if (ill->ill_resolver_mp != NULL) freemsg(ill->ill_resolver_mp); if (ill->ill_bcast_mp != NULL) freemsg(ill->ill_bcast_mp); if (ill->ill_flags & ILLF_XRESOLV) ill->ill_net_type = IRE_IF_RESOLVER; else ill->ill_net_type = IRE_IF_NORESOLVER; ill->ill_resolver_mp = ill_dlur_gen(NULL, ill->ill_phys_addr_length, ill->ill_sap, ill->ill_sap_length); ill->ill_bcast_mp = copymsg(ill->ill_resolver_mp); if (ill->ill_isv6) /* * Note: xresolv interfaces will eventually need NOARP * set here as well, but that will require those * external resolvers to have some knowledge of * that flag and act appropriately. Not to be changed * at present. */ ill->ill_flags |= ILLF_NONUD; else ill->ill_flags |= ILLF_NOARP; if (ill->ill_phys_addr_length == 0) { if (ill->ill_media->ip_m_mac_type == SUNW_DL_VNI) { ill->ill_ipif->ipif_flags |= IPIF_NOXMIT; ill->ill_phyint->phyint_flags |= PHYI_VIRTUAL; } else { /* pt-pt supports multicast. */ ill->ill_flags |= ILLF_MULTICAST; ill->ill_ipif->ipif_flags |= IPIF_POINTOPOINT; } } } else { ill->ill_net_type = IRE_IF_RESOLVER; if (ill->ill_bcast_mp != NULL) freemsg(ill->ill_bcast_mp); ill->ill_bcast_mp = ill_dlur_gen(brdcst_addr, ill->ill_bcast_addr_length, ill->ill_sap, ill->ill_sap_length); /* * Later detect lack of DLPI driver multicast * capability by catching DL_ENABMULTI errors in * ip_rput_dlpi. */ ill->ill_flags |= ILLF_MULTICAST; if (!ill->ill_isv6) ill->ill_ipif->ipif_flags |= IPIF_BROADCAST; } /* By default an interface does not support any CoS marking */ ill->ill_flags &= ~ILLF_COS_ENABLED; /* * If we get QoS information in DL_INFO_ACK, the device supports * some form of CoS marking, set ILLF_COS_ENABLED. */ sel1 = (dl_qos_cl_sel1_t *)mi_offset_param(mp, dlia->dl_qos_offset, dlia->dl_qos_length); if ((sel1 != NULL) && (sel1->dl_qos_type == DL_QOS_CL_SEL1)) { ill->ill_flags |= ILLF_COS_ENABLED; } /* Clear any previous error indication. */ ill->ill_error = 0; freemsg(mp); } /* * Perform various checks to verify that an address would make sense as a * local, remote, or subnet interface address. */ static boolean_t ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask) { ipaddr_t net_mask; /* * Don't allow all zeroes, all ones or experimental address, but allow * all ones netmask. */ if ((net_mask = ip_net_mask(addr)) == 0) return (B_FALSE); /* A given netmask overrides the "guess" netmask */ if (subnet_mask != 0) net_mask = subnet_mask; if ((net_mask != ~(ipaddr_t)0) && ((addr == (addr & net_mask)) || (addr == (addr | ~net_mask)))) { return (B_FALSE); } if (CLASSD(addr)) return (B_FALSE); return (B_TRUE); } /* * ipif_lookup_group * Returns held ipif */ ipif_t * ipif_lookup_group(ipaddr_t group, zoneid_t zoneid) { ire_t *ire; ipif_t *ipif; ire = ire_lookup_multi(group, zoneid); if (ire == NULL) return (NULL); ipif = ire->ire_ipif; ipif_refhold(ipif); ire_refrele(ire); return (ipif); } /* * Look for an ipif with the specified interface address and destination. * The destination address is used only for matching point-to-point interfaces. */ ipif_t * ipif_lookup_interface(ipaddr_t if_addr, ipaddr_t dst, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error) { ipif_t *ipif; ill_t *ill; ill_walk_context_t ctx; ipsq_t *ipsq; if (error != NULL) *error = 0; /* * First match all the point-to-point interfaces * before looking at non-point-to-point interfaces. * This is done to avoid returning non-point-to-point * ipif instead of unnumbered point-to-point ipif. */ rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { /* Allow the ipif to be down */ if ((ipif->ipif_flags & IPIF_POINTOPOINT) && (ipif->ipif_lcl_addr == if_addr) && (ipif->ipif_pp_dst_addr == dst)) { /* * The block comment at the start of ipif_down * explains the use of the macros used below */ if (IPIF_CAN_LOOKUP(ipif)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); rw_exit(&ill_g_lock); return (ipif); } else if (IPIF_CAN_WAIT(ipif, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); *error = EINPROGRESS; return (NULL); } } } mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); } rw_exit(&ill_g_lock); /* lookup the ipif based on interface address */ ipif = ipif_lookup_addr(if_addr, NULL, ALL_ZONES, q, mp, func, error); ASSERT(ipif == NULL || !ipif->ipif_isv6); return (ipif); } /* * Look for an ipif with the specified address. For point-point links * we look for matches on either the destination address and the local * address, but we ignore the check on the local address if IPIF_UNNUMBERED * is set. * Matches on a specific ill if match_ill is set. */ ipif_t * ipif_lookup_addr(ipaddr_t addr, ill_t *match_ill, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error) { ipif_t *ipif; ill_t *ill; boolean_t ptp = B_FALSE; ipsq_t *ipsq; ill_walk_context_t ctx; if (error != NULL) *error = 0; rw_enter(&ill_g_lock, RW_READER); /* * Repeat twice, first based on local addresses and * next time for pointopoint. */ repeat: ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { if (match_ill != NULL && ill != match_ill) { continue; } GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid) continue; /* Allow the ipif to be down */ if ((!ptp && (ipif->ipif_lcl_addr == addr) && ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) || (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) && (ipif->ipif_pp_dst_addr == addr))) { /* * The block comment at the start of ipif_down * explains the use of the macros used below */ if (IPIF_CAN_LOOKUP(ipif)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); rw_exit(&ill_g_lock); return (ipif); } else if (IPIF_CAN_WAIT(ipif, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); *error = EINPROGRESS; return (NULL); } } } mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); } /* Now try the ptp case */ if (ptp) { rw_exit(&ill_g_lock); if (error != NULL) *error = ENXIO; return (NULL); } ptp = B_TRUE; goto repeat; } /* * Look for an ipif that matches the specified remote address i.e. the * ipif that would receive the specified packet. * First look for directly connected interfaces and then do a recursive * IRE lookup and pick the first ipif corresponding to the source address in the * ire. * Returns: held ipif */ ipif_t * ipif_lookup_remote(ill_t *ill, ipaddr_t addr, zoneid_t zoneid) { ipif_t *ipif; ire_t *ire; ASSERT(!ill->ill_isv6); /* * Someone could be changing this ipif currently or change it * after we return this. Thus a few packets could use the old * old values. However structure updates/creates (ire, ilg, ilm etc) * will atomically be updated or cleaned up with the new value * Thus we don't need a lock to check the flags or other attrs below. */ mutex_enter(&ill->ill_lock); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid) continue; /* Allow the ipif to be down */ if (ipif->ipif_flags & IPIF_POINTOPOINT) { if ((ipif->ipif_pp_dst_addr == addr) || (!(ipif->ipif_flags & IPIF_UNNUMBERED) && ipif->ipif_lcl_addr == addr)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); return (ipif); } } else if (ipif->ipif_subnet == (addr & ipif->ipif_net_mask)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); return (ipif); } } mutex_exit(&ill->ill_lock); ire = ire_route_lookup(addr, 0, 0, 0, NULL, NULL, zoneid, MATCH_IRE_RECURSIVE); if (ire != NULL) { /* * The callers of this function wants to know the * interface on which they have to send the replies * back. For IRE_CACHES that have ire_stq and ire_ipif * derived from different ills, we really don't care * what we return here. */ ipif = ire->ire_ipif; if (ipif != NULL) { ipif_refhold(ipif); ire_refrele(ire); return (ipif); } ire_refrele(ire); } /* Pick the first interface */ ipif = ipif_get_next_ipif(NULL, ill); return (ipif); } /* * This func does not prevent refcnt from increasing. But if * the caller has taken steps to that effect, then this func * can be used to determine whether the ill has become quiescent */ boolean_t ill_is_quiescent(ill_t *ill) { ipif_t *ipif; ASSERT(MUTEX_HELD(&ill->ill_lock)); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_refcnt != 0 || ipif->ipif_ire_cnt != 0) return (B_FALSE); } if (ill->ill_ire_cnt != 0 || ill->ill_refcnt != 0 || ill->ill_nce_cnt != 0 || ill->ill_srcif_refcnt != 0 || ill->ill_mrtun_refcnt != 0) return (B_FALSE); return (B_TRUE); } /* * This func does not prevent refcnt from increasing. But if * the caller has taken steps to that effect, then this func * can be used to determine whether the ipif has become quiescent */ static boolean_t ipif_is_quiescent(ipif_t *ipif) { ill_t *ill; ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); if (ipif->ipif_refcnt != 0 || ipif->ipif_ire_cnt != 0) return (B_FALSE); ill = ipif->ipif_ill; if (ill->ill_ipif_up_count != 0 || ill->ill_logical_down) return (B_TRUE); /* This is the last ipif going down or being deleted on this ill */ if (ill->ill_ire_cnt != 0 || ill->ill_refcnt != 0) return (B_FALSE); return (B_TRUE); } /* * This func does not prevent refcnt from increasing. But if * the caller has taken steps to that effect, then this func * can be used to determine whether the ipifs marked with IPIF_MOVING * have become quiescent and can be moved in a failover/failback. */ static ipif_t * ill_quiescent_to_move(ill_t *ill) { ipif_t *ipif; ASSERT(MUTEX_HELD(&ill->ill_lock)); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_state_flags & IPIF_MOVING) { if (ipif->ipif_refcnt != 0 || ipif->ipif_ire_cnt != 0) { return (ipif); } } } return (NULL); } /* * The ipif/ill/ire has been refreled. Do the tail processing. * Determine if the ipif or ill in question has become quiescent and if so * wakeup close and/or restart any queued pending ioctl that is waiting * for the ipif_down (or ill_down) */ void ipif_ill_refrele_tail(ill_t *ill) { mblk_t *mp; conn_t *connp; ipsq_t *ipsq; ipif_t *ipif; ASSERT(MUTEX_HELD(&ill->ill_lock)); if ((ill->ill_state_flags & ILL_CONDEMNED) && ill_is_quiescent(ill)) { /* ill_close may be waiting */ cv_broadcast(&ill->ill_cv); } /* ipsq can't change because ill_lock is held */ ipsq = ill->ill_phyint->phyint_ipsq; if (ipsq->ipsq_waitfor == 0) { /* Not waiting for anything, just return. */ mutex_exit(&ill->ill_lock); return; } ASSERT(ipsq->ipsq_pending_mp != NULL && ipsq->ipsq_pending_ipif != NULL); /* * ipif->ipif_refcnt must go down to zero for restarting REMOVEIF. * Last ipif going down needs to down the ill, so ill_ire_cnt must * be zero for restarting an ioctl that ends up downing the ill. */ ipif = ipsq->ipsq_pending_ipif; if (ipif->ipif_ill != ill) { /* The ioctl is pending on some other ill. */ mutex_exit(&ill->ill_lock); return; } switch (ipsq->ipsq_waitfor) { case IPIF_DOWN: case IPIF_FREE: if (!ipif_is_quiescent(ipif)) { mutex_exit(&ill->ill_lock); return; } break; case ILL_DOWN: case ILL_FREE: /* * case ILL_FREE arises only for loopback. otherwise ill_delete * waits synchronously in ip_close, and no message is queued in * ipsq_pending_mp at all in this case */ if (!ill_is_quiescent(ill)) { mutex_exit(&ill->ill_lock); return; } break; case ILL_MOVE_OK: if (ill_quiescent_to_move(ill) != NULL) { mutex_exit(&ill->ill_lock); return; } break; default: cmn_err(CE_PANIC, "ipsq: %p unknown ipsq_waitfor %d\n", (void *)ipsq, ipsq->ipsq_waitfor); } /* * Incr refcnt for the qwriter_ip call below which * does a refrele */ ill_refhold_locked(ill); mutex_exit(&ill->ill_lock); mp = ipsq_pending_mp_get(ipsq, &connp); ASSERT(mp != NULL); switch (mp->b_datap->db_type) { case M_ERROR: case M_HANGUP: (void) qwriter_ip(NULL, ill, ill->ill_rq, mp, ipif_all_down_tail, CUR_OP, B_TRUE); return; case M_IOCTL: case M_IOCDATA: (void) qwriter_ip(NULL, ill, (connp != NULL ? CONNP_TO_WQ(connp) : ill->ill_wq), mp, ip_reprocess_ioctl, CUR_OP, B_TRUE); return; default: cmn_err(CE_PANIC, "ipif_ill_refrele_tail mp %p " "db_type %d\n", (void *)mp, mp->b_datap->db_type); } } #ifdef ILL_DEBUG /* Reuse trace buffer from beginning (if reached the end) and record trace */ void th_trace_rrecord(th_trace_t *th_trace) { tr_buf_t *tr_buf; uint_t lastref; lastref = th_trace->th_trace_lastref; lastref++; if (lastref == TR_BUF_MAX) lastref = 0; th_trace->th_trace_lastref = lastref; tr_buf = &th_trace->th_trbuf[lastref]; tr_buf->tr_depth = getpcstack(tr_buf->tr_stack, IP_STACK_DEPTH); } th_trace_t * th_trace_ipif_lookup(ipif_t *ipif) { int bucket_id; th_trace_t *th_trace; ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); bucket_id = IP_TR_HASH(curthread); ASSERT(bucket_id < IP_TR_HASH_MAX); for (th_trace = ipif->ipif_trace[bucket_id]; th_trace != NULL; th_trace = th_trace->th_next) { if (th_trace->th_id == curthread) return (th_trace); } return (NULL); } void ipif_trace_ref(ipif_t *ipif) { int bucket_id; th_trace_t *th_trace; ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); if (ipif->ipif_trace_disable) return; /* * Attempt to locate the trace buffer for the curthread. * If it does not exist, then allocate a new trace buffer * and link it in list of trace bufs for this ipif, at the head */ th_trace = th_trace_ipif_lookup(ipif); if (th_trace == NULL) { bucket_id = IP_TR_HASH(curthread); th_trace = (th_trace_t *)kmem_zalloc(sizeof (th_trace_t), KM_NOSLEEP); if (th_trace == NULL) { ipif->ipif_trace_disable = B_TRUE; ipif_trace_cleanup(ipif); return; } th_trace->th_id = curthread; th_trace->th_next = ipif->ipif_trace[bucket_id]; th_trace->th_prev = &ipif->ipif_trace[bucket_id]; if (th_trace->th_next != NULL) th_trace->th_next->th_prev = &th_trace->th_next; ipif->ipif_trace[bucket_id] = th_trace; } ASSERT(th_trace->th_refcnt >= 0 && th_trace->th_refcnt < TR_BUF_MAX -1); th_trace->th_refcnt++; th_trace_rrecord(th_trace); } void ipif_untrace_ref(ipif_t *ipif) { th_trace_t *th_trace; ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); if (ipif->ipif_trace_disable) return; th_trace = th_trace_ipif_lookup(ipif); ASSERT(th_trace != NULL); ASSERT(th_trace->th_refcnt > 0); th_trace->th_refcnt--; th_trace_rrecord(th_trace); } th_trace_t * th_trace_ill_lookup(ill_t *ill) { th_trace_t *th_trace; int bucket_id; ASSERT(MUTEX_HELD(&ill->ill_lock)); bucket_id = IP_TR_HASH(curthread); ASSERT(bucket_id < IP_TR_HASH_MAX); for (th_trace = ill->ill_trace[bucket_id]; th_trace != NULL; th_trace = th_trace->th_next) { if (th_trace->th_id == curthread) return (th_trace); } return (NULL); } void ill_trace_ref(ill_t *ill) { int bucket_id; th_trace_t *th_trace; ASSERT(MUTEX_HELD(&ill->ill_lock)); if (ill->ill_trace_disable) return; /* * Attempt to locate the trace buffer for the curthread. * If it does not exist, then allocate a new trace buffer * and link it in list of trace bufs for this ill, at the head */ th_trace = th_trace_ill_lookup(ill); if (th_trace == NULL) { bucket_id = IP_TR_HASH(curthread); th_trace = (th_trace_t *)kmem_zalloc(sizeof (th_trace_t), KM_NOSLEEP); if (th_trace == NULL) { ill->ill_trace_disable = B_TRUE; ill_trace_cleanup(ill); return; } th_trace->th_id = curthread; th_trace->th_next = ill->ill_trace[bucket_id]; th_trace->th_prev = &ill->ill_trace[bucket_id]; if (th_trace->th_next != NULL) th_trace->th_next->th_prev = &th_trace->th_next; ill->ill_trace[bucket_id] = th_trace; } ASSERT(th_trace->th_refcnt >= 0 && th_trace->th_refcnt < TR_BUF_MAX - 1); th_trace->th_refcnt++; th_trace_rrecord(th_trace); } void ill_untrace_ref(ill_t *ill) { th_trace_t *th_trace; ASSERT(MUTEX_HELD(&ill->ill_lock)); if (ill->ill_trace_disable) return; th_trace = th_trace_ill_lookup(ill); ASSERT(th_trace != NULL); ASSERT(th_trace->th_refcnt > 0); th_trace->th_refcnt--; th_trace_rrecord(th_trace); } /* * Verify that this thread has no refs to the ipif and free * the trace buffers */ /* ARGSUSED */ void ipif_thread_exit(ipif_t *ipif, void *dummy) { th_trace_t *th_trace; mutex_enter(&ipif->ipif_ill->ill_lock); th_trace = th_trace_ipif_lookup(ipif); if (th_trace == NULL) { mutex_exit(&ipif->ipif_ill->ill_lock); return; } ASSERT(th_trace->th_refcnt == 0); /* unlink th_trace and free it */ *th_trace->th_prev = th_trace->th_next; if (th_trace->th_next != NULL) th_trace->th_next->th_prev = th_trace->th_prev; th_trace->th_next = NULL; th_trace->th_prev = NULL; kmem_free(th_trace, sizeof (th_trace_t)); mutex_exit(&ipif->ipif_ill->ill_lock); } /* * Verify that this thread has no refs to the ill and free * the trace buffers */ /* ARGSUSED */ void ill_thread_exit(ill_t *ill, void *dummy) { th_trace_t *th_trace; mutex_enter(&ill->ill_lock); th_trace = th_trace_ill_lookup(ill); if (th_trace == NULL) { mutex_exit(&ill->ill_lock); return; } ASSERT(th_trace->th_refcnt == 0); /* unlink th_trace and free it */ *th_trace->th_prev = th_trace->th_next; if (th_trace->th_next != NULL) th_trace->th_next->th_prev = th_trace->th_prev; th_trace->th_next = NULL; th_trace->th_prev = NULL; kmem_free(th_trace, sizeof (th_trace_t)); mutex_exit(&ill->ill_lock); } #endif #ifdef ILL_DEBUG void ip_thread_exit(void) { ill_t *ill; ipif_t *ipif; ill_walk_context_t ctx; rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_ALL(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { ipif_thread_exit(ipif, NULL); } ill_thread_exit(ill, NULL); } rw_exit(&ill_g_lock); ire_walk(ire_thread_exit, NULL); ndp_walk_impl(NULL, nce_thread_exit, NULL, B_FALSE); } /* * Called when ipif is unplumbed or when memory alloc fails */ void ipif_trace_cleanup(ipif_t *ipif) { int i; th_trace_t *th_trace; th_trace_t *th_trace_next; for (i = 0; i < IP_TR_HASH_MAX; i++) { for (th_trace = ipif->ipif_trace[i]; th_trace != NULL; th_trace = th_trace_next) { th_trace_next = th_trace->th_next; kmem_free(th_trace, sizeof (th_trace_t)); } ipif->ipif_trace[i] = NULL; } } /* * Called when ill is unplumbed or when memory alloc fails */ void ill_trace_cleanup(ill_t *ill) { int i; th_trace_t *th_trace; th_trace_t *th_trace_next; for (i = 0; i < IP_TR_HASH_MAX; i++) { for (th_trace = ill->ill_trace[i]; th_trace != NULL; th_trace = th_trace_next) { th_trace_next = th_trace->th_next; kmem_free(th_trace, sizeof (th_trace_t)); } ill->ill_trace[i] = NULL; } } #else void ip_thread_exit(void) {} #endif void ipif_refhold_locked(ipif_t *ipif) { ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); ipif->ipif_refcnt++; IPIF_TRACE_REF(ipif); } void ipif_refhold(ipif_t *ipif) { ill_t *ill; ill = ipif->ipif_ill; mutex_enter(&ill->ill_lock); ipif->ipif_refcnt++; IPIF_TRACE_REF(ipif); mutex_exit(&ill->ill_lock); } /* * Must not be called while holding any locks. Otherwise if this is * the last reference to be released there is a chance of recursive mutex * panic due to ipif_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying * to restart an ioctl. */ void ipif_refrele(ipif_t *ipif) { ill_t *ill; ill = ipif->ipif_ill; mutex_enter(&ill->ill_lock); ASSERT(ipif->ipif_refcnt != 0); ipif->ipif_refcnt--; IPIF_UNTRACE_REF(ipif); if (ipif->ipif_refcnt != 0) { mutex_exit(&ill->ill_lock); return; } /* Drops the ill_lock */ ipif_ill_refrele_tail(ill); } ipif_t * ipif_get_next_ipif(ipif_t *curr, ill_t *ill) { ipif_t *ipif; mutex_enter(&ill->ill_lock); for (ipif = (curr == NULL ? ill->ill_ipif : curr->ipif_next); ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); return (ipif); } mutex_exit(&ill->ill_lock); return (NULL); } /* * TODO: make this table extendible at run time * Return a pointer to the mac type info for 'mac_type' */ static ip_m_t * ip_m_lookup(t_uscalar_t mac_type) { ip_m_t *ipm; for (ipm = ip_m_tbl; ipm < A_END(ip_m_tbl); ipm++) if (ipm->ip_m_mac_type == mac_type) return (ipm); return (NULL); } /* * ip_rt_add is called to add an IPv4 route to the forwarding table. * ipif_arg is passed in to associate it with the correct interface. * We may need to restart this operation if the ipif cannot be looked up * due to an exclusive operation that is currently in progress. The restart * entry point is specified by 'func' */ int ip_rt_add(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr, ipaddr_t src_addr, int flags, ipif_t *ipif_arg, ipif_t *src_ipif, ire_t **ire_arg, boolean_t ioctl_msg, queue_t *q, mblk_t *mp, ipsq_func_t func) { ire_t *ire; ire_t *gw_ire = NULL; ipif_t *ipif = NULL; boolean_t ipif_refheld = B_FALSE; uint_t type; int match_flags = MATCH_IRE_TYPE; int error; ip1dbg(("ip_rt_add:")); if (ire_arg != NULL) *ire_arg = NULL; /* * If this is the case of RTF_HOST being set, then we set the netmask * to all ones (regardless if one was supplied). */ if (flags & RTF_HOST) mask = IP_HOST_MASK; /* * Prevent routes with a zero gateway from being created (since * interfaces can currently be plumbed and brought up no assigned * address). * For routes with RTA_SRCIFP, the gateway address can be 0.0.0.0. */ if (gw_addr == 0 && src_ipif == NULL) return (ENETUNREACH); /* * Get the ipif, if any, corresponding to the gw_addr */ if (gw_addr != 0) { ipif = ipif_lookup_interface(gw_addr, dst_addr, q, mp, func, &error); if (ipif != NULL) { if (IS_VNI(ipif->ipif_ill)) { ipif_refrele(ipif); return (EINVAL); } ipif_refheld = B_TRUE; } else if (error == EINPROGRESS) { ip1dbg(("ip_rt_add: null and EINPROGRESS")); return (EINPROGRESS); } else { error = 0; } } if (ipif != NULL) { ip1dbg(("ip_rt_add: ipif_lookup_interface done ipif nonnull")); ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock)); } else { ip1dbg(("ip_rt_add: ipif_lookup_interface done ipif is null")); } /* * GateD will attempt to create routes with a loopback interface * address as the gateway and with RTF_GATEWAY set. We allow * these routes to be added, but create them as interface routes * since the gateway is an interface address. */ if ((ipif != NULL) && (ipif->ipif_ire_type == IRE_LOOPBACK)) flags &= ~RTF_GATEWAY; /* * Traditionally, interface routes are ones where RTF_GATEWAY isn't set * and the gateway address provided is one of the system's interface * addresses. By using the routing socket interface and supplying an * RTA_IFP sockaddr with an interface index, an alternate method of * specifying an interface route to be created is available which uses * the interface index that specifies the outgoing interface rather than * the address of an outgoing interface (which may not be able to * uniquely identify an interface). When coupled with the RTF_GATEWAY * flag, routes can be specified which not only specify the next-hop to * be used when routing to a certain prefix, but also which outgoing * interface should be used. * * Previously, interfaces would have unique addresses assigned to them * and so the address assigned to a particular interface could be used * to identify a particular interface. One exception to this was the * case of an unnumbered interface (where IPIF_UNNUMBERED was set). * * With the advent of IPv6 and its link-local addresses, this * restriction was relaxed and interfaces could share addresses between * themselves. In fact, typically all of the link-local interfaces on * an IPv6 node or router will have the same link-local address. In * order to differentiate between these interfaces, the use of an * interface index is necessary and this index can be carried inside a * RTA_IFP sockaddr (which is actually a sockaddr_dl). One restriction * of using the interface index, however, is that all of the ipif's that * are part of an ill have the same index and so the RTA_IFP sockaddr * cannot be used to differentiate between ipif's (or logical * interfaces) that belong to the same ill (physical interface). * * For example, in the following case involving IPv4 interfaces and * logical interfaces * * 192.0.2.32 255.255.255.224 192.0.2.33 U if0 * 192.0.2.32 255.255.255.224 192.0.2.34 U if0:1 * 192.0.2.32 255.255.255.224 192.0.2.35 U if0:2 * * the ipif's corresponding to each of these interface routes can be * uniquely identified by the "gateway" (actually interface address). * * In this case involving multiple IPv6 default routes to a particular * link-local gateway, the use of RTA_IFP is necessary to specify which * default route is of interest: * * default fe80::123:4567:89ab:cdef U if0 * default fe80::123:4567:89ab:cdef U if1 */ /* RTF_GATEWAY not set */ if (!(flags & RTF_GATEWAY)) { queue_t *stq; queue_t *rfq = NULL; ill_t *in_ill = NULL; /* * As the interface index specified with the RTA_IFP sockaddr is * the same for all ipif's off of an ill, the matching logic * below uses MATCH_IRE_ILL if such an index was specified. * This means that routes sharing the same prefix when added * using a RTA_IFP sockaddr must have distinct interface * indices (namely, they must be on distinct ill's). * * On the other hand, since the gateway address will usually be * different for each ipif on the system, the matching logic * uses MATCH_IRE_IPIF in the case of a traditional interface * route. This means that interface routes for the same prefix * can be created if they belong to distinct ipif's and if a * RTA_IFP sockaddr is not present. */ if (ipif_arg != NULL) { if (ipif_refheld) { ipif_refrele(ipif); ipif_refheld = B_FALSE; } ipif = ipif_arg; match_flags |= MATCH_IRE_ILL; } else { /* * Check the ipif corresponding to the gw_addr */ if (ipif == NULL) return (ENETUNREACH); match_flags |= MATCH_IRE_IPIF; } ASSERT(ipif != NULL); /* * If src_ipif is not NULL, we have to create * an ire with non-null ire_in_ill value */ if (src_ipif != NULL) { in_ill = src_ipif->ipif_ill; } /* * We check for an existing entry at this point. * * Since a netmask isn't passed in via the ioctl interface * (SIOCADDRT), we don't check for a matching netmask in that * case. */ if (!ioctl_msg) match_flags |= MATCH_IRE_MASK; if (src_ipif != NULL) { /* Look up in the special table */ ire = ire_srcif_table_lookup(dst_addr, IRE_INTERFACE, ipif, src_ipif->ipif_ill, match_flags); } else { ire = ire_ftable_lookup(dst_addr, mask, 0, IRE_INTERFACE, ipif, NULL, ALL_ZONES, 0, match_flags); } if (ire != NULL) { ire_refrele(ire); if (ipif_refheld) ipif_refrele(ipif); return (EEXIST); } if (src_ipif != NULL) { /* * Create the special ire for the IRE table * which hangs out of ire_in_ill. This ire * is in-between IRE_CACHE and IRE_INTERFACE. * Thus rfq is non-NULL. */ rfq = ipif->ipif_rq; } /* Create the usual interface ires */ stq = (ipif->ipif_net_type == IRE_IF_RESOLVER) ? ipif->ipif_rq : ipif->ipif_wq; /* * Create a copy of the IRE_LOOPBACK, * IRE_IF_NORESOLVER or IRE_IF_RESOLVER with * the modified address and netmask. */ ire = ire_create( (uchar_t *)&dst_addr, (uint8_t *)&mask, (uint8_t *)&ipif->ipif_src_addr, NULL, NULL, &ipif->ipif_mtu, NULL, rfq, stq, ipif->ipif_net_type, ipif->ipif_resolver_mp, ipif, in_ill, 0, 0, 0, flags, &ire_uinfo_null); if (ire == NULL) { if (ipif_refheld) ipif_refrele(ipif); return (ENOMEM); } /* * Some software (for example, GateD and Sun Cluster) attempts * to create (what amount to) IRE_PREFIX routes with the * loopback address as the gateway. This is primarily done to * set up prefixes with the RTF_REJECT flag set (for example, * when generating aggregate routes.) * * If the IRE type (as defined by ipif->ipif_net_type) is * IRE_LOOPBACK, then we map the request into a * IRE_IF_NORESOLVER. * * Needless to say, the real IRE_LOOPBACK is NOT created by this * routine, but rather using ire_create() directly. */ if (ipif->ipif_net_type == IRE_LOOPBACK) ire->ire_type = IRE_IF_NORESOLVER; error = ire_add(&ire, q, mp, func); if (error == 0) goto save_ire; /* * In the result of failure, ire_add() will have already * deleted the ire in question, so there is no need to * do that here. */ if (ipif_refheld) ipif_refrele(ipif); return (error); } if (ipif_refheld) { ipif_refrele(ipif); ipif_refheld = B_FALSE; } if (src_ipif != NULL) { /* RTA_SRCIFP is not supported on RTF_GATEWAY */ ip2dbg(("ip_rt_add: SRCIF cannot be set with gateway route\n")); return (EINVAL); } /* * Get an interface IRE for the specified gateway. * If we don't have an IRE_IF_NORESOLVER or IRE_IF_RESOLVER for the * gateway, it is currently unreachable and we fail the request * accordingly. */ ipif = ipif_arg; if (ipif_arg != NULL) match_flags |= MATCH_IRE_ILL; gw_ire = ire_ftable_lookup(gw_addr, 0, 0, IRE_INTERFACE, ipif_arg, NULL, ALL_ZONES, 0, match_flags); if (gw_ire == NULL) return (ENETUNREACH); /* * We create one of three types of IREs as a result of this request * based on the netmask. A netmask of all ones (which is automatically * assumed when RTF_HOST is set) results in an IRE_HOST being created. * An all zeroes netmask implies a default route so an IRE_DEFAULT is * created. Otherwise, an IRE_PREFIX route is created for the * destination prefix. */ if (mask == IP_HOST_MASK) type = IRE_HOST; else if (mask == 0) type = IRE_DEFAULT; else type = IRE_PREFIX; /* check for a duplicate entry */ ire = ire_ftable_lookup(dst_addr, mask, gw_addr, type, ipif_arg, NULL, ALL_ZONES, 0, match_flags | MATCH_IRE_MASK | MATCH_IRE_GW); if (ire != NULL) { ire_refrele(gw_ire); ire_refrele(ire); return (EEXIST); } /* Create the IRE. */ ire = ire_create( (uchar_t *)&dst_addr, /* dest address */ (uchar_t *)&mask, /* mask */ /* src address assigned by the caller? */ (uchar_t *)(((src_addr != INADDR_ANY) && (flags & RTF_SETSRC)) ? &src_addr : NULL), (uchar_t *)&gw_addr, /* gateway address */ NULL, /* no in-srcaddress */ &gw_ire->ire_max_frag, NULL, /* no Fast Path header */ NULL, /* no recv-from queue */ NULL, /* no send-to queue */ (ushort_t)type, /* IRE type */ NULL, ipif_arg, NULL, 0, 0, 0, flags, &gw_ire->ire_uinfo); /* Inherit ULP info from gw */ if (ire == NULL) { ire_refrele(gw_ire); return (ENOMEM); } /* * POLICY: should we allow an RTF_HOST with address INADDR_ANY? * SUN/OS socket stuff does but do we really want to allow 0.0.0.0? */ /* Add the new IRE. */ error = ire_add(&ire, q, mp, func); if (error != 0) { /* * In the result of failure, ire_add() will have already * deleted the ire in question, so there is no need to * do that here. */ ire_refrele(gw_ire); return (error); } if (flags & RTF_MULTIRT) { /* * Invoke the CGTP (multirouting) filtering module * to add the dst address in the filtering database. * Replicated inbound packets coming from that address * will be filtered to discard the duplicates. * It is not necessary to call the CGTP filter hook * when the dst address is a broadcast or multicast, * because an IP source address cannot be a broadcast * or a multicast. */ ire_t *ire_dst = ire_ctable_lookup(ire->ire_addr, 0, IRE_BROADCAST, NULL, NULL, MATCH_IRE_TYPE); if (ire_dst != NULL) { ip_cgtp_bcast_add(ire, ire_dst); ire_refrele(ire_dst); goto save_ire; } if ((ip_cgtp_filter_ops != NULL) && !CLASSD(ire->ire_addr)) { int res = ip_cgtp_filter_ops->cfo_add_dest_v4( ire->ire_addr, ire->ire_gateway_addr, ire->ire_src_addr, gw_ire->ire_src_addr); if (res != 0) { ire_refrele(gw_ire); ire_delete(ire); return (res); } } } save_ire: if (gw_ire != NULL) { ire_refrele(gw_ire); } /* * We do not do save_ire for the routes added with RTA_SRCIFP * flag. This route is only added and deleted by mipagent. * So, for simplicity of design, we refrain from saving * ires that are created with srcif value. This may change * in future if we find more usage of srcifp feature. */ if (ipif != NULL && src_ipif == NULL) { /* * Save enough information so that we can recreate the IRE if * the interface goes down and then up. The metrics associated * with the route will be saved as well when rts_setmetrics() is * called after the IRE has been created. In the case where * memory cannot be allocated, none of this information will be * saved. */ ipif_save_ire(ipif, ire); } if (ioctl_msg) ip_rts_rtmsg(RTM_OLDADD, ire, 0); if (ire_arg != NULL) { /* * Store the ire that was successfully added into where ire_arg * points to so that callers don't have to look it up * themselves (but they are responsible for ire_refrele()ing * the ire when they are finished with it). */ *ire_arg = ire; } else { ire_refrele(ire); /* Held in ire_add */ } if (ipif_refheld) ipif_refrele(ipif); return (0); } /* * ip_rt_delete is called to delete an IPv4 route. * ipif_arg is passed in to associate it with the correct interface. * src_ipif is passed to associate the incoming interface of the packet. * We may need to restart this operation if the ipif cannot be looked up * due to an exclusive operation that is currently in progress. The restart * entry point is specified by 'func' */ /* ARGSUSED4 */ int ip_rt_delete(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr, uint_t rtm_addrs, int flags, ipif_t *ipif_arg, ipif_t *src_ipif, boolean_t ioctl_msg, queue_t *q, mblk_t *mp, ipsq_func_t func) { ire_t *ire = NULL; ipif_t *ipif; boolean_t ipif_refheld = B_FALSE; uint_t type; uint_t match_flags = MATCH_IRE_TYPE; int err = 0; ip1dbg(("ip_rt_delete:")); /* * If this is the case of RTF_HOST being set, then we set the netmask * to all ones. Otherwise, we use the netmask if one was supplied. */ if (flags & RTF_HOST) { mask = IP_HOST_MASK; match_flags |= MATCH_IRE_MASK; } else if (rtm_addrs & RTA_NETMASK) { match_flags |= MATCH_IRE_MASK; } /* * Note that RTF_GATEWAY is never set on a delete, therefore * we check if the gateway address is one of our interfaces first, * and fall back on RTF_GATEWAY routes. * * This makes it possible to delete an original * IRE_IF_NORESOLVER/IRE_IF_RESOLVER - consistent with SunOS 4.1. * * As the interface index specified with the RTA_IFP sockaddr is the * same for all ipif's off of an ill, the matching logic below uses * MATCH_IRE_ILL if such an index was specified. This means a route * sharing the same prefix and interface index as the the route * intended to be deleted might be deleted instead if a RTA_IFP sockaddr * is specified in the request. * * On the other hand, since the gateway address will usually be * different for each ipif on the system, the matching logic * uses MATCH_IRE_IPIF in the case of a traditional interface * route. This means that interface routes for the same prefix can be * uniquely identified if they belong to distinct ipif's and if a * RTA_IFP sockaddr is not present. * * For more detail on specifying routes by gateway address and by * interface index, see the comments in ip_rt_add(). * gw_addr could be zero in some cases when both RTA_SRCIFP and * RTA_IFP are specified. If RTA_SRCIFP is specified and both * RTA_IFP and gateway_addr are NULL/zero, then delete will not * succeed. */ if (src_ipif != NULL) { if (ipif_arg == NULL && gw_addr != 0) { ipif_arg = ipif_lookup_interface(gw_addr, dst_addr, q, mp, func, &err); if (ipif_arg != NULL) ipif_refheld = B_TRUE; } if (ipif_arg == NULL) { err = (err == EINPROGRESS) ? err : ESRCH; return (err); } ipif = ipif_arg; } else { ipif = ipif_lookup_interface(gw_addr, dst_addr, q, mp, func, &err); if (ipif != NULL) ipif_refheld = B_TRUE; else if (err == EINPROGRESS) return (err); else err = 0; } if (ipif != NULL) { if (ipif_arg != NULL) { if (ipif_refheld) { ipif_refrele(ipif); ipif_refheld = B_FALSE; } ipif = ipif_arg; match_flags |= MATCH_IRE_ILL; } else { match_flags |= MATCH_IRE_IPIF; } if (src_ipif != NULL) { ire = ire_srcif_table_lookup(dst_addr, IRE_INTERFACE, ipif, src_ipif->ipif_ill, match_flags); } else { if (ipif->ipif_ire_type == IRE_LOOPBACK) { ire = ire_ctable_lookup(dst_addr, 0, IRE_LOOPBACK, ipif, ALL_ZONES, match_flags); } if (ire == NULL) { ire = ire_ftable_lookup(dst_addr, mask, 0, IRE_INTERFACE, ipif, NULL, ALL_ZONES, 0, match_flags); } } } if (ire == NULL) { /* * At this point, the gateway address is not one of our own * addresses or a matching interface route was not found. We * set the IRE type to lookup based on whether * this is a host route, a default route or just a prefix. * * If an ipif_arg was passed in, then the lookup is based on an * interface index so MATCH_IRE_ILL is added to match_flags. * In any case, MATCH_IRE_IPIF is cleared and MATCH_IRE_GW is * set as the route being looked up is not a traditional * interface route. * Since we do not add gateway route with srcipif, we don't * expect to find it either. */ if (src_ipif != NULL) { if (ipif_refheld) ipif_refrele(ipif); return (ESRCH); } else { match_flags &= ~MATCH_IRE_IPIF; match_flags |= MATCH_IRE_GW; if (ipif_arg != NULL) match_flags |= MATCH_IRE_ILL; if (mask == IP_HOST_MASK) type = IRE_HOST; else if (mask == 0) type = IRE_DEFAULT; else type = IRE_PREFIX; ire = ire_ftable_lookup(dst_addr, mask, gw_addr, type, ipif_arg, NULL, ALL_ZONES, 0, match_flags); if (ire == NULL && type == IRE_HOST) { ire = ire_ftable_lookup(dst_addr, mask, gw_addr, IRE_HOST_REDIRECT, ipif_arg, NULL, ALL_ZONES, 0, match_flags); } } } if (ipif_refheld) ipif_refrele(ipif); /* ipif is not refheld anymore */ if (ire == NULL) return (ESRCH); if (ire->ire_flags & RTF_MULTIRT) { /* * Invoke the CGTP (multirouting) filtering module * to remove the dst address from the filtering database. * Packets coming from that address will no longer be * filtered to remove duplicates. */ if (ip_cgtp_filter_ops != NULL) { err = ip_cgtp_filter_ops->cfo_del_dest_v4(ire->ire_addr, ire->ire_gateway_addr); } ip_cgtp_bcast_delete(ire); } ipif = ire->ire_ipif; /* * Removing from ipif_saved_ire_mp is not necessary * when src_ipif being non-NULL. ip_rt_add does not * save the ires which src_ipif being non-NULL. */ if (ipif != NULL && src_ipif == NULL) { ipif_remove_ire(ipif, ire); } if (ioctl_msg) ip_rts_rtmsg(RTM_OLDDEL, ire, 0); ire_delete(ire); ire_refrele(ire); return (err); } /* * ip_siocaddrt is called to complete processing of an SIOCADDRT IOCTL. */ /* ARGSUSED */ int ip_siocaddrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req) { ipaddr_t dst_addr; ipaddr_t gw_addr; ipaddr_t mask; int error = 0; mblk_t *mp1; struct rtentry *rt; ipif_t *ipif = NULL; ip1dbg(("ip_siocaddrt:")); /* Existence of mp1 verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; rt = (struct rtentry *)mp1->b_rptr; dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr; gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr; /* * If the RTF_HOST flag is on, this is a request to assign a gateway * to a particular host address. In this case, we set the netmask to * all ones for the particular destination address. Otherwise, * determine the netmask to be used based on dst_addr and the interfaces * in use. */ if (rt->rt_flags & RTF_HOST) { mask = IP_HOST_MASK; } else { /* * Note that ip_subnet_mask returns a zero mask in the case of * default (an all-zeroes address). */ mask = ip_subnet_mask(dst_addr, &ipif); } error = ip_rt_add(dst_addr, mask, gw_addr, 0, rt->rt_flags, NULL, NULL, NULL, B_TRUE, q, mp, ip_process_ioctl); if (ipif != NULL) ipif_refrele(ipif); return (error); } /* * ip_siocdelrt is called to complete processing of an SIOCDELRT IOCTL. */ /* ARGSUSED */ int ip_siocdelrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req) { ipaddr_t dst_addr; ipaddr_t gw_addr; ipaddr_t mask; int error; mblk_t *mp1; struct rtentry *rt; ipif_t *ipif = NULL; ip1dbg(("ip_siocdelrt:")); /* Existence of mp1 verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; rt = (struct rtentry *)mp1->b_rptr; dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr; gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr; /* * If the RTF_HOST flag is on, this is a request to delete a gateway * to a particular host address. In this case, we set the netmask to * all ones for the particular destination address. Otherwise, * determine the netmask to be used based on dst_addr and the interfaces * in use. */ if (rt->rt_flags & RTF_HOST) { mask = IP_HOST_MASK; } else { /* * Note that ip_subnet_mask returns a zero mask in the case of * default (an all-zeroes address). */ mask = ip_subnet_mask(dst_addr, &ipif); } error = ip_rt_delete(dst_addr, mask, gw_addr, RTA_DST | RTA_GATEWAY | RTA_NETMASK, rt->rt_flags, NULL, NULL, B_TRUE, q, mp, ip_process_ioctl); if (ipif != NULL) ipif_refrele(ipif); return (error); } /* * Enqueue the mp onto the ipsq, chained by b_next. * b_prev stores the function to be executed later, and b_queue the queue * where this mp originated. */ void ipsq_enq(ipsq_t *ipsq, queue_t *q, mblk_t *mp, ipsq_func_t func, int type, ill_t *pending_ill) { conn_t *connp = NULL; ASSERT(MUTEX_HELD(&ipsq->ipsq_lock)); ASSERT(func != NULL); mp->b_queue = q; mp->b_prev = (void *)func; mp->b_next = NULL; switch (type) { case CUR_OP: if (ipsq->ipsq_mptail != NULL) { ASSERT(ipsq->ipsq_mphead != NULL); ipsq->ipsq_mptail->b_next = mp; } else { ASSERT(ipsq->ipsq_mphead == NULL); ipsq->ipsq_mphead = mp; } ipsq->ipsq_mptail = mp; break; case NEW_OP: if (ipsq->ipsq_xopq_mptail != NULL) { ASSERT(ipsq->ipsq_xopq_mphead != NULL); ipsq->ipsq_xopq_mptail->b_next = mp; } else { ASSERT(ipsq->ipsq_xopq_mphead == NULL); ipsq->ipsq_xopq_mphead = mp; } ipsq->ipsq_xopq_mptail = mp; break; default: cmn_err(CE_PANIC, "ipsq_enq %d type \n", type); } if (CONN_Q(q) && pending_ill != NULL) { connp = Q_TO_CONN(q); ASSERT(MUTEX_HELD(&connp->conn_lock)); connp->conn_oper_pending_ill = pending_ill; } } /* * Return the mp at the head of the ipsq. After emptying the ipsq * look at the next ioctl, if this ioctl is complete. Otherwise * return, we will resume when we complete the current ioctl. * The current ioctl will wait till it gets a response from the * driver below. */ static mblk_t * ipsq_dq(ipsq_t *ipsq) { mblk_t *mp; ASSERT(MUTEX_HELD(&ipsq->ipsq_lock)); mp = ipsq->ipsq_mphead; if (mp != NULL) { ipsq->ipsq_mphead = mp->b_next; if (ipsq->ipsq_mphead == NULL) ipsq->ipsq_mptail = NULL; mp->b_next = NULL; return (mp); } if (ipsq->ipsq_current_ipif != NULL) return (NULL); mp = ipsq->ipsq_xopq_mphead; if (mp != NULL) { ipsq->ipsq_xopq_mphead = mp->b_next; if (ipsq->ipsq_xopq_mphead == NULL) ipsq->ipsq_xopq_mptail = NULL; mp->b_next = NULL; return (mp); } return (NULL); } /* * Enter the ipsq corresponding to ill, by waiting synchronously till * we can enter the ipsq exclusively. Unless 'force' is used, the ipsq * will have to drain completely before ipsq_enter returns success. * ipsq_current_ipif will be set if some exclusive ioctl is in progress, * and the ipsq_exit logic will start the next enqueued ioctl after * completion of the current ioctl. If 'force' is used, we don't wait * for the enqueued ioctls. This is needed when a conn_close wants to * enter the ipsq and abort an ioctl that is somehow stuck. Unplumb * of an ill can also use this option. But we dont' use it currently. */ #define ENTER_SQ_WAIT_TICKS 100 boolean_t ipsq_enter(ill_t *ill, boolean_t force) { ipsq_t *ipsq; boolean_t waited_enough = B_FALSE; /* * Holding the ill_lock prevents assocs from changing. * Since the assocs could change while we wait for the * writer, it is easier to wait on a fixed global rather than try to * cv_wait on a changing ipsq. */ mutex_enter(&ill->ill_lock); for (;;) { if (ill->ill_state_flags & ILL_CONDEMNED) { mutex_exit(&ill->ill_lock); return (B_FALSE); } ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); if (ipsq->ipsq_writer == NULL && (ipsq->ipsq_current_ipif == NULL || waited_enough)) { break; } else if (ipsq->ipsq_writer != NULL) { mutex_exit(&ipsq->ipsq_lock); cv_wait(&ill->ill_cv, &ill->ill_lock); } else { mutex_exit(&ipsq->ipsq_lock); if (force) { (void) cv_timedwait(&ill->ill_cv, &ill->ill_lock, lbolt + ENTER_SQ_WAIT_TICKS); waited_enough = B_TRUE; continue; } else { cv_wait(&ill->ill_cv, &ill->ill_lock); } } } ASSERT(ipsq->ipsq_mphead == NULL && ipsq->ipsq_mptail == NULL); ASSERT(ipsq->ipsq_reentry_cnt == 0); ipsq->ipsq_writer = curthread; ipsq->ipsq_reentry_cnt++; #ifdef ILL_DEBUG ipsq->ipsq_depth = getpcstack(ipsq->ipsq_stack, IP_STACK_DEPTH); #endif mutex_exit(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); return (B_TRUE); } /* * The ipsq_t (ipsq) is the synchronization data structure used to serialize * certain critical operations like plumbing (i.e. most set ioctls), * multicast joins, igmp/mld timers, IPMP operations etc. On a non-IPMP * system there is 1 ipsq per phyint. On an IPMP system there is 1 ipsq per * IPMP group. The ipsq serializes exclusive ioctls issued by applications * on a per ipsq basis in ipsq_xopq_mphead. It also protects against multiple * threads executing in the ipsq. Responses from the driver pertain to the * current ioctl (say a DL_BIND_ACK in response to a DL_BIND_REQUEST initiated * as part of bringing up the interface) and are enqueued in ipsq_mphead. * * If a thread does not want to reenter the ipsq when it is already writer, * it must make sure that the specified reentry point to be called later * when the ipsq is empty, nor any code path starting from the specified reentry * point must never ever try to enter the ipsq again. Otherwise it can lead * to an infinite loop. The reentry point ip_rput_dlpi_writer is an example. * When the thread that is currently exclusive finishes, it (ipsq_exit) * dequeues the requests waiting to become exclusive in ipsq_mphead and calls * the reentry point. When the list at ipsq_mphead becomes empty ipsq_exit * proceeds to dequeue the next ioctl in ipsq_xopq_mphead and start the next * ioctl if the current ioctl has completed. If the current ioctl is still * in progress it simply returns. The current ioctl could be waiting for * a response from another module (arp_ or the driver or could be waiting for * the ipif/ill/ire refcnts to drop to zero. In such a case the ipsq_pending_mp * and ipsq_pending_ipif are set. ipsq_current_ipif is set throughout the * execution of the ioctl and ipsq_exit does not start the next ioctl unless * ipsq_current_ipif is clear which happens only on ioctl completion. */ /* * Try to enter the ipsq exclusively, corresponding to ipif or ill. (only 1 of * ipif or ill can be specified). The caller ensures ipif or ill is valid by * ref-holding it if necessary. If the ipsq cannot be entered, the mp is queued * completion. */ ipsq_t * ipsq_try_enter(ipif_t *ipif, ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func, int type, boolean_t reentry_ok) { ipsq_t *ipsq; /* Only 1 of ipif or ill can be specified */ ASSERT((ipif != NULL) ^ (ill != NULL)); if (ipif != NULL) ill = ipif->ipif_ill; /* * lock ordering ill_g_lock -> conn_lock -> ill_lock -> ipsq_lock * ipsq of an ill can't change when ill_lock is held. */ GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); /* * 1. Enter the ipsq if we are already writer and reentry is ok. * (Note: If the caller does not specify reentry_ok then neither * 'func' nor any of its callees must ever attempt to enter the ipsq * again. Otherwise it can lead to an infinite loop * 2. Enter the ipsq if there is no current writer and this attempted * entry is part of the current ioctl or operation * 3. Enter the ipsq if there is no current writer and this is a new * ioctl (or operation) and the ioctl (or operation) queue is * empty and there is no ioctl (or operation) currently in progress */ if ((ipsq->ipsq_writer == NULL && ((type == CUR_OP) || (type == NEW_OP && ipsq->ipsq_xopq_mphead == NULL && ipsq->ipsq_current_ipif == NULL))) || (ipsq->ipsq_writer == curthread && reentry_ok)) { /* Success. */ ipsq->ipsq_reentry_cnt++; ipsq->ipsq_writer = curthread; mutex_exit(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); #ifdef ILL_DEBUG ipsq->ipsq_depth = getpcstack(ipsq->ipsq_stack, IP_STACK_DEPTH); #endif return (ipsq); } ipsq_enq(ipsq, q, mp, func, type, ill); mutex_exit(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); return (NULL); } /* * Try to enter the ipsq exclusively, corresponding to ipif or ill. (only 1 of * ipif or ill can be specified). The caller ensures ipif or ill is valid by * ref-holding it if necessary. If the ipsq cannot be entered, the mp is queued * completion. * * This function does a refrele on the ipif/ill. */ void qwriter_ip(ipif_t *ipif, ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func, int type, boolean_t reentry_ok) { ipsq_t *ipsq; ipsq = ipsq_try_enter(ipif, ill, q, mp, func, type, reentry_ok); /* * Caller must have done a refhold on the ipif. ipif_refrele * happens on the passed ipif. We can do this since we are * already exclusive, or we won't access ipif henceforth, Both * this func and caller will just return if we ipsq_try_enter * fails above. This is needed because func needs to * see the correct refcount. Eg. removeif can work only then. */ if (ipif != NULL) ipif_refrele(ipif); else ill_refrele(ill); if (ipsq != NULL) { (*func)(ipsq, q, mp, NULL); ipsq_exit(ipsq, B_TRUE, B_TRUE); } } /* * If there are more than ILL_GRP_CNT ills in a group, * we use kmem alloc'd buffers, else use the stack */ #define ILL_GRP_CNT 14 /* * Drain the ipsq, if there are messages on it, and then leave the ipsq. * Called by a thread that is currently exclusive on this ipsq. */ void ipsq_exit(ipsq_t *ipsq, boolean_t start_igmp_timer, boolean_t start_mld_timer) { queue_t *q; mblk_t *mp; ipsq_func_t func; int next; ill_t **ill_list = NULL; size_t ill_list_size = 0; int cnt = 0; boolean_t need_ipsq_free = B_FALSE; ASSERT(IAM_WRITER_IPSQ(ipsq)); mutex_enter(&ipsq->ipsq_lock); ASSERT(ipsq->ipsq_reentry_cnt >= 1); if (ipsq->ipsq_reentry_cnt != 1) { ipsq->ipsq_reentry_cnt--; mutex_exit(&ipsq->ipsq_lock); return; } mp = ipsq_dq(ipsq); while (mp != NULL) { again: mutex_exit(&ipsq->ipsq_lock); func = (ipsq_func_t)mp->b_prev; q = (queue_t *)mp->b_queue; mp->b_prev = NULL; mp->b_queue = NULL; /* * If 'q' is an conn queue, it is valid, since we did a * a refhold on the connp, at the start of the ioctl. * If 'q' is an ill queue, it is valid, since close of an * ill will clean up the 'ipsq'. */ (*func)(ipsq, q, mp, NULL); mutex_enter(&ipsq->ipsq_lock); mp = ipsq_dq(ipsq); } mutex_exit(&ipsq->ipsq_lock); /* * Need to grab the locks in the right order. Need to * atomically check (under ipsq_lock) that there are no * messages before relinquishing the ipsq. Also need to * atomically wakeup waiters on ill_cv while holding ill_lock. * Holding ill_g_lock ensures that ipsq list of ills is stable. * If we need to call ill_split_ipsq and change we need * to grab ill_g_lock as writer. */ rw_enter(&ill_g_lock, ipsq->ipsq_split ? RW_WRITER : RW_READER); /* ipsq_refs can't change while ill_g_lock is held as reader */ if (ipsq->ipsq_refs != 0) { /* At most 2 ills v4/v6 per phyint */ cnt = ipsq->ipsq_refs << 1; ill_list_size = cnt * sizeof (ill_t *); /* * If memory allocation fails, we will do the split * the next time ipsq_exit is called for whatever reason. * As long as the ipsq_split flag is set the need to * split is remembered. */ ill_list = kmem_zalloc(ill_list_size, KM_NOSLEEP); if (ill_list != NULL) cnt = ill_lock_ipsq_ills(ipsq, ill_list, cnt); } mutex_enter(&ipsq->ipsq_lock); mp = ipsq_dq(ipsq); if (mp != NULL) { /* oops, some message has landed up, we can't get out */ if (ill_list != NULL) ill_unlock_ills(ill_list, cnt); rw_exit(&ill_g_lock); if (ill_list != NULL) kmem_free(ill_list, ill_list_size); ill_list = NULL; ill_list_size = 0; cnt = 0; goto again; } /* * Split only if no ioctl is pending and if memory alloc succeeded * above. */ if (ipsq->ipsq_split && ipsq->ipsq_current_ipif == NULL && ill_list != NULL) { /* * No new ill can join this ipsq since we are holding the * ill_g_lock. Hence ill_split_ipsq can safely traverse the * ipsq. ill_split_ipsq may fail due to memory shortage. * If so we will retry on the next ipsq_exit. */ ipsq->ipsq_split = ill_split_ipsq(ipsq); } /* * We are holding the ipsq lock, hence no new messages can * land up on the ipsq, and there are no messages currently. * Now safe to get out. Wake up waiters and relinquish ipsq * atomically while holding ill locks. */ ipsq->ipsq_writer = NULL; ipsq->ipsq_reentry_cnt--; ASSERT(ipsq->ipsq_reentry_cnt == 0); #ifdef ILL_DEBUG ipsq->ipsq_depth = 0; #endif mutex_exit(&ipsq->ipsq_lock); /* * For IPMP this should wake up all ills in this ipsq. * We need to hold the ill_lock while waking up waiters to * avoid missed wakeups. But there is no need to acquire all * the ill locks and then wakeup. If we have not acquired all * the locks (due to memory failure above) ill_signal_ipsq_ills * wakes up ills one at a time after getting the right ill_lock */ ill_signal_ipsq_ills(ipsq, ill_list != NULL); if (ill_list != NULL) ill_unlock_ills(ill_list, cnt); if (ipsq->ipsq_refs == 0) need_ipsq_free = B_TRUE; rw_exit(&ill_g_lock); if (ill_list != 0) kmem_free(ill_list, ill_list_size); if (need_ipsq_free) { /* * Free the ipsq. ipsq_refs can't increase because ipsq can't be * looked up. ipsq can be looked up only thru ill or phyint * and there are no ills/phyint on this ipsq. */ ipsq_delete(ipsq); } /* * Now start any igmp or mld timers that could not be started * while inside the ipsq. The timers can't be started while inside * the ipsq, since igmp_start_timers may need to call untimeout() * which can't be done while holding a lock i.e. the ipsq. Otherwise * there could be a deadlock since the timeout handlers * mld_timeout_handler / igmp_timeout_handler also synchronously * wait in ipsq_enter() trying to get the ipsq. * * However there is one exception to the above. If this thread is * itself the igmp/mld timeout handler thread, then we don't want * to start any new timer until the current handler is done. The * handler thread passes in B_FALSE for start_igmp/mld_timers, while * all others pass B_TRUE. */ if (start_igmp_timer) { mutex_enter(&igmp_timer_lock); next = igmp_deferred_next; igmp_deferred_next = INFINITY; mutex_exit(&igmp_timer_lock); if (next != INFINITY) igmp_start_timers(next); } if (start_mld_timer) { mutex_enter(&mld_timer_lock); next = mld_deferred_next; mld_deferred_next = INFINITY; mutex_exit(&mld_timer_lock); if (next != INFINITY) mld_start_timers(next); } } /* * The ill is closing. Flush all messages on the ipsq that originated * from this ill. Usually there wont' be any messages on the ipsq_xopq_mphead * for this ill since ipsq_enter could not have entered until then. * New messages can't be queued since the CONDEMNED flag is set. */ static void ipsq_flush(ill_t *ill) { queue_t *q; mblk_t *prev; mblk_t *mp; mblk_t *mp_next; ipsq_t *ipsq; ASSERT(IAM_WRITER_ILL(ill)); ipsq = ill->ill_phyint->phyint_ipsq; /* * Flush any messages sent up by the driver. */ mutex_enter(&ipsq->ipsq_lock); for (prev = NULL, mp = ipsq->ipsq_mphead; mp != NULL; mp = mp_next) { mp_next = mp->b_next; q = mp->b_queue; if (q == ill->ill_rq || q == ill->ill_wq) { /* Remove the mp from the ipsq */ if (prev == NULL) ipsq->ipsq_mphead = mp->b_next; else prev->b_next = mp->b_next; if (ipsq->ipsq_mptail == mp) { ASSERT(mp_next == NULL); ipsq->ipsq_mptail = prev; } inet_freemsg(mp); } else { prev = mp; } } mutex_exit(&ipsq->ipsq_lock); (void) ipsq_pending_mp_cleanup(ill, NULL); ipsq_xopq_mp_cleanup(ill, NULL); ill_pending_mp_cleanup(ill); } /* * Clean up one squeue element. ill_inuse_ref is protected by ill_lock. * The real cleanup happens behind the squeue via ip_squeue_clean function but * we need to protect ourselfs from 2 threads trying to cleanup at the same * time (possible with one port going down for aggr and someone tearing down the * entire aggr simultaneously. So we use ill_inuse_ref protected by ill_lock * to indicate when the cleanup has started (1 ref) and when the cleanup * is done (0 ref). When a new ring gets assigned to squeue, we start by * putting 2 ref on ill_inuse_ref. */ static void ipsq_clean_ring(ill_t *ill, ill_rx_ring_t *rx_ring) { conn_t *connp; squeue_t *sqp; mblk_t *mp; ASSERT(rx_ring != NULL); /* Just clean one squeue */ mutex_enter(&ill->ill_lock); /* * Reset the ILL_SOFT_RING_ASSIGN bit so that * ip_squeue_soft_ring_affinty() will not go * ahead with assigning rings. */ ill->ill_state_flags &= ~ILL_SOFT_RING_ASSIGN; while (rx_ring->rr_ring_state == ILL_RING_INPROC) /* Some operations pending on the ring. Wait */ cv_wait(&ill->ill_cv, &ill->ill_lock); if (rx_ring->rr_ring_state != ILL_RING_INUSE) { /* * Someone already trying to clean * this squeue or its already been cleaned. */ mutex_exit(&ill->ill_lock); return; } sqp = rx_ring->rr_sqp; if (sqp == NULL) { /* * The rx_ring never had a squeue assigned to it. * We are under ill_lock so we can clean it up * here itself since no one can get to it. */ rx_ring->rr_blank = NULL; rx_ring->rr_handle = NULL; rx_ring->rr_sqp = NULL; rx_ring->rr_ring_state = ILL_RING_FREE; mutex_exit(&ill->ill_lock); return; } /* Set the state that its being cleaned */ rx_ring->rr_ring_state = ILL_RING_BEING_FREED; ASSERT(sqp != NULL); mutex_exit(&ill->ill_lock); /* * Use the preallocated ill_unbind_conn for this purpose */ connp = ill->ill_dls_capab->ill_unbind_conn; mp = &connp->conn_tcp->tcp_closemp; CONN_INC_REF(connp); squeue_enter(sqp, mp, ip_squeue_clean, connp, NULL); mutex_enter(&ill->ill_lock); while (rx_ring->rr_ring_state != ILL_RING_FREE) cv_wait(&ill->ill_cv, &ill->ill_lock); mutex_exit(&ill->ill_lock); } static void ipsq_clean_all(ill_t *ill) { int idx; /* * No need to clean if poll_capab isn't set for this ill */ if (!(ill->ill_capabilities & (ILL_CAPAB_POLL|ILL_CAPAB_SOFT_RING))) return; for (idx = 0; idx < ILL_MAX_RINGS; idx++) { ill_rx_ring_t *ipr = &ill->ill_dls_capab->ill_ring_tbl[idx]; ipsq_clean_ring(ill, ipr); } ill->ill_capabilities &= ~(ILL_CAPAB_POLL|ILL_CAPAB_SOFT_RING); } /* ARGSUSED */ int ip_sioctl_slifoindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { ill_t *ill; struct lifreq *lifr = (struct lifreq *)ifreq; boolean_t isv6; conn_t *connp; connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; /* * Set original index. * Failover and failback move logical interfaces * from one physical interface to another. The * original index indicates the parent of a logical * interface, in other words, the physical interface * the logical interface will be moved back to on * failback. */ /* * Don't allow the original index to be changed * for non-failover addresses, autoconfigured * addresses, or IPv6 link local addresses. */ if (((ipif->ipif_flags & (IPIF_NOFAILOVER | IPIF_ADDRCONF)) != NULL) || (isv6 && IN6_IS_ADDR_LINKLOCAL(&ipif->ipif_v6lcl_addr))) { return (EINVAL); } /* * The new original index must be in use by some * physical interface. */ ill = ill_lookup_on_ifindex(lifr->lifr_index, isv6, NULL, NULL, NULL, NULL); if (ill == NULL) return (ENXIO); ill_refrele(ill); ipif->ipif_orig_ifindex = lifr->lifr_index; /* * When this ipif gets failed back, don't * preserve the original id, as it is no * longer applicable. */ ipif->ipif_orig_ipifid = 0; /* * For IPv4, change the original index of any * multicast addresses associated with the * ipif to the new value. */ if (!isv6) { ilm_t *ilm; mutex_enter(&ipif->ipif_ill->ill_lock); for (ilm = ipif->ipif_ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (ilm->ilm_ipif == ipif) { ilm->ilm_orig_ifindex = lifr->lifr_index; } } mutex_exit(&ipif->ipif_ill->ill_lock); } return (0); } /* ARGSUSED */ int ip_sioctl_get_oindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifreq *lifr = (struct lifreq *)ifreq; /* * Get the original interface index i.e the one * before FAILOVER if it ever happened. */ lifr->lifr_index = ipif->ipif_orig_ifindex; return (0); } /* * Parse an iftun_req structure coming down SIOC[GS]TUNPARAM ioctls, * refhold and return the associated ipif */ int ip_extract_tunreq(queue_t *q, mblk_t *mp, ipif_t **ipifp, ipsq_func_t func) { boolean_t exists; struct iftun_req *ta; ipif_t *ipif; ill_t *ill; boolean_t isv6; mblk_t *mp1; int error; conn_t *connp; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; ta = (struct iftun_req *)mp1->b_rptr; /* * Null terminate the string to protect against buffer * overrun. String was generated by user code and may not * be trusted. */ ta->ifta_lifr_name[LIFNAMSIZ - 1] = '\0'; connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; /* Disallows implicit create */ ipif = ipif_lookup_on_name(ta->ifta_lifr_name, mi_strlen(ta->ifta_lifr_name), B_FALSE, &exists, isv6, connp->conn_zoneid, CONNP_TO_WQ(connp), mp, func, &error); if (ipif == NULL) return (error); if (ipif->ipif_id != 0) { /* * We really don't want to set/get tunnel parameters * on virtual tunnel interfaces. Only allow the * base tunnel to do these. */ ipif_refrele(ipif); return (EINVAL); } /* * Send down to tunnel mod for ioctl processing. * Will finish ioctl in ip_rput_other(). */ ill = ipif->ipif_ill; if (ill->ill_net_type == IRE_LOOPBACK) { ipif_refrele(ipif); return (EOPNOTSUPP); } if (ill->ill_wq == NULL) { ipif_refrele(ipif); return (ENXIO); } /* * Mark the ioctl as coming from an IPv6 interface for * tun's convenience. */ if (ill->ill_isv6) ta->ifta_flags |= 0x80000000; *ipifp = ipif; return (0); } /* * Parse an ifreq or lifreq struct coming down ioctls and refhold * and return the associated ipif. * Return value: * Non zero: An error has occurred. ci may not be filled out. * zero : ci is filled out with the ioctl cmd in ci.ci_name, and * a held ipif in ci.ci_ipif. */ int ip_extract_lifreq_cmn(queue_t *q, mblk_t *mp, int cmd_type, int flags, cmd_info_t *ci, ipsq_func_t func) { sin_t *sin; sin6_t *sin6; char *name; struct ifreq *ifr; struct lifreq *lifr; ipif_t *ipif = NULL; ill_t *ill; conn_t *connp; boolean_t isv6; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; boolean_t exists; int err; mblk_t *mp1; zoneid_t zoneid; if (q->q_next != NULL) { ill = (ill_t *)q->q_ptr; isv6 = ill->ill_isv6; connp = NULL; zoneid = ALL_ZONES; } else { ill = NULL; connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; zoneid = connp->conn_zoneid; if (zoneid == GLOBAL_ZONEID) { /* global zone can access ipifs in all zones */ zoneid = ALL_ZONES; } } /* Has been checked in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; if (cmd_type == IF_CMD) { /* This a old style SIOC[GS]IF* command */ ifr = (struct ifreq *)mp1->b_rptr; /* * Null terminate the string to protect against buffer * overrun. String was generated by user code and may not * be trusted. */ ifr->ifr_name[IFNAMSIZ - 1] = '\0'; sin = (sin_t *)&ifr->ifr_addr; name = ifr->ifr_name; ci->ci_sin = sin; ci->ci_sin6 = NULL; ci->ci_lifr = (struct lifreq *)ifr; } else { /* This a new style SIOC[GS]LIF* command */ ASSERT(cmd_type == LIF_CMD); lifr = (struct lifreq *)mp1->b_rptr; /* * Null terminate the string to protect against buffer * overrun. String was generated by user code and may not * be trusted. */ lifr->lifr_name[LIFNAMSIZ - 1] = '\0'; name = lifr->lifr_name; sin = (sin_t *)&lifr->lifr_addr; sin6 = (sin6_t *)&lifr->lifr_addr; if (iocp->ioc_cmd == SIOCSLIFGROUPNAME) { (void) strncpy(ci->ci_groupname, lifr->lifr_groupname, LIFNAMSIZ); } ci->ci_sin = sin; ci->ci_sin6 = sin6; ci->ci_lifr = lifr; } if (iocp->ioc_cmd == SIOCSLIFNAME) { /* * The ioctl will be failed if the ioctl comes down * an conn stream */ if (ill == NULL) { /* * Not an ill queue, return EINVAL same as the * old error code. */ return (ENXIO); } ipif = ill->ill_ipif; ipif_refhold(ipif); } else { ipif = ipif_lookup_on_name(name, mi_strlen(name), B_FALSE, &exists, isv6, zoneid, (connp == NULL) ? q : CONNP_TO_WQ(connp), mp, func, &err); if (ipif == NULL) { if (err == EINPROGRESS) return (err); if (iocp->ioc_cmd == SIOCLIFFAILOVER || iocp->ioc_cmd == SIOCLIFFAILBACK) { /* * Need to try both v4 and v6 since this * ioctl can come down either v4 or v6 * socket. The lifreq.lifr_family passed * down by this ioctl is AF_UNSPEC. */ ipif = ipif_lookup_on_name(name, mi_strlen(name), B_FALSE, &exists, !isv6, zoneid, (connp == NULL) ? q : CONNP_TO_WQ(connp), mp, func, &err); if (err == EINPROGRESS) return (err); } err = 0; /* Ensure we don't use it below */ } } /* * Old style [GS]IFCMD does not admit IPv6 ipif */ if (ipif != NULL && ipif->ipif_isv6 && cmd_type == IF_CMD) { ipif_refrele(ipif); return (ENXIO); } if (ipif == NULL && ill != NULL && ill->ill_ipif != NULL && name[0] == '\0') { /* * Handle a or a SIOC?IF* with a null name * during plumb (on the ill queue before the I_PLINK). */ ipif = ill->ill_ipif; ipif_refhold(ipif); } if (ipif == NULL) return (ENXIO); /* * Allow only GET operations if this ipif has been created * temporarily due to a MOVE operation. */ if (ipif->ipif_replace_zero && !(flags & IPI_REPL)) { ipif_refrele(ipif); return (EINVAL); } ci->ci_ipif = ipif; return (0); } /* * Return the total number of ipifs. */ static uint_t ip_get_numifs(zoneid_t zoneid) { uint_t numifs = 0; ill_t *ill; ill_walk_context_t ctx; ipif_t *ipif; rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_V4(&ctx); while (ill != NULL) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_zoneid == zoneid) numifs++; } ill = ill_next(&ctx, ill); } rw_exit(&ill_g_lock); return (numifs); } /* * Return the total number of ipifs. */ static uint_t ip_get_numlifs(int family, int lifn_flags, zoneid_t zoneid) { uint_t numifs = 0; ill_t *ill; ipif_t *ipif; ill_walk_context_t ctx; ip1dbg(("ip_get_numlifs(%d %u %d)\n", family, lifn_flags, (int)zoneid)); rw_enter(&ill_g_lock, RW_READER); if (family == AF_INET) ill = ILL_START_WALK_V4(&ctx); else if (family == AF_INET6) ill = ILL_START_WALK_V6(&ctx); else ill = ILL_START_WALK_ALL(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if ((ipif->ipif_flags & IPIF_NOXMIT) && !(lifn_flags & LIFC_NOXMIT)) continue; if ((ipif->ipif_flags & IPIF_TEMPORARY) && !(lifn_flags & LIFC_TEMPORARY)) continue; if (((ipif->ipif_flags & (IPIF_NOXMIT|IPIF_NOLOCAL| IPIF_DEPRECATED)) || (ill->ill_phyint->phyint_flags & PHYI_LOOPBACK) || !(ipif->ipif_flags & IPIF_UP)) && (lifn_flags & LIFC_EXTERNAL_SOURCE)) continue; if (zoneid != ipif->ipif_zoneid && (zoneid != GLOBAL_ZONEID || !(lifn_flags & LIFC_ALLZONES))) continue; numifs++; } } rw_exit(&ill_g_lock); return (numifs); } uint_t ip_get_lifsrcofnum(ill_t *ill) { uint_t numifs = 0; ill_t *ill_head = ill; /* * ill_g_usesrc_lock protects ill_usesrc_grp_next, for example, some * other thread may be trying to relink the ILLs in this usesrc group * and adjusting the ill_usesrc_grp_next pointers */ rw_enter(&ill_g_usesrc_lock, RW_READER); if ((ill->ill_usesrc_ifindex == 0) && (ill->ill_usesrc_grp_next != NULL)) { for (; (ill != NULL) && (ill->ill_usesrc_grp_next != ill_head); ill = ill->ill_usesrc_grp_next) numifs++; } rw_exit(&ill_g_usesrc_lock); return (numifs); } /* Null values are passed in for ipif, sin, and ifreq */ /* ARGSUSED */ int ip_sioctl_get_ifnum(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { int *nump; ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */ /* Existence of b_cont->b_cont checked in ip_wput_nondata */ nump = (int *)mp->b_cont->b_cont->b_rptr; *nump = ip_get_numifs(Q_TO_CONN(q)->conn_zoneid); ip1dbg(("ip_sioctl_get_ifnum numifs %d", *nump)); return (0); } /* Null values are passed in for ipif, sin, and ifreq */ /* ARGSUSED */ int ip_sioctl_get_lifnum(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifnum *lifn; mblk_t *mp1; ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */ /* Existence checked in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; lifn = (struct lifnum *)mp1->b_rptr; switch (lifn->lifn_family) { case AF_UNSPEC: case AF_INET: case AF_INET6: break; default: return (EAFNOSUPPORT); } lifn->lifn_count = ip_get_numlifs(lifn->lifn_family, lifn->lifn_flags, Q_TO_CONN(q)->conn_zoneid); ip1dbg(("ip_sioctl_get_lifnum numifs %d", lifn->lifn_count)); return (0); } /* ARGSUSED */ int ip_sioctl_get_ifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { STRUCT_HANDLE(ifconf, ifc); mblk_t *mp1; struct iocblk *iocp; struct ifreq *ifr; ill_walk_context_t ctx; ill_t *ill; ipif_t *ipif; struct sockaddr_in *sin; int32_t ifclen; zoneid_t zoneid; ASSERT(q->q_next == NULL); /* not valid ioctls for ip as a module */ ip1dbg(("ip_sioctl_get_ifconf")); /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; iocp = (struct iocblk *)mp->b_rptr; zoneid = Q_TO_CONN(q)->conn_zoneid; /* * The original SIOCGIFCONF passed in a struct ifconf which specified * the user buffer address and length into which the list of struct * ifreqs was to be copied. Since AT&T Streams does not seem to * allow M_COPYOUT to be used in conjunction with I_STR IOCTLS, * the SIOCGIFCONF operation was redefined to simply provide * a large output buffer into which we are supposed to jam the ifreq * array. The same ioctl command code was used, despite the fact that * both the applications and the kernel code had to change, thus making * it impossible to support both interfaces. * * For reasons not good enough to try to explain, the following * algorithm is used for deciding what to do with one of these: * If the IOCTL comes in as an I_STR, it is assumed to be of the new * form with the output buffer coming down as the continuation message. * If it arrives as a TRANSPARENT IOCTL, it is assumed to be old style, * and we have to copy in the ifconf structure to find out how big the * output buffer is and where to copy out to. Sure no problem... * */ STRUCT_SET_HANDLE(ifc, iocp->ioc_flag, NULL); if ((mp1->b_wptr - mp1->b_rptr) == STRUCT_SIZE(ifc)) { int numifs = 0; size_t ifc_bufsize; /* * Must be (better be!) continuation of a TRANSPARENT * IOCTL. We just copied in the ifconf structure. */ STRUCT_SET_HANDLE(ifc, iocp->ioc_flag, (struct ifconf *)mp1->b_rptr); /* * Allocate a buffer to hold requested information. * * If ifc_len is larger than what is needed, we only * allocate what we will use. * * If ifc_len is smaller than what is needed, return * EINVAL. * * XXX: the ill_t structure can hava 2 counters, for * v4 and v6 (not just ill_ipif_up_count) to store the * number of interfaces for a device, so we don't need * to count them here... */ numifs = ip_get_numifs(zoneid); ifclen = STRUCT_FGET(ifc, ifc_len); ifc_bufsize = numifs * sizeof (struct ifreq); if (ifc_bufsize > ifclen) { if (iocp->ioc_cmd == O_SIOCGIFCONF) { /* old behaviour */ return (EINVAL); } else { ifc_bufsize = ifclen; } } mp1 = mi_copyout_alloc(q, mp, STRUCT_FGETP(ifc, ifc_buf), ifc_bufsize, B_FALSE); if (mp1 == NULL) return (ENOMEM); mp1->b_wptr = mp1->b_rptr + ifc_bufsize; } bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr); /* * the SIOCGIFCONF ioctl only knows about * IPv4 addresses, so don't try to tell * it about interfaces with IPv6-only * addresses. (Last parm 'isv6' is B_FALSE) */ ifr = (struct ifreq *)mp1->b_rptr; rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) { if (zoneid != ipif->ipif_zoneid) continue; if ((uchar_t *)&ifr[1] > mp1->b_wptr) { if (iocp->ioc_cmd == O_SIOCGIFCONF) { /* old behaviour */ rw_exit(&ill_g_lock); return (EINVAL); } else { goto if_copydone; } } (void) ipif_get_name(ipif, ifr->ifr_name, sizeof (ifr->ifr_name)); sin = (sin_t *)&ifr->ifr_addr; *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_lcl_addr; ifr++; } } if_copydone: rw_exit(&ill_g_lock); mp1->b_wptr = (uchar_t *)ifr; if (STRUCT_BUF(ifc) != NULL) { STRUCT_FSET(ifc, ifc_len, (int)((uchar_t *)ifr - mp1->b_rptr)); } return (0); } /* * Get the interfaces using the address hosted on the interface passed in, * as a source adddress */ /* ARGSUSED */ int ip_sioctl_get_lifsrcof(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { mblk_t *mp1; ill_t *ill, *ill_head; ipif_t *ipif, *orig_ipif; int numlifs = 0; size_t lifs_bufsize, lifsmaxlen; struct lifreq *lifr; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; uint_t ifindex; zoneid_t zoneid; int err = 0; boolean_t isv6 = B_FALSE; struct sockaddr_in *sin; struct sockaddr_in6 *sin6; STRUCT_HANDLE(lifsrcof, lifs); ASSERT(q->q_next == NULL); zoneid = Q_TO_CONN(q)->conn_zoneid; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; /* * Must be (better be!) continuation of a TRANSPARENT * IOCTL. We just copied in the lifsrcof structure. */ STRUCT_SET_HANDLE(lifs, iocp->ioc_flag, (struct lifsrcof *)mp1->b_rptr); if (MBLKL(mp1) != STRUCT_SIZE(lifs)) return (EINVAL); ifindex = STRUCT_FGET(lifs, lifs_ifindex); isv6 = (Q_TO_CONN(q))->conn_af_isv6; ipif = ipif_lookup_on_ifindex(ifindex, isv6, zoneid, q, mp, ip_process_ioctl, &err); if (ipif == NULL) { ip1dbg(("ip_sioctl_get_lifsrcof: no ipif for ifindex %d\n", ifindex)); return (err); } /* Allocate a buffer to hold requested information */ numlifs = ip_get_lifsrcofnum(ipif->ipif_ill); lifs_bufsize = numlifs * sizeof (struct lifreq); lifsmaxlen = STRUCT_FGET(lifs, lifs_maxlen); /* The actual size needed is always returned in lifs_len */ STRUCT_FSET(lifs, lifs_len, lifs_bufsize); /* If the amount we need is more than what is passed in, abort */ if (lifs_bufsize > lifsmaxlen || lifs_bufsize == 0) { ipif_refrele(ipif); return (0); } mp1 = mi_copyout_alloc(q, mp, STRUCT_FGETP(lifs, lifs_buf), lifs_bufsize, B_FALSE); if (mp1 == NULL) { ipif_refrele(ipif); return (ENOMEM); } mp1->b_wptr = mp1->b_rptr + lifs_bufsize; bzero(mp1->b_rptr, lifs_bufsize); lifr = (struct lifreq *)mp1->b_rptr; ill = ill_head = ipif->ipif_ill; orig_ipif = ipif; /* ill_g_usesrc_lock protects ill_usesrc_grp_next */ rw_enter(&ill_g_usesrc_lock, RW_READER); rw_enter(&ill_g_lock, RW_READER); ill = ill->ill_usesrc_grp_next; /* start from next ill */ for (; (ill != NULL) && (ill != ill_head); ill = ill->ill_usesrc_grp_next) { if ((uchar_t *)&lifr[1] > mp1->b_wptr) break; ipif = ill->ill_ipif; (void) ipif_get_name(ipif, lifr->lifr_name, sizeof (lifr->lifr_name)); if (ipif->ipif_isv6) { sin6 = (sin6_t *)&lifr->lifr_addr; *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6lcl_addr; lifr->lifr_addrlen = ip_mask_to_plen_v6( &ipif->ipif_v6net_mask); } else { sin = (sin_t *)&lifr->lifr_addr; *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_lcl_addr; lifr->lifr_addrlen = ip_mask_to_plen( ipif->ipif_net_mask); } lifr++; } rw_exit(&ill_g_usesrc_lock); rw_exit(&ill_g_lock); ipif_refrele(orig_ipif); mp1->b_wptr = (uchar_t *)lifr; STRUCT_FSET(lifs, lifs_len, (int)((uchar_t *)lifr - mp1->b_rptr)); return (0); } /* ARGSUSED */ int ip_sioctl_get_lifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { mblk_t *mp1; int list; ill_t *ill; ipif_t *ipif; int flags; int numlifs = 0; size_t lifc_bufsize; struct lifreq *lifr; sa_family_t family; struct sockaddr_in *sin; struct sockaddr_in6 *sin6; ill_walk_context_t ctx; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; int32_t lifclen; zoneid_t zoneid; STRUCT_HANDLE(lifconf, lifc); ip1dbg(("ip_sioctl_get_lifconf")); ASSERT(q->q_next == NULL); zoneid = Q_TO_CONN(q)->conn_zoneid; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; /* * An extended version of SIOCGIFCONF that takes an * additional address family and flags field. * AF_UNSPEC retrieve both IPv4 and IPv6. * Unless LIFC_NOXMIT is specified the IPIF_NOXMIT * interfaces are omitted. * Similarly, IPIF_TEMPORARY interfaces are omitted * unless LIFC_TEMPORARY is specified. * If LIFC_EXTERNAL_SOURCE is specified, IPIF_NOXMIT, * IPIF_NOLOCAL, PHYI_LOOPBACK, IPIF_DEPRECATED and * not IPIF_UP interfaces are omitted. LIFC_EXTERNAL_SOURCE * has priority over LIFC_NOXMIT. */ STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, NULL); if ((mp1->b_wptr - mp1->b_rptr) != STRUCT_SIZE(lifc)) return (EINVAL); /* * Must be (better be!) continuation of a TRANSPARENT * IOCTL. We just copied in the lifconf structure. */ STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, (struct lifconf *)mp1->b_rptr); family = STRUCT_FGET(lifc, lifc_family); flags = STRUCT_FGET(lifc, lifc_flags); switch (family) { case AF_UNSPEC: /* * walk all ILL's. */ list = MAX_G_HEADS; break; case AF_INET: /* * walk only IPV4 ILL's. */ list = IP_V4_G_HEAD; break; case AF_INET6: /* * walk only IPV6 ILL's. */ list = IP_V6_G_HEAD; break; default: return (EAFNOSUPPORT); } /* * Allocate a buffer to hold requested information. * * If lifc_len is larger than what is needed, we only * allocate what we will use. * * If lifc_len is smaller than what is needed, return * EINVAL. */ numlifs = ip_get_numlifs(family, flags, zoneid); lifc_bufsize = numlifs * sizeof (struct lifreq); lifclen = STRUCT_FGET(lifc, lifc_len); if (lifc_bufsize > lifclen) { if (iocp->ioc_cmd == O_SIOCGLIFCONF) return (EINVAL); else lifc_bufsize = lifclen; } mp1 = mi_copyout_alloc(q, mp, STRUCT_FGETP(lifc, lifc_buf), lifc_bufsize, B_FALSE); if (mp1 == NULL) return (ENOMEM); mp1->b_wptr = mp1->b_rptr + lifc_bufsize; bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr); lifr = (struct lifreq *)mp1->b_rptr; rw_enter(&ill_g_lock, RW_READER); ill = ill_first(list, list, &ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if ((ipif->ipif_flags & IPIF_NOXMIT) && !(flags & LIFC_NOXMIT)) continue; if ((ipif->ipif_flags & IPIF_TEMPORARY) && !(flags & LIFC_TEMPORARY)) continue; if (((ipif->ipif_flags & (IPIF_NOXMIT|IPIF_NOLOCAL| IPIF_DEPRECATED)) || (ill->ill_phyint->phyint_flags & PHYI_LOOPBACK) || !(ipif->ipif_flags & IPIF_UP)) && (flags & LIFC_EXTERNAL_SOURCE)) continue; if (zoneid != ipif->ipif_zoneid && (zoneid != GLOBAL_ZONEID || !(flags & LIFC_ALLZONES))) continue; if ((uchar_t *)&lifr[1] > mp1->b_wptr) { if (iocp->ioc_cmd == O_SIOCGLIFCONF) { rw_exit(&ill_g_lock); return (EINVAL); } else { goto lif_copydone; } } (void) ipif_get_name(ipif, lifr->lifr_name, sizeof (lifr->lifr_name)); if (ipif->ipif_isv6) { sin6 = (sin6_t *)&lifr->lifr_addr; *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6lcl_addr; lifr->lifr_addrlen = ip_mask_to_plen_v6( &ipif->ipif_v6net_mask); } else { sin = (sin_t *)&lifr->lifr_addr; *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_lcl_addr; lifr->lifr_addrlen = ip_mask_to_plen( ipif->ipif_net_mask); } lifr++; } } lif_copydone: rw_exit(&ill_g_lock); mp1->b_wptr = (uchar_t *)lifr; if (STRUCT_BUF(lifc) != NULL) { STRUCT_FSET(lifc, lifc_len, (int)((uchar_t *)lifr - mp1->b_rptr)); } return (0); } /* ARGSUSED */ int ip_sioctl_set_ipmpfailback(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { /* Existence of b_cont->b_cont checked in ip_wput_nondata */ ipmp_enable_failback = *(int *)mp->b_cont->b_cont->b_rptr; return (0); } static void ip_sioctl_ip6addrpolicy(queue_t *q, mblk_t *mp) { ip6_asp_t *table; size_t table_size; mblk_t *data_mp; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; /* These two ioctls are I_STR only */ if (iocp->ioc_count == TRANSPARENT) { miocnak(q, mp, 0, EINVAL); return; } data_mp = mp->b_cont; if (data_mp == NULL) { /* The user passed us a NULL argument */ table = NULL; table_size = iocp->ioc_count; } else { /* * The user provided a table. The stream head * may have copied in the user data in chunks, * so make sure everything is pulled up * properly. */ if (MBLKL(data_mp) < iocp->ioc_count) { mblk_t *new_data_mp; if ((new_data_mp = msgpullup(data_mp, -1)) == NULL) { miocnak(q, mp, 0, ENOMEM); return; } freemsg(data_mp); data_mp = new_data_mp; mp->b_cont = data_mp; } table = (ip6_asp_t *)data_mp->b_rptr; table_size = iocp->ioc_count; } switch (iocp->ioc_cmd) { case SIOCGIP6ADDRPOLICY: iocp->ioc_rval = ip6_asp_get(table, table_size); if (iocp->ioc_rval == -1) iocp->ioc_error = EINVAL; #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4 else if (table != NULL && (iocp->ioc_flag & IOC_MODELS) == IOC_ILP32) { ip6_asp_t *src = table; ip6_asp32_t *dst = (void *)table; int count = table_size / sizeof (ip6_asp_t); int i; /* * We need to do an in-place shrink of the array * to match the alignment attributes of the * 32-bit ABI looking at it. */ /* LINTED: logical expression always true: op "||" */ ASSERT(sizeof (*src) > sizeof (*dst)); for (i = 1; i < count; i++) bcopy(src + i, dst + i, sizeof (*dst)); } #endif break; case SIOCSIP6ADDRPOLICY: ASSERT(mp->b_prev == NULL); mp->b_prev = (void *)q; #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4 /* * We pass in the datamodel here so that the ip6_asp_replace() * routine can handle converting from 32-bit to native formats * where necessary. * * A better way to handle this might be to convert the inbound * data structure here, and hang it off a new 'mp'; thus the * ip6_asp_replace() logic would always be dealing with native * format data structures.. * * (An even simpler way to handle these ioctls is to just * add a 32-bit trailing 'pad' field to the ip6_asp_t structure * and just recompile everything that depends on it.) */ #endif ip6_asp_replace(mp, table, table_size, B_FALSE, iocp->ioc_flag & IOC_MODELS); return; } DB_TYPE(mp) = (iocp->ioc_error == 0) ? M_IOCACK : M_IOCNAK; qreply(q, mp); } static void ip_sioctl_dstinfo(queue_t *q, mblk_t *mp) { mblk_t *data_mp; struct dstinforeq *dir; uint8_t *end, *cur; in6_addr_t *daddr, *saddr; ipaddr_t v4daddr; ire_t *ire; char *slabel, *dlabel; boolean_t isipv4; int match_ire; ill_t *dst_ill; ipif_t *src_ipif, *ire_ipif; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; zoneid_t zoneid; ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */ zoneid = Q_TO_CONN(q)->conn_zoneid; /* * This ioctl is I_STR only, and must have a * data mblk following the M_IOCTL mblk. */ data_mp = mp->b_cont; if (iocp->ioc_count == TRANSPARENT || data_mp == NULL) { miocnak(q, mp, 0, EINVAL); return; } if (MBLKL(data_mp) < iocp->ioc_count) { mblk_t *new_data_mp; if ((new_data_mp = msgpullup(data_mp, -1)) == NULL) { miocnak(q, mp, 0, ENOMEM); return; } freemsg(data_mp); data_mp = new_data_mp; mp->b_cont = data_mp; } match_ire = MATCH_IRE_RECURSIVE | MATCH_IRE_DEFAULT | MATCH_IRE_PARENT; for (cur = data_mp->b_rptr, end = data_mp->b_wptr; end - cur >= sizeof (struct dstinforeq); cur += sizeof (struct dstinforeq)) { dir = (struct dstinforeq *)cur; daddr = &dir->dir_daddr; saddr = &dir->dir_saddr; /* * ip_addr_scope_v6() and ip6_asp_lookup() handle * v4 mapped addresses; ire_ftable_lookup[_v6]() * and ipif_select_source[_v6]() do not. */ dir->dir_dscope = ip_addr_scope_v6(daddr); dlabel = ip6_asp_lookup(daddr, &dir->dir_precedence); isipv4 = IN6_IS_ADDR_V4MAPPED(daddr); if (isipv4) { IN6_V4MAPPED_TO_IPADDR(daddr, v4daddr); ire = ire_ftable_lookup(v4daddr, NULL, NULL, 0, NULL, NULL, zoneid, 0, match_ire); } else { ire = ire_ftable_lookup_v6(daddr, NULL, NULL, 0, NULL, NULL, zoneid, 0, match_ire); } if (ire == NULL) { dir->dir_dreachable = 0; /* move on to next dst addr */ continue; } dir->dir_dreachable = 1; ire_ipif = ire->ire_ipif; if (ire_ipif == NULL) goto next_dst; /* * We expect to get back an interface ire or a * gateway ire cache entry. For both types, the * output interface is ire_ipif->ipif_ill. */ dst_ill = ire_ipif->ipif_ill; dir->dir_dmactype = dst_ill->ill_mactype; if (isipv4) { src_ipif = ipif_select_source(dst_ill, v4daddr, zoneid); } else { src_ipif = ipif_select_source_v6(dst_ill, daddr, B_FALSE, IPV6_PREFER_SRC_DEFAULT, zoneid); } if (src_ipif == NULL) goto next_dst; *saddr = src_ipif->ipif_v6lcl_addr; dir->dir_sscope = ip_addr_scope_v6(saddr); slabel = ip6_asp_lookup(saddr, NULL); dir->dir_labelmatch = ip6_asp_labelcmp(dlabel, slabel); dir->dir_sdeprecated = (src_ipif->ipif_flags & IPIF_DEPRECATED) ? 1 : 0; ipif_refrele(src_ipif); next_dst: ire_refrele(ire); } miocack(q, mp, iocp->ioc_count, 0); } /* * Check if this is an address assigned to this machine. * Skips interfaces that are down by using ire checks. * Translates mapped addresses to v4 addresses and then * treats them as such, returning true if the v4 address * associated with this mapped address is configured. * Note: Applications will have to be careful what they do * with the response; use of mapped addresses limits * what can be done with the socket, especially with * respect to socket options and ioctls - neither IPv4 * options nor IPv6 sticky options/ancillary data options * may be used. */ /* ARGSUSED */ int ip_sioctl_tmyaddr(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { struct sioc_addrreq *sia; sin_t *sin; ire_t *ire; mblk_t *mp1; zoneid_t zoneid; ip1dbg(("ip_sioctl_tmyaddr")); ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */ zoneid = Q_TO_CONN(q)->conn_zoneid; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; sia = (struct sioc_addrreq *)mp1->b_rptr; sin = (sin_t *)&sia->sa_addr; switch (sin->sin_family) { case AF_INET6: { sin6_t *sin6 = (sin6_t *)sin; if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { ipaddr_t v4_addr; IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr, v4_addr); ire = ire_ctable_lookup(v4_addr, 0, IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY); } else { in6_addr_t v6addr; v6addr = sin6->sin6_addr; ire = ire_ctable_lookup_v6(&v6addr, 0, IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY); } break; } case AF_INET: { ipaddr_t v4addr; v4addr = sin->sin_addr.s_addr; ire = ire_ctable_lookup(v4addr, 0, IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY); break; } default: return (EAFNOSUPPORT); } if (ire != NULL) { sia->sa_res = 1; ire_refrele(ire); } else { sia->sa_res = 0; } return (0); } /* * Check if this is an address assigned on-link i.e. neighbor, * and makes sure it's reachable from the current zone. * Returns true for my addresses as well. * Translates mapped addresses to v4 addresses and then * treats them as such, returning true if the v4 address * associated with this mapped address is configured. * Note: Applications will have to be careful what they do * with the response; use of mapped addresses limits * what can be done with the socket, especially with * respect to socket options and ioctls - neither IPv4 * options nor IPv6 sticky options/ancillary data options * may be used. */ /* ARGSUSED */ int ip_sioctl_tonlink(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *duymmy_ifreq) { struct sioc_addrreq *sia; sin_t *sin; mblk_t *mp1; ire_t *ire = NULL; zoneid_t zoneid; ip1dbg(("ip_sioctl_tonlink")); ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */ zoneid = Q_TO_CONN(q)->conn_zoneid; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; sia = (struct sioc_addrreq *)mp1->b_rptr; sin = (sin_t *)&sia->sa_addr; /* * Match addresses with a zero gateway field to avoid * routes going through a router. * Exclude broadcast and multicast addresses. */ switch (sin->sin_family) { case AF_INET6: { sin6_t *sin6 = (sin6_t *)sin; if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { ipaddr_t v4_addr; IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr, v4_addr); if (!CLASSD(v4_addr)) { ire = ire_route_lookup(v4_addr, 0, 0, 0, NULL, NULL, zoneid, MATCH_IRE_GW); } } else { in6_addr_t v6addr; in6_addr_t v6gw; v6addr = sin6->sin6_addr; v6gw = ipv6_all_zeros; if (!IN6_IS_ADDR_MULTICAST(&v6addr)) { ire = ire_route_lookup_v6(&v6addr, 0, &v6gw, 0, NULL, NULL, zoneid, MATCH_IRE_GW); } } break; } case AF_INET: { ipaddr_t v4addr; v4addr = sin->sin_addr.s_addr; if (!CLASSD(v4addr)) { ire = ire_route_lookup(v4addr, 0, 0, 0, NULL, NULL, zoneid, MATCH_IRE_GW); } break; } default: return (EAFNOSUPPORT); } sia->sa_res = 0; if (ire != NULL) { if (ire->ire_type & (IRE_INTERFACE|IRE_CACHE| IRE_LOCAL|IRE_LOOPBACK)) { sia->sa_res = 1; } ire_refrele(ire); } return (0); } /* * TBD: implement when kernel maintaines a list of site prefixes. */ /* ARGSUSED */ int ip_sioctl_tmysite(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { return (ENXIO); } /* ARGSUSED */ int ip_sioctl_tunparam(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { ill_t *ill; mblk_t *mp1; conn_t *connp; boolean_t success; ip1dbg(("ip_sioctl_tunparam(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* ioctl comes down on an conn */ ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL); connp = Q_TO_CONN(q); mp->b_datap->db_type = M_IOCTL; /* * Send down a copy. (copymsg does not copy b_next/b_prev). * The original mp contains contaminated b_next values due to 'mi', * which is needed to do the mi_copy_done. Unfortunately if we * send down the original mblk itself and if we are popped due to an * an unplumb before the response comes back from tunnel, * the streamhead (which does a freemsg) will see this contaminated * message and the assertion in freemsg about non-null b_next/b_prev * will panic a DEBUG kernel. */ mp1 = copymsg(mp); if (mp1 == NULL) return (ENOMEM); ill = ipif->ipif_ill; mutex_enter(&connp->conn_lock); mutex_enter(&ill->ill_lock); if (ipip->ipi_cmd == SIOCSTUNPARAM || ipip->ipi_cmd == OSIOCSTUNPARAM) { success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp, 0); } else { success = ill_pending_mp_add(ill, connp, mp); } mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); if (success) { ip1dbg(("sending down tunparam request ")); putnext(ill->ill_wq, mp1); return (EINPROGRESS); } else { /* The conn has started closing */ freemsg(mp1); return (EINTR); } } static int ip_sioctl_arp_common(ill_t *ill, queue_t *q, mblk_t *mp, sin_t *sin, boolean_t x_arp_ioctl, boolean_t if_arp_ioctl) { mblk_t *mp1; mblk_t *mp2; mblk_t *pending_mp; ipaddr_t ipaddr; area_t *area; struct iocblk *iocp; conn_t *connp; struct arpreq *ar; struct xarpreq *xar; boolean_t success; int flags, alength; char *lladdr; ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL); connp = Q_TO_CONN(q); iocp = (struct iocblk *)mp->b_rptr; /* * ill has already been set depending on whether * bsd style or interface style ioctl. */ ASSERT(ill != NULL); /* * Is this one of the new SIOC*XARP ioctls? */ if (x_arp_ioctl) { /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->XARPREQ_MBLK */ xar = (struct xarpreq *)mp->b_cont->b_cont->b_rptr; ar = NULL; flags = xar->xarp_flags; lladdr = LLADDR(&xar->xarp_ha); /* * Validate against user's link layer address length * input and name and addr length limits. */ alength = ill->ill_phys_addr_length; if (iocp->ioc_cmd == SIOCSXARP) { if (alength != xar->xarp_ha.sdl_alen || (alength + xar->xarp_ha.sdl_nlen > sizeof (xar->xarp_ha.sdl_data))) return (EINVAL); } } else { /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->ARPREQ_MBLK */ ar = (struct arpreq *)mp->b_cont->b_cont->b_rptr; xar = NULL; flags = ar->arp_flags; lladdr = ar->arp_ha.sa_data; /* * Theoretically, the sa_family could tell us what link * layer type this operation is trying to deal with. By * common usage AF_UNSPEC means ethernet. We'll assume * any attempt to use the SIOC?ARP ioctls is for ethernet, * for now. Our new SIOC*XARP ioctls can be used more * generally. * * If the underlying media happens to have a non 6 byte * address, arp module will fail set/get, but the del * operation will succeed. */ alength = 6; if ((iocp->ioc_cmd != SIOCDARP) && (alength != ill->ill_phys_addr_length)) { return (EINVAL); } } /* * We are going to pass up to ARP a packet chain that looks * like: * * M_IOCTL-->ARP_op_MBLK-->ORIG_M_IOCTL-->MI_COPY_MBLK-->[X]ARPREQ_MBLK * * Get a copy of the original IOCTL mblk to head the chain, * to be sent up (in mp1). Also get another copy to store * in the ill_pending_mp list, for matching the response * when it comes back from ARP. */ mp1 = copyb(mp); pending_mp = copymsg(mp); if (mp1 == NULL || pending_mp == NULL) { if (mp1 != NULL) freeb(mp1); if (pending_mp != NULL) inet_freemsg(pending_mp); return (ENOMEM); } ipaddr = sin->sin_addr.s_addr; mp2 = ill_arp_alloc(ill, (uchar_t *)&ip_area_template, (caddr_t)&ipaddr); if (mp2 == NULL) { freeb(mp1); inet_freemsg(pending_mp); return (ENOMEM); } /* Put together the chain. */ mp1->b_cont = mp2; mp1->b_datap->db_type = M_IOCTL; mp2->b_cont = mp; mp2->b_datap->db_type = M_DATA; iocp = (struct iocblk *)mp1->b_rptr; /* * An M_IOCDATA's payload (struct copyresp) is mostly the same as an * M_IOCTL's payload (struct iocblk), but 'struct copyresp' has a * cp_private field (or cp_rval on 32-bit systems) in place of the * ioc_count field; set ioc_count to be correct. */ iocp->ioc_count = MBLKL(mp1->b_cont); /* * Set the proper command in the ARP message. * Convert the SIOC{G|S|D}ARP calls into our * AR_ENTRY_xxx calls. */ area = (area_t *)mp2->b_rptr; switch (iocp->ioc_cmd) { case SIOCDARP: case SIOCDXARP: /* * We defer deleting the corresponding IRE until * we return from arp. */ area->area_cmd = AR_ENTRY_DELETE; area->area_proto_mask_offset = 0; break; case SIOCGARP: case SIOCGXARP: area->area_cmd = AR_ENTRY_SQUERY; area->area_proto_mask_offset = 0; break; case SIOCSARP: case SIOCSXARP: { /* * Delete the corresponding ire to make sure IP will * pick up any change from arp. */ if (!if_arp_ioctl) { (void) ip_ire_clookup_and_delete(ipaddr, NULL); break; } else { ipif_t *ipif = ipif_get_next_ipif(NULL, ill); if (ipif != NULL) { (void) ip_ire_clookup_and_delete(ipaddr, ipif); ipif_refrele(ipif); } break; } } } iocp->ioc_cmd = area->area_cmd; /* * Before sending 'mp' to ARP, we have to clear the b_next * and b_prev. Otherwise if STREAMS encounters such a message * in freemsg(), (because ARP can close any time) it can cause * a panic. But mi code needs the b_next and b_prev values of * mp->b_cont, to complete the ioctl. So we store it here * in pending_mp->bcont, and restore it in ip_sioctl_iocack() * when the response comes down from ARP. */ pending_mp->b_cont->b_next = mp->b_cont->b_next; pending_mp->b_cont->b_prev = mp->b_cont->b_prev; mp->b_cont->b_next = NULL; mp->b_cont->b_prev = NULL; mutex_enter(&connp->conn_lock); mutex_enter(&ill->ill_lock); /* conn has not yet started closing, hence this can't fail */ success = ill_pending_mp_add(ill, connp, pending_mp); ASSERT(success); mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); /* * Fill in the rest of the ARP operation fields. */ area->area_hw_addr_length = alength; bcopy(lladdr, (char *)area + area->area_hw_addr_offset, area->area_hw_addr_length); /* Translate the flags. */ if (flags & ATF_PERM) area->area_flags |= ACE_F_PERMANENT; if (flags & ATF_PUBL) area->area_flags |= ACE_F_PUBLISH; /* * Up to ARP it goes. The response will come * back in ip_wput as an M_IOCACK message, and * will be handed to ip_sioctl_iocack for * completion. */ putnext(ill->ill_rq, mp1); return (EINPROGRESS); } /* ARGSUSED */ int ip_sioctl_xarp(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct xarpreq *xar; boolean_t isv6; mblk_t *mp1; int err; conn_t *connp; int ifnamelen; ire_t *ire = NULL; ill_t *ill = NULL; struct sockaddr_in *sin; boolean_t if_arp_ioctl = B_FALSE; /* ioctl comes down on an conn */ ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL); connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; /* Existance verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; ASSERT(MBLKL(mp1) >= sizeof (*xar)); xar = (struct xarpreq *)mp1->b_rptr; sin = (sin_t *)&xar->xarp_pa; if (isv6 || (xar->xarp_ha.sdl_family != AF_LINK) || (xar->xarp_pa.ss_family != AF_INET)) return (ENXIO); ifnamelen = xar->xarp_ha.sdl_nlen; if (ifnamelen != 0) { char *cptr, cval; if (ifnamelen >= LIFNAMSIZ) return (EINVAL); /* * Instead of bcopying a bunch of bytes, * null-terminate the string in-situ. */ cptr = xar->xarp_ha.sdl_data + ifnamelen; cval = *cptr; *cptr = '\0'; ill = ill_lookup_on_name(xar->xarp_ha.sdl_data, B_FALSE, isv6, CONNP_TO_WQ(connp), mp, ip_process_ioctl, &err, NULL); *cptr = cval; if (ill == NULL) return (err); if (ill->ill_net_type != IRE_IF_RESOLVER) { ill_refrele(ill); return (ENXIO); } if_arp_ioctl = B_TRUE; } else { /* * PSARC 2003/088 states that if sdl_nlen == 0, it behaves * as an extended BSD ioctl. The kernel uses the IP address * to figure out the network interface. */ ire = ire_cache_lookup(sin->sin_addr.s_addr, ALL_ZONES); if ((ire == NULL) || (ire->ire_type == IRE_LOOPBACK) || ((ill = ire_to_ill(ire)) == NULL) || (ill->ill_net_type != IRE_IF_RESOLVER)) { if (ire != NULL) ire_refrele(ire); ire = ire_ftable_lookup(sin->sin_addr.s_addr, 0, 0, IRE_IF_RESOLVER, NULL, NULL, ALL_ZONES, 0, MATCH_IRE_TYPE); if ((ire == NULL) || ((ill = ire_to_ill(ire)) == NULL)) { if (ire != NULL) ire_refrele(ire); return (ENXIO); } } ASSERT(ire != NULL && ill != NULL); } err = ip_sioctl_arp_common(ill, q, mp, sin, B_TRUE, if_arp_ioctl); if (if_arp_ioctl) ill_refrele(ill); if (ire != NULL) ire_refrele(ire); return (err); } /* * ARP IOCTLs. * How does IP get in the business of fronting ARP configuration/queries? * Well its like this, the Berkeley ARP IOCTLs (SIOCGARP, SIOCDARP, SIOCSARP) * are by tradition passed in through a datagram socket. That lands in IP. * As it happens, this is just as well since the interface is quite crude in * that it passes in no information about protocol or hardware types, or * interface association. After making the protocol assumption, IP is in * the position to look up the name of the ILL, which ARP will need, and * format a request that can be handled by ARP. The request is passed up * stream to ARP, and the original IOCTL is completed by IP when ARP passes * back a response. ARP supports its own set of more general IOCTLs, in * case anyone is interested. */ /* ARGSUSED */ int ip_sioctl_arp(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { struct arpreq *ar; struct sockaddr_in *sin; ire_t *ire; boolean_t isv6; mblk_t *mp1; int err; conn_t *connp; ill_t *ill; /* ioctl comes down on an conn */ ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL); connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; if (isv6) return (ENXIO); /* Existance verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; ar = (struct arpreq *)mp1->b_rptr; sin = (sin_t *)&ar->arp_pa; /* * We need to let ARP know on which interface the IP * address has an ARP mapping. In the IPMP case, a * simple forwarding table lookup will return the * IRE_IF_RESOLVER for the first interface in the group, * which might not be the interface on which the * requested IP address was resolved due to the ill * selection algorithm (see ip_newroute_get_dst_ill()). * So we do a cache table lookup first: if the IRE cache * entry for the IP address is still there, it will * contain the ill pointer for the right interface, so * we use that. If the cache entry has been flushed, we * fall back to the forwarding table lookup. This should * be rare enough since IRE cache entries have a longer * life expectancy than ARP cache entries. */ ire = ire_cache_lookup(sin->sin_addr.s_addr, ALL_ZONES); if ((ire == NULL) || (ire->ire_type == IRE_LOOPBACK) || ((ill = ire_to_ill(ire)) == NULL)) { if (ire != NULL) ire_refrele(ire); ire = ire_ftable_lookup(sin->sin_addr.s_addr, 0, 0, IRE_IF_RESOLVER, NULL, NULL, ALL_ZONES, 0, MATCH_IRE_TYPE); if ((ire == NULL) || ((ill = ire_to_ill(ire)) == NULL)) { if (ire != NULL) ire_refrele(ire); return (ENXIO); } } ASSERT(ire != NULL && ill != NULL); err = ip_sioctl_arp_common(ill, q, mp, sin, B_FALSE, B_FALSE); ire_refrele(ire); return (err); } /* * Do I_PLINK/I_LINK or I_PUNLINK/I_UNLINK with consistency checks and also * atomically set/clear the muxids. Also complete the ioctl by acking or * naking it. Note that the code is structured such that the link type, * whether it's persistent or not, is treated equally. ifconfig(1M) and * its clones use the persistent link, while pppd(1M) and perhaps many * other daemons may use non-persistent link. When combined with some * ill_t states, linking and unlinking lower streams may be used as * indicators of dynamic re-plumbing events [see PSARC/1999/348]. */ /* ARGSUSED */ void ip_sioctl_plink(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg) { mblk_t *mp1; mblk_t *mp2; struct linkblk *li; queue_t *ipwq; char *name; struct qinit *qinfo; struct ipmx_s *ipmxp; ill_t *ill = NULL; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; int err = 0; boolean_t entered_ipsq = B_FALSE; boolean_t islink; queue_t *dwq = NULL; ASSERT(iocp->ioc_cmd == I_PLINK || iocp->ioc_cmd == I_PUNLINK || iocp->ioc_cmd == I_LINK || iocp->ioc_cmd == I_UNLINK); islink = (iocp->ioc_cmd == I_PLINK || iocp->ioc_cmd == I_LINK) ? B_TRUE : B_FALSE; mp1 = mp->b_cont; /* This is the linkblk info */ li = (struct linkblk *)mp1->b_rptr; /* * ARP has added this special mblk, and the utility is asking us * to perform consistency checks, and also atomically set the * muxid. Ifconfig is an example. It achieves this by using * /dev/arp as the mux to plink the arp stream, and pushes arp on * to /dev/udp[6] stream for use as the mux when plinking the IP * stream. SIOCSLIFMUXID is not required. See ifconfig.c, arp.c * and other comments in this routine for more details. */ mp2 = mp1->b_cont; /* This is added by ARP */ /* * If I_{P}LINK/I_{P}UNLINK is issued by a utility other than * ifconfig which didn't push ARP on top of the dummy mux, we won't * get the special mblk above. For backward compatibility, we just * return success. The utility will use SIOCSLIFMUXID to store * the muxids. This is not atomic, and can leave the streams * unplumbable if the utility is interrrupted, before it does the * SIOCSLIFMUXID. */ if (mp2 == NULL) { /* * At this point we don't know whether or not this is the * IP module stream or the ARP device stream. We need to * walk the lower stream in order to find this out, since * the capability negotiation is done only on the IP module * stream. IP module instance is identified by the module * name IP, non-null q_next, and it's wput not being ip_lwput. * STREAMS ensures that the lower stream (l_qbot) will not * vanish until this ioctl completes. So we can safely walk * the stream or refer to the q_ptr. */ ipwq = li->l_qbot; while (ipwq != NULL) { qinfo = ipwq->q_qinfo; name = qinfo->qi_minfo->mi_idname; if (name != NULL && name[0] != NULL && (strcmp(name, ip_mod_info.mi_idname) == 0) && ((void *)(qinfo->qi_putp) != (void *)ip_lwput) && (ipwq->q_next != NULL)) { break; } ipwq = ipwq->q_next; } /* * This looks like an IP module stream, so trigger * the capability reset or re-negotiation if necessary. */ if (ipwq != NULL) { ill = ipwq->q_ptr; ASSERT(ill != NULL); if (ipsq == NULL) { ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink, NEW_OP, B_TRUE); if (ipsq == NULL) return; entered_ipsq = B_TRUE; } ASSERT(IAM_WRITER_ILL(ill)); /* * Store the upper read queue of the module * immediately below IP, and count the total * number of lower modules. Do this only * for I_PLINK or I_LINK event. */ ill->ill_lmod_rq = NULL; ill->ill_lmod_cnt = 0; if (islink && (dwq = ipwq->q_next) != NULL) { ill->ill_lmod_rq = RD(dwq); while (dwq != NULL) { ill->ill_lmod_cnt++; dwq = dwq->q_next; } } /* * There's no point in resetting or re-negotiating if * we are not bound to the driver, so only do this if * the DLPI state is idle (up); we assume such state * since ill_ipif_up_count gets incremented in * ipif_up_done(), which is after we are bound to the * driver. Note that in the case of logical * interfaces, IP won't rebind to the driver unless * the ill_ipif_up_count is 0, meaning that all other * IP interfaces (including the main ipif) are in the * down state. Because of this, we use such counter * as an indicator, instead of relying on the IPIF_UP * flag, which is per ipif instance. */ if (ill->ill_ipif_up_count > 0) { if (islink) ill_capability_probe(ill); else ill_capability_reset(ill); } } goto done; } /* * This is an I_{P}LINK sent down by ifconfig on * /dev/arp. ARP has appended this last (3rd) mblk, * giving more info. STREAMS ensures that the lower * stream (l_qbot) will not vanish until this ioctl * completes. So we can safely walk the stream or refer * to the q_ptr. */ ipmxp = (struct ipmx_s *)mp2->b_rptr; if (ipmxp->ipmx_arpdev_stream) { /* * The operation is occuring on the arp-device * stream. */ ill = ill_lookup_on_name(ipmxp->ipmx_name, B_FALSE, B_FALSE, q, mp, ip_sioctl_plink, &err, NULL); if (ill == NULL) { if (err == EINPROGRESS) { return; } else { err = EINVAL; goto done; } } if (ipsq == NULL) { ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink, NEW_OP, B_TRUE); if (ipsq == NULL) { ill_refrele(ill); return; } entered_ipsq = B_TRUE; } ASSERT(IAM_WRITER_ILL(ill)); ill_refrele(ill); /* * To ensure consistency between IP and ARP, * the following LIFO scheme is used in * plink/punlink. (IP first, ARP last). * This is because the muxid's are stored * in the IP stream on the ill. * * I_{P}LINK: ifconfig plinks the IP stream before * plinking the ARP stream. On an arp-dev * stream, IP checks that it is not yet * plinked, and it also checks that the * corresponding IP stream is already plinked. * * I_{P}UNLINK: ifconfig punlinks the ARP stream * before punlinking the IP stream. IP does * not allow punlink of the IP stream unless * the arp stream has been punlinked. * */ if ((islink && (ill->ill_arp_muxid != 0 || ill->ill_ip_muxid == 0)) || (!islink && ill->ill_arp_muxid != li->l_index)) { err = EINVAL; goto done; } if (islink) { ill->ill_arp_muxid = li->l_index; } else { ill->ill_arp_muxid = 0; } } else { /* * This must be the IP module stream with or * without arp. Walk the stream and locate the * IP module. An IP module instance is * identified by the module name IP, non-null * q_next, and it's wput not being ip_lwput. */ ipwq = li->l_qbot; while (ipwq != NULL) { qinfo = ipwq->q_qinfo; name = qinfo->qi_minfo->mi_idname; if (name != NULL && name[0] != NULL && (strcmp(name, ip_mod_info.mi_idname) == 0) && ((void *)(qinfo->qi_putp) != (void *)ip_lwput) && (ipwq->q_next != NULL)) { break; } ipwq = ipwq->q_next; } if (ipwq != NULL) { ill = ipwq->q_ptr; ASSERT(ill != NULL); if (ipsq == NULL) { ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink, NEW_OP, B_TRUE); if (ipsq == NULL) return; entered_ipsq = B_TRUE; } ASSERT(IAM_WRITER_ILL(ill)); /* * Return error if the ip_mux_id is * non-zero and command is I_{P}LINK. * If command is I_{P}UNLINK, return * error if the arp-devstr is not * yet punlinked. */ if ((islink && ill->ill_ip_muxid != 0) || (!islink && ill->ill_arp_muxid != 0)) { err = EINVAL; goto done; } ill->ill_lmod_rq = NULL; ill->ill_lmod_cnt = 0; if (islink) { /* * Store the upper read queue of the module * immediately below IP, and count the total * number of lower modules. */ if ((dwq = ipwq->q_next) != NULL) { ill->ill_lmod_rq = RD(dwq); while (dwq != NULL) { ill->ill_lmod_cnt++; dwq = dwq->q_next; } } ill->ill_ip_muxid = li->l_index; } else { ill->ill_ip_muxid = 0; } /* * See comments above about resetting/re- * negotiating driver sub-capabilities. */ if (ill->ill_ipif_up_count > 0) { if (islink) ill_capability_probe(ill); else ill_capability_reset(ill); } } } done: iocp->ioc_count = 0; iocp->ioc_error = err; if (err == 0) mp->b_datap->db_type = M_IOCACK; else mp->b_datap->db_type = M_IOCNAK; qreply(q, mp); /* Conn was refheld in ip_sioctl_copyin_setup */ if (CONN_Q(q)) CONN_OPER_PENDING_DONE(Q_TO_CONN(q)); if (entered_ipsq) ipsq_exit(ipsq, B_TRUE, B_TRUE); } /* * Search the ioctl command in the ioctl tables and return a pointer * to the ioctl command information. The ioctl command tables are * static and fully populated at compile time. */ ip_ioctl_cmd_t * ip_sioctl_lookup(int ioc_cmd) { int index; ip_ioctl_cmd_t *ipip; ip_ioctl_cmd_t *ipip_end; if (ioc_cmd == IPI_DONTCARE) return (NULL); /* * Do a 2 step search. First search the indexed table * based on the least significant byte of the ioctl cmd. * If we don't find a match, then search the misc table * serially. */ index = ioc_cmd & 0xFF; if (index < ip_ndx_ioctl_count) { ipip = &ip_ndx_ioctl_table[index]; if (ipip->ipi_cmd == ioc_cmd) { /* Found a match in the ndx table */ return (ipip); } } /* Search the misc table */ ipip_end = &ip_misc_ioctl_table[ip_misc_ioctl_count]; for (ipip = ip_misc_ioctl_table; ipip < ipip_end; ipip++) { if (ipip->ipi_cmd == ioc_cmd) /* Found a match in the misc table */ return (ipip); } return (NULL); } /* * Wrapper function for resuming deferred ioctl processing * Used for SIOCGDSTINFO, SIOCGIP6ADDRPOLICY, SIOCGMSFILTER, * SIOCSMSFILTER, SIOCGIPMSFILTER, and SIOCSIPMSFILTER currently. */ /* ARGSUSED */ void ip_sioctl_copyin_resume(ipsq_t *dummy_ipsq, queue_t *q, mblk_t *mp, void *dummy_arg) { ip_sioctl_copyin_setup(q, mp); } /* * ip_sioctl_copyin_setup is called by ip_wput with any M_IOCTL message * that arrives. Most of the IOCTLs are "socket" IOCTLs which we handle * in either I_STR or TRANSPARENT form, using the mi_copy facility. * We establish here the size of the block to be copied in. mi_copyin * arranges for this to happen, an processing continues in ip_wput with * an M_IOCDATA message. */ void ip_sioctl_copyin_setup(queue_t *q, mblk_t *mp) { int copyin_size; struct iocblk *iocp = (struct iocblk *)mp->b_rptr; ip_ioctl_cmd_t *ipip; cred_t *cr; ipip = ip_sioctl_lookup(iocp->ioc_cmd); if (ipip == NULL) { /* * The ioctl is not one we understand or own. * Pass it along to be processed down stream, * if this is a module instance of IP, else nak * the ioctl. */ if (q->q_next == NULL) { goto nak; } else { putnext(q, mp); return; } } /* * If this is deferred, then we will do all the checks when we * come back. */ if ((iocp->ioc_cmd == SIOCGDSTINFO || iocp->ioc_cmd == SIOCGIP6ADDRPOLICY) && !ip6_asp_can_lookup()) { ip6_asp_pending_op(q, mp, ip_sioctl_copyin_resume); return; } /* * Only allow a very small subset of IP ioctls on this stream if * IP is a module and not a driver. Allowing ioctls to be processed * in this case may cause assert failures or data corruption. * Typically G[L]IFFLAGS, SLIFNAME/IF_UNITSEL are the only few * ioctls allowed on an IP module stream, after which this stream * normally becomes a multiplexor (at which time the stream head * will fail all ioctls). */ if ((q->q_next != NULL) && !(ipip->ipi_flags & IPI_MODOK)) { if (ipip->ipi_flags & IPI_PASS_DOWN) { /* * Pass common Streams ioctls which the IP * module does not own or consume along to * be processed down stream. */ putnext(q, mp); return; } else { goto nak; } } /* Make sure we have ioctl data to process. */ if (mp->b_cont == NULL && !(ipip->ipi_flags & IPI_NULL_BCONT)) goto nak; /* * Prefer dblk credential over ioctl credential; some synthesized * ioctls have kcred set because there's no way to crhold() * a credential in some contexts. (ioc_cr is not crfree() by * the framework; the caller of ioctl needs to hold the reference * for the duration of the call). */ cr = DB_CREDDEF(mp, iocp->ioc_cr); /* Make sure normal users don't send down privileged ioctls */ if ((ipip->ipi_flags & IPI_PRIV) && (cr != NULL) && secpolicy_net_config(cr, B_TRUE) != 0) { /* We checked the privilege earlier but log it here */ miocnak(q, mp, 0, secpolicy_net_config(cr, B_FALSE)); return; } /* * The ioctl command tables can only encode fixed length * ioctl data. If the length is variable, the table will * encode the length as zero. Such special cases are handled * below in the switch. */ if (ipip->ipi_copyin_size != 0) { mi_copyin(q, mp, NULL, ipip->ipi_copyin_size); return; } switch (iocp->ioc_cmd) { case O_SIOCGIFCONF: case SIOCGIFCONF: /* * This IOCTL is hilarious. See comments in * ip_sioctl_get_ifconf for the story. */ if (iocp->ioc_count == TRANSPARENT) copyin_size = SIZEOF_STRUCT(ifconf, iocp->ioc_flag); else copyin_size = iocp->ioc_count; mi_copyin(q, mp, NULL, copyin_size); return; case O_SIOCGLIFCONF: case SIOCGLIFCONF: copyin_size = SIZEOF_STRUCT(lifconf, iocp->ioc_flag); mi_copyin(q, mp, NULL, copyin_size); return; case SIOCGLIFSRCOF: copyin_size = SIZEOF_STRUCT(lifsrcof, iocp->ioc_flag); mi_copyin(q, mp, NULL, copyin_size); return; case SIOCGIP6ADDRPOLICY: ip_sioctl_ip6addrpolicy(q, mp); ip6_asp_table_refrele(); return; case SIOCSIP6ADDRPOLICY: ip_sioctl_ip6addrpolicy(q, mp); return; case SIOCGDSTINFO: ip_sioctl_dstinfo(q, mp); ip6_asp_table_refrele(); return; case I_PLINK: case I_PUNLINK: case I_LINK: case I_UNLINK: /* * We treat non-persistent link similarly as the persistent * link case, in terms of plumbing/unplumbing, as well as * dynamic re-plumbing events indicator. See comments * in ip_sioctl_plink() for more. * * Request can be enqueued in the 'ipsq' while waiting * to become exclusive. So bump up the conn ref. */ if (CONN_Q(q)) CONN_INC_REF(Q_TO_CONN(q)); ip_sioctl_plink(NULL, q, mp, NULL); return; case ND_GET: case ND_SET: /* * Use of the nd table requires holding the reader lock. * Modifying the nd table thru nd_load/nd_unload requires * the writer lock. */ rw_enter(&ip_g_nd_lock, RW_READER); if (nd_getset(q, ip_g_nd, mp)) { rw_exit(&ip_g_nd_lock); if (iocp->ioc_error) iocp->ioc_count = 0; mp->b_datap->db_type = M_IOCACK; qreply(q, mp); return; } rw_exit(&ip_g_nd_lock); /* * We don't understand this subioctl of ND_GET / ND_SET. * Maybe intended for some driver / module below us */ if (q->q_next) { putnext(q, mp); } else { iocp->ioc_error = ENOENT; mp->b_datap->db_type = M_IOCNAK; iocp->ioc_count = 0; qreply(q, mp); } return; case IP_IOCTL: ip_wput_ioctl(q, mp); return; default: cmn_err(CE_PANIC, "should not happen "); } nak: if (mp->b_cont != NULL) { freemsg(mp->b_cont); mp->b_cont = NULL; } iocp->ioc_error = EINVAL; mp->b_datap->db_type = M_IOCNAK; iocp->ioc_count = 0; qreply(q, mp); } /* ip_wput hands off ARP IOCTL responses to us */ void ip_sioctl_iocack(queue_t *q, mblk_t *mp) { struct arpreq *ar; struct xarpreq *xar; area_t *area; mblk_t *area_mp; struct iocblk *iocp; mblk_t *orig_ioc_mp, *tmp; struct iocblk *orig_iocp; ill_t *ill; conn_t *connp = NULL; uint_t ioc_id; mblk_t *pending_mp; int x_arp_ioctl = B_FALSE, ifx_arp_ioctl = B_FALSE; int *flagsp; char *storage = NULL; sin_t *sin; ipaddr_t addr; int err; ill = q->q_ptr; ASSERT(ill != NULL); /* * We should get back from ARP a packet chain that looks like: * M_IOCACK-->ARP_op_MBLK-->ORIG_M_IOCTL-->MI_COPY_MBLK-->[X]ARPREQ_MBLK */ if (!(area_mp = mp->b_cont) || (area_mp->b_wptr - area_mp->b_rptr) < sizeof (ip_sock_ar_t) || !(orig_ioc_mp = area_mp->b_cont) || !orig_ioc_mp->b_cont || !orig_ioc_mp->b_cont->b_cont) { freemsg(mp); return; } orig_iocp = (struct iocblk *)orig_ioc_mp->b_rptr; tmp = (orig_ioc_mp->b_cont)->b_cont; if ((orig_iocp->ioc_cmd == SIOCGXARP) || (orig_iocp->ioc_cmd == SIOCSXARP) || (orig_iocp->ioc_cmd == SIOCDXARP)) { x_arp_ioctl = B_TRUE; xar = (struct xarpreq *)tmp->b_rptr; sin = (sin_t *)&xar->xarp_pa; flagsp = &xar->xarp_flags; storage = xar->xarp_ha.sdl_data; if (xar->xarp_ha.sdl_nlen != 0) ifx_arp_ioctl = B_TRUE; } else { ar = (struct arpreq *)tmp->b_rptr; sin = (sin_t *)&ar->arp_pa; flagsp = &ar->arp_flags; storage = ar->arp_ha.sa_data; } iocp = (struct iocblk *)mp->b_rptr; /* * Pick out the originating queue based on the ioc_id. */ ioc_id = iocp->ioc_id; pending_mp = ill_pending_mp_get(ill, &connp, ioc_id); if (pending_mp == NULL) { ASSERT(connp == NULL); inet_freemsg(mp); return; } ASSERT(connp != NULL); q = CONNP_TO_WQ(connp); /* Uncouple the internally generated IOCTL from the original one */ area = (area_t *)area_mp->b_rptr; area_mp->b_cont = NULL; /* * Restore the b_next and b_prev used by mi code. This is needed * to complete the ioctl using mi* functions. We stored them in * the pending mp prior to sending the request to ARP. */ orig_ioc_mp->b_cont->b_next = pending_mp->b_cont->b_next; orig_ioc_mp->b_cont->b_prev = pending_mp->b_cont->b_prev; inet_freemsg(pending_mp); /* * We're done if there was an error or if this is not an SIOCG{X}ARP * Catch the case where there is an IRE_CACHE by no entry in the * arp table. */ addr = sin->sin_addr.s_addr; if (iocp->ioc_error && iocp->ioc_cmd == AR_ENTRY_SQUERY) { ire_t *ire; dl_unitdata_req_t *dlup; mblk_t *llmp; int addr_len; ill_t *ipsqill = NULL; if (ifx_arp_ioctl) { /* * There's no need to lookup the ill, since * we've already done that when we started * processing the ioctl and sent the message * to ARP on that ill. So use the ill that * is stored in q->q_ptr. */ ipsqill = ill; ire = ire_ctable_lookup(addr, 0, IRE_CACHE, ipsqill->ill_ipif, ALL_ZONES, MATCH_IRE_TYPE | MATCH_IRE_ILL); } else { ire = ire_ctable_lookup(addr, 0, IRE_CACHE, NULL, ALL_ZONES, MATCH_IRE_TYPE); if (ire != NULL) ipsqill = ire_to_ill(ire); } if ((x_arp_ioctl) && (ipsqill != NULL)) storage += ill_xarp_info(&xar->xarp_ha, ipsqill); if (ire != NULL) { *flagsp = ATF_INUSE; llmp = ire->ire_dlureq_mp; if (llmp != NULL && ipsqill != NULL) { uchar_t *macaddr; addr_len = ipsqill->ill_phys_addr_length; if (x_arp_ioctl && ((addr_len + ipsqill->ill_name_length) > sizeof (xar->xarp_ha.sdl_data))) { ire_refrele(ire); freemsg(mp); ip_ioctl_finish(q, orig_ioc_mp, EINVAL, NO_COPYOUT, NULL, NULL); return; } *flagsp |= ATF_COM; dlup = (dl_unitdata_req_t *)llmp->b_rptr; if (ipsqill->ill_sap_length < 0) macaddr = llmp->b_rptr + dlup->dl_dest_addr_offset; else macaddr = llmp->b_rptr + dlup->dl_dest_addr_offset + ipsqill->ill_sap_length; /* * For SIOCGARP, MAC address length * validation has already been done * before the ioctl was issued to ARP to * allow it to progress only on 6 byte * addressable (ethernet like) media. Thus * the mac address copying can not overwrite * the sa_data area below. */ bcopy(macaddr, storage, addr_len); } /* Ditch the internal IOCTL. */ freemsg(mp); ire_refrele(ire); ip_ioctl_finish(q, orig_ioc_mp, 0, COPYOUT, NULL, NULL); return; } } /* * Delete the coresponding IRE_CACHE if any. * Reset the error if there was one (in case there was no entry * in arp.) */ if (iocp->ioc_cmd == AR_ENTRY_DELETE) { ipif_t *ipintf = NULL; if (ifx_arp_ioctl) { /* * There's no need to lookup the ill, since * we've already done that when we started * processing the ioctl and sent the message * to ARP on that ill. So use the ill that * is stored in q->q_ptr. */ ipintf = ill->ill_ipif; } if (ip_ire_clookup_and_delete(addr, ipintf)) { /* * The address in "addr" may be an entry for a * router. If that's true, then any off-net * IRE_CACHE entries that go through the router * with address "addr" must be clobbered. Use * ire_walk to achieve this goal. */ if (ifx_arp_ioctl) ire_walk_ill_v4(MATCH_IRE_ILL, 0, ire_delete_cache_gw, (char *)&addr, ill); else ire_walk_v4(ire_delete_cache_gw, (char *)&addr, ALL_ZONES); iocp->ioc_error = 0; } } if (iocp->ioc_error || iocp->ioc_cmd != AR_ENTRY_SQUERY) { err = iocp->ioc_error; freemsg(mp); ip_ioctl_finish(q, orig_ioc_mp, err, NO_COPYOUT, NULL, NULL); return; } /* * Completion of an SIOCG{X}ARP. Translate the information from * the area_t into the struct {x}arpreq. */ if (x_arp_ioctl) { storage += ill_xarp_info(&xar->xarp_ha, ill); if ((ill->ill_phys_addr_length + ill->ill_name_length) > sizeof (xar->xarp_ha.sdl_data)) { freemsg(mp); ip_ioctl_finish(q, orig_ioc_mp, EINVAL, NO_COPYOUT, NULL, NULL); return; } } *flagsp = ATF_INUSE; if (area->area_flags & ACE_F_PERMANENT) *flagsp |= ATF_PERM; if (area->area_flags & ACE_F_PUBLISH) *flagsp |= ATF_PUBL; if (area->area_hw_addr_length != 0) { *flagsp |= ATF_COM; /* * For SIOCGARP, MAC address length validation has * already been done before the ioctl was issued to ARP * to allow it to progress only on 6 byte addressable * (ethernet like) media. Thus the mac address copying * can not overwrite the sa_data area below. */ bcopy((char *)area + area->area_hw_addr_offset, storage, area->area_hw_addr_length); } /* Ditch the internal IOCTL. */ freemsg(mp); /* Complete the original. */ ip_ioctl_finish(q, orig_ioc_mp, 0, COPYOUT, NULL, NULL); } /* * Create a new logical interface. If ipif_id is zero (i.e. not a logical * interface) create the next available logical interface for this * physical interface. * If ipif is NULL (i.e. the lookup didn't find one) attempt to create an * ipif with the specified name. * * If the address family is not AF_UNSPEC then set the address as well. * * If ip_sioctl_addr returns EINPROGRESS then the ioctl (the copyout) * is completed when the DL_BIND_ACK arrive in ip_rput_dlpi_writer. * * Executed as a writer on the ill or ill group. * So no lock is needed to traverse the ipif chain, or examine the * phyint flags. */ /* ARGSUSED */ int ip_sioctl_addif(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq) { mblk_t *mp1; struct lifreq *lifr; boolean_t isv6; boolean_t exists; char *name; char *endp; char *cp; int namelen; ipif_t *ipif; long id; ipsq_t *ipsq; ill_t *ill; sin_t *sin; int err = 0; boolean_t found_sep = B_FALSE; conn_t *connp; zoneid_t zoneid; int orig_ifindex = 0; ip1dbg(("ip_sioctl_addif\n")); /* Existence of mp1 has been checked in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; /* * Null terminate the string to protect against buffer * overrun. String was generated by user code and may not * be trusted. */ lifr = (struct lifreq *)mp1->b_rptr; lifr->lifr_name[LIFNAMSIZ - 1] = '\0'; name = lifr->lifr_name; ASSERT(CONN_Q(q)); connp = Q_TO_CONN(q); isv6 = connp->conn_af_isv6; zoneid = connp->conn_zoneid; namelen = mi_strlen(name); if (namelen == 0) return (EINVAL); exists = B_FALSE; if ((namelen + 1 == sizeof (ipif_loopback_name)) && (mi_strcmp(name, ipif_loopback_name) == 0)) { /* * Allow creating lo0 using SIOCLIFADDIF. * can't be any other writer thread. So can pass null below * for the last 4 args to ipif_lookup_name. */ ipif = ipif_lookup_on_name(lifr->lifr_name, namelen, B_TRUE, &exists, isv6, zoneid, NULL, NULL, NULL, NULL); /* Prevent any further action */ if (ipif == NULL) { return (ENOBUFS); } else if (!exists) { /* We created the ipif now and as writer */ ipif_refrele(ipif); return (0); } else { ill = ipif->ipif_ill; ill_refhold(ill); ipif_refrele(ipif); } } else { /* Look for a colon in the name. */ endp = &name[namelen]; for (cp = endp; --cp > name; ) { if (*cp == IPIF_SEPARATOR_CHAR) { found_sep = B_TRUE; /* * Reject any non-decimal aliases for plumbing * of logical interfaces. Aliases with leading * zeroes are also rejected as they introduce * ambiguity in the naming of the interfaces. * Comparing with "0" takes care of all such * cases. */ if ((strncmp("0", cp+1, 1)) == 0) return (EINVAL); if (ddi_strtol(cp+1, &endp, 10, &id) != 0 || id <= 0 || *endp != '\0') { return (EINVAL); } *cp = '\0'; break; } } ill = ill_lookup_on_name(name, B_FALSE, isv6, CONNP_TO_WQ(connp), mp, ip_process_ioctl, &err, NULL); if (found_sep) *cp = IPIF_SEPARATOR_CHAR; if (ill == NULL) return (err); } ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_process_ioctl, NEW_OP, B_TRUE); /* * Release the refhold due to the lookup, now that we are excl * or we are just returning */ ill_refrele(ill); if (ipsq == NULL) return (EINPROGRESS); /* * If the interface is failed, inactive or offlined, look for a working * interface in the ill group and create the ipif there. If we can't * find a good interface, create the ipif anyway so that in.mpathd can * move it to the first repaired interface. */ if ((ill->ill_phyint->phyint_flags & (PHYI_FAILED|PHYI_INACTIVE|PHYI_OFFLINE)) && ill->ill_phyint->phyint_groupname_len != 0) { phyint_t *phyi; char *groupname = ill->ill_phyint->phyint_groupname; /* * We're looking for a working interface, but it doesn't matter * if it's up or down; so instead of following the group lists, * we look at each physical interface and compare the groupname. * We're only interested in interfaces with IPv4 (resp. IPv6) * plumbed when we're adding an IPv4 (resp. IPv6) ipif. * Otherwise we create the ipif on the failed interface. */ rw_enter(&ill_g_lock, RW_READER); phyi = avl_first(&phyint_g_list.phyint_list_avl_by_index); for (; phyi != NULL; phyi = avl_walk(&phyint_g_list.phyint_list_avl_by_index, phyi, AVL_AFTER)) { if (phyi->phyint_groupname_len == 0) continue; ASSERT(phyi->phyint_groupname != NULL); if (mi_strcmp(groupname, phyi->phyint_groupname) == 0 && !(phyi->phyint_flags & (PHYI_FAILED|PHYI_INACTIVE|PHYI_OFFLINE)) && (ill->ill_isv6 ? (phyi->phyint_illv6 != NULL) : (phyi->phyint_illv4 != NULL))) { break; } } rw_exit(&ill_g_lock); if (phyi != NULL) { orig_ifindex = ill->ill_phyint->phyint_ifindex; ill = (ill->ill_isv6 ? phyi->phyint_illv6 : phyi->phyint_illv4); } } /* * We are now exclusive on the ipsq, so an ill move will be serialized * before or after us. */ ASSERT(IAM_WRITER_ILL(ill)); ASSERT(ill->ill_move_in_progress == B_FALSE); if (found_sep && orig_ifindex == 0) { /* Now see if there is an IPIF with this unit number. */ for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) { if (ipif->ipif_id == id) { err = EEXIST; goto done; } } } /* * We use IRE_LOCAL for lo0:1 etc. for "receive only" use * of lo0. We never come here when we plumb lo0:0. It * happens in ipif_lookup_on_name. * The specified unit number is ignored when we create the ipif on a * different interface. However, we save it in ipif_orig_ipifid below so * that the ipif fails back to the right position. */ if ((ipif = ipif_allocate(ill, (found_sep && orig_ifindex == 0) ? id : -1, IRE_LOCAL, B_TRUE)) == NULL) { err = ENOBUFS; goto done; } /* Return created name with ioctl */ (void) sprintf(lifr->lifr_name, "%s%c%d", ill->ill_name, IPIF_SEPARATOR_CHAR, ipif->ipif_id); ip1dbg(("created %s\n", lifr->lifr_name)); /* Set address */ sin = (sin_t *)&lifr->lifr_addr; if (sin->sin_family != AF_UNSPEC) { err = ip_sioctl_addr(ipif, sin, q, mp, &ip_ndx_ioctl_table[SIOCLIFADDR_NDX], lifr); } /* Set ifindex and unit number for failback */ if (err == 0 && orig_ifindex != 0) { ipif->ipif_orig_ifindex = orig_ifindex; if (found_sep) { ipif->ipif_orig_ipifid = id; } } done: ipsq_exit(ipsq, B_TRUE, B_TRUE); return (err); } /* * Remove an existing logical interface. If ipif_id is zero (i.e. not a logical * interface) delete it based on the IP address (on this physical interface). * Otherwise delete it based on the ipif_id. * Also, special handling to allow a removeif of lo0. */ /* ARGSUSED */ int ip_sioctl_removeif(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req) { conn_t *connp; ill_t *ill = ipif->ipif_ill; boolean_t success; ip1dbg(("ip_sioctl_remove_if(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); connp = Q_TO_CONN(q); /* * Special case for unplumbing lo0 (the loopback physical interface). * If unplumbing lo0, the incoming address structure has been * initialized to all zeros. When unplumbing lo0, all its logical * interfaces must be removed too. * * Note that this interface may be called to remove a specific * loopback logical interface (eg, lo0:1). But in that case * ipif->ipif_id != 0 so that the code path for that case is the * same as any other interface (meaning it skips the code directly * below). */ if (ipif->ipif_id == 0 && ipif->ipif_net_type == IRE_LOOPBACK) { if (sin->sin_family == AF_UNSPEC && (IN6_IS_ADDR_UNSPECIFIED(&((sin6_t *)sin)->sin6_addr))) { /* * Mark it condemned. No new ref. will be made to ill. */ mutex_enter(&ill->ill_lock); ill->ill_state_flags |= ILL_CONDEMNED; for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { ipif->ipif_state_flags |= IPIF_CONDEMNED; } mutex_exit(&ill->ill_lock); ipif = ill->ill_ipif; /* unplumb the loopback interface */ ill_delete(ill); mutex_enter(&connp->conn_lock); mutex_enter(&ill->ill_lock); ASSERT(ill->ill_group == NULL); /* Are any references to this ill active */ if (ill_is_quiescent(ill)) { mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); ill_delete_tail(ill); mi_free(ill); return (0); } success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp, ILL_FREE); mutex_exit(&connp->conn_lock); mutex_exit(&ill->ill_lock); if (success) return (EINPROGRESS); else return (EINTR); } } /* * We are exclusive on the ipsq, so an ill move will be serialized * before or after us. */ ASSERT(ill->ill_move_in_progress == B_FALSE); if (ipif->ipif_id == 0) { /* Find based on address */ if (ipif->ipif_isv6) { sin6_t *sin6; if (sin->sin_family != AF_INET6) return (EAFNOSUPPORT); sin6 = (sin6_t *)sin; /* We are a writer, so we should be able to lookup */ ipif = ipif_lookup_addr_v6(&sin6->sin6_addr, ill, ALL_ZONES, NULL, NULL, NULL, NULL); if (ipif == NULL) { /* * Maybe the address in on another interface in * the same IPMP group? We check this below. */ ipif = ipif_lookup_addr_v6(&sin6->sin6_addr, NULL, ALL_ZONES, NULL, NULL, NULL, NULL); } } else { ipaddr_t addr; if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); addr = sin->sin_addr.s_addr; /* We are a writer, so we should be able to lookup */ ipif = ipif_lookup_addr(addr, ill, ALL_ZONES, NULL, NULL, NULL, NULL); if (ipif == NULL) { /* * Maybe the address in on another interface in * the same IPMP group? We check this below. */ ipif = ipif_lookup_addr(addr, NULL, ALL_ZONES, NULL, NULL, NULL, NULL); } } if (ipif == NULL) { return (EADDRNOTAVAIL); } /* * When the address to be removed is hosted on a different * interface, we check if the interface is in the same IPMP * group as the specified one; if so we proceed with the * removal. * ill->ill_group is NULL when the ill is down, so we have to * compare the group names instead. */ if (ipif->ipif_ill != ill && (ipif->ipif_ill->ill_phyint->phyint_groupname_len == 0 || ill->ill_phyint->phyint_groupname_len == 0 || mi_strcmp(ipif->ipif_ill->ill_phyint->phyint_groupname, ill->ill_phyint->phyint_groupname) != 0)) { ipif_refrele(ipif); return (EADDRNOTAVAIL); } /* This is a writer */ ipif_refrele(ipif); } /* * Can not delete instance zero since it is tied to the ill. */ if (ipif->ipif_id == 0) return (EBUSY); mutex_enter(&ill->ill_lock); ipif->ipif_state_flags |= IPIF_CONDEMNED; mutex_exit(&ill->ill_lock); ipif_free(ipif); mutex_enter(&connp->conn_lock); mutex_enter(&ill->ill_lock); /* Are any references to this ipif active */ if (ipif->ipif_refcnt == 0 && ipif->ipif_ire_cnt == 0) { mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); ipif_down_tail(ipif); ipif_free_tail(ipif); return (0); } success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp, IPIF_FREE); mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); if (success) return (EINPROGRESS); else return (EINTR); } /* * Restart the removeif ioctl. The refcnt has gone down to 0. * The ipif is already condemned. So can't find it thru lookups. */ /* ARGSUSED */ int ip_sioctl_removeif_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req) { ill_t *ill; ip1dbg(("ip_sioctl_removeif_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipif->ipif_id == 0 && ipif->ipif_net_type == IRE_LOOPBACK) { ill = ipif->ipif_ill; ASSERT(IAM_WRITER_ILL(ill)); ASSERT((ipif->ipif_state_flags & IPIF_CONDEMNED) && (ill->ill_state_flags & IPIF_CONDEMNED)); ill_delete_tail(ill); mi_free(ill); return (0); } ill = ipif->ipif_ill; ASSERT(IAM_WRITER_IPIF(ipif)); ASSERT(ipif->ipif_state_flags & IPIF_CONDEMNED); ipif_down_tail(ipif); ipif_free_tail(ipif); ILL_UNMARK_CHANGING(ill); return (0); } /* * Set the local interface address. * Allow an address of all zero when the interface is down. */ /* ARGSUSED */ int ip_sioctl_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq) { int err = 0; in6_addr_t v6addr; boolean_t need_up = B_FALSE; ip1dbg(("ip_sioctl_addr(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); if (ipif->ipif_isv6) { sin6_t *sin6; ill_t *ill; phyint_t *phyi; if (sin->sin_family != AF_INET6) return (EAFNOSUPPORT); sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; ill = ipif->ipif_ill; phyi = ill->ill_phyint; /* * Enforce that true multicast interfaces have a link-local * address for logical unit 0. */ if (ipif->ipif_id == 0 && (ill->ill_flags & ILLF_MULTICAST) && !(ipif->ipif_flags & (IPIF_POINTOPOINT)) && !(phyi->phyint_flags & (PHYI_LOOPBACK)) && !IN6_IS_ADDR_LINKLOCAL(&v6addr)) { return (EADDRNOTAVAIL); } /* * up interfaces shouldn't have the unspecified address * unless they also have the IPIF_NOLOCAL flags set and * have a subnet assigned. */ if ((ipif->ipif_flags & IPIF_UP) && IN6_IS_ADDR_UNSPECIFIED(&v6addr) && (!(ipif->ipif_flags & IPIF_NOLOCAL) || IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) { return (EADDRNOTAVAIL); } if (!ip_local_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask)) return (EADDRNOTAVAIL); } else { ipaddr_t addr; if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); addr = sin->sin_addr.s_addr; /* Allow 0 as the local address. */ if (addr != 0 && !ip_addr_ok_v4(addr, ipif->ipif_net_mask)) return (EADDRNOTAVAIL); IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); } /* * Even if there is no change we redo things just to rerun * ipif_set_default. */ if (ipif->ipif_flags & IPIF_UP) { /* * Setting a new local address, make sure * we have net and subnet bcast ire's for * the old address if we need them. */ if (!ipif->ipif_isv6) ipif_check_bcast_ires(ipif); /* * If the interface is already marked up, * we call ipif_down which will take care * of ditching any IREs that have been set * up based on the old interface address. */ err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); need_up = 1; } err = ip_sioctl_addr_tail(ipif, sin, q, mp, need_up); return (err); } int ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, boolean_t need_up) { in6_addr_t v6addr; ipaddr_t addr; sin6_t *sin6; int err = 0; ip1dbg(("ip_sioctl_addr_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); if (ipif->ipif_isv6) { sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; } else { addr = sin->sin_addr.s_addr; IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); } mutex_enter(&ipif->ipif_ill->ill_lock); ipif->ipif_v6lcl_addr = v6addr; if (ipif->ipif_flags & (IPIF_ANYCAST | IPIF_NOLOCAL)) { ipif->ipif_v6src_addr = ipv6_all_zeros; } else { ipif->ipif_v6src_addr = v6addr; } if ((ipif->ipif_isv6) && IN6_IS_ADDR_6TO4(&v6addr) && (!ipif->ipif_ill->ill_is_6to4tun)) { queue_t *wqp = ipif->ipif_ill->ill_wq; /* * The local address of this interface is a 6to4 address, * check if this interface is in fact a 6to4 tunnel or just * an interface configured with a 6to4 address. We are only * interested in the former. */ if (wqp != NULL) { while ((wqp->q_next != NULL) && (wqp->q_next->q_qinfo != NULL) && (wqp->q_next->q_qinfo->qi_minfo != NULL)) { if (wqp->q_next->q_qinfo->qi_minfo->mi_idnum == TUN6TO4_MODID) { /* set for use in IP */ ipif->ipif_ill->ill_is_6to4tun = 1; break; } wqp = wqp->q_next; } } } ipif_set_default(ipif); mutex_exit(&ipif->ipif_ill->ill_lock); if (need_up) { /* * Now bring the interface back up. If this * is the only IPIF for the ILL, ipif_up * will have to re-bind to the device, so * we may get back EINPROGRESS, in which * case, this IOCTL will get completed in * ip_rput_dlpi when we see the DL_BIND_ACK. */ err = ipif_up(ipif, q, mp); } else { /* * Update the IPIF list in SCTP, ipif_up_done() will do it * if need_up is true. */ sctp_update_ipif(ipif, SCTP_IPIF_UPDATE); } return (err); } /* * Restart entry point to restart the address set operation after the * refcounts have dropped to zero. */ /* ARGSUSED */ int ip_sioctl_addr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { ip1dbg(("ip_sioctl_addr_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); ipif_down_tail(ipif); return (ip_sioctl_addr_tail(ipif, sin, q, mp, B_TRUE)); } /* ARGSUSED */ int ip_sioctl_get_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { sin6_t *sin6 = (struct sockaddr_in6 *)sin; struct lifreq *lifr = (struct lifreq *)if_req; ip1dbg(("ip_sioctl_get_addr(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * The net mask and address can't change since we have a * reference to the ipif. So no lock is necessary. */ if (ipif->ipif_isv6) { *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6lcl_addr; ASSERT(ipip->ipi_cmd_type == LIF_CMD); lifr->lifr_addrlen = ip_mask_to_plen_v6(&ipif->ipif_v6net_mask); } else { *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_lcl_addr; if (ipip->ipi_cmd_type == LIF_CMD) { lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask); } } return (0); } /* * Set the destination address for a pt-pt interface. */ /* ARGSUSED */ int ip_sioctl_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int err = 0; in6_addr_t v6addr; boolean_t need_up = B_FALSE; ip1dbg(("ip_sioctl_dstaddr(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); if (ipif->ipif_isv6) { sin6_t *sin6; if (sin->sin_family != AF_INET6) return (EAFNOSUPPORT); sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; if (!ip_remote_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask)) return (EADDRNOTAVAIL); } else { ipaddr_t addr; if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); addr = sin->sin_addr.s_addr; if (!ip_addr_ok_v4(addr, ipif->ipif_net_mask)) return (EADDRNOTAVAIL); IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); } if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6pp_dst_addr, &v6addr)) return (0); /* No change */ if (ipif->ipif_flags & IPIF_UP) { /* * If the interface is already marked up, * we call ipif_down which will take care * of ditching any IREs that have been set * up based on the old pp dst address. */ err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); need_up = B_TRUE; } /* * could return EINPROGRESS. If so ioctl will complete in * ip_rput_dlpi_writer */ err = ip_sioctl_dstaddr_tail(ipif, sin, q, mp, need_up); return (err); } static int ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, boolean_t need_up) { in6_addr_t v6addr; ill_t *ill = ipif->ipif_ill; int err = 0; ip1dbg(("ip_sioctl_dstaddr_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipif->ipif_isv6) { sin6_t *sin6; sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; } else { ipaddr_t addr; addr = sin->sin_addr.s_addr; IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); } mutex_enter(&ill->ill_lock); /* Set point to point destination address. */ if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) { /* * Allow this as a means of creating logical * pt-pt interfaces on top of e.g. an Ethernet. * XXX Undocumented HACK for testing. * pt-pt interfaces are created with NUD disabled. */ ipif->ipif_flags |= IPIF_POINTOPOINT; ipif->ipif_flags &= ~IPIF_BROADCAST; if (ipif->ipif_isv6) ipif->ipif_ill->ill_flags |= ILLF_NONUD; } /* Set the new address. */ ipif->ipif_v6pp_dst_addr = v6addr; /* Make sure subnet tracks pp_dst */ ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr; mutex_exit(&ill->ill_lock); if (need_up) { /* * Now bring the interface back up. If this * is the only IPIF for the ILL, ipif_up * will have to re-bind to the device, so * we may get back EINPROGRESS, in which * case, this IOCTL will get completed in * ip_rput_dlpi when we see the DL_BIND_ACK. */ err = ipif_up(ipif, q, mp); } return (err); } /* * Restart entry point to restart the dstaddress set operation after the * refcounts have dropped to zero. */ /* ARGSUSED */ int ip_sioctl_dstaddr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { ip1dbg(("ip_sioctl_dstaddr_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ipif_down_tail(ipif); return (ip_sioctl_dstaddr_tail(ipif, sin, q, mp, B_TRUE)); } /* ARGSUSED */ int ip_sioctl_get_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { sin6_t *sin6 = (struct sockaddr_in6 *)sin; ip1dbg(("ip_sioctl_get_dstaddr(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * Get point to point destination address. The addresses can't * change since we hold a reference to the ipif. */ if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) return (EADDRNOTAVAIL); if (ipif->ipif_isv6) { ASSERT(ipip->ipi_cmd_type == LIF_CMD); *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6pp_dst_addr; } else { *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_pp_dst_addr; } return (0); } /* * part of ipmp, make this func return the active/inactive state and * caller can set once atomically instead of multiple mutex_enter/mutex_exit */ /* * This function either sets or clears the IFF_INACTIVE flag. * * As long as there are some addresses or multicast memberships on the * IPv4 or IPv6 interface of the "phyi" that does not belong in here, we * will consider it to be ACTIVE (clear IFF_INACTIVE) i.e the interface * will be used for outbound packets. * * Caller needs to verify the validity of setting IFF_INACTIVE. */ static void phyint_inactive(phyint_t *phyi) { ill_t *ill_v4; ill_t *ill_v6; ipif_t *ipif; ilm_t *ilm; ill_v4 = phyi->phyint_illv4; ill_v6 = phyi->phyint_illv6; /* * No need for a lock while traversing the list since iam * a writer */ if (ill_v4 != NULL) { ASSERT(IAM_WRITER_ILL(ill_v4)); for (ipif = ill_v4->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_orig_ifindex != phyi->phyint_ifindex) { mutex_enter(&phyi->phyint_lock); phyi->phyint_flags &= ~PHYI_INACTIVE; mutex_exit(&phyi->phyint_lock); return; } } for (ilm = ill_v4->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (ilm->ilm_orig_ifindex != phyi->phyint_ifindex) { mutex_enter(&phyi->phyint_lock); phyi->phyint_flags &= ~PHYI_INACTIVE; mutex_exit(&phyi->phyint_lock); return; } } } if (ill_v6 != NULL) { ill_v6 = phyi->phyint_illv6; for (ipif = ill_v6->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_orig_ifindex != phyi->phyint_ifindex) { mutex_enter(&phyi->phyint_lock); phyi->phyint_flags &= ~PHYI_INACTIVE; mutex_exit(&phyi->phyint_lock); return; } } for (ilm = ill_v6->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (ilm->ilm_orig_ifindex != phyi->phyint_ifindex) { mutex_enter(&phyi->phyint_lock); phyi->phyint_flags &= ~PHYI_INACTIVE; mutex_exit(&phyi->phyint_lock); return; } } } mutex_enter(&phyi->phyint_lock); phyi->phyint_flags |= PHYI_INACTIVE; mutex_exit(&phyi->phyint_lock); } /* * This function is called only when the phyint flags change. Currently * called from ip_sioctl_flags. We re-do the broadcast nomination so * that we can select a good ill. */ static void ip_redo_nomination(phyint_t *phyi) { ill_t *ill_v4; ill_v4 = phyi->phyint_illv4; if (ill_v4 != NULL && ill_v4->ill_group != NULL) { ASSERT(IAM_WRITER_ILL(ill_v4)); if (ill_v4->ill_group->illgrp_ill_count > 1) ill_nominate_bcast_rcv(ill_v4->ill_group); } } /* * Heuristic to check if ill is INACTIVE. * Checks if ill has an ipif with an usable ip address. * * Return values: * B_TRUE - ill is INACTIVE; has no usable ipif * B_FALSE - ill is not INACTIVE; ill has at least one usable ipif */ static boolean_t ill_is_inactive(ill_t *ill) { ipif_t *ipif; /* Check whether it is in an IPMP group */ if (ill->ill_phyint->phyint_groupname == NULL) return (B_FALSE); if (ill->ill_ipif_up_count == 0) return (B_TRUE); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { uint64_t flags = ipif->ipif_flags; /* * This ipif is usable if it is IPIF_UP and not a * dedicated test address. A dedicated test address * is marked IPIF_NOFAILOVER *and* IPIF_DEPRECATED * (note in particular that V6 test addresses are * link-local data addresses and thus are marked * IPIF_NOFAILOVER but not IPIF_DEPRECATED). */ if ((flags & IPIF_UP) && ((flags & (IPIF_DEPRECATED|IPIF_NOFAILOVER)) != (IPIF_DEPRECATED|IPIF_NOFAILOVER))) return (B_FALSE); } return (B_TRUE); } /* * Set interface flags. * Need to do special action for IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, * IPIF_NOLOCAL, ILLF_NONUD, ILLF_NOARP, IPIF_PRIVATE, IPIF_ANYCAST, * IPIF_PREFERRED, PHYI_STANDBY, PHYI_FAILED and PHYI_OFFLINE. * * NOTE : We really don't enforce that ipif_id zero should be used * for setting any flags other than IFF_LOGINT_FLAGS. This * is because applications generally does SICGLIFFLAGS and * ORs in the new flags (that affects the logical) and does a * SIOCSLIFFLAGS. Thus, "flags" below could contain bits other * than IFF_LOGINT_FLAGS. One could check whether "turn_on" - the * flags that will be turned on is correct with respect to * ipif_id 0. For backward compatibility reasons, it is not done. */ /* ARGSUSED */ int ip_sioctl_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { uint64_t turn_on; uint64_t turn_off; int err; boolean_t need_up = B_FALSE; phyint_t *phyi; ill_t *ill; uint64_t intf_flags; boolean_t phyint_flags_modified = B_FALSE; uint64_t flags; struct ifreq *ifr; struct lifreq *lifr; boolean_t set_linklocal = B_FALSE; boolean_t zero_source = B_FALSE; ip1dbg(("ip_sioctl_flags(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); ill = ipif->ipif_ill; phyi = ill->ill_phyint; if (ipip->ipi_cmd_type == IF_CMD) { ifr = (struct ifreq *)if_req; flags = (uint64_t)(ifr->ifr_flags & 0x0000ffff); } else { lifr = (struct lifreq *)if_req; flags = lifr->lifr_flags; } intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags; /* * Has the flags been set correctly till now ? */ ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0); ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0); ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0); /* * Compare the new flags to the old, and partition * into those coming on and those going off. * For the 16 bit command keep the bits above bit 16 unchanged. */ if (ipip->ipi_cmd == SIOCSIFFLAGS) flags |= intf_flags & ~0xFFFF; /* * First check which bits will change and then which will * go on and off */ turn_on = (flags ^ intf_flags) & ~IFF_CANTCHANGE; if (!turn_on) return (0); /* No change */ turn_off = intf_flags & turn_on; turn_on ^= turn_off; err = 0; /* * Don't allow any bits belonging to the logical interface * to be set or cleared on the replacement ipif that was * created temporarily during a MOVE. */ if (ipif->ipif_replace_zero && ((turn_on|turn_off) & IFF_LOGINT_FLAGS) != 0) { return (EINVAL); } /* * Only allow the IFF_XRESOLV and IFF_TEMPORARY flags to be set on * IPv6 interfaces. */ if ((turn_on & (IFF_XRESOLV|IFF_TEMPORARY)) && !(ipif->ipif_isv6)) return (EINVAL); /* * Don't allow the IFF_ROUTER flag to be turned on on loopback * interfaces. It makes no sense in that context. */ if ((turn_on & IFF_ROUTER) && (phyi->phyint_flags & PHYI_LOOPBACK)) return (EINVAL); if (flags & (IFF_NOLOCAL|IFF_ANYCAST)) zero_source = B_TRUE; /* * For IPv6 ipif_id 0, don't allow the interface to be up without * a link local address if IFF_NOLOCAL or IFF_ANYCAST are not set. * If the link local address isn't set, and can be set, it will get * set later on in this function. */ if (ipif->ipif_id == 0 && ipif->ipif_isv6 && (flags & IFF_UP) && !zero_source && IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) { if (ipif_cant_setlinklocal(ipif)) return (EINVAL); set_linklocal = B_TRUE; } /* * ILL cannot be part of a usesrc group and and IPMP group at the * same time. No need to grab ill_g_usesrc_lock here, see * synchronization notes in ip.c */ if (turn_on & PHYI_STANDBY && ipif->ipif_ill->ill_usesrc_grp_next != NULL) { return (EINVAL); } /* * If we modify physical interface flags, we'll potentially need to * send up two routing socket messages for the changes (one for the * IPv4 ill, and another for the IPv6 ill). Note that here. */ if ((turn_on|turn_off) & IFF_PHYINT_FLAGS) phyint_flags_modified = B_TRUE; /* * If we are setting or clearing FAILED or STANDBY or OFFLINE, * we need to flush the IRE_CACHES belonging to this ill. * We handle this case here without doing the DOWN/UP dance * like it is done for other flags. If some other flags are * being turned on/off with FAILED/STANDBY/OFFLINE, the code * below will handle it by bringing it down and then * bringing it UP. */ if ((turn_on|turn_off) & (PHYI_FAILED|PHYI_STANDBY|PHYI_OFFLINE)) { ill_t *ill_v4, *ill_v6; ill_v4 = phyi->phyint_illv4; ill_v6 = phyi->phyint_illv6; /* * First set the INACTIVE flag if needed. Then delete the ires. * ire_add will atomically prevent creating new IRE_CACHEs * unless hidden flag is set. * PHYI_FAILED and PHYI_INACTIVE are exclusive */ if ((turn_on & PHYI_FAILED) && ((intf_flags & PHYI_STANDBY) || !ipmp_enable_failback)) { /* Reset PHYI_INACTIVE when PHYI_FAILED is being set */ phyi->phyint_flags &= ~PHYI_INACTIVE; } if ((turn_off & PHYI_FAILED) && ((intf_flags & PHYI_STANDBY) || (!ipmp_enable_failback && ill_is_inactive(ill)))) { phyint_inactive(phyi); } if (turn_on & PHYI_STANDBY) { /* * We implicitly set INACTIVE only when STANDBY is set. * INACTIVE is also set on non-STANDBY phyint when user * disables FAILBACK using configuration file. * Do not allow STANDBY to be set on such INACTIVE * phyint */ if (phyi->phyint_flags & PHYI_INACTIVE) return (EINVAL); if (!(phyi->phyint_flags & PHYI_FAILED)) phyint_inactive(phyi); } if (turn_off & PHYI_STANDBY) { if (ipmp_enable_failback) { /* * Reset PHYI_INACTIVE. */ phyi->phyint_flags &= ~PHYI_INACTIVE; } else if (ill_is_inactive(ill) && !(phyi->phyint_flags & PHYI_FAILED)) { /* * Need to set INACTIVE, when user sets * STANDBY on a non-STANDBY phyint and * later resets STANDBY */ phyint_inactive(phyi); } } /* * We should always send up a message so that the * daemons come to know of it. Note that the zeroth * interface can be down and the check below for IPIF_UP * will not make sense as we are actually setting * a phyint flag here. We assume that the ipif used * is always the zeroth ipif. (ip_rts_ifmsg does not * send up any message for non-zero ipifs). */ phyint_flags_modified = B_TRUE; if (ill_v4 != NULL) { ire_walk_ill_v4(MATCH_IRE_ILL | MATCH_IRE_TYPE, IRE_CACHE, ill_stq_cache_delete, (char *)ill_v4, ill_v4); illgrp_reset_schednext(ill_v4); } if (ill_v6 != NULL) { ire_walk_ill_v6(MATCH_IRE_ILL | MATCH_IRE_TYPE, IRE_CACHE, ill_stq_cache_delete, (char *)ill_v6, ill_v6); illgrp_reset_schednext(ill_v6); } } /* * If ILLF_ROUTER changes, we need to change the ip forwarding * status of the interface and, if the interface is part of an IPMP * group, all other interfaces that are part of the same IPMP * group. */ if ((turn_on | turn_off) & ILLF_ROUTER) { (void) ill_forward_set(q, mp, ((turn_on & ILLF_ROUTER) != 0), (caddr_t)ill); } /* * If the interface is not UP and we are not going to * bring it UP, record the flags and return. When the * interface comes UP later, the right actions will be * taken. */ if (!(ipif->ipif_flags & IPIF_UP) && !(turn_on & IPIF_UP)) { /* Record new flags in their respective places. */ mutex_enter(&ill->ill_lock); mutex_enter(&ill->ill_phyint->phyint_lock); ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS); ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS); ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS); ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS); phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS); phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS); mutex_exit(&ill->ill_lock); mutex_exit(&ill->ill_phyint->phyint_lock); /* * We do the broadcast and nomination here rather * than waiting for a FAILOVER/FAILBACK to happen. In * the case of FAILBACK from INACTIVE standby to the * interface that has been repaired, PHYI_FAILED has not * been cleared yet. If there are only two interfaces in * that group, all we have is a FAILED and INACTIVE * interface. If we do the nomination soon after a failback, * the broadcast nomination code would select the * INACTIVE interface for receiving broadcasts as FAILED is * not yet cleared. As we don't want STANDBY/INACTIVE to * receive broadcast packets, we need to redo nomination * when the FAILED is cleared here. Thus, in general we * always do the nomination here for FAILED, STANDBY * and OFFLINE. */ if (((turn_on | turn_off) & (PHYI_FAILED|PHYI_STANDBY|PHYI_OFFLINE))) { ip_redo_nomination(phyi); } if (phyint_flags_modified) { if (phyi->phyint_illv4 != NULL) { ip_rts_ifmsg(phyi->phyint_illv4-> ill_ipif); } if (phyi->phyint_illv6 != NULL) { ip_rts_ifmsg(phyi->phyint_illv6-> ill_ipif); } } return (0); } else if (set_linklocal || zero_source) { mutex_enter(&ill->ill_lock); if (set_linklocal) ipif->ipif_state_flags |= IPIF_SET_LINKLOCAL; if (zero_source) ipif->ipif_state_flags |= IPIF_ZERO_SOURCE; mutex_exit(&ill->ill_lock); } /* * Disallow IPv6 interfaces coming up that have the unspecified address, * or point-to-point interfaces with an unspecified destination. We do * allow the address to be unspecified for IPIF_NOLOCAL interfaces that * have a subnet assigned, which is how in.ndpd currently manages its * onlink prefix list when no addresses are configured with those * prefixes. */ if (ipif->ipif_isv6 && ((IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) && (!(ipif->ipif_flags & IPIF_NOLOCAL) && !(turn_on & IPIF_NOLOCAL) || IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) || ((ipif->ipif_flags & IPIF_POINTOPOINT) && IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6pp_dst_addr)))) { return (EINVAL); } /* * Prevent IPv4 point-to-point interfaces with a 0.0.0.0 destination * from being brought up. */ if (!ipif->ipif_isv6 && ((ipif->ipif_flags & IPIF_POINTOPOINT) && ipif->ipif_pp_dst_addr == INADDR_ANY)) { return (EINVAL); } /* * The only flag changes that we currently take specific action on * is IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, IPIF_NOLOCAL, * ILLF_NOARP, ILLF_NONUD, IPIF_PRIVATE, IPIF_ANYCAST, and * IPIF_PREFERRED. This is done by bring the ipif down, changing * the flags and bringing it back up again. */ if ((turn_on|turn_off) & (IPIF_UP|IPIF_DEPRECATED|IPIF_NOXMIT|IPIF_NOLOCAL|ILLF_NOARP| ILLF_NONUD|IPIF_PRIVATE|IPIF_ANYCAST|IPIF_PREFERRED)) { /* * Taking this ipif down, make sure we have * valid net and subnet bcast ire's for other * logical interfaces, if we need them. */ if (!ipif->ipif_isv6) ipif_check_bcast_ires(ipif); if (((ipif->ipif_flags | turn_on) & IPIF_UP) && !(turn_off & IPIF_UP)) { need_up = B_TRUE; if (ipif->ipif_flags & IPIF_UP) ill->ill_logical_down = 1; turn_on &= ~IPIF_UP; } err = ipif_down(ipif, q, mp); ip1dbg(("ipif_down returns %d err ", err)); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); } return (ip_sioctl_flags_tail(ipif, flags, q, mp, need_up)); } static int ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q, mblk_t *mp, boolean_t need_up) { ill_t *ill; phyint_t *phyi; uint64_t turn_on; uint64_t turn_off; uint64_t intf_flags; boolean_t phyint_flags_modified = B_FALSE; int err = 0; boolean_t set_linklocal = B_FALSE; boolean_t zero_source = B_FALSE; ip1dbg(("ip_sioctl_flags_tail(%s:%u)\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); ASSERT(IAM_WRITER_IPIF(ipif)); ill = ipif->ipif_ill; phyi = ill->ill_phyint; intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags; turn_on = (flags ^ intf_flags) & ~(IFF_CANTCHANGE | IFF_UP); turn_off = intf_flags & turn_on; turn_on ^= turn_off; if ((turn_on|turn_off) & (PHYI_FAILED|PHYI_STANDBY|PHYI_OFFLINE)) phyint_flags_modified = B_TRUE; /* * Now we change the flags. Track current value of * other flags in their respective places. */ mutex_enter(&ill->ill_lock); mutex_enter(&phyi->phyint_lock); ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS); ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS); ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS); ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS); phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS); phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS); if (ipif->ipif_state_flags & IPIF_SET_LINKLOCAL) { set_linklocal = B_TRUE; ipif->ipif_state_flags &= ~IPIF_SET_LINKLOCAL; } if (ipif->ipif_state_flags & IPIF_ZERO_SOURCE) { zero_source = B_TRUE; ipif->ipif_state_flags &= ~IPIF_ZERO_SOURCE; } mutex_exit(&ill->ill_lock); mutex_exit(&phyi->phyint_lock); if (((turn_on | turn_off) & (PHYI_FAILED|PHYI_STANDBY|PHYI_OFFLINE))) ip_redo_nomination(phyi); if (set_linklocal) (void) ipif_setlinklocal(ipif); if (zero_source) ipif->ipif_v6src_addr = ipv6_all_zeros; else ipif->ipif_v6src_addr = ipif->ipif_v6lcl_addr; if (need_up) { /* * XXX ipif_up really does not know whether a phyint flags * was modified or not. So, it sends up information on * only one routing sockets message. As we don't bring up * the interface and also set STANDBY/FAILED simultaneously * it should be okay. */ err = ipif_up(ipif, q, mp); } else { /* * Make sure routing socket sees all changes to the flags. * ipif_up_done* handles this when we use ipif_up. */ if (phyint_flags_modified) { if (phyi->phyint_illv4 != NULL) { ip_rts_ifmsg(phyi->phyint_illv4-> ill_ipif); } if (phyi->phyint_illv6 != NULL) { ip_rts_ifmsg(phyi->phyint_illv6-> ill_ipif); } } else { ip_rts_ifmsg(ipif); } } return (err); } /* * Restart entry point to restart the flags restart operation after the * refcounts have dropped to zero. */ /* ARGSUSED */ int ip_sioctl_flags_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int err; struct ifreq *ifr = (struct ifreq *)if_req; struct lifreq *lifr = (struct lifreq *)if_req; ip1dbg(("ip_sioctl_flags_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ipif_down_tail(ipif); if (ipip->ipi_cmd_type == IF_CMD) { /* * Since ip_sioctl_flags expects an int and ifr_flags * is a short we need to cast ifr_flags into an int * to avoid having sign extension cause bits to get * set that should not be. */ err = ip_sioctl_flags_tail(ipif, (uint64_t)(ifr->ifr_flags & 0x0000ffff), q, mp, B_TRUE); } else { err = ip_sioctl_flags_tail(ipif, lifr->lifr_flags, q, mp, B_TRUE); } return (err); } /* ARGSUSED */ int ip_sioctl_get_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { /* * Has the flags been set correctly till now ? */ ill_t *ill = ipif->ipif_ill; phyint_t *phyi = ill->ill_phyint; ip1dbg(("ip_sioctl_get_flags(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0); ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0); ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0); /* * Need a lock since some flags can be set even when there are * references to the ipif. */ mutex_enter(&ill->ill_lock); if (ipip->ipi_cmd_type == IF_CMD) { struct ifreq *ifr = (struct ifreq *)if_req; /* Get interface flags (low 16 only). */ ifr->ifr_flags = ((ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags) & 0xffff); } else { struct lifreq *lifr = (struct lifreq *)if_req; /* Get interface flags. */ lifr->lifr_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags; } mutex_exit(&ill->ill_lock); return (0); } /* ARGSUSED */ int ip_sioctl_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int mtu; int ip_min_mtu; struct ifreq *ifr; struct lifreq *lifr; ire_t *ire; ip1dbg(("ip_sioctl_mtu(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipip->ipi_cmd_type == IF_CMD) { ifr = (struct ifreq *)if_req; mtu = ifr->ifr_metric; } else { lifr = (struct lifreq *)if_req; mtu = lifr->lifr_mtu; } if (ipif->ipif_isv6) ip_min_mtu = IPV6_MIN_MTU; else ip_min_mtu = IP_MIN_MTU; if (mtu > ipif->ipif_ill->ill_max_frag || mtu < ip_min_mtu) return (EINVAL); /* * Change the MTU size in all relevant ire's. * Mtu change Vs. new ire creation - protocol below. * First change ipif_mtu and the ire_max_frag of the * interface ire. Then do an ire walk and change the * ire_max_frag of all affected ires. During ire_add * under the bucket lock, set the ire_max_frag of the * new ire being created from the ipif/ire from which * it is being derived. If an mtu change happens after * the ire is added, the new ire will be cleaned up. * Conversely if the mtu change happens before the ire * is added, ire_add will see the new value of the mtu. */ ipif->ipif_mtu = mtu; ipif->ipif_flags |= IPIF_FIXEDMTU; if (ipif->ipif_isv6) ire = ipif_to_ire_v6(ipif); else ire = ipif_to_ire(ipif); if (ire != NULL) { ire->ire_max_frag = ipif->ipif_mtu; ire_refrele(ire); } if (ipif->ipif_flags & IPIF_UP) { if (ipif->ipif_isv6) ire_walk_v6(ipif_mtu_change, (char *)ipif, ALL_ZONES); else ire_walk_v4(ipif_mtu_change, (char *)ipif, ALL_ZONES); } /* Update the MTU in SCTP's list */ sctp_update_ipif(ipif, SCTP_IPIF_UPDATE); return (0); } /* Get interface MTU. */ /* ARGSUSED */ int ip_sioctl_get_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { struct ifreq *ifr; struct lifreq *lifr; ip1dbg(("ip_sioctl_get_mtu(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipip->ipi_cmd_type == IF_CMD) { ifr = (struct ifreq *)if_req; ifr->ifr_metric = ipif->ipif_mtu; } else { lifr = (struct lifreq *)if_req; lifr->lifr_mtu = ipif->ipif_mtu; } return (0); } /* Set interface broadcast address. */ /* ARGSUSED2 */ int ip_sioctl_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ipaddr_t addr; ire_t *ire; ip1dbg(("ip_sioctl_brdaddr(%s:%u)\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); ASSERT(IAM_WRITER_IPIF(ipif)); if (!(ipif->ipif_flags & IPIF_BROADCAST)) return (EADDRNOTAVAIL); ASSERT(!(ipif->ipif_isv6)); /* No IPv6 broadcast */ if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); addr = sin->sin_addr.s_addr; if (ipif->ipif_flags & IPIF_UP) { /* * If we are already up, make sure the new * broadcast address makes sense. If it does, * there should be an IRE for it already. * Don't match on ipif, only on the ill * since we are sharing these now. Don't use * MATCH_IRE_ILL_GROUP as we are looking for * the broadcast ire on this ill and each ill * in the group has its own broadcast ire. */ ire = ire_ctable_lookup(addr, 0, IRE_BROADCAST, ipif, ALL_ZONES, (MATCH_IRE_ILL | MATCH_IRE_TYPE)); if (ire == NULL) { return (EINVAL); } else { ire_refrele(ire); } } /* * Changing the broadcast addr for this ipif. * Make sure we have valid net and subnet bcast * ire's for other logical interfaces, if needed. */ if (addr != ipif->ipif_brd_addr) ipif_check_bcast_ires(ipif); IN6_IPADDR_TO_V4MAPPED(addr, &ipif->ipif_v6brd_addr); return (0); } /* Get interface broadcast address. */ /* ARGSUSED */ int ip_sioctl_get_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ip1dbg(("ip_sioctl_get_brdaddr(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (!(ipif->ipif_flags & IPIF_BROADCAST)) return (EADDRNOTAVAIL); /* IPIF_BROADCAST not possible with IPv6 */ ASSERT(!ipif->ipif_isv6); *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_brd_addr; return (0); } /* * This routine is called to handle the SIOCS*IFNETMASK IOCTL. */ /* ARGSUSED */ int ip_sioctl_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int err = 0; in6_addr_t v6mask; ip1dbg(("ip_sioctl_netmask(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); if (ipif->ipif_isv6) { sin6_t *sin6; if (sin->sin_family != AF_INET6) return (EAFNOSUPPORT); sin6 = (sin6_t *)sin; v6mask = sin6->sin6_addr; } else { ipaddr_t mask; if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); mask = sin->sin_addr.s_addr; V4MASK_TO_V6(mask, v6mask); } /* * No big deal if the interface isn't already up, or the mask * isn't really changing, or this is pt-pt. */ if (!(ipif->ipif_flags & IPIF_UP) || IN6_ARE_ADDR_EQUAL(&v6mask, &ipif->ipif_v6net_mask) || (ipif->ipif_flags & IPIF_POINTOPOINT)) { ipif->ipif_v6net_mask = v6mask; if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) { V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } return (0); } /* * Make sure we have valid net and subnet broadcast ire's * for the old netmask, if needed by other logical interfaces. */ if (!ipif->ipif_isv6) ipif_check_bcast_ires(ipif); err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); err = ip_sioctl_netmask_tail(ipif, sin, q, mp); return (err); } static int ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp) { in6_addr_t v6mask; int err = 0; ip1dbg(("ip_sioctl_netmask_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipif->ipif_isv6) { sin6_t *sin6; sin6 = (sin6_t *)sin; v6mask = sin6->sin6_addr; } else { ipaddr_t mask; mask = sin->sin_addr.s_addr; V4MASK_TO_V6(mask, v6mask); } ipif->ipif_v6net_mask = v6mask; if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) { V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } err = ipif_up(ipif, q, mp); if (err == 0 || err == EINPROGRESS) { /* * The interface must be DL_BOUND if this packet has to * go out on the wire. Since we only go through a logical * down and are bound with the driver during an internal * down/up that is satisfied. */ if (!ipif->ipif_isv6 && ipif->ipif_ill->ill_wq != NULL) { /* Potentially broadcast an address mask reply. */ ipif_mask_reply(ipif); } } return (err); } /* ARGSUSED */ int ip_sioctl_netmask_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ip1dbg(("ip_sioctl_netmask_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ipif_down_tail(ipif); return (ip_sioctl_netmask_tail(ipif, sin, q, mp)); } /* Get interface net mask. */ /* ARGSUSED */ int ip_sioctl_get_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { struct lifreq *lifr = (struct lifreq *)if_req; struct sockaddr_in6 *sin6 = (sin6_t *)sin; ip1dbg(("ip_sioctl_get_netmask(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * net mask can't change since we have a reference to the ipif. */ if (ipif->ipif_isv6) { ASSERT(ipip->ipi_cmd_type == LIF_CMD); *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6net_mask; lifr->lifr_addrlen = ip_mask_to_plen_v6(&ipif->ipif_v6net_mask); } else { *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_net_mask; if (ipip->ipi_cmd_type == LIF_CMD) { lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask); } } return (0); } /* ARGSUSED */ int ip_sioctl_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ip1dbg(("ip_sioctl_metric(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * Set interface metric. We don't use this for * anything but we keep track of it in case it is * important to routing applications or such. */ if (ipip->ipi_cmd_type == IF_CMD) { struct ifreq *ifr; ifr = (struct ifreq *)if_req; ipif->ipif_metric = ifr->ifr_metric; } else { struct lifreq *lifr; lifr = (struct lifreq *)if_req; ipif->ipif_metric = lifr->lifr_metric; } return (0); } /* ARGSUSED */ int ip_sioctl_get_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { /* Get interface metric. */ ip1dbg(("ip_sioctl_get_metric(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipip->ipi_cmd_type == IF_CMD) { struct ifreq *ifr; ifr = (struct ifreq *)if_req; ifr->ifr_metric = ipif->ipif_metric; } else { struct lifreq *lifr; lifr = (struct lifreq *)if_req; lifr->lifr_metric = ipif->ipif_metric; } return (0); } /* ARGSUSED */ int ip_sioctl_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ip1dbg(("ip_sioctl_muxid(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * Set the muxid returned from I_PLINK. */ if (ipip->ipi_cmd_type == IF_CMD) { struct ifreq *ifr = (struct ifreq *)if_req; ipif->ipif_ill->ill_ip_muxid = ifr->ifr_ip_muxid; ipif->ipif_ill->ill_arp_muxid = ifr->ifr_arp_muxid; } else { struct lifreq *lifr = (struct lifreq *)if_req; ipif->ipif_ill->ill_ip_muxid = lifr->lifr_ip_muxid; ipif->ipif_ill->ill_arp_muxid = lifr->lifr_arp_muxid; } return (0); } /* ARGSUSED */ int ip_sioctl_get_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { ip1dbg(("ip_sioctl_get_muxid(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * Get the muxid saved in ill for I_PUNLINK. */ if (ipip->ipi_cmd_type == IF_CMD) { struct ifreq *ifr = (struct ifreq *)if_req; ifr->ifr_ip_muxid = ipif->ipif_ill->ill_ip_muxid; ifr->ifr_arp_muxid = ipif->ipif_ill->ill_arp_muxid; } else { struct lifreq *lifr = (struct lifreq *)if_req; lifr->lifr_ip_muxid = ipif->ipif_ill->ill_ip_muxid; lifr->lifr_arp_muxid = ipif->ipif_ill->ill_arp_muxid; } return (0); } /* * Set the subnet prefix. Does not modify the broadcast address. */ /* ARGSUSED */ int ip_sioctl_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int err = 0; in6_addr_t v6addr; in6_addr_t v6mask; boolean_t need_up = B_FALSE; int addrlen; ip1dbg(("ip_sioctl_subnet(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); addrlen = ((struct lifreq *)if_req)->lifr_addrlen; if (ipif->ipif_isv6) { sin6_t *sin6; if (sin->sin_family != AF_INET6) return (EAFNOSUPPORT); sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; if (!ip_remote_addr_ok_v6(&v6addr, &ipv6_all_ones)) return (EADDRNOTAVAIL); } else { ipaddr_t addr; if (sin->sin_family != AF_INET) return (EAFNOSUPPORT); addr = sin->sin_addr.s_addr; if (!ip_addr_ok_v4(addr, 0xFFFFFFFF)) return (EADDRNOTAVAIL); IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); /* Add 96 bits */ addrlen += IPV6_ABITS - IP_ABITS; } if (ip_plen_to_mask_v6(addrlen, &v6mask) == NULL) return (EINVAL); /* Check if bits in the address is set past the mask */ if (!V6_MASK_EQ(v6addr, v6mask, v6addr)) return (EINVAL); if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6subnet, &v6addr) && IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6net_mask, &v6mask)) return (0); /* No change */ if (ipif->ipif_flags & IPIF_UP) { /* * If the interface is already marked up, * we call ipif_down which will take care * of ditching any IREs that have been set * up based on the old interface address. */ err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); need_up = B_TRUE; } err = ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, need_up); return (err); } static int ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t v6addr, in6_addr_t v6mask, queue_t *q, mblk_t *mp, boolean_t need_up) { ill_t *ill = ipif->ipif_ill; int err = 0; ip1dbg(("ip_sioctl_subnet_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* Set the new address. */ mutex_enter(&ill->ill_lock); ipif->ipif_v6net_mask = v6mask; if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) { V6_MASK_COPY(v6addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } mutex_exit(&ill->ill_lock); if (need_up) { /* * Now bring the interface back up. If this * is the only IPIF for the ILL, ipif_up * will have to re-bind to the device, so * we may get back EINPROGRESS, in which * case, this IOCTL will get completed in * ip_rput_dlpi when we see the DL_BIND_ACK. */ err = ipif_up(ipif, q, mp); if (err == EINPROGRESS) return (err); } return (err); } /* ARGSUSED */ int ip_sioctl_subnet_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int addrlen; in6_addr_t v6addr; in6_addr_t v6mask; struct lifreq *lifr = (struct lifreq *)if_req; ip1dbg(("ip_sioctl_subnet_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ipif_down_tail(ipif); addrlen = lifr->lifr_addrlen; if (ipif->ipif_isv6) { sin6_t *sin6; sin6 = (sin6_t *)sin; v6addr = sin6->sin6_addr; } else { ipaddr_t addr; addr = sin->sin_addr.s_addr; IN6_IPADDR_TO_V4MAPPED(addr, &v6addr); addrlen += IPV6_ABITS - IP_ABITS; } (void) ip_plen_to_mask_v6(addrlen, &v6mask); return (ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, B_TRUE)); } /* ARGSUSED */ int ip_sioctl_get_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { struct lifreq *lifr = (struct lifreq *)if_req; struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin; ip1dbg(("ip_sioctl_get_subnet(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(ipip->ipi_cmd_type == LIF_CMD); if (ipif->ipif_isv6) { *sin6 = sin6_null; sin6->sin6_family = AF_INET6; sin6->sin6_addr = ipif->ipif_v6subnet; lifr->lifr_addrlen = ip_mask_to_plen_v6(&ipif->ipif_v6net_mask); } else { *sin = sin_null; sin->sin_family = AF_INET; sin->sin_addr.s_addr = ipif->ipif_subnet; lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask); } return (0); } /* * Set the IPv6 address token. */ /* ARGSUSED */ int ip_sioctl_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipi, void *if_req) { ill_t *ill = ipif->ipif_ill; int err; in6_addr_t v6addr; in6_addr_t v6mask; boolean_t need_up = B_FALSE; int i; sin6_t *sin6 = (sin6_t *)sin; struct lifreq *lifr = (struct lifreq *)if_req; int addrlen; ip1dbg(("ip_sioctl_token(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); addrlen = lifr->lifr_addrlen; /* Only allow for logical unit zero i.e. not on "le0:17" */ if (ipif->ipif_id != 0) return (EINVAL); if (!ipif->ipif_isv6) return (EINVAL); if (addrlen > IPV6_ABITS) return (EINVAL); v6addr = sin6->sin6_addr; /* * The length of the token is the length from the end. To get * the proper mask for this, compute the mask of the bits not * in the token; ie. the prefix, and then xor to get the mask. */ if (ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask) == NULL) return (EINVAL); for (i = 0; i < 4; i++) { v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff; } if (V6_MASK_EQ(v6addr, v6mask, ill->ill_token) && ill->ill_token_length == addrlen) return (0); /* No change */ if (ipif->ipif_flags & IPIF_UP) { err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); need_up = B_TRUE; } err = ip_sioctl_token_tail(ipif, sin6, addrlen, q, mp, need_up); return (err); } static int ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen, queue_t *q, mblk_t *mp, boolean_t need_up) { in6_addr_t v6addr; in6_addr_t v6mask; ill_t *ill = ipif->ipif_ill; int i; int err = 0; ip1dbg(("ip_sioctl_token_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); v6addr = sin6->sin6_addr; /* * The length of the token is the length from the end. To get * the proper mask for this, compute the mask of the bits not * in the token; ie. the prefix, and then xor to get the mask. */ (void) ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask); for (i = 0; i < 4; i++) v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff; mutex_enter(&ill->ill_lock); V6_MASK_COPY(v6addr, v6mask, ill->ill_token); ill->ill_token_length = addrlen; mutex_exit(&ill->ill_lock); if (need_up) { /* * Now bring the interface back up. If this * is the only IPIF for the ILL, ipif_up * will have to re-bind to the device, so * we may get back EINPROGRESS, in which * case, this IOCTL will get completed in * ip_rput_dlpi when we see the DL_BIND_ACK. */ err = ipif_up(ipif, q, mp); if (err == EINPROGRESS) return (err); } return (err); } /* ARGSUSED */ int ip_sioctl_get_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipi, void *if_req) { ill_t *ill; sin6_t *sin6 = (sin6_t *)sin; struct lifreq *lifr = (struct lifreq *)if_req; ip1dbg(("ip_sioctl_get_token(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipif->ipif_id != 0) return (EINVAL); ill = ipif->ipif_ill; if (!ill->ill_isv6) return (ENXIO); *sin6 = sin6_null; sin6->sin6_family = AF_INET6; ASSERT(!IN6_IS_ADDR_V4MAPPED(&ill->ill_token)); sin6->sin6_addr = ill->ill_token; lifr->lifr_addrlen = ill->ill_token_length; return (0); } /* * Set (hardware) link specific information that might override * what was acquired through the DL_INFO_ACK. * The logic is as follows. * * become exclusive * set CHANGING flag * change mtu on affected IREs * clear CHANGING flag * * An ire add that occurs before the CHANGING flag is set will have its mtu * changed by the ip_sioctl_lnkinfo. * * During the time the CHANGING flag is set, no new ires will be added to the * bucket, and ire add will fail (due the CHANGING flag). * * An ire add that occurs after the CHANGING flag is set will have the right mtu * before it is added to the bucket. * * Obviously only 1 thread can set the CHANGING flag and we need to become * exclusive to set the flag. */ /* ARGSUSED */ int ip_sioctl_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipi, void *if_req) { ill_t *ill = ipif->ipif_ill; ipif_t *nipif; int ip_min_mtu; boolean_t mtu_walk = B_FALSE; struct lifreq *lifr = (struct lifreq *)if_req; lif_ifinfo_req_t *lir; ire_t *ire; ip1dbg(("ip_sioctl_lnkinfo(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); lir = &lifr->lifr_ifinfo; ASSERT(IAM_WRITER_IPIF(ipif)); /* Only allow for logical unit zero i.e. not on "le0:17" */ if (ipif->ipif_id != 0) return (EINVAL); /* Set interface MTU. */ if (ipif->ipif_isv6) ip_min_mtu = IPV6_MIN_MTU; else ip_min_mtu = IP_MIN_MTU; /* * Verify values before we set anything. Allow zero to * mean unspecified. */ if (lir->lir_maxmtu != 0 && (lir->lir_maxmtu > ill->ill_max_frag || lir->lir_maxmtu < ip_min_mtu)) return (EINVAL); if (lir->lir_reachtime != 0 && lir->lir_reachtime > ND_MAX_REACHTIME) return (EINVAL); if (lir->lir_reachretrans != 0 && lir->lir_reachretrans > ND_MAX_REACHRETRANSTIME) return (EINVAL); mutex_enter(&ill->ill_lock); ill->ill_state_flags |= ILL_CHANGING; for (nipif = ill->ill_ipif; nipif != NULL; nipif = nipif->ipif_next) { nipif->ipif_state_flags |= IPIF_CHANGING; } mutex_exit(&ill->ill_lock); if (lir->lir_maxmtu != 0) { ill->ill_max_mtu = lir->lir_maxmtu; ill->ill_mtu_userspecified = 1; mtu_walk = B_TRUE; } if (lir->lir_reachtime != 0) ill->ill_reachable_time = lir->lir_reachtime; if (lir->lir_reachretrans != 0) ill->ill_reachable_retrans_time = lir->lir_reachretrans; ill->ill_max_hops = lir->lir_maxhops; ill->ill_max_buf = ND_MAX_Q; if (mtu_walk) { /* * Set the MTU on all ipifs associated with this ill except * for those whose MTU was fixed via SIOCSLIFMTU. */ for (nipif = ill->ill_ipif; nipif != NULL; nipif = nipif->ipif_next) { if (nipif->ipif_flags & IPIF_FIXEDMTU) continue; nipif->ipif_mtu = ill->ill_max_mtu; if (!(nipif->ipif_flags & IPIF_UP)) continue; if (nipif->ipif_isv6) ire = ipif_to_ire_v6(nipif); else ire = ipif_to_ire(nipif); if (ire != NULL) { ire->ire_max_frag = ipif->ipif_mtu; ire_refrele(ire); } if (ill->ill_isv6) { ire_walk_ill_v6(MATCH_IRE_ILL, 0, ipif_mtu_change, (char *)nipif, ill); } else { ire_walk_ill_v4(MATCH_IRE_ILL, 0, ipif_mtu_change, (char *)nipif, ill); } } } mutex_enter(&ill->ill_lock); for (nipif = ill->ill_ipif; nipif != NULL; nipif = nipif->ipif_next) { nipif->ipif_state_flags &= ~IPIF_CHANGING; } ILL_UNMARK_CHANGING(ill); mutex_exit(&ill->ill_lock); return (0); } /* ARGSUSED */ int ip_sioctl_get_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipi, void *if_req) { struct lif_ifinfo_req *lir; ill_t *ill = ipif->ipif_ill; ip1dbg(("ip_sioctl_get_lnkinfo(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); if (ipif->ipif_id != 0) return (EINVAL); lir = &((struct lifreq *)if_req)->lifr_ifinfo; lir->lir_maxhops = ill->ill_max_hops; lir->lir_reachtime = ill->ill_reachable_time; lir->lir_reachretrans = ill->ill_reachable_retrans_time; lir->lir_maxmtu = ill->ill_max_mtu; return (0); } /* * Return best guess as to the subnet mask for the specified address. * Based on the subnet masks for all the configured interfaces. * * We end up returning a zero mask in the case of default, multicast or * experimental. */ static ipaddr_t ip_subnet_mask(ipaddr_t addr, ipif_t **ipifp) { ipaddr_t net_mask; ill_t *ill; ipif_t *ipif; ill_walk_context_t ctx; ipif_t *fallback_ipif = NULL; net_mask = ip_net_mask(addr); if (net_mask == 0) { *ipifp = NULL; return (0); } /* Let's check to see if this is maybe a local subnet route. */ /* this function only applies to IPv4 interfaces */ rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { mutex_enter(&ill->ill_lock); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; if (!(ipif->ipif_flags & IPIF_UP)) continue; if ((ipif->ipif_subnet & net_mask) == (addr & net_mask)) { /* * Don't trust pt-pt interfaces if there are * other interfaces. */ if (ipif->ipif_flags & IPIF_POINTOPOINT) { if (fallback_ipif == NULL) { ipif_refhold_locked(ipif); fallback_ipif = ipif; } continue; } /* * Fine. Just assume the same net mask as the * directly attached subnet interface is using. */ ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); if (fallback_ipif != NULL) ipif_refrele(fallback_ipif); *ipifp = ipif; return (ipif->ipif_net_mask); } } mutex_exit(&ill->ill_lock); } rw_exit(&ill_g_lock); *ipifp = fallback_ipif; return ((fallback_ipif != NULL) ? fallback_ipif->ipif_net_mask : net_mask); } /* * ip_sioctl_copyin_setup calls ip_wput_ioctl to process the IP_IOCTL ioctl. */ static void ip_wput_ioctl(queue_t *q, mblk_t *mp) { IOCP iocp; ipft_t *ipft; ipllc_t *ipllc; mblk_t *mp1; cred_t *cr; int error = 0; conn_t *connp; ip1dbg(("ip_wput_ioctl")); iocp = (IOCP)mp->b_rptr; mp1 = mp->b_cont; if (mp1 == NULL) { iocp->ioc_error = EINVAL; mp->b_datap->db_type = M_IOCNAK; iocp->ioc_count = 0; qreply(q, mp); return; } /* * These IOCTLs provide various control capabilities to * upstream agents such as ULPs and processes. There * are currently two such IOCTLs implemented. They * are used by TCP to provide update information for * existing IREs and to forcibly delete an IRE for a * host that is not responding, thereby forcing an * attempt at a new route. */ iocp->ioc_error = EINVAL; if (!pullupmsg(mp1, sizeof (ipllc->ipllc_cmd))) goto done; ipllc = (ipllc_t *)mp1->b_rptr; for (ipft = ip_ioctl_ftbl; ipft->ipft_pfi; ipft++) { if (ipllc->ipllc_cmd == ipft->ipft_cmd) break; } /* * prefer credential from mblk over ioctl; * see ip_sioctl_copyin_setup */ cr = DB_CREDDEF(mp, iocp->ioc_cr); /* * Refhold the conn in case the request gets queued up in some lookup */ ASSERT(CONN_Q(q)); connp = Q_TO_CONN(q); CONN_INC_REF(connp); if (ipft->ipft_pfi && ((mp1->b_wptr - mp1->b_rptr) >= ipft->ipft_min_size || pullupmsg(mp1, ipft->ipft_min_size))) { error = (*ipft->ipft_pfi)(q, (ipft->ipft_flags & IPFT_F_SELF_REPLY) ? mp : mp1, cr); } if (ipft->ipft_flags & IPFT_F_SELF_REPLY) { /* * CONN_OPER_PENDING_DONE happens in the function called * through ipft_pfi above. */ return; } CONN_OPER_PENDING_DONE(connp); if (ipft->ipft_flags & IPFT_F_NO_REPLY) { freemsg(mp); return; } iocp->ioc_error = error; done: mp->b_datap->db_type = M_IOCACK; if (iocp->ioc_error) iocp->ioc_count = 0; qreply(q, mp); } /* * Lookup an ipif using the sequence id (ipif_seqid) */ ipif_t * ipif_lookup_seqid(ill_t *ill, uint_t seqid) { ipif_t *ipif; ASSERT(MUTEX_HELD(&ill->ill_lock)); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_seqid == seqid && IPIF_CAN_LOOKUP(ipif)) return (ipif); } return (NULL); } uint64_t ipif_g_seqid; /* * Assign a unique id for the ipif. This is used later when we send * IRES to ARP for resolution where we initialize ire_ipif_seqid * to the value pointed by ire_ipif->ipif_seqid. Later when the * IRE is added, we verify that ipif has not disappeared. */ static void ipif_assign_seqid(ipif_t *ipif) { ipif->ipif_seqid = atomic_add_64_nv(&ipif_g_seqid, 1); } /* * Insert the ipif, so that the list of ipifs on the ill will be sorted * with respect to ipif_id. Note that an ipif with an ipif_id of -1 will * be inserted into the first space available in the list. The value of * ipif_id will then be set to the appropriate value for its position. */ static int ipif_insert(ipif_t *ipif, boolean_t acquire_g_lock, boolean_t acquire_ill_lock) { ill_t *ill; ipif_t *tipif; ipif_t **tipifp; int id; ASSERT(ipif->ipif_ill->ill_net_type == IRE_LOOPBACK || IAM_WRITER_IPIF(ipif)); ill = ipif->ipif_ill; ASSERT(ill != NULL); /* * In the case of lo0:0 we already hold the ill_g_lock. * ill_lookup_on_name (acquires ill_g_lock) -> ipif_allocate -> * ipif_insert. Another such caller is ipif_move. */ if (acquire_g_lock) rw_enter(&ill_g_lock, RW_WRITER); if (acquire_ill_lock) mutex_enter(&ill->ill_lock); id = ipif->ipif_id; tipifp = &(ill->ill_ipif); if (id == -1) { /* need to find a real id */ id = 0; while ((tipif = *tipifp) != NULL) { ASSERT(tipif->ipif_id >= id); if (tipif->ipif_id != id) break; /* non-consecutive id */ id++; tipifp = &(tipif->ipif_next); } /* limit number of logical interfaces */ if (id >= ip_addrs_per_if) { if (acquire_ill_lock) mutex_exit(&ill->ill_lock); if (acquire_g_lock) rw_exit(&ill_g_lock); return (-1); } ipif->ipif_id = id; /* assign new id */ } else if (id < ip_addrs_per_if) { /* we have a real id; insert ipif in the right place */ while ((tipif = *tipifp) != NULL) { ASSERT(tipif->ipif_id != id); if (tipif->ipif_id > id) break; /* found correct location */ tipifp = &(tipif->ipif_next); } } else { if (acquire_ill_lock) mutex_exit(&ill->ill_lock); if (acquire_g_lock) rw_exit(&ill_g_lock); return (-1); } ASSERT(tipifp != &(ill->ill_ipif) || id == 0); ipif->ipif_next = tipif; *tipifp = ipif; if (acquire_ill_lock) mutex_exit(&ill->ill_lock); if (acquire_g_lock) rw_exit(&ill_g_lock); return (0); } /* * Allocate and initialize a new interface control structure. (Always * called as writer.) * When ipif_allocate() is called from ip_ll_subnet_defaults, the ill * is not part of the global linked list of ills. ipif_seqid is unique * in the system and to preserve the uniqueness, it is assigned only * when ill becomes part of the global list. At that point ill will * have a name. If it doesn't get assigned here, it will get assigned * in ipif_set_values() as part of SIOCSLIFNAME processing. * Aditionally, if we come here from ip_ll_subnet_defaults, we don't set * the interface flags or any other information from the DL_INFO_ACK for * DL_STYLE2 drivers (initialize == B_FALSE), since we won't have them at * this point. The flags etc. will be set in ip_ll_subnet_defaults when the * second DL_INFO_ACK comes in from the driver. */ static ipif_t * ipif_allocate(ill_t *ill, int id, uint_t ire_type, boolean_t initialize) { ipif_t *ipif; phyint_t *phyi; ip1dbg(("ipif_allocate(%s:%d ill %p)\n", ill->ill_name, id, (void *)ill)); ASSERT(ire_type == IRE_LOOPBACK || IAM_WRITER_ILL(ill)); if ((ipif = (ipif_t *)mi_alloc(sizeof (ipif_t), BPRI_MED)) == NULL) return (NULL); *ipif = ipif_zero; /* start clean */ ipif->ipif_ill = ill; ipif->ipif_id = id; /* could be -1 */ ipif->ipif_zoneid = GLOBAL_ZONEID; mutex_init(&ipif->ipif_saved_ire_lock, NULL, MUTEX_DEFAULT, NULL); ipif->ipif_refcnt = 0; ipif->ipif_saved_ire_cnt = 0; if (ipif_insert(ipif, ire_type != IRE_LOOPBACK, B_TRUE)) { mi_free(ipif); return (NULL); } /* -1 id should have been replaced by real id */ id = ipif->ipif_id; ASSERT(id >= 0); if (ill->ill_name[0] != '\0') { ipif_assign_seqid(ipif); if (ill->ill_phyint->phyint_ifindex != 0) sctp_update_ipif(ipif, SCTP_IPIF_INSERT); } /* * Keep a copy of original id in ipif_orig_ipifid. Failback * will attempt to restore the original id. The SIOCSLIFOINDEX * ioctl sets ipif_orig_ipifid to zero. */ ipif->ipif_orig_ipifid = id; /* * We grab the ill_lock and phyint_lock to protect the flag changes. * The ipif is still not up and can't be looked up until the * ioctl completes and the IPIF_CHANGING flag is cleared. */ mutex_enter(&ill->ill_lock); mutex_enter(&ill->ill_phyint->phyint_lock); /* * Set the running flag when logical interface zero is created. * For subsequent logical interfaces, a DLPI link down * notification message may have cleared the running flag to * indicate the link is down, so we shouldn't just blindly set it. */ if (id == 0) ill->ill_phyint->phyint_flags |= PHYI_RUNNING; ipif->ipif_ire_type = ire_type; phyi = ill->ill_phyint; ipif->ipif_orig_ifindex = phyi->phyint_ifindex; if (ipif->ipif_isv6) { ill->ill_flags |= ILLF_IPV6; } else { ipaddr_t inaddr_any = INADDR_ANY; ill->ill_flags |= ILLF_IPV4; /* Keep the IN6_IS_ADDR_V4MAPPED assertions happy */ IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6lcl_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6src_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6subnet); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6net_mask); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6brd_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &ipif->ipif_v6pp_dst_addr); } /* * Don't set the interface flags etc. now, will do it in * ip_ll_subnet_defaults. */ if (!initialize) { mutex_exit(&ill->ill_lock); mutex_exit(&ill->ill_phyint->phyint_lock); return (ipif); } ipif->ipif_mtu = ill->ill_max_mtu; if (ill->ill_bcast_addr_length != 0) { /* * Later detect lack of DLPI driver multicast * capability by catching DL_ENABMULTI errors in * ip_rput_dlpi. */ ill->ill_flags |= ILLF_MULTICAST; if (!ipif->ipif_isv6) ipif->ipif_flags |= IPIF_BROADCAST; } else { if (ill->ill_net_type != IRE_LOOPBACK) { if (ipif->ipif_isv6) /* * Note: xresolv interfaces will eventually need * NOARP set here as well, but that will require * those external resolvers to have some * knowledge of that flag and act appropriately. * Not to be changed at present. */ ill->ill_flags |= ILLF_NONUD; else ill->ill_flags |= ILLF_NOARP; } if (ill->ill_phys_addr_length == 0) { if (ill->ill_media && ill->ill_media->ip_m_mac_type == SUNW_DL_VNI) { ipif->ipif_flags |= IPIF_NOXMIT; phyi->phyint_flags |= PHYI_VIRTUAL; } else { /* pt-pt supports multicast. */ ill->ill_flags |= ILLF_MULTICAST; if (ill->ill_net_type == IRE_LOOPBACK) { phyi->phyint_flags |= (PHYI_LOOPBACK | PHYI_VIRTUAL); } else { ipif->ipif_flags |= IPIF_POINTOPOINT; } } } } mutex_exit(&ill->ill_lock); mutex_exit(&ill->ill_phyint->phyint_lock); return (ipif); } /* * If appropriate, send a message up to the resolver delete the entry * for the address of this interface which is going out of business. * (Always called as writer). * * NOTE : We need to check for NULL mps as some of the fields are * initialized only for some interface types. See ipif_resolver_up() * for details. */ void ipif_arp_down(ipif_t *ipif) { mblk_t *mp; ip1dbg(("ipif_arp_down(%s:%u)\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); ASSERT(IAM_WRITER_IPIF(ipif)); /* Delete the mapping for the local address */ mp = ipif->ipif_arp_del_mp; if (mp != NULL) { ip1dbg(("ipif_arp_down: %s (%u) for %s:%u\n", dlpi_prim_str(*(int *)mp->b_rptr), *(int *)mp->b_rptr, ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ipif->ipif_ill->ill_rq, mp); ipif->ipif_arp_del_mp = NULL; } /* * If this is the last ipif that is going down, we need * to clean up ARP completely. */ if (ipif->ipif_ill->ill_ipif_up_count == 0) { /* Send up AR_INTERFACE_DOWN message */ mp = ipif->ipif_ill->ill_arp_down_mp; if (mp != NULL) { ip1dbg(("ipif_arp_down: %s (%u) for %s:%u\n", dlpi_prim_str(*(int *)mp->b_rptr), *(int *)mp->b_rptr, ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ipif->ipif_ill->ill_rq, mp); ipif->ipif_ill->ill_arp_down_mp = NULL; } /* Tell ARP to delete the multicast mappings */ mp = ipif->ipif_ill->ill_arp_del_mapping_mp; if (mp != NULL) { ip1dbg(("ipif_arp_down: %s (%u) for %s:%u\n", dlpi_prim_str(*(int *)mp->b_rptr), *(int *)mp->b_rptr, ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ipif->ipif_ill->ill_rq, mp); ipif->ipif_ill->ill_arp_del_mapping_mp = NULL; } } } /* * This function sets up the multicast mappings in ARP. When ipif_resolver_up * calls this function, it passes a non-NULL arp_add_mapping_mp indicating * that it wants the add_mp allocated in this function to be returned * wihtout sending it to arp. When ip_rput_dlpi_writer calls this to * just re-do the multicast, it wants us to send the add_mp to ARP also. * ipif_resolver_up does not want us to do the "add" i.e sending to ARP, * as it does a ipif_arp_down after calling this function - which will * remove what we add here. * * Returns -1 on failures and 0 on success. */ int ipif_arp_setup_multicast(ipif_t *ipif, mblk_t **arp_add_mapping_mp) { mblk_t *del_mp = NULL; mblk_t *add_mp = NULL; mblk_t *mp; ill_t *ill = ipif->ipif_ill; phyint_t *phyi = ill->ill_phyint; ipaddr_t addr, mask, extract_mask = 0; arma_t *arma; uint8_t *maddr, *bphys_addr; uint32_t hw_start; dl_unitdata_req_t *dlur; ASSERT(IAM_WRITER_IPIF(ipif)); if (ipif->ipif_flags & IPIF_POINTOPOINT) return (0); /* * Delete the existing mapping from ARP. Normally ipif_down * -> ipif_arp_down should send this up to ARP. The only * reason we would find this when we are switching from * Multicast to Broadcast where we did not do a down. */ mp = ill->ill_arp_del_mapping_mp; if (mp != NULL) { ip1dbg(("ipif_arp_down: %s (%u) for %s:%u\n", dlpi_prim_str(*(int *)mp->b_rptr), *(int *)mp->b_rptr, ill->ill_name, ipif->ipif_id)); putnext(ill->ill_rq, mp); ill->ill_arp_del_mapping_mp = NULL; } if (arp_add_mapping_mp != NULL) *arp_add_mapping_mp = NULL; /* * Check that the address is not to long for the constant * length reserved in the template arma_t. */ if (ill->ill_phys_addr_length > IP_MAX_HW_LEN) return (-1); /* Add mapping mblk */ addr = (ipaddr_t)htonl(INADDR_UNSPEC_GROUP); mask = (ipaddr_t)htonl(IN_CLASSD_NET); add_mp = ill_arp_alloc(ill, (uchar_t *)&ip_arma_multi_template, (caddr_t)&addr); if (add_mp == NULL) return (-1); arma = (arma_t *)add_mp->b_rptr; maddr = (uint8_t *)arma + arma->arma_hw_addr_offset; bcopy(&mask, (char *)arma + arma->arma_proto_mask_offset, IP_ADDR_LEN); arma->arma_hw_addr_length = ill->ill_phys_addr_length; /* * Determine the broadcast address. */ dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr; if (ill->ill_sap_length < 0) bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset; else bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset + ill->ill_sap_length; /* * Check PHYI_MULTI_BCAST and length of physical * address to determine if we use the mapping or the * broadcast address. */ if (!(phyi->phyint_flags & PHYI_MULTI_BCAST)) if (!MEDIA_V4MINFO(ill->ill_media, ill->ill_phys_addr_length, bphys_addr, maddr, &hw_start, &extract_mask)) phyi->phyint_flags |= PHYI_MULTI_BCAST; if ((phyi->phyint_flags & PHYI_MULTI_BCAST) || (ill->ill_flags & ILLF_MULTICAST)) { /* Make sure this will not match the "exact" entry. */ addr = (ipaddr_t)htonl(INADDR_ALLHOSTS_GROUP); del_mp = ill_arp_alloc(ill, (uchar_t *)&ip_ared_template, (caddr_t)&addr); if (del_mp == NULL) { freemsg(add_mp); return (-1); } bcopy(&extract_mask, (char *)arma + arma->arma_proto_extract_mask_offset, IP_ADDR_LEN); if (phyi->phyint_flags & PHYI_MULTI_BCAST) { /* Use link-layer broadcast address for MULTI_BCAST */ bcopy(bphys_addr, maddr, ill->ill_phys_addr_length); ip2dbg(("ipif_arp_setup_multicast: adding" " MULTI_BCAST ARP setup for %s\n", ill->ill_name)); } else { arma->arma_hw_mapping_start = hw_start; ip2dbg(("ipif_arp_setup_multicast: adding multicast" " ARP setup for %s\n", ill->ill_name)); } } else { freemsg(add_mp); ASSERT(del_mp == NULL); /* It is neither MULTICAST nor MULTI_BCAST */ return (0); } ASSERT(add_mp != NULL && del_mp != NULL); ill->ill_arp_del_mapping_mp = del_mp; if (arp_add_mapping_mp != NULL) { /* The caller just wants the mblks allocated */ *arp_add_mapping_mp = add_mp; } else { /* The caller wants us to send it to arp */ putnext(ill->ill_rq, add_mp); } return (0); } /* * Get the resolver set up for a new interface address. * (Always called as writer.) * Called both for IPv4 and IPv6 interfaces, * though it only sets up the resolver for v6 * if it's an xresolv interface (one using an external resolver). * Honors ILLF_NOARP. * The boolean value arp_just_publish, if B_TRUE, indicates that * it only needs to send an AR_ENTRY_ADD message up to ARP for * IPv4 interfaces. Currently, B_TRUE is only set when this * function is called by ip_rput_dlpi_writer() to handle * asynchronous hardware address change notification. * Returns error on failure. */ int ipif_resolver_up(ipif_t *ipif, boolean_t arp_just_publish) { caddr_t addr; mblk_t *arp_up_mp = NULL; mblk_t *arp_down_mp = NULL; mblk_t *arp_add_mp = NULL; mblk_t *arp_del_mp = NULL; mblk_t *arp_add_mapping_mp = NULL; mblk_t *arp_del_mapping_mp = NULL; ill_t *ill = ipif->ipif_ill; uchar_t *area_p = NULL; uchar_t *ared_p = NULL; int err = ENOMEM; ip1dbg(("ipif_resolver_up(%s:%u) flags 0x%x\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (uint_t)ipif->ipif_flags)); ASSERT(IAM_WRITER_IPIF(ipif)); if ((ill->ill_net_type != IRE_IF_RESOLVER) || (ill->ill_isv6 && !(ill->ill_flags & ILLF_XRESOLV))) { return (0); } if (ill->ill_isv6) { /* * External resolver for IPv6 */ ASSERT(!arp_just_publish); if (!IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) { addr = (caddr_t)&ipif->ipif_v6lcl_addr; area_p = (uchar_t *)&ip6_area_template; ared_p = (uchar_t *)&ip6_ared_template; } } else { /* * IPv4 arp case. If the ARP stream has already started * closing, fail this request for ARP bringup. Else * record the fact that an ARP bringup is pending. */ mutex_enter(&ill->ill_lock); if (ill->ill_arp_closing) { mutex_exit(&ill->ill_lock); err = EINVAL; goto failed; } else { if (ill->ill_ipif_up_count == 0) ill->ill_arp_bringup_pending = 1; mutex_exit(&ill->ill_lock); } if (ipif->ipif_lcl_addr != INADDR_ANY) { addr = (caddr_t)&ipif->ipif_lcl_addr; area_p = (uchar_t *)&ip_area_template; ared_p = (uchar_t *)&ip_ared_template; } } /* * Add an entry for the local address in ARP only if it * is not UNNUMBERED and the address is not INADDR_ANY. */ if (((ipif->ipif_flags & IPIF_UNNUMBERED) == 0) && area_p != NULL) { /* Now ask ARP to publish our address. */ arp_add_mp = ill_arp_alloc(ill, area_p, addr); if (arp_add_mp == NULL) goto failed; if (arp_just_publish) { /* * Copy the new hardware address and length into * arp_add_mp to be sent to ARP. */ area_t *area = (area_t *)arp_add_mp->b_rptr; area->area_hw_addr_length = ill->ill_phys_addr_length; bcopy((char *)ill->ill_phys_addr, ((char *)area + area->area_hw_addr_offset), area->area_hw_addr_length); } ((area_t *)arp_add_mp->b_rptr)->area_flags = ACE_F_PERMANENT | ACE_F_PUBLISH | ACE_F_MYADDR; if (arp_just_publish) goto arp_setup_multicast; /* * Allocate an ARP deletion message so we know we can tell ARP * when the interface goes down. */ arp_del_mp = ill_arp_alloc(ill, ared_p, addr); if (arp_del_mp == NULL) goto failed; } else { if (arp_just_publish) goto done; } /* * Need to bring up ARP or setup multicast mapping only * when the first interface is coming UP. */ if (ill->ill_ipif_up_count != 0) goto done; /* * Allocate an ARP down message (to be saved) and an ARP up * message. */ arp_down_mp = ill_arp_alloc(ill, (uchar_t *)&ip_ard_template, 0); if (arp_down_mp == NULL) goto failed; arp_up_mp = ill_arp_alloc(ill, (uchar_t *)&ip_aru_template, 0); if (arp_up_mp == NULL) goto failed; if (ipif->ipif_flags & IPIF_POINTOPOINT) goto done; arp_setup_multicast: /* * Setup the multicast mappings. This function initializes * ill_arp_del_mapping_mp also. This does not need to be done for * IPv6. */ if (!ill->ill_isv6) { err = ipif_arp_setup_multicast(ipif, &arp_add_mapping_mp); if (err != 0) goto failed; ASSERT(ill->ill_arp_del_mapping_mp != NULL); ASSERT(arp_add_mapping_mp != NULL); } done:; if (arp_del_mp != NULL) { ASSERT(ipif->ipif_arp_del_mp == NULL); ipif->ipif_arp_del_mp = arp_del_mp; } if (arp_down_mp != NULL) { ASSERT(ill->ill_arp_down_mp == NULL); ill->ill_arp_down_mp = arp_down_mp; } if (arp_del_mapping_mp != NULL) { ASSERT(ill->ill_arp_del_mapping_mp == NULL); ill->ill_arp_del_mapping_mp = arp_del_mapping_mp; } if (arp_up_mp != NULL) { ip1dbg(("ipif_resolver_up: ARP_UP for %s:%u\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ill->ill_rq, arp_up_mp); } if (arp_add_mp != NULL) { ip1dbg(("ipif_resolver_up: ARP_ADD for %s:%u\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ill->ill_rq, arp_add_mp); } if (arp_add_mapping_mp != NULL) { ip1dbg(("ipif_resolver_up: MAPPING_ADD for %s:%u\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); putnext(ill->ill_rq, arp_add_mapping_mp); } if (arp_just_publish) return (0); if (ill->ill_flags & ILLF_NOARP) err = ill_arp_off(ill); else err = ill_arp_on(ill); if (err) { ip0dbg(("ipif_resolver_up: arp_on/off failed %d\n", err)); freemsg(ipif->ipif_arp_del_mp); if (arp_down_mp != NULL) freemsg(ill->ill_arp_down_mp); if (ill->ill_arp_del_mapping_mp != NULL) freemsg(ill->ill_arp_del_mapping_mp); ipif->ipif_arp_del_mp = NULL; ill->ill_arp_down_mp = NULL; ill->ill_arp_del_mapping_mp = NULL; return (err); } return (ill->ill_ipif_up_count != 0 ? 0 : EINPROGRESS); failed:; ip1dbg(("ipif_resolver_up: FAILED\n")); freemsg(arp_add_mp); freemsg(arp_del_mp); freemsg(arp_add_mapping_mp); freemsg(arp_up_mp); freemsg(arp_down_mp); ill->ill_arp_bringup_pending = 0; return (err); } /* * Wakeup all threads waiting to enter the ipsq, and sleeping * on any of the ills in this ipsq. The ill_lock of the ill * must be held so that waiters don't miss wakeups */ static void ill_signal_ipsq_ills(ipsq_t *ipsq, boolean_t caller_holds_lock) { phyint_t *phyint; phyint = ipsq->ipsq_phyint_list; while (phyint != NULL) { if (phyint->phyint_illv4) { if (!caller_holds_lock) mutex_enter(&phyint->phyint_illv4->ill_lock); ASSERT(MUTEX_HELD(&phyint->phyint_illv4->ill_lock)); cv_broadcast(&phyint->phyint_illv4->ill_cv); if (!caller_holds_lock) mutex_exit(&phyint->phyint_illv4->ill_lock); } if (phyint->phyint_illv6) { if (!caller_holds_lock) mutex_enter(&phyint->phyint_illv6->ill_lock); ASSERT(MUTEX_HELD(&phyint->phyint_illv6->ill_lock)); cv_broadcast(&phyint->phyint_illv6->ill_cv); if (!caller_holds_lock) mutex_exit(&phyint->phyint_illv6->ill_lock); } phyint = phyint->phyint_ipsq_next; } } static ipsq_t * ipsq_create(char *groupname) { ipsq_t *ipsq; ASSERT(RW_WRITE_HELD(&ill_g_lock)); ipsq = kmem_zalloc(sizeof (ipsq_t), KM_NOSLEEP); if (ipsq == NULL) { return (NULL); } if (groupname != NULL) (void) strcpy(ipsq->ipsq_name, groupname); else ipsq->ipsq_name[0] = '\0'; mutex_init(&ipsq->ipsq_lock, NULL, MUTEX_DEFAULT, NULL); ipsq->ipsq_flags |= IPSQ_GROUP; ipsq->ipsq_next = ipsq_g_head; ipsq_g_head = ipsq; return (ipsq); } /* * Return an ipsq correspoding to the groupname. If 'create' is true * allocate a new ipsq if one does not exist. Usually an ipsq is associated * uniquely with an IPMP group. However during IPMP groupname operations, * multiple IPMP groups may be associated with a single ipsq. But no * IPMP group can be associated with more than 1 ipsq at any time. * For example * Interfaces IPMP grpname ipsq ipsq_name ipsq_refs * hme1, hme2 mpk17-84 ipsq1 mpk17-84 2 * hme3, hme4 mpk17-85 ipsq2 mpk17-85 2 * * Now the command ifconfig hme3 group mpk17-84 results in the temporary * status shown below during the execution of the above command. * hme1, hme2, hme3, hme4 mpk17-84, mpk17-85 ipsq1 mpk17-84 4 * * After the completion of the above groupname command we return to the stable * state shown below. * hme1, hme2, hme3 mpk17-84 ipsq1 mpk17-84 3 * hme4 mpk17-85 ipsq2 mpk17-85 1 * * Because of the above, we don't search based on the ipsq_name since that * would miss the correct ipsq during certain windows as shown above. * The ipsq_name is only used during split of an ipsq to return the ipsq to its * natural state. */ static ipsq_t * ip_ipsq_lookup(char *groupname, boolean_t create, ipsq_t *exclude_ipsq) { ipsq_t *ipsq; int group_len; phyint_t *phyint; ASSERT(RW_LOCK_HELD(&ill_g_lock)); group_len = strlen(groupname); ASSERT(group_len != 0); group_len++; for (ipsq = ipsq_g_head; ipsq != NULL; ipsq = ipsq->ipsq_next) { /* * When an ipsq is being split, and ill_split_ipsq * calls this function, we exclude it from being considered. */ if (ipsq == exclude_ipsq) continue; /* * Compare against the ipsq_name. The groupname change happens * in 2 phases. The 1st phase merges the from group into * the to group's ipsq, by calling ill_merge_groups and restarts * the ioctl. The 2nd phase then locates the ipsq again thru * ipsq_name. At this point the phyint_groupname has not been * updated. */ if ((group_len == strlen(ipsq->ipsq_name) + 1) && (bcmp(ipsq->ipsq_name, groupname, group_len) == 0)) { /* * Verify that an ipmp groupname is exactly * part of 1 ipsq and is not found in any other * ipsq. */ ASSERT(ip_ipsq_lookup(groupname, B_FALSE, ipsq) == NULL); return (ipsq); } /* * Comparison against ipsq_name alone is not sufficient. * In the case when groups are currently being * merged, the ipsq could hold other IPMP groups temporarily. * so we walk the phyint list and compare against the * phyint_groupname as well. */ phyint = ipsq->ipsq_phyint_list; while (phyint != NULL) { if ((group_len == phyint->phyint_groupname_len) && (bcmp(phyint->phyint_groupname, groupname, group_len) == 0)) { /* * Verify that an ipmp groupname is exactly * part of 1 ipsq and is not found in any other * ipsq. */ ASSERT(ip_ipsq_lookup(groupname, B_FALSE, ipsq) == NULL); return (ipsq); } phyint = phyint->phyint_ipsq_next; } } if (create) ipsq = ipsq_create(groupname); return (ipsq); } static void ipsq_delete(ipsq_t *ipsq) { ipsq_t *nipsq; ipsq_t *pipsq = NULL; /* * We don't hold the ipsq lock, but we are sure no new * messages can land up, since the ipsq_refs is zero. * i.e. this ipsq is unnamed and no phyint or phyint group * is associated with this ipsq. (Lookups are based on ill_name * or phyint_group_name) */ ASSERT(ipsq->ipsq_refs == 0); ASSERT(ipsq->ipsq_xopq_mphead == NULL && ipsq->ipsq_mphead == NULL); ASSERT(ipsq->ipsq_pending_mp == NULL); if (!(ipsq->ipsq_flags & IPSQ_GROUP)) { /* * This is not the ipsq of an IPMP group. */ kmem_free(ipsq, sizeof (ipsq_t)); return; } rw_enter(&ill_g_lock, RW_WRITER); /* * Locate the ipsq before we can remove it from * the singly linked list of ipsq's. */ for (nipsq = ipsq_g_head; nipsq != NULL; nipsq = nipsq->ipsq_next) { if (nipsq == ipsq) { break; } pipsq = nipsq; } ASSERT(nipsq == ipsq); /* unlink ipsq from the list */ if (pipsq != NULL) pipsq->ipsq_next = ipsq->ipsq_next; else ipsq_g_head = ipsq->ipsq_next; kmem_free(ipsq, sizeof (ipsq_t)); rw_exit(&ill_g_lock); } static void ill_move_to_new_ipsq(ipsq_t *old_ipsq, ipsq_t *new_ipsq, mblk_t *current_mp, queue_t *q) { ASSERT(MUTEX_HELD(&new_ipsq->ipsq_lock)); ASSERT(old_ipsq->ipsq_mphead == NULL && old_ipsq->ipsq_mptail == NULL); ASSERT(old_ipsq->ipsq_pending_ipif == NULL); ASSERT(old_ipsq->ipsq_pending_mp == NULL); ASSERT(current_mp != NULL); ipsq_enq(new_ipsq, q, current_mp, (ipsq_func_t)ip_process_ioctl, NEW_OP, NULL); ASSERT(new_ipsq->ipsq_xopq_mptail != NULL && new_ipsq->ipsq_xopq_mphead != NULL); /* * move from old ipsq to the new ipsq. */ new_ipsq->ipsq_xopq_mptail->b_next = old_ipsq->ipsq_xopq_mphead; if (old_ipsq->ipsq_xopq_mphead != NULL) new_ipsq->ipsq_xopq_mptail = old_ipsq->ipsq_xopq_mptail; old_ipsq->ipsq_xopq_mphead = old_ipsq->ipsq_xopq_mptail = NULL; } void ill_group_cleanup(ill_t *ill) { ill_t *ill_v4; ill_t *ill_v6; ipif_t *ipif; ill_v4 = ill->ill_phyint->phyint_illv4; ill_v6 = ill->ill_phyint->phyint_illv6; if (ill_v4 != NULL) { mutex_enter(&ill_v4->ill_lock); for (ipif = ill_v4->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { IPIF_UNMARK_MOVING(ipif); } ill_v4->ill_up_ipifs = B_FALSE; mutex_exit(&ill_v4->ill_lock); } if (ill_v6 != NULL) { mutex_enter(&ill_v6->ill_lock); for (ipif = ill_v6->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { IPIF_UNMARK_MOVING(ipif); } ill_v6->ill_up_ipifs = B_FALSE; mutex_exit(&ill_v6->ill_lock); } } /* * This function is called when an ill has had a change in its group status * to bring up all the ipifs that were up before the change. */ int ill_up_ipifs(ill_t *ill, queue_t *q, mblk_t *mp) { ipif_t *ipif; ill_t *ill_v4; ill_t *ill_v6; ill_t *from_ill; int err = 0; ASSERT(IAM_WRITER_ILL(ill)); /* * Except for ipif_state_flags and ill_state_flags the other * fields of the ipif/ill that are modified below are protected * implicitly since we are a writer. We would have tried to down * even an ipif that was already down, in ill_down_ipifs. So we * just blindly clear the IPIF_CHANGING flag here on all ipifs. */ ill_v4 = ill->ill_phyint->phyint_illv4; ill_v6 = ill->ill_phyint->phyint_illv6; if (ill_v4 != NULL) { ill_v4->ill_up_ipifs = B_TRUE; for (ipif = ill_v4->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { mutex_enter(&ill_v4->ill_lock); ipif->ipif_state_flags &= ~IPIF_CHANGING; IPIF_UNMARK_MOVING(ipif); mutex_exit(&ill_v4->ill_lock); if (ipif->ipif_was_up) { if (!(ipif->ipif_flags & IPIF_UP)) err = ipif_up(ipif, q, mp); ipif->ipif_was_up = B_FALSE; if (err != 0) { /* * Can there be any other error ? */ ASSERT(err == EINPROGRESS); return (err); } } } mutex_enter(&ill_v4->ill_lock); ill_v4->ill_state_flags &= ~ILL_CHANGING; mutex_exit(&ill_v4->ill_lock); ill_v4->ill_up_ipifs = B_FALSE; if (ill_v4->ill_move_in_progress) { ASSERT(ill_v4->ill_move_peer != NULL); ill_v4->ill_move_in_progress = B_FALSE; from_ill = ill_v4->ill_move_peer; from_ill->ill_move_in_progress = B_FALSE; from_ill->ill_move_peer = NULL; mutex_enter(&from_ill->ill_lock); from_ill->ill_state_flags &= ~ILL_CHANGING; mutex_exit(&from_ill->ill_lock); if (ill_v6 == NULL) { if (from_ill->ill_phyint->phyint_flags & PHYI_STANDBY) { phyint_inactive(from_ill->ill_phyint); } if (ill_v4->ill_phyint->phyint_flags & PHYI_STANDBY) { phyint_inactive(ill_v4->ill_phyint); } } ill_v4->ill_move_peer = NULL; } } if (ill_v6 != NULL) { ill_v6->ill_up_ipifs = B_TRUE; for (ipif = ill_v6->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { mutex_enter(&ill_v6->ill_lock); ipif->ipif_state_flags &= ~IPIF_CHANGING; IPIF_UNMARK_MOVING(ipif); mutex_exit(&ill_v6->ill_lock); if (ipif->ipif_was_up) { if (!(ipif->ipif_flags & IPIF_UP)) err = ipif_up(ipif, q, mp); ipif->ipif_was_up = B_FALSE; if (err != 0) { /* * Can there be any other error ? */ ASSERT(err == EINPROGRESS); return (err); } } } mutex_enter(&ill_v6->ill_lock); ill_v6->ill_state_flags &= ~ILL_CHANGING; mutex_exit(&ill_v6->ill_lock); ill_v6->ill_up_ipifs = B_FALSE; if (ill_v6->ill_move_in_progress) { ASSERT(ill_v6->ill_move_peer != NULL); ill_v6->ill_move_in_progress = B_FALSE; from_ill = ill_v6->ill_move_peer; from_ill->ill_move_in_progress = B_FALSE; from_ill->ill_move_peer = NULL; mutex_enter(&from_ill->ill_lock); from_ill->ill_state_flags &= ~ILL_CHANGING; mutex_exit(&from_ill->ill_lock); if (from_ill->ill_phyint->phyint_flags & PHYI_STANDBY) { phyint_inactive(from_ill->ill_phyint); } if (ill_v6->ill_phyint->phyint_flags & PHYI_STANDBY) { phyint_inactive(ill_v6->ill_phyint); } ill_v6->ill_move_peer = NULL; } } return (0); } /* * bring down all the approriate ipifs. */ /* ARGSUSED */ static void ill_down_ipifs(ill_t *ill, mblk_t *mp, int index, boolean_t chk_nofailover) { ipif_t *ipif; ASSERT(IAM_WRITER_ILL(ill)); /* * Except for ipif_state_flags the other fields of the ipif/ill that * are modified below are protected implicitly since we are a writer */ for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (chk_nofailover && (ipif->ipif_flags & IPIF_NOFAILOVER)) continue; if (index == 0 || index == ipif->ipif_orig_ifindex) { /* * We go through the ipif_down logic even if the ipif * is already down, since routes can be added based * on down ipifs. Going through ipif_down once again * will delete any IREs created based on these routes. */ if (ipif->ipif_flags & IPIF_UP) ipif->ipif_was_up = B_TRUE; /* * If called with chk_nofailover true ipif is moving. */ mutex_enter(&ill->ill_lock); if (chk_nofailover) { ipif->ipif_state_flags |= IPIF_MOVING | IPIF_CHANGING; } else { ipif->ipif_state_flags |= IPIF_CHANGING; } mutex_exit(&ill->ill_lock); /* * Need to re-create net/subnet bcast ires if * they are dependent on ipif. */ if (!ipif->ipif_isv6) ipif_check_bcast_ires(ipif); (void) ipif_logical_down(ipif, NULL, NULL); ipif_down_tail(ipif); /* * We don't do ipif_multicast_down for IPv4 in * ipif_down. We need to set this so that * ipif_multicast_up will join the * ALLHOSTS_GROUP on to_ill. */ ipif->ipif_multicast_up = B_FALSE; } } } #define IPSQ_INC_REF(ipsq) { \ ASSERT(RW_WRITE_HELD(&ill_g_lock)); \ (ipsq)->ipsq_refs++; \ } #define IPSQ_DEC_REF(ipsq) { \ ASSERT(RW_WRITE_HELD(&ill_g_lock)); \ (ipsq)->ipsq_refs--; \ if ((ipsq)->ipsq_refs == 0) \ (ipsq)->ipsq_name[0] = '\0'; \ } /* * Change the ipsq of all the ill's whose current ipsq is 'cur_ipsq' to * new_ipsq. */ static void ill_merge_ipsq(ipsq_t *cur_ipsq, ipsq_t *new_ipsq) { phyint_t *phyint; phyint_t *next_phyint; /* * To change the ipsq of an ill, we need to hold the ill_g_lock as * writer and the ill_lock of the ill in question. Also the dest * ipsq can't vanish while we hold the ill_g_lock as writer. */ ASSERT(RW_WRITE_HELD(&ill_g_lock)); phyint = cur_ipsq->ipsq_phyint_list; cur_ipsq->ipsq_phyint_list = NULL; while (phyint != NULL) { next_phyint = phyint->phyint_ipsq_next; IPSQ_DEC_REF(cur_ipsq); phyint->phyint_ipsq_next = new_ipsq->ipsq_phyint_list; new_ipsq->ipsq_phyint_list = phyint; IPSQ_INC_REF(new_ipsq); phyint->phyint_ipsq = new_ipsq; phyint = next_phyint; } } #define SPLIT_SUCCESS 0 #define SPLIT_NOT_NEEDED 1 #define SPLIT_FAILED 2 int ill_split_to_grp_ipsq(phyint_t *phyint, ipsq_t *cur_ipsq, boolean_t need_retry) { ipsq_t *newipsq = NULL; /* * Assertions denote pre-requisites for changing the ipsq of * a phyint */ ASSERT(RW_WRITE_HELD(&ill_g_lock)); /* * assocs can't change while ill_g_lock * is held as writer. See ill_phyint_reinit() */ ASSERT(phyint->phyint_illv4 == NULL || MUTEX_HELD(&phyint->phyint_illv4->ill_lock)); ASSERT(phyint->phyint_illv6 == NULL || MUTEX_HELD(&phyint->phyint_illv6->ill_lock)); if ((phyint->phyint_groupname_len != (strlen(cur_ipsq->ipsq_name) + 1) || bcmp(phyint->phyint_groupname, cur_ipsq->ipsq_name, phyint->phyint_groupname_len) != 0)) { /* * Once we fail in creating a new ipsq due to memory shortage, * don't attempt to create new ipsq again, based on another * phyint, since we want all phyints belonging to an IPMP group * to be in the same ipsq even in the event of mem alloc fails. */ newipsq = ip_ipsq_lookup(phyint->phyint_groupname, !need_retry, cur_ipsq); if (newipsq == NULL) { /* Memory allocation failure */ return (SPLIT_FAILED); } else { /* ipsq_refs protected by ill_g_lock (writer) */ IPSQ_DEC_REF(cur_ipsq); phyint->phyint_ipsq = newipsq; phyint->phyint_ipsq_next = newipsq->ipsq_phyint_list; newipsq->ipsq_phyint_list = phyint; IPSQ_INC_REF(newipsq); return (SPLIT_SUCCESS); } } return (SPLIT_NOT_NEEDED); } /* * The ill locks of the phyint and the ill_g_lock (writer) must be held * to do this split */ static int ill_split_to_own_ipsq(phyint_t *phyint, ipsq_t *cur_ipsq) { ipsq_t *newipsq; ASSERT(RW_WRITE_HELD(&ill_g_lock)); /* * assocs can't change while ill_g_lock * is held as writer. See ill_phyint_reinit() */ ASSERT(phyint->phyint_illv4 == NULL || MUTEX_HELD(&phyint->phyint_illv4->ill_lock)); ASSERT(phyint->phyint_illv6 == NULL || MUTEX_HELD(&phyint->phyint_illv6->ill_lock)); if (!ipsq_init((phyint->phyint_illv4 != NULL) ? phyint->phyint_illv4: phyint->phyint_illv6)) { /* * ipsq_init failed due to no memory * caller will use the same ipsq */ return (SPLIT_FAILED); } /* ipsq_ref is protected by ill_g_lock (writer) */ IPSQ_DEC_REF(cur_ipsq); /* * This is a new ipsq that is unknown to the world. * So we don't need to hold ipsq_lock, */ newipsq = phyint->phyint_ipsq; newipsq->ipsq_writer = NULL; newipsq->ipsq_reentry_cnt--; ASSERT(newipsq->ipsq_reentry_cnt == 0); #ifdef ILL_DEBUG newipsq->ipsq_depth = 0; #endif return (SPLIT_SUCCESS); } /* * Change the ipsq of all the ill's whose current ipsq is 'cur_ipsq' to * ipsq's representing their individual groups or themselves. Return * whether split needs to be retried again later. */ static boolean_t ill_split_ipsq(ipsq_t *cur_ipsq) { phyint_t *phyint; phyint_t *next_phyint; int error; boolean_t need_retry = B_FALSE; phyint = cur_ipsq->ipsq_phyint_list; cur_ipsq->ipsq_phyint_list = NULL; while (phyint != NULL) { next_phyint = phyint->phyint_ipsq_next; /* * 'created' will tell us whether the callee actually * created an ipsq. Lack of memory may force the callee * to return without creating an ipsq. */ if (phyint->phyint_groupname == NULL) { error = ill_split_to_own_ipsq(phyint, cur_ipsq); } else { error = ill_split_to_grp_ipsq(phyint, cur_ipsq, need_retry); } switch (error) { case SPLIT_FAILED: need_retry = B_TRUE; /* FALLTHRU */ case SPLIT_NOT_NEEDED: /* * Keep it on the list. */ phyint->phyint_ipsq_next = cur_ipsq->ipsq_phyint_list; cur_ipsq->ipsq_phyint_list = phyint; break; case SPLIT_SUCCESS: break; default: ASSERT(0); } phyint = next_phyint; } return (need_retry); } /* * given an ipsq 'ipsq' lock all ills associated with this ipsq. * and return the ills in the list. This list will be * needed to unlock all the ills later on by the caller. * The associations could change between the * lock and unlock. Hence the unlock can't traverse the * ipsq to get the list of ills. */ static int ill_lock_ipsq_ills(ipsq_t *ipsq, ill_t **list, int list_max) { int cnt = 0; phyint_t *phyint; /* * The caller holds ill_g_lock to ensure that the ill memberships * of the ipsq don't change */ ASSERT(RW_LOCK_HELD(&ill_g_lock)); phyint = ipsq->ipsq_phyint_list; while (phyint != NULL) { if (phyint->phyint_illv4 != NULL) { ASSERT(cnt < list_max); list[cnt++] = phyint->phyint_illv4; } if (phyint->phyint_illv6 != NULL) { ASSERT(cnt < list_max); list[cnt++] = phyint->phyint_illv6; } phyint = phyint->phyint_ipsq_next; } ill_lock_ills(list, cnt); return (cnt); } void ill_lock_ills(ill_t **list, int cnt) { int i; if (cnt > 1) { boolean_t try_again; do { try_again = B_FALSE; for (i = 0; i < cnt - 1; i++) { if (list[i] < list[i + 1]) { ill_t *tmp; /* swap the elements */ tmp = list[i]; list[i] = list[i + 1]; list[i + 1] = tmp; try_again = B_TRUE; } } } while (try_again); } for (i = 0; i < cnt; i++) { if (i == 0) { if (list[i] != NULL) mutex_enter(&list[i]->ill_lock); else return; } else if ((list[i-1] != list[i]) && (list[i] != NULL)) { mutex_enter(&list[i]->ill_lock); } } } void ill_unlock_ills(ill_t **list, int cnt) { int i; for (i = 0; i < cnt; i++) { if ((i == 0) && (list[i] != NULL)) { mutex_exit(&list[i]->ill_lock); } else if ((list[i-1] != list[i]) && (list[i] != NULL)) { mutex_exit(&list[i]->ill_lock); } } } /* * Merge all the ills from 1 ipsq group into another ipsq group. * The source ipsq group is specified by the ipsq associated with * 'from_ill'. The destination ipsq group is specified by the ipsq * associated with 'to_ill' or 'groupname' respectively. * Note that ipsq itself does not have a reference count mechanism * and functions don't look up an ipsq and pass it around. Instead * functions pass around an ill or groupname, and the ipsq is looked * up from the ill or groupname and the required operation performed * atomically with the lookup on the ipsq. */ static int ill_merge_groups(ill_t *from_ill, ill_t *to_ill, char *groupname, mblk_t *mp, queue_t *q) { ipsq_t *old_ipsq; ipsq_t *new_ipsq; ill_t **ill_list; int cnt; size_t ill_list_size; boolean_t became_writer_on_new_sq = B_FALSE; /* Exactly 1 of 'to_ill' and groupname can be specified. */ ASSERT((to_ill != NULL) ^ (groupname != NULL)); /* * Need to hold ill_g_lock as writer and also the ill_lock to * change the assoc of an ill. Need to hold the * ipsq_lock to prevent new messages from landing on an ipsq. */ rw_enter(&ill_g_lock, RW_WRITER); old_ipsq = from_ill->ill_phyint->phyint_ipsq; if (groupname != NULL) new_ipsq = ip_ipsq_lookup(groupname, B_TRUE, NULL); else { new_ipsq = to_ill->ill_phyint->phyint_ipsq; } ASSERT(old_ipsq != NULL && new_ipsq != NULL); /* * both groups are on the same ipsq. */ if (old_ipsq == new_ipsq) { rw_exit(&ill_g_lock); return (0); } cnt = old_ipsq->ipsq_refs << 1; ill_list_size = cnt * sizeof (ill_t *); ill_list = kmem_zalloc(ill_list_size, KM_NOSLEEP); if (ill_list == NULL) { rw_exit(&ill_g_lock); return (ENOMEM); } cnt = ill_lock_ipsq_ills(old_ipsq, ill_list, cnt); /* Need ipsq lock to enque messages on new ipsq or to become writer */ mutex_enter(&new_ipsq->ipsq_lock); if ((new_ipsq->ipsq_writer == NULL && new_ipsq->ipsq_current_ipif == NULL) || (new_ipsq->ipsq_writer == curthread)) { new_ipsq->ipsq_writer = curthread; new_ipsq->ipsq_reentry_cnt++; became_writer_on_new_sq = B_TRUE; } /* * We are holding ill_g_lock as writer and all the ill locks of * the old ipsq. So the old_ipsq can't be looked up, and hence no new * message can land up on the old ipsq even though we don't hold the * ipsq_lock of the old_ipsq. Now move all messages to the newipsq. */ ill_move_to_new_ipsq(old_ipsq, new_ipsq, mp, q); /* * now change the ipsq of all ills in the 'old_ipsq' to 'new_ipsq'. * 'new_ipsq' has been looked up, and it can't change its * assocs. till we release the ill_g_lock, and hence it can't vanish. */ ill_merge_ipsq(old_ipsq, new_ipsq); /* * Mark the new ipsq as needing a split since it is currently * being shared by more than 1 IPMP group. The split will * occur at the end of ipsq_exit */ new_ipsq->ipsq_split = B_TRUE; /* Now release all the locks */ mutex_exit(&new_ipsq->ipsq_lock); ill_unlock_ills(ill_list, cnt); rw_exit(&ill_g_lock); kmem_free(ill_list, ill_list_size); /* * If we succeeded in becoming writer on the new ipsq, then * drain the new ipsq and start processing all enqueued messages * including the current ioctl we are processing which is either * a set groupname or failover/failback. */ if (became_writer_on_new_sq) ipsq_exit(new_ipsq, B_TRUE, B_TRUE); /* * syncq has been changed and all the messages have been moved. */ mutex_enter(&old_ipsq->ipsq_lock); old_ipsq->ipsq_current_ipif = NULL; mutex_exit(&old_ipsq->ipsq_lock); return (EINPROGRESS); } /* * Delete and add the loopback copy and non-loopback copy of * the BROADCAST ire corresponding to ill and addr. Used to * group broadcast ires together when ill becomes part of * a group. * * This function is also called when ill is leaving the group * so that the ires belonging to the group gets re-grouped. */ static void ill_bcast_delete_and_add(ill_t *ill, ipaddr_t addr) { ire_t *ire, *nire, *nire_next, *ire_head = NULL; ire_t **ire_ptpn = &ire_head; /* * The loopback and non-loopback IREs are inserted in the order in which * they're found, on the basis that they are correctly ordered (loopback * first). */ for (;;) { ire = ire_ctable_lookup(addr, 0, IRE_BROADCAST, ill->ill_ipif, ALL_ZONES, MATCH_IRE_TYPE | MATCH_IRE_ILL); if (ire == NULL) break; /* * we are passing in KM_SLEEP because it is not easy to * go back to a sane state in case of memory failure. */ nire = kmem_cache_alloc(ire_cache, KM_SLEEP); ASSERT(nire != NULL); bzero(nire, sizeof (ire_t)); /* * Don't use ire_max_frag directly since we don't * hold on to 'ire' until we add the new ire 'nire' and * we don't want the new ire to have a dangling reference * to 'ire'. The ire_max_frag of a broadcast ire must * be in sync with the ipif_mtu of the associate ipif. * For eg. this happens as a result of SIOCSLIFNAME, * SIOCSLIFLNKINFO or a DL_NOTE_SDU_SIZE inititated by * the driver. A change in ire_max_frag triggered as * as a result of path mtu discovery, or due to an * IP_IOC_IRE_ADVISE_NOREPLY from the transport or due a * route change -mtu command does not apply to broadcast ires. * * XXX We need a recovery strategy here if ire_init fails */ if (ire_init(nire, (uchar_t *)&ire->ire_addr, (uchar_t *)&ire->ire_mask, (uchar_t *)&ire->ire_src_addr, (uchar_t *)&ire->ire_gateway_addr, (uchar_t *)&ire->ire_in_src_addr, ire->ire_stq == NULL ? &ip_loopback_mtu : &ire->ire_ipif->ipif_mtu, ire->ire_fp_mp, ire->ire_rfq, ire->ire_stq, ire->ire_type, ire->ire_dlureq_mp, ire->ire_ipif, ire->ire_in_ill, ire->ire_cmask, ire->ire_phandle, ire->ire_ihandle, ire->ire_flags, &ire->ire_uinfo) == NULL) { cmn_err(CE_PANIC, "ire_init() failed"); } ire_delete(ire); ire_refrele(ire); /* * The newly created IREs are inserted at the tail of the list * starting with ire_head. As we've just allocated them no one * knows about them so it's safe. */ *ire_ptpn = nire; ire_ptpn = &nire->ire_next; } for (nire = ire_head; nire != NULL; nire = nire_next) { int error; ire_t *oire; /* unlink the IRE from our list before calling ire_add() */ nire_next = nire->ire_next; nire->ire_next = NULL; /* ire_add adds the ire at the right place in the list */ oire = nire; error = ire_add(&nire, NULL, NULL, NULL); ASSERT(error == 0); ASSERT(oire == nire); ire_refrele(nire); /* Held in ire_add */ } } /* * This function is usually called when an ill is inserted in * a group and all the ipifs are already UP. As all the ipifs * are already UP, the broadcast ires have already been created * and been inserted. But, ire_add_v4 would not have grouped properly. * We need to re-group for the benefit of ip_wput_ire which * expects BROADCAST ires to be grouped properly to avoid sending * more than one copy of the broadcast packet per group. * * NOTE : We don't check for ill_ipif_up_count to be non-zero here * because when ipif_up_done ends up calling this, ires have * already been added before illgrp_insert i.e before ill_group * has been initialized. */ static void ill_group_bcast_for_xmit(ill_t *ill) { ill_group_t *illgrp; ipif_t *ipif; ipaddr_t addr; ipaddr_t net_mask; ipaddr_t subnet_netmask; illgrp = ill->ill_group; /* * This function is called even when an ill is deleted from * the group. Hence, illgrp could be null. */ if (illgrp != NULL && illgrp->illgrp_ill_count == 1) return; /* * Delete all the BROADCAST ires matching this ill and add * them back. This time, ire_add_v4 should take care of * grouping them with others because ill is part of the * group. */ ill_bcast_delete_and_add(ill, 0); ill_bcast_delete_and_add(ill, INADDR_BROADCAST); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { net_mask = ip_net_mask(ipif->ipif_lcl_addr); } else { net_mask = htonl(IN_CLASSA_NET); } addr = net_mask & ipif->ipif_subnet; ill_bcast_delete_and_add(ill, addr); ill_bcast_delete_and_add(ill, ~net_mask | addr); subnet_netmask = ipif->ipif_net_mask; addr = ipif->ipif_subnet; ill_bcast_delete_and_add(ill, addr); ill_bcast_delete_and_add(ill, ~subnet_netmask | addr); } } /* * This function is called from illgrp_delete when ill is being deleted * from the group. * * As ill is not there in the group anymore, any address belonging * to this ill should be cleared of IRE_MARK_NORECV. */ static void ill_clear_bcast_mark(ill_t *ill, ipaddr_t addr) { ire_t *ire; irb_t *irb; ASSERT(ill->ill_group == NULL); ire = ire_ctable_lookup(addr, 0, IRE_BROADCAST, ill->ill_ipif, ALL_ZONES, MATCH_IRE_TYPE | MATCH_IRE_ILL); if (ire != NULL) { /* * IPMP and plumbing operations are serialized on the ipsq, so * no one will insert or delete a broadcast ire under our feet. */ irb = ire->ire_bucket; rw_enter(&irb->irb_lock, RW_READER); ire_refrele(ire); for (; ire != NULL; ire = ire->ire_next) { if (ire->ire_addr != addr) break; if (ire_to_ill(ire) != ill) continue; ASSERT(!(ire->ire_marks & IRE_MARK_CONDEMNED)); ire->ire_marks &= ~IRE_MARK_NORECV; } rw_exit(&irb->irb_lock); } } /* * This function must be called only after the broadcast ires * have been grouped together. For a given address addr, nominate * only one of the ires whose interface is not FAILED or OFFLINE. * * This is also called when an ipif goes down, so that we can nominate * a different ire with the same address for receiving. */ static void ill_mark_bcast(ill_group_t *illgrp, ipaddr_t addr) { irb_t *irb; ire_t *ire; ire_t *ire1; ire_t *save_ire; ire_t **irep = NULL; boolean_t first = B_TRUE; ire_t *clear_ire = NULL; ire_t *start_ire = NULL; ire_t *new_lb_ire; ire_t *new_nlb_ire; boolean_t new_lb_ire_used = B_FALSE; boolean_t new_nlb_ire_used = B_FALSE; uint64_t match_flags; uint64_t phyi_flags; boolean_t fallback = B_FALSE; ire = ire_ctable_lookup(addr, 0, IRE_BROADCAST, NULL, ALL_ZONES, MATCH_IRE_TYPE); /* * We may not be able to find some ires if a previous * ire_create failed. This happens when an ipif goes * down and we are unable to create BROADCAST ires due * to memory failure. Thus, we have to check for NULL * below. This should handle the case for LOOPBACK, * POINTOPOINT and interfaces with some POINTOPOINT * logicals for which there are no BROADCAST ires. */ if (ire == NULL) return; /* * Currently IRE_BROADCASTS are deleted when an ipif * goes down which runs exclusively. Thus, setting * IRE_MARK_RCVD should not race with ire_delete marking * IRE_MARK_CONDEMNED. We grab the lock below just to * be consistent with other parts of the code that walks * a given bucket. */ save_ire = ire; irb = ire->ire_bucket; new_lb_ire = kmem_cache_alloc(ire_cache, KM_NOSLEEP); if (new_lb_ire == NULL) { ire_refrele(ire); return; } new_nlb_ire = kmem_cache_alloc(ire_cache, KM_NOSLEEP); if (new_nlb_ire == NULL) { ire_refrele(ire); kmem_cache_free(ire_cache, new_lb_ire); return; } IRB_REFHOLD(irb); rw_enter(&irb->irb_lock, RW_WRITER); /* * Get to the first ire matching the address and the * group. If the address does not match we are done * as we could not find the IRE. If the address matches * we should get to the first one matching the group. */ while (ire != NULL) { if (ire->ire_addr != addr || ire->ire_ipif->ipif_ill->ill_group == illgrp) { break; } ire = ire->ire_next; } match_flags = PHYI_FAILED | PHYI_INACTIVE; start_ire = ire; redo: while (ire != NULL && ire->ire_addr == addr && ire->ire_ipif->ipif_ill->ill_group == illgrp) { /* * The first ire for any address within a group * should always be the one with IRE_MARK_NORECV cleared * so that ip_wput_ire can avoid searching for one. * Note down the insertion point which will be used * later. */ if (first && (irep == NULL)) irep = ire->ire_ptpn; /* * PHYI_FAILED is set when the interface fails. * This interface might have become good, but the * daemon has not yet detected. We should still * not receive on this. PHYI_OFFLINE should never * be picked as this has been offlined and soon * be removed. */ phyi_flags = ire->ire_ipif->ipif_ill->ill_phyint->phyint_flags; if (phyi_flags & PHYI_OFFLINE) { ire->ire_marks |= IRE_MARK_NORECV; ire = ire->ire_next; continue; } if (phyi_flags & match_flags) { ire->ire_marks |= IRE_MARK_NORECV; ire = ire->ire_next; if ((phyi_flags & (PHYI_FAILED | PHYI_INACTIVE)) == PHYI_INACTIVE) { fallback = B_TRUE; } continue; } if (first) { /* * We will move this to the front of the list later * on. */ clear_ire = ire; ire->ire_marks &= ~IRE_MARK_NORECV; } else { ire->ire_marks |= IRE_MARK_NORECV; } first = B_FALSE; ire = ire->ire_next; } /* * If we never nominated anybody, try nominating at least * an INACTIVE, if we found one. Do it only once though. */ if (first && (match_flags == (PHYI_FAILED | PHYI_INACTIVE)) && fallback) { match_flags = PHYI_FAILED; ire = start_ire; irep = NULL; goto redo; } ire_refrele(save_ire); /* * irep non-NULL indicates that we entered the while loop * above. If clear_ire is at the insertion point, we don't * have to do anything. clear_ire will be NULL if all the * interfaces are failed. * * We cannot unlink and reinsert the ire at the right place * in the list since there can be other walkers of this bucket. * Instead we delete and recreate the ire */ if (clear_ire != NULL && irep != NULL && *irep != clear_ire) { ire_t *clear_ire_stq = NULL; bzero(new_lb_ire, sizeof (ire_t)); /* XXX We need a recovery strategy here. */ if (ire_init(new_lb_ire, (uchar_t *)&clear_ire->ire_addr, (uchar_t *)&clear_ire->ire_mask, (uchar_t *)&clear_ire->ire_src_addr, (uchar_t *)&clear_ire->ire_gateway_addr, (uchar_t *)&clear_ire->ire_in_src_addr, &clear_ire->ire_max_frag, clear_ire->ire_fp_mp, clear_ire->ire_rfq, clear_ire->ire_stq, clear_ire->ire_type, clear_ire->ire_dlureq_mp, clear_ire->ire_ipif, clear_ire->ire_in_ill, clear_ire->ire_cmask, clear_ire->ire_phandle, clear_ire->ire_ihandle, clear_ire->ire_flags, &clear_ire->ire_uinfo) == NULL) cmn_err(CE_PANIC, "ire_init() failed"); if (clear_ire->ire_stq == NULL) { ire_t *ire_next = clear_ire->ire_next; if (ire_next != NULL && ire_next->ire_stq != NULL && ire_next->ire_addr == clear_ire->ire_addr && ire_next->ire_ipif->ipif_ill == clear_ire->ire_ipif->ipif_ill) { clear_ire_stq = ire_next; bzero(new_nlb_ire, sizeof (ire_t)); /* XXX We need a recovery strategy here. */ if (ire_init(new_nlb_ire, (uchar_t *)&clear_ire_stq->ire_addr, (uchar_t *)&clear_ire_stq->ire_mask, (uchar_t *)&clear_ire_stq->ire_src_addr, (uchar_t *)&clear_ire_stq->ire_gateway_addr, (uchar_t *)&clear_ire_stq->ire_in_src_addr, &clear_ire_stq->ire_max_frag, clear_ire_stq->ire_fp_mp, clear_ire_stq->ire_rfq, clear_ire_stq->ire_stq, clear_ire_stq->ire_type, clear_ire_stq->ire_dlureq_mp, clear_ire_stq->ire_ipif, clear_ire_stq->ire_in_ill, clear_ire_stq->ire_cmask, clear_ire_stq->ire_phandle, clear_ire_stq->ire_ihandle, clear_ire_stq->ire_flags, &clear_ire_stq->ire_uinfo) == NULL) cmn_err(CE_PANIC, "ire_init() failed"); } } /* * Delete the ire. We can't call ire_delete() since * we are holding the bucket lock. We can't release the * bucket lock since we can't allow irep to change. So just * mark it CONDEMNED. The IRB_REFRELE will delete the * ire from the list and do the refrele. */ clear_ire->ire_marks |= IRE_MARK_CONDEMNED; irb->irb_marks |= IRE_MARK_CONDEMNED; if (clear_ire_stq != NULL) { ire_fastpath_list_delete( (ill_t *)clear_ire_stq->ire_stq->q_ptr, clear_ire_stq); clear_ire_stq->ire_marks |= IRE_MARK_CONDEMNED; } /* * Also take care of otherfields like ib/ob pkt count * etc. Need to dup them. ditto in ill_bcast_delete_and_add */ /* Add the new ire's. Insert at *irep */ new_lb_ire->ire_bucket = clear_ire->ire_bucket; ire1 = *irep; if (ire1 != NULL) ire1->ire_ptpn = &new_lb_ire->ire_next; new_lb_ire->ire_next = ire1; /* Link the new one in. */ new_lb_ire->ire_ptpn = irep; membar_producer(); *irep = new_lb_ire; new_lb_ire_used = B_TRUE; BUMP_IRE_STATS(ire_stats_v4, ire_stats_inserted); new_lb_ire->ire_bucket->irb_ire_cnt++; new_lb_ire->ire_ipif->ipif_ire_cnt++; if (clear_ire_stq != NULL) { new_nlb_ire->ire_bucket = clear_ire->ire_bucket; irep = &new_lb_ire->ire_next; /* Add the new ire. Insert at *irep */ ire1 = *irep; if (ire1 != NULL) ire1->ire_ptpn = &new_nlb_ire->ire_next; new_nlb_ire->ire_next = ire1; /* Link the new one in. */ new_nlb_ire->ire_ptpn = irep; membar_producer(); *irep = new_nlb_ire; new_nlb_ire_used = B_TRUE; BUMP_IRE_STATS(ire_stats_v4, ire_stats_inserted); new_nlb_ire->ire_bucket->irb_ire_cnt++; new_nlb_ire->ire_ipif->ipif_ire_cnt++; ((ill_t *)new_nlb_ire->ire_stq->q_ptr)->ill_ire_cnt++; } } rw_exit(&irb->irb_lock); if (!new_lb_ire_used) kmem_cache_free(ire_cache, new_lb_ire); if (!new_nlb_ire_used) kmem_cache_free(ire_cache, new_nlb_ire); IRB_REFRELE(irb); } /* * Whenever an ipif goes down we have to renominate a different * broadcast ire to receive. Whenever an ipif comes up, we need * to make sure that we have only one nominated to receive. */ static void ipif_renominate_bcast(ipif_t *ipif) { ill_t *ill = ipif->ipif_ill; ipaddr_t subnet_addr; ipaddr_t net_addr; ipaddr_t net_mask = 0; ipaddr_t subnet_netmask; ipaddr_t addr; ill_group_t *illgrp; illgrp = ill->ill_group; /* * If this is the last ipif going down, it might take * the ill out of the group. In that case ipif_down -> * illgrp_delete takes care of doing the nomination. * ipif_down does not call for this case. */ ASSERT(illgrp != NULL); /* There could not have been any ires associated with this */ if (ipif->ipif_subnet == 0) return; ill_mark_bcast(illgrp, 0); ill_mark_bcast(illgrp, INADDR_BROADCAST); if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { net_mask = ip_net_mask(ipif->ipif_lcl_addr); } else { net_mask = htonl(IN_CLASSA_NET); } addr = net_mask & ipif->ipif_subnet; ill_mark_bcast(illgrp, addr); net_addr = ~net_mask | addr; ill_mark_bcast(illgrp, net_addr); subnet_netmask = ipif->ipif_net_mask; addr = ipif->ipif_subnet; ill_mark_bcast(illgrp, addr); subnet_addr = ~subnet_netmask | addr; ill_mark_bcast(illgrp, subnet_addr); } /* * Whenever we form or delete ill groups, we need to nominate one set of * BROADCAST ires for receiving in the group. * * 1) When ipif_up_done -> ilgrp_insert calls this function, BROADCAST ires * have been added, but ill_ipif_up_count is 0. Thus, we don't assert * for ill_ipif_up_count to be non-zero. This is the only case where * ill_ipif_up_count is zero and we would still find the ires. * * 2) ip_sioctl_group_name/ifgrp_insert calls this function, at least one * ipif is UP and we just have to do the nomination. * * 3) When ill_handoff_responsibility calls us, some ill has been removed * from the group. So, we have to do the nomination. * * Because of (3), there could be just one ill in the group. But we have * to nominate still as IRE_MARK_NORCV may have been marked on this. * Thus, this function does not optimize when there is only one ill as * it is not correct for (3). */ static void ill_nominate_bcast_rcv(ill_group_t *illgrp) { ill_t *ill; ipif_t *ipif; ipaddr_t subnet_addr; ipaddr_t prev_subnet_addr = 0; ipaddr_t net_addr; ipaddr_t prev_net_addr = 0; ipaddr_t net_mask = 0; ipaddr_t subnet_netmask; ipaddr_t addr; /* * When the last memeber is leaving, there is nothing to * nominate. */ if (illgrp->illgrp_ill_count == 0) { ASSERT(illgrp->illgrp_ill == NULL); return; } ill = illgrp->illgrp_ill; ASSERT(!ill->ill_isv6); /* * We assume that ires with same address and belonging to the * same group, has been grouped together. Nominating a *single* * ill in the group for sending and receiving broadcast is done * by making sure that the first BROADCAST ire (which will be * the one returned by ire_ctable_lookup for ip_rput and the * one that will be used in ip_wput_ire) will be the one that * will not have IRE_MARK_NORECV set. * * 1) ip_rput checks and discards packets received on ires marked * with IRE_MARK_NORECV. Thus, we don't send up duplicate * broadcast packets. We need to clear IRE_MARK_NORECV on the * first ire in the group for every broadcast address in the group. * ip_rput will accept packets only on the first ire i.e only * one copy of the ill. * * 2) ip_wput_ire needs to send out just one copy of the broadcast * packet for the whole group. It needs to send out on the ill * whose ire has not been marked with IRE_MARK_NORECV. If it sends * on the one marked with IRE_MARK_NORECV, ip_rput will accept * the copy echoed back on other port where the ire is not marked * with IRE_MARK_NORECV. * * Note that we just need to have the first IRE either loopback or * non-loopback (either of them may not exist if ire_create failed * during ipif_down) with IRE_MARK_NORECV not set. ip_rput will * always hit the first one and hence will always accept one copy. * * We have a broadcast ire per ill for all the unique prefixes * hosted on that ill. As we don't have a way of knowing the * unique prefixes on a given ill and hence in the whole group, * we just call ill_mark_bcast on all the prefixes that exist * in the group. For the common case of one prefix, the code * below optimizes by remebering the last address used for * markng. In the case of multiple prefixes, this will still * optimize depending the order of prefixes. * * The only unique address across the whole group is 0.0.0.0 and * 255.255.255.255 and thus we call only once. ill_mark_bcast enables * the first ire in the bucket for receiving and disables the * others. */ ill_mark_bcast(illgrp, 0); ill_mark_bcast(illgrp, INADDR_BROADCAST); for (; ill != NULL; ill = ill->ill_group_next) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!(ipif->ipif_flags & IPIF_UP) || ipif->ipif_subnet == 0) { continue; } if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { net_mask = ip_net_mask(ipif->ipif_lcl_addr); } else { net_mask = htonl(IN_CLASSA_NET); } addr = net_mask & ipif->ipif_subnet; if (prev_net_addr == 0 || prev_net_addr != addr) { ill_mark_bcast(illgrp, addr); net_addr = ~net_mask | addr; ill_mark_bcast(illgrp, net_addr); } prev_net_addr = addr; subnet_netmask = ipif->ipif_net_mask; addr = ipif->ipif_subnet; if (prev_subnet_addr == 0 || prev_subnet_addr != addr) { ill_mark_bcast(illgrp, addr); subnet_addr = ~subnet_netmask | addr; ill_mark_bcast(illgrp, subnet_addr); } prev_subnet_addr = addr; } } } /* * This function is called while forming ill groups. * * Currently, we handle only allmulti groups. We want to join * allmulti on only one of the ills in the groups. In future, * when we have link aggregation, we may have to join normal * multicast groups on multiple ills as switch does inbound load * balancing. Following are the functions that calls this * function : * * 1) ill_recover_multicast : Interface is coming back UP. * When the first ipif comes back UP, ipif_up_done/ipif_up_done_v6 * will call ill_recover_multicast to recover all the multicast * groups. We need to make sure that only one member is joined * in the ill group. * * 2) ip_addmulti/ip_addmulti_v6 : ill groups has already been formed. * Somebody is joining allmulti. We need to make sure that only one * member is joined in the group. * * 3) illgrp_insert : If allmulti has already joined, we need to make * sure that only one member is joined in the group. * * 4) ip_delmulti/ip_delmulti_v6 : Somebody in the group is leaving * allmulti who we have nominated. We need to pick someother ill. * * 5) illgrp_delete : The ill we nominated is leaving the group, * we need to pick a new ill to join the group. * * For (1), (2), (5) - we just have to check whether there is * a good ill joined in the group. If we could not find any ills * joined the group, we should join. * * For (4), the one that was nominated to receive, left the group. * There could be nobody joined in the group when this function is * called. * * For (3) - we need to explicitly check whether there are multiple * ills joined in the group. * * For simplicity, we don't differentiate any of the above cases. We * just leave the group if it is joined on any of them and join on * the first good ill. */ int ill_nominate_mcast_rcv(ill_group_t *illgrp) { ilm_t *ilm; ill_t *ill; ill_t *fallback_inactive_ill = NULL; ill_t *fallback_failed_ill = NULL; int ret = 0; /* * Leave the allmulti on all the ills and start fresh. */ for (ill = illgrp->illgrp_ill; ill != NULL; ill = ill->ill_group_next) { if (ill->ill_join_allmulti) (void) ip_leave_allmulti(ill->ill_ipif); } /* * Choose a good ill. Fallback to inactive or failed if * none available. We need to fallback to FAILED in the * case where we have 2 interfaces in a group - where * one of them is failed and another is a good one and * the good one (not marked inactive) is leaving the group. */ ret = 0; for (ill = illgrp->illgrp_ill; ill != NULL; ill = ill->ill_group_next) { /* Never pick an offline interface */ if (ill->ill_phyint->phyint_flags & PHYI_OFFLINE) continue; if (ill->ill_phyint->phyint_flags & PHYI_FAILED) { fallback_failed_ill = ill; continue; } if (ill->ill_phyint->phyint_flags & PHYI_INACTIVE) { fallback_inactive_ill = ill; continue; } for (ilm = ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { ret = ip_join_allmulti(ill->ill_ipif); /* * ip_join_allmulti can fail because of memory * failures. So, make sure we join at least * on one ill. */ if (ill->ill_join_allmulti) return (0); } } } if (ret != 0) { /* * If we tried nominating above and failed to do so, * return error. We might have tried multiple times. * But, return the latest error. */ return (ret); } if ((ill = fallback_inactive_ill) != NULL) { for (ilm = ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { ret = ip_join_allmulti(ill->ill_ipif); return (ret); } } } else if ((ill = fallback_failed_ill) != NULL) { for (ilm = ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { ret = ip_join_allmulti(ill->ill_ipif); return (ret); } } } return (0); } /* * This function is called from illgrp_delete after it is * deleted from the group to reschedule responsibilities * to a different ill. */ static void ill_handoff_responsibility(ill_t *ill, ill_group_t *illgrp) { ilm_t *ilm; ipif_t *ipif; ipaddr_t subnet_addr; ipaddr_t net_addr; ipaddr_t net_mask = 0; ipaddr_t subnet_netmask; ipaddr_t addr; ASSERT(ill->ill_group == NULL); /* * Broadcast Responsibility: * * 1. If this ill has been nominated for receiving broadcast * packets, we need to find a new one. Before we find a new * one, we need to re-group the ires that are part of this new * group (assumed by ill_nominate_bcast_rcv). We do this by * calling ill_group_bcast_for_xmit(ill) which will do the right * thing for us. * * 2. If this ill was not nominated for receiving broadcast * packets, we need to clear the IRE_MARK_NORECV flag * so that we continue to send up broadcast packets. */ if (!ill->ill_isv6) { /* * Case 1 above : No optimization here. Just redo the * nomination. */ ill_group_bcast_for_xmit(ill); ill_nominate_bcast_rcv(illgrp); /* * Case 2 above : Lookup and clear IRE_MARK_NORECV. */ ill_clear_bcast_mark(ill, 0); ill_clear_bcast_mark(ill, INADDR_BROADCAST); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!(ipif->ipif_flags & IPIF_UP) || ipif->ipif_subnet == 0) { continue; } if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { net_mask = ip_net_mask(ipif->ipif_lcl_addr); } else { net_mask = htonl(IN_CLASSA_NET); } addr = net_mask & ipif->ipif_subnet; ill_clear_bcast_mark(ill, addr); net_addr = ~net_mask | addr; ill_clear_bcast_mark(ill, net_addr); subnet_netmask = ipif->ipif_net_mask; addr = ipif->ipif_subnet; ill_clear_bcast_mark(ill, addr); subnet_addr = ~subnet_netmask | addr; ill_clear_bcast_mark(ill, subnet_addr); } } /* * Multicast Responsibility. * * If we have joined allmulti on this one, find a new member * in the group to join allmulti. As this ill is already part * of allmulti, we don't have to join on this one. * * If we have not joined allmulti on this one, there is no * responsibility to handoff. But we need to take new * responsibility i.e, join allmulti on this one if we need * to. */ if (ill->ill_join_allmulti) { (void) ill_nominate_mcast_rcv(illgrp); } else { for (ilm = ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { (void) ip_join_allmulti(ill->ill_ipif); break; } } } /* * We intentionally do the flushing of IRE_CACHES only matching * on the ill and not on groups. Note that we are already deleted * from the group. * * This will make sure that all IRE_CACHES whose stq is pointing * at ill_wq or ire_ipif->ipif_ill pointing at this ill will get * deleted and IRE_CACHES that are not pointing at this ill will * be left alone. */ if (ill->ill_isv6) { ire_walk_ill_v6(MATCH_IRE_ILL | MATCH_IRE_TYPE, IRE_CACHE, illgrp_cache_delete, (char *)ill, ill); } else { ire_walk_ill_v4(MATCH_IRE_ILL | MATCH_IRE_TYPE, IRE_CACHE, illgrp_cache_delete, (char *)ill, ill); } /* * Some conn may have cached one of the IREs deleted above. By removing * the ire reference, we clean up the extra reference to the ill held in * ire->ire_stq. */ ipcl_walk(conn_cleanup_stale_ire, NULL); /* * Re-do source address selection for all the members in the * group, if they borrowed source address from one of the ipifs * in this ill. */ for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ill->ill_isv6) { ipif_update_other_ipifs_v6(ipif, illgrp); } else { ipif_update_other_ipifs(ipif, illgrp); } } } /* * Delete the ill from the group. The caller makes sure that it is * in a group and it okay to delete from the group. So, we always * delete here. */ static void illgrp_delete(ill_t *ill) { ill_group_t *illgrp; ill_group_t *tmpg; ill_t *tmp_ill; /* * Reset illgrp_ill_schednext if it was pointing at us. * We need to do this before we set ill_group to NULL. */ rw_enter(&ill_g_lock, RW_WRITER); mutex_enter(&ill->ill_lock); illgrp_reset_schednext(ill); illgrp = ill->ill_group; /* Delete the ill from illgrp. */ if (illgrp->illgrp_ill == ill) { illgrp->illgrp_ill = ill->ill_group_next; } else { tmp_ill = illgrp->illgrp_ill; while (tmp_ill->ill_group_next != ill) { tmp_ill = tmp_ill->ill_group_next; ASSERT(tmp_ill != NULL); } tmp_ill->ill_group_next = ill->ill_group_next; } ill->ill_group = NULL; ill->ill_group_next = NULL; illgrp->illgrp_ill_count--; mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); /* * As this ill is leaving the group, we need to hand off * the responsibilities to the other ills in the group, if * this ill had some responsibilities. */ ill_handoff_responsibility(ill, illgrp); rw_enter(&ill_g_lock, RW_WRITER); if (illgrp->illgrp_ill_count == 0) { ASSERT(illgrp->illgrp_ill == NULL); if (ill->ill_isv6) { if (illgrp == illgrp_head_v6) { illgrp_head_v6 = illgrp->illgrp_next; } else { tmpg = illgrp_head_v6; while (tmpg->illgrp_next != illgrp) { tmpg = tmpg->illgrp_next; ASSERT(tmpg != NULL); } tmpg->illgrp_next = illgrp->illgrp_next; } } else { if (illgrp == illgrp_head_v4) { illgrp_head_v4 = illgrp->illgrp_next; } else { tmpg = illgrp_head_v4; while (tmpg->illgrp_next != illgrp) { tmpg = tmpg->illgrp_next; ASSERT(tmpg != NULL); } tmpg->illgrp_next = illgrp->illgrp_next; } } mutex_destroy(&illgrp->illgrp_lock); mi_free(illgrp); } rw_exit(&ill_g_lock); /* * Even though the ill is out of the group its not necessary * to set ipsq_split as TRUE as the ipifs could be down temporarily * We will split the ipsq when phyint_groupname is set to NULL. */ /* * Send a routing sockets message if we are deleting from * groups with names. */ if (ill->ill_phyint->phyint_groupname_len != 0) ip_rts_ifmsg(ill->ill_ipif); } /* * Re-do source address selection. This is normally called when * an ill joins the group or when a non-NOLOCAL/DEPRECATED/ANYCAST * ipif comes up. */ void ill_update_source_selection(ill_t *ill) { ipif_t *ipif; ASSERT(IAM_WRITER_ILL(ill)); if (ill->ill_group != NULL) ill = ill->ill_group->illgrp_ill; for (; ill != NULL; ill = ill->ill_group_next) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ill->ill_isv6) ipif_recreate_interface_routes_v6(NULL, ipif); else ipif_recreate_interface_routes(NULL, ipif); } } } /* * Insert ill in a group headed by illgrp_head. The caller can either * pass a groupname in which case we search for a group with the * same name to insert in or pass a group to insert in. This function * would only search groups with names. * * NOTE : The caller should make sure that there is at least one ipif * UP on this ill so that illgrp_scheduler can pick this ill * for outbound packets. If ill_ipif_up_count is zero, we have * already sent a DL_UNBIND to the driver and we don't want to * send anymore packets. We don't assert for ipif_up_count * to be greater than zero, because ipif_up_done wants to call * this function before bumping up the ipif_up_count. See * ipif_up_done() for details. */ int illgrp_insert(ill_group_t **illgrp_head, ill_t *ill, char *groupname, ill_group_t *grp_to_insert, boolean_t ipif_is_coming_up) { ill_group_t *illgrp; ill_t *prev_ill; phyint_t *phyi; ASSERT(ill->ill_group == NULL); rw_enter(&ill_g_lock, RW_WRITER); mutex_enter(&ill->ill_lock); if (groupname != NULL) { /* * Look for a group with a matching groupname to insert. */ for (illgrp = *illgrp_head; illgrp != NULL; illgrp = illgrp->illgrp_next) { ill_t *tmp_ill; /* * If we have an ill_group_t in the list which has * no ill_t assigned then we must be in the process of * removing this group. We skip this as illgrp_delete() * will remove it from the list. */ if ((tmp_ill = illgrp->illgrp_ill) == NULL) { ASSERT(illgrp->illgrp_ill_count == 0); continue; } ASSERT(tmp_ill->ill_phyint != NULL); phyi = tmp_ill->ill_phyint; /* * Look at groups which has names only. */ if (phyi->phyint_groupname_len == 0) continue; /* * Names are stored in the phyint common to both * IPv4 and IPv6. */ if (mi_strcmp(phyi->phyint_groupname, groupname) == 0) { break; } } } else { /* * If the caller passes in a NULL "grp_to_insert", we * allocate one below and insert this singleton. */ illgrp = grp_to_insert; } ill->ill_group_next = NULL; if (illgrp == NULL) { illgrp = (ill_group_t *)mi_zalloc(sizeof (ill_group_t)); if (illgrp == NULL) { return (ENOMEM); } illgrp->illgrp_next = *illgrp_head; *illgrp_head = illgrp; illgrp->illgrp_ill = ill; illgrp->illgrp_ill_count = 1; ill->ill_group = illgrp; /* * Used in illgrp_scheduler to protect multiple threads * from traversing the list. */ mutex_init(&illgrp->illgrp_lock, NULL, MUTEX_DEFAULT, 0); } else { ASSERT(ill->ill_net_type == illgrp->illgrp_ill->ill_net_type); ASSERT(ill->ill_type == illgrp->illgrp_ill->ill_type); /* Insert ill at tail of this group */ prev_ill = illgrp->illgrp_ill; while (prev_ill->ill_group_next != NULL) prev_ill = prev_ill->ill_group_next; prev_ill->ill_group_next = ill; ill->ill_group = illgrp; illgrp->illgrp_ill_count++; /* * Inherit group properties. Currently only forwarding * is the property we try to keep the same with all the * ills. When there are more, we will abstract this into * a function. */ ill->ill_flags &= ~ILLF_ROUTER; ill->ill_flags |= (illgrp->illgrp_ill->ill_flags & ILLF_ROUTER); } mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); /* * 1) When ipif_up_done() calls this function, ipif_up_count * may be zero as it has not yet been bumped. But the ires * have already been added. So, we do the nomination here * itself. But, when ip_sioctl_groupname calls this, it checks * for ill_ipif_up_count != 0. Thus we don't check for * ill_ipif_up_count here while nominating broadcast ires for * receive. * * 2) Similarly, we need to call ill_group_bcast_for_xmit here * to group them properly as ire_add() has already happened * in the ipif_up_done() case. For ip_sioctl_groupname/ifgrp_insert * case, we need to do it here anyway. */ if (!ill->ill_isv6) { ill_group_bcast_for_xmit(ill); ill_nominate_bcast_rcv(illgrp); } if (!ipif_is_coming_up) { /* * When ipif_up_done() calls this function, the multicast * groups have not been joined yet. So, there is no point in * nomination. ip_join_allmulti will handle groups when * ill_recover_multicast is called from ipif_up_done() later. */ (void) ill_nominate_mcast_rcv(illgrp); /* * ipif_up_done calls ill_update_source_selection * anyway. Moreover, we don't want to re-create * interface routes while ipif_up_done() still has reference * to them. Refer to ipif_up_done() for more details. */ ill_update_source_selection(ill); } /* * Send a routing sockets message if we are inserting into * groups with names. */ if (groupname != NULL) ip_rts_ifmsg(ill->ill_ipif); return (0); } /* * Return the first phyint matching the groupname. There could * be more than one when there are ill groups. * * Needs work: called only from ip_sioctl_groupname */ static phyint_t * phyint_lookup_group(char *groupname) { phyint_t *phyi; ASSERT(RW_LOCK_HELD(&ill_g_lock)); /* * Group names are stored in the phyint - a common structure * to both IPv4 and IPv6. */ phyi = avl_first(&phyint_g_list.phyint_list_avl_by_index); for (; phyi != NULL; phyi = avl_walk(&phyint_g_list.phyint_list_avl_by_index, phyi, AVL_AFTER)) { if (phyi->phyint_groupname_len == 0) continue; ASSERT(phyi->phyint_groupname != NULL); if (mi_strcmp(groupname, phyi->phyint_groupname) == 0) return (phyi); } return (NULL); } /* * MT notes on creation and deletion of IPMP groups * * Creation and deletion of IPMP groups introduce the need to merge or * split the associated serialization objects i.e the ipsq's. Normally all * the ills in an IPMP group would map to a single ipsq. If IPMP is not enabled * an ill-pair(v4, v6) i.e. phyint would map to a single ipsq. However during * the execution of the SIOCSLIFGROUPNAME command the picture changes. There * is a need to change the association and we have to operate on both * the source and destination IPMP groups. For eg. attempting to set the * groupname of hme0 to mpk17-85 when it already belongs to mpk17-84 has to * handle 2 IPMP groups and 2 ipsqs. All the ills belonging to either of the * source or destination IPMP group are mapped to a single ipsq for executing * the SIOCSLIFGROUPNAME command. This is termed as a merge of the ipsq's. * The mapping is restored back to normal at a later point. This is * termed as a split of the ipsq. The converse of the merge i.e. a split of the * ipsq happens while unwinding from ipsq_exit. If at least 1 set groupname * occurred on the ipsq, then the ipsq_split flag is set. This indicates the * ipsq has to be examined for redoing the associations. * * In the above example the ioctl handling code locates the current ipsq of hme0 * which is ipsq(mpk17-84). It then enters the above ipsq immediately or * eventually (after queueing the ioctl in ipsq(mpk17-84)). Then it locates * the destination ipsq which is ipsq(mpk17-85) and merges the source ipsq into * the destination ipsq. If the destination ipsq is not busy, it also enters * the destination ipsq exclusively. Now the actual groupname setting operation * can proceed. If the destination ipsq is busy, the operation is enqueued * on the destination (merged) ipsq and will be handled in the unwind from * ipsq_exit. * * To prevent other threads accessing the ill while the group name change is * in progres, we bring down the ipifs which also removes the ill from the * group. The group is changed in phyint and when the first ipif on the ill * is brought up, the ill is inserted into the right IPMP group by * illgrp_insert. */ /* ARGSUSED */ int ip_sioctl_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { int i; char *tmp; int namelen; ill_t *ill = ipif->ipif_ill; ill_t *ill_v4, *ill_v6; int err = 0; phyint_t *phyi; phyint_t *phyi_tmp; struct lifreq *lifr; mblk_t *mp1; char *groupname; ipsq_t *ipsq; ASSERT(IAM_WRITER_IPIF(ipif)); /* Existance verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; lifr = (struct lifreq *)mp1->b_rptr; groupname = lifr->lifr_groupname; if (ipif->ipif_id != 0) return (EINVAL); phyi = ill->ill_phyint; ASSERT(phyi != NULL); if (phyi->phyint_flags & PHYI_VIRTUAL) return (EINVAL); tmp = groupname; for (i = 0; i < LIFNAMSIZ && *tmp != '\0'; tmp++, i++) ; if (i == LIFNAMSIZ) { /* no null termination */ return (EINVAL); } /* * Calculate the namelen exclusive of the null * termination character. */ namelen = tmp - groupname; ill_v4 = phyi->phyint_illv4; ill_v6 = phyi->phyint_illv6; /* * ILL cannot be part of a usesrc group and and IPMP group at the * same time. No need to grab the ill_g_usesrc_lock here, see * synchronization notes in ip.c */ if (ipif->ipif_ill->ill_usesrc_grp_next != NULL) { return (EINVAL); } /* * mark the ill as changing. * this should queue all new requests on the syncq. */ GRAB_ILL_LOCKS(ill_v4, ill_v6); if (ill_v4 != NULL) ill_v4->ill_state_flags |= ILL_CHANGING; if (ill_v6 != NULL) ill_v6->ill_state_flags |= ILL_CHANGING; RELEASE_ILL_LOCKS(ill_v4, ill_v6); if (namelen == 0) { /* * Null string means remove this interface from the * existing group. */ if (phyi->phyint_groupname_len == 0) { /* * Never was in a group. */ err = 0; goto done; } /* * IPv4 or IPv6 may be temporarily out of the group when all * the ipifs are down. Thus, we need to check for ill_group to * be non-NULL. */ if (ill_v4 != NULL && ill_v4->ill_group != NULL) { ill_down_ipifs(ill_v4, mp, 0, B_FALSE); mutex_enter(&ill_v4->ill_lock); if (!ill_is_quiescent(ill_v4)) { /* * ipsq_pending_mp_add will not fail since * connp is NULL */ (void) ipsq_pending_mp_add(NULL, ill_v4->ill_ipif, q, mp, ILL_DOWN); mutex_exit(&ill_v4->ill_lock); err = EINPROGRESS; goto done; } mutex_exit(&ill_v4->ill_lock); } if (ill_v6 != NULL && ill_v6->ill_group != NULL) { ill_down_ipifs(ill_v6, mp, 0, B_FALSE); mutex_enter(&ill_v6->ill_lock); if (!ill_is_quiescent(ill_v6)) { (void) ipsq_pending_mp_add(NULL, ill_v6->ill_ipif, q, mp, ILL_DOWN); mutex_exit(&ill_v6->ill_lock); err = EINPROGRESS; goto done; } mutex_exit(&ill_v6->ill_lock); } rw_enter(&ill_g_lock, RW_WRITER); GRAB_ILL_LOCKS(ill_v4, ill_v6); mutex_enter(&phyi->phyint_lock); ASSERT(phyi->phyint_groupname != NULL); mi_free(phyi->phyint_groupname); phyi->phyint_groupname = NULL; phyi->phyint_groupname_len = 0; mutex_exit(&phyi->phyint_lock); RELEASE_ILL_LOCKS(ill_v4, ill_v6); rw_exit(&ill_g_lock); err = ill_up_ipifs(ill, q, mp); /* * set the split flag so that the ipsq can be split */ mutex_enter(&phyi->phyint_ipsq->ipsq_lock); phyi->phyint_ipsq->ipsq_split = B_TRUE; mutex_exit(&phyi->phyint_ipsq->ipsq_lock); } else { if (phyi->phyint_groupname_len != 0) { ASSERT(phyi->phyint_groupname != NULL); /* Are we inserting in the same group ? */ if (mi_strcmp(groupname, phyi->phyint_groupname) == 0) { err = 0; goto done; } } rw_enter(&ill_g_lock, RW_READER); /* * Merge ipsq for the group's. * This check is here as multiple groups/ills might be * sharing the same ipsq. * If we have to merege than the operation is restarted * on the new ipsq. */ ipsq = ip_ipsq_lookup(groupname, B_FALSE, NULL); if (phyi->phyint_ipsq != ipsq) { rw_exit(&ill_g_lock); err = ill_merge_groups(ill, NULL, groupname, mp, q); goto done; } /* * Running exclusive on new ipsq. */ ASSERT(ipsq != NULL); ASSERT(ipsq->ipsq_writer == curthread); /* * Check whether the ill_type and ill_net_type matches before * we allocate any memory so that the cleanup is easier. * * We can't group dissimilar ones as we can't load spread * packets across the group because of potential link-level * header differences. */ phyi_tmp = phyint_lookup_group(groupname); if (phyi_tmp != NULL) { if ((ill_v4 != NULL && phyi_tmp->phyint_illv4 != NULL) && ((ill_v4->ill_net_type != phyi_tmp->phyint_illv4->ill_net_type) || (ill_v4->ill_type != phyi_tmp->phyint_illv4->ill_type))) { mutex_enter(&phyi->phyint_ipsq->ipsq_lock); phyi->phyint_ipsq->ipsq_split = B_TRUE; mutex_exit(&phyi->phyint_ipsq->ipsq_lock); rw_exit(&ill_g_lock); return (EINVAL); } if ((ill_v6 != NULL && phyi_tmp->phyint_illv6 != NULL) && ((ill_v6->ill_net_type != phyi_tmp->phyint_illv6->ill_net_type) || (ill_v6->ill_type != phyi_tmp->phyint_illv6->ill_type))) { mutex_enter(&phyi->phyint_ipsq->ipsq_lock); phyi->phyint_ipsq->ipsq_split = B_TRUE; mutex_exit(&phyi->phyint_ipsq->ipsq_lock); rw_exit(&ill_g_lock); return (EINVAL); } } rw_exit(&ill_g_lock); /* * bring down all v4 ipifs. */ if (ill_v4 != NULL) { ill_down_ipifs(ill_v4, mp, 0, B_FALSE); } /* * bring down all v6 ipifs. */ if (ill_v6 != NULL) { ill_down_ipifs(ill_v6, mp, 0, B_FALSE); } /* * make sure all ipifs are down and there are no active * references. Call to ipsq_pending_mp_add will not fail * since connp is NULL. */ if (ill_v4 != NULL) { mutex_enter(&ill_v4->ill_lock); if (!ill_is_quiescent(ill_v4)) { (void) ipsq_pending_mp_add(NULL, ill_v4->ill_ipif, q, mp, ILL_DOWN); mutex_exit(&ill_v4->ill_lock); err = EINPROGRESS; goto done; } mutex_exit(&ill_v4->ill_lock); } if (ill_v6 != NULL) { mutex_enter(&ill_v6->ill_lock); if (!ill_is_quiescent(ill_v6)) { (void) ipsq_pending_mp_add(NULL, ill_v6->ill_ipif, q, mp, ILL_DOWN); mutex_exit(&ill_v6->ill_lock); err = EINPROGRESS; goto done; } mutex_exit(&ill_v6->ill_lock); } /* * allocate including space for null terminator * before we insert. */ tmp = (char *)mi_alloc(namelen + 1, BPRI_MED); if (tmp == NULL) return (ENOMEM); rw_enter(&ill_g_lock, RW_WRITER); GRAB_ILL_LOCKS(ill_v4, ill_v6); mutex_enter(&phyi->phyint_lock); if (phyi->phyint_groupname_len != 0) { ASSERT(phyi->phyint_groupname != NULL); mi_free(phyi->phyint_groupname); } /* * setup the new group name. */ phyi->phyint_groupname = tmp; bcopy(groupname, phyi->phyint_groupname, namelen + 1); phyi->phyint_groupname_len = namelen + 1; mutex_exit(&phyi->phyint_lock); RELEASE_ILL_LOCKS(ill_v4, ill_v6); rw_exit(&ill_g_lock); err = ill_up_ipifs(ill, q, mp); } done: /* * normally ILL_CHANGING is cleared in ill_up_ipifs. */ if (err != EINPROGRESS) { GRAB_ILL_LOCKS(ill_v4, ill_v6); if (ill_v4 != NULL) ill_v4->ill_state_flags &= ~ILL_CHANGING; if (ill_v6 != NULL) ill_v6->ill_state_flags &= ~ILL_CHANGING; RELEASE_ILL_LOCKS(ill_v4, ill_v6); } return (err); } /* ARGSUSED */ int ip_sioctl_get_groupname(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { ill_t *ill; phyint_t *phyi; struct lifreq *lifr; mblk_t *mp1; /* Existence verified in ip_wput_nondata */ mp1 = mp->b_cont->b_cont; lifr = (struct lifreq *)mp1->b_rptr; ill = ipif->ipif_ill; phyi = ill->ill_phyint; lifr->lifr_groupname[0] = '\0'; /* * ill_group may be null if all the interfaces * are down. But still, the phyint should always * hold the name. */ if (phyi->phyint_groupname_len != 0) { bcopy(phyi->phyint_groupname, lifr->lifr_groupname, phyi->phyint_groupname_len); } return (0); } typedef struct conn_move_s { ill_t *cm_from_ill; ill_t *cm_to_ill; int cm_ifindex; } conn_move_t; /* * ipcl_walk function for moving conn_multicast_ill for a given ill. */ static void conn_move(conn_t *connp, caddr_t arg) { conn_move_t *connm; int ifindex; int i; ill_t *from_ill; ill_t *to_ill; ilg_t *ilg; ilm_t *ret_ilm; connm = (conn_move_t *)arg; ifindex = connm->cm_ifindex; from_ill = connm->cm_from_ill; to_ill = connm->cm_to_ill; /* Change IP_BOUND_IF/IPV6_BOUND_IF associations. */ /* All multicast fields protected by conn_lock */ mutex_enter(&connp->conn_lock); ASSERT(connp->conn_outgoing_ill == connp->conn_incoming_ill); if ((connp->conn_outgoing_ill == from_ill) && (ifindex == 0 || connp->conn_orig_bound_ifindex == ifindex)) { connp->conn_outgoing_ill = to_ill; connp->conn_incoming_ill = to_ill; } /* Change IP_MULTICAST_IF/IPV6_MULTICAST_IF associations */ if ((connp->conn_multicast_ill == from_ill) && (ifindex == 0 || connp->conn_orig_multicast_ifindex == ifindex)) { connp->conn_multicast_ill = connm->cm_to_ill; } /* Change IP_XMIT_IF associations */ if ((connp->conn_xmit_if_ill == from_ill) && (ifindex == 0 || connp->conn_orig_xmit_ifindex == ifindex)) { connp->conn_xmit_if_ill = to_ill; } /* * Change the ilg_ill to point to the new one. This assumes * ilm_move_v6 has moved the ilms to new_ill and the driver * has been told to receive packets on this interface. * ilm_move_v6 FAILBACKS all the ilms successfully always. * But when doing a FAILOVER, it might fail with ENOMEM and so * some ilms may not have moved. We check to see whether * the ilms have moved to to_ill. We can't check on from_ill * as in the process of moving, we could have split an ilm * in to two - which has the same orig_ifindex and v6group. * * For IPv4, ilg_ipif moves implicitly. The code below really * does not do anything for IPv4 as ilg_ill is NULL for IPv4. */ for (i = connp->conn_ilg_inuse - 1; i >= 0; i--) { ilg = &connp->conn_ilg[i]; if ((ilg->ilg_ill == from_ill) && (ifindex == 0 || ilg->ilg_orig_ifindex == ifindex)) { /* ifindex != 0 indicates failback */ if (ifindex != 0) { connp->conn_ilg[i].ilg_ill = to_ill; continue; } ret_ilm = ilm_lookup_ill_index_v6(to_ill, &ilg->ilg_v6group, ilg->ilg_orig_ifindex, connp->conn_zoneid); if (ret_ilm != NULL) connp->conn_ilg[i].ilg_ill = to_ill; } } mutex_exit(&connp->conn_lock); } static void conn_move_ill(ill_t *from_ill, ill_t *to_ill, int ifindex) { conn_move_t connm; connm.cm_from_ill = from_ill; connm.cm_to_ill = to_ill; connm.cm_ifindex = ifindex; ipcl_walk(conn_move, (caddr_t)&connm); } /* * ilm has been moved from from_ill to to_ill. * Send DL_DISABMULTI_REQ to ill and DL_ENABMULTI_REQ on to_ill. * appropriately. * * NOTE : We can't reuse the code in ip_ll_addmulti/delmulti because * the code there de-references ipif_ill to get the ill to * send multicast requests. It does not work as ipif is on its * move and already moved when this function is called. * Thus, we need to use from_ill and to_ill send down multicast * requests. */ static void ilm_send_multicast_reqs(ill_t *from_ill, ill_t *to_ill) { ipif_t *ipif; ilm_t *ilm; /* * See whether we need to send down DL_ENABMULTI_REQ on * to_ill as ilm has just been added. */ ASSERT(IAM_WRITER_ILL(to_ill)); ASSERT(IAM_WRITER_ILL(from_ill)); ILM_WALKER_HOLD(to_ill); for (ilm = to_ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (!ilm->ilm_is_new || (ilm->ilm_flags & ILM_DELETED)) continue; /* * no locks held, ill/ipif cannot dissappear as long * as we are writer. */ ipif = to_ill->ill_ipif; /* * No need to hold any lock as we are the writer and this * can only be changed by a writer. */ ilm->ilm_is_new = B_FALSE; if (to_ill->ill_net_type != IRE_IF_RESOLVER || ipif->ipif_flags & IPIF_POINTOPOINT) { ip1dbg(("ilm_send_multicast_reqs: to_ill not " "resolver\n")); continue; /* Must be IRE_IF_NORESOLVER */ } if (to_ill->ill_phyint->phyint_flags & PHYI_MULTI_BCAST) { ip1dbg(("ilm_send_multicast_reqs: " "to_ill MULTI_BCAST\n")); goto from; } if (to_ill->ill_isv6) mld_joingroup(ilm); else igmp_joingroup(ilm); if (to_ill->ill_ipif_up_count == 0) { /* * Nobody there. All multicast addresses will be * re-joined when we get the DL_BIND_ACK bringing the * interface up. */ ilm->ilm_notify_driver = B_FALSE; ip1dbg(("ilm_send_multicast_reqs: to_ill nobody up\n")); goto from; } /* * For allmulti address, we want to join on only one interface. * Checking for ilm_numentries_v6 is not correct as you may * find an ilm with zero address on to_ill, but we may not * have nominated to_ill for receiving. Thus, if we have * nominated from_ill (ill_join_allmulti is set), nominate * only if to_ill is not already nominated (to_ill normally * should not have been nominated if "from_ill" has already * been nominated. As we don't prevent failovers from happening * across groups, we don't assert). */ if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { /* * There is no need to hold ill locks as we are * writer on both ills and when ill_join_allmulti * is changed the thread is always a writer. */ if (from_ill->ill_join_allmulti && !to_ill->ill_join_allmulti) { (void) ip_join_allmulti(to_ill->ill_ipif); } } else if (ilm->ilm_notify_driver) { /* * This is a newly moved ilm so we need to tell the * driver about the new group. There can be more than * one ilm's for the same group in the list each with a * different orig_ifindex. We have to inform the driver * once. In ilm_move_v[4,6] we only set the flag * ilm_notify_driver for the first ilm. */ (void) ip_ll_send_enabmulti_req(to_ill, &ilm->ilm_v6addr); } ilm->ilm_notify_driver = B_FALSE; /* * See whether we need to send down DL_DISABMULTI_REQ on * from_ill as ilm has just been removed. */ from: ipif = from_ill->ill_ipif; if (from_ill->ill_net_type != IRE_IF_RESOLVER || ipif->ipif_flags & IPIF_POINTOPOINT) { ip1dbg(("ilm_send_multicast_reqs: " "from_ill not resolver\n")); continue; /* Must be IRE_IF_NORESOLVER */ } if (from_ill->ill_phyint->phyint_flags & PHYI_MULTI_BCAST) { ip1dbg(("ilm_send_multicast_reqs: " "from_ill MULTI_BCAST\n")); continue; } if (IN6_IS_ADDR_UNSPECIFIED(&ilm->ilm_v6addr)) { if (from_ill->ill_join_allmulti) (void) ip_leave_allmulti(from_ill->ill_ipif); } else if (ilm_numentries_v6(from_ill, &ilm->ilm_v6addr) == 0) { (void) ip_ll_send_disabmulti_req(from_ill, &ilm->ilm_v6addr); } } ILM_WALKER_RELE(to_ill); } /* * This function is called when all multicast memberships needs * to be moved from "from_ill" to "to_ill" for IPv6. This function is * called only once unlike the IPv4 counterpart where it is called after * every logical interface is moved. The reason is due to multicast * memberships are joined using an interface address in IPv4 while in * IPv6, interface index is used. */ static void ilm_move_v6(ill_t *from_ill, ill_t *to_ill, int ifindex) { ilm_t *ilm; ilm_t *ilm_next; ilm_t *new_ilm; ilm_t **ilmp; int count; char buf[INET6_ADDRSTRLEN]; in6_addr_t ipv6_snm = ipv6_solicited_node_mcast; ASSERT(MUTEX_HELD(&to_ill->ill_lock)); ASSERT(MUTEX_HELD(&from_ill->ill_lock)); ASSERT(RW_WRITE_HELD(&ill_g_lock)); if (ifindex == 0) { /* * Form the solicited node mcast address which is used later. */ ipif_t *ipif; ipif = from_ill->ill_ipif; ASSERT(ipif->ipif_id == 0); ipv6_snm.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3]; } ilmp = &from_ill->ill_ilm; for (ilm = from_ill->ill_ilm; ilm != NULL; ilm = ilm_next) { ilm_next = ilm->ilm_next; if (ilm->ilm_flags & ILM_DELETED) { ilmp = &ilm->ilm_next; continue; } new_ilm = ilm_lookup_ill_index_v6(to_ill, &ilm->ilm_v6addr, ilm->ilm_orig_ifindex, ilm->ilm_zoneid); ASSERT(ilm->ilm_orig_ifindex != 0); if (ilm->ilm_orig_ifindex == ifindex) { /* * We are failing back multicast memberships. * If the same ilm exists in to_ill, it means somebody * has joined the same group there e.g. ff02::1 * is joined within the kernel when the interfaces * came UP. */ ASSERT(ilm->ilm_ipif == NULL); if (new_ilm != NULL) { new_ilm->ilm_refcnt += ilm->ilm_refcnt; if (new_ilm->ilm_fmode != MODE_IS_EXCLUDE || !SLIST_IS_EMPTY(new_ilm->ilm_filter)) { new_ilm->ilm_is_new = B_TRUE; } } else { /* * check if we can just move the ilm */ if (from_ill->ill_ilm_walker_cnt != 0) { /* * We have walkers we cannot move * the ilm, so allocate a new ilm, * this (old) ilm will be marked * ILM_DELETED at the end of the loop * and will be freed when the * last walker exits. */ new_ilm = (ilm_t *)mi_zalloc (sizeof (ilm_t)); if (new_ilm == NULL) { ip0dbg(("ilm_move_v6: " "FAILBACK of IPv6" " multicast address %s : " "from %s to" " %s failed : ENOMEM \n", inet_ntop(AF_INET6, &ilm->ilm_v6addr, buf, sizeof (buf)), from_ill->ill_name, to_ill->ill_name)); ilmp = &ilm->ilm_next; continue; } *new_ilm = *ilm; /* * we don't want new_ilm linked to * ilm's filter list. */ new_ilm->ilm_filter = NULL; } else { /* * No walkers we can move the ilm. * lets take it out of the list. */ *ilmp = ilm->ilm_next; ilm->ilm_next = NULL; new_ilm = ilm; } /* * if this is the first ilm for the group * set ilm_notify_driver so that we notify the * driver in ilm_send_multicast_reqs. */ if (ilm_lookup_ill_v6(to_ill, &new_ilm->ilm_v6addr, ALL_ZONES) == NULL) new_ilm->ilm_notify_driver = B_TRUE; new_ilm->ilm_ill = to_ill; /* Add to the to_ill's list */ new_ilm->ilm_next = to_ill->ill_ilm; to_ill->ill_ilm = new_ilm; /* * set the flag so that mld_joingroup is * called in ilm_send_multicast_reqs(). */ new_ilm->ilm_is_new = B_TRUE; } goto bottom; } else if (ifindex != 0) { /* * If this is FAILBACK (ifindex != 0) and the ifindex * has not matched above, look at the next ilm. */ ilmp = &ilm->ilm_next; continue; } /* * If we are here, it means ifindex is 0. Failover * everything. * * We need to handle solicited node mcast address * and all_nodes mcast address differently as they * are joined witin the kenrel (ipif_multicast_up) * and potentially from the userland. We are called * after the ipifs of from_ill has been moved. * If we still find ilms on ill with solicited node * mcast address or all_nodes mcast address, it must * belong to the UP interface that has not moved e.g. * ipif_id 0 with the link local prefix does not move. * We join this on the new ill accounting for all the * userland memberships so that applications don't * see any failure. * * We need to make sure that we account only for the * solicited node and all node multicast addresses * that was brought UP on these. In the case of * a failover from A to B, we might have ilms belonging * to A (ilm_orig_ifindex pointing at A) on B accounting * for the membership from the userland. If we are failing * over from B to C now, we will find the ones belonging * to A on B. These don't account for the ill_ipif_up_count. * They just move from B to C. The check below on * ilm_orig_ifindex ensures that. */ if ((ilm->ilm_orig_ifindex == from_ill->ill_phyint->phyint_ifindex) && (IN6_ARE_ADDR_EQUAL(&ipv6_snm, &ilm->ilm_v6addr) || IN6_ARE_ADDR_EQUAL(&ipv6_all_hosts_mcast, &ilm->ilm_v6addr))) { ASSERT(ilm->ilm_refcnt > 0); count = ilm->ilm_refcnt - from_ill->ill_ipif_up_count; /* * For indentation reasons, we are not using a * "else" here. */ if (count == 0) { ilmp = &ilm->ilm_next; continue; } ilm->ilm_refcnt -= count; if (new_ilm != NULL) { /* * Can find one with the same * ilm_orig_ifindex, if we are failing * over to a STANDBY. This happens * when somebody wants to join a group * on a STANDBY interface and we * internally join on a different one. * If we had joined on from_ill then, a * failover now will find a new ilm * with this index. */ ip1dbg(("ilm_move_v6: FAILOVER, found" " new ilm on %s, group address %s\n", to_ill->ill_name, inet_ntop(AF_INET6, &ilm->ilm_v6addr, buf, sizeof (buf)))); new_ilm->ilm_refcnt += count; if (new_ilm->ilm_fmode != MODE_IS_EXCLUDE || !SLIST_IS_EMPTY(new_ilm->ilm_filter)) { new_ilm->ilm_is_new = B_TRUE; } } else { new_ilm = (ilm_t *)mi_zalloc(sizeof (ilm_t)); if (new_ilm == NULL) { ip0dbg(("ilm_move_v6: FAILOVER of IPv6" " multicast address %s : from %s to" " %s failed : ENOMEM \n", inet_ntop(AF_INET6, &ilm->ilm_v6addr, buf, sizeof (buf)), from_ill->ill_name, to_ill->ill_name)); ilmp = &ilm->ilm_next; continue; } *new_ilm = *ilm; new_ilm->ilm_filter = NULL; new_ilm->ilm_refcnt = count; new_ilm->ilm_timer = INFINITY; new_ilm->ilm_rtx.rtx_timer = INFINITY; new_ilm->ilm_is_new = B_TRUE; /* * If the to_ill has not joined this * group we need to tell the driver in * ill_send_multicast_reqs. */ if (ilm_lookup_ill_v6(to_ill, &new_ilm->ilm_v6addr, ALL_ZONES) == NULL) new_ilm->ilm_notify_driver = B_TRUE; new_ilm->ilm_ill = to_ill; /* Add to the to_ill's list */ new_ilm->ilm_next = to_ill->ill_ilm; to_ill->ill_ilm = new_ilm; ASSERT(new_ilm->ilm_ipif == NULL); } if (ilm->ilm_refcnt == 0) { goto bottom; } else { new_ilm->ilm_fmode = MODE_IS_EXCLUDE; CLEAR_SLIST(new_ilm->ilm_filter); ilmp = &ilm->ilm_next; } continue; } else { /* * ifindex = 0 means, move everything pointing at * from_ill. We are doing this becuase ill has * either FAILED or became INACTIVE. * * As we would like to move things later back to * from_ill, we want to retain the identity of this * ilm. Thus, we don't blindly increment the reference * count on the ilms matching the address alone. We * need to match on the ilm_orig_index also. new_ilm * was obtained by matching ilm_orig_index also. */ if (new_ilm != NULL) { /* * This is possible only if a previous restore * was incomplete i.e restore to * ilm_orig_ifindex left some ilms because * of some failures. Thus when we are failing * again, we might find our old friends there. */ ip1dbg(("ilm_move_v6: FAILOVER, found new ilm" " on %s, group address %s\n", to_ill->ill_name, inet_ntop(AF_INET6, &ilm->ilm_v6addr, buf, sizeof (buf)))); new_ilm->ilm_refcnt += ilm->ilm_refcnt; if (new_ilm->ilm_fmode != MODE_IS_EXCLUDE || !SLIST_IS_EMPTY(new_ilm->ilm_filter)) { new_ilm->ilm_is_new = B_TRUE; } } else { if (from_ill->ill_ilm_walker_cnt != 0) { new_ilm = (ilm_t *) mi_zalloc(sizeof (ilm_t)); if (new_ilm == NULL) { ip0dbg(("ilm_move_v6: " "FAILOVER of IPv6" " multicast address %s : " "from %s to" " %s failed : ENOMEM \n", inet_ntop(AF_INET6, &ilm->ilm_v6addr, buf, sizeof (buf)), from_ill->ill_name, to_ill->ill_name)); ilmp = &ilm->ilm_next; continue; } *new_ilm = *ilm; new_ilm->ilm_filter = NULL; } else { *ilmp = ilm->ilm_next; new_ilm = ilm; } /* * If the to_ill has not joined this * group we need to tell the driver in * ill_send_multicast_reqs. */ if (ilm_lookup_ill_v6(to_ill, &new_ilm->ilm_v6addr, ALL_ZONES) == NULL) new_ilm->ilm_notify_driver = B_TRUE; /* Add to the to_ill's list */ new_ilm->ilm_next = to_ill->ill_ilm; to_ill->ill_ilm = new_ilm; ASSERT(ilm->ilm_ipif == NULL); new_ilm->ilm_ill = to_ill; new_ilm->ilm_is_new = B_TRUE; } } bottom: /* * Revert multicast filter state to (EXCLUDE, NULL). * new_ilm->ilm_is_new should already be set if needed. */ new_ilm->ilm_fmode = MODE_IS_EXCLUDE; CLEAR_SLIST(new_ilm->ilm_filter); /* * We allocated/got a new ilm, free the old one. */ if (new_ilm != ilm) { if (from_ill->ill_ilm_walker_cnt == 0) { *ilmp = ilm->ilm_next; ilm->ilm_next = NULL; FREE_SLIST(ilm->ilm_filter); FREE_SLIST(ilm->ilm_pendsrcs); FREE_SLIST(ilm->ilm_rtx.rtx_allow); FREE_SLIST(ilm->ilm_rtx.rtx_block); mi_free((char *)ilm); } else { ilm->ilm_flags |= ILM_DELETED; from_ill->ill_ilm_cleanup_reqd = 1; ilmp = &ilm->ilm_next; } } } } /* * Move all the multicast memberships to to_ill. Called when * an ipif moves from "from_ill" to "to_ill". This function is slightly * different from IPv6 counterpart as multicast memberships are associated * with ills in IPv6. This function is called after every ipif is moved * unlike IPv6, where it is moved only once. */ static void ilm_move_v4(ill_t *from_ill, ill_t *to_ill, ipif_t *ipif) { ilm_t *ilm; ilm_t *ilm_next; ilm_t *new_ilm; ilm_t **ilmp; ASSERT(MUTEX_HELD(&to_ill->ill_lock)); ASSERT(MUTEX_HELD(&from_ill->ill_lock)); ASSERT(RW_WRITE_HELD(&ill_g_lock)); ilmp = &from_ill->ill_ilm; for (ilm = from_ill->ill_ilm; ilm != NULL; ilm = ilm_next) { ilm_next = ilm->ilm_next; if (ilm->ilm_flags & ILM_DELETED) { ilmp = &ilm->ilm_next; continue; } ASSERT(ilm->ilm_ipif != NULL); if (ilm->ilm_ipif != ipif) { ilmp = &ilm->ilm_next; continue; } if (V4_PART_OF_V6(ilm->ilm_v6addr) == htonl(INADDR_ALLHOSTS_GROUP)) { /* * We joined this in ipif_multicast_up * and we never did an ipif_multicast_down * for IPv4. If nobody else from the userland * has reference, we free the ilm, and later * when this ipif comes up on the new ill, * we will join this again. */ if (--ilm->ilm_refcnt == 0) goto delete_ilm; new_ilm = ilm_lookup_ipif(ipif, V4_PART_OF_V6(ilm->ilm_v6addr)); if (new_ilm != NULL) { new_ilm->ilm_refcnt += ilm->ilm_refcnt; /* * We still need to deal with the from_ill. */ new_ilm->ilm_is_new = B_TRUE; new_ilm->ilm_fmode = MODE_IS_EXCLUDE; CLEAR_SLIST(new_ilm->ilm_filter); goto delete_ilm; } /* * If we could not find one e.g. ipif is * still down on to_ill, we add this ilm * on ill_new to preserve the reference * count. */ } /* * When ipifs move, ilms always move with it * to the NEW ill. Thus we should never be * able to find ilm till we really move it here. */ ASSERT(ilm_lookup_ipif(ipif, V4_PART_OF_V6(ilm->ilm_v6addr)) == NULL); if (from_ill->ill_ilm_walker_cnt != 0) { new_ilm = (ilm_t *)mi_zalloc(sizeof (ilm_t)); if (new_ilm == NULL) { char buf[INET6_ADDRSTRLEN]; ip0dbg(("ilm_move_v4: FAILBACK of IPv4" " multicast address %s : " "from %s to" " %s failed : ENOMEM \n", inet_ntop(AF_INET, &ilm->ilm_v6addr, buf, sizeof (buf)), from_ill->ill_name, to_ill->ill_name)); ilmp = &ilm->ilm_next; continue; } *new_ilm = *ilm; /* We don't want new_ilm linked to ilm's filter list */ new_ilm->ilm_filter = NULL; } else { /* Remove from the list */ *ilmp = ilm->ilm_next; new_ilm = ilm; } /* * If we have never joined this group on the to_ill * make sure we tell the driver. */ if (ilm_lookup_ill_v6(to_ill, &new_ilm->ilm_v6addr, ALL_ZONES) == NULL) new_ilm->ilm_notify_driver = B_TRUE; /* Add to the to_ill's list */ new_ilm->ilm_next = to_ill->ill_ilm; to_ill->ill_ilm = new_ilm; new_ilm->ilm_is_new = B_TRUE; /* * Revert multicast filter state to (EXCLUDE, NULL) */ new_ilm->ilm_fmode = MODE_IS_EXCLUDE; CLEAR_SLIST(new_ilm->ilm_filter); /* * Delete only if we have allocated a new ilm. */ if (new_ilm != ilm) { delete_ilm: if (from_ill->ill_ilm_walker_cnt == 0) { /* Remove from the list */ *ilmp = ilm->ilm_next; ilm->ilm_next = NULL; FREE_SLIST(ilm->ilm_filter); FREE_SLIST(ilm->ilm_pendsrcs); FREE_SLIST(ilm->ilm_rtx.rtx_allow); FREE_SLIST(ilm->ilm_rtx.rtx_block); mi_free((char *)ilm); } else { ilm->ilm_flags |= ILM_DELETED; from_ill->ill_ilm_cleanup_reqd = 1; ilmp = &ilm->ilm_next; } } } } static uint_t ipif_get_id(ill_t *ill, uint_t id) { uint_t unit; ipif_t *tipif; boolean_t found = B_FALSE; /* * During failback, we want to go back to the same id * instead of the smallest id so that the original * configuration is maintained. id is non-zero in that * case. */ if (id != 0) { /* * While failing back, if we still have an ipif with * MAX_ADDRS_PER_IF, it means this will be replaced * as soon as we return from this function. It was * to set to MAX_ADDRS_PER_IF by the caller so that * we can choose the smallest id. Thus we return zero * in that case ignoring the hint. */ if (ill->ill_ipif->ipif_id == MAX_ADDRS_PER_IF) return (0); for (tipif = ill->ill_ipif; tipif != NULL; tipif = tipif->ipif_next) { if (tipif->ipif_id == id) { found = B_TRUE; break; } } /* * If somebody already plumbed another logical * with the same id, we won't be able to find it. */ if (!found) return (id); } for (unit = 0; unit <= ip_addrs_per_if; unit++) { found = B_FALSE; for (tipif = ill->ill_ipif; tipif != NULL; tipif = tipif->ipif_next) { if (tipif->ipif_id == unit) { found = B_TRUE; break; } } if (!found) break; } return (unit); } /* ARGSUSED */ static int ipif_move(ipif_t *ipif, ill_t *to_ill, queue_t *q, mblk_t *mp, ipif_t **rep_ipif_ptr) { ill_t *from_ill; ipif_t *rep_ipif; ipif_t **ipifp; uint_t unit; int err = 0; ipif_t *to_ipif; struct iocblk *iocp; boolean_t failback_cmd; boolean_t remove_ipif; int rc; ASSERT(IAM_WRITER_ILL(to_ill)); ASSERT(IAM_WRITER_IPIF(ipif)); iocp = (struct iocblk *)mp->b_rptr; failback_cmd = (iocp->ioc_cmd == SIOCLIFFAILBACK); remove_ipif = B_FALSE; from_ill = ipif->ipif_ill; ASSERT(MUTEX_HELD(&to_ill->ill_lock)); ASSERT(MUTEX_HELD(&from_ill->ill_lock)); ASSERT(RW_WRITE_HELD(&ill_g_lock)); /* * Don't move LINK LOCAL addresses as they are tied to * physical interface. */ if (from_ill->ill_isv6 && IN6_IS_ADDR_LINKLOCAL(&ipif->ipif_v6lcl_addr)) { ipif->ipif_was_up = B_FALSE; IPIF_UNMARK_MOVING(ipif); return (0); } /* * We set the ipif_id to maximum so that the search for * ipif_id will pick the lowest number i.e 0 in the * following 2 cases : * * 1) We have a replacement ipif at the head of to_ill. * We can't remove it yet as we can exceed ip_addrs_per_if * on to_ill and hence the MOVE might fail. We want to * remove it only if we could move the ipif. Thus, by * setting it to the MAX value, we make the search in * ipif_get_id return the zeroth id. * * 2) When DR pulls out the NIC and re-plumbs the interface, * we might just have a zero address plumbed on the ipif * with zero id in the case of IPv4. We remove that while * doing the failback. We want to remove it only if we * could move the ipif. Thus, by setting it to the MAX * value, we make the search in ipif_get_id return the * zeroth id. * * Both (1) and (2) are done only when when we are moving * an ipif (either due to failover/failback) which originally * belonged to this interface i.e the ipif_orig_ifindex is * the same as to_ill's ifindex. This is needed so that * FAILOVER from A -> B ( A failed) followed by FAILOVER * from B -> A (B is being removed from the group) and * FAILBACK from A -> B restores the original configuration. * Without the check for orig_ifindex, the second FAILOVER * could make the ipif belonging to B replace the A's zeroth * ipif and the subsequent failback re-creating the replacement * ipif again. * * NOTE : We created the replacement ipif when we did a * FAILOVER (See below). We could check for FAILBACK and * then look for replacement ipif to be removed. But we don't * want to do that because we wan't to allow the possibility * of a FAILOVER from A -> B (which creates the replacement ipif), * followed by a *FAILOVER* from B -> A instead of a FAILBACK * from B -> A. */ to_ipif = to_ill->ill_ipif; if ((to_ill->ill_phyint->phyint_ifindex == ipif->ipif_orig_ifindex) && IPIF_REPL_CHECK(to_ipif, failback_cmd)) { ASSERT(to_ipif->ipif_id == 0); remove_ipif = B_TRUE; to_ipif->ipif_id = MAX_ADDRS_PER_IF; } /* * Find the lowest logical unit number on the to_ill. * If we are failing back, try to get the original id * rather than the lowest one so that the original * configuration is maintained. * * XXX need a better scheme for this. */ if (failback_cmd) { unit = ipif_get_id(to_ill, ipif->ipif_orig_ipifid); } else { unit = ipif_get_id(to_ill, 0); } /* Reset back to zero in case we fail below */ if (to_ipif->ipif_id == MAX_ADDRS_PER_IF) to_ipif->ipif_id = 0; if (unit == ip_addrs_per_if) { ipif->ipif_was_up = B_FALSE; IPIF_UNMARK_MOVING(ipif); return (EINVAL); } /* * ipif is ready to move from "from_ill" to "to_ill". * * 1) If we are moving ipif with id zero, create a * replacement ipif for this ipif on from_ill. If this fails * fail the MOVE operation. * * 2) Remove the replacement ipif on to_ill if any. * We could remove the replacement ipif when we are moving * the ipif with id zero. But what if somebody already * unplumbed it ? Thus we always remove it if it is present. * We want to do it only if we are sure we are going to * move the ipif to to_ill which is why there are no * returns due to error till ipif is linked to to_ill. * Note that the first ipif that we failback will always * be zero if it is present. */ if (ipif->ipif_id == 0) { ipaddr_t inaddr_any = INADDR_ANY; rep_ipif = (ipif_t *)mi_alloc(sizeof (ipif_t), BPRI_MED); if (rep_ipif == NULL) { ipif->ipif_was_up = B_FALSE; IPIF_UNMARK_MOVING(ipif); return (ENOMEM); } *rep_ipif = ipif_zero; /* * Before we put the ipif on the list, store the addresses * as mapped addresses as some of the ioctls e.g SIOCGIFADDR * assumes so. This logic is not any different from what * ipif_allocate does. */ IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6lcl_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6src_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6subnet); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6net_mask); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6brd_addr); IN6_IPADDR_TO_V4MAPPED(inaddr_any, &rep_ipif->ipif_v6pp_dst_addr); /* * We mark IPIF_NOFAILOVER so that this can never * move. */ rep_ipif->ipif_flags = ipif->ipif_flags | IPIF_NOFAILOVER; rep_ipif->ipif_flags &= ~IPIF_UP; rep_ipif->ipif_replace_zero = B_TRUE; mutex_init(&rep_ipif->ipif_saved_ire_lock, NULL, MUTEX_DEFAULT, NULL); rep_ipif->ipif_id = 0; rep_ipif->ipif_ire_type = ipif->ipif_ire_type; rep_ipif->ipif_ill = from_ill; rep_ipif->ipif_orig_ifindex = from_ill->ill_phyint->phyint_ifindex; /* Insert at head */ rep_ipif->ipif_next = from_ill->ill_ipif; from_ill->ill_ipif = rep_ipif; /* * We don't really care to let apps know about * this interface. */ } if (remove_ipif) { /* * We set to a max value above for this case to get * id zero. ASSERT that we did get one. */ ASSERT((to_ipif->ipif_id == 0) && (unit == 0)); rep_ipif = to_ipif; to_ill->ill_ipif = rep_ipif->ipif_next; rep_ipif->ipif_next = NULL; /* * If some apps scanned and find this interface, * it is time to let them know, so that they can * delete it. */ *rep_ipif_ptr = rep_ipif; } /* Get it out of the ILL interface list. */ ipifp = &ipif->ipif_ill->ill_ipif; for (; *ipifp != NULL; ipifp = &ipifp[0]->ipif_next) { if (*ipifp == ipif) { *ipifp = ipif->ipif_next; break; } } /* Assign the new ill */ ipif->ipif_ill = to_ill; ipif->ipif_id = unit; /* id has already been checked */ rc = ipif_insert(ipif, B_FALSE, B_FALSE); ASSERT(rc == 0); /* Let SCTP update its list */ sctp_move_ipif(ipif, from_ill, to_ill); /* * Handle the failover and failback of ipif_t between * ill_t that have differing maximum mtu values. */ if (ipif->ipif_mtu > to_ill->ill_max_mtu) { if (ipif->ipif_saved_mtu == 0) { /* * As this ipif_t is moving to an ill_t * that has a lower ill_max_mtu, its * ipif_mtu needs to be saved so it can * be restored during failback or during * failover to an ill_t which has a * higher ill_max_mtu. */ ipif->ipif_saved_mtu = ipif->ipif_mtu; ipif->ipif_mtu = to_ill->ill_max_mtu; } else { /* * The ipif_t is, once again, moving to * an ill_t that has a lower maximum mtu * value. */ ipif->ipif_mtu = to_ill->ill_max_mtu; } } else if (ipif->ipif_mtu < to_ill->ill_max_mtu && ipif->ipif_saved_mtu != 0) { /* * The mtu of this ipif_t had to be reduced * during an earlier failover; this is an * opportunity for it to be increased (either as * part of another failover or a failback). */ if (ipif->ipif_saved_mtu <= to_ill->ill_max_mtu) { ipif->ipif_mtu = ipif->ipif_saved_mtu; ipif->ipif_saved_mtu = 0; } else { ipif->ipif_mtu = to_ill->ill_max_mtu; } } /* * We preserve all the other fields of the ipif including * ipif_saved_ire_mp. The routes that are saved here will * be recreated on the new interface and back on the old * interface when we move back. */ ASSERT(ipif->ipif_arp_del_mp == NULL); return (err); } static int ipif_move_all(ill_t *from_ill, ill_t *to_ill, queue_t *q, mblk_t *mp, int ifindex, ipif_t **rep_ipif_ptr) { ipif_t *mipif; ipif_t *ipif_next; int err; /* * We don't really try to MOVE back things if some of the * operations fail. The daemon will take care of moving again * later on. */ for (mipif = from_ill->ill_ipif; mipif != NULL; mipif = ipif_next) { ipif_next = mipif->ipif_next; if (!(mipif->ipif_flags & IPIF_NOFAILOVER) && (ifindex == 0 || ifindex == mipif->ipif_orig_ifindex)) { err = ipif_move(mipif, to_ill, q, mp, rep_ipif_ptr); /* * When the MOVE fails, it is the job of the * application to take care of this properly * i.e try again if it is ENOMEM. */ if (mipif->ipif_ill != from_ill) { /* * ipif has moved. * * Move the multicast memberships associated * with this ipif to the new ill. For IPv6, we * do it once after all the ipifs are moved * (in ill_move) as they are not associated * with ipifs. * * We need to move the ilms as the ipif has * already been moved to a new ill even * in the case of errors. Neither * ilm_free(ipif) will find the ilm * when somebody unplumbs this ipif nor * ilm_delete(ilm) will be able to find the * ilm, if we don't move now. */ if (!from_ill->ill_isv6) ilm_move_v4(from_ill, to_ill, mipif); } if (err != 0) return (err); } } return (0); } static int ill_move(ill_t *from_ill, ill_t *to_ill, queue_t *q, mblk_t *mp) { int ifindex; int err; struct iocblk *iocp; ipif_t *ipif; ipif_t *rep_ipif_ptr = NULL; ipif_t *from_ipif = NULL; boolean_t check_rep_if = B_FALSE; iocp = (struct iocblk *)mp->b_rptr; if (iocp->ioc_cmd == SIOCLIFFAILOVER) { /* * Move everything pointing at from_ill to to_ill. * We acheive this by passing in 0 as ifindex. */ ifindex = 0; } else { /* * Move everything pointing at from_ill whose original * ifindex of connp, ipif, ilm points at to_ill->ill_index. * We acheive this by passing in ifindex rather than 0. * Multicast vifs, ilgs move implicitly because ipifs move. */ ASSERT(iocp->ioc_cmd == SIOCLIFFAILBACK); ifindex = to_ill->ill_phyint->phyint_ifindex; } /* * Determine if there is at least one ipif that would move from * 'from_ill' to 'to_ill'. If so, it is possible that the replacement * ipif (if it exists) on the to_ill would be consumed as a result of * the move, in which case we need to quiesce the replacement ipif also. */ for (from_ipif = from_ill->ill_ipif; from_ipif != NULL; from_ipif = from_ipif->ipif_next) { if (((ifindex == 0) || (ifindex == from_ipif->ipif_orig_ifindex)) && !(from_ipif->ipif_flags & IPIF_NOFAILOVER)) { check_rep_if = B_TRUE; break; } } ill_down_ipifs(from_ill, mp, ifindex, B_TRUE); GRAB_ILL_LOCKS(from_ill, to_ill); if ((ipif = ill_quiescent_to_move(from_ill)) != NULL) { (void) ipsq_pending_mp_add(NULL, ipif, q, mp, ILL_MOVE_OK); RELEASE_ILL_LOCKS(from_ill, to_ill); return (EINPROGRESS); } /* Check if the replacement ipif is quiescent to delete */ if (check_rep_if && IPIF_REPL_CHECK(to_ill->ill_ipif, (iocp->ioc_cmd == SIOCLIFFAILBACK))) { to_ill->ill_ipif->ipif_state_flags |= IPIF_MOVING | IPIF_CHANGING; if ((ipif = ill_quiescent_to_move(to_ill)) != NULL) { (void) ipsq_pending_mp_add(NULL, ipif, q, mp, ILL_MOVE_OK); RELEASE_ILL_LOCKS(from_ill, to_ill); return (EINPROGRESS); } } RELEASE_ILL_LOCKS(from_ill, to_ill); ASSERT(!MUTEX_HELD(&to_ill->ill_lock)); rw_enter(&ill_g_lock, RW_WRITER); GRAB_ILL_LOCKS(from_ill, to_ill); err = ipif_move_all(from_ill, to_ill, q, mp, ifindex, &rep_ipif_ptr); /* ilm_move is done inside ipif_move for IPv4 */ if (err == 0 && from_ill->ill_isv6) ilm_move_v6(from_ill, to_ill, ifindex); RELEASE_ILL_LOCKS(from_ill, to_ill); rw_exit(&ill_g_lock); /* * send rts messages and multicast messages. */ if (rep_ipif_ptr != NULL) { ip_rts_ifmsg(rep_ipif_ptr); ip_rts_newaddrmsg(RTM_DELETE, 0, rep_ipif_ptr); IPIF_TRACE_CLEANUP(rep_ipif_ptr); mi_free(rep_ipif_ptr); } ilm_send_multicast_reqs(from_ill, to_ill); conn_move_ill(from_ill, to_ill, ifindex); return (err); } /* * Used to extract arguments for FAILOVER/FAILBACK ioctls. * Also checks for the validity of the arguments. * Note: We are already exclusive inside the from group. * It is upto the caller to release refcnt on the to_ill's. */ static int ip_extract_move_args(queue_t *q, mblk_t *mp, ill_t **ill_from_v4, ill_t **ill_from_v6, ill_t **ill_to_v4, ill_t **ill_to_v6) { int dst_index; ipif_t *ipif_v4, *ipif_v6; struct lifreq *lifr; mblk_t *mp1; boolean_t exists; sin_t *sin; int err = 0; if ((mp1 = mp->b_cont) == NULL) return (EPROTO); if ((mp1 = mp1->b_cont) == NULL) return (EPROTO); lifr = (struct lifreq *)mp1->b_rptr; sin = (sin_t *)&lifr->lifr_addr; /* * We operate on both IPv4 and IPv6. Thus, we don't allow IPv4/IPv6 * specific operations. */ if (sin->sin_family != AF_UNSPEC) return (EINVAL); /* * Get ipif with id 0. We are writer on the from ill. So we can pass * NULLs for the last 4 args and we know the lookup won't fail * with EINPROGRESS. */ ipif_v4 = ipif_lookup_on_name(lifr->lifr_name, mi_strlen(lifr->lifr_name), B_FALSE, &exists, B_FALSE, ALL_ZONES, NULL, NULL, NULL, NULL); ipif_v6 = ipif_lookup_on_name(lifr->lifr_name, mi_strlen(lifr->lifr_name), B_FALSE, &exists, B_TRUE, ALL_ZONES, NULL, NULL, NULL, NULL); if (ipif_v4 == NULL && ipif_v6 == NULL) return (ENXIO); if (ipif_v4 != NULL) { ASSERT(ipif_v4->ipif_refcnt != 0); if (ipif_v4->ipif_id != 0) { err = EINVAL; goto done; } ASSERT(IAM_WRITER_IPIF(ipif_v4)); *ill_from_v4 = ipif_v4->ipif_ill; } if (ipif_v6 != NULL) { ASSERT(ipif_v6->ipif_refcnt != 0); if (ipif_v6->ipif_id != 0) { err = EINVAL; goto done; } ASSERT(IAM_WRITER_IPIF(ipif_v6)); *ill_from_v6 = ipif_v6->ipif_ill; } err = 0; dst_index = lifr->lifr_movetoindex; *ill_to_v4 = ill_lookup_on_ifindex(dst_index, B_FALSE, q, mp, ip_process_ioctl, &err); if (err != 0) { /* * There could be only v6. */ if (err != ENXIO) goto done; err = 0; } *ill_to_v6 = ill_lookup_on_ifindex(dst_index, B_TRUE, q, mp, ip_process_ioctl, &err); if (err != 0) { if (err != ENXIO) goto done; if (*ill_to_v4 == NULL) { err = ENXIO; goto done; } err = 0; } /* * If we have something to MOVE i.e "from" not NULL, * "to" should be non-NULL. */ if ((*ill_from_v4 != NULL && *ill_to_v4 == NULL) || (*ill_from_v6 != NULL && *ill_to_v6 == NULL)) { err = EINVAL; } done: if (ipif_v4 != NULL) ipif_refrele(ipif_v4); if (ipif_v6 != NULL) ipif_refrele(ipif_v6); return (err); } /* * FAILOVER and FAILBACK are modelled as MOVE operations. * * We don't check whether the MOVE is within the same group or * not, because this ioctl can be used as a generic mechanism * to failover from interface A to B, though things will function * only if they are really part of the same group. Moreover, * all ipifs may be down and hence temporarily out of the group. * * ipif's that need to be moved are first brought down; V4 ipifs are brought * down first and then V6. For each we wait for the ipif's to become quiescent. * Bringing down the ipifs ensures that all ires pointing to these ipifs's * have been deleted and there are no active references. Once quiescent the * ipif's are moved and brought up on the new ill. * * Normally the source ill and destination ill belong to the same IPMP group * and hence the same ipsq_t. In the event they don't belong to the same * same group the two ipsq's are first merged into one ipsq - that of the * to_ill. The multicast memberships on the source and destination ill cannot * change during the move operation since multicast joins/leaves also have to * execute on the same ipsq and are hence serialized. */ /* ARGSUSED */ int ip_sioctl_move(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { ill_t *ill_to_v4 = NULL; ill_t *ill_to_v6 = NULL; ill_t *ill_from_v4 = NULL; ill_t *ill_from_v6 = NULL; int err = 0; /* * setup from and to ill's, we can get EINPROGRESS only for * to_ill's. */ err = ip_extract_move_args(q, mp, &ill_from_v4, &ill_from_v6, &ill_to_v4, &ill_to_v6); if (err != 0) { ip0dbg(("ip_sioctl_move: extract args failed\n")); goto done; } /* * nothing to do. */ if ((ill_from_v4 != NULL) && (ill_from_v4 == ill_to_v4)) { goto done; } /* * nothing to do. */ if ((ill_from_v6 != NULL) && (ill_from_v6 == ill_to_v6)) { goto done; } /* * Mark the ill as changing. * ILL_CHANGING flag is cleared when the ipif's are brought up * in ill_up_ipifs in case of error they are cleared below. */ GRAB_ILL_LOCKS(ill_from_v4, ill_from_v6); if (ill_from_v4 != NULL) ill_from_v4->ill_state_flags |= ILL_CHANGING; if (ill_from_v6 != NULL) ill_from_v6->ill_state_flags |= ILL_CHANGING; RELEASE_ILL_LOCKS(ill_from_v4, ill_from_v6); /* * Make sure that both src and dst are * in the same syncq group. If not make it happen. * We are not holding any locks because we are the writer * on the from_ipsq and we will hold locks in ill_merge_groups * to protect to_ipsq against changing. */ if (ill_from_v4 != NULL) { if (ill_from_v4->ill_phyint->phyint_ipsq != ill_to_v4->ill_phyint->phyint_ipsq) { err = ill_merge_groups(ill_from_v4, ill_to_v4, NULL, mp, q); goto err_ret; } ASSERT(!MUTEX_HELD(&ill_to_v4->ill_lock)); } else { if (ill_from_v6->ill_phyint->phyint_ipsq != ill_to_v6->ill_phyint->phyint_ipsq) { err = ill_merge_groups(ill_from_v6, ill_to_v6, NULL, mp, q); goto err_ret; } ASSERT(!MUTEX_HELD(&ill_to_v6->ill_lock)); } /* * Now that the ipsq's have been merged and we are the writer * lets mark to_ill as changing as well. */ GRAB_ILL_LOCKS(ill_to_v4, ill_to_v6); if (ill_to_v4 != NULL) ill_to_v4->ill_state_flags |= ILL_CHANGING; if (ill_to_v6 != NULL) ill_to_v6->ill_state_flags |= ILL_CHANGING; RELEASE_ILL_LOCKS(ill_to_v4, ill_to_v6); /* * Its ok for us to proceed with the move even if * ill_pending_mp is non null on one of the from ill's as the reply * should not be looking at the ipif, it should only care about the * ill itself. */ /* * lets move ipv4 first. */ if (ill_from_v4 != NULL) { ASSERT(IAM_WRITER_ILL(ill_to_v4)); ill_from_v4->ill_move_in_progress = B_TRUE; ill_to_v4->ill_move_in_progress = B_TRUE; ill_to_v4->ill_move_peer = ill_from_v4; ill_from_v4->ill_move_peer = ill_to_v4; err = ill_move(ill_from_v4, ill_to_v4, q, mp); } /* * Now lets move ipv6. */ if (err == 0 && ill_from_v6 != NULL) { ASSERT(IAM_WRITER_ILL(ill_to_v6)); ill_from_v6->ill_move_in_progress = B_TRUE; ill_to_v6->ill_move_in_progress = B_TRUE; ill_to_v6->ill_move_peer = ill_from_v6; ill_from_v6->ill_move_peer = ill_to_v6; err = ill_move(ill_from_v6, ill_to_v6, q, mp); } err_ret: /* * EINPROGRESS means we are waiting for the ipif's that need to be * moved to become quiescent. */ if (err == EINPROGRESS) { goto done; } /* * if err is set ill_up_ipifs will not be called * lets clear the flags. */ GRAB_ILL_LOCKS(ill_to_v4, ill_to_v6); GRAB_ILL_LOCKS(ill_from_v4, ill_from_v6); /* * Some of the clearing may be redundant. But it is simple * not making any extra checks. */ if (ill_from_v6 != NULL) { ill_from_v6->ill_move_in_progress = B_FALSE; ill_from_v6->ill_move_peer = NULL; ill_from_v6->ill_state_flags &= ~ILL_CHANGING; } if (ill_from_v4 != NULL) { ill_from_v4->ill_move_in_progress = B_FALSE; ill_from_v4->ill_move_peer = NULL; ill_from_v4->ill_state_flags &= ~ILL_CHANGING; } if (ill_to_v6 != NULL) { ill_to_v6->ill_move_in_progress = B_FALSE; ill_to_v6->ill_move_peer = NULL; ill_to_v6->ill_state_flags &= ~ILL_CHANGING; } if (ill_to_v4 != NULL) { ill_to_v4->ill_move_in_progress = B_FALSE; ill_to_v4->ill_move_peer = NULL; ill_to_v4->ill_state_flags &= ~ILL_CHANGING; } /* * Check for setting INACTIVE, if STANDBY is set and FAILED is not set. * Do this always to maintain proper state i.e even in case of errors. * As phyint_inactive looks at both v4 and v6 interfaces, * we need not call on both v4 and v6 interfaces. */ if (ill_from_v4 != NULL) { if ((ill_from_v4->ill_phyint->phyint_flags & (PHYI_STANDBY | PHYI_FAILED)) == PHYI_STANDBY) { phyint_inactive(ill_from_v4->ill_phyint); } } else if (ill_from_v6 != NULL) { if ((ill_from_v6->ill_phyint->phyint_flags & (PHYI_STANDBY | PHYI_FAILED)) == PHYI_STANDBY) { phyint_inactive(ill_from_v6->ill_phyint); } } if (ill_to_v4 != NULL) { if (ill_to_v4->ill_phyint->phyint_flags & PHYI_INACTIVE) { ill_to_v4->ill_phyint->phyint_flags &= ~PHYI_INACTIVE; } } else if (ill_to_v6 != NULL) { if (ill_to_v6->ill_phyint->phyint_flags & PHYI_INACTIVE) { ill_to_v6->ill_phyint->phyint_flags &= ~PHYI_INACTIVE; } } RELEASE_ILL_LOCKS(ill_to_v4, ill_to_v6); RELEASE_ILL_LOCKS(ill_from_v4, ill_from_v6); no_err: /* * lets bring the interfaces up on the to_ill. */ if (err == 0) { err = ill_up_ipifs(ill_to_v4 == NULL ? ill_to_v6:ill_to_v4, q, mp); } done: if (ill_to_v4 != NULL) { ill_refrele(ill_to_v4); } if (ill_to_v6 != NULL) { ill_refrele(ill_to_v6); } return (err); } static void ill_dl_down(ill_t *ill) { /* * The ill is down; unbind but stay attached since we're still * associated with a PPA. */ mblk_t *mp = ill->ill_unbind_mp; ill->ill_unbind_mp = NULL; ip1dbg(("ill_dl_down(%s)\n", ill->ill_name)); if (mp != NULL) { ip1dbg(("ill_dl_down: %s (%u) for %s\n", dlpi_prim_str(*(int *)mp->b_rptr), *(int *)mp->b_rptr, ill->ill_name)); mutex_enter(&ill->ill_lock); ill->ill_state_flags |= ILL_DL_UNBIND_IN_PROGRESS; mutex_exit(&ill->ill_lock); ill_dlpi_send(ill, mp); } /* * Toss all of our multicast memberships. We could keep them, but * then we'd have to do bookkeeping of any joins and leaves performed * by the application while the the interface is down (we can't just * issue them because arp cannot currently process AR_ENTRY_SQUERY's * on a downed interface). */ ill_leave_multicast(ill); mutex_enter(&ill->ill_lock); ill->ill_dl_up = 0; mutex_exit(&ill->ill_lock); } void ill_dlpi_dispatch(ill_t *ill, mblk_t *mp) { union DL_primitives *dlp; t_uscalar_t prim; ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO); dlp = (union DL_primitives *)mp->b_rptr; prim = dlp->dl_primitive; ip1dbg(("ill_dlpi_dispatch: sending %s (%u) to %s\n", dlpi_prim_str(prim), prim, ill->ill_name)); switch (prim) { case DL_PHYS_ADDR_REQ: { dl_phys_addr_req_t *dlpap = (dl_phys_addr_req_t *)mp->b_rptr; ill->ill_phys_addr_pend = dlpap->dl_addr_type; break; } case DL_BIND_REQ: mutex_enter(&ill->ill_lock); ill->ill_state_flags &= ~ILL_DL_UNBIND_IN_PROGRESS; mutex_exit(&ill->ill_lock); break; } ill->ill_dlpi_pending = prim; /* * Some drivers send M_FLUSH up to IP as part of unbind * request. When this M_FLUSH is sent back to the driver, * this can go after we send the detach request if the * M_FLUSH ends up in IP's syncq. To avoid that, we reply * to the M_FLUSH in ip_rput and locally generate another * M_FLUSH for the correctness. This will get freed in * ip_wput_nondata. */ if (prim == DL_UNBIND_REQ) (void) putnextctl1(ill->ill_rq, M_FLUSH, FLUSHRW); putnext(ill->ill_wq, mp); } /* * Send a DLPI control message to the driver but make sure there * is only one outstanding message. Uses ill_dlpi_pending to tell * when it must queue. ip_rput_dlpi_writer calls ill_dlpi_done() * when an ACK or a NAK is received to process the next queued message. * * We don't protect ill_dlpi_pending with any lock. This is okay as * every place where its accessed, ip is exclusive while accessing * ill_dlpi_pending except when this function is called from ill_init() */ void ill_dlpi_send(ill_t *ill, mblk_t *mp) { mblk_t **mpp; ASSERT(IAM_WRITER_ILL(ill)); ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO); if (ill->ill_dlpi_pending != DL_PRIM_INVAL) { /* Must queue message. Tail insertion */ mpp = &ill->ill_dlpi_deferred; while (*mpp != NULL) mpp = &((*mpp)->b_next); ip1dbg(("ill_dlpi_send: deferring request for %s\n", ill->ill_name)); *mpp = mp; return; } ill_dlpi_dispatch(ill, mp); } /* * Called when an DLPI control message has been acked or nacked to * send down the next queued message (if any). */ void ill_dlpi_done(ill_t *ill, t_uscalar_t prim) { mblk_t *mp; ASSERT(IAM_WRITER_ILL(ill)); ASSERT(prim != DL_PRIM_INVAL); if (ill->ill_dlpi_pending != prim) { if (ill->ill_dlpi_pending == DL_PRIM_INVAL) { (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE, "ill_dlpi_done: unsolicited ack for %s from %s\n", dlpi_prim_str(prim), ill->ill_name); } else { (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE, "ill_dlpi_done: unexpected ack for %s from %s " "(expecting ack for %s)\n", dlpi_prim_str(prim), ill->ill_name, dlpi_prim_str(ill->ill_dlpi_pending)); } return; } ip1dbg(("ill_dlpi_done: %s has completed %s (%u)\n", ill->ill_name, dlpi_prim_str(ill->ill_dlpi_pending), ill->ill_dlpi_pending)); if ((mp = ill->ill_dlpi_deferred) == NULL) { ill->ill_dlpi_pending = DL_PRIM_INVAL; return; } ill->ill_dlpi_deferred = mp->b_next; mp->b_next = NULL; ill_dlpi_dispatch(ill, mp); } void conn_delete_ire(conn_t *connp, caddr_t arg) { ipif_t *ipif = (ipif_t *)arg; ire_t *ire; /* * Look at the cached ires on conns which has pointers to ipifs. * We just call ire_refrele which clears up the reference * to ire. Called when a conn closes. Also called from ipif_free * to cleanup indirect references to the stale ipif via the cached ire. */ mutex_enter(&connp->conn_lock); ire = connp->conn_ire_cache; if (ire != NULL && (ipif == NULL || ire->ire_ipif == ipif)) { connp->conn_ire_cache = NULL; mutex_exit(&connp->conn_lock); IRE_REFRELE_NOTR(ire); return; } mutex_exit(&connp->conn_lock); } /* * Some operations (illgrp_delete(), ipif_down()) conditionally delete a number * of IREs. Those IREs may have been previously cached in the conn structure. * This ipcl_walk() walker function releases all references to such IREs based * on the condemned flag. */ /* ARGSUSED */ void conn_cleanup_stale_ire(conn_t *connp, caddr_t arg) { ire_t *ire; mutex_enter(&connp->conn_lock); ire = connp->conn_ire_cache; if (ire != NULL && (ire->ire_marks & IRE_MARK_CONDEMNED)) { connp->conn_ire_cache = NULL; mutex_exit(&connp->conn_lock); IRE_REFRELE_NOTR(ire); return; } mutex_exit(&connp->conn_lock); } /* * Take down a specific interface, but don't lose any information about it. * Also delete interface from its interface group (ifgrp). * (Always called as writer.) * This function goes through the down sequence even if the interface is * already down. There are 2 reasons. * a. Currently we permit interface routes that depend on down interfaces * to be added. This behaviour itself is questionable. However it appears * that both Solaris and 4.3 BSD have exhibited this behaviour for a long * time. We go thru the cleanup in order to remove these routes. * b. The bringup of the interface could fail in ill_dl_up i.e. we get * DL_ERROR_ACK in response to the the DL_BIND request. The interface is * down, but we need to cleanup i.e. do ill_dl_down and * ip_rput_dlpi_writer (DL_ERROR_ACK) -> ipif_down. * * IP-MT notes: * * Model of reference to interfaces. * * The following members in ipif_t track references to the ipif. * int ipif_refcnt; Active reference count * uint_t ipif_ire_cnt; Number of ire's referencing this ipif * The following members in ill_t track references to the ill. * int ill_refcnt; active refcnt * uint_t ill_ire_cnt; Number of ires referencing ill * uint_t ill_nce_cnt; Number of nces referencing ill * * Reference to an ipif or ill can be obtained in any of the following ways. * * Through the lookup functions ipif_lookup_* / ill_lookup_* functions * Pointers to ipif / ill from other data structures viz ire and conn. * Implicit reference to the ipif / ill by holding a reference to the ire. * * The ipif/ill lookup functions return a reference held ipif / ill. * ipif_refcnt and ill_refcnt track the reference counts respectively. * This is a purely dynamic reference count associated with threads holding * references to the ipif / ill. Pointers from other structures do not * count towards this reference count. * * ipif_ire_cnt/ill_ire_cnt is the number of ire's associated with the * ipif/ill. This is incremented whenever a new ire is created referencing the * ipif/ill. This is done atomically inside ire_add_v[46] where the ire is * actually added to the ire hash table. The count is decremented in * ire_inactive where the ire is destroyed. * * nce's reference ill's thru nce_ill and the count of nce's associated with * an ill is recorded in ill_nce_cnt. This is incremented atomically in * ndp_add() where the nce is actually added to the table. Similarly it is * decremented in ndp_inactive where the nce is destroyed. * * Flow of ioctls involving interface down/up * * The following is the sequence of an attempt to set some critical flags on an * up interface. * ip_sioctl_flags * ipif_down * wait for ipif to be quiescent * ipif_down_tail * ip_sioctl_flags_tail * * All set ioctls that involve down/up sequence would have a skeleton similar * to the above. All the *tail functions are called after the refcounts have * dropped to the appropriate values. * * The mechanism to quiesce an ipif is as follows. * * Mark the ipif as IPIF_CHANGING. No more lookups will be allowed * on the ipif. Callers either pass a flag requesting wait or the lookup * functions will return NULL. * * Delete all ires referencing this ipif * * Any thread attempting to do an ipif_refhold on an ipif that has been * obtained thru a cached pointer will first make sure that * the ipif can be refheld using the macro IPIF_CAN_LOOKUP and only then * increment the refcount. * * The above guarantees that the ipif refcount will eventually come down to * zero and the ipif will quiesce, once all threads that currently hold a * reference to the ipif refrelease the ipif. The ipif is quiescent after the * ipif_refcount has dropped to zero and all ire's associated with this ipif * have also been ire_inactive'd. i.e. when ipif_ire_cnt and ipif_refcnt both * drop to zero. * * Lookups during the IPIF_CHANGING/ILL_CHANGING interval. * * Threads trying to lookup an ipif or ill can pass a flag requesting * wait and restart if the ipif / ill cannot be looked up currently. * For eg. bind, and route operations (Eg. route add / delete) cannot return * failure if the ipif is currently undergoing an exclusive operation, and * hence pass the flag. The mblk is then enqueued in the ipsq and the operation * is restarted by ipsq_exit() when the currently exclusive ioctl completes. * The lookup and enqueue is atomic using the ill_lock and ipsq_lock. The * lookup is done holding the ill_lock. Hence the ill/ipif state flags can't * change while the ill_lock is held. Before dropping the ill_lock we acquire * the ipsq_lock and call ipsq_enq. This ensures that ipsq_exit can't finish * until we release the ipsq_lock, even though the the ill/ipif state flags * can change after we drop the ill_lock. * * An attempt to send out a packet using an ipif that is currently * IPIF_CHANGING will fail. No attempt is made in this case to enqueue this * operation and restart it later when the exclusive condition on the ipif ends. * This is an example of not passing the wait flag to the lookup functions. For * example an attempt to refhold and use conn->conn_multicast_ipif and send * out a multicast packet on that ipif will fail while the ipif is * IPIF_CHANGING. An attempt to create an IRE_CACHE using an ipif that is * currently IPIF_CHANGING will also fail. */ int ipif_down(ipif_t *ipif, queue_t *q, mblk_t *mp) { ill_t *ill = ipif->ipif_ill; phyint_t *phyi; conn_t *connp; boolean_t success; boolean_t ipif_was_up = B_FALSE; ASSERT(IAM_WRITER_IPIF(ipif)); ip1dbg(("ipif_down(%s:%u)\n", ill->ill_name, ipif->ipif_id)); if (ipif->ipif_flags & IPIF_UP) { mutex_enter(&ill->ill_lock); ipif->ipif_flags &= ~IPIF_UP; ASSERT(ill->ill_ipif_up_count > 0); --ill->ill_ipif_up_count; mutex_exit(&ill->ill_lock); ipif_was_up = B_TRUE; /* Update status in SCTP's list */ sctp_update_ipif(ipif, SCTP_IPIF_DOWN); } /* * Blow away v6 memberships we established in ipif_multicast_up(); the * v4 ones are left alone (as is the ipif_multicast_up flag, so we * know not to rejoin when the interface is brought back up). */ if (ipif->ipif_isv6) ipif_multicast_down(ipif); /* * Remove from the mapping for __sin6_src_id. We insert only * when the address is not INADDR_ANY. As IPv4 addresses are * stored as mapped addresses, we need to check for mapped * INADDR_ANY also. */ if (ipif_was_up && !IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) && !IN6_IS_ADDR_V4MAPPED_ANY(&ipif->ipif_v6lcl_addr) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { int err; err = ip_srcid_remove(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid); if (err != 0) { ip0dbg(("ipif_down: srcid_remove %d\n", err)); } } /* * Before we delete the ill from the group (if any), we need * to make sure that we delete all the routes dependent on * this and also any ipifs dependent on this ipif for * source address. We need to do before we delete from * the group because * * 1) ipif_down_delete_ire de-references ill->ill_group. * * 2) ipif_update_other_ipifs needs to walk the whole group * for re-doing source address selection. Note that * ipif_select_source[_v6] called from * ipif_update_other_ipifs[_v6] will not pick this ipif * because we have already marked down here i.e cleared * IPIF_UP. */ if (ipif->ipif_isv6) ire_walk_v6(ipif_down_delete_ire, (char *)ipif, ALL_ZONES); else ire_walk_v4(ipif_down_delete_ire, (char *)ipif, ALL_ZONES); /* * Need to add these also to be saved and restored when the * ipif is brought down and up */ mutex_enter(&ire_mrtun_lock); if (ire_mrtun_count != 0) { mutex_exit(&ire_mrtun_lock); ire_walk_ill_mrtun(0, 0, ipif_down_delete_ire, (char *)ipif, NULL); } else { mutex_exit(&ire_mrtun_lock); } mutex_enter(&ire_srcif_table_lock); if (ire_srcif_table_count > 0) { mutex_exit(&ire_srcif_table_lock); ire_walk_srcif_table_v4(ipif_down_delete_ire, (char *)ipif); } else { mutex_exit(&ire_srcif_table_lock); } /* * Cleaning up the conn_ire_cache or conns must be done only after the * ires have been deleted above. Otherwise a thread could end up * caching an ire in a conn after we have finished the cleanup of the * conn. The caching is done after making sure that the ire is not yet * condemned. Also documented in the block comment above ip_output */ ipcl_walk(conn_cleanup_stale_ire, NULL); /* Also, delete the ires cached in SCTP */ sctp_ire_cache_flush(ipif); /* Resolve any IPsec/IKE NAT-T instances that depend on this ipif. */ nattymod_clean_ipif(ipif); /* * Update any other ipifs which have used "our" local address as * a source address. This entails removing and recreating IRE_INTERFACE * entries for such ipifs. */ if (ipif->ipif_isv6) ipif_update_other_ipifs_v6(ipif, ill->ill_group); else ipif_update_other_ipifs(ipif, ill->ill_group); if (ipif_was_up) { /* * Check whether it is last ipif to leave this group. * If this is the last ipif to leave, we should remove * this ill from the group as ipif_select_source will not * be able to find any useful ipifs if this ill is selected * for load balancing. * * For nameless groups, we should call ifgrp_delete if this * belongs to some group. As this ipif is going down, we may * need to reconstruct groups. */ phyi = ill->ill_phyint; /* * If the phyint_groupname_len is 0, it may or may not * be in the nameless group. If the phyint_groupname_len is * not 0, then this ill should be part of some group. * As we always insert this ill in the group if * phyint_groupname_len is not zero when the first ipif * comes up (in ipif_up_done), it should be in a group * when the namelen is not 0. * * NOTE : When we delete the ill from the group,it will * blow away all the IRE_CACHES pointing either at this ipif or * ill_wq (illgrp_cache_delete does this). Thus, no IRES * should be pointing at this ill. */ ASSERT(phyi->phyint_groupname_len == 0 || (phyi->phyint_groupname != NULL && ill->ill_group != NULL)); if (phyi->phyint_groupname_len != 0) { if (ill->ill_ipif_up_count == 0) illgrp_delete(ill); } /* * If we have deleted some of the broadcast ires associated * with this ipif, we need to re-nominate somebody else if * the ires that we deleted were the nominated ones. */ if (ill->ill_group != NULL && !ill->ill_isv6) ipif_renominate_bcast(ipif); } if (ipif->ipif_isv6) ipif_ndp_down(ipif); /* * If mp is NULL the caller will wait for the appropriate refcnt. * Eg. ip_sioctl_removeif -> ipif_free -> ipif_down * and ill_delete -> ipif_free -> ipif_down */ if (mp == NULL) { ASSERT(q == NULL); return (0); } if (CONN_Q(q)) { connp = Q_TO_CONN(q); mutex_enter(&connp->conn_lock); } else { connp = NULL; } mutex_enter(&ill->ill_lock); /* * Are there any ire's pointing to this ipif that are still active ? * If this is the last ipif going down, are there any ire's pointing * to this ill that are still active ? */ if (ipif_is_quiescent(ipif)) { mutex_exit(&ill->ill_lock); if (connp != NULL) mutex_exit(&connp->conn_lock); return (0); } ip1dbg(("ipif_down: need to wait, adding pending mp %s ill %p", ill->ill_name, (void *)ill)); /* * Enqueue the mp atomically in ipsq_pending_mp. When the refcount * drops down, the operation will be restarted by ipif_ill_refrele_tail * which in turn is called by the last refrele on the ipif/ill/ire. */ success = ipsq_pending_mp_add(connp, ipif, q, mp, IPIF_DOWN); if (!success) { /* The conn is closing. So just return */ ASSERT(connp != NULL); mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); return (EINTR); } mutex_exit(&ill->ill_lock); if (connp != NULL) mutex_exit(&connp->conn_lock); return (EINPROGRESS); } static void ipif_down_tail(ipif_t *ipif) { ill_t *ill = ipif->ipif_ill; /* * Skip any loopback interface (null wq). * If this is the last logical interface on the ill * have ill_dl_down tell the driver we are gone (unbind) * Note that lun 0 can ipif_down even though * there are other logical units that are up. * This occurs e.g. when we change a "significant" IFF_ flag. */ if (ipif->ipif_ill->ill_wq != NULL) { if (!ill->ill_logical_down && (ill->ill_ipif_up_count == 0) && ill->ill_dl_up) { ill_dl_down(ill); } } ill->ill_logical_down = 0; /* * Have to be after removing the routes in ipif_down_delete_ire. */ if (ipif->ipif_isv6) { if (ipif->ipif_ill->ill_flags & ILLF_XRESOLV) ipif_arp_down(ipif); } else { ipif_arp_down(ipif); } ip_rts_ifmsg(ipif); ip_rts_newaddrmsg(RTM_DELETE, 0, ipif); } /* * Bring interface logically down without bringing the physical interface * down e.g. when the netmask is changed. This avoids long lasting link * negotiations between an ethernet interface and a certain switches. */ static int ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp) { /* * The ill_logical_down flag is a transient flag. It is set here * and is cleared once the down has completed in ipif_down_tail. * This flag does not indicate whether the ill stream is in the * DL_BOUND state with the driver. Instead this flag is used by * ipif_down_tail to determine whether to DL_UNBIND the stream with * the driver. The state of the ill stream i.e. whether it is * DL_BOUND with the driver or not is indicated by the ill_dl_up flag. */ ipif->ipif_ill->ill_logical_down = 1; return (ipif_down(ipif, q, mp)); } /* * This is called when the SIOCSLIFUSESRC ioctl is processed in IP. * If the usesrc client ILL is already part of a usesrc group or not, * in either case a ire_stq with the matching usesrc client ILL will * locate the IRE's that need to be deleted. We want IREs to be created * with the new source address. */ static void ipif_delete_cache_ire(ire_t *ire, char *ill_arg) { ill_t *ucill = (ill_t *)ill_arg; ASSERT(IAM_WRITER_ILL(ucill)); if (ire->ire_stq == NULL) return; if ((ire->ire_type == IRE_CACHE) && ((ill_t *)ire->ire_stq->q_ptr == ucill)) ire_delete(ire); } /* * ire_walk routine to delete every IRE dependent on the interface * address that is going down. (Always called as writer.) * Works for both v4 and v6. * In addition for checking for ire_ipif matches it also checks for * IRE_CACHE entries which have the same source address as the * disappearing ipif since ipif_select_source might have picked * that source. Note that ipif_down/ipif_update_other_ipifs takes * care of any IRE_INTERFACE with the disappearing source address. */ static void ipif_down_delete_ire(ire_t *ire, char *ipif_arg) { ipif_t *ipif = (ipif_t *)ipif_arg; ill_t *ire_ill; ill_t *ipif_ill; ASSERT(IAM_WRITER_IPIF(ipif)); if (ire->ire_ipif == NULL) return; /* * For IPv4, we derive source addresses for an IRE from ipif's * belonging to the same IPMP group as the IRE's outgoing * interface. If an IRE's outgoing interface isn't in the * same IPMP group as a particular ipif, then that ipif * couldn't have been used as a source address for this IRE. * * For IPv6, source addresses are only restricted to the IPMP group * if the IRE is for a link-local address or a multicast address. * Otherwise, source addresses for an IRE can be chosen from * interfaces other than the the outgoing interface for that IRE. * * For source address selection details, see ipif_select_source() * and ipif_select_source_v6(). */ if (ire->ire_ipversion == IPV4_VERSION || IN6_IS_ADDR_LINKLOCAL(&ire->ire_addr_v6) || IN6_IS_ADDR_MULTICAST(&ire->ire_addr_v6)) { ire_ill = ire->ire_ipif->ipif_ill; ipif_ill = ipif->ipif_ill; if (ire_ill->ill_group != ipif_ill->ill_group) { return; } } if (ire->ire_ipif != ipif) { /* * Look for a matching source address. */ if (ire->ire_type != IRE_CACHE) return; if (ipif->ipif_flags & IPIF_NOLOCAL) return; if (ire->ire_ipversion == IPV4_VERSION) { if (ire->ire_src_addr != ipif->ipif_src_addr) return; } else { if (!IN6_ARE_ADDR_EQUAL(&ire->ire_src_addr_v6, &ipif->ipif_v6lcl_addr)) return; } ire_delete(ire); return; } /* * ire_delete() will do an ire_flush_cache which will delete * all ire_ipif matches */ ire_delete(ire); } /* * ire_walk_ill function for deleting all IRE_CACHE entries for an ill when * 1) an ipif (on that ill) changes the IPIF_DEPRECATED flags, or * 2) when an interface is brought up or down (on that ill). * This ensures that the IRE_CACHE entries don't retain stale source * address selection results. */ void ill_ipif_cache_delete(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; ill_t *ipif_ill; ASSERT(IAM_WRITER_ILL(ill)); /* * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4. * Hence this should be IRE_CACHE. */ ASSERT(ire->ire_type == IRE_CACHE); /* * We are called for IRE_CACHES whose ire_ipif matches ill. * We are only interested in IRE_CACHES that has borrowed * the source address from ill_arg e.g. ipif_up_done[_v6] * for which we need to look at ire_ipif->ipif_ill match * with ill. */ ASSERT(ire->ire_ipif != NULL); ipif_ill = ire->ire_ipif->ipif_ill; if (ipif_ill == ill || (ill->ill_group != NULL && ipif_ill->ill_group == ill->ill_group)) { ire_delete(ire); } } /* * Delete all the ire whose stq references ill_arg. */ static void ill_stq_cache_delete(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; ill_t *ire_ill; ASSERT(IAM_WRITER_ILL(ill)); /* * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4. * Hence this should be IRE_CACHE. */ ASSERT(ire->ire_type == IRE_CACHE); /* * We are called for IRE_CACHES whose ire_stq and ire_ipif * matches ill. We are only interested in IRE_CACHES that * has ire_stq->q_ptr pointing at ill_arg. Thus we do the * filtering here. */ ire_ill = (ill_t *)ire->ire_stq->q_ptr; if (ire_ill == ill) ire_delete(ire); } /* * This is called when an ill leaves the group. We want to delete * all IRE_CACHES whose stq is pointing at ill_wq or ire_ipif is * pointing at ill. */ static void illgrp_cache_delete(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; ASSERT(IAM_WRITER_ILL(ill)); ASSERT(ill->ill_group == NULL); /* * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4. * Hence this should be IRE_CACHE. */ ASSERT(ire->ire_type == IRE_CACHE); /* * We are called for IRE_CACHES whose ire_stq and ire_ipif * matches ill. We are interested in both. */ ASSERT((ill == (ill_t *)ire->ire_stq->q_ptr) || (ire->ire_ipif->ipif_ill == ill)); ire_delete(ire); } /* * Initiate deallocate of an IPIF. Always called as writer. Called by * ill_delete or ip_sioctl_removeif. */ static void ipif_free(ipif_t *ipif) { ASSERT(IAM_WRITER_IPIF(ipif)); /* Remove conn references */ reset_conn_ipif(ipif); /* * Make sure we have valid net and subnet broadcast ire's for the * other ipif's which share them with this ipif. */ if (!ipif->ipif_isv6) ipif_check_bcast_ires(ipif); /* * Take down the interface. We can be called either from ill_delete * or from ip_sioctl_removeif. */ (void) ipif_down(ipif, NULL, NULL); rw_enter(&ill_g_lock, RW_WRITER); /* Remove pointers to this ill in the multicast routing tables */ reset_mrt_vif_ipif(ipif); rw_exit(&ill_g_lock); } static void ipif_free_tail(ipif_t *ipif) { mblk_t *mp; ipif_t **ipifp; /* * Free state for addition IRE_IF_[NO]RESOLVER ire's. */ mutex_enter(&ipif->ipif_saved_ire_lock); mp = ipif->ipif_saved_ire_mp; ipif->ipif_saved_ire_mp = NULL; mutex_exit(&ipif->ipif_saved_ire_lock); freemsg(mp); /* * Need to hold both ill_g_lock and ill_lock while * inserting or removing an ipif from the linked list * of ipifs hanging off the ill. */ rw_enter(&ill_g_lock, RW_WRITER); /* * Remove all multicast memberships on the interface now. * This removes IPv4 multicast memberships joined within * the kernel as ipif_down does not do ipif_multicast_down * for IPv4. IPv6 is not handled here as the multicast memberships * are based on ill and not on ipif. */ ilm_free(ipif); /* * Since we held the ill_g_lock while doing the ilm_free above, * we can assert the ilms were really deleted and not just marked * ILM_DELETED. */ ASSERT(ilm_walk_ipif(ipif) == 0); IPIF_TRACE_CLEANUP(ipif); /* Ask SCTP to take it out of it list */ sctp_update_ipif(ipif, SCTP_IPIF_REMOVE); mutex_enter(&ipif->ipif_ill->ill_lock); /* Get it out of the ILL interface list. */ ipifp = &ipif->ipif_ill->ill_ipif; for (; *ipifp != NULL; ipifp = &ipifp[0]->ipif_next) { if (*ipifp == ipif) { *ipifp = ipif->ipif_next; break; } } mutex_exit(&ipif->ipif_ill->ill_lock); rw_exit(&ill_g_lock); mutex_destroy(&ipif->ipif_saved_ire_lock); /* Free the memory. */ mi_free((char *)ipif); } /* * Returns an ipif name in the form "ill_name/unit" if ipif_id is not zero, * "ill_name" otherwise. */ char * ipif_get_name(ipif_t *ipif, char *buf, int len) { char lbuf[32]; char *name; size_t name_len; buf[0] = '\0'; if (!ipif) return (buf); name = ipif->ipif_ill->ill_name; name_len = ipif->ipif_ill->ill_name_length; if (ipif->ipif_id != 0) { (void) sprintf(lbuf, "%s%c%d", name, IPIF_SEPARATOR_CHAR, ipif->ipif_id); name = lbuf; name_len = mi_strlen(name) + 1; } len -= 1; buf[len] = '\0'; len = MIN(len, name_len); bcopy(name, buf, len); return (buf); } /* * Find an IPIF based on the name passed in. Names can be of the * form (e.g., le0), :<#> (e.g., le0:1), * The string can have forms like <#> (e.g., le0), * <#>. (e.g. le0.foo), or .<#> (e.g. ip.tun3). * When there is no colon, the implied unit id is zero. must * correspond to the name of an ILL. (May be called as writer.) */ static ipif_t * ipif_lookup_on_name(char *name, size_t namelen, boolean_t do_alloc, boolean_t *exists, boolean_t isv6, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error) { char *cp; char *endp; long id; ill_t *ill; ipif_t *ipif; uint_t ire_type; boolean_t did_alloc = B_FALSE; ipsq_t *ipsq; if (error != NULL) *error = 0; /* * If the caller wants to us to create the ipif, make sure we have a * valid zoneid */ ASSERT(!do_alloc || zoneid != ALL_ZONES); if (namelen == 0) { if (error != NULL) *error = ENXIO; return (NULL); } *exists = B_FALSE; /* Look for a colon in the name. */ endp = &name[namelen]; for (cp = endp; --cp > name; ) { if (*cp == IPIF_SEPARATOR_CHAR) break; } if (*cp == IPIF_SEPARATOR_CHAR) { /* * Reject any non-decimal aliases for logical * interfaces. Aliases with leading zeroes * are also rejected as they introduce ambiguity * in the naming of the interfaces. * In order to confirm with existing semantics, * and to not break any programs/script relying * on that behaviour, if<0>:0 is considered to be * a valid interface. * * If alias has two or more digits and the first * is zero, fail. */ if (&cp[2] < endp && cp[1] == '0') return (NULL); } if (cp <= name) { cp = endp; } else { *cp = '\0'; } /* * Look up the ILL, based on the portion of the name * before the slash. ill_lookup_on_name returns a held ill. * Temporary to check whether ill exists already. If so * ill_lookup_on_name will clear it. */ ill = ill_lookup_on_name(name, do_alloc, isv6, q, mp, func, error, &did_alloc); if (cp != endp) *cp = IPIF_SEPARATOR_CHAR; if (ill == NULL) return (NULL); /* Establish the unit number in the name. */ id = 0; if (cp < endp && *endp == '\0') { /* If there was a colon, the unit number follows. */ cp++; if (ddi_strtol(cp, NULL, 0, &id) != 0) { ill_refrele(ill); if (error != NULL) *error = ENXIO; return (NULL); } } GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); /* Now see if there is an IPIF with this unit number. */ for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) { if (ipif->ipif_id == id) { if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid) { mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); ill_refrele(ill); if (error != NULL) *error = ENXIO; return (NULL); } /* * The block comment at the start of ipif_down * explains the use of the macros used below */ if (IPIF_CAN_LOOKUP(ipif)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); if (!did_alloc) *exists = B_TRUE; /* * Drop locks before calling ill_refrele * since it can potentially call into * ipif_ill_refrele_tail which can end up * in trying to acquire any lock. */ RELEASE_CONN_LOCK(q); ill_refrele(ill); return (ipif); } else if (IPIF_CAN_WAIT(ipif, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); mutex_exit(&ill->ill_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); ill_refrele(ill); *error = EINPROGRESS; return (NULL); } } } RELEASE_CONN_LOCK(q); if (!do_alloc) { mutex_exit(&ill->ill_lock); ill_refrele(ill); if (error != NULL) *error = ENXIO; return (NULL); } /* * If none found, atomically allocate and return a new one. * Historically, we used IRE_LOOPBACK only for lun 0, and IRE_LOCAL * to support "receive only" use of lo0:1 etc. as is still done * below as an initial guess. * However, this is now likely to be overriden later in ipif_up_done() * when we know for sure what address has been configured on the * interface, since we might have more than one loopback interface * with a loopback address, e.g. in the case of zones, and all the * interfaces with loopback addresses need to be marked IRE_LOOPBACK. */ if (ill->ill_net_type == IRE_LOOPBACK && id == 0) ire_type = IRE_LOOPBACK; else ire_type = IRE_LOCAL; ipif = ipif_allocate(ill, id, ire_type, B_TRUE); if (ipif != NULL) ipif_refhold_locked(ipif); else if (error != NULL) *error = ENOMEM; mutex_exit(&ill->ill_lock); ill_refrele(ill); return (ipif); } /* * This routine is called whenever a new address comes up on an ipif. If * we are configured to respond to address mask requests, then we are supposed * to broadcast an address mask reply at this time. This routine is also * called if we are already up, but a netmask change is made. This is legal * but might not make the system manager very popular. (May be called * as writer.) */ static void ipif_mask_reply(ipif_t *ipif) { icmph_t *icmph; ipha_t *ipha; mblk_t *mp; #define REPLY_LEN (sizeof (icmp_ipha) + sizeof (icmph_t) + IP_ADDR_LEN) if (!ip_respond_to_address_mask_broadcast) return; /* ICMP mask reply is IPv4 only */ ASSERT(!ipif->ipif_isv6); /* ICMP mask reply is not for a loopback interface */ ASSERT(ipif->ipif_ill->ill_wq != NULL); mp = allocb(REPLY_LEN, BPRI_HI); if (mp == NULL) return; mp->b_wptr = mp->b_rptr + REPLY_LEN; ipha = (ipha_t *)mp->b_rptr; bzero(ipha, REPLY_LEN); *ipha = icmp_ipha; ipha->ipha_ttl = ip_broadcast_ttl; ipha->ipha_src = ipif->ipif_src_addr; ipha->ipha_dst = ipif->ipif_brd_addr; ipha->ipha_length = htons(REPLY_LEN); ipha->ipha_ident = 0; icmph = (icmph_t *)&ipha[1]; icmph->icmph_type = ICMP_ADDRESS_MASK_REPLY; bcopy(&ipif->ipif_net_mask, &icmph[1], IP_ADDR_LEN); icmph->icmph_checksum = IP_CSUM(mp, sizeof (ipha_t), 0); if (icmph->icmph_checksum == 0) icmph->icmph_checksum = 0xffff; put(ipif->ipif_wq, mp); #undef REPLY_LEN } /* * When the mtu in the ipif changes, we call this routine through ire_walk * to update all the relevant IREs. * Skip IRE_LOCAL and "loopback" IRE_BROADCAST by checking ire_stq. */ static void ipif_mtu_change(ire_t *ire, char *ipif_arg) { ipif_t *ipif = (ipif_t *)ipif_arg; if (ire->ire_stq == NULL || ire->ire_ipif != ipif) return; ire->ire_max_frag = MIN(ipif->ipif_mtu, IP_MAXPACKET); } /* * When the mtu in the ill changes, we call this routine through ire_walk * to update all the relevant IREs. * Skip IRE_LOCAL and "loopback" IRE_BROADCAST by checking ire_stq. */ void ill_mtu_change(ire_t *ire, char *ill_arg) { ill_t *ill = (ill_t *)ill_arg; if (ire->ire_stq == NULL || ire->ire_ipif->ipif_ill != ill) return; ire->ire_max_frag = ire->ire_ipif->ipif_mtu; } /* * Join the ipif specific multicast groups. * Must be called after a mapping has been set up in the resolver. (Always * called as writer.) */ void ipif_multicast_up(ipif_t *ipif) { int err, index; ill_t *ill; ASSERT(IAM_WRITER_IPIF(ipif)); ill = ipif->ipif_ill; index = ill->ill_phyint->phyint_ifindex; ip1dbg(("ipif_multicast_up\n")); if (!(ill->ill_flags & ILLF_MULTICAST) || ipif->ipif_multicast_up) return; if (ipif->ipif_isv6) { if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) return; /* Join the all hosts multicast address */ ip1dbg(("ipif_multicast_up - addmulti\n")); /* * Passing B_TRUE means we have to join the multicast * membership on this interface even though this is * FAILED. If we join on a different one in the group, * we will not be able to delete the membership later * as we currently don't track where we join when we * join within the kernel unlike applications where * we have ilg/ilg_orig_index. See ip_addmulti_v6 * for more on this. */ err = ip_addmulti_v6(&ipv6_all_hosts_mcast, ill, index, ipif->ipif_zoneid, ILGSTAT_NONE, MODE_IS_EXCLUDE, NULL); if (err != 0) { ip0dbg(("ipif_multicast_up: " "all_hosts_mcast failed %d\n", err)); return; } /* * Enable multicast for the solicited node multicast address */ if (!(ipif->ipif_flags & IPIF_NOLOCAL)) { in6_addr_t ipv6_multi = ipv6_solicited_node_mcast; ipv6_multi.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3]; err = ip_addmulti_v6(&ipv6_multi, ill, index, ipif->ipif_zoneid, ILGSTAT_NONE, MODE_IS_EXCLUDE, NULL); if (err != 0) { ip0dbg(("ipif_multicast_up: solicited MC" " failed %d\n", err)); (void) ip_delmulti_v6(&ipv6_all_hosts_mcast, ill, ill->ill_phyint->phyint_ifindex, ipif->ipif_zoneid, B_TRUE, B_TRUE); return; } } } else { if (ipif->ipif_lcl_addr == INADDR_ANY) return; /* Join the all hosts multicast address */ ip1dbg(("ipif_multicast_up - addmulti\n")); err = ip_addmulti(htonl(INADDR_ALLHOSTS_GROUP), ipif, ILGSTAT_NONE, MODE_IS_EXCLUDE, NULL); if (err) { ip0dbg(("ipif_multicast_up: failed %d\n", err)); return; } } ipif->ipif_multicast_up = 1; } /* * Blow away any IPv6 multicast groups that we joined in ipif_multicast_up(); * any explicit memberships are blown away in ill_leave_multicast() when the * ill is brought down. */ static void ipif_multicast_down(ipif_t *ipif) { int err; ASSERT(IAM_WRITER_IPIF(ipif)); ip1dbg(("ipif_multicast_down\n")); if (!ipif->ipif_multicast_up) return; ASSERT(ipif->ipif_isv6); ip1dbg(("ipif_multicast_down - delmulti\n")); /* * Leave the all hosts multicast address. Similar to ip_addmulti_v6, * we should look for ilms on this ill rather than the ones that have * been failed over here. They are here temporarily. As * ipif_multicast_up has joined on this ill, we should delete only * from this ill. */ err = ip_delmulti_v6(&ipv6_all_hosts_mcast, ipif->ipif_ill, ipif->ipif_ill->ill_phyint->phyint_ifindex, ipif->ipif_zoneid, B_TRUE, B_TRUE); if (err != 0) { ip0dbg(("ipif_multicast_down: all_hosts_mcast failed %d\n", err)); } /* * Disable multicast for the solicited node multicast address */ if (!(ipif->ipif_flags & IPIF_NOLOCAL)) { in6_addr_t ipv6_multi = ipv6_solicited_node_mcast; ipv6_multi.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3]; err = ip_delmulti_v6(&ipv6_multi, ipif->ipif_ill, ipif->ipif_ill->ill_phyint->phyint_ifindex, ipif->ipif_zoneid, B_TRUE, B_TRUE); if (err != 0) { ip0dbg(("ipif_multicast_down: sol MC failed %d\n", err)); } } ipif->ipif_multicast_up = 0; } /* * Used when an interface comes up to recreate any extra routes on this * interface. */ static ire_t ** ipif_recover_ire(ipif_t *ipif) { mblk_t *mp; ire_t **ipif_saved_irep; ire_t **irep; ip1dbg(("ipif_recover_ire(%s:%u)", ipif->ipif_ill->ill_name, ipif->ipif_id)); mutex_enter(&ipif->ipif_saved_ire_lock); ipif_saved_irep = (ire_t **)kmem_zalloc(sizeof (ire_t *) * ipif->ipif_saved_ire_cnt, KM_NOSLEEP); if (ipif_saved_irep == NULL) { mutex_exit(&ipif->ipif_saved_ire_lock); return (NULL); } irep = ipif_saved_irep; for (mp = ipif->ipif_saved_ire_mp; mp != NULL; mp = mp->b_cont) { ire_t *ire; queue_t *rfq; queue_t *stq; ifrt_t *ifrt; uchar_t *src_addr; uchar_t *gateway_addr; mblk_t *resolver_mp; ushort_t type; /* * When the ire was initially created and then added in * ip_rt_add(), it was created either using ipif->ipif_net_type * in the case of a traditional interface route, or as one of * the IRE_OFFSUBNET types (with the exception of * IRE_HOST_REDIRECT which is created by icmp_redirect() and * which we don't need to save or recover). In the case where * ipif->ipif_net_type was IRE_LOOPBACK, ip_rt_add() will update * the ire_type to IRE_IF_NORESOLVER before calling ire_add() * to satisfy software like GateD and Sun Cluster which creates * routes using the the loopback interface's address as a * gateway. * * As ifrt->ifrt_type reflects the already updated ire_type and * since ire_create() expects that IRE_IF_NORESOLVER will have * a valid ire_dlureq_mp field (which doesn't make sense for a * IRE_LOOPBACK), ire_create() will be called in the same way * here as in ip_rt_add(), namely using ipif->ipif_net_type when * the route looks like a traditional interface route (where * ifrt->ifrt_type & IRE_INTERFACE is true) and otherwise using * the saved ifrt->ifrt_type. This means that in the case where * ipif->ipif_net_type is IRE_LOOPBACK, the ire created by * ire_create() will be an IRE_LOOPBACK, it will then be turned * into an IRE_IF_NORESOLVER and then added by ire_add(). */ ifrt = (ifrt_t *)mp->b_rptr; if (ifrt->ifrt_type & IRE_INTERFACE) { rfq = NULL; stq = (ipif->ipif_net_type == IRE_IF_RESOLVER) ? ipif->ipif_rq : ipif->ipif_wq; src_addr = (ifrt->ifrt_flags & RTF_SETSRC) ? (uint8_t *)&ifrt->ifrt_src_addr : (uint8_t *)&ipif->ipif_src_addr; gateway_addr = NULL; resolver_mp = ipif->ipif_resolver_mp; type = ipif->ipif_net_type; } else if (ifrt->ifrt_type & IRE_BROADCAST) { /* Recover multiroute broadcast IRE. */ rfq = ipif->ipif_rq; stq = ipif->ipif_wq; src_addr = (ifrt->ifrt_flags & RTF_SETSRC) ? (uint8_t *)&ifrt->ifrt_src_addr : (uint8_t *)&ipif->ipif_src_addr; gateway_addr = (uint8_t *)&ifrt->ifrt_gateway_addr; resolver_mp = ipif->ipif_bcast_mp; type = ifrt->ifrt_type; } else { rfq = NULL; stq = NULL; src_addr = (ifrt->ifrt_flags & RTF_SETSRC) ? (uint8_t *)&ifrt->ifrt_src_addr : NULL; gateway_addr = (uint8_t *)&ifrt->ifrt_gateway_addr; resolver_mp = NULL; type = ifrt->ifrt_type; } /* * Create a copy of the IRE with the saved address and netmask. */ ip1dbg(("ipif_recover_ire: creating IRE %s (%d) for " "0x%x/0x%x\n", ip_nv_lookup(ire_nv_tbl, ifrt->ifrt_type), ifrt->ifrt_type, ntohl(ifrt->ifrt_addr), ntohl(ifrt->ifrt_mask))); ire = ire_create( (uint8_t *)&ifrt->ifrt_addr, (uint8_t *)&ifrt->ifrt_mask, src_addr, gateway_addr, NULL, &ifrt->ifrt_max_frag, NULL, rfq, stq, type, resolver_mp, ipif, NULL, 0, 0, 0, ifrt->ifrt_flags, &ifrt->ifrt_iulp_info); if (ire == NULL) { mutex_exit(&ipif->ipif_saved_ire_lock); kmem_free(ipif_saved_irep, ipif->ipif_saved_ire_cnt * sizeof (ire_t *)); return (NULL); } /* * Some software (for example, GateD and Sun Cluster) attempts * to create (what amount to) IRE_PREFIX routes with the * loopback address as the gateway. This is primarily done to * set up prefixes with the RTF_REJECT flag set (for example, * when generating aggregate routes.) * * If the IRE type (as defined by ipif->ipif_net_type) is * IRE_LOOPBACK, then we map the request into a * IRE_IF_NORESOLVER. */ if (ipif->ipif_net_type == IRE_LOOPBACK) ire->ire_type = IRE_IF_NORESOLVER; /* * ire held by ire_add, will be refreled' towards the * the end of ipif_up_done */ (void) ire_add(&ire, NULL, NULL, NULL); *irep = ire; irep++; ip1dbg(("ipif_recover_ire: added ire %p\n", (void *)ire)); } mutex_exit(&ipif->ipif_saved_ire_lock); return (ipif_saved_irep); } /* * Used to set the netmask and broadcast address to default values when the * interface is brought up. (Always called as writer.) */ static void ipif_set_default(ipif_t *ipif) { ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock)); if (!ipif->ipif_isv6) { /* * Interface holds an IPv4 address. Default * mask is the natural netmask. */ if (!ipif->ipif_net_mask) { ipaddr_t v4mask; v4mask = ip_net_mask(ipif->ipif_lcl_addr); V4MASK_TO_V6(v4mask, ipif->ipif_v6net_mask); } if (ipif->ipif_flags & IPIF_POINTOPOINT) { /* ipif_subnet is ipif_pp_dst_addr for pt-pt */ ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr; } else { V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } /* * NOTE: SunOS 4.X does this even if the broadcast address * has been already set thus we do the same here. */ if (ipif->ipif_flags & IPIF_BROADCAST) { ipaddr_t v4addr; v4addr = ipif->ipif_subnet | ~ipif->ipif_net_mask; IN6_IPADDR_TO_V4MAPPED(v4addr, &ipif->ipif_v6brd_addr); } } else { /* * Interface holds an IPv6-only address. Default * mask is all-ones. */ if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6net_mask)) ipif->ipif_v6net_mask = ipv6_all_ones; if (ipif->ipif_flags & IPIF_POINTOPOINT) { /* ipif_subnet is ipif_pp_dst_addr for pt-pt */ ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr; } else { V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } } } /* * Return 0 if this address can be used as local address without causing * duplicate address problems. Otherwise, return EADDRNOTAVAIL if the address * is already up on a different ill, and EADDRINUSE if it's up on the same ill. * Special checks are needed to allow the same IPv6 link-local address * on different ills. * TODO: allowing the same site-local address on different ill's. */ int ip_addr_availability_check(ipif_t *new_ipif) { in6_addr_t our_v6addr; ill_t *ill; ipif_t *ipif; ill_walk_context_t ctx; ASSERT(IAM_WRITER_IPIF(new_ipif)); ASSERT(MUTEX_HELD(&ip_addr_avail_lock)); ASSERT(RW_READ_HELD(&ill_g_lock)); new_ipif->ipif_flags &= ~IPIF_UNNUMBERED; if (IN6_IS_ADDR_UNSPECIFIED(&new_ipif->ipif_v6lcl_addr) || IN6_IS_ADDR_V4MAPPED_ANY(&new_ipif->ipif_v6lcl_addr)) return (0); our_v6addr = new_ipif->ipif_v6lcl_addr; if (new_ipif->ipif_isv6) ill = ILL_START_WALK_V6(&ctx); else ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if ((ipif == new_ipif) || !(ipif->ipif_flags & IPIF_UP) || (ipif->ipif_flags & IPIF_UNNUMBERED)) continue; if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr, &our_v6addr)) { if (new_ipif->ipif_flags & IPIF_POINTOPOINT) new_ipif->ipif_flags |= IPIF_UNNUMBERED; else if (ipif->ipif_flags & IPIF_POINTOPOINT) ipif->ipif_flags |= IPIF_UNNUMBERED; else if (IN6_IS_ADDR_LINKLOCAL(&our_v6addr) && new_ipif->ipif_ill != ill) continue; else if (IN6_IS_ADDR_SITELOCAL(&our_v6addr) && new_ipif->ipif_ill != ill) continue; else if (new_ipif->ipif_zoneid != ipif->ipif_zoneid && (ill->ill_phyint->phyint_flags & PHYI_LOOPBACK)) continue; else if (new_ipif->ipif_ill == ill) return (EADDRINUSE); else return (EADDRNOTAVAIL); } } } return (0); } /* * Bring up an ipif: bring up arp/ndp, bring up the DLPI stream, and add * IREs for the ipif. * When the routine returns EINPROGRESS then mp has been consumed and * the ioctl will be acked from ip_rput_dlpi. */ static int ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp) { ill_t *ill = ipif->ipif_ill; boolean_t isv6 = ipif->ipif_isv6; int err = 0; boolean_t success; ASSERT(IAM_WRITER_IPIF(ipif)); ip1dbg(("ipif_up(%s:%u)\n", ill->ill_name, ipif->ipif_id)); /* Shouldn't get here if it is already up. */ if (ipif->ipif_flags & IPIF_UP) return (EALREADY); /* Skip arp/ndp for any loopback interface. */ if (ill->ill_wq != NULL) { conn_t *connp = Q_TO_CONN(q); ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq; if (!ill->ill_dl_up) { /* * ill_dl_up is not yet set. i.e. we are yet to * DL_BIND with the driver and this is the first * logical interface on the ill to become "up". * Tell the driver to get going (via DL_BIND_REQ). * Note that changing "significant" IFF_ flags * address/netmask etc cause a down/up dance, but * does not cause an unbind (DL_UNBIND) with the driver */ return (ill_dl_up(ill, ipif, mp, q)); } /* * ipif_resolver_up may end up sending an * AR_INTERFACE_UP message to ARP, which would, in * turn send a DLPI message to the driver. ioctls are * serialized and so we cannot send more than one * interface up message at a time. If ipif_resolver_up * does send an interface up message to ARP, we get * EINPROGRESS and we will complete in ip_arp_done. */ ASSERT(connp != NULL); ASSERT(ipsq->ipsq_pending_mp == NULL); mutex_enter(&connp->conn_lock); mutex_enter(&ill->ill_lock); success = ipsq_pending_mp_add(connp, ipif, q, mp, 0); mutex_exit(&ill->ill_lock); mutex_exit(&connp->conn_lock); if (!success) return (EINTR); /* * Crank up IPv6 neighbor discovery * Unlike ARP, this should complete when * ipif_ndp_up returns. However, for * ILLF_XRESOLV interfaces we also send a * AR_INTERFACE_UP to the external resolver. * That ioctl will complete in ip_rput. */ if (isv6) { err = ipif_ndp_up(ipif, &ipif->ipif_v6lcl_addr, B_FALSE); if (err != 0) { mp = ipsq_pending_mp_get(ipsq, &connp); return (err); } } /* Now, ARP */ if ((err = ipif_resolver_up(ipif, B_FALSE)) == EINPROGRESS) { /* We will complete it in ip_arp_done */ return (err); } mp = ipsq_pending_mp_get(ipsq, &connp); ASSERT(mp != NULL); if (err != 0) return (err); } return (isv6 ? ipif_up_done_v6(ipif) : ipif_up_done(ipif)); } /* * Perform a bind for the physical device. * When the routine returns EINPROGRESS then mp has been consumed and * the ioctl will be acked from ip_rput_dlpi. * Allocate an unbind message and save it until ipif_down. */ static int ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q) { mblk_t *areq_mp = NULL; mblk_t *bind_mp = NULL; mblk_t *unbind_mp = NULL; conn_t *connp; boolean_t success; ip1dbg(("ill_dl_up(%s)\n", ill->ill_name)); ASSERT(IAM_WRITER_ILL(ill)); ASSERT(mp != NULL); /* Create a resolver cookie for ARP */ if (!ill->ill_isv6 && ill->ill_net_type == IRE_IF_RESOLVER) { areq_t *areq; uint16_t sap_addr; areq_mp = ill_arp_alloc(ill, (uchar_t *)&ip_areq_template, 0); if (areq_mp == NULL) { return (ENOMEM); } freemsg(ill->ill_resolver_mp); ill->ill_resolver_mp = areq_mp; areq = (areq_t *)areq_mp->b_rptr; sap_addr = ill->ill_sap; bcopy(&sap_addr, areq->areq_sap, sizeof (sap_addr)); /* * Wait till we call ill_pending_mp_add to determine * the success before we free the ill_resolver_mp and * attach areq_mp in it's place. */ } bind_mp = ip_dlpi_alloc(sizeof (dl_bind_req_t) + sizeof (long), DL_BIND_REQ); if (bind_mp == NULL) goto bad; ((dl_bind_req_t *)bind_mp->b_rptr)->dl_sap = ill->ill_sap; ((dl_bind_req_t *)bind_mp->b_rptr)->dl_service_mode = DL_CLDLS; unbind_mp = ip_dlpi_alloc(sizeof (dl_unbind_req_t), DL_UNBIND_REQ); if (unbind_mp == NULL) goto bad; /* * Record state needed to complete this operation when the * DL_BIND_ACK shows up. Also remember the pre-allocated mblks. */ if (WR(q)->q_next == NULL) { connp = Q_TO_CONN(q); mutex_enter(&connp->conn_lock); } else { connp = NULL; } mutex_enter(&ipif->ipif_ill->ill_lock); success = ipsq_pending_mp_add(connp, ipif, q, mp, 0); mutex_exit(&ipif->ipif_ill->ill_lock); if (connp != NULL) mutex_exit(&connp->conn_lock); if (!success) goto bad; /* * Save the unbind message for ill_dl_down(); it will be consumed when * the interface goes down. */ ASSERT(ill->ill_unbind_mp == NULL); ill->ill_unbind_mp = unbind_mp; ill_dlpi_send(ill, bind_mp); /* Send down link-layer capabilities probe if not already done. */ ill_capability_probe(ill); /* * Sysid used to rely on the fact that netboots set domainname * and the like. Now that miniroot boots aren't strictly netboots * and miniroot network configuration is driven from userland * these things still need to be set. This situation can be detected * by comparing the interface being configured here to the one * dhcack was set to reference by the boot loader. Once sysid is * converted to use dhcp_ipc_getinfo() this call can go away. */ if ((ipif->ipif_flags & IPIF_DHCPRUNNING) && (dhcack != NULL) && (strcmp(ill->ill_name, dhcack) == 0) && (strlen(srpc_domain) == 0)) { if (dhcpinit() != 0) cmn_err(CE_WARN, "no cached dhcp response"); } /* * This operation will complete in ip_rput_dlpi with either * a DL_BIND_ACK or DL_ERROR_ACK. */ return (EINPROGRESS); bad: ip1dbg(("ill_dl_up(%s) FAILED\n", ill->ill_name)); /* * We don't have to check for possible removal from illgrp * as we have not yet inserted in illgrp. For groups * without names, this ipif is still not UP and hence * this could not have possibly had any influence in forming * groups. */ if (bind_mp != NULL) freemsg(bind_mp); if (unbind_mp != NULL) freemsg(unbind_mp); return (ENOMEM); } uint_t ip_loopback_mtuplus = IP_LOOPBACK_MTU + IP_SIMPLE_HDR_LENGTH + 20; /* * DLPI and ARP is up. * Create all the IREs associated with an interface bring up multicast. * Set the interface flag and finish other initialization * that potentially had to be differed to after DL_BIND_ACK. */ int ipif_up_done(ipif_t *ipif) { ire_t *ire_array[20]; ire_t **irep = ire_array; ire_t **irep1; ipaddr_t net_mask = 0; ipaddr_t subnet_mask, route_mask; ill_t *ill = ipif->ipif_ill; queue_t *stq; ipif_t *src_ipif; ipif_t *tmp_ipif; boolean_t flush_ire_cache = B_TRUE; int err = 0; phyint_t *phyi; ire_t **ipif_saved_irep = NULL; int ipif_saved_ire_cnt; int cnt; boolean_t src_ipif_held = B_FALSE; boolean_t ire_added = B_FALSE; boolean_t loopback = B_FALSE; ip1dbg(("ipif_up_done(%s:%u)\n", ipif->ipif_ill->ill_name, ipif->ipif_id)); /* Check if this is a loopback interface */ if (ipif->ipif_ill->ill_wq == NULL) loopback = B_TRUE; ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock)); /* * If all other interfaces for this ill are down or DEPRECATED, * or otherwise unsuitable for source address selection, remove * any IRE_CACHE entries for this ill to make sure source * address selection gets to take this new ipif into account. * No need to hold ill_lock while traversing the ipif list since * we are writer */ for (tmp_ipif = ill->ill_ipif; tmp_ipif; tmp_ipif = tmp_ipif->ipif_next) { if (((tmp_ipif->ipif_flags & (IPIF_NOXMIT|IPIF_ANYCAST|IPIF_NOLOCAL|IPIF_DEPRECATED)) || !(tmp_ipif->ipif_flags & IPIF_UP)) || (tmp_ipif == ipif)) continue; /* first useable pre-existing interface */ flush_ire_cache = B_FALSE; break; } if (flush_ire_cache) ire_walk_ill_v4(MATCH_IRE_ILL_GROUP | MATCH_IRE_TYPE, IRE_CACHE, ill_ipif_cache_delete, (char *)ill, ill); /* * Figure out which way the send-to queue should go. Only * IRE_IF_RESOLVER or IRE_IF_NORESOLVER or IRE_LOOPBACK * should show up here. */ switch (ill->ill_net_type) { case IRE_IF_RESOLVER: stq = ill->ill_rq; break; case IRE_IF_NORESOLVER: case IRE_LOOPBACK: stq = ill->ill_wq; break; default: return (EINVAL); } if (ill->ill_phyint->phyint_flags & PHYI_LOOPBACK) { /* * lo0:1 and subsequent ipifs were marked IRE_LOCAL in * ipif_lookup_on_name(), but in the case of zones we can have * several loopback addresses on lo0. So all the interfaces with * loopback addresses need to be marked IRE_LOOPBACK. */ if (V4_PART_OF_V6(ipif->ipif_v6lcl_addr) == htonl(INADDR_LOOPBACK)) ipif->ipif_ire_type = IRE_LOOPBACK; else ipif->ipif_ire_type = IRE_LOCAL; } if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST|IPIF_DEPRECATED)) { /* * Can't use our source address. Select a different * source address for the IRE_INTERFACE and IRE_LOCAL */ src_ipif = ipif_select_source(ipif->ipif_ill, ipif->ipif_subnet, ipif->ipif_zoneid); if (src_ipif == NULL) src_ipif = ipif; /* Last resort */ else src_ipif_held = B_TRUE; } else { src_ipif = ipif; } /* Create all the IREs associated with this interface */ if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { /* Register the source address for __sin6_src_id */ err = ip_srcid_insert(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid); if (err != 0) { ip0dbg(("ipif_up_done: srcid_insert %d\n", err)); return (err); } /* If the interface address is set, create the local IRE. */ ip1dbg(("ipif_up_done: 0x%p creating IRE 0x%x for 0x%x\n", (void *)ipif, ipif->ipif_ire_type, ntohl(ipif->ipif_lcl_addr))); *irep++ = ire_create( (uchar_t *)&ipif->ipif_lcl_addr, /* dest address */ (uchar_t *)&ip_g_all_ones, /* mask */ (uchar_t *)&src_ipif->ipif_src_addr, /* source address */ NULL, /* no gateway */ NULL, &ip_loopback_mtuplus, /* max frag size */ NULL, ipif->ipif_rq, /* recv-from queue */ NULL, /* no send-to queue */ ipif->ipif_ire_type, /* LOCAL or LOOPBACK */ NULL, ipif, NULL, 0, 0, 0, (ipif->ipif_flags & IPIF_PRIVATE) ? RTF_PRIVATE : 0, &ire_uinfo_null); } else { ip1dbg(( "ipif_up_done: not creating IRE %d for 0x%x: flags 0x%x\n", ipif->ipif_ire_type, ntohl(ipif->ipif_lcl_addr), (uint_t)ipif->ipif_flags)); } if ((ipif->ipif_lcl_addr != INADDR_ANY) && !(ipif->ipif_flags & IPIF_NOLOCAL)) { net_mask = ip_net_mask(ipif->ipif_lcl_addr); } else { net_mask = htonl(IN_CLASSA_NET); /* fallback */ } subnet_mask = ipif->ipif_net_mask; /* * If mask was not specified, use natural netmask of * interface address. Also, store this mask back into the * ipif struct. */ if (subnet_mask == 0) { subnet_mask = net_mask; V4MASK_TO_V6(subnet_mask, ipif->ipif_v6net_mask); V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask, ipif->ipif_v6subnet); } /* Set up the IRE_IF_RESOLVER or IRE_IF_NORESOLVER, as appropriate. */ if (stq != NULL && !(ipif->ipif_flags & IPIF_NOXMIT) && ipif->ipif_subnet != INADDR_ANY) { /* ipif_subnet is ipif_pp_dst_addr for pt-pt */ if (ipif->ipif_flags & IPIF_POINTOPOINT) { route_mask = IP_HOST_MASK; } else { route_mask = subnet_mask; } ip1dbg(("ipif_up_done: ipif 0x%p ill 0x%p " "creating if IRE ill_net_type 0x%x for 0x%x\n", (void *)ipif, (void *)ill, ill->ill_net_type, ntohl(ipif->ipif_subnet))); *irep++ = ire_create( (uchar_t *)&ipif->ipif_subnet, /* dest address */ (uchar_t *)&route_mask, /* mask */ (uchar_t *)&src_ipif->ipif_src_addr, /* src addr */ NULL, /* no gateway */ NULL, &ipif->ipif_mtu, /* max frag */ NULL, NULL, /* no recv queue */ stq, /* send-to queue */ ill->ill_net_type, /* IF_[NO]RESOLVER */ ill->ill_resolver_mp, /* xmit header */ ipif, NULL, 0, 0, 0, (ipif->ipif_flags & IPIF_PRIVATE) ? RTF_PRIVATE: 0, &ire_uinfo_null); } /* * If the interface address is set, create the broadcast IREs. * * ire_create_bcast checks if the proposed new IRE matches * any existing IRE's with the same physical interface (ILL). * This should get rid of duplicates. * ire_create_bcast also check IPIF_NOXMIT and does not create * any broadcast ires. */ if ((ipif->ipif_subnet != INADDR_ANY) && (ipif->ipif_flags & IPIF_BROADCAST)) { ipaddr_t addr; ip1dbg(("ipif_up_done: creating broadcast IRE\n")); irep = ire_check_and_create_bcast(ipif, 0, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); irep = ire_check_and_create_bcast(ipif, INADDR_BROADCAST, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); /* * For backward compatibility, we need to create net * broadcast ire's based on the old "IP address class * system." The reason is that some old machines only * respond to these class derived net broadcast. * * But we should not create these net broadcast ire's if * the subnet_mask is shorter than the IP address class based * derived netmask. Otherwise, we may create a net * broadcast address which is the same as an IP address * on the subnet. Then TCP will refuse to talk to that * address. * * Nor do we need IRE_BROADCAST ire's for the interface * with the netmask as 0xFFFFFFFF, as IRE_LOCAL for that * interface is already created. Creating these broadcast * ire's will only create confusion as the "addr" is going * to be same as that of the IP address of the interface. */ if (net_mask < subnet_mask) { addr = net_mask & ipif->ipif_subnet; irep = ire_check_and_create_bcast(ipif, addr, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); irep = ire_check_and_create_bcast(ipif, ~net_mask | addr, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); } if (subnet_mask != 0xFFFFFFFF) { addr = ipif->ipif_subnet; irep = ire_check_and_create_bcast(ipif, addr, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); irep = ire_check_and_create_bcast(ipif, ~subnet_mask|addr, irep, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); } } ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock)); /* If an earlier ire_create failed, get out now */ for (irep1 = irep; irep1 > ire_array; ) { irep1--; if (*irep1 == NULL) { ip1dbg(("ipif_up_done: NULL ire found in ire_array\n")); err = ENOMEM; goto bad; } } /* * Need to atomically check for ip_addr_availablity_check * under ip_addr_avail_lock, and if it fails got bad, and remove * from group also.The ill_g_lock is grabbed as reader * just to make sure no new ills or new ipifs are being added * to the system while we are checking the uniqueness of addresses. */ rw_enter(&ill_g_lock, RW_READER); mutex_enter(&ip_addr_avail_lock); /* Mark it up, and increment counters. */ ill->ill_ipif_up_count++; ipif->ipif_flags |= IPIF_UP; err = ip_addr_availability_check(ipif); mutex_exit(&ip_addr_avail_lock); rw_exit(&ill_g_lock); if (err != 0) { /* * Our address may already be up on the same ill. In this case, * the ARP entry for our ipif replaced the one for the other * ipif. So we don't want to delete it (otherwise the other ipif * would be unable to send packets). * ip_addr_availability_check() identifies this case for us and * returns EADDRINUSE; we need to turn it into EADDRNOTAVAIL * which is the expected error code. */ if (err == EADDRINUSE) { freemsg(ipif->ipif_arp_del_mp); ipif->ipif_arp_del_mp = NULL; err = EADDRNOTAVAIL; } ill->ill_ipif_up_count--; ipif->ipif_flags &= ~IPIF_UP; goto bad; } /* * Add in all newly created IREs. ire_create_bcast() has * already checked for duplicates of the IRE_BROADCAST type. * We want to add before we call ifgrp_insert which wants * to know whether IRE_IF_RESOLVER exists or not. * * NOTE : We refrele the ire though we may branch to "bad" * later on where we do ire_delete. This is okay * because nobody can delete it as we are running * exclusively. */ for (irep1 = irep; irep1 > ire_array; ) { irep1--; ASSERT(!MUTEX_HELD(&((*irep1)->ire_ipif->ipif_ill->ill_lock))); /* * refheld by ire_add. refele towards the end of the func */ (void) ire_add(irep1, NULL, NULL, NULL); } ire_added = B_TRUE; /* * Form groups if possible. * * If we are supposed to be in a ill_group with a name, insert it * now as we know that at least one ipif is UP. Otherwise form * nameless groups. * * If ip_enable_group_ifs is set and ipif address is not 0, insert * this ipif into the appropriate interface group, or create a * new one. If this is already in a nameless group, we try to form * a bigger group looking at other ills potentially sharing this * ipif's prefix. */ phyi = ill->ill_phyint; if (phyi->phyint_groupname_len != 0) { ASSERT(phyi->phyint_groupname != NULL); if (ill->ill_ipif_up_count == 1) { ASSERT(ill->ill_group == NULL); err = illgrp_insert(&illgrp_head_v4, ill, phyi->phyint_groupname, NULL, B_TRUE); if (err != 0) { ip1dbg(("ipif_up_done: illgrp allocation " "failed, error %d\n", err)); goto bad; } } ASSERT(ill->ill_group != NULL); } /* * When this is part of group, we need to make sure that * any broadcast ires created because of this ipif coming * UP gets marked/cleared with IRE_MARK_NORECV appropriately * so that we don't receive duplicate broadcast packets. */ if (ill->ill_group != NULL && ill->ill_ipif_up_count != 0) ipif_renominate_bcast(ipif); /* Recover any additional IRE_IF_[NO]RESOLVER entries for this ipif */ ipif_saved_ire_cnt = ipif->ipif_saved_ire_cnt; ipif_saved_irep = ipif_recover_ire(ipif); if (!loopback) { /* * If the broadcast address has been set, make sure it makes * sense based on the interface address. * Only match on ill since we are sharing broadcast addresses. */ if ((ipif->ipif_brd_addr != INADDR_ANY) && (ipif->ipif_flags & IPIF_BROADCAST)) { ire_t *ire; ire = ire_ctable_lookup(ipif->ipif_brd_addr, 0, IRE_BROADCAST, ipif, ALL_ZONES, (MATCH_IRE_TYPE | MATCH_IRE_ILL)); if (ire == NULL) { /* * If there isn't a matching broadcast IRE, * revert to the default for this netmask. */ ipif->ipif_v6brd_addr = ipv6_all_zeros; mutex_enter(&ipif->ipif_ill->ill_lock); ipif_set_default(ipif); mutex_exit(&ipif->ipif_ill->ill_lock); } else { ire_refrele(ire); } } } /* This is the first interface on this ill */ if (ipif->ipif_ipif_up_count == 1 && !loopback) { /* * Need to recover all multicast memberships in the driver. * This had to be deferred until we had attached. */ ill_recover_multicast(ill); } /* Join the allhosts multicast address */ ipif_multicast_up(ipif); if (!loopback) { /* * See whether anybody else would benefit from the * new ipif that we added. We call this always rather * than while adding a non-IPIF_NOLOCAL/DEPRECATED/ANYCAST * ipif is for the benefit of illgrp_insert (done above) * which does not do source address selection as it does * not want to re-create interface routes that we are * having reference to it here. */ ill_update_source_selection(ill); } for (irep1 = irep; irep1 > ire_array; ) { irep1--; if (*irep1 != NULL) { /* was held in ire_add */ ire_refrele(*irep1); } } cnt = ipif_saved_ire_cnt; for (irep1 = ipif_saved_irep; cnt > 0; irep1++, cnt--) { if (*irep1 != NULL) { /* was held in ire_add */ ire_refrele(*irep1); } } /* * This had to be deferred until we had bound. * tell routing sockets that this interface is up */ ip_rts_ifmsg(ipif); ip_rts_newaddrmsg(RTM_ADD, 0, ipif); if (!loopback) { /* Broadcast an address mask reply. */ ipif_mask_reply(ipif); } if (ipif_saved_irep != NULL) { kmem_free(ipif_saved_irep, ipif_saved_ire_cnt * sizeof (ire_t *)); } if (src_ipif_held) ipif_refrele(src_ipif); /* Let SCTP update the status for this ipif */ sctp_update_ipif(ipif, SCTP_IPIF_UP); return (0); bad: ip1dbg(("ipif_up_done: FAILED \n")); /* * We don't have to bother removing from ill groups because * * 1) For groups with names, we insert only when the first ipif * comes up. In that case if it fails, it will not be in any * group. So, we need not try to remove for that case. * * 2) For groups without names, either we tried to insert ipif_ill * in a group as singleton or found some other group to become * a bigger group. For the former, if it fails we don't have * anything to do as ipif_ill is not in the group and for the * latter, there are no failures in illgrp_insert/illgrp_delete * (ENOMEM can't occur for this. Check ifgrp_insert). */ while (irep > ire_array) { irep--; if (*irep != NULL) { ire_delete(*irep); if (ire_added) ire_refrele(*irep); } } (void) ip_srcid_remove(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid); if (ipif_saved_irep != NULL) { kmem_free(ipif_saved_irep, ipif_saved_ire_cnt * sizeof (ire_t *)); } if (src_ipif_held) ipif_refrele(src_ipif); ipif_arp_down(ipif); return (err); } /* * Turn off the ARP with the ILLF_NOARP flag. */ static int ill_arp_off(ill_t *ill) { mblk_t *arp_off_mp = NULL; mblk_t *arp_on_mp = NULL; ip1dbg(("ill_arp_off(%s)\n", ill->ill_name)); ASSERT(IAM_WRITER_ILL(ill)); ASSERT(ill->ill_net_type == IRE_IF_RESOLVER); /* * If the on message is still around we've already done * an arp_off without doing an arp_on thus there is no * work needed. */ if (ill->ill_arp_on_mp != NULL) return (0); /* * Allocate an ARP on message (to be saved) and an ARP off message */ arp_off_mp = ill_arp_alloc(ill, (uchar_t *)&ip_aroff_template, 0); if (!arp_off_mp) return (ENOMEM); arp_on_mp = ill_arp_alloc(ill, (uchar_t *)&ip_aron_template, 0); if (!arp_on_mp) goto failed; ASSERT(ill->ill_arp_on_mp == NULL); ill->ill_arp_on_mp = arp_on_mp; /* Send an AR_INTERFACE_OFF request */ putnext(ill->ill_rq, arp_off_mp); return (0); failed: if (arp_off_mp) freemsg(arp_off_mp); return (ENOMEM); } /* * Turn on ARP by turning off the ILLF_NOARP flag. */ static int ill_arp_on(ill_t *ill) { mblk_t *mp; ip1dbg(("ipif_arp_on(%s)\n", ill->ill_name)); ASSERT(ill->ill_net_type == IRE_IF_RESOLVER); ASSERT(IAM_WRITER_ILL(ill)); /* * Send an AR_INTERFACE_ON request if we have already done * an arp_off (which allocated the message). */ if (ill->ill_arp_on_mp != NULL) { mp = ill->ill_arp_on_mp; ill->ill_arp_on_mp = NULL; putnext(ill->ill_rq, mp); } return (0); } /* * Called after either deleting ill from the group or when setting * FAILED or STANDBY on the interface. */ static void illgrp_reset_schednext(ill_t *ill) { ill_group_t *illgrp; ill_t *save_ill; ASSERT(IAM_WRITER_ILL(ill)); /* * When called from illgrp_delete, ill_group will be non-NULL. * But when called from ip_sioctl_flags, it could be NULL if * somebody is setting FAILED/INACTIVE on some interface which * is not part of a group. */ illgrp = ill->ill_group; if (illgrp == NULL) return; if (illgrp->illgrp_ill_schednext != ill) return; illgrp->illgrp_ill_schednext = NULL; save_ill = ill; /* * Choose a good ill to be the next one for * outbound traffic. As the flags FAILED/STANDBY is * not yet marked when called from ip_sioctl_flags, * we check for ill separately. */ for (ill = illgrp->illgrp_ill; ill != NULL; ill = ill->ill_group_next) { if ((ill != save_ill) && !(ill->ill_phyint->phyint_flags & (PHYI_FAILED|PHYI_INACTIVE|PHYI_OFFLINE))) { illgrp->illgrp_ill_schednext = ill; return; } } } /* * Given an ill, find the next ill in the group to be scheduled. * (This should be called by ip_newroute() before ire_create().) * The passed in ill may be pulled out of the group, after we have picked * up a different outgoing ill from the same group. However ire add will * atomically check this. */ ill_t * illgrp_scheduler(ill_t *ill) { ill_t *retill; ill_group_t *illgrp; int illcnt; int i; uint64_t flags; /* * We don't use a lock to check for the ill_group. If this ill * is currently being inserted we may end up just returning this * ill itself. That is ok. */ if (ill->ill_group == NULL) { ill_refhold(ill); return (ill); } /* * Grab the ill_g_lock as reader to make sure we are dealing with * a set of stable ills. No ill can be added or deleted or change * group while we hold the reader lock. */ rw_enter(&ill_g_lock, RW_READER); if ((illgrp = ill->ill_group) == NULL) { rw_exit(&ill_g_lock); ill_refhold(ill); return (ill); } illcnt = illgrp->illgrp_ill_count; mutex_enter(&illgrp->illgrp_lock); retill = illgrp->illgrp_ill_schednext; if (retill == NULL) retill = illgrp->illgrp_ill; /* * We do a circular search beginning at illgrp_ill_schednext * or illgrp_ill. We don't check the flags against the ill lock * since it can change anytime. The ire creation will be atomic * and will fail if the ill is FAILED or OFFLINE. */ for (i = 0; i < illcnt; i++) { flags = retill->ill_phyint->phyint_flags; if (!(flags & (PHYI_FAILED|PHYI_INACTIVE|PHYI_OFFLINE)) && ILL_CAN_LOOKUP(retill)) { illgrp->illgrp_ill_schednext = retill->ill_group_next; ill_refhold(retill); break; } retill = retill->ill_group_next; if (retill == NULL) retill = illgrp->illgrp_ill; } mutex_exit(&illgrp->illgrp_lock); rw_exit(&ill_g_lock); return (i == illcnt ? NULL : retill); } /* * Checks for availbility of a usable source address (if there is one) when the * destination ILL has the ill_usesrc_ifindex pointing to another ILL. Note * this selection is done regardless of the destination. */ boolean_t ipif_usesrc_avail(ill_t *ill, zoneid_t zoneid) { uint_t ifindex; ipif_t *ipif = NULL; ill_t *uill; boolean_t isv6; ASSERT(ill != NULL); isv6 = ill->ill_isv6; ifindex = ill->ill_usesrc_ifindex; if (ifindex != 0) { uill = ill_lookup_on_ifindex(ifindex, isv6, NULL, NULL, NULL, NULL); if (uill == NULL) return (NULL); mutex_enter(&uill->ill_lock); for (ipif = uill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST)) continue; if (!(ipif->ipif_flags & IPIF_UP)) continue; if (ipif->ipif_zoneid != zoneid) continue; if ((isv6 && IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) || (ipif->ipif_lcl_addr == INADDR_ANY)) continue; mutex_exit(&uill->ill_lock); ill_refrele(uill); return (B_TRUE); } mutex_exit(&uill->ill_lock); ill_refrele(uill); } return (B_FALSE); } /* * Determine the best source address given a destination address and an ill. * Prefers non-deprecated over deprecated but will return a deprecated * address if there is no other choice. If there is a usable source address * on the interface pointed to by ill_usesrc_ifindex then that is given * first preference. * * Returns NULL if there is no suitable source address for the ill. * This only occurs when there is no valid source address for the ill. */ ipif_t * ipif_select_source(ill_t *ill, ipaddr_t dst, zoneid_t zoneid) { ipif_t *ipif; ipif_t *ipif_dep = NULL; /* Fallback to deprecated */ ipif_t *ipif_arr[MAX_IPIF_SELECT_SOURCE]; int index = 0; boolean_t wrapped = B_FALSE; boolean_t same_subnet_only = B_FALSE; boolean_t ipif_same_found, ipif_other_found; ill_t *till, *usill = NULL; if (ill->ill_usesrc_ifindex != 0) { usill = ill_lookup_on_ifindex(ill->ill_usesrc_ifindex, B_FALSE, NULL, NULL, NULL, NULL); if (usill != NULL) ill = usill; /* Select source from usesrc ILL */ else return (NULL); } /* * Holds the ill_g_lock as reader. This makes sure that no ipif/ill * can be deleted. But an ipif/ill can get CONDEMNED any time. * After selecting the right ipif, under ill_lock make sure ipif is * not condemned, and increment refcnt. If ipif is CONDEMNED, * we retry. Inside the loop we still need to check for CONDEMNED, * but not under a lock. */ rw_enter(&ill_g_lock, RW_READER); retry: till = ill; ipif_arr[0] = NULL; if (till->ill_group != NULL) till = till->ill_group->illgrp_ill; /* * Choose one good source address from each ill across the group. * If possible choose a source address in the same subnet as * the destination address. * * We don't check for PHYI_FAILED or PHYI_INACTIVE or PHYI_OFFLINE * This is okay because of the following. * * If PHYI_FAILED is set and we still have non-deprecated * addresses, it means the addresses have not yet been * failed over to a different interface. We potentially * select them to create IRE_CACHES, which will be later * flushed when the addresses move over. * * If PHYI_INACTIVE is set and we still have non-deprecated * addresses, it means either the user has configured them * or PHYI_INACTIVE has not been cleared after the addresses * been moved over. For the former, in.mpathd does a failover * when the interface becomes INACTIVE and hence we should * not find them. Once INACTIVE is set, we don't allow them * to create logical interfaces anymore. For the latter, a * flush will happen when INACTIVE is cleared which will * flush the IRE_CACHES. * * If PHYI_OFFLINE is set, all the addresses will be failed * over soon. We potentially select them to create IRE_CACHEs, * which will be later flushed when the addresses move over. * * NOTE : As ipif_select_source is called to borrow source address * for an ipif that is part of a group, source address selection * will be re-done whenever the group changes i.e either an * insertion/deletion in the group. * * Fill ipif_arr[] with source addresses, using these rules: * * 1. At most one source address from a given ill ends up * in ipif_arr[] -- that is, at most one of the ipif's * associated with a given ill ends up in ipif_arr[]. * * 2. If there is at least one non-deprecated ipif in the * IPMP group with a source address on the same subnet as * our destination, then fill ipif_arr[] only with * source addresses on the same subnet as our destination. * Note that because of (1), only the first * non-deprecated ipif found with a source address * matching the destination ends up in ipif_arr[]. * * 3. Otherwise, fill ipif_arr[] with non-deprecated source * addresses not in the same subnet as our destination. * Again, because of (1), only the first off-subnet source * address will be chosen. * * 4. If there are no non-deprecated ipifs, then just use * the source address associated with the last deprecated * one we find that happens to be on the same subnet, * otherwise the first one not in the same subnet. */ for (; till != NULL; till = till->ill_group_next) { ipif_same_found = B_FALSE; ipif_other_found = B_FALSE; for (ipif = till->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; /* Always skip NOLOCAL and ANYCAST interfaces */ if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST)) continue; if (!(ipif->ipif_flags & IPIF_UP)) continue; if (ipif->ipif_zoneid != zoneid) continue; /* * Interfaces with 0.0.0.0 address are allowed to be UP, * but are not valid as source addresses. */ if (ipif->ipif_lcl_addr == INADDR_ANY) continue; if (ipif->ipif_flags & IPIF_DEPRECATED) { if (ipif_dep == NULL || (ipif->ipif_net_mask & dst) == ipif->ipif_subnet) ipif_dep = ipif; continue; } if ((ipif->ipif_net_mask & dst) == ipif->ipif_subnet) { /* found a source address in the same subnet */ if (same_subnet_only == B_FALSE) { same_subnet_only = B_TRUE; index = 0; } ipif_same_found = B_TRUE; } else { if (same_subnet_only == B_TRUE || ipif_other_found == B_TRUE) continue; ipif_other_found = B_TRUE; } ipif_arr[index++] = ipif; if (index == MAX_IPIF_SELECT_SOURCE) { wrapped = B_TRUE; index = 0; } if (ipif_same_found == B_TRUE) break; } } if (ipif_arr[0] == NULL) { ipif = ipif_dep; } else { if (wrapped) index = MAX_IPIF_SELECT_SOURCE; ipif = ipif_arr[ipif_rand() % index]; ASSERT(ipif != NULL); } if (ipif != NULL) { mutex_enter(&ipif->ipif_ill->ill_lock); if (!IPIF_CAN_LOOKUP(ipif)) { mutex_exit(&ipif->ipif_ill->ill_lock); goto retry; } ipif_refhold_locked(ipif); mutex_exit(&ipif->ipif_ill->ill_lock); } rw_exit(&ill_g_lock); if (usill != NULL) ill_refrele(usill); #ifdef DEBUG if (ipif == NULL) { char buf1[INET6_ADDRSTRLEN]; ip1dbg(("ipif_select_source(%s, %s) -> NULL\n", ill->ill_name, inet_ntop(AF_INET, &dst, buf1, sizeof (buf1)))); } else { char buf1[INET6_ADDRSTRLEN]; char buf2[INET6_ADDRSTRLEN]; ip1dbg(("ipif_select_source(%s, %s) -> %s\n", ipif->ipif_ill->ill_name, inet_ntop(AF_INET, &dst, buf1, sizeof (buf1)), inet_ntop(AF_INET, &ipif->ipif_lcl_addr, buf2, sizeof (buf2)))); } #endif /* DEBUG */ return (ipif); } /* * If old_ipif is not NULL, see if ipif was derived from old * ipif and if so, recreate the interface route by re-doing * source address selection. This happens when ipif_down -> * ipif_update_other_ipifs calls us. * * If old_ipif is NULL, just redo the source address selection * if needed. This happens when illgrp_insert or ipif_up_done * calls us. */ static void ipif_recreate_interface_routes(ipif_t *old_ipif, ipif_t *ipif) { ire_t *ire; ire_t *ipif_ire; queue_t *stq; ipif_t *nipif; ill_t *ill; boolean_t need_rele = B_FALSE; ASSERT(old_ipif == NULL || IAM_WRITER_IPIF(old_ipif)); ASSERT(IAM_WRITER_IPIF(ipif)); ill = ipif->ipif_ill; if (!(ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST|IPIF_DEPRECATED))) { /* * Can't possibly have borrowed the source * from old_ipif. */ return; } /* * Is there any work to be done? No work if the address * is INADDR_ANY, loopback or NOLOCAL or ANYCAST ( * ipif_select_source() does not borrow addresses from * NOLOCAL and ANYCAST interfaces). */ if ((old_ipif != NULL) && ((old_ipif->ipif_lcl_addr == INADDR_ANY) || (old_ipif->ipif_ill->ill_wq == NULL) || (old_ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST)))) { return; } /* * Perform the same checks as when creating the * IRE_INTERFACE in ipif_up_done. */ if (!(ipif->ipif_flags & IPIF_UP)) return; if ((ipif->ipif_flags & IPIF_NOXMIT) || (ipif->ipif_subnet == INADDR_ANY)) return; ipif_ire = ipif_to_ire(ipif); if (ipif_ire == NULL) return; /* * We know that ipif uses some other source for its * IRE_INTERFACE. Is it using the source of this * old_ipif? */ if (old_ipif != NULL && old_ipif->ipif_lcl_addr != ipif_ire->ire_src_addr) { ire_refrele(ipif_ire); return; } if (ip_debug > 2) { /* ip1dbg */ pr_addr_dbg("ipif_recreate_interface_routes: deleting IRE for" " src %s\n", AF_INET, &ipif_ire->ire_src_addr); } stq = ipif_ire->ire_stq; /* * Can't use our source address. Select a different * source address for the IRE_INTERFACE. */ nipif = ipif_select_source(ill, ipif->ipif_subnet, ipif->ipif_zoneid); if (nipif == NULL) { /* Last resort - all ipif's have IPIF_NOLOCAL */ nipif = ipif; } else { need_rele = B_TRUE; } ire = ire_create( (uchar_t *)&ipif->ipif_subnet, /* dest pref */ (uchar_t *)&ipif->ipif_net_mask, /* mask */ (uchar_t *)&nipif->ipif_src_addr, /* src addr */ NULL, /* no gateway */ NULL, &ipif->ipif_mtu, /* max frag */ NULL, /* fast path header */ NULL, /* no recv from queue */ stq, /* send-to queue */ ill->ill_net_type, /* IF_[NO]RESOLVER */ ill->ill_resolver_mp, /* xmit header */ ipif, NULL, 0, 0, 0, 0, &ire_uinfo_null); if (ire != NULL) { ire_t *ret_ire; int error; /* * We don't need ipif_ire anymore. We need to delete * before we add so that ire_add does not detect * duplicates. */ ire_delete(ipif_ire); ret_ire = ire; error = ire_add(&ret_ire, NULL, NULL, NULL); ASSERT(error == 0); ASSERT(ire == ret_ire); /* Held in ire_add */ ire_refrele(ret_ire); } /* * Either we are falling through from above or could not * allocate a replacement. */ ire_refrele(ipif_ire); if (need_rele) ipif_refrele(nipif); } /* * This old_ipif is going away. * * Determine if any other ipif's is using our address as * ipif_lcl_addr (due to those being IPIF_NOLOCAL, IPIF_ANYCAST, or * IPIF_DEPRECATED). * Find the IRE_INTERFACE for such ipifs and recreate them * to use an different source address following the rules in * ipif_up_done. * * This function takes an illgrp as an argument so that illgrp_delete * can call this to update source address even after deleting the * old_ipif->ipif_ill from the ill group. */ static void ipif_update_other_ipifs(ipif_t *old_ipif, ill_group_t *illgrp) { ipif_t *ipif; ill_t *ill; char buf[INET6_ADDRSTRLEN]; ASSERT(IAM_WRITER_IPIF(old_ipif)); ASSERT(illgrp == NULL || IAM_WRITER_IPIF(old_ipif)); ill = old_ipif->ipif_ill; ip1dbg(("ipif_update_other_ipifs(%s, %s)\n", ill->ill_name, inet_ntop(AF_INET, &old_ipif->ipif_lcl_addr, buf, sizeof (buf)))); /* * If this part of a group, look at all ills as ipif_select_source * borrows source address across all the ills in the group. */ if (illgrp != NULL) ill = illgrp->illgrp_ill; for (; ill != NULL; ill = ill->ill_group_next) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif == old_ipif) continue; ipif_recreate_interface_routes(old_ipif, ipif); } } } /* ARGSUSED */ int if_unitsel_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { /* * ill_phyint_reinit merged the v4 and v6 into a single * ipsq. Could also have become part of a ipmp group in the * process, and we might not have been able to complete the * operation in ipif_set_values, if we could not become * exclusive. If so restart it here. */ return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q)); } /* ARGSUSED */ int if_unitsel(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { queue_t *q1 = q; char *cp; char interf_name[LIFNAMSIZ]; uint_t ppa = *(uint_t *)mp->b_cont->b_cont->b_rptr; if (!q->q_next) { ip1dbg(( "if_unitsel: IF_UNITSEL: no q_next\n")); return (EINVAL); } if (((ill_t *)(q->q_ptr))->ill_name[0] != '\0') return (EALREADY); do { q1 = q1->q_next; } while (q1->q_next); cp = q1->q_qinfo->qi_minfo->mi_idname; (void) sprintf(interf_name, "%s%d", cp, ppa); /* * Here we are not going to delay the ioack until after * ACKs from DL_ATTACH_REQ/DL_BIND_REQ. So no need to save the * original ioctl message before sending the requests. */ return (ipif_set_values(q, mp, interf_name, &ppa)); } /* ARGSUSED */ int ip_sioctl_sifname(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_ifreq) { return (ENXIO); } /* * Net and subnet broadcast ire's are now specific to the particular * physical interface (ill) and not to any one locigal interface (ipif). * However, if a particular logical interface is being taken down, it's * associated ire's will be taken down as well. Hence, when we go to * take down or change the local address, broadcast address or netmask * of a specific logical interface, we must check to make sure that we * have valid net and subnet broadcast ire's for the other logical * interfaces which may have been shared with the logical interface * being brought down or changed. * * There is one set of 0.0.0.0 and 255.255.255.255 per ill. Usually it * is tied to the first interface coming UP. If that ipif is going down, * we need to recreate them on the next valid ipif. * * Note: assume that the ipif passed in is still up so that it's IRE * entries are still valid. */ static void ipif_check_bcast_ires(ipif_t *test_ipif) { ipif_t *ipif; ire_t *test_subnet_ire, *test_net_ire; ire_t *test_allzero_ire, *test_allone_ire; ire_t *ire_array[12]; ire_t **irep = &ire_array[0]; ire_t **irep1; ipaddr_t net_addr, subnet_addr, net_mask, subnet_mask; ipaddr_t test_net_addr, test_subnet_addr; ipaddr_t test_net_mask, test_subnet_mask; boolean_t need_net_bcast_ire = B_FALSE; boolean_t need_subnet_bcast_ire = B_FALSE; boolean_t allzero_bcast_ire_created = B_FALSE; boolean_t allone_bcast_ire_created = B_FALSE; boolean_t net_bcast_ire_created = B_FALSE; boolean_t subnet_bcast_ire_created = B_FALSE; ipif_t *backup_ipif_net = (ipif_t *)NULL; ipif_t *backup_ipif_subnet = (ipif_t *)NULL; ipif_t *backup_ipif_allzeros = (ipif_t *)NULL; ipif_t *backup_ipif_allones = (ipif_t *)NULL; uint64_t check_flags = IPIF_DEPRECATED | IPIF_NOLOCAL | IPIF_ANYCAST; ASSERT(!test_ipif->ipif_isv6); ASSERT(IAM_WRITER_IPIF(test_ipif)); /* * No broadcast IREs for the LOOPBACK interface * or others such as point to point and IPIF_NOXMIT. */ if (!(test_ipif->ipif_flags & IPIF_BROADCAST) || (test_ipif->ipif_flags & IPIF_NOXMIT)) return; test_allzero_ire = ire_ctable_lookup(0, 0, IRE_BROADCAST, test_ipif, ALL_ZONES, (MATCH_IRE_TYPE | MATCH_IRE_IPIF)); test_allone_ire = ire_ctable_lookup(INADDR_BROADCAST, 0, IRE_BROADCAST, test_ipif, ALL_ZONES, (MATCH_IRE_TYPE | MATCH_IRE_IPIF)); test_net_mask = ip_net_mask(test_ipif->ipif_subnet); test_subnet_mask = test_ipif->ipif_net_mask; /* * If no net mask set, assume the default based on net class. */ if (test_subnet_mask == 0) test_subnet_mask = test_net_mask; /* * Check if there is a network broadcast ire associated with this ipif */ test_net_addr = test_net_mask & test_ipif->ipif_subnet; test_net_ire = ire_ctable_lookup(test_net_addr, 0, IRE_BROADCAST, test_ipif, ALL_ZONES, (MATCH_IRE_TYPE | MATCH_IRE_IPIF)); /* * Check if there is a subnet broadcast IRE associated with this ipif */ test_subnet_addr = test_subnet_mask & test_ipif->ipif_subnet; test_subnet_ire = ire_ctable_lookup(test_subnet_addr, 0, IRE_BROADCAST, test_ipif, ALL_ZONES, (MATCH_IRE_TYPE | MATCH_IRE_IPIF)); /* * No broadcast ire's associated with this ipif. */ if ((test_subnet_ire == NULL) && (test_net_ire == NULL) && (test_allzero_ire == NULL) && (test_allone_ire == NULL)) { return; } /* * We have established which bcast ires have to be replaced. * Next we try to locate ipifs that match there ires. * The rules are simple: If we find an ipif that matches on the subnet * address it will also match on the net address, the allzeros and * allones address. Any ipif that matches only on the net address will * also match the allzeros and allones addresses. * The other criterion is the ipif_flags. We look for non-deprecated * (and non-anycast and non-nolocal) ipifs as the best choice. * ipifs with check_flags matching (deprecated, etc) are used only * if good ipifs are not available. While looping, we save existing * deprecated ipifs as backup_ipif. * We loop through all the ipifs for this ill looking for ipifs * whose broadcast addr match the ipif passed in, but do not have * their own broadcast ires. For creating 0.0.0.0 and * 255.255.255.255 we just need an ipif on this ill to create. */ for (ipif = test_ipif->ipif_ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { ASSERT(!ipif->ipif_isv6); /* * Already checked the ipif passed in. */ if (ipif == test_ipif) { continue; } /* * We only need to recreate broadcast ires if another ipif in * the same zone uses them. The new ires must be created in the * same zone. */ if (ipif->ipif_zoneid != test_ipif->ipif_zoneid) { continue; } /* * Only interested in logical interfaces with valid local * addresses or with the ability to broadcast. */ if ((ipif->ipif_subnet == 0) || !(ipif->ipif_flags & IPIF_BROADCAST) || (ipif->ipif_flags & IPIF_NOXMIT) || !(ipif->ipif_flags & IPIF_UP)) { continue; } /* * Check if there is a net broadcast ire for this * net address. If it turns out that the ipif we are * about to take down owns this ire, we must make a * new one because it is potentially going away. */ if (test_net_ire && (!net_bcast_ire_created)) { net_mask = ip_net_mask(ipif->ipif_subnet); net_addr = net_mask & ipif->ipif_subnet; if (net_addr == test_net_addr) { need_net_bcast_ire = B_TRUE; /* * Use DEPRECATED ipif only if no good * ires are available. subnet_addr is * a better match than net_addr. */ if ((ipif->ipif_flags & check_flags) && (backup_ipif_net == NULL)) { backup_ipif_net = ipif; } } } /* * Check if there is a subnet broadcast ire for this * net address. If it turns out that the ipif we are * about to take down owns this ire, we must make a * new one because it is potentially going away. */ if (test_subnet_ire && (!subnet_bcast_ire_created)) { subnet_mask = ipif->ipif_net_mask; subnet_addr = ipif->ipif_subnet; if (subnet_addr == test_subnet_addr) { need_subnet_bcast_ire = B_TRUE; if ((ipif->ipif_flags & check_flags) && (backup_ipif_subnet == NULL)) { backup_ipif_subnet = ipif; } } } /* Short circuit here if this ipif is deprecated */ if (ipif->ipif_flags & check_flags) { if ((test_allzero_ire != NULL) && (!allzero_bcast_ire_created) && (backup_ipif_allzeros == NULL)) { backup_ipif_allzeros = ipif; } if ((test_allone_ire != NULL) && (!allone_bcast_ire_created) && (backup_ipif_allones == NULL)) { backup_ipif_allones = ipif; } continue; } /* * Found an ipif which has the same broadcast ire as the * ipif passed in and the ipif passed in "owns" the ire. * Create new broadcast ire's for this broadcast addr. */ if (need_net_bcast_ire && !net_bcast_ire_created) { irep = ire_create_bcast(ipif, net_addr, irep); irep = ire_create_bcast(ipif, ~net_mask | net_addr, irep); net_bcast_ire_created = B_TRUE; } if (need_subnet_bcast_ire && !subnet_bcast_ire_created) { irep = ire_create_bcast(ipif, subnet_addr, irep); irep = ire_create_bcast(ipif, ~subnet_mask | subnet_addr, irep); subnet_bcast_ire_created = B_TRUE; } if (test_allzero_ire != NULL && !allzero_bcast_ire_created) { irep = ire_create_bcast(ipif, 0, irep); allzero_bcast_ire_created = B_TRUE; } if (test_allone_ire != NULL && !allone_bcast_ire_created) { irep = ire_create_bcast(ipif, INADDR_BROADCAST, irep); allone_bcast_ire_created = B_TRUE; } /* * Once we have created all the appropriate ires, we * just break out of this loop to add what we have created. * This has been indented similar to ire_match_args for * readability. */ if (((test_net_ire == NULL) || (net_bcast_ire_created)) && ((test_subnet_ire == NULL) || (subnet_bcast_ire_created)) && ((test_allzero_ire == NULL) || (allzero_bcast_ire_created)) && ((test_allone_ire == NULL) || (allone_bcast_ire_created))) { break; } } /* * Create bcast ires on deprecated ipifs if no non-deprecated ipifs * exist. 6 pairs of bcast ires are needed. * Note - the old ires are deleted in ipif_down. */ if (need_net_bcast_ire && !net_bcast_ire_created && backup_ipif_net) { ipif = backup_ipif_net; irep = ire_create_bcast(ipif, net_addr, irep); irep = ire_create_bcast(ipif, ~net_mask | net_addr, irep); net_bcast_ire_created = B_TRUE; } if (need_subnet_bcast_ire && !subnet_bcast_ire_created && backup_ipif_subnet) { ipif = backup_ipif_subnet; irep = ire_create_bcast(ipif, subnet_addr, irep); irep = ire_create_bcast(ipif, ~subnet_mask | subnet_addr, irep); subnet_bcast_ire_created = B_TRUE; } if (test_allzero_ire != NULL && !allzero_bcast_ire_created && backup_ipif_allzeros) { irep = ire_create_bcast(backup_ipif_allzeros, 0, irep); allzero_bcast_ire_created = B_TRUE; } if (test_allone_ire != NULL && !allone_bcast_ire_created && backup_ipif_allones) { irep = ire_create_bcast(backup_ipif_allones, INADDR_BROADCAST, irep); allone_bcast_ire_created = B_TRUE; } /* * If we can't create all of them, don't add any of them. * Code in ip_wput_ire and ire_to_ill assumes that we * always have a non-loopback copy and loopback copy * for a given address. */ for (irep1 = irep; irep1 > ire_array; ) { irep1--; if (*irep1 == NULL) { ip0dbg(("ipif_check_bcast_ires: can't create " "IRE_BROADCAST, memory allocation failure\n")); while (irep > ire_array) { irep--; if (*irep != NULL) ire_delete(*irep); } goto bad; } } for (irep1 = irep; irep1 > ire_array; ) { int error; irep1--; error = ire_add(irep1, NULL, NULL, NULL); if (error == 0) { ire_refrele(*irep1); /* Held in ire_add */ } } bad: if (test_allzero_ire != NULL) ire_refrele(test_allzero_ire); if (test_allone_ire != NULL) ire_refrele(test_allone_ire); if (test_net_ire != NULL) ire_refrele(test_net_ire); if (test_subnet_ire != NULL) ire_refrele(test_subnet_ire); } /* * Extract both the flags (including IFF_CANTCHANGE) such as IFF_IPV* * from lifr_flags and the name from lifr_name. * Set IFF_IPV* and ill_isv6 prior to doing the lookup * since ipif_lookup_on_name uses the _isv6 flags when matching. * Returns EINPROGRESS when mp has been consumed by queueing it on * ill_pending_mp and the ioctl will complete in ip_rput. */ /* ARGSUSED */ int ip_sioctl_slifname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { int err; ill_t *ill; struct lifreq *lifr = (struct lifreq *)if_req; ASSERT(ipif != NULL); ip1dbg(("ip_sioctl_slifname %s\n", lifr->lifr_name)); ASSERT(q->q_next != NULL); ill = (ill_t *)q->q_ptr; /* * If we are not writer on 'q' then this interface exists already * and previous lookups (ipif_extract_lifreq_cmn) found this ipif. * So return EALREADY */ if (ill != ipif->ipif_ill) return (EALREADY); if (ill->ill_name[0] != '\0') return (EALREADY); /* * Set all the flags. Allows all kinds of override. Provide some * sanity checking by not allowing IFF_BROADCAST and IFF_MULTICAST * unless there is either multicast/broadcast support in the driver * or it is a pt-pt link. */ if (lifr->lifr_flags & (IFF_PROMISC|IFF_ALLMULTI)) { /* Meaningless to IP thus don't allow them to be set. */ ip1dbg(("ip_setname: EINVAL 1\n")); return (EINVAL); } /* * For a DL_STYLE2 driver (ill_needs_attach), we would not have the * ill_bcast_addr_length info. */ if (!ill->ill_needs_attach && ((lifr->lifr_flags & IFF_MULTICAST) && !(lifr->lifr_flags & IFF_POINTOPOINT) && ill->ill_bcast_addr_length == 0)) { /* Link not broadcast/pt-pt capable i.e. no multicast */ ip1dbg(("ip_setname: EINVAL 2\n")); return (EINVAL); } if ((lifr->lifr_flags & IFF_BROADCAST) && ((lifr->lifr_flags & IFF_IPV6) || (!ill->ill_needs_attach && ill->ill_bcast_addr_length == 0))) { /* Link not broadcast capable or IPv6 i.e. no broadcast */ ip1dbg(("ip_setname: EINVAL 3\n")); return (EINVAL); } if (lifr->lifr_flags & IFF_UP) { /* Can only be set with SIOCSLIFFLAGS */ ip1dbg(("ip_setname: EINVAL 4\n")); return (EINVAL); } if ((lifr->lifr_flags & (IFF_IPV6|IFF_IPV4)) != IFF_IPV6 && (lifr->lifr_flags & (IFF_IPV6|IFF_IPV4)) != IFF_IPV4) { ip1dbg(("ip_setname: EINVAL 5\n")); return (EINVAL); } /* * Only allow the IFF_XRESOLV flag to be set on IPv6 interfaces. */ if ((lifr->lifr_flags & IFF_XRESOLV) && !(lifr->lifr_flags & IFF_IPV6) && !(ipif->ipif_isv6)) { ip1dbg(("ip_setname: EINVAL 6\n")); return (EINVAL); } /* * The user has done SIOCGLIFFLAGS prior to this ioctl and hence * we have all the flags here. So, we assign rather than we OR. * We can't OR the flags here because we don't want to set * both IFF_IPV4 and IFF_IPV6. We start off as IFF_IPV4 in * ipif_allocate and become IFF_IPV4 or IFF_IPV6 here depending * on lifr_flags value here. */ /* * This ill has not been inserted into the global list. * So we are still single threaded and don't need any lock */ ipif->ipif_flags = lifr->lifr_flags & IFF_LOGINT_FLAGS; ill->ill_flags = lifr->lifr_flags & IFF_PHYINTINST_FLAGS; ill->ill_phyint->phyint_flags = lifr->lifr_flags & IFF_PHYINT_FLAGS; /* We started off as V4. */ if (ill->ill_flags & ILLF_IPV6) { ill->ill_phyint->phyint_illv6 = ill; ill->ill_phyint->phyint_illv4 = NULL; } err = ipif_set_values(q, mp, lifr->lifr_name, &lifr->lifr_ppa); return (err); } /* ARGSUSED */ int ip_sioctl_slifname_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { /* * ill_phyint_reinit merged the v4 and v6 into a single * ipsq. Could also have become part of a ipmp group in the * process, and we might not have been able to complete the * slifname in ipif_set_values, if we could not become * exclusive. If so restart it here */ return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q)); } /* * Return a pointer to the ipif which matches the index, IP version type and * zoneid. */ ipif_t * ipif_lookup_on_ifindex(uint_t index, boolean_t isv6, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *err) { ill_t *ill; ipsq_t *ipsq; phyint_t *phyi; ipif_t *ipif; ASSERT((q == NULL && mp == NULL && func == NULL && err == NULL) || (q != NULL && mp != NULL && func != NULL && err != NULL)); if (err != NULL) *err = 0; /* * Indexes are stored in the phyint - a common structure * to both IPv4 and IPv6. */ rw_enter(&ill_g_lock, RW_READER); phyi = avl_find(&phyint_g_list.phyint_list_avl_by_index, (void *) &index, NULL); if (phyi != NULL) { ill = isv6 ? phyi->phyint_illv6 : phyi->phyint_illv4; if (ill == NULL) { rw_exit(&ill_g_lock); if (err != NULL) *err = ENXIO; return (NULL); } GRAB_CONN_LOCK(q); mutex_enter(&ill->ill_lock); if (ILL_CAN_LOOKUP(ill)) { for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (IPIF_CAN_LOOKUP(ipif) && (zoneid == ALL_ZONES || zoneid == ipif->ipif_zoneid)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); rw_exit(&ill_g_lock); return (ipif); } } } else if (ILL_CAN_WAIT(ill, q)) { ipsq = ill->ill_phyint->phyint_ipsq; mutex_enter(&ipsq->ipsq_lock); rw_exit(&ill_g_lock); mutex_exit(&ill->ill_lock); ipsq_enq(ipsq, q, mp, func, NEW_OP, ill); mutex_exit(&ipsq->ipsq_lock); RELEASE_CONN_LOCK(q); *err = EINPROGRESS; return (NULL); } mutex_exit(&ill->ill_lock); RELEASE_CONN_LOCK(q); } rw_exit(&ill_g_lock); if (err != NULL) *err = ENXIO; return (NULL); } typedef struct conn_change_s { uint_t cc_old_ifindex; uint_t cc_new_ifindex; } conn_change_t; /* * ipcl_walk function for changing interface index. */ static void conn_change_ifindex(conn_t *connp, caddr_t arg) { conn_change_t *connc; uint_t old_ifindex; uint_t new_ifindex; int i; ilg_t *ilg; connc = (conn_change_t *)arg; old_ifindex = connc->cc_old_ifindex; new_ifindex = connc->cc_new_ifindex; if (connp->conn_orig_bound_ifindex == old_ifindex) connp->conn_orig_bound_ifindex = new_ifindex; if (connp->conn_orig_multicast_ifindex == old_ifindex) connp->conn_orig_multicast_ifindex = new_ifindex; if (connp->conn_orig_xmit_ifindex == old_ifindex) connp->conn_orig_xmit_ifindex = new_ifindex; for (i = connp->conn_ilg_inuse - 1; i >= 0; i--) { ilg = &connp->conn_ilg[i]; if (ilg->ilg_orig_ifindex == old_ifindex) ilg->ilg_orig_ifindex = new_ifindex; } } /* * Walk all the ipifs and ilms on this ill and change the orig_ifindex * to new_index if it matches the old_index. * * Failovers typically happen within a group of ills. But somebody * can remove an ill from the group after a failover happened. If * we are setting the ifindex after this, we potentially need to * look at all the ills rather than just the ones in the group. * We cut down the work by looking at matching ill_net_types * and ill_types as we could not possibly grouped them together. */ static void ip_change_ifindex(ill_t *ill_orig, conn_change_t *connc) { ill_t *ill; ipif_t *ipif; uint_t old_ifindex; uint_t new_ifindex; ilm_t *ilm; ill_walk_context_t ctx; old_ifindex = connc->cc_old_ifindex; new_ifindex = connc->cc_new_ifindex; rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_ALL(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { if ((ill_orig->ill_net_type != ill->ill_net_type) || (ill_orig->ill_type != ill->ill_type)) { continue; } for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (ipif->ipif_orig_ifindex == old_ifindex) ipif->ipif_orig_ifindex = new_ifindex; } for (ilm = ill->ill_ilm; ilm != NULL; ilm = ilm->ilm_next) { if (ilm->ilm_orig_ifindex == old_ifindex) ilm->ilm_orig_ifindex = new_ifindex; } } rw_exit(&ill_g_lock); } /* * We first need to ensure that the new index is unique, and * then carry the change across both v4 and v6 ill representation * of the physical interface. */ /* ARGSUSED */ int ip_sioctl_slifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { ill_t *ill; ill_t *ill_other; phyint_t *phyi; int old_index; conn_change_t connc; struct ifreq *ifr = (struct ifreq *)ifreq; struct lifreq *lifr = (struct lifreq *)ifreq; uint_t index; ill_t *ill_v4; ill_t *ill_v6; if (ipip->ipi_cmd_type == IF_CMD) index = ifr->ifr_index; else index = lifr->lifr_index; /* * Only allow on physical interface. Also, index zero is illegal. * * Need to check for PHYI_FAILED and PHYI_INACTIVE * * 1) If PHYI_FAILED is set, a failover could have happened which * implies a possible failback might have to happen. As failback * depends on the old index, we should fail setting the index. * * 2) If PHYI_INACTIVE is set, in.mpathd does a failover so that * any addresses or multicast memberships are failed over to * a non-STANDBY interface. As failback depends on the old * index, we should fail setting the index for this case also. * * 3) If PHYI_OFFLINE is set, a possible failover has happened. * Be consistent with PHYI_FAILED and fail the ioctl. */ ill = ipif->ipif_ill; phyi = ill->ill_phyint; if ((phyi->phyint_flags & (PHYI_FAILED|PHYI_INACTIVE|PHYI_OFFLINE)) || ipif->ipif_id != 0 || index == 0) { return (EINVAL); } old_index = phyi->phyint_ifindex; /* If the index is not changing, no work to do */ if (old_index == index) return (0); /* * Use ill_lookup_on_ifindex to determine if the * new index is unused and if so allow the change. */ ill_v6 = ill_lookup_on_ifindex(index, B_TRUE, NULL, NULL, NULL, NULL); ill_v4 = ill_lookup_on_ifindex(index, B_FALSE, NULL, NULL, NULL, NULL); if (ill_v6 != NULL || ill_v4 != NULL) { if (ill_v4 != NULL) ill_refrele(ill_v4); if (ill_v6 != NULL) ill_refrele(ill_v6); return (EBUSY); } /* * The new index is unused. Set it in the phyint. * Locate the other ill so that we can send a routing * sockets message. */ if (ill->ill_isv6) { ill_other = phyi->phyint_illv4; } else { ill_other = phyi->phyint_illv6; } phyi->phyint_ifindex = index; connc.cc_old_ifindex = old_index; connc.cc_new_ifindex = index; ip_change_ifindex(ill, &connc); ipcl_walk(conn_change_ifindex, (caddr_t)&connc); /* Send the routing sockets message */ ip_rts_ifmsg(ipif); if (ill_other != NULL) ip_rts_ifmsg(ill_other->ill_ipif); return (0); } /* ARGSUSED */ int ip_sioctl_get_lifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct ifreq *ifr = (struct ifreq *)ifreq; struct lifreq *lifr = (struct lifreq *)ifreq; ip1dbg(("ip_sioctl_get_lifindex(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* Get the interface index */ if (ipip->ipi_cmd_type == IF_CMD) { ifr->ifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex; } else { lifr->lifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex; } return (0); } /* ARGSUSED */ int ip_sioctl_get_lifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifreq *lifr = (struct lifreq *)ifreq; ip1dbg(("ip_sioctl_get_lifzone(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* Get the interface zone */ ASSERT(ipip->ipi_cmd_type == LIF_CMD); lifr->lifr_zoneid = ipif->ipif_zoneid; return (0); } /* * Set the zoneid of an interface. */ /* ARGSUSED */ int ip_sioctl_slifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifreq *lifr = (struct lifreq *)ifreq; int err = 0; boolean_t need_up = B_FALSE; zone_t *zptr; zone_status_t status; zoneid_t zoneid; /* cannot assign instance zero to a non-global zone */ if (ipif->ipif_id == 0) return (ENOTSUP); ASSERT(ipip->ipi_cmd_type == LIF_CMD); zoneid = lifr->lifr_zoneid; /* * Cannot assign to a zone that doesn't exist or is shutting down. In * the event of a race with the zone shutdown processing, since IP * serializes this ioctl and SIOCGLIFCONF/SIOCLIFREMOVEIF, we know the * interface will be cleaned up even if the zone is shut down * immediately after the status check. If the interface can't be brought * down right away, and the zone is shut down before the restart * function is called, we resolve the possible races by rechecking the * zone status in the restart function. */ if ((zptr = zone_find_by_id(zoneid)) == NULL) return (EINVAL); status = zone_status_get(zptr); zone_rele(zptr); if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING) return (EINVAL); if (ipif->ipif_flags & IPIF_UP) { /* * If the interface is already marked up, * we call ipif_down which will take care * of ditching any IREs that have been set * up based on the old interface address. */ err = ipif_logical_down(ipif, q, mp); if (err == EINPROGRESS) return (err); ipif_down_tail(ipif); need_up = B_TRUE; } err = ip_sioctl_slifzone_tail(ipif, zoneid, q, mp, need_up); return (err); } static int ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid, queue_t *q, mblk_t *mp, boolean_t need_up) { int err = 0; ip1dbg(("ip_sioctl_zoneid_tail(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* Set the new zone id. */ ipif->ipif_zoneid = zoneid; /* Update sctp list */ sctp_update_ipif(ipif, SCTP_IPIF_UPDATE); if (need_up) { /* * Now bring the interface back up. If this * is the only IPIF for the ILL, ipif_up * will have to re-bind to the device, so * we may get back EINPROGRESS, in which * case, this IOCTL will get completed in * ip_rput_dlpi when we see the DL_BIND_ACK. */ err = ipif_up(ipif, q, mp); } return (err); } /* ARGSUSED */ int ip_sioctl_slifzone_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *if_req) { struct lifreq *lifr = (struct lifreq *)if_req; zoneid_t zoneid; zone_t *zptr; zone_status_t status; ASSERT(ipif->ipif_id != 0); ASSERT(ipip->ipi_cmd_type == LIF_CMD); zoneid = lifr->lifr_zoneid; ip1dbg(("ip_sioctl_slifzone_restart(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); /* * We recheck the zone status to resolve the following race condition: * 1) process sends SIOCSLIFZONE to put hme0:1 in zone "myzone"; * 2) hme0:1 is up and can't be brought down right away; * ip_sioctl_slifzone() returns EINPROGRESS and the request is queued; * 3) zone "myzone" is halted; the zone status switches to * 'shutting_down' and the zones framework sends SIOCGLIFCONF to list * the interfaces to remove - hme0:1 is not returned because it's not * yet in "myzone", so it won't be removed; * 4) the restart function for SIOCSLIFZONE is called; without the * status check here, we would have hme0:1 in "myzone" after it's been * destroyed. * Note that if the status check fails, we need to bring the interface * back to its state prior to ip_sioctl_slifzone(), hence the call to * ipif_up_done[_v6](). */ status = ZONE_IS_UNINITIALIZED; if ((zptr = zone_find_by_id(zoneid)) != NULL) { status = zone_status_get(zptr); zone_rele(zptr); } if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING) { if (ipif->ipif_isv6) { (void) ipif_up_done_v6(ipif); } else { (void) ipif_up_done(ipif); } return (EINVAL); } ipif_down_tail(ipif); return (ip_sioctl_slifzone_tail(ipif, zoneid, q, mp, B_TRUE)); } /* ARGSUSED */ int ip_sioctl_get_lifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifreq *lifr = ifreq; ASSERT(q->q_next == NULL); ASSERT(CONN_Q(q)); ip1dbg(("ip_sioctl_get_lifusesrc(%s:%u %p)\n", ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif)); lifr->lifr_index = ipif->ipif_ill->ill_usesrc_ifindex; ip1dbg(("ip_sioctl_get_lifusesrc:lifr_index = %d\n", lifr->lifr_index)); return (0); } /* Find the previous ILL in this usesrc group */ static ill_t * ill_prev_usesrc(ill_t *uill) { ill_t *ill; for (ill = uill->ill_usesrc_grp_next; ASSERT(ill), ill->ill_usesrc_grp_next != uill; ill = ill->ill_usesrc_grp_next) /* do nothing */; return (ill); } /* * Release all members of the usesrc group. This routine is called * from ill_delete when the interface being unplumbed is the * group head. */ static void ill_disband_usesrc_group(ill_t *uill) { ill_t *next_ill, *tmp_ill; ASSERT(RW_WRITE_HELD(&ill_g_usesrc_lock)); next_ill = uill->ill_usesrc_grp_next; do { ASSERT(next_ill != NULL); tmp_ill = next_ill->ill_usesrc_grp_next; ASSERT(tmp_ill != NULL); next_ill->ill_usesrc_grp_next = NULL; next_ill->ill_usesrc_ifindex = 0; next_ill = tmp_ill; } while (next_ill->ill_usesrc_ifindex != 0); uill->ill_usesrc_grp_next = NULL; } /* * Remove the client usesrc ILL from the list and relink to a new list */ int ill_relink_usesrc_ills(ill_t *ucill, ill_t *uill, uint_t ifindex) { ill_t *ill, *tmp_ill; ASSERT((ucill != NULL) && (ucill->ill_usesrc_grp_next != NULL) && (uill != NULL) && RW_WRITE_HELD(&ill_g_usesrc_lock)); /* * Check if the usesrc client ILL passed in is not already * in use as a usesrc ILL i.e one whose source address is * in use OR a usesrc ILL is not already in use as a usesrc * client ILL */ if ((ucill->ill_usesrc_ifindex == 0) || (uill->ill_usesrc_ifindex != 0)) { return (-1); } ill = ill_prev_usesrc(ucill); ASSERT(ill->ill_usesrc_grp_next != NULL); /* Remove from the current list */ if (ill->ill_usesrc_grp_next->ill_usesrc_grp_next == ill) { /* Only two elements in the list */ ASSERT(ill->ill_usesrc_ifindex == 0); ill->ill_usesrc_grp_next = NULL; } else { ill->ill_usesrc_grp_next = ucill->ill_usesrc_grp_next; } if (ifindex == 0) { ucill->ill_usesrc_ifindex = 0; ucill->ill_usesrc_grp_next = NULL; return (0); } ucill->ill_usesrc_ifindex = ifindex; tmp_ill = uill->ill_usesrc_grp_next; uill->ill_usesrc_grp_next = ucill; ucill->ill_usesrc_grp_next = (tmp_ill != NULL) ? tmp_ill : uill; return (0); } /* * Set the ill_usesrc and ill_usesrc_head fields. See synchronization notes in * ip.c for locking details. */ /* ARGSUSED */ int ip_sioctl_slifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq) { struct lifreq *lifr = (struct lifreq *)ifreq; boolean_t isv6 = B_FALSE, reset_flg = B_FALSE, ill_flag_changed = B_FALSE; ill_t *usesrc_ill, *usesrc_cli_ill = ipif->ipif_ill; int err = 0, ret; uint_t ifindex; phyint_t *us_phyint, *us_cli_phyint; ipsq_t *ipsq = NULL; ASSERT(IAM_WRITER_IPIF(ipif)); ASSERT(q->q_next == NULL); ASSERT(CONN_Q(q)); isv6 = (Q_TO_CONN(q))->conn_af_isv6; us_cli_phyint = usesrc_cli_ill->ill_phyint; ASSERT(us_cli_phyint != NULL); /* * If the client ILL is being used for IPMP, abort. * Note, this can be done before ipsq_try_enter since we are already * exclusive on this ILL */ if ((us_cli_phyint->phyint_groupname != NULL) || (us_cli_phyint->phyint_flags & PHYI_STANDBY)) { return (EINVAL); } ifindex = lifr->lifr_index; if (ifindex == 0) { if (usesrc_cli_ill->ill_usesrc_grp_next == NULL) { /* non usesrc group interface, nothing to reset */ return (0); } ifindex = usesrc_cli_ill->ill_usesrc_ifindex; /* valid reset request */ reset_flg = B_TRUE; } usesrc_ill = ill_lookup_on_ifindex(ifindex, isv6, q, mp, ip_process_ioctl, &err); if (usesrc_ill == NULL) { return (err); } /* * The usesrc_cli_ill or the usesrc_ill cannot be part of an IPMP * group nor can either of the interfaces be used for standy. So * to guarantee mutual exclusion with ip_sioctl_flags (which sets * PHYI_STANDBY) and ip_sioctl_groupname (which sets the groupname) * we need to be exclusive on the ipsq belonging to the usesrc_ill. * We are already exlusive on this ipsq i.e ipsq corresponding to * the usesrc_cli_ill */ ipsq = ipsq_try_enter(NULL, usesrc_ill, q, mp, ip_process_ioctl, NEW_OP, B_TRUE); if (ipsq == NULL) { err = EINPROGRESS; /* Operation enqueued on the ipsq of the usesrc ILL */ goto done; } /* Check if the usesrc_ill is used for IPMP */ us_phyint = usesrc_ill->ill_phyint; if ((us_phyint->phyint_groupname != NULL) || (us_phyint->phyint_flags & PHYI_STANDBY)) { err = EINVAL; goto done; } /* * If the client is already in use as a usesrc_ill or a usesrc_ill is * already a client then return EINVAL */ if (IS_USESRC_ILL(usesrc_cli_ill) || IS_USESRC_CLI_ILL(usesrc_ill)) { err = EINVAL; goto done; } /* * If the ill_usesrc_ifindex field is already set to what it needs to * be then this is a duplicate operation. */ if (!reset_flg && usesrc_cli_ill->ill_usesrc_ifindex == ifindex) { err = 0; goto done; } ip1dbg(("ip_sioctl_slifusesrc: usesrc_cli_ill %s, usesrc_ill %s," " v6 = %d", usesrc_cli_ill->ill_name, usesrc_ill->ill_name, usesrc_ill->ill_isv6)); /* * The next step ensures that no new ires will be created referencing * the client ill, until the ILL_CHANGING flag is cleared. Then * we go through an ire walk deleting all ire caches that reference * the client ill. New ires referencing the client ill that are added * to the ire table before the ILL_CHANGING flag is set, will be * cleaned up by the ire walk below. Attempt to add new ires referencing * the client ill while the ILL_CHANGING flag is set will be failed * during the ire_add in ire_atomic_start. ire_atomic_start atomically * checks (under the ill_g_usesrc_lock) that the ire being added * is not stale, i.e the ire_stq and ire_ipif are consistent and * belong to the same usesrc group. */ mutex_enter(&usesrc_cli_ill->ill_lock); usesrc_cli_ill->ill_state_flags |= ILL_CHANGING; mutex_exit(&usesrc_cli_ill->ill_lock); ill_flag_changed = B_TRUE; if (ipif->ipif_isv6) ire_walk_v6(ipif_delete_cache_ire, (char *)usesrc_cli_ill, ALL_ZONES); else ire_walk_v4(ipif_delete_cache_ire, (char *)usesrc_cli_ill, ALL_ZONES); /* * ill_g_usesrc_lock global lock protects the ill_usesrc_grp_next * and the ill_usesrc_ifindex fields */ rw_enter(&ill_g_usesrc_lock, RW_WRITER); if (reset_flg) { ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill, 0); if (ret != 0) { err = EINVAL; } rw_exit(&ill_g_usesrc_lock); goto done; } /* * Four possibilities to consider: * 1. Both usesrc_ill and usesrc_cli_ill are not part of any usesrc grp * 2. usesrc_ill is part of a group but usesrc_cli_ill isn't * 3. usesrc_cli_ill is part of a group but usesrc_ill isn't * 4. Both are part of their respective usesrc groups */ if ((usesrc_ill->ill_usesrc_grp_next == NULL) && (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) { ASSERT(usesrc_ill->ill_usesrc_ifindex == 0); usesrc_cli_ill->ill_usesrc_ifindex = ifindex; usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill; usesrc_cli_ill->ill_usesrc_grp_next = usesrc_ill; } else if ((usesrc_ill->ill_usesrc_grp_next != NULL) && (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) { usesrc_cli_ill->ill_usesrc_ifindex = ifindex; /* Insert at head of list */ usesrc_cli_ill->ill_usesrc_grp_next = usesrc_ill->ill_usesrc_grp_next; usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill; } else { ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill, ifindex); if (ret != 0) err = EINVAL; } rw_exit(&ill_g_usesrc_lock); done: if (ill_flag_changed) { mutex_enter(&usesrc_cli_ill->ill_lock); usesrc_cli_ill->ill_state_flags &= ~ILL_CHANGING; mutex_exit(&usesrc_cli_ill->ill_lock); } if (ipsq != NULL) ipsq_exit(ipsq, B_TRUE, B_TRUE); /* The refrele on the lifr_name ipif is done by ip_process_ioctl */ ill_refrele(usesrc_ill); return (err); } /* * comparison function used by avl. */ static int ill_phyint_compare_index(const void *index_ptr, const void *phyip) { uint_t index; ASSERT(phyip != NULL && index_ptr != NULL); index = *((uint_t *)index_ptr); /* * let the phyint with the lowest index be on top. */ if (((phyint_t *)phyip)->phyint_ifindex < index) return (1); if (((phyint_t *)phyip)->phyint_ifindex > index) return (-1); return (0); } /* * comparison function used by avl. */ static int ill_phyint_compare_name(const void *name_ptr, const void *phyip) { ill_t *ill; int res = 0; ASSERT(phyip != NULL && name_ptr != NULL); if (((phyint_t *)phyip)->phyint_illv4) ill = ((phyint_t *)phyip)->phyint_illv4; else ill = ((phyint_t *)phyip)->phyint_illv6; ASSERT(ill != NULL); res = strcmp(ill->ill_name, (char *)name_ptr); if (res > 0) return (1); else if (res < 0) return (-1); return (0); } /* * This function is called from ill_delete when the ill is being * unplumbed. We remove the reference from the phyint and we also * free the phyint when there are no more references to it. */ static void ill_phyint_free(ill_t *ill) { phyint_t *phyi; phyint_t *next_phyint; ipsq_t *cur_ipsq; ASSERT(ill->ill_phyint != NULL); ASSERT(RW_WRITE_HELD(&ill_g_lock)); phyi = ill->ill_phyint; ill->ill_phyint = NULL; /* * ill_init allocates a phyint always to store the copy * of flags relevant to phyint. At that point in time, we could * not assign the name and hence phyint_illv4/v6 could not be * initialized. Later in ipif_set_values, we assign the name to * the ill, at which point in time we assign phyint_illv4/v6. * Thus we don't rely on phyint_illv6 to be initialized always. */ if (ill->ill_flags & ILLF_IPV6) { phyi->phyint_illv6 = NULL; } else { phyi->phyint_illv4 = NULL; } /* * ipif_down removes it from the group when the last ipif goes * down. */ ASSERT(ill->ill_group == NULL); if (phyi->phyint_illv4 != NULL || phyi->phyint_illv6 != NULL) return; /* * Make sure this phyint was put in the list. */ if (phyi->phyint_ifindex > 0) { avl_remove(&phyint_g_list.phyint_list_avl_by_index, phyi); avl_remove(&phyint_g_list.phyint_list_avl_by_name, phyi); } /* * remove phyint from the ipsq list. */ cur_ipsq = phyi->phyint_ipsq; if (phyi == cur_ipsq->ipsq_phyint_list) { cur_ipsq->ipsq_phyint_list = phyi->phyint_ipsq_next; } else { next_phyint = cur_ipsq->ipsq_phyint_list; while (next_phyint != NULL) { if (next_phyint->phyint_ipsq_next == phyi) { next_phyint->phyint_ipsq_next = phyi->phyint_ipsq_next; break; } next_phyint = next_phyint->phyint_ipsq_next; } ASSERT(next_phyint != NULL); } IPSQ_DEC_REF(cur_ipsq); if (phyi->phyint_groupname_len != 0) { ASSERT(phyi->phyint_groupname != NULL); mi_free(phyi->phyint_groupname); } mi_free(phyi); } /* * Attach the ill to the phyint structure which can be shared by both * IPv4 and IPv6 ill. ill_init allocates a phyint to just hold flags. This * function is called from ipif_set_values and ill_lookup_on_name (for * loopback) where we know the name of the ill. We lookup the ill and if * there is one present already with the name use that phyint. Otherwise * reuse the one allocated by ill_init. */ static void ill_phyint_reinit(ill_t *ill) { boolean_t isv6 = ill->ill_isv6; phyint_t *phyi_old; phyint_t *phyi; avl_index_t where = 0; ill_t *ill_other = NULL; ipsq_t *ipsq; ASSERT(RW_WRITE_HELD(&ill_g_lock)); phyi_old = ill->ill_phyint; ASSERT(isv6 || (phyi_old->phyint_illv4 == ill && phyi_old->phyint_illv6 == NULL)); ASSERT(!isv6 || (phyi_old->phyint_illv6 == ill && phyi_old->phyint_illv4 == NULL)); ASSERT(phyi_old->phyint_ifindex == 0); phyi = avl_find(&phyint_g_list.phyint_list_avl_by_name, ill->ill_name, &where); /* * 1. We grabbed the ill_g_lock before inserting this ill into * the global list of ills. So no other thread could have located * this ill and hence the ipsq of this ill is guaranteed to be empty. * 2. Now locate the other protocol instance of this ill. * 3. Now grab both ill locks in the right order, and the phyint lock of * the new ipsq. Holding ill locks + ill_g_lock ensures that the ipsq * of neither ill can change. * 4. Merge the phyint and thus the ipsq as well of this ill onto the * other ill. * 5. Release all locks. */ /* * Look for IPv4 if we are initializing IPv6 or look for IPv6 if * we are initializing IPv4. */ if (phyi != NULL) { ill_other = (isv6) ? phyi->phyint_illv4 : phyi->phyint_illv6; ASSERT(ill_other->ill_phyint != NULL); ASSERT((isv6 && !ill_other->ill_isv6) || (!isv6 && ill_other->ill_isv6)); GRAB_ILL_LOCKS(ill, ill_other); /* * We are potentially throwing away phyint_flags which * could be different from the one that we obtain from * ill_other->ill_phyint. But it is okay as we are assuming * that the state maintained within IP is correct. */ mutex_enter(&phyi->phyint_lock); if (isv6) { ASSERT(phyi->phyint_illv6 == NULL); phyi->phyint_illv6 = ill; } else { ASSERT(phyi->phyint_illv4 == NULL); phyi->phyint_illv4 = ill; } /* * This is a new ill, currently undergoing SLIFNAME * So we could not have joined an IPMP group until now. */ ASSERT(phyi_old->phyint_ipsq_next == NULL && phyi_old->phyint_groupname == NULL); /* * This phyi_old is going away. Decref ipsq_refs and * assert it is zero. The ipsq itself will be freed in * ipsq_exit */ ipsq = phyi_old->phyint_ipsq; IPSQ_DEC_REF(ipsq); ASSERT(ipsq->ipsq_refs == 0); /* Get the singleton phyint out of the ipsq list */ ASSERT(phyi_old->phyint_ipsq_next == NULL); ipsq->ipsq_phyint_list = NULL; phyi_old->phyint_illv4 = NULL; phyi_old->phyint_illv6 = NULL; mi_free(phyi_old); } else { mutex_enter(&ill->ill_lock); /* * We don't need to acquire any lock, since * the ill is not yet visible globally and we * have not yet released the ill_g_lock. */ phyi = phyi_old; mutex_enter(&phyi->phyint_lock); /* XXX We need a recovery strategy here. */ if (!phyint_assign_ifindex(phyi)) cmn_err(CE_PANIC, "phyint_assign_ifindex() failed"); avl_insert(&phyint_g_list.phyint_list_avl_by_name, (void *)phyi, where); (void) avl_find(&phyint_g_list.phyint_list_avl_by_index, &phyi->phyint_ifindex, &where); avl_insert(&phyint_g_list.phyint_list_avl_by_index, (void *)phyi, where); } /* * Reassigning ill_phyint automatically reassigns the ipsq also. * pending mp is not affected because that is per ill basis. */ ill->ill_phyint = phyi; /* * Keep the index on ipif_orig_index to be used by FAILOVER. * We do this here as when the first ipif was allocated, * ipif_allocate does not know the right interface index. */ ill->ill_ipif->ipif_orig_ifindex = ill->ill_phyint->phyint_ifindex; /* * Now that the phyint's ifindex has been assigned, complete the * remaining */ if (ill->ill_isv6) { ill->ill_ip6_mib->ipv6IfIndex = ill->ill_phyint->phyint_ifindex; ill->ill_icmp6_mib->ipv6IfIcmpIfIndex = ill->ill_phyint->phyint_ifindex; } RELEASE_ILL_LOCKS(ill, ill_other); mutex_exit(&phyi->phyint_lock); } /* * Notify any downstream modules of the name of this interface. * An M_IOCTL is used even though we don't expect a successful reply. * Any reply message from the driver (presumably an M_IOCNAK) will * eventually get discarded somewhere upstream. The message format is * simply an SIOCSLIFNAME ioctl just as might be sent from ifconfig * to IP. */ static void ip_ifname_notify(ill_t *ill, queue_t *q) { mblk_t *mp1, *mp2; struct iocblk *iocp; struct lifreq *lifr; mp1 = mkiocb(SIOCSLIFNAME); if (mp1 == NULL) return; mp2 = allocb(sizeof (struct lifreq), BPRI_HI); if (mp2 == NULL) { freeb(mp1); return; } mp1->b_cont = mp2; iocp = (struct iocblk *)mp1->b_rptr; iocp->ioc_count = sizeof (struct lifreq); lifr = (struct lifreq *)mp2->b_rptr; mp2->b_wptr += sizeof (struct lifreq); bzero(lifr, sizeof (struct lifreq)); (void) strncpy(lifr->lifr_name, ill->ill_name, LIFNAMSIZ); lifr->lifr_ppa = ill->ill_ppa; lifr->lifr_flags = (ill->ill_flags & (ILLF_IPV4|ILLF_IPV6)); putnext(q, mp1); } static boolean_t ip_trash_timer_started = B_FALSE; static int ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q) { int err; /* Set the obsolete NDD per-interface forwarding name. */ err = ill_set_ndd_name(ill); if (err != 0) { cmn_err(CE_WARN, "ipif_set_values: ill_set_ndd_name (%d)\n", err); } /* Tell downstream modules where they are. */ ip_ifname_notify(ill, q); /* * ill_dl_phys returns EINPROGRESS in the usual case. * Error cases are ENOMEM ... */ err = ill_dl_phys(ill, ipif, mp, q); /* * If there is no IRE expiration timer running, get one started. * igmp and mld timers will be triggered by the first multicast */ if (!ip_trash_timer_started) { /* * acquire the lock and check again. */ mutex_enter(&ip_trash_timer_lock); if (!ip_trash_timer_started) { ip_ire_expire_id = timeout(ip_trash_timer_expire, NULL, MSEC_TO_TICK(ip_timer_interval)); ip_trash_timer_started = B_TRUE; } mutex_exit(&ip_trash_timer_lock); } if (ill->ill_isv6) { mutex_enter(&mld_slowtimeout_lock); if (mld_slowtimeout_id == 0) { mld_slowtimeout_id = timeout(mld_slowtimo, NULL, MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL)); } mutex_exit(&mld_slowtimeout_lock); } else { mutex_enter(&igmp_slowtimeout_lock); if (igmp_slowtimeout_id == 0) { igmp_slowtimeout_id = timeout(igmp_slowtimo, NULL, MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL)); } mutex_exit(&igmp_slowtimeout_lock); } return (err); } /* * Common routine for ppa and ifname setting. Should be called exclusive. * * Returns EINPROGRESS when mp has been consumed by queueing it on * ill_pending_mp and the ioctl will complete in ip_rput. * * NOTE : If ppa is UNIT_MAX, we assign the next valid ppa and return * the new name and new ppa in lifr_name and lifr_ppa respectively. * For SLIFNAME, we pass these values back to the userland. */ static int ipif_set_values(queue_t *q, mblk_t *mp, char *interf_name, uint_t *new_ppa_ptr) { ill_t *ill; ipif_t *ipif; ipsq_t *ipsq; char *ppa_ptr; char *old_ptr; char old_char; int error; ip1dbg(("ipif_set_values: interface %s\n", interf_name)); ASSERT(q->q_next != NULL); ASSERT(interf_name != NULL); ill = (ill_t *)q->q_ptr; ASSERT(ill->ill_name[0] == '\0'); ASSERT(IAM_WRITER_ILL(ill)); ASSERT((mi_strlen(interf_name) + 1) <= LIFNAMSIZ); ASSERT(ill->ill_ppa == UINT_MAX); /* The ppa is sent down by ifconfig or is chosen */ if ((ppa_ptr = ill_get_ppa_ptr(interf_name)) == NULL) { return (EINVAL); } /* * make sure ppa passed in is same as ppa in the name. * This check is not made when ppa == UINT_MAX in that case ppa * in the name could be anything. System will choose a ppa and * update new_ppa_ptr and inter_name to contain the choosen ppa. */ if (*new_ppa_ptr != UINT_MAX) { /* stoi changes the pointer */ old_ptr = ppa_ptr; /* * ifconfig passed in 0 for the ppa for DLPI 1 style devices * (they don't have an externally visible ppa). We assign one * here so that we can manage the interface. Note that in * the past this value was always 0 for DLPI 1 drivers. */ if (*new_ppa_ptr == 0) *new_ppa_ptr = stoi(&old_ptr); else if (*new_ppa_ptr != (uint_t)stoi(&old_ptr)) return (EINVAL); } /* * terminate string before ppa * save char at that location. */ old_char = ppa_ptr[0]; ppa_ptr[0] = '\0'; ill->ill_ppa = *new_ppa_ptr; /* * Finish as much work now as possible before calling ill_glist_insert * which makes the ill globally visible and also merges it with the * other protocol instance of this phyint. The remaining work is * done after entering the ipsq which may happen sometime later. * ill_set_ndd_name occurs after the ill has been made globally visible. */ ipif = ill->ill_ipif; /* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */ ipif_assign_seqid(ipif); if (!(ill->ill_flags & (ILLF_IPV4|ILLF_IPV6))) ill->ill_flags |= ILLF_IPV4; ASSERT(ipif->ipif_next == NULL); /* Only one ipif on ill */ ASSERT((ipif->ipif_flags & IPIF_UP) == 0); if (ill->ill_flags & ILLF_IPV6) { ill->ill_isv6 = B_TRUE; if (ill->ill_rq != NULL) { ill->ill_rq->q_qinfo = &rinit_ipv6; ill->ill_wq->q_qinfo = &winit_ipv6; } /* Keep the !IN6_IS_ADDR_V4MAPPED assertions happy */ ipif->ipif_v6lcl_addr = ipv6_all_zeros; ipif->ipif_v6src_addr = ipv6_all_zeros; ipif->ipif_v6subnet = ipv6_all_zeros; ipif->ipif_v6net_mask = ipv6_all_zeros; ipif->ipif_v6brd_addr = ipv6_all_zeros; ipif->ipif_v6pp_dst_addr = ipv6_all_zeros; /* * point-to-point or Non-mulicast capable * interfaces won't do NUD unless explicitly * configured to do so. */ if (ipif->ipif_flags & IPIF_POINTOPOINT || !(ill->ill_flags & ILLF_MULTICAST)) { ill->ill_flags |= ILLF_NONUD; } /* Make sure IPv4 specific flag is not set on IPv6 if */ if (ill->ill_flags & ILLF_NOARP) { /* * Note: xresolv interfaces will eventually need * NOARP set here as well, but that will require * those external resolvers to have some * knowledge of that flag and act appropriately. * Not to be changed at present. */ ill->ill_flags &= ~ILLF_NOARP; } /* * Set the ILLF_ROUTER flag according to the global * IPv6 forwarding policy. */ if (ipv6_forward != 0) ill->ill_flags |= ILLF_ROUTER; } else if (ill->ill_flags & ILLF_IPV4) { ill->ill_isv6 = B_FALSE; IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6lcl_addr); IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6src_addr); IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6subnet); IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6net_mask); IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6brd_addr); IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6pp_dst_addr); /* * Set the ILLF_ROUTER flag according to the global * IPv4 forwarding policy. */ if (ip_g_forward != 0) ill->ill_flags |= ILLF_ROUTER; } ASSERT(ill->ill_phyint != NULL); /* * The ipv6Ifindex and ipv6IfIcmpIfIndex assignments will * be completed in ill_glist_insert -> ill_phyint_reinit */ if (ill->ill_isv6) { /* allocate v6 mib */ if (!ill_allocate_mibs(ill)) return (ENOMEM); } /* * Pick a default sap until we get the DL_INFO_ACK back from * the driver. */ if (ill->ill_sap == 0) { if (ill->ill_isv6) ill->ill_sap = IP6_DL_SAP; else ill->ill_sap = IP_DL_SAP; } ill->ill_ifname_pending = 1; ill->ill_ifname_pending_err = 0; ill_refhold(ill); rw_enter(&ill_g_lock, RW_WRITER); if ((error = ill_glist_insert(ill, interf_name, (ill->ill_flags & ILLF_IPV6) == ILLF_IPV6)) > 0) { ill->ill_ppa = UINT_MAX; ill->ill_name[0] = '\0'; /* * undo null termination done above. */ ppa_ptr[0] = old_char; rw_exit(&ill_g_lock); ill_refrele(ill); return (error); } ASSERT(ill->ill_name_length <= LIFNAMSIZ); /* * When we return the buffer pointed to by interf_name should contain * the same name as in ill_name. * If a ppa was choosen by the system (ppa passed in was UINT_MAX) * the buffer pointed to by new_ppa_ptr would not contain the right ppa * so copy full name and update the ppa ptr. * When ppa passed in != UINT_MAX all values are correct just undo * null termination, this saves a bcopy. */ if (*new_ppa_ptr == UINT_MAX) { bcopy(ill->ill_name, interf_name, ill->ill_name_length); *new_ppa_ptr = ill->ill_ppa; } else { /* * undo null termination done above. */ ppa_ptr[0] = old_char; } /* Let SCTP know about this ILL */ sctp_update_ill(ill, SCTP_ILL_INSERT); /* and also about the first ipif */ sctp_update_ipif(ipif, SCTP_IPIF_INSERT); ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_reprocess_ioctl, NEW_OP, B_TRUE); rw_exit(&ill_g_lock); ill_refrele(ill); if (ipsq == NULL) return (EINPROGRESS); /* * Need to set the ipsq_current_ipif now, if we have changed ipsq * due to the phyint merge in ill_phyint_reinit. */ ASSERT(ipsq->ipsq_current_ipif == NULL || ipsq->ipsq_current_ipif == ipif); ipsq->ipsq_current_ipif = ipif; ipsq->ipsq_last_cmd = SIOCSLIFNAME; error = ipif_set_values_tail(ill, ipif, mp, q); ipsq_exit(ipsq, B_TRUE, B_TRUE); if (error != 0 && error != EINPROGRESS) { /* * restore previous values */ ill->ill_isv6 = B_FALSE; } return (error); } extern void (*ip_cleanup_func)(void); void ipif_init(void) { hrtime_t hrt; int i; /* * Can't call drv_getparm here as it is too early in the boot. * As we use ipif_src_random just for picking a different * source address everytime, this need not be really random. */ hrt = gethrtime(); ipif_src_random = ((hrt >> 32) & 0xffffffff) * (hrt & 0xffffffff); for (i = 0; i < MAX_G_HEADS; i++) { ill_g_heads[i].ill_g_list_head = (ill_if_t *)&ill_g_heads[i]; ill_g_heads[i].ill_g_list_tail = (ill_if_t *)&ill_g_heads[i]; } avl_create(&phyint_g_list.phyint_list_avl_by_index, ill_phyint_compare_index, sizeof (phyint_t), offsetof(struct phyint, phyint_avl_by_index)); avl_create(&phyint_g_list.phyint_list_avl_by_name, ill_phyint_compare_name, sizeof (phyint_t), offsetof(struct phyint, phyint_avl_by_name)); ip_cleanup_func = ip_thread_exit; } /* * This is called by ip_rt_add when src_addr value is other than zero. * src_addr signifies the source address of the incoming packet. For * reverse tunnel route we need to create a source addr based routing * table. This routine creates ip_mrtun_table if it's empty and then * it adds the route entry hashed by source address. It verifies that * the outgoing interface is always a non-resolver interface (tunnel). */ int ip_mrtun_rt_add(ipaddr_t in_src_addr, int flags, ipif_t *ipif_arg, ipif_t *src_ipif, ire_t **ire_arg, queue_t *q, mblk_t *mp, ipsq_func_t func) { ire_t *ire; ire_t *save_ire; ipif_t *ipif; ill_t *in_ill = NULL; ill_t *out_ill; queue_t *stq; mblk_t *dlureq_mp; int error; if (ire_arg != NULL) *ire_arg = NULL; ASSERT(in_src_addr != INADDR_ANY); ipif = ipif_arg; if (ipif != NULL) { out_ill = ipif->ipif_ill; } else { ip1dbg(("ip_mrtun_rt_add: ipif is NULL\n")); return (EINVAL); } if (src_ipif == NULL) { ip1dbg(("ip_mrtun_rt_add: src_ipif is NULL\n")); return (EINVAL); } in_ill = src_ipif->ipif_ill; /* * Check for duplicates. We don't need to * match out_ill, because the uniqueness of * a route is only dependent on src_addr and * in_ill. */ ire = ire_mrtun_lookup(in_src_addr, in_ill); if (ire != NULL) { ire_refrele(ire); return (EEXIST); } if (ipif->ipif_net_type != IRE_IF_NORESOLVER) { ip2dbg(("ip_mrtun_rt_add: outgoing interface is type %d\n", ipif->ipif_net_type)); return (EINVAL); } stq = ipif->ipif_wq; ASSERT(stq != NULL); /* * The outgoing interface must be non-resolver * interface. */ dlureq_mp = ill_dlur_gen(NULL, out_ill->ill_phys_addr_length, out_ill->ill_sap, out_ill->ill_sap_length); if (dlureq_mp == NULL) { ip1dbg(("ip_newroute: dlureq_mp NULL\n")); return (ENOMEM); } /* Create the IRE. */ ire = ire_create( NULL, /* Zero dst addr */ NULL, /* Zero mask */ NULL, /* Zero gateway addr */ NULL, /* Zero ipif_src addr */ (uint8_t *)&in_src_addr, /* in_src-addr */ &ipif->ipif_mtu, NULL, NULL, /* rfq */ stq, IRE_MIPRTUN, dlureq_mp, ipif, in_ill, 0, 0, 0, flags, &ire_uinfo_null); if (ire == NULL) return (ENOMEM); ip2dbg(("ip_mrtun_rt_add: mrtun route is created with type %d\n", ire->ire_type)); save_ire = ire; ASSERT(save_ire != NULL); error = ire_add_mrtun(&ire, q, mp, func); /* * If ire_add_mrtun() failed, the ire passed in was freed * so there is no need to do so here. */ if (error != 0) { return (error); } /* Duplicate check */ if (ire != save_ire) { /* route already exists by now */ ire_refrele(ire); return (EEXIST); } if (ire_arg != NULL) { /* * Store the ire that was just added. the caller * ip_rts_request responsible for doing ire_refrele() * on it. */ *ire_arg = ire; } else { ire_refrele(ire); /* held in ire_add_mrtun */ } return (0); } /* * It is called by ip_rt_delete() only when mipagent requests to delete * a reverse tunnel route that was added by ip_mrtun_rt_add() before. */ int ip_mrtun_rt_delete(ipaddr_t in_src_addr, ipif_t *src_ipif) { ire_t *ire = NULL; if (in_src_addr == INADDR_ANY) return (EINVAL); if (src_ipif == NULL) return (EINVAL); /* search if this route exists in the ip_mrtun_table */ ire = ire_mrtun_lookup(in_src_addr, src_ipif->ipif_ill); if (ire == NULL) { ip2dbg(("ip_mrtun_rt_delete: ire not found\n")); return (ESRCH); } ire_delete(ire); ire_refrele(ire); return (0); } /* * Lookup the ipif corresponding to the onlink destination address. For * point-to-point interfaces, it matches with remote endpoint destination * address. For point-to-multipoint interfaces it only tries to match the * destination with the interface's subnet address. The longest, most specific * match is found to take care of such rare network configurations like - * le0: 129.146.1.1/16 * le1: 129.146.2.2/24 * It is used only by SO_DONTROUTE at the moment. */ ipif_t * ipif_lookup_onlink_addr(ipaddr_t addr, zoneid_t zoneid) { ipif_t *ipif, *best_ipif; ill_t *ill; ill_walk_context_t ctx; ASSERT(zoneid != ALL_ZONES); best_ipif = NULL; rw_enter(&ill_g_lock, RW_READER); ill = ILL_START_WALK_V4(&ctx); for (; ill != NULL; ill = ill_next(&ctx, ill)) { mutex_enter(&ill->ill_lock); for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; if (ipif->ipif_zoneid != zoneid) continue; /* * Point-to-point case. Look for exact match with * destination address. */ if (ipif->ipif_flags & IPIF_POINTOPOINT) { if (ipif->ipif_pp_dst_addr == addr) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); if (best_ipif != NULL) ipif_refrele(best_ipif); return (ipif); } } else if (ipif->ipif_subnet == (addr & ipif->ipif_net_mask)) { /* * Point-to-multipoint case. Looping through to * find the most specific match. If there are * multiple best match ipif's then prefer ipif's * that are UP. If there is only one best match * ipif and it is DOWN we must still return it. */ if ((best_ipif == NULL) || (ipif->ipif_net_mask > best_ipif->ipif_net_mask) || ((ipif->ipif_net_mask == best_ipif->ipif_net_mask) && ((ipif->ipif_flags & IPIF_UP) && (!(best_ipif->ipif_flags & IPIF_UP))))) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); rw_exit(&ill_g_lock); if (best_ipif != NULL) ipif_refrele(best_ipif); best_ipif = ipif; rw_enter(&ill_g_lock, RW_READER); mutex_enter(&ill->ill_lock); } } } mutex_exit(&ill->ill_lock); } rw_exit(&ill_g_lock); return (best_ipif); } /* * Save enough information so that we can recreate the IRE if * the interface goes down and then up. */ static void ipif_save_ire(ipif_t *ipif, ire_t *ire) { mblk_t *save_mp; save_mp = allocb(sizeof (ifrt_t), BPRI_MED); if (save_mp != NULL) { ifrt_t *ifrt; save_mp->b_wptr += sizeof (ifrt_t); ifrt = (ifrt_t *)save_mp->b_rptr; bzero(ifrt, sizeof (ifrt_t)); ifrt->ifrt_type = ire->ire_type; ifrt->ifrt_addr = ire->ire_addr; ifrt->ifrt_gateway_addr = ire->ire_gateway_addr; ifrt->ifrt_src_addr = ire->ire_src_addr; ifrt->ifrt_mask = ire->ire_mask; ifrt->ifrt_flags = ire->ire_flags; ifrt->ifrt_max_frag = ire->ire_max_frag; mutex_enter(&ipif->ipif_saved_ire_lock); save_mp->b_cont = ipif->ipif_saved_ire_mp; ipif->ipif_saved_ire_mp = save_mp; ipif->ipif_saved_ire_cnt++; mutex_exit(&ipif->ipif_saved_ire_lock); } } static void ipif_remove_ire(ipif_t *ipif, ire_t *ire) { mblk_t **mpp; mblk_t *mp; ifrt_t *ifrt; /* Remove from ipif_saved_ire_mp list if it is there */ mutex_enter(&ipif->ipif_saved_ire_lock); for (mpp = &ipif->ipif_saved_ire_mp; *mpp != NULL; mpp = &(*mpp)->b_cont) { /* * On a given ipif, the triple of address, gateway and * mask is unique for each saved IRE (in the case of * ordinary interface routes, the gateway address is * all-zeroes). */ mp = *mpp; ifrt = (ifrt_t *)mp->b_rptr; if (ifrt->ifrt_addr == ire->ire_addr && ifrt->ifrt_gateway_addr == ire->ire_gateway_addr && ifrt->ifrt_mask == ire->ire_mask) { *mpp = mp->b_cont; ipif->ipif_saved_ire_cnt--; freeb(mp); break; } } mutex_exit(&ipif->ipif_saved_ire_lock); } /* * IP multirouting broadcast routes handling * Append CGTP broadcast IREs to regular ones created * at ifconfig time. */ static void ip_cgtp_bcast_add(ire_t *ire, ire_t *ire_dst) { ire_t *ire_prim; ASSERT(ire != NULL); ASSERT(ire_dst != NULL); ire_prim = ire_ctable_lookup(ire->ire_gateway_addr, 0, IRE_BROADCAST, NULL, NULL, MATCH_IRE_TYPE); if (ire_prim != NULL) { /* * We are in the special case of broadcasts for * CGTP. We add an IRE_BROADCAST that holds * the RTF_MULTIRT flag, the destination * address of ire_dst and the low level * info of ire_prim. In other words, CGTP * broadcast is added to the redundant ipif. */ ipif_t *ipif_prim; ire_t *bcast_ire; ipif_prim = ire_prim->ire_ipif; ip2dbg(("ip_cgtp_filter_bcast_add: " "ire_dst %p, ire_prim %p, ipif_prim %p\n", (void *)ire_dst, (void *)ire_prim, (void *)ipif_prim)); bcast_ire = ire_create( (uchar_t *)&ire->ire_addr, (uchar_t *)&ip_g_all_ones, (uchar_t *)&ire_dst->ire_src_addr, (uchar_t *)&ire->ire_gateway_addr, NULL, &ipif_prim->ipif_mtu, NULL, ipif_prim->ipif_rq, ipif_prim->ipif_wq, IRE_BROADCAST, ipif_prim->ipif_bcast_mp, ipif_prim, NULL, 0, 0, 0, ire->ire_flags, &ire_uinfo_null); if (bcast_ire != NULL) { if (ire_add(&bcast_ire, NULL, NULL, NULL) == 0) { ip2dbg(("ip_cgtp_filter_bcast_add: " "added bcast_ire %p\n", (void *)bcast_ire)); ipif_save_ire(bcast_ire->ire_ipif, bcast_ire); ire_refrele(bcast_ire); } } ire_refrele(ire_prim); } } /* * IP multirouting broadcast routes handling * Remove the broadcast ire */ static void ip_cgtp_bcast_delete(ire_t *ire) { ire_t *ire_dst; ASSERT(ire != NULL); ire_dst = ire_ctable_lookup(ire->ire_addr, 0, IRE_BROADCAST, NULL, NULL, MATCH_IRE_TYPE); if (ire_dst != NULL) { ire_t *ire_prim; ire_prim = ire_ctable_lookup(ire->ire_gateway_addr, 0, IRE_BROADCAST, NULL, NULL, MATCH_IRE_TYPE); if (ire_prim != NULL) { ipif_t *ipif_prim; ire_t *bcast_ire; ipif_prim = ire_prim->ire_ipif; ip2dbg(("ip_cgtp_filter_bcast_delete: " "ire_dst %p, ire_prim %p, ipif_prim %p\n", (void *)ire_dst, (void *)ire_prim, (void *)ipif_prim)); bcast_ire = ire_ctable_lookup(ire->ire_addr, ire->ire_gateway_addr, IRE_BROADCAST, ipif_prim, NULL, MATCH_IRE_TYPE | MATCH_IRE_GW | MATCH_IRE_IPIF | MATCH_IRE_MASK); if (bcast_ire != NULL) { ip2dbg(("ip_cgtp_filter_bcast_delete: " "looked up bcast_ire %p\n", (void *)bcast_ire)); ipif_remove_ire(bcast_ire->ire_ipif, bcast_ire); ire_delete(bcast_ire); } ire_refrele(ire_prim); } ire_refrele(ire_dst); } } /* * IPsec hardware acceleration capabilities related functions. */ /* * Free a per-ill IPsec capabilities structure. */ static void ill_ipsec_capab_free(ill_ipsec_capab_t *capab) { if (capab->auth_hw_algs != NULL) kmem_free(capab->auth_hw_algs, capab->algs_size); if (capab->encr_hw_algs != NULL) kmem_free(capab->encr_hw_algs, capab->algs_size); if (capab->encr_algparm != NULL) kmem_free(capab->encr_algparm, capab->encr_algparm_size); kmem_free(capab, sizeof (ill_ipsec_capab_t)); } /* * Allocate a new per-ill IPsec capabilities structure. This structure * is specific to an IPsec protocol (AH or ESP). It is implemented as * an array which specifies, for each algorithm, whether this algorithm * is supported by the ill or not. */ static ill_ipsec_capab_t * ill_ipsec_capab_alloc(void) { ill_ipsec_capab_t *capab; uint_t nelems; capab = kmem_zalloc(sizeof (ill_ipsec_capab_t), KM_NOSLEEP); if (capab == NULL) return (NULL); /* we need one bit per algorithm */ nelems = MAX_IPSEC_ALGS / BITS(ipsec_capab_elem_t); capab->algs_size = nelems * sizeof (ipsec_capab_elem_t); /* allocate memory to store algorithm flags */ capab->encr_hw_algs = kmem_zalloc(capab->algs_size, KM_NOSLEEP); if (capab->encr_hw_algs == NULL) goto nomem; capab->auth_hw_algs = kmem_zalloc(capab->algs_size, KM_NOSLEEP); if (capab->auth_hw_algs == NULL) goto nomem; /* * Leave encr_algparm NULL for now since we won't need it half * the time */ return (capab); nomem: ill_ipsec_capab_free(capab); return (NULL); } /* * Resize capability array. Since we're exclusive, this is OK. */ static boolean_t ill_ipsec_capab_resize_algparm(ill_ipsec_capab_t *capab, int algid) { ipsec_capab_algparm_t *nalp, *oalp; uint32_t olen, nlen; oalp = capab->encr_algparm; olen = capab->encr_algparm_size; if (oalp != NULL) { if (algid < capab->encr_algparm_end) return (B_TRUE); } nlen = (algid + 1) * sizeof (*nalp); nalp = kmem_zalloc(nlen, KM_NOSLEEP); if (nalp == NULL) return (B_FALSE); if (oalp != NULL) { bcopy(oalp, nalp, olen); kmem_free(oalp, olen); } capab->encr_algparm = nalp; capab->encr_algparm_size = nlen; capab->encr_algparm_end = algid + 1; return (B_TRUE); } /* * Compare the capabilities of the specified ill with the protocol * and algorithms specified by the SA passed as argument. * If they match, returns B_TRUE, B_FALSE if they do not match. * * The ill can be passed as a pointer to it, or by specifying its index * and whether it is an IPv6 ill (ill_index and ill_isv6 arguments). * * Called by ipsec_out_is_accelerated() do decide whether an outbound * packet is eligible for hardware acceleration, and by * ill_ipsec_capab_send_all() to decide whether a SA must be sent down * to a particular ill. */ boolean_t ipsec_capab_match(ill_t *ill, uint_t ill_index, boolean_t ill_isv6, ipsa_t *sa) { boolean_t sa_isv6; uint_t algid; struct ill_ipsec_capab_s *cpp; boolean_t need_refrele = B_FALSE; if (ill == NULL) { ill = ill_lookup_on_ifindex(ill_index, ill_isv6, NULL, NULL, NULL, NULL); if (ill == NULL) { ip0dbg(("ipsec_capab_match: ill doesn't exist\n")); return (B_FALSE); } need_refrele = B_TRUE; } /* * Use the address length specified by the SA to determine * if it corresponds to a IPv6 address, and fail the matching * if the isv6 flag passed as argument does not match. * Note: this check is used for SADB capability checking before * sending SA information to an ill. */ sa_isv6 = (sa->ipsa_addrfam == AF_INET6); if (sa_isv6 != ill_isv6) /* protocol mismatch */ goto done; /* * Check if the ill supports the protocol, algorithm(s) and * key size(s) specified by the SA, and get the pointers to * the algorithms supported by the ill. */ switch (sa->ipsa_type) { case SADB_SATYPE_ESP: if (!(ill->ill_capabilities & ILL_CAPAB_ESP)) /* ill does not support ESP acceleration */ goto done; cpp = ill->ill_ipsec_capab_esp; algid = sa->ipsa_auth_alg; if (!IPSEC_ALG_IS_ENABLED(algid, cpp->auth_hw_algs)) goto done; algid = sa->ipsa_encr_alg; if (!IPSEC_ALG_IS_ENABLED(algid, cpp->encr_hw_algs)) goto done; if (algid < cpp->encr_algparm_end) { ipsec_capab_algparm_t *alp = &cpp->encr_algparm[algid]; if (sa->ipsa_encrkeybits < alp->minkeylen) goto done; if (sa->ipsa_encrkeybits > alp->maxkeylen) goto done; } break; case SADB_SATYPE_AH: if (!(ill->ill_capabilities & ILL_CAPAB_AH)) /* ill does not support AH acceleration */ goto done; if (!IPSEC_ALG_IS_ENABLED(sa->ipsa_auth_alg, ill->ill_ipsec_capab_ah->auth_hw_algs)) goto done; break; } if (need_refrele) ill_refrele(ill); return (B_TRUE); done: if (need_refrele) ill_refrele(ill); return (B_FALSE); } /* * Add a new ill to the list of IPsec capable ills. * Called from ill_capability_ipsec_ack() when an ACK was received * indicating that IPsec hardware processing was enabled for an ill. * * ill must point to the ill for which acceleration was enabled. * dl_cap must be set to DL_CAPAB_IPSEC_AH or DL_CAPAB_IPSEC_ESP. */ static void ill_ipsec_capab_add(ill_t *ill, uint_t dl_cap, boolean_t sadb_resync) { ipsec_capab_ill_t **ills, *cur_ill, *new_ill; uint_t sa_type; uint_t ipproto; ASSERT((dl_cap == DL_CAPAB_IPSEC_AH) || (dl_cap == DL_CAPAB_IPSEC_ESP)); switch (dl_cap) { case DL_CAPAB_IPSEC_AH: sa_type = SADB_SATYPE_AH; ills = &ipsec_capab_ills_ah; ipproto = IPPROTO_AH; break; case DL_CAPAB_IPSEC_ESP: sa_type = SADB_SATYPE_ESP; ills = &ipsec_capab_ills_esp; ipproto = IPPROTO_ESP; break; } rw_enter(&ipsec_capab_ills_lock, RW_WRITER); /* * Add ill index to list of hardware accelerators. If * already in list, do nothing. */ for (cur_ill = *ills; cur_ill != NULL && (cur_ill->ill_index != ill->ill_phyint->phyint_ifindex || cur_ill->ill_isv6 != ill->ill_isv6); cur_ill = cur_ill->next) ; if (cur_ill == NULL) { /* if this is a new entry for this ill */ new_ill = kmem_zalloc(sizeof (ipsec_capab_ill_t), KM_NOSLEEP); if (new_ill == NULL) { rw_exit(&ipsec_capab_ills_lock); return; } new_ill->ill_index = ill->ill_phyint->phyint_ifindex; new_ill->ill_isv6 = ill->ill_isv6; new_ill->next = *ills; *ills = new_ill; } else if (!sadb_resync) { /* not resync'ing SADB and an entry exists for this ill */ rw_exit(&ipsec_capab_ills_lock); return; } rw_exit(&ipsec_capab_ills_lock); if (ipcl_proto_fanout_v6[ipproto].connf_head != NULL) /* * IPsec module for protocol loaded, initiate dump * of the SADB to this ill. */ sadb_ill_download(ill, sa_type); } /* * Remove an ill from the list of IPsec capable ills. */ static void ill_ipsec_capab_delete(ill_t *ill, uint_t dl_cap) { ipsec_capab_ill_t **ills, *cur_ill, *prev_ill; ASSERT(dl_cap == DL_CAPAB_IPSEC_AH || dl_cap == DL_CAPAB_IPSEC_ESP); ills = (dl_cap == DL_CAPAB_IPSEC_AH) ? &ipsec_capab_ills_ah : &ipsec_capab_ills_esp; rw_enter(&ipsec_capab_ills_lock, RW_WRITER); prev_ill = NULL; for (cur_ill = *ills; cur_ill != NULL && (cur_ill->ill_index != ill->ill_phyint->phyint_ifindex || cur_ill->ill_isv6 != ill->ill_isv6); prev_ill = cur_ill, cur_ill = cur_ill->next) ; if (cur_ill == NULL) { /* entry not found */ rw_exit(&ipsec_capab_ills_lock); return; } if (prev_ill == NULL) { /* entry at front of list */ *ills = NULL; } else { prev_ill->next = cur_ill->next; } kmem_free(cur_ill, sizeof (ipsec_capab_ill_t)); rw_exit(&ipsec_capab_ills_lock); } /* * Handling of DL_CONTROL_REQ messages that must be sent down to * an ill while having exclusive access. */ /* ARGSUSED */ static void ill_ipsec_capab_send_writer(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *arg) { ill_t *ill = (ill_t *)q->q_ptr; ill_dlpi_send(ill, mp); } /* * Called by SADB to send a DL_CONTROL_REQ message to every ill * supporting the specified IPsec protocol acceleration. * sa_type must be SADB_SATYPE_AH or SADB_SATYPE_ESP. * We free the mblk and, if sa is non-null, release the held referece. */ void ill_ipsec_capab_send_all(uint_t sa_type, mblk_t *mp, ipsa_t *sa) { ipsec_capab_ill_t *ici, *cur_ici; ill_t *ill; mblk_t *nmp, *mp_ship_list = NULL, *next_mp; ici = (sa_type == SADB_SATYPE_AH) ? ipsec_capab_ills_ah : ipsec_capab_ills_esp; rw_enter(&ipsec_capab_ills_lock, RW_READER); for (cur_ici = ici; cur_ici != NULL; cur_ici = cur_ici->next) { ill = ill_lookup_on_ifindex(cur_ici->ill_index, cur_ici->ill_isv6, NULL, NULL, NULL, NULL); /* * Handle the case where the ill goes away while the SADB is * attempting to send messages. If it's going away, it's * nuking its shadow SADB, so we don't care.. */ if (ill == NULL) continue; if (sa != NULL) { /* * Make sure capabilities match before * sending SA to ill. */ if (!ipsec_capab_match(ill, cur_ici->ill_index, cur_ici->ill_isv6, sa)) { ill_refrele(ill); continue; } mutex_enter(&sa->ipsa_lock); sa->ipsa_flags |= IPSA_F_HW; mutex_exit(&sa->ipsa_lock); } /* * Copy template message, and add it to the front * of the mblk ship list. We want to avoid holding * the ipsec_capab_ills_lock while sending the * message to the ills. * * The b_next and b_prev are temporarily used * to build a list of mblks to be sent down, and to * save the ill to which they must be sent. */ nmp = copymsg(mp); if (nmp == NULL) { ill_refrele(ill); continue; } ASSERT(nmp->b_next == NULL && nmp->b_prev == NULL); nmp->b_next = mp_ship_list; mp_ship_list = nmp; nmp->b_prev = (mblk_t *)ill; } rw_exit(&ipsec_capab_ills_lock); nmp = mp_ship_list; while (nmp != NULL) { /* restore the mblk to a sane state */ next_mp = nmp->b_next; nmp->b_next = NULL; ill = (ill_t *)nmp->b_prev; nmp->b_prev = NULL; /* * Ship the mblk to the ill, must be exclusive. Keep the * reference to the ill as qwriter_ip() does a ill_referele(). */ (void) qwriter_ip(NULL, ill, ill->ill_wq, nmp, ill_ipsec_capab_send_writer, NEW_OP, B_TRUE); nmp = next_mp; } if (sa != NULL) IPSA_REFRELE(sa); freemsg(mp); } /* * Derive an interface id from the link layer address. * Knows about IEEE 802 and IEEE EUI-64 mappings. */ static boolean_t ip_ether_v6intfid(uint_t phys_length, uint8_t *phys_addr, in6_addr_t *v6addr) { char *addr; if (phys_length != ETHERADDRL) return (B_FALSE); /* Form EUI-64 like address */ addr = (char *)&v6addr->s6_addr32[2]; bcopy((char *)phys_addr, addr, 3); addr[0] ^= 0x2; /* Toggle Universal/Local bit */ addr[3] = (char)0xff; addr[4] = (char)0xfe; bcopy((char *)phys_addr + 3, addr + 5, 3); return (B_TRUE); } /* ARGSUSED */ static boolean_t ip_nodef_v6intfid(uint_t phys_length, uint8_t *phys_addr, in6_addr_t *v6addr) { return (B_FALSE); } /* ARGSUSED */ static boolean_t ip_ether_v6mapinfo(uint_t lla_length, uint8_t *bphys_addr, uint8_t *maddr, uint32_t *hw_start, in6_addr_t *v6_extract_mask) { /* * Multicast address mappings used over Ethernet/802.X. * This address is used as a base for mappings. */ static uint8_t ipv6_g_phys_multi_addr[] = {0x33, 0x33, 0x00, 0x00, 0x00, 0x00}; /* * Extract low order 32 bits from IPv6 multicast address. * Or that into the link layer address, starting from the * second byte. */ *hw_start = 2; v6_extract_mask->s6_addr32[0] = 0; v6_extract_mask->s6_addr32[1] = 0; v6_extract_mask->s6_addr32[2] = 0; v6_extract_mask->s6_addr32[3] = 0xffffffffU; bcopy(ipv6_g_phys_multi_addr, maddr, lla_length); return (B_TRUE); } /* * Indicate by return value whether multicast is supported. If not, * this code should not touch/change any parameters. */ /* ARGSUSED */ static boolean_t ip_ether_v4mapinfo(uint_t phys_length, uint8_t *bphys_addr, uint8_t *maddr, uint32_t *hw_start, ipaddr_t *extract_mask) { /* * Multicast address mappings used over Ethernet/802.X. * This address is used as a base for mappings. */ static uint8_t ip_g_phys_multi_addr[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 }; if (phys_length != ETHERADDRL) return (B_FALSE); *extract_mask = htonl(0x007fffff); *hw_start = 2; bcopy(ip_g_phys_multi_addr, maddr, ETHERADDRL); return (B_TRUE); } /* * Derive IPoIB interface id from the link layer address. */ static boolean_t ip_ib_v6intfid(uint_t phys_length, uint8_t *phys_addr, in6_addr_t *v6addr) { char *addr; if (phys_length != 20) return (B_FALSE); addr = (char *)&v6addr->s6_addr32[2]; bcopy(phys_addr + 12, addr, 8); /* * In IBA 1.1 timeframe, some vendors erroneously set the u/l bit * in the globally assigned EUI-64 GUID to 1, in violation of IEEE * rules. In these cases, the IBA considers these GUIDs to be in * "Modified EUI-64" format, and thus toggling the u/l bit is not * required; vendors are required not to assign global EUI-64's * that differ only in u/l bit values, thus guaranteeing uniqueness * of the interface identifier. Whether the GUID is in modified * or proper EUI-64 format, the ipv6 identifier must have the u/l * bit set to 1. */ addr[0] |= 2; /* Set Universal/Local bit to 1 */ return (B_TRUE); } /* * Note on mapping from multicast IP addresses to IPoIB multicast link * addresses. IPoIB multicast link addresses are based on IBA link addresses. * The format of an IPoIB multicast address is: * * 4 byte QPN Scope Sign. Pkey * +--------------------------------------------+ * | 00FFFFFF | FF | 1X | X01B | Pkey | GroupID | * +--------------------------------------------+ * * The Scope and Pkey components are properties of the IBA port and * network interface. They can be ascertained from the broadcast address. * The Sign. part is the signature, and is 401B for IPv4 and 601B for IPv6. */ static boolean_t ip_ib_v6mapinfo(uint_t lla_length, uint8_t *bphys_addr, uint8_t *maddr, uint32_t *hw_start, in6_addr_t *v6_extract_mask) { /* * Base IPoIB IPv6 multicast address used for mappings. * Does not contain the IBA scope/Pkey values. */ static uint8_t ipv6_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0x10, 0x60, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; /* * Extract low order 80 bits from IPv6 multicast address. * Or that into the link layer address, starting from the * sixth byte. */ *hw_start = 6; bcopy(ipv6_g_phys_ibmulti_addr, maddr, lla_length); /* * Now fill in the IBA scope/Pkey values from the broadcast address. */ *(maddr + 5) = *(bphys_addr + 5); *(maddr + 8) = *(bphys_addr + 8); *(maddr + 9) = *(bphys_addr + 9); v6_extract_mask->s6_addr32[0] = 0; v6_extract_mask->s6_addr32[1] = htonl(0x0000ffff); v6_extract_mask->s6_addr32[2] = 0xffffffffU; v6_extract_mask->s6_addr32[3] = 0xffffffffU; return (B_TRUE); } static boolean_t ip_ib_v4mapinfo(uint_t phys_length, uint8_t *bphys_addr, uint8_t *maddr, uint32_t *hw_start, ipaddr_t *extract_mask) { /* * Base IPoIB IPv4 multicast address used for mappings. * Does not contain the IBA scope/Pkey values. */ static uint8_t ipv4_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0x10, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; if (phys_length != sizeof (ipv4_g_phys_ibmulti_addr)) return (B_FALSE); /* * Extract low order 28 bits from IPv4 multicast address. * Or that into the link layer address, starting from the * sixteenth byte. */ *extract_mask = htonl(0x0fffffff); *hw_start = 16; bcopy(ipv4_g_phys_ibmulti_addr, maddr, phys_length); /* * Now fill in the IBA scope/Pkey values from the broadcast address. */ *(maddr + 5) = *(bphys_addr + 5); *(maddr + 8) = *(bphys_addr + 8); *(maddr + 9) = *(bphys_addr + 9); return (B_TRUE); } /* * Returns B_TRUE if an ipif is present in the given zone, matching some flags * (typically IPIF_UP). If ipifp is non-null, the held ipif is returned there. * This works for both IPv4 and IPv6; if the passed-in ill is v6, the ipif with * the link-local address is preferred. */ boolean_t ipif_lookup_zoneid(ill_t *ill, zoneid_t zoneid, int flags, ipif_t **ipifp) { ipif_t *ipif; ipif_t *maybe_ipif = NULL; mutex_enter(&ill->ill_lock); if (ill->ill_state_flags & ILL_CONDEMNED) { mutex_exit(&ill->ill_lock); if (ipifp != NULL) *ipifp = NULL; return (B_FALSE); } for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { if (!IPIF_CAN_LOOKUP(ipif)) continue; if (zoneid != ALL_ZONES && ipif->ipif_zoneid != zoneid) continue; if ((ipif->ipif_flags & flags) != flags) continue; if (ipifp == NULL) { mutex_exit(&ill->ill_lock); ASSERT(maybe_ipif == NULL); return (B_TRUE); } if (!ill->ill_isv6 || IN6_IS_ADDR_LINKLOCAL(&ipif->ipif_v6src_addr)) { ipif_refhold_locked(ipif); mutex_exit(&ill->ill_lock); *ipifp = ipif; return (B_TRUE); } if (maybe_ipif == NULL) maybe_ipif = ipif; } if (ipifp != NULL) { if (maybe_ipif != NULL) ipif_refhold_locked(maybe_ipif); *ipifp = maybe_ipif; } mutex_exit(&ill->ill_lock); return (maybe_ipif != NULL); } /* * Same as ipif_lookup_zoneid() but looks at all the ills in the same group. */ boolean_t ipif_lookup_zoneid_group(ill_t *ill, zoneid_t zoneid, int flags, ipif_t **ipifp) { ill_t *illg; /* * We look at the passed-in ill first without grabbing ill_g_lock. */ if (ipif_lookup_zoneid(ill, zoneid, flags, ipifp)) { return (B_TRUE); } rw_enter(&ill_g_lock, RW_READER); if (ill->ill_group == NULL) { /* ill not in a group */ rw_exit(&ill_g_lock); return (B_FALSE); } /* * There's no ipif in the zone on ill, however ill is part of an IPMP * group. We need to look for an ipif in the zone on all the ills in the * group. */ illg = ill->ill_group->illgrp_ill; do { /* * We don't call ipif_lookup_zoneid() on ill as we already know * that it's not there. */ if (illg != ill && ipif_lookup_zoneid(illg, zoneid, flags, ipifp)) { break; } } while ((illg = illg->ill_group_next) != NULL); rw_exit(&ill_g_lock); return (illg != NULL); } /* * Check if this ill is only being used to send ICMP probes for IPMP */ boolean_t ill_is_probeonly(ill_t *ill) { /* * Check if the interface is FAILED, or INACTIVE */ if (ill->ill_phyint->phyint_flags & (PHYI_FAILED|PHYI_INACTIVE)) return (B_TRUE); return (B_FALSE); }