ip_if.c revision e35d2278fa5447def80bb5a191ce0f1c6b6836de
/*
* 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
* 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 2007 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 <sys/sysmacros.h>
#include <sys/isa_defs.h>
#include <net/if_types.h>
#include <netinet/igmp_var.h>
#include <sys/ethernet.h>
#include <inet/ip_multi.h>
#include <inet/ip_ftable.h>
#include <inet/ip_netinfo.h>
#include <inet/ipsec_info.h>
#include <inet/ipsec_impl.h>
#include <inet/ip_listutils.h>
#include <inet/ipclassifier.h>
#include <sys/systeminfo.h>
#include <sys/bootconf.h>
/* 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;
int ipft_min_size;
int ipft_flags;
} ipft_t;
typedef struct ip_sock_ar_s {
union {
} ip_sock_ar_u;
} ip_sock_ar_t;
static void ipsq_delete(ipsq_t *);
static void ipif_delete_cache_ire(ire_t *, char *);
queue_t *q);
static void ill_delete_interface_type(ill_if_t *);
static void ill_glist_delete(ill_t *);
static void ill_stq_cache_delete(ire_t *, char *);
in6_addr_t *);
ipaddr_t *);
in6_addr_t *);
ipaddr_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_capability_dls_disable(ill_t *);
static void illgrp_cache_delete(ire_t *, char *);
static void ill_disband_usesrc_group(ill_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
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
{
/*
* Per-ill capabilities.
*/
struct ill_ipsec_capab_s {
/* algorithm key lengths */
};
/*
* 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 */
/* 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 */
/* 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 */
/* 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 */
/* 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 = {
sizeof (ared_t) + IP_ADDR_LEN,
sizeof (ared_t),
sizeof (ared_t),
};
static ared_t ip6_ared_template = {
sizeof (ared_t) + IPV6_ADDR_LEN,
sizeof (ared_t),
sizeof (ared_t),
};
/*
* 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), /* 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 */
IP_ADDR_LEN, /* sender addr length */
AR_EQ_DEFAULT_XMIT_COUNT, /* xmit_count */
AR_EQ_DEFAULT_XMIT_INTERVAL, /* (re)xmit_interval in milliseconds */
AR_EQ_DEFAULT_MAX_BUFFERED /* max # of requests to buffer */
/* anything else filled in by the code */
};
static arc_t ip_aru_template = {
sizeof (arc_t), /* Name offset */
sizeof (arc_t) /* Name length (set by ill_arp_alloc) */
};
static arc_t ip_ard_template = {
sizeof (arc_t), /* Name offset */
sizeof (arc_t) /* Name length (set by ill_arp_alloc) */
};
static arc_t ip_aron_template = {
sizeof (arc_t), /* Name offset */
sizeof (arc_t) /* Name length (set by ill_arp_alloc) */
};
static arc_t ip_aroff_template = {
sizeof (arc_t), /* Name offset */
sizeof (arc_t) /* Name length (set by ill_arp_alloc) */
};
static arma_t ip_arma_multi_template = {
/* Name offset */
sizeof (arma_t), /* Name length (set by ill_arp_alloc) */
sizeof (arma_t), /* proto_addr_offset */
IP_ADDR_LEN, /* proto_addr_length */
IP_MAX_HW_LEN, /* hw_addr_length */
0, /* hw_mapping_start */
};
static ipft_t ip_ioctl_ftbl[] = {
{ 0 }
};
/* Simple ICMP IP Header Template */
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" },
};
};
char ipif_loopback_name[] = "lo0";
static char *ipv4_forward_suffix = ":ip_forwarding";
static char *ipv6_forward_suffix = ":ip6_forwarding";
/* When set search for unused ipif_seqid */
/*
* ppa arena is created after these many
* interfaces have been plumbed.
*/
/*
* 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
*/
#define SOFT_RINGS_ENABLED() (ip_soft_rings_cnt ? \
static uint_t
{
12345;
}
/*
* Allocate per-interface mibs.
* Returns true if ok. False otherwise.
* ipsq may not yet be allocated (loopback case ).
*/
static boolean_t
{
/* Already allocated? */
return (B_TRUE);
}
return (B_FALSE);
}
/* Setup static information */
sizeof (mib2_ipIfStatsEntry_t));
sizeof (mib2_ipv6AddrEntry_t));
sizeof (mib2_ipv6RouteEntry_t));
sizeof (mib2_ipv6NetToMediaEntry_t));
sizeof (ipv6_member_t));
sizeof (ipv6_grpsrc_t));
} else {
sizeof (mib2_ipAddrEntry_t));
sizeof (mib2_ipRouteEntry_t));
sizeof (mib2_ipNetToMediaEntry_t));
sizeof (ip_member_t));
sizeof (ip_grpsrc_t));
/*
* For a v4 ill, we are done at this point, because per ill
* icmp mibs are only used for v6.
*/
return (B_TRUE);
}
return (B_FALSE);
}
/* static icmp info */
sizeof (mib2_ipv6IfIcmpEntry_t);
/*
* The ipIfStatsIfindex 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 *
{
char *cp;
int len;
return (NULL);
if (template_len)
if (len > template_len)
if (addr) {
if (area->area_proto_mask_offset)
else
while (len-- > 0)
*cp++ = (char)~0;
}
}
return (mp);
}
mblk_t *
{
(char *)&ipif->ipif_lcl_addr));
}
mblk_t *
{
(char *)&ipif->ipif_lcl_addr));
}
mblk_t *
{
(char *)&addr));
}
/*
* 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 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.
*/
/*
* 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.
*/
/*
* 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
*/
/* Clean up msgs on pending upcalls for mrouted */
/*
* 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.
*/
/*
* ill_down will arrange to blow off any IRE's dependent on this
* ILL, and shut down fragmentation reassembly.
*/
/* Let SCTP know, so that it can remove this from its list. */
/*
* 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.
*/
} else { /* consumer of the usesrc ILL */
}
}
}
static void
{
}
}
/*
* Send all deferred messages without waiting for their ACKs.
*/
void
{
/*
* Clear ill_dlpi_pending so that the message is not queued in
* ill_dlpi_send().
*/
}
}
/*
* 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
{
}
/*
* 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.
*/
/*
* Clean up polling and soft ring capabilities
*/
/*
* Send the detach if there's one to send (i.e., if we're above a
* style 2 DLPI driver).
*/
}
/*
* 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.
*/
/*
* Free capabilities.
*/
}
}
}
}
sizeof (ill_zerocopy_capab_t));
}
}
sizeof (ill_dls_capab_t) +
(sizeof (ill_rx_ring_t) * ILL_MAX_RINGS));
}
/*
* 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.
*/
/*
* 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);
}
}
/* Free all retained control messages. */
do {
while (mpp[0]) {
}
}
/* Drop refcnt here */
}
static void
{
/*
* MIB statistics must not be lost, so when an interface
* goes away the counter values will be added to the global
* MIBs.
*/
ill->ill_ip_mib);
} else {
ill->ill_ip_mib);
}
}
ill->ill_icmp6_mib);
}
}
/*
* 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
{
if (sap_length == 0) {
else
} else if (sap_length < 0) {
else
} else {
else
}
}
/*
* 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 *
{
return (NULL);
/* HACK: accomodate incompatible DLPI drivers */
if (addr_length == 8)
addr_length = 6;
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.
*/
{
/*
* M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls.
*/
/*
* 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.
*/
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)
*/
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 *
{
/*
* 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.
*/
if (ioc_id != 0)
/* Search the list for the appropriate ioctl based on ioc_id */
/* Match based on the ioc_id or based on the conn */
break;
}
/* Unlink the mblk from the pending mp list */
} else {
}
/*
* conn refcnt must have been bumped up at the start of
* the ioctl. So we can safely access the conn.
*/
}
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
*/
int waitfor)
{
/*
* The caller may be using a different ipif than the one passed into
* ipsq_current_start() (e.g., suppose an ioctl that came in on the V4
* ill needs to wait for the V6 ill to quiesce). So we can't ASSERT
* that `ipsq_current_ipif == ipif'.
*/
/*
* M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls,
*/
/*
* 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.
*/
return (B_FALSE);
}
/*
* 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
*/
return (B_TRUE);
}
/*
* Retrieve the ipsq_pending_mp and return it. There can be only 1 mp
* queued in the list.
*/
mblk_t *
{
return (NULL);
}
/* There can be only 1 such excl message */
ipsq->ipsq_waitfor = 0;
/*
* 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.
*/
} else {
}
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.
*/
{
queue_t *q;
/*
* If connp is null, unconditionally clean up the ipsq_pending_mp.
* 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.
*/
return (B_FALSE);
}
/* Now remove from the ipsq_pending_mp */
/* If MOVE was in progress, clear the move_in_progress fields also. */
if (ill->ill_move_in_progress) {
} else if (ill->ill_up_ipifs) {
}
ipsq->ipsq_waitfor = 0;
ipsq->ipsq_current_ioctl = 0;
} else {
}
} else {
/*
* be just inet_freemsg. we have to restart it
* otherwise the thread will be stuck.
*/
}
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
{
queue_t *q;
/*
* 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()
*/
}
}
/*
* Called in the conn close path and ill delete path
*/
static void
{
queue_t *q;
q = CONNP_TO_WQ(connp);
else
/*
* 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.
*/
/* Unlink the mblk from the pending mp list */
} else {
}
/*
* Create a temporary list and release the ipsq lock
* New elements are added to the head of the tmp_list
*/
} else {
}
}
} else {
/*
* this can't be just inet_freemsg. we have to
* restart it otherwise the thread will be stuck.
*/
}
}
}
/*
* 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
{
/*
* 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.
*/
return;
}
return;
}
/*
* is changing. But we need to make sure that the ill will
* not vanish. So we just bump up the ill_waiter count.
*/
if (refheld) {
/*
* 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.
*/
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
*/
if (refheld)
}
/*
* ipcl_walk function for cleaning up conn_*_ill fields.
*/
static void
{
/* Revert to late binding */
}
/*
* 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.
*/
return;
}
}
}
/* ARGSUSED */
void
{
}
}
/*
* 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.
*/
{
/*
* Atomically test and add the pending mp if references are active.
*/
if (!ill_is_quiescent(ill)) {
/* call cannot fail since `conn_t *' argument is NULL */
return (B_FALSE);
}
return (B_TRUE);
}
static void
{
/* Blow off any IREs dependent on this ILL. */
if (ipst->ips_ire_mrtun_count != 0) {
} else {
}
/*
* If any interface based forwarding table exists
* Blow off the ires there dependent on this ill
*/
if (ipst->ips_ire_srcif_table_count > 0) {
ipst);
} else {
}
/* Remove any conn_*_ill depending on this ill */
}
}
static void
{
int i;
/* Destroy ill_srcif_table if it exists */
/* Lock not reqd really because nobody should be able to access */
ill->ill_srcif_refcnt = 0;
for (i = 0; i < IP_SRCIF_TABLE_SIZE; i++) {
}
IP_SRCIF_TABLE_SIZE * sizeof (irb_t));
ill->ill_srcif_refcnt = 0;
ill->ill_mrtun_refcnt = 0;
}
}
/*
* ire_walk routine used to delete every IRE that depends on queues
* associated with 'ill'. (Always called as writer.)
*/
static void
{
/*
* 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.
*/
}
}
/*
* 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
{
}
}
/*
*/
void
{
}
/* Consume an M_IOCACK of the fastpath probe. */
void
{
/*
* If this was the first attempt turn on the fastpath probing.
*/
/* Free the M_IOCACK mblk, hold on to the data */
return;
/*
* Update all IRE's or NCE's that are waiting for
* fastpath update.
*/
} else {
ip0dbg(("ill_fastpath_ack: no b_cont\n"));
}
}
/*
* 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
{
return (EINVAL);
switch (ill->ill_dlpi_fastpath_state) {
case IDS_FAILED:
/*
* Driver NAKed the first fastpath ioctl - assume it doesn't
* support it.
*/
return (ENOTSUP);
case IDS_UNKNOWN:
/* This is the first probe */
break;
default:
break;
}
return (EAGAIN);
return (EAGAIN);
}
return (0);
}
void
{
/*
* Do so only if negotiation is enabled, capabilities are unknown,
* and a capability negotiation is not already in progress.
*/
return;
ip1dbg(("ill_capability_probe: starting capability negotiation\n"));
}
void
{
/*
* 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 IDS_OK.
*/
/*
* 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.
*/
/* Nothing to send down in order to disable the capabilities? */
return;
"DL_CAPABILITY_REQ (ENOMEM)\n");
return;
}
ip1dbg(("ill_capability_reset: resetting negotiated capabilities\n"));
}
/*
* Request or set new-style hardware capabilities supported by DLS provider.
*/
static void
{
return;
}
ptr += sizeof (dl_capability_req_t);
}
}
static void
{
/*
* 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)
*/
"malformed sub-capability too long for mblk");
return;
}
"encapsulated capab type %d too long for mblk",
return;
}
ip1dbg(("ill_capability_id_ack: mid token for capab type %d "
"isn't as expected; pass-thru module(s) detected, "
return;
}
/* Process the encapsulated sub-capability */
}
/*
* 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
{
/*
* 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)
*/
"malformed sub-capability too long for mblk");
return;
}
"unsupported MDT sub-capability (version %d, expected %d)",
return;
}
ip1dbg(("ill_capability_mdt_ack: mid token for MDT "
"capability isn't as expected; pass-thru module(s) "
"detected, discarding capability\n"));
return;
}
if (*ill_mdt_capab == NULL) {
if (*ill_mdt_capab == NULL) {
"could not enable MDT version %d "
"for %s (ENOMEM)\n", MDT_VERSION_2,
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",
/*
* 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.
*/
} else {
size = sizeof (dl_capability_req_t) +
sizeof (dl_capability_sub_t) + sizeof (dl_capab_mdt_t);
"could not enable MDT for %s (ENOMEM)\n",
return;
}
/* initialize dl_capability_req_t */
sizeof (dl_capab_mdt_t);
/* initialize dl_capability_sub_t */
/* initialize dl_capab_mdt_t */
ip1dbg(("ill_capability_mdt_ack: asking interface %s "
/* set ENABLE flag */
/* nmp points to a DL_CAPABILITY_REQ message to enable MDT */
}
}
static void
{
int size;
if (!ILL_MDT_CAPABLE(ill))
return;
/*
* 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.
*/
ip1dbg(("ill_capability_mdt_reset: unable to allocate "
"request to disable MDT\n"));
return;
}
mdt_subcap->mdt_flags = 0;
mdt_subcap->mdt_hdr_head = 0;
mdt_subcap->mdt_hdr_tail = 0;
else
}
/*
* 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
{
return (B_FALSE);
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 *
{
/*
* 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.
*/
return (NULL);
/* initialize dl_capability_req_t */
ptr += sizeof (dl_capability_req_t);
/* initialize dl_capability_sub_t */
/* initialize dl_capab_ipsec_t */
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
{
if (sub_dl_cap == DL_CAPAB_IPSEC_AH) {
} else {
}
/*
* 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.
*/
/*
* 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)
*/
"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.2 call ill_dlpi_send(isub->dlcap) to send all
* AH or ESP SA's to interface.
*/
"too many ciphers for sub-capability len");
return;
}
alg_len = sizeof (dl_capab_ipsec_alg_t);
/*
* 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.
*/
("ill_capability_ipsec_ack: got ENABLE ACK\n"));
/*
* Update IPsec capabilities for this ill
*/
("ill_capability_ipsec_ack: "
"allocating ipsec_capab for ill\n"));
"ill_capability_ipsec_ack: "
"could not enable IPsec Hardware "
"acceleration for %s (ENOMEM)\n",
return;
}
}
"ill_capability_ipsec_ack: "
"malformed IPsec algorithm id %d",
continue;
}
} else {
"ill_capability_ipsec_ack: "
"no space for IPsec alg id %d",
continue;
}
}
/*
* indicate that a capability was enabled, which
* will be used below to kick off a SADB dump
* to the ill.
*/
} else {
("ill_capability_ipsec_ack: enabling alg 0x%x\n",
/*
* 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.
*/
"ill_capability_ipsec_ack: "
"could not enable IPsec Hardware "
"acceleration for %s (ENOMEM)\n",
return;
}
/* ptr to current output alg specifier */
}
/*
* Copy current alg specifier, set ENABLE
* flag, and advance to next output alg.
* For now we enable all IPsec capabilities.
*/
}
/* move to next input algorithm specifier */
ialg = (dl_capab_ipsec_alg_t *)
}
/*
* nmp points to a DL_CAPABILITY_REQ message to enable
* IPsec hardware acceleration.
*/
if (need_sadb_dump)
/*
* An acknowledgement corresponding to a request to
* enable acceleration was received, notify SADB.
*/
}
/*
* 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
{
int i, k;
/* dl_capability_sub_t for "stype" */
/* dl_capab_ipsec_t for "stype" */
/* create entries for "stype" AUTH ciphers */
for (k = 0; k < BITSPERBYTE; k++) {
continue;
}
}
/* create entries for "stype" ENCR ciphers */
for (k = 0; k < BITSPERBYTE; k++) {
continue;
}
}
}
/*
* 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.
*/
x = (x & 0x55) + ((x >> 1) & 0x55); \
x = (x & 0x33) + ((x >> 2) & 0x33); \
}
/* ARGSUSED */
static void
{
int i, size = 0;
return;
/* Find out the number of ciphers for AH */
}
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 */
}
}
/* Find out the number of ciphers for ESP */
}
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 */
}
}
if (size == 0) {
ip1dbg(("ill_capability_ipsec_reset: capabilities exist but "
"there's nothing to reset\n"));
return;
}
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.
*/
/* Fill in DL_CAPAB_IPSEC_AH sub-capability entries */
if (ah_cnt > 0) {
}
/* Fill in DL_CAPAB_IPSEC_ESP sub-capability entries */
if (esp_cnt > 0) {
}
/*
* 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.
*/
else
}
static void
{
/*
* 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.
*/
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.
*/
case DL_CAPAB_IPSEC_AH:
case DL_CAPAB_IPSEC_ESP:
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.
*/
ip1dbg(("ill_capability_dispatch: unencapsulated capab type "
"%d discarded; %d module(s) present below IP\n",
return;
}
case DL_CAPAB_IPSEC_AH:
case DL_CAPAB_IPSEC_ESP:
break;
case DL_CAPAB_MDT:
break;
case DL_CAPAB_HCKSUM:
break;
case DL_CAPAB_ZEROCOPY:
break;
case DL_CAPAB_POLL:
if (!SOFT_RINGS_ENABLED())
break;
case DL_CAPAB_SOFT_RING:
if (SOFT_RINGS_ENABLED())
break;
case DL_CAPAB_LSO:
break;
default:
ip1dbg(("ill_capability_dispatch: unknown capab type %d\n",
}
}
/*
* 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
/*
*/
static mac_resource_handle_t
{
int ip_rx_index;
return (NULL);
}
(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.
*/
return (NULL);
}
static boolean_t
{
"soft_ring enabled for ill=%s (%p) but data "
(void *)ill);
}
return (B_TRUE);
"polling enabled for ill=%s (%p) but data "
(void *)ill);
}
return (B_TRUE);
}
/* Soft_Ring or polling is being re-enabled */
sizeof (ill_rx_ring_t) * ILL_MAX_RINGS);
return (B_TRUE);
}
return (B_FALSE);
sz = sizeof (ill_dls_capab_t);
(void *)ill);
return (B_FALSE);
}
/* Allocate space to hold ring table */
return (B_TRUE);
}
/*
* 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
{
}
}
static void
{
if (!ill_capability_dls_init(ill))
return;
/* Copy locally to get the members aligned */
sizeof (dl_capab_dls_t));
/* Get the tx function and handle from dld */
if (sub_dl_cap == DL_CAPAB_SOFT_RING) {
}
"not allocate memory for CAPAB_REQ for %s (%p)\n",
return;
}
/* initialize dl_capability_req_t */
rptr += sizeof (dl_capability_req_t);
/* initialize dl_capability_sub_t */
rptr += sizeof (dl_capab_dls_t);
/* initialize dl_capab_dls_t to be sent down */
if (sub_dl_cap == DL_CAPAB_SOFT_RING) {
} else {
ip1dbg(("ill_capability_dls_capable: asking interface %s "
}
sizeof (dl_capab_dls_t));
/*
* nmp points to a DL_CAPABILITY_REQ message to
* enable either soft_ring or polling
*/
}
static void
{
int size;
return;
ip1dbg(("ill_capability_dls_reset: unable to allocate "
"request to disable soft_ring\n"));
return;
}
else
else
else
}
/*
* 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
{
sub_dl_cap == DL_CAPAB_POLL);
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)
*/
"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.
*/
ip1dbg(("ill_capability_dls_ack: mid token for dls "
"capability isn't as expected; pass-thru "
"module(s) detected, discarding capability\n"));
/*
* 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.
*/
}
return;
}
default:
/* Disable if unknown flag */
case SOFT_RING_DISABLE:
case POLL_DISABLE:
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.
*/
break;
case SOFT_RING_ENABLE:
case POLL_ENABLE:
if (sub_dl_cap == DL_CAPAB_SOFT_RING &&
}
if (sub_dl_cap == DL_CAPAB_POLL &&
ip1dbg(("ill_capability_dls_ack: interface %s "
}
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
{
/*
* 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)
*/
"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)
*/
"unsupported hardware checksum "
"sub-capability (version %d, expected %d)",
return;
}
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 \
/* do ENABLE processing */
if (*ill_hcksum == NULL) {
if (*ill_hcksum == NULL) {
"could not enable hcksum version %d "
"for %s (ENOMEM)\n", HCKSUM_CURRENT_VERSION,
return;
}
}
ip1dbg(("ill_capability_hcksum_ack: interface %s "
"has enabled hardware checksumming\n ",
/*
* 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.
*/
size = sizeof (dl_capability_req_t) +
"could not enable hardware cksum for %s (ENOMEM)\n",
return;
}
/* initialize dl_capability_req_t */
sizeof (dl_capability_req_t);
sizeof (dl_capability_sub_t) +
/* initialize dl_capability_sub_t */
/* initialize dl_capab_hcksum_t */
/* Set ENABLE flag */
/*
* nmp points to a DL_CAPABILITY_REQ message to enable
* hardware checksum acceleration.
*/
} else {
ip1dbg(("ill_capability_hcksum_ack: interface %s has "
"advertised %x hardware checksum capability flags\n",
}
}
static void
{
int size;
if (!ILL_HCKSUM_CAPABLE(ill))
return;
/*
* 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.
*/
ip1dbg(("ill_capability_hcksum_reset: unable to allocate "
"request to disable hardware checksum offload\n"));
return;
}
hck_subcap->hcksum_txflags = 0;
else
}
static void
{
/*
* 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)
*/
"malformed sub-capability too long for mblk");
return;
}
"unsupported ZEROCOPY sub-capability (version %d, "
return;
}
ip1dbg(("ill_capability_zerocopy_ack: mid token for zerocopy "
"capability isn't as expected; pass-thru module(s) "
"detected, discarding capability\n"));
return;
}
if (*ill_zerocopy_capab == NULL) {
kmem_zalloc(sizeof (ill_zerocopy_capab_t),
if (*ill_zerocopy_capab == NULL) {
"could not enable Zero-copy version %d "
"for %s (ENOMEM)\n", ZEROCOPY_VERSION_1,
return;
}
}
ip1dbg(("ill_capability_zerocopy_ack: interface %s "
} else {
size = sizeof (dl_capability_req_t) +
sizeof (dl_capability_sub_t) +
sizeof (dl_capab_zerocopy_t);
"could not enable zerocopy for %s (ENOMEM)\n",
return;
}
/* initialize dl_capability_req_t */
sizeof (dl_capab_zerocopy_t);
rptr += sizeof (dl_capability_req_t);
/* initialize dl_capability_sub_t */
/* initialize dl_capab_zerocopy_t */
ip1dbg(("ill_capability_zerocopy_ack: asking interface %s "
/* set VMSAFE_MEM flag */
/* nmp points to a DL_CAPABILITY_REQ message to enable zcopy */
}
}
static void
{
int size;
return;
/*
* 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.
*/
ip1dbg(("ill_capability_zerocopy_reset: unable to allocate "
"request to disable Zero-copy\n"));
return;
}
else
}
/*
* Process Large Segment Offload capability negotiation ack received from a
* DLS Provider. isub must point to the sub-capability (DL_CAPAB_LSO) of a
* DL_CAPABILITY_ACK message.
*/
static void
{
/*
* 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)
*/
"malformed sub-capability too long for mblk");
return;
}
"unsupported LSO sub-capability (version %d, expected %d)",
return;
}
ip1dbg(("ill_capability_lso_ack: mid token for LSO "
"capability isn't as expected; pass-thru module(s) "
"detected, discarding capability\n"));
return;
}
if (*ill_lso_capab == NULL) {
if (*ill_lso_capab == NULL) {
"could not enable LSO version %d "
"for %s (ENOMEM)\n", LSO_VERSION_1,
return;
}
}
ip1dbg(("ill_capability_lso_ack: interface %s "
size = sizeof (dl_capability_req_t) +
sizeof (dl_capability_sub_t) + sizeof (dl_capab_lso_t);
"could not enable LSO for %s (ENOMEM)\n",
return;
}
/* initialize dl_capability_req_t */
sizeof (dl_capab_lso_t);
/* initialize dl_capability_sub_t */
/* initialize dl_capab_lso_t */
/* set ENABLE flag */
/* nmp points to a DL_CAPABILITY_REQ message to enable LSO */
} else {
ip1dbg(("ill_capability_lso_ack: interface %s has "
"advertised %x LSO capability flags\n",
}
}
static void
{
int size;
return;
/*
* Clear the capability flag for LSO but retain the
* ill_lso_capab structure since it's possible that another
* thread is still referring to it. The structure only gets
* deallocated when we destroy the ill.
*/
ip1dbg(("ill_capability_lso_reset: unable to allocate "
"request to disable LSO\n"));
return;
}
lso_subcap->lso_flags = 0;
else
}
/*
* Consume a new-style hardware capabilities negotiation ack.
* Called from ip_rput_dlpi_writer().
*/
void
{
if (capp->dl_sub_length == 0)
/* no new-style capabilities */
return;
/* make sure the driver supplied correct dl_sub_length */
ip0dbg(("ill_capability_ack: bad DL_CAPABILITY_ACK, "
return;
}
/*
* There are sub-capabilities. Process the ones we know about.
* Loop until we don't have room for another sub-cap header..
*/
case DL_CAPAB_ID_WRAPPER:
break;
default:
break;
}
}
}
/*
* 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 next_timeout = 0;
return (B_FALSE);
/* Walk the frag hash table. */
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.
*/
if (next_timeout == 0 ||
frag_timeout < next_timeout) {
}
break;
}
/* Time's up. Get it out of here. */
if (ipfnext)
/* Extra points for neatness. */
IP_REASS_SET_START(mp, 0);
IP_REASS_SET_END(mp, 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 (hdr_length != 0) {
} else {
}
} else {
if (hdr_length != 0) {
send_icmp_head = mp;
} else {
}
}
}
/*
* Now need to send any icmp messages that we delayed from
* above.
*/
while (send_icmp_head_v6 != NULL) {
else
} else {
}
}
while (send_icmp_head != NULL) {
mp = send_icmp_head;
else
} else {
ipst);
}
}
}
/*
* 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
{
/*
* 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.
*/
(ip_min_frag_prune_time != 0 ?
} else {
ill->ill_frag_free_num_pkts = 0;
}
/*
* free ill_frag_free_num_pkts oldest packets from each bucket.
*/
if (ill->ill_frag_free_num_pkts != 0) {
int ix;
}
}
}
/*
* 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.
*/
int ix;
count = 0;
}
}
/* Refresh the per ILL count */
ill->ill_frag_count = 0;
break;
}
return; /* Somebody beat us to it, nothing to do */
}
}
}
/*
* free 'free_cnt' fragmented packets starting at ipf.
*/
void
{
IP_REASS_SET_START(tmp, 0);
IP_REASS_SET_END(tmp, 0);
}
ipfb->ipfb_frag_pkts--;
}
if (ipf)
}
#define ND_FORWARD_WARNING "The <if>: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
{
return (0);
}
/*
* For obsolete per-interface forwarding configuration;
* called in response to ND_SET.
*/
/* ARGSUSED */
static int
{
long value;
int retval;
return (EINVAL);
}
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
{
return (EINVAL);
/*
* If the ill is in an IPMP group, set the forwarding policy on all
* members of the group to the same value.
*/
ip1dbg(("ill_forward_set: %s %s forwarding on %s",
if (enable)
else
/* Notify routing socket listeners of this change. */
}
} else {
ip1dbg(("ill_forward_set: %s %s forwarding on %s",
if (enable)
else
/* Notify routing socket listeners of this change. */
}
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
{
if (enable)
else
}
}
}
/*
* Given an ill with a _valid_ name, add the ip_forwarding ndd variable
* 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
{
char *suffix;
else
/*
* Copies over the '\0'.
* Note that strlen(suffix) is always bounded.
*/
/*
* Use of the nd table requires holding the reader lock.
* the writer lock.
*/
/*
* 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.
*/
return (ENOMEM);
}
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 *
{
/*
* setup the lists to search
*/
if (end_list != MAX_G_HEADS) {
} else {
ctx->ctx_current_list = 0;
}
/*
* ill is guaranteed to be non NULL or ifp should have
* not existed.
*/
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 *
{
return (ill);
}
/* goto next ill_ifp in the list. */
/* make sure not at end of circular list */
while (ifp ==
return (NULL);
}
}
/*
* 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)
{
while (len > 0) {
name--;
break;
len--;
}
/* empty string, all digits, or no trailing digits */
return (NULL);
name++;
/* check for attempted use of octal */
return (NULL);
return (name);
}
/*
* use avl tree to locate the ill.
*/
static ill_t *
{
int len;
int list;
*error = 0;
/*
* get ppa ptr
*/
if (isv6)
list = IP_V6_G_HEAD;
else
list = IP_V4_G_HEAD;
return (NULL);
}
/*
* match is done on len - 1 as the name is not null
* terminated it contains ppa in addition to the interface
* name.
*/
break;
} else {
}
}
/*
* Even the interface type does not exist.
*/
return (NULL);
}
/*
* The block comment at the start of ipif_down
* explains the use of the macros used below
*/
GRAB_CONN_LOCK(q);
if (ILL_CAN_LOOKUP(ill)) {
return (ill);
} else if (ILL_CAN_WAIT(ill, q)) {
*error = EINPROGRESS;
return (NULL);
}
}
return (NULL);
}
/*
* comparison function for use with avl.
*/
static int
{
/*
* We want the ill with the lowest ppa to be on the
* top.
*/
return (1);
return (-1);
return (0);
}
/*
* remove an interface type from the global list.
*/
static void
{
}
/* Defined in ip_netinfo.c */
extern ddi_taskq_t *eventq_queue_nic;
/*
* remove ill from the global list.
*/
static void
{
char *nicname;
return;
}
} else {
nicnamelen = 0;
}
/*
* If the ill was never inserted into the AVL tree
* we skip the if branch.
*/
/*
* remove from AVL tree and free ppa number
*/
}
}
/*
* Indicate ill is no longer in the list.
*/
ill->ill_name_length = 0;
}
/*
* Run the unplumb hook after the NIC has disappeared from being
* visible so that attempts to revalidate its existance will fail.
*
* This needs to be run inside the ill_g_lock perimeter to ensure
* that the ordering of delivered events to listeners matches the
* order of them in the kernel.
*/
ip2dbg(("ill_glist_delete: unexpected nic event %d "
} else {
== DDI_FAILURE) {
ip2dbg(("ill_glist_delete: ddi_taskq_dispatch "
"failed\n"));
info->hne_datalen);
}
}
}
} else {
ip2dbg(("ill_glist_delete: could not attach UNPLUMB nic event "
}
}
/*
* 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
{
int ppa;
/*
* Create an arena.
*/
/* allocate what has already been assigned */
1, /* size */
0, /* phase */
0, /* nocross */
if (ppa == 0) {
ip1dbg(("ill_alloc_ppa: ppa allocation"
" failed while switching"));
break;
}
}
}
if (ppa == 0)
return (EAGAIN);
} else {
1, /* size */
0, /* phase */
0, /* nocross */
/*
* 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.
*/
start = 0;
} else {
}
return (EAGAIN);
else
return (EEXIST);
}
}
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
{
avl_index_t where = 0;
int error;
int name_length;
int index;
if (isv6)
else
/*
* Search for interface type based on name
*/
break;
}
}
/*
* Interface type not found, create one.
*/
/*
* allocate ill_if_t structure
*/
if (ill_interface == NULL) {
return (ENOMEM);
}
ill_compare_ppa, sizeof (ill_t),
/*
* link the structure in the back to maintain order
* of configuration for ifconfig output.
*/
}
if (error != 0) {
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.
*/
/*
* convert ppa to string to calculate the amount of space
* required for it in the name.
*/
/* Do we have enough space to insert ppa ? */
/* Free ppa and interface type struct */
}
0) {
}
return (EINVAL);
}
}
&where);
return (0);
}
/* Initialize the per phyint (per IPMP group) ipsq used for serialization */
static boolean_t
{
/* Init the ipsq and impicitly enter as writer */
return (B_FALSE);
#ifdef ILL_DEBUG
#endif
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
{
int count;
/*
* 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.
*/
BPRI_HI);
return (ENOMEM);
/*
* Allocate sufficient space to contain our fragment hash table and
* the device name.
*/
return (ENOMEM);
}
ill->ill_frag_free_num_pkts = 0;
ill->ill_last_frag_clean_time = 0;
}
return (ENOMEM);
}
/*
* 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.
*/
return (ENOMEM);
}
/* Frag queue limit stuff */
ill->ill_frag_count = 0;
ill->ill_ipf_gen = 0;
/*
* 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_refcnt = 0;
/* Send down the Info Request to the driver. */
qprocson(q);
return (0);
}
/*
* ill_dls_info
* creates datalink socket info from the device.
*/
int
{
return (sizeof (struct sockaddr_dl));
}
/*
* ill_xarp_info
* creates xarp info from the device.
*/
static int
{
}
static int
{
netstack_t *ns;
return (EIO);
if (rw == KSTAT_WRITE)
return (EACCES);
return (-1);
return (-1);
}
return (0);
}
/*
* Has ifindex been plumbed already.
*/
static boolean_t
{
/*
* Indexes are stored in the phyint - a common structure
* to both IPv4 and IPv6.
*/
}
/*
* Assign a unique interface index for the phyint.
*/
static boolean_t
{
if (!ipst->ips_ill_index_wrap) {
if (ipst->ips_ill_index == 0) {
/* Reached the uint_t limit Next time wrap */
}
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.
*/
if (ipst->ips_ill_index != 0 &&
/* found unused index - use it */
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 *
{
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);
return (ill);
}
/* Create the loopback device on demand */
sizeof (ipif_loopback_name), BPRI_MED));
goto done;
/*
* For exclusive stacks we set the zoneid to zero
* to make IP operate as if in the global zone.
*/
goto done;
if (isv6)
else
/* Add room for tcp+ip headers */
if (isv6) {
} else {
}
if (!ill_allocate_mibs(ill))
goto done;
/*
* 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'.
*/
/* Set ill_name_set for ill_phyint_reinit to work properly */
/* No resolver here. */
/* Initialize the ipsq */
goto done;
#ifdef ILL_DEBUG
#endif
goto done;
/* Set up default loopback address and mask. */
if (!isv6) {
} else {
}
/*
* 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->ill_frag_count = 0;
ill->ill_frag_free_num_pkts = 0;
ill->ill_last_frag_clean_time = 0;
/* Let SCTP know so that it can add this to its list */
/*
* We have already assigned ipif_v6lcl_addr above, but we need to
* call sctp_update_ipif_addr() after SCTP_ILL_INSERT, which
* requires to be after ill_glist_insert() since we need the
* ill_index set. Pass on ipv6_loopback as the old address.
*/
/*
* If the ipsq was changed in ill_phyint_reinit free the old ipsq.
*/
/* Loopback ills aren't in any IPMP group */
}
/*
* 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.
*/
/* Export loopback interface statistics */
ipif_loopback_name, "net",
KSTAT_TYPE_NAMED, 2, 0,
}
}
*error = 0;
return (ill);
done:
}
}
}
return (NULL);
}
/*
* For IPP calls - use the ip_stack_t for global stack.
*/
ill_t *
{
return (NULL);
}
return (ill);
}
/*
* Return a pointer to the ill which matches the index and IP version type.
*/
ill_t *
{
*err = 0;
/*
* Indexes are stored in the phyint - a common structure
* to both IPv4 and IPv6.
*/
/*
* The block comment at the start of ipif_down
* explains the use of the macros used below
*/
GRAB_CONN_LOCK(q);
if (ILL_CAN_LOOKUP(ill)) {
return (ill);
} else if (ILL_CAN_WAIT(ill, q)) {
*err = EINPROGRESS;
return (NULL);
}
}
}
return (NULL);
}
/*
* Return the ifindex next in sequence after the passed in ifindex.
* If there is no next ifindex for the given protocol, return 0.
*/
{
if (index == 0) {
} else {
}
/*
* If we're not returning the first interface in the tree
* and we still haven't moved past the phyint_t that
* corresponds to index, avl_walk needs to be called again
*/
if (isv6) {
if ((phyi->phyint_illv6) &&
break;
} else {
if ((phyi->phyint_illv4) &&
break;
}
}
}
else
ifindex = 0;
return (ifindex);
}
/*
* Return the ifindex for the named interface.
* If there is no next ifindex for the interface, return 0.
*/
{
avl_index_t where = 0;
return (0);
}
return (ifindex);
}
/*
* 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->ill_refcnt++;
}
void
{
ill->ill_refcnt++;
}
int
{
if (ILL_CAN_LOOKUP(ill)) {
return (0);
}
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->ill_refcnt--;
if (ill->ill_refcnt != 0) {
/* Every ire pointing to the ill adds 1 to ill_refcnt */
return;
}
/* Drops the ill_lock */
}
/*
* 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.
*/
{
return (B_FALSE);
}
ill->ill_waiters++;
return (B_TRUE);
}
void
{
ill->ill_waiters--;
if (ill->ill_waiters == 0)
}
/*
* 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
{
ipst = CONNQ_TO_IPST(q);
(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 */
(void) mi_mpprintf(mp,
"%05u %05u %03d %s",
}
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
{
char buf1[INET6_ADDRSTRLEN];
char buf2[INET6_ADDRSTRLEN];
char buf3[INET6_ADDRSTRLEN];
char buf4[INET6_ADDRSTRLEN];
char buf5[INET6_ADDRSTRLEN];
char buf6[INET6_ADDRSTRLEN];
(void) mi_mpprintf(mp,
"\tlocal address\n"
"\tsrc address\n"
"\tsubnet\n"
"\tmask\n"
"\tbroadcast\n"
"\tp-p-dst");
if (zoneid != GLOBAL_ZONEID &&
continue;
(void) mi_mpprintf(mp,
"%04u %05u %u/%u/%u %s %d",
(void *)ipif,
ipif->ipif_zoneid);
/* Tack on text strings for any flags. */
nvp = ipif_nv_tbl;
}
(void) mi_mpprintf(mp,
"\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s",
}
}
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
{
/*
* Till the ill is fully up ILL_CHANGING will be set and
* the ill is not globally visible. So no need for a lock.
*/
}
/*
* When the new DLPI stuff is ready we'll pull lengths
* from dlia.
*/
if (brdcst_addr == NULL) {
brdcst_addr_length = 0;
}
ip1dbg(("ip: bcast_len %d, sap_len %d, phys_len %d\n",
} else {
brdcst_addr_length = 6;
sap_length = -2;
}
if (!ill->ill_dlpi_style_set) {
/*
* 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.
*/
return;
}
/*
* 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.
*/
else
/*
* 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.
*/
/*
* 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.
*/
/*
* Free ill_resolver_mp and ill_bcast_mp as things could have
* changed now.
*/
if (ill->ill_bcast_addr_length == 0) {
else
/*
* 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.
*/
else
if (ill->ill_phys_addr_length == 0) {
} else {
/* pt-pt supports multicast. */
}
}
} else {
/*
* Later detect lack of DLPI driver multicast
* capability by catching DL_ENABMULTI errors in
* ip_rput_dlpi.
*/
}
/* By default an interface does not support any CoS marking */
/*
* If we get QoS information in DL_INFO_ACK, the device supports
* some form of CoS marking, set ILLF_COS_ENABLED.
*/
}
/* Clear any previous error indication. */
}
/*
* Perform various checks to verify that an address would make sense as a
* local, remote, or subnet interface address.
*/
static boolean_t
{
/*
* Don't allow all zeroes, all ones or experimental address, but allow
* all ones netmask.
*/
return (B_FALSE);
/* A given netmask overrides the "guess" netmask */
if (subnet_mask != 0)
return (B_FALSE);
}
return (B_FALSE);
return (B_TRUE);
}
/*
* ipif_lookup_group
* Returns held ipif
*/
ipif_t *
{
return (NULL);
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 *
{
*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.
*/
GRAB_CONN_LOCK(q);
/* Allow the ipif to be down */
/*
* The block comment at the start of ipif_down
* explains the use of the macros used below
*/
if (IPIF_CAN_LOOKUP(ipif)) {
return (ipif);
} else if (IPIF_CAN_WAIT(ipif, q)) {
ill);
*error = EINPROGRESS;
return (NULL);
}
}
}
}
/* lookup the ipif based on interface address */
ipst);
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 *
{
*error = 0;
/*
* Repeat twice, first based on local addresses and
* next time for pointopoint.
*/
continue;
}
GRAB_CONN_LOCK(q);
continue;
/* Allow the ipif to be down */
/*
* The block comment at the start of ipif_down
* explains the use of the macros used below
*/
if (IPIF_CAN_LOOKUP(ipif)) {
return (ipif);
} else if (IPIF_CAN_WAIT(ipif, q)) {
ill);
*error = EINPROGRESS;
return (NULL);
}
}
}
}
/* If we already did the ptp case, then we are done */
if (ptp) {
return (NULL);
}
goto repeat;
}
/*
* 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.
* Return the zoneid for the ipif which matches. ALL_ZONES if no match.
*/
{
/*
* Repeat twice, first based on local addresses and
* next time for pointopoint.
*/
continue;
}
/* Allow the ipif to be down */
/*
* If ipif_zoneid was ALL_ZONES then we have
* a trusted extensions shared IP address.
* In that case GLOBAL_ZONEID works to send.
*/
return (zoneid);
}
}
}
/* If we already did the ptp case, then we are done */
if (ptp) {
return (ALL_ZONES);
}
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 *
{
/*
* Someone could be changing this ipif currently or change it
* after we return this. Thus a few packets could use the old
* 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.
*/
if (!IPIF_CAN_LOOKUP(ipif))
continue;
continue;
/* Allow the ipif to be down */
return (ipif);
}
return (ipif);
}
}
/*
* 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.
*/
return (ipif);
}
}
/* Pick the first interface */
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
*/
{
return (B_FALSE);
}
}
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
{
return (B_FALSE);
}
ill->ill_logical_down) {
return (B_TRUE);
}
/* This is the last ipif going down or being deleted on this ill */
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
*/
static ipif_t *
{
return (ipif);
}
}
}
return (NULL);
}
/*
* Determine if the ipif or ill in question has become quiescent and if so
* for the ipif_down (or ill_down)
*/
void
{
ill_is_quiescent(ill)) {
/* ill_close may be waiting */
}
/* ipsq can't change because ill_lock is held */
if (ipsq->ipsq_waitfor == 0) {
/* Not waiting for anything, just return. */
return;
}
/*
* 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.
*/
/* The ioctl is pending on some other ill. */
return;
}
switch (ipsq->ipsq_waitfor) {
case IPIF_DOWN:
case IPIF_FREE:
if (!ipif_is_quiescent(ipif)) {
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)) {
return;
}
break;
case ILL_MOVE_OK:
return;
}
break;
default:
}
/*
* Incr refcnt for the qwriter_ip call below which
* does a refrele
*/
case M_PCPROTO:
case M_PROTO:
/*
* For now, only DL_NOTIFY_IND messages can use this facility.
*/
switch (dlindp->dl_notification) {
case DL_NOTE_PHYS_ADDR:
return;
default:
ASSERT(0);
}
break;
case M_ERROR:
case M_HANGUP:
return;
case M_IOCTL:
case M_IOCDATA:
return;
default:
}
}
#ifdef ILL_DEBUG
/* Reuse trace buffer from beginning (if reached the end) and record trace */
void
{
lastref++;
if (lastref == TR_BUF_MAX)
lastref = 0;
}
{
int bucket_id;
return (th_trace);
}
return (NULL);
}
void
{
int bucket_id;
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
*/
return;
}
}
}
void
{
if (ipif->ipif_trace_disable)
return;
}
{
int bucket_id;
return (th_trace);
}
return (NULL);
}
void
{
int bucket_id;
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
*/
return;
}
}
}
void
{
if (ill->ill_trace_disable)
return;
}
/*
* Verify that this thread has no refs to the ipif and free
* the trace buffers
*/
/* ARGSUSED */
void
{
return;
}
/* unlink th_trace and free it */
}
/*
* Verify that this thread has no refs to the ill and free
* the trace buffers
*/
/* ARGSUSED */
void
{
return;
}
/* unlink th_trace and free it */
}
#endif
#ifdef ILL_DEBUG
void
{
}
}
}
/*
* Called when ipif is unplumbed or when memory alloc fails
*/
void
{
int i;
for (i = 0; i < IP_TR_HASH_MAX; i++) {
th_trace = th_trace_next) {
}
}
}
/*
* Called when ill is unplumbed or when memory alloc fails
*/
void
{
int i;
for (i = 0; i < IP_TR_HASH_MAX; i++) {
th_trace = th_trace_next) {
}
}
}
#else
void ip_thread_exit(void) {}
#endif
void
{
ipif->ipif_refcnt++;
}
void
{
ipif->ipif_refcnt++;
}
/*
* 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->ipif_refcnt--;
if (ipif->ipif_refcnt != 0) {
return;
}
/* Drops the ill_lock */
}
ipif_t *
{
if (!IPIF_CAN_LOOKUP(ipif))
continue;
return (ipif);
}
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 *
{
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
{
int match_flags = MATCH_IRE_TYPE;
int error;
ip1dbg(("ip_rt_add:"));
/*
* If this is the case of RTF_HOST being set, then we set the netmask
* to all ones (regardless if one was supplied).
*/
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.
*/
return (ENETUNREACH);
/*
* Get the ipif, if any, corresponding to the gw_addr
*/
if (gw_addr != 0) {
return (EINVAL);
}
} else if (error == EINPROGRESS) {
ip1dbg(("ip_rt_add: null and EINPROGRESS"));
return (EINPROGRESS);
} else {
error = 0;
}
}
ip1dbg(("ip_rt_add: ipif_lookup_interface done ipif nonnull"));
} 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.
*/
flags &= ~RTF_GATEWAY;
mask == IP_HOST_MASK) {
if (ipif_refheld)
return (EEXIST);
}
ip1dbg(("ipif_up_done: 0x%p creating IRE 0x%x"
"for 0x%x\n", (void *)ipif,
ire = ire_create(
NULL, /* no gateway */
NULL,
NULL,
NULL, /* no send-to queue */
NULL,
ipif,
NULL,
0,
0,
0,
RTF_PRIVATE : 0,
NULL,
NULL,
ipst);
if (ipif_refheld)
return (ENOMEM);
}
if (error == 0)
goto save_ire;
if (ipif_refheld)
return (error);
}
}
/*
* 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)) {
ip2dbg(("ip_rt_add: gateway security attributes "
"cannot be set with interface route\n"));
if (ipif_refheld)
return (EINVAL);
}
/*
* 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_refheld) {
}
} else {
/*
* Check the ipif corresponding to the gw_addr
*/
return (ENETUNREACH);
}
/*
* If src_ipif is not NULL, we have to create
* an ire with non-null ire_in_ill value
*/
}
/*
* 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)
/* Look up in the special table */
} else {
}
if (ipif_refheld)
return (EEXIST);
}
/*
* 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.
*/
}
/* Create the usual interface ires */
/*
* Create a copy of the IRE_LOOPBACK,
* IRE_IF_NORESOLVER or IRE_IF_RESOLVER with
* the modified address and netmask.
*/
ire = ire_create(
NULL,
NULL,
NULL,
rfq,
stq,
ipif,
0,
0,
0,
NULL,
NULL,
ipst);
if (ipif_refheld)
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 (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)
return (error);
}
if (ipif_refheld) {
}
/* 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.
*/
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)
else if (mask == 0)
type = IRE_DEFAULT;
else
type = IRE_PREFIX;
/* check for a duplicate entry */
return (EEXIST);
}
/* Security attribute exists */
/* find or create the gateway credentials group */
/* we hold reference to it upon success */
return (ENOMEM);
}
/*
* Create and add the security attribute to the group; a
* reference to the group is made upon allocating a new
* entry successfully. If it finds an already-existing
* entry for the security attribute in the group, it simply
* returns it and no new reference is made to the group.
*/
/* release reference held by gcgrp_lookup */
return (ENOMEM);
}
}
/* Create the IRE. */
ire = ire_create(
/* src address assigned by the caller? */
NULL, /* no in-srcaddress */
NULL, /* no Fast Path header */
NULL, /* no recv-from queue */
NULL, /* no send-to queue */
NULL,
NULL,
0,
0,
0,
gc, /* security attribute */
NULL,
ipst);
/*
* The ire holds a reference to the 'gc' and the 'gc' holds a
* reference to the 'gcgrp'. We can now release the extra reference
* the 'gcgrp' acquired in the gcgrp_lookup, if it was not used.
*/
if (gcgrp_xtraref)
GC_REFRELE(gc);
return (ENOMEM);
}
/*
* POLICY: should we allow an RTF_HOST with address INADDR_ANY?
*/
/* Add the new IRE. */
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.
*/
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.
*/
goto save_ire;
}
if (res != 0) {
return (res);
}
}
}
/*
* Now that the prefix IRE entry has been created, delete any
* existing gateway IRE cache entries as well as any IRE caches
* using the gateway, and force them to be created through
* ip_newroute.
*/
}
}
/*
* 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.
*/
/*
* 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.
*/
}
if (ioctl_msg)
/*
* 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).
*/
} else {
}
if (ipif_refheld)
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
{
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.
*/
mask = IP_HOST_MASK;
} else if (rtm_addrs & RTA_NETMASK) {
}
/*
* 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
* succeed.
*/
}
return (err);
}
} else {
else if (err == EINPROGRESS)
return (err);
else
err = 0;
}
if (ipif_refheld) {
}
} else {
}
} else {
match_flags, ipst);
}
}
}
}
/*
* 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 (ipif_refheld)
return (ESRCH);
} else {
if (mask == IP_HOST_MASK)
else if (mask == 0)
type = IRE_DEFAULT;
else
type = IRE_PREFIX;
ipst);
}
}
if (ipif_refheld)
/* ipif is not refheld anymore */
return (ESRCH);
/*
* 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 &&
}
}
/*
* 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 (ioctl_msg)
return (err);
}
/*
* ip_siocaddrt is called to complete processing of an SIOCADDRT IOCTL.
*/
/* ARGSUSED */
int
{
int error = 0;
ipst = CONNQ_TO_IPST(q);
ip1dbg(("ip_siocaddrt:"));
/* Existence of mp1 verified in ip_wput_nondata */
/*
* 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.
*/
mask = IP_HOST_MASK;
} else {
/*
* Note that ip_subnet_mask returns a zero mask in the case of
* default (an all-zeroes address).
*/
}
return (error);
}
/*
* ip_siocdelrt is called to complete processing of an SIOCDELRT IOCTL.
*/
/* ARGSUSED */
int
{
int error;
ipst = CONNQ_TO_IPST(q);
ip1dbg(("ip_siocdelrt:"));
/* Existence of mp1 verified in ip_wput_nondata */
/*
* 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.
*/
mask = IP_HOST_MASK;
} else {
/*
* Note that ip_subnet_mask returns a zero mask in the case of
* default (an all-zeroes address).
*/
}
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
{
switch (type) {
case CUR_OP:
} else {
}
break;
case NEW_OP:
} else {
}
break;
default:
}
}
}
/*
* 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 *
{
return (mp);
}
return (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
{
/*
* Holding the ill_lock prevents <ill-ipsq> assocs from changing.
* Since the <ill-ipsq> 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.
*/
for (;;) {
return (B_FALSE);
}
break;
} else {
if (force) {
continue;
} else {
}
}
}
ipsq->ipsq_reentry_cnt++;
#ifdef ILL_DEBUG
#endif
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),
* 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
* 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 *
{
/* Only 1 of ipif or ill can be specified */
/*
* 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);
/*
* 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
*/
/* Success. */
ipsq->ipsq_reentry_cnt++;
#ifdef ILL_DEBUG
#endif
return (ipsq);
}
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.
*
*/
void
{
/*
* 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.
*/
else
}
}
/*
* 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
{
queue_t *q;
int next;
size_t ill_list_size = 0;
int cnt = 0;
ipsq->ipsq_reentry_cnt--;
return;
}
/*
* 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'.
*/
}
/*
* 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 <ill-ipsq> we need
* to grab ill_g_lock as writer.
*/
/* ipsq_refs can't change while ill_g_lock is held as reader */
/*
* 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.
*/
}
/* oops, some message has landed up, we can't get out */
ill_list_size = 0;
cnt = 0;
goto again;
}
/*
* Split only if no ioctl is pending and if memory alloc succeeded
* above.
*/
/*
* 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.
*/
}
/*
* 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_reentry_cnt--;
#ifdef ILL_DEBUG
ipsq->ipsq_depth = 0;
#endif
/*
* 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
*/
if (ill_list != 0)
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
*/
}
/*
* 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
* 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) {
}
if (start_mld_timer) {
}
}
/*
* Start the current exclusive operation on `ipsq'; associate it with `ipif'
* and `ioccmd'.
*/
void
{
}
/*
* Finish the current exclusive operation on `ipsq'. Note that other
* operations will not be able to proceed until an ipsq_exit() is done.
*/
void
{
/*
* For SIOCSLIFREMOVEIF, the ipif has been already been blown away
* (but we're careful to never set IPIF_CHANGING in that case).
*/
/*
* Unhook the nic event message from the ill and enqueue it
* into the nic event taskq.
*/
ip2dbg(("ipsq_current_finish: "
"ddi_taskq_dispatch failed\n"));
info->hne_datalen);
}
}
}
ipsq->ipsq_current_ioctl = 0;
}
/*
* 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
{
queue_t *q;
/*
* Flush any messages sent up by the driver.
*/
/* Remove the mp from the ipsq */
else
}
} else {
}
}
}
/*
* 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
{
/* Just clean one squeue */
/*
* Reset the ILL_SOFT_RING_ASSIGN bit so that
* ip_squeue_soft_ring_affinty() will not go
* ahead with assigning rings.
*/
/* Some operations pending on the ring. Wait */
/*
* Someone already trying to clean
* this squeue or its already been cleaned.
*/
return;
}
/*
* 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.
*/
return;
}
/* Set the state that its being cleaned */
/*
* Use the preallocated ill_unbind_conn for this purpose
*/
else
}
static void
{
int idx;
/*
* No need to clean if poll_capab isn't set for this ill
*/
return;
}
}
/* ARGSUSED */
int
{
/*
* 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.
*/
return (EINVAL);
}
/*
* The new original index must be in use by some
* physical interface.
*/
return (ENXIO);
/*
* 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) {
}
}
}
return (0);
}
/* ARGSUSED */
int
{
/*
* Get the original interface index i.e the one
* before FAILOVER if it ever happened.
*/
return (0);
}
/*
* Parse an iftun_req structure coming down SIOC[GS]TUNPARAM ioctls,
* refhold and return the associated ipif
*/
int
{
int error;
/* Existence verified in ip_wput_nondata */
/*
* Null terminate the string to protect against buffer
* overrun. String was generated by user code and may not
* be trusted.
*/
/* Disallows implicit create */
return (error);
/*
* on virtual tunnel interfaces. Only allow the
* base tunnel to do these.
*/
return (EINVAL);
}
/*
* Send down to tunnel mod for ioctl processing.
* Will finish ioctl in ip_rput_other().
*/
return (EOPNOTSUPP);
}
return (ENXIO);
}
/*
* Mark the ioctl as coming from an IPv6 interface for
* tun's convenience.
*/
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
{
char *name;
int err;
} else {
if (zoneid == GLOBAL_ZONEID) {
/* global zone can access ipifs in all zones */
}
}
/* Has been checked in ip_wput_nondata */
/* This a old style SIOC[GS]IF* command */
/*
* Null terminate the string to protect against buffer
* overrun. String was generated by user code and may not
* be trusted.
*/
} else {
/* This a new style SIOC[GS]LIF* command */
/*
* Null terminate the string to protect against buffer
* overrun. String was generated by user code and may not
* be trusted.
*/
}
}
/*
* The ioctl will be failed if the ioctl comes down
* an conn stream
*/
/*
* Not an ill queue, return EINVAL same as the
* old error code.
*/
return (ENXIO);
}
} else {
ipst);
if (err == EINPROGRESS)
return (err);
/*
* 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.
*/
if (err == EINPROGRESS)
return (err);
}
err = 0; /* Ensure we don't use it below */
}
}
/*
* Old style [GS]IFCMD does not admit IPv6 ipif
*/
return (ENXIO);
}
name[0] == '\0') {
/*
* Handle a or a SIOC?IF* with a null name
* during plumb (on the ill queue before the I_PLINK).
*/
}
return (ENXIO);
/*
* Allow only GET operations if this ipif has been created
* temporarily due to a MOVE operation.
*/
return (EINVAL);
}
return (0);
}
/*
* Return the total number of ipifs.
*/
static uint_t
{
numifs++;
}
}
return (numifs);
}
/*
* Return the total number of ipifs.
*/
static uint_t
{
else
!(lifn_flags & LIFC_NOXMIT))
continue;
!(lifn_flags & LIFC_TEMPORARY))
continue;
if (((ipif->ipif_flags &
IPIF_DEPRECATED)) ||
PHYI_LOOPBACK) ||
continue;
(zoneid != GLOBAL_ZONEID ||
!(lifn_flags & LIFC_ALLZONES)))
continue;
numifs++;
}
}
return (numifs);
}
{
/*
* 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
*/
if ((ill->ill_usesrc_ifindex == 0) &&
numifs++;
}
return (numifs);
}
/* Null values are passed in for ipif, sin, and ifreq */
/* ARGSUSED */
int
{
int *nump;
/* Existence of b_cont->b_cont checked in ip_wput_nondata */
return (0);
}
/* Null values are passed in for ipif, sin, and ifreq */
/* ARGSUSED */
int
{
/* Existence checked in ip_wput_nondata */
switch (lifn->lifn_family) {
case AF_UNSPEC:
case AF_INET:
case AF_INET6:
break;
default:
return (EAFNOSUPPORT);
}
return (0);
}
/* ARGSUSED */
int
{
struct sockaddr_in *sin;
ip1dbg(("ip_sioctl_get_ifconf"));
/* Existence verified in ip_wput_nondata */
/*
* 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...
*
*/
int numifs = 0;
/*
* Must be (better be!) continuation of a TRANSPARENT
* IOCTL. We just copied in the ifconf structure.
*/
/*
* 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...
*/
if (ifc_bufsize > ifclen) {
/* old behaviour */
return (EINVAL);
} else {
}
}
return (ENOMEM);
}
/*
* 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)
*/
continue;
/* old behaviour */
return (EINVAL);
} else {
goto if_copydone;
}
}
(void) ipif_get_name(ipif,
ifr++;
}
}
}
return (0);
}
/*
* Get the interfaces using the address hosted on the interface passed in,
* as a source adddress
*/
/* ARGSUSED */
int
{
int numlifs = 0;
int err = 0;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
ipst = CONNQ_TO_IPST(q);
/* Existence verified in ip_wput_nondata */
/*
* Must be (better be!) continuation of a TRANSPARENT
* IOCTL. We just copied in the lifsrcof structure.
*/
return (EINVAL);
ip1dbg(("ip_sioctl_get_lifsrcof: no ipif for ifindex %d\n",
ifindex));
return (err);
}
/* Allocate a buffer to hold requested information */
/* The actual size needed is always returned in lifs_len */
/* If the amount we need is more than what is passed in, abort */
return (0);
}
return (ENOMEM);
}
/* ill_g_usesrc_lock protects ill_usesrc_grp_next */
break;
(void) ipif_get_name(ipif,
&ipif->ipif_v6net_mask);
} else {
}
lifr++;
}
return (0);
}
/* ARGSUSED */
int
{
int list;
int flags;
int numlifs = 0;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
ip1dbg(("ip_sioctl_get_lifconf"));
/* Existence verified in ip_wput_nondata */
/*
* 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.
*/
return (EINVAL);
/*
* Must be (better be!) continuation of a TRANSPARENT
* IOCTL. We just copied in the lifconf structure.
*/
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.
*/
if (lifc_bufsize > lifclen) {
return (EINVAL);
else
}
return (ENOMEM);
!(flags & LIFC_NOXMIT))
continue;
!(flags & LIFC_TEMPORARY))
continue;
if (((ipif->ipif_flags &
IPIF_DEPRECATED)) ||
PHYI_LOOPBACK) ||
continue;
(zoneid != GLOBAL_ZONEID ||
!(flags & LIFC_ALLZONES)))
continue;
return (EINVAL);
} else {
goto lif_copydone;
}
}
(void) ipif_get_name(ipif,
lifr->lifr_addrlen =
&ipif->ipif_v6net_mask);
} else {
lifr->lifr_addrlen =
}
lifr++;
}
}
}
return (0);
}
/* ARGSUSED */
int
{
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
/* Existence of b_cont->b_cont checked in ip_wput_nondata */
return (0);
}
static void
{
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
/* These two ioctls are I_STR only */
return;
}
/* The user passed us a NULL argument */
} 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.
*/
NULL) {
return;
}
}
}
case SIOCGIP6ADDRPOLICY:
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 "||" */
for (i = 1; i < count; i++)
}
#endif
break;
case SIOCSIP6ADDRPOLICY:
/*
* 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
return;
}
}
static void
{
struct dstinforeq *dir;
int match_ire;
/*
* This ioctl is I_STR only, and must have a
* data mblk following the M_IOCTL mblk.
*/
return;
}
return;
}
}
cur += sizeof (struct dstinforeq)) {
/*
* ip_addr_scope_v6() and ip6_asp_lookup() handle
* v4 mapped addresses; ire_ftable_lookup[_v6]()
* and ipif_select_source[_v6]() do not.
*/
if (isipv4) {
} else {
}
dir->dir_dreachable = 0;
/* move on to next dst addr */
continue;
}
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.
*/
if (isipv4) {
} else {
zoneid);
}
goto next_dst;
}
}
/*
* 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
* may be used.
*/
/* ARGSUSED */
int
{
struct sioc_addrreq *sia;
ip1dbg(("ip_sioctl_tmyaddr"));
ipst = CONNQ_TO_IPST(q);
/* Existence verified in ip_wput_nondata */
switch (sin->sin_family) {
case AF_INET6: {
v4_addr);
} else {
}
break;
}
case AF_INET: {
break;
}
default:
return (EAFNOSUPPORT);
}
} else {
}
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
* may be used.
*/
/* ARGSUSED */
int
{
struct sioc_addrreq *sia;
ip1dbg(("ip_sioctl_tonlink"));
ipst = CONNQ_TO_IPST(q);
/* Existence verified in ip_wput_nondata */
/*
* 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: {
v4_addr);
MATCH_IRE_GW, ipst);
}
} else {
if (!IN6_IS_ADDR_MULTICAST(&v6addr)) {
}
}
break;
}
case AF_INET: {
MATCH_IRE_GW, ipst);
}
break;
}
default:
return (EAFNOSUPPORT);
}
}
}
return (0);
}
/*
* TBD: implement when kernel maintaines a list of site prefixes.
*/
/* ARGSUSED */
int
{
return (ENXIO);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_tunparam(%s:%u %p)\n",
/* ioctl comes down on an conn */
/*
* 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
* will panic a DEBUG kernel.
*/
return (ENOMEM);
mp, 0);
} else {
}
if (success) {
ip1dbg(("sending down tunparam request "));
return (EINPROGRESS);
} else {
/* The conn has started closing */
return (EINTR);
}
}
static int
{
char *lladdr;
/*
* ill has already been set depending on whether
* bsd style or interface style ioctl.
*/
/*
* Is this one of the new SIOC*XARP ioctls?
*/
if (x_arp_ioctl) {
/* We have a chain - M_IOCTL-->MI_COPY_MBLK-->XARPREQ_MBLK */
/*
* Validate against user's link layer address length
* input and name and addr length limits.
*/
return (EINVAL);
}
} else {
/* We have a chain - M_IOCTL-->MI_COPY_MBLK-->ARPREQ_MBLK */
/*
* 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
* operation will succeed.
*/
alength = 6;
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.
*/
if (pending_mp != NULL)
return (ENOMEM);
}
return (ENOMEM);
}
/* Put together the chain. */
/*
* 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.
*/
/*
* Set the proper command in the ARP message.
* Convert the SIOC{G|S|D}ARP calls into our
* AR_ENTRY_xxx calls.
*/
case SIOCDARP:
case SIOCDXARP:
/*
* We defer deleting the corresponding IRE until
* we return from arp.
*/
area->area_proto_mask_offset = 0;
break;
case SIOCGARP:
case SIOCGXARP:
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) {
break;
} else {
ipst);
}
break;
}
}
}
/*
* 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.
*/
/* conn has not yet started closing, hence this can't fail */
/*
* Fill in the rest of the ARP operation fields.
*/
/* Translate the flags. */
if (flags & ATF_AUTHORITY)
/*
* 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.
*/
return (EINPROGRESS);
}
/* ARGSUSED */
int
{
int err;
int ifnamelen;
struct sockaddr_in *sin;
/* ioctl comes down on an conn */
/* Existance verified in ip_wput_nondata */
return (ENXIO);
if (ifnamelen != 0) {
return (EINVAL);
/*
* Instead of bcopying a bunch of bytes,
* null-terminate the string in-situ.
*/
*cptr = '\0';
return (err);
return (ENXIO);
}
} 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.
*/
ipst);
return (ENXIO);
}
}
}
if (if_arp_ioctl)
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
{
struct sockaddr_in *sin;
int err;
/* ioctl comes down on an conn */
ipst = CONNQ_TO_IPST(q);
if (isv6)
return (ENXIO);
/* Existance verified in ip_wput_nondata */
/*
* 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.
*/
return (ENXIO);
}
}
return (err);
}
/*
* 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
{
char *name;
int err = 0;
if (CONN_Q(q))
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
/*
* 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
* stream. SIOCSLIFMUXID is not required. See ifconfig.c, arp.c
* and other comments in this routine for more details.
*/
/*
* 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.
*/
/*
* 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.
*/
break;
}
}
/*
* This looks like an IP module stream, so trigger
* the capability reset or re-negotiation if necessary.
*/
return;
}
/*
* 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_cnt = 0;
ill->ill_lmod_cnt++;
}
}
/*
* 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)
else
}
}
goto done;
}
/*
* This is an I_{P}LINK sent down by ifconfig on
* 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.
*/
if (ipmxp->ipmx_arpdev_stream) {
/*
* The operation is occuring on the arp-device
* stream.
*/
if (err == EINPROGRESS) {
return;
} else {
goto done;
}
}
return;
}
}
/*
* To ensure consistency between IP and ARP,
* the following LIFO scheme is used in
* 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 &&
(!islink &&
goto done;
}
if (islink) {
} 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.
*/
break;
}
}
return;
}
/*
* 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.
*/
goto done;
}
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.
*/
ill->ill_lmod_cnt++;
}
}
} else {
ill->ill_ip_muxid = 0;
}
/*
* negotiating driver sub-capabilities.
*/
if (ill->ill_ipif_up_count > 0) {
if (islink)
else
}
}
}
done:
if (err == 0)
else
/* Conn was refheld in ip_sioctl_copyin_setup */
if (CONN_Q(q))
if (entered_ipsq)
}
/*
* 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_sioctl_lookup(int ioc_cmd)
{
int index;
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.
*/
if (index < ip_ndx_ioctl_count) {
/* Found a match in the ndx table */
return (ipip);
}
}
/* Search the misc table */
/* 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
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
{
int copyin_size;
if (CONN_Q(q))
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
/*
* 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.
*/
goto nak;
} else {
return;
}
}
/*
* If this is deferred, then we will do all the checks when we
* come back.
*/
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).
*/
/*
* Pass common Streams ioctls which the IP
* module does not own or consume along to
* be processed down stream.
*/
return;
} else {
goto nak;
}
}
/* Make sure we have ioctl data to process. */
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).
*/
/* Make sure normal users don't send down privileged ioctls */
/* We checked the privilege earlier but log it here */
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) {
return;
}
case O_SIOCGIFCONF:
case SIOCGIFCONF:
/*
* This IOCTL is hilarious. See comments in
* ip_sioctl_get_ifconf for the story.
*/
else
return;
case O_SIOCGLIFCONF:
case SIOCGLIFCONF:
return;
case SIOCGLIFSRCOF:
return;
case SIOCGIP6ADDRPOLICY:
return;
case SIOCSIP6ADDRPOLICY:
return;
case SIOCGDSTINFO:
ip_sioctl_dstinfo(q, mp);
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));
return;
case ND_GET:
case ND_SET:
/*
* Use of the nd table requires holding the reader lock.
* the writer lock.
*/
return;
}
/*
* We don't understand this subioctl of ND_GET / ND_SET.
* Maybe intended for some driver / module below us
*/
if (q->q_next) {
} else {
}
return;
case IP_IOCTL:
ip_wput_ioctl(q, mp);
return;
default:
}
nak:
}
}
/* ip_wput hands off ARP IOCTL responses to us */
void
{
int *flagsp;
int err;
/*
* 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
*/
return;
}
} else {
}
/*
* Pick out the originating queue based on the ioc_id.
*/
if (pending_mp == NULL) {
return;
}
q = CONNP_TO_WQ(connp);
/* Uncouple the internally generated IOCTL from the original one */
/*
* 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.
*/
/*
* 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.
*/
int addr_len;
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.
*/
} else {
}
/*
* Since the ire obtained from cachetable is used for
* mac addr copying below, treat an incomplete ire as if
* as if we never found it.
*/
goto errack;
}
if (x_arp_ioctl && ((addr_len +
return;
}
if (ipsqill->ill_sap_length < 0)
else
/*
* 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.
*/
}
/* Ditch the internal IOCTL. */
return;
}
}
/*
* Delete the coresponding IRE_CACHE if any.
* Reset the error if there was one (in case there was no entry
* in arp.)
*/
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.
*/
}
/*
* 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)
else
}
}
return;
}
/*
* Completion of an SIOCG{X}ARP. Translate the information from
* the area_t into the struct {x}arpreq.
*/
if (x_arp_ioctl) {
NULL);
return;
}
}
*flagsp |= ATF_AUTHORITY;
if (area->area_hw_addr_length != 0) {
/*
* 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.
*/
}
/* Ditch the internal IOCTL. */
/* Complete the original. */
}
/*
* 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
{
char *name;
char *endp;
char *cp;
int namelen;
long id;
int err = 0;
int orig_ifindex = 0;
ip1dbg(("ip_sioctl_addif\n"));
/* Existence of mp1 has been checked in ip_wput_nondata */
/*
* Null terminate the string to protect against buffer
* overrun. String was generated by user code and may not
* be trusted.
*/
if (namelen == 0)
return (EINVAL);
/*
* 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.
*/
/* Prevent any further action */
return (ENOBUFS);
} else if (!exists) {
/* We created the ipif now and as writer */
return (0);
} else {
}
} else {
/* Look for a colon in the name. */
if (*cp == IPIF_SEPARATOR_CHAR) {
/*
* 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.
*/
return (EINVAL);
return (EINVAL);
}
*cp = '\0';
break;
}
}
if (found_sep)
return (err);
}
B_TRUE);
/*
* Release the refhold due to the lookup, now that we are excl
* or we are just returning
*/
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.
*/
/*
* 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.
*/
if (phyi->phyint_groupname_len == 0)
continue;
!(phyi->phyint_flags &
break;
}
}
phyi->phyint_illv4);
}
}
/*
* We are now exclusive on the ipsq, so an ill move will be serialized
* before or after us.
*/
if (found_sep && orig_ifindex == 0) {
/* Now see if there is an IPIF with this unit number. */
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.
*/
goto done;
}
/* Return created name with ioctl */
/* Set address */
}
/* Set ifindex and unit number for failback */
if (err == 0 && orig_ifindex != 0) {
if (found_sep) {
}
}
done:
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
{
ipst = CONNQ_TO_IPST(q);
ip1dbg(("ip_sioctl_remove_if(%s:%u %p)\n",
/*
* 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).
*/
/*
* Mark it condemned. No new ref. will be made to ill.
*/
}
/* unplumb the loopback interface */
/* Are any references to this ill active */
if (ill_is_quiescent(ill)) {
return (0);
}
if (success)
return (EINPROGRESS);
else
return (EINTR);
}
}
/*
* We are exclusive on the ipsq, so an ill move will be serialized
* before or after us.
*/
/* Find based on address */
return (EAFNOSUPPORT);
/* We are a writer, so we should be able to lookup */
/*
* Maybe the address in on another interface in
* the same IPMP group? We check this below.
*/
ipst);
}
} else {
return (EAFNOSUPPORT);
/* We are a writer, so we should be able to lookup */
/*
* Maybe the address in on another interface in
* the same IPMP group? We check this below.
*/
}
}
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.
*/
return (EADDRNOTAVAIL);
}
/* This is a writer */
}
/*
* Can not delete instance zero since it is tied to the ill.
*/
return (EBUSY);
/* Are any references to this ipif active */
return (0);
}
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
{
ip1dbg(("ip_sioctl_removeif_restart(%s:%u %p)\n",
return (0);
}
return (0);
}
/*
* Set the local interface address.
* Allow an address of all zero when the interface is down.
*/
/* ARGSUSED */
int
{
int err = 0;
ip1dbg(("ip_sioctl_addr(%s:%u %p)\n",
return (EAFNOSUPPORT);
/*
* Enforce that true multicast interfaces have a link-local
* address for logical unit 0.
*/
!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.
*/
return (EADDRNOTAVAIL);
}
return (EADDRNOTAVAIL);
} else {
return (EAFNOSUPPORT);
/* Allow 0 as the local address. */
return (EADDRNOTAVAIL);
}
/*
* Even if there is no change we redo things just to rerun
* ipif_set_default.
*/
/*
* Setting a new local address, make sure
* we have net and subnet bcast ire's for
* the old address if we need them.
*/
/*
* 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.
*/
if (err == EINPROGRESS)
return (err);
need_up = 1;
}
return (err);
}
int
{
int sinlen;
int err = 0;
ip1dbg(("ip_sioctl_addr_tail(%s:%u %p)\n",
/* Must cancel any pending timer before taking the ill_lock */
if (ipif->ipif_recovery_id != 0)
ipif->ipif_recovery_id = 0;
sinlen = sizeof (struct sockaddr_in6);
} else {
sinlen = sizeof (struct sockaddr_in);
}
} else {
}
ipif->ipif_addr_ready = 0;
/*
* If the interface was previously marked as a duplicate, then since
* we've now got a "new" address, it should no longer be considered a
* duplicate -- even if the "new" address is the same as the old one.
* Note that if all ipifs are down, we may have a pending ARP down
* event to handle. This is because we want to recover from duplicates
* and thus delay tearing down ARP until the duplicates have been
* removed or disabled.
*/
need_arp_down = !need_up;
}
}
!ill->ill_is_6to4tun) {
/*
* 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.
*/
== TUN6TO4_MODID) {
/* set for use in IP */
break;
}
}
}
}
/*
* When publishing an interface address change event, we only notify
* the event listeners of the new address. It is assumed that if they
* actively care about the addresses assigned that they will have
* already discovered the previous address assigned (if there was one.)
*
* Don't attach nic event message for SIOCLIFADDIF ioctl.
*/
ip2dbg(("ip_sioctl_addr_tail: unexpected nic event %d "
}
} else {
ip2dbg(("ip_sioctl_addr_tail: could not attach "
"address information for ADDRESS_CHANGE nic"
" event of %s (ENOMEM)\n",
}
} else
ip2dbg(("ip_sioctl_addr_tail: could not attach "
"ADDRESS_CHANGE nic event information for %s "
}
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.
*/
}
if (need_dl_down)
if (need_arp_down)
return (err);
}
/*
* Restart entry point to restart the address set operation after the
* refcounts have dropped to zero.
*/
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_addr_restart(%s:%u %p)\n",
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_addr(%s:%u %p)\n",
/*
* The net mask and address can't change since we have a
* reference to the ipif. So no lock is necessary.
*/
lifr->lifr_addrlen =
} else {
lifr->lifr_addrlen =
}
}
return (0);
}
/*
* Set the destination address for a pt-pt interface.
*/
/* ARGSUSED */
int
{
int err = 0;
ip1dbg(("ip_sioctl_dstaddr(%s:%u %p)\n",
return (EAFNOSUPPORT);
return (EADDRNOTAVAIL);
} else {
return (EAFNOSUPPORT);
return (EADDRNOTAVAIL);
}
return (0); /* No change */
/*
* 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.
*/
if (err == EINPROGRESS)
return (err);
}
/*
* could return EINPROGRESS. If so ioctl will complete in
* ip_rput_dlpi_writer
*/
return (err);
}
static int
{
int err = 0;
/* Must cancel any pending timer before taking the ill_lock */
if (ipif->ipif_recovery_id != 0)
ipif->ipif_recovery_id = 0;
} else {
}
/* Set point to point destination address. */
/*
* 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.
*/
}
/*
* If the interface was previously marked as a duplicate, then since
* we've now got a "new" address, it should no longer be considered a
* duplicate -- even if the "new" address is the same as the old one.
* Note that if all ipifs are down, we may have a pending ARP down
* event to handle.
*/
need_arp_down = !need_up;
}
}
/* Set the new address. */
/* Make sure subnet tracks pp_dst */
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.
*/
}
if (need_dl_down)
if (need_arp_down)
return (err);
}
/*
* Restart entry point to restart the dstaddress set operation after the
* refcounts have dropped to zero.
*/
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_dstaddr_restart(%s:%u %p)\n",
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_dstaddr(%s:%u %p)\n",
/*
* Get point to point destination address. The addresses can't
* change since we hold a reference to the ipif.
*/
return (EADDRNOTAVAIL);
} else {
}
return (0);
}
/*
* 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
{
/*
* No need for a lock while traversing the list since iam
* a writer
*/
return;
}
}
return;
}
}
}
return;
}
}
return;
}
}
}
}
/*
* 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
{
}
}
/*
* 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
{
/* Check whether it is in an IPMP group */
return (B_FALSE);
if (ill->ill_ipif_up_count == 0)
return (B_TRUE);
/*
* 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).
*/
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
{
int err;
ip1dbg(("ip_sioctl_flags(%s:%u %p)\n",
} else {
}
/*
* Has the flags been set correctly till now ?
*/
/*
* 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.
*/
/*
* First check which bits will change and then which will
* go on and off
*/
if (!turn_on)
return (0); /* No change */
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 &&
return (EINVAL);
}
/*
* Only allow the IFF_XRESOLV and IFF_TEMPORARY flags to be set on
* IPv6 interfaces.
*/
return (EINVAL);
/*
* Don't allow the IFF_ROUTER flag to be turned on on loopback
* interfaces. It makes no sense in that context.
*/
return (EINVAL);
/*
* 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_cant_setlinklocal(ipif))
return (EINVAL);
}
/*
* 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 &&
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 we are setting or clearing FAILED or STANDBY or OFFLINE,
* we need to flush the IRE_CACHES belonging to this ill.
* like it is done for other flags. If some other flags are
* below will handle it by bringing it down and then
* bringing it UP.
*/
/*
* 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) ||
!ipst->ips_ipmp_enable_failback)) {
/* Reset PHYI_INACTIVE when PHYI_FAILED is being set */
}
if ((turn_off & PHYI_FAILED) &&
((intf_flags & PHYI_STANDBY) ||
(!ipst->ips_ipmp_enable_failback &&
ill_is_inactive(ill)))) {
}
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
*/
return (EINVAL);
}
if (turn_off & PHYI_STANDBY) {
if (ipst->ips_ipmp_enable_failback) {
/*
* Reset PHYI_INACTIVE.
*/
} else if (ill_is_inactive(ill) &&
/*
* Need to set INACTIVE, when user sets
* STANDBY on a non-STANDBY phyint and
* later resets STANDBY
*/
}
}
/*
* 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).
*/
}
}
}
/*
* 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 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.
*/
/* Record new flags in their respective places. */
/*
* We do the broadcast and nomination here rather
* 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
* 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 (phyint_flags_modified) {
ill_ipif);
}
ill_ipif);
}
}
return (0);
} else if (set_linklocal || zero_source) {
if (set_linklocal)
if (zero_source)
}
/*
* 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.
*/
return (EINVAL);
}
/*
* Prevent IPv4 point-to-point interfaces with a 0.0.0.0 destination
* from being brought up.
*/
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.
*/
/*
* Taking this ipif down, make sure we have
* valid net and subnet bcast ire's for other
* logical interfaces, if we need them.
*/
}
if (err == EINPROGRESS)
return (err);
}
}
static int
{
int err = 0;
ip1dbg(("ip_sioctl_flags_tail(%s:%u)\n",
/*
* Now we change the flags. Track current value of
* other flags in their respective places.
*/
}
}
if (set_linklocal) {
(void) ipif_setlinklocal(ipif);
}
if (zero_source)
else
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
* it should be okay.
*/
} 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) {
ill_ipif);
}
ill_ipif);
}
} else {
}
}
/* Update the flags in SCTP's IPIF list */
return (err);
}
/*
* Restart entry point to restart the flags restart operation after the
* refcounts have dropped to zero.
*/
/* ARGSUSED */
int
{
int err;
ip1dbg(("ip_sioctl_flags_restart(%s:%u %p)\n",
/*
* 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.
*/
} else {
}
return (err);
}
/*
* Can operate on either a module or a driver queue.
*/
/* ARGSUSED */
int
{
/*
* Has the flags been set correctly till now ?
*/
ip1dbg(("ip_sioctl_get_flags(%s:%u %p)\n",
/*
* Need a lock since some flags can be set even when there are
* references to the ipif.
*/
/* Get interface flags (low 16 only). */
} else {
/* Get interface flags. */
}
return (0);
}
/* ARGSUSED */
int
{
int mtu;
int ip_min_mtu;
} else {
}
else
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
* 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.
*/
else
}
ipst);
else
ipst);
}
/* Update the MTU in SCTP's list */
return (0);
}
/* Get interface MTU. */
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_mtu(%s:%u %p)\n",
} else {
}
return (0);
}
/* Set interface broadcast address. */
/* ARGSUSED2 */
int
{
return (EADDRNOTAVAIL);
return (EAFNOSUPPORT);
/*
* 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.
*/
return (EINVAL);
} else {
}
}
/*
* Changing the broadcast addr for this ipif.
* Make sure we have valid net and subnet bcast
* ire's for other logical interfaces, if needed.
*/
return (0);
}
/* Get interface broadcast address. */
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_brdaddr(%s:%u %p)\n",
return (EADDRNOTAVAIL);
/* IPIF_BROADCAST not possible with IPv6 */
return (0);
}
/*
* This routine is called to handle the SIOCS*IFNETMASK IOCTL.
*/
/* ARGSUSED */
int
{
int err = 0;
ip1dbg(("ip_sioctl_netmask(%s:%u %p)\n",
return (EAFNOSUPPORT);
} else {
return (EAFNOSUPPORT);
}
/*
* No big deal if the interface isn't already up, or the mask
* isn't really changing, or this is pt-pt.
*/
}
return (0);
}
/*
* Make sure we have valid net and subnet broadcast ire's
* for the old netmask, if needed by other logical interfaces.
*/
if (err == EINPROGRESS)
return (err);
return (err);
}
static int
{
int err = 0;
ip1dbg(("ip_sioctl_netmask_tail(%s:%u %p)\n",
} else {
}
}
/*
* 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
*/
/* Potentially broadcast an address mask reply. */
}
}
return (err);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_netmask_restart(%s:%u %p)\n",
}
/* Get interface net mask. */
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_netmask(%s:%u %p)\n",
/*
* net mask can't change since we have a reference to the ipif.
*/
lifr->lifr_addrlen =
} else {
lifr->lifr_addrlen =
}
}
return (0);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_metric(%s:%u %p)\n",
/*
* 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.
*/
} else {
}
return (0);
}
/* ARGSUSED */
int
{
/* Get interface metric. */
ip1dbg(("ip_sioctl_get_metric(%s:%u %p)\n",
} else {
}
return (0);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_muxid(%s:%u %p)\n",
/*
* Set the muxid returned from I_PLINK.
*/
} else {
}
return (0);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_muxid(%s:%u %p)\n",
/*
* Get the muxid saved in ill for I_PUNLINK.
*/
} else {
}
return (0);
}
/*
* Set the subnet prefix. Does not modify the broadcast address.
*/
/* ARGSUSED */
int
{
int err = 0;
int addrlen;
ip1dbg(("ip_sioctl_subnet(%s:%u %p)\n",
return (EAFNOSUPPORT);
return (EADDRNOTAVAIL);
} else {
return (EAFNOSUPPORT);
return (EADDRNOTAVAIL);
/* Add 96 bits */
}
return (EINVAL);
/* Check if bits in the address is set past the mask */
return (EINVAL);
return (0); /* No change */
/*
* 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.
*/
if (err == EINPROGRESS)
return (err);
}
return (err);
}
static int
{
int err = 0;
ip1dbg(("ip_sioctl_subnet_tail(%s:%u %p)\n",
/* Set the new address. */
}
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.
*/
if (err == EINPROGRESS)
return (err);
}
return (err);
}
/* ARGSUSED */
int
{
int addrlen;
ip1dbg(("ip_sioctl_subnet_restart(%s:%u %p)\n",
} else {
}
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_subnet(%s:%u %p)\n",
lifr->lifr_addrlen =
} else {
}
return (0);
}
/*
* Set the IPv6 address token.
*/
/* ARGSUSED */
int
{
int err;
int i;
int addrlen;
ip1dbg(("ip_sioctl_token(%s:%u %p)\n",
/* Only allow for logical unit zero i.e. not on "le0:17" */
return (EINVAL);
return (EINVAL);
if (addrlen > IPV6_ABITS)
return (EINVAL);
/*
* 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.
*/
return (EINVAL);
for (i = 0; i < 4; i++) {
}
return (0); /* No change */
if (err == EINPROGRESS)
return (err);
}
return (err);
}
static int
{
int i;
int err = 0;
ip1dbg(("ip_sioctl_token_tail(%s:%u %p)\n",
/*
* 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.
*/
for (i = 0; i < 4; i++)
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.
*/
if (err == EINPROGRESS)
return (err);
}
return (err);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_token(%s:%u %p)\n",
return (EINVAL);
return (ENXIO);
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
{
int ip_min_mtu;
ip1dbg(("ip_sioctl_lnkinfo(%s:%u %p)\n",
/* Only allow for logical unit zero i.e. not on "le0:17" */
return (EINVAL);
/* Set interface MTU. */
else
/*
* Verify values before we set anything. Allow zero to
* mean unspecified.
*/
if (lir->lir_maxmtu != 0 &&
return (EINVAL);
if (lir->lir_reachtime != 0 &&
return (EINVAL);
if (lir->lir_reachretrans != 0 &&
return (EINVAL);
}
if (lir->lir_maxmtu != 0) {
}
if (lir->lir_reachtime != 0)
if (lir->lir_reachretrans != 0)
if (mtu_walk) {
/*
* Set the MTU on all ipifs associated with this ill except
* for those whose MTU was fixed via SIOCSLIFMTU.
*/
continue;
continue;
else
}
ipif_mtu_change, (char *)nipif,
ill);
} else {
ipif_mtu_change, (char *)nipif,
ill);
}
}
}
}
return (0);
}
/* ARGSUSED */
int
{
struct lif_ifinfo_req *lir;
ip1dbg(("ip_sioctl_get_lnkinfo(%s:%u %p)\n",
return (EINVAL);
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
{
if (net_mask == 0) {
return (0);
}
/* Let's check to see if this is maybe a local subnet route. */
/* this function only applies to IPv4 interfaces */
if (!IPIF_CAN_LOOKUP(ipif))
continue;
continue;
/*
* Don't trust pt-pt interfaces if there are
* other interfaces.
*/
if (fallback_ipif == NULL) {
}
continue;
}
/*
* Fine. Just assume the same net mask as the
* directly attached subnet interface is using.
*/
if (fallback_ipif != NULL)
return (ipif->ipif_net_mask);
}
}
}
*ipifp = fallback_ipif;
return ((fallback_ipif != NULL) ?
}
/*
* ip_sioctl_copyin_setup calls ip_wput_ioctl to process the IP_IOCTL ioctl.
*/
static void
{
int error = 0;
ip1dbg(("ip_wput_ioctl"));
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.
*/
goto done;
break;
}
/*
* prefer credential from mblk over ioctl;
* see ip_sioctl_copyin_setup
*/
/*
* Refhold the conn in case the request gets queued up in some lookup
*/
}
/*
* CONN_OPER_PENDING_DONE happens in the function called
* through ipft_pfi above.
*/
return;
}
return;
}
done:
}
/*
* Lookup an ipif using the sequence id (ipif_seqid)
*/
ipif_t *
{
return (ipif);
}
return (NULL);
}
/*
* 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
{
}
/*
* 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
{
int id;
/*
* 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)
if (acquire_ill_lock)
id = 0;
break; /* non-consecutive id */
id++;
}
/* limit number of logical interfaces */
if (acquire_ill_lock)
if (acquire_g_lock)
return (-1);
}
/* we have a real id; insert ipif in the right place */
break; /* found correct location */
}
} else {
if (acquire_ill_lock)
if (acquire_g_lock)
return (-1);
}
if (acquire_ill_lock)
if (acquire_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 *
{
ip1dbg(("ipif_allocate(%s:%d ill %p)\n",
return (NULL);
/*
* Inherit the zoneid from the ill; for the shared stack instance
* this is always the global zone
*/
ipif->ipif_refcnt = 0;
ipif->ipif_saved_ire_cnt = 0;
return (NULL);
}
/* -1 id should have been replaced by real id */
/*
* 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.
*/
/*
* 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.
*/
/*
* 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)
} else {
/* Keep the IN6_IS_ADDR_V4MAPPED assertions happy */
&ipif->ipif_v6lcl_addr);
&ipif->ipif_v6src_addr);
&ipif->ipif_v6subnet);
&ipif->ipif_v6net_mask);
&ipif->ipif_v6brd_addr);
}
/*
* Don't set the interface flags etc. now, will do it in
* ip_ll_subnet_defaults.
*/
if (!initialize) {
return (ipif);
}
if (ill->ill_bcast_addr_length != 0) {
/*
* Later detect lack of DLPI driver multicast
* capability by catching DL_ENABMULTI errors in
* ip_rput_dlpi.
*/
} else {
/*
* 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.
*/
else
}
if (ill->ill_phys_addr_length == 0) {
} else {
/* pt-pt supports multicast. */
phyi->phyint_flags |=
} else {
}
}
}
}
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
{
/* Delete the mapping for the local address */
ip1dbg(("ipif_arp_down: arp cmd %x for %s:%u\n",
}
/*
* If this is the last ipif that is going down and there are no
* duplicate addresses we may yet attempt to re-probe, then we need to
* clean up ARP completely.
*/
/* Send up AR_INTERFACE_DOWN message */
ip1dbg(("ipif_arp_down: arp cmd %x for %s:%u\n",
}
/* Tell ARP to delete the multicast mappings */
ip1dbg(("ipif_arp_down: arp cmd %x for %s:%u\n",
}
}
}
/*
* 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
{
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.
*/
ip1dbg(("ipif_arp_down: arp cmd %x for %s:%u\n",
}
if (arp_add_mapping_mp != NULL)
/*
* Check that the address is not to long for the constant
* length reserved in the template arma_t.
*/
return (-1);
/* Add mapping mblk */
return (-1);
/*
* Determine the broadcast address.
*/
if (ill->ill_sap_length < 0)
else
/*
* Check PHYI_MULTI_BCAST and length of physical
* address to determine if we use the mapping or the
* broadcast address.
*/
/* Make sure this will not match the "exact" entry. */
return (-1);
}
/* Use link-layer broadcast address for MULTI_BCAST */
ip2dbg(("ipif_arp_setup_multicast: adding"
} else {
ip2dbg(("ipif_arp_setup_multicast: adding multicast"
}
} else {
/* It is neither MULTICAST nor MULTI_BCAST */
return (0);
}
if (arp_add_mapping_mp != NULL) {
/* The caller just wants the mblks allocated */
} else {
/* The caller wants us to send it to arp */
}
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 enumerated value res_act is used to tune the behavior.
* If set to Res_act_initial, then we set up all the resolver
* structures for a new interface. If set to Res_act_move, then
* we just send an AR_ENTRY_ADD message up to ARP for IPv4
* interfaces; this is called by ip_rput_dlpi_writer() to handle
* asynchronous hardware address change notification. If set to
* Res_act_defend, then we tell ARP that it needs to send a single
* gratuitous message in defense of the address.
* Returns error on failure.
*/
int
{
ip1dbg(("ipif_resolver_up(%s:%u) flags 0x%x\n",
if (res_act == Res_act_initial) {
ipif->ipif_addr_ready = 0;
/*
* We're bringing an interface up here. There's no way that we
* should need to shut down ARP now.
*/
}
}
if (ipif->ipif_recovery_id != 0)
ipif->ipif_recovery_id = 0;
return (0);
}
/* NDP will set the ipif_addr_ready flag when it's ready */
return (0);
/*
* External resolver for IPv6
*/
}
} 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.
*/
if (ill->ill_arp_closing) {
goto failed;
} else {
if (ill->ill_ipif_up_count == 0 &&
}
}
}
/*
* Add an entry for the local address in ARP only if it
* is not UNNUMBERED and the address is not INADDR_ANY.
*/
/* Now ask ARP to publish our address. */
if (arp_add_mp == NULL)
goto failed;
if (res_act != Res_act_initial) {
/*
* Copy the new hardware address and length into
* arp_add_mp to be sent to ARP.
*/
}
if (res_act == Res_act_defend) {
/*
* If we're just defending our address now, then
* there's no need to set up ARP multicast mappings.
* The publish command is enough.
*/
goto done;
}
if (res_act != Res_act_initial)
goto arp_setup_multicast;
/*
* Allocate an ARP deletion message so we know we can tell ARP
* when the interface goes down.
*/
if (arp_del_mp == NULL)
goto failed;
} else {
if (res_act != Res_act_initial)
goto done;
}
/*
* Need to bring up ARP or setup multicast mapping only
* when the first interface is coming UP.
*/
was_dup) {
goto done;
}
/*
* Allocate an ARP down message (to be saved) and an ARP up
* message.
*/
if (arp_down_mp == NULL)
goto failed;
goto failed;
goto done;
/*
* Setup the multicast mappings. This function initializes
* ill_arp_del_mapping_mp also. This does not need to be done for
* IPv6.
*/
if (err != 0)
goto failed;
}
done:
if (arp_del_mp != NULL) {
}
if (arp_down_mp != NULL) {
}
if (arp_del_mapping_mp != NULL) {
}
ip1dbg(("ipif_resolver_up: ARP_UP for %s:%u\n",
}
if (arp_add_mp != NULL) {
ip1dbg(("ipif_resolver_up: ARP_ADD for %s:%u\n",
/*
* If it's an extended ARP implementation, then we'll wait to
* hear that DAD has finished before using the interface.
*/
if (!ill->ill_arp_extend)
} else {
}
if (arp_add_mapping_mp != NULL) {
ip1dbg(("ipif_resolver_up: MAPPING_ADD for %s:%u\n",
}
if (res_act != Res_act_initial)
return (0);
else
if (err != 0) {
return (err);
}
ip1dbg(("ipif_resolver_up: FAILED\n"));
ill->ill_arp_bringup_pending = 0;
return (err);
}
/*
* This routine restarts IPv4 duplicate address detection (DAD) when a link has
* just gone back up.
*/
static void
{
/*
* If we can't contact ARP for some reason, that's not really a
* problem. Just send out the routing socket notification that
* DAD completion would have done, and continue.
*/
return;
}
/* Setting the 'unverified' flag restarts DAD */
}
static void
{
return;
if (!ndp_restart_dad(nce)) {
/*
* If we can't restart DAD for some reason, that's not really a
* problem. Just send out the routing socket notification that
* DAD completion would have done, and continue.
*/
}
}
/*
* Restart duplicate address detection on all interfaces on the given ill.
*
* This is called when an interface transitions from down to up
* (DL_NOTE_LINK_UP) or up to down (DL_NOTE_LINK_DOWN).
*
* Note that since the underlying physical link has transitioned, we must cause
* at least one routing socket message to be sent here, either via DAD
* completion or just by default on the first ipif. (If we don't do this, then
* in.mpathd will see long delays when doing link-based failure recovery.)
*/
void
{
return;
/*
* If layer two doesn't support duplicate address detection, then just
* send the routing socket message now and be done with it.
*/
return;
}
if (went_up) {
else
/*
* For IPv4, the ARP module itself will
* automatically start the DAD process when it
* sees DL_NOTE_LINK_UP. We respond to the
* AR_CN_READY at the completion of that task.
* For IPv6, we must kick off the bring-up
* process now.
*/
} else {
/*
* Unfortunately, the first ipif is "special"
* and represents the underlying ill in the
* routing socket messages. Thus, when this
* one ipif is down, we must still notify so
* that the user knows the IFF_RUNNING status
* change. (If the first ipif is up, then
* we'll handle eventual routing socket
* notification via DAD completion.)
*/
}
} else {
/*
* After link down, we'll need to send a new routing
* message when the link comes back, so clear
* ipif_addr_ready.
*/
ipif->ipif_addr_ready = 0;
}
}
/*
* If we've torn down links, then notify the user right away.
*/
if (!went_up)
}
/*
* 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
{
if (phyint->phyint_illv4) {
if (!caller_holds_lock)
if (!caller_holds_lock)
}
if (phyint->phyint_illv6) {
if (!caller_holds_lock)
if (!caller_holds_lock)
}
}
}
static ipsq_t *
{
return (NULL);
}
else
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 *
{
int group_len;
group_len++;
/*
* 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.
*/
/*
* Verify that an ipmp groupname is exactly
* part of 1 ipsq and is not found in any other
* 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.
*/
group_len) == 0)) {
/*
* Verify that an ipmp groupname is exactly
* part of 1 ipsq and is not found in any other
* ipsq.
*/
return (ipsq);
}
}
}
if (create)
return (ipsq);
}
static void
{
/*
* 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)
*/
/*
* This is not the ipsq of an IPMP group.
*/
return;
}
/*
* Locate the ipsq before we can remove it from
* the singly linked list of ipsq's.
*/
break;
}
}
/* unlink ipsq from the list */
else
}
static void
queue_t *q)
{
/*
* move from old ipsq to the new ipsq.
*/
}
void
{
}
}
}
}
}
/*
* 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
{
int err = 0;
/*
* Except for ipif_state_flags and ill_state_flags the other
* 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.
*/
if (ipif->ipif_was_up) {
if (err != 0) {
/*
* Can there be any other error ?
*/
return (err);
}
}
}
if (ill_v4->ill_move_in_progress) {
PHYI_STANDBY) {
}
PHYI_STANDBY) {
}
}
}
}
if (ipif->ipif_was_up) {
if (err != 0) {
/*
* Can there be any other error ?
*/
return (err);
}
}
}
if (ill_v6->ill_move_in_progress) {
}
}
}
}
return (0);
}
/*
* bring down all the approriate ipifs.
*/
/* ARGSUSED */
static void
{
/*
* are modified below are protected implicitly since we are a writer
*/
continue;
/*
* 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 called with chk_nofailover true ipif is moving.
*/
if (chk_nofailover) {
ipif->ipif_state_flags |=
} else {
}
/*
* they are dependent on 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.
*/
}
}
}
}
}
/*
* Change the ipsq of all the ill's whose current ipsq is 'cur_ipsq' to
* new_ipsq.
*/
static void
{
/*
* 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.
*/
}
}
#define SPLIT_SUCCESS 0
#define SPLIT_NOT_NEEDED 1
#define SPLIT_FAILED 2
int
{
/*
* Assertions denote pre-requisites for changing the ipsq of
* a phyint
*/
/*
* <ill-phyint> assocs can't change while ill_g_lock
* is held as writer. See ill_phyint_reinit()
*/
if ((phyint->phyint_groupname_len !=
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.
*/
/* Memory allocation failure */
return (SPLIT_FAILED);
} else {
/* ipsq_refs protected by ill_g_lock (writer) */
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-phyint> assocs can't change while ill_g_lock
* is held as writer. See ill_phyint_reinit()
*/
/*
* 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) */
/*
* This is a new ipsq that is unknown to the world.
* So we don't need to hold ipsq_lock,
*/
#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
{
int error;
/*
* 'created' will tell us whether the callee actually
* created an ipsq. Lack of memory may force the callee
* to return without creating an ipsq.
*/
} else {
need_retry, ipst);
}
switch (error) {
case SPLIT_FAILED:
need_retry = B_TRUE;
/* FALLTHRU */
case SPLIT_NOT_NEEDED:
/*
* Keep it on the list.
*/
break;
case SPLIT_SUCCESS:
break;
default:
ASSERT(0);
}
}
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 <ill-ipsq> associations could change between the
* lock and unlock. Hence the unlock can't traverse the
* ipsq to get the list of ills.
*/
static int
{
int cnt = 0;
/*
* The caller holds ill_g_lock to ensure that the ill memberships
* of the ipsq don't change
*/
}
}
}
return (cnt);
}
void
{
int i;
if (cnt > 1) {
do {
for (i = 0; i < cnt - 1; i++) {
/* swap the elements */
}
}
} while (try_again);
}
for (i = 0; i < cnt; i++) {
if (i == 0) {
else
return;
}
}
}
void
{
int i;
for (i = 0; i < cnt; i++) {
}
}
}
/*
* 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
queue_t *q)
{
int cnt;
/* Exactly 1 of 'to_ill' and groupname can be specified. */
/*
* Need to hold ill_g_lock as writer and also the ill_lock to
* change the <ill-ipsq> assoc of an ill. Need to hold the
* ipsq_lock to prevent new messages from landing on an ipsq.
*/
else {
}
/*
* both groups are on the same ipsq.
*/
return (0);
}
return (ENOMEM);
}
/* Need ipsq lock to enque messages on new ipsq or to become writer */
}
/*
* 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.
*/
/*
* 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 <ill-ipsq>
* assocs. till we release the ill_g_lock, and hence it can't vanish.
*/
/*
* 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
*/
/* Now release all the locks */
/*
* 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
*/
/*
* syncq has been changed and all the messages have been moved.
*/
old_ipsq->ipsq_current_ioctl = 0;
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
{
/*
* 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 (;;) {
break;
/*
* we are passing in KM_SLEEP because it is not easy to
* go back to a sane state in case of memory failure.
*/
/*
* 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
*/
NULL,
NULL,
}
/*
* 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.
*/
}
int error;
/* unlink the IRE from our list before calling ire_add() */
/* ire_add adds the ire at the right place in the list */
}
}
/*
* 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
{
/*
* This function is called even when an ill is deleted from
* the group. Hence, illgrp could be null.
*/
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.
*/
} else {
}
}
}
/*
* 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
{
/*
* IPMP and plumbing operations are serialized on the ipsq, so
* no one will insert or delete a broadcast ire under our feet.
*/
break;
continue;
}
}
}
/*
* 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
{
/*
* 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.
*/
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.
*/
if (new_lb_ire == NULL) {
return;
}
if (new_nlb_ire == NULL) {
return;
}
/*
* 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.
*/
break;
}
}
redo:
/*
* 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.
*/
/*
* 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.
*/
if (phyi_flags & PHYI_OFFLINE) {
continue;
}
if (phyi_flags & match_flags) {
}
continue;
}
if (first) {
/*
* We will move this to the front of the list later
* on.
*/
} else {
}
}
/*
* If we never nominated anybody, try nominating at least
* an INACTIVE, if we found one. Do it only once though.
*/
fallback) {
goto redo;
}
/*
* 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
*/
}
/* XXX We need a recovery strategy here. */
if (ire_init(new_lb_ire,
NULL,
NULL,
fp_mp =
res_mp =
} else {
}
/* XXX We need a recovery strategy here. */
if (ire_init(new_nlb_ire,
NULL,
NULL,
}
}
/*
* 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.
*/
}
/*
* etc. Need to dup them. ditto in ill_bcast_delete_and_add
*/
/* Add the new ire's. Insert at *irep */
/* Link the new one in. */
*irep = new_lb_ire;
if (clear_ire_stq != NULL) {
/* Add the new ire. Insert at *irep */
/* Link the new one in. */
*irep = new_nlb_ire;
}
}
if (!new_lb_ire_used)
if (!new_nlb_ire_used)
}
/*
* 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
{
/*
* 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.
*/
/* There could not have been any ires associated with this */
if (ipif->ipif_subnet == 0)
return;
} else {
}
}
/*
* 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
{
ipaddr_t prev_subnet_addr = 0;
ipaddr_t prev_net_addr = 0;
/*
* When the last memeber is leaving, there is nothing to
* nominate.
*/
if (illgrp->illgrp_ill_count == 0) {
return;
}
/*
* 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.
*/
ipif->ipif_subnet == 0) {
continue;
}
} else {
}
}
if (prev_subnet_addr == 0 ||
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
{
int ret = 0;
/*
* Leave the allmulti on all the ills and start fresh.
*/
if (ill->ill_join_allmulti)
}
/*
* 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;
/* Never pick an offline interface */
continue;
continue;
}
continue;
}
/*
* 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);
}
return (ret);
}
}
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
{
/*
* 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.
*/
/*
* Case 1 above : No optimization here. Just redo the
* nomination.
*/
/*
* Case 2 above : Lookup and clear IRE_MARK_NORECV.
*/
ill_clear_bcast_mark(ill, 0);
ipif->ipif_subnet == 0) {
continue;
}
} else {
}
}
}
/*
* 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 {
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.
*/
} else {
}
/*
* 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.
*/
/*
* 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.
*/
} else {
}
}
}
/*
* 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
{
/*
* Reset illgrp_ill_schednext if it was pointing at us.
* We need to do this before we set ill_group to NULL.
*/
/* Delete the ill from illgrp. */
} else {
}
}
/*
* 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.
*/
if (illgrp->illgrp_ill_count == 0) {
} else {
}
}
} else {
} else {
}
}
}
}
/*
* 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.
*/
}
/*
* 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
{
else
}
}
}
/*
* 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
{
/*
* Look for a group with a matching groupname to insert.
*/
/*
* 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.
*/
continue;
}
/*
* 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.
*/
groupname) == 0) {
break;
}
}
} else {
/*
* If the caller passes in a NULL "grp_to_insert", we
* allocate one below and insert this singleton.
*/
}
return (ENOMEM);
}
*illgrp_head = illgrp;
/*
* Used in illgrp_scheduler to protect multiple threads
* from traversing the list.
*/
} else {
/* Insert ill at tail of this group */
/*
* 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.
*/
}
/*
* 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 (!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.
*/
}
/*
* Send a routing sockets message if we are inserting into
* groups with names.
*/
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 *
{
/*
* Group names are stored in the phyint - a common structure
* to both IPv4 and IPv6.
*/
if (phyi->phyint_groupname_len == 0)
continue;
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 <ill-ipsq> 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 <ill-ipsq> 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 <ill-ipsq> 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
{
int i;
char *tmp;
int namelen;
int err = 0;
char *groupname;
/* Existance verified in ip_wput_nondata */
return (EINVAL);
return (EINVAL);
;
if (i == LIFNAMSIZ) {
/* no null termination */
return (EINVAL);
}
/*
* Calculate the namelen exclusive of the null
* termination character.
*/
/*
* 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
*/
return (EINVAL);
}
/*
* mark the ill as changing.
* this should queue all new requests on the syncq.
*/
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_is_quiescent(ill_v4)) {
/*
* ipsq_pending_mp_add will not fail since
* connp is NULL
*/
(void) ipsq_pending_mp_add(NULL,
err = EINPROGRESS;
goto done;
}
}
if (!ill_is_quiescent(ill_v6)) {
(void) ipsq_pending_mp_add(NULL,
err = EINPROGRESS;
goto done;
}
}
phyi->phyint_groupname_len = 0;
/*
* set the split flag so that the ipsq can be split
*/
} else {
if (phyi->phyint_groupname_len != 0) {
/* Are we inserting in the same group ? */
phyi->phyint_groupname) == 0) {
err = 0;
goto done;
}
}
/*
* Merge ipsq for the group's.
* sharing the same ipsq.
* If we have to merege than the operation is restarted
* on the new ipsq.
*/
goto done;
}
/*
* Running exclusive on new ipsq.
*/
/*
* 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.
*/
((ill_v4->ill_net_type !=
return (EINVAL);
}
((ill_v6->ill_net_type !=
return (EINVAL);
}
}
/*
* bring down all v4 ipifs.
*/
}
/*
* bring down all v6 ipifs.
*/
}
/*
* 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_is_quiescent(ill_v4)) {
(void) ipsq_pending_mp_add(NULL,
err = EINPROGRESS;
goto done;
}
}
if (!ill_is_quiescent(ill_v6)) {
(void) ipsq_pending_mp_add(NULL,
err = EINPROGRESS;
goto done;
}
}
/*
* allocate including space for null terminator
* before we insert.
*/
return (ENOMEM);
if (phyi->phyint_groupname_len != 0) {
}
/*
* setup the new group name.
*/
}
done:
/*
* normally ILL_CHANGING is cleared in ill_up_ipifs.
*/
if (err != EINPROGRESS) {
}
return (err);
}
/* ARGSUSED */
int
{
/* Existence verified in ip_wput_nondata */
/*
* 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) {
}
return (0);
}
typedef struct conn_move_s {
int cm_ifindex;
} conn_move_t;
/*
* ipcl_walk function for moving conn_multicast_ill for a given ill.
*/
static void
{
int ifindex;
int i;
/* Change IP_BOUND_IF/IPV6_BOUND_IF associations. */
/* All multicast fields protected by conn_lock */
}
/* Change IP_MULTICAST_IF/IPV6_MULTICAST_IF associations */
}
/* Change IP_XMIT_IF associations */
}
/*
* 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.
*/
/* ifindex != 0 indicates failback */
if (ifindex != 0) {
continue;
}
connp->conn_zoneid);
}
}
}
static void
{
}
/*
* 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
{
/*
* See whether we need to send down DL_ENABMULTI_REQ on
* to_ill as ilm has just been added.
*/
continue;
/*
* as we are writer.
*/
/*
* No need to hold any lock as we are the writer and this
* can only be changed by a writer.
*/
ip1dbg(("ilm_send_multicast_reqs: to_ill not "
"resolver\n"));
continue; /* Must be IRE_IF_NORESOLVER */
}
ip1dbg(("ilm_send_multicast_reqs: "
"to_ill MULTI_BCAST\n"));
goto from;
}
else
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.
*/
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).
*/
/*
* 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) {
}
} 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);
}
/*
* See whether we need to send down DL_DISABMULTI_REQ on
* from_ill as ilm has just been removed.
*/
from:
ip1dbg(("ilm_send_multicast_reqs: "
"from_ill not resolver\n"));
continue; /* Must be IRE_IF_NORESOLVER */
}
ip1dbg(("ilm_send_multicast_reqs: "
"from_ill MULTI_BCAST\n"));
continue;
}
if (from_ill->ill_join_allmulti)
(void) ip_ll_send_disabmulti_req(from_ill,
&ilm->ilm_v6addr);
}
}
}
/*
* 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
{
int count;
char buf[INET6_ADDRSTRLEN];
if (ifindex == 0) {
/*
* Form the solicited node mcast address which is used later.
*/
}
continue;
}
/*
* 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.
*/
}
} 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.
*/
(sizeof (ilm_t));
ip0dbg(("ilm_move_v6: "
"FAILBACK of IPv6"
" multicast address %s : "
"from %s to"
" %s failed : ENOMEM \n",
sizeof (buf)),
continue;
}
/*
* we don't want new_ilm linked to
* ilm's filter list.
*/
} else {
/*
* No walkers we can move the ilm.
* lets take it out of the list.
*/
}
/*
* 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,
/* Add to the to_ill's list */
/*
* set the flag so that mld_joingroup is
* called in ilm_send_multicast_reqs().
*/
}
goto bottom;
} else if (ifindex != 0) {
/*
* If this is FAILBACK (ifindex != 0) and the ifindex
* has not matched above, look at the next ilm.
*/
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 ==
&ilm->ilm_v6addr))) {
/*
* For indentation reasons, we are not using a
* "else" here.
*/
if (count == 0) {
continue;
}
/*
* 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",
sizeof (buf))));
}
} else {
ip0dbg(("ilm_move_v6: FAILOVER of IPv6"
" multicast address %s : from %s to"
" %s failed : ENOMEM \n",
continue;
}
/*
* 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,
/* Add to the to_ill's list */
}
if (ilm->ilm_refcnt == 0) {
goto bottom;
} else {
}
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.
*/
/*
* 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",
sizeof (buf))));
}
} else {
if (from_ill->ill_ilm_walker_cnt != 0) {
ip0dbg(("ilm_move_v6: "
"FAILOVER of IPv6"
" multicast address %s : "
"from %s to"
" %s failed : ENOMEM \n",
sizeof (buf)),
continue;
}
} else {
}
/*
* 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,
/* Add to the to_ill's list */
}
}
/*
* Revert multicast filter state to (EXCLUDE, NULL).
* new_ilm->ilm_is_new should already be set if needed.
*/
/*
*/
if (from_ill->ill_ilm_walker_cnt == 0) {
} else {
}
}
}
}
/*
* 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
{
continue;
}
continue;
}
/*
* 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;
/*
* We still need to deal with the from_ill.
*/
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.
*/
if (from_ill->ill_ilm_walker_cnt != 0) {
char buf[INET6_ADDRSTRLEN];
ip0dbg(("ilm_move_v4: FAILBACK of IPv4"
" multicast address %s : "
"from %s to"
" %s failed : ENOMEM \n",
sizeof (buf)),
continue;
}
/* We don't want new_ilm linked to ilm's filter list */
} else {
/* Remove from the list */
}
/*
* If we have never joined this group on the to_ill
* make sure we tell the driver.
*/
/* Add to the to_ill's list */
/*
* Revert multicast filter state to (EXCLUDE, NULL)
*/
/*
* Delete only if we have allocated a new ilm.
*/
if (from_ill->ill_ilm_walker_cnt == 0) {
/* Remove from the list */
} else {
}
}
}
}
static uint_t
{
/*
* 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.
*/
return (0);
break;
}
}
/*
* If somebody already plumbed another logical
* with the same id, we won't be able to find it.
*/
if (!found)
return (id);
}
break;
}
}
if (!found)
break;
}
return (unit);
}
/* ARGSUSED */
static int
{
int err = 0;
int rc;
/*
* Don't move LINK LOCAL addresses as they are tied to
* physical interface.
*/
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
* 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.
*/
ipif->ipif_orig_ifindex) &&
}
/*
* 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) {
} else {
}
/* Reset back to zero in case we fail below */
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.
*/
return (ENOMEM);
}
/*
* 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.
*/
/*
* We mark IPIF_NOFAILOVER so that this can never
* move.
*/
/* Insert at head */
/*
* 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.
*/
/*
* 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. */
break;
}
}
/* Assign the new ill */
/* id has already been checked */
/* Let SCTP update its list */
/*
* Handle the failover and failback of ipif_t between
* ill_t that have differing maximum mtu values.
*/
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.
*/
} else {
/*
* The ipif_t is, once again, moving to
* an ill_t that has a lower maximum mtu
* value.
*/
}
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).
*/
ipif->ipif_saved_mtu = 0;
} else {
}
}
/*
* 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.
*/
return (err);
}
static int
{
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.
*/
/*
* 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.
*/
/*
* 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 (err != 0)
return (err);
}
}
return (0);
}
static int
{
int ifindex;
int err;
/*
* 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.
*/
}
/*
* 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.
*/
if (((ifindex == 0) ||
break;
}
}
mp, ILL_MOVE_OK);
return (EINPROGRESS);
}
/* Check if the replacement ipif is quiescent to delete */
mp, ILL_MOVE_OK);
return (EINPROGRESS);
}
}
/* ilm_move is done inside ipif_move for IPv4 */
/*
* send rts messages and multicast messages.
*/
if (rep_ipif_ptr != NULL) {
if (rep_ipif_ptr->ipif_recovery_id != 0) {
rep_ipif_ptr->ipif_recovery_id = 0;
}
}
return (err);
}
/*
* 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
{
int dst_index;
int err = 0;
if (CONN_Q(q))
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
return (EPROTO);
return (EPROTO);
/*
* specific operations.
*/
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.
*/
return (ENXIO);
goto done;
}
}
goto done;
}
}
err = 0;
if (err != 0) {
/*
* There could be only v6.
*/
goto done;
err = 0;
}
if (err != 0) {
goto done;
goto done;
}
err = 0;
}
/*
* If we have something to MOVE i.e "from" not NULL,
* "to" should be non-NULL.
*/
}
done:
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
* execute on the same ipsq and are hence serialized.
*/
/* ARGSUSED */
int
{
int err = 0;
/*
* setup from and to ill's, we can get EINPROGRESS only for
* to_ill's.
*/
if (err != 0) {
ip0dbg(("ip_sioctl_move: extract args failed\n"));
goto done;
}
/*
* nothing to do.
*/
goto done;
}
/*
* nothing to do.
*/
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.
*/
if (ill_from_v4 != NULL)
if (ill_from_v6 != NULL)
/*
* 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) {
goto err_ret;
}
} else {
goto err_ret;
}
}
/*
* Now that the ipsq's have been merged and we are the writer
* lets mark to_ill as changing as well.
*/
/*
* 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) {
}
/*
* Now lets move ipv6.
*/
}
/*
* 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.
*/
/*
* Some of the clearing may be redundant. But it is simple
* not making any extra checks.
*/
if (ill_from_v6 != NULL) {
}
if (ill_from_v4 != NULL) {
}
}
}
/*
* 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) {
}
} else if (ill_from_v6 != NULL) {
}
}
}
}
}
/*
* lets bring the interfaces up on the to_ill.
*/
if (err == 0) {
q, mp);
}
if (err == 0) {
}
done:
}
}
return (err);
}
static void
{
/*
* The ill is down; unbind but stay attached since we're still
* associated with a PPA. If we have negotiated DLPI capabilites
* with the data link service provider (IDS_OK) then reset them.
* The interval between unbinding and rebinding is potentially
* unbounded hence we cannot assume things will be the same.
* The DLPI capabilities will be probed again when the data link
* is brought up.
*/
ip1dbg(("ill_dl_down: %s (%u) for %s\n",
}
/*
* 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).
*/
ip2dbg(("ill_dl_down:unexpected nic event %d attached for %s\n",
}
info->hne_datalen = 0;
} else
ip2dbg(("ill_dl_down: could not attach DOWN nic event "
}
void
{
union DL_primitives *dlp;
ip1dbg(("ill_dlpi_dispatch: sending %s (%u) to %s\n",
switch (prim) {
case DL_PHYS_ADDR_REQ:
{
break;
}
case DL_BIND_REQ:
break;
}
/*
* Except for the ACKs for the M_PCPROTO messages, all other ACKs
* are dropped by ip_rput() if ILL_CONDEMNED is set. Therefore
* we only wait for the ACK of the DL_UNBIND_REQ.
*/
(prim == DL_UNBIND_REQ)) {
}
/*
* 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)
}
/*
* 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
{
/* Must queue message. Tail insertion */
ip1dbg(("ill_dlpi_send: deferring request for %s\n",
return;
}
}
/*
* Called when an DLPI control message has been acked or nacked to
* send down the next queued message (if any).
*/
void
{
"ill_dlpi_done: unsolicited ack for %s from %s\n",
} else {
"ill_dlpi_done: unexpected ack for %s from %s "
"(expecting ack for %s)\n",
}
return;
}
return;
}
}
void
{
/*
* 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.
*/
return;
}
}
/*
* 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
{
return;
}
}
/*
* 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.
*
* 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
* 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.
*
*
* 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
*
* 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
* 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
* 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
{
--ill->ill_ipif_up_count;
/* Update status in SCTP's list */
}
/*
* 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).
*/
/*
* 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.
*/
int err;
if (err != 0) {
}
}
/*
* 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.
*/
ipst);
} else {
ipst);
}
/*
* Need to add these also to be saved and restored when the
* ipif is brought down and up
*/
if (ipst->ips_ire_mrtun_count != 0) {
} else {
}
if (ipst->ips_ire_srcif_table_count > 0) {
ipst);
} else {
}
/*
* 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
*/
/* Also, delete the ires cached in SCTP */
/*
* 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.
*/
else
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.
*/
/*
* 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.
*/
if (phyi->phyint_groupname_len != 0) {
if (ill->ill_ipif_up_count == 0)
}
/*
* 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.
*/
}
/*
* neighbor-discovery or arp entries for this interface.
*/
/*
* 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
*/
return (0);
}
if (CONN_Q(q)) {
} else {
}
/*
* 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)) {
return (0);
}
ip1dbg(("ipif_down: need to wait, adding pending mp %s ill %p",
/*
* Enqueue the mp atomically in ipsq_pending_mp. When the refcount
* drops down, the operation will be restarted by ipif_ill_refrele_tail
*/
if (!success) {
/* The conn is closing. So just return */
return (EINTR);
}
return (EINPROGRESS);
}
void
{
/*
* 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.
*/
}
ill->ill_logical_down = 0;
/*
* Have to be after removing the routes in ipif_down_delete_ire.
*/
} else {
}
}
/*
* 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
{
/*
* 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.
*/
}
/*
* 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
{
return;
}
/*
* 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
{
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().
*/
return;
}
}
/*
* Look for a matching source address.
*/
return;
return;
return;
} else {
&ipif->ipif_v6lcl_addr))
return;
}
return;
}
/*
* ire_delete() will do an ire_flush_cache which will delete
* all ire_ipif matches
*/
}
/*
* 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
{
/*
* We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
* Hence this should be 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.
*/
}
}
/*
* Delete all the ire whose stq references ill_arg.
*/
static void
{
/*
* We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
* Hence this should be 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.
*/
}
/*
* 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
{
/*
* We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
* Hence this should be IRE_CACHE.
*/
/*
* We are called for IRE_CACHES whose ire_stq and ire_ipif
* matches ill. We are interested in both.
*/
}
/*
* Initiate deallocate of an IPIF. Always called as writer. Called by
* ill_delete or ip_sioctl_removeif.
*/
static void
{
if (ipif->ipif_recovery_id != 0)
ipif->ipif_recovery_id = 0;
/* Remove conn references */
/*
* Make sure we have valid net and subnet broadcast ire's for the
* other ipif's which share them with this ipif.
*/
/*
* Take down the interface. We can be called either from ill_delete
* or from ip_sioctl_removeif.
*/
/*
* Now that the interface is down, there's no chance it can still
* become a duplicate. Cancel any timer that may have been set while
* tearing down.
*/
if (ipif->ipif_recovery_id != 0)
ipif->ipif_recovery_id = 0;
/* Remove pointers to this ill in the multicast routing tables */
}
/*
* Warning: this is not the only function that calls mi_free on an ipif_t. See
* also ill_move().
*/
static void
{
/*
* Free state for addition IRE_IF_[NO]RESOLVER ire's.
*/
/*
* 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.
*/
/*
* 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.
*/
/*
* 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.
*/
/* Ask SCTP to take it out of it list */
/* Get it out of the ILL interface list. */
break;
}
}
/* Free the memory. */
}
/*
* "ill_name" otherwise.
*/
char *
{
char lbuf[32];
char *name;
buf[0] = '\0';
if (!ipif)
return (buf);
}
len -= 1;
return (buf);
}
/*
* Find an IPIF based on the name passed in. Names can be of the
* form <phys> (e.g., le0), <phys>:<#> (e.g., le0:1),
* The <phys> string can have forms like <dev><#> (e.g., le0),
* <dev><#>.<module> (e.g. le0.foo), or <dev>.<module><#> (e.g. ip.tun3).
* When there is no colon, the implied unit id is zero. <phys> must
* correspond to the name of an ILL. (May be called as writer.)
*/
static ipif_t *
{
char *cp;
char *endp;
long id;
*error = 0;
/*
* If the caller wants to us to create the ipif, make sure we have a
* valid zoneid
*/
if (namelen == 0) {
return (NULL);
}
/* Look for a colon in the 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,
* 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.
*/
return (NULL);
}
} 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.
*/
return (NULL);
/* Establish the unit number in the name. */
id = 0;
/* If there was a colon, the unit number follows. */
cp++;
return (NULL);
}
}
GRAB_CONN_LOCK(q);
/* Now see if there is an IPIF with this unit number. */
return (NULL);
}
/*
* The block comment at the start of ipif_down
* explains the use of the macros used below
*/
if (IPIF_CAN_LOOKUP(ipif)) {
if (!did_alloc)
/*
* 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.
*/
return (ipif);
} else if (IPIF_CAN_WAIT(ipif, q)) {
*error = EINPROGRESS;
return (NULL);
}
}
}
if (!do_alloc) {
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.
*/
else
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.)
*/
void
{
return;
/* ICMP mask reply is IPv4 only */
/* ICMP mask reply is not for a loopback interface */
return;
ipha->ipha_ident = 0;
if (icmph->icmph_checksum == 0)
}
/*
* 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
{
return;
}
/*
* 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
{
return;
}
/*
* Join the ipif specific multicast groups.
* Must be called after a mapping has been set up in the resolver. (Always
* called as writer.)
*/
void
{
ip1dbg(("ipif_multicast_up\n"));
return;
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.
*/
if (err != 0) {
ip0dbg(("ipif_multicast_up: "
"all_hosts_mcast failed %d\n",
err));
return;
}
/*
* Enable multicast for the solicited node multicast address
*/
NULL);
if (err != 0) {
ip0dbg(("ipif_multicast_up: solicited MC"
" failed %d\n", err));
(void) ip_delmulti_v6(&ipv6_all_hosts_mcast,
return;
}
}
} else {
return;
/* Join the all hosts multicast address */
ip1dbg(("ipif_multicast_up - addmulti\n"));
if (err) {
return;
}
}
}
/*
* 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
{
int err;
ip1dbg(("ipif_multicast_down\n"));
if (!ipif->ipif_multicast_up)
return;
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.
*/
if (err != 0) {
ip0dbg(("ipif_multicast_down: all_hosts_mcast failed %d\n",
err));
}
/*
* Disable multicast for the solicited node multicast address
*/
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 **
{
if (ipif_saved_irep == NULL) {
return (NULL);
}
/*
* 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 types ire 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 nce_res_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().
*/
gateway_addr = NULL;
/* Recover multiroute broadcast IRE. */
} else {
resolver_mp = NULL;
}
/*
* 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",
ire = ire_create(
NULL,
NULL,
rfq,
stq,
type,
ipif,
NULL,
0,
0,
0,
NULL,
NULL,
ipst);
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.
*/
/*
* ire held by ire_add, will be refreled' towards the
* the end of ipif_up_done
*/
irep++;
}
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
{
/*
* Interface holds an IPv4 address. Default
* mask is the natural netmask.
*/
if (!ipif->ipif_net_mask) {
}
/* ipif_subnet is ipif_pp_dst_addr for pt-pt */
} else {
}
/*
* NOTE: SunOS 4.X does this even if the broadcast address
* has been already set thus we do the same here.
*/
}
} else {
/*
* Interface holds an IPv6-only address. Default
* mask is all-ones.
*/
/* ipif_subnet is ipif_pp_dst_addr for pt-pt */
} else {
}
}
}
/*
* 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
{
return (0);
else
continue;
&our_v6addr)) {
else if (IN6_IS_ADDR_LINKLOCAL(&our_v6addr) &&
continue;
else if (IN6_IS_ADDR_SITELOCAL(&our_v6addr) &&
continue;
else if (new_ipif->ipif_zoneid !=
ipif->ipif_zoneid &&
continue;
return (EADDRINUSE);
else
return (EADDRNOTAVAIL);
}
}
}
return (0);
}
/*
* 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
{
int err = 0;
/* Shouldn't get here if it is already up. */
return (EALREADY);
/*
* 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
* does not cause an unbind (DL_UNBIND) with the driver
*/
}
/*
* 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.
*/
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) {
if (err != 0) {
if (err != EINPROGRESS)
return (err);
}
}
/* Now, ARP */
if (err == EINPROGRESS) {
/* We will complete it in ip_arp_done */
return (err);
}
if (err != 0)
return (err);
} else {
/*
* Interfaces without underlying hardware don't do duplicate
* address detection.
*/
}
}
/*
* 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
{
/* Create a resolver cookie for ARP */
(uchar_t *)&ip_areq_template, 0);
return (ENOMEM);
}
/*
* 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.
*/
}
goto bad;
goto bad;
/*
* Record state needed to complete this operation when the
* DL_BIND_ACK shows up. Also remember the pre-allocated mblks.
*/
if (!success)
goto bad;
/*
* Save the unbind message for ill_dl_down(); it will be consumed when
* the interface goes down.
*/
/* Send down link-layer capabilities probe if not already done. */
/*
* 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.
*/
(strlen(srpc_domain) == 0)) {
if (dhcpinit() != 0)
}
/*
* This operation will complete in ip_rput_dlpi with either
* a DL_BIND_ACK or DL_ERROR_ACK.
*/
return (EINPROGRESS);
bad:
/*
* 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.
*/
return (ENOMEM);
}
/*
* 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
{
int err = 0;
int ipif_saved_ire_cnt;
int cnt;
ip1dbg(("ipif_up_done(%s:%u)\n",
/* Check if this is a loopback interface */
/*
* 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
*/
if (((tmp_ipif->ipif_flags &
continue;
/* first useable pre-existing interface */
break;
}
if (flush_ire_cache)
/*
* 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:
break;
case IRE_IF_NORESOLVER:
case IRE_LOOPBACK:
break;
default:
return (EINVAL);
}
/*
* 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.
*/
else
}
/*
* Can't use our source address. Select a different
* source address for the IRE_INTERFACE and IRE_LOCAL
*/
else
} else {
}
/* Create all the IREs associated with this interface */
/*
* If we're on a labeled system then make sure that zone-
* private addresses have proper remote host database entries.
*/
if (is_system_labeled() &&
return (EINVAL);
/* Register the source address for __sin6_src_id */
if (err != 0) {
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,
*irep++ = ire_create(
NULL, /* no gateway */
NULL,
&ip_loopback_mtuplus, /* max frag size */
NULL,
NULL, /* no send-to queue */
NULL,
ipif,
NULL,
0,
0,
0,
RTF_PRIVATE : 0,
NULL,
NULL,
ipst);
} else {
ip1dbg((
"ipif_up_done: not creating IRE %d for 0x%x: flags 0x%x\n",
}
} else {
}
/*
* If mask was not specified, use natural netmask of
* interface address. Also, store this mask back into the
* ipif struct.
*/
if (subnet_mask == 0) {
}
/* Set up the IRE_IF_RESOLVER or IRE_IF_NORESOLVER, as appropriate. */
/* ipif_subnet is ipif_pp_dst_addr for pt-pt */
} else {
}
ip1dbg(("ipif_up_done: ipif 0x%p ill 0x%p "
"creating if IRE ill_net_type 0x%x for 0x%x\n",
*irep++ = ire_create(
NULL, /* no gateway */
NULL,
NULL,
NULL, /* no recv queue */
stq, /* send-to queue */
ipif,
NULL,
0,
0,
0,
NULL,
NULL,
ipst);
}
/*
* 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.
*/
ip1dbg(("ipif_up_done: creating broadcast IRE\n"));
(MATCH_IRE_TYPE | MATCH_IRE_ILL));
(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) {
(MATCH_IRE_TYPE | MATCH_IRE_ILL));
(MATCH_IRE_TYPE | MATCH_IRE_ILL));
}
if (subnet_mask != 0xFFFFFFFF) {
(MATCH_IRE_TYPE | MATCH_IRE_ILL));
(MATCH_IRE_TYPE | MATCH_IRE_ILL));
}
}
/* If an earlier ire_create failed, get out now */
irep1--;
ip1dbg(("ipif_up_done: NULL ire found in ire_array\n"));
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.
*/
/* Mark it up, and increment counters. */
ill->ill_ipif_up_count++;
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) {
err = EADDRNOTAVAIL;
}
ill->ill_ipif_up_count--;
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.
*/
irep1--;
/*
* refheld by ire_add. refele towards the end of the func
*/
}
/*
* 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.
*/
if (phyi->phyint_groupname_len != 0) {
if (err != 0) {
ip1dbg(("ipif_up_done: illgrp allocation "
"failed, error %d\n", err));
goto bad;
}
}
}
/*
* When this is part of group, we need to make sure that
* any broadcast ires created because of this ipif coming
* so that we don't receive duplicate broadcast packets.
*/
/* Recover any additional IRE_IF_[NO]RESOLVER entries for this 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 there isn't a matching broadcast IRE,
* revert to the default for this netmask.
*/
} else {
}
}
}
/* This is the first interface on this ill */
/*
* Need to recover all multicast memberships in the driver.
* This had to be deferred until we had attached.
*/
}
/* Join the allhosts multicast address */
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.
*/
}
irep1--;
/* was held in ire_add */
ire_refrele(*irep1);
}
}
/* was held in ire_add */
ire_refrele(*irep1);
}
}
/* Broadcast an address mask reply. */
}
if (ipif_saved_irep != NULL) {
ipif_saved_ire_cnt * sizeof (ire_t *));
}
if (src_ipif_held)
/*
* This had to be deferred until we had bound. Tell routing sockets and
* others that this interface is up if it looks like the address has
* been validated. Otherwise, if it isn't ready yet, wait for
* duplicate address detection to do its thing.
*/
if (ipif->ipif_addr_ready) {
/* Let SCTP update the status for this ipif */
}
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).
*/
irep--;
ire_delete(*irep);
if (ire_added)
ire_refrele(*irep);
}
}
if (ipif_saved_irep != NULL) {
ipif_saved_ire_cnt * sizeof (ire_t *));
}
if (src_ipif_held)
return (err);
}
/*
* Turn off the ARP with the ILLF_NOARP flag.
*/
static int
{
/*
* 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.
*/
return (0);
/*
* Allocate an ARP on message (to be saved) and an ARP off message
*/
if (!arp_off_mp)
return (ENOMEM);
if (!arp_on_mp)
goto failed;
/* Send an AR_INTERFACE_OFF request */
return (0);
if (arp_off_mp)
return (ENOMEM);
}
/*
* Turn on ARP by turning off the ILLF_NOARP flag.
*/
static int
{
/*
* Send an AR_INTERFACE_ON request if we have already done
* an arp_off (which allocated the message).
*/
}
return (0);
}
/*
* Called after either deleting ill from the group or when setting
* FAILED or STANDBY on the interface.
*/
static void
{
/*
* When called from illgrp_delete, ill_group will be non-NULL.
* But when called from ip_sioctl_flags, it could be NULL if
* is not part of a group.
*/
return;
return;
/*
* Choose a good ill to be the next one for
* not yet marked when called from ip_sioctl_flags,
* we check for ill separately.
*/
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 *
{
int illcnt;
int i;
/*
* 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.
*/
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.
*/
return (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++) {
ILL_CAN_LOOKUP(retill)) {
break;
}
}
}
/*
* 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.
*/
{
if (ifindex != 0) {
return (NULL);
if (!IPIF_CAN_LOOKUP(ipif))
continue;
continue;
continue;
continue;
if ((isv6 &&
continue;
return (B_TRUE);
}
}
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 *
{
int index = 0;
if (ill->ill_usesrc_ifindex != 0) {
else
return (NULL);
}
/*
* If we're dealing with an unlabeled destination on a labeled system,
* make sure that we ignore source addresses that are incompatible with
* the destination's default label. That destination's default label
* must dominate the minimum label on the source address.
*/
if (is_system_labeled()) {
return (NULL);
}
}
/*
* 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.
*/
/*
* 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
*
* 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.
*/
if (!IPIF_CAN_LOOKUP(ipif))
continue;
/* Always skip NOLOCAL and ANYCAST interfaces */
continue;
continue;
continue;
/*
* Interfaces with 0.0.0.0 address are allowed to be UP,
* but are not valid as source addresses.
*/
continue;
/*
* Check compatibility of local address for
* destination's default label if we're on a labeled
* system. Incompatible addresses can't be used at
* all.
*/
continue;
incompat =
if (incompat)
continue;
}
/*
* We prefer not to use all all-zones addresses, if we
* can avoid it, as they pose problems with unlabeled
* destinations.
*/
if (!specific_found &&
(!same_subnet_only ||
ipif->ipif_subnet)) {
index = 0;
}
} else {
if (specific_found)
continue;
}
continue;
}
/* found a source address in the same subnet */
if (!same_subnet_only) {
index = 0;
}
} else {
if (same_subnet_only || ipif_other_found)
continue;
}
if (index == MAX_IPIF_SELECT_SOURCE) {
index = 0;
}
if (ipif_same_found)
break;
}
}
} else {
if (wrapped)
}
if (!IPIF_CAN_LOOKUP(ipif)) {
goto retry;
}
}
#ifdef DEBUG
char buf1[INET6_ADDRSTRLEN];
ip1dbg(("ipif_select_source(%s, %s) -> NULL\n",
} else {
char buf1[INET6_ADDRSTRLEN];
char buf2[INET6_ADDRSTRLEN];
ip1dbg(("ipif_select_source(%s, %s) -> %s\n",
}
#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
{
if (!(ipif->ipif_flags &
/*
* 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).
*/
(old_ipif->ipif_flags &
(IPIF_NOLOCAL|IPIF_ANYCAST)))) {
return;
}
/*
* Perform the same checks as when creating the
* IRE_INTERFACE in ipif_up_done.
*/
return;
return;
return;
/*
* We know that ipif uses some other source for its
* IRE_INTERFACE. Is it using the source of this
* old_ipif?
*/
return;
}
if (ip_debug > 2) {
/* ip1dbg */
pr_addr_dbg("ipif_recreate_interface_routes: deleting IRE for"
}
/*
* Can't use our source address. Select a different
* source address for the IRE_INTERFACE.
*/
/* Last resort - all ipif's have IPIF_NOLOCAL */
} else {
}
ire = ire_create(
NULL, /* no gateway */
NULL,
NULL, /* fast path header */
NULL, /* no recv from queue */
stq, /* send-to queue */
ipif,
NULL,
0,
0,
0,
0,
NULL,
NULL,
ipst);
int error;
/*
* We don't need ipif_ire anymore. We need to delete
* before we add so that ire_add does not detect
* duplicates.
*/
/* Held in ire_add */
}
/*
* Either we are falling through from above or could not
* allocate a replacement.
*/
if (need_rele)
}
/*
* 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
{
char buf[INET6_ADDRSTRLEN];
ip1dbg(("ipif_update_other_ipifs(%s, %s)\n",
/*
* If this part of a group, look at all ills as ipif_select_source
* borrows source address across all the ills in the group.
*/
continue;
}
}
}
/* ARGSUSED */
int
{
/*
* 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.
*/
}
/*
* Can operate on either a module or a driver queue.
* Returns an error if not a module queue.
*/
/* ARGSUSED */
int
{
char *cp;
char interf_name[LIFNAMSIZ];
ip1dbg((
"if_unitsel: IF_UNITSEL: no q_next\n"));
return (EINVAL);
}
return (EALREADY);
do {
/*
* 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.
*/
}
/* ARGSUSED */
int
{
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
{
/*
* No broadcast IREs for the LOOPBACK interface
* or others such as point to point and IPIF_NOXMIT.
*/
return;
ipst);
ipst);
/*
* If no net mask set, assume the default based on net class.
*/
if (test_subnet_mask == 0)
/*
* Check if there is a network broadcast ire associated with this ipif
*/
ipst);
/*
* Check if there is a subnet broadcast IRE associated with this ipif
*/
ipst);
/*
* No broadcast ire's associated with this ipif.
*/
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.
*/
/*
* Already checked the ipif passed in.
*/
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.
*/
continue;
}
/*
* Only interested in logical interfaces with valid local
* addresses or with the ability to broadcast.
*/
if ((ipif->ipif_subnet == 0) ||
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)) {
if (net_addr == test_net_addr) {
/*
* Use DEPRECATED ipif only if no good
* ires are available. subnet_addr is
* a better match than net_addr.
*/
(backup_ipif_net == NULL)) {
}
}
}
/*
* 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)) {
if (subnet_addr == test_subnet_addr) {
(backup_ipif_subnet == NULL)) {
}
}
}
/* Short circuit here if this ipif is deprecated */
if ((test_allzero_ire != NULL) &&
(backup_ipif_allzeros == NULL)) {
}
if ((test_allone_ire != NULL) &&
(!allone_bcast_ire_created) &&
(backup_ipif_allones == NULL)) {
}
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) {
}
if (need_subnet_bcast_ire && !subnet_bcast_ire_created) {
}
}
}
/*
* 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) ||
((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_subnet_bcast_ire && !subnet_bcast_ire_created &&
}
}
}
/*
* 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.
*/
irep1--;
ip0dbg(("ipif_check_bcast_ires: can't create "
"IRE_BROADCAST, memory allocation failure\n"));
irep--;
ire_delete(*irep);
}
goto bad;
}
}
int error;
irep1--;
if (error == 0) {
}
}
bad:
if (test_allzero_ire != NULL)
if (test_allone_ire != NULL)
if (test_net_ire != NULL)
if (test_subnet_ire != NULL)
}
/*
* 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.
*
* Can operate on either a module or a driver queue.
* Returns an error if not a module queue.
*/
/* ARGSUSED */
int
{
int err;
ip1dbg((
"if_sioctl_slifname: SIOCSLIFNAME: no q_next\n"));
return (EINVAL);
}
/*
* 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
*/
return (EALREADY);
return (EALREADY);
/*
* Set all the flags. Allows all kinds of override. Provide some
* sanity checking by not allowing IFF_BROADCAST and IFF_MULTICAST
* or it is a pt-pt link.
*/
/* 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 &&
ill->ill_bcast_addr_length == 0)) {
ip1dbg(("ip_setname: EINVAL 2\n"));
return (EINVAL);
}
/* Link not broadcast capable or IPv6 i.e. no broadcast */
ip1dbg(("ip_setname: EINVAL 3\n"));
return (EINVAL);
}
/* Can only be set with SIOCSLIFFLAGS */
ip1dbg(("ip_setname: EINVAL 4\n"));
return (EINVAL);
}
ip1dbg(("ip_setname: EINVAL 5\n"));
return (EINVAL);
}
/*
* Only allow the IFF_XRESOLV flag to be set on IPv6 interfaces.
*/
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
*/
/* We started off as V4. */
}
return (err);
}
/* ARGSUSED */
int
{
/*
* 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 a pointer to the ipif which matches the index, IP version type and
* zoneid.
*/
ipif_t *
{
*err = 0;
/*
* Indexes are stored in the phyint - a common structure
* to both IPv4 and IPv6.
*/
return (NULL);
}
GRAB_CONN_LOCK(q);
if (ILL_CAN_LOOKUP(ill)) {
if (IPIF_CAN_LOOKUP(ipif) &&
return (ipif);
}
}
} else if (ILL_CAN_WAIT(ill, q)) {
*err = EINPROGRESS;
return (NULL);
}
}
return (NULL);
}
typedef struct conn_change_s {
/*
* ipcl_walk function for changing interface index.
*/
static void
{
int i;
}
}
/*
* 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
{
continue;
}
}
}
}
}
/*
* 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
{
int old_index;
else
/*
* 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.
*/
return (EINVAL);
}
/* If the index is not changing, no work to do */
return (0);
/*
* Use ill_lookup_on_ifindex to determine if the
* new index is unused and if so allow the change.
*/
ipst);
ipst);
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.
*/
} else {
}
/* Send the routing sockets message */
return (0);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_lifindex(%s:%u %p)\n",
/* Get the interface index */
} else {
}
return (0);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_lifzone(%s:%u %p)\n",
/* Get the interface zone */
return (0);
}
/*
* Set the zoneid of an interface.
*/
/* ARGSUSED */
int
{
int err = 0;
if (!is_system_labeled())
return (ENOTSUP);
}
/* cannot assign instance zero to a non-global zone */
return (ENOTSUP);
/*
* 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.
*/
return (EINVAL);
return (EINVAL);
/*
* 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.
*/
if (err == EINPROGRESS)
return (err);
}
return (err);
}
static int
{
int err = 0;
ip1dbg(("ip_sioctl_zoneid_tail(%s:%u %p)\n",
if (CONN_Q(q))
ipst = CONNQ_TO_IPST(q);
else
ipst = ILLQ_TO_IPST(q);
/*
* For exclusive stacks we don't allow a different zoneid than
* global.
*/
zoneid != GLOBAL_ZONEID)
return (EINVAL);
/* Set the new zone id. */
/* Update sctp list */
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.
*/
}
return (err);
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_slifzone_restart(%s:%u %p)\n",
/*
* 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]().
*/
}
(void) ipif_up_done_v6(ipif);
} else {
(void) ipif_up_done(ipif);
}
return (EINVAL);
}
B_TRUE));
}
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_get_lifusesrc(%s:%u %p)\n",
return (0);
}
/* Find the previous ILL in this usesrc group */
static ill_t *
{
/* 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
{
do {
next_ill->ill_usesrc_ifindex = 0;
} while (next_ill->ill_usesrc_ifindex != 0);
}
/*
* Remove the client usesrc ILL from the list and relink to a new list
*/
int
{
/*
* 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);
}
/* Remove from the current list */
/* Only two elements in the list */
} else {
}
if (ifindex == 0) {
ucill->ill_usesrc_ifindex = 0;
return (0);
}
return (0);
}
/*
* Set the ill_usesrc and ill_usesrc_head fields. See synchronization notes in
* ip.c for locking details.
*/
/* ARGSUSED */
int
{
/*
* 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
*/
return (EINVAL);
}
if (ifindex == 0) {
/* non usesrc group interface, nothing to reset */
return (0);
}
/* valid reset request */
}
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
*/
err = EINPROGRESS;
/* Operation enqueued on the ipsq of the usesrc ILL */
goto done;
}
/* Check if the usesrc_ill is used for IPMP */
goto done;
}
/*
* If the client is already in use as a usesrc_ill or a usesrc_ill is
* already a client then return EINVAL
*/
goto done;
}
/*
* If the ill_usesrc_ifindex field is already set to what it needs to
* be then this is a duplicate operation.
*/
err = 0;
goto done;
}
ip1dbg(("ip_sioctl_slifusesrc: usesrc_cli_ill %s, usesrc_ill %s,"
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.
*/
else
/*
* ill_g_usesrc_lock global lock protects the ill_usesrc_grp_next
* and the ill_usesrc_ifindex fields
*/
if (reset_flg) {
if (ret != 0) {
}
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
*/
/* Insert at head of list */
} else {
ifindex);
if (ret != 0)
}
done:
if (ill_flag_changed) {
}
/* The refrele on the lifr_name ipif is done by ip_process_ioctl */
return (err);
}
/*
* comparison function used by avl.
*/
static int
{
/*
* let the phyint with the lowest index be on top.
*/
return (1);
return (-1);
return (0);
}
/*
* comparison function used by avl.
*/
static int
{
int res = 0;
else
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_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.
*/
} else {
}
/*
* ipif_down removes it from the group when the last ipif goes
* down.
*/
return;
/*
* Make sure this phyint was put in the list.
*/
if (phyi->phyint_ifindex > 0) {
phyi);
phyi);
}
/*
* remove phyint from the ipsq list.
*/
} else {
while (next_phyint != NULL) {
break;
}
}
}
if (phyi->phyint_groupname_len != 0) {
}
}
/*
* 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
{
avl_index_t where = 0;
/*
* 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.
*/
/*
* 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.
*/
if (isv6) {
} else {
}
/*
* This is a new ill, currently undergoing SLIFNAME
* So we could not have joined an IPMP group until now.
*/
/*
* This phyi_old is going away. Decref ipsq_refs and
* assert it is zero. The ipsq itself will be freed in
* ipsq_exit
*/
/* Get the singleton phyint out of the ipsq list */
} else {
/*
* 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.
*/
/* XXX We need a recovery strategy here. */
}
/*
* Reassigning ill_phyint automatically reassigns the ipsq also.
* pending mp is not affected because that is per ill basis.
*/
/*
* 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.
*/
/*
* Now that the phyint's ifindex has been assigned, complete the
* remaining
*/
}
/*
* Generate an event within the hooks framework to indicate that
* a new interface has just been added to IP. For this event to
* be generated, the network interface must, at least, have an
* ifindex assigned to it.
*
* This needs to be run inside the ill_g_lock perimeter to ensure
* that the ordering of delivered events to listeners matches the
* order of them in the kernel.
*
* This function could be called from ill_lookup_on_name. In that case
* the interface is loopback "lo", which will not generate a NIC event.
*/
ip2dbg(("ill_phyint_reinit: unexpected nic event %d "
}
info->hne_datalen);
} else {
ip2dbg(("ill_phyint_reinit: could not attach "
"ill_name information for PLUMB nic event "
}
} else
ip2dbg(("ill_phyint_reinit: could not attach PLUMB nic "
"event information for %s (ENOMEM)\n",
}
}
/*
* 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
{
return;
return;
}
}
static int
{
int err;
/* Set the obsolete NDD per-interface forwarding name. */
if (err != 0) {
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 ...
*/
/*
* If there is no IRE expiration timer running, get one started.
* igmp and mld timers will be triggered by the first multicast
*/
if (ipst->ips_ip_ire_expire_id == 0) {
/*
* acquire the lock and check again.
*/
if (ipst->ips_ip_ire_expire_id == 0) {
}
}
if (ipst->ips_mld_slowtimeout_id == 0) {
(void *)ipst,
}
} else {
if (ipst->ips_igmp_slowtimeout_id == 0) {
(void *)ipst,
}
}
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
{
char *ppa_ptr;
char *old_ptr;
char old_char;
int error;
/* The ppa is sent down by ifconfig or is chosen */
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 */
/*
* 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)
return (EINVAL);
}
/*
* terminate string before ppa
* save char at that location.
*/
ppa_ptr[0] = '\0';
/*
* 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.
*/
/* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */
}
/* Keep the !IN6_IS_ADDR_V4MAPPED assertions happy */
/*
* point-to-point or Non-mulicast capable
* interfaces won't do NUD unless explicitly
* configured to do so.
*/
}
/* Make sure IPv4 specific flag is not set on IPv6 if */
/*
* 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.
*/
}
/*
* Set the ILLF_ROUTER flag according to the global
* IPv6 forwarding policy.
*/
if (ipst->ips_ipv6_forward != 0)
/*
* Set the ILLF_ROUTER flag according to the global
* IPv4 forwarding policy.
*/
if (ipst->ips_ip_g_forward != 0)
}
/*
* The ipIfStatsIfindex and ipv6IfIcmpIfIndex assignments will
* be completed in ill_glist_insert -> ill_phyint_reinit
*/
if (!ill_allocate_mibs(ill))
return (ENOMEM);
/*
* Pick a default sap until we get the DL_INFO_ACK back from
* the driver.
*/
else
}
ill->ill_ifname_pending_err = 0;
/*
* undo null termination done above.
*/
return (error);
}
/*
* 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) {
} else {
/*
* undo null termination done above.
*/
}
/* Let SCTP know about this ILL */
B_TRUE);
return (EINPROGRESS);
/*
* If ill_phyint_reinit() changed our ipsq, then start on the new ipsq.
*/
else
/*
* restore previous values
*/
}
return (error);
}
void
{
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.
*/
for (i = 0; i < MAX_G_HEADS; i++) {
}
sizeof (phyint_t),
sizeof (phyint_t),
}
/*
* 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
{
int error;
} else {
ip1dbg(("ip_mrtun_rt_add: ipif is NULL\n"));
return (EINVAL);
}
ip1dbg(("ip_mrtun_rt_add: src_ipif is NULL\n"));
return (EINVAL);
}
/*
* 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.
*/
return (EEXIST);
}
ip2dbg(("ip_mrtun_rt_add: outgoing interface is type %d\n",
ipif->ipif_net_type));
return (EINVAL);
}
/*
* The outgoing interface must be non-resolver
* interface.
*/
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 */
NULL,
NULL, /* rfq */
stq,
ipif,
0,
0,
0,
NULL,
NULL,
ipst);
return (ENOMEM);
}
ip2dbg(("ip_mrtun_rt_add: mrtun route is created with type %d\n",
/*
* 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 */
/* route already exists by now */
return (EEXIST);
}
/*
* Store the ire that was just added. the caller
* ip_rts_request responsible for doing ire_refrele()
* on it.
*/
} else {
}
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
{
if (in_src_addr == INADDR_ANY)
return (EINVAL);
return (EINVAL);
/* search if this route exists in the ip_mrtun_table */
ip2dbg(("ip_mrtun_rt_delete: ire not found\n"));
return (ESRCH);
}
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 *
{
if (!IPIF_CAN_LOOKUP(ipif))
continue;
continue;
/*
* Point-to-point case. Look for exact match with
* destination address.
*/
return (ipif);
}
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.
*/
(ipif->ipif_net_mask >
best_ipif->ipif_net_mask) ||
((ipif->ipif_net_mask ==
best_ipif->ipif_net_mask) &&
}
}
}
}
return (best_ipif);
}
/*
* Save enough information so that we can recreate the IRE if
* the interface goes down and then up.
*/
static void
{
}
}
static void
{
/* Remove from ipif_saved_ire_mp list if it is there */
/*
* 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).
*/
break;
}
}
}
/*
* IP multirouting broadcast routes handling
* Append CGTP broadcast IREs to regular ones created
* at ifconfig time.
*/
static void
{
/*
* 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.
*/
ip2dbg(("ip_cgtp_filter_bcast_add: "
"ire_dst %p, ire_prim %p, ipif_prim %p\n",
(void *)ipif_prim));
(uchar_t *)&ip_g_all_ones,
NULL,
NULL,
NULL,
0,
0,
0,
NULL,
NULL,
ipst);
B_FALSE) == 0) {
ip2dbg(("ip_cgtp_filter_bcast_add: "
"added bcast_ire %p\n",
(void *)bcast_ire));
}
}
}
}
/*
* IP multirouting broadcast routes handling
* Remove the broadcast ire
*/
static void
{
ip2dbg(("ip_cgtp_filter_bcast_delete: "
"ire_dst %p, ire_prim %p, ipif_prim %p\n",
(void *)ipif_prim));
NULL,
ip2dbg(("ip_cgtp_filter_bcast_delete: "
"looked up bcast_ire %p\n",
(void *)bcast_ire));
}
}
}
}
/*
* IPsec hardware acceleration capabilities related functions.
*/
/*
* Free a per-ill IPsec capabilities structure.
*/
static void
{
}
/*
* 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)
{
return (NULL);
/* we need one bit per algorithm */
/* allocate memory to store algorithm flags */
goto nomem;
goto nomem;
/*
* Leave encr_algparm NULL for now since we won't need it half
* the time
*/
return (capab);
return (NULL);
}
/*
* Resize capability array. Since we're exclusive, this is OK.
*/
static boolean_t
{
return (B_TRUE);
}
return (B_FALSE);
}
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.
*/
{
struct ill_ipsec_capab_s *cpp;
ip0dbg(("ipsec_capab_match: ill doesn't exist\n"));
return (B_FALSE);
}
}
/*
* 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.
*/
/* 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.
*/
case SADB_SATYPE_ESP:
/* ill does not support ESP acceleration */
goto done;
goto done;
goto done;
goto done;
goto done;
}
break;
case SADB_SATYPE_AH:
/* ill does not support AH acceleration */
goto done;
goto done;
break;
}
if (need_refrele)
return (B_TRUE);
done:
if (need_refrele)
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
{
(dl_cap == DL_CAPAB_IPSEC_ESP));
switch (dl_cap) {
case DL_CAPAB_IPSEC_AH:
break;
case DL_CAPAB_IPSEC_ESP:
break;
}
/*
* Add ill index to list of hardware accelerators. If
* already in list, do nothing.
*/
;
/* if this is a new entry for this ill */
return;
}
} else if (!sadb_resync) {
/* not resync'ing SADB and an entry exists for this ill */
return;
}
/*
* IPsec module for protocol loaded, initiate dump
* of the SADB to this ill.
*/
}
/*
* Remove an ill from the list of IPsec capable ills.
*/
static void
{
dl_cap == DL_CAPAB_IPSEC_ESP);
;
/* entry not found */
return;
}
/* entry at front of list */
} else {
}
}
/*
* Handling of DL_CONTROL_REQ messages that must be sent down to
* an ill while having exclusive access.
*/
/* ARGSUSED */
static void
{
}
/*
* 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
netstack_t *ns)
{
/*
* 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..
*/
continue;
/*
* Make sure capabilities match before
* sending SA to ill.
*/
continue;
}
}
/*
* 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.
*/
continue;
}
mp_ship_list = nmp;
}
nmp = mp_ship_list;
/* restore the mblk to a sane state */
/*
* Ship the mblk to the ill, must be exclusive. Keep the
* reference to the ill as qwriter_ip() does a ill_referele().
*/
}
}
/*
* Derive an interface id from the link layer address.
* Knows about IEEE 802 and IEEE EUI-64 mappings.
*/
static boolean_t
{
char *addr;
if (phys_length != ETHERADDRL)
return (B_FALSE);
/* Form EUI-64 like address */
return (B_TRUE);
}
/* ARGSUSED */
static boolean_t
{
return (B_FALSE);
}
/* ARGSUSED */
static boolean_t
{
/*
* Multicast address mappings used over Ethernet/802.X.
* This address is used as a base for mappings.
*/
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;
return (B_TRUE);
}
/*
* Indicate by return value whether multicast is supported. If not,
*/
/* ARGSUSED */
static boolean_t
{
/*
* Multicast address mappings used over Ethernet/802.X.
* This address is used as a base for mappings.
*/
0x00, 0x00, 0x00 };
if (phys_length != ETHERADDRL)
return (B_FALSE);
*hw_start = 2;
return (B_TRUE);
}
/*
* Derive IPoIB interface id from the link layer address.
*/
static boolean_t
{
char *addr;
if (phys_length != 20)
return (B_FALSE);
/*
* 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.
*/
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
{
/*
* Base IPoIB IPv6 multicast address used for mappings.
*/
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;
/*
*/
v6_extract_mask->s6_addr32[0] = 0;
return (B_TRUE);
}
static boolean_t
{
/*
* Base IPoIB IPv4 multicast address used for mappings.
*/
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.
*/
*hw_start = 16;
/*
*/
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.
*/
{
return (B_FALSE);
}
if (!IPIF_CAN_LOOKUP(ipif))
continue;
continue;
continue;
return (B_TRUE);
}
return (B_TRUE);
}
if (maybe_ipif == NULL)
maybe_ipif = ipif;
}
if (maybe_ipif != NULL)
*ipifp = maybe_ipif;
}
return (maybe_ipif != NULL);
}
/*
* Same as ipif_lookup_zoneid() but looks at all the ills in the same group.
*/
{
/*
* We look at the passed-in ill first without grabbing ill_g_lock.
*/
return (B_TRUE);
}
/* ill not in a group */
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.
*/
do {
/*
* We don't call ipif_lookup_zoneid() on ill as we already know
* that it's not there.
*/
break;
}
}
/*
* Check if this ill is only being used to send ICMP probes for IPMP
*/
{
/*
* Check if the interface is FAILED, or INACTIVE
*/
return (B_TRUE);
return (B_FALSE);
}
/*
* Return a pointer to an ipif_t given a combination of (ill_idx,ipif_id)
* If a pointer to an ipif_t is returned then the caller will need to do
* an ill_refrele().
*/
ipif_t *
{
ipst);
return (NULL);
return (NULL);
}
if (!IPIF_CAN_LOOKUP(ipif))
continue;
break;
}
}
return (ipif);
}
/*
* Flush the fastpath by deleting any nce's that are waiting for the fastpath,
* There is one exceptions IRE_BROADCAST are difficult to recreate,
* so instead we just nuke their nce_fp_mp's; see ndp_fastpath_flush()
* for details.
*/
void
{
}
/*
* Set the physical address information for `ill' to the contents of the
* dl_notify_ind_t pointed to by `mp'. Must be called as writer, and will be
* asynchronous if `ill' cannot immediately be quiesced -- in which case
* EINPROGRESS will be returned.
*/
int
{
/* Changing DL_IPV6_TOKEN is not yet supported */
return (0);
}
/*
* We need to store up to two copies of `mp' in `ill'. Due to the
* design of ipsq_pending_mp_add(), we can't pass them as separate
* arguments to ill_set_phys_addr_tail(). Instead, chain them
* together here, then pull 'em apart in ill_set_phys_addr_tail().
*/
return (ENOMEM);
}
/*
* If we can quiesce the ill, then set the address. If not, then
* ill_set_phys_addr_tail() will be called from ipif_ill_refrele_tail().
*/
if (!ill_is_quiescent(ill)) {
/* call cannot fail since `conn_t *' argument is NULL */
return (EINPROGRESS);
}
return (0);
}
/*
* Once the ill associated with `q' has quiesced, set its physical address
* information to the values in `addrmp'. Note that two copies of `addrmp'
* are passed (linked by b_cont), since we sometimes need to save two distinct
* copies in the ill_t, and our context doesn't permit sleeping or allocation
* failure (we'll free the other copy if it's not needed). Since the ill_t
* is quiesced, we know any stale IREs with the old address information have
* already been removed, so we don't need to call ill_fastpath_flush().
*/
/* ARGSUSED */
static void
{
case DL_IPV6_LINK_LAYER_ADDR:
break;
case DL_CURR_PHYS_ADDR:
else
break;
default:
ASSERT(0);
}
/*
* If there are ipifs to bring up, ill_up_ipifs() will return nonzero,
* and ipsq_current_finish() will be called by ip_rput_dlpi_writer()
* or ip_arp_done() when the last ipif is brought up.
*/
}
/*
* Helper routine for setting the ill_nd_lla fields.
*/
void
{
}
#define IP "ip"
/*
* Issue REMOVEIF ioctls to have the loopback interfaces
* go away. Other interfaces are either I_LINKed or I_PLINKed;
* the former going away when the user-level processes in the zone
* are killed * and the latter are cleaned up by the stream head
* str_stack_shutdown callback that undoes all I_PLINKs.
*/
void
{
int error;
int rval;
#ifdef NS_DEBUG
(void) printf("ip_loopback_cleanup() stackid %d\n",
#endif
if (error) {
#ifdef DEBUG
printf("ip_loopback_cleanup: lyr ident get failed error %d\n",
error);
#endif
return;
}
if (error) {
#ifdef DEBUG
printf("ip_loopback_cleanup: open of UDP6DEV failed error %d\n",
error);
#endif
goto out;
}
/* LINTED - statement has no consequent */
if (error) {
#ifdef NS_DEBUG
printf("ip_loopback_cleanup: ioctl SIOCLIFREMOVEIF failed on "
"UDP6 error %d\n", error);
#endif
}
if (error) {
#ifdef NS_DEBUG
printf("ip_loopback_cleanup: open of UDPDEV failed error %d\n",
error);
#endif
goto out;
}
/* LINTED - statement has no consequent */
if (error) {
#ifdef NS_DEBUG
printf("ip_loopback_cleanup: ioctl SIOCLIFREMOVEIF failed on "
"UDP error %d\n", error);
#endif
}
out:
/* Close layered handles */
if (lh)
if (li)
}