/*
- * Copyright (c) 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <linux/types.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
+#include <linux/pkt_cls.h>
#include <linux/pkt_sched.h>
#include <linux/rtnetlink.h>
#include <linux/sockios.h>
VALID_IN6 = 1 << 3,
VALID_MTU = 1 << 4,
VALID_POLICING = 1 << 5,
- VALID_HAVE_VPORT_STATS = 1 << 6
+ VALID_VPORT_STAT_ERROR = 1 << 6
};
struct tap_state {
static struct tcmsg *tc_make_request(const struct netdev *, int type,
unsigned int flags, struct ofpbuf *);
static int tc_transact(struct ofpbuf *request, struct ofpbuf **replyp);
+static int tc_add_del_ingress_qdisc(struct netdev *netdev, bool add);
+static int tc_add_policer(struct netdev *netdev, int kbits_rate,
+ int kbits_burst);
static int tc_parse_qdisc(const struct ofpbuf *, const char **kind,
struct nlattr **options);
struct in_addr address, netmask;
struct in6_addr in6;
int mtu;
- bool carrier;
+ unsigned int ifi_flags;
long long int carrier_resets;
uint32_t kbits_rate; /* Policing data. */
uint32_t kbits_burst;
- bool have_vport_stats;
+ int vport_stats_error; /* Cached error code from vport_get_stats().
+ 0 or an errno value. */
struct tc *tc;
union {
const char *cmd_name);
static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
int cmd, const char *cmd_name);
-static int get_flags(const struct netdev *, int *flagsp);
-static int set_flags(struct netdev *, int flags);
+static int get_flags(const struct netdev_dev *, unsigned int *flags);
+static int set_flags(struct netdev *, unsigned int flags);
static int do_get_ifindex(const char *netdev_name);
static int get_ifindex(const struct netdev *, int *ifindexp);
static int do_set_addr(struct netdev *netdev,
const uint8_t[ETH_ADDR_LEN]);
static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats);
static int get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats);
-static int get_carrier_via_sysfs(const char *name, bool *carrier);
static int af_packet_sock(void);
static void netdev_linux_miimon_run(void);
static void netdev_linux_miimon_wait(void);
}
static void
-netdev_dev_linux_changed(struct netdev_dev_linux *dev)
+netdev_dev_linux_changed(struct netdev_dev_linux *dev, unsigned int ifi_flags)
{
dev->change_seq++;
if (!dev->change_seq) {
dev->change_seq++;
}
+
+ if ((dev->ifi_flags ^ ifi_flags) & IFF_RUNNING) {
+ dev->carrier_resets++;
+ }
+ dev->ifi_flags = ifi_flags;
+
dev->cache_valid = 0;
}
if (is_netdev_linux_class(netdev_class)) {
dev = netdev_dev_linux_cast(base_dev);
-
- if (dev->carrier != change->running) {
- dev->carrier = change->running;
- dev->carrier_resets++;
- }
-
- netdev_dev_linux_changed(dev);
+ netdev_dev_linux_changed(dev, change->ifi_flags);
}
}
} else {
shash_init(&device_shash);
netdev_dev_get_devices(&netdev_linux_class, &device_shash);
SHASH_FOR_EACH (node, &device_shash) {
- bool carrier;
+ unsigned int flags;
dev = node->data;
- get_carrier_via_sysfs(node->name, &carrier);
- if (dev->carrier != carrier) {
- dev->carrier = carrier;
- dev->carrier_resets++;
- }
-
- netdev_dev_linux_changed(dev);
+ get_flags(&dev->netdev_dev, &flags);
+ netdev_dev_linux_changed(dev, flags);
}
shash_destroy(&device_shash);
}
}
-/* Creates system and internal devices. */
static int
-netdev_linux_create(const struct netdev_class *class, const char *name,
- struct netdev_dev **netdev_devp)
+cache_notifier_ref(void)
{
- struct netdev_dev_linux *netdev_dev;
-
if (!cache_notifier_refcount) {
assert(!netdev_linux_cache_notifier);
}
cache_notifier_refcount++;
+ return 0;
+}
+
+static void
+cache_notifier_unref(void)
+{
+ assert(cache_notifier_refcount > 0);
+ if (!--cache_notifier_refcount) {
+ assert(netdev_linux_cache_notifier);
+ rtnetlink_link_notifier_destroy(netdev_linux_cache_notifier);
+ netdev_linux_cache_notifier = NULL;
+ }
+}
+
+/* Creates system and internal devices. */
+static int
+netdev_linux_create(const struct netdev_class *class, const char *name,
+ struct netdev_dev **netdev_devp)
+{
+ struct netdev_dev_linux *netdev_dev;
+ int error;
+
+ error = cache_notifier_ref();
+ if (error) {
+ return error;
+ }
+
netdev_dev = xzalloc(sizeof *netdev_dev);
netdev_dev->change_seq = 1;
netdev_dev_init(&netdev_dev->netdev_dev, name, class);
- get_carrier_via_sysfs(name, &netdev_dev->carrier);
+ get_flags(&netdev_dev->netdev_dev, &netdev_dev->ifi_flags);
*netdev_devp = &netdev_dev->netdev_dev;
return 0;
netdev_dev = xzalloc(sizeof *netdev_dev);
state = &netdev_dev->state.tap;
+ error = cache_notifier_ref();
+ if (error) {
+ goto error;
+ }
+
/* Open tap device. */
state->fd = open(tap_dev, O_RDWR);
if (state->fd < 0) {
error = errno;
VLOG_WARN("opening \"%s\" failed: %s", tap_dev, strerror(error));
- goto error;
+ goto error_unref_notifier;
}
/* Create tap device. */
VLOG_WARN("%s: creating tap device failed: %s", name,
strerror(errno));
error = errno;
- goto error;
+ goto error_unref_notifier;
}
/* Make non-blocking. */
error = set_nonblocking(state->fd);
if (error) {
- goto error;
+ goto error_unref_notifier;
}
netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class);
*netdev_devp = &netdev_dev->netdev_dev;
return 0;
+error_unref_notifier:
+ cache_notifier_unref();
error:
free(netdev_dev);
return error;
netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
}
- if (class == &netdev_linux_class || class == &netdev_internal_class) {
- cache_notifier_refcount--;
-
- if (!cache_notifier_refcount) {
- assert(netdev_linux_cache_notifier);
- rtnetlink_link_notifier_destroy(netdev_linux_cache_notifier);
- netdev_linux_cache_notifier = NULL;
- }
- } else if (class == &netdev_tap_class) {
+ if (class == &netdev_tap_class) {
destroy_tap(netdev_dev);
- } else {
- NOT_REACHED();
}
-
free(netdev_dev);
+
+ cache_notifier_unref();
}
static int
}
for (;;) {
- ssize_t retval = read(netdev->fd, data, size);
+ ssize_t retval = recv(netdev->fd, data, size, MSG_TRUNC);
if (retval >= 0) {
- return retval;
+ return retval <= size ? retval : -EMSGSIZE;
} else if (errno != EINTR) {
if (errno != EAGAIN) {
VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
struct ifreq ifr;
int error;
+ if (netdev_dev->cache_valid & VALID_MTU &&
+ netdev_dev->mtu == mtu) {
+ return 0;
+ }
ifr.ifr_mtu = mtu;
error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
SIOCSIFMTU, "SIOCSIFMTU");
if (netdev_dev->miimon_interval > 0) {
*carrier = netdev_dev->miimon;
} else {
- *carrier = netdev_dev->carrier;
+ *carrier = (netdev_dev->ifi_flags & IFF_RUNNING) != 0;
}
return 0;
netdev_linux_get_miimon(dev->netdev_dev.name, &miimon);
if (miimon != dev->miimon) {
dev->miimon = miimon;
- netdev_dev_linux_changed(dev);
+ netdev_dev_linux_changed(dev, dev->ifi_flags);
}
timer_set_duration(&dev->miimon_timer, dev->miimon_interval);
struct netdev_dev_linux *netdev_dev =
netdev_dev_linux_cast(netdev_get_dev(netdev_));
- if (netdev_dev->have_vport_stats ||
- !(netdev_dev->cache_valid & VALID_HAVE_VPORT_STATS)) {
+ if (!netdev_dev->vport_stats_error ||
+ !(netdev_dev->cache_valid & VALID_VPORT_STAT_ERROR)) {
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);
+ VLOG_WARN_RL(&rl, "%s: obtaining netdev stats via vport failed "
+ "(%s)", netdev_get_name(netdev_), strerror(error));
}
- netdev_dev->have_vport_stats = !error;
- netdev_dev->cache_valid |= VALID_HAVE_VPORT_STATS;
+ netdev_dev->vport_stats_error = error;
+ netdev_dev->cache_valid |= VALID_VPORT_STAT_ERROR;
}
}
error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
if (error) {
- if (!netdev_dev->have_vport_stats) {
+ if (netdev_dev->vport_stats_error) {
return error;
} else {
return 0;
}
}
- if (!netdev_dev->have_vport_stats) {
+ if (netdev_dev->vport_stats_error) {
/* stats not available from OVS then use ioctl stats. */
*stats = dev_stats;
} else {
/* Retrieves current device stats for 'netdev-tap' netdev or
* netdev-internal. */
static int
-netdev_pseudo_get_stats(const struct netdev *netdev_,
+netdev_tap_get_stats(const struct netdev *netdev_,
struct netdev_stats *stats)
{
struct netdev_dev_linux *netdev_dev =
error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
if (error) {
- if (!netdev_dev->have_vport_stats) {
+ if (netdev_dev->vport_stats_error) {
return error;
} else {
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. */
- if (!netdev_dev->have_vport_stats) {
+ if (netdev_dev->vport_stats_error) {
*stats = dev_stats;
swap_uint64(&stats->rx_packets, &stats->tx_packets);
swap_uint64(&stats->rx_bytes, &stats->tx_bytes);
return 0;
}
+static int
+netdev_internal_get_stats(const struct netdev *netdev_,
+ struct netdev_stats *stats)
+{
+ struct netdev_dev_linux *netdev_dev =
+ netdev_dev_linux_cast(netdev_get_dev(netdev_));
+
+ get_stats_via_vport(netdev_, stats);
+ return netdev_dev->vport_stats_error;
+}
+
/* Stores the features supported by 'netdev' into each of '*current',
* '*advertised', '*supported', and '*peer' that are non-null. Each value is a
- * bitmap of "enum ofp_port_features" bits, in host byte order. Returns 0 if
- * successful, otherwise a positive errno value. */
+ * bitmap of NETDEV_* bits. Returns 0 if successful, otherwise a positive
+ * errno value. */
static int
netdev_linux_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)
{
struct ethtool_cmd ecmd;
+ uint32_t speed;
int error;
memset(&ecmd, 0, sizeof ecmd);
/* Supported features. */
*supported = 0;
if (ecmd.supported & SUPPORTED_10baseT_Half) {
- *supported |= OFPPF_10MB_HD;
+ *supported |= NETDEV_F_10MB_HD;
}
if (ecmd.supported & SUPPORTED_10baseT_Full) {
- *supported |= OFPPF_10MB_FD;
+ *supported |= NETDEV_F_10MB_FD;
}
if (ecmd.supported & SUPPORTED_100baseT_Half) {
- *supported |= OFPPF_100MB_HD;
+ *supported |= NETDEV_F_100MB_HD;
}
if (ecmd.supported & SUPPORTED_100baseT_Full) {
- *supported |= OFPPF_100MB_FD;
+ *supported |= NETDEV_F_100MB_FD;
}
if (ecmd.supported & SUPPORTED_1000baseT_Half) {
- *supported |= OFPPF_1GB_HD;
+ *supported |= NETDEV_F_1GB_HD;
}
if (ecmd.supported & SUPPORTED_1000baseT_Full) {
- *supported |= OFPPF_1GB_FD;
+ *supported |= NETDEV_F_1GB_FD;
}
if (ecmd.supported & SUPPORTED_10000baseT_Full) {
- *supported |= OFPPF_10GB_FD;
+ *supported |= NETDEV_F_10GB_FD;
}
if (ecmd.supported & SUPPORTED_TP) {
- *supported |= OFPPF_COPPER;
+ *supported |= NETDEV_F_COPPER;
}
if (ecmd.supported & SUPPORTED_FIBRE) {
- *supported |= OFPPF_FIBER;
+ *supported |= NETDEV_F_FIBER;
}
if (ecmd.supported & SUPPORTED_Autoneg) {
- *supported |= OFPPF_AUTONEG;
+ *supported |= NETDEV_F_AUTONEG;
}
if (ecmd.supported & SUPPORTED_Pause) {
- *supported |= OFPPF_PAUSE;
+ *supported |= NETDEV_F_PAUSE;
}
if (ecmd.supported & SUPPORTED_Asym_Pause) {
- *supported |= OFPPF_PAUSE_ASYM;
+ *supported |= NETDEV_F_PAUSE_ASYM;
}
/* Advertised features. */
*advertised = 0;
if (ecmd.advertising & ADVERTISED_10baseT_Half) {
- *advertised |= OFPPF_10MB_HD;
+ *advertised |= NETDEV_F_10MB_HD;
}
if (ecmd.advertising & ADVERTISED_10baseT_Full) {
- *advertised |= OFPPF_10MB_FD;
+ *advertised |= NETDEV_F_10MB_FD;
}
if (ecmd.advertising & ADVERTISED_100baseT_Half) {
- *advertised |= OFPPF_100MB_HD;
+ *advertised |= NETDEV_F_100MB_HD;
}
if (ecmd.advertising & ADVERTISED_100baseT_Full) {
- *advertised |= OFPPF_100MB_FD;
+ *advertised |= NETDEV_F_100MB_FD;
}
if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
- *advertised |= OFPPF_1GB_HD;
+ *advertised |= NETDEV_F_1GB_HD;
}
if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
- *advertised |= OFPPF_1GB_FD;
+ *advertised |= NETDEV_F_1GB_FD;
}
if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
- *advertised |= OFPPF_10GB_FD;
+ *advertised |= NETDEV_F_10GB_FD;
}
if (ecmd.advertising & ADVERTISED_TP) {
- *advertised |= OFPPF_COPPER;
+ *advertised |= NETDEV_F_COPPER;
}
if (ecmd.advertising & ADVERTISED_FIBRE) {
- *advertised |= OFPPF_FIBER;
+ *advertised |= NETDEV_F_FIBER;
}
if (ecmd.advertising & ADVERTISED_Autoneg) {
- *advertised |= OFPPF_AUTONEG;
+ *advertised |= NETDEV_F_AUTONEG;
}
if (ecmd.advertising & ADVERTISED_Pause) {
- *advertised |= OFPPF_PAUSE;
+ *advertised |= NETDEV_F_PAUSE;
}
if (ecmd.advertising & ADVERTISED_Asym_Pause) {
- *advertised |= OFPPF_PAUSE_ASYM;
+ *advertised |= NETDEV_F_PAUSE_ASYM;
}
/* Current settings. */
- if (ecmd.speed == SPEED_10) {
- *current = ecmd.duplex ? OFPPF_10MB_FD : OFPPF_10MB_HD;
- } else if (ecmd.speed == SPEED_100) {
- *current = ecmd.duplex ? OFPPF_100MB_FD : OFPPF_100MB_HD;
- } else if (ecmd.speed == SPEED_1000) {
- *current = ecmd.duplex ? OFPPF_1GB_FD : OFPPF_1GB_HD;
- } else if (ecmd.speed == SPEED_10000) {
- *current = OFPPF_10GB_FD;
+ speed = ecmd.speed;
+ if (speed == SPEED_10) {
+ *current = ecmd.duplex ? NETDEV_F_10MB_FD : NETDEV_F_10MB_HD;
+ } else if (speed == SPEED_100) {
+ *current = ecmd.duplex ? NETDEV_F_100MB_FD : NETDEV_F_100MB_HD;
+ } else if (speed == SPEED_1000) {
+ *current = ecmd.duplex ? NETDEV_F_1GB_FD : NETDEV_F_1GB_HD;
+ } else if (speed == SPEED_10000) {
+ *current = NETDEV_F_10GB_FD;
+ } else if (speed == 40000) {
+ *current = NETDEV_F_40GB_FD;
+ } else if (speed == 100000) {
+ *current = NETDEV_F_100GB_FD;
+ } else if (speed == 1000000) {
+ *current = NETDEV_F_1TB_FD;
} else {
*current = 0;
}
if (ecmd.port == PORT_TP) {
- *current |= OFPPF_COPPER;
+ *current |= NETDEV_F_COPPER;
} else if (ecmd.port == PORT_FIBRE) {
- *current |= OFPPF_FIBER;
+ *current |= NETDEV_F_FIBER;
}
if (ecmd.autoneg) {
- *current |= OFPPF_AUTONEG;
+ *current |= NETDEV_F_AUTONEG;
}
/* Peer advertisements. */
/* Set the features advertised by 'netdev' to 'advertise'. */
static int
-netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise)
+netdev_linux_set_advertisements(struct netdev *netdev,
+ enum netdev_features advertise)
{
struct ethtool_cmd ecmd;
int error;
}
ecmd.advertising = 0;
- if (advertise & OFPPF_10MB_HD) {
+ if (advertise & NETDEV_F_10MB_HD) {
ecmd.advertising |= ADVERTISED_10baseT_Half;
}
- if (advertise & OFPPF_10MB_FD) {
+ if (advertise & NETDEV_F_10MB_FD) {
ecmd.advertising |= ADVERTISED_10baseT_Full;
}
- if (advertise & OFPPF_100MB_HD) {
+ if (advertise & NETDEV_F_100MB_HD) {
ecmd.advertising |= ADVERTISED_100baseT_Half;
}
- if (advertise & OFPPF_100MB_FD) {
+ if (advertise & NETDEV_F_100MB_FD) {
ecmd.advertising |= ADVERTISED_100baseT_Full;
}
- if (advertise & OFPPF_1GB_HD) {
+ if (advertise & NETDEV_F_1GB_HD) {
ecmd.advertising |= ADVERTISED_1000baseT_Half;
}
- if (advertise & OFPPF_1GB_FD) {
+ if (advertise & NETDEV_F_1GB_FD) {
ecmd.advertising |= ADVERTISED_1000baseT_Full;
}
- if (advertise & OFPPF_10GB_FD) {
+ if (advertise & NETDEV_F_10GB_FD) {
ecmd.advertising |= ADVERTISED_10000baseT_Full;
}
- if (advertise & OFPPF_COPPER) {
+ if (advertise & NETDEV_F_COPPER) {
ecmd.advertising |= ADVERTISED_TP;
}
- if (advertise & OFPPF_FIBER) {
+ if (advertise & NETDEV_F_FIBER) {
ecmd.advertising |= ADVERTISED_FIBRE;
}
- if (advertise & OFPPF_AUTONEG) {
+ if (advertise & NETDEV_F_AUTONEG) {
ecmd.advertising |= ADVERTISED_Autoneg;
}
- if (advertise & OFPPF_PAUSE) {
+ if (advertise & NETDEV_F_PAUSE) {
ecmd.advertising |= ADVERTISED_Pause;
}
- if (advertise & OFPPF_PAUSE_ASYM) {
+ if (advertise & NETDEV_F_PAUSE_ASYM) {
ecmd.advertising |= ADVERTISED_Asym_Pause;
}
return netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
ETHTOOL_SSET, "ETHTOOL_SSET");
}
-#define POLICE_ADD_CMD "/sbin/tc qdisc add dev %s handle ffff: ingress"
-#define POLICE_CONFIG_CMD "/sbin/tc filter add dev %s parent ffff: protocol ip prio 50 u32 match ip src 0.0.0.0/0 police rate %dkbit burst %dk mtu 65535 drop flowid :1"
-
-/* Remove ingress policing from 'netdev'. Returns 0 if successful, otherwise a
- * positive errno value.
- *
- * This function is equivalent to running
- * /sbin/tc qdisc del dev %s handle ffff: ingress
- * but it is much, much faster.
- */
-static int
-netdev_linux_remove_policing(struct netdev *netdev)
-{
- struct netdev_dev_linux *netdev_dev =
- netdev_dev_linux_cast(netdev_get_dev(netdev));
- const char *netdev_name = netdev_get_name(netdev);
-
- struct ofpbuf request;
- struct tcmsg *tcmsg;
- int error;
-
- tcmsg = tc_make_request(netdev, RTM_DELQDISC, 0, &request);
- if (!tcmsg) {
- return ENODEV;
- }
- tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
- tcmsg->tcm_parent = TC_H_INGRESS;
- nl_msg_put_string(&request, TCA_KIND, "ingress");
- nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
-
- error = tc_transact(&request, NULL);
- if (error && error != ENOENT && error != EINVAL) {
- VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
- netdev_name, strerror(error));
- return error;
- }
-
- netdev_dev->kbits_rate = 0;
- netdev_dev->kbits_burst = 0;
- netdev_dev->cache_valid |= VALID_POLICING;
- return 0;
-}
-
-/* Attempts to set input rate limiting (policing) policy. */
+/* Attempts to set input rate limiting (policing) policy. Returns 0 if
+ * successful, otherwise a positive errno value. */
static int
netdev_linux_set_policing(struct netdev *netdev,
uint32_t kbits_rate, uint32_t kbits_burst)
struct netdev_dev_linux *netdev_dev =
netdev_dev_linux_cast(netdev_get_dev(netdev));
const char *netdev_name = netdev_get_name(netdev);
- char command[1024];
+ int error;
- COVERAGE_INC(netdev_set_policing);
kbits_burst = (!kbits_rate ? 0 /* Force to 0 if no rate specified. */
: !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */
return 0;
}
- netdev_linux_remove_policing(netdev);
+ COVERAGE_INC(netdev_set_policing);
+ /* Remove any existing ingress qdisc. */
+ error = tc_add_del_ingress_qdisc(netdev, false);
+ if (error) {
+ VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
+ netdev_name, strerror(error));
+ return error;
+ }
+
if (kbits_rate) {
- snprintf(command, sizeof(command), POLICE_ADD_CMD, netdev_name);
- if (system(command) != 0) {
- VLOG_WARN_RL(&rl, "%s: problem adding policing", netdev_name);
- return -1;
+ error = tc_add_del_ingress_qdisc(netdev, true);
+ if (error) {
+ VLOG_WARN_RL(&rl, "%s: adding policing qdisc failed: %s",
+ netdev_name, strerror(error));
+ return error;
}
- snprintf(command, sizeof(command), POLICE_CONFIG_CMD, netdev_name,
- kbits_rate, kbits_burst);
- if (system(command) != 0) {
- VLOG_WARN_RL(&rl, "%s: problem configuring policing",
- netdev_name);
- return -1;
+ error = tc_add_policer(netdev, kbits_rate, kbits_burst);
+ if (error){
+ VLOG_WARN_RL(&rl, "%s: adding policing action failed: %s",
+ netdev_name, strerror(error));
+ return error;
}
-
- netdev_dev->kbits_rate = kbits_rate;
- netdev_dev->kbits_burst = kbits_burst;
- netdev_dev->cache_valid |= VALID_POLICING;
}
+ netdev_dev->kbits_rate = kbits_rate;
+ netdev_dev->kbits_burst = kbits_burst;
+ netdev_dev->cache_valid |= VALID_POLICING;
+
return 0;
}
netdev_linux_update_flags(struct netdev *netdev, enum netdev_flags off,
enum netdev_flags on, enum netdev_flags *old_flagsp)
{
+ struct netdev_dev_linux *netdev_dev;
int old_flags, new_flags;
- int error;
+ int error = 0;
- error = get_flags(netdev, &old_flags);
- if (!error) {
- *old_flagsp = iff_to_nd_flags(old_flags);
- new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
- if (new_flags != old_flags) {
- error = set_flags(netdev, new_flags);
- }
+ netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
+ old_flags = netdev_dev->ifi_flags;
+ *old_flagsp = iff_to_nd_flags(old_flags);
+ new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
+ if (new_flags != old_flags) {
+ error = set_flags(netdev, new_flags);
+ get_flags(&netdev_dev->netdev_dev, &netdev_dev->ifi_flags);
}
return error;
}
NETDEV_LINUX_CLASS(
"tap",
netdev_linux_create_tap,
- netdev_pseudo_get_stats,
+ netdev_tap_get_stats,
NULL); /* set_stats */
const struct netdev_class netdev_internal_class =
NETDEV_LINUX_CLASS(
"internal",
netdev_linux_create,
- netdev_pseudo_get_stats,
+ netdev_internal_get_stats,
netdev_vport_set_stats);
\f
/* HTB traffic control class. */
return error;
}
+/* Adds or deletes a root ingress qdisc on 'netdev'. We use this for
+ * policing configuration.
+ *
+ * This function is equivalent to running the following when 'add' is true:
+ * /sbin/tc qdisc add dev <devname> handle ffff: ingress
+ *
+ * This function is equivalent to running the following when 'add' is false:
+ * /sbin/tc qdisc del dev <devname> handle ffff: ingress
+ *
+ * The configuration and stats may be seen with the following command:
+ * /sbin/tc -s qdisc show dev <devname>
+ *
+ * Returns 0 if successful, otherwise a positive errno value.
+ */
+static int
+tc_add_del_ingress_qdisc(struct netdev *netdev, bool add)
+{
+ struct ofpbuf request;
+ struct tcmsg *tcmsg;
+ int error;
+ int type = add ? RTM_NEWQDISC : RTM_DELQDISC;
+ int flags = add ? NLM_F_EXCL | NLM_F_CREATE : 0;
+
+ tcmsg = tc_make_request(netdev, type, flags, &request);
+ if (!tcmsg) {
+ return ENODEV;
+ }
+ tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
+ tcmsg->tcm_parent = TC_H_INGRESS;
+ nl_msg_put_string(&request, TCA_KIND, "ingress");
+ nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
+
+ error = tc_transact(&request, NULL);
+ if (error) {
+ /* If we're deleting the qdisc, don't worry about some of the
+ * error conditions. */
+ if (!add && (error == ENOENT || error == EINVAL)) {
+ return 0;
+ }
+ return error;
+ }
+
+ return 0;
+}
+
+/* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
+ * of 'kbits_burst'.
+ *
+ * This function is equivalent to running:
+ * /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
+ * basic police rate <kbits_rate>kbit burst <kbits_burst>k
+ * mtu 65535 drop
+ *
+ * The configuration and stats may be seen with the following command:
+ * /sbin/tc -s filter show <devname> eth0 parent ffff:
+ *
+ * Returns 0 if successful, otherwise a positive errno value.
+ */
+static int
+tc_add_policer(struct netdev *netdev, int kbits_rate, int kbits_burst)
+{
+ struct tc_police tc_police;
+ struct ofpbuf request;
+ struct tcmsg *tcmsg;
+ size_t basic_offset;
+ size_t police_offset;
+ int error;
+ int mtu = 65535;
+
+ memset(&tc_police, 0, sizeof tc_police);
+ tc_police.action = TC_POLICE_SHOT;
+ tc_police.mtu = mtu;
+ tc_fill_rate(&tc_police.rate, kbits_rate/8 * 1000, mtu);
+ tc_police.burst = tc_bytes_to_ticks(tc_police.rate.rate,
+ kbits_burst * 1024);
+
+ tcmsg = tc_make_request(netdev, RTM_NEWTFILTER,
+ NLM_F_EXCL | NLM_F_CREATE, &request);
+ if (!tcmsg) {
+ return ENODEV;
+ }
+ tcmsg->tcm_parent = tc_make_handle(0xffff, 0);
+ tcmsg->tcm_info = tc_make_handle(49,
+ (OVS_FORCE uint16_t) htons(ETH_P_ALL));
+
+ nl_msg_put_string(&request, TCA_KIND, "basic");
+ basic_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
+ police_offset = nl_msg_start_nested(&request, TCA_BASIC_POLICE);
+ nl_msg_put_unspec(&request, TCA_POLICE_TBF, &tc_police, sizeof tc_police);
+ tc_put_rtab(&request, TCA_POLICE_RATE, &tc_police.rate);
+ nl_msg_end_nested(&request, police_offset);
+ nl_msg_end_nested(&request, basic_offset);
+
+ error = tc_transact(&request, NULL);
+ if (error) {
+ return error;
+ }
+
+ return 0;
+}
+
static void
read_psched(void)
{
\f
/* Linux-only functions declared in netdev-linux.h */
+/* Returns a fd for an AF_INET socket or a negative errno value. */
+int
+netdev_linux_get_af_inet_sock(void)
+{
+ int error = netdev_linux_init();
+ return error ? -error : af_inet_sock;
+}
+
/* Modifies the 'flag' bit in ethtool's flags field for 'netdev'. If
* 'enable' is true, the bit is set. Otherwise, it is cleared. */
int
}
static int
-get_carrier_via_sysfs(const char *name, bool *carrier)
-{
- char line[8];
- int retval;
-
- int error = 0;
- char *fn = NULL;
- int fd = -1;
-
- *carrier = false;
-
- fn = xasprintf("/sys/class/net/%s/carrier", name);
- fd = open(fn, O_RDONLY);
- if (fd < 0) {
- error = errno;
- VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(error));
- goto exit;
- }
-
- retval = read(fd, line, sizeof line);
- if (retval < 0) {
- error = errno;
- if (error == EINVAL) {
- /* This is the normal return value when we try to check carrier if
- * the network device is not up. */
- } else {
- VLOG_WARN_RL(&rl, "%s: read failed: %s", fn, strerror(error));
- }
- goto exit;
- } else if (retval == 0) {
- error = EPROTO;
- VLOG_WARN_RL(&rl, "%s: unexpected end of file", fn);
- goto exit;
- }
-
- if (line[0] != '0' && line[0] != '1') {
- error = EPROTO;
- VLOG_WARN_RL(&rl, "%s: value is %c (expected 0 or 1)", fn, line[0]);
- goto exit;
- }
- *carrier = line[0] != '0';
- error = 0;
-
-exit:
- if (fd >= 0) {
- close(fd);
- }
- free(fn);
- return error;
-}
-
-static int
-get_flags(const struct netdev *netdev, int *flags)
+get_flags(const struct netdev_dev *dev, unsigned int *flags)
{
struct ifreq ifr;
int error;
- error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCGIFFLAGS,
+ *flags = 0;
+ error = netdev_linux_do_ioctl(dev->name, &ifr, SIOCGIFFLAGS,
"SIOCGIFFLAGS");
- *flags = ifr.ifr_flags;
+ if (!error) {
+ *flags = ifr.ifr_flags;
+ }
return error;
}
static int
-set_flags(struct netdev *netdev, int flags)
+set_flags(struct netdev *netdev, unsigned int flags)
{
struct ifreq ifr;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff