* timeouts.) */
uint8_t tcp_flags;
- /* If nonnull, called just before executing a resubmit action.
+ /* If nonnull, called just before executing a resubmit action. In
+ * addition, disables logging of traces when the recursion depth is
+ * exceeded.
*
* This is normally null so the client has to set it manually after
* calling action_xlate_ctx_init(). */
* reason to look at them. */
int recurse; /* Recursion level, via xlate_table_action. */
+ bool max_resubmit_trigger; /* Recursed too deeply during translation. */
struct flow base_flow; /* Flow at the last commit. */
uint32_t orig_skb_priority; /* Priority when packet arrived. */
uint8_t table_id; /* OpenFlow table ID where flow was found. */
tag_type tag; /* Tag associated with this port. */
uint32_t bond_stable_id; /* stable_id to use as bond slave, or 0. */
bool may_enable; /* May be enabled in bonds. */
+ long long int carrier_seq; /* Carrier status changes. */
/* Spanning tree. */
struct stp_port *stp_port; /* Spanning Tree Protocol, if any. */
uint16_t ofp_port);
static struct ofport_dpif *get_odp_port(struct ofproto_dpif *,
uint32_t odp_port);
+static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
+ const struct ofpbuf *, ovs_be16 initial_tci,
+ struct ds *);
/* Packet processing. */
static void update_learning_table(struct ofproto_dpif *,
hmap_init(&port->priorities);
port->realdev_ofp_port = 0;
port->vlandev_vid = 0;
+ port->carrier_seq = netdev_get_carrier_resets(port->up.netdev);
if (ofproto->sflow) {
dpif_sflow_add_port(ofproto->sflow, port_);
static void
port_run(struct ofport_dpif *ofport)
{
+ long long int carrier_seq = netdev_get_carrier_resets(ofport->up.netdev);
+ bool carrier_changed = carrier_seq != ofport->carrier_seq;
bool enable = netdev_get_carrier(ofport->up.netdev);
+ ofport->carrier_seq = carrier_seq;
+
if (ofport->cfm) {
cfm_run(ofport->cfm);
if (ofport->bundle) {
enable = enable && lacp_slave_may_enable(ofport->bundle->lacp, ofport);
+ if (carrier_changed) {
+ lacp_slave_carrier_changed(ofport->bundle->lacp, ofport);
+ }
}
if (ofport->may_enable != enable) {
pin.packet = packet->data;
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;
- 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);
+ connmgr_send_packet_in(ofproto->up.connmgr, &pin);
}
static bool
VLOG_ERR_RL(&recurse_rl, "resubmit actions recursed over %d times",
MAX_RESUBMIT_RECURSION);
+ ctx->max_resubmit_trigger = true;
}
}
pin.table_id = ctx->table_id;
pin.cookie = ctx->rule ? ctx->rule->up.flow_cookie : 0;
- 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);
+ connmgr_send_packet_in(ctx->ofproto->up.connmgr, &pin);
ofpbuf_delete(packet);
}
ctx->nf_output_iface = NF_OUT_DROP;
ctx->mirrors = 0;
ctx->recurse = 0;
+ ctx->max_resubmit_trigger = false;
ctx->orig_skb_priority = ctx->flow.skb_priority;
ctx->table_id = 0;
ctx->exit = false;
ctx->may_set_up_flow = false;
return ctx->odp_actions;
} else {
+ static struct vlog_rate_limit trace_rl = VLOG_RATE_LIMIT_INIT(1, 1);
+ struct flow original_flow = ctx->flow;
+ ovs_be16 initial_tci = ctx->base_flow.vlan_tci;
+
add_sflow_action(ctx);
do_xlate_actions(in, n_in, ctx);
+ if (ctx->max_resubmit_trigger && !ctx->resubmit_hook
+ && !VLOG_DROP_ERR(&trace_rl)) {
+ struct ds ds = DS_EMPTY_INITIALIZER;
+
+ ofproto_trace(ctx->ofproto, &original_flow, ctx->packet,
+ initial_tci, &ds);
+ VLOG_ERR("Trace triggered by excessive resubmit recursion:\n%s",
+ ds_cstr(&ds));
+ ds_destroy(&ds);
+ }
+
if (!connmgr_may_set_up_flow(ctx->ofproto->up.connmgr, &ctx->flow,
ctx->odp_actions->data,
ctx->odp_actions->size)) {
ds_destroy(&ds);
}
-struct ofproto_trace {
+struct trace_ctx {
struct action_xlate_ctx ctx;
struct flow flow;
struct ds *result;
static void
trace_format_flow(struct ds *result, int level, const char *title,
- struct ofproto_trace *trace)
+ struct trace_ctx *trace)
{
ds_put_char_multiple(result, '\t', level);
ds_put_format(result, "%s: ", title);
static void
trace_format_regs(struct ds *result, int level, const char *title,
- struct ofproto_trace *trace)
+ struct trace_ctx *trace)
{
size_t i;
static void
trace_format_odp(struct ds *result, int level, const char *title,
- struct ofproto_trace *trace)
+ struct trace_ctx *trace)
{
struct ofpbuf *odp_actions = trace->ctx.odp_actions;
static void
trace_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
{
- struct ofproto_trace *trace = CONTAINER_OF(ctx, struct ofproto_trace, ctx);
+ struct trace_ctx *trace = CONTAINER_OF(ctx, struct trace_ctx, ctx);
struct ds *result = trace->result;
ds_put_char(result, '\n');
struct ofproto_dpif *ofproto;
struct ofpbuf odp_key;
struct ofpbuf *packet;
- struct rule_dpif *rule;
ovs_be16 initial_tci;
struct ds result;
struct flow flow;
goto exit;
}
- ds_put_cstr(&result, "Flow: ");
- flow_format(&result, &flow);
- ds_put_char(&result, '\n');
+ ofproto_trace(ofproto, &flow, packet, initial_tci, &result);
+ unixctl_command_reply(conn, ds_cstr(&result));
+
+exit:
+ ds_destroy(&result);
+ ofpbuf_delete(packet);
+ ofpbuf_uninit(&odp_key);
+}
+
+static void
+ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
+ const struct ofpbuf *packet, ovs_be16 initial_tci,
+ struct ds *ds)
+{
+ struct rule_dpif *rule;
- rule = rule_dpif_lookup(ofproto, &flow, 0);
- trace_format_rule(&result, 0, 0, rule);
+ ds_put_cstr(ds, "Flow: ");
+ flow_format(ds, flow);
+ ds_put_char(ds, '\n');
+
+ rule = rule_dpif_lookup(ofproto, flow, 0);
+ trace_format_rule(ds, 0, 0, rule);
if (rule) {
- struct ofproto_trace trace;
+ struct trace_ctx 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,
+ tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0;
+ trace.result = ds;
+ trace.flow = *flow;
+ action_xlate_ctx_init(&trace.ctx, ofproto, flow, initial_tci,
rule, tcp_flags, packet);
trace.ctx.resubmit_hook = trace_resubmit;
odp_actions = xlate_actions(&trace.ctx,
rule->up.actions, rule->up.n_actions);
- ds_put_char(&result, '\n');
- trace_format_flow(&result, 0, "Final flow", &trace);
- ds_put_cstr(&result, "Datapath actions: ");
- format_odp_actions(&result, odp_actions->data, odp_actions->size);
+ ds_put_char(ds, '\n');
+ trace_format_flow(ds, 0, "Final flow", &trace);
+ ds_put_cstr(ds, "Datapath actions: ");
+ format_odp_actions(ds, odp_actions->data, odp_actions->size);
ofpbuf_delete(odp_actions);
if (!trace.ctx.may_set_up_flow) {
if (packet) {
- ds_put_cstr(&result, "\nThis flow is not cachable.");
+ ds_put_cstr(ds, "\nThis flow is not cachable.");
} else {
- ds_put_cstr(&result, "\nThe datapath actions are incomplete--"
+ ds_put_cstr(ds, "\nThe datapath actions are incomplete--"
"for complete actions, please supply a packet.");
}
}
}
-
- unixctl_command_reply(conn, ds_cstr(&result));
-
-exit:
- ds_destroy(&result);
- ofpbuf_delete(packet);
- ofpbuf_uninit(&odp_key);
}
static void
return hash_2words(realdev_ofp_port, vid);
}
+/* Returns the ODP port number of the Linux VLAN device that corresponds to
+ * 'vlan_tci' on the network device with port number 'realdev_odp_port' in
+ * 'ofproto'. For example, given 'realdev_odp_port' of eth0 and 'vlan_tci' 9,
+ * it would return the port number of eth0.9.
+ *
+ * Unless VLAN splinters are enabled for port 'realdev_odp_port', this
+ * function just returns its 'realdev_odp_port' argument. */
static uint32_t
vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto,
uint32_t realdev_odp_port, ovs_be16 vlan_tci)
return NULL;
}
+/* Returns the OpenFlow port number of the "real" device underlying the Linux
+ * VLAN device with OpenFlow port number 'vlandev_ofp_port' and stores the
+ * VLAN VID of the Linux VLAN device in '*vid'. For example, given
+ * 'vlandev_ofp_port' of eth0.9, it would return the OpenFlow port number of
+ * eth0 and store 9 in '*vid'.
+ *
+ * Returns 0 and does not modify '*vid' if 'vlandev_ofp_port' is not a Linux
+ * VLAN device. Unless VLAN splinters are enabled, this is what this function
+ * always does.*/
static uint16_t
vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto,
- uint16_t vlandev_ofp_port, int *vid)
+ uint16_t vlandev_ofp_port, int *vid)
{
if (!hmap_is_empty(&ofproto->vlandev_map)) {
const struct vlan_splinter *vsp;
projects / openvswitch / blobdiff