#include "lacp.h"
#include "learn.h"
#include "mac-learning.h"
+#include "meta-flow.h"
#include "multipath.h"
#include "netdev.h"
#include "netlink.h"
struct rule_dpif {
struct rule up;
- long long int used; /* Time last used; time created if not used. */
-
/* These statistics:
*
* - Do include packets and bytes from facets that have been deleted or
static struct rule_dpif *rule_dpif_lookup(struct ofproto_dpif *,
const struct flow *, uint8_t table);
-static void flow_push_stats(const struct rule_dpif *, const struct flow *,
+static void flow_push_stats(struct rule_dpif *, const struct flow *,
uint64_t packets, uint64_t bytes,
long long int used);
static void stp_run(struct ofproto_dpif *ofproto);
static void stp_wait(struct ofproto_dpif *ofproto);
+static int set_stp_port(struct ofport *,
+ const struct ofproto_port_stp_settings *);
static bool ofbundle_includes_vlan(const struct ofbundle *, uint16_t vlan);
* we are just revalidating. */
bool may_learn;
- /* Cookie of the currently matching rule, or 0. */
- ovs_be64 cookie;
+ /* The rule that we are currently translating, or NULL. */
+ struct rule_dpif *rule;
+
+ /* Union of the set of TCP flags seen so far in this flow. (Used only by
+ * NXAST_FIN_TIMEOUT. Set to zero to avoid updating updating rules'
+ * timeouts.) */
+ uint8_t tcp_flags;
/* If nonnull, called just before executing a resubmit action.
*
* be reassessed for every packet. */
bool has_learn; /* Actions include NXAST_LEARN? */
bool has_normal; /* Actions output to OFPP_NORMAL? */
+ bool has_fin_timeout; /* Actions include NXAST_FIN_TIMEOUT? */
uint16_t nf_output_iface; /* Output interface index for NetFlow. */
mirror_mask_t mirrors; /* Bitmap of associated mirrors. */
static void action_xlate_ctx_init(struct action_xlate_ctx *,
struct ofproto_dpif *, const struct flow *,
- ovs_be16 initial_tci, ovs_be64 cookie,
- const struct ofpbuf *);
+ ovs_be16 initial_tci, struct rule_dpif *,
+ uint8_t tcp_flags, const struct ofpbuf *);
static struct ofpbuf *xlate_actions(struct action_xlate_ctx *,
const union ofp_action *in, size_t n_in);
/* Accounting. */
uint64_t accounted_bytes; /* Bytes processed by facet_account(). */
struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
+ uint8_t tcp_flags; /* TCP flags seen for this 'rule'. */
/* Properties of datapath actions.
*
bool may_install; /* Reassess actions for every packet? */
bool has_learn; /* Actions include NXAST_LEARN? */
bool has_normal; /* Actions output to OFPP_NORMAL? */
+ bool has_fin_timeout; /* Actions include NXAST_FIN_TIMEOUT? */
tag_type tags; /* Tags that would require revalidation. */
mirror_mask_t mirrors; /* Bitmap of dependent mirrors. */
};
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 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;
}
static int
-construct(struct ofproto *ofproto_, int *n_tablesp)
+construct(struct ofproto *ofproto_)
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
const char *name = ofproto->up.name;
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);
ofproto->sflow = NULL;
ofproto->stp = NULL;
hmap_init(&ofproto->bundles);
- ofproto->ml = mac_learning_create();
+ ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME);
for (i = 0; i < MAX_MIRRORS; i++) {
ofproto->mirrors[i] = NULL;
}
hmap_insert(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node,
hash_string(ofproto->up.name, 0));
-
- *n_tablesp = N_TABLES;
memset(&ofproto->stats, 0, sizeof ofproto->stats);
+
+ ofproto_init_tables(ofproto_, N_TABLES);
+
return 0;
}
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
struct rule_dpif *rule, *next_rule;
- struct classifier *table;
+ struct oftable *table;
int i;
hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
struct cls_cursor cursor;
- cls_cursor_init(&cursor, table, NULL);
+ cls_cursor_init(&cursor, &table->cls, NULL);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
ofproto_rule_destroy(&rule->up);
}
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);
}
stp_set_max_age(ofproto->stp, s->max_age);
stp_set_forward_delay(ofproto->stp, s->fwd_delay);
} else {
+ struct ofport *ofport;
+
+ HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
+ set_stp_port(ofport, NULL);
+ }
+
stp_destroy(ofproto->stp);
ofproto->stp = NULL;
}
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;
}
/* Revalidate cached flows whenever forward_bpdu option changes. */
ofproto->need_revalidate = true;
}
+
+static void
+set_mac_idle_time(struct ofproto *ofproto_, unsigned int idle_time)
+{
+ struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
+ mac_learning_set_idle_time(ofproto->ml, idle_time);
+}
\f
/* Ports. */
};
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.controller_id = 0;
pin.table_id = 0;
pin.cookie = 0;
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);
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);
}
dpif_flow_stats_extract(&facet->flow, packet, &stats);
- subfacet_update_stats(ofproto, subfacet, &stats);
+ subfacet_update_stats(subfacet, &stats);
+
+ if (!subfacet->actions_len) {
+ /* No actions to execute, so skip talking to the dpif. */
+ continue;
+ }
if (flow->vlan_tci != subfacet->initial_tci) {
/* This packet was received on a VLAN splinter port. We added
}
op = &ops[(*n_ops)++];
- execute = &op->dpif_op.execute;
+ execute = &op->dpif_op.u.execute;
op->subfacet = subfacet;
- execute->type = DPIF_OP_EXECUTE;
+ op->dpif_op.type = DPIF_OP_EXECUTE;
execute->key = miss->key;
execute->key_len = miss->key_len;
execute->actions = (facet->may_install
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
expire(struct ofproto_dpif *ofproto)
{
struct rule_dpif *rule, *next_rule;
- struct classifier *table;
+ struct oftable *table;
int dp_max_idle;
/* Update stats for each flow in the datapath. */
OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
struct cls_cursor cursor;
- cls_cursor_init(&cursor, table, NULL);
+ cls_cursor_init(&cursor, &table->cls, NULL);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
rule_expire(rule);
}
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);
+ facet->tcp_flags |= stats->tcp_flags;
+
+ 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;
if (rule->up.hard_timeout
&& now > rule->up.modified + rule->up.hard_timeout * 1000) {
reason = OFPRR_HARD_TIMEOUT;
- } else if (rule->up.idle_timeout && list_is_empty(&rule->facets)
- && now > rule->used + rule->up.idle_timeout * 1000) {
+ } else if (rule->up.idle_timeout
+ && now > rule->up.used + rule->up.idle_timeout * 1000) {
reason = OFPRR_IDLE_TIMEOUT;
} else {
return;
/* 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. */
* - 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;
/* Feed information from the active flows back into the learning table to
* ensure that table is always in sync with what is actually flowing
* through the datapath. */
- if (facet->has_learn || facet->has_normal) {
+ if (facet->has_learn || facet->has_normal
+ || (facet->has_fin_timeout
+ && facet->tcp_flags & (TCP_FIN | TCP_RST))) {
struct action_xlate_ctx ctx;
action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
facet->flow.vlan_tci,
- facet->rule->up.flow_cookie, NULL);
+ facet->rule, facet->tcp_flags, 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;
facet_reset_counters(facet);
netflow_flow_clear(&facet->nf_flow);
+ facet->tcp_flags = 0;
}
/* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
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, 0, 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, new_rule->up.flow_cookie,
- NULL);
+ subfacet->initial_tci, new_rule, 0, 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. */
facet->may_install = ctx.may_set_up_flow;
facet->has_learn = ctx.has_learn;
facet->has_normal = ctx.has_normal;
+ facet->has_fin_timeout = ctx.has_fin_timeout;
facet->mirrors = ctx.mirrors;
if (new_actions) {
i = 0;
/* 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) {
- facet->rule->used = used;
- }
+ ofproto_rule_update_used(&facet->rule->up, used);
netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, used);
}
}
if (rule) {
rule->packet_count += push->packets;
rule->byte_count += push->bytes;
- rule->used = MAX(push->used, rule->used);
+ ofproto_rule_update_used(&rule->up, push->used);
}
}
/* Pushes flow statistics to the rules which 'flow' resubmits into given
* 'rule''s actions and mirrors. */
static void
-flow_push_stats(const struct rule_dpif *rule,
+flow_push_stats(struct rule_dpif *rule,
const struct flow *flow, uint64_t packets, uint64_t bytes,
long long int used)
{
push.bytes = bytes;
push.used = used;
- action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci,
- rule->up.flow_cookie, NULL);
+ ofproto_rule_update_used(&rule->up, used);
+
+ action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci, rule,
+ 0, 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 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,
- rule->up.flow_cookie, packet);
+ action_xlate_ctx_init(&ctx, ofproto, &facet->flow, subfacet->initial_tci,
+ rule, 0, 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;
facet->has_learn = ctx.has_learn;
facet->has_normal = ctx.has_normal;
+ facet->has_fin_timeout = ctx.has_fin_timeout;
facet->nf_flow.output_iface = ctx.nf_output_iface;
facet->mirrors = ctx.mirrors;
*
* 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->tcp_flags |= stats->tcp_flags;
facet_push_stats(facet);
netflow_flow_update_flags(&facet->nf_flow, stats->tcp_flags);
}
return NULL;
}
- cls = &ofproto->up.tables[table_id];
+ cls = &ofproto->up.tables[table_id].cls;
if (flow->nw_frag & FLOW_NW_FRAG_ANY
&& ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
/* For OFPC_NORMAL frag_handling, we must pretend that transport ports
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);
return error;
}
- rule->used = rule->up.created;
rule->packet_count = 0;
rule->byte_count = 0;
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)
{
size_t size;
action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci,
- rule->up.flow_cookie, packet);
+ rule, packet_get_tcp_flags(packet, flow), 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,
odp_actions->size, packet)) {
- rule->used = time_msec();
rule->packet_count++;
rule->byte_count += size;
- flow_push_stats(rule, flow, 1, size, rule->used);
+ flow_push_stats(rule, flow, 1, size, time_msec());
}
ofpbuf_delete(odp_actions);
{
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;
+ struct rule_dpif *old_rule = ctx->rule;
ctx->recurse++;
- ctx->cookie = rule->up.flow_cookie;
+ ctx->rule = rule;
do_xlate_actions(rule->up.actions, rule->up.n_actions, ctx);
- ctx->cookie = old_cookie;
+ ctx->rule = old_rule;
ctx->recurse--;
}
}
static void
-execute_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,
+ uint16_t controller_id)
{
struct ofputil_packet_in pin;
struct ofpbuf *packet;
pin.packet = packet->data;
pin.packet_len = packet->size;
- pin.reason = OFPR_ACTION;
+ pin.reason = reason;
+ pin.controller_id = controller_id;
pin.table_id = ctx->table_id;
- pin.cookie = ctx->cookie;
+ pin.cookie = ctx->rule ? ctx->rule->up.flow_cookie : 0;
pin.buffer_id = 0;
pin.send_len = len;
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, 0);
+
+ /* Stop processing for current table. */
+ return true;
+ }
+}
+
static void
xlate_output_action__(struct action_xlate_ctx *ctx,
uint16_t port, uint16_t max_len)
flood_packets(ctx, true);
break;
case OFPP_CONTROLLER:
- execute_controller_action(ctx, max_len);
- break;
- case OFPP_LOCAL:
- compose_output_action(ctx, OFPP_LOCAL);
+ execute_controller_action(ctx, max_len, OFPR_ACTION, 0);
break;
case OFPP_NONE:
break;
+ case OFPP_LOCAL:
default:
if (port != ctx->flow.in_port) {
compose_output_action(ctx, port);
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);
}
+/* Reduces '*timeout' to no more than 'max'. A value of zero in either case
+ * means "infinite". */
+static void
+reduce_timeout(uint16_t max, uint16_t *timeout)
+{
+ if (max && (!*timeout || *timeout > max)) {
+ *timeout = max;
+ }
+}
+
+static void
+xlate_fin_timeout(struct action_xlate_ctx *ctx,
+ const struct nx_action_fin_timeout *naft)
+{
+ if (ctx->tcp_flags & (TCP_FIN | TCP_RST) && ctx->rule) {
+ struct rule_dpif *rule = ctx->rule;
+
+ reduce_timeout(ntohs(naft->fin_idle_timeout), &rule->up.idle_timeout);
+ reduce_timeout(ntohs(naft->fin_hard_timeout), &rule->up.hard_timeout);
+ }
+}
+
static bool
may_receive(const struct ofport_dpif *port, struct action_xlate_ctx *ctx)
{
{
const struct ofport_dpif *port;
const union ofp_action *ia;
+ bool was_evictable = true;
size_t left;
port = get_ofp_port(ctx->ofproto, ctx->flow.in_port);
return;
}
+ if (ctx->rule) {
+ /* Don't let the rule we're working on get evicted underneath us. */
+ was_evictable = ctx->rule->up.evictable;
+ ctx->rule->up.evictable = false;
+ }
OFPUTIL_ACTION_FOR_EACH_UNSAFE (ia, left, in, n_in) {
const struct ofp_action_dl_addr *oada;
const struct nx_action_resubmit *nar;
const struct nx_action_autopath *naa;
const struct nx_action_bundle *nab;
const struct nx_action_output_reg *naor;
+ const struct nx_action_controller *nac;
enum ofputil_action_code code;
ovs_be64 tun_id;
}
break;
+ case OFPUTIL_NXAST_DEC_TTL:
+ if (compose_dec_ttl(ctx)) {
+ goto out;
+ }
+ break;
+
case OFPUTIL_NXAST_EXIT:
ctx->exit = true;
break;
+
+ case OFPUTIL_NXAST_FIN_TIMEOUT:
+ ctx->has_fin_timeout = true;
+ xlate_fin_timeout(ctx, (const struct nx_action_fin_timeout *) ia);
+ break;
+
+ case OFPUTIL_NXAST_CONTROLLER:
+ nac = (const struct nx_action_controller *) ia;
+ execute_controller_action(ctx, ntohs(nac->max_len), nac->reason,
+ ntohs(nac->controller_id));
+ 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)) {
ofpbuf_clear(ctx->odp_actions);
add_sflow_action(ctx);
}
+ if (ctx->rule) {
+ ctx->rule->up.evictable = was_evictable;
+ }
}
static void
action_xlate_ctx_init(struct action_xlate_ctx *ctx,
struct ofproto_dpif *ofproto, const struct flow *flow,
- ovs_be16 initial_tci, ovs_be64 cookie,
- const struct ofpbuf *packet)
+ ovs_be16 initial_tci, struct rule_dpif *rule,
+ uint8_t tcp_flags, 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->rule = rule;
ctx->packet = packet;
ctx->may_learn = packet != NULL;
+ ctx->tcp_flags = tcp_flags;
ctx->resubmit_hook = NULL;
}
ctx->may_set_up_flow = true;
ctx->has_learn = false;
ctx->has_normal = false;
+ ctx->has_fin_timeout = false;
ctx->nf_output_iface = NF_OUT_DROP;
ctx->mirrors = 0;
ctx->recurse = 0;
case OFPC_FRAG_NX_MATCH:
/* Nothing to do. */
break;
+
+ case OFPC_INVALID_TTL_TO_CONTROLLER:
+ NOT_REACHED();
}
}
table_update_taggable(struct ofproto_dpif *ofproto, uint8_t table_id)
{
struct table_dpif *table = &ofproto->tables[table_id];
- const struct classifier *cls = &ofproto->up.tables[table_id];
+ const struct oftable *oftable = &ofproto->up.tables[table_id];
struct cls_table *catchall, *other;
struct cls_table *t;
catchall = other = NULL;
- switch (hmap_count(&cls->tables)) {
+ switch (hmap_count(&oftable->cls.tables)) {
case 0:
/* We could tag this OpenFlow table but it would make the logic a
* little harder and it's a corner case that doesn't seem worth it
case 1:
case 2:
- HMAP_FOR_EACH (t, hmap_node, &cls->tables) {
+ HMAP_FOR_EACH (t, hmap_node, &oftable->cls.tables) {
if (cls_table_is_catchall(t)) {
catchall = t;
} else if (!other) {
}
}
-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,
ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
odp_flow_key_from_flow(&key, flow);
- action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci, 0,
- packet);
+ action_xlate_ctx_init(&push.ctx, ofproto, flow, flow->vlan_tci, NULL,
+ packet_get_tcp_flags(packet, flow), packet);
/* Ensure that resubmits in 'ofp_actions' get accounted to their
* matching rules. */
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");
}
struct ofbundle *bundle = e->port.p;
ds_put_format(&ds, "%5d %4d "ETH_ADDR_FMT" %3d\n",
ofbundle_get_a_port(bundle)->odp_port,
- e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
+ e->vlan, ETH_ADDR_ARGS(e->mac),
+ mac_entry_age(ofproto->ml, e));
}
unixctl_command_reply(conn, 200, ds_cstr(&ds));
ds_destroy(&ds);
ds_put_char(result, '\n');
}
+static void
+trace_format_odp(struct ds *result, int level, const char *title,
+ struct ofproto_trace *trace)
+{
+ struct ofpbuf *odp_actions = trace->ctx.odp_actions;
+
+ ds_put_char_multiple(result, '\t', level);
+ ds_put_format(result, "%s: ", title);
+ format_odp_actions(result, odp_actions->data, odp_actions->size);
+ ds_put_char(result, '\n');
+}
+
static void
trace_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
{
ds_put_char(result, '\n');
trace_format_flow(result, ctx->recurse + 1, "Resubmitted flow", trace);
trace_format_regs(result, ctx->recurse + 1, "Resubmitted regs", trace);
+ trace_format_odp(result, ctx->recurse + 1, "Resubmitted odp", trace);
trace_format_rule(result, ctx->table_id, ctx->recurse + 1, rule);
}
if (rule) {
struct ofproto_trace trace;
struct ofpbuf *odp_actions;
+ uint8_t tcp_flags;
+ tcp_flags = packet ? packet_get_tcp_flags(packet, &flow) : 0;
trace.result = &result;
trace.flow = flow;
action_xlate_ctx_init(&trace.ctx, ofproto, &flow, initial_tci,
- rule->up.flow_cookie, packet);
+ rule, tcp_flags, 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.)
set_flood_vlans,
is_mirror_output_bundle,
forward_bpdu_changed,
+ set_mac_idle_time,
set_realdev,
};
git://git.onelab.eu / sliver-openvswitch.git / blobdiff