X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=ofproto%2Fofproto.c;h=2b2a306a03ed815c8e87194bfe85577c93dfacdd;hb=952d37436a18737fc942f42c5e81f67f427769e1;hp=1fd7babdd9f51686f1ea4c07acabf7cec0a0108d;hpb=5ecc9d8156062191f0d53ba3dc2c5776c962b7c5;p=openvswitch diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index 1fd7babd..2b2a306a 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -63,6 +63,31 @@ VLOG_DEFINE_THIS_MODULE(ofproto); +COVERAGE_DEFINE(facet_changed_rule); +COVERAGE_DEFINE(facet_revalidate); +COVERAGE_DEFINE(odp_overflow); +COVERAGE_DEFINE(ofproto_agg_request); +COVERAGE_DEFINE(ofproto_costly_flags); +COVERAGE_DEFINE(ofproto_ctlr_action); +COVERAGE_DEFINE(ofproto_del_rule); +COVERAGE_DEFINE(ofproto_error); +COVERAGE_DEFINE(ofproto_expiration); +COVERAGE_DEFINE(ofproto_expired); +COVERAGE_DEFINE(ofproto_flows_req); +COVERAGE_DEFINE(ofproto_flush); +COVERAGE_DEFINE(ofproto_invalidated); +COVERAGE_DEFINE(ofproto_no_packet_in); +COVERAGE_DEFINE(ofproto_ofconn_stuck); +COVERAGE_DEFINE(ofproto_ofp2odp); +COVERAGE_DEFINE(ofproto_packet_in); +COVERAGE_DEFINE(ofproto_packet_out); +COVERAGE_DEFINE(ofproto_queue_req); +COVERAGE_DEFINE(ofproto_recv_openflow); +COVERAGE_DEFINE(ofproto_reinit_ports); +COVERAGE_DEFINE(ofproto_unexpected_rule); +COVERAGE_DEFINE(ofproto_uninstallable); +COVERAGE_DEFINE(ofproto_update_port); + #include "sflow_api.h" struct ofport { @@ -1291,7 +1316,7 @@ int ofproto_port_del(struct ofproto *ofproto, uint16_t odp_port) { struct ofport *ofport = get_port(ofproto, odp_port); - const char *name = ofport ? (char *) ofport->opp.name : ""; + const char *name = ofport ? ofport->opp.name : ""; int error; error = dpif_port_del(ofproto->dpif, odp_port); @@ -1414,7 +1439,7 @@ reinit_ports(struct ofproto *p) svec_init(&devnames); HMAP_FOR_EACH (ofport, hmap_node, &p->ports) { - svec_add (&devnames, (char *) ofport->opp.name); + svec_add (&devnames, ofport->opp.name); } dpif_port_list(p->dpif, &odp_ports, &n_odp_ports); for (i = 0; i < n_odp_ports; i++) { @@ -1496,7 +1521,7 @@ ofport_equal(const struct ofport *a_, const struct ofport *b_) BUILD_ASSERT_DECL(sizeof *a == 48); /* Detect ofp_phy_port changes. */ return (a->port_no == b->port_no && !memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr) - && !strcmp((char *) a->name, (char *) b->name) + && !strcmp(a->name, b->name) && a->state == b->state && a->config == b->config && a->curr == b->curr @@ -1515,7 +1540,10 @@ send_port_status(struct ofproto *p, const struct ofport *ofport, struct ofp_port_status *ops; struct ofpbuf *b; - if (!ofconn_receives_async_msgs(ofconn)) { + /* Primary controllers, even slaves, should always get port status + updates. Otherwise obey ofconn_receives_async_msgs(). */ + if (ofconn->type != OFCONN_PRIMARY + && !ofconn_receives_async_msgs(ofconn)) { continue; } @@ -1530,7 +1558,7 @@ send_port_status(struct ofproto *p, const struct ofport *ofport, static void ofport_install(struct ofproto *p, struct ofport *ofport) { - const char *netdev_name = (const char *) ofport->opp.name; + const char *netdev_name = ofport->opp.name; netdev_monitor_add(p->netdev_monitor, ofport->netdev); hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->odp_port, 0)); @@ -1546,7 +1574,7 @@ ofport_remove(struct ofproto *p, struct ofport *ofport) netdev_monitor_remove(p->netdev_monitor, ofport->netdev); hmap_remove(&p->ports, &ofport->hmap_node); shash_delete(&p->port_by_name, - shash_find(&p->port_by_name, (char *) ofport->opp.name)); + shash_find(&p->port_by_name, ofport->opp.name)); if (p->sflow) { ofproto_sflow_del_port(p->sflow, ofport->odp_port); } @@ -1618,9 +1646,9 @@ update_port(struct ofproto *p, const char *devname) return; } else if (old_ofport && new_ofport) { /* Most of the 'config' bits are OpenFlow soft state, but - * OFPPC_PORT_DOWN is maintained the kernel. So transfer the OpenFlow - * bits from old_ofport. (make_ofport() only sets OFPPC_PORT_DOWN and - * leaves the other bits 0.) */ + * OFPPC_PORT_DOWN is maintained by the kernel. So transfer the + * OpenFlow bits from old_ofport. (make_ofport() only sets + * OFPPC_PORT_DOWN and leaves the other bits 0.) */ new_ofport->opp.config |= old_ofport->opp.config & ~OFPPC_PORT_DOWN; if (ofport_equal(old_ofport, new_ofport)) { @@ -2785,15 +2813,12 @@ xlate_set_queue_action(struct action_xlate_ctx *ctx, static void xlate_set_dl_tci(struct action_xlate_ctx *ctx) { - ovs_be16 dl_vlan = ctx->flow.dl_vlan; - uint8_t dl_vlan_pcp = ctx->flow.dl_vlan_pcp; - - if (dl_vlan == htons(OFP_VLAN_NONE)) { + ovs_be16 tci = ctx->flow.vlan_tci; + if (!(tci & htons(VLAN_CFI))) { odp_actions_add(ctx->out, ODPAT_STRIP_VLAN); } else { union odp_action *oa = odp_actions_add(ctx->out, ODPAT_SET_DL_TCI); - oa->dl_tci.tci = htons(ntohs(dl_vlan & htons(VLAN_VID_MASK)) - | (dl_vlan_pcp << VLAN_PCP_SHIFT)); + oa->dl_tci.tci = tci & ~htons(VLAN_CFI); } } @@ -2801,12 +2826,11 @@ static void xlate_reg_move_action(struct action_xlate_ctx *ctx, const struct nx_action_reg_move *narm) { - ovs_be16 old_vlan = ctx->flow.dl_vlan; - uint8_t old_pcp = ctx->flow.dl_vlan_pcp; + ovs_be16 old_tci = ctx->flow.vlan_tci; nxm_execute_reg_move(narm, &ctx->flow); - if (ctx->flow.dl_vlan != old_vlan || ctx->flow.dl_vlan_pcp != old_pcp) { + if (ctx->flow.vlan_tci != old_tci) { xlate_set_dl_tci(ctx); } } @@ -2896,18 +2920,20 @@ do_xlate_actions(const union ofp_action *in, size_t n_in, break; case OFPAT_SET_VLAN_VID: - ctx->flow.dl_vlan = ia->vlan_vid.vlan_vid; + ctx->flow.vlan_tci &= ~htons(VLAN_VID_MASK); + ctx->flow.vlan_tci |= ia->vlan_vid.vlan_vid | htons(VLAN_CFI); xlate_set_dl_tci(ctx); break; case OFPAT_SET_VLAN_PCP: - ctx->flow.dl_vlan_pcp = ia->vlan_pcp.vlan_pcp; + ctx->flow.vlan_tci &= ~htons(VLAN_PCP_MASK); + ctx->flow.vlan_tci |= htons( + (ia->vlan_pcp.vlan_pcp << VLAN_PCP_SHIFT) | VLAN_CFI); xlate_set_dl_tci(ctx); break; case OFPAT_STRIP_VLAN: - ctx->flow.dl_vlan = htons(OFP_VLAN_NONE); - ctx->flow.dl_vlan_pcp = 0; + ctx->flow.vlan_tci = htons(0); xlate_set_dl_tci(ctx); break; @@ -3412,8 +3438,7 @@ put_ofp_flow_stats(struct ofconn *ofconn, struct rule *rule, ofs->length = htons(len); ofs->table_id = 0; ofs->pad = 0; - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, - ofconn->flow_format, &ofs->match); + ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofs->match); calc_flow_duration(rule->created, &ofs->duration_sec, &ofs->duration_nsec); ofs->cookie = rule->flow_cookie; ofs->priority = htons(rule->cr.priority); @@ -3452,7 +3477,8 @@ handle_flow_stats_request(struct ofconn *ofconn, struct cls_rule target; struct rule *rule; - cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, &target); + ofputil_cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, + &target); cls_cursor_init(&cursor, &ofconn->ofproto->cls, &target); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { put_ofp_flow_stats(ofconn, rule, fsr->out_port, &reply); @@ -3544,8 +3570,7 @@ flow_stats_ds(struct ofproto *ofproto, struct rule *rule, struct ds *results) size_t act_len = sizeof *rule->actions * rule->n_actions; query_stats(ofproto, rule, &packet_count, &byte_count); - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, - NXFF_OPENFLOW10, &match); + ofputil_cls_rule_to_match(&rule->cr, NXFF_OPENFLOW10, &match); ds_put_format(results, "duration=%llds, ", (time_msec() - rule->created) / 1000); @@ -3626,7 +3651,8 @@ handle_aggregate_stats_request(struct ofconn *ofconn, } request = (struct ofp_aggregate_stats_request *) osr->body; - cls_rule_from_match(&request->match, 0, NXFF_OPENFLOW10, 0, &target); + ofputil_cls_rule_from_match(&request->match, 0, NXFF_OPENFLOW10, 0, + &target); msg = start_ofp_stats_reply(osr, sizeof *reply); reply = append_ofp_stats_reply(sizeof *reply, ofconn, &msg); @@ -3989,9 +4015,9 @@ modify_flows_loose(struct ofconn *ofconn, struct flow_mod *fm) } if (match) { - /* This credits the packet to whichever flow happened to happened to - * match last. That's weird. Maybe we should do a lookup for the - * flow that actually matches the packet? Who knows. */ + /* This credits the packet to whichever flow happened to match last. + * That's weird. Maybe we should do a lookup for the flow that + * actually matches the packet? Who knows. */ send_buffered_packet(ofconn, match, fm->buffer_id); return 0; } else { @@ -4185,8 +4211,8 @@ handle_ofpt_flow_mod(struct ofconn *ofconn, struct ofp_header *oh) } /* Translate the message. */ - cls_rule_from_match(&ofm->match, ntohs(ofm->priority), ofconn->flow_format, - ofm->cookie, &fm.cr); + ofputil_cls_rule_from_match(&ofm->match, ntohs(ofm->priority), + ofconn->flow_format, ofm->cookie, &fm.cr); fm.cookie = ofm->cookie; fm.command = ntohs(ofm->command); fm.idle_timeout = ntohs(ofm->idle_timeout); @@ -4461,6 +4487,11 @@ handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet) payload.size = msg->length - sizeof *msg; flow_extract(&payload, msg->arg, msg->port, &flow); + packet->l2 = payload.l2; + packet->l3 = payload.l3; + packet->l4 = payload.l4; + packet->l7 = payload.l7; + /* Check with in-band control to see if this packet should be sent * to the local port regardless of the flow table. */ if (in_band_msg_in_hook(p->in_band, &flow, &payload)) { @@ -4815,8 +4846,7 @@ compose_ofp_flow_removed(struct ofconn *ofconn, const struct rule *rule, struct ofpbuf *buf; ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf); - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, ofconn->flow_format, - &ofr->match); + ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofr->match); ofr->cookie = rule->flow_cookie; ofr->priority = htons(rule->cr.priority); ofr->reason = reason;