2 * Copyright (c) 2009, 2010 Nicira Networks.
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.
21 #include <arpa/inet.h>
23 #include <linux/gen_stats.h>
24 #include <linux/if_tun.h>
26 #include <linux/types.h>
27 #include <linux/ethtool.h>
28 #include <linux/pkt_sched.h>
29 #include <linux/rtnetlink.h>
30 #include <linux/sockios.h>
31 #include <linux/version.h>
32 #include <sys/types.h>
33 #include <sys/ioctl.h>
34 #include <sys/socket.h>
35 #include <netpacket/packet.h>
36 #include <net/ethernet.h>
38 #include <linux/if_tunnel.h>
39 #include <net/if_arp.h>
40 #include <net/if_packet.h>
41 #include <net/route.h>
42 #include <netinet/in.h>
49 #include "dynamic-string.h"
50 #include "fatal-signal.h"
53 #include "netdev-provider.h"
54 #include "netdev-vport.h"
57 #include "openflow/openflow.h"
59 #include "poll-loop.h"
60 #include "rtnetlink.h"
61 #include "socket-util.h"
66 VLOG_DEFINE_THIS_MODULE(netdev_linux);
68 /* These were introduced in Linux 2.6.14, so they might be missing if we have
70 #ifndef ADVERTISED_Pause
71 #define ADVERTISED_Pause (1 << 13)
73 #ifndef ADVERTISED_Asym_Pause
74 #define ADVERTISED_Asym_Pause (1 << 14)
77 /* This was introduced in Linux 2.6.25, so it might be missing if we have old
80 #define TC_RTAB_SIZE 1024
83 static struct rtnetlink_notifier netdev_linux_cache_notifier;
84 static int cache_notifier_refcount;
87 VALID_IFINDEX = 1 << 0,
88 VALID_ETHERADDR = 1 << 1,
92 VALID_CARRIER = 1 << 5,
93 VALID_IS_PSEUDO = 1 << 6, /* Represents is_internal and is_tap. */
94 VALID_POLICING = 1 << 7,
95 VALID_HAVE_VPORT_STATS = 1 << 8
103 /* Traffic control. */
105 /* An instance of a traffic control class. Always associated with a particular
108 * Each TC implementation subclasses this with whatever additional data it
111 const struct tc_ops *ops;
112 struct hmap queues; /* Contains "struct tc_queue"s.
113 * Read by generic TC layer.
114 * Written only by TC implementation. */
117 /* One traffic control queue.
119 * Each TC implementation subclasses this with whatever additional data it
122 struct hmap_node hmap_node; /* In struct tc's "queues" hmap. */
123 unsigned int queue_id; /* OpenFlow queue ID. */
126 /* A particular kind of traffic control. Each implementation generally maps to
127 * one particular Linux qdisc class.
129 * The functions below return 0 if successful or a positive errno value on
130 * failure, except where otherwise noted. All of them must be provided, except
131 * where otherwise noted. */
133 /* Name used by kernel in the TCA_KIND attribute of tcmsg, e.g. "htb".
134 * This is null for tc_ops_default and tc_ops_other, for which there are no
135 * appropriate values. */
136 const char *linux_name;
138 /* Name used in OVS database, e.g. "linux-htb". Must be nonnull. */
139 const char *ovs_name;
141 /* Number of supported OpenFlow queues, 0 for qdiscs that have no
142 * queues. The queues are numbered 0 through n_queues - 1. */
143 unsigned int n_queues;
145 /* Called to install this TC class on 'netdev'. The implementation should
146 * make the Netlink calls required to set up 'netdev' with the right qdisc
147 * and configure it according to 'details'. The implementation may assume
148 * that the current qdisc is the default; that is, there is no need for it
149 * to delete the current qdisc before installing itself.
151 * The contents of 'details' should be documented as valid for 'ovs_name'
152 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
153 * (which is built as ovs-vswitchd.conf.db(8)).
155 * This function must return 0 if and only if it sets 'netdev->tc' to an
156 * initialized 'struct tc'.
158 * (This function is null for tc_ops_other, which cannot be installed. For
159 * other TC classes it should always be nonnull.) */
160 int (*tc_install)(struct netdev *netdev, const struct shash *details);
162 /* Called when the netdev code determines (through a Netlink query) that
163 * this TC class's qdisc is installed on 'netdev', but we didn't install
164 * it ourselves and so don't know any of the details.
166 * 'nlmsg' is the kernel reply to a RTM_GETQDISC Netlink message for
167 * 'netdev'. The TCA_KIND attribute of 'nlmsg' is 'linux_name'. The
168 * implementation should parse the other attributes of 'nlmsg' as
169 * necessary to determine its configuration. If necessary it should also
170 * use Netlink queries to determine the configuration of queues on
173 * This function must return 0 if and only if it sets 'netdev->tc' to an
174 * initialized 'struct tc'. */
175 int (*tc_load)(struct netdev *netdev, struct ofpbuf *nlmsg);
177 /* Destroys the data structures allocated by the implementation as part of
178 * 'tc'. (This includes destroying 'tc->queues' by calling
181 * The implementation should not need to perform any Netlink calls. If
182 * desirable, the caller is responsible for deconfiguring the kernel qdisc.
183 * (But it may not be desirable.)
185 * This function may be null if 'tc' is trivial. */
186 void (*tc_destroy)(struct tc *tc);
188 /* Retrieves details of 'netdev->tc' configuration into 'details'.
190 * The implementation should not need to perform any Netlink calls, because
191 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
192 * cached the configuration.
194 * The contents of 'details' should be documented as valid for 'ovs_name'
195 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
196 * (which is built as ovs-vswitchd.conf.db(8)).
198 * This function may be null if 'tc' is not configurable.
200 int (*qdisc_get)(const struct netdev *netdev, struct shash *details);
202 /* Reconfigures 'netdev->tc' according to 'details', performing any
203 * required Netlink calls to complete the reconfiguration.
205 * The contents of 'details' should be documented as valid for 'ovs_name'
206 * in the "other_config" column in the "QoS" table in vswitchd/vswitch.xml
207 * (which is built as ovs-vswitchd.conf.db(8)).
209 * This function may be null if 'tc' is not configurable.
211 int (*qdisc_set)(struct netdev *, const struct shash *details);
213 /* Retrieves details of 'queue' on 'netdev->tc' into 'details'. 'queue' is
214 * one of the 'struct tc_queue's within 'netdev->tc->queues'.
216 * The contents of 'details' should be documented as valid for 'ovs_name'
217 * in the "other_config" column in the "Queue" table in
218 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
220 * The implementation should not need to perform any Netlink calls, because
221 * the 'tc_install' or 'tc_load' that instantiated 'netdev->tc' should have
222 * cached the queue configuration.
224 * This function may be null if 'tc' does not have queues ('n_queues' is
226 int (*class_get)(const struct netdev *netdev, const struct tc_queue *queue,
227 struct shash *details);
229 /* Configures or reconfigures 'queue_id' on 'netdev->tc' according to
230 * 'details', perfoming any required Netlink calls to complete the
231 * reconfiguration. The caller ensures that 'queue_id' is less than
234 * The contents of 'details' should be documented as valid for 'ovs_name'
235 * in the "other_config" column in the "Queue" table in
236 * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
238 * This function may be null if 'tc' does not have queues or its queues are
239 * not configurable. */
240 int (*class_set)(struct netdev *, unsigned int queue_id,
241 const struct shash *details);
243 /* Deletes 'queue' from 'netdev->tc'. 'queue' is one of the 'struct
244 * tc_queue's within 'netdev->tc->queues'.
246 * This function may be null if 'tc' does not have queues or its queues
247 * cannot be deleted. */
248 int (*class_delete)(struct netdev *, struct tc_queue *queue);
250 /* Obtains stats for 'queue' from 'netdev->tc'. 'queue' is one of the
251 * 'struct tc_queue's within 'netdev->tc->queues'.
253 * On success, initializes '*stats'.
255 * This function may be null if 'tc' does not have queues or if it cannot
256 * report queue statistics. */
257 int (*class_get_stats)(const struct netdev *netdev,
258 const struct tc_queue *queue,
259 struct netdev_queue_stats *stats);
261 /* Extracts queue stats from 'nlmsg', which is a response to a
262 * RTM_GETTCLASS message, and passes them to 'cb' along with 'aux'.
264 * This function may be null if 'tc' does not have queues or if it cannot
265 * report queue statistics. */
266 int (*class_dump_stats)(const struct netdev *netdev,
267 const struct ofpbuf *nlmsg,
268 netdev_dump_queue_stats_cb *cb, void *aux);
272 tc_init(struct tc *tc, const struct tc_ops *ops)
275 hmap_init(&tc->queues);
279 tc_destroy(struct tc *tc)
281 hmap_destroy(&tc->queues);
284 static const struct tc_ops tc_ops_htb;
285 static const struct tc_ops tc_ops_hfsc;
286 static const struct tc_ops tc_ops_default;
287 static const struct tc_ops tc_ops_other;
289 static const struct tc_ops *tcs[] = {
290 &tc_ops_htb, /* Hierarchy token bucket (see tc-htb(8)). */
291 &tc_ops_hfsc, /* Hierarchical fair service curve. */
292 &tc_ops_default, /* Default qdisc (see tc-pfifo_fast(8)). */
293 &tc_ops_other, /* Some other qdisc. */
297 static unsigned int tc_make_handle(unsigned int major, unsigned int minor);
298 static unsigned int tc_get_major(unsigned int handle);
299 static unsigned int tc_get_minor(unsigned int handle);
301 static unsigned int tc_ticks_to_bytes(unsigned int rate, unsigned int ticks);
302 static unsigned int tc_bytes_to_ticks(unsigned int rate, unsigned int size);
303 static unsigned int tc_buffer_per_jiffy(unsigned int rate);
305 static struct tcmsg *tc_make_request(const struct netdev *, int type,
306 unsigned int flags, struct ofpbuf *);
307 static int tc_transact(struct ofpbuf *request, struct ofpbuf **replyp);
309 static int tc_parse_qdisc(const struct ofpbuf *, const char **kind,
310 struct nlattr **options);
311 static int tc_parse_class(const struct ofpbuf *, unsigned int *queue_id,
312 struct nlattr **options,
313 struct netdev_queue_stats *);
314 static int tc_query_class(const struct netdev *,
315 unsigned int handle, unsigned int parent,
316 struct ofpbuf **replyp);
317 static int tc_delete_class(const struct netdev *, unsigned int handle);
319 static int tc_del_qdisc(struct netdev *netdev);
320 static int tc_query_qdisc(const struct netdev *netdev);
322 static int tc_calc_cell_log(unsigned int mtu);
323 static void tc_fill_rate(struct tc_ratespec *rate, uint64_t bps, int mtu);
324 static void tc_put_rtab(struct ofpbuf *, uint16_t type,
325 const struct tc_ratespec *rate);
326 static int tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes);
328 struct netdev_dev_linux {
329 struct netdev_dev netdev_dev;
331 struct shash_node *shash_node;
332 unsigned int cache_valid;
334 /* The following are figured out "on demand" only. They are only valid
335 * when the corresponding VALID_* bit in 'cache_valid' is set. */
337 uint8_t etheraddr[ETH_ADDR_LEN];
338 struct in_addr address, netmask;
342 bool is_internal; /* Is this an openvswitch internal device? */
343 bool is_tap; /* Is this a tuntap device? */
344 uint32_t kbits_rate; /* Policing data. */
345 uint32_t kbits_burst;
346 bool have_vport_stats;
350 struct tap_state tap;
354 struct netdev_linux {
355 struct netdev netdev;
359 /* An AF_INET socket (used for ioctl operations). */
360 static int af_inet_sock = -1;
362 /* A Netlink routing socket that is not subscribed to any multicast groups. */
363 static struct nl_sock *rtnl_sock;
365 struct netdev_linux_notifier {
366 struct netdev_notifier notifier;
370 static struct shash netdev_linux_notifiers =
371 SHASH_INITIALIZER(&netdev_linux_notifiers);
372 static struct rtnetlink_notifier netdev_linux_poll_notifier;
374 /* This is set pretty low because we probably won't learn anything from the
375 * additional log messages. */
376 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
378 static int netdev_linux_init(void);
380 static int netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *,
381 int cmd, const char *cmd_name);
382 static int netdev_linux_do_ioctl(const char *name, struct ifreq *, int cmd,
383 const char *cmd_name);
384 static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
385 int cmd, const char *cmd_name);
386 static int get_flags(const struct netdev *, int *flagsp);
387 static int set_flags(struct netdev *, int flags);
388 static int do_get_ifindex(const char *netdev_name);
389 static int get_ifindex(const struct netdev *, int *ifindexp);
390 static int do_set_addr(struct netdev *netdev,
391 int ioctl_nr, const char *ioctl_name,
392 struct in_addr addr);
393 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
394 static int set_etheraddr(const char *netdev_name, int hwaddr_family,
395 const uint8_t[ETH_ADDR_LEN]);
396 static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats);
397 static int get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats);
400 is_netdev_linux_class(const struct netdev_class *netdev_class)
402 return netdev_class->init == netdev_linux_init;
405 static struct netdev_dev_linux *
406 netdev_dev_linux_cast(const struct netdev_dev *netdev_dev)
408 const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev);
409 assert(is_netdev_linux_class(netdev_class));
411 return CONTAINER_OF(netdev_dev, struct netdev_dev_linux, netdev_dev);
414 static struct netdev_linux *
415 netdev_linux_cast(const struct netdev *netdev)
417 struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
418 const struct netdev_class *netdev_class = netdev_dev_get_class(netdev_dev);
419 assert(is_netdev_linux_class(netdev_class));
421 return CONTAINER_OF(netdev, struct netdev_linux, netdev);
425 netdev_linux_init(void)
427 static int status = -1;
429 /* Create AF_INET socket. */
430 af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
431 status = af_inet_sock >= 0 ? 0 : errno;
433 VLOG_ERR("failed to create inet socket: %s", strerror(status));
436 /* Create rtnetlink socket. */
438 status = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock);
440 VLOG_ERR_RL(&rl, "failed to create rtnetlink socket: %s",
449 netdev_linux_run(void)
451 rtnetlink_notifier_run();
455 netdev_linux_wait(void)
457 rtnetlink_notifier_wait();
461 netdev_linux_cache_cb(const struct rtnetlink_change *change,
462 void *aux OVS_UNUSED)
464 struct netdev_dev_linux *dev;
466 struct netdev_dev *base_dev = netdev_dev_from_name(change->ifname);
468 const struct netdev_class *netdev_class =
469 netdev_dev_get_class(base_dev);
471 if (is_netdev_linux_class(netdev_class)) {
472 dev = netdev_dev_linux_cast(base_dev);
473 dev->cache_valid = 0;
477 struct shash device_shash;
478 struct shash_node *node;
480 shash_init(&device_shash);
481 netdev_dev_get_devices(&netdev_linux_class, &device_shash);
482 SHASH_FOR_EACH (node, &device_shash) {
484 dev->cache_valid = 0;
486 shash_destroy(&device_shash);
490 /* Creates the netdev device of 'type' with 'name'. */
492 netdev_linux_create_system(const struct netdev_class *class OVS_UNUSED,
493 const char *name, const struct shash *args,
494 struct netdev_dev **netdev_devp)
496 struct netdev_dev_linux *netdev_dev;
499 if (!shash_is_empty(args)) {
500 VLOG_WARN("%s: arguments for system devices should be empty", name);
503 if (!cache_notifier_refcount) {
504 error = rtnetlink_notifier_register(&netdev_linux_cache_notifier,
505 netdev_linux_cache_cb, NULL);
510 cache_notifier_refcount++;
512 netdev_dev = xzalloc(sizeof *netdev_dev);
513 netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_linux_class);
515 *netdev_devp = &netdev_dev->netdev_dev;
519 /* For most types of netdevs we open the device for each call of
520 * netdev_open(). However, this is not the case with tap devices,
521 * since it is only possible to open the device once. In this
522 * situation we share a single file descriptor, and consequently
523 * buffers, across all readers. Therefore once data is read it will
524 * be unavailable to other reads for tap devices. */
526 netdev_linux_create_tap(const struct netdev_class *class OVS_UNUSED,
527 const char *name, const struct shash *args,
528 struct netdev_dev **netdev_devp)
530 struct netdev_dev_linux *netdev_dev;
531 struct tap_state *state;
532 static const char tap_dev[] = "/dev/net/tun";
536 if (!shash_is_empty(args)) {
537 VLOG_WARN("%s: arguments for TAP devices should be empty", name);
540 netdev_dev = xzalloc(sizeof *netdev_dev);
541 state = &netdev_dev->state.tap;
543 /* Open tap device. */
544 state->fd = open(tap_dev, O_RDWR);
547 VLOG_WARN("opening \"%s\" failed: %s", tap_dev, strerror(error));
551 /* Create tap device. */
552 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
553 strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
554 if (ioctl(state->fd, TUNSETIFF, &ifr) == -1) {
555 VLOG_WARN("%s: creating tap device failed: %s", name,
561 /* Make non-blocking. */
562 error = set_nonblocking(state->fd);
567 netdev_dev_init(&netdev_dev->netdev_dev, name, &netdev_tap_class);
568 *netdev_devp = &netdev_dev->netdev_dev;
577 destroy_tap(struct netdev_dev_linux *netdev_dev)
579 struct tap_state *state = &netdev_dev->state.tap;
581 if (state->fd >= 0) {
586 /* Destroys the netdev device 'netdev_dev_'. */
588 netdev_linux_destroy(struct netdev_dev *netdev_dev_)
590 struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_);
591 const char *type = netdev_dev_get_type(netdev_dev_);
593 if (netdev_dev->tc && netdev_dev->tc->ops->tc_destroy) {
594 netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
597 if (!strcmp(type, "system")) {
598 cache_notifier_refcount--;
600 if (!cache_notifier_refcount) {
601 rtnetlink_notifier_unregister(&netdev_linux_cache_notifier);
603 } else if (!strcmp(type, "tap")) {
604 destroy_tap(netdev_dev);
611 netdev_linux_open(struct netdev_dev *netdev_dev_, int ethertype,
612 struct netdev **netdevp)
614 struct netdev_dev_linux *netdev_dev = netdev_dev_linux_cast(netdev_dev_);
615 struct netdev_linux *netdev;
616 enum netdev_flags flags;
619 /* Allocate network device. */
620 netdev = xzalloc(sizeof *netdev);
622 netdev_init(&netdev->netdev, netdev_dev_);
624 error = netdev_get_flags(&netdev->netdev, &flags);
625 if (error == ENODEV) {
629 if (!strcmp(netdev_dev_get_type(netdev_dev_), "tap") &&
630 !netdev_dev->state.tap.opened) {
632 /* We assume that the first user of the tap device is the primary user
633 * and give them the tap FD. Subsequent users probably just expect
634 * this to be a system device so open it normally to avoid send/receive
635 * directions appearing to be reversed. */
636 netdev->fd = netdev_dev->state.tap.fd;
637 netdev_dev->state.tap.opened = true;
638 } else if (ethertype != NETDEV_ETH_TYPE_NONE) {
639 struct sockaddr_ll sll;
643 /* Create file descriptor. */
644 protocol = (ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL
645 : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2
647 netdev->fd = socket(PF_PACKET, SOCK_RAW, htons(protocol));
648 if (netdev->fd < 0) {
653 /* Set non-blocking mode. */
654 error = set_nonblocking(netdev->fd);
659 /* Get ethernet device index. */
660 error = get_ifindex(&netdev->netdev, &ifindex);
665 /* Bind to specific ethernet device. */
666 memset(&sll, 0, sizeof sll);
667 sll.sll_family = AF_PACKET;
668 sll.sll_ifindex = ifindex;
670 (struct sockaddr *) &sll, sizeof sll) < 0) {
672 VLOG_ERR("bind to %s failed: %s", netdev_dev_get_name(netdev_dev_),
677 /* Between the socket() and bind() calls above, the socket receives all
678 * packets of the requested type on all system interfaces. We do not
679 * want to receive that data, but there is no way to avoid it. So we
680 * must now drain out the receive queue. */
681 error = drain_rcvbuf(netdev->fd);
687 *netdevp = &netdev->netdev;
691 netdev_uninit(&netdev->netdev, true);
695 /* Closes and destroys 'netdev'. */
697 netdev_linux_close(struct netdev *netdev_)
699 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
701 if (netdev->fd > 0 && strcmp(netdev_get_type(netdev_), "tap")) {
707 /* Initializes 'svec' with a list of the names of all known network devices. */
709 netdev_linux_enumerate(struct svec *svec)
711 struct if_nameindex *names;
713 names = if_nameindex();
717 for (i = 0; names[i].if_name != NULL; i++) {
718 svec_add(svec, names[i].if_name);
720 if_freenameindex(names);
723 VLOG_WARN("could not obtain list of network device names: %s",
730 netdev_linux_recv(struct netdev *netdev_, void *data, size_t size)
732 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
734 if (netdev->fd < 0) {
735 /* Device was opened with NETDEV_ETH_TYPE_NONE. */
740 ssize_t retval = read(netdev->fd, data, size);
743 } else if (errno != EINTR) {
744 if (errno != EAGAIN) {
745 VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
746 strerror(errno), netdev_get_name(netdev_));
753 /* Registers with the poll loop to wake up from the next call to poll_block()
754 * when a packet is ready to be received with netdev_recv() on 'netdev'. */
756 netdev_linux_recv_wait(struct netdev *netdev_)
758 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
759 if (netdev->fd >= 0) {
760 poll_fd_wait(netdev->fd, POLLIN);
764 /* Discards all packets waiting to be received from 'netdev'. */
766 netdev_linux_drain(struct netdev *netdev_)
768 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
769 if (netdev->fd < 0) {
771 } else if (!strcmp(netdev_get_type(netdev_), "tap")) {
773 int error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
774 SIOCGIFTXQLEN, "SIOCGIFTXQLEN");
778 drain_fd(netdev->fd, ifr.ifr_qlen);
781 return drain_rcvbuf(netdev->fd);
785 /* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive
786 * errno value. Returns EAGAIN without blocking if the packet cannot be queued
787 * immediately. Returns EMSGSIZE if a partial packet was transmitted or if
788 * the packet is too big or too small to transmit on the device.
790 * The caller retains ownership of 'buffer' in all cases.
792 * The kernel maintains a packet transmission queue, so the caller is not
793 * expected to do additional queuing of packets. */
795 netdev_linux_send(struct netdev *netdev_, const void *data, size_t size)
797 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
799 /* XXX should support sending even if 'ethertype' was NETDEV_ETH_TYPE_NONE.
801 if (netdev->fd < 0) {
806 ssize_t retval = write(netdev->fd, data, size);
808 /* The Linux AF_PACKET implementation never blocks waiting for room
809 * for packets, instead returning ENOBUFS. Translate this into
810 * EAGAIN for the caller. */
811 if (errno == ENOBUFS) {
813 } else if (errno == EINTR) {
815 } else if (errno != EAGAIN) {
816 VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
817 netdev_get_name(netdev_), strerror(errno));
820 } else if (retval != size) {
821 VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of "
822 "%zu) on %s", retval, size, netdev_get_name(netdev_));
830 /* Registers with the poll loop to wake up from the next call to poll_block()
831 * when the packet transmission queue has sufficient room to transmit a packet
832 * with netdev_send().
834 * The kernel maintains a packet transmission queue, so the client is not
835 * expected to do additional queuing of packets. Thus, this function is
836 * unlikely to ever be used. It is included for completeness. */
838 netdev_linux_send_wait(struct netdev *netdev_)
840 struct netdev_linux *netdev = netdev_linux_cast(netdev_);
841 if (netdev->fd < 0) {
843 } else if (strcmp(netdev_get_type(netdev_), "tap")) {
844 poll_fd_wait(netdev->fd, POLLOUT);
846 /* TAP device always accepts packets.*/
847 poll_immediate_wake();
851 /* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
852 * otherwise a positive errno value. */
854 netdev_linux_set_etheraddr(struct netdev *netdev_,
855 const uint8_t mac[ETH_ADDR_LEN])
857 struct netdev_dev_linux *netdev_dev =
858 netdev_dev_linux_cast(netdev_get_dev(netdev_));
861 if (!(netdev_dev->cache_valid & VALID_ETHERADDR)
862 || !eth_addr_equals(netdev_dev->etheraddr, mac)) {
863 error = set_etheraddr(netdev_get_name(netdev_), ARPHRD_ETHER, mac);
865 netdev_dev->cache_valid |= VALID_ETHERADDR;
866 memcpy(netdev_dev->etheraddr, mac, ETH_ADDR_LEN);
874 /* Returns a pointer to 'netdev''s MAC address. The caller must not modify or
875 * free the returned buffer. */
877 netdev_linux_get_etheraddr(const struct netdev *netdev_,
878 uint8_t mac[ETH_ADDR_LEN])
880 struct netdev_dev_linux *netdev_dev =
881 netdev_dev_linux_cast(netdev_get_dev(netdev_));
882 if (!(netdev_dev->cache_valid & VALID_ETHERADDR)) {
883 int error = get_etheraddr(netdev_get_name(netdev_),
884 netdev_dev->etheraddr);
888 netdev_dev->cache_valid |= VALID_ETHERADDR;
890 memcpy(mac, netdev_dev->etheraddr, ETH_ADDR_LEN);
894 /* Returns the maximum size of transmitted (and received) packets on 'netdev',
895 * in bytes, not including the hardware header; thus, this is typically 1500
896 * bytes for Ethernet devices. */
898 netdev_linux_get_mtu(const struct netdev *netdev_, int *mtup)
900 struct netdev_dev_linux *netdev_dev =
901 netdev_dev_linux_cast(netdev_get_dev(netdev_));
902 if (!(netdev_dev->cache_valid & VALID_MTU)) {
906 error = netdev_linux_do_ioctl(netdev_get_name(netdev_), &ifr,
907 SIOCGIFMTU, "SIOCGIFMTU");
911 netdev_dev->mtu = ifr.ifr_mtu;
912 netdev_dev->cache_valid |= VALID_MTU;
914 *mtup = netdev_dev->mtu;
918 /* Returns the ifindex of 'netdev', if successful, as a positive number.
919 * On failure, returns a negative errno value. */
921 netdev_linux_get_ifindex(const struct netdev *netdev)
925 error = get_ifindex(netdev, &ifindex);
926 return error ? -error : ifindex;
930 netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier)
932 struct netdev_dev_linux *netdev_dev =
933 netdev_dev_linux_cast(netdev_get_dev(netdev_));
938 if (!(netdev_dev->cache_valid & VALID_CARRIER)) {
942 fn = xasprintf("/sys/class/net/%s/carrier",
943 netdev_get_name(netdev_));
944 fd = open(fn, O_RDONLY);
947 VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(error));
951 retval = read(fd, line, sizeof line);
954 if (error == EINVAL) {
955 /* This is the normal return value when we try to check carrier
956 * if the network device is not up. */
958 VLOG_WARN_RL(&rl, "%s: read failed: %s", fn, strerror(error));
961 } else if (retval == 0) {
963 VLOG_WARN_RL(&rl, "%s: unexpected end of file", fn);
967 if (line[0] != '0' && line[0] != '1') {
969 VLOG_WARN_RL(&rl, "%s: value is %c (expected 0 or 1)",
973 netdev_dev->carrier = line[0] != '0';
974 netdev_dev->cache_valid |= VALID_CARRIER;
976 *carrier = netdev_dev->carrier;
987 /* Check whether we can we use RTM_GETLINK to get network device statistics.
988 * In pre-2.6.19 kernels, this was only available if wireless extensions were
991 check_for_working_netlink_stats(void)
993 /* Decide on the netdev_get_stats() implementation to use. Netlink is
994 * preferable, so if that works, we'll use it. */
995 int ifindex = do_get_ifindex("lo");
997 VLOG_WARN("failed to get ifindex for lo, "
998 "obtaining netdev stats from proc");
1001 struct netdev_stats stats;
1002 int error = get_stats_via_netlink(ifindex, &stats);
1004 VLOG_DBG("obtaining netdev stats via rtnetlink");
1007 VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats "
1008 "via proc (you are probably running a pre-2.6.19 "
1009 "kernel)", strerror(error));
1015 /* Brings the 'is_internal' and 'is_tap' members of 'netdev_dev' up-to-date. */
1017 netdev_linux_update_is_pseudo(struct netdev_dev_linux *netdev_dev)
1019 if (!(netdev_dev->cache_valid & VALID_IS_PSEUDO)) {
1020 const char *name = netdev_dev_get_name(&netdev_dev->netdev_dev);
1021 const char *type = netdev_dev_get_type(&netdev_dev->netdev_dev);
1023 netdev_dev->is_tap = !strcmp(type, "tap");
1024 netdev_dev->is_internal = false;
1025 if (!netdev_dev->is_tap) {
1026 struct ethtool_drvinfo drvinfo;
1029 memset(&drvinfo, 0, sizeof drvinfo);
1030 error = netdev_linux_do_ethtool(name,
1031 (struct ethtool_cmd *)&drvinfo,
1033 "ETHTOOL_GDRVINFO");
1035 if (!error && !strcmp(drvinfo.driver, "openvswitch")) {
1036 netdev_dev->is_internal = true;
1040 netdev_dev->cache_valid |= VALID_IS_PSEUDO;
1045 swap_uint64(uint64_t *a, uint64_t *b)
1052 /* Retrieves current device stats for 'netdev'. */
1054 netdev_linux_get_stats(const struct netdev *netdev_,
1055 struct netdev_stats *stats)
1057 struct netdev_dev_linux *netdev_dev =
1058 netdev_dev_linux_cast(netdev_get_dev(netdev_));
1059 static int use_netlink_stats = -1;
1062 if (netdev_dev->have_vport_stats ||
1063 !(netdev_dev->cache_valid & VALID_HAVE_VPORT_STATS)) {
1065 error = netdev_vport_get_stats(netdev_, stats);
1066 netdev_dev->have_vport_stats = !error;
1067 netdev_dev->cache_valid |= VALID_HAVE_VPORT_STATS;
1070 if (!netdev_dev->have_vport_stats) {
1071 if (use_netlink_stats < 0) {
1072 use_netlink_stats = check_for_working_netlink_stats();
1074 if (use_netlink_stats) {
1077 error = get_ifindex(netdev_, &ifindex);
1079 error = get_stats_via_netlink(ifindex, stats);
1082 error = get_stats_via_proc(netdev_get_name(netdev_), stats);
1086 /* If this port is an internal port then the transmit and receive stats
1087 * will appear to be swapped relative to the other ports since we are the
1088 * one sending the data, not a remote computer. For consistency, we swap
1089 * them back here. This does not apply if we are getting stats from the
1090 * vport layer because it always tracks stats from the perspective of the
1092 netdev_linux_update_is_pseudo(netdev_dev);
1093 if (!error && !netdev_dev->have_vport_stats &&
1094 (netdev_dev->is_internal || netdev_dev->is_tap)) {
1095 swap_uint64(&stats->rx_packets, &stats->tx_packets);
1096 swap_uint64(&stats->rx_bytes, &stats->tx_bytes);
1097 swap_uint64(&stats->rx_errors, &stats->tx_errors);
1098 swap_uint64(&stats->rx_dropped, &stats->tx_dropped);
1099 stats->rx_length_errors = 0;
1100 stats->rx_over_errors = 0;
1101 stats->rx_crc_errors = 0;
1102 stats->rx_frame_errors = 0;
1103 stats->rx_fifo_errors = 0;
1104 stats->rx_missed_errors = 0;
1105 stats->tx_aborted_errors = 0;
1106 stats->tx_carrier_errors = 0;
1107 stats->tx_fifo_errors = 0;
1108 stats->tx_heartbeat_errors = 0;
1109 stats->tx_window_errors = 0;
1115 /* Stores the features supported by 'netdev' into each of '*current',
1116 * '*advertised', '*supported', and '*peer' that are non-null. Each value is a
1117 * bitmap of "enum ofp_port_features" bits, in host byte order. Returns 0 if
1118 * successful, otherwise a positive errno value. */
1120 netdev_linux_get_features(struct netdev *netdev,
1121 uint32_t *current, uint32_t *advertised,
1122 uint32_t *supported, uint32_t *peer)
1124 struct ethtool_cmd ecmd;
1127 memset(&ecmd, 0, sizeof ecmd);
1128 error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1129 ETHTOOL_GSET, "ETHTOOL_GSET");
1134 /* Supported features. */
1136 if (ecmd.supported & SUPPORTED_10baseT_Half) {
1137 *supported |= OFPPF_10MB_HD;
1139 if (ecmd.supported & SUPPORTED_10baseT_Full) {
1140 *supported |= OFPPF_10MB_FD;
1142 if (ecmd.supported & SUPPORTED_100baseT_Half) {
1143 *supported |= OFPPF_100MB_HD;
1145 if (ecmd.supported & SUPPORTED_100baseT_Full) {
1146 *supported |= OFPPF_100MB_FD;
1148 if (ecmd.supported & SUPPORTED_1000baseT_Half) {
1149 *supported |= OFPPF_1GB_HD;
1151 if (ecmd.supported & SUPPORTED_1000baseT_Full) {
1152 *supported |= OFPPF_1GB_FD;
1154 if (ecmd.supported & SUPPORTED_10000baseT_Full) {
1155 *supported |= OFPPF_10GB_FD;
1157 if (ecmd.supported & SUPPORTED_TP) {
1158 *supported |= OFPPF_COPPER;
1160 if (ecmd.supported & SUPPORTED_FIBRE) {
1161 *supported |= OFPPF_FIBER;
1163 if (ecmd.supported & SUPPORTED_Autoneg) {
1164 *supported |= OFPPF_AUTONEG;
1166 if (ecmd.supported & SUPPORTED_Pause) {
1167 *supported |= OFPPF_PAUSE;
1169 if (ecmd.supported & SUPPORTED_Asym_Pause) {
1170 *supported |= OFPPF_PAUSE_ASYM;
1173 /* Advertised features. */
1175 if (ecmd.advertising & ADVERTISED_10baseT_Half) {
1176 *advertised |= OFPPF_10MB_HD;
1178 if (ecmd.advertising & ADVERTISED_10baseT_Full) {
1179 *advertised |= OFPPF_10MB_FD;
1181 if (ecmd.advertising & ADVERTISED_100baseT_Half) {
1182 *advertised |= OFPPF_100MB_HD;
1184 if (ecmd.advertising & ADVERTISED_100baseT_Full) {
1185 *advertised |= OFPPF_100MB_FD;
1187 if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
1188 *advertised |= OFPPF_1GB_HD;
1190 if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
1191 *advertised |= OFPPF_1GB_FD;
1193 if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
1194 *advertised |= OFPPF_10GB_FD;
1196 if (ecmd.advertising & ADVERTISED_TP) {
1197 *advertised |= OFPPF_COPPER;
1199 if (ecmd.advertising & ADVERTISED_FIBRE) {
1200 *advertised |= OFPPF_FIBER;
1202 if (ecmd.advertising & ADVERTISED_Autoneg) {
1203 *advertised |= OFPPF_AUTONEG;
1205 if (ecmd.advertising & ADVERTISED_Pause) {
1206 *advertised |= OFPPF_PAUSE;
1208 if (ecmd.advertising & ADVERTISED_Asym_Pause) {
1209 *advertised |= OFPPF_PAUSE_ASYM;
1212 /* Current settings. */
1213 if (ecmd.speed == SPEED_10) {
1214 *current = ecmd.duplex ? OFPPF_10MB_FD : OFPPF_10MB_HD;
1215 } else if (ecmd.speed == SPEED_100) {
1216 *current = ecmd.duplex ? OFPPF_100MB_FD : OFPPF_100MB_HD;
1217 } else if (ecmd.speed == SPEED_1000) {
1218 *current = ecmd.duplex ? OFPPF_1GB_FD : OFPPF_1GB_HD;
1219 } else if (ecmd.speed == SPEED_10000) {
1220 *current = OFPPF_10GB_FD;
1225 if (ecmd.port == PORT_TP) {
1226 *current |= OFPPF_COPPER;
1227 } else if (ecmd.port == PORT_FIBRE) {
1228 *current |= OFPPF_FIBER;
1232 *current |= OFPPF_AUTONEG;
1235 /* Peer advertisements. */
1236 *peer = 0; /* XXX */
1241 /* Set the features advertised by 'netdev' to 'advertise'. */
1243 netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise)
1245 struct ethtool_cmd ecmd;
1248 memset(&ecmd, 0, sizeof ecmd);
1249 error = netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1250 ETHTOOL_GSET, "ETHTOOL_GSET");
1255 ecmd.advertising = 0;
1256 if (advertise & OFPPF_10MB_HD) {
1257 ecmd.advertising |= ADVERTISED_10baseT_Half;
1259 if (advertise & OFPPF_10MB_FD) {
1260 ecmd.advertising |= ADVERTISED_10baseT_Full;
1262 if (advertise & OFPPF_100MB_HD) {
1263 ecmd.advertising |= ADVERTISED_100baseT_Half;
1265 if (advertise & OFPPF_100MB_FD) {
1266 ecmd.advertising |= ADVERTISED_100baseT_Full;
1268 if (advertise & OFPPF_1GB_HD) {
1269 ecmd.advertising |= ADVERTISED_1000baseT_Half;
1271 if (advertise & OFPPF_1GB_FD) {
1272 ecmd.advertising |= ADVERTISED_1000baseT_Full;
1274 if (advertise & OFPPF_10GB_FD) {
1275 ecmd.advertising |= ADVERTISED_10000baseT_Full;
1277 if (advertise & OFPPF_COPPER) {
1278 ecmd.advertising |= ADVERTISED_TP;
1280 if (advertise & OFPPF_FIBER) {
1281 ecmd.advertising |= ADVERTISED_FIBRE;
1283 if (advertise & OFPPF_AUTONEG) {
1284 ecmd.advertising |= ADVERTISED_Autoneg;
1286 if (advertise & OFPPF_PAUSE) {
1287 ecmd.advertising |= ADVERTISED_Pause;
1289 if (advertise & OFPPF_PAUSE_ASYM) {
1290 ecmd.advertising |= ADVERTISED_Asym_Pause;
1292 return netdev_linux_do_ethtool(netdev_get_name(netdev), &ecmd,
1293 ETHTOOL_SSET, "ETHTOOL_SSET");
1296 /* If 'netdev_name' is the name of a VLAN network device (e.g. one created with
1297 * vconfig(8)), sets '*vlan_vid' to the VLAN VID associated with that device
1298 * and returns 0. Otherwise returns a errno value (specifically ENOENT if
1299 * 'netdev_name' is the name of a network device that is not a VLAN device) and
1300 * sets '*vlan_vid' to -1. */
1302 netdev_linux_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
1304 const char *netdev_name = netdev_get_name(netdev);
1305 struct ds line = DS_EMPTY_INITIALIZER;
1306 FILE *stream = NULL;
1310 COVERAGE_INC(netdev_get_vlan_vid);
1311 fn = xasprintf("/proc/net/vlan/%s", netdev_name);
1312 stream = fopen(fn, "r");
1318 if (ds_get_line(&line, stream)) {
1319 if (ferror(stream)) {
1321 VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno));
1324 VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn);
1329 if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) {
1331 VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"",
1332 fn, ds_cstr(&line));
1350 #define POLICE_ADD_CMD "/sbin/tc qdisc add dev %s handle ffff: ingress"
1351 #define POLICE_CONFIG_CMD "/sbin/tc filter add dev %s parent ffff: protocol ip prio 50 u32 match ip src 0.0.0.0/0 police rate %dkbit burst %dk mtu 65535 drop flowid :1"
1353 /* Remove ingress policing from 'netdev'. Returns 0 if successful, otherwise a
1354 * positive errno value.
1356 * This function is equivalent to running
1357 * /sbin/tc qdisc del dev %s handle ffff: ingress
1358 * but it is much, much faster.
1361 netdev_linux_remove_policing(struct netdev *netdev)
1363 struct netdev_dev_linux *netdev_dev =
1364 netdev_dev_linux_cast(netdev_get_dev(netdev));
1365 const char *netdev_name = netdev_get_name(netdev);
1367 struct ofpbuf request;
1368 struct tcmsg *tcmsg;
1371 tcmsg = tc_make_request(netdev, RTM_DELQDISC, 0, &request);
1375 tcmsg->tcm_handle = tc_make_handle(0xffff, 0);
1376 tcmsg->tcm_parent = TC_H_INGRESS;
1377 nl_msg_put_string(&request, TCA_KIND, "ingress");
1378 nl_msg_put_unspec(&request, TCA_OPTIONS, NULL, 0);
1380 error = tc_transact(&request, NULL);
1381 if (error && error != ENOENT && error != EINVAL) {
1382 VLOG_WARN_RL(&rl, "%s: removing policing failed: %s",
1383 netdev_name, strerror(error));
1387 netdev_dev->kbits_rate = 0;
1388 netdev_dev->kbits_burst = 0;
1389 netdev_dev->cache_valid |= VALID_POLICING;
1393 /* Attempts to set input rate limiting (policing) policy. */
1395 netdev_linux_set_policing(struct netdev *netdev,
1396 uint32_t kbits_rate, uint32_t kbits_burst)
1398 struct netdev_dev_linux *netdev_dev =
1399 netdev_dev_linux_cast(netdev_get_dev(netdev));
1400 const char *netdev_name = netdev_get_name(netdev);
1403 COVERAGE_INC(netdev_set_policing);
1405 kbits_burst = (!kbits_rate ? 0 /* Force to 0 if no rate specified. */
1406 : !kbits_burst ? 1000 /* Default to 1000 kbits if 0. */
1407 : kbits_burst); /* Stick with user-specified value. */
1409 if (netdev_dev->cache_valid & VALID_POLICING
1410 && netdev_dev->kbits_rate == kbits_rate
1411 && netdev_dev->kbits_burst == kbits_burst) {
1412 /* Assume that settings haven't changed since we last set them. */
1416 netdev_linux_remove_policing(netdev);
1418 snprintf(command, sizeof(command), POLICE_ADD_CMD, netdev_name);
1419 if (system(command) != 0) {
1420 VLOG_WARN_RL(&rl, "%s: problem adding policing", netdev_name);
1424 snprintf(command, sizeof(command), POLICE_CONFIG_CMD, netdev_name,
1425 kbits_rate, kbits_burst);
1426 if (system(command) != 0) {
1427 VLOG_WARN_RL(&rl, "%s: problem configuring policing",
1432 netdev_dev->kbits_rate = kbits_rate;
1433 netdev_dev->kbits_burst = kbits_burst;
1434 netdev_dev->cache_valid |= VALID_POLICING;
1441 netdev_linux_get_qos_types(const struct netdev *netdev OVS_UNUSED,
1444 const struct tc_ops **opsp;
1446 for (opsp = tcs; *opsp != NULL; opsp++) {
1447 const struct tc_ops *ops = *opsp;
1448 if (ops->tc_install && ops->ovs_name[0] != '\0') {
1449 svec_add(types, ops->ovs_name);
1455 static const struct tc_ops *
1456 tc_lookup_ovs_name(const char *name)
1458 const struct tc_ops **opsp;
1460 for (opsp = tcs; *opsp != NULL; opsp++) {
1461 const struct tc_ops *ops = *opsp;
1462 if (!strcmp(name, ops->ovs_name)) {
1469 static const struct tc_ops *
1470 tc_lookup_linux_name(const char *name)
1472 const struct tc_ops **opsp;
1474 for (opsp = tcs; *opsp != NULL; opsp++) {
1475 const struct tc_ops *ops = *opsp;
1476 if (ops->linux_name && !strcmp(name, ops->linux_name)) {
1483 static struct tc_queue *
1484 tc_find_queue__(const struct netdev *netdev, unsigned int queue_id,
1487 struct netdev_dev_linux *netdev_dev =
1488 netdev_dev_linux_cast(netdev_get_dev(netdev));
1489 struct tc_queue *queue;
1491 HMAP_FOR_EACH_IN_BUCKET (queue, hmap_node, hash, &netdev_dev->tc->queues) {
1492 if (queue->queue_id == queue_id) {
1499 static struct tc_queue *
1500 tc_find_queue(const struct netdev *netdev, unsigned int queue_id)
1502 return tc_find_queue__(netdev, queue_id, hash_int(queue_id, 0));
1506 netdev_linux_get_qos_capabilities(const struct netdev *netdev OVS_UNUSED,
1508 struct netdev_qos_capabilities *caps)
1510 const struct tc_ops *ops = tc_lookup_ovs_name(type);
1514 caps->n_queues = ops->n_queues;
1519 netdev_linux_get_qos(const struct netdev *netdev,
1520 const char **typep, struct shash *details)
1522 struct netdev_dev_linux *netdev_dev =
1523 netdev_dev_linux_cast(netdev_get_dev(netdev));
1526 error = tc_query_qdisc(netdev);
1531 *typep = netdev_dev->tc->ops->ovs_name;
1532 return (netdev_dev->tc->ops->qdisc_get
1533 ? netdev_dev->tc->ops->qdisc_get(netdev, details)
1538 netdev_linux_set_qos(struct netdev *netdev,
1539 const char *type, const struct shash *details)
1541 struct netdev_dev_linux *netdev_dev =
1542 netdev_dev_linux_cast(netdev_get_dev(netdev));
1543 const struct tc_ops *new_ops;
1546 new_ops = tc_lookup_ovs_name(type);
1547 if (!new_ops || !new_ops->tc_install) {
1551 error = tc_query_qdisc(netdev);
1556 if (new_ops == netdev_dev->tc->ops) {
1557 return new_ops->qdisc_set ? new_ops->qdisc_set(netdev, details) : 0;
1559 /* Delete existing qdisc. */
1560 error = tc_del_qdisc(netdev);
1564 assert(netdev_dev->tc == NULL);
1566 /* Install new qdisc. */
1567 error = new_ops->tc_install(netdev, details);
1568 assert((error == 0) == (netdev_dev->tc != NULL));
1575 netdev_linux_get_queue(const struct netdev *netdev,
1576 unsigned int queue_id, struct shash *details)
1578 struct netdev_dev_linux *netdev_dev =
1579 netdev_dev_linux_cast(netdev_get_dev(netdev));
1582 error = tc_query_qdisc(netdev);
1586 struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1588 ? netdev_dev->tc->ops->class_get(netdev, queue, details)
1594 netdev_linux_set_queue(struct netdev *netdev,
1595 unsigned int queue_id, const struct shash *details)
1597 struct netdev_dev_linux *netdev_dev =
1598 netdev_dev_linux_cast(netdev_get_dev(netdev));
1601 error = tc_query_qdisc(netdev);
1604 } else if (queue_id >= netdev_dev->tc->ops->n_queues
1605 || !netdev_dev->tc->ops->class_set) {
1609 return netdev_dev->tc->ops->class_set(netdev, queue_id, details);
1613 netdev_linux_delete_queue(struct netdev *netdev, unsigned int queue_id)
1615 struct netdev_dev_linux *netdev_dev =
1616 netdev_dev_linux_cast(netdev_get_dev(netdev));
1619 error = tc_query_qdisc(netdev);
1622 } else if (!netdev_dev->tc->ops->class_delete) {
1625 struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1627 ? netdev_dev->tc->ops->class_delete(netdev, queue)
1633 netdev_linux_get_queue_stats(const struct netdev *netdev,
1634 unsigned int queue_id,
1635 struct netdev_queue_stats *stats)
1637 struct netdev_dev_linux *netdev_dev =
1638 netdev_dev_linux_cast(netdev_get_dev(netdev));
1641 error = tc_query_qdisc(netdev);
1644 } else if (!netdev_dev->tc->ops->class_get_stats) {
1647 const struct tc_queue *queue = tc_find_queue(netdev, queue_id);
1649 ? netdev_dev->tc->ops->class_get_stats(netdev, queue, stats)
1655 start_queue_dump(const struct netdev *netdev, struct nl_dump *dump)
1657 struct ofpbuf request;
1658 struct tcmsg *tcmsg;
1660 tcmsg = tc_make_request(netdev, RTM_GETTCLASS, 0, &request);
1664 tcmsg->tcm_parent = 0;
1665 nl_dump_start(dump, rtnl_sock, &request);
1666 ofpbuf_uninit(&request);
1671 netdev_linux_dump_queues(const struct netdev *netdev,
1672 netdev_dump_queues_cb *cb, void *aux)
1674 struct netdev_dev_linux *netdev_dev =
1675 netdev_dev_linux_cast(netdev_get_dev(netdev));
1676 struct tc_queue *queue;
1677 struct shash details;
1681 error = tc_query_qdisc(netdev);
1684 } else if (!netdev_dev->tc->ops->class_get) {
1689 shash_init(&details);
1690 HMAP_FOR_EACH (queue, hmap_node, &netdev_dev->tc->queues) {
1691 shash_clear(&details);
1693 error = netdev_dev->tc->ops->class_get(netdev, queue, &details);
1695 (*cb)(queue->queue_id, &details, aux);
1700 shash_destroy(&details);
1706 netdev_linux_dump_queue_stats(const struct netdev *netdev,
1707 netdev_dump_queue_stats_cb *cb, void *aux)
1709 struct netdev_dev_linux *netdev_dev =
1710 netdev_dev_linux_cast(netdev_get_dev(netdev));
1711 struct nl_dump dump;
1716 error = tc_query_qdisc(netdev);
1719 } else if (!netdev_dev->tc->ops->class_dump_stats) {
1724 if (!start_queue_dump(netdev, &dump)) {
1727 while (nl_dump_next(&dump, &msg)) {
1728 error = netdev_dev->tc->ops->class_dump_stats(netdev, &msg, cb, aux);
1734 error = nl_dump_done(&dump);
1735 return error ? error : last_error;
1739 netdev_linux_get_in4(const struct netdev *netdev_,
1740 struct in_addr *address, struct in_addr *netmask)
1742 struct netdev_dev_linux *netdev_dev =
1743 netdev_dev_linux_cast(netdev_get_dev(netdev_));
1745 if (!(netdev_dev->cache_valid & VALID_IN4)) {
1748 error = netdev_linux_get_ipv4(netdev_, &netdev_dev->address,
1749 SIOCGIFADDR, "SIOCGIFADDR");
1754 error = netdev_linux_get_ipv4(netdev_, &netdev_dev->netmask,
1755 SIOCGIFNETMASK, "SIOCGIFNETMASK");
1760 netdev_dev->cache_valid |= VALID_IN4;
1762 *address = netdev_dev->address;
1763 *netmask = netdev_dev->netmask;
1764 return address->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
1768 netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address,
1769 struct in_addr netmask)
1771 struct netdev_dev_linux *netdev_dev =
1772 netdev_dev_linux_cast(netdev_get_dev(netdev_));
1775 error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address);
1777 netdev_dev->cache_valid |= VALID_IN4;
1778 netdev_dev->address = address;
1779 netdev_dev->netmask = netmask;
1780 if (address.s_addr != INADDR_ANY) {
1781 error = do_set_addr(netdev_, SIOCSIFNETMASK,
1782 "SIOCSIFNETMASK", netmask);
1789 parse_if_inet6_line(const char *line,
1790 struct in6_addr *in6, char ifname[16 + 1])
1792 uint8_t *s6 = in6->s6_addr;
1793 #define X8 "%2"SCNx8
1795 " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
1796 "%*x %*x %*x %*x %16s\n",
1797 &s6[0], &s6[1], &s6[2], &s6[3],
1798 &s6[4], &s6[5], &s6[6], &s6[7],
1799 &s6[8], &s6[9], &s6[10], &s6[11],
1800 &s6[12], &s6[13], &s6[14], &s6[15],
1804 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
1805 * 'in6' is non-null) and returns true. Otherwise, returns false. */
1807 netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
1809 struct netdev_dev_linux *netdev_dev =
1810 netdev_dev_linux_cast(netdev_get_dev(netdev_));
1811 if (!(netdev_dev->cache_valid & VALID_IN6)) {
1815 netdev_dev->in6 = in6addr_any;
1817 file = fopen("/proc/net/if_inet6", "r");
1819 const char *name = netdev_get_name(netdev_);
1820 while (fgets(line, sizeof line, file)) {
1821 struct in6_addr in6_tmp;
1822 char ifname[16 + 1];
1823 if (parse_if_inet6_line(line, &in6_tmp, ifname)
1824 && !strcmp(name, ifname))
1826 netdev_dev->in6 = in6_tmp;
1832 netdev_dev->cache_valid |= VALID_IN6;
1834 *in6 = netdev_dev->in6;
1839 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
1841 struct sockaddr_in sin;
1842 memset(&sin, 0, sizeof sin);
1843 sin.sin_family = AF_INET;
1844 sin.sin_addr = addr;
1847 memset(sa, 0, sizeof *sa);
1848 memcpy(sa, &sin, sizeof sin);
1852 do_set_addr(struct netdev *netdev,
1853 int ioctl_nr, const char *ioctl_name, struct in_addr addr)
1856 strncpy(ifr.ifr_name, netdev_get_name(netdev), sizeof ifr.ifr_name);
1857 make_in4_sockaddr(&ifr.ifr_addr, addr);
1859 return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, ioctl_nr,
1863 /* Adds 'router' as a default IP gateway. */
1865 netdev_linux_add_router(struct netdev *netdev OVS_UNUSED, struct in_addr router)
1867 struct in_addr any = { INADDR_ANY };
1871 memset(&rt, 0, sizeof rt);
1872 make_in4_sockaddr(&rt.rt_dst, any);
1873 make_in4_sockaddr(&rt.rt_gateway, router);
1874 make_in4_sockaddr(&rt.rt_genmask, any);
1875 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1876 error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
1878 VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error));
1884 netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
1887 static const char fn[] = "/proc/net/route";
1892 *netdev_name = NULL;
1893 stream = fopen(fn, "r");
1894 if (stream == NULL) {
1895 VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
1900 while (fgets(line, sizeof line, stream)) {
1903 uint32_t dest, gateway, mask;
1904 int refcnt, metric, mtu;
1905 unsigned int flags, use, window, irtt;
1908 "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
1910 iface, &dest, &gateway, &flags, &refcnt,
1911 &use, &metric, &mask, &mtu, &window, &irtt) != 11) {
1913 VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
1917 if (!(flags & RTF_UP)) {
1918 /* Skip routes that aren't up. */
1922 /* The output of 'dest', 'mask', and 'gateway' were given in
1923 * network byte order, so we don't need need any endian
1924 * conversions here. */
1925 if ((dest & mask) == (host->s_addr & mask)) {
1927 /* The host is directly reachable. */
1928 next_hop->s_addr = 0;
1930 /* To reach the host, we must go through a gateway. */
1931 next_hop->s_addr = gateway;
1933 *netdev_name = xstrdup(iface);
1944 /* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
1945 * successfully retrieved, it stores the corresponding MAC address in 'mac' and
1946 * returns 0. Otherwise, it returns a positive errno value; in particular,
1947 * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
1949 netdev_linux_arp_lookup(const struct netdev *netdev,
1950 uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
1953 struct sockaddr_in sin;
1956 memset(&r, 0, sizeof r);
1957 sin.sin_family = AF_INET;
1958 sin.sin_addr.s_addr = ip;
1960 memcpy(&r.arp_pa, &sin, sizeof sin);
1961 r.arp_ha.sa_family = ARPHRD_ETHER;
1963 strncpy(r.arp_dev, netdev_get_name(netdev), sizeof r.arp_dev);
1964 COVERAGE_INC(netdev_arp_lookup);
1965 retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
1967 memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
1968 } else if (retval != ENXIO) {
1969 VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
1970 netdev_get_name(netdev), IP_ARGS(&ip), strerror(retval));
1976 nd_to_iff_flags(enum netdev_flags nd)
1979 if (nd & NETDEV_UP) {
1982 if (nd & NETDEV_PROMISC) {
1989 iff_to_nd_flags(int iff)
1991 enum netdev_flags nd = 0;
1995 if (iff & IFF_PROMISC) {
1996 nd |= NETDEV_PROMISC;
2002 netdev_linux_update_flags(struct netdev *netdev, enum netdev_flags off,
2003 enum netdev_flags on, enum netdev_flags *old_flagsp)
2005 int old_flags, new_flags;
2008 error = get_flags(netdev, &old_flags);
2010 *old_flagsp = iff_to_nd_flags(old_flags);
2011 new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
2012 if (new_flags != old_flags) {
2013 error = set_flags(netdev, new_flags);
2020 poll_notify(struct list *list)
2022 struct netdev_linux_notifier *notifier;
2023 LIST_FOR_EACH (notifier, node, list) {
2024 struct netdev_notifier *n = ¬ifier->notifier;
2030 netdev_linux_poll_cb(const struct rtnetlink_change *change,
2031 void *aux OVS_UNUSED)
2034 struct list *list = shash_find_data(&netdev_linux_notifiers,
2040 struct shash_node *node;
2041 SHASH_FOR_EACH (node, &netdev_linux_notifiers) {
2042 poll_notify(node->data);
2048 netdev_linux_poll_add(struct netdev *netdev,
2049 void (*cb)(struct netdev_notifier *), void *aux,
2050 struct netdev_notifier **notifierp)
2052 const char *netdev_name = netdev_get_name(netdev);
2053 struct netdev_linux_notifier *notifier;
2056 if (shash_is_empty(&netdev_linux_notifiers)) {
2057 int error = rtnetlink_notifier_register(&netdev_linux_poll_notifier,
2058 netdev_linux_poll_cb, NULL);
2064 list = shash_find_data(&netdev_linux_notifiers, netdev_name);
2066 list = xmalloc(sizeof *list);
2068 shash_add(&netdev_linux_notifiers, netdev_name, list);
2071 notifier = xmalloc(sizeof *notifier);
2072 netdev_notifier_init(¬ifier->notifier, netdev, cb, aux);
2073 list_push_back(list, ¬ifier->node);
2074 *notifierp = ¬ifier->notifier;
2079 netdev_linux_poll_remove(struct netdev_notifier *notifier_)
2081 struct netdev_linux_notifier *notifier =
2082 CONTAINER_OF(notifier_, struct netdev_linux_notifier, notifier);
2085 /* Remove 'notifier' from its list. */
2086 list = list_remove(¬ifier->node);
2087 if (list_is_empty(list)) {
2088 /* The list is now empty. Remove it from the hash and free it. */
2089 const char *netdev_name = netdev_get_name(notifier->notifier.netdev);
2090 shash_delete(&netdev_linux_notifiers,
2091 shash_find(&netdev_linux_notifiers, netdev_name));
2096 /* If that was the last notifier, unregister. */
2097 if (shash_is_empty(&netdev_linux_notifiers)) {
2098 rtnetlink_notifier_unregister(&netdev_linux_poll_notifier);
2102 const struct netdev_class netdev_linux_class = {
2109 netdev_linux_create_system,
2110 netdev_linux_destroy,
2111 NULL, /* reconfigure */
2116 netdev_linux_enumerate,
2119 netdev_linux_recv_wait,
2123 netdev_linux_send_wait,
2125 netdev_linux_set_etheraddr,
2126 netdev_linux_get_etheraddr,
2127 netdev_linux_get_mtu,
2128 netdev_linux_get_ifindex,
2129 netdev_linux_get_carrier,
2130 netdev_linux_get_stats,
2131 netdev_vport_set_stats,
2133 netdev_linux_get_features,
2134 netdev_linux_set_advertisements,
2135 netdev_linux_get_vlan_vid,
2137 netdev_linux_set_policing,
2138 netdev_linux_get_qos_types,
2139 netdev_linux_get_qos_capabilities,
2140 netdev_linux_get_qos,
2141 netdev_linux_set_qos,
2142 netdev_linux_get_queue,
2143 netdev_linux_set_queue,
2144 netdev_linux_delete_queue,
2145 netdev_linux_get_queue_stats,
2146 netdev_linux_dump_queues,
2147 netdev_linux_dump_queue_stats,
2149 netdev_linux_get_in4,
2150 netdev_linux_set_in4,
2151 netdev_linux_get_in6,
2152 netdev_linux_add_router,
2153 netdev_linux_get_next_hop,
2154 netdev_linux_arp_lookup,
2156 netdev_linux_update_flags,
2158 netdev_linux_poll_add,
2159 netdev_linux_poll_remove,
2162 const struct netdev_class netdev_tap_class = {
2169 netdev_linux_create_tap,
2170 netdev_linux_destroy,
2171 NULL, /* reconfigure */
2176 NULL, /* enumerate */
2179 netdev_linux_recv_wait,
2183 netdev_linux_send_wait,
2185 netdev_linux_set_etheraddr,
2186 netdev_linux_get_etheraddr,
2187 netdev_linux_get_mtu,
2188 netdev_linux_get_ifindex,
2189 netdev_linux_get_carrier,
2190 netdev_linux_get_stats,
2191 NULL, /* set_stats */
2193 netdev_linux_get_features,
2194 netdev_linux_set_advertisements,
2195 netdev_linux_get_vlan_vid,
2197 netdev_linux_set_policing,
2198 netdev_linux_get_qos_types,
2199 netdev_linux_get_qos_capabilities,
2200 netdev_linux_get_qos,
2201 netdev_linux_set_qos,
2202 netdev_linux_get_queue,
2203 netdev_linux_set_queue,
2204 netdev_linux_delete_queue,
2205 netdev_linux_get_queue_stats,
2206 netdev_linux_dump_queues,
2207 netdev_linux_dump_queue_stats,
2209 netdev_linux_get_in4,
2210 netdev_linux_set_in4,
2211 netdev_linux_get_in6,
2212 netdev_linux_add_router,
2213 netdev_linux_get_next_hop,
2214 netdev_linux_arp_lookup,
2216 netdev_linux_update_flags,
2218 netdev_linux_poll_add,
2219 netdev_linux_poll_remove,
2222 /* HTB traffic control class. */
2224 #define HTB_N_QUEUES 0xf000
2228 unsigned int max_rate; /* In bytes/s. */
2232 struct tc_queue tc_queue;
2233 unsigned int min_rate; /* In bytes/s. */
2234 unsigned int max_rate; /* In bytes/s. */
2235 unsigned int burst; /* In bytes. */
2236 unsigned int priority; /* Lower values are higher priorities. */
2240 htb_get__(const struct netdev *netdev)
2242 struct netdev_dev_linux *netdev_dev =
2243 netdev_dev_linux_cast(netdev_get_dev(netdev));
2244 return CONTAINER_OF(netdev_dev->tc, struct htb, tc);
2248 htb_install__(struct netdev *netdev, uint64_t max_rate)
2250 struct netdev_dev_linux *netdev_dev =
2251 netdev_dev_linux_cast(netdev_get_dev(netdev));
2254 htb = xmalloc(sizeof *htb);
2255 tc_init(&htb->tc, &tc_ops_htb);
2256 htb->max_rate = max_rate;
2258 netdev_dev->tc = &htb->tc;
2263 /* Create an HTB qdisc.
2265 * Equivalent to "tc qdisc add dev <dev> root handle 1: htb default 1". */
2267 htb_setup_qdisc__(struct netdev *netdev)
2270 struct tc_htb_glob opt;
2271 struct ofpbuf request;
2272 struct tcmsg *tcmsg;
2274 tc_del_qdisc(netdev);
2276 tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2277 NLM_F_EXCL | NLM_F_CREATE, &request);
2281 tcmsg->tcm_handle = tc_make_handle(1, 0);
2282 tcmsg->tcm_parent = TC_H_ROOT;
2284 nl_msg_put_string(&request, TCA_KIND, "htb");
2286 memset(&opt, 0, sizeof opt);
2287 opt.rate2quantum = 10;
2291 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2292 nl_msg_put_unspec(&request, TCA_HTB_INIT, &opt, sizeof opt);
2293 nl_msg_end_nested(&request, opt_offset);
2295 return tc_transact(&request, NULL);
2298 /* Equivalent to "tc class replace <dev> classid <handle> parent <parent> htb
2299 * rate <min_rate>bps ceil <max_rate>bps burst <burst>b prio <priority>". */
2301 htb_setup_class__(struct netdev *netdev, unsigned int handle,
2302 unsigned int parent, struct htb_class *class)
2305 struct tc_htb_opt opt;
2306 struct ofpbuf request;
2307 struct tcmsg *tcmsg;
2311 netdev_get_mtu(netdev, &mtu);
2313 memset(&opt, 0, sizeof opt);
2314 tc_fill_rate(&opt.rate, class->min_rate, mtu);
2315 tc_fill_rate(&opt.ceil, class->max_rate, mtu);
2316 opt.buffer = tc_calc_buffer(opt.rate.rate, mtu, class->burst);
2317 opt.cbuffer = tc_calc_buffer(opt.ceil.rate, mtu, class->burst);
2318 opt.prio = class->priority;
2320 tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2324 tcmsg->tcm_handle = handle;
2325 tcmsg->tcm_parent = parent;
2327 nl_msg_put_string(&request, TCA_KIND, "htb");
2328 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2329 nl_msg_put_unspec(&request, TCA_HTB_PARMS, &opt, sizeof opt);
2330 tc_put_rtab(&request, TCA_HTB_RTAB, &opt.rate);
2331 tc_put_rtab(&request, TCA_HTB_CTAB, &opt.ceil);
2332 nl_msg_end_nested(&request, opt_offset);
2334 error = tc_transact(&request, NULL);
2336 VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
2337 "min_rate=%u max_rate=%u burst=%u prio=%u (%s)",
2338 netdev_get_name(netdev),
2339 tc_get_major(handle), tc_get_minor(handle),
2340 tc_get_major(parent), tc_get_minor(parent),
2341 class->min_rate, class->max_rate,
2342 class->burst, class->priority, strerror(error));
2347 /* Parses Netlink attributes in 'options' for HTB parameters and stores a
2348 * description of them into 'details'. The description complies with the
2349 * specification given in the vswitch database documentation for linux-htb
2352 htb_parse_tca_options__(struct nlattr *nl_options, struct htb_class *class)
2354 static const struct nl_policy tca_htb_policy[] = {
2355 [TCA_HTB_PARMS] = { .type = NL_A_UNSPEC, .optional = false,
2356 .min_len = sizeof(struct tc_htb_opt) },
2359 struct nlattr *attrs[ARRAY_SIZE(tca_htb_policy)];
2360 const struct tc_htb_opt *htb;
2362 if (!nl_parse_nested(nl_options, tca_htb_policy,
2363 attrs, ARRAY_SIZE(tca_htb_policy))) {
2364 VLOG_WARN_RL(&rl, "failed to parse HTB class options");
2368 htb = nl_attr_get(attrs[TCA_HTB_PARMS]);
2369 class->min_rate = htb->rate.rate;
2370 class->max_rate = htb->ceil.rate;
2371 class->burst = tc_ticks_to_bytes(htb->rate.rate, htb->buffer);
2372 class->priority = htb->prio;
2377 htb_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2378 struct htb_class *options,
2379 struct netdev_queue_stats *stats)
2381 struct nlattr *nl_options;
2382 unsigned int handle;
2385 error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2386 if (!error && queue_id) {
2387 unsigned int major = tc_get_major(handle);
2388 unsigned int minor = tc_get_minor(handle);
2389 if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2390 *queue_id = minor - 1;
2395 if (!error && options) {
2396 error = htb_parse_tca_options__(nl_options, options);
2402 htb_parse_qdisc_details__(struct netdev *netdev,
2403 const struct shash *details, struct htb_class *hc)
2405 const char *max_rate_s;
2407 max_rate_s = shash_find_data(details, "max-rate");
2408 hc->max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2409 if (!hc->max_rate) {
2412 netdev_get_features(netdev, ¤t, NULL, NULL, NULL);
2413 hc->max_rate = netdev_features_to_bps(current) / 8;
2415 hc->min_rate = hc->max_rate;
2421 htb_parse_class_details__(struct netdev *netdev,
2422 const struct shash *details, struct htb_class *hc)
2424 const struct htb *htb = htb_get__(netdev);
2425 const char *min_rate_s = shash_find_data(details, "min-rate");
2426 const char *max_rate_s = shash_find_data(details, "max-rate");
2427 const char *burst_s = shash_find_data(details, "burst");
2428 const char *priority_s = shash_find_data(details, "priority");
2431 /* min-rate. Don't allow a min-rate below 1500 bytes/s. */
2433 /* min-rate is required. */
2436 hc->min_rate = strtoull(min_rate_s, NULL, 10) / 8;
2437 hc->min_rate = MAX(hc->min_rate, 1500);
2438 hc->min_rate = MIN(hc->min_rate, htb->max_rate);
2441 hc->max_rate = (max_rate_s
2442 ? strtoull(max_rate_s, NULL, 10) / 8
2444 hc->max_rate = MAX(hc->max_rate, hc->min_rate);
2445 hc->max_rate = MIN(hc->max_rate, htb->max_rate);
2449 * According to hints in the documentation that I've read, it is important
2450 * that 'burst' be at least as big as the largest frame that might be
2451 * transmitted. Also, making 'burst' a bit bigger than necessary is OK,
2452 * but having it a bit too small is a problem. Since netdev_get_mtu()
2453 * doesn't include the Ethernet header, we need to add at least 14 (18?) to
2454 * the MTU. We actually add 64, instead of 14, as a guard against
2455 * additional headers get tacked on somewhere that we're not aware of. */
2456 netdev_get_mtu(netdev, &mtu);
2457 hc->burst = burst_s ? strtoull(burst_s, NULL, 10) / 8 : 0;
2458 hc->burst = MAX(hc->burst, mtu + 64);
2461 hc->priority = priority_s ? strtoul(priority_s, NULL, 10) : 0;
2467 htb_query_class__(const struct netdev *netdev, unsigned int handle,
2468 unsigned int parent, struct htb_class *options,
2469 struct netdev_queue_stats *stats)
2471 struct ofpbuf *reply;
2474 error = tc_query_class(netdev, handle, parent, &reply);
2476 error = htb_parse_tcmsg__(reply, NULL, options, stats);
2477 ofpbuf_delete(reply);
2483 htb_tc_install(struct netdev *netdev, const struct shash *details)
2487 error = htb_setup_qdisc__(netdev);
2489 struct htb_class hc;
2491 htb_parse_qdisc_details__(netdev, details, &hc);
2492 error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2493 tc_make_handle(1, 0), &hc);
2495 htb_install__(netdev, hc.max_rate);
2501 static struct htb_class *
2502 htb_class_cast__(const struct tc_queue *queue)
2504 return CONTAINER_OF(queue, struct htb_class, tc_queue);
2508 htb_update_queue__(struct netdev *netdev, unsigned int queue_id,
2509 const struct htb_class *hc)
2511 struct htb *htb = htb_get__(netdev);
2512 size_t hash = hash_int(queue_id, 0);
2513 struct tc_queue *queue;
2514 struct htb_class *hcp;
2516 queue = tc_find_queue__(netdev, queue_id, hash);
2518 hcp = htb_class_cast__(queue);
2520 hcp = xmalloc(sizeof *hcp);
2521 queue = &hcp->tc_queue;
2522 queue->queue_id = queue_id;
2523 hmap_insert(&htb->tc.queues, &queue->hmap_node, hash);
2526 hcp->min_rate = hc->min_rate;
2527 hcp->max_rate = hc->max_rate;
2528 hcp->burst = hc->burst;
2529 hcp->priority = hc->priority;
2533 htb_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
2536 struct nl_dump dump;
2537 struct htb_class hc;
2540 /* Get qdisc options. */
2542 htb_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
2543 htb = htb_install__(netdev, hc.max_rate);
2546 if (!start_queue_dump(netdev, &dump)) {
2549 while (nl_dump_next(&dump, &msg)) {
2550 unsigned int queue_id;
2552 if (!htb_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
2553 htb_update_queue__(netdev, queue_id, &hc);
2556 nl_dump_done(&dump);
2562 htb_tc_destroy(struct tc *tc)
2564 struct htb *htb = CONTAINER_OF(tc, struct htb, tc);
2565 struct htb_class *hc, *next;
2567 HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &htb->tc.queues) {
2568 hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2576 htb_qdisc_get(const struct netdev *netdev, struct shash *details)
2578 const struct htb *htb = htb_get__(netdev);
2579 shash_add(details, "max-rate", xasprintf("%llu", 8ULL * htb->max_rate));
2584 htb_qdisc_set(struct netdev *netdev, const struct shash *details)
2586 struct htb_class hc;
2589 htb_parse_qdisc_details__(netdev, details, &hc);
2590 error = htb_setup_class__(netdev, tc_make_handle(1, 0xfffe),
2591 tc_make_handle(1, 0), &hc);
2593 htb_get__(netdev)->max_rate = hc.max_rate;
2599 htb_class_get(const struct netdev *netdev OVS_UNUSED,
2600 const struct tc_queue *queue, struct shash *details)
2602 const struct htb_class *hc = htb_class_cast__(queue);
2604 shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
2605 if (hc->min_rate != hc->max_rate) {
2606 shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
2608 shash_add(details, "burst", xasprintf("%llu", 8ULL * hc->burst));
2610 shash_add(details, "priority", xasprintf("%u", hc->priority));
2616 htb_class_set(struct netdev *netdev, unsigned int queue_id,
2617 const struct shash *details)
2619 struct htb_class hc;
2622 error = htb_parse_class_details__(netdev, details, &hc);
2627 error = htb_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
2628 tc_make_handle(1, 0xfffe), &hc);
2633 htb_update_queue__(netdev, queue_id, &hc);
2638 htb_class_delete(struct netdev *netdev, struct tc_queue *queue)
2640 struct htb_class *hc = htb_class_cast__(queue);
2641 struct htb *htb = htb_get__(netdev);
2644 error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
2646 hmap_remove(&htb->tc.queues, &hc->tc_queue.hmap_node);
2653 htb_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
2654 struct netdev_queue_stats *stats)
2656 return htb_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
2657 tc_make_handle(1, 0xfffe), NULL, stats);
2661 htb_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
2662 const struct ofpbuf *nlmsg,
2663 netdev_dump_queue_stats_cb *cb, void *aux)
2665 struct netdev_queue_stats stats;
2666 unsigned int handle, major, minor;
2669 error = tc_parse_class(nlmsg, &handle, NULL, &stats);
2674 major = tc_get_major(handle);
2675 minor = tc_get_minor(handle);
2676 if (major == 1 && minor > 0 && minor <= HTB_N_QUEUES) {
2677 (*cb)(minor - 1, &stats, aux);
2682 static const struct tc_ops tc_ops_htb = {
2683 "htb", /* linux_name */
2684 "linux-htb", /* ovs_name */
2685 HTB_N_QUEUES, /* n_queues */
2694 htb_class_get_stats,
2695 htb_class_dump_stats
2698 /* "linux-hfsc" traffic control class. */
2700 #define HFSC_N_QUEUES 0xf000
2708 struct tc_queue tc_queue;
2713 static struct hfsc *
2714 hfsc_get__(const struct netdev *netdev)
2716 struct netdev_dev_linux *netdev_dev;
2717 netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
2718 return CONTAINER_OF(netdev_dev->tc, struct hfsc, tc);
2721 static struct hfsc_class *
2722 hfsc_class_cast__(const struct tc_queue *queue)
2724 return CONTAINER_OF(queue, struct hfsc_class, tc_queue);
2727 static struct hfsc *
2728 hfsc_install__(struct netdev *netdev, uint32_t max_rate)
2730 struct netdev_dev_linux * netdev_dev;
2733 netdev_dev = netdev_dev_linux_cast(netdev_get_dev(netdev));
2734 hfsc = xmalloc(sizeof *hfsc);
2735 tc_init(&hfsc->tc, &tc_ops_hfsc);
2736 hfsc->max_rate = max_rate;
2737 netdev_dev->tc = &hfsc->tc;
2743 hfsc_update_queue__(struct netdev *netdev, unsigned int queue_id,
2744 const struct hfsc_class *hc)
2748 struct hfsc_class *hcp;
2749 struct tc_queue *queue;
2751 hfsc = hfsc_get__(netdev);
2752 hash = hash_int(queue_id, 0);
2754 queue = tc_find_queue__(netdev, queue_id, hash);
2756 hcp = hfsc_class_cast__(queue);
2758 hcp = xmalloc(sizeof *hcp);
2759 queue = &hcp->tc_queue;
2760 queue->queue_id = queue_id;
2761 hmap_insert(&hfsc->tc.queues, &queue->hmap_node, hash);
2764 hcp->min_rate = hc->min_rate;
2765 hcp->max_rate = hc->max_rate;
2769 hfsc_parse_tca_options__(struct nlattr *nl_options, struct hfsc_class *class)
2771 const struct tc_service_curve *rsc, *fsc, *usc;
2772 static const struct nl_policy tca_hfsc_policy[] = {
2774 .type = NL_A_UNSPEC,
2776 .min_len = sizeof(struct tc_service_curve),
2779 .type = NL_A_UNSPEC,
2781 .min_len = sizeof(struct tc_service_curve),
2784 .type = NL_A_UNSPEC,
2786 .min_len = sizeof(struct tc_service_curve),
2789 struct nlattr *attrs[ARRAY_SIZE(tca_hfsc_policy)];
2791 if (!nl_parse_nested(nl_options, tca_hfsc_policy,
2792 attrs, ARRAY_SIZE(tca_hfsc_policy))) {
2793 VLOG_WARN_RL(&rl, "failed to parse HFSC class options");
2797 rsc = nl_attr_get(attrs[TCA_HFSC_RSC]);
2798 fsc = nl_attr_get(attrs[TCA_HFSC_FSC]);
2799 usc = nl_attr_get(attrs[TCA_HFSC_USC]);
2801 if (rsc->m1 != 0 || rsc->d != 0 ||
2802 fsc->m1 != 0 || fsc->d != 0 ||
2803 usc->m1 != 0 || usc->d != 0) {
2804 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
2805 "Non-linear service curves are not supported.");
2809 if (rsc->m2 != fsc->m2) {
2810 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
2811 "Real-time service curves are not supported ");
2815 if (rsc->m2 > usc->m2) {
2816 VLOG_WARN_RL(&rl, "failed to parse HFSC class options. "
2817 "Min-rate service curve is greater than "
2818 "the max-rate service curve.");
2822 class->min_rate = fsc->m2;
2823 class->max_rate = usc->m2;
2828 hfsc_parse_tcmsg__(struct ofpbuf *tcmsg, unsigned int *queue_id,
2829 struct hfsc_class *options,
2830 struct netdev_queue_stats *stats)
2833 unsigned int handle;
2834 struct nlattr *nl_options;
2836 error = tc_parse_class(tcmsg, &handle, &nl_options, stats);
2842 unsigned int major, minor;
2844 major = tc_get_major(handle);
2845 minor = tc_get_minor(handle);
2846 if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
2847 *queue_id = minor - 1;
2854 error = hfsc_parse_tca_options__(nl_options, options);
2861 hfsc_query_class__(const struct netdev *netdev, unsigned int handle,
2862 unsigned int parent, struct hfsc_class *options,
2863 struct netdev_queue_stats *stats)
2866 struct ofpbuf *reply;
2868 error = tc_query_class(netdev, handle, parent, &reply);
2873 error = hfsc_parse_tcmsg__(reply, NULL, options, stats);
2874 ofpbuf_delete(reply);
2879 hfsc_parse_qdisc_details__(struct netdev *netdev, const struct shash *details,
2880 struct hfsc_class *class)
2883 const char *max_rate_s;
2885 max_rate_s = shash_find_data(details, "max-rate");
2886 max_rate = max_rate_s ? strtoull(max_rate_s, NULL, 10) / 8 : 0;
2891 netdev_get_features(netdev, ¤t, NULL, NULL, NULL);
2892 max_rate = netdev_features_to_bps(current) / 8;
2895 class->min_rate = max_rate;
2896 class->max_rate = max_rate;
2900 hfsc_parse_class_details__(struct netdev *netdev,
2901 const struct shash *details,
2902 struct hfsc_class * class)
2904 const struct hfsc *hfsc;
2905 uint32_t min_rate, max_rate;
2906 const char *min_rate_s, *max_rate_s;
2908 hfsc = hfsc_get__(netdev);
2909 min_rate_s = shash_find_data(details, "min-rate");
2910 max_rate_s = shash_find_data(details, "max-rate");
2916 min_rate = strtoull(min_rate_s, NULL, 10) / 8;
2917 min_rate = MAX(min_rate, 1500);
2918 min_rate = MIN(min_rate, hfsc->max_rate);
2920 max_rate = (max_rate_s
2921 ? strtoull(max_rate_s, NULL, 10) / 8
2923 max_rate = MAX(max_rate, min_rate);
2924 max_rate = MIN(max_rate, hfsc->max_rate);
2926 class->min_rate = min_rate;
2927 class->max_rate = max_rate;
2932 /* Create an HFSC qdisc.
2934 * Equivalent to "tc qdisc add dev <dev> root handle 1: hfsc default 1". */
2936 hfsc_setup_qdisc__(struct netdev * netdev)
2938 struct tcmsg *tcmsg;
2939 struct ofpbuf request;
2940 struct tc_hfsc_qopt opt;
2942 tc_del_qdisc(netdev);
2944 tcmsg = tc_make_request(netdev, RTM_NEWQDISC,
2945 NLM_F_EXCL | NLM_F_CREATE, &request);
2951 tcmsg->tcm_handle = tc_make_handle(1, 0);
2952 tcmsg->tcm_parent = TC_H_ROOT;
2954 memset(&opt, 0, sizeof opt);
2957 nl_msg_put_string(&request, TCA_KIND, "hfsc");
2958 nl_msg_put_unspec(&request, TCA_OPTIONS, &opt, sizeof opt);
2960 return tc_transact(&request, NULL);
2963 /* Create an HFSC class.
2965 * Equivalent to "tc class add <dev> parent <parent> classid <handle> hfsc
2966 * sc rate <min_rate> ul rate <max_rate>" */
2968 hfsc_setup_class__(struct netdev *netdev, unsigned int handle,
2969 unsigned int parent, struct hfsc_class *class)
2973 struct tcmsg *tcmsg;
2974 struct ofpbuf request;
2975 struct tc_service_curve min, max;
2977 tcmsg = tc_make_request(netdev, RTM_NEWTCLASS, NLM_F_CREATE, &request);
2983 tcmsg->tcm_handle = handle;
2984 tcmsg->tcm_parent = parent;
2988 min.m2 = class->min_rate;
2992 max.m2 = class->max_rate;
2994 nl_msg_put_string(&request, TCA_KIND, "hfsc");
2995 opt_offset = nl_msg_start_nested(&request, TCA_OPTIONS);
2996 nl_msg_put_unspec(&request, TCA_HFSC_RSC, &min, sizeof min);
2997 nl_msg_put_unspec(&request, TCA_HFSC_FSC, &min, sizeof min);
2998 nl_msg_put_unspec(&request, TCA_HFSC_USC, &max, sizeof max);
2999 nl_msg_end_nested(&request, opt_offset);
3001 error = tc_transact(&request, NULL);
3003 VLOG_WARN_RL(&rl, "failed to replace %s class %u:%u, parent %u:%u, "
3004 "min-rate %ubps, max-rate %ubps (%s)",
3005 netdev_get_name(netdev),
3006 tc_get_major(handle), tc_get_minor(handle),
3007 tc_get_major(parent), tc_get_minor(parent),
3008 class->min_rate, class->max_rate, strerror(error));
3015 hfsc_tc_install(struct netdev *netdev, const struct shash *details)
3018 struct hfsc_class class;
3020 error = hfsc_setup_qdisc__(netdev);
3026 hfsc_parse_qdisc_details__(netdev, details, &class);
3027 error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3028 tc_make_handle(1, 0), &class);
3034 hfsc_install__(netdev, class.max_rate);
3039 hfsc_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3043 struct nl_dump dump;
3044 struct hfsc_class hc;
3047 hfsc_query_class__(netdev, tc_make_handle(1, 0xfffe), 0, &hc, NULL);
3048 hfsc = hfsc_install__(netdev, hc.max_rate);
3050 if (!start_queue_dump(netdev, &dump)) {
3054 while (nl_dump_next(&dump, &msg)) {
3055 unsigned int queue_id;
3057 if (!hfsc_parse_tcmsg__(&msg, &queue_id, &hc, NULL)) {
3058 hfsc_update_queue__(netdev, queue_id, &hc);
3062 nl_dump_done(&dump);
3067 hfsc_tc_destroy(struct tc *tc)
3070 struct hfsc_class *hc, *next;
3072 hfsc = CONTAINER_OF(tc, struct hfsc, tc);
3074 HMAP_FOR_EACH_SAFE (hc, next, tc_queue.hmap_node, &hfsc->tc.queues) {
3075 hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3084 hfsc_qdisc_get(const struct netdev *netdev, struct shash *details)
3086 const struct hfsc *hfsc;
3087 hfsc = hfsc_get__(netdev);
3088 shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hfsc->max_rate));
3093 hfsc_qdisc_set(struct netdev *netdev, const struct shash *details)
3096 struct hfsc_class class;
3098 hfsc_parse_qdisc_details__(netdev, details, &class);
3099 error = hfsc_setup_class__(netdev, tc_make_handle(1, 0xfffe),
3100 tc_make_handle(1, 0), &class);
3103 hfsc_get__(netdev)->max_rate = class.max_rate;
3110 hfsc_class_get(const struct netdev *netdev OVS_UNUSED,
3111 const struct tc_queue *queue, struct shash *details)
3113 const struct hfsc_class *hc;
3115 hc = hfsc_class_cast__(queue);
3116 shash_add(details, "min-rate", xasprintf("%llu", 8ULL * hc->min_rate));
3117 if (hc->min_rate != hc->max_rate) {
3118 shash_add(details, "max-rate", xasprintf("%llu", 8ULL * hc->max_rate));
3124 hfsc_class_set(struct netdev *netdev, unsigned int queue_id,
3125 const struct shash *details)
3128 struct hfsc_class class;
3130 error = hfsc_parse_class_details__(netdev, details, &class);
3135 error = hfsc_setup_class__(netdev, tc_make_handle(1, queue_id + 1),
3136 tc_make_handle(1, 0xfffe), &class);
3141 hfsc_update_queue__(netdev, queue_id, &class);
3146 hfsc_class_delete(struct netdev *netdev, struct tc_queue *queue)
3150 struct hfsc_class *hc;
3152 hc = hfsc_class_cast__(queue);
3153 hfsc = hfsc_get__(netdev);
3155 error = tc_delete_class(netdev, tc_make_handle(1, queue->queue_id + 1));
3157 hmap_remove(&hfsc->tc.queues, &hc->tc_queue.hmap_node);
3164 hfsc_class_get_stats(const struct netdev *netdev, const struct tc_queue *queue,
3165 struct netdev_queue_stats *stats)
3167 return hfsc_query_class__(netdev, tc_make_handle(1, queue->queue_id + 1),
3168 tc_make_handle(1, 0xfffe), NULL, stats);
3172 hfsc_class_dump_stats(const struct netdev *netdev OVS_UNUSED,
3173 const struct ofpbuf *nlmsg,
3174 netdev_dump_queue_stats_cb *cb, void *aux)
3176 struct netdev_queue_stats stats;
3177 unsigned int handle, major, minor;
3180 error = tc_parse_class(nlmsg, &handle, NULL, &stats);
3185 major = tc_get_major(handle);
3186 minor = tc_get_minor(handle);
3187 if (major == 1 && minor > 0 && minor <= HFSC_N_QUEUES) {
3188 (*cb)(minor - 1, &stats, aux);
3193 static const struct tc_ops tc_ops_hfsc = {
3194 "hfsc", /* linux_name */
3195 "linux-hfsc", /* ovs_name */
3196 HFSC_N_QUEUES, /* n_queues */
3197 hfsc_tc_install, /* tc_install */
3198 hfsc_tc_load, /* tc_load */
3199 hfsc_tc_destroy, /* tc_destroy */
3200 hfsc_qdisc_get, /* qdisc_get */
3201 hfsc_qdisc_set, /* qdisc_set */
3202 hfsc_class_get, /* class_get */
3203 hfsc_class_set, /* class_set */
3204 hfsc_class_delete, /* class_delete */
3205 hfsc_class_get_stats, /* class_get_stats */
3206 hfsc_class_dump_stats /* class_dump_stats */
3209 /* "linux-default" traffic control class.
3211 * This class represents the default, unnamed Linux qdisc. It corresponds to
3212 * the "" (empty string) QoS type in the OVS database. */
3215 default_install__(struct netdev *netdev)
3217 struct netdev_dev_linux *netdev_dev =
3218 netdev_dev_linux_cast(netdev_get_dev(netdev));
3219 static struct tc *tc;
3222 tc = xmalloc(sizeof *tc);
3223 tc_init(tc, &tc_ops_default);
3225 netdev_dev->tc = tc;
3229 default_tc_install(struct netdev *netdev,
3230 const struct shash *details OVS_UNUSED)
3232 default_install__(netdev);
3237 default_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3239 default_install__(netdev);
3243 static const struct tc_ops tc_ops_default = {
3244 NULL, /* linux_name */
3249 NULL, /* tc_destroy */
3250 NULL, /* qdisc_get */
3251 NULL, /* qdisc_set */
3252 NULL, /* class_get */
3253 NULL, /* class_set */
3254 NULL, /* class_delete */
3255 NULL, /* class_get_stats */
3256 NULL /* class_dump_stats */
3259 /* "linux-other" traffic control class.
3264 other_tc_load(struct netdev *netdev, struct ofpbuf *nlmsg OVS_UNUSED)
3266 struct netdev_dev_linux *netdev_dev =
3267 netdev_dev_linux_cast(netdev_get_dev(netdev));
3268 static struct tc *tc;
3271 tc = xmalloc(sizeof *tc);
3272 tc_init(tc, &tc_ops_other);
3274 netdev_dev->tc = tc;
3278 static const struct tc_ops tc_ops_other = {
3279 NULL, /* linux_name */
3280 "linux-other", /* ovs_name */
3282 NULL, /* tc_install */
3284 NULL, /* tc_destroy */
3285 NULL, /* qdisc_get */
3286 NULL, /* qdisc_set */
3287 NULL, /* class_get */
3288 NULL, /* class_set */
3289 NULL, /* class_delete */
3290 NULL, /* class_get_stats */
3291 NULL /* class_dump_stats */
3294 /* Traffic control. */
3296 /* Number of kernel "tc" ticks per second. */
3297 static double ticks_per_s;
3299 /* Number of kernel "jiffies" per second. This is used for the purpose of
3300 * computing buffer sizes. Generally kernel qdiscs need to be able to buffer
3301 * one jiffy's worth of data.
3303 * There are two possibilities here:
3305 * - 'buffer_hz' is the kernel's real timer tick rate, a small number in the
3306 * approximate range of 100 to 1024. That means that we really need to
3307 * make sure that the qdisc can buffer that much data.
3309 * - 'buffer_hz' is an absurdly large number. That means that the kernel
3310 * has finely granular timers and there's no need to fudge additional room
3311 * for buffers. (There's no extra effort needed to implement that: the
3312 * large 'buffer_hz' is used as a divisor, so practically any number will
3313 * come out as 0 in the division. Small integer results in the case of
3314 * really high dividends won't have any real effect anyhow.)
3316 static unsigned int buffer_hz;
3318 /* Returns tc handle 'major':'minor'. */
3320 tc_make_handle(unsigned int major, unsigned int minor)
3322 return TC_H_MAKE(major << 16, minor);
3325 /* Returns the major number from 'handle'. */
3327 tc_get_major(unsigned int handle)
3329 return TC_H_MAJ(handle) >> 16;
3332 /* Returns the minor number from 'handle'. */
3334 tc_get_minor(unsigned int handle)
3336 return TC_H_MIN(handle);
3339 static struct tcmsg *
3340 tc_make_request(const struct netdev *netdev, int type, unsigned int flags,
3341 struct ofpbuf *request)
3343 struct tcmsg *tcmsg;
3347 error = get_ifindex(netdev, &ifindex);
3352 ofpbuf_init(request, 512);
3353 nl_msg_put_nlmsghdr(request, sizeof *tcmsg, type, NLM_F_REQUEST | flags);
3354 tcmsg = ofpbuf_put_zeros(request, sizeof *tcmsg);
3355 tcmsg->tcm_family = AF_UNSPEC;
3356 tcmsg->tcm_ifindex = ifindex;
3357 /* Caller should fill in tcmsg->tcm_handle. */
3358 /* Caller should fill in tcmsg->tcm_parent. */
3364 tc_transact(struct ofpbuf *request, struct ofpbuf **replyp)
3366 int error = nl_sock_transact(rtnl_sock, request, replyp);
3367 ofpbuf_uninit(request);
3374 /* The values in psched are not individually very meaningful, but they are
3375 * important. The tables below show some values seen in the wild.
3379 * - "c" has always been a constant 1000000 since at least Linux 2.4.14.
3380 * (Before that, there are hints that it was 1000000000.)
3382 * - "d" can be unrealistically large, see the comment on 'buffer_hz'
3386 * -----------------------------------
3387 * [1] 000c8000 000f4240 000f4240 00000064
3388 * [2] 000003e8 00000400 000f4240 3b9aca00
3389 * [3] 000003e8 00000400 000f4240 3b9aca00
3390 * [4] 000003e8 00000400 000f4240 00000064
3391 * [5] 000003e8 00000040 000f4240 3b9aca00
3392 * [6] 000003e8 00000040 000f4240 000000f9
3394 * a b c d ticks_per_s buffer_hz
3395 * ------- --------- ---------- ------------- ----------- -------------
3396 * [1] 819,200 1,000,000 1,000,000 100 819,200 100
3397 * [2] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
3398 * [3] 1,000 1,024 1,000,000 1,000,000,000 976,562 1,000,000,000
3399 * [4] 1,000 1,024 1,000,000 100 976,562 100
3400 * [5] 1,000 64 1,000,000 1,000,000,000 15,625,000 1,000,000,000
3401 * [6] 1,000 64 1,000,000 249 15,625,000 249
3403 * [1] 2.6.18-128.1.6.el5.xs5.5.0.505.1024xen from XenServer 5.5.0-24648p
3404 * [2] 2.6.26-1-686-bigmem from Debian lenny
3405 * [3] 2.6.26-2-sparc64 from Debian lenny
3406 * [4] 2.6.27.42-0.1.1.xs5.6.810.44.111163xen from XenServer 5.6.810-31078p
3407 * [5] 2.6.32.21.22 (approx.) from Ubuntu 10.04 on VMware Fusion
3408 * [6] 2.6.34 from kernel.org on KVM
3410 static const char fn[] = "/proc/net/psched";
3411 unsigned int a, b, c, d;
3417 stream = fopen(fn, "r");
3419 VLOG_WARN("%s: open failed: %s", fn, strerror(errno));
3423 if (fscanf(stream, "%x %x %x %x", &a, &b, &c, &d) != 4) {
3424 VLOG_WARN("%s: read failed", fn);
3428 VLOG_DBG("%s: psched parameters are: %u %u %u %u", fn, a, b, c, d);
3432 VLOG_WARN("%s: invalid scheduler parameters", fn);
3436 ticks_per_s = (double) a * c / b;
3440 VLOG_WARN("%s: unexpected psched parameters: %u %u %u %u",
3443 VLOG_DBG("%s: ticks_per_s=%f buffer_hz=%u", fn, ticks_per_s, buffer_hz);
3446 /* Returns the number of bytes that can be transmitted in 'ticks' ticks at a
3447 * rate of 'rate' bytes per second. */
3449 tc_ticks_to_bytes(unsigned int rate, unsigned int ticks)
3454 return (rate * ticks) / ticks_per_s;
3457 /* Returns the number of ticks that it would take to transmit 'size' bytes at a
3458 * rate of 'rate' bytes per second. */
3460 tc_bytes_to_ticks(unsigned int rate, unsigned int size)
3465 return rate ? ((unsigned long long int) ticks_per_s * size) / rate : 0;
3468 /* Returns the number of bytes that need to be reserved for qdisc buffering at
3469 * a transmission rate of 'rate' bytes per second. */
3471 tc_buffer_per_jiffy(unsigned int rate)
3476 return rate / buffer_hz;
3479 /* Given Netlink 'msg' that describes a qdisc, extracts the name of the qdisc,
3480 * e.g. "htb", into '*kind' (if it is nonnull). If 'options' is nonnull,
3481 * extracts 'msg''s TCA_OPTIONS attributes into '*options' if it is present or
3482 * stores NULL into it if it is absent.
3484 * '*kind' and '*options' point into 'msg', so they are owned by whoever owns
3487 * Returns 0 if successful, otherwise a positive errno value. */
3489 tc_parse_qdisc(const struct ofpbuf *msg, const char **kind,
3490 struct nlattr **options)
3492 static const struct nl_policy tca_policy[] = {
3493 [TCA_KIND] = { .type = NL_A_STRING, .optional = false },
3494 [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = true },
3496 struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3498 if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3499 tca_policy, ta, ARRAY_SIZE(ta))) {
3500 VLOG_WARN_RL(&rl, "failed to parse qdisc message");
3505 *kind = nl_attr_get_string(ta[TCA_KIND]);
3509 *options = ta[TCA_OPTIONS];
3524 /* Given Netlink 'msg' that describes a class, extracts the queue ID (e.g. the
3525 * minor number of its class ID) into '*queue_id', its TCA_OPTIONS attribute
3526 * into '*options', and its queue statistics into '*stats'. Any of the output
3527 * arguments may be null.
3529 * Returns 0 if successful, otherwise a positive errno value. */
3531 tc_parse_class(const struct ofpbuf *msg, unsigned int *handlep,
3532 struct nlattr **options, struct netdev_queue_stats *stats)
3534 static const struct nl_policy tca_policy[] = {
3535 [TCA_OPTIONS] = { .type = NL_A_NESTED, .optional = false },
3536 [TCA_STATS2] = { .type = NL_A_NESTED, .optional = false },
3538 struct nlattr *ta[ARRAY_SIZE(tca_policy)];
3540 if (!nl_policy_parse(msg, NLMSG_HDRLEN + sizeof(struct tcmsg),
3541 tca_policy, ta, ARRAY_SIZE(ta))) {
3542 VLOG_WARN_RL(&rl, "failed to parse class message");
3547 struct tcmsg *tc = ofpbuf_at_assert(msg, NLMSG_HDRLEN, sizeof *tc);
3548 *handlep = tc->tcm_handle;
3552 *options = ta[TCA_OPTIONS];
3556 const struct gnet_stats_queue *gsq;
3557 struct gnet_stats_basic gsb;
3559 static const struct nl_policy stats_policy[] = {
3560 [TCA_STATS_BASIC] = { .type = NL_A_UNSPEC, .optional = false,
3561 .min_len = sizeof gsb },
3562 [TCA_STATS_QUEUE] = { .type = NL_A_UNSPEC, .optional = false,
3563 .min_len = sizeof *gsq },
3565 struct nlattr *sa[ARRAY_SIZE(stats_policy)];
3567 if (!nl_parse_nested(ta[TCA_STATS2], stats_policy,
3568 sa, ARRAY_SIZE(sa))) {
3569 VLOG_WARN_RL(&rl, "failed to parse class stats");
3573 /* Alignment issues screw up the length of struct gnet_stats_basic on
3574 * some arch/bitsize combinations. Newer versions of Linux have a
3575 * struct gnet_stats_basic_packed, but we can't depend on that. The
3576 * easiest thing to do is just to make a copy. */
3577 memset(&gsb, 0, sizeof gsb);
3578 memcpy(&gsb, nl_attr_get(sa[TCA_STATS_BASIC]),
3579 MIN(nl_attr_get_size(sa[TCA_STATS_BASIC]), sizeof gsb));
3580 stats->tx_bytes = gsb.bytes;
3581 stats->tx_packets = gsb.packets;
3583 gsq = nl_attr_get(sa[TCA_STATS_QUEUE]);
3584 stats->tx_errors = gsq->drops;
3594 memset(stats, 0, sizeof *stats);
3599 /* Queries the kernel for class with identifier 'handle' and parent 'parent'
3602 tc_query_class(const struct netdev *netdev,
3603 unsigned int handle, unsigned int parent,
3604 struct ofpbuf **replyp)
3606 struct ofpbuf request;
3607 struct tcmsg *tcmsg;
3610 tcmsg = tc_make_request(netdev, RTM_GETTCLASS, NLM_F_ECHO, &request);
3614 tcmsg->tcm_handle = handle;
3615 tcmsg->tcm_parent = parent;
3617 error = tc_transact(&request, replyp);
3619 VLOG_WARN_RL(&rl, "query %s class %u:%u (parent %u:%u) failed (%s)",
3620 netdev_get_name(netdev),
3621 tc_get_major(handle), tc_get_minor(handle),
3622 tc_get_major(parent), tc_get_minor(parent),
3628 /* Equivalent to "tc class del dev <name> handle <handle>". */
3630 tc_delete_class(const struct netdev *netdev, unsigned int handle)
3632 struct ofpbuf request;
3633 struct tcmsg *tcmsg;
3636 tcmsg = tc_make_request(netdev, RTM_DELTCLASS, 0, &request);
3640 tcmsg->tcm_handle = handle;
3641 tcmsg->tcm_parent = 0;
3643 error = tc_transact(&request, NULL);
3645 VLOG_WARN_RL(&rl, "delete %s class %u:%u failed (%s)",
3646 netdev_get_name(netdev),
3647 tc_get_major(handle), tc_get_minor(handle),
3653 /* Equivalent to "tc qdisc del dev <name> root". */
3655 tc_del_qdisc(struct netdev *netdev)
3657 struct netdev_dev_linux *netdev_dev =
3658 netdev_dev_linux_cast(netdev_get_dev(netdev));
3659 struct ofpbuf request;
3660 struct tcmsg *tcmsg;
3663 tcmsg = tc_make_request(netdev, RTM_DELQDISC, 0, &request);
3667 tcmsg->tcm_handle = tc_make_handle(1, 0);
3668 tcmsg->tcm_parent = TC_H_ROOT;
3670 error = tc_transact(&request, NULL);
3671 if (error == EINVAL) {
3672 /* EINVAL probably means that the default qdisc was in use, in which
3673 * case we've accomplished our purpose. */
3676 if (!error && netdev_dev->tc) {
3677 if (netdev_dev->tc->ops->tc_destroy) {
3678 netdev_dev->tc->ops->tc_destroy(netdev_dev->tc);
3680 netdev_dev->tc = NULL;
3685 /* If 'netdev''s qdisc type and parameters are not yet known, queries the
3686 * kernel to determine what they are. Returns 0 if successful, otherwise a
3687 * positive errno value. */
3689 tc_query_qdisc(const struct netdev *netdev)
3691 struct netdev_dev_linux *netdev_dev =
3692 netdev_dev_linux_cast(netdev_get_dev(netdev));
3693 struct ofpbuf request, *qdisc;
3694 const struct tc_ops *ops;
3695 struct tcmsg *tcmsg;
3699 if (netdev_dev->tc) {
3703 /* This RTM_GETQDISC is crafted to avoid OOPSing kernels that do not have
3704 * commit 53b0f08 "net_sched: Fix qdisc_notify()", which is anything before
3705 * 2.6.35 without that fix backported to it.
3707 * To avoid the OOPS, we must not make a request that would attempt to dump
3708 * a "built-in" qdisc, that is, the default pfifo_fast qdisc or one of a
3709 * few others. There are a few ways that I can see to do this, but most of
3710 * them seem to be racy (and if you lose the race the kernel OOPSes). The
3711 * technique chosen here is to assume that any non-default qdisc that we
3712 * create will have a class with handle 1:0. The built-in qdiscs only have
3713 * a class with handle 0:0.
3715 * We could check for Linux 2.6.35+ and use a more straightforward method
3717 tcmsg = tc_make_request(netdev, RTM_GETQDISC, NLM_F_ECHO, &request);
3721 tcmsg->tcm_handle = tc_make_handle(1, 0);
3722 tcmsg->tcm_parent = 0;
3724 /* Figure out what tc class to instantiate. */
3725 error = tc_transact(&request, &qdisc);
3729 error = tc_parse_qdisc(qdisc, &kind, NULL);
3731 ops = &tc_ops_other;
3733 ops = tc_lookup_linux_name(kind);
3735 static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 1);
3736 VLOG_INFO_RL(&rl2, "unknown qdisc \"%s\"", kind);
3738 ops = &tc_ops_other;
3741 } else if (error == ENOENT) {
3742 /* Either it's a built-in qdisc, or it's a qdisc set up by some
3743 * other entity that doesn't have a handle 1:0. We will assume
3744 * that it's the system default qdisc. */
3745 ops = &tc_ops_default;
3748 /* Who knows? Maybe the device got deleted. */
3749 VLOG_WARN_RL(&rl, "query %s qdisc failed (%s)",
3750 netdev_get_name(netdev), strerror(error));
3751 ops = &tc_ops_other;
3754 /* Instantiate it. */
3755 load_error = ops->tc_load((struct netdev *) netdev, qdisc);
3756 assert((load_error == 0) == (netdev_dev->tc != NULL));
3757 ofpbuf_delete(qdisc);
3759 return error ? error : load_error;
3762 /* Linux traffic control uses tables with 256 entries ("rtab" tables) to
3763 approximate the time to transmit packets of various lengths. For an MTU of
3764 256 or less, each entry is exact; for an MTU of 257 through 512, each entry
3765 represents two possible packet lengths; for a MTU of 513 through 1024, four
3766 possible lengths; and so on.
3768 Returns, for the specified 'mtu', the number of bits that packet lengths
3769 need to be shifted right to fit within such a 256-entry table. */
3771 tc_calc_cell_log(unsigned int mtu)
3776 mtu = ETH_PAYLOAD_MAX;
3778 mtu += ETH_HEADER_LEN + VLAN_HEADER_LEN;
3780 for (cell_log = 0; mtu >= 256; cell_log++) {
3787 /* Initializes 'rate' properly for a rate of 'Bps' bytes per second with an MTU
3790 tc_fill_rate(struct tc_ratespec *rate, uint64_t Bps, int mtu)
3792 memset(rate, 0, sizeof *rate);
3793 rate->cell_log = tc_calc_cell_log(mtu);
3794 /* rate->overhead = 0; */ /* New in 2.6.24, not yet in some */
3795 /* rate->cell_align = 0; */ /* distro headers. */
3796 rate->mpu = ETH_TOTAL_MIN;
3800 /* Appends to 'msg' an "rtab" table for the specified 'rate' as a Netlink
3801 * attribute of the specified "type".
3803 * See tc_calc_cell_log() above for a description of "rtab"s. */
3805 tc_put_rtab(struct ofpbuf *msg, uint16_t type, const struct tc_ratespec *rate)
3810 rtab = nl_msg_put_unspec_uninit(msg, type, TC_RTAB_SIZE);
3811 for (i = 0; i < TC_RTAB_SIZE / sizeof *rtab; i++) {
3812 unsigned packet_size = (i + 1) << rate->cell_log;
3813 if (packet_size < rate->mpu) {
3814 packet_size = rate->mpu;
3816 rtab[i] = tc_bytes_to_ticks(rate->rate, packet_size);
3820 /* Calculates the proper value of 'buffer' or 'cbuffer' in HTB options given a
3821 * rate of 'Bps' bytes per second, the specified 'mtu', and a user-requested
3822 * burst size of 'burst_bytes'. (If no value was requested, a 'burst_bytes' of
3825 tc_calc_buffer(unsigned int Bps, int mtu, uint64_t burst_bytes)
3827 unsigned int min_burst = tc_buffer_per_jiffy(Bps) + mtu;
3828 return tc_bytes_to_ticks(Bps, MAX(burst_bytes, min_burst));
3832 /* Utility functions. */
3835 get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
3837 /* Policy for RTNLGRP_LINK messages.
3839 * There are *many* more fields in these messages, but currently we only
3840 * care about these fields. */
3841 static const struct nl_policy rtnlgrp_link_policy[] = {
3842 [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
3843 [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
3844 .min_len = sizeof(struct rtnl_link_stats) },
3847 struct ofpbuf request;
3848 struct ofpbuf *reply;
3849 struct ifinfomsg *ifi;
3850 const struct rtnl_link_stats *rtnl_stats;
3851 struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
3854 ofpbuf_init(&request, 0);
3855 nl_msg_put_nlmsghdr(&request, sizeof *ifi, RTM_GETLINK, NLM_F_REQUEST);
3856 ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
3857 ifi->ifi_family = PF_UNSPEC;
3858 ifi->ifi_index = ifindex;
3859 error = nl_sock_transact(rtnl_sock, &request, &reply);
3860 ofpbuf_uninit(&request);
3865 if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
3866 rtnlgrp_link_policy,
3867 attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
3868 ofpbuf_delete(reply);
3872 if (!attrs[IFLA_STATS]) {
3873 VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
3874 ofpbuf_delete(reply);
3878 rtnl_stats = nl_attr_get(attrs[IFLA_STATS]);
3879 stats->rx_packets = rtnl_stats->rx_packets;
3880 stats->tx_packets = rtnl_stats->tx_packets;
3881 stats->rx_bytes = rtnl_stats->rx_bytes;
3882 stats->tx_bytes = rtnl_stats->tx_bytes;
3883 stats->rx_errors = rtnl_stats->rx_errors;
3884 stats->tx_errors = rtnl_stats->tx_errors;
3885 stats->rx_dropped = rtnl_stats->rx_dropped;
3886 stats->tx_dropped = rtnl_stats->tx_dropped;
3887 stats->multicast = rtnl_stats->multicast;
3888 stats->collisions = rtnl_stats->collisions;
3889 stats->rx_length_errors = rtnl_stats->rx_length_errors;
3890 stats->rx_over_errors = rtnl_stats->rx_over_errors;
3891 stats->rx_crc_errors = rtnl_stats->rx_crc_errors;
3892 stats->rx_frame_errors = rtnl_stats->rx_frame_errors;
3893 stats->rx_fifo_errors = rtnl_stats->rx_fifo_errors;
3894 stats->rx_missed_errors = rtnl_stats->rx_missed_errors;
3895 stats->tx_aborted_errors = rtnl_stats->tx_aborted_errors;
3896 stats->tx_carrier_errors = rtnl_stats->tx_carrier_errors;
3897 stats->tx_fifo_errors = rtnl_stats->tx_fifo_errors;
3898 stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors;
3899 stats->tx_window_errors = rtnl_stats->tx_window_errors;
3901 ofpbuf_delete(reply);
3907 get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
3909 static const char fn[] = "/proc/net/dev";
3914 stream = fopen(fn, "r");
3916 VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
3921 while (fgets(line, sizeof line, stream)) {
3924 #define X64 "%"SCNu64
3927 X64 X64 X64 X64 X64 X64 X64 "%*u"
3928 X64 X64 X64 X64 X64 X64 X64 "%*u",
3934 &stats->rx_fifo_errors,
3935 &stats->rx_frame_errors,
3941 &stats->tx_fifo_errors,
3943 &stats->tx_carrier_errors) != 15) {
3944 VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
3945 } else if (!strcmp(devname, netdev_name)) {
3946 stats->rx_length_errors = UINT64_MAX;
3947 stats->rx_over_errors = UINT64_MAX;
3948 stats->rx_crc_errors = UINT64_MAX;
3949 stats->rx_missed_errors = UINT64_MAX;
3950 stats->tx_aborted_errors = UINT64_MAX;
3951 stats->tx_heartbeat_errors = UINT64_MAX;
3952 stats->tx_window_errors = UINT64_MAX;
3958 VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
3964 get_flags(const struct netdev *netdev, int *flags)
3969 error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCGIFFLAGS,
3971 *flags = ifr.ifr_flags;
3976 set_flags(struct netdev *netdev, int flags)
3980 ifr.ifr_flags = flags;
3981 return netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, SIOCSIFFLAGS,
3986 do_get_ifindex(const char *netdev_name)
3990 strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
3991 COVERAGE_INC(netdev_get_ifindex);
3992 if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
3993 VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
3994 netdev_name, strerror(errno));
3997 return ifr.ifr_ifindex;
4001 get_ifindex(const struct netdev *netdev_, int *ifindexp)
4003 struct netdev_dev_linux *netdev_dev =
4004 netdev_dev_linux_cast(netdev_get_dev(netdev_));
4006 if (!(netdev_dev->cache_valid & VALID_IFINDEX)) {
4007 int ifindex = do_get_ifindex(netdev_get_name(netdev_));
4011 netdev_dev->cache_valid |= VALID_IFINDEX;
4012 netdev_dev->ifindex = ifindex;
4014 *ifindexp = netdev_dev->ifindex;
4019 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
4024 memset(&ifr, 0, sizeof ifr);
4025 strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4026 COVERAGE_INC(netdev_get_hwaddr);
4027 if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
4028 VLOG_ERR("ioctl(SIOCGIFHWADDR) on %s device failed: %s",
4029 netdev_name, strerror(errno));
4032 hwaddr_family = ifr.ifr_hwaddr.sa_family;
4033 if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
4034 VLOG_WARN("%s device has unknown hardware address family %d",
4035 netdev_name, hwaddr_family);
4037 memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
4042 set_etheraddr(const char *netdev_name, int hwaddr_family,
4043 const uint8_t mac[ETH_ADDR_LEN])
4047 memset(&ifr, 0, sizeof ifr);
4048 strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
4049 ifr.ifr_hwaddr.sa_family = hwaddr_family;
4050 memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
4051 COVERAGE_INC(netdev_set_hwaddr);
4052 if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
4053 VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
4054 netdev_name, strerror(errno));
4061 netdev_linux_do_ethtool(const char *name, struct ethtool_cmd *ecmd,
4062 int cmd, const char *cmd_name)
4066 memset(&ifr, 0, sizeof ifr);
4067 strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
4068 ifr.ifr_data = (caddr_t) ecmd;
4071 COVERAGE_INC(netdev_ethtool);
4072 if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) {
4075 if (errno != EOPNOTSUPP) {
4076 VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
4077 "failed: %s", cmd_name, name, strerror(errno));
4079 /* The device doesn't support this operation. That's pretty
4080 * common, so there's no point in logging anything. */
4087 netdev_linux_do_ioctl(const char *name, struct ifreq *ifr, int cmd,
4088 const char *cmd_name)
4090 strncpy(ifr->ifr_name, name, sizeof ifr->ifr_name);
4091 if (ioctl(af_inet_sock, cmd, ifr) == -1) {
4092 VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s", name, cmd_name,
4100 netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
4101 int cmd, const char *cmd_name)
4106 ifr.ifr_addr.sa_family = AF_INET;
4107 error = netdev_linux_do_ioctl(netdev_get_name(netdev), &ifr, cmd, cmd_name);
4109 const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
4110 *ip = sin->sin_addr;