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