lib/netdev-linux.c

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