X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif.c;h=a8e5cd579153a896e76e285bf87a58a7bbd81749;hb=7aaeab4df24b7e9460705b1dad1010eef0354c50;hp=56b17967e6a9cea7f43a99860ae3b60cdbb462fc;hpb=9d189a50e6f8e10d7b68a8646d3b0031075ce82d;p=sliver-openvswitch.git diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c index 56b17967e..a8e5cd579 100644 --- a/ofproto/ofproto-dpif.c +++ b/ofproto/ofproto-dpif.c @@ -71,6 +71,7 @@ COVERAGE_DEFINE(facet_revalidate); COVERAGE_DEFINE(facet_unexpected); COVERAGE_DEFINE(facet_suppress); COVERAGE_DEFINE(subfacet_install_fail); +COVERAGE_DEFINE(flow_mod_overflow); /* Number of implemented OpenFlow tables. */ enum { N_TABLES = 255 }; @@ -298,7 +299,9 @@ struct ofport_dpif { enum stp_state stp_state; /* Always STP_DISABLED if STP not in use. */ long long int stp_state_entered; - struct hmap priorities; /* Map of attached 'priority_to_dscp's. */ + /* Queue to DSCP mapping. */ + struct ofproto_port_queue *qdscp; + size_t n_qdscp; /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) * @@ -310,16 +313,6 @@ struct ofport_dpif { int vlandev_vid; }; -/* Node in 'ofport_dpif''s 'priorities' map. Used to maintain a map from - * 'priority' (the datapath's term for QoS queue) to the dscp bits which all - * traffic egressing the 'ofport' with that priority should be marked with. */ -struct priority_to_dscp { - struct hmap_node hmap_node; /* Node in 'ofport_dpif''s 'priorities' map. */ - uint32_t priority; /* Priority of this queue (see struct flow). */ - - uint8_t dscp; /* DSCP bits to mark outgoing traffic with. */ -}; - /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) * * This is deprecated. It is only for compatibility with broken device drivers @@ -334,7 +327,6 @@ struct vlan_splinter { int vid; }; -static bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *); static void vsp_remove(struct ofport_dpif *); static void vsp_add(struct ofport_dpif *, ofp_port_t realdev_ofp_port, int vid); @@ -355,9 +347,9 @@ 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_clear_priorities(struct ofport_dpif *); static void ofport_update_peer(struct ofport_dpif *); static void run_fast_rl(void); +static int run_fast(struct ofproto *); struct dpif_completion { struct list list_node; @@ -409,7 +401,9 @@ struct dpif_backer { int refcount; struct dpif *dpif; struct timer next_expiration; - struct hmap odp_to_ofport_map; /* ODP port to ofport mapping. */ + + struct ovs_rwlock odp_to_ofport_lock; + struct hmap odp_to_ofport_map OVS_GUARDED; /* ODP port to ofport map. */ struct simap tnl_backers; /* Set of dpif ports backing tunnels. */ @@ -453,8 +447,6 @@ struct dpif_backer { static struct shash all_dpif_backers = SHASH_INITIALIZER(&all_dpif_backers); static void drop_key_clear(struct dpif_backer *); -static struct ofport_dpif * -odp_port_to_ofport(const struct dpif_backer *, odp_port_t odp_port); static void update_moving_averages(struct dpif_backer *backer); struct ofproto_dpif { @@ -491,8 +483,9 @@ struct ofproto_dpif { long long int stp_last_tick; /* VLAN splinters. */ - struct hmap realdev_vid_map; /* (realdev,vid) -> vlandev. */ - struct hmap vlandev_map; /* vlandev -> (realdev,vid). */ + struct ovs_mutex vsp_mutex; + struct hmap realdev_vid_map OVS_GUARDED; /* (realdev,vid) -> vlandev. */ + struct hmap vlandev_map OVS_GUARDED; /* vlandev -> (realdev,vid). */ /* Ports. */ struct sset ports; /* Set of standard port names. */ @@ -503,6 +496,11 @@ struct ofproto_dpif { /* Per ofproto's dpif stats. */ uint64_t n_hit; uint64_t n_missed; + + /* Work queues. */ + struct ovs_mutex flow_mod_mutex; + struct list flow_mods OVS_GUARDED; + size_t n_flow_mods OVS_GUARDED; }; /* Defer flow mod completion until "ovs-appctl ofproto/unclog"? (Useful only @@ -527,6 +525,8 @@ 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 *); /* Upcalls. */ #define FLOW_MISS_MAX_BATCH 50 @@ -547,11 +547,23 @@ 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); -int +/* Executes and takes ownership of 'fm'. */ +void ofproto_dpif_flow_mod(struct ofproto_dpif *ofproto, struct ofputil_flow_mod *fm) { - return ofproto_flow_mod(&ofproto->up, fm); + ovs_mutex_lock(&ofproto->flow_mod_mutex); + if (ofproto->n_flow_mods > 1024) { + ovs_mutex_unlock(&ofproto->flow_mod_mutex); + COVERAGE_INC(flow_mod_overflow); + free(fm->ofpacts); + free(fm); + return; + } + + list_push_back(&ofproto->flow_mods, &fm->list_node); + ofproto->n_flow_mods++; + ovs_mutex_unlock(&ofproto->flow_mod_mutex); } void @@ -770,7 +782,8 @@ type_run(const char *type) continue; } - xlate_ofproto_set(ofproto, ofproto->up.name, ofproto->ml, + xlate_ofproto_set(ofproto, ofproto->up.name, + ofproto->backer->dpif, ofproto->ml, ofproto->stp, ofproto->mbridge, ofproto->sflow, ofproto->ipfix, ofproto->up.frag_handling, @@ -794,6 +807,7 @@ type_run(const char *type) ofport->up.ofp_port, ofport->odp_port, 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); } @@ -940,10 +954,12 @@ process_dpif_port_change(struct dpif_backer *backer, const char *devname) /* 'ofport''s datapath port number has changed from * 'ofport->odp_port' to 'port.port_no'. Update our internal data * structures to match. */ + ovs_rwlock_wrlock(&backer->odp_to_ofport_lock); hmap_remove(&backer->odp_to_ofport_map, &ofport->odp_port_node); ofport->odp_port = port.port_no; hmap_insert(&backer->odp_to_ofport_map, &ofport->odp_port_node, hash_odp_port(port.port_no)); + ovs_rwlock_unlock(&backer->odp_to_ofport_lock); backer->need_revalidate = REV_RECONFIGURE; } } @@ -1018,13 +1034,9 @@ run_fast_rl(void) if (time_msec() >= port_rl) { struct ofproto_dpif *ofproto; - struct ofport_dpif *ofport; HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) { - - HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) { - port_run_fast(ofport); - } + run_fast(&ofproto->up); } port_rl = time_msec() + 200; } @@ -1099,6 +1111,7 @@ close_dpif_backer(struct dpif_backer *backer) hmap_destroy(&backer->drop_keys); 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); free(backer->type); @@ -1177,6 +1190,7 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) backer->governor = NULL; backer->refcount = 1; hmap_init(&backer->odp_to_ofport_map); + ovs_rwlock_init(&backer->odp_to_ofport_lock); hmap_init(&backer->drop_keys); hmap_init(&backer->subfacets); timer_set_duration(&backer->next_expiration, 1000); @@ -1260,12 +1274,19 @@ 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->vsp_mutex, PTHREAD_MUTEX_NORMAL); classifier_init(&ofproto->facets); ofproto->consistency_rl = LLONG_MIN; list_init(&ofproto->completions); + ovs_mutex_init(&ofproto->flow_mod_mutex, PTHREAD_MUTEX_NORMAL); + ovs_mutex_lock(&ofproto->flow_mod_mutex); + list_init(&ofproto->flow_mods); + ofproto->n_flow_mods = 0; + ovs_mutex_unlock(&ofproto->flow_mod_mutex); + ofproto_dpif_unixctl_init(); hmap_init(&ofproto->vlandev_map); @@ -1396,6 +1417,7 @@ destruct(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); struct rule_dpif *rule, *next_rule; + struct ofputil_flow_mod *fm, *next_fm; struct oftable *table; ofproto->backer->need_revalidate = REV_RECONFIGURE; @@ -1413,6 +1435,16 @@ destruct(struct ofproto *ofproto_) } } + ovs_mutex_lock(&ofproto->flow_mod_mutex); + LIST_FOR_EACH_SAFE (fm, next_fm, list_node, &ofproto->flow_mods) { + list_remove(&fm->list_node); + ofproto->n_flow_mods--; + free(fm->ofpacts); + free(fm); + } + ovs_mutex_unlock(&ofproto->flow_mod_mutex); + ovs_mutex_destroy(&ofproto->flow_mod_mutex); + mbridge_unref(ofproto->mbridge); netflow_destroy(ofproto->netflow); @@ -1429,6 +1461,8 @@ destruct(struct ofproto *ofproto_) sset_destroy(&ofproto->ghost_ports); sset_destroy(&ofproto->port_poll_set); + ovs_mutex_destroy(&ofproto->vsp_mutex); + close_dpif_backer(ofproto->backer); } @@ -1436,7 +1470,9 @@ static int run_fast(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); + struct ofputil_flow_mod *fm, *next; struct ofport_dpif *ofport; + struct list flow_mods; /* Do not perform any periodic activity required by 'ofproto' while * waiting for flow restore to complete. */ @@ -1444,6 +1480,29 @@ run_fast(struct ofproto *ofproto_) return 0; } + ovs_mutex_lock(&ofproto->flow_mod_mutex); + if (ofproto->n_flow_mods) { + flow_mods = ofproto->flow_mods; + list_moved(&flow_mods); + list_init(&ofproto->flow_mods); + ofproto->n_flow_mods = 0; + } else { + list_init(&flow_mods); + } + ovs_mutex_unlock(&ofproto->flow_mod_mutex); + + LIST_FOR_EACH_SAFE (fm, next, 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); + } + HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) { port_run_fast(ofport); } @@ -1688,7 +1747,8 @@ port_construct(struct ofport *port_) port->stp_state = STP_DISABLED; port->is_tunnel = false; port->peer = NULL; - hmap_init(&port->priorities); + port->qdscp = NULL; + port->n_qdscp = 0; port->realdev_ofp_port = 0; port->vlandev_vid = 0; port->carrier_seq = netdev_get_carrier_resets(netdev); @@ -1727,8 +1787,10 @@ port_construct(struct ofport *port_) return EBUSY; } + ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock); hmap_insert(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node, hash_odp_port(port->odp_port)); + ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock); } dpif_port_destroy(&dpif_port); @@ -1769,7 +1831,9 @@ port_destruct(struct ofport *port_) } if (port->odp_port != ODPP_NONE && !port->is_tunnel) { + ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock); hmap_remove(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node); + ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock); } tnl_port_del(port); @@ -1782,8 +1846,7 @@ port_destruct(struct ofport *port_) dpif_sflow_del_port(ofproto->sflow, port->odp_port); } - ofport_clear_priorities(port); - hmap_destroy(&port->priorities); + free(port->qdscp); } static void @@ -2179,95 +2242,24 @@ stp_wait(struct ofproto_dpif *ofproto) } } -int -ofproto_dpif_queue_to_priority(const struct ofproto_dpif *ofproto, - uint32_t queue_id, uint32_t *priority) -{ - return dpif_queue_to_priority(ofproto->backer->dpif, queue_id, priority); -} - -static struct priority_to_dscp * -get_priority(const struct ofport_dpif *ofport, uint32_t priority) -{ - struct priority_to_dscp *pdscp; - uint32_t hash; - - hash = hash_int(priority, 0); - HMAP_FOR_EACH_IN_BUCKET (pdscp, hmap_node, hash, &ofport->priorities) { - if (pdscp->priority == priority) { - return pdscp; - } - } - return NULL; -} - -bool -ofproto_dpif_dscp_from_priority(const struct ofport_dpif *ofport, - uint32_t priority, uint8_t *dscp) -{ - struct priority_to_dscp *pdscp = get_priority(ofport, priority); - *dscp = pdscp ? pdscp->dscp : 0; - return pdscp != NULL; -} - -static void -ofport_clear_priorities(struct ofport_dpif *ofport) -{ - struct priority_to_dscp *pdscp, *next; - - HMAP_FOR_EACH_SAFE (pdscp, next, hmap_node, &ofport->priorities) { - hmap_remove(&ofport->priorities, &pdscp->hmap_node); - free(pdscp); - } -} - static int -set_queues(struct ofport *ofport_, - const struct ofproto_port_queue *qdscp_list, +set_queues(struct ofport *ofport_, const struct ofproto_port_queue *qdscp, size_t n_qdscp) { struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); - struct hmap new = HMAP_INITIALIZER(&new); - size_t i; - - for (i = 0; i < n_qdscp; i++) { - struct priority_to_dscp *pdscp; - uint32_t priority; - uint8_t dscp; - - dscp = (qdscp_list[i].dscp << 2) & IP_DSCP_MASK; - if (dpif_queue_to_priority(ofproto->backer->dpif, qdscp_list[i].queue, - &priority)) { - continue; - } - pdscp = get_priority(ofport, priority); - if (pdscp) { - hmap_remove(&ofport->priorities, &pdscp->hmap_node); - } else { - pdscp = xmalloc(sizeof *pdscp); - pdscp->priority = priority; - pdscp->dscp = dscp; - ofproto->backer->need_revalidate = REV_RECONFIGURE; - } - - if (pdscp->dscp != dscp) { - pdscp->dscp = dscp; - ofproto->backer->need_revalidate = REV_RECONFIGURE; - } - - hmap_insert(&new, &pdscp->hmap_node, hash_int(pdscp->priority, 0)); - } - - if (!hmap_is_empty(&ofport->priorities)) { - ofport_clear_priorities(ofport); + if (ofport->n_qdscp != n_qdscp + || (n_qdscp && memcmp(ofport->qdscp, qdscp, + n_qdscp * sizeof *qdscp))) { ofproto->backer->need_revalidate = REV_RECONFIGURE; + free(ofport->qdscp); + ofport->qdscp = n_qdscp + ? xmemdup(qdscp, n_qdscp * sizeof *qdscp) + : NULL; + ofport->n_qdscp = n_qdscp; } - hmap_swap(&new, &ofport->priorities); - hmap_destroy(&new); - return 0; } @@ -3475,7 +3467,7 @@ handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet, subfacet_update_stats(subfacet, stats); } - if (miss->upcall_type == DPIF_UC_MISS || subfacet->path != want_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; @@ -3606,98 +3598,6 @@ drop_key_clear(struct dpif_backer *backer) } } -/* Given a datpath, packet, and flow metadata ('backer', 'packet', and 'key' - * respectively), populates 'flow' with the result of odp_flow_key_to_flow(). - * Optionally, if nonnull, populates 'fitnessp' with the fitness of 'flow' as - * returned by odp_flow_key_to_flow(). Also, optionally populates 'ofproto' - * with the ofproto_dpif, and 'odp_in_port' with the datapath in_port, that - * 'packet' ingressed. - * - * If 'ofproto' is nonnull, requires 'flow''s in_port to exist. Otherwise sets - * 'flow''s in_port to OFPP_NONE. - * - * This function does post-processing on data returned from - * odp_flow_key_to_flow() to help make VLAN splinters transparent to the rest - * of the upcall processing logic. In particular, if the extracted in_port is - * a VLAN splinter port, it replaces flow->in_port by the "real" port, sets - * flow->vlan_tci correctly for the VLAN of the VLAN splinter port, and pushes - * a VLAN header onto 'packet' (if it is nonnull). - * - * Similarly, this function also includes some logic to help with tunnels. It - * may modify 'flow' as necessary to make the tunneling implementation - * transparent to the upcall processing logic. - * - * Returns 0 if successful, ENODEV if the parsed flow has no associated ofport, - * or some other positive errno if there are other problems. */ -static int -ofproto_receive(const struct dpif_backer *backer, struct ofpbuf *packet, - const struct nlattr *key, size_t key_len, - struct flow *flow, enum odp_key_fitness *fitnessp, - struct ofproto_dpif **ofproto, odp_port_t *odp_in_port) -{ - const struct ofport_dpif *port; - enum odp_key_fitness fitness; - int error = ENODEV; - - fitness = odp_flow_key_to_flow(key, key_len, flow); - if (fitness == ODP_FIT_ERROR) { - error = EINVAL; - goto exit; - } - - if (odp_in_port) { - *odp_in_port = flow->in_port.odp_port; - } - - port = (tnl_port_should_receive(flow) - ? tnl_port_receive(flow) - : odp_port_to_ofport(backer, flow->in_port.odp_port)); - flow->in_port.ofp_port = port ? port->up.ofp_port : OFPP_NONE; - if (!port) { - goto exit; - } - - /* XXX: Since the tunnel module is not scoped per backer, for a tunnel port - * it's theoretically possible that we'll receive an ofport belonging to an - * entirely different datapath. In practice, this can't happen because no - * platforms has two separate datapaths which each support tunneling. */ - ovs_assert(ofproto_dpif_cast(port->up.ofproto)->backer == backer); - - if (vsp_adjust_flow(ofproto_dpif_cast(port->up.ofproto), flow)) { - if (packet) { - /* Make the packet resemble the flow, so that it gets sent to - * an OpenFlow controller properly, so that it looks correct - * for sFlow, and so that flow_extract() will get the correct - * vlan_tci if it is called on 'packet'. - * - * The allocated space inside 'packet' probably also contains - * 'key', that is, both 'packet' and 'key' are probably part of - * a struct dpif_upcall (see the large comment on that - * structure definition), so pushing data on 'packet' is in - * general not a good idea since it could overwrite 'key' or - * free it as a side effect. However, it's OK in this special - * case because we know that 'packet' is inside a Netlink - * attribute: pushing 4 bytes will just overwrite the 4-byte - * "struct nlattr", which is fine since we don't need that - * header anymore. */ - eth_push_vlan(packet, flow->vlan_tci); - } - /* We can't reproduce 'key' from 'flow'. */ - fitness = fitness == ODP_FIT_PERFECT ? ODP_FIT_TOO_MUCH : fitness; - } - error = 0; - - if (ofproto) { - *ofproto = ofproto_dpif_cast(port->up.ofproto); - } - -exit: - if (fitnessp) { - *fitnessp = fitness; - } - return error; -} - static void handle_miss_upcalls(struct dpif_backer *backer, struct dpif_upcall *upcalls, size_t n_upcalls) @@ -3732,9 +3632,9 @@ handle_miss_upcalls(struct dpif_backer *backer, struct dpif_upcall *upcalls, uint32_t hash; int error; - error = ofproto_receive(backer, upcall->packet, upcall->key, - upcall->key_len, &flow, &miss->key_fitness, - &ofproto, &odp_in_port); + error = xlate_receive(backer, upcall->packet, upcall->key, + upcall->key_len, &flow, &miss->key_fitness, + &ofproto, &odp_in_port); if (error == ENODEV) { struct drop_key *drop_key; @@ -3900,8 +3800,8 @@ handle_sflow_upcall(struct dpif_backer *backer, struct flow flow; odp_port_t odp_in_port; - if (ofproto_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, &odp_in_port) + if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, + &flow, NULL, &ofproto, &odp_in_port) || !ofproto->sflow) { return; } @@ -3920,8 +3820,8 @@ handle_flow_sample_upcall(struct dpif_backer *backer, union user_action_cookie cookie; struct flow flow; - if (ofproto_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, NULL) + if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, + &flow, NULL, &ofproto, NULL) || !ofproto->ipfix) { return; } @@ -3945,8 +3845,8 @@ handle_ipfix_upcall(struct dpif_backer *backer, struct ofproto_dpif *ofproto; struct flow flow; - if (ofproto_receive(backer, upcall->packet, upcall->key, upcall->key_len, - &flow, NULL, &ofproto, NULL) + if (xlate_receive(backer, upcall->packet, upcall->key, upcall->key_len, + &flow, NULL, &ofproto, NULL) || !ofproto->ipfix) { return; } @@ -4700,7 +4600,7 @@ facet_check_consistency(struct facet *facet) * where it is and recompiles its actions anyway. * * - If any of 'facet''s subfacets correspond to a new flow according to - * ofproto_receive(), 'facet' is removed. + * xlate_receive(), 'facet' is removed. * * Returns true if 'facet' is still valid. False if 'facet' was removed. */ static bool @@ -4723,9 +4623,9 @@ facet_revalidate(struct facet *facet) struct flow recv_flow; int error; - error = ofproto_receive(ofproto->backer, NULL, subfacet->key, - subfacet->key_len, &recv_flow, NULL, - &recv_ofproto, NULL); + error = xlate_receive(ofproto->backer, NULL, subfacet->key, + subfacet->key_len, &recv_flow, NULL, + &recv_ofproto, NULL); if (error || recv_ofproto != ofproto || facet != facet_find(ofproto, &recv_flow)) { @@ -4883,9 +4783,11 @@ push_all_stats(void) void rule_credit_stats(struct rule_dpif *rule, const struct dpif_flow_stats *stats) { + ovs_mutex_lock(&rule->stats_mutex); rule->packet_count += stats->n_packets; rule->byte_count += stats->n_bytes; ofproto_rule_update_used(&rule->up, stats->used); + ovs_mutex_unlock(&rule->stats_mutex); } /* Subfacets. */ @@ -5243,16 +5145,21 @@ static enum ofperr rule_construct(struct rule *rule_) { struct rule_dpif *rule = rule_dpif_cast(rule_); + ovs_mutex_init(&rule->stats_mutex, PTHREAD_MUTEX_NORMAL); + ovs_mutex_lock(&rule->stats_mutex); rule->packet_count = 0; rule->byte_count = 0; + ovs_mutex_unlock(&rule->stats_mutex); complete_operation(rule); return 0; } static void -rule_destruct(struct rule *rule) +rule_destruct(struct rule *rule_) { - complete_operation(rule_dpif_cast(rule)); + struct rule_dpif *rule = rule_dpif_cast(rule_); + complete_operation(rule); + ovs_mutex_destroy(&rule->stats_mutex); } static void @@ -5268,8 +5175,10 @@ rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes) /* Start from historical data for 'rule' itself that are no longer tracked * in facets. This counts, for example, facets that have expired. */ + ovs_mutex_lock(&rule->stats_mutex); *packets = rule->packet_count; *bytes = rule->byte_count; + ovs_mutex_unlock(&rule->stats_mutex); } static void @@ -5395,28 +5304,16 @@ compose_slow_path(const struct ofproto_dpif *ofproto, const struct flow *flow, ODPP_NONE); odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf); } else { - put_userspace_action(ofproto, &buf, flow, &cookie, - sizeof cookie.slow_path); + odp_port_t odp_port; + uint32_t pid; + + odp_port = ofp_port_to_odp_port(ofproto, flow->in_port.ofp_port); + pid = dpif_port_get_pid(ofproto->backer->dpif, odp_port); + odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf); } *actionsp = buf.data; *actions_lenp = buf.size; } - -size_t -put_userspace_action(const struct ofproto_dpif *ofproto, - struct ofpbuf *odp_actions, - const struct flow *flow, - const union user_action_cookie *cookie, - const size_t cookie_size) -{ - uint32_t pid; - - pid = dpif_port_get_pid(ofproto->backer->dpif, - ofp_port_to_odp_port(ofproto, - flow->in_port.ofp_port)); - - return odp_put_userspace_action(pid, cookie, cookie_size, odp_actions); -} static bool set_frag_handling(struct ofproto *ofproto_, @@ -5770,10 +5667,8 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], backer = node->data; } - /* Extract the ofproto_dpif object from the ofproto_receive() - * function. */ - if (ofproto_receive(backer, NULL, odp_key.data, - odp_key.size, &flow, NULL, &ofproto, NULL)) { + if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, &flow, + NULL, &ofproto, NULL)) { unixctl_command_reply_error(conn, "Invalid datapath flow"); goto exit; } @@ -5824,7 +5719,7 @@ exit: ofpbuf_uninit(&odp_mask); } -void +static void ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow, const struct ofpbuf *packet, struct ds *ds) { @@ -6261,7 +6156,7 @@ ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn, } odp_flow_format(subfacet->key, subfacet->key_len, - mask.data, mask.size, &ds); + mask.data, mask.size, &ds, false); ds_put_format(&ds, ", packets:%"PRIu64", bytes:%"PRIu64", used:", subfacet->dp_packet_count, subfacet->dp_byte_count); @@ -6403,20 +6298,20 @@ hash_realdev_vid(ofp_port_t realdev_ofp_port, int vid) bool ofproto_has_vlan_splinters(const struct ofproto_dpif *ofproto) + OVS_EXCLUDED(ofproto->vsp_mutex) { - return !hmap_is_empty(&ofproto->realdev_vid_map); + bool ret; + + ovs_mutex_lock(&ofproto->vsp_mutex); + ret = !hmap_is_empty(&ofproto->realdev_vid_map); + ovs_mutex_unlock(&ofproto->vsp_mutex); + return ret; } -/* Returns the OFP port number of the Linux VLAN device that corresponds to - * 'vlan_tci' on the network device with port number 'realdev_ofp_port' in - * 'struct ofport_dpif'. For example, given 'realdev_ofp_port' of eth0 and - * 'vlan_tci' 9, it would return the port number of eth0.9. - * - * Unless VLAN splinters are enabled for port 'realdev_ofp_port', this - * function just returns its 'realdev_ofp_port' argument. */ -ofp_port_t -vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto, - ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci) +static ofp_port_t +vsp_realdev_to_vlandev__(const struct ofproto_dpif *ofproto, + ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci) + OVS_REQUIRES(ofproto->vsp_mutex) { if (!hmap_is_empty(&ofproto->realdev_vid_map)) { int vid = vlan_tci_to_vid(vlan_tci); @@ -6434,6 +6329,26 @@ vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto, return realdev_ofp_port; } +/* Returns the OFP port number of the Linux VLAN device that corresponds to + * 'vlan_tci' on the network device with port number 'realdev_ofp_port' in + * 'struct ofport_dpif'. For example, given 'realdev_ofp_port' of eth0 and + * 'vlan_tci' 9, it would return the port number of eth0.9. + * + * Unless VLAN splinters are enabled for port 'realdev_ofp_port', this + * function just returns its 'realdev_ofp_port' argument. */ +ofp_port_t +vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto, + ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci) + OVS_EXCLUDED(ofproto->vsp_mutex) +{ + ofp_port_t ret; + + ovs_mutex_lock(&ofproto->vsp_mutex); + ret = vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, vlan_tci); + ovs_mutex_unlock(&ofproto->vsp_mutex); + return ret; +} + static struct vlan_splinter * vlandev_find(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port) { @@ -6462,6 +6377,7 @@ vlandev_find(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port) static ofp_port_t vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port, int *vid) + OVS_REQ_WRLOCK(ofproto->vsp_mutex) { if (!hmap_is_empty(&ofproto->vlandev_map)) { const struct vlan_splinter *vsp; @@ -6483,13 +6399,16 @@ vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto, * 'flow->vlan_tci' to the VLAN VID, and returns true. Otherwise (which is * always the case unless VLAN splinters are enabled), returns false without * making any changes. */ -static bool +bool vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow) + OVS_EXCLUDED(ofproto->vsp_mutex) { ofp_port_t realdev; int vid; + ovs_mutex_lock(&ofproto->vsp_mutex); realdev = vsp_vlandev_to_realdev(ofproto, flow->in_port.ofp_port, &vid); + ovs_mutex_unlock(&ofproto->vsp_mutex); if (!realdev) { return false; } @@ -6507,6 +6426,7 @@ vsp_remove(struct ofport_dpif *port) struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto); struct vlan_splinter *vsp; + ovs_mutex_lock(&ofproto->vsp_mutex); vsp = vlandev_find(ofproto, port->up.ofp_port); if (vsp) { hmap_remove(&ofproto->vlandev_map, &vsp->vlandev_node); @@ -6517,6 +6437,7 @@ vsp_remove(struct ofport_dpif *port) } else { VLOG_ERR("missing vlan device record"); } + ovs_mutex_unlock(&ofproto->vsp_mutex); } static void @@ -6524,24 +6445,27 @@ vsp_add(struct ofport_dpif *port, ofp_port_t realdev_ofp_port, int vid) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto); + ovs_mutex_lock(&ofproto->vsp_mutex); if (!vsp_vlandev_to_realdev(ofproto, port->up.ofp_port, NULL) - && (vsp_realdev_to_vlandev(ofproto, realdev_ofp_port, htons(vid)) + && (vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, htons(vid)) == realdev_ofp_port)) { struct vlan_splinter *vsp; vsp = xmalloc(sizeof *vsp); - hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node, - hash_ofp_port(port->up.ofp_port)); - hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node, - hash_realdev_vid(realdev_ofp_port, vid)); vsp->realdev_ofp_port = realdev_ofp_port; vsp->vlandev_ofp_port = port->up.ofp_port; vsp->vid = vid; port->realdev_ofp_port = realdev_ofp_port; + + hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node, + hash_ofp_port(port->up.ofp_port)); + hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node, + hash_realdev_vid(realdev_ofp_port, vid)); } else { VLOG_ERR("duplicate vlan device record"); } + ovs_mutex_unlock(&ofproto->vsp_mutex); } static odp_port_t @@ -6551,18 +6475,21 @@ ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port) return ofport ? ofport->odp_port : ODPP_NONE; } -static struct ofport_dpif * +struct ofport_dpif * odp_port_to_ofport(const struct dpif_backer *backer, odp_port_t odp_port) { struct ofport_dpif *port; + ovs_rwlock_rdlock(&backer->odp_to_ofport_lock); HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node, hash_odp_port(odp_port), &backer->odp_to_ofport_map) { if (port->odp_port == odp_port) { + ovs_rwlock_unlock(&backer->odp_to_ofport_lock); return port; } } + ovs_rwlock_unlock(&backer->odp_to_ofport_lock); return NULL; }