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