static int open_dpif(const struct dpif_linux_dp *, struct dpif **);
static uint32_t dpif_linux_port_get_pid(const struct dpif *,
odp_port_t port_no, uint32_t hash);
-static int dpif_linux_refresh_channels(struct dpif_linux *, uint32_t n_handlers);
+static int dpif_linux_refresh_channels(struct dpif_linux *,
+ 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 *,
}
static void
-destroy_all_channels(struct dpif_linux *dpif)
+destroy_all_channels(struct dpif_linux *dpif) OVS_REQ_WRLOCK(dpif->upcall_lock)
{
unsigned int i;
static int
dpif_linux_port_add__(struct dpif_linux *dpif, struct netdev *netdev,
odp_port_t *port_nop)
+ OVS_REQ_WRLOCK(dpif->upcall_lock)
{
const struct netdev_tunnel_config *tnl_cfg;
char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
request.port_no = *port_nop;
upcall_pids = vport_socksp_to_pids(socksp, dpif->n_handlers);
- request.n_upcall_pids = dpif->n_handlers;
+ request.n_upcall_pids = socksp ? dpif->n_handlers : 1;
request.upcall_pids = upcall_pids;
error = dpif_linux_vport_transact(&request, &reply, &buf);
static int
dpif_linux_port_del__(struct dpif_linux *dpif, odp_port_t port_no)
+ OVS_REQ_WRLOCK(dpif->upcall_lock)
{
struct dpif_linux_vport vport;
int error;
}
static uint32_t
-dpif_linux_port_get_pid(const struct dpif *dpif_, odp_port_t port_no,
- uint32_t hash)
+dpif_linux_port_get_pid__(const struct dpif_linux *dpif, odp_port_t port_no,
+ uint32_t hash)
+ OVS_REQ_RDLOCK(dpif->upcall_lock)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
uint32_t port_idx = odp_to_u32(port_no);
uint32_t pid = 0;
- fat_rwlock_rdlock(&dpif->upcall_lock);
if (dpif->handlers) {
/* The ODPP_NONE "reserved" port number uses the "ovs-system"'s
* channel, since it is not heavily loaded. */
pid = nl_sock_pid(h->channels[idx].sock);
}
- fat_rwlock_unlock(&dpif->upcall_lock);
return pid;
}
+static uint32_t
+dpif_linux_port_get_pid(const struct dpif *dpif_, odp_port_t port_no,
+ uint32_t hash)
+{
+ const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+ uint32_t ret;
+
+ fat_rwlock_rdlock(&dpif->upcall_lock);
+ ret = dpif_linux_port_get_pid__(dpif, port_no, hash);
+ fat_rwlock_unlock(&dpif->upcall_lock);
+
+ return ret;
+}
+
static int
dpif_linux_flow_flush(struct dpif *dpif_)
{
static int
dpif_linux_flow_get(const struct dpif *dpif_,
const struct nlattr *key, size_t key_len,
- struct ofpbuf **actionsp, struct dpif_flow_stats *stats)
+ struct ofpbuf **bufp,
+ struct nlattr **maskp, size_t *mask_len,
+ struct nlattr **actionsp, size_t *actions_len,
+ struct dpif_flow_stats *stats)
{
const struct dpif_linux *dpif = dpif_linux_cast(dpif_);
struct dpif_linux_flow reply;
- struct ofpbuf *buf;
int error;
- error = dpif_linux_flow_get__(dpif, key, key_len, &reply, &buf);
+ error = dpif_linux_flow_get__(dpif, key, key_len, &reply, bufp);
if (!error) {
- if (stats) {
- dpif_linux_flow_get_stats(&reply, stats);
+ if (maskp) {
+ *maskp = CONST_CAST(struct nlattr *, reply.mask);
+ *mask_len = reply.mask_len;
}
if (actionsp) {
- ofpbuf_set_data(buf, CONST_CAST(struct nlattr *, reply.actions));
- ofpbuf_set_size(buf, reply.actions_len);
- *actionsp = buf;
- } else {
- ofpbuf_delete(buf);
+ *actionsp = CONST_CAST(struct nlattr *, reply.actions);
+ *actions_len = reply.actions_len;
+ }
+ if (stats) {
+ dpif_linux_flow_get_stats(&reply, stats);
}
}
return error;
}
if (actions && !state->flow.actions) {
+ struct dpif_linux_flow reply;
+
+ /* Keys are required to be allocated from 'state->buffer' so
+ * they're preserved across calls. Therefore we need a separate
+ * reply to prevent them from being overwritten. Actions, however,
+ * don't have this requirement, so it's that fine they're destroyed
+ * on the next call. */
error = dpif_linux_flow_get__(dpif, state->flow.key,
state->flow.key_len,
- &state->flow, &state->tmp);
+ &reply, &state->tmp);
+ state->flow.actions = reply.actions;
+ state->flow.actions_len = reply.actions_len;
+
if (error == ENOENT) {
VLOG_DBG("dumped flow disappeared on get");
} else if (error) {
dpif_linux_flow_dump_next_may_destroy_keys(void *state_)
{
struct dpif_linux_flow_state *state = state_;
+ struct dpif_linux_flow flow;
+ struct ofpbuf nlmsg;
- return ofpbuf_size(&state->buffer) ? false : true;
+ /* Check whether there's a flow remaining in the buffer that includes
+ * actions. (If it does not include actions, then we could end up
+ * destroying keys previously returned trying to retrieve its actions
+ * fails.) */
+ return (!nl_dump_peek(&nlmsg, &state->buffer)
+ || dpif_linux_flow_from_ofpbuf(&flow, &nlmsg)
+ || !flow.actions);
}
static int
* backing kernel vports. */
static int
dpif_linux_refresh_channels(struct dpif_linux *dpif, uint32_t n_handlers)
+ OVS_REQ_WRLOCK(dpif->upcall_lock)
{
unsigned long int *keep_channels;
struct dpif_linux_vport vport;
static int
dpif_linux_recv_set__(struct dpif_linux *dpif, bool enable)
+ OVS_REQ_WRLOCK(dpif->upcall_lock)
{
if ((dpif->handlers != NULL) == enable) {
return 0;
static int
dpif_linux_recv__(struct dpif_linux *dpif, uint32_t handler_id,
struct dpif_upcall *upcall, struct ofpbuf *buf)
+ OVS_REQ_RDLOCK(dpif->upcall_lock)
{
struct dpif_handler *handler;
int read_tries = 0;
}
static void
-dpif_linux_recv_wait(struct dpif *dpif_, uint32_t handler_id)
+dpif_linux_recv_wait__(struct dpif_linux *dpif, uint32_t handler_id)
+ OVS_REQ_RDLOCK(dpif->upcall_lock)
{
- struct dpif_linux *dpif = dpif_linux_cast(dpif_);
-
- fat_rwlock_rdlock(&dpif->upcall_lock);
if (dpif->handlers && handler_id < dpif->n_handlers) {
struct dpif_handler *handler = &dpif->handlers[handler_id];
poll_fd_wait(handler->epoll_fd, POLLIN);
}
- fat_rwlock_unlock(&dpif->upcall_lock);
}
static void
-dpif_linux_recv_purge(struct dpif *dpif_)
+dpif_linux_recv_wait(struct dpif *dpif_, uint32_t handler_id)
{
struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- fat_rwlock_wrlock(&dpif->upcall_lock);
+ fat_rwlock_rdlock(&dpif->upcall_lock);
+ dpif_linux_recv_wait__(dpif, handler_id);
+ fat_rwlock_unlock(&dpif->upcall_lock);
+}
+
+static void
+dpif_linux_recv_purge__(struct dpif_linux *dpif)
+ OVS_REQ_WRLOCK(dpif->upcall_lock)
+{
if (dpif->handlers) {
size_t i, j;
}
}
}
+}
+
+static void
+dpif_linux_recv_purge(struct dpif *dpif_)
+{
+ struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+
+ fat_rwlock_wrlock(&dpif->upcall_lock);
+ dpif_linux_recv_purge__(dpif);
fat_rwlock_unlock(&dpif->upcall_lock);
}
projects / cascardo / ovs.git / blobdiff