2 * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include "netdev-linux.h"
23 #include <arpa/inet.h>
25 #include <linux/filter.h>
26 #include <linux/gen_stats.h>
27 #include <linux/if_ether.h>
28 #include <linux/if_tun.h>
29 #include <linux/types.h>
30 #include <linux/ethtool.h>
31 #include <linux/mii.h>
32 #include <linux/pkt_cls.h>
33 #include <linux/pkt_sched.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/sockios.h>
36 #include <linux/version.h>
37 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/socket.h>
40 #include <netpacket/packet.h>
42 #include <net/if_arp.h>
43 #include <net/if_packet.h>
44 #include <net/route.h>
45 #include <netinet/in.h>
52 #include "dpif-linux.h"
53 #include "dynamic-string.h"
54 #include "fatal-signal.h"
57 #include "netdev-provider.h"
58 #include "netdev-vport.h"
59 #include "netlink-notifier.h"
60 #include "netlink-socket.h"
63 #include "openflow/openflow.h"
65 #include "poll-loop.h"
66 #include "rtnetlink-link.h"
68 #include "socket-util.h"
71 #include "unaligned.h"
74 VLOG_DEFINE_THIS_MODULE(netdev_linux);
76 COVERAGE_DEFINE(netdev_set_policing);
77 COVERAGE_DEFINE(netdev_arp_lookup);
78 COVERAGE_DEFINE(netdev_get_ifindex);
79 COVERAGE_DEFINE(netdev_get_hwaddr);
80 COVERAGE_DEFINE(netdev_set_hwaddr);
81 COVERAGE_DEFINE(netdev_get_ethtool);
82 COVERAGE_DEFINE(netdev_set_ethtool);
85 /* These were introduced in Linux 2.6.14, so they might be missing if we have
87 #ifndef ADVERTISED_Pause
88 #define ADVERTISED_Pause (1 << 13)
90 #ifndef ADVERTISED_Asym_Pause
91 #define ADVERTISED_Asym_Pause (1 << 14)
94 /* These were introduced in Linux 2.6.24, so they might be missing if we
95 * have old headers. */
96 #ifndef ETHTOOL_GFLAGS
97 #define ETHTOOL_GFLAGS 0x00000025 /* Get flags bitmap(ethtool_value) */
99 #ifndef ETHTOOL_SFLAGS
100 #define ETHTOOL_SFLAGS 0x00000026 /* Set flags bitmap(ethtool_value) */
103 /* This was introduced in Linux 2.6.25, so it might be missing if we have old
106 #define TC_RTAB_SIZE 1024
109 static struct nln_notifier *netdev_linux_cache_notifier = NULL;
110 static int cache_notifier_refcount;
113 VALID_IFINDEX = 1 << 0,
114 VALID_ETHERADDR = 1 << 1,
118 VALID_POLICING = 1 << 5,
119 VALID_VPORT_STAT_ERROR = 1 << 6,
120 VALID_DRVINFO = 1 << 7,
121 VALID_FEATURES = 1 << 8,
128 /* Traffic control. */
130 /* An instance of a traffic control class. Always associated with a particular
133 * Each TC implementation subclasses this with whatever additional data it
136 const struct tc_ops *ops;
137 struct hmap queues; /* Contains "struct tc_queue"s.
138 * Read by generic TC layer.
139 * Written only by TC implementation. */
142 #define TC_INITIALIZER(TC, OPS) { OPS, HMAP_INITIALIZER(&(TC)->queues) }
144 /* One traffic control queue.
146 * Each TC implementation subclasses this with whatever additional data it
149 struct hmap_node hmap_node; /* In struct tc's "queues" hmap. */
150 unsigned int queue_id; /* OpenFlow queue ID. */
151 long long int created; /* Time queue was created, in msecs. */
154 /* A particular kind of traffic control. Each implementation generally maps to
155 * one particular Linux qdisc class.
157 * The functions below return 0 if successful or a positive errno value on
158 * failure, except where otherwise noted. All of them must be provided, except
159 * where otherwise noted. */
161 /* Name used by kernel in the TCA_KIND attribute of tcmsg, e.g. "htb".
162 * This is null for tc_ops_default and tc_ops_other, for which there are no
163 * appropriate values. */
164 const char *linux_name;
166 /* Name used in OVS database, e.g. "linux-htb". Must be nonnull. */
167 const char *ovs_name;
169 /* Number of supported OpenFlow queues, 0 for qdiscs that have no
170 * queues. The queues are numbered 0 through n_queues - 1. */
171 unsigned int n_queues;
173 /* Called to install this TC class on 'netdev'. The implementation should
174 * make the Netlink calls required to set up 'netdev' with the right qdisc
175 * and configure it according to 'details'. The implementation may assume
176 * that the current qdisc is the default; that is, there is no need for it
177 * to delete the current qdisc before installing itself.
179 * The contents of 'details' should be documented as valid for 'ovs_name'
180 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
181 * (which is built as ovs-vswitchd.conf.db(8)).
183 * This function must return 0 if and only if it sets 'netdev->tc' to an
184 * initialized 'struct tc'.
186 * (This function is null for tc_ops_other, which cannot be installed. For
187 * other TC classes it should always be nonnull.) */
188 int (*tc_install)(struct netdev *netdev, const struct smap *details);
190 /* Called when the netdev code determines (through a Netlink query) that
191 * this TC class's qdisc is installed on 'netdev', but we didn't install
192 * it ourselves and so don't know any of the details.
194 * 'nlmsg' is the kernel reply to a RTM_GETQDISC Netlink message for
195 * 'netdev'. The TCA_KIND attribute of 'nlmsg' is 'linux_name'. The
196 * implementation should parse the other attributes of 'nlmsg' as
197 * necessary to determine its configuration. If necessary it should also
198 * use Netlink queries to determine the configuration of queues on
201 * This function must return 0 if and only if it sets 'netdev->tc' to an
202 * initialized 'struct tc'. */
203 int (*tc_load)(struct netdev *netdev, struct ofpbuf *nlmsg);
205 /* Destroys the data structures allocated by the implementation as part of
206 * 'tc'. (This includes destroying 'tc->queues' by calling
209 * The implementation should not need to perform any Netlink calls. If
210 * desirable, the caller is responsible for deconfiguring the kernel qdisc.
211 * (But it may not be desirable.)
213 * This function may be null if 'tc' is trivial. */
214 void (*tc_destroy)(struct tc *tc);
216 /* Retrieves details of 'netdev->tc' configuration into 'details'.
218 * The implementation should not need to perform any Netlink calls, because
219 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
220 * cached the configuration.
222 * The contents of 'details' should be documented as valid for 'ovs_name'
223 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
224 * (which is built as ovs-vswitchd.conf.db(8)).
226 * This function may be null if 'tc' is not configurable.
228 int (*qdisc_get)(const struct netdev *netdev, struct smap *details);
230 /* Reconfigures 'netdev->tc' according to 'details', performing any
231 * required Netlink calls to complete the reconfiguration.
233 * The contents of 'details' should be documented as valid for 'ovs_name'
234 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
235 * (which is built as ovs-vswitchd.conf.db(8)).
237 * This function may be null if 'tc' is not configurable.
239 int (*qdisc_set)(struct netdev *, const struct smap *details);
241 /* Retrieves details of 'queue' on 'netdev->tc' into 'details'. 'queue' is
242 * one of the 'struct tc_queue's within 'netdev->tc->queues'.
244 * The contents of 'details' should be documented as valid for 'ovs_name'
245 * in the "other_config" column in the "Queue" table in
246 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
248 * The implementation should not need to perform any Netlink calls, because
249 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
250 * cached the queue configuration.
252 * This function may be null if 'tc' does not have queues ('n_queues' is
254 int (*class_get)(const struct netdev *netdev, const struct tc_queue *queue,
255 struct smap *details);
257 /* Configures or reconfigures 'queue_id' on 'netdev->tc' according to
258 * 'details', perfoming any required Netlink calls to complete the
259 * reconfiguration. The caller ensures that 'queue_id' is less than
262 * The contents of 'details' should be documented as valid for 'ovs_name'
263 * in the "other_config" column in the "Queue" table in
264 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
266 * This function may be null if 'tc' does not have queues or its queues are
267 * not configurable. */
268 int (*class_set)(struct netdev *, unsigned int queue_id,
269 const struct smap *details);
271 /* Deletes 'queue' from 'netdev->tc'. 'queue' is one of the 'struct
272 * tc_queue's within 'netdev->tc->queues'.
274 * This function may be null if 'tc' does not have queues or its queues
275 * cannot be deleted. */
276 int (*class_delete)(struct netdev *, struct tc_queue *queue);
278 /* Obtains stats for 'queue' from 'netdev->tc'. 'queue' is one of the
279 * 'struct tc_queue's within 'netdev->tc->queues'.
281 * On success, initializes '*stats'.
283 * This function may be null if 'tc' does not have queues or if it cannot
284 * report queue statistics. */
285 int (*class_get_stats)(const struct netdev *netdev,
286 const struct tc_queue *queue,
287 struct netdev_queue_stats *stats);
289 /* Extracts queue stats from 'nlmsg', which is a response to a
290 * RTM_GETTCLASS message, and passes them to 'cb' along with 'aux'.
292 * This function may be null if 'tc' does not have queues or if it cannot
293 * report queue statistics. */
294 int (*class_dump_stats)(const struct netdev *netdev,
295 const struct ofpbuf *nlmsg,
296 netdev_dump_queue_stats_cb *cb, void *aux);
300 tc_init(struct tc *tc, const struct tc_ops *ops)
303 hmap_init(&tc->queues);
307 tc_destroy(struct tc *tc)
309 hmap_destroy(&tc->queues);
312 static const struct tc_ops tc_ops_htb;
313 static const struct tc_ops tc_ops_hfsc;
314 static const struct tc_ops tc_ops_default;
315 static const struct tc_ops tc_ops_other;
317 static const struct tc_ops *const tcs[] = {
318 &tc_ops_htb, /* Hierarchy token bucket (see tc-htb(8)). */
319 &tc_ops_hfsc, /* Hierarchical fair service curve. */
320 &tc_ops_default, /* Default qdisc (see tc-pfifo_fast(8)). */
321 &tc_ops_other, /* Some other qdisc. */
325 static unsigned int tc_make_handle(unsigned int major, unsigned int minor);
326 static unsigned int tc_get_major(unsigned int handle);
327 static unsigned int tc_get_minor(unsigned int handle);
329 static unsigned int tc_ticks_to_bytes(unsigned int rate, unsigned int ticks);
330 static unsigned int tc_bytes_to_ticks(unsigned int rate, unsigned int size);
331 static unsigned int tc_buffer_per_jiffy(unsigned int rate);
333 static struct tcmsg *tc_make_request(const struct netdev *, int type,
334 unsigned int flags, struct ofpbuf *);
335 static int tc_transact(struct ofpbuf *request, struct ofpbuf **replyp);
336 static int tc_add_del_ingress_qdisc(struct netdev *netdev, bool add);
337 static int tc_add_policer(struct netdev *netdev, int kbits_rate,
340 static int tc_parse_qdisc(const struct ofpbuf *, const char **kind,
341 struct nlattr **options);
342 static int tc_parse_class(const struct ofpbuf *, unsigned int *queue_id,
343 struct nlattr **options,
344 struct netdev_queue_stats *);
345 static int tc_query_class(const struct netdev *,
346 unsigned int handle, unsigned int parent,
347 struct ofpbuf **replyp);
348 static int tc_delete_class(const struct netdev *, unsigned int handle);
350 static int tc_del_qdisc(struct netdev *netdev);
351 static int tc_query_qdisc(const struct netdev *netdev);
353 static int tc_calc_cell_log(unsigned int mtu);
354 static void tc_fill_rate(struct tc_ratespec *rate, uint64_t bps, int mtu);
355 static void tc_put_rtab(struct ofpbuf *, uint16_t type,
356 const struct tc_ratespec *rate);
357 static int tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes);
359 struct netdev_linux {
362 struct shash_node *shash_node;
363 unsigned int cache_valid;
364 unsigned int change_seq;
366 bool miimon; /* Link status of last poll. */
367 long long int miimon_interval; /* Miimon Poll rate. Disabled if <= 0. */
368 struct timer miimon_timer;
370 /* The following are figured out "on demand" only. They are only valid
371 * when the corresponding VALID_* bit in 'cache_valid' is set. */
373 uint8_t etheraddr[ETH_ADDR_LEN];
374 struct in_addr address, netmask;
377 unsigned int ifi_flags;
378 long long int carrier_resets;
379 uint32_t kbits_rate; /* Policing data. */
380 uint32_t kbits_burst;
381 int vport_stats_error; /* Cached error code from vport_get_stats().
382 0 or an errno value. */
383 int netdev_mtu_error; /* Cached error code from SIOCGIFMTU or SIOCSIFMTU. */
384 int ether_addr_error; /* Cached error code from set/get etheraddr. */
385 int netdev_policing_error; /* Cached error code from set policing. */
386 int get_features_error; /* Cached error code from ETHTOOL_GSET. */
387 int get_ifindex_error; /* Cached error code from SIOCGIFINDEX. */
389 enum netdev_features current; /* Cached from ETHTOOL_GSET. */
390 enum netdev_features advertised; /* Cached from ETHTOOL_GSET. */
391 enum netdev_features supported; /* Cached from ETHTOOL_GSET. */
392 enum netdev_features peer; /* Cached from ETHTOOL_GSET. */
394 struct ethtool_drvinfo drvinfo; /* Cached from ETHTOOL_GDRVINFO. */
398 struct tap_state tap;
402 struct netdev_rx_linux {
408 static const struct netdev_rx_class netdev_rx_linux_class;
410 /* Sockets used for ioctl operations. */
411 static int af_inet_sock = -1; /* AF_INET, SOCK_DGRAM. */
413 /* This is set pretty low because we probably won't learn anything from the
414 * additional log messages. */
415 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
417 static int netdev_linux_init(void);
419 static int netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *,
420 int cmd, const char *cmd_name);
421 static int netdev_linux_do_ioctl(const char *name, struct ifreq *, int cmd,
422 const char *cmd_name);
423 static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
424 int cmd, const char *cmd_name);
425 static int get_flags(const struct netdev *, unsigned int *flags);
426 static int set_flags(const char *, unsigned int flags);
427 static int do_get_ifindex(const char *netdev_name);
428 static int get_ifindex(const struct netdev *, int *ifindexp);
429 static int do_set_addr(struct netdev *netdev,
430 int ioctl_nr, const char *ioctl_name,
431 struct in_addr addr);
432 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
433 static int set_etheraddr(const char *netdev_name, const uint8_t[ETH_ADDR_LEN]);
434 static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats);
435 static int get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats);
436 static int af_packet_sock(void);
437 static void netdev_linux_miimon_run(void);
438 static void netdev_linux_miimon_wait(void);
441 is_netdev_linux_class(const struct netdev_class *netdev_class)
443 return netdev_class->init == netdev_linux_init;
447 is_tap_netdev(const struct netdev *netdev)
449 return netdev_get_class(netdev) == &netdev_tap_class;
452 static struct netdev_linux *
453 netdev_linux_cast(const struct netdev *netdev)
455 ovs_assert(is_netdev_linux_class(netdev_get_class(netdev)));
457 return CONTAINER_OF(netdev, struct netdev_linux, up);
460 static struct netdev_rx_linux *
461 netdev_rx_linux_cast(const struct netdev_rx *rx)
463 netdev_rx_assert_class(rx, &netdev_rx_linux_class);
464 return CONTAINER_OF(rx, struct netdev_rx_linux, up);
468 netdev_linux_init(void)
470 static int status = -1;
472 /* Create AF_INET socket. */
473 af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
474 status = af_inet_sock >= 0 ? 0 : errno;
476 VLOG_ERR("failed to create inet socket: %s", ovs_strerror(status));
483 netdev_linux_run(void)
485 rtnetlink_link_run();
486 netdev_linux_miimon_run();
490 netdev_linux_wait(void)
492 rtnetlink_link_wait();
493 netdev_linux_miimon_wait();
497 netdev_linux_changed(struct netdev_linux *dev,
498 unsigned int ifi_flags, unsigned int mask)
501 if (!dev->change_seq) {
505 if ((dev->ifi_flags ^ ifi_flags) & IFF_RUNNING) {
506 dev->carrier_resets++;
508 dev->ifi_flags = ifi_flags;
510 dev->cache_valid &= mask;
514 netdev_linux_update(struct netdev_linux *dev,
515 const struct rtnetlink_link_change *change)
517 if (change->nlmsg_type == RTM_NEWLINK) {
519 netdev_linux_changed(dev, change->ifi_flags, VALID_DRVINFO);
521 /* Update netdev from rtnl-change msg. */
523 dev->mtu = change->mtu;
524 dev->cache_valid |= VALID_MTU;
525 dev->netdev_mtu_error = 0;
528 if (!eth_addr_is_zero(change->addr)) {
529 memcpy(dev->etheraddr, change->addr, ETH_ADDR_LEN);
530 dev->cache_valid |= VALID_ETHERADDR;
531 dev->ether_addr_error = 0;
534 dev->ifindex = change->ifi_index;
535 dev->cache_valid |= VALID_IFINDEX;
536 dev->get_ifindex_error = 0;
539 netdev_linux_changed(dev, change->ifi_flags, 0);
544 netdev_linux_cache_cb(const struct rtnetlink_link_change *change,
545 void *aux OVS_UNUSED)
547 struct netdev_linux *dev;
549 struct netdev *base_dev = netdev_from_name(change->ifname);
550 if (base_dev && is_netdev_linux_class(netdev_get_class(base_dev))) {
551 netdev_linux_update(netdev_linux_cast(base_dev), change);
554 struct shash device_shash;
555 struct shash_node *node;
557 shash_init(&device_shash);
558 netdev_get_devices(&netdev_linux_class, &device_shash);
559 SHASH_FOR_EACH (node, &device_shash) {
564 get_flags(&dev->up, &flags);
565 netdev_linux_changed(dev, flags, 0);
567 shash_destroy(&device_shash);
572 cache_notifier_ref(void)
574 if (!cache_notifier_refcount) {
575 ovs_assert(!netdev_linux_cache_notifier);
577 netdev_linux_cache_notifier =
578 rtnetlink_link_notifier_create(netdev_linux_cache_cb, NULL);
580 if (!netdev_linux_cache_notifier) {
584 cache_notifier_refcount++;
590 cache_notifier_unref(void)
592 ovs_assert(cache_notifier_refcount > 0);
593 if (!--cache_notifier_refcount) {
594 ovs_assert(netdev_linux_cache_notifier);
595 rtnetlink_link_notifier_destroy(netdev_linux_cache_notifier);
596 netdev_linux_cache_notifier = NULL;
600 /* Creates system and internal devices. */
602 netdev_linux_create(const struct netdev_class *class, const char *name,
603 struct netdev **netdevp)
605 struct netdev_linux *netdev;
608 error = cache_notifier_ref();
613 netdev = xzalloc(sizeof *netdev);
614 netdev->change_seq = 1;
615 netdev_init(&netdev->up, name, class);
616 error = get_flags(&netdev->up, &netdev->ifi_flags);
617 if (error == ENODEV) {
618 if (class != &netdev_internal_class) {
619 /* The device does not exist, so don't allow it to be opened. */
620 netdev_uninit(&netdev->up, false);
621 cache_notifier_unref();
625 /* "Internal" netdevs have to be created as netdev objects before
626 * they exist in the kernel, because creating them in the kernel
627 * happens by passing a netdev object to dpif_port_add().
628 * Therefore, ignore the error. */
632 *netdevp = &netdev->up;
636 /* For most types of netdevs we open the device for each call of
637 * netdev_open(). However, this is not the case with tap devices,
638 * since it is only possible to open the device once. In this
639 * situation we share a single file descriptor, and consequently
640 * buffers, across all readers. Therefore once data is read it will
641 * be unavailable to other reads for tap devices. */
643 netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED,
644 const char *name, struct netdev **netdevp)
646 struct netdev_linux *netdev;
647 struct tap_state *state;
648 static const char tap_dev[] = "/dev/net/tun";
652 netdev = xzalloc(sizeof *netdev);
653 state = &netdev->state.tap;
655 error = cache_notifier_ref();
660 /* Open tap device. */
661 state->fd = open(tap_dev, O_RDWR);
664 VLOG_WARN("opening \"%s\" failed: %s", tap_dev, ovs_strerror(error));
665 goto error_unref_notifier;
668 /* Create tap device. */
669 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
670 ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
671 if (ioctl(state->fd, TUNSETIFF, &ifr) == -1) {
672 VLOG_WARN("%s: creating tap device failed: %s", name,
673 ovs_strerror(errno));
678 /* Make non-blocking. */
679 error = set_nonblocking(state->fd);
684 netdev_init(&netdev->up, name, &netdev_tap_class);
685 *netdevp = &netdev->up;
690 error_unref_notifier:
691 cache_notifier_unref();
698 destroy_tap(struct netdev_linux *netdev)
700 struct tap_state *state = &netdev->state.tap;
702 if (state->fd >= 0) {
707 /* Destroys the netdev device 'netdev_'. */
709 netdev_linux_destroy(struct netdev *netdev_)
711 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
713 if (netdev->tc && netdev->tc->ops->tc_destroy) {
714 netdev->tc->ops->tc_destroy(netdev->tc);
717 if (netdev_get_class(netdev_) == &netdev_tap_class) {
722 cache_notifier_unref();
726 netdev_linux_rx_open(struct netdev *netdev_, struct netdev_rx **rxp)
728 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
729 bool is_tap = is_tap_netdev(netdev_);
730 struct netdev_rx_linux *rx;
735 fd = netdev->state.tap.fd;
737 struct sockaddr_ll sll;
739 /* Result of tcpdump -dd inbound */
740 static struct sock_filter filt[] = {
741 { 0x28, 0, 0, 0xfffff004 }, /* ldh [0] */
742 { 0x15, 0, 1, 0x00000004 }, /* jeq #4 jt 2 jf 3 */
743 { 0x6, 0, 0, 0x00000000 }, /* ret #0 */
744 { 0x6, 0, 0, 0x0000ffff } /* ret #65535 */
746 static struct sock_fprog fprog = { ARRAY_SIZE(filt), filt };
748 /* Create file descriptor. */
749 fd = socket(PF_PACKET, SOCK_RAW, 0);
752 VLOG_ERR("failed to create raw socket (%s)", ovs_strerror(error));
756 /* Set non-blocking mode. */
757 error = set_nonblocking(fd);
762 /* Get ethernet device index. */
763 error = get_ifindex(&netdev->up, &ifindex);
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) {
775 VLOG_ERR("%s: failed to bind raw socket (%s)",
776 netdev_get_name(netdev_), ovs_strerror(error));
780 /* Filter for only inbound packets. */
781 error = setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &fprog,
785 VLOG_ERR("%s: failed attach filter (%s)",
786 netdev_get_name(netdev_), ovs_strerror(error));
791 rx = xmalloc(sizeof *rx);
792 netdev_rx_init(&rx->up, netdev_, &netdev_rx_linux_class);
807 netdev_rx_linux_destroy(struct netdev_rx *rx_)
809 struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
818 netdev_rx_linux_recv(struct netdev_rx *rx_, void *data, size_t size)
820 struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
825 ? read(rx->fd, data, size)
826 : recv(rx->fd, data, size, MSG_TRUNC));
827 } while (retval < 0 && errno == EINTR);
830 return retval > size ? -EMSGSIZE : retval;
832 if (errno != EAGAIN) {
833 VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
834 ovs_strerror(errno), netdev_rx_get_name(rx_));
841 netdev_rx_linux_wait(struct netdev_rx *rx_)
843 struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
844 poll_fd_wait(rx->fd, POLLIN);
848 netdev_rx_linux_drain(struct netdev_rx *rx_)
850 struct netdev_rx_linux *rx = netdev_rx_linux_cast(rx_);
853 int error = netdev_linux_do_ioctl(netdev_rx_get_name(rx_), &ifr,
854 SIOCGIFTXQLEN, "SIOCGIFTXQLEN");
858 drain_fd(rx->fd, ifr.ifr_qlen);
861 return drain_rcvbuf(rx->fd);
865 /* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive
866 * errno value. Returns EAGAIN without blocking if the packet cannot be queued
867 * immediately. Returns EMSGSIZE if a partial packet was transmitted or if
868 * the packet is too big or too small to transmit on the device.
870 * The caller retains ownership of 'buffer' in all cases.
872 * The kernel maintains a packet transmission queue, so the caller is not
873 * expected to do additional queuing of packets. */
875 netdev_linux_send(struct netdev *netdev_, const void *data, size_t size)
880 if (!is_tap_netdev(netdev_)) {
881 /* Use our AF_PACKET socket to send to this device. */
882 struct sockaddr_ll sll;
889 sock = af_packet_sock();
894 error = get_ifindex(netdev_, &ifindex);
899 /* We don't bother setting most fields in sockaddr_ll because the
900 * kernel ignores them for SOCK_RAW. */
901 memset(&sll, 0, sizeof sll);
902 sll.sll_family = AF_PACKET;
903 sll.sll_ifindex = ifindex;
905 iov.iov_base = CONST_CAST(void *, data);
909 msg.msg_namelen = sizeof sll;
912 msg.msg_control = NULL;
913 msg.msg_controllen = 0;
916 retval = sendmsg(sock, &msg, 0);
918 /* Use the tap fd to send to this device. This is essential for
919 * tap devices, because packets sent to a tap device with an
920 * AF_PACKET socket will loop back to be *received* again on the
921 * tap device. This doesn't occur on other interface types
922 * because we attach a socket filter to the rx socket. */
923 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
925 retval = write(netdev->state.tap.fd, data, size);
929 /* The Linux AF_PACKET implementation never blocks waiting for room
930 * for packets, instead returning ENOBUFS. Translate this into
931 * EAGAIN for the caller. */
932 if (errno == ENOBUFS) {
934 } else if (errno == EINTR) {
936 } else if (errno != EAGAIN) {
937 VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
938 netdev_get_name(netdev_), ovs_strerror(errno));
941 } else if (retval != size) {
942 VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of "
943 "%zu) on %s", retval, size, netdev_get_name(netdev_));
951 /* Registers with the poll loop to wake up from the next call to poll_block()
952 * when the packet transmission queue has sufficient room to transmit a packet
953 * with netdev_send().
955 * The kernel maintains a packet transmission queue, so the client is not
956 * expected to do additional queuing of packets. Thus, this function is
957 * unlikely to ever be used. It is included for completeness. */
959 netdev_linux_send_wait(struct netdev *netdev)
961 if (is_tap_netdev(netdev)) {
962 /* TAP device always accepts packets.*/
963 poll_immediate_wake();
967 /* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
968 * otherwise a positive errno value. */
970 netdev_linux_set_etheraddr(struct netdev *netdev_,
971 const uint8_t mac[ETH_ADDR_LEN])
973 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
974 struct netdev_saved_flags *sf = NULL;
977 if (netdev->cache_valid & VALID_ETHERADDR) {
978 if (netdev->ether_addr_error) {
979 return netdev->ether_addr_error;
981 if (eth_addr_equals(netdev->etheraddr, mac)) {
984 netdev->cache_valid &= ~VALID_ETHERADDR;
987 /* Tap devices must be brought down before setting the address. */
988 if (is_tap_netdev(netdev_)) {
989 netdev_turn_flags_off(netdev_, NETDEV_UP, &sf);
991 error = set_etheraddr(netdev_get_name(netdev_), mac);
992 if (!error || error == ENODEV) {
993 netdev->ether_addr_error = error;
994 netdev->cache_valid |= VALID_ETHERADDR;
996 memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
1000 netdev_restore_flags(sf);
1005 /* Copies 'netdev''s MAC address to 'mac' which is passed as param. */
1007 netdev_linux_get_etheraddr(const struct netdev *netdev_,
1008 uint8_t mac[ETH_ADDR_LEN])
1010 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1012 if (!(netdev->cache_valid & VALID_ETHERADDR)) {
1013 int error = get_etheraddr(netdev_get_name(netdev_),
1016 netdev->ether_addr_error = error;
1017 netdev->cache_valid |= VALID_ETHERADDR;
1020 if (!netdev->ether_addr_error) {
1021 memcpy(mac, netdev->etheraddr, ETH_ADDR_LEN);
1024 return netdev->ether_addr_error;
1027 /* Returns the maximum size of transmitted (and received) packets on 'netdev',
1028 * in bytes, not including the hardware header; thus, this is typically 1500
1029 * bytes for Ethernet devices. */
1031 netdev_linux_get_mtu(const struct netdev *netdev_, int *mtup)
1033 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1034 if (!(netdev->cache_valid & VALID_MTU)) {
1038 error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
1039 SIOCGIFMTU, "SIOCGIFMTU");
1041 netdev->netdev_mtu_error = error;
1042 netdev->mtu = ifr.ifr_mtu;
1043 netdev->cache_valid |= VALID_MTU;
1046 if (!netdev->netdev_mtu_error) {
1047 *mtup = netdev->mtu;
1049 return netdev->netdev_mtu_error;
1052 /* Sets the maximum size of transmitted (MTU) for given device using linux
1053 * networking ioctl interface.
1056 netdev_linux_set_mtu(const struct netdev *netdev_, int mtu)
1058 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1062 if (netdev->cache_valid & VALID_MTU) {
1063 if (netdev->netdev_mtu_error) {
1064 return netdev->netdev_mtu_error;
1066 if (netdev->mtu == mtu) {
1069 netdev->cache_valid &= ~VALID_MTU;
1072 error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
1073 SIOCSIFMTU, "SIOCSIFMTU");
1074 if (!error || error == ENODEV) {
1075 netdev->netdev_mtu_error = error;
1076 netdev->mtu = ifr.ifr_mtu;
1077 netdev->cache_valid |= VALID_MTU;
1082 /* Returns the ifindex of 'netdev', if successful, as a positive number.
1083 * On failure, returns a negative errno value. */
1085 netdev_linux_get_ifindex(const struct netdev *netdev)
1089 error = get_ifindex(netdev, &ifindex);
1090 return error ? -error : ifindex;
1094 netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier)
1096 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1098 if (netdev->miimon_interval > 0) {
1099 *carrier = netdev->miimon;
1101 *carrier = (netdev->ifi_flags & IFF_RUNNING) != 0;
1107 static long long int
1108 netdev_linux_get_carrier_resets(const struct netdev *netdev)
1110 return netdev_linux_cast(netdev)->carrier_resets;
1114 netdev_linux_do_miimon(const char *name, int cmd, const char *cmd_name,
1115 struct mii_ioctl_data *data)
1120 memset(&ifr, 0, sizeof ifr);
1121 memcpy(&ifr.ifr_data, data, sizeof *data);
1122 error = netdev_linux_do_ioctl(name, &ifr, cmd, cmd_name);
1123 memcpy(data, &ifr.ifr_data, sizeof *data);
1129 netdev_linux_get_miimon(const char *name, bool *miimon)
1131 struct mii_ioctl_data data;
1136 memset(&data, 0, sizeof data);
1137 error = netdev_linux_do_miimon(name, SIOCGMIIPHY, "SIOCGMIIPHY", &data);
1139 /* data.phy_id is filled out by previous SIOCGMIIPHY miimon call. */
1140 data.reg_num = MII_BMSR;
1141 error = netdev_linux_do_miimon(name, SIOCGMIIREG, "SIOCGMIIREG",
1145 *miimon = !!(data.val_out & BMSR_LSTATUS);
1147 VLOG_WARN_RL(&rl, "%s: failed to query MII", name);
1150 struct ethtool_cmd ecmd;
1152 VLOG_DBG_RL(&rl, "%s: failed to query MII, falling back to ethtool",
1155 COVERAGE_INC(netdev_get_ethtool);
1156 memset(&ecmd, 0, sizeof ecmd);
1157 error = netdev_linux_do_ethtool(name, &ecmd, ETHTOOL_GLINK,
1160 struct ethtool_value eval;
1162 memcpy(&eval, &ecmd, sizeof eval);
1163 *miimon = !!eval.data;
1165 VLOG_WARN_RL(&rl, "%s: ethtool link status failed", name);
1173 netdev_linux_set_miimon_interval(struct netdev *netdev_,
1174 long long int interval)
1176 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1178 interval = interval > 0 ? MAX(interval, 100) : 0;
1179 if (netdev->miimon_interval != interval) {
1180 netdev->miimon_interval = interval;
1181 timer_set_expired(&netdev->miimon_timer);
1188 netdev_linux_miimon_run(void)
1190 struct shash device_shash;
1191 struct shash_node *node;
1193 shash_init(&device_shash);
1194 netdev_get_devices(&netdev_linux_class, &device_shash);
1195 SHASH_FOR_EACH (node, &device_shash) {
1196 struct netdev_linux *dev = node->data;
1199 if (dev->miimon_interval <= 0 || !timer_expired(&dev->miimon_timer)) {
1203 netdev_linux_get_miimon(dev->up.name, &miimon);
1204 if (miimon != dev->miimon) {
1205 dev->miimon = miimon;
1206 netdev_linux_changed(dev, dev->ifi_flags, 0);
1209 timer_set_duration(&dev->miimon_timer, dev->miimon_interval);
1212 shash_destroy(&device_shash);
1216 netdev_linux_miimon_wait(void)
1218 struct shash device_shash;
1219 struct shash_node *node;
1221 shash_init(&device_shash);
1222 netdev_get_devices(&netdev_linux_class, &device_shash);
1223 SHASH_FOR_EACH (node, &device_shash) {
1224 struct netdev_linux *dev = node->data;
1226 if (dev->miimon_interval > 0) {
1227 timer_wait(&dev->miimon_timer);
1230 shash_destroy(&device_shash);
1233 /* Check whether we can we use RTM_GETLINK to get network device statistics.
1234 * In pre-2.6.19 kernels, this was only available if wireless extensions were
1237 check_for_working_netlink_stats(void)
1239 /* Decide on the netdev_get_stats() implementation to use. Netlink is
1240 * preferable, so if that works, we'll use it. */
1241 int ifindex = do_get_ifindex("lo");
1243 VLOG_WARN("failed to get ifindex for lo, "
1244 "obtaining netdev stats from proc");
1247 struct netdev_stats stats;
1248 int error = get_stats_via_netlink(ifindex, &stats);
1250 VLOG_DBG("obtaining netdev stats via rtnetlink");
1253 VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats "
1254 "via proc (you are probably running a pre-2.6.19 "
1255 "kernel)", ovs_strerror(error));
1262 swap_uint64(uint64_t *a, uint64_t *b)
1269 /* Copies 'src' into 'dst', performing format conversion in the process.
1271 * 'src' is allowed to be misaligned. */
1273 netdev_stats_from_ovs_vport_stats(struct netdev_stats *dst,
1274 const struct ovs_vport_stats *src)
1276 dst->rx_packets = get_unaligned_u64(&src->rx_packets);
1277 dst->tx_packets = get_unaligned_u64(&src->tx_packets);
1278 dst->rx_bytes = get_unaligned_u64(&src->rx_bytes);
1279 dst->tx_bytes = get_unaligned_u64(&src->tx_bytes);
1280 dst->rx_errors = get_unaligned_u64(&src->rx_errors);
1281 dst->tx_errors = get_unaligned_u64(&src->tx_errors);
1282 dst->rx_dropped = get_unaligned_u64(&src->rx_dropped);
1283 dst->tx_dropped = get_unaligned_u64(&src->tx_dropped);
1285 dst->collisions = 0;
1286 dst->rx_length_errors = 0;
1287 dst->rx_over_errors = 0;
1288 dst->rx_crc_errors = 0;
1289 dst->rx_frame_errors = 0;
1290 dst->rx_fifo_errors = 0;
1291 dst->rx_missed_errors = 0;
1292 dst->tx_aborted_errors = 0;
1293 dst->tx_carrier_errors = 0;
1294 dst->tx_fifo_errors = 0;
1295 dst->tx_heartbeat_errors = 0;
1296 dst->tx_window_errors = 0;
1300 get_stats_via_vport__(const struct netdev *netdev, struct netdev_stats *stats)
1302 struct dpif_linux_vport reply;
1306 error = dpif_linux_vport_get(netdev_get_name(netdev), &reply, &buf);
1309 } else if (!reply.stats) {
1314 netdev_stats_from_ovs_vport_stats(stats, reply.stats);
1322 get_stats_via_vport(const struct netdev *netdev_,
1323 struct netdev_stats *stats)
1325 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1327 if (!netdev->vport_stats_error ||
1328 !(netdev->cache_valid & VALID_VPORT_STAT_ERROR)) {
1331 error = get_stats_via_vport__(netdev_, stats);
1332 if (error && error != ENOENT) {
1333 VLOG_WARN_RL(&rl, "%s: obtaining netdev stats via vport failed "
1335 netdev_get_name(netdev_), ovs_strerror(error));
1337 netdev->vport_stats_error = error;
1338 netdev->cache_valid |= VALID_VPORT_STAT_ERROR;
1343 netdev_linux_sys_get_stats(const struct netdev *netdev_,
1344 struct netdev_stats *stats)
1346 static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
1347 static int use_netlink_stats;
1350 if (ovsthread_once_start(&once)) {
1351 use_netlink_stats = check_for_working_netlink_stats();
1352 ovsthread_once_done(&once);
1355 if (use_netlink_stats) {
1358 error = get_ifindex(netdev_, &ifindex);
1360 error = get_stats_via_netlink(ifindex, stats);
1363 error = get_stats_via_proc(netdev_get_name(netdev_), stats);
1367 VLOG_WARN_RL(&rl, "%s: linux-sys get stats failed %d",
1368 netdev_get_name(netdev_), error);
1374 /* Retrieves current device stats for 'netdev-linux'. */
1376 netdev_linux_get_stats(const struct netdev *netdev_,
1377 struct netdev_stats *stats)
1379 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1380 struct netdev_stats dev_stats;
1383 get_stats_via_vport(netdev_, stats);
1385 error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
1388 if (netdev->vport_stats_error) {
1395 if (netdev->vport_stats_error) {
1396 /* stats not available from OVS then use ioctl stats. */
1399 stats->rx_errors += dev_stats.rx_errors;
1400 stats->tx_errors += dev_stats.tx_errors;
1401 stats->rx_dropped += dev_stats.rx_dropped;
1402 stats->tx_dropped += dev_stats.tx_dropped;
1403 stats->multicast += dev_stats.multicast;
1404 stats->collisions += dev_stats.collisions;
1405 stats->rx_length_errors += dev_stats.rx_length_errors;
1406 stats->rx_over_errors += dev_stats.rx_over_errors;
1407 stats->rx_crc_errors += dev_stats.rx_crc_errors;
1408 stats->rx_frame_errors += dev_stats.rx_frame_errors;
1409 stats->rx_fifo_errors += dev_stats.rx_fifo_errors;
1410 stats->rx_missed_errors += dev_stats.rx_missed_errors;
1411 stats->tx_aborted_errors += dev_stats.tx_aborted_errors;
1412 stats->tx_carrier_errors += dev_stats.tx_carrier_errors;
1413 stats->tx_fifo_errors += dev_stats.tx_fifo_errors;
1414 stats->tx_heartbeat_errors += dev_stats.tx_heartbeat_errors;
1415 stats->tx_window_errors += dev_stats.tx_window_errors;
1420 /* Retrieves current device stats for 'netdev-tap' netdev or
1421 * netdev-internal. */
1423 netdev_tap_get_stats(const struct netdev *netdev_,
1424 struct netdev_stats *stats)
1426 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1427 struct netdev_stats dev_stats;
1430 get_stats_via_vport(netdev_, stats);
1432 error = netdev_linux_sys_get_stats(netdev_, &dev_stats);
1434 if (netdev->vport_stats_error) {
1441 /* If this port is an internal port then the transmit and receive stats
1442 * will appear to be swapped relative to the other ports since we are the
1443 * one sending the data, not a remote computer. For consistency, we swap
1444 * them back here. This does not apply if we are getting stats from the
1445 * vport layer because it always tracks stats from the perspective of the
1447 if (netdev->vport_stats_error) {
1449 swap_uint64(&stats->rx_packets, &stats->tx_packets);
1450 swap_uint64(&stats->rx_bytes, &stats->tx_bytes);
1451 swap_uint64(&stats->rx_errors, &stats->tx_errors);
1452 swap_uint64(&stats->rx_dropped, &stats->tx_dropped);
1453 stats->rx_length_errors = 0;
1454 stats->rx_over_errors = 0;
1455 stats->rx_crc_errors = 0;
1456 stats->rx_frame_errors = 0;
1457 stats->rx_fifo_errors = 0;
1458 stats->rx_missed_errors = 0;
1459 stats->tx_aborted_errors = 0;
1460 stats->tx_carrier_errors = 0;
1461 stats->tx_fifo_errors = 0;
1462 stats->tx_heartbeat_errors = 0;
1463 stats->tx_window_errors = 0;
1465 stats->rx_dropped += dev_stats.tx_dropped;
1466 stats->tx_dropped += dev_stats.rx_dropped;
1468 stats->rx_errors += dev_stats.tx_errors;
1469 stats->tx_errors += dev_stats.rx_errors;
1471 stats->multicast += dev_stats.multicast;
1472 stats->collisions += dev_stats.collisions;
1478 netdev_internal_get_stats(const struct netdev *netdev_,
1479 struct netdev_stats *stats)
1481 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1483 get_stats_via_vport(netdev_, stats);
1484 return netdev->vport_stats_error;
1488 netdev_internal_set_stats(struct netdev *netdev,
1489 const struct netdev_stats *stats)
1491 struct ovs_vport_stats vport_stats;
1492 struct dpif_linux_vport vport;
1495 vport_stats.rx_packets = stats->rx_packets;
1496 vport_stats.tx_packets = stats->tx_packets;
1497 vport_stats.rx_bytes = stats->rx_bytes;
1498 vport_stats.tx_bytes = stats->tx_bytes;
1499 vport_stats.rx_errors = stats->rx_errors;
1500 vport_stats.tx_errors = stats->tx_errors;
1501 vport_stats.rx_dropped = stats->rx_dropped;
1502 vport_stats.tx_dropped = stats->tx_dropped;
1504 dpif_linux_vport_init(&vport);
1505 vport.cmd = OVS_VPORT_CMD_SET;
1506 vport.name = netdev_get_name(netdev);
1507 vport.stats = &vport_stats;
1509 err = dpif_linux_vport_transact(&vport, NULL, NULL);
1511 /* If the vport layer doesn't know about the device, that doesn't mean it
1512 * doesn't exist (after all were able to open it when netdev_open() was
1513 * called), it just means that it isn't attached and we'll be getting
1514 * stats a different way. */
1515 if (err == ENODEV) {
1523 netdev_linux_read_features(struct netdev_linux *netdev)
1525 struct ethtool_cmd ecmd;
1529 if (netdev->cache_valid & VALID_FEATURES) {
1533 COVERAGE_INC(netdev_get_ethtool);
1534 memset(&ecmd, 0, sizeof ecmd);
1535 error = netdev_linux_do_ethtool(netdev->up.name, &ecmd,
1536 ETHTOOL_GSET, "ETHTOOL_GSET");
1541 /* Supported features. */
1542 netdev->supported = 0;
1543 if (ecmd.supported & SUPPORTED_10baseT_Half) {
1544 netdev->supported |= NETDEV_F_10MB_HD;
1546 if (ecmd.supported & SUPPORTED_10baseT_Full) {
1547 netdev->supported |= NETDEV_F_10MB_FD;
1549 if (ecmd.supported & SUPPORTED_100baseT_Half) {
1550 netdev->supported |= NETDEV_F_100MB_HD;
1552 if (ecmd.supported & SUPPORTED_100baseT_Full) {
1553 netdev->supported |= NETDEV_F_100MB_FD;
1555 if (ecmd.supported & SUPPORTED_1000baseT_Half) {
1556 netdev->supported |= NETDEV_F_1GB_HD;
1558 if (ecmd.supported & SUPPORTED_1000baseT_Full) {
1559 netdev->supported |= NETDEV_F_1GB_FD;
1561 if (ecmd.supported & SUPPORTED_10000baseT_Full) {
1562 netdev->supported |= NETDEV_F_10GB_FD;
1564 if (ecmd.supported & SUPPORTED_TP) {
1565 netdev->supported |= NETDEV_F_COPPER;
1567 if (ecmd.supported & SUPPORTED_FIBRE) {
1568 netdev->supported |= NETDEV_F_FIBER;
1570 if (ecmd.supported & SUPPORTED_Autoneg) {
1571 netdev->supported |= NETDEV_F_AUTONEG;
1573 if (ecmd.supported & SUPPORTED_Pause) {
1574 netdev->supported |= NETDEV_F_PAUSE;
1576 if (ecmd.supported & SUPPORTED_Asym_Pause) {
1577 netdev->supported |= NETDEV_F_PAUSE_ASYM;
1580 /* Advertised features. */
1581 netdev->advertised = 0;
1582 if (ecmd.advertising & ADVERTISED_10baseT_Half) {
1583 netdev->advertised |= NETDEV_F_10MB_HD;
1585 if (ecmd.advertising & ADVERTISED_10baseT_Full) {
1586 netdev->advertised |= NETDEV_F_10MB_FD;
1588 if (ecmd.advertising & ADVERTISED_100baseT_Half) {
1589 netdev->advertised |= NETDEV_F_100MB_HD;
1591 if (ecmd.advertising & ADVERTISED_100baseT_Full) {
1592 netdev->advertised |= NETDEV_F_100MB_FD;
1594 if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
1595 netdev->advertised |= NETDEV_F_1GB_HD;
1597 if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
1598 netdev->advertised |= NETDEV_F_1GB_FD;
1600 if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
1601 netdev->advertised |= NETDEV_F_10GB_FD;
1603 if (ecmd.advertising & ADVERTISED_TP) {
1604 netdev->advertised |= NETDEV_F_COPPER;
1606 if (ecmd.advertising & ADVERTISED_FIBRE) {
1607 netdev->advertised |= NETDEV_F_FIBER;
1609 if (ecmd.advertising & ADVERTISED_Autoneg) {
1610 netdev->advertised |= NETDEV_F_AUTONEG;
1612 if (ecmd.advertising & ADVERTISED_Pause) {
1613 netdev->advertised |= NETDEV_F_PAUSE;
1615 if (ecmd.advertising & ADVERTISED_Asym_Pause) {
1616 netdev->advertised |= NETDEV_F_PAUSE_ASYM;
1619 /* Current settings. */
1621 if (speed == SPEED_10) {
1622 netdev->current = ecmd.duplex ? NETDEV_F_10MB_FD : NETDEV_F_10MB_HD;
1623 } else if (speed == SPEED_100) {
1624 netdev->current = ecmd.duplex ? NETDEV_F_100MB_FD : NETDEV_F_100MB_HD;
1625 } else if (speed == SPEED_1000) {
1626 netdev->current = ecmd.duplex ? NETDEV_F_1GB_FD : NETDEV_F_1GB_HD;
1627 } else if (speed == SPEED_10000) {
1628 netdev->current = NETDEV_F_10GB_FD;
1629 } else if (speed == 40000) {
1630 netdev->current = NETDEV_F_40GB_FD;
1631 } else if (speed == 100000) {
1632 netdev->current = NETDEV_F_100GB_FD;
1633 } else if (speed == 1000000) {
1634 netdev->current = NETDEV_F_1TB_FD;
1636 netdev->current = 0;
1639 if (ecmd.port == PORT_TP) {
1640 netdev->current |= NETDEV_F_COPPER;
1641 } else if (ecmd.port == PORT_FIBRE) {
1642 netdev->current |= NETDEV_F_FIBER;
1646 netdev->current |= NETDEV_F_AUTONEG;
1649 /* Peer advertisements. */
1650 netdev->peer = 0; /* XXX */
1653 netdev->cache_valid |= VALID_FEATURES;
1654 netdev->get_features_error = error;
1657 /* Stores the features supported by 'netdev' into each of '*current',
1658 * '*advertised', '*supported', and '*peer' that are non-null. Each value is a
1659 * bitmap of NETDEV_* bits. Returns 0 if successful, otherwise a positive
1662 netdev_linux_get_features(const struct netdev *netdev_,
1663 enum netdev_features *current,
1664 enum netdev_features *advertised,
1665 enum netdev_features *supported,
1666 enum netdev_features *peer)
1668 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1670 netdev_linux_read_features(netdev);
1672 if (!netdev->get_features_error) {
1673 *current = netdev->current;
1674 *advertised = netdev->advertised;
1675 *supported = netdev->supported;
1676 *peer = netdev->peer;
1678 return netdev->get_features_error;
1681 /* Set the features advertised by 'netdev' to 'advertise'. */
1683 netdev_linux_set_advertisements(struct netdev *netdev,
1684 enum netdev_features advertise)
1686 struct ethtool_cmd ecmd;
1689 COVERAGE_INC(netdev_get_ethtool);
1690 memset(&ecmd, 0, sizeof ecmd);
1691 error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1692 ETHTOOL_GSET, "ETHTOOL_GSET");
1697 ecmd.advertising = 0;
1698 if (advertise & NETDEV_F_10MB_HD) {
1699 ecmd.advertising |= ADVERTISED_10baseT_Half;
1701 if (advertise & NETDEV_F_10MB_FD) {
1702 ecmd.advertising |= ADVERTISED_10baseT_Full;
1704 if (advertise & NETDEV_F_100MB_HD) {
1705 ecmd.advertising |= ADVERTISED_100baseT_Half;
1707 if (advertise & NETDEV_F_100MB_FD) {
1708 ecmd.advertising |= ADVERTISED_100baseT_Full;
1710 if (advertise & NETDEV_F_1GB_HD) {
1711 ecmd.advertising |= ADVERTISED_1000baseT_Half;
1713 if (advertise & NETDEV_F_1GB_FD) {
1714 ecmd.advertising |= ADVERTISED_1000baseT_Full;
1716 if (advertise & NETDEV_F_10GB_FD) {
1717 ecmd.advertising |= ADVERTISED_10000baseT_Full;
1719 if (advertise & NETDEV_F_COPPER) {
1720 ecmd.advertising |= ADVERTISED_TP;
1722 if (advertise & NETDEV_F_FIBER) {
1723 ecmd.advertising |= ADVERTISED_FIBRE;
1725 if (advertise & NETDEV_F_AUTONEG) {
1726 ecmd.advertising |= ADVERTISED_Autoneg;
1728 if (advertise & NETDEV_F_PAUSE) {
1729 ecmd.advertising |= ADVERTISED_Pause;
1731 if (advertise & NETDEV_F_PAUSE_ASYM) {
1732 ecmd.advertising |= ADVERTISED_Asym_Pause;
1734 COVERAGE_INC(netdev_set_ethtool);
1735 return netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1736 ETHTOOL_SSET, "ETHTOOL_SSET");
1739 /* Attempts to set input rate limiting (policing) policy. Returns 0 if
1740 * successful, otherwise a positive errno value. */
1742 netdev_linux_set_policing(struct netdev *netdev_,
1743 uint32_t kbits_rate, uint32_t kbits_burst)
1745 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1746 const char *netdev_name = netdev_get_name(netdev_);
1750 kbits_burst = (!kbits_rate ? 0 /* Force to 0 if no rate specified. */
1751 : !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */
1752 : kbits_burst); /* Stick with user-specified value. */
1754 if (netdev->cache_valid & VALID_POLICING) {
1755 if (netdev->netdev_policing_error) {
1756 return netdev->netdev_policing_error;
1759 if (netdev->kbits_rate == kbits_rate &&
1760 netdev->kbits_burst == kbits_burst) {
1761 /* Assume that settings haven't changed since we last set them. */
1764 netdev->cache_valid &= ~VALID_POLICING;
1767 COVERAGE_INC(netdev_set_policing);
1768 /* Remove any existing ingress qdisc. */
1769 error = tc_add_del_ingress_qdisc(netdev_, false);
1771 VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
1772 netdev_name, ovs_strerror(error));
1777 error = tc_add_del_ingress_qdisc(netdev_, true);
1779 VLOG_WARN_RL(&rl, "%s: adding policing qdisc failed: %s",
1780 netdev_name, ovs_strerror(error));
1784 error = tc_add_policer(netdev_, kbits_rate, kbits_burst);
1786 VLOG_WARN_RL(&rl, "%s: adding policing action failed: %s",
1787 netdev_name, ovs_strerror(error));
1792 netdev->kbits_rate = kbits_rate;
1793 netdev->kbits_burst = kbits_burst;
1796 if (!error || error == ENODEV) {
1797 netdev->netdev_policing_error = error;
1798 netdev->cache_valid |= VALID_POLICING;
1804 netdev_linux_get_qos_types(const struct netdev *netdev OVS_UNUSED,
1807 const struct tc_ops *const *opsp;
1809 for (opsp = tcs; *opsp != NULL; opsp++) {
1810 const struct tc_ops *ops = *opsp;
1811 if (ops->tc_install && ops->ovs_name[0] != '\0') {
1812 sset_add(types, ops->ovs_name);
1818 static const struct tc_ops *
1819 tc_lookup_ovs_name(const char *name)
1821 const struct tc_ops *const *opsp;
1823 for (opsp = tcs; *opsp != NULL; opsp++) {
1824 const struct tc_ops *ops = *opsp;
1825 if (!strcmp(name, ops->ovs_name)) {
1832 static const struct tc_ops *
1833 tc_lookup_linux_name(const char *name)
1835 const struct tc_ops *const *opsp;
1837 for (opsp = tcs; *opsp != NULL; opsp++) {
1838 const struct tc_ops *ops = *opsp;
1839 if (ops->linux_name && !strcmp(name, ops->linux_name)) {
1846 static struct tc_queue *
1847 tc_find_queue__(const struct netdev *netdev_, unsigned int queue_id,
1850 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1851 struct tc_queue *queue;
1853 HMAP_FOR_EACH_IN_BUCKET (queue, hmap_node, hash, &netdev->tc->queues) {
1854 if (queue->queue_id == queue_id) {
1861 static struct tc_queue *
1862 tc_find_queue(const struct netdev *netdev, unsigned int queue_id)
1864 return tc_find_queue__(netdev, queue_id, hash_int(queue_id, 0));
1868 netdev_linux_get_qos_capabilities(const struct netdev *netdev OVS_UNUSED,
1870 struct netdev_qos_capabilities *caps)
1872 const struct tc_ops *ops = tc_lookup_ovs_name(type);
1876 caps->n_queues = ops->n_queues;
1881 netdev_linux_get_qos(const struct netdev *netdev_,
1882 const char **typep, struct smap *details)
1884 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1887 error = tc_query_qdisc(netdev_);
1892 *typep = netdev->tc->ops->ovs_name;
1893 return (netdev->tc->ops->qdisc_get
1894 ? netdev->tc->ops->qdisc_get(netdev_, details)
1899 netdev_linux_set_qos(struct netdev *netdev_,
1900 const char *type, const struct smap *details)
1902 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1903 const struct tc_ops *new_ops;
1906 new_ops = tc_lookup_ovs_name(type);
1907 if (!new_ops || !new_ops->tc_install) {
1911 error = tc_query_qdisc(netdev_);
1916 if (new_ops == netdev->tc->ops) {
1917 return new_ops->qdisc_set ? new_ops->qdisc_set(netdev_, details) : 0;
1919 /* Delete existing qdisc. */
1920 error = tc_del_qdisc(netdev_);
1924 ovs_assert(netdev->tc == NULL);
1926 /* Install new qdisc. */
1927 error = new_ops->tc_install(netdev_, details);
1928 ovs_assert((error == 0) == (netdev->tc != NULL));
1935 netdev_linux_get_queue(const struct netdev *netdev_,
1936 unsigned int queue_id, struct smap *details)
1938 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1941 error = tc_query_qdisc(netdev_);
1945 struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
1947 ? netdev->tc->ops->class_get(netdev_, queue, details)
1953 netdev_linux_set_queue(struct netdev *netdev_,
1954 unsigned int queue_id, const struct smap *details)
1956 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1959 error = tc_query_qdisc(netdev_);
1962 } else if (queue_id >= netdev->tc->ops->n_queues
1963 || !netdev->tc->ops->class_set) {
1967 return netdev->tc->ops->class_set(netdev_, queue_id, details);
1971 netdev_linux_delete_queue(struct netdev *netdev_, unsigned int queue_id)
1973 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1976 error = tc_query_qdisc(netdev_);
1979 } else if (!netdev->tc->ops->class_delete) {
1982 struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
1984 ? netdev->tc->ops->class_delete(netdev_, queue)
1990 netdev_linux_get_queue_stats(const struct netdev *netdev_,
1991 unsigned int queue_id,
1992 struct netdev_queue_stats *stats)
1994 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
1997 error = tc_query_qdisc(netdev_);
2000 } else if (!netdev->tc->ops->class_get_stats) {
2003 const struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
2007 stats->created = queue->created;
2008 return netdev->tc->ops->class_get_stats(netdev_, queue, stats);
2013 start_queue_dump(const struct netdev *netdev, struct nl_dump *dump)
2015 struct ofpbuf request;
2016 struct tcmsg *tcmsg;
2018 tcmsg = tc_make_request(netdev, RTM_GETTCLASS, 0, &request);
2022 tcmsg->tcm_parent = 0;
2023 nl_dump_start(dump, NETLINK_ROUTE, &request);
2024 ofpbuf_uninit(&request);
2029 netdev_linux_dump_queues(const struct netdev *netdev_,
2030 netdev_dump_queues_cb *cb, void *aux)
2032 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2033 struct tc_queue *queue, *next_queue;
2034 struct smap details;
2038 error = tc_query_qdisc(netdev_);
2041 } else if (!netdev->tc->ops->class_get) {
2046 smap_init(&details);
2047 HMAP_FOR_EACH_SAFE (queue, next_queue, hmap_node,
2048 &netdev->tc->queues) {
2049 smap_clear(&details);
2051 error = netdev->tc->ops->class_get(netdev_, queue, &details);
2053 (*cb)(queue->queue_id, &details, aux);
2058 smap_destroy(&details);
2064 netdev_linux_dump_queue_stats(const struct netdev *netdev_,
2065 netdev_dump_queue_stats_cb *cb, void *aux)
2067 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2068 struct nl_dump dump;
2073 error = tc_query_qdisc(netdev_);
2076 } else if (!netdev->tc->ops->class_dump_stats) {
2081 if (!start_queue_dump(netdev_, &dump)) {
2084 while (nl_dump_next(&dump, &msg)) {
2085 error = netdev->tc->ops->class_dump_stats(netdev_, &msg, cb, aux);
2091 error = nl_dump_done(&dump);
2092 return error ? error : last_error;
2096 netdev_linux_get_in4(const struct netdev *netdev_,
2097 struct in_addr *address, struct in_addr *netmask)
2099 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2101 if (!(netdev->cache_valid & VALID_IN4)) {
2104 error = netdev_linux_get_ipv4(netdev_, &netdev->address,
2105 SIOCGIFADDR, "SIOCGIFADDR");
2110 error = netdev_linux_get_ipv4(netdev_, &netdev->netmask,
2111 SIOCGIFNETMASK, "SIOCGIFNETMASK");
2116 netdev->cache_valid |= VALID_IN4;
2118 *address = netdev->address;
2119 *netmask = netdev->netmask;
2120 return address->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
2124 netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address,
2125 struct in_addr netmask)
2127 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2130 error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address);
2132 netdev->cache_valid |= VALID_IN4;
2133 netdev->address = address;
2134 netdev->netmask = netmask;
2135 if (address.s_addr != INADDR_ANY) {
2136 error = do_set_addr(netdev_, SIOCSIFNETMASK,
2137 "SIOCSIFNETMASK", netmask);
2144 parse_if_inet6_line(const char *line,
2145 struct in6_addr *in6, char ifname[16 + 1])
2147 uint8_t *s6 = in6->s6_addr;
2148 #define X8 "%2"SCNx8
2150 " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
2151 "%*x %*x %*x %*x %16s\n",
2152 &s6[0], &s6[1], &s6[2], &s6[3],
2153 &s6[4], &s6[5], &s6[6], &s6[7],
2154 &s6[8], &s6[9], &s6[10], &s6[11],
2155 &s6[12], &s6[13], &s6[14], &s6[15],
2159 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
2160 * 'in6' is non-null) and returns true. Otherwise, returns false. */
2162 netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
2164 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2165 if (!(netdev->cache_valid & VALID_IN6)) {
2169 netdev->in6 = in6addr_any;
2171 file = fopen("/proc/net/if_inet6", "r");
2173 const char *name = netdev_get_name(netdev_);
2174 while (fgets(line, sizeof line, file)) {
2175 struct in6_addr in6_tmp;
2176 char ifname[16 + 1];
2177 if (parse_if_inet6_line(line, &in6_tmp, ifname)
2178 && !strcmp(name, ifname))
2180 netdev->in6 = in6_tmp;
2186 netdev->cache_valid |= VALID_IN6;
2193 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
2195 struct sockaddr_in sin;
2196 memset(&sin, 0, sizeof sin);
2197 sin.sin_family = AF_INET;
2198 sin.sin_addr = addr;
2201 memset(sa, 0, sizeof *sa);
2202 memcpy(sa, &sin, sizeof sin);
2206 do_set_addr(struct netdev *netdev,
2207 int ioctl_nr, const char *ioctl_name, struct in_addr addr)
2210 ovs_strzcpy(ifr.ifr_name, netdev_get_name(netdev), sizeof ifr.ifr_name);
2211 make_in4_sockaddr(&ifr.ifr_addr, addr);
2213 return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, ioctl_nr,
2217 /* Adds 'router' as a default IP gateway. */
2219 netdev_linux_add_router(struct netdev *netdev OVS_UNUSED, struct in_addr router)
2221 struct in_addr any = { INADDR_ANY };
2225 memset(&rt, 0, sizeof rt);
2226 make_in4_sockaddr(&rt.rt_dst, any);
2227 make_in4_sockaddr(&rt.rt_gateway, router);
2228 make_in4_sockaddr(&rt.rt_genmask, any);
2229 rt.rt_flags = RTF_UP | RTF_GATEWAY;
2230 error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
2232 VLOG_WARN("ioctl(SIOCADDRT): %s", ovs_strerror(error));
2238 netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
2241 static const char fn[] = "/proc/net/route";
2246 *netdev_name = NULL;
2247 stream = fopen(fn, "r");
2248 if (stream == NULL) {
2249 VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, ovs_strerror(errno));
2254 while (fgets(line, sizeof line, stream)) {
2257 ovs_be32 dest, gateway, mask;
2258 int refcnt, metric, mtu;
2259 unsigned int flags, use, window, irtt;
2262 "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
2264 iface, &dest, &gateway, &flags, &refcnt,
2265 &use, &metric, &mask, &mtu, &window, &irtt) != 11) {
2267 VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
2271 if (!(flags & RTF_UP)) {
2272 /* Skip routes that aren't up. */
2276 /* The output of 'dest', 'mask', and 'gateway' were given in
2277 * network byte order, so we don't need need any endian
2278 * conversions here. */
2279 if ((dest & mask) == (host->s_addr & mask)) {
2281 /* The host is directly reachable. */
2282 next_hop->s_addr = 0;
2284 /* To reach the host, we must go through a gateway. */
2285 next_hop->s_addr = gateway;
2287 *netdev_name = xstrdup(iface);
2299 netdev_linux_get_status(const struct netdev *netdev_, struct smap *smap)
2301 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2304 if (!(netdev->cache_valid & VALID_DRVINFO)) {
2305 struct ethtool_cmd *cmd = (struct ethtool_cmd *) &netdev->drvinfo;
2307 COVERAGE_INC(netdev_get_ethtool);
2308 memset(&netdev->drvinfo, 0, sizeof netdev->drvinfo);
2309 error = netdev_linux_do_ethtool(netdev->up.name,
2312 "ETHTOOL_GDRVINFO");
2314 netdev->cache_valid |= VALID_DRVINFO;
2319 smap_add(smap, "driver_name", netdev->drvinfo.driver);
2320 smap_add(smap, "driver_version", netdev->drvinfo.version);
2321 smap_add(smap, "firmware_version", netdev->drvinfo.fw_version);
2327 netdev_internal_get_status(const struct netdev *netdev OVS_UNUSED,
2330 smap_add(smap, "driver_name", "openvswitch");
2334 /* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
2335 * successfully retrieved, it stores the corresponding MAC address in 'mac' and
2336 * returns 0. Otherwise, it returns a positive errno value; in particular,
2337 * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
2339 netdev_linux_arp_lookup(const struct netdev *netdev,
2340 ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
2343 struct sockaddr_in sin;
2346 memset(&r, 0, sizeof r);
2347 memset(&sin, 0, sizeof sin);
2348 sin.sin_family = AF_INET;
2349 sin.sin_addr.s_addr = ip;
2351 memcpy(&r.arp_pa, &sin, sizeof sin);
2352 r.arp_ha.sa_family = ARPHRD_ETHER;
2354 ovs_strzcpy(r.arp_dev, netdev_get_name(netdev), sizeof r.arp_dev);
2355 COVERAGE_INC(netdev_arp_lookup);
2356 retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
2358 memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
2359 } else if (retval != ENXIO) {
2360 VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
2361 netdev_get_name(netdev), IP_ARGS(ip),
2362 ovs_strerror(retval));
2368 nd_to_iff_flags(enum netdev_flags nd)
2371 if (nd & NETDEV_UP) {
2374 if (nd & NETDEV_PROMISC) {
2381 iff_to_nd_flags(int iff)
2383 enum netdev_flags nd = 0;
2387 if (iff & IFF_PROMISC) {
2388 nd |= NETDEV_PROMISC;
2394 netdev_linux_update_flags(struct netdev *netdev_, enum netdev_flags off,
2395 enum netdev_flags on, enum netdev_flags *old_flagsp)
2397 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2398 int old_flags, new_flags;
2401 old_flags = netdev->ifi_flags;
2402 *old_flagsp = iff_to_nd_flags(old_flags);
2403 new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
2404 if (new_flags != old_flags) {
2405 error = set_flags(netdev_get_name(netdev_), new_flags);
2406 get_flags(netdev_, &netdev->ifi_flags);
2412 netdev_linux_change_seq(const struct netdev *netdev)
2414 return netdev_linux_cast(netdev)->change_seq;
2417 #define NETDEV_LINUX_CLASS(NAME, CREATE, GET_STATS, SET_STATS, \
2418 GET_FEATURES, GET_STATUS) \
2422 netdev_linux_init, \
2424 netdev_linux_wait, \
2427 netdev_linux_destroy, \
2428 NULL, /* get_config */ \
2429 NULL, /* set_config */ \
2430 NULL, /* get_tunnel_config */ \
2432 netdev_linux_rx_open, \
2434 netdev_linux_send, \
2435 netdev_linux_send_wait, \
2437 netdev_linux_set_etheraddr, \
2438 netdev_linux_get_etheraddr, \
2439 netdev_linux_get_mtu, \
2440 netdev_linux_set_mtu, \
2441 netdev_linux_get_ifindex, \
2442 netdev_linux_get_carrier, \
2443 netdev_linux_get_carrier_resets, \
2444 netdev_linux_set_miimon_interval, \
2449 netdev_linux_set_advertisements, \
2451 netdev_linux_set_policing, \
2452 netdev_linux_get_qos_types, \
2453 netdev_linux_get_qos_capabilities, \
2454 netdev_linux_get_qos, \
2455 netdev_linux_set_qos, \
2456 netdev_linux_get_queue, \
2457 netdev_linux_set_queue, \
2458 netdev_linux_delete_queue, \
2459 netdev_linux_get_queue_stats, \
2460 netdev_linux_dump_queues, \
2461 netdev_linux_dump_queue_stats, \
2463 netdev_linux_get_in4, \
2464 netdev_linux_set_in4, \
2465 netdev_linux_get_in6, \
2466 netdev_linux_add_router, \
2467 netdev_linux_get_next_hop, \
2469 netdev_linux_arp_lookup, \
2471 netdev_linux_update_flags, \
2473 netdev_linux_change_seq \
2476 const struct netdev_class netdev_linux_class =
2479 netdev_linux_create,
2480 netdev_linux_get_stats,
2481 NULL, /* set_stats */
2482 netdev_linux_get_features,
2483 netdev_linux_get_status);
2485 const struct netdev_class netdev_tap_class =
2488 netdev_linux_create_tap,
2489 netdev_tap_get_stats,
2490 NULL, /* set_stats */
2491 netdev_linux_get_features,
2492 netdev_linux_get_status);
2494 const struct netdev_class netdev_internal_class =
2497 netdev_linux_create,
2498 netdev_internal_get_stats,
2499 netdev_internal_set_stats,
2500 NULL, /* get_features */
2501 netdev_internal_get_status);
2503 static const struct netdev_rx_class netdev_rx_linux_class = {
2504 netdev_rx_linux_destroy,
2505 netdev_rx_linux_recv,
2506 netdev_rx_linux_wait,
2507 netdev_rx_linux_drain,
2510 /* HTB traffic control class. */
2512 #define HTB_N_QUEUES 0xf000
2516 unsigned int max_rate; /* In bytes/s. */
2520 struct tc_queue tc_queue;
2521 unsigned int min_rate; /* In bytes/s. */
2522 unsigned int max_rate; /* In bytes/s. */
2523 unsigned int burst; /* In bytes. */
2524 unsigned int priority; /* Lower values are higher priorities. */
2528 htb_get__(const struct netdev *netdev_)
2530 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2531 return CONTAINER_OF(netdev->tc, struct htb, tc);
2535 htb_install__(struct netdev *netdev_, uint64_t max_rate)
2537 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
2540 htb = xmalloc(sizeof *htb);
2541 tc_init(&htb->tc, &tc_ops_htb);
2542 htb->max_rate = max_rate;
2544 netdev->tc = &htb->tc;
2547 /* Create an HTB qdisc.
2549 * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2551 htb_setup_qdisc__(struct netdev *netdev)
2554 struct tc_htb_glob opt;
2555 struct ofpbuf request;
2556 struct tcmsg *tcmsg;
2558 tc_del_qdisc(netdev);
2560 tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2561 NLM_F_EXCL | NLM_F_CREATE, &request);
2565 tcmsg->tcm_handle = tc_make_handle(1, 0);
2566 tcmsg->tcm_parent = TC_H_ROOT;
2568 nl_msg_put_string(&request, TCA_KIND, "htb");
2570 memset(&opt, 0, sizeof opt);
2571 opt.rate2quantum = 10;
2575 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2576 nl_msg_put_unspec(&request, TCA_HTB_INIT, &opt, sizeof opt);
2577 nl_msg_end_nested(&request, opt_offset);
2579 return tc_transact(&request, NULL);
2582 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2583 * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2585 htb_setup_class__(struct netdev *netdev, unsigned int handle,
2586 unsigned int parent, struct htb_class *class)
2589 struct tc_htb_opt opt;
2590 struct ofpbuf request;
2591 struct tcmsg *tcmsg;
2595 error = netdev_get_mtu(netdev, &mtu);
2597 VLOG_WARN_RL(&rl, "cannot set up HTB on device %s that lacks MTU",
2598 netdev_get_name(netdev));
2602 memset(&opt, 0, sizeof opt);
2603 tc_fill_rate(&opt.rate, class->min_rate, mtu);
2604 tc_fill_rate(&opt.ceil, class->max_rate, mtu);
2605 opt.buffer = tc_calc_buffer(opt.rate.rate, mtu, class->burst);
2606 opt.cbuffer = tc_calc_buffer(opt.ceil.rate, mtu, class->burst);
2607 opt.prio = class->priority;
2609 tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2613 tcmsg->tcm_handle = handle;
2614 tcmsg->tcm_parent = parent;
2616 nl_msg_put_string(&request, TCA_KIND, "htb");
2617 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2618 nl_msg_put_unspec(&request, TCA_HTB_PARMS, &opt, sizeof opt);
2619 tc_put_rtab(&request, TCA_HTB_RTAB, &opt.rate);
2620 tc_put_rtab(&request, TCA_HTB_CTAB, &opt.ceil);
2621 nl_msg_end_nested(&request, opt_offset);
2623 error = tc_transact(&request, NULL);
2625 VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
2626 "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2627 netdev_get_name(netdev),
2628 tc_get_major(handle), tc_get_minor(handle),
2629 tc_get_major(parent), tc_get_minor(parent),
2630 class->min_rate, class->max_rate,
2631 class->burst, class->priority, ovs_strerror(error));
2636 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2637 * description of them into 'details'. The description complies with the
2638 * specification given in the vswitch database documentation for linux-htb
2641 htb_parse_tca_options__(struct nlattr *nl_options, struct htb_class *class)
2643 static const struct nl_policy tca_htb_policy[] = {
2644 [TCA_HTB_PARMS] = { .type = NL_A_UNSPEC, .optional = false,
2645 .min_len = sizeof(struct tc_htb_opt) },
2648 struct nlattr *attrs[ARRAY_SIZE(tca_htb_policy)];
2649 const struct tc_htb_opt *htb;
2651 if (!nl_parse_nested(nl_options, tca_htb_policy,
2652 attrs, ARRAY_SIZE(tca_htb_policy))) {
2653 VLOG_WARN_RL(&rl, "failed to parse HTB class options");
2657 htb = nl_attr_get(attrs[TCA_HTB_PARMS]);
2658 class->min_rate = htb->rate.rate;
2659 class->max_rate = htb->ceil.rate;
2660 class->burst = tc_ticks_to_bytes(htb->rate.rate, htb->buffer);
2661 class->priority = htb->prio;
2666 htb_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2667 struct htb_class *options,
2668 struct netdev_queue_stats *stats)
2670 struct nlattr *nl_options;
2671 unsigned int handle;
2674 error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2675 if (!error && queue_id) {
2676 unsigned int major = tc_get_major(handle);
2677 unsigned int minor = tc_get_minor(handle);
2678 if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2679 *queue_id = minor - 1;
2684 if (!error && options) {
2685 error = htb_parse_tca_options__(nl_options, options);
2691 htb_parse_qdisc_details__(struct netdev *netdev,
2692 const struct smap *details, struct htb_class *hc)
2694 const char *max_rate_s;
2696 max_rate_s = smap_get(details, "max-rate");
2697 hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2698 if (!hc->max_rate) {
2699 enum netdev_features current;
2701 netdev_get_features(netdev, ¤t, NULL, NULL, NULL);
2702 hc->max_rate = netdev_features_to_bps(current, 100 * 1000 * 1000) / 8;
2704 hc->min_rate = hc->max_rate;
2710 htb_parse_class_details__(struct netdev *netdev,
2711 const struct smap *details, struct htb_class *hc)
2713 const struct htb *htb = htb_get__(netdev);
2714 const char *min_rate_s = smap_get(details, "min-rate");
2715 const char *max_rate_s = smap_get(details, "max-rate");
2716 const char *burst_s = smap_get(details, "burst");
2717 const char *priority_s = smap_get(details, "priority");
2720 error = netdev_get_mtu(netdev, &mtu);
2722 VLOG_WARN_RL(&rl, "cannot parse HTB class on device %s that lacks MTU",
2723 netdev_get_name(netdev));
2727 /* HTB requires at least an mtu sized min-rate to send any traffic even
2728 * on uncongested links. */
2729 hc->min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
2730 hc->min_rate = MAX(hc->min_rate, mtu);
2731 hc->min_rate = MIN(hc->min_rate, htb->max_rate);
2734 hc->max_rate = (max_rate_s
2735 ? strtoull(max_rate_s, NULL, 10) / 8
2737 hc->max_rate = MAX(hc->max_rate, hc->min_rate);
2738 hc->max_rate = MIN(hc->max_rate, htb->max_rate);
2742 * According to hints in the documentation that I've read, it is important
2743 * that 'burst' be at least as big as the largest frame that might be
2744 * transmitted. Also, making 'burst' a bit bigger than necessary is OK,
2745 * but having it a bit too small is a problem. Since netdev_get_mtu()
2746 * doesn't include the Ethernet header, we need to add at least 14 (18?) to
2747 * the MTU. We actually add 64, instead of 14, as a guard against
2748 * additional headers get tacked on somewhere that we're not aware of. */
2749 hc->burst = burst_s ? strtoull(burst_s, NULL, 10) / 8 : 0;
2750 hc->burst = MAX(hc->burst, mtu + 64);
2753 hc->priority = priority_s ? strtoul(priority_s, NULL, 10) : 0;
2759 htb_query_class__(const struct netdev *netdev, unsigned int handle,
2760 unsigned int parent, struct htb_class *options,
2761 struct netdev_queue_stats *stats)
2763 struct ofpbuf *reply;
2766 error = tc_query_class(netdev, handle, parent, &reply);
2768 error = htb_parse_tcmsg__(reply, NULL, options, stats);
2769 ofpbuf_delete(reply);
2775 htb_tc_install(struct netdev *netdev, const struct smap *details)
2779 error = htb_setup_qdisc__(netdev);
2781 struct htb_class hc;
2783 htb_parse_qdisc_details__(netdev, details, &hc);
2784 error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2785 tc_make_handle(1, 0), &hc);
2787 htb_install__(netdev, hc.max_rate);
2793 static struct htb_class *
2794 htb_class_cast__(const struct tc_queue *queue)
2796 return CONTAINER_OF(queue, struct htb_class, tc_queue);
2800 htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
2801 const struct htb_class *hc)
2803 struct htb *htb = htb_get__(netdev);
2804 size_t hash = hash_int(queue_id, 0);
2805 struct tc_queue *queue;
2806 struct htb_class *hcp;
2808 queue = tc_find_queue__(netdev, queue_id, hash);
2810 hcp = htb_class_cast__(queue);
2812 hcp = xmalloc(sizeof *hcp);
2813 queue = &hcp->tc_queue;
2814 queue->queue_id = queue_id;
2815 queue->created = time_msec();
2816 hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
2819 hcp->min_rate = hc->min_rate;
2820 hcp->max_rate = hc->max_rate;
2821 hcp->burst = hc->burst;
2822 hcp->priority = hc->priority;
2826 htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
2829 struct nl_dump dump;
2830 struct htb_class hc;
2832 /* Get qdisc options. */
2834 htb_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
2835 htb_install__(netdev, hc.max_rate);
2838 if (!start_queue_dump(netdev, &dump)) {
2841 while (nl_dump_next(&dump, &msg)) {
2842 unsigned int queue_id;
2844 if (!htb_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
2845 htb_update_queue__(netdev, queue_id, &hc);
2848 nl_dump_done(&dump);
2854 htb_tc_destroy(struct tc *tc)
2856 struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
2857 struct htb_class *hc, *next;
2859 HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &htb->tc.queues) {
2860 hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2868 htb_qdisc_get(const struct netdev *netdev, struct smap *details)
2870 const struct htb *htb = htb_get__(netdev);
2871 smap_add_format(details, "max-rate", "%llu", 8ULL * htb->max_rate);
2876 htb_qdisc_set(struct netdev *netdev, const struct smap *details)
2878 struct htb_class hc;
2881 htb_parse_qdisc_details__(netdev, details, &hc);
2882 error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2883 tc_make_handle(1, 0), &hc);
2885 htb_get__(netdev)->max_rate = hc.max_rate;
2891 htb_class_get(const struct netdev *netdev OVS_UNUSED,
2892 const struct tc_queue *queue, struct smap *details)
2894 const struct htb_class *hc = htb_class_cast__(queue);
2896 smap_add_format(details, "min-rate", "%llu", 8ULL * hc->min_rate);
2897 if (hc->min_rate != hc->max_rate) {
2898 smap_add_format(details, "max-rate", "%llu", 8ULL * hc->max_rate);
2900 smap_add_format(details, "burst", "%llu", 8ULL * hc->burst);
2902 smap_add_format(details, "priority", "%u", hc->priority);
2908 htb_class_set(struct netdev *netdev, unsigned int queue_id,
2909 const struct smap *details)
2911 struct htb_class hc;
2914 error = htb_parse_class_details__(netdev, details, &hc);
2919 error = htb_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
2920 tc_make_handle(1, 0xfffe), &hc);
2925 htb_update_queue__(netdev, queue_id, &hc);
2930 htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
2932 struct htb_class *hc = htb_class_cast__(queue);
2933 struct htb *htb = htb_get__(netdev);
2936 error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
2938 hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2945 htb_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
2946 struct netdev_queue_stats *stats)
2948 return htb_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
2949 tc_make_handle(1, 0xfffe), NULL, stats);
2953 htb_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
2954 const struct ofpbuf *nlmsg,
2955 netdev_dump_queue_stats_cb *cb, void *aux)
2957 struct netdev_queue_stats stats;
2958 unsigned int handle, major, minor;
2961 error = tc_parse_class(nlmsg, &handle, NULL, &stats);
2966 major = tc_get_major(handle);
2967 minor = tc_get_minor(handle);
2968 if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2969 (*cb)(minor - 1, &stats, aux);
2974 static const struct tc_ops tc_ops_htb = {
2975 "htb", /* linux_name */
2976 "linux-htb", /* ovs_name */
2977 HTB_N_QUEUES, /* n_queues */
2986 htb_class_get_stats,
2987 htb_class_dump_stats
2990 /* "linux-hfsc" traffic control class. */
2992 #define HFSC_N_QUEUES 0xf000
3000 struct tc_queue tc_queue;
3005 static struct hfsc *
3006 hfsc_get__(const struct netdev *netdev_)
3008 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3009 return CONTAINER_OF(netdev->tc, struct hfsc, tc);
3012 static struct hfsc_class *
3013 hfsc_class_cast__(const struct tc_queue *queue)
3015 return CONTAINER_OF(queue, struct hfsc_class, tc_queue);
3019 hfsc_install__(struct netdev *netdev_, uint32_t max_rate)
3021 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3024 hfsc = xmalloc(sizeof *hfsc);
3025 tc_init(&hfsc->tc, &tc_ops_hfsc);
3026 hfsc->max_rate = max_rate;
3027 netdev->tc = &hfsc->tc;
3031 hfsc_update_queue__(struct netdev *netdev, unsigned int queue_id,
3032 const struct hfsc_class *hc)
3036 struct hfsc_class *hcp;
3037 struct tc_queue *queue;
3039 hfsc = hfsc_get__(netdev);
3040 hash = hash_int(queue_id, 0);
3042 queue = tc_find_queue__(netdev, queue_id, hash);
3044 hcp = hfsc_class_cast__(queue);
3046 hcp = xmalloc(sizeof *hcp);
3047 queue = &hcp->tc_queue;
3048 queue->queue_id = queue_id;
3049 queue->created = time_msec();
3050 hmap_insert(&hfsc->tc.queues, &queue->hmap_node, hash);
3053 hcp->min_rate = hc->min_rate;
3054 hcp->max_rate = hc->max_rate;
3058 hfsc_parse_tca_options__(struct nlattr *nl_options, struct hfsc_class *class)
3060 const struct tc_service_curve *rsc, *fsc, *usc;
3061 static const struct nl_policy tca_hfsc_policy[] = {
3063 .type = NL_A_UNSPEC,
3065 .min_len = sizeof(struct tc_service_curve),
3068 .type = NL_A_UNSPEC,
3070 .min_len = sizeof(struct tc_service_curve),
3073 .type = NL_A_UNSPEC,
3075 .min_len = sizeof(struct tc_service_curve),
3078 struct nlattr *attrs[ARRAY_SIZE(tca_hfsc_policy)];
3080 if (!nl_parse_nested(nl_options, tca_hfsc_policy,
3081 attrs, ARRAY_SIZE(tca_hfsc_policy))) {
3082 VLOG_WARN_RL(&rl, "failed to parse HFSC class options");
3086 rsc = nl_attr_get(attrs[TCA_HFSC_RSC]);
3087 fsc = nl_attr_get(attrs[TCA_HFSC_FSC]);
3088 usc = nl_attr_get(attrs[TCA_HFSC_USC]);
3090 if (rsc->m1 != 0 || rsc->d != 0 ||
3091 fsc->m1 != 0 || fsc->d != 0 ||
3092 usc->m1 != 0 || usc->d != 0) {
3093 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3094 "Non-linear service curves are not supported.");
3098 if (rsc->m2 != fsc->m2) {
3099 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3100 "Real-time service curves are not supported ");
3104 if (rsc->m2 > usc->m2) {
3105 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
3106 "Min-rate service curve is greater than "
3107 "the max-rate service curve.");
3111 class->min_rate = fsc->m2;
3112 class->max_rate = usc->m2;
3117 hfsc_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
3118 struct hfsc_class *options,
3119 struct netdev_queue_stats *stats)
3122 unsigned int handle;
3123 struct nlattr *nl_options;
3125 error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
3131 unsigned int major, minor;
3133 major = tc_get_major(handle);
3134 minor = tc_get_minor(handle);
3135 if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3136 *queue_id = minor - 1;
3143 error = hfsc_parse_tca_options__(nl_options, options);
3150 hfsc_query_class__(const struct netdev *netdev, unsigned int handle,
3151 unsigned int parent, struct hfsc_class *options,
3152 struct netdev_queue_stats *stats)
3155 struct ofpbuf *reply;
3157 error = tc_query_class(netdev, handle, parent, &reply);
3162 error = hfsc_parse_tcmsg__(reply, NULL, options, stats);
3163 ofpbuf_delete(reply);
3168 hfsc_parse_qdisc_details__(struct netdev *netdev, const struct smap *details,
3169 struct hfsc_class *class)
3172 const char *max_rate_s;
3174 max_rate_s = smap_get(details, "max-rate");
3175 max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
3178 enum netdev_features current;
3180 netdev_get_features(netdev, ¤t, NULL, NULL, NULL);
3181 max_rate = netdev_features_to_bps(current, 100 * 1000 * 1000) / 8;
3184 class->min_rate = max_rate;
3185 class->max_rate = max_rate;
3189 hfsc_parse_class_details__(struct netdev *netdev,
3190 const struct smap *details,
3191 struct hfsc_class * class)
3193 const struct hfsc *hfsc;
3194 uint32_t min_rate, max_rate;
3195 const char *min_rate_s, *max_rate_s;
3197 hfsc = hfsc_get__(netdev);
3198 min_rate_s = smap_get(details, "min-rate");
3199 max_rate_s = smap_get(details, "max-rate");
3201 min_rate = min_rate_s ? strtoull(min_rate_s, NULL, 10) / 8 : 0;
3202 min_rate = MAX(min_rate, 1);
3203 min_rate = MIN(min_rate, hfsc->max_rate);
3205 max_rate = (max_rate_s
3206 ? strtoull(max_rate_s, NULL, 10) / 8
3208 max_rate = MAX(max_rate, min_rate);
3209 max_rate = MIN(max_rate, hfsc->max_rate);
3211 class->min_rate = min_rate;
3212 class->max_rate = max_rate;
3217 /* Create an HFSC qdisc.
3219 * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
3221 hfsc_setup_qdisc__(struct netdev * netdev)
3223 struct tcmsg *tcmsg;
3224 struct ofpbuf request;
3225 struct tc_hfsc_qopt opt;
3227 tc_del_qdisc(netdev);
3229 tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
3230 NLM_F_EXCL | NLM_F_CREATE, &request);
3236 tcmsg->tcm_handle = tc_make_handle(1, 0);
3237 tcmsg->tcm_parent = TC_H_ROOT;
3239 memset(&opt, 0, sizeof opt);
3242 nl_msg_put_string(&request, TCA_KIND, "hfsc");
3243 nl_msg_put_unspec(&request, TCA_OPTIONS, &opt, sizeof opt);
3245 return tc_transact(&request, NULL);
3248 /* Create an HFSC class.
3250 * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
3251 * sc rate <min_rate> ul rate <max_rate>" */
3253 hfsc_setup_class__(struct netdev *netdev, unsigned int handle,
3254 unsigned int parent, struct hfsc_class *class)
3258 struct tcmsg *tcmsg;
3259 struct ofpbuf request;
3260 struct tc_service_curve min, max;
3262 tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
3268 tcmsg->tcm_handle = handle;
3269 tcmsg->tcm_parent = parent;
3273 min.m2 = class->min_rate;
3277 max.m2 = class->max_rate;
3279 nl_msg_put_string(&request, TCA_KIND, "hfsc");
3280 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3281 nl_msg_put_unspec(&request, TCA_HFSC_RSC, &min, sizeof min);
3282 nl_msg_put_unspec(&request, TCA_HFSC_FSC, &min, sizeof min);
3283 nl_msg_put_unspec(&request, TCA_HFSC_USC, &max, sizeof max);
3284 nl_msg_end_nested(&request, opt_offset);
3286 error = tc_transact(&request, NULL);
3288 VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
3289 "min-rate %ubps, max-rate %ubps (%s)",
3290 netdev_get_name(netdev),
3291 tc_get_major(handle), tc_get_minor(handle),
3292 tc_get_major(parent), tc_get_minor(parent),
3293 class->min_rate, class->max_rate, ovs_strerror(error));
3300 hfsc_tc_install(struct netdev *netdev, const struct smap *details)
3303 struct hfsc_class class;
3305 error = hfsc_setup_qdisc__(netdev);
3311 hfsc_parse_qdisc_details__(netdev, details, &class);
3312 error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3313 tc_make_handle(1, 0), &class);
3319 hfsc_install__(netdev, class.max_rate);
3324 hfsc_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3327 struct nl_dump dump;
3328 struct hfsc_class hc;
3331 hfsc_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
3332 hfsc_install__(netdev, hc.max_rate);
3334 if (!start_queue_dump(netdev, &dump)) {
3338 while (nl_dump_next(&dump, &msg)) {
3339 unsigned int queue_id;
3341 if (!hfsc_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
3342 hfsc_update_queue__(netdev, queue_id, &hc);
3346 nl_dump_done(&dump);
3351 hfsc_tc_destroy(struct tc *tc)
3354 struct hfsc_class *hc, *next;
3356 hfsc = CONTAINER_OF(tc, struct hfsc, tc);
3358 HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &hfsc->tc.queues) {
3359 hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3368 hfsc_qdisc_get(const struct netdev *netdev, struct smap *details)
3370 const struct hfsc *hfsc;
3371 hfsc = hfsc_get__(netdev);
3372 smap_add_format(details, "max-rate", "%llu", 8ULL * hfsc->max_rate);
3377 hfsc_qdisc_set(struct netdev *netdev, const struct smap *details)
3380 struct hfsc_class class;
3382 hfsc_parse_qdisc_details__(netdev, details, &class);
3383 error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3384 tc_make_handle(1, 0), &class);
3387 hfsc_get__(netdev)->max_rate = class.max_rate;
3394 hfsc_class_get(const struct netdev *netdev OVS_UNUSED,
3395 const struct tc_queue *queue, struct smap *details)
3397 const struct hfsc_class *hc;
3399 hc = hfsc_class_cast__(queue);
3400 smap_add_format(details, "min-rate", "%llu", 8ULL * hc->min_rate);
3401 if (hc->min_rate != hc->max_rate) {
3402 smap_add_format(details, "max-rate", "%llu", 8ULL * hc->max_rate);
3408 hfsc_class_set(struct netdev *netdev, unsigned int queue_id,
3409 const struct smap *details)
3412 struct hfsc_class class;
3414 error = hfsc_parse_class_details__(netdev, details, &class);
3419 error = hfsc_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3420 tc_make_handle(1, 0xfffe), &class);
3425 hfsc_update_queue__(netdev, queue_id, &class);
3430 hfsc_class_delete(struct netdev *netdev, struct tc_queue *queue)
3434 struct hfsc_class *hc;
3436 hc = hfsc_class_cast__(queue);
3437 hfsc = hfsc_get__(netdev);
3439 error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3441 hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3448 hfsc_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3449 struct netdev_queue_stats *stats)
3451 return hfsc_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3452 tc_make_handle(1, 0xfffe), NULL, stats);
3456 hfsc_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3457 const struct ofpbuf *nlmsg,
3458 netdev_dump_queue_stats_cb *cb, void *aux)
3460 struct netdev_queue_stats stats;
3461 unsigned int handle, major, minor;
3464 error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3469 major = tc_get_major(handle);
3470 minor = tc_get_minor(handle);
3471 if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3472 (*cb)(minor - 1, &stats, aux);
3477 static const struct tc_ops tc_ops_hfsc = {
3478 "hfsc", /* linux_name */
3479 "linux-hfsc", /* ovs_name */
3480 HFSC_N_QUEUES, /* n_queues */
3481 hfsc_tc_install, /* tc_install */
3482 hfsc_tc_load, /* tc_load */
3483 hfsc_tc_destroy, /* tc_destroy */
3484 hfsc_qdisc_get, /* qdisc_get */
3485 hfsc_qdisc_set, /* qdisc_set */
3486 hfsc_class_get, /* class_get */
3487 hfsc_class_set, /* class_set */
3488 hfsc_class_delete, /* class_delete */
3489 hfsc_class_get_stats, /* class_get_stats */
3490 hfsc_class_dump_stats /* class_dump_stats */
3493 /* "linux-default" traffic control class.
3495 * This class represents the default, unnamed Linux qdisc. It corresponds to
3496 * the "" (empty string) QoS type in the OVS database. */
3499 default_install__(struct netdev *netdev_)
3501 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3502 static const struct tc tc = TC_INITIALIZER(&tc, &tc_ops_default);
3504 /* Nothing but a tc class implementation is allowed to write to a tc. This
3505 * class never does that, so we can legitimately use a const tc object. */
3506 netdev->tc = CONST_CAST(struct tc *, &tc);
3510 default_tc_install(struct netdev *netdev,
3511 const struct smap *details OVS_UNUSED)
3513 default_install__(netdev);
3518 default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3520 default_install__(netdev);
3524 static const struct tc_ops tc_ops_default = {
3525 NULL, /* linux_name */
3530 NULL, /* tc_destroy */
3531 NULL, /* qdisc_get */
3532 NULL, /* qdisc_set */
3533 NULL, /* class_get */
3534 NULL, /* class_set */
3535 NULL, /* class_delete */
3536 NULL, /* class_get_stats */
3537 NULL /* class_dump_stats */
3540 /* "linux-other" traffic control class.
3545 other_tc_load(struct netdev *netdev_, struct ofpbuf *nlmsg OVS_UNUSED)
3547 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
3548 static const struct tc tc = TC_INITIALIZER(&tc, &tc_ops_other);
3550 /* Nothing but a tc class implementation is allowed to write to a tc. This
3551 * class never does that, so we can legitimately use a const tc object. */
3552 netdev->tc = CONST_CAST(struct tc *, &tc);
3556 static const struct tc_ops tc_ops_other = {
3557 NULL, /* linux_name */
3558 "linux-other", /* ovs_name */
3560 NULL, /* tc_install */
3562 NULL, /* tc_destroy */
3563 NULL, /* qdisc_get */
3564 NULL, /* qdisc_set */
3565 NULL, /* class_get */
3566 NULL, /* class_set */
3567 NULL, /* class_delete */
3568 NULL, /* class_get_stats */
3569 NULL /* class_dump_stats */
3572 /* Traffic control. */
3574 /* Number of kernel "tc" ticks per second. */
3575 static double ticks_per_s;
3577 /* Number of kernel "jiffies" per second. This is used for the purpose of
3578 * computing buffer sizes. Generally kernel qdiscs need to be able to buffer
3579 * one jiffy's worth of data.
3581 * There are two possibilities here:
3583 * - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3584 * approximate range of 100 to 1024. That means that we really need to
3585 * make sure that the qdisc can buffer that much data.
3587 * - 'buffer_hz' is an absurdly large number. That means that the kernel
3588 * has finely granular timers and there's no need to fudge additional room
3589 * for buffers. (There's no extra effort needed to implement that: the
3590 * large 'buffer_hz' is used as a divisor, so practically any number will
3591 * come out as 0 in the division. Small integer results in the case of
3592 * really high dividends won't have any real effect anyhow.)
3594 static unsigned int buffer_hz;
3596 /* Returns tc handle 'major':'minor'. */
3598 tc_make_handle(unsigned int major, unsigned int minor)
3600 return TC_H_MAKE(major << 16, minor);
3603 /* Returns the major number from 'handle'. */
3605 tc_get_major(unsigned int handle)
3607 return TC_H_MAJ(handle) >> 16;
3610 /* Returns the minor number from 'handle'. */
3612 tc_get_minor(unsigned int handle)
3614 return TC_H_MIN(handle);
3617 static struct tcmsg *
3618 tc_make_request(const struct netdev *netdev, int type, unsigned int flags,
3619 struct ofpbuf *request)
3621 struct tcmsg *tcmsg;
3625 error = get_ifindex(netdev, &ifindex);
3630 ofpbuf_init(request, 512);
3631 nl_msg_put_nlmsghdr(request, sizeof *tcmsg, type, NLM_F_REQUEST | flags);
3632 tcmsg = ofpbuf_put_zeros(request, sizeof *tcmsg);
3633 tcmsg->tcm_family = AF_UNSPEC;
3634 tcmsg->tcm_ifindex = ifindex;
3635 /* Caller should fill in tcmsg->tcm_handle. */
3636 /* Caller should fill in tcmsg->tcm_parent. */
3642 tc_transact(struct ofpbuf *request, struct ofpbuf **replyp)
3644 int error = nl_transact(NETLINK_ROUTE, request, replyp);
3645 ofpbuf_uninit(request);
3649 /* Adds or deletes a root ingress qdisc on 'netdev'. We use this for
3650 * policing configuration.
3652 * This function is equivalent to running the following when 'add' is true:
3653 * /sbin/tc qdisc add dev <devname> handle ffff: ingress
3655 * This function is equivalent to running the following when 'add' is false:
3656 * /sbin/tc qdisc del dev <devname> handle ffff: ingress
3658 * The configuration and stats may be seen with the following command:
3659 * /sbin/tc -s qdisc show dev <devname>
3661 * Returns 0 if successful, otherwise a positive errno value.
3664 tc_add_del_ingress_qdisc(struct netdev *netdev, bool add)
3666 struct ofpbuf request;
3667 struct tcmsg *tcmsg;
3669 int type = add ? RTM_NEWQDISC : RTM_DELQDISC;
3670 int flags = add ? NLM_F_EXCL | NLM_F_CREATE : 0;
3672 tcmsg = tc_make_request(netdev, type, flags, &request);
3676 tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
3677 tcmsg->tcm_parent = TC_H_INGRESS;
3678 nl_msg_put_string(&request, TCA_KIND, "ingress");
3679 nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
3681 error = tc_transact(&request, NULL);
3683 /* If we're deleting the qdisc, don't worry about some of the
3684 * error conditions. */
3685 if (!add && (error == ENOENT || error == EINVAL)) {
3694 /* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
3697 * This function is equivalent to running:
3698 * /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
3699 * basic police rate <kbits_rate>kbit burst <kbits_burst>k
3702 * The configuration and stats may be seen with the following command:
3703 * /sbin/tc -s filter show <devname> eth0 parent ffff:
3705 * Returns 0 if successful, otherwise a positive errno value.
3708 tc_add_policer(struct netdev *netdev, int kbits_rate, int kbits_burst)
3710 struct tc_police tc_police;
3711 struct ofpbuf request;
3712 struct tcmsg *tcmsg;
3713 size_t basic_offset;
3714 size_t police_offset;
3718 memset(&tc_police, 0, sizeof tc_police);
3719 tc_police.action = TC_POLICE_SHOT;
3720 tc_police.mtu = mtu;
3721 tc_fill_rate(&tc_police.rate, (kbits_rate * 1000)/8, mtu);
3722 tc_police.burst = tc_bytes_to_ticks(tc_police.rate.rate,
3723 kbits_burst * 1024);
3725 tcmsg = tc_make_request(netdev, RTM_NEWTFILTER,
3726 NLM_F_EXCL | NLM_F_CREATE, &request);
3730 tcmsg->tcm_parent = tc_make_handle(0xffff, 0);
3731 tcmsg->tcm_info = tc_make_handle(49,
3732 (OVS_FORCE uint16_t) htons(ETH_P_ALL));
3734 nl_msg_put_string(&request, TCA_KIND, "basic");
3735 basic_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
3736 police_offset = nl_msg_start_nested(&request, TCA_BASIC_POLICE);
3737 nl_msg_put_unspec(&request, TCA_POLICE_TBF, &tc_police, sizeof tc_police);
3738 tc_put_rtab(&request, TCA_POLICE_RATE, &tc_police.rate);
3739 nl_msg_end_nested(&request, police_offset);
3740 nl_msg_end_nested(&request, basic_offset);
3742 error = tc_transact(&request, NULL);
3753 /* The values in psched are not individually very meaningful, but they are
3754 * important. The tables below show some values seen in the wild.
3758 * - "c" has always been a constant 1000000 since at least Linux 2.4.14.
3759 * (Before that, there are hints that it was 1000000000.)
3761 * - "d" can be unrealistically large, see the comment on 'buffer_hz'
3765 * -----------------------------------
3766 * [1] 000c8000 000f4240 000f4240 00000064
3767 * [2] 000003e8 00000400 000f4240 3b9aca00
3768 * [3] 000003e8 00000400 000f4240 3b9aca00
3769 * [4] 000003e8 00000400 000f4240 00000064
3770 * [5] 000003e8 00000040 000f4240 3b9aca00
3771 * [6] 000003e8 00000040 000f4240 000000f9
3773 * a b c d ticks_per_s buffer_hz
3774 * ------- --------- ---------- ------------- ----------- -------------
3775 * [1] 819,200 1,000,000 1,000,000 100 819,200 100
3776 * [2] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
3777 * [3] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
3778 * [4] 1,000 1,024 1,000,000 100 976,562 100
3779 * [5] 1,000 64 1,000,000 1,000,000,000 15,625,000 1,000,000,000
3780 * [6] 1,000 64 1,000,000 249 15,625,000 249
3782 * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
3783 * [2] 2.6.26-1-686-bigmem from Debian lenny
3784 * [3] 2.6.26-2-sparc64 from Debian lenny
3785 * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
3786 * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
3787 * [6] 2.6.34 from kernel.org on KVM
3789 static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
3790 static const char fn[] = "/proc/net/psched";
3791 unsigned int a, b, c, d;
3794 if (!ovsthread_once_start(&once)) {
3801 stream = fopen(fn, "r");
3803 VLOG_WARN("%s: open failed: %s", fn, ovs_strerror(errno));
3807 if (fscanf(stream, "%x %x %x %x", &a, &b, &c, &d) != 4) {
3808 VLOG_WARN("%s: read failed", fn);
3812 VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn, a, b, c, d);
3816 VLOG_WARN("%s: invalid scheduler parameters", fn);
3820 ticks_per_s = (double) a * c / b;
3824 VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
3827 VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn, ticks_per_s, buffer_hz);
3830 ovsthread_once_done(&once);
3833 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
3834 * rate of 'rate' bytes per second. */
3836 tc_ticks_to_bytes(unsigned int rate, unsigned int ticks)
3839 return (rate * ticks) / ticks_per_s;
3842 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
3843 * rate of 'rate' bytes per second. */
3845 tc_bytes_to_ticks(unsigned int rate, unsigned int size)
3848 return rate ? ((unsigned long long int) ticks_per_s * size) / rate : 0;
3851 /* Returns the number of bytes that need to be reserved for qdisc buffering at
3852 * a transmission rate of 'rate' bytes per second. */
3854 tc_buffer_per_jiffy(unsigned int rate)
3857 return rate / buffer_hz;
3860 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
3861 * e.g. "htb", into '*kind' (if it is nonnull). If 'options' is nonnull,
3862 * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
3863 * stores NULL into it if it is absent.
3865 * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
3868 * Returns 0 if successful, otherwise a positive errno value. */
3870 tc_parse_qdisc(const struct ofpbuf *msg, const char **kind,
3871 struct nlattr **options)
3873 static const struct nl_policy tca_policy[] = {
3874 [TCA_KIND] = { .type = NL_A_STRING, .optional = false },
3875 [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
3877 struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3879 if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3880 tca_policy, ta, ARRAY_SIZE(ta))) {
3881 VLOG_WARN_RL(&rl, "failed to parse qdisc message");
3886 *kind = nl_attr_get_string(ta[TCA_KIND]);
3890 *options = ta[TCA_OPTIONS];
3905 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
3906 * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
3907 * into '*options', and its queue statistics into '*stats'. Any of the output
3908 * arguments may be null.
3910 * Returns 0 if successful, otherwise a positive errno value. */
3912 tc_parse_class(const struct ofpbuf *msg, unsigned int *handlep,
3913 struct nlattr **options, struct netdev_queue_stats *stats)
3915 static const struct nl_policy tca_policy[] = {
3916 [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = false },
3917 [TCA_STATS2] = { .type = NL_A_NESTED, .optional = false },
3919 struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3921 if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3922 tca_policy, ta, ARRAY_SIZE(ta))) {
3923 VLOG_WARN_RL(&rl, "failed to parse class message");
3928 struct tcmsg *tc = ofpbuf_at_assert(msg, NLMSG_HDRLEN, sizeof *tc);
3929 *handlep = tc->tcm_handle;
3933 *options = ta[TCA_OPTIONS];
3937 const struct gnet_stats_queue *gsq;
3938 struct gnet_stats_basic gsb;
3940 static const struct nl_policy stats_policy[] = {
3941 [TCA_STATS_BASIC] = { .type = NL_A_UNSPEC, .optional = false,
3942 .min_len = sizeof gsb },
3943 [TCA_STATS_QUEUE] = { .type = NL_A_UNSPEC, .optional = false,
3944 .min_len = sizeof *gsq },
3946 struct nlattr *sa[ARRAY_SIZE(stats_policy)];
3948 if (!nl_parse_nested(ta[TCA_STATS2], stats_policy,
3949 sa, ARRAY_SIZE(sa))) {
3950 VLOG_WARN_RL(&rl, "failed to parse class stats");
3954 /* Alignment issues screw up the length of struct gnet_stats_basic on
3955 * some arch/bitsize combinations. Newer versions of Linux have a
3956 * struct gnet_stats_basic_packed, but we can't depend on that. The
3957 * easiest thing to do is just to make a copy. */
3958 memset(&gsb, 0, sizeof gsb);
3959 memcpy(&gsb, nl_attr_get(sa[TCA_STATS_BASIC]),
3960 MIN(nl_attr_get_size(sa[TCA_STATS_BASIC]), sizeof gsb));
3961 stats->tx_bytes = gsb.bytes;
3962 stats->tx_packets = gsb.packets;
3964 gsq = nl_attr_get(sa[TCA_STATS_QUEUE]);
3965 stats->tx_errors = gsq->drops;
3975 memset(stats, 0, sizeof *stats);
3980 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
3983 tc_query_class(const struct netdev *netdev,
3984 unsigned int handle, unsigned int parent,
3985 struct ofpbuf **replyp)
3987 struct ofpbuf request;
3988 struct tcmsg *tcmsg;
3991 tcmsg = tc_make_request(netdev, RTM_GETTCLASS, NLM_F_ECHO, &request);
3995 tcmsg->tcm_handle = handle;
3996 tcmsg->tcm_parent = parent;
3998 error = tc_transact(&request, replyp);
4000 VLOG_WARN_RL(&rl, "query %s class %u:%u (parent %u:%u) failed (%s)",
4001 netdev_get_name(netdev),
4002 tc_get_major(handle), tc_get_minor(handle),
4003 tc_get_major(parent), tc_get_minor(parent),
4004 ovs_strerror(error));
4009 /* Equivalent to "tc class del dev <name> handle <handle>". */
4011 tc_delete_class(const struct netdev *netdev, unsigned int handle)
4013 struct ofpbuf request;
4014 struct tcmsg *tcmsg;
4017 tcmsg = tc_make_request(netdev, RTM_DELTCLASS, 0, &request);
4021 tcmsg->tcm_handle = handle;
4022 tcmsg->tcm_parent = 0;
4024 error = tc_transact(&request, NULL);
4026 VLOG_WARN_RL(&rl, "delete %s class %u:%u failed (%s)",
4027 netdev_get_name(netdev),
4028 tc_get_major(handle), tc_get_minor(handle),
4029 ovs_strerror(error));
4034 /* Equivalent to "tc qdisc del dev <name> root". */
4036 tc_del_qdisc(struct netdev *netdev_)
4038 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4039 struct ofpbuf request;
4040 struct tcmsg *tcmsg;
4043 tcmsg = tc_make_request(netdev_, RTM_DELQDISC, 0, &request);
4047 tcmsg->tcm_handle = tc_make_handle(1, 0);
4048 tcmsg->tcm_parent = TC_H_ROOT;
4050 error = tc_transact(&request, NULL);
4051 if (error == EINVAL) {
4052 /* EINVAL probably means that the default qdisc was in use, in which
4053 * case we've accomplished our purpose. */
4056 if (!error && netdev->tc) {
4057 if (netdev->tc->ops->tc_destroy) {
4058 netdev->tc->ops->tc_destroy(netdev->tc);
4065 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
4066 * kernel to determine what they are. Returns 0 if successful, otherwise a
4067 * positive errno value. */
4069 tc_query_qdisc(const struct netdev *netdev_)
4071 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4072 struct ofpbuf request, *qdisc;
4073 const struct tc_ops *ops;
4074 struct tcmsg *tcmsg;
4082 /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
4083 * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
4084 * 2.6.35 without that fix backported to it.
4086 * To avoid the OOPS, we must not make a request that would attempt to dump
4087 * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
4088 * few others. There are a few ways that I can see to do this, but most of
4089 * them seem to be racy (and if you lose the race the kernel OOPSes). The
4090 * technique chosen here is to assume that any non-default qdisc that we
4091 * create will have a class with handle 1:0. The built-in qdiscs only have
4092 * a class with handle 0:0.
4094 * We could check for Linux 2.6.35+ and use a more straightforward method
4096 tcmsg = tc_make_request(netdev_, RTM_GETQDISC, NLM_F_ECHO, &request);
4100 tcmsg->tcm_handle = tc_make_handle(1, 0);
4101 tcmsg->tcm_parent = 0;
4103 /* Figure out what tc class to instantiate. */
4104 error = tc_transact(&request, &qdisc);
4108 error = tc_parse_qdisc(qdisc, &kind, NULL);
4110 ops = &tc_ops_other;
4112 ops = tc_lookup_linux_name(kind);
4114 static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 1);
4115 VLOG_INFO_RL(&rl2, "unknown qdisc \"%s\"", kind);
4117 ops = &tc_ops_other;
4120 } else if (error == ENOENT) {
4121 /* Either it's a built-in qdisc, or it's a qdisc set up by some
4122 * other entity that doesn't have a handle 1:0. We will assume
4123 * that it's the system default qdisc. */
4124 ops = &tc_ops_default;
4127 /* Who knows? Maybe the device got deleted. */
4128 VLOG_WARN_RL(&rl, "query %s qdisc failed (%s)",
4129 netdev_get_name(netdev_), ovs_strerror(error));
4130 ops = &tc_ops_other;
4133 /* Instantiate it. */
4134 load_error = ops->tc_load(CONST_CAST(struct netdev *, netdev_), qdisc);
4135 ovs_assert((load_error == 0) == (netdev->tc != NULL));
4136 ofpbuf_delete(qdisc);
4138 return error ? error : load_error;
4141 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
4142 approximate the time to transmit packets of various lengths. For an MTU of
4143 256 or less, each entry is exact; for an MTU of 257 through 512, each entry
4144 represents two possible packet lengths; for a MTU of 513 through 1024, four
4145 possible lengths; and so on.
4147 Returns, for the specified 'mtu', the number of bits that packet lengths
4148 need to be shifted right to fit within such a 256-entry table. */
4150 tc_calc_cell_log(unsigned int mtu)
4155 mtu = ETH_PAYLOAD_MAX;
4157 mtu += ETH_HEADER_LEN + VLAN_HEADER_LEN;
4159 for (cell_log = 0; mtu >= 256; cell_log++) {
4166 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
4169 tc_fill_rate(struct tc_ratespec *rate, uint64_t Bps, int mtu)
4171 memset(rate, 0, sizeof *rate);
4172 rate->cell_log = tc_calc_cell_log(mtu);
4173 /* rate->overhead = 0; */ /* New in 2.6.24, not yet in some */
4174 /* rate->cell_align = 0; */ /* distro headers. */
4175 rate->mpu = ETH_TOTAL_MIN;
4179 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
4180 * attribute of the specified "type".
4182 * See tc_calc_cell_log() above for a description of "rtab"s. */
4184 tc_put_rtab(struct ofpbuf *msg, uint16_t type, const struct tc_ratespec *rate)
4189 rtab = nl_msg_put_unspec_uninit(msg, type, TC_RTAB_SIZE);
4190 for (i = 0; i < TC_RTAB_SIZE / sizeof *rtab; i++) {
4191 unsigned packet_size = (i + 1) << rate->cell_log;
4192 if (packet_size < rate->mpu) {
4193 packet_size = rate->mpu;
4195 rtab[i] = tc_bytes_to_ticks(rate->rate, packet_size);
4199 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
4200 * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
4201 * burst size of 'burst_bytes'. (If no value was requested, a 'burst_bytes' of
4204 tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes)
4206 unsigned int min_burst = tc_buffer_per_jiffy(Bps) + mtu;
4207 return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
4210 /* Linux-only functions declared in netdev-linux.h */
4212 /* Returns a fd for an AF_INET socket or a negative errno value. */
4214 netdev_linux_get_af_inet_sock(void)
4216 int error = netdev_linux_init();
4217 return error ? -error : af_inet_sock;
4220 /* Modifies the 'flag' bit in ethtool's flags field for 'netdev'. If
4221 * 'enable' is true, the bit is set. Otherwise, it is cleared. */
4223 netdev_linux_ethtool_set_flag(struct netdev *netdev, uint32_t flag,
4224 const char *flag_name, bool enable)
4226 const char *netdev_name = netdev_get_name(netdev);
4227 struct ethtool_value evalue;
4231 COVERAGE_INC(netdev_get_ethtool);
4232 memset(&evalue, 0, sizeof evalue);
4233 error = netdev_linux_do_ethtool(netdev_name,
4234 (struct ethtool_cmd *)&evalue,
4235 ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4240 COVERAGE_INC(netdev_set_ethtool);
4241 evalue.data = new_flags = (evalue.data & ~flag) | (enable ? flag : 0);
4242 error = netdev_linux_do_ethtool(netdev_name,
4243 (struct ethtool_cmd *)&evalue,
4244 ETHTOOL_SFLAGS, "ETHTOOL_SFLAGS");
4249 COVERAGE_INC(netdev_get_ethtool);
4250 memset(&evalue, 0, sizeof evalue);
4251 error = netdev_linux_do_ethtool(netdev_name,
4252 (struct ethtool_cmd *)&evalue,
4253 ETHTOOL_GFLAGS, "ETHTOOL_GFLAGS");
4258 if (new_flags != evalue.data) {
4259 VLOG_WARN_RL(&rl, "attempt to %s ethtool %s flag on network "
4260 "device %s failed", enable ? "enable" : "disable",
4261 flag_name, netdev_name);
4268 /* Utility functions. */
4270 /* Copies 'src' into 'dst', performing format conversion in the process. */
4272 netdev_stats_from_rtnl_link_stats(struct netdev_stats *dst,
4273 const struct rtnl_link_stats *src)
4275 dst->rx_packets = src->rx_packets;
4276 dst->tx_packets = src->tx_packets;
4277 dst->rx_bytes = src->rx_bytes;
4278 dst->tx_bytes = src->tx_bytes;
4279 dst->rx_errors = src->rx_errors;
4280 dst->tx_errors = src->tx_errors;
4281 dst->rx_dropped = src->rx_dropped;
4282 dst->tx_dropped = src->tx_dropped;
4283 dst->multicast = src->multicast;
4284 dst->collisions = src->collisions;
4285 dst->rx_length_errors = src->rx_length_errors;
4286 dst->rx_over_errors = src->rx_over_errors;
4287 dst->rx_crc_errors = src->rx_crc_errors;
4288 dst->rx_frame_errors = src->rx_frame_errors;
4289 dst->rx_fifo_errors = src->rx_fifo_errors;
4290 dst->rx_missed_errors = src->rx_missed_errors;
4291 dst->tx_aborted_errors = src->tx_aborted_errors;
4292 dst->tx_carrier_errors = src->tx_carrier_errors;
4293 dst->tx_fifo_errors = src->tx_fifo_errors;
4294 dst->tx_heartbeat_errors = src->tx_heartbeat_errors;
4295 dst->tx_window_errors = src->tx_window_errors;
4299 get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
4301 /* Policy for RTNLGRP_LINK messages.
4303 * There are *many* more fields in these messages, but currently we only
4304 * care about these fields. */
4305 static const struct nl_policy rtnlgrp_link_policy[] = {
4306 [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
4307 [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
4308 .min_len = sizeof(struct rtnl_link_stats) },
4311 struct ofpbuf request;
4312 struct ofpbuf *reply;
4313 struct ifinfomsg *ifi;
4314 struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
4317 ofpbuf_init(&request, 0);
4318 nl_msg_put_nlmsghdr(&request, sizeof *ifi, RTM_GETLINK, NLM_F_REQUEST);
4319 ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
4320 ifi->ifi_family = PF_UNSPEC;
4321 ifi->ifi_index = ifindex;
4322 error = nl_transact(NETLINK_ROUTE, &request, &reply);
4323 ofpbuf_uninit(&request);
4328 if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
4329 rtnlgrp_link_policy,
4330 attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
4331 ofpbuf_delete(reply);
4335 if (!attrs[IFLA_STATS]) {
4336 VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
4337 ofpbuf_delete(reply);
4341 netdev_stats_from_rtnl_link_stats(stats, nl_attr_get(attrs[IFLA_STATS]));
4343 ofpbuf_delete(reply);
4349 get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
4351 static const char fn[] = "/proc/net/dev";
4356 stream = fopen(fn, "r");
4358 VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, ovs_strerror(errno));
4363 while (fgets(line, sizeof line, stream)) {
4366 #define X64 "%"SCNu64
4369 X64 X64 X64 X64 X64 X64 X64 "%*u"
4370 X64 X64 X64 X64 X64 X64 X64 "%*u",
4376 &stats->rx_fifo_errors,
4377 &stats->rx_frame_errors,
4383 &stats->tx_fifo_errors,
4385 &stats->tx_carrier_errors) != 15) {
4386 VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
4387 } else if (!strcmp(devname, netdev_name)) {
4388 stats->rx_length_errors = UINT64_MAX;
4389 stats->rx_over_errors = UINT64_MAX;
4390 stats->rx_crc_errors = UINT64_MAX;
4391 stats->rx_missed_errors = UINT64_MAX;
4392 stats->tx_aborted_errors = UINT64_MAX;
4393 stats->tx_heartbeat_errors = UINT64_MAX;
4394 stats->tx_window_errors = UINT64_MAX;
4400 VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
4406 get_flags(const struct netdev *dev, unsigned int *flags)
4412 error = netdev_linux_do_ioctl(dev->name, &ifr, SIOCGIFFLAGS,
4415 *flags = ifr.ifr_flags;
4421 set_flags(const char *name, unsigned int flags)
4425 ifr.ifr_flags = flags;
4426 return netdev_linux_do_ioctl(name, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
4430 do_get_ifindex(const char *netdev_name)
4434 ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4435 COVERAGE_INC(netdev_get_ifindex);
4436 if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
4437 VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
4438 netdev_name, ovs_strerror(errno));
4441 return ifr.ifr_ifindex;
4445 get_ifindex(const struct netdev *netdev_, int *ifindexp)
4447 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
4449 if (!(netdev->cache_valid & VALID_IFINDEX)) {
4450 int ifindex = do_get_ifindex(netdev_get_name(netdev_));
4453 netdev->get_ifindex_error = -ifindex;
4454 netdev->ifindex = 0;
4456 netdev->get_ifindex_error = 0;
4457 netdev->ifindex = ifindex;
4459 netdev->cache_valid |= VALID_IFINDEX;
4462 *ifindexp = netdev->ifindex;
4463 return netdev->get_ifindex_error;
4467 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
4472 memset(&ifr, 0, sizeof ifr);
4473 ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4474 COVERAGE_INC(netdev_get_hwaddr);
4475 if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
4476 /* ENODEV probably means that a vif disappeared asynchronously and
4477 * hasn't been removed from the database yet, so reduce the log level
4478 * to INFO for that case. */
4479 VLOG(errno == ENODEV ? VLL_INFO : VLL_ERR,
4480 "ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4481 netdev_name, ovs_strerror(errno));
4484 hwaddr_family = ifr.ifr_hwaddr.sa_family;
4485 if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
4486 VLOG_WARN("%s device has unknown hardware address family %d",
4487 netdev_name, hwaddr_family);
4489 memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
4494 set_etheraddr(const char *netdev_name,
4495 const uint8_t mac[ETH_ADDR_LEN])
4499 memset(&ifr, 0, sizeof ifr);
4500 ovs_strzcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4501 ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
4502 memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
4503 COVERAGE_INC(netdev_set_hwaddr);
4504 if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
4505 VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4506 netdev_name, ovs_strerror(errno));
4513 netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd,
4514 int cmd, const char *cmd_name)
4518 memset(&ifr, 0, sizeof ifr);
4519 ovs_strzcpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
4520 ifr.ifr_data = (caddr_t) ecmd;
4523 if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) {
4526 if (errno != EOPNOTSUPP) {
4527 VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
4528 "failed: %s", cmd_name, name, ovs_strerror(errno));
4530 /* The device doesn't support this operation. That's pretty
4531 * common, so there's no point in logging anything. */
4538 netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd,
4539 const char *cmd_name)
4541 ovs_strzcpy(ifr->ifr_name, name, sizeof ifr->ifr_name);
4542 if (ioctl(af_inet_sock, cmd, ifr) == -1) {
4543 VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", name, cmd_name,
4544 ovs_strerror(errno));
4551 netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
4552 int cmd, const char *cmd_name)
4557 ifr.ifr_addr.sa_family = AF_INET;
4558 error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name);
4560 const struct sockaddr_in *sin = ALIGNED_CAST(struct sockaddr_in *,
4562 *ip = sin->sin_addr;
4567 /* Returns an AF_PACKET raw socket or a negative errno value. */
4569 af_packet_sock(void)
4571 static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
4574 if (ovsthread_once_start(&once)) {
4575 sock = socket(AF_PACKET, SOCK_RAW, 0);
4577 int error = set_nonblocking(sock);
4584 VLOG_ERR("failed to create packet socket: %s",
4585 ovs_strerror(errno));
4587 ovsthread_once_done(&once);