#include "netdev-provider.h"
#include "netdev-vport.h"
#include "netlink.h"
+#include "netlink-notifier.h"
#include "netlink-socket.h"
#include "ofpbuf.h"
#include "openflow/openflow.h"
#include "packets.h"
#include "poll-loop.h"
-#include "rtnetlink.h"
#include "rtnetlink-link.h"
#include "socket-util.h"
#include "shash.h"
#define ADVERTISED_Asym_Pause (1 << 14)
#endif
+/* These were introduced in Linux 2.6.24, so they might be missing if we
+ * have old headers. */
+#ifndef ETHTOOL_GFLAGS
+#define ETHTOOL_GFLAGS 0x00000025 /* Get flags bitmap(ethtool_value) */
+#endif
+#ifndef ETHTOOL_SFLAGS
+#define ETHTOOL_SFLAGS 0x00000026 /* Set flags bitmap(ethtool_value) */
+#endif
+
/* This was introduced in Linux 2.6.25, so it might be missing if we have old
* headers. */
#ifndef TC_RTAB_SIZE
#define TC_RTAB_SIZE 1024
#endif
-static struct rtnetlink_notifier netdev_linux_cache_notifier;
+static struct nln_notifier netdev_linux_cache_notifier;
static int cache_notifier_refcount;
enum {
VALID_IN6 = 1 << 3,
VALID_MTU = 1 << 4,
VALID_CARRIER = 1 << 5,
- VALID_IS_PSEUDO = 1 << 6, /* Represents is_internal and is_tap. */
- VALID_POLICING = 1 << 7,
- VALID_HAVE_VPORT_STATS = 1 << 8
+ VALID_POLICING = 1 << 6,
+ VALID_HAVE_VPORT_STATS = 1 << 7
};
struct tap_state {
struct in6_addr in6;
int mtu;
int carrier;
- bool is_internal; /* Is this an openvswitch internal device? */
- bool is_tap; /* Is this a tuntap device? */
uint32_t kbits_rate; /* Policing data. */
uint32_t kbits_burst;
bool have_vport_stats;
/* Creates system and internal devices. */
static int
-netdev_linux_create(const struct netdev_class *class,
- const char *name, const struct shash *args,
- struct netdev_dev **netdev_devp)
+netdev_linux_create(const struct netdev_class *class, const char *name,
+ struct netdev_dev **netdev_devp)
{
struct netdev_dev_linux *netdev_dev;
int error;
- if (!shash_is_empty(args)) {
- VLOG_WARN("%s: arguments for %s devices should be empty",
- name, class->type);
- }
-
if (!cache_notifier_refcount) {
error = rtnetlink_link_notifier_register(&netdev_linux_cache_notifier,
netdev_linux_cache_cb, NULL);
netdev_dev = xzalloc(sizeof *netdev_dev);
netdev_dev->change_seq = 1;
- netdev_dev_init(&netdev_dev->netdev_dev, name, args, class);
+ netdev_dev_init(&netdev_dev->netdev_dev, name, class);
*netdev_devp = &netdev_dev->netdev_dev;
return 0;
* be unavailable to other reads for tap devices. */
static int
netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED,
- const char *name, const struct shash *args,
- struct netdev_dev **netdev_devp)
+ const char *name, struct netdev_dev **netdev_devp)
{
struct netdev_dev_linux *netdev_dev;
struct tap_state *state;
struct ifreq ifr;
int error;
- if (!shash_is_empty(args)) {
- VLOG_WARN("%s: arguments for TAP devices should be empty", name);
- }
-
netdev_dev = xzalloc(sizeof *netdev_dev);
state = &netdev_dev->state.tap;
goto error;
}
- netdev_dev_init(&netdev_dev->netdev_dev, name, args, &netdev_tap_class);
+ netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class);
*netdev_devp = &netdev_dev->netdev_dev;
return 0;
return 0;
}
+/* Sets the maximum size of transmitted (MTU) for given device using linux
+ * networking ioctl interface.
+ */
+static int
+netdev_linux_set_mtu(const struct netdev *netdev_, int mtu)
+{
+ struct netdev_dev_linux *netdev_dev =
+ netdev_dev_linux_cast(netdev_get_dev(netdev_));
+ struct ifreq ifr;
+ int error;
+
+ ifr.ifr_mtu = mtu;
+ error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
+ SIOCSIFMTU, "SIOCSIFMTU");
+ if (error) {
+ return error;
+ }
+
+ netdev_dev->mtu = ifr.ifr_mtu;
+ netdev_dev->cache_valid |= VALID_MTU;
+ return 0;
+}
+
/* Returns the ifindex of 'netdev', if successful, as a positive number.
* On failure, returns a negative errno value. */
static int
}
}
-/* Brings the 'is_internal' and 'is_tap' members of 'netdev_dev' up-to-date. */
-static void
-netdev_linux_update_is_pseudo(struct netdev_dev_linux *netdev_dev)
-{
- if (!(netdev_dev->cache_valid & VALID_IS_PSEUDO)) {
- const char *name = netdev_dev_get_name(&netdev_dev->netdev_dev);
- const char *type = netdev_dev_get_type(&netdev_dev->netdev_dev);
-
- netdev_dev->is_tap = !strcmp(type, "tap");
- netdev_dev->is_internal = (!netdev_dev->is_tap
- && dpif_linux_is_internal_device(name));
- netdev_dev->cache_valid |= VALID_IS_PSEUDO;
- }
-}
-
static void
swap_uint64(uint64_t *a, uint64_t *b)
{
*b = tmp;
}
-/* Retrieves current device stats for 'netdev'. */
-static int
-netdev_linux_get_stats(const struct netdev *netdev_,
- struct netdev_stats *stats)
+static void
+get_stats_via_vport(const struct netdev *netdev_,
+ struct netdev_stats *stats)
{
struct netdev_dev_linux *netdev_dev =
netdev_dev_linux_cast(netdev_get_dev(netdev_));
- static int use_netlink_stats = -1;
- int error;
if (netdev_dev->have_vport_stats ||
!(netdev_dev->cache_valid & VALID_HAVE_VPORT_STATS)) {
+ int error;
error = netdev_vport_get_stats(netdev_, stats);
+ if (error) {
+ VLOG_WARN_RL(&rl, "%s: obtaining netdev stats via vport failed %d",
+ netdev_get_name(netdev_), error);
+ }
netdev_dev->have_vport_stats = !error;
netdev_dev->cache_valid |= VALID_HAVE_VPORT_STATS;
}
+}
- if (!netdev_dev->have_vport_stats) {
- if (use_netlink_stats < 0) {
- use_netlink_stats = check_for_working_netlink_stats();
+static int
+netdev_linux_sys_get_stats(const struct netdev *netdev_,
+ struct netdev_stats *stats)
+{
+ static int use_netlink_stats = -1;
+ int error;
+
+ if (use_netlink_stats < 0) {
+ use_netlink_stats = check_for_working_netlink_stats();
+ }
+
+ if (use_netlink_stats) {
+ int ifindex;
+
+ error = get_ifindex(netdev_, &ifindex);
+ if (!error) {
+ error = get_stats_via_netlink(ifindex, stats);
}
- if (use_netlink_stats) {
- int ifindex;
+ } else {
+ error = get_stats_via_proc(netdev_get_name(netdev_), stats);
+ }
- error = get_ifindex(netdev_, &ifindex);
- if (!error) {
- error = get_stats_via_netlink(ifindex, stats);
- }
+ if (error) {
+ VLOG_WARN_RL(&rl, "%s: linux-sys get stats failed %d",
+ netdev_get_name(netdev_), error);
+ }
+ return error;
+
+}
+
+/* Retrieves current device stats for 'netdev-linux'. */
+static int
+netdev_linux_get_stats(const struct netdev *netdev_,
+ struct netdev_stats *stats)
+{
+ struct netdev_dev_linux *netdev_dev =
+ netdev_dev_linux_cast(netdev_get_dev(netdev_));
+ struct netdev_stats dev_stats;
+ int error;
+
+ get_stats_via_vport(netdev_, stats);
+
+ error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
+
+ if (error) {
+ if (!netdev_dev->have_vport_stats) {
+ return error;
+ } else {
+ return 0;
+ }
+ }
+
+ if (!netdev_dev->have_vport_stats) {
+ /* stats not available from OVS then use ioctl stats. */
+ *stats = dev_stats;
+ } else {
+ stats->rx_errors += dev_stats.rx_errors;
+ stats->tx_errors += dev_stats.tx_errors;
+ stats->rx_dropped += dev_stats.rx_dropped;
+ stats->tx_dropped += dev_stats.tx_dropped;
+ stats->multicast += dev_stats.multicast;
+ stats->collisions += dev_stats.collisions;
+ stats->rx_length_errors += dev_stats.rx_length_errors;
+ stats->rx_over_errors += dev_stats.rx_over_errors;
+ stats->rx_crc_errors += dev_stats.rx_crc_errors;
+ stats->rx_frame_errors += dev_stats.rx_frame_errors;
+ stats->rx_fifo_errors += dev_stats.rx_fifo_errors;
+ stats->rx_missed_errors += dev_stats.rx_missed_errors;
+ stats->tx_aborted_errors += dev_stats.tx_aborted_errors;
+ stats->tx_carrier_errors += dev_stats.tx_carrier_errors;
+ stats->tx_fifo_errors += dev_stats.tx_fifo_errors;
+ stats->tx_heartbeat_errors += dev_stats.tx_heartbeat_errors;
+ stats->tx_window_errors += dev_stats.tx_window_errors;
+ }
+ return 0;
+}
+
+/* Retrieves current device stats for 'netdev-tap' netdev or
+ * netdev-internal. */
+static int
+netdev_pseudo_get_stats(const struct netdev *netdev_,
+ struct netdev_stats *stats)
+{
+ struct netdev_dev_linux *netdev_dev =
+ netdev_dev_linux_cast(netdev_get_dev(netdev_));
+ struct netdev_stats dev_stats;
+ int error;
+
+ get_stats_via_vport(netdev_, stats);
+
+ error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
+ if (error) {
+ if (!netdev_dev->have_vport_stats) {
+ return error;
} else {
- error = get_stats_via_proc(netdev_get_name(netdev_), stats);
+ return 0;
}
}
* them back here. This does not apply if we are getting stats from the
* vport layer because it always tracks stats from the perspective of the
* switch. */
- netdev_linux_update_is_pseudo(netdev_dev);
- if (!error && !netdev_dev->have_vport_stats &&
- (netdev_dev->is_internal || netdev_dev->is_tap)) {
+ if (!netdev_dev->have_vport_stats) {
+ *stats = dev_stats;
swap_uint64(&stats->rx_packets, &stats->tx_packets);
swap_uint64(&stats->rx_bytes, &stats->tx_bytes);
swap_uint64(&stats->rx_errors, &stats->tx_errors);
stats->tx_fifo_errors = 0;
stats->tx_heartbeat_errors = 0;
stats->tx_window_errors = 0;
- }
+ } else {
+ stats->rx_dropped += dev_stats.tx_dropped;
+ stats->tx_dropped += dev_stats.rx_dropped;
- return error;
+ stats->rx_errors += dev_stats.tx_errors;
+ stats->tx_errors += dev_stats.rx_errors;
+
+ stats->multicast += dev_stats.multicast;
+ stats->collisions += dev_stats.collisions;
+ }
+ return 0;
}
/* Stores the features supported by 'netdev' into each of '*current',
return netdev_dev_linux_cast(netdev_get_dev(netdev))->change_seq;
}
-#define NETDEV_LINUX_CLASS(NAME, CREATE, ENUMERATE, SET_STATS) \
+#define NETDEV_LINUX_CLASS(NAME, CREATE, ENUMERATE, GET_STATS, SET_STATS) \
{ \
NAME, \
\
\
CREATE, \
netdev_linux_destroy, \
+ NULL, /* get_config */ \
NULL, /* set_config */ \
- NULL, /* config_equal */ \
\
netdev_linux_open, \
netdev_linux_close, \
netdev_linux_set_etheraddr, \
netdev_linux_get_etheraddr, \
netdev_linux_get_mtu, \
+ netdev_linux_set_mtu, \
netdev_linux_get_ifindex, \
netdev_linux_get_carrier, \
netdev_linux_set_miimon_interval, \
- netdev_linux_get_stats, \
+ GET_STATS, \
SET_STATS, \
\
netdev_linux_get_features, \
"system",
netdev_linux_create,
netdev_linux_enumerate,
+ netdev_linux_get_stats,
NULL); /* set_stats */
const struct netdev_class netdev_tap_class =
"tap",
netdev_linux_create_tap,
NULL, /* enumerate */
+ netdev_pseudo_get_stats,
NULL); /* set_stats */
const struct netdev_class netdev_internal_class =
"internal",
netdev_linux_create,
NULL, /* enumerate */
+ netdev_pseudo_get_stats,
netdev_vport_set_stats);
\f
/* HTB traffic control class. */
int error;
int mtu;
- netdev_get_mtu(netdev, &mtu);
- if (mtu == INT_MAX) {
+ error = netdev_get_mtu(netdev, &mtu);
+ if (error) {
VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU",
netdev_get_name(netdev));
- return EINVAL;
+ return error;
}
memset(&opt, 0, sizeof opt);
const char *max_rate_s = shash_find_data(details, "max-rate");
const char *burst_s = shash_find_data(details, "burst");
const char *priority_s = shash_find_data(details, "priority");
- int mtu;
+ int mtu, error;
- netdev_get_mtu(netdev, &mtu);
- if (mtu == INT_MAX) {
+ error = netdev_get_mtu(netdev, &mtu);
+ if (error) {
VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU",
netdev_get_name(netdev));
- return EINVAL;
+ return error;
}
/* HTB requires at least an mtu sized min-rate to send any traffic even
return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
}
\f
-/* Public utility functions. */
-
-#define COPY_NETDEV_STATS \
- dst->rx_packets = src->rx_packets; \
- dst->tx_packets = src->tx_packets; \
- dst->rx_bytes = src->rx_bytes; \
- dst->tx_bytes = src->tx_bytes; \
- dst->rx_errors = src->rx_errors; \
- dst->tx_errors = src->tx_errors; \
- dst->rx_dropped = src->rx_dropped; \
- dst->tx_dropped = src->tx_dropped; \
- dst->multicast = src->multicast; \
- dst->collisions = src->collisions; \
- dst->rx_length_errors = src->rx_length_errors; \
- dst->rx_over_errors = src->rx_over_errors; \
- dst->rx_crc_errors = src->rx_crc_errors; \
- dst->rx_frame_errors = src->rx_frame_errors; \
- dst->rx_fifo_errors = src->rx_fifo_errors; \
- dst->rx_missed_errors = src->rx_missed_errors; \
- dst->tx_aborted_errors = src->tx_aborted_errors; \
- dst->tx_carrier_errors = src->tx_carrier_errors; \
- dst->tx_fifo_errors = src->tx_fifo_errors; \
- dst->tx_heartbeat_errors = src->tx_heartbeat_errors; \
- dst->tx_window_errors = src->tx_window_errors
-
/* Copies 'src' into 'dst', performing format conversion in the process. */
-void
+static void
netdev_stats_from_rtnl_link_stats(struct netdev_stats *dst,
const struct rtnl_link_stats *src)
{
- COPY_NETDEV_STATS;
-}
-
-/* Copies 'src' into 'dst', performing format conversion in the process. */
-void
-netdev_stats_from_rtnl_link_stats64(struct netdev_stats *dst,
- const struct rtnl_link_stats64 *src)
-{
- COPY_NETDEV_STATS;
+ dst->rx_packets = src->rx_packets;
+ dst->tx_packets = src->tx_packets;
+ dst->rx_bytes = src->rx_bytes;
+ dst->tx_bytes = src->tx_bytes;
+ dst->rx_errors = src->rx_errors;
+ dst->tx_errors = src->tx_errors;
+ dst->rx_dropped = src->rx_dropped;
+ dst->tx_dropped = src->tx_dropped;
+ dst->multicast = src->multicast;
+ dst->collisions = src->collisions;
+ dst->rx_length_errors = src->rx_length_errors;
+ dst->rx_over_errors = src->rx_over_errors;
+ dst->rx_crc_errors = src->rx_crc_errors;
+ dst->rx_frame_errors = src->rx_frame_errors;
+ dst->rx_fifo_errors = src->rx_fifo_errors;
+ dst->rx_missed_errors = src->rx_missed_errors;
+ dst->tx_aborted_errors = src->tx_aborted_errors;
+ dst->tx_carrier_errors = src->tx_carrier_errors;
+ dst->tx_fifo_errors = src->tx_fifo_errors;
+ dst->tx_heartbeat_errors = src->tx_heartbeat_errors;
+ dst->tx_window_errors = src->tx_window_errors;
}
-/* Copies 'src' into 'dst', performing format conversion in the process. */
-void
-netdev_stats_to_rtnl_link_stats64(struct rtnl_link_stats64 *dst,
- const struct netdev_stats *src)
-{
- COPY_NETDEV_STATS;
- dst->rx_compressed = 0;
- dst->tx_compressed = 0;
-}
\f
/* Utility functions. */
}
}
+/* Modifies the 'flag' bit in ethtool's flags field for 'netdev'. If
+ * 'enable' is true, the bit is set. Otherwise, it is cleared. */
+int
+netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag,
+ const char *flag_name, bool enable)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ struct ethtool_value evalue;
+ uint32_t new_flags;
+ int error;
+
+ memset(&evalue, 0, sizeof evalue);
+ error = netdev_linux_do_ethtool(netdev_name,
+ (struct ethtool_cmd *)&evalue,
+ ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
+ if (error) {
+ return error;
+ }
+
+ evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0);
+ error = netdev_linux_do_ethtool(netdev_name,
+ (struct ethtool_cmd *)&evalue,
+ ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS");
+ if (error) {
+ return error;
+ }
+
+ memset(&evalue, 0, sizeof evalue);
+ error = netdev_linux_do_ethtool(netdev_name,
+ (struct ethtool_cmd *)&evalue,
+ ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
+ if (error) {
+ return error;
+ }
+
+ if (new_flags != evalue.data) {
+ VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network "
+ "device %s failed", enable ? "enable" : "disable",
+ flag_name, netdev_name);
+ return EOPNOTSUPP;
+ }
+
+ return 0;
+}
+
static int
netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd,
const char *cmd_name)
git://git.onelab.eu / sliver-openvswitch.git / blobdiff