ip_if.c revision e11c3f44f531fdff80941ce57c065d2ae861cefc
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1990 Mentat Inc. */
/*
* 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/mac_client.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 phyint_free(phyint_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 int ill_capability_ipsec_reset_size(ill_t *, int *, int *, int *,
int *);
static void ill_capability_dld_enable(ill_t *);
static void ill_capability_ack_thr(void *);
static void ill_capability_lso_enable(ill_t *);
static void ill_disband_usesrc_group(ill_t *);
#ifdef DEBUG
static void ill_trace_cleanup(const ill_t *);
static void ipif_trace_cleanup(const ipif_t *);
#endif
/*
* 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),
0
};
static ared_t ip6_ared_template = {
sizeof (ared_t) + IPV6_ADDR_LEN,
sizeof (ared_t),
sizeof (ared_t),
0
};
/*
* 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_NOFAILOVER, "NOFAILOVER" },
{ PHYI_FAILED, "FAILED" },
{ PHYI_STANDBY, "STANDBY" },
{ PHYI_INACTIVE, "INACTIVE" },
{ PHYI_OFFLINE, "OFFLINE" },
{ PHYI_IPMP, "IPMP" }
};
};
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.
*/
/*
* 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 *
{
} else {
}
return (NULL);
/*
* IPMP requires that the hardware address be included in all
* AR_ENTRY_ADD requests so that ARP can deduce the arl to send on.
* If there are no active underlying ills in the group (and thus no
* hardware address, DAD will be deferred until an underlying ill
* becomes active.
*/
return (NULL);
}
} else {
}
return (mp);
}
mblk_t *
{
} else {
}
}
mblk_t *
{
(char *)&addr));
}
mblk_t *
{
}
return (mp);
}
/*
* Completely vaporize a lower level tap and all associated interfaces.
* ill_delete is called only out of ip_close when the device control
* stream is being closed.
*/
void
{
/*
* ill_delete 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.
*/
/*
* Remove multicast references added as a result of calls to
* ip_join_allmulti().
*/
/*
* If the ill being deleted is under IPMP, boot it out of the illgrp.
*/
if (IS_UNDER_IPMP(ill))
/*
* 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
{
}
}
/*
* 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.
*/
/*
* 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));
}
}
}
/*
* 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.
*/
/*
* If this ill is an IPMP meta-interface, blow away the illgrp. This
* is safe to do because the illgrp has already been unlinked from the
* group by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find it.
*/
}
/*
* Take us out of the list of ILLs. ill_glist_delete -> 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]) {
}
}
#ifdef DEBUG
#endif
/* 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 ipx_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 `ipx_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 ipx_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 */
ipx->ipx_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 ipx_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 ipx_pending_mp.
* even if it is meant for another ill, since we have to enqueue
* a new mp now in ipx_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 ipx_pending_mp */
ipx->ipx_waitfor = 0;
ipx->ipx_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
* ipx_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. 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 */
}
}
/*
* Source address selection makes it possible for IRE_CACHE
* entries to be created with ire_stq coming from interface X
* and ipif coming from interface Y. 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. */
/* Remove any conn_*_ill depending on this ill */
}
/*
* ire_walk routine used to delete every IRE that depends on queues
* associated with 'ill'. (Always called as writer.)
*/
static void
{
/*
* Source address selection makes it possible for IRE_CACHE
* entries to be created with ire_stq coming from interface X
* and ipif coming from interface Y. Thus whenever interface
* X goes down, remove all references to it by checking both
* on ire_ipif and ire_stq.
*/
}
}
/*
*/
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
{
return;
/*
* We are starting a new cycle of capability negotiation.
* Free up the capab reset messages of any previous incarnation.
* We will do a fresh allocation when we get the response to our probe
*/
}
ip1dbg(("ill_capability_probe: starting capability negotiation\n"));
return;
}
void
{
return;
/*
* We turn off all capabilities except those pertaining to
* direct function call capabilities viz. ILL_CAPAB_DLD*
* which will be turned off by the corresponding reset functions.
*/
}
static void
{
int err;
if (ILL_MDT_CAPABLE(ill))
if (ILL_HCKSUM_CAPABLE(ill)) {
size += sizeof (dl_capability_sub_t) +
sizeof (dl_capab_hcksum_t);
}
size += sizeof (dl_capability_sub_t) +
sizeof (dl_capab_zerocopy_t);
}
size += sizeof (dl_capability_sub_t);
}
size += sizeof (dl_capability_sub_t) +
sizeof (dl_capab_dld_t);
}
/*
* Each handler fills in the corresponding dl_capability_sub_t
* inside the mblk,
*/
}
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
{
if (!ILL_MDT_CAPABLE(ill))
return;
mdt_subcap->mdt_flags = 0;
mdt_subcap->mdt_hdr_head = 0;
mdt_subcap->mdt_hdr_tail = 0;
}
static void
{
return;
/*
* The dl_capab_dld_t that follows the dl_capability_sub_t is not
* initialized below since it is not used by DLD.
*/
}
/*
* 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 int
{
int i, size = 0;
return (0);
/* 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 */
}
}
return (size);
}
/* ARGSUSED */
static void
{
int size;
if (size == 0)
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.
*/
}
static void
{
/*
* 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_DLD:
break;
default:
ip1dbg(("ill_capability_dispatch: unknown capab type %d\n",
}
}
/*
* 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
{
if (!ILL_HCKSUM_CAPABLE(ill))
return;
hck_subcap->hcksum_txflags = 0;
}
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
{
return;
}
/*
* DLD capability
* Refer to dld.h for more information regarding the purpose and usage
* of this capability.
*/
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 DLD sub-capability (version %d, "
return;
}
ip1dbg(("ill_capability_dld_ack: mid token for dld "
"capability isn't as expected; pass-thru module(s) "
"detected, discarding capability\n"));
return;
}
/*
* Copy locally to ensure alignment.
*/
"could not enable DLD version %d "
"for %s (ENOMEM)\n", DLD_CURRENT_VERSION,
return;
}
}
ip1dbg(("ill_capability_dld_ack: interface %s "
}
/*
* Typically capability negotiation between IP and the driver happens via
* DLPI message exchange. However GLD also offers a direct function call
* mechanism to exchange the DLD_DIRECT_CAPAB and DLD_POLL_CAPAB capabilities,
* But arbitrary function calls into IP or GLD are not permitted, since both
* of them are protected by their own perimeter mechanism. The perimeter can
* be viewed as a coarse lock or serialization mechanism. The hierarchy of
* these perimeters is IP -> MAC. Thus for example to enable the squeue
* polling, IP needs to enter its perimeter, then call ill_mac_perim_enter
* to enter the mac perimeter and then do the direct function calls into
* GLD to enable squeue polling. The ring related callbacks from the mac into
* the stack to add, bind, quiesce, restart or cleanup a ring are all
* protected by the mac perimeter.
*/
static void
{
int err;
}
static void
{
int err;
}
{
DLD_QUERY));
}
static void
{
int rc;
if (rc == 0) {
/*
* One time registration of flow enable callback function
*/
} else {
"capability, rc = %d\n", rc);
}
}
static void
{
int rc;
if (rc == 0) {
} else {
ip1dbg(("warning: could not enable POLL "
"capability, rc = %d\n", rc));
}
}
/*
* Enable the LSO capability.
*/
static void
{
int rc;
"could not enable LSO for %s (ENOMEM)\n",
return;
}
}
DLD_ENABLE)) == 0) {
ip1dbg(("ill_capability_lso_enable: interface %s "
} else {
}
}
static void
{
return;
}
}
static void
{
return;
/*
* For performance we avoid locks in the transmit data path
* and don't maintain a count of the number of threads using
* direct calls. Thus some threads could be using direct
* transmit calls to GLD, even after the capability mechanism
* turns it off. This is still safe since the handles used in
* the direct calls continue to be valid until the unplumb is
* completed. Remove the callback that was added (1-time) at
* capab enable time.
*/
}
NULL, DLD_DISABLE);
}
NULL, DLD_DISABLE);
}
/*
* 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.
*/
NULL, DLD_DISABLE);
}
}
/*
* Capability Negotiation protocol
*
* We don't wait for DLPI capability operations to finish during interface
* bringup or teardown. Doing so would introduce more asynchrony and the
* Instead the 'ipsq_current_ipif' of the ipsq is not cleared as long as
* the 'ill_dlpi_deferred' chain is non-empty. This ensures that the next
* exclusive operation won't start until the DLPI operations of the previous
* exclusive operation complete.
*
* The capability state machine is shown below.
*
* state next state event, action
*
* IDCS_UNKNOWN IDCS_PROBE_SENT ill_capability_probe
* IDCS_PROBE_SENT IDCS_OK ill_capability_ack
* IDCS_PROBE_SENT IDCS_FAILED ip_rput_dlpi_writer (nack)
* IDCS_OK IDCS_RENEG Receipt of DL_NOTE_CAPAB_RENEG
* IDCS_OK IDCS_RESET_SENT ill_capability_reset
* IDCS_RESET_SENT IDCS_UNKNOWN ill_capability_ack_thr
* IDCS_RENEG IDCS_PROBE_SENT ill_capability_ack_thr ->
* ill_capability_probe.
*/
/*
* Dedicated thread started from ip_stack_init that handles capability
* disable. This thread ensures the taskq dispatch does not fail by waiting
* for resources using TQ_SLEEP. The taskq mechanism is used to ensure
* that direct calls to DLD are done in a cv_waitable context.
*/
void
{
char name[64];
name);
for (;;) {
}
if (ipst->ips_capab_taskq_quit)
break;
}
thread_exit();
}
/*
* Consume a new-style hardware capabilities negotiation ack.
* Called via taskq on receipt of DL_CAPABBILITY_ACK.
*/
static void
ill_capability_ack_thr(void *arg)
{
/*
* We have received the ack for our DL_CAPAB reset request.
* There isnt' anything in the message that needs processing.
* All message based capabilities have been disabled, now
* do the function call based capability disable.
*/
if (reneg)
goto done;
}
if (capp->dl_sub_length == 0) {
/* no new-style capabilities */
goto done;
}
/* make sure the driver supplied correct dl_sub_length */
ip0dbg(("ill_capability_ack: bad DL_CAPABILITY_ACK, "
goto done;
}
/*
* 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;
}
}
done:
}
/*
* This needs to be started in a taskq thread to provide a cv_waitable
* context.
*/
void
{
TQ_NOSLEEP) != 0)
return;
/*
* The taskq dispatch failed. Signal the ill_taskq_dispatch thread
* which will do the dispatch using TQ_SLEEP to guarantee success.
*/
}
/*
* 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.
*/
int ix;
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);
}
/*
* Helper function for ill_forward_set().
*/
static void
{
ip1dbg(("ill_forward_set: %s %s forwarding on %s",
if (enable)
else
/* Notify routing socket listeners of this change. */
}
/*
* Set an ill's ILLF_ROUTER flag appropriately. Send up RTS_IFINFO routing
* socket messages for each interface whose flags we change.
*/
int
{
return (0);
if (IS_LOOPBACK(ill))
return (EINVAL);
/*
* Update all of the interfaces in the group.
*/
/*
* Update the IPMP meta-interface.
*/
return (0);
}
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
{
/*
* NOTE: we're called separately for each ill in an illgrp,
* so don't match across the illgrp.
*/
B_FALSE);
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: [a-zA-Z]+[a-zA-Z0-9._]*[0-9]+
* The final number (PPA) must not have any leading zeros. Upon success, a
* pointer to the start of the PPA is returned; otherwise NULL is returned.
*/
static char *
ill_get_ppa_ptr(char *name)
{
int ppa_ndx, i;
/*
* Check that the first character is [a-zA-Z], and that the last
* character is [0-9].
*/
return (NULL);
/*
* Set `ppa_ndx' to the PPA start, and check for leading zeroes.
*/
break;
return (NULL);
/*
* Check that the intermediate characters are [a-z0-9.]
*/
for (i = 1; i < ppa_ndx; i++) {
return (NULL);
}
}
}
/*
* 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
{
}
/*
* remove ill from the global list.
*/
static void
{
return;
/*
* 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;
}
/* Generate one last event for this ill. */
/*
* 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
return;
}
/*
* There are no ills left on this phyint; pull it out of the phyint
* avl trees, and free it.
*/
if (phyi->phyint_ifindex > 0) {
phyi);
phyi);
}
}
/*
* 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 */
/* minaddr */
/* maxaddr */
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 */
}
return (EINVAL);
}
}
&where);
return (0);
}
/* Initialize the per phyint ipsq used for serialization */
static boolean_t
{
return (B_FALSE);
if (enter) {
#ifdef 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
{
}
/* Pick a unique ifindex */
{
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);
}
/*
* Assign a unique interface index for the phyint.
*/
static boolean_t
{
}
/*
* 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_dlpi_pending for ipsq_current_finish() to work properly */
/* No resolver here. */
/* Initialize the ipsq */
goto done;
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.
*/
/*
* ill_glist_insert() -> ill_phyint_reinit() may have merged IPSQs.
* If so, free our original one.
*/
/*
* 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,
buf,
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
{
int min_mtu;
/*
* 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;
}
/*
* Synthetic DLPI types such as SUNW_DL_IPMP specify a zero SDU,
* but we must ensure a minimum IP MTU is used since other bits of
* IP will fly apart otherwise.
*/
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.
*
* NOTE: The IPMP meta-interface is special-cased because it starts
* with no underlying interfaces (and thus an unknown broadcast
* address length), but we enforce that an interface is broadcast-
* capable as part of allowing it to join a group.
*/
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.
*/
}
/* For IPMP, PHYI_IPMP should already be set by ipif_allocate() */
/* 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, or all ones, but allow
* all ones netmask.
*/
return (B_FALSE);
/* A given netmask overrides the "guess" netmask */
if (subnet_mask != 0)
return (B_FALSE);
}
/*
* Even if the netmask is all ones, we do not allow address to be
* 255.255.255.255
*/
if (addr == INADDR_BROADCAST)
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
}
#define V6_IPIF_LINKLOCAL(p) \
/*
* Compare two given ipifs and check if the second one is better than
* the first one using the order of preference (not taking deprecated
* into acount) specified in ipif_lookup_multicast().
*/
static boolean_t
{
/* Check the least preferred first. */
/* If both ipifs are the same, use the first one. */
return (B_FALSE);
else
return (B_TRUE);
}
/* For IPv6, check for link local address. */
/* The second one is equal or less preferred. */
return (B_FALSE);
} else {
return (B_TRUE);
}
}
/* Then check for point to point interface. */
return (B_FALSE);
} else {
return (B_TRUE);
}
}
/* old_ipif is a normal interface, so no need to use the new one. */
return (B_FALSE);
}
/*
* Find a mulitcast-capable ipif given an IP instance and zoneid.
* The ipif must be up, and its ill must multicast-capable, not
* condemned, not an underlying interface in an IPMP group, and
* not a VNI interface. Order of preference:
*
* 1a. normal
* 1b. normal, but deprecated
* 2a. point to point
* 2b. point to point, but deprecated
* 3a. link local
* 3b. link local, but deprecated
* 4. loopback.
*/
ipif_t *
{
if (isv6)
else
continue;
}
continue;
}
!IPIF_CAN_LOOKUP(ipif)) {
continue;
}
/*
* Found one candidate. If it is deprecated,
* remember it in dep_ipif. If it is not deprecated,
* remember it in saved_ipif.
*/
isv6)) {
/*
* If the previous dep_ipif does not
* belong to the same ill, we've done
* a ipif_refhold() on it. So we need
* to release it.
*/
}
continue;
}
if (saved_ipif == NULL) {
saved_ipif = ipif;
} else {
saved_ipif = ipif;
}
}
}
/*
* Before going to the next ill, do a ipif_refhold() on the
* saved ones.
*/
}
/*
* If we have only the saved_ipif, return it. But if we have both
* saved_ipif and dep_ipif, check to see which one is better.
*/
if (saved_ipif != NULL) {
return (dep_ipif);
} else {
return (saved_ipif);
}
}
return (saved_ipif);
} else {
return (dep_ipif);
}
}
/*
* This function is called when an application does not specify an interface
* calls ire_lookup_multi() to look for an interface route for the
* specified multicast group. Doing this allows the administrator to add
* prefix routes for multicast to indicate which interface to be used for
* multicast traffic in the above scenario. The route could be for all
* multicast (224.0/4), for a single multicast group (a /32 route) or
* anything in between. If there is no such multicast route, we just find
* any multicast capable interface and return it. The returned ipif
* is refhold'ed.
*/
ipif_t *
{
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);
}
/*
* Common function for ipif_lookup_addr() and ipif_lookup_addr_exact().
*/
static 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;
}
/*
* Check if the address exists in the system.
* We don't hold the conn_lock as we will not perform defered ipsqueue
* operation.
*/
{
continue;
/* Allow the ipif to be down */
/*
* XXX Different from ipif_lookup_addr(), we don't do
* twice lookups. As from bind()'s point of view, we
* may return once we find a match.
*/
/*
* Allow bind() to be successful even if the
* ipif is with IPIF_CHANGING bit set.
*/
return (B_TRUE);
}
}
}
return (B_FALSE);
}
/*
* Lookup an ipif with the specified address. For point-to-point links we
* look for matches on either the destination address or the local address,
* but we skip the local address check if IPIF_UNNUMBERED is set. If the
* `match_ill' argument is non-NULL, the lookup is restricted to that ill
* (or illgrp if `match_ill' is in an IPMP group).
*/
ipif_t *
{
}
/*
* Special abbreviated version of ipif_lookup_addr() that doesn't match
* `match_ill' across the IPMP group. This function is only needed in some
* corner-cases; almost everything should use ipif_lookup_addr().
*/
static ipif_t *
{
}
/*
* 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.
* If the `match_ill' argument is non-NULL, the lookup is restricted to that
* ill (or illgrp if `match_ill' is in an IPMP group).
* 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 IREs 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
*/
static boolean_t
{
return (B_FALSE);
}
}
return (B_FALSE);
}
return (B_TRUE);
}
{
return (B_FALSE);
}
}
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);
}
/*
* return true if the ipif can be destroyed: the ipif has to be quiescent
*/
static boolean_t
{
}
/*
* Determine if the ipif or ill in question has become quiescent and if so
* for the ipif_down (or ill_down)
*/
void
{
/* ip_modclose() may be waiting */
}
goto unlock;
goto unlock;
switch (ipx->ipx_waitfor) {
case IPIF_DOWN:
if (!ipif_is_quiescent(ipif))
goto unlock;
break;
case IPIF_FREE:
if (!ipif_is_freeable(ipif))
goto unlock;
break;
case ILL_DOWN:
if (!ill_is_quiescent(ill))
goto unlock;
break;
case ILL_FREE:
/*
* ILL_FREE is only for loopback; normal ill teardown waits
* synchronously in ip_modclose() without using ipx_waitfor,
* handled by the cv_broadcast() at the top of this function.
*/
if (!ill_is_freeable(ill))
goto unlock;
break;
default:
}
/*
* NOTE: all of the qwriter_ip() calls below use CUR_OP since
* we can only get here when the current operation decides it
* it needs to quiesce via ipsq_pending_mp_add().
*/
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:
B_TRUE);
return;
case M_IOCTL:
case M_IOCDATA:
return;
default:
}
return;
}
#ifdef DEBUG
/* Reuse trace buffer from beginning (if reached the end) and record trace */
static void
{
lastref++;
if (lastref == TR_BUF_MAX)
lastref = 0;
}
static void
th_trace_free(void *value)
{
}
/*
* Find or create the per-thread hash table used to track object references.
* The ipst argument is NULL if we shouldn't allocate.
*
* Accesses per-thread data, so there's no need to lock here.
*/
static mod_hash_t *
{
mod_hash_t *mh;
char name[256];
int retv;
return (NULL);
(void *)curthread);
/*
* We use mod_hash_create_extended here rather than the more
* obvious mod_hash_create_ptrhash because the latter has a
* hard-coded KM_SLEEP, and we'd prefer to fail rather than
* block.
*/
return (NULL);
}
/*
* We trace ills, ipifs, ires, and nces. All of these are
* per-IP-stack, so the lock on the thread list is as well.
*/
}
}
{
mod_hash_t *mh;
return (B_FALSE);
/*
* Attempt to locate the trace buffer for this obj and thread.
* If it does not exist, then allocate a new trace buffer and
* insert into the hash.
*/
return (B_FALSE);
(mod_hash_val_t)th_trace) != 0) {
return (B_FALSE);
}
} else {
}
return (B_TRUE);
}
/*
* For the purpose of tracing a reference release, we assume that global
* tracing is always on and that the same thread initiated the reference hold
* is releasing.
*/
void
th_trace_unref(const void *obj)
{
int retv;
mod_hash_t *mh;
}
/*
* If tracing has been disabled, then we assume that the reference counts are
* now useless, and we clear them out before destroying the entries.
*/
void
{
mod_hash_t *mh;
int retv;
&val) == 0) {
if (trace_disable)
}
}
}
void
{
if (ipif->ipif_trace_disable)
return;
}
}
void
{
if (!ipif->ipif_trace_disable)
}
void
{
if (ill->ill_trace_disable)
return;
}
}
void
{
if (!ill->ill_trace_disable)
}
/*
* Called when ipif is unplumbed or when memory alloc fails. Note that on
* failure, ipif_trace_disable is set.
*/
static void
{
}
/*
* Called when ill is unplumbed or when memory alloc fails. Note that on
* failure, ill_trace_disable is set.
*/
static void
{
}
#endif /* DEBUG */
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).
*/
if (gw_addr == 0)
return (ENETUNREACH);
/*
* Get the ipif, if any, corresponding to the gw_addr
*/
ipst);
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, /* no send-to queue */
ipif,
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);
}
/*
* 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)
if (ipif_refheld)
return (EEXIST);
}
/*
* 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,
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. We also OR in the RTF_BLACKHOLE flag as
* these interface routes, by definition, can only be that.
*
* 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) {
}
/*
* 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.
*/
/*
* With IPMP, we allow host routes to influence in.mpathd's
* target selection. However, if the test addresses are on
* their own network, the above lookup will fail since the
* underlying IRE_INTERFACEs are marked hidden. So allow
* hidden test IREs to be found and try again.
*/
if (!(match_flags & MATCH_IRE_MARK_TESTHIDDEN)) {
goto again;
}
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 src nce */
NULL, /* no recv-from queue */
NULL, /* no send-to queue */
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.
*/
}
}
/*
* 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.
* 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().
*/
ipst);
else if (err == EINPROGRESS)
return (err);
else
err = 0;
if (ipif_refheld) {
}
} 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.
*/
if (mask == IP_HOST_MASK)
else if (mask == 0)
type = IRE_DEFAULT;
else
type = IRE_PREFIX;
}
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 (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;
case SWITCH_OP:
/* only one switch operation is currently allowed */
break;
default:
}
}
}
/*
* Dequeue the next message that requested exclusive access to this IPSQ's
* xop. Specifically:
*
* 1. If we're still processing the current operation on `ipsq', then
* dequeue the next message for the operation (from ipx_mphead), or
* return NULL if there are no queued messages for the operation.
* These messages are queued via CUR_OP to qwriter_ip() and friends.
*
* 2. If the current operation on `ipsq' has completed (ipx_current_ipif is
* not set) see if the ipsq has requested an xop switch. If so, switch
* `ipsq' to a different xop. Xop switches only happen when joining or
* leaving IPMP groups and require a careful dance -- see the comments
* in-line below for details. If we're leaving a group xop or if we're
* joining a group xop and become writer on it, then we proceed to (3).
* Otherwise, we return NULL and exit the xop.
*
* 3. For each IPSQ in the xop, return any switch operation stored on
* ipsq_switch_mp (set via SWITCH_OP); these must be processed before
* any other messages queued on the IPSQ. Otherwise, dequeue the next
* exclusive operation (queued via NEW_OP) stored on ipsq_xopq_mphead.
* Note that if the phyint tied to `ipsq' is not using IPMP there will
* only be one IPSQ in the xop. Otherwise, there will be one IPSQ for
* each phyint in the group, including the IPMP meta-interface phyint.
*/
static mblk_t *
{
/*
* Grab all the locks we need in the defined order (ill_g_lock ->
* ipsq_lock -> ipx_lock); ill_g_lock is needed to use ipsq_next.
*/
/*
* Dequeue the next message associated with the current exclusive
* operation, if any.
*/
goto out;
}
goto empty;
/*
* The exclusive operation that is now being completed has
* requested a switch to a different xop. This happens
* when an interface joins or leaves an IPMP group. Joins
* happen through SIOCSLIFGROUPNAME (ip_sioctl_groupname()).
* Leaves happen via SIOCSLIFGROUPNAME, interface unplumb
* (phyint_free()), or interface plumb for an ill type
* not in the IPMP group (ip_rput_dlpi_writer()).
*
* Xop switches are not allowed on the IPMP meta-interface.
*/
/*
* We're switching back to our own xop, so we have two
* that we are leaving.
*
* First, pull ourselves out of the group ipsq list.
* This is safe since we're writer on ill_g_lock.
*/
/*
* Second, prepare to exit the group xop. The actual
* ipsq_exit() is done at the end of this function
* since we cannot hold any locks across ipsq_exit().
* Note that although we drop the group's ipx_lock, no
* threads can proceed since we're still ipx_writer.
*/
/*
* Third, set ipx to point to our own xop (which was
* inactive and therefore can be entered).
*/
} else {
/*
* We're switching from our own xop to a group xop.
* The requestor of the switch must ensure that the
* group xop cannot go away (e.g. by ensuring the
* phyint associated with the xop cannot go away).
*
* If we can become writer on our new xop, then we'll
* do the drain. Otherwise, the current writer of our
* new xop will do the drain when it exits.
*
* First, splice ourselves into the group IPSQ list.
* This is safe since we're writer on ill_g_lock.
*/
/*
* Second, exit our own xop, since it's now unused.
* This is safe since we've got the only reference.
*/
/*
* Third, set ipx to point to our new xop, and check
* if we can become writer on it. If we cannot, then
* the current writer will drain the IPSQ group when
* it exits. Our ipsq_xop is guaranteed to be stable
* because we're still holding ipsq_lock.
*/
goto out;
}
}
/*
* Fourth, become writer on our new ipx before we continue
* with the drain. Note that we never dropped ipsq_lock
* above, so no other thread could've raced with us to
* become writer first. Also, we're holding ipx_lock, so
* no other thread can examine the ipx right now.
*/
#ifdef DEBUG
#endif
}
do {
/*
* So that other operations operate on a consistent and
* complete phyint, a switch message on an IPSQ must be
* handled prior to any other operations on that IPSQ.
*/
goto out;
}
goto out;
}
/*
* There are no messages. Further, we are holding ipx_lock, hence no
* new messages can end up on any IPSQ in the xop.
*/
#ifdef DEBUG
#endif
out:
/*
* If we completely emptied the xop, then wake up any threads waiting
* to enter any of the IPSQ's associated with it.
*/
if (emptied) {
do {
continue;
}
/*
* Now that all locks are dropped, exit the IPSQ we left.
*/
return (mp);
}
/*
* 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.
* ipx_current_ipif will be set if some exclusive op is in progress,
* and the ipsq_exit logic will start the next enqueued op after
* completion of the current op. If 'force' is used, we don't wait
* for the enqueued ops. 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
{
/*
* Note that the relationship between ill and ipsq is fixed as long as
* the ill is not ILL_CONDEMNED. Holding ipsq_lock ensures the
* relationship between the IPSQ and xop cannot change. However,
* since we cannot hold ipsq_lock across the cv_wait(), it may change
* while we're waiting. We wait on ill_cv and rely on ipsq_exit()
* waking up all ills in the xop when it becomes available.
*/
for (;;) {
return (B_FALSE);
}
break;
} else {
}
}
ipx->ipx_reentry_cnt++;
#ifdef DEBUG
#endif
return (B_TRUE);
}
{
}
void
{
}
/*
* The ipsq_t (ipsq) is the synchronization data structure used to serialize
* certain critical operations like plumbing (i.e. most set ioctls), multicast
* 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_REQ initiated as part of bringing
* up the interface) and are enqueued in ipx_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 ipx_mphead and calls
* the reentry point. When the list at ipx_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 ipx_pending_ipif are set. ipx_current_ipif is set throughout the
* execution of the ioctl and ipsq_exit does not start the next ioctl unless
* ipx_current_ipif is NULL which happens only once the ioctl is complete and
* all associated DLPI operations have completed.
*/
/*
* Try to enter the IPSQ corresponding to `ipif' or `ill' exclusively (`ipif'
* and `ill' cannot both be specified). Returns a pointer to the entered IPSQ
* refholding it as necessary. If the IPSQ cannot be entered and `func' is
* non-NULL, then `func' will be called back with `q' and `mp' once the IPSQ
* can be entered. If `func' is NULL, then `q' and `mp' are ignored.
*/
ipsq_t *
{
/* Only 1 of ipif or ill can be specified */
/*
* lock ordering: conn_lock -> ill_lock -> ipsq_lock -> ipx_lock.
* ipx of an ipsq can't change when ipsq_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 operation
* 3. Enter the ipsq if there is no current writer and this is a new
* operation and the operation queue is empty and there is no
* operation currently in progress
*/
/* Success. */
ipx->ipx_reentry_cnt++;
#ifdef DEBUG
#endif
return (ipsq);
}
return (NULL);
}
/*
* Try to enter the IPSQ corresponding to `ill' as writer. The caller ensures
* ill is valid by refholding it if necessary; we will refrele. If the IPSQ
* cannot be entered, the mp is queued for completion.
*/
void
{
/*
* Drop the caller's refhold on the ill. This is safe since we either
* entered the IPSQ (and thus are exclusive), or failed to enter the
* IPSQ, in which case we return without accessing ill anymore. This
* is needed because func needs to see the correct refcount.
* e.g. removeif can work only then.
*/
}
}
/*
* Exit the specified IPSQ. If this is the final exit on it then drain it
* prior to exiting. Caller must be writer on the specified IPSQ.
*/
void
{
queue_t *q;
return;
}
for (;;) {
/*
* If we've changed to a new IPSQ, and the phyint associated
* with the old one has gone away, free the old IPSQ. Note
* that this cannot happen while the IPSQ is in a group.
*/
}
break;
/*
* If 'q' is an conn queue, it is valid, since we did a
* a refhold on the conn at the start of the ioctl.
* If 'q' is an ill queue, it is valid, since close of an
* ill will clean up its IPSQ.
*/
}
}
/*
* Start the current exclusive operation on `ipsq'; associate it with `ipif'
* and `ioccmd'.
*/
void
{
}
/*
* Finish the current exclusive operation on `ipsq'. Usually, this will allow
* the next exclusive operation to begin once we ipsq_exit(). However, if
* pending DLPI operations remain, then we will wait for the queue to drain
* before allowing the next exclusive operation to begin. This ensures that
* DLPI operations from one exclusive operation are never improperly processed
* as part of a subsequent exclusive operation.
*/
void
{
/*
* For SIOCLIFREMOVEIF, the ipif has been already been blown away
* (but in that case, IPIF_CHANGING will already be clear and no
* pending DLPI messages can remain).
*/
}
ipx->ipx_current_ioctl = 0;
if (dlpi_pending == DL_PRIM_INVAL) {
}
}
/*
* 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.
*/
/* dequeue mp */
else
}
} else {
}
}
}
/*
* Parse an iftun_req structure coming down SIOC[GS]TUNPARAM ioctls,
* refhold and return the associated ipif
*/
/* ARGSUSED */
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);
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);
return (0);
}
/*
* Return the total number of ipifs.
*/
static uint_t
{
if (IS_UNDER_IPMP(ill))
continue;
numifs++;
}
}
return (numifs);
}
/*
* Return the total number of ipifs.
*/
static uint_t
{
else
continue;
!(lifn_flags & LIFC_NOXMIT))
continue;
!(lifn_flags & LIFC_TEMPORARY))
continue;
if (((ipif->ipif_flags &
IPIF_DEPRECATED)) ||
IS_LOOPBACK(ill) ||
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)
*/
if (IS_UNDER_IPMP(ill))
continue;
continue;
/* old behaviour */
return (EINVAL);
} else {
goto if_copydone;
}
}
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;
&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);
continue;
!(flags & LIFC_NOXMIT))
continue;
!(flags & LIFC_TEMPORARY))
continue;
if (((ipif->ipif_flags &
IPIF_DEPRECATED)) ||
IS_LOOPBACK(ill) ||
continue;
(zoneid != GLOBAL_ZONEID ||
!(flags & LIFC_ALLZONES)))
continue;
return (EINVAL);
} else {
goto lif_copydone;
}
}
lifr->lifr_addrlen =
&ipif->ipif_v6net_mask);
} else {
lifr->lifr_addrlen =
}
lifr++;
}
}
}
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 {
}
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);
}
}
/*
* ARP IOCTLs.
* How does IP get in the business of fronting ARP configuration/queries?
* Well it's 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
{
/* 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);
}
}
/*
* IPMP ARP special handling:
*
* 1. Since ARP mappings must appear consistent across the group,
* prohibit changing ARP mappings on the underlying interfaces.
*
* 2. Since ARP mappings for IPMP data addresses are maintained by
* IP itself, prohibit changing them.
*
* 3. For proxy ARP, use a functioning hardware address in the group,
* provided one exists. If one doesn't, just add the entry as-is;
* ipmp_illgrp_refresh_arpent() will refresh it if things change.
*/
if (IS_UNDER_IPMP(ill)) {
return (EPERM);
}
case SIOCSARP:
case SIOCSXARP:
if (!ipmp_ill_is_active(proxy_ill))
}
/* FALLTHRU */
case SIOCDARP:
case SIOCDXARP:
return (EPERM);
}
}
}
/*
* 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) {
} else {
ipst);
}
}
break;
}
/*
* Fill in the rest of the ARP operation fields.
*/
/* Translate the flags. */
if (flags & ATF_AUTHORITY)
/*
* If this is a permanent AR_ENTRY_ADD on the IPMP interface, track it
* so that IP can update ARP as the active ills in the group change.
*/
/*
* The second part of the conditional below handles a corner
* case: if this is proxy ARP and the IPMP group has no active
* interfaces, we can't send the request to ARP now since it
* won't be able to build an ACE. So we return success and
* notify ARP about the proxy ARP entry once an interface
* becomes active.
*/
}
}
/*
* 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 */
pending_mp, 0) != 0);
} else {
}
/*
* Up to ARP it goes. The response will come back in ip_wput() as an
* M_IOCACK, and will be handed to ip_sioctl_iocack() for completion.
*/
/*
* If we created an IPMP ARP entry, mark that we've notified ARP.
*/
return (EINPROGRESS);
}
/*
* Parse an [x]arpreq structure coming down SIOC[GSD][X]ARP ioctls, identify
* the associated sin and refhold and return the associated ipif via `ci'.
*/
int
{
int err;
struct sockaddr_dl *sdl;
/* ioctl comes down on a conn */
if (connp->conn_af_isv6)
return (ENXIO);
/* Verified in ip_wput_nondata */
return (ENXIO);
return (EINVAL);
} else {
}
return (err);
return (ENXIO);
}
} else {
/*
* Either an SIOC[DGS]ARP or an SIOC[DGS]XARP with an sdl_nlen
* of 0: use the IP address to find the ipif. If the IP
* address is an IPMP test address, ire_ftable_lookup() will
* find the wrong ill, so we first do an ipif_lookup_addr().
*/
return (ENXIO);
}
}
}
return (ENXIO);
}
return (0);
}
/*
* Link or unlink the illgrp on IPMP meta-interface `ill' depending on the
* value of `ioccmd'. While an illgrp is linked to an ipmp_grp_t, it is
* accessible from that ipmp_grp_t, which means SIOCSLIFGROUPNAME can look it
* up and thus an ill can join that illgrp.
*
* open()/close() primarily because close() is not allowed to fail or block
* forever. On the other hand, I_PUNLINK *can* fail, and there's no reason
* why anyone should ever need to I_PUNLINK an in-use IPMP stream. To ensure
* symmetric behavior (e.g., doing an I_PLINK after and I_PUNLINK undoes the
* I_PUNLINK) we defer linking to I_PLINK. Separately, we also fail attempts
* to I_LINK since I_UNLINK is optional and we'd end up in an inconsistent
* state if I_UNLINK didn't occur.
*
* once because of the way ifconfig works. However, it's OK to link the same
* illgrp more than once, or unlink an illgrp that's already unlinked.
*/
static int
{
int err;
switch (ioccmd) {
case I_LINK:
return (ENOTSUP);
case I_PLINK:
break;
case I_PUNLINK:
/*
* Require all UP ipifs be brought down prior to unlinking the
* illgrp so any associated IREs (and other state) is torched.
*/
return (EBUSY);
/*
* NOTE: We hold ipmp_lock across the unlink to prevent a race
* with an SIOCSLIFGROUPNAME request from an ill trying to
* join this group. Specifically: ills trying to join grab
* ipmp_lock and bump a "pending join" counter checked by
* ipmp_illgrp_unlink_grp(). During the unlink no new pending
* joins can occur (since we have ipmp_lock). Once we drop
* ipmp_lock, subsequent SIOCSLIFGROUPNAME requests will not
* find the illgrp (since we unlinked it) and will return
* EAFNOSUPPORT. This will then take them back through the
* IPMP meta-interface plumbing logic in ifconfig, and thus
* back through I_PLINK above.
*/
return (err);
default:
break;
}
return (0);
}
/*
* 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
{
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
* request ip_sioctl_plink_ipmod() to skip the consistency checks.
* The utility will use SIOCSLIFMUXID to store the muxids. This is
* not atomic, and can leave the streams unplumbable if the utility
* is interrupted before it does the SIOCSLIFMUXID.
*/
if (err == EINPROGRESS)
return;
goto done;
}
/*
* This is an I_{P}LINK sent down by ifconfig through the ARP module;
* ARP has appended this last mblk to tell us whether the lower stream
* is an arp-dev stream or an IP module stream.
*/
if (ipmxp->ipmx_arpdev_stream) {
/*
* The lower stream is the arp-dev stream.
*/
if (err == EINPROGRESS)
return;
goto done;
}
return;
}
}
/*
* To ensure consistency between IP and ARP, the following
* 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 &&
goto done;
}
goto done;
} else {
/*
* The lower stream is probably an IP module stream. Do
* consistency checking.
*/
if (err == EINPROGRESS)
return;
}
done:
if (err == 0)
else
/* Conn was refheld in ip_sioctl_copyin_setup */
if (CONN_Q(q))
if (entered_ipsq)
}
/*
* Process I_{P}LINK and I_{P}UNLINK requests named by `ioccmd' and pointed to
* by `mp' and `li' for the IP module stream (if li->q_bot is in fact an IP
* module stream). If `doconsist' is set, then do the extended consistency
* checks requested by ifconfig(1M) and (atomically) set ill_ip_muxid here.
* Returns zero on success, EINPROGRESS if the operation is still pending, or
* an error code on failure.
*/
static int
{
int err = 0;
const char *name;
/*
* Walk the lower stream to verify it's the IP module stream.
* The IP module is identified by its name, wput function,
* and non-NULL q_next. STREAMS ensures that the lower stream
* (li->l_qbot) will not vanish until this ioctl completes.
*/
break;
}
}
/*
* If this isn't an IP module stream, bail.
*/
return (0);
return (EINPROGRESS);
}
if (doconsist) {
/*
* Consistency checking requires that I_{P}LINK occurs
* prior to setting ill_ip_muxid, and that I_{P}UNLINK
* occurs prior to clearing ill_arp_muxid.
*/
goto done;
}
}
goto done;
/*
* As part of I_{P}LINKing, stash the number of downstream modules and
* the read queue of the module immediately below IP in the ill.
* These are used during the capability negotiation below.
*/
ill->ill_lmod_cnt = 0;
ill->ill_lmod_cnt++;
}
if (doconsist)
/*
* Mark the ipsq busy until the capability operations initiated below
* returns, but the capability operation may complete asynchronously
* much later.
*/
/*
* If there's at least one up ipif on this ill, then we're bound to
* the underlying driver via DLPI. In that case, renegotiate
* capabilities to account for any possible change in modules
* interposed between IP and the driver.
*/
if (ill->ill_ipif_up_count > 0) {
if (islink)
else
}
done:
if (entered_ipsq)
return (err);
}
/*
* 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 */
/* ARGSUSED3 */
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 {
}
/*
* Find the pending message; if we're exclusive, it'll be on our IPSQ.
* Otherwise, we can find it from our ioc_id.
*/
else
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;
}
}
/*
* If this was a failed AR_ENTRY_ADD or a successful AR_ENTRY_DELETE
* on the IPMP meta-interface, ensure any ARP entries added in
* ip_sioctl_arp() are deleted.
*/
}
/*
* 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) {
ipsq);
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.
* 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;
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);
/* We are now exclusive on the IPSQ */
if (found_sep) {
/* 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. Plumbing for lo0:0 happens in ipif_lookup_on_name()
* instead.
*/
goto done;
}
/* Return created name with ioctl */
/* Set address */
}
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_freeable(ill)) {
return (0);
}
if (success)
return (EINPROGRESS);
else
return (EINTR);
}
}
/* Find based on address */
return (EAFNOSUPPORT);
/* We are a writer, so we should be able to lookup */
ipst);
} else {
return (EAFNOSUPPORT);
/* We are a writer, so we should be able to lookup */
ipst);
}
return (EADDRNOTAVAIL);
}
/*
* It is possible for a user to send an SIOCLIFREMOVEIF with
* lifr_name of the physical interface but with an ip address
* lifr_addr of a logical interface plumbed over it.
* So update ipx_current_ipif now that ipif points to the
* correct one.
*/
/* 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 */
if (ipif_is_freeable(ipif)) {
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.
*/
}
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);
}
/*
* Set interface flags. Many flags require special handling (e.g.,
* bringing the interface down); see below for details.
*
* 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 = 0;
ip1dbg(("ip_sioctl_flags(%s:%u %p)\n",
} else {
}
/*
* Have the flags been set correctly until 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.
*/
/*
* Explicitly fail attempts to change flags that are always invalid on
* an IPMP meta-interface.
*/
return (EINVAL);
/*
* Check which flags will change; silently ignore flags which userland
* is not allowed to control. (Because these flags may change between
* SIOCGLIFFLAGS and SIOCSLIFFLAGS, and that's outside of userland's
* control, we need to silently ignore them rather than fail.)
*/
if (turn_on == 0)
return (0); /* No change */
/*
* All test addresses must be IFF_DEPRECATED (to ensure source address
* selection avoids them) -- so force IFF_DEPRECATED on, and do not
* allow it to be turned off.
*/
return (EINVAL);
if (turn_on & IFF_NOFAILOVER) {
flags |= IFF_DEPRECATED;
}
/*
* On underlying interfaces, only allow applications to manage test
* addresses -- otherwise, they may get confused when the address
* moves as part of being brought up. Likewise, prevent an
* application-managed test address from being converted to a data
* address. To prevent migration of administratively up addresses in
* the kernel, we don't allow them to be converted either.
*/
if (IS_UNDER_IPMP(ill)) {
return (EINVAL);
if ((turn_off & IFF_NOFAILOVER) &&
return (EINVAL);
}
/*
* Only allow the IFF_XRESOLV and IFF_TEMPORARY flags to be set on
* IPv6 interfaces.
*/
return (EINVAL);
/*
* cannot turn off IFF_NOXMIT on VNI 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);
}
/*
* 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.
*/
/*
* All functioning PHYI_STANDBY interfaces start life PHYI_INACTIVE
* (otherwise, we'd immediately use them, defeating standby). Also,
* since PHYI_INACTIVE has a separate meaning when PHYI_STANDBY is not
* set, don't allow PHYI_STANDBY to be set if PHYI_INACTIVE is already
* set, and clear PHYI_INACTIVE if PHYI_STANDBY is being cleared. We
* also don't allow PHYI_STANDBY if VNI is enabled since its semantics
* will not be honored.
*/
if (turn_on & PHYI_STANDBY) {
/*
* No need to grab ill_g_usesrc_lock here; see the
* synchronization notes in ip.c.
*/
return (EINVAL);
if (!(flags & PHYI_FAILED)) {
flags |= PHYI_INACTIVE;
turn_on |= PHYI_INACTIVE;
}
}
if (turn_off & PHYI_STANDBY) {
flags &= ~PHYI_INACTIVE;
}
/*
* PHYI_FAILED and PHYI_INACTIVE are mutually exclusive; fail if both
* would end up on.
*/
(PHYI_FAILED | PHYI_INACTIVE))
return (EINVAL);
/*
* If ILLF_ROUTER changes, we need to change the ip forwarding
* status of the interface.
*/
/*
* 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. */
/*
* PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the
* same to the kernel: if any of them has been set by
* userland, the interface cannot be used for data traffic.
*/
/*
* It's possible the ill is part of an "anonymous"
* IPMP group rather than a real group. In that case,
* there are no other interfaces in the group and thus
* no need to call ipmp_phyint_refresh_active().
*/
if (IS_UNDER_IPMP(ill))
}
if (phyint_flags_modified) {
}
}
}
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 are
* IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, IPIF_NOLOCAL, ILLF_NOARP,
* ILLF_NONUD, IPIF_PRIVATE, IPIF_ANYCAST, IPIF_PREFERRED, and
* IPIF_NOFAILOVER. This is done by bring the ipif down, changing the
* flags and bringing it back up again. For IPIF_NOFAILOVER, the act
* of bringing it back up will trigger the address to be moved.
*/
IPIF_NOFAILOVER)) {
/*
* 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
/*
* PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the same to
* the kernel: if any of them has been set by userland, the interface
* cannot be used for data traffic.
*/
/*
* It's possible the ill is part of an "anonymous" IPMP group
* rather than a real group. In that case, there are no other
* interfaces in the group and thus no need for us to call
* ipmp_phyint_refresh_active().
*/
if (IS_UNDER_IPMP(ill))
}
/*
* XXX ipif_up really does not know whether a phyint flags
* was modified or not. So, it sends up information on
* only one routing sockets message. As we don't bring up
* the interface and also set PHYI_ flags simultaneously
* 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) {
}
}
} else {
}
/*
* Update the flags in SCTP's IPIF list, ipif_up() will do
* this in need_up case.
*/
}
return (err);
}
/*
* Restart the flags operation now that the refcounts have dropped to zero.
*/
/* ARGSUSED */
int
{
ip1dbg(("ip_sioctl_flags_restart(%s:%u %p)\n",
/* cast to uint16_t prevents unwanted sign extension */
} else {
}
}
/*
* 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.
*/
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",
/*
* Since no applications should ever be setting metrics on underlying
* interfaces, we explicitly fail to smoke 'em out.
*/
return (EINVAL);
/*
* 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
}
}
}
}
/*
* Refresh IPMP meta-interface MTU if necessary.
*/
if (IS_UNDER_IPMP(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
{
}
/*
* Clone the contents of `sipif' to `dipif'. Requires that both ipifs are
* administratively down (i.e., no DAD), of the same type, and locked. Note
* that the clone is complete -- including the seqid -- and the expectation is
* that the caller will either free or overwrite `sipif' before it's unlocked.
*/
static void
{
/*
* While dipif is down right now, it might've been up before. Since
* it's changing identity, its packet counters need to be reset.
*/
dipif->ipif_ib_pkt_count = 0;
dipif->ipif_ob_pkt_count = 0;
dipif->ipif_fo_pkt_count = 0;
/*
* As per the comment atop the function, we assume that these sipif
* fields will be changed before sipif is unlocked.
*/
}
/*
* Transfer the contents of `sipif' to `dipif', and then free (if `virgipif'
* is NULL) or overwrite `sipif' with `virgipif', which must be a virgin
* (unreferenced) ipif. Also, if `sipif' is used by the current xop, then
* transfer the xop to `dipif'. Requires that all ipifs are administratively
* down (i.e., no DAD), of the same type, and unlocked.
*/
static void
{
int ipx_current_ioctl;
/*
* Grab all of the locks that protect the ipif in a defined order.
*/
} else {
}
}
/*
* Transfer ownership of the current xop, if necessary.
*/
}
}
/*
* 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.
*/
if (acquire_g_lock)
id = 0;
break; /* non-consecutive id */
id++;
}
/* limit number of logical interfaces */
if (acquire_g_lock)
return (-1);
}
/* we have a real id; insert ipif in the right place */
break; /* found correct location */
}
} else {
if (acquire_g_lock)
return (-1);
}
if (acquire_g_lock)
return (0);
}
static void
{
break;
}
}
}
/*
* 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;
if (insert) {
return (NULL);
}
/* -1 id should have been replaced by real id */
}
/*
* If this is ipif zero, configure ill/phyint-wide information.
* Defer most configuration until we're guaranteed we're attached.
*/
if (id == 0) {
/*
* Set PHYI_IPMP and also set PHYI_FAILED since there
* are no active interfaces. Similarly, PHYI_RUNNING
* isn't set until the group has an active interface.
*/
/*
* Create the illgrp (which must not exist yet because
* the zeroth ipif is created once per ill). However,
* do not not link it to the ipmp_grp_t until I_PLINK
* is called; see ip_sioctl_plink_ipmp() for details.
*/
if (insert) {
}
return (NULL);
}
} else {
/*
* By default, PHYI_RUNNING is set when the zeroth
* ipif is created. For other ipifs, we don't touch
* it since DLPI notifications may have changed it.
*/
}
}
/*
* 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.
*/
} 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)
goto out;
/*
* NOTE: The IPMP meta-interface is special-cased because it starts
* with no underlying interfaces (and thus an unknown broadcast
* address length), but all interfaces that can be placed into an IPMP
* group are required to be broadcast-capable.
*/
/*
* 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 {
}
}
}
}
out:
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
{
return;
/* Delete the mapping for the local address */
ip1dbg(("ipif_resolver_down: arp cmd %x for %s:%u\n",
}
/*
* Make IPMP aware of the deleted data address.
*/
/*
* 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.
*/
/*
* If this was the last ipif on an IPMP interface, purge any
* IPMP ARP entries associated with it.
*/
/* Send up AR_INTERFACE_DOWN message */
ip1dbg(("ipif_resolver_down: arp cmd %x for %s:%u\n",
}
/* Tell ARP to delete the multicast mappings */
ip1dbg(("ipif_resolver_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);
/*
* IPMP meta-interfaces don't have any inherent multicast mappings,
* and instead use the ones on the underlying interfaces.
*/
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 IP 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 ILLF_XRESOLV interface. Honors ILLF_NOARP.
*
* The enumerated value res_act tunes the behavior:
* * Res_act_initial: set up all the resolver structures for a new
* IP address.
* * Res_act_defend: tell ARP that it needs to send a single gratuitous
* ARP message in defense of the address.
* * Res_act_rebind: tell ARP to change the hardware address for an IP
* address (and issue gratuitous ARPs). Used by ipmp_ill_bind_ipif().
*
* 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 &&
}
}
/*
* If we're here via ipif_up(), then the ipif won't be bound
* yet -- add it to the group, which will bind it if possible.
* (We would add it in ipif_up(), but deleting on failure
* there is gruesome.) If we're here via ipmp_ill_bind_ipif(),
* then the ipif has already been added to the group and we
* just need to use the binding.
*/
/*
* We couldn't bind the ipif to an ill yet,
* so we have nothing to publish.
*/
}
added_ipif = B_TRUE;
}
}
/*
* Add an entry for the local address in ARP only if it
* is not UNNUMBERED and it is suitable for publishing.
*/
if (res_act == Res_act_defend) {
if (arp_add_mp == NULL)
goto failed;
/*
* 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;
}
/*
* Allocate an ARP add message and an ARP delete message (the
* latter is saved for use when the address goes down).
*/
goto failed;
goto failed;
if (res_act != Res_act_initial)
goto arp_setup_multicast;
} 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.
*/
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, or for the IPMP interface (since it has no link-layer).
*/
if (err != 0)
goto failed;
}
done:
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)
arp_add_mp = NULL;
} else {
}
if (arp_add_mapping_mp != NULL) {
ip1dbg(("ipif_resolver_up: MAPPING_ADD for %s:%u\n",
}
if (res_act == Res_act_initial) {
else
if (err != 0) {
err));
goto failed;
}
}
if (arp_del_mp != NULL) {
}
if (arp_down_mp != NULL) {
}
if (arp_del_mapping_mp != NULL) {
}
ip1dbg(("ipif_resolver_up: FAILED\n"));
if (added_ipif)
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
{
/* ACE_F_UNVERIFIED restarts DAD */
/*
* 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;
}
}
static void
{
B_FALSE);
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)
}
static void
{
}
static int
{
int err;
return (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) {
return (err);
}
}
}
return (0);
}
/*
* This function is called to bring up all the ipifs that were up before
* bringing the ill down via ill_down_ipifs().
*/
int
{
int err;
if (err != 0)
return (err);
}
/*
* Bring down any IPIF_UP ipifs on ill.
*/
static void
{
/*
* are modified below are protected implicitly since we are a writer
*/
/*
* 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.
*/
/*
* they are dependent on ipif.
*/
}
}
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++) {
}
}
}
/*
* Redo source address selection. This is called when a
* non-NOLOCAL/DEPRECATED/ANYCAST ipif comes up.
*/
void
{
/*
* Underlying interfaces are only used for test traffic and thus
* should always send with their (deprecated) source addresses.
*/
if (IS_UNDER_IPMP(ill))
return;
else
}
}
/*
* Finish the group join started in ip_sioctl_groupname().
*/
/* ARGSUSED */
static void
{
/* IS_UNDER_IPMP() won't work until ipmp_ill_join_illgrp() is called */
}
}
}
/*
* Process an SIOCSLIFGROUPNAME request.
*/
/* ARGSUSED */
int
{
int err = 0;
/*
* Note that phyint_grp can only change here, where we're exclusive.
*/
return (EINVAL);
/*
* If the name hasn't changed, there's nothing to do.
*/
goto unlock;
/*
* Handle requests to rename an IPMP meta-interface.
*
* Note that creation of the IPMP meta-interface is handled in
* userland through the standard plumbing sequence. As part of the
* plumbing the IPMP meta-interface, its initial groupname is set to
* the name of the interface (see ipif_set_values_tail()).
*/
goto unlock;
}
/*
* Handle requests to add or remove an IP interface from a group.
*/
/*
* Moves are handled by first removing the interface from
* its existing group, and then adding it to another group.
* So, fail if it's already in a group.
*/
if (IS_UNDER_IPMP(ill)) {
goto unlock;
}
goto unlock;
}
/*
* Check if the phyint and its ills are suitable for
* inclusion into the group.
*/
goto unlock;
/*
* Checks pass; join the group, and enqueue the remaining
* illgrp joins for when we've become part of the group xop
* and are exclusive across its IPSQs. Since qwriter_ip()
* requires an mblk_t to scribble on, and since `mp' will be
* freed as part of completing the ioctl, allocate another.
*/
goto unlock;
}
/*
* Before we drop ipmp_lock, bump gr_pend* to ensure that the
* IPMP meta-interface ills needed by `phyi' cannot go away
* before ip_join_illgrps() is called back. See the comments
* in ip_sioctl_plink_ipmp() for more.
*/
return (0);
} else {
/*
* Request to remove the interface from a group. If the
* interface is not in a group, this trivially succeeds.
*/
if (IS_UNDER_IPMP(ill))
return (0);
}
return (err);
}
/*
* Process an SIOCGLIFBINDING request.
*/
/* ARGSUSED */
int
{
return (EINVAL);
return (0);
}
return (0);
}
/*
* Process an SIOCGLIFGROUPNAME request.
*/
/* ARGSUSED */
int
{
else
return (0);
}
/*
* Process an SIOCGLIFGROUPINFO request.
*/
/* ARGSUSED */
int
{
/* ip_wput_nondata() verified mp->b_cont->b_cont */
return (ENOENT);
}
return (0);
}
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",
/*
* ip_rput does not pass up normal (M_PROTO) DLPI messages
* after ILL_CONDEMNED is set. So in the unplumb case, we call
* ill_capability_dld_disable disable rightaway. If this is not
* an unplumb operation then the disable happens on receipt of
* the capab ack via ip_rput_dlpi_writer ->
* ill_capability_ack_thr. In both cases the order of
* the operations seen by DLD is capability disable followed
* by DL_UNBIND. Also the DLD capability disable needs a
* cv_wait'able context.
*/
}
/*
* 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).
*/
}
static 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.
*/
}
/*
* Helper function for ill_dlpi_send().
*/
/* ARGSUSED */
static void
{
}
/*
* 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.
*/
void
{
/*
* To ensure that any DLPI requests for current exclusive operation
* are always completely sent before any DLPI messages for other
* operations, require writer access before enqueuing.
*/
if (!IAM_WRITER_ILL(ill)) {
/* qwriter_ip() does the ill_refrele() */
return;
}
/* Must queue message. Tail insertion */
ip1dbg(("ill_dlpi_send: deferring request for %s\n",
return;
}
}
static void
{
}
void
{
if (ill->ill_capab_pending_cnt == 0 &&
}
/*
* Send all deferred DLPI messages without waiting for their ACKs.
*/
void
{
/*
* Clear ill_dlpi_pending so that the message is not queued in
* ill_dlpi_send().
*/
}
}
/*
* Check if the DLPI primitive `prim' is pending; print a warning if not.
*/
{
return (B_TRUE);
}
/*
* During teardown, ill_dlpi_dispatch() will send DLPI requests
* without waiting, so don't print any warnings in that case.
*/
return (B_FALSE);
}
if (pending == DL_PRIM_INVAL) {
"received unsolicited ack for %s on %s\n",
} else {
"received unexpected ack for %s on %s (expecting %s)\n",
}
return (B_FALSE);
}
/*
* Complete the current DLPI operation associated with `prim' on `ill' and
* start the next queued DLPI operation (if any). If there are no queued DLPI
* operations and the ill's current exclusive IPSQ operation has finished
* (i.e., ipsq_current_finish() was called), then clear ipsq_current_ipif to
* allow the next exclusive IPSQ operation to begin upon ipsq_exit(). See
* the comments above ipsq_current_finish() for details.
*/
void
{
if (ipx->ipx_current_done) {
}
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 (e.g., 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.
* (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
* uint_t ipif_ilm_cnt; Number of ilms's references 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
* uint_t ill_ilm_cnt; Number of ilms 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
* ire_add_v[46] where the ire is actually added to the ire hash table.
* The count is decremented in ire_inactive where the ire is destroyed.
*
* nce's reference ill's thru nce_ill and the count of nce's associated with
* an ill is recorded in ill_nce_cnt. This is incremented atomically in
* ndp_add_v4()/ndp_add_v6() where the nce is actually added to the
* table. Similarly it is decremented in ndp_inactive() where the nce
* is destroyed.
*
* ilm's reference to the ipif (for IPv4 ilm's) or the ill (for IPv6 ilm's)
* is incremented in ilm_add_v6() and decremented before the ilm is freed
* in ilm_walker_cleanup() or ilm_delete().
*
*
* 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, ill}_cnt and
* ipif_refcnt both drop to zero. See also: comments above IPIF_DOWN_OK()
* in ip.h
*
* 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 current exclusive operation 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 memberships we established in ipif_multicast_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) {
}
}
/*
* Delete all IRE's pointing at this ipif or its source address.
*/
ipst);
} else {
ipst);
}
/*
* Since the interface is now down, it may have just become
* inactive. Note that this needs to be done even for a
* lll_logical_down(), or ARP entries will not get correctly
* restored when the interface comes back up.
*/
if (IS_UNDER_IPMP(ill))
}
/*
* 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
/*
* 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;
/*
* Has to be after removing the routes in ipif_down_delete_ire.
*/
}
/*
* 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;
/*
* 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 are called for IRE_CACHEs whose ire_stq or ire_ipif matches
* ill, but we only want to delete the IRE if ire_ipif matches.
*/
}
/*
* Delete all the IREs whose ire_stq's reference `ill_arg'. IPMP uses this
* instead of ill_ipif_cache_delete() because ire_ipif->ipif_ill references
* the IPMP ill.
*/
void
{
/*
* We are called for IRE_CACHEs whose ire_stq or ire_ipif matches
* ill, but we only want to delete the IRE if ire_stq matches.
*/
}
/*
* Delete all broadcast IREs with a source address on `ill_arg'.
*/
static void
{
}
/*
* 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 */
/* If necessary, clear the cached source ipif rotor. */
}
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.
*/
#ifdef DEBUG
#endif
/* Ask SCTP to take it out of it list */
/* Get it out of the ILL interface list. */
/* Free the memory. */
}
/*
* Sets `buf' to an ipif name of the form "ill_name:id", or "ill_name" if "id"
* is zero.
*/
void
{
char *name;
buf[0] = '\0';
}
len -= 1;
}
/*
* 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;
}
/*
* 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
{
int err;
ip1dbg(("ipif_multicast_up\n"));
return;
return;
ip1dbg(("ipif_multicast_up - addmulti\n"));
/*
* Join the all hosts multicast address. We skip this for
* underlying IPMP interfaces since they should be invisible.
*/
if (!IS_UNDER_IPMP(ill)) {
if (err != 0) {
ip0dbg(("ipif_multicast_up: "
"all_hosts_mcast failed %d\n", err));
return;
}
}
/*
* Enable multicast for the solicited node multicast address
*/
if (err != 0) {
ip0dbg(("ipif_multicast_up: solicited MC"
" failed %d\n", err));
if (ipif->ipif_joined_allhosts) {
ipif->ipif_joined_allhosts = 0;
}
return;
}
}
} else {
return;
/* Join the all hosts multicast address */
ip1dbg(("ipif_multicast_up - addmulti\n"));
if (err) {
return;
}
}
}
/*
* Blow away any multicast groups that we joined in ipif_multicast_up().
* (Explicit memberships are blown away in ill_leave_multicast() when the
* ill is brought down.)
*/
void
{
int err;
ip1dbg(("ipif_multicast_down\n"));
if (!ipif->ipif_multicast_up)
return;
ip1dbg(("ipif_multicast_down - delmulti\n"));
B_TRUE);
if (err != 0)
ipif->ipif_multicast_up = 0;
return;
}
/*
* Leave the all-hosts multicast address.
*/
if (ipif->ipif_joined_allhosts) {
if (err != 0) {
ip0dbg(("ipif_multicast_down: all_hosts_mcast "
"failed %d\n", err));
}
ipif->ipif_joined_allhosts = 0;
}
/*
* 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,
* 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 {
}
/*
* 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,
rfq,
stq,
type,
ipif,
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.
* Note that the same IPv6 link-local address is allowed as long as the ills
* are not on the same link.
*/
int
{
return (0);
else
&our_v6addr))
continue;
else if ((IN6_IS_ADDR_LINKLOCAL(&our_v6addr) ||
continue;
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.
*/
int
{
int err = 0;
/* Shouldn't get here if it is already up. */
return (EALREADY);
/*
* If this is a request to bring up a data address on an interface
* under IPMP, then move the address to its IPMP meta-interface and
* try to bring it up. One complication is that the zeroth ipif for
* an ill is special, in that every ill always has one, and that code
* throughout IP deferences ill->ill_ipif without holding any locks.
*/
/*
* The ipif being brought up should be quiesced. If it's not,
* something has gone amiss and we need to bail out. (If it's
* quiesced, we know it will remain so via IPIF_CHANGING.)
*/
if (!ipif_is_quiescent(ipif)) {
return (EINVAL);
}
/*
* If we're going to need to allocate ipifs, do it prior
* to starting the move (and grabbing locks).
*/
B_FALSE);
B_FALSE);
return (ENOMEM);
}
}
/*
* Grab or transfer the ipif to move. During the move, keep
* ill_g_lock held to prevent any ill walker threads from
* seeing things in an inconsistent state.
*/
} else {
}
/*
* Place the ipif on the IPMP ill. If the zeroth ipif on
* the IPMP ill is a stub (0.0.0.0 down address) then we
* replace that one. Otherwise, pick the next available slot.
*/
} else {
/*
* No more available ipif_id's -- put it back
* on the original ill and fail the operation.
* Since we're writer on the ill, we can be
* sure our old slot is still available.
*/
if (ipif_orig_id == 0) {
NULL);
} else {
}
return (ENOMEM);
}
}
/*
* Tell SCTP that the ipif has moved. Note that even if we
* had to allocate a new ipif, the original sequence id was
* preserved and therefore SCTP won't know.
*/
/*
* If the ipif being brought up was on slot zero, then we
* first need to bring up the placeholder we stuck there. In
* ip_rput_dlpi_writer(), ip_arp_done(), or the recursive call
* to ipif_up() itself, if we successfully bring up the
* placeholder, we'll check ill_move_ipif and bring it up too.
*/
if (ipif_orig_id == 0) {
if (err != EINPROGRESS)
return (err);
}
/*
* Bring it up on the IPMP ill.
*/
}
/*
* 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 the resolver. For IPv6, this cranks up the
* external resolver if one is configured, but even if an
* external resolver isn't configured, it must be called to
* reset DAD state. For IPv6, if an external resolver is not
* being used, ipif_resolver_up() will never return
* EINPROGRESS, so we can always call ipif_ndp_up() here.
* Note that if an external resolver is being used, there's no
* need to call ipif_ndp_up() since it will do nothing.
*/
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.
*/
}
}
return (err);
}
/*
* 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 */
return (ENOMEM);
}
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
* dhcifname 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:
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);
}
if (IS_LOOPBACK(ill)) {
/*
* 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 */
&ip_loopback_mtuplus, /* max frag size */
NULL,
NULL, /* no send-to queue */
ipif,
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, /* no recv queue */
stq, /* send-to queue */
ipif,
0,
0,
0,
NULL,
NULL,
ipst);
}
/*
* Create any necessary broadcast IREs.
*/
/* 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 address availability under
* ip_addr_avail_lock. ill_g_lock is held as reader to ensure no new
* ills or new ipifs can be added while we are checking availability.
*/
/* 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.
*/
irep1--;
/*
* refheld by ire_add. refele towards the end of the func
*/
}
/* 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 {
}
}
}
if (ill->ill_need_recover_multicast) {
/*
* Need to recover all multicast memberships in the driver.
* This had to be deferred until we had attached. The same
* code exists in ipif_up_done_v6() to recover IPv6
* memberships.
*
* Note that it would be preferable to unconditionally do the
* ill_recover_multicast() in ill_dl_up(), but we cannot do
* that since ill_join_allmulti() depends on ill_dl_up being
* set, and it is not set until we receive a DL_BIND_ACK after
* having called ill_dl_up().
*/
}
/*
* Since the interface is now up, it may now be active.
*/
if (IS_UNDER_IPMP(ill))
/*
* If this is an IPMP interface, we may now be able to
* establish ARP entries.
*/
}
/* Join the allhosts multicast address */
/*
* See if anybody else would benefit from our new ipif.
*/
if (!loopback &&
}
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)
return (0);
bad:
ip1dbg(("ipif_up_done: FAILED \n"));
irep--;
ire_delete(*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);
}
/*
* 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);
}
/*
* IP source address type, sorted from worst to best. For a given type,
* always prefer IP addresses on the same subnet. All-zones addresses are
* suboptimal because they pose problems with unlabeled destinations.
*/
typedef enum {
IPIF_DIFFNET_DEPRECATED, /* deprecated and different subnet */
IPIF_SAMENET_DEPRECATED, /* deprecated and same subnet */
IPIF_DIFFNET_ALLZONES, /* allzones and different subnet */
IPIF_SAMENET_ALLZONES, /* allzones and same subnet */
IPIF_DIFFNET, /* normal and different subnet */
IPIF_SAMENET /* normal and same subnet */
} ipif_type_t;
/*
* Pick the optimal ipif on `ill' for sending to destination `dst' from zone
* `zoneid'. We rate usable ipifs from low -> high as per the ipif_type_t
* enumeration, and return the highest-rated ipif. If there's a tie, we pick
* the first one, unless IPMP is used in which case we round-robin among them;
* see below for more.
*
* 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 *
{
if (ill->ill_usesrc_ifindex != 0) {
else
return (NULL);
}
/*
* Test addresses should never be used for source address selection,
* so if we were passed one, switch to the IPMP meta-interface.
*/
if (IS_UNDER_IPMP(ill)) {
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.
*/
/*
* For source address selection, we treat the ipif list as circular
* and continue until we get back to where we started. This allows
* IPMP to vary source address selection (which improves inbound load
* spreading) by caching its last ending point and starting from
* there. NOTE: we don't have to worry about ill_src_ipif changing
* ills since that can't happen on the IPMP ill.
*/
ipif = start_ipif;
do {
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;
if (incompat)
continue;
}
} else {
}
if (best_type == IPIF_SAMENET)
break; /* can't get better */
}
if (!IPIF_CAN_LOOKUP(ipif)) {
goto retry;
}
/*
* For IPMP, update the source ipif rotor to the next ipif,
* provided we can look it up. (We must not use it if it's
* IPIF_CONDEMNED since we may have grabbed ill_g_lock after
* ipif_free() checked ill_src_ipif.)
*/
else
}
}
#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 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, /* no src nce */
NULL, /* no recv from queue */
stq, /* send-to queue */
ipif,
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 are 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.
*/
static void
{
char buf[INET6_ADDRSTRLEN];
continue;
}
}
/* ARGSUSED */
int
{
/*
* ill_phyint_reinit merged the v4 and v6 into a single
* ipsq. 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);
}
/*
* Refresh all IRE_BROADCAST entries associated with `ill' to ensure the
* minimum (but complete) set exist. This is necessary when adding or
* IPMP group use the IRE_BROADCAST entries for the IPMP group (whenever
* its test address subnets overlap with IPMP data addresses). It's also
* used to refresh the IRE_BROADCAST entries associated with the IPMP
* interface when the nominated broadcast interface changes.
*/
void
{
/*
* Remove any old broadcast IREs.
*/
/*
* Create new ones for any ipifs that are up and broadcast-capable.
*/
continue;
ire_refrele(*irep);
}
}
}
/*
* Create any IRE_BROADCAST entries for `ipif', and store those entries in
* `irep'. Returns a pointer to the next free `irep' entry (just like
* ire_check_and_create_bcast()).
*/
static ire_t **
{
ip1dbg(("ipif_create_bcast_ires: creating broadcast IREs\n"));
/*
* For backward compatibility, we create net broadcast IREs based on
* the old "IP address class system", since some old machines only
* respond to these class derived net broadcast. However, we must not
* create these net broadcast IREs if the subnetmask 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 -- and then TCP will refuse to talk to that address.
*/
if (netmask < subnetmask) {
flags);
}
/*
* Don't create IRE_BROADCAST IREs for the interface if the subnetmask
* is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
* created. Creating these broadcast IREs will only create confusion
* as `addr' will be the same as the IP address.
*/
if (subnetmask != 0xFFFFFFFF) {
}
return (irep);
}
/*
* Broadcast IRE info structure used in the functions below. Since we
* allocate BCAST_COUNT of them on the stack, keep the bit layout compact.
*/
typedef struct bcast_ireinfo {
bi_pad:5;
/*
* Check if `ipif' needs the dying broadcast IRE described by `bireinfop', and
* return B_TRUE if it should immediately be used to recreate the IRE.
*/
static boolean_t
{
case BCAST_NET:
return (B_FALSE);
break;
case BCAST_SUBNET:
return (B_FALSE);
break;
}
return (B_FALSE);
}
return (B_TRUE);
}
/*
* Create the broadcast IREs described by `bireinfop' on `ipif', and return
* them ala ire_check_and_create_bcast().
*/
static ire_t **
{
case BCAST_NET:
break;
case BCAST_SUBNET:
break;
}
return (irep);
}
/*
* Walk through all of the ipifs on `ill' that will be affected by `test_ipif'
* going away, and determine if any of the broadcast IREs (named by `bireinfop')
* that are going away are still needed. If so, have ipif_create_bcast()
* recreate them (except for the deprecated case, as explained below).
*/
static ire_t **
{
int i;
/*
* Skip this ipif if it's (a) the one being taken down, (b)
* not in the same zone, or (c) has no valid local address.
*/
ipif->ipif_subnet == 0 ||
continue;
/*
* For each dying IRE that hasn't yet been replaced, see if
* `ipif' needs it and whether the IRE should be recreated on
* `ipif'. If `ipif' is deprecated, ipif_consider_bcast()
* will return B_FALSE even if `ipif' needs the IRE on the
* hopes that we'll later find a needy non-deprecated ipif.
* However, the ipif is recorded in bi_backup for possible
* subsequent use by ipif_check_bcast_ires().
*/
for (i = 0; i < BCAST_COUNT; i++) {
continue;
continue;
}
/*
* If we've replaced all of the broadcast IREs that are going
* to be taken down, we know we're done.
*/
for (i = 0; i < BCAST_COUNT; i++) {
break;
}
if (i == BCAST_COUNT)
break;
}
return (irep);
}
/*
* Check if `test_ipif' (which is going away) is associated with any existing
* broadcast IREs, and whether any other ipifs (e.g., on the same ill) were
* using those broadcast IREs. If so, recreate the broadcast IREs on one or
* more of those other ipifs. (The old IREs will be deleted in ipif_down().)
*
* This is necessary because broadcast IREs are shared. In particular, a
* given ill has one set of all-zeroes and all-ones broadcast IREs (for every
* zone), plus one set of all-subnet-ones, all-subnet-zeroes, all-net-ones,
* ipifs on. Thus, if there are two IPIF_UP ipifs on the same subnet with the
* same zone, they will share the same set of broadcast IREs.
*
* Note: the upper bound of 12 IREs comes from the worst case of replacing all
* six pairs (loopback and non-loopback) of broadcast IREs (all-zeroes,
* all-ones, subnet-zeroes, subnet-ones, net-zeroes, and net-ones).
*/
static void
{
/*
* No broadcast IREs for the LOOPBACK interface
* or others such as point to point and IPIF_NOXMIT.
*/
return;
if (test_ipif->ipif_net_mask != 0)
/*
* Figure out what (if any) broadcast IREs will die as a result of
* `test_ipif' going away. If none will die, we're done.
*/
for (i = 0, willdie = 0; i < BCAST_COUNT; i++) {
willdie++;
}
}
if (willdie == 0)
return;
/*
* Walk through all the ipifs that will be affected by the dying IREs,
* and recreate the IREs as necessary. Note that all interfaces in an
* IPMP illgrp share the same broadcast IREs, and thus the entire
* illgrp must be walked, starting with the IPMP meta-interface (so
* that broadcast IREs end up on it whenever possible).
*/
if (IS_UNDER_IPMP(ill))
for (i = 0; i < BCAST_COUNT; i++) {
if (bireinfo[i].bi_willdie &&
!bireinfo[i].bi_haverep)
break;
}
if (i == BCAST_COUNT)
break;
}
}
/*
* Scan through the set of broadcast IREs and see if there are any
* that we need to replace that have not yet been replaced. If so,
* replace them using the appropriate backup ipif.
*/
for (i = 0; i < BCAST_COUNT; i++) {
}
/*
* 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);
}
return;
}
}
irep1--;
}
}
/*
* 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
{
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 (ip_extract_lifreq()) 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);
}
/*
* If there's another ill already with the requested name, ensure
* that it's of the same type. Otherwise, ill_phyint_reinit() will
* fuse together two unrelated ills, which will cause chaos.
*/
ip1dbg(("if_sioctl_slifname: SIOCSLIFNAME: attempt to "
"use the same ill name on differing media\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. */
}
}
/* ARGSUSED */
int
{
/*
* ill_phyint_reinit merged the v4 and v6 into a single
* ipsq. 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;
break;
}
}
}
return (ipif);
}
/*
* 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
{
else
/*
* Only allow on physical interface. Also, index zero is illegal.
*/
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. */
/* Update SCTP's ILL list */
/* 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));
}
/*
* Return the number of addresses on `ill' with one or more of the values
* in `set' set and all of the values in `clear' clear.
*/
static uint_t
{
cnt++;
return (cnt);
}
/*
* Return the number of migratable addresses on `ill' that are under
* application control.
*/
{
}
/*
* Return the number of point-to-point addresses on `ill'.
*/
{
}
/* 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 (ifindex == 0) {
/* non usesrc group interface, nothing to reset */
return (0);
}
/* valid reset request */
}
if (usesrc_ill == NULL) {
return (err);
}
err = EINPROGRESS;
/* Operation enqueued on the ipsq of the usesrc ILL */
goto done;
}
/* USESRC isn't currently supported with IPMP */
goto done;
}
/*
* USESRC isn't compatible with the STANDBY flag. (STANDBY is only
* used by IPMP underlying interfaces, but someone might think it's
* more general and try to use it independently with VNI.)
*/
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 on the unplumb path via ill_glist_delete() when
* there are no ills left on the phyint and thus the phyint can be freed.
*/
static void
{
/*
* If this phyint was an IPMP meta-interface, blow away the group.
* This is safe to do because all of the illgrps have already been
* removed by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find us.
* If we're cleaning up as a result of failed initialization,
* phyint_grp may be NULL.
*/
}
/*
* If this interface was under IPMP, take it out of the group.
*/
/*
* Delete the phyint and disassociate its ipsq. The ipsq itself
* will be freed in ipsq_exit().
*/
}
/*
* 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;
/*
* Now that our ill has a name, set it in the phyint.
*/
/*
* 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 {
}
/*
* Delete the old phyint and make its ipsq eligible
* to be freed in ipsq_exit().
*/
} 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.
*/
/*
* Now that the phyint's ifindex has been assigned, complete the
* remaining
*/
} else {
}
/*
* 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.
*/
}
}
/*
* 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);
}
/*
* Now that ill_name is set, the configuration for the IPMP
* meta-interface can be performed.
*/
/*
* If phyi->phyint_grp is NULL, then this is the first IPMP
* meta-interface and we need to create the IPMP group.
*/
/*
* If someone has renamed another IPMP group to have
* the same name as our interface, bail.
*/
return (EEXIST);
}
return (ENOMEM);
}
}
}
/* 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;
/*
* When the first ipif comes up in ipif_up_done(), multicast groups
* that were joined while this ill was not bound to the DLPI link need
* to be recovered by ill_recover_multicast().
*/
/*
* 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;
for (i = 0; i < MAX_G_HEADS; i++) {
}
sizeof (phyint_t),
sizeof (phyint_t),
}
/*
* 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
*
* This is used by SO_DONTROUTE and IP_NEXTHOP. Since neither of those are
* supported on underlying interfaces in an IPMP group, underlying interfaces
* are ignored when looking up a match. (If we didn't ignore them, we'd
* risk using a test address as a source for outgoing traffic.)
*/
ipif_t *
{
if (IS_UNDER_IPMP(ill))
continue;
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,
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 {
}
}
/*
* 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;
}
/* restore the mblk to a sane state */
}
}
/*
* Derive an interface id from the link layer address.
* Knows about IEEE 802 and IEEE EUI-64 mappings.
*/
static boolean_t
{
char *addr;
return (B_FALSE);
/* Form EUI-64 like address */
return (B_TRUE);
}
/* ARGSUSED */
static boolean_t
{
return (B_FALSE);
}
typedef struct ipmp_ifcookie {
char ic_zonename[ZONENAME_MAX];
/*
* Construct a pseudo-random interface ID for the IPMP interface that's both
* predictable and (almost) guaranteed to be unique.
*/
static boolean_t
{
ipmp_ifcookie_t ic = { 0 };
}
/*
* Map the hash to an interface ID per the basic approach in RFC3041.
*/
return (B_TRUE);
}
/* 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;
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);
}
/*
* 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
* EINPROGRESS, 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)
}
/*
* This needs to be in-sync with nic_event_t definition
*/
static const char *
{
switch (event) {
case NE_PLUMB:
return ("PLUMB");
case NE_UNPLUMB:
return ("UNPLUMB");
case NE_UP:
return ("UP");
case NE_DOWN:
return ("DOWN");
case NE_ADDRESS_CHANGE:
return ("ADDRESS_CHANGE");
case NE_LIF_UP:
return ("LIF_UP");
case NE_LIF_DOWN:
return ("LIF_DOWN");
default:
return ("UNKNOWN");
}
}
void
{
/* create a new nic event info */
goto fail;
goto fail;
}
DDI_NOSLEEP) == DDI_SUCCESS)
return;
fail:
}
}
ip2dbg(("ill_nic_event_dispatch: could not dispatch %s nic event "
}
void
{
}