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