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