/*
- * 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.
#include "coverage.h"
#include "dpctl.h"
+#include "dp-packet.h"
+#include "dpif-netdev.h"
#include "dynamic-string.h"
#include "flow.h"
#include "netdev.h"
#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 "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);
tnl_conf_seq = seq_create();
dpctl_unixctl_register();
tnl_port_map_init();
- tnl_arp_cache_init();
+ tnl_neigh_cache_init();
route_table_init();
for (i = 0; i < ARRAY_SIZE(base_dpif_classes); i++) {
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",
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;
* 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;
}
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
* 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,
- ofpbuf_data(key), ofpbuf_size(key), NULL, 0, NULL, 0,
- ufid, NULL);
+ 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)",
}
ofpbuf_use_stack(&reply, &stub, sizeof stub);
- error = dpif_flow_get(dpif, ofpbuf_data(key), ofpbuf_size(key), ufid,
- &reply, &flow);
+ error = dpif_flow_get(dpif, key->data, key->size, ufid,
+ PMD_ID_NULL, &reply, &flow);
if (!error
- && (!ufid || (flow.ufid_present && ovs_u128_equal(ufid, &flow.ufid)))) {
+ && (!ufid || (flow.ufid_present
+ && ovs_u128_equals(ufid, &flow.ufid)))) {
enable_feature = true;
}
- error = dpif_flow_del(dpif, ofpbuf_data(key), ofpbuf_size(key), ufid,
- NULL);
+ 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;
}
-/* Tests whether 'dpif' supports userspace flow ids. We can skip serializing
- * some flow attributes for datapaths that support this feature.
- *
- * Returns true if 'dpif' supports UFID for flow operations.
- * Returns false if 'dpif' does not support UFID. */
-bool
-dpif_get_enable_ufid(struct dpif *dpif)
-{
- if (dpif->dpif_class->get_ufid_support) {
- return dpif->dpif_class->get_ufid_support(dpif);
- }
- return false;
-}
-
/* 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, const ovs_u128 *ufid,
- struct ofpbuf *buf, struct dpif_flow *flow)
+ const unsigned pmd_id, struct ofpbuf *buf, struct dpif_flow *flow)
{
struct dpif_op *opp;
struct dpif_op op;
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);
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, struct dpif_flow_stats *stats)
+ const ovs_u128 *ufid, const unsigned pmd_id,
+ struct dpif_flow_stats *stats)
{
struct dpif_op *opp;
struct dpif_op op;
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;
int
dpif_flow_del(struct dpif *dpif,
const struct nlattr *key, size_t key_len, const ovs_u128 *ufid,
- struct dpif_flow_stats *stats)
+ const unsigned pmd_id, struct dpif_flow_stats *stats)
{
struct dpif_op *opp;
struct dpif_op op;
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);
/* 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:
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. */
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;
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;
}
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)
{
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);
/* 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);
}
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);
}
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);
}
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-"
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);
}
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);
}
projects / cascardo / ovs.git / blobdiff