lib/netdev-linux.c

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