From e1ec7dd4608876283038c417065c4f9978255fa3 Mon Sep 17 00:00:00 2001 From: Ethan Jackson Date: Tue, 25 Jun 2013 14:45:43 -0700 Subject: [PATCH 1/1] ofproto-dpif: Implement multi-threaded miss handling. 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 Acked-by: Ben Pfaff --- ofproto/automake.mk | 2 + ofproto/ofproto-dpif-upcall.c | 828 ++++++++++++++++++++++++++++++++++ ofproto/ofproto-dpif-upcall.h | 130 ++++++ ofproto/ofproto-dpif-xlate.h | 4 +- ofproto/ofproto-dpif.c | 647 +++++--------------------- ofproto/ofproto-dpif.h | 29 ++ 6 files changed, 1108 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 af9a12a3e..47ca1b81f 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 000000000..54d3c21e9 --- /dev/null +++ b/ofproto/ofproto-dpif-upcall.c @@ -0,0 +1,828 @@ +/* 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 +#include "ofproto-dpif-upcall.h" + +#include +#include +#include + +#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); + +/* A thread that processes each upcall handed to it by the dispatcher thread, + * forwards the upcall's packet, and then queues it to the main ofproto_dpif + * to possibly set up a kernel flow as a cache. */ +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'. */ +}; + +/* An upcall handler for ofproto_dpif. + * + * udpif is implemented as a "dispatcher" thread that reads upcalls from the + * kernel. It processes each upcall just enough to figure out its next + * destination. For a "miss" upcall (MISS_UPCALL), this is one of several + * "handler" threads (see struct handler). Other upcalls are queued to the + * main ofproto_dpif. */ +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 thread 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"); + while (!latch_is_set(&udpif->exit_latch)) { + recv_upcalls(udpif); + dpif_recv_wait(udpif->dpif); + latch_wait(&udpif->exit_latch); + poll_block(); + } + + return NULL; +} + +/* 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 000000000..f74206031 --- /dev/null +++ b/ofproto/ofproto-dpif-upcall.h @@ -0,0 +1,130 @@ +/* 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; + +/* udif is responsible for retrieving upcalls from the kernel, processing miss + * upcalls, and handing more complex ones up to the main ofproto-dpif + * module. */ + +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 *); + +void udpif_revalidate(struct udpif *); + +/* udpif can handle some upcalls on its own. Others need the main ofproto_dpif + * code to handle them. This interface passes upcalls not handled by udpif up + * to the ofproto_dpif main thread. */ + +/* Type of an upcall. */ +enum upcall_type { + /* Handled internally by udpif code. Not returned by upcall_next().*/ + BAD_UPCALL, /* Some kind of bug somewhere. */ + MISS_UPCALL, /* A flow miss. */ + + /* Require main thread's involvement. May be returned by upcall_next(). */ + SFLOW_UPCALL, /* sFlow sample. */ + FLOW_SAMPLE_UPCALL, /* Per-flow sampling. */ + IPFIX_UPCALL /* Per-bridge sampling. */ +}; + +/* An upcall. */ +struct upcall { + struct list list_node; /* For queuing upcalls. */ + + enum upcall_type type; /* Classification. */ + + /* Raw upcall plus data for keeping track of the memory backing it. */ + struct dpif_upcall dpif_upcall; /* As returned by dpif_recv() */ + struct ofpbuf upcall_buf; /* Owns some data in 'dpif_upcall'. */ + uint64_t upcall_stub[256 / 8]; /* Buffer to reduce need for malloc(). */ +}; + +struct upcall *upcall_next(struct udpif *); +void upcall_destroy(struct upcall *); + +/* udpif figures out how to forward packets, and does forward them, but it + * can't set up datapath flows on its own. This interface passes packet + * forwarding data from udpif to the higher level ofproto_dpif to allow the + * latter to set up datapath flows. */ + +/* 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. */ +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; +}; + +struct flow_miss_batch *flow_miss_batch_next(struct udpif *); +void flow_miss_batch_destroy(struct flow_miss_batch *); + +/* 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. + * + * udpif can't install drop flows by itself. This interfaces allows udpif to + * pass the drop flows up to ofproto_dpif to get it to install them. */ +struct drop_key { + struct hmap_node hmap_node; + struct list list_node; + struct nlattr *key; + size_t key_len; +}; + +struct drop_key *drop_key_next(struct udpif *); +void drop_key_destroy(struct drop_key *); +void udpif_drop_key_clear(struct udpif *); + +#endif /* ofproto-dpif-upcall.h */ diff --git a/ofproto/ofproto-dpif-xlate.h b/ofproto/ofproto-dpif-xlate.h index 1c37bc335..ba24e926f 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 6e8c6e976..050c81809 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; } @@ -837,6 +831,8 @@ type_run(const char *type) run_fast_rl(); } } + + udpif_revalidate(backer->udpif); } if (!backer->recv_set_enable) { @@ -1000,32 +996,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; } @@ -1042,14 +1016,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; @@ -1059,23 +1032,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 @@ -1135,6 +1091,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)); @@ -1204,6 +1161,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; @@ -1251,6 +1209,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(); @@ -1667,7 +1626,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); } @@ -3271,26 +3230,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; @@ -3306,96 +3245,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 @@ -3404,7 +3253,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; @@ -3429,97 +3278,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 @@ -3528,20 +3314,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; @@ -3581,57 +3357,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 * @@ -3670,109 +3414,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)); @@ -3805,66 +3464,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; } } @@ -3933,66 +3532,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. */ @@ -4366,8 +3963,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; @@ -4375,10 +3971,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; @@ -4386,7 +3979,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); @@ -4395,8 +3988,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; } @@ -4645,7 +4236,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); @@ -4653,10 +4244,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; @@ -4677,10 +4266,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); @@ -4785,7 +4370,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); @@ -4802,6 +4386,28 @@ facet_reset_counters(struct facet *facet) facet->accounted_bytes = 0; } +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) { @@ -4817,34 +4423,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); } } @@ -4916,8 +4504,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; @@ -4951,8 +4538,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 30ba566a4..6a4ae078b 100644 --- a/ofproto/ofproto-dpif.h +++ b/ofproto/ofproto-dpif.h @@ -18,6 +18,7 @@ #include #include "hmapx.h" +#include "odp-util.h" #include "ofproto/ofproto-provider.h" #include "ovs-thread.h" #include "timer.h" @@ -29,6 +30,34 @@ 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; -- 2.43.0