#include "lacp.h"
#include "learn.h"
#include "mac-learning.h"
+#include "meta-flow.h"
#include "multipath.h"
#include "netdev.h"
#include "netlink.h"
* we are just revalidating. */
bool may_learn;
+ /* Cookie of the currently matching rule, or 0. */
+ ovs_be64 cookie;
+
/* If nonnull, called just before executing a resubmit action.
*
* This is normally null so the client has to set it manually after
static void action_xlate_ctx_init(struct action_xlate_ctx *,
struct ofproto_dpif *, const struct flow *,
- ovs_be16 initial_tci, const struct ofpbuf *);
+ ovs_be16 initial_tci, ovs_be64 cookie,
+ const struct ofpbuf *);
static struct ofpbuf *xlate_actions(struct action_xlate_ctx *,
const union ofp_action *in, size_t n_in);
};
static struct facet *facet_create(struct rule_dpif *, const struct flow *);
-static void facet_remove(struct ofproto_dpif *, struct facet *);
+static void facet_remove(struct facet *);
static void facet_free(struct facet *);
static struct facet *facet_find(struct ofproto_dpif *, const struct flow *);
static struct facet *facet_lookup_valid(struct ofproto_dpif *,
const struct flow *);
-static bool facet_revalidate(struct ofproto_dpif *, struct facet *);
-
-static bool execute_controller_action(struct ofproto_dpif *,
- const struct flow *,
- const struct nlattr *odp_actions,
- size_t actions_len,
- struct ofpbuf *packet);
+static bool facet_revalidate(struct facet *);
+static bool facet_check_consistency(struct facet *);
-static void facet_flush_stats(struct ofproto_dpif *, struct facet *);
+static void facet_flush_stats(struct facet *);
-static void facet_update_time(struct ofproto_dpif *, struct facet *,
- long long int used);
+static void facet_update_time(struct facet *, long long int used);
static void facet_reset_counters(struct facet *);
static void facet_push_stats(struct facet *);
-static void facet_account(struct ofproto_dpif *, struct facet *);
+static void facet_account(struct facet *);
static bool facet_is_controller_flow(struct facet *);
ovs_be16 initial_tci; /* Initial VLAN TCI value. */
};
-static struct subfacet *subfacet_create(struct ofproto_dpif *, struct facet *,
- enum odp_key_fitness,
+static struct subfacet *subfacet_create(struct facet *, enum odp_key_fitness,
const struct nlattr *key,
size_t key_len, ovs_be16 initial_tci);
static struct subfacet *subfacet_find(struct ofproto_dpif *,
const struct nlattr *key, size_t key_len);
-static void subfacet_destroy(struct ofproto_dpif *, struct subfacet *);
-static void subfacet_destroy__(struct ofproto_dpif *, struct subfacet *);
+static void subfacet_destroy(struct subfacet *);
+static void subfacet_destroy__(struct subfacet *);
+static void subfacet_get_key(struct subfacet *, struct odputil_keybuf *,
+ struct ofpbuf *key);
static void subfacet_reset_dp_stats(struct subfacet *,
struct dpif_flow_stats *);
-static void subfacet_update_time(struct ofproto_dpif *, struct subfacet *,
- long long int used);
-static void subfacet_update_stats(struct ofproto_dpif *, struct subfacet *,
+static void subfacet_update_time(struct subfacet *, long long int used);
+static void subfacet_update_stats(struct subfacet *,
const struct dpif_flow_stats *);
-static void subfacet_make_actions(struct ofproto_dpif *, struct subfacet *,
+static void subfacet_make_actions(struct subfacet *,
const struct ofpbuf *packet);
-static int subfacet_install(struct ofproto_dpif *, struct subfacet *,
+static int subfacet_install(struct subfacet *,
const struct nlattr *actions, size_t actions_len,
struct dpif_flow_stats *);
-static void subfacet_uninstall(struct ofproto_dpif *, struct subfacet *);
+static void subfacet_uninstall(struct subfacet *);
struct ofport_dpif {
struct ofport up;
dpif_flow_flush(ofproto->dpif);
dpif_recv_purge(ofproto->dpif);
- error = dpif_recv_set_mask(ofproto->dpif,
- ((1u << DPIF_UC_MISS) |
- (1u << DPIF_UC_ACTION)));
+ error = dpif_recv_set(ofproto->dpif, true);
if (error) {
VLOG_ERR("failed to listen on datapath %s: %s", name, strerror(error));
dpif_close(ofproto->dpif);
HMAP_FOR_EACH_SAFE (facet, next, hmap_node, &ofproto->facets) {
if (revalidate_all
|| tag_set_intersects(&revalidate_set, facet->tags)) {
- facet_revalidate(ofproto, facet);
+ facet_revalidate(facet);
+ }
+ }
+ }
+
+ /* Check the consistency of a random facet, to aid debugging. */
+ if (!hmap_is_empty(&ofproto->facets) && !ofproto->need_revalidate) {
+ struct facet *facet;
+
+ facet = CONTAINER_OF(hmap_random_node(&ofproto->facets),
+ struct facet, hmap_node);
+ if (!tag_set_intersects(&ofproto->revalidate_set, facet->tags)) {
+ if (!facet_check_consistency(facet)) {
+ ofproto->need_revalidate = true;
}
}
}
subfacet->dp_packet_count = 0;
subfacet->dp_byte_count = 0;
}
- facet_remove(ofproto, facet);
+ facet_remove(facet);
}
dpif_flow_flush(ofproto->dpif);
}
if (stp_learn_in_state(ofport->stp_state)
!= stp_learn_in_state(state)) {
/* xxx Learning action flows should also be flushed. */
- mac_learning_flush(ofproto->ml);
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
}
fwd_change = stp_forward_in_state(ofport->stp_state)
!= stp_forward_in_state(state);
update_stp_port_state(ofport);
}
}
+
+ if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+ }
}
}
}
bond_run(bundle->bond, &bundle->ofproto->revalidate_set,
- lacp_negotiated(bundle->lacp));
+ lacp_status(bundle->lacp));
if (bond_should_send_learning_packets(bundle->bond)) {
bundle_send_learning_packets(bundle);
}
}
ofproto->need_revalidate = true;
- mac_learning_flush(ofproto->ml);
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
mirror_update_dups(ofproto);
return 0;
ofproto = mirror->ofproto;
ofproto->need_revalidate = true;
- mac_learning_flush(ofproto->ml);
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
- ofproto->need_revalidate = true;
- mac_learning_flush(ofproto->ml);
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
}
return 0;
}
};
struct flow_miss_op {
- union dpif_op dpif_op;
+ struct dpif_op dpif_op;
struct subfacet *subfacet;
};
* OpenFlow controller as necessary according to their individual
* configurations. */
static void
-send_packet_in_miss(struct ofproto_dpif *ofproto, struct ofpbuf *packet,
+send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet,
const struct flow *flow)
{
struct ofputil_packet_in pin;
pin.packet_len = packet->size;
pin.total_len = packet->size;
pin.reason = OFPR_NO_MATCH;
- pin.buffer_id = 0; /* not yet known */
- pin.send_len = 0; /* not used for flow table misses */
-
- flow_get_metadata(flow, &pin.fmd);
-
- /* Registers aren't meaningful on a miss. */
- memset(pin.fmd.reg_masks, 0, sizeof pin.fmd.reg_masks);
-
- connmgr_send_packet_in(ofproto->up.connmgr, &pin, flow);
-}
-
-/* Sends an OFPT_PACKET_IN message for 'packet' of type OFPR_ACTION to each
- * OpenFlow controller as necessary according to their individual
- * configurations.
- *
- * 'send_len' should be the number of bytes of 'packet' to send to the
- * controller, as specified in the action that caused the packet to be sent. */
-static void
-send_packet_in_action(struct ofproto_dpif *ofproto, struct ofpbuf *packet,
- uint64_t userdata, const struct flow *flow)
-{
- struct ofputil_packet_in pin;
- struct user_action_cookie cookie;
- memcpy(&cookie, &userdata, sizeof(cookie));
+ pin.table_id = 0;
+ pin.cookie = 0;
- pin.packet = packet->data;
- pin.packet_len = packet->size;
- pin.total_len = packet->size;
- pin.reason = OFPR_ACTION;
pin.buffer_id = 0; /* not yet known */
- pin.send_len = cookie.data;
+ pin.send_len = 0; /* not used for flow table misses */
flow_get_metadata(flow, &pin.fmd);
- /* Metadata may not be accurate at this time. */
+ /* Registers aren't meaningful on a miss. */
memset(pin.fmd.reg_masks, 0, sizeof pin.fmd.reg_masks);
- pin.fmd.tun_id_mask = 0;
connmgr_send_packet_in(ofproto->up.connmgr, &pin, flow);
}
facet = facet_create(rule, flow);
}
- subfacet = subfacet_create(ofproto, facet,
+ subfacet = subfacet_create(facet,
miss->key_fitness, miss->key, miss->key_len,
miss->initial_tci);
LIST_FOR_EACH_SAFE (packet, next_packet, list_node, &miss->packets) {
struct dpif_flow_stats stats;
+ struct flow_miss_op *op;
+ struct dpif_execute *execute;
- list_remove(&packet->list_node);
ofproto->n_matches++;
if (facet->rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
}
if (!facet->may_install || !subfacet->actions) {
- subfacet_make_actions(ofproto, subfacet, packet);
+ subfacet_make_actions(subfacet, packet);
}
- /* Credit statistics to subfacet for this packet. We must do this now
- * because execute_controller_action() below may destroy 'packet'. */
dpif_flow_stats_extract(&facet->flow, packet, &stats);
- subfacet_update_stats(ofproto, subfacet, &stats);
-
- if (!execute_controller_action(ofproto, &facet->flow,
- subfacet->actions,
- subfacet->actions_len, packet)
- && subfacet->actions_len > 0) {
- struct flow_miss_op *op = &ops[(*n_ops)++];
- struct dpif_execute *execute = &op->dpif_op.execute;
-
- if (flow->vlan_tci != subfacet->initial_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);
- }
+ subfacet_update_stats(subfacet, &stats);
+
+ if (!subfacet->actions_len) {
+ /* No actions to execute, so skip talking to the dpif. */
+ continue;
+ }
- op->subfacet = subfacet;
- execute->type = DPIF_OP_EXECUTE;
- execute->key = miss->key;
- execute->key_len = miss->key_len;
- execute->actions
- = (facet->may_install
- ? subfacet->actions
- : xmemdup(subfacet->actions, subfacet->actions_len));
- execute->actions_len = subfacet->actions_len;
- execute->packet = packet;
+ if (flow->vlan_tci != subfacet->initial_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 = &ops[(*n_ops)++];
+ execute = &op->dpif_op.u.execute;
+ op->subfacet = subfacet;
+ op->dpif_op.type = DPIF_OP_EXECUTE;
+ execute->key = miss->key;
+ execute->key_len = miss->key_len;
+ execute->actions = (facet->may_install
+ ? subfacet->actions
+ : xmemdup(subfacet->actions,
+ subfacet->actions_len));
+ execute->actions_len = subfacet->actions_len;
+ execute->packet = packet;
}
if (facet->may_install && subfacet->key_fitness != ODP_FIT_TOO_LITTLE) {
struct flow_miss_op *op = &ops[(*n_ops)++];
- struct dpif_flow_put *put = &op->dpif_op.flow_put;
+ struct dpif_flow_put *put = &op->dpif_op.u.flow_put;
op->subfacet = subfacet;
- put->type = DPIF_OP_FLOW_PUT;
+ op->dpif_op.type = DPIF_OP_FLOW_PUT;
put->flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
put->key = miss->key;
put->key_len = miss->key_len;
struct dpif_upcall *upcall;
struct flow_miss *miss, *next_miss;
struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH * 2];
- union dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
+ struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
struct hmap todo;
size_t n_ops;
size_t i;
/* Process each element in the to-do list, constructing the set of
* operations to batch. */
n_ops = 0;
- HMAP_FOR_EACH_SAFE (miss, next_miss, hmap_node, &todo) {
+ HMAP_FOR_EACH (miss, hmap_node, &todo) {
handle_flow_miss(ofproto, miss, flow_miss_ops, &n_ops);
- ofpbuf_list_delete(&miss->packets);
- hmap_remove(&todo, &miss->hmap_node);
- free(miss);
}
assert(n_ops <= ARRAY_SIZE(flow_miss_ops));
- hmap_destroy(&todo);
/* Execute batch. */
for (i = 0; i < n_ops; i++) {
for (i = 0; i < n_ops; i++) {
struct flow_miss_op *op = &flow_miss_ops[i];
struct dpif_execute *execute;
- struct dpif_flow_put *put;
switch (op->dpif_op.type) {
case DPIF_OP_EXECUTE:
- execute = &op->dpif_op.execute;
+ execute = &op->dpif_op.u.execute;
if (op->subfacet->actions != execute->actions) {
free((struct nlattr *) execute->actions);
}
- ofpbuf_delete((struct ofpbuf *) execute->packet);
break;
case DPIF_OP_FLOW_PUT:
- put = &op->dpif_op.flow_put;
- if (!put->error) {
+ if (!op->dpif_op.error) {
op->subfacet->installed = true;
}
break;
}
}
+ HMAP_FOR_EACH_SAFE (miss, next_miss, hmap_node, &todo) {
+ ofpbuf_list_delete(&miss->packets);
+ hmap_remove(&todo, &miss->hmap_node);
+ free(miss);
+ }
+ hmap_destroy(&todo);
}
static void
dpif_sflow_received(ofproto->sflow, upcall->packet, &flow,
&cookie);
}
- } else if (cookie.type == USER_ACTION_COOKIE_CONTROLLER) {
- COVERAGE_INC(ofproto_dpif_ctlr_action);
- send_packet_in_action(ofproto, upcall->packet, upcall->userdata,
- &flow);
} else {
VLOG_WARN_RL(&rl, "invalid user cookie : 0x%"PRIx64, upcall->userdata);
}
subfacet->dp_packet_count = stats->n_packets;
subfacet->dp_byte_count = stats->n_bytes;
- subfacet_update_time(p, subfacet, stats->used);
- facet_account(p, facet);
+ subfacet_update_time(subfacet, stats->used);
+ facet_account(facet);
facet_push_stats(facet);
} else {
if (!VLOG_DROP_WARN(&rl)) {
HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
&ofproto->subfacets) {
if (subfacet->used < cutoff) {
- subfacet_destroy(ofproto, subfacet);
+ subfacet_destroy(subfacet);
}
}
}
static void
rule_expire(struct rule_dpif *rule)
{
- struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
struct facet *facet, *next_facet;
long long int now;
uint8_t reason;
/* Update stats. (This is a no-op if the rule expired due to an idle
* timeout, because that only happens when the rule has no facets left.) */
LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
- facet_remove(ofproto, facet);
+ facet_remove(facet);
}
/* Get rid of the rule. */
free(facet);
}
-/* If the 'actions_len' bytes of actions in 'odp_actions' are just a single
- * OVS_ACTION_ATTR_USERSPACE action, executes it internally and returns true.
- * Otherwise, returns false without doing anything. */
-static bool
-execute_controller_action(struct ofproto_dpif *ofproto,
- const struct flow *flow,
- const struct nlattr *odp_actions, size_t actions_len,
- struct ofpbuf *packet)
-{
- if (actions_len
- && odp_actions->nla_type == OVS_ACTION_ATTR_USERSPACE
- && NLA_ALIGN(odp_actions->nla_len) == actions_len) {
- /* As an optimization, avoid a round-trip from userspace to kernel to
- * userspace. This also avoids possibly filling up kernel packet
- * buffers along the way.
- *
- * This optimization will not accidentally catch sFlow
- * OVS_ACTION_ATTR_USERSPACE actions, since those are encapsulated
- * inside OVS_ACTION_ATTR_SAMPLE. */
- const struct nlattr *nla;
-
- nla = nl_attr_find_nested(odp_actions, OVS_USERSPACE_ATTR_USERDATA);
- send_packet_in_action(ofproto, packet, nl_attr_get_u64(nla), flow);
- return true;
- } else {
- return false;
- }
-}
-
/* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on
* 'packet', which arrived on 'in_port'.
*
struct ofpbuf key;
int error;
- if (execute_controller_action(ofproto, flow, odp_actions, actions_len,
- packet)) {
- ofpbuf_delete(packet);
- return true;
- }
-
ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
odp_flow_key_from_flow(&key, flow);
* - Removes 'facet' from its rule and from ofproto->facets.
*/
static void
-facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_remove(struct facet *facet)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
struct subfacet *subfacet, *next_subfacet;
assert(!list_is_empty(&facet->subfacets));
/* First uninstall all of the subfacets to get final statistics. */
LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
- subfacet_uninstall(ofproto, subfacet);
+ subfacet_uninstall(subfacet);
}
/* Flush the final stats to the rule.
* This might require us to have at least one subfacet around so that we
* can use its actions for accounting in facet_account(), which is why we
* have uninstalled but not yet destroyed the subfacets. */
- facet_flush_stats(ofproto, facet);
+ facet_flush_stats(facet);
/* Now we're really all done so destroy everything. */
LIST_FOR_EACH_SAFE (subfacet, next_subfacet, list_node,
&facet->subfacets) {
- subfacet_destroy__(ofproto, subfacet);
+ subfacet_destroy__(subfacet);
}
hmap_remove(&ofproto->facets, &facet->hmap_node);
list_remove(&facet->list_node);
}
static void
-facet_account(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_account(struct facet *facet)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
uint64_t n_bytes;
struct subfacet *subfacet;
const struct nlattr *a;
struct action_xlate_ctx ctx;
action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
- facet->flow.vlan_tci, NULL);
+ facet->flow.vlan_tci,
+ facet->rule->up.flow_cookie, NULL);
ctx.may_learn = true;
ofpbuf_delete(xlate_actions(&ctx, facet->rule->up.actions,
facet->rule->up.n_actions));
* 'facet''s statistics in the datapath should have been zeroed and folded into
* its packet and byte counts before this function is called. */
static void
-facet_flush_stats(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_flush_stats(struct facet *facet)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
struct subfacet *subfacet;
LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
}
facet_push_stats(facet);
- facet_account(ofproto, facet);
+ facet_account(facet);
if (ofproto->netflow && !facet_is_controller_flow(facet)) {
struct ofexpired expired;
if (facet
&& (ofproto->need_revalidate
|| tag_set_intersects(&ofproto->revalidate_set, facet->tags))
- && !facet_revalidate(ofproto, facet)) {
+ && !facet_revalidate(facet)) {
COVERAGE_INC(facet_invalidated);
return NULL;
}
return facet;
}
-/* Re-searches 'ofproto''s classifier for a rule matching 'facet':
+static bool
+facet_check_consistency(struct facet *facet)
+{
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
+
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
+
+ struct rule_dpif *rule;
+ struct subfacet *subfacet;
+ bool may_log = false;
+ bool ok;
+
+ /* Check the rule for consistency. */
+ rule = rule_dpif_lookup(ofproto, &facet->flow, 0);
+ if (!rule) {
+ if (!VLOG_DROP_WARN(&rl)) {
+ char *s = flow_to_string(&facet->flow);
+ VLOG_WARN("%s: facet should not exist", s);
+ free(s);
+ }
+ return false;
+ } else if (rule != facet->rule) {
+ may_log = !VLOG_DROP_WARN(&rl);
+ ok = false;
+ if (may_log) {
+ struct ds s;
+
+ ds_init(&s);
+ flow_format(&s, &facet->flow);
+ ds_put_format(&s, ": facet associated with wrong rule (was "
+ "table=%"PRIu8",", facet->rule->up.table_id);
+ cls_rule_format(&facet->rule->up.cr, &s);
+ ds_put_format(&s, ") (should have been table=%"PRIu8",",
+ rule->up.table_id);
+ cls_rule_format(&rule->up.cr, &s);
+ ds_put_char(&s, ')');
+
+ VLOG_WARN("%s", ds_cstr(&s));
+ ds_destroy(&s);
+ }
+ } else {
+ ok = true;
+ }
+
+ /* Check the datapath actions for consistency. */
+ LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
+ struct action_xlate_ctx ctx;
+ struct ofpbuf *odp_actions;
+ bool actions_changed;
+ bool should_install;
+
+ action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
+ subfacet->initial_tci, rule->up.flow_cookie,
+ NULL);
+ odp_actions = xlate_actions(&ctx, rule->up.actions,
+ rule->up.n_actions);
+
+ should_install = (ctx.may_set_up_flow
+ && subfacet->key_fitness != ODP_FIT_TOO_LITTLE);
+ if (!should_install && !subfacet->installed) {
+ /* The actions for uninstallable flows may vary from one packet to
+ * the next, so don't compare the actions. */
+ goto next;
+ }
+
+ actions_changed = (subfacet->actions_len != odp_actions->size
+ || memcmp(subfacet->actions, odp_actions->data,
+ subfacet->actions_len));
+ if (should_install != subfacet->installed || actions_changed) {
+ if (ok) {
+ may_log = !VLOG_DROP_WARN(&rl);
+ ok = false;
+ }
+
+ if (may_log) {
+ struct odputil_keybuf keybuf;
+ struct ofpbuf key;
+ struct ds s;
+
+ ds_init(&s);
+ subfacet_get_key(subfacet, &keybuf, &key);
+ odp_flow_key_format(key.data, key.size, &s);
+
+ ds_put_cstr(&s, ": inconsistency in subfacet");
+ if (should_install != subfacet->installed) {
+ enum odp_key_fitness fitness = subfacet->key_fitness;
+
+ ds_put_format(&s, " (should%s have been installed)",
+ should_install ? "" : " not");
+ ds_put_format(&s, " (may_set_up_flow=%s, fitness=%s)",
+ ctx.may_set_up_flow ? "true" : "false",
+ odp_key_fitness_to_string(fitness));
+ }
+ if (actions_changed) {
+ ds_put_cstr(&s, " (actions were: ");
+ format_odp_actions(&s, subfacet->actions,
+ subfacet->actions_len);
+ ds_put_cstr(&s, ") (correct actions: ");
+ format_odp_actions(&s, odp_actions->data,
+ odp_actions->size);
+ ds_put_char(&s, ')');
+ } else {
+ ds_put_cstr(&s, " (actions: ");
+ format_odp_actions(&s, subfacet->actions,
+ subfacet->actions_len);
+ ds_put_char(&s, ')');
+ }
+ VLOG_WARN("%s", ds_cstr(&s));
+ ds_destroy(&s);
+ }
+ }
+
+ next:
+ ofpbuf_delete(odp_actions);
+ }
+
+ return ok;
+}
+
+/* Re-searches the classifier for 'facet':
*
* - If the rule found is different from 'facet''s current rule, moves
* 'facet' to the new rule and recompiles its actions.
*
* Returns true if 'facet' still exists, false if it has been destroyed. */
static bool
-facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_revalidate(struct facet *facet)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
struct actions {
struct nlattr *odp_actions;
size_t actions_len;
new_rule = rule_dpif_lookup(ofproto, &facet->flow, 0);
if (!new_rule) {
/* No new rule, so delete the facet. */
- facet_remove(ofproto, facet);
+ facet_remove(facet);
return false;
}
bool should_install;
action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
- subfacet->initial_tci, NULL);
+ subfacet->initial_tci, new_rule->up.flow_cookie,
+ NULL);
odp_actions = xlate_actions(&ctx, new_rule->up.actions,
new_rule->up.n_actions);
actions_changed = (subfacet->actions_len != odp_actions->size
if (should_install) {
struct dpif_flow_stats stats;
- subfacet_install(ofproto, subfacet,
+ subfacet_install(subfacet,
odp_actions->data, odp_actions->size, &stats);
- subfacet_update_stats(ofproto, subfacet, &stats);
+ subfacet_update_stats(subfacet, &stats);
} else {
- subfacet_uninstall(ofproto, subfacet);
+ subfacet_uninstall(subfacet);
}
if (!new_actions) {
i++;
}
if (new_actions) {
- facet_flush_stats(ofproto, facet);
+ facet_flush_stats(facet);
}
/* Update 'facet' now that we've taken care of all the old state. */
/* Updates 'facet''s used time. Caller is responsible for calling
* facet_push_stats() to update the flows which 'facet' resubmits into. */
static void
-facet_update_time(struct ofproto_dpif *ofproto, struct facet *facet,
- long long int used)
+facet_update_time(struct facet *facet, long long int used)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
if (used > facet->used) {
facet->used = used;
if (used > facet->rule->used) {
push.bytes = bytes;
push.used = used;
- action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci, NULL);
+ action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci,
+ rule->up.flow_cookie, NULL);
push.ctx.resubmit_hook = push_resubmit;
ofpbuf_delete(xlate_actions(&push.ctx,
rule->up.actions, rule->up.n_actions));
* which case the caller must populate the actions with
* subfacet_make_actions(). */
static struct subfacet *
-subfacet_create(struct ofproto_dpif *ofproto, struct facet *facet,
- enum odp_key_fitness key_fitness,
+subfacet_create(struct facet *facet, enum odp_key_fitness key_fitness,
const struct nlattr *key, size_t key_len, ovs_be16 initial_tci)
{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
uint32_t key_hash = odp_flow_key_hash(key, key_len);
struct subfacet *subfacet;
/* This shouldn't happen. */
VLOG_ERR_RL(&rl, "subfacet with wrong facet");
- subfacet_destroy(ofproto, subfacet);
+ subfacet_destroy(subfacet);
}
subfacet = xzalloc(sizeof *subfacet);
/* Uninstalls 'subfacet' from the datapath, if it is installed, removes it from
* its facet within 'ofproto', and frees it. */
static void
-subfacet_destroy__(struct ofproto_dpif *ofproto, struct subfacet *subfacet)
+subfacet_destroy__(struct subfacet *subfacet)
{
- subfacet_uninstall(ofproto, subfacet);
+ struct facet *facet = subfacet->facet;
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
+
+ subfacet_uninstall(subfacet);
hmap_remove(&ofproto->subfacets, &subfacet->hmap_node);
list_remove(&subfacet->list_node);
free(subfacet->key);
/* Destroys 'subfacet', as with subfacet_destroy__(), and then if this was the
* last remaining subfacet in its facet destroys the facet too. */
static void
-subfacet_destroy(struct ofproto_dpif *ofproto, struct subfacet *subfacet)
+subfacet_destroy(struct subfacet *subfacet)
{
struct facet *facet = subfacet->facet;
if (list_is_singleton(&facet->subfacets)) {
/* facet_remove() needs at least one subfacet (it will remove it). */
- facet_remove(ofproto, facet);
+ facet_remove(facet);
} else {
- subfacet_destroy__(ofproto, subfacet);
+ subfacet_destroy__(subfacet);
}
}
/* Composes the datapath actions for 'subfacet' based on its rule's actions. */
static void
-subfacet_make_actions(struct ofproto_dpif *p, struct subfacet *subfacet,
- const struct ofpbuf *packet)
+subfacet_make_actions(struct subfacet *subfacet, const struct ofpbuf *packet)
{
struct facet *facet = subfacet->facet;
const struct rule_dpif *rule = facet->rule;
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
struct ofpbuf *odp_actions;
struct action_xlate_ctx ctx;
- action_xlate_ctx_init(&ctx, p, &facet->flow, subfacet->initial_tci,
- packet);
+ action_xlate_ctx_init(&ctx, ofproto, &facet->flow, subfacet->initial_tci,
+ rule->up.flow_cookie, packet);
odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
facet->tags = ctx.tags;
facet->may_install = ctx.may_set_up_flow;
*
* Returns 0 if successful, otherwise a positive errno value. */
static int
-subfacet_install(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
+subfacet_install(struct subfacet *subfacet,
const struct nlattr *actions, size_t actions_len,
struct dpif_flow_stats *stats)
{
+ struct facet *facet = subfacet->facet;
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
struct odputil_keybuf keybuf;
enum dpif_flow_put_flags flags;
struct ofpbuf key;
/* If 'subfacet' is installed in the datapath, uninstalls it. */
static void
-subfacet_uninstall(struct ofproto_dpif *p, struct subfacet *subfacet)
+subfacet_uninstall(struct subfacet *subfacet)
{
if (subfacet->installed) {
+ struct rule_dpif *rule = subfacet->facet->rule;
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
struct odputil_keybuf keybuf;
struct dpif_flow_stats stats;
struct ofpbuf key;
int error;
subfacet_get_key(subfacet, &keybuf, &key);
- error = dpif_flow_del(p->dpif, key.data, key.size, &stats);
+ error = dpif_flow_del(ofproto->dpif, key.data, key.size, &stats);
subfacet_reset_dp_stats(subfacet, &stats);
if (!error) {
- subfacet_update_stats(p, subfacet, &stats);
+ subfacet_update_stats(subfacet, &stats);
}
subfacet->installed = false;
} else {
/* Updates 'subfacet''s used time. The caller is responsible for calling
* facet_push_stats() to update the flows which 'subfacet' resubmits into. */
static void
-subfacet_update_time(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
- long long int used)
+subfacet_update_time(struct subfacet *subfacet, long long int used)
{
if (used > subfacet->used) {
subfacet->used = used;
- facet_update_time(ofproto, subfacet->facet, used);
+ facet_update_time(subfacet->facet, used);
}
}
* represents a packet that was sent by hand or if it represents statistics
* that have been cleared out of the datapath. */
static void
-subfacet_update_stats(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
+subfacet_update_stats(struct subfacet *subfacet,
const struct dpif_flow_stats *stats)
{
if (stats->n_packets || stats->used > subfacet->used) {
struct facet *facet = subfacet->facet;
- subfacet_update_time(ofproto, subfacet, stats->used);
+ subfacet_update_time(subfacet, stats->used);
facet->packet_count += stats->n_packets;
facet->byte_count += stats->n_bytes;
facet_push_stats(facet);
free(rule);
}
-static int
+static enum ofperr
rule_construct(struct rule *rule_)
{
struct rule_dpif *rule = rule_dpif_cast(rule_);
struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
struct rule_dpif *victim;
uint8_t table_id;
- int error;
+ enum ofperr error;
error = validate_actions(rule->up.actions, rule->up.n_actions,
&rule->up.cr.flow, ofproto->max_ports);
rule_destruct(struct rule *rule_)
{
struct rule_dpif *rule = rule_dpif_cast(rule_);
- struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
struct facet *facet, *next_facet;
LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
- facet_revalidate(ofproto, facet);
+ facet_revalidate(facet);
}
complete_operation(rule);
}
}
-static int
+static enum ofperr
rule_execute(struct rule *rule_, const struct flow *flow,
struct ofpbuf *packet)
{
struct ofpbuf *odp_actions;
size_t size;
- action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci, packet);
+ action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci,
+ rule->up.flow_cookie, packet);
odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
size = packet->size;
if (execute_odp_actions(ofproto, flow, odp_actions->data,
{
struct rule_dpif *rule = rule_dpif_cast(rule_);
struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
- int error;
+ enum ofperr error;
error = validate_actions(rule->up.actions, rule->up.n_actions,
&rule->up.cr.flow, ofproto->max_ports);
}
if (rule) {
+ ovs_be64 old_cookie = ctx->cookie;
+
ctx->recurse++;
+ ctx->cookie = rule->up.flow_cookie;
do_xlate_actions(rule->up.actions, rule->up.n_actions, ctx);
+ ctx->cookie = old_cookie;
ctx->recurse--;
}
}
static void
-compose_controller_action(struct action_xlate_ctx *ctx, int len)
+execute_controller_action(struct action_xlate_ctx *ctx, int len,
+ enum ofp_packet_in_reason reason)
{
- struct user_action_cookie cookie;
+ struct ofputil_packet_in pin;
+ struct ofpbuf *packet;
- commit_odp_actions(&ctx->flow, &ctx->base_flow, ctx->odp_actions);
- cookie.type = USER_ACTION_COOKIE_CONTROLLER;
- cookie.data = len;
- cookie.n_output = 0;
- cookie.vlan_tci = 0;
- put_userspace_action(ctx->ofproto, ctx->odp_actions, &ctx->flow, &cookie);
+ ctx->may_set_up_flow = false;
+ if (!ctx->packet) {
+ return;
+ }
+
+ packet = ofpbuf_clone(ctx->packet);
+
+ if (packet->l2 && packet->l3) {
+ struct eth_header *eh;
+
+ eth_pop_vlan(packet);
+ eh = packet->l2;
+ assert(eh->eth_type == ctx->flow.dl_type);
+ memcpy(eh->eth_src, ctx->flow.dl_src, sizeof eh->eth_src);
+ memcpy(eh->eth_dst, ctx->flow.dl_dst, sizeof eh->eth_dst);
+
+ if (ctx->flow.vlan_tci & htons(VLAN_CFI)) {
+ eth_push_vlan(packet, ctx->flow.vlan_tci);
+ }
+
+ if (packet->l4) {
+ if (ctx->flow.dl_type == htons(ETH_TYPE_IP)) {
+ packet_set_ipv4(packet, ctx->flow.nw_src, ctx->flow.nw_dst,
+ ctx->flow.nw_tos, ctx->flow.nw_ttl);
+ }
+
+ if (packet->l7) {
+ if (ctx->flow.nw_proto == IPPROTO_TCP) {
+ packet_set_tcp_port(packet, ctx->flow.tp_src,
+ ctx->flow.tp_dst);
+ } else if (ctx->flow.nw_proto == IPPROTO_UDP) {
+ packet_set_udp_port(packet, ctx->flow.tp_src,
+ ctx->flow.tp_dst);
+ }
+ }
+ }
+ }
+
+ pin.packet = packet->data;
+ pin.packet_len = packet->size;
+ pin.reason = reason;
+ pin.table_id = ctx->table_id;
+ pin.cookie = ctx->cookie;
+
+ pin.buffer_id = 0;
+ pin.send_len = len;
+ pin.total_len = packet->size;
+ flow_get_metadata(&ctx->flow, &pin.fmd);
+
+ connmgr_send_packet_in(ctx->ofproto->up.connmgr, &pin, &ctx->flow);
+ ofpbuf_delete(packet);
+}
+
+static bool
+compose_dec_ttl(struct action_xlate_ctx *ctx)
+{
+ if (ctx->flow.dl_type != htons(ETH_TYPE_IP) &&
+ ctx->flow.dl_type != htons(ETH_TYPE_IPV6)) {
+ return false;
+ }
+
+ if (ctx->flow.nw_ttl > 1) {
+ ctx->flow.nw_ttl--;
+ return false;
+ } else {
+ execute_controller_action(ctx, UINT16_MAX, OFPR_INVALID_TTL);
+
+ /* Stop processing for current table. */
+ return true;
+ }
}
static void
flood_packets(ctx, true);
break;
case OFPP_CONTROLLER:
- compose_controller_action(ctx, max_len);
+ execute_controller_action(ctx, max_len, OFPR_ACTION);
break;
case OFPP_LOCAL:
compose_output_action(ctx, OFPP_LOCAL);
xlate_output_reg_action(struct action_xlate_ctx *ctx,
const struct nx_action_output_reg *naor)
{
+ struct mf_subfield src;
uint64_t ofp_port;
- ofp_port = nxm_read_field_bits(naor->src, naor->ofs_nbits, &ctx->flow);
+ nxm_decode(&src, naor->src, naor->ofs_nbits);
+ ofp_port = mf_get_subfield(&src, &ctx->flow);
if (ofp_port <= UINT16_MAX) {
xlate_output_action__(ctx, ofp_port, ntohs(naor->max_len));
error = ofproto_flow_mod(&ctx->ofproto->up, &fm);
if (error && !VLOG_DROP_WARN(&rl)) {
- char *msg = ofputil_error_to_string(error);
- VLOG_WARN("learning action failed to modify flow table (%s)", msg);
- free(msg);
+ VLOG_WARN("learning action failed to modify flow table (%s)",
+ ofperr_get_name(error));
}
free(fm.actions);
break;
case OFPUTIL_OFPAT_SET_NW_TOS:
- ctx->flow.nw_tos &= ~IP_DSCP_MASK;
- ctx->flow.nw_tos |= ia->nw_tos.nw_tos & IP_DSCP_MASK;
+ /* OpenFlow 1.0 only supports IPv4. */
+ if (ctx->flow.dl_type == htons(ETH_TYPE_IP)) {
+ ctx->flow.nw_tos &= ~IP_DSCP_MASK;
+ ctx->flow.nw_tos |= ia->nw_tos.nw_tos & IP_DSCP_MASK;
+ }
break;
case OFPUTIL_OFPAT_SET_TP_SRC:
}
break;
+ case OFPUTIL_NXAST_DEC_TTL:
+ if (compose_dec_ttl(ctx)) {
+ goto out;
+ }
+ break;
+
case OFPUTIL_NXAST_EXIT:
ctx->exit = true;
break;
}
}
+out:
/* We've let OFPP_NORMAL and the learning action look at the packet,
* so drop it now if forwarding is disabled. */
if (port && !stp_forward_in_state(port->stp_state)) {
static void
action_xlate_ctx_init(struct action_xlate_ctx *ctx,
struct ofproto_dpif *ofproto, const struct flow *flow,
- ovs_be16 initial_tci, const struct ofpbuf *packet)
+ ovs_be16 initial_tci, ovs_be64 cookie,
+ const struct ofpbuf *packet)
{
ctx->ofproto = ofproto;
ctx->flow = *flow;
ctx->base_flow = ctx->flow;
ctx->base_flow.tun_id = 0;
ctx->base_flow.vlan_tci = initial_tci;
+ ctx->cookie = cookie;
ctx->packet = packet;
ctx->may_learn = packet != NULL;
ctx->resubmit_hook = NULL;
case OFPC_FRAG_NX_MATCH:
/* Nothing to do. */
break;
+
+ case OFPC_INVALID_TTL_TO_CONTROLLER:
+ NOT_REACHED();
}
}
}
}
-static int
+static enum ofperr
packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
const struct flow *flow,
const union ofp_action *ofp_actions, size_t n_ofp_actions)
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
- int error;
+ enum ofperr error;
if (flow->in_port >= ofproto->max_ports && flow->in_port < OFPP_MAX) {
- return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_IN_PORT);
+ return OFPERR_NXBRC_BAD_IN_PORT;
}
error = validate_actions(ofp_actions, n_ofp_actions, flow,
ofproto->max_ports);
if (!error) {
struct odputil_keybuf keybuf;
- struct action_xlate_ctx ctx;
struct ofpbuf *odp_actions;
+ struct ofproto_push push;
struct ofpbuf key;
ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
odp_flow_key_from_flow(&key, flow);
- action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci, packet);
- odp_actions = xlate_actions(&ctx, ofp_actions, n_ofp_actions);
+ action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci, 0,
+ packet);
+
+ /* Ensure that resubmits in 'ofp_actions' get accounted to their
+ * matching rules. */
+ push.packets = 1;
+ push.bytes = packet->size;
+ push.used = time_msec();
+ push.ctx.resubmit_hook = push_resubmit;
+
+ odp_actions = xlate_actions(&push.ctx, ofp_actions, n_ofp_actions);
dpif_execute(ofproto->dpif, key.data, key.size,
odp_actions->data, odp_actions->size, packet);
ofpbuf_delete(odp_actions);
if (subfacet->installed) {
struct dpif_flow_stats stats;
- subfacet_install(ofproto, subfacet, subfacet->actions,
+ subfacet_install(subfacet, subfacet->actions,
subfacet->actions_len, &stats);
- subfacet_update_stats(ofproto, subfacet, &stats);
+ subfacet_update_stats(subfacet, &stats);
}
}
}
static void
-ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc OVS_UNUSED,
+ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
const char *argv[], void *aux OVS_UNUSED)
{
- const struct ofproto_dpif *ofproto;
+ struct ofproto_dpif *ofproto;
- ofproto = ofproto_dpif_lookup(argv[1]);
- if (!ofproto) {
- unixctl_command_reply(conn, 501, "no such bridge");
- return;
+ if (argc > 1) {
+ ofproto = ofproto_dpif_lookup(argv[1]);
+ if (!ofproto) {
+ unixctl_command_reply(conn, 501, "no such bridge");
+ return;
+ }
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+ } else {
+ HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+ mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+ }
}
- mac_learning_flush(ofproto->ml);
unixctl_command_reply(conn, 200, "table successfully flushed");
}
trace.result = &result;
trace.flow = flow;
- action_xlate_ctx_init(&trace.ctx, ofproto, &flow, initial_tci, packet);
+ action_xlate_ctx_init(&trace.ctx, ofproto, &flow, initial_tci,
+ rule->up.flow_cookie, packet);
trace.ctx.resubmit_hook = trace_resubmit;
odp_actions = xlate_actions(&trace.ctx,
rule->up.actions, rule->up.n_actions);
unixctl_command_reply(conn, 200, NULL);
}
+/* Runs a self-check of flow translations in 'ofproto'. Appends a message to
+ * 'reply' describing the results. */
+static void
+ofproto_dpif_self_check__(struct ofproto_dpif *ofproto, struct ds *reply)
+{
+ struct facet *facet;
+ int errors;
+
+ errors = 0;
+ HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
+ if (!facet_check_consistency(facet)) {
+ errors++;
+ }
+ }
+ if (errors) {
+ ofproto->need_revalidate = true;
+ }
+
+ if (errors) {
+ ds_put_format(reply, "%s: self-check failed (%d errors)\n",
+ ofproto->up.name, errors);
+ } else {
+ ds_put_format(reply, "%s: self-check passed\n", ofproto->up.name);
+ }
+}
+
+static void
+ofproto_dpif_self_check(struct unixctl_conn *conn,
+ int argc, const char *argv[], void *aux OVS_UNUSED)
+{
+ struct ds reply = DS_EMPTY_INITIALIZER;
+ struct ofproto_dpif *ofproto;
+
+ if (argc > 1) {
+ ofproto = ofproto_dpif_lookup(argv[1]);
+ if (!ofproto) {
+ unixctl_command_reply(conn, 501, "Unknown ofproto (use "
+ "ofproto/list for help)");
+ return;
+ }
+ ofproto_dpif_self_check__(ofproto, &reply);
+ } else {
+ HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+ ofproto_dpif_self_check__(ofproto, &reply);
+ }
+ }
+
+ unixctl_command_reply(conn, 200, ds_cstr(&reply));
+ ds_destroy(&reply);
+}
+
static void
ofproto_dpif_unixctl_init(void)
{
unixctl_command_register(
"ofproto/trace",
"bridge {tun_id in_port packet | odp_flow [-generate]}",
- 2, 4, ofproto_unixctl_trace, NULL);
- unixctl_command_register("fdb/flush", "bridge", 1, 1,
+ 2, 5, ofproto_unixctl_trace, NULL);
+ unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
ofproto_unixctl_fdb_flush, NULL);
unixctl_command_register("fdb/show", "bridge", 1, 1,
ofproto_unixctl_fdb_show, NULL);
ofproto_dpif_clog, NULL);
unixctl_command_register("ofproto/unclog", "", 0, 0,
ofproto_dpif_unclog, NULL);
+ unixctl_command_register("ofproto/self-check", "[bridge]", 0, 1,
+ ofproto_dpif_self_check, NULL);
}
\f
/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)