X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=ofproto%2Fofproto-dpif.c;h=a42d09eb9575f2dc8f6f09667335e5bbc667a567;hb=2b540ecba2c583ec6050b5cc0017660eb101e4ed;hp=29918baccc5644e2fe90909a8c4cb29437f233cb;hpb=3e5b3fdbf52cee41142ed8e2bf5cab9f49146d97;p=openvswitch diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c index 29918bac..a42d09eb 100644 --- a/ofproto/ofproto-dpif.c +++ b/ofproto/ofproto-dpif.c @@ -109,7 +109,7 @@ static void flow_push_stats(struct rule_dpif *, const struct flow *, uint64_t packets, uint64_t bytes, long long int used); -static uint32_t rule_calculate_tag(const struct flow *, +static tag_type rule_calculate_tag(const struct flow *, const struct flow_wildcards *, uint32_t basis); static void rule_invalidate(const struct rule_dpif *); @@ -145,8 +145,8 @@ static void update_mirror_stats(struct ofproto_dpif *ofproto, uint64_t packets, uint64_t bytes); struct ofbundle { - struct ofproto_dpif *ofproto; /* Owning ofproto. */ struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */ + struct ofproto_dpif *ofproto; /* Owning ofproto. */ void *aux; /* Key supplied by ofproto's client. */ char *name; /* Identifier for log messages. */ @@ -209,11 +209,17 @@ struct action_xlate_ctx { * revalidating without a packet to refer to. */ const struct ofpbuf *packet; - /* Should OFPP_NORMAL MAC learning and NXAST_LEARN actions execute? We - * want to execute them if we are actually processing a packet, or if we - * are accounting for packets that the datapath has processed, but not if - * we are just revalidating. */ - bool may_learn; + /* Should OFPP_NORMAL update the MAC learning table? We want to update it + * if we are actually processing a packet, or if we are accounting for + * packets that the datapath has processed, but not if we are just + * revalidating. */ + bool may_learn_macs; + + /* Should "learn" actions update the flow table? We want to update it if + * we are actually processing a packet, or in most cases if we are + * accounting for packets that the datapath has processed, but not if we + * are just revalidating. */ + bool may_flow_mod; /* The rule that we are currently translating, or NULL. */ struct rule_dpif *rule; @@ -223,7 +229,9 @@ struct action_xlate_ctx { * 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(). */ @@ -246,6 +254,7 @@ struct action_xlate_ctx { * 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. */ @@ -343,7 +352,7 @@ static void facet_flush_stats(struct facet *); 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 facet *); +static void facet_account(struct facet *, bool may_flow_mod); static bool facet_is_controller_flow(struct facet *); @@ -559,6 +568,9 @@ static struct ofport_dpif *get_ofp_port(struct ofproto_dpif *, 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 *, @@ -1107,6 +1119,14 @@ get_cfm_remote_mpids(const struct ofport *ofport_, const uint64_t **rmps, return -1; } } + +static int +get_cfm_health(const struct ofport *ofport_) +{ + struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); + + return ofport->cfm ? cfm_get_health(ofport->cfm) : -1; +} /* Spanning Tree. */ @@ -2465,14 +2485,12 @@ send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet, 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); @@ -2480,7 +2498,7 @@ send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet, /* 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 @@ -2985,7 +3003,7 @@ update_stats(struct ofproto_dpif *p) facet->tcp_flags |= stats->tcp_flags; subfacet_update_time(subfacet, stats->used); - facet_account(facet); + facet_account(facet, true); facet_push_stats(facet); } else { if (!VLOG_DROP_WARN(&rl)) { @@ -3237,7 +3255,7 @@ facet_remove(struct facet *facet) } static void -facet_account(struct facet *facet) +facet_account(struct facet *facet, bool may_flow_mod) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto); uint64_t n_bytes; @@ -3263,7 +3281,8 @@ facet_account(struct facet *facet) action_xlate_ctx_init(&ctx, ofproto, &facet->flow, facet->flow.vlan_tci, facet->rule, facet->tcp_flags, NULL); - ctx.may_learn = true; + ctx.may_learn_macs = true; + ctx.may_flow_mod = may_flow_mod; ofpbuf_delete(xlate_actions(&ctx, facet->rule->up.actions, facet->rule->up.n_actions)); } @@ -3337,7 +3356,7 @@ facet_flush_stats(struct facet *facet) } facet_push_stats(facet); - facet_account(facet); + facet_account(facet, false); if (ofproto->netflow && !facet_is_controller_flow(facet)) { struct ofexpired expired; @@ -4403,7 +4422,7 @@ xlate_table_action(struct action_xlate_ctx *ctx, if (table_id > 0 && table_id < N_TABLES) { struct table_dpif *table = &ofproto->tables[table_id]; if (table->other_table) { - ctx->tags |= (rule + ctx->tags |= (rule && rule->tag ? rule->tag : rule_calculate_tag(&ctx->flow, &table->other_table->wc, @@ -4435,6 +4454,7 @@ xlate_table_action(struct action_xlate_ctx *ctx, VLOG_ERR_RL(&recurse_rl, "resubmit actions recursed over %d times", MAX_RESUBMIT_RECURSION); + ctx->max_resubmit_trigger = true; } } @@ -4495,7 +4515,13 @@ execute_controller_action(struct action_xlate_ctx *ctx, int len, eth_pop_vlan(packet); eh = packet->l2; - assert(eh->eth_type == ctx->flow.dl_type); + + /* If the Ethernet type is less than ETH_TYPE_MIN, it's likely an 802.2 + * LLC frame. Calculating the Ethernet type of these frames is more + * trouble than seems appropriate for a simple assertion. */ + assert(ntohs(eh->eth_type) < ETH_TYPE_MIN + || 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); @@ -4528,12 +4554,10 @@ execute_controller_action(struct action_xlate_ctx *ctx, int len, 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); } @@ -4961,7 +4985,7 @@ do_xlate_actions(const union ofp_action *in, size_t n_in, case OFPUTIL_NXAST_LEARN: ctx->has_learn = true; - if (ctx->may_learn) { + if (ctx->may_flow_mod) { xlate_learn_action(ctx, (const struct nx_action_learn *) ia); } break; @@ -5014,7 +5038,8 @@ action_xlate_ctx_init(struct action_xlate_ctx *ctx, ctx->base_flow.vlan_tci = initial_tci; ctx->rule = rule; ctx->packet = packet; - ctx->may_learn = packet != NULL; + ctx->may_learn_macs = packet != NULL; + ctx->may_flow_mod = packet != NULL; ctx->tcp_flags = tcp_flags; ctx->resubmit_hook = NULL; } @@ -5037,6 +5062,7 @@ xlate_actions(struct action_xlate_ctx *ctx, 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; @@ -5068,9 +5094,24 @@ xlate_actions(struct action_xlate_ctx *ctx, 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)) { @@ -5626,7 +5667,7 @@ xlate_normal(struct action_xlate_ctx *ctx) } /* Learn source MAC. */ - if (ctx->may_learn) { + if (ctx->may_learn_macs) { update_learning_table(ctx->ofproto, &ctx->flow, vlan, in_bundle); } @@ -5675,7 +5716,7 @@ xlate_normal(struct action_xlate_ctx *ctx) /* Calculates the tag to use for 'flow' and wildcards 'wc' when it is inserted * into an OpenFlow table with the given 'basis'. */ -static uint32_t +static tag_type rule_calculate_tag(const struct flow *flow, const struct flow_wildcards *wc, uint32_t secret) { @@ -5948,7 +5989,7 @@ ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED, ds_destroy(&ds); } -struct ofproto_trace { +struct trace_ctx { struct action_xlate_ctx ctx; struct flow flow; struct ds *result; @@ -5977,7 +6018,7 @@ trace_format_rule(struct ds *result, uint8_t table_id, int level, 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); @@ -5992,7 +6033,7 @@ trace_format_flow(struct ds *result, int level, const char *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; @@ -6006,7 +6047,7 @@ trace_format_regs(struct ds *result, int level, const char *title, 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; @@ -6019,7 +6060,7 @@ trace_format_odp(struct ds *result, int level, const char *title, 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'); @@ -6037,7 +6078,6 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], 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; @@ -6110,48 +6150,57 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], 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; + + ds_put_cstr(ds, "Flow: "); + flow_format(ds, flow); + ds_put_char(ds, '\n'); - rule = rule_dpif_lookup(ofproto, &flow, 0); - trace_format_rule(&result, 0, 0, rule); + 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 @@ -6291,6 +6340,13 @@ hash_realdev_vid(uint16_t realdev_ofp_port, int vid) 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) @@ -6327,9 +6383,18 @@ vlandev_find(const struct ofproto_dpif *ofproto, uint16_t vlandev_ofp_port) 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; @@ -6434,6 +6499,7 @@ const struct ofproto_class ofproto_dpif_class = { set_cfm, get_cfm_fault, get_cfm_remote_mpids, + get_cfm_health, set_stp, get_stp_status, set_stp_port,