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