From: Ben Pfaff Date: Wed, 2 Sep 2009 17:14:53 +0000 (-0700) Subject: Merge citrix branch into master. X-Git-Tag: v0.99.0~122 X-Git-Url: http://git.onelab.eu/?p=sliver-openvswitch.git;a=commitdiff_plain;h=f1acd62b54376a425a975f9af501c4c8c5689b39 Merge citrix branch into master. --- f1acd62b54376a425a975f9af501c4c8c5689b39 diff --cc extras/ezio/ovs-switchui.c index 721717eef,e83367d0f..0f6640e0c --- a/extras/ezio/ovs-switchui.c +++ b/extras/ezio/ovs-switchui.c @@@ -2480,7 -2480,7 +2480,7 @@@ choose_netdevs(struct svec *choices retval = netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev); if (!retval) { - bool exclude = netdev_get_in4(netdev, NULL) == 0; - bool exclude = netdev_get_in4(netdev, NULL, NULL); ++ bool exclude = netdev_get_in4(netdev, NULL, NULL) == 0; netdev_close(netdev); if (exclude) { continue; diff --cc lib/netdev-linux.c index 3e3404447,000000000..11d83e971 mode 100644,000000..100644 --- a/lib/netdev-linux.c +++ b/lib/netdev-linux.c @@@ -1,1593 -1,0 +1,1673 @@@ +/* + * Copyright (c) 2009 Nicira Networks. + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "coverage.h" +#include "dynamic-string.h" +#include "fatal-signal.h" +#include "netdev-provider.h" +#include "netlink.h" +#include "ofpbuf.h" +#include "openflow/openflow.h" +#include "packets.h" +#include "poll-loop.h" +#include "rtnetlink.h" +#include "socket-util.h" +#include "shash.h" +#include "svec.h" + +#define THIS_MODULE VLM_netdev_linux +#include "vlog.h" + +/* These were introduced in Linux 2.6.14, so they might be missing if we have + * old headers. */ +#ifndef ADVERTISED_Pause +#define ADVERTISED_Pause (1 << 13) +#endif +#ifndef ADVERTISED_Asym_Pause +#define ADVERTISED_Asym_Pause (1 << 14) +#endif + +struct netdev_linux { + struct netdev netdev; + + /* File descriptors. For ordinary network devices, the two fds below are + * the same; for tap devices, they differ. */ + int netdev_fd; /* Network device. */ + int tap_fd; /* TAP character device, if any, otherwise the + * network device. */ + + struct netdev_linux_cache *cache; +}; + +enum { + VALID_IFINDEX = 1 << 0, + VALID_ETHERADDR = 1 << 1, + VALID_IN4 = 1 << 2, + VALID_IN6 = 1 << 3, + VALID_MTU = 1 << 4, + VALID_CARRIER = 1 << 5 +}; + +/* Cached network device information. */ +struct netdev_linux_cache { + struct shash_node *shash_node; + unsigned int valid; + int ref_cnt; + + int ifindex; + uint8_t etheraddr[ETH_ADDR_LEN]; - struct in_addr in4; ++ struct in_addr address, netmask; + struct in6_addr in6; + int mtu; + int carrier; +}; + +static struct shash cache_map = SHASH_INITIALIZER(&cache_map); +static struct rtnetlink_notifier netdev_linux_cache_notifier; + +/* An AF_INET socket (used for ioctl operations). */ +static int af_inet_sock = -1; + +struct netdev_linux_notifier { + struct netdev_notifier notifier; + struct list node; +}; + +static struct shash netdev_linux_notifiers = + SHASH_INITIALIZER(&netdev_linux_notifiers); +static struct rtnetlink_notifier netdev_linux_poll_notifier; + +/* This is set pretty low because we probably won't learn anything from the + * additional log messages. */ +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20); + +static int netdev_linux_do_ethtool(struct netdev *, struct ethtool_cmd *, + int cmd, const char *cmd_name); +static int netdev_linux_do_ioctl(const struct netdev *, struct ifreq *, + int cmd, 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 do_get_ifindex(const char *netdev_name); +static int get_ifindex(const struct netdev *, int *ifindexp); +static int do_set_addr(struct netdev *netdev, + int ioctl_nr, const char *ioctl_name, + struct in_addr addr); +static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]); +static int set_etheraddr(const char *netdev_name, int hwaddr_family, + 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 struct netdev_linux * +netdev_linux_cast(const struct netdev *netdev) +{ + netdev_assert_class(netdev, &netdev_linux_class); + return CONTAINER_OF(netdev, struct netdev_linux, netdev); +} + +static int +netdev_linux_init(void) +{ + static int status = -1; + if (status < 0) { + af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0); + status = af_inet_sock >= 0 ? 0 : errno; + if (status) { + VLOG_ERR("failed to create inet socket: %s", strerror(status)); + } + } + return status; +} + +static void +netdev_linux_run(void) +{ + rtnetlink_notifier_run(); +} + +static void +netdev_linux_wait(void) +{ + rtnetlink_notifier_wait(); +} + +static void +netdev_linux_cache_cb(const struct rtnetlink_change *change, + void *aux UNUSED) +{ + struct netdev_linux_cache *cache; + if (change) { + cache = shash_find_data(&cache_map, change->ifname); + if (cache) { + cache->valid = 0; + } + } else { + struct shash_node *node; + SHASH_FOR_EACH (node, &cache_map) { + cache = node->data; + cache->valid = 0; + } + } +} + +static int +netdev_linux_open(const char *name, char *suffix, int ethertype, + struct netdev **netdevp) +{ + struct netdev_linux *netdev; + enum netdev_flags flags; + int error; + + /* Allocate network device. */ + netdev = xcalloc(1, sizeof *netdev); + netdev_init(&netdev->netdev, suffix, &netdev_linux_class); + netdev->netdev_fd = -1; + netdev->tap_fd = -1; + netdev->cache = shash_find_data(&cache_map, suffix); + if (!netdev->cache) { + if (shash_is_empty(&cache_map)) { + int error = rtnetlink_notifier_register( + &netdev_linux_cache_notifier, netdev_linux_cache_cb, NULL); + if (error) { + netdev_close(&netdev->netdev); + return error; + } + } + netdev->cache = xmalloc(sizeof *netdev->cache); + netdev->cache->shash_node = shash_add(&cache_map, suffix, + netdev->cache); + netdev->cache->valid = 0; + netdev->cache->ref_cnt = 0; + } + netdev->cache->ref_cnt++; + + if (!strncmp(name, "tap:", 4)) { + static const char tap_dev[] = "/dev/net/tun"; + struct ifreq ifr; + + /* Open tap device. */ + netdev->tap_fd = open(tap_dev, O_RDWR); + if (netdev->tap_fd < 0) { + error = errno; + VLOG_WARN("opening \"%s\" failed: %s", tap_dev, strerror(error)); + goto error; + } + + /* Create tap device. */ + ifr.ifr_flags = IFF_TAP | IFF_NO_PI; + error = netdev_linux_do_ioctl(&netdev->netdev, &ifr, + TUNSETIFF, "TUNSETIFF"); + if (error) { + goto error; + } + + /* Make non-blocking. */ + error = set_nonblocking(netdev->tap_fd); + if (error) { + goto error; + } + } + + error = netdev_get_flags(&netdev->netdev, &flags); + if (error == ENODEV) { + goto error; + } + + if (netdev->tap_fd >= 0 || ethertype != NETDEV_ETH_TYPE_NONE) { + struct sockaddr_ll sll; + int protocol; + int ifindex; + + /* Create file descriptor. */ + protocol = (ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL + : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2 + : ethertype); + netdev->netdev_fd = socket(PF_PACKET, SOCK_RAW, htons(protocol)); + if (netdev->netdev_fd < 0) { + error = errno; + goto error; + } + if (netdev->tap_fd < 0) { + netdev->tap_fd = netdev->netdev_fd; + } + + /* Set non-blocking mode. */ + error = set_nonblocking(netdev->netdev_fd); + if (error) { + goto error; + } + + /* Get ethernet device index. */ + error = get_ifindex(&netdev->netdev, &ifindex); + if (error) { + goto error; + } + + /* Bind to specific ethernet device. */ + memset(&sll, 0, sizeof sll); + sll.sll_family = AF_PACKET; + sll.sll_ifindex = ifindex; + if (bind(netdev->netdev_fd, + (struct sockaddr *) &sll, sizeof sll) < 0) { + error = errno; + VLOG_ERR("bind to %s failed: %s", suffix, strerror(error)); + goto error; + } + + /* Between the socket() and bind() calls above, the socket receives all + * packets of the requested type on all system interfaces. We do not + * want to receive that data, but there is no way to avoid it. So we + * must now drain out the receive queue. */ + error = drain_rcvbuf(netdev->netdev_fd); + if (error) { + goto error; + } + } + + *netdevp = &netdev->netdev; + return 0; + +error: + netdev_close(&netdev->netdev); + return error; +} + +/* Closes and destroys 'netdev'. */ +static void +netdev_linux_close(struct netdev *netdev_) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + + if (netdev->cache && !--netdev->cache->ref_cnt) { + shash_delete(&cache_map, netdev->cache->shash_node); + free(netdev->cache); + + if (shash_is_empty(&cache_map)) { + rtnetlink_notifier_unregister(&netdev_linux_cache_notifier); + } + } + if (netdev->netdev_fd >= 0) { + close(netdev->netdev_fd); + } + if (netdev->tap_fd >= 0 && netdev->netdev_fd != netdev->tap_fd) { + close(netdev->tap_fd); + } + free(netdev); +} + +/* Initializes 'svec' with a list of the names of all known network devices. */ +static int +netdev_linux_enumerate(struct svec *svec) +{ + struct if_nameindex *names; + + names = if_nameindex(); + if (names) { + size_t i; + + for (i = 0; names[i].if_name != NULL; i++) { + svec_add(svec, names[i].if_name); + } + if_freenameindex(names); + return 0; + } else { + VLOG_WARN("could not obtain list of network device names: %s", + strerror(errno)); + return errno; + } +} + +static int +netdev_linux_recv(struct netdev *netdev_, void *data, size_t size) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + + if (netdev->tap_fd < 0) { + /* Device was opened with NETDEV_ETH_TYPE_NONE. */ + return EAGAIN; + } + + for (;;) { + ssize_t retval = read(netdev->tap_fd, data, size); + if (retval >= 0) { + return retval; + } else if (errno != EINTR) { + if (errno != EAGAIN) { + VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s", + strerror(errno), netdev_get_name(netdev_)); + } + return errno; + } + } +} + +/* Registers with the poll loop to wake up from the next call to poll_block() + * when a packet is ready to be received with netdev_recv() on 'netdev'. */ +static void +netdev_linux_recv_wait(struct netdev *netdev_) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (netdev->tap_fd >= 0) { + poll_fd_wait(netdev->tap_fd, POLLIN); + } +} + +/* Discards all packets waiting to be received from 'netdev'. */ +static int +netdev_linux_drain(struct netdev *netdev_) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (netdev->tap_fd < 0 && netdev->netdev_fd < 0) { + return 0; + } else if (netdev->tap_fd != netdev->netdev_fd) { + struct ifreq ifr; + int error = netdev_linux_do_ioctl(netdev_, &ifr, + SIOCGIFTXQLEN, "SIOCGIFTXQLEN"); + if (error) { + return error; + } + drain_fd(netdev->tap_fd, ifr.ifr_qlen); + return 0; + } else { + return drain_rcvbuf(netdev->netdev_fd); + } +} + +/* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive + * errno value. Returns EAGAIN without blocking if the packet cannot be queued + * immediately. Returns EMSGSIZE if a partial packet was transmitted or if + * the packet is too big or too small to transmit on the device. + * + * The caller retains ownership of 'buffer' in all cases. + * + * The kernel maintains a packet transmission queue, so the caller is not + * expected to do additional queuing of packets. */ +static int +netdev_linux_send(struct netdev *netdev_, const void *data, size_t size) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + + /* XXX should support sending even if 'ethertype' was NETDEV_ETH_TYPE_NONE. + */ + if (netdev->tap_fd < 0) { + return EPIPE; + } + + for (;;) { + ssize_t retval = write(netdev->tap_fd, data, size); + if (retval < 0) { + /* The Linux AF_PACKET implementation never blocks waiting for room + * for packets, instead returning ENOBUFS. Translate this into + * EAGAIN for the caller. */ + if (errno == ENOBUFS) { + return EAGAIN; + } else if (errno == EINTR) { + continue; + } else if (errno != EAGAIN) { + VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s", + netdev_get_name(netdev_), strerror(errno)); + } + return errno; + } else if (retval != size) { + VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of " + "%zu) on %s", retval, size, netdev_get_name(netdev_)); + return EMSGSIZE; + } else { + return 0; + } + } +} + +/* Registers with the poll loop to wake up from the next call to poll_block() + * when the packet transmission queue has sufficient room to transmit a packet + * with netdev_send(). + * + * The kernel maintains a packet transmission queue, so the client is not + * expected to do additional queuing of packets. Thus, this function is + * unlikely to ever be used. It is included for completeness. */ +static void +netdev_linux_send_wait(struct netdev *netdev_) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (netdev->tap_fd < 0 && netdev->netdev_fd < 0) { + /* Nothing to do. */ + } else if (netdev->tap_fd == netdev->netdev_fd) { + poll_fd_wait(netdev->tap_fd, POLLOUT); + } else { + /* TAP device always accepts packets.*/ + poll_immediate_wake(); + } +} + +/* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful, + * otherwise a positive errno value. */ +static int +netdev_linux_set_etheraddr(struct netdev *netdev_, + const uint8_t mac[ETH_ADDR_LEN]) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + int error = set_etheraddr(netdev_get_name(netdev_), ARPHRD_ETHER, mac); + if (!error) { + memcpy(netdev->cache->etheraddr, mac, ETH_ADDR_LEN); + } + return error; +} + +/* Returns a pointer to 'netdev''s MAC address. The caller must not modify or + * free the returned buffer. */ +static int +netdev_linux_get_etheraddr(const struct netdev *netdev_, + uint8_t mac[ETH_ADDR_LEN]) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (!(netdev->cache->valid & VALID_ETHERADDR)) { + int error = get_etheraddr(netdev_get_name(netdev_), + netdev->cache->etheraddr); + if (error) { + return error; + } + netdev->cache->valid |= VALID_ETHERADDR; + } + memcpy(mac, netdev->cache->etheraddr, ETH_ADDR_LEN); + 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_linux_get_mtu(const struct netdev *netdev_, int *mtup) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (!(netdev->cache->valid & VALID_MTU)) { + struct ifreq ifr; + int error; + + error = netdev_linux_do_ioctl(netdev_, &ifr, SIOCGIFMTU, "SIOCGIFMTU"); + if (error) { + return error; + } + netdev->cache->mtu = ifr.ifr_mtu; + netdev->cache->valid |= VALID_MTU; + } + *mtup = netdev->cache->mtu; + return 0; +} + +static int +netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + int error = 0; + char *fn = NULL; + int fd = -1; + + if (!(netdev->cache->valid & VALID_CARRIER)) { + char line[8]; + int retval; + + fn = xasprintf("/sys/class/net/%s/carrier", netdev_get_name(netdev_)); + 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; + } + netdev->cache->carrier = line[0] != '0'; + netdev->cache->valid |= VALID_CARRIER; + } + *carrier = netdev->cache->carrier; + error = 0; + +exit: + if (fd >= 0) { + close(fd); + } + free(fn); + return error; +} + +/* Check whether we can we use RTM_GETLINK to get network device statistics. + * In pre-2.6.19 kernels, this was only available if wireless extensions were + * enabled. */ +static bool +check_for_working_netlink_stats(void) +{ + /* Decide on the netdev_get_stats() implementation to use. Netlink is + * preferable, so if that works, we'll use it. */ + int ifindex = do_get_ifindex("lo"); + if (ifindex < 0) { + VLOG_WARN("failed to get ifindex for lo, " + "obtaining netdev stats from proc"); + return false; + } else { + struct netdev_stats stats; + int error = get_stats_via_netlink(ifindex, &stats); + if (!error) { + VLOG_DBG("obtaining netdev stats via rtnetlink"); + return true; + } else { + VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats " + "via proc (you are probably running a pre-2.6.19 " + "kernel)", strerror(error)); + return false; + } + } +} + +/* Retrieves current device stats for 'netdev'. + * + * XXX All of the members of struct netdev_stats are 64 bits wide, but on + * 32-bit architectures the Linux network stats are only 32 bits. */ +static int +netdev_linux_get_stats(const struct netdev *netdev, struct netdev_stats *stats) +{ + static int use_netlink_stats = -1; + int error; + + COVERAGE_INC(netdev_get_stats); + 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); + } + } else { + error = get_stats_via_proc(netdev->name, stats); + } + return 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. On failure, all of the + * passed-in values are set to 0. */ +static int +netdev_linux_get_features(struct netdev *netdev, + uint32_t *current, uint32_t *advertised, + uint32_t *supported, uint32_t *peer) +{ + struct ethtool_cmd ecmd; + int error; + + memset(&ecmd, 0, sizeof ecmd); + error = netdev_linux_do_ethtool(netdev, &ecmd, + ETHTOOL_GSET, "ETHTOOL_GSET"); + if (error) { + return error; + } + + /* Supported features. */ + *supported = 0; + if (ecmd.supported & SUPPORTED_10baseT_Half) { + *supported |= OFPPF_10MB_HD; + } + if (ecmd.supported & SUPPORTED_10baseT_Full) { + *supported |= OFPPF_10MB_FD; + } + if (ecmd.supported & SUPPORTED_100baseT_Half) { + *supported |= OFPPF_100MB_HD; + } + if (ecmd.supported & SUPPORTED_100baseT_Full) { + *supported |= OFPPF_100MB_FD; + } + if (ecmd.supported & SUPPORTED_1000baseT_Half) { + *supported |= OFPPF_1GB_HD; + } + if (ecmd.supported & SUPPORTED_1000baseT_Full) { + *supported |= OFPPF_1GB_FD; + } + if (ecmd.supported & SUPPORTED_10000baseT_Full) { + *supported |= OFPPF_10GB_FD; + } + if (ecmd.supported & SUPPORTED_TP) { + *supported |= OFPPF_COPPER; + } + if (ecmd.supported & SUPPORTED_FIBRE) { + *supported |= OFPPF_FIBER; + } + if (ecmd.supported & SUPPORTED_Autoneg) { + *supported |= OFPPF_AUTONEG; + } + if (ecmd.supported & SUPPORTED_Pause) { + *supported |= OFPPF_PAUSE; + } + if (ecmd.supported & SUPPORTED_Asym_Pause) { + *supported |= OFPPF_PAUSE_ASYM; + } + + /* Advertised features. */ + *advertised = 0; + if (ecmd.advertising & ADVERTISED_10baseT_Half) { + *advertised |= OFPPF_10MB_HD; + } + if (ecmd.advertising & ADVERTISED_10baseT_Full) { + *advertised |= OFPPF_10MB_FD; + } + if (ecmd.advertising & ADVERTISED_100baseT_Half) { + *advertised |= OFPPF_100MB_HD; + } + if (ecmd.advertising & ADVERTISED_100baseT_Full) { + *advertised |= OFPPF_100MB_FD; + } + if (ecmd.advertising & ADVERTISED_1000baseT_Half) { + *advertised |= OFPPF_1GB_HD; + } + if (ecmd.advertising & ADVERTISED_1000baseT_Full) { + *advertised |= OFPPF_1GB_FD; + } + if (ecmd.advertising & ADVERTISED_10000baseT_Full) { + *advertised |= OFPPF_10GB_FD; + } + if (ecmd.advertising & ADVERTISED_TP) { + *advertised |= OFPPF_COPPER; + } + if (ecmd.advertising & ADVERTISED_FIBRE) { + *advertised |= OFPPF_FIBER; + } + if (ecmd.advertising & ADVERTISED_Autoneg) { + *advertised |= OFPPF_AUTONEG; + } + if (ecmd.advertising & ADVERTISED_Pause) { + *advertised |= OFPPF_PAUSE; + } + if (ecmd.advertising & ADVERTISED_Asym_Pause) { + *advertised |= OFPPF_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; + } else { + *current = 0; + } + + if (ecmd.port == PORT_TP) { + *current |= OFPPF_COPPER; + } else if (ecmd.port == PORT_FIBRE) { + *current |= OFPPF_FIBER; + } + + if (ecmd.autoneg) { + *current |= OFPPF_AUTONEG; + } + + /* Peer advertisements. */ + *peer = 0; /* XXX */ + + return 0; +} + +/* Set the features advertised by 'netdev' to 'advertise'. */ +static int +netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise) +{ + struct ethtool_cmd ecmd; + int error; + + memset(&ecmd, 0, sizeof ecmd); + error = netdev_linux_do_ethtool(netdev, &ecmd, + ETHTOOL_GSET, "ETHTOOL_GSET"); + if (error) { + return error; + } + + ecmd.advertising = 0; + if (advertise & OFPPF_10MB_HD) { + ecmd.advertising |= ADVERTISED_10baseT_Half; + } + if (advertise & OFPPF_10MB_FD) { + ecmd.advertising |= ADVERTISED_10baseT_Full; + } + if (advertise & OFPPF_100MB_HD) { + ecmd.advertising |= ADVERTISED_100baseT_Half; + } + if (advertise & OFPPF_100MB_FD) { + ecmd.advertising |= ADVERTISED_100baseT_Full; + } + if (advertise & OFPPF_1GB_HD) { + ecmd.advertising |= ADVERTISED_1000baseT_Half; + } + if (advertise & OFPPF_1GB_FD) { + ecmd.advertising |= ADVERTISED_1000baseT_Full; + } + if (advertise & OFPPF_10GB_FD) { + ecmd.advertising |= ADVERTISED_10000baseT_Full; + } + if (advertise & OFPPF_COPPER) { + ecmd.advertising |= ADVERTISED_TP; + } + if (advertise & OFPPF_FIBER) { + ecmd.advertising |= ADVERTISED_FIBRE; + } + if (advertise & OFPPF_AUTONEG) { + ecmd.advertising |= ADVERTISED_Autoneg; + } + if (advertise & OFPPF_PAUSE) { + ecmd.advertising |= ADVERTISED_Pause; + } + if (advertise & OFPPF_PAUSE_ASYM) { + ecmd.advertising |= ADVERTISED_Asym_Pause; + } + return netdev_linux_do_ethtool(netdev, &ecmd, + ETHTOOL_SSET, "ETHTOOL_SSET"); +} + +/* If 'netdev_name' is the name of 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. */ +static int +netdev_linux_get_vlan_vid(const struct netdev *netdev, int *vlan_vid) +{ + const char *netdev_name = netdev_get_name(netdev); + struct ds line = DS_EMPTY_INITIALIZER; + FILE *stream = NULL; + int error; + char *fn; + + COVERAGE_INC(netdev_get_vlan_vid); + fn = xasprintf("/proc/net/vlan/%s", netdev_name); + stream = fopen(fn, "r"); + if (!stream) { + error = errno; + goto done; + } + + if (ds_get_line(&line, stream)) { + if (ferror(stream)) { + error = errno; + VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno)); + } else { + error = EPROTO; + VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn); + } + goto done; + } + + if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) { + error = EPROTO; + VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"", + fn, ds_cstr(&line)); + goto done; + } + + error = 0; + +done: + free(fn); + if (stream) { + fclose(stream); + } + ds_destroy(&line); + if (error) { + *vlan_vid = -1; + } + return error; +} + +#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" +/* We redirect stderr to /dev/null because we often want to remove all + * traffic control configuration on a port so its in a known state. If + * this done when there is no such configuration, tc complains, so we just + * always ignore it. + */ +#define POLICE_DEL_CMD "/sbin/tc qdisc del dev %s handle ffff: ingress 2>/dev/null" + +/* Attempts to set input rate limiting (policing) policy. */ +static int +netdev_linux_set_policing(struct netdev *netdev, + uint32_t kbits_rate, uint32_t kbits_burst) +{ + const char *netdev_name = netdev_get_name(netdev); + char command[1024]; + + COVERAGE_INC(netdev_set_policing); + if (kbits_rate) { + if (!kbits_burst) { + /* Default to 10 kilobits if not specified. */ + kbits_burst = 10; + } + + /* xxx This should be more careful about only adding if it + * xxx actually exists, as opposed to always deleting it. */ + snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name); + if (system(command) == -1) { + VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name); + } + + 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; + } + + 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; + } + } else { + snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name); + if (system(command) == -1) { + VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name); + } + } + + return 0; +} + - /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address (if - * 'in4' is non-null) and returns true. Otherwise, returns false. */ +static int - netdev_linux_get_in4(const struct netdev *netdev_, struct in_addr *in4) ++netdev_linux_get_in4(const struct netdev *netdev_, ++ struct in_addr *address, struct in_addr *netmask) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (!(netdev->cache->valid & VALID_IN4)) { - const struct sockaddr_in *sin; - struct ifreq ifr; + int error; + - ifr.ifr_addr.sa_family = AF_INET; - error = netdev_linux_do_ioctl(netdev_, &ifr, ++ error = netdev_linux_get_ipv4(netdev_, &netdev->cache->address, + SIOCGIFADDR, "SIOCGIFADDR"); + if (error) { + return error; + } + - sin = (struct sockaddr_in *) &ifr.ifr_addr; - netdev->cache->in4 = sin->sin_addr; ++ error = netdev_linux_get_ipv4(netdev_, &netdev->cache->netmask, ++ SIOCGIFNETMASK, "SIOCGIFNETMASK"); ++ if (error) { ++ return error; ++ } ++ + netdev->cache->valid |= VALID_IN4; + } - *in4 = netdev->cache->in4; - return in4->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0; ++ *address = netdev->cache->address; ++ *netmask = netdev->cache->netmask; ++ return address->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0; +} + - /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask. If - * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared. Returns a - * positive errno value. */ +static int - netdev_linux_set_in4(struct netdev *netdev_, struct in_addr addr, - struct in_addr mask) ++netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address, ++ struct in_addr netmask) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + int error; + - error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", addr); ++ error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address); + if (!error) { + netdev->cache->valid |= VALID_IN4; - netdev->cache->in4 = addr; - if (addr.s_addr != INADDR_ANY) { ++ netdev->cache->address = address; ++ netdev->cache->netmask = netmask; ++ if (address.s_addr != INADDR_ANY) { + error = do_set_addr(netdev_, SIOCSIFNETMASK, - "SIOCSIFNETMASK", mask); ++ "SIOCSIFNETMASK", netmask); + } + } + return error; +} + +static bool +parse_if_inet6_line(const char *line, + struct in6_addr *in6, char ifname[16 + 1]) +{ + uint8_t *s6 = in6->s6_addr; +#define X8 "%2"SCNx8 + return sscanf(line, + " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 + "%*x %*x %*x %*x %16s\n", + &s6[0], &s6[1], &s6[2], &s6[3], + &s6[4], &s6[5], &s6[6], &s6[7], + &s6[8], &s6[9], &s6[10], &s6[11], + &s6[12], &s6[13], &s6[14], &s6[15], + ifname) == 17; +} + +/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if + * 'in6' is non-null) and returns true. Otherwise, returns false. */ +static int +netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + if (!(netdev->cache->valid & VALID_IN6)) { + FILE *file; + char line[128]; + + netdev->cache->in6 = in6addr_any; + + file = fopen("/proc/net/if_inet6", "r"); + if (file != NULL) { + const char *name = netdev_get_name(netdev_); + while (fgets(line, sizeof line, file)) { + struct in6_addr in6; + char ifname[16 + 1]; + if (parse_if_inet6_line(line, &in6, ifname) + && !strcmp(name, ifname)) + { + netdev->cache->in6 = in6; + break; + } + } + fclose(file); + } + netdev->cache->valid |= VALID_IN6; + } + *in6 = netdev->cache->in6; + return 0; +} + +static void +make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr) +{ + struct sockaddr_in sin; + memset(&sin, 0, sizeof sin); + sin.sin_family = AF_INET; + sin.sin_addr = addr; + sin.sin_port = 0; + + memset(sa, 0, sizeof *sa); + memcpy(sa, &sin, sizeof sin); +} + +static int +do_set_addr(struct netdev *netdev, + int ioctl_nr, const char *ioctl_name, struct in_addr addr) +{ + struct ifreq ifr; + strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name); + make_in4_sockaddr(&ifr.ifr_addr, addr); + return netdev_linux_do_ioctl(netdev, &ifr, ioctl_nr, ioctl_name); +} + +/* Adds 'router' as a default IP gateway. */ +static int +netdev_linux_add_router(struct netdev *netdev UNUSED, struct in_addr router) +{ + struct in_addr any = { INADDR_ANY }; + struct rtentry rt; + int error; + + memset(&rt, 0, sizeof rt); + make_in4_sockaddr(&rt.rt_dst, any); + make_in4_sockaddr(&rt.rt_gateway, router); + make_in4_sockaddr(&rt.rt_genmask, any); + rt.rt_flags = RTF_UP | RTF_GATEWAY; + COVERAGE_INC(netdev_add_router); + error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0; + if (error) { + VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error)); + } + return error; +} + ++static int ++netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop, ++ char **netdev_name) ++{ ++ static const char fn[] = "/proc/net/route"; ++ FILE *stream; ++ char line[256]; ++ int ln; ++ ++ *netdev_name = NULL; ++ stream = fopen(fn, "r"); ++ if (stream == NULL) { ++ VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno)); ++ return errno; ++ } ++ ++ ln = 0; ++ while (fgets(line, sizeof line, stream)) { ++ if (++ln >= 2) { ++ char iface[17]; ++ uint32_t dest, gateway, mask; ++ int refcnt, metric, mtu; ++ unsigned int flags, use, window, irtt; ++ ++ if (sscanf(line, ++ "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32 ++ " %d %u %u\n", ++ iface, &dest, &gateway, &flags, &refcnt, ++ &use, &metric, &mask, &mtu, &window, &irtt) != 11) { ++ ++ VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s", ++ fn, ln, line); ++ continue; ++ } ++ if (!(flags & RTF_UP)) { ++ /* Skip routes that aren't up. */ ++ continue; ++ } ++ ++ /* The output of 'dest', 'mask', and 'gateway' were given in ++ * network byte order, so we don't need need any endian ++ * conversions here. */ ++ if ((dest & mask) == (host->s_addr & mask)) { ++ if (!gateway) { ++ /* The host is directly reachable. */ ++ next_hop->s_addr = 0; ++ } else { ++ /* To reach the host, we must go through a gateway. */ ++ next_hop->s_addr = gateway; ++ } ++ *netdev_name = xstrdup(iface); ++ fclose(stream); ++ return 0; ++ } ++ } ++ } ++ ++ fclose(stream); ++ return ENXIO; ++} ++ +/* 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_linux_arp_lookup(const struct netdev *netdev, + uint32_t ip, uint8_t mac[ETH_ADDR_LEN]) +{ + struct arpreq r; + struct sockaddr_in *pa; + int retval; + + memset(&r, 0, sizeof r); + pa = (struct sockaddr_in *) &r.arp_pa; + pa->sin_family = AF_INET; + pa->sin_addr.s_addr = ip; + pa->sin_port = 0; + r.arp_ha.sa_family = ARPHRD_ETHER; + r.arp_flags = 0; + strncpy(r.arp_dev, netdev->name, sizeof r.arp_dev); + COVERAGE_INC(netdev_arp_lookup); + retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0; + if (!retval) { + memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN); + } else if (retval != ENXIO) { + VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s", + netdev->name, IP_ARGS(&ip), strerror(retval)); + } + return retval; +} + +static int +nd_to_iff_flags(enum netdev_flags nd) +{ + int iff = 0; + if (nd & NETDEV_UP) { + iff |= IFF_UP; + } + if (nd & NETDEV_PROMISC) { + iff |= IFF_PROMISC; + } + return iff; +} + +static int +iff_to_nd_flags(int iff) +{ + enum netdev_flags nd = 0; + if (iff & IFF_UP) { + nd |= NETDEV_UP; + } + if (iff & IFF_PROMISC) { + nd |= NETDEV_PROMISC; + } + return nd; +} + +static int +netdev_linux_update_flags(struct netdev *netdev, enum netdev_flags off, + enum netdev_flags on, enum netdev_flags *old_flagsp) +{ + int old_flags, new_flags; + int error; + + 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); + } + } + return error; +} + +static void +poll_notify(struct list *list) +{ + struct netdev_linux_notifier *notifier; + LIST_FOR_EACH (notifier, struct netdev_linux_notifier, node, list) { + struct netdev_notifier *n = ¬ifier->notifier; + n->cb(n); + } +} + +static void +netdev_linux_poll_cb(const struct rtnetlink_change *change, + void *aux UNUSED) +{ + if (change) { + struct list *list = shash_find_data(&netdev_linux_notifiers, + change->ifname); + if (list) { + poll_notify(list); + } + } else { + struct shash_node *node; + SHASH_FOR_EACH (node, &netdev_linux_notifiers) { + poll_notify(node->data); + } + } +} + +static int +netdev_linux_poll_add(struct netdev *netdev, + void (*cb)(struct netdev_notifier *), void *aux, + struct netdev_notifier **notifierp) +{ + const char *netdev_name = netdev_get_name(netdev); + struct netdev_linux_notifier *notifier; + struct list *list; + + if (shash_is_empty(&netdev_linux_notifiers)) { + int error = rtnetlink_notifier_register(&netdev_linux_poll_notifier, + netdev_linux_poll_cb, NULL); + if (error) { + return error; + } + } + + list = shash_find_data(&netdev_linux_notifiers, netdev_name); + if (!list) { + list = xmalloc(sizeof *list); + list_init(list); + shash_add(&netdev_linux_notifiers, netdev_name, list); + } + + notifier = xmalloc(sizeof *notifier); + netdev_notifier_init(¬ifier->notifier, netdev, cb, aux); + list_push_back(list, ¬ifier->node); + *notifierp = ¬ifier->notifier; + return 0; +} + +static void +netdev_linux_poll_remove(struct netdev_notifier *notifier_) +{ + struct netdev_linux_notifier *notifier = + CONTAINER_OF(notifier_, struct netdev_linux_notifier, notifier); + struct list *list; + + /* Remove 'notifier' from its list. */ + list = list_remove(¬ifier->node); + if (list_is_empty(list)) { + /* The list is now empty. Remove it from the hash and free it. */ + const char *netdev_name = netdev_get_name(notifier->notifier.netdev); + shash_delete(&netdev_linux_notifiers, + shash_find(&netdev_linux_notifiers, netdev_name)); + free(list); + } + free(notifier); + + /* If that was the last notifier, unregister. */ + if (shash_is_empty(&netdev_linux_notifiers)) { + rtnetlink_notifier_unregister(&netdev_linux_poll_notifier); + } +} + +const struct netdev_class netdev_linux_class = { + "", /* prefix */ + "linux", /* name */ + + netdev_linux_init, + netdev_linux_run, + netdev_linux_wait, + + netdev_linux_open, + netdev_linux_close, + + netdev_linux_enumerate, + + netdev_linux_recv, + netdev_linux_recv_wait, + netdev_linux_drain, + + netdev_linux_send, + netdev_linux_send_wait, + + netdev_linux_set_etheraddr, + netdev_linux_get_etheraddr, + netdev_linux_get_mtu, + netdev_linux_get_carrier, + netdev_linux_get_stats, + + netdev_linux_get_features, + netdev_linux_set_advertisements, + netdev_linux_get_vlan_vid, + netdev_linux_set_policing, + + netdev_linux_get_in4, + netdev_linux_set_in4, + netdev_linux_get_in6, + netdev_linux_add_router, ++ netdev_linux_get_next_hop, + netdev_linux_arp_lookup, + + netdev_linux_update_flags, + + netdev_linux_poll_add, + netdev_linux_poll_remove, +}; + +const struct netdev_class netdev_tap_class = { + "tap", /* prefix */ + "tap", /* name */ + + netdev_linux_init, + NULL, /* run */ + NULL, /* wait */ + + netdev_linux_open, + netdev_linux_close, + + netdev_linux_enumerate, + + netdev_linux_recv, + netdev_linux_recv_wait, + netdev_linux_drain, + + netdev_linux_send, + netdev_linux_send_wait, + + netdev_linux_set_etheraddr, + netdev_linux_get_etheraddr, + netdev_linux_get_mtu, + netdev_linux_get_carrier, + netdev_linux_get_stats, + + netdev_linux_get_features, + netdev_linux_set_advertisements, + netdev_linux_get_vlan_vid, + netdev_linux_set_policing, + + netdev_linux_get_in4, + netdev_linux_set_in4, + netdev_linux_get_in6, + netdev_linux_add_router, ++ netdev_linux_get_next_hop, + netdev_linux_arp_lookup, + + netdev_linux_update_flags, + + netdev_linux_poll_add, + netdev_linux_poll_remove, +}; + +static int +get_stats_via_netlink(int ifindex, struct netdev_stats *stats) +{ + /* Policy for RTNLGRP_LINK messages. + * + * There are *many* more fields in these messages, but currently we only + * care about these fields. */ + static const struct nl_policy rtnlgrp_link_policy[] = { + [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false }, + [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true, + .min_len = sizeof(struct rtnl_link_stats) }, + }; + + + static struct nl_sock *rtnl_sock; + struct ofpbuf request; + struct ofpbuf *reply; + struct ifinfomsg *ifi; + const struct rtnl_link_stats *rtnl_stats; + struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)]; + int error; + + if (!rtnl_sock) { + error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock); + if (error) { + VLOG_ERR_RL(&rl, "failed to create rtnetlink socket: %s", + strerror(error)); + return error; + } + } + + ofpbuf_init(&request, 0); + nl_msg_put_nlmsghdr(&request, rtnl_sock, sizeof *ifi, + RTM_GETLINK, NLM_F_REQUEST); + ifi = ofpbuf_put_zeros(&request, sizeof *ifi); + ifi->ifi_family = PF_UNSPEC; + ifi->ifi_index = ifindex; + error = nl_sock_transact(rtnl_sock, &request, &reply); + ofpbuf_uninit(&request); + if (error) { + return error; + } + + if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg), + rtnlgrp_link_policy, + attrs, ARRAY_SIZE(rtnlgrp_link_policy))) { + ofpbuf_delete(reply); + return EPROTO; + } + + if (!attrs[IFLA_STATS]) { + VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats"); + return EPROTO; + } + + rtnl_stats = nl_attr_get(attrs[IFLA_STATS]); + stats->rx_packets = rtnl_stats->rx_packets; + stats->tx_packets = rtnl_stats->tx_packets; + stats->rx_bytes = rtnl_stats->rx_bytes; + stats->tx_bytes = rtnl_stats->tx_bytes; + stats->rx_errors = rtnl_stats->rx_errors; + stats->tx_errors = rtnl_stats->tx_errors; + stats->rx_dropped = rtnl_stats->rx_dropped; + stats->tx_dropped = rtnl_stats->tx_dropped; + stats->multicast = rtnl_stats->multicast; + stats->collisions = rtnl_stats->collisions; + stats->rx_length_errors = rtnl_stats->rx_length_errors; + stats->rx_over_errors = rtnl_stats->rx_over_errors; + stats->rx_crc_errors = rtnl_stats->rx_crc_errors; + stats->rx_frame_errors = rtnl_stats->rx_frame_errors; + stats->rx_fifo_errors = rtnl_stats->rx_fifo_errors; + stats->rx_missed_errors = rtnl_stats->rx_missed_errors; + stats->tx_aborted_errors = rtnl_stats->tx_aborted_errors; + stats->tx_carrier_errors = rtnl_stats->tx_carrier_errors; + stats->tx_fifo_errors = rtnl_stats->tx_fifo_errors; + stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors; + stats->tx_window_errors = rtnl_stats->tx_window_errors; + + return 0; +} + +static int +get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats) +{ + static const char fn[] = "/proc/net/dev"; + char line[1024]; + FILE *stream; + int ln; + + stream = fopen(fn, "r"); + if (!stream) { + VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno)); + return errno; + } + + ln = 0; + while (fgets(line, sizeof line, stream)) { + if (++ln >= 3) { + char devname[16]; +#define X64 "%"SCNu64 + if (sscanf(line, + " %15[^:]:" + X64 X64 X64 X64 X64 X64 X64 "%*u" + X64 X64 X64 X64 X64 X64 X64 "%*u", + devname, + &stats->rx_bytes, + &stats->rx_packets, + &stats->rx_errors, + &stats->rx_dropped, + &stats->rx_fifo_errors, + &stats->rx_frame_errors, + &stats->multicast, + &stats->tx_bytes, + &stats->tx_packets, + &stats->tx_errors, + &stats->tx_dropped, + &stats->tx_fifo_errors, + &stats->collisions, + &stats->tx_carrier_errors) != 15) { + VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln); + } else if (!strcmp(devname, netdev_name)) { + stats->rx_length_errors = UINT64_MAX; + stats->rx_over_errors = UINT64_MAX; + stats->rx_crc_errors = UINT64_MAX; + stats->rx_missed_errors = UINT64_MAX; + stats->tx_aborted_errors = UINT64_MAX; + stats->tx_heartbeat_errors = UINT64_MAX; + stats->tx_window_errors = UINT64_MAX; + fclose(stream); + return 0; + } + } + } + VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name); + fclose(stream); + return ENODEV; +} + +static int +get_flags(const struct netdev *netdev, int *flags) +{ + struct ifreq ifr; + int error; + + error = netdev_linux_do_ioctl(netdev, &ifr, SIOCGIFFLAGS, "SIOCGIFFLAGS"); + *flags = ifr.ifr_flags; + return error; +} + +static int +set_flags(struct netdev *netdev, int flags) +{ + struct ifreq ifr; + + ifr.ifr_flags = flags; + return netdev_linux_do_ioctl(netdev, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS"); +} + +static int +do_get_ifindex(const char *netdev_name) +{ + struct ifreq ifr; + + strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name); + COVERAGE_INC(netdev_get_ifindex); + if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) { + VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s", + netdev_name, strerror(errno)); + return -errno; + } + return ifr.ifr_ifindex; +} + +static int +get_ifindex(const struct netdev *netdev_, int *ifindexp) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + *ifindexp = 0; + if (!(netdev->cache->valid & VALID_IFINDEX)) { + int ifindex = do_get_ifindex(netdev_get_name(netdev_)); + if (ifindex < 0) { + return -ifindex; + } + netdev->cache->valid |= VALID_IFINDEX; + netdev->cache->ifindex = ifindex; + } + *ifindexp = netdev->cache->ifindex; + return 0; +} + +static int +get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]) +{ + struct ifreq ifr; + int hwaddr_family; + + memset(&ifr, 0, sizeof ifr); + strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name); + COVERAGE_INC(netdev_get_hwaddr); + if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) { + VLOG_ERR("ioctl(SIOCGIFHWADDR) on %s device failed: %s", + netdev_name, strerror(errno)); + return errno; + } + hwaddr_family = ifr.ifr_hwaddr.sa_family; + if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) { + VLOG_WARN("%s device has unknown hardware address family %d", + netdev_name, hwaddr_family); + } + memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN); + return 0; +} + +static int +set_etheraddr(const char *netdev_name, int hwaddr_family, + const uint8_t mac[ETH_ADDR_LEN]) +{ + struct ifreq ifr; + + memset(&ifr, 0, sizeof ifr); + strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name); + ifr.ifr_hwaddr.sa_family = hwaddr_family; + memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN); + COVERAGE_INC(netdev_set_hwaddr); + if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) { + VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s", + netdev_name, strerror(errno)); + return errno; + } + return 0; +} + +static int +netdev_linux_do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd, + int cmd, const char *cmd_name) +{ + struct ifreq ifr; + + memset(&ifr, 0, sizeof ifr); + strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name); + ifr.ifr_data = (caddr_t) ecmd; + + ecmd->cmd = cmd; + COVERAGE_INC(netdev_ethtool); + if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) { + return 0; + } else { + if (errno != EOPNOTSUPP) { + VLOG_WARN_RL(&rl, "ethtool command %s on network device %s " + "failed: %s", cmd_name, netdev->name, + strerror(errno)); + } else { + /* The device doesn't support this operation. That's pretty + * common, so there's no point in logging anything. */ + } + return errno; + } +} + +static int +netdev_linux_do_ioctl(const struct netdev *netdev, struct ifreq *ifr, + int cmd, const char *cmd_name) +{ + strncpy(ifr->ifr_name, netdev_get_name(netdev), sizeof ifr->ifr_name); + if (ioctl(af_inet_sock, cmd, ifr) == -1) { + VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", + netdev_get_name(netdev), cmd_name, strerror(errno)); + return errno; + } + return 0; +} ++ ++static int ++netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip, ++ int cmd, const char *cmd_name) ++{ ++ struct ifreq ifr; ++ int error; ++ ++ ifr.ifr_addr.sa_family = AF_INET; ++ error = netdev_linux_do_ioctl(netdev, &ifr, cmd, cmd_name); ++ if (!error) { ++ const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr; ++ *ip = sin->sin_addr; ++ } ++ return error; ++} diff --cc lib/netdev-provider.h index 9c880b1c2,000000000..a573e2468 mode 100644,000000..100644 --- a/lib/netdev-provider.h +++ b/lib/netdev-provider.h @@@ -1,284 -1,0 +1,297 @@@ +/* + * Copyright (c) 2009 Nicira Networks. + * + * 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. + */ + +#ifndef NETDEV_PROVIDER_H +#define NETDEV_PROVIDER_H 1 + +/* Generic interface to network devices. */ + +#include +#include "netdev.h" +#include "list.h" + +/* A network device (e.g. an Ethernet device). + * + * This structure should be treated as opaque by network device + * implementations. */ +struct netdev { + const struct netdev_class *class; + char *name; /* e.g. "eth0" */ + enum netdev_flags save_flags; /* Initial device flags. */ + enum netdev_flags changed_flags; /* Flags that we changed. */ + struct list node; /* Element in global list. */ +}; + +void netdev_init(struct netdev *, const char *name, + const struct netdev_class *); +static inline void netdev_assert_class(const struct netdev *netdev, + const struct netdev_class *class) +{ + assert(netdev->class == class); +} + +/* A network device notifier. + * + * Network device implementations should use netdev_notifier_init() to + * initialize this structure, but they may freely read its members after + * initialization. */ +struct netdev_notifier { + struct netdev *netdev; + void (*cb)(struct netdev_notifier *); + void *aux; +}; +void netdev_notifier_init(struct netdev_notifier *, struct netdev *, + void (*cb)(struct netdev_notifier *), void *aux); + +/* Network device class structure, to be defined by each implementation of a + * network device. + * + * These functions return 0 if successful or a positive errno value on failure, + * except where otherwise noted. */ +struct netdev_class { + /* Prefix for names of netdevs in this class, e.g. "ndunix:". + * + * One netdev class may have the empty string "" as its prefix, in which + * case that netdev class is associated with netdev names that do not + * contain a colon. */ + const char *prefix; + + /* Class name, for use in error messages. */ + const char *name; + + /* Called only once, at program startup. Returning an error from this + * function will prevent any network device in this class from being + * opened. + * + * This function may be set to null if a network device class needs no + * initialization at program startup. */ + int (*init)(void); + + /* Performs periodic work needed by netdevs of this class. May be null if + * no periodic work is necessary. */ + void (*run)(void); + + /* Arranges for poll_block() to wake up if the "run" member function needs + * to be called. May be null if nothing is needed here. */ + void (*wait)(void); + + /* Attempts to open a network device. On success, sets '*netdevp' to the + * new network device. 'name' is the full network device name provided by + * the user. This name is useful for error messages but must not be + * modified. + * + * 'suffix' is a copy of 'name' following the netdev's 'prefix'. + * + * '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. */ + int (*open)(const char *name, char *suffix, int ethertype, + struct netdev **netdevp); + + /* Closes 'netdev'. */ + void (*close)(struct netdev *netdev); + + /* Enumerates the names of all network devices of this class. + * + * The caller has already initialized 'all_names' and might already have + * added some names to it. This function should not disturb any existing + * names in 'all_names'. + * + * If this netdev class does not support enumeration, this may be a null + * pointer. */ + int (*enumerate)(struct svec *all_anmes); + + /* Attempts to receive a packet from 'netdev' into the 'size' bytes in + * 'buffer'. If successful, returns the number of bytes in the received + * packet, otherwise a negative errno value. Returns -EAGAIN immediately + * if no packet is ready to be received. */ + int (*recv)(struct netdev *netdev, void *buffer, size_t size); + + /* Registers with the poll loop to wake up from the next call to + * poll_block() when a packet is ready to be received with netdev_recv() on + * 'netdev'. */ + void (*recv_wait)(struct netdev *netdev); + + /* Discards all packets waiting to be received from 'netdev'. */ + int (*drain)(struct netdev *netdev); + + /* Sends the 'size'-byte packet in 'buffer' on 'netdev'. Returns 0 if + * successful, otherwise a positive errno value. Returns EAGAIN without + * blocking if the packet cannot be queued immediately. Returns EMSGSIZE + * if a partial packet was transmitted or if the packet is too big or too + * small to transmit on the device. + * + * The caller retains ownership of 'buffer' in all cases. + * + * The network device is expected to maintain a packet transmission queue, + * so that the caller does not ordinarily have to do additional queuing of + * packets. */ + int (*send)(struct netdev *netdev, const void *buffer, size_t size); + + /* Registers with the poll loop to wake up from the next call to + * poll_block() when the packet transmission queue for 'netdev' has + * sufficient room to transmit a packet with netdev_send(). + * + * The network device is expected to maintain a packet transmission queue, + * so that the caller does not ordinarily have to do additional queuing of + * packets. Thus, this function is unlikely to ever be useful. */ + void (*send_wait)(struct netdev *netdev); + + /* Sets 'netdev''s Ethernet address to 'mac' */ + int (*set_etheraddr)(struct netdev *netdev, const uint8_t mac[6]); + + /* Retrieves 'netdev''s Ethernet address into 'mac'. */ + int (*get_etheraddr)(const struct netdev *netdev, uint8_t mac[6]); + + /* Retrieves 'netdev''s MTU into '*mtup'. + * + * The MTU is the maximum size of transmitted (and received) packets, in + * bytes, not including the hardware header; thus, this is typically 1500 + * bytes for Ethernet devices.*/ + int (*get_mtu)(const struct netdev *, int *mtup); + + /* Sets 'carrier' to true if carrier is active (link light is on) on + * 'netdev'. */ + int (*get_carrier)(const struct netdev *netdev, bool *carrier); + + /* Retrieves current device stats for 'netdev' into 'stats'. + * + * A network device that supports some statistics but not others, it should + * set the values of the unsupported statistics to all-1-bits + * (UINT64_MAX). */ + int (*get_stats)(const struct netdev *netdev, struct netdev_stats *stats); + + /* Stores the features supported by 'netdev' into each of '*current', + * '*advertised', '*supported', and '*peer'. Each value is a bitmap of + * "enum ofp_port_features" bits, in host byte order. */ + int (*get_features)(struct netdev *netdev, + uint32_t *current, uint32_t *advertised, + uint32_t *supported, uint32_t *peer); + + /* Set the features advertised by 'netdev' to 'advertise', which is a + * bitmap of "enum ofp_port_features" bits, in host byte order. + * + * This function may be set to null for a network device that does not + * support configuring advertisements. */ + int (*set_advertisements)(struct netdev *, uint32_t advertise); + + /* 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. + * + * Returns ENOENT if 'netdev_name' is the name of a network device that is + * not a VLAN device. + * + * This function should be set to null if it doesn't make any sense for + * your network device (it probably doesn't). */ + int (*get_vlan_vid)(const struct netdev *netdev, int *vlan_vid); + + /* Attempts to set input rate limiting (policing) policy, such that up to + * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative + * burst size of 'kbits' kb. + * + * This function may be set to null if policing is not supported. */ + int (*set_policing)(struct netdev *netdev, unsigned int kbits_rate, + unsigned int kbits_burst); + - /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address. ++ /* If 'netdev' has an assigned IPv4 address, sets '*address' to that ++ * address and '*netmask' to the associated netmask. + * + * The following error values have well-defined meanings: + * + * - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address. + * + * - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'. + * + * This function may be set to null if it would always return EOPNOTSUPP + * anyhow. */ - int (*get_in4)(const struct netdev *netdev, struct in_addr *in4); ++ int (*get_in4)(const struct netdev *netdev, struct in_addr *address, ++ struct in_addr *netmask); + + /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask. If + * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared. + * + * This function may be set to null if it would always return EOPNOTSUPP + * anyhow. */ + int (*set_in4)(struct netdev *, struct in_addr addr, struct in_addr mask); + + /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address. + * + * The following error values have well-defined meanings: + * + * - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address. + * + * - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'. + * + * This function may be set to null if it would always return EOPNOTSUPP + * anyhow. */ + int (*get_in6)(const struct netdev *netdev, struct in6_addr *in6); + + /* Adds 'router' as a default IP gateway for the TCP/IP stack that + * corresponds to 'netdev'. + * + * This function may be set to null if it would always return EOPNOTSUPP + * anyhow. */ + int (*add_router)(struct netdev *netdev, struct in_addr router); + ++ /* Looks up the next hop for 'host'. If succesful, 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()). ++ * ++ * This function may be set to null if it would always return EOPNOTSUPP ++ * anyhow. */ ++ int (*get_next_hop)(const struct in_addr *host, struct in_addr *next_hop, ++ char **netdev_name); ++ + /* Looks up the ARP table entry for 'ip' on 'netdev' and stores the + * corresponding MAC address in 'mac'. A return value of ENXIO, in + * particular, indicates that there is no ARP table entry for 'ip' on + * 'netdev'. + * + * This function may be set to null if it would always return EOPNOTSUPP + * anyhow. */ + int (*arp_lookup)(const struct netdev *, uint32_t ip, uint8_t mac[6]); + + /* 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.) + * + * This function may be invoked from a signal handler. Therefore, it + * should not do anything that is not signal-safe (such as logging). */ + int (*update_flags)(struct netdev *netdev, enum netdev_flags off, + enum netdev_flags on, enum netdev_flags *old_flags); + + /* Arranges for 'cb' to be called whenever one of the attributes of + * 'netdev' changes and sets '*notifierp' to a newly created + * netdev_notifier that represents this arrangement. The created notifier + * will have its 'netdev', 'cb', and 'aux' members set to the values of the + * corresponding parameters. */ + int (*poll_add)(struct netdev *netdev, + void (*cb)(struct netdev_notifier *), void *aux, + struct netdev_notifier **notifierp); + + /* Cancels poll notification for 'notifier'. */ + void (*poll_remove)(struct netdev_notifier *notifier); +}; + +extern const struct netdev_class netdev_linux_class; +extern const struct netdev_class netdev_tap_class; + +#endif /* netdev.h */ diff --cc lib/netdev.c index dcb63fa02,9a92a5f97..38610e115 --- a/lib/netdev.c +++ b/lib/netdev.c @@@ -386,33 -732,127 +386,39 @@@ netdev_get_features(struct netdev *netd int netdev_set_advertisements(struct netdev *netdev, uint32_t advertise) { - struct ethtool_cmd ecmd; - int error; - - memset(&ecmd, 0, sizeof ecmd); - error = do_ethtool(netdev, &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET"); - if (error) { - return error; - } - - ecmd.advertising = 0; - if (advertise & OFPPF_10MB_HD) { - ecmd.advertising |= ADVERTISED_10baseT_Half; - } - if (advertise & OFPPF_10MB_FD) { - ecmd.advertising |= ADVERTISED_10baseT_Full; - } - if (advertise & OFPPF_100MB_HD) { - ecmd.advertising |= ADVERTISED_100baseT_Half; - } - if (advertise & OFPPF_100MB_FD) { - ecmd.advertising |= ADVERTISED_100baseT_Full; - } - if (advertise & OFPPF_1GB_HD) { - ecmd.advertising |= ADVERTISED_1000baseT_Half; - } - if (advertise & OFPPF_1GB_FD) { - ecmd.advertising |= ADVERTISED_1000baseT_Full; - } - if (advertise & OFPPF_10GB_FD) { - ecmd.advertising |= ADVERTISED_10000baseT_Full; - } - if (advertise & OFPPF_COPPER) { - ecmd.advertising |= ADVERTISED_TP; - } - if (advertise & OFPPF_FIBER) { - ecmd.advertising |= ADVERTISED_FIBRE; - } - if (advertise & OFPPF_AUTONEG) { - ecmd.advertising |= ADVERTISED_Autoneg; - } - if (advertise & OFPPF_PAUSE) { - ecmd.advertising |= ADVERTISED_Pause; - } - if (advertise & OFPPF_PAUSE_ASYM) { - ecmd.advertising |= ADVERTISED_Asym_Pause; - } - return do_ethtool(netdev, &ecmd, ETHTOOL_SSET, "ETHTOOL_SSET"); -} - -/* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address - * and '*mask' to the netmask (if they are non-null) and returns true. - * Otherwise, returns false. */ -bool -netdev_nodev_get_in4(const char *netdev_name, struct in_addr *in4, - struct in_addr *mask) -{ - struct ifreq ifr; - struct in_addr ip = { INADDR_ANY }; - - init_netdev(); - - strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name); - ifr.ifr_addr.sa_family = AF_INET; - COVERAGE_INC(netdev_get_in4); - if (ioctl(af_inet_sock, SIOCGIFADDR, &ifr) == 0) { - struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr; - ip = sin->sin_addr; - } else { - VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFADDR) failed: %s", - netdev_name, strerror(errno)); - } - if (in4) { - *in4 = ip; - } - - if (mask) { - if (ioctl(af_inet_sock, SIOCGIFNETMASK, &ifr) == 0) { - struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr; - *mask = sin->sin_addr; - } else { - VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFNETMASK) failed: %s", - netdev_name, strerror(errno)); - } - } - - return ip.s_addr != INADDR_ANY; + return (netdev->class->set_advertisements + ? netdev->class->set_advertisements(netdev, advertise) + : EOPNOTSUPP); } - /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address and - * returns 0. Otherwise, returns a positive errno value and sets '*in4' to 0 - * (INADDR_ANY). -bool -netdev_get_in4(const struct netdev *netdev, struct in_addr *in4, struct - in_addr *mask) -{ - return netdev_nodev_get_in4(netdev->name, in4, mask); -} - -static void -make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr) -{ - struct sockaddr_in sin; - memset(&sin, 0, sizeof sin); - sin.sin_family = AF_INET; - sin.sin_addr = addr; - sin.sin_port = 0; - - memset(sa, 0, sizeof *sa); - memcpy(sa, &sin, sizeof sin); -} - -static int -do_set_addr(struct netdev *netdev, int sock, - int ioctl_nr, const char *ioctl_name, struct in_addr addr) ++/* If 'netdev' has an assigned IPv4 address, sets '*address' to that address ++ * and '*netmask' to its netmask and returns 0. Otherwise, returns a positive ++ * errno value and sets '*address' to 0 (INADDR_ANY). + * + * The following error values have well-defined meanings: + * + * - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address. + * + * - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'. + * - * 'in4' may be null, in which case the address itself is not reported. */ ++ * '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, struct in_addr *in4) ++netdev_get_in4(const struct netdev *netdev, ++ struct in_addr *address_, struct in_addr *netmask_) { - struct in_addr dummy; - struct ifreq ifr; ++ struct in_addr address; ++ struct in_addr netmask; int error; - strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name); - make_in4_sockaddr(&ifr.ifr_addr, addr); - COVERAGE_INC(netdev_set_in4); - error = ioctl(sock, ioctl_nr, &ifr) < 0 ? errno : 0; - if (error) { - VLOG_WARN("ioctl(%s): %s", ioctl_name, strerror(error)); + error = (netdev->class->get_in4 - ? netdev->class->get_in4(netdev, in4 ? in4 : &dummy) ++ ? netdev->class->get_in4(netdev, &address, &netmask) + : EOPNOTSUPP); - if (error && in4) { - in4->s_addr = 0; ++ if (address_) { ++ address_->s_addr = error ? 0 : address.s_addr; ++ } ++ if (netmask_) { ++ netmask_->s_addr = error ? 0 : netmask.s_addr; } return error; } @@@ -423,46 -863,69 +429,68 @@@ int netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask) { - int error; - - error = do_set_addr(netdev, af_inet_sock, - SIOCSIFADDR, "SIOCSIFADDR", addr); - if (!error && addr.s_addr != INADDR_ANY) { - error = do_set_addr(netdev, af_inet_sock, - SIOCSIFNETMASK, "SIOCSIFNETMASK", mask); - } - return error; + return (netdev->class->set_in4 + ? netdev->class->set_in4(netdev, addr, mask) + : EOPNOTSUPP); } -/* Adds 'router' as a default IP gateway. */ +/* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds + * to 'netdev'. */ int -netdev_add_router(struct in_addr router) +netdev_add_router(struct netdev *netdev, struct in_addr router) { - struct in_addr any = { INADDR_ANY }; - struct rtentry rt; - int error; - - memset(&rt, 0, sizeof rt); - make_in4_sockaddr(&rt.rt_dst, any); - make_in4_sockaddr(&rt.rt_gateway, router); - make_in4_sockaddr(&rt.rt_genmask, any); - rt.rt_flags = RTF_UP | RTF_GATEWAY; COVERAGE_INC(netdev_add_router); - error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0; + return (netdev->class->add_router + ? netdev->class->add_router(netdev, router) + : EOPNOTSUPP); +} + ++/* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to ++ * 'netdev'. If a route cannot not be determined, sets '*next_hop' to 0, ++ * '*netdev_name' to null, and returns a positive errno value. Otherwise, if a ++ * next hop is found, 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()). */ ++int ++netdev_get_next_hop(const struct netdev *netdev, ++ const struct in_addr *host, struct in_addr *next_hop, ++ char **netdev_name) ++{ ++ int error = (netdev->class->get_next_hop ++ ? netdev->class->get_next_hop(host, next_hop, netdev_name) ++ : EOPNOTSUPP); + if (error) { - VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error)); ++ next_hop->s_addr = 0; ++ *netdev_name = NULL; + } + return error; + } + -/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if - * 'in6' is non-null) and returns true. Otherwise, returns false. */ -bool -netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6) -{ - if (in6) { - *in6 = netdev->in6; - } - return memcmp(&netdev->in6, &in6addr_any, sizeof netdev->in6) != 0; -} - -/* Obtains the current flags for 'netdev' and stores them into '*flagsp'. - * Returns 0 if successful, otherwise a positive errno value. On failure, - * stores 0 into '*flagsp'. */ +/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and + * returns 0. Otherwise, returns a positive errno value and sets '*in6' to + * all-zero-bits (in6addr_any). + * + * The following error values have well-defined meanings: + * + * - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address. + * + * - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'. + * + * 'in6' may be null, in which case the address itself is not reported. */ int -netdev_get_flags(const struct netdev *netdev, enum netdev_flags *flagsp) +netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6) { - return netdev_nodev_get_flags(netdev->name, flagsp); -} + struct in6_addr dummy; + int error; -static int -nd_to_iff_flags(enum netdev_flags nd) -{ - int iff = 0; - if (nd & NETDEV_UP) { - iff |= IFF_UP; + error = (netdev->class->get_in6 + ? netdev->class->get_in6(netdev, in6 ? in6 : &dummy) + : EOPNOTSUPP); + if (error && in6) { + memset(in6, 0, sizeof *in6); } - if (nd & NETDEV_PROMISC) { - iff |= IFF_PROMISC; - } - return iff; + return error; } /* On 'netdev', turns off the flags in 'off' and then turns on the flags in @@@ -596,194 -1282,271 +624,194 @@@ in netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate, uint32_t kbits_burst) { - return netdev_nodev_set_policing(netdev->name, kbits_rate, kbits_burst); + return (netdev->class->set_policing + ? netdev->class->set_policing(netdev, kbits_rate, kbits_burst) + : EOPNOTSUPP); } -/* Initializes 'svec' with a list of the names of all known network devices. */ -void -netdev_enumerate(struct svec *svec) +/* 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) { - struct if_nameindex *names; - - svec_init(svec); - names = if_nameindex(); - if (names) { - size_t i; - - for (i = 0; names[i].if_name != NULL; i++) { - svec_add(svec, names[i].if_name); - } - if_freenameindex(names); - } else { - VLOG_WARN("could not obtain list of network device names: %s", - strerror(errno)); + int error = (netdev->class->get_vlan_vid + ? netdev->class->get_vlan_vid(netdev, vlan_vid) + : ENOENT); + if (error) { + *vlan_vid = 0; } + return error; } -/* Attempts to locate a device based on its IPv4 address. The caller - * may provide a hint as to the device by setting 'netdev_name' to a - * likely device name. This string must be malloc'd, since if it is - * not correct then it will be freed. If there is no hint, then - * 'netdev_name' must be the NULL pointer. - * - * If the device is found, the return value will be true and 'netdev_name' - * contains the device's name as a string, which the caller is responsible - * for freeing. If the device is not found, the return value is false. */ -bool -netdev_find_dev_by_in4(const struct in_addr *in4, char **netdev_name) +/* 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) { - int i; - struct in_addr dev_in4; + struct netdev *netdev; struct svec dev_list; + size_t i; - /* Check the hint first. */ - if (*netdev_name && (netdev_nodev_get_in4(*netdev_name, &dev_in4, NULL)) - && (dev_in4.s_addr == in4->s_addr)) { - return true; - } - - free(*netdev_name); - *netdev_name = NULL; netdev_enumerate(&dev_list); - - for (i=0; is_addr)) { - *netdev_name = xstrdup(dev_list.names[i]); - svec_destroy(&dev_list); - return true; + for (i = 0; i < dev_list.n; i++) { + const char *name = dev_list.names[i]; + struct in_addr dev_in4; + + if (!netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev) - && !netdev_get_in4(netdev, &dev_in4) ++ && !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 false; + return netdev; } - -/* Looks up the next hop for 'ip'. If the next hop can be found, the - * address is stored in 'next_hop'. If a gateway is not required to - * reach 'ip', zero is stored in 'next_hop'. In either case, zero is - * returned and a copy of the name of the device to reach 'ip' is stored - * in 'netdev_name', which the caller is responsible for freeing. If a - * route could not be determined, a positive errno is returned. */ -int -netdev_get_next_hop(const struct in_addr *host, struct in_addr *next_hop, - char **netdev_name) + +/* Initializes 'netdev' as a netdev named 'name' of the specified 'class'. + * + * This function adds 'netdev' to a netdev-owned linked list, so it is very + * important that 'netdev' only be freed after calling netdev_close(). */ +void +netdev_init(struct netdev *netdev, const char *name, + const struct netdev_class *class) { - static const char fn[] = "/proc/net/route"; - FILE *stream; - char line[256]; - int ln; - - *netdev_name = NULL; - stream = fopen(fn, "r"); - if (stream == NULL) { - VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno)); - return errno; - } - - ln = 0; - while (fgets(line, sizeof line, stream)) { - if (++ln >= 2) { - char iface[17]; - uint32_t dest, gateway, mask; - int refcnt, metric, mtu; - unsigned int flags, use, window, irtt; - - if (sscanf(line, - "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32 - " %d %u %u\n", - iface, &dest, &gateway, &flags, &refcnt, - &use, &metric, &mask, &mtu, &window, &irtt) != 11) { - - VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s", - fn, ln, line); - continue; - } - if (!(flags & RTF_UP)) { - /* Skip routes that aren't up. */ - continue; - } - - /* The output of 'dest', 'mask', and 'gateway' were given in - * network byte order, so we don't need need any endian - * conversions here. */ - if ((dest & mask) == (host->s_addr & mask)) { - if (!gateway) { - /* The host is directly reachable. */ - next_hop->s_addr = 0; - } else { - /* To reach the host, we must go through a gateway. */ - next_hop->s_addr = gateway; - } - *netdev_name = xstrdup(iface); - fclose(stream); - return 0; - } - } - } - - fclose(stream); - return ENXIO; + netdev->class = class; + netdev->name = xstrdup(name); + netdev->save_flags = 0; + netdev->changed_flags = 0; + list_push_back(&netdev_list, &netdev->node); } -/* Obtains the current flags for the network device named 'netdev_name' and - * stores them into '*flagsp'. Returns 0 if successful, otherwise a positive - * errno value. On error, stores 0 into '*flagsp'. - * - * If only device flags are needed, this is more efficient than calling - * netdev_open(), netdev_get_flags(), netdev_close(). */ -int -netdev_nodev_get_flags(const char *netdev_name, enum netdev_flags *flagsp) +/* 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) { - int error, flags; - - init_netdev(); - - *flagsp = 0; - error = get_flags(netdev_name, &flags); - if (error) { - return error; - } - - if (flags & IFF_UP) { - *flagsp |= NETDEV_UP; - } - if (flags & IFF_PROMISC) { - *flagsp |= NETDEV_PROMISC; - } - return 0; + notifier->netdev = netdev; + notifier->cb = cb; + notifier->aux = aux; } + +/* Tracks changes in the status of a set of network devices. */ +struct netdev_monitor { + struct shash polled_netdevs; + struct shash changed_netdevs; +}; -int -netdev_nodev_get_etheraddr(const char *netdev_name, uint8_t mac[6]) +/* Creates and returns a new structure for monitor changes in the status of + * network devices. */ +struct netdev_monitor * +netdev_monitor_create(void) { - init_netdev(); - - return get_etheraddr(netdev_name, mac, NULL); + struct netdev_monitor *monitor = xmalloc(sizeof *monitor); + shash_init(&monitor->polled_netdevs); + shash_init(&monitor->changed_netdevs); + return monitor; } -/* If 'netdev_name' is the name of 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 char *netdev_name, int *vlan_vid) +/* Destroys 'monitor'. */ +void +netdev_monitor_destroy(struct netdev_monitor *monitor) { - struct ds line = DS_EMPTY_INITIALIZER; - FILE *stream = NULL; - int error; - char *fn; - - COVERAGE_INC(netdev_get_vlan_vid); - fn = xasprintf("/proc/net/vlan/%s", netdev_name); - stream = fopen(fn, "r"); - if (!stream) { - error = errno; - goto done; - } + if (monitor) { + struct shash_node *node; - if (ds_get_line(&line, stream)) { - if (ferror(stream)) { - error = errno; - VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno)); - } else { - error = EPROTO; - VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn); + SHASH_FOR_EACH (node, &monitor->polled_netdevs) { + struct netdev_notifier *notifier = node->data; + notifier->netdev->class->poll_remove(notifier); } - goto done; - } - if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) { - error = EPROTO; - VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"", - fn, ds_cstr(&line)); - goto done; + shash_destroy(&monitor->polled_netdevs); + shash_destroy(&monitor->changed_netdevs); + free(monitor); } - - error = 0; - -done: - free(fn); - if (stream) { - fclose(stream); - } - ds_destroy(&line); - if (error) { - *vlan_vid = -1; - } - return error; } - -static void restore_all_flags(void *aux); -/* Set up a signal hook to restore network device flags on program - * termination. */ static void -init_netdev(void) +netdev_monitor_cb(struct netdev_notifier *notifier) { - static bool inited; - if (!inited) { - int ifindex; - int error; - - inited = true; - - fatal_signal_add_hook(restore_all_flags, NULL, true); + struct netdev_monitor *monitor = notifier->aux; + const char *name = netdev_get_name(notifier->netdev); + if (!shash_find(&monitor->changed_netdevs, name)) { + shash_add(&monitor->changed_netdevs, name, NULL); + } +} - af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0); - if (af_inet_sock < 0) { - ovs_fatal(errno, "socket(AF_INET)"); +/* 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->class->poll_add) + { + struct netdev_notifier *notifier; + error = 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; +} - error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock); - if (error) { - ovs_fatal(error, "socket(AF_NETLINK, NETLINK_ROUTE)"); +/* 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->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); } + } +} - /* Decide on the netdev_get_stats() implementation to use. Netlink is - * preferable, so if that works, we'll use it. */ - ifindex = do_get_ifindex("lo"); - if (ifindex < 0) { - VLOG_WARN("failed to get ifindex for lo, " - "obtaining netdev stats from proc"); - use_netlink_stats = false; - } else { - struct netdev_stats stats; - error = get_stats_via_netlink(ifindex, &stats); - if (!error) { - VLOG_DBG("obtaining netdev stats via rtnetlink"); - use_netlink_stats = true; - } else { - VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats " - "via proc (you are probably running a pre-2.6.19 " - "kernel)", strerror(error)); - use_netlink_stats = false; - } - } +/* 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 = xstrdup(node->name); + shash_delete(&monitor->changed_netdevs, node); + return 0; } } diff --cc lib/netdev.h index b66d7bc0b,84ae16ee4..4a29cf374 --- a/lib/netdev.h +++ b/lib/netdev.h @@@ -106,13 -90,11 +106,16 @@@ int netdev_get_features(struct netdev * uint32_t *current, uint32_t *advertised, uint32_t *supported, uint32_t *peer); int netdev_set_advertisements(struct netdev *, uint32_t advertise); -bool netdev_get_in4(const struct netdev *, struct in_addr *addr, - struct in_addr *mask); -int netdev_set_in4(struct netdev *, struct in_addr in4, struct in_addr mask); -int netdev_add_router(struct in_addr router); -bool netdev_get_in6(const struct netdev *, struct in6_addr *); + - int netdev_get_in4(const struct netdev *, struct in_addr *); ++int netdev_get_in4(const struct netdev *, struct in_addr *address, ++ struct in_addr *netmask); +int netdev_set_in4(struct netdev *, struct in_addr addr, struct in_addr mask); +int netdev_get_in6(const struct netdev *, struct in6_addr *); +int netdev_add_router(struct netdev *, struct in_addr router); ++int netdev_get_next_hop(const struct netdev *, const struct in_addr *host, ++ struct in_addr *next_hop, char **); +int netdev_arp_lookup(const struct netdev *, uint32_t ip, uint8_t mac[6]); + int netdev_get_flags(const struct netdev *, enum netdev_flags *); int netdev_set_flags(struct netdev *, enum netdev_flags, bool permanent); int netdev_turn_flags_on(struct netdev *, enum netdev_flags, bool permanent); diff --cc ofproto/in-band.c index a08af0796,fa77a254d..18415f48e --- a/ofproto/in-band.c +++ b/ofproto/in-band.c @@@ -69,17 -73,16 +73,17 @@@ struct in_band struct rconn *controller; struct status_category *ss_cat; - /* Keeping track of controller's MAC address. */ - uint32_t ip; /* Current IP, 0 if unknown. */ - uint32_t last_ip; /* Last known IP, 0 if never known. */ - uint8_t mac[ETH_ADDR_LEN]; /* Current MAC, 0 if unknown. */ - uint8_t last_mac[ETH_ADDR_LEN]; /* Last known MAC, 0 if never known */ - struct netdev *netdev; - time_t next_refresh; /* Next time to refresh MAC address. */ + /* Keep track of local port's information. */ + uint8_t local_mac[ETH_ADDR_LEN]; /* Current MAC. */ - char local_name[IF_NAMESIZE]; /* Local device name. */ ++ struct netdev *local_netdev; /* Local port's network device. */ + time_t next_local_refresh; - /* Keeping track of the local port's MAC address. */ - uint8_t local_mac[ETH_ADDR_LEN]; /* Current MAC. */ - time_t next_local_refresh; /* Next time to refresh MAC address. */ + /* Keep track of controller and next hop's information. */ + uint32_t controller_ip; /* Controller IP, 0 if unknown. */ + uint8_t remote_mac[ETH_ADDR_LEN]; /* Remote MAC. */ ++ struct netdev *remote_netdev; + uint8_t last_remote_mac[ETH_ADDR_LEN]; /* Previous remote MAC. */ + time_t next_remote_refresh; /* Rules that we set up. */ struct ib_rule rules[N_IB_RULES]; @@@ -88,58 -91,44 +92,64 @@@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60); static const uint8_t * - get_controller_mac(struct in_band *ib) + get_remote_mac(struct in_band *ib) { + int retval; + bool have_mac; - struct in_addr c_in4, r_in4; - char *dev_name; ++ struct in_addr c_in4; /* Controller's IP address. */ ++ struct in_addr r_in4; /* Next hop IP address. */ ++ char *next_hop_dev; time_t now = time_now(); - uint32_t controller_ip; - controller_ip = rconn_get_remote_ip(ib->controller); - if (controller_ip != ib->ip || now >= ib->next_refresh) { - bool have_mac; - - ib->ip = controller_ip; - - /* Look up MAC address. */ - memset(ib->mac, 0, sizeof ib->mac); - if (ib->ip) { - struct in_addr local_in4 = { rconn_get_local_ip(ib->controller) }; - struct in_addr in4; - int retval; - - /* Refresh device with IP address 'in4'. */ - if (!ib->netdev - || netdev_get_in4(ib->netdev, &in4) - || in4.s_addr != local_in4.s_addr) - { - netdev_close(ib->netdev); - ib->netdev = netdev_find_dev_by_in4(&local_in4); - } + if (now >= ib->next_remote_refresh) { ++ /* Find the next-hop IP address. */ + c_in4.s_addr = ib->controller_ip; + memset(ib->remote_mac, 0, sizeof ib->remote_mac); - retval = netdev_get_next_hop(&c_in4, &r_in4, &dev_name); ++ retval = netdev_get_next_hop(ib->local_netdev, ++ &c_in4, &r_in4, &next_hop_dev); + if (retval) { + VLOG_WARN("cannot find route for controller ("IP_FMT"): %s", + IP_ARGS(&ib->controller_ip), strerror(retval)); + ib->next_remote_refresh = now + 1; + return NULL; + } + if (!r_in4.s_addr) { + r_in4.s_addr = c_in4.s_addr; + } - if (ib->netdev) { - retval = netdev_arp_lookup(ib->netdev, ib->ip, ib->mac); - if (retval) { - VLOG_DBG_RL(&rl, "cannot look up controller MAC address " - "("IP_FMT"): %s", - IP_ARGS(&ib->ip), strerror(retval)); - } - } else { - VLOG_DBG_RL(&rl, "cannot find device with IP address "IP_FMT, - IP_ARGS(&local_in4.s_addr)); - retval = netdev_nodev_arp_lookup(dev_name, r_in4.s_addr, - ib->remote_mac); ++ /* Get the next-hop IP and network device. */ ++ if (!ib->remote_netdev ++ || strcmp(netdev_get_name(ib->remote_netdev), next_hop_dev)) ++ { ++ netdev_close(ib->remote_netdev); ++ retval = netdev_open(next_hop_dev, NETDEV_ETH_TYPE_NONE, ++ &ib->remote_netdev); ++ if (retval) { ++ VLOG_WARN_RL(&rl, "cannot open netdev %s (next hop " ++ "to controller "IP_FMT"): %s", ++ next_hop_dev, IP_ARGS(&ib->controller_ip), ++ strerror(retval)); ++ ib->next_remote_refresh = now + 1; ++ return NULL; + } + } - have_mac = !eth_addr_is_zero(ib->mac); + - /* Log changes in IP, MAC addresses. */ - if (ib->ip && ib->ip != ib->last_ip) { - VLOG_DBG("controller IP address changed from "IP_FMT - " to "IP_FMT, IP_ARGS(&ib->last_ip), IP_ARGS(&ib->ip)); - ib->last_ip = ib->ip; ++ /* Look up the MAC address of the next-hop IP address. */ ++ retval = netdev_arp_lookup(ib->remote_netdev, r_in4.s_addr, ++ ib->remote_mac); + if (retval) { + VLOG_DBG_RL(&rl, "cannot look up remote MAC address ("IP_FMT"): %s", + IP_ARGS(&r_in4.s_addr), strerror(retval)); } - if (have_mac && memcmp(ib->last_mac, ib->mac, ETH_ADDR_LEN)) { - VLOG_DBG("controller MAC address changed from "ETH_ADDR_FMT" to " + have_mac = !eth_addr_is_zero(ib->remote_mac); - free(dev_name); - - if (have_mac - && !eth_addr_equals(ib->last_remote_mac, ib->remote_mac)) { ++ free(next_hop_dev); ++ if (have_mac ++ && !eth_addr_equals(ib->last_remote_mac, ib->remote_mac)) { + VLOG_DBG("remote MAC address changed from "ETH_ADDR_FMT" to " ETH_ADDR_FMT, - ETH_ADDR_ARGS(ib->last_mac), ETH_ADDR_ARGS(ib->mac)); - memcpy(ib->last_mac, ib->mac, ETH_ADDR_LEN); + ETH_ADDR_ARGS(ib->last_remote_mac), + ETH_ADDR_ARGS(ib->remote_mac)); + memcpy(ib->last_remote_mac, ib->remote_mac, ETH_ADDR_LEN); } /* Schedule next refresh. @@@ -158,7 -149,7 +170,7 @@@ get_local_mac(struct in_band *ib time_t now = time_now(); if (now >= ib->next_local_refresh) { uint8_t ea[ETH_ADDR_LEN]; - if (ib->netdev && !netdev_get_etheraddr(ib->netdev, ea)) { - if (!netdev_nodev_get_etheraddr(ib->local_name, ea)) { ++ if (ib->local_netdev && netdev_get_etheraddr(ib->local_netdev, ea)) { memcpy(ib->local_mac, ea, ETH_ADDR_LEN); } ib->next_local_refresh = now + 1; @@@ -327,22 -428,30 +449,44 @@@ in_band_flushed(struct in_band *in_band } } --void - in_band_create(struct ofproto *ofproto, struct switch_status *ss, - struct rconn *controller, struct in_band **in_bandp) ++int + in_band_create(struct ofproto *ofproto, struct dpif *dpif, + struct switch_status *ss, struct rconn *controller, + struct in_band **in_bandp) { struct in_band *in_band; ++ char local_name[IF_NAMESIZE]; ++ struct netdev *local_netdev; + int error; + - in_band = xcalloc(1, sizeof *in_band); - error = dpif_port_get_name(dpif, ODPP_LOCAL, in_band->local_name, - sizeof in_band->local_name); ++ error = dpif_port_get_name(dpif, ODPP_LOCAL, ++ local_name, sizeof local_name); + if (error) { - free(in_band); - return; ++ VLOG_ERR("failed to initialize in-band control: cannot get name " ++ "of datapath local port (%s)", strerror(error)); ++ return error; + } + ++ error = netdev_open(local_name, NETDEV_ETH_TYPE_NONE, &local_netdev); ++ if (error) { ++ VLOG_ERR("failed to initialize in-band control: cannot open " ++ "datapath local port %s (%s)", local_name, strerror(error)); ++ return error; ++ } + + in_band = xcalloc(1, sizeof *in_band); in_band->ofproto = ofproto; in_band->controller = controller; in_band->ss_cat = switch_status_register(ss, "in-band", in_band_status_cb, in_band); - in_band->next_refresh = TIME_MIN; - in_band->next_remote_refresh = TIME_MIN; ++ in_band->local_netdev = local_netdev; in_band->next_local_refresh = TIME_MIN; - in_band->netdev = NULL; ++ in_band->remote_netdev = NULL; ++ in_band->next_remote_refresh = TIME_MIN; *in_bandp = in_band; ++ ++ return 0; } void @@@ -350,7 -459,6 +494,8 @@@ in_band_destroy(struct in_band *in_band { if (in_band) { switch_status_unregister(in_band->ss_cat); - netdev_close(in_band->netdev); ++ netdev_close(in_band->local_netdev); ++ netdev_close(in_band->remote_netdev); /* We don't own the rconn. */ } } diff --cc ofproto/in-band.h index 624bee9e3,736ad7648..ddbc5e563 --- a/ofproto/in-band.h +++ b/ofproto/in-band.h @@@ -21,15 -21,21 +21,20 @@@ struct dpif; struct in_band; + struct odp_actions; struct ofproto; struct rconn; -struct secchan; struct settings; struct switch_status; - void in_band_create(struct ofproto *, struct switch_status *, -void in_band_create(struct ofproto *, struct dpif *, struct switch_status *, -- struct rconn *controller, struct in_band **); ++int in_band_create(struct ofproto *, struct dpif *, struct switch_status *, ++ struct rconn *controller, struct in_band **); void in_band_destroy(struct in_band *); void in_band_run(struct in_band *); + bool in_band_msg_in_hook(struct in_band *, const flow_t *, + const struct ofpbuf *packet); + bool in_band_rule_check(struct in_band *, const flow_t *, + const struct odp_actions *); void in_band_wait(struct in_band *); void in_band_flushed(struct in_band *); diff --cc ofproto/ofproto.c index dbaa75bc1,6097d57f1..7650068e8 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@@ -424,9 -433,9 +424,8 @@@ ofproto_set_in_band(struct ofproto *p, { if (in_band != (p->in_band != NULL)) { if (in_band) { - in_band_create(p, p->switch_status, p->controller->rconn, - &p->in_band); - in_band_create(p, &p->dpif, p->switch_status, - p->controller->rconn, &p->in_band); -- return 0; ++ return in_band_create(p, p->dpif, p->switch_status, ++ p->controller->rconn, &p->in_band); } else { ofproto_set_discovery(p, false, NULL, true); in_band_destroy(p->in_band); @@@ -3028,6 -3031,17 +3034,17 @@@ handle_odp_msg(struct ofproto *p, struc payload.size = msg->length - sizeof *msg; flow_extract(&payload, msg->port, &flow); + /* Check with in-band control to see if this packet should be sent + * to the local port regardless of the flow table. */ + if (in_band_msg_in_hook(p->in_band, &flow, &payload)) { + union odp_action action; + + memset(&action, 0, sizeof(action)); + action.output.type = ODPAT_OUTPUT; + action.output.port = ODPP_LOCAL; - dpif_execute(&p->dpif, flow.in_port, &action, 1, &payload); ++ dpif_execute(p->dpif, flow.in_port, &action, 1, &payload); + } + rule = lookup_valid_rule(p, &flow); if (!rule) { /* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */