24511676 Connectivity to LDOM with OVS is lost when start/stop of LDOM is performed
/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include <errno.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netpacket/packet.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <net/route.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/sockio.h>
#include <strings.h>
#include <libdllink.h>
#include <kstat2.h>
#include "coverage.h"
#include "dpif-netdev.h"
#include "dynamic-string.h"
#include "fatal-signal.h"
#include "hash.h"
#include "hmap.h"
#include "netdev-provider.h"
#include "netdev-vport.h"
#include "ofpbuf.h"
#include "openflow/openflow.h"
#include "ovs-atomic.h"
#include "packets.h"
#include "poll-loop.h"
#include "shash.h"
#include "socket-util.h"
#include "sset.h"
#include "timer.h"
#include "unaligned.h"
#include "vlog.h"
#include "netdev-solaris.h"
#include "util-solaris.h"
#include "dpif-solaris.h"
/*
* Enable vlog() for this module
*/
VLOG_DEFINE_THIS_MODULE(netdev_solaris);
/*
* Per-network device state.
*/
struct netdev_solaris {
struct netdev up;
/* Protects all members below. */
struct ovs_mutex mutex;
/*
* Bit mask of cached properties. These can be cached because
* nothing besides vswitchd is altering the properties.
*/
unsigned int cache_valid;
/*
* Network device features (e.g., speed, duplex, etc)
*/
enum netdev_features current;
enum netdev_features advertised;
enum netdev_features supported;
int get_features_error;
int ifindex; /* interface index */
struct in_addr in4; /* IPv4 address */
struct in_addr netmask; /* IPv4 netmask */
struct in6_addr in6; /* IPv6 address */
unsigned int plumbed; /* per-family plumbed */
unsigned int implicitly_plumbed; /* per-family implicitly plumbed */
char class[DLADM_PROP_VAL_MAX]; /* datalink class */
char brname[MAXLINKNAMELEN]; /* bridge name */
int mtu; /* datalink MTU */
uint8_t etheraddr[ETH_ADDR_LEN]; /* MAC address */
uint32_t kbits_rate; /* Ingress policing rate */
struct tc *tc; /* traffic control */
};
/*
* Bits indicating what network device configuration is cached.
* See cache_valid field above.
*/
enum {
VALID_IFINDEX = 1 << 0,
VALID_ETHERADDR = 1 << 1,
VALID_IN4 = 1 << 2,
VALID_IN6 = 1 << 3,
VALID_MTU = 1 << 4,
VALID_LINKCLASS = 1 << 5,
VALID_FEATURES = 1 << 6
};
/*
* Used to track state of IP plumbing on network devices.
*/
#define SOLARIS_IPV4 0x01
#define SOLARIS_IPV6 0x02
/*
* Cached socket descriptors.
*/
static int sock4;
static int sock6;
/*
* Cached kstat2_handle_t. Re-use unless an error causes it to be
* closed. In that case, cache the handle on the next open.
*/
static kstat2_handle_t nd_khandle;
static boolean_t kstat2_handle_initialized = B_FALSE;
static struct ovs_mutex kstat_mutex = OVS_MUTEX_INITIALIZER;
static int netdev_solaris_init(void);
static struct netdev_solaris *netdev_solaris_cast(const struct netdev *);
/* Maintaining a mapping of every netdev->name to its bridge name. */
struct shash port_to_bridge_map = SHASH_INITIALIZER(&port_to_bridge_map);
/*
* An instance of a traffic control class.
*
* Always associated with a particular network device.
*
* Each TC implementation subclasses this with whatever additional data
* it needs.
*/
struct tc {
const struct tc_ops *ops;
/*
* Contains "struct tc_queues"s.
* Read by generic TC layer.
* Written only by TC implementation.
*/
struct hmap queues;
};
#define TC_INITIALIZER(TC, OPS) { OPS, HMAP_INITIALIZER(&(TC)->queues) }
/*
* One traffic control queue.
*
* Each TC implementation subclasses this with whatever additional
* data it needs.
*/
struct tc_queue {
struct hmap_node hmap_node; /* In struct tc's "queues" hmap. */
unsigned int queue_id; /* OpenFlow queue ID. */
long long int created; /* Time queue was created, in msecs. */
};
/*
* A particular kind of traffic control.
*
* Each implementation generally maps to one particular Linux qdisc class.
*
* The functions below return 0 if successful or a positive errno value on
* failure, except where otherwise noted. All of them must be provided,
* except where otherwise noted.
*/
struct tc_ops {
/*
* Name used by kernel in the TCA_KIND attribute of tcmsg, e.g. "htb".
* This is null for tc_ops_default since there is no appropriate
* value.
*/
const char *linux_name;
/*
* Name used in OVS database, e.g. "linux-htb". Must be nonnull.
*/
const char *ovs_name;
/*
* Number of supported OpenFlow queues, 0 for qdiscs that have no
* queues. The queues are numbered 0 through n_queues - 1.
*/
unsigned int n_queues;
/*
* Called to install this TC class on 'netdev'. The implementation
* should make the calls required to set up 'netdev' with the right
* qdisc and configure it according to 'details'. The implementation
* may assume that the current qdisc is the default; that is, there
* is no need for it to delete the current qdisc before installing
* itself.
*
* The contents of 'details' should be documented as valid for
* 'ovs_name' in the "other_config" column in the "QoS" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
* This function must return 0 if and only if it sets 'netdev->tc'
* to an initialized 'struct tc'.
*
* This function should always be nonnull.
*/
int (*tc_install)(struct netdev *netdev, const struct smap *details);
/*
* Called when the netdev code determines that this TC class's qdisc
* is installed on 'netdev', but we didn't install it ourselves and
* so don't know any of the details.
*
* There is nothing for this function to do on Solaris.
*
* This function must return 0 if and only if it sets 'netdev->tc'
* to an initialized 'struct tc'.
*/
int (*tc_load)(struct netdev *netdev, struct ofpbuf *nlmsg);
/*
* Destroys the data structures allocated by the implementation as
* part of 'tc'. (This includes destroying 'tc->queues' by calling
* tc_destroy(tc).
*
* This function may be null if 'tc' is trivial.
*/
void (*tc_destroy)(struct tc *tc);
/*
* Retrieves details of 'netdev->tc' configuration into 'details'.
*
* The contents of 'details' should be documented as valid for
* 'ovs_name' in the "other_config" column in the "QoS" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
* This function may be null if 'tc' is not configurable.
*/
int (*qdisc_get)(const struct netdev *netdev, struct smap *details);
/*
* Reconfigures 'netdev->tc' according to 'details'.
*
* The contents of 'details' should be documented as valid for
* 'ovs_name' in the "other_config" column in the "QoS" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
* This function may be null if 'tc' is not configurable.
*/
int (*qdisc_set)(struct netdev *, const struct smap *details);
/*
* Retrieves details of 'queue' on 'netdev->tc' into 'details'.
* 'queue' is one of the 'struct tc_queue's within
* 'netdev->tc->queues'.
*
* The contents of 'details' should be documented as valid for
* 'ovs_name' in the "other_config" column in the "Queue" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
* This function may be null if 'tc' does not have queues
* ('n_queues' is 0).
*/
int (*class_get)(const struct netdev *netdev,
const struct tc_queue *queue, struct smap *details);
/*
* Configures or reconfigures 'queue_id' on 'netdev->tc' according to
* 'details'. The caller ensures that 'queue_id' is less than
* 'n_queues'.
*
* The contents of 'details' should be documented as valid for
* 'ovs_name' in the "other_config" column in the "Queue" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
* This function may be null if 'tc' does not have queues or its
* queues are not configurable.
*/
int (*class_set)(struct netdev *, unsigned int queue_id,
const struct smap *details);
/*
* Deletes 'queue' from 'netdev->tc'. 'queue' is one of the 'struct
* tc_queue's within 'netdev->tc->queues'.
*
* This function may be null if 'tc' does not have queues or its queues
* cannot be deleted.
*/
int (*class_delete)(struct netdev *, struct tc_queue *queue);
/*
* Obtains stats for 'queue' from 'netdev->tc'. 'queue' is one of the
* 'struct tc_queue's within 'netdev->tc->queues'.
*
* On success, initializes '*stats'.
*
* This function may be null if 'tc' does not have queues or if it
* cannot report queue statistics.
*/
int (*class_get_stats)(const struct netdev *netdev,
const struct tc_queue *queue, struct netdev_queue_stats *stats);
/*
* Extracts queue stats from 'nlmsg', which is a response to a
* RTM_GETTCLASS message, and passes them to 'cb' along with 'aux'.
*
* This function may be null if 'tc' does not have queues or if it
* cannot report queue statistics.
*/
int (*class_dump_stats)(const struct netdev *netdev,
const struct ofpbuf *nlmsg, netdev_dump_queue_stats_cb *cb,
void *aux);
};
static void
tc_init(struct tc *tc, const struct tc_ops *ops)
{
tc->ops = ops;
hmap_init(&tc->queues);
}
static void
tc_destroy(struct tc *tc)
{
hmap_destroy(&tc->queues);
}
static const struct tc_ops tc_ops_htb;
static const struct tc_ops tc_ops_default;
static const struct tc_ops *const tcs[] = {
&tc_ops_htb, /* Hierarchy token bucket */
&tc_ops_default, /* Default qdisc */
NULL
};
static const struct tc_ops *
tc_lookup_ovs_name(const char *name)
{
const struct tc_ops *const *opsp;
for (opsp = tcs; *opsp != NULL; opsp++) {
const struct tc_ops *ops = *opsp;
if (strcmp(name, ops->ovs_name) == 0) {
return (ops);
}
}
return (NULL);
}
static struct tc_queue *
tc_find_queue__(const struct netdev *netdev_, unsigned int queue_id,
size_t hash)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
struct tc_queue *queue;
HMAP_FOR_EACH_IN_BUCKET(queue, hmap_node, hash, &netdev->tc->queues) {
if (queue->queue_id == queue_id) {
return (queue);
}
}
return (NULL);
}
static struct tc_queue *
tc_find_queue(const struct netdev *netdev, unsigned int queue_id)
{
return (tc_find_queue__(netdev, queue_id, hash_int(queue_id, 0)));
}
static int
tc_delete_class(const struct netdev *netdev OVS_UNUSED,
unsigned int handle OVS_UNUSED)
{
return (0);
}
static int
tc_del_qdisc(struct netdev *netdev_)
{
const char *netdev_name = netdev_get_name(netdev_);
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
VLOG_DBG("tc_del_qdisc device %s", netdev_name);
if (netdev->tc) {
if (netdev->tc->ops->tc_destroy) {
netdev->tc->ops->tc_destroy(netdev->tc);
}
netdev->tc = NULL;
}
return (0);
}
/*
* If 'netdev''s qdisc type and parameters are not yet known, queries the
* kernel to determine what they are. Returns 0 if successful, otherwise a
* positive errno value.
*/
static int
tc_query_qdisc(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const struct tc_ops *ops;
int load_error;
int error;
if (netdev->tc) {
return (0);
}
/*
* Either it's a built-in qdisc, or it's a qdisc set up by some
* other entity that doesn't have a handle 1:0. We will assume
* that it's the system default qdisc.
*/
ops = &tc_ops_default;
error = 0;
/* Instantiate it. */
load_error = ops->tc_load(CONST_CAST(struct netdev *, netdev_), NULL);
ovs_assert((load_error == 0) == (netdev->tc != NULL));
return (error ? error : load_error);
}
static bool
is_netdev_solaris_class(const struct netdev_class *netdev_class)
{
return (netdev_class->init == netdev_solaris_init);
}
static struct netdev_solaris *
netdev_solaris_cast(const struct netdev *netdev)
{
ovs_assert(is_netdev_solaris_class(netdev_get_class(netdev)));
return (CONTAINER_OF(netdev, struct netdev_solaris, up));
}
char *
netdev_solaris_get_class(struct netdev *netdev)
{
return ((netdev_solaris_cast(netdev))->class);
}
static int
netdev_solaris_plumb(const struct netdev *netdev_, sa_family_t af)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char *astring;
int sock;
int proto;
int error;
ovs_assert(af == AF_INET || af == AF_INET6);
if (af == AF_INET) {
sock = sock4;
astring = "IPv4";
proto = SOLARIS_IPV4;
} else {
sock = sock6;
astring = "IPv6";
proto = SOLARIS_IPV6;
}
if ((netdev->plumbed & proto) != 0)
return (0);
error = solaris_plumb_if(sock, netdev_name, af);
if (error != 0) {
VLOG_ERR("%s device could not be plumbed", netdev_name);
return (error);
}
VLOG_DBG("%s device plumbed for %s", netdev_name, astring);
netdev->implicitly_plumbed |= proto;
netdev->plumbed |= proto;
return (0);
}
static int
netdev_solaris_unplumb(const struct netdev *netdev_, sa_family_t af)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char *astring;
int sock;
int proto;
int error;
ovs_assert(af == AF_INET || af == AF_INET6);
if (af == AF_INET) {
sock = sock4;
astring = "IPv4";
proto = SOLARIS_IPV4;
} else {
sock = sock6;
astring = "IPv6";
proto = SOLARIS_IPV6;
}
if ((netdev->implicitly_plumbed & proto) == 0 &&
(netdev->up.netdev_class != &netdev_internal_class)) {
return (0);
}
error = solaris_unplumb_if(sock, netdev_name, af);
if (error != 0) {
if (error == ENXIO &&
netdev->up.netdev_class == &netdev_internal_class) {
return (0);
}
VLOG_ERR("%s device could not be unplumbed %d", netdev_name,
error);
}
VLOG_ERR("%s device unplumbed for %s", netdev_name, astring);
netdev->implicitly_plumbed &= ~proto;
netdev->plumbed &= ~proto;
return (0);
}
struct solaris_netdev_sdmap {
const char *sns_val;
enum netdev_features sns_feature;
};
static int
netdev_solaris_chk_speed_duplex(const char *netdev_name,
const char *field_name, enum netdev_features *features)
{
struct solaris_netdev_sdmap map [] = {
{"10G-f", NETDEV_F_10GB_FD},
{"1G-f", NETDEV_F_1GB_FD},
{"1G-h", NETDEV_F_1GB_HD},
{"100M-f", NETDEV_F_100MB_FD},
{"100M-h", NETDEV_F_100MB_HD},
{"10M-f", NETDEV_F_100MB_FD},
{"10M-h", NETDEV_F_10MB_HD},
{"40G-f", NETDEV_F_40GB_FD},
{"100G-f", NETDEV_F_100GB_FD},
{"1T-f", NETDEV_F_1TB_FD},
{NULL, NETDEV_F_OTHER},
};
struct solaris_netdev_sdmap *snsp;
char buffer[DLADM_PROP_VAL_MAX];
int i;
int error;
error = solaris_get_dlprop(netdev_name, "speed-duplex", field_name,
buffer, sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve feature speed-duplex for %s "
"device", netdev_name);
return (error);
}
snsp = map;
for (i = 0; snsp[i].sns_val != NULL; i++) {
if (strstr(buffer, snsp[i].sns_val) != NULL)
*features |= snsp[i].sns_feature;
}
return (0);
}
static int
netdev_solaris_read_features(struct netdev_solaris *netdev,
const char *netdev_name)
{
char buffer[DLADM_PROP_VAL_MAX];
int error = 0;
int speed;
bool full;
if (netdev->cache_valid & VALID_FEATURES)
goto exit;
/*
* Supported features
*
* Unsupported features:
* NETDEV_F_COPPER
* NETDEV_F_FIBER
* NETDEV_F_PAUSE;
* NETDEV_F_PAUSE_ASYM;
*/
netdev->supported = 0;
if ((error = netdev_solaris_chk_speed_duplex(netdev_name,
"possible", &netdev->supported)) != 0)
goto exit;
/*
* Advertised features.
*
* Unsupported features:
* NETDEV_F_COPPER
* NETDEV_F_FIBER
* NETDEV_F_PAUSE;
* NETDEV_F_PAUSE_ASYM;
*/
netdev->advertised = 0;
if ((error = netdev_solaris_chk_speed_duplex(netdev_name,
"current", &netdev->advertised)) != 0)
goto exit;
/* Current settings. */
error = solaris_get_dlprop(netdev_name, "speed", "current", buffer,
sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve speed for %s device",
netdev_name);
goto exit;
}
speed = atoi(buffer);
error = solaris_get_dlprop(netdev_name, "duplex", "current", buffer,
sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve duplex for %s device",
netdev_name);
goto exit;
}
full = (strcmp(buffer, "full") == 0);
speed /= 1000000;
if (speed == 10) {
netdev->current = full ? NETDEV_F_10MB_FD : NETDEV_F_10MB_HD;
} else if (speed == 100) {
netdev->current = full ? NETDEV_F_100MB_FD : NETDEV_F_100MB_HD;
} else if (speed == 1000) {
netdev->current = full ? NETDEV_F_1GB_FD : NETDEV_F_1GB_HD;
} else if (speed == 10000) {
netdev->current = NETDEV_F_10GB_FD;
} else if (speed == 40000) {
netdev->current = NETDEV_F_40GB_FD;
} else if (speed == 100000) {
netdev->current = NETDEV_F_100GB_FD;
} else if (speed == 1000000) {
netdev->current = NETDEV_F_1TB_FD;
} else {
netdev->current = 0;
}
netdev->advertised |= (netdev->supported & NETDEV_F_AUTONEG);
netdev->cache_valid |= VALID_FEATURES;
exit:
netdev->get_features_error = error;
return (error);
}
static int
netdev_solaris_init(void)
{
int error;
sock4 = socket(AF_INET, SOCK_DGRAM, 0);
if (sock4 < 0) {
error = errno;
VLOG_ERR("failed to create AF_INET socket (%s)",
ovs_strerror(error));
return (error);
}
sock6 = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock6 < 0) {
error = errno;
VLOG_ERR("failed to create AF_INET6 socket (%s)",
ovs_strerror(error));
return (error);
}
error = solaris_init_rad();
return (error);
}
static void
netdev_solaris_run(void)
{
}
static void
netdev_solaris_wait(void)
{
}
static struct netdev *
netdev_solaris_alloc(void)
{
struct netdev_solaris *netdev = xzalloc(sizeof (*netdev));
return (&netdev->up);
}
static void
netdev_solaris_add_port_to_bridge_mapping(const struct netdev
*netdev, const char *brname)
{
VLOG_DBG("netdev_solaris_add_port_to_bridge_mapping: adding a mapping "
"<%s,%s> to port_to_bridge_map", netdev->name, brname);
shash_add_nocopy(&port_to_bridge_map, netdev->name, brname);
}
static int
netdev_solaris_unconfigure_uplink(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error;
char curr_lower[DLADM_PROP_VAL_MAX];
struct netdev *netdev_to_migrate = NULL;
char *new_lower = NULL;
bool b_error = false;
VLOG_DBG("netdev_solaris_unconfigure_uplink device %s", netdev_name);
error = solaris_get_dlprop(netdev->brname, "lower-link", "current",
curr_lower, sizeof (curr_lower));
if (error) {
VLOG_ERR("netdev_solaris_unconfigure_uplink couldn't obtain "
"bridge(%s) lowerlink", netdev->brname);
return (0);
}
if (strcmp(netdev_name, curr_lower) == 0) {
/*
* The uplink which we are trying to remove has bridge vnic on
* top of it. We need to migrate bridge vnic to a different
* uplink or to ovs.etherstub0 if uplink_port_list is empty.
*/
VLOG_DBG("netdev_solaris_unconfigure_uplink: unconfiguring the "
"uplink (%s) which is the bridge %s's lowerlink (%s)",
netdev_name, netdev->brname, curr_lower);
netdev_to_migrate = dpif_solaris_obtain_netdev_to_migrate(
netdev->brname, &b_error);
if (b_error) {
VLOG_ERR("netdev_solaris_unconfigure_uplink: couldn't "
"obtain netdev_to_migrate for bridge vnic %s",
netdev->brname);
return (0);
}
if (netdev_to_migrate == NULL)
new_lower = NETDEV_IMPL_ETHERSTUB;
else
new_lower = netdev_to_migrate->name;
VLOG_DBG("netdev_solaris_unconfigure_uplink migrating bridge "
"vnic to %s", new_lower);
error = solaris_modify_vnic(new_lower, netdev->brname);
if (error != 0) {
VLOG_ERR("failed to unconfigure %s as uplink for %s: "
"%s", netdev_name, netdev->brname,
ovs_strerror(error));
return (0);
}
/*
* reset internal port's physname and refresh its port channel.
*/
dpif_solaris_migrate_internal_port(netdev->brname, new_lower);
}
return (0);
}
static int
netdev_solaris_configure_uplink(const struct netdev *netdev_,
const char *brname)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *new_uplink = netdev_get_name(netdev_);
char curr_lower[DLADM_PROP_VAL_MAX];
int error;
const char *netdev_existing_class;
struct netdev *i_netdev;
boolean_t migrated = B_FALSE;
VLOG_DBG("netdev_solaris_configure_uplink device %s", new_uplink);
/*
* Normally, we would expect to see that the bridge VNIC has already
* been created by a call to netdev_solaris_construct() to create the
* bridge netdev. However, on a service restart ovs-vswitchd sometimes
* adds the lower-link port prior to adding the bridge's internal port.
* As a result, we need to create the bridge VNIC here if it does not
* already exist.
*/
error = solaris_get_dlprop(brname, "lower-link", "current",
curr_lower, sizeof (curr_lower));
VLOG_DBG("netdev_solaris_configure_uplink lower-link:%s", curr_lower);
if (error == ENODEV) {
/*
* No implicit VNIC exists, create it now first over
* NETDEV_IMPL_ETHERSTUB and later migrate onto new_uplink. Not
* creating it directly over new_uplink as it may fail(for vnet)
* if it doesn't support creating vnic with "auto" mac-addr-type
*/
VLOG_DBG("%s vnic being created on %s", brname,
NETDEV_IMPL_ETHERSTUB);
error = solaris_create_vnic(NETDEV_IMPL_ETHERSTUB, brname);
if (error == 0) {
VLOG_DBG("%s vnic is being migrated on %s", brname,
new_uplink);
error = solaris_modify_vnic(new_uplink, brname);
if (error == 0) {
(void) strlcpy(netdev->brname, brname,
sizeof (netdev->brname));
} else {
VLOG_ERR("Failed to migrate %s vnic over %s:%s",
brname, new_uplink, ovs_strerror(error));
}
} else {
VLOG_ERR("Failed to create vnic for %s: %s",
brname, ovs_strerror(error));
}
goto exit;
} else if (error != 0) {
VLOG_ERR("Failed to get the lower-link for %s: %s",
brname, ovs_strerror(error));
goto exit;
}
/*
* If the lower-link is already set correctly, then return with
* success.
*/
if (strcmp(curr_lower, new_uplink) == 0) {
VLOG_DBG("netdev_solaris_configure_uplink lower-link(%s) is "
"already correctly set. (%s)", curr_lower, new_uplink);
error = 0;
goto exit;
}
if (strcmp(curr_lower, NETDEV_IMPL_ETHERSTUB) == 0) {
/*
* Bridge vnic is on ovs.etherstub0. We have to migrate the
* bridge vnic to the uplink
*/
VLOG_DBG("bridge vnic %s is on %s, migrating it to %s",
brname, curr_lower, new_uplink);
error = solaris_modify_vnic(new_uplink, brname);
if (error != 0) {
VLOG_ERR("failed to configure %s as uplink: %s",
new_uplink, ovs_strerror(error));
goto exit;
}
migrated = B_TRUE;
} else {
/*
* Bridge vnic is already on an uplink. Now we see if the
* uplink to be added is other than etherstub or not.
* If the bridge vnic is currently residing on an etherstub
* and the one to be configured is not etherstub,
* then we migrate the bridge vnic.
*/
i_netdev = netdev_from_name(curr_lower);
if (!i_netdev) {
VLOG_ERR("netdev_solaris_configure_uplink error "
"in fetching lower-link netdev for %s", curr_lower);
goto exit;
}
/* i_netdev->ref_cnt--; */
netdev_close(i_netdev);
netdev_existing_class = netdev_solaris_get_class(i_netdev);
if ((strcmp(netdev_existing_class, "etherstub") == 0) &&
(strcmp(netdev->class, "etherstub") != 0)) {
error = solaris_modify_vnic(new_uplink, brname);
if (error != 0) {
VLOG_ERR("failed to configure %s as uplink: %s",
new_uplink, ovs_strerror(error));
goto exit;
}
migrated = B_TRUE;
}
}
(void) strlcpy(netdev->brname, brname, sizeof (netdev->brname));
exit:
/*
* reset internal port's physname and refresh its port channel.
*/
if (migrated)
dpif_solaris_migrate_internal_port(brname, new_uplink);
return (error);
}
static boolean_t
solaris_is_if_plumbed(struct netdev *netdev_, sa_family_t af, uint64_t *flags)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int sock;
int proto;
int error;
char *astring;
ovs_assert(af == AF_INET || af == AF_INET6);
if (af == AF_INET) {
sock = sock4;
astring = "IPv4";
proto = SOLARIS_IPV4;
} else {
sock = sock6;
astring = "IPv6";
proto = SOLARIS_IPV6;
}
error = solaris_if_enabled(sock, netdev_name, flags);
if (error == 0) {
netdev->plumbed |= proto;
} else if (error != ENXIO) {
VLOG_DBG("netdev_is_if_plumbed %s device encountered "
"error %d for %s", netdev_name, error, astring);
}
return (error == 0);
}
int
netdev_create_impl_etherstub(void)
{
int error;
error = solaris_create_etherstub(NETDEV_IMPL_ETHERSTUB);
if (error != 0) {
VLOG_ERR("netdev_create_impl_etherstub: failed to create %s: "
"%s", NETDEV_IMPL_ETHERSTUB, ovs_strerror(error));
} else {
boolean_t bval = B_TRUE;
error = solaris_set_dlprop_boolean(NETDEV_IMPL_ETHERSTUB,
"openvswitch", &bval, B_FALSE);
if (error != 0) {
(void) solaris_delete_etherstub(NETDEV_IMPL_ETHERSTUB);
VLOG_ERR("netdev_create_impl_etherstub: failed to "
"set 'openvswitch' property on %s: %s: ",
NETDEV_IMPL_ETHERSTUB, ovs_strerror(error));
}
}
return (error);
}
void
netdev_delete_impl_etherstub(void)
{
boolean_t bval = B_FALSE;
int error;
error = solaris_set_dlprop_boolean(NETDEV_IMPL_ETHERSTUB,
"openvswitch", &bval, B_FALSE);
if (error != 0) {
VLOG_ERR("netdev_create_impl_etherstub: failed to "
"set 'openvswitch' property on %s: %s: ",
NETDEV_IMPL_ETHERSTUB, ovs_strerror(error));
} else {
error = solaris_delete_etherstub(NETDEV_IMPL_ETHERSTUB);
if (error != 0) {
VLOG_ERR("netdev_delete_impl_etherstub: failed to "
"delete %s: %s", NETDEV_IMPL_ETHERSTUB,
ovs_strerror(error));
}
}
}
boolean_t
netdev_impl_etherstub_exists(void)
{
char prop[DLADM_PROP_VAL_MAX];
int error;
error = solaris_get_dlprop(NETDEV_IMPL_ETHERSTUB, "openvswitch",
"current", prop, sizeof (prop));
if (error == ENODEV)
return (B_FALSE);
/*
* If the implicit etherstub exists, but the openvswitch
* property is not set, then something has gone wrong.
*/
if (strcmp(prop, "1") != 0) {
VLOG_FATAL("%s does not have openvswitch property set",
NETDEV_IMPL_ETHERSTUB);
}
return (B_TRUE);
}
/*
* Creates system and internal devices. Really very little to
* do here given that neither system or internal devices must
* exist in the kernel yet.
*/
static int
netdev_solaris_construct(struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char buffer[DLADM_PROP_VAL_MAX];
uint64_t flags;
int error;
ovs_mutex_init(&netdev->mutex);
if (netdev->up.netdev_class != &netdev_internal_class) {
VLOG_DBG("netdev_solaris_construct system device %s",
netdev_name);
} else {
VLOG_DBG("netdev_solaris_construct internal device %s",
netdev_name);
}
netdev->implicitly_plumbed = 0;
netdev->plumbed = 0;
(void) solaris_is_if_plumbed(netdev_, AF_INET, &flags);
(void) solaris_is_if_plumbed(netdev_, AF_INET6, &flags);
/*
* loopback is illegal.
*/
if (netdev->plumbed != 0 && flags & NETDEV_LOOPBACK) {
VLOG_ERR("%s: cannot add a loopback device",
netdev_name);
return (EINVAL);
}
if (netdev->up.netdev_class == &netdev_internal_class) {
error = solaris_get_dlprop(netdev_name, "lower-link",
"current", buffer, sizeof (buffer));
if (error == ENODEV) {
error = solaris_create_vnic(NETDEV_IMPL_ETHERSTUB,
netdev_name);
if (error != 0) {
VLOG_ERR("failed to configure %s as uplink: "
"%s", netdev_name, ovs_strerror(error));
return (error);
}
} else if (error != 0) {
VLOG_ERR("Failed to get the lower-link for %s: %s",
netdev_name, ovs_strerror(error));
}
}
return (0);
}
static void
netdev_solaris_destruct(struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error;
VLOG_DBG("netdev_solaris_destruct device %s", netdev_name);
/*
* If implicitly plumbed, then unplumb it.
*/
(void) netdev_solaris_unplumb(netdev_, AF_INET);
(void) netdev_solaris_unplumb(netdev_, AF_INET6);
if (netdev->up.netdev_class == &netdev_internal_class) {
error = solaris_delete_vnic(netdev_name);
if (error != 0) {
VLOG_ERR("failed to delete %s: %s",
netdev_name, ovs_strerror(error));
}
} else {
if (netdev->brname[0] != '\0') {
netdev_solaris_unconfigure_uplink(netdev_);
}
}
ovs_mutex_destroy(&netdev->mutex);
}
static void
netdev_solaris_dealloc(struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
free(netdev);
}
/*
* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
* otherwise a positive errno value.
*/
static int
netdev_solaris_set_etheraddr(struct netdev *netdev_,
const uint8_t mac[ETH_ADDR_LEN])
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char buffer[128];
int error = 0;
VLOG_DBG("netdev_solaris_set_etheraddr device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if ((netdev->cache_valid & VALID_ETHERADDR) &&
(eth_addr_equals(netdev->etheraddr, mac))) {
goto exit;
}
/*
* In case there is some kind of failure, invalidate
* the cached value.
*/
netdev->cache_valid &= ~VALID_ETHERADDR;
/*
* MAC addresses are datalink properties.
*/
(void) snprintf(buffer, sizeof (buffer), ETH_ADDR_FMT,
ETH_ADDR_ARGS(mac));
error = solaris_set_dlprop_string(netdev_name, "mac-address", buffer,
B_TRUE);
if (error != 0) {
VLOG_ERR("set etheraddr %s on %s device failed: %s",
buffer, netdev_name, ovs_strerror(error));
goto exit;
}
memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
netdev->cache_valid |= VALID_ETHERADDR;
netdev_change_seq_changed(netdev_);
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_get_dlclass(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char buffer[DLADM_PROP_VAL_MAX];
int error = 0;
if (netdev->cache_valid & VALID_LINKCLASS)
goto exit;
/*
* Get the datalink class for this link.
*/
error = solaris_get_dlclass(netdev_name, buffer, sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve linkclass for %s device, %d",
netdev_name, error);
goto exit;
}
(void) strlcpy(netdev->class, buffer, sizeof (netdev->class));
netdev->cache_valid |= VALID_LINKCLASS;
exit:
return (error);
}
/*
* Determines if this netdev is an uplink for the bridge.
*/
static bool
netdev_solaris_is_uplink(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
VLOG_DBG("netdev_solaris_is_uplink device %s", netdev_name);
if (netdev_solaris_get_dlclass(netdev_) != 0)
return (false);
return (solaris_is_uplink_class(netdev->class));
}
static int
netdev_solaris_get_etheraddr(const struct netdev *netdev_,
uint8_t mac[ETH_ADDR_LEN])
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
char buffer[DLADM_PROP_VAL_MAX];
int error = 0;
VLOG_DBG("netdev_solaris_get_etheraddr device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
/*
* Only the bridge ethernet address can be changed outside the
* knowledge of vswitchd (when the uplink is added and the bridge
* VNIC is moved to the uplink).
*/
if ((netdev->cache_valid & VALID_ETHERADDR) &&
(netdev->up.netdev_class != &netdev_internal_class)) {
memcpy(mac, netdev->etheraddr, ETH_ADDR_LEN);
goto exit;
}
/*
* MAC addresses are datalink properties.
*/
error = solaris_get_dlprop(netdev_name, "mac-address", "current",
buffer, sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve etheraddr for %s device",
netdev_name);
goto exit;
}
if (!eth_addr_from_string(buffer, mac)) {
VLOG_ERR("Invalid etheraddr for %s device", netdev_name);
error = EINVAL;
goto exit;
}
memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
netdev->cache_valid |= VALID_ETHERADDR;
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_get_mtu__(struct netdev_solaris *netdev, int *mtup,
const char *netdev_name)
{
char buffer[DLADM_PROP_VAL_MAX];
int mtu;
int error = 0;
if (netdev->cache_valid & VALID_MTU) {
*mtup = netdev->mtu;
return (0);
}
/*
* MTU is a datalink property
*/
error = solaris_get_dlprop(netdev_name, "mtu", "current", buffer,
sizeof (buffer));
if (error != 0) {
VLOG_ERR("Unable to retrieve mtu for %s device",
netdev_name);
return (error);
}
mtu = atoi(buffer);
if (mtu == 0) {
VLOG_ERR("Invalid mtu for %s device", netdev_name);
error = EINVAL;
return (error);
}
netdev->mtu = *mtup = mtu;
netdev->cache_valid |= VALID_MTU;
return (0);
}
/*
* Returns the maximum size of transmitted (and received) packets on 'netdev',
* in bytes, not including the hardware header; thus, this is typically 1500
* bytes for Ethernet devices.
*/
static int
netdev_solaris_get_mtu(const struct netdev *netdev_, int *mtup)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_get_mtu device %s", netdev_name);
if (!netdev_) {
VLOG_DBG("netdev_solaris_get_mtu null netdevs");
return (error);
}
ovs_mutex_lock(&netdev->mutex);
error = netdev_solaris_get_mtu__(netdev, mtup, netdev_name);
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
/*
* Sets the maximum size of transmitted (MTU) for given device.
*/
static int
netdev_solaris_set_mtu(const struct netdev *netdev_ OVS_UNUSED, int mtu)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
uint64_t ulval = mtu;
int error = 0;
VLOG_DBG("netdev_solaris_set_mtu device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if ((netdev->cache_valid & VALID_MTU && netdev->mtu == mtu))
goto exit;
/*
* In case there is some kind of failure, invalidate
* the cached value.
*/
netdev->cache_valid &= ~VALID_MTU;
/*
* MTU is a datalink property.
*/
error = solaris_set_dlprop_ulong(netdev_name, "mtu", &ulval, B_TRUE);
if (error != 0) {
VLOG_ERR("set mtu on %s device failed: %s",
netdev_name, ovs_strerror(error));
goto exit;
}
netdev->mtu = mtu;
netdev->cache_valid |= VALID_MTU;
netdev_change_seq_changed(netdev_);
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
/*
* Returns the ifindex of 'netdev', if successful, as a positive number.
* On failure, returns a negative errno.
*/
static int
netdev_solaris_get_ifindex(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int ifindex;
int error = 0;
VLOG_DBG("netdev_solaris_get_ifindex device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if (netdev->cache_valid & VALID_IFINDEX) {
ifindex = netdev->ifindex;
goto exit;
}
ifindex = (int)if_nametoindex(netdev_name);
if (ifindex <= 0) {
error = errno;
goto exit;
}
netdev->ifindex = ifindex;
netdev->cache_valid |= VALID_IFINDEX;
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error ? -error : ifindex);
}
/*
* Retrieves current device stats for 'netdev-solaris'.
*/
static int
netdev_solaris_get_stats(const struct netdev *netdev_,
struct netdev_stats *stats)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
kstat2_status_t stat;
kstat2_map_t map;
char kuri[1024];
char devname[DLADM_PROP_VAL_MAX];
char modname[DLADM_PROP_VAL_MAX];
char kstat_name[MAXLINKNAMELEN];
char *name;
zoneid_t zid;
uint_t instance;
int error = 0;
boolean_t is_uplink;
VLOG_DBG("netdev_solaris_get_stats device %s", netdev_name);
is_uplink = netdev_solaris_is_uplink(netdev_);
/*
* Initialize statistics only supported on uplink.
*/
stats->rx_length_errors = 0;
stats->rx_missed_errors = 0;
stats->rx_over_errors = 0;
/*
* Unsupported on Solaris.
*/
stats->rx_crc_errors = UINT64_MAX;
stats->rx_frame_errors = UINT64_MAX;
stats->rx_fifo_errors = UINT64_MAX;
stats->tx_aborted_errors = UINT64_MAX;
stats->tx_carrier_errors = UINT64_MAX;
stats->tx_fifo_errors = UINT64_MAX;
stats->tx_heartbeat_errors = UINT64_MAX;
stats->tx_window_errors = UINT64_MAX;
ovs_mutex_lock(&kstat_mutex);
if (!kstat2_handle_initialized) {
VLOG_DBG("netdev_solaris_get_stats initializing handle");
if (!kstat_handle_init(&nd_khandle)) {
error = -1;
goto done;
}
kstat2_handle_initialized = B_TRUE;
} else if (!kstat_handle_update(nd_khandle)) {
VLOG_DBG("netdev_solaris_get_stats error updating stats");
kstat_handle_close(&nd_khandle);
kstat2_handle_initialized = B_FALSE;
error = -1;
goto done;
}
name = (char *)netdev_name;
instance = 0;
if (strchr(netdev_name, '/') != NULL) {
(void) solaris_dlparse_zonelinkname(netdev_name, kstat_name,
&zid);
name = kstat_name;
instance = zid;
}
(void) snprintf(kuri, sizeof (kuri), "kstat:/net/link/%s/%d",
name, instance);
stat = kstat2_lookup_map(nd_khandle, kuri, &map);
if (stat != KSTAT2_S_OK) {
VLOG_WARN("kstat2_lookup_map of %s failed: %s", kuri,
kstat2_status_string(stat));
} else {
if (is_uplink) {
stats->rx_packets = get_nvvt_int(map, "ipackets64");
stats->tx_packets = get_nvvt_int(map, "opackets64");
stats->rx_bytes = get_nvvt_int(map, "rbytes");
stats->tx_bytes = get_nvvt_int(map, "obytes");
stats->rx_errors = get_nvvt_int(map, "ierrors");
stats->tx_errors = get_nvvt_int(map, "oerrors");
} else {
stats->tx_packets = get_nvvt_int(map, "ipackets64");
stats->rx_packets = get_nvvt_int(map, "opackets64");
stats->tx_bytes = get_nvvt_int(map, "rbytes");
stats->rx_bytes = get_nvvt_int(map, "obytes");
stats->tx_errors = get_nvvt_int(map, "ierrors");
stats->rx_errors = get_nvvt_int(map, "oerrors");
}
stats->collisions = get_nvvt_int(map, "collisions");
stats->multicast = get_nvvt_int(map, "multircv") +
get_nvvt_int(map, "multixmt");
}
(void) snprintf(kuri, sizeof (kuri), "kstat:/net/%s/link/%d",
name, instance);
stat = kstat2_lookup_map(nd_khandle, kuri, &map);
if (stat != KSTAT2_S_OK) {
VLOG_WARN("kstat2_lookup_map of %s failed: %s", kuri,
kstat2_status_string(stat));
} else {
if (is_uplink) {
stats->rx_dropped = get_nvvt_int(map, "idrops");
stats->tx_dropped = get_nvvt_int(map, "odrops");
} else {
stats->tx_dropped = get_nvvt_int(map, "idrops");
stats->rx_dropped = get_nvvt_int(map, "odrops");
}
}
if (!is_uplink)
goto done;
/*
* Can we do anything for aggr?
*/
if (strcmp("phys", netdev->class) != 0)
goto done;
if (solaris_get_devname(netdev_name, devname, sizeof (devname)) != 0) {
VLOG_WARN("Failed to retrieve devname of uplink\n");
error = -1;
goto done;
}
if (!dlparse_drvppa(devname, modname, sizeof (modname),
&instance)) {
VLOG_DBG("netdev_solaris_get_stats error getting "
"mod/instance for %s\n", devname);
error = -1;
goto done;
}
(void) snprintf(kuri, sizeof (kuri), "kstat:/net/%s/statistics/%d",
modname, instance);
stat = kstat2_lookup_map(nd_khandle, kuri, &map);
if (stat != KSTAT2_S_OK) {
VLOG_WARN("kstat2_lookup_map of %s failed: %s", kuri,
kstat2_status_string(stat));
error = -1;
goto done;
}
stats->rx_length_errors = get_nvvt_int(map, "Recv_Length_Errors");
stats->rx_missed_errors = get_nvvt_int(map, "Recv_Missed_Packets");
stats->rx_over_errors = get_nvvt_int(map, "Recv_Oversize");
done:
ovs_mutex_unlock(&kstat_mutex);
return (error);
}
/*
* Stores the features supported by 'netdev' into of '*current', '*advertised',
* '*supported', and '*peer'. Each value is a bitmap of NETDEV_* bits.
* Returns 0 if successful, otherwise a positive errno value.
*/
static int
netdev_solaris_get_features(const struct netdev *netdev_,
enum netdev_features *current,
enum netdev_features *advertised,
enum netdev_features *supported,
enum netdev_features *peer)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
const char *physname;
char buffer[DLADM_PROP_VAL_MAX];
int error = 0;
VLOG_DBG("netdev_solaris_get_features device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if (netdev_solaris_is_uplink(netdev_)) {
physname = netdev_name;
} else {
error = solaris_get_dllower(netdev_name, buffer,
sizeof (buffer));
if (error != 0)
goto exit;
physname = buffer;
}
error = netdev_solaris_read_features(netdev, physname);
if (error != 0)
goto exit;
*current = netdev->current;
*advertised = netdev->advertised;
*supported = netdev->supported;
*peer = 0;
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
/*
* Attempts to set input rate limiting (policing) policy. Returns 0 if
* successful, otherwise a positive errno value.
*/
static int
netdev_solaris_set_policing(struct netdev *netdev_,
uint32_t kbits_rate, uint32_t kbits_burst OVS_UNUSED)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
uint64_t rate;
ovs_mutex_lock(&netdev->mutex);
if (netdev->kbits_rate == kbits_rate)
goto out;
VLOG_DBG("netdev_solaris_set_policing setting "
"ingress_policing_rate %d kbps on device %s",
kbits_rate, netdev_name);
rate = kbits_rate * 1000;
if ((error = solaris_set_dlprop_ulong(netdev_name, "max-bw",
kbits_rate == 0 ? NULL : &rate, B_TRUE)) != 0) {
VLOG_ERR("set ingress_policing_rate "
"%d kbps on %s failed: %s",
kbits_rate, netdev_name, ovs_strerror(error));
goto out;
}
netdev->kbits_rate = kbits_rate;
out:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_get_qos_types(const struct netdev *netdev_,
struct sset *types)
{
const char *netdev_name = netdev_get_name(netdev_);
const struct tc_ops *const *opsp;
VLOG_DBG("netdev_solaris_get_qos_types device %s", netdev_name);
/*
* XXXSolaris we will support only HTB-equivalent which will translate
* to maxbw/priority.
*/
for (opsp = tcs; *opsp != NULL; opsp++) {
const struct tc_ops *ops = *opsp;
if (ops->tc_install && ops->ovs_name[0] != '\0')
sset_add(types, ops->ovs_name);
}
return (0);
}
static int
netdev_solaris_get_qos_capabilities(const struct netdev *netdev_,
const char *type, struct netdev_qos_capabilities *caps)
{
const char *netdev_name = netdev_get_name(netdev_);
int error = EOPNOTSUPP;
const struct tc_ops *ops = tc_lookup_ovs_name(type);
VLOG_DBG("netdev_solaris_get_qos_capabilities device %s",
netdev_name);
if (!ops)
return (EOPNOTSUPP);
/*
* Arbit number for now. In theory we are not limited for bandwidth
* limit. But, with shares and priority this can be revisited.
*/
caps->n_queues = ops->n_queues;
return (error);
}
static int
netdev_solaris_get_qos(const struct netdev *netdev_,
const char **typep, struct smap *details)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_get_qos device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
*typep = netdev->tc->ops->ovs_name;
error = (netdev->tc->ops->qdisc_get ?
netdev->tc->ops->qdisc_get(netdev_, details) : 0);
}
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_set_qos(struct netdev *netdev_,
const char *type, const struct smap *details)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
const struct tc_ops *new_ops;
int error = 0;
VLOG_DBG("netdev_solaris_set_qos device %s", netdev_name);
new_ops = tc_lookup_ovs_name(type);
if (!new_ops) {
VLOG_DBG("netdev_solaris_set_qos type %s not found", type);
return (EOPNOTSUPP);
}
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (error) {
VLOG_DBG("netdev_solaris_set_qos qdisc querry failed");
goto exit;
}
if (new_ops == netdev->tc->ops) {
error = new_ops->qdisc_set ?
new_ops->qdisc_set(netdev_, details) :
0;
} else {
error = tc_del_qdisc(netdev_);
if (error) {
VLOG_DBG("netdev_solaris_set_qos error deleting %s",
type);
goto exit;
}
ovs_assert(netdev->tc == NULL);
/* Install new qdisc. */
error = new_ops->tc_install(netdev_, details);
ovs_assert((error == 0) == (netdev->tc != NULL));
VLOG_DBG("netdev_solaris_set_qos installed %s, %d", type,
error);
}
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_get_queue(const struct netdev *netdev_,
unsigned int queue_id, struct smap *details)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_get_queue device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
error = (queue ?
netdev->tc->ops->class_get(netdev_, queue, details) :
ENOENT);
}
ovs_mutex_unlock(&netdev->mutex);
VLOG_DBG("netdev_solaris_get_queue device %s done %d", netdev_name,
error);
return (error);
}
static int
netdev_solaris_set_queue(struct netdev *netdev_,
unsigned int queue_id, const struct smap *details)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_set_queue device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
error = (queue_id < netdev->tc->ops->n_queues &&
netdev->tc->ops->class_set ?
netdev->tc->ops->class_set(netdev_, queue_id, details) :
EINVAL);
} else {
VLOG_DBG("netdev_solaris_set_queue %s: no qdisc", netdev_name);
}
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_delete_queue(struct netdev *netdev_,
unsigned int queue_id)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_delete_queue device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
if (netdev->tc->ops->class_delete) {
struct tc_queue *queue =
tc_find_queue(netdev_, queue_id);
error = (queue
? netdev->tc->ops->class_delete(netdev_, queue)
: ENOENT);
} else {
error = EINVAL;
}
}
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_get_queue_stats(const struct netdev *netdev_,
unsigned int queue_id OVS_UNUSED,
struct netdev_queue_stats *stats OVS_UNUSED)
{
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_set_queue_stats device %s", netdev_name);
return (error);
}
struct netdev_solaris_queue_state {
unsigned int *queues;
size_t cur_queue;
size_t n_queues;
};
static int
netdev_solaris_queue_dump_start(const struct netdev *netdev_,
void **statep)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_queue_dump_start device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
if (netdev->tc->ops->class_get) {
struct netdev_solaris_queue_state *state;
struct tc_queue *queue;
size_t i;
*statep = state = xmalloc(sizeof (*state));
state->n_queues = hmap_count(&netdev->tc->queues);
state->cur_queue = 0;
state->queues =
xmalloc(state->n_queues * sizeof (*state->queues));
i = 0;
HMAP_FOR_EACH(queue, hmap_node, &netdev->tc->queues) {
state->queues[i++] = queue->queue_id;
}
} else {
error = EOPNOTSUPP;
}
} else {
VLOG_DBG("netdev_solaris_queue_dump_start: no qdisc");
}
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_queue_dump_next(const struct netdev *netdev_,
void *state_, unsigned int *queue_idp, struct smap *details)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
int error = EOF;
struct netdev_solaris_queue_state *state = state_;
if (!state) {
VLOG_DBG("netdev_solaris_queue_dump_next %s: null state\n",
netdev_name);
return (EOF);
}
VLOG_DBG("netdev_solaris_queue_dump_next device %s, %"PRIuSIZE
", %"PRIuSIZE, netdev_name, state->cur_queue, state->n_queues);
ovs_mutex_lock(&netdev->mutex);
while (state->cur_queue < state->n_queues) {
unsigned int queue_id = state->queues[state->cur_queue++];
struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
if (queue) {
*queue_idp = queue_id;
if (!netdev->tc || !netdev->tc->ops ||
!netdev->tc->ops->class_get) {
break;
}
error = netdev->tc->ops->class_get(netdev_, queue,
details);
break;
}
}
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_queue_dump_done(const struct netdev *netdev_,
void *state_)
{
const char *netdev_name = netdev_get_name(netdev_);
struct netdev_solaris_queue_state *state = state_;
VLOG_DBG("netdev_solaris_queue_dump_done device %s", netdev_name);
if (state) {
if (state->queues)
free(state->queues);
free(state);
}
return (0);
}
static int
netdev_solaris_dump_queue_stats(const struct netdev *netdev_,
netdev_dump_queue_stats_cb *cb OVS_UNUSED, void *aux OVS_UNUSED)
{
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
VLOG_DBG("netdev_solaris_queue_dump_stats device %s", netdev_name);
return (error);
}
/*
* If 'netdev' has an assigned IPv4 address, sets '*address' to that
* address and '*netmask' to the associated netmask. Otherwise, returns
* errno.
*/
static int
netdev_solaris_get_in4(const struct netdev *netdev_,
struct in_addr *address, struct in_addr *netmask)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
struct lifreq lifr;
const struct sockaddr_in *sin;
int error = 0;
VLOG_DBG("netdev_solaris_get_in4 device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if (netdev->cache_valid & VALID_IN4) {
*address = netdev->in4;
*netmask = netdev->netmask;
goto exit;
}
error = netdev_solaris_plumb(netdev_, AF_INET);
if (error != 0)
goto exit;
/*
* In the future, a RAD IP module might be a good provider
* of this information. For now, use the SIOCGLIFADDR.
*/
bzero(&lifr, sizeof (lifr));
(void) strncpy(lifr.lifr_name, netdev_name, sizeof (lifr.lifr_name));
sin = ALIGNED_CAST(struct sockaddr_in *, &lifr.lifr_addr);
if (ioctl(sock4, SIOCGLIFADDR, &lifr) < 0) {
error = errno;
goto exit;
}
netdev->in4 = sin->sin_addr;
if (ioctl(sock4, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0) {
error = errno;
goto exit;
}
netdev->netmask = sin->sin_addr;
netdev->cache_valid |= VALID_IN4;
if (netdev->in4.s_addr != INADDR_ANY) {
*address = netdev->in4;
*netmask = netdev->netmask;
} else {
error = EADDRNOTAVAIL;
}
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
static int
netdev_solaris_set_in4(struct netdev *netdev_, struct in_addr address,
struct in_addr netmask)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
struct lifreq lifr;
struct sockaddr_in *sin;
int error = 0;
VLOG_DBG("netdev_solaris_set_in4 device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
error = netdev_solaris_plumb(netdev_, AF_INET);
if (error != 0)
goto exit;
/*
* In the future, a RAD IP module might be a good provider
* of this information. For now, use the SIOCSLIFADDR.
*/
bzero(&lifr, sizeof (lifr));
(void) strncpy(lifr.lifr_name, netdev_name, sizeof (lifr.lifr_name));
sin = ALIGNED_CAST(struct sockaddr_in *, &lifr.lifr_addr);
sin->sin_addr = address;
sin->sin_family = AF_INET;
if (ioctl(sock4, SIOCSLIFADDR, &lifr) < 0) {
error = errno;
goto exit;
}
if (address.s_addr == htonl(INADDR_ANY))
goto done;
sin->sin_addr = netmask;
if (ioctl(sock4, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0) {
error = errno;
goto done;
}
netdev->in4 = address;
netdev->netmask = netmask;
netdev->cache_valid |= VALID_IN4;
done:
netdev_change_seq_changed(netdev_);
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
/*
* If 'netdev' has an assigned IPv6 address, sets '*address' to that
* address. Otherwise, returns errno.
*/
static int
netdev_solaris_get_in6(const struct netdev *netdev_, struct in6_addr *address)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
struct lifreq lifr;
const struct sockaddr_in6 *sin6;
int error = 0;
VLOG_DBG("netdev_solaris_get_in6 device %s", netdev_name);
ovs_mutex_lock(&netdev->mutex);
if (netdev->cache_valid & VALID_IN6) {
if (!IN6_IS_ADDR_UNSPECIFIED(address))
*address = netdev->in6;
else
error = EADDRNOTAVAIL;
goto exit;
}
error = netdev_solaris_plumb(netdev_, AF_INET6);
if (error != 0)
goto exit;
/*
* In the future, a RAD IP module might be a good provider
* of this information. For now, use the SIOCGLIFADDR.
*/
bzero(&lifr, sizeof (lifr));
(void) strncpy(lifr.lifr_name, netdev_name, sizeof (lifr.lifr_name));
if (ioctl(sock6, SIOCGLIFADDR, &lifr) < 0) {
error = errno;
goto exit;
}
sin6 = ALIGNED_CAST(struct sockaddr_in6 *, &lifr.lifr_addr);
netdev->in6 = sin6->sin6_addr;
netdev->cache_valid |= VALID_IN6;
if (!IN6_IS_ADDR_UNSPECIFIED(address))
*address = netdev->in6;
else
error = EADDRNOTAVAIL;
exit:
ovs_mutex_unlock(&netdev->mutex);
return (error);
}
#define ROUNDUP_LONG(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof (long) - 1))) : \
sizeof (long))
#define RT_ADVANCE(x, n) ((x) += ROUNDUP_LONG(salen(n)))
#define BUF_SIZE 2048
typedef struct rtmsg {
struct rt_msghdr m_rtm;
char m_space[BUF_SIZE];
} rtmsg_t;
static int
salen(const struct sockaddr *sa)
{
switch (sa->sa_family) {
case AF_INET:
return (sizeof (struct sockaddr_in));
case AF_LINK:
return (sizeof (struct sockaddr_dl));
case AF_INET6:
return (sizeof (struct sockaddr_in6));
default:
return (sizeof (struct sockaddr));
}
}
/*
* Adds 'router' as a default IP gateway.
*/
static int
netdev_solaris_add_router(struct netdev *netdev_, struct in_addr router)
{
const char *netdev_name = netdev_get_name(netdev_);
rtmsg_t m_rtmsg;
struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
char *cp = m_rtmsg.m_space;
struct sockaddr_in gateway;
struct sockaddr_in dest;
struct sockaddr_in mask;
int rtsock_fd;
int error = 0;
int l;
VLOG_DBG("netdev_solaris_add_router %s", netdev_name);
rtsock_fd = socket(PF_ROUTE, SOCK_RAW, 0);
if (rtsock_fd == -1) {
error = errno;
VLOG_ERR("failed to create PF_ROUTE socket (%s)",
ovs_strerror(error));
return (error);
}
memset(&gateway, 0, sizeof (gateway));
gateway.sin_family = AF_INET;
gateway.sin_addr = router;
memset(&dest, 0, sizeof (dest));
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = htonl(INADDR_ANY);
memset(&dest, 0, sizeof (mask));
mask.sin_family = AF_INET;
mask.sin_addr.s_addr = htonl(INADDR_ANY);
(void) memset(&m_rtmsg, 0, sizeof (m_rtmsg));
rtm->rtm_version = RTM_VERSION;
rtm->rtm_type = RTM_ADD;
rtm->rtm_flags = RTF_GATEWAY | RTF_STATIC | RTF_UP;
rtm->rtm_addrs = RTA_GATEWAY | RTA_DST | RTA_NETMASK;
l = ROUNDUP_LONG(sizeof (struct sockaddr_in));
(void) memcpy(cp, &dest, l);
cp += l;
(void) memcpy(cp, &gateway, l);
cp += l;
(void) memcpy(cp, &mask, l);
cp += l;
rtm->rtm_msglen = l = cp - (char *)&m_rtmsg;
if (write(rtsock_fd, (char *)&m_rtmsg, l) != l) {
char buffer[INET_ADDRSTRLEN];
(void) inet_ntop(AF_INET, &router, buffer, sizeof (buffer));
error = errno;
VLOG_ERR("failed to add router %s: %s", buffer,
ovs_strerror(error));
}
close(rtsock_fd);
return (error);
}
/*
* Looks up the next hop for 'host' in the host's routing table. If
* successful, stores the next hop gateway's address (0 if 'host' is on a
* directly connected network) in '*next_hop' and a copy of the name of the
* device to reach 'host' in '*netdev_name', and returns 0. The caller is
* responsible for freeing '*netdev_name' (by calling free()).
*/
static int
netdev_solaris_get_next_hop(const struct in_addr *host,
struct in_addr *next_hop, char **netdev_name)
{
rtmsg_t m_rtmsg;
struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
char *cp = m_rtmsg.m_space;
int rtsock_fd;
struct sockaddr_in sin;
struct sockaddr_dl sdl;
const pid_t pid = getpid();
static int seq;
boolean_t gateway = B_FALSE;
ssize_t ssz;
char *ifname = NULL;
int saved_errno;
int error = 0;
int rlen;
int l;
int i;
memset(&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = 0;
sin.sin_addr = *host;
memset(&sdl, 0, sizeof (sdl));
sdl.sdl_family = AF_LINK;
rtsock_fd = socket(PF_ROUTE, SOCK_RAW, 0);
if (rtsock_fd == -1) {
error = errno;
VLOG_ERR("failed to create PF_ROUTE socket (%s)",
ovs_strerror(error));
return (error);
}
(void) memset(&m_rtmsg, 0, sizeof (m_rtmsg));
rtm->rtm_type = RTM_GET;
rtm->rtm_flags = RTF_HOST|RTF_UP;
rtm->rtm_version = RTM_VERSION;
rtm->rtm_seq = ++seq;
rtm->rtm_addrs = RTA_DST|RTA_IFP;
l = ROUNDUP_LONG(sizeof (struct sockaddr_in));
(void) memcpy(cp, &sin, l);
cp += l;
l = ROUNDUP_LONG(sizeof (struct sockaddr_dl));
(void) memcpy(cp, &sdl, l);
cp += l;
rtm->rtm_msglen = l = cp - (char *)&m_rtmsg;
if ((rlen = write(rtsock_fd, (char *)&m_rtmsg, l)) < l) {
error = errno;
VLOG_ERR("failed to get route: %s", ovs_strerror(error));
close(rtsock_fd);
return (errno);
}
memset(next_hop, 0, sizeof (*next_hop));
*netdev_name = NULL;
memset(&m_rtmsg, 0, sizeof (m_rtmsg));
do {
ssz = read(rtsock_fd, &m_rtmsg, sizeof (m_rtmsg));
} while (ssz > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
saved_errno = errno;
close(rtsock_fd);
if (ssz <= 0) {
if (ssz < 0) {
return (saved_errno);
}
return (EPIPE);
}
cp = (void *)&m_rtmsg.m_space;
for (i = 1; i; i <<= 1) {
if ((rtm->rtm_addrs & i) != 0) {
const struct sockaddr *sa = (const void *)cp;
if ((i == RTA_GATEWAY) && sa->sa_family == AF_INET) {
const struct sockaddr_in * const sin =
ALIGNED_CAST(const struct sockaddr_in *,
sa);
*next_hop = sin->sin_addr;
gateway = B_TRUE;
}
if ((i == RTA_IFP) && sa->sa_family == AF_LINK) {
const struct sockaddr_dl * const sdl =
ALIGNED_CAST(const struct sockaddr_dl *,
sa);
ifname = xmemdup0(sdl->sdl_data,
sdl->sdl_nlen);
}
RT_ADVANCE(cp, sa);
}
}
if (ifname == NULL) {
return (ENXIO);
}
if (!gateway) {
*next_hop = *host;
}
*netdev_name = ifname;
VLOG_DBG("host " IP_FMT " next-hop " IP_FMT " if %s\n",
IP_ARGS(host->s_addr), IP_ARGS(next_hop->s_addr), *netdev_name);
return (0);
}
static int
netdev_solaris_get_status(const struct netdev *netdev_,
struct smap *smap OVS_UNUSED)
{
const char *netdev_name = netdev_get_name(netdev_);
int error = EOPNOTSUPP;
VLOG_DBG("netdev_solaris_get_status %s", netdev_name);
/*
* It looks like this is used to populate a column,
* OVSREC_INTERFACE_COL_STATUS in the OVSDB. It doesn't appear
* to be required though. If we wanted to return the driver name
* then we could return that using libdladm.
*/
return (error);
}
/*
* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
* successfully retrieved, it stores the corresponding MAC address in 'mac' and
* returns 0. Otherwise, it returns a positive errno value; in particular,
* ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'.
*/
static int
netdev_solaris_arp_lookup(const struct netdev *netdev_,
ovs_be32 ip OVS_UNUSED, uint8_t mac[ETH_ADDR_LEN] OVS_UNUSED)
{
const char *netdev_name = netdev_get_name(netdev_);
int error = 0;
struct xarpreq ar;
struct sockaddr_in *sin;
VLOG_DBG("netdev_solaris_arp_lookup %s", netdev_name);
bzero(&ar, sizeof (ar));
sin = ALIGNED_CAST(struct sockaddr_in *, &ar.xarp_pa);
sin->sin_addr.s_addr = ip;
sin->sin_family = AF_INET;
ar.xarp_ha.sdl_family = AF_LINK;
if (ioctl(sock4, SIOCGXARP, &ar) < 0) {
error = errno;
goto out;
}
if (!(ar.xarp_flags & ATF_COM)) {
errno = EOPNOTSUPP; /* XXX */
goto out;
}
memcpy(mac, LLADDR(&ar.xarp_ha), ETH_ADDR_LEN);
out:
return (error);
}
static int
lifr_to_nd_flags(int64_t lifrflags)
{
enum netdev_flags nd_flags = 0;
if (lifrflags & IFF_UP) {
nd_flags |= NETDEV_UP;
}
if (lifrflags & IFF_PROMISC) {
nd_flags |= NETDEV_PROMISC;
}
if (lifrflags & IFF_LOOPBACK) {
nd_flags |= NETDEV_LOOPBACK;
}
return (nd_flags);
}
static int64_t
nd_to_lifr_flags(enum netdev_flags nd_flags)
{
int64_t lifrflags = 0;
if (nd_flags & NETDEV_UP) {
lifrflags |= IFF_UP;
}
if (nd_flags & NETDEV_PROMISC) {
lifrflags |= IFF_PROMISC;
}
if (nd_flags & NETDEV_LOOPBACK) {
lifrflags |= IFF_LOOPBACK;
}
return (lifrflags);
}
/*
* Retrieves the current set of flags on 'netdev' into '*old_flags'. Then,
* turns off the flags that are set to 1 in 'off' and turns on the flags
* that are set to 1 in 'on'. (No bit will be set to 1 in both 'off' and
* 'on'; that is, off & on == 0.)
*/
static int
netdev_solaris_update_flags(struct netdev *netdev_, enum netdev_flags off,
enum netdev_flags on, enum netdev_flags *old_flagsp)
{
const char *netdev_name = netdev_get_name(netdev_);
struct lifreq lifr;
int64_t old_lifr_flags;
int64_t new_lifr_flags;
int error = 0;
VLOG_DBG("netdev_solaris_update_flags %s", netdev_name);
bzero(&lifr, sizeof (lifr));
(void) strncpy(lifr.lifr_name, netdev_name, sizeof (lifr.lifr_name));
if (ioctl(sock4, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
error = errno;
goto exit;
}
old_lifr_flags = lifr.lifr_flags;
*old_flagsp = lifr_to_nd_flags(old_lifr_flags);
new_lifr_flags = (old_lifr_flags & ~nd_to_lifr_flags(off)) |
nd_to_lifr_flags(on);
if (new_lifr_flags == old_lifr_flags)
goto exit;
lifr.lifr_flags = new_lifr_flags;
if (ioctl(sock4, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) {
error = errno;
goto exit;
}
netdev_change_seq_changed(netdev_);
exit:
return (error);
}
static int
netdev_internal_get_status(const struct netdev *netdev OVS_UNUSED,
struct smap *smap)
{
smap_add(smap, "driver_name", "openvswitch");
return (0);
}
#define NETDEV_SOLARIS_CLASS(NAME, CONSTRUCT, GET_STATS, SET_STATS, \
GET_FEATURES, GET_STATUS) \
{ \
NAME, \
netdev_solaris_init, \
netdev_solaris_run, \
netdev_solaris_wait, \
netdev_solaris_alloc, \
CONSTRUCT, \
netdev_solaris_destruct, \
netdev_solaris_dealloc, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
netdev_solaris_set_etheraddr, \
netdev_solaris_get_etheraddr, \
netdev_solaris_get_mtu, \
netdev_solaris_set_mtu, \
netdev_solaris_get_ifindex, \
NULL, \
NULL, \
NULL, \
GET_STATS, \
SET_STATS, \
GET_FEATURES, \
NULL, \
netdev_solaris_set_policing, \
netdev_solaris_get_qos_types, \
netdev_solaris_get_qos_capabilities, \
netdev_solaris_get_qos, \
netdev_solaris_set_qos, \
netdev_solaris_get_queue, \
netdev_solaris_set_queue, \
netdev_solaris_delete_queue, \
netdev_solaris_get_queue_stats, \
netdev_solaris_queue_dump_start, \
netdev_solaris_queue_dump_next, \
netdev_solaris_queue_dump_done, \
netdev_solaris_dump_queue_stats, \
netdev_solaris_get_in4, \
netdev_solaris_set_in4, \
netdev_solaris_get_in6, \
netdev_solaris_add_router, \
netdev_solaris_get_next_hop, \
GET_STATUS, \
netdev_solaris_arp_lookup, \
netdev_solaris_update_flags, \
netdev_solaris_configure_uplink, \
netdev_solaris_is_uplink, \
netdev_solaris_add_port_to_bridge_mapping, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL \
}
const struct netdev_class netdev_solaris_class =
NETDEV_SOLARIS_CLASS(
"system",
netdev_solaris_construct,
netdev_solaris_get_stats,
NULL, /* set_stats */
netdev_solaris_get_features,
netdev_solaris_get_status);
const struct netdev_class netdev_internal_class =
NETDEV_SOLARIS_CLASS(
"internal",
netdev_solaris_construct,
netdev_solaris_get_stats,
NULL, /* set_stats */
NULL, /* get_features */
netdev_internal_get_status);
/* Solaris HTB traffic control class */
#define HTB_N_QUEUES 0xf000
struct htb {
struct tc tc;
unsigned int max_rate; /* In bytes/s. */
};
struct htb_class {
struct tc_queue tc_queue;
unsigned int min_rate; /* In bytes/s */
unsigned int max_rate; /* In bytes/s */
unsigned int burst; /* In bytes/s -- unused */
unsigned int priority; /* Lower value is higher priority */
};
/*
* Create an HTB qdisc.
*
* Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1".
*/
static int
htb_setup_qdisc__(struct netdev *netdev)
{
VLOG_DBG("htb_setup_qdisc__ device %s", netdev->name);
tc_del_qdisc(netdev);
return (0);
}
static struct htb *
htb_get__(const struct netdev *netdev_)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
VLOG_DBG("htb_get__ device %s", netdev_name);
return (CONTAINER_OF(netdev->tc, struct htb, tc));
}
static void
htb_install__(struct netdev *netdev_, uint64_t max_rate)
{
const char *netdev_name = netdev_get_name(netdev_);
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
struct htb *htb;
VLOG_DBG("htb_install__ device %s", netdev_name);
htb = xmalloc(sizeof (*htb));
tc_init(&htb->tc, &tc_ops_htb);
htb->max_rate = max_rate;
netdev->tc = &htb->tc;
VLOG_DBG("htb_install__ device %s TC configured ", netdev_name);
}
static int
htb_setup_class__(struct netdev *netdev, unsigned int handle OVS_UNUSED,
unsigned int parent OVS_UNUSED,
struct htb_class *class OVS_UNUSED)
{
VLOG_DBG("htb_setup_class__ device %s", netdev->name);
return (0);
}
static void
htb_parse_qdisc_details__(struct netdev *netdev_,
const struct smap *details, struct htb_class *hc)
{
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
const char *netdev_name = netdev_get_name(netdev_);
const char *max_rate_s;
const char *physname;
char buffer[DLADM_PROP_VAL_MAX];
int error = 0;
VLOG_DBG("htb_parse_qdisc_details__ device %s", netdev_name);
/*
* Initialize in case of early return.
*/
hc->max_rate = 0;
hc->min_rate = 0;
hc->burst = 0;
hc->priority = 0;
if (netdev_solaris_is_uplink(netdev_)) {
physname = netdev_name;
} else {
error = solaris_get_dllower(netdev_name, buffer,
sizeof (buffer));
if (error != 0)
return;
physname = buffer;
}
max_rate_s = smap_get(details, "max-rate");
hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
if (!hc->max_rate) {
enum netdev_features current;
netdev_solaris_read_features(netdev, physname);
current = !netdev->get_features_error ? netdev->current : 0;
hc->max_rate = netdev_features_to_bps(current,
100 * 1000 * 1000) / 8;
}
}
static int
htb_tc_install(struct netdev *netdev, const struct smap *details)
{
int error;
VLOG_DBG("htb_tc_install device %s", netdev->name);
error = htb_setup_qdisc__(netdev);
if (!error) {
struct htb_class hc;
htb_parse_qdisc_details__(netdev, details, &hc);
error = htb_setup_class__(netdev, 0, 0, &hc);
if (!error) {
htb_install__(netdev, hc.max_rate);
}
}
return (error);
}
static void
htb_tc_destroy(struct tc *tc)
{
struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
struct htb_class *hc, *next;
HMAP_FOR_EACH_SAFE(hc, next, tc_queue.hmap_node, &htb->tc.queues) {
hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
free(hc);
}
tc_destroy(tc);
free(htb);
}
static int
htb_qdisc_get(const struct netdev *netdev, struct smap *details)
{
const struct htb *htb = htb_get__(netdev);
VLOG_DBG("htb_qdisc_get device %s", netdev->name);
smap_add_format(details, "max-rate", "%llu", 8ULL * htb->max_rate);
return (0);
}
static int
htb_qdisc_set(struct netdev *netdev, const struct smap *details)
{
struct htb_class hc;
int error;
VLOG_DBG("htb_qdisc_set device %s", netdev->name);
htb_parse_qdisc_details__(netdev, details, &hc);
/* Solaris: don't care about the handles */
error = htb_setup_class__(netdev, 0, 0, &hc);
if (!error) {
htb_get__(netdev)->max_rate = hc.max_rate;
}
return (error);
}
static struct htb_class *
htb_class_cast__(const struct tc_queue *queue)
{
return (CONTAINER_OF(queue, struct htb_class, tc_queue));
}
static int
htb_class_get(const struct netdev *netdev,
const struct tc_queue *queue, struct smap *details)
{
const struct htb_class *hc = htb_class_cast__(queue);
VLOG_DBG("htb_class_get device %s", netdev->name);
if (hc->max_rate > 0)
smap_add_format(details, "max-rate", "%llu",
8ULL * hc->max_rate);
VLOG_DBG("htb_class_get device done");
return (0);
}
/* Solaris: currently, min-rate, burst and priority are not supported */
static int
htb_parse_class_details__(struct netdev *netdev,
const struct smap *details, struct htb_class *hc)
{
const struct htb *htb = htb_get__(netdev);
const char *max_rate_s = smap_get(details, "max-rate");
VLOG_DBG("htb_parse_class_details__ device %s", netdev->name);
/* max-rate */
hc->max_rate = (max_rate_s
? strtoull(max_rate_s, NULL, 10) / 8
: htb->max_rate);
VLOG_DBG("htb_parse_class_details__ device max_rate is %u",
hc->max_rate);
return (0);
}
static void
htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
const struct htb_class *hc)
{
struct htb *htb = htb_get__(netdev);
size_t hash = hash_int(queue_id, 0);
struct tc_queue *queue;
struct htb_class *hcp;
VLOG_DBG("htb_update_queue__ %s", netdev->name);
queue = tc_find_queue__(netdev, queue_id, hash);
if (queue) {
hcp = htb_class_cast__(queue);
} else {
hcp = xmalloc(sizeof (*hcp));
queue = &hcp->tc_queue;
queue->queue_id = queue_id;
queue->created = time_msec();
hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
}
hcp->max_rate = hc->max_rate;
}
static int
htb_class_set(struct netdev *netdev, unsigned int queue_id,
const struct smap *details)
{
struct htb_class hc;
int error;
VLOG_DBG("htb_class_set %s", netdev->name);
error = htb_parse_class_details__(netdev, details, &hc);
if (error) {
return (error);
}
error = htb_setup_class__(netdev, 0, 0, &hc);
if (error) {
return (error);
}
htb_update_queue__(netdev, queue_id, &hc);
return (0);
}
static int
htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
{
struct htb_class *hc = htb_class_cast__(queue);
struct htb *htb = htb_get__(netdev);
int error;
VLOG_DBG("htb_class_delete %s", netdev->name);
error = tc_delete_class(netdev, 0);
if (!error) {
hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
free(hc);
}
return (error);
}
/*
* Used to get existing configuration for qdiscs in the kernel, not used in
* Solaris.
*/
static int
htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
{
VLOG_DBG("htb_tc_load %s", netdev->name);
return (0);
}
static const struct tc_ops tc_ops_htb = {
"htb", /* linux_name */
"linux-htb", /* ovs_name */
HTB_N_QUEUES, /* n_queues */
htb_tc_install,
htb_tc_load,
htb_tc_destroy,
htb_qdisc_get,
htb_qdisc_set,
htb_class_get,
htb_class_set,
htb_class_delete,
NULL,
NULL
};
/*
* The default traffic control class.
*
* This class represents the default, unnamed Linux qdisc. It corresponds to
* the "" (empty string) QoS type in the OVS database.
*/
static void
default_install__(struct netdev *netdev_)
{
const char *netdev_name = netdev_get_name(netdev_);
struct netdev_solaris *netdev = netdev_solaris_cast(netdev_);
static const struct tc tc = TC_INITIALIZER(&tc, &tc_ops_default);
VLOG_DBG("default_install__ device %s", netdev_name);
/*
* Nothing but a tc class implementation is allowed to write to a tc.
* This class never does that, so we can legitimately use a const tc
* object.
*/
netdev->tc = CONST_CAST(struct tc *, &tc);
}
static int
default_tc_install(struct netdev *netdev,
const struct smap *details OVS_UNUSED)
{
VLOG_DBG("default_tc_install device %s", netdev->name);
default_install__(netdev);
return (0);
}
static int
default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
{
VLOG_DBG("default_tc_load device %s", netdev->name);
default_install__(netdev);
return (0);
}
static const struct tc_ops tc_ops_default = {
NULL, /* linux_name */
"", /* ovs_name */
0, /* n_queues */
default_tc_install,
default_tc_load,
NULL, /* tc_destroy */
NULL, /* qdisc_get */
NULL, /* qdisc_set */
NULL, /* class_get */
NULL, /* class_set */
NULL, /* class_delete */
NULL, /* class_get_stats */
NULL /* class_dump_stats */
};