lib/netdev-linux.c

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