X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev-linux.c;h=e9fabc5b8083b067a23ae94b7405fba5e8c4fe50;hb=43694e2a8d950f62781ec6dc613b5dac32de35fd;hp=6189bf79065a834ef0ed382671fafcc1996a4776;hpb=8b61709d5ec6c4ef58a04fcaefde617ff63fa10d;p=sliver-openvswitch.git diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c index 6189bf790..e9fabc5b8 100644 --- a/lib/netdev-linux.c +++ b/lib/netdev-linux.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009 Nicira Networks. + * Copyright (c) 2009, 2010 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,17 +15,16 @@ */ #include - -#include "netdev-linux.h" - #include #include #include #include #include #include +#include #include #include +#include #include #include #include @@ -35,6 +34,7 @@ #include #include #include +#include #include #include #include @@ -51,8 +51,11 @@ #include "netlink.h" #include "ofpbuf.h" #include "openflow/openflow.h" +#include "openvswitch/internal_dev.h" +#include "openvswitch/gre.h" #include "packets.h" #include "poll-loop.h" +#include "rtnetlink.h" #include "socket-util.h" #include "shash.h" #include "svec.h" @@ -69,17 +72,8 @@ #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; -}; +static struct rtnetlink_notifier netdev_linux_cache_notifier; +static int cache_notifier_refcount; enum { VALID_IFINDEX = 1 << 0, @@ -87,35 +81,47 @@ enum { VALID_IN4 = 1 << 2, VALID_IN6 = 1 << 3, VALID_MTU = 1 << 4, - VALID_CARRIER = 1 << 5 + VALID_CARRIER = 1 << 5, + VALID_IS_PSEUDO = 1 << 6, /* Represents is_internal and is_tap. */ + VALID_POLICING = 1 << 7 }; -/* Cached network device information. */ -struct netdev_linux_cache { +struct tap_state { + int fd; +}; + +struct patch_state { + char *peer; +}; + +struct netdev_dev_linux { + struct netdev_dev netdev_dev; + struct shash_node *shash_node; - unsigned int valid; - int ref_cnt; + unsigned int cache_valid; + /* The following are figured out "on demand" only. They are only valid + * when the corresponding VALID_* bit in 'cache_valid' is set. */ 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; + bool is_internal; /* Is this an openvswitch internal device? */ + bool is_tap; /* Is this a tuntap device? */ + uint32_t kbits_rate; /* Policing data. */ + uint32_t kbits_burst; + + union { + struct tap_state tap; + struct patch_state patch; + } state; }; -static struct shash cache_map = SHASH_INITIALIZER(&cache_map); -static struct linux_netdev_notifier netdev_linux_cache_notifier; - -/* Policy for RTNLGRP_LINK messages. - * - * There are *many* more fields in these messages, but currently we only care - * about interface names. */ -static const struct nl_policy rtnlgrp_link_policy[] = { - [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false }, - [IFLA_MASTER] = { .type = NL_A_U32, .optional = true }, - [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true, - .min_len = sizeof(struct rtnl_link_stats) }, +struct netdev_linux { + struct netdev netdev; + int fd; }; /* An AF_INET socket (used for ioctl operations). */ @@ -128,15 +134,19 @@ struct netdev_linux_notifier { static struct shash netdev_linux_notifiers = SHASH_INITIALIZER(&netdev_linux_notifiers); -static struct linux_netdev_notifier netdev_linux_poll_notifier; +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 *, +static int netdev_linux_init(void); + +static int netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *, int cmd, const char *cmd_name); -static int netdev_linux_do_ioctl(const struct netdev *, struct ifreq *, +static int netdev_linux_do_ioctl(const char *name, 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); @@ -150,11 +160,30 @@ 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 int get_rtnl_sock(struct nl_sock **); + +static bool +is_netdev_linux_class(const struct netdev_class *netdev_class) +{ + return netdev_class->init == netdev_linux_init; +} + +static struct netdev_dev_linux * +netdev_dev_linux_cast(const struct netdev_dev *netdev_dev) +{ + const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev); + assert(is_netdev_linux_class(netdev_class)); + + return CONTAINER_OF(netdev_dev, struct netdev_dev_linux, netdev_dev); +} static struct netdev_linux * netdev_linux_cast(const struct netdev *netdev) { - netdev_assert_class(netdev, &netdev_linux_class); + struct netdev_dev *netdev_dev = netdev_get_dev(netdev); + const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev); + assert(is_netdev_linux_class(netdev_class)); + return CONTAINER_OF(netdev, struct netdev_linux, netdev); } @@ -175,98 +204,335 @@ netdev_linux_init(void) static void netdev_linux_run(void) { - linux_netdev_notifier_run(); + rtnetlink_notifier_run(); } static void netdev_linux_wait(void) { - linux_netdev_notifier_wait(); + rtnetlink_notifier_wait(); } static void -netdev_linux_cache_cb(const struct linux_netdev_change *change, - void *aux UNUSED) +netdev_linux_cache_cb(const struct rtnetlink_change *change, + void *aux OVS_UNUSED) { - struct netdev_linux_cache *cache; + struct netdev_dev_linux *dev; if (change) { - cache = shash_find_data(&cache_map, change->ifname); - if (cache) { - cache->valid = 0; + struct netdev_dev *base_dev = netdev_dev_from_name(change->ifname); + if (base_dev) { + const struct netdev_class *netdev_class = + netdev_dev_get_class(base_dev); + + if (is_netdev_linux_class(netdev_class)) { + dev = netdev_dev_linux_cast(base_dev); + dev->cache_valid = 0; + } } } else { + struct shash device_shash; struct shash_node *node; - SHASH_FOR_EACH (node, &cache_map) { - cache = node->data; - cache->valid = 0; + + shash_init(&device_shash); + netdev_dev_get_devices(&netdev_linux_class, &device_shash); + SHASH_FOR_EACH (node, &device_shash) { + dev = node->data; + dev->cache_valid = 0; } + shash_destroy(&device_shash); } } static int -netdev_linux_open(const char *name, char *suffix, int ethertype, - struct netdev **netdevp) +if_up(const char *name) { - struct netdev_linux *netdev; - enum netdev_flags flags; - int error; + struct ifreq ifr; - /* 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 = linux_netdev_notifier_register( - &netdev_linux_cache_notifier, netdev_linux_cache_cb, NULL); - if (error) { - netdev_close(&netdev->netdev); - return error; + strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name); + ifr.ifr_flags = IFF_UP; + + if (ioctl(af_inet_sock, SIOCSIFFLAGS, &ifr) == -1) { + VLOG_DBG_RL(&rl, "%s: failed to bring device up: %s", + name, strerror(errno)); + return errno; + } + + return 0; +} + +/* A veth may be created using the 'command' "+,". A veth may + * be destroyed by using the 'command' "-", where can be + * either side of the device. + */ +static int +modify_veth(const char *format, ...) +{ + FILE *veth_file; + va_list args; + int retval; + + veth_file = fopen("/sys/class/net/veth_pairs", "w"); + if (!veth_file) { + VLOG_WARN_RL(&rl, "could not open veth device. Are you running a " + "supported XenServer with the kernel module loaded?"); + return ENODEV; + } + setvbuf(veth_file, NULL, _IONBF, 0); + + va_start(args, format); + retval = vfprintf(veth_file, format, args); + va_end(args); + + fclose(veth_file); + if (retval < 0) { + VLOG_WARN_RL(&rl, "could not destroy patch: %s", strerror(errno)); + return errno; + } + + return 0; +} + +static int +create_patch(const char *name, const char *peer) +{ + int retval; + struct netdev_dev *peer_nd; + + + /* Only create the veth if the peer didn't already do it. */ + peer_nd = netdev_dev_from_name(peer); + if (peer_nd) { + if (!strcmp("patch", netdev_dev_get_type(peer_nd))) { + struct netdev_dev_linux *ndl = netdev_dev_linux_cast(peer_nd); + if (!strcmp(name, ndl->state.patch.peer)) { + return 0; + } else { + VLOG_WARN_RL(&rl, "peer '%s' already paired with '%s'", + peer, ndl->state.patch.peer); + return EINVAL; } + } else { + VLOG_WARN_RL(&rl, "peer '%s' exists and is not a patch", peer); + return EINVAL; } - 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; + retval = modify_veth("+%s,%s", name, peer); + if (retval) { + return retval; + } - /* 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; - } + retval = if_up(name); + if (retval) { + return retval; + } - /* Create tap device. */ - ifr.ifr_flags = IFF_TAP | IFF_NO_PI; - error = netdev_linux_do_ioctl(&netdev->netdev, &ifr, - TUNSETIFF, "TUNSETIFF"); + retval = if_up(peer); + if (retval) { + return retval; + } + + return 0; +} + +static int +setup_patch(const char *name, const struct shash *args, char **peer_) +{ + const char *peer; + + peer = shash_find_data(args, "peer"); + if (!peer) { + VLOG_WARN("patch type requires valid 'peer' argument"); + return EINVAL; + } + + if (shash_count(args) > 1) { + VLOG_WARN("patch type takes only a 'peer' argument"); + return EINVAL; + } + + if (strlen(peer) >= IFNAMSIZ) { + VLOG_WARN_RL(&rl, "patch 'peer' arg too long"); + return EINVAL; + } + + *peer_ = xstrdup(peer); + return create_patch(name, peer); +} + +/* Creates the netdev device of 'type' with 'name'. */ +static int +netdev_linux_create_system(const char *name, const char *type OVS_UNUSED, + const struct shash *args, struct netdev_dev **netdev_devp) +{ + struct netdev_dev_linux *netdev_dev; + int error; + + if (!shash_is_empty(args)) { + VLOG_WARN("%s: arguments for system devices should be empty", name); + } + + if (!cache_notifier_refcount) { + error = rtnetlink_notifier_register(&netdev_linux_cache_notifier, + netdev_linux_cache_cb, NULL); if (error) { - goto error; + return error; } + } + cache_notifier_refcount++; - /* Make non-blocking. */ - error = set_nonblocking(netdev->tap_fd); - if (error) { - goto error; + netdev_dev = xzalloc(sizeof *netdev_dev); + netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_linux_class); + + *netdev_devp = &netdev_dev->netdev_dev; + return 0; +} + +/* For most types of netdevs we open the device for each call of + * netdev_open(). However, this is not the case with tap devices, + * since it is only possible to open the device once. In this + * situation we share a single file descriptor, and consequently + * buffers, across all readers. Therefore once data is read it will + * be unavailable to other reads for tap devices. */ +static int +netdev_linux_create_tap(const char *name, const char *type OVS_UNUSED, + const struct shash *args, struct netdev_dev **netdev_devp) +{ + struct netdev_dev_linux *netdev_dev; + struct tap_state *state; + static const char tap_dev[] = "/dev/net/tun"; + struct ifreq ifr; + int error; + + if (!shash_is_empty(args)) { + VLOG_WARN("%s: arguments for TAP devices should be empty", name); + } + + netdev_dev = xzalloc(sizeof *netdev_dev); + state = &netdev_dev->state.tap; + + /* 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; + } + + /* Create tap device. */ + ifr.ifr_flags = IFF_TAP | IFF_NO_PI; + strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name); + if (ioctl(state->fd, TUNSETIFF, &ifr) == -1) { + VLOG_WARN("%s: creating tap device failed: %s", name, + strerror(errno)); + error = errno; + goto error; + } + + /* Make non-blocking. */ + error = set_nonblocking(state->fd); + if (error) { + goto error; + } + + netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class); + *netdev_devp = &netdev_dev->netdev_dev; + return 0; + +error: + free(netdev_dev); + return error; +} + +static int +netdev_linux_create_patch(const char *name, const char *type OVS_UNUSED, + const struct shash *args, struct netdev_dev **netdev_devp) +{ + struct netdev_dev_linux *netdev_dev; + char *peer = NULL; + int error; + + error = setup_patch(name, args, &peer); + if (error) { + free(peer); + return error; + } + + netdev_dev = xzalloc(sizeof *netdev_dev); + netdev_dev->state.patch.peer = peer; + netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_patch_class); + *netdev_devp = &netdev_dev->netdev_dev; + + return 0; +} + +static void +destroy_tap(struct netdev_dev_linux *netdev_dev) +{ + struct tap_state *state = &netdev_dev->state.tap; + + if (state->fd >= 0) { + close(state->fd); + } +} + +static void +destroy_patch(struct netdev_dev_linux *netdev_dev) +{ + const char *name = netdev_dev_get_name(&netdev_dev->netdev_dev); + struct patch_state *state = &netdev_dev->state.patch; + + /* Only destroy veth if 'peer' doesn't exist as an existing netdev. */ + if (!netdev_dev_from_name(state->peer)) { + modify_veth("-%s", name); + } + free(state->peer); +} + +/* Destroys the netdev device 'netdev_dev_'. */ +static void +netdev_linux_destroy(struct netdev_dev *netdev_dev_) +{ + struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_); + const char *type = netdev_dev_get_type(netdev_dev_); + + if (!strcmp(type, "system")) { + cache_notifier_refcount--; + + if (!cache_notifier_refcount) { + rtnetlink_notifier_unregister(&netdev_linux_cache_notifier); } + } else if (!strcmp(type, "tap")) { + destroy_tap(netdev_dev); + } else if (!strcmp(type, "patch")) { + destroy_patch(netdev_dev); } + free(netdev_dev); +} + +static int +netdev_linux_open(struct netdev_dev *netdev_dev_, int ethertype, + struct netdev **netdevp) +{ + struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_); + struct netdev_linux *netdev; + enum netdev_flags flags; + int error; + + /* Allocate network device. */ + netdev = xzalloc(sizeof *netdev); + netdev->fd = -1; + netdev_init(&netdev->netdev, netdev_dev_); + error = netdev_get_flags(&netdev->netdev, &flags); if (error == ENODEV) { goto error; } - if (netdev->tap_fd >= 0 || ethertype != NETDEV_ETH_TYPE_NONE) { + if (!strcmp(netdev_dev_get_type(netdev_dev_), "tap")) { + netdev->fd = netdev_dev->state.tap.fd; + } else if (ethertype != NETDEV_ETH_TYPE_NONE) { struct sockaddr_ll sll; int protocol; int ifindex; @@ -275,17 +541,14 @@ netdev_linux_open(const char *name, char *suffix, int ethertype, 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) { + netdev->fd = socket(PF_PACKET, SOCK_RAW, htons(protocol)); + if (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); + error = set_nonblocking(netdev->fd); if (error) { goto error; } @@ -300,10 +563,11 @@ netdev_linux_open(const char *name, char *suffix, int ethertype, memset(&sll, 0, sizeof sll); sll.sll_family = AF_PACKET; sll.sll_ifindex = ifindex; - if (bind(netdev->netdev_fd, + if (bind(netdev->fd, (struct sockaddr *) &sll, sizeof sll) < 0) { error = errno; - VLOG_ERR("bind to %s failed: %s", suffix, strerror(error)); + VLOG_ERR("bind to %s failed: %s", netdev_dev_get_name(netdev_dev_), + strerror(error)); goto error; } @@ -311,7 +575,7 @@ netdev_linux_open(const char *name, char *suffix, int ethertype, * 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); + error = drain_rcvbuf(netdev->fd); if (error) { goto error; } @@ -321,7 +585,7 @@ netdev_linux_open(const char *name, char *suffix, int ethertype, return 0; error: - netdev_close(&netdev->netdev); + netdev_uninit(&netdev->netdev, true); return error; } @@ -331,19 +595,8 @@ 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)) { - linux_netdev_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); + if (netdev->fd > 0 && strcmp(netdev_get_type(netdev_), "tap")) { + close(netdev->fd); } free(netdev); } @@ -375,13 +628,13 @@ netdev_linux_recv(struct netdev *netdev_, void *data, size_t size) { struct netdev_linux *netdev = netdev_linux_cast(netdev_); - if (netdev->tap_fd < 0) { + if (netdev->fd < 0) { /* Device was opened with NETDEV_ETH_TYPE_NONE. */ - return EAGAIN; + return -EAGAIN; } for (;;) { - ssize_t retval = read(netdev->tap_fd, data, size); + ssize_t retval = read(netdev->fd, data, size); if (retval >= 0) { return retval; } else if (errno != EINTR) { @@ -389,7 +642,7 @@ netdev_linux_recv(struct netdev *netdev_, void *data, size_t size) VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s", strerror(errno), netdev_get_name(netdev_)); } - return errno; + return -errno; } } } @@ -400,8 +653,8 @@ 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); + if (netdev->fd >= 0) { + poll_fd_wait(netdev->fd, POLLIN); } } @@ -410,19 +663,19 @@ 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) { + if (netdev->fd < 0) { return 0; - } else if (netdev->tap_fd != netdev->netdev_fd) { + } else if (!strcmp(netdev_get_type(netdev_), "tap")) { struct ifreq ifr; - int error = netdev_linux_do_ioctl(netdev_, &ifr, + int error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr, SIOCGIFTXQLEN, "SIOCGIFTXQLEN"); if (error) { return error; } - drain_fd(netdev->tap_fd, ifr.ifr_qlen); + drain_fd(netdev->fd, ifr.ifr_qlen); return 0; } else { - return drain_rcvbuf(netdev->netdev_fd); + return drain_rcvbuf(netdev->fd); } } @@ -442,12 +695,12 @@ netdev_linux_send(struct netdev *netdev_, const void *data, size_t size) /* XXX should support sending even if 'ethertype' was NETDEV_ETH_TYPE_NONE. */ - if (netdev->tap_fd < 0) { + if (netdev->fd < 0) { return EPIPE; } for (;;) { - ssize_t retval = write(netdev->tap_fd, data, size); + ssize_t retval = write(netdev->fd, data, size); if (retval < 0) { /* The Linux AF_PACKET implementation never blocks waiting for room * for packets, instead returning ENOBUFS. Translate this into @@ -482,10 +735,10 @@ 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) { + if (netdev->fd < 0) { /* Nothing to do. */ - } else if (netdev->tap_fd == netdev->netdev_fd) { - poll_fd_wait(netdev->tap_fd, POLLOUT); + } else if (strcmp(netdev_get_type(netdev_), "tap")) { + poll_fd_wait(netdev->fd, POLLOUT); } else { /* TAP device always accepts packets.*/ poll_immediate_wake(); @@ -498,10 +751,19 @@ 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); + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + int error; + + if (!(netdev_dev->cache_valid & VALID_ETHERADDR) + || !eth_addr_equals(netdev_dev->etheraddr, mac)) { + error = set_etheraddr(netdev_get_name(netdev_), ARPHRD_ETHER, mac); + if (!error) { + netdev_dev->cache_valid |= VALID_ETHERADDR; + memcpy(netdev_dev->etheraddr, mac, ETH_ADDR_LEN); + } + } else { + error = 0; } return error; } @@ -512,16 +774,17 @@ 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)) { + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + if (!(netdev_dev->cache_valid & VALID_ETHERADDR)) { int error = get_etheraddr(netdev_get_name(netdev_), - netdev->cache->etheraddr); + netdev_dev->etheraddr); if (error) { return error; } - netdev->cache->valid |= VALID_ETHERADDR; + netdev_dev->cache_valid |= VALID_ETHERADDR; } - memcpy(mac, netdev->cache->etheraddr, ETH_ADDR_LEN); + memcpy(mac, netdev_dev->etheraddr, ETH_ADDR_LEN); return 0; } @@ -531,35 +794,50 @@ netdev_linux_get_etheraddr(const struct netdev *netdev_, 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 netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + if (!(netdev_dev->cache_valid & VALID_MTU)) { struct ifreq ifr; int error; - error = netdev_linux_do_ioctl(netdev_, &ifr, SIOCGIFMTU, "SIOCGIFMTU"); + error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr, + SIOCGIFMTU, "SIOCGIFMTU"); if (error) { return error; } - netdev->cache->mtu = ifr.ifr_mtu; - netdev->cache->valid |= VALID_MTU; + netdev_dev->mtu = ifr.ifr_mtu; + netdev_dev->cache_valid |= VALID_MTU; } - *mtup = netdev->cache->mtu; + *mtup = netdev_dev->mtu; return 0; } +/* Returns the ifindex of 'netdev', if successful, as a positive number. + * On failure, returns a negative errno value. */ +static int +netdev_linux_get_ifindex(const struct netdev *netdev) +{ + int ifindex, error; + + error = get_ifindex(netdev, &ifindex); + return error ? -error : ifindex; +} + static int netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier) { - struct netdev_linux *netdev = netdev_linux_cast(netdev_); + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); int error = 0; char *fn = NULL; int fd = -1; - if (!(netdev->cache->valid & VALID_CARRIER)) { + if (!(netdev_dev->cache_valid & VALID_CARRIER)) { char line[8]; int retval; - fn = xasprintf("/sys/class/net/%s/carrier", netdev_get_name(netdev_)); + fn = xasprintf("/sys/class/net/%s/carrier", + netdev_get_name(netdev_)); fd = open(fn, O_RDONLY); if (fd < 0) { error = errno; @@ -589,10 +867,10 @@ netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier) fn, line[0]); goto exit; } - netdev->cache->carrier = line[0] != '0'; - netdev->cache->valid |= VALID_CARRIER; + netdev_dev->carrier = line[0] != '0'; + netdev_dev->cache_valid |= VALID_CARRIER; } - *carrier = netdev->cache->carrier; + *carrier = netdev_dev->carrier; error = 0; exit: @@ -631,38 +909,141 @@ check_for_working_netlink_stats(void) } } +/* Brings the 'is_internal' and 'is_tap' members of 'netdev_dev' up-to-date. */ +static void +netdev_linux_update_is_pseudo(struct netdev_dev_linux *netdev_dev) +{ + if (!(netdev_dev->cache_valid & VALID_IS_PSEUDO)) { + const char *name = netdev_dev_get_name(&netdev_dev->netdev_dev); + const char *type = netdev_dev_get_type(&netdev_dev->netdev_dev); + + netdev_dev->is_tap = !strcmp(type, "tap"); + netdev_dev->is_internal = false; + if (!netdev_dev->is_tap) { + struct ethtool_drvinfo drvinfo; + int error; + + memset(&drvinfo, 0, sizeof drvinfo); + error = netdev_linux_do_ethtool(name, + (struct ethtool_cmd *)&drvinfo, + ETHTOOL_GDRVINFO, + "ETHTOOL_GDRVINFO"); + + if (!error && !strcmp(drvinfo.driver, "openvswitch")) { + netdev_dev->is_internal = true; + } + } + + netdev_dev->cache_valid |= VALID_IS_PSEUDO; + } +} + /* 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) +netdev_linux_get_stats(const struct netdev *netdev_, + struct netdev_stats *stats) { + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); static int use_netlink_stats = -1; int error; + struct netdev_stats raw_stats; + struct netdev_stats *collect_stats = stats; COVERAGE_INC(netdev_get_stats); + + netdev_linux_update_is_pseudo(netdev_dev); + if (netdev_dev->is_internal) { + collect_stats = &raw_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); + error = get_ifindex(netdev_, &ifindex); if (!error) { - error = get_stats_via_netlink(ifindex, stats); + error = get_stats_via_netlink(ifindex, collect_stats); } } else { - error = get_stats_via_proc(netdev->name, stats); + error = get_stats_via_proc(netdev_get_name(netdev_), collect_stats); + } + + /* If this port is an internal port then the transmit and receive stats + * will appear to be swapped relative to the other ports since we are the + * one sending the data, not a remote computer. For consistency, we swap + * them back here. */ + if (!error && (netdev_dev->is_internal || netdev_dev->is_tap)) { + stats->rx_packets = raw_stats.tx_packets; + stats->tx_packets = raw_stats.rx_packets; + stats->rx_bytes = raw_stats.tx_bytes; + stats->tx_bytes = raw_stats.rx_bytes; + stats->rx_errors = raw_stats.tx_errors; + stats->tx_errors = raw_stats.rx_errors; + stats->rx_dropped = raw_stats.tx_dropped; + stats->tx_dropped = raw_stats.rx_dropped; + stats->multicast = raw_stats.multicast; + stats->collisions = raw_stats.collisions; + stats->rx_length_errors = 0; + stats->rx_over_errors = 0; + stats->rx_crc_errors = 0; + stats->rx_frame_errors = 0; + stats->rx_fifo_errors = 0; + stats->rx_missed_errors = 0; + stats->tx_aborted_errors = 0; + stats->tx_carrier_errors = 0; + stats->tx_fifo_errors = 0; + stats->tx_heartbeat_errors = 0; + stats->tx_window_errors = 0; } + return error; } +static int +netdev_linux_set_stats(struct netdev *netdev, + const struct netdev_stats *stats) +{ + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev)); + struct internal_dev_stats dp_dev_stats; + struct ifreq ifr; + + /* We must reject this call if 'netdev' is not an Open vSwitch internal + * port, because the ioctl that we are about to execute is in the "device + * private ioctls" range, which means that executing it on a device that + * is not the type we expect could do any random thing. + * + * (Amusingly, these ioctl numbers are commented "THESE IOCTLS ARE + * _DEPRECATED_ AND WILL DISAPPEAR IN 2.5.X" in linux/sockios.h. I guess + * DaveM is a little behind on that.) */ + netdev_linux_update_is_pseudo(netdev_dev); + if (!netdev_dev->is_internal) { + return EOPNOTSUPP; + } + + /* This actually only sets the *offset* that the dp_dev applies, but in our + * usage for fake bond devices the dp_dev never has any traffic of it own + * so it has the same effect. */ + dp_dev_stats.rx_packets = stats->rx_packets; + dp_dev_stats.rx_bytes = stats->rx_bytes; + dp_dev_stats.tx_packets = stats->tx_packets; + dp_dev_stats.tx_bytes = stats->tx_bytes; + ifr.ifr_data = (void *) &dp_dev_stats; + return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, + INTERNAL_DEV_SET_STATS, + "INTERNAL_DEV_SET_STATS"); +} + /* 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. */ + * successful, otherwise a positive errno value. */ static int netdev_linux_get_features(struct netdev *netdev, uint32_t *current, uint32_t *advertised, @@ -672,7 +1053,7 @@ netdev_linux_get_features(struct netdev *netdev, int error; memset(&ecmd, 0, sizeof ecmd); - error = netdev_linux_do_ethtool(netdev, &ecmd, + error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET"); if (error) { return error; @@ -793,7 +1174,7 @@ netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise) int error; memset(&ecmd, 0, sizeof ecmd); - error = netdev_linux_do_ethtool(netdev, &ecmd, + error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET"); if (error) { return error; @@ -836,7 +1217,7 @@ netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise) if (advertise & OFPPF_PAUSE_ASYM) { ecmd.advertising |= ADVERTISED_Asym_Pause; } - return netdev_linux_do_ethtool(netdev, &ecmd, + return netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd, ETHTOOL_SSET, "ETHTOOL_SSET"); } @@ -896,35 +1277,88 @@ done: #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. + +/* 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. */ -#define POLICE_DEL_CMD "/sbin/tc qdisc del dev %s handle ffff: ingress 2>/dev/null" +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 ofpbuf *reply; + struct tcmsg *tcmsg; + struct nl_sock *rtnl_sock; + int ifindex; + int error; + + error = get_ifindex(netdev, &ifindex); + if (error) { + return error; + } + + error = get_rtnl_sock(&rtnl_sock); + if (error) { + return error; + } + + ofpbuf_init(&request, 0); + nl_msg_put_nlmsghdr(&request, rtnl_sock, sizeof *tcmsg, + RTM_DELQDISC, NLM_F_REQUEST); + tcmsg = ofpbuf_put_zeros(&request, sizeof *tcmsg); + tcmsg->tcm_family = AF_UNSPEC; + tcmsg->tcm_ifindex = ifindex; + tcmsg->tcm_handle = 0xffff0000; + tcmsg->tcm_parent = TC_H_INGRESS; + nl_msg_put_string(&request, TCA_KIND, "ingress"); + nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0); + error = nl_sock_transact(rtnl_sock, &request, &reply); + ofpbuf_uninit(&request); + ofpbuf_delete(reply); + if (error && error != ENOENT) { + 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. */ 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]; 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); - } + kbits_burst = (!kbits_rate ? 0 /* Force to 0 if no rate specified. */ + : !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */ + : kbits_burst); /* Stick with user-specified value. */ + if (netdev_dev->cache_valid & VALID_POLICING + && netdev_dev->kbits_rate == kbits_rate + && netdev_dev->kbits_burst == kbits_burst) { + /* Assume that settings haven't changed since we last set them. */ + return 0; + } + + netdev_linux_remove_policing(netdev); + 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); @@ -938,59 +1372,60 @@ netdev_linux_set_policing(struct netdev *netdev, 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); - } + + netdev_dev->kbits_rate = kbits_rate; + netdev_dev->kbits_burst = kbits_burst; + netdev_dev->cache_valid |= VALID_POLICING; } 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; + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + + if (!(netdev_dev->cache_valid & VALID_IN4)) { int error; - ifr.ifr_addr.sa_family = AF_INET; - error = netdev_linux_do_ioctl(netdev_, &ifr, + error = netdev_linux_get_ipv4(netdev_, &netdev_dev->address, SIOCGIFADDR, "SIOCGIFADDR"); if (error) { return error; } - sin = (struct sockaddr_in *) &ifr.ifr_addr; - netdev->cache->in4 = sin->sin_addr; - netdev->cache->valid |= VALID_IN4; + error = netdev_linux_get_ipv4(netdev_, &netdev_dev->netmask, + SIOCGIFNETMASK, "SIOCGIFNETMASK"); + if (error) { + return error; + } + + netdev_dev->cache_valid |= VALID_IN4; } - *in4 = netdev->cache->in4; - return in4->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0; + *address = netdev_dev->address; + *netmask = netdev_dev->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_); + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(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_dev->cache_valid |= VALID_IN4; + netdev_dev->address = address; + netdev_dev->netmask = netmask; + if (address.s_addr != INADDR_ANY) { error = do_set_addr(netdev_, SIOCSIFNETMASK, - "SIOCSIFNETMASK", mask); + "SIOCSIFNETMASK", netmask); } } return error; @@ -1017,12 +1452,13 @@ parse_if_inet6_line(const char *line, 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)) { + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + if (!(netdev_dev->cache_valid & VALID_IN6)) { FILE *file; char line[128]; - netdev->cache->in6 = in6addr_any; + netdev_dev->in6 = in6addr_any; file = fopen("/proc/net/if_inet6", "r"); if (file != NULL) { @@ -1033,15 +1469,15 @@ netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6) if (parse_if_inet6_line(line, &in6, ifname) && !strcmp(name, ifname)) { - netdev->cache->in6 = in6; + netdev_dev->in6 = in6; break; } } fclose(file); } - netdev->cache->valid |= VALID_IN6; + netdev_dev->cache_valid |= VALID_IN6; } - *in6 = netdev->cache->in6; + *in6 = netdev_dev->in6; return 0; } @@ -1063,14 +1499,16 @@ 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); + strncpy(ifr.ifr_name, netdev_get_name(netdev), sizeof ifr.ifr_name); make_in4_sockaddr(&ifr.ifr_addr, addr); - return netdev_linux_do_ioctl(netdev, &ifr, ioctl_nr, ioctl_name); + + return netdev_linux_do_ioctl(netdev_get_name(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) +netdev_linux_add_router(struct netdev *netdev OVS_UNUSED, struct in_addr router) { struct in_addr any = { INADDR_ANY }; struct rtentry rt; @@ -1089,6 +1527,67 @@ netdev_linux_add_router(struct netdev *netdev UNUSED, struct in_addr router) 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, @@ -1098,24 +1597,24 @@ netdev_linux_arp_lookup(const struct netdev *netdev, uint32_t ip, uint8_t mac[ETH_ADDR_LEN]) { struct arpreq r; - struct sockaddr_in *pa; + struct sockaddr_in sin; 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; + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = ip; + sin.sin_port = 0; + memcpy(&r.arp_pa, &sin, sizeof sin); r.arp_ha.sa_family = ARPHRD_ETHER; r.arp_flags = 0; - strncpy(r.arp_dev, netdev->name, sizeof r.arp_dev); + strncpy(r.arp_dev, netdev_get_name(netdev), 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)); + netdev_get_name(netdev), IP_ARGS(&ip), strerror(retval)); } return retval; } @@ -1175,8 +1674,8 @@ poll_notify(struct list *list) } static void -netdev_linux_poll_cb(const struct linux_netdev_change *change, - void *aux UNUSED) +netdev_linux_poll_cb(const struct rtnetlink_change *change, + void *aux OVS_UNUSED) { if (change) { struct list *list = shash_find_data(&netdev_linux_notifiers, @@ -1202,7 +1701,7 @@ netdev_linux_poll_add(struct netdev *netdev, struct list *list; if (shash_is_empty(&netdev_linux_notifiers)) { - int error = linux_netdev_notifier_register(&netdev_linux_poll_notifier, + int error = rtnetlink_notifier_register(&netdev_linux_poll_notifier, netdev_linux_poll_cb, NULL); if (error) { return error; @@ -1243,18 +1742,21 @@ netdev_linux_poll_remove(struct netdev_notifier *notifier_) /* If that was the last notifier, unregister. */ if (shash_is_empty(&netdev_linux_notifiers)) { - linux_netdev_notifier_unregister(&netdev_linux_poll_notifier); + rtnetlink_notifier_unregister(&netdev_linux_poll_notifier); } } const struct netdev_class netdev_linux_class = { - "", /* prefix */ - "linux", /* name */ + "system", netdev_linux_init, netdev_linux_run, netdev_linux_wait, + netdev_linux_create_system, + netdev_linux_destroy, + NULL, /* reconfigure */ + netdev_linux_open, netdev_linux_close, @@ -1270,8 +1772,10 @@ const struct netdev_class netdev_linux_class = { netdev_linux_set_etheraddr, netdev_linux_get_etheraddr, netdev_linux_get_mtu, + netdev_linux_get_ifindex, netdev_linux_get_carrier, netdev_linux_get_stats, + netdev_linux_set_stats, netdev_linux_get_features, netdev_linux_set_advertisements, @@ -1282,6 +1786,7 @@ const struct netdev_class netdev_linux_class = { 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, @@ -1291,17 +1796,69 @@ const struct netdev_class netdev_linux_class = { }; const struct netdev_class netdev_tap_class = { - "tap", /* prefix */ - "tap", /* name */ + "tap", netdev_linux_init, - NULL, /* run */ - NULL, /* wait */ + netdev_linux_run, + netdev_linux_wait, + + netdev_linux_create_tap, + netdev_linux_destroy, + NULL, /* reconfigure */ netdev_linux_open, netdev_linux_close, - netdev_linux_enumerate, + NULL, /* 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_ifindex, + netdev_linux_get_carrier, + netdev_linux_get_stats, + NULL, /* set_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_patch_class = { + "patch", + + netdev_linux_init, + netdev_linux_run, + netdev_linux_wait, + + netdev_linux_create_patch, + netdev_linux_destroy, + NULL, /* reconfigure */ + + netdev_linux_open, + netdev_linux_close, + + NULL, /* enumerate */ netdev_linux_recv, netdev_linux_recv_wait, @@ -1313,8 +1870,10 @@ const struct netdev_class netdev_tap_class = { netdev_linux_set_etheraddr, netdev_linux_get_etheraddr, netdev_linux_get_mtu, + netdev_linux_get_ifindex, netdev_linux_get_carrier, netdev_linux_get_stats, + NULL, /* set_stats */ netdev_linux_get_features, netdev_linux_set_advertisements, @@ -1325,6 +1884,7 @@ const struct netdev_class netdev_tap_class = { 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, @@ -1332,11 +1892,22 @@ const struct netdev_class netdev_tap_class = { netdev_linux_poll_add, netdev_linux_poll_remove, }; + static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats) { - static struct nl_sock *rtnl_sock; + /* 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) }, + }; + + struct nl_sock *rtnl_sock; struct ofpbuf request; struct ofpbuf *reply; struct ifinfomsg *ifi; @@ -1344,13 +1915,9 @@ get_stats_via_netlink(int ifindex, struct netdev_stats *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; - } + error = get_rtnl_sock(&rtnl_sock); + if (error) { + return error; } ofpbuf_init(&request, 0); @@ -1374,6 +1941,7 @@ get_stats_via_netlink(int ifindex, struct netdev_stats *stats) if (!attrs[IFLA_STATS]) { VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats"); + ofpbuf_delete(reply); return EPROTO; } @@ -1400,6 +1968,8 @@ get_stats_via_netlink(int ifindex, struct netdev_stats *stats) stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors; stats->tx_window_errors = rtnl_stats->tx_window_errors; + ofpbuf_delete(reply); + return 0; } @@ -1466,7 +2036,8 @@ get_flags(const struct netdev *netdev, int *flags) struct ifreq ifr; int error; - error = netdev_linux_do_ioctl(netdev, &ifr, SIOCGIFFLAGS, "SIOCGIFFLAGS"); + error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCGIFFLAGS, + "SIOCGIFFLAGS"); *flags = ifr.ifr_flags; return error; } @@ -1477,7 +2048,8 @@ set_flags(struct netdev *netdev, int flags) struct ifreq ifr; ifr.ifr_flags = flags; - return netdev_linux_do_ioctl(netdev, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS"); + return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCSIFFLAGS, + "SIOCSIFFLAGS"); } static int @@ -1498,17 +2070,18 @@ do_get_ifindex(const char *netdev_name) static int get_ifindex(const struct netdev *netdev_, int *ifindexp) { - struct netdev_linux *netdev = netdev_linux_cast(netdev_); + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); *ifindexp = 0; - if (!(netdev->cache->valid & VALID_IFINDEX)) { + if (!(netdev_dev->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; + netdev_dev->cache_valid |= VALID_IFINDEX; + netdev_dev->ifindex = ifindex; } - *ifindexp = netdev->cache->ifindex; + *ifindexp = netdev_dev->ifindex; return 0; } @@ -1555,13 +2128,13 @@ set_etheraddr(const char *netdev_name, int hwaddr_family, } static int -netdev_linux_do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd, +netdev_linux_do_ethtool(const char *name, 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); + strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name); ifr.ifr_data = (caddr_t) ecmd; ecmd->cmd = cmd; @@ -1571,8 +2144,7 @@ netdev_linux_do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd, } else { if (errno != EOPNOTSUPP) { VLOG_WARN_RL(&rl, "ethtool command %s on network device %s " - "failed: %s", cmd_name, netdev->name, - strerror(errno)); + "failed: %s", cmd_name, name, strerror(errno)); } else { /* The device doesn't support this operation. That's pretty * common, so there's no point in logging anything. */ @@ -1582,142 +2154,53 @@ netdev_linux_do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd, } static int -netdev_linux_do_ioctl(const struct netdev *netdev, struct ifreq *ifr, - int cmd, const char *cmd_name) +netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd, + const char *cmd_name) { - strncpy(ifr->ifr_name, netdev_get_name(netdev), sizeof ifr->ifr_name); + strncpy(ifr->ifr_name, name, 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)); + VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", name, cmd_name, + strerror(errno)); return errno; } return 0; } - -/* rtnetlink socket. */ -static struct nl_sock *notify_sock; - -/* All registered notifiers. */ -static struct list all_notifiers = LIST_INITIALIZER(&all_notifiers); -static void linux_netdev_report_change(const struct nlmsghdr *, - const struct ifinfomsg *, - struct nlattr *attrs[]); -static void linux_netdev_report_notify_error(void); - -int -linux_netdev_notifier_register(struct linux_netdev_notifier *notifier, - linux_netdev_notify_func *cb, void *aux) +static int +netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip, + int cmd, const char *cmd_name) { - if (!notify_sock) { - int error = nl_sock_create(NETLINK_ROUTE, RTNLGRP_LINK, 0, 0, - ¬ify_sock); - if (error) { - VLOG_WARN("could not create rtnetlink socket: %s", - strerror(error)); - return error; - } - } else { - /* Catch up on notification work so that the new notifier won't - * receive any stale notifications. */ - linux_netdev_notifier_run(); - } - - list_push_back(&all_notifiers, ¬ifier->node); - notifier->cb = cb; - notifier->aux = aux; - return 0; -} + struct ifreq ifr; + int error; -void -linux_netdev_notifier_unregister(struct linux_netdev_notifier *notifier) -{ - list_remove(¬ifier->node); - if (list_is_empty(&all_notifiers)) { - nl_sock_destroy(notify_sock); - notify_sock = NULL; + ifr.ifr_addr.sa_family = AF_INET; + error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name); + if (!error) { + const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr; + *ip = sin->sin_addr; } + return error; } -void -linux_netdev_notifier_run(void) +/* Obtains a Netlink routing socket that is not subscribed to any multicast + * groups. Returns 0 if successful, otherwise a positive errno value. Stores + * the socket in '*rtnl_sockp' if successful, otherwise a null pointer. */ +static int +get_rtnl_sock(struct nl_sock **rtnl_sockp) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - - if (!notify_sock) { - return; - } - - for (;;) { - struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)]; - struct ofpbuf *buf; - int error; - - error = nl_sock_recv(notify_sock, &buf, false); - if (!error) { - if (nl_policy_parse(buf, NLMSG_HDRLEN + sizeof(struct ifinfomsg), - rtnlgrp_link_policy, - attrs, ARRAY_SIZE(rtnlgrp_link_policy))) { - struct ifinfomsg *ifinfo; + static struct nl_sock *sock; + int error; - ifinfo = (void *) ((char *) buf->data + NLMSG_HDRLEN); - linux_netdev_report_change(buf->data, ifinfo, attrs); - } else { - VLOG_WARN_RL(&rl, "received bad rtnl message"); - linux_netdev_report_notify_error(); - } - ofpbuf_delete(buf); - } else if (error == EAGAIN) { - return; - } else { - if (error == ENOBUFS) { - VLOG_WARN_RL(&rl, "rtnetlink receive buffer overflowed"); - } else { - VLOG_WARN_RL(&rl, "error reading rtnetlink socket: %s", - strerror(error)); - } - linux_netdev_report_notify_error(); + if (!sock) { + error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &sock); + if (error) { + VLOG_ERR_RL(&rl, "failed to create rtnetlink socket: %s", + strerror(error)); } + } else { + error = 0; } -} - -void -linux_netdev_notifier_wait(void) -{ - if (notify_sock) { - nl_sock_wait(notify_sock, POLLIN); - } -} - -static void -linux_netdev_report_change(const struct nlmsghdr *nlmsg, - const struct ifinfomsg *ifinfo, - struct nlattr *attrs[]) -{ - struct linux_netdev_notifier *notifier; - struct linux_netdev_change change; - - COVERAGE_INC(linux_netdev_changed); - - change.nlmsg_type = nlmsg->nlmsg_type; - change.ifi_index = ifinfo->ifi_index; - change.ifname = nl_attr_get_string(attrs[IFLA_IFNAME]); - change.master_ifindex = (attrs[IFLA_MASTER] - ? nl_attr_get_u32(attrs[IFLA_MASTER]) : 0); - - LIST_FOR_EACH (notifier, struct linux_netdev_notifier, node, - &all_notifiers) { - notifier->cb(&change, notifier->aux); - } -} - -static void -linux_netdev_report_notify_error(void) -{ - struct linux_netdev_notifier *notifier; - LIST_FOR_EACH (notifier, struct linux_netdev_notifier, node, - &all_notifiers) { - notifier->cb(NULL, notifier->aux); - } + *rtnl_sockp = sock; + return error; }