* calling action_xlate_ctx_init(). */
void (*resubmit_hook)(struct action_xlate_ctx *, struct rule_dpif *rule);
+ /* If nonnull, flow translation calls this function to report some
+ * significant decision, e.g. to explain why OFPP_NORMAL translation
+ * dropped a packet. */
+ void (*report_hook)(struct action_xlate_ctx *, const char *s);
+
/* If nonnull, flow translation credits the specified statistics to each
* rule reached through a resubmit or OFPP_TABLE action.
*
const struct nlattr **actionsp,
size_t *actions_lenp);
+static void xlate_report(struct action_xlate_ctx *ctx, const char *s);
+
/* A subfacet (see "struct subfacet" below) has three possible installation
* states:
*
}
static void
-get_tables(struct ofproto *ofproto_, struct ofp_table_stats *ots)
+get_tables(struct ofproto *ofproto_, struct ofp10_table_stats *ots)
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
struct dpif_dp_stats s;
break;
case PORT_VLAN_TRUNK:
- trunks = (unsigned long *) s->trunks;
+ trunks = CONST_CAST(unsigned long *, s->trunks);
break;
case PORT_VLAN_NATIVE_UNTAGGED:
bitmap_set1(trunks, vlan);
bitmap_set0(trunks, 0);
} else {
- trunks = (unsigned long *) s->trunks;
+ trunks = CONST_CAST(unsigned long *, s->trunks);
}
break;
port_run_fast(ofport);
if (ofport->cfm) {
+ int cfm_opup = cfm_get_opup(ofport->cfm);
+
cfm_run(ofport->cfm);
- enable = enable && !cfm_get_fault(ofport->cfm)
- && cfm_get_opup(ofport->cfm);
+ enable = enable && !cfm_get_fault(ofport->cfm);
+
+ if (cfm_opup >= 0) {
+ enable = enable && cfm_opup;
+ }
}
if (ofport->bundle) {
port_add(struct ofproto *ofproto_, struct netdev *netdev, uint16_t *ofp_portp)
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
- uint16_t odp_port;
+ uint16_t odp_port = UINT16_MAX;
int error;
error = dpif_port_add(ofproto->dpif, netdev, &odp_port);
long long int now;
uint8_t reason;
+ if (rule->up.pending) {
+ /* We'll have to expire it later. */
+ return;
+ }
+
/* Has 'rule' expired? */
now = time_msec();
if (rule->up.hard_timeout
struct flow flow;
int error;
- flow_extract((struct ofpbuf *) packet, 0, 0, 0, &flow);
+ flow_extract(packet, 0, 0, 0, &flow);
odp_port = vsp_realdev_to_vlandev(ofproto, ofport->odp_port,
flow.vlan_tci);
if (odp_port != ofport->odp_port) {
compose_output_action(ctx, ctx->flow.in_port);
break;
case OFPP_TABLE:
- xlate_table_action(ctx, ctx->flow.in_port, ctx->table_id);
+ xlate_table_action(ctx, ctx->flow.in_port, 0);
break;
case OFPP_NORMAL:
xlate_normal(ctx);
ctx->may_learn = packet != NULL;
ctx->tcp_flags = tcp_flags;
ctx->resubmit_hook = NULL;
+ ctx->report_hook = NULL;
ctx->resubmit_stats = NULL;
}
xlate_actions(ctx, ofpacts, ofpacts_len, &odp_actions);
ofpbuf_uninit(&odp_actions);
}
+
+static void
+xlate_report(struct action_xlate_ctx *ctx, const char *s)
+{
+ if (ctx->report_hook) {
+ ctx->report_hook(ctx, s);
+ }
+}
\f
/* OFPP_NORMAL implementation. */
* so in one special case.
*/
static bool
-is_admissible(struct ofproto_dpif *ofproto, const struct flow *flow,
- struct ofport_dpif *in_port, uint16_t vlan, tag_type *tags)
+is_admissible(struct action_xlate_ctx *ctx, struct ofport_dpif *in_port,
+ uint16_t vlan)
{
+ struct ofproto_dpif *ofproto = ctx->ofproto;
+ struct flow *flow = &ctx->flow;
struct ofbundle *in_bundle = in_port->bundle;
/* Drop frames for reserved multicast addresses
* only if forward_bpdu option is absent. */
if (!ofproto->up.forward_bpdu && eth_addr_is_reserved(flow->dl_dst)) {
+ xlate_report(ctx, "packet has reserved destination MAC, dropping");
return false;
}
struct mac_entry *mac;
switch (bond_check_admissibility(in_bundle->bond, in_port,
- flow->dl_dst, tags)) {
+ flow->dl_dst, &ctx->tags)) {
case BV_ACCEPT:
break;
case BV_DROP:
+ xlate_report(ctx, "bonding refused admissibility, dropping");
return false;
case BV_DROP_IF_MOVED:
if (mac && mac->port.p != in_bundle &&
(!is_gratuitous_arp(flow)
|| mac_entry_is_grat_arp_locked(mac))) {
+ xlate_report(ctx, "SLB bond thinks this packet looped back, "
+ "dropping");
return false;
}
break;
in_bundle = lookup_input_bundle(ctx->ofproto, ctx->flow.in_port,
ctx->packet != NULL, &in_port);
if (!in_bundle) {
+ xlate_report(ctx, "no input bundle, dropping");
return;
}
"VLAN tag received on port %s",
ctx->ofproto->up.name, in_bundle->name);
}
+ xlate_report(ctx, "partial VLAN tag, dropping");
return;
}
"%s, which is reserved exclusively for mirroring",
ctx->ofproto->up.name, in_bundle->name);
}
+ xlate_report(ctx, "input port is mirror output port, dropping");
return;
}
/* Check VLAN. */
vid = vlan_tci_to_vid(ctx->flow.vlan_tci);
if (!input_vid_is_valid(vid, in_bundle, ctx->packet != NULL)) {
+ xlate_report(ctx, "disallowed VLAN VID for this input port, dropping");
return;
}
vlan = input_vid_to_vlan(in_bundle, vid);
/* Check other admissibility requirements. */
- if (in_port &&
- !is_admissible(ctx->ofproto, &ctx->flow, in_port, vlan, &ctx->tags)) {
+ if (in_port && !is_admissible(ctx, in_port, vlan)) {
return;
}
&ctx->tags);
if (mac) {
if (mac->port.p != in_bundle) {
+ xlate_report(ctx, "forwarding to learned port");
output_normal(ctx, mac->port.p, vlan);
+ } else {
+ xlate_report(ctx, "learned port is input port, dropping");
}
} else {
struct ofbundle *bundle;
+ xlate_report(ctx, "no learned MAC for destination, flooding");
HMAP_FOR_EACH (bundle, hmap_node, &ctx->ofproto->bundles) {
if (bundle != in_bundle
&& ofbundle_includes_vlan(bundle, vlan)
trace_format_rule(result, ctx->table_id, ctx->recurse + 1, rule);
}
+static void
+trace_report(struct action_xlate_ctx *ctx, const char *s)
+{
+ struct trace_ctx *trace = CONTAINER_OF(ctx, struct trace_ctx, ctx);
+ struct ds *result = trace->result;
+
+ ds_put_char_multiple(result, '\t', ctx->recurse);
+ ds_put_cstr(result, s);
+ ds_put_char(result, '\n');
+}
+
static void
ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
void *aux OVS_UNUSED)
action_xlate_ctx_init(&trace.ctx, ofproto, flow, initial_tci,
rule, tcp_flags, packet);
trace.ctx.resubmit_hook = trace_resubmit;
+ trace.ctx.report_hook = trace_report;
xlate_actions(&trace.ctx, rule->up.ofpacts, rule->up.ofpacts_len,
&odp_actions);
git://git.onelab.eu / sliver-openvswitch.git / blobdiff