kfree_skb(skb);
goto errout;
}
- err = rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
+ rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
+ return;
errout:
if (err < 0)
rtnl_set_sk_err(net, RTNLGRP_LINK, err);
/* Initialize kobject for bridge. This will be added as
* /sys/class/net/<devname>/brif later, if sysfs is enabled. */
- kobject_set_name(&dp->ifobj, SYSFS_BRIDGE_PORT_SUBDIR); /* "brif" */
dp->ifobj.kset = NULL;
- dp->ifobj.parent = NULL;
kobject_init(&dp->ifobj, &dp_ktype);
/* Allocate table. */
mutex_unlock(&dp_mutex);
rtnl_unlock();
-#ifdef SUPPORT_SYSFS
dp_sysfs_add_dp(dp);
-#endif
return 0;
if (p->port_no != ODPP_LOCAL)
dp_del_port(p);
-#ifdef SUPPORT_SYSFS
dp_sysfs_del_dp(dp);
-#endif
rcu_assign_pointer(dps[dp->dp_idx], NULL);
}
struct kobj_type brport_ktype = {
-#ifdef SUPPORT_SYSFS
+#ifdef CONFIG_SYSFS
.sysfs_ops = &brport_sysfs_ops,
#endif
.release = release_nbp
/* Initialize kobject for bridge. This will be added as
* /sys/class/net/<devname>/brport later, if sysfs is enabled. */
- kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR); /* "brport" */
p->kobj.kset = NULL;
- p->kobj.parent = &p->dev->NETDEV_DEV_MEMBER.kobj;
kobject_init(&p->kobj, &brport_ktype);
dp_ifinfo_notify(RTM_NEWLINK, p);
if (copy_from_user(&port, portp, sizeof port))
goto out;
port.devname[IFNAMSIZ - 1] = '\0';
- port_no = port.port;
-
- err = -EINVAL;
- if (port_no < 0 || port_no >= DP_MAX_PORTS)
- goto out;
rtnl_lock();
dp = get_dp_locked(dp_idx);
if (!dp)
goto out_unlock_rtnl;
- err = -EEXIST;
- if (dp->ports[port_no])
- goto out_unlock_dp;
+ for (port_no = 1; port_no < DP_MAX_PORTS; port_no++)
+ if (!dp->ports[port_no])
+ goto got_port_no;
+ err = -EFBIG;
+ goto out_unlock_dp;
+got_port_no:
if (!(port.flags & ODP_PORT_INTERNAL)) {
err = -ENODEV;
dev = dev_get_by_name(&init_net, port.devname);
if (err)
goto out_put;
-#ifdef SUPPORT_SYSFS
dp_sysfs_add_if(dp->ports[port_no]);
-#endif
+
+ err = __put_user(port_no, &port.port);
out_put:
dev_put(dev);
{
ASSERT_RTNL();
-#ifdef SUPPORT_SYSFS
if (p->port_no != ODPP_LOCAL)
dp_sysfs_del_if(p);
-#endif
dp_ifinfo_notify(RTM_DELLINK, p);
p->dp->n_ports--;
#error
#endif
-#ifdef CONFIG_XEN
+#if defined(CONFIG_XEN) && LINUX_VERSION_CODE == KERNEL_VERSION(2,6,18)
/* This code is copied verbatim from net/dev/core.c in Xen's
* linux-2.6.18-92.1.10.el5.xs5.0.0.394.644. We can't call those functions
* directly because they aren't exported. */
}
}
-int skb_checksum_setup(struct sk_buff *skb)
+int vswitch_skb_checksum_setup(struct sk_buff *skb)
{
if (skb->proto_csum_blank) {
if (skb->protocol != htons(ETH_P_IP))
out:
return -EPROTO;
}
-#endif
+#else
+int vswitch_skb_checksum_setup(struct sk_buff *skb) { return 0; }
+#endif /* CONFIG_XEN && linux == 2.6.18 */
int
dp_output_control(struct datapath *dp, struct sk_buff *skb, int queue_no,
/* If a checksum-deferred packet is forwarded to the controller,
* correct the pointers and checksum. This happens on a regular basis
- * only on Xen (the CHECKSUM_HW case), on which VMs can pass up packets
- * that do not have their checksum computed. We also implement it for
- * the non-Xen case, but it is difficult to trigger or test this case
- * there, hence the WARN_ON_ONCE().
+ * only on Xen, on which VMs can pass up packets that do not have their
+ * checksum computed.
*/
- err = skb_checksum_setup(skb);
+ err = vswitch_skb_checksum_setup(skb);
if (err)
goto err_kfree_skb;
#ifndef CHECKSUM_HW
if (skb->ip_summed == CHECKSUM_PARTIAL) {
- WARN_ON_ONCE(1);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
/* Until 2.6.22, the start of the transport header was also the
* start of data to be checksummed. Linux 2.6.22 introduced
stats->n_bytes = flow->byte_count;
stats->ip_tos = flow->ip_tos;
stats->tcp_flags = flow->tcp_flags;
+ stats->error = 0;
}
static void clear_stats(struct sw_flow *flow)
static int put_flow(struct datapath *dp, struct odp_flow_put __user *ufp)
{
struct odp_flow_put uf;
- struct sw_flow *flow, **bucket;
+ struct sw_flow *flow;
struct dp_table *table;
struct odp_flow_stats stats;
int error;
goto error;
uf.flow.key.reserved = 0;
- retry:
table = rcu_dereference(dp->table);
- bucket = dp_table_lookup_for_insert(table, &uf.flow.key);
- if (!bucket) {
- /* No such flow, and the slots where it could go are full. */
- error = uf.flags & ODPPF_CREATE ? -EFBIG : -ENOENT;
- goto error;
- } else if (!*bucket) {
- /* No such flow, but we found an available slot for it. */
+ flow = dp_table_lookup(table, &uf.flow.key);
+ if (!flow) {
+ /* No such flow. */
struct sw_flow_actions *acts;
error = -ENOENT;
goto error;
/* Expand table, if necessary, to make room. */
- if (dp->n_flows * 4 >= table->n_buckets &&
- table->n_buckets < DP_MAX_BUCKETS) {
+ if (dp->n_flows >= table->n_buckets) {
+ error = -ENOSPC;
+ if (table->n_buckets >= DP_MAX_BUCKETS)
+ goto error;
+
error = dp_table_expand(dp);
if (error)
goto error;
-
- /* The bucket's location has changed. Try again. */
- goto retry;
+ table = rcu_dereference(dp->table);
}
/* Allocate flow. */
rcu_assign_pointer(flow->sf_acts, acts);
/* Put flow in bucket. */
- rcu_assign_pointer(*bucket, flow);
+ error = dp_table_insert(table, flow);
+ if (error)
+ goto error_free_flow_acts;
dp->n_flows++;
memset(&stats, 0, sizeof(struct odp_flow_stats));
} else {
/* We found a matching flow. */
- struct sw_flow *flow = *rcu_dereference(bucket);
struct sw_flow_actions *old_acts, *new_acts;
unsigned long int flags;
return -EFAULT;
return 0;
+ error_free_flow_acts:
+ kfree(flow->sf_acts);
error_free_flow:
kmem_cache_free(flow_cache, flow);
error:
if (!n_actions)
return 0;
- if (ufp->n_actions > INT_MAX / sizeof(union odp_action))
- return -EINVAL;
sf_acts = rcu_dereference(flow->sf_acts);
if (__put_user(sf_acts->n_actions, &ufp->n_actions) ||
return put_actions(flow, ufp);
}
-static int del_or_query_flow(struct datapath *dp,
- struct odp_flow __user *ufp,
- unsigned int cmd)
+static int del_flow(struct datapath *dp, struct odp_flow __user *ufp)
{
struct dp_table *table = rcu_dereference(dp->table);
struct odp_flow uf;
if (!flow)
goto error;
- if (cmd == ODP_FLOW_DEL) {
- /* XXX redundant lookup */
- error = dp_table_delete(table, flow);
- if (error)
- goto error;
+ /* XXX redundant lookup */
+ error = dp_table_delete(table, flow);
+ if (error)
+ goto error;
- /* XXX These statistics might lose a few packets, since other
- * CPUs can be using this flow. We used to synchronize_rcu()
- * to make sure that we get completely accurate stats, but that
- * blows our performance, badly. */
- dp->n_flows--;
- error = answer_query(flow, ufp);
- flow_deferred_free(flow);
- } else {
- error = answer_query(flow, ufp);
- }
+ /* XXX These statistics might lose a few packets, since other CPUs can
+ * be using this flow. We used to synchronize_rcu() to make sure that
+ * we get completely accurate stats, but that blows our performance,
+ * badly. */
+ dp->n_flows--;
+ error = answer_query(flow, ufp);
+ flow_deferred_free(flow);
error:
return error;
}
-static int query_multiple_flows(struct datapath *dp,
- const struct odp_flowvec *flowvec)
+static int query_flows(struct datapath *dp, const struct odp_flowvec *flowvec)
{
struct dp_table *table = rcu_dereference(dp->table);
int i;
flow = dp_table_lookup(table, &uf.key);
if (!flow)
- error = __clear_user(&ufp->stats, sizeof ufp->stats);
+ error = __put_user(ENOENT, &ufp->stats.error);
else
error = answer_query(flow, ufp);
if (error)
return err;
}
-static int
-get_dp_stats(struct datapath *dp, struct odp_stats __user *statsp)
+static int get_dp_stats(struct datapath *dp, struct odp_stats __user *statsp)
{
struct odp_stats stats;
int i;
stats.n_flows = dp->n_flows;
- stats.cur_capacity = rcu_dereference(dp->table)->n_buckets * 2;
- stats.max_capacity = DP_MAX_BUCKETS * 2;
+ stats.cur_capacity = rcu_dereference(dp->table)->n_buckets;
+ stats.max_capacity = DP_MAX_BUCKETS;
stats.n_ports = dp->n_ports;
stats.max_ports = DP_MAX_PORTS;
stats.max_groups = DP_MAX_GROUPS;
break;
}
}
- return put_user(idx, &pvp->n_ports);
+ return put_user(dp->n_ports, &pvp->n_ports);
}
/* RCU callback for freeing a dp_port_group */
/* Handle commands with special locking requirements up front. */
switch (cmd) {
case ODP_DP_CREATE:
- return create_dp(dp_idx, (char __user *)argp);
+ err = create_dp(dp_idx, (char __user *)argp);
+ goto exit;
case ODP_DP_DESTROY:
- return destroy_dp(dp_idx);
+ err = destroy_dp(dp_idx);
+ goto exit;
case ODP_PORT_ADD:
- return add_port(dp_idx, (struct odp_port __user *)argp);
+ err = add_port(dp_idx, (struct odp_port __user *)argp);
+ goto exit;
case ODP_PORT_DEL:
err = get_user(port_no, (int __user *)argp);
- if (err)
- break;
- return del_port(dp_idx, port_no);
+ if (!err)
+ err = del_port(dp_idx, port_no);
+ goto exit;
}
dp = get_dp_locked(dp_idx);
+ err = -ENODEV;
if (!dp)
- return -ENODEV;
+ goto exit;
switch (cmd) {
case ODP_DP_STATS:
break;
case ODP_FLOW_DEL:
- case ODP_FLOW_GET:
- err = del_or_query_flow(dp, (struct odp_flow __user *)argp,
- cmd);
+ err = del_flow(dp, (struct odp_flow __user *)argp);
break;
- case ODP_FLOW_GET_MULTIPLE:
- err = do_flowvec_ioctl(dp, argp, query_multiple_flows);
+ case ODP_FLOW_GET:
+ err = do_flowvec_ioctl(dp, argp, query_flows);
break;
case ODP_FLOW_LIST:
break;
}
mutex_unlock(&dp->mutex);
+exit:
return err;
}
#include <linux/netdevice.h>
#include <linux/workqueue.h>
#include <linux/skbuff.h>
+#include <linux/version.h>
#include "flow.h"
#include "dp_sysfs.h"
#define DP_MAX_PORTS 256
#define DP_MAX_GROUPS 16
- #define DP_L2_BITS (PAGE_SHIFT - ilog2(sizeof(struct sw_flow*)))
+ #define DP_L2_BITS (PAGE_SHIFT - ilog2(sizeof(struct dp_bucket*)))
#define DP_L2_SIZE (1 << DP_L2_BITS)
#define DP_L2_SHIFT 0
- #define DP_L1_BITS (PAGE_SHIFT - ilog2(sizeof(struct sw_flow**)))
+ #define DP_L1_BITS (PAGE_SHIFT - ilog2(sizeof(struct dp_bucket**)))
#define DP_L1_SIZE (1 << DP_L1_BITS)
#define DP_L1_SHIFT DP_L2_BITS
+ /* For 4 kB pages, this is 1,048,576 on 32-bit or 262,144 on 64-bit. */
#define DP_MAX_BUCKETS (DP_L1_SIZE * DP_L2_SIZE)
+ /**
+ * struct dp_table - flow table
+ * @n_buckets: number of buckets (a power of 2 between %DP_L1_SIZE and
+ * %DP_MAX_BUCKETS)
+ * @buckets: pointer to @n_buckets/%DP_L1_SIZE pointers to %DP_L1_SIZE pointers
+ * to buckets
+ * @hash_seed: random number used for flow hashing, to make the hash
+ * distribution harder to predict
+ * @rcu: RCU callback structure
+ *
+ * The @buckets array is logically an array of pointers to buckets. It is
+ * broken into two levels to avoid the need to kmalloc() any object larger than
+ * a single page or to use vmalloc(). @buckets is always nonnull, as is each
+ * @buckets[i], but each @buckets[i][j] is nonnull only if the specified hash
+ * bucket is nonempty (for 0 <= i < @n_buckets/%DP_L1_SIZE, 0 <= j <
+ * %DP_L1_SIZE).
+ */
struct dp_table {
unsigned int n_buckets;
- struct sw_flow ***flows[2];
+ struct dp_bucket ***buckets;
+ unsigned int hash_seed;
+ struct rcu_head rcu;
+ };
+
+ /**
+ * struct dp_bucket - single bucket within datapath flow table
+ * @rcu: RCU callback structure
+ * @n_flows: number of flows in @flows[] array
+ * @flows: array of @n_flows pointers to flows
+ *
+ * The expected number of flows per bucket is 1, but this allows for an
+ * arbitrary number of collisions.
+ */
+ struct dp_bucket {
struct rcu_head rcu;
+ unsigned int n_flows;
+ struct sw_flow *flows[];
};
#define DP_N_QUEUES 2
struct dp_table *dp_table_create(unsigned int n_buckets);
void dp_table_destroy(struct dp_table *, int free_flows);
struct sw_flow *dp_table_lookup(struct dp_table *, const struct odp_flow_key *);
- struct sw_flow **dp_table_lookup_for_insert(struct dp_table *, const struct odp_flow_key *);
+ int dp_table_insert(struct dp_table *, struct sw_flow *);
int dp_table_delete(struct dp_table *, struct sw_flow *);
int dp_table_expand(struct datapath *);
int dp_table_flush(struct datapath *);
}
#endif
+int vswitch_skb_checksum_setup(struct sk_buff *skb);
+
#endif /* datapath.h */
static void show_flows(struct rconn *);
static void show_dpid_ip(struct rconn *, const struct dict *);
-static void show_secchan_state(const struct dict *);
+static void show_ofproto_state(const struct dict *);
static void show_fail_open_state(const struct dict *);
static void show_discovery_state(const struct dict *);
static void show_remote_state(const struct dict *);
if (!show_reboot_state()) {
show_flows(rconn);
show_dpid_ip(rconn, dict);
- show_secchan_state(dict);
+ show_ofproto_state(dict);
show_fail_open_state(dict);
show_discovery_state(dict);
show_remote_state(dict);
}
static void
-show_secchan_state(const struct dict *dict)
+show_ofproto_state(const struct dict *dict)
{
static struct message *msg;
const char *is_connected;
retval = netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev);
if (!retval) {
- bool exclude = netdev_get_in4(netdev, NULL) == 0;
- bool exclude = netdev_get_in4(netdev, NULL, NULL);
++ bool exclude = netdev_get_in4(netdev, NULL, NULL) == 0;
netdev_close(netdev);
if (exclude) {
continue;
out = prompt("Ctlr rate limit:", in,
"^(Disabled|("NUM100_TO_99999_RE")/s)$");
free(in);
- config.rate_limit = isdigit(out[0]) ? atoi(out) : -1;
+ config.rate_limit
+ = isdigit((unsigned char)out[0]) ? atoi(out) : -1;
free(out);
break;
out = prompt("Activity probe:", in,
"^(Default|("NUM5_TO_99999_RE") s)$");
free(in);
- config.inactivity_probe = isdigit(out[0]) ? atoi(out) : -1;
+ config.inactivity_probe
+ = isdigit((unsigned char)out[0]) ? atoi(out) : -1;
free(out);
break;
out = prompt("Max backoff:", in,
"^(Default|("NUM1_TO_99999_RE") s)$");
free(in);
- config.max_backoff = isdigit(out[0]) ? atoi(out) : -1;
+ config.max_backoff
+ = isdigit((unsigned char)out[0]) ? atoi(out) : -1;
free(out);
break;
}
* ----------------------------------------------------------------------
*/
-/* Protocol between secchan and datapath. */
+/* Protocol between userspace and kernel datapath. */
#ifndef OPENVSWITCH_DATAPATH_PROTOCOL_H
#define OPENVSWITCH_DATAPATH_PROTOCOL_H 1
#define ODP_PORT_GROUP_GET _IOWR('O', 12, struct odp_port_group)
#define ODP_FLOW_GET _IOWR('O', 13, struct odp_flow)
-#define ODP_FLOW_GET_MULTIPLE _IOWR('O', 14, struct odp_flowvec)
+#define ODP_FLOW_PUT _IOWR('O', 14, struct odp_flow)
#define ODP_FLOW_LIST _IOWR('O', 15, struct odp_flowvec)
-
#define ODP_FLOW_FLUSH _IO('O', 16)
-#define ODP_FLOW_PUT _IOWR('O', 17, struct odp_flow)
-#define ODP_FLOW_DEL _IOWR('O', 18, struct odp_flow)
+#define ODP_FLOW_DEL _IOWR('O', 17, struct odp_flow)
-#define ODP_EXECUTE _IOR('O', 19, struct odp_execute)
+#define ODP_EXECUTE _IOR('O', 18, struct odp_execute)
struct odp_stats {
/* Flows. */
__u32 used_nsec;
__u8 tcp_flags;
__u8 ip_tos;
- __u16 reserved;
+ __u16 error; /* Used by ODP_FLOW_GET. */
};
struct odp_flow_key {
__be16 tp_dst; /* TCP/UDP destination port. */
__u8 dl_src[ETH_ALEN]; /* Ethernet source address. */
__u8 dl_dst[ETH_ALEN]; /* Ethernet destination address. */
- __u8 nw_proto; /* IP protocol. */
+ __u8 nw_proto; /* IP protocol or lower 8 bits of
+ ARP opcode. */
__u8 reserved; /* Pad to 64 bits. */
};
--- /dev/null
- struct in_addr in4;
+/*
+ * Copyright (c) 2009 Nicira Networks.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <arpa/inet.h>
+#include <inttypes.h>
+#include <linux/if_tun.h>
+#include <linux/types.h>
+#include <linux/ethtool.h>
+#include <linux/rtnetlink.h>
+#include <linux/sockios.h>
+#include <linux/version.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/if_packet.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "coverage.h"
+#include "dynamic-string.h"
+#include "fatal-signal.h"
+#include "netdev-provider.h"
+#include "netlink.h"
+#include "ofpbuf.h"
+#include "openflow/openflow.h"
+#include "packets.h"
+#include "poll-loop.h"
+#include "rtnetlink.h"
+#include "socket-util.h"
+#include "shash.h"
+#include "svec.h"
+
+#define THIS_MODULE VLM_netdev_linux
+#include "vlog.h"
+\f
+/* These were introduced in Linux 2.6.14, so they might be missing if we have
+ * old headers. */
+#ifndef ADVERTISED_Pause
+#define ADVERTISED_Pause (1 << 13)
+#endif
+#ifndef ADVERTISED_Asym_Pause
+#define ADVERTISED_Asym_Pause (1 << 14)
+#endif
+
+struct netdev_linux {
+ struct netdev netdev;
+
+ /* File descriptors. For ordinary network devices, the two fds below are
+ * the same; for tap devices, they differ. */
+ int netdev_fd; /* Network device. */
+ int tap_fd; /* TAP character device, if any, otherwise the
+ * network device. */
+
+ struct netdev_linux_cache *cache;
+};
+
+enum {
+ VALID_IFINDEX = 1 << 0,
+ VALID_ETHERADDR = 1 << 1,
+ VALID_IN4 = 1 << 2,
+ VALID_IN6 = 1 << 3,
+ VALID_MTU = 1 << 4,
+ VALID_CARRIER = 1 << 5
+};
+
+/* Cached network device information. */
+struct netdev_linux_cache {
+ struct shash_node *shash_node;
+ unsigned int valid;
+ int ref_cnt;
+
+ int ifindex;
+ uint8_t etheraddr[ETH_ADDR_LEN];
- /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address (if
- * 'in4' is non-null) and returns true. Otherwise, returns false. */
++ struct in_addr address, netmask;
+ struct in6_addr in6;
+ int mtu;
+ int carrier;
+};
+
+static struct shash cache_map = SHASH_INITIALIZER(&cache_map);
+static struct rtnetlink_notifier netdev_linux_cache_notifier;
+
+/* An AF_INET socket (used for ioctl operations). */
+static int af_inet_sock = -1;
+
+struct netdev_linux_notifier {
+ struct netdev_notifier notifier;
+ struct list node;
+};
+
+static struct shash netdev_linux_notifiers =
+ SHASH_INITIALIZER(&netdev_linux_notifiers);
+static struct rtnetlink_notifier netdev_linux_poll_notifier;
+
+/* This is set pretty low because we probably won't learn anything from the
+ * additional log messages. */
+static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
+
+static int netdev_linux_do_ethtool(struct netdev *, struct ethtool_cmd *,
+ int cmd, const char *cmd_name);
+static int netdev_linux_do_ioctl(const struct netdev *, struct ifreq *,
+ int cmd, const char *cmd_name);
++static int netdev_linux_get_ipv4(const struct netdev *, struct in_addr *,
++ int cmd, const char *cmd_name);
+static int get_flags(const struct netdev *, int *flagsp);
+static int set_flags(struct netdev *, int flags);
+static int do_get_ifindex(const char *netdev_name);
+static int get_ifindex(const struct netdev *, int *ifindexp);
+static int do_set_addr(struct netdev *netdev,
+ int ioctl_nr, const char *ioctl_name,
+ struct in_addr addr);
+static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
+static int set_etheraddr(const char *netdev_name, int hwaddr_family,
+ const uint8_t[ETH_ADDR_LEN]);
+static int get_stats_via_netlink(int ifindex, struct netdev_stats *stats);
+static int get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats);
+
+static struct netdev_linux *
+netdev_linux_cast(const struct netdev *netdev)
+{
+ netdev_assert_class(netdev, &netdev_linux_class);
+ return CONTAINER_OF(netdev, struct netdev_linux, netdev);
+}
+
+static int
+netdev_linux_init(void)
+{
+ static int status = -1;
+ if (status < 0) {
+ af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
+ status = af_inet_sock >= 0 ? 0 : errno;
+ if (status) {
+ VLOG_ERR("failed to create inet socket: %s", strerror(status));
+ }
+ }
+ return status;
+}
+
+static void
+netdev_linux_run(void)
+{
+ rtnetlink_notifier_run();
+}
+
+static void
+netdev_linux_wait(void)
+{
+ rtnetlink_notifier_wait();
+}
+
+static void
+netdev_linux_cache_cb(const struct rtnetlink_change *change,
+ void *aux UNUSED)
+{
+ struct netdev_linux_cache *cache;
+ if (change) {
+ cache = shash_find_data(&cache_map, change->ifname);
+ if (cache) {
+ cache->valid = 0;
+ }
+ } else {
+ struct shash_node *node;
+ SHASH_FOR_EACH (node, &cache_map) {
+ cache = node->data;
+ cache->valid = 0;
+ }
+ }
+}
+
+static int
+netdev_linux_open(const char *name, char *suffix, int ethertype,
+ struct netdev **netdevp)
+{
+ struct netdev_linux *netdev;
+ enum netdev_flags flags;
+ int error;
+
+ /* Allocate network device. */
+ netdev = xcalloc(1, sizeof *netdev);
+ netdev_init(&netdev->netdev, suffix, &netdev_linux_class);
+ netdev->netdev_fd = -1;
+ netdev->tap_fd = -1;
+ netdev->cache = shash_find_data(&cache_map, suffix);
+ if (!netdev->cache) {
+ if (shash_is_empty(&cache_map)) {
+ int error = rtnetlink_notifier_register(
+ &netdev_linux_cache_notifier, netdev_linux_cache_cb, NULL);
+ if (error) {
+ netdev_close(&netdev->netdev);
+ return error;
+ }
+ }
+ netdev->cache = xmalloc(sizeof *netdev->cache);
+ netdev->cache->shash_node = shash_add(&cache_map, suffix,
+ netdev->cache);
+ netdev->cache->valid = 0;
+ netdev->cache->ref_cnt = 0;
+ }
+ netdev->cache->ref_cnt++;
+
+ if (!strncmp(name, "tap:", 4)) {
+ static const char tap_dev[] = "/dev/net/tun";
+ struct ifreq ifr;
+
+ /* Open tap device. */
+ netdev->tap_fd = open(tap_dev, O_RDWR);
+ if (netdev->tap_fd < 0) {
+ error = errno;
+ VLOG_WARN("opening \"%s\" failed: %s", tap_dev, strerror(error));
+ goto error;
+ }
+
+ /* Create tap device. */
+ ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
+ error = netdev_linux_do_ioctl(&netdev->netdev, &ifr,
+ TUNSETIFF, "TUNSETIFF");
+ if (error) {
+ goto error;
+ }
+
+ /* Make non-blocking. */
+ error = set_nonblocking(netdev->tap_fd);
+ if (error) {
+ goto error;
+ }
+ }
+
+ error = netdev_get_flags(&netdev->netdev, &flags);
+ if (error == ENODEV) {
+ goto error;
+ }
+
+ if (netdev->tap_fd >= 0 || ethertype != NETDEV_ETH_TYPE_NONE) {
+ struct sockaddr_ll sll;
+ int protocol;
+ int ifindex;
+
+ /* Create file descriptor. */
+ protocol = (ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL
+ : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2
+ : ethertype);
+ netdev->netdev_fd = socket(PF_PACKET, SOCK_RAW, htons(protocol));
+ if (netdev->netdev_fd < 0) {
+ error = errno;
+ goto error;
+ }
+ if (netdev->tap_fd < 0) {
+ netdev->tap_fd = netdev->netdev_fd;
+ }
+
+ /* Set non-blocking mode. */
+ error = set_nonblocking(netdev->netdev_fd);
+ if (error) {
+ goto error;
+ }
+
+ /* Get ethernet device index. */
+ error = get_ifindex(&netdev->netdev, &ifindex);
+ if (error) {
+ goto error;
+ }
+
+ /* Bind to specific ethernet device. */
+ memset(&sll, 0, sizeof sll);
+ sll.sll_family = AF_PACKET;
+ sll.sll_ifindex = ifindex;
+ if (bind(netdev->netdev_fd,
+ (struct sockaddr *) &sll, sizeof sll) < 0) {
+ error = errno;
+ VLOG_ERR("bind to %s failed: %s", suffix, strerror(error));
+ goto error;
+ }
+
+ /* Between the socket() and bind() calls above, the socket receives all
+ * packets of the requested type on all system interfaces. We do not
+ * want to receive that data, but there is no way to avoid it. So we
+ * must now drain out the receive queue. */
+ error = drain_rcvbuf(netdev->netdev_fd);
+ if (error) {
+ goto error;
+ }
+ }
+
+ *netdevp = &netdev->netdev;
+ return 0;
+
+error:
+ netdev_close(&netdev->netdev);
+ return error;
+}
+
+/* Closes and destroys 'netdev'. */
+static void
+netdev_linux_close(struct netdev *netdev_)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+
+ if (netdev->cache && !--netdev->cache->ref_cnt) {
+ shash_delete(&cache_map, netdev->cache->shash_node);
+ free(netdev->cache);
+
+ if (shash_is_empty(&cache_map)) {
+ rtnetlink_notifier_unregister(&netdev_linux_cache_notifier);
+ }
+ }
+ if (netdev->netdev_fd >= 0) {
+ close(netdev->netdev_fd);
+ }
+ if (netdev->tap_fd >= 0 && netdev->netdev_fd != netdev->tap_fd) {
+ close(netdev->tap_fd);
+ }
+ free(netdev);
+}
+
+/* Initializes 'svec' with a list of the names of all known network devices. */
+static int
+netdev_linux_enumerate(struct svec *svec)
+{
+ struct if_nameindex *names;
+
+ names = if_nameindex();
+ if (names) {
+ size_t i;
+
+ for (i = 0; names[i].if_name != NULL; i++) {
+ svec_add(svec, names[i].if_name);
+ }
+ if_freenameindex(names);
+ return 0;
+ } else {
+ VLOG_WARN("could not obtain list of network device names: %s",
+ strerror(errno));
+ return errno;
+ }
+}
+
+static int
+netdev_linux_recv(struct netdev *netdev_, void *data, size_t size)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+
+ if (netdev->tap_fd < 0) {
+ /* Device was opened with NETDEV_ETH_TYPE_NONE. */
+ return EAGAIN;
+ }
+
+ for (;;) {
+ ssize_t retval = read(netdev->tap_fd, data, size);
+ if (retval >= 0) {
+ return retval;
+ } else if (errno != EINTR) {
+ if (errno != EAGAIN) {
+ VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
+ strerror(errno), netdev_get_name(netdev_));
+ }
+ return errno;
+ }
+ }
+}
+
+/* Registers with the poll loop to wake up from the next call to poll_block()
+ * when a packet is ready to be received with netdev_recv() on 'netdev'. */
+static void
+netdev_linux_recv_wait(struct netdev *netdev_)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (netdev->tap_fd >= 0) {
+ poll_fd_wait(netdev->tap_fd, POLLIN);
+ }
+}
+
+/* Discards all packets waiting to be received from 'netdev'. */
+static int
+netdev_linux_drain(struct netdev *netdev_)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (netdev->tap_fd < 0 && netdev->netdev_fd < 0) {
+ return 0;
+ } else if (netdev->tap_fd != netdev->netdev_fd) {
+ struct ifreq ifr;
+ int error = netdev_linux_do_ioctl(netdev_, &ifr,
+ SIOCGIFTXQLEN, "SIOCGIFTXQLEN");
+ if (error) {
+ return error;
+ }
+ drain_fd(netdev->tap_fd, ifr.ifr_qlen);
+ return 0;
+ } else {
+ return drain_rcvbuf(netdev->netdev_fd);
+ }
+}
+
+/* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive
+ * errno value. Returns EAGAIN without blocking if the packet cannot be queued
+ * immediately. Returns EMSGSIZE if a partial packet was transmitted or if
+ * the packet is too big or too small to transmit on the device.
+ *
+ * The caller retains ownership of 'buffer' in all cases.
+ *
+ * The kernel maintains a packet transmission queue, so the caller is not
+ * expected to do additional queuing of packets. */
+static int
+netdev_linux_send(struct netdev *netdev_, const void *data, size_t size)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+
+ /* XXX should support sending even if 'ethertype' was NETDEV_ETH_TYPE_NONE.
+ */
+ if (netdev->tap_fd < 0) {
+ return EPIPE;
+ }
+
+ for (;;) {
+ ssize_t retval = write(netdev->tap_fd, data, size);
+ if (retval < 0) {
+ /* The Linux AF_PACKET implementation never blocks waiting for room
+ * for packets, instead returning ENOBUFS. Translate this into
+ * EAGAIN for the caller. */
+ if (errno == ENOBUFS) {
+ return EAGAIN;
+ } else if (errno == EINTR) {
+ continue;
+ } else if (errno != EAGAIN) {
+ VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
+ netdev_get_name(netdev_), strerror(errno));
+ }
+ return errno;
+ } else if (retval != size) {
+ VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of "
+ "%zu) on %s", retval, size, netdev_get_name(netdev_));
+ return EMSGSIZE;
+ } else {
+ return 0;
+ }
+ }
+}
+
+/* Registers with the poll loop to wake up from the next call to poll_block()
+ * when the packet transmission queue has sufficient room to transmit a packet
+ * with netdev_send().
+ *
+ * The kernel maintains a packet transmission queue, so the client is not
+ * expected to do additional queuing of packets. Thus, this function is
+ * unlikely to ever be used. It is included for completeness. */
+static void
+netdev_linux_send_wait(struct netdev *netdev_)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (netdev->tap_fd < 0 && netdev->netdev_fd < 0) {
+ /* Nothing to do. */
+ } else if (netdev->tap_fd == netdev->netdev_fd) {
+ poll_fd_wait(netdev->tap_fd, POLLOUT);
+ } else {
+ /* TAP device always accepts packets.*/
+ poll_immediate_wake();
+ }
+}
+
+/* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
+ * otherwise a positive errno value. */
+static int
+netdev_linux_set_etheraddr(struct netdev *netdev_,
+ const uint8_t mac[ETH_ADDR_LEN])
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ int error = set_etheraddr(netdev_get_name(netdev_), ARPHRD_ETHER, mac);
+ if (!error) {
+ memcpy(netdev->cache->etheraddr, mac, ETH_ADDR_LEN);
+ }
+ return error;
+}
+
+/* Returns a pointer to 'netdev''s MAC address. The caller must not modify or
+ * free the returned buffer. */
+static int
+netdev_linux_get_etheraddr(const struct netdev *netdev_,
+ uint8_t mac[ETH_ADDR_LEN])
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (!(netdev->cache->valid & VALID_ETHERADDR)) {
+ int error = get_etheraddr(netdev_get_name(netdev_),
+ netdev->cache->etheraddr);
+ if (error) {
+ return error;
+ }
+ netdev->cache->valid |= VALID_ETHERADDR;
+ }
+ memcpy(mac, netdev->cache->etheraddr, ETH_ADDR_LEN);
+ return 0;
+}
+
+/* Returns the maximum size of transmitted (and received) packets on 'netdev',
+ * in bytes, not including the hardware header; thus, this is typically 1500
+ * bytes for Ethernet devices. */
+static int
+netdev_linux_get_mtu(const struct netdev *netdev_, int *mtup)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (!(netdev->cache->valid & VALID_MTU)) {
+ struct ifreq ifr;
+ int error;
+
+ error = netdev_linux_do_ioctl(netdev_, &ifr, SIOCGIFMTU, "SIOCGIFMTU");
+ if (error) {
+ return error;
+ }
+ netdev->cache->mtu = ifr.ifr_mtu;
+ netdev->cache->valid |= VALID_MTU;
+ }
+ *mtup = netdev->cache->mtu;
+ return 0;
+}
+
+static int
+netdev_linux_get_carrier(const struct netdev *netdev_, bool *carrier)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ int error = 0;
+ char *fn = NULL;
+ int fd = -1;
+
+ if (!(netdev->cache->valid & VALID_CARRIER)) {
+ char line[8];
+ int retval;
+
+ fn = xasprintf("/sys/class/net/%s/carrier", netdev_get_name(netdev_));
+ fd = open(fn, O_RDONLY);
+ if (fd < 0) {
+ error = errno;
+ VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(error));
+ goto exit;
+ }
+
+ retval = read(fd, line, sizeof line);
+ if (retval < 0) {
+ error = errno;
+ if (error == EINVAL) {
+ /* This is the normal return value when we try to check carrier
+ * if the network device is not up. */
+ } else {
+ VLOG_WARN_RL(&rl, "%s: read failed: %s", fn, strerror(error));
+ }
+ goto exit;
+ } else if (retval == 0) {
+ error = EPROTO;
+ VLOG_WARN_RL(&rl, "%s: unexpected end of file", fn);
+ goto exit;
+ }
+
+ if (line[0] != '0' && line[0] != '1') {
+ error = EPROTO;
+ VLOG_WARN_RL(&rl, "%s: value is %c (expected 0 or 1)",
+ fn, line[0]);
+ goto exit;
+ }
+ netdev->cache->carrier = line[0] != '0';
+ netdev->cache->valid |= VALID_CARRIER;
+ }
+ *carrier = netdev->cache->carrier;
+ error = 0;
+
+exit:
+ if (fd >= 0) {
+ close(fd);
+ }
+ free(fn);
+ return error;
+}
+
+/* Check whether we can we use RTM_GETLINK to get network device statistics.
+ * In pre-2.6.19 kernels, this was only available if wireless extensions were
+ * enabled. */
+static bool
+check_for_working_netlink_stats(void)
+{
+ /* Decide on the netdev_get_stats() implementation to use. Netlink is
+ * preferable, so if that works, we'll use it. */
+ int ifindex = do_get_ifindex("lo");
+ if (ifindex < 0) {
+ VLOG_WARN("failed to get ifindex for lo, "
+ "obtaining netdev stats from proc");
+ return false;
+ } else {
+ struct netdev_stats stats;
+ int error = get_stats_via_netlink(ifindex, &stats);
+ if (!error) {
+ VLOG_DBG("obtaining netdev stats via rtnetlink");
+ return true;
+ } else {
+ VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats "
+ "via proc (you are probably running a pre-2.6.19 "
+ "kernel)", strerror(error));
+ return false;
+ }
+ }
+}
+
+/* Retrieves current device stats for 'netdev'.
+ *
+ * XXX All of the members of struct netdev_stats are 64 bits wide, but on
+ * 32-bit architectures the Linux network stats are only 32 bits. */
+static int
+netdev_linux_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
+{
+ static int use_netlink_stats = -1;
+ int error;
+
+ COVERAGE_INC(netdev_get_stats);
+ if (use_netlink_stats < 0) {
+ use_netlink_stats = check_for_working_netlink_stats();
+ }
+ if (use_netlink_stats) {
+ int ifindex;
+
+ error = get_ifindex(netdev, &ifindex);
+ if (!error) {
+ error = get_stats_via_netlink(ifindex, stats);
+ }
+ } else {
+ error = get_stats_via_proc(netdev->name, stats);
+ }
+ return error;
+}
+
+/* Stores the features supported by 'netdev' into each of '*current',
+ * '*advertised', '*supported', and '*peer' that are non-null. Each value is a
+ * bitmap of "enum ofp_port_features" bits, in host byte order. Returns 0 if
+ * successful, otherwise a positive errno value. On failure, all of the
+ * passed-in values are set to 0. */
+static int
+netdev_linux_get_features(struct netdev *netdev,
+ uint32_t *current, uint32_t *advertised,
+ uint32_t *supported, uint32_t *peer)
+{
+ struct ethtool_cmd ecmd;
+ int error;
+
+ memset(&ecmd, 0, sizeof ecmd);
+ error = netdev_linux_do_ethtool(netdev, &ecmd,
+ ETHTOOL_GSET, "ETHTOOL_GSET");
+ if (error) {
+ return error;
+ }
+
+ /* Supported features. */
+ *supported = 0;
+ if (ecmd.supported & SUPPORTED_10baseT_Half) {
+ *supported |= OFPPF_10MB_HD;
+ }
+ if (ecmd.supported & SUPPORTED_10baseT_Full) {
+ *supported |= OFPPF_10MB_FD;
+ }
+ if (ecmd.supported & SUPPORTED_100baseT_Half) {
+ *supported |= OFPPF_100MB_HD;
+ }
+ if (ecmd.supported & SUPPORTED_100baseT_Full) {
+ *supported |= OFPPF_100MB_FD;
+ }
+ if (ecmd.supported & SUPPORTED_1000baseT_Half) {
+ *supported |= OFPPF_1GB_HD;
+ }
+ if (ecmd.supported & SUPPORTED_1000baseT_Full) {
+ *supported |= OFPPF_1GB_FD;
+ }
+ if (ecmd.supported & SUPPORTED_10000baseT_Full) {
+ *supported |= OFPPF_10GB_FD;
+ }
+ if (ecmd.supported & SUPPORTED_TP) {
+ *supported |= OFPPF_COPPER;
+ }
+ if (ecmd.supported & SUPPORTED_FIBRE) {
+ *supported |= OFPPF_FIBER;
+ }
+ if (ecmd.supported & SUPPORTED_Autoneg) {
+ *supported |= OFPPF_AUTONEG;
+ }
+ if (ecmd.supported & SUPPORTED_Pause) {
+ *supported |= OFPPF_PAUSE;
+ }
+ if (ecmd.supported & SUPPORTED_Asym_Pause) {
+ *supported |= OFPPF_PAUSE_ASYM;
+ }
+
+ /* Advertised features. */
+ *advertised = 0;
+ if (ecmd.advertising & ADVERTISED_10baseT_Half) {
+ *advertised |= OFPPF_10MB_HD;
+ }
+ if (ecmd.advertising & ADVERTISED_10baseT_Full) {
+ *advertised |= OFPPF_10MB_FD;
+ }
+ if (ecmd.advertising & ADVERTISED_100baseT_Half) {
+ *advertised |= OFPPF_100MB_HD;
+ }
+ if (ecmd.advertising & ADVERTISED_100baseT_Full) {
+ *advertised |= OFPPF_100MB_FD;
+ }
+ if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
+ *advertised |= OFPPF_1GB_HD;
+ }
+ if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
+ *advertised |= OFPPF_1GB_FD;
+ }
+ if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
+ *advertised |= OFPPF_10GB_FD;
+ }
+ if (ecmd.advertising & ADVERTISED_TP) {
+ *advertised |= OFPPF_COPPER;
+ }
+ if (ecmd.advertising & ADVERTISED_FIBRE) {
+ *advertised |= OFPPF_FIBER;
+ }
+ if (ecmd.advertising & ADVERTISED_Autoneg) {
+ *advertised |= OFPPF_AUTONEG;
+ }
+ if (ecmd.advertising & ADVERTISED_Pause) {
+ *advertised |= OFPPF_PAUSE;
+ }
+ if (ecmd.advertising & ADVERTISED_Asym_Pause) {
+ *advertised |= OFPPF_PAUSE_ASYM;
+ }
+
+ /* Current settings. */
+ if (ecmd.speed == SPEED_10) {
+ *current = ecmd.duplex ? OFPPF_10MB_FD : OFPPF_10MB_HD;
+ } else if (ecmd.speed == SPEED_100) {
+ *current = ecmd.duplex ? OFPPF_100MB_FD : OFPPF_100MB_HD;
+ } else if (ecmd.speed == SPEED_1000) {
+ *current = ecmd.duplex ? OFPPF_1GB_FD : OFPPF_1GB_HD;
+ } else if (ecmd.speed == SPEED_10000) {
+ *current = OFPPF_10GB_FD;
+ } else {
+ *current = 0;
+ }
+
+ if (ecmd.port == PORT_TP) {
+ *current |= OFPPF_COPPER;
+ } else if (ecmd.port == PORT_FIBRE) {
+ *current |= OFPPF_FIBER;
+ }
+
+ if (ecmd.autoneg) {
+ *current |= OFPPF_AUTONEG;
+ }
+
+ /* Peer advertisements. */
+ *peer = 0; /* XXX */
+
+ return 0;
+}
+
+/* Set the features advertised by 'netdev' to 'advertise'. */
+static int
+netdev_linux_set_advertisements(struct netdev *netdev, uint32_t advertise)
+{
+ struct ethtool_cmd ecmd;
+ int error;
+
+ memset(&ecmd, 0, sizeof ecmd);
+ error = netdev_linux_do_ethtool(netdev, &ecmd,
+ ETHTOOL_GSET, "ETHTOOL_GSET");
+ if (error) {
+ return error;
+ }
+
+ ecmd.advertising = 0;
+ if (advertise & OFPPF_10MB_HD) {
+ ecmd.advertising |= ADVERTISED_10baseT_Half;
+ }
+ if (advertise & OFPPF_10MB_FD) {
+ ecmd.advertising |= ADVERTISED_10baseT_Full;
+ }
+ if (advertise & OFPPF_100MB_HD) {
+ ecmd.advertising |= ADVERTISED_100baseT_Half;
+ }
+ if (advertise & OFPPF_100MB_FD) {
+ ecmd.advertising |= ADVERTISED_100baseT_Full;
+ }
+ if (advertise & OFPPF_1GB_HD) {
+ ecmd.advertising |= ADVERTISED_1000baseT_Half;
+ }
+ if (advertise & OFPPF_1GB_FD) {
+ ecmd.advertising |= ADVERTISED_1000baseT_Full;
+ }
+ if (advertise & OFPPF_10GB_FD) {
+ ecmd.advertising |= ADVERTISED_10000baseT_Full;
+ }
+ if (advertise & OFPPF_COPPER) {
+ ecmd.advertising |= ADVERTISED_TP;
+ }
+ if (advertise & OFPPF_FIBER) {
+ ecmd.advertising |= ADVERTISED_FIBRE;
+ }
+ if (advertise & OFPPF_AUTONEG) {
+ ecmd.advertising |= ADVERTISED_Autoneg;
+ }
+ if (advertise & OFPPF_PAUSE) {
+ ecmd.advertising |= ADVERTISED_Pause;
+ }
+ if (advertise & OFPPF_PAUSE_ASYM) {
+ ecmd.advertising |= ADVERTISED_Asym_Pause;
+ }
+ return netdev_linux_do_ethtool(netdev, &ecmd,
+ ETHTOOL_SSET, "ETHTOOL_SSET");
+}
+
+/* If 'netdev_name' is the name of a VLAN network device (e.g. one created with
+ * vconfig(8)), sets '*vlan_vid' to the VLAN VID associated with that device
+ * and returns 0. Otherwise returns a errno value (specifically ENOENT if
+ * 'netdev_name' is the name of a network device that is not a VLAN device) and
+ * sets '*vlan_vid' to -1. */
+static int
+netdev_linux_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ struct ds line = DS_EMPTY_INITIALIZER;
+ FILE *stream = NULL;
+ int error;
+ char *fn;
+
+ COVERAGE_INC(netdev_get_vlan_vid);
+ fn = xasprintf("/proc/net/vlan/%s", netdev_name);
+ stream = fopen(fn, "r");
+ if (!stream) {
+ error = errno;
+ goto done;
+ }
+
+ if (ds_get_line(&line, stream)) {
+ if (ferror(stream)) {
+ error = errno;
+ VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno));
+ } else {
+ error = EPROTO;
+ VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn);
+ }
+ goto done;
+ }
+
+ if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) {
+ error = EPROTO;
+ VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"",
+ fn, ds_cstr(&line));
+ goto done;
+ }
+
+ error = 0;
+
+done:
+ free(fn);
+ if (stream) {
+ fclose(stream);
+ }
+ ds_destroy(&line);
+ if (error) {
+ *vlan_vid = -1;
+ }
+ return error;
+}
+
+#define POLICE_ADD_CMD "/sbin/tc qdisc add dev %s handle ffff: ingress"
+#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"
+/* We redirect stderr to /dev/null because we often want to remove all
+ * traffic control configuration on a port so its in a known state. If
+ * this done when there is no such configuration, tc complains, so we just
+ * always ignore it.
+ */
+#define POLICE_DEL_CMD "/sbin/tc qdisc del dev %s handle ffff: ingress 2>/dev/null"
+
+/* Attempts to set input rate limiting (policing) policy. */
+static int
+netdev_linux_set_policing(struct netdev *netdev,
+ uint32_t kbits_rate, uint32_t kbits_burst)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ char command[1024];
+
+ COVERAGE_INC(netdev_set_policing);
+ if (kbits_rate) {
+ if (!kbits_burst) {
+ /* Default to 10 kilobits if not specified. */
+ kbits_burst = 10;
+ }
+
+ /* xxx This should be more careful about only adding if it
+ * xxx actually exists, as opposed to always deleting it. */
+ snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
+ if (system(command) == -1) {
+ VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
+ }
+
+ snprintf(command, sizeof(command), POLICE_ADD_CMD, netdev_name);
+ if (system(command) != 0) {
+ VLOG_WARN_RL(&rl, "%s: problem adding policing", netdev_name);
+ return -1;
+ }
+
+ snprintf(command, sizeof(command), POLICE_CONFIG_CMD, netdev_name,
+ kbits_rate, kbits_burst);
+ if (system(command) != 0) {
+ VLOG_WARN_RL(&rl, "%s: problem configuring policing",
+ netdev_name);
+ return -1;
+ }
+ } else {
+ snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
+ if (system(command) == -1) {
+ VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
+ }
+ }
+
+ return 0;
+}
+
- netdev_linux_get_in4(const struct netdev *netdev_, struct in_addr *in4)
+static int
- const struct sockaddr_in *sin;
- struct ifreq ifr;
++netdev_linux_get_in4(const struct netdev *netdev_,
++ struct in_addr *address, struct in_addr *netmask)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (!(netdev->cache->valid & VALID_IN4)) {
- ifr.ifr_addr.sa_family = AF_INET;
- error = netdev_linux_do_ioctl(netdev_, &ifr,
+ int error;
+
- sin = (struct sockaddr_in *) &ifr.ifr_addr;
- netdev->cache->in4 = sin->sin_addr;
++ error = netdev_linux_get_ipv4(netdev_, &netdev->cache->address,
+ SIOCGIFADDR, "SIOCGIFADDR");
+ if (error) {
+ return error;
+ }
+
- *in4 = netdev->cache->in4;
- return in4->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
++ error = netdev_linux_get_ipv4(netdev_, &netdev->cache->netmask,
++ SIOCGIFNETMASK, "SIOCGIFNETMASK");
++ if (error) {
++ return error;
++ }
++
+ netdev->cache->valid |= VALID_IN4;
+ }
- /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask. If
- * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared. Returns a
- * positive errno value. */
++ *address = netdev->cache->address;
++ *netmask = netdev->cache->netmask;
++ return address->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
+}
+
- netdev_linux_set_in4(struct netdev *netdev_, struct in_addr addr,
- struct in_addr mask)
+static int
- error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", addr);
++netdev_linux_set_in4(struct netdev *netdev_, struct in_addr address,
++ struct in_addr netmask)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ int error;
+
- netdev->cache->in4 = addr;
- if (addr.s_addr != INADDR_ANY) {
++ error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", address);
+ if (!error) {
+ netdev->cache->valid |= VALID_IN4;
- "SIOCSIFNETMASK", mask);
++ netdev->cache->address = address;
++ netdev->cache->netmask = netmask;
++ if (address.s_addr != INADDR_ANY) {
+ error = do_set_addr(netdev_, SIOCSIFNETMASK,
++ "SIOCSIFNETMASK", netmask);
+ }
+ }
+ return error;
+}
+
+static bool
+parse_if_inet6_line(const char *line,
+ struct in6_addr *in6, char ifname[16 + 1])
+{
+ uint8_t *s6 = in6->s6_addr;
+#define X8 "%2"SCNx8
+ return sscanf(line,
+ " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
+ "%*x %*x %*x %*x %16s\n",
+ &s6[0], &s6[1], &s6[2], &s6[3],
+ &s6[4], &s6[5], &s6[6], &s6[7],
+ &s6[8], &s6[9], &s6[10], &s6[11],
+ &s6[12], &s6[13], &s6[14], &s6[15],
+ ifname) == 17;
+}
+
+/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
+ * 'in6' is non-null) and returns true. Otherwise, returns false. */
+static int
+netdev_linux_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ if (!(netdev->cache->valid & VALID_IN6)) {
+ FILE *file;
+ char line[128];
+
+ netdev->cache->in6 = in6addr_any;
+
+ file = fopen("/proc/net/if_inet6", "r");
+ if (file != NULL) {
+ const char *name = netdev_get_name(netdev_);
+ while (fgets(line, sizeof line, file)) {
+ struct in6_addr in6;
+ char ifname[16 + 1];
+ if (parse_if_inet6_line(line, &in6, ifname)
+ && !strcmp(name, ifname))
+ {
+ netdev->cache->in6 = in6;
+ break;
+ }
+ }
+ fclose(file);
+ }
+ netdev->cache->valid |= VALID_IN6;
+ }
+ *in6 = netdev->cache->in6;
+ return 0;
+}
+
+static void
+make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
+{
+ struct sockaddr_in sin;
+ memset(&sin, 0, sizeof sin);
+ sin.sin_family = AF_INET;
+ sin.sin_addr = addr;
+ sin.sin_port = 0;
+
+ memset(sa, 0, sizeof *sa);
+ memcpy(sa, &sin, sizeof sin);
+}
+
+static int
+do_set_addr(struct netdev *netdev,
+ int ioctl_nr, const char *ioctl_name, struct in_addr addr)
+{
+ struct ifreq ifr;
+ strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
+ make_in4_sockaddr(&ifr.ifr_addr, addr);
+ return netdev_linux_do_ioctl(netdev, &ifr, ioctl_nr, ioctl_name);
+}
+
+/* Adds 'router' as a default IP gateway. */
+static int
+netdev_linux_add_router(struct netdev *netdev UNUSED, struct in_addr router)
+{
+ struct in_addr any = { INADDR_ANY };
+ struct rtentry rt;
+ int error;
+
+ memset(&rt, 0, sizeof rt);
+ make_in4_sockaddr(&rt.rt_dst, any);
+ make_in4_sockaddr(&rt.rt_gateway, router);
+ make_in4_sockaddr(&rt.rt_genmask, any);
+ rt.rt_flags = RTF_UP | RTF_GATEWAY;
+ COVERAGE_INC(netdev_add_router);
+ error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
+ if (error) {
+ VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error));
+ }
+ return error;
+}
+
++static int
++netdev_linux_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
++ char **netdev_name)
++{
++ static const char fn[] = "/proc/net/route";
++ FILE *stream;
++ char line[256];
++ int ln;
++
++ *netdev_name = NULL;
++ stream = fopen(fn, "r");
++ if (stream == NULL) {
++ VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
++ return errno;
++ }
++
++ ln = 0;
++ while (fgets(line, sizeof line, stream)) {
++ if (++ln >= 2) {
++ char iface[17];
++ uint32_t dest, gateway, mask;
++ int refcnt, metric, mtu;
++ unsigned int flags, use, window, irtt;
++
++ if (sscanf(line,
++ "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
++ " %d %u %u\n",
++ iface, &dest, &gateway, &flags, &refcnt,
++ &use, &metric, &mask, &mtu, &window, &irtt) != 11) {
++
++ VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
++ fn, ln, line);
++ continue;
++ }
++ if (!(flags & RTF_UP)) {
++ /* Skip routes that aren't up. */
++ continue;
++ }
++
++ /* The output of 'dest', 'mask', and 'gateway' were given in
++ * network byte order, so we don't need need any endian
++ * conversions here. */
++ if ((dest & mask) == (host->s_addr & mask)) {
++ if (!gateway) {
++ /* The host is directly reachable. */
++ next_hop->s_addr = 0;
++ } else {
++ /* To reach the host, we must go through a gateway. */
++ next_hop->s_addr = gateway;
++ }
++ *netdev_name = xstrdup(iface);
++ fclose(stream);
++ return 0;
++ }
++ }
++ }
++
++ fclose(stream);
++ return ENXIO;
++}
++
+/* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
+ * successfully retrieved, it stores the corresponding MAC address in 'mac' and
+ * returns 0. Otherwise, it returns a positive errno value; in particular,
+ * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
+static int
+netdev_linux_arp_lookup(const struct netdev *netdev,
+ uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
+{
+ struct arpreq r;
+ struct sockaddr_in *pa;
+ int retval;
+
+ memset(&r, 0, sizeof r);
+ pa = (struct sockaddr_in *) &r.arp_pa;
+ pa->sin_family = AF_INET;
+ pa->sin_addr.s_addr = ip;
+ pa->sin_port = 0;
+ r.arp_ha.sa_family = ARPHRD_ETHER;
+ r.arp_flags = 0;
+ strncpy(r.arp_dev, netdev->name, sizeof r.arp_dev);
+ COVERAGE_INC(netdev_arp_lookup);
+ retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
+ if (!retval) {
+ memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
+ } else if (retval != ENXIO) {
+ VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
+ netdev->name, IP_ARGS(&ip), strerror(retval));
+ }
+ return retval;
+}
+
+static int
+nd_to_iff_flags(enum netdev_flags nd)
+{
+ int iff = 0;
+ if (nd & NETDEV_UP) {
+ iff |= IFF_UP;
+ }
+ if (nd & NETDEV_PROMISC) {
+ iff |= IFF_PROMISC;
+ }
+ return iff;
+}
+
+static int
+iff_to_nd_flags(int iff)
+{
+ enum netdev_flags nd = 0;
+ if (iff & IFF_UP) {
+ nd |= NETDEV_UP;
+ }
+ if (iff & IFF_PROMISC) {
+ nd |= NETDEV_PROMISC;
+ }
+ return nd;
+}
+
+static int
+netdev_linux_update_flags(struct netdev *netdev, enum netdev_flags off,
+ enum netdev_flags on, enum netdev_flags *old_flagsp)
+{
+ int old_flags, new_flags;
+ int error;
+
+ error = get_flags(netdev, &old_flags);
+ if (!error) {
+ *old_flagsp = iff_to_nd_flags(old_flags);
+ new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
+ if (new_flags != old_flags) {
+ error = set_flags(netdev, new_flags);
+ }
+ }
+ return error;
+}
+
+static void
+poll_notify(struct list *list)
+{
+ struct netdev_linux_notifier *notifier;
+ LIST_FOR_EACH (notifier, struct netdev_linux_notifier, node, list) {
+ struct netdev_notifier *n = ¬ifier->notifier;
+ n->cb(n);
+ }
+}
+
+static void
+netdev_linux_poll_cb(const struct rtnetlink_change *change,
+ void *aux UNUSED)
+{
+ if (change) {
+ struct list *list = shash_find_data(&netdev_linux_notifiers,
+ change->ifname);
+ if (list) {
+ poll_notify(list);
+ }
+ } else {
+ struct shash_node *node;
+ SHASH_FOR_EACH (node, &netdev_linux_notifiers) {
+ poll_notify(node->data);
+ }
+ }
+}
+
+static int
+netdev_linux_poll_add(struct netdev *netdev,
+ void (*cb)(struct netdev_notifier *), void *aux,
+ struct netdev_notifier **notifierp)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ struct netdev_linux_notifier *notifier;
+ struct list *list;
+
+ if (shash_is_empty(&netdev_linux_notifiers)) {
+ int error = rtnetlink_notifier_register(&netdev_linux_poll_notifier,
+ netdev_linux_poll_cb, NULL);
+ if (error) {
+ return error;
+ }
+ }
+
+ list = shash_find_data(&netdev_linux_notifiers, netdev_name);
+ if (!list) {
+ list = xmalloc(sizeof *list);
+ list_init(list);
+ shash_add(&netdev_linux_notifiers, netdev_name, list);
+ }
+
+ notifier = xmalloc(sizeof *notifier);
+ netdev_notifier_init(¬ifier->notifier, netdev, cb, aux);
+ list_push_back(list, ¬ifier->node);
+ *notifierp = ¬ifier->notifier;
+ return 0;
+}
+
+static void
+netdev_linux_poll_remove(struct netdev_notifier *notifier_)
+{
+ struct netdev_linux_notifier *notifier =
+ CONTAINER_OF(notifier_, struct netdev_linux_notifier, notifier);
+ struct list *list;
+
+ /* Remove 'notifier' from its list. */
+ list = list_remove(¬ifier->node);
+ if (list_is_empty(list)) {
+ /* The list is now empty. Remove it from the hash and free it. */
+ const char *netdev_name = netdev_get_name(notifier->notifier.netdev);
+ shash_delete(&netdev_linux_notifiers,
+ shash_find(&netdev_linux_notifiers, netdev_name));
+ free(list);
+ }
+ free(notifier);
+
+ /* If that was the last notifier, unregister. */
+ if (shash_is_empty(&netdev_linux_notifiers)) {
+ rtnetlink_notifier_unregister(&netdev_linux_poll_notifier);
+ }
+}
+
+const struct netdev_class netdev_linux_class = {
+ "", /* prefix */
+ "linux", /* name */
+
+ netdev_linux_init,
+ netdev_linux_run,
+ netdev_linux_wait,
+
+ netdev_linux_open,
+ netdev_linux_close,
+
+ netdev_linux_enumerate,
+
+ netdev_linux_recv,
+ netdev_linux_recv_wait,
+ netdev_linux_drain,
+
+ netdev_linux_send,
+ netdev_linux_send_wait,
+
+ netdev_linux_set_etheraddr,
+ netdev_linux_get_etheraddr,
+ netdev_linux_get_mtu,
+ netdev_linux_get_carrier,
+ netdev_linux_get_stats,
+
+ netdev_linux_get_features,
+ netdev_linux_set_advertisements,
+ netdev_linux_get_vlan_vid,
+ netdev_linux_set_policing,
+
+ netdev_linux_get_in4,
+ netdev_linux_set_in4,
+ netdev_linux_get_in6,
+ netdev_linux_add_router,
++ netdev_linux_get_next_hop,
+ netdev_linux_arp_lookup,
+
+ netdev_linux_update_flags,
+
+ netdev_linux_poll_add,
+ netdev_linux_poll_remove,
+};
+
+const struct netdev_class netdev_tap_class = {
+ "tap", /* prefix */
+ "tap", /* name */
+
+ netdev_linux_init,
+ NULL, /* run */
+ NULL, /* wait */
+
+ netdev_linux_open,
+ netdev_linux_close,
+
+ netdev_linux_enumerate,
+
+ netdev_linux_recv,
+ netdev_linux_recv_wait,
+ netdev_linux_drain,
+
+ netdev_linux_send,
+ netdev_linux_send_wait,
+
+ netdev_linux_set_etheraddr,
+ netdev_linux_get_etheraddr,
+ netdev_linux_get_mtu,
+ netdev_linux_get_carrier,
+ netdev_linux_get_stats,
+
+ netdev_linux_get_features,
+ netdev_linux_set_advertisements,
+ netdev_linux_get_vlan_vid,
+ netdev_linux_set_policing,
+
+ netdev_linux_get_in4,
+ netdev_linux_set_in4,
+ netdev_linux_get_in6,
+ netdev_linux_add_router,
++ netdev_linux_get_next_hop,
+ netdev_linux_arp_lookup,
+
+ netdev_linux_update_flags,
+
+ netdev_linux_poll_add,
+ netdev_linux_poll_remove,
+};
+\f
+static int
+get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
+{
+ /* Policy for RTNLGRP_LINK messages.
+ *
+ * There are *many* more fields in these messages, but currently we only
+ * care about these fields. */
+ static const struct nl_policy rtnlgrp_link_policy[] = {
+ [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
+ [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct rtnl_link_stats) },
+ };
+
+
+ static struct nl_sock *rtnl_sock;
+ struct ofpbuf request;
+ struct ofpbuf *reply;
+ struct ifinfomsg *ifi;
+ const struct rtnl_link_stats *rtnl_stats;
+ struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
+ int error;
+
+ if (!rtnl_sock) {
+ error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock);
+ if (error) {
+ VLOG_ERR_RL(&rl, "failed to create rtnetlink socket: %s",
+ strerror(error));
+ return error;
+ }
+ }
+
+ ofpbuf_init(&request, 0);
+ nl_msg_put_nlmsghdr(&request, rtnl_sock, sizeof *ifi,
+ RTM_GETLINK, NLM_F_REQUEST);
+ ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
+ ifi->ifi_family = PF_UNSPEC;
+ ifi->ifi_index = ifindex;
+ error = nl_sock_transact(rtnl_sock, &request, &reply);
+ ofpbuf_uninit(&request);
+ if (error) {
+ return error;
+ }
+
+ if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
+ rtnlgrp_link_policy,
+ attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
+ ofpbuf_delete(reply);
+ return EPROTO;
+ }
+
+ if (!attrs[IFLA_STATS]) {
+ VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
+ return EPROTO;
+ }
+
+ rtnl_stats = nl_attr_get(attrs[IFLA_STATS]);
+ stats->rx_packets = rtnl_stats->rx_packets;
+ stats->tx_packets = rtnl_stats->tx_packets;
+ stats->rx_bytes = rtnl_stats->rx_bytes;
+ stats->tx_bytes = rtnl_stats->tx_bytes;
+ stats->rx_errors = rtnl_stats->rx_errors;
+ stats->tx_errors = rtnl_stats->tx_errors;
+ stats->rx_dropped = rtnl_stats->rx_dropped;
+ stats->tx_dropped = rtnl_stats->tx_dropped;
+ stats->multicast = rtnl_stats->multicast;
+ stats->collisions = rtnl_stats->collisions;
+ stats->rx_length_errors = rtnl_stats->rx_length_errors;
+ stats->rx_over_errors = rtnl_stats->rx_over_errors;
+ stats->rx_crc_errors = rtnl_stats->rx_crc_errors;
+ stats->rx_frame_errors = rtnl_stats->rx_frame_errors;
+ stats->rx_fifo_errors = rtnl_stats->rx_fifo_errors;
+ stats->rx_missed_errors = rtnl_stats->rx_missed_errors;
+ stats->tx_aborted_errors = rtnl_stats->tx_aborted_errors;
+ stats->tx_carrier_errors = rtnl_stats->tx_carrier_errors;
+ stats->tx_fifo_errors = rtnl_stats->tx_fifo_errors;
+ stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors;
+ stats->tx_window_errors = rtnl_stats->tx_window_errors;
+
+ return 0;
+}
+
+static int
+get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
+{
+ static const char fn[] = "/proc/net/dev";
+ char line[1024];
+ FILE *stream;
+ int ln;
+
+ stream = fopen(fn, "r");
+ if (!stream) {
+ VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
+ return errno;
+ }
+
+ ln = 0;
+ while (fgets(line, sizeof line, stream)) {
+ if (++ln >= 3) {
+ char devname[16];
+#define X64 "%"SCNu64
+ if (sscanf(line,
+ " %15[^:]:"
+ X64 X64 X64 X64 X64 X64 X64 "%*u"
+ X64 X64 X64 X64 X64 X64 X64 "%*u",
+ devname,
+ &stats->rx_bytes,
+ &stats->rx_packets,
+ &stats->rx_errors,
+ &stats->rx_dropped,
+ &stats->rx_fifo_errors,
+ &stats->rx_frame_errors,
+ &stats->multicast,
+ &stats->tx_bytes,
+ &stats->tx_packets,
+ &stats->tx_errors,
+ &stats->tx_dropped,
+ &stats->tx_fifo_errors,
+ &stats->collisions,
+ &stats->tx_carrier_errors) != 15) {
+ VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
+ } else if (!strcmp(devname, netdev_name)) {
+ stats->rx_length_errors = UINT64_MAX;
+ stats->rx_over_errors = UINT64_MAX;
+ stats->rx_crc_errors = UINT64_MAX;
+ stats->rx_missed_errors = UINT64_MAX;
+ stats->tx_aborted_errors = UINT64_MAX;
+ stats->tx_heartbeat_errors = UINT64_MAX;
+ stats->tx_window_errors = UINT64_MAX;
+ fclose(stream);
+ return 0;
+ }
+ }
+ }
+ VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
+ fclose(stream);
+ return ENODEV;
+}
+\f
+static int
+get_flags(const struct netdev *netdev, int *flags)
+{
+ struct ifreq ifr;
+ int error;
+
+ error = netdev_linux_do_ioctl(netdev, &ifr, SIOCGIFFLAGS, "SIOCGIFFLAGS");
+ *flags = ifr.ifr_flags;
+ return error;
+}
+
+static int
+set_flags(struct netdev *netdev, int flags)
+{
+ struct ifreq ifr;
+
+ ifr.ifr_flags = flags;
+ return netdev_linux_do_ioctl(netdev, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
+}
+
+static int
+do_get_ifindex(const char *netdev_name)
+{
+ struct ifreq ifr;
+
+ strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
+ COVERAGE_INC(netdev_get_ifindex);
+ if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
+ VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
+ netdev_name, strerror(errno));
+ return -errno;
+ }
+ return ifr.ifr_ifindex;
+}
+
+static int
+get_ifindex(const struct netdev *netdev_, int *ifindexp)
+{
+ struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ *ifindexp = 0;
+ if (!(netdev->cache->valid & VALID_IFINDEX)) {
+ int ifindex = do_get_ifindex(netdev_get_name(netdev_));
+ if (ifindex < 0) {
+ return -ifindex;
+ }
+ netdev->cache->valid |= VALID_IFINDEX;
+ netdev->cache->ifindex = ifindex;
+ }
+ *ifindexp = netdev->cache->ifindex;
+ return 0;
+}
+
+static int
+get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
+{
+ struct ifreq ifr;
+ int hwaddr_family;
+
+ memset(&ifr, 0, sizeof ifr);
+ strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
+ COVERAGE_INC(netdev_get_hwaddr);
+ if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
+ VLOG_ERR("ioctl(SIOCGIFHWADDR) on %s device failed: %s",
+ netdev_name, strerror(errno));
+ return errno;
+ }
+ hwaddr_family = ifr.ifr_hwaddr.sa_family;
+ if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
+ VLOG_WARN("%s device has unknown hardware address family %d",
+ netdev_name, hwaddr_family);
+ }
+ memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
+ return 0;
+}
+
+static int
+set_etheraddr(const char *netdev_name, int hwaddr_family,
+ const uint8_t mac[ETH_ADDR_LEN])
+{
+ struct ifreq ifr;
+
+ memset(&ifr, 0, sizeof ifr);
+ strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
+ ifr.ifr_hwaddr.sa_family = hwaddr_family;
+ memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
+ COVERAGE_INC(netdev_set_hwaddr);
+ if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
+ VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
+ netdev_name, strerror(errno));
+ return errno;
+ }
+ return 0;
+}
+
+static int
+netdev_linux_do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd,
+ int cmd, const char *cmd_name)
+{
+ struct ifreq ifr;
+
+ memset(&ifr, 0, sizeof ifr);
+ strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
+ ifr.ifr_data = (caddr_t) ecmd;
+
+ ecmd->cmd = cmd;
+ COVERAGE_INC(netdev_ethtool);
+ if (ioctl(af_inet_sock, SIOCETHTOOL, &ifr) == 0) {
+ return 0;
+ } else {
+ if (errno != EOPNOTSUPP) {
+ VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
+ "failed: %s", cmd_name, netdev->name,
+ strerror(errno));
+ } else {
+ /* The device doesn't support this operation. That's pretty
+ * common, so there's no point in logging anything. */
+ }
+ return errno;
+ }
+}
+
+static int
+netdev_linux_do_ioctl(const struct netdev *netdev, struct ifreq *ifr,
+ int cmd, const char *cmd_name)
+{
+ strncpy(ifr->ifr_name, netdev_get_name(netdev), sizeof ifr->ifr_name);
+ if (ioctl(af_inet_sock, cmd, ifr) == -1) {
+ VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s",
+ netdev_get_name(netdev), cmd_name, strerror(errno));
+ return errno;
+ }
+ return 0;
+}
++
++static int
++netdev_linux_get_ipv4(const struct netdev *netdev, struct in_addr *ip,
++ int cmd, const char *cmd_name)
++{
++ struct ifreq ifr;
++ int error;
++
++ ifr.ifr_addr.sa_family = AF_INET;
++ error = netdev_linux_do_ioctl(netdev, &ifr, cmd, cmd_name);
++ if (!error) {
++ const struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
++ *ip = sin->sin_addr;
++ }
++ return error;
++}
--- /dev/null
- /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address.
+/*
+ * Copyright (c) 2009 Nicira Networks.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NETDEV_PROVIDER_H
+#define NETDEV_PROVIDER_H 1
+
+/* Generic interface to network devices. */
+
+#include <assert.h>
+#include "netdev.h"
+#include "list.h"
+
+/* A network device (e.g. an Ethernet device).
+ *
+ * This structure should be treated as opaque by network device
+ * implementations. */
+struct netdev {
+ const struct netdev_class *class;
+ char *name; /* e.g. "eth0" */
+ enum netdev_flags save_flags; /* Initial device flags. */
+ enum netdev_flags changed_flags; /* Flags that we changed. */
+ struct list node; /* Element in global list. */
+};
+
+void netdev_init(struct netdev *, const char *name,
+ const struct netdev_class *);
+static inline void netdev_assert_class(const struct netdev *netdev,
+ const struct netdev_class *class)
+{
+ assert(netdev->class == class);
+}
+
+/* A network device notifier.
+ *
+ * Network device implementations should use netdev_notifier_init() to
+ * initialize this structure, but they may freely read its members after
+ * initialization. */
+struct netdev_notifier {
+ struct netdev *netdev;
+ void (*cb)(struct netdev_notifier *);
+ void *aux;
+};
+void netdev_notifier_init(struct netdev_notifier *, struct netdev *,
+ void (*cb)(struct netdev_notifier *), void *aux);
+
+/* Network device class structure, to be defined by each implementation of a
+ * network device.
+ *
+ * These functions return 0 if successful or a positive errno value on failure,
+ * except where otherwise noted. */
+struct netdev_class {
+ /* Prefix for names of netdevs in this class, e.g. "ndunix:".
+ *
+ * One netdev class may have the empty string "" as its prefix, in which
+ * case that netdev class is associated with netdev names that do not
+ * contain a colon. */
+ const char *prefix;
+
+ /* Class name, for use in error messages. */
+ const char *name;
+
+ /* Called only once, at program startup. Returning an error from this
+ * function will prevent any network device in this class from being
+ * opened.
+ *
+ * This function may be set to null if a network device class needs no
+ * initialization at program startup. */
+ int (*init)(void);
+
+ /* Performs periodic work needed by netdevs of this class. May be null if
+ * no periodic work is necessary. */
+ void (*run)(void);
+
+ /* Arranges for poll_block() to wake up if the "run" member function needs
+ * to be called. May be null if nothing is needed here. */
+ void (*wait)(void);
+
+ /* Attempts to open a network device. On success, sets '*netdevp' to the
+ * new network device. 'name' is the full network device name provided by
+ * the user. This name is useful for error messages but must not be
+ * modified.
+ *
+ * 'suffix' is a copy of 'name' following the netdev's 'prefix'.
+ *
+ * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order
+ * to capture frames of that type received on the device. It may also be
+ * one of the 'enum netdev_pseudo_ethertype' values to receive frames in
+ * one of those categories. */
+ int (*open)(const char *name, char *suffix, int ethertype,
+ struct netdev **netdevp);
+
+ /* Closes 'netdev'. */
+ void (*close)(struct netdev *netdev);
+
+ /* Enumerates the names of all network devices of this class.
+ *
+ * The caller has already initialized 'all_names' and might already have
+ * added some names to it. This function should not disturb any existing
+ * names in 'all_names'.
+ *
+ * If this netdev class does not support enumeration, this may be a null
+ * pointer. */
+ int (*enumerate)(struct svec *all_anmes);
+
+ /* Attempts to receive a packet from 'netdev' into the 'size' bytes in
+ * 'buffer'. If successful, returns the number of bytes in the received
+ * packet, otherwise a negative errno value. Returns -EAGAIN immediately
+ * if no packet is ready to be received. */
+ int (*recv)(struct netdev *netdev, void *buffer, size_t size);
+
+ /* Registers with the poll loop to wake up from the next call to
+ * poll_block() when a packet is ready to be received with netdev_recv() on
+ * 'netdev'. */
+ void (*recv_wait)(struct netdev *netdev);
+
+ /* Discards all packets waiting to be received from 'netdev'. */
+ int (*drain)(struct netdev *netdev);
+
+ /* Sends the 'size'-byte packet in 'buffer' on 'netdev'. Returns 0 if
+ * successful, otherwise a positive errno value. Returns EAGAIN without
+ * blocking if the packet cannot be queued immediately. Returns EMSGSIZE
+ * if a partial packet was transmitted or if the packet is too big or too
+ * small to transmit on the device.
+ *
+ * The caller retains ownership of 'buffer' in all cases.
+ *
+ * The network device is expected to maintain a packet transmission queue,
+ * so that the caller does not ordinarily have to do additional queuing of
+ * packets. */
+ int (*send)(struct netdev *netdev, const void *buffer, size_t size);
+
+ /* Registers with the poll loop to wake up from the next call to
+ * poll_block() when the packet transmission queue for 'netdev' has
+ * sufficient room to transmit a packet with netdev_send().
+ *
+ * The network device is expected to maintain a packet transmission queue,
+ * so that the caller does not ordinarily have to do additional queuing of
+ * packets. Thus, this function is unlikely to ever be useful. */
+ void (*send_wait)(struct netdev *netdev);
+
+ /* Sets 'netdev''s Ethernet address to 'mac' */
+ int (*set_etheraddr)(struct netdev *netdev, const uint8_t mac[6]);
+
+ /* Retrieves 'netdev''s Ethernet address into 'mac'. */
+ int (*get_etheraddr)(const struct netdev *netdev, uint8_t mac[6]);
+
+ /* Retrieves 'netdev''s MTU into '*mtup'.
+ *
+ * The MTU is the maximum size of transmitted (and received) packets, in
+ * bytes, not including the hardware header; thus, this is typically 1500
+ * bytes for Ethernet devices.*/
+ int (*get_mtu)(const struct netdev *, int *mtup);
+
+ /* Sets 'carrier' to true if carrier is active (link light is on) on
+ * 'netdev'. */
+ int (*get_carrier)(const struct netdev *netdev, bool *carrier);
+
+ /* Retrieves current device stats for 'netdev' into 'stats'.
+ *
+ * A network device that supports some statistics but not others, it should
+ * set the values of the unsupported statistics to all-1-bits
+ * (UINT64_MAX). */
+ int (*get_stats)(const struct netdev *netdev, struct netdev_stats *stats);
+
+ /* Stores the features supported by 'netdev' into each of '*current',
+ * '*advertised', '*supported', and '*peer'. Each value is a bitmap of
+ * "enum ofp_port_features" bits, in host byte order. */
+ int (*get_features)(struct netdev *netdev,
+ uint32_t *current, uint32_t *advertised,
+ uint32_t *supported, uint32_t *peer);
+
+ /* Set the features advertised by 'netdev' to 'advertise', which is a
+ * bitmap of "enum ofp_port_features" bits, in host byte order.
+ *
+ * This function may be set to null for a network device that does not
+ * support configuring advertisements. */
+ int (*set_advertisements)(struct netdev *, uint32_t advertise);
+
+ /* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
+ * sets '*vlan_vid' to the VLAN VID associated with that device and returns
+ * 0.
+ *
+ * Returns ENOENT if 'netdev_name' is the name of a network device that is
+ * not a VLAN device.
+ *
+ * This function should be set to null if it doesn't make any sense for
+ * your network device (it probably doesn't). */
+ int (*get_vlan_vid)(const struct netdev *netdev, int *vlan_vid);
+
+ /* Attempts to set input rate limiting (policing) policy, such that up to
+ * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative
+ * burst size of 'kbits' kb.
+ *
+ * This function may be set to null if policing is not supported. */
+ int (*set_policing)(struct netdev *netdev, unsigned int kbits_rate,
+ unsigned int kbits_burst);
+
- int (*get_in4)(const struct netdev *netdev, struct in_addr *in4);
++ /* If 'netdev' has an assigned IPv4 address, sets '*address' to that
++ * address and '*netmask' to the associated netmask.
+ *
+ * The following error values have well-defined meanings:
+ *
+ * - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
+ *
+ * - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
++ int (*get_in4)(const struct netdev *netdev, struct in_addr *address,
++ struct in_addr *netmask);
+
+ /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask. If
+ * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
+ int (*set_in4)(struct netdev *, struct in_addr addr, struct in_addr mask);
+
+ /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address.
+ *
+ * The following error values have well-defined meanings:
+ *
+ * - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
+ *
+ * - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
+ int (*get_in6)(const struct netdev *netdev, struct in6_addr *in6);
+
+ /* Adds 'router' as a default IP gateway for the TCP/IP stack that
+ * corresponds to 'netdev'.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
+ int (*add_router)(struct netdev *netdev, struct in_addr router);
+
++ /* Looks up the next hop for 'host'. If succesful, stores the next hop
++ * gateway's address (0 if 'host' is on a directly connected network) in
++ * '*next_hop' and a copy of the name of the device to reach 'host' in
++ * '*netdev_name', and returns 0. The caller is responsible for freeing
++ * '*netdev_name' (by calling free()).
++ *
++ * This function may be set to null if it would always return EOPNOTSUPP
++ * anyhow. */
++ int (*get_next_hop)(const struct in_addr *host, struct in_addr *next_hop,
++ char **netdev_name);
++
+ /* Looks up the ARP table entry for 'ip' on 'netdev' and stores the
+ * corresponding MAC address in 'mac'. A return value of ENXIO, in
+ * particular, indicates that there is no ARP table entry for 'ip' on
+ * 'netdev'.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
+ int (*arp_lookup)(const struct netdev *, uint32_t ip, uint8_t mac[6]);
+
+ /* Retrieves the current set of flags on 'netdev' into '*old_flags'. Then,
+ * turns off the flags that are set to 1 in 'off' and turns on the flags
+ * that are set to 1 in 'on'. (No bit will be set to 1 in both 'off' and
+ * 'on'; that is, off & on == 0.)
+ *
+ * This function may be invoked from a signal handler. Therefore, it
+ * should not do anything that is not signal-safe (such as logging). */
+ int (*update_flags)(struct netdev *netdev, enum netdev_flags off,
+ enum netdev_flags on, enum netdev_flags *old_flags);
+
+ /* Arranges for 'cb' to be called whenever one of the attributes of
+ * 'netdev' changes and sets '*notifierp' to a newly created
+ * netdev_notifier that represents this arrangement. The created notifier
+ * will have its 'netdev', 'cb', and 'aux' members set to the values of the
+ * corresponding parameters. */
+ int (*poll_add)(struct netdev *netdev,
+ void (*cb)(struct netdev_notifier *), void *aux,
+ struct netdev_notifier **notifierp);
+
+ /* Cancels poll notification for 'notifier'. */
+ void (*poll_remove)(struct netdev_notifier *notifier);
+};
+
+extern const struct netdev_class netdev_linux_class;
+extern const struct netdev_class netdev_tap_class;
+
+#endif /* netdev.h */
#include <assert.h>
#include <errno.h>
-#include <fcntl.h>
-#include <arpa/inet.h>
#include <inttypes.h>
-#include <linux/if_tun.h>
-#include <linux/types.h>
-#include <linux/ethtool.h>
-#include <linux/rtnetlink.h>
-#include <linux/sockios.h>
-#include <linux/version.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <netpacket/packet.h>
-#include <net/ethernet.h>
-#include <net/if.h>
-#include <net/if_arp.h>
-#include <net/if_packet.h>
-#include <net/route.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include "dynamic-string.h"
#include "fatal-signal.h"
#include "list.h"
-#include "netlink.h"
+#include "netdev-provider.h"
#include "ofpbuf.h"
-#include "openflow/openflow.h"
#include "packets.h"
#include "poll-loop.h"
-#include "socket-util.h"
+#include "shash.h"
#include "svec.h"
-/* linux/if.h defines IFF_LOWER_UP, net/if.h doesn't.
- * net/if.h defines if_nameindex(), linux/if.h doesn't.
- * We can't include both headers, so define IFF_LOWER_UP ourselves. */
-#ifndef IFF_LOWER_UP
-#define IFF_LOWER_UP 0x10000
-#endif
-
-/* These were introduced in Linux 2.6.14, so they might be missing if we have
- * old headers. */
-#ifndef ADVERTISED_Pause
-#define ADVERTISED_Pause (1 << 13)
-#endif
-#ifndef ADVERTISED_Asym_Pause
-#define ADVERTISED_Asym_Pause (1 << 14)
-#endif
-
#define THIS_MODULE VLM_netdev
#include "vlog.h"
-struct netdev {
- struct list node;
- char *name;
-
- /* File descriptors. For ordinary network devices, the two fds below are
- * the same; for tap devices, they differ. */
- int netdev_fd; /* Network device. */
- int tap_fd; /* TAP character device, if any, otherwise the
- * network device. */
-
- /* Cached network device information. */
- int ifindex; /* -1 if not known. */
- uint8_t etheraddr[ETH_ADDR_LEN];
- struct in6_addr in6;
- int speed;
- int mtu;
- int txqlen;
- int hwaddr_family;
-
- int save_flags; /* Initial device flags. */
- int changed_flags; /* Flags that we changed. */
-};
-
-/* Policy for RTNLGRP_LINK messages.
- *
- * There are *many* more fields in these messages, but currently we only care
- * about interface names. */
-static const struct nl_policy rtnlgrp_link_policy[] = {
- [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
- [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
- .min_len = sizeof(struct rtnl_link_stats) },
+static const struct netdev_class *netdev_classes[] = {
+ &netdev_linux_class,
+ &netdev_tap_class,
};
+static int n_netdev_classes = ARRAY_SIZE(netdev_classes);
/* All open network devices. */
static struct list netdev_list = LIST_INITIALIZER(&netdev_list);
-/* An AF_INET socket (used for ioctl operations). */
-static int af_inet_sock = -1;
-
-/* NETLINK_ROUTE socket. */
-static struct nl_sock *rtnl_sock;
-
-/* Can we use RTM_GETLINK to get network device statistics? (In pre-2.6.19
- * kernels, this was only available if wireless extensions were enabled.) */
-static bool use_netlink_stats;
-
/* This is set pretty low because we probably won't learn anything from the
* additional log messages. */
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
-static void init_netdev(void);
-static int do_open_netdev(const char *name, int ethertype, int tap_fd,
- struct netdev **netdev_);
+static void restore_all_flags(void *aux);
static int restore_flags(struct netdev *netdev);
-static int get_flags(const char *netdev_name, int *flagsp);
-static int set_flags(const char *netdev_name, int flags);
-static int do_get_ifindex(const char *netdev_name);
-static int get_ifindex(const struct netdev *, int *ifindexp);
-static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN],
- int *hwaddr_familyp);
-static int set_etheraddr(const char *netdev_name, int hwaddr_family,
- const uint8_t[ETH_ADDR_LEN]);
-
-/* Obtains the IPv6 address for 'name' into 'in6'. */
-static void
-get_ipv6_address(const char *name, struct in6_addr *in6)
+
+/* Attempts to initialize the netdev module. Returns 0 if successful,
+ * otherwise a positive errno value.
+ *
+ * Calling this function is optional. If not called explicitly, it will
+ * automatically be called upon the first attempt to open a network device. */
+int
+netdev_initialize(void)
{
- FILE *file;
- char line[128];
-
- file = fopen("/proc/net/if_inet6", "r");
- if (file == NULL) {
- /* This most likely indicates that the host doesn't have IPv6 support,
- * so it's not really a failure condition.*/
- *in6 = in6addr_any;
- return;
- }
+ static int status = -1;
+ if (status < 0) {
+ int i, j;
+
+ fatal_signal_add_hook(restore_all_flags, NULL, true);
- while (fgets(line, sizeof line, file)) {
- uint8_t *s6 = in6->s6_addr;
- char ifname[16 + 1];
-
-#define X8 "%2"SCNx8
- if (sscanf(line, " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
- "%*x %*x %*x %*x %16s\n",
- &s6[0], &s6[1], &s6[2], &s6[3],
- &s6[4], &s6[5], &s6[6], &s6[7],
- &s6[8], &s6[9], &s6[10], &s6[11],
- &s6[12], &s6[13], &s6[14], &s6[15],
- ifname) == 17
- && !strcmp(name, ifname))
- {
- fclose(file);
- return;
+ status = 0;
+ for (i = j = 0; i < n_netdev_classes; i++) {
+ const struct netdev_class *class = netdev_classes[i];
+ if (class->init) {
+ int retval = class->init();
+ if (!retval) {
+ netdev_classes[j++] = class;
+ } else {
+ VLOG_ERR("failed to initialize %s network device "
+ "class: %s", class->name, strerror(retval));
+ if (!status) {
+ status = retval;
+ }
+ }
+ }
}
+ n_netdev_classes = j;
}
- *in6 = in6addr_any;
-
- fclose(file);
+ return status;
}
-static int
-do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd,
- int cmd, const char *cmd_name)
+/* Performs periodic work needed by all the various kinds of netdevs.
+ *
+ * If your program opens any netdevs, it must call this function within its
+ * main poll loop. */
+void
+netdev_run(void)
{
- struct ifreq ifr;
-
- memset(&ifr, 0, sizeof ifr);
- strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
- ifr.ifr_data = (caddr_t) ecmd;
-
- ecmd->cmd = cmd;
- COVERAGE_INC(netdev_ethtool);
- if (ioctl(netdev->netdev_fd, SIOCETHTOOL, &ifr) == 0) {
- return 0;
- } else {
- if (errno != EOPNOTSUPP) {
- VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
- "failed: %s", cmd_name, netdev->name,
- strerror(errno));
- } else {
- /* The device doesn't support this operation. That's pretty
- * common, so there's no point in logging anything. */
+ int i;
+ for (i = 0; i < n_netdev_classes; i++) {
+ const struct netdev_class *class = netdev_classes[i];
+ if (class->run) {
+ class->run();
}
- return errno;
}
}
-static int
-do_get_features(struct netdev *netdev,
- uint32_t *current, uint32_t *advertised,
- uint32_t *supported, uint32_t *peer)
+/* Arranges for poll_block() to wake up when netdev_run() needs to be called.
+ *
+ * If your program opens any netdevs, it must call this function within its
+ * main poll loop. */
+void
+netdev_wait(void)
{
- struct ethtool_cmd ecmd;
- int error;
-
- *current = 0;
- *supported = 0;
- *advertised = 0;
- *peer = 0;
-
- memset(&ecmd, 0, sizeof ecmd);
- error = do_ethtool(netdev, &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET");
- if (error) {
- return error;
- }
-
- if (ecmd.supported & SUPPORTED_10baseT_Half) {
- *supported |= OFPPF_10MB_HD;
- }
- if (ecmd.supported & SUPPORTED_10baseT_Full) {
- *supported |= OFPPF_10MB_FD;
- }
- if (ecmd.supported & SUPPORTED_100baseT_Half) {
- *supported |= OFPPF_100MB_HD;
- }
- if (ecmd.supported & SUPPORTED_100baseT_Full) {
- *supported |= OFPPF_100MB_FD;
- }
- if (ecmd.supported & SUPPORTED_1000baseT_Half) {
- *supported |= OFPPF_1GB_HD;
- }
- if (ecmd.supported & SUPPORTED_1000baseT_Full) {
- *supported |= OFPPF_1GB_FD;
- }
- if (ecmd.supported & SUPPORTED_10000baseT_Full) {
- *supported |= OFPPF_10GB_FD;
- }
- if (ecmd.supported & SUPPORTED_TP) {
- *supported |= OFPPF_COPPER;
- }
- if (ecmd.supported & SUPPORTED_FIBRE) {
- *supported |= OFPPF_FIBER;
- }
- if (ecmd.supported & SUPPORTED_Autoneg) {
- *supported |= OFPPF_AUTONEG;
- }
- if (ecmd.supported & SUPPORTED_Pause) {
- *supported |= OFPPF_PAUSE;
- }
- if (ecmd.supported & SUPPORTED_Asym_Pause) {
- *supported |= OFPPF_PAUSE_ASYM;
- }
-
- /* Set the advertised features */
- if (ecmd.advertising & ADVERTISED_10baseT_Half) {
- *advertised |= OFPPF_10MB_HD;
- }
- if (ecmd.advertising & ADVERTISED_10baseT_Full) {
- *advertised |= OFPPF_10MB_FD;
- }
- if (ecmd.advertising & ADVERTISED_100baseT_Half) {
- *advertised |= OFPPF_100MB_HD;
- }
- if (ecmd.advertising & ADVERTISED_100baseT_Full) {
- *advertised |= OFPPF_100MB_FD;
- }
- if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
- *advertised |= OFPPF_1GB_HD;
- }
- if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
- *advertised |= OFPPF_1GB_FD;
- }
- if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
- *advertised |= OFPPF_10GB_FD;
- }
- if (ecmd.advertising & ADVERTISED_TP) {
- *advertised |= OFPPF_COPPER;
- }
- if (ecmd.advertising & ADVERTISED_FIBRE) {
- *advertised |= OFPPF_FIBER;
- }
- if (ecmd.advertising & ADVERTISED_Autoneg) {
- *advertised |= OFPPF_AUTONEG;
- }
- if (ecmd.advertising & ADVERTISED_Pause) {
- *advertised |= OFPPF_PAUSE;
- }
- if (ecmd.advertising & ADVERTISED_Asym_Pause) {
- *advertised |= OFPPF_PAUSE_ASYM;
- }
-
- /* Set the current features */
- if (ecmd.speed == SPEED_10) {
- *current = (ecmd.duplex) ? OFPPF_10MB_FD : OFPPF_10MB_HD;
- }
- else if (ecmd.speed == SPEED_100) {
- *current = (ecmd.duplex) ? OFPPF_100MB_FD : OFPPF_100MB_HD;
- }
- else if (ecmd.speed == SPEED_1000) {
- *current = (ecmd.duplex) ? OFPPF_1GB_FD : OFPPF_1GB_HD;
- }
- else if (ecmd.speed == SPEED_10000) {
- *current = OFPPF_10GB_FD;
- }
-
- if (ecmd.port == PORT_TP) {
- *current |= OFPPF_COPPER;
- }
- else if (ecmd.port == PORT_FIBRE) {
- *current |= OFPPF_FIBER;
- }
-
- if (ecmd.autoneg) {
- *current |= OFPPF_AUTONEG;
+ int i;
+ for (i = 0; i < n_netdev_classes; i++) {
+ const struct netdev_class *class = netdev_classes[i];
+ if (class->wait) {
+ class->wait();
+ }
}
- return 0;
}
/* Opens the network device named 'name' (e.g. "eth0") and returns zero if
* the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
* categories. */
int
-netdev_open(const char *name, int ethertype, struct netdev **netdevp)
-{
- if (!strncmp(name, "tap:", 4)) {
- return netdev_open_tap(name + 4, netdevp);
- } else {
- return do_open_netdev(name, ethertype, -1, netdevp);
- }
-}
-
-/* Opens a TAP virtual network device. If 'name' is a nonnull, non-empty
- * string, attempts to assign that name to the TAP device (failing if the name
- * is already in use); otherwise, a name is automatically assigned. Returns
- * zero if successful, otherwise a positive errno value. On success, sets
- * '*netdevp' to the new network device, otherwise to null. */
-int
-netdev_open_tap(const char *name, struct netdev **netdevp)
-{
- static const char tap_dev[] = "/dev/net/tun";
- struct ifreq ifr;
- int error;
- int tap_fd;
-
- tap_fd = open(tap_dev, O_RDWR);
- if (tap_fd < 0) {
- ovs_error(errno, "opening \"%s\" failed", tap_dev);
- return errno;
- }
-
- memset(&ifr, 0, sizeof ifr);
- ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
- if (name) {
- strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
- }
- if (ioctl(tap_fd, TUNSETIFF, &ifr) < 0) {
- int error = errno;
- ovs_error(error, "ioctl(TUNSETIFF) on \"%s\" failed", tap_dev);
- close(tap_fd);
- return error;
- }
-
- error = set_nonblocking(tap_fd);
- if (error) {
- ovs_error(error, "set_nonblocking on \"%s\" failed", tap_dev);
- close(tap_fd);
- return error;
- }
-
- error = do_open_netdev(ifr.ifr_name, NETDEV_ETH_TYPE_NONE, tap_fd,
- netdevp);
- if (error) {
- close(tap_fd);
- }
- return error;
-}
-
-static int
-do_open_netdev(const char *name, int ethertype, int tap_fd,
- struct netdev **netdev_)
+netdev_open(const char *name_, int ethertype, struct netdev **netdevp)
{
- int netdev_fd;
- struct sockaddr_ll sll;
- struct ifreq ifr;
- int ifindex = -1;
- uint8_t etheraddr[ETH_ADDR_LEN];
- struct in6_addr in6;
- int mtu;
- int txqlen;
- int hwaddr_family;
+ char *name = xstrdup(name_);
+ char *prefix, *suffix, *colon;
+ struct netdev *netdev = NULL;
int error;
- struct netdev *netdev;
+ int i;
- init_netdev();
- *netdev_ = NULL;
- COVERAGE_INC(netdev_open);
-
- /* Create raw socket. */
- netdev_fd = socket(PF_PACKET, SOCK_RAW,
- htons(ethertype == NETDEV_ETH_TYPE_NONE ? 0
- : ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL
- : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2
- : ethertype));
- if (netdev_fd < 0) {
- return errno;
+ netdev_initialize();
+ colon = strchr(name, ':');
+ if (colon) {
+ *colon = '\0';
+ prefix = name;
+ suffix = colon + 1;
+ } else {
+ prefix = "";
+ suffix = name;
}
- if (ethertype != NETDEV_ETH_TYPE_NONE) {
- /* Set non-blocking mode. */
- error = set_nonblocking(netdev_fd);
- if (error) {
- goto error_already_set;
- }
-
- /* Get ethernet device index. */
- ifindex = do_get_ifindex(name);
- if (ifindex < 0) {
- return -ifindex;
- }
-
- /* Bind to specific ethernet device. */
- memset(&sll, 0, sizeof sll);
- sll.sll_family = AF_PACKET;
- sll.sll_ifindex = ifindex;
- if (bind(netdev_fd, (struct sockaddr *) &sll, sizeof sll) < 0) {
- VLOG_ERR("bind to %s failed: %s", name, strerror(errno));
- goto error;
- }
-
- /* Between the socket() and bind() calls above, the socket receives all
- * packets of the requested type on all system interfaces. We do not
- * want to receive that data, but there is no way to avoid it. So we
- * must now drain out the receive queue. */
- error = drain_rcvbuf(netdev_fd);
- if (error) {
- goto error_already_set;
+ for (i = 0; i < n_netdev_classes; i++) {
+ const struct netdev_class *class = netdev_classes[i];
+ if (!strcmp(prefix, class->prefix)) {
+ error = class->open(name_, suffix, ethertype, &netdev);
+ goto exit;
}
}
+ error = EAFNOSUPPORT;
- /* Get MAC address. */
- error = get_etheraddr(name, etheraddr, &hwaddr_family);
- if (error) {
- goto error_already_set;
- }
-
- /* Get MTU. */
- strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
- if (ioctl(netdev_fd, SIOCGIFMTU, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCGIFMTU) on %s device failed: %s",
- name, strerror(errno));
- goto error;
- }
- mtu = ifr.ifr_mtu;
-
- /* Get TX queue length. */
- if (ioctl(netdev_fd, SIOCGIFTXQLEN, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCGIFTXQLEN) on %s device failed: %s",
- name, strerror(errno));
- goto error;
- }
- txqlen = ifr.ifr_qlen;
-
- get_ipv6_address(name, &in6);
-
- /* Allocate network device. */
- netdev = xmalloc(sizeof *netdev);
- netdev->name = xstrdup(name);
- netdev->ifindex = ifindex;
- netdev->txqlen = txqlen;
- netdev->hwaddr_family = hwaddr_family;
- netdev->netdev_fd = netdev_fd;
- netdev->tap_fd = tap_fd < 0 ? netdev_fd : tap_fd;
- memcpy(netdev->etheraddr, etheraddr, sizeof etheraddr);
- netdev->mtu = mtu;
- netdev->in6 = in6;
-
- /* Save flags to restore at close or exit. */
- error = get_flags(netdev->name, &netdev->save_flags);
- if (error) {
- goto error_already_set;
- }
- netdev->changed_flags = 0;
- fatal_signal_block();
- list_push_back(&netdev_list, &netdev->node);
- fatal_signal_unblock();
-
- /* Success! */
- *netdev_ = netdev;
- return 0;
-
-error:
- error = errno;
-error_already_set:
- close(netdev_fd);
- if (tap_fd >= 0) {
- close(tap_fd);
- }
+exit:
+ *netdevp = error ? NULL : netdev;
return error;
}
netdev_close(struct netdev *netdev)
{
if (netdev) {
- /* Bring down interface and drop promiscuous mode, if we brought up
- * the interface or enabled promiscuous mode. */
+ char *name;
int error;
+
+ /* Restore flags that we changed, if any. */
fatal_signal_block();
error = restore_flags(netdev);
list_remove(&netdev->node);
}
/* Free. */
- free(netdev->name);
- close(netdev->netdev_fd);
- if (netdev->netdev_fd != netdev->tap_fd) {
- close(netdev->tap_fd);
+ name = netdev->name;
+ netdev->class->close(netdev);
+ free(name);
+ }
+}
+
+/* Returns true if a network device named 'name' exists and may be opened,
+ * otherwise false. */
+bool
+netdev_exists(const char *name)
+{
+ struct netdev *netdev;
+ int error;
+
+ error = netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev);
+ if (!error) {
+ netdev_close(netdev);
+ return true;
+ } else {
+ if (error != ENODEV) {
+ VLOG_WARN("failed to open network device %s: %s",
+ name, strerror(error));
}
- free(netdev);
+ return false;
}
}
-/* Pads 'buffer' out with zero-bytes to the minimum valid length of an
- * Ethernet packet, if necessary. */
-static void
-pad_to_minimum_length(struct ofpbuf *buffer)
+/* Initializes 'svec' with a list of the names of all known network devices. */
+int
+netdev_enumerate(struct svec *svec)
{
- if (buffer->size < ETH_TOTAL_MIN) {
- ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
+ int error;
+ int i;
+
+ svec_init(svec);
+
+ netdev_initialize();
+
+ error = 0;
+ for (i = 0; i < n_netdev_classes; i++) {
+ const struct netdev_class *class = netdev_classes[i];
+ if (class->enumerate) {
+ int retval = class->enumerate(svec);
+ if (retval) {
+ VLOG_WARN("failed to enumerate %s network devices: %s",
+ class->name, strerror(retval));
+ if (!error) {
+ error = retval;
+ }
+ }
+ }
}
+ return error;
}
/* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
int
netdev_recv(struct netdev *netdev, struct ofpbuf *buffer)
{
- ssize_t n_bytes;
+ int retval;
assert(buffer->size == 0);
assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
- do {
- n_bytes = read(netdev->tap_fd,
- ofpbuf_tail(buffer), ofpbuf_tailroom(buffer));
- } while (n_bytes < 0 && errno == EINTR);
- if (n_bytes < 0) {
- if (errno != EAGAIN) {
- VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
- netdev->name, strerror(errno));
- }
- return errno;
- } else {
+
+ retval = netdev->class->recv(netdev,
+ buffer->data, ofpbuf_tailroom(buffer));
+ if (retval >= 0) {
COVERAGE_INC(netdev_received);
- buffer->size += n_bytes;
-
- /* When the kernel internally sends out an Ethernet frame on an
- * interface, it gives us a copy *before* padding the frame to the
- * minimum length. Thus, when it sends out something like an ARP
- * request, we see a too-short frame. So pad it out to the minimum
- * length. */
- pad_to_minimum_length(buffer);
+ buffer->size += retval;
+ if (buffer->size < ETH_TOTAL_MIN) {
+ ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
+ }
return 0;
+ } else {
+ return -retval;
}
}
void
netdev_recv_wait(struct netdev *netdev)
{
- poll_fd_wait(netdev->tap_fd, POLLIN);
+ netdev->class->recv_wait(netdev);
}
/* Discards all packets waiting to be received from 'netdev'. */
int
netdev_drain(struct netdev *netdev)
{
- if (netdev->tap_fd != netdev->netdev_fd) {
- drain_fd(netdev->tap_fd, netdev->txqlen);
- return 0;
- } else {
- return drain_rcvbuf(netdev->netdev_fd);
- }
+ return netdev->class->drain(netdev);
}
/* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive
int
netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
{
- ssize_t n_bytes;
-
- do {
- n_bytes = write(netdev->tap_fd, buffer->data, buffer->size);
- } while (n_bytes < 0 && errno == EINTR);
-
- if (n_bytes < 0) {
- /* The Linux AF_PACKET implementation never blocks waiting for room
- * for packets, instead returning ENOBUFS. Translate this into EAGAIN
- * for the caller. */
- if (errno == ENOBUFS) {
- return EAGAIN;
- } else if (errno != EAGAIN) {
- VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
- netdev->name, strerror(errno));
- }
- return errno;
- } else if (n_bytes != buffer->size) {
- VLOG_WARN_RL(&rl,
- "send partial Ethernet packet (%d bytes of %zu) on %s",
- (int) n_bytes, buffer->size, netdev->name);
- return EMSGSIZE;
- } else {
+ int error = netdev->class->send(netdev, buffer->data, buffer->size);
+ if (!error) {
COVERAGE_INC(netdev_sent);
- return 0;
}
+ return error;
}
/* Registers with the poll loop to wake up from the next call to poll_block()
void
netdev_send_wait(struct netdev *netdev)
{
- if (netdev->tap_fd == netdev->netdev_fd) {
- poll_fd_wait(netdev->tap_fd, POLLOUT);
- } else {
- /* TAP device always accepts packets.*/
- poll_immediate_wake();
- }
+ return netdev->class->send_wait(netdev);
}
/* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful,
int
netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN])
{
- int error = set_etheraddr(netdev->name, netdev->hwaddr_family, mac);
- if (!error) {
- memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
- }
- return error;
+ return netdev->class->set_etheraddr(netdev, mac);
}
+/* Retrieves 'netdev''s MAC address. If successful, returns 0 and copies the
+ * the MAC address into 'mac'. On failure, returns a positive errno value and
+ * clears 'mac' to all-zeros. */
int
-netdev_nodev_set_etheraddr(const char *name, const uint8_t mac[ETH_ADDR_LEN])
+netdev_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN])
{
- init_netdev();
- return set_etheraddr(name, ARPHRD_ETHER, mac);
-}
-
-/* Returns a pointer to 'netdev''s MAC address. The caller must not modify or
- * free the returned buffer. */
-const uint8_t *
-netdev_get_etheraddr(const struct netdev *netdev)
-{
- return netdev->etheraddr;
+ return netdev->class->get_etheraddr(netdev, mac);
}
/* Returns the name of the network device that 'netdev' represents,
return netdev->name;
}
-/* Returns the maximum size of transmitted (and received) packets on 'netdev',
- * in bytes, not including the hardware header; thus, this is typically 1500
- * bytes for Ethernet devices. */
+/* Retrieves the MTU of 'netdev'. The MTU is the maximum size of transmitted
+ * (and received) packets, in bytes, not including the hardware header; thus,
+ * this is typically 1500 bytes for Ethernet devices.
+ *
+ * If successful, returns 0 and stores the MTU size in '*mtup'. On failure,
+ * returns a positive errno value and stores ETH_PAYLOAD_MAX (1500) in
+ * '*mtup'. */
int
-netdev_get_mtu(const struct netdev *netdev)
+netdev_get_mtu(const struct netdev *netdev, int *mtup)
{
- return netdev->mtu;
+ int error = netdev->class->get_mtu(netdev, mtup);
+ if (error) {
+ VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s",
+ netdev_get_name(netdev), strerror(error));
+ *mtup = ETH_PAYLOAD_MAX;
+ }
+ return error;
}
/* Stores the features supported by 'netdev' into each of '*current',
uint32_t *supported, uint32_t *peer)
{
uint32_t dummy[4];
- return do_get_features(netdev,
- current ? current : &dummy[0],
- advertised ? advertised : &dummy[1],
- supported ? supported : &dummy[2],
- peer ? peer : &dummy[3]);
+ return netdev->class->get_features(netdev,
+ current ? current : &dummy[0],
+ advertised ? advertised : &dummy[1],
+ supported ? supported : &dummy[2],
+ peer ? peer : &dummy[3]);
}
+/* Set the features advertised by 'netdev' to 'advertise'. Returns 0 if
+ * successful, otherwise a positive errno value. */
int
netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
{
- struct ethtool_cmd ecmd;
- int error;
-
- memset(&ecmd, 0, sizeof ecmd);
- error = do_ethtool(netdev, &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET");
- if (error) {
- return error;
- }
-
- ecmd.advertising = 0;
- if (advertise & OFPPF_10MB_HD) {
- ecmd.advertising |= ADVERTISED_10baseT_Half;
- }
- if (advertise & OFPPF_10MB_FD) {
- ecmd.advertising |= ADVERTISED_10baseT_Full;
- }
- if (advertise & OFPPF_100MB_HD) {
- ecmd.advertising |= ADVERTISED_100baseT_Half;
- }
- if (advertise & OFPPF_100MB_FD) {
- ecmd.advertising |= ADVERTISED_100baseT_Full;
- }
- if (advertise & OFPPF_1GB_HD) {
- ecmd.advertising |= ADVERTISED_1000baseT_Half;
- }
- if (advertise & OFPPF_1GB_FD) {
- ecmd.advertising |= ADVERTISED_1000baseT_Full;
- }
- if (advertise & OFPPF_10GB_FD) {
- ecmd.advertising |= ADVERTISED_10000baseT_Full;
- }
- if (advertise & OFPPF_COPPER) {
- ecmd.advertising |= ADVERTISED_TP;
- }
- if (advertise & OFPPF_FIBER) {
- ecmd.advertising |= ADVERTISED_FIBRE;
- }
- if (advertise & OFPPF_AUTONEG) {
- ecmd.advertising |= ADVERTISED_Autoneg;
- }
- if (advertise & OFPPF_PAUSE) {
- ecmd.advertising |= ADVERTISED_Pause;
- }
- if (advertise & OFPPF_PAUSE_ASYM) {
- ecmd.advertising |= ADVERTISED_Asym_Pause;
- }
- return do_ethtool(netdev, &ecmd, ETHTOOL_SSET, "ETHTOOL_SSET");
-}
-
-/* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address
- * and '*mask' to the netmask (if they are non-null) and returns true.
- * Otherwise, returns false. */
-bool
-netdev_nodev_get_in4(const char *netdev_name, struct in_addr *in4,
- struct in_addr *mask)
-{
- struct ifreq ifr;
- struct in_addr ip = { INADDR_ANY };
-
- init_netdev();
-
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- ifr.ifr_addr.sa_family = AF_INET;
- COVERAGE_INC(netdev_get_in4);
- if (ioctl(af_inet_sock, SIOCGIFADDR, &ifr) == 0) {
- struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
- ip = sin->sin_addr;
- } else {
- VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFADDR) failed: %s",
- netdev_name, strerror(errno));
- }
- if (in4) {
- *in4 = ip;
- }
-
- if (mask) {
- if (ioctl(af_inet_sock, SIOCGIFNETMASK, &ifr) == 0) {
- struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
- *mask = sin->sin_addr;
- } else {
- VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFNETMASK) failed: %s",
- netdev_name, strerror(errno));
- }
- }
-
- return ip.s_addr != INADDR_ANY;
+ return (netdev->class->set_advertisements
+ ? netdev->class->set_advertisements(netdev, advertise)
+ : EOPNOTSUPP);
}
- /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address and
- * returns 0. Otherwise, returns a positive errno value and sets '*in4' to 0
- * (INADDR_ANY).
-bool
-netdev_get_in4(const struct netdev *netdev, struct in_addr *in4, struct
- in_addr *mask)
-{
- return netdev_nodev_get_in4(netdev->name, in4, mask);
-}
-
-static void
-make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
-{
- struct sockaddr_in sin;
- memset(&sin, 0, sizeof sin);
- sin.sin_family = AF_INET;
- sin.sin_addr = addr;
- sin.sin_port = 0;
-
- memset(sa, 0, sizeof *sa);
- memcpy(sa, &sin, sizeof sin);
-}
-
-static int
-do_set_addr(struct netdev *netdev, int sock,
- int ioctl_nr, const char *ioctl_name, struct in_addr addr)
++/* If 'netdev' has an assigned IPv4 address, sets '*address' to that address
++ * and '*netmask' to its netmask and returns 0. Otherwise, returns a positive
++ * errno value and sets '*address' to 0 (INADDR_ANY).
+ *
+ * The following error values have well-defined meanings:
+ *
+ * - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
+ *
+ * - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
+ *
- * 'in4' may be null, in which case the address itself is not reported. */
++ * 'address' or 'netmask' or both may be null, in which case the address or netmask
++ * is not reported. */
+int
- netdev_get_in4(const struct netdev *netdev, struct in_addr *in4)
++netdev_get_in4(const struct netdev *netdev,
++ struct in_addr *address_, struct in_addr *netmask_)
{
- struct in_addr dummy;
- struct ifreq ifr;
++ struct in_addr address;
++ struct in_addr netmask;
int error;
- strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
- make_in4_sockaddr(&ifr.ifr_addr, addr);
- COVERAGE_INC(netdev_set_in4);
- error = ioctl(sock, ioctl_nr, &ifr) < 0 ? errno : 0;
- if (error) {
- VLOG_WARN("ioctl(%s): %s", ioctl_name, strerror(error));
+ error = (netdev->class->get_in4
- ? netdev->class->get_in4(netdev, in4 ? in4 : &dummy)
++ ? netdev->class->get_in4(netdev, &address, &netmask)
+ : EOPNOTSUPP);
- if (error && in4) {
- in4->s_addr = 0;
++ if (address_) {
++ address_->s_addr = error ? 0 : address.s_addr;
++ }
++ if (netmask_) {
++ netmask_->s_addr = error ? 0 : netmask.s_addr;
}
return error;
}
int
netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
{
- int error;
-
- error = do_set_addr(netdev, af_inet_sock,
- SIOCSIFADDR, "SIOCSIFADDR", addr);
- if (!error && addr.s_addr != INADDR_ANY) {
- error = do_set_addr(netdev, af_inet_sock,
- SIOCSIFNETMASK, "SIOCSIFNETMASK", mask);
- }
- return error;
+ return (netdev->class->set_in4
+ ? netdev->class->set_in4(netdev, addr, mask)
+ : EOPNOTSUPP);
}
-/* Adds 'router' as a default IP gateway. */
+/* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
+ * to 'netdev'. */
int
-netdev_add_router(struct in_addr router)
+netdev_add_router(struct netdev *netdev, struct in_addr router)
{
- struct in_addr any = { INADDR_ANY };
- struct rtentry rt;
- int error;
-
- memset(&rt, 0, sizeof rt);
- make_in4_sockaddr(&rt.rt_dst, any);
- make_in4_sockaddr(&rt.rt_gateway, router);
- make_in4_sockaddr(&rt.rt_genmask, any);
- rt.rt_flags = RTF_UP | RTF_GATEWAY;
COVERAGE_INC(netdev_add_router);
- error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
+ return (netdev->class->add_router
+ ? netdev->class->add_router(netdev, router)
+ : EOPNOTSUPP);
+}
+
++/* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to
++ * 'netdev'. If a route cannot not be determined, sets '*next_hop' to 0,
++ * '*netdev_name' to null, and returns a positive errno value. Otherwise, if a
++ * next hop is found, stores the next hop gateway's address (0 if 'host' is on
++ * a directly connected network) in '*next_hop' and a copy of the name of the
++ * device to reach 'host' in '*netdev_name', and returns 0. The caller is
++ * responsible for freeing '*netdev_name' (by calling free()). */
++int
++netdev_get_next_hop(const struct netdev *netdev,
++ const struct in_addr *host, struct in_addr *next_hop,
++ char **netdev_name)
++{
++ int error = (netdev->class->get_next_hop
++ ? netdev->class->get_next_hop(host, next_hop, netdev_name)
++ : EOPNOTSUPP);
+ if (error) {
- VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error));
++ next_hop->s_addr = 0;
++ *netdev_name = NULL;
+ }
+ return error;
+ }
+
-/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
- * 'in6' is non-null) and returns true. Otherwise, returns false. */
-bool
-netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
-{
- if (in6) {
- *in6 = netdev->in6;
- }
- return memcmp(&netdev->in6, &in6addr_any, sizeof netdev->in6) != 0;
-}
-
-/* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
- * Returns 0 if successful, otherwise a positive errno value. On failure,
- * stores 0 into '*flagsp'. */
+/* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and
+ * returns 0. Otherwise, returns a positive errno value and sets '*in6' to
+ * all-zero-bits (in6addr_any).
+ *
+ * The following error values have well-defined meanings:
+ *
+ * - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
+ *
+ * - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
+ *
+ * 'in6' may be null, in which case the address itself is not reported. */
int
-netdev_get_flags(const struct netdev *netdev, enum netdev_flags *flagsp)
+netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
{
- return netdev_nodev_get_flags(netdev->name, flagsp);
-}
+ struct in6_addr dummy;
+ int error;
-static int
-nd_to_iff_flags(enum netdev_flags nd)
-{
- int iff = 0;
- if (nd & NETDEV_UP) {
- iff |= IFF_UP;
+ error = (netdev->class->get_in6
+ ? netdev->class->get_in6(netdev, in6 ? in6 : &dummy)
+ : EOPNOTSUPP);
+ if (error && in6) {
+ memset(in6, 0, sizeof *in6);
}
- if (nd & NETDEV_PROMISC) {
- iff |= IFF_PROMISC;
- }
- return iff;
+ return error;
}
/* On 'netdev', turns off the flags in 'off' and then turns on the flags in
* successful, otherwise a positive errno value. */
static int
do_update_flags(struct netdev *netdev, enum netdev_flags off,
- enum netdev_flags on, bool permanent)
+ enum netdev_flags on, enum netdev_flags *old_flagsp,
+ bool permanent)
{
- int old_flags, new_flags;
+ enum netdev_flags old_flags;
int error;
- error = get_flags(netdev->name, &old_flags);
+ error = netdev->class->update_flags(netdev, off & ~on, on, &old_flags);
if (error) {
- return error;
- }
-
- new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
- if (!permanent) {
- netdev->changed_flags |= new_flags ^ old_flags;
+ VLOG_WARN_RL(&rl, "failed to %s flags for network device %s: %s",
+ off || on ? "set" : "get", netdev_get_name(netdev),
+ strerror(error));
+ old_flags = 0;
+ } else if ((off || on) && !permanent) {
+ enum netdev_flags new_flags = (old_flags & ~off) | on;
+ enum netdev_flags changed_flags = old_flags ^ new_flags;
+ if (changed_flags) {
+ if (!netdev->changed_flags) {
+ netdev->save_flags = old_flags;
+ }
+ netdev->changed_flags |= changed_flags;
+ }
}
- if (new_flags != old_flags) {
- error = set_flags(netdev->name, new_flags);
+ if (old_flagsp) {
+ *old_flagsp = old_flags;
}
return error;
}
+/* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
+ * Returns 0 if successful, otherwise a positive errno value. On failure,
+ * stores 0 into '*flagsp'. */
+int
+netdev_get_flags(const struct netdev *netdev_, enum netdev_flags *flagsp)
+{
+ struct netdev *netdev = (struct netdev *) netdev_;
+ return do_update_flags(netdev, 0, 0, flagsp, false);
+}
+
/* Sets the flags for 'netdev' to 'flags'.
* If 'permanent' is true, the changes will persist; otherwise, they
* will be reverted when 'netdev' is closed or the program exits.
netdev_set_flags(struct netdev *netdev, enum netdev_flags flags,
bool permanent)
{
- return do_update_flags(netdev, -1, flags, permanent);
+ return do_update_flags(netdev, -1, flags, NULL, permanent);
}
/* Turns on the specified 'flags' on 'netdev'.
netdev_turn_flags_on(struct netdev *netdev, enum netdev_flags flags,
bool permanent)
{
- return do_update_flags(netdev, 0, flags, permanent);
+ return do_update_flags(netdev, 0, flags, NULL, permanent);
}
/* Turns off the specified 'flags' on 'netdev'.
netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
bool permanent)
{
- return do_update_flags(netdev, flags, 0, permanent);
+ return do_update_flags(netdev, flags, 0, NULL, permanent);
}
/* Looks up the ARP table entry for 'ip' on 'netdev'. If one exists and can be
* successfully retrieved, it stores the corresponding MAC address in 'mac' and
* returns 0. Otherwise, it returns a positive errno value; in particular,
- * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
-int
-netdev_nodev_arp_lookup(const char *netdev_name, uint32_t ip,
- uint8_t mac[ETH_ADDR_LEN])
-{
- struct arpreq r;
- struct sockaddr_in *pa;
- int retval;
-
- init_netdev();
-
- memset(&r, 0, sizeof r);
- pa = (struct sockaddr_in *) &r.arp_pa;
- pa->sin_family = AF_INET;
- pa->sin_addr.s_addr = ip;
- pa->sin_port = 0;
- r.arp_ha.sa_family = ARPHRD_ETHER;
- r.arp_flags = 0;
- strncpy(r.arp_dev, netdev_name, sizeof r.arp_dev);
- COVERAGE_INC(netdev_arp_lookup);
- retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
- if (!retval) {
- memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
- } else if (retval != ENXIO) {
- VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
- netdev_name, IP_ARGS(&ip), strerror(retval));
- }
- return retval;
-}
-
+ * ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
int
-netdev_arp_lookup(const struct netdev *netdev, uint32_t ip,
- uint8_t mac[ETH_ADDR_LEN])
-{
- return netdev_nodev_arp_lookup(netdev->name, ip, mac);
-}
-
-static int
-get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
+netdev_arp_lookup(const struct netdev *netdev,
+ uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
{
- struct ofpbuf request;
- struct ofpbuf *reply;
- struct ifinfomsg *ifi;
- const struct rtnl_link_stats *rtnl_stats;
- struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
- int error;
-
- ofpbuf_init(&request, 0);
- nl_msg_put_nlmsghdr(&request, rtnl_sock, sizeof *ifi,
- RTM_GETLINK, NLM_F_REQUEST);
- ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
- ifi->ifi_family = PF_UNSPEC;
- ifi->ifi_index = ifindex;
- error = nl_sock_transact(rtnl_sock, &request, &reply);
- ofpbuf_uninit(&request);
+ int error = (netdev->class->arp_lookup
+ ? netdev->class->arp_lookup(netdev, ip, mac)
+ : EOPNOTSUPP);
if (error) {
- return error;
- }
-
- if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
- rtnlgrp_link_policy,
- attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
- ofpbuf_delete(reply);
- return EPROTO;
- }
-
- if (!attrs[IFLA_STATS]) {
- VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
- return EPROTO;
- }
-
- rtnl_stats = nl_attr_get(attrs[IFLA_STATS]);
- stats->rx_packets = rtnl_stats->rx_packets;
- stats->tx_packets = rtnl_stats->tx_packets;
- stats->rx_bytes = rtnl_stats->rx_bytes;
- stats->tx_bytes = rtnl_stats->tx_bytes;
- stats->rx_errors = rtnl_stats->rx_errors;
- stats->tx_errors = rtnl_stats->tx_errors;
- stats->rx_dropped = rtnl_stats->rx_dropped;
- stats->tx_dropped = rtnl_stats->tx_dropped;
- stats->multicast = rtnl_stats->multicast;
- stats->collisions = rtnl_stats->collisions;
- stats->rx_length_errors = rtnl_stats->rx_length_errors;
- stats->rx_over_errors = rtnl_stats->rx_over_errors;
- stats->rx_crc_errors = rtnl_stats->rx_crc_errors;
- stats->rx_frame_errors = rtnl_stats->rx_frame_errors;
- stats->rx_fifo_errors = rtnl_stats->rx_fifo_errors;
- stats->rx_missed_errors = rtnl_stats->rx_missed_errors;
- stats->tx_aborted_errors = rtnl_stats->tx_aborted_errors;
- stats->tx_carrier_errors = rtnl_stats->tx_carrier_errors;
- stats->tx_fifo_errors = rtnl_stats->tx_fifo_errors;
- stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors;
- stats->tx_window_errors = rtnl_stats->tx_window_errors;
-
- return 0;
-}
-
-static int
-get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
-{
- static const char fn[] = "/proc/net/dev";
- char line[1024];
- FILE *stream;
- int ln;
-
- stream = fopen(fn, "r");
- if (!stream) {
- VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
- return errno;
+ memset(mac, 0, ETH_ADDR_LEN);
}
-
- ln = 0;
- while (fgets(line, sizeof line, stream)) {
- if (++ln >= 3) {
- char devname[16];
-#define X64 "%"SCNu64
- if (sscanf(line,
- " %15[^:]:"
- X64 X64 X64 X64 X64 X64 X64 "%*u"
- X64 X64 X64 X64 X64 X64 X64 "%*u",
- devname,
- &stats->rx_bytes,
- &stats->rx_packets,
- &stats->rx_errors,
- &stats->rx_dropped,
- &stats->rx_fifo_errors,
- &stats->rx_frame_errors,
- &stats->multicast,
- &stats->tx_bytes,
- &stats->tx_packets,
- &stats->tx_errors,
- &stats->tx_dropped,
- &stats->tx_fifo_errors,
- &stats->collisions,
- &stats->tx_carrier_errors) != 15) {
- VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
- } else if (!strcmp(devname, netdev_name)) {
- stats->rx_length_errors = UINT64_MAX;
- stats->rx_over_errors = UINT64_MAX;
- stats->rx_crc_errors = UINT64_MAX;
- stats->rx_missed_errors = UINT64_MAX;
- stats->tx_aborted_errors = UINT64_MAX;
- stats->tx_heartbeat_errors = UINT64_MAX;
- stats->tx_window_errors = UINT64_MAX;
- fclose(stream);
- return 0;
- }
- }
- }
- VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
- fclose(stream);
- return ENODEV;
+ return error;
}
+/* Sets 'carrier' to true if carrier is active (link light is on) on
+ * 'netdev'. */
int
netdev_get_carrier(const struct netdev *netdev, bool *carrier)
{
- return netdev_nodev_get_carrier(netdev->name, carrier);
-}
-
-int
-netdev_nodev_get_carrier(const char *netdev_name, bool *carrier)
-{
- char line[8];
- int retval;
- int error;
- char *fn;
- int fd;
-
- *carrier = false;
-
- fn = xasprintf("/sys/class/net/%s/carrier", netdev_name);
- fd = open(fn, O_RDONLY);
- if (fd < 0) {
- error = errno;
- VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(error));
- goto exit;
- }
-
- retval = read(fd, line, sizeof line);
- if (retval < 0) {
- error = errno;
- if (error == EINVAL) {
- /* This is the normal return value when we try to check carrier if
- * the network device is not up. */
- } else {
- VLOG_WARN_RL(&rl, "%s: read failed: %s", fn, strerror(error));
- }
- goto exit_close;
- } else if (retval == 0) {
- error = EPROTO;
- VLOG_WARN_RL(&rl, "%s: unexpected end of file", fn);
- goto exit_close;
- }
-
- if (line[0] != '0' && line[0] != '1') {
- error = EPROTO;
- VLOG_WARN_RL(&rl, "%s: value is %c (expected 0 or 1)", fn, line[0]);
- goto exit_close;
+ int error = (netdev->class->get_carrier
+ ? netdev->class->get_carrier(netdev, carrier)
+ : EOPNOTSUPP);
+ if (error) {
+ *carrier = false;
}
- *carrier = line[0] != '0';
- error = 0;
-
-exit_close:
- close(fd);
-exit:
- free(fn);
return error;
}
+/* Retrieves current device stats for 'netdev'. */
int
netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
{
int error;
COVERAGE_INC(netdev_get_stats);
- if (use_netlink_stats) {
- int ifindex;
-
- error = get_ifindex(netdev, &ifindex);
- if (!error) {
- error = get_stats_via_netlink(ifindex, stats);
- }
- } else {
- error = get_stats_via_proc(netdev->name, stats);
- }
-
+ error = (netdev->class->get_stats
+ ? netdev->class->get_stats(netdev, stats)
+ : EOPNOTSUPP);
if (error) {
memset(stats, 0xff, sizeof *stats);
}
return error;
}
-#define POLICE_ADD_CMD "/sbin/tc qdisc add dev %s handle ffff: ingress"
-#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"
-/* We redirect stderr to /dev/null because we often want to remove all
- * traffic control configuration on a port so its in a known state. If
- * this done when there is no such configuration, tc complains, so we just
- * always ignore it.
- */
-#define POLICE_DEL_CMD "/sbin/tc qdisc del dev %s handle ffff: ingress 2>/dev/null"
-
-/* Attempts to set input rate limiting (policing) policy. */
-int
-netdev_nodev_set_policing(const char *netdev_name, uint32_t kbits_rate,
- uint32_t kbits_burst)
-{
- char command[1024];
-
- init_netdev();
-
- COVERAGE_INC(netdev_set_policing);
- if (kbits_rate) {
- if (!kbits_burst) {
- /* Default to 10 kilobits if not specified. */
- kbits_burst = 10;
- }
-
- /* xxx This should be more careful about only adding if it
- * xxx actually exists, as opposed to always deleting it. */
- snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
- if (system(command) == -1) {
- VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
- }
-
- snprintf(command, sizeof(command), POLICE_ADD_CMD, netdev_name);
- if (system(command) != 0) {
- VLOG_WARN_RL(&rl, "%s: problem adding policing", netdev_name);
- return -1;
- }
-
- snprintf(command, sizeof(command), POLICE_CONFIG_CMD, netdev_name,
- kbits_rate, kbits_burst);
- if (system(command) != 0) {
- VLOG_WARN_RL(&rl, "%s: problem configuring policing",
- netdev_name);
- return -1;
- }
- } else {
- snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
- if (system(command) == -1) {
- VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
- }
- }
-
- return 0;
-}
-
+/* Attempts to set input rate limiting (policing) policy, such that up to
+ * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative burst
+ * size of 'kbits' kb. */
int
netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate,
uint32_t kbits_burst)
{
- return netdev_nodev_set_policing(netdev->name, kbits_rate, kbits_burst);
+ return (netdev->class->set_policing
+ ? netdev->class->set_policing(netdev, kbits_rate, kbits_burst)
+ : EOPNOTSUPP);
}
-/* Initializes 'svec' with a list of the names of all known network devices. */
-void
-netdev_enumerate(struct svec *svec)
+/* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
+ * sets '*vlan_vid' to the VLAN VID associated with that device and returns 0.
+ * Otherwise returns a errno value (specifically ENOENT if 'netdev_name' is the
+ * name of a network device that is not a VLAN device) and sets '*vlan_vid' to
+ * -1. */
+int
+netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
{
- struct if_nameindex *names;
-
- svec_init(svec);
- names = if_nameindex();
- if (names) {
- size_t i;
-
- for (i = 0; names[i].if_name != NULL; i++) {
- svec_add(svec, names[i].if_name);
- }
- if_freenameindex(names);
- } else {
- VLOG_WARN("could not obtain list of network device names: %s",
- strerror(errno));
+ int error = (netdev->class->get_vlan_vid
+ ? netdev->class->get_vlan_vid(netdev, vlan_vid)
+ : ENOENT);
+ if (error) {
+ *vlan_vid = 0;
}
+ return error;
}
-/* Attempts to locate a device based on its IPv4 address. The caller
- * may provide a hint as to the device by setting 'netdev_name' to a
- * likely device name. This string must be malloc'd, since if it is
- * not correct then it will be freed. If there is no hint, then
- * 'netdev_name' must be the NULL pointer.
- *
- * If the device is found, the return value will be true and 'netdev_name'
- * contains the device's name as a string, which the caller is responsible
- * for freeing. If the device is not found, the return value is false. */
-bool
-netdev_find_dev_by_in4(const struct in_addr *in4, char **netdev_name)
+/* Returns a network device that has 'in4' as its IP address, if one exists,
+ * otherwise a null pointer. */
+struct netdev *
+netdev_find_dev_by_in4(const struct in_addr *in4)
{
- int i;
- struct in_addr dev_in4;
+ struct netdev *netdev;
struct svec dev_list;
+ size_t i;
- /* Check the hint first. */
- if (*netdev_name && (netdev_nodev_get_in4(*netdev_name, &dev_in4, NULL))
- && (dev_in4.s_addr == in4->s_addr)) {
- return true;
- }
-
- free(*netdev_name);
- *netdev_name = NULL;
netdev_enumerate(&dev_list);
-
- for (i=0; i<dev_list.n; i++) {
- if ((netdev_nodev_get_in4(dev_list.names[i], &dev_in4, NULL))
- && (dev_in4.s_addr == in4->s_addr)) {
- *netdev_name = xstrdup(dev_list.names[i]);
- svec_destroy(&dev_list);
- return true;
+ for (i = 0; i < dev_list.n; i++) {
+ const char *name = dev_list.names[i];
+ struct in_addr dev_in4;
+
+ if (!netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev)
- && !netdev_get_in4(netdev, &dev_in4)
++ && !netdev_get_in4(netdev, &dev_in4, NULL)
+ && dev_in4.s_addr == in4->s_addr) {
+ goto exit;
}
+ netdev_close(netdev);
}
+ netdev = NULL;
+exit:
svec_destroy(&dev_list);
- return false;
+ return netdev;
}
-
-/* Looks up the next hop for 'ip'. If the next hop can be found, the
- * address is stored in 'next_hop'. If a gateway is not required to
- * reach 'ip', zero is stored in 'next_hop'. In either case, zero is
- * returned and a copy of the name of the device to reach 'ip' is stored
- * in 'netdev_name', which the caller is responsible for freeing. If a
- * route could not be determined, a positive errno is returned. */
-int
-netdev_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
- char **netdev_name)
+\f
+/* Initializes 'netdev' as a netdev named 'name' of the specified 'class'.
+ *
+ * This function adds 'netdev' to a netdev-owned linked list, so it is very
+ * important that 'netdev' only be freed after calling netdev_close(). */
+void
+netdev_init(struct netdev *netdev, const char *name,
+ const struct netdev_class *class)
{
- static const char fn[] = "/proc/net/route";
- FILE *stream;
- char line[256];
- int ln;
-
- *netdev_name = NULL;
- stream = fopen(fn, "r");
- if (stream == NULL) {
- VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
- return errno;
- }
-
- ln = 0;
- while (fgets(line, sizeof line, stream)) {
- if (++ln >= 2) {
- char iface[17];
- uint32_t dest, gateway, mask;
- int refcnt, metric, mtu;
- unsigned int flags, use, window, irtt;
-
- if (sscanf(line,
- "%16s %"SCNx32" %"SCNx32" %04X %d %u %d %"SCNx32
- " %d %u %u\n",
- iface, &dest, &gateway, &flags, &refcnt,
- &use, &metric, &mask, &mtu, &window, &irtt) != 11) {
-
- VLOG_WARN_RL(&rl, "%s: could not parse line %d: %s",
- fn, ln, line);
- continue;
- }
- if (!(flags & RTF_UP)) {
- /* Skip routes that aren't up. */
- continue;
- }
-
- /* The output of 'dest', 'mask', and 'gateway' were given in
- * network byte order, so we don't need need any endian
- * conversions here. */
- if ((dest & mask) == (host->s_addr & mask)) {
- if (!gateway) {
- /* The host is directly reachable. */
- next_hop->s_addr = 0;
- } else {
- /* To reach the host, we must go through a gateway. */
- next_hop->s_addr = gateway;
- }
- *netdev_name = xstrdup(iface);
- fclose(stream);
- return 0;
- }
- }
- }
-
- fclose(stream);
- return ENXIO;
+ netdev->class = class;
+ netdev->name = xstrdup(name);
+ netdev->save_flags = 0;
+ netdev->changed_flags = 0;
+ list_push_back(&netdev_list, &netdev->node);
}
-/* Obtains the current flags for the network device named 'netdev_name' and
- * stores them into '*flagsp'. Returns 0 if successful, otherwise a positive
- * errno value. On error, stores 0 into '*flagsp'.
- *
- * If only device flags are needed, this is more efficient than calling
- * netdev_open(), netdev_get_flags(), netdev_close(). */
-int
-netdev_nodev_get_flags(const char *netdev_name, enum netdev_flags *flagsp)
+/* Initializes 'notifier' as a netdev notifier for 'netdev', for which
+ * notification will consist of calling 'cb', with auxiliary data 'aux'. */
+void
+netdev_notifier_init(struct netdev_notifier *notifier, struct netdev *netdev,
+ void (*cb)(struct netdev_notifier *), void *aux)
{
- int error, flags;
-
- init_netdev();
-
- *flagsp = 0;
- error = get_flags(netdev_name, &flags);
- if (error) {
- return error;
- }
-
- if (flags & IFF_UP) {
- *flagsp |= NETDEV_UP;
- }
- if (flags & IFF_PROMISC) {
- *flagsp |= NETDEV_PROMISC;
- }
- return 0;
+ notifier->netdev = netdev;
+ notifier->cb = cb;
+ notifier->aux = aux;
}
+\f
+/* Tracks changes in the status of a set of network devices. */
+struct netdev_monitor {
+ struct shash polled_netdevs;
+ struct shash changed_netdevs;
+};
-int
-netdev_nodev_get_etheraddr(const char *netdev_name, uint8_t mac[6])
+/* Creates and returns a new structure for monitor changes in the status of
+ * network devices. */
+struct netdev_monitor *
+netdev_monitor_create(void)
{
- init_netdev();
-
- return get_etheraddr(netdev_name, mac, NULL);
+ struct netdev_monitor *monitor = xmalloc(sizeof *monitor);
+ shash_init(&monitor->polled_netdevs);
+ shash_init(&monitor->changed_netdevs);
+ return monitor;
}
-/* If 'netdev_name' is the name of a VLAN network device (e.g. one created with
- * vconfig(8)), sets '*vlan_vid' to the VLAN VID associated with that device
- * and returns 0. Otherwise returns a errno value (specifically ENOENT if
- * 'netdev_name' is the name of a network device that is not a VLAN device) and
- * sets '*vlan_vid' to -1. */
-int
-netdev_get_vlan_vid(const char *netdev_name, int *vlan_vid)
+/* Destroys 'monitor'. */
+void
+netdev_monitor_destroy(struct netdev_monitor *monitor)
{
- struct ds line = DS_EMPTY_INITIALIZER;
- FILE *stream = NULL;
- int error;
- char *fn;
-
- COVERAGE_INC(netdev_get_vlan_vid);
- fn = xasprintf("/proc/net/vlan/%s", netdev_name);
- stream = fopen(fn, "r");
- if (!stream) {
- error = errno;
- goto done;
- }
+ if (monitor) {
+ struct shash_node *node;
- if (ds_get_line(&line, stream)) {
- if (ferror(stream)) {
- error = errno;
- VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno));
- } else {
- error = EPROTO;
- VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn);
+ SHASH_FOR_EACH (node, &monitor->polled_netdevs) {
+ struct netdev_notifier *notifier = node->data;
+ notifier->netdev->class->poll_remove(notifier);
}
- goto done;
- }
- if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) {
- error = EPROTO;
- VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"",
- fn, ds_cstr(&line));
- goto done;
+ shash_destroy(&monitor->polled_netdevs);
+ shash_destroy(&monitor->changed_netdevs);
+ free(monitor);
}
-
- error = 0;
-
-done:
- free(fn);
- if (stream) {
- fclose(stream);
- }
- ds_destroy(&line);
- if (error) {
- *vlan_vid = -1;
- }
- return error;
}
-\f
-static void restore_all_flags(void *aux);
-/* Set up a signal hook to restore network device flags on program
- * termination. */
static void
-init_netdev(void)
+netdev_monitor_cb(struct netdev_notifier *notifier)
{
- static bool inited;
- if (!inited) {
- int ifindex;
- int error;
-
- inited = true;
-
- fatal_signal_add_hook(restore_all_flags, NULL, true);
+ struct netdev_monitor *monitor = notifier->aux;
+ const char *name = netdev_get_name(notifier->netdev);
+ if (!shash_find(&monitor->changed_netdevs, name)) {
+ shash_add(&monitor->changed_netdevs, name, NULL);
+ }
+}
- af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
- if (af_inet_sock < 0) {
- ovs_fatal(errno, "socket(AF_INET)");
+/* Attempts to add 'netdev' as a netdev monitored by 'monitor'. Returns 0 if
+ * successful, otherwise a positive errno value.
+ *
+ * Adding a given 'netdev' to a monitor multiple times is equivalent to adding
+ * it once. */
+int
+netdev_monitor_add(struct netdev_monitor *monitor, struct netdev *netdev)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ int error = 0;
+ if (!shash_find(&monitor->polled_netdevs, netdev_name)
+ && netdev->class->poll_add)
+ {
+ struct netdev_notifier *notifier;
+ error = netdev->class->poll_add(netdev, netdev_monitor_cb, monitor,
+ ¬ifier);
+ if (!error) {
+ assert(notifier->netdev == netdev);
+ shash_add(&monitor->polled_netdevs, netdev_name, notifier);
}
+ }
+ return error;
+}
- error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock);
- if (error) {
- ovs_fatal(error, "socket(AF_NETLINK, NETLINK_ROUTE)");
+/* Removes 'netdev' from the set of netdevs monitored by 'monitor'. (This has
+ * no effect if 'netdev' is not in the set of devices monitored by
+ * 'monitor'.) */
+void
+netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev)
+{
+ const char *netdev_name = netdev_get_name(netdev);
+ struct shash_node *node;
+
+ node = shash_find(&monitor->polled_netdevs, netdev_name);
+ if (node) {
+ /* Cancel future notifications. */
+ struct netdev_notifier *notifier = node->data;
+ netdev->class->poll_remove(notifier);
+ shash_delete(&monitor->polled_netdevs, node);
+
+ /* Drop any pending notification. */
+ node = shash_find(&monitor->changed_netdevs, netdev_name);
+ if (node) {
+ shash_delete(&monitor->changed_netdevs, node);
}
+ }
+}
- /* Decide on the netdev_get_stats() implementation to use. Netlink is
- * preferable, so if that works, we'll use it. */
- ifindex = do_get_ifindex("lo");
- if (ifindex < 0) {
- VLOG_WARN("failed to get ifindex for lo, "
- "obtaining netdev stats from proc");
- use_netlink_stats = false;
- } else {
- struct netdev_stats stats;
- error = get_stats_via_netlink(ifindex, &stats);
- if (!error) {
- VLOG_DBG("obtaining netdev stats via rtnetlink");
- use_netlink_stats = true;
- } else {
- VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats "
- "via proc (you are probably running a pre-2.6.19 "
- "kernel)", strerror(error));
- use_netlink_stats = false;
- }
- }
+/* Checks for changes to netdevs in the set monitored by 'monitor'. If any of
+ * the attributes (Ethernet address, carrier status, speed or peer-advertised
+ * speed, flags, etc.) of a network device monitored by 'monitor' has changed,
+ * sets '*devnamep' to the name of a device that has changed and returns 0.
+ * The caller is responsible for freeing '*devnamep' (with free()).
+ *
+ * If no devices have changed, sets '*devnamep' to NULL and returns EAGAIN.
+ */
+int
+netdev_monitor_poll(struct netdev_monitor *monitor, char **devnamep)
+{
+ struct shash_node *node = shash_first(&monitor->changed_netdevs);
+ if (!node) {
+ *devnamep = NULL;
+ return EAGAIN;
+ } else {
+ *devnamep = xstrdup(node->name);
+ shash_delete(&monitor->changed_netdevs, node);
+ return 0;
}
}
+/* Registers with the poll loop to wake up from the next call to poll_block()
+ * when netdev_monitor_poll(monitor) would indicate that a device has
+ * changed. */
+void
+netdev_monitor_poll_wait(const struct netdev_monitor *monitor)
+{
+ if (!shash_is_empty(&monitor->changed_netdevs)) {
+ poll_immediate_wake();
+ } else {
+ /* XXX Nothing needed here for netdev_linux, but maybe other netdev
+ * classes need help. */
+ }
+}
+\f
/* Restore the network device flags on 'netdev' to those that were active
* before we changed them. Returns 0 if successful, otherwise a positive
* errno value.
static int
restore_flags(struct netdev *netdev)
{
- struct ifreq ifr;
- int restore_flags;
-
- /* Get current flags. */
- strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
- COVERAGE_INC(netdev_get_flags);
- if (ioctl(netdev->netdev_fd, SIOCGIFFLAGS, &ifr) < 0) {
- return errno;
- }
-
- /* Restore flags that we might have changed, if necessary. */
- restore_flags = netdev->changed_flags & (IFF_PROMISC | IFF_UP);
- if ((ifr.ifr_flags ^ netdev->save_flags) & restore_flags) {
- ifr.ifr_flags &= ~restore_flags;
- ifr.ifr_flags |= netdev->save_flags & restore_flags;
- COVERAGE_INC(netdev_set_flags);
- if (ioctl(netdev->netdev_fd, SIOCSIFFLAGS, &ifr) < 0) {
- return errno;
- }
+ if (netdev->changed_flags) {
+ enum netdev_flags restore = netdev->save_flags & netdev->changed_flags;
+ enum netdev_flags old_flags;
+ return netdev->class->update_flags(netdev,
+ netdev->changed_flags & ~restore,
+ restore, &old_flags);
}
-
return 0;
}
restore_flags(netdev);
}
}
-
-static int
-get_flags(const char *netdev_name, int *flags)
-{
- struct ifreq ifr;
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- COVERAGE_INC(netdev_get_flags);
- if (ioctl(af_inet_sock, SIOCGIFFLAGS, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCGIFFLAGS) on %s device failed: %s",
- netdev_name, strerror(errno));
- return errno;
- }
- *flags = ifr.ifr_flags;
- return 0;
-}
-
-static int
-set_flags(const char *netdev_name, int flags)
-{
- struct ifreq ifr;
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- ifr.ifr_flags = flags;
- COVERAGE_INC(netdev_set_flags);
- if (ioctl(af_inet_sock, SIOCSIFFLAGS, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCSIFFLAGS) on %s device failed: %s",
- netdev_name, strerror(errno));
- return errno;
- }
- return 0;
-}
-
-static int
-do_get_ifindex(const char *netdev_name)
-{
- struct ifreq ifr;
-
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- COVERAGE_INC(netdev_get_ifindex);
- if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
- VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
- netdev_name, strerror(errno));
- return -errno;
- }
- return ifr.ifr_ifindex;
-}
-
-static int
-get_ifindex(const struct netdev *netdev, int *ifindexp)
-{
- *ifindexp = 0;
- if (netdev->ifindex < 0) {
- int ifindex = do_get_ifindex(netdev->name);
- if (ifindex < 0) {
- return -ifindex;
- }
- ((struct netdev *) netdev)->ifindex = ifindex;
- }
- *ifindexp = netdev->ifindex;
- return 0;
-}
-
-static int
-get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN],
- int *hwaddr_familyp)
-{
- struct ifreq ifr;
-
- memset(&ifr, 0, sizeof ifr);
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- COVERAGE_INC(netdev_get_hwaddr);
- if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCGIFHWADDR) on %s device failed: %s",
- netdev_name, strerror(errno));
- return errno;
- }
- if (hwaddr_familyp) {
- int hwaddr_family = ifr.ifr_hwaddr.sa_family;
- *hwaddr_familyp = hwaddr_family;
- if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
- VLOG_WARN("%s device has unknown hardware address family %d",
- netdev_name, hwaddr_family);
- }
- }
- memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
- return 0;
-}
-
-static int
-set_etheraddr(const char *netdev_name, int hwaddr_family,
- const uint8_t mac[ETH_ADDR_LEN])
-{
- struct ifreq ifr;
-
- memset(&ifr, 0, sizeof ifr);
- strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
- ifr.ifr_hwaddr.sa_family = hwaddr_family;
- memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
- COVERAGE_INC(netdev_set_hwaddr);
- if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
- VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
- netdev_name, strerror(errno));
- return errno;
- }
- return 0;
-}
enum netdev_flags {
NETDEV_UP = 0x0001, /* Device enabled? */
- NETDEV_PROMISC = 0x0002 /* Promiscuous mode? */
+ NETDEV_PROMISC = 0x0002, /* Promiscuous mode? */
+ NETDEV_LOOPBACK = 0x0004 /* This is a loopback device. */
};
enum netdev_pseudo_ethertype {
NETDEV_ETH_TYPE_802_2 /* Receive all IEEE 802.2 frames. */
};
+/* Network device statistics.
+ *
+ * Values of unsupported statistics are set to all-1-bits (UINT64_MAX). */
struct netdev_stats {
uint64_t rx_packets; /* Total packets received. */
uint64_t tx_packets; /* Total packets transmitted. */
struct netdev;
+int netdev_initialize(void);
+void netdev_run(void);
+void netdev_wait(void);
+
int netdev_open(const char *name, int ethertype, struct netdev **);
-int netdev_open_tap(const char *name, struct netdev **);
void netdev_close(struct netdev *);
+bool netdev_exists(const char *name);
+
+int netdev_enumerate(struct svec *);
+
+const char *netdev_get_name(const struct netdev *);
+int netdev_get_mtu(const struct netdev *, int *mtup);
+
int netdev_recv(struct netdev *, struct ofpbuf *);
void netdev_recv_wait(struct netdev *);
int netdev_drain(struct netdev *);
+
int netdev_send(struct netdev *, const struct ofpbuf *);
void netdev_send_wait(struct netdev *);
+
int netdev_set_etheraddr(struct netdev *, const uint8_t mac[6]);
-const uint8_t *netdev_get_etheraddr(const struct netdev *);
-const char *netdev_get_name(const struct netdev *);
-int netdev_get_mtu(const struct netdev *);
+int netdev_get_etheraddr(const struct netdev *, uint8_t mac[6]);
+
+int netdev_get_carrier(const struct netdev *, bool *carrier);
int netdev_get_features(struct netdev *,
uint32_t *current, uint32_t *advertised,
uint32_t *supported, uint32_t *peer);
int netdev_set_advertisements(struct netdev *, uint32_t advertise);
-bool netdev_get_in4(const struct netdev *, struct in_addr *addr,
- struct in_addr *mask);
-int netdev_set_in4(struct netdev *, struct in_addr in4, struct in_addr mask);
-int netdev_add_router(struct in_addr router);
-bool netdev_get_in6(const struct netdev *, struct in6_addr *);
+
- int netdev_get_in4(const struct netdev *, struct in_addr *);
++int netdev_get_in4(const struct netdev *, struct in_addr *address,
++ struct in_addr *netmask);
+int netdev_set_in4(struct netdev *, struct in_addr addr, struct in_addr mask);
+int netdev_get_in6(const struct netdev *, struct in6_addr *);
+int netdev_add_router(struct netdev *, struct in_addr router);
++int netdev_get_next_hop(const struct netdev *, const struct in_addr *host,
++ struct in_addr *next_hop, char **);
+int netdev_arp_lookup(const struct netdev *, uint32_t ip, uint8_t mac[6]);
+
int netdev_get_flags(const struct netdev *, enum netdev_flags *);
int netdev_set_flags(struct netdev *, enum netdev_flags, bool permanent);
int netdev_turn_flags_on(struct netdev *, enum netdev_flags, bool permanent);
int netdev_turn_flags_off(struct netdev *, enum netdev_flags, bool permanent);
-int netdev_arp_lookup(const struct netdev *, uint32_t ip, uint8_t mac[6]);
-int netdev_get_carrier(const struct netdev *, bool *carrier);
+
int netdev_get_stats(const struct netdev *, struct netdev_stats *);
int netdev_set_policing(struct netdev *, uint32_t kbits_rate,
uint32_t kbits_burst);
-void netdev_enumerate(struct svec *);
-bool netdev_find_dev_by_in4(const struct in_addr *in4, char **netdev_name);
-int netdev_get_next_hop(const struct in_addr *host, struct in_addr *next_hop,
- char **netdev_name);
-int netdev_nodev_get_flags(const char *netdev_name, enum netdev_flags *);
-bool netdev_nodev_get_in4(const char *netdev_name, struct in_addr *in4,
- struct in_addr *mask);
-int netdev_nodev_set_etheraddr(const char *name, const uint8_t mac[6]);
-int netdev_nodev_get_etheraddr(const char *netdev_name, uint8_t mac[6]);
-int netdev_nodev_set_policing(const char *netdev_name, uint32_t kbits_rate,
- uint32_t kbits_burst);
-int netdev_nodev_arp_lookup(const char *netdev_name, uint32_t ip,
- uint8_t mac[6]);
-int netdev_nodev_get_carrier(const char *netdev_name, bool *carrier);
-
-int netdev_get_vlan_vid(const char *netdev_name, int *vlan_vid);
+int netdev_get_vlan_vid(const struct netdev *, int *vlan_vid);
+struct netdev *netdev_find_dev_by_in4(const struct in_addr *);
+
+struct netdev_monitor *netdev_monitor_create(void);
+void netdev_monitor_destroy(struct netdev_monitor *);
+int netdev_monitor_add(struct netdev_monitor *, struct netdev *);
+void netdev_monitor_remove(struct netdev_monitor *, struct netdev *);
+int netdev_monitor_poll(struct netdev_monitor *, char **devnamep);
+void netdev_monitor_poll_wait(const struct netdev_monitor *);
#endif /* netdev.h */
#include <net/if.h>
#include <string.h>
#include <stdlib.h>
+ #include "dhcp.h"
+ #include "dpif.h"
#include "flow.h"
#include "mac-learning.h"
#include "netdev.h"
#include "ofproto.h"
#include "ofpbuf.h"
#include "openflow/openflow.h"
+ #include "openvswitch/datapath-protocol.h"
#include "packets.h"
#include "poll-loop.h"
#include "rconn.h"
#define IB_BASE_PRIORITY 18181800
enum {
- IBR_FROM_LOCAL_PORT, /* Sent by the local port. */
- IBR_OFP_TO_LOCAL, /* Sent to secure channel on local port. */
- IBR_ARP_FROM_LOCAL, /* ARP from the local port. */
- IBR_ARP_FROM_CTL, /* ARP from the controller. */
- IBR_TO_CTL_OFP_SRC, /* To controller, OpenFlow source port. */
- IBR_TO_CTL_OFP_DST, /* To controller, OpenFlow dest port. */
- IBR_FROM_CTL_OFP_SRC, /* From controller, OpenFlow source port. */
- IBR_FROM_CTL_OFP_DST, /* From controller, OpenFlow dest port. */
+ IBR_FROM_LOCAL_DHCP, /* From local port, DHCP. */
+ IBR_TO_LOCAL_ARP, /* To local port, ARP. */
+ IBR_FROM_LOCAL_ARP, /* From local port, ARP. */
+ IBR_TO_REMOTE_ARP, /* To remote MAC, ARP. */
+ IBR_FROM_REMOTE_ARP, /* From remote MAC, ARP. */
+ IBR_TO_CTL_ARP, /* To controller IP, ARP. */
+ IBR_FROM_CTL_ARP, /* From controller IP, ARP. */
+ IBR_TO_CTL_OFP, /* To controller, OpenFlow port. */
+ IBR_FROM_CTL_OFP, /* From controller, OpenFlow port. */
#if OFP_TCP_PORT != OFP_SSL_PORT
#error Need to support separate TCP and SSL flows.
#endif
struct rconn *controller;
struct status_category *ss_cat;
- /* Keeping track of controller's MAC address. */
- uint32_t ip; /* Current IP, 0 if unknown. */
- uint32_t last_ip; /* Last known IP, 0 if never known. */
- uint8_t mac[ETH_ADDR_LEN]; /* Current MAC, 0 if unknown. */
- uint8_t last_mac[ETH_ADDR_LEN]; /* Last known MAC, 0 if never known */
- struct netdev *netdev;
- time_t next_refresh; /* Next time to refresh MAC address. */
+ /* Keep track of local port's information. */
+ uint8_t local_mac[ETH_ADDR_LEN]; /* Current MAC. */
- char local_name[IF_NAMESIZE]; /* Local device name. */
++ struct netdev *local_netdev; /* Local port's network device. */
+ time_t next_local_refresh;
- /* Keeping track of the local port's MAC address. */
- uint8_t local_mac[ETH_ADDR_LEN]; /* Current MAC. */
- time_t next_local_refresh; /* Next time to refresh MAC address. */
+ /* Keep track of controller and next hop's information. */
+ uint32_t controller_ip; /* Controller IP, 0 if unknown. */
+ uint8_t remote_mac[ETH_ADDR_LEN]; /* Remote MAC. */
++ struct netdev *remote_netdev;
+ uint8_t last_remote_mac[ETH_ADDR_LEN]; /* Previous remote MAC. */
+ time_t next_remote_refresh;
/* Rules that we set up. */
struct ib_rule rules[N_IB_RULES];
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
static const uint8_t *
- get_controller_mac(struct in_band *ib)
+ get_remote_mac(struct in_band *ib)
{
- struct in_addr c_in4, r_in4;
- char *dev_name;
+ int retval;
+ bool have_mac;
++ struct in_addr c_in4; /* Controller's IP address. */
++ struct in_addr r_in4; /* Next hop IP address. */
++ char *next_hop_dev;
time_t now = time_now();
- uint32_t controller_ip;
- controller_ip = rconn_get_remote_ip(ib->controller);
- if (controller_ip != ib->ip || now >= ib->next_refresh) {
- bool have_mac;
-
- ib->ip = controller_ip;
-
- /* Look up MAC address. */
- memset(ib->mac, 0, sizeof ib->mac);
- if (ib->ip) {
- struct in_addr local_in4 = { rconn_get_local_ip(ib->controller) };
- struct in_addr in4;
- int retval;
-
- /* Refresh device with IP address 'in4'. */
- if (!ib->netdev
- || netdev_get_in4(ib->netdev, &in4)
- || in4.s_addr != local_in4.s_addr)
- {
- netdev_close(ib->netdev);
- ib->netdev = netdev_find_dev_by_in4(&local_in4);
- }
+ if (now >= ib->next_remote_refresh) {
++ /* Find the next-hop IP address. */
+ c_in4.s_addr = ib->controller_ip;
+ memset(ib->remote_mac, 0, sizeof ib->remote_mac);
- retval = netdev_get_next_hop(&c_in4, &r_in4, &dev_name);
++ retval = netdev_get_next_hop(ib->local_netdev,
++ &c_in4, &r_in4, &next_hop_dev);
+ if (retval) {
+ VLOG_WARN("cannot find route for controller ("IP_FMT"): %s",
+ IP_ARGS(&ib->controller_ip), strerror(retval));
+ ib->next_remote_refresh = now + 1;
+ return NULL;
+ }
+ if (!r_in4.s_addr) {
+ r_in4.s_addr = c_in4.s_addr;
+ }
- if (ib->netdev) {
- retval = netdev_arp_lookup(ib->netdev, ib->ip, ib->mac);
- if (retval) {
- VLOG_DBG_RL(&rl, "cannot look up controller MAC address "
- "("IP_FMT"): %s",
- IP_ARGS(&ib->ip), strerror(retval));
- }
- } else {
- VLOG_DBG_RL(&rl, "cannot find device with IP address "IP_FMT,
- IP_ARGS(&local_in4.s_addr));
- retval = netdev_nodev_arp_lookup(dev_name, r_in4.s_addr,
- ib->remote_mac);
++ /* Get the next-hop IP and network device. */
++ if (!ib->remote_netdev
++ || strcmp(netdev_get_name(ib->remote_netdev), next_hop_dev))
++ {
++ netdev_close(ib->remote_netdev);
++ retval = netdev_open(next_hop_dev, NETDEV_ETH_TYPE_NONE,
++ &ib->remote_netdev);
++ if (retval) {
++ VLOG_WARN_RL(&rl, "cannot open netdev %s (next hop "
++ "to controller "IP_FMT"): %s",
++ next_hop_dev, IP_ARGS(&ib->controller_ip),
++ strerror(retval));
++ ib->next_remote_refresh = now + 1;
++ return NULL;
+ }
+ }
- have_mac = !eth_addr_is_zero(ib->mac);
+
- /* Log changes in IP, MAC addresses. */
- if (ib->ip && ib->ip != ib->last_ip) {
- VLOG_DBG("controller IP address changed from "IP_FMT
- " to "IP_FMT, IP_ARGS(&ib->last_ip), IP_ARGS(&ib->ip));
- ib->last_ip = ib->ip;
++ /* Look up the MAC address of the next-hop IP address. */
++ retval = netdev_arp_lookup(ib->remote_netdev, r_in4.s_addr,
++ ib->remote_mac);
+ if (retval) {
+ VLOG_DBG_RL(&rl, "cannot look up remote MAC address ("IP_FMT"): %s",
+ IP_ARGS(&r_in4.s_addr), strerror(retval));
}
- if (have_mac && memcmp(ib->last_mac, ib->mac, ETH_ADDR_LEN)) {
- VLOG_DBG("controller MAC address changed from "ETH_ADDR_FMT" to "
+ have_mac = !eth_addr_is_zero(ib->remote_mac);
- free(dev_name);
-
- if (have_mac
- && !eth_addr_equals(ib->last_remote_mac, ib->remote_mac)) {
++ free(next_hop_dev);
++ if (have_mac
++ && !eth_addr_equals(ib->last_remote_mac, ib->remote_mac)) {
+ VLOG_DBG("remote MAC address changed from "ETH_ADDR_FMT" to "
ETH_ADDR_FMT,
- ETH_ADDR_ARGS(ib->last_mac), ETH_ADDR_ARGS(ib->mac));
- memcpy(ib->last_mac, ib->mac, ETH_ADDR_LEN);
+ ETH_ADDR_ARGS(ib->last_remote_mac),
+ ETH_ADDR_ARGS(ib->remote_mac));
+ memcpy(ib->last_remote_mac, ib->remote_mac, ETH_ADDR_LEN);
}
/* Schedule next refresh.
* If we have an IP address but not a MAC address, then refresh
* quickly, since we probably will get a MAC address soon (via ARP).
* Otherwise, we can afford to wait a little while. */
- ib->next_refresh = now + (!ib->ip || have_mac ? 10 : 1);
+ ib->next_remote_refresh
+ = now + (!ib->controller_ip || have_mac ? 10 : 1);
}
- return !eth_addr_is_zero(ib->mac) ? ib->mac : NULL;
+
+ return !eth_addr_is_zero(ib->remote_mac) ? ib->remote_mac : NULL;
}
static const uint8_t *
time_t now = time_now();
if (now >= ib->next_local_refresh) {
uint8_t ea[ETH_ADDR_LEN];
- if (ib->netdev && !netdev_get_etheraddr(ib->netdev, ea)) {
- if (!netdev_nodev_get_etheraddr(ib->local_name, ea)) {
++ if (ib->local_netdev && netdev_get_etheraddr(ib->local_netdev, ea)) {
memcpy(ib->local_mac, ea, ETH_ADDR_LEN);
}
ib->next_local_refresh = now + 1;
in_band_status_cb(struct status_reply *sr, void *in_band_)
{
struct in_band *in_band = in_band_;
- const uint8_t *local_mac;
- const uint8_t *controller_mac;
- local_mac = get_local_mac(in_band);
- if (local_mac) {
+ if (!eth_addr_is_zero(in_band->local_mac)) {
status_reply_put(sr, "local-mac="ETH_ADDR_FMT,
- ETH_ADDR_ARGS(local_mac));
+ ETH_ADDR_ARGS(in_band->local_mac));
}
- controller_mac = get_controller_mac(in_band);
- if (controller_mac) {
- status_reply_put(sr, "controller-mac="ETH_ADDR_FMT,
- ETH_ADDR_ARGS(controller_mac));
+ if (!eth_addr_is_zero(in_band->remote_mac)) {
+ status_reply_put(sr, "remote-mac="ETH_ADDR_FMT,
+ ETH_ADDR_ARGS(in_band->remote_mac));
}
}
}
}
+ /* Returns true if 'packet' should be sent to the local port regardless
+ * of the flow table. */
+ bool
+ in_band_msg_in_hook(struct in_band *in_band, const flow_t *flow,
+ const struct ofpbuf *packet)
+ {
+ if (!in_band) {
+ return false;
+ }
+
+ /* Regardless of how the flow table is configured, we want to be
+ * able to see replies to our DHCP requests. */
+ if (flow->dl_type == htons(ETH_TYPE_IP)
+ && flow->nw_proto == IP_TYPE_UDP
+ && flow->tp_src == htons(DHCP_SERVER_PORT)
+ && flow->tp_dst == htons(DHCP_CLIENT_PORT)
+ && packet->l7) {
+ struct dhcp_header *dhcp;
+ const uint8_t *local_mac;
+
+ dhcp = ofpbuf_at(packet, (char *)packet->l7 - (char *)packet->data,
+ sizeof *dhcp);
+ if (!dhcp) {
+ return false;
+ }
+
+ local_mac = get_local_mac(in_band);
+ if (eth_addr_equals(dhcp->chaddr, local_mac)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /* Returns true if the rule that would match 'flow' with 'actions' is
+ * allowed to be set up in the datapath. */
+ bool
+ in_band_rule_check(struct in_band *in_band, const flow_t *flow,
+ const struct odp_actions *actions)
+ {
+ if (!in_band) {
+ return true;
+ }
+
+ /* Don't allow flows that would prevent DHCP replies from being seen
+ * by the local port. */
+ if (flow->dl_type == htons(ETH_TYPE_IP)
+ && flow->nw_proto == IP_TYPE_UDP
+ && flow->tp_src == htons(DHCP_SERVER_PORT)
+ && flow->tp_dst == htons(DHCP_CLIENT_PORT)) {
+ int i;
+
+ for (i=0; i<actions->n_actions; i++) {
+ if (actions->actions[i].output.type == ODPAT_OUTPUT
+ && actions->actions[i].output.port == ODPP_LOCAL) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ return true;
+ }
+
void
in_band_run(struct in_band *in_band)
{
- const uint8_t *controller_mac;
+ time_t now = time_now();
+ uint32_t controller_ip;
+ const uint8_t *remote_mac;
const uint8_t *local_mac;
flow_t flow;
- if (time_now() < MIN(in_band->next_refresh, in_band->next_local_refresh)) {
+ if (now < in_band->next_remote_refresh
+ && now < in_band->next_local_refresh) {
return;
}
- controller_mac = get_controller_mac(in_band);
- local_mac = get_local_mac(in_band);
- /* Switch traffic sent by the local port. */
- memset(&flow, 0, sizeof flow);
- flow.in_port = ODPP_LOCAL;
- setup_flow(in_band, IBR_FROM_LOCAL_PORT, &flow, OFPFW_IN_PORT,
- OFPP_NORMAL);
+ controller_ip = rconn_get_remote_ip(in_band->controller);
+ if (in_band->controller_ip && controller_ip != in_band->controller_ip) {
+ VLOG_DBG("controller IP address changed from "IP_FMT" to "IP_FMT,
+ IP_ARGS(&in_band->controller_ip),
+ IP_ARGS(&controller_ip));
+ }
+ in_band->controller_ip = controller_ip;
+
+ remote_mac = get_remote_mac(in_band);
+ local_mac = get_local_mac(in_band);
if (local_mac) {
- /* Deliver traffic sent to the connection's interface. */
+ /* Allow DHCP requests to be sent from the local port. */
+ memset(&flow, 0, sizeof flow);
+ flow.in_port = ODPP_LOCAL;
+ flow.dl_type = htons(ETH_TYPE_IP);
+ memcpy(flow.dl_src, local_mac, ETH_ADDR_LEN);
+ flow.nw_proto = IP_TYPE_UDP;
+ flow.tp_src = htons(DHCP_CLIENT_PORT);
+ flow.tp_dst = htons(DHCP_SERVER_PORT);
+ setup_flow(in_band, IBR_FROM_LOCAL_DHCP, &flow,
+ (OFPFW_IN_PORT | OFPFW_DL_TYPE | OFPFW_DL_SRC
+ | OFPFW_NW_PROTO | OFPFW_TP_SRC | OFPFW_TP_DST),
+ OFPP_NORMAL);
+
+ /* Allow the connection's interface to receive directed ARP traffic. */
memset(&flow, 0, sizeof flow);
+ flow.dl_type = htons(ETH_TYPE_ARP);
memcpy(flow.dl_dst, local_mac, ETH_ADDR_LEN);
- setup_flow(in_band, IBR_OFP_TO_LOCAL, &flow, OFPFW_DL_DST,
- OFPP_NORMAL);
+ flow.nw_proto = ARP_OP_REPLY;
+ setup_flow(in_band, IBR_TO_LOCAL_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO),
+ OFPP_NORMAL);
/* Allow the connection's interface to be the source of ARP traffic. */
memset(&flow, 0, sizeof flow);
flow.dl_type = htons(ETH_TYPE_ARP);
memcpy(flow.dl_src, local_mac, ETH_ADDR_LEN);
- setup_flow(in_band, IBR_ARP_FROM_LOCAL, &flow,
- OFPFW_DL_TYPE | OFPFW_DL_SRC, OFPP_NORMAL);
+ flow.nw_proto = ARP_OP_REQUEST;
+ setup_flow(in_band, IBR_FROM_LOCAL_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO),
+ OFPP_NORMAL);
+ } else {
+ drop_flow(in_band, IBR_TO_LOCAL_ARP);
+ drop_flow(in_band, IBR_FROM_LOCAL_ARP);
+ }
+
+ if (remote_mac) {
+ /* Allow ARP replies to the remote side's MAC. */
+ memset(&flow, 0, sizeof flow);
+ flow.dl_type = htons(ETH_TYPE_ARP);
+ memcpy(flow.dl_dst, remote_mac, ETH_ADDR_LEN);
+ flow.nw_proto = ARP_OP_REPLY;
+ setup_flow(in_band, IBR_TO_REMOTE_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO),
+ OFPP_NORMAL);
+
+ /* Allow ARP requests from the remote side's MAC. */
+ memset(&flow, 0, sizeof flow);
+ flow.dl_type = htons(ETH_TYPE_ARP);
+ memcpy(flow.dl_src, remote_mac, ETH_ADDR_LEN);
+ flow.nw_proto = ARP_OP_REQUEST;
+ setup_flow(in_band, IBR_FROM_REMOTE_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO),
+ OFPP_NORMAL);
} else {
- drop_flow(in_band, IBR_OFP_TO_LOCAL);
- drop_flow(in_band, IBR_ARP_FROM_LOCAL);
+ drop_flow(in_band, IBR_TO_REMOTE_ARP);
+ drop_flow(in_band, IBR_FROM_REMOTE_ARP);
}
- if (controller_mac) {
- /* Switch ARP requests sent by the controller. (OFPP_NORMAL will "do
- * the right thing" regarding VLANs here.) */
+ if (controller_ip) {
+ /* Allow ARP replies to the controller's IP. */
memset(&flow, 0, sizeof flow);
flow.dl_type = htons(ETH_TYPE_ARP);
- memcpy(flow.dl_dst, eth_addr_broadcast, ETH_ADDR_LEN);
- memcpy(flow.dl_src, controller_mac, ETH_ADDR_LEN);
- setup_flow(in_band, IBR_ARP_FROM_CTL, &flow,
- OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_DL_SRC,
+ flow.nw_proto = ARP_OP_REPLY;
+ flow.nw_dst = controller_ip;
+ setup_flow(in_band, IBR_TO_CTL_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_NW_PROTO | OFPFW_NW_DST_MASK),
OFPP_NORMAL);
+ /* Allow ARP requests from the controller's IP. */
+ memset(&flow, 0, sizeof flow);
+ flow.dl_type = htons(ETH_TYPE_ARP);
+ flow.nw_proto = ARP_OP_REQUEST;
+ flow.nw_src = controller_ip;
+ setup_flow(in_band, IBR_FROM_CTL_ARP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_NW_PROTO | OFPFW_NW_SRC_MASK),
+ OFPP_NORMAL);
+
/* OpenFlow traffic to or from the controller.
*
* (A given field's value is completely ignored if it is wildcarded,
* case here.) */
memset(&flow, 0, sizeof flow);
flow.dl_type = htons(ETH_TYPE_IP);
- memcpy(flow.dl_src, controller_mac, ETH_ADDR_LEN);
- memcpy(flow.dl_dst, controller_mac, ETH_ADDR_LEN);
flow.nw_proto = IP_TYPE_TCP;
+ flow.nw_src = controller_ip;
+ flow.nw_dst = controller_ip;
flow.tp_src = htons(OFP_TCP_PORT);
flow.tp_dst = htons(OFP_TCP_PORT);
- setup_flow(in_band, IBR_TO_CTL_OFP_SRC, &flow,
- (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO
- | OFPFW_TP_SRC), OFPP_NORMAL);
- setup_flow(in_band, IBR_TO_CTL_OFP_DST, &flow,
- (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO
+ setup_flow(in_band, IBR_TO_CTL_OFP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_NW_PROTO | OFPFW_NW_DST_MASK
| OFPFW_TP_DST), OFPP_NORMAL);
- setup_flow(in_band, IBR_FROM_CTL_OFP_SRC, &flow,
- (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO
+ setup_flow(in_band, IBR_FROM_CTL_OFP, &flow,
+ (OFPFW_DL_TYPE | OFPFW_NW_PROTO | OFPFW_NW_SRC_MASK
| OFPFW_TP_SRC), OFPP_NORMAL);
- setup_flow(in_band, IBR_FROM_CTL_OFP_DST, &flow,
- (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO
- | OFPFW_TP_DST), OFPP_NORMAL);
} else {
- drop_flow(in_band, IBR_ARP_FROM_CTL);
- drop_flow(in_band, IBR_TO_CTL_OFP_DST);
- drop_flow(in_band, IBR_TO_CTL_OFP_SRC);
- drop_flow(in_band, IBR_FROM_CTL_OFP_DST);
- drop_flow(in_band, IBR_FROM_CTL_OFP_SRC);
+ drop_flow(in_band, IBR_TO_CTL_ARP);
+ drop_flow(in_band, IBR_FROM_CTL_ARP);
+ drop_flow(in_band, IBR_TO_CTL_OFP);
+ drop_flow(in_band, IBR_FROM_CTL_OFP);
}
}
in_band_wait(struct in_band *in_band)
{
time_t now = time_now();
- time_t wakeup = MIN(in_band->next_refresh, in_band->next_local_refresh);
+ time_t wakeup
+ = MIN(in_band->next_remote_refresh, in_band->next_local_refresh);
if (wakeup > now) {
poll_timer_wait((wakeup - now) * 1000);
} else {
}
}
--void
- in_band_create(struct ofproto *ofproto, struct switch_status *ss,
- struct rconn *controller, struct in_band **in_bandp)
++int
+ in_band_create(struct ofproto *ofproto, struct dpif *dpif,
+ struct switch_status *ss, struct rconn *controller,
+ struct in_band **in_bandp)
{
struct in_band *in_band;
- in_band = xcalloc(1, sizeof *in_band);
- error = dpif_port_get_name(dpif, ODPP_LOCAL, in_band->local_name,
- sizeof in_band->local_name);
++ char local_name[IF_NAMESIZE];
++ struct netdev *local_netdev;
+ int error;
+
- free(in_band);
- return;
++ error = dpif_port_get_name(dpif, ODPP_LOCAL,
++ local_name, sizeof local_name);
+ if (error) {
++ VLOG_ERR("failed to initialize in-band control: cannot get name "
++ "of datapath local port (%s)", strerror(error));
++ return error;
+ }
+
++ error = netdev_open(local_name, NETDEV_ETH_TYPE_NONE, &local_netdev);
++ if (error) {
++ VLOG_ERR("failed to initialize in-band control: cannot open "
++ "datapath local port %s (%s)", local_name, strerror(error));
++ return error;
++ }
+
+ in_band = xcalloc(1, sizeof *in_band);
in_band->ofproto = ofproto;
in_band->controller = controller;
in_band->ss_cat = switch_status_register(ss, "in-band",
in_band_status_cb, in_band);
- in_band->next_refresh = TIME_MIN;
- in_band->next_remote_refresh = TIME_MIN;
++ in_band->local_netdev = local_netdev;
in_band->next_local_refresh = TIME_MIN;
- in_band->netdev = NULL;
++ in_band->remote_netdev = NULL;
++ in_band->next_remote_refresh = TIME_MIN;
*in_bandp = in_band;
++
++ return 0;
}
void
{
if (in_band) {
switch_status_unregister(in_band->ss_cat);
- netdev_close(in_band->netdev);
++ netdev_close(in_band->local_netdev);
++ netdev_close(in_band->remote_netdev);
/* We don't own the rconn. */
}
}
struct dpif;
struct in_band;
+ struct odp_actions;
struct ofproto;
struct rconn;
-struct secchan;
struct settings;
struct switch_status;
- void in_band_create(struct ofproto *, struct switch_status *,
-void in_band_create(struct ofproto *, struct dpif *, struct switch_status *,
-- struct rconn *controller, struct in_band **);
++int in_band_create(struct ofproto *, struct dpif *, struct switch_status *,
++ struct rconn *controller, struct in_band **);
void in_band_destroy(struct in_band *);
void in_band_run(struct in_band *);
+ bool in_band_msg_in_hook(struct in_band *, const flow_t *,
+ const struct ofpbuf *packet);
+ bool in_band_rule_check(struct in_band *, const flow_t *,
+ const struct odp_actions *);
void in_band_wait(struct in_band *);
void in_band_flushed(struct in_band *);
return true;
}
- /* Rules with priority higher than UINT16_MAX are set up by secchan itself
+ /* Rules with priority higher than UINT16_MAX are set up by ofproto itself
* (e.g. by in-band control) and are intentionally hidden from the
* controller. */
if (rule->cr.priority > UINT16_MAX) {
char *serial; /* Serial number. */
/* Datapath. */
- struct dpif dpif;
- struct dpifmon *dpifmon;
+ struct dpif *dpif;
+ struct netdev_monitor *netdev_monitor;
struct port_array ports; /* Index is ODP port nr; ofport->opp.port_no is
* OFP port nr. */
struct shash port_by_name;
static const struct ofhooks default_ofhooks;
-static uint64_t pick_datapath_id(struct dpif *, uint64_t fallback_dpid);
+static uint64_t pick_datapath_id(const struct ofproto *);
static uint64_t pick_fallback_dpid(void);
static void send_packet_in_miss(struct ofpbuf *, void *ofproto);
static void send_packet_in_action(struct ofpbuf *, void *ofproto);
ofproto_create(const char *datapath, const struct ofhooks *ofhooks, void *aux,
struct ofproto **ofprotop)
{
- struct dpifmon *dpifmon;
struct odp_stats stats;
struct ofproto *p;
- struct dpif dpif;
+ struct dpif *dpif;
int error;
*ofprotop = NULL;
VLOG_ERR("failed to open datapath %s: %s", datapath, strerror(error));
return error;
}
- error = dpif_get_dp_stats(&dpif, &stats);
+ error = dpif_get_dp_stats(dpif, &stats);
if (error) {
VLOG_ERR("failed to obtain stats for datapath %s: %s",
datapath, strerror(error));
- dpif_close(&dpif);
+ dpif_close(dpif);
return error;
}
- error = dpif_set_listen_mask(&dpif, ODPL_MISS | ODPL_ACTION);
+ error = dpif_recv_set_mask(dpif, ODPL_MISS | ODPL_ACTION);
if (error) {
VLOG_ERR("failed to listen on datapath %s: %s",
datapath, strerror(error));
- dpif_close(&dpif);
- return error;
- }
- dpif_flow_flush(&dpif);
- dpif_purge(&dpif);
-
- /* Start monitoring datapath ports for status changes. */
- error = dpifmon_create(datapath, &dpifmon);
- if (error) {
- VLOG_ERR("failed to starting monitoring datapath %s: %s",
- datapath, strerror(error));
- dpif_close(&dpif);
+ dpif_close(dpif);
return error;
}
+ dpif_flow_flush(dpif);
+ dpif_recv_purge(dpif);
/* Initialize settings. */
p = xcalloc(1, sizeof *p);
p->fallback_dpid = pick_fallback_dpid();
- p->datapath_id = pick_datapath_id(&dpif, p->fallback_dpid);
- VLOG_INFO("using datapath ID %012"PRIx64, p->datapath_id);
+ p->datapath_id = p->fallback_dpid;
p->manufacturer = xstrdup("Nicira Networks, Inc.");
p->hardware = xstrdup("Reference Implementation");
p->software = xstrdup(VERSION BUILDNR);
/* Initialize datapath. */
p->dpif = dpif;
- p->dpifmon = dpifmon;
+ p->netdev_monitor = netdev_monitor_create();
port_array_init(&p->ports);
shash_init(&p->port_by_name);
p->max_ports = stats.max_ports;
return error;
}
+ /* Pick final datapath ID. */
+ p->datapath_id = pick_datapath_id(p);
+ VLOG_INFO("using datapath ID %012"PRIx64, p->datapath_id);
+
*ofprotop = p;
return 0;
}
ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id)
{
uint64_t old_dpid = p->datapath_id;
- p->datapath_id = (datapath_id
- ? datapath_id
- : pick_datapath_id(&p->dpif, p->fallback_dpid));
+ p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p);
if (p->datapath_id != old_dpid) {
VLOG_INFO("datapath ID changed to %012"PRIx64, p->datapath_id);
rconn_reconnect(p->controller->rconn);
{
if (in_band != (p->in_band != NULL)) {
if (in_band) {
- in_band_create(p, p->switch_status, p->controller->rconn,
- &p->in_band);
- in_band_create(p, &p->dpif, p->switch_status,
- p->controller->rconn, &p->in_band);
-- return 0;
++ return in_band_create(p, p->dpif, p->switch_status,
++ p->controller->rconn, &p->in_band);
} else {
ofproto_set_discovery(p, false, NULL, true);
in_band_destroy(p->in_band);
return error;
}
error = discovery_create(re, update_resolv_conf,
- &p->dpif, p->switch_status,
+ p->dpif, p->switch_status,
&p->discovery);
if (error) {
return error;
ofconn_destroy(ofconn, p);
}
- dpif_close(&p->dpif);
- dpifmon_destroy(p->dpifmon);
+ dpif_close(p->dpif);
+ netdev_monitor_destroy(p->netdev_monitor);
PORT_ARRAY_FOR_EACH (ofport, &p->ports, port_no) {
ofport_free(ofport);
}
return error;
}
+static void
+process_port_change(struct ofproto *ofproto, int error, char *devname)
+{
+ if (error == ENOBUFS) {
+ reinit_ports(ofproto);
+ } else if (!error) {
+ update_port(ofproto, devname);
+ free(devname);
+ }
+}
+
int
ofproto_run1(struct ofproto *p)
{
struct ofpbuf *buf;
int error;
- error = dpif_recv(&p->dpif, &buf);
+ error = dpif_recv(p->dpif, &buf);
if (error) {
if (error == ENODEV) {
/* Someone destroyed the datapath behind our back. The caller
* better destroy us and give up, because we're just going to
* spin from here on out. */
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
- VLOG_ERR_RL(&rl, "dp%u: datapath was destroyed externally",
- dpif_id(&p->dpif));
+ VLOG_ERR_RL(&rl, "%s: datapath was destroyed externally",
+ dpif_name(p->dpif));
return ENODEV;
}
break;
handle_odp_msg(p, buf);
}
- while ((error = dpifmon_poll(p->dpifmon, &devname)) != EAGAIN) {
- if (error == ENOBUFS) {
- reinit_ports(p);
- } else if (!error) {
- update_port(p, devname);
- free(devname);
- }
+ while ((error = dpif_port_poll(p->dpif, &devname)) != EAGAIN) {
+ process_port_change(p, error, devname);
+ }
+ while ((error = netdev_monitor_poll(p->netdev_monitor,
+ &devname)) != EAGAIN) {
+ process_port_change(p, error, devname);
}
if (p->in_band) {
struct ofconn *ofconn;
size_t i;
- dpif_recv_wait(&p->dpif);
- dpifmon_wait(p->dpifmon);
+ dpif_recv_wait(p->dpif);
+ dpif_port_poll_wait(p->dpif);
+ netdev_monitor_poll_wait(p->netdev_monitor);
LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
ofconn_wait(ofconn);
}
/* XXX Should we translate the dpif_execute() errno value into an OpenFlow
* error code? */
- dpif_execute(&p->dpif, flow->in_port, odp_actions.actions,
+ dpif_execute(p->dpif, flow->in_port, odp_actions.actions,
odp_actions.n_actions, packet);
return 0;
}
{
COVERAGE_INC(ofproto_flush);
classifier_for_each(&ofproto->cls, CLS_INC_ALL, destroy_rule, ofproto);
- dpif_flow_flush(&ofproto->dpif);
+ dpif_flow_flush(ofproto->dpif);
if (ofproto->in_band) {
in_band_flushed(ofproto->in_band);
}
PORT_ARRAY_FOR_EACH (ofport, &p->ports, port_no) {
svec_add (&devnames, (char *) ofport->opp.name);
}
- dpif_port_list(&p->dpif, &odp_ports, &n_odp_ports);
+ dpif_port_list(p->dpif, &odp_ports, &n_odp_ports);
for (i = 0; i < n_odp_ports; i++) {
svec_add (&devnames, odp_ports[i].devname);
}
ports[n_ports++] = port_no;
}
}
- dpif_port_group_set(&p->dpif, group, ports, n_ports);
+ dpif_port_group_set(p->dpif, group, ports, n_ports);
free(ports);
}
ofport = xmalloc(sizeof *ofport);
ofport->netdev = netdev;
ofport->opp.port_no = odp_port_to_ofp_port(odp_port->port);
- memcpy(ofport->opp.hw_addr, netdev_get_etheraddr(netdev), ETH_ALEN);
+ netdev_get_etheraddr(netdev, ofport->opp.hw_addr);
memcpy(ofport->opp.name, odp_port->devname,
MIN(sizeof ofport->opp.name, sizeof odp_port->devname));
ofport->opp.name[sizeof ofport->opp.name - 1] = '\0';
static void
ofport_install(struct ofproto *p, struct ofport *ofport)
{
+ netdev_monitor_add(p->netdev_monitor, ofport->netdev);
port_array_set(&p->ports, ofp_port_to_odp_port(ofport->opp.port_no),
ofport);
shash_add(&p->port_by_name, (char *) ofport->opp.name, ofport);
static void
ofport_remove(struct ofproto *p, struct ofport *ofport)
{
+ netdev_monitor_remove(p->netdev_monitor, ofport->netdev);
port_array_set(&p->ports, ofp_port_to_odp_port(ofport->opp.port_no), NULL);
shash_delete(&p->port_by_name,
shash_find(&p->port_by_name, (char *) ofport->opp.name));
COVERAGE_INC(ofproto_update_port);
/* Query the datapath for port information. */
- error = dpif_port_query_by_name(&p->dpif, devname, &odp_port);
+ error = dpif_port_query_by_name(p->dpif, devname, &odp_port);
/* Find the old ofport. */
old_ofport = shash_find_data(&p->port_by_name, devname);
size_t i;
int error;
- error = dpif_port_list(&p->dpif, &ports, &n_ports);
+ error = dpif_port_list(p->dpif, &ports, &n_ports);
if (error) {
return error;
}
}
/* Execute the ODP actions. */
- if (!dpif_execute(&ofproto->dpif, flow->in_port,
+ if (!dpif_execute(ofproto->dpif, flow->in_port,
actions, n_actions, packet)) {
struct odp_flow_stats stats;
flow_extract_stats(flow, packet, &stats);
put->flow.actions = rule->odp_actions;
put->flow.n_actions = rule->n_odp_actions;
put->flags = flags;
- return dpif_flow_put(&ofproto->dpif, put);
+ return dpif_flow_put(ofproto->dpif, put);
}
static void
odp_flow.key = rule->cr.flow;
odp_flow.actions = NULL;
odp_flow.n_actions = 0;
- if (!dpif_flow_del(&p->dpif, &odp_flow)) {
+ if (!dpif_flow_del(p->dpif, &odp_flow)) {
update_stats(rule, &odp_flow.stats);
}
rule->installed = false;
struct rule *super = rule->super;
rule_account(ofproto, rule, 0);
- if (ofproto->netflow) {
+ if (ofproto->netflow && rule->byte_count) {
struct ofexpired expired;
expired.flow = rule->cr.flow;
expired.packet_count = rule->packet_count;
bool drop_frags;
/* Figure out flags. */
- dpif_get_drop_frags(&p->dpif, &drop_frags);
+ dpif_get_drop_frags(p->dpif, &drop_frags);
flags = drop_frags ? OFPC_FRAG_DROP : OFPC_FRAG_NORMAL;
if (ofconn->send_flow_exp) {
flags |= OFPC_SEND_FLOW_EXP;
if (ofconn == p->controller) {
switch (flags & OFPC_FRAG_MASK) {
case OFPC_FRAG_NORMAL:
- dpif_set_drop_frags(&p->dpif, false);
+ dpif_set_drop_frags(p->dpif, false);
break;
case OFPC_FRAG_DROP:
- dpif_set_drop_frags(&p->dpif, true);
+ dpif_set_drop_frags(p->dpif, true);
break;
default:
VLOG_WARN_RL(&rl, "requested bad fragment mode (flags=%"PRIx16")",
ctx.tags = tags ? tags : &no_tags;
ctx.may_setup_flow = true;
do_xlate_actions(in, n_in, &ctx);
+
+ /* Check with in-band control to see if we're allowed to setup this
+ * flow. */
+ if (!in_band_rule_check(ofproto->in_band, flow, out)) {
+ ctx.may_setup_flow = false;
+ }
+
if (may_setup_flow) {
*may_setup_flow = ctx.may_setup_flow;
}
return error;
}
- dpif_execute(&p->dpif, flow.in_port, actions.actions, actions.n_actions,
+ dpif_execute(p->dpif, flow.in_port, actions.actions, actions.n_actions,
&payload);
ofpbuf_delete(buffer);
n_wild = classifier_count(&p->cls) - classifier_count_exact(&p->cls);
/* Hash table. */
- dpif_get_dp_stats(&p->dpif, &dpstats);
+ dpif_get_dp_stats(p->dpif, &dpstats);
ots = append_stats_reply(sizeof *ots, ofconn, &msg);
memset(ots, 0, sizeof *ots);
ots->table_id = TABLEID_HASH;
packet_count = rule->packet_count;
byte_count = rule->byte_count;
- if (!dpif_flow_get_multiple(&p->dpif, odp_flows, n_odp_flows)) {
+ if (!dpif_flow_get_multiple(p->dpif, odp_flows, n_odp_flows)) {
size_t i;
for (i = 0; i < n_odp_flows; i++) {
struct odp_flow *odp_flow = &odp_flows[i];
}
query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
- flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &match);
+ flow_to_ovs_match(&rule->cr.flow, rule->cr.wc.wildcards, &match);
ds_put_format(results, "duration=%llds, ",
(time_msec() - rule->created) / 1000);
- ds_put_format(results, "priority=%u", rule->cr.priority);
+ ds_put_format(results, "priority=%u, ", rule->cr.priority);
ds_put_format(results, "n_packets=%"PRIu64", ", packet_count);
ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
ofp_print_match(results, &match, true);
payload.size = msg->length - sizeof *msg;
flow_extract(&payload, msg->port, &flow);
- dpif_execute(&p->dpif, flow.in_port, &action, 1, &payload);
+ /* Check with in-band control to see if this packet should be sent
+ * to the local port regardless of the flow table. */
+ if (in_band_msg_in_hook(p->in_band, &flow, &payload)) {
+ union odp_action action;
+
+ memset(&action, 0, sizeof(action));
+ action.output.type = ODPAT_OUTPUT;
+ action.output.port = ODPP_LOCAL;
++ dpif_execute(p->dpif, flow.in_port, &action, 1, &payload);
+ }
+
rule = lookup_valid_rule(p, &flow);
if (!rule) {
/* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
{
struct ofconn *ofconn;
struct ofconn *prev;
- struct ofpbuf *buf;
+ struct ofpbuf *buf = NULL;
/* We limit the maximum number of queued flow expirations it by accounting
* them under the counter for replies. That works because preventing
size_t i;
int error;
- error = dpif_flow_list_all(&p->dpif, &flows, &n_flows);
+ error = dpif_flow_list_all(p->dpif, &flows, &n_flows);
if (error) {
return;
}
classifier_find_rule_exactly(&p->cls, &f->key, 0, UINT16_MAX));
if (!rule || !rule->installed) {
COVERAGE_INC(ofproto_unexpected_rule);
- dpif_flow_del(&p->dpif, f);
+ dpif_flow_del(p->dpif, f);
continue;
}
}
static uint64_t
-pick_datapath_id(struct dpif *dpif, uint64_t fallback_dpid)
+pick_datapath_id(const struct ofproto *ofproto)
{
- char local_name[IF_NAMESIZE];
- uint8_t ea[ETH_ADDR_LEN];
- int error;
+ const struct ofport *port;
- error = dpif_get_name(dpif, local_name, sizeof local_name);
- if (!error) {
- error = netdev_nodev_get_etheraddr(local_name, ea);
+ port = port_array_get(&ofproto->ports, ODPP_LOCAL);
+ if (port) {
+ uint8_t ea[ETH_ADDR_LEN];
+ int error;
+
+ error = netdev_get_etheraddr(port->netdev, ea);
if (!error) {
return eth_addr_to_uint64(ea);
}
VLOG_WARN("could not get MAC address for %s (%s)",
- local_name, strerror(error));
+ netdev_get_name(port->netdev), strerror(error));
}
-
- return fallback_dpid;
+ return ofproto->fallback_dpid;
}
static uint64_t
#include "odp-util.h"
#include "ofp-print.h"
#include "ofpbuf.h"
+#include "ofproto/ofproto.h"
#include "packets.h"
#include "poll-loop.h"
#include "port-array.h"
#include "proc-net-compat.h"
#include "process.h"
-#include "secchan/ofproto.h"
#include "socket-util.h"
#include "stp.h"
#include "svec.h"
extern uint64_t mgmt_id;
struct iface {
+ /* These members are always valid. */
struct port *port; /* Containing port. */
size_t port_ifidx; /* Index within containing port. */
-
char *name; /* Host network device name. */
- int dp_ifidx; /* Index within kernel datapath. */
-
- uint8_t mac[ETH_ADDR_LEN]; /* Ethernet address (all zeros if unknowns). */
-
tag_type tag; /* Tag associated with this interface. */
- bool enabled; /* May be chosen for flows? */
long long delay_expires; /* Time after which 'enabled' may change. */
+
+ /* These members are valid only after bridge_reconfigure() causes them to
+ * be initialized.*/
+ int dp_ifidx; /* Index within kernel datapath. */
+ struct netdev *netdev; /* Network device. */
+ bool enabled; /* May be chosen for flows? */
};
#define BOND_MASK 0xff
struct ofproto *ofproto; /* OpenFlow switch. */
/* Kernel datapath information. */
- struct dpif dpif; /* Kernel datapath. */
+ struct dpif *dpif; /* Datapath. */
struct port_array ifaces; /* Indexed by kernel datapath port number. */
/* Bridge ports. */
static void bridge_flush(struct bridge *);
static void bridge_pick_local_hw_addr(struct bridge *,
uint8_t ea[ETH_ADDR_LEN],
- const char **devname);
+ struct iface **hw_addr_iface);
static uint64_t bridge_pick_datapath_id(struct bridge *,
const uint8_t bridge_ea[ETH_ADDR_LEN],
- const char *devname);
+ struct iface *hw_addr_iface);
+static struct iface *bridge_get_local_iface(struct bridge *);
static uint64_t dpid_from_hash(const void *, size_t nbytes);
static void bridge_unixctl_fdb_show(struct unixctl_conn *, const char *args);
uint16_t dp_ifidx);
static void port_update_bond_compat(struct port *);
static void port_update_vlan_compat(struct port *);
+static void port_update_bonding(struct port *);
static void mirror_create(struct bridge *, const char *name);
static void mirror_destroy(struct mirror *);
for (j = 0; j < port->n_ifaces; j++) {
struct iface *iface = port->ifaces[j];
if (iface->dp_ifidx < 0) {
- VLOG_ERR("%s interface not in dp%u, ignoring",
- iface->name, dpif_id(&br->dpif));
+ VLOG_ERR("%s interface not in datapath %s, ignoring",
+ iface->name, dpif_name(br->dpif));
} else {
if (iface->dp_ifidx != ODPP_LOCAL) {
svec_add(svec, iface->name);
void
bridge_init(void)
{
- int retval;
- int i;
-
- bond_init();
+ struct svec dpif_names;
+ size_t i;
unixctl_command_register("fdb/show", bridge_unixctl_fdb_show);
- for (i = 0; i < DP_MAX; i++) {
- struct dpif dpif;
- char devname[16];
+ svec_init(&dpif_names);
+ dp_enumerate(&dpif_names);
+ for (i = 0; i < dpif_names.n; i++) {
+ const char *dpif_name = dpif_names.names[i];
+ struct dpif *dpif;
+ int retval;
- sprintf(devname, "dp%d", i);
- retval = dpif_open(devname, &dpif);
+ retval = dpif_open(dpif_name, &dpif);
if (!retval) {
- char dpif_name[IF_NAMESIZE];
- if (dpif_get_name(&dpif, dpif_name, sizeof dpif_name)
- || !cfg_has("bridge.%s.port", dpif_name)) {
- dpif_delete(&dpif);
+ struct svec all_names;
+ size_t j;
+
+ svec_init(&all_names);
+ dpif_get_all_names(dpif, &all_names);
+ for (j = 0; j < all_names.n; j++) {
+ if (cfg_has("bridge.%s.port", all_names.names[j])) {
+ goto found;
+ }
}
- dpif_close(&dpif);
- } else if (retval != ENODEV) {
- VLOG_ERR("failed to delete datapath dp%d: %s",
- i, strerror(retval));
+ dpif_delete(dpif);
+ found:
+ svec_destroy(&all_names);
+ dpif_close(dpif);
}
}
unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows);
+ bond_init();
bridge_reconfigure();
}
* the old certificate will still be trusted until vSwitch is
* restarted. We may want to address this in vconn's SSL library. */
if (config_string_change("ssl.ca-cert", &cacert_file)
- || (stat(cacert_file, &s) && errno == ENOENT)) {
+ || (cacert_file && stat(cacert_file, &s) && errno == ENOENT)) {
vconn_ssl_set_ca_cert_file(cacert_file,
cfg_get_bool(0, "ssl.bootstrap-ca-cert"));
}
}
#endif
+/* iterate_and_prune_ifaces() callback function that opens the network device
+ * for 'iface', if it is not already open, and retrieves the interface's MAC
+ * address and carrier status. */
+static bool
+init_iface_netdev(struct bridge *br UNUSED, struct iface *iface,
+ void *aux UNUSED)
+{
+ if (iface->netdev) {
+ return true;
+ } else if (!netdev_open(iface->name, NETDEV_ETH_TYPE_NONE,
+ &iface->netdev)) {
+ netdev_get_carrier(iface->netdev, &iface->enabled);
+ return true;
+ } else {
+ /* If the network device can't be opened, then we're not going to try
+ * to do anything with this interface. */
+ return false;
+ }
+}
+
+static bool
+check_iface_dp_ifidx(struct bridge *br, struct iface *iface, void *aux UNUSED)
+{
+ if (iface->dp_ifidx >= 0) {
+ VLOG_DBG("%s has interface %s on port %d",
+ dpif_name(br->dpif),
+ iface->name, iface->dp_ifidx);
+ return true;
+ } else {
+ VLOG_ERR("%s interface not in %s, dropping",
+ iface->name, dpif_name(br->dpif));
+ return false;
+ }
+}
+
+static bool
+set_iface_policing(struct bridge *br UNUSED, struct iface *iface,
+ void *aux UNUSED)
+{
+ int rate = cfg_get_int(0, "port.%s.ingress.policing-rate", iface->name);
+ int burst = cfg_get_int(0, "port.%s.ingress.policing-burst", iface->name);
+ netdev_set_policing(iface->netdev, rate, burst);
+ return true;
+}
+
+/* Calls 'cb' for each interfaces in 'br', passing along the 'aux' argument.
+ * Deletes from 'br' all the interfaces for which 'cb' returns false, and then
+ * deletes from 'br' any ports that no longer have any interfaces. */
+static void
+iterate_and_prune_ifaces(struct bridge *br,
+ bool (*cb)(struct bridge *, struct iface *,
+ void *aux),
+ void *aux)
+{
+ size_t i, j;
+
+ for (i = 0; i < br->n_ports; ) {
+ struct port *port = br->ports[i];
+ for (j = 0; j < port->n_ifaces; ) {
+ struct iface *iface = port->ifaces[j];
+ if (cb(br, iface, aux)) {
+ j++;
+ } else {
+ iface_destroy(iface);
+ }
+ }
+
+ if (port->n_ifaces) {
+ i++;
+ } else {
+ VLOG_ERR("%s port has no interfaces, dropping", port->name);
+ port_destroy(port);
+ }
+ }
+}
+
void
bridge_reconfigure(void)
{
- struct svec old_br, new_br, raw_new_br;
+ struct svec old_br, new_br;
struct bridge *br, *next;
- size_t i, j;
+ size_t i;
COVERAGE_INC(bridge_reconfigure);
- /* Collect old bridges. */
+ /* Collect old and new bridges. */
svec_init(&old_br);
+ svec_init(&new_br);
LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
svec_add(&old_br, br->name);
}
-
- /* Collect new bridges. */
- svec_init(&raw_new_br);
- cfg_get_subsections(&raw_new_br, "bridge");
- svec_init(&new_br);
- for (i = 0; i < raw_new_br.n; i++) {
- const char *name = raw_new_br.names[i];
- if ((!strncmp(name, "dp", 2) && isdigit(name[2])) ||
- (!strncmp(name, "nl:", 3) && isdigit(name[3]))) {
- VLOG_ERR("%s is not a valid bridge name (bridges may not be "
- "named \"dp\" or \"nl:\" followed by a digit)", name);
- } else {
- svec_add(&new_br, name);
- }
- }
- svec_destroy(&raw_new_br);
+ cfg_get_subsections(&new_br, "bridge");
/* Get rid of deleted bridges and add new bridges. */
svec_sort(&old_br);
size_t n_dpif_ports;
struct svec want_ifaces;
- dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
+ dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
bridge_get_all_ifaces(br, &want_ifaces);
for (i = 0; i < n_dpif_ports; i++) {
const struct odp_port *p = &dpif_ports[i];
if (!svec_contains(&want_ifaces, p->devname)
&& strcmp(p->devname, br->name)) {
- int retval = dpif_port_del(&br->dpif, p->port);
+ int retval = dpif_port_del(br->dpif, p->port);
if (retval) {
- VLOG_ERR("failed to remove %s interface from dp%u: %s",
- p->devname, dpif_id(&br->dpif), strerror(retval));
+ VLOG_ERR("failed to remove %s interface from %s: %s",
+ p->devname, dpif_name(br->dpif),
+ strerror(retval));
}
}
}
struct odp_port *dpif_ports;
size_t n_dpif_ports;
struct svec cur_ifaces, want_ifaces, add_ifaces;
- int next_port_no;
- dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
+ dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
svec_init(&cur_ifaces);
for (i = 0; i < n_dpif_ports; i++) {
svec_add(&cur_ifaces, dpif_ports[i].devname);
bridge_get_all_ifaces(br, &want_ifaces);
svec_diff(&want_ifaces, &cur_ifaces, &add_ifaces, NULL, NULL);
- next_port_no = 1;
for (i = 0; i < add_ifaces.n; i++) {
const char *if_name = add_ifaces.names[i];
- for (;;) {
- bool internal;
- int error;
-
- /* It's an internal interface if it's marked that way, or if
- * it's a bonded interface for which we're faking up a network
- * device. */
- internal = cfg_get_bool(0, "iface.%s.internal", if_name);
- if (cfg_get_bool(0, "bonding.%s.fake-iface", if_name)) {
- struct port *port = port_lookup(br, if_name);
- if (port && port->n_ifaces > 1) {
- internal = true;
- }
- }
+ bool internal;
+ int error;
- /* Add to datapath. */
- error = dpif_port_add(&br->dpif, if_name, next_port_no++,
- internal ? ODP_PORT_INTERNAL : 0);
- if (error != EEXIST) {
- if (next_port_no >= 256) {
- VLOG_ERR("ran out of valid port numbers on dp%u",
- dpif_id(&br->dpif));
- goto out;
- }
- if (error) {
- VLOG_ERR("failed to add %s interface to dp%u: %s",
- if_name, dpif_id(&br->dpif), strerror(error));
- }
- break;
+ /* It's an internal interface if it's marked that way, or if
+ * it's a bonded interface for which we're faking up a network
+ * device. */
+ internal = cfg_get_bool(0, "iface.%s.internal", if_name);
+ if (cfg_get_bool(0, "bonding.%s.fake-iface", if_name)) {
+ struct port *port = port_lookup(br, if_name);
+ if (port && port->n_ifaces > 1) {
+ internal = true;
}
}
+
+ /* Add to datapath. */
+ error = dpif_port_add(br->dpif, if_name,
+ internal ? ODP_PORT_INTERNAL : 0, NULL);
+ if (error == EFBIG) {
+ VLOG_ERR("ran out of valid port numbers on %s",
+ dpif_name(br->dpif));
+ break;
+ } else if (error) {
+ VLOG_ERR("failed to add %s interface to %s: %s",
+ if_name, dpif_name(br->dpif), strerror(error));
+ }
}
- out:
svec_destroy(&cur_ifaces);
svec_destroy(&want_ifaces);
svec_destroy(&add_ifaces);
LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
uint8_t ea[8];
uint64_t dpid;
- struct iface *local_iface = NULL;
- const char *devname;
- uint8_t engine_type = br->dpif.minor;
- uint8_t engine_id = br->dpif.minor;
+ struct iface *local_iface;
+ struct iface *hw_addr_iface;
+ uint8_t engine_type, engine_id;
bool add_id_to_iface = false;
struct svec nf_hosts;
bridge_fetch_dp_ifaces(br);
- for (i = 0; i < br->n_ports; ) {
- struct port *port = br->ports[i];
+ iterate_and_prune_ifaces(br, init_iface_netdev, NULL);
- for (j = 0; j < port->n_ifaces; ) {
- struct iface *iface = port->ifaces[j];
- if (iface->dp_ifidx < 0) {
- VLOG_ERR("%s interface not in dp%u, dropping",
- iface->name, dpif_id(&br->dpif));
- iface_destroy(iface);
- } else {
- if (iface->dp_ifidx == ODPP_LOCAL) {
- local_iface = iface;
- }
- VLOG_DBG("dp%u has interface %s on port %d",
- dpif_id(&br->dpif), iface->name, iface->dp_ifidx);
- j++;
- }
- }
- if (!port->n_ifaces) {
- VLOG_ERR("%s port has no interfaces, dropping", port->name);
- port_destroy(port);
- continue;
- }
- i++;
- }
+ iterate_and_prune_ifaces(br, check_iface_dp_ifidx, NULL);
/* Pick local port hardware address, datapath ID. */
- bridge_pick_local_hw_addr(br, ea, &devname);
+ bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
+ local_iface = bridge_get_local_iface(br);
if (local_iface) {
- int error = netdev_nodev_set_etheraddr(local_iface->name, ea);
+ int error = netdev_set_etheraddr(local_iface->netdev, ea);
if (error) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
}
}
- dpid = bridge_pick_datapath_id(br, ea, devname);
+ dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
ofproto_set_datapath_id(br->ofproto, dpid);
/* Set NetFlow configuration on this bridge. */
+ dpif_get_netflow_ids(br->dpif, &engine_type, &engine_id);
if (cfg_has("netflow.%s.engine-type", br->name)) {
engine_type = cfg_get_int(0, "netflow.%s.engine-type",
br->name);
for (i = 0; i < br->n_ports; i++) {
struct port *port = br->ports[i];
port_update_vlan_compat(port);
+ port_update_bonding(port);
}
}
LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
brstp_reconfigure(br);
+ iterate_and_prune_ifaces(br, set_iface_policing, NULL);
}
}
static void
bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
- const char **devname)
+ struct iface **hw_addr_iface)
{
uint64_t requested_ea;
size_t i, j;
int error;
- *devname = NULL;
+ *hw_addr_iface = NULL;
/* Did the user request a particular MAC? */
requested_ea = cfg_get_mac(0, "bridge.%s.mac", br->name);
for (j = 0; j < port->n_ifaces; j++) {
struct iface *candidate = port->ifaces[j];
uint8_t candidate_ea[ETH_ADDR_LEN];
- if (!netdev_nodev_get_etheraddr(candidate->name, candidate_ea)
+ if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
&& eth_addr_equals(iface_ea, candidate_ea)) {
iface = candidate;
}
}
/* Grab MAC. */
- error = netdev_nodev_get_etheraddr(iface->name, iface_ea);
+ error = netdev_get_etheraddr(iface->netdev, iface_ea);
if (error) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
memcmp(iface_ea, ea, ETH_ADDR_LEN) < 0)
{
memcpy(ea, iface_ea, ETH_ADDR_LEN);
- *devname = iface ? iface->name : NULL;
+ *hw_addr_iface = iface;
}
}
if (eth_addr_is_multicast(ea) || eth_addr_is_vif(ea)) {
memcpy(ea, br->default_ea, ETH_ADDR_LEN);
- *devname = NULL;
+ *hw_addr_iface = NULL;
VLOG_WARN("bridge %s: using default bridge Ethernet "
"address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
} else {
/* Choose and returns the datapath ID for bridge 'br' given that the bridge
* Ethernet address is 'bridge_ea'. If 'bridge_ea' is the Ethernet address of
- * a network device, then that network device's name must be passed in as
- * 'devname'; if 'bridge_ea' was derived some other way, then 'devname' must be
- * passed in as a null pointer. */
+ * an interface on 'br', then that interface must be passed in as
+ * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
+ * 'hw_addr_iface' must be passed in as a null pointer. */
static uint64_t
bridge_pick_datapath_id(struct bridge *br,
const uint8_t bridge_ea[ETH_ADDR_LEN],
- const char *devname)
+ struct iface *hw_addr_iface)
{
/*
* The procedure for choosing a bridge MAC address will, in the most
return dpid;
}
- if (devname) {
+ if (hw_addr_iface) {
int vlan;
- if (!netdev_get_vlan_vid(devname, &vlan)) {
+ if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) {
/*
* A bridge whose MAC address is taken from a VLAN network device
* (that is, a network device created with vconfig(8) or similar
mac_learning_flush(br->ml);
}
}
+
+/* Returns the 'br' interface for the ODPP_LOCAL port, or null if 'br' has no
+ * such interface. */
+static struct iface *
+bridge_get_local_iface(struct bridge *br)
+{
+ size_t i, j;
+
+ for (i = 0; i < br->n_ports; i++) {
+ struct port *port = br->ports[i];
+ for (j = 0; j < port->n_ifaces; j++) {
+ struct iface *iface = port->ifaces[j];
+ if (iface->dp_ifidx == ODPP_LOCAL) {
+ return iface;
+ }
+ }
+ }
+
+ return NULL;
+}
\f
/* Bridge unixctl user interface functions. */
static void
br = xcalloc(1, sizeof *br);
error = dpif_create(name, &br->dpif);
- if (error == EEXIST) {
+ if (error == EEXIST || error == EBUSY) {
error = dpif_open(name, &br->dpif);
if (error) {
VLOG_ERR("datapath %s already exists but cannot be opened: %s",
free(br);
return NULL;
}
- dpif_flow_flush(&br->dpif);
+ dpif_flow_flush(br->dpif);
} else if (error) {
VLOG_ERR("failed to create datapath %s: %s", name, strerror(error));
free(br);
error = ofproto_create(name, &bridge_ofhooks, br, &br->ofproto);
if (error) {
VLOG_ERR("failed to create switch %s: %s", name, strerror(error));
- dpif_delete(&br->dpif);
- dpif_close(&br->dpif);
+ dpif_delete(br->dpif);
+ dpif_close(br->dpif);
free(br);
return NULL;
}
list_push_back(&all_bridges, &br->node);
- VLOG_INFO("created bridge %s on dp%u", br->name, dpif_id(&br->dpif));
+ VLOG_INFO("created bridge %s on %s", br->name, dpif_name(br->dpif));
return br;
}
port_destroy(br->ports[br->n_ports - 1]);
}
list_remove(&br->node);
- error = dpif_delete(&br->dpif);
+ error = dpif_delete(br->dpif);
if (error && error != ENOENT) {
- VLOG_ERR("failed to delete dp%u: %s",
- dpif_id(&br->dpif), strerror(error));
+ VLOG_ERR("failed to delete %s: %s",
+ dpif_name(br->dpif), strerror(error));
}
- dpif_close(&br->dpif);
+ dpif_close(br->dpif);
ofproto_destroy(br->ofproto);
free(br->controller);
mac_learning_destroy(br->ml);
return controller && controller[0] ? controller : NULL;
}
+static bool
+check_duplicate_ifaces(struct bridge *br, struct iface *iface, void *ifaces_)
+{
+ struct svec *ifaces = ifaces_;
+ if (!svec_contains(ifaces, iface->name)) {
+ svec_add(ifaces, iface->name);
+ svec_sort(ifaces);
+ return true;
+ } else {
+ VLOG_ERR("bridge %s: %s interface is on multiple ports, "
+ "removing from %s",
+ br->name, iface->name, iface->port->name);
+ return false;
+ }
+}
+
static void
bridge_reconfigure_one(struct bridge *br)
{
struct svec old_ports, new_ports, ifaces;
struct svec listeners, old_listeners;
struct svec snoops, old_snoops;
- size_t i, j;
+ size_t i;
/* Collect old ports. */
svec_init(&old_ports);
svec_init(&new_ports);
cfg_get_all_keys(&new_ports, "bridge.%s.port", br->name);
svec_sort(&new_ports);
- if (bridge_get_controller(br) && !svec_contains(&new_ports, br->name)) {
- svec_add(&new_ports, br->name);
- svec_sort(&new_ports);
+ if (bridge_get_controller(br)) {
+ char local_name[IF_NAMESIZE];
+ int error;
+
+ error = dpif_port_get_name(br->dpif, ODPP_LOCAL,
+ local_name, sizeof local_name);
+ if (!error && !svec_contains(&new_ports, local_name)) {
+ svec_add(&new_ports, local_name);
+ svec_sort(&new_ports);
+ }
}
if (!svec_is_unique(&new_ports)) {
VLOG_WARN("bridge %s: %s specified twice as bridge port",
/* Check and delete duplicate interfaces. */
svec_init(&ifaces);
- for (i = 0; i < br->n_ports; ) {
- struct port *port = br->ports[i];
- for (j = 0; j < port->n_ifaces; ) {
- struct iface *iface = port->ifaces[j];
- if (svec_contains(&ifaces, iface->name)) {
- VLOG_ERR("bridge %s: %s interface is on multiple ports, "
- "removing from %s",
- br->name, iface->name, port->name);
- iface_destroy(iface);
- } else {
- svec_add(&ifaces, iface->name);
- svec_sort(&ifaces);
- j++;
- }
- }
- if (!port->n_ifaces) {
- VLOG_ERR("%s port has no interfaces, dropping", port->name);
- port_destroy(port);
- } else {
- i++;
- }
- }
+ iterate_and_prune_ifaces(br, check_duplicate_ifaces, &ifaces);
svec_destroy(&ifaces);
/* Delete all flows if we're switching from connected to standalone or vice
cfg_get_string(0, "%s.accept-regex", pfx),
update_resolv_conf);
} else {
- struct netdev *netdev;
+ struct iface *local_iface;
bool in_band;
- int error;
in_band = (!cfg_is_valid(CFG_BOOL | CFG_REQUIRED,
"%s.in-band", pfx)
ofproto_set_discovery(br->ofproto, false, NULL, NULL);
ofproto_set_in_band(br->ofproto, in_band);
- error = netdev_open(br->name, NETDEV_ETH_TYPE_NONE, &netdev);
- if (!error) {
- if (cfg_is_valid(CFG_IP | CFG_REQUIRED, "%s.ip", pfx)) {
- struct in_addr ip, mask, gateway;
- ip.s_addr = cfg_get_ip(0, "%s.ip", pfx);
- mask.s_addr = cfg_get_ip(0, "%s.netmask", pfx);
- gateway.s_addr = cfg_get_ip(0, "%s.gateway", pfx);
-
- netdev_turn_flags_on(netdev, NETDEV_UP, true);
- if (!mask.s_addr) {
- mask.s_addr = guess_netmask(ip.s_addr);
- }
- if (!netdev_set_in4(netdev, ip, mask)) {
- VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
- "netmask "IP_FMT,
- br->name, IP_ARGS(&ip.s_addr),
- IP_ARGS(&mask.s_addr));
- }
+ local_iface = bridge_get_local_iface(br);
+ if (local_iface
+ && cfg_is_valid(CFG_IP | CFG_REQUIRED, "%s.ip", pfx)) {
+ struct netdev *netdev = local_iface->netdev;
+ struct in_addr ip, mask, gateway;
+ ip.s_addr = cfg_get_ip(0, "%s.ip", pfx);
+ mask.s_addr = cfg_get_ip(0, "%s.netmask", pfx);
+ gateway.s_addr = cfg_get_ip(0, "%s.gateway", pfx);
+
+ netdev_turn_flags_on(netdev, NETDEV_UP, true);
+ if (!mask.s_addr) {
+ mask.s_addr = guess_netmask(ip.s_addr);
+ }
+ if (!netdev_set_in4(netdev, ip, mask)) {
+ VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
+ "netmask "IP_FMT,
+ br->name, IP_ARGS(&ip.s_addr),
+ IP_ARGS(&mask.s_addr));
+ }
- if (gateway.s_addr) {
- if (!netdev_add_router(gateway)) {
- VLOG_INFO("bridge %s: configured gateway "IP_FMT,
- br->name, IP_ARGS(&gateway.s_addr));
- }
+ if (gateway.s_addr) {
+ if (!netdev_add_router(netdev, gateway)) {
+ VLOG_INFO("bridge %s: configured gateway "IP_FMT,
+ br->name, IP_ARGS(&gateway.s_addr));
}
}
- netdev_close(netdev);
}
}
}
port_array_clear(&br->ifaces);
- dpif_port_list(&br->dpif, &dpif_ports, &n_dpif_ports);
+ dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
for (i = 0; i < n_dpif_ports; i++) {
struct odp_port *p = &dpif_ports[i];
struct iface *iface = iface_lookup(br, p->devname);
if (iface) {
if (iface->dp_ifidx >= 0) {
- VLOG_WARN("dp%u reported interface %s twice",
- dpif_id(&br->dpif), p->devname);
+ VLOG_WARN("%s reported interface %s twice",
+ dpif_name(br->dpif), p->devname);
} else if (iface_from_dp_ifidx(br, p->port)) {
- VLOG_WARN("dp%u reported interface %"PRIu16" twice",
- dpif_id(&br->dpif), p->port);
+ VLOG_WARN("%s reported interface %"PRIu16" twice",
+ dpif_name(br->dpif), p->port);
} else {
port_array_set(&br->ifaces, p->port, iface);
iface->dp_ifidx = p->port;
for (i = 0; i < br->n_ports; i++) {
struct port *port = br->ports[i];
if (port_includes_vlan(port, m->out_vlan)
- && set_dst(dst, flow, in_port, port, tags)
- && !dst_is_duplicate(dsts, dst - dsts, dst))
+ && set_dst(dst, flow, in_port, port, tags))
{
if (port->vlan < 0) {
dst->vlan = m->out_vlan;
}
+ if (dst_is_duplicate(dsts, dst - dsts, dst)) {
+ continue;
+ }
if (dst->dp_ifidx == flow->in_port
&& dst->vlan == vlan) {
/* Don't send out input port on same VLAN. */
bridge_flush(br);
} else {
- memcpy(iface->mac, opp->hw_addr, ETH_ADDR_LEN);
if (port->n_ifaces > 1) {
bool up = !(opp->state & OFPPS_LINK_DOWN);
bond_link_status_update(iface, up);
if (slave->up) {
bond.up = true;
}
- memcpy(slave->mac, iface->mac, ETH_ADDR_LEN);
+ netdev_get_etheraddr(iface->netdev, slave->mac);
}
proc_net_compat_update_bond(port->name, &bond);
&& p->n_ifaces
&& (!vlandev_name || strcmp(p->name, vlandev_name) <= 0))
{
- const uint8_t *ea = p->ifaces[0]->mac;
+ uint8_t ea[ETH_ADDR_LEN];
+ netdev_get_etheraddr(p->ifaces[0]->netdev, ea);
if (!eth_addr_is_multicast(ea) &&
!eth_addr_is_reserved(ea) &&
!eth_addr_is_zero(ea)) {
iface->dp_ifidx = -1;
iface->tag = tag_create_random();
iface->delay_expires = LLONG_MAX;
-
- if (!cfg_get_bool(0, "iface.%s.internal", iface->name)) {
- netdev_nodev_get_etheraddr(name, iface->mac);
- netdev_nodev_get_carrier(name, &iface->enabled);
- } else {
- /* Internal interfaces are created later by the call to dpif_port_add()
- * in bridge_reconfigure(). Until then, we can't obtain any
- * information about them. (There's no real value in doing so, anyway,
- * because the 'mac' and 'enabled' values are only used for interfaces
- * that are bond slaves, and it doesn't normally make sense to bond an
- * internal interface.) */
- }
+ iface->netdev = NULL;
if (port->n_ifaces >= port->allocated_ifaces) {
port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
- port_update_bonding(port);
bridge_flush(port->bridge);
}
del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
del->port_ifidx = iface->port_ifidx;
+ netdev_close(iface->netdev);
free(iface->name);
free(iface);
bond_send_learning_packets(port);
}
- port_update_bonding(port);
bridge_flush(port->bridge);
}
}
int *vlans;
size_t i;
bool mirror_all_ports;
+ bool any_ports_specified;
/* Get output port. */
out_port_name = cfg_get_key(0, "mirror.%s.%s.output.port",
cfg_get_all_keys(&src_ports, "%s.select.src-port", pfx);
cfg_get_all_keys(&dst_ports, "%s.select.dst-port", pfx);
cfg_get_all_keys(&ports, "%s.select.port", pfx);
+ any_ports_specified = src_ports.n || dst_ports.n || ports.n;
svec_append(&src_ports, &ports);
svec_append(&dst_ports, &ports);
svec_destroy(&ports);
prune_ports(m, &src_ports);
prune_ports(m, &dst_ports);
+ if (any_ports_specified && !src_ports.n && !dst_ports.n) {
+ VLOG_ERR("%s: none of the specified ports exist; "
+ "disabling port mirror %s", pfx, pfx);
+ mirror_destroy(m);
+ goto exit;
+ }
/* Get all the vlans, and drop duplicate and invalid vlans. */
svec_init(&vlan_strings);
}
/* Clean up. */
+ exit:
svec_destroy(&src_ports);
svec_destroy(&dst_ports);
free(pfx);
if (!iface) {
VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
br->name, port_no);
- } else if (eth_addr_is_zero(iface->mac)) {
- VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d with unknown MAC",
- br->name, port_no);
} else {
- union ofp_action action;
struct eth_header *eth = pkt->l2;
- flow_t flow;
- memcpy(eth->eth_src, iface->mac, ETH_ADDR_LEN);
+ netdev_get_etheraddr(iface->netdev, eth->eth_src);
+ if (eth_addr_is_zero(eth->eth_src)) {
+ VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d "
+ "with unknown MAC", br->name, port_no);
+ } else {
+ union ofp_action action;
+ flow_t flow;
- memset(&action, 0, sizeof action);
- action.type = htons(OFPAT_OUTPUT);
- action.output.len = htons(sizeof action);
- action.output.port = htons(port_no);
+ memset(&action, 0, sizeof action);
+ action.type = htons(OFPAT_OUTPUT);
+ action.output.len = htons(sizeof action);
+ action.output.port = htons(port_no);
- flow_extract(pkt, ODPP_NONE, &flow);
- ofproto_send_packet(br->ofproto, &flow, &action, 1, pkt);
+ flow_extract(pkt, ODPP_NONE, &flow);
+ ofproto_send_packet(br->ofproto, &flow, &action, 1, pkt);
+ }
}
ofpbuf_delete(pkt);
}
git://git.onelab.eu / sliver-openvswitch.git / commitdiff