lib/netdev-linux.c

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