lib/netdev-linux.c

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