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