lib/netdev-linux.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "netdev-linux.h"
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <arpa/inet.h>
  24 #include <inttypes.h>
  25 #include <linux/filter.h>
  26 #include <linux/gen_stats.h>
  27 #include <linux/if_ether.h>
  28 #include <linux/if_tun.h>
  29 #include <linux/types.h>
  30 #include <linux/ethtool.h>
  31 #include <linux/mii.h>
  32 #include <linux/pkt_cls.h>
  33 #include <linux/pkt_sched.h>
  34 #include <linux/rtnetlink.h>
  35 #include <linux/sockios.h>
  36 #include <linux/version.h>
  37 #include <sys/types.h>
  38 #include <sys/ioctl.h>
  39 #include <sys/socket.h>
  40 #include <netpacket/packet.h>
  41 #include <net/if.h>
  42 #include <net/if_arp.h>
  43 #include <net/if_packet.h>
  44 #include <net/route.h>
  45 #include <netinet/in.h>
  46 #include <poll.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 #include "connectivity.h"
  52 #include "coverage.h"
  53 #include "dpif-linux.h"
  54 #include "dynamic-string.h"
  55 #include "fatal-signal.h"
  56 #include "hash.h"
  57 #include "hmap.h"
  58 #include "netdev-provider.h"
  59 #include "netdev-vport.h"
  60 #include "netlink-notifier.h"
  61 #include "netlink-socket.h"
  62 #include "netlink.h"
  63 #include "ofpbuf.h"
  64 #include "openflow/openflow.h"
  65 #include "ovs-atomic.h"
  66 #include "packets.h"
  67 #include "poll-loop.h"
  68 #include "rtnetlink-link.h"
  69 #include "seq.h"
  70 #include "shash.h"
  71 #include "socket-util.h"
  72 #include "sset.h"
  73 #include "timer.h"
  74 #include "unaligned.h"
  75 #include "vlog.h"
  76
  77 VLOG_DEFINE_THIS_MODULE(netdev_linux);
  78
  79 COVERAGE_DEFINE(netdev_set_policing);
  80 COVERAGE_DEFINE(netdev_arp_lookup);
  81 COVERAGE_DEFINE(netdev_get_ifindex);
  82 COVERAGE_DEFINE(netdev_get_hwaddr);
  83 COVERAGE_DEFINE(netdev_set_hwaddr);
  84 COVERAGE_DEFINE(netdev_get_ethtool);
  85 COVERAGE_DEFINE(netdev_set_ethtool);
  86
  87 \f
  88 /* These were introduced in Linux 2.6.14, so they might be missing if we have
  89  * old headers. */
  90 #ifndef ADVERTISED_Pause
  91 #define ADVERTISED_Pause                (1 << 13)
  92 #endif
  93 #ifndef ADVERTISED_Asym_Pause
  94 #define ADVERTISED_Asym_Pause           (1 << 14)
  95 #endif
  96
  97 /* These were introduced in Linux 2.6.24, so they might be missing if we
  98  * have old headers. */
  99 #ifndef ETHTOOL_GFLAGS
 100 #define ETHTOOL_GFLAGS       0x00000025 /* Get flags bitmap(ethtool_value) */
 101 #endif
 102 #ifndef ETHTOOL_SFLAGS
 103 #define ETHTOOL_SFLAGS       0x00000026 /* Set flags bitmap(ethtool_value) */
 104 #endif
 105
 106 /* This was introduced in Linux 2.6.25, so it might be missing if we have old
 107  * headers. */
 108 #ifndef TC_RTAB_SIZE
 109 #define TC_RTAB_SIZE 1024
 110 #endif
 111
 112 enum {
 113     VALID_IFINDEX           = 1 << 0,
 114     VALID_ETHERADDR         = 1 << 1,
 115     VALID_IN4               = 1 << 2,
 116     VALID_IN6               = 1 << 3,
 117     VALID_MTU               = 1 << 4,
 118     VALID_POLICING          = 1 << 5,
 119     VALID_VPORT_STAT_ERROR  = 1 << 6,
 120     VALID_DRVINFO           = 1 << 7,
 121     VALID_FEATURES          = 1 << 8,
 122 };
 123 \f
 124 /* Traffic control. */
 125
 126 /* An instance of a traffic control class.  Always associated with a particular
 127  * network device.
 128  *
 129  * Each TC implementation subclasses this with whatever additional data it
 130  * needs. */
 131 struct tc {
 132     const struct tc_ops *ops;
 133     struct hmap queues;         /* Contains "struct tc_queue"s.
 134                                  * Read by generic TC layer.
 135                                  * Written only by TC implementation. */
 136 };
 137
 138 #define TC_INITIALIZER(TC, OPS) { OPS, HMAP_INITIALIZER(&(TC)->queues) }
 139
 140 /* One traffic control queue.
 141  *
 142  * Each TC implementation subclasses this with whatever additional data it
 143  * needs. */
 144 struct tc_queue {
 145     struct hmap_node hmap_node; /* In struct tc's "queues" hmap. */
 146     unsigned int queue_id;      /* OpenFlow queue ID. */
 147     long long int created;      /* Time queue was created, in msecs. */
 148 };
 149
 150 /* A particular kind of traffic control.  Each implementation generally maps to
 151  * one particular Linux qdisc class.
 152  *
 153  * The functions below return 0 if successful or a positive errno value on
 154  * failure, except where otherwise noted.  All of them must be provided, except
 155  * where otherwise noted. */
 156 struct tc_ops {
 157     /* Name used by kernel in the TCA_KIND attribute of tcmsg, e.g. "htb".
 158      * This is null for tc_ops_default and tc_ops_other, for which there are no
 159      * appropriate values. */
 160     const char *linux_name;
 161
 162     /* Name used in OVS database, e.g. "linux-htb".  Must be nonnull. */
 163     const char *ovs_name;
 164
 165     /* Number of supported OpenFlow queues, 0 for qdiscs that have no
 166      * queues.  The queues are numbered 0 through n_queues - 1. */
 167     unsigned int n_queues;
 168
 169     /* Called to install this TC class on 'netdev'.  The implementation should
 170      * make the Netlink calls required to set up 'netdev' with the right qdisc
 171      * and configure it according to 'details'.  The implementation may assume
 172      * that the current qdisc is the default; that is, there is no need for it
 173      * to delete the current qdisc before installing itself.
 174      *
 175      * The contents of 'details' should be documented as valid for 'ovs_name'
 176      * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
 177      * (which is built as ovs-vswitchd.conf.db(8)).
 178      *
 179      * This function must return 0 if and only if it sets 'netdev->tc' to an
 180      * initialized 'struct tc'.
 181      *
 182      * (This function is null for tc_ops_other, which cannot be installed.  For
 183      * other TC classes it should always be nonnull.) */
 184     int (*tc_install)(struct netdev *netdev, const struct smap *details);
 185
 186     /* Called when the netdev code determines (through a Netlink query) that
 187      * this TC class's qdisc is installed on 'netdev', but we didn't install
 188      * it ourselves and so don't know any of the details.
 189      *
 190      * 'nlmsg' is the kernel reply to a RTM_GETQDISC Netlink message for
 191      * 'netdev'.  The TCA_KIND attribute of 'nlmsg' is 'linux_name'.  The
 192      * implementation should parse the other attributes of 'nlmsg' as
 193      * necessary to determine its configuration.  If necessary it should also
 194      * use Netlink queries to determine the configuration of queues on
 195      * 'netdev'.
 196      *
 197      * This function must return 0 if and only if it sets 'netdev->tc' to an
 198      * initialized 'struct tc'. */
 199     int (*tc_load)(struct netdev *netdev, struct ofpbuf *nlmsg);
 200
 201     /* Destroys the data structures allocated by the implementation as part of
 202      * 'tc'.  (This includes destroying 'tc->queues' by calling
 203      * tc_destroy(tc).
 204      *
 205      * The implementation should not need to perform any Netlink calls.  If
 206      * desirable, the caller is responsible for deconfiguring the kernel qdisc.
 207      * (But it may not be desirable.)
 208      *
 209      * This function may be null if 'tc' is trivial. */
 210     void (*tc_destroy)(struct tc *tc);
 211
 212     /* Retrieves details of 'netdev->tc' configuration into 'details'.
 213      *
 214      * The implementation should not need to perform any Netlink calls, because
 215      * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
 216      * cached the configuration.
 217      *
 218      * The contents of 'details' should be documented as valid for 'ovs_name'
 219      * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
 220      * (which is built as ovs-vswitchd.conf.db(8)).
 221      *
 222      * This function may be null if 'tc' is not configurable.
 223      */
 224     int (*qdisc_get)(const struct netdev *netdev, struct smap *details);
 225
 226     /* Reconfigures 'netdev->tc' according to 'details', performing any
 227      * required Netlink calls to complete the reconfiguration.
 228      *
 229      * The contents of 'details' should be documented as valid for 'ovs_name'
 230      * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
 231      * (which is built as ovs-vswitchd.conf.db(8)).
 232      *
 233      * This function may be null if 'tc' is not configurable.
 234      */
 235     int (*qdisc_set)(struct netdev *, const struct smap *details);
 236
 237     /* Retrieves details of 'queue' on 'netdev->tc' into 'details'.  'queue' is
 238      * one of the 'struct tc_queue's within 'netdev->tc->queues'.
 239      *
 240      * The contents of 'details' should be documented as valid for 'ovs_name'
 241      * in the "other_config" column in the "Queue" table in
 242      * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
 243      *
 244      * The implementation should not need to perform any Netlink calls, because
 245      * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
 246      * cached the queue configuration.
 247      *
 248      * This function may be null if 'tc' does not have queues ('n_queues' is
 249      * 0). */
 250     int (*class_get)(const struct netdev *netdev, const struct tc_queue *queue,
 251                      struct smap *details);
 252
 253     /* Configures or reconfigures 'queue_id' on 'netdev->tc' according to
 254      * 'details', perfoming any required Netlink calls to complete the
 255      * reconfiguration.  The caller ensures that 'queue_id' is less than
 256      * 'n_queues'.
 257      *
 258      * The contents of 'details' should be documented as valid for 'ovs_name'
 259      * in the "other_config" column in the "Queue" table in
 260      * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
 261      *
 262      * This function may be null if 'tc' does not have queues or its queues are
 263      * not configurable. */
 264     int (*class_set)(struct netdev *, unsigned int queue_id,
 265                      const struct smap *details);
 266
 267     /* Deletes 'queue' from 'netdev->tc'.  'queue' is one of the 'struct
 268      * tc_queue's within 'netdev->tc->queues'.
 269      *
 270      * This function may be null if 'tc' does not have queues or its queues
 271      * cannot be deleted. */
 272     int (*class_delete)(struct netdev *, struct tc_queue *queue);
 273
 274     /* Obtains stats for 'queue' from 'netdev->tc'.  'queue' is one of the
 275      * 'struct tc_queue's within 'netdev->tc->queues'.
 276      *
 277      * On success, initializes '*stats'.
 278      *
 279      * This function may be null if 'tc' does not have queues or if it cannot
 280      * report queue statistics. */
 281     int (*class_get_stats)(const struct netdev *netdev,
 282                            const struct tc_queue *queue,
 283                            struct netdev_queue_stats *stats);
 284
 285     /* Extracts queue stats from 'nlmsg', which is a response to a
 286      * RTM_GETTCLASS message, and passes them to 'cb' along with 'aux'.
 287      *
 288      * This function may be null if 'tc' does not have queues or if it cannot
 289      * report queue statistics. */
 290     int (*class_dump_stats)(const struct netdev *netdev,
 291                             const struct ofpbuf *nlmsg,
 292                             netdev_dump_queue_stats_cb *cb, void *aux);
 293 };
 294
 295 static void
 296 tc_init(struct tc *tc, const struct tc_ops *ops)
 297 {
 298     tc->ops = ops;
 299     hmap_init(&tc->queues);
 300 }
 301
 302 static void
 303 tc_destroy(struct tc *tc)
 304 {
 305     hmap_destroy(&tc->queues);
 306 }
 307
 308 static const struct tc_ops tc_ops_htb;
 309 static const struct tc_ops tc_ops_hfsc;
 310 static const struct tc_ops tc_ops_default;
 311 static const struct tc_ops tc_ops_other;
 312
 313 static const struct tc_ops *const tcs[] = {
 314     &tc_ops_htb,                /* Hierarchy token bucket (see tc-htb(8)). */
 315     &tc_ops_hfsc,               /* Hierarchical fair service curve. */
 316     &tc_ops_default,            /* Default qdisc (see tc-pfifo_fast(8)). */
 317     &tc_ops_other,              /* Some other qdisc. */
 318     NULL
 319 };
 320
 321 static unsigned int tc_make_handle(unsigned int major, unsigned int minor);
 322 static unsigned int tc_get_major(unsigned int handle);
 323 static unsigned int tc_get_minor(unsigned int handle);
 324
 325 static unsigned int tc_ticks_to_bytes(unsigned int rate, unsigned int ticks);
 326 static unsigned int tc_bytes_to_ticks(unsigned int rate, unsigned int size);
 327 static unsigned int tc_buffer_per_jiffy(unsigned int rate);
 328
 329 static struct tcmsg *tc_make_request(const struct netdev *, int type,
 330                                      unsigned int flags, struct ofpbuf *);
 331 static int tc_transact(struct ofpbuf *request, struct ofpbuf **replyp);
 332 static int tc_add_del_ingress_qdisc(struct netdev *netdev, bool add);
 333 static int tc_add_policer(struct netdev *netdev, int kbits_rate,
 334                           int kbits_burst);
 335
 336 static int tc_parse_qdisc(const struct ofpbuf *, const char **kind,
 337                           struct nlattr **options);
 338 static int tc_parse_class(const struct ofpbuf *, unsigned int *queue_id,
 339                           struct nlattr **options,
 340                           struct netdev_queue_stats *);
 341 static int tc_query_class(const struct netdev *,
 342                           unsigned int handle, unsigned int parent,
 343                           struct ofpbuf **replyp);
 344 static int tc_delete_class(const struct netdev *, unsigned int handle);
 345
 346 static int tc_del_qdisc(struct netdev *netdev);
 347 static int tc_query_qdisc(const struct netdev *netdev);
 348
 349 static int tc_calc_cell_log(unsigned int mtu);
 350 static void tc_fill_rate(struct tc_ratespec *rate, uint64_t bps, int mtu);
 351 static void tc_put_rtab(struct ofpbuf *, uint16_t type,
 352                         const struct tc_ratespec *rate);
 353 static int tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes);
 354 \f
 355 struct netdev_linux {
 356     struct netdev up;
 357
 358     /* Protects all members below. */
 359     struct ovs_mutex mutex;
 360
 361     unsigned int cache_valid;
 362
 363     bool miimon;                    /* Link status of last poll. */
 364     long long int miimon_interval;  /* Miimon Poll rate. Disabled if <= 0. */
 365     struct timer miimon_timer;
 366
 367     /* The following are figured out "on demand" only.  They are only valid
 368      * when the corresponding VALID_* bit in 'cache_valid' is set. */
 369     int ifindex;
 370     uint8_t etheraddr[ETH_ADDR_LEN];
 371     struct in_addr address, netmask;
 372     struct in6_addr in6;
 373     int mtu;
 374     unsigned int ifi_flags;
 375     long long int carrier_resets;
 376     uint32_t kbits_rate;        /* Policing data. */
 377     uint32_t kbits_burst;
 378     int vport_stats_error;      /* Cached error code from vport_get_stats().
 379                                    0 or an errno value. */
 380     int netdev_mtu_error;       /* Cached error code from SIOCGIFMTU or SIOCSIFMTU. */
 381     int ether_addr_error;       /* Cached error code from set/get etheraddr. */
 382     int netdev_policing_error;  /* Cached error code from set policing. */
 383     int get_features_error;     /* Cached error code from ETHTOOL_GSET. */
 384     int get_ifindex_error;      /* Cached error code from SIOCGIFINDEX. */
 385
 386     enum netdev_features current;    /* Cached from ETHTOOL_GSET. */
 387     enum netdev_features advertised; /* Cached from ETHTOOL_GSET. */
 388     enum netdev_features supported;  /* Cached from ETHTOOL_GSET. */
 389
 390     struct ethtool_drvinfo drvinfo;  /* Cached from ETHTOOL_GDRVINFO. */
 391     struct tc *tc;
 392
 393     /* For devices of class netdev_tap_class only. */
 394     int tap_fd;
 395 };
 396
 397 struct netdev_rx_linux {
 398     struct netdev_rx up;
 399     bool is_tap;
 400     int fd;
 401 };
 402
 403 /* This is set pretty low because we probably won't learn anything from the
 404  * additional log messages. */
 405 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
 406
 407 /* Polling miimon status for all ports causes performance degradation when
 408  * handling a large number of ports. If there are no devices using miimon, then
 409  * we skip netdev_linux_miimon_run() and netdev_linux_miimon_wait(). */
 410 static atomic_int miimon_cnt = ATOMIC_VAR_INIT(0);
 411
 412 static void netdev_linux_run(void);
 413
 414 static int netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *,
 415                                    int cmd, const char *cmd_name);
 416 static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
 417                                  int cmd, const char *cmd_name);
 418 static int get_flags(const struct netdev *, unsigned int *flags);
 419 static int set_flags(const char *, unsigned int flags);
 420 static int update_flags(struct netdev_linux *netdev, enum netdev_flags off,
 421                         enum netdev_flags on, enum netdev_flags *old_flagsp)
 422     OVS_REQUIRES(netdev->mutex);
 423 static int do_get_ifindex(const char *netdev_name);
 424 static int get_ifindex(const struct netdev *, int *ifindexp);
 425 static int do_set_addr(struct netdev *netdev,
 426                        int ioctl_nr, const char *ioctl_name,
 427                        struct in_addr addr);
 428 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
 429 static int set_etheraddr(const char *netdev_name, const uint8_t[ETH_ADDR_LEN]);
 430 static int get_stats_via_netlink(const struct netdev *, struct netdev_stats *);
 431 static int af_packet_sock(void);
 432 static bool netdev_linux_miimon_enabled(void);
 433 static void netdev_linux_miimon_run(void);
 434 static void netdev_linux_miimon_wait(void);
 435
 436 static bool
 437 is_netdev_linux_class(const struct netdev_class *netdev_class)
 438 {
 439     return netdev_class->run == netdev_linux_run;
 440 }
 441
 442 static bool
 443 is_tap_netdev(const struct netdev *netdev)
 444 {
 445     return netdev_get_class(netdev) == &netdev_tap_class;
 446 }
 447
 448 static struct netdev_linux *
 449 netdev_linux_cast(const struct netdev *netdev)
 450 {
 451     ovs_assert(is_netdev_linux_class(netdev_get_class(netdev)));
 452
 453     return CONTAINER_OF(netdev, struct netdev_linux, up);
 454 }
 455
 456 static struct netdev_rx_linux *
 457 netdev_rx_linux_cast(const struct netdev_rx *rx)
 458 {
 459     ovs_assert(is_netdev_linux_class(netdev_get_class(rx->netdev)));
 460     return CONTAINER_OF(rx, struct netdev_rx_linux, up);
 461 }
 462 \f
 463 static void netdev_linux_update(struct netdev_linux *netdev,
 464                                 const struct rtnetlink_link_change *)
 465     OVS_REQUIRES(netdev->mutex);
 466 static void netdev_linux_changed(struct netdev_linux *netdev,
 467                                  unsigned int ifi_flags, unsigned int mask)
 468     OVS_REQUIRES(netdev->mutex);
 469
 470 /* Returns a NETLINK_ROUTE socket listening for RTNLGRP_LINK changes, or NULL
 471  * if no such socket could be created. */
 472 static struct nl_sock *
 473 netdev_linux_notify_sock(void)
 474 {
 475     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
 476     static struct nl_sock *sock;
 477
 478     if (ovsthread_once_start(&once)) {
 479         int error;
 480
 481         error = nl_sock_create(NETLINK_ROUTE, &sock);
 482         if (!error) {
 483             error = nl_sock_join_mcgroup(sock, RTNLGRP_LINK);
 484             if (error) {
 485                 nl_sock_destroy(sock);
 486                 sock = NULL;
 487             }
 488         }
 489         ovsthread_once_done(&once);
 490     }
 491
 492     return sock;
 493 }
 494
 495 static bool
 496 netdev_linux_miimon_enabled(void)
 497 {
 498     int miimon;
 499
 500     atomic_read(&miimon_cnt, &miimon);
 501     return miimon > 0;
 502 }
 503
 504 static void
 505 netdev_linux_run(void)
 506 {
 507     struct nl_sock *sock;
 508     int error;
 509
 510     if (netdev_linux_miimon_enabled()) {
 511         netdev_linux_miimon_run();
 512     }
 513
 514     sock = netdev_linux_notify_sock();
 515     if (!sock) {
 516         return;
 517     }
 518
 519     do {
 520         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 521         uint64_t buf_stub[4096 / 8];
 522         struct ofpbuf buf;
 523
 524         ofpbuf_use_stub(&buf, buf_stub, sizeof buf_stub);
 525         error = nl_sock_recv(sock, &buf, false);
 526         if (!error) {
 527             struct rtnetlink_link_change change;
 528
 529             if (rtnetlink_link_parse(&buf, &change)) {
 530                 struct netdev *netdev_ = netdev_from_name(change.ifname);
 531                 if (netdev_ && is_netdev_linux_class(netdev_->netdev_class)) {
 532                     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 533
 534                     ovs_mutex_lock(&netdev->mutex);
 535                     netdev_linux_update(netdev, &change);
 536                     ovs_mutex_unlock(&netdev->mutex);
 537                 }
 538                 netdev_close(netdev_);
 539             }
 540         } else if (error == ENOBUFS) {
 541             struct shash device_shash;
 542             struct shash_node *node;
 543
 544             nl_sock_drain(sock);
 545
 546             shash_init(&device_shash);
 547             netdev_get_devices(&netdev_linux_class, &device_shash);
 548             SHASH_FOR_EACH (node, &device_shash) {
 549                 struct netdev *netdev_ = node->data;
 550                 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 551                 unsigned int flags;
 552
 553                 ovs_mutex_lock(&netdev->mutex);
 554                 get_flags(netdev_, &flags);
 555                 netdev_linux_changed(netdev, flags, 0);
 556                 ovs_mutex_unlock(&netdev->mutex);
 557
 558                 netdev_close(netdev_);
 559             }
 560             shash_destroy(&device_shash);
 561         } else if (error != EAGAIN) {
 562             VLOG_WARN_RL(&rl, "error reading or parsing netlink (%s)",
 563                          ovs_strerror(error));
 564         }
 565         ofpbuf_uninit(&buf);
 566     } while (!error);
 567 }
 568
 569 static void
 570 netdev_linux_wait(void)
 571 {
 572     struct nl_sock *sock;
 573
 574     if (netdev_linux_miimon_enabled()) {
 575         netdev_linux_miimon_wait();
 576     }
 577     sock = netdev_linux_notify_sock();
 578     if (sock) {
 579         nl_sock_wait(sock, POLLIN);
 580     }
 581 }
 582
 583 static void
 584 netdev_linux_changed(struct netdev_linux *dev,
 585                      unsigned int ifi_flags, unsigned int mask)
 586     OVS_REQUIRES(dev->mutex)
 587 {
 588     seq_change(connectivity_seq_get());
 589
 590     if ((dev->ifi_flags ^ ifi_flags) & IFF_RUNNING) {
 591         dev->carrier_resets++;
 592     }
 593     dev->ifi_flags = ifi_flags;
 594
 595     dev->cache_valid &= mask;
 596 }
 597
 598 static void
 599 netdev_linux_update(struct netdev_linux *dev,
 600                     const struct rtnetlink_link_change *change)
 601     OVS_REQUIRES(dev->mutex)
 602 {
 603     if (change->nlmsg_type == RTM_NEWLINK) {
 604         /* Keep drv-info */
 605         netdev_linux_changed(dev, change->ifi_flags, VALID_DRVINFO);
 606
 607         /* Update netdev from rtnl-change msg. */
 608         if (change->mtu) {
 609             dev->mtu = change->mtu;
 610             dev->cache_valid |= VALID_MTU;
 611             dev->netdev_mtu_error = 0;
 612         }
 613
 614         if (!eth_addr_is_zero(change->addr)) {
 615             memcpy(dev->etheraddr, change->addr, ETH_ADDR_LEN);
 616             dev->cache_valid |= VALID_ETHERADDR;
 617             dev->ether_addr_error = 0;
 618         }
 619
 620         dev->ifindex = change->ifi_index;
 621         dev->cache_valid |= VALID_IFINDEX;
 622         dev->get_ifindex_error = 0;
 623
 624     } else {
 625         netdev_linux_changed(dev, change->ifi_flags, 0);
 626     }
 627 }
 628
 629 static struct netdev *
 630 netdev_linux_alloc(void)
 631 {
 632     struct netdev_linux *netdev = xzalloc(sizeof *netdev);
 633     return &netdev->up;
 634 }
 635
 636 static void
 637 netdev_linux_common_construct(struct netdev_linux *netdev)
 638 {
 639     ovs_mutex_init(&netdev->mutex);
 640 }
 641
 642 /* Creates system and internal devices. */
 643 static int
 644 netdev_linux_construct(struct netdev *netdev_)
 645 {
 646     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 647     int error;
 648
 649     netdev_linux_common_construct(netdev);
 650
 651     error = get_flags(&netdev->up, &netdev->ifi_flags);
 652     if (error == ENODEV) {
 653         if (netdev->up.netdev_class != &netdev_internal_class) {
 654             /* The device does not exist, so don't allow it to be opened. */
 655             return ENODEV;
 656         } else {
 657             /* "Internal" netdevs have to be created as netdev objects before
 658              * they exist in the kernel, because creating them in the kernel
 659              * happens by passing a netdev object to dpif_port_add().
 660              * Therefore, ignore the error. */
 661         }
 662     }
 663
 664     return 0;
 665 }
 666
 667 /* For most types of netdevs we open the device for each call of
 668  * netdev_open().  However, this is not the case with tap devices,
 669  * since it is only possible to open the device once.  In this
 670  * situation we share a single file descriptor, and consequently
 671  * buffers, across all readers.  Therefore once data is read it will
 672  * be unavailable to other reads for tap devices. */
 673 static int
 674 netdev_linux_construct_tap(struct netdev *netdev_)
 675 {
 676     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 677     static const char tap_dev[] = "/dev/net/tun";
 678     const char *name = netdev_->name;
 679     struct ifreq ifr;
 680     int error;
 681
 682     netdev_linux_common_construct(netdev);
 683
 684     /* Open tap device. */
 685     netdev->tap_fd = open(tap_dev, O_RDWR);
 686     if (netdev->tap_fd < 0) {
 687         error = errno;
 688         VLOG_WARN("opening \"%s\" failed: %s", tap_dev, ovs_strerror(error));
 689         return error;
 690     }
 691
 692     /* Create tap device. */
 693     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 694     ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
 695     if (ioctl(netdev->tap_fd, TUNSETIFF, &ifr) == -1) {
 696         VLOG_WARN("%s: creating tap device failed: %s", name,
 697                   ovs_strerror(errno));
 698         error = errno;
 699         goto error_close;
 700     }
 701
 702     /* Make non-blocking. */
 703     error = set_nonblocking(netdev->tap_fd);
 704     if (error) {
 705         goto error_close;
 706     }
 707
 708     return 0;
 709
 710 error_close:
 711     close(netdev->tap_fd);
 712     return error;
 713 }
 714
 715 static void
 716 netdev_linux_destruct(struct netdev *netdev_)
 717 {
 718     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 719
 720     if (netdev->tc && netdev->tc->ops->tc_destroy) {
 721         netdev->tc->ops->tc_destroy(netdev->tc);
 722     }
 723
 724     if (netdev_get_class(netdev_) == &netdev_tap_class
 725         && netdev->tap_fd >= 0)
 726     {
 727         close(netdev->tap_fd);
 728     }
 729
 730     if (netdev->miimon_interval > 0) {
 731         int junk;
 732         atomic_sub(&miimon_cnt, 1, &junk);
 733     }
 734
 735     ovs_mutex_destroy(&netdev->mutex);
 736 }
 737
 738 static void
 739 netdev_linux_dealloc(struct netdev *netdev_)
 740 {
 741     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 742     free(netdev);
 743 }
 744
 745 static struct netdev_rx *
 746 netdev_linux_rx_alloc(void)
 747 {
 748     struct netdev_rx_linux *rx = xzalloc(sizeof *rx);
 749     return &rx->up;
 750 }
 751
 752 static int
 753 netdev_linux_rx_construct(struct netdev_rx *rx_)
 754 {
 755     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 756     struct netdev *netdev_ = rx->up.netdev;
 757     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 758     int error;
 759
 760     ovs_mutex_lock(&netdev->mutex);
 761     rx->is_tap = is_tap_netdev(netdev_);
 762     if (rx->is_tap) {
 763         rx->fd = netdev->tap_fd;
 764     } else {
 765         struct sockaddr_ll sll;
 766         int ifindex;
 767         /* Result of tcpdump -dd inbound */
 768         static const struct sock_filter filt[] = {
 769             { 0x28, 0, 0, 0xfffff004 }, /* ldh [0] */
 770             { 0x15, 0, 1, 0x00000004 }, /* jeq #4     jt 2  jf 3 */
 771             { 0x6, 0, 0, 0x00000000 },  /* ret #0 */
 772             { 0x6, 0, 0, 0x0000ffff }   /* ret #65535 */
 773         };
 774         static const struct sock_fprog fprog = {
 775             ARRAY_SIZE(filt), (struct sock_filter *) filt
 776         };
 777
 778         /* Create file descriptor. */
 779         rx->fd = socket(PF_PACKET, SOCK_RAW, 0);
 780         if (rx->fd < 0) {
 781             error = errno;
 782             VLOG_ERR("failed to create raw socket (%s)", ovs_strerror(error));
 783             goto error;
 784         }
 785
 786         /* Set non-blocking mode. */
 787         error = set_nonblocking(rx->fd);
 788         if (error) {
 789             goto error;
 790         }
 791
 792         /* Get ethernet device index. */
 793         error = get_ifindex(&netdev->up, &ifindex);
 794         if (error) {
 795             goto error;
 796         }
 797
 798         /* Bind to specific ethernet device. */
 799         memset(&sll, 0, sizeof sll);
 800         sll.sll_family = AF_PACKET;
 801         sll.sll_ifindex = ifindex;
 802         sll.sll_protocol = (OVS_FORCE unsigned short int) htons(ETH_P_ALL);
 803         if (bind(rx->fd, (struct sockaddr *) &sll, sizeof sll) < 0) {
 804             error = errno;
 805             VLOG_ERR("%s: failed to bind raw socket (%s)",
 806                      netdev_get_name(netdev_), ovs_strerror(error));
 807             goto error;
 808         }
 809
 810         /* Filter for only inbound packets. */
 811         error = setsockopt(rx->fd, SOL_SOCKET, SO_ATTACH_FILTER, &fprog,
 812                            sizeof fprog);
 813         if (error) {
 814             error = errno;
 815             VLOG_ERR("%s: failed to attach filter (%s)",
 816                      netdev_get_name(netdev_), ovs_strerror(error));
 817             goto error;
 818         }
 819     }
 820     ovs_mutex_unlock(&netdev->mutex);
 821
 822     return 0;
 823
 824 error:
 825     if (rx->fd >= 0) {
 826         close(rx->fd);
 827     }
 828     ovs_mutex_unlock(&netdev->mutex);
 829     return error;
 830 }
 831
 832 static void
 833 netdev_linux_rx_destruct(struct netdev_rx *rx_)
 834 {
 835     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 836
 837     if (!rx->is_tap) {
 838         close(rx->fd);
 839     }
 840 }
 841
 842 static void
 843 netdev_linux_rx_dealloc(struct netdev_rx *rx_)
 844 {
 845     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 846
 847     free(rx);
 848 }
 849
 850 static int
 851 netdev_linux_rx_recv(struct netdev_rx *rx_, struct ofpbuf *buffer)
 852 {
 853     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 854     ssize_t retval;
 855     size_t size = ofpbuf_tailroom(buffer);
 856
 857     do {
 858         retval = (rx->is_tap
 859                   ? read(rx->fd, buffer->data, size)
 860                   : recv(rx->fd, buffer->data, size, MSG_TRUNC));
 861     } while (retval < 0 && errno == EINTR);
 862
 863     if (retval < 0) {
 864         if (errno != EAGAIN) {
 865             VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
 866                          ovs_strerror(errno), netdev_rx_get_name(rx_));
 867         }
 868         return errno;
 869     } else if (retval > size) {
 870         return EMSGSIZE;
 871     } else {
 872         buffer->size += retval;
 873         return 0;
 874     }
 875 }
 876
 877 static void
 878 netdev_linux_rx_wait(struct netdev_rx *rx_)
 879 {
 880     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 881     poll_fd_wait(rx->fd, POLLIN);
 882 }
 883
 884 static int
 885 netdev_linux_rx_drain(struct netdev_rx *rx_)
 886 {
 887     struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
 888     if (rx->is_tap) {
 889         struct ifreq ifr;
 890         int error = af_inet_ifreq_ioctl(netdev_rx_get_name(rx_), &ifr,
 891                                         SIOCGIFTXQLEN, "SIOCGIFTXQLEN");
 892         if (error) {
 893             return error;
 894         }
 895         drain_fd(rx->fd, ifr.ifr_qlen);
 896         return 0;
 897     } else {
 898         return drain_rcvbuf(rx->fd);
 899     }
 900 }
 901
 902 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
 903  * errno value.  Returns EAGAIN without blocking if the packet cannot be queued
 904  * immediately.  Returns EMSGSIZE if a partial packet was transmitted or if
 905  * the packet is too big or too small to transmit on the device.
 906  *
 907  * The caller retains ownership of 'buffer' in all cases.
 908  *
 909  * The kernel maintains a packet transmission queue, so the caller is not
 910  * expected to do additional queuing of packets. */
 911 static int
 912 netdev_linux_send(struct netdev *netdev_, const void *data, size_t size)
 913 {
 914     for (;;) {
 915         ssize_t retval;
 916
 917         if (!is_tap_netdev(netdev_)) {
 918             /* Use our AF_PACKET socket to send to this device. */
 919             struct sockaddr_ll sll;
 920             struct msghdr msg;
 921             struct iovec iov;
 922             int ifindex;
 923             int sock;
 924
 925             sock = af_packet_sock();
 926             if (sock < 0) {
 927                 return -sock;
 928             }
 929
 930             ifindex = netdev_get_ifindex(netdev_);
 931             if (ifindex < 0) {
 932                 return -ifindex;
 933             }
 934
 935             /* We don't bother setting most fields in sockaddr_ll because the
 936              * kernel ignores them for SOCK_RAW. */
 937             memset(&sll, 0, sizeof sll);
 938             sll.sll_family = AF_PACKET;
 939             sll.sll_ifindex = ifindex;
 940
 941             iov.iov_base = CONST_CAST(void *, data);
 942             iov.iov_len = size;
 943
 944             msg.msg_name = &sll;
 945             msg.msg_namelen = sizeof sll;
 946             msg.msg_iov = &iov;
 947             msg.msg_iovlen = 1;
 948             msg.msg_control = NULL;
 949             msg.msg_controllen = 0;
 950             msg.msg_flags = 0;
 951
 952             retval = sendmsg(sock, &msg, 0);
 953         } else {
 954             /* Use the tap fd to send to this device.  This is essential for
 955              * tap devices, because packets sent to a tap device with an
 956              * AF_PACKET socket will loop back to be *received* again on the
 957              * tap device.  This doesn't occur on other interface types
 958              * because we attach a socket filter to the rx socket. */
 959             struct netdev_linux *netdev = netdev_linux_cast(netdev_);
 960
 961             retval = write(netdev->tap_fd, data, size);
 962         }
 963
 964         if (retval < 0) {
 965             /* The Linux AF_PACKET implementation never blocks waiting for room
 966              * for packets, instead returning ENOBUFS.  Translate this into
 967              * EAGAIN for the caller. */
 968             if (errno == ENOBUFS) {
 969                 return EAGAIN;
 970             } else if (errno == EINTR) {
 971                 continue;
 972             } else if (errno != EAGAIN) {
 973                 VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
 974                              netdev_get_name(netdev_), ovs_strerror(errno));
 975             }
 976             return errno;
 977         } else if (retval != size) {
 978             VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%"PRIuSIZE"d bytes of "
 979                          "%"PRIuSIZE") on %s", retval, size, netdev_get_name(netdev_));
 980             return EMSGSIZE;
 981         } else {
 982             return 0;
 983         }
 984     }
 985 }
 986
 987 /* Registers with the poll loop to wake up from the next call to poll_block()
 988  * when the packet transmission queue has sufficient room to transmit a packet
 989  * with netdev_send().
 990  *
 991  * The kernel maintains a packet transmission queue, so the client is not
 992  * expected to do additional queuing of packets.  Thus, this function is
 993  * unlikely to ever be used.  It is included for completeness. */
 994 static void
 995 netdev_linux_send_wait(struct netdev *netdev)
 996 {
 997     if (is_tap_netdev(netdev)) {
 998         /* TAP device always accepts packets.*/
 999         poll_immediate_wake();
1000     }
1001 }
1002
1003 /* Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
1004  * otherwise a positive errno value. */
1005 static int
1006 netdev_linux_set_etheraddr(struct netdev *netdev_,
1007                            const uint8_t mac[ETH_ADDR_LEN])
1008 {
1009     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1010     enum netdev_flags old_flags = 0;
1011     int error;
1012
1013     ovs_mutex_lock(&netdev->mutex);
1014
1015     if (netdev->cache_valid & VALID_ETHERADDR) {
1016         error = netdev->ether_addr_error;
1017         if (error || eth_addr_equals(netdev->etheraddr, mac)) {
1018             goto exit;
1019         }
1020         netdev->cache_valid &= ~VALID_ETHERADDR;
1021     }
1022
1023     /* Tap devices must be brought down before setting the address. */
1024     if (is_tap_netdev(netdev_)) {
1025         update_flags(netdev, NETDEV_UP, 0, &old_flags);
1026     }
1027     error = set_etheraddr(netdev_get_name(netdev_), mac);
1028     if (!error || error == ENODEV) {
1029         netdev->ether_addr_error = error;
1030         netdev->cache_valid |= VALID_ETHERADDR;
1031         if (!error) {
1032             memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
1033         }
1034     }
1035
1036     if (is_tap_netdev(netdev_) && old_flags & NETDEV_UP) {
1037         update_flags(netdev, 0, NETDEV_UP, &old_flags);
1038     }
1039
1040 exit:
1041     ovs_mutex_unlock(&netdev->mutex);
1042     return error;
1043 }
1044
1045 /* Copies 'netdev''s MAC address to 'mac' which is passed as param. */
1046 static int
1047 netdev_linux_get_etheraddr(const struct netdev *netdev_,
1048                            uint8_t mac[ETH_ADDR_LEN])
1049 {
1050     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1051     int error;
1052
1053     ovs_mutex_lock(&netdev->mutex);
1054     if (!(netdev->cache_valid & VALID_ETHERADDR)) {
1055         netdev->ether_addr_error = get_etheraddr(netdev_get_name(netdev_),
1056                                                  netdev->etheraddr);
1057         netdev->cache_valid |= VALID_ETHERADDR;
1058     }
1059
1060     error = netdev->ether_addr_error;
1061     if (!error) {
1062         memcpy(mac, netdev->etheraddr, ETH_ADDR_LEN);
1063     }
1064     ovs_mutex_unlock(&netdev->mutex);
1065
1066     return error;
1067 }
1068
1069 static int
1070 netdev_linux_get_mtu__(struct netdev_linux *netdev, int *mtup)
1071 {
1072     int error;
1073
1074     if (!(netdev->cache_valid & VALID_MTU)) {
1075         struct ifreq ifr;
1076
1077         netdev->netdev_mtu_error = af_inet_ifreq_ioctl(
1078             netdev_get_name(&netdev->up), &ifr, SIOCGIFMTU, "SIOCGIFMTU");
1079         netdev->mtu = ifr.ifr_mtu;
1080         netdev->cache_valid |= VALID_MTU;
1081     }
1082
1083     error = netdev->netdev_mtu_error;
1084     if (!error) {
1085         *mtup = netdev->mtu;
1086     }
1087
1088     return error;
1089 }
1090
1091 /* Returns the maximum size of transmitted (and received) packets on 'netdev',
1092  * in bytes, not including the hardware header; thus, this is typically 1500
1093  * bytes for Ethernet devices. */
1094 static int
1095 netdev_linux_get_mtu(const struct netdev *netdev_, int *mtup)
1096 {
1097     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1098     int error;
1099
1100     ovs_mutex_lock(&netdev->mutex);
1101     error = netdev_linux_get_mtu__(netdev, mtup);
1102     ovs_mutex_unlock(&netdev->mutex);
1103
1104     return error;
1105 }
1106
1107 /* Sets the maximum size of transmitted (MTU) for given device using linux
1108  * networking ioctl interface.
1109  */
1110 static int
1111 netdev_linux_set_mtu(const struct netdev *netdev_, int mtu)
1112 {
1113     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1114     struct ifreq ifr;
1115     int error;
1116
1117     ovs_mutex_lock(&netdev->mutex);
1118     if (netdev->cache_valid & VALID_MTU) {
1119         error = netdev->netdev_mtu_error;
1120         if (error || netdev->mtu == mtu) {
1121             goto exit;
1122         }
1123         netdev->cache_valid &= ~VALID_MTU;
1124     }
1125     ifr.ifr_mtu = mtu;
1126     error = af_inet_ifreq_ioctl(netdev_get_name(netdev_), &ifr,
1127                                 SIOCSIFMTU, "SIOCSIFMTU");
1128     if (!error || error == ENODEV) {
1129         netdev->netdev_mtu_error = error;
1130         netdev->mtu = ifr.ifr_mtu;
1131         netdev->cache_valid |= VALID_MTU;
1132     }
1133 exit:
1134     ovs_mutex_unlock(&netdev->mutex);
1135     return error;
1136 }
1137
1138 /* Returns the ifindex of 'netdev', if successful, as a positive number.
1139  * On failure, returns a negative errno value. */
1140 static int
1141 netdev_linux_get_ifindex(const struct netdev *netdev_)
1142 {
1143     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1144     int ifindex, error;
1145
1146     ovs_mutex_lock(&netdev->mutex);
1147     error = get_ifindex(netdev_, &ifindex);
1148     ovs_mutex_unlock(&netdev->mutex);
1149
1150     return error ? -error : ifindex;
1151 }
1152
1153 static int
1154 netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier)
1155 {
1156     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1157
1158     ovs_mutex_lock(&netdev->mutex);
1159     if (netdev->miimon_interval > 0) {
1160         *carrier = netdev->miimon;
1161     } else {
1162         *carrier = (netdev->ifi_flags & IFF_RUNNING) != 0;
1163     }
1164     ovs_mutex_unlock(&netdev->mutex);
1165
1166     return 0;
1167 }
1168
1169 static long long int
1170 netdev_linux_get_carrier_resets(const struct netdev *netdev_)
1171 {
1172     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1173     long long int carrier_resets;
1174
1175     ovs_mutex_lock(&netdev->mutex);
1176     carrier_resets = netdev->carrier_resets;
1177     ovs_mutex_unlock(&netdev->mutex);
1178
1179     return carrier_resets;
1180 }
1181
1182 static int
1183 netdev_linux_do_miimon(const char *name, int cmd, const char *cmd_name,
1184                        struct mii_ioctl_data *data)
1185 {
1186     struct ifreq ifr;
1187     int error;
1188
1189     memset(&ifr, 0, sizeof ifr);
1190     memcpy(&ifr.ifr_data, data, sizeof *data);
1191     error = af_inet_ifreq_ioctl(name, &ifr, cmd, cmd_name);
1192     memcpy(data, &ifr.ifr_data, sizeof *data);
1193
1194     return error;
1195 }
1196
1197 static int
1198 netdev_linux_get_miimon(const char *name, bool *miimon)
1199 {
1200     struct mii_ioctl_data data;
1201     int error;
1202
1203     *miimon = false;
1204
1205     memset(&data, 0, sizeof data);
1206     error = netdev_linux_do_miimon(name, SIOCGMIIPHY, "SIOCGMIIPHY", &data);
1207     if (!error) {
1208         /* data.phy_id is filled out by previous SIOCGMIIPHY miimon call. */
1209         data.reg_num = MII_BMSR;
1210         error = netdev_linux_do_miimon(name, SIOCGMIIREG, "SIOCGMIIREG",
1211                                        &data);
1212
1213         if (!error) {
1214             *miimon = !!(data.val_out & BMSR_LSTATUS);
1215         } else {
1216             VLOG_WARN_RL(&rl, "%s: failed to query MII", name);
1217         }
1218     } else {
1219         struct ethtool_cmd ecmd;
1220
1221         VLOG_DBG_RL(&rl, "%s: failed to query MII, falling back to ethtool",
1222                     name);
1223
1224         COVERAGE_INC(netdev_get_ethtool);
1225         memset(&ecmd, 0, sizeof ecmd);
1226         error = netdev_linux_do_ethtool(name, &ecmd, ETHTOOL_GLINK,
1227                                         "ETHTOOL_GLINK");
1228         if (!error) {
1229             struct ethtool_value eval;
1230
1231             memcpy(&eval, &ecmd, sizeof eval);
1232             *miimon = !!eval.data;
1233         } else {
1234             VLOG_WARN_RL(&rl, "%s: ethtool link status failed", name);
1235         }
1236     }
1237
1238     return error;
1239 }
1240
1241 static int
1242 netdev_linux_set_miimon_interval(struct netdev *netdev_,
1243                                  long long int interval)
1244 {
1245     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1246
1247     ovs_mutex_lock(&netdev->mutex);
1248     interval = interval > 0 ? MAX(interval, 100) : 0;
1249     if (netdev->miimon_interval != interval) {
1250         int junk;
1251
1252         if (interval && !netdev->miimon_interval) {
1253             atomic_add(&miimon_cnt, 1, &junk);
1254         } else if (!interval && netdev->miimon_interval) {
1255             atomic_sub(&miimon_cnt, 1, &junk);
1256         }
1257
1258         netdev->miimon_interval = interval;
1259         timer_set_expired(&netdev->miimon_timer);
1260     }
1261     ovs_mutex_unlock(&netdev->mutex);
1262
1263     return 0;
1264 }
1265
1266 static void
1267 netdev_linux_miimon_run(void)
1268 {
1269     struct shash device_shash;
1270     struct shash_node *node;
1271
1272     shash_init(&device_shash);
1273     netdev_get_devices(&netdev_linux_class, &device_shash);
1274     SHASH_FOR_EACH (node, &device_shash) {
1275         struct netdev *netdev = node->data;
1276         struct netdev_linux *dev = netdev_linux_cast(netdev);
1277         bool miimon;
1278
1279         ovs_mutex_lock(&dev->mutex);
1280         if (dev->miimon_interval > 0 && timer_expired(&dev->miimon_timer)) {
1281             netdev_linux_get_miimon(dev->up.name, &miimon);
1282             if (miimon != dev->miimon) {
1283                 dev->miimon = miimon;
1284                 netdev_linux_changed(dev, dev->ifi_flags, 0);
1285             }
1286
1287             timer_set_duration(&dev->miimon_timer, dev->miimon_interval);
1288         }
1289         ovs_mutex_unlock(&dev->mutex);
1290         netdev_close(netdev);
1291     }
1292
1293     shash_destroy(&device_shash);
1294 }
1295
1296 static void
1297 netdev_linux_miimon_wait(void)
1298 {
1299     struct shash device_shash;
1300     struct shash_node *node;
1301
1302     shash_init(&device_shash);
1303     netdev_get_devices(&netdev_linux_class, &device_shash);
1304     SHASH_FOR_EACH (node, &device_shash) {
1305         struct netdev *netdev = node->data;
1306         struct netdev_linux *dev = netdev_linux_cast(netdev);
1307
1308         ovs_mutex_lock(&dev->mutex);
1309         if (dev->miimon_interval > 0) {
1310             timer_wait(&dev->miimon_timer);
1311         }
1312         ovs_mutex_unlock(&dev->mutex);
1313         netdev_close(netdev);
1314     }
1315     shash_destroy(&device_shash);
1316 }
1317
1318 static void
1319 swap_uint64(uint64_t *a, uint64_t *b)
1320 {
1321     uint64_t tmp = *a;
1322     *a = *b;
1323     *b = tmp;
1324 }
1325
1326 /* Copies 'src' into 'dst', performing format conversion in the process.
1327  *
1328  * 'src' is allowed to be misaligned. */
1329 static void
1330 netdev_stats_from_ovs_vport_stats(struct netdev_stats *dst,
1331                                   const struct ovs_vport_stats *src)
1332 {
1333     dst->rx_packets = get_unaligned_u64(&src->rx_packets);
1334     dst->tx_packets = get_unaligned_u64(&src->tx_packets);
1335     dst->rx_bytes = get_unaligned_u64(&src->rx_bytes);
1336     dst->tx_bytes = get_unaligned_u64(&src->tx_bytes);
1337     dst->rx_errors = get_unaligned_u64(&src->rx_errors);
1338     dst->tx_errors = get_unaligned_u64(&src->tx_errors);
1339     dst->rx_dropped = get_unaligned_u64(&src->rx_dropped);
1340     dst->tx_dropped = get_unaligned_u64(&src->tx_dropped);
1341     dst->multicast = 0;
1342     dst->collisions = 0;
1343     dst->rx_length_errors = 0;
1344     dst->rx_over_errors = 0;
1345     dst->rx_crc_errors = 0;
1346     dst->rx_frame_errors = 0;
1347     dst->rx_fifo_errors = 0;
1348     dst->rx_missed_errors = 0;
1349     dst->tx_aborted_errors = 0;
1350     dst->tx_carrier_errors = 0;
1351     dst->tx_fifo_errors = 0;
1352     dst->tx_heartbeat_errors = 0;
1353     dst->tx_window_errors = 0;
1354 }
1355
1356 static int
1357 get_stats_via_vport__(const struct netdev *netdev, struct netdev_stats *stats)
1358 {
1359     struct dpif_linux_vport reply;
1360     struct ofpbuf *buf;
1361     int error;
1362
1363     error = dpif_linux_vport_get(netdev_get_name(netdev), &reply, &buf);
1364     if (error) {
1365         return error;
1366     } else if (!reply.stats) {
1367         ofpbuf_delete(buf);
1368         return EOPNOTSUPP;
1369     }
1370
1371     netdev_stats_from_ovs_vport_stats(stats, reply.stats);
1372
1373     ofpbuf_delete(buf);
1374
1375     return 0;
1376 }
1377
1378 static void
1379 get_stats_via_vport(const struct netdev *netdev_,
1380                     struct netdev_stats *stats)
1381 {
1382     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1383
1384     if (!netdev->vport_stats_error ||
1385         !(netdev->cache_valid & VALID_VPORT_STAT_ERROR)) {
1386         int error;
1387
1388         error = get_stats_via_vport__(netdev_, stats);
1389         if (error && error != ENOENT) {
1390             VLOG_WARN_RL(&rl, "%s: obtaining netdev stats via vport failed "
1391                          "(%s)",
1392                          netdev_get_name(netdev_), ovs_strerror(error));
1393         }
1394         netdev->vport_stats_error = error;
1395         netdev->cache_valid |= VALID_VPORT_STAT_ERROR;
1396     }
1397 }
1398
1399 /* Retrieves current device stats for 'netdev-linux'. */
1400 static int
1401 netdev_linux_get_stats(const struct netdev *netdev_,
1402                        struct netdev_stats *stats)
1403 {
1404     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1405     struct netdev_stats dev_stats;
1406     int error;
1407
1408     ovs_mutex_lock(&netdev->mutex);
1409     get_stats_via_vport(netdev_, stats);
1410     error = get_stats_via_netlink(netdev_, &dev_stats);
1411     if (error) {
1412         if (!netdev->vport_stats_error) {
1413             error = 0;
1414         }
1415     } else if (netdev->vport_stats_error) {
1416         /* stats not available from OVS then use ioctl stats. */
1417         *stats = dev_stats;
1418     } else {
1419         stats->rx_errors           += dev_stats.rx_errors;
1420         stats->tx_errors           += dev_stats.tx_errors;
1421         stats->rx_dropped          += dev_stats.rx_dropped;
1422         stats->tx_dropped          += dev_stats.tx_dropped;
1423         stats->multicast           += dev_stats.multicast;
1424         stats->collisions          += dev_stats.collisions;
1425         stats->rx_length_errors    += dev_stats.rx_length_errors;
1426         stats->rx_over_errors      += dev_stats.rx_over_errors;
1427         stats->rx_crc_errors       += dev_stats.rx_crc_errors;
1428         stats->rx_frame_errors     += dev_stats.rx_frame_errors;
1429         stats->rx_fifo_errors      += dev_stats.rx_fifo_errors;
1430         stats->rx_missed_errors    += dev_stats.rx_missed_errors;
1431         stats->tx_aborted_errors   += dev_stats.tx_aborted_errors;
1432         stats->tx_carrier_errors   += dev_stats.tx_carrier_errors;
1433         stats->tx_fifo_errors      += dev_stats.tx_fifo_errors;
1434         stats->tx_heartbeat_errors += dev_stats.tx_heartbeat_errors;
1435         stats->tx_window_errors    += dev_stats.tx_window_errors;
1436     }
1437     ovs_mutex_unlock(&netdev->mutex);
1438
1439     return error;
1440 }
1441
1442 /* Retrieves current device stats for 'netdev-tap' netdev or
1443  * netdev-internal. */
1444 static int
1445 netdev_tap_get_stats(const struct netdev *netdev_, struct netdev_stats *stats)
1446 {
1447     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1448     struct netdev_stats dev_stats;
1449     int error;
1450
1451     ovs_mutex_lock(&netdev->mutex);
1452     get_stats_via_vport(netdev_, stats);
1453     error = get_stats_via_netlink(netdev_, &dev_stats);
1454     if (error) {
1455         if (!netdev->vport_stats_error) {
1456             error = 0;
1457         }
1458     } else if (netdev->vport_stats_error) {
1459         /* Transmit and receive stats will appear to be swapped relative to the
1460          * other ports since we are the one sending the data, not a remote
1461          * computer.  For consistency, we swap them back here. This does not
1462          * apply if we are getting stats from the vport layer because it always
1463          * tracks stats from the perspective of the switch. */
1464
1465         *stats = dev_stats;
1466         swap_uint64(&stats->rx_packets, &stats->tx_packets);
1467         swap_uint64(&stats->rx_bytes, &stats->tx_bytes);
1468         swap_uint64(&stats->rx_errors, &stats->tx_errors);
1469         swap_uint64(&stats->rx_dropped, &stats->tx_dropped);
1470         stats->rx_length_errors = 0;
1471         stats->rx_over_errors = 0;
1472         stats->rx_crc_errors = 0;
1473         stats->rx_frame_errors = 0;
1474         stats->rx_fifo_errors = 0;
1475         stats->rx_missed_errors = 0;
1476         stats->tx_aborted_errors = 0;
1477         stats->tx_carrier_errors = 0;
1478         stats->tx_fifo_errors = 0;
1479         stats->tx_heartbeat_errors = 0;
1480         stats->tx_window_errors = 0;
1481     } else {
1482         stats->rx_dropped          += dev_stats.tx_dropped;
1483         stats->tx_dropped          += dev_stats.rx_dropped;
1484
1485         stats->rx_errors           += dev_stats.tx_errors;
1486         stats->tx_errors           += dev_stats.rx_errors;
1487
1488         stats->multicast           += dev_stats.multicast;
1489         stats->collisions          += dev_stats.collisions;
1490     }
1491     ovs_mutex_unlock(&netdev->mutex);
1492
1493     return error;
1494 }
1495
1496 static int
1497 netdev_internal_get_stats(const struct netdev *netdev_,
1498                           struct netdev_stats *stats)
1499 {
1500     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1501     int error;
1502
1503     ovs_mutex_lock(&netdev->mutex);
1504     get_stats_via_vport(netdev_, stats);
1505     error = netdev->vport_stats_error;
1506     ovs_mutex_unlock(&netdev->mutex);
1507
1508     return error;
1509 }
1510
1511 static int
1512 netdev_internal_set_stats(struct netdev *netdev,
1513                           const struct netdev_stats *stats)
1514 {
1515     struct ovs_vport_stats vport_stats;
1516     struct dpif_linux_vport vport;
1517     int err;
1518
1519     vport_stats.rx_packets = stats->rx_packets;
1520     vport_stats.tx_packets = stats->tx_packets;
1521     vport_stats.rx_bytes = stats->rx_bytes;
1522     vport_stats.tx_bytes = stats->tx_bytes;
1523     vport_stats.rx_errors = stats->rx_errors;
1524     vport_stats.tx_errors = stats->tx_errors;
1525     vport_stats.rx_dropped = stats->rx_dropped;
1526     vport_stats.tx_dropped = stats->tx_dropped;
1527
1528     dpif_linux_vport_init(&vport);
1529     vport.cmd = OVS_VPORT_CMD_SET;
1530     vport.name = netdev_get_name(netdev);
1531     vport.stats = &vport_stats;
1532
1533     err = dpif_linux_vport_transact(&vport, NULL, NULL);
1534
1535     /* If the vport layer doesn't know about the device, that doesn't mean it
1536      * doesn't exist (after all were able to open it when netdev_open() was
1537      * called), it just means that it isn't attached and we'll be getting
1538      * stats a different way. */
1539     if (err == ENODEV) {
1540         err = EOPNOTSUPP;
1541     }
1542
1543     return err;
1544 }
1545
1546 static void
1547 netdev_linux_read_features(struct netdev_linux *netdev)
1548 {
1549     struct ethtool_cmd ecmd;
1550     uint32_t speed;
1551     int error;
1552
1553     if (netdev->cache_valid & VALID_FEATURES) {
1554         return;
1555     }
1556
1557     COVERAGE_INC(netdev_get_ethtool);
1558     memset(&ecmd, 0, sizeof ecmd);
1559     error = netdev_linux_do_ethtool(netdev->up.name, &ecmd,
1560                                     ETHTOOL_GSET, "ETHTOOL_GSET");
1561     if (error) {
1562         goto out;
1563     }
1564
1565     /* Supported features. */
1566     netdev->supported = 0;
1567     if (ecmd.supported & SUPPORTED_10baseT_Half) {
1568         netdev->supported |= NETDEV_F_10MB_HD;
1569     }
1570     if (ecmd.supported & SUPPORTED_10baseT_Full) {
1571         netdev->supported |= NETDEV_F_10MB_FD;
1572     }
1573     if (ecmd.supported & SUPPORTED_100baseT_Half)  {
1574         netdev->supported |= NETDEV_F_100MB_HD;
1575     }
1576     if (ecmd.supported & SUPPORTED_100baseT_Full) {
1577         netdev->supported |= NETDEV_F_100MB_FD;
1578     }
1579     if (ecmd.supported & SUPPORTED_1000baseT_Half) {
1580         netdev->supported |= NETDEV_F_1GB_HD;
1581     }
1582     if (ecmd.supported & SUPPORTED_1000baseT_Full) {
1583         netdev->supported |= NETDEV_F_1GB_FD;
1584     }
1585     if (ecmd.supported & SUPPORTED_10000baseT_Full) {
1586         netdev->supported |= NETDEV_F_10GB_FD;
1587     }
1588     if (ecmd.supported & SUPPORTED_TP) {
1589         netdev->supported |= NETDEV_F_COPPER;
1590     }
1591     if (ecmd.supported & SUPPORTED_FIBRE) {
1592         netdev->supported |= NETDEV_F_FIBER;
1593     }
1594     if (ecmd.supported & SUPPORTED_Autoneg) {
1595         netdev->supported |= NETDEV_F_AUTONEG;
1596     }
1597     if (ecmd.supported & SUPPORTED_Pause) {
1598         netdev->supported |= NETDEV_F_PAUSE;
1599     }
1600     if (ecmd.supported & SUPPORTED_Asym_Pause) {
1601         netdev->supported |= NETDEV_F_PAUSE_ASYM;
1602     }
1603
1604     /* Advertised features. */
1605     netdev->advertised = 0;
1606     if (ecmd.advertising & ADVERTISED_10baseT_Half) {
1607         netdev->advertised |= NETDEV_F_10MB_HD;
1608     }
1609     if (ecmd.advertising & ADVERTISED_10baseT_Full) {
1610         netdev->advertised |= NETDEV_F_10MB_FD;
1611     }
1612     if (ecmd.advertising & ADVERTISED_100baseT_Half) {
1613         netdev->advertised |= NETDEV_F_100MB_HD;
1614     }
1615     if (ecmd.advertising & ADVERTISED_100baseT_Full) {
1616         netdev->advertised |= NETDEV_F_100MB_FD;
1617     }
1618     if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
1619         netdev->advertised |= NETDEV_F_1GB_HD;
1620     }
1621     if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
1622         netdev->advertised |= NETDEV_F_1GB_FD;
1623     }
1624     if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
1625         netdev->advertised |= NETDEV_F_10GB_FD;
1626     }
1627     if (ecmd.advertising & ADVERTISED_TP) {
1628         netdev->advertised |= NETDEV_F_COPPER;
1629     }
1630     if (ecmd.advertising & ADVERTISED_FIBRE) {
1631         netdev->advertised |= NETDEV_F_FIBER;
1632     }
1633     if (ecmd.advertising & ADVERTISED_Autoneg) {
1634         netdev->advertised |= NETDEV_F_AUTONEG;
1635     }
1636     if (ecmd.advertising & ADVERTISED_Pause) {
1637         netdev->advertised |= NETDEV_F_PAUSE;
1638     }
1639     if (ecmd.advertising & ADVERTISED_Asym_Pause) {
1640         netdev->advertised |= NETDEV_F_PAUSE_ASYM;
1641     }
1642
1643     /* Current settings. */
1644     speed = ecmd.speed;
1645     if (speed == SPEED_10) {
1646         netdev->current = ecmd.duplex ? NETDEV_F_10MB_FD : NETDEV_F_10MB_HD;
1647     } else if (speed == SPEED_100) {
1648         netdev->current = ecmd.duplex ? NETDEV_F_100MB_FD : NETDEV_F_100MB_HD;
1649     } else if (speed == SPEED_1000) {
1650         netdev->current = ecmd.duplex ? NETDEV_F_1GB_FD : NETDEV_F_1GB_HD;
1651     } else if (speed == SPEED_10000) {
1652         netdev->current = NETDEV_F_10GB_FD;
1653     } else if (speed == 40000) {
1654         netdev->current = NETDEV_F_40GB_FD;
1655     } else if (speed == 100000) {
1656         netdev->current = NETDEV_F_100GB_FD;
1657     } else if (speed == 1000000) {
1658         netdev->current = NETDEV_F_1TB_FD;
1659     } else {
1660         netdev->current = 0;
1661     }
1662
1663     if (ecmd.port == PORT_TP) {
1664         netdev->current |= NETDEV_F_COPPER;
1665     } else if (ecmd.port == PORT_FIBRE) {
1666         netdev->current |= NETDEV_F_FIBER;
1667     }
1668
1669     if (ecmd.autoneg) {
1670         netdev->current |= NETDEV_F_AUTONEG;
1671     }
1672
1673 out:
1674     netdev->cache_valid |= VALID_FEATURES;
1675     netdev->get_features_error = error;
1676 }
1677
1678 /* Stores the features supported by 'netdev' into of '*current', '*advertised',
1679  * '*supported', and '*peer'.  Each value is a bitmap of NETDEV_* bits.
1680  * Returns 0 if successful, otherwise a positive errno value. */
1681 static int
1682 netdev_linux_get_features(const struct netdev *netdev_,
1683                           enum netdev_features *current,
1684                           enum netdev_features *advertised,
1685                           enum netdev_features *supported,
1686                           enum netdev_features *peer)
1687 {
1688     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1689     int error;
1690
1691     ovs_mutex_lock(&netdev->mutex);
1692     netdev_linux_read_features(netdev);
1693     if (!netdev->get_features_error) {
1694         *current = netdev->current;
1695         *advertised = netdev->advertised;
1696         *supported = netdev->supported;
1697         *peer = 0;              /* XXX */
1698     }
1699     error = netdev->get_features_error;
1700     ovs_mutex_unlock(&netdev->mutex);
1701
1702     return error;
1703 }
1704
1705 /* Set the features advertised by 'netdev' to 'advertise'. */
1706 static int
1707 netdev_linux_set_advertisements(struct netdev *netdev_,
1708                                 enum netdev_features advertise)
1709 {
1710     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1711     struct ethtool_cmd ecmd;
1712     int error;
1713
1714     ovs_mutex_lock(&netdev->mutex);
1715
1716     COVERAGE_INC(netdev_get_ethtool);
1717     memset(&ecmd, 0, sizeof ecmd);
1718     error = netdev_linux_do_ethtool(netdev_get_name(netdev_), &ecmd,
1719                                     ETHTOOL_GSET, "ETHTOOL_GSET");
1720     if (error) {
1721         goto exit;
1722     }
1723
1724     ecmd.advertising = 0;
1725     if (advertise & NETDEV_F_10MB_HD) {
1726         ecmd.advertising |= ADVERTISED_10baseT_Half;
1727     }
1728     if (advertise & NETDEV_F_10MB_FD) {
1729         ecmd.advertising |= ADVERTISED_10baseT_Full;
1730     }
1731     if (advertise & NETDEV_F_100MB_HD) {
1732         ecmd.advertising |= ADVERTISED_100baseT_Half;
1733     }
1734     if (advertise & NETDEV_F_100MB_FD) {
1735         ecmd.advertising |= ADVERTISED_100baseT_Full;
1736     }
1737     if (advertise & NETDEV_F_1GB_HD) {
1738         ecmd.advertising |= ADVERTISED_1000baseT_Half;
1739     }
1740     if (advertise & NETDEV_F_1GB_FD) {
1741         ecmd.advertising |= ADVERTISED_1000baseT_Full;
1742     }
1743     if (advertise & NETDEV_F_10GB_FD) {
1744         ecmd.advertising |= ADVERTISED_10000baseT_Full;
1745     }
1746     if (advertise & NETDEV_F_COPPER) {
1747         ecmd.advertising |= ADVERTISED_TP;
1748     }
1749     if (advertise & NETDEV_F_FIBER) {
1750         ecmd.advertising |= ADVERTISED_FIBRE;
1751     }
1752     if (advertise & NETDEV_F_AUTONEG) {
1753         ecmd.advertising |= ADVERTISED_Autoneg;
1754     }
1755     if (advertise & NETDEV_F_PAUSE) {
1756         ecmd.advertising |= ADVERTISED_Pause;
1757     }
1758     if (advertise & NETDEV_F_PAUSE_ASYM) {
1759         ecmd.advertising |= ADVERTISED_Asym_Pause;
1760     }
1761     COVERAGE_INC(netdev_set_ethtool);
1762     error = netdev_linux_do_ethtool(netdev_get_name(netdev_), &ecmd,
1763                                     ETHTOOL_SSET, "ETHTOOL_SSET");
1764
1765 exit:
1766     ovs_mutex_unlock(&netdev->mutex);
1767     return error;
1768 }
1769
1770 /* Attempts to set input rate limiting (policing) policy.  Returns 0 if
1771  * successful, otherwise a positive errno value. */
1772 static int
1773 netdev_linux_set_policing(struct netdev *netdev_,
1774                           uint32_t kbits_rate, uint32_t kbits_burst)
1775 {
1776     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1777     const char *netdev_name = netdev_get_name(netdev_);
1778     int error;
1779
1780     kbits_burst = (!kbits_rate ? 0       /* Force to 0 if no rate specified. */
1781                    : !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */
1782                    : kbits_burst);       /* Stick with user-specified value. */
1783
1784     ovs_mutex_lock(&netdev->mutex);
1785     if (netdev->cache_valid & VALID_POLICING) {
1786         error = netdev->netdev_policing_error;
1787         if (error || (netdev->kbits_rate == kbits_rate &&
1788                       netdev->kbits_burst == kbits_burst)) {
1789             /* Assume that settings haven't changed since we last set them. */
1790             goto out;
1791         }
1792         netdev->cache_valid &= ~VALID_POLICING;
1793     }
1794
1795     COVERAGE_INC(netdev_set_policing);
1796     /* Remove any existing ingress qdisc. */
1797     error = tc_add_del_ingress_qdisc(netdev_, false);
1798     if (error) {
1799         VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
1800                      netdev_name, ovs_strerror(error));
1801         goto out;
1802     }
1803
1804     if (kbits_rate) {
1805         error = tc_add_del_ingress_qdisc(netdev_, true);
1806         if (error) {
1807             VLOG_WARN_RL(&rl, "%s: adding policing qdisc failed: %s",
1808                          netdev_name, ovs_strerror(error));
1809             goto out;
1810         }
1811
1812         error = tc_add_policer(netdev_, kbits_rate, kbits_burst);
1813         if (error){
1814             VLOG_WARN_RL(&rl, "%s: adding policing action failed: %s",
1815                     netdev_name, ovs_strerror(error));
1816             goto out;
1817         }
1818     }
1819
1820     netdev->kbits_rate = kbits_rate;
1821     netdev->kbits_burst = kbits_burst;
1822
1823 out:
1824     if (!error || error == ENODEV) {
1825         netdev->netdev_policing_error = error;
1826         netdev->cache_valid |= VALID_POLICING;
1827     }
1828     ovs_mutex_unlock(&netdev->mutex);
1829     return error;
1830 }
1831
1832 static int
1833 netdev_linux_get_qos_types(const struct netdev *netdev OVS_UNUSED,
1834                            struct sset *types)
1835 {
1836     const struct tc_ops *const *opsp;
1837
1838     for (opsp = tcs; *opsp != NULL; opsp++) {
1839         const struct tc_ops *ops = *opsp;
1840         if (ops->tc_install && ops->ovs_name[0] != '\0') {
1841             sset_add(types, ops->ovs_name);
1842         }
1843     }
1844     return 0;
1845 }
1846
1847 static const struct tc_ops *
1848 tc_lookup_ovs_name(const char *name)
1849 {
1850     const struct tc_ops *const *opsp;
1851
1852     for (opsp = tcs; *opsp != NULL; opsp++) {
1853         const struct tc_ops *ops = *opsp;
1854         if (!strcmp(name, ops->ovs_name)) {
1855             return ops;
1856         }
1857     }
1858     return NULL;
1859 }
1860
1861 static const struct tc_ops *
1862 tc_lookup_linux_name(const char *name)
1863 {
1864     const struct tc_ops *const *opsp;
1865
1866     for (opsp = tcs; *opsp != NULL; opsp++) {
1867         const struct tc_ops *ops = *opsp;
1868         if (ops->linux_name && !strcmp(name, ops->linux_name)) {
1869             return ops;
1870         }
1871     }
1872     return NULL;
1873 }
1874
1875 static struct tc_queue *
1876 tc_find_queue__(const struct netdev *netdev_, unsigned int queue_id,
1877                 size_t hash)
1878 {
1879     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1880     struct tc_queue *queue;
1881
1882     HMAP_FOR_EACH_IN_BUCKET (queue, hmap_node, hash, &netdev->tc->queues) {
1883         if (queue->queue_id == queue_id) {
1884             return queue;
1885         }
1886     }
1887     return NULL;
1888 }
1889
1890 static struct tc_queue *
1891 tc_find_queue(const struct netdev *netdev, unsigned int queue_id)
1892 {
1893     return tc_find_queue__(netdev, queue_id, hash_int(queue_id, 0));
1894 }
1895
1896 static int
1897 netdev_linux_get_qos_capabilities(const struct netdev *netdev OVS_UNUSED,
1898                                   const char *type,
1899                                   struct netdev_qos_capabilities *caps)
1900 {
1901     const struct tc_ops *ops = tc_lookup_ovs_name(type);
1902     if (!ops) {
1903         return EOPNOTSUPP;
1904     }
1905     caps->n_queues = ops->n_queues;
1906     return 0;
1907 }
1908
1909 static int
1910 netdev_linux_get_qos(const struct netdev *netdev_,
1911                      const char **typep, struct smap *details)
1912 {
1913     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1914     int error;
1915
1916     ovs_mutex_lock(&netdev->mutex);
1917     error = tc_query_qdisc(netdev_);
1918     if (!error) {
1919         *typep = netdev->tc->ops->ovs_name;
1920         error = (netdev->tc->ops->qdisc_get
1921                  ? netdev->tc->ops->qdisc_get(netdev_, details)
1922                  : 0);
1923     }
1924     ovs_mutex_unlock(&netdev->mutex);
1925
1926     return error;
1927 }
1928
1929 static int
1930 netdev_linux_set_qos(struct netdev *netdev_,
1931                      const char *type, const struct smap *details)
1932 {
1933     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1934     const struct tc_ops *new_ops;
1935     int error;
1936
1937     new_ops = tc_lookup_ovs_name(type);
1938     if (!new_ops || !new_ops->tc_install) {
1939         return EOPNOTSUPP;
1940     }
1941
1942     ovs_mutex_lock(&netdev->mutex);
1943     error = tc_query_qdisc(netdev_);
1944     if (error) {
1945         goto exit;
1946     }
1947
1948     if (new_ops == netdev->tc->ops) {
1949         error = new_ops->qdisc_set ? new_ops->qdisc_set(netdev_, details) : 0;
1950     } else {
1951         /* Delete existing qdisc. */
1952         error = tc_del_qdisc(netdev_);
1953         if (error) {
1954             goto exit;
1955         }
1956         ovs_assert(netdev->tc == NULL);
1957
1958         /* Install new qdisc. */
1959         error = new_ops->tc_install(netdev_, details);
1960         ovs_assert((error == 0) == (netdev->tc != NULL));
1961     }
1962
1963 exit:
1964     ovs_mutex_unlock(&netdev->mutex);
1965     return error;
1966 }
1967
1968 static int
1969 netdev_linux_get_queue(const struct netdev *netdev_,
1970                        unsigned int queue_id, struct smap *details)
1971 {
1972     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1973     int error;
1974
1975     ovs_mutex_lock(&netdev->mutex);
1976     error = tc_query_qdisc(netdev_);
1977     if (!error) {
1978         struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
1979         error = (queue
1980                 ? netdev->tc->ops->class_get(netdev_, queue, details)
1981                 : ENOENT);
1982     }
1983     ovs_mutex_unlock(&netdev->mutex);
1984
1985     return error;
1986 }
1987
1988 static int
1989 netdev_linux_set_queue(struct netdev *netdev_,
1990                        unsigned int queue_id, const struct smap *details)
1991 {
1992     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1993     int error;
1994
1995     ovs_mutex_lock(&netdev->mutex);
1996     error = tc_query_qdisc(netdev_);
1997     if (!error) {
1998         error = (queue_id < netdev->tc->ops->n_queues
1999                  && netdev->tc->ops->class_set
2000                  ? netdev->tc->ops->class_set(netdev_, queue_id, details)
2001                  : EINVAL);
2002     }
2003     ovs_mutex_unlock(&netdev->mutex);
2004
2005     return error;
2006 }
2007
2008 static int
2009 netdev_linux_delete_queue(struct netdev *netdev_, unsigned int queue_id)
2010 {
2011     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2012     int error;
2013
2014     ovs_mutex_lock(&netdev->mutex);
2015     error = tc_query_qdisc(netdev_);
2016     if (!error) {
2017         if (netdev->tc->ops->class_delete) {
2018             struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
2019             error = (queue
2020                      ? netdev->tc->ops->class_delete(netdev_, queue)
2021                      : ENOENT);
2022         } else {
2023             error = EINVAL;
2024         }
2025     }
2026     ovs_mutex_unlock(&netdev->mutex);
2027
2028     return error;
2029 }
2030
2031 static int
2032 netdev_linux_get_queue_stats(const struct netdev *netdev_,
2033                              unsigned int queue_id,
2034                              struct netdev_queue_stats *stats)
2035 {
2036     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2037     int error;
2038
2039     ovs_mutex_lock(&netdev->mutex);
2040     error = tc_query_qdisc(netdev_);
2041     if (!error) {
2042         if (netdev->tc->ops->class_get_stats) {
2043             const struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
2044             if (queue) {
2045                 stats->created = queue->created;
2046                 error = netdev->tc->ops->class_get_stats(netdev_, queue,
2047                                                          stats);
2048             } else {
2049                 error = ENOENT;
2050             }
2051         } else {
2052             error = EOPNOTSUPP;
2053         }
2054     }
2055     ovs_mutex_unlock(&netdev->mutex);
2056
2057     return error;
2058 }
2059
2060 static bool
2061 start_queue_dump(const struct netdev *netdev, struct nl_dump *dump)
2062 {
2063     struct ofpbuf request;
2064     struct tcmsg *tcmsg;
2065
2066     tcmsg = tc_make_request(netdev, RTM_GETTCLASS, 0, &request);
2067     if (!tcmsg) {
2068         return false;
2069     }
2070     tcmsg->tcm_parent = 0;
2071     nl_dump_start(dump, NETLINK_ROUTE, &request);
2072     ofpbuf_uninit(&request);
2073     return true;
2074 }
2075
2076 struct netdev_linux_queue_state {
2077     unsigned int *queues;
2078     size_t cur_queue;
2079     size_t n_queues;
2080 };
2081
2082 static int
2083 netdev_linux_queue_dump_start(const struct netdev *netdev_, void **statep)
2084 {
2085     const struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2086     int error;
2087
2088     ovs_mutex_lock(&netdev->mutex);
2089     error = tc_query_qdisc(netdev_);
2090     if (!error) {
2091         if (netdev->tc->ops->class_get) {
2092             struct netdev_linux_queue_state *state;
2093             struct tc_queue *queue;
2094             size_t i;
2095
2096             *statep = state = xmalloc(sizeof *state);
2097             state->n_queues = hmap_count(&netdev->tc->queues);
2098             state->cur_queue = 0;
2099             state->queues = xmalloc(state->n_queues * sizeof *state->queues);
2100
2101             i = 0;
2102             HMAP_FOR_EACH (queue, hmap_node, &netdev->tc->queues) {
2103                 state->queues[i++] = queue->queue_id;
2104             }
2105         } else {
2106             error = EOPNOTSUPP;
2107         }
2108     }
2109     ovs_mutex_unlock(&netdev->mutex);
2110
2111     return error;
2112 }
2113
2114 static int
2115 netdev_linux_queue_dump_next(const struct netdev *netdev_, void *state_,
2116                              unsigned int *queue_idp, struct smap *details)
2117 {
2118     const struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2119     struct netdev_linux_queue_state *state = state_;
2120     int error = EOF;
2121
2122     ovs_mutex_lock(&netdev->mutex);
2123     while (state->cur_queue < state->n_queues) {
2124         unsigned int queue_id = state->queues[state->cur_queue++];
2125         struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
2126
2127         if (queue) {
2128             *queue_idp = queue_id;
2129             error = netdev->tc->ops->class_get(netdev_, queue, details);
2130             break;
2131         }
2132     }
2133     ovs_mutex_unlock(&netdev->mutex);
2134
2135     return error;
2136 }
2137
2138 static int
2139 netdev_linux_queue_dump_done(const struct netdev *netdev OVS_UNUSED,
2140                              void *state_)
2141 {
2142     struct netdev_linux_queue_state *state = state_;
2143
2144     free(state->queues);
2145     free(state);
2146     return 0;
2147 }
2148
2149 static int
2150 netdev_linux_dump_queue_stats(const struct netdev *netdev_,
2151                               netdev_dump_queue_stats_cb *cb, void *aux)
2152 {
2153     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2154     int error;
2155
2156     ovs_mutex_lock(&netdev->mutex);
2157     error = tc_query_qdisc(netdev_);
2158     if (!error) {
2159         struct nl_dump dump;
2160
2161         if (!netdev->tc->ops->class_dump_stats) {
2162             error = EOPNOTSUPP;
2163         } else if (!start_queue_dump(netdev_, &dump)) {
2164             error = ENODEV;
2165         } else {
2166             struct ofpbuf msg;
2167             int retval;
2168
2169             while (nl_dump_next(&dump, &msg)) {
2170                 retval = netdev->tc->ops->class_dump_stats(netdev_, &msg,
2171                                                            cb, aux);
2172                 if (retval) {
2173                     error = retval;
2174                 }
2175             }
2176
2177             retval = nl_dump_done(&dump);
2178             if (retval) {
2179                 error = retval;
2180             }
2181         }
2182     }
2183     ovs_mutex_unlock(&netdev->mutex);
2184
2185     return error;
2186 }
2187
2188 static int
2189 netdev_linux_get_in4(const struct netdev *netdev_,
2190                      struct in_addr *address, struct in_addr *netmask)
2191 {
2192     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2193     int error;
2194
2195     ovs_mutex_lock(&netdev->mutex);
2196     if (!(netdev->cache_valid & VALID_IN4)) {
2197         error = netdev_linux_get_ipv4(netdev_, &netdev->address,
2198                                       SIOCGIFADDR, "SIOCGIFADDR");
2199         if (!error) {
2200             error = netdev_linux_get_ipv4(netdev_, &netdev->netmask,
2201                                           SIOCGIFNETMASK, "SIOCGIFNETMASK");
2202             if (!error) {
2203                 netdev->cache_valid |= VALID_IN4;
2204             }
2205         }
2206     } else {
2207         error = 0;
2208     }
2209
2210     if (!error) {
2211         if (netdev->address.s_addr != INADDR_ANY) {
2212             *address = netdev->address;
2213             *netmask = netdev->netmask;
2214         } else {
2215             error = EADDRNOTAVAIL;
2216         }
2217     }
2218     ovs_mutex_unlock(&netdev->mutex);
2219
2220     return error;
2221 }
2222
2223 static int
2224 netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address,
2225                      struct in_addr netmask)
2226 {
2227     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2228     int error;
2229
2230     ovs_mutex_lock(&netdev->mutex);
2231     error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address);
2232     if (!error) {
2233         netdev->cache_valid |= VALID_IN4;
2234         netdev->address = address;
2235         netdev->netmask = netmask;
2236         if (address.s_addr != INADDR_ANY) {
2237             error = do_set_addr(netdev_, SIOCSIFNETMASK,
2238                                 "SIOCSIFNETMASK", netmask);
2239         }
2240     }
2241     ovs_mutex_unlock(&netdev->mutex);
2242
2243     return error;
2244 }
2245
2246 static bool
2247 parse_if_inet6_line(const char *line,
2248                     struct in6_addr *in6, char ifname[16 + 1])
2249 {
2250     uint8_t *s6 = in6->s6_addr;
2251 #define X8 "%2"SCNx8
2252     return ovs_scan(line,
2253                     " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
2254                     "%*x %*x %*x %*x %16s\n",
2255                     &s6[0], &s6[1], &s6[2], &s6[3],
2256                     &s6[4], &s6[5], &s6[6], &s6[7],
2257                     &s6[8], &s6[9], &s6[10], &s6[11],
2258                     &s6[12], &s6[13], &s6[14], &s6[15],
2259                     ifname);
2260 }
2261
2262 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
2263  * 'in6' is non-null) and returns true.  Otherwise, returns false. */
2264 static int
2265 netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
2266 {
2267     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2268
2269     ovs_mutex_lock(&netdev->mutex);
2270     if (!(netdev->cache_valid & VALID_IN6)) {
2271         FILE *file;
2272         char line[128];
2273
2274         netdev->in6 = in6addr_any;
2275
2276         file = fopen("/proc/net/if_inet6", "r");
2277         if (file != NULL) {
2278             const char *name = netdev_get_name(netdev_);
2279             while (fgets(line, sizeof line, file)) {
2280                 struct in6_addr in6_tmp;
2281                 char ifname[16 + 1];
2282                 if (parse_if_inet6_line(line, &in6_tmp, ifname)
2283                     && !strcmp(name, ifname))
2284                 {
2285                     netdev->in6 = in6_tmp;
2286                     break;
2287                 }
2288             }
2289             fclose(file);
2290         }
2291         netdev->cache_valid |= VALID_IN6;
2292     }
2293     *in6 = netdev->in6;
2294     ovs_mutex_unlock(&netdev->mutex);
2295
2296     return 0;
2297 }
2298
2299 static void
2300 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
2301 {
2302     struct sockaddr_in sin;
2303     memset(&sin, 0, sizeof sin);
2304     sin.sin_family = AF_INET;
2305     sin.sin_addr = addr;
2306     sin.sin_port = 0;
2307
2308     memset(sa, 0, sizeof *sa);
2309     memcpy(sa, &sin, sizeof sin);
2310 }
2311
2312 static int
2313 do_set_addr(struct netdev *netdev,
2314             int ioctl_nr, const char *ioctl_name, struct in_addr addr)
2315 {
2316     struct ifreq ifr;
2317
2318     make_in4_sockaddr(&ifr.ifr_addr, addr);
2319     return af_inet_ifreq_ioctl(netdev_get_name(netdev), &ifr, ioctl_nr,
2320                                ioctl_name);
2321 }
2322
2323 /* Adds 'router' as a default IP gateway. */
2324 static int
2325 netdev_linux_add_router(struct netdev *netdev OVS_UNUSED, struct in_addr router)
2326 {
2327     struct in_addr any = { INADDR_ANY };
2328     struct rtentry rt;
2329     int error;
2330
2331     memset(&rt, 0, sizeof rt);
2332     make_in4_sockaddr(&rt.rt_dst, any);
2333     make_in4_sockaddr(&rt.rt_gateway, router);
2334     make_in4_sockaddr(&rt.rt_genmask, any);
2335     rt.rt_flags = RTF_UP | RTF_GATEWAY;
2336     error = af_inet_ioctl(SIOCADDRT, &rt);
2337     if (error) {
2338         VLOG_WARN("ioctl(SIOCADDRT): %s", ovs_strerror(error));
2339     }
2340     return error;
2341 }
2342
2343 static int
2344 netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
2345                           char **netdev_name)
2346 {
2347     static const char fn[] = "/proc/net/route";
2348     FILE *stream;
2349     char line[256];
2350     int ln;
2351
2352     *netdev_name = NULL;
2353     stream = fopen(fn, "r");
2354     if (stream == NULL) {
2355         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, ovs_strerror(errno));
2356         return errno;
2357     }
2358
2359     ln = 0;
2360     while (fgets(line, sizeof line, stream)) {
2361         if (++ln >= 2) {
2362             char iface[17];
2363             ovs_be32 dest, gateway, mask;
2364             int refcnt, metric, mtu;
2365             unsigned int flags, use, window, irtt;
2366
2367             if (!ovs_scan(line,
2368                           "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
2369                           " %d %u %u\n",
2370                           iface, &dest, &gateway, &flags, &refcnt,
2371                           &use, &metric, &mask, &mtu, &window, &irtt)) {
2372                 VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
2373                         fn, ln, line);
2374                 continue;
2375             }
2376             if (!(flags & RTF_UP)) {
2377                 /* Skip routes that aren't up. */
2378                 continue;
2379             }
2380
2381             /* The output of 'dest', 'mask', and 'gateway' were given in
2382              * network byte order, so we don't need need any endian
2383              * conversions here. */
2384             if ((dest & mask) == (host->s_addr & mask)) {
2385                 if (!gateway) {
2386                     /* The host is directly reachable. */
2387                     next_hop->s_addr = 0;
2388                 } else {
2389                     /* To reach the host, we must go through a gateway. */
2390                     next_hop->s_addr = gateway;
2391                 }
2392                 *netdev_name = xstrdup(iface);
2393                 fclose(stream);
2394                 return 0;
2395             }
2396         }
2397     }
2398
2399     fclose(stream);
2400     return ENXIO;
2401 }
2402
2403 static int
2404 netdev_linux_get_status(const struct netdev *netdev_, struct smap *smap)
2405 {
2406     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2407     int error = 0;
2408
2409     ovs_mutex_lock(&netdev->mutex);
2410     if (!(netdev->cache_valid & VALID_DRVINFO)) {
2411         struct ethtool_cmd *cmd = (struct ethtool_cmd *) &netdev->drvinfo;
2412
2413         COVERAGE_INC(netdev_get_ethtool);
2414         memset(&netdev->drvinfo, 0, sizeof netdev->drvinfo);
2415         error = netdev_linux_do_ethtool(netdev->up.name,
2416                                         cmd,
2417                                         ETHTOOL_GDRVINFO,
2418                                         "ETHTOOL_GDRVINFO");
2419         if (!error) {
2420             netdev->cache_valid |= VALID_DRVINFO;
2421         }
2422     }
2423
2424     if (!error) {
2425         smap_add(smap, "driver_name", netdev->drvinfo.driver);
2426         smap_add(smap, "driver_version", netdev->drvinfo.version);
2427         smap_add(smap, "firmware_version", netdev->drvinfo.fw_version);
2428     }
2429     ovs_mutex_unlock(&netdev->mutex);
2430
2431     return error;
2432 }
2433
2434 static int
2435 netdev_internal_get_status(const struct netdev *netdev OVS_UNUSED,
2436                            struct smap *smap)
2437 {
2438     smap_add(smap, "driver_name", "openvswitch");
2439     return 0;
2440 }
2441
2442 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
2443  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
2444  * returns 0.  Otherwise, it returns a positive errno value; in particular,
2445  * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
2446 static int
2447 netdev_linux_arp_lookup(const struct netdev *netdev,
2448                         ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
2449 {
2450     struct arpreq r;
2451     struct sockaddr_in sin;
2452     int retval;
2453
2454     memset(&r, 0, sizeof r);
2455     memset(&sin, 0, sizeof sin);
2456     sin.sin_family = AF_INET;
2457     sin.sin_addr.s_addr = ip;
2458     sin.sin_port = 0;
2459     memcpy(&r.arp_pa, &sin, sizeof sin);
2460     r.arp_ha.sa_family = ARPHRD_ETHER;
2461     r.arp_flags = 0;
2462     ovs_strzcpy(r.arp_dev, netdev_get_name(netdev), sizeof r.arp_dev);
2463     COVERAGE_INC(netdev_arp_lookup);
2464     retval = af_inet_ioctl(SIOCGARP, &r);
2465     if (!retval) {
2466         memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
2467     } else if (retval != ENXIO) {
2468         VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
2469                      netdev_get_name(netdev), IP_ARGS(ip),
2470                      ovs_strerror(retval));
2471     }
2472     return retval;
2473 }
2474
2475 static int
2476 nd_to_iff_flags(enum netdev_flags nd)
2477 {
2478     int iff = 0;
2479     if (nd & NETDEV_UP) {
2480         iff |= IFF_UP;
2481     }
2482     if (nd & NETDEV_PROMISC) {
2483         iff |= IFF_PROMISC;
2484     }
2485     if (nd & NETDEV_LOOPBACK) {
2486         iff |= IFF_LOOPBACK;
2487     }
2488     return iff;
2489 }
2490
2491 static int
2492 iff_to_nd_flags(int iff)
2493 {
2494     enum netdev_flags nd = 0;
2495     if (iff & IFF_UP) {
2496         nd |= NETDEV_UP;
2497     }
2498     if (iff & IFF_PROMISC) {
2499         nd |= NETDEV_PROMISC;
2500     }
2501     if (iff & IFF_LOOPBACK) {
2502         nd |= NETDEV_LOOPBACK;
2503     }
2504     return nd;
2505 }
2506
2507 static int
2508 update_flags(struct netdev_linux *netdev, enum netdev_flags off,
2509              enum netdev_flags on, enum netdev_flags *old_flagsp)
2510     OVS_REQUIRES(netdev->mutex)
2511 {
2512     int old_flags, new_flags;
2513     int error = 0;
2514
2515     old_flags = netdev->ifi_flags;
2516     *old_flagsp = iff_to_nd_flags(old_flags);
2517     new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
2518     if (new_flags != old_flags) {
2519         error = set_flags(netdev_get_name(&netdev->up), new_flags);
2520         get_flags(&netdev->up, &netdev->ifi_flags);
2521     }
2522
2523     return error;
2524 }
2525
2526 static int
2527 netdev_linux_update_flags(struct netdev *netdev_, enum netdev_flags off,
2528                           enum netdev_flags on, enum netdev_flags *old_flagsp)
2529 {
2530     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2531     int error;
2532
2533     ovs_mutex_lock(&netdev->mutex);
2534     error = update_flags(netdev, off, on, old_flagsp);
2535     ovs_mutex_unlock(&netdev->mutex);
2536
2537     return error;
2538 }
2539
2540 #define NETDEV_LINUX_CLASS(NAME, CONSTRUCT, GET_STATS, SET_STATS,  \
2541                            GET_FEATURES, GET_STATUS)            \
2542 {                                                               \
2543     NAME,                                                       \
2544                                                                 \
2545     NULL,                                                       \
2546     netdev_linux_run,                                           \
2547     netdev_linux_wait,                                          \
2548                                                                 \
2549     netdev_linux_alloc,                                         \
2550     CONSTRUCT,                                                  \
2551     netdev_linux_destruct,                                      \
2552     netdev_linux_dealloc,                                       \
2553     NULL,                       /* get_config */                \
2554     NULL,                       /* set_config */                \
2555     NULL,                       /* get_tunnel_config */         \
2556                                                                 \
2557     netdev_linux_send,                                          \
2558     netdev_linux_send_wait,                                     \
2559                                                                 \
2560     netdev_linux_set_etheraddr,                                 \
2561     netdev_linux_get_etheraddr,                                 \
2562     netdev_linux_get_mtu,                                       \
2563     netdev_linux_set_mtu,                                       \
2564     netdev_linux_get_ifindex,                                   \
2565     netdev_linux_get_carrier,                                   \
2566     netdev_linux_get_carrier_resets,                            \
2567     netdev_linux_set_miimon_interval,                           \
2568     GET_STATS,                                                  \
2569     SET_STATS,                                                  \
2570                                                                 \
2571     GET_FEATURES,                                               \
2572     netdev_linux_set_advertisements,                            \
2573                                                                 \
2574     netdev_linux_set_policing,                                  \
2575     netdev_linux_get_qos_types,                                 \
2576     netdev_linux_get_qos_capabilities,                          \
2577     netdev_linux_get_qos,                                       \
2578     netdev_linux_set_qos,                                       \
2579     netdev_linux_get_queue,                                     \
2580     netdev_linux_set_queue,                                     \
2581     netdev_linux_delete_queue,                                  \
2582     netdev_linux_get_queue_stats,                               \
2583     netdev_linux_queue_dump_start,                              \
2584     netdev_linux_queue_dump_next,                               \
2585     netdev_linux_queue_dump_done,                               \
2586     netdev_linux_dump_queue_stats,                              \
2587                                                                 \
2588     netdev_linux_get_in4,                                       \
2589     netdev_linux_set_in4,                                       \
2590     netdev_linux_get_in6,                                       \
2591     netdev_linux_add_router,                                    \
2592     netdev_linux_get_next_hop,                                  \
2593     GET_STATUS,                                                 \
2594     netdev_linux_arp_lookup,                                    \
2595                                                                 \
2596     netdev_linux_update_flags,                                  \
2597                                                                 \
2598     netdev_linux_rx_alloc,                                      \
2599     netdev_linux_rx_construct,                                  \
2600     netdev_linux_rx_destruct,                                   \
2601     netdev_linux_rx_dealloc,                                    \
2602     netdev_linux_rx_recv,                                       \
2603     netdev_linux_rx_wait,                                       \
2604     netdev_linux_rx_drain,                                      \
2605 }
2606
2607 const struct netdev_class netdev_linux_class =
2608     NETDEV_LINUX_CLASS(
2609         "system",
2610         netdev_linux_construct,
2611         netdev_linux_get_stats,
2612         NULL,                    /* set_stats */
2613         netdev_linux_get_features,
2614         netdev_linux_get_status);
2615
2616 const struct netdev_class netdev_tap_class =
2617     NETDEV_LINUX_CLASS(
2618         "tap",
2619         netdev_linux_construct_tap,
2620         netdev_tap_get_stats,
2621         NULL,                   /* set_stats */
2622         netdev_linux_get_features,
2623         netdev_linux_get_status);
2624
2625 const struct netdev_class netdev_internal_class =
2626     NETDEV_LINUX_CLASS(
2627         "internal",
2628         netdev_linux_construct,
2629         netdev_internal_get_stats,
2630         netdev_internal_set_stats,
2631         NULL,                  /* get_features */
2632         netdev_internal_get_status);
2633 \f
2634 /* HTB traffic control class. */
2635
2636 #define HTB_N_QUEUES 0xf000
2637
2638 struct htb {
2639     struct tc tc;
2640     unsigned int max_rate;      /* In bytes/s. */
2641 };
2642
2643 struct htb_class {
2644     struct tc_queue tc_queue;
2645     unsigned int min_rate;      /* In bytes/s. */
2646     unsigned int max_rate;      /* In bytes/s. */
2647     unsigned int burst;         /* In bytes. */
2648     unsigned int priority;      /* Lower values are higher priorities. */
2649 };
2650
2651 static struct htb *
2652 htb_get__(const struct netdev *netdev_)
2653 {
2654     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2655     return CONTAINER_OF(netdev->tc, struct htb, tc);
2656 }
2657
2658 static void
2659 htb_install__(struct netdev *netdev_, uint64_t max_rate)
2660 {
2661     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2662     struct htb *htb;
2663
2664     htb = xmalloc(sizeof *htb);
2665     tc_init(&htb->tc, &tc_ops_htb);
2666     htb->max_rate = max_rate;
2667
2668     netdev->tc = &htb->tc;
2669 }
2670
2671 /* Create an HTB qdisc.
2672  *
2673  * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2674 static int
2675 htb_setup_qdisc__(struct netdev *netdev)
2676 {
2677     size_t opt_offset;
2678     struct tc_htb_glob opt;
2679     struct ofpbuf request;
2680     struct tcmsg *tcmsg;
2681
2682     tc_del_qdisc(netdev);
2683
2684     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2685                             NLM_F_EXCL | NLM_F_CREATE, &request);
2686     if (!tcmsg) {
2687         return ENODEV;
2688     }
2689     tcmsg->tcm_handle = tc_make_handle(1, 0);
2690     tcmsg->tcm_parent = TC_H_ROOT;
2691
2692     nl_msg_put_string(&request, TCA_KIND, "htb");
2693
2694     memset(&opt, 0, sizeof opt);
2695     opt.rate2quantum = 10;
2696     opt.version = 3;
2697     opt.defcls = 1;
2698
2699     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2700     nl_msg_put_unspec(&request, TCA_HTB_INIT, &opt, sizeof opt);
2701     nl_msg_end_nested(&request, opt_offset);
2702
2703     return tc_transact(&request, NULL);
2704 }
2705
2706 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2707  * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2708 static int
2709 htb_setup_class__(struct netdev *netdev, unsigned int handle,
2710                   unsigned int parent, struct htb_class *class)
2711 {
2712     size_t opt_offset;
2713     struct tc_htb_opt opt;
2714     struct ofpbuf request;
2715     struct tcmsg *tcmsg;
2716     int error;
2717     int mtu;
2718
2719     error = netdev_linux_get_mtu__(netdev_linux_cast(netdev), &mtu);
2720     if (error) {
2721         VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU",
2722                      netdev_get_name(netdev));
2723         return error;
2724     }
2725
2726     memset(&opt, 0, sizeof opt);
2727     tc_fill_rate(&opt.rate, class->min_rate, mtu);
2728     tc_fill_rate(&opt.ceil, class->max_rate, mtu);
2729     opt.buffer = tc_calc_buffer(opt.rate.rate, mtu, class->burst);
2730     opt.cbuffer = tc_calc_buffer(opt.ceil.rate, mtu, class->burst);
2731     opt.prio = class->priority;
2732
2733     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2734     if (!tcmsg) {
2735         return ENODEV;
2736     }
2737     tcmsg->tcm_handle = handle;
2738     tcmsg->tcm_parent = parent;
2739
2740     nl_msg_put_string(&request, TCA_KIND, "htb");
2741     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2742     nl_msg_put_unspec(&request, TCA_HTB_PARMS, &opt, sizeof opt);
2743     tc_put_rtab(&request, TCA_HTB_RTAB, &opt.rate);
2744     tc_put_rtab(&request, TCA_HTB_CTAB, &opt.ceil);
2745     nl_msg_end_nested(&request, opt_offset);
2746
2747     error = tc_transact(&request, NULL);
2748     if (error) {
2749         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
2750                      "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2751                      netdev_get_name(netdev),
2752                      tc_get_major(handle), tc_get_minor(handle),
2753                      tc_get_major(parent), tc_get_minor(parent),
2754                      class->min_rate, class->max_rate,
2755                      class->burst, class->priority, ovs_strerror(error));
2756     }
2757     return error;
2758 }
2759
2760 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2761  * description of them into 'details'.  The description complies with the
2762  * specification given in the vswitch database documentation for linux-htb
2763  * queue details. */
2764 static int
2765 htb_parse_tca_options__(struct nlattr *nl_options, struct htb_class *class)
2766 {
2767     static const struct nl_policy tca_htb_policy[] = {
2768         [TCA_HTB_PARMS] = { .type = NL_A_UNSPEC, .optional = false,
2769                             .min_len = sizeof(struct tc_htb_opt) },
2770     };
2771
2772     struct nlattr *attrs[ARRAY_SIZE(tca_htb_policy)];
2773     const struct tc_htb_opt *htb;
2774
2775     if (!nl_parse_nested(nl_options, tca_htb_policy,
2776                          attrs, ARRAY_SIZE(tca_htb_policy))) {
2777         VLOG_WARN_RL(&rl, "failed to parse HTB class options");
2778         return EPROTO;
2779     }
2780
2781     htb = nl_attr_get(attrs[TCA_HTB_PARMS]);
2782     class->min_rate = htb->rate.rate;
2783     class->max_rate = htb->ceil.rate;
2784     class->burst = tc_ticks_to_bytes(htb->rate.rate, htb->buffer);
2785     class->priority = htb->prio;
2786     return 0;
2787 }
2788
2789 static int
2790 htb_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2791                   struct htb_class *options,
2792                   struct netdev_queue_stats *stats)
2793 {
2794     struct nlattr *nl_options;
2795     unsigned int handle;
2796     int error;
2797
2798     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2799     if (!error && queue_id) {
2800         unsigned int major = tc_get_major(handle);
2801         unsigned int minor = tc_get_minor(handle);
2802         if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2803             *queue_id = minor - 1;
2804         } else {
2805             error = EPROTO;
2806         }
2807     }
2808     if (!error && options) {
2809         error = htb_parse_tca_options__(nl_options, options);
2810     }
2811     return error;
2812 }
2813
2814 static void
2815 htb_parse_qdisc_details__(struct netdev *netdev_,
2816                           const struct smap *details, struct htb_class *hc)
2817 {
2818     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2819     const char *max_rate_s;
2820
2821     max_rate_s = smap_get(details, "max-rate");
2822     hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2823     if (!hc->max_rate) {
2824         enum netdev_features current;
2825
2826         netdev_linux_read_features(netdev);
2827         current = !netdev->get_features_error ? netdev->current : 0;
2828         hc->max_rate = netdev_features_to_bps(current, 100 * 1000 * 1000) / 8;
2829     }
2830     hc->min_rate = hc->max_rate;
2831     hc->burst = 0;
2832     hc->priority = 0;
2833 }
2834
2835 static int
2836 htb_parse_class_details__(struct netdev *netdev,
2837                           const struct smap *details, struct htb_class *hc)
2838 {
2839     const struct htb *htb = htb_get__(netdev);
2840     const char *min_rate_s = smap_get(details, "min-rate");
2841     const char *max_rate_s = smap_get(details, "max-rate");
2842     const char *burst_s = smap_get(details, "burst");
2843     const char *priority_s = smap_get(details, "priority");
2844     int mtu, error;
2845
2846     error = netdev_linux_get_mtu__(netdev_linux_cast(netdev), &mtu);
2847     if (error) {
2848         VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU",
2849                      netdev_get_name(netdev));
2850         return error;
2851     }
2852
2853     /* HTB requires at least an mtu sized min-rate to send any traffic even
2854      * on uncongested links. */
2855     hc->min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
2856     hc->min_rate = MAX(hc->min_rate, mtu);
2857     hc->min_rate = MIN(hc->min_rate, htb->max_rate);
2858
2859     /* max-rate */
2860     hc->max_rate = (max_rate_s
2861                     ? strtoull(max_rate_s, NULL, 10) / 8
2862                     : htb->max_rate);
2863     hc->max_rate = MAX(hc->max_rate, hc->min_rate);
2864     hc->max_rate = MIN(hc->max_rate, htb->max_rate);
2865
2866     /* burst
2867      *
2868      * According to hints in the documentation that I've read, it is important
2869      * that 'burst' be at least as big as the largest frame that might be
2870      * transmitted.  Also, making 'burst' a bit bigger than necessary is OK,
2871      * but having it a bit too small is a problem.  Since netdev_get_mtu()
2872      * doesn't include the Ethernet header, we need to add at least 14 (18?) to
2873      * the MTU.  We actually add 64, instead of 14, as a guard against
2874      * additional headers get tacked on somewhere that we're not aware of. */
2875     hc->burst = burst_s ? strtoull(burst_s, NULL, 10) / 8 : 0;
2876     hc->burst = MAX(hc->burst, mtu + 64);
2877
2878     /* priority */
2879     hc->priority = priority_s ? strtoul(priority_s, NULL, 10) : 0;
2880
2881     return 0;
2882 }
2883
2884 static int
2885 htb_query_class__(const struct netdev *netdev, unsigned int handle,
2886                   unsigned int parent, struct htb_class *options,
2887                   struct netdev_queue_stats *stats)
2888 {
2889     struct ofpbuf *reply;
2890     int error;
2891
2892     error = tc_query_class(netdev, handle, parent, &reply);
2893     if (!error) {
2894         error = htb_parse_tcmsg__(reply, NULL, options, stats);
2895         ofpbuf_delete(reply);
2896     }
2897     return error;
2898 }
2899
2900 static int
2901 htb_tc_install(struct netdev *netdev, const struct smap *details)
2902 {
2903     int error;
2904
2905     error = htb_setup_qdisc__(netdev);
2906     if (!error) {
2907         struct htb_class hc;
2908
2909         htb_parse_qdisc_details__(netdev, details, &hc);
2910         error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2911                                   tc_make_handle(1, 0), &hc);
2912         if (!error) {
2913             htb_install__(netdev, hc.max_rate);
2914         }
2915     }
2916     return error;
2917 }
2918
2919 static struct htb_class *
2920 htb_class_cast__(const struct tc_queue *queue)
2921 {
2922     return CONTAINER_OF(queue, struct htb_class, tc_queue);
2923 }
2924
2925 static void
2926 htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
2927                    const struct htb_class *hc)
2928 {
2929     struct htb *htb = htb_get__(netdev);
2930     size_t hash = hash_int(queue_id, 0);
2931     struct tc_queue *queue;
2932     struct htb_class *hcp;
2933
2934     queue = tc_find_queue__(netdev, queue_id, hash);
2935     if (queue) {
2936         hcp = htb_class_cast__(queue);
2937     } else {
2938         hcp = xmalloc(sizeof *hcp);
2939         queue = &hcp->tc_queue;
2940         queue->queue_id = queue_id;
2941         queue->created = time_msec();
2942         hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
2943     }
2944
2945     hcp->min_rate = hc->min_rate;
2946     hcp->max_rate = hc->max_rate;
2947     hcp->burst = hc->burst;
2948     hcp->priority = hc->priority;
2949 }
2950
2951 static int
2952 htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
2953 {
2954     struct ofpbuf msg;
2955     struct nl_dump dump;
2956     struct htb_class hc;
2957
2958     /* Get qdisc options. */
2959     hc.max_rate = 0;
2960     htb_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
2961     htb_install__(netdev, hc.max_rate);
2962
2963     /* Get queues. */
2964     if (!start_queue_dump(netdev, &dump)) {
2965         return ENODEV;
2966     }
2967     while (nl_dump_next(&dump, &msg)) {
2968         unsigned int queue_id;
2969
2970         if (!htb_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
2971             htb_update_queue__(netdev, queue_id, &hc);
2972         }
2973     }
2974     nl_dump_done(&dump);
2975
2976     return 0;
2977 }
2978
2979 static void
2980 htb_tc_destroy(struct tc *tc)
2981 {
2982     struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
2983     struct htb_class *hc, *next;
2984
2985     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &htb->tc.queues) {
2986         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2987         free(hc);
2988     }
2989     tc_destroy(tc);
2990     free(htb);
2991 }
2992
2993 static int
2994 htb_qdisc_get(const struct netdev *netdev, struct smap *details)
2995 {
2996     const struct htb *htb = htb_get__(netdev);
2997     smap_add_format(details, "max-rate", "%llu", 8ULL * htb->max_rate);
2998     return 0;
2999 }
3000
3001 static int
3002 htb_qdisc_set(struct netdev *netdev, const struct smap *details)
3003 {
3004     struct htb_class hc;
3005     int error;
3006
3007     htb_parse_qdisc_details__(netdev, details, &hc);
3008     error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3009                               tc_make_handle(1, 0), &hc);
3010     if (!error) {
3011         htb_get__(netdev)->max_rate = hc.max_rate;
3012     }
3013     return error;
3014 }
3015
3016 static int
3017 htb_class_get(const struct netdev *netdev OVS_UNUSED,
3018               const struct tc_queue *queue, struct smap *details)
3019 {
3020     const struct htb_class *hc = htb_class_cast__(queue);
3021
3022     smap_add_format(details, "min-rate", "%llu", 8ULL * hc->min_rate);
3023     if (hc->min_rate != hc->max_rate) {
3024         smap_add_format(details, "max-rate", "%llu", 8ULL * hc->max_rate);
3025     }
3026     smap_add_format(details, "burst", "%llu", 8ULL * hc->burst);
3027     if (hc->priority) {
3028         smap_add_format(details, "priority", "%u", hc->priority);
3029     }
3030     return 0;
3031 }
3032
3033 static int
3034 htb_class_set(struct netdev *netdev, unsigned int queue_id,
3035               const struct smap *details)
3036 {
3037     struct htb_class hc;
3038     int error;
3039
3040     error = htb_parse_class_details__(netdev, details, &hc);
3041     if (error) {
3042         return error;
3043     }
3044
3045     error = htb_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3046                               tc_make_handle(1, 0xfffe), &hc);
3047     if (error) {
3048         return error;
3049     }
3050
3051     htb_update_queue__(netdev, queue_id, &hc);
3052     return 0;
3053 }
3054
3055 static int
3056 htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
3057 {
3058     struct htb_class *hc = htb_class_cast__(queue);
3059     struct htb *htb = htb_get__(netdev);
3060     int error;
3061
3062     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3063     if (!error) {
3064         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
3065         free(hc);
3066     }
3067     return error;
3068 }
3069
3070 static int
3071 htb_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3072                     struct netdev_queue_stats *stats)
3073 {
3074     return htb_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3075                              tc_make_handle(1, 0xfffe), NULL, stats);
3076 }
3077
3078 static int
3079 htb_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3080                      const struct ofpbuf *nlmsg,
3081                      netdev_dump_queue_stats_cb *cb, void *aux)
3082 {
3083     struct netdev_queue_stats stats;
3084     unsigned int handle, major, minor;
3085     int error;
3086
3087     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3088     if (error) {
3089         return error;
3090     }
3091
3092     major = tc_get_major(handle);
3093     minor = tc_get_minor(handle);
3094     if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
3095         (*cb)(minor - 1, &stats, aux);
3096     }
3097     return 0;
3098 }
3099
3100 static const struct tc_ops tc_ops_htb = {
3101     "htb",                      /* linux_name */
3102     "linux-htb",                /* ovs_name */
3103     HTB_N_QUEUES,               /* n_queues */
3104     htb_tc_install,
3105     htb_tc_load,
3106     htb_tc_destroy,
3107     htb_qdisc_get,
3108     htb_qdisc_set,
3109     htb_class_get,
3110     htb_class_set,
3111     htb_class_delete,
3112     htb_class_get_stats,
3113     htb_class_dump_stats
3114 };
3115 \f
3116 /* "linux-hfsc" traffic control class. */
3117
3118 #define HFSC_N_QUEUES 0xf000
3119
3120 struct hfsc {
3121     struct tc tc;
3122     uint32_t max_rate;
3123 };
3124
3125 struct hfsc_class {
3126     struct tc_queue tc_queue;
3127     uint32_t min_rate;
3128     uint32_t max_rate;
3129 };
3130
3131 static struct hfsc *
3132 hfsc_get__(const struct netdev *netdev_)
3133 {
3134     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3135     return CONTAINER_OF(netdev->tc, struct hfsc, tc);
3136 }
3137
3138 static struct hfsc_class *
3139 hfsc_class_cast__(const struct tc_queue *queue)
3140 {
3141     return CONTAINER_OF(queue, struct hfsc_class, tc_queue);
3142 }
3143
3144 static void
3145 hfsc_install__(struct netdev *netdev_, uint32_t max_rate)
3146 {
3147     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3148     struct hfsc *hfsc;
3149
3150     hfsc = xmalloc(sizeof *hfsc);
3151     tc_init(&hfsc->tc, &tc_ops_hfsc);
3152     hfsc->max_rate = max_rate;
3153     netdev->tc = &hfsc->tc;
3154 }
3155
3156 static void
3157 hfsc_update_queue__(struct netdev *netdev, unsigned int queue_id,
3158                     const struct hfsc_class *hc)
3159 {
3160     size_t hash;
3161     struct hfsc *hfsc;
3162     struct hfsc_class *hcp;
3163     struct tc_queue *queue;
3164
3165     hfsc = hfsc_get__(netdev);
3166     hash = hash_int(queue_id, 0);
3167
3168     queue = tc_find_queue__(netdev, queue_id, hash);
3169     if (queue) {
3170         hcp = hfsc_class_cast__(queue);
3171     } else {
3172         hcp             = xmalloc(sizeof *hcp);
3173         queue           = &hcp->tc_queue;
3174         queue->queue_id = queue_id;
3175         queue->created  = time_msec();
3176         hmap_insert(&hfsc->tc.queues, &queue->hmap_node, hash);
3177     }
3178
3179     hcp->min_rate = hc->min_rate;
3180     hcp->max_rate = hc->max_rate;
3181 }
3182
3183 static int
3184 hfsc_parse_tca_options__(struct nlattr *nl_options, struct hfsc_class *class)
3185 {
3186     const struct tc_service_curve *rsc, *fsc, *usc;
3187     static const struct nl_policy tca_hfsc_policy[] = {
3188         [TCA_HFSC_RSC] = {
3189             .type      = NL_A_UNSPEC,
3190             .optional  = false,
3191             .min_len   = sizeof(struct tc_service_curve),
3192         },
3193         [TCA_HFSC_FSC] = {
3194             .type      = NL_A_UNSPEC,
3195             .optional  = false,
3196             .min_len   = sizeof(struct tc_service_curve),
3197         },
3198         [TCA_HFSC_USC] = {
3199             .type      = NL_A_UNSPEC,
3200             .optional  = false,
3201             .min_len   = sizeof(struct tc_service_curve),
3202         },
3203     };
3204     struct nlattr *attrs[ARRAY_SIZE(tca_hfsc_policy)];
3205
3206     if (!nl_parse_nested(nl_options, tca_hfsc_policy,
3207                          attrs, ARRAY_SIZE(tca_hfsc_policy))) {
3208         VLOG_WARN_RL(&rl, "failed to parse HFSC class options");
3209         return EPROTO;
3210     }
3211
3212     rsc = nl_attr_get(attrs[TCA_HFSC_RSC]);
3213     fsc = nl_attr_get(attrs[TCA_HFSC_FSC]);
3214     usc = nl_attr_get(attrs[TCA_HFSC_USC]);
3215
3216     if (rsc->m1 != 0 || rsc->d != 0 ||
3217         fsc->m1 != 0 || fsc->d != 0 ||
3218         usc->m1 != 0 || usc->d != 0) {
3219         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3220                      "Non-linear service curves are not supported.");
3221         return EPROTO;
3222     }
3223
3224     if (rsc->m2 != fsc->m2) {
3225         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3226                      "Real-time service curves are not supported ");
3227         return EPROTO;
3228     }
3229
3230     if (rsc->m2 > usc->m2) {
3231         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3232                      "Min-rate service curve is greater than "
3233                      "the max-rate service curve.");
3234         return EPROTO;
3235     }
3236
3237     class->min_rate = fsc->m2;
3238     class->max_rate = usc->m2;
3239     return 0;
3240 }
3241
3242 static int
3243 hfsc_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
3244                    struct hfsc_class *options,
3245                    struct netdev_queue_stats *stats)
3246 {
3247     int error;
3248     unsigned int handle;
3249     struct nlattr *nl_options;
3250
3251     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
3252     if (error) {
3253         return error;
3254     }
3255
3256     if (queue_id) {
3257         unsigned int major, minor;
3258
3259         major = tc_get_major(handle);
3260         minor = tc_get_minor(handle);
3261         if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3262             *queue_id = minor - 1;
3263         } else {
3264             return EPROTO;
3265         }
3266     }
3267
3268     if (options) {
3269         error = hfsc_parse_tca_options__(nl_options, options);
3270     }
3271
3272     return error;
3273 }
3274
3275 static int
3276 hfsc_query_class__(const struct netdev *netdev, unsigned int handle,
3277                    unsigned int parent, struct hfsc_class *options,
3278                    struct netdev_queue_stats *stats)
3279 {
3280     int error;
3281     struct ofpbuf *reply;
3282
3283     error = tc_query_class(netdev, handle, parent, &reply);
3284     if (error) {
3285         return error;
3286     }
3287
3288     error = hfsc_parse_tcmsg__(reply, NULL, options, stats);
3289     ofpbuf_delete(reply);
3290     return error;
3291 }
3292
3293 static void
3294 hfsc_parse_qdisc_details__(struct netdev *netdev_, const struct smap *details,
3295                            struct hfsc_class *class)
3296 {
3297     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3298     uint32_t max_rate;
3299     const char *max_rate_s;
3300
3301     max_rate_s = smap_get(details, "max-rate");
3302     max_rate   = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
3303
3304     if (!max_rate) {
3305         enum netdev_features current;
3306
3307         netdev_linux_read_features(netdev);
3308         current = !netdev->get_features_error ? netdev->current : 0;
3309         max_rate = netdev_features_to_bps(current, 100 * 1000 * 1000) / 8;
3310     }
3311
3312     class->min_rate = max_rate;
3313     class->max_rate = max_rate;
3314 }
3315
3316 static int
3317 hfsc_parse_class_details__(struct netdev *netdev,
3318                            const struct smap *details,
3319                            struct hfsc_class * class)
3320 {
3321     const struct hfsc *hfsc;
3322     uint32_t min_rate, max_rate;
3323     const char *min_rate_s, *max_rate_s;
3324
3325     hfsc       = hfsc_get__(netdev);
3326     min_rate_s = smap_get(details, "min-rate");
3327     max_rate_s = smap_get(details, "max-rate");
3328
3329     min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
3330     min_rate = MAX(min_rate, 1);
3331     min_rate = MIN(min_rate, hfsc->max_rate);
3332
3333     max_rate = (max_rate_s
3334                 ? strtoull(max_rate_s, NULL, 10) / 8
3335                 : hfsc->max_rate);
3336     max_rate = MAX(max_rate, min_rate);
3337     max_rate = MIN(max_rate, hfsc->max_rate);
3338
3339     class->min_rate = min_rate;
3340     class->max_rate = max_rate;
3341
3342     return 0;
3343 }
3344
3345 /* Create an HFSC qdisc.
3346  *
3347  * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
3348 static int
3349 hfsc_setup_qdisc__(struct netdev * netdev)
3350 {
3351     struct tcmsg *tcmsg;
3352     struct ofpbuf request;
3353     struct tc_hfsc_qopt opt;
3354
3355     tc_del_qdisc(netdev);
3356
3357     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
3358                             NLM_F_EXCL | NLM_F_CREATE, &request);
3359
3360     if (!tcmsg) {
3361         return ENODEV;
3362     }
3363
3364     tcmsg->tcm_handle = tc_make_handle(1, 0);
3365     tcmsg->tcm_parent = TC_H_ROOT;
3366
3367     memset(&opt, 0, sizeof opt);
3368     opt.defcls = 1;
3369
3370     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3371     nl_msg_put_unspec(&request, TCA_OPTIONS, &opt, sizeof opt);
3372
3373     return tc_transact(&request, NULL);
3374 }
3375
3376 /* Create an HFSC class.
3377  *
3378  * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
3379  * sc rate <min_rate> ul rate <max_rate>" */
3380 static int
3381 hfsc_setup_class__(struct netdev *netdev, unsigned int handle,
3382                    unsigned int parent, struct hfsc_class *class)
3383 {
3384     int error;
3385     size_t opt_offset;
3386     struct tcmsg *tcmsg;
3387     struct ofpbuf request;
3388     struct tc_service_curve min, max;
3389
3390     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
3391
3392     if (!tcmsg) {
3393         return ENODEV;
3394     }
3395
3396     tcmsg->tcm_handle = handle;
3397     tcmsg->tcm_parent = parent;
3398
3399     min.m1 = 0;
3400     min.d  = 0;
3401     min.m2 = class->min_rate;
3402
3403     max.m1 = 0;
3404     max.d  = 0;
3405     max.m2 = class->max_rate;
3406
3407     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3408     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3409     nl_msg_put_unspec(&request, TCA_HFSC_RSC, &min, sizeof min);
3410     nl_msg_put_unspec(&request, TCA_HFSC_FSC, &min, sizeof min);
3411     nl_msg_put_unspec(&request, TCA_HFSC_USC, &max, sizeof max);
3412     nl_msg_end_nested(&request, opt_offset);
3413
3414     error = tc_transact(&request, NULL);
3415     if (error) {
3416         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
3417                      "min-rate %ubps, max-rate %ubps (%s)",
3418                      netdev_get_name(netdev),
3419                      tc_get_major(handle), tc_get_minor(handle),
3420                      tc_get_major(parent), tc_get_minor(parent),
3421                      class->min_rate, class->max_rate, ovs_strerror(error));
3422     }
3423
3424     return error;
3425 }
3426
3427 static int
3428 hfsc_tc_install(struct netdev *netdev, const struct smap *details)
3429 {
3430     int error;
3431     struct hfsc_class class;
3432
3433     error = hfsc_setup_qdisc__(netdev);
3434
3435     if (error) {
3436         return error;
3437     }
3438
3439     hfsc_parse_qdisc_details__(netdev, details, &class);
3440     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3441                                tc_make_handle(1, 0), &class);
3442
3443     if (error) {
3444         return error;
3445     }
3446
3447     hfsc_install__(netdev, class.max_rate);
3448     return 0;
3449 }
3450
3451 static int
3452 hfsc_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3453 {
3454     struct ofpbuf msg;
3455     struct nl_dump dump;
3456     struct hfsc_class hc;
3457
3458     hc.max_rate = 0;
3459     hfsc_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
3460     hfsc_install__(netdev, hc.max_rate);
3461
3462     if (!start_queue_dump(netdev, &dump)) {
3463         return ENODEV;
3464     }
3465
3466     while (nl_dump_next(&dump, &msg)) {
3467         unsigned int queue_id;
3468
3469         if (!hfsc_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
3470             hfsc_update_queue__(netdev, queue_id, &hc);
3471         }
3472     }
3473
3474     nl_dump_done(&dump);
3475     return 0;
3476 }
3477
3478 static void
3479 hfsc_tc_destroy(struct tc *tc)
3480 {
3481     struct hfsc *hfsc;
3482     struct hfsc_class *hc, *next;
3483
3484     hfsc = CONTAINER_OF(tc, struct hfsc, tc);
3485
3486     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &hfsc->tc.queues) {
3487         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3488         free(hc);
3489     }
3490
3491     tc_destroy(tc);
3492     free(hfsc);
3493 }
3494
3495 static int
3496 hfsc_qdisc_get(const struct netdev *netdev, struct smap *details)
3497 {
3498     const struct hfsc *hfsc;
3499     hfsc = hfsc_get__(netdev);
3500     smap_add_format(details, "max-rate", "%llu", 8ULL * hfsc->max_rate);
3501     return 0;
3502 }
3503
3504 static int
3505 hfsc_qdisc_set(struct netdev *netdev, const struct smap *details)
3506 {
3507     int error;
3508     struct hfsc_class class;
3509
3510     hfsc_parse_qdisc_details__(netdev, details, &class);
3511     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3512                                tc_make_handle(1, 0), &class);
3513
3514     if (!error) {
3515         hfsc_get__(netdev)->max_rate = class.max_rate;
3516     }
3517
3518     return error;
3519 }
3520
3521 static int
3522 hfsc_class_get(const struct netdev *netdev OVS_UNUSED,
3523               const struct tc_queue *queue, struct smap *details)
3524 {
3525     const struct hfsc_class *hc;
3526
3527     hc = hfsc_class_cast__(queue);
3528     smap_add_format(details, "min-rate", "%llu", 8ULL * hc->min_rate);
3529     if (hc->min_rate != hc->max_rate) {
3530         smap_add_format(details, "max-rate", "%llu", 8ULL * hc->max_rate);
3531     }
3532     return 0;
3533 }
3534
3535 static int
3536 hfsc_class_set(struct netdev *netdev, unsigned int queue_id,
3537                const struct smap *details)
3538 {
3539     int error;
3540     struct hfsc_class class;
3541
3542     error = hfsc_parse_class_details__(netdev, details, &class);
3543     if (error) {
3544         return error;
3545     }
3546
3547     error = hfsc_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3548                                tc_make_handle(1, 0xfffe), &class);
3549     if (error) {
3550         return error;
3551     }
3552
3553     hfsc_update_queue__(netdev, queue_id, &class);
3554     return 0;
3555 }
3556
3557 static int
3558 hfsc_class_delete(struct netdev *netdev, struct tc_queue *queue)
3559 {
3560     int error;
3561     struct hfsc *hfsc;
3562     struct hfsc_class *hc;
3563
3564     hc   = hfsc_class_cast__(queue);
3565     hfsc = hfsc_get__(netdev);
3566
3567     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3568     if (!error) {
3569         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3570         free(hc);
3571     }
3572     return error;
3573 }
3574
3575 static int
3576 hfsc_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3577                      struct netdev_queue_stats *stats)
3578 {
3579     return hfsc_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3580                              tc_make_handle(1, 0xfffe), NULL, stats);
3581 }
3582
3583 static int
3584 hfsc_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3585                       const struct ofpbuf *nlmsg,
3586                       netdev_dump_queue_stats_cb *cb, void *aux)
3587 {
3588     struct netdev_queue_stats stats;
3589     unsigned int handle, major, minor;
3590     int error;
3591
3592     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3593     if (error) {
3594         return error;
3595     }
3596
3597     major = tc_get_major(handle);
3598     minor = tc_get_minor(handle);
3599     if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3600         (*cb)(minor - 1, &stats, aux);
3601     }
3602     return 0;
3603 }
3604
3605 static const struct tc_ops tc_ops_hfsc = {
3606     "hfsc",                     /* linux_name */
3607     "linux-hfsc",               /* ovs_name */
3608     HFSC_N_QUEUES,              /* n_queues */
3609     hfsc_tc_install,            /* tc_install */
3610     hfsc_tc_load,               /* tc_load */
3611     hfsc_tc_destroy,            /* tc_destroy */
3612     hfsc_qdisc_get,             /* qdisc_get */
3613     hfsc_qdisc_set,             /* qdisc_set */
3614     hfsc_class_get,             /* class_get */
3615     hfsc_class_set,             /* class_set */
3616     hfsc_class_delete,          /* class_delete */
3617     hfsc_class_get_stats,       /* class_get_stats */
3618     hfsc_class_dump_stats       /* class_dump_stats */
3619 };
3620 \f
3621 /* "linux-default" traffic control class.
3622  *
3623  * This class represents the default, unnamed Linux qdisc.  It corresponds to
3624  * the "" (empty string) QoS type in the OVS database. */
3625
3626 static void
3627 default_install__(struct netdev *netdev_)
3628 {
3629     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3630     static const struct tc tc = TC_INITIALIZER(&tc, &tc_ops_default);
3631
3632     /* Nothing but a tc class implementation is allowed to write to a tc.  This
3633      * class never does that, so we can legitimately use a const tc object. */
3634     netdev->tc = CONST_CAST(struct tc *, &tc);
3635 }
3636
3637 static int
3638 default_tc_install(struct netdev *netdev,
3639                    const struct smap *details OVS_UNUSED)
3640 {
3641     default_install__(netdev);
3642     return 0;
3643 }
3644
3645 static int
3646 default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3647 {
3648     default_install__(netdev);
3649     return 0;
3650 }
3651
3652 static const struct tc_ops tc_ops_default = {
3653     NULL,                       /* linux_name */
3654     "",                         /* ovs_name */
3655     0,                          /* n_queues */
3656     default_tc_install,
3657     default_tc_load,
3658     NULL,                       /* tc_destroy */
3659     NULL,                       /* qdisc_get */
3660     NULL,                       /* qdisc_set */
3661     NULL,                       /* class_get */
3662     NULL,                       /* class_set */
3663     NULL,                       /* class_delete */
3664     NULL,                       /* class_get_stats */
3665     NULL                        /* class_dump_stats */
3666 };
3667 \f
3668 /* "linux-other" traffic control class.
3669  *
3670  * */
3671
3672 static int
3673 other_tc_load(struct netdev *netdev_, struct ofpbuf *nlmsg OVS_UNUSED)
3674 {
3675     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3676     static const struct tc tc = TC_INITIALIZER(&tc, &tc_ops_other);
3677
3678     /* Nothing but a tc class implementation is allowed to write to a tc.  This
3679      * class never does that, so we can legitimately use a const tc object. */
3680     netdev->tc = CONST_CAST(struct tc *, &tc);
3681     return 0;
3682 }
3683
3684 static const struct tc_ops tc_ops_other = {
3685     NULL,                       /* linux_name */
3686     "linux-other",              /* ovs_name */
3687     0,                          /* n_queues */
3688     NULL,                       /* tc_install */
3689     other_tc_load,
3690     NULL,                       /* tc_destroy */
3691     NULL,                       /* qdisc_get */
3692     NULL,                       /* qdisc_set */
3693     NULL,                       /* class_get */
3694     NULL,                       /* class_set */
3695     NULL,                       /* class_delete */
3696     NULL,                       /* class_get_stats */
3697     NULL                        /* class_dump_stats */
3698 };
3699 \f
3700 /* Traffic control. */
3701
3702 /* Number of kernel "tc" ticks per second. */
3703 static double ticks_per_s;
3704
3705 /* Number of kernel "jiffies" per second.  This is used for the purpose of
3706  * computing buffer sizes.  Generally kernel qdiscs need to be able to buffer
3707  * one jiffy's worth of data.
3708  *
3709  * There are two possibilities here:
3710  *
3711  *    - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3712  *      approximate range of 100 to 1024.  That means that we really need to
3713  *      make sure that the qdisc can buffer that much data.
3714  *
3715  *    - 'buffer_hz' is an absurdly large number.  That means that the kernel
3716  *      has finely granular timers and there's no need to fudge additional room
3717  *      for buffers.  (There's no extra effort needed to implement that: the
3718  *      large 'buffer_hz' is used as a divisor, so practically any number will
3719  *      come out as 0 in the division.  Small integer results in the case of
3720  *      really high dividends won't have any real effect anyhow.)
3721  */
3722 static unsigned int buffer_hz;
3723
3724 /* Returns tc handle 'major':'minor'. */
3725 static unsigned int
3726 tc_make_handle(unsigned int major, unsigned int minor)
3727 {
3728     return TC_H_MAKE(major << 16, minor);
3729 }
3730
3731 /* Returns the major number from 'handle'. */
3732 static unsigned int
3733 tc_get_major(unsigned int handle)
3734 {
3735     return TC_H_MAJ(handle) >> 16;
3736 }
3737
3738 /* Returns the minor number from 'handle'. */
3739 static unsigned int
3740 tc_get_minor(unsigned int handle)
3741 {
3742     return TC_H_MIN(handle);
3743 }
3744
3745 static struct tcmsg *
3746 tc_make_request(const struct netdev *netdev, int type, unsigned int flags,
3747                 struct ofpbuf *request)
3748 {
3749     struct tcmsg *tcmsg;
3750     int ifindex;
3751     int error;
3752
3753     error = get_ifindex(netdev, &ifindex);
3754     if (error) {
3755         return NULL;
3756     }
3757
3758     ofpbuf_init(request, 512);
3759     nl_msg_put_nlmsghdr(request, sizeof *tcmsg, type, NLM_F_REQUEST | flags);
3760     tcmsg = ofpbuf_put_zeros(request, sizeof *tcmsg);
3761     tcmsg->tcm_family = AF_UNSPEC;
3762     tcmsg->tcm_ifindex = ifindex;
3763     /* Caller should fill in tcmsg->tcm_handle. */
3764     /* Caller should fill in tcmsg->tcm_parent. */
3765
3766     return tcmsg;
3767 }
3768
3769 static int
3770 tc_transact(struct ofpbuf *request, struct ofpbuf **replyp)
3771 {
3772     int error = nl_transact(NETLINK_ROUTE, request, replyp);
3773     ofpbuf_uninit(request);
3774     return error;
3775 }
3776
3777 /* Adds or deletes a root ingress qdisc on 'netdev'.  We use this for
3778  * policing configuration.
3779  *
3780  * This function is equivalent to running the following when 'add' is true:
3781  *     /sbin/tc qdisc add dev <devname> handle ffff: ingress
3782  *
3783  * This function is equivalent to running the following when 'add' is false:
3784  *     /sbin/tc qdisc del dev <devname> handle ffff: ingress
3785  *
3786  * The configuration and stats may be seen with the following command:
3787  *     /sbin/tc -s qdisc show dev <devname>
3788  *
3789  * Returns 0 if successful, otherwise a positive errno value.
3790  */
3791 static int
3792 tc_add_del_ingress_qdisc(struct netdev *netdev, bool add)
3793 {
3794     struct ofpbuf request;
3795     struct tcmsg *tcmsg;
3796     int error;
3797     int type = add ? RTM_NEWQDISC : RTM_DELQDISC;
3798     int flags = add ? NLM_F_EXCL | NLM_F_CREATE : 0;
3799
3800     tcmsg = tc_make_request(netdev, type, flags, &request);
3801     if (!tcmsg) {
3802         return ENODEV;
3803     }
3804     tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
3805     tcmsg->tcm_parent = TC_H_INGRESS;
3806     nl_msg_put_string(&request, TCA_KIND, "ingress");
3807     nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
3808
3809     error = tc_transact(&request, NULL);
3810     if (error) {
3811         /* If we're deleting the qdisc, don't worry about some of the
3812          * error conditions. */
3813         if (!add && (error == ENOENT || error == EINVAL)) {
3814             return 0;
3815         }
3816         return error;
3817     }
3818
3819     return 0;
3820 }
3821
3822 /* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
3823  * of 'kbits_burst'.
3824  *
3825  * This function is equivalent to running:
3826  *     /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
3827  *              basic police rate <kbits_rate>kbit burst <kbits_burst>k
3828  *              mtu 65535 drop
3829  *
3830  * The configuration and stats may be seen with the following command:
3831  *     /sbin/tc -s filter show <devname> eth0 parent ffff:
3832  *
3833  * Returns 0 if successful, otherwise a positive errno value.
3834  */
3835 static int
3836 tc_add_policer(struct netdev *netdev, int kbits_rate, int kbits_burst)
3837 {
3838     struct tc_police tc_police;
3839     struct ofpbuf request;
3840     struct tcmsg *tcmsg;
3841     size_t basic_offset;
3842     size_t police_offset;
3843     int error;
3844     int mtu = 65535;
3845
3846     memset(&tc_police, 0, sizeof tc_police);
3847     tc_police.action = TC_POLICE_SHOT;
3848     tc_police.mtu = mtu;
3849     tc_fill_rate(&tc_police.rate, (kbits_rate * 1000)/8, mtu);
3850     tc_police.burst = tc_bytes_to_ticks(tc_police.rate.rate,
3851                                         kbits_burst * 1024);
3852
3853     tcmsg = tc_make_request(netdev, RTM_NEWTFILTER,
3854                             NLM_F_EXCL | NLM_F_CREATE, &request);
3855     if (!tcmsg) {
3856         return ENODEV;
3857     }
3858     tcmsg->tcm_parent = tc_make_handle(0xffff, 0);
3859     tcmsg->tcm_info = tc_make_handle(49,
3860                                      (OVS_FORCE uint16_t) htons(ETH_P_ALL));
3861
3862     nl_msg_put_string(&request, TCA_KIND, "basic");
3863     basic_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3864     police_offset = nl_msg_start_nested(&request, TCA_BASIC_POLICE);
3865     nl_msg_put_unspec(&request, TCA_POLICE_TBF, &tc_police, sizeof tc_police);
3866     tc_put_rtab(&request, TCA_POLICE_RATE, &tc_police.rate);
3867     nl_msg_end_nested(&request, police_offset);
3868     nl_msg_end_nested(&request, basic_offset);
3869
3870     error = tc_transact(&request, NULL);
3871     if (error) {
3872         return error;
3873     }
3874
3875     return 0;
3876 }
3877
3878 static void
3879 read_psched(void)
3880 {
3881     /* The values in psched are not individually very meaningful, but they are
3882      * important.  The tables below show some values seen in the wild.
3883      *
3884      * Some notes:
3885      *
3886      *   - "c" has always been a constant 1000000 since at least Linux 2.4.14.
3887      *     (Before that, there are hints that it was 1000000000.)
3888      *
3889      *   - "d" can be unrealistically large, see the comment on 'buffer_hz'
3890      *     above.
3891      *
3892      *                        /proc/net/psched
3893      *     -----------------------------------
3894      * [1] 000c8000 000f4240 000f4240 00000064
3895      * [2] 000003e8 00000400 000f4240 3b9aca00
3896      * [3] 000003e8 00000400 000f4240 3b9aca00
3897      * [4] 000003e8 00000400 000f4240 00000064
3898      * [5] 000003e8 00000040 000f4240 3b9aca00
3899      * [6] 000003e8 00000040 000f4240 000000f9
3900      *
3901      *           a         b          c             d ticks_per_s     buffer_hz
3902      *     ------- --------- ---------- ------------- ----------- -------------
3903      * [1] 819,200 1,000,000  1,000,000           100     819,200           100
3904      * [2]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3905      * [3]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3906      * [4]   1,000     1,024  1,000,000           100     976,562           100
3907      * [5]   1,000        64  1,000,000 1,000,000,000  15,625,000 1,000,000,000
3908      * [6]   1,000        64  1,000,000           249  15,625,000           249
3909      *
3910      * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
3911      * [2] 2.6.26-1-686-bigmem from Debian lenny
3912      * [3] 2.6.26-2-sparc64 from Debian lenny
3913      * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
3914      * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
3915      * [6] 2.6.34 from kernel.org on KVM
3916      */
3917     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
3918     static const char fn[] = "/proc/net/psched";
3919     unsigned int a, b, c, d;
3920     FILE *stream;
3921
3922     if (!ovsthread_once_start(&once)) {
3923         return;
3924     }
3925
3926     ticks_per_s = 1.0;
3927     buffer_hz = 100;
3928
3929     stream = fopen(fn, "r");
3930     if (!stream) {
3931         VLOG_WARN("%s: open failed: %s", fn, ovs_strerror(errno));
3932         goto exit;
3933     }
3934
3935     if (fscanf(stream, "%x %x %x %x", &a, &b, &c, &d) != 4) {
3936         VLOG_WARN("%s: read failed", fn);
3937         fclose(stream);
3938         goto exit;
3939     }
3940     VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn, a, b, c, d);
3941     fclose(stream);
3942
3943     if (!a || !c) {
3944         VLOG_WARN("%s: invalid scheduler parameters", fn);
3945         goto exit;
3946     }
3947
3948     ticks_per_s = (double) a * c / b;
3949     if (c == 1000000) {
3950         buffer_hz = d;
3951     } else {
3952         VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
3953                   fn, a, b, c, d);
3954     }
3955     VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn, ticks_per_s, buffer_hz);
3956
3957 exit:
3958     ovsthread_once_done(&once);
3959 }
3960
3961 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
3962  * rate of 'rate' bytes per second. */
3963 static unsigned int
3964 tc_ticks_to_bytes(unsigned int rate, unsigned int ticks)
3965 {
3966     read_psched();
3967     return (rate * ticks) / ticks_per_s;
3968 }
3969
3970 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
3971  * rate of 'rate' bytes per second. */
3972 static unsigned int
3973 tc_bytes_to_ticks(unsigned int rate, unsigned int size)
3974 {
3975     read_psched();
3976     return rate ? ((unsigned long long int) ticks_per_s * size) / rate : 0;
3977 }
3978
3979 /* Returns the number of bytes that need to be reserved for qdisc buffering at
3980  * a transmission rate of 'rate' bytes per second. */
3981 static unsigned int
3982 tc_buffer_per_jiffy(unsigned int rate)
3983 {
3984     read_psched();
3985     return rate / buffer_hz;
3986 }
3987
3988 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
3989  * e.g. "htb", into '*kind' (if it is nonnull).  If 'options' is nonnull,
3990  * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
3991  * stores NULL into it if it is absent.
3992  *
3993  * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
3994  * 'msg'.
3995  *
3996  * Returns 0 if successful, otherwise a positive errno value. */
3997 static int
3998 tc_parse_qdisc(const struct ofpbuf *msg, const char **kind,
3999                struct nlattr **options)
4000 {
4001     static const struct nl_policy tca_policy[] = {
4002         [TCA_KIND] = { .type = NL_A_STRING, .optional = false },
4003         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
4004     };
4005     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
4006
4007     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
4008                          tca_policy, ta, ARRAY_SIZE(ta))) {
4009         VLOG_WARN_RL(&rl, "failed to parse qdisc message");
4010         goto error;
4011     }
4012
4013     if (kind) {
4014         *kind = nl_attr_get_string(ta[TCA_KIND]);
4015     }
4016
4017     if (options) {
4018         *options = ta[TCA_OPTIONS];
4019     }
4020
4021     return 0;
4022
4023 error:
4024     if (kind) {
4025         *kind = NULL;
4026     }
4027     if (options) {
4028         *options = NULL;
4029     }
4030     return EPROTO;
4031 }
4032
4033 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
4034  * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
4035  * into '*options', and its queue statistics into '*stats'.  Any of the output
4036  * arguments may be null.
4037  *
4038  * Returns 0 if successful, otherwise a positive errno value. */
4039 static int
4040 tc_parse_class(const struct ofpbuf *msg, unsigned int *handlep,
4041                struct nlattr **options, struct netdev_queue_stats *stats)
4042 {
4043     static const struct nl_policy tca_policy[] = {
4044         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = false },
4045         [TCA_STATS2] = { .type = NL_A_NESTED, .optional = false },
4046     };
4047     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
4048
4049     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
4050                          tca_policy, ta, ARRAY_SIZE(ta))) {
4051         VLOG_WARN_RL(&rl, "failed to parse class message");
4052         goto error;
4053     }
4054
4055     if (handlep) {
4056         struct tcmsg *tc = ofpbuf_at_assert(msg, NLMSG_HDRLEN, sizeof *tc);
4057         *handlep = tc->tcm_handle;
4058     }
4059
4060     if (options) {
4061         *options = ta[TCA_OPTIONS];
4062     }
4063
4064     if (stats) {
4065         const struct gnet_stats_queue *gsq;
4066         struct gnet_stats_basic gsb;
4067
4068         static const struct nl_policy stats_policy[] = {
4069             [TCA_STATS_BASIC] = { .type = NL_A_UNSPEC, .optional = false,
4070                                   .min_len = sizeof gsb },
4071             [TCA_STATS_QUEUE] = { .type = NL_A_UNSPEC, .optional = false,
4072                                   .min_len = sizeof *gsq },
4073         };
4074         struct nlattr *sa[ARRAY_SIZE(stats_policy)];
4075
4076         if (!nl_parse_nested(ta[TCA_STATS2], stats_policy,
4077                              sa, ARRAY_SIZE(sa))) {
4078             VLOG_WARN_RL(&rl, "failed to parse class stats");
4079             goto error;
4080         }
4081
4082         /* Alignment issues screw up the length of struct gnet_stats_basic on
4083          * some arch/bitsize combinations.  Newer versions of Linux have a
4084          * struct gnet_stats_basic_packed, but we can't depend on that.  The
4085          * easiest thing to do is just to make a copy. */
4086         memset(&gsb, 0, sizeof gsb);
4087         memcpy(&gsb, nl_attr_get(sa[TCA_STATS_BASIC]),
4088                MIN(nl_attr_get_size(sa[TCA_STATS_BASIC]), sizeof gsb));
4089         stats->tx_bytes = gsb.bytes;
4090         stats->tx_packets = gsb.packets;
4091
4092         gsq = nl_attr_get(sa[TCA_STATS_QUEUE]);
4093         stats->tx_errors = gsq->drops;
4094     }
4095
4096     return 0;
4097
4098 error:
4099     if (options) {
4100         *options = NULL;
4101     }
4102     if (stats) {
4103         memset(stats, 0, sizeof *stats);
4104     }
4105     return EPROTO;
4106 }
4107
4108 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
4109  * on 'netdev'. */
4110 static int
4111 tc_query_class(const struct netdev *netdev,
4112                unsigned int handle, unsigned int parent,
4113                struct ofpbuf **replyp)
4114 {
4115     struct ofpbuf request;
4116     struct tcmsg *tcmsg;
4117     int error;
4118
4119     tcmsg = tc_make_request(netdev, RTM_GETTCLASS, NLM_F_ECHO, &request);
4120     if (!tcmsg) {
4121         return ENODEV;
4122     }
4123     tcmsg->tcm_handle = handle;
4124     tcmsg->tcm_parent = parent;
4125
4126     error = tc_transact(&request, replyp);
4127     if (error) {
4128         VLOG_WARN_RL(&rl, "query %s class %u:%u (parent %u:%u) failed (%s)",
4129                      netdev_get_name(netdev),
4130                      tc_get_major(handle), tc_get_minor(handle),
4131                      tc_get_major(parent), tc_get_minor(parent),
4132                      ovs_strerror(error));
4133     }
4134     return error;
4135 }
4136
4137 /* Equivalent to "tc class del dev <name> handle <handle>". */
4138 static int
4139 tc_delete_class(const struct netdev *netdev, unsigned int handle)
4140 {
4141     struct ofpbuf request;
4142     struct tcmsg *tcmsg;
4143     int error;
4144
4145     tcmsg = tc_make_request(netdev, RTM_DELTCLASS, 0, &request);
4146     if (!tcmsg) {
4147         return ENODEV;
4148     }
4149     tcmsg->tcm_handle = handle;
4150     tcmsg->tcm_parent = 0;
4151
4152     error = tc_transact(&request, NULL);
4153     if (error) {
4154         VLOG_WARN_RL(&rl, "delete %s class %u:%u failed (%s)",
4155                      netdev_get_name(netdev),
4156                      tc_get_major(handle), tc_get_minor(handle),
4157                      ovs_strerror(error));
4158     }
4159     return error;
4160 }
4161
4162 /* Equivalent to "tc qdisc del dev <name> root". */
4163 static int
4164 tc_del_qdisc(struct netdev *netdev_)
4165 {
4166     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4167     struct ofpbuf request;
4168     struct tcmsg *tcmsg;
4169     int error;
4170
4171     tcmsg = tc_make_request(netdev_, RTM_DELQDISC, 0, &request);
4172     if (!tcmsg) {
4173         return ENODEV;
4174     }
4175     tcmsg->tcm_handle = tc_make_handle(1, 0);
4176     tcmsg->tcm_parent = TC_H_ROOT;
4177
4178     error = tc_transact(&request, NULL);
4179     if (error == EINVAL) {
4180         /* EINVAL probably means that the default qdisc was in use, in which
4181          * case we've accomplished our purpose. */
4182         error = 0;
4183     }
4184     if (!error && netdev->tc) {
4185         if (netdev->tc->ops->tc_destroy) {
4186             netdev->tc->ops->tc_destroy(netdev->tc);
4187         }
4188         netdev->tc = NULL;
4189     }
4190     return error;
4191 }
4192
4193 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
4194  * kernel to determine what they are.  Returns 0 if successful, otherwise a
4195  * positive errno value. */
4196 static int
4197 tc_query_qdisc(const struct netdev *netdev_)
4198 {
4199     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4200     struct ofpbuf request, *qdisc;
4201     const struct tc_ops *ops;
4202     struct tcmsg *tcmsg;
4203     int load_error;
4204     int error;
4205
4206     if (netdev->tc) {
4207         return 0;
4208     }
4209
4210     /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
4211      * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
4212      * 2.6.35 without that fix backported to it.
4213      *
4214      * To avoid the OOPS, we must not make a request that would attempt to dump
4215      * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
4216      * few others.  There are a few ways that I can see to do this, but most of
4217      * them seem to be racy (and if you lose the race the kernel OOPSes).  The
4218      * technique chosen here is to assume that any non-default qdisc that we
4219      * create will have a class with handle 1:0.  The built-in qdiscs only have
4220      * a class with handle 0:0.
4221      *
4222      * We could check for Linux 2.6.35+ and use a more straightforward method
4223      * there. */
4224     tcmsg = tc_make_request(netdev_, RTM_GETQDISC, NLM_F_ECHO, &request);
4225     if (!tcmsg) {
4226         return ENODEV;
4227     }
4228     tcmsg->tcm_handle = tc_make_handle(1, 0);
4229     tcmsg->tcm_parent = 0;
4230
4231     /* Figure out what tc class to instantiate. */
4232     error = tc_transact(&request, &qdisc);
4233     if (!error) {
4234         const char *kind;
4235
4236         error = tc_parse_qdisc(qdisc, &kind, NULL);
4237         if (error) {
4238             ops = &tc_ops_other;
4239         } else {
4240             ops = tc_lookup_linux_name(kind);
4241             if (!ops) {
4242                 static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 1);
4243                 VLOG_INFO_RL(&rl2, "unknown qdisc \"%s\"", kind);
4244
4245                 ops = &tc_ops_other;
4246             }
4247         }
4248     } else if (error == ENOENT) {
4249         /* Either it's a built-in qdisc, or it's a qdisc set up by some
4250          * other entity that doesn't have a handle 1:0.  We will assume
4251          * that it's the system default qdisc. */
4252         ops = &tc_ops_default;
4253         error = 0;
4254     } else {
4255         /* Who knows?  Maybe the device got deleted. */
4256         VLOG_WARN_RL(&rl, "query %s qdisc failed (%s)",
4257                      netdev_get_name(netdev_), ovs_strerror(error));
4258         ops = &tc_ops_other;
4259     }
4260
4261     /* Instantiate it. */
4262     load_error = ops->tc_load(CONST_CAST(struct netdev *, netdev_), qdisc);
4263     ovs_assert((load_error == 0) == (netdev->tc != NULL));
4264     ofpbuf_delete(qdisc);
4265
4266     return error ? error : load_error;
4267 }
4268
4269 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
4270    approximate the time to transmit packets of various lengths.  For an MTU of
4271    256 or less, each entry is exact; for an MTU of 257 through 512, each entry
4272    represents two possible packet lengths; for a MTU of 513 through 1024, four
4273    possible lengths; and so on.
4274
4275    Returns, for the specified 'mtu', the number of bits that packet lengths
4276    need to be shifted right to fit within such a 256-entry table. */
4277 static int
4278 tc_calc_cell_log(unsigned int mtu)
4279 {
4280     int cell_log;
4281
4282     if (!mtu) {
4283         mtu = ETH_PAYLOAD_MAX;
4284     }
4285     mtu += ETH_HEADER_LEN + VLAN_HEADER_LEN;
4286
4287     for (cell_log = 0; mtu >= 256; cell_log++) {
4288         mtu >>= 1;
4289     }
4290
4291     return cell_log;
4292 }
4293
4294 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
4295  * of 'mtu'. */
4296 static void
4297 tc_fill_rate(struct tc_ratespec *rate, uint64_t Bps, int mtu)
4298 {
4299     memset(rate, 0, sizeof *rate);
4300     rate->cell_log = tc_calc_cell_log(mtu);
4301     /* rate->overhead = 0; */           /* New in 2.6.24, not yet in some */
4302     /* rate->cell_align = 0; */         /* distro headers. */
4303     rate->mpu = ETH_TOTAL_MIN;
4304     rate->rate = Bps;
4305 }
4306
4307 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
4308  * attribute of the specified "type".
4309  *
4310  * See tc_calc_cell_log() above for a description of "rtab"s. */
4311 static void
4312 tc_put_rtab(struct ofpbuf *msg, uint16_t type, const struct tc_ratespec *rate)
4313 {
4314     uint32_t *rtab;
4315     unsigned int i;
4316
4317     rtab = nl_msg_put_unspec_uninit(msg, type, TC_RTAB_SIZE);
4318     for (i = 0; i < TC_RTAB_SIZE / sizeof *rtab; i++) {
4319         unsigned packet_size = (i + 1) << rate->cell_log;
4320         if (packet_size < rate->mpu) {
4321             packet_size = rate->mpu;
4322         }
4323         rtab[i] = tc_bytes_to_ticks(rate->rate, packet_size);
4324     }
4325 }
4326
4327 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
4328  * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
4329  * burst size of 'burst_bytes'.  (If no value was requested, a 'burst_bytes' of
4330  * 0 is fine.) */
4331 static int
4332 tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes)
4333 {
4334     unsigned int min_burst = tc_buffer_per_jiffy(Bps) + mtu;
4335     return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
4336 }
4337 \f
4338 /* Linux-only functions declared in netdev-linux.h  */
4339
4340 /* Modifies the 'flag' bit in ethtool's flags field for 'netdev'.  If
4341  * 'enable' is true, the bit is set.  Otherwise, it is cleared. */
4342 int
4343 netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag,
4344                               const char *flag_name, bool enable)
4345 {
4346     const char *netdev_name = netdev_get_name(netdev);
4347     struct ethtool_value evalue;
4348     uint32_t new_flags;
4349     int error;
4350
4351     COVERAGE_INC(netdev_get_ethtool);
4352     memset(&evalue, 0, sizeof evalue);
4353     error = netdev_linux_do_ethtool(netdev_name,
4354                                     (struct ethtool_cmd *)&evalue,
4355                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4356     if (error) {
4357         return error;
4358     }
4359
4360     COVERAGE_INC(netdev_set_ethtool);
4361     evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0);
4362     error = netdev_linux_do_ethtool(netdev_name,
4363                                     (struct ethtool_cmd *)&evalue,
4364                                     ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS");
4365     if (error) {
4366         return error;
4367     }
4368
4369     COVERAGE_INC(netdev_get_ethtool);
4370     memset(&evalue, 0, sizeof evalue);
4371     error = netdev_linux_do_ethtool(netdev_name,
4372                                     (struct ethtool_cmd *)&evalue,
4373                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4374     if (error) {
4375         return error;
4376     }
4377
4378     if (new_flags != evalue.data) {
4379         VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network "
4380                      "device %s failed", enable ? "enable" : "disable",
4381                      flag_name, netdev_name);
4382         return EOPNOTSUPP;
4383     }
4384
4385     return 0;
4386 }
4387 \f
4388 /* Utility functions. */
4389
4390 /* Copies 'src' into 'dst', performing format conversion in the process. */
4391 static void
4392 netdev_stats_from_rtnl_link_stats(struct netdev_stats *dst,
4393                                   const struct rtnl_link_stats *src)
4394 {
4395     dst->rx_packets = src->rx_packets;
4396     dst->tx_packets = src->tx_packets;
4397     dst->rx_bytes = src->rx_bytes;
4398     dst->tx_bytes = src->tx_bytes;
4399     dst->rx_errors = src->rx_errors;
4400     dst->tx_errors = src->tx_errors;
4401     dst->rx_dropped = src->rx_dropped;
4402     dst->tx_dropped = src->tx_dropped;
4403     dst->multicast = src->multicast;
4404     dst->collisions = src->collisions;
4405     dst->rx_length_errors = src->rx_length_errors;
4406     dst->rx_over_errors = src->rx_over_errors;
4407     dst->rx_crc_errors = src->rx_crc_errors;
4408     dst->rx_frame_errors = src->rx_frame_errors;
4409     dst->rx_fifo_errors = src->rx_fifo_errors;
4410     dst->rx_missed_errors = src->rx_missed_errors;
4411     dst->tx_aborted_errors = src->tx_aborted_errors;
4412     dst->tx_carrier_errors = src->tx_carrier_errors;
4413     dst->tx_fifo_errors = src->tx_fifo_errors;
4414     dst->tx_heartbeat_errors = src->tx_heartbeat_errors;
4415     dst->tx_window_errors = src->tx_window_errors;
4416 }
4417
4418 static int
4419 get_stats_via_netlink(const struct netdev *netdev_, struct netdev_stats *stats)
4420 {
4421     struct ofpbuf request;
4422     struct ofpbuf *reply;
4423     int error;
4424
4425     ofpbuf_init(&request, 0);
4426     nl_msg_put_nlmsghdr(&request,
4427                         sizeof(struct ifinfomsg) + NL_ATTR_SIZE(IFNAMSIZ),
4428                         RTM_GETLINK, NLM_F_REQUEST);
4429     ofpbuf_put_zeros(&request, sizeof(struct ifinfomsg));
4430     nl_msg_put_string(&request, IFLA_IFNAME, netdev_get_name(netdev_));
4431     error = nl_transact(NETLINK_ROUTE, &request, &reply);
4432     ofpbuf_uninit(&request);
4433     if (error) {
4434         return error;
4435     }
4436
4437     if (ofpbuf_try_pull(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg))) {
4438         const struct nlattr *a = nl_attr_find(reply, 0, IFLA_STATS);
4439         if (a && nl_attr_get_size(a) >= sizeof(struct rtnl_link_stats)) {
4440             netdev_stats_from_rtnl_link_stats(stats, nl_attr_get(a));
4441             error = 0;
4442         } else {
4443             VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
4444             error = EPROTO;
4445         }
4446     } else {
4447         VLOG_WARN_RL(&rl, "short RTM_GETLINK reply");
4448         error = EPROTO;
4449     }
4450
4451
4452     ofpbuf_delete(reply);
4453     return error;
4454 }
4455
4456 static int
4457 get_flags(const struct netdev *dev, unsigned int *flags)
4458 {
4459     struct ifreq ifr;
4460     int error;
4461
4462     *flags = 0;
4463     error = af_inet_ifreq_ioctl(dev->name, &ifr, SIOCGIFFLAGS, "SIOCGIFFLAGS");
4464     if (!error) {
4465         *flags = ifr.ifr_flags;
4466     }
4467     return error;
4468 }
4469
4470 static int
4471 set_flags(const char *name, unsigned int flags)
4472 {
4473     struct ifreq ifr;
4474
4475     ifr.ifr_flags = flags;
4476     return af_inet_ifreq_ioctl(name, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
4477 }
4478
4479 static int
4480 do_get_ifindex(const char *netdev_name)
4481 {
4482     struct ifreq ifr;
4483     int error;
4484
4485     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4486     COVERAGE_INC(netdev_get_ifindex);
4487
4488     error = af_inet_ioctl(SIOCGIFINDEX, &ifr);
4489     if (error) {
4490         VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
4491                      netdev_name, ovs_strerror(error));
4492         return -error;
4493     }
4494     return ifr.ifr_ifindex;
4495 }
4496
4497 static int
4498 get_ifindex(const struct netdev *netdev_, int *ifindexp)
4499 {
4500     struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4501
4502     if (!(netdev->cache_valid & VALID_IFINDEX)) {
4503         int ifindex = do_get_ifindex(netdev_get_name(netdev_));
4504
4505         if (ifindex < 0) {
4506             netdev->get_ifindex_error = -ifindex;
4507             netdev->ifindex = 0;
4508         } else {
4509             netdev->get_ifindex_error = 0;
4510             netdev->ifindex = ifindex;
4511         }
4512         netdev->cache_valid |= VALID_IFINDEX;
4513     }
4514
4515     *ifindexp = netdev->ifindex;
4516     return netdev->get_ifindex_error;
4517 }
4518
4519 static int
4520 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
4521 {
4522     struct ifreq ifr;
4523     int hwaddr_family;
4524     int error;
4525
4526     memset(&ifr, 0, sizeof ifr);
4527     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4528     COVERAGE_INC(netdev_get_hwaddr);
4529     error = af_inet_ioctl(SIOCGIFHWADDR, &ifr);
4530     if (error) {
4531         /* ENODEV probably means that a vif disappeared asynchronously and
4532          * hasn't been removed from the database yet, so reduce the log level
4533          * to INFO for that case. */
4534         VLOG(error == ENODEV ? VLL_INFO : VLL_ERR,
4535              "ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4536              netdev_name, ovs_strerror(error));
4537         return error;
4538     }
4539     hwaddr_family = ifr.ifr_hwaddr.sa_family;
4540     if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
4541         VLOG_WARN("%s device has unknown hardware address family %d",
4542                   netdev_name, hwaddr_family);
4543     }
4544     memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
4545     return 0;
4546 }
4547
4548 static int
4549 set_etheraddr(const char *netdev_name,
4550               const uint8_t mac[ETH_ADDR_LEN])
4551 {
4552     struct ifreq ifr;
4553     int error;
4554
4555     memset(&ifr, 0, sizeof ifr);
4556     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4557     ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
4558     memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
4559     COVERAGE_INC(netdev_set_hwaddr);
4560     error = af_inet_ioctl(SIOCSIFHWADDR, &ifr);
4561     if (error) {
4562         VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4563                  netdev_name, ovs_strerror(error));
4564     }
4565     return error;
4566 }
4567
4568 static int
4569 netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd,
4570                         int cmd, const char *cmd_name)
4571 {
4572     struct ifreq ifr;
4573     int error;
4574
4575     memset(&ifr, 0, sizeof ifr);
4576     ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
4577     ifr.ifr_data = (caddr_t) ecmd;
4578
4579     ecmd->cmd = cmd;
4580     error = af_inet_ioctl(SIOCETHTOOL, &ifr);
4581     if (error) {
4582         if (error != EOPNOTSUPP) {
4583             VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
4584                          "failed: %s", cmd_name, name, ovs_strerror(error));
4585         } else {
4586             /* The device doesn't support this operation.  That's pretty
4587              * common, so there's no point in logging anything. */
4588         }
4589     }
4590     return error;
4591 }
4592
4593 static int
4594 netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
4595                       int cmd, const char *cmd_name)
4596 {
4597     struct ifreq ifr;
4598     int error;
4599
4600     ifr.ifr_addr.sa_family = AF_INET;
4601     error = af_inet_ifreq_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name);
4602     if (!error) {
4603         const struct sockaddr_in *sin = ALIGNED_CAST(struct sockaddr_in *,
4604                                                      &ifr.ifr_addr);
4605         *ip = sin->sin_addr;
4606     }
4607     return error;
4608 }
4609
4610 /* Returns an AF_PACKET raw socket or a negative errno value. */
4611 static int
4612 af_packet_sock(void)
4613 {
4614     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
4615     static int sock;
4616
4617     if (ovsthread_once_start(&once)) {
4618         sock = socket(AF_PACKET, SOCK_RAW, 0);
4619         if (sock >= 0) {
4620             int error = set_nonblocking(sock);
4621             if (error) {
4622                 close(sock);
4623                 sock = -error;
4624             }
4625         } else {
4626             sock = -errno;
4627             VLOG_ERR("failed to create packet socket: %s",
4628                      ovs_strerror(errno));
4629         }
4630         ovsthread_once_done(&once);
4631     }
4632
4633     return sock;
4634 }