lib/netdev-linux.c

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