X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fdpif.c;h=a866499514063482009f2edc433f8627ce677321;hb=d0a46cb4608e632f5028034762f0adde2ce947a0;hp=d179d8a1bc2a1a2e49e13096a31320a3f1a67b69;hpb=a36de779d739cdcd72c65c67a547a786798b595a;p=cascardo%2Fovs.git diff --git a/lib/dpif.c b/lib/dpif.c index d179d8a1b..a86649951 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,6 +25,8 @@ #include "coverage.h" #include "dpctl.h" +#include "dp-packet.h" +#include "dpif-netdev.h" #include "dynamic-string.h" #include "flow.h" #include "netdev.h" @@ -35,17 +37,19 @@ #include "ofp-print.h" #include "ofp-util.h" #include "ofpbuf.h" -#include "packet-dpif.h" #include "packets.h" #include "poll-loop.h" +#include "route-table.h" +#include "seq.h" #include "shash.h" #include "sset.h" #include "timeval.h" -#include "tnl-arp-cache.h" +#include "tnl-neigh-cache.h" #include "tnl-ports.h" #include "util.h" +#include "uuid.h" #include "valgrind.h" -#include "vlog.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(dpif); @@ -89,6 +93,7 @@ static void log_flow_message(const struct dpif *dpif, int error, const char *operation, const struct nlattr *key, size_t key_len, const struct nlattr *mask, size_t mask_len, + const ovs_u128 *ufid, const struct dpif_flow_stats *stats, const struct nlattr *actions, size_t actions_len); static void log_operation(const struct dpif *, const char *operation, @@ -103,6 +108,9 @@ static void log_execute_message(struct dpif *, const struct dpif_execute *, static void log_flow_get_message(const struct dpif *, const struct dpif_flow_get *, int error); +/* Incremented whenever tnl route, arp, etc changes. */ +struct seq *tnl_conf_seq; + static void dp_initialize(void) { @@ -111,13 +119,17 @@ dp_initialize(void) if (ovsthread_once_start(&once)) { int i; + tnl_conf_seq = seq_create(); + dpctl_unixctl_register(); + tnl_port_map_init(); + tnl_neigh_cache_init(); + route_table_init(); + for (i = 0; i < ARRAY_SIZE(base_dpif_classes); i++) { dp_register_provider(base_dpif_classes[i]); } - dpctl_unixctl_register(); + ovsthread_once_done(&once); - tnl_port_map_init(); - tnl_arp_cache_init(); } } @@ -125,6 +137,7 @@ static int dp_register_provider__(const struct dpif_class *new_class) { struct registered_dpif_class *registered_class; + int error; if (sset_contains(&dpif_blacklist, new_class->type)) { VLOG_DBG("attempted to register blacklisted provider: %s", @@ -138,6 +151,13 @@ dp_register_provider__(const struct dpif_class *new_class) return EEXIST; } + error = new_class->init ? new_class->init() : 0; + if (error) { + VLOG_WARN("failed to initialize %s datapath class: %s", + new_class->type, ovs_strerror(error)); + return error; + } + registered_class = xmalloc(sizeof *registered_class); registered_class->dpif_class = new_class; registered_class->refcount = 0; @@ -216,15 +236,14 @@ dp_blacklist_provider(const char *type) ovs_mutex_unlock(&dpif_mutex); } -/* Clears 'types' and enumerates the types of all currently registered datapath - * providers into it. The caller must first initialize the sset. */ +/* Adds the types of all currently registered datapath providers to 'types'. + * The caller must first initialize the sset. */ void dp_enumerate_types(struct sset *types) { struct shash_node *node; dp_initialize(); - sset_clear(types); ovs_mutex_lock(&dpif_mutex); SHASH_FOR_EACH(node, &dpif_classes) { @@ -796,11 +815,11 @@ dpif_port_poll_wait(const struct dpif *dpif) * arguments must have been initialized through a call to flow_extract(). * 'used' is stored into stats->used. */ void -dpif_flow_stats_extract(const struct flow *flow, const struct ofpbuf *packet, +dpif_flow_stats_extract(const struct flow *flow, const struct dp_packet *packet, long long int used, struct dpif_flow_stats *stats) { stats->tcp_flags = ntohs(flow->tcp_flags); - stats->n_bytes = ofpbuf_size(packet); + stats->n_bytes = dp_packet_size(packet); stats->n_packets = 1; stats->used = used; } @@ -822,6 +841,22 @@ dpif_flow_stats_format(const struct dpif_flow_stats *stats, struct ds *s) } } +/* Places the hash of the 'key_len' bytes starting at 'key' into '*hash'. */ +void +dpif_flow_hash(const struct dpif *dpif OVS_UNUSED, + const void *key, size_t key_len, ovs_u128 *hash) +{ + static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER; + static uint32_t secret; + + if (ovsthread_once_start(&once)) { + secret = random_uint32(); + ovsthread_once_done(&once); + } + hash_bytes128(key, key_len, secret, hash); + uuid_set_bits_v4((struct uuid *)hash); +} + /* Deletes all flows from 'dpif'. Returns 0 if successful, otherwise a * positive errno value. */ int @@ -836,11 +871,57 @@ dpif_flow_flush(struct dpif *dpif) return error; } +/* Attempts to install 'key' into the datapath, fetches it, then deletes it. + * Returns true if the datapath supported installing 'flow', false otherwise. + */ +bool +dpif_probe_feature(struct dpif *dpif, const char *name, + const struct ofpbuf *key, const ovs_u128 *ufid) +{ + struct dpif_flow flow; + struct ofpbuf reply; + uint64_t stub[DPIF_FLOW_BUFSIZE / 8]; + bool enable_feature = false; + int error; + + /* Use DPIF_FP_MODIFY to cover the case where ovs-vswitchd is killed (and + * restarted) at just the right time such that feature probes from the + * previous run are still present in the datapath. */ + error = dpif_flow_put(dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY | DPIF_FP_PROBE, + key->data, key->size, NULL, 0, NULL, 0, + ufid, PMD_ID_NULL, NULL); + if (error) { + if (error != EINVAL) { + VLOG_WARN("%s: %s flow probe failed (%s)", + dpif_name(dpif), name, ovs_strerror(error)); + } + return false; + } + + ofpbuf_use_stack(&reply, &stub, sizeof stub); + error = dpif_flow_get(dpif, key->data, key->size, ufid, + PMD_ID_NULL, &reply, &flow); + if (!error + && (!ufid || (flow.ufid_present + && ovs_u128_equals(ufid, &flow.ufid)))) { + enable_feature = true; + } + + error = dpif_flow_del(dpif, key->data, key->size, ufid, + PMD_ID_NULL, NULL); + if (error) { + VLOG_WARN("%s: failed to delete %s feature probe flow", + dpif_name(dpif), name); + } + + return enable_feature; +} + /* A dpif_operate() wrapper for performing a single DPIF_OP_FLOW_GET. */ int dpif_flow_get(struct dpif *dpif, - const struct nlattr *key, size_t key_len, - struct ofpbuf *buf, struct dpif_flow *flow) + const struct nlattr *key, size_t key_len, const ovs_u128 *ufid, + const unsigned pmd_id, struct ofpbuf *buf, struct dpif_flow *flow) { struct dpif_op *opp; struct dpif_op op; @@ -848,7 +929,11 @@ dpif_flow_get(struct dpif *dpif, op.type = DPIF_OP_FLOW_GET; op.u.flow_get.key = key; op.u.flow_get.key_len = key_len; + op.u.flow_get.ufid = ufid; + op.u.flow_get.pmd_id = pmd_id; op.u.flow_get.buffer = buf; + + memset(flow, 0, sizeof *flow); op.u.flow_get.flow = flow; op.u.flow_get.flow->key = key; op.u.flow_get.flow->key_len = key_len; @@ -865,6 +950,7 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags, const struct nlattr *key, size_t key_len, const struct nlattr *mask, size_t mask_len, const struct nlattr *actions, size_t actions_len, + const ovs_u128 *ufid, const unsigned pmd_id, struct dpif_flow_stats *stats) { struct dpif_op *opp; @@ -878,6 +964,8 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags, op.u.flow_put.mask_len = mask_len; op.u.flow_put.actions = actions; op.u.flow_put.actions_len = actions_len; + op.u.flow_put.ufid = ufid; + op.u.flow_put.pmd_id = pmd_id; op.u.flow_put.stats = stats; opp = &op; @@ -889,8 +977,8 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags, /* A dpif_operate() wrapper for performing a single DPIF_OP_FLOW_DEL. */ int dpif_flow_del(struct dpif *dpif, - const struct nlattr *key, size_t key_len, - struct dpif_flow_stats *stats) + const struct nlattr *key, size_t key_len, const ovs_u128 *ufid, + const unsigned pmd_id, struct dpif_flow_stats *stats) { struct dpif_op *opp; struct dpif_op op; @@ -898,7 +986,10 @@ dpif_flow_del(struct dpif *dpif, op.type = DPIF_OP_FLOW_DEL; op.u.flow_del.key = key; op.u.flow_del.key_len = key_len; + op.u.flow_del.ufid = ufid; + op.u.flow_del.pmd_id = pmd_id; op.u.flow_del.stats = stats; + op.u.flow_del.terse = false; opp = &op; dpif_operate(dpif, &opp, 1); @@ -907,14 +998,15 @@ dpif_flow_del(struct dpif *dpif, } /* Creates and returns a new 'struct dpif_flow_dump' for iterating through the - * flows in 'dpif'. + * flows in 'dpif'. If 'terse' is true, then only UFID and statistics will + * be returned in the dump. Otherwise, all fields will be returned. * * This function always successfully returns a dpif_flow_dump. Error * reporting is deferred to dpif_flow_dump_destroy(). */ struct dpif_flow_dump * -dpif_flow_dump_create(const struct dpif *dpif) +dpif_flow_dump_create(const struct dpif *dpif, bool terse) { - return dpif->dpif_class->flow_dump_create(dpif); + return dpif->dpif_class->flow_dump_create(dpif, terse); } /* Destroys 'dump', which must have been created with dpif_flow_dump_create(). @@ -979,7 +1071,7 @@ dpif_flow_dump_next(struct dpif_flow_dump_thread *thread, for (f = flows; f < &flows[n] && should_log_flow_message(0); f++) { log_flow_message(dpif, 0, "flow_dump", f->key, f->key_len, f->mask, f->mask_len, - &f->stats, f->actions, f->actions_len); + &f->ufid, &f->stats, f->actions, f->actions_len); } } else { VLOG_DBG_RL(&dpmsg_rl, "%s: dumped all flows", dpif_name(dpif)); @@ -995,17 +1087,17 @@ struct dpif_execute_helper_aux { /* This is called for actions that need the context of the datapath to be * meaningful. */ static void -dpif_execute_helper_cb(void *aux_, struct dpif_packet **packets, int cnt, +dpif_execute_helper_cb(void *aux_, struct dp_packet **packets, int cnt, const struct nlattr *action, bool may_steal OVS_UNUSED) { struct dpif_execute_helper_aux *aux = aux_; int type = nl_attr_type(action); - struct ofpbuf *packet = &packets[0]->ofpbuf; - struct pkt_metadata *md = &packets[0]->md; + struct dp_packet *packet = *packets; ovs_assert(cnt == 1); switch ((enum ovs_action_attr)type) { + case OVS_ACTION_ATTR_CT: case OVS_ACTION_ATTR_OUTPUT: case OVS_ACTION_ATTR_TUNNEL_PUSH: case OVS_ACTION_ATTR_TUNNEL_POP: @@ -1014,8 +1106,11 @@ dpif_execute_helper_cb(void *aux_, struct dpif_packet **packets, int cnt, struct dpif_execute execute; struct ofpbuf execute_actions; uint64_t stub[256 / 8]; + struct pkt_metadata *md = &packet->md; + bool dst_set; - if (md->tunnel.ip_dst) { + dst_set = flow_tnl_dst_is_set(&md->tunnel); + if (dst_set) { /* The Linux kernel datapath throws away the tunnel information * that we supply as metadata. We have to use a "set" action to * supply it. */ @@ -1023,21 +1118,21 @@ dpif_execute_helper_cb(void *aux_, struct dpif_packet **packets, int cnt, odp_put_tunnel_action(&md->tunnel, &execute_actions); ofpbuf_put(&execute_actions, action, NLA_ALIGN(action->nla_len)); - execute.actions = ofpbuf_data(&execute_actions); - execute.actions_len = ofpbuf_size(&execute_actions); + execute.actions = execute_actions.data; + execute.actions_len = execute_actions.size; } else { execute.actions = action; execute.actions_len = NLA_ALIGN(action->nla_len); } execute.packet = packet; - execute.md = *md; execute.needs_help = false; execute.probe = false; + execute.mtu = 0; aux->error = dpif_execute(aux->dpif, &execute); log_execute_message(aux->dpif, &execute, true, aux->error); - if (md->tunnel.ip_dst) { + if (dst_set) { ofpbuf_uninit(&execute_actions); } break; @@ -1066,23 +1161,13 @@ static int dpif_execute_with_help(struct dpif *dpif, struct dpif_execute *execute) { struct dpif_execute_helper_aux aux = {dpif, 0}; - struct dpif_packet packet, *pp; + struct dp_packet *pp; COVERAGE_INC(dpif_execute_with_help); - packet.ofpbuf = *execute->packet; - packet.md = execute->md; - pp = &packet; - + pp = execute->packet; odp_execute_actions(&aux, &pp, 1, false, execute->actions, execute->actions_len, dpif_execute_helper_cb); - - /* Even though may_steal is set to false, some actions could modify or - * reallocate the ofpbuf memory. We need to pass those changes to the - * caller */ - *execute->packet = packet.ofpbuf; - execute->md = packet.md; - return aux.error; } @@ -1264,6 +1349,14 @@ dpif_handlers_set(struct dpif *dpif, uint32_t n_handlers) return error; } +void +dpif_register_dp_purge_cb(struct dpif *dpif, dp_purge_callback *cb, void *aux) +{ + if (dpif->dpif_class->register_dp_purge_cb) { + dpif->dpif_class->register_dp_purge_cb(dpif, cb, aux); + } +} + void dpif_register_upcall_cb(struct dpif *dpif, upcall_callback *cb, void *aux) { @@ -1295,8 +1388,8 @@ dpif_print_packet(struct dpif *dpif, struct dpif_upcall *upcall) struct ds flow; char *packet; - packet = ofp_packet_to_string(ofpbuf_data(&upcall->packet), - ofpbuf_size(&upcall->packet)); + packet = ofp_packet_to_string(dp_packet_data(&upcall->packet), + dp_packet_size(&upcall->packet)); ds_init(&flow); odp_flow_key_format(upcall->key, upcall->key_len, &flow); @@ -1313,13 +1406,12 @@ dpif_print_packet(struct dpif *dpif, struct dpif_upcall *upcall) /* If 'dpif' creates its own I/O polling threads, refreshes poll threads * configuration. */ int -dpif_poll_threads_set(struct dpif *dpif, unsigned int n_rxqs, - const char *cmask) +dpif_poll_threads_set(struct dpif *dpif, const char *cmask) { int error = 0; if (dpif->dpif_class->poll_threads_set) { - error = dpif->dpif_class->poll_threads_set(dpif, n_rxqs, cmask); + error = dpif->dpif_class->poll_threads_set(dpif, cmask); if (error) { log_operation(dpif, "poll_threads_set", error); } @@ -1491,7 +1583,7 @@ flow_message_log_level(int error) static bool should_log_flow_message(int error) { - return !vlog_should_drop(THIS_MODULE, flow_message_log_level(error), + return !vlog_should_drop(&this_module, flow_message_log_level(error), error ? &error_rl : &dpmsg_rl); } @@ -1499,7 +1591,7 @@ static void log_flow_message(const struct dpif *dpif, int error, const char *operation, const struct nlattr *key, size_t key_len, const struct nlattr *mask, size_t mask_len, - const struct dpif_flow_stats *stats, + const ovs_u128 *ufid, const struct dpif_flow_stats *stats, const struct nlattr *actions, size_t actions_len) { struct ds ds = DS_EMPTY_INITIALIZER; @@ -1511,6 +1603,10 @@ log_flow_message(const struct dpif *dpif, int error, const char *operation, if (error) { ds_put_format(&ds, "(%s) ", ovs_strerror(error)); } + if (ufid) { + odp_format_ufid(ufid, &ds); + ds_put_cstr(&ds, " "); + } odp_flow_format(key, key_len, mask, mask_len, NULL, &ds, true); if (stats) { ds_put_cstr(&ds, ", "); @@ -1520,7 +1616,7 @@ log_flow_message(const struct dpif *dpif, int error, const char *operation, ds_put_cstr(&ds, ", actions:"); format_odp_actions(&ds, actions, actions_len); } - vlog(THIS_MODULE, flow_message_log_level(error), "%s", ds_cstr(&ds)); + vlog(&this_module, flow_message_log_level(error), "%s", ds_cstr(&ds)); ds_destroy(&ds); } @@ -1544,7 +1640,8 @@ log_flow_put_message(struct dpif *dpif, const struct dpif_flow_put *put, } log_flow_message(dpif, error, ds_cstr(&s), put->key, put->key_len, put->mask, put->mask_len, - put->stats, put->actions, put->actions_len); + put->ufid, put->stats, put->actions, + put->actions_len); ds_destroy(&s); } } @@ -1555,7 +1652,8 @@ log_flow_del_message(struct dpif *dpif, const struct dpif_flow_del *del, { if (should_log_flow_message(error)) { log_flow_message(dpif, error, "flow_del", del->key, del->key_len, - NULL, 0, !error ? del->stats : NULL, NULL, 0); + NULL, 0, del->ufid, !error ? del->stats : NULL, + NULL, 0); } } @@ -1585,8 +1683,8 @@ log_execute_message(struct dpif *dpif, const struct dpif_execute *execute, struct ds ds = DS_EMPTY_INITIALIZER; char *packet; - packet = ofp_packet_to_string(ofpbuf_data(execute->packet), - ofpbuf_size(execute->packet)); + packet = ofp_packet_to_string(dp_packet_data(execute->packet), + dp_packet_size(execute->packet)); ds_put_format(&ds, "%s: %sexecute ", dpif_name(dpif), (subexecute ? "sub-" @@ -1597,7 +1695,8 @@ log_execute_message(struct dpif *dpif, const struct dpif_execute *execute, ds_put_format(&ds, " failed (%s)", ovs_strerror(error)); } ds_put_format(&ds, " on packet %s", packet); - vlog(THIS_MODULE, error ? VLL_WARN : VLL_DBG, "%s", ds_cstr(&ds)); + ds_put_format(&ds, " mtu %d", execute->mtu); + vlog(&this_module, error ? VLL_WARN : VLL_DBG, "%s", ds_cstr(&ds)); ds_destroy(&ds); free(packet); } @@ -1611,7 +1710,7 @@ log_flow_get_message(const struct dpif *dpif, const struct dpif_flow_get *get, log_flow_message(dpif, error, "flow_get", get->key, get->key_len, get->flow->mask, get->flow->mask_len, - &get->flow->stats, + get->ufid, &get->flow->stats, get->flow->actions, get->flow->actions_len); } } @@ -1619,6 +1718,5 @@ log_flow_get_message(const struct dpif *dpif, const struct dpif_flow_get *get, bool dpif_supports_tnl_push_pop(const struct dpif *dpif) { - return !strcmp(dpif->dpif_class->type, "netdev") || - !strcmp(dpif->dpif_class->type, "dummy"); + return dpif_is_netdev(dpif); }