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 int
2420 netdev_tap_pl_update_flags(struct netdev *netdev, enum netdev_flags off,
2421                           enum netdev_flags on, enum netdev_flags *old_flagsp)
2422 {
2423     return 0;
2424 }
2425
2426 static unsigned int
2427 netdev_linux_change_seq(const struct netdev *netdev)
2428 {
2429     return netdev_dev_linux_cast(netdev_get_dev(netdev))->change_seq;
2430 }
2431
2432 #define NETDEV_LINUX_CLASS(NAME, CREATE, GET_STATS, SET_STATS,  \
2433                            GET_FEATURES, GET_STATUS,            \
2434                            UPDATE_FLAGS)                        \
2435 {                                                               \
2436     NAME,                                                       \
2437                                                                 \
2438     netdev_linux_init,                                          \
2439     netdev_linux_run,                                           \
2440     netdev_linux_wait,                                          \
2441                                                                 \
2442     CREATE,                                                     \
2443     netdev_linux_destroy,                                       \
2444     NULL,                       /* get_config */                \
2445     NULL,                       /* set_config */                \
2446                                                                 \
2447     netdev_linux_open,                                          \
2448     netdev_linux_close,                                         \
2449                                                                 \
2450     netdev_linux_listen,                                        \
2451     netdev_linux_recv,                                          \
2452     netdev_linux_recv_wait,                                     \
2453     netdev_linux_drain,                                         \
2454                                                                 \
2455     netdev_linux_send,                                          \
2456     netdev_linux_send_wait,                                     \
2457                                                                 \
2458     netdev_linux_set_etheraddr,                                 \
2459     netdev_linux_get_etheraddr,                                 \
2460     netdev_linux_get_mtu,                                       \
2461     netdev_linux_set_mtu,                                       \
2462     netdev_linux_get_ifindex,                                   \
2463     netdev_linux_get_carrier,                                   \
2464     netdev_linux_get_carrier_resets,                            \
2465     netdev_linux_set_miimon_interval,                           \
2466     GET_STATS,                                                  \
2467     SET_STATS,                                                  \
2468                                                                 \
2469     GET_FEATURES,                                               \
2470     netdev_linux_set_advertisements,                            \
2471                                                                 \
2472     netdev_linux_set_policing,                                  \
2473     netdev_linux_get_qos_types,                                 \
2474     netdev_linux_get_qos_capabilities,                          \
2475     netdev_linux_get_qos,                                       \
2476     netdev_linux_set_qos,                                       \
2477     netdev_linux_get_queue,                                     \
2478     netdev_linux_set_queue,                                     \
2479     netdev_linux_delete_queue,                                  \
2480     netdev_linux_get_queue_stats,                               \
2481     netdev_linux_dump_queues,                                   \
2482     netdev_linux_dump_queue_stats,                              \
2483                                                                 \
2484     netdev_linux_get_in4,                                       \
2485     netdev_linux_set_in4,                                       \
2486     netdev_linux_get_in6,                                       \
2487     netdev_linux_add_router,                                    \
2488     netdev_linux_get_next_hop,                                  \
2489     GET_STATUS,                                                 \
2490     netdev_linux_arp_lookup,                                    \
2491                                                                 \
2492     UPDATE_FLAGS,                                               \
2493                                                                 \
2494     netdev_linux_change_seq                                     \
2495 }
2496
2497 const struct netdev_class netdev_linux_class =
2498     NETDEV_LINUX_CLASS(
2499         "system",
2500         netdev_linux_create,
2501         netdev_linux_get_stats,
2502         NULL,                    /* set_stats */
2503         netdev_linux_get_features,
2504         netdev_linux_get_drv_info,
2505         netdev_linux_update_flags);
2506
2507 const struct netdev_class netdev_tap_class =
2508     NETDEV_LINUX_CLASS(
2509         "tap",
2510         netdev_linux_create_tap,
2511         netdev_tap_get_stats,
2512         NULL,                   /* set_stats */
2513         netdev_linux_get_features,
2514         netdev_linux_get_drv_info,
2515         netdev_linux_update_flags);
2516
2517 const struct netdev_class netdev_internal_class =
2518     NETDEV_LINUX_CLASS(
2519         "internal",
2520         netdev_linux_create,
2521         netdev_internal_get_stats,
2522         netdev_vport_set_stats,
2523         NULL,                  /* get_features */
2524         netdev_internal_get_drv_info,
2525         netdev_linux_update_flags);
2526
2527 const struct netdev_class netdev_tap_pl_class =
2528     NETDEV_LINUX_CLASS(
2529         "tap_pl",
2530         netdev_linux_create_tap_pl,
2531         netdev_tap_get_stats,
2532         NULL,                   /* set_stats */
2533         netdev_linux_get_features,
2534         netdev_linux_get_drv_info,
2535         netdev_tap_pl_update_flags);
2536 \f
2537 /* HTB traffic control class. */
2538
2539 #define HTB_N_QUEUES 0xf000
2540
2541 struct htb {
2542     struct tc tc;
2543     unsigned int max_rate;      /* In bytes/s. */
2544 };
2545
2546 struct htb_class {
2547     struct tc_queue tc_queue;
2548     unsigned int min_rate;      /* In bytes/s. */
2549     unsigned int max_rate;      /* In bytes/s. */
2550     unsigned int burst;         /* In bytes. */
2551     unsigned int priority;      /* Lower values are higher priorities. */
2552 };
2553
2554 static struct htb *
2555 htb_get__(const struct netdev *netdev)
2556 {
2557     struct netdev_dev_linux *netdev_dev =
2558                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2559     return CONTAINER_OF(netdev_dev->tc, struct htb, tc);
2560 }
2561
2562 static void
2563 htb_install__(struct netdev *netdev, uint64_t max_rate)
2564 {
2565     struct netdev_dev_linux *netdev_dev =
2566                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2567     struct htb *htb;
2568
2569     htb = xmalloc(sizeof *htb);
2570     tc_init(&htb->tc, &tc_ops_htb);
2571     htb->max_rate = max_rate;
2572
2573     netdev_dev->tc = &htb->tc;
2574 }
2575
2576 /* Create an HTB qdisc.
2577  *
2578  * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2579 static int
2580 htb_setup_qdisc__(struct netdev *netdev)
2581 {
2582     size_t opt_offset;
2583     struct tc_htb_glob opt;
2584     struct ofpbuf request;
2585     struct tcmsg *tcmsg;
2586
2587     tc_del_qdisc(netdev);
2588
2589     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2590                             NLM_F_EXCL | NLM_F_CREATE, &request);
2591     if (!tcmsg) {
2592         return ENODEV;
2593     }
2594     tcmsg->tcm_handle = tc_make_handle(1, 0);
2595     tcmsg->tcm_parent = TC_H_ROOT;
2596
2597     nl_msg_put_string(&request, TCA_KIND, "htb");
2598
2599     memset(&opt, 0, sizeof opt);
2600     opt.rate2quantum = 10;
2601     opt.version = 3;
2602     opt.defcls = 1;
2603
2604     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2605     nl_msg_put_unspec(&request, TCA_HTB_INIT, &opt, sizeof opt);
2606     nl_msg_end_nested(&request, opt_offset);
2607
2608     return tc_transact(&request, NULL);
2609 }
2610
2611 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2612  * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2613 static int
2614 htb_setup_class__(struct netdev *netdev, unsigned int handle,
2615                   unsigned int parent, struct htb_class *class)
2616 {
2617     size_t opt_offset;
2618     struct tc_htb_opt opt;
2619     struct ofpbuf request;
2620     struct tcmsg *tcmsg;
2621     int error;
2622     int mtu;
2623
2624     error = netdev_get_mtu(netdev, &mtu);
2625     if (error) {
2626         VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU",
2627                      netdev_get_name(netdev));
2628         return error;
2629     }
2630
2631     memset(&opt, 0, sizeof opt);
2632     tc_fill_rate(&opt.rate, class->min_rate, mtu);
2633     tc_fill_rate(&opt.ceil, class->max_rate, mtu);
2634     opt.buffer = tc_calc_buffer(opt.rate.rate, mtu, class->burst);
2635     opt.cbuffer = tc_calc_buffer(opt.ceil.rate, mtu, class->burst);
2636     opt.prio = class->priority;
2637
2638     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2639     if (!tcmsg) {
2640         return ENODEV;
2641     }
2642     tcmsg->tcm_handle = handle;
2643     tcmsg->tcm_parent = parent;
2644
2645     nl_msg_put_string(&request, TCA_KIND, "htb");
2646     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2647     nl_msg_put_unspec(&request, TCA_HTB_PARMS, &opt, sizeof opt);
2648     tc_put_rtab(&request, TCA_HTB_RTAB, &opt.rate);
2649     tc_put_rtab(&request, TCA_HTB_CTAB, &opt.ceil);
2650     nl_msg_end_nested(&request, opt_offset);
2651
2652     error = tc_transact(&request, NULL);
2653     if (error) {
2654         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
2655                      "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2656                      netdev_get_name(netdev),
2657                      tc_get_major(handle), tc_get_minor(handle),
2658                      tc_get_major(parent), tc_get_minor(parent),
2659                      class->min_rate, class->max_rate,
2660                      class->burst, class->priority, strerror(error));
2661     }
2662     return error;
2663 }
2664
2665 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2666  * description of them into 'details'.  The description complies with the
2667  * specification given in the vswitch database documentation for linux-htb
2668  * queue details. */
2669 static int
2670 htb_parse_tca_options__(struct nlattr *nl_options, struct htb_class *class)
2671 {
2672     static const struct nl_policy tca_htb_policy[] = {
2673         [TCA_HTB_PARMS] = { .type = NL_A_UNSPEC, .optional = false,
2674                             .min_len = sizeof(struct tc_htb_opt) },
2675     };
2676
2677     struct nlattr *attrs[ARRAY_SIZE(tca_htb_policy)];
2678     const struct tc_htb_opt *htb;
2679
2680     if (!nl_parse_nested(nl_options, tca_htb_policy,
2681                          attrs, ARRAY_SIZE(tca_htb_policy))) {
2682         VLOG_WARN_RL(&rl, "failed to parse HTB class options");
2683         return EPROTO;
2684     }
2685
2686     htb = nl_attr_get(attrs[TCA_HTB_PARMS]);
2687     class->min_rate = htb->rate.rate;
2688     class->max_rate = htb->ceil.rate;
2689     class->burst = tc_ticks_to_bytes(htb->rate.rate, htb->buffer);
2690     class->priority = htb->prio;
2691     return 0;
2692 }
2693
2694 static int
2695 htb_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2696                   struct htb_class *options,
2697                   struct netdev_queue_stats *stats)
2698 {
2699     struct nlattr *nl_options;
2700     unsigned int handle;
2701     int error;
2702
2703     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2704     if (!error && queue_id) {
2705         unsigned int major = tc_get_major(handle);
2706         unsigned int minor = tc_get_minor(handle);
2707         if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2708             *queue_id = minor - 1;
2709         } else {
2710             error = EPROTO;
2711         }
2712     }
2713     if (!error && options) {
2714         error = htb_parse_tca_options__(nl_options, options);
2715     }
2716     return error;
2717 }
2718
2719 static void
2720 htb_parse_qdisc_details__(struct netdev *netdev,
2721                           const struct shash *details, struct htb_class *hc)
2722 {
2723     const char *max_rate_s;
2724
2725     max_rate_s = shash_find_data(details, "max-rate");
2726     hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2727     if (!hc->max_rate) {
2728         enum netdev_features current;
2729
2730         netdev_get_features(netdev, &current, NULL, NULL, NULL);
2731         hc->max_rate = netdev_features_to_bps(current) / 8;
2732     }
2733     hc->min_rate = hc->max_rate;
2734     hc->burst = 0;
2735     hc->priority = 0;
2736 }
2737
2738 static int
2739 htb_parse_class_details__(struct netdev *netdev,
2740                           const struct shash *details, struct htb_class *hc)
2741 {
2742     const struct htb *htb = htb_get__(netdev);
2743     const char *min_rate_s = shash_find_data(details, "min-rate");
2744     const char *max_rate_s = shash_find_data(details, "max-rate");
2745     const char *burst_s = shash_find_data(details, "burst");
2746     const char *priority_s = shash_find_data(details, "priority");
2747     int mtu, error;
2748
2749     error = netdev_get_mtu(netdev, &mtu);
2750     if (error) {
2751         VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU",
2752                      netdev_get_name(netdev));
2753         return error;
2754     }
2755
2756     /* HTB requires at least an mtu sized min-rate to send any traffic even
2757      * on uncongested links. */
2758     hc->min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
2759     hc->min_rate = MAX(hc->min_rate, mtu);
2760     hc->min_rate = MIN(hc->min_rate, htb->max_rate);
2761
2762     /* max-rate */
2763     hc->max_rate = (max_rate_s
2764                     ? strtoull(max_rate_s, NULL, 10) / 8
2765                     : htb->max_rate);
2766     hc->max_rate = MAX(hc->max_rate, hc->min_rate);
2767     hc->max_rate = MIN(hc->max_rate, htb->max_rate);
2768
2769     /* burst
2770      *
2771      * According to hints in the documentation that I've read, it is important
2772      * that 'burst' be at least as big as the largest frame that might be
2773      * transmitted.  Also, making 'burst' a bit bigger than necessary is OK,
2774      * but having it a bit too small is a problem.  Since netdev_get_mtu()
2775      * doesn't include the Ethernet header, we need to add at least 14 (18?) to
2776      * the MTU.  We actually add 64, instead of 14, as a guard against
2777      * additional headers get tacked on somewhere that we're not aware of. */
2778     hc->burst = burst_s ? strtoull(burst_s, NULL, 10) / 8 : 0;
2779     hc->burst = MAX(hc->burst, mtu + 64);
2780
2781     /* priority */
2782     hc->priority = priority_s ? strtoul(priority_s, NULL, 10) : 0;
2783
2784     return 0;
2785 }
2786
2787 static int
2788 htb_query_class__(const struct netdev *netdev, unsigned int handle,
2789                   unsigned int parent, struct htb_class *options,
2790                   struct netdev_queue_stats *stats)
2791 {
2792     struct ofpbuf *reply;
2793     int error;
2794
2795     error = tc_query_class(netdev, handle, parent, &reply);
2796     if (!error) {
2797         error = htb_parse_tcmsg__(reply, NULL, options, stats);
2798         ofpbuf_delete(reply);
2799     }
2800     return error;
2801 }
2802
2803 static int
2804 htb_tc_install(struct netdev *netdev, const struct shash *details)
2805 {
2806     int error;
2807
2808     error = htb_setup_qdisc__(netdev);
2809     if (!error) {
2810         struct htb_class hc;
2811
2812         htb_parse_qdisc_details__(netdev, details, &hc);
2813         error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2814                                   tc_make_handle(1, 0), &hc);
2815         if (!error) {
2816             htb_install__(netdev, hc.max_rate);
2817         }
2818     }
2819     return error;
2820 }
2821
2822 static struct htb_class *
2823 htb_class_cast__(const struct tc_queue *queue)
2824 {
2825     return CONTAINER_OF(queue, struct htb_class, tc_queue);
2826 }
2827
2828 static void
2829 htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
2830                    const struct htb_class *hc)
2831 {
2832     struct htb *htb = htb_get__(netdev);
2833     size_t hash = hash_int(queue_id, 0);
2834     struct tc_queue *queue;
2835     struct htb_class *hcp;
2836
2837     queue = tc_find_queue__(netdev, queue_id, hash);
2838     if (queue) {
2839         hcp = htb_class_cast__(queue);
2840     } else {
2841         hcp = xmalloc(sizeof *hcp);
2842         queue = &hcp->tc_queue;
2843         queue->queue_id = queue_id;
2844         hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
2845     }
2846
2847     hcp->min_rate = hc->min_rate;
2848     hcp->max_rate = hc->max_rate;
2849     hcp->burst = hc->burst;
2850     hcp->priority = hc->priority;
2851 }
2852
2853 static int
2854 htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
2855 {
2856     struct ofpbuf msg;
2857     struct nl_dump dump;
2858     struct htb_class hc;
2859
2860     /* Get qdisc options. */
2861     hc.max_rate = 0;
2862     htb_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
2863     htb_install__(netdev, hc.max_rate);
2864
2865     /* Get queues. */
2866     if (!start_queue_dump(netdev, &dump)) {
2867         return ENODEV;
2868     }
2869     while (nl_dump_next(&dump, &msg)) {
2870         unsigned int queue_id;
2871
2872         if (!htb_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
2873             htb_update_queue__(netdev, queue_id, &hc);
2874         }
2875     }
2876     nl_dump_done(&dump);
2877
2878     return 0;
2879 }
2880
2881 static void
2882 htb_tc_destroy(struct tc *tc)
2883 {
2884     struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
2885     struct htb_class *hc, *next;
2886
2887     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &htb->tc.queues) {
2888         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2889         free(hc);
2890     }
2891     tc_destroy(tc);
2892     free(htb);
2893 }
2894
2895 static int
2896 htb_qdisc_get(const struct netdev *netdev, struct shash *details)
2897 {
2898     const struct htb *htb = htb_get__(netdev);
2899     shash_add(details, "max-rate", xasprintf("%llu", 8ULL * htb->max_rate));
2900     return 0;
2901 }
2902
2903 static int
2904 htb_qdisc_set(struct netdev *netdev, const struct shash *details)
2905 {
2906     struct htb_class hc;
2907     int error;
2908
2909     htb_parse_qdisc_details__(netdev, details, &hc);
2910     error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2911                               tc_make_handle(1, 0), &hc);
2912     if (!error) {
2913         htb_get__(netdev)->max_rate = hc.max_rate;
2914     }
2915     return error;
2916 }
2917
2918 static int
2919 htb_class_get(const struct netdev *netdev OVS_UNUSED,
2920               const struct tc_queue *queue, struct shash *details)
2921 {
2922     const struct htb_class *hc = htb_class_cast__(queue);
2923
2924     shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
2925     if (hc->min_rate != hc->max_rate) {
2926         shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
2927     }
2928     shash_add(details, "burst", xasprintf("%llu", 8ULL * hc->burst));
2929     if (hc->priority) {
2930         shash_add(details, "priority", xasprintf("%u", hc->priority));
2931     }
2932     return 0;
2933 }
2934
2935 static int
2936 htb_class_set(struct netdev *netdev, unsigned int queue_id,
2937               const struct shash *details)
2938 {
2939     struct htb_class hc;
2940     int error;
2941
2942     error = htb_parse_class_details__(netdev, details, &hc);
2943     if (error) {
2944         return error;
2945     }
2946
2947     error = htb_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
2948                               tc_make_handle(1, 0xfffe), &hc);
2949     if (error) {
2950         return error;
2951     }
2952
2953     htb_update_queue__(netdev, queue_id, &hc);
2954     return 0;
2955 }
2956
2957 static int
2958 htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
2959 {
2960     struct htb_class *hc = htb_class_cast__(queue);
2961     struct htb *htb = htb_get__(netdev);
2962     int error;
2963
2964     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
2965     if (!error) {
2966         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2967         free(hc);
2968     }
2969     return error;
2970 }
2971
2972 static int
2973 htb_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
2974                     struct netdev_queue_stats *stats)
2975 {
2976     return htb_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
2977                              tc_make_handle(1, 0xfffe), NULL, stats);
2978 }
2979
2980 static int
2981 htb_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
2982                      const struct ofpbuf *nlmsg,
2983                      netdev_dump_queue_stats_cb *cb, void *aux)
2984 {
2985     struct netdev_queue_stats stats;
2986     unsigned int handle, major, minor;
2987     int error;
2988
2989     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
2990     if (error) {
2991         return error;
2992     }
2993
2994     major = tc_get_major(handle);
2995     minor = tc_get_minor(handle);
2996     if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2997         (*cb)(minor - 1, &stats, aux);
2998     }
2999     return 0;
3000 }
3001
3002 static const struct tc_ops tc_ops_htb = {
3003     "htb",                      /* linux_name */
3004     "linux-htb",                /* ovs_name */
3005     HTB_N_QUEUES,               /* n_queues */
3006     htb_tc_install,
3007     htb_tc_load,
3008     htb_tc_destroy,
3009     htb_qdisc_get,
3010     htb_qdisc_set,
3011     htb_class_get,
3012     htb_class_set,
3013     htb_class_delete,
3014     htb_class_get_stats,
3015     htb_class_dump_stats
3016 };
3017 \f
3018 /* "linux-hfsc" traffic control class. */
3019
3020 #define HFSC_N_QUEUES 0xf000
3021
3022 struct hfsc {
3023     struct tc tc;
3024     uint32_t max_rate;
3025 };
3026
3027 struct hfsc_class {
3028     struct tc_queue tc_queue;
3029     uint32_t min_rate;
3030     uint32_t max_rate;
3031 };
3032
3033 static struct hfsc *
3034 hfsc_get__(const struct netdev *netdev)
3035 {
3036     struct netdev_dev_linux *netdev_dev;
3037     netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
3038     return CONTAINER_OF(netdev_dev->tc, struct hfsc, tc);
3039 }
3040
3041 static struct hfsc_class *
3042 hfsc_class_cast__(const struct tc_queue *queue)
3043 {
3044     return CONTAINER_OF(queue, struct hfsc_class, tc_queue);
3045 }
3046
3047 static void
3048 hfsc_install__(struct netdev *netdev, uint32_t max_rate)
3049 {
3050     struct netdev_dev_linux * netdev_dev;
3051     struct hfsc *hfsc;
3052
3053     netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
3054     hfsc = xmalloc(sizeof *hfsc);
3055     tc_init(&hfsc->tc, &tc_ops_hfsc);
3056     hfsc->max_rate = max_rate;
3057     netdev_dev->tc = &hfsc->tc;
3058 }
3059
3060 static void
3061 hfsc_update_queue__(struct netdev *netdev, unsigned int queue_id,
3062                     const struct hfsc_class *hc)
3063 {
3064     size_t hash;
3065     struct hfsc *hfsc;
3066     struct hfsc_class *hcp;
3067     struct tc_queue *queue;
3068
3069     hfsc = hfsc_get__(netdev);
3070     hash = hash_int(queue_id, 0);
3071
3072     queue = tc_find_queue__(netdev, queue_id, hash);
3073     if (queue) {
3074         hcp = hfsc_class_cast__(queue);
3075     } else {
3076         hcp             = xmalloc(sizeof *hcp);
3077         queue           = &hcp->tc_queue;
3078         queue->queue_id = queue_id;
3079         hmap_insert(&hfsc->tc.queues, &queue->hmap_node, hash);
3080     }
3081
3082     hcp->min_rate = hc->min_rate;
3083     hcp->max_rate = hc->max_rate;
3084 }
3085
3086 static int
3087 hfsc_parse_tca_options__(struct nlattr *nl_options, struct hfsc_class *class)
3088 {
3089     const struct tc_service_curve *rsc, *fsc, *usc;
3090     static const struct nl_policy tca_hfsc_policy[] = {
3091         [TCA_HFSC_RSC] = {
3092             .type      = NL_A_UNSPEC,
3093             .optional  = false,
3094             .min_len   = sizeof(struct tc_service_curve),
3095         },
3096         [TCA_HFSC_FSC] = {
3097             .type      = NL_A_UNSPEC,
3098             .optional  = false,
3099             .min_len   = sizeof(struct tc_service_curve),
3100         },
3101         [TCA_HFSC_USC] = {
3102             .type      = NL_A_UNSPEC,
3103             .optional  = false,
3104             .min_len   = sizeof(struct tc_service_curve),
3105         },
3106     };
3107     struct nlattr *attrs[ARRAY_SIZE(tca_hfsc_policy)];
3108
3109     if (!nl_parse_nested(nl_options, tca_hfsc_policy,
3110                          attrs, ARRAY_SIZE(tca_hfsc_policy))) {
3111         VLOG_WARN_RL(&rl, "failed to parse HFSC class options");
3112         return EPROTO;
3113     }
3114
3115     rsc = nl_attr_get(attrs[TCA_HFSC_RSC]);
3116     fsc = nl_attr_get(attrs[TCA_HFSC_FSC]);
3117     usc = nl_attr_get(attrs[TCA_HFSC_USC]);
3118
3119     if (rsc->m1 != 0 || rsc->d != 0 ||
3120         fsc->m1 != 0 || fsc->d != 0 ||
3121         usc->m1 != 0 || usc->d != 0) {
3122         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3123                      "Non-linear service curves are not supported.");
3124         return EPROTO;
3125     }
3126
3127     if (rsc->m2 != fsc->m2) {
3128         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3129                      "Real-time service curves are not supported ");
3130         return EPROTO;
3131     }
3132
3133     if (rsc->m2 > usc->m2) {
3134         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3135                      "Min-rate service curve is greater than "
3136                      "the max-rate service curve.");
3137         return EPROTO;
3138     }
3139
3140     class->min_rate = fsc->m2;
3141     class->max_rate = usc->m2;
3142     return 0;
3143 }
3144
3145 static int
3146 hfsc_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
3147                    struct hfsc_class *options,
3148                    struct netdev_queue_stats *stats)
3149 {
3150     int error;
3151     unsigned int handle;
3152     struct nlattr *nl_options;
3153
3154     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
3155     if (error) {
3156         return error;
3157     }
3158
3159     if (queue_id) {
3160         unsigned int major, minor;
3161
3162         major = tc_get_major(handle);
3163         minor = tc_get_minor(handle);
3164         if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3165             *queue_id = minor - 1;
3166         } else {
3167             return EPROTO;
3168         }
3169     }
3170
3171     if (options) {
3172         error = hfsc_parse_tca_options__(nl_options, options);
3173     }
3174
3175     return error;
3176 }
3177
3178 static int
3179 hfsc_query_class__(const struct netdev *netdev, unsigned int handle,
3180                    unsigned int parent, struct hfsc_class *options,
3181                    struct netdev_queue_stats *stats)
3182 {
3183     int error;
3184     struct ofpbuf *reply;
3185
3186     error = tc_query_class(netdev, handle, parent, &reply);
3187     if (error) {
3188         return error;
3189     }
3190
3191     error = hfsc_parse_tcmsg__(reply, NULL, options, stats);
3192     ofpbuf_delete(reply);
3193     return error;
3194 }
3195
3196 static void
3197 hfsc_parse_qdisc_details__(struct netdev *netdev, const struct shash *details,
3198                            struct hfsc_class *class)
3199 {
3200     uint32_t max_rate;
3201     const char *max_rate_s;
3202
3203     max_rate_s = shash_find_data(details, "max-rate");
3204     max_rate   = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
3205
3206     if (!max_rate) {
3207         enum netdev_features current;
3208
3209         netdev_get_features(netdev, &current, NULL, NULL, NULL);
3210         max_rate = netdev_features_to_bps(current) / 8;
3211     }
3212
3213     class->min_rate = max_rate;
3214     class->max_rate = max_rate;
3215 }
3216
3217 static int
3218 hfsc_parse_class_details__(struct netdev *netdev,
3219                            const struct shash *details,
3220                            struct hfsc_class * class)
3221 {
3222     const struct hfsc *hfsc;
3223     uint32_t min_rate, max_rate;
3224     const char *min_rate_s, *max_rate_s;
3225
3226     hfsc       = hfsc_get__(netdev);
3227     min_rate_s = shash_find_data(details, "min-rate");
3228     max_rate_s = shash_find_data(details, "max-rate");
3229
3230     min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
3231     min_rate = MAX(min_rate, 1);
3232     min_rate = MIN(min_rate, hfsc->max_rate);
3233
3234     max_rate = (max_rate_s
3235                 ? strtoull(max_rate_s, NULL, 10) / 8
3236                 : hfsc->max_rate);
3237     max_rate = MAX(max_rate, min_rate);
3238     max_rate = MIN(max_rate, hfsc->max_rate);
3239
3240     class->min_rate = min_rate;
3241     class->max_rate = max_rate;
3242
3243     return 0;
3244 }
3245
3246 /* Create an HFSC qdisc.
3247  *
3248  * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
3249 static int
3250 hfsc_setup_qdisc__(struct netdev * netdev)
3251 {
3252     struct tcmsg *tcmsg;
3253     struct ofpbuf request;
3254     struct tc_hfsc_qopt opt;
3255
3256     tc_del_qdisc(netdev);
3257
3258     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
3259                             NLM_F_EXCL | NLM_F_CREATE, &request);
3260
3261     if (!tcmsg) {
3262         return ENODEV;
3263     }
3264
3265     tcmsg->tcm_handle = tc_make_handle(1, 0);
3266     tcmsg->tcm_parent = TC_H_ROOT;
3267
3268     memset(&opt, 0, sizeof opt);
3269     opt.defcls = 1;
3270
3271     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3272     nl_msg_put_unspec(&request, TCA_OPTIONS, &opt, sizeof opt);
3273
3274     return tc_transact(&request, NULL);
3275 }
3276
3277 /* Create an HFSC class.
3278  *
3279  * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
3280  * sc rate <min_rate> ul rate <max_rate>" */
3281 static int
3282 hfsc_setup_class__(struct netdev *netdev, unsigned int handle,
3283                    unsigned int parent, struct hfsc_class *class)
3284 {
3285     int error;
3286     size_t opt_offset;
3287     struct tcmsg *tcmsg;
3288     struct ofpbuf request;
3289     struct tc_service_curve min, max;
3290
3291     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
3292
3293     if (!tcmsg) {
3294         return ENODEV;
3295     }
3296
3297     tcmsg->tcm_handle = handle;
3298     tcmsg->tcm_parent = parent;
3299
3300     min.m1 = 0;
3301     min.d  = 0;
3302     min.m2 = class->min_rate;
3303
3304     max.m1 = 0;
3305     max.d  = 0;
3306     max.m2 = class->max_rate;
3307
3308     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3309     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3310     nl_msg_put_unspec(&request, TCA_HFSC_RSC, &min, sizeof min);
3311     nl_msg_put_unspec(&request, TCA_HFSC_FSC, &min, sizeof min);
3312     nl_msg_put_unspec(&request, TCA_HFSC_USC, &max, sizeof max);
3313     nl_msg_end_nested(&request, opt_offset);
3314
3315     error = tc_transact(&request, NULL);
3316     if (error) {
3317         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
3318                      "min-rate %ubps, max-rate %ubps (%s)",
3319                      netdev_get_name(netdev),
3320                      tc_get_major(handle), tc_get_minor(handle),
3321                      tc_get_major(parent), tc_get_minor(parent),
3322                      class->min_rate, class->max_rate, strerror(error));
3323     }
3324
3325     return error;
3326 }
3327
3328 static int
3329 hfsc_tc_install(struct netdev *netdev, const struct shash *details)
3330 {
3331     int error;
3332     struct hfsc_class class;
3333
3334     error = hfsc_setup_qdisc__(netdev);
3335
3336     if (error) {
3337         return error;
3338     }
3339
3340     hfsc_parse_qdisc_details__(netdev, details, &class);
3341     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3342                                tc_make_handle(1, 0), &class);
3343
3344     if (error) {
3345         return error;
3346     }
3347
3348     hfsc_install__(netdev, class.max_rate);
3349     return 0;
3350 }
3351
3352 static int
3353 hfsc_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3354 {
3355     struct ofpbuf msg;
3356     struct nl_dump dump;
3357     struct hfsc_class hc;
3358
3359     hc.max_rate = 0;
3360     hfsc_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
3361     hfsc_install__(netdev, hc.max_rate);
3362
3363     if (!start_queue_dump(netdev, &dump)) {
3364         return ENODEV;
3365     }
3366
3367     while (nl_dump_next(&dump, &msg)) {
3368         unsigned int queue_id;
3369
3370         if (!hfsc_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
3371             hfsc_update_queue__(netdev, queue_id, &hc);
3372         }
3373     }
3374
3375     nl_dump_done(&dump);
3376     return 0;
3377 }
3378
3379 static void
3380 hfsc_tc_destroy(struct tc *tc)
3381 {
3382     struct hfsc *hfsc;
3383     struct hfsc_class *hc, *next;
3384
3385     hfsc = CONTAINER_OF(tc, struct hfsc, tc);
3386
3387     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &hfsc->tc.queues) {
3388         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3389         free(hc);
3390     }
3391
3392     tc_destroy(tc);
3393     free(hfsc);
3394 }
3395
3396 static int
3397 hfsc_qdisc_get(const struct netdev *netdev, struct shash *details)
3398 {
3399     const struct hfsc *hfsc;
3400     hfsc = hfsc_get__(netdev);
3401     shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hfsc->max_rate));
3402     return 0;
3403 }
3404
3405 static int
3406 hfsc_qdisc_set(struct netdev *netdev, const struct shash *details)
3407 {
3408     int error;
3409     struct hfsc_class class;
3410
3411     hfsc_parse_qdisc_details__(netdev, details, &class);
3412     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3413                                tc_make_handle(1, 0), &class);
3414
3415     if (!error) {
3416         hfsc_get__(netdev)->max_rate = class.max_rate;
3417     }
3418
3419     return error;
3420 }
3421
3422 static int
3423 hfsc_class_get(const struct netdev *netdev OVS_UNUSED,
3424               const struct tc_queue *queue, struct shash *details)
3425 {
3426     const struct hfsc_class *hc;
3427
3428     hc = hfsc_class_cast__(queue);
3429     shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
3430     if (hc->min_rate != hc->max_rate) {
3431         shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
3432     }
3433     return 0;
3434 }
3435
3436 static int
3437 hfsc_class_set(struct netdev *netdev, unsigned int queue_id,
3438                const struct shash *details)
3439 {
3440     int error;
3441     struct hfsc_class class;
3442
3443     error = hfsc_parse_class_details__(netdev, details, &class);
3444     if (error) {
3445         return error;
3446     }
3447
3448     error = hfsc_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3449                                tc_make_handle(1, 0xfffe), &class);
3450     if (error) {
3451         return error;
3452     }
3453
3454     hfsc_update_queue__(netdev, queue_id, &class);
3455     return 0;
3456 }
3457
3458 static int
3459 hfsc_class_delete(struct netdev *netdev, struct tc_queue *queue)
3460 {
3461     int error;
3462     struct hfsc *hfsc;
3463     struct hfsc_class *hc;
3464
3465     hc   = hfsc_class_cast__(queue);
3466     hfsc = hfsc_get__(netdev);
3467
3468     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3469     if (!error) {
3470         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3471         free(hc);
3472     }
3473     return error;
3474 }
3475
3476 static int
3477 hfsc_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3478                      struct netdev_queue_stats *stats)
3479 {
3480     return hfsc_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3481                              tc_make_handle(1, 0xfffe), NULL, stats);
3482 }
3483
3484 static int
3485 hfsc_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3486                       const struct ofpbuf *nlmsg,
3487                       netdev_dump_queue_stats_cb *cb, void *aux)
3488 {
3489     struct netdev_queue_stats stats;
3490     unsigned int handle, major, minor;
3491     int error;
3492
3493     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3494     if (error) {
3495         return error;
3496     }
3497
3498     major = tc_get_major(handle);
3499     minor = tc_get_minor(handle);
3500     if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3501         (*cb)(minor - 1, &stats, aux);
3502     }
3503     return 0;
3504 }
3505
3506 static const struct tc_ops tc_ops_hfsc = {
3507     "hfsc",                     /* linux_name */
3508     "linux-hfsc",               /* ovs_name */
3509     HFSC_N_QUEUES,              /* n_queues */
3510     hfsc_tc_install,            /* tc_install */
3511     hfsc_tc_load,               /* tc_load */
3512     hfsc_tc_destroy,            /* tc_destroy */
3513     hfsc_qdisc_get,             /* qdisc_get */
3514     hfsc_qdisc_set,             /* qdisc_set */
3515     hfsc_class_get,             /* class_get */
3516     hfsc_class_set,             /* class_set */
3517     hfsc_class_delete,          /* class_delete */
3518     hfsc_class_get_stats,       /* class_get_stats */
3519     hfsc_class_dump_stats       /* class_dump_stats */
3520 };
3521 \f
3522 /* "linux-default" traffic control class.
3523  *
3524  * This class represents the default, unnamed Linux qdisc.  It corresponds to
3525  * the "" (empty string) QoS type in the OVS database. */
3526
3527 static void
3528 default_install__(struct netdev *netdev)
3529 {
3530     struct netdev_dev_linux *netdev_dev =
3531                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
3532     static struct tc *tc;
3533
3534     if (!tc) {
3535         tc = xmalloc(sizeof *tc);
3536         tc_init(tc, &tc_ops_default);
3537     }
3538     netdev_dev->tc = tc;
3539 }
3540
3541 static int
3542 default_tc_install(struct netdev *netdev,
3543                    const struct shash *details OVS_UNUSED)
3544 {
3545     default_install__(netdev);
3546     return 0;
3547 }
3548
3549 static int
3550 default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3551 {
3552     default_install__(netdev);
3553     return 0;
3554 }
3555
3556 static const struct tc_ops tc_ops_default = {
3557     NULL,                       /* linux_name */
3558     "",                         /* ovs_name */
3559     0,                          /* n_queues */
3560     default_tc_install,
3561     default_tc_load,
3562     NULL,                       /* tc_destroy */
3563     NULL,                       /* qdisc_get */
3564     NULL,                       /* qdisc_set */
3565     NULL,                       /* class_get */
3566     NULL,                       /* class_set */
3567     NULL,                       /* class_delete */
3568     NULL,                       /* class_get_stats */
3569     NULL                        /* class_dump_stats */
3570 };
3571 \f
3572 /* "linux-other" traffic control class.
3573  *
3574  * */
3575
3576 static int
3577 other_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3578 {
3579     struct netdev_dev_linux *netdev_dev =
3580                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
3581     static struct tc *tc;
3582
3583     if (!tc) {
3584         tc = xmalloc(sizeof *tc);
3585         tc_init(tc, &tc_ops_other);
3586     }
3587     netdev_dev->tc = tc;
3588     return 0;
3589 }
3590
3591 static const struct tc_ops tc_ops_other = {
3592     NULL,                       /* linux_name */
3593     "linux-other",              /* ovs_name */
3594     0,                          /* n_queues */
3595     NULL,                       /* tc_install */
3596     other_tc_load,
3597     NULL,                       /* tc_destroy */
3598     NULL,                       /* qdisc_get */
3599     NULL,                       /* qdisc_set */
3600     NULL,                       /* class_get */
3601     NULL,                       /* class_set */
3602     NULL,                       /* class_delete */
3603     NULL,                       /* class_get_stats */
3604     NULL                        /* class_dump_stats */
3605 };
3606 \f
3607 /* Traffic control. */
3608
3609 /* Number of kernel "tc" ticks per second. */
3610 static double ticks_per_s;
3611
3612 /* Number of kernel "jiffies" per second.  This is used for the purpose of
3613  * computing buffer sizes.  Generally kernel qdiscs need to be able to buffer
3614  * one jiffy's worth of data.
3615  *
3616  * There are two possibilities here:
3617  *
3618  *    - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3619  *      approximate range of 100 to 1024.  That means that we really need to
3620  *      make sure that the qdisc can buffer that much data.
3621  *
3622  *    - 'buffer_hz' is an absurdly large number.  That means that the kernel
3623  *      has finely granular timers and there's no need to fudge additional room
3624  *      for buffers.  (There's no extra effort needed to implement that: the
3625  *      large 'buffer_hz' is used as a divisor, so practically any number will
3626  *      come out as 0 in the division.  Small integer results in the case of
3627  *      really high dividends won't have any real effect anyhow.)
3628  */
3629 static unsigned int buffer_hz;
3630
3631 /* Returns tc handle 'major':'minor'. */
3632 static unsigned int
3633 tc_make_handle(unsigned int major, unsigned int minor)
3634 {
3635     return TC_H_MAKE(major << 16, minor);
3636 }
3637
3638 /* Returns the major number from 'handle'. */
3639 static unsigned int
3640 tc_get_major(unsigned int handle)
3641 {
3642     return TC_H_MAJ(handle) >> 16;
3643 }
3644
3645 /* Returns the minor number from 'handle'. */
3646 static unsigned int
3647 tc_get_minor(unsigned int handle)
3648 {
3649     return TC_H_MIN(handle);
3650 }
3651
3652 static struct tcmsg *
3653 tc_make_request(const struct netdev *netdev, int type, unsigned int flags,
3654                 struct ofpbuf *request)
3655 {
3656     struct tcmsg *tcmsg;
3657     int ifindex;
3658     int error;
3659
3660     error = get_ifindex(netdev, &ifindex);
3661     if (error) {
3662         return NULL;
3663     }
3664
3665     ofpbuf_init(request, 512);
3666     nl_msg_put_nlmsghdr(request, sizeof *tcmsg, type, NLM_F_REQUEST | flags);
3667     tcmsg = ofpbuf_put_zeros(request, sizeof *tcmsg);
3668     tcmsg->tcm_family = AF_UNSPEC;
3669     tcmsg->tcm_ifindex = ifindex;
3670     /* Caller should fill in tcmsg->tcm_handle. */
3671     /* Caller should fill in tcmsg->tcm_parent. */
3672
3673     return tcmsg;
3674 }
3675
3676 static int
3677 tc_transact(struct ofpbuf *request, struct ofpbuf **replyp)
3678 {
3679     int error = nl_sock_transact(rtnl_sock, request, replyp);
3680     ofpbuf_uninit(request);
3681     return error;
3682 }
3683
3684 /* Adds or deletes a root ingress qdisc on 'netdev'.  We use this for
3685  * policing configuration.
3686  *
3687  * This function is equivalent to running the following when 'add' is true:
3688  *     /sbin/tc qdisc add dev <devname> handle ffff: ingress
3689  *
3690  * This function is equivalent to running the following when 'add' is false:
3691  *     /sbin/tc qdisc del dev <devname> handle ffff: ingress
3692  *
3693  * The configuration and stats may be seen with the following command:
3694  *     /sbin/tc -s qdisc show dev <devname>
3695  *
3696  * Returns 0 if successful, otherwise a positive errno value.
3697  */
3698 static int
3699 tc_add_del_ingress_qdisc(struct netdev *netdev, bool add)
3700 {
3701     struct ofpbuf request;
3702     struct tcmsg *tcmsg;
3703     int error;
3704     int type = add ? RTM_NEWQDISC : RTM_DELQDISC;
3705     int flags = add ? NLM_F_EXCL | NLM_F_CREATE : 0;
3706
3707     tcmsg = tc_make_request(netdev, type, flags, &request);
3708     if (!tcmsg) {
3709         return ENODEV;
3710     }
3711     tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
3712     tcmsg->tcm_parent = TC_H_INGRESS;
3713     nl_msg_put_string(&request, TCA_KIND, "ingress");
3714     nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
3715
3716     error = tc_transact(&request, NULL);
3717     if (error) {
3718         /* If we're deleting the qdisc, don't worry about some of the
3719          * error conditions. */
3720         if (!add && (error == ENOENT || error == EINVAL)) {
3721             return 0;
3722         }
3723         return error;
3724     }
3725
3726     return 0;
3727 }
3728
3729 /* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
3730  * of 'kbits_burst'.
3731  *
3732  * This function is equivalent to running:
3733  *     /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
3734  *              basic police rate <kbits_rate>kbit burst <kbits_burst>k
3735  *              mtu 65535 drop
3736  *
3737  * The configuration and stats may be seen with the following command:
3738  *     /sbin/tc -s filter show <devname> eth0 parent ffff:
3739  *
3740  * Returns 0 if successful, otherwise a positive errno value.
3741  */
3742 static int
3743 tc_add_policer(struct netdev *netdev, int kbits_rate, int kbits_burst)
3744 {
3745     struct tc_police tc_police;
3746     struct ofpbuf request;
3747     struct tcmsg *tcmsg;
3748     size_t basic_offset;
3749     size_t police_offset;
3750     int error;
3751     int mtu = 65535;
3752
3753     memset(&tc_police, 0, sizeof tc_police);
3754     tc_police.action = TC_POLICE_SHOT;
3755     tc_police.mtu = mtu;
3756     tc_fill_rate(&tc_police.rate, kbits_rate/8 * 1000, mtu);
3757     tc_police.burst = tc_bytes_to_ticks(tc_police.rate.rate,
3758                                         kbits_burst * 1024);
3759
3760     tcmsg = tc_make_request(netdev, RTM_NEWTFILTER,
3761                             NLM_F_EXCL | NLM_F_CREATE, &request);
3762     if (!tcmsg) {
3763         return ENODEV;
3764     }
3765     tcmsg->tcm_parent = tc_make_handle(0xffff, 0);
3766     tcmsg->tcm_info = tc_make_handle(49,
3767                                      (OVS_FORCE uint16_t) htons(ETH_P_ALL));
3768
3769     nl_msg_put_string(&request, TCA_KIND, "basic");
3770     basic_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3771     police_offset = nl_msg_start_nested(&request, TCA_BASIC_POLICE);
3772     nl_msg_put_unspec(&request, TCA_POLICE_TBF, &tc_police, sizeof tc_police);
3773     tc_put_rtab(&request, TCA_POLICE_RATE, &tc_police.rate);
3774     nl_msg_end_nested(&request, police_offset);
3775     nl_msg_end_nested(&request, basic_offset);
3776
3777     error = tc_transact(&request, NULL);
3778     if (error) {
3779         return error;
3780     }
3781
3782     return 0;
3783 }
3784
3785 static void
3786 read_psched(void)
3787 {
3788     /* The values in psched are not individually very meaningful, but they are
3789      * important.  The tables below show some values seen in the wild.
3790      *
3791      * Some notes:
3792      *
3793      *   - "c" has always been a constant 1000000 since at least Linux 2.4.14.
3794      *     (Before that, there are hints that it was 1000000000.)
3795      *
3796      *   - "d" can be unrealistically large, see the comment on 'buffer_hz'
3797      *     above.
3798      *
3799      *                        /proc/net/psched
3800      *     -----------------------------------
3801      * [1] 000c8000 000f4240 000f4240 00000064
3802      * [2] 000003e8 00000400 000f4240 3b9aca00
3803      * [3] 000003e8 00000400 000f4240 3b9aca00
3804      * [4] 000003e8 00000400 000f4240 00000064
3805      * [5] 000003e8 00000040 000f4240 3b9aca00
3806      * [6] 000003e8 00000040 000f4240 000000f9
3807      *
3808      *           a         b          c             d ticks_per_s     buffer_hz
3809      *     ------- --------- ---------- ------------- ----------- -------------
3810      * [1] 819,200 1,000,000  1,000,000           100     819,200           100
3811      * [2]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3812      * [3]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3813      * [4]   1,000     1,024  1,000,000           100     976,562           100
3814      * [5]   1,000        64  1,000,000 1,000,000,000  15,625,000 1,000,000,000
3815      * [6]   1,000        64  1,000,000           249  15,625,000           249
3816      *
3817      * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
3818      * [2] 2.6.26-1-686-bigmem from Debian lenny
3819      * [3] 2.6.26-2-sparc64 from Debian lenny
3820      * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
3821      * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
3822      * [6] 2.6.34 from kernel.org on KVM
3823      */
3824     static const char fn[] = "/proc/net/psched";
3825     unsigned int a, b, c, d;
3826     FILE *stream;
3827
3828     ticks_per_s = 1.0;
3829     buffer_hz = 100;
3830
3831     stream = fopen(fn, "r");
3832     if (!stream) {
3833         VLOG_WARN("%s: open failed: %s", fn, strerror(errno));
3834         return;
3835     }
3836
3837     if (fscanf(stream, "%x %x %x %x", &a, &b, &c, &d) != 4) {
3838         VLOG_WARN("%s: read failed", fn);
3839         fclose(stream);
3840         return;
3841     }
3842     VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn, a, b, c, d);
3843     fclose(stream);
3844
3845     if (!a || !c) {
3846         VLOG_WARN("%s: invalid scheduler parameters", fn);
3847         return;
3848     }
3849
3850     ticks_per_s = (double) a * c / b;
3851     if (c == 1000000) {
3852         buffer_hz = d;
3853     } else {
3854         VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
3855                   fn, a, b, c, d);
3856     }
3857     VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn, ticks_per_s, buffer_hz);
3858 }
3859
3860 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
3861  * rate of 'rate' bytes per second. */
3862 static unsigned int
3863 tc_ticks_to_bytes(unsigned int rate, unsigned int ticks)
3864 {
3865     if (!buffer_hz) {
3866         read_psched();
3867     }
3868     return (rate * ticks) / ticks_per_s;
3869 }
3870
3871 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
3872  * rate of 'rate' bytes per second. */
3873 static unsigned int
3874 tc_bytes_to_ticks(unsigned int rate, unsigned int size)
3875 {
3876     if (!buffer_hz) {
3877         read_psched();
3878     }
3879     return rate ? ((unsigned long long int) ticks_per_s * size) / rate : 0;
3880 }
3881
3882 /* Returns the number of bytes that need to be reserved for qdisc buffering at
3883  * a transmission rate of 'rate' bytes per second. */
3884 static unsigned int
3885 tc_buffer_per_jiffy(unsigned int rate)
3886 {
3887     if (!buffer_hz) {
3888         read_psched();
3889     }
3890     return rate / buffer_hz;
3891 }
3892
3893 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
3894  * e.g. "htb", into '*kind' (if it is nonnull).  If 'options' is nonnull,
3895  * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
3896  * stores NULL into it if it is absent.
3897  *
3898  * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
3899  * 'msg'.
3900  *
3901  * Returns 0 if successful, otherwise a positive errno value. */
3902 static int
3903 tc_parse_qdisc(const struct ofpbuf *msg, const char **kind,
3904                struct nlattr **options)
3905 {
3906     static const struct nl_policy tca_policy[] = {
3907         [TCA_KIND] = { .type = NL_A_STRING, .optional = false },
3908         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
3909     };
3910     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3911
3912     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3913                          tca_policy, ta, ARRAY_SIZE(ta))) {
3914         VLOG_WARN_RL(&rl, "failed to parse qdisc message");
3915         goto error;
3916     }
3917
3918     if (kind) {
3919         *kind = nl_attr_get_string(ta[TCA_KIND]);
3920     }
3921
3922     if (options) {
3923         *options = ta[TCA_OPTIONS];
3924     }
3925
3926     return 0;
3927
3928 error:
3929     if (kind) {
3930         *kind = NULL;
3931     }
3932     if (options) {
3933         *options = NULL;
3934     }
3935     return EPROTO;
3936 }
3937
3938 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
3939  * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
3940  * into '*options', and its queue statistics into '*stats'.  Any of the output
3941  * arguments may be null.
3942  *
3943  * Returns 0 if successful, otherwise a positive errno value. */
3944 static int
3945 tc_parse_class(const struct ofpbuf *msg, unsigned int *handlep,
3946                struct nlattr **options, struct netdev_queue_stats *stats)
3947 {
3948     static const struct nl_policy tca_policy[] = {
3949         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = false },
3950         [TCA_STATS2] = { .type = NL_A_NESTED, .optional = false },
3951     };
3952     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3953
3954     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3955                          tca_policy, ta, ARRAY_SIZE(ta))) {
3956         VLOG_WARN_RL(&rl, "failed to parse class message");
3957         goto error;
3958     }
3959
3960     if (handlep) {
3961         struct tcmsg *tc = ofpbuf_at_assert(msg, NLMSG_HDRLEN, sizeof *tc);
3962         *handlep = tc->tcm_handle;
3963     }
3964
3965     if (options) {
3966         *options = ta[TCA_OPTIONS];
3967     }
3968
3969     if (stats) {
3970         const struct gnet_stats_queue *gsq;
3971         struct gnet_stats_basic gsb;
3972
3973         static const struct nl_policy stats_policy[] = {
3974             [TCA_STATS_BASIC] = { .type = NL_A_UNSPEC, .optional = false,
3975                                   .min_len = sizeof gsb },
3976             [TCA_STATS_QUEUE] = { .type = NL_A_UNSPEC, .optional = false,
3977                                   .min_len = sizeof *gsq },
3978         };
3979         struct nlattr *sa[ARRAY_SIZE(stats_policy)];
3980
3981         if (!nl_parse_nested(ta[TCA_STATS2], stats_policy,
3982                              sa, ARRAY_SIZE(sa))) {
3983             VLOG_WARN_RL(&rl, "failed to parse class stats");
3984             goto error;
3985         }
3986
3987         /* Alignment issues screw up the length of struct gnet_stats_basic on
3988          * some arch/bitsize combinations.  Newer versions of Linux have a
3989          * struct gnet_stats_basic_packed, but we can't depend on that.  The
3990          * easiest thing to do is just to make a copy. */
3991         memset(&gsb, 0, sizeof gsb);
3992         memcpy(&gsb, nl_attr_get(sa[TCA_STATS_BASIC]),
3993                MIN(nl_attr_get_size(sa[TCA_STATS_BASIC]), sizeof gsb));
3994         stats->tx_bytes = gsb.bytes;
3995         stats->tx_packets = gsb.packets;
3996
3997         gsq = nl_attr_get(sa[TCA_STATS_QUEUE]);
3998         stats->tx_errors = gsq->drops;
3999     }
4000
4001     return 0;
4002
4003 error:
4004     if (options) {
4005         *options = NULL;
4006     }
4007     if (stats) {
4008         memset(stats, 0, sizeof *stats);
4009     }
4010     return EPROTO;
4011 }
4012
4013 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
4014  * on 'netdev'. */
4015 static int
4016 tc_query_class(const struct netdev *netdev,
4017                unsigned int handle, unsigned int parent,
4018                struct ofpbuf **replyp)
4019 {
4020     struct ofpbuf request;
4021     struct tcmsg *tcmsg;
4022     int error;
4023
4024     tcmsg = tc_make_request(netdev, RTM_GETTCLASS, NLM_F_ECHO, &request);
4025     if (!tcmsg) {
4026         return ENODEV;
4027     }
4028     tcmsg->tcm_handle = handle;
4029     tcmsg->tcm_parent = parent;
4030
4031     error = tc_transact(&request, replyp);
4032     if (error) {
4033         VLOG_WARN_RL(&rl, "query %s class %u:%u (parent %u:%u) failed (%s)",
4034                      netdev_get_name(netdev),
4035                      tc_get_major(handle), tc_get_minor(handle),
4036                      tc_get_major(parent), tc_get_minor(parent),
4037                      strerror(error));
4038     }
4039     return error;
4040 }
4041
4042 /* Equivalent to "tc class del dev <name> handle <handle>". */
4043 static int
4044 tc_delete_class(const struct netdev *netdev, unsigned int handle)
4045 {
4046     struct ofpbuf request;
4047     struct tcmsg *tcmsg;
4048     int error;
4049
4050     tcmsg = tc_make_request(netdev, RTM_DELTCLASS, 0, &request);
4051     if (!tcmsg) {
4052         return ENODEV;
4053     }
4054     tcmsg->tcm_handle = handle;
4055     tcmsg->tcm_parent = 0;
4056
4057     error = tc_transact(&request, NULL);
4058     if (error) {
4059         VLOG_WARN_RL(&rl, "delete %s class %u:%u failed (%s)",
4060                      netdev_get_name(netdev),
4061                      tc_get_major(handle), tc_get_minor(handle),
4062                      strerror(error));
4063     }
4064     return error;
4065 }
4066
4067 /* Equivalent to "tc qdisc del dev <name> root". */
4068 static int
4069 tc_del_qdisc(struct netdev *netdev)
4070 {
4071     struct netdev_dev_linux *netdev_dev =
4072                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
4073     struct ofpbuf request;
4074     struct tcmsg *tcmsg;
4075     int error;
4076
4077     tcmsg = tc_make_request(netdev, RTM_DELQDISC, 0, &request);
4078     if (!tcmsg) {
4079         return ENODEV;
4080     }
4081     tcmsg->tcm_handle = tc_make_handle(1, 0);
4082     tcmsg->tcm_parent = TC_H_ROOT;
4083
4084     error = tc_transact(&request, NULL);
4085     if (error == EINVAL) {
4086         /* EINVAL probably means that the default qdisc was in use, in which
4087          * case we've accomplished our purpose. */
4088         error = 0;
4089     }
4090     if (!error && netdev_dev->tc) {
4091         if (netdev_dev->tc->ops->tc_destroy) {
4092             netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
4093         }
4094         netdev_dev->tc = NULL;
4095     }
4096     return error;
4097 }
4098
4099 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
4100  * kernel to determine what they are.  Returns 0 if successful, otherwise a
4101  * positive errno value. */
4102 static int
4103 tc_query_qdisc(const struct netdev *netdev)
4104 {
4105     struct netdev_dev_linux *netdev_dev =
4106                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
4107     struct ofpbuf request, *qdisc;
4108     const struct tc_ops *ops;
4109     struct tcmsg *tcmsg;
4110     int load_error;
4111     int error;
4112
4113     if (netdev_dev->tc) {
4114         return 0;
4115     }
4116
4117     /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
4118      * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
4119      * 2.6.35 without that fix backported to it.
4120      *
4121      * To avoid the OOPS, we must not make a request that would attempt to dump
4122      * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
4123      * few others.  There are a few ways that I can see to do this, but most of
4124      * them seem to be racy (and if you lose the race the kernel OOPSes).  The
4125      * technique chosen here is to assume that any non-default qdisc that we
4126      * create will have a class with handle 1:0.  The built-in qdiscs only have
4127      * a class with handle 0:0.
4128      *
4129      * We could check for Linux 2.6.35+ and use a more straightforward method
4130      * there. */
4131     tcmsg = tc_make_request(netdev, RTM_GETQDISC, NLM_F_ECHO, &request);
4132     if (!tcmsg) {
4133         return ENODEV;
4134     }
4135     tcmsg->tcm_handle = tc_make_handle(1, 0);
4136     tcmsg->tcm_parent = 0;
4137
4138     /* Figure out what tc class to instantiate. */
4139     error = tc_transact(&request, &qdisc);
4140     if (!error) {
4141         const char *kind;
4142
4143         error = tc_parse_qdisc(qdisc, &kind, NULL);
4144         if (error) {
4145             ops = &tc_ops_other;
4146         } else {
4147             ops = tc_lookup_linux_name(kind);
4148             if (!ops) {
4149                 static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 1);
4150                 VLOG_INFO_RL(&rl2, "unknown qdisc \"%s\"", kind);
4151
4152                 ops = &tc_ops_other;
4153             }
4154         }
4155     } else if (error == ENOENT) {
4156         /* Either it's a built-in qdisc, or it's a qdisc set up by some
4157          * other entity that doesn't have a handle 1:0.  We will assume
4158          * that it's the system default qdisc. */
4159         ops = &tc_ops_default;
4160         error = 0;
4161     } else {
4162         /* Who knows?  Maybe the device got deleted. */
4163         VLOG_WARN_RL(&rl, "query %s qdisc failed (%s)",
4164                      netdev_get_name(netdev), strerror(error));
4165         ops = &tc_ops_other;
4166     }
4167
4168     /* Instantiate it. */
4169     load_error = ops->tc_load((struct netdev *) netdev, qdisc);
4170     assert((load_error == 0) == (netdev_dev->tc != NULL));
4171     ofpbuf_delete(qdisc);
4172
4173     return error ? error : load_error;
4174 }
4175
4176 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
4177    approximate the time to transmit packets of various lengths.  For an MTU of
4178    256 or less, each entry is exact; for an MTU of 257 through 512, each entry
4179    represents two possible packet lengths; for a MTU of 513 through 1024, four
4180    possible lengths; and so on.
4181
4182    Returns, for the specified 'mtu', the number of bits that packet lengths
4183    need to be shifted right to fit within such a 256-entry table. */
4184 static int
4185 tc_calc_cell_log(unsigned int mtu)
4186 {
4187     int cell_log;
4188
4189     if (!mtu) {
4190         mtu = ETH_PAYLOAD_MAX;
4191     }
4192     mtu += ETH_HEADER_LEN + VLAN_HEADER_LEN;
4193
4194     for (cell_log = 0; mtu >= 256; cell_log++) {
4195         mtu >>= 1;
4196     }
4197
4198     return cell_log;
4199 }
4200
4201 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
4202  * of 'mtu'. */
4203 static void
4204 tc_fill_rate(struct tc_ratespec *rate, uint64_t Bps, int mtu)
4205 {
4206     memset(rate, 0, sizeof *rate);
4207     rate->cell_log = tc_calc_cell_log(mtu);
4208     /* rate->overhead = 0; */           /* New in 2.6.24, not yet in some */
4209     /* rate->cell_align = 0; */         /* distro headers. */
4210     rate->mpu = ETH_TOTAL_MIN;
4211     rate->rate = Bps;
4212 }
4213
4214 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
4215  * attribute of the specified "type".
4216  *
4217  * See tc_calc_cell_log() above for a description of "rtab"s. */
4218 static void
4219 tc_put_rtab(struct ofpbuf *msg, uint16_t type, const struct tc_ratespec *rate)
4220 {
4221     uint32_t *rtab;
4222     unsigned int i;
4223
4224     rtab = nl_msg_put_unspec_uninit(msg, type, TC_RTAB_SIZE);
4225     for (i = 0; i < TC_RTAB_SIZE / sizeof *rtab; i++) {
4226         unsigned packet_size = (i + 1) << rate->cell_log;
4227         if (packet_size < rate->mpu) {
4228             packet_size = rate->mpu;
4229         }
4230         rtab[i] = tc_bytes_to_ticks(rate->rate, packet_size);
4231     }
4232 }
4233
4234 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
4235  * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
4236  * burst size of 'burst_bytes'.  (If no value was requested, a 'burst_bytes' of
4237  * 0 is fine.) */
4238 static int
4239 tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes)
4240 {
4241     unsigned int min_burst = tc_buffer_per_jiffy(Bps) + mtu;
4242     return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
4243 }
4244 \f
4245 /* Linux-only functions declared in netdev-linux.h  */
4246
4247 /* Returns a fd for an AF_INET socket or a negative errno value. */
4248 int
4249 netdev_linux_get_af_inet_sock(void)
4250 {
4251     int error = netdev_linux_init();
4252     return error ? -error : af_inet_sock;
4253 }
4254
4255 /* Modifies the 'flag' bit in ethtool's flags field for 'netdev'.  If
4256  * 'enable' is true, the bit is set.  Otherwise, it is cleared. */
4257 int
4258 netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag,
4259                               const char *flag_name, bool enable)
4260 {
4261     const char *netdev_name = netdev_get_name(netdev);
4262     struct ethtool_value evalue;
4263     uint32_t new_flags;
4264     int error;
4265
4266     memset(&evalue, 0, sizeof evalue);
4267     error = netdev_linux_do_ethtool(netdev_name,
4268                                     (struct ethtool_cmd *)&evalue,
4269                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4270     if (error) {
4271         return error;
4272     }
4273
4274     evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0);
4275     error = netdev_linux_do_ethtool(netdev_name,
4276                                     (struct ethtool_cmd *)&evalue,
4277                                     ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS");
4278     if (error) {
4279         return error;
4280     }
4281
4282     memset(&evalue, 0, sizeof evalue);
4283     error = netdev_linux_do_ethtool(netdev_name,
4284                                     (struct ethtool_cmd *)&evalue,
4285                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4286     if (error) {
4287         return error;
4288     }
4289
4290     if (new_flags != evalue.data) {
4291         VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network "
4292                      "device %s failed", enable ? "enable" : "disable",
4293                      flag_name, netdev_name);
4294         return EOPNOTSUPP;
4295     }
4296
4297     return 0;
4298 }
4299 \f
4300 /* Utility functions. */
4301
4302 /* Copies 'src' into 'dst', performing format conversion in the process. */
4303 static void
4304 netdev_stats_from_rtnl_link_stats(struct netdev_stats *dst,
4305                                   const struct rtnl_link_stats *src)
4306 {
4307     dst->rx_packets = src->rx_packets;
4308     dst->tx_packets = src->tx_packets;
4309     dst->rx_bytes = src->rx_bytes;
4310     dst->tx_bytes = src->tx_bytes;
4311     dst->rx_errors = src->rx_errors;
4312     dst->tx_errors = src->tx_errors;
4313     dst->rx_dropped = src->rx_dropped;
4314     dst->tx_dropped = src->tx_dropped;
4315     dst->multicast = src->multicast;
4316     dst->collisions = src->collisions;
4317     dst->rx_length_errors = src->rx_length_errors;
4318     dst->rx_over_errors = src->rx_over_errors;
4319     dst->rx_crc_errors = src->rx_crc_errors;
4320     dst->rx_frame_errors = src->rx_frame_errors;
4321     dst->rx_fifo_errors = src->rx_fifo_errors;
4322     dst->rx_missed_errors = src->rx_missed_errors;
4323     dst->tx_aborted_errors = src->tx_aborted_errors;
4324     dst->tx_carrier_errors = src->tx_carrier_errors;
4325     dst->tx_fifo_errors = src->tx_fifo_errors;
4326     dst->tx_heartbeat_errors = src->tx_heartbeat_errors;
4327     dst->tx_window_errors = src->tx_window_errors;
4328 }
4329
4330 static int
4331 get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
4332 {
4333     /* Policy for RTNLGRP_LINK messages.
4334      *
4335      * There are *many* more fields in these messages, but currently we only
4336      * care about these fields. */
4337     static const struct nl_policy rtnlgrp_link_policy[] = {
4338         [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
4339         [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
4340                          .min_len = sizeof(struct rtnl_link_stats) },
4341     };
4342
4343     struct ofpbuf request;
4344     struct ofpbuf *reply;
4345     struct ifinfomsg *ifi;
4346     struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
4347     int error;
4348
4349     ofpbuf_init(&request, 0);
4350     nl_msg_put_nlmsghdr(&request, sizeof *ifi, RTM_GETLINK, NLM_F_REQUEST);
4351     ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
4352     ifi->ifi_family = PF_UNSPEC;
4353     ifi->ifi_index = ifindex;
4354     error = nl_sock_transact(rtnl_sock, &request, &reply);
4355     ofpbuf_uninit(&request);
4356     if (error) {
4357         return error;
4358     }
4359
4360     if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
4361                          rtnlgrp_link_policy,
4362                          attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
4363         ofpbuf_delete(reply);
4364         return EPROTO;
4365     }
4366
4367     if (!attrs[IFLA_STATS]) {
4368         VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
4369         ofpbuf_delete(reply);
4370         return EPROTO;
4371     }
4372
4373     netdev_stats_from_rtnl_link_stats(stats, nl_attr_get(attrs[IFLA_STATS]));
4374
4375     ofpbuf_delete(reply);
4376
4377     return 0;
4378 }
4379
4380 static int
4381 get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
4382 {
4383     static const char fn[] = "/proc/net/dev";
4384     char line[1024];
4385     FILE *stream;
4386     int ln;
4387
4388     stream = fopen(fn, "r");
4389     if (!stream) {
4390         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
4391         return errno;
4392     }
4393
4394     ln = 0;
4395     while (fgets(line, sizeof line, stream)) {
4396         if (++ln >= 3) {
4397             char devname[16];
4398 #define X64 "%"SCNu64
4399             if (sscanf(line,
4400                        " %15[^:]:"
4401                        X64 X64 X64 X64 X64 X64 X64 "%*u"
4402                        X64 X64 X64 X64 X64 X64 X64 "%*u",
4403                        devname,
4404                        &stats->rx_bytes,
4405                        &stats->rx_packets,
4406                        &stats->rx_errors,
4407                        &stats->rx_dropped,
4408                        &stats->rx_fifo_errors,
4409                        &stats->rx_frame_errors,
4410                        &stats->multicast,
4411                        &stats->tx_bytes,
4412                        &stats->tx_packets,
4413                        &stats->tx_errors,
4414                        &stats->tx_dropped,
4415                        &stats->tx_fifo_errors,
4416                        &stats->collisions,
4417                        &stats->tx_carrier_errors) != 15) {
4418                 VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
4419             } else if (!strcmp(devname, netdev_name)) {
4420                 stats->rx_length_errors = UINT64_MAX;
4421                 stats->rx_over_errors = UINT64_MAX;
4422                 stats->rx_crc_errors = UINT64_MAX;
4423                 stats->rx_missed_errors = UINT64_MAX;
4424                 stats->tx_aborted_errors = UINT64_MAX;
4425                 stats->tx_heartbeat_errors = UINT64_MAX;
4426                 stats->tx_window_errors = UINT64_MAX;
4427                 fclose(stream);
4428                 return 0;
4429             }
4430         }
4431     }
4432     VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
4433     fclose(stream);
4434     return ENODEV;
4435 }
4436
4437 static int
4438 get_flags(const struct netdev_dev *dev, unsigned int *flags)
4439 {
4440     struct ifreq ifr;
4441     int error;
4442
4443     *flags = 0;
4444     error = netdev_linux_do_ioctl(dev->name, &ifr, SIOCGIFFLAGS,
4445                                   "SIOCGIFFLAGS");
4446     if (!error) {
4447         *flags = ifr.ifr_flags;
4448     }
4449     return error;
4450 }
4451
4452 static int
4453 set_flags(struct netdev *netdev, unsigned int flags)
4454 {
4455     struct ifreq ifr;
4456
4457     ifr.ifr_flags = flags;
4458     return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCSIFFLAGS,
4459                                  "SIOCSIFFLAGS");
4460 }
4461
4462 static int
4463 do_get_ifindex(const char *netdev_name)
4464 {
4465     struct ifreq ifr;
4466
4467     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4468     COVERAGE_INC(netdev_get_ifindex);
4469     if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
4470         VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
4471                      netdev_name, strerror(errno));
4472         return -errno;
4473     }
4474     return ifr.ifr_ifindex;
4475 }
4476
4477 static int
4478 get_ifindex(const struct netdev *netdev_, int *ifindexp)
4479 {
4480     struct netdev_dev_linux *netdev_dev =
4481                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
4482
4483     if (!(netdev_dev->cache_valid & VALID_IFINDEX)) {
4484         int ifindex = do_get_ifindex(netdev_get_name(netdev_));
4485
4486         if (ifindex < 0) {
4487             netdev_dev->get_ifindex_error = -ifindex;
4488             netdev_dev->ifindex = 0;
4489         } else {
4490             netdev_dev->get_ifindex_error = 0;
4491             netdev_dev->ifindex = ifindex;
4492         }
4493         netdev_dev->cache_valid |= VALID_IFINDEX;
4494     }
4495
4496     *ifindexp = netdev_dev->ifindex;
4497     return netdev_dev->get_ifindex_error;
4498 }
4499
4500 static int
4501 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
4502 {
4503     struct ifreq ifr;
4504     int hwaddr_family;
4505
4506     memset(&ifr, 0, sizeof ifr);
4507     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4508     COVERAGE_INC(netdev_get_hwaddr);
4509     if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
4510         /* ENODEV probably means that a vif disappeared asynchronously and
4511          * hasn't been removed from the database yet, so reduce the log level
4512          * to INFO for that case. */
4513         VLOG(errno == ENODEV ? VLL_INFO : VLL_ERR,
4514              "ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4515              netdev_name, strerror(errno));
4516         return errno;
4517     }
4518     hwaddr_family = ifr.ifr_hwaddr.sa_family;
4519     if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
4520         VLOG_WARN("%s device has unknown hardware address family %d",
4521                   netdev_name, hwaddr_family);
4522     }
4523     memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
4524     return 0;
4525 }
4526
4527 static int
4528 set_etheraddr(const char *netdev_name,
4529               const uint8_t mac[ETH_ADDR_LEN])
4530 {
4531     struct ifreq ifr;
4532
4533     memset(&ifr, 0, sizeof ifr);
4534     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4535     ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
4536     memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
4537     COVERAGE_INC(netdev_set_hwaddr);
4538     if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
4539         VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4540                  netdev_name, strerror(errno));
4541         return errno;
4542     }
4543     return 0;
4544 }
4545
4546 static int
4547 netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd,
4548                         int cmd, const char *cmd_name)
4549 {
4550     struct ifreq ifr;
4551
4552     memset(&ifr, 0, sizeof ifr);
4553     ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
4554     ifr.ifr_data = (caddr_t) ecmd;
4555
4556     ecmd->cmd = cmd;
4557     COVERAGE_INC(netdev_ethtool);
4558     if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) {
4559         return 0;
4560     } else {
4561         if (errno != EOPNOTSUPP) {
4562             VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
4563                          "failed: %s", cmd_name, name, strerror(errno));
4564         } else {
4565             /* The device doesn't support this operation.  That's pretty
4566              * common, so there's no point in logging anything. */
4567         }
4568         return errno;
4569     }
4570 }
4571
4572 static int
4573 netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd,
4574                       const char *cmd_name)
4575 {
4576     ovs_strzcpy(ifr->ifr_name, name, sizeof ifr->ifr_name);
4577     if (ioctl(af_inet_sock, cmd, ifr) == -1) {
4578         VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", name, cmd_name,
4579                      strerror(errno));
4580         return errno;
4581     }
4582     return 0;
4583 }
4584
4585 static int
4586 netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
4587                       int cmd, const char *cmd_name)
4588 {
4589     struct ifreq ifr;
4590     int error;
4591
4592     ifr.ifr_addr.sa_family = AF_INET;
4593     error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name);
4594     if (!error) {
4595         const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
4596         *ip = sin->sin_addr;
4597     }
4598     return error;
4599 }
4600
4601 /* Returns an AF_PACKET raw socket or a negative errno value. */
4602 static int
4603 af_packet_sock(void)
4604 {
4605     static int sock = INT_MIN;
4606
4607     if (sock == INT_MIN) {
4608         sock = socket(AF_PACKET, SOCK_RAW, 0);
4609         if (sock >= 0) {
4610             set_nonblocking(sock);
4611         } else {
4612             sock = -errno;
4613             VLOG_ERR("failed to create packet socket: %s", strerror(errno));
4614         }
4615     }
4616
4617     return sock;
4618 }