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