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