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     enum netdev_features current;    /* Cached from ETHTOOL_GSET. */
 387     enum netdev_features advertised; /* Cached from ETHTOOL_GSET. */
 388     enum netdev_features supported;  /* Cached from ETHTOOL_GSET. */
 389     enum netdev_features peer;       /* Cached from ETHTOOL_GSET. */
 390
 391     struct ethtool_drvinfo drvinfo;  /* Cached from ETHTOOL_GDRVINFO. */
 392     struct tc *tc;
 393
 394     union {
 395         struct tap_state tap;
 396     } state;
 397 };
 398
 399 struct netdev_linux {
 400     struct netdev netdev;
 401     int fd;
 402 };
 403
 404 /* Sockets used for ioctl operations. */
 405 static int af_inet_sock = -1;   /* AF_INET, SOCK_DGRAM. */
 406
 407 /* A Netlink routing socket that is not subscribed to any multicast groups. */
 408 static struct nl_sock *rtnl_sock;
 409
 410 /* This is set pretty low because we probably won't learn anything from the
 411  * additional log messages. */
 412 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
 413
 414 static int netdev_linux_init(void);
 415
 416 static int netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *,
 417                                    int cmd, const char *cmd_name);
 418 static int netdev_linux_do_ioctl(const char *name, struct ifreq *, int cmd,
 419                                  const char *cmd_name);
 420 static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
 421                                  int cmd, const char *cmd_name);
 422 static int get_flags(const struct netdev_dev *, unsigned int *flags);
 423 static int set_flags(struct netdev *, unsigned int flags);
 424 static int do_get_ifindex(const char *netdev_name);
 425 static int get_ifindex(const struct netdev *, int *ifindexp);
 426 static int do_set_addr(struct netdev *netdev,
 427                        int ioctl_nr, const char *ioctl_name,
 428                        struct in_addr addr);
 429 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
 430 static int set_etheraddr(const char *netdev_name, const uint8_t[ETH_ADDR_LEN]);
 431 static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats);
 432 static int get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats);
 433 static int af_packet_sock(void);
 434 static void netdev_linux_miimon_run(void);
 435 static void netdev_linux_miimon_wait(void);
 436
 437 static bool
 438 is_netdev_linux_class(const struct netdev_class *netdev_class)
 439 {
 440     return netdev_class->init == netdev_linux_init;
 441 }
 442
 443 static struct netdev_dev_linux *
 444 netdev_dev_linux_cast(const struct netdev_dev *netdev_dev)
 445 {
 446     const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev);
 447     assert(is_netdev_linux_class(netdev_class));
 448
 449     return CONTAINER_OF(netdev_dev, struct netdev_dev_linux, netdev_dev);
 450 }
 451
 452 static struct netdev_linux *
 453 netdev_linux_cast(const struct netdev *netdev)
 454 {
 455     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
 456     const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev);
 457     assert(is_netdev_linux_class(netdev_class));
 458
 459     return CONTAINER_OF(netdev, struct netdev_linux, netdev);
 460 }
 461 \f
 462 static int
 463 netdev_linux_init(void)
 464 {
 465     static int status = -1;
 466     if (status < 0) {
 467         /* Create AF_INET socket. */
 468         af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
 469         status = af_inet_sock >= 0 ? 0 : errno;
 470         if (status) {
 471             VLOG_ERR("failed to create inet socket: %s", strerror(status));
 472         }
 473
 474         /* Create rtnetlink socket. */
 475         if (!status) {
 476             status = nl_sock_create(NETLINK_ROUTE, &rtnl_sock);
 477             if (status) {
 478                 VLOG_ERR_RL(&rl, "failed to create rtnetlink socket: %s",
 479                             strerror(status));
 480             }
 481         }
 482     }
 483     return status;
 484 }
 485
 486 static void
 487 netdev_linux_run(void)
 488 {
 489     rtnetlink_link_run();
 490     netdev_linux_miimon_run();
 491 }
 492
 493 static void
 494 netdev_linux_wait(void)
 495 {
 496     rtnetlink_link_wait();
 497     netdev_linux_miimon_wait();
 498 }
 499
 500 static int
 501 netdev_linux_get_drvinfo(struct netdev_dev_linux *netdev_dev)
 502 {
 503
 504     int error;
 505
 506     if (netdev_dev->cache_valid & VALID_DRVINFO) {
 507         return 0;
 508     }
 509
 510     memset(&netdev_dev->drvinfo, 0, sizeof netdev_dev->drvinfo);
 511     error = netdev_linux_do_ethtool(netdev_dev->netdev_dev.name,
 512                                     (struct ethtool_cmd *)&netdev_dev->drvinfo,
 513                                     ETHTOOL_GDRVINFO,
 514                                     "ETHTOOL_GDRVINFO");
 515     if (!error) {
 516         netdev_dev->cache_valid |= VALID_DRVINFO;
 517     }
 518     return error;
 519 }
 520
 521 static void
 522 netdev_dev_linux_changed(struct netdev_dev_linux *dev,
 523                          unsigned int ifi_flags,
 524                          unsigned int mask)
 525 {
 526     dev->change_seq++;
 527     if (!dev->change_seq) {
 528         dev->change_seq++;
 529     }
 530
 531     if ((dev->ifi_flags ^ ifi_flags) & IFF_RUNNING) {
 532         dev->carrier_resets++;
 533     }
 534     dev->ifi_flags = ifi_flags;
 535
 536     dev->cache_valid &= mask;
 537 }
 538
 539 static void
 540 netdev_dev_linux_update(struct netdev_dev_linux *dev,
 541                          const struct rtnetlink_link_change *change)
 542 {
 543     if (change->nlmsg_type == RTM_NEWLINK) {
 544         /* Keep drv-info */
 545         netdev_dev_linux_changed(dev, change->ifi_flags, VALID_DRVINFO);
 546
 547         /* Update netdev from rtnl-change msg. */
 548         if (change->mtu) {
 549             dev->mtu = change->mtu;
 550             dev->cache_valid |= VALID_MTU;
 551             dev->netdev_mtu_error = 0;
 552         }
 553
 554         if (!eth_addr_is_zero(change->addr)) {
 555             memcpy(dev->etheraddr, change->addr, ETH_ADDR_LEN);
 556             dev->cache_valid |= VALID_ETHERADDR;
 557             dev->ether_addr_error = 0;
 558         }
 559
 560         dev->ifindex = change->ifi_index;
 561         dev->cache_valid |= VALID_IFINDEX;
 562         dev->get_ifindex_error = 0;
 563
 564     } else {
 565         netdev_dev_linux_changed(dev, change->ifi_flags, 0);
 566     }
 567 }
 568
 569 static void
 570 netdev_linux_cache_cb(const struct rtnetlink_link_change *change,
 571                       void *aux OVS_UNUSED)
 572 {
 573     struct netdev_dev_linux *dev;
 574     if (change) {
 575         struct netdev_dev *base_dev = netdev_dev_from_name(change->ifname);
 576         if (base_dev) {
 577             const struct netdev_class *netdev_class =
 578                                                 netdev_dev_get_class(base_dev);
 579
 580             if (is_netdev_linux_class(netdev_class)) {
 581                 dev = netdev_dev_linux_cast(base_dev);
 582                 netdev_dev_linux_update(dev, change);
 583             }
 584         }
 585     } else {
 586         struct shash device_shash;
 587         struct shash_node *node;
 588
 589         shash_init(&device_shash);
 590         netdev_dev_get_devices(&netdev_linux_class, &device_shash);
 591         SHASH_FOR_EACH (node, &device_shash) {
 592             unsigned int flags;
 593
 594             dev = node->data;
 595
 596             get_flags(&dev->netdev_dev, &flags);
 597             netdev_dev_linux_changed(dev, flags, 0);
 598         }
 599         shash_destroy(&device_shash);
 600     }
 601 }
 602
 603 static int
 604 cache_notifier_ref(void)
 605 {
 606     if (!cache_notifier_refcount) {
 607         assert(!netdev_linux_cache_notifier);
 608
 609         netdev_linux_cache_notifier =
 610             rtnetlink_link_notifier_create(netdev_linux_cache_cb, NULL);
 611
 612         if (!netdev_linux_cache_notifier) {
 613             return EINVAL;
 614         }
 615     }
 616     cache_notifier_refcount++;
 617
 618     return 0;
 619 }
 620
 621 static void
 622 cache_notifier_unref(void)
 623 {
 624     assert(cache_notifier_refcount > 0);
 625     if (!--cache_notifier_refcount) {
 626         assert(netdev_linux_cache_notifier);
 627         rtnetlink_link_notifier_destroy(netdev_linux_cache_notifier);
 628         netdev_linux_cache_notifier = NULL;
 629     }
 630 }
 631
 632 /* Creates system and internal devices. */
 633 static int
 634 netdev_linux_create(const struct netdev_class *class, const char *name,
 635                     struct netdev_dev **netdev_devp)
 636 {
 637     struct netdev_dev_linux *netdev_dev;
 638     int error;
 639
 640     error = cache_notifier_ref();
 641     if (error) {
 642         return error;
 643     }
 644
 645     netdev_dev = xzalloc(sizeof *netdev_dev);
 646     netdev_dev->change_seq = 1;
 647     netdev_dev_init(&netdev_dev->netdev_dev, name, class);
 648     get_flags(&netdev_dev->netdev_dev, &netdev_dev->ifi_flags);
 649
 650     *netdev_devp = &netdev_dev->netdev_dev;
 651     return 0;
 652 }
 653
 654 /* For most types of netdevs we open the device for each call of
 655  * netdev_open().  However, this is not the case with tap devices,
 656  * since it is only possible to open the device once.  In this
 657  * situation we share a single file descriptor, and consequently
 658  * buffers, across all readers.  Therefore once data is read it will
 659  * be unavailable to other reads for tap devices. */
 660 static int
 661 netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED,
 662                         const char *name, struct netdev_dev **netdev_devp)
 663 {
 664     struct netdev_dev_linux *netdev_dev;
 665     struct tap_state *state;
 666     static const char tap_dev[] = "/dev/net/tun";
 667     struct ifreq ifr;
 668     int error;
 669
 670     netdev_dev = xzalloc(sizeof *netdev_dev);
 671     state = &netdev_dev->state.tap;
 672
 673     error = cache_notifier_ref();
 674     if (error) {
 675         goto error;
 676     }
 677
 678     /* Open tap device. */
 679     state->fd = open(tap_dev, O_RDWR);
 680     if (state->fd < 0) {
 681         error = errno;
 682         VLOG_WARN("opening \"%s\" failed: %s", tap_dev, strerror(error));
 683         goto error_unref_notifier;
 684     }
 685
 686     /* Create tap device. */
 687     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 688     ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
 689     if (ioctl(state->fd, TUNSETIFF, &ifr) == -1) {
 690         VLOG_WARN("%s: creating tap device failed: %s", name,
 691                   strerror(errno));
 692         error = errno;
 693         goto error_unref_notifier;
 694     }
 695
 696     /* Make non-blocking. */
 697     error = set_nonblocking(state->fd);
 698     if (error) {
 699         goto error_unref_notifier;
 700     }
 701
 702     netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class);
 703     *netdev_devp = &netdev_dev->netdev_dev;
 704     return 0;
 705
 706 error_unref_notifier:
 707     cache_notifier_unref();
 708 error:
 709     free(netdev_dev);
 710     return error;
 711 }
 712
 713 static void
 714 destroy_tap(struct netdev_dev_linux *netdev_dev)
 715 {
 716     struct tap_state *state = &netdev_dev->state.tap;
 717
 718     if (state->fd >= 0) {
 719         close(state->fd);
 720     }
 721 }
 722
 723 /* Destroys the netdev device 'netdev_dev_'. */
 724 static void
 725 netdev_linux_destroy(struct netdev_dev *netdev_dev_)
 726 {
 727     struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_);
 728     const struct netdev_class *class = netdev_dev_get_class(netdev_dev_);
 729
 730     if (netdev_dev->tc && netdev_dev->tc->ops->tc_destroy) {
 731         netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
 732     }
 733
 734     if (class == &netdev_tap_class) {
 735         destroy_tap(netdev_dev);
 736     }
 737     free(netdev_dev);
 738
 739     cache_notifier_unref();
 740 }
 741
 742 static int
 743 netdev_linux_open(struct netdev_dev *netdev_dev_, struct netdev **netdevp)
 744 {
 745     struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_);
 746     struct netdev_linux *netdev;
 747     enum netdev_flags flags;
 748     int error;
 749
 750     /* Allocate network device. */
 751     netdev = xzalloc(sizeof *netdev);
 752     netdev->fd = -1;
 753     netdev_init(&netdev->netdev, netdev_dev_);
 754
 755     /* Verify that the device really exists, by attempting to read its flags.
 756      * (The flags might be cached, in which case this won't actually do an
 757      * ioctl.)
 758      *
 759      * Don't do this for "internal" netdevs, though, because those have to be
 760      * created as netdev objects before they exist in the kernel, because
 761      * creating them in the kernel happens by passing a netdev object to
 762      * dpif_port_add(). */
 763     if (netdev_dev_get_class(netdev_dev_) != &netdev_internal_class) {
 764         error = netdev_get_flags(&netdev->netdev, &flags);
 765         if (error == ENODEV) {
 766             goto error;
 767         }
 768     }
 769
 770     if (!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     uint32_t speed;
1494     int error;
1495
1496     if (netdev_dev->cache_valid & VALID_FEATURES) {
1497         return;
1498     }
1499
1500     memset(&ecmd, 0, sizeof ecmd);
1501     error = netdev_linux_do_ethtool(netdev_dev->netdev_dev.name, &ecmd,
1502                                     ETHTOOL_GSET, "ETHTOOL_GSET");
1503     if (error) {
1504         goto out;
1505     }
1506
1507     /* Supported features. */
1508     netdev_dev->supported = 0;
1509     if (ecmd.supported & SUPPORTED_10baseT_Half) {
1510         netdev_dev->supported |= NETDEV_F_10MB_HD;
1511     }
1512     if (ecmd.supported & SUPPORTED_10baseT_Full) {
1513         netdev_dev->supported |= NETDEV_F_10MB_FD;
1514     }
1515     if (ecmd.supported & SUPPORTED_100baseT_Half)  {
1516         netdev_dev->supported |= NETDEV_F_100MB_HD;
1517     }
1518     if (ecmd.supported & SUPPORTED_100baseT_Full) {
1519         netdev_dev->supported |= NETDEV_F_100MB_FD;
1520     }
1521     if (ecmd.supported & SUPPORTED_1000baseT_Half) {
1522         netdev_dev->supported |= NETDEV_F_1GB_HD;
1523     }
1524     if (ecmd.supported & SUPPORTED_1000baseT_Full) {
1525         netdev_dev->supported |= NETDEV_F_1GB_FD;
1526     }
1527     if (ecmd.supported & SUPPORTED_10000baseT_Full) {
1528         netdev_dev->supported |= NETDEV_F_10GB_FD;
1529     }
1530     if (ecmd.supported & SUPPORTED_TP) {
1531         netdev_dev->supported |= NETDEV_F_COPPER;
1532     }
1533     if (ecmd.supported & SUPPORTED_FIBRE) {
1534         netdev_dev->supported |= NETDEV_F_FIBER;
1535     }
1536     if (ecmd.supported & SUPPORTED_Autoneg) {
1537         netdev_dev->supported |= NETDEV_F_AUTONEG;
1538     }
1539     if (ecmd.supported & SUPPORTED_Pause) {
1540         netdev_dev->supported |= NETDEV_F_PAUSE;
1541     }
1542     if (ecmd.supported & SUPPORTED_Asym_Pause) {
1543         netdev_dev->supported |= NETDEV_F_PAUSE_ASYM;
1544     }
1545
1546     /* Advertised features. */
1547     netdev_dev->advertised = 0;
1548     if (ecmd.advertising & ADVERTISED_10baseT_Half) {
1549         netdev_dev->advertised |= NETDEV_F_10MB_HD;
1550     }
1551     if (ecmd.advertising & ADVERTISED_10baseT_Full) {
1552         netdev_dev->advertised |= NETDEV_F_10MB_FD;
1553     }
1554     if (ecmd.advertising & ADVERTISED_100baseT_Half) {
1555         netdev_dev->advertised |= NETDEV_F_100MB_HD;
1556     }
1557     if (ecmd.advertising & ADVERTISED_100baseT_Full) {
1558         netdev_dev->advertised |= NETDEV_F_100MB_FD;
1559     }
1560     if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
1561         netdev_dev->advertised |= NETDEV_F_1GB_HD;
1562     }
1563     if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
1564         netdev_dev->advertised |= NETDEV_F_1GB_FD;
1565     }
1566     if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
1567         netdev_dev->advertised |= NETDEV_F_10GB_FD;
1568     }
1569     if (ecmd.advertising & ADVERTISED_TP) {
1570         netdev_dev->advertised |= NETDEV_F_COPPER;
1571     }
1572     if (ecmd.advertising & ADVERTISED_FIBRE) {
1573         netdev_dev->advertised |= NETDEV_F_FIBER;
1574     }
1575     if (ecmd.advertising & ADVERTISED_Autoneg) {
1576         netdev_dev->advertised |= NETDEV_F_AUTONEG;
1577     }
1578     if (ecmd.advertising & ADVERTISED_Pause) {
1579         netdev_dev->advertised |= NETDEV_F_PAUSE;
1580     }
1581     if (ecmd.advertising & ADVERTISED_Asym_Pause) {
1582         netdev_dev->advertised |= NETDEV_F_PAUSE_ASYM;
1583     }
1584
1585     /* Current settings. */
1586     speed = ecmd.speed;
1587     if (speed == SPEED_10) {
1588         netdev_dev->current = ecmd.duplex ? NETDEV_F_10MB_FD : NETDEV_F_10MB_HD;
1589     } else if (speed == SPEED_100) {
1590         netdev_dev->current = ecmd.duplex ? NETDEV_F_100MB_FD : NETDEV_F_100MB_HD;
1591     } else if (speed == SPEED_1000) {
1592         netdev_dev->current = ecmd.duplex ? NETDEV_F_1GB_FD : NETDEV_F_1GB_HD;
1593     } else if (speed == SPEED_10000) {
1594         netdev_dev->current = NETDEV_F_10GB_FD;
1595     } else if (speed == 40000) {
1596         netdev_dev->current = NETDEV_F_40GB_FD;
1597     } else if (speed == 100000) {
1598         netdev_dev->current = NETDEV_F_100GB_FD;
1599     } else if (speed == 1000000) {
1600         netdev_dev->current = NETDEV_F_1TB_FD;
1601     } else {
1602         netdev_dev->current = 0;
1603     }
1604
1605     if (ecmd.port == PORT_TP) {
1606         netdev_dev->current |= NETDEV_F_COPPER;
1607     } else if (ecmd.port == PORT_FIBRE) {
1608         netdev_dev->current |= NETDEV_F_FIBER;
1609     }
1610
1611     if (ecmd.autoneg) {
1612         netdev_dev->current |= NETDEV_F_AUTONEG;
1613     }
1614
1615     /* Peer advertisements. */
1616     netdev_dev->peer = 0;                  /* XXX */
1617
1618 out:
1619     netdev_dev->cache_valid |= VALID_FEATURES;
1620     netdev_dev->get_features_error = error;
1621 }
1622
1623 /* Stores the features supported by 'netdev' into each of '*current',
1624  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
1625  * bitmap of NETDEV_* bits.  Returns 0 if successful, otherwise a positive
1626  * errno value. */
1627 static int
1628 netdev_linux_get_features(const struct netdev *netdev_,
1629                           enum netdev_features *current,
1630                           enum netdev_features *advertised,
1631                           enum netdev_features *supported,
1632                           enum netdev_features *peer)
1633 {
1634     struct netdev_dev_linux *netdev_dev =
1635                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
1636
1637     netdev_linux_read_features(netdev_dev);
1638
1639     if (!netdev_dev->get_features_error) {
1640         *current = netdev_dev->current;
1641         *advertised = netdev_dev->advertised;
1642         *supported = netdev_dev->supported;
1643         *peer = netdev_dev->peer;
1644     }
1645     return netdev_dev->get_features_error;
1646 }
1647
1648 /* Set the features advertised by 'netdev' to 'advertise'. */
1649 static int
1650 netdev_linux_set_advertisements(struct netdev *netdev,
1651                                 enum netdev_features advertise)
1652 {
1653     struct ethtool_cmd ecmd;
1654     int error;
1655
1656     memset(&ecmd, 0, sizeof ecmd);
1657     error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1658                                     ETHTOOL_GSET, "ETHTOOL_GSET");
1659     if (error) {
1660         return error;
1661     }
1662
1663     ecmd.advertising = 0;
1664     if (advertise & NETDEV_F_10MB_HD) {
1665         ecmd.advertising |= ADVERTISED_10baseT_Half;
1666     }
1667     if (advertise & NETDEV_F_10MB_FD) {
1668         ecmd.advertising |= ADVERTISED_10baseT_Full;
1669     }
1670     if (advertise & NETDEV_F_100MB_HD) {
1671         ecmd.advertising |= ADVERTISED_100baseT_Half;
1672     }
1673     if (advertise & NETDEV_F_100MB_FD) {
1674         ecmd.advertising |= ADVERTISED_100baseT_Full;
1675     }
1676     if (advertise & NETDEV_F_1GB_HD) {
1677         ecmd.advertising |= ADVERTISED_1000baseT_Half;
1678     }
1679     if (advertise & NETDEV_F_1GB_FD) {
1680         ecmd.advertising |= ADVERTISED_1000baseT_Full;
1681     }
1682     if (advertise & NETDEV_F_10GB_FD) {
1683         ecmd.advertising |= ADVERTISED_10000baseT_Full;
1684     }
1685     if (advertise & NETDEV_F_COPPER) {
1686         ecmd.advertising |= ADVERTISED_TP;
1687     }
1688     if (advertise & NETDEV_F_FIBER) {
1689         ecmd.advertising |= ADVERTISED_FIBRE;
1690     }
1691     if (advertise & NETDEV_F_AUTONEG) {
1692         ecmd.advertising |= ADVERTISED_Autoneg;
1693     }
1694     if (advertise & NETDEV_F_PAUSE) {
1695         ecmd.advertising |= ADVERTISED_Pause;
1696     }
1697     if (advertise & NETDEV_F_PAUSE_ASYM) {
1698         ecmd.advertising |= ADVERTISED_Asym_Pause;
1699     }
1700     return netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1701                                    ETHTOOL_SSET, "ETHTOOL_SSET");
1702 }
1703
1704 /* Attempts to set input rate limiting (policing) policy.  Returns 0 if
1705  * successful, otherwise a positive errno value. */
1706 static int
1707 netdev_linux_set_policing(struct netdev *netdev,
1708                           uint32_t kbits_rate, uint32_t kbits_burst)
1709 {
1710     struct netdev_dev_linux *netdev_dev =
1711         netdev_dev_linux_cast(netdev_get_dev(netdev));
1712     const char *netdev_name = netdev_get_name(netdev);
1713     int error;
1714
1715
1716     kbits_burst = (!kbits_rate ? 0       /* Force to 0 if no rate specified. */
1717                    : !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */
1718                    : kbits_burst);       /* Stick with user-specified value. */
1719
1720     if (netdev_dev->cache_valid & VALID_POLICING) {
1721         if (netdev_dev->netdev_policing_error) {
1722             return netdev_dev->netdev_policing_error;
1723         }
1724
1725         if (netdev_dev->kbits_rate == kbits_rate &&
1726             netdev_dev->kbits_burst == kbits_burst) {
1727             /* Assume that settings haven't changed since we last set them. */
1728             return 0;
1729         }
1730         netdev_dev->cache_valid &= ~VALID_POLICING;
1731     }
1732
1733     COVERAGE_INC(netdev_set_policing);
1734     /* Remove any existing ingress qdisc. */
1735     error = tc_add_del_ingress_qdisc(netdev, false);
1736     if (error) {
1737         VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
1738                      netdev_name, strerror(error));
1739         goto out;
1740     }
1741
1742     if (kbits_rate) {
1743         error = tc_add_del_ingress_qdisc(netdev, true);
1744         if (error) {
1745             VLOG_WARN_RL(&rl, "%s: adding policing qdisc failed: %s",
1746                          netdev_name, strerror(error));
1747             goto out;
1748         }
1749
1750         error = tc_add_policer(netdev, kbits_rate, kbits_burst);
1751         if (error){
1752             VLOG_WARN_RL(&rl, "%s: adding policing action failed: %s",
1753                     netdev_name, strerror(error));
1754             goto out;
1755         }
1756     }
1757
1758     netdev_dev->kbits_rate = kbits_rate;
1759     netdev_dev->kbits_burst = kbits_burst;
1760
1761 out:
1762     if (!error || error == ENODEV) {
1763         netdev_dev->netdev_policing_error = error;
1764         netdev_dev->cache_valid |= VALID_POLICING;
1765     }
1766     return error;
1767 }
1768
1769 static int
1770 netdev_linux_get_qos_types(const struct netdev *netdev OVS_UNUSED,
1771                            struct sset *types)
1772 {
1773     const struct tc_ops **opsp;
1774
1775     for (opsp = tcs; *opsp != NULL; opsp++) {
1776         const struct tc_ops *ops = *opsp;
1777         if (ops->tc_install && ops->ovs_name[0] != '\0') {
1778             sset_add(types, ops->ovs_name);
1779         }
1780     }
1781     return 0;
1782 }
1783
1784 static const struct tc_ops *
1785 tc_lookup_ovs_name(const char *name)
1786 {
1787     const struct tc_ops **opsp;
1788
1789     for (opsp = tcs; *opsp != NULL; opsp++) {
1790         const struct tc_ops *ops = *opsp;
1791         if (!strcmp(name, ops->ovs_name)) {
1792             return ops;
1793         }
1794     }
1795     return NULL;
1796 }
1797
1798 static const struct tc_ops *
1799 tc_lookup_linux_name(const char *name)
1800 {
1801     const struct tc_ops **opsp;
1802
1803     for (opsp = tcs; *opsp != NULL; opsp++) {
1804         const struct tc_ops *ops = *opsp;
1805         if (ops->linux_name && !strcmp(name, ops->linux_name)) {
1806             return ops;
1807         }
1808     }
1809     return NULL;
1810 }
1811
1812 static struct tc_queue *
1813 tc_find_queue__(const struct netdev *netdev, unsigned int queue_id,
1814                 size_t hash)
1815 {
1816     struct netdev_dev_linux *netdev_dev =
1817                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1818     struct tc_queue *queue;
1819
1820     HMAP_FOR_EACH_IN_BUCKET (queue, hmap_node, hash, &netdev_dev->tc->queues) {
1821         if (queue->queue_id == queue_id) {
1822             return queue;
1823         }
1824     }
1825     return NULL;
1826 }
1827
1828 static struct tc_queue *
1829 tc_find_queue(const struct netdev *netdev, unsigned int queue_id)
1830 {
1831     return tc_find_queue__(netdev, queue_id, hash_int(queue_id, 0));
1832 }
1833
1834 static int
1835 netdev_linux_get_qos_capabilities(const struct netdev *netdev OVS_UNUSED,
1836                                   const char *type,
1837                                   struct netdev_qos_capabilities *caps)
1838 {
1839     const struct tc_ops *ops = tc_lookup_ovs_name(type);
1840     if (!ops) {
1841         return EOPNOTSUPP;
1842     }
1843     caps->n_queues = ops->n_queues;
1844     return 0;
1845 }
1846
1847 static int
1848 netdev_linux_get_qos(const struct netdev *netdev,
1849                      const char **typep, struct shash *details)
1850 {
1851     struct netdev_dev_linux *netdev_dev =
1852                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1853     int error;
1854
1855     error = tc_query_qdisc(netdev);
1856     if (error) {
1857         return error;
1858     }
1859
1860     *typep = netdev_dev->tc->ops->ovs_name;
1861     return (netdev_dev->tc->ops->qdisc_get
1862             ? netdev_dev->tc->ops->qdisc_get(netdev, details)
1863             : 0);
1864 }
1865
1866 static int
1867 netdev_linux_set_qos(struct netdev *netdev,
1868                      const char *type, const struct shash *details)
1869 {
1870     struct netdev_dev_linux *netdev_dev =
1871                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1872     const struct tc_ops *new_ops;
1873     int error;
1874
1875     new_ops = tc_lookup_ovs_name(type);
1876     if (!new_ops || !new_ops->tc_install) {
1877         return EOPNOTSUPP;
1878     }
1879
1880     error = tc_query_qdisc(netdev);
1881     if (error) {
1882         return error;
1883     }
1884
1885     if (new_ops == netdev_dev->tc->ops) {
1886         return new_ops->qdisc_set ? new_ops->qdisc_set(netdev, details) : 0;
1887     } else {
1888         /* Delete existing qdisc. */
1889         error = tc_del_qdisc(netdev);
1890         if (error) {
1891             return error;
1892         }
1893         assert(netdev_dev->tc == NULL);
1894
1895         /* Install new qdisc. */
1896         error = new_ops->tc_install(netdev, details);
1897         assert((error == 0) == (netdev_dev->tc != NULL));
1898
1899         return error;
1900     }
1901 }
1902
1903 static int
1904 netdev_linux_get_queue(const struct netdev *netdev,
1905                        unsigned int queue_id, struct shash *details)
1906 {
1907     struct netdev_dev_linux *netdev_dev =
1908                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1909     int error;
1910
1911     error = tc_query_qdisc(netdev);
1912     if (error) {
1913         return error;
1914     } else {
1915         struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1916         return (queue
1917                 ? netdev_dev->tc->ops->class_get(netdev, queue, details)
1918                 : ENOENT);
1919     }
1920 }
1921
1922 static int
1923 netdev_linux_set_queue(struct netdev *netdev,
1924                        unsigned int queue_id, const struct shash *details)
1925 {
1926     struct netdev_dev_linux *netdev_dev =
1927                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1928     int error;
1929
1930     error = tc_query_qdisc(netdev);
1931     if (error) {
1932         return error;
1933     } else if (queue_id >= netdev_dev->tc->ops->n_queues
1934                || !netdev_dev->tc->ops->class_set) {
1935         return EINVAL;
1936     }
1937
1938     return netdev_dev->tc->ops->class_set(netdev, queue_id, details);
1939 }
1940
1941 static int
1942 netdev_linux_delete_queue(struct netdev *netdev, unsigned int queue_id)
1943 {
1944     struct netdev_dev_linux *netdev_dev =
1945                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1946     int error;
1947
1948     error = tc_query_qdisc(netdev);
1949     if (error) {
1950         return error;
1951     } else if (!netdev_dev->tc->ops->class_delete) {
1952         return EINVAL;
1953     } else {
1954         struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1955         return (queue
1956                 ? netdev_dev->tc->ops->class_delete(netdev, queue)
1957                 : ENOENT);
1958     }
1959 }
1960
1961 static int
1962 netdev_linux_get_queue_stats(const struct netdev *netdev,
1963                              unsigned int queue_id,
1964                              struct netdev_queue_stats *stats)
1965 {
1966     struct netdev_dev_linux *netdev_dev =
1967                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
1968     int error;
1969
1970     error = tc_query_qdisc(netdev);
1971     if (error) {
1972         return error;
1973     } else if (!netdev_dev->tc->ops->class_get_stats) {
1974         return EOPNOTSUPP;
1975     } else {
1976         const struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1977         return (queue
1978                 ? netdev_dev->tc->ops->class_get_stats(netdev, queue, stats)
1979                 : ENOENT);
1980     }
1981 }
1982
1983 static bool
1984 start_queue_dump(const struct netdev *netdev, struct nl_dump *dump)
1985 {
1986     struct ofpbuf request;
1987     struct tcmsg *tcmsg;
1988
1989     tcmsg = tc_make_request(netdev, RTM_GETTCLASS, 0, &request);
1990     if (!tcmsg) {
1991         return false;
1992     }
1993     tcmsg->tcm_parent = 0;
1994     nl_dump_start(dump, rtnl_sock, &request);
1995     ofpbuf_uninit(&request);
1996     return true;
1997 }
1998
1999 static int
2000 netdev_linux_dump_queues(const struct netdev *netdev,
2001                          netdev_dump_queues_cb *cb, void *aux)
2002 {
2003     struct netdev_dev_linux *netdev_dev =
2004                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2005     struct tc_queue *queue;
2006     struct shash details;
2007     int last_error;
2008     int error;
2009
2010     error = tc_query_qdisc(netdev);
2011     if (error) {
2012         return error;
2013     } else if (!netdev_dev->tc->ops->class_get) {
2014         return EOPNOTSUPP;
2015     }
2016
2017     last_error = 0;
2018     shash_init(&details);
2019     HMAP_FOR_EACH (queue, hmap_node, &netdev_dev->tc->queues) {
2020         shash_clear(&details);
2021
2022         error = netdev_dev->tc->ops->class_get(netdev, queue, &details);
2023         if (!error) {
2024             (*cb)(queue->queue_id, &details, aux);
2025         } else {
2026             last_error = error;
2027         }
2028     }
2029     shash_destroy(&details);
2030
2031     return last_error;
2032 }
2033
2034 static int
2035 netdev_linux_dump_queue_stats(const struct netdev *netdev,
2036                               netdev_dump_queue_stats_cb *cb, void *aux)
2037 {
2038     struct netdev_dev_linux *netdev_dev =
2039                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2040     struct nl_dump dump;
2041     struct ofpbuf msg;
2042     int last_error;
2043     int error;
2044
2045     error = tc_query_qdisc(netdev);
2046     if (error) {
2047         return error;
2048     } else if (!netdev_dev->tc->ops->class_dump_stats) {
2049         return EOPNOTSUPP;
2050     }
2051
2052     last_error = 0;
2053     if (!start_queue_dump(netdev, &dump)) {
2054         return ENODEV;
2055     }
2056     while (nl_dump_next(&dump, &msg)) {
2057         error = netdev_dev->tc->ops->class_dump_stats(netdev, &msg, cb, aux);
2058         if (error) {
2059             last_error = error;
2060         }
2061     }
2062
2063     error = nl_dump_done(&dump);
2064     return error ? error : last_error;
2065 }
2066
2067 static int
2068 netdev_linux_get_in4(const struct netdev *netdev_,
2069                      struct in_addr *address, struct in_addr *netmask)
2070 {
2071     struct netdev_dev_linux *netdev_dev =
2072                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
2073
2074     if (!(netdev_dev->cache_valid & VALID_IN4)) {
2075         int error;
2076
2077         error = netdev_linux_get_ipv4(netdev_, &netdev_dev->address,
2078                                       SIOCGIFADDR, "SIOCGIFADDR");
2079         if (error) {
2080             return error;
2081         }
2082
2083         error = netdev_linux_get_ipv4(netdev_, &netdev_dev->netmask,
2084                                       SIOCGIFNETMASK, "SIOCGIFNETMASK");
2085         if (error) {
2086             return error;
2087         }
2088
2089         netdev_dev->cache_valid |= VALID_IN4;
2090     }
2091     *address = netdev_dev->address;
2092     *netmask = netdev_dev->netmask;
2093     return address->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
2094 }
2095
2096 static int
2097 netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address,
2098                      struct in_addr netmask)
2099 {
2100     struct netdev_dev_linux *netdev_dev =
2101                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
2102     int error;
2103
2104     error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address);
2105     if (!error) {
2106         netdev_dev->cache_valid |= VALID_IN4;
2107         netdev_dev->address = address;
2108         netdev_dev->netmask = netmask;
2109         if (address.s_addr != INADDR_ANY) {
2110             error = do_set_addr(netdev_, SIOCSIFNETMASK,
2111                                 "SIOCSIFNETMASK", netmask);
2112         }
2113     }
2114     return error;
2115 }
2116
2117 static bool
2118 parse_if_inet6_line(const char *line,
2119                     struct in6_addr *in6, char ifname[16 + 1])
2120 {
2121     uint8_t *s6 = in6->s6_addr;
2122 #define X8 "%2"SCNx8
2123     return sscanf(line,
2124                   " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
2125                   "%*x %*x %*x %*x %16s\n",
2126                   &s6[0], &s6[1], &s6[2], &s6[3],
2127                   &s6[4], &s6[5], &s6[6], &s6[7],
2128                   &s6[8], &s6[9], &s6[10], &s6[11],
2129                   &s6[12], &s6[13], &s6[14], &s6[15],
2130                   ifname) == 17;
2131 }
2132
2133 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
2134  * 'in6' is non-null) and returns true.  Otherwise, returns false. */
2135 static int
2136 netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
2137 {
2138     struct netdev_dev_linux *netdev_dev =
2139                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
2140     if (!(netdev_dev->cache_valid & VALID_IN6)) {
2141         FILE *file;
2142         char line[128];
2143
2144         netdev_dev->in6 = in6addr_any;
2145
2146         file = fopen("/proc/net/if_inet6", "r");
2147         if (file != NULL) {
2148             const char *name = netdev_get_name(netdev_);
2149             while (fgets(line, sizeof line, file)) {
2150                 struct in6_addr in6_tmp;
2151                 char ifname[16 + 1];
2152                 if (parse_if_inet6_line(line, &in6_tmp, ifname)
2153                     && !strcmp(name, ifname))
2154                 {
2155                     netdev_dev->in6 = in6_tmp;
2156                     break;
2157                 }
2158             }
2159             fclose(file);
2160         }
2161         netdev_dev->cache_valid |= VALID_IN6;
2162     }
2163     *in6 = netdev_dev->in6;
2164     return 0;
2165 }
2166
2167 static void
2168 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
2169 {
2170     struct sockaddr_in sin;
2171     memset(&sin, 0, sizeof sin);
2172     sin.sin_family = AF_INET;
2173     sin.sin_addr = addr;
2174     sin.sin_port = 0;
2175
2176     memset(sa, 0, sizeof *sa);
2177     memcpy(sa, &sin, sizeof sin);
2178 }
2179
2180 static int
2181 do_set_addr(struct netdev *netdev,
2182             int ioctl_nr, const char *ioctl_name, struct in_addr addr)
2183 {
2184     struct ifreq ifr;
2185     ovs_strzcpy(ifr.ifr_name, netdev_get_name(netdev), sizeof ifr.ifr_name);
2186     make_in4_sockaddr(&ifr.ifr_addr, addr);
2187
2188     return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, ioctl_nr,
2189                                  ioctl_name);
2190 }
2191
2192 /* Adds 'router' as a default IP gateway. */
2193 static int
2194 netdev_linux_add_router(struct netdev *netdev OVS_UNUSED, struct in_addr router)
2195 {
2196     struct in_addr any = { INADDR_ANY };
2197     struct rtentry rt;
2198     int error;
2199
2200     memset(&rt, 0, sizeof rt);
2201     make_in4_sockaddr(&rt.rt_dst, any);
2202     make_in4_sockaddr(&rt.rt_gateway, router);
2203     make_in4_sockaddr(&rt.rt_genmask, any);
2204     rt.rt_flags = RTF_UP | RTF_GATEWAY;
2205     error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
2206     if (error) {
2207         VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error));
2208     }
2209     return error;
2210 }
2211
2212 static int
2213 netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
2214                           char **netdev_name)
2215 {
2216     static const char fn[] = "/proc/net/route";
2217     FILE *stream;
2218     char line[256];
2219     int ln;
2220
2221     *netdev_name = NULL;
2222     stream = fopen(fn, "r");
2223     if (stream == NULL) {
2224         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
2225         return errno;
2226     }
2227
2228     ln = 0;
2229     while (fgets(line, sizeof line, stream)) {
2230         if (++ln >= 2) {
2231             char iface[17];
2232             ovs_be32 dest, gateway, mask;
2233             int refcnt, metric, mtu;
2234             unsigned int flags, use, window, irtt;
2235
2236             if (sscanf(line,
2237                        "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
2238                        " %d %u %u\n",
2239                        iface, &dest, &gateway, &flags, &refcnt,
2240                        &use, &metric, &mask, &mtu, &window, &irtt) != 11) {
2241
2242                 VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
2243                         fn, ln, line);
2244                 continue;
2245             }
2246             if (!(flags & RTF_UP)) {
2247                 /* Skip routes that aren't up. */
2248                 continue;
2249             }
2250
2251             /* The output of 'dest', 'mask', and 'gateway' were given in
2252              * network byte order, so we don't need need any endian
2253              * conversions here. */
2254             if ((dest & mask) == (host->s_addr & mask)) {
2255                 if (!gateway) {
2256                     /* The host is directly reachable. */
2257                     next_hop->s_addr = 0;
2258                 } else {
2259                     /* To reach the host, we must go through a gateway. */
2260                     next_hop->s_addr = gateway;
2261                 }
2262                 *netdev_name = xstrdup(iface);
2263                 fclose(stream);
2264                 return 0;
2265             }
2266         }
2267     }
2268
2269     fclose(stream);
2270     return ENXIO;
2271 }
2272
2273 static int
2274 netdev_linux_get_status(const struct netdev *netdev, struct shash *sh)
2275 {
2276     int error;
2277     struct netdev_dev_linux *netdev_dev =
2278                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2279
2280     error = netdev_linux_get_drvinfo(netdev_dev);
2281     if (!error) {
2282         shash_add(sh, "driver_name", xstrdup(netdev_dev->drvinfo.driver));
2283         shash_add(sh, "driver_version", xstrdup(netdev_dev->drvinfo.version));
2284         shash_add(sh, "firmware_version", xstrdup(netdev_dev->drvinfo.fw_version));
2285     }
2286     return error;
2287 }
2288
2289 static int
2290 netdev_internal_get_status(const struct netdev *netdev OVS_UNUSED, struct shash *sh)
2291 {
2292     shash_add(sh, "driver_name", xstrdup("openvswitch"));
2293     return 0;
2294 }
2295
2296 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
2297  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
2298  * returns 0.  Otherwise, it returns a positive errno value; in particular,
2299  * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
2300 static int
2301 netdev_linux_arp_lookup(const struct netdev *netdev,
2302                         ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
2303 {
2304     struct arpreq r;
2305     struct sockaddr_in sin;
2306     int retval;
2307
2308     memset(&r, 0, sizeof r);
2309     memset(&sin, 0, sizeof sin);
2310     sin.sin_family = AF_INET;
2311     sin.sin_addr.s_addr = ip;
2312     sin.sin_port = 0;
2313     memcpy(&r.arp_pa, &sin, sizeof sin);
2314     r.arp_ha.sa_family = ARPHRD_ETHER;
2315     r.arp_flags = 0;
2316     ovs_strzcpy(r.arp_dev, netdev_get_name(netdev), sizeof r.arp_dev);
2317     COVERAGE_INC(netdev_arp_lookup);
2318     retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
2319     if (!retval) {
2320         memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
2321     } else if (retval != ENXIO) {
2322         VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
2323                      netdev_get_name(netdev), IP_ARGS(&ip), strerror(retval));
2324     }
2325     return retval;
2326 }
2327
2328 static int
2329 nd_to_iff_flags(enum netdev_flags nd)
2330 {
2331     int iff = 0;
2332     if (nd & NETDEV_UP) {
2333         iff |= IFF_UP;
2334     }
2335     if (nd & NETDEV_PROMISC) {
2336         iff |= IFF_PROMISC;
2337     }
2338     return iff;
2339 }
2340
2341 static int
2342 iff_to_nd_flags(int iff)
2343 {
2344     enum netdev_flags nd = 0;
2345     if (iff & IFF_UP) {
2346         nd |= NETDEV_UP;
2347     }
2348     if (iff & IFF_PROMISC) {
2349         nd |= NETDEV_PROMISC;
2350     }
2351     return nd;
2352 }
2353
2354 static int
2355 netdev_linux_update_flags(struct netdev *netdev, enum netdev_flags off,
2356                           enum netdev_flags on, enum netdev_flags *old_flagsp)
2357 {
2358     struct netdev_dev_linux *netdev_dev;
2359     int old_flags, new_flags;
2360     int error = 0;
2361
2362     netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
2363     old_flags = netdev_dev->ifi_flags;
2364     *old_flagsp = iff_to_nd_flags(old_flags);
2365     new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
2366     if (new_flags != old_flags) {
2367         error = set_flags(netdev, new_flags);
2368         get_flags(&netdev_dev->netdev_dev, &netdev_dev->ifi_flags);
2369     }
2370     return error;
2371 }
2372
2373 static unsigned int
2374 netdev_linux_change_seq(const struct netdev *netdev)
2375 {
2376     return netdev_dev_linux_cast(netdev_get_dev(netdev))->change_seq;
2377 }
2378
2379 #define NETDEV_LINUX_CLASS(NAME, CREATE, GET_STATS, SET_STATS,  \
2380                            GET_FEATURES, GET_STATUS)            \
2381 {                                                               \
2382     NAME,                                                       \
2383                                                                 \
2384     netdev_linux_init,                                          \
2385     netdev_linux_run,                                           \
2386     netdev_linux_wait,                                          \
2387                                                                 \
2388     CREATE,                                                     \
2389     netdev_linux_destroy,                                       \
2390     NULL,                       /* get_config */                \
2391     NULL,                       /* set_config */                \
2392                                                                 \
2393     netdev_linux_open,                                          \
2394     netdev_linux_close,                                         \
2395                                                                 \
2396     netdev_linux_listen,                                        \
2397     netdev_linux_recv,                                          \
2398     netdev_linux_recv_wait,                                     \
2399     netdev_linux_drain,                                         \
2400                                                                 \
2401     netdev_linux_send,                                          \
2402     netdev_linux_send_wait,                                     \
2403                                                                 \
2404     netdev_linux_set_etheraddr,                                 \
2405     netdev_linux_get_etheraddr,                                 \
2406     netdev_linux_get_mtu,                                       \
2407     netdev_linux_set_mtu,                                       \
2408     netdev_linux_get_ifindex,                                   \
2409     netdev_linux_get_carrier,                                   \
2410     netdev_linux_get_carrier_resets,                            \
2411     netdev_linux_set_miimon_interval,                           \
2412     GET_STATS,                                                  \
2413     SET_STATS,                                                  \
2414                                                                 \
2415     GET_FEATURES,                                               \
2416     netdev_linux_set_advertisements,                            \
2417                                                                 \
2418     netdev_linux_set_policing,                                  \
2419     netdev_linux_get_qos_types,                                 \
2420     netdev_linux_get_qos_capabilities,                          \
2421     netdev_linux_get_qos,                                       \
2422     netdev_linux_set_qos,                                       \
2423     netdev_linux_get_queue,                                     \
2424     netdev_linux_set_queue,                                     \
2425     netdev_linux_delete_queue,                                  \
2426     netdev_linux_get_queue_stats,                               \
2427     netdev_linux_dump_queues,                                   \
2428     netdev_linux_dump_queue_stats,                              \
2429                                                                 \
2430     netdev_linux_get_in4,                                       \
2431     netdev_linux_set_in4,                                       \
2432     netdev_linux_get_in6,                                       \
2433     netdev_linux_add_router,                                    \
2434     netdev_linux_get_next_hop,                                  \
2435     GET_STATUS,                                                 \
2436     netdev_linux_arp_lookup,                                    \
2437                                                                 \
2438     netdev_linux_update_flags,                                  \
2439                                                                 \
2440     netdev_linux_change_seq                                     \
2441 }
2442
2443 const struct netdev_class netdev_linux_class =
2444     NETDEV_LINUX_CLASS(
2445         "system",
2446         netdev_linux_create,
2447         netdev_linux_get_stats,
2448         NULL,                    /* set_stats */
2449         netdev_linux_get_features,
2450         netdev_linux_get_status);
2451
2452 const struct netdev_class netdev_tap_class =
2453     NETDEV_LINUX_CLASS(
2454         "tap",
2455         netdev_linux_create_tap,
2456         netdev_tap_get_stats,
2457         NULL,                   /* set_stats */
2458         netdev_linux_get_features,
2459         netdev_linux_get_status);
2460
2461 const struct netdev_class netdev_internal_class =
2462     NETDEV_LINUX_CLASS(
2463         "internal",
2464         netdev_linux_create,
2465         netdev_internal_get_stats,
2466         netdev_vport_set_stats,
2467         NULL,                  /* get_features */
2468         netdev_internal_get_status);
2469 \f
2470 /* HTB traffic control class. */
2471
2472 #define HTB_N_QUEUES 0xf000
2473
2474 struct htb {
2475     struct tc tc;
2476     unsigned int max_rate;      /* In bytes/s. */
2477 };
2478
2479 struct htb_class {
2480     struct tc_queue tc_queue;
2481     unsigned int min_rate;      /* In bytes/s. */
2482     unsigned int max_rate;      /* In bytes/s. */
2483     unsigned int burst;         /* In bytes. */
2484     unsigned int priority;      /* Lower values are higher priorities. */
2485 };
2486
2487 static struct htb *
2488 htb_get__(const struct netdev *netdev)
2489 {
2490     struct netdev_dev_linux *netdev_dev =
2491                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2492     return CONTAINER_OF(netdev_dev->tc, struct htb, tc);
2493 }
2494
2495 static void
2496 htb_install__(struct netdev *netdev, uint64_t max_rate)
2497 {
2498     struct netdev_dev_linux *netdev_dev =
2499                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
2500     struct htb *htb;
2501
2502     htb = xmalloc(sizeof *htb);
2503     tc_init(&htb->tc, &tc_ops_htb);
2504     htb->max_rate = max_rate;
2505
2506     netdev_dev->tc = &htb->tc;
2507 }
2508
2509 /* Create an HTB qdisc.
2510  *
2511  * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2512 static int
2513 htb_setup_qdisc__(struct netdev *netdev)
2514 {
2515     size_t opt_offset;
2516     struct tc_htb_glob opt;
2517     struct ofpbuf request;
2518     struct tcmsg *tcmsg;
2519
2520     tc_del_qdisc(netdev);
2521
2522     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2523                             NLM_F_EXCL | NLM_F_CREATE, &request);
2524     if (!tcmsg) {
2525         return ENODEV;
2526     }
2527     tcmsg->tcm_handle = tc_make_handle(1, 0);
2528     tcmsg->tcm_parent = TC_H_ROOT;
2529
2530     nl_msg_put_string(&request, TCA_KIND, "htb");
2531
2532     memset(&opt, 0, sizeof opt);
2533     opt.rate2quantum = 10;
2534     opt.version = 3;
2535     opt.defcls = 1;
2536
2537     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2538     nl_msg_put_unspec(&request, TCA_HTB_INIT, &opt, sizeof opt);
2539     nl_msg_end_nested(&request, opt_offset);
2540
2541     return tc_transact(&request, NULL);
2542 }
2543
2544 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2545  * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2546 static int
2547 htb_setup_class__(struct netdev *netdev, unsigned int handle,
2548                   unsigned int parent, struct htb_class *class)
2549 {
2550     size_t opt_offset;
2551     struct tc_htb_opt opt;
2552     struct ofpbuf request;
2553     struct tcmsg *tcmsg;
2554     int error;
2555     int mtu;
2556
2557     error = netdev_get_mtu(netdev, &mtu);
2558     if (error) {
2559         VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU",
2560                      netdev_get_name(netdev));
2561         return error;
2562     }
2563
2564     memset(&opt, 0, sizeof opt);
2565     tc_fill_rate(&opt.rate, class->min_rate, mtu);
2566     tc_fill_rate(&opt.ceil, class->max_rate, mtu);
2567     opt.buffer = tc_calc_buffer(opt.rate.rate, mtu, class->burst);
2568     opt.cbuffer = tc_calc_buffer(opt.ceil.rate, mtu, class->burst);
2569     opt.prio = class->priority;
2570
2571     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2572     if (!tcmsg) {
2573         return ENODEV;
2574     }
2575     tcmsg->tcm_handle = handle;
2576     tcmsg->tcm_parent = parent;
2577
2578     nl_msg_put_string(&request, TCA_KIND, "htb");
2579     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2580     nl_msg_put_unspec(&request, TCA_HTB_PARMS, &opt, sizeof opt);
2581     tc_put_rtab(&request, TCA_HTB_RTAB, &opt.rate);
2582     tc_put_rtab(&request, TCA_HTB_CTAB, &opt.ceil);
2583     nl_msg_end_nested(&request, opt_offset);
2584
2585     error = tc_transact(&request, NULL);
2586     if (error) {
2587         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
2588                      "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2589                      netdev_get_name(netdev),
2590                      tc_get_major(handle), tc_get_minor(handle),
2591                      tc_get_major(parent), tc_get_minor(parent),
2592                      class->min_rate, class->max_rate,
2593                      class->burst, class->priority, strerror(error));
2594     }
2595     return error;
2596 }
2597
2598 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2599  * description of them into 'details'.  The description complies with the
2600  * specification given in the vswitch database documentation for linux-htb
2601  * queue details. */
2602 static int
2603 htb_parse_tca_options__(struct nlattr *nl_options, struct htb_class *class)
2604 {
2605     static const struct nl_policy tca_htb_policy[] = {
2606         [TCA_HTB_PARMS] = { .type = NL_A_UNSPEC, .optional = false,
2607                             .min_len = sizeof(struct tc_htb_opt) },
2608     };
2609
2610     struct nlattr *attrs[ARRAY_SIZE(tca_htb_policy)];
2611     const struct tc_htb_opt *htb;
2612
2613     if (!nl_parse_nested(nl_options, tca_htb_policy,
2614                          attrs, ARRAY_SIZE(tca_htb_policy))) {
2615         VLOG_WARN_RL(&rl, "failed to parse HTB class options");
2616         return EPROTO;
2617     }
2618
2619     htb = nl_attr_get(attrs[TCA_HTB_PARMS]);
2620     class->min_rate = htb->rate.rate;
2621     class->max_rate = htb->ceil.rate;
2622     class->burst = tc_ticks_to_bytes(htb->rate.rate, htb->buffer);
2623     class->priority = htb->prio;
2624     return 0;
2625 }
2626
2627 static int
2628 htb_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2629                   struct htb_class *options,
2630                   struct netdev_queue_stats *stats)
2631 {
2632     struct nlattr *nl_options;
2633     unsigned int handle;
2634     int error;
2635
2636     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2637     if (!error && queue_id) {
2638         unsigned int major = tc_get_major(handle);
2639         unsigned int minor = tc_get_minor(handle);
2640         if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2641             *queue_id = minor - 1;
2642         } else {
2643             error = EPROTO;
2644         }
2645     }
2646     if (!error && options) {
2647         error = htb_parse_tca_options__(nl_options, options);
2648     }
2649     return error;
2650 }
2651
2652 static void
2653 htb_parse_qdisc_details__(struct netdev *netdev,
2654                           const struct shash *details, struct htb_class *hc)
2655 {
2656     const char *max_rate_s;
2657
2658     max_rate_s = shash_find_data(details, "max-rate");
2659     hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2660     if (!hc->max_rate) {
2661         enum netdev_features current;
2662
2663         netdev_get_features(netdev, &current, NULL, NULL, NULL);
2664         hc->max_rate = netdev_features_to_bps(current) / 8;
2665     }
2666     hc->min_rate = hc->max_rate;
2667     hc->burst = 0;
2668     hc->priority = 0;
2669 }
2670
2671 static int
2672 htb_parse_class_details__(struct netdev *netdev,
2673                           const struct shash *details, struct htb_class *hc)
2674 {
2675     const struct htb *htb = htb_get__(netdev);
2676     const char *min_rate_s = shash_find_data(details, "min-rate");
2677     const char *max_rate_s = shash_find_data(details, "max-rate");
2678     const char *burst_s = shash_find_data(details, "burst");
2679     const char *priority_s = shash_find_data(details, "priority");
2680     int mtu, error;
2681
2682     error = netdev_get_mtu(netdev, &mtu);
2683     if (error) {
2684         VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU",
2685                      netdev_get_name(netdev));
2686         return error;
2687     }
2688
2689     /* HTB requires at least an mtu sized min-rate to send any traffic even
2690      * on uncongested links. */
2691     hc->min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
2692     hc->min_rate = MAX(hc->min_rate, mtu);
2693     hc->min_rate = MIN(hc->min_rate, htb->max_rate);
2694
2695     /* max-rate */
2696     hc->max_rate = (max_rate_s
2697                     ? strtoull(max_rate_s, NULL, 10) / 8
2698                     : htb->max_rate);
2699     hc->max_rate = MAX(hc->max_rate, hc->min_rate);
2700     hc->max_rate = MIN(hc->max_rate, htb->max_rate);
2701
2702     /* burst
2703      *
2704      * According to hints in the documentation that I've read, it is important
2705      * that 'burst' be at least as big as the largest frame that might be
2706      * transmitted.  Also, making 'burst' a bit bigger than necessary is OK,
2707      * but having it a bit too small is a problem.  Since netdev_get_mtu()
2708      * doesn't include the Ethernet header, we need to add at least 14 (18?) to
2709      * the MTU.  We actually add 64, instead of 14, as a guard against
2710      * additional headers get tacked on somewhere that we're not aware of. */
2711     hc->burst = burst_s ? strtoull(burst_s, NULL, 10) / 8 : 0;
2712     hc->burst = MAX(hc->burst, mtu + 64);
2713
2714     /* priority */
2715     hc->priority = priority_s ? strtoul(priority_s, NULL, 10) : 0;
2716
2717     return 0;
2718 }
2719
2720 static int
2721 htb_query_class__(const struct netdev *netdev, unsigned int handle,
2722                   unsigned int parent, struct htb_class *options,
2723                   struct netdev_queue_stats *stats)
2724 {
2725     struct ofpbuf *reply;
2726     int error;
2727
2728     error = tc_query_class(netdev, handle, parent, &reply);
2729     if (!error) {
2730         error = htb_parse_tcmsg__(reply, NULL, options, stats);
2731         ofpbuf_delete(reply);
2732     }
2733     return error;
2734 }
2735
2736 static int
2737 htb_tc_install(struct netdev *netdev, const struct shash *details)
2738 {
2739     int error;
2740
2741     error = htb_setup_qdisc__(netdev);
2742     if (!error) {
2743         struct htb_class hc;
2744
2745         htb_parse_qdisc_details__(netdev, details, &hc);
2746         error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2747                                   tc_make_handle(1, 0), &hc);
2748         if (!error) {
2749             htb_install__(netdev, hc.max_rate);
2750         }
2751     }
2752     return error;
2753 }
2754
2755 static struct htb_class *
2756 htb_class_cast__(const struct tc_queue *queue)
2757 {
2758     return CONTAINER_OF(queue, struct htb_class, tc_queue);
2759 }
2760
2761 static void
2762 htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
2763                    const struct htb_class *hc)
2764 {
2765     struct htb *htb = htb_get__(netdev);
2766     size_t hash = hash_int(queue_id, 0);
2767     struct tc_queue *queue;
2768     struct htb_class *hcp;
2769
2770     queue = tc_find_queue__(netdev, queue_id, hash);
2771     if (queue) {
2772         hcp = htb_class_cast__(queue);
2773     } else {
2774         hcp = xmalloc(sizeof *hcp);
2775         queue = &hcp->tc_queue;
2776         queue->queue_id = queue_id;
2777         hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
2778     }
2779
2780     hcp->min_rate = hc->min_rate;
2781     hcp->max_rate = hc->max_rate;
2782     hcp->burst = hc->burst;
2783     hcp->priority = hc->priority;
2784 }
2785
2786 static int
2787 htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
2788 {
2789     struct ofpbuf msg;
2790     struct nl_dump dump;
2791     struct htb_class hc;
2792
2793     /* Get qdisc options. */
2794     hc.max_rate = 0;
2795     htb_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
2796     htb_install__(netdev, hc.max_rate);
2797
2798     /* Get queues. */
2799     if (!start_queue_dump(netdev, &dump)) {
2800         return ENODEV;
2801     }
2802     while (nl_dump_next(&dump, &msg)) {
2803         unsigned int queue_id;
2804
2805         if (!htb_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
2806             htb_update_queue__(netdev, queue_id, &hc);
2807         }
2808     }
2809     nl_dump_done(&dump);
2810
2811     return 0;
2812 }
2813
2814 static void
2815 htb_tc_destroy(struct tc *tc)
2816 {
2817     struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
2818     struct htb_class *hc, *next;
2819
2820     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &htb->tc.queues) {
2821         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2822         free(hc);
2823     }
2824     tc_destroy(tc);
2825     free(htb);
2826 }
2827
2828 static int
2829 htb_qdisc_get(const struct netdev *netdev, struct shash *details)
2830 {
2831     const struct htb *htb = htb_get__(netdev);
2832     shash_add(details, "max-rate", xasprintf("%llu", 8ULL * htb->max_rate));
2833     return 0;
2834 }
2835
2836 static int
2837 htb_qdisc_set(struct netdev *netdev, const struct shash *details)
2838 {
2839     struct htb_class hc;
2840     int error;
2841
2842     htb_parse_qdisc_details__(netdev, details, &hc);
2843     error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2844                               tc_make_handle(1, 0), &hc);
2845     if (!error) {
2846         htb_get__(netdev)->max_rate = hc.max_rate;
2847     }
2848     return error;
2849 }
2850
2851 static int
2852 htb_class_get(const struct netdev *netdev OVS_UNUSED,
2853               const struct tc_queue *queue, struct shash *details)
2854 {
2855     const struct htb_class *hc = htb_class_cast__(queue);
2856
2857     shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
2858     if (hc->min_rate != hc->max_rate) {
2859         shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
2860     }
2861     shash_add(details, "burst", xasprintf("%llu", 8ULL * hc->burst));
2862     if (hc->priority) {
2863         shash_add(details, "priority", xasprintf("%u", hc->priority));
2864     }
2865     return 0;
2866 }
2867
2868 static int
2869 htb_class_set(struct netdev *netdev, unsigned int queue_id,
2870               const struct shash *details)
2871 {
2872     struct htb_class hc;
2873     int error;
2874
2875     error = htb_parse_class_details__(netdev, details, &hc);
2876     if (error) {
2877         return error;
2878     }
2879
2880     error = htb_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
2881                               tc_make_handle(1, 0xfffe), &hc);
2882     if (error) {
2883         return error;
2884     }
2885
2886     htb_update_queue__(netdev, queue_id, &hc);
2887     return 0;
2888 }
2889
2890 static int
2891 htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
2892 {
2893     struct htb_class *hc = htb_class_cast__(queue);
2894     struct htb *htb = htb_get__(netdev);
2895     int error;
2896
2897     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
2898     if (!error) {
2899         hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2900         free(hc);
2901     }
2902     return error;
2903 }
2904
2905 static int
2906 htb_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
2907                     struct netdev_queue_stats *stats)
2908 {
2909     return htb_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
2910                              tc_make_handle(1, 0xfffe), NULL, stats);
2911 }
2912
2913 static int
2914 htb_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
2915                      const struct ofpbuf *nlmsg,
2916                      netdev_dump_queue_stats_cb *cb, void *aux)
2917 {
2918     struct netdev_queue_stats stats;
2919     unsigned int handle, major, minor;
2920     int error;
2921
2922     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
2923     if (error) {
2924         return error;
2925     }
2926
2927     major = tc_get_major(handle);
2928     minor = tc_get_minor(handle);
2929     if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2930         (*cb)(minor - 1, &stats, aux);
2931     }
2932     return 0;
2933 }
2934
2935 static const struct tc_ops tc_ops_htb = {
2936     "htb",                      /* linux_name */
2937     "linux-htb",                /* ovs_name */
2938     HTB_N_QUEUES,               /* n_queues */
2939     htb_tc_install,
2940     htb_tc_load,
2941     htb_tc_destroy,
2942     htb_qdisc_get,
2943     htb_qdisc_set,
2944     htb_class_get,
2945     htb_class_set,
2946     htb_class_delete,
2947     htb_class_get_stats,
2948     htb_class_dump_stats
2949 };
2950 \f
2951 /* "linux-hfsc" traffic control class. */
2952
2953 #define HFSC_N_QUEUES 0xf000
2954
2955 struct hfsc {
2956     struct tc tc;
2957     uint32_t max_rate;
2958 };
2959
2960 struct hfsc_class {
2961     struct tc_queue tc_queue;
2962     uint32_t min_rate;
2963     uint32_t max_rate;
2964 };
2965
2966 static struct hfsc *
2967 hfsc_get__(const struct netdev *netdev)
2968 {
2969     struct netdev_dev_linux *netdev_dev;
2970     netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
2971     return CONTAINER_OF(netdev_dev->tc, struct hfsc, tc);
2972 }
2973
2974 static struct hfsc_class *
2975 hfsc_class_cast__(const struct tc_queue *queue)
2976 {
2977     return CONTAINER_OF(queue, struct hfsc_class, tc_queue);
2978 }
2979
2980 static void
2981 hfsc_install__(struct netdev *netdev, uint32_t max_rate)
2982 {
2983     struct netdev_dev_linux * netdev_dev;
2984     struct hfsc *hfsc;
2985
2986     netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
2987     hfsc = xmalloc(sizeof *hfsc);
2988     tc_init(&hfsc->tc, &tc_ops_hfsc);
2989     hfsc->max_rate = max_rate;
2990     netdev_dev->tc = &hfsc->tc;
2991 }
2992
2993 static void
2994 hfsc_update_queue__(struct netdev *netdev, unsigned int queue_id,
2995                     const struct hfsc_class *hc)
2996 {
2997     size_t hash;
2998     struct hfsc *hfsc;
2999     struct hfsc_class *hcp;
3000     struct tc_queue *queue;
3001
3002     hfsc = hfsc_get__(netdev);
3003     hash = hash_int(queue_id, 0);
3004
3005     queue = tc_find_queue__(netdev, queue_id, hash);
3006     if (queue) {
3007         hcp = hfsc_class_cast__(queue);
3008     } else {
3009         hcp             = xmalloc(sizeof *hcp);
3010         queue           = &hcp->tc_queue;
3011         queue->queue_id = queue_id;
3012         hmap_insert(&hfsc->tc.queues, &queue->hmap_node, hash);
3013     }
3014
3015     hcp->min_rate = hc->min_rate;
3016     hcp->max_rate = hc->max_rate;
3017 }
3018
3019 static int
3020 hfsc_parse_tca_options__(struct nlattr *nl_options, struct hfsc_class *class)
3021 {
3022     const struct tc_service_curve *rsc, *fsc, *usc;
3023     static const struct nl_policy tca_hfsc_policy[] = {
3024         [TCA_HFSC_RSC] = {
3025             .type      = NL_A_UNSPEC,
3026             .optional  = false,
3027             .min_len   = sizeof(struct tc_service_curve),
3028         },
3029         [TCA_HFSC_FSC] = {
3030             .type      = NL_A_UNSPEC,
3031             .optional  = false,
3032             .min_len   = sizeof(struct tc_service_curve),
3033         },
3034         [TCA_HFSC_USC] = {
3035             .type      = NL_A_UNSPEC,
3036             .optional  = false,
3037             .min_len   = sizeof(struct tc_service_curve),
3038         },
3039     };
3040     struct nlattr *attrs[ARRAY_SIZE(tca_hfsc_policy)];
3041
3042     if (!nl_parse_nested(nl_options, tca_hfsc_policy,
3043                          attrs, ARRAY_SIZE(tca_hfsc_policy))) {
3044         VLOG_WARN_RL(&rl, "failed to parse HFSC class options");
3045         return EPROTO;
3046     }
3047
3048     rsc = nl_attr_get(attrs[TCA_HFSC_RSC]);
3049     fsc = nl_attr_get(attrs[TCA_HFSC_FSC]);
3050     usc = nl_attr_get(attrs[TCA_HFSC_USC]);
3051
3052     if (rsc->m1 != 0 || rsc->d != 0 ||
3053         fsc->m1 != 0 || fsc->d != 0 ||
3054         usc->m1 != 0 || usc->d != 0) {
3055         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3056                      "Non-linear service curves are not supported.");
3057         return EPROTO;
3058     }
3059
3060     if (rsc->m2 != fsc->m2) {
3061         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3062                      "Real-time service curves are not supported ");
3063         return EPROTO;
3064     }
3065
3066     if (rsc->m2 > usc->m2) {
3067         VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3068                      "Min-rate service curve is greater than "
3069                      "the max-rate service curve.");
3070         return EPROTO;
3071     }
3072
3073     class->min_rate = fsc->m2;
3074     class->max_rate = usc->m2;
3075     return 0;
3076 }
3077
3078 static int
3079 hfsc_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
3080                    struct hfsc_class *options,
3081                    struct netdev_queue_stats *stats)
3082 {
3083     int error;
3084     unsigned int handle;
3085     struct nlattr *nl_options;
3086
3087     error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
3088     if (error) {
3089         return error;
3090     }
3091
3092     if (queue_id) {
3093         unsigned int major, minor;
3094
3095         major = tc_get_major(handle);
3096         minor = tc_get_minor(handle);
3097         if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3098             *queue_id = minor - 1;
3099         } else {
3100             return EPROTO;
3101         }
3102     }
3103
3104     if (options) {
3105         error = hfsc_parse_tca_options__(nl_options, options);
3106     }
3107
3108     return error;
3109 }
3110
3111 static int
3112 hfsc_query_class__(const struct netdev *netdev, unsigned int handle,
3113                    unsigned int parent, struct hfsc_class *options,
3114                    struct netdev_queue_stats *stats)
3115 {
3116     int error;
3117     struct ofpbuf *reply;
3118
3119     error = tc_query_class(netdev, handle, parent, &reply);
3120     if (error) {
3121         return error;
3122     }
3123
3124     error = hfsc_parse_tcmsg__(reply, NULL, options, stats);
3125     ofpbuf_delete(reply);
3126     return error;
3127 }
3128
3129 static void
3130 hfsc_parse_qdisc_details__(struct netdev *netdev, const struct shash *details,
3131                            struct hfsc_class *class)
3132 {
3133     uint32_t max_rate;
3134     const char *max_rate_s;
3135
3136     max_rate_s = shash_find_data(details, "max-rate");
3137     max_rate   = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
3138
3139     if (!max_rate) {
3140         enum netdev_features current;
3141
3142         netdev_get_features(netdev, &current, NULL, NULL, NULL);
3143         max_rate = netdev_features_to_bps(current) / 8;
3144     }
3145
3146     class->min_rate = max_rate;
3147     class->max_rate = max_rate;
3148 }
3149
3150 static int
3151 hfsc_parse_class_details__(struct netdev *netdev,
3152                            const struct shash *details,
3153                            struct hfsc_class * class)
3154 {
3155     const struct hfsc *hfsc;
3156     uint32_t min_rate, max_rate;
3157     const char *min_rate_s, *max_rate_s;
3158
3159     hfsc       = hfsc_get__(netdev);
3160     min_rate_s = shash_find_data(details, "min-rate");
3161     max_rate_s = shash_find_data(details, "max-rate");
3162
3163     min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
3164     min_rate = MAX(min_rate, 1);
3165     min_rate = MIN(min_rate, hfsc->max_rate);
3166
3167     max_rate = (max_rate_s
3168                 ? strtoull(max_rate_s, NULL, 10) / 8
3169                 : hfsc->max_rate);
3170     max_rate = MAX(max_rate, min_rate);
3171     max_rate = MIN(max_rate, hfsc->max_rate);
3172
3173     class->min_rate = min_rate;
3174     class->max_rate = max_rate;
3175
3176     return 0;
3177 }
3178
3179 /* Create an HFSC qdisc.
3180  *
3181  * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
3182 static int
3183 hfsc_setup_qdisc__(struct netdev * netdev)
3184 {
3185     struct tcmsg *tcmsg;
3186     struct ofpbuf request;
3187     struct tc_hfsc_qopt opt;
3188
3189     tc_del_qdisc(netdev);
3190
3191     tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
3192                             NLM_F_EXCL | NLM_F_CREATE, &request);
3193
3194     if (!tcmsg) {
3195         return ENODEV;
3196     }
3197
3198     tcmsg->tcm_handle = tc_make_handle(1, 0);
3199     tcmsg->tcm_parent = TC_H_ROOT;
3200
3201     memset(&opt, 0, sizeof opt);
3202     opt.defcls = 1;
3203
3204     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3205     nl_msg_put_unspec(&request, TCA_OPTIONS, &opt, sizeof opt);
3206
3207     return tc_transact(&request, NULL);
3208 }
3209
3210 /* Create an HFSC class.
3211  *
3212  * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
3213  * sc rate <min_rate> ul rate <max_rate>" */
3214 static int
3215 hfsc_setup_class__(struct netdev *netdev, unsigned int handle,
3216                    unsigned int parent, struct hfsc_class *class)
3217 {
3218     int error;
3219     size_t opt_offset;
3220     struct tcmsg *tcmsg;
3221     struct ofpbuf request;
3222     struct tc_service_curve min, max;
3223
3224     tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
3225
3226     if (!tcmsg) {
3227         return ENODEV;
3228     }
3229
3230     tcmsg->tcm_handle = handle;
3231     tcmsg->tcm_parent = parent;
3232
3233     min.m1 = 0;
3234     min.d  = 0;
3235     min.m2 = class->min_rate;
3236
3237     max.m1 = 0;
3238     max.d  = 0;
3239     max.m2 = class->max_rate;
3240
3241     nl_msg_put_string(&request, TCA_KIND, "hfsc");
3242     opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3243     nl_msg_put_unspec(&request, TCA_HFSC_RSC, &min, sizeof min);
3244     nl_msg_put_unspec(&request, TCA_HFSC_FSC, &min, sizeof min);
3245     nl_msg_put_unspec(&request, TCA_HFSC_USC, &max, sizeof max);
3246     nl_msg_end_nested(&request, opt_offset);
3247
3248     error = tc_transact(&request, NULL);
3249     if (error) {
3250         VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
3251                      "min-rate %ubps, max-rate %ubps (%s)",
3252                      netdev_get_name(netdev),
3253                      tc_get_major(handle), tc_get_minor(handle),
3254                      tc_get_major(parent), tc_get_minor(parent),
3255                      class->min_rate, class->max_rate, strerror(error));
3256     }
3257
3258     return error;
3259 }
3260
3261 static int
3262 hfsc_tc_install(struct netdev *netdev, const struct shash *details)
3263 {
3264     int error;
3265     struct hfsc_class class;
3266
3267     error = hfsc_setup_qdisc__(netdev);
3268
3269     if (error) {
3270         return error;
3271     }
3272
3273     hfsc_parse_qdisc_details__(netdev, details, &class);
3274     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3275                                tc_make_handle(1, 0), &class);
3276
3277     if (error) {
3278         return error;
3279     }
3280
3281     hfsc_install__(netdev, class.max_rate);
3282     return 0;
3283 }
3284
3285 static int
3286 hfsc_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3287 {
3288     struct ofpbuf msg;
3289     struct nl_dump dump;
3290     struct hfsc_class hc;
3291
3292     hc.max_rate = 0;
3293     hfsc_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
3294     hfsc_install__(netdev, hc.max_rate);
3295
3296     if (!start_queue_dump(netdev, &dump)) {
3297         return ENODEV;
3298     }
3299
3300     while (nl_dump_next(&dump, &msg)) {
3301         unsigned int queue_id;
3302
3303         if (!hfsc_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
3304             hfsc_update_queue__(netdev, queue_id, &hc);
3305         }
3306     }
3307
3308     nl_dump_done(&dump);
3309     return 0;
3310 }
3311
3312 static void
3313 hfsc_tc_destroy(struct tc *tc)
3314 {
3315     struct hfsc *hfsc;
3316     struct hfsc_class *hc, *next;
3317
3318     hfsc = CONTAINER_OF(tc, struct hfsc, tc);
3319
3320     HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &hfsc->tc.queues) {
3321         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3322         free(hc);
3323     }
3324
3325     tc_destroy(tc);
3326     free(hfsc);
3327 }
3328
3329 static int
3330 hfsc_qdisc_get(const struct netdev *netdev, struct shash *details)
3331 {
3332     const struct hfsc *hfsc;
3333     hfsc = hfsc_get__(netdev);
3334     shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hfsc->max_rate));
3335     return 0;
3336 }
3337
3338 static int
3339 hfsc_qdisc_set(struct netdev *netdev, const struct shash *details)
3340 {
3341     int error;
3342     struct hfsc_class class;
3343
3344     hfsc_parse_qdisc_details__(netdev, details, &class);
3345     error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3346                                tc_make_handle(1, 0), &class);
3347
3348     if (!error) {
3349         hfsc_get__(netdev)->max_rate = class.max_rate;
3350     }
3351
3352     return error;
3353 }
3354
3355 static int
3356 hfsc_class_get(const struct netdev *netdev OVS_UNUSED,
3357               const struct tc_queue *queue, struct shash *details)
3358 {
3359     const struct hfsc_class *hc;
3360
3361     hc = hfsc_class_cast__(queue);
3362     shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
3363     if (hc->min_rate != hc->max_rate) {
3364         shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
3365     }
3366     return 0;
3367 }
3368
3369 static int
3370 hfsc_class_set(struct netdev *netdev, unsigned int queue_id,
3371                const struct shash *details)
3372 {
3373     int error;
3374     struct hfsc_class class;
3375
3376     error = hfsc_parse_class_details__(netdev, details, &class);
3377     if (error) {
3378         return error;
3379     }
3380
3381     error = hfsc_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3382                                tc_make_handle(1, 0xfffe), &class);
3383     if (error) {
3384         return error;
3385     }
3386
3387     hfsc_update_queue__(netdev, queue_id, &class);
3388     return 0;
3389 }
3390
3391 static int
3392 hfsc_class_delete(struct netdev *netdev, struct tc_queue *queue)
3393 {
3394     int error;
3395     struct hfsc *hfsc;
3396     struct hfsc_class *hc;
3397
3398     hc   = hfsc_class_cast__(queue);
3399     hfsc = hfsc_get__(netdev);
3400
3401     error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3402     if (!error) {
3403         hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3404         free(hc);
3405     }
3406     return error;
3407 }
3408
3409 static int
3410 hfsc_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3411                      struct netdev_queue_stats *stats)
3412 {
3413     return hfsc_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3414                              tc_make_handle(1, 0xfffe), NULL, stats);
3415 }
3416
3417 static int
3418 hfsc_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3419                       const struct ofpbuf *nlmsg,
3420                       netdev_dump_queue_stats_cb *cb, void *aux)
3421 {
3422     struct netdev_queue_stats stats;
3423     unsigned int handle, major, minor;
3424     int error;
3425
3426     error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3427     if (error) {
3428         return error;
3429     }
3430
3431     major = tc_get_major(handle);
3432     minor = tc_get_minor(handle);
3433     if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3434         (*cb)(minor - 1, &stats, aux);
3435     }
3436     return 0;
3437 }
3438
3439 static const struct tc_ops tc_ops_hfsc = {
3440     "hfsc",                     /* linux_name */
3441     "linux-hfsc",               /* ovs_name */
3442     HFSC_N_QUEUES,              /* n_queues */
3443     hfsc_tc_install,            /* tc_install */
3444     hfsc_tc_load,               /* tc_load */
3445     hfsc_tc_destroy,            /* tc_destroy */
3446     hfsc_qdisc_get,             /* qdisc_get */
3447     hfsc_qdisc_set,             /* qdisc_set */
3448     hfsc_class_get,             /* class_get */
3449     hfsc_class_set,             /* class_set */
3450     hfsc_class_delete,          /* class_delete */
3451     hfsc_class_get_stats,       /* class_get_stats */
3452     hfsc_class_dump_stats       /* class_dump_stats */
3453 };
3454 \f
3455 /* "linux-default" traffic control class.
3456  *
3457  * This class represents the default, unnamed Linux qdisc.  It corresponds to
3458  * the "" (empty string) QoS type in the OVS database. */
3459
3460 static void
3461 default_install__(struct netdev *netdev)
3462 {
3463     struct netdev_dev_linux *netdev_dev =
3464                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
3465     static struct tc *tc;
3466
3467     if (!tc) {
3468         tc = xmalloc(sizeof *tc);
3469         tc_init(tc, &tc_ops_default);
3470     }
3471     netdev_dev->tc = tc;
3472 }
3473
3474 static int
3475 default_tc_install(struct netdev *netdev,
3476                    const struct shash *details OVS_UNUSED)
3477 {
3478     default_install__(netdev);
3479     return 0;
3480 }
3481
3482 static int
3483 default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3484 {
3485     default_install__(netdev);
3486     return 0;
3487 }
3488
3489 static const struct tc_ops tc_ops_default = {
3490     NULL,                       /* linux_name */
3491     "",                         /* ovs_name */
3492     0,                          /* n_queues */
3493     default_tc_install,
3494     default_tc_load,
3495     NULL,                       /* tc_destroy */
3496     NULL,                       /* qdisc_get */
3497     NULL,                       /* qdisc_set */
3498     NULL,                       /* class_get */
3499     NULL,                       /* class_set */
3500     NULL,                       /* class_delete */
3501     NULL,                       /* class_get_stats */
3502     NULL                        /* class_dump_stats */
3503 };
3504 \f
3505 /* "linux-other" traffic control class.
3506  *
3507  * */
3508
3509 static int
3510 other_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3511 {
3512     struct netdev_dev_linux *netdev_dev =
3513                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
3514     static struct tc *tc;
3515
3516     if (!tc) {
3517         tc = xmalloc(sizeof *tc);
3518         tc_init(tc, &tc_ops_other);
3519     }
3520     netdev_dev->tc = tc;
3521     return 0;
3522 }
3523
3524 static const struct tc_ops tc_ops_other = {
3525     NULL,                       /* linux_name */
3526     "linux-other",              /* ovs_name */
3527     0,                          /* n_queues */
3528     NULL,                       /* tc_install */
3529     other_tc_load,
3530     NULL,                       /* tc_destroy */
3531     NULL,                       /* qdisc_get */
3532     NULL,                       /* qdisc_set */
3533     NULL,                       /* class_get */
3534     NULL,                       /* class_set */
3535     NULL,                       /* class_delete */
3536     NULL,                       /* class_get_stats */
3537     NULL                        /* class_dump_stats */
3538 };
3539 \f
3540 /* Traffic control. */
3541
3542 /* Number of kernel "tc" ticks per second. */
3543 static double ticks_per_s;
3544
3545 /* Number of kernel "jiffies" per second.  This is used for the purpose of
3546  * computing buffer sizes.  Generally kernel qdiscs need to be able to buffer
3547  * one jiffy's worth of data.
3548  *
3549  * There are two possibilities here:
3550  *
3551  *    - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3552  *      approximate range of 100 to 1024.  That means that we really need to
3553  *      make sure that the qdisc can buffer that much data.
3554  *
3555  *    - 'buffer_hz' is an absurdly large number.  That means that the kernel
3556  *      has finely granular timers and there's no need to fudge additional room
3557  *      for buffers.  (There's no extra effort needed to implement that: the
3558  *      large 'buffer_hz' is used as a divisor, so practically any number will
3559  *      come out as 0 in the division.  Small integer results in the case of
3560  *      really high dividends won't have any real effect anyhow.)
3561  */
3562 static unsigned int buffer_hz;
3563
3564 /* Returns tc handle 'major':'minor'. */
3565 static unsigned int
3566 tc_make_handle(unsigned int major, unsigned int minor)
3567 {
3568     return TC_H_MAKE(major << 16, minor);
3569 }
3570
3571 /* Returns the major number from 'handle'. */
3572 static unsigned int
3573 tc_get_major(unsigned int handle)
3574 {
3575     return TC_H_MAJ(handle) >> 16;
3576 }
3577
3578 /* Returns the minor number from 'handle'. */
3579 static unsigned int
3580 tc_get_minor(unsigned int handle)
3581 {
3582     return TC_H_MIN(handle);
3583 }
3584
3585 static struct tcmsg *
3586 tc_make_request(const struct netdev *netdev, int type, unsigned int flags,
3587                 struct ofpbuf *request)
3588 {
3589     struct tcmsg *tcmsg;
3590     int ifindex;
3591     int error;
3592
3593     error = get_ifindex(netdev, &ifindex);
3594     if (error) {
3595         return NULL;
3596     }
3597
3598     ofpbuf_init(request, 512);
3599     nl_msg_put_nlmsghdr(request, sizeof *tcmsg, type, NLM_F_REQUEST | flags);
3600     tcmsg = ofpbuf_put_zeros(request, sizeof *tcmsg);
3601     tcmsg->tcm_family = AF_UNSPEC;
3602     tcmsg->tcm_ifindex = ifindex;
3603     /* Caller should fill in tcmsg->tcm_handle. */
3604     /* Caller should fill in tcmsg->tcm_parent. */
3605
3606     return tcmsg;
3607 }
3608
3609 static int
3610 tc_transact(struct ofpbuf *request, struct ofpbuf **replyp)
3611 {
3612     int error = nl_sock_transact(rtnl_sock, request, replyp);
3613     ofpbuf_uninit(request);
3614     return error;
3615 }
3616
3617 /* Adds or deletes a root ingress qdisc on 'netdev'.  We use this for
3618  * policing configuration.
3619  *
3620  * This function is equivalent to running the following when 'add' is true:
3621  *     /sbin/tc qdisc add dev <devname> handle ffff: ingress
3622  *
3623  * This function is equivalent to running the following when 'add' is false:
3624  *     /sbin/tc qdisc del dev <devname> handle ffff: ingress
3625  *
3626  * The configuration and stats may be seen with the following command:
3627  *     /sbin/tc -s qdisc show dev <devname>
3628  *
3629  * Returns 0 if successful, otherwise a positive errno value.
3630  */
3631 static int
3632 tc_add_del_ingress_qdisc(struct netdev *netdev, bool add)
3633 {
3634     struct ofpbuf request;
3635     struct tcmsg *tcmsg;
3636     int error;
3637     int type = add ? RTM_NEWQDISC : RTM_DELQDISC;
3638     int flags = add ? NLM_F_EXCL | NLM_F_CREATE : 0;
3639
3640     tcmsg = tc_make_request(netdev, type, flags, &request);
3641     if (!tcmsg) {
3642         return ENODEV;
3643     }
3644     tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
3645     tcmsg->tcm_parent = TC_H_INGRESS;
3646     nl_msg_put_string(&request, TCA_KIND, "ingress");
3647     nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
3648
3649     error = tc_transact(&request, NULL);
3650     if (error) {
3651         /* If we're deleting the qdisc, don't worry about some of the
3652          * error conditions. */
3653         if (!add && (error == ENOENT || error == EINVAL)) {
3654             return 0;
3655         }
3656         return error;
3657     }
3658
3659     return 0;
3660 }
3661
3662 /* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
3663  * of 'kbits_burst'.
3664  *
3665  * This function is equivalent to running:
3666  *     /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
3667  *              basic police rate <kbits_rate>kbit burst <kbits_burst>k
3668  *              mtu 65535 drop
3669  *
3670  * The configuration and stats may be seen with the following command:
3671  *     /sbin/tc -s filter show <devname> eth0 parent ffff:
3672  *
3673  * Returns 0 if successful, otherwise a positive errno value.
3674  */
3675 static int
3676 tc_add_policer(struct netdev *netdev, int kbits_rate, int kbits_burst)
3677 {
3678     struct tc_police tc_police;
3679     struct ofpbuf request;
3680     struct tcmsg *tcmsg;
3681     size_t basic_offset;
3682     size_t police_offset;
3683     int error;
3684     int mtu = 65535;
3685
3686     memset(&tc_police, 0, sizeof tc_police);
3687     tc_police.action = TC_POLICE_SHOT;
3688     tc_police.mtu = mtu;
3689     tc_fill_rate(&tc_police.rate, kbits_rate/8 * 1000, mtu);
3690     tc_police.burst = tc_bytes_to_ticks(tc_police.rate.rate,
3691                                         kbits_burst * 1024);
3692
3693     tcmsg = tc_make_request(netdev, RTM_NEWTFILTER,
3694                             NLM_F_EXCL | NLM_F_CREATE, &request);
3695     if (!tcmsg) {
3696         return ENODEV;
3697     }
3698     tcmsg->tcm_parent = tc_make_handle(0xffff, 0);
3699     tcmsg->tcm_info = tc_make_handle(49,
3700                                      (OVS_FORCE uint16_t) htons(ETH_P_ALL));
3701
3702     nl_msg_put_string(&request, TCA_KIND, "basic");
3703     basic_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3704     police_offset = nl_msg_start_nested(&request, TCA_BASIC_POLICE);
3705     nl_msg_put_unspec(&request, TCA_POLICE_TBF, &tc_police, sizeof tc_police);
3706     tc_put_rtab(&request, TCA_POLICE_RATE, &tc_police.rate);
3707     nl_msg_end_nested(&request, police_offset);
3708     nl_msg_end_nested(&request, basic_offset);
3709
3710     error = tc_transact(&request, NULL);
3711     if (error) {
3712         return error;
3713     }
3714
3715     return 0;
3716 }
3717
3718 static void
3719 read_psched(void)
3720 {
3721     /* The values in psched are not individually very meaningful, but they are
3722      * important.  The tables below show some values seen in the wild.
3723      *
3724      * Some notes:
3725      *
3726      *   - "c" has always been a constant 1000000 since at least Linux 2.4.14.
3727      *     (Before that, there are hints that it was 1000000000.)
3728      *
3729      *   - "d" can be unrealistically large, see the comment on 'buffer_hz'
3730      *     above.
3731      *
3732      *                        /proc/net/psched
3733      *     -----------------------------------
3734      * [1] 000c8000 000f4240 000f4240 00000064
3735      * [2] 000003e8 00000400 000f4240 3b9aca00
3736      * [3] 000003e8 00000400 000f4240 3b9aca00
3737      * [4] 000003e8 00000400 000f4240 00000064
3738      * [5] 000003e8 00000040 000f4240 3b9aca00
3739      * [6] 000003e8 00000040 000f4240 000000f9
3740      *
3741      *           a         b          c             d ticks_per_s     buffer_hz
3742      *     ------- --------- ---------- ------------- ----------- -------------
3743      * [1] 819,200 1,000,000  1,000,000           100     819,200           100
3744      * [2]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3745      * [3]   1,000     1,024  1,000,000 1,000,000,000     976,562 1,000,000,000
3746      * [4]   1,000     1,024  1,000,000           100     976,562           100
3747      * [5]   1,000        64  1,000,000 1,000,000,000  15,625,000 1,000,000,000
3748      * [6]   1,000        64  1,000,000           249  15,625,000           249
3749      *
3750      * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
3751      * [2] 2.6.26-1-686-bigmem from Debian lenny
3752      * [3] 2.6.26-2-sparc64 from Debian lenny
3753      * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
3754      * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
3755      * [6] 2.6.34 from kernel.org on KVM
3756      */
3757     static const char fn[] = "/proc/net/psched";
3758     unsigned int a, b, c, d;
3759     FILE *stream;
3760
3761     ticks_per_s = 1.0;
3762     buffer_hz = 100;
3763
3764     stream = fopen(fn, "r");
3765     if (!stream) {
3766         VLOG_WARN("%s: open failed: %s", fn, strerror(errno));
3767         return;
3768     }
3769
3770     if (fscanf(stream, "%x %x %x %x", &a, &b, &c, &d) != 4) {
3771         VLOG_WARN("%s: read failed", fn);
3772         fclose(stream);
3773         return;
3774     }
3775     VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn, a, b, c, d);
3776     fclose(stream);
3777
3778     if (!a || !c) {
3779         VLOG_WARN("%s: invalid scheduler parameters", fn);
3780         return;
3781     }
3782
3783     ticks_per_s = (double) a * c / b;
3784     if (c == 1000000) {
3785         buffer_hz = d;
3786     } else {
3787         VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
3788                   fn, a, b, c, d);
3789     }
3790     VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn, ticks_per_s, buffer_hz);
3791 }
3792
3793 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
3794  * rate of 'rate' bytes per second. */
3795 static unsigned int
3796 tc_ticks_to_bytes(unsigned int rate, unsigned int ticks)
3797 {
3798     if (!buffer_hz) {
3799         read_psched();
3800     }
3801     return (rate * ticks) / ticks_per_s;
3802 }
3803
3804 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
3805  * rate of 'rate' bytes per second. */
3806 static unsigned int
3807 tc_bytes_to_ticks(unsigned int rate, unsigned int size)
3808 {
3809     if (!buffer_hz) {
3810         read_psched();
3811     }
3812     return rate ? ((unsigned long long int) ticks_per_s * size) / rate : 0;
3813 }
3814
3815 /* Returns the number of bytes that need to be reserved for qdisc buffering at
3816  * a transmission rate of 'rate' bytes per second. */
3817 static unsigned int
3818 tc_buffer_per_jiffy(unsigned int rate)
3819 {
3820     if (!buffer_hz) {
3821         read_psched();
3822     }
3823     return rate / buffer_hz;
3824 }
3825
3826 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
3827  * e.g. "htb", into '*kind' (if it is nonnull).  If 'options' is nonnull,
3828  * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
3829  * stores NULL into it if it is absent.
3830  *
3831  * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
3832  * 'msg'.
3833  *
3834  * Returns 0 if successful, otherwise a positive errno value. */
3835 static int
3836 tc_parse_qdisc(const struct ofpbuf *msg, const char **kind,
3837                struct nlattr **options)
3838 {
3839     static const struct nl_policy tca_policy[] = {
3840         [TCA_KIND] = { .type = NL_A_STRING, .optional = false },
3841         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
3842     };
3843     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3844
3845     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3846                          tca_policy, ta, ARRAY_SIZE(ta))) {
3847         VLOG_WARN_RL(&rl, "failed to parse qdisc message");
3848         goto error;
3849     }
3850
3851     if (kind) {
3852         *kind = nl_attr_get_string(ta[TCA_KIND]);
3853     }
3854
3855     if (options) {
3856         *options = ta[TCA_OPTIONS];
3857     }
3858
3859     return 0;
3860
3861 error:
3862     if (kind) {
3863         *kind = NULL;
3864     }
3865     if (options) {
3866         *options = NULL;
3867     }
3868     return EPROTO;
3869 }
3870
3871 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
3872  * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
3873  * into '*options', and its queue statistics into '*stats'.  Any of the output
3874  * arguments may be null.
3875  *
3876  * Returns 0 if successful, otherwise a positive errno value. */
3877 static int
3878 tc_parse_class(const struct ofpbuf *msg, unsigned int *handlep,
3879                struct nlattr **options, struct netdev_queue_stats *stats)
3880 {
3881     static const struct nl_policy tca_policy[] = {
3882         [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = false },
3883         [TCA_STATS2] = { .type = NL_A_NESTED, .optional = false },
3884     };
3885     struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3886
3887     if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3888                          tca_policy, ta, ARRAY_SIZE(ta))) {
3889         VLOG_WARN_RL(&rl, "failed to parse class message");
3890         goto error;
3891     }
3892
3893     if (handlep) {
3894         struct tcmsg *tc = ofpbuf_at_assert(msg, NLMSG_HDRLEN, sizeof *tc);
3895         *handlep = tc->tcm_handle;
3896     }
3897
3898     if (options) {
3899         *options = ta[TCA_OPTIONS];
3900     }
3901
3902     if (stats) {
3903         const struct gnet_stats_queue *gsq;
3904         struct gnet_stats_basic gsb;
3905
3906         static const struct nl_policy stats_policy[] = {
3907             [TCA_STATS_BASIC] = { .type = NL_A_UNSPEC, .optional = false,
3908                                   .min_len = sizeof gsb },
3909             [TCA_STATS_QUEUE] = { .type = NL_A_UNSPEC, .optional = false,
3910                                   .min_len = sizeof *gsq },
3911         };
3912         struct nlattr *sa[ARRAY_SIZE(stats_policy)];
3913
3914         if (!nl_parse_nested(ta[TCA_STATS2], stats_policy,
3915                              sa, ARRAY_SIZE(sa))) {
3916             VLOG_WARN_RL(&rl, "failed to parse class stats");
3917             goto error;
3918         }
3919
3920         /* Alignment issues screw up the length of struct gnet_stats_basic on
3921          * some arch/bitsize combinations.  Newer versions of Linux have a
3922          * struct gnet_stats_basic_packed, but we can't depend on that.  The
3923          * easiest thing to do is just to make a copy. */
3924         memset(&gsb, 0, sizeof gsb);
3925         memcpy(&gsb, nl_attr_get(sa[TCA_STATS_BASIC]),
3926                MIN(nl_attr_get_size(sa[TCA_STATS_BASIC]), sizeof gsb));
3927         stats->tx_bytes = gsb.bytes;
3928         stats->tx_packets = gsb.packets;
3929
3930         gsq = nl_attr_get(sa[TCA_STATS_QUEUE]);
3931         stats->tx_errors = gsq->drops;
3932     }
3933
3934     return 0;
3935
3936 error:
3937     if (options) {
3938         *options = NULL;
3939     }
3940     if (stats) {
3941         memset(stats, 0, sizeof *stats);
3942     }
3943     return EPROTO;
3944 }
3945
3946 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
3947  * on 'netdev'. */
3948 static int
3949 tc_query_class(const struct netdev *netdev,
3950                unsigned int handle, unsigned int parent,
3951                struct ofpbuf **replyp)
3952 {
3953     struct ofpbuf request;
3954     struct tcmsg *tcmsg;
3955     int error;
3956
3957     tcmsg = tc_make_request(netdev, RTM_GETTCLASS, NLM_F_ECHO, &request);
3958     if (!tcmsg) {
3959         return ENODEV;
3960     }
3961     tcmsg->tcm_handle = handle;
3962     tcmsg->tcm_parent = parent;
3963
3964     error = tc_transact(&request, replyp);
3965     if (error) {
3966         VLOG_WARN_RL(&rl, "query %s class %u:%u (parent %u:%u) failed (%s)",
3967                      netdev_get_name(netdev),
3968                      tc_get_major(handle), tc_get_minor(handle),
3969                      tc_get_major(parent), tc_get_minor(parent),
3970                      strerror(error));
3971     }
3972     return error;
3973 }
3974
3975 /* Equivalent to "tc class del dev <name> handle <handle>". */
3976 static int
3977 tc_delete_class(const struct netdev *netdev, unsigned int handle)
3978 {
3979     struct ofpbuf request;
3980     struct tcmsg *tcmsg;
3981     int error;
3982
3983     tcmsg = tc_make_request(netdev, RTM_DELTCLASS, 0, &request);
3984     if (!tcmsg) {
3985         return ENODEV;
3986     }
3987     tcmsg->tcm_handle = handle;
3988     tcmsg->tcm_parent = 0;
3989
3990     error = tc_transact(&request, NULL);
3991     if (error) {
3992         VLOG_WARN_RL(&rl, "delete %s class %u:%u failed (%s)",
3993                      netdev_get_name(netdev),
3994                      tc_get_major(handle), tc_get_minor(handle),
3995                      strerror(error));
3996     }
3997     return error;
3998 }
3999
4000 /* Equivalent to "tc qdisc del dev <name> root". */
4001 static int
4002 tc_del_qdisc(struct netdev *netdev)
4003 {
4004     struct netdev_dev_linux *netdev_dev =
4005                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
4006     struct ofpbuf request;
4007     struct tcmsg *tcmsg;
4008     int error;
4009
4010     tcmsg = tc_make_request(netdev, RTM_DELQDISC, 0, &request);
4011     if (!tcmsg) {
4012         return ENODEV;
4013     }
4014     tcmsg->tcm_handle = tc_make_handle(1, 0);
4015     tcmsg->tcm_parent = TC_H_ROOT;
4016
4017     error = tc_transact(&request, NULL);
4018     if (error == EINVAL) {
4019         /* EINVAL probably means that the default qdisc was in use, in which
4020          * case we've accomplished our purpose. */
4021         error = 0;
4022     }
4023     if (!error && netdev_dev->tc) {
4024         if (netdev_dev->tc->ops->tc_destroy) {
4025             netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
4026         }
4027         netdev_dev->tc = NULL;
4028     }
4029     return error;
4030 }
4031
4032 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
4033  * kernel to determine what they are.  Returns 0 if successful, otherwise a
4034  * positive errno value. */
4035 static int
4036 tc_query_qdisc(const struct netdev *netdev)
4037 {
4038     struct netdev_dev_linux *netdev_dev =
4039                                 netdev_dev_linux_cast(netdev_get_dev(netdev));
4040     struct ofpbuf request, *qdisc;
4041     const struct tc_ops *ops;
4042     struct tcmsg *tcmsg;
4043     int load_error;
4044     int error;
4045
4046     if (netdev_dev->tc) {
4047         return 0;
4048     }
4049
4050     /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
4051      * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
4052      * 2.6.35 without that fix backported to it.
4053      *
4054      * To avoid the OOPS, we must not make a request that would attempt to dump
4055      * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
4056      * few others.  There are a few ways that I can see to do this, but most of
4057      * them seem to be racy (and if you lose the race the kernel OOPSes).  The
4058      * technique chosen here is to assume that any non-default qdisc that we
4059      * create will have a class with handle 1:0.  The built-in qdiscs only have
4060      * a class with handle 0:0.
4061      *
4062      * We could check for Linux 2.6.35+ and use a more straightforward method
4063      * there. */
4064     tcmsg = tc_make_request(netdev, RTM_GETQDISC, NLM_F_ECHO, &request);
4065     if (!tcmsg) {
4066         return ENODEV;
4067     }
4068     tcmsg->tcm_handle = tc_make_handle(1, 0);
4069     tcmsg->tcm_parent = 0;
4070
4071     /* Figure out what tc class to instantiate. */
4072     error = tc_transact(&request, &qdisc);
4073     if (!error) {
4074         const char *kind;
4075
4076         error = tc_parse_qdisc(qdisc, &kind, NULL);
4077         if (error) {
4078             ops = &tc_ops_other;
4079         } else {
4080             ops = tc_lookup_linux_name(kind);
4081             if (!ops) {
4082                 static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 1);
4083                 VLOG_INFO_RL(&rl2, "unknown qdisc \"%s\"", kind);
4084
4085                 ops = &tc_ops_other;
4086             }
4087         }
4088     } else if (error == ENOENT) {
4089         /* Either it's a built-in qdisc, or it's a qdisc set up by some
4090          * other entity that doesn't have a handle 1:0.  We will assume
4091          * that it's the system default qdisc. */
4092         ops = &tc_ops_default;
4093         error = 0;
4094     } else {
4095         /* Who knows?  Maybe the device got deleted. */
4096         VLOG_WARN_RL(&rl, "query %s qdisc failed (%s)",
4097                      netdev_get_name(netdev), strerror(error));
4098         ops = &tc_ops_other;
4099     }
4100
4101     /* Instantiate it. */
4102     load_error = ops->tc_load((struct netdev *) netdev, qdisc);
4103     assert((load_error == 0) == (netdev_dev->tc != NULL));
4104     ofpbuf_delete(qdisc);
4105
4106     return error ? error : load_error;
4107 }
4108
4109 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
4110    approximate the time to transmit packets of various lengths.  For an MTU of
4111    256 or less, each entry is exact; for an MTU of 257 through 512, each entry
4112    represents two possible packet lengths; for a MTU of 513 through 1024, four
4113    possible lengths; and so on.
4114
4115    Returns, for the specified 'mtu', the number of bits that packet lengths
4116    need to be shifted right to fit within such a 256-entry table. */
4117 static int
4118 tc_calc_cell_log(unsigned int mtu)
4119 {
4120     int cell_log;
4121
4122     if (!mtu) {
4123         mtu = ETH_PAYLOAD_MAX;
4124     }
4125     mtu += ETH_HEADER_LEN + VLAN_HEADER_LEN;
4126
4127     for (cell_log = 0; mtu >= 256; cell_log++) {
4128         mtu >>= 1;
4129     }
4130
4131     return cell_log;
4132 }
4133
4134 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
4135  * of 'mtu'. */
4136 static void
4137 tc_fill_rate(struct tc_ratespec *rate, uint64_t Bps, int mtu)
4138 {
4139     memset(rate, 0, sizeof *rate);
4140     rate->cell_log = tc_calc_cell_log(mtu);
4141     /* rate->overhead = 0; */           /* New in 2.6.24, not yet in some */
4142     /* rate->cell_align = 0; */         /* distro headers. */
4143     rate->mpu = ETH_TOTAL_MIN;
4144     rate->rate = Bps;
4145 }
4146
4147 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
4148  * attribute of the specified "type".
4149  *
4150  * See tc_calc_cell_log() above for a description of "rtab"s. */
4151 static void
4152 tc_put_rtab(struct ofpbuf *msg, uint16_t type, const struct tc_ratespec *rate)
4153 {
4154     uint32_t *rtab;
4155     unsigned int i;
4156
4157     rtab = nl_msg_put_unspec_uninit(msg, type, TC_RTAB_SIZE);
4158     for (i = 0; i < TC_RTAB_SIZE / sizeof *rtab; i++) {
4159         unsigned packet_size = (i + 1) << rate->cell_log;
4160         if (packet_size < rate->mpu) {
4161             packet_size = rate->mpu;
4162         }
4163         rtab[i] = tc_bytes_to_ticks(rate->rate, packet_size);
4164     }
4165 }
4166
4167 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
4168  * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
4169  * burst size of 'burst_bytes'.  (If no value was requested, a 'burst_bytes' of
4170  * 0 is fine.) */
4171 static int
4172 tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes)
4173 {
4174     unsigned int min_burst = tc_buffer_per_jiffy(Bps) + mtu;
4175     return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
4176 }
4177 \f
4178 /* Linux-only functions declared in netdev-linux.h  */
4179
4180 /* Returns a fd for an AF_INET socket or a negative errno value. */
4181 int
4182 netdev_linux_get_af_inet_sock(void)
4183 {
4184     int error = netdev_linux_init();
4185     return error ? -error : af_inet_sock;
4186 }
4187
4188 /* Modifies the 'flag' bit in ethtool's flags field for 'netdev'.  If
4189  * 'enable' is true, the bit is set.  Otherwise, it is cleared. */
4190 int
4191 netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag,
4192                               const char *flag_name, bool enable)
4193 {
4194     const char *netdev_name = netdev_get_name(netdev);
4195     struct ethtool_value evalue;
4196     uint32_t new_flags;
4197     int error;
4198
4199     memset(&evalue, 0, sizeof evalue);
4200     error = netdev_linux_do_ethtool(netdev_name,
4201                                     (struct ethtool_cmd *)&evalue,
4202                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4203     if (error) {
4204         return error;
4205     }
4206
4207     evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0);
4208     error = netdev_linux_do_ethtool(netdev_name,
4209                                     (struct ethtool_cmd *)&evalue,
4210                                     ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS");
4211     if (error) {
4212         return error;
4213     }
4214
4215     memset(&evalue, 0, sizeof evalue);
4216     error = netdev_linux_do_ethtool(netdev_name,
4217                                     (struct ethtool_cmd *)&evalue,
4218                                     ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4219     if (error) {
4220         return error;
4221     }
4222
4223     if (new_flags != evalue.data) {
4224         VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network "
4225                      "device %s failed", enable ? "enable" : "disable",
4226                      flag_name, netdev_name);
4227         return EOPNOTSUPP;
4228     }
4229
4230     return 0;
4231 }
4232 \f
4233 /* Utility functions. */
4234
4235 /* Copies 'src' into 'dst', performing format conversion in the process. */
4236 static void
4237 netdev_stats_from_rtnl_link_stats(struct netdev_stats *dst,
4238                                   const struct rtnl_link_stats *src)
4239 {
4240     dst->rx_packets = src->rx_packets;
4241     dst->tx_packets = src->tx_packets;
4242     dst->rx_bytes = src->rx_bytes;
4243     dst->tx_bytes = src->tx_bytes;
4244     dst->rx_errors = src->rx_errors;
4245     dst->tx_errors = src->tx_errors;
4246     dst->rx_dropped = src->rx_dropped;
4247     dst->tx_dropped = src->tx_dropped;
4248     dst->multicast = src->multicast;
4249     dst->collisions = src->collisions;
4250     dst->rx_length_errors = src->rx_length_errors;
4251     dst->rx_over_errors = src->rx_over_errors;
4252     dst->rx_crc_errors = src->rx_crc_errors;
4253     dst->rx_frame_errors = src->rx_frame_errors;
4254     dst->rx_fifo_errors = src->rx_fifo_errors;
4255     dst->rx_missed_errors = src->rx_missed_errors;
4256     dst->tx_aborted_errors = src->tx_aborted_errors;
4257     dst->tx_carrier_errors = src->tx_carrier_errors;
4258     dst->tx_fifo_errors = src->tx_fifo_errors;
4259     dst->tx_heartbeat_errors = src->tx_heartbeat_errors;
4260     dst->tx_window_errors = src->tx_window_errors;
4261 }
4262
4263 static int
4264 get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
4265 {
4266     /* Policy for RTNLGRP_LINK messages.
4267      *
4268      * There are *many* more fields in these messages, but currently we only
4269      * care about these fields. */
4270     static const struct nl_policy rtnlgrp_link_policy[] = {
4271         [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
4272         [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
4273                          .min_len = sizeof(struct rtnl_link_stats) },
4274     };
4275
4276     struct ofpbuf request;
4277     struct ofpbuf *reply;
4278     struct ifinfomsg *ifi;
4279     struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
4280     int error;
4281
4282     ofpbuf_init(&request, 0);
4283     nl_msg_put_nlmsghdr(&request, sizeof *ifi, RTM_GETLINK, NLM_F_REQUEST);
4284     ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
4285     ifi->ifi_family = PF_UNSPEC;
4286     ifi->ifi_index = ifindex;
4287     error = nl_sock_transact(rtnl_sock, &request, &reply);
4288     ofpbuf_uninit(&request);
4289     if (error) {
4290         return error;
4291     }
4292
4293     if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
4294                          rtnlgrp_link_policy,
4295                          attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
4296         ofpbuf_delete(reply);
4297         return EPROTO;
4298     }
4299
4300     if (!attrs[IFLA_STATS]) {
4301         VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
4302         ofpbuf_delete(reply);
4303         return EPROTO;
4304     }
4305
4306     netdev_stats_from_rtnl_link_stats(stats, nl_attr_get(attrs[IFLA_STATS]));
4307
4308     ofpbuf_delete(reply);
4309
4310     return 0;
4311 }
4312
4313 static int
4314 get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
4315 {
4316     static const char fn[] = "/proc/net/dev";
4317     char line[1024];
4318     FILE *stream;
4319     int ln;
4320
4321     stream = fopen(fn, "r");
4322     if (!stream) {
4323         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
4324         return errno;
4325     }
4326
4327     ln = 0;
4328     while (fgets(line, sizeof line, stream)) {
4329         if (++ln >= 3) {
4330             char devname[16];
4331 #define X64 "%"SCNu64
4332             if (sscanf(line,
4333                        " %15[^:]:"
4334                        X64 X64 X64 X64 X64 X64 X64 "%*u"
4335                        X64 X64 X64 X64 X64 X64 X64 "%*u",
4336                        devname,
4337                        &stats->rx_bytes,
4338                        &stats->rx_packets,
4339                        &stats->rx_errors,
4340                        &stats->rx_dropped,
4341                        &stats->rx_fifo_errors,
4342                        &stats->rx_frame_errors,
4343                        &stats->multicast,
4344                        &stats->tx_bytes,
4345                        &stats->tx_packets,
4346                        &stats->tx_errors,
4347                        &stats->tx_dropped,
4348                        &stats->tx_fifo_errors,
4349                        &stats->collisions,
4350                        &stats->tx_carrier_errors) != 15) {
4351                 VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
4352             } else if (!strcmp(devname, netdev_name)) {
4353                 stats->rx_length_errors = UINT64_MAX;
4354                 stats->rx_over_errors = UINT64_MAX;
4355                 stats->rx_crc_errors = UINT64_MAX;
4356                 stats->rx_missed_errors = UINT64_MAX;
4357                 stats->tx_aborted_errors = UINT64_MAX;
4358                 stats->tx_heartbeat_errors = UINT64_MAX;
4359                 stats->tx_window_errors = UINT64_MAX;
4360                 fclose(stream);
4361                 return 0;
4362             }
4363         }
4364     }
4365     VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
4366     fclose(stream);
4367     return ENODEV;
4368 }
4369
4370 static int
4371 get_flags(const struct netdev_dev *dev, unsigned int *flags)
4372 {
4373     struct ifreq ifr;
4374     int error;
4375
4376     *flags = 0;
4377     error = netdev_linux_do_ioctl(dev->name, &ifr, SIOCGIFFLAGS,
4378                                   "SIOCGIFFLAGS");
4379     if (!error) {
4380         *flags = ifr.ifr_flags;
4381     }
4382     return error;
4383 }
4384
4385 static int
4386 set_flags(struct netdev *netdev, unsigned int flags)
4387 {
4388     struct ifreq ifr;
4389
4390     ifr.ifr_flags = flags;
4391     return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCSIFFLAGS,
4392                                  "SIOCSIFFLAGS");
4393 }
4394
4395 static int
4396 do_get_ifindex(const char *netdev_name)
4397 {
4398     struct ifreq ifr;
4399
4400     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4401     COVERAGE_INC(netdev_get_ifindex);
4402     if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
4403         VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
4404                      netdev_name, strerror(errno));
4405         return -errno;
4406     }
4407     return ifr.ifr_ifindex;
4408 }
4409
4410 static int
4411 get_ifindex(const struct netdev *netdev_, int *ifindexp)
4412 {
4413     struct netdev_dev_linux *netdev_dev =
4414                                 netdev_dev_linux_cast(netdev_get_dev(netdev_));
4415
4416     if (!(netdev_dev->cache_valid & VALID_IFINDEX)) {
4417         int ifindex = do_get_ifindex(netdev_get_name(netdev_));
4418
4419         if (ifindex < 0) {
4420             netdev_dev->get_ifindex_error = -ifindex;
4421             netdev_dev->ifindex = 0;
4422         } else {
4423             netdev_dev->get_ifindex_error = 0;
4424             netdev_dev->ifindex = ifindex;
4425         }
4426         netdev_dev->cache_valid |= VALID_IFINDEX;
4427     }
4428
4429     *ifindexp = netdev_dev->ifindex;
4430     return netdev_dev->get_ifindex_error;
4431 }
4432
4433 static int
4434 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
4435 {
4436     struct ifreq ifr;
4437     int hwaddr_family;
4438
4439     memset(&ifr, 0, sizeof ifr);
4440     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4441     COVERAGE_INC(netdev_get_hwaddr);
4442     if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
4443         /* ENODEV probably means that a vif disappeared asynchronously and
4444          * hasn't been removed from the database yet, so reduce the log level
4445          * to INFO for that case. */
4446         VLOG(errno == ENODEV ? VLL_INFO : VLL_ERR,
4447              "ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4448              netdev_name, strerror(errno));
4449         return errno;
4450     }
4451     hwaddr_family = ifr.ifr_hwaddr.sa_family;
4452     if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
4453         VLOG_WARN("%s device has unknown hardware address family %d",
4454                   netdev_name, hwaddr_family);
4455     }
4456     memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
4457     return 0;
4458 }
4459
4460 static int
4461 set_etheraddr(const char *netdev_name,
4462               const uint8_t mac[ETH_ADDR_LEN])
4463 {
4464     struct ifreq ifr;
4465
4466     memset(&ifr, 0, sizeof ifr);
4467     ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4468     ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
4469     memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
4470     COVERAGE_INC(netdev_set_hwaddr);
4471     if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
4472         VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4473                  netdev_name, strerror(errno));
4474         return errno;
4475     }
4476     return 0;
4477 }
4478
4479 static int
4480 netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd,
4481                         int cmd, const char *cmd_name)
4482 {
4483     struct ifreq ifr;
4484
4485     memset(&ifr, 0, sizeof ifr);
4486     ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
4487     ifr.ifr_data = (caddr_t) ecmd;
4488
4489     ecmd->cmd = cmd;
4490     COVERAGE_INC(netdev_ethtool);
4491     if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) {
4492         return 0;
4493     } else {
4494         if (errno != EOPNOTSUPP) {
4495             VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
4496                          "failed: %s", cmd_name, name, strerror(errno));
4497         } else {
4498             /* The device doesn't support this operation.  That's pretty
4499              * common, so there's no point in logging anything. */
4500         }
4501         return errno;
4502     }
4503 }
4504
4505 static int
4506 netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd,
4507                       const char *cmd_name)
4508 {
4509     ovs_strzcpy(ifr->ifr_name, name, sizeof ifr->ifr_name);
4510     if (ioctl(af_inet_sock, cmd, ifr) == -1) {
4511         VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", name, cmd_name,
4512                      strerror(errno));
4513         return errno;
4514     }
4515     return 0;
4516 }
4517
4518 static int
4519 netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
4520                       int cmd, const char *cmd_name)
4521 {
4522     struct ifreq ifr;
4523     int error;
4524
4525     ifr.ifr_addr.sa_family = AF_INET;
4526     error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name);
4527     if (!error) {
4528         const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
4529         *ip = sin->sin_addr;
4530     }
4531     return error;
4532 }
4533
4534 /* Returns an AF_PACKET raw socket or a negative errno value. */
4535 static int
4536 af_packet_sock(void)
4537 {
4538     static int sock = INT_MIN;
4539
4540     if (sock == INT_MIN) {
4541         sock = socket(AF_PACKET, SOCK_RAW, 0);
4542         if (sock >= 0) {
4543             set_nonblocking(sock);
4544         } else {
4545             sock = -errno;
4546             VLOG_ERR("failed to create packet socket: %s", strerror(errno));
4547         }
4548     }
4549
4550     return sock;
4551 }