lib/netdev-linux.c

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