lib/netdev-linux.c

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