2 * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 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 <sys/types.h>
37 #include <sys/ioctl.h>
38 #include <sys/socket.h>
39 #include <netpacket/packet.h>
41 #include <net/if_arp.h>
42 #include <net/if_packet.h>
43 #include <net/route.h>
44 #include <netinet/in.h>
51 #include "dpif-linux.h"
52 #include "dpif-netdev.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"
64 #include "ovs-atomic.h"
65 #include "packet-dpif.h"
67 #include "poll-loop.h"
68 #include "rtnetlink-link.h"
70 #include "socket-util.h"
73 #include "unaligned.h"
76 VLOG_DEFINE_THIS_MODULE(netdev_linux
);
78 COVERAGE_DEFINE(netdev_set_policing
);
79 COVERAGE_DEFINE(netdev_arp_lookup
);
80 COVERAGE_DEFINE(netdev_get_ifindex
);
81 COVERAGE_DEFINE(netdev_get_hwaddr
);
82 COVERAGE_DEFINE(netdev_set_hwaddr
);
83 COVERAGE_DEFINE(netdev_get_ethtool
);
84 COVERAGE_DEFINE(netdev_set_ethtool
);
87 /* These were introduced in Linux 2.6.14, so they might be missing if we have
89 #ifndef ADVERTISED_Pause
90 #define ADVERTISED_Pause (1 << 13)
92 #ifndef ADVERTISED_Asym_Pause
93 #define ADVERTISED_Asym_Pause (1 << 14)
96 /* These were introduced in Linux 2.6.24, so they might be missing if we
97 * have old headers. */
98 #ifndef ETHTOOL_GFLAGS
99 #define ETHTOOL_GFLAGS 0x00000025 /* Get flags bitmap(ethtool_value) */
101 #ifndef ETHTOOL_SFLAGS
102 #define ETHTOOL_SFLAGS 0x00000026 /* Set flags bitmap(ethtool_value) */
105 /* This was introduced in Linux 2.6.25, so it might be missing if we have old
108 #define TC_RTAB_SIZE 1024
111 /* Linux 2.6.21 introduced struct tpacket_auxdata.
112 * Linux 2.6.27 added the tp_vlan_tci member.
113 * Linux 3.0 defined TP_STATUS_VLAN_VALID.
114 * Linux 3.13 repurposed a padding member for tp_vlan_tpid and defined
115 * TP_STATUS_VLAN_TPID_VALID.
117 * With all this churn it's easiest to unconditionally define a replacement
118 * structure that has everything we want.
120 #ifndef PACKET_AUXDATA
121 #define PACKET_AUXDATA 8
123 #ifndef TP_STATUS_VLAN_VALID
124 #define TP_STATUS_VLAN_VALID (1 << 4)
126 #ifndef TP_STATUS_VLAN_TPID_VALID
127 #define TP_STATUS_VLAN_TPID_VALID (1 << 6)
129 #undef tpacket_auxdata
130 #define tpacket_auxdata rpl_tpacket_auxdata
131 struct tpacket_auxdata
{
137 uint16_t tp_vlan_tci
;
138 uint16_t tp_vlan_tpid
;
142 VALID_IFINDEX
= 1 << 0,
143 VALID_ETHERADDR
= 1 << 1,
147 VALID_POLICING
= 1 << 5,
148 VALID_VPORT_STAT_ERROR
= 1 << 6,
149 VALID_DRVINFO
= 1 << 7,
150 VALID_FEATURES
= 1 << 8,
153 /* Traffic control. */
155 /* An instance of a traffic control class. Always associated with a particular
158 * Each TC implementation subclasses this with whatever additional data it
161 const struct tc_ops
*ops
;
162 struct hmap queues
; /* Contains "struct tc_queue"s.
163 * Read by generic TC layer.
164 * Written only by TC implementation. */
167 #define TC_INITIALIZER(TC, OPS) { OPS, HMAP_INITIALIZER(&(TC)->queues) }
169 /* One traffic control queue.
171 * Each TC implementation subclasses this with whatever additional data it
174 struct hmap_node hmap_node
; /* In struct tc's "queues" hmap. */
175 unsigned int queue_id
; /* OpenFlow queue ID. */
176 long long int created
; /* Time queue was created, in msecs. */
179 /* A particular kind of traffic control. Each implementation generally maps to
180 * one particular Linux qdisc class.
182 * The functions below return 0 if successful or a positive errno value on
183 * failure, except where otherwise noted. All of them must be provided, except
184 * where otherwise noted. */
186 /* Name used by kernel in the TCA_KIND attribute of tcmsg, e.g. "htb".
187 * This is null for tc_ops_default and tc_ops_other, for which there are no
188 * appropriate values. */
189 const char *linux_name
;
191 /* Name used in OVS database, e.g. "linux-htb". Must be nonnull. */
192 const char *ovs_name
;
194 /* Number of supported OpenFlow queues, 0 for qdiscs that have no
195 * queues. The queues are numbered 0 through n_queues - 1. */
196 unsigned int n_queues
;
198 /* Called to install this TC class on 'netdev'. The implementation should
199 * make the Netlink calls required to set up 'netdev' with the right qdisc
200 * and configure it according to 'details'. The implementation may assume
201 * that the current qdisc is the default; that is, there is no need for it
202 * to delete the current qdisc before installing itself.
204 * The contents of 'details' should be documented as valid for 'ovs_name'
205 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
206 * (which is built as ovs-vswitchd.conf.db(8)).
208 * This function must return 0 if and only if it sets 'netdev->tc' to an
209 * initialized 'struct tc'.
211 * (This function is null for tc_ops_other, which cannot be installed. For
212 * other TC classes it should always be nonnull.) */
213 int (*tc_install
)(struct netdev
*netdev
, const struct smap
*details
);
215 /* Called when the netdev code determines (through a Netlink query) that
216 * this TC class's qdisc is installed on 'netdev', but we didn't install
217 * it ourselves and so don't know any of the details.
219 * 'nlmsg' is the kernel reply to a RTM_GETQDISC Netlink message for
220 * 'netdev'. The TCA_KIND attribute of 'nlmsg' is 'linux_name'. The
221 * implementation should parse the other attributes of 'nlmsg' as
222 * necessary to determine its configuration. If necessary it should also
223 * use Netlink queries to determine the configuration of queues on
226 * This function must return 0 if and only if it sets 'netdev->tc' to an
227 * initialized 'struct tc'. */
228 int (*tc_load
)(struct netdev
*netdev
, struct ofpbuf
*nlmsg
);
230 /* Destroys the data structures allocated by the implementation as part of
231 * 'tc'. (This includes destroying 'tc->queues' by calling
234 * The implementation should not need to perform any Netlink calls. If
235 * desirable, the caller is responsible for deconfiguring the kernel qdisc.
236 * (But it may not be desirable.)
238 * This function may be null if 'tc' is trivial. */
239 void (*tc_destroy
)(struct tc
*tc
);
241 /* Retrieves details of 'netdev->tc' configuration into 'details'.
243 * The implementation should not need to perform any Netlink calls, because
244 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
245 * cached the configuration.
247 * The contents of 'details' should be documented as valid for 'ovs_name'
248 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
249 * (which is built as ovs-vswitchd.conf.db(8)).
251 * This function may be null if 'tc' is not configurable.
253 int (*qdisc_get
)(const struct netdev
*netdev
, struct smap
*details
);
255 /* Reconfigures 'netdev->tc' according to 'details', performing any
256 * required Netlink calls to complete the reconfiguration.
258 * The contents of 'details' should be documented as valid for 'ovs_name'
259 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
260 * (which is built as ovs-vswitchd.conf.db(8)).
262 * This function may be null if 'tc' is not configurable.
264 int (*qdisc_set
)(struct netdev
*, const struct smap
*details
);
266 /* Retrieves details of 'queue' on 'netdev->tc' into 'details'. 'queue' is
267 * one of the 'struct tc_queue's within 'netdev->tc->queues'.
269 * The contents of 'details' should be documented as valid for 'ovs_name'
270 * in the "other_config" column in the "Queue" table in
271 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
273 * The implementation should not need to perform any Netlink calls, because
274 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
275 * cached the queue configuration.
277 * This function may be null if 'tc' does not have queues ('n_queues' is
279 int (*class_get
)(const struct netdev
*netdev
, const struct tc_queue
*queue
,
280 struct smap
*details
);
282 /* Configures or reconfigures 'queue_id' on 'netdev->tc' according to
283 * 'details', perfoming any required Netlink calls to complete the
284 * reconfiguration. The caller ensures that 'queue_id' is less than
287 * The contents of 'details' should be documented as valid for 'ovs_name'
288 * in the "other_config" column in the "Queue" table in
289 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
291 * This function may be null if 'tc' does not have queues or its queues are
292 * not configurable. */
293 int (*class_set
)(struct netdev
*, unsigned int queue_id
,
294 const struct smap
*details
);
296 /* Deletes 'queue' from 'netdev->tc'. 'queue' is one of the 'struct
297 * tc_queue's within 'netdev->tc->queues'.
299 * This function may be null if 'tc' does not have queues or its queues
300 * cannot be deleted. */
301 int (*class_delete
)(struct netdev
*, struct tc_queue
*queue
);
303 /* Obtains stats for 'queue' from 'netdev->tc'. 'queue' is one of the
304 * 'struct tc_queue's within 'netdev->tc->queues'.
306 * On success, initializes '*stats'.
308 * This function may be null if 'tc' does not have queues or if it cannot
309 * report queue statistics. */
310 int (*class_get_stats
)(const struct netdev
*netdev
,
311 const struct tc_queue
*queue
,
312 struct netdev_queue_stats
*stats
);
314 /* Extracts queue stats from 'nlmsg', which is a response to a
315 * RTM_GETTCLASS message, and passes them to 'cb' along with 'aux'.
317 * This function may be null if 'tc' does not have queues or if it cannot
318 * report queue statistics. */
319 int (*class_dump_stats
)(const struct netdev
*netdev
,
320 const struct ofpbuf
*nlmsg
,
321 netdev_dump_queue_stats_cb
*cb
, void *aux
);
325 tc_init(struct tc
*tc
, const struct tc_ops
*ops
)
328 hmap_init(&tc
->queues
);
332 tc_destroy(struct tc
*tc
)
334 hmap_destroy(&tc
->queues
);
337 static const struct tc_ops tc_ops_htb
;
338 static const struct tc_ops tc_ops_hfsc
;
339 static const struct tc_ops tc_ops_default
;
340 static const struct tc_ops tc_ops_other
;
342 static const struct tc_ops
*const tcs
[] = {
343 &tc_ops_htb
, /* Hierarchy token bucket (see tc-htb(8)). */
344 &tc_ops_hfsc
, /* Hierarchical fair service curve. */
345 &tc_ops_default
, /* Default qdisc (see tc-pfifo_fast(8)). */
346 &tc_ops_other
, /* Some other qdisc. */
350 static unsigned int tc_make_handle(unsigned int major
, unsigned int minor
);
351 static unsigned int tc_get_major(unsigned int handle
);
352 static unsigned int tc_get_minor(unsigned int handle
);
354 static unsigned int tc_ticks_to_bytes(unsigned int rate
, unsigned int ticks
);
355 static unsigned int tc_bytes_to_ticks(unsigned int rate
, unsigned int size
);
356 static unsigned int tc_buffer_per_jiffy(unsigned int rate
);
358 static struct tcmsg
*tc_make_request(const struct netdev
*, int type
,
359 unsigned int flags
, struct ofpbuf
*);
360 static int tc_transact(struct ofpbuf
*request
, struct ofpbuf
**replyp
);
361 static int tc_add_del_ingress_qdisc(struct netdev
*netdev
, bool add
);
362 static int tc_add_policer(struct netdev
*netdev
, int kbits_rate
,
365 static int tc_parse_qdisc(const struct ofpbuf
*, const char **kind
,
366 struct nlattr
**options
);
367 static int tc_parse_class(const struct ofpbuf
*, unsigned int *queue_id
,
368 struct nlattr
**options
,
369 struct netdev_queue_stats
*);
370 static int tc_query_class(const struct netdev
*,
371 unsigned int handle
, unsigned int parent
,
372 struct ofpbuf
**replyp
);
373 static int tc_delete_class(const struct netdev
*, unsigned int handle
);
375 static int tc_del_qdisc(struct netdev
*netdev
);
376 static int tc_query_qdisc(const struct netdev
*netdev
);
378 static int tc_calc_cell_log(unsigned int mtu
);
379 static void tc_fill_rate(struct tc_ratespec
*rate
, uint64_t bps
, int mtu
);
380 static void tc_put_rtab(struct ofpbuf
*, uint16_t type
,
381 const struct tc_ratespec
*rate
);
382 static int tc_calc_buffer(unsigned int Bps
, int mtu
, uint64_t burst_bytes
);
384 struct netdev_linux
{
387 /* Protects all members below. */
388 struct ovs_mutex mutex
;
390 unsigned int cache_valid
;
392 bool miimon
; /* Link status of last poll. */
393 long long int miimon_interval
; /* Miimon Poll rate. Disabled if <= 0. */
394 struct timer miimon_timer
;
396 /* The following are figured out "on demand" only. They are only valid
397 * when the corresponding VALID_* bit in 'cache_valid' is set. */
399 uint8_t etheraddr
[ETH_ADDR_LEN
];
400 struct in_addr address
, netmask
;
403 unsigned int ifi_flags
;
404 long long int carrier_resets
;
405 uint32_t kbits_rate
; /* Policing data. */
406 uint32_t kbits_burst
;
407 int vport_stats_error
; /* Cached error code from vport_get_stats().
408 0 or an errno value. */
409 int netdev_mtu_error
; /* Cached error code from SIOCGIFMTU or SIOCSIFMTU. */
410 int ether_addr_error
; /* Cached error code from set/get etheraddr. */
411 int netdev_policing_error
; /* Cached error code from set policing. */
412 int get_features_error
; /* Cached error code from ETHTOOL_GSET. */
413 int get_ifindex_error
; /* Cached error code from SIOCGIFINDEX. */
415 enum netdev_features current
; /* Cached from ETHTOOL_GSET. */
416 enum netdev_features advertised
; /* Cached from ETHTOOL_GSET. */
417 enum netdev_features supported
; /* Cached from ETHTOOL_GSET. */
419 struct ethtool_drvinfo drvinfo
; /* Cached from ETHTOOL_GDRVINFO. */
422 /* For devices of class netdev_tap_class only. */
426 struct netdev_rxq_linux
{
427 struct netdev_rxq up
;
432 /* This is set pretty low because we probably won't learn anything from the
433 * additional log messages. */
434 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 20);
436 /* Polling miimon status for all ports causes performance degradation when
437 * handling a large number of ports. If there are no devices using miimon, then
438 * we skip netdev_linux_miimon_run() and netdev_linux_miimon_wait().
440 * Readers do not depend on this variable synchronizing with the related
441 * changes in the device miimon status, so we can use atomic_count. */
442 static atomic_count miimon_cnt
= ATOMIC_COUNT_INIT(0);
444 static void netdev_linux_run(void);
446 static int netdev_linux_do_ethtool(const char *name
, struct ethtool_cmd
*,
447 int cmd
, const char *cmd_name
);
448 static int netdev_linux_get_ipv4(const struct netdev
*, struct in_addr
*,
449 int cmd
, const char *cmd_name
);
450 static int get_flags(const struct netdev
*, unsigned int *flags
);
451 static int set_flags(const char *, unsigned int flags
);
452 static int update_flags(struct netdev_linux
*netdev
, enum netdev_flags off
,
453 enum netdev_flags on
, enum netdev_flags
*old_flagsp
)
454 OVS_REQUIRES(netdev
->mutex
);
455 static int do_get_ifindex(const char *netdev_name
);
456 static int get_ifindex(const struct netdev
*, int *ifindexp
);
457 static int do_set_addr(struct netdev
*netdev
,
458 int ioctl_nr
, const char *ioctl_name
,
459 struct in_addr addr
);
460 static int get_etheraddr(const char *netdev_name
, uint8_t ea
[ETH_ADDR_LEN
]);
461 static int set_etheraddr(const char *netdev_name
, const uint8_t[ETH_ADDR_LEN
]);
462 static int get_stats_via_netlink(const struct netdev
*, struct netdev_stats
*);
463 static int af_packet_sock(void);
464 static bool netdev_linux_miimon_enabled(void);
465 static void netdev_linux_miimon_run(void);
466 static void netdev_linux_miimon_wait(void);
467 static int netdev_linux_get_mtu__(struct netdev_linux
*netdev
, int *mtup
);
470 is_netdev_linux_class(const struct netdev_class
*netdev_class
)
472 return netdev_class
->run
== netdev_linux_run
;
476 is_tap_netdev(const struct netdev
*netdev
)
478 return netdev_get_class(netdev
) == &netdev_tap_class
;
481 static struct netdev_linux
*
482 netdev_linux_cast(const struct netdev
*netdev
)
484 ovs_assert(is_netdev_linux_class(netdev_get_class(netdev
)));
486 return CONTAINER_OF(netdev
, struct netdev_linux
, up
);
489 static struct netdev_rxq_linux
*
490 netdev_rxq_linux_cast(const struct netdev_rxq
*rx
)
492 ovs_assert(is_netdev_linux_class(netdev_get_class(rx
->netdev
)));
493 return CONTAINER_OF(rx
, struct netdev_rxq_linux
, up
);
496 static void netdev_linux_update(struct netdev_linux
*netdev
,
497 const struct rtnetlink_link_change
*)
498 OVS_REQUIRES(netdev
->mutex
);
499 static void netdev_linux_changed(struct netdev_linux
*netdev
,
500 unsigned int ifi_flags
, unsigned int mask
)
501 OVS_REQUIRES(netdev
->mutex
);
503 /* Returns a NETLINK_ROUTE socket listening for RTNLGRP_LINK changes, or NULL
504 * if no such socket could be created. */
505 static struct nl_sock
*
506 netdev_linux_notify_sock(void)
508 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
509 static struct nl_sock
*sock
;
511 if (ovsthread_once_start(&once
)) {
514 error
= nl_sock_create(NETLINK_ROUTE
, &sock
);
516 error
= nl_sock_join_mcgroup(sock
, RTNLGRP_LINK
);
518 nl_sock_destroy(sock
);
522 ovsthread_once_done(&once
);
529 netdev_linux_miimon_enabled(void)
531 return atomic_count_get(&miimon_cnt
) > 0;
535 netdev_linux_run(void)
537 struct nl_sock
*sock
;
540 if (netdev_linux_miimon_enabled()) {
541 netdev_linux_miimon_run();
544 sock
= netdev_linux_notify_sock();
550 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
551 uint64_t buf_stub
[4096 / 8];
554 ofpbuf_use_stub(&buf
, buf_stub
, sizeof buf_stub
);
555 error
= nl_sock_recv(sock
, &buf
, false);
557 struct rtnetlink_link_change change
;
559 if (rtnetlink_link_parse(&buf
, &change
)) {
560 struct netdev
*netdev_
= netdev_from_name(change
.ifname
);
561 if (netdev_
&& is_netdev_linux_class(netdev_
->netdev_class
)) {
562 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
564 ovs_mutex_lock(&netdev
->mutex
);
565 netdev_linux_update(netdev
, &change
);
566 ovs_mutex_unlock(&netdev
->mutex
);
568 netdev_close(netdev_
);
570 } else if (error
== ENOBUFS
) {
571 struct shash device_shash
;
572 struct shash_node
*node
;
576 shash_init(&device_shash
);
577 netdev_get_devices(&netdev_linux_class
, &device_shash
);
578 SHASH_FOR_EACH (node
, &device_shash
) {
579 struct netdev
*netdev_
= node
->data
;
580 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
583 ovs_mutex_lock(&netdev
->mutex
);
584 get_flags(netdev_
, &flags
);
585 netdev_linux_changed(netdev
, flags
, 0);
586 ovs_mutex_unlock(&netdev
->mutex
);
588 netdev_close(netdev_
);
590 shash_destroy(&device_shash
);
591 } else if (error
!= EAGAIN
) {
592 VLOG_WARN_RL(&rl
, "error reading or parsing netlink (%s)",
593 ovs_strerror(error
));
600 netdev_linux_wait(void)
602 struct nl_sock
*sock
;
604 if (netdev_linux_miimon_enabled()) {
605 netdev_linux_miimon_wait();
607 sock
= netdev_linux_notify_sock();
609 nl_sock_wait(sock
, POLLIN
);
614 netdev_linux_changed(struct netdev_linux
*dev
,
615 unsigned int ifi_flags
, unsigned int mask
)
616 OVS_REQUIRES(dev
->mutex
)
618 netdev_change_seq_changed(&dev
->up
);
620 if ((dev
->ifi_flags
^ ifi_flags
) & IFF_RUNNING
) {
621 dev
->carrier_resets
++;
623 dev
->ifi_flags
= ifi_flags
;
625 dev
->cache_valid
&= mask
;
629 netdev_linux_update(struct netdev_linux
*dev
,
630 const struct rtnetlink_link_change
*change
)
631 OVS_REQUIRES(dev
->mutex
)
633 if (change
->nlmsg_type
== RTM_NEWLINK
) {
635 netdev_linux_changed(dev
, change
->ifi_flags
, VALID_DRVINFO
);
637 /* Update netdev from rtnl-change msg. */
639 dev
->mtu
= change
->mtu
;
640 dev
->cache_valid
|= VALID_MTU
;
641 dev
->netdev_mtu_error
= 0;
644 if (!eth_addr_is_zero(change
->addr
)) {
645 memcpy(dev
->etheraddr
, change
->addr
, ETH_ADDR_LEN
);
646 dev
->cache_valid
|= VALID_ETHERADDR
;
647 dev
->ether_addr_error
= 0;
650 dev
->ifindex
= change
->ifi_index
;
651 dev
->cache_valid
|= VALID_IFINDEX
;
652 dev
->get_ifindex_error
= 0;
655 netdev_linux_changed(dev
, change
->ifi_flags
, 0);
659 static struct netdev
*
660 netdev_linux_alloc(void)
662 struct netdev_linux
*netdev
= xzalloc(sizeof *netdev
);
667 netdev_linux_common_construct(struct netdev_linux
*netdev
)
669 ovs_mutex_init(&netdev
->mutex
);
672 /* Creates system and internal devices. */
674 netdev_linux_construct(struct netdev
*netdev_
)
676 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
679 netdev_linux_common_construct(netdev
);
681 error
= get_flags(&netdev
->up
, &netdev
->ifi_flags
);
682 if (error
== ENODEV
) {
683 if (netdev
->up
.netdev_class
!= &netdev_internal_class
) {
684 /* The device does not exist, so don't allow it to be opened. */
687 /* "Internal" netdevs have to be created as netdev objects before
688 * they exist in the kernel, because creating them in the kernel
689 * happens by passing a netdev object to dpif_port_add().
690 * Therefore, ignore the error. */
697 /* For most types of netdevs we open the device for each call of
698 * netdev_open(). However, this is not the case with tap devices,
699 * since it is only possible to open the device once. In this
700 * situation we share a single file descriptor, and consequently
701 * buffers, across all readers. Therefore once data is read it will
702 * be unavailable to other reads for tap devices. */
704 netdev_linux_construct_tap(struct netdev
*netdev_
)
706 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
707 static const char tap_dev
[] = "/dev/net/tun";
708 const char *name
= netdev_
->name
;
712 netdev_linux_common_construct(netdev
);
714 /* Open tap device. */
715 netdev
->tap_fd
= open(tap_dev
, O_RDWR
);
716 if (netdev
->tap_fd
< 0) {
718 VLOG_WARN("opening \"%s\" failed: %s", tap_dev
, ovs_strerror(error
));
722 /* Create tap device. */
723 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
724 ovs_strzcpy(ifr
.ifr_name
, name
, sizeof ifr
.ifr_name
);
725 if (ioctl(netdev
->tap_fd
, TUNSETIFF
, &ifr
) == -1) {
726 VLOG_WARN("%s: creating tap device failed: %s", name
,
727 ovs_strerror(errno
));
732 /* Make non-blocking. */
733 error
= set_nonblocking(netdev
->tap_fd
);
741 close(netdev
->tap_fd
);
746 netdev_linux_destruct(struct netdev
*netdev_
)
748 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
750 if (netdev
->tc
&& netdev
->tc
->ops
->tc_destroy
) {
751 netdev
->tc
->ops
->tc_destroy(netdev
->tc
);
754 if (netdev_get_class(netdev_
) == &netdev_tap_class
755 && netdev
->tap_fd
>= 0)
757 close(netdev
->tap_fd
);
760 if (netdev
->miimon_interval
> 0) {
761 atomic_count_dec(&miimon_cnt
);
764 ovs_mutex_destroy(&netdev
->mutex
);
768 netdev_linux_dealloc(struct netdev
*netdev_
)
770 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
774 static struct netdev_rxq
*
775 netdev_linux_rxq_alloc(void)
777 struct netdev_rxq_linux
*rx
= xzalloc(sizeof *rx
);
782 netdev_linux_rxq_construct(struct netdev_rxq
*rxq_
)
784 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
785 struct netdev
*netdev_
= rx
->up
.netdev
;
786 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
789 ovs_mutex_lock(&netdev
->mutex
);
790 rx
->is_tap
= is_tap_netdev(netdev_
);
792 rx
->fd
= netdev
->tap_fd
;
794 struct sockaddr_ll sll
;
796 /* Result of tcpdump -dd inbound */
797 static const struct sock_filter filt
[] = {
798 { 0x28, 0, 0, 0xfffff004 }, /* ldh [0] */
799 { 0x15, 0, 1, 0x00000004 }, /* jeq #4 jt 2 jf 3 */
800 { 0x6, 0, 0, 0x00000000 }, /* ret #0 */
801 { 0x6, 0, 0, 0x0000ffff } /* ret #65535 */
803 static const struct sock_fprog fprog
= {
804 ARRAY_SIZE(filt
), (struct sock_filter
*) filt
807 /* Create file descriptor. */
808 rx
->fd
= socket(PF_PACKET
, SOCK_RAW
, 0);
811 VLOG_ERR("failed to create raw socket (%s)", ovs_strerror(error
));
816 if (setsockopt(rx
->fd
, SOL_PACKET
, PACKET_AUXDATA
, &val
, sizeof val
)) {
818 VLOG_ERR("%s: failed to mark socket for auxdata (%s)",
819 netdev_get_name(netdev_
), ovs_strerror(error
));
823 /* Set non-blocking mode. */
824 error
= set_nonblocking(rx
->fd
);
829 /* Get ethernet device index. */
830 error
= get_ifindex(&netdev
->up
, &ifindex
);
835 /* Bind to specific ethernet device. */
836 memset(&sll
, 0, sizeof sll
);
837 sll
.sll_family
= AF_PACKET
;
838 sll
.sll_ifindex
= ifindex
;
839 sll
.sll_protocol
= htons(ETH_P_ALL
);
840 if (bind(rx
->fd
, (struct sockaddr
*) &sll
, sizeof sll
) < 0) {
842 VLOG_ERR("%s: failed to bind raw socket (%s)",
843 netdev_get_name(netdev_
), ovs_strerror(error
));
847 /* Filter for only inbound packets. */
848 error
= setsockopt(rx
->fd
, SOL_SOCKET
, SO_ATTACH_FILTER
, &fprog
,
852 VLOG_ERR("%s: failed to attach filter (%s)",
853 netdev_get_name(netdev_
), ovs_strerror(error
));
857 ovs_mutex_unlock(&netdev
->mutex
);
865 ovs_mutex_unlock(&netdev
->mutex
);
870 netdev_linux_rxq_destruct(struct netdev_rxq
*rxq_
)
872 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
880 netdev_linux_rxq_dealloc(struct netdev_rxq
*rxq_
)
882 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
888 auxdata_to_vlan_tpid(const struct tpacket_auxdata
*aux
)
890 if (aux
->tp_status
& TP_STATUS_VLAN_TPID_VALID
) {
891 return htons(aux
->tp_vlan_tpid
);
893 return htons(ETH_TYPE_VLAN
);
898 auxdata_has_vlan_tci(const struct tpacket_auxdata
*aux
)
900 return aux
->tp_vlan_tci
|| aux
->tp_status
& TP_STATUS_VLAN_VALID
;
904 netdev_linux_rxq_recv_sock(int fd
, struct ofpbuf
*buffer
)
909 struct cmsghdr
*cmsg
;
912 char buffer
[CMSG_SPACE(sizeof(struct tpacket_auxdata
))];
916 /* Reserve headroom for a single VLAN tag */
917 ofpbuf_reserve(buffer
, VLAN_HEADER_LEN
);
918 size
= ofpbuf_tailroom(buffer
);
920 iov
.iov_base
= ofpbuf_data(buffer
);
922 msgh
.msg_name
= NULL
;
923 msgh
.msg_namelen
= 0;
926 msgh
.msg_control
= &cmsg_buffer
;
927 msgh
.msg_controllen
= sizeof cmsg_buffer
;
931 retval
= recvmsg(fd
, &msgh
, MSG_TRUNC
);
932 } while (retval
< 0 && errno
== EINTR
);
936 } else if (retval
> size
) {
940 ofpbuf_set_size(buffer
, ofpbuf_size(buffer
) + retval
);
942 for (cmsg
= CMSG_FIRSTHDR(&msgh
); cmsg
; cmsg
= CMSG_NXTHDR(&msgh
, cmsg
)) {
943 const struct tpacket_auxdata
*aux
;
945 if (cmsg
->cmsg_level
!= SOL_PACKET
946 || cmsg
->cmsg_type
!= PACKET_AUXDATA
947 || cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct tpacket_auxdata
))) {
951 aux
= ALIGNED_CAST(struct tpacket_auxdata
*, CMSG_DATA(cmsg
));
952 if (auxdata_has_vlan_tci(aux
)) {
953 if (retval
< ETH_HEADER_LEN
) {
957 eth_push_vlan(buffer
, auxdata_to_vlan_tpid(aux
),
958 htons(aux
->tp_vlan_tci
));
967 netdev_linux_rxq_recv_tap(int fd
, struct ofpbuf
*buffer
)
970 size_t size
= ofpbuf_tailroom(buffer
);
973 retval
= read(fd
, ofpbuf_data(buffer
), size
);
974 } while (retval
< 0 && errno
== EINTR
);
978 } else if (retval
> size
) {
982 ofpbuf_set_size(buffer
, ofpbuf_size(buffer
) + retval
);
987 netdev_linux_rxq_recv(struct netdev_rxq
*rxq_
, struct dpif_packet
**packets
,
990 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
991 struct netdev
*netdev
= rx
->up
.netdev
;
992 struct dpif_packet
*packet
;
993 struct ofpbuf
*buffer
;
997 if (netdev_linux_get_mtu__(netdev_linux_cast(netdev
), &mtu
)) {
998 mtu
= ETH_PAYLOAD_MAX
;
1001 packet
= dpif_packet_new_with_headroom(VLAN_ETH_HEADER_LEN
+ mtu
,
1002 DP_NETDEV_HEADROOM
);
1003 buffer
= &packet
->ofpbuf
;
1005 retval
= (rx
->is_tap
1006 ? netdev_linux_rxq_recv_tap(rx
->fd
, buffer
)
1007 : netdev_linux_rxq_recv_sock(rx
->fd
, buffer
));
1010 if (retval
!= EAGAIN
&& retval
!= EMSGSIZE
) {
1011 VLOG_WARN_RL(&rl
, "error receiving Ethernet packet on %s: %s",
1012 ovs_strerror(errno
), netdev_rxq_get_name(rxq_
));
1014 dpif_packet_delete(packet
);
1016 dp_packet_pad(buffer
);
1017 dpif_packet_set_dp_hash(packet
, 0);
1018 packets
[0] = packet
;
1026 netdev_linux_rxq_wait(struct netdev_rxq
*rxq_
)
1028 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
1029 poll_fd_wait(rx
->fd
, POLLIN
);
1033 netdev_linux_rxq_drain(struct netdev_rxq
*rxq_
)
1035 struct netdev_rxq_linux
*rx
= netdev_rxq_linux_cast(rxq_
);
1038 int error
= af_inet_ifreq_ioctl(netdev_rxq_get_name(rxq_
), &ifr
,
1039 SIOCGIFTXQLEN
, "SIOCGIFTXQLEN");
1043 drain_fd(rx
->fd
, ifr
.ifr_qlen
);
1046 return drain_rcvbuf(rx
->fd
);
1050 /* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive
1051 * errno value. Returns EAGAIN without blocking if the packet cannot be queued
1052 * immediately. Returns EMSGSIZE if a partial packet was transmitted or if
1053 * the packet is too big or too small to transmit on the device.
1055 * The caller retains ownership of 'buffer' in all cases.
1057 * The kernel maintains a packet transmission queue, so the caller is not
1058 * expected to do additional queuing of packets. */
1060 netdev_linux_send(struct netdev
*netdev_
, struct dpif_packet
**pkts
, int cnt
,
1066 /* 'i' is incremented only if there's no error */
1067 for (i
= 0; i
< cnt
;) {
1068 const void *data
= ofpbuf_data(&pkts
[i
]->ofpbuf
);
1069 size_t size
= ofpbuf_size(&pkts
[i
]->ofpbuf
);
1072 if (!is_tap_netdev(netdev_
)) {
1073 /* Use our AF_PACKET socket to send to this device. */
1074 struct sockaddr_ll sll
;
1080 sock
= af_packet_sock();
1085 ifindex
= netdev_get_ifindex(netdev_
);
1090 /* We don't bother setting most fields in sockaddr_ll because the
1091 * kernel ignores them for SOCK_RAW. */
1092 memset(&sll
, 0, sizeof sll
);
1093 sll
.sll_family
= AF_PACKET
;
1094 sll
.sll_ifindex
= ifindex
;
1096 iov
.iov_base
= CONST_CAST(void *, data
);
1099 msg
.msg_name
= &sll
;
1100 msg
.msg_namelen
= sizeof sll
;
1103 msg
.msg_control
= NULL
;
1104 msg
.msg_controllen
= 0;
1107 retval
= sendmsg(sock
, &msg
, 0);
1109 /* Use the tap fd to send to this device. This is essential for
1110 * tap devices, because packets sent to a tap device with an
1111 * AF_PACKET socket will loop back to be *received* again on the
1112 * tap device. This doesn't occur on other interface types
1113 * because we attach a socket filter to the rx socket. */
1114 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1116 retval
= write(netdev
->tap_fd
, data
, size
);
1120 /* The Linux AF_PACKET implementation never blocks waiting for room
1121 * for packets, instead returning ENOBUFS. Translate this into
1122 * EAGAIN for the caller. */
1123 error
= errno
== ENOBUFS
? EAGAIN
: errno
;
1124 if (error
== EINTR
) {
1125 /* continue without incrementing 'i', i.e. retry this packet */
1129 } else if (retval
!= size
) {
1130 VLOG_WARN_RL(&rl
, "sent partial Ethernet packet (%"PRIuSIZE
" bytes"
1131 " of %"PRIuSIZE
") on %s", retval
, size
,
1132 netdev_get_name(netdev_
));
1137 /* Process the next packet in the batch */
1142 for (i
= 0; i
< cnt
; i
++) {
1143 dpif_packet_delete(pkts
[i
]);
1147 if (error
&& error
!= EAGAIN
) {
1148 VLOG_WARN_RL(&rl
, "error sending Ethernet packet on %s: %s",
1149 netdev_get_name(netdev_
), ovs_strerror(error
));
1156 /* Registers with the poll loop to wake up from the next call to poll_block()
1157 * when the packet transmission queue has sufficient room to transmit a packet
1158 * with netdev_send().
1160 * The kernel maintains a packet transmission queue, so the client is not
1161 * expected to do additional queuing of packets. Thus, this function is
1162 * unlikely to ever be used. It is included for completeness. */
1164 netdev_linux_send_wait(struct netdev
*netdev
)
1166 if (is_tap_netdev(netdev
)) {
1167 /* TAP device always accepts packets.*/
1168 poll_immediate_wake();
1172 /* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
1173 * otherwise a positive errno value. */
1175 netdev_linux_set_etheraddr(struct netdev
*netdev_
,
1176 const uint8_t mac
[ETH_ADDR_LEN
])
1178 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1179 enum netdev_flags old_flags
= 0;
1182 ovs_mutex_lock(&netdev
->mutex
);
1184 if (netdev
->cache_valid
& VALID_ETHERADDR
) {
1185 error
= netdev
->ether_addr_error
;
1186 if (error
|| eth_addr_equals(netdev
->etheraddr
, mac
)) {
1189 netdev
->cache_valid
&= ~VALID_ETHERADDR
;
1192 /* Tap devices must be brought down before setting the address. */
1193 if (is_tap_netdev(netdev_
)) {
1194 update_flags(netdev
, NETDEV_UP
, 0, &old_flags
);
1196 error
= set_etheraddr(netdev_get_name(netdev_
), mac
);
1197 if (!error
|| error
== ENODEV
) {
1198 netdev
->ether_addr_error
= error
;
1199 netdev
->cache_valid
|= VALID_ETHERADDR
;
1201 memcpy(netdev
->etheraddr
, mac
, ETH_ADDR_LEN
);
1205 if (is_tap_netdev(netdev_
) && old_flags
& NETDEV_UP
) {
1206 update_flags(netdev
, 0, NETDEV_UP
, &old_flags
);
1210 ovs_mutex_unlock(&netdev
->mutex
);
1214 /* Copies 'netdev''s MAC address to 'mac' which is passed as param. */
1216 netdev_linux_get_etheraddr(const struct netdev
*netdev_
,
1217 uint8_t mac
[ETH_ADDR_LEN
])
1219 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1222 ovs_mutex_lock(&netdev
->mutex
);
1223 if (!(netdev
->cache_valid
& VALID_ETHERADDR
)) {
1224 netdev
->ether_addr_error
= get_etheraddr(netdev_get_name(netdev_
),
1226 netdev
->cache_valid
|= VALID_ETHERADDR
;
1229 error
= netdev
->ether_addr_error
;
1231 memcpy(mac
, netdev
->etheraddr
, ETH_ADDR_LEN
);
1233 ovs_mutex_unlock(&netdev
->mutex
);
1239 netdev_linux_get_mtu__(struct netdev_linux
*netdev
, int *mtup
)
1243 if (!(netdev
->cache_valid
& VALID_MTU
)) {
1246 netdev
->netdev_mtu_error
= af_inet_ifreq_ioctl(
1247 netdev_get_name(&netdev
->up
), &ifr
, SIOCGIFMTU
, "SIOCGIFMTU");
1248 netdev
->mtu
= ifr
.ifr_mtu
;
1249 netdev
->cache_valid
|= VALID_MTU
;
1252 error
= netdev
->netdev_mtu_error
;
1254 *mtup
= netdev
->mtu
;
1260 /* Returns the maximum size of transmitted (and received) packets on 'netdev',
1261 * in bytes, not including the hardware header; thus, this is typically 1500
1262 * bytes for Ethernet devices. */
1264 netdev_linux_get_mtu(const struct netdev
*netdev_
, int *mtup
)
1266 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1269 ovs_mutex_lock(&netdev
->mutex
);
1270 error
= netdev_linux_get_mtu__(netdev
, mtup
);
1271 ovs_mutex_unlock(&netdev
->mutex
);
1276 /* Sets the maximum size of transmitted (MTU) for given device using linux
1277 * networking ioctl interface.
1280 netdev_linux_set_mtu(const struct netdev
*netdev_
, int mtu
)
1282 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1286 ovs_mutex_lock(&netdev
->mutex
);
1287 if (netdev
->cache_valid
& VALID_MTU
) {
1288 error
= netdev
->netdev_mtu_error
;
1289 if (error
|| netdev
->mtu
== mtu
) {
1292 netdev
->cache_valid
&= ~VALID_MTU
;
1295 error
= af_inet_ifreq_ioctl(netdev_get_name(netdev_
), &ifr
,
1296 SIOCSIFMTU
, "SIOCSIFMTU");
1297 if (!error
|| error
== ENODEV
) {
1298 netdev
->netdev_mtu_error
= error
;
1299 netdev
->mtu
= ifr
.ifr_mtu
;
1300 netdev
->cache_valid
|= VALID_MTU
;
1303 ovs_mutex_unlock(&netdev
->mutex
);
1307 /* Returns the ifindex of 'netdev', if successful, as a positive number.
1308 * On failure, returns a negative errno value. */
1310 netdev_linux_get_ifindex(const struct netdev
*netdev_
)
1312 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1315 ovs_mutex_lock(&netdev
->mutex
);
1316 error
= get_ifindex(netdev_
, &ifindex
);
1317 ovs_mutex_unlock(&netdev
->mutex
);
1319 return error
? -error
: ifindex
;
1323 netdev_linux_get_carrier(const struct netdev
*netdev_
, bool *carrier
)
1325 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1327 ovs_mutex_lock(&netdev
->mutex
);
1328 if (netdev
->miimon_interval
> 0) {
1329 *carrier
= netdev
->miimon
;
1331 *carrier
= (netdev
->ifi_flags
& IFF_RUNNING
) != 0;
1333 ovs_mutex_unlock(&netdev
->mutex
);
1338 static long long int
1339 netdev_linux_get_carrier_resets(const struct netdev
*netdev_
)
1341 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1342 long long int carrier_resets
;
1344 ovs_mutex_lock(&netdev
->mutex
);
1345 carrier_resets
= netdev
->carrier_resets
;
1346 ovs_mutex_unlock(&netdev
->mutex
);
1348 return carrier_resets
;
1352 netdev_linux_do_miimon(const char *name
, int cmd
, const char *cmd_name
,
1353 struct mii_ioctl_data
*data
)
1358 memset(&ifr
, 0, sizeof ifr
);
1359 memcpy(&ifr
.ifr_data
, data
, sizeof *data
);
1360 error
= af_inet_ifreq_ioctl(name
, &ifr
, cmd
, cmd_name
);
1361 memcpy(data
, &ifr
.ifr_data
, sizeof *data
);
1367 netdev_linux_get_miimon(const char *name
, bool *miimon
)
1369 struct mii_ioctl_data data
;
1374 memset(&data
, 0, sizeof data
);
1375 error
= netdev_linux_do_miimon(name
, SIOCGMIIPHY
, "SIOCGMIIPHY", &data
);
1377 /* data.phy_id is filled out by previous SIOCGMIIPHY miimon call. */
1378 data
.reg_num
= MII_BMSR
;
1379 error
= netdev_linux_do_miimon(name
, SIOCGMIIREG
, "SIOCGMIIREG",
1383 *miimon
= !!(data
.val_out
& BMSR_LSTATUS
);
1385 VLOG_WARN_RL(&rl
, "%s: failed to query MII", name
);
1388 struct ethtool_cmd ecmd
;
1390 VLOG_DBG_RL(&rl
, "%s: failed to query MII, falling back to ethtool",
1393 COVERAGE_INC(netdev_get_ethtool
);
1394 memset(&ecmd
, 0, sizeof ecmd
);
1395 error
= netdev_linux_do_ethtool(name
, &ecmd
, ETHTOOL_GLINK
,
1398 struct ethtool_value eval
;
1400 memcpy(&eval
, &ecmd
, sizeof eval
);
1401 *miimon
= !!eval
.data
;
1403 VLOG_WARN_RL(&rl
, "%s: ethtool link status failed", name
);
1411 netdev_linux_set_miimon_interval(struct netdev
*netdev_
,
1412 long long int interval
)
1414 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1416 ovs_mutex_lock(&netdev
->mutex
);
1417 interval
= interval
> 0 ? MAX(interval
, 100) : 0;
1418 if (netdev
->miimon_interval
!= interval
) {
1419 if (interval
&& !netdev
->miimon_interval
) {
1420 atomic_count_inc(&miimon_cnt
);
1421 } else if (!interval
&& netdev
->miimon_interval
) {
1422 atomic_count_dec(&miimon_cnt
);
1425 netdev
->miimon_interval
= interval
;
1426 timer_set_expired(&netdev
->miimon_timer
);
1428 ovs_mutex_unlock(&netdev
->mutex
);
1434 netdev_linux_miimon_run(void)
1436 struct shash device_shash
;
1437 struct shash_node
*node
;
1439 shash_init(&device_shash
);
1440 netdev_get_devices(&netdev_linux_class
, &device_shash
);
1441 SHASH_FOR_EACH (node
, &device_shash
) {
1442 struct netdev
*netdev
= node
->data
;
1443 struct netdev_linux
*dev
= netdev_linux_cast(netdev
);
1446 ovs_mutex_lock(&dev
->mutex
);
1447 if (dev
->miimon_interval
> 0 && timer_expired(&dev
->miimon_timer
)) {
1448 netdev_linux_get_miimon(dev
->up
.name
, &miimon
);
1449 if (miimon
!= dev
->miimon
) {
1450 dev
->miimon
= miimon
;
1451 netdev_linux_changed(dev
, dev
->ifi_flags
, 0);
1454 timer_set_duration(&dev
->miimon_timer
, dev
->miimon_interval
);
1456 ovs_mutex_unlock(&dev
->mutex
);
1457 netdev_close(netdev
);
1460 shash_destroy(&device_shash
);
1464 netdev_linux_miimon_wait(void)
1466 struct shash device_shash
;
1467 struct shash_node
*node
;
1469 shash_init(&device_shash
);
1470 netdev_get_devices(&netdev_linux_class
, &device_shash
);
1471 SHASH_FOR_EACH (node
, &device_shash
) {
1472 struct netdev
*netdev
= node
->data
;
1473 struct netdev_linux
*dev
= netdev_linux_cast(netdev
);
1475 ovs_mutex_lock(&dev
->mutex
);
1476 if (dev
->miimon_interval
> 0) {
1477 timer_wait(&dev
->miimon_timer
);
1479 ovs_mutex_unlock(&dev
->mutex
);
1480 netdev_close(netdev
);
1482 shash_destroy(&device_shash
);
1486 swap_uint64(uint64_t *a
, uint64_t *b
)
1493 /* Copies 'src' into 'dst', performing format conversion in the process.
1495 * 'src' is allowed to be misaligned. */
1497 netdev_stats_from_ovs_vport_stats(struct netdev_stats
*dst
,
1498 const struct ovs_vport_stats
*src
)
1500 dst
->rx_packets
= get_32aligned_u64(&src
->rx_packets
);
1501 dst
->tx_packets
= get_32aligned_u64(&src
->tx_packets
);
1502 dst
->rx_bytes
= get_32aligned_u64(&src
->rx_bytes
);
1503 dst
->tx_bytes
= get_32aligned_u64(&src
->tx_bytes
);
1504 dst
->rx_errors
= get_32aligned_u64(&src
->rx_errors
);
1505 dst
->tx_errors
= get_32aligned_u64(&src
->tx_errors
);
1506 dst
->rx_dropped
= get_32aligned_u64(&src
->rx_dropped
);
1507 dst
->tx_dropped
= get_32aligned_u64(&src
->tx_dropped
);
1509 dst
->collisions
= 0;
1510 dst
->rx_length_errors
= 0;
1511 dst
->rx_over_errors
= 0;
1512 dst
->rx_crc_errors
= 0;
1513 dst
->rx_frame_errors
= 0;
1514 dst
->rx_fifo_errors
= 0;
1515 dst
->rx_missed_errors
= 0;
1516 dst
->tx_aborted_errors
= 0;
1517 dst
->tx_carrier_errors
= 0;
1518 dst
->tx_fifo_errors
= 0;
1519 dst
->tx_heartbeat_errors
= 0;
1520 dst
->tx_window_errors
= 0;
1524 get_stats_via_vport__(const struct netdev
*netdev
, struct netdev_stats
*stats
)
1526 struct dpif_linux_vport reply
;
1530 error
= dpif_linux_vport_get(netdev_get_name(netdev
), &reply
, &buf
);
1533 } else if (!reply
.stats
) {
1538 netdev_stats_from_ovs_vport_stats(stats
, reply
.stats
);
1546 get_stats_via_vport(const struct netdev
*netdev_
,
1547 struct netdev_stats
*stats
)
1549 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1551 if (!netdev
->vport_stats_error
||
1552 !(netdev
->cache_valid
& VALID_VPORT_STAT_ERROR
)) {
1555 error
= get_stats_via_vport__(netdev_
, stats
);
1556 if (error
&& error
!= ENOENT
) {
1557 VLOG_WARN_RL(&rl
, "%s: obtaining netdev stats via vport failed "
1559 netdev_get_name(netdev_
), ovs_strerror(error
));
1561 netdev
->vport_stats_error
= error
;
1562 netdev
->cache_valid
|= VALID_VPORT_STAT_ERROR
;
1566 /* Retrieves current device stats for 'netdev-linux'. */
1568 netdev_linux_get_stats(const struct netdev
*netdev_
,
1569 struct netdev_stats
*stats
)
1571 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1572 struct netdev_stats dev_stats
;
1575 ovs_mutex_lock(&netdev
->mutex
);
1576 get_stats_via_vport(netdev_
, stats
);
1577 error
= get_stats_via_netlink(netdev_
, &dev_stats
);
1579 if (!netdev
->vport_stats_error
) {
1582 } else if (netdev
->vport_stats_error
) {
1583 /* stats not available from OVS then use netdev stats. */
1586 /* Use kernel netdev's packet and byte counts since vport's counters
1587 * do not reflect packet counts on the wire when GSO, TSO or GRO are
1589 stats
->rx_packets
= dev_stats
.rx_packets
;
1590 stats
->rx_bytes
= dev_stats
.rx_bytes
;
1591 stats
->tx_packets
= dev_stats
.tx_packets
;
1592 stats
->tx_bytes
= dev_stats
.tx_bytes
;
1594 stats
->rx_errors
+= dev_stats
.rx_errors
;
1595 stats
->tx_errors
+= dev_stats
.tx_errors
;
1596 stats
->rx_dropped
+= dev_stats
.rx_dropped
;
1597 stats
->tx_dropped
+= dev_stats
.tx_dropped
;
1598 stats
->multicast
+= dev_stats
.multicast
;
1599 stats
->collisions
+= dev_stats
.collisions
;
1600 stats
->rx_length_errors
+= dev_stats
.rx_length_errors
;
1601 stats
->rx_over_errors
+= dev_stats
.rx_over_errors
;
1602 stats
->rx_crc_errors
+= dev_stats
.rx_crc_errors
;
1603 stats
->rx_frame_errors
+= dev_stats
.rx_frame_errors
;
1604 stats
->rx_fifo_errors
+= dev_stats
.rx_fifo_errors
;
1605 stats
->rx_missed_errors
+= dev_stats
.rx_missed_errors
;
1606 stats
->tx_aborted_errors
+= dev_stats
.tx_aborted_errors
;
1607 stats
->tx_carrier_errors
+= dev_stats
.tx_carrier_errors
;
1608 stats
->tx_fifo_errors
+= dev_stats
.tx_fifo_errors
;
1609 stats
->tx_heartbeat_errors
+= dev_stats
.tx_heartbeat_errors
;
1610 stats
->tx_window_errors
+= dev_stats
.tx_window_errors
;
1612 ovs_mutex_unlock(&netdev
->mutex
);
1617 /* Retrieves current device stats for 'netdev-tap' netdev or
1618 * netdev-internal. */
1620 netdev_tap_get_stats(const struct netdev
*netdev_
, struct netdev_stats
*stats
)
1622 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1623 struct netdev_stats dev_stats
;
1626 ovs_mutex_lock(&netdev
->mutex
);
1627 get_stats_via_vport(netdev_
, stats
);
1628 error
= get_stats_via_netlink(netdev_
, &dev_stats
);
1630 if (!netdev
->vport_stats_error
) {
1633 } else if (netdev
->vport_stats_error
) {
1634 /* Transmit and receive stats will appear to be swapped relative to the
1635 * other ports since we are the one sending the data, not a remote
1636 * computer. For consistency, we swap them back here. This does not
1637 * apply if we are getting stats from the vport layer because it always
1638 * tracks stats from the perspective of the switch. */
1641 swap_uint64(&stats
->rx_packets
, &stats
->tx_packets
);
1642 swap_uint64(&stats
->rx_bytes
, &stats
->tx_bytes
);
1643 swap_uint64(&stats
->rx_errors
, &stats
->tx_errors
);
1644 swap_uint64(&stats
->rx_dropped
, &stats
->tx_dropped
);
1645 stats
->rx_length_errors
= 0;
1646 stats
->rx_over_errors
= 0;
1647 stats
->rx_crc_errors
= 0;
1648 stats
->rx_frame_errors
= 0;
1649 stats
->rx_fifo_errors
= 0;
1650 stats
->rx_missed_errors
= 0;
1651 stats
->tx_aborted_errors
= 0;
1652 stats
->tx_carrier_errors
= 0;
1653 stats
->tx_fifo_errors
= 0;
1654 stats
->tx_heartbeat_errors
= 0;
1655 stats
->tx_window_errors
= 0;
1657 /* Use kernel netdev's packet and byte counts since vport counters
1658 * do not reflect packet counts on the wire when GSO, TSO or GRO
1660 stats
->rx_packets
= dev_stats
.tx_packets
;
1661 stats
->rx_bytes
= dev_stats
.tx_bytes
;
1662 stats
->tx_packets
= dev_stats
.rx_packets
;
1663 stats
->tx_bytes
= dev_stats
.rx_bytes
;
1665 stats
->rx_dropped
+= dev_stats
.tx_dropped
;
1666 stats
->tx_dropped
+= dev_stats
.rx_dropped
;
1668 stats
->rx_errors
+= dev_stats
.tx_errors
;
1669 stats
->tx_errors
+= dev_stats
.rx_errors
;
1671 stats
->multicast
+= dev_stats
.multicast
;
1672 stats
->collisions
+= dev_stats
.collisions
;
1674 ovs_mutex_unlock(&netdev
->mutex
);
1680 netdev_internal_get_stats(const struct netdev
*netdev_
,
1681 struct netdev_stats
*stats
)
1683 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1686 ovs_mutex_lock(&netdev
->mutex
);
1687 get_stats_via_vport(netdev_
, stats
);
1688 error
= netdev
->vport_stats_error
;
1689 ovs_mutex_unlock(&netdev
->mutex
);
1695 netdev_internal_set_stats(struct netdev
*netdev
,
1696 const struct netdev_stats
*stats
)
1698 struct ovs_vport_stats vport_stats
;
1699 struct dpif_linux_vport vport
;
1702 put_32aligned_u64(&vport_stats
.rx_packets
, stats
->rx_packets
);
1703 put_32aligned_u64(&vport_stats
.tx_packets
, stats
->tx_packets
);
1704 put_32aligned_u64(&vport_stats
.rx_bytes
, stats
->rx_bytes
);
1705 put_32aligned_u64(&vport_stats
.tx_bytes
, stats
->tx_bytes
);
1706 put_32aligned_u64(&vport_stats
.rx_errors
, stats
->rx_errors
);
1707 put_32aligned_u64(&vport_stats
.tx_errors
, stats
->tx_errors
);
1708 put_32aligned_u64(&vport_stats
.rx_dropped
, stats
->rx_dropped
);
1709 put_32aligned_u64(&vport_stats
.tx_dropped
, stats
->tx_dropped
);
1711 dpif_linux_vport_init(&vport
);
1712 vport
.cmd
= OVS_VPORT_CMD_SET
;
1713 vport
.name
= netdev_get_name(netdev
);
1714 vport
.stats
= &vport_stats
;
1716 err
= dpif_linux_vport_transact(&vport
, NULL
, NULL
);
1718 /* If the vport layer doesn't know about the device, that doesn't mean it
1719 * doesn't exist (after all were able to open it when netdev_open() was
1720 * called), it just means that it isn't attached and we'll be getting
1721 * stats a different way. */
1722 if (err
== ENODEV
) {
1730 netdev_linux_read_features(struct netdev_linux
*netdev
)
1732 struct ethtool_cmd ecmd
;
1736 if (netdev
->cache_valid
& VALID_FEATURES
) {
1740 COVERAGE_INC(netdev_get_ethtool
);
1741 memset(&ecmd
, 0, sizeof ecmd
);
1742 error
= netdev_linux_do_ethtool(netdev
->up
.name
, &ecmd
,
1743 ETHTOOL_GSET
, "ETHTOOL_GSET");
1748 /* Supported features. */
1749 netdev
->supported
= 0;
1750 if (ecmd
.supported
& SUPPORTED_10baseT_Half
) {
1751 netdev
->supported
|= NETDEV_F_10MB_HD
;
1753 if (ecmd
.supported
& SUPPORTED_10baseT_Full
) {
1754 netdev
->supported
|= NETDEV_F_10MB_FD
;
1756 if (ecmd
.supported
& SUPPORTED_100baseT_Half
) {
1757 netdev
->supported
|= NETDEV_F_100MB_HD
;
1759 if (ecmd
.supported
& SUPPORTED_100baseT_Full
) {
1760 netdev
->supported
|= NETDEV_F_100MB_FD
;
1762 if (ecmd
.supported
& SUPPORTED_1000baseT_Half
) {
1763 netdev
->supported
|= NETDEV_F_1GB_HD
;
1765 if (ecmd
.supported
& SUPPORTED_1000baseT_Full
) {
1766 netdev
->supported
|= NETDEV_F_1GB_FD
;
1768 if (ecmd
.supported
& SUPPORTED_10000baseT_Full
) {
1769 netdev
->supported
|= NETDEV_F_10GB_FD
;
1771 if (ecmd
.supported
& SUPPORTED_TP
) {
1772 netdev
->supported
|= NETDEV_F_COPPER
;
1774 if (ecmd
.supported
& SUPPORTED_FIBRE
) {
1775 netdev
->supported
|= NETDEV_F_FIBER
;
1777 if (ecmd
.supported
& SUPPORTED_Autoneg
) {
1778 netdev
->supported
|= NETDEV_F_AUTONEG
;
1780 if (ecmd
.supported
& SUPPORTED_Pause
) {
1781 netdev
->supported
|= NETDEV_F_PAUSE
;
1783 if (ecmd
.supported
& SUPPORTED_Asym_Pause
) {
1784 netdev
->supported
|= NETDEV_F_PAUSE_ASYM
;
1787 /* Advertised features. */
1788 netdev
->advertised
= 0;
1789 if (ecmd
.advertising
& ADVERTISED_10baseT_Half
) {
1790 netdev
->advertised
|= NETDEV_F_10MB_HD
;
1792 if (ecmd
.advertising
& ADVERTISED_10baseT_Full
) {
1793 netdev
->advertised
|= NETDEV_F_10MB_FD
;
1795 if (ecmd
.advertising
& ADVERTISED_100baseT_Half
) {
1796 netdev
->advertised
|= NETDEV_F_100MB_HD
;
1798 if (ecmd
.advertising
& ADVERTISED_100baseT_Full
) {
1799 netdev
->advertised
|= NETDEV_F_100MB_FD
;
1801 if (ecmd
.advertising
& ADVERTISED_1000baseT_Half
) {
1802 netdev
->advertised
|= NETDEV_F_1GB_HD
;
1804 if (ecmd
.advertising
& ADVERTISED_1000baseT_Full
) {
1805 netdev
->advertised
|= NETDEV_F_1GB_FD
;
1807 if (ecmd
.advertising
& ADVERTISED_10000baseT_Full
) {
1808 netdev
->advertised
|= NETDEV_F_10GB_FD
;
1810 if (ecmd
.advertising
& ADVERTISED_TP
) {
1811 netdev
->advertised
|= NETDEV_F_COPPER
;
1813 if (ecmd
.advertising
& ADVERTISED_FIBRE
) {
1814 netdev
->advertised
|= NETDEV_F_FIBER
;
1816 if (ecmd
.advertising
& ADVERTISED_Autoneg
) {
1817 netdev
->advertised
|= NETDEV_F_AUTONEG
;
1819 if (ecmd
.advertising
& ADVERTISED_Pause
) {
1820 netdev
->advertised
|= NETDEV_F_PAUSE
;
1822 if (ecmd
.advertising
& ADVERTISED_Asym_Pause
) {
1823 netdev
->advertised
|= NETDEV_F_PAUSE_ASYM
;
1826 /* Current settings. */
1828 if (speed
== SPEED_10
) {
1829 netdev
->current
= ecmd
.duplex
? NETDEV_F_10MB_FD
: NETDEV_F_10MB_HD
;
1830 } else if (speed
== SPEED_100
) {
1831 netdev
->current
= ecmd
.duplex
? NETDEV_F_100MB_FD
: NETDEV_F_100MB_HD
;
1832 } else if (speed
== SPEED_1000
) {
1833 netdev
->current
= ecmd
.duplex
? NETDEV_F_1GB_FD
: NETDEV_F_1GB_HD
;
1834 } else if (speed
== SPEED_10000
) {
1835 netdev
->current
= NETDEV_F_10GB_FD
;
1836 } else if (speed
== 40000) {
1837 netdev
->current
= NETDEV_F_40GB_FD
;
1838 } else if (speed
== 100000) {
1839 netdev
->current
= NETDEV_F_100GB_FD
;
1840 } else if (speed
== 1000000) {
1841 netdev
->current
= NETDEV_F_1TB_FD
;
1843 netdev
->current
= 0;
1846 if (ecmd
.port
== PORT_TP
) {
1847 netdev
->current
|= NETDEV_F_COPPER
;
1848 } else if (ecmd
.port
== PORT_FIBRE
) {
1849 netdev
->current
|= NETDEV_F_FIBER
;
1853 netdev
->current
|= NETDEV_F_AUTONEG
;
1857 netdev
->cache_valid
|= VALID_FEATURES
;
1858 netdev
->get_features_error
= error
;
1861 /* Stores the features supported by 'netdev' into of '*current', '*advertised',
1862 * '*supported', and '*peer'. Each value is a bitmap of NETDEV_* bits.
1863 * Returns 0 if successful, otherwise a positive errno value. */
1865 netdev_linux_get_features(const struct netdev
*netdev_
,
1866 enum netdev_features
*current
,
1867 enum netdev_features
*advertised
,
1868 enum netdev_features
*supported
,
1869 enum netdev_features
*peer
)
1871 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1874 ovs_mutex_lock(&netdev
->mutex
);
1875 netdev_linux_read_features(netdev
);
1876 if (!netdev
->get_features_error
) {
1877 *current
= netdev
->current
;
1878 *advertised
= netdev
->advertised
;
1879 *supported
= netdev
->supported
;
1880 *peer
= 0; /* XXX */
1882 error
= netdev
->get_features_error
;
1883 ovs_mutex_unlock(&netdev
->mutex
);
1888 /* Set the features advertised by 'netdev' to 'advertise'. */
1890 netdev_linux_set_advertisements(struct netdev
*netdev_
,
1891 enum netdev_features advertise
)
1893 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1894 struct ethtool_cmd ecmd
;
1897 ovs_mutex_lock(&netdev
->mutex
);
1899 COVERAGE_INC(netdev_get_ethtool
);
1900 memset(&ecmd
, 0, sizeof ecmd
);
1901 error
= netdev_linux_do_ethtool(netdev_get_name(netdev_
), &ecmd
,
1902 ETHTOOL_GSET
, "ETHTOOL_GSET");
1907 ecmd
.advertising
= 0;
1908 if (advertise
& NETDEV_F_10MB_HD
) {
1909 ecmd
.advertising
|= ADVERTISED_10baseT_Half
;
1911 if (advertise
& NETDEV_F_10MB_FD
) {
1912 ecmd
.advertising
|= ADVERTISED_10baseT_Full
;
1914 if (advertise
& NETDEV_F_100MB_HD
) {
1915 ecmd
.advertising
|= ADVERTISED_100baseT_Half
;
1917 if (advertise
& NETDEV_F_100MB_FD
) {
1918 ecmd
.advertising
|= ADVERTISED_100baseT_Full
;
1920 if (advertise
& NETDEV_F_1GB_HD
) {
1921 ecmd
.advertising
|= ADVERTISED_1000baseT_Half
;
1923 if (advertise
& NETDEV_F_1GB_FD
) {
1924 ecmd
.advertising
|= ADVERTISED_1000baseT_Full
;
1926 if (advertise
& NETDEV_F_10GB_FD
) {
1927 ecmd
.advertising
|= ADVERTISED_10000baseT_Full
;
1929 if (advertise
& NETDEV_F_COPPER
) {
1930 ecmd
.advertising
|= ADVERTISED_TP
;
1932 if (advertise
& NETDEV_F_FIBER
) {
1933 ecmd
.advertising
|= ADVERTISED_FIBRE
;
1935 if (advertise
& NETDEV_F_AUTONEG
) {
1936 ecmd
.advertising
|= ADVERTISED_Autoneg
;
1938 if (advertise
& NETDEV_F_PAUSE
) {
1939 ecmd
.advertising
|= ADVERTISED_Pause
;
1941 if (advertise
& NETDEV_F_PAUSE_ASYM
) {
1942 ecmd
.advertising
|= ADVERTISED_Asym_Pause
;
1944 COVERAGE_INC(netdev_set_ethtool
);
1945 error
= netdev_linux_do_ethtool(netdev_get_name(netdev_
), &ecmd
,
1946 ETHTOOL_SSET
, "ETHTOOL_SSET");
1949 ovs_mutex_unlock(&netdev
->mutex
);
1953 /* Attempts to set input rate limiting (policing) policy. Returns 0 if
1954 * successful, otherwise a positive errno value. */
1956 netdev_linux_set_policing(struct netdev
*netdev_
,
1957 uint32_t kbits_rate
, uint32_t kbits_burst
)
1959 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
1960 const char *netdev_name
= netdev_get_name(netdev_
);
1963 kbits_burst
= (!kbits_rate
? 0 /* Force to 0 if no rate specified. */
1964 : !kbits_burst
? 1000 /* Default to 1000 kbits if 0. */
1965 : kbits_burst
); /* Stick with user-specified value. */
1967 ovs_mutex_lock(&netdev
->mutex
);
1968 if (netdev
->cache_valid
& VALID_POLICING
) {
1969 error
= netdev
->netdev_policing_error
;
1970 if (error
|| (netdev
->kbits_rate
== kbits_rate
&&
1971 netdev
->kbits_burst
== kbits_burst
)) {
1972 /* Assume that settings haven't changed since we last set them. */
1975 netdev
->cache_valid
&= ~VALID_POLICING
;
1978 COVERAGE_INC(netdev_set_policing
);
1979 /* Remove any existing ingress qdisc. */
1980 error
= tc_add_del_ingress_qdisc(netdev_
, false);
1982 VLOG_WARN_RL(&rl
, "%s: removing policing failed: %s",
1983 netdev_name
, ovs_strerror(error
));
1988 error
= tc_add_del_ingress_qdisc(netdev_
, true);
1990 VLOG_WARN_RL(&rl
, "%s: adding policing qdisc failed: %s",
1991 netdev_name
, ovs_strerror(error
));
1995 error
= tc_add_policer(netdev_
, kbits_rate
, kbits_burst
);
1997 VLOG_WARN_RL(&rl
, "%s: adding policing action failed: %s",
1998 netdev_name
, ovs_strerror(error
));
2003 netdev
->kbits_rate
= kbits_rate
;
2004 netdev
->kbits_burst
= kbits_burst
;
2007 if (!error
|| error
== ENODEV
) {
2008 netdev
->netdev_policing_error
= error
;
2009 netdev
->cache_valid
|= VALID_POLICING
;
2011 ovs_mutex_unlock(&netdev
->mutex
);
2016 netdev_linux_get_qos_types(const struct netdev
*netdev OVS_UNUSED
,
2019 const struct tc_ops
*const *opsp
;
2021 for (opsp
= tcs
; *opsp
!= NULL
; opsp
++) {
2022 const struct tc_ops
*ops
= *opsp
;
2023 if (ops
->tc_install
&& ops
->ovs_name
[0] != '\0') {
2024 sset_add(types
, ops
->ovs_name
);
2030 static const struct tc_ops
*
2031 tc_lookup_ovs_name(const char *name
)
2033 const struct tc_ops
*const *opsp
;
2035 for (opsp
= tcs
; *opsp
!= NULL
; opsp
++) {
2036 const struct tc_ops
*ops
= *opsp
;
2037 if (!strcmp(name
, ops
->ovs_name
)) {
2044 static const struct tc_ops
*
2045 tc_lookup_linux_name(const char *name
)
2047 const struct tc_ops
*const *opsp
;
2049 for (opsp
= tcs
; *opsp
!= NULL
; opsp
++) {
2050 const struct tc_ops
*ops
= *opsp
;
2051 if (ops
->linux_name
&& !strcmp(name
, ops
->linux_name
)) {
2058 static struct tc_queue
*
2059 tc_find_queue__(const struct netdev
*netdev_
, unsigned int queue_id
,
2062 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2063 struct tc_queue
*queue
;
2065 HMAP_FOR_EACH_IN_BUCKET (queue
, hmap_node
, hash
, &netdev
->tc
->queues
) {
2066 if (queue
->queue_id
== queue_id
) {
2073 static struct tc_queue
*
2074 tc_find_queue(const struct netdev
*netdev
, unsigned int queue_id
)
2076 return tc_find_queue__(netdev
, queue_id
, hash_int(queue_id
, 0));
2080 netdev_linux_get_qos_capabilities(const struct netdev
*netdev OVS_UNUSED
,
2082 struct netdev_qos_capabilities
*caps
)
2084 const struct tc_ops
*ops
= tc_lookup_ovs_name(type
);
2088 caps
->n_queues
= ops
->n_queues
;
2093 netdev_linux_get_qos(const struct netdev
*netdev_
,
2094 const char **typep
, struct smap
*details
)
2096 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2099 ovs_mutex_lock(&netdev
->mutex
);
2100 error
= tc_query_qdisc(netdev_
);
2102 *typep
= netdev
->tc
->ops
->ovs_name
;
2103 error
= (netdev
->tc
->ops
->qdisc_get
2104 ? netdev
->tc
->ops
->qdisc_get(netdev_
, details
)
2107 ovs_mutex_unlock(&netdev
->mutex
);
2113 netdev_linux_set_qos(struct netdev
*netdev_
,
2114 const char *type
, const struct smap
*details
)
2116 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2117 const struct tc_ops
*new_ops
;
2120 new_ops
= tc_lookup_ovs_name(type
);
2121 if (!new_ops
|| !new_ops
->tc_install
) {
2125 ovs_mutex_lock(&netdev
->mutex
);
2126 error
= tc_query_qdisc(netdev_
);
2131 if (new_ops
== netdev
->tc
->ops
) {
2132 error
= new_ops
->qdisc_set
? new_ops
->qdisc_set(netdev_
, details
) : 0;
2134 /* Delete existing qdisc. */
2135 error
= tc_del_qdisc(netdev_
);
2139 ovs_assert(netdev
->tc
== NULL
);
2141 /* Install new qdisc. */
2142 error
= new_ops
->tc_install(netdev_
, details
);
2143 ovs_assert((error
== 0) == (netdev
->tc
!= NULL
));
2147 ovs_mutex_unlock(&netdev
->mutex
);
2152 netdev_linux_get_queue(const struct netdev
*netdev_
,
2153 unsigned int queue_id
, struct smap
*details
)
2155 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2158 ovs_mutex_lock(&netdev
->mutex
);
2159 error
= tc_query_qdisc(netdev_
);
2161 struct tc_queue
*queue
= tc_find_queue(netdev_
, queue_id
);
2163 ? netdev
->tc
->ops
->class_get(netdev_
, queue
, details
)
2166 ovs_mutex_unlock(&netdev
->mutex
);
2172 netdev_linux_set_queue(struct netdev
*netdev_
,
2173 unsigned int queue_id
, const struct smap
*details
)
2175 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2178 ovs_mutex_lock(&netdev
->mutex
);
2179 error
= tc_query_qdisc(netdev_
);
2181 error
= (queue_id
< netdev
->tc
->ops
->n_queues
2182 && netdev
->tc
->ops
->class_set
2183 ? netdev
->tc
->ops
->class_set(netdev_
, queue_id
, details
)
2186 ovs_mutex_unlock(&netdev
->mutex
);
2192 netdev_linux_delete_queue(struct netdev
*netdev_
, unsigned int queue_id
)
2194 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2197 ovs_mutex_lock(&netdev
->mutex
);
2198 error
= tc_query_qdisc(netdev_
);
2200 if (netdev
->tc
->ops
->class_delete
) {
2201 struct tc_queue
*queue
= tc_find_queue(netdev_
, queue_id
);
2203 ? netdev
->tc
->ops
->class_delete(netdev_
, queue
)
2209 ovs_mutex_unlock(&netdev
->mutex
);
2215 netdev_linux_get_queue_stats(const struct netdev
*netdev_
,
2216 unsigned int queue_id
,
2217 struct netdev_queue_stats
*stats
)
2219 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2222 ovs_mutex_lock(&netdev
->mutex
);
2223 error
= tc_query_qdisc(netdev_
);
2225 if (netdev
->tc
->ops
->class_get_stats
) {
2226 const struct tc_queue
*queue
= tc_find_queue(netdev_
, queue_id
);
2228 stats
->created
= queue
->created
;
2229 error
= netdev
->tc
->ops
->class_get_stats(netdev_
, queue
,
2238 ovs_mutex_unlock(&netdev
->mutex
);
2243 struct queue_dump_state
{
2244 struct nl_dump dump
;
2249 start_queue_dump(const struct netdev
*netdev
, struct queue_dump_state
*state
)
2251 struct ofpbuf request
;
2252 struct tcmsg
*tcmsg
;
2254 tcmsg
= tc_make_request(netdev
, RTM_GETTCLASS
, 0, &request
);
2258 tcmsg
->tcm_parent
= 0;
2259 nl_dump_start(&state
->dump
, NETLINK_ROUTE
, &request
);
2260 ofpbuf_uninit(&request
);
2262 ofpbuf_init(&state
->buf
, NL_DUMP_BUFSIZE
);
2267 finish_queue_dump(struct queue_dump_state
*state
)
2269 ofpbuf_uninit(&state
->buf
);
2270 return nl_dump_done(&state
->dump
);
2273 struct netdev_linux_queue_state
{
2274 unsigned int *queues
;
2280 netdev_linux_queue_dump_start(const struct netdev
*netdev_
, void **statep
)
2282 const struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2285 ovs_mutex_lock(&netdev
->mutex
);
2286 error
= tc_query_qdisc(netdev_
);
2288 if (netdev
->tc
->ops
->class_get
) {
2289 struct netdev_linux_queue_state
*state
;
2290 struct tc_queue
*queue
;
2293 *statep
= state
= xmalloc(sizeof *state
);
2294 state
->n_queues
= hmap_count(&netdev
->tc
->queues
);
2295 state
->cur_queue
= 0;
2296 state
->queues
= xmalloc(state
->n_queues
* sizeof *state
->queues
);
2299 HMAP_FOR_EACH (queue
, hmap_node
, &netdev
->tc
->queues
) {
2300 state
->queues
[i
++] = queue
->queue_id
;
2306 ovs_mutex_unlock(&netdev
->mutex
);
2312 netdev_linux_queue_dump_next(const struct netdev
*netdev_
, void *state_
,
2313 unsigned int *queue_idp
, struct smap
*details
)
2315 const struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2316 struct netdev_linux_queue_state
*state
= state_
;
2319 ovs_mutex_lock(&netdev
->mutex
);
2320 while (state
->cur_queue
< state
->n_queues
) {
2321 unsigned int queue_id
= state
->queues
[state
->cur_queue
++];
2322 struct tc_queue
*queue
= tc_find_queue(netdev_
, queue_id
);
2325 *queue_idp
= queue_id
;
2326 error
= netdev
->tc
->ops
->class_get(netdev_
, queue
, details
);
2330 ovs_mutex_unlock(&netdev
->mutex
);
2336 netdev_linux_queue_dump_done(const struct netdev
*netdev OVS_UNUSED
,
2339 struct netdev_linux_queue_state
*state
= state_
;
2341 free(state
->queues
);
2347 netdev_linux_dump_queue_stats(const struct netdev
*netdev_
,
2348 netdev_dump_queue_stats_cb
*cb
, void *aux
)
2350 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2353 ovs_mutex_lock(&netdev
->mutex
);
2354 error
= tc_query_qdisc(netdev_
);
2356 struct queue_dump_state state
;
2358 if (!netdev
->tc
->ops
->class_dump_stats
) {
2360 } else if (!start_queue_dump(netdev_
, &state
)) {
2366 while (nl_dump_next(&state
.dump
, &msg
, &state
.buf
)) {
2367 retval
= netdev
->tc
->ops
->class_dump_stats(netdev_
, &msg
,
2374 retval
= finish_queue_dump(&state
);
2380 ovs_mutex_unlock(&netdev
->mutex
);
2386 netdev_linux_get_in4(const struct netdev
*netdev_
,
2387 struct in_addr
*address
, struct in_addr
*netmask
)
2389 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2392 ovs_mutex_lock(&netdev
->mutex
);
2393 if (!(netdev
->cache_valid
& VALID_IN4
)) {
2394 error
= netdev_linux_get_ipv4(netdev_
, &netdev
->address
,
2395 SIOCGIFADDR
, "SIOCGIFADDR");
2397 error
= netdev_linux_get_ipv4(netdev_
, &netdev
->netmask
,
2398 SIOCGIFNETMASK
, "SIOCGIFNETMASK");
2400 netdev
->cache_valid
|= VALID_IN4
;
2408 if (netdev
->address
.s_addr
!= INADDR_ANY
) {
2409 *address
= netdev
->address
;
2410 *netmask
= netdev
->netmask
;
2412 error
= EADDRNOTAVAIL
;
2415 ovs_mutex_unlock(&netdev
->mutex
);
2421 netdev_linux_set_in4(struct netdev
*netdev_
, struct in_addr address
,
2422 struct in_addr netmask
)
2424 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2427 ovs_mutex_lock(&netdev
->mutex
);
2428 error
= do_set_addr(netdev_
, SIOCSIFADDR
, "SIOCSIFADDR", address
);
2430 netdev
->cache_valid
|= VALID_IN4
;
2431 netdev
->address
= address
;
2432 netdev
->netmask
= netmask
;
2433 if (address
.s_addr
!= INADDR_ANY
) {
2434 error
= do_set_addr(netdev_
, SIOCSIFNETMASK
,
2435 "SIOCSIFNETMASK", netmask
);
2438 ovs_mutex_unlock(&netdev
->mutex
);
2444 parse_if_inet6_line(const char *line
,
2445 struct in6_addr
*in6
, char ifname
[16 + 1])
2447 uint8_t *s6
= in6
->s6_addr
;
2448 #define X8 "%2"SCNx8
2449 return ovs_scan(line
,
2450 " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
2451 "%*x %*x %*x %*x %16s\n",
2452 &s6
[0], &s6
[1], &s6
[2], &s6
[3],
2453 &s6
[4], &s6
[5], &s6
[6], &s6
[7],
2454 &s6
[8], &s6
[9], &s6
[10], &s6
[11],
2455 &s6
[12], &s6
[13], &s6
[14], &s6
[15],
2459 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
2460 * 'in6' is non-null) and returns true. Otherwise, returns false. */
2462 netdev_linux_get_in6(const struct netdev
*netdev_
, struct in6_addr
*in6
)
2464 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2466 ovs_mutex_lock(&netdev
->mutex
);
2467 if (!(netdev
->cache_valid
& VALID_IN6
)) {
2471 netdev
->in6
= in6addr_any
;
2473 file
= fopen("/proc/net/if_inet6", "r");
2475 const char *name
= netdev_get_name(netdev_
);
2476 while (fgets(line
, sizeof line
, file
)) {
2477 struct in6_addr in6_tmp
;
2478 char ifname
[16 + 1];
2479 if (parse_if_inet6_line(line
, &in6_tmp
, ifname
)
2480 && !strcmp(name
, ifname
))
2482 netdev
->in6
= in6_tmp
;
2488 netdev
->cache_valid
|= VALID_IN6
;
2491 ovs_mutex_unlock(&netdev
->mutex
);
2497 make_in4_sockaddr(struct sockaddr
*sa
, struct in_addr addr
)
2499 struct sockaddr_in sin
;
2500 memset(&sin
, 0, sizeof sin
);
2501 sin
.sin_family
= AF_INET
;
2502 sin
.sin_addr
= addr
;
2505 memset(sa
, 0, sizeof *sa
);
2506 memcpy(sa
, &sin
, sizeof sin
);
2510 do_set_addr(struct netdev
*netdev
,
2511 int ioctl_nr
, const char *ioctl_name
, struct in_addr addr
)
2515 make_in4_sockaddr(&ifr
.ifr_addr
, addr
);
2516 return af_inet_ifreq_ioctl(netdev_get_name(netdev
), &ifr
, ioctl_nr
,
2520 /* Adds 'router' as a default IP gateway. */
2522 netdev_linux_add_router(struct netdev
*netdev OVS_UNUSED
, struct in_addr router
)
2524 struct in_addr any
= { INADDR_ANY
};
2528 memset(&rt
, 0, sizeof rt
);
2529 make_in4_sockaddr(&rt
.rt_dst
, any
);
2530 make_in4_sockaddr(&rt
.rt_gateway
, router
);
2531 make_in4_sockaddr(&rt
.rt_genmask
, any
);
2532 rt
.rt_flags
= RTF_UP
| RTF_GATEWAY
;
2533 error
= af_inet_ioctl(SIOCADDRT
, &rt
);
2535 VLOG_WARN("ioctl(SIOCADDRT): %s", ovs_strerror(error
));
2541 netdev_linux_get_next_hop(const struct in_addr
*host
, struct in_addr
*next_hop
,
2544 static const char fn
[] = "/proc/net/route";
2549 *netdev_name
= NULL
;
2550 stream
= fopen(fn
, "r");
2551 if (stream
== NULL
) {
2552 VLOG_WARN_RL(&rl
, "%s: open failed: %s", fn
, ovs_strerror(errno
));
2557 while (fgets(line
, sizeof line
, stream
)) {
2560 ovs_be32 dest
, gateway
, mask
;
2561 int refcnt
, metric
, mtu
;
2562 unsigned int flags
, use
, window
, irtt
;
2565 "%16s %"SCNx32
" %"SCNx32
" %04X %d %u %d %"SCNx32
2567 iface
, &dest
, &gateway
, &flags
, &refcnt
,
2568 &use
, &metric
, &mask
, &mtu
, &window
, &irtt
)) {
2569 VLOG_WARN_RL(&rl
, "%s: could not parse line %d: %s",
2573 if (!(flags
& RTF_UP
)) {
2574 /* Skip routes that aren't up. */
2578 /* The output of 'dest', 'mask', and 'gateway' were given in
2579 * network byte order, so we don't need need any endian
2580 * conversions here. */
2581 if ((dest
& mask
) == (host
->s_addr
& mask
)) {
2583 /* The host is directly reachable. */
2584 next_hop
->s_addr
= 0;
2586 /* To reach the host, we must go through a gateway. */
2587 next_hop
->s_addr
= gateway
;
2589 *netdev_name
= xstrdup(iface
);
2601 netdev_linux_get_status(const struct netdev
*netdev_
, struct smap
*smap
)
2603 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2606 ovs_mutex_lock(&netdev
->mutex
);
2607 if (!(netdev
->cache_valid
& VALID_DRVINFO
)) {
2608 struct ethtool_cmd
*cmd
= (struct ethtool_cmd
*) &netdev
->drvinfo
;
2610 COVERAGE_INC(netdev_get_ethtool
);
2611 memset(&netdev
->drvinfo
, 0, sizeof netdev
->drvinfo
);
2612 error
= netdev_linux_do_ethtool(netdev
->up
.name
,
2615 "ETHTOOL_GDRVINFO");
2617 netdev
->cache_valid
|= VALID_DRVINFO
;
2622 smap_add(smap
, "driver_name", netdev
->drvinfo
.driver
);
2623 smap_add(smap
, "driver_version", netdev
->drvinfo
.version
);
2624 smap_add(smap
, "firmware_version", netdev
->drvinfo
.fw_version
);
2626 ovs_mutex_unlock(&netdev
->mutex
);
2632 netdev_internal_get_status(const struct netdev
*netdev OVS_UNUSED
,
2635 smap_add(smap
, "driver_name", "openvswitch");
2639 /* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
2640 * successfully retrieved, it stores the corresponding MAC address in 'mac' and
2641 * returns 0. Otherwise, it returns a positive errno value; in particular,
2642 * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
2644 netdev_linux_arp_lookup(const struct netdev
*netdev
,
2645 ovs_be32 ip
, uint8_t mac
[ETH_ADDR_LEN
])
2648 struct sockaddr_in sin
;
2651 memset(&r
, 0, sizeof r
);
2652 memset(&sin
, 0, sizeof sin
);
2653 sin
.sin_family
= AF_INET
;
2654 sin
.sin_addr
.s_addr
= ip
;
2656 memcpy(&r
.arp_pa
, &sin
, sizeof sin
);
2657 r
.arp_ha
.sa_family
= ARPHRD_ETHER
;
2659 ovs_strzcpy(r
.arp_dev
, netdev_get_name(netdev
), sizeof r
.arp_dev
);
2660 COVERAGE_INC(netdev_arp_lookup
);
2661 retval
= af_inet_ioctl(SIOCGARP
, &r
);
2663 memcpy(mac
, r
.arp_ha
.sa_data
, ETH_ADDR_LEN
);
2664 } else if (retval
!= ENXIO
) {
2665 VLOG_WARN_RL(&rl
, "%s: could not look up ARP entry for "IP_FMT
": %s",
2666 netdev_get_name(netdev
), IP_ARGS(ip
),
2667 ovs_strerror(retval
));
2673 nd_to_iff_flags(enum netdev_flags nd
)
2676 if (nd
& NETDEV_UP
) {
2679 if (nd
& NETDEV_PROMISC
) {
2682 if (nd
& NETDEV_LOOPBACK
) {
2683 iff
|= IFF_LOOPBACK
;
2689 iff_to_nd_flags(int iff
)
2691 enum netdev_flags nd
= 0;
2695 if (iff
& IFF_PROMISC
) {
2696 nd
|= NETDEV_PROMISC
;
2698 if (iff
& IFF_LOOPBACK
) {
2699 nd
|= NETDEV_LOOPBACK
;
2705 update_flags(struct netdev_linux
*netdev
, enum netdev_flags off
,
2706 enum netdev_flags on
, enum netdev_flags
*old_flagsp
)
2707 OVS_REQUIRES(netdev
->mutex
)
2709 int old_flags
, new_flags
;
2712 old_flags
= netdev
->ifi_flags
;
2713 *old_flagsp
= iff_to_nd_flags(old_flags
);
2714 new_flags
= (old_flags
& ~nd_to_iff_flags(off
)) | nd_to_iff_flags(on
);
2715 if (new_flags
!= old_flags
) {
2716 error
= set_flags(netdev_get_name(&netdev
->up
), new_flags
);
2717 get_flags(&netdev
->up
, &netdev
->ifi_flags
);
2724 netdev_linux_update_flags(struct netdev
*netdev_
, enum netdev_flags off
,
2725 enum netdev_flags on
, enum netdev_flags
*old_flagsp
)
2727 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2730 ovs_mutex_lock(&netdev
->mutex
);
2731 error
= update_flags(netdev
, off
, on
, old_flagsp
);
2732 ovs_mutex_unlock(&netdev
->mutex
);
2737 #define NETDEV_LINUX_CLASS(NAME, CONSTRUCT, GET_STATS, SET_STATS, \
2738 GET_FEATURES, GET_STATUS) \
2744 netdev_linux_wait, \
2746 netdev_linux_alloc, \
2748 netdev_linux_destruct, \
2749 netdev_linux_dealloc, \
2750 NULL, /* get_config */ \
2751 NULL, /* set_config */ \
2752 NULL, /* get_tunnel_config */ \
2753 NULL, /* get_numa_id */ \
2755 netdev_linux_send, \
2756 netdev_linux_send_wait, \
2758 netdev_linux_set_etheraddr, \
2759 netdev_linux_get_etheraddr, \
2760 netdev_linux_get_mtu, \
2761 netdev_linux_set_mtu, \
2762 netdev_linux_get_ifindex, \
2763 netdev_linux_get_carrier, \
2764 netdev_linux_get_carrier_resets, \
2765 netdev_linux_set_miimon_interval, \
2770 netdev_linux_set_advertisements, \
2772 netdev_linux_set_policing, \
2773 netdev_linux_get_qos_types, \
2774 netdev_linux_get_qos_capabilities, \
2775 netdev_linux_get_qos, \
2776 netdev_linux_set_qos, \
2777 netdev_linux_get_queue, \
2778 netdev_linux_set_queue, \
2779 netdev_linux_delete_queue, \
2780 netdev_linux_get_queue_stats, \
2781 netdev_linux_queue_dump_start, \
2782 netdev_linux_queue_dump_next, \
2783 netdev_linux_queue_dump_done, \
2784 netdev_linux_dump_queue_stats, \
2786 netdev_linux_get_in4, \
2787 netdev_linux_set_in4, \
2788 netdev_linux_get_in6, \
2789 netdev_linux_add_router, \
2790 netdev_linux_get_next_hop, \
2792 netdev_linux_arp_lookup, \
2794 netdev_linux_update_flags, \
2796 netdev_linux_rxq_alloc, \
2797 netdev_linux_rxq_construct, \
2798 netdev_linux_rxq_destruct, \
2799 netdev_linux_rxq_dealloc, \
2800 netdev_linux_rxq_recv, \
2801 netdev_linux_rxq_wait, \
2802 netdev_linux_rxq_drain, \
2805 const struct netdev_class netdev_linux_class
=
2808 netdev_linux_construct
,
2809 netdev_linux_get_stats
,
2810 NULL
, /* set_stats */
2811 netdev_linux_get_features
,
2812 netdev_linux_get_status
);
2814 const struct netdev_class netdev_tap_class
=
2817 netdev_linux_construct_tap
,
2818 netdev_tap_get_stats
,
2819 NULL
, /* set_stats */
2820 netdev_linux_get_features
,
2821 netdev_linux_get_status
);
2823 const struct netdev_class netdev_internal_class
=
2826 netdev_linux_construct
,
2827 netdev_internal_get_stats
,
2828 netdev_internal_set_stats
,
2829 NULL
, /* get_features */
2830 netdev_internal_get_status
);
2832 /* HTB traffic control class. */
2834 #define HTB_N_QUEUES 0xf000
2838 unsigned int max_rate
; /* In bytes/s. */
2842 struct tc_queue tc_queue
;
2843 unsigned int min_rate
; /* In bytes/s. */
2844 unsigned int max_rate
; /* In bytes/s. */
2845 unsigned int burst
; /* In bytes. */
2846 unsigned int priority
; /* Lower values are higher priorities. */
2850 htb_get__(const struct netdev
*netdev_
)
2852 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2853 return CONTAINER_OF(netdev
->tc
, struct htb
, tc
);
2857 htb_install__(struct netdev
*netdev_
, uint64_t max_rate
)
2859 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
2862 htb
= xmalloc(sizeof *htb
);
2863 tc_init(&htb
->tc
, &tc_ops_htb
);
2864 htb
->max_rate
= max_rate
;
2866 netdev
->tc
= &htb
->tc
;
2869 /* Create an HTB qdisc.
2871 * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2873 htb_setup_qdisc__(struct netdev
*netdev
)
2876 struct tc_htb_glob opt
;
2877 struct ofpbuf request
;
2878 struct tcmsg
*tcmsg
;
2880 tc_del_qdisc(netdev
);
2882 tcmsg
= tc_make_request(netdev
, RTM_NEWQDISC
,
2883 NLM_F_EXCL
| NLM_F_CREATE
, &request
);
2887 tcmsg
->tcm_handle
= tc_make_handle(1, 0);
2888 tcmsg
->tcm_parent
= TC_H_ROOT
;
2890 nl_msg_put_string(&request
, TCA_KIND
, "htb");
2892 memset(&opt
, 0, sizeof opt
);
2893 opt
.rate2quantum
= 10;
2897 opt_offset
= nl_msg_start_nested(&request
, TCA_OPTIONS
);
2898 nl_msg_put_unspec(&request
, TCA_HTB_INIT
, &opt
, sizeof opt
);
2899 nl_msg_end_nested(&request
, opt_offset
);
2901 return tc_transact(&request
, NULL
);
2904 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2905 * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2907 htb_setup_class__(struct netdev
*netdev
, unsigned int handle
,
2908 unsigned int parent
, struct htb_class
*class)
2911 struct tc_htb_opt opt
;
2912 struct ofpbuf request
;
2913 struct tcmsg
*tcmsg
;
2917 error
= netdev_linux_get_mtu__(netdev_linux_cast(netdev
), &mtu
);
2919 VLOG_WARN_RL(&rl
, "cannot set up HTB on device %s that lacks MTU",
2920 netdev_get_name(netdev
));
2924 memset(&opt
, 0, sizeof opt
);
2925 tc_fill_rate(&opt
.rate
, class->min_rate
, mtu
);
2926 tc_fill_rate(&opt
.ceil
, class->max_rate
, mtu
);
2927 opt
.buffer
= tc_calc_buffer(opt
.rate
.rate
, mtu
, class->burst
);
2928 opt
.cbuffer
= tc_calc_buffer(opt
.ceil
.rate
, mtu
, class->burst
);
2929 opt
.prio
= class->priority
;
2931 tcmsg
= tc_make_request(netdev
, RTM_NEWTCLASS
, NLM_F_CREATE
, &request
);
2935 tcmsg
->tcm_handle
= handle
;
2936 tcmsg
->tcm_parent
= parent
;
2938 nl_msg_put_string(&request
, TCA_KIND
, "htb");
2939 opt_offset
= nl_msg_start_nested(&request
, TCA_OPTIONS
);
2940 nl_msg_put_unspec(&request
, TCA_HTB_PARMS
, &opt
, sizeof opt
);
2941 tc_put_rtab(&request
, TCA_HTB_RTAB
, &opt
.rate
);
2942 tc_put_rtab(&request
, TCA_HTB_CTAB
, &opt
.ceil
);
2943 nl_msg_end_nested(&request
, opt_offset
);
2945 error
= tc_transact(&request
, NULL
);
2947 VLOG_WARN_RL(&rl
, "failed to replace %s class %u:%u, parent %u:%u, "
2948 "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2949 netdev_get_name(netdev
),
2950 tc_get_major(handle
), tc_get_minor(handle
),
2951 tc_get_major(parent
), tc_get_minor(parent
),
2952 class->min_rate
, class->max_rate
,
2953 class->burst
, class->priority
, ovs_strerror(error
));
2958 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2959 * description of them into 'details'. The description complies with the
2960 * specification given in the vswitch database documentation for linux-htb
2963 htb_parse_tca_options__(struct nlattr
*nl_options
, struct htb_class
*class)
2965 static const struct nl_policy tca_htb_policy
[] = {
2966 [TCA_HTB_PARMS
] = { .type
= NL_A_UNSPEC
, .optional
= false,
2967 .min_len
= sizeof(struct tc_htb_opt
) },
2970 struct nlattr
*attrs
[ARRAY_SIZE(tca_htb_policy
)];
2971 const struct tc_htb_opt
*htb
;
2973 if (!nl_parse_nested(nl_options
, tca_htb_policy
,
2974 attrs
, ARRAY_SIZE(tca_htb_policy
))) {
2975 VLOG_WARN_RL(&rl
, "failed to parse HTB class options");
2979 htb
= nl_attr_get(attrs
[TCA_HTB_PARMS
]);
2980 class->min_rate
= htb
->rate
.rate
;
2981 class->max_rate
= htb
->ceil
.rate
;
2982 class->burst
= tc_ticks_to_bytes(htb
->rate
.rate
, htb
->buffer
);
2983 class->priority
= htb
->prio
;
2988 htb_parse_tcmsg__(struct ofpbuf
*tcmsg
, unsigned int *queue_id
,
2989 struct htb_class
*options
,
2990 struct netdev_queue_stats
*stats
)
2992 struct nlattr
*nl_options
;
2993 unsigned int handle
;
2996 error
= tc_parse_class(tcmsg
, &handle
, &nl_options
, stats
);
2997 if (!error
&& queue_id
) {
2998 unsigned int major
= tc_get_major(handle
);
2999 unsigned int minor
= tc_get_minor(handle
);
3000 if (major
== 1 && minor
> 0 && minor
<= HTB_N_QUEUES
) {
3001 *queue_id
= minor
- 1;
3006 if (!error
&& options
) {
3007 error
= htb_parse_tca_options__(nl_options
, options
);
3013 htb_parse_qdisc_details__(struct netdev
*netdev_
,
3014 const struct smap
*details
, struct htb_class
*hc
)
3016 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3017 const char *max_rate_s
;
3019 max_rate_s
= smap_get(details
, "max-rate");
3020 hc
->max_rate
= max_rate_s
? strtoull(max_rate_s
, NULL
, 10) / 8 : 0;
3021 if (!hc
->max_rate
) {
3022 enum netdev_features current
;
3024 netdev_linux_read_features(netdev
);
3025 current
= !netdev
->get_features_error
? netdev
->current
: 0;
3026 hc
->max_rate
= netdev_features_to_bps(current
, 100 * 1000 * 1000) / 8;
3028 hc
->min_rate
= hc
->max_rate
;
3034 htb_parse_class_details__(struct netdev
*netdev
,
3035 const struct smap
*details
, struct htb_class
*hc
)
3037 const struct htb
*htb
= htb_get__(netdev
);
3038 const char *min_rate_s
= smap_get(details
, "min-rate");
3039 const char *max_rate_s
= smap_get(details
, "max-rate");
3040 const char *burst_s
= smap_get(details
, "burst");
3041 const char *priority_s
= smap_get(details
, "priority");
3044 error
= netdev_linux_get_mtu__(netdev_linux_cast(netdev
), &mtu
);
3046 VLOG_WARN_RL(&rl
, "cannot parse HTB class on device %s that lacks MTU",
3047 netdev_get_name(netdev
));
3051 /* HTB requires at least an mtu sized min-rate to send any traffic even
3052 * on uncongested links. */
3053 hc
->min_rate
= min_rate_s
? strtoull(min_rate_s
, NULL
, 10) / 8 : 0;
3054 hc
->min_rate
= MAX(hc
->min_rate
, mtu
);
3055 hc
->min_rate
= MIN(hc
->min_rate
, htb
->max_rate
);
3058 hc
->max_rate
= (max_rate_s
3059 ? strtoull(max_rate_s
, NULL
, 10) / 8
3061 hc
->max_rate
= MAX(hc
->max_rate
, hc
->min_rate
);
3062 hc
->max_rate
= MIN(hc
->max_rate
, htb
->max_rate
);
3066 * According to hints in the documentation that I've read, it is important
3067 * that 'burst' be at least as big as the largest frame that might be
3068 * transmitted. Also, making 'burst' a bit bigger than necessary is OK,
3069 * but having it a bit too small is a problem. Since netdev_get_mtu()
3070 * doesn't include the Ethernet header, we need to add at least 14 (18?) to
3071 * the MTU. We actually add 64, instead of 14, as a guard against
3072 * additional headers get tacked on somewhere that we're not aware of. */
3073 hc
->burst
= burst_s
? strtoull(burst_s
, NULL
, 10) / 8 : 0;
3074 hc
->burst
= MAX(hc
->burst
, mtu
+ 64);
3077 hc
->priority
= priority_s
? strtoul(priority_s
, NULL
, 10) : 0;
3083 htb_query_class__(const struct netdev
*netdev
, unsigned int handle
,
3084 unsigned int parent
, struct htb_class
*options
,
3085 struct netdev_queue_stats
*stats
)
3087 struct ofpbuf
*reply
;
3090 error
= tc_query_class(netdev
, handle
, parent
, &reply
);
3092 error
= htb_parse_tcmsg__(reply
, NULL
, options
, stats
);
3093 ofpbuf_delete(reply
);
3099 htb_tc_install(struct netdev
*netdev
, const struct smap
*details
)
3103 error
= htb_setup_qdisc__(netdev
);
3105 struct htb_class hc
;
3107 htb_parse_qdisc_details__(netdev
, details
, &hc
);
3108 error
= htb_setup_class__(netdev
, tc_make_handle(1, 0xfffe),
3109 tc_make_handle(1, 0), &hc
);
3111 htb_install__(netdev
, hc
.max_rate
);
3117 static struct htb_class
*
3118 htb_class_cast__(const struct tc_queue
*queue
)
3120 return CONTAINER_OF(queue
, struct htb_class
, tc_queue
);
3124 htb_update_queue__(struct netdev
*netdev
, unsigned int queue_id
,
3125 const struct htb_class
*hc
)
3127 struct htb
*htb
= htb_get__(netdev
);
3128 size_t hash
= hash_int(queue_id
, 0);
3129 struct tc_queue
*queue
;
3130 struct htb_class
*hcp
;
3132 queue
= tc_find_queue__(netdev
, queue_id
, hash
);
3134 hcp
= htb_class_cast__(queue
);
3136 hcp
= xmalloc(sizeof *hcp
);
3137 queue
= &hcp
->tc_queue
;
3138 queue
->queue_id
= queue_id
;
3139 queue
->created
= time_msec();
3140 hmap_insert(&htb
->tc
.queues
, &queue
->hmap_node
, hash
);
3143 hcp
->min_rate
= hc
->min_rate
;
3144 hcp
->max_rate
= hc
->max_rate
;
3145 hcp
->burst
= hc
->burst
;
3146 hcp
->priority
= hc
->priority
;
3150 htb_tc_load(struct netdev
*netdev
, struct ofpbuf
*nlmsg OVS_UNUSED
)
3153 struct queue_dump_state state
;
3154 struct htb_class hc
;
3156 /* Get qdisc options. */
3158 htb_query_class__(netdev
, tc_make_handle(1, 0xfffe), 0, &hc
, NULL
);
3159 htb_install__(netdev
, hc
.max_rate
);
3162 if (!start_queue_dump(netdev
, &state
)) {
3165 while (nl_dump_next(&state
.dump
, &msg
, &state
.buf
)) {
3166 unsigned int queue_id
;
3168 if (!htb_parse_tcmsg__(&msg
, &queue_id
, &hc
, NULL
)) {
3169 htb_update_queue__(netdev
, queue_id
, &hc
);
3172 finish_queue_dump(&state
);
3178 htb_tc_destroy(struct tc
*tc
)
3180 struct htb
*htb
= CONTAINER_OF(tc
, struct htb
, tc
);
3181 struct htb_class
*hc
, *next
;
3183 HMAP_FOR_EACH_SAFE (hc
, next
, tc_queue
.hmap_node
, &htb
->tc
.queues
) {
3184 hmap_remove(&htb
->tc
.queues
, &hc
->tc_queue
.hmap_node
);
3192 htb_qdisc_get(const struct netdev
*netdev
, struct smap
*details
)
3194 const struct htb
*htb
= htb_get__(netdev
);
3195 smap_add_format(details
, "max-rate", "%llu", 8ULL * htb
->max_rate
);
3200 htb_qdisc_set(struct netdev
*netdev
, const struct smap
*details
)
3202 struct htb_class hc
;
3205 htb_parse_qdisc_details__(netdev
, details
, &hc
);
3206 error
= htb_setup_class__(netdev
, tc_make_handle(1, 0xfffe),
3207 tc_make_handle(1, 0), &hc
);
3209 htb_get__(netdev
)->max_rate
= hc
.max_rate
;
3215 htb_class_get(const struct netdev
*netdev OVS_UNUSED
,
3216 const struct tc_queue
*queue
, struct smap
*details
)
3218 const struct htb_class
*hc
= htb_class_cast__(queue
);
3220 smap_add_format(details
, "min-rate", "%llu", 8ULL * hc
->min_rate
);
3221 if (hc
->min_rate
!= hc
->max_rate
) {
3222 smap_add_format(details
, "max-rate", "%llu", 8ULL * hc
->max_rate
);
3224 smap_add_format(details
, "burst", "%llu", 8ULL * hc
->burst
);
3226 smap_add_format(details
, "priority", "%u", hc
->priority
);
3232 htb_class_set(struct netdev
*netdev
, unsigned int queue_id
,
3233 const struct smap
*details
)
3235 struct htb_class hc
;
3238 error
= htb_parse_class_details__(netdev
, details
, &hc
);
3243 error
= htb_setup_class__(netdev
, tc_make_handle(1, queue_id
+ 1),
3244 tc_make_handle(1, 0xfffe), &hc
);
3249 htb_update_queue__(netdev
, queue_id
, &hc
);
3254 htb_class_delete(struct netdev
*netdev
, struct tc_queue
*queue
)
3256 struct htb_class
*hc
= htb_class_cast__(queue
);
3257 struct htb
*htb
= htb_get__(netdev
);
3260 error
= tc_delete_class(netdev
, tc_make_handle(1, queue
->queue_id
+ 1));
3262 hmap_remove(&htb
->tc
.queues
, &hc
->tc_queue
.hmap_node
);
3269 htb_class_get_stats(const struct netdev
*netdev
, const struct tc_queue
*queue
,
3270 struct netdev_queue_stats
*stats
)
3272 return htb_query_class__(netdev
, tc_make_handle(1, queue
->queue_id
+ 1),
3273 tc_make_handle(1, 0xfffe), NULL
, stats
);
3277 htb_class_dump_stats(const struct netdev
*netdev OVS_UNUSED
,
3278 const struct ofpbuf
*nlmsg
,
3279 netdev_dump_queue_stats_cb
*cb
, void *aux
)
3281 struct netdev_queue_stats stats
;
3282 unsigned int handle
, major
, minor
;
3285 error
= tc_parse_class(nlmsg
, &handle
, NULL
, &stats
);
3290 major
= tc_get_major(handle
);
3291 minor
= tc_get_minor(handle
);
3292 if (major
== 1 && minor
> 0 && minor
<= HTB_N_QUEUES
) {
3293 (*cb
)(minor
- 1, &stats
, aux
);
3298 static const struct tc_ops tc_ops_htb
= {
3299 "htb", /* linux_name */
3300 "linux-htb", /* ovs_name */
3301 HTB_N_QUEUES
, /* n_queues */
3310 htb_class_get_stats
,
3311 htb_class_dump_stats
3314 /* "linux-hfsc" traffic control class. */
3316 #define HFSC_N_QUEUES 0xf000
3324 struct tc_queue tc_queue
;
3329 static struct hfsc
*
3330 hfsc_get__(const struct netdev
*netdev_
)
3332 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3333 return CONTAINER_OF(netdev
->tc
, struct hfsc
, tc
);
3336 static struct hfsc_class
*
3337 hfsc_class_cast__(const struct tc_queue
*queue
)
3339 return CONTAINER_OF(queue
, struct hfsc_class
, tc_queue
);
3343 hfsc_install__(struct netdev
*netdev_
, uint32_t max_rate
)
3345 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3348 hfsc
= xmalloc(sizeof *hfsc
);
3349 tc_init(&hfsc
->tc
, &tc_ops_hfsc
);
3350 hfsc
->max_rate
= max_rate
;
3351 netdev
->tc
= &hfsc
->tc
;
3355 hfsc_update_queue__(struct netdev
*netdev
, unsigned int queue_id
,
3356 const struct hfsc_class
*hc
)
3360 struct hfsc_class
*hcp
;
3361 struct tc_queue
*queue
;
3363 hfsc
= hfsc_get__(netdev
);
3364 hash
= hash_int(queue_id
, 0);
3366 queue
= tc_find_queue__(netdev
, queue_id
, hash
);
3368 hcp
= hfsc_class_cast__(queue
);
3370 hcp
= xmalloc(sizeof *hcp
);
3371 queue
= &hcp
->tc_queue
;
3372 queue
->queue_id
= queue_id
;
3373 queue
->created
= time_msec();
3374 hmap_insert(&hfsc
->tc
.queues
, &queue
->hmap_node
, hash
);
3377 hcp
->min_rate
= hc
->min_rate
;
3378 hcp
->max_rate
= hc
->max_rate
;
3382 hfsc_parse_tca_options__(struct nlattr
*nl_options
, struct hfsc_class
*class)
3384 const struct tc_service_curve
*rsc
, *fsc
, *usc
;
3385 static const struct nl_policy tca_hfsc_policy
[] = {
3387 .type
= NL_A_UNSPEC
,
3389 .min_len
= sizeof(struct tc_service_curve
),
3392 .type
= NL_A_UNSPEC
,
3394 .min_len
= sizeof(struct tc_service_curve
),
3397 .type
= NL_A_UNSPEC
,
3399 .min_len
= sizeof(struct tc_service_curve
),
3402 struct nlattr
*attrs
[ARRAY_SIZE(tca_hfsc_policy
)];
3404 if (!nl_parse_nested(nl_options
, tca_hfsc_policy
,
3405 attrs
, ARRAY_SIZE(tca_hfsc_policy
))) {
3406 VLOG_WARN_RL(&rl
, "failed to parse HFSC class options");
3410 rsc
= nl_attr_get(attrs
[TCA_HFSC_RSC
]);
3411 fsc
= nl_attr_get(attrs
[TCA_HFSC_FSC
]);
3412 usc
= nl_attr_get(attrs
[TCA_HFSC_USC
]);
3414 if (rsc
->m1
!= 0 || rsc
->d
!= 0 ||
3415 fsc
->m1
!= 0 || fsc
->d
!= 0 ||
3416 usc
->m1
!= 0 || usc
->d
!= 0) {
3417 VLOG_WARN_RL(&rl
, "failed to parse HFSC class options. "
3418 "Non-linear service curves are not supported.");
3422 if (rsc
->m2
!= fsc
->m2
) {
3423 VLOG_WARN_RL(&rl
, "failed to parse HFSC class options. "
3424 "Real-time service curves are not supported ");
3428 if (rsc
->m2
> usc
->m2
) {
3429 VLOG_WARN_RL(&rl
, "failed to parse HFSC class options. "
3430 "Min-rate service curve is greater than "
3431 "the max-rate service curve.");
3435 class->min_rate
= fsc
->m2
;
3436 class->max_rate
= usc
->m2
;
3441 hfsc_parse_tcmsg__(struct ofpbuf
*tcmsg
, unsigned int *queue_id
,
3442 struct hfsc_class
*options
,
3443 struct netdev_queue_stats
*stats
)
3446 unsigned int handle
;
3447 struct nlattr
*nl_options
;
3449 error
= tc_parse_class(tcmsg
, &handle
, &nl_options
, stats
);
3455 unsigned int major
, minor
;
3457 major
= tc_get_major(handle
);
3458 minor
= tc_get_minor(handle
);
3459 if (major
== 1 && minor
> 0 && minor
<= HFSC_N_QUEUES
) {
3460 *queue_id
= minor
- 1;
3467 error
= hfsc_parse_tca_options__(nl_options
, options
);
3474 hfsc_query_class__(const struct netdev
*netdev
, unsigned int handle
,
3475 unsigned int parent
, struct hfsc_class
*options
,
3476 struct netdev_queue_stats
*stats
)
3479 struct ofpbuf
*reply
;
3481 error
= tc_query_class(netdev
, handle
, parent
, &reply
);
3486 error
= hfsc_parse_tcmsg__(reply
, NULL
, options
, stats
);
3487 ofpbuf_delete(reply
);
3492 hfsc_parse_qdisc_details__(struct netdev
*netdev_
, const struct smap
*details
,
3493 struct hfsc_class
*class)
3495 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3497 const char *max_rate_s
;
3499 max_rate_s
= smap_get(details
, "max-rate");
3500 max_rate
= max_rate_s
? strtoull(max_rate_s
, NULL
, 10) / 8 : 0;
3503 enum netdev_features current
;
3505 netdev_linux_read_features(netdev
);
3506 current
= !netdev
->get_features_error
? netdev
->current
: 0;
3507 max_rate
= netdev_features_to_bps(current
, 100 * 1000 * 1000) / 8;
3510 class->min_rate
= max_rate
;
3511 class->max_rate
= max_rate
;
3515 hfsc_parse_class_details__(struct netdev
*netdev
,
3516 const struct smap
*details
,
3517 struct hfsc_class
* class)
3519 const struct hfsc
*hfsc
;
3520 uint32_t min_rate
, max_rate
;
3521 const char *min_rate_s
, *max_rate_s
;
3523 hfsc
= hfsc_get__(netdev
);
3524 min_rate_s
= smap_get(details
, "min-rate");
3525 max_rate_s
= smap_get(details
, "max-rate");
3527 min_rate
= min_rate_s
? strtoull(min_rate_s
, NULL
, 10) / 8 : 0;
3528 min_rate
= MAX(min_rate
, 1);
3529 min_rate
= MIN(min_rate
, hfsc
->max_rate
);
3531 max_rate
= (max_rate_s
3532 ? strtoull(max_rate_s
, NULL
, 10) / 8
3534 max_rate
= MAX(max_rate
, min_rate
);
3535 max_rate
= MIN(max_rate
, hfsc
->max_rate
);
3537 class->min_rate
= min_rate
;
3538 class->max_rate
= max_rate
;
3543 /* Create an HFSC qdisc.
3545 * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
3547 hfsc_setup_qdisc__(struct netdev
* netdev
)
3549 struct tcmsg
*tcmsg
;
3550 struct ofpbuf request
;
3551 struct tc_hfsc_qopt opt
;
3553 tc_del_qdisc(netdev
);
3555 tcmsg
= tc_make_request(netdev
, RTM_NEWQDISC
,
3556 NLM_F_EXCL
| NLM_F_CREATE
, &request
);
3562 tcmsg
->tcm_handle
= tc_make_handle(1, 0);
3563 tcmsg
->tcm_parent
= TC_H_ROOT
;
3565 memset(&opt
, 0, sizeof opt
);
3568 nl_msg_put_string(&request
, TCA_KIND
, "hfsc");
3569 nl_msg_put_unspec(&request
, TCA_OPTIONS
, &opt
, sizeof opt
);
3571 return tc_transact(&request
, NULL
);
3574 /* Create an HFSC class.
3576 * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
3577 * sc rate <min_rate> ul rate <max_rate>" */
3579 hfsc_setup_class__(struct netdev
*netdev
, unsigned int handle
,
3580 unsigned int parent
, struct hfsc_class
*class)
3584 struct tcmsg
*tcmsg
;
3585 struct ofpbuf request
;
3586 struct tc_service_curve min
, max
;
3588 tcmsg
= tc_make_request(netdev
, RTM_NEWTCLASS
, NLM_F_CREATE
, &request
);
3594 tcmsg
->tcm_handle
= handle
;
3595 tcmsg
->tcm_parent
= parent
;
3599 min
.m2
= class->min_rate
;
3603 max
.m2
= class->max_rate
;
3605 nl_msg_put_string(&request
, TCA_KIND
, "hfsc");
3606 opt_offset
= nl_msg_start_nested(&request
, TCA_OPTIONS
);
3607 nl_msg_put_unspec(&request
, TCA_HFSC_RSC
, &min
, sizeof min
);
3608 nl_msg_put_unspec(&request
, TCA_HFSC_FSC
, &min
, sizeof min
);
3609 nl_msg_put_unspec(&request
, TCA_HFSC_USC
, &max
, sizeof max
);
3610 nl_msg_end_nested(&request
, opt_offset
);
3612 error
= tc_transact(&request
, NULL
);
3614 VLOG_WARN_RL(&rl
, "failed to replace %s class %u:%u, parent %u:%u, "
3615 "min-rate %ubps, max-rate %ubps (%s)",
3616 netdev_get_name(netdev
),
3617 tc_get_major(handle
), tc_get_minor(handle
),
3618 tc_get_major(parent
), tc_get_minor(parent
),
3619 class->min_rate
, class->max_rate
, ovs_strerror(error
));
3626 hfsc_tc_install(struct netdev
*netdev
, const struct smap
*details
)
3629 struct hfsc_class
class;
3631 error
= hfsc_setup_qdisc__(netdev
);
3637 hfsc_parse_qdisc_details__(netdev
, details
, &class);
3638 error
= hfsc_setup_class__(netdev
, tc_make_handle(1, 0xfffe),
3639 tc_make_handle(1, 0), &class);
3645 hfsc_install__(netdev
, class.max_rate
);
3650 hfsc_tc_load(struct netdev
*netdev
, struct ofpbuf
*nlmsg OVS_UNUSED
)
3653 struct queue_dump_state state
;
3654 struct hfsc_class hc
;
3657 hfsc_query_class__(netdev
, tc_make_handle(1, 0xfffe), 0, &hc
, NULL
);
3658 hfsc_install__(netdev
, hc
.max_rate
);
3660 if (!start_queue_dump(netdev
, &state
)) {
3664 while (nl_dump_next(&state
.dump
, &msg
, &state
.buf
)) {
3665 unsigned int queue_id
;
3667 if (!hfsc_parse_tcmsg__(&msg
, &queue_id
, &hc
, NULL
)) {
3668 hfsc_update_queue__(netdev
, queue_id
, &hc
);
3672 finish_queue_dump(&state
);
3677 hfsc_tc_destroy(struct tc
*tc
)
3680 struct hfsc_class
*hc
, *next
;
3682 hfsc
= CONTAINER_OF(tc
, struct hfsc
, tc
);
3684 HMAP_FOR_EACH_SAFE (hc
, next
, tc_queue
.hmap_node
, &hfsc
->tc
.queues
) {
3685 hmap_remove(&hfsc
->tc
.queues
, &hc
->tc_queue
.hmap_node
);
3694 hfsc_qdisc_get(const struct netdev
*netdev
, struct smap
*details
)
3696 const struct hfsc
*hfsc
;
3697 hfsc
= hfsc_get__(netdev
);
3698 smap_add_format(details
, "max-rate", "%llu", 8ULL * hfsc
->max_rate
);
3703 hfsc_qdisc_set(struct netdev
*netdev
, const struct smap
*details
)
3706 struct hfsc_class
class;
3708 hfsc_parse_qdisc_details__(netdev
, details
, &class);
3709 error
= hfsc_setup_class__(netdev
, tc_make_handle(1, 0xfffe),
3710 tc_make_handle(1, 0), &class);
3713 hfsc_get__(netdev
)->max_rate
= class.max_rate
;
3720 hfsc_class_get(const struct netdev
*netdev OVS_UNUSED
,
3721 const struct tc_queue
*queue
, struct smap
*details
)
3723 const struct hfsc_class
*hc
;
3725 hc
= hfsc_class_cast__(queue
);
3726 smap_add_format(details
, "min-rate", "%llu", 8ULL * hc
->min_rate
);
3727 if (hc
->min_rate
!= hc
->max_rate
) {
3728 smap_add_format(details
, "max-rate", "%llu", 8ULL * hc
->max_rate
);
3734 hfsc_class_set(struct netdev
*netdev
, unsigned int queue_id
,
3735 const struct smap
*details
)
3738 struct hfsc_class
class;
3740 error
= hfsc_parse_class_details__(netdev
, details
, &class);
3745 error
= hfsc_setup_class__(netdev
, tc_make_handle(1, queue_id
+ 1),
3746 tc_make_handle(1, 0xfffe), &class);
3751 hfsc_update_queue__(netdev
, queue_id
, &class);
3756 hfsc_class_delete(struct netdev
*netdev
, struct tc_queue
*queue
)
3760 struct hfsc_class
*hc
;
3762 hc
= hfsc_class_cast__(queue
);
3763 hfsc
= hfsc_get__(netdev
);
3765 error
= tc_delete_class(netdev
, tc_make_handle(1, queue
->queue_id
+ 1));
3767 hmap_remove(&hfsc
->tc
.queues
, &hc
->tc_queue
.hmap_node
);
3774 hfsc_class_get_stats(const struct netdev
*netdev
, const struct tc_queue
*queue
,
3775 struct netdev_queue_stats
*stats
)
3777 return hfsc_query_class__(netdev
, tc_make_handle(1, queue
->queue_id
+ 1),
3778 tc_make_handle(1, 0xfffe), NULL
, stats
);
3782 hfsc_class_dump_stats(const struct netdev
*netdev OVS_UNUSED
,
3783 const struct ofpbuf
*nlmsg
,
3784 netdev_dump_queue_stats_cb
*cb
, void *aux
)
3786 struct netdev_queue_stats stats
;
3787 unsigned int handle
, major
, minor
;
3790 error
= tc_parse_class(nlmsg
, &handle
, NULL
, &stats
);
3795 major
= tc_get_major(handle
);
3796 minor
= tc_get_minor(handle
);
3797 if (major
== 1 && minor
> 0 && minor
<= HFSC_N_QUEUES
) {
3798 (*cb
)(minor
- 1, &stats
, aux
);
3803 static const struct tc_ops tc_ops_hfsc
= {
3804 "hfsc", /* linux_name */
3805 "linux-hfsc", /* ovs_name */
3806 HFSC_N_QUEUES
, /* n_queues */
3807 hfsc_tc_install
, /* tc_install */
3808 hfsc_tc_load
, /* tc_load */
3809 hfsc_tc_destroy
, /* tc_destroy */
3810 hfsc_qdisc_get
, /* qdisc_get */
3811 hfsc_qdisc_set
, /* qdisc_set */
3812 hfsc_class_get
, /* class_get */
3813 hfsc_class_set
, /* class_set */
3814 hfsc_class_delete
, /* class_delete */
3815 hfsc_class_get_stats
, /* class_get_stats */
3816 hfsc_class_dump_stats
/* class_dump_stats */
3819 /* "linux-default" traffic control class.
3821 * This class represents the default, unnamed Linux qdisc. It corresponds to
3822 * the "" (empty string) QoS type in the OVS database. */
3825 default_install__(struct netdev
*netdev_
)
3827 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3828 static const struct tc tc
= TC_INITIALIZER(&tc
, &tc_ops_default
);
3830 /* Nothing but a tc class implementation is allowed to write to a tc. This
3831 * class never does that, so we can legitimately use a const tc object. */
3832 netdev
->tc
= CONST_CAST(struct tc
*, &tc
);
3836 default_tc_install(struct netdev
*netdev
,
3837 const struct smap
*details OVS_UNUSED
)
3839 default_install__(netdev
);
3844 default_tc_load(struct netdev
*netdev
, struct ofpbuf
*nlmsg OVS_UNUSED
)
3846 default_install__(netdev
);
3850 static const struct tc_ops tc_ops_default
= {
3851 NULL
, /* linux_name */
3856 NULL
, /* tc_destroy */
3857 NULL
, /* qdisc_get */
3858 NULL
, /* qdisc_set */
3859 NULL
, /* class_get */
3860 NULL
, /* class_set */
3861 NULL
, /* class_delete */
3862 NULL
, /* class_get_stats */
3863 NULL
/* class_dump_stats */
3866 /* "linux-other" traffic control class.
3871 other_tc_load(struct netdev
*netdev_
, struct ofpbuf
*nlmsg OVS_UNUSED
)
3873 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
3874 static const struct tc tc
= TC_INITIALIZER(&tc
, &tc_ops_other
);
3876 /* Nothing but a tc class implementation is allowed to write to a tc. This
3877 * class never does that, so we can legitimately use a const tc object. */
3878 netdev
->tc
= CONST_CAST(struct tc
*, &tc
);
3882 static const struct tc_ops tc_ops_other
= {
3883 NULL
, /* linux_name */
3884 "linux-other", /* ovs_name */
3886 NULL
, /* tc_install */
3888 NULL
, /* tc_destroy */
3889 NULL
, /* qdisc_get */
3890 NULL
, /* qdisc_set */
3891 NULL
, /* class_get */
3892 NULL
, /* class_set */
3893 NULL
, /* class_delete */
3894 NULL
, /* class_get_stats */
3895 NULL
/* class_dump_stats */
3898 /* Traffic control. */
3900 /* Number of kernel "tc" ticks per second. */
3901 static double ticks_per_s
;
3903 /* Number of kernel "jiffies" per second. This is used for the purpose of
3904 * computing buffer sizes. Generally kernel qdiscs need to be able to buffer
3905 * one jiffy's worth of data.
3907 * There are two possibilities here:
3909 * - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3910 * approximate range of 100 to 1024. That means that we really need to
3911 * make sure that the qdisc can buffer that much data.
3913 * - 'buffer_hz' is an absurdly large number. That means that the kernel
3914 * has finely granular timers and there's no need to fudge additional room
3915 * for buffers. (There's no extra effort needed to implement that: the
3916 * large 'buffer_hz' is used as a divisor, so practically any number will
3917 * come out as 0 in the division. Small integer results in the case of
3918 * really high dividends won't have any real effect anyhow.)
3920 static unsigned int buffer_hz
;
3922 /* Returns tc handle 'major':'minor'. */
3924 tc_make_handle(unsigned int major
, unsigned int minor
)
3926 return TC_H_MAKE(major
<< 16, minor
);
3929 /* Returns the major number from 'handle'. */
3931 tc_get_major(unsigned int handle
)
3933 return TC_H_MAJ(handle
) >> 16;
3936 /* Returns the minor number from 'handle'. */
3938 tc_get_minor(unsigned int handle
)
3940 return TC_H_MIN(handle
);
3943 static struct tcmsg
*
3944 tc_make_request(const struct netdev
*netdev
, int type
, unsigned int flags
,
3945 struct ofpbuf
*request
)
3947 struct tcmsg
*tcmsg
;
3951 error
= get_ifindex(netdev
, &ifindex
);
3956 ofpbuf_init(request
, 512);
3957 nl_msg_put_nlmsghdr(request
, sizeof *tcmsg
, type
, NLM_F_REQUEST
| flags
);
3958 tcmsg
= ofpbuf_put_zeros(request
, sizeof *tcmsg
);
3959 tcmsg
->tcm_family
= AF_UNSPEC
;
3960 tcmsg
->tcm_ifindex
= ifindex
;
3961 /* Caller should fill in tcmsg->tcm_handle. */
3962 /* Caller should fill in tcmsg->tcm_parent. */
3968 tc_transact(struct ofpbuf
*request
, struct ofpbuf
**replyp
)
3970 int error
= nl_transact(NETLINK_ROUTE
, request
, replyp
);
3971 ofpbuf_uninit(request
);
3975 /* Adds or deletes a root ingress qdisc on 'netdev'. We use this for
3976 * policing configuration.
3978 * This function is equivalent to running the following when 'add' is true:
3979 * /sbin/tc qdisc add dev <devname> handle ffff: ingress
3981 * This function is equivalent to running the following when 'add' is false:
3982 * /sbin/tc qdisc del dev <devname> handle ffff: ingress
3984 * The configuration and stats may be seen with the following command:
3985 * /sbin/tc -s qdisc show dev <devname>
3987 * Returns 0 if successful, otherwise a positive errno value.
3990 tc_add_del_ingress_qdisc(struct netdev
*netdev
, bool add
)
3992 struct ofpbuf request
;
3993 struct tcmsg
*tcmsg
;
3995 int type
= add
? RTM_NEWQDISC
: RTM_DELQDISC
;
3996 int flags
= add
? NLM_F_EXCL
| NLM_F_CREATE
: 0;
3998 tcmsg
= tc_make_request(netdev
, type
, flags
, &request
);
4002 tcmsg
->tcm_handle
= tc_make_handle(0xffff, 0);
4003 tcmsg
->tcm_parent
= TC_H_INGRESS
;
4004 nl_msg_put_string(&request
, TCA_KIND
, "ingress");
4005 nl_msg_put_unspec(&request
, TCA_OPTIONS
, NULL
, 0);
4007 error
= tc_transact(&request
, NULL
);
4009 /* If we're deleting the qdisc, don't worry about some of the
4010 * error conditions. */
4011 if (!add
&& (error
== ENOENT
|| error
== EINVAL
)) {
4020 /* Adds a policer to 'netdev' with a rate of 'kbits_rate' and a burst size
4023 * This function is equivalent to running:
4024 * /sbin/tc filter add dev <devname> parent ffff: protocol all prio 49
4025 * basic police rate <kbits_rate>kbit burst <kbits_burst>k
4028 * The configuration and stats may be seen with the following command:
4029 * /sbin/tc -s filter show <devname> eth0 parent ffff:
4031 * Returns 0 if successful, otherwise a positive errno value.
4034 tc_add_policer(struct netdev
*netdev
, int kbits_rate
, int kbits_burst
)
4036 struct tc_police tc_police
;
4037 struct ofpbuf request
;
4038 struct tcmsg
*tcmsg
;
4039 size_t basic_offset
;
4040 size_t police_offset
;
4044 memset(&tc_police
, 0, sizeof tc_police
);
4045 tc_police
.action
= TC_POLICE_SHOT
;
4046 tc_police
.mtu
= mtu
;
4047 tc_fill_rate(&tc_police
.rate
, ((uint64_t) kbits_rate
* 1000)/8, mtu
);
4048 tc_police
.burst
= tc_bytes_to_ticks(tc_police
.rate
.rate
,
4049 kbits_burst
* 1024);
4051 tcmsg
= tc_make_request(netdev
, RTM_NEWTFILTER
,
4052 NLM_F_EXCL
| NLM_F_CREATE
, &request
);
4056 tcmsg
->tcm_parent
= tc_make_handle(0xffff, 0);
4057 tcmsg
->tcm_info
= tc_make_handle(49,
4058 (OVS_FORCE
uint16_t) htons(ETH_P_ALL
));
4060 nl_msg_put_string(&request
, TCA_KIND
, "basic");
4061 basic_offset
= nl_msg_start_nested(&request
, TCA_OPTIONS
);
4062 police_offset
= nl_msg_start_nested(&request
, TCA_BASIC_POLICE
);
4063 nl_msg_put_unspec(&request
, TCA_POLICE_TBF
, &tc_police
, sizeof tc_police
);
4064 tc_put_rtab(&request
, TCA_POLICE_RATE
, &tc_police
.rate
);
4065 nl_msg_end_nested(&request
, police_offset
);
4066 nl_msg_end_nested(&request
, basic_offset
);
4068 error
= tc_transact(&request
, NULL
);
4079 /* The values in psched are not individually very meaningful, but they are
4080 * important. The tables below show some values seen in the wild.
4084 * - "c" has always been a constant 1000000 since at least Linux 2.4.14.
4085 * (Before that, there are hints that it was 1000000000.)
4087 * - "d" can be unrealistically large, see the comment on 'buffer_hz'
4091 * -----------------------------------
4092 * [1] 000c8000 000f4240 000f4240 00000064
4093 * [2] 000003e8 00000400 000f4240 3b9aca00
4094 * [3] 000003e8 00000400 000f4240 3b9aca00
4095 * [4] 000003e8 00000400 000f4240 00000064
4096 * [5] 000003e8 00000040 000f4240 3b9aca00
4097 * [6] 000003e8 00000040 000f4240 000000f9
4099 * a b c d ticks_per_s buffer_hz
4100 * ------- --------- ---------- ------------- ----------- -------------
4101 * [1] 819,200 1,000,000 1,000,000 100 819,200 100
4102 * [2] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
4103 * [3] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
4104 * [4] 1,000 1,024 1,000,000 100 976,562 100
4105 * [5] 1,000 64 1,000,000 1,000,000,000 15,625,000 1,000,000,000
4106 * [6] 1,000 64 1,000,000 249 15,625,000 249
4108 * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
4109 * [2] 2.6.26-1-686-bigmem from Debian lenny
4110 * [3] 2.6.26-2-sparc64 from Debian lenny
4111 * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
4112 * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
4113 * [6] 2.6.34 from kernel.org on KVM
4115 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
4116 static const char fn
[] = "/proc/net/psched";
4117 unsigned int a
, b
, c
, d
;
4120 if (!ovsthread_once_start(&once
)) {
4127 stream
= fopen(fn
, "r");
4129 VLOG_WARN("%s: open failed: %s", fn
, ovs_strerror(errno
));
4133 if (fscanf(stream
, "%x %x %x %x", &a
, &b
, &c
, &d
) != 4) {
4134 VLOG_WARN("%s: read failed", fn
);
4138 VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn
, a
, b
, c
, d
);
4142 VLOG_WARN("%s: invalid scheduler parameters", fn
);
4146 ticks_per_s
= (double) a
* c
/ b
;
4150 VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
4153 VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn
, ticks_per_s
, buffer_hz
);
4156 ovsthread_once_done(&once
);
4159 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
4160 * rate of 'rate' bytes per second. */
4162 tc_ticks_to_bytes(unsigned int rate
, unsigned int ticks
)
4165 return (rate
* ticks
) / ticks_per_s
;
4168 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
4169 * rate of 'rate' bytes per second. */
4171 tc_bytes_to_ticks(unsigned int rate
, unsigned int size
)
4174 return rate
? ((unsigned long long int) ticks_per_s
* size
) / rate
: 0;
4177 /* Returns the number of bytes that need to be reserved for qdisc buffering at
4178 * a transmission rate of 'rate' bytes per second. */
4180 tc_buffer_per_jiffy(unsigned int rate
)
4183 return rate
/ buffer_hz
;
4186 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
4187 * e.g. "htb", into '*kind' (if it is nonnull). If 'options' is nonnull,
4188 * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
4189 * stores NULL into it if it is absent.
4191 * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
4194 * Returns 0 if successful, otherwise a positive errno value. */
4196 tc_parse_qdisc(const struct ofpbuf
*msg
, const char **kind
,
4197 struct nlattr
**options
)
4199 static const struct nl_policy tca_policy
[] = {
4200 [TCA_KIND
] = { .type
= NL_A_STRING
, .optional
= false },
4201 [TCA_OPTIONS
] = { .type
= NL_A_NESTED
, .optional
= true },
4203 struct nlattr
*ta
[ARRAY_SIZE(tca_policy
)];
4205 if (!nl_policy_parse(msg
, NLMSG_HDRLEN
+ sizeof(struct tcmsg
),
4206 tca_policy
, ta
, ARRAY_SIZE(ta
))) {
4207 VLOG_WARN_RL(&rl
, "failed to parse qdisc message");
4212 *kind
= nl_attr_get_string(ta
[TCA_KIND
]);
4216 *options
= ta
[TCA_OPTIONS
];
4231 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
4232 * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
4233 * into '*options', and its queue statistics into '*stats'. Any of the output
4234 * arguments may be null.
4236 * Returns 0 if successful, otherwise a positive errno value. */
4238 tc_parse_class(const struct ofpbuf
*msg
, unsigned int *handlep
,
4239 struct nlattr
**options
, struct netdev_queue_stats
*stats
)
4241 static const struct nl_policy tca_policy
[] = {
4242 [TCA_OPTIONS
] = { .type
= NL_A_NESTED
, .optional
= false },
4243 [TCA_STATS2
] = { .type
= NL_A_NESTED
, .optional
= false },
4245 struct nlattr
*ta
[ARRAY_SIZE(tca_policy
)];
4247 if (!nl_policy_parse(msg
, NLMSG_HDRLEN
+ sizeof(struct tcmsg
),
4248 tca_policy
, ta
, ARRAY_SIZE(ta
))) {
4249 VLOG_WARN_RL(&rl
, "failed to parse class message");
4254 struct tcmsg
*tc
= ofpbuf_at_assert(msg
, NLMSG_HDRLEN
, sizeof *tc
);
4255 *handlep
= tc
->tcm_handle
;
4259 *options
= ta
[TCA_OPTIONS
];
4263 const struct gnet_stats_queue
*gsq
;
4264 struct gnet_stats_basic gsb
;
4266 static const struct nl_policy stats_policy
[] = {
4267 [TCA_STATS_BASIC
] = { .type
= NL_A_UNSPEC
, .optional
= false,
4268 .min_len
= sizeof gsb
},
4269 [TCA_STATS_QUEUE
] = { .type
= NL_A_UNSPEC
, .optional
= false,
4270 .min_len
= sizeof *gsq
},
4272 struct nlattr
*sa
[ARRAY_SIZE(stats_policy
)];
4274 if (!nl_parse_nested(ta
[TCA_STATS2
], stats_policy
,
4275 sa
, ARRAY_SIZE(sa
))) {
4276 VLOG_WARN_RL(&rl
, "failed to parse class stats");
4280 /* Alignment issues screw up the length of struct gnet_stats_basic on
4281 * some arch/bitsize combinations. Newer versions of Linux have a
4282 * struct gnet_stats_basic_packed, but we can't depend on that. The
4283 * easiest thing to do is just to make a copy. */
4284 memset(&gsb
, 0, sizeof gsb
);
4285 memcpy(&gsb
, nl_attr_get(sa
[TCA_STATS_BASIC
]),
4286 MIN(nl_attr_get_size(sa
[TCA_STATS_BASIC
]), sizeof gsb
));
4287 stats
->tx_bytes
= gsb
.bytes
;
4288 stats
->tx_packets
= gsb
.packets
;
4290 gsq
= nl_attr_get(sa
[TCA_STATS_QUEUE
]);
4291 stats
->tx_errors
= gsq
->drops
;
4301 memset(stats
, 0, sizeof *stats
);
4306 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
4309 tc_query_class(const struct netdev
*netdev
,
4310 unsigned int handle
, unsigned int parent
,
4311 struct ofpbuf
**replyp
)
4313 struct ofpbuf request
;
4314 struct tcmsg
*tcmsg
;
4317 tcmsg
= tc_make_request(netdev
, RTM_GETTCLASS
, NLM_F_ECHO
, &request
);
4321 tcmsg
->tcm_handle
= handle
;
4322 tcmsg
->tcm_parent
= parent
;
4324 error
= tc_transact(&request
, replyp
);
4326 VLOG_WARN_RL(&rl
, "query %s class %u:%u (parent %u:%u) failed (%s)",
4327 netdev_get_name(netdev
),
4328 tc_get_major(handle
), tc_get_minor(handle
),
4329 tc_get_major(parent
), tc_get_minor(parent
),
4330 ovs_strerror(error
));
4335 /* Equivalent to "tc class del dev <name> handle <handle>". */
4337 tc_delete_class(const struct netdev
*netdev
, unsigned int handle
)
4339 struct ofpbuf request
;
4340 struct tcmsg
*tcmsg
;
4343 tcmsg
= tc_make_request(netdev
, RTM_DELTCLASS
, 0, &request
);
4347 tcmsg
->tcm_handle
= handle
;
4348 tcmsg
->tcm_parent
= 0;
4350 error
= tc_transact(&request
, NULL
);
4352 VLOG_WARN_RL(&rl
, "delete %s class %u:%u failed (%s)",
4353 netdev_get_name(netdev
),
4354 tc_get_major(handle
), tc_get_minor(handle
),
4355 ovs_strerror(error
));
4360 /* Equivalent to "tc qdisc del dev <name> root". */
4362 tc_del_qdisc(struct netdev
*netdev_
)
4364 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
4365 struct ofpbuf request
;
4366 struct tcmsg
*tcmsg
;
4369 tcmsg
= tc_make_request(netdev_
, RTM_DELQDISC
, 0, &request
);
4373 tcmsg
->tcm_handle
= tc_make_handle(1, 0);
4374 tcmsg
->tcm_parent
= TC_H_ROOT
;
4376 error
= tc_transact(&request
, NULL
);
4377 if (error
== EINVAL
) {
4378 /* EINVAL probably means that the default qdisc was in use, in which
4379 * case we've accomplished our purpose. */
4382 if (!error
&& netdev
->tc
) {
4383 if (netdev
->tc
->ops
->tc_destroy
) {
4384 netdev
->tc
->ops
->tc_destroy(netdev
->tc
);
4391 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
4392 * kernel to determine what they are. Returns 0 if successful, otherwise a
4393 * positive errno value. */
4395 tc_query_qdisc(const struct netdev
*netdev_
)
4397 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
4398 struct ofpbuf request
, *qdisc
;
4399 const struct tc_ops
*ops
;
4400 struct tcmsg
*tcmsg
;
4408 /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
4409 * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
4410 * 2.6.35 without that fix backported to it.
4412 * To avoid the OOPS, we must not make a request that would attempt to dump
4413 * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
4414 * few others. There are a few ways that I can see to do this, but most of
4415 * them seem to be racy (and if you lose the race the kernel OOPSes). The
4416 * technique chosen here is to assume that any non-default qdisc that we
4417 * create will have a class with handle 1:0. The built-in qdiscs only have
4418 * a class with handle 0:0.
4420 * We could check for Linux 2.6.35+ and use a more straightforward method
4422 tcmsg
= tc_make_request(netdev_
, RTM_GETQDISC
, NLM_F_ECHO
, &request
);
4426 tcmsg
->tcm_handle
= tc_make_handle(1, 0);
4427 tcmsg
->tcm_parent
= 0;
4429 /* Figure out what tc class to instantiate. */
4430 error
= tc_transact(&request
, &qdisc
);
4434 error
= tc_parse_qdisc(qdisc
, &kind
, NULL
);
4436 ops
= &tc_ops_other
;
4438 ops
= tc_lookup_linux_name(kind
);
4440 static struct vlog_rate_limit rl2
= VLOG_RATE_LIMIT_INIT(1, 1);
4441 VLOG_INFO_RL(&rl2
, "unknown qdisc \"%s\"", kind
);
4443 ops
= &tc_ops_other
;
4446 } else if (error
== ENOENT
) {
4447 /* Either it's a built-in qdisc, or it's a qdisc set up by some
4448 * other entity that doesn't have a handle 1:0. We will assume
4449 * that it's the system default qdisc. */
4450 ops
= &tc_ops_default
;
4453 /* Who knows? Maybe the device got deleted. */
4454 VLOG_WARN_RL(&rl
, "query %s qdisc failed (%s)",
4455 netdev_get_name(netdev_
), ovs_strerror(error
));
4456 ops
= &tc_ops_other
;
4459 /* Instantiate it. */
4460 load_error
= ops
->tc_load(CONST_CAST(struct netdev
*, netdev_
), qdisc
);
4461 ovs_assert((load_error
== 0) == (netdev
->tc
!= NULL
));
4462 ofpbuf_delete(qdisc
);
4464 return error
? error
: load_error
;
4467 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
4468 approximate the time to transmit packets of various lengths. For an MTU of
4469 256 or less, each entry is exact; for an MTU of 257 through 512, each entry
4470 represents two possible packet lengths; for a MTU of 513 through 1024, four
4471 possible lengths; and so on.
4473 Returns, for the specified 'mtu', the number of bits that packet lengths
4474 need to be shifted right to fit within such a 256-entry table. */
4476 tc_calc_cell_log(unsigned int mtu
)
4481 mtu
= ETH_PAYLOAD_MAX
;
4483 mtu
+= ETH_HEADER_LEN
+ VLAN_HEADER_LEN
;
4485 for (cell_log
= 0; mtu
>= 256; cell_log
++) {
4492 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
4495 tc_fill_rate(struct tc_ratespec
*rate
, uint64_t Bps
, int mtu
)
4497 memset(rate
, 0, sizeof *rate
);
4498 rate
->cell_log
= tc_calc_cell_log(mtu
);
4499 /* rate->overhead = 0; */ /* New in 2.6.24, not yet in some */
4500 /* rate->cell_align = 0; */ /* distro headers. */
4501 rate
->mpu
= ETH_TOTAL_MIN
;
4505 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
4506 * attribute of the specified "type".
4508 * See tc_calc_cell_log() above for a description of "rtab"s. */
4510 tc_put_rtab(struct ofpbuf
*msg
, uint16_t type
, const struct tc_ratespec
*rate
)
4515 rtab
= nl_msg_put_unspec_uninit(msg
, type
, TC_RTAB_SIZE
);
4516 for (i
= 0; i
< TC_RTAB_SIZE
/ sizeof *rtab
; i
++) {
4517 unsigned packet_size
= (i
+ 1) << rate
->cell_log
;
4518 if (packet_size
< rate
->mpu
) {
4519 packet_size
= rate
->mpu
;
4521 rtab
[i
] = tc_bytes_to_ticks(rate
->rate
, packet_size
);
4525 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
4526 * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
4527 * burst size of 'burst_bytes'. (If no value was requested, a 'burst_bytes' of
4530 tc_calc_buffer(unsigned int Bps
, int mtu
, uint64_t burst_bytes
)
4532 unsigned int min_burst
= tc_buffer_per_jiffy(Bps
) + mtu
;
4533 return tc_bytes_to_ticks(Bps
, MAX(burst_bytes
, min_burst
));
4536 /* Linux-only functions declared in netdev-linux.h */
4538 /* Modifies the 'flag' bit in ethtool's flags field for 'netdev'. If
4539 * 'enable' is true, the bit is set. Otherwise, it is cleared. */
4541 netdev_linux_ethtool_set_flag(struct netdev
*netdev
, uint32_t flag
,
4542 const char *flag_name
, bool enable
)
4544 const char *netdev_name
= netdev_get_name(netdev
);
4545 struct ethtool_value evalue
;
4549 COVERAGE_INC(netdev_get_ethtool
);
4550 memset(&evalue
, 0, sizeof evalue
);
4551 error
= netdev_linux_do_ethtool(netdev_name
,
4552 (struct ethtool_cmd
*)&evalue
,
4553 ETHTOOL_GFLAGS
, "ETHTOOL_GFLAGS");
4558 COVERAGE_INC(netdev_set_ethtool
);
4559 evalue
.data
= new_flags
= (evalue
.data
& ~flag
) | (enable
? flag
: 0);
4560 error
= netdev_linux_do_ethtool(netdev_name
,
4561 (struct ethtool_cmd
*)&evalue
,
4562 ETHTOOL_SFLAGS
, "ETHTOOL_SFLAGS");
4567 COVERAGE_INC(netdev_get_ethtool
);
4568 memset(&evalue
, 0, sizeof evalue
);
4569 error
= netdev_linux_do_ethtool(netdev_name
,
4570 (struct ethtool_cmd
*)&evalue
,
4571 ETHTOOL_GFLAGS
, "ETHTOOL_GFLAGS");
4576 if (new_flags
!= evalue
.data
) {
4577 VLOG_WARN_RL(&rl
, "attempt to %s ethtool %s flag on network "
4578 "device %s failed", enable
? "enable" : "disable",
4579 flag_name
, netdev_name
);
4586 /* Utility functions. */
4588 /* Copies 'src' into 'dst', performing format conversion in the process. */
4590 netdev_stats_from_rtnl_link_stats(struct netdev_stats
*dst
,
4591 const struct rtnl_link_stats
*src
)
4593 dst
->rx_packets
= src
->rx_packets
;
4594 dst
->tx_packets
= src
->tx_packets
;
4595 dst
->rx_bytes
= src
->rx_bytes
;
4596 dst
->tx_bytes
= src
->tx_bytes
;
4597 dst
->rx_errors
= src
->rx_errors
;
4598 dst
->tx_errors
= src
->tx_errors
;
4599 dst
->rx_dropped
= src
->rx_dropped
;
4600 dst
->tx_dropped
= src
->tx_dropped
;
4601 dst
->multicast
= src
->multicast
;
4602 dst
->collisions
= src
->collisions
;
4603 dst
->rx_length_errors
= src
->rx_length_errors
;
4604 dst
->rx_over_errors
= src
->rx_over_errors
;
4605 dst
->rx_crc_errors
= src
->rx_crc_errors
;
4606 dst
->rx_frame_errors
= src
->rx_frame_errors
;
4607 dst
->rx_fifo_errors
= src
->rx_fifo_errors
;
4608 dst
->rx_missed_errors
= src
->rx_missed_errors
;
4609 dst
->tx_aborted_errors
= src
->tx_aborted_errors
;
4610 dst
->tx_carrier_errors
= src
->tx_carrier_errors
;
4611 dst
->tx_fifo_errors
= src
->tx_fifo_errors
;
4612 dst
->tx_heartbeat_errors
= src
->tx_heartbeat_errors
;
4613 dst
->tx_window_errors
= src
->tx_window_errors
;
4617 get_stats_via_netlink(const struct netdev
*netdev_
, struct netdev_stats
*stats
)
4619 struct ofpbuf request
;
4620 struct ofpbuf
*reply
;
4623 ofpbuf_init(&request
, 0);
4624 nl_msg_put_nlmsghdr(&request
,
4625 sizeof(struct ifinfomsg
) + NL_ATTR_SIZE(IFNAMSIZ
),
4626 RTM_GETLINK
, NLM_F_REQUEST
);
4627 ofpbuf_put_zeros(&request
, sizeof(struct ifinfomsg
));
4628 nl_msg_put_string(&request
, IFLA_IFNAME
, netdev_get_name(netdev_
));
4629 error
= nl_transact(NETLINK_ROUTE
, &request
, &reply
);
4630 ofpbuf_uninit(&request
);
4635 if (ofpbuf_try_pull(reply
, NLMSG_HDRLEN
+ sizeof(struct ifinfomsg
))) {
4636 const struct nlattr
*a
= nl_attr_find(reply
, 0, IFLA_STATS
);
4637 if (a
&& nl_attr_get_size(a
) >= sizeof(struct rtnl_link_stats
)) {
4638 netdev_stats_from_rtnl_link_stats(stats
, nl_attr_get(a
));
4641 VLOG_WARN_RL(&rl
, "RTM_GETLINK reply lacks stats");
4645 VLOG_WARN_RL(&rl
, "short RTM_GETLINK reply");
4650 ofpbuf_delete(reply
);
4655 get_flags(const struct netdev
*dev
, unsigned int *flags
)
4661 error
= af_inet_ifreq_ioctl(dev
->name
, &ifr
, SIOCGIFFLAGS
, "SIOCGIFFLAGS");
4663 *flags
= ifr
.ifr_flags
;
4669 set_flags(const char *name
, unsigned int flags
)
4673 ifr
.ifr_flags
= flags
;
4674 return af_inet_ifreq_ioctl(name
, &ifr
, SIOCSIFFLAGS
, "SIOCSIFFLAGS");
4678 do_get_ifindex(const char *netdev_name
)
4683 ovs_strzcpy(ifr
.ifr_name
, netdev_name
, sizeof ifr
.ifr_name
);
4684 COVERAGE_INC(netdev_get_ifindex
);
4686 error
= af_inet_ioctl(SIOCGIFINDEX
, &ifr
);
4688 VLOG_WARN_RL(&rl
, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
4689 netdev_name
, ovs_strerror(error
));
4692 return ifr
.ifr_ifindex
;
4696 get_ifindex(const struct netdev
*netdev_
, int *ifindexp
)
4698 struct netdev_linux
*netdev
= netdev_linux_cast(netdev_
);
4700 if (!(netdev
->cache_valid
& VALID_IFINDEX
)) {
4701 int ifindex
= do_get_ifindex(netdev_get_name(netdev_
));
4704 netdev
->get_ifindex_error
= -ifindex
;
4705 netdev
->ifindex
= 0;
4707 netdev
->get_ifindex_error
= 0;
4708 netdev
->ifindex
= ifindex
;
4710 netdev
->cache_valid
|= VALID_IFINDEX
;
4713 *ifindexp
= netdev
->ifindex
;
4714 return netdev
->get_ifindex_error
;
4718 get_etheraddr(const char *netdev_name
, uint8_t ea
[ETH_ADDR_LEN
])
4724 memset(&ifr
, 0, sizeof ifr
);
4725 ovs_strzcpy(ifr
.ifr_name
, netdev_name
, sizeof ifr
.ifr_name
);
4726 COVERAGE_INC(netdev_get_hwaddr
);
4727 error
= af_inet_ioctl(SIOCGIFHWADDR
, &ifr
);
4729 /* ENODEV probably means that a vif disappeared asynchronously and
4730 * hasn't been removed from the database yet, so reduce the log level
4731 * to INFO for that case. */
4732 VLOG(error
== ENODEV
? VLL_INFO
: VLL_ERR
,
4733 "ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4734 netdev_name
, ovs_strerror(error
));
4737 hwaddr_family
= ifr
.ifr_hwaddr
.sa_family
;
4738 if (hwaddr_family
!= AF_UNSPEC
&& hwaddr_family
!= ARPHRD_ETHER
) {
4739 VLOG_WARN("%s device has unknown hardware address family %d",
4740 netdev_name
, hwaddr_family
);
4742 memcpy(ea
, ifr
.ifr_hwaddr
.sa_data
, ETH_ADDR_LEN
);
4747 set_etheraddr(const char *netdev_name
,
4748 const uint8_t mac
[ETH_ADDR_LEN
])
4753 memset(&ifr
, 0, sizeof ifr
);
4754 ovs_strzcpy(ifr
.ifr_name
, netdev_name
, sizeof ifr
.ifr_name
);
4755 ifr
.ifr_hwaddr
.sa_family
= ARPHRD_ETHER
;
4756 memcpy(ifr
.ifr_hwaddr
.sa_data
, mac
, ETH_ADDR_LEN
);
4757 COVERAGE_INC(netdev_set_hwaddr
);
4758 error
= af_inet_ioctl(SIOCSIFHWADDR
, &ifr
);
4760 VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4761 netdev_name
, ovs_strerror(error
));
4767 netdev_linux_do_ethtool(const char *name
, struct ethtool_cmd
*ecmd
,
4768 int cmd
, const char *cmd_name
)
4773 memset(&ifr
, 0, sizeof ifr
);
4774 ovs_strzcpy(ifr
.ifr_name
, name
, sizeof ifr
.ifr_name
);
4775 ifr
.ifr_data
= (caddr_t
) ecmd
;
4778 error
= af_inet_ioctl(SIOCETHTOOL
, &ifr
);
4780 if (error
!= EOPNOTSUPP
) {
4781 VLOG_WARN_RL(&rl
, "ethtool command %s on network device %s "
4782 "failed: %s", cmd_name
, name
, ovs_strerror(error
));
4784 /* The device doesn't support this operation. That's pretty
4785 * common, so there's no point in logging anything. */
4792 netdev_linux_get_ipv4(const struct netdev
*netdev
, struct in_addr
*ip
,
4793 int cmd
, const char *cmd_name
)
4798 ifr
.ifr_addr
.sa_family
= AF_INET
;
4799 error
= af_inet_ifreq_ioctl(netdev_get_name(netdev
), &ifr
, cmd
, cmd_name
);
4801 const struct sockaddr_in
*sin
= ALIGNED_CAST(struct sockaddr_in
*,
4803 *ip
= sin
->sin_addr
;
4808 /* Returns an AF_PACKET raw socket or a negative errno value. */
4810 af_packet_sock(void)
4812 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
4815 if (ovsthread_once_start(&once
)) {
4816 sock
= socket(AF_PACKET
, SOCK_RAW
, 0);
4818 int error
= set_nonblocking(sock
);
4825 VLOG_ERR("failed to create packet socket: %s",
4826 ovs_strerror(errno
));
4828 ovsthread_once_done(&once
);