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