mpd_tables.c revision 9bea609830e5d4083cf3cd9a11ab54699ca62b3e
/*
* 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.
*/
#include "mpd_defs.h"
#include "mpd_tables.h"
/*
* Global list of phyints, phyint instances, phyint groups and the anonymous
* group; the latter is initialized in phyint_init().
*/
struct phyint_group *phyint_anongroup;
/*
* Grouplist signature; initialized in phyint_init().
*/
static uint64_t phyint_grouplistsig;
/* Initialize any per-file global state. Returns 0 on success, -1 on failure */
int
phyint_init(void)
{
if (track_all_phyints) {
if (phyint_anongroup == NULL)
return (-1);
}
return (0);
}
/* Return the phyint with the given name */
struct phyint *
phyint_lookup(const char *name)
{
break;
}
return (pi);
}
/*
* Lookup a phyint in the group that has the same hardware address as `pi', or
* NULL if there's none. If `online_only' is set, then only online phyints
* are considered when matching. Otherwise, phyints that had been offlined
* due to a duplicate hardware address will also be considered.
*/
static struct phyint *
{
return (NULL);
continue;
/*
* NOTE: even when online_only is B_FALSE, we ignore phyints
* that are administratively offline (rather than offline
* because they're dups); when they're brought back online,
* they'll be flagged as dups if need be.
*/
continue;
return (pi2);
}
return (NULL);
}
/*
* Respond to DLPI notifications. Currently, this only processes physical
* address changes for the phyint passed via `arg' by onlining or offlining
* phyints in the group.
*/
/* ARGSUSED */
static void
{
return;
/*
* If our hardware address hasn't changed, there's nothing to do.
*/
return;
/*
* Our old hardware address was a duplicate. If we'd been
* offlined because of it, and our new hardware address is not
* a duplicate, then bring us online. Otherwise, `oduppi'
* must've been the one brought offline; bring it online.
*/
if (pi->pi_hwaddrdup) {
(void) phyint_undo_offline(pi);
} else {
(void) phyint_undo_offline(oduppi);
}
}
/*
* Our new hardware address was a duplicate and we're not
* yet flagged as a duplicate; bring us offline.
*/
(void) phyint_offline(pi, 0);
}
}
/*
* Initialize information about the underlying link for `pi', and set us
* up to be notified about future changes. Returns _B_TRUE on success.
*/
{
int retval;
const char *errmsg;
if (retval != DLPI_SUCCESS) {
errmsg = "cannot open";
goto failed;
}
&pi->pi_hwaddrlen);
if (retval != DLPI_SUCCESS) {
errmsg = "cannot get hardware address";
goto failed;
}
/*
* Check if the link supports DLPI link state notifications. For
* historical reasons, the actual changes are tracked through routing
* sockets, so we immediately disable the notification upon success.
*/
if (retval == DLPI_SUCCESS) {
}
/*
* Enable notification of hardware address changes to keep pi_hwaddr
* up-to-date and track if we need to offline/undo-offline phyints.
*/
return (_B_TRUE);
}
return (_B_FALSE);
}
/*
* Close use of link on `pi'.
*/
void
{
}
/*
* NOTE: we don't clear pi_notes here so that iflinkstate() can still
* properly report the link state even when offline (which is possible
* since we use IFF_RUNNING to track link state).
*/
}
/* Return the phyint instance with the given name and the given family */
struct phyint_instance *
{
return (NULL);
}
struct phyint_group *
phyint_group_lookup(const char *pg_name)
{
struct phyint_group *pg;
break;
}
return (pg);
}
/*
* Insert the phyint in the linked list of all phyints. If the phyint belongs
* to some group, insert it in the phyint group list.
*/
static void
{
/* Insert the phyint at the head of the 'all phyints' list */
/*
* Insert the phyint at the head of the 'phyint_group members' list
* of the phyint group to which it belongs.
*/
/* Refresh the group state now that this phyint has been added */
}
/* Insert the phyint instance in the linked list of all phyint instances. */
static void
{
logdebug("phyint_inst_insert(%s %s)\n",
}
/*
* Insert the phyint at the head of the 'all phyint instances' list.
*/
if (phyint_instances != NULL)
}
/*
* Create a new phyint with the given parameters. Also insert it into
* the list of all phyints and the list of phyint group members by calling
* phyint_insert().
*/
static struct phyint *
{
logperror("phyint_create: calloc");
return (NULL);
}
/*
* Record the phyint values.
*/
/*
* Initialize the link state. The link state is initialized to
* up, so that if the link is down when IPMP starts monitoring
* the interface, it will appear as though there has been a
* transition from the link up to link down. This avoids
* having to treat this situation as a special case.
*/
if (!phyint_link_init(pi)) {
return (NULL);
}
/*
* Insert the phyint in the list of all phyints, and the
* list of phyint group members
*/
return (pi);
}
/*
* Create a new phyint instance belonging to the phyint 'pi' and address
* family 'af'. Also insert it into the list of all phyint instances by
* calling phyint_inst_insert().
*/
static struct phyint_instance *
{
struct phyint_instance *pii;
logperror("phyint_inst_create: calloc");
return (NULL);
}
/*
* Attach the phyint instance to the phyint.
* Set the back pointers as well
*/
else
/* Insert the phyint instance in the list of all phyint instances. */
return (pii);
}
/*
* Change the state of phyint `pi' to state `state'.
*/
void
{
/*
* To simplify things, some callers always set a given state
* regardless of the previous state of the phyint (e.g., setting
* PI_RUNNING when it's already set). We shouldn't bother
* generating an event or consuming a signature for these, since
* the actual state of the interface is unchanged.
*/
return;
}
/*
* Note that `pi' has changed state.
*/
void
{
}
/*
* Insert the phyint group in the linked list of all phyint groups
* at the head of the list
*/
void
{
if (phyint_groups != NULL)
phyint_groups = pg;
}
/*
* Create a new phyint group called 'name'.
*/
struct phyint_group *
phyint_group_create(const char *name)
{
struct phyint_group *pg;
logperror("phyint_group_create: calloc");
return (NULL);
}
/*
* Normal groups always start in the PG_FAILED state since they
* have no active interfaces. In contrast, anonymous groups are
* heterogeneous and thus always PG_OK.
*/
return (pg);
}
/*
* Change the state of the phyint group `pg' to state `state'.
*/
void
{
/*
* To simplify things, some callers always set a given state
* regardless of the previous state of the group (e.g., setting
* PG_DEGRADED when it's already set). We shouldn't bother
* generating an event or consuming a signature for these, since
* the actual state of the group is unchanged.
*/
return;
switch (state) {
case PG_FAILED:
/*
* We can never know with certainty that a group has
* failed. It is possible that all known targets have
* failed simultaneously, and new targets have come up
* instead. If the targets are routers then router
* discovery will kick in, and we will see the new routers
* thru routing socket messages. But if the targets are
* hosts, we have to discover it by multicast. So flush
* all the host targets. The next probe will send out a
* multicast echo request. If this is a group failure, we
* will still not see any response, otherwise the group
* will be repaired after we get NUM_PROBE_REPAIRS
* consecutive unicast replies on any phyint.
*/
break;
case PG_OK:
case PG_DEGRADED:
break;
default:
logerr("phyint_group_chstate: invalid group state %d; "
"aborting\n", state);
abort();
}
(void) phyint_group_state_event(pg);
}
/*
* Create a new phyint instance and initialize it from the values supplied by
* the kernel. Always check for ENXIO before logging any error, because the
* interface could have vanished after completion of SIOCGLIFCONF.
* Return values:
* pointer to the phyint instance on success
* NULL on failure Eg. if the phyint instance is not found in the kernel
*/
struct phyint_instance *
{
int ifsock;
struct phyint_instance *pii;
struct phyint_group *pg;
logdebug("phyint_inst_init_from_k(%s %s)\n",
}
/* Get the socket for doing ioctls */
/*
* Get the interface flags. Ignore virtual interfaces, IPMP
* meta-interfaces, point-to-point interfaces, and interfaces
* that can't support multicast.
*/
logperror("phyint_inst_init_from_k:"
" ioctl (get flags)");
}
return (NULL);
}
if (!(flags & IFF_MULTICAST) ||
return (NULL);
/*
* Get the ifindex for recording later in our tables, in case we need
* to create a new phyint.
*/
logperror("phyint_inst_init_from_k: "
" ioctl (get lifindex)");
}
return (NULL);
}
/*
* Get the phyint group name of this phyint, from the kernel.
*/
logperror("phyint_inst_init_from_k: "
"ioctl (get group name)");
}
return (NULL);
}
/*
* If the phyint is not part of any group, pg_name is the
* null string. If 'track_all_phyints' is false, there is no
* need to create a phyint.
*/
/*
* If the IFF_FAILED, IFF_INACTIVE, or IFF_OFFLINE flags are
* set, reset them. These flags shouldn't be set if in.mpathd
* isn't tracking the interface.
*/
logperror("phyint_inst_init_from_k:"
" ioctl (set flags)");
}
}
}
return (NULL);
}
/*
* We need to create a new phyint instance. We may also need to
* create the group if e.g. the SIOCGLIFCONF loop in initifs() found
* an underlying interface before it found its IPMP meta-interface.
* Note that we keep any created groups even if phyint_inst_from_k()
* fails since a group's existence is not dependent on the ability of
* in.mpathd to the track the group's interfaces.
*/
logerr("phyint_inst_init_from_k: cannot create group "
"%s\n", pg_name);
return (NULL);
}
}
/*
* Lookup the phyint. If the phyint does not exist create it.
*/
logerr("phyint_inst_init_from_k:"
" unable to create phyint %s\n", pi_name);
return (NULL);
}
} else {
/* The phyint exists already. */
/*
* Normally we should see consistent values for the IPv4 and
* IPv6 instances, for phyint properties. If we don't, it
* means things have changed underneath us, and we should
* resync our tables with the kernel. Check whether the
* interface index has changed. If so, it is most likely
* the interface has been unplumbed and replumbed,
* while we are yet to update our tables. Do it now.
*/
goto retry;
}
/*
* If the group name seen by the IPv4 and IPv6 instances
* are different, it is most likely the groupname has
* changed, while we are yet to update our tables. Do it now.
*/
goto retry;
}
}
/*
* Create a new phyint instance, corresponding to the 'af'
* passed in.
*/
logerr("phyint_inst_init_from_k: unable to create"
if (pi_created)
return (NULL);
}
/*
* NOTE: the change_pif_flags() implementation requires a phyint
* instance before it can function, so a number of tasks that would
* otherwise be done in phyint_create() are deferred to here.
*/
if (pi_created) {
/*
* If the interface is offline, set the state to PI_OFFLINE.
* Otherwise, optimistically consider this interface running.
* Later (in process_link_state_changes()), we will adjust
* this to match the current state of the link. Further, if
* test addresses are subsequently assigned, we will
* transition to PI_NOTARGETS and then to either PI_RUNNING or
* PI_FAILED depending on the probe results.
*/
} else {
/* calls phyint_chstate() */
}
/*
* If this a standby phyint, determine whether it should be
* IFF_INACTIVE.
*/
/*
* If this phyint does not have a unique hardware address in its
* group, offline it.
*/
(void) phyint_offline(pi, 0);
}
}
return (pii);
}
/*
* Bind pii_probe_sock to the address associated with pii_probe_logint.
* targets. Do the common part in this function, and complete the
* initializations by calling the protocol specific functions
* phyint_inst_v{4,6}_sockinit() respectively.
*
* Return values: _B_TRUE/_B_FALSE for success or failure respectively.
*/
{
struct phyint_group *pg;
logdebug("phyint_inst_sockinit(%s %s)\n",
}
/*
* If the socket is already bound, close pii_probe_sock
*/
/*
* If the phyint is not part of a named group and track_all_phyints is
* false, simply return.
*/
logdebug("phyint_inst_sockinit: no group\n");
return (_B_FALSE);
}
/*
* Initialize the socket by calling the protocol specific function.
* If it succeeds, add the socket to the poll list.
*/
else
return (_B_TRUE);
/* Something failed, cleanup and return false */
return (_B_FALSE);
}
/*
* IPv6 specific part in initializing the pii_probe_sock. This socket is
*/
static boolean_t
{
int hopcount = 1;
int off = 0;
int on = 1;
struct sockaddr_in6 testaddr;
int flags;
/*
* Open a raw socket with ICMPv6 protocol.
*
* Use IPV6_BOUND_IF to make sure that probes are sent and received on
* the specified phyint only. Bind to the test address to ensure that
* the responses are sent to the specified phyint.
*
* Set the hopcount to 1 so that probe packets are not routed.
* Disable multicast loopback. Set the receive filter to
* receive only ICMPv6 echo replies.
*/
if (pii->pii_probe_sock < 0) {
return (_B_FALSE);
}
/*
* Probes must not block in case of lower layer issues.
*/
" F_GETFL");
return (_B_FALSE);
}
" F_SETFL O_NONBLOCK");
return (_B_FALSE);
}
sizeof (testaddr)) < 0) {
return (_B_FALSE);
}
" IPV6_MULTICAST_IF");
return (_B_FALSE);
}
" IPV6_BOUND_IF");
return (_B_FALSE);
}
" IPV6_UNICAST_HOPS");
return (_B_FALSE);
}
" IPV6_MULTICAST_HOPS");
return (_B_FALSE);
}
" IPV6_MULTICAST_LOOP");
return (_B_FALSE);
}
/*
* Filter out so that we only receive ICMP echo replies
*/
" ICMP6_FILTER");
return (_B_FALSE);
}
/* Enable receipt of hoplimit */
" IPV6_RECVHOPLIMIT");
return (_B_FALSE);
}
/* Enable receipt of timestamp */
" SO_TIMESTAMP");
return (_B_FALSE);
}
return (_B_TRUE);
}
/*
* IPv4 specific part in initializing the pii_probe_sock. This socket is
*/
static boolean_t
{
struct sockaddr_in testaddr;
char char_off = 0;
int ttl = 1;
char char_ttl = 1;
int on = 1;
int flags;
/*
* Open a raw socket with ICMPv4 protocol.
*
* Use IP_BOUND_IF to make sure that probes are sent and received on
* the specified phyint only. Bind to the test address to ensure that
* the responses are sent to the specified phyint.
*
* Set the ttl to 1 so that probe packets are not routed.
* Disable multicast loopback. Enable receipt of timestamp.
*/
if (pii->pii_probe_sock < 0) {
return (_B_FALSE);
}
/*
* Probes must not block in case of lower layer issues.
*/
" F_GETFL");
return (_B_FALSE);
}
" F_SETFL O_NONBLOCK");
return (_B_FALSE);
}
sizeof (testaddr)) < 0) {
return (_B_FALSE);
}
" IP_BOUND_IF");
return (_B_FALSE);
}
" IP_MULTICAST_IF");
return (_B_FALSE);
}
" IP_TTL");
return (_B_FALSE);
}
" IP_MULTICAST_LOOP");
return (_B_FALSE);
}
" IP_MULTICAST_TTL");
return (_B_FALSE);
}
sizeof (on)) < 0) {
" SO_TIMESTAMP");
return (_B_FALSE);
}
return (_B_TRUE);
}
/*
* Remove the phyint group from the list of 'all phyint groups'
* and free it.
*/
void
{
/*
* The anonymous group always exists, even when empty.
*/
if (pg == phyint_anongroup)
return;
/*
* The phyint group must be empty, and must not have any phyints.
* The phyint group must be in the list of all phyint groups
*/
else
}
/*
* Refresh the state of `pg' based on its current members.
*/
void
{
/*
* Anonymous groups never change state.
*/
if (pg == phyint_anongroup)
return;
nif++;
if (phyint_is_usable(pi)) {
nusable++;
}
}
if (nusable == 0)
else
state = PG_DEGRADED;
/*
* If we're shutting down, skip logging messages since otherwise our
* shutdown housecleaning will make us report that groups are unusable.
*/
if (cleanup_started)
return;
/*
* NOTE: We use pg_failmsg_printed rather than origstate since
* otherwise at startup we'll log a "now usable" message when the
* first usable phyint is added to an empty group.
*/
logerr("At least 1 IP interface (%s) in group %s is now "
logerr("All IP interfaces in group %s are now unusable\n",
}
}
/*
* Extract information from the kernel about the desired phyint.
* Look only for properties of the phyint and not properties of logints.
* Take appropriate action on the changes.
* Return codes:
* PI_OK
* The phyint exists in the kernel and matches our knowledge
* of the phyint.
* PI_DELETED
* The phyint has vanished in the kernel.
* PI_IFINDEX_CHANGED
* The phyint's interface index has changed.
* Ask the caller to delete and recreate the phyint.
* PI_IOCTL_ERROR
* Some ioctl error. Don't change anything.
* PI_GROUP_CHANGED
* The phyint has changed group.
*/
int
{
int ifsock;
logdebug("phyint_inst_update_from_k(%s %s)\n",
}
/*
* Get the ifindex from the kernel, for comparison with the
* value in our tables.
*/
return (PI_DELETED);
} else {
" ioctl (get lifindex)");
return (PI_IOCTL_ERROR);
}
}
/*
* The index has changed. Most likely the interface has
* been unplumbed and replumbed. Ask the caller to take
* appropriate action.
*/
logdebug("phyint_inst_update_from_k:"
" old index %d new index %d\n",
}
return (PI_IFINDEX_CHANGED);
}
/*
* Get the group name from the kernel, for comparison with
* the value in our tables.
*/
return (PI_DELETED);
} else {
" ioctl (get groupname)");
return (PI_IOCTL_ERROR);
}
}
/*
* If the phyint has changed group i.e. if the phyint group name
* returned by the kernel is different, ask the caller to delete
* and recreate the phyint in the right group
*/
/* Groupname has changed */
logdebug("phyint_inst_update_from_k:"
" groupname change\n");
}
return (PI_GROUP_CHANGED);
}
/*
* Get the current phyint flags from the kernel, and determine what
* flags have changed by comparing against our tables. Note that the
* IFF_INACTIVE processing in initifs() relies on this call to ensure
* that IFF_INACTIVE is really still set on the interface.
*/
return (PI_DELETED);
} else {
" ioctl (get flags)");
return (PI_IOCTL_ERROR);
}
}
/*
* Make sure the IFF_FAILED flag is set if and only if we think
* the interface should be failed.
*/
} else {
}
/* No change in phyint status */
return (PI_OK);
}
/*
* Delete the phyint. Remove it from the list of all phyints, and the
* list of phyint group members.
*/
static void
{
/* Both IPv4 and IPv6 phyint instances must have been deleted. */
/*
* The phyint must belong to a group.
*/
/* The phyint must be in the list of all phyints */
/* Remove the phyint from the phyint group list */
/* Phyint is the 1st in the phyint group list */
} else {
}
/* Refresh the group state now that this phyint has been removed */
/* Remove the phyint from the global list of phyints */
/* Phyint is the 1st in the list */
} else {
}
/*
* See if another phyint in the group had been offlined because
* it was a dup of `pi' -- and if so, online it.
*/
if (!pi->pi_hwaddrdup &&
(void) phyint_undo_offline(pi2);
}
/*
* If the interface was in a named group and was either an active
* standby or the last active interface, try to activate another
* interface to compensate.
*/
if (pg != phyint_anongroup) {
if (phyint_is_functioning(pi2) &&
break;
}
}
if (!active ||
}
}
/*
* Offline phyint `pi' if at least `minred' usable interfaces remain in the
* group. Returns an IPMP error code.
*/
int
{
unsigned int nusable = 0;
/*
* Verify that enough usable interfaces in the group would remain.
* As a special case, if the group has failed, allow any non-offline
* phyints to be offlined.
*/
if (pg != phyint_anongroup) {
continue;
if (phyint_is_usable(pi2) ||
nusable++;
}
}
return (IPMP_EMINRED);
return (IPMP_FAILURE);
/*
* The interface is now offline, so stop probing it. Note that
* if_mpadm(1M) will down the test addresses, after receiving a
* success reply from us. The routing socket message will then make us
* close the socket used for sending probes. But it is more logical
* that an offlined interface must not be probed, even if it has test
* addresses.
*
* NOTE: stop_probing() also sets PI_OFFLINE.
*/
/*
* If we're offlining the phyint because it has a duplicate hardware
* address, print a warning -- and leave the link open so that we can
* be notified of hardware address changes that make it usable again.
* Otherwise, close the link so that we won't prevent a detach.
*/
if (pi->pi_hwaddrdup) {
logerr("IP interface %s has a hardware address which is not "
} else {
}
/*
* If this phyint was preventing another phyint with a duplicate
* hardware address from being online, bring that one online now.
*/
if (!pi->pi_hwaddrdup &&
(void) phyint_undo_offline(pi2);
}
/*
* If this interface was active, try to activate another INACTIVE
* interface in the group.
*/
if (was_active)
return (IPMP_SUCCESS);
}
/*
* Undo a previous offline of `pi'. Returns an IPMP error code.
*/
int
{
return (IPMP_FAILURE);
}
/*
* If necessary, reinitialize our link information and verify that its
* hardware address is still unique across the group.
*/
return (IPMP_FAILURE);
}
return (IPMP_EHWADDRDUP);
}
if (pi->pi_hwaddrdup) {
logerr("IP interface %s now has a unique hardware address in "
}
return (IPMP_FAILURE);
/*
* While the interface was offline, it may have failed (e.g. the link
* may have gone down). phyint_inst_check_for_failure() will have
* already set pi_flags with IFF_FAILED, so we can use that to decide
* whether the phyint should transition to running. Note that after
* we transition to running, we will start sending probes again (if
* test addresses are configured), which may also reveal that the
* interface is in fact failed.
*/
} else {
/* calls phyint_chstate() */
}
/*
* Give the requestor time to configure test addresses before
* complaining that they're missing.
*/
return (IPMP_SUCCESS);
}
/*
* Delete (unlink and free), the phyint instance.
*/
void
{
logdebug("phyint_inst_delete(%s %s)\n",
}
/*
* If the phyint instance has associated probe targets
* delete all the targets
*/
/*
* Delete all the logints associated with this phyint
* instance.
*/
/*
* Close the socket used to send probes to targets from this phyint.
*/
/*
* Phyint instance must be in the list of all phyint instances.
* Remove phyint instance from the global list of phyint instances.
*/
/* Phyint is the 1st in the list */
} else {
}
/*
* Reset the phyint instance pointer in the phyint.
* If this is the last phyint instance (being deleted) on this
* phyint, then delete the phyint.
*/
else
}
static void
{
char abuf[INET6_ADDRSTRLEN];
int most_recent;
int i;
logdebug("pii->pi_phyint NULL can't print\n");
return;
}
logdebug("\nPhyint instance: %s %s index %u state %x flags %llx "
"sock %x in_use %d\n",
pii->pii_in_use);
logdebug("\n");
logdebug("pi_targets NULL\n");
} else {
logdebug("pi_target_next NULL\n");
}
} else {
logdebug("pi_rtt_target_next NULL\n");
}
i = most_recent;
do {
logdebug("#%d target %s ", i,
} else {
logdebug("#%d target NULL ", i);
}
logdebug("time_start %lld status %d "
"time_ackproc %lld time_lost %u",
i = PROBE_INDEX_PREV(i);
} while (i != most_recent);
}
}
/*
* Lookup a logint based on the logical interface name, on the given
* phyint instance.
*/
static struct logint *
{
logdebug("logint_lookup(%s, %s)\n",
}
break;
}
return (li);
}
/*
* Insert a logint at the head of the list of logints of the given
* phyint instance
*/
static void
{
}
/*
* Create a new named logint, on the specified phyint instance.
*/
static struct logint *
{
logdebug("logint_create(%s %s %s)\n",
}
logperror("logint_create: calloc");
return (NULL);
}
return (li);
}
/*
* Initialize the logint based on the data returned by the kernel.
*/
void
{
int ifsock;
struct in6_addr test_subnet;
int test_subnet_len;
struct sockaddr_in6 *sin6;
struct sockaddr_in *sin;
char abuf[INET6_ADDRSTRLEN];
logdebug("logint_init_from_k(%s %s)\n",
}
/* Get the socket for doing ioctls */
/*
* Get the flags from the kernel. Also serves as a check whether
* the logical still exists. If it doesn't exist, no need to proceed
* any further. li_in_use will make the caller clean up the logint
*/
/* Interface may have vanished */
"ioctl (get flags)");
}
return;
}
/*
* Verified the logint exists. Now lookup the logint in our tables.
* If it does not exist, create a new logint.
*/
/*
* Pretend the interface does not exist
* in the kernel
*/
return;
}
}
/*
* Update li->li_flags with the new flags, after saving the old
* value. This is used later to check what flags has changed and
* take any action
*/
/*
* Get the address, prefix, prefixlength and update the logint.
* Check if anything has changed. If the logint used for the
* test address has changed, take suitable action.
*/
/* Interface may have vanished */
}
goto error;
}
} else {
}
/* Interface may have vanished */
goto error;
}
} else {
}
/*
* If this is the logint corresponding to the test address used for
* sending probes, then if anything significant has changed we need to
* determine the test address again. We ignore changes to the
* IFF_FAILED and IFF_RUNNING flags since those happen as a matter of
* course.
*/
~(IFF_FAILED | IFF_RUNNING)) != 0 ||
/*
* Something significant that affects the testaddress
* has changed. Redo the testaddress selection later on
* in select_test_ifs(). For now do the cleanup and
* set pii_probe_logint to NULL.
*/
}
}
/* Update the logint with the values obtained from the kernel. */
if (ptp) {
} else {
}
return;
logerr("logint_init_from_k: IGNORED %s %s %s addr %s\n",
}
/*
* Delete (unlink and free) a logint.
*/
void
{
struct phyint_instance *pii;
int af;
char abuf[INET6_ADDRSTRLEN];
logdebug("logint_delete(%s %s %s/%u)\n",
li->li_subnet_len);
}
/* logint must be in the list of logints */
/* Remove the logint from the list of logints */
/* logint is the 1st in the list */
} else {
}
/*
* If this logint is also being used for probing, then close the
* associated socket, if it exists.
*/
}
}
static void
{
char abuf[INET6_ADDRSTRLEN];
}
char *
{
} else {
}
return (abuf);
}
/*
* Fill in the sockaddr_storage pointed to by `ssp' with the IP address
* represented by the [`af',`addr'] pair. Needed because in.mpathd internally
* stores all addresses as in6_addrs, but we don't want to expose that.
*/
void
{
switch (af) {
case AF_INET:
break;
case AF_INET6:
break;
}
}
/* Lookup target on its address */
struct target *
{
char abuf[INET6_ADDRSTRLEN];
logdebug("target_lookup(%s %s): addr %s\n",
}
break;
}
return (tg);
}
/*
* Find and return the next active target, for the next probe.
* If no active targets are available, return NULL.
*/
struct target *
{
/*
* Target must be in the list of targets for this phyint
* instance.
*/
/* Return the next active target */
do {
/*
* Go to the next target. If we hit the end,
* reset the ptr to the head
*/
case TG_ACTIVE:
return (tg);
case TG_UNUSED:
/*
* Bubble up the unused target to active
*/
pii->pii_ntargets++;
return (tg);
}
break;
case TG_SLOW:
/*
* Bubble up the slow target to unused
*/
}
break;
case TG_DEAD:
/*
* Bubble up the dead target to slow
*/
}
break;
}
return (NULL);
}
/*
* Select the best available target, that is not already TG_ACTIVE,
* for the caller. The caller will determine whether it wants to
* make the returned target TG_ACTIVE.
* The selection order is as follows.
* 1. pick a TG_UNSED target, if it exists.
* 2. else pick a TG_SLOW target that has recovered, if it exists
* 3. else pick any TG_SLOW target, if it exists
* 4. else pick a TG_DEAD target that has recovered, if it exists
* 5. else pick any TG_DEAD target, if it exists
* 6. else return null
*/
static struct target *
{
case TG_UNUSED:
return (tg);
case TG_SLOW:
slow_recovered = tg;
/*
* Promote the slow_recovered to unused
*/
} else {
}
break;
case TG_DEAD:
dead_recovered = tg;
/*
* Promote the dead_recovered to slow
*/
} else {
}
break;
default:
break;
}
}
if (slow_recovered != NULL)
return (slow_recovered);
return (slow);
else if (dead_recovered != NULL)
return (dead_recovered);
else
return (dead);
}
/*
* Some target was deleted. If we don't have even MIN_PROBE_TARGETS
* that are active, pick the next best below.
*/
static void
{
/* We are out of targets */
return;
}
pii->pii_ntargets++;
}
}
}
static struct target *
{
break;
}
return (tg);
}
/*
* Create a default target entry.
*/
void
{
char abuf[INET6_ADDRSTRLEN];
logdebug("target_create(%s %s, %s)\n",
}
/*
* If the test address is not yet initialized, do not add
* any target, since we cannot determine whether the target
* belongs to the same subnet as the test address.
*/
return;
/*
* If there are multiple subnets associated with an interface, then
* add the target to this phyint instance only if it belongs to the
* same subnet as the test address. This assures us that we will
* be able to reach this target through our routing table.
*/
return;
if (is_router) {
if (!pii->pii_targets_are_routers) {
/*
* Prefer router over hosts. Using hosts is a
* fallback mechanism, hence delete all host
* targets.
*/
}
} else {
/*
* Routers take precedence over hosts. If this
* is a router list and we are trying to add a
* host, just return. If this is a host list
* and if we have sufficient targets, just return
*/
if (pii->pii_targets_are_routers ||
return;
}
}
logperror("target_create: calloc");
return;
}
tg->tg_num_deferred = 0;
/*
* If this is the first target, set 'pii_targets_are_routers'
* The list of targets is either a list of hosts or list or
* routers, but not a mix.
*/
}
} else {
if (pii->pii_ntargets == 0) {
}
pii->pii_ntargets++;
}
/*
* Change state to PI_RUNNING if this phyint instance is capable of
* sending and receiving probes -- that is, if we know of at least 1
* target, and this phyint instance is probe-capable. For more
* details, see the phyint state diagram in mpd_probe.c.
*/
else
}
}
/*
* Add the target address named by `addr' to phyint instance `pii' if it does
* not already exist. If the target is a router, `is_router' should be set to
* B_TRUE.
*/
void
{
return;
/*
* If the target does not exist, create it; target_create() will set
* tg_in_use to true. Even if it exists already, if it's a router
* target and we'd previously learned of it through multicast, then we
* need to recreate it as a router target. Otherwise, just set
* tg_in_use to to true so that init_router_targets() won't delete it.
*/
else if (is_router)
}
/*
* Insert target at head of linked list of targets for the associated
* phyint instance
*/
static void
{
}
/*
* Delete a target (unlink and free).
*/
void
{
int af;
struct phyint_instance *pii;
struct phyint_instance *pii_other;
char abuf[INET6_ADDRSTRLEN];
logdebug("target_delete(%s %s, %s)\n",
}
/*
* Target must be in the list of targets for this phyint
* instance.
*/
/*
* Reset all references to 'tg' in the probe information
* for this phyint.
*/
/*
* Remove this target from the list of targets of this
* phyint instance.
*/
} else {
}
pii->pii_ntargets--;
/*
* Adjust the next target to probe, if it points to
* to the currently deleted target.
*/
/*
* The number of active targets pii_ntargets == 0 iff
* the next active target pii->pii_target_next == NULL
*/
if (pii->pii_ntargets != 0) {
return;
}
/* At this point, we don't have any active targets. */
if (pii->pii_targets_are_routers) {
/*
* Activate any TG_SLOW or TG_DEAD router targets,
* since we don't have any other targets
*/
if (pii->pii_ntargets != 0) {
return;
}
}
/*
* If we still don't have any active targets, the list must
* must be really empty. There aren't even TG_SLOW or TG_DEAD
* targets. Zero out the probe stats since it will not be
* relevant any longer.
*/
/*
* If there are no targets on both instances and the interface would
* otherwise be considered PI_RUNNING, go back to PI_NOTARGETS state,
* since we cannot probe this phyint any more. For more details,
* please see phyint state diagram in mpd_probe.c.
*/
}
/*
* Flush the target list of every phyint in the group, if the list
* is a host target list. This is called if group failure is suspected.
* If all targets have failed, multicast will subsequently discover new
* targets. Else it is a group failure.
* Note: This function is a no-op if the list is a router target list.
*/
static void
{
struct phyint_instance *pii;
/*
* Delete all the targets. When the list becomes
* empty, target_delete() will set pii->pii_targets
* to NULL.
*/
}
/*
* Delete all the targets. When the list becomes
* empty, target_delete() will set pii->pii_targets
* to NULL.
*/
}
}
}
/*
* Reset all references to 'target' in the probe info, as this target is
* being deleted. The pr_target field is guaranteed to be non-null if
* pr_status is PR_UNACKED. So we change the pr_status to PR_LOST, so that
* pr_target will not be accessed unconditionally.
*/
static void
{
int i;
for (i = 0; i < PROBE_STATS_COUNT; i++) {
PR_LOST);
}
}
}
}
/*
* Clear the probe statistics array.
*/
void
{
/* Reset the next probe index in the probe stats array */
pii->pii_probe_next = 0;
}
static void
{
char abuf[INET6_ADDRSTRLEN];
char buf[128];
char buf2[128];
int af;
int i;
logdebug("Target on %s %s addr %s\n"
"status %d rtt_sa %lld rtt_sd %lld crtt %d tg_in_use %d\n",
buf[0] = '\0';
for (i = 0; i < tg->tg_num_deferred; i++) {
tg->tg_deferred[i]);
}
}
void
phyint_inst_print_all(void)
{
struct phyint_instance *pii;
}
}
/*
* Compare two prefixes that have the same prefix length.
* Fails if the prefix length is unreasonable.
*/
{
int j;
if (prefix_len > IPV6_ABITS)
return (_B_FALSE);
return (_B_FALSE);
/* Make the N leftmost bits one */
return (_B_FALSE);
return (_B_TRUE);
}
/*
* Get the number of UP logints on phyint `pi'.
*/
static int
{
int count = 0;
count++;
}
}
count++;
}
}
return (count);
}
/*
* Get the phyint instance with the other (IPv4 / IPv6) protocol
*/
struct phyint_instance *
{
else
}
/*
* Check whether a phyint is functioning.
*/
{
return (_B_TRUE);
}
/*
* Check whether a phyint is usable.
*/
{
if (logint_upcount(pi) == 0)
return (_B_FALSE);
return (phyint_is_functioning(pi));
}
/*
* Post an EC_IPMP sysevent of subclass `subclass' and attributes `nvl'.
* Before sending the event, it prepends the current version of the IPMP
* sysevent API. Returns 0 on success, -1 on failure (in either case,
* `nvl' is freed).
*/
static int
{
/*
* Initialize the event channel if we haven't already done so.
*/
if (errno != 0) {
logerr("cannot create event channel `%s': %s\n",
goto failed;
}
}
if (errno != 0) {
goto failed;
}
if (errno != 0) {
goto failed;
}
return (0);
return (-1);
}
/*
* Return the external IPMP state associated with phyint `pi'.
*/
static ipmp_if_state_t
{
case PI_INIT:
return (IPMP_IF_UNKNOWN);
case PI_NOTARGETS:
return (IPMP_IF_FAILED);
return (IPMP_IF_UNKNOWN);
case PI_OFFLINE:
return (IPMP_IF_OFFLINE);
case PI_FAILED:
return (IPMP_IF_FAILED);
case PI_RUNNING:
return (IPMP_IF_OK);
}
abort();
/* NOTREACHED */
}
/*
* Return the external IPMP interface type associated with phyint `pi'.
*/
static ipmp_if_type_t
{
return (IPMP_IF_STANDBY);
else
return (IPMP_IF_NORMAL);
}
/*
* Return the external IPMP link state associated with phyint `pi'.
*/
static ipmp_if_linkstate_t
{
return (IPMP_LINK_UNKNOWN);
}
/*
* Return the external IPMP probe state associated with phyint `pi'.
*/
static ipmp_if_probestate_t
{
return (IPMP_PROBE_DISABLED);
return (IPMP_PROBE_FAILED);
return (IPMP_PROBE_UNKNOWN);
return (IPMP_PROBE_OK);
}
/*
* Return the external IPMP target mode associated with phyint instance `pii'.
*/
static ipmp_if_targmode_t
{
if (!PROBE_ENABLED(pii))
return (IPMP_TARG_DISABLED);
else if (pii->pii_targets_are_routers)
return (IPMP_TARG_ROUTES);
else
return (IPMP_TARG_MULTICAST);
}
/*
* Return the external IPMP flags associated with phyint `pi'.
*/
static ipmp_if_flags_t
{
ipmp_if_flags_t flags = 0;
if (logint_upcount(pi) == 0)
if (pi->pi_hwaddrdup)
return (flags);
}
/*
* Store the test address used on phyint instance `pii' in `ssp'. If there's
* no test address, 0.0.0.0 is stored.
*/
static struct sockaddr_storage *
{
if (PROBE_ENABLED(pii))
else
return (ssp);
}
/*
* Return the external IPMP group state associated with phyint group `pg'.
*/
static ipmp_group_state_t
{
case PG_FAILED:
return (IPMP_GROUP_FAILED);
case PG_DEGRADED:
return (IPMP_GROUP_DEGRADED);
case PG_OK:
return (IPMP_GROUP_OK);
}
abort();
/* NOTREACHED */
}
/*
* Return the external IPMP probe state associated with probe `ps'.
*/
static ipmp_probe_state_t
{
case PR_UNUSED:
case PR_LOST:
return (IPMP_PROBE_LOST);
case PR_UNACKED:
return (IPMP_PROBE_SENT);
case PR_ACKED:
return (IPMP_PROBE_ACKED);
}
abort();
/* NOTREACHED */
}
/*
* Generate an ESC_IPMP_PROBE_STATE sysevent for the probe described by `pr'
* on phyint instance `pii'. Returns 0 on success, -1 on failure.
*/
int
{
struct sockaddr_storage ss;
if (errno != 0) {
logperror("cannot create `interface change' event");
return (-1);
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
pr->pr_hrtime_sent);
if (errno != 0)
goto failed;
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
else
sizeof (ss));
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
logperror("cannot create `probe state' event");
return (-1);
}
/*
* Generate an ESC_IPMP_GROUP_STATE sysevent for phyint group `pg'.
* Returns 0 on success, -1 on failure.
*/
static int
{
if (errno != 0) {
logperror("cannot create `group state change' event");
return (-1);
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
logperror("cannot create `group state change' event");
return (-1);
}
/*
* Generate an ESC_IPMP_GROUP_CHANGE sysevent of type `op' for phyint group
* `pg'. Returns 0 on success, -1 on failure.
*/
static int
{
if (errno != 0) {
logperror("cannot create `group change' event");
return (-1);
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
logperror("cannot create `group change' event");
return (-1);
}
/*
* Generate an ESC_IPMP_GROUP_MEMBER_CHANGE sysevent for phyint `pi' in
* group `pg'. Returns 0 on success, -1 on failure.
*/
static int
{
if (errno != 0) {
logperror("cannot create `group member change' event");
return (-1);
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
logperror("cannot create `group member change' event");
return (-1);
}
/*
* Generate an ESC_IPMP_IF_CHANGE sysevent for phyint `pi' in group `pg'.
* Returns 0 on success, -1 on failure.
*/
static int
{
if (errno != 0) {
logperror("cannot create `interface change' event");
return (-1);
}
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
if (errno != 0)
goto failed;
logperror("cannot create `interface change' event");
return (-1);
}
/*
* Generate a signature for use. The signature is conceptually divided
* into two pieces: a random 16-bit "generation number" and a 48-bit
* monotonically increasing integer. The generation number protects
* against stale updates to entities (e.g., IPMP groups) that have been
* deleted and since recreated.
*/
static uint64_t
gensig(void)
{
static int seeded = 0;
if (seeded == 0) {
seeded++;
}
}
/*
* Store the information associated with group `grname' into a dynamically
* allocated structure pointed to by `*grinfopp'. Returns an IPMP error code.
*/
unsigned int
{
struct phyint_group *pg;
unsigned int i, j;
struct sockaddr_storage *addrs;
int fdt = 0;
return (IPMP_EUNKGROUP);
/*
* Tally up the number of interfaces, allocate an array to hold them,
* and insert their names into the array. While we're at it, if any
* interface is actually enabled to send probes, save the group fdt.
*/
nif++;
}
/*
* If this is the anonymous group, there's no other information to
* collect (since there's no IPMP interface).
*/
if (pg == phyint_anongroup) {
}
/*
* Grab some additional information about the group from the kernel.
* (NOTE: since SIOCGLIFGROUPINFO does not look up by interface name,
* we can use ifsock_v4 even for a V6-only group.)
*/
return (IPMP_EUNKGROUP);
logperror("getgroupinfo: SIOCGLIFGROUPINFO");
return (IPMP_FAILURE);
}
/*
* Tally up the number of data addresses, allocate an array to hold
* them, and insert their values into the array.
*/
naddr++;
i = 0;
/*
* It's possible to have duplicate addresses (if some are
* down). Weed the dups out to avoid confusing consumers.
* (If groups start having tons of addresses, we'll need a
* better algorithm here.)
*/
for (j = 0; j < i; j++) {
break;
}
if (j == i) {
}
}
naddr = i;
}
/*
* Store the target information associated with phyint instance `pii' into a
* dynamically allocated structure pointed to by `*targinfopp'. Returns an
* IPMP error code.
*/
unsigned int
{
struct sockaddr_storage ss;
if (PROBE_CAPABLE(pii)) {
do {
}
}
}
/*
* Store the information associated with interface `ifname' into a dynamically
* allocated structure pointed to by `*ifinfopp'. Returns an IPMP error code.
*/
unsigned int
{
int retval;
return (IPMP_EUNKIF);
goto out;
out:
return (retval);
}
/*
* Store the current list of IPMP groups into a dynamically allocated
* structure pointed to by `*grlistpp'. Returns an IPMP error code.
*/
unsigned int
{
struct phyint_group *pg;
char (*groups)[LIFGRNAMSIZ];
unsigned int i, ngroup;
/*
* Tally up the number of groups, allocate an array to hold them, and
* insert their names into the array.
*/
ngroup++;
}
}
/*
* Store the address information for `ssp' (in group `grname') into a
* dynamically allocated structure pointed to by `*adinfopp'. Returns an IPMP
* error code. (We'd call this function getaddrinfo(), but it would conflict
* with getaddrinfo(3SOCKET)).
*/
unsigned int
{
int ifsock;
const char *binding = "";
struct phyint_group *pg;
return (IPMP_EUNKADDR);
/*
* Walk through the data addresses, and find a match. Note that since
* some of the addresses may be down, more than one may match. We
* prefer an up address (if one exists).
*/
addrmatchp = addrp;
break;
}
}
if (addrmatchp == NULL)
return (IPMP_EUNKADDR);
if (state == IPMP_ADDR_UP) {
}
}
/*
* Store a snapshot of the IPMP subsystem into a dynamically allocated
* structure pointed to by `*snapp'. Returns an IPMP error code.
*/
unsigned int
{
unsigned int i, j;
int retval;
snap = ipmp_snap_create();
return (IPMP_ENOMEM);
/*
* Add group list.
*/
if (retval != IPMP_SUCCESS)
goto failed;
/*
* Add information for each group in the list, along with all of its
* data addresses.
*/
if (retval != IPMP_SUCCESS)
goto failed;
if (retval != IPMP_SUCCESS) {
goto failed;
}
if (retval != IPMP_SUCCESS)
goto failed;
if (retval != IPMP_SUCCESS) {
goto failed;
}
}
}
/*
* Add information for each configured phyint.
*/
if (retval != IPMP_SUCCESS)
goto failed;
if (retval != IPMP_SUCCESS) {
goto failed;
}
}
return (IPMP_SUCCESS);
return (retval);
}