Hi Alin, should we change the file name to dpif_netlink?
Thanks,
Eitan
-----Original Message-----
From: Alin Serdean [mailto:aserd...@cloudbasesolutions.com]
Sent: Wednesday, September 17, 2014 1:11 PM
To: Eitan Eliahu; Nithin Raju; 'Ben Pfaff'; dev@openvswitch.org
Subject: [ovs-dev] [PATCH] Changes needed for dpif-linux to compile under MSVC
The patch contains the necessary modifications to compile and also to run
under MSVC.
Added the files to the build system and also changed dpif_linux to be under
a more generic name dpif_windows.
Added a TODO under the windows part in case we want to implement another
counterpart for epoll functions.
Signed-off-by: Alin Gabriel Serdean <aserd...@cloudbasesolutions.com>
---
lib/automake.mk | 2 +
lib/dpif-linux.c | 563 ++++++++++++++++++++++++++++------------------------
lib/dpif-linux.h | 2 +-
lib/dpif-provider.h | 2 +-
lib/dpif.c | 4 +-
5 files changed, 311 insertions(+), 262 deletions(-)
diff --git a/lib/automake.mk b/lib/automake.mk
index b14a510..fb97130 100644
--- a/lib/automake.mk
+++ b/lib/automake.mk
@@ -332,6 +332,8 @@ endif
if WIN32
lib_libopenvswitch_la_SOURCES += \
+ lib/dpif-linux.c \
+ lib/dpif-linux.h \
lib/netlink-notifier.c \
lib/netlink-notifier.h \
lib/netlink-protocol.h \
diff --git a/lib/dpif-linux.c b/lib/dpif-linux.c
index 2c387ed..a5d0fb5 100644
--- a/lib/dpif-linux.c
+++ b/lib/dpif-linux.c
@@ -62,7 +62,7 @@ enum { MAX_PORTS = USHRT_MAX };
* missing if we have old headers. */
#define ETH_FLAG_LRO (1 << 15) /* LRO is enabled */
-struct dpif_linux_dp {
+struct dpif_netlink_dp {
/* Generic Netlink header. */
uint8_t cmd;
@@ -78,17 +78,17 @@ struct dpif_linux_dp {
/* OVS_DP_ATTR_MEGAFLOW_STATS.*/
};
-static void dpif_linux_dp_init(struct dpif_linux_dp *);
-static int dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *,
+static void dpif_netlink_dp_init(struct dpif_netlink_dp *);
+static int dpif_netlink_dp_from_ofpbuf(struct dpif_netlink_dp *,
const struct ofpbuf *);
-static void dpif_linux_dp_dump_start(struct nl_dump *);
-static int dpif_linux_dp_transact(const struct dpif_linux_dp *request,
- struct dpif_linux_dp *reply,
+static void dpif_netlink_dp_dump_start(struct nl_dump *);
+static int dpif_netlink_dp_transact(const struct dpif_netlink_dp *request,
+ struct dpif_netlink_dp *reply,
struct ofpbuf **bufp);
-static int dpif_linux_dp_get(const struct dpif *, struct dpif_linux_dp *reply,
+static int dpif_netlink_dp_get(const struct dpif *, struct dpif_netlink_dp
*reply,
struct ofpbuf **bufp);
-struct dpif_linux_flow {
+struct dpif_netlink_flow {
/* Generic Netlink header. */
uint8_t cmd;
@@ -116,18 +116,18 @@ struct dpif_linux_flow {
bool clear; /* OVS_FLOW_ATTR_CLEAR. */
};
-static void dpif_linux_flow_init(struct dpif_linux_flow *);
-static int dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *,
+static void dpif_netlink_flow_init(struct dpif_netlink_flow *);
+static int dpif_netlink_flow_from_ofpbuf(struct dpif_netlink_flow *,
const struct ofpbuf *);
-static void dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *,
+static void dpif_netlink_flow_to_ofpbuf(const struct dpif_netlink_flow *,
struct ofpbuf *);
-static int dpif_linux_flow_transact(struct dpif_linux_flow *request,
- struct dpif_linux_flow *reply,
+static int dpif_netlink_flow_transact(struct dpif_netlink_flow *request,
+ struct dpif_netlink_flow *reply,
struct ofpbuf **bufp);
-static void dpif_linux_flow_get_stats(const struct dpif_linux_flow *,
+static void dpif_netlink_flow_get_stats(const struct dpif_netlink_flow *,
struct dpif_flow_stats *);
-static void dpif_linux_flow_to_dpif_flow(struct dpif_flow *,
- const struct dpif_linux_flow *);
+static void dpif_netlink_flow_to_dpif_flow(struct dpif_flow *,
+ const struct dpif_netlink_flow *);
/* One of the dpif channels between the kernel and userspace. */
struct dpif_channel {
@@ -144,7 +144,7 @@ struct dpif_handler {
};
/* Datapath interface for the openvswitch Linux kernel module. */
-struct dpif_linux {
+struct dpif_netlink {
struct dpif dpif;
int dp_ifindex;
@@ -160,14 +160,14 @@ struct dpif_linux {
bool refresh_channels;
};
-static void report_loss(struct dpif_linux *, struct dpif_channel *,
+static void report_loss(struct dpif_netlink *, struct dpif_channel *,
uint32_t ch_idx, uint32_t handler_id);
static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(9999, 5);
/* Generic Netlink family numbers for OVS.
*
- * Initialized by dpif_linux_init(). */
+ * Initialized by dpif_netlink_init(). */
static int ovs_datapath_family;
static int ovs_vport_family;
static int ovs_flow_family;
@@ -175,29 +175,29 @@ static int ovs_packet_family;
/* Generic Netlink multicast groups for OVS.
*
- * Initialized by dpif_linux_init(). */
+ * Initialized by dpif_netlink_init(). */
static unsigned int ovs_vport_mcgroup;
-static int dpif_linux_init(void);
-static int open_dpif(const struct dpif_linux_dp *, struct dpif **);
-static uint32_t dpif_linux_port_get_pid(const struct dpif *,
+static int dpif_netlink_init(void);
+static int open_dpif(const struct dpif_netlink_dp *, struct dpif **);
+static uint32_t dpif_netlink_port_get_pid(const struct dpif *,
odp_port_t port_no, uint32_t hash);
-static int dpif_linux_refresh_channels(struct dpif_linux *,
+static int dpif_netlink_refresh_channels(struct dpif_netlink *,
uint32_t n_handlers);
static void dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *,
struct ofpbuf *);
static int dpif_linux_vport_from_ofpbuf(struct dpif_linux_vport *,
const struct ofpbuf *);
-static struct dpif_linux *
-dpif_linux_cast(const struct dpif *dpif)
+static struct dpif_netlink *
+dpif_netlink_cast(const struct dpif *dpif)
{
- dpif_assert_class(dpif, &dpif_linux_class);
- return CONTAINER_OF(dpif, struct dpif_linux, dpif);
+ dpif_assert_class(dpif, &dpif_netlink_class);
+ return CONTAINER_OF(dpif, struct dpif_netlink, dpif);
}
static int
-dpif_linux_enumerate(struct sset *all_dps,
+dpif_netlink_enumerate(struct sset *all_dps,
const struct dpif_class *dpif_class OVS_UNUSED)
{
struct nl_dump dump;
@@ -205,17 +205,17 @@ dpif_linux_enumerate(struct sset *all_dps,
struct ofpbuf msg, buf;
int error;
- error = dpif_linux_init();
+ error = dpif_netlink_init();
if (error) {
return error;
}
ofpbuf_use_stub(&buf, reply_stub, sizeof reply_stub);
- dpif_linux_dp_dump_start(&dump);
+ dpif_netlink_dp_dump_start(&dump);
while (nl_dump_next(&dump, &msg, &buf)) {
- struct dpif_linux_dp dp;
+ struct dpif_netlink_dp dp;
- if (!dpif_linux_dp_from_ofpbuf(&dp, &msg)) {
+ if (!dpif_netlink_dp_from_ofpbuf(&dp, &msg)) {
sset_add(all_dps, dp.name);
}
}
@@ -224,21 +224,21 @@ dpif_linux_enumerate(struct sset *all_dps,
}
static int
-dpif_linux_open(const struct dpif_class *class OVS_UNUSED, const char *name,
+dpif_netlink_open(const struct dpif_class *class OVS_UNUSED, const char *name,
bool create, struct dpif **dpifp)
{
- struct dpif_linux_dp dp_request, dp;
+ struct dpif_netlink_dp dp_request, dp;
struct ofpbuf *buf;
uint32_t upcall_pid;
int error;
- error = dpif_linux_init();
+ error = dpif_netlink_init();
if (error) {
return error;
}
/* Create or look up datapath. */
- dpif_linux_dp_init(&dp_request);
+ dpif_netlink_dp_init(&dp_request);
if (create) {
dp_request.cmd = OVS_DP_CMD_NEW;
upcall_pid = 0;
@@ -250,7 +250,7 @@ dpif_linux_open(const struct dpif_class *class OVS_UNUSED,
const char *name,
dp_request.name = name;
dp_request.user_features |= OVS_DP_F_UNALIGNED;
dp_request.user_features |= OVS_DP_F_VPORT_PIDS;
- error = dpif_linux_dp_transact(&dp_request, &dp, &buf);
+ error = dpif_netlink_dp_transact(&dp_request, &dp, &buf);
if (error) {
return error;
}
@@ -261,15 +261,15 @@ dpif_linux_open(const struct dpif_class *class
OVS_UNUSED, const char *name,
}
static int
-open_dpif(const struct dpif_linux_dp *dp, struct dpif **dpifp)
+open_dpif(const struct dpif_netlink_dp *dp, struct dpif **dpifp)
{
- struct dpif_linux *dpif;
+ struct dpif_netlink *dpif;
dpif = xzalloc(sizeof *dpif);
dpif->port_notifier = NULL;
fat_rwlock_init(&dpif->upcall_lock);
- dpif_init(&dpif->dpif, &dpif_linux_class, dp->name,
+ dpif_init(&dpif->dpif, &dpif_netlink_class, dp->name,
dp->dp_ifindex, dp->dp_ifindex);
dpif->dp_ifindex = dp->dp_ifindex;
@@ -340,7 +340,7 @@ vport_socksp_to_pids(struct nl_sock **socksp, uint32_t
n_socks)
/* Given the port number 'port_idx', extracts the pids of netlink sockets
* associated to the port and assigns it to 'upcall_pids'. */
static bool
-vport_get_pids(struct dpif_linux *dpif, uint32_t port_idx,
+vport_get_pids(struct dpif_netlink *dpif, uint32_t port_idx,
uint32_t **upcall_pids)
{
uint32_t *pids;
@@ -365,7 +365,7 @@ vport_get_pids(struct dpif_linux *dpif, uint32_t port_idx,
}
static int
-vport_add_channels(struct dpif_linux *dpif, odp_port_t port_no,
+vport_add_channels(struct dpif_netlink *dpif, odp_port_t port_no,
struct nl_sock **socksp)
{
struct epoll_event event;
@@ -413,11 +413,17 @@ vport_add_channels(struct dpif_linux *dpif, odp_port_t
port_no,
for (i = 0; i < dpif->n_handlers; i++) {
struct dpif_handler *handler = &dpif->handlers[i];
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
if (epoll_ctl(handler->epoll_fd, EPOLL_CTL_ADD, nl_sock_fd(socksp[i]),
&event) < 0) {
error = errno;
goto error;
}
+#endif
dpif->handlers[i].channels[port_idx].sock = socksp[i];
dpif->handlers[i].channels[port_idx].last_poll = LLONG_MIN;
}
@@ -426,8 +432,14 @@ vport_add_channels(struct dpif_linux *dpif, odp_port_t
port_no,
error:
for (j = 0; j < i; j++) {
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
epoll_ctl(dpif->handlers[j].epoll_fd, EPOLL_CTL_DEL,
nl_sock_fd(socksp[j]), NULL);
+#endif
dpif->handlers[j].channels[port_idx].sock = NULL;
}
@@ -435,7 +447,7 @@ error:
}
static void
-vport_del_channels(struct dpif_linux *dpif, odp_port_t port_no)
+vport_del_channels(struct dpif_netlink *dpif, odp_port_t port_no)
{
uint32_t port_idx = odp_to_u32(port_no);
size_t i;
@@ -454,8 +466,14 @@ vport_del_channels(struct dpif_linux *dpif, odp_port_t
port_no)
for (i = 0; i < dpif->n_handlers; i++) {
struct dpif_handler *handler = &dpif->handlers[i];
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
epoll_ctl(handler->epoll_fd, EPOLL_CTL_DEL,
nl_sock_fd(handler->channels[port_idx].sock), NULL);
+#endif
nl_sock_destroy(handler->channels[port_idx].sock);
handler->channels[port_idx].sock = NULL;
handler->event_offset = handler->n_events = 0;
@@ -463,7 +481,7 @@ vport_del_channels(struct dpif_linux *dpif, odp_port_t
port_no)
}
static void
-destroy_all_channels(struct dpif_linux *dpif) OVS_REQ_WRLOCK(dpif->upcall_lock)
+destroy_all_channels(struct dpif_netlink *dpif)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
unsigned int i;
@@ -496,7 +514,13 @@ destroy_all_channels(struct dpif_linux *dpif)
OVS_REQ_WRLOCK(dpif->upcall_lock)
for (i = 0; i < dpif->n_handlers; i++) {
struct dpif_handler *handler = &dpif->handlers[i];
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
close(handler->epoll_fd);
+#endif
free(handler->epoll_events);
free(handler->channels);
}
@@ -508,9 +532,9 @@ destroy_all_channels(struct dpif_linux *dpif)
OVS_REQ_WRLOCK(dpif->upcall_lock)
}
static void
-dpif_linux_close(struct dpif *dpif_)
+dpif_netlink_close(struct dpif *dpif_)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
nl_sock_destroy(dpif->port_notifier);
@@ -523,38 +547,38 @@ dpif_linux_close(struct dpif *dpif_)
}
static int
-dpif_linux_destroy(struct dpif *dpif_)
+dpif_netlink_destroy(struct dpif *dpif_)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_dp dp;
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_dp dp;
- dpif_linux_dp_init(&dp);
+ dpif_netlink_dp_init(&dp);
dp.cmd = OVS_DP_CMD_DEL;
dp.dp_ifindex = dpif->dp_ifindex;
- return dpif_linux_dp_transact(&dp, NULL, NULL);
+ return dpif_netlink_dp_transact(&dp, NULL, NULL);
}
static void
-dpif_linux_run(struct dpif *dpif_)
+dpif_netlink_run(struct dpif *dpif_)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
if (dpif->refresh_channels) {
dpif->refresh_channels = false;
fat_rwlock_wrlock(&dpif->upcall_lock);
- dpif_linux_refresh_channels(dpif, dpif->n_handlers);
+ dpif_netlink_refresh_channels(dpif, dpif->n_handlers);
fat_rwlock_unlock(&dpif->upcall_lock);
}
}
static int
-dpif_linux_get_stats(const struct dpif *dpif_, struct dpif_dp_stats *stats)
+dpif_netlink_get_stats(const struct dpif *dpif_, struct dpif_dp_stats *stats)
{
- struct dpif_linux_dp dp;
+ struct dpif_netlink_dp dp;
struct ofpbuf *buf;
int error;
- error = dpif_linux_dp_get(dpif_, &dp, &buf);
+ error = dpif_netlink_dp_get(dpif_, &dp, &buf);
if (!error) {
memset(stats, 0, sizeof *stats);
@@ -643,7 +667,7 @@ netdev_to_ovs_vport_type(const struct netdev *netdev)
}
static int
-dpif_linux_port_add__(struct dpif_linux *dpif, struct netdev *netdev,
+dpif_netlink_port_add__(struct dpif_netlink *dpif, struct netdev *netdev,
odp_port_t *port_nop)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
@@ -681,7 +705,13 @@ dpif_linux_port_add__(struct dpif_linux *dpif, struct
netdev *netdev,
request.name = name;
if (request.type == OVS_VPORT_TYPE_NETDEV) {
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
netdev_linux_ethtool_set_flag(netdev, ETH_FLAG_LRO, "LRO", false);
+#endif
}
tnl_cfg = netdev_get_tunnel_config(netdev);
@@ -737,21 +767,21 @@ exit:
}
static int
-dpif_linux_port_add(struct dpif *dpif_, struct netdev *netdev,
+dpif_netlink_port_add(struct dpif *dpif_, struct netdev *netdev,
odp_port_t *port_nop)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
int error;
fat_rwlock_wrlock(&dpif->upcall_lock);
- error = dpif_linux_port_add__(dpif, netdev, port_nop);
+ error = dpif_netlink_port_add__(dpif, netdev, port_nop);
fat_rwlock_unlock(&dpif->upcall_lock);
return error;
}
static int
-dpif_linux_port_del__(struct dpif_linux *dpif, odp_port_t port_no)
+dpif_netlink_port_del__(struct dpif_netlink *dpif, odp_port_t port_no)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
struct dpif_linux_vport vport;
@@ -769,20 +799,20 @@ dpif_linux_port_del__(struct dpif_linux *dpif, odp_port_t
port_no)
}
static int
-dpif_linux_port_del(struct dpif *dpif_, odp_port_t port_no)
+dpif_netlink_port_del(struct dpif *dpif_, odp_port_t port_no)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
int error;
fat_rwlock_wrlock(&dpif->upcall_lock);
- error = dpif_linux_port_del__(dpif, port_no);
+ error = dpif_netlink_port_del__(dpif, port_no);
fat_rwlock_unlock(&dpif->upcall_lock);
return error;
}
static int
-dpif_linux_port_query__(const struct dpif_linux *dpif, odp_port_t port_no,
+dpif_netlink_port_query__(const struct dpif_netlink *dpif, odp_port_t port_no,
const char *port_name, struct dpif_port *dpif_port)
{
struct dpif_linux_vport request;
@@ -813,25 +843,25 @@ dpif_linux_port_query__(const struct dpif_linux *dpif,
odp_port_t port_no,
}
static int
-dpif_linux_port_query_by_number(const struct dpif *dpif_, odp_port_t port_no,
+dpif_netlink_port_query_by_number(const struct dpif *dpif_, odp_port_t port_no,
struct dpif_port *dpif_port)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
- return dpif_linux_port_query__(dpif, port_no, NULL, dpif_port);
+ return dpif_netlink_port_query__(dpif, port_no, NULL, dpif_port);
}
static int
-dpif_linux_port_query_by_name(const struct dpif *dpif_, const char *devname,
+dpif_netlink_port_query_by_name(const struct dpif *dpif_, const char *devname,
struct dpif_port *dpif_port)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
- return dpif_linux_port_query__(dpif, 0, devname, dpif_port);
+ return dpif_netlink_port_query__(dpif, 0, devname, dpif_port);
}
static uint32_t
-dpif_linux_port_get_pid__(const struct dpif_linux *dpif, odp_port_t port_no,
+dpif_netlink_port_get_pid__(const struct dpif_netlink *dpif, odp_port_t
port_no,
uint32_t hash)
OVS_REQ_RDLOCK(dpif->upcall_lock)
{
@@ -857,38 +887,38 @@ dpif_linux_port_get_pid__(const struct dpif_linux *dpif,
odp_port_t port_no,
}
static uint32_t
-dpif_linux_port_get_pid(const struct dpif *dpif_, odp_port_t port_no,
+dpif_netlink_port_get_pid(const struct dpif *dpif_, odp_port_t port_no,
uint32_t hash)
{
- const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ const struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
uint32_t ret;
fat_rwlock_rdlock(&dpif->upcall_lock);
- ret = dpif_linux_port_get_pid__(dpif, port_no, hash);
+ ret = dpif_netlink_port_get_pid__(dpif, port_no, hash);
fat_rwlock_unlock(&dpif->upcall_lock);
return ret;
}
static int
-dpif_linux_flow_flush(struct dpif *dpif_)
+dpif_netlink_flow_flush(struct dpif *dpif_)
{
- const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_flow flow;
+ const struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_flow flow;
- dpif_linux_flow_init(&flow);
+ dpif_netlink_flow_init(&flow);
flow.cmd = OVS_FLOW_CMD_DEL;
flow.dp_ifindex = dpif->dp_ifindex;
- return dpif_linux_flow_transact(&flow, NULL, NULL);
+ return dpif_netlink_flow_transact(&flow, NULL, NULL);
}
-struct dpif_linux_port_state {
+struct dpif_netlink_port_state {
struct nl_dump dump;
struct ofpbuf buf;
};
static void
-dpif_linux_port_dump_start__(const struct dpif_linux *dpif,
+dpif_netlink_port_dump_start__(const struct dpif_netlink *dpif,
struct nl_dump *dump)
{
struct dpif_linux_vport request;
@@ -905,20 +935,20 @@ dpif_linux_port_dump_start__(const struct dpif_linux
*dpif,
}
static int
-dpif_linux_port_dump_start(const struct dpif *dpif_, void **statep)
+dpif_netlink_port_dump_start(const struct dpif *dpif_, void **statep)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_port_state *state;
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_port_state *state;
*statep = state = xmalloc(sizeof *state);
- dpif_linux_port_dump_start__(dpif, &state->dump);
+ dpif_netlink_port_dump_start__(dpif, &state->dump);
ofpbuf_init(&state->buf, NL_DUMP_BUFSIZE);
return 0;
}
static int
-dpif_linux_port_dump_next__(const struct dpif_linux *dpif, struct nl_dump
*dump,
+dpif_netlink_port_dump_next__(const struct dpif_netlink *dpif, struct nl_dump
*dump,
struct dpif_linux_vport *vport,
struct ofpbuf *buffer)
{
@@ -938,15 +968,15 @@ dpif_linux_port_dump_next__(const struct dpif_linux
*dpif, struct nl_dump *dump,
}
static int
-dpif_linux_port_dump_next(const struct dpif *dpif_, void *state_,
+dpif_netlink_port_dump_next(const struct dpif *dpif_, void *state_,
struct dpif_port *dpif_port)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_port_state *state = state_;
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_port_state *state = state_;
struct dpif_linux_vport vport;
int error;
- error = dpif_linux_port_dump_next__(dpif, &state->dump, &vport,
+ error = dpif_netlink_port_dump_next__(dpif, &state->dump, &vport,
&state->buf);
if (error) {
return error;
@@ -958,9 +988,9 @@ dpif_linux_port_dump_next(const struct dpif *dpif_, void
*state_,
}
static int
-dpif_linux_port_dump_done(const struct dpif *dpif_ OVS_UNUSED, void *state_)
+dpif_netlink_port_dump_done(const struct dpif *dpif_ OVS_UNUSED, void *state_)
{
- struct dpif_linux_port_state *state = state_;
+ struct dpif_netlink_port_state *state = state_;
int error = nl_dump_done(&state->dump);
ofpbuf_uninit(&state->buf);
@@ -969,9 +999,9 @@ dpif_linux_port_dump_done(const struct dpif *dpif_
OVS_UNUSED, void *state_)
}
static int
-dpif_linux_port_poll(const struct dpif *dpif_, char **devnamep)
+dpif_netlink_port_poll(const struct dpif *dpif_, char **devnamep)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
/* Lazily create the Netlink socket to listen for notifications. */
if (!dpif->port_notifier) {
@@ -1037,9 +1067,9 @@ dpif_linux_port_poll(const struct dpif *dpif_, char
**devnamep)
}
static void
-dpif_linux_port_poll_wait(const struct dpif *dpif_)
+dpif_netlink_port_poll_wait(const struct dpif *dpif_)
{
- const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ const struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
if (dpif->port_notifier) {
nl_sock_wait(dpif->port_notifier, POLLIN);
@@ -1049,11 +1079,11 @@ dpif_linux_port_poll_wait(const struct dpif *dpif_)
}
static void
-dpif_linux_init_flow_get(const struct dpif_linux *dpif,
+dpif_netlink_init_flow_get(const struct dpif_netlink *dpif,
const struct nlattr *key, size_t key_len,
- struct dpif_linux_flow *request)
+ struct dpif_netlink_flow *request)
{
- dpif_linux_flow_init(request);
+ dpif_netlink_flow_init(request);
request->cmd = OVS_FLOW_CMD_GET;
request->dp_ifindex = dpif->dp_ifindex;
request->key = key;
@@ -1061,23 +1091,23 @@ dpif_linux_init_flow_get(const struct dpif_linux *dpif,
}
static int
-dpif_linux_flow_get(const struct dpif_linux *dpif,
+dpif_netlink_flow_get(const struct dpif_netlink *dpif,
const struct nlattr *key, size_t key_len,
- struct dpif_linux_flow *reply, struct ofpbuf **bufp)
+ struct dpif_netlink_flow *reply, struct ofpbuf **bufp)
{
- struct dpif_linux_flow request;
+ struct dpif_netlink_flow request;
- dpif_linux_init_flow_get(dpif, key, key_len, &request);
- return dpif_linux_flow_transact(&request, reply, bufp);
+ dpif_netlink_init_flow_get(dpif, key, key_len, &request);
+ return dpif_netlink_flow_transact(&request, reply, bufp);
}
static void
-dpif_linux_init_flow_put(struct dpif_linux *dpif, const struct dpif_flow_put
*put,
- struct dpif_linux_flow *request)
+dpif_netlink_init_flow_put(struct dpif_netlink *dpif, const struct
dpif_flow_put *put,
+ struct dpif_netlink_flow *request)
{
static const struct nlattr dummy_action;
- dpif_linux_flow_init(request);
+ dpif_netlink_flow_init(request);
request->cmd = (put->flags & DPIF_FP_CREATE
? OVS_FLOW_CMD_NEW : OVS_FLOW_CMD_SET);
request->dp_ifindex = dpif->dp_ifindex;
@@ -1097,45 +1127,45 @@ dpif_linux_init_flow_put(struct dpif_linux *dpif, const
struct dpif_flow_put *pu
}
static void
-dpif_linux_init_flow_del(struct dpif_linux *dpif, const struct dpif_flow_del
*del,
- struct dpif_linux_flow *request)
+dpif_netlink_init_flow_del(struct dpif_netlink *dpif, const struct
dpif_flow_del *del,
+ struct dpif_netlink_flow *request)
{
- dpif_linux_flow_init(request);
+ dpif_netlink_flow_init(request);
request->cmd = OVS_FLOW_CMD_DEL;
request->dp_ifindex = dpif->dp_ifindex;
request->key = del->key;
request->key_len = del->key_len;
}
-struct dpif_linux_flow_dump {
+struct dpif_netlink_flow_dump {
struct dpif_flow_dump up;
struct nl_dump nl_dump;
atomic_int status;
};
-static struct dpif_linux_flow_dump *
-dpif_linux_flow_dump_cast(struct dpif_flow_dump *dump)
+static struct dpif_netlink_flow_dump *
+dpif_netlink_flow_dump_cast(struct dpif_flow_dump *dump)
{
- return CONTAINER_OF(dump, struct dpif_linux_flow_dump, up);
+ return CONTAINER_OF(dump, struct dpif_netlink_flow_dump, up);
}
static struct dpif_flow_dump *
-dpif_linux_flow_dump_create(const struct dpif *dpif_)
+dpif_netlink_flow_dump_create(const struct dpif *dpif_)
{
- const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_flow_dump *dump;
- struct dpif_linux_flow request;
+ const struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_flow_dump *dump;
+ struct dpif_netlink_flow request;
struct ofpbuf *buf;
dump = xmalloc(sizeof *dump);
dpif_flow_dump_init(&dump->up, dpif_);
- dpif_linux_flow_init(&request);
+ dpif_netlink_flow_init(&request);
request.cmd = OVS_FLOW_CMD_GET;
request.dp_ifindex = dpif->dp_ifindex;
buf = ofpbuf_new(1024);
- dpif_linux_flow_to_ofpbuf(&request, buf);
+ dpif_netlink_flow_to_ofpbuf(&request, buf);
nl_dump_start(&dump->nl_dump, NETLINK_GENERIC, buf);
ofpbuf_delete(buf);
atomic_init(&dump->status, 0);
@@ -1144,9 +1174,9 @@ dpif_linux_flow_dump_create(const struct dpif *dpif_)
}
static int
-dpif_linux_flow_dump_destroy(struct dpif_flow_dump *dump_)
+dpif_netlink_flow_dump_destroy(struct dpif_flow_dump *dump_)
{
- struct dpif_linux_flow_dump *dump = dpif_linux_flow_dump_cast(dump_);
+ struct dpif_netlink_flow_dump *dump = dpif_netlink_flow_dump_cast(dump_);
unsigned int nl_status = nl_dump_done(&dump->nl_dump);
int dump_status;
@@ -1156,26 +1186,26 @@ dpif_linux_flow_dump_destroy(struct dpif_flow_dump
*dump_)
return dump_status ? dump_status : nl_status;
}
-struct dpif_linux_flow_dump_thread {
+struct dpif_netlink_flow_dump_thread {
struct dpif_flow_dump_thread up;
- struct dpif_linux_flow_dump *dump;
- struct dpif_linux_flow flow;
+ struct dpif_netlink_flow_dump *dump;
+ struct dpif_netlink_flow flow;
struct dpif_flow_stats stats;
struct ofpbuf nl_flows; /* Always used to store flows. */
struct ofpbuf *nl_actions; /* Used if kernel does not supply actions. */
};
-static struct dpif_linux_flow_dump_thread *
-dpif_linux_flow_dump_thread_cast(struct dpif_flow_dump_thread *thread)
+static struct dpif_netlink_flow_dump_thread *
+dpif_netlink_flow_dump_thread_cast(struct dpif_flow_dump_thread *thread)
{
- return CONTAINER_OF(thread, struct dpif_linux_flow_dump_thread, up);
+ return CONTAINER_OF(thread, struct dpif_netlink_flow_dump_thread, up);
}
static struct dpif_flow_dump_thread *
-dpif_linux_flow_dump_thread_create(struct dpif_flow_dump *dump_)
+dpif_netlink_flow_dump_thread_create(struct dpif_flow_dump *dump_)
{
- struct dpif_linux_flow_dump *dump = dpif_linux_flow_dump_cast(dump_);
- struct dpif_linux_flow_dump_thread *thread;
+ struct dpif_netlink_flow_dump *dump = dpif_netlink_flow_dump_cast(dump_);
+ struct dpif_netlink_flow_dump_thread *thread;
thread = xmalloc(sizeof *thread);
dpif_flow_dump_thread_init(&thread->up, &dump->up);
@@ -1187,10 +1217,10 @@ dpif_linux_flow_dump_thread_create(struct
dpif_flow_dump *dump_)
}
static void
-dpif_linux_flow_dump_thread_destroy(struct dpif_flow_dump_thread *thread_)
+dpif_netlink_flow_dump_thread_destroy(struct dpif_flow_dump_thread *thread_)
{
- struct dpif_linux_flow_dump_thread *thread
- = dpif_linux_flow_dump_thread_cast(thread_);
+ struct dpif_netlink_flow_dump_thread *thread
+ = dpif_netlink_flow_dump_thread_cast(thread_);
ofpbuf_uninit(&thread->nl_flows);
ofpbuf_delete(thread->nl_actions);
@@ -1198,8 +1228,8 @@ dpif_linux_flow_dump_thread_destroy(struct
dpif_flow_dump_thread *thread_)
}
static void
-dpif_linux_flow_to_dpif_flow(struct dpif_flow *dpif_flow,
- const struct dpif_linux_flow *linux_flow)
+dpif_netlink_flow_to_dpif_flow(struct dpif_flow *dpif_flow,
+ const struct dpif_netlink_flow *linux_flow)
{
dpif_flow->key = linux_flow->key;
dpif_flow->key_len = linux_flow->key_len;
@@ -1207,17 +1237,17 @@ dpif_linux_flow_to_dpif_flow(struct dpif_flow
*dpif_flow,
dpif_flow->mask_len = linux_flow->mask_len;
dpif_flow->actions = linux_flow->actions;
dpif_flow->actions_len = linux_flow->actions_len;
- dpif_linux_flow_get_stats(linux_flow, &dpif_flow->stats);
+ dpif_netlink_flow_get_stats(linux_flow, &dpif_flow->stats);
}
static int
-dpif_linux_flow_dump_next(struct dpif_flow_dump_thread *thread_,
+dpif_netlink_flow_dump_next(struct dpif_flow_dump_thread *thread_,
struct dpif_flow *flows, int max_flows)
{
- struct dpif_linux_flow_dump_thread *thread
- = dpif_linux_flow_dump_thread_cast(thread_);
- struct dpif_linux_flow_dump *dump = thread->dump;
- struct dpif_linux *dpif = dpif_linux_cast(thread->up.dpif);
+ struct dpif_netlink_flow_dump_thread *thread
+ = dpif_netlink_flow_dump_thread_cast(thread_);
+ struct dpif_netlink_flow_dump *dump = thread->dump;
+ struct dpif_netlink *dpif = dpif_netlink_cast(thread->up.dpif);
int n_flows;
ofpbuf_delete(thread->nl_actions);
@@ -1226,7 +1256,7 @@ dpif_linux_flow_dump_next(struct dpif_flow_dump_thread
*thread_,
n_flows = 0;
while (!n_flows
|| (n_flows < max_flows && ofpbuf_size(&thread->nl_flows))) {
- struct dpif_linux_flow linux_flow;
+ struct dpif_netlink_flow linux_flow;
struct ofpbuf nl_flow;
int error;
@@ -1236,7 +1266,7 @@ dpif_linux_flow_dump_next(struct dpif_flow_dump_thread
*thread_,
}
/* Convert the flow to our output format. */
- error = dpif_linux_flow_from_ofpbuf(&linux_flow, &nl_flow);
+ error = dpif_netlink_flow_from_ofpbuf(&linux_flow, &nl_flow);
if (error) {
atomic_store_relaxed(&dump->status, error);
break;
@@ -1244,11 +1274,11 @@ dpif_linux_flow_dump_next(struct dpif_flow_dump_thread
*thread_,
if (linux_flow.actions) {
/* Common case: the flow includes actions. */
- dpif_linux_flow_to_dpif_flow(&flows[n_flows++], &linux_flow);
+ dpif_netlink_flow_to_dpif_flow(&flows[n_flows++], &linux_flow);
} else {
/* Rare case: the flow does not include actions. Retrieve this
* individual flow again to get the actions. */
- error = dpif_linux_flow_get(dpif, linux_flow.key,
+ error = dpif_netlink_flow_get(dpif, linux_flow.key,
linux_flow.key_len, &linux_flow,
&thread->nl_actions);
if (error == ENOENT) {
@@ -1263,7 +1293,7 @@ dpif_linux_flow_dump_next(struct dpif_flow_dump_thread
*thread_,
/* Save this flow. Then exit, because we only have one buffer to
* handle this case. */
- dpif_linux_flow_to_dpif_flow(&flows[n_flows++], &linux_flow);
+ dpif_netlink_flow_to_dpif_flow(&flows[n_flows++], &linux_flow);
break;
}
}
@@ -1271,7 +1301,7 @@ dpif_linux_flow_dump_next(struct dpif_flow_dump_thread
*thread_,
}
static void
-dpif_linux_encode_execute(int dp_ifindex, const struct dpif_execute *d_exec,
+dpif_netlink_encode_execute(int dp_ifindex, const struct dpif_execute *d_exec,
struct ofpbuf *buf)
{
struct ovs_header *k_exec;
@@ -1303,7 +1333,7 @@ dpif_linux_encode_execute(int dp_ifindex, const struct
dpif_execute *d_exec,
#define MAX_OPS 50
static void
-dpif_linux_operate__(struct dpif_linux *dpif,
+dpif_netlink_operate__(struct dpif_netlink *dpif,
struct dpif_op **ops, size_t n_ops)
{
struct op_auxdata {
@@ -1327,7 +1357,7 @@ dpif_linux_operate__(struct dpif_linux *dpif,
struct dpif_flow_del *del;
struct dpif_execute *execute;
struct dpif_flow_get *get;
- struct dpif_linux_flow flow;
+ struct dpif_netlink_flow flow;
ofpbuf_use_stub(&aux->request,
aux->request_stub, sizeof aux->request_stub);
@@ -1339,35 +1369,35 @@ dpif_linux_operate__(struct dpif_linux *dpif,
switch (op->type) {
case DPIF_OP_FLOW_PUT:
put = &op->u.flow_put;
- dpif_linux_init_flow_put(dpif, put, &flow);
+ dpif_netlink_init_flow_put(dpif, put, &flow);
if (put->stats) {
flow.nlmsg_flags |= NLM_F_ECHO;
aux->txn.reply = &aux->reply;
}
- dpif_linux_flow_to_ofpbuf(&flow, &aux->request);
+ dpif_netlink_flow_to_ofpbuf(&flow, &aux->request);
break;
case DPIF_OP_FLOW_DEL:
del = &op->u.flow_del;
- dpif_linux_init_flow_del(dpif, del, &flow);
+ dpif_netlink_init_flow_del(dpif, del, &flow);
if (del->stats) {
flow.nlmsg_flags |= NLM_F_ECHO;
aux->txn.reply = &aux->reply;
}
- dpif_linux_flow_to_ofpbuf(&flow, &aux->request);
+ dpif_netlink_flow_to_ofpbuf(&flow, &aux->request);
break;
case DPIF_OP_EXECUTE:
execute = &op->u.execute;
- dpif_linux_encode_execute(dpif->dp_ifindex, execute,
+ dpif_netlink_encode_execute(dpif->dp_ifindex, execute,
&aux->request);
break;
case DPIF_OP_FLOW_GET:
get = &op->u.flow_get;
- dpif_linux_init_flow_get(dpif, get->key, get->key_len, &flow);
+ dpif_netlink_init_flow_get(dpif, get->key, get->key_len, &flow);
aux->txn.reply = get->buffer;
- dpif_linux_flow_to_ofpbuf(&flow, &aux->request);
+ dpif_netlink_flow_to_ofpbuf(&flow, &aux->request);
break;
default:
@@ -1395,12 +1425,12 @@ dpif_linux_operate__(struct dpif_linux *dpif,
put = &op->u.flow_put;
if (put->stats) {
if (!op->error) {
- struct dpif_linux_flow reply;
+ struct dpif_netlink_flow reply;
- op->error = dpif_linux_flow_from_ofpbuf(&reply,
+ op->error = dpif_netlink_flow_from_ofpbuf(&reply,
txn->reply);
if (!op->error) {
- dpif_linux_flow_get_stats(&reply, put->stats);
+ dpif_netlink_flow_get_stats(&reply, put->stats);
}
}
}
@@ -1410,12 +1440,12 @@ dpif_linux_operate__(struct dpif_linux *dpif,
del = &op->u.flow_del;
if (del->stats) {
if (!op->error) {
- struct dpif_linux_flow reply;
+ struct dpif_netlink_flow reply;
- op->error = dpif_linux_flow_from_ofpbuf(&reply,
+ op->error = dpif_netlink_flow_from_ofpbuf(&reply,
txn->reply);
if (!op->error) {
- dpif_linux_flow_get_stats(&reply, del->stats);
+ dpif_netlink_flow_get_stats(&reply, del->stats);
}
}
}
@@ -1427,11 +1457,11 @@ dpif_linux_operate__(struct dpif_linux *dpif,
case DPIF_OP_FLOW_GET:
get = &op->u.flow_get;
if (!op->error) {
- struct dpif_linux_flow reply;
+ struct dpif_netlink_flow reply;
- op->error = dpif_linux_flow_from_ofpbuf(&reply, txn->reply);
+ op->error = dpif_netlink_flow_from_ofpbuf(&reply, txn->reply);
if (!op->error) {
- dpif_linux_flow_to_dpif_flow(get->flow, &reply);
+ dpif_netlink_flow_to_dpif_flow(get->flow, &reply);
}
}
break;
@@ -1446,13 +1476,13 @@ dpif_linux_operate__(struct dpif_linux *dpif,
}
static void
-dpif_linux_operate(struct dpif *dpif_, struct dpif_op **ops, size_t n_ops)
+dpif_netlink_operate(struct dpif *dpif_, struct dpif_op **ops, size_t n_ops)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
while (n_ops > 0) {
size_t chunk = MIN(n_ops, MAX_OPS);
- dpif_linux_operate__(dpif, ops, chunk);
+ dpif_netlink_operate__(dpif, ops, chunk);
ops += chunk;
n_ops -= chunk;
}
@@ -1463,7 +1493,7 @@ dpif_linux_operate(struct dpif *dpif_, struct dpif_op
**ops, size_t n_ops)
* any kernel vport that lacks one and deleting any channels that have no
* backing kernel vports. */
static int
-dpif_linux_refresh_channels(struct dpif_linux *dpif, uint32_t n_handlers)
+dpif_netlink_refresh_channels(struct dpif_netlink *dpif, uint32_t n_handlers)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
unsigned long int *keep_channels;
@@ -1481,6 +1511,11 @@ dpif_linux_refresh_channels(struct dpif_linux *dpif,
uint32_t n_handlers)
for (i = 0; i < n_handlers; i++) {
struct dpif_handler *handler = &dpif->handlers[i];
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
handler->epoll_fd = epoll_create(10);
if (handler->epoll_fd < 0) {
size_t j;
@@ -1493,6 +1528,7 @@ dpif_linux_refresh_channels(struct dpif_linux *dpif,
uint32_t n_handlers)
return errno;
}
+#endif
}
dpif->n_handlers = n_handlers;
}
@@ -1507,8 +1543,8 @@ dpif_linux_refresh_channels(struct dpif_linux *dpif,
uint32_t n_handlers)
keep_channels = bitmap_allocate(keep_channels_nbits);
ofpbuf_use_stub(&buf, reply_stub, sizeof reply_stub);
- dpif_linux_port_dump_start__(dpif, &dump);
- while (!dpif_linux_port_dump_next__(dpif, &dump, &vport, &buf)) {
+ dpif_netlink_port_dump_start__(dpif, &dump);
+ while (!dpif_netlink_port_dump_next__(dpif, &dump, &vport, &buf)) {
uint32_t port_no = odp_to_u32(vport.port_no);
uint32_t *upcall_pids = NULL;
int error;
@@ -1589,7 +1625,7 @@ dpif_linux_refresh_channels(struct dpif_linux *dpif,
uint32_t n_handlers)
}
static int
-dpif_linux_recv_set__(struct dpif_linux *dpif, bool enable)
+dpif_netlink_recv_set__(struct dpif_netlink *dpif, bool enable)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
if ((dpif->handlers != NULL) == enable) {
@@ -1598,32 +1634,32 @@ dpif_linux_recv_set__(struct dpif_linux *dpif, bool
enable)
destroy_all_channels(dpif);
return 0;
} else {
- return dpif_linux_refresh_channels(dpif, 1);
+ return dpif_netlink_refresh_channels(dpif, 1);
}
}
static int
-dpif_linux_recv_set(struct dpif *dpif_, bool enable)
+dpif_netlink_recv_set(struct dpif *dpif_, bool enable)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
int error;
fat_rwlock_wrlock(&dpif->upcall_lock);
- error = dpif_linux_recv_set__(dpif, enable);
+ error = dpif_netlink_recv_set__(dpif, enable);
fat_rwlock_unlock(&dpif->upcall_lock);
return error;
}
static int
-dpif_linux_handlers_set(struct dpif *dpif_, uint32_t n_handlers)
+dpif_netlink_handlers_set(struct dpif *dpif_, uint32_t n_handlers)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
int error = 0;
fat_rwlock_wrlock(&dpif->upcall_lock);
if (dpif->handlers) {
- error = dpif_linux_refresh_channels(dpif, n_handlers);
+ error = dpif_netlink_refresh_channels(dpif, n_handlers);
}
fat_rwlock_unlock(&dpif->upcall_lock);
@@ -1631,7 +1667,7 @@ dpif_linux_handlers_set(struct dpif *dpif_, uint32_t
n_handlers)
}
static int
-dpif_linux_queue_to_priority(const struct dpif *dpif OVS_UNUSED,
+dpif_netlink_queue_to_priority(const struct dpif *dpif OVS_UNUSED,
uint32_t queue_id, uint32_t *priority)
{
if (queue_id < 0xf000) {
@@ -1707,7 +1743,7 @@ parse_odp_packet(struct ofpbuf *buf, struct dpif_upcall
*upcall,
}
static int
-dpif_linux_recv__(struct dpif_linux *dpif, uint32_t handler_id,
+dpif_netlink_recv__(struct dpif_netlink *dpif, uint32_t handler_id,
struct dpif_upcall *upcall, struct ofpbuf *buf)
OVS_REQ_RDLOCK(dpif->upcall_lock)
{
@@ -1724,10 +1760,15 @@ dpif_linux_recv__(struct dpif_linux *dpif, uint32_t
handler_id,
handler->event_offset = handler->n_events = 0;
+#ifdef _WIN32
+ retval = dpif->uc_array_size;
+ handler->event_offset = 0;
+#else
do {
retval = epoll_wait(handler->epoll_fd, handler->epoll_events,
dpif->uc_array_size, 0);
} while (retval < 0 && errno == EINTR);
+#endif
if (retval < 0) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
VLOG_WARN_RL(&rl, "epoll_wait failed (%s)", ovs_strerror(errno));
@@ -1781,42 +1822,48 @@ dpif_linux_recv__(struct dpif_linux *dpif, uint32_t
handler_id,
}
static int
-dpif_linux_recv(struct dpif *dpif_, uint32_t handler_id,
+dpif_netlink_recv(struct dpif *dpif_, uint32_t handler_id,
struct dpif_upcall *upcall, struct ofpbuf *buf)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
int error;
fat_rwlock_rdlock(&dpif->upcall_lock);
- error = dpif_linux_recv__(dpif, handler_id, upcall, buf);
+ error = dpif_netlink_recv__(dpif, handler_id, upcall, buf);
fat_rwlock_unlock(&dpif->upcall_lock);
return error;
}
static void
-dpif_linux_recv_wait__(struct dpif_linux *dpif, uint32_t handler_id)
+dpif_netlink_recv_wait__(struct dpif_netlink *dpif, uint32_t handler_id)
OVS_REQ_RDLOCK(dpif->upcall_lock)
{
+#ifdef _WIN32
+ /*
+ * XXX : Map appropiate Windows handle
+ */
+#else
if (dpif->handlers && handler_id < dpif->n_handlers) {
struct dpif_handler *handler = &dpif->handlers[handler_id];
poll_fd_wait(handler->epoll_fd, POLLIN);
}
+#endif
}
static void
-dpif_linux_recv_wait(struct dpif *dpif_, uint32_t handler_id)
+dpif_netlink_recv_wait(struct dpif *dpif_, uint32_t handler_id)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
fat_rwlock_rdlock(&dpif->upcall_lock);
- dpif_linux_recv_wait__(dpif, handler_id);
+ dpif_netlink_recv_wait__(dpif, handler_id);
fat_rwlock_unlock(&dpif->upcall_lock);
}
static void
-dpif_linux_recv_purge__(struct dpif_linux *dpif)
+dpif_netlink_recv_purge__(struct dpif_netlink *dpif)
OVS_REQ_WRLOCK(dpif->upcall_lock)
{
if (dpif->handlers) {
@@ -1835,55 +1882,55 @@ dpif_linux_recv_purge__(struct dpif_linux *dpif)
}
static void
-dpif_linux_recv_purge(struct dpif *dpif_)
+dpif_netlink_recv_purge(struct dpif *dpif_)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
fat_rwlock_wrlock(&dpif->upcall_lock);
- dpif_linux_recv_purge__(dpif);
+ dpif_netlink_recv_purge__(dpif);
fat_rwlock_unlock(&dpif->upcall_lock);
}
-const struct dpif_class dpif_linux_class = {
+const struct dpif_class dpif_netlink_class = {
"system",
- dpif_linux_enumerate,
+ dpif_netlink_enumerate,
NULL,
- dpif_linux_open,
- dpif_linux_close,
- dpif_linux_destroy,
- dpif_linux_run,
+ dpif_netlink_open,
+ dpif_netlink_close,
+ dpif_netlink_destroy,
+ dpif_netlink_run,
NULL, /* wait */
- dpif_linux_get_stats,
- dpif_linux_port_add,
- dpif_linux_port_del,
- dpif_linux_port_query_by_number,
- dpif_linux_port_query_by_name,
- dpif_linux_port_get_pid,
- dpif_linux_port_dump_start,
- dpif_linux_port_dump_next,
- dpif_linux_port_dump_done,
- dpif_linux_port_poll,
- dpif_linux_port_poll_wait,
- dpif_linux_flow_flush,
- dpif_linux_flow_dump_create,
- dpif_linux_flow_dump_destroy,
- dpif_linux_flow_dump_thread_create,
- dpif_linux_flow_dump_thread_destroy,
- dpif_linux_flow_dump_next,
- dpif_linux_operate,
- dpif_linux_recv_set,
- dpif_linux_handlers_set,
- dpif_linux_queue_to_priority,
- dpif_linux_recv,
- dpif_linux_recv_wait,
- dpif_linux_recv_purge,
+ dpif_netlink_get_stats,
+ dpif_netlink_port_add,
+ dpif_netlink_port_del,
+ dpif_netlink_port_query_by_number,
+ dpif_netlink_port_query_by_name,
+ dpif_netlink_port_get_pid,
+ dpif_netlink_port_dump_start,
+ dpif_netlink_port_dump_next,
+ dpif_netlink_port_dump_done,
+ dpif_netlink_port_poll,
+ dpif_netlink_port_poll_wait,
+ dpif_netlink_flow_flush,
+ dpif_netlink_flow_dump_create,
+ dpif_netlink_flow_dump_destroy,
+ dpif_netlink_flow_dump_thread_create,
+ dpif_netlink_flow_dump_thread_destroy,
+ dpif_netlink_flow_dump_next,
+ dpif_netlink_operate,
+ dpif_netlink_recv_set,
+ dpif_netlink_handlers_set,
+ dpif_netlink_queue_to_priority,
+ dpif_netlink_recv,
+ dpif_netlink_recv_wait,
+ dpif_netlink_recv_purge,
NULL, /* register_upcall_cb */
NULL, /* enable_upcall */
NULL, /* disable_upcall */
};
static int
-dpif_linux_init(void)
+dpif_netlink_init(void)
{
static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
static int error;
@@ -1918,7 +1965,7 @@ dpif_linux_init(void)
}
bool
-dpif_linux_is_internal_device(const char *name)
+dpif_netlink_is_internal_device(const char *name)
{
struct dpif_linux_vport reply;
struct ofpbuf *buf;
@@ -2062,7 +2109,7 @@ dpif_linux_vport_transact(const struct dpif_linux_vport
*request,
ovs_assert((reply != NULL) == (bufp != NULL));
- error = dpif_linux_init();
+ error = dpif_netlink_init();
if (error) {
if (reply) {
*bufp = NULL;
@@ -2112,7 +2159,7 @@ dpif_linux_vport_get(const char *name, struct
dpif_linux_vport *reply,
* 'dp' will contain pointers into 'buf', so the caller should not free 'buf'
* while 'dp' is still in use. */
static int
-dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
+dpif_netlink_dp_from_ofpbuf(struct dpif_netlink_dp *dp, const struct ofpbuf
*buf)
{
static const struct nl_policy ovs_datapath_policy[] = {
[OVS_DP_ATTR_NAME] = { .type = NL_A_STRING, .max_len = IFNAMSIZ },
@@ -2129,7 +2176,7 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const
struct ofpbuf *buf)
struct genlmsghdr *genl;
struct ofpbuf b;
- dpif_linux_dp_init(dp);
+ dpif_netlink_dp_init(dp);
ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
@@ -2158,7 +2205,7 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const
struct ofpbuf *buf)
/* Appends to 'buf' the Generic Netlink message described by 'dp'. */
static void
-dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp, struct ofpbuf *buf)
+dpif_netlink_dp_to_ofpbuf(const struct dpif_netlink_dp *dp, struct ofpbuf *buf)
{
struct ovs_header *ovs_header;
@@ -2186,22 +2233,22 @@ dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp,
struct ofpbuf *buf)
/* Clears 'dp' to "empty" values. */
static void
-dpif_linux_dp_init(struct dpif_linux_dp *dp)
+dpif_netlink_dp_init(struct dpif_netlink_dp *dp)
{
memset(dp, 0, sizeof *dp);
}
static void
-dpif_linux_dp_dump_start(struct nl_dump *dump)
+dpif_netlink_dp_dump_start(struct nl_dump *dump)
{
- struct dpif_linux_dp request;
+ struct dpif_netlink_dp request;
struct ofpbuf *buf;
- dpif_linux_dp_init(&request);
+ dpif_netlink_dp_init(&request);
request.cmd = OVS_DP_CMD_GET;
buf = ofpbuf_new(1024);
- dpif_linux_dp_to_ofpbuf(&request, buf);
+ dpif_netlink_dp_to_ofpbuf(&request, buf);
nl_dump_start(dump, NETLINK_GENERIC, buf);
ofpbuf_delete(buf);
}
@@ -2213,8 +2260,8 @@ dpif_linux_dp_dump_start(struct nl_dump *dump)
* and stored in '*reply' and '*bufp'. The caller must free '*bufp' when the
* reply is no longer needed ('reply' will contain pointers into '*bufp'). */
static int
-dpif_linux_dp_transact(const struct dpif_linux_dp *request,
- struct dpif_linux_dp *reply, struct ofpbuf **bufp)
+dpif_netlink_dp_transact(const struct dpif_netlink_dp *request,
+ struct dpif_netlink_dp *reply, struct ofpbuf **bufp)
{
struct ofpbuf *request_buf;
int error;
@@ -2222,14 +2269,14 @@ dpif_linux_dp_transact(const struct dpif_linux_dp
*request,
ovs_assert((reply != NULL) == (bufp != NULL));
request_buf = ofpbuf_new(1024);
- dpif_linux_dp_to_ofpbuf(request, request_buf);
+ dpif_netlink_dp_to_ofpbuf(request, request_buf);
error = nl_transact(NETLINK_GENERIC, request_buf, bufp);
ofpbuf_delete(request_buf);
if (reply) {
- dpif_linux_dp_init(reply);
+ dpif_netlink_dp_init(reply);
if (!error) {
- error = dpif_linux_dp_from_ofpbuf(reply, *bufp);
+ error = dpif_netlink_dp_from_ofpbuf(reply, *bufp);
}
if (error) {
ofpbuf_delete(*bufp);
@@ -2243,17 +2290,17 @@ dpif_linux_dp_transact(const struct dpif_linux_dp
*request,
* The caller must free '*bufp' when the reply is no longer needed ('reply'
* will contain pointers into '*bufp'). */
static int
-dpif_linux_dp_get(const struct dpif *dpif_, struct dpif_linux_dp *reply,
+dpif_netlink_dp_get(const struct dpif *dpif_, struct dpif_netlink_dp *reply,
struct ofpbuf **bufp)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- struct dpif_linux_dp request;
+ struct dpif_netlink *dpif = dpif_netlink_cast(dpif_);
+ struct dpif_netlink_dp request;
- dpif_linux_dp_init(&request);
+ dpif_netlink_dp_init(&request);
request.cmd = OVS_DP_CMD_GET;
request.dp_ifindex = dpif->dp_ifindex;
- return dpif_linux_dp_transact(&request, reply, bufp);
+ return dpif_netlink_dp_transact(&request, reply, bufp);
}
/* Parses the contents of 'buf', which contains a "struct ovs_header" followed
@@ -2263,7 +2310,7 @@ dpif_linux_dp_get(const struct dpif *dpif_, struct
dpif_linux_dp *reply,
* 'flow' will contain pointers into 'buf', so the caller should not free 'buf'
* while 'flow' is still in use. */
static int
-dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
+dpif_netlink_flow_from_ofpbuf(struct dpif_netlink_flow *flow,
const struct ofpbuf *buf)
{
static const struct nl_policy ovs_flow_policy[] = {
@@ -2283,7 +2330,7 @@ dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
struct genlmsghdr *genl;
struct ofpbuf b;
- dpif_linux_flow_init(flow);
+ dpif_netlink_flow_init(flow);
ofpbuf_use_const(&b, ofpbuf_data(buf), ofpbuf_size(buf));
nlmsg = ofpbuf_try_pull(&b, sizeof *nlmsg);
@@ -2324,7 +2371,7 @@ dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *flow,
/* Appends to 'buf' (which must initially be empty) a "struct ovs_header"
* followed by Netlink attributes corresponding to 'flow'. */
static void
-dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *flow,
+dpif_netlink_flow_to_ofpbuf(const struct dpif_netlink_flow *flow,
struct ofpbuf *buf)
{
struct ovs_header *ovs_header;
@@ -2361,7 +2408,7 @@ dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow
*flow,
/* Clears 'flow' to "empty" values. */
static void
-dpif_linux_flow_init(struct dpif_linux_flow *flow)
+dpif_netlink_flow_init(struct dpif_netlink_flow *flow)
{
memset(flow, 0, sizeof *flow);
}
@@ -2373,8 +2420,8 @@ dpif_linux_flow_init(struct dpif_linux_flow *flow)
* stored in '*reply' and '*bufp'. The caller must free '*bufp' when the reply
* is no longer needed ('reply' will contain pointers into '*bufp'). */
static int
-dpif_linux_flow_transact(struct dpif_linux_flow *request,
- struct dpif_linux_flow *reply, struct ofpbuf **bufp)
+dpif_netlink_flow_transact(struct dpif_netlink_flow *request,
+ struct dpif_netlink_flow *reply, struct ofpbuf **bufp)
{
struct ofpbuf *request_buf;
int error;
@@ -2386,16 +2433,16 @@ dpif_linux_flow_transact(struct dpif_linux_flow
*request,
}
request_buf = ofpbuf_new(1024);
- dpif_linux_flow_to_ofpbuf(request, request_buf);
+ dpif_netlink_flow_to_ofpbuf(request, request_buf);
error = nl_transact(NETLINK_GENERIC, request_buf, bufp);
ofpbuf_delete(request_buf);
if (reply) {
if (!error) {
- error = dpif_linux_flow_from_ofpbuf(reply, *bufp);
+ error = dpif_netlink_flow_from_ofpbuf(reply, *bufp);
}
if (error) {
- dpif_linux_flow_init(reply);
+ dpif_netlink_flow_init(reply);
ofpbuf_delete(*bufp);
*bufp = NULL;
}
@@ -2404,7 +2451,7 @@ dpif_linux_flow_transact(struct dpif_linux_flow *request,
}
static void
-dpif_linux_flow_get_stats(const struct dpif_linux_flow *flow,
+dpif_netlink_flow_get_stats(const struct dpif_netlink_flow *flow,
struct dpif_flow_stats *stats)
{
if (flow->stats) {
@@ -2421,7 +2468,7 @@ dpif_linux_flow_get_stats(const struct dpif_linux_flow
*flow,
/* Logs information about a packet that was recently lost in 'ch' (in
* 'dpif_'). */
static void
-report_loss(struct dpif_linux *dpif, struct dpif_channel *ch, uint32_t ch_idx,
+report_loss(struct dpif_netlink *dpif, struct dpif_channel *ch, uint32_t
ch_idx,
uint32_t handler_id)
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
diff --git a/lib/dpif-linux.h b/lib/dpif-linux.h
index a35826c..4f85e44 100644
--- a/lib/dpif-linux.h
+++ b/lib/dpif-linux.h
@@ -56,6 +56,6 @@ int dpif_linux_vport_transact(const struct dpif_linux_vport
*request,
int dpif_linux_vport_get(const char *name, struct dpif_linux_vport *reply,
struct ofpbuf **bufp);
-bool dpif_linux_is_internal_device(const char *name);
+bool dpif_netlink_is_internal_device(const char *name);
#endif /* dpif-linux.h */
diff --git a/lib/dpif-provider.h b/lib/dpif-provider.h
index 89b32dd..3f57049 100644
--- a/lib/dpif-provider.h
+++ b/lib/dpif-provider.h
@@ -358,7 +358,7 @@ struct dpif_class {
void (*disable_upcall)(struct dpif *);
};
-extern const struct dpif_class dpif_linux_class;
+extern const struct dpif_class dpif_netlink_class;
extern const struct dpif_class dpif_netdev_class;
#ifdef __cplusplus
diff --git a/lib/dpif.c b/lib/dpif.c
index bf2c5f9..51b0166 100644
--- a/lib/dpif.c
+++ b/lib/dpif.c
@@ -59,8 +59,8 @@ COVERAGE_DEFINE(dpif_purge);
COVERAGE_DEFINE(dpif_execute_with_help);
static const struct dpif_class *base_dpif_classes[] = {
-#ifdef __linux__
- &dpif_linux_class,
+#if defined(__linux__) || defined(_WIN32)
+ &dpif_netlink_class,
#endif
&dpif_netdev_class,
};
--
1.9.0.msysgit.0
_______________________________________________
dev mailing list
dev@openvswitch.org
http://openvswitch.org/mailman/listinfo/dev
