X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fnetdev-linux.c;h=fc61d452d266915304988ce1ca0510cb3fa5f06c;hb=9ed3ba29b36ab99b75d6519660f58d6f5f9bd190;hp=166728262b81f4b6e80ac1e54ae94c4b3de7d9d2;hpb=aebf4235f3938b9e8865d4eb4a767d7584478d30;p=openvswitch diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c index 16672826..fc61d452 100644 --- a/lib/netdev-linux.c +++ b/lib/netdev-linux.c @@ -58,12 +58,12 @@ #include "netdev-provider.h" #include "netdev-vport.h" #include "netlink.h" +#include "netlink-notifier.h" #include "netlink-socket.h" #include "ofpbuf.h" #include "openflow/openflow.h" #include "packets.h" #include "poll-loop.h" -#include "rtnetlink.h" #include "rtnetlink-link.h" #include "socket-util.h" #include "shash.h" @@ -90,13 +90,22 @@ COVERAGE_DEFINE(netdev_ethtool); #define ADVERTISED_Asym_Pause (1 << 14) #endif +/* These were introduced in Linux 2.6.24, so they might be missing if we + * have old headers. */ +#ifndef ETHTOOL_GFLAGS +#define ETHTOOL_GFLAGS 0x00000025 /* Get flags bitmap(ethtool_value) */ +#endif +#ifndef ETHTOOL_SFLAGS +#define ETHTOOL_SFLAGS 0x00000026 /* Set flags bitmap(ethtool_value) */ +#endif + /* This was introduced in Linux 2.6.25, so it might be missing if we have old * headers. */ #ifndef TC_RTAB_SIZE #define TC_RTAB_SIZE 1024 #endif -static struct rtnetlink_notifier netdev_linux_cache_notifier; +static struct nln_notifier netdev_linux_cache_notifier; static int cache_notifier_refcount; enum { @@ -516,18 +525,12 @@ netdev_linux_cache_cb(const struct rtnetlink_link_change *change, /* Creates system and internal devices. */ static int -netdev_linux_create(const struct netdev_class *class, - const char *name, const struct shash *args, - struct netdev_dev **netdev_devp) +netdev_linux_create(const struct netdev_class *class, const char *name, + struct netdev_dev **netdev_devp) { struct netdev_dev_linux *netdev_dev; int error; - if (!shash_is_empty(args)) { - VLOG_WARN("%s: arguments for %s devices should be empty", - name, class->type); - } - if (!cache_notifier_refcount) { error = rtnetlink_link_notifier_register(&netdev_linux_cache_notifier, netdev_linux_cache_cb, NULL); @@ -539,7 +542,7 @@ netdev_linux_create(const struct netdev_class *class, netdev_dev = xzalloc(sizeof *netdev_dev); netdev_dev->change_seq = 1; - netdev_dev_init(&netdev_dev->netdev_dev, name, args, class); + netdev_dev_init(&netdev_dev->netdev_dev, name, class); *netdev_devp = &netdev_dev->netdev_dev; return 0; @@ -553,8 +556,7 @@ netdev_linux_create(const struct netdev_class *class, * be unavailable to other reads for tap devices. */ static int netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED, - const char *name, const struct shash *args, - struct netdev_dev **netdev_devp) + const char *name, struct netdev_dev **netdev_devp) { struct netdev_dev_linux *netdev_dev; struct tap_state *state; @@ -562,10 +564,6 @@ netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED, 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; @@ -593,7 +591,7 @@ netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED, goto error; } - netdev_dev_init(&netdev_dev->netdev_dev, name, args, &netdev_tap_class); + netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class); *netdev_devp = &netdev_dev->netdev_dev; return 0; @@ -639,8 +637,7 @@ netdev_linux_destroy(struct netdev_dev *netdev_dev_) } static int -netdev_linux_open(struct netdev_dev *netdev_dev_, int ethertype, - struct netdev **netdevp) +netdev_linux_open(struct netdev_dev *netdev_dev_, struct netdev **netdevp) { struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_); struct netdev_linux *netdev; @@ -676,54 +673,6 @@ netdev_linux_open(struct netdev_dev *netdev_dev_, int ethertype, * directions appearing to be reversed. */ netdev->fd = netdev_dev->state.tap.fd; netdev_dev->state.tap.opened = true; - } else if (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->fd = socket(PF_PACKET, SOCK_RAW, - (OVS_FORCE int) htons(protocol)); - if (netdev->fd < 0) { - error = errno; - goto error; - } - - /* Set non-blocking mode. */ - error = set_nonblocking(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->fd, - (struct sockaddr *) &sll, sizeof sll) < 0) { - error = errno; - VLOG_ERR("bind to %s failed: %s", netdev_dev_get_name(netdev_dev_), - 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->fd); - if (error) { - goto error; - } } *netdevp = &netdev->netdev; @@ -768,13 +717,68 @@ netdev_linux_enumerate(struct sset *sset) } } +static int +netdev_linux_listen(struct netdev *netdev_) +{ + struct netdev_linux *netdev = netdev_linux_cast(netdev_); + struct sockaddr_ll sll; + int ifindex; + int error; + int fd; + + if (netdev->fd >= 0) { + return 0; + } + + /* Create file descriptor. */ + fd = socket(PF_PACKET, SOCK_RAW, 0); + if (fd < 0) { + error = errno; + VLOG_ERR("failed to create raw socket (%s)", strerror(error)); + goto error; + } + + /* Set non-blocking mode. */ + error = set_nonblocking(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; + sll.sll_protocol = (OVS_FORCE unsigned short int) htons(ETH_P_ALL); + if (bind(fd, (struct sockaddr *) &sll, sizeof sll) < 0) { + error = errno; + VLOG_ERR("%s: failed to bind raw socket (%s)", + netdev_get_name(netdev_), strerror(error)); + goto error; + } + + netdev->fd = fd; + return 0; + +error: + if (fd >= 0) { + close(fd); + } + return error; +} + static int netdev_linux_recv(struct netdev *netdev_, void *data, size_t size) { struct netdev_linux *netdev = netdev_linux_cast(netdev_); if (netdev->fd < 0) { - /* Device was opened with NETDEV_ETH_TYPE_NONE. */ + /* Device is not listening. */ return -EAGAIN; } @@ -996,6 +1000,29 @@ netdev_linux_get_mtu(const struct netdev *netdev_, int *mtup) return 0; } +/* Sets the maximum size of transmitted (MTU) for given device using linux + * networking ioctl interface. + */ +static int +netdev_linux_set_mtu(const struct netdev *netdev_, int mtu) +{ + struct netdev_dev_linux *netdev_dev = + netdev_dev_linux_cast(netdev_get_dev(netdev_)); + struct ifreq ifr; + int error; + + ifr.ifr_mtu = mtu; + error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr, + SIOCSIFMTU, "SIOCSIFMTU"); + if (error) { + return error; + } + + netdev_dev->mtu = ifr.ifr_mtu; + netdev_dev->cache_valid |= VALID_MTU; + return 0; +} + /* Returns the ifindex of 'netdev', if successful, as a positive number. * On failure, returns a negative errno value. */ static int @@ -2246,14 +2273,15 @@ netdev_linux_change_seq(const struct netdev *netdev) \ CREATE, \ netdev_linux_destroy, \ + NULL, /* get_config */ \ NULL, /* set_config */ \ - NULL, /* config_equal */ \ \ netdev_linux_open, \ netdev_linux_close, \ \ ENUMERATE, \ \ + netdev_linux_listen, \ netdev_linux_recv, \ netdev_linux_recv_wait, \ netdev_linux_drain, \ @@ -2264,6 +2292,7 @@ netdev_linux_change_seq(const struct netdev *netdev) netdev_linux_set_etheraddr, \ netdev_linux_get_etheraddr, \ netdev_linux_get_mtu, \ + netdev_linux_set_mtu, \ netdev_linux_get_ifindex, \ netdev_linux_get_carrier, \ netdev_linux_set_miimon_interval, \ @@ -2407,11 +2436,11 @@ htb_setup_class__(struct netdev *netdev, unsigned int handle, int error; int mtu; - netdev_get_mtu(netdev, &mtu); - if (mtu == INT_MAX) { + error = netdev_get_mtu(netdev, &mtu); + if (error) { VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU", netdev_get_name(netdev)); - return EINVAL; + return error; } memset(&opt, 0, sizeof opt); @@ -2530,13 +2559,13 @@ htb_parse_class_details__(struct netdev *netdev, const char *max_rate_s = shash_find_data(details, "max-rate"); const char *burst_s = shash_find_data(details, "burst"); const char *priority_s = shash_find_data(details, "priority"); - int mtu; + int mtu, error; - netdev_get_mtu(netdev, &mtu); - if (mtu == INT_MAX) { + error = netdev_get_mtu(netdev, &mtu); + if (error) { VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU", netdev_get_name(netdev)); - return EINVAL; + return error; } /* HTB requires at least an mtu sized min-rate to send any traffic even @@ -4152,8 +4181,12 @@ get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]) ovs_strzcpy(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)); + /* ENODEV probably means that a vif disappeared asynchronously and + * hasn't been removed from the database yet, so reduce the log level + * to INFO for that case. */ + VLOG(errno == ENODEV ? VLL_INFO : VLL_ERR, + "ioctl(SIOCGIFHWADDR) on %s device failed: %s", + netdev_name, strerror(errno)); return errno; } hwaddr_family = ifr.ifr_hwaddr.sa_family; @@ -4210,6 +4243,51 @@ netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd, } } +/* Modifies the 'flag' bit in ethtool's flags field for 'netdev'. If + * 'enable' is true, the bit is set. Otherwise, it is cleared. */ +int +netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag, + const char *flag_name, bool enable) +{ + const char *netdev_name = netdev_get_name(netdev); + struct ethtool_value evalue; + uint32_t new_flags; + int error; + + memset(&evalue, 0, sizeof evalue); + error = netdev_linux_do_ethtool(netdev_name, + (struct ethtool_cmd *)&evalue, + ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS"); + if (error) { + return error; + } + + evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0); + error = netdev_linux_do_ethtool(netdev_name, + (struct ethtool_cmd *)&evalue, + ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS"); + if (error) { + return error; + } + + memset(&evalue, 0, sizeof evalue); + error = netdev_linux_do_ethtool(netdev_name, + (struct ethtool_cmd *)&evalue, + ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS"); + if (error) { + return error; + } + + if (new_flags != evalue.data) { + VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network " + "device %s failed", enable ? "enable" : "disable", + flag_name, netdev_name); + return EOPNOTSUPP; + } + + return 0; +} + static int netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd, const char *cmd_name)