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