X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif.c;h=bfa9a9a56afd7ff2da616327f26d946cdcf8dbaf;hb=202a4b176e939574b643651dceef22097ce23780;hp=7cd9d4409df6a0edc095b700d78502d76efbfc31;hpb=8b81d1ef3ca5f1815267a12d44b6ebc96b5a45c1;p=sliver-openvswitch.git diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c index 7cd9d4409..bfa9a9a56 100644 --- a/ofproto/ofproto-dpif.c +++ b/ofproto/ofproto-dpif.c @@ -52,6 +52,7 @@ #include "ofproto-dpif-governor.h" #include "ofproto-dpif-ipfix.h" #include "ofproto-dpif-mirror.h" +#include "ofproto-dpif-monitor.h" #include "ofproto-dpif-sflow.h" #include "ofproto-dpif-upcall.h" #include "ofproto-dpif-xlate.h" @@ -68,13 +69,14 @@ VLOG_DEFINE_THIS_MODULE(ofproto_dpif); COVERAGE_DEFINE(ofproto_dpif_expired); -COVERAGE_DEFINE(facet_changed_rule); COVERAGE_DEFINE(facet_revalidate); COVERAGE_DEFINE(facet_unexpected); -COVERAGE_DEFINE(facet_suppress); +COVERAGE_DEFINE(facet_create); +COVERAGE_DEFINE(facet_remove); +COVERAGE_DEFINE(subfacet_create); +COVERAGE_DEFINE(subfacet_destroy); COVERAGE_DEFINE(subfacet_install_fail); COVERAGE_DEFINE(packet_in_overflow); -COVERAGE_DEFINE(flow_mod_overflow); /* Number of implemented OpenFlow tables. */ enum { N_TABLES = 255 }; @@ -108,6 +110,28 @@ struct rule_dpif { static void rule_get_stats(struct rule *, uint64_t *packets, uint64_t *bytes); static struct rule_dpif *rule_dpif_cast(const struct rule *); +struct group_dpif { + struct ofgroup up; + + /* These statistics: + * + * - Do include packets and bytes from facets that have been deleted or + * whose own statistics have been folded into the rule. + * + * - Do include packets and bytes sent "by hand" that were accounted to + * the rule without any facet being involved (this is a rare corner + * case in rule_execute()). + * + * - Do not include packet or bytes that can be obtained from any facet's + * packet_count or byte_count member or that can be obtained from the + * datapath by, e.g., dpif_flow_get() for any subfacet. + */ + struct ovs_mutex stats_mutex; + uint64_t packet_count OVS_GUARDED; /* Number of packets received. */ + uint64_t byte_count OVS_GUARDED; /* Number of bytes received. */ + struct bucket_counter *bucket_stats OVS_GUARDED; /* Bucket statistics. */ +}; + struct ofbundle { struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */ struct ofproto_dpif *ofproto; /* Owning ofproto. */ @@ -175,7 +199,6 @@ struct subfacet { struct facet *facet; /* Owning facet. */ struct dpif_backer *backer; /* Owning backer. */ - enum odp_key_fitness key_fitness; struct nlattr *key; int key_len; @@ -190,7 +213,8 @@ struct subfacet { #define SUBFACET_DESTROY_MAX_BATCH 50 -static struct subfacet *subfacet_create(struct facet *, struct flow_miss *); +static struct subfacet *subfacet_create(struct facet *, struct flow_miss *, + uint32_t key_hash); static struct subfacet *subfacet_find(struct dpif_backer *, const struct nlattr *key, size_t key_len, uint32_t key_hash); @@ -262,7 +286,7 @@ struct facet { /* 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'. */ + uint16_t tcp_flags; /* TCP flags seen for this 'rule'. */ struct xlate_out xout; @@ -309,6 +333,7 @@ struct ofport_dpif { struct bfd *bfd; /* BFD, if any. */ bool may_enable; /* May be enabled in bonds. */ bool is_tunnel; /* This port is a tunnel. */ + bool is_layer3; /* This is a layer 3 port. */ long long int carrier_seq; /* Carrier status changes. */ struct ofport_dpif *peer; /* Peer if patch port. */ @@ -361,8 +386,6 @@ ofport_dpif_cast(const struct ofport *ofport) } static void port_run(struct ofport_dpif *); -static void port_run_fast(struct ofport_dpif *); -static void port_wait(struct ofport_dpif *); static int set_bfd(struct ofport *, const struct smap *); static int set_cfm(struct ofport *, const struct cfm_settings *); static void ofport_update_peer(struct ofport_dpif *); @@ -413,7 +436,7 @@ struct dpif_backer { struct timer next_expiration; struct ovs_rwlock odp_to_ofport_lock; - struct hmap odp_to_ofport_map OVS_GUARDED; /* ODP port to ofport map. */ + struct hmap odp_to_ofport_map OVS_GUARDED; /* Contains "struct ofport"s. */ struct simap tnl_backers; /* Set of dpif ports backing tunnels. */ @@ -438,20 +461,6 @@ struct dpif_backer { unsigned avg_n_subfacet; /* Average number of flows. */ long long int avg_subfacet_life; /* Average life span of subfacets. */ - /* The average number of subfacets... */ - struct avg_subfacet_rates hourly; /* ...over the last hour. */ - struct avg_subfacet_rates daily; /* ...over the last day. */ - struct avg_subfacet_rates lifetime; /* ...over the switch lifetime. */ - long long int last_minute; /* Last time 'hourly' was updated. */ - - /* Number of subfacets added or deleted since 'last_minute'. */ - unsigned subfacet_add_count; - unsigned subfacet_del_count; - - /* Number of subfacets added or deleted from 'created' to 'last_minute.' */ - unsigned long long int total_subfacet_add_count; - unsigned long long int total_subfacet_del_count; - /* Number of upcall handling threads. */ unsigned int n_handler_threads; }; @@ -460,7 +469,6 @@ struct dpif_backer { static struct shash all_dpif_backers = SHASH_INITIALIZER(&all_dpif_backers); static void drop_key_clear(struct dpif_backer *); -static void update_moving_averages(struct dpif_backer *backer); struct ofproto_dpif { struct hmap_node all_ofproto_dpifs_node; /* In 'all_ofproto_dpifs'. */ @@ -485,8 +493,9 @@ struct ofproto_dpif { struct classifier facets; /* Contains 'struct facet's. */ long long int consistency_rl; - struct netdev_stats stats; /* To account packets generated and consumed in - * userspace. */ + struct ovs_mutex stats_mutex; + struct netdev_stats stats OVS_GUARDED; /* To account packets generated and + * consumed in userspace. */ /* Spanning tree. */ struct stp *stp; @@ -508,7 +517,6 @@ struct ofproto_dpif { uint64_t n_missed; /* Work queues. */ - struct guarded_list flow_mods; /* Contains "struct flow_mod"s. */ struct guarded_list pins; /* Contains "struct ofputil_packet_in"s. */ }; @@ -531,7 +539,9 @@ ofproto_dpif_cast(const struct ofproto *ofproto) static struct ofport_dpif *get_ofp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port); static void ofproto_trace(struct ofproto_dpif *, const struct flow *, - const struct ofpbuf *packet, struct ds *); + const struct ofpbuf *packet, + const struct ofpact[], size_t ofpacts_len, + struct ds *); /* Upcalls. */ static void handle_upcalls(struct dpif_backer *); @@ -542,36 +552,30 @@ static int expire(struct dpif_backer *); /* NetFlow. */ static void send_netflow_active_timeouts(struct ofproto_dpif *); -/* Utilities. */ -static int send_packet(const struct ofport_dpif *, struct ofpbuf *packet); - /* Global variables. */ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); /* Initial mappings of port to bridge mappings. */ static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports); -/* Executes and takes ownership of 'fm'. */ +/* Executes 'fm'. The caller retains ownership of 'fm' and everything in + * it. */ void ofproto_dpif_flow_mod(struct ofproto_dpif *ofproto, struct ofputil_flow_mod *fm) { - if (!guarded_list_push_back(&ofproto->flow_mods, &fm->list_node, 1024)) { - COVERAGE_INC(flow_mod_overflow); - free(fm->ofpacts); - free(fm); - } + ofproto_flow_mod(&ofproto->up, fm); } /* Appends 'pin' to the queue of "packet ins" to be sent to the controller. * Takes ownership of 'pin' and pin->packet. */ void ofproto_dpif_send_packet_in(struct ofproto_dpif *ofproto, - struct ofputil_packet_in *pin) + struct ofproto_packet_in *pin) { if (!guarded_list_push_back(&ofproto->pins, &pin->list_node, 1024)) { COVERAGE_INC(packet_in_overflow); - free(CONST_CAST(void *, pin->packet)); + free(CONST_CAST(void *, pin->up.packet)); free(pin); } } @@ -824,8 +828,8 @@ type_run(const char *type) ofport->up.netdev, ofport->cfm, ofport->bfd, ofport->peer, stp_port, ofport->qdscp, ofport->n_qdscp, - ofport->up.pp.config, ofport->is_tunnel, - ofport->may_enable); + ofport->up.pp.config, ofport->up.pp.state, + ofport->is_tunnel, ofport->may_enable); } ovs_rwlock_unlock(&xlate_rwlock); @@ -1083,8 +1087,6 @@ dealloc(struct ofproto *ofproto_) static void close_dpif_backer(struct dpif_backer *backer) { - struct shash_node *node; - ovs_assert(backer->refcount > 0); if (--backer->refcount) { @@ -1094,13 +1096,13 @@ close_dpif_backer(struct dpif_backer *backer) drop_key_clear(backer); hmap_destroy(&backer->drop_keys); + udpif_destroy(backer->udpif); + simap_destroy(&backer->tnl_backers); ovs_rwlock_destroy(&backer->odp_to_ofport_lock); hmap_destroy(&backer->odp_to_ofport_map); - node = shash_find(&all_dpif_backers, backer->type); + shash_find_and_delete(&all_dpif_backers, backer->type); free(backer->type); - shash_delete(&all_dpif_backers, node); - udpif_destroy(backer->udpif); dpif_close(backer->dpif); ovs_assert(hmap_is_empty(&backer->subfacets)); @@ -1224,14 +1226,6 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) backer->max_n_subfacet = 0; backer->created = time_msec(); - backer->last_minute = backer->created; - memset(&backer->hourly, 0, sizeof backer->hourly); - memset(&backer->daily, 0, sizeof backer->daily); - memset(&backer->lifetime, 0, sizeof backer->lifetime); - backer->subfacet_add_count = 0; - backer->subfacet_del_count = 0; - backer->total_subfacet_add_count = 0; - backer->total_subfacet_del_count = 0; backer->avg_n_subfacet = 0; backer->avg_subfacet_life = 0; @@ -1243,7 +1237,6 @@ construct(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); struct shash_node *node, *next; - uint32_t max_ports; int error; error = open_dpif_backer(ofproto->up.type, &ofproto->backer); @@ -1251,9 +1244,6 @@ construct(struct ofproto *ofproto_) return error; } - max_ports = dpif_get_max_ports(ofproto->backer->dpif); - ofproto_init_max_ports(ofproto_, MIN(max_ports, ofp_to_u16(OFPP_MAX))); - ofproto->netflow = NULL; ofproto->sflow = NULL; ofproto->ipfix = NULL; @@ -1262,12 +1252,12 @@ construct(struct ofproto *ofproto_) ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME); ofproto->mbridge = mbridge_create(); ofproto->has_bonded_bundles = false; + ovs_mutex_init(&ofproto->stats_mutex); ovs_mutex_init(&ofproto->vsp_mutex); - classifier_init(&ofproto->facets); + classifier_init(&ofproto->facets, NULL); ofproto->consistency_rl = LLONG_MIN; - guarded_list_init(&ofproto->flow_mods); guarded_list_init(&ofproto->pins); ofproto_dpif_unixctl_init(); @@ -1391,12 +1381,11 @@ destruct(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); struct rule_dpif *rule, *next_rule; - struct ofputil_packet_in *pin, *next_pin; - struct ofputil_flow_mod *fm, *next_fm; + struct ofproto_packet_in *pin, *next_pin; struct facet *facet, *next_facet; - struct list flow_mods, pins; struct cls_cursor cursor; struct oftable *table; + struct list pins; ovs_rwlock_rdlock(&ofproto->facets.rwlock); cls_cursor_init(&cursor, &ofproto->facets, NULL); @@ -1427,18 +1416,10 @@ destruct(struct ofproto *ofproto_) } } - guarded_list_pop_all(&ofproto->flow_mods, &flow_mods); - LIST_FOR_EACH_SAFE (fm, next_fm, list_node, &flow_mods) { - list_remove(&fm->list_node); - free(fm->ofpacts); - free(fm); - } - guarded_list_destroy(&ofproto->flow_mods); - guarded_list_pop_all(&ofproto->pins, &pins); LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) { list_remove(&pin->list_node); - free(CONST_CAST(void *, pin->packet)); + free(CONST_CAST(void *, pin->up.packet)); free(pin); } guarded_list_destroy(&ofproto->pins); @@ -1459,6 +1440,7 @@ destruct(struct ofproto *ofproto_) sset_destroy(&ofproto->ghost_ports); sset_destroy(&ofproto->port_poll_set); + ovs_mutex_destroy(&ofproto->stats_mutex); ovs_mutex_destroy(&ofproto->vsp_mutex); close_dpif_backer(ofproto->backer); @@ -1468,10 +1450,8 @@ static int run_fast(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); - struct ofputil_packet_in *pin, *next_pin; - struct ofputil_flow_mod *fm, *next_fm; - struct list flow_mods, pins; - struct ofport_dpif *ofport; + struct ofproto_packet_in *pin, *next_pin; + struct list pins; /* Do not perform any periodic activity required by 'ofproto' while * waiting for flow restore to complete. */ @@ -1479,31 +1459,14 @@ run_fast(struct ofproto *ofproto_) return 0; } - guarded_list_pop_all(&ofproto->flow_mods, &flow_mods); - LIST_FOR_EACH_SAFE (fm, next_fm, list_node, &flow_mods) { - int error = ofproto_flow_mod(&ofproto->up, fm); - if (error && !VLOG_DROP_WARN(&rl)) { - VLOG_WARN("learning action failed to modify flow table (%s)", - ofperr_get_name(error)); - } - - list_remove(&fm->list_node); - free(fm->ofpacts); - free(fm); - } - guarded_list_pop_all(&ofproto->pins, &pins); LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) { connmgr_send_packet_in(ofproto->up.connmgr, pin); list_remove(&pin->list_node); - free(CONST_CAST(void *, pin->packet)); + free(CONST_CAST(void *, pin->up.packet)); free(pin); } - HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) { - port_run_fast(ofport); - } - return 0; } @@ -1564,14 +1527,14 @@ run(struct ofproto *ofproto_) if (time_msec() >= ofproto->consistency_rl && !classifier_is_empty(&ofproto->facets) && !ofproto->backer->need_revalidate) { - struct cls_table *table; + struct cls_subtable *table; struct cls_rule *cr; struct facet *facet; ofproto->consistency_rl = time_msec() + 250; - table = CONTAINER_OF(hmap_random_node(&ofproto->facets.tables), - struct cls_table, hmap_node); + table = CONTAINER_OF(hmap_random_node(&ofproto->facets.subtables), + struct cls_subtable, hmap_node); cr = CONTAINER_OF(hmap_random_node(&table->rules), struct cls_rule, hmap_node); facet = CONTAINER_OF(cr, struct facet, cr); @@ -1589,7 +1552,6 @@ static void wait(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); - struct ofport_dpif *ofport; struct ofbundle *bundle; if (ofproto_get_flow_restore_wait()) { @@ -1602,9 +1564,6 @@ wait(struct ofproto *ofproto_) if (ofproto->ipfix) { dpif_ipfix_wait(ofproto->ipfix); } - HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) { - port_wait(ofport); - } HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) { bundle_wait(bundle); } @@ -1751,6 +1710,7 @@ port_construct(struct ofport *port_) port->realdev_ofp_port = 0; port->vlandev_vid = 0; port->carrier_seq = netdev_get_carrier_resets(netdev); + port->is_layer3 = netdev_vport_is_layer3(netdev); if (netdev_vport_is_patch(netdev)) { /* By bailing out here, we don't submit the port to the sFlow module @@ -1867,6 +1827,9 @@ port_modified(struct ofport *port_) bfd_set_netdev(port->bfd, port->up.netdev); } + ofproto_dpif_monitor_port_update(port, port->bfd, port->cfm, + port->up.pp.hw_addr); + if (port->is_tunnel && tnl_port_reconfigure(port, port->up.netdev, port->odp_port)) { ofproto_dpif_cast(port->up.ofproto)->backer->need_revalidate = @@ -1957,11 +1920,9 @@ static int set_cfm(struct ofport *ofport_, const struct cfm_settings *s) { struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); - int error; + int error = 0; - if (!s) { - error = 0; - } else { + if (s) { if (!ofport->cfm) { struct ofproto_dpif *ofproto; @@ -1971,13 +1932,17 @@ set_cfm(struct ofport *ofport_, const struct cfm_settings *s) } if (cfm_configure(ofport->cfm, s)) { - return 0; + error = 0; + goto out; } error = EINVAL; } cfm_unref(ofport->cfm); ofport->cfm = NULL; +out: + ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm, + ofport->up.pp.hw_addr); return error; } @@ -1989,6 +1954,7 @@ get_cfm_status(const struct ofport *ofport_, if (ofport->cfm) { status->faults = cfm_get_fault(ofport->cfm); + status->flap_count = cfm_get_flap_count(ofport->cfm); status->remote_opstate = cfm_get_opup(ofport->cfm); status->health = cfm_get_health(ofport->cfm); cfm_get_remote_mpids(ofport->cfm, &status->rmps, &status->n_rmps); @@ -2011,7 +1977,8 @@ set_bfd(struct ofport *ofport_, const struct smap *cfg) if (ofport->bfd != old) { ofproto->backer->need_revalidate = REV_RECONFIGURE; } - + ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm, + ofport->up.pp.hw_addr); return 0; } @@ -2049,7 +2016,7 @@ send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_) VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d " "with unknown MAC", ofproto->up.name, port_num); } else { - send_packet(ofport, pkt); + ofproto_dpif_send_packet(ofport, pkt); } } ofpbuf_delete(pkt); @@ -2212,6 +2179,24 @@ get_stp_port_status(struct ofport *ofport_, s->state = stp_port_get_state(sp); s->sec_in_state = (time_msec() - ofport->stp_state_entered) / 1000; s->role = stp_port_get_role(sp); + + return 0; +} + +static int +get_stp_port_stats(struct ofport *ofport_, + struct ofproto_port_stp_stats *s) +{ + struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); + struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); + struct stp_port *sp = ofport->stp_port; + + if (!ofproto->stp || !sp) { + s->enabled = false; + return 0; + } + + s->enabled = true; stp_port_get_counts(sp, &s->tx_count, &s->rx_count, &s->error_count); return 0; @@ -2341,6 +2326,7 @@ bundle_update(struct ofbundle *bundle) bundle->floodable = true; LIST_FOR_EACH (port, bundle_node, &bundle->ports) { if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD + || port->is_layer3 || !stp_forward_in_state(port->stp_state)) { bundle->floodable = false; break; @@ -2388,6 +2374,7 @@ bundle_add_port(struct ofbundle *bundle, ofp_port_t ofp_port, port->bundle = bundle; list_push_back(&bundle->ports, &port->bundle_node); if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD + || port->is_layer3 || !stp_forward_in_state(port->stp_state)) { bundle->floodable = false; } @@ -2645,7 +2632,7 @@ send_pdu_cb(void *port_, const void *pdu, size_t pdu_size) pdu_size); memcpy(packet_pdu, pdu, pdu_size); - send_packet(port, &packet); + ofproto_dpif_send_packet(port, &packet); ofpbuf_uninit(&packet); } else { VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface " @@ -2682,7 +2669,7 @@ bundle_send_learning_packets(struct ofbundle *bundle) LIST_FOR_EACH (learning_packet, list_node, &packets) { int ret; - ret = send_packet(learning_packet->private_p, learning_packet); + ret = ofproto_dpif_send_packet(learning_packet->private_p, learning_packet); if (ret) { error = ret; n_errors++; @@ -2896,28 +2883,6 @@ ofport_update_peer(struct ofport_dpif *ofport) free(peer_name); } -static void -port_run_fast(struct ofport_dpif *ofport) -{ - if (ofport->cfm && cfm_should_send_ccm(ofport->cfm)) { - struct ofpbuf packet; - - ofpbuf_init(&packet, 0); - cfm_compose_ccm(ofport->cfm, &packet, ofport->up.pp.hw_addr); - send_packet(ofport, &packet); - ofpbuf_uninit(&packet); - } - - if (ofport->bfd && bfd_should_send_packet(ofport->bfd)) { - struct ofpbuf packet; - - ofpbuf_init(&packet, 0); - bfd_put_packet(ofport->bfd, &packet, ofport->up.pp.hw_addr); - send_packet(ofport, &packet); - ofpbuf_uninit(&packet); - } -} - static void port_run(struct ofport_dpif *ofport) { @@ -2929,12 +2894,9 @@ port_run(struct ofport_dpif *ofport) ofport->carrier_seq = carrier_seq; - port_run_fast(ofport); - if (ofport->cfm) { int cfm_opup = cfm_get_opup(ofport->cfm); - cfm_run(ofport->cfm); cfm_enable = !cfm_get_fault(ofport->cfm); if (cfm_opup >= 0) { @@ -2943,7 +2905,6 @@ port_run(struct ofport_dpif *ofport) } if (ofport->bfd) { - bfd_run(ofport->bfd); bfd_enable = bfd_forwarding(ofport->bfd); } @@ -2966,18 +2927,6 @@ port_run(struct ofport_dpif *ofport) ofport->may_enable = enable; } -static void -port_wait(struct ofport_dpif *ofport) -{ - if (ofport->cfm) { - cfm_wait(ofport->cfm); - } - - if (ofport->bfd) { - bfd_wait(ofport->bfd); - } -} - static int port_query_by_name(const struct ofproto *ofproto_, const char *devname, struct ofproto_port *ofproto_port) @@ -3091,10 +3040,11 @@ port_get_stats(const struct ofport *ofport_, struct netdev_stats *stats) if (!error && ofport_->ofp_port == OFPP_LOCAL) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); + ovs_mutex_lock(&ofproto->stats_mutex); /* ofproto->stats.tx_packets represents packets that we created * internally and sent to some port (e.g. packets sent with - * send_packet()). Account for them as if they had come from - * OFPP_LOCAL and got forwarded. */ + * ofproto_dpif_send_packet()). Account for them as if they had + * come from OFPP_LOCAL and got forwarded. */ if (stats->rx_packets != UINT64_MAX) { stats->rx_packets += ofproto->stats.tx_packets; @@ -3115,6 +3065,7 @@ port_get_stats(const struct ofport *ofport_, struct netdev_stats *stats) if (stats->tx_bytes != UINT64_MAX) { stats->tx_bytes += ofproto->stats.rx_bytes; } + ovs_mutex_unlock(&ofproto->stats_mutex); } return error; @@ -3272,7 +3223,7 @@ flow_miss_should_make_facet(struct flow_miss *miss) hash = flow_hash_in_wildcards(&miss->flow, &miss->xout.wc, 0); return governor_should_install_flow(backer->governor, hash, - list_size(&miss->packets)); + miss->stats.n_packets); } /* Handles 'miss', which matches 'facet'. May add any required datapath @@ -3290,13 +3241,32 @@ handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet, { enum subfacet_path want_path; struct subfacet *subfacet; + uint32_t key_hash; + /* Update facet stats. */ facet->packet_count += miss->stats.n_packets; facet->prev_packet_count += miss->stats.n_packets; facet->byte_count += miss->stats.n_bytes; facet->prev_byte_count += miss->stats.n_bytes; - want_path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH; + /* Look for an existing subfacet. If we find one, update its used time. */ + key_hash = odp_flow_key_hash(miss->key, miss->key_len); + if (!list_is_empty(&facet->subfacets)) { + subfacet = subfacet_find(miss->ofproto->backer, + miss->key, miss->key_len, key_hash); + if (subfacet) { + if (subfacet->facet == facet) { + subfacet->used = MAX(subfacet->used, miss->stats.used); + } else { + /* This shouldn't happen. */ + VLOG_ERR_RL(&rl, "subfacet with wrong facet"); + subfacet_destroy(subfacet); + subfacet = NULL; + } + } + } else { + subfacet = NULL; + } /* Don't install the flow if it's the result of the "userspace" * action for an already installed facet. This can occur when a @@ -3308,7 +3278,13 @@ handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet, return; } - subfacet = subfacet_create(facet, miss); + /* Create a subfacet, if we don't already have one. */ + if (!subfacet) { + subfacet = subfacet_create(facet, miss, key_hash); + } + + /* Install the subfacet, if it's not already installed. */ + want_path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH; if (subfacet->path != want_path) { struct flow_miss_op *op = &ops[(*n_ops)++]; struct dpif_flow_put *put = &op->dpif_op.u.flow_put; @@ -3350,7 +3326,7 @@ handle_flow_miss(struct flow_miss *miss, struct flow_miss_op *ops, { struct facet *facet; - miss->ofproto->n_missed += list_size(&miss->packets); + miss->ofproto->n_missed += miss->stats.n_packets; facet = facet_lookup_valid(miss->ofproto, &miss->flow); if (!facet) { @@ -3458,107 +3434,12 @@ handle_flow_misses(struct dpif_backer *backer, struct flow_miss_batch *fmb) } } -static void -handle_sflow_upcall(struct dpif_backer *backer, - const struct dpif_upcall *upcall) -{ - struct ofproto_dpif *ofproto; - union user_action_cookie cookie; - struct flow flow; - odp_port_t odp_in_port; - - if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, &odp_in_port) - || !ofproto->sflow) { - return; - } - - memset(&cookie, 0, sizeof cookie); - memcpy(&cookie, nl_attr_get(upcall->userdata), sizeof cookie.sflow); - dpif_sflow_received(ofproto->sflow, upcall->packet, &flow, - odp_in_port, &cookie); -} - -static void -handle_flow_sample_upcall(struct dpif_backer *backer, - const struct dpif_upcall *upcall) -{ - struct ofproto_dpif *ofproto; - union user_action_cookie cookie; - struct flow flow; - - if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, NULL) - || !ofproto->ipfix) { - return; - } - - memset(&cookie, 0, sizeof cookie); - memcpy(&cookie, nl_attr_get(upcall->userdata), sizeof cookie.flow_sample); - - /* The flow reflects exactly the contents of the packet. Sample - * the packet using it. */ - dpif_ipfix_flow_sample(ofproto->ipfix, upcall->packet, &flow, - cookie.flow_sample.collector_set_id, - cookie.flow_sample.probability, - cookie.flow_sample.obs_domain_id, - cookie.flow_sample.obs_point_id); -} - -static void -handle_ipfix_upcall(struct dpif_backer *backer, - const struct dpif_upcall *upcall) -{ - struct ofproto_dpif *ofproto; - struct flow flow; - - if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, NULL) - || !ofproto->ipfix) { - return; - } - - /* The flow reflects exactly the contents of the packet. Sample - * the packet using it. */ - dpif_ipfix_bridge_sample(ofproto->ipfix, upcall->packet, &flow); -} - static void handle_upcalls(struct dpif_backer *backer) { struct flow_miss_batch *fmb; int n_processed; - for (n_processed = 0; n_processed < FLOW_MISS_MAX_BATCH; n_processed++) { - struct upcall *upcall = upcall_next(backer->udpif); - - if (!upcall) { - break; - } - - switch (upcall->type) { - case SFLOW_UPCALL: - handle_sflow_upcall(backer, &upcall->dpif_upcall); - break; - - case FLOW_SAMPLE_UPCALL: - handle_flow_sample_upcall(backer, &upcall->dpif_upcall); - break; - - case IPFIX_UPCALL: - handle_ipfix_upcall(backer, &upcall->dpif_upcall); - break; - - case BAD_UPCALL: - break; - - case MISS_UPCALL: - NOT_REACHED(); - } - - upcall_destroy(upcall); - } - for (n_processed = 0; n_processed < FLOW_MISS_MAX_BATCH; n_processed++) { struct drop_key *drop_key = drop_key_next(backer->udpif); if (!drop_key) { @@ -3770,8 +3651,6 @@ update_stats(struct dpif_backer *backer) run_fast_rl(); } dpif_flow_dump_done(&dump); - - update_moving_averages(backer); } /* Calculates and returns the number of milliseconds of idle time after which @@ -3954,6 +3833,7 @@ facet_create(const struct flow_miss *miss) struct facet *facet; struct match match; + COVERAGE_INC(facet_create); facet = xzalloc(sizeof *facet); facet->ofproto = miss->ofproto; facet->used = miss->stats.used; @@ -3985,24 +3865,49 @@ facet_free(struct facet *facet) } } -/* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on - * 'packet', which arrived on 'in_port'. */ -static bool -execute_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow, - const struct nlattr *odp_actions, size_t actions_len, - struct ofpbuf *packet) +/* Executes, within 'ofproto', the actions in 'rule' or 'ofpacts' on 'packet'. + * 'flow' must reflect the data in 'packet'. */ +int +ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto, + const struct flow *flow, + struct rule_dpif *rule, + const struct ofpact *ofpacts, size_t ofpacts_len, + struct ofpbuf *packet) { struct odputil_keybuf keybuf; + struct dpif_flow_stats stats; + struct xlate_out xout; + struct xlate_in xin; + ofp_port_t in_port; struct ofpbuf key; int error; + ovs_assert((rule != NULL) != (ofpacts != NULL)); + + dpif_flow_stats_extract(flow, packet, time_msec(), &stats); + if (rule) { + rule_dpif_credit_stats(rule, &stats); + } + + xlate_in_init(&xin, ofproto, flow, rule, stats.tcp_flags, packet); + xin.ofpacts = ofpacts; + xin.ofpacts_len = ofpacts_len; + xin.resubmit_stats = &stats; + xlate_actions(&xin, &xout); + ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); - odp_flow_key_from_flow(&key, flow, - ofp_port_to_odp_port(ofproto, flow->in_port.ofp_port)); + in_port = flow->in_port.ofp_port; + if (in_port == OFPP_NONE) { + in_port = OFPP_LOCAL; + } + odp_flow_key_from_flow(&key, flow, ofp_port_to_odp_port(ofproto, in_port)); error = dpif_execute(ofproto->backer->dpif, key.data, key.size, - odp_actions, actions_len, packet); - return !error; + xout.odp_actions.data, xout.odp_actions.size, packet, + (xout.slow & SLOW_ACTION) != 0); + xlate_out_uninit(&xout); + + return error; } /* Remove 'facet' from its ofproto and free up the associated memory: @@ -4017,6 +3922,7 @@ facet_remove(struct facet *facet) { struct subfacet *subfacet, *next_subfacet; + COVERAGE_INC(facet_remove); ovs_assert(!list_is_empty(&facet->subfacets)); /* First uninstall all of the subfacets to get final statistics. */ @@ -4224,15 +4130,11 @@ facet_check_consistency(struct facet *facet) struct xlate_out xout; struct xlate_in xin; - - struct rule_dpif *rule; bool ok; /* Check the datapath actions for consistency. */ - rule_dpif_lookup(facet->ofproto, &facet->flow, NULL, &rule); - xlate_in_init(&xin, facet->ofproto, &facet->flow, rule, 0, NULL); + xlate_in_init(&xin, facet->ofproto, &facet->flow, NULL, 0, NULL); xlate_actions(&xin, &xout); - rule_dpif_unref(rule); ok = ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions) && facet->xout.slow == xout.slow; @@ -4384,21 +4286,20 @@ flow_push_stats(struct ofproto_dpif *ofproto, struct flow *flow, struct dpif_flow_stats *stats, bool may_learn) { struct ofport_dpif *in_port; - struct rule_dpif *rule; struct xlate_in xin; in_port = get_ofp_port(ofproto, flow->in_port.ofp_port); if (in_port && in_port->is_tunnel) { netdev_vport_inc_rx(in_port->up.netdev, stats); + if (in_port->bfd) { + bfd_account_rx(in_port->bfd, stats); + } } - rule_dpif_lookup(ofproto, flow, NULL, &rule); - rule_dpif_credit_stats(rule, stats); - xlate_in_init(&xin, ofproto, flow, rule, stats->tcp_flags, NULL); + xlate_in_init(&xin, ofproto, flow, NULL, stats->tcp_flags, NULL); xin.resubmit_stats = stats; xin.may_learn = may_learn; xlate_actions_for_side_effects(&xin); - rule_dpif_unref(rule); } static void @@ -4475,9 +4376,15 @@ rule_dpif_credit_stats(struct rule_dpif *rule, } bool -rule_dpif_fail_open(const struct rule_dpif *rule) +rule_dpif_is_fail_open(const struct rule_dpif *rule) { - return rule->up.cr.priority == FAIL_OPEN_PRIORITY; + return is_fail_open_rule(&rule->up); +} + +bool +rule_dpif_is_table_miss(const struct rule_dpif *rule) +{ + return rule_is_table_miss(&rule->up); } ovs_be64 @@ -4522,43 +4429,25 @@ subfacet_find(struct dpif_backer *backer, const struct nlattr *key, return NULL; } -/* Searches 'facet' (within 'ofproto') for a subfacet with the specified - * 'key_fitness', 'key', and 'key_len' members in 'miss'. Returns the - * existing subfacet if there is one, otherwise creates and returns a - * new subfacet. */ +/* Creates and returns a new subfacet within 'facet' for the flow in 'miss'. + * 'key_hash' must be a hash over miss->key. The caller must have already + * ensured that no subfacet subfacet already exists. */ static struct subfacet * -subfacet_create(struct facet *facet, struct flow_miss *miss) +subfacet_create(struct facet *facet, struct flow_miss *miss, uint32_t key_hash) { struct dpif_backer *backer = miss->ofproto->backer; - enum odp_key_fitness key_fitness = miss->key_fitness; const struct nlattr *key = miss->key; size_t key_len = miss->key_len; - uint32_t key_hash; struct subfacet *subfacet; - key_hash = odp_flow_key_hash(key, key_len); - - if (list_is_empty(&facet->subfacets)) { - subfacet = &facet->one_subfacet; - } else { - subfacet = subfacet_find(backer, key, key_len, key_hash); - if (subfacet) { - if (subfacet->facet == facet) { - return subfacet; - } - - /* This shouldn't happen. */ - VLOG_ERR_RL(&rl, "subfacet with wrong facet"); - subfacet_destroy(subfacet); - } - - subfacet = xmalloc(sizeof *subfacet); - } + subfacet = (list_is_empty(&facet->subfacets) + ? &facet->one_subfacet + : xmalloc(sizeof *subfacet)); + COVERAGE_INC(subfacet_create); hmap_insert(&backer->subfacets, &subfacet->hmap_node, key_hash); list_push_back(&facet->subfacets, &subfacet->list_node); subfacet->facet = facet; - subfacet->key_fitness = key_fitness; subfacet->key = xmemdup(key, key_len); subfacet->key_len = key_len; subfacet->used = miss->stats.used; @@ -4568,7 +4457,6 @@ subfacet_create(struct facet *facet, struct flow_miss *miss) subfacet->path = SF_NOT_INSTALLED; subfacet->backer = backer; - backer->subfacet_add_count++; return subfacet; } @@ -4578,11 +4466,8 @@ static void subfacet_destroy__(struct subfacet *subfacet) { struct facet *facet = subfacet->facet; - struct ofproto_dpif *ofproto = facet->ofproto; - - /* Update ofproto stats before uninstall the subfacet. */ - ofproto->backer->subfacet_del_count++; + COVERAGE_INC(subfacet_destroy); subfacet_uninstall(subfacet); hmap_remove(&subfacet->backer->subfacets, &subfacet->hmap_node); list_remove(&subfacet->list_node); @@ -4804,9 +4689,7 @@ rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, cls_rule = classifier_lookup(cls, &ofpc_normal_flow, wc); } else if (frag && ofproto->up.frag_handling == OFPC_FRAG_DROP) { cls_rule = &ofproto->drop_frags_rule->up.cr; - if (wc) { - flow_wildcards_init_exact(wc); - } + /* Frag mask in wc already set above. */ } else { cls_rule = classifier_lookup(cls, flow, wc); } @@ -4933,21 +4816,8 @@ rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow, struct ofpbuf *packet) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto); - struct dpif_flow_stats stats; - struct xlate_out xout; - struct xlate_in xin; - - dpif_flow_stats_extract(flow, packet, time_msec(), &stats); - rule_dpif_credit_stats(rule, &stats); - - xlate_in_init(&xin, ofproto, flow, rule, stats.tcp_flags, packet); - xin.resubmit_stats = &stats; - xlate_actions(&xin, &xout); - execute_odp_actions(ofproto, flow, xout.odp_actions.data, - xout.odp_actions.size, packet); - - xlate_out_uninit(&xout); + ofproto_dpif_execute_actions(ofproto, flow, rule, NULL, 0, packet); } static enum ofperr @@ -4974,59 +4844,153 @@ rule_modify_actions(struct rule *rule_, bool reset_counters) complete_operation(rule); } - -/* Sends 'packet' out 'ofport'. - * May modify 'packet'. - * Returns 0 if successful, otherwise a positive errno value. */ -static int -send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet) + +static struct group_dpif *group_dpif_cast(const struct ofgroup *group) { - struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); - uint64_t odp_actions_stub[1024 / 8]; - struct ofpbuf key, odp_actions; - struct dpif_flow_stats stats; - struct odputil_keybuf keybuf; - struct ofpact_output output; - struct xlate_out xout; - struct xlate_in xin; - struct flow flow; - union flow_in_port in_port_; - int error; + return group ? CONTAINER_OF(group, struct group_dpif, up) : NULL; +} - ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub); - ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); +static struct ofgroup * +group_alloc(void) +{ + struct group_dpif *group = xzalloc(sizeof *group); + return &group->up; +} - /* Use OFPP_NONE as the in_port to avoid special packet processing. */ - in_port_.ofp_port = OFPP_NONE; - flow_extract(packet, 0, 0, NULL, &in_port_, &flow); - odp_flow_key_from_flow(&key, &flow, ofp_port_to_odp_port(ofproto, - OFPP_LOCAL)); - dpif_flow_stats_extract(&flow, packet, time_msec(), &stats); +static void +group_dealloc(struct ofgroup *group_) +{ + struct group_dpif *group = group_dpif_cast(group_); + free(group); +} - ofpact_init(&output.ofpact, OFPACT_OUTPUT, sizeof output); - output.port = ofport->up.ofp_port; - output.max_len = 0; +static void +group_construct_stats(struct group_dpif *group) + OVS_REQUIRES(group->stats_mutex) +{ + group->packet_count = 0; + group->byte_count = 0; + if (!group->bucket_stats) { + group->bucket_stats = xcalloc(group->up.n_buckets, + sizeof *group->bucket_stats); + } else { + memset(group->bucket_stats, 0, group->up.n_buckets * + sizeof *group->bucket_stats); + } +} - xlate_in_init(&xin, ofproto, &flow, NULL, 0, packet); - xin.ofpacts_len = sizeof output; - xin.ofpacts = &output.ofpact; - xin.resubmit_stats = &stats; - xlate_actions(&xin, &xout); +static enum ofperr +group_construct(struct ofgroup *group_) +{ + struct group_dpif *group = group_dpif_cast(group_); + ovs_mutex_init(&group->stats_mutex); + ovs_mutex_lock(&group->stats_mutex); + group_construct_stats(group); + ovs_mutex_unlock(&group->stats_mutex); + return 0; +} - error = dpif_execute(ofproto->backer->dpif, - key.data, key.size, - xout.odp_actions.data, xout.odp_actions.size, - packet); - xlate_out_uninit(&xout); +static void +group_destruct__(struct group_dpif *group) + OVS_REQUIRES(group->stats_mutex) +{ + free(group->bucket_stats); + group->bucket_stats = NULL; +} - if (error) { - VLOG_WARN_RL(&rl, "%s: failed to send packet on port %s (%s)", - ofproto->up.name, netdev_get_name(ofport->up.netdev), - ovs_strerror(error)); +static void +group_destruct(struct ofgroup *group_) +{ + struct group_dpif *group = group_dpif_cast(group_); + ovs_mutex_lock(&group->stats_mutex); + group_destruct__(group); + ovs_mutex_unlock(&group->stats_mutex); + ovs_mutex_destroy(&group->stats_mutex); +} + +static enum ofperr +group_modify(struct ofgroup *group_, struct ofgroup *victim_) +{ + struct group_dpif *group = group_dpif_cast(group_); + struct group_dpif *victim = group_dpif_cast(victim_); + + ovs_mutex_lock(&group->stats_mutex); + if (victim->up.n_buckets < group->up.n_buckets) { + group_destruct__(group); } + group_construct_stats(group); + ovs_mutex_unlock(&group->stats_mutex); + + return 0; +} + +static enum ofperr +group_get_stats(const struct ofgroup *group_, struct ofputil_group_stats *ogs) +{ + struct group_dpif *group = group_dpif_cast(group_); + + /* Start from historical data for 'group' itself that are no longer tracked + * in facets. This counts, for example, facets that have expired. */ + ovs_mutex_lock(&group->stats_mutex); + ogs->packet_count = group->packet_count; + ogs->byte_count = group->byte_count; + memcpy(ogs->bucket_stats, group->bucket_stats, + group->up.n_buckets * sizeof *group->bucket_stats); + ovs_mutex_unlock(&group->stats_mutex); + + return 0; +} + +bool +group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id, + struct group_dpif **group) + OVS_TRY_RDLOCK(true, (*group)->up.rwlock) +{ + struct ofgroup *ofgroup; + bool found; + + *group = NULL; + found = ofproto_group_lookup(&ofproto->up, group_id, &ofgroup); + *group = found ? group_dpif_cast(ofgroup) : NULL; + + return found; +} + +void +group_dpif_release(struct group_dpif *group) + OVS_RELEASES(group->up.rwlock) +{ + ofproto_group_release(&group->up); +} + +void +group_dpif_get_buckets(const struct group_dpif *group, + const struct list **buckets) +{ + *buckets = &group->up.buckets; +} +enum ofp11_group_type +group_dpif_get_type(const struct group_dpif *group) +{ + return group->up.type; +} + +/* Sends 'packet' out 'ofport'. + * May modify 'packet'. + * Returns 0 if successful, otherwise a positive errno value. */ +int +ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet) +{ + struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); + int error; + + error = xlate_send_packet(ofport, packet); + + ovs_mutex_lock(&ofproto->stats_mutex); ofproto->stats.tx_packets++; ofproto->stats.tx_bytes += packet->size; + ovs_mutex_unlock(&ofproto->stats_mutex); return error; } @@ -5089,30 +5053,9 @@ packet_out(struct ofproto *ofproto_, struct ofpbuf *packet, const struct ofpact *ofpacts, size_t ofpacts_len) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); - struct odputil_keybuf keybuf; - struct dpif_flow_stats stats; - struct xlate_out xout; - struct xlate_in xin; - struct ofpbuf key; - - - ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); - odp_flow_key_from_flow(&key, flow, - ofp_port_to_odp_port(ofproto, - flow->in_port.ofp_port)); - - dpif_flow_stats_extract(flow, packet, time_msec(), &stats); - - xlate_in_init(&xin, ofproto, flow, NULL, stats.tcp_flags, packet); - xin.resubmit_stats = &stats; - xin.ofpacts_len = ofpacts_len; - xin.ofpacts = ofpacts; - - xlate_actions(&xin, &xout); - dpif_execute(ofproto->backer->dpif, key.data, key.size, - xout.odp_actions.data, xout.odp_actions.size, packet); - xlate_out_uninit(&xout); + ofproto_dpif_execute_actions(ofproto, flow, NULL, ofpacts, + ofpacts_len, packet); return 0; } @@ -5297,7 +5240,7 @@ trace_format_rule(struct ds *result, int level, const struct rule_dpif *rule) actions = rule_dpif_get_actions(rule); ds_put_char_multiple(result, '\t', level); - ds_put_cstr(result, "OpenFlow "); + ds_put_cstr(result, "OpenFlow actions="); ofpacts_format(actions->ofpacts, actions->ofpacts_len, result); ds_put_char(result, '\n'); @@ -5328,7 +5271,7 @@ trace_format_regs(struct ds *result, int level, const char *title, ds_put_char_multiple(result, '\t', level); ds_put_format(result, "%s:", title); for (i = 0; i < FLOW_N_REGS; i++) { - ds_put_format(result, " reg%zu=0x%"PRIx32, i, trace->flow.regs[i]); + ds_put_format(result, " reg%"PRIuSIZE"=0x%"PRIx32, i, trace->flow.regs[i]); } ds_put_char(result, '\n'); } @@ -5369,21 +5312,26 @@ trace_report(struct xlate_in *xin, const char *s, int recurse) ds_put_char(result, '\n'); } -static void -ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], - void *aux OVS_UNUSED) +/* Parses the 'argc' elements of 'argv', ignoring argv[0]. The following + * forms are supported: + * + * - [dpname] odp_flow [-generate | packet] + * - bridge br_flow [-generate | packet] + * + * On success, initializes '*ofprotop' and 'flow' and returns NULL. On failure + * returns a nonnull error message. */ +static const char * +parse_flow_and_packet(int argc, const char *argv[], + struct ofproto_dpif **ofprotop, struct flow *flow, + struct ofpbuf **packetp) { - const struct dpif_backer *backer; - struct ofproto_dpif *ofproto; - struct ofpbuf odp_key, odp_mask; + const struct dpif_backer *backer = NULL; + const char *error = NULL; + struct simap port_names = SIMAP_INITIALIZER(&port_names); struct ofpbuf *packet; - struct ds result; - struct flow flow; - char *s; + struct ofpbuf odp_key; + struct ofpbuf odp_mask; - packet = NULL; - backer = NULL; - ds_init(&result); ofpbuf_init(&odp_key, 0); ofpbuf_init(&odp_mask, 0); @@ -5392,132 +5340,264 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], packet = ofpbuf_new(0); argc--; } else { - const char *error = eth_from_hex(argv[argc - 1], &packet); + error = eth_from_hex(argv[argc - 1], &packet); if (!error) { argc--; } else if (argc == 4) { /* The 3-argument form must end in "-generate' or a hex string. */ - unixctl_command_reply_error(conn, error); goto exit; } } + /* odp_flow can have its in_port specified as a name instead of port no. + * We do not yet know whether a given flow is a odp_flow or a br_flow. + * But, to know whether a flow is odp_flow through odp_flow_from_string(), + * we need to create a simap of name to port no. */ + if (argc == 3) { + const char *dp_type; + if (!strncmp(argv[1], "ovs-", 4)) { + dp_type = argv[1] + 4; + } else { + dp_type = argv[1]; + } + backer = shash_find_data(&all_dpif_backers, dp_type); + } else if (argc == 2) { + struct shash_node *node; + if (shash_count(&all_dpif_backers) == 1) { + node = shash_first(&all_dpif_backers); + backer = node->data; + } + } else { + error = "Syntax error"; + goto exit; + } + if (backer && backer->dpif) { + struct dpif_port dpif_port; + struct dpif_port_dump port_dump; + DPIF_PORT_FOR_EACH (&dpif_port, &port_dump, backer->dpif) { + simap_put(&port_names, dpif_port.name, + odp_to_u32(dpif_port.port_no)); + } + } + /* Parse the flow and determine whether a datapath or * bridge is specified. If function odp_flow_key_from_string() * returns 0, the flow is a odp_flow. If function * parse_ofp_exact_flow() returns 0, the flow is a br_flow. */ - if (!odp_flow_from_string(argv[argc - 1], NULL, &odp_key, &odp_mask)) { - /* If the odp_flow is the second argument, - * the datapath name is the first argument. */ - if (argc == 3) { - const char *dp_type; - if (!strncmp(argv[1], "ovs-", 4)) { - dp_type = argv[1] + 4; - } else { - dp_type = argv[1]; - } - backer = shash_find_data(&all_dpif_backers, dp_type); - if (!backer) { - unixctl_command_reply_error(conn, "Cannot find datapath " - "of this name"); - goto exit; - } - } else { - /* No datapath name specified, so there should be only one - * datapath. */ - struct shash_node *node; - if (shash_count(&all_dpif_backers) != 1) { - unixctl_command_reply_error(conn, "Must specify datapath " - "name, there is more than one type of datapath"); - goto exit; - } - node = shash_first(&all_dpif_backers); - backer = node->data; + if (!odp_flow_from_string(argv[argc - 1], &port_names, + &odp_key, &odp_mask)) { + if (!backer) { + error = "Cannot find the datapath"; + goto exit; } - if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, &flow, - NULL, &ofproto, NULL)) { - unixctl_command_reply_error(conn, "Invalid datapath flow"); + if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, flow, + NULL, ofprotop, NULL)) { + error = "Invalid datapath flow"; goto exit; } - ds_put_format(&result, "Bridge: %s\n", ofproto->up.name); - } else if (!parse_ofp_exact_flow(&flow, argv[argc - 1])) { + } else if (!parse_ofp_exact_flow(flow, NULL, argv[argc - 1], NULL)) { if (argc != 3) { - unixctl_command_reply_error(conn, "Must specify bridge name"); + error = "Must specify bridge name"; goto exit; } - ofproto = ofproto_dpif_lookup(argv[1]); - if (!ofproto) { - unixctl_command_reply_error(conn, "Unknown bridge name"); + *ofprotop = ofproto_dpif_lookup(argv[1]); + if (!*ofprotop) { + error = "Unknown bridge name"; goto exit; } } else { - unixctl_command_reply_error(conn, "Bad flow syntax"); + error = "Bad flow syntax"; goto exit; } /* Generate a packet, if requested. */ if (packet) { if (!packet->size) { - flow_compose(packet, &flow); + flow_compose(packet, flow); } else { - union flow_in_port in_port_; - - in_port_ = flow.in_port; - ds_put_cstr(&result, "Packet: "); - s = ofp_packet_to_string(packet->data, packet->size); - ds_put_cstr(&result, s); - free(s); + union flow_in_port in_port = flow->in_port; /* Use the metadata from the flow and the packet argument * to reconstruct the flow. */ - flow_extract(packet, flow.skb_priority, flow.pkt_mark, NULL, - &in_port_, &flow); + flow_extract(packet, flow->skb_priority, flow->pkt_mark, NULL, + &in_port, flow); } } - ofproto_trace(ofproto, &flow, packet, &result); + error = NULL; + +exit: + if (error) { + ofpbuf_delete(packet); + packet = NULL; + } + *packetp = packet; + ofpbuf_uninit(&odp_key); + ofpbuf_uninit(&odp_mask); + simap_destroy(&port_names); + return error; +} + +static void +ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], + void *aux OVS_UNUSED) +{ + struct ofproto_dpif *ofproto; + struct ofpbuf *packet; + const char *error; + struct flow flow; + + error = parse_flow_and_packet(argc, argv, &ofproto, &flow, &packet); + if (!error) { + struct ds result; + + ds_init(&result); + ofproto_trace(ofproto, &flow, packet, NULL, 0, &result); + unixctl_command_reply(conn, ds_cstr(&result)); + ds_destroy(&result); + ofpbuf_delete(packet); + } else { + unixctl_command_reply_error(conn, error); + } +} + +static void +ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc, + const char *argv[], void *aux OVS_UNUSED) +{ + enum ofputil_protocol usable_protocols; + struct ofproto_dpif *ofproto; + bool enforce_consistency; + struct ofpbuf ofpacts; + struct ofpbuf *packet; + struct ds result; + struct flow flow; + uint16_t in_port; + + /* Three kinds of error return values! */ + enum ofperr retval; + const char *error; + char *rw_error; + + packet = NULL; + ds_init(&result); + ofpbuf_init(&ofpacts, 0); + + /* Parse actions. */ + rw_error = parse_ofpacts(argv[--argc], &ofpacts, &usable_protocols); + if (rw_error) { + unixctl_command_reply_error(conn, rw_error); + free(rw_error); + goto exit; + } + + /* OpenFlow 1.1 and later suggest that the switch enforces certain forms of + * consistency between the flow and the actions. With -consistent, we + * enforce consistency even for a flow supported in OpenFlow 1.0. */ + if (!strcmp(argv[1], "-consistent")) { + enforce_consistency = true; + argv++; + argc--; + } else { + enforce_consistency = false; + } + + error = parse_flow_and_packet(argc, argv, &ofproto, &flow, &packet); + if (error) { + unixctl_command_reply_error(conn, error); + goto exit; + } + + /* Do the same checks as handle_packet_out() in ofproto.c. + * + * We pass a 'table_id' of 0 to ofproto_check_ofpacts(), which isn't + * strictly correct because these actions aren't in any table, but it's OK + * because it 'table_id' is used only to check goto_table instructions, but + * packet-outs take a list of actions and therefore it can't include + * instructions. + * + * We skip the "meter" check here because meter is an instruction, not an + * action, and thus cannot appear in ofpacts. */ + in_port = ofp_to_u16(flow.in_port.ofp_port); + if (in_port >= ofproto->up.max_ports && in_port < ofp_to_u16(OFPP_MAX)) { + unixctl_command_reply_error(conn, "invalid in_port"); + goto exit; + } + if (enforce_consistency) { + retval = ofpacts_check_consistency(ofpacts.data, ofpacts.size, &flow, + u16_to_ofp(ofproto->up.max_ports), + 0, 0, usable_protocols); + } else { + retval = ofpacts_check(ofpacts.data, ofpacts.size, &flow, + u16_to_ofp(ofproto->up.max_ports), 0, 0, + &usable_protocols); + } + + if (retval) { + ds_clear(&result); + ds_put_format(&result, "Bad actions: %s", ofperr_to_string(retval)); + unixctl_command_reply_error(conn, ds_cstr(&result)); + goto exit; + } + + ofproto_trace(ofproto, &flow, packet, ofpacts.data, ofpacts.size, &result); unixctl_command_reply(conn, ds_cstr(&result)); exit: ds_destroy(&result); ofpbuf_delete(packet); - ofpbuf_uninit(&odp_key); - ofpbuf_uninit(&odp_mask); + ofpbuf_uninit(&ofpacts); } +/* Implements a "trace" through 'ofproto''s flow table, appending a textual + * description of the results to 'ds'. + * + * The trace follows a packet with the specified 'flow' through the flow + * table. 'packet' may be nonnull to trace an actual packet, with consequent + * side effects (if it is nonnull then its flow must be 'flow'). + * + * If 'ofpacts' is nonnull then its 'ofpacts_len' bytes specify the actions to + * trace, otherwise the actions are determined by a flow table lookup. */ static void ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow, - const struct ofpbuf *packet, struct ds *ds) + const struct ofpbuf *packet, + const struct ofpact ofpacts[], size_t ofpacts_len, + struct ds *ds) { struct rule_dpif *rule; struct flow_wildcards wc; + ds_put_format(ds, "Bridge: %s\n", ofproto->up.name); ds_put_cstr(ds, "Flow: "); flow_format(ds, flow); ds_put_char(ds, '\n'); flow_wildcards_init_catchall(&wc); - rule_dpif_lookup(ofproto, flow, &wc, &rule); + if (ofpacts) { + rule = NULL; + } else { + rule_dpif_lookup(ofproto, flow, &wc, &rule); - trace_format_rule(ds, 0, rule); - if (rule == ofproto->miss_rule) { - ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n"); - } else if (rule == ofproto->no_packet_in_rule) { - ds_put_cstr(ds, "\nNo match, packets dropped because " - "OFPPC_NO_PACKET_IN is set on in_port.\n"); - } else if (rule == ofproto->drop_frags_rule) { - ds_put_cstr(ds, "\nPackets dropped because they are IP fragments " - "and the fragment handling mode is \"drop\".\n"); + trace_format_rule(ds, 0, rule); + if (rule == ofproto->miss_rule) { + ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n"); + } else if (rule == ofproto->no_packet_in_rule) { + ds_put_cstr(ds, "\nNo match, packets dropped because " + "OFPPC_NO_PACKET_IN is set on in_port.\n"); + } else if (rule == ofproto->drop_frags_rule) { + ds_put_cstr(ds, "\nPackets dropped because they are IP fragments " + "and the fragment handling mode is \"drop\".\n"); + } } - if (rule) { + if (rule || ofpacts) { uint64_t odp_actions_stub[1024 / 8]; struct ofpbuf odp_actions; struct trace_ctx trace; struct match match; - uint8_t tcp_flags; + uint16_t tcp_flags; tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0; trace.result = ds; @@ -5525,6 +5605,10 @@ ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow, ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub); xlate_in_init(&trace.xin, ofproto, flow, rule, tcp_flags, packet); + if (ofpacts) { + trace.xin.ofpacts = ofpacts; + trace.xin.ofpacts_len = ofpacts_len; + } trace.xin.resubmit_hook = trace_resubmit; trace.xin.report_hook = trace_report; @@ -5544,27 +5628,19 @@ ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow, trace.xout.odp_actions.size); if (trace.xout.slow) { + enum slow_path_reason slow; + ds_put_cstr(ds, "\nThis flow is handled by the userspace " "slow path because it:"); - switch (trace.xout.slow) { - case SLOW_CFM: - ds_put_cstr(ds, "\n\t- Consists of CFM packets."); - break; - case SLOW_LACP: - ds_put_cstr(ds, "\n\t- Consists of LACP packets."); - break; - case SLOW_STP: - ds_put_cstr(ds, "\n\t- Consists of STP packets."); - break; - case SLOW_BFD: - ds_put_cstr(ds, "\n\t- Consists of BFD packets."); - break; - case SLOW_CONTROLLER: - ds_put_cstr(ds, "\n\t- Sends \"packet-in\" messages " - "to the OpenFlow controller."); - break; - case __SLOW_MAX: - NOT_REACHED(); + + slow = trace.xout.slow; + while (slow) { + enum slow_path_reason bit = rightmost_1bit(slow); + + ds_put_format(ds, "\n\t- %s.", + slow_path_reason_to_explanation(bit)); + + slow &= ~bit; } } @@ -5669,14 +5745,6 @@ ofproto_unixctl_dpif_dump_dps(struct unixctl_conn *conn, int argc OVS_UNUSED, ds_destroy(&ds); } -static void -show_dp_rates(struct ds *ds, const char *heading, - const struct avg_subfacet_rates *rates) -{ - ds_put_format(ds, "%s add rate: %5.3f/min, del rate: %5.3f/min\n", - heading, rates->add_rate, rates->del_rate); -} - static void dpif_show_backer(const struct dpif_backer *backer, struct ds *ds) { @@ -5684,7 +5752,6 @@ dpif_show_backer(const struct dpif_backer *backer, struct ds *ds) struct ofproto_dpif *ofproto; struct shash ofproto_shash; uint64_t n_hit, n_missed; - long long int minutes; size_t i; n_hit = n_missed = 0; @@ -5697,20 +5764,11 @@ dpif_show_backer(const struct dpif_backer *backer, struct ds *ds) ds_put_format(ds, "%s: hit:%"PRIu64" missed:%"PRIu64"\n", dpif_name(backer->dpif), n_hit, n_missed); - ds_put_format(ds, "\tflows: cur: %zu, avg: %u, max: %u," + ds_put_format(ds, "\tflows: cur: %"PRIuSIZE", avg: %u, max: %u," " life span: %lldms\n", hmap_count(&backer->subfacets), backer->avg_n_subfacet, backer->max_n_subfacet, backer->avg_subfacet_life); - minutes = (time_msec() - backer->created) / (1000 * 60); - if (minutes >= 60) { - show_dp_rates(ds, "\thourly avg:", &backer->hourly); - } - if (minutes >= 60 * 24) { - show_dp_rates(ds, "\tdaily avg:", &backer->daily); - } - show_dp_rates(ds, "\toverall avg:", &backer->lifetime); - shash_init(&ofproto_shash); ofprotos = get_ofprotos(&ofproto_shash); for (i = 0; i < shash_count(&ofproto_shash); i++) { @@ -5817,7 +5875,7 @@ ofproto_unixctl_dpif_dump_megaflows(struct unixctl_conn *conn, CLS_CURSOR_FOR_EACH (facet, cr, &cursor) { cls_rule_format(&facet->cr, &ds); ds_put_cstr(&ds, ", "); - ds_put_format(&ds, "n_subfacets:%zu, ", list_size(&facet->subfacets)); + ds_put_format(&ds, "n_subfacets:%"PRIuSIZE", ", list_size(&facet->subfacets)); ds_put_format(&ds, "used:%.3fs, ", (now - facet->used) / 1000.0); ds_put_cstr(&ds, "Datapath actions: "); if (facet->xout.slow) { @@ -5917,7 +5975,7 @@ ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn, } odp_flow_format(subfacet->key, subfacet->key_len, - mask.data, mask.size, &ds, false); + mask.data, mask.size, NULL, &ds, false); ds_put_format(&ds, ", packets:%"PRIu64", bytes:%"PRIu64", used:", subfacet->dp_packet_count, subfacet->dp_byte_count); @@ -5984,8 +6042,12 @@ ofproto_dpif_unixctl_init(void) unixctl_command_register( "ofproto/trace", - "[dp_name]|bridge odp_flow|br_flow [-generate|packet]", + "{[dp_name] odp_flow | bridge br_flow} [-generate|packet]", 1, 3, ofproto_unixctl_trace, NULL); + unixctl_command_register( + "ofproto/trace-packet-out", + "[-consistent] {[dp_name] odp_flow | bridge br_flow} [-generate|packet] actions", + 2, 6, ofproto_unixctl_trace_actions, NULL); unixctl_command_register("fdb/flush", "[bridge]", 0, 1, ofproto_unixctl_fdb_flush, NULL); unixctl_command_register("fdb/show", "bridge", 1, 1, @@ -6263,51 +6325,6 @@ odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port) } } -/* Compute exponentially weighted moving average, adding 'new' as the newest, - * most heavily weighted element. 'base' designates the rate of decay: after - * 'base' further updates, 'new''s weight in the EWMA decays to about 1/e - * (about .37). */ -static void -exp_mavg(double *avg, int base, double new) -{ - *avg = (*avg * (base - 1) + new) / base; -} - -static void -update_moving_averages(struct dpif_backer *backer) -{ - const int min_ms = 60 * 1000; /* milliseconds in one minute. */ - long long int minutes = (time_msec() - backer->created) / min_ms; - - if (minutes > 0) { - backer->lifetime.add_rate = (double) backer->total_subfacet_add_count - / minutes; - backer->lifetime.del_rate = (double) backer->total_subfacet_del_count - / minutes; - } else { - backer->lifetime.add_rate = 0.0; - backer->lifetime.del_rate = 0.0; - } - - /* Update hourly averages on the minute boundaries. */ - if (time_msec() - backer->last_minute >= min_ms) { - exp_mavg(&backer->hourly.add_rate, 60, backer->subfacet_add_count); - exp_mavg(&backer->hourly.del_rate, 60, backer->subfacet_del_count); - - /* Update daily averages on the hour boundaries. */ - if ((backer->last_minute - backer->created) / min_ms % 60 == 59) { - exp_mavg(&backer->daily.add_rate, 24, backer->hourly.add_rate); - exp_mavg(&backer->daily.del_rate, 24, backer->hourly.del_rate); - } - - backer->total_subfacet_add_count += backer->subfacet_add_count; - backer->total_subfacet_del_count += backer->subfacet_del_count; - backer->subfacet_add_count = 0; - backer->subfacet_del_count = 0; - backer->last_minute += min_ms; - } -} - const struct ofproto_class ofproto_dpif_class = { init, enumerate_types, @@ -6368,6 +6385,7 @@ const struct ofproto_class ofproto_dpif_class = { get_stp_status, set_stp_port, get_stp_port_status, + get_stp_port_stats, set_queues, bundle_set, bundle_remove, @@ -6382,10 +6400,10 @@ const struct ofproto_class ofproto_dpif_class = { NULL, /* meter_set */ NULL, /* meter_get */ NULL, /* meter_del */ - NULL, /* group_alloc */ - NULL, /* group_construct */ - NULL, /* group_destruct */ - NULL, /* group_dealloc */ - NULL, /* group_modify */ - NULL, /* group_get_stats */ + group_alloc, /* group_alloc */ + group_construct, /* group_construct */ + group_destruct, /* group_destruct */ + group_dealloc, /* group_dealloc */ + group_modify, /* group_modify */ + group_get_stats, /* group_get_stats */ };