[ovs-dev] [thread 15/15] ofproto-dpif: Implement multi-threaded miss handling.

Ethan Jackson ethan at nicira.com
Thu Aug 8 19:58:34 UTC 2013


This patch factors flow miss handling into its own module,
ofproto-dpif-upcall which can utilize multiple threads to process
misses.  For some important benchmarks, this change improves Open
vSwitch flow setup performance by roughly 50x (that's 50 times not
50%) in my testing.

Signed-off-by: Ethan Jackson <ethan at nicira.com>
---
 ofproto/automake.mk           |    2 +
 ofproto/ofproto-dpif-upcall.c |  820 +++++++++++++++++++++++++++++++++++++++++
 ofproto/ofproto-dpif-upcall.h |  110 ++++++
 ofproto/ofproto-dpif-xlate.h  |    4 +-
 ofproto/ofproto-dpif.c        |  647 ++++++--------------------------
 ofproto/ofproto-dpif.h        |   26 ++
 6 files changed, 1077 insertions(+), 532 deletions(-)
 create mode 100644 ofproto/ofproto-dpif-upcall.c
 create mode 100644 ofproto/ofproto-dpif-upcall.h

diff --git a/ofproto/automake.mk b/ofproto/automake.mk
index af9a12a..47ca1b8 100644
--- a/ofproto/automake.mk
+++ b/ofproto/automake.mk
@@ -30,6 +30,8 @@ ofproto_libofproto_a_SOURCES = \
 	ofproto/ofproto-dpif-mirror.h \
 	ofproto/ofproto-dpif-sflow.c \
 	ofproto/ofproto-dpif-sflow.h \
+	ofproto/ofproto-dpif-upcall.c \
+	ofproto/ofproto-dpif-upcall.h \
 	ofproto/ofproto-dpif-xlate.c \
 	ofproto/ofproto-dpif-xlate.h \
 	ofproto/ofproto-provider.h \
diff --git a/ofproto/ofproto-dpif-upcall.c b/ofproto/ofproto-dpif-upcall.c
new file mode 100644
index 0000000..9168098
--- /dev/null
+++ b/ofproto/ofproto-dpif-upcall.c
@@ -0,0 +1,820 @@
+/* Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ *
+ * 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 "ofproto-dpif-upcall.h"
+
+#include <errno.h>
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "coverage.h"
+#include "dynamic-string.h"
+#include "dpif.h"
+#include "fail-open.h"
+#include "latch.h"
+#include "seq.h"
+#include "list.h"
+#include "netlink.h"
+#include "ofpbuf.h"
+#include "ofproto-dpif.h"
+#include "packets.h"
+#include "poll-loop.h"
+#include "vlog.h"
+
+#define MAX_QUEUE_LENGTH 512
+
+VLOG_DEFINE_THIS_MODULE(ofproto_dpif_upcall);
+
+COVERAGE_DEFINE(upcall_queue_overflow);
+COVERAGE_DEFINE(drop_queue_overflow);
+COVERAGE_DEFINE(miss_queue_overflow);
+COVERAGE_DEFINE(fmb_queue_overflow);
+
+struct handler {
+    struct udpif *udpif;               /* Parent udpif. */
+    pthread_t thread;                  /* Thread ID. */
+
+    struct ovs_mutex mutex;            /* Mutex guarding the following. */
+
+    /* Atomic queue of unprocessed miss upcalls. */
+    struct list upcalls OVS_GUARDED;
+    size_t n_upcalls OVS_GUARDED;
+
+    pthread_cond_t wake_cond;          /* Wakes 'thread' while holding
+                                          'mutex'. */
+};
+
+struct udpif {
+    struct dpif *dpif;                 /* Datapath handle. */
+    struct dpif_backer *backer;        /* Opaque dpif_backer pointer. */
+
+    uint32_t secret;                   /* Random seed for upcall hash. */
+
+    pthread_t dispatcher;              /* Dispatcher thrad ID. */
+
+    struct handler *handlers;          /* Miss handlers. */
+    size_t n_handlers;
+
+    /* Atomic queue of unprocessed drop keys. */
+    struct ovs_mutex drop_key_mutex;
+    struct list drop_keys OVS_GUARDED;
+    size_t n_drop_keys OVS_GUARDED;
+
+    /* Atomic queue of special upcalls for ofproto-dpif to process. */
+    struct ovs_mutex upcall_mutex;
+    struct list upcalls OVS_GUARDED;
+    size_t n_upcalls OVS_GUARDED;
+
+    /* Atomic queue of flow_miss_batches. */
+    struct ovs_mutex fmb_mutex;
+    struct list fmbs OVS_GUARDED;
+    size_t n_fmbs OVS_GUARDED;
+
+    /* Number of times udpif_revalidate() has been called. */
+    atomic_uint reval_seq;
+
+    struct seq* wait_seq;
+    uint64_t last_seq;
+
+    struct latch exit_latch; /* Tells child threads to exit. */
+};
+
+static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+
+static void recv_upcalls(struct udpif *);
+static void handle_miss_upcalls(struct udpif *, struct list *upcalls);
+static void miss_destroy(struct flow_miss *);
+static void *udpif_dispatcher(void *);
+static void *udpif_miss_handler(void *);
+
+struct udpif *
+udpif_create(struct dpif_backer *backer, struct dpif *dpif)
+{
+    struct udpif *udpif = xzalloc(sizeof *udpif);
+
+    udpif->dpif = dpif;
+    udpif->backer = backer;
+    udpif->secret = random_uint32();
+    udpif->wait_seq = seq_create();
+    latch_init(&udpif->exit_latch);
+    list_init(&udpif->drop_keys);
+    list_init(&udpif->upcalls);
+    list_init(&udpif->fmbs);
+    atomic_init(&udpif->reval_seq, 0);
+
+    return udpif;
+}
+
+void
+udpif_destroy(struct udpif *udpif)
+{
+    struct flow_miss_batch *fmb;
+    struct drop_key *drop_key;
+    struct upcall *upcall;
+
+    udpif_recv_set(udpif, 0, false);
+
+    while ((drop_key = drop_key_next(udpif))) {
+        drop_key_destroy(drop_key);
+    }
+
+    while ((upcall = upcall_next(udpif))) {
+        upcall_destroy(upcall);
+    }
+
+    while ((fmb = flow_miss_batch_next(udpif))) {
+        flow_miss_batch_destroy(fmb);
+    }
+
+    ovs_mutex_destroy(&udpif->drop_key_mutex);
+    ovs_mutex_destroy(&udpif->upcall_mutex);
+    ovs_mutex_destroy(&udpif->fmb_mutex);
+    latch_destroy(&udpif->exit_latch);
+    seq_destroy(udpif->wait_seq);
+    free(udpif);
+}
+
+/* Tells 'udpif' to begin or stop handling flow misses depending on the value
+ * of 'enable'.  'n_handlers' is the number of miss_handler threads to create.
+ * Passing 'n_handlers' as zero is equivalent to passing 'enable' as false. */
+void
+udpif_recv_set(struct udpif *udpif, size_t n_handlers, bool enable)
+{
+    n_handlers = enable ? n_handlers : 0;
+    n_handlers = MIN(n_handlers, 64);
+
+    /* Stop the old threads (if any). */
+    if (udpif->handlers && udpif->n_handlers != n_handlers) {
+        size_t i;
+
+        latch_set(&udpif->exit_latch);
+
+        /* Wake the handlers so they can exit. */
+        for (i = 0; i < udpif->n_handlers; i++) {
+            struct handler *handler = &udpif->handlers[i];
+
+            ovs_mutex_lock(&handler->mutex);
+            xpthread_cond_signal(&handler->wake_cond);
+            ovs_mutex_unlock(&handler->mutex);
+        }
+
+        xpthread_join(udpif->dispatcher, NULL);
+        for (i = 0; i < udpif->n_handlers; i++) {
+            struct handler *handler = &udpif->handlers[i];
+            struct upcall *miss, *next;
+
+            xpthread_join(handler->thread, NULL);
+
+            ovs_mutex_lock(&handler->mutex);
+            LIST_FOR_EACH_SAFE (miss, next, list_node, &handler->upcalls) {
+                list_remove(&miss->list_node);
+                upcall_destroy(miss);
+            }
+            ovs_mutex_unlock(&handler->mutex);
+            ovs_mutex_destroy(&handler->mutex);
+
+            xpthread_cond_destroy(&handler->wake_cond);
+        }
+        latch_poll(&udpif->exit_latch);
+
+        free(udpif->handlers);
+        udpif->handlers = NULL;
+        udpif->n_handlers = 0;
+    }
+
+    /* Start new threads (if necessary). */
+    if (!udpif->handlers && n_handlers) {
+        size_t i;
+
+        udpif->n_handlers = n_handlers;
+        udpif->handlers = xzalloc(udpif->n_handlers * sizeof *udpif->handlers);
+        for (i = 0; i < udpif->n_handlers; i++) {
+            struct handler *handler = &udpif->handlers[i];
+
+            handler->udpif = udpif;
+            list_init(&handler->upcalls);
+            xpthread_cond_init(&handler->wake_cond, NULL);
+            ovs_mutex_init(&handler->mutex, PTHREAD_MUTEX_NORMAL);
+            xpthread_create(&handler->thread, NULL, udpif_miss_handler, handler);
+        }
+        xpthread_create(&udpif->dispatcher, NULL, udpif_dispatcher, udpif);
+    }
+}
+
+void
+udpif_run(struct udpif *udpif)
+{
+    udpif->last_seq = seq_read(udpif->wait_seq);
+}
+
+void
+udpif_wait(struct udpif *udpif)
+{
+    ovs_mutex_lock(&udpif->drop_key_mutex);
+    if (udpif->n_drop_keys) {
+        poll_immediate_wake();
+    }
+    ovs_mutex_unlock(&udpif->drop_key_mutex);
+
+    ovs_mutex_lock(&udpif->upcall_mutex);
+    if (udpif->n_upcalls) {
+        poll_immediate_wake();
+    }
+    ovs_mutex_unlock(&udpif->upcall_mutex);
+
+    ovs_mutex_lock(&udpif->fmb_mutex);
+    if (udpif->n_fmbs) {
+        poll_immediate_wake();
+    }
+    ovs_mutex_unlock(&udpif->fmb_mutex);
+
+    seq_wait(udpif->wait_seq, udpif->last_seq);
+}
+
+/* Notifies 'udpif' that something changed which may render previous
+ * xlate_actions() results invalid. */
+void
+udpif_revalidate(struct udpif *udpif)
+{
+    struct flow_miss_batch *fmb, *next_fmb;
+    unsigned int junk;
+
+    /* Since we remove each miss on revalidation, their statistics won't be
+     * accounted to the appropriate 'facet's in the upper layer.  In most
+     * cases, this is alright because we've already pushed the stats to the
+     * relevant rules.  However, NetFlow requires absolute packet counts on
+     * 'facet's which could now be incorrect. */
+    ovs_mutex_lock(&udpif->fmb_mutex);
+    atomic_add(&udpif->reval_seq, 1, &junk);
+    LIST_FOR_EACH_SAFE (fmb, next_fmb, list_node, &udpif->fmbs) {
+        list_remove(&fmb->list_node);
+        flow_miss_batch_destroy(fmb);
+        udpif->n_fmbs--;
+    }
+    ovs_mutex_unlock(&udpif->fmb_mutex);
+    udpif_drop_key_clear(udpif);
+}
+
+/* Retreives the next upcall which ofproto-dpif is responsible for handling.
+ * The caller is responsible for destroying the returned upcall with
+ * upcall_destroy(). */
+struct upcall *
+upcall_next(struct udpif *udpif)
+{
+    struct upcall *next = NULL;
+
+    ovs_mutex_lock(&udpif->upcall_mutex);
+    if (udpif->n_upcalls) {
+        udpif->n_upcalls--;
+        next = CONTAINER_OF(list_pop_front(&udpif->upcalls), struct upcall,
+                            list_node);
+    }
+    ovs_mutex_unlock(&udpif->upcall_mutex);
+    return next;
+}
+
+/* Destroys and deallocates 'upcall'. */
+void
+upcall_destroy(struct upcall *upcall)
+{
+    if (upcall) {
+        ofpbuf_uninit(&upcall->upcall_buf);
+        free(upcall);
+    }
+}
+
+/* Retreives the next batch of processed flow misses for 'udpif' to install.
+ * The caller is responsible for destroying it with flow_miss_batch_destroy().
+ */
+struct flow_miss_batch *
+flow_miss_batch_next(struct udpif *udpif)
+{
+    struct flow_miss_batch *next = NULL;
+
+    ovs_mutex_lock(&udpif->fmb_mutex);
+    if (udpif->n_fmbs) {
+        udpif->n_fmbs--;
+        next = CONTAINER_OF(list_pop_front(&udpif->fmbs),
+                            struct flow_miss_batch, list_node);
+    }
+    ovs_mutex_unlock(&udpif->fmb_mutex);
+    return next;
+}
+
+/* Destroys and deallocates 'fmb'. */
+void
+flow_miss_batch_destroy(struct flow_miss_batch *fmb)
+{
+    struct flow_miss *miss, *next;
+
+    if (!fmb) {
+        return;
+    }
+
+    HMAP_FOR_EACH_SAFE (miss, next, hmap_node, &fmb->misses) {
+        hmap_remove(&fmb->misses, &miss->hmap_node);
+        miss_destroy(miss);
+    }
+
+    hmap_destroy(&fmb->misses);
+    free(fmb);
+}
+
+/* Retreives the next drop key which ofproto-dpif needs to process.  The caller
+ * is responsible for destroying it with drop_key_destroy(). */
+struct drop_key *
+drop_key_next(struct udpif *udpif)
+{
+    struct drop_key *next = NULL;
+
+    ovs_mutex_lock(&udpif->drop_key_mutex);
+    if (udpif->n_drop_keys) {
+        udpif->n_drop_keys--;
+        next = CONTAINER_OF(list_pop_front(&udpif->drop_keys), struct drop_key,
+                            list_node);
+    }
+    ovs_mutex_unlock(&udpif->drop_key_mutex);
+    return next;
+}
+
+/* Destorys and deallocates 'drop_key'. */
+void
+drop_key_destroy(struct drop_key *drop_key)
+{
+    if (drop_key) {
+        free(drop_key->key);
+        free(drop_key);
+    }
+}
+
+/* Clears all drop keys waiting to be processed by drop_key_next(). */
+void
+udpif_drop_key_clear(struct udpif *udpif)
+{
+    struct drop_key *drop_key, *next;
+
+    ovs_mutex_lock(&udpif->drop_key_mutex);
+    LIST_FOR_EACH_SAFE (drop_key, next, list_node, &udpif->drop_keys) {
+        list_remove(&drop_key->list_node);
+        drop_key_destroy(drop_key);
+        udpif->n_drop_keys--;
+    }
+    ovs_mutex_unlock(&udpif->drop_key_mutex);
+}
+
+/* The dispatcher thread is responsible for receving upcalls from the kernel,
+ * assigning the miss upcalls to a miss_handler thread, and assigning the more
+ * complex ones to ofproto-dpif directly. */
+static void *
+udpif_dispatcher(void *arg)
+{
+    struct udpif *udpif = arg;
+
+    set_subprogram_name("dispatcher");
+    for (;;) {
+        if (latch_is_set(&udpif->exit_latch)) {
+            return NULL;
+        }
+
+        recv_upcalls(udpif);
+        dpif_recv_wait(udpif->dpif);
+        latch_wait(&udpif->exit_latch);
+        poll_block();
+    }
+}
+
+/* The miss handler thread is responsible for processing miss upcalls retreived
+ * by the dispatcher thread.  Once finished it passes the processed miss
+ * upcalls to ofproto-dpif where they're installed in the datapath. */
+static void *
+udpif_miss_handler(void *arg)
+{
+    struct list misses = LIST_INITIALIZER(&misses);
+    struct handler *handler = arg;
+
+    set_subprogram_name("miss_handler");
+    for (;;) {
+        size_t i;
+
+        ovs_mutex_lock(&handler->mutex);
+
+        if (latch_is_set(&handler->udpif->exit_latch)) {
+            ovs_mutex_unlock(&handler->mutex);
+            return NULL;
+        }
+
+        if (!handler->n_upcalls) {
+            ovs_mutex_cond_wait(&handler->wake_cond, &handler->mutex);
+        }
+
+        for (i = 0; i < FLOW_MISS_MAX_BATCH; i++) {
+            if (handler->n_upcalls) {
+                handler->n_upcalls--;
+                list_push_back(&misses, list_pop_front(&handler->upcalls));
+            } else {
+                break;
+            }
+        }
+        ovs_mutex_unlock(&handler->mutex);
+
+        handle_miss_upcalls(handler->udpif, &misses);
+    }
+}
+
+static void
+miss_destroy(struct flow_miss *miss)
+{
+    struct upcall *upcall, *next;
+
+    LIST_FOR_EACH_SAFE (upcall, next, list_node, &miss->upcalls) {
+        list_remove(&upcall->list_node);
+        upcall_destroy(upcall);
+    }
+    xlate_out_uninit(&miss->xout);
+}
+
+static enum upcall_type
+classify_upcall(const struct upcall *upcall)
+{
+    const struct dpif_upcall *dpif_upcall = &upcall->dpif_upcall;
+    union user_action_cookie cookie;
+    size_t userdata_len;
+
+    /* First look at the upcall type. */
+    switch (dpif_upcall->type) {
+    case DPIF_UC_ACTION:
+        break;
+
+    case DPIF_UC_MISS:
+        return MISS_UPCALL;
+
+    case DPIF_N_UC_TYPES:
+    default:
+        VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32,
+                     dpif_upcall->type);
+        return BAD_UPCALL;
+    }
+
+    /* "action" upcalls need a closer look. */
+    if (!dpif_upcall->userdata) {
+        VLOG_WARN_RL(&rl, "action upcall missing cookie");
+        return BAD_UPCALL;
+    }
+    userdata_len = nl_attr_get_size(dpif_upcall->userdata);
+    if (userdata_len < sizeof cookie.type
+        || userdata_len > sizeof cookie) {
+        VLOG_WARN_RL(&rl, "action upcall cookie has unexpected size %zu",
+                     userdata_len);
+        return BAD_UPCALL;
+    }
+    memset(&cookie, 0, sizeof cookie);
+    memcpy(&cookie, nl_attr_get(dpif_upcall->userdata), userdata_len);
+    if (userdata_len == sizeof cookie.sflow
+        && cookie.type == USER_ACTION_COOKIE_SFLOW) {
+        return SFLOW_UPCALL;
+    } else if (userdata_len == sizeof cookie.slow_path
+               && cookie.type == USER_ACTION_COOKIE_SLOW_PATH) {
+        return MISS_UPCALL;
+    } else if (userdata_len == sizeof cookie.flow_sample
+               && cookie.type == USER_ACTION_COOKIE_FLOW_SAMPLE) {
+        return FLOW_SAMPLE_UPCALL;
+    } else if (userdata_len == sizeof cookie.ipfix
+               && cookie.type == USER_ACTION_COOKIE_IPFIX) {
+        return IPFIX_UPCALL;
+    } else {
+        VLOG_WARN_RL(&rl, "invalid user cookie of type %"PRIu16
+                     " and size %zu", cookie.type, userdata_len);
+        return BAD_UPCALL;
+    }
+}
+
+static void
+recv_upcalls(struct udpif *udpif)
+{
+    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
+    for (;;) {
+        struct upcall *upcall;
+        int error;
+
+        upcall = xmalloc(sizeof *upcall);
+        ofpbuf_use_stub(&upcall->upcall_buf, upcall->upcall_stub,
+                        sizeof upcall->upcall_stub);
+        error = dpif_recv(udpif->dpif, &upcall->dpif_upcall,
+                          &upcall->upcall_buf);
+        if (error) {
+            upcall_destroy(upcall);
+            break;
+        }
+
+        upcall->type = classify_upcall(upcall);
+        if (upcall->type == BAD_UPCALL) {
+            upcall_destroy(upcall);
+        } else if (upcall->type == MISS_UPCALL) {
+            struct dpif_upcall *dupcall = &upcall->dpif_upcall;
+            uint32_t hash = udpif->secret;
+            struct handler *handler;
+            struct nlattr *nla;
+            size_t n_bytes, left;
+
+            n_bytes = 0;
+            NL_ATTR_FOR_EACH (nla, left, dupcall->key, dupcall->key_len) {
+                enum ovs_key_attr type = nl_attr_type(nla);
+                if (type == OVS_KEY_ATTR_IN_PORT
+                    || type == OVS_KEY_ATTR_TCP
+                    || type == OVS_KEY_ATTR_UDP) {
+                    if (nl_attr_get_size(nla) == 4) {
+                        ovs_be32 attr = nl_attr_get_be32(nla);
+                        hash = mhash_add(hash, (uint32_t) attr);
+                        n_bytes += 4;
+                    } else {
+                        VLOG_WARN("Netlink attribute with incorrect size.");
+                    }
+                }
+            }
+           hash =  mhash_finish(hash, n_bytes);
+
+           handler = &udpif->handlers[hash % udpif->n_handlers];
+
+           ovs_mutex_lock(&handler->mutex);
+           if (handler->n_upcalls < MAX_QUEUE_LENGTH) {
+               list_push_back(&handler->upcalls, &upcall->list_node);
+               handler->n_upcalls++;
+               xpthread_cond_signal(&handler->wake_cond);
+               ovs_mutex_unlock(&handler->mutex);
+               if (!VLOG_DROP_DBG(&rl)) {
+                   struct ds ds = DS_EMPTY_INITIALIZER;
+
+                   odp_flow_key_format(upcall->dpif_upcall.key,
+                                       upcall->dpif_upcall.key_len,
+                                       &ds);
+                   VLOG_DBG("dispatcher: miss enqueue (%s)", ds_cstr(&ds));
+                   ds_destroy(&ds);
+               }
+           } else {
+               ovs_mutex_unlock(&handler->mutex);
+               COVERAGE_INC(miss_queue_overflow);
+               upcall_destroy(upcall);
+           }
+        } else {
+            ovs_mutex_lock(&udpif->upcall_mutex);
+            if (udpif->n_upcalls < MAX_QUEUE_LENGTH) {
+                udpif->n_upcalls++;
+                list_push_back(&udpif->upcalls, &upcall->list_node);
+                ovs_mutex_unlock(&udpif->upcall_mutex);
+                seq_change(udpif->wait_seq);
+            } else {
+                ovs_mutex_unlock(&udpif->upcall_mutex);
+                COVERAGE_INC(upcall_queue_overflow);
+                upcall_destroy(upcall);
+            }
+        }
+    }
+}
+
+static struct flow_miss *
+flow_miss_find(struct hmap *todo, const struct ofproto_dpif *ofproto,
+               const struct flow *flow, uint32_t hash)
+{
+    struct flow_miss *miss;
+
+    HMAP_FOR_EACH_WITH_HASH (miss, hmap_node, hash, todo) {
+        if (miss->ofproto == ofproto && flow_equal(&miss->flow, flow)) {
+            return miss;
+        }
+    }
+
+    return NULL;
+}
+
+/* Executes flow miss 'miss'.  May add any required datapath operations
+ * to 'ops', incrementing '*n_ops' for each new op. */
+static void
+execute_flow_miss(struct flow_miss *miss, struct dpif_op *ops, size_t *n_ops)
+{
+    struct ofproto_dpif *ofproto = miss->ofproto;
+    struct flow_wildcards wc;
+    struct rule_dpif *rule;
+    struct ofpbuf *packet;
+    struct xlate_in xin;
+
+    memset(&miss->stats, 0, sizeof miss->stats);
+    miss->stats.used = time_msec();
+    LIST_FOR_EACH (packet, list_node, &miss->packets) {
+        miss->stats.tcp_flags |= packet_get_tcp_flags(packet, &miss->flow);
+        miss->stats.n_bytes += packet->size;
+        miss->stats.n_packets++;
+    }
+
+    flow_wildcards_init_catchall(&wc);
+    rule_dpif_lookup(ofproto, &miss->flow, &wc, &rule);
+    rule_credit_stats(rule, &miss->stats);
+    xlate_in_init(&xin, ofproto, &miss->flow, rule, miss->stats.tcp_flags,
+                  NULL);
+    xin.may_learn = true;
+    xin.resubmit_stats = &miss->stats;
+    xlate_actions(&xin, &miss->xout);
+    flow_wildcards_or(&miss->xout.wc, &miss->xout.wc, &wc);
+
+    if (rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
+        struct ofputil_packet_in pin;
+
+        /* Extra-special case for fail-open mode.
+         *
+         * We are in fail-open mode and the packet matched the fail-open
+         * rule, but we are connected to a controller too.  We should send
+         * the packet up to the controller in the hope that it will try to
+         * set up a flow and thereby allow us to exit fail-open.
+         *
+         * See the top-level comment in fail-open.c for more information. */
+        pin.packet = packet->data;
+        pin.packet_len = packet->size;
+        pin.reason = OFPR_NO_MATCH;
+        pin.controller_id = 0;
+        pin.table_id = 0;
+        pin.cookie = 0;
+        pin.send_len = 0; /* Not used for flow table misses. */
+        flow_get_metadata(&miss->flow, &pin.fmd);
+        ofproto_dpif_send_packet_in(ofproto, &pin);
+    }
+
+    if (miss->xout.slow) {
+        LIST_FOR_EACH (packet, list_node, &miss->packets) {
+            struct xlate_in xin;
+
+            xlate_in_init(&xin, miss->ofproto, &miss->flow, rule, 0, packet);
+            xlate_actions_for_side_effects(&xin);
+        }
+    }
+    rule_release(rule);
+
+    if (miss->xout.odp_actions.size) {
+        LIST_FOR_EACH (packet, list_node, &miss->packets) {
+            struct dpif_op *op = &ops[*n_ops];
+            struct dpif_execute *execute = &op->u.execute;
+
+            if (miss->flow.in_port.ofp_port
+                != vsp_realdev_to_vlandev(miss->ofproto,
+                                          miss->flow.in_port.ofp_port,
+                                          miss->flow.vlan_tci)) {
+                /* This packet was received on a VLAN splinter port.  We
+                 * added a VLAN to the packet to make the packet resemble
+                 * the flow, but the actions were composed assuming that
+                 * the packet contained no VLAN.  So, we must remove the
+                 * VLAN header from the packet before trying to execute the
+                 * actions. */
+                eth_pop_vlan(packet);
+            }
+
+            op->type = DPIF_OP_EXECUTE;
+            execute->key = miss->key;
+            execute->key_len = miss->key_len;
+            execute->packet = packet;
+            execute->actions = miss->xout.odp_actions.data;
+            execute->actions_len = miss->xout.odp_actions.size;
+
+            (*n_ops)++;
+        }
+    }
+}
+
+static void
+handle_miss_upcalls(struct udpif *udpif, struct list *upcalls)
+{
+    struct dpif_op *opsp[FLOW_MISS_MAX_BATCH];
+    struct dpif_op ops[FLOW_MISS_MAX_BATCH];
+    unsigned int old_reval_seq, new_reval_seq;
+    struct upcall *upcall, *next;
+    struct flow_miss_batch *fmb;
+    size_t n_upcalls, n_ops, i;
+    struct flow_miss *miss;
+
+    atomic_read(&udpif->reval_seq, &old_reval_seq);
+
+    /* Construct the to-do list.
+     *
+     * This just amounts to extracting the flow from each packet and sticking
+     * the packets that have the same flow in the same "flow_miss" structure so
+     * that we can process them together. */
+    fmb = xmalloc(sizeof *fmb);
+    hmap_init(&fmb->misses);
+    n_upcalls = 0;
+    LIST_FOR_EACH_SAFE (upcall, next, list_node, upcalls) {
+        struct dpif_upcall *dupcall = &upcall->dpif_upcall;
+        struct flow_miss *miss = &fmb->miss_buf[n_upcalls];
+        struct flow_miss *existing_miss;
+        struct ofproto_dpif *ofproto;
+        odp_port_t odp_in_port;
+        struct flow flow;
+        uint32_t hash;
+        int error;
+
+        error = xlate_receive(udpif->backer, dupcall->packet, dupcall->key,
+                              dupcall->key_len, &flow, &miss->key_fitness,
+                              &ofproto, &odp_in_port);
+
+        if (error == ENODEV) {
+            struct drop_key *drop_key;
+
+            /* Received packet on datapath port for which we couldn't
+             * associate an ofproto.  This can happen if a port is removed
+             * while traffic is being received.  Print a rate-limited message
+             * in case it happens frequently.  Install a drop flow so
+             * that future packets of the flow are inexpensively dropped
+             * in the kernel. */
+            VLOG_INFO_RL(&rl, "received packet on unassociated datapath port "
+                              "%"PRIu32, odp_in_port);
+
+            drop_key = xmalloc(sizeof *drop_key);
+            drop_key->key = xmemdup(dupcall->key, dupcall->key_len);
+            drop_key->key_len = dupcall->key_len;
+
+            ovs_mutex_lock(&udpif->drop_key_mutex);
+            if (udpif->n_drop_keys < MAX_QUEUE_LENGTH) {
+                udpif->n_drop_keys++;
+                list_push_back(&udpif->drop_keys, &drop_key->list_node);
+                ovs_mutex_unlock(&udpif->drop_key_mutex);
+                seq_change(udpif->wait_seq);
+            } else {
+                ovs_mutex_unlock(&udpif->drop_key_mutex);
+                COVERAGE_INC(drop_queue_overflow);
+                drop_key_destroy(drop_key);
+            }
+            continue;
+        } else if (error) {
+            continue;
+        }
+
+        flow_extract(dupcall->packet, flow.skb_priority, flow.skb_mark,
+                     &flow.tunnel, &flow.in_port, &miss->flow);
+
+        /* Add other packets to a to-do list. */
+        hash = flow_hash(&miss->flow, 0);
+        existing_miss = flow_miss_find(&fmb->misses, ofproto, &miss->flow, hash);
+        if (!existing_miss) {
+            hmap_insert(&fmb->misses, &miss->hmap_node, hash);
+            miss->ofproto = ofproto;
+            miss->key = dupcall->key;
+            miss->key_len = dupcall->key_len;
+            miss->upcall_type = dupcall->type;
+            list_init(&miss->packets);
+            list_init(&miss->upcalls);
+
+            n_upcalls++;
+        } else {
+            miss = existing_miss;
+        }
+        list_push_back(&miss->packets, &dupcall->packet->list_node);
+
+        list_remove(&upcall->list_node);
+        list_push_back(&miss->upcalls, &upcall->list_node);
+    }
+
+    LIST_FOR_EACH_SAFE (upcall, next, list_node, upcalls) {
+        list_remove(&upcall->list_node);
+        upcall_destroy(upcall);
+    }
+
+    /* Process each element in the to-do list, constructing the set of
+     * operations to batch. */
+    n_ops = 0;
+    HMAP_FOR_EACH (miss, hmap_node, &fmb->misses) {
+        execute_flow_miss(miss, ops, &n_ops);
+    }
+    ovs_assert(n_ops <= ARRAY_SIZE(ops));
+
+    /* Execute batch. */
+    for (i = 0; i < n_ops; i++) {
+        opsp[i] = &ops[i];
+    }
+    dpif_operate(udpif->dpif, opsp, n_ops);
+
+    ovs_mutex_lock(&udpif->fmb_mutex);
+    atomic_read(&udpif->reval_seq, &new_reval_seq);
+    if (old_reval_seq != new_reval_seq) {
+        /* udpif_revalidate() was called as we were calculating the actions.
+         * To be safe, we need to assume all the misses need revalidation. */
+        ovs_mutex_unlock(&udpif->fmb_mutex);
+        flow_miss_batch_destroy(fmb);
+    } else if (udpif->n_fmbs < MAX_QUEUE_LENGTH) {
+        udpif->n_fmbs++;
+        list_push_back(&udpif->fmbs, &fmb->list_node);
+        ovs_mutex_unlock(&udpif->fmb_mutex);
+        seq_change(udpif->wait_seq);
+    } else {
+        COVERAGE_INC(fmb_queue_overflow);
+        ovs_mutex_unlock(&udpif->fmb_mutex);
+        flow_miss_batch_destroy(fmb);
+    }
+}
diff --git a/ofproto/ofproto-dpif-upcall.h b/ofproto/ofproto-dpif-upcall.h
new file mode 100644
index 0000000..08461bd
--- /dev/null
+++ b/ofproto/ofproto-dpif-upcall.h
@@ -0,0 +1,110 @@
+/* Copyright (c) 2013 Nicira, Inc.
+ *
+ * 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 OFPROTO_DPIF_UPCALL_H
+#define OFPROTO_DPIF_UPCALL_H
+
+#define FLOW_MISS_MAX_BATCH 50
+
+#include "dpif.h"
+#include "flow.h"
+#include "hmap.h"
+#include "list.h"
+#include "odp-util.h"
+#include "ofpbuf.h"
+#include "ofproto-dpif-xlate.h"
+
+struct dpif;
+struct dpif_backer;
+
+enum upcall_type {
+    SFLOW_UPCALL,
+    MISS_UPCALL,
+    BAD_UPCALL,
+    FLOW_SAMPLE_UPCALL,
+    IPFIX_UPCALL
+};
+
+struct upcall {
+    struct list list_node;
+
+    enum upcall_type type;
+    struct dpif_upcall dpif_upcall;
+    struct ofpbuf upcall_buf;
+    uint64_t upcall_stub[256 / 8];
+};
+
+/* Flow miss batching.
+ *
+ * Some dpifs implement operations faster when you hand them off in a batch.
+ * To allow batching, "struct flow_miss" queues the dpif-related work needed
+ * for a given flow.  Each "struct flow_miss" corresponds to sending one or
+ * more packets, plus possibly installing the flow in the dpif.
+ *
+ * So far we only batch the operations that affect flow setup time the most.
+ * It's possible to batch more than that, but the benefit might be minimal. */
+struct flow_miss {
+    struct hmap_node hmap_node;
+    struct ofproto_dpif *ofproto;
+
+    struct flow flow;
+    enum odp_key_fitness key_fitness;
+    const struct nlattr *key;
+    size_t key_len;
+    struct list packets;
+    enum dpif_upcall_type upcall_type;
+    struct dpif_flow_stats stats;
+
+    struct xlate_out xout;
+
+    struct list upcalls;
+};
+
+struct flow_miss_batch {
+    struct list list_node;
+
+    struct flow_miss miss_buf[FLOW_MISS_MAX_BATCH];
+    struct hmap misses;
+};
+
+/* Drop keys are odp flow keys which have drop flows installed in the kernel.
+ * These are datapath flows which have no associated ofproto, if they did we
+ * would use facets. */
+struct drop_key {
+    struct hmap_node hmap_node;
+    struct list list_node;
+    struct nlattr *key;
+    size_t key_len;
+};
+
+struct udpif *udpif_create(struct dpif_backer *, struct dpif *);
+void udpif_recv_set(struct udpif *, size_t n_workers, bool enable);
+void udpif_destroy(struct udpif *);
+
+void udpif_run(struct udpif *);
+void udpif_wait(struct udpif *);
+
+struct upcall *upcall_next(struct udpif *);
+void upcall_destroy(struct upcall *);
+
+struct flow_miss_batch *flow_miss_batch_next(struct udpif *);
+void flow_miss_batch_destroy(struct flow_miss_batch *);
+
+struct drop_key *drop_key_next(struct udpif *);
+void drop_key_destroy(struct drop_key *);
+void udpif_drop_key_clear(struct udpif *);
+
+void udpif_revalidate(struct udpif *);
+
+#endif /* ofproto-dpif-upcall.h */
diff --git a/ofproto/ofproto-dpif-xlate.h b/ofproto/ofproto-dpif-xlate.h
index 1c37bc3..ba24e92 100644
--- a/ofproto/ofproto-dpif-xlate.h
+++ b/ofproto/ofproto-dpif-xlate.h
@@ -12,8 +12,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License. */
 
-#ifndef OFPROT_DPIF_XLATE_H
-#define OFPROT_DPIF_XLATE_H 1
+#ifndef OFPROTO_DPIF_XLATE_H
+#define OFPROTO_DPIF_XLATE_H 1
 
 #include "flow.h"
 #include "meta-flow.h"
diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index 47786b0..ef70c07 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -52,6 +52,7 @@
 #include "ofproto-dpif-ipfix.h"
 #include "ofproto-dpif-mirror.h"
 #include "ofproto-dpif-sflow.h"
+#include "ofproto-dpif-upcall.h"
 #include "ofproto-dpif-xlate.h"
 #include "poll-loop.h"
 #include "simap.h"
@@ -74,6 +75,8 @@ COVERAGE_DEFINE(subfacet_install_fail);
 COVERAGE_DEFINE(packet_in_overflow);
 COVERAGE_DEFINE(flow_mod_overflow);
 
+#define N_THREADS 16
+
 /* Number of implemented OpenFlow tables. */
 enum { N_TABLES = 255 };
 enum { TBL_INTERNAL = N_TABLES - 1 };    /* Used for internal hidden rules. */
@@ -166,8 +169,7 @@ struct subfacet {
 
 #define SUBFACET_DESTROY_MAX_BATCH 50
 
-static struct subfacet *subfacet_create(struct facet *, struct flow_miss *miss,
-                                        long long int now);
+static struct subfacet *subfacet_create(struct facet *, struct flow_miss *);
 static struct subfacet *subfacet_find(struct dpif_backer *,
                                       const struct nlattr *key, size_t key_len,
                                       uint32_t key_hash);
@@ -243,7 +245,6 @@ struct facet {
     uint8_t tcp_flags;           /* TCP flags seen for this 'rule'. */
 
     struct xlate_out xout;
-    bool fail_open;              /* Facet matched the fail open rule. */
 
     /* Storage for a single subfacet, to reduce malloc() time and space
      * overhead.  (A facet always has at least one subfacet and in the common
@@ -255,9 +256,7 @@ struct facet {
     long long int learn_rl;      /* Rate limiter for facet_learn(). */
 };
 
-static struct facet *facet_create(const struct flow_miss *, struct rule_dpif *,
-                                  struct xlate_out *,
-                                  struct dpif_flow_stats *);
+static struct facet *facet_create(const struct flow_miss *);
 static void facet_remove(struct facet *);
 static void facet_free(struct facet *);
 
@@ -270,6 +269,8 @@ static bool facet_check_consistency(struct facet *);
 static void facet_flush_stats(struct facet *);
 
 static void facet_reset_counters(struct facet *);
+static void flow_push_stats(struct ofproto_dpif *, struct flow *,
+                            struct dpif_flow_stats *, bool may_learn);
 static void facet_push_stats(struct facet *, bool may_learn);
 static void facet_learn(struct facet *);
 static void facet_account(struct facet *);
@@ -378,15 +379,6 @@ COVERAGE_DEFINE(rev_flow_table);
 COVERAGE_DEFINE(rev_mac_learning);
 COVERAGE_DEFINE(rev_inconsistency);
 
-/* Drop keys are odp flow keys which have drop flows installed in the kernel.
- * These are datapath flows which have no associated ofproto, if they did we
- * would use facets. */
-struct drop_key {
-    struct hmap_node hmap_node;
-    struct nlattr *key;
-    size_t key_len;
-};
-
 struct avg_subfacet_rates {
     double add_rate;   /* Moving average of new flows created per minute. */
     double del_rate;   /* Moving average of flows deleted per minute. */
@@ -397,6 +389,7 @@ struct dpif_backer {
     char *type;
     int refcount;
     struct dpif *dpif;
+    struct udpif *udpif;
     struct timer next_expiration;
 
     struct ovs_rwlock odp_to_ofport_lock;
@@ -530,8 +523,7 @@ static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
                           const struct ofpbuf *packet, struct ds *);
 
 /* Upcalls. */
-#define FLOW_MISS_MAX_BATCH 50
-static int handle_upcalls(struct dpif_backer *, unsigned int max_batch);
+static void handle_upcalls(struct dpif_backer *);
 
 /* Flow expiration. */
 static int expire(struct dpif_backer *);
@@ -704,9 +696,11 @@ type_run(const char *type)
 
         error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
         if (error) {
+            udpif_recv_set(backer->udpif, 0, false);
             VLOG_ERR("Failed to enable receiving packets in dpif.");
             return error;
         }
+        udpif_recv_set(backer->udpif, N_THREADS, backer->recv_set_enable);
         dpif_flow_flush(backer->dpif);
         backer->need_revalidate = REV_RECONFIGURE;
     }
@@ -833,6 +827,8 @@ type_run(const char *type)
                 run_fast_rl();
             }
         }
+
+        udpif_revalidate(backer->udpif);
     }
 
     if (!backer->recv_set_enable) {
@@ -996,32 +992,10 @@ process_dpif_port_error(struct dpif_backer *backer, int error)
 }
 
 static int
-dpif_backer_run_fast(struct dpif_backer *backer, int max_batch)
+dpif_backer_run_fast(struct dpif_backer *backer)
 {
-    unsigned int work;
-
-    /* If recv_set_enable is false, we should not handle upcalls. */
-    if (!backer->recv_set_enable) {
-        return 0;
-    }
-
-    /* Handle one or more batches of upcalls, until there's nothing left to do
-     * or until we do a fixed total amount of work.
-     *
-     * We do work in batches because it can be much cheaper to set up a number
-     * of flows and fire off their patches all at once.  We do multiple batches
-     * because in some cases handling a packet can cause another packet to be
-     * queued almost immediately as part of the return flow.  Both
-     * optimizations can make major improvements on some benchmarks and
-     * presumably for real traffic as well. */
-    work = 0;
-    while (work < max_batch) {
-        int retval = handle_upcalls(backer, max_batch - work);
-        if (retval <= 0) {
-            return -retval;
-        }
-        work += retval;
-    }
+    udpif_run(backer->udpif);
+    handle_upcalls(backer);
 
     return 0;
 }
@@ -1038,14 +1012,13 @@ type_run_fast(const char *type)
         return 0;
     }
 
-    return dpif_backer_run_fast(backer, FLOW_MISS_MAX_BATCH);
+    return dpif_backer_run_fast(backer);
 }
 
 static void
 run_fast_rl(void)
 {
     static long long int port_rl = LLONG_MIN;
-    static unsigned int backer_rl = 0;
 
     if (time_msec() >= port_rl) {
         struct ofproto_dpif *ofproto;
@@ -1055,23 +1028,6 @@ run_fast_rl(void)
         }
         port_rl = time_msec() + 200;
     }
-
-    /* XXX: We have to be careful not to do too much work in this function.  If
-     * we call dpif_backer_run_fast() too often, or with too large a batch,
-     * performance improves signifcantly, but at a cost.  It's possible for the
-     * number of flows in the datapath to increase without bound, and for poll
-     * loops to take 10s of seconds.   The correct solution to this problem,
-     * long term, is to separate flow miss handling into it's own thread so it
-     * isn't affected by revalidations, and expirations.  Until then, this is
-     * the best we can do. */
-    if (++backer_rl >= 10) {
-        struct shash_node *node;
-
-        backer_rl = 0;
-        SHASH_FOR_EACH (node, &all_dpif_backers) {
-            dpif_backer_run_fast(node->data, 1);
-        }
-    }
 }
 
 static void
@@ -1131,6 +1087,7 @@ close_dpif_backer(struct dpif_backer *backer)
     node = shash_find(&all_dpif_backers, backer->type);
     free(backer->type);
     shash_delete(&all_dpif_backers, node);
+    udpif_destroy(backer->udpif);
     dpif_close(backer->dpif);
 
     ovs_assert(hmap_is_empty(&backer->subfacets));
@@ -1200,6 +1157,7 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp)
         free(backer);
         return error;
     }
+    backer->udpif = udpif_create(backer, backer->dpif);
 
     backer->type = xstrdup(type);
     backer->governor = NULL;
@@ -1247,6 +1205,7 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp)
         close_dpif_backer(backer);
         return error;
     }
+    udpif_recv_set(backer->udpif, N_THREADS, backer->recv_set_enable);
 
     backer->max_n_subfacet = 0;
     backer->created = time_msec();
@@ -1661,7 +1620,7 @@ wait(struct ofproto *ofproto_)
     }
 
     dpif_wait(ofproto->backer->dpif);
-    dpif_recv_wait(ofproto->backer->dpif);
+    udpif_wait(ofproto->backer->udpif);
     if (ofproto->sflow) {
         dpif_sflow_wait(ofproto->sflow);
     }
@@ -3261,26 +3220,6 @@ port_is_lacp_current(const struct ofport *ofport_)
 
 /* Upcall handling. */
 
-/* Flow miss batching.
- *
- * Some dpifs implement operations faster when you hand them off in a batch.
- * To allow batching, "struct flow_miss" queues the dpif-related work needed
- * for a given flow.  Each "struct flow_miss" corresponds to sending one or
- * more packets, plus possibly installing the flow in the dpif.
- *
- * So far we only batch the operations that affect flow setup time the most.
- * It's possible to batch more than that, but the benefit might be minimal. */
-struct flow_miss {
-    struct hmap_node hmap_node;
-    struct ofproto_dpif *ofproto;
-    struct flow flow;
-    enum odp_key_fitness key_fitness;
-    const struct nlattr *key;
-    size_t key_len;
-    struct list packets;
-    enum dpif_upcall_type upcall_type;
-};
-
 struct flow_miss_op {
     struct dpif_op dpif_op;
 
@@ -3296,96 +3235,6 @@ struct flow_miss_op {
     struct subfacet *subfacet;
 };
 
-/* Sends an OFPT_PACKET_IN message for 'packet' of type OFPR_NO_MATCH to each
- * OpenFlow controller as necessary according to their individual
- * configurations. */
-static void
-send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet,
-                    const struct flow *flow)
-{
-    struct ofputil_packet_in pin;
-
-    pin.packet = packet->data;
-    pin.packet_len = packet->size;
-    pin.reason = OFPR_NO_MATCH;
-    pin.controller_id = 0;
-
-    pin.table_id = 0;
-    pin.cookie = 0;
-
-    pin.send_len = 0;           /* not used for flow table misses */
-
-    flow_get_metadata(flow, &pin.fmd);
-
-    connmgr_send_packet_in(ofproto->up.connmgr, &pin);
-}
-
-static struct flow_miss *
-flow_miss_find(struct hmap *todo, const struct ofproto_dpif *ofproto,
-               const struct flow *flow, uint32_t hash)
-{
-    struct flow_miss *miss;
-
-    HMAP_FOR_EACH_WITH_HASH (miss, hmap_node, hash, todo) {
-        if (miss->ofproto == ofproto && flow_equal(&miss->flow, flow)) {
-            return miss;
-        }
-    }
-
-    return NULL;
-}
-
-/* Partially Initializes 'op' as an "execute" operation for 'miss' and
- * 'packet'.  The caller must initialize op->actions and op->actions_len.  If
- * 'miss' is associated with a subfacet the caller must also initialize the
- * returned op->subfacet, and if anything needs to be freed after processing
- * the op, the caller must initialize op->garbage also. */
-static void
-init_flow_miss_execute_op(struct flow_miss *miss, struct ofpbuf *packet,
-                          struct flow_miss_op *op)
-{
-    if (miss->flow.in_port.ofp_port
-        != vsp_realdev_to_vlandev(miss->ofproto, miss->flow.in_port.ofp_port,
-                                  miss->flow.vlan_tci)) {
-        /* This packet was received on a VLAN splinter port.  We
-         * added a VLAN to the packet to make the packet resemble
-         * the flow, but the actions were composed assuming that
-         * the packet contained no VLAN.  So, we must remove the
-         * VLAN header from the packet before trying to execute the
-         * actions. */
-        eth_pop_vlan(packet);
-    }
-
-    op->subfacet = NULL;
-    op->xout_garbage = false;
-    op->dpif_op.type = DPIF_OP_EXECUTE;
-    op->dpif_op.u.execute.key = miss->key;
-    op->dpif_op.u.execute.key_len = miss->key_len;
-    op->dpif_op.u.execute.packet = packet;
-    ofpbuf_use_stack(&op->mask, &op->maskbuf, sizeof op->maskbuf);
-}
-
-/* Helper for handle_flow_miss_without_facet() and
- * handle_flow_miss_with_facet(). */
-static void
-handle_flow_miss_common(struct ofproto_dpif *ofproto, struct ofpbuf *packet,
-                        const struct flow *flow, bool fail_open)
-{
-    if (fail_open) {
-        /*
-         * Extra-special case for fail-open mode.
-         *
-         * We are in fail-open mode and the packet matched the fail-open
-         * rule, but we are connected to a controller too.  We should send
-         * the packet up to the controller in the hope that it will try to
-         * set up a flow and thereby allow us to exit fail-open.
-         *
-         * See the top-level comment in fail-open.c for more information.
-         */
-        send_packet_in_miss(ofproto, packet, flow);
-    }
-}
-
 /* Figures out whether a flow that missed in 'ofproto', whose details are in
  * 'miss' masked by 'wc', is likely to be worth tracking in detail in userspace
  * and (usually) installing a datapath flow.  The answer is usually "yes" (a
@@ -3394,7 +3243,7 @@ handle_flow_miss_common(struct ofproto_dpif *ofproto, struct ofpbuf *packet,
  * flows we impose some heuristics to decide which flows are likely to be worth
  * tracking. */
 static bool
-flow_miss_should_make_facet(struct flow_miss *miss, struct flow_wildcards *wc)
+flow_miss_should_make_facet(struct flow_miss *miss)
 {
     struct dpif_backer *backer = miss->ofproto->backer;
     uint32_t hash;
@@ -3419,97 +3268,34 @@ flow_miss_should_make_facet(struct flow_miss *miss, struct flow_wildcards *wc)
         backer->governor = governor_create();
     }
 
-    hash = flow_hash_in_wildcards(&miss->flow, wc, 0);
+    hash = flow_hash_in_wildcards(&miss->flow, &miss->xout.wc, 0);
     return governor_should_install_flow(backer->governor, hash,
                                         list_size(&miss->packets));
 }
 
-/* Handles 'miss' without creating a facet or subfacet or creating any datapath
- * flow.  'miss->flow' must have matched 'rule' and been xlated into 'xout'.
- * May add an "execute" operation to 'ops' and increment '*n_ops'. */
-static void
-handle_flow_miss_without_facet(struct rule_dpif *rule, struct xlate_out *xout,
-                               struct flow_miss *miss,
-                               struct flow_miss_op *ops, size_t *n_ops)
-{
-    struct ofpbuf *packet;
-
-    LIST_FOR_EACH (packet, list_node, &miss->packets) {
-
-        COVERAGE_INC(facet_suppress);
-
-        handle_flow_miss_common(miss->ofproto, packet, &miss->flow,
-                                rule->up.cr.priority == FAIL_OPEN_PRIORITY);
-
-        if (xout->slow) {
-            struct xlate_in xin;
-
-            xlate_in_init(&xin, miss->ofproto, &miss->flow, rule, 0, packet);
-            xlate_actions_for_side_effects(&xin);
-        }
-
-        if (xout->odp_actions.size) {
-            struct flow_miss_op *op = &ops[*n_ops];
-            struct dpif_execute *execute = &op->dpif_op.u.execute;
-
-            init_flow_miss_execute_op(miss, packet, op);
-            xlate_out_copy(&op->xout, xout);
-            execute->actions = op->xout.odp_actions.data;
-            execute->actions_len = op->xout.odp_actions.size;
-            op->xout_garbage = true;
-
-            (*n_ops)++;
-        }
-    }
-}
-
 /* Handles 'miss', which matches 'facet'.  May add any required datapath
  * operations to 'ops', incrementing '*n_ops' for each new op.
  *
- * All of the packets in 'miss' are considered to have arrived at time 'now'.
- * This is really important only for new facets: if we just called time_msec()
- * here, then the new subfacet or its packets could look (occasionally) as
- * though it was used some time after the facet was used.  That can make a
- * one-packet flow look like it has a nonzero duration, which looks odd in
- * e.g. NetFlow statistics.
- *
- * If non-null, 'stats' will be folded into 'facet'. */
+ * All of the packets in 'miss' are considered to have arrived at time
+ * 'miss->stats.used'.  This is really important only for new facets: if we
+ * just called time_msec() here, then the new subfacet or its packets could
+ * look (occasionally) as though it was used some time after the facet was
+ * used.  That can make a one-packet flow look like it has a nonzero duration,
+ * which looks odd in e.g. NetFlow statistics. */
 static void
 handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet,
-                            long long int now, struct dpif_flow_stats *stats,
                             struct flow_miss_op *ops, size_t *n_ops)
 {
     enum subfacet_path want_path;
     struct subfacet *subfacet;
-    struct ofpbuf *packet;
-
-    want_path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH;
-
-    LIST_FOR_EACH (packet, list_node, &miss->packets) {
-        struct flow_miss_op *op = &ops[*n_ops];
-
-        handle_flow_miss_common(miss->ofproto, packet, &miss->flow,
-                                facet->fail_open);
 
-        if (want_path != SF_FAST_PATH) {
-            struct rule_dpif *rule;
-            struct xlate_in xin;
+    facet->packet_count += miss->stats.n_packets;
+    facet->prev_packet_count += miss->stats.n_packets;
+    facet->byte_count += miss->stats.n_bytes;
+    facet->prev_byte_count += miss->stats.n_bytes;
 
-            rule_dpif_lookup(facet->ofproto, &facet->flow, NULL, &rule);
-            xlate_in_init(&xin, facet->ofproto, &miss->flow, rule, 0, packet);
-            xlate_actions_for_side_effects(&xin);
-            rule_release(rule);
-        }
-
-        if (facet->xout.odp_actions.size) {
-            struct dpif_execute *execute = &op->dpif_op.u.execute;
-
-            init_flow_miss_execute_op(miss, packet, op);
-            execute->actions = facet->xout.odp_actions.data,
-            execute->actions_len = facet->xout.odp_actions.size;
-            (*n_ops)++;
-        }
-    }
+    subfacet = subfacet_create(facet, miss);
+    want_path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH;
 
     /* Don't install the flow if it's the result of the "userspace"
      * action for an already installed facet.  This can occur when a
@@ -3518,20 +3304,10 @@ handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet,
      * be rejected as overlapping by the datapath. */
     if (miss->upcall_type == DPIF_UC_ACTION
         && !list_is_empty(&facet->subfacets)) {
-        if (stats) {
-            facet->used = MAX(facet->used, stats->used);
-            facet->packet_count += stats->n_packets;
-            facet->byte_count += stats->n_bytes;
-            facet->tcp_flags |= stats->tcp_flags;
-        }
         return;
     }
 
-    subfacet = subfacet_create(facet, miss, now);
-    if (stats) {
-        subfacet_update_stats(subfacet, stats);
-    }
-
+    subfacet = subfacet_create(facet, miss);
     if (subfacet->path != want_path) {
         struct flow_miss_op *op = &ops[(*n_ops)++];
         struct dpif_flow_put *put = &op->dpif_op.u.flow_put;
@@ -3571,57 +3347,25 @@ static void
 handle_flow_miss(struct flow_miss *miss, struct flow_miss_op *ops,
                  size_t *n_ops)
 {
-    struct ofproto_dpif *ofproto = miss->ofproto;
-    struct dpif_flow_stats stats__;
-    struct dpif_flow_stats *stats = &stats__;
-    struct ofpbuf *packet;
     struct facet *facet;
-    long long int now;
 
-    now = time_msec();
-    memset(stats, 0, sizeof *stats);
-    stats->used = now;
-    LIST_FOR_EACH (packet, list_node, &miss->packets) {
-        stats->tcp_flags |= packet_get_tcp_flags(packet, &miss->flow);
-        stats->n_bytes += packet->size;
-        stats->n_packets++;
-    }
+    miss->ofproto->n_missed += list_size(&miss->packets);
 
-    facet = facet_lookup_valid(ofproto, &miss->flow);
+    facet = facet_lookup_valid(miss->ofproto, &miss->flow);
     if (!facet) {
-        struct flow_wildcards wc;
-        struct rule_dpif *rule;
-        struct xlate_out xout;
-        struct xlate_in xin;
-
-        flow_wildcards_init_catchall(&wc);
-        rule_dpif_lookup(ofproto, &miss->flow, &wc, &rule);
-        rule_credit_stats(rule, stats);
-
-        xlate_in_init(&xin, ofproto, &miss->flow, rule, stats->tcp_flags,
-                      NULL);
-        xin.resubmit_stats = stats;
-        xin.may_learn = true;
-        xlate_actions(&xin, &xout);
-        flow_wildcards_or(&xout.wc, &xout.wc, &wc);
-
         /* There does not exist a bijection between 'struct flow' and datapath
          * flow keys with fitness ODP_FIT_TO_LITTLE.  This breaks a fundamental
          * assumption used throughout the facet and subfacet handling code.
          * Since we have to handle these misses in userspace anyway, we simply
          * skip facet creation, avoiding the problem altogether. */
         if (miss->key_fitness == ODP_FIT_TOO_LITTLE
-            || !flow_miss_should_make_facet(miss, &xout.wc)) {
-            handle_flow_miss_without_facet(rule, &xout, miss, ops, n_ops);
-            rule_release(rule);
+            || !flow_miss_should_make_facet(miss)) {
             return;
         }
 
-        facet = facet_create(miss, rule, &xout, stats);
-        rule_release(rule);
-        stats = NULL;
+        facet = facet_create(miss);
     }
-    handle_flow_miss_with_facet(miss, facet, now, stats, ops, n_ops);
+    handle_flow_miss_with_facet(miss, facet, ops, n_ops);
 }
 
 static struct drop_key *
@@ -3660,109 +3404,24 @@ drop_key_clear(struct dpif_backer *backer)
         }
 
         hmap_remove(&backer->drop_keys, &drop_key->hmap_node);
-        free(drop_key->key);
-        free(drop_key);
+        drop_key_destroy(drop_key);
     }
+
+    udpif_drop_key_clear(backer->udpif);
 }
 
 static void
-handle_miss_upcalls(struct dpif_backer *backer, struct dpif_upcall *upcalls,
-                    size_t n_upcalls)
+handle_flow_misses(struct dpif_backer *backer, struct flow_miss_batch *fmb)
 {
-    struct dpif_upcall *upcall;
+    struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH];
+    struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH];
     struct flow_miss *miss;
-    struct flow_miss misses[FLOW_MISS_MAX_BATCH];
-    struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH * 2];
-    struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
-    struct hmap todo;
-    int n_misses;
-    size_t n_ops;
-    size_t i;
-
-    if (!n_upcalls) {
-        return;
-    }
-
-    /* Construct the to-do list.
-     *
-     * This just amounts to extracting the flow from each packet and sticking
-     * the packets that have the same flow in the same "flow_miss" structure so
-     * that we can process them together. */
-    hmap_init(&todo);
-    n_misses = 0;
-    for (upcall = upcalls; upcall < &upcalls[n_upcalls]; upcall++) {
-        struct flow_miss *miss = &misses[n_misses];
-        struct flow_miss *existing_miss;
-        struct ofproto_dpif *ofproto;
-        odp_port_t odp_in_port;
-        struct flow flow;
-        uint32_t hash;
-        int error;
-
-        error = xlate_receive(backer, upcall->packet, upcall->key,
-                              upcall->key_len, &flow, &miss->key_fitness,
-                              &ofproto, &odp_in_port);
-        if (error == ENODEV) {
-            struct drop_key *drop_key;
-
-            /* Received packet on datapath port for which we couldn't
-             * associate an ofproto.  This can happen if a port is removed
-             * while traffic is being received.  Print a rate-limited message
-             * in case it happens frequently.  Install a drop flow so
-             * that future packets of the flow are inexpensively dropped
-             * in the kernel. */
-            VLOG_INFO_RL(&rl, "received packet on unassociated datapath port "
-                              "%"PRIu32, odp_in_port);
-
-            drop_key = drop_key_lookup(backer, upcall->key, upcall->key_len);
-            if (!drop_key) {
-                int ret;
-                ret = dpif_flow_put(backer->dpif,
-                                    DPIF_FP_CREATE | DPIF_FP_MODIFY,
-                                    upcall->key, upcall->key_len,
-                                    NULL, 0, NULL, 0, NULL);
-
-                if (!ret) {
-                    drop_key = xmalloc(sizeof *drop_key);
-                    drop_key->key = xmemdup(upcall->key, upcall->key_len);
-                    drop_key->key_len = upcall->key_len;
-
-                    hmap_insert(&backer->drop_keys, &drop_key->hmap_node,
-                                hash_bytes(drop_key->key, drop_key->key_len, 0));
-                }
-            }
-            continue;
-        }
-        if (error) {
-            continue;
-        }
-
-        ofproto->n_missed++;
-        flow_extract(upcall->packet, flow.skb_priority, flow.skb_mark,
-                     &flow.tunnel, &flow.in_port, &miss->flow);
-
-        /* Add other packets to a to-do list. */
-        hash = flow_hash(&miss->flow, 0);
-        existing_miss = flow_miss_find(&todo, ofproto, &miss->flow, hash);
-        if (!existing_miss) {
-            hmap_insert(&todo, &miss->hmap_node, hash);
-            miss->ofproto = ofproto;
-            miss->key = upcall->key;
-            miss->key_len = upcall->key_len;
-            miss->upcall_type = upcall->type;
-            list_init(&miss->packets);
-
-            n_misses++;
-        } else {
-            miss = existing_miss;
-        }
-        list_push_back(&miss->packets, &upcall->packet->list_node);
-    }
+    size_t n_ops, i;
 
     /* Process each element in the to-do list, constructing the set of
      * operations to batch. */
     n_ops = 0;
-    HMAP_FOR_EACH (miss, hmap_node, &todo) {
+    HMAP_FOR_EACH (miss, hmap_node, &fmb->misses) {
         handle_flow_miss(miss, flow_miss_ops, &n_ops);
     }
     ovs_assert(n_ops <= ARRAY_SIZE(flow_miss_ops));
@@ -3795,66 +3454,6 @@ handle_miss_upcalls(struct dpif_backer *backer, struct dpif_upcall *upcalls,
 
             subfacet->path = SF_NOT_INSTALLED;
         }
-
-        /* Free memory. */
-        if (flow_miss_ops[i].xout_garbage) {
-            xlate_out_uninit(&flow_miss_ops[i].xout);
-        }
-    }
-    hmap_destroy(&todo);
-}
-
-static enum { SFLOW_UPCALL, MISS_UPCALL, BAD_UPCALL, FLOW_SAMPLE_UPCALL,
-              IPFIX_UPCALL }
-classify_upcall(const struct dpif_upcall *upcall)
-{
-    size_t userdata_len;
-    union user_action_cookie cookie;
-
-    /* First look at the upcall type. */
-    switch (upcall->type) {
-    case DPIF_UC_ACTION:
-        break;
-
-    case DPIF_UC_MISS:
-        return MISS_UPCALL;
-
-    case DPIF_N_UC_TYPES:
-    default:
-        VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
-        return BAD_UPCALL;
-    }
-
-    /* "action" upcalls need a closer look. */
-    if (!upcall->userdata) {
-        VLOG_WARN_RL(&rl, "action upcall missing cookie");
-        return BAD_UPCALL;
-    }
-    userdata_len = nl_attr_get_size(upcall->userdata);
-    if (userdata_len < sizeof cookie.type
-        || userdata_len > sizeof cookie) {
-        VLOG_WARN_RL(&rl, "action upcall cookie has unexpected size %zu",
-                     userdata_len);
-        return BAD_UPCALL;
-    }
-    memset(&cookie, 0, sizeof cookie);
-    memcpy(&cookie, nl_attr_get(upcall->userdata), userdata_len);
-    if (userdata_len == sizeof cookie.sflow
-        && cookie.type == USER_ACTION_COOKIE_SFLOW) {
-        return SFLOW_UPCALL;
-    } else if (userdata_len == sizeof cookie.slow_path
-               && cookie.type == USER_ACTION_COOKIE_SLOW_PATH) {
-        return MISS_UPCALL;
-    } else if (userdata_len == sizeof cookie.flow_sample
-               && cookie.type == USER_ACTION_COOKIE_FLOW_SAMPLE) {
-        return FLOW_SAMPLE_UPCALL;
-    } else if (userdata_len == sizeof cookie.ipfix
-               && cookie.type == USER_ACTION_COOKIE_IPFIX) {
-        return IPFIX_UPCALL;
-    } else {
-        VLOG_WARN_RL(&rl, "invalid user cookie of type %"PRIu16
-                     " and size %zu", cookie.type, userdata_len);
-        return BAD_UPCALL;
     }
 }
 
@@ -3923,66 +3522,64 @@ handle_ipfix_upcall(struct dpif_backer *backer,
     dpif_ipfix_bridge_sample(ofproto->ipfix, upcall->packet, &flow);
 }
 
-static int
-handle_upcalls(struct dpif_backer *backer, unsigned int max_batch)
+static void
+handle_upcalls(struct dpif_backer *backer)
 {
-    struct dpif_upcall misses[FLOW_MISS_MAX_BATCH];
-    struct ofpbuf miss_bufs[FLOW_MISS_MAX_BATCH];
-    uint64_t miss_buf_stubs[FLOW_MISS_MAX_BATCH][4096 / 8];
+    struct flow_miss_batch *fmb;
     int n_processed;
-    int n_misses;
-    int i;
 
-    ovs_assert(max_batch <= FLOW_MISS_MAX_BATCH);
+    for (n_processed = 0; n_processed < FLOW_MISS_MAX_BATCH; n_processed++) {
+        struct upcall *upcall = upcall_next(backer->udpif);
 
-    n_misses = 0;
-    for (n_processed = 0; n_processed < max_batch; n_processed++) {
-        struct dpif_upcall *upcall = &misses[n_misses];
-        struct ofpbuf *buf = &miss_bufs[n_misses];
-        int error;
-
-        ofpbuf_use_stub(buf, miss_buf_stubs[n_misses],
-                        sizeof miss_buf_stubs[n_misses]);
-        error = dpif_recv(backer->dpif, upcall, buf);
-        if (error) {
-            ofpbuf_uninit(buf);
+        if (!upcall) {
             break;
         }
 
-        switch (classify_upcall(upcall)) {
-        case MISS_UPCALL:
-            /* Handle it later. */
-            n_misses++;
-            break;
-
+        switch (upcall->type) {
         case SFLOW_UPCALL:
-            handle_sflow_upcall(backer, upcall);
-            ofpbuf_uninit(buf);
+            handle_sflow_upcall(backer, &upcall->dpif_upcall);
             break;
 
         case FLOW_SAMPLE_UPCALL:
-            handle_flow_sample_upcall(backer, upcall);
-            ofpbuf_uninit(buf);
+            handle_flow_sample_upcall(backer, &upcall->dpif_upcall);
             break;
 
         case IPFIX_UPCALL:
-            handle_ipfix_upcall(backer, upcall);
-            ofpbuf_uninit(buf);
+            handle_ipfix_upcall(backer, &upcall->dpif_upcall);
             break;
 
         case BAD_UPCALL:
-            ofpbuf_uninit(buf);
             break;
+
+        case MISS_UPCALL:
+            NOT_REACHED();
         }
+
+        upcall_destroy(upcall);
     }
 
-    /* Handle deferred MISS_UPCALL processing. */
-    handle_miss_upcalls(backer, misses, n_misses);
-    for (i = 0; i < n_misses; i++) {
-        ofpbuf_uninit(&miss_bufs[i]);
+    for (n_processed = 0; n_processed < FLOW_MISS_MAX_BATCH; n_processed++) {
+        struct drop_key *drop_key = drop_key_next(backer->udpif);
+        if (!drop_key) {
+            break;
+        }
+
+        if (!drop_key_lookup(backer, drop_key->key, drop_key->key_len)) {
+            hmap_insert(&backer->drop_keys, &drop_key->hmap_node,
+                        hash_bytes(drop_key->key, drop_key->key_len, 0));
+            dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY,
+                          drop_key->key, drop_key->key_len,
+                          NULL, 0, NULL, 0, NULL);
+        } else {
+            drop_key_destroy(drop_key);
+        }
     }
 
-    return n_processed;
+    fmb = flow_miss_batch_next(backer->udpif);
+    if (fmb) {
+        handle_flow_misses(backer, fmb);
+        flow_miss_batch_destroy(fmb);
+    }
 }
 
 /* Flow expiration. */
@@ -4356,8 +3953,7 @@ rule_expire(struct rule_dpif *rule)
  * The facet will initially have no subfacets.  The caller should create (at
  * least) one subfacet with subfacet_create(). */
 static struct facet *
-facet_create(const struct flow_miss *miss, struct rule_dpif *rule,
-             struct xlate_out *xout, struct dpif_flow_stats *stats)
+facet_create(const struct flow_miss *miss)
 {
     struct ofproto_dpif *ofproto = miss->ofproto;
     struct facet *facet;
@@ -4365,10 +3961,7 @@ facet_create(const struct flow_miss *miss, struct rule_dpif *rule,
 
     facet = xzalloc(sizeof *facet);
     facet->ofproto = miss->ofproto;
-    facet->packet_count = facet->prev_packet_count = stats->n_packets;
-    facet->byte_count = facet->prev_byte_count = stats->n_bytes;
-    facet->tcp_flags = stats->tcp_flags;
-    facet->used = stats->used;
+    facet->used = miss->stats.used;
     facet->flow = miss->flow;
     facet->learn_rl = time_msec() + 500;
 
@@ -4376,7 +3969,7 @@ facet_create(const struct flow_miss *miss, struct rule_dpif *rule,
     netflow_flow_init(&facet->nf_flow);
     netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, facet->used);
 
-    xlate_out_copy(&facet->xout, xout);
+    xlate_out_copy(&facet->xout, &miss->xout);
 
     match_init(&match, &facet->flow, &facet->xout.wc);
     cls_rule_init(&facet->cr, &match, OFP_DEFAULT_PRIORITY);
@@ -4385,8 +3978,6 @@ facet_create(const struct flow_miss *miss, struct rule_dpif *rule,
     ovs_rwlock_unlock(&ofproto->facets.rwlock);
 
     facet->nf_flow.output_iface = facet->xout.nf_output_iface;
-    facet->fail_open = rule->up.cr.priority == FAIL_OPEN_PRIORITY;
-
     return facet;
 }
 
@@ -4635,7 +4226,7 @@ facet_check_consistency(struct facet *facet)
     struct xlate_in xin;
 
     struct rule_dpif *rule;
-    bool ok, fail_open;
+    bool ok;
 
     /* Check the datapath actions for consistency. */
     rule_dpif_lookup(facet->ofproto, &facet->flow, NULL, &rule);
@@ -4643,10 +4234,8 @@ facet_check_consistency(struct facet *facet)
     xlate_actions(&xin, &xout);
     rule_release(rule);
 
-    fail_open = rule->up.cr.priority == FAIL_OPEN_PRIORITY;
     ok = ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)
-        && facet->xout.slow == xout.slow
-        && facet->fail_open == fail_open;
+        && facet->xout.slow == xout.slow;
     if (!ok && !VLOG_DROP_WARN(&rl)) {
         struct ds s = DS_EMPTY_INITIALIZER;
 
@@ -4667,10 +4256,6 @@ facet_check_consistency(struct facet *facet)
             ds_put_format(&s, " slow path incorrect. should be %d", xout.slow);
         }
 
-        if (facet->fail_open != fail_open) {
-            ds_put_format(&s, " fail open incorrect. should be %s",
-                          fail_open ? "true" : "false");
-        }
         ds_destroy(&s);
     }
     xlate_out_uninit(&xout);
@@ -4775,7 +4360,6 @@ facet_revalidate(struct facet *facet)
     facet->xout.mirrors = xout.mirrors;
     facet->nf_flow.output_iface = facet->xout.nf_output_iface;
     facet->used = MAX(facet->used, new_rule->up.created);
-    facet->fail_open = new_rule->up.cr.priority == FAIL_OPEN_PRIORITY;
 
     xlate_out_uninit(&xout);
     rule_release(new_rule);
@@ -4793,6 +4377,28 @@ facet_reset_counters(struct facet *facet)
 }
 
 static void
+flow_push_stats(struct ofproto_dpif *ofproto, struct flow *flow,
+                struct dpif_flow_stats *stats, bool may_learn)
+{
+    struct ofport_dpif *in_port;
+    struct rule_dpif *rule;
+    struct xlate_in xin;
+
+    in_port = get_ofp_port(ofproto, flow->in_port.ofp_port);
+    if (in_port && in_port->is_tunnel) {
+        netdev_vport_inc_rx(in_port->up.netdev, stats);
+    }
+
+    rule_dpif_lookup(ofproto, flow, NULL, &rule);
+    rule_credit_stats(rule, stats);
+    xlate_in_init(&xin, ofproto, flow, rule, stats->tcp_flags, NULL);
+    xin.resubmit_stats = stats;
+    xin.may_learn = may_learn;
+    xlate_actions_for_side_effects(&xin);
+    rule_release(rule);
+}
+
+static void
 facet_push_stats(struct facet *facet, bool may_learn)
 {
     struct dpif_flow_stats stats;
@@ -4807,34 +4413,16 @@ facet_push_stats(struct facet *facet, bool may_learn)
     stats.tcp_flags = facet->tcp_flags;
 
     if (may_learn || stats.n_packets || facet->used > facet->prev_used) {
-        struct ofproto_dpif *ofproto = facet->ofproto;
-        struct ofport_dpif *in_port;
-        struct rule_dpif *rule;
-        struct xlate_in xin;
-
         facet->prev_packet_count = facet->packet_count;
         facet->prev_byte_count = facet->byte_count;
         facet->prev_used = facet->used;
 
-        in_port = get_ofp_port(ofproto, facet->flow.in_port.ofp_port);
-        if (in_port && in_port->is_tunnel) {
-            netdev_vport_inc_rx(in_port->up.netdev, &stats);
-        }
-
-        rule_dpif_lookup(ofproto, &facet->flow, NULL, &rule);
-        rule_credit_stats(rule, &stats);
-        netflow_flow_update_time(ofproto->netflow, &facet->nf_flow,
+        netflow_flow_update_time(facet->ofproto->netflow, &facet->nf_flow,
                                  facet->used);
         netflow_flow_update_flags(&facet->nf_flow, facet->tcp_flags);
-        mirror_update_stats(ofproto->mbridge, facet->xout.mirrors,
+        mirror_update_stats(facet->ofproto->mbridge, facet->xout.mirrors,
                             stats.n_packets, stats.n_bytes);
-
-        xlate_in_init(&xin, ofproto, &facet->flow, rule, stats.tcp_flags,
-                      NULL);
-        xin.resubmit_stats = &stats;
-        xin.may_learn = may_learn;
-        xlate_actions_for_side_effects(&xin);
-        rule_release(rule);
+        flow_push_stats(facet->ofproto, &facet->flow, &stats, may_learn);
     }
 }
 
@@ -4904,8 +4492,7 @@ subfacet_find(struct dpif_backer *backer, const struct nlattr *key,
  * existing subfacet if there is one, otherwise creates and returns a
  * new subfacet. */
 static struct subfacet *
-subfacet_create(struct facet *facet, struct flow_miss *miss,
-                long long int now)
+subfacet_create(struct facet *facet, struct flow_miss *miss)
 {
     struct dpif_backer *backer = miss->ofproto->backer;
     enum odp_key_fitness key_fitness = miss->key_fitness;
@@ -4939,8 +4526,8 @@ subfacet_create(struct facet *facet, struct flow_miss *miss,
     subfacet->key_fitness = key_fitness;
     subfacet->key = xmemdup(key, key_len);
     subfacet->key_len = key_len;
-    subfacet->used = now;
-    subfacet->created = now;
+    subfacet->used = miss->stats.used;
+    subfacet->created = subfacet->used;
     subfacet->dp_packet_count = 0;
     subfacet->dp_byte_count = 0;
     subfacet->path = SF_NOT_INSTALLED;
diff --git a/ofproto/ofproto-dpif.h b/ofproto/ofproto-dpif.h
index 30ba566..5395642 100644
--- a/ofproto/ofproto-dpif.h
+++ b/ofproto/ofproto-dpif.h
@@ -18,6 +18,7 @@
 #include <stdint.h>
 
 #include "hmapx.h"
+#include "odp-util.h"
 #include "ofproto/ofproto-provider.h"
 #include "ovs-thread.h"
 #include "timer.h"
@@ -29,6 +30,31 @@ struct ofproto_dpif;
 struct ofport_dpif;
 struct dpif_backer;
 
+/* Ofproto-dpif -- DPIF based ofproto implementation.
+ *
+ * Ofproto-dpif provides an ofproto implementation for those platforms which
+ * implement the netdev and dpif interface defined in netdev.h and dpif.h.  The
+ * most important of which is the Linux Kernel Module (dpif-linux), but
+ * alternatives are supported such as a userspace only implementation
+ * (dpif-netdev), and a dummy implementation used for unit testing.
+ *
+ * Ofproto-dpif is divided into three major chunks.
+ * - ofproto-dpif.c
+ *   The main ofproto-dpif module is responsible for implementing the
+ *   provider interface, installing and removing datapath flows, maintaining
+ *   packet statistics, running protocols (BFD, LACP, STP, etc), and
+ *   configuring relevant submodules.
+ * - ofproto-dpif-upcall.c
+ *   Ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel,
+ *   processing miss upcalls, and handing more complex ones up to the main
+ *   ofproto-dpif module.  Miss upcall processing boils down to figuring out
+ *   what each packet's actions are, executing them (i.e. asking the kernel to
+ *   forward it), and handing it up to ofproto-dpif to decided whether or not
+ *   to install a kernel flow.
+ * - ofproto-dpif-xlate.c
+ *   Ofproto-dpif-xlate is responsible for translating translating OpenFlow
+ *   actions into datapath actions. */
+
 struct rule_dpif {
     struct rule up;
 
-- 
1.7.9.5




More information about the dev mailing list