/*
- * Copyright (c) 2008, 2009, 2010 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "packets.h"
#include "poll-loop.h"
#include "shash.h"
+#include "smap.h"
+#include "sset.h"
#include "svec.h"
#include "vlog.h"
fatal_signal_add_hook(close_all_netdevs, NULL, NULL, true);
-#ifdef HAVE_NETLINK
+#ifdef LINUX_DATAPATH
netdev_register_provider(&netdev_linux_class);
netdev_register_provider(&netdev_internal_class);
netdev_register_provider(&netdev_tap_class);
netdev_vport_register();
#endif
+#ifdef __FreeBSD__
+ netdev_register_provider(&netdev_tap_class);
+ netdev_register_provider(&netdev_bsd_class);
+#endif
+ netdev_register_provider(&netdev_tunnel_class);
+ netdev_register_provider(&netdev_pltap_class);
}
}
}
/* Clears 'types' and enumerates the types of all currently registered netdev
- * providers into it. The caller must first initialize the svec. */
+ * providers into it. The caller must first initialize the sset. */
void
-netdev_enumerate_types(struct svec *types)
+netdev_enumerate_types(struct sset *types)
{
struct shash_node *node;
netdev_initialize();
- svec_clear(types);
+ sset_clear(types);
SHASH_FOR_EACH(node, &netdev_classes) {
const struct netdev_class *netdev_class = node->data;
- svec_add(types, netdev_class->type);
+ sset_add(types, netdev_class->type);
}
}
-void
-update_device_args(struct netdev_dev *dev, const struct shash *args)
-{
- smap_destroy(&dev->args);
- smap_clone(&dev->args, args);
-}
-
-/* Opens the network device named 'name' (e.g. "eth0") and returns zero if
- * successful, otherwise a positive errno value. On success, sets '*netdevp'
- * to the new network device, otherwise to null.
- *
- * If this is the first time the device has been opened, then create is called
- * before opening. The device is created using the given type and arguments.
+/* Opens the network device named 'name' (e.g. "eth0") of the specified 'type'
+ * (e.g. "system") and returns zero if successful, otherwise a positive errno
+ * value. On success, sets '*netdevp' to the new network device, otherwise to
+ * null.
*
- * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order to
- * capture frames of that type received on the device. It may also be one of
- * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
- * categories. */
+ * Some network devices may need to be configured (with netdev_set_config())
+ * before they can be used. */
int
-netdev_open(struct netdev_options *options, struct netdev **netdevp)
+netdev_open(const char *name, const char *type, struct netdev **netdevp)
{
- struct shash empty_args = SHASH_INITIALIZER(&empty_args);
struct netdev_dev *netdev_dev;
int error;
*netdevp = NULL;
netdev_initialize();
- if (!options->args) {
- options->args = &empty_args;
- }
-
- netdev_dev = shash_find_data(&netdev_dev_shash, options->name);
+ netdev_dev = shash_find_data(&netdev_dev_shash, name);
if (!netdev_dev) {
const struct netdev_class *class;
- class = netdev_lookup_provider(options->type);
+ class = netdev_lookup_provider(type);
if (!class) {
VLOG_WARN("could not create netdev %s of unknown type %s",
- options->name, options->type);
+ name, type);
return EAFNOSUPPORT;
}
- error = class->create(class, options->name, options->args,
- &netdev_dev);
+ error = class->create(class, name, &netdev_dev);
if (error) {
return error;
}
assert(netdev_dev->netdev_class == class);
- update_device_args(netdev_dev, options->args);
-
- } else if (!shash_is_empty(options->args) &&
- !smap_equal(&netdev_dev->args, options->args)) {
- VLOG_WARN("%s: attempted to open already open netdev with "
- "different arguments", options->name);
- return EINVAL;
}
- error = netdev_dev->netdev_class->open(netdev_dev, options->ethertype,
- netdevp);
+ error = netdev_dev->netdev_class->open(netdev_dev, netdevp);
if (!error) {
netdev_dev->ref_cnt++;
return error;
}
+/* Reconfigures the device 'netdev' with 'args'. 'args' may be empty
+ * or NULL if none are needed. */
int
-netdev_open_default(const char *name, struct netdev **netdevp)
+netdev_set_config(struct netdev *netdev, const struct smap *args)
{
- struct netdev_options options;
+ struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
- memset(&options, 0, sizeof options);
- options.name = name;
- options.ethertype = NETDEV_ETH_TYPE_NONE;
+ if (netdev_dev->netdev_class->set_config) {
+ struct smap no_args = SMAP_INITIALIZER(&no_args);
+ return netdev_dev->netdev_class->set_config(netdev_dev,
+ args ? args : &no_args);
+ } else if (args && !smap_is_empty(args)) {
+ VLOG_WARN("%s: arguments provided to device that is not configurable",
+ netdev_get_name(netdev));
+ }
- return netdev_open(&options, netdevp);
+ return 0;
}
-/* Reconfigures the device 'netdev' with 'args'. 'args' may be empty
- * or NULL if none are needed. */
+/* Returns the current configuration for 'netdev' in 'args'. The caller must
+ * have already initialized 'args' with smap_init(). Returns 0 on success, in
+ * which case 'args' will be filled with 'netdev''s configuration. On failure
+ * returns a positive errno value, in which case 'args' will be empty.
+ *
+ * The caller owns 'args' and its contents and must eventually free them with
+ * smap_destroy(). */
int
-netdev_reconfigure(struct netdev *netdev, const struct shash *args)
+netdev_get_config(const struct netdev *netdev, struct smap *args)
{
- struct shash empty_args = SHASH_INITIALIZER(&empty_args);
struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
+ int error;
- if (!args) {
- args = &empty_args;
- }
-
- if (netdev_dev->netdev_class->reconfigure) {
- if (!smap_equal(&netdev_dev->args, args)) {
- update_device_args(netdev_dev, args);
- return netdev_dev->netdev_class->reconfigure(netdev_dev, args);
+ smap_clear(args);
+ if (netdev_dev->netdev_class->get_config) {
+ error = netdev_dev->netdev_class->get_config(netdev_dev, args);
+ if (error) {
+ smap_clear(args);
}
- } else if (!shash_is_empty(args)) {
- VLOG_WARN("%s: arguments provided to device that does not have a "
- "reconfigure function", netdev_get_name(netdev));
+ } else {
+ error = 0;
}
- return 0;
+ return error;
}
/* Closes and destroys 'netdev'. */
struct netdev *netdev;
int error;
- error = netdev_open_default(name, &netdev);
+ error = netdev_open(name, "system", &netdev);
if (!error) {
netdev_close(netdev);
return true;
return !!shash_find_data(&netdev_dev_shash, name);
}
-/* Clears 'svec' and enumerates the names of all known network devices. */
-int
-netdev_enumerate(struct svec *svec)
+/* Parses 'netdev_name_', which is of the form [type@]name into its component
+ * pieces. 'name' and 'type' must be freed by the caller. */
+void
+netdev_parse_name(const char *netdev_name_, char **name, char **type)
{
- struct shash_node *node;
- int error = 0;
-
- netdev_initialize();
- svec_clear(svec);
+ char *netdev_name = xstrdup(netdev_name_);
+ char *separator;
- SHASH_FOR_EACH(node, &netdev_classes) {
- const struct netdev_class *netdev_class = node->data;
- if (netdev_class->enumerate) {
- int retval = netdev_class->enumerate(svec);
- if (retval) {
- VLOG_WARN("failed to enumerate %s network devices: %s",
- netdev_class->type, strerror(retval));
- if (!error) {
- error = retval;
- }
- }
- }
+ separator = strchr(netdev_name, '@');
+ if (separator) {
+ *separator = '\0';
+ *type = netdev_name;
+ *name = xstrdup(separator + 1);
+ } else {
+ *name = netdev_name;
+ *type = xstrdup("system");
}
+}
- return error;
+/* Attempts to set up 'netdev' for receiving packets with netdev_recv().
+ * Returns 0 if successful, otherwise a positive errno value. EOPNOTSUPP
+ * indicates that the network device does not implement packet reception
+ * through this interface. */
+int
+netdev_listen(struct netdev *netdev)
+{
+ int (*listen)(struct netdev *);
+
+ listen = netdev_get_dev(netdev)->netdev_class->listen;
+ return listen ? (listen)(netdev) : EOPNOTSUPP;
}
/* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
* (Some devices do not allow for a VLAN header, in which case VLAN_HEADER_LEN
* need not be included.)
*
+ * This function can only be expected to return a packet if ->listen() has
+ * been called successfully.
+ *
* If a packet is successfully retrieved, returns 0. In this case 'buffer' is
* guaranteed to contain at least ETH_TOTAL_MIN bytes. Otherwise, returns a
* positive errno value. Returns EAGAIN immediately if no packet is ready to
* (and received) packets, in bytes, not including the hardware header; thus,
* this is typically 1500 bytes for Ethernet devices.
*
- * If successful, returns 0 and stores the MTU size in '*mtup'. On failure,
- * returns a positive errno value and stores ETH_PAYLOAD_MAX (1500) in
- * '*mtup'. */
+ * If successful, returns 0 and stores the MTU size in '*mtup'. Returns
+ * EOPNOTSUPP if 'netdev' does not have an MTU (as e.g. some tunnels do not).
+ * On other failure, returns a positive errno value. On failure, sets '*mtup'
+ * to 0. */
int
netdev_get_mtu(const struct netdev *netdev, int *mtup)
{
- int error = netdev_get_dev(netdev)->netdev_class->get_mtu(netdev, mtup);
+ const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
+ int error;
+
+ error = class->get_mtu ? class->get_mtu(netdev, mtup) : EOPNOTSUPP;
if (error) {
- VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s",
+ *mtup = 0;
+ if (error != EOPNOTSUPP) {
+ VLOG_DBG_RL(&rl, "failed to retrieve MTU for network device %s: "
+ "%s", netdev_get_name(netdev), strerror(error));
+ }
+ }
+ return error;
+}
+
+/* Sets the MTU of 'netdev'. The MTU is the maximum size of transmitted
+ * (and received) packets, in bytes.
+ *
+ * If successful, returns 0. Returns EOPNOTSUPP if 'netdev' does not have an
+ * MTU (as e.g. some tunnels do not). On other failure, returns a positive
+ * errno value. */
+int
+netdev_set_mtu(const struct netdev *netdev, int mtu)
+{
+ const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
+ int error;
+
+ error = class->set_mtu ? class->set_mtu(netdev, mtu) : EOPNOTSUPP;
+ if (error && error != EOPNOTSUPP) {
+ VLOG_DBG_RL(&rl, "failed to set MTU for network device %s: %s",
netdev_get_name(netdev), strerror(error));
- *mtup = ETH_PAYLOAD_MAX;
}
+
return error;
}
* cases this function will always return EOPNOTSUPP. */
int
netdev_get_features(const struct netdev *netdev,
- uint32_t *current, uint32_t *advertised,
- uint32_t *supported, uint32_t *peer)
+ enum netdev_features *current,
+ enum netdev_features *advertised,
+ enum netdev_features *supported,
+ enum netdev_features *peer)
{
int (*get_features)(const struct netdev *netdev,
- uint32_t *current, uint32_t *advertised,
- uint32_t *supported, uint32_t *peer);
- uint32_t dummy[4];
+ enum netdev_features *current,
+ enum netdev_features *advertised,
+ enum netdev_features *supported,
+ enum netdev_features *peer);
+ enum netdev_features dummy[4];
int error;
if (!current) {
get_features = netdev_get_dev(netdev)->netdev_class->get_features;
error = get_features
- ? get_features(netdev, current, advertised, supported, peer)
+ ? get_features(netdev, current, advertised, supported,
+ peer)
: EOPNOTSUPP;
if (error) {
*current = *advertised = *supported = *peer = 0;
return error;
}
-/* Returns the maximum speed of a network connection that has the "enum
- * ofp_port_features" bits in 'features', in bits per second. If no bits that
- * indicate a speed are set in 'features', assumes 100Mbps. */
+/* Returns the maximum speed of a network connection that has the NETDEV_F_*
+ * bits in 'features', in bits per second. If no bits that indicate a speed
+ * are set in 'features', assumes 100Mbps. */
uint64_t
-netdev_features_to_bps(uint32_t features)
+netdev_features_to_bps(enum netdev_features features)
{
enum {
- F_10000MB = OFPPF_10GB_FD,
- F_1000MB = OFPPF_1GB_HD | OFPPF_1GB_FD,
- F_100MB = OFPPF_100MB_HD | OFPPF_100MB_FD,
- F_10MB = OFPPF_10MB_HD | OFPPF_10MB_FD
+ F_1000000MB = NETDEV_F_1TB_FD,
+ F_100000MB = NETDEV_F_100GB_FD,
+ F_40000MB = NETDEV_F_40GB_FD,
+ F_10000MB = NETDEV_F_10GB_FD,
+ F_1000MB = NETDEV_F_1GB_HD | NETDEV_F_1GB_FD,
+ F_100MB = NETDEV_F_100MB_HD | NETDEV_F_100MB_FD,
+ F_10MB = NETDEV_F_10MB_HD | NETDEV_F_10MB_FD
};
- return ( features & F_10000MB ? UINT64_C(10000000000)
- : features & F_1000MB ? UINT64_C(1000000000)
- : features & F_100MB ? UINT64_C(100000000)
- : features & F_10MB ? UINT64_C(10000000)
- : UINT64_C(100000000));
+ return ( features & F_1000000MB ? UINT64_C(1000000000000)
+ : features & F_100000MB ? UINT64_C(100000000000)
+ : features & F_40000MB ? UINT64_C(40000000000)
+ : features & F_10000MB ? UINT64_C(10000000000)
+ : features & F_1000MB ? UINT64_C(1000000000)
+ : features & F_100MB ? UINT64_C(100000000)
+ : features & F_10MB ? UINT64_C(10000000)
+ : UINT64_C(100000000));
}
-/* Returns true if any of the "enum ofp_port_features" bits that indicate a
- * full-duplex link are set in 'features', otherwise false. */
+/* Returns true if any of the NETDEV_F_* bits that indicate a full-duplex link
+ * are set in 'features', otherwise false. */
bool
-netdev_features_is_full_duplex(uint32_t features)
+netdev_features_is_full_duplex(enum netdev_features features)
{
- return (features & (OFPPF_10MB_FD | OFPPF_100MB_FD | OFPPF_1GB_FD
- | OFPPF_10GB_FD)) != 0;
+ return (features & (NETDEV_F_10MB_FD | NETDEV_F_100MB_FD | NETDEV_F_1GB_FD
+ | NETDEV_F_10GB_FD | NETDEV_F_40GB_FD
+ | NETDEV_F_100GB_FD | NETDEV_F_1TB_FD)) != 0;
}
/* Set the features advertised by 'netdev' to 'advertise'. Returns 0 if
* successful, otherwise a positive errno value. */
int
-netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
+netdev_set_advertisements(struct netdev *netdev,
+ enum netdev_features advertise)
{
return (netdev_get_dev(netdev)->netdev_class->set_advertisements
? netdev_get_dev(netdev)->netdev_class->set_advertisements(
*
* - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
*
- * 'address' or 'netmask' or both may be null, in which case the address or
+ * 'address' or 'netmask' or both may be null, in which case the address or
* netmask is not reported. */
int
netdev_get_in4(const struct netdev *netdev,
: EOPNOTSUPP);
}
+/* Obtains ad IPv4 address from device name and save the address in
+ * in4. Returns 0 if successful, otherwise a positive errno value.
+ */
+int
+netdev_get_in4_by_name(const char *device_name, struct in_addr *in4)
+{
+ struct netdev *netdev;
+ int error;
+
+ error = netdev_open(device_name, "system", &netdev);
+ if (error) {
+ in4->s_addr = htonl(0);
+ return error;
+ }
+
+ error = netdev_get_in4(netdev, in4, NULL);
+ netdev_close(netdev);
+ return error;
+}
+
/* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
* to 'netdev'. */
int
return error;
}
-/* Populates 'sh' with status information.
+/* Populates 'smap' with status information.
*
- * Populates 'sh' with 'netdev' specific status information. This information
- * may be used to populate the status column of the Interface table as defined
- * in ovs-vswitchd.conf.db(5). */
+ * Populates 'smap' with 'netdev' specific status information. This
+ * information may be used to populate the status column of the Interface table
+ * as defined in ovs-vswitchd.conf.db(5). */
int
-netdev_get_status(const struct netdev *netdev, struct shash *sh)
+netdev_get_drv_info(const struct netdev *netdev, struct smap *smap)
{
struct netdev_dev *dev = netdev_get_dev(netdev);
- return (dev->netdev_class->get_status
- ? dev->netdev_class->get_status(netdev, sh)
+ return (dev->netdev_class->get_drv_info
+ ? dev->netdev_class->get_drv_info(netdev, smap)
: EOPNOTSUPP);
}
int
netdev_get_flags(const struct netdev *netdev_, enum netdev_flags *flagsp)
{
- struct netdev *netdev = (struct netdev *) netdev_;
+ struct netdev *netdev = CONST_CAST(struct netdev *, netdev_);
return do_update_flags(netdev, 0, 0, flagsp, false);
}
* ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
int
netdev_arp_lookup(const struct netdev *netdev,
- uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
+ ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
{
int error = (netdev_get_dev(netdev)->netdev_class->arp_lookup
? netdev_get_dev(netdev)->netdev_class->arp_lookup(netdev,
return carrier;
}
-/* Returns true if 'netdev' is up according to its MII. */
-bool
-netdev_get_miimon(const struct netdev *netdev)
+/* Returns the number of times 'netdev''s carrier has changed. */
+long long int
+netdev_get_carrier_resets(const struct netdev *netdev)
{
- int error;
- enum netdev_flags flags;
- bool miimon;
-
- netdev_get_flags(netdev, &flags);
- if (!(flags & NETDEV_UP)) {
- return false;
- }
-
- if (!netdev_get_dev(netdev)->netdev_class->get_miimon) {
- return true;
- }
-
- error = netdev_get_dev(netdev)->netdev_class->get_miimon(netdev, &miimon);
-
- if (error) {
- VLOG_DBG("%s: failed to get network device MII status, assuming "
- "down: %s", netdev_get_name(netdev), strerror(error));
- miimon = false;
- }
+ return (netdev_get_dev(netdev)->netdev_class->get_carrier_resets
+ ? netdev_get_dev(netdev)->netdev_class->get_carrier_resets(netdev)
+ : 0);
+}
- return miimon;
+/* Attempts to force netdev_get_carrier() to poll 'netdev''s MII registers for
+ * link status instead of checking 'netdev''s carrier. 'netdev''s MII
+ * registers will be polled once ever 'interval' milliseconds. If 'netdev'
+ * does not support MII, another method may be used as a fallback. If
+ * 'interval' is less than or equal to zero, reverts netdev_get_carrier() to
+ * its normal behavior.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+int
+netdev_set_miimon_interval(struct netdev *netdev, long long int interval)
+{
+ struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
+ return (netdev_dev->netdev_class->set_miimon_interval
+ ? netdev_dev->netdev_class->set_miimon_interval(netdev, interval)
+ : EOPNOTSUPP);
}
/* Retrieves current device stats for 'netdev'. */
* Every network device supports disabling QoS with a type of "", but this type
* will not be added to 'types'.
*
- * The caller must initialize 'types' (e.g. with svec_init()) before calling
+ * The caller must initialize 'types' (e.g. with sset_init()) before calling
* this function. The caller is responsible for destroying 'types' (e.g. with
- * svec_destroy()) when it is no longer needed.
+ * sset_destroy()) when it is no longer needed.
*
* Returns 0 if successful, otherwise a positive errno value. */
int
-netdev_get_qos_types(const struct netdev *netdev, struct svec *types)
+netdev_get_qos_types(const struct netdev *netdev, struct sset *types)
{
const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
return (class->get_qos_types
*
* A '*typep' of "" indicates that QoS is currently disabled on 'netdev'.
*
- * The caller must initialize 'details' as an empty shash (e.g. with
- * shash_init()) before calling this function. The caller must free 'details',
- * including 'data' members, when it is no longer needed (e.g. with
- * shash_destroy_free_data()).
+ * The caller must initialize 'details' as an empty smap (e.g. with
+ * smap_init()) before calling this function. The caller must free 'details'
+ * when it is no longer needed (e.g. with smap_destroy()).
*
* The caller must not modify or free '*typep'.
*
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). */
int
netdev_get_qos(const struct netdev *netdev,
- const char **typep, struct shash *details)
+ const char **typep, struct smap *details)
{
const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
int retval;
retval = class->get_qos(netdev, typep, details);
if (retval) {
*typep = NULL;
- shash_clear_free_data(details);
+ smap_clear(details);
}
return retval;
} else {
* details. */
int
netdev_set_qos(struct netdev *netdev,
- const char *type, const struct shash *details)
+ const char *type, const struct smap *details)
{
const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
if (class->set_qos) {
if (!details) {
- static struct shash empty = SHASH_INITIALIZER(&empty);
+ static struct smap empty = SMAP_INITIALIZER(&empty);
details = ∅
}
return class->set_qos(netdev, type, details);
* given 'type' in the "other_config" column in the "Queue" table in
* vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
*
- * The caller must initialize 'details' (e.g. with shash_init()) before calling
- * this function. The caller must free 'details', including 'data' members,
- * when it is no longer needed (e.g. with shash_destroy_free_data()). */
+ * The caller must initialize 'details' (e.g. with smap_init()) before calling
+ * this function. The caller must free 'details' when it is no longer needed
+ * (e.g. with smap_destroy()). */
int
netdev_get_queue(const struct netdev *netdev,
- unsigned int queue_id, struct shash *details)
+ unsigned int queue_id, struct smap *details)
{
const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
int retval;
? class->get_queue(netdev, queue_id, details)
: EOPNOTSUPP);
if (retval) {
- shash_clear_free_data(details);
+ smap_clear(details);
}
return retval;
}
* it. */
int
netdev_set_queue(struct netdev *netdev,
- unsigned int queue_id, const struct shash *details)
+ unsigned int queue_id, const struct smap *details)
{
const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
return (class->set_queue
* Calling this function may be more efficient than calling netdev_get_queue()
* for every queue.
*
- * 'cb' must not modify or free the 'details' argument passed in.
+ * 'cb' must not modify or free the 'details' argument passed in. It may
+ * delete or modify the queue passed in as its 'queue_id' argument. It may
+ * modify but must not delete any other queue within 'netdev'. 'cb' should not
+ * add new queues because this may cause some queues to be visited twice or not
+ * at all.
*
* Returns 0 if successful, otherwise a positive errno value. On error, some
* configured queues may not have been included in the iteration. */
: EOPNOTSUPP);
}
-/* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
- * sets '*vlan_vid' to the VLAN VID associated with that device and returns 0.
- * Otherwise returns a errno value (specifically ENOENT if 'netdev_name' is the
- * name of a network device that is not a VLAN device) and sets '*vlan_vid' to
- * -1. */
-int
-netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
-{
- int error = (netdev_get_dev(netdev)->netdev_class->get_vlan_vid
- ? netdev_get_dev(netdev)->netdev_class->get_vlan_vid(netdev,
- vlan_vid)
- : ENOENT);
- if (error) {
- *vlan_vid = 0;
- }
- return error;
-}
-
-/* Returns a network device that has 'in4' as its IP address, if one exists,
- * otherwise a null pointer. */
-struct netdev *
-netdev_find_dev_by_in4(const struct in_addr *in4)
+/* Returns a sequence number which indicates changes in one of 'netdev''s
+ * properties. The returned sequence will be nonzero so that callers have a
+ * value which they may use as a reset when tracking 'netdev'.
+ *
+ * The returned sequence number will change whenever 'netdev''s flags,
+ * features, ethernet address, or carrier changes. It may change for other
+ * reasons as well, or no reason at all. */
+unsigned int
+netdev_change_seq(const struct netdev *netdev)
{
- struct netdev *netdev;
- struct svec dev_list = SVEC_EMPTY_INITIALIZER;
- size_t i;
-
- netdev_enumerate(&dev_list);
- for (i = 0; i < dev_list.n; i++) {
- const char *name = dev_list.names[i];
- struct in_addr dev_in4;
-
- if (!netdev_open_default(name, &netdev)
- && !netdev_get_in4(netdev, &dev_in4, NULL)
- && dev_in4.s_addr == in4->s_addr) {
- goto exit;
- }
- netdev_close(netdev);
- }
- netdev = NULL;
-
-exit:
- svec_destroy(&dev_list);
- return netdev;
+ return netdev_get_dev(netdev)->netdev_class->change_seq(netdev);
}
\f
-/* Initializes 'netdev_dev' as a netdev device named 'name' of the
- * specified 'netdev_class'.
+/* Initializes 'netdev_dev' as a netdev device named 'name' of the specified
+ * 'netdev_class'. This function is ordinarily called from a netdev provider's
+ * 'create' function.
*
* This function adds 'netdev_dev' to a netdev-owned shash, so it is
* very important that 'netdev_dev' only be freed after calling
netdev_dev->netdev_class = netdev_class;
netdev_dev->name = xstrdup(name);
netdev_dev->node = shash_add(&netdev_dev_shash, name, netdev_dev);
- shash_init(&netdev_dev->args);
}
/* Undoes the results of initialization.
assert(!netdev_dev->ref_cnt);
shash_delete(&netdev_dev_shash, netdev_dev->node);
- smap_destroy(&netdev_dev->args);
if (destroy) {
netdev_dev->netdev_class->destroy(netdev_dev);
{
return netdev->netdev_dev;
}
-
-/* Initializes 'notifier' as a netdev notifier for 'netdev', for which
- * notification will consist of calling 'cb', with auxiliary data 'aux'. */
-void
-netdev_notifier_init(struct netdev_notifier *notifier, struct netdev *netdev,
- void (*cb)(struct netdev_notifier *), void *aux)
-{
- notifier->netdev = netdev;
- notifier->cb = cb;
- notifier->aux = aux;
-}
-\f
-/* Tracks changes in the status of a set of network devices. */
-struct netdev_monitor {
- struct shash polled_netdevs;
- struct shash changed_netdevs;
-};
-
-/* Creates and returns a new structure for monitor changes in the status of
- * network devices. */
-struct netdev_monitor *
-netdev_monitor_create(void)
-{
- struct netdev_monitor *monitor = xmalloc(sizeof *monitor);
- shash_init(&monitor->polled_netdevs);
- shash_init(&monitor->changed_netdevs);
- return monitor;
-}
-
-/* Destroys 'monitor'. */
-void
-netdev_monitor_destroy(struct netdev_monitor *monitor)
-{
- if (monitor) {
- struct shash_node *node;
-
- SHASH_FOR_EACH (node, &monitor->polled_netdevs) {
- struct netdev_notifier *notifier = node->data;
- netdev_get_dev(notifier->netdev)->netdev_class->poll_remove(
- notifier);
- }
-
- shash_destroy(&monitor->polled_netdevs);
- shash_destroy(&monitor->changed_netdevs);
- free(monitor);
- }
-}
-
-static void
-netdev_monitor_cb(struct netdev_notifier *notifier)
-{
- struct netdev_monitor *monitor = notifier->aux;
- const char *name = netdev_get_name(notifier->netdev);
- shash_add_once(&monitor->changed_netdevs, name, NULL);
-}
-
-/* Attempts to add 'netdev' as a netdev monitored by 'monitor'. Returns 0 if
- * successful, otherwise a positive errno value.
- *
- * Adding a given 'netdev' to a monitor multiple times is equivalent to adding
- * it once. */
-int
-netdev_monitor_add(struct netdev_monitor *monitor, struct netdev *netdev)
-{
- const char *netdev_name = netdev_get_name(netdev);
- int error = 0;
- if (!shash_find(&monitor->polled_netdevs, netdev_name)
- && netdev_get_dev(netdev)->netdev_class->poll_add)
- {
- struct netdev_notifier *notifier;
- error = netdev_get_dev(netdev)->netdev_class->poll_add(netdev,
- netdev_monitor_cb, monitor, ¬ifier);
- if (!error) {
- assert(notifier->netdev == netdev);
- shash_add(&monitor->polled_netdevs, netdev_name, notifier);
- }
- }
- return error;
-}
-
-/* Removes 'netdev' from the set of netdevs monitored by 'monitor'. (This has
- * no effect if 'netdev' is not in the set of devices monitored by
- * 'monitor'.) */
-void
-netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev)
-{
- const char *netdev_name = netdev_get_name(netdev);
- struct shash_node *node;
-
- node = shash_find(&monitor->polled_netdevs, netdev_name);
- if (node) {
- /* Cancel future notifications. */
- struct netdev_notifier *notifier = node->data;
- netdev_get_dev(netdev)->netdev_class->poll_remove(notifier);
- shash_delete(&monitor->polled_netdevs, node);
-
- /* Drop any pending notification. */
- node = shash_find(&monitor->changed_netdevs, netdev_name);
- if (node) {
- shash_delete(&monitor->changed_netdevs, node);
- }
- }
-}
-
-/* Checks for changes to netdevs in the set monitored by 'monitor'. If any of
- * the attributes (Ethernet address, carrier status, speed or peer-advertised
- * speed, flags, etc.) of a network device monitored by 'monitor' has changed,
- * sets '*devnamep' to the name of a device that has changed and returns 0.
- * The caller is responsible for freeing '*devnamep' (with free()).
- *
- * If no devices have changed, sets '*devnamep' to NULL and returns EAGAIN. */
-int
-netdev_monitor_poll(struct netdev_monitor *monitor, char **devnamep)
-{
- struct shash_node *node = shash_first(&monitor->changed_netdevs);
- if (!node) {
- *devnamep = NULL;
- return EAGAIN;
- } else {
- *devnamep = shash_steal(&monitor->changed_netdevs, node);
- return 0;
- }
-}
-
-/* Registers with the poll loop to wake up from the next call to poll_block()
- * when netdev_monitor_poll(monitor) would indicate that a device has
- * changed. */
-void
-netdev_monitor_poll_wait(const struct netdev_monitor *monitor)
-{
- if (!shash_is_empty(&monitor->changed_netdevs)) {
- poll_immediate_wake();
- } else {
- /* XXX Nothing needed here for netdev_linux, but maybe other netdev
- * classes need help. */
- }
-}
\f
/* Restore the network device flags on 'netdev' to those that were active
* before we changed them. Returns 0 if successful, otherwise a positive
git://git.onelab.eu / sliver-openvswitch.git / blobdiff