X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=acf504f5d6f30b006d3da5a879d4673ea552600f;hb=f08e39dd023ff27c32166b76d6906fbf20f78991;hp=bf4be5ee8caa384ab7233c710be48d73548ff84b;hpb=f5d16e557ffe376a23ac3fd2cf1a7bcab2013ec2;p=cascardo%2Fovs.git diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index bf4be5ee8..acf504f5d 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2009-2015 Nicira, Inc. * Copyright (c) 2010 Jean Tourrilhes - HP-Labs. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -44,6 +44,7 @@ #include "openflow/nicira-ext.h" #include "openflow/openflow.h" #include "ovs-rcu.h" +#include "dp-packet.h" #include "packets.h" #include "pinsched.h" #include "pktbuf.h" @@ -55,9 +56,10 @@ #include "smap.h" #include "sset.h" #include "timeval.h" +#include "tun-metadata.h" #include "unaligned.h" #include "unixctl.h" -#include "vlog.h" +#include "openvswitch/vlog.h" #include "bundles.h" VLOG_DEFINE_THIS_MODULE(ofproto); @@ -80,18 +82,13 @@ static void oftable_destroy(struct oftable *); static void oftable_set_name(struct oftable *, const char *name); -static enum ofperr evict_rules_from_table(struct oftable *, - unsigned int extra_space) +static enum ofperr evict_rules_from_table(struct oftable *) OVS_REQUIRES(ofproto_mutex); static void oftable_disable_eviction(struct oftable *); static void oftable_enable_eviction(struct oftable *, const struct mf_subfield *fields, size_t n_fields); -static void oftable_remove_rule(struct rule *rule) OVS_REQUIRES(ofproto_mutex); -static void oftable_remove_rule__(struct ofproto *, struct rule *) - OVS_REQUIRES(ofproto_mutex); - /* A set of rules within a single OpenFlow table (oftable) that have the same * values for the oftable's eviction_fields. A rule to be evicted, when one is * needed, is taken from the eviction group that contains the greatest number @@ -153,8 +150,8 @@ struct rule_criteria { }; static void rule_criteria_init(struct rule_criteria *, uint8_t table_id, - const struct match *match, - unsigned int priority, + const struct match *match, int priority, + cls_version_t version, ovs_be64 cookie, ovs_be64 cookie_mask, ofp_port_t out_port, uint32_t out_group); static void rule_criteria_require_rw(struct rule_criteria *, @@ -170,10 +167,10 @@ static enum ofperr collect_rules_loose(struct ofproto *, * (We can't do this immediately from ofopgroup_complete() because that holds * ofproto_mutex, which rule_execute() needs released.) */ struct rule_execute { - struct list list_node; /* In struct ofproto's "rule_executes" list. */ + struct ovs_list list_node; /* In struct ofproto's "rule_executes" list. */ struct rule *rule; /* Owns a reference to the rule. */ ofp_port_t in_port; - struct ofpbuf *packet; /* Owns the packet. */ + struct dp_packet *packet; /* Owns the packet. */ }; static void run_rule_executes(struct ofproto *) OVS_EXCLUDED(ofproto_mutex); @@ -185,7 +182,7 @@ struct learned_cookie { struct hmap_node hmap_node OVS_GUARDED_BY(ofproto_mutex); /* In 'dead_cookies' list when removed from hmap. */ - struct list list_node; + struct ovs_list list_node; } u; /* Key. */ @@ -205,9 +202,9 @@ static const struct ofpact_learn *next_learn_with_delete( static void learned_cookies_inc(struct ofproto *, const struct rule_actions *) OVS_REQUIRES(ofproto_mutex); static void learned_cookies_dec(struct ofproto *, const struct rule_actions *, - struct list *dead_cookies) + struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex); -static void learned_cookies_flush(struct ofproto *, struct list *dead_cookies) +static void learned_cookies_flush(struct ofproto *, struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex); /* ofport. */ @@ -236,8 +233,13 @@ struct ofport_usage { }; /* rule. */ -static void ofproto_rule_send_removed(struct rule *, uint8_t reason); +static void ofproto_rule_send_removed(struct rule *) + OVS_EXCLUDED(ofproto_mutex); static bool rule_is_readonly(const struct rule *); +static void ofproto_rule_insert__(struct ofproto *, struct rule *) + OVS_REQUIRES(ofproto_mutex); +static void ofproto_rule_remove__(struct ofproto *, struct rule *) + OVS_REQUIRES(ofproto_mutex); /* The source of a flow_mod request, in the code that processes flow_mods. * @@ -247,23 +249,39 @@ static bool rule_is_readonly(const struct rule *); * meaningful and thus supplied as NULL. */ struct flow_mod_requester { struct ofconn *ofconn; /* Connection on which flow_mod arrived. */ - ovs_be32 xid; /* OpenFlow xid of flow_mod request. */ + const struct ofp_header *request; }; /* OpenFlow. */ -static enum ofperr add_flow(struct ofproto *, struct ofputil_flow_mod *, - const struct flow_mod_requester *); +static enum ofperr replace_rule_create(struct ofproto *, + struct ofputil_flow_mod *, + struct cls_rule *cr, uint8_t table_id, + struct rule *old_rule, + struct rule **new_rule) + OVS_REQUIRES(ofproto_mutex); + +static void replace_rule_start(struct ofproto *, + struct rule *old_rule, + struct rule *new_rule, + struct cls_conjunction *, size_t n_conjs) + OVS_REQUIRES(ofproto_mutex); + +static void replace_rule_revert(struct ofproto *, struct rule *old_rule, + struct rule *new_rule) + OVS_REQUIRES(ofproto_mutex); -static enum ofperr modify_flows__(struct ofproto *, struct ofputil_flow_mod *, - const struct rule_collection *, - const struct flow_mod_requester *); -static void delete_flows__(const struct rule_collection *, +static void replace_rule_finish(struct ofproto *, struct ofputil_flow_mod *, + const struct flow_mod_requester *, + struct rule *old_rule, struct rule *new_rule, + struct ovs_list *dead_cookies) + OVS_REQUIRES(ofproto_mutex); +static void delete_flows__(struct rule_collection *, enum ofp_flow_removed_reason, const struct flow_mod_requester *) OVS_REQUIRES(ofproto_mutex); -static enum ofperr send_buffered_packet(struct ofconn *, uint32_t buffer_id, - struct rule *) +static void send_buffered_packet(const struct flow_mod_requester *, + uint32_t buffer_id, struct rule *) OVS_REQUIRES(ofproto_mutex); static bool ofproto_group_exists__(const struct ofproto *ofproto, @@ -274,6 +292,15 @@ static bool ofproto_group_exists(const struct ofproto *ofproto, OVS_EXCLUDED(ofproto->groups_rwlock); static enum ofperr add_group(struct ofproto *, struct ofputil_group_mod *); static void handle_openflow(struct ofconn *, const struct ofpbuf *); +static enum ofperr do_bundle_flow_mod_start(struct ofproto *, + struct ofputil_flow_mod *, + struct ofp_bundle_entry *) + OVS_REQUIRES(ofproto_mutex); +static void do_bundle_flow_mod_finish(struct ofproto *, + struct ofputil_flow_mod *, + const struct flow_mod_requester *, + struct ofp_bundle_entry *) + OVS_REQUIRES(ofproto_mutex); static enum ofperr handle_flow_mod__(struct ofproto *, struct ofputil_flow_mod *, const struct flow_mod_requester *) @@ -304,6 +331,8 @@ unsigned ofproto_flow_limit = OFPROTO_FLOW_LIMIT_DEFAULT; unsigned ofproto_max_idle = OFPROTO_MAX_IDLE_DEFAULT; size_t n_handlers, n_revalidators; +size_t n_dpdk_rxqs; +char *pmd_cpu_mask; /* Map from datapath name to struct ofproto, for use by unixctl commands. */ static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos); @@ -458,6 +487,14 @@ ofproto_enumerate_names(const char *type, struct sset *names) return class ? class->enumerate_names(type, names) : EAFNOSUPPORT; } +static void +ofproto_bump_tables_version(struct ofproto *ofproto) +{ + ++ofproto->tables_version; + ofproto->ofproto_class->set_tables_version(ofproto, + ofproto->tables_version); +} + int ofproto_create(const char *datapath_name, const char *datapath_type, struct ofproto **ofprotop) @@ -511,6 +548,7 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->eviction_group_timer = LLONG_MIN; ofproto->tables = NULL; ofproto->n_tables = 0; + ofproto->tables_version = CLS_MIN_VERSION; hindex_init(&ofproto->cookies); hmap_init(&ofproto->learned_cookies); list_init(&ofproto->expirable); @@ -522,35 +560,20 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ovs_rwlock_init(&ofproto->groups_rwlock); hmap_init(&ofproto->groups); ovs_mutex_unlock(&ofproto_mutex); + ofproto->ogf.types = 0xf; ofproto->ogf.capabilities = OFPGFC_CHAINING | OFPGFC_SELECT_LIVENESS | OFPGFC_SELECT_WEIGHT; - ofproto->ogf.max_groups[OFPGT11_ALL] = OFPG_MAX; - ofproto->ogf.max_groups[OFPGT11_SELECT] = OFPG_MAX; - ofproto->ogf.max_groups[OFPGT11_INDIRECT] = OFPG_MAX; - ofproto->ogf.max_groups[OFPGT11_FF] = OFPG_MAX; - ofproto->ogf.actions[0] = - (1 << OFPAT11_OUTPUT) | - (1 << OFPAT11_COPY_TTL_OUT) | - (1 << OFPAT11_COPY_TTL_IN) | - (1 << OFPAT11_SET_MPLS_TTL) | - (1 << OFPAT11_DEC_MPLS_TTL) | - (1 << OFPAT11_PUSH_VLAN) | - (1 << OFPAT11_POP_VLAN) | - (1 << OFPAT11_PUSH_MPLS) | - (1 << OFPAT11_POP_MPLS) | - (1 << OFPAT11_SET_QUEUE) | - (1 << OFPAT11_GROUP) | - (1 << OFPAT11_SET_NW_TTL) | - (1 << OFPAT11_DEC_NW_TTL) | - (1 << OFPAT12_SET_FIELD); -/* not supported: - * (1 << OFPAT13_PUSH_PBB) | - * (1 << OFPAT13_POP_PBB) */ + for (i = 0; i < 4; i++) { + ofproto->ogf.max_groups[i] = OFPG_MAX; + ofproto->ogf.ofpacts[i] = (UINT64_C(1) << N_OFPACTS) - 1; + } + tun_metadata_init(); error = ofproto->ofproto_class->construct(ofproto); if (error) { VLOG_ERR("failed to open datapath %s: %s", datapath_name, ovs_strerror(error)); + connmgr_destroy(ofproto->connmgr); ofproto_destroy__(ofproto); return error; } @@ -577,6 +600,9 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->meters = xzalloc((ofproto->meter_features.max_meters + 1) * sizeof(struct meter *)); + /* Set the initial tables version. */ + ofproto_bump_tables_version(ofproto); + *ofprotop = ofproto; return 0; } @@ -736,18 +762,32 @@ ofproto_set_mcast_snooping(struct ofproto *ofproto, : EOPNOTSUPP); } -/* Configures multicast snooping flood setting on 'ofp_port' of 'ofproto'. +/* Configures multicast snooping flood settings on 'ofp_port' of 'ofproto'. * * Returns 0 if successful, otherwise a positive errno value.*/ int -ofproto_port_set_mcast_snooping(struct ofproto *ofproto, void *aux, bool flood) +ofproto_port_set_mcast_snooping(struct ofproto *ofproto, void *aux, + const struct ofproto_mcast_snooping_port_settings *s) { return (ofproto->ofproto_class->set_mcast_snooping_port - ? ofproto->ofproto_class->set_mcast_snooping_port(ofproto, aux, - flood) + ? ofproto->ofproto_class->set_mcast_snooping_port(ofproto, aux, s) : EOPNOTSUPP); } +void +ofproto_set_n_dpdk_rxqs(int n_rxqs) +{ + n_dpdk_rxqs = MAX(n_rxqs, 0); +} + +void +ofproto_set_cpu_mask(const char *cmask) +{ + free(pmd_cpu_mask); + + pmd_cpu_mask = cmask ? xstrdup(cmask) : NULL; +} + void ofproto_set_threads(int n_handlers_, int n_revalidators_) { @@ -929,6 +969,87 @@ ofproto_port_get_stp_stats(struct ofproto *ofproto, ofp_port_t ofp_port, ? ofproto->ofproto_class->get_stp_port_stats(ofport, s) : EOPNOTSUPP); } + +/* Rapid Spanning Tree Protocol (RSTP) configuration. */ + +/* Configures RSTP on 'ofproto' using the settings defined in 's'. If + * 's' is NULL, disables RSTP. + * + * Returns 0 if successful, otherwise a positive errno value. */ +int +ofproto_set_rstp(struct ofproto *ofproto, + const struct ofproto_rstp_settings *s) +{ + if (!ofproto->ofproto_class->set_rstp) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->set_rstp(ofproto, s); + return 0; +} + +/* Retrieves RSTP status of 'ofproto' and stores it in 's'. If the + * 'enabled' member of 's' is false, then the other members are not + * meaningful. + * + * Returns 0 if successful, otherwise a positive errno value. */ +int +ofproto_get_rstp_status(struct ofproto *ofproto, + struct ofproto_rstp_status *s) +{ + if (!ofproto->ofproto_class->get_rstp_status) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->get_rstp_status(ofproto, s); + return 0; +} + +/* Configures RSTP on 'ofp_port' of 'ofproto' using the settings defined + * in 's'. The caller is responsible for assigning RSTP port numbers + * (using the 'port_num' member in the range of 1 through 255, inclusive) + * and ensuring there are no duplicates. If the 's' is NULL, then RSTP + * is disabled on the port. + * + * Returns 0 if successful, otherwise a positive errno value.*/ +int +ofproto_port_set_rstp(struct ofproto *ofproto, ofp_port_t ofp_port, + const struct ofproto_port_rstp_settings *s) +{ + struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); + if (!ofport) { + VLOG_WARN("%s: cannot configure RSTP on nonexistent port %"PRIu16, + ofproto->name, ofp_port); + return ENODEV; + } + + if (!ofproto->ofproto_class->set_rstp_port) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->set_rstp_port(ofport, s); + return 0; +} + +/* Retrieves RSTP port status of 'ofp_port' on 'ofproto' and stores it in + * 's'. If the 'enabled' member in 's' is false, then the other members + * are not meaningful. + * + * Returns 0 if successful, otherwise a positive errno value.*/ +int +ofproto_port_get_rstp_status(struct ofproto *ofproto, ofp_port_t ofp_port, + struct ofproto_port_rstp_status *s) +{ + struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); + if (!ofport) { + VLOG_WARN_RL(&rl, "%s: cannot get RSTP status on nonexistent " + "port %"PRIu16, ofproto->name, ofp_port); + return ENODEV; + } + + if (!ofproto->ofproto_class->get_rstp_port_status) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->get_rstp_port_status(ofport, s); + return 0; +} /* Queue DSCP configuration. */ @@ -957,6 +1078,83 @@ ofproto_port_set_queues(struct ofproto *ofproto, ofp_port_t ofp_port, : EOPNOTSUPP); } +/* LLDP configuration. */ +void +ofproto_port_set_lldp(struct ofproto *ofproto, + ofp_port_t ofp_port, + const struct smap *cfg) +{ + struct ofport *ofport; + int error; + + ofport = ofproto_get_port(ofproto, ofp_port); + if (!ofport) { + VLOG_WARN("%s: cannot configure LLDP on nonexistent port %"PRIu16, + ofproto->name, ofp_port); + return; + } + error = (ofproto->ofproto_class->set_lldp + ? ofproto->ofproto_class->set_lldp(ofport, cfg) + : EOPNOTSUPP); + if (error) { + VLOG_WARN("%s: lldp configuration on port %"PRIu16" (%s) failed (%s)", + ofproto->name, ofp_port, netdev_get_name(ofport->netdev), + ovs_strerror(error)); + } +} + +int +ofproto_set_aa(struct ofproto *ofproto, void *aux OVS_UNUSED, + const struct aa_settings *s) +{ + if (!ofproto->ofproto_class->set_aa) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->set_aa(ofproto, s); + return 0; +} + +int +ofproto_aa_mapping_register(struct ofproto *ofproto, void *aux, + const struct aa_mapping_settings *s) +{ + if (!ofproto->ofproto_class->aa_mapping_set) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->aa_mapping_set(ofproto, aux, s); + return 0; +} + +int +ofproto_aa_mapping_unregister(struct ofproto *ofproto, void *aux) +{ + if (!ofproto->ofproto_class->aa_mapping_unset) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->aa_mapping_unset(ofproto, aux); + return 0; +} + +int +ofproto_aa_vlan_get_queued(struct ofproto *ofproto, + struct ovs_list *list) +{ + if (!ofproto->ofproto_class->aa_vlan_get_queued) { + return EOPNOTSUPP; + } + ofproto->ofproto_class->aa_vlan_get_queued(ofproto, list); + return 0; +} + +unsigned int +ofproto_aa_vlan_get_queue_size(struct ofproto *ofproto) +{ + if (!ofproto->ofproto_class->aa_vlan_get_queue_size) { + return EOPNOTSUPP; + } + return ofproto->ofproto_class->aa_vlan_get_queue_size(ofproto); +} + /* Connectivity Fault Management configuration. */ /* Clears the CFM configuration from 'ofp_port' on 'ofproto'. */ @@ -1067,6 +1265,21 @@ ofproto_port_is_lacp_current(struct ofproto *ofproto, ofp_port_t ofp_port) ? ofproto->ofproto_class->port_is_lacp_current(ofport) : -1); } + +int +ofproto_port_get_lacp_stats(const struct ofport *port, struct lacp_slave_stats *stats) +{ + struct ofproto *ofproto = port->ofproto; + int error; + + if (ofproto->ofproto_class->port_get_lacp_stats) { + error = ofproto->ofproto_class->port_get_lacp_stats(port, stats); + } else { + error = EOPNOTSUPP; + } + + return error; +} /* Bundles. */ @@ -1122,7 +1335,8 @@ ofproto_mirror_unregister(struct ofproto *ofproto, void *aux) /* Retrieves statistics from mirror associated with client data pointer * 'aux' in 'ofproto'. Stores packet and byte counts in 'packets' and * 'bytes', respectively. If a particular counters is not supported, - * the appropriate argument is set to UINT64_MAX. */ + * the appropriate argument is set to UINT64_MAX. + */ int ofproto_mirror_get_stats(struct ofproto *ofproto, void *aux, uint64_t *packets, uint64_t *bytes) @@ -1214,13 +1428,14 @@ ofproto_configure_table(struct ofproto *ofproto, int table_id, } table->max_flows = s->max_flows; - fat_rwlock_wrlock(&table->cls.rwlock); - classifier_set_prefix_fields(&table->cls, - s->prefix_fields, s->n_prefix_fields); - fat_rwlock_unlock(&table->cls.rwlock); + + if (classifier_set_prefix_fields(&table->cls, + s->prefix_fields, s->n_prefix_fields)) { + /* XXX: Trigger revalidation. */ + } ovs_mutex_lock(&ofproto_mutex); - evict_rules_from_table(table, 0); + evict_rules_from_table(table); ovs_mutex_unlock(&ofproto_mutex); } @@ -1236,18 +1451,6 @@ ofproto_get_snoops(const struct ofproto *ofproto, struct sset *snoops) connmgr_get_snoops(ofproto->connmgr, snoops); } -static void -ofproto_rule_delete__(struct rule *rule, uint8_t reason) - OVS_REQUIRES(ofproto_mutex) -{ - struct rule_collection rules; - - rules.rules = rules.stub; - rules.n = 1; - rules.stub[0] = rule; - delete_flows__(&rules, reason, NULL); -} - /* Deletes 'rule' from 'ofproto'. * * Within an ofproto implementation, this function allows an ofproto @@ -1265,8 +1468,19 @@ ofproto_rule_delete(struct ofproto *ofproto, struct rule *rule) * switch is being deleted and any OpenFlow channels have been or soon will * be killed. */ ovs_mutex_lock(&ofproto_mutex); - oftable_remove_rule__(ofproto, rule); - ofproto->ofproto_class->rule_delete(rule); + + if (!rule->removed) { + /* Make sure there is no postponed removal of the rule. */ + ovs_assert(cls_rule_visible_in_version(&rule->cr, CLS_MAX_VERSION)); + + if (!classifier_remove(&rule->ofproto->tables[rule->table_id].cls, + &rule->cr)) { + OVS_NOT_REACHED(); + } + ofproto_rule_remove__(rule->ofproto, rule); + ofproto->ofproto_class->rule_delete(rule); + ofproto_rule_unref(rule); + } ovs_mutex_unlock(&ofproto_mutex); } @@ -1276,26 +1490,36 @@ ofproto_flush__(struct ofproto *ofproto) { struct oftable *table; + /* This will flush all datapath flows. */ if (ofproto->ofproto_class->flush) { ofproto->ofproto_class->flush(ofproto); } + /* XXX: There is a small race window here, where new datapath flows can be + * created by upcall handlers based on the existing flow table. We can not + * call ofproto class flush while holding 'ofproto_mutex' to prevent this, + * as then we could deadlock on syncing with the handler threads waiting on + * the same mutex. */ + ovs_mutex_lock(&ofproto_mutex); OFPROTO_FOR_EACH_TABLE (table, ofproto) { - struct rule *rule, *next_rule; - struct cls_cursor cursor; + struct rule_collection rules; + struct rule *rule; if (table->flags & OFTABLE_HIDDEN) { continue; } - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, NULL); - fat_rwlock_unlock(&table->cls.rwlock); - CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) { - ofproto_rule_delete__(rule, OFPRR_DELETE); + rule_collection_init(&rules); + + CLS_FOR_EACH (rule, cr, &table->cls) { + rule_collection_add(&rules, rule); } + delete_flows__(&rules, OFPRR_DELETE, NULL); } + /* XXX: Concurrent handler threads may insert new learned flows based on + * learn actions of the now deleted flows right after we release + * 'ofproto_mutex'. */ ovs_mutex_unlock(&ofproto_mutex); } @@ -1314,8 +1538,6 @@ ofproto_destroy__(struct ofproto *ofproto) ovs_rwlock_destroy(&ofproto->groups_rwlock); hmap_destroy(&ofproto->groups); - connmgr_destroy(ofproto->connmgr); - hmap_remove(&all_ofprotos, &ofproto->hmap_node); free(ofproto->name); free(ofproto->type); @@ -1345,6 +1567,16 @@ ofproto_destroy__(struct ofproto *ofproto) ofproto->ofproto_class->dealloc(ofproto); } +/* Destroying rules is doubly deferred, must have 'ofproto' around for them. + * - 1st we defer the removal of the rules from the classifier + * - 2nd we defer the actual destruction of the rules. */ +static void +ofproto_destroy_defer__(struct ofproto *ofproto) + OVS_EXCLUDED(ofproto_mutex) +{ + ovsrcu_postpone(ofproto_destroy__, ofproto); +} + void ofproto_destroy(struct ofproto *p) OVS_EXCLUDED(ofproto_mutex) @@ -1374,8 +1606,14 @@ ofproto_destroy(struct ofproto *p) } p->ofproto_class->destruct(p); + + /* We should not postpone this because it involves deleting a listening + * socket which we may want to reopen soon. 'connmgr' should not be used + * by other threads */ + connmgr_destroy(p->connmgr); + /* Destroying rules is deferred, must have 'ofproto' around for them. */ - ovsrcu_postpone(ofproto_destroy__, p); + ovsrcu_postpone(ofproto_destroy_defer__, p); } /* Destroys the datapath with the respective 'name' and 'type'. With the Linux @@ -1456,17 +1694,21 @@ ofproto_run(struct ofproto *p) for (i = 0; i < p->n_tables; i++) { struct oftable *table = &p->tables[i]; struct eviction_group *evg; - struct cls_cursor cursor; struct rule *rule; if (!table->eviction_fields) { continue; } + if (table->n_flows > 100000) { + static struct vlog_rate_limit count_rl = + VLOG_RATE_LIMIT_INIT(1, 1); + VLOG_WARN_RL(&count_rl, "Table %"PRIuSIZE" has an excessive" + " number of rules: %d", i, table->n_flows); + } + ovs_mutex_lock(&ofproto_mutex); - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, NULL); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH (rule, cr, &table->cls) { if (rule->idle_timeout || rule->hard_timeout) { if (!rule->eviction_group) { eviction_group_add_rule(rule); @@ -1476,7 +1718,6 @@ ofproto_run(struct ofproto *p) } } } - fat_rwlock_unlock(&table->cls.rwlock); HEAP_FOR_EACH (evg, size_node, &table->eviction_groups_by_size) { heap_rebuild(&evg->rules); @@ -1557,9 +1798,7 @@ ofproto_get_memory_usage(const struct ofproto *ofproto, struct simap *usage) n_rules = 0; OFPROTO_FOR_EACH_TABLE (table, ofproto) { - fat_rwlock_rdlock(&table->cls.rwlock); - n_rules += classifier_count(&table->cls); - fat_rwlock_unlock(&table->cls.rwlock); + n_rules += table->n_flows; } simap_increase(usage, "rules", n_rules); @@ -1789,7 +2028,7 @@ ofproto_port_del(struct ofproto *ofproto, ofp_port_t ofp_port) static void flow_mod_init(struct ofputil_flow_mod *fm, - const struct match *match, unsigned int priority, + const struct match *match, int priority, const struct ofpact *ofpacts, size_t ofpacts_len, enum ofp_flow_mod_command command) { @@ -1803,6 +2042,7 @@ flow_mod_init(struct ofputil_flow_mod *fm, fm->command = command; fm->idle_timeout = 0; fm->hard_timeout = 0; + fm->importance = 0; fm->buffer_id = UINT32_MAX; fm->out_port = OFPP_ANY; fm->out_group = OFPG_ANY; @@ -1814,7 +2054,7 @@ flow_mod_init(struct ofputil_flow_mod *fm, static int simple_flow_mod(struct ofproto *ofproto, - const struct match *match, unsigned int priority, + const struct match *match, int priority, const struct ofpact *ofpacts, size_t ofpacts_len, enum ofp_flow_mod_command command) { @@ -1838,7 +2078,7 @@ simple_flow_mod(struct ofproto *ofproto, * This is a helper function for in-band control and fail-open. */ void ofproto_add_flow(struct ofproto *ofproto, const struct match *match, - unsigned int priority, + int priority, const struct ofpact *ofpacts, size_t ofpacts_len) OVS_EXCLUDED(ofproto_mutex) { @@ -1847,9 +2087,9 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match, /* First do a cheap check whether the rule we're looking for already exists * with the actions that we want. If it does, then we're done. */ - fat_rwlock_rdlock(&ofproto->tables[0].cls.rwlock); rule = rule_from_cls_rule(classifier_find_match_exactly( - &ofproto->tables[0].cls, match, priority)); + &ofproto->tables[0].cls, match, priority, + CLS_MAX_VERSION)); if (rule) { const struct rule_actions *actions = rule_get_actions(rule); must_add = !ofpacts_equal(actions->ofpacts, actions->ofpacts_len, @@ -1857,7 +2097,6 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match, } else { must_add = true; } - fat_rwlock_unlock(&ofproto->tables[0].cls.rwlock); /* If there's no such rule or the rule doesn't have the actions we want, * fall back to a executing a full flow mod. We can't optimize this at @@ -1869,13 +2108,12 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match, } } -/* Executes the flow modification specified in 'fm'. Returns 0 on success, an - * OFPERR_* OpenFlow error code on failure, or OFPROTO_POSTPONE if the - * operation cannot be initiated now but may be retried later. +/* Executes the flow modification specified in 'fm'. Returns 0 on success, or + * an OFPERR_* OpenFlow error code on failure. * * This is a helper function for in-band control and fail-open and the "learn" * action. */ -int +enum ofperr ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) OVS_EXCLUDED(ofproto_mutex) { @@ -1888,10 +2126,9 @@ ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) struct rule *rule; bool done = false; - fat_rwlock_rdlock(&table->cls.rwlock); - rule = rule_from_cls_rule(classifier_find_match_exactly(&table->cls, - &fm->match, - fm->priority)); + rule = rule_from_cls_rule(classifier_find_match_exactly( + &table->cls, &fm->match, fm->priority, + CLS_MAX_VERSION)); if (rule) { /* Reading many of the rule fields and writing on 'modified' * requires the rule->mutex. Also, rule->actions may change @@ -1902,6 +2139,7 @@ ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) actions = rule_get_actions(rule); if (rule->idle_timeout == fm->idle_timeout && rule->hard_timeout == fm->hard_timeout + && rule->importance == fm->importance && rule->flags == (fm->flags & OFPUTIL_FF_STATE) && (!fm->modify_cookie || (fm->new_cookie == rule->flow_cookie)) && ofpacts_equal(fm->ofpacts, fm->ofpacts_len, @@ -1913,7 +2151,6 @@ ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) } ovs_mutex_unlock(&rule->mutex); } - fat_rwlock_unlock(&table->cls.rwlock); if (done) { return 0; @@ -1929,7 +2166,7 @@ ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) * This is a helper function for in-band control and fail-open. */ void ofproto_delete_flow(struct ofproto *ofproto, - const struct match *target, unsigned int priority) + const struct match *target, int priority) OVS_EXCLUDED(ofproto_mutex) { struct classifier *cls = &ofproto->tables[0].cls; @@ -1937,10 +2174,8 @@ ofproto_delete_flow(struct ofproto *ofproto, /* First do a cheap check whether the rule we're looking for has already * been deleted. If so, then we're done. */ - fat_rwlock_rdlock(&cls->rwlock); - rule = rule_from_cls_rule(classifier_find_match_exactly(cls, target, - priority)); - fat_rwlock_unlock(&cls->rwlock); + rule = rule_from_cls_rule(classifier_find_match_exactly( + cls, target, priority, CLS_MAX_VERSION)); if (!rule) { return; } @@ -2224,6 +2459,9 @@ ofproto_port_unregister(struct ofproto *ofproto, ofp_port_t ofp_port) if (port->ofproto->ofproto_class->set_stp_port) { port->ofproto->ofproto_class->set_stp_port(port, NULL); } + if (port->ofproto->ofproto_class->set_rstp_port) { + port->ofproto->ofproto_class->set_rstp_port(port, NULL); + } if (port->ofproto->ofproto_class->set_cfm) { port->ofproto->ofproto_class->set_cfm(port, NULL); } @@ -2523,7 +2761,14 @@ ofproto_rule_destroy__(struct rule *rule) static void rule_destroy_cb(struct rule *rule) + OVS_NO_THREAD_SAFETY_ANALYSIS { + /* Send rule removed if needed. */ + if (rule->flags & OFPUTIL_FF_SEND_FLOW_REM + && rule->removed_reason != OVS_OFPRR_NONE + && !rule_is_hidden(rule)) { + ofproto_rule_send_removed(rule); + } rule->ofproto->ofproto_class->rule_destruct(rule); ofproto_rule_destroy__(rule); } @@ -2559,6 +2804,70 @@ ofproto_rule_unref(struct rule *rule) } } +static void +remove_rule_rcu__(struct rule *rule) + OVS_REQUIRES(ofproto_mutex) +{ + struct ofproto *ofproto = rule->ofproto; + struct oftable *table = &ofproto->tables[rule->table_id]; + + ovs_assert(!cls_rule_visible_in_version(&rule->cr, CLS_MAX_VERSION)); + if (!classifier_remove(&table->cls, &rule->cr)) { + OVS_NOT_REACHED(); + } + ofproto->ofproto_class->rule_delete(rule); + ofproto_rule_unref(rule); +} + +static void +remove_rule_rcu(struct rule *rule) + OVS_EXCLUDED(ofproto_mutex) +{ + ovs_mutex_lock(&ofproto_mutex); + remove_rule_rcu__(rule); + ovs_mutex_unlock(&ofproto_mutex); +} + +/* Removes and deletes rules from a NULL-terminated array of rule pointers. */ +static void +remove_rules_rcu(struct rule **rules) + OVS_EXCLUDED(ofproto_mutex) +{ + struct rule **orig_rules = rules; + + if (*rules) { + struct ofproto *ofproto = rules[0]->ofproto; + unsigned long tables[BITMAP_N_LONGS(256)]; + struct rule *rule; + size_t table_id; + + memset(tables, 0, sizeof tables); + + ovs_mutex_lock(&ofproto_mutex); + while ((rule = *rules++)) { + /* Defer once for each new table. This defers the subtable cleanup + * until later, so that when removing large number of flows the + * operation is faster. */ + if (!bitmap_is_set(tables, rule->table_id)) { + struct classifier *cls = &ofproto->tables[rule->table_id].cls; + + bitmap_set1(tables, rule->table_id); + classifier_defer(cls); + } + remove_rule_rcu__(rule); + } + + BITMAP_FOR_EACH_1(table_id, 256, tables) { + struct classifier *cls = &ofproto->tables[table_id].cls; + + classifier_publish(cls); + } + ovs_mutex_unlock(&ofproto_mutex); + } + + free(orig_rules); +} + void ofproto_group_ref(struct ofgroup *group) { @@ -2651,13 +2960,13 @@ run_rule_executes(struct ofproto *ofproto) OVS_EXCLUDED(ofproto_mutex) { struct rule_execute *e, *next; - struct list executes; + struct ovs_list executes; guarded_list_pop_all(&ofproto->rule_executes, &executes); LIST_FOR_EACH_SAFE (e, next, list_node, &executes) { struct flow flow; - flow_extract(e->packet, NULL, &flow); + flow_extract(e->packet, &flow); flow.in_port.ofp_port = e->in_port; ofproto->ofproto_class->rule_execute(e->rule, &flow, e->packet); @@ -2671,11 +2980,11 @@ static void destroy_rule_executes(struct ofproto *ofproto) { struct rule_execute *e, *next; - struct list executes; + struct ovs_list executes; guarded_list_pop_all(&ofproto->rule_executes, &executes); LIST_FOR_EACH_SAFE (e, next, list_node, &executes) { - ofpbuf_delete(e->packet); + dp_packet_delete(e->packet); rule_execute_destroy(e); } } @@ -2697,7 +3006,7 @@ hash_learned_cookie(ovs_be64 cookie_, uint8_t table_id) static void learned_cookies_update_one__(struct ofproto *ofproto, const struct ofpact_learn *learn, - int delta, struct list *dead_cookies) + int delta, struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex) { uint32_t hash = hash_learned_cookie(learn->cookie, learn->table_id); @@ -2748,7 +3057,7 @@ next_learn_with_delete(const struct rule_actions *actions, static void learned_cookies_update__(struct ofproto *ofproto, const struct rule_actions *actions, - int delta, struct list *dead_cookies) + int delta, struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex) { if (actions->has_learn_with_delete) { @@ -2772,33 +3081,31 @@ learned_cookies_inc(struct ofproto *ofproto, static void learned_cookies_dec(struct ofproto *ofproto, const struct rule_actions *actions, - struct list *dead_cookies) + struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex) { learned_cookies_update__(ofproto, actions, -1, dead_cookies); } static void -learned_cookies_flush(struct ofproto *ofproto, struct list *dead_cookies) +learned_cookies_flush(struct ofproto *ofproto, struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex) { - struct learned_cookie *c, *next; + struct learned_cookie *c; - LIST_FOR_EACH_SAFE (c, next, u.list_node, dead_cookies) { + LIST_FOR_EACH_POP (c, u.list_node, dead_cookies) { struct rule_criteria criteria; struct rule_collection rules; struct match match; match_init_catchall(&match); - rule_criteria_init(&criteria, c->table_id, &match, 0, + rule_criteria_init(&criteria, c->table_id, &match, 0, CLS_MAX_VERSION, c->cookie, OVS_BE64_MAX, OFPP_ANY, OFPG_ANY); rule_criteria_require_rw(&criteria, false); collect_rules_loose(ofproto, &criteria, &rules); - delete_flows__(&rules, OFPRR_DELETE, NULL); rule_criteria_destroy(&criteria); - rule_collection_destroy(&rules); + delete_flows__(&rules, OFPRR_DELETE, NULL); - list_remove(&c->u.list_node); free(c); } } @@ -2810,6 +3117,106 @@ handle_echo_request(struct ofconn *ofconn, const struct ofp_header *oh) return 0; } +static void +query_tables(struct ofproto *ofproto, + struct ofputil_table_features **featuresp, + struct ofputil_table_stats **statsp) +{ + struct mf_bitmap rw_fields = oxm_writable_fields(); + struct mf_bitmap match = oxm_matchable_fields(); + struct mf_bitmap mask = oxm_maskable_fields(); + + struct ofputil_table_features *features; + struct ofputil_table_stats *stats; + int i; + + features = *featuresp = xcalloc(ofproto->n_tables, sizeof *features); + for (i = 0; i < ofproto->n_tables; i++) { + struct ofputil_table_features *f = &features[i]; + + f->table_id = i; + sprintf(f->name, "table%d", i); + f->metadata_match = OVS_BE64_MAX; + f->metadata_write = OVS_BE64_MAX; + atomic_read_relaxed(&ofproto->tables[i].miss_config, &f->miss_config); + f->max_entries = 1000000; + + bool more_tables = false; + for (int j = i + 1; j < ofproto->n_tables; j++) { + if (!(ofproto->tables[j].flags & OFTABLE_HIDDEN)) { + bitmap_set1(f->nonmiss.next, j); + more_tables = true; + } + } + f->nonmiss.instructions = (1u << N_OVS_INSTRUCTIONS) - 1; + if (!more_tables) { + f->nonmiss.instructions &= ~(1u << OVSINST_OFPIT11_GOTO_TABLE); + } + f->nonmiss.write.ofpacts = (UINT64_C(1) << N_OFPACTS) - 1; + f->nonmiss.write.set_fields = rw_fields; + f->nonmiss.apply = f->nonmiss.write; + f->miss = f->nonmiss; + + f->match = match; + f->mask = mask; + f->wildcard = match; + } + + if (statsp) { + stats = *statsp = xcalloc(ofproto->n_tables, sizeof *stats); + for (i = 0; i < ofproto->n_tables; i++) { + struct ofputil_table_stats *s = &stats[i]; + + s->table_id = i; + s->active_count = ofproto->tables[i].n_flows; + if (i == 0) { + s->active_count -= connmgr_count_hidden_rules( + ofproto->connmgr); + } + } + } else { + stats = NULL; + } + + ofproto->ofproto_class->query_tables(ofproto, features, stats); + + for (i = 0; i < ofproto->n_tables; i++) { + const struct oftable *table = &ofproto->tables[i]; + struct ofputil_table_features *f = &features[i]; + + if (table->name) { + ovs_strzcpy(f->name, table->name, sizeof f->name); + } + + if (table->max_flows < f->max_entries) { + f->max_entries = table->max_flows; + } + } +} + +static void +query_switch_features(struct ofproto *ofproto, + bool *arp_match_ip, uint64_t *ofpacts) +{ + struct ofputil_table_features *features, *f; + + *arp_match_ip = false; + *ofpacts = 0; + + query_tables(ofproto, &features, NULL); + for (f = features; f < &features[ofproto->n_tables]; f++) { + *ofpacts |= f->nonmiss.apply.ofpacts | f->miss.apply.ofpacts; + if (bitmap_is_set(f->match.bm, MFF_ARP_SPA) || + bitmap_is_set(f->match.bm, MFF_ARP_TPA)) { + *arp_match_ip = true; + } + } + free(features); + + /* Sanity check. */ + ovs_assert(*ofpacts & (UINT64_C(1) << OFPACT_OUTPUT)); +} + static enum ofperr handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh) { @@ -2819,15 +3226,14 @@ handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh) bool arp_match_ip; struct ofpbuf *b; - ofproto->ofproto_class->get_features(ofproto, &arp_match_ip, - &features.actions); - ovs_assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */ + query_switch_features(ofproto, &arp_match_ip, &features.ofpacts); features.datapath_id = ofproto->datapath_id; features.n_buffers = pktbuf_capacity(); features.n_tables = ofproto_get_n_visible_tables(ofproto); features.capabilities = (OFPUTIL_C_FLOW_STATS | OFPUTIL_C_TABLE_STATS | - OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS); + OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS | + OFPUTIL_C_GROUP_STATS); if (arp_match_ip) { features.capabilities |= OFPUTIL_C_ARP_MATCH_IP; } @@ -2910,7 +3316,7 @@ reject_slave_controller(struct ofconn *ofconn) { if (ofconn_get_type(ofconn) == OFCONN_PRIMARY && ofconn_get_role(ofconn) == OFPCR12_ROLE_SLAVE) { - return OFPERR_OFPBRC_EPERM; + return OFPERR_OFPBRC_IS_SLAVE; } else { return 0; } @@ -2951,7 +3357,7 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) { struct ofproto *p = ofconn_get_ofproto(ofconn); struct ofputil_packet_out po; - struct ofpbuf *payload; + struct dp_packet *payload; uint64_t ofpacts_stub[1024 / 8]; struct ofpbuf ofpacts; struct flow flow; @@ -2984,18 +3390,18 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) } } else { /* Ensure that the L3 header is 32-bit aligned. */ - payload = ofpbuf_clone_data_with_headroom(po.packet, po.packet_len, 2); + payload = dp_packet_clone_data_with_headroom(po.packet, po.packet_len, 2); } /* Verify actions against packet, then send packet if successful. */ - flow_extract(payload, NULL, &flow); + flow_extract(payload, &flow); flow.in_port.ofp_port = po.in_port; error = ofproto_check_ofpacts(p, po.ofpacts, po.ofpacts_len); if (!error) { error = p->ofproto_class->packet_out(p, payload, &flow, po.ofpacts, po.ofpacts_len); } - ofpbuf_delete(payload); + dp_packet_delete(payload); exit_free_ofpacts: ofpbuf_uninit(&ofpacts); @@ -3029,9 +3435,34 @@ update_port_config(struct ofconn *ofconn, struct ofport *port, } static enum ofperr -handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh) +port_mod_start(struct ofconn *ofconn, struct ofputil_port_mod *pm, + struct ofport **port) { struct ofproto *p = ofconn_get_ofproto(ofconn); + + *port = ofproto_get_port(p, pm->port_no); + if (!*port) { + return OFPERR_OFPPMFC_BAD_PORT; + } + if (!eth_addr_equals((*port)->pp.hw_addr, pm->hw_addr)) { + return OFPERR_OFPPMFC_BAD_HW_ADDR; + } + return 0; +} + +static void +port_mod_finish(struct ofconn *ofconn, struct ofputil_port_mod *pm, + struct ofport *port) +{ + update_port_config(ofconn, port, pm->config, pm->mask); + if (pm->advertise) { + netdev_set_advertisements(port->netdev, pm->advertise); + } +} + +static enum ofperr +handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh) +{ struct ofputil_port_mod pm; struct ofport *port; enum ofperr error; @@ -3046,18 +3477,11 @@ handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh) return error; } - port = ofproto_get_port(p, pm.port_no); - if (!port) { - return OFPERR_OFPPMFC_BAD_PORT; - } else if (!eth_addr_equals(port->pp.hw_addr, pm.hw_addr)) { - return OFPERR_OFPPMFC_BAD_HW_ADDR; - } else { - update_port_config(ofconn, port, pm.config, pm.mask); - if (pm.advertise) { - netdev_set_advertisements(port->netdev, pm.advertise); - } + error = port_mod_start(ofconn, &pm, &port); + if (!error) { + port_mod_finish(ofconn, &pm, port); } - return 0; + return error; } static enum ofperr @@ -3096,69 +3520,61 @@ static enum ofperr handle_table_stats_request(struct ofconn *ofconn, const struct ofp_header *request) { - struct ofproto *p = ofconn_get_ofproto(ofconn); - struct ofp12_table_stats *ots; - struct ofpbuf *msg; - int n_tables; + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct ofputil_table_features *features; + struct ofputil_table_stats *stats; + struct ofpbuf *reply; size_t i; - /* Set up default values. - * - * ofp12_table_stats is used as a generic structure as - * it is able to hold all the fields for ofp10_table_stats - * and ofp11_table_stats (and of course itself). - */ - ots = xcalloc(p->n_tables, sizeof *ots); - for (i = 0; i < p->n_tables; i++) { - ots[i].table_id = i; - sprintf(ots[i].name, "table%"PRIuSIZE, i); - ots[i].match = htonll(OFPXMT13_MASK); - ots[i].wildcards = htonll(OFPXMT13_MASK); - ots[i].write_actions = htonl(OFPAT11_OUTPUT); - ots[i].apply_actions = htonl(OFPAT11_OUTPUT); - ots[i].write_setfields = htonll(OFPXMT13_MASK); - ots[i].apply_setfields = htonll(OFPXMT13_MASK); - ots[i].metadata_match = OVS_BE64_MAX; - ots[i].metadata_write = OVS_BE64_MAX; - ots[i].instructions = htonl(OFPIT11_ALL); - ots[i].config = htonl(OFPTC11_TABLE_MISS_MASK); - ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */ - fat_rwlock_rdlock(&p->tables[i].cls.rwlock); - ots[i].active_count = htonl(classifier_count(&p->tables[i].cls)); - fat_rwlock_unlock(&p->tables[i].cls.rwlock); - } - - p->ofproto_class->get_tables(p, ots); - - /* Post-process the tables, dropping hidden tables. */ - n_tables = p->n_tables; - for (i = 0; i < p->n_tables; i++) { - const struct oftable *table = &p->tables[i]; + query_tables(ofproto, &features, &stats); - if (table->flags & OFTABLE_HIDDEN) { - n_tables = i; - break; + reply = ofputil_encode_table_stats_reply(request); + for (i = 0; i < ofproto->n_tables; i++) { + if (!(ofproto->tables[i].flags & OFTABLE_HIDDEN)) { + ofputil_append_table_stats_reply(reply, &stats[i], &features[i]); } + } + ofconn_send_reply(ofconn, reply); - if (table->name) { - ovs_strzcpy(ots[i].name, table->name, sizeof ots[i].name); - } + free(features); + free(stats); - if (table->max_flows < ntohl(ots[i].max_entries)) { - ots[i].max_entries = htonl(table->max_flows); - } + return 0; +} + +static enum ofperr +handle_table_features_request(struct ofconn *ofconn, + const struct ofp_header *request) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct ofputil_table_features *features; + struct ovs_list replies; + struct ofpbuf msg; + size_t i; + + ofpbuf_use_const(&msg, request, ntohs(request->length)); + ofpraw_pull_assert(&msg); + if (msg.size || ofpmp_more(request)) { + return OFPERR_OFPTFFC_EPERM; } - msg = ofputil_encode_table_stats_reply(ots, n_tables, request); - ofconn_send_reply(ofconn, msg); + query_tables(ofproto, &features, NULL); - free(ots); + ofpmp_init(&replies, request); + for (i = 0; i < ofproto->n_tables; i++) { + if (!(ofproto->tables[i].flags & OFTABLE_HIDDEN)) { + ofputil_append_table_features_reply(&features[i], &replies); + } + } + ofconn_send_replies(ofconn, &replies); + + free(features); return 0; } static void -append_port_stat(struct ofport *port, struct list *replies) +append_port_stat(struct ofport *port, struct ovs_list *replies) { struct ofputil_port_stats ops = { .port_no = port->pp.port_no }; @@ -3176,11 +3592,11 @@ append_port_stat(struct ofport *port, struct list *replies) static void handle_port_request(struct ofconn *ofconn, const struct ofp_header *request, ofp_port_t port_no, - void (*cb)(struct ofport *, struct list *replies)) + void (*cb)(struct ofport *, struct ovs_list *replies)) { struct ofproto *ofproto = ofconn_get_ofproto(ofconn); struct ofport *port; - struct list replies; + struct ovs_list replies; ofpmp_init(&replies, request); if (port_no != OFPP_ANY) { @@ -3212,7 +3628,7 @@ handle_port_stats_request(struct ofconn *ofconn, } static void -append_port_desc(struct ofport *port, struct list *replies) +append_port_desc(struct ofport *port, struct ovs_list *replies) { ofputil_append_port_desc_stats_reply(&port->pp, replies); } @@ -3337,12 +3753,13 @@ next_matching_table(const struct ofproto *ofproto, * supplied as 0. */ static void rule_criteria_init(struct rule_criteria *criteria, uint8_t table_id, - const struct match *match, unsigned int priority, - ovs_be64 cookie, ovs_be64 cookie_mask, - ofp_port_t out_port, uint32_t out_group) + const struct match *match, int priority, + cls_version_t version, ovs_be64 cookie, + ovs_be64 cookie_mask, ofp_port_t out_port, + uint32_t out_group) { criteria->table_id = table_id; - cls_rule_init(&criteria->cr, match, priority); + cls_rule_init(&criteria->cr, match, priority, version); criteria->cookie = cookie; criteria->cookie_mask = cookie_mask; criteria->out_port = out_port; @@ -3431,18 +3848,56 @@ rule_collection_unref(struct rule_collection *rules) } } +/* Returns a NULL-terminated array of rule pointers, + * destroys 'rules'. */ +static struct rule ** +rule_collection_detach(struct rule_collection *rules) +{ + struct rule **rule_array; + + rule_collection_add(rules, NULL); + + if (rules->rules == rules->stub) { + rules->rules = xmemdup(rules->rules, rules->n * sizeof *rules->rules); + } + + rule_array = rules->rules; + rule_collection_init(rules); + + return rule_array; +} + void rule_collection_destroy(struct rule_collection *rules) { if (rules->rules != rules->stub) { free(rules->rules); } + + /* Make repeated destruction harmless. */ + rule_collection_init(rules); +} + +/* Schedules postponed removal of rules, destroys 'rules'. */ +static void +rule_collection_remove_postponed(struct rule_collection *rules) + OVS_REQUIRES(ofproto_mutex) +{ + if (rules->n > 0) { + if (rules->n == 1) { + ovsrcu_postpone(remove_rule_rcu, rules->rules[0]); + } else { + ovsrcu_postpone(remove_rules_rcu, rule_collection_detach(rules)); + } + } } /* Checks whether 'rule' matches 'c' and, if so, adds it to 'rules'. This * function verifies most of the criteria in 'c' itself, but the caller must * check 'c->cr' itself. * + * Rules that have already been marked for removal are not collected. + * * Increments '*n_readonly' if 'rule' wasn't added because it's read-only (and * 'c' only includes modifiable rules). */ static void @@ -3454,7 +3909,8 @@ collect_rule(struct rule *rule, const struct rule_criteria *c, && ofproto_rule_has_out_port(rule, c->out_port) && ofproto_rule_has_out_group(rule, c->out_group) && !((rule->flow_cookie ^ c->cookie) & c->cookie_mask) - && (!rule_is_hidden(rule) || c->include_hidden)) { + && (!rule_is_hidden(rule) || c->include_hidden) + && cls_rule_visible_in_version(&rule->cr, c->cr.version)) { /* Rule matches all the criteria... */ if (!rule_is_readonly(rule) || c->include_readonly) { /* ...add it. */ @@ -3501,15 +3957,11 @@ collect_rules_loose(struct ofproto *ofproto, } } else { FOR_EACH_MATCHING_TABLE (table, criteria->table_id, ofproto) { - struct cls_cursor cursor; struct rule *rule; - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, &criteria->cr); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH_TARGET (rule, cr, &table->cls, &criteria->cr) { collect_rule(rule, criteria, rules, &n_readonly); } - fat_rwlock_unlock(&table->cls.rwlock); } } @@ -3539,7 +3991,7 @@ collect_rules_strict(struct ofproto *ofproto, { struct oftable *table; size_t n_readonly = 0; - int error = 0; + enum ofperr error = 0; rule_collection_init(rules); @@ -3562,10 +4014,8 @@ collect_rules_strict(struct ofproto *ofproto, FOR_EACH_MATCHING_TABLE (table, criteria->table_id, ofproto) { struct rule *rule; - fat_rwlock_rdlock(&table->cls.rwlock); rule = rule_from_cls_rule(classifier_find_rule_exactly( &table->cls, &criteria->cr)); - fat_rwlock_unlock(&table->cls.rwlock); if (rule) { collect_rule(rule, criteria, rules, &n_readonly); } @@ -3603,7 +4053,7 @@ handle_flow_stats_request(struct ofconn *ofconn, struct ofputil_flow_stats_request fsr; struct rule_criteria criteria; struct rule_collection rules; - struct list replies; + struct ovs_list replies; enum ofperr error; size_t i; @@ -3612,8 +4062,9 @@ handle_flow_stats_request(struct ofconn *ofconn, return error; } - rule_criteria_init(&criteria, fsr.table_id, &fsr.match, 0, fsr.cookie, - fsr.cookie_mask, fsr.out_port, fsr.out_group); + rule_criteria_init(&criteria, fsr.table_id, &fsr.match, 0, CLS_MAX_VERSION, + fsr.cookie, fsr.cookie_mask, fsr.out_port, + fsr.out_group); ovs_mutex_lock(&ofproto_mutex); error = collect_rules_loose(ofproto, &criteria, &rules); @@ -3640,6 +4091,7 @@ handle_flow_stats_request(struct ofconn *ofconn, fs.cookie = rule->flow_cookie; fs.idle_timeout = rule->idle_timeout; fs.hard_timeout = rule->hard_timeout; + fs.importance = rule->importance; created = rule->created; modified = rule->modified; actions = rule_get_actions(rule); @@ -3708,15 +4160,11 @@ ofproto_get_all_flows(struct ofproto *p, struct ds *results) struct oftable *table; OFPROTO_FOR_EACH_TABLE (table, p) { - struct cls_cursor cursor; struct rule *rule; - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, NULL); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH (rule, cr, &table->cls) { flow_stats_ds(rule, results); } - fat_rwlock_unlock(&table->cls.rwlock); } } @@ -3779,7 +4227,7 @@ handle_aggregate_stats_request(struct ofconn *ofconn, } rule_criteria_init(&criteria, request.table_id, &request.match, 0, - request.cookie, request.cookie_mask, + CLS_MAX_VERSION, request.cookie, request.cookie_mask, request.out_port, request.out_group); ovs_mutex_lock(&ofproto_mutex); @@ -3837,7 +4285,7 @@ handle_aggregate_stats_request(struct ofconn *ofconn, struct queue_stats_cbdata { struct ofport *ofport; - struct list replies; + struct ovs_list replies; long long int now; }; @@ -3933,54 +4381,94 @@ handle_queue_stats_request(struct ofconn *ofconn, return error; } -static bool -should_evict_a_rule(struct oftable *table, unsigned int extra_space) - OVS_REQUIRES(ofproto_mutex) - OVS_NO_THREAD_SAFETY_ANALYSIS -{ - return classifier_count(&table->cls) + extra_space > table->max_flows; -} - static enum ofperr -evict_rules_from_table(struct oftable *table, unsigned int extra_space) +evict_rules_from_table(struct oftable *table) OVS_REQUIRES(ofproto_mutex) { - while (should_evict_a_rule(table, extra_space)) { + enum ofperr error = 0; + struct rule_collection rules; + unsigned int count = table->n_flows; + unsigned int max_flows = table->max_flows; + + rule_collection_init(&rules); + + while (count-- > max_flows) { struct rule *rule; if (!choose_rule_to_evict(table, &rule)) { - return OFPERR_OFPFMFC_TABLE_FULL; + error = OFPERR_OFPFMFC_TABLE_FULL; + break; } else { - ofproto_rule_delete__(rule, OFPRR_EVICTION); + eviction_group_remove_rule(rule); + rule_collection_add(&rules, rule); } } + delete_flows__(&rules, OFPRR_EVICTION, NULL); - return 0; + return error; +} + +static void +get_conjunctions(const struct ofputil_flow_mod *fm, + struct cls_conjunction **conjsp, size_t *n_conjsp) + OVS_REQUIRES(ofproto_mutex) +{ + struct cls_conjunction *conjs = NULL; + int n_conjs = 0; + + const struct ofpact *ofpact; + OFPACT_FOR_EACH (ofpact, fm->ofpacts, fm->ofpacts_len) { + if (ofpact->type == OFPACT_CONJUNCTION) { + n_conjs++; + } else if (ofpact->type != OFPACT_NOTE) { + /* "conjunction" may appear with "note" actions but not with any + * other type of actions. */ + ovs_assert(!n_conjs); + break; + } + } + if (n_conjs) { + int i = 0; + + conjs = xzalloc(n_conjs * sizeof *conjs); + OFPACT_FOR_EACH (ofpact, fm->ofpacts, fm->ofpacts_len) { + if (ofpact->type == OFPACT_CONJUNCTION) { + struct ofpact_conjunction *oc = ofpact_get_CONJUNCTION(ofpact); + conjs[i].clause = oc->clause; + conjs[i].n_clauses = oc->n_clauses; + conjs[i].id = oc->id; + i++; + } + } + } + + *conjsp = conjs; + *n_conjsp = n_conjs; } /* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT * in which no matching flow already exists in the flow table. * - * Adds the flow specified by 'ofm', which is followed by 'n_actions' - * ofp_actions, to the ofproto's flow table. Returns 0 on success, an OpenFlow - * error code on failure, or OFPROTO_POSTPONE if the operation cannot be - * initiated now but may be retried later. + * Adds the flow specified by 'fm', to the ofproto's flow table. Returns 0 on + * success, or an OpenFlow error code on failure. * - * The caller retains ownership of 'fm->ofpacts'. + * On successful return the caller must complete the operation either by + * calling add_flow_finish(), or add_flow_revert() if the operation needs to + * be reverted. * - * 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id, - * if any. */ + * The caller retains ownership of 'fm->ofpacts'. */ static enum ofperr -add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) +add_flow_start(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule **old_rule, struct rule **new_rule) OVS_REQUIRES(ofproto_mutex) { - const struct rule_actions *actions; struct oftable *table; struct cls_rule cr; struct rule *rule; uint8_t table_id; - int error = 0; + struct cls_conjunction *conjs; + size_t n_conjs; + enum ofperr error; if (!check_table_id(ofproto, fm->table_id)) { error = OFPERR_OFPBRC_BAD_TABLE_ID; @@ -4012,67 +4500,132 @@ add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm, return OFPERR_OFPBRC_EPERM; } - if (!(fm->flags & OFPUTIL_FF_HIDDEN_FIELDS)) { - if (!match_has_default_hidden_fields(&fm->match)) { - VLOG_WARN_RL(&rl, "%s: (add_flow) only internal flows can set " - "non-default values to hidden fields", ofproto->name); - return OFPERR_OFPBRC_EPERM; - } + if (!(fm->flags & OFPUTIL_FF_HIDDEN_FIELDS) + && !match_has_default_hidden_fields(&fm->match)) { + VLOG_WARN_RL(&rl, "%s: (add_flow) only internal flows can set " + "non-default values to hidden fields", ofproto->name); + return OFPERR_OFPBRC_EPERM; } - cls_rule_init(&cr, &fm->match, fm->priority); + cls_rule_init(&cr, &fm->match, fm->priority, ofproto->tables_version + 1); - /* Transform "add" into "modify" if there's an existing identical flow. */ - fat_rwlock_rdlock(&table->cls.rwlock); + /* Check for the existence of an identical rule. + * This will not return rules earlier marked for removal. */ rule = rule_from_cls_rule(classifier_find_rule_exactly(&table->cls, &cr)); - fat_rwlock_unlock(&table->cls.rwlock); - if (rule) { - struct rule_collection rules; - - cls_rule_destroy(&cr); + *old_rule = rule; + if (!rule) { + /* Check for overlap, if requested. */ + if (fm->flags & OFPUTIL_FF_CHECK_OVERLAP + && classifier_rule_overlaps(&table->cls, &cr)) { + cls_rule_destroy(&cr); + return OFPERR_OFPFMFC_OVERLAP; + } - rule_collection_init(&rules); - rule_collection_add(&rules, rule); + /* If necessary, evict an existing rule to clear out space. */ + if (table->n_flows >= table->max_flows) { + if (!choose_rule_to_evict(table, &rule)) { + error = OFPERR_OFPFMFC_TABLE_FULL; + cls_rule_destroy(&cr); + return error; + } + eviction_group_remove_rule(rule); + /* Marks '*old_rule' as an evicted rule rather than replaced rule. + */ + fm->delete_reason = OFPRR_EVICTION; + *old_rule = rule; + } + } else { fm->modify_cookie = true; - error = modify_flows__(ofproto, fm, &rules, req); - rule_collection_destroy(&rules); + } + /* Allocate new rule. */ + error = replace_rule_create(ofproto, fm, &cr, table - ofproto->tables, + rule, new_rule); + if (error) { return error; } - /* Check for overlap, if requested. */ - if (fm->flags & OFPUTIL_FF_CHECK_OVERLAP) { - bool overlaps; + get_conjunctions(fm, &conjs, &n_conjs); + replace_rule_start(ofproto, rule, *new_rule, conjs, n_conjs); + free(conjs); - fat_rwlock_rdlock(&table->cls.rwlock); - overlaps = classifier_rule_overlaps(&table->cls, &cr); - fat_rwlock_unlock(&table->cls.rwlock); + return 0; +} - if (overlaps) { - cls_rule_destroy(&cr); - return OFPERR_OFPFMFC_OVERLAP; - } +/* Revert the effects of add_flow_start(). */ +static void +add_flow_revert(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule *old_rule, struct rule *new_rule) + OVS_REQUIRES(ofproto_mutex) +{ + if (old_rule && fm->delete_reason == OFPRR_EVICTION) { + /* Revert the eviction. */ + eviction_group_add_rule(old_rule); } - /* If necessary, evict an existing rule to clear out space. */ - error = evict_rules_from_table(table, 1); - if (error) { - cls_rule_destroy(&cr); - return error; + replace_rule_revert(ofproto, old_rule, new_rule); +} + +/* To be called after version bump. */ +static void +add_flow_finish(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req, + struct rule *old_rule, struct rule *new_rule) + OVS_REQUIRES(ofproto_mutex) +{ + struct ovs_list dead_cookies = OVS_LIST_INITIALIZER(&dead_cookies); + + replace_rule_finish(ofproto, fm, req, old_rule, new_rule, &dead_cookies); + learned_cookies_flush(ofproto, &dead_cookies); + + if (old_rule) { + ovsrcu_postpone(remove_rule_rcu, old_rule); + } else { + if (minimask_get_vid_mask(&new_rule->cr.match.mask) == VLAN_VID_MASK) { + if (ofproto->vlan_bitmap) { + uint16_t vid = miniflow_get_vid(&new_rule->cr.match.flow); + + if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) { + bitmap_set1(ofproto->vlan_bitmap, vid); + ofproto->vlans_changed = true; + } + } else { + ofproto->vlans_changed = true; + } + } + + ofmonitor_report(ofproto->connmgr, new_rule, NXFME_ADDED, 0, + req ? req->ofconn : NULL, + req ? req->request->xid : 0, NULL); } + send_buffered_packet(req, fm->buffer_id, new_rule); +} + +/* OFPFC_MODIFY and OFPFC_MODIFY_STRICT. */ + +/* Create a new rule based on attributes in 'fm', match in 'cr', 'table_id', + * and 'old_rule'. Note that the rule is NOT inserted into a any data + * structures yet. Takes ownership of 'cr'. */ +static enum ofperr +replace_rule_create(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct cls_rule *cr, uint8_t table_id, + struct rule *old_rule, struct rule **new_rule) +{ + struct rule *rule; + enum ofperr error; + /* Allocate new rule. */ rule = ofproto->ofproto_class->rule_alloc(); if (!rule) { - cls_rule_destroy(&cr); - VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)", - ofproto->name, ovs_strerror(error)); - return ENOMEM; + cls_rule_destroy(cr); + VLOG_WARN_RL(&rl, "%s: failed to allocate a rule.", ofproto->name); + return OFPERR_OFPFMFC_UNKNOWN; } /* Initialize base state. */ *CONST_CAST(struct ofproto **, &rule->ofproto) = ofproto; - cls_rule_move(CONST_CAST(struct cls_rule *, &rule->cr), &cr); + cls_rule_move(CONST_CAST(struct cls_rule *, &rule->cr), cr); ovs_refcount_init(&rule->ref_count); rule->flow_cookie = fm->new_cookie; rule->created = rule->modified = time_msec(); @@ -4081,12 +4634,13 @@ add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm, ovs_mutex_lock(&rule->mutex); rule->idle_timeout = fm->idle_timeout; rule->hard_timeout = fm->hard_timeout; - ovs_mutex_unlock(&rule->mutex); + rule->importance = fm->importance; + rule->removed_reason = OVS_OFPRR_NONE; - *CONST_CAST(uint8_t *, &rule->table_id) = table - ofproto->tables; + *CONST_CAST(uint8_t *, &rule->table_id) = table_id; rule->flags = fm->flags & OFPUTIL_FF_STATE; - actions = rule_actions_create(fm->ofpacts, fm->ofpacts_len); - ovsrcu_set(&rule->actions, actions); + *CONST_CAST(const struct rule_actions **, &rule->actions) + = rule_actions_create(fm->ofpacts, fm->ofpacts_len); list_init(&rule->meter_list_node); rule->eviction_group = NULL; list_init(&rule->expirable); @@ -4094,6 +4648,28 @@ add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm, rule->add_seqno = 0; rule->modify_seqno = 0; + /* Copy values from old rule for modify semantics. */ + if (old_rule && fm->delete_reason != OFPRR_EVICTION) { + /* 'fm' says that */ + bool change_cookie = (fm->modify_cookie + && fm->new_cookie != OVS_BE64_MAX + && fm->new_cookie != old_rule->flow_cookie); + + ovs_mutex_lock(&old_rule->mutex); + if (fm->command != OFPFC_ADD) { + rule->idle_timeout = old_rule->idle_timeout; + rule->hard_timeout = old_rule->hard_timeout; + rule->importance = old_rule->importance; + rule->flags = old_rule->flags; + rule->created = old_rule->created; + } + if (!change_cookie) { + rule->flow_cookie = old_rule->flow_cookie; + } + ovs_mutex_unlock(&old_rule->mutex); + } + ovs_mutex_unlock(&rule->mutex); + /* Construct rule, initializing derived state. */ error = ofproto->ofproto_class->rule_construct(rule); if (error) { @@ -4101,167 +4677,177 @@ add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm, return error; } - if (fm->hard_timeout || fm->idle_timeout) { - list_insert(&ofproto->expirable, &rule->expirable); - } - cookies_insert(ofproto, rule); - eviction_group_add_rule(rule); - if (actions->has_meter) { - meter_insert_rule(rule); - } + rule->removed = true; /* Not yet in ofproto data structures. */ - fat_rwlock_wrlock(&table->cls.rwlock); - classifier_insert(&table->cls, CONST_CAST(struct cls_rule *, &rule->cr)); - fat_rwlock_unlock(&table->cls.rwlock); + *new_rule = rule; + return 0; +} - error = ofproto->ofproto_class->rule_insert(rule); - if (error) { - oftable_remove_rule(rule); - ofproto_rule_unref(rule); - return error; - } - learned_cookies_inc(ofproto, actions); +static void +replace_rule_start(struct ofproto *ofproto, + struct rule *old_rule, struct rule *new_rule, + struct cls_conjunction *conjs, size_t n_conjs) +{ + struct oftable *table = &ofproto->tables[new_rule->table_id]; - if (minimask_get_vid_mask(&rule->cr.match.mask) == VLAN_VID_MASK) { - if (ofproto->vlan_bitmap) { - uint16_t vid = miniflow_get_vid(&rule->cr.match.flow); - if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) { - bitmap_set1(ofproto->vlan_bitmap, vid); - ofproto->vlans_changed = true; - } - } else { - ofproto->vlans_changed = true; - } + /* 'old_rule' may be either an evicted rule or replaced rule. */ + if (old_rule) { + /* Mark the old rule for removal in the next version. */ + cls_rule_make_invisible_in_version(&old_rule->cr, + ofproto->tables_version + 1); + } else { + table->n_flows++; } + /* Insert flow to the classifier, so that later flow_mods may relate + * to it. This is reversible, in case later errors require this to + * be reverted. */ + ofproto_rule_insert__(ofproto, new_rule); + /* Make the new rule visible for classifier lookups only from the next + * version. */ + classifier_insert(&table->cls, &new_rule->cr, conjs, n_conjs); +} - ofmonitor_report(ofproto->connmgr, rule, NXFME_ADDED, 0, - req ? req->ofconn : NULL, req ? req->xid : 0, NULL); +static void replace_rule_revert(struct ofproto *ofproto, + struct rule *old_rule, struct rule *new_rule) +{ + struct oftable *table = &ofproto->tables[new_rule->table_id]; - return req ? send_buffered_packet(req->ofconn, fm->buffer_id, rule) : 0; + if (old_rule) { + /* Restore the original visibility of the old rule. */ + cls_rule_restore_visibility(&old_rule->cr); + } else { + /* Restore table's rule count. */ + table->n_flows--; + } + + /* Remove the new rule immediately. It was never visible to lookups. */ + if (!classifier_remove(&table->cls, &new_rule->cr)) { + OVS_NOT_REACHED(); + } + ofproto_rule_remove__(ofproto, new_rule); + /* The rule was not inserted to the ofproto provider, so we can + * release it without deleting it from the ofproto provider. */ + ofproto_rule_unref(new_rule); } - -/* OFPFC_MODIFY and OFPFC_MODIFY_STRICT. */ -/* Modifies the rules listed in 'rules', changing their actions to match those - * in 'fm'. - * - * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id, - * if any. - * - * Returns 0 on success, otherwise an OpenFlow error code. */ -static enum ofperr -modify_flows__(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct rule_collection *rules, - const struct flow_mod_requester *req) +/* Adds the 'new_rule', replacing the 'old_rule'. */ +static void +replace_rule_finish(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req, + struct rule *old_rule, struct rule *new_rule, + struct ovs_list *dead_cookies) OVS_REQUIRES(ofproto_mutex) { - struct list dead_cookies = LIST_INITIALIZER(&dead_cookies); - enum nx_flow_update_event event; - size_t i; + bool forward_stats = !(fm->flags & OFPUTIL_FF_RESET_COUNTS); + struct rule *replaced_rule; + + replaced_rule = fm->delete_reason != OFPRR_EVICTION ? old_rule : NULL; + + /* Insert the new flow to the ofproto provider. A non-NULL 'replaced_rule' + * is a duplicate rule the 'new_rule' is replacing. The provider should + * link the stats from the old rule to the new one if 'forward_stats' is + * 'true'. The 'replaced_rule' will be deleted right after this call. */ + ofproto->ofproto_class->rule_insert(new_rule, replaced_rule, + forward_stats); + learned_cookies_inc(ofproto, rule_get_actions(new_rule)); + + if (old_rule) { + const struct rule_actions *old_actions = rule_get_actions(old_rule); + + /* Remove the old rule from data structures. Removal from the + * classifier and the deletion of the rule is RCU postponed by the + * caller. */ + ofproto_rule_remove__(ofproto, old_rule); + learned_cookies_dec(ofproto, old_actions, dead_cookies); + + if (replaced_rule) { + enum nx_flow_update_event event = fm->command == OFPFC_ADD + ? NXFME_ADDED : NXFME_MODIFIED; + + bool change_cookie = (fm->modify_cookie + && fm->new_cookie != OVS_BE64_MAX + && fm->new_cookie != old_rule->flow_cookie); + + bool change_actions = !ofpacts_equal(fm->ofpacts, + fm->ofpacts_len, + old_actions->ofpacts, + old_actions->ofpacts_len); + + if (event != NXFME_MODIFIED || change_actions || change_cookie) { + ofmonitor_report(ofproto->connmgr, new_rule, event, 0, + req ? req->ofconn : NULL, + req ? req->request->xid : 0, + change_actions ? old_actions : NULL); + } + } else { + /* XXX: This is slight duplication with delete_flows_finish__() */ - if (ofproto->ofproto_class->rule_premodify_actions) { - for (i = 0; i < rules->n; i++) { - struct rule *rule = rules->rules[i]; - enum ofperr error; + old_rule->removed_reason = OFPRR_EVICTION; - error = ofproto->ofproto_class->rule_premodify_actions( - rule, fm->ofpacts, fm->ofpacts_len); - if (error) { - return error; - } + ofmonitor_report(ofproto->connmgr, old_rule, NXFME_DELETED, + OFPRR_EVICTION, + req ? req->ofconn : NULL, + req ? req->request->xid : 0, NULL); } } +} - event = fm->command == OFPFC_ADD ? NXFME_ADDED : NXFME_MODIFIED; - for (i = 0; i < rules->n; i++) { - struct rule *rule = rules->rules[i]; - - /* 'fm' says that */ - bool change_cookie = (fm->modify_cookie - && fm->new_cookie != OVS_BE64_MAX - && fm->new_cookie != rule->flow_cookie); - - const struct rule_actions *actions = rule_get_actions(rule); - bool change_actions = !ofpacts_equal(fm->ofpacts, fm->ofpacts_len, - actions->ofpacts, - actions->ofpacts_len); - - bool reset_counters = (fm->flags & OFPUTIL_FF_RESET_COUNTS) != 0; - - long long int now = time_msec(); +static enum ofperr +modify_flows_start__(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule_collection *old_rules, + struct rule_collection *new_rules) + OVS_REQUIRES(ofproto_mutex) +{ + enum ofperr error; - /* FIXME: Implement OFPFUTIL_FF_RESET_COUNTS */ + rule_collection_init(new_rules); - if (change_cookie) { - cookies_remove(ofproto, rule); - } + if (old_rules->n > 0) { + struct cls_conjunction *conjs; + size_t n_conjs; + size_t i; - ovs_mutex_lock(&rule->mutex); - if (fm->command == OFPFC_ADD) { - rule->idle_timeout = fm->idle_timeout; - rule->hard_timeout = fm->hard_timeout; - rule->flags = fm->flags & OFPUTIL_FF_STATE; - rule->created = now; - } - if (change_cookie) { - rule->flow_cookie = fm->new_cookie; - } - rule->modified = now; - ovs_mutex_unlock(&rule->mutex); + /* Create a new 'modified' rule for each old rule. */ + for (i = 0; i < old_rules->n; i++) { + struct rule *old_rule = old_rules->rules[i]; + struct rule *new_rule; + struct cls_rule cr; - if (change_cookie) { - cookies_insert(ofproto, rule); - } - if (fm->command == OFPFC_ADD) { - if (fm->idle_timeout || fm->hard_timeout) { - if (!rule->eviction_group) { - eviction_group_add_rule(rule); - } + cls_rule_clone_in_version(&cr, &old_rule->cr, + ofproto->tables_version + 1); + error = replace_rule_create(ofproto, fm, &cr, old_rule->table_id, + old_rule, &new_rule); + if (!error) { + rule_collection_add(new_rules, new_rule); } else { - eviction_group_remove_rule(rule); + rule_collection_unref(new_rules); + rule_collection_destroy(new_rules); + return error; } } + ovs_assert(new_rules->n == old_rules->n); - if (change_actions) { - ovsrcu_set(&rule->actions, rule_actions_create(fm->ofpacts, - fm->ofpacts_len)); - } - - if (change_actions || reset_counters) { - ofproto->ofproto_class->rule_modify_actions(rule, reset_counters); + get_conjunctions(fm, &conjs, &n_conjs); + for (i = 0; i < old_rules->n; i++) { + replace_rule_start(ofproto, old_rules->rules[i], + new_rules->rules[i], conjs, n_conjs); } - - if (event != NXFME_MODIFIED || change_actions || change_cookie) { - ofmonitor_report(ofproto->connmgr, rule, event, 0, - req ? req->ofconn : NULL, req ? req->xid : 0, - change_actions ? actions : NULL); - } - - if (change_actions) { - learned_cookies_inc(ofproto, rule_get_actions(rule)); - learned_cookies_dec(ofproto, actions, &dead_cookies); - rule_actions_destroy(actions); + free(conjs); + } else if (!(fm->cookie_mask != htonll(0) + || fm->new_cookie == OVS_BE64_MAX)) { + /* No match, add a new flow. */ + error = add_flow_start(ofproto, fm, &old_rules->rules[0], + &new_rules->rules[0]); + if (!error) { + ovs_assert(fm->delete_reason == OFPRR_EVICTION + || !old_rules->rules[0]); } + new_rules->n = 1; + } else { + error = 0; } - learned_cookies_flush(ofproto, &dead_cookies); - - if (fm->buffer_id != UINT32_MAX && req) { - return send_buffered_packet(req->ofconn, fm->buffer_id, - rules->rules[0]); - } - - return 0; -} -static enum ofperr -modify_flows_add(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) - OVS_REQUIRES(ofproto_mutex) -{ - if (fm->cookie_mask != htonll(0) || fm->new_cookie == OVS_BE64_MAX) { - return 0; - } - return add_flow(ofproto, fm, req); + return error; } /* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code on @@ -4270,165 +4856,265 @@ modify_flows_add(struct ofproto *ofproto, struct ofputil_flow_mod *fm, * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id, * if any. */ static enum ofperr -modify_flows_loose(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) +modify_flows_start_loose(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule_collection *old_rules, + struct rule_collection *new_rules) OVS_REQUIRES(ofproto_mutex) { struct rule_criteria criteria; - struct rule_collection rules; - int error; + enum ofperr error; - rule_criteria_init(&criteria, fm->table_id, &fm->match, 0, + rule_criteria_init(&criteria, fm->table_id, &fm->match, 0, CLS_MAX_VERSION, fm->cookie, fm->cookie_mask, OFPP_ANY, OFPG11_ANY); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); - error = collect_rules_loose(ofproto, &criteria, &rules); + error = collect_rules_loose(ofproto, &criteria, old_rules); rule_criteria_destroy(&criteria); if (!error) { - error = (rules.n > 0 - ? modify_flows__(ofproto, fm, &rules, req) - : modify_flows_add(ofproto, fm, req)); + error = modify_flows_start__(ofproto, fm, old_rules, new_rules); } - rule_collection_destroy(&rules); - + if (error) { + rule_collection_destroy(old_rules); + } return error; } +static void +modify_flows_revert(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule_collection *old_rules, + struct rule_collection *new_rules) + OVS_REQUIRES(ofproto_mutex) +{ + /* Old rules were not changed yet, only need to revert new rules. */ + if (old_rules->n == 0 && new_rules->n == 1) { + add_flow_revert(ofproto, fm, old_rules->rules[0], new_rules->rules[0]); + } else if (old_rules->n > 0) { + for (size_t i = 0; i < old_rules->n; i++) { + replace_rule_revert(ofproto, old_rules->rules[i], + new_rules->rules[i]); + } + rule_collection_destroy(new_rules); + rule_collection_destroy(old_rules); + } +} + +static void +modify_flows_finish(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req, + struct rule_collection *old_rules, + struct rule_collection *new_rules) + OVS_REQUIRES(ofproto_mutex) +{ + if (old_rules->n == 0 && new_rules->n == 1) { + add_flow_finish(ofproto, fm, req, old_rules->rules[0], + new_rules->rules[0]); + } else if (old_rules->n > 0) { + struct ovs_list dead_cookies = OVS_LIST_INITIALIZER(&dead_cookies); + + ovs_assert(new_rules->n == old_rules->n); + + for (size_t i = 0; i < old_rules->n; i++) { + replace_rule_finish(ofproto, fm, req, old_rules->rules[i], + new_rules->rules[i], &dead_cookies); + } + learned_cookies_flush(ofproto, &dead_cookies); + rule_collection_remove_postponed(old_rules); + + send_buffered_packet(req, fm->buffer_id, new_rules->rules[0]); + rule_collection_destroy(new_rules); + } +} + /* Implements OFPFC_MODIFY_STRICT. Returns 0 on success or an OpenFlow error * code on failure. */ static enum ofperr -modify_flow_strict(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) +modify_flow_start_strict(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct rule_collection *old_rules, + struct rule_collection *new_rules) OVS_REQUIRES(ofproto_mutex) { struct rule_criteria criteria; - struct rule_collection rules; - int error; + enum ofperr error; rule_criteria_init(&criteria, fm->table_id, &fm->match, fm->priority, - fm->cookie, fm->cookie_mask, OFPP_ANY, OFPG11_ANY); + CLS_MAX_VERSION, fm->cookie, fm->cookie_mask, OFPP_ANY, + OFPG11_ANY); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); - error = collect_rules_strict(ofproto, &criteria, &rules); + error = collect_rules_strict(ofproto, &criteria, old_rules); rule_criteria_destroy(&criteria); if (!error) { - if (rules.n == 0) { - error = modify_flows_add(ofproto, fm, req); - } else if (rules.n == 1) { - error = modify_flows__(ofproto, fm, &rules, req); - } + /* collect_rules_strict() can return max 1 rule. */ + error = modify_flows_start__(ofproto, fm, old_rules, new_rules); } - rule_collection_destroy(&rules); - + if (error) { + rule_collection_destroy(old_rules); + } return error; } /* OFPFC_DELETE implementation. */ -/* Deletes the rules listed in 'rules'. */ static void -delete_flows__(const struct rule_collection *rules, - enum ofp_flow_removed_reason reason, - const struct flow_mod_requester *req) +delete_flows_start__(struct ofproto *ofproto, + const struct rule_collection *rules) + OVS_REQUIRES(ofproto_mutex) +{ + for (size_t i = 0; i < rules->n; i++) { + struct rule *rule = rules->rules[i]; + struct oftable *table = &ofproto->tables[rule->table_id]; + + table->n_flows--; + cls_rule_make_invisible_in_version(&rule->cr, + ofproto->tables_version + 1); + } +} + +static void +delete_flows_finish__(struct ofproto *ofproto, + struct rule_collection *rules, + enum ofp_flow_removed_reason reason, + const struct flow_mod_requester *req) OVS_REQUIRES(ofproto_mutex) { if (rules->n) { - struct list dead_cookies = LIST_INITIALIZER(&dead_cookies); - struct ofproto *ofproto = rules->rules[0]->ofproto; - size_t i; + struct ovs_list dead_cookies = OVS_LIST_INITIALIZER(&dead_cookies); - for (i = 0; i < rules->n; i++) { + for (size_t i = 0; i < rules->n; i++) { struct rule *rule = rules->rules[i]; - const struct rule_actions *actions = rule_get_actions(rule); - ofproto_rule_send_removed(rule, reason); + /* This value will be used to send the flow removed message right + * before the rule is actually destroyed. */ + rule->removed_reason = reason; ofmonitor_report(ofproto->connmgr, rule, NXFME_DELETED, reason, - req ? req->ofconn : NULL, req ? req->xid : 0, - NULL); - oftable_remove_rule(rule); - ofproto->ofproto_class->rule_delete(rule); - - learned_cookies_dec(ofproto, actions, &dead_cookies); + req ? req->ofconn : NULL, + req ? req->request->xid : 0, NULL); + ofproto_rule_remove__(ofproto, rule); + learned_cookies_dec(ofproto, rule_get_actions(rule), + &dead_cookies); } + rule_collection_remove_postponed(rules); + learned_cookies_flush(ofproto, &dead_cookies); + } +} + +/* Deletes the rules listed in 'rules'. + * The deleted rules will become invisible to the lookups in the next version. + * Destroys 'rules'. */ +static void +delete_flows__(struct rule_collection *rules, + enum ofp_flow_removed_reason reason, + const struct flow_mod_requester *req) + OVS_REQUIRES(ofproto_mutex) +{ + if (rules->n) { + struct ofproto *ofproto = rules->rules[0]->ofproto; + + delete_flows_start__(ofproto, rules); + ofproto_bump_tables_version(ofproto); + delete_flows_finish__(ofproto, rules, reason, req); ofmonitor_flush(ofproto->connmgr); } } /* Implements OFPFC_DELETE. */ static enum ofperr -delete_flows_loose(struct ofproto *ofproto, - const struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) +delete_flows_start_loose(struct ofproto *ofproto, + const struct ofputil_flow_mod *fm, + struct rule_collection *rules) OVS_REQUIRES(ofproto_mutex) { struct rule_criteria criteria; - struct rule_collection rules; enum ofperr error; - rule_criteria_init(&criteria, fm->table_id, &fm->match, 0, - fm->cookie, fm->cookie_mask, - fm->out_port, fm->out_group); + rule_criteria_init(&criteria, fm->table_id, &fm->match, 0, CLS_MAX_VERSION, + fm->cookie, fm->cookie_mask, fm->out_port, + fm->out_group); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); - error = collect_rules_loose(ofproto, &criteria, &rules); + error = collect_rules_loose(ofproto, &criteria, rules); rule_criteria_destroy(&criteria); - if (!error && rules.n > 0) { - delete_flows__(&rules, fm->delete_reason, req); + if (!error) { + delete_flows_start__(ofproto, rules); } - rule_collection_destroy(&rules); return error; } +static void +delete_flows_revert(struct ofproto *ofproto, + struct rule_collection *rules) + OVS_REQUIRES(ofproto_mutex) +{ + for (size_t i = 0; i < rules->n; i++) { + struct rule *rule = rules->rules[i]; + struct oftable *table = &ofproto->tables[rule->table_id]; + + /* Restore table's rule count. */ + table->n_flows++; + + /* Restore the original visibility of the rule. */ + cls_rule_restore_visibility(&rule->cr); + } + rule_collection_destroy(rules); +} + +static void +delete_flows_finish(struct ofproto *ofproto, + const struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req, + struct rule_collection *rules) + OVS_REQUIRES(ofproto_mutex) +{ + delete_flows_finish__(ofproto, rules, fm->delete_reason, req); +} + /* Implements OFPFC_DELETE_STRICT. */ static enum ofperr -delete_flow_strict(struct ofproto *ofproto, const struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) +delete_flow_start_strict(struct ofproto *ofproto, + const struct ofputil_flow_mod *fm, + struct rule_collection *rules) OVS_REQUIRES(ofproto_mutex) { struct rule_criteria criteria; - struct rule_collection rules; enum ofperr error; rule_criteria_init(&criteria, fm->table_id, &fm->match, fm->priority, - fm->cookie, fm->cookie_mask, + CLS_MAX_VERSION, fm->cookie, fm->cookie_mask, fm->out_port, fm->out_group); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); - error = collect_rules_strict(ofproto, &criteria, &rules); + error = collect_rules_strict(ofproto, &criteria, rules); rule_criteria_destroy(&criteria); - if (!error && rules.n > 0) { - delete_flows__(&rules, fm->delete_reason, req); + if (!error) { + delete_flows_start__(ofproto, rules); } - rule_collection_destroy(&rules); return error; } +/* This may only be called by rule_destroy_cb()! */ static void -ofproto_rule_send_removed(struct rule *rule, uint8_t reason) - OVS_REQUIRES(ofproto_mutex) +ofproto_rule_send_removed(struct rule *rule) + OVS_EXCLUDED(ofproto_mutex) { struct ofputil_flow_removed fr; long long int used; - if (rule_is_hidden(rule) || - !(rule->flags & OFPUTIL_FF_SEND_FLOW_REM)) { - return; - } - minimatch_expand(&rule->cr.match, &fr.match); fr.priority = rule->cr.priority; + + ovs_mutex_lock(&ofproto_mutex); fr.cookie = rule->flow_cookie; - fr.reason = reason; + fr.reason = rule->removed_reason; fr.table_id = rule->table_id; calc_duration(rule->created, time_msec(), &fr.duration_sec, &fr.duration_nsec); @@ -4438,8 +5124,8 @@ ofproto_rule_send_removed(struct rule *rule, uint8_t reason) ovs_mutex_unlock(&rule->mutex); rule->ofproto->ofproto_class->rule_get_stats(rule, &fr.packet_count, &fr.byte_count, &used); - connmgr_send_flow_removed(rule->ofproto->connmgr, &fr); + ovs_mutex_unlock(&ofproto_mutex); } /* Sends an OpenFlow "flow removed" message with the given 'reason' (either @@ -4452,7 +5138,12 @@ void ofproto_rule_expire(struct rule *rule, uint8_t reason) OVS_REQUIRES(ofproto_mutex) { - ofproto_rule_delete__(rule, reason); + struct rule_collection rules; + + rules.rules = rules.stub; + rules.n = 1; + rules.stub[0] = rule; + delete_flows__(&rules, reason, NULL); } /* Reduces '*timeout' to no more than 'max'. A value of zero in either case @@ -4518,7 +5209,7 @@ handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh) struct flow_mod_requester req; req.ofconn = ofconn; - req.xid = oh->xid; + req.request = oh; error = handle_flow_mod__(ofproto, &fm, &req); } if (error) { @@ -4533,43 +5224,19 @@ exit: return error; } -static enum ofperr -handle_flow_mod__(struct ofproto *ofproto, struct ofputil_flow_mod *fm, - const struct flow_mod_requester *req) - OVS_EXCLUDED(ofproto_mutex) -{ - enum ofperr error; - - ovs_mutex_lock(&ofproto_mutex); - switch (fm->command) { - case OFPFC_ADD: - error = add_flow(ofproto, fm, req); - break; - - case OFPFC_MODIFY: - error = modify_flows_loose(ofproto, fm, req); - break; - - case OFPFC_MODIFY_STRICT: - error = modify_flow_strict(ofproto, fm, req); - break; - - case OFPFC_DELETE: - error = delete_flows_loose(ofproto, fm, req); - break; - - case OFPFC_DELETE_STRICT: - error = delete_flow_strict(ofproto, fm, req); - break; +static enum ofperr +handle_flow_mod__(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req) + OVS_EXCLUDED(ofproto_mutex) +{ + struct ofp_bundle_entry be; + enum ofperr error; - default: - if (fm->command > 0xff) { - VLOG_WARN_RL(&rl, "%s: flow_mod has explicit table_id but " - "flow_mod_table_id extension is not enabled", - ofproto->name); - } - error = OFPERR_OFPFMFC_BAD_COMMAND; - break; + ovs_mutex_lock(&ofproto_mutex); + error = do_bundle_flow_mod_start(ofproto, fm, &be); + if (!error) { + ofproto_bump_tables_version(ofproto); + do_bundle_flow_mod_finish(ofproto, fm, req, &be); } ofmonitor_flush(ofproto->connmgr); ovs_mutex_unlock(&ofproto_mutex); @@ -4736,7 +5403,7 @@ handle_barrier_request(struct ofconn *ofconn, const struct ofp_header *oh) static void ofproto_compose_flow_refresh_update(const struct rule *rule, enum nx_flow_monitor_flags flags, - struct list *msgs) + struct ovs_list *msgs) OVS_REQUIRES(ofproto_mutex) { const struct rule_actions *actions; @@ -4768,7 +5435,7 @@ ofproto_compose_flow_refresh_update(const struct rule *rule, void ofmonitor_compose_refresh_updates(struct rule_collection *rules, - struct list *msgs) + struct ovs_list *msgs) OVS_REQUIRES(ofproto_mutex) { size_t i; @@ -4830,17 +5497,13 @@ ofproto_collect_ofmonitor_refresh_rules(const struct ofmonitor *m, const struct oftable *table; struct cls_rule target; - cls_rule_init_from_minimatch(&target, &m->match, 0); + cls_rule_init_from_minimatch(&target, &m->match, 0, CLS_MAX_VERSION); FOR_EACH_MATCHING_TABLE (table, m->table_id, ofproto) { - struct cls_cursor cursor; struct rule *rule; - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, &target); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH_TARGET (rule, cr, &table->cls, &target) { ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules); } - fat_rwlock_unlock(&table->cls.rwlock); } cls_rule_destroy(&target); } @@ -4889,12 +5552,11 @@ handle_flow_monitor_request(struct ofconn *ofconn, const struct ofp_header *oh) struct ofmonitor **monitors; size_t n_monitors, allocated_monitors; struct rule_collection rules; - struct list replies; + struct ovs_list replies; enum ofperr error; struct ofpbuf b; size_t i; - error = 0; ofpbuf_use_const(&b, oh, ntohs(oh->length)); monitors = NULL; n_monitors = allocated_monitors = 0; @@ -4983,7 +5645,7 @@ handle_flow_monitor_cancel(struct ofconn *ofconn, const struct ofp_header *oh) */ struct meter { long long int created; /* Time created. */ - struct list rules; /* List of "struct rule_dpif"s. */ + struct ovs_list rules; /* List of "struct rule_dpif"s. */ ofproto_meter_id provider_meter_id; uint16_t flags; /* Meter flags. */ uint16_t n_bands; /* Number of meter bands. */ @@ -5139,15 +5801,12 @@ handle_delete_meter(struct ofconn *ofconn, struct ofputil_meter_mod *mm) } } } - if (rules.n > 0) { - delete_flows__(&rules, OFPRR_METER_DELETE, NULL); - } + delete_flows__(&rules, OFPRR_METER_DELETE, NULL); /* Delete the meters. */ meter_delete(ofproto, first, last); ovs_mutex_unlock(&ofproto_mutex); - rule_collection_destroy(&rules); return error; } @@ -5238,7 +5897,7 @@ handle_meter_request(struct ofconn *ofconn, const struct ofp_header *request, enum ofptype type) { struct ofproto *ofproto = ofconn_get_ofproto(ofconn); - struct list replies; + struct ovs_list replies; uint64_t bands_stub[256 / 8]; struct ofpbuf bands; uint32_t meter_id, first, last; @@ -5374,8 +6033,8 @@ group_get_ref_count(struct ofgroup *group) uint32_t count; match_init_catchall(&match); - rule_criteria_init(&criteria, 0xff, &match, 0, htonll(0), htonll(0), - OFPP_ANY, group->group_id); + rule_criteria_init(&criteria, 0xff, &match, 0, CLS_MAX_VERSION, htonll(0), + htonll(0), OFPP_ANY, group->group_id); ovs_mutex_lock(&ofproto_mutex); error = collect_rules_loose(ofproto, &criteria, &rules); ovs_mutex_unlock(&ofproto_mutex); @@ -5388,7 +6047,7 @@ group_get_ref_count(struct ofgroup *group) } static void -append_group_stats(struct ofgroup *group, struct list *replies) +append_group_stats(struct ofgroup *group, struct ovs_list *replies) { struct ofputil_group_stats ogs; const struct ofproto *ofproto = group->ofproto; @@ -5422,11 +6081,11 @@ append_group_stats(struct ofgroup *group, struct list *replies) static void handle_group_request(struct ofconn *ofconn, const struct ofp_header *request, uint32_t group_id, - void (*cb)(struct ofgroup *, struct list *replies)) + void (*cb)(struct ofgroup *, struct ovs_list *replies)) { struct ofproto *ofproto = ofconn_get_ofproto(ofconn); struct ofgroup *group; - struct list replies; + struct ovs_list replies; ofpmp_init(&replies, request); if (group_id == OFPG_ALL) { @@ -5461,12 +6120,14 @@ handle_group_stats_request(struct ofconn *ofconn, } static void -append_group_desc(struct ofgroup *group, struct list *replies) +append_group_desc(struct ofgroup *group, struct ovs_list *replies) { struct ofputil_group_desc gds; gds.group_id = group->group_id; gds.type = group->type; + gds.props = group->props; + ofputil_append_group_desc_reply(&gds, &group->buckets, replies); } @@ -5569,6 +6230,9 @@ init_group(struct ofproto *ofproto, struct ofputil_group_mod *gm, *CONST_CAST(uint32_t *, &(*ofgroup)->n_buckets) = list_size(&(*ofgroup)->buckets); + memcpy(CONST_CAST(struct ofputil_group_props *, &(*ofgroup)->props), + &gm->props, sizeof (struct ofputil_group_props)); + /* Construct called BEFORE any locks are held. */ error = ofproto->ofproto_class->group_construct(*ofgroup); if (error) { @@ -5626,7 +6290,102 @@ add_group(struct ofproto *ofproto, struct ofputil_group_mod *gm) return error; } -/* Implements OFPGC11_MODIFY. Returns 0 on success or an OpenFlow error code +/* Adds all of the buckets from 'ofgroup' to 'new_ofgroup'. The buckets + * already in 'new_ofgroup' will be placed just after the (copy of the) bucket + * in 'ofgroup' with bucket ID 'command_bucket_id'. Special + * 'command_bucket_id' values OFPG15_BUCKET_FIRST and OFPG15_BUCKET_LAST are + * also honored. */ +static enum ofperr +copy_buckets_for_insert_bucket(const struct ofgroup *ofgroup, + struct ofgroup *new_ofgroup, + uint32_t command_bucket_id) +{ + struct ofputil_bucket *last = NULL; + + if (command_bucket_id <= OFPG15_BUCKET_MAX) { + /* Check here to ensure that a bucket corresponding to + * command_bucket_id exists in the old bucket list. + * + * The subsequent search of below of new_ofgroup covers + * both buckets in the old bucket list and buckets added + * by the insert buckets group mod message this function processes. */ + if (!ofputil_bucket_find(&ofgroup->buckets, command_bucket_id)) { + return OFPERR_OFPGMFC_UNKNOWN_BUCKET; + } + + if (!list_is_empty(&new_ofgroup->buckets)) { + last = ofputil_bucket_list_back(&new_ofgroup->buckets); + } + } + + ofputil_bucket_clone_list(&new_ofgroup->buckets, &ofgroup->buckets, NULL); + + if (ofputil_bucket_check_duplicate_id(&ofgroup->buckets)) { + VLOG_WARN_RL(&rl, "Duplicate bucket id"); + return OFPERR_OFPGMFC_BUCKET_EXISTS; + } + + /* Rearrange list according to command_bucket_id */ + if (command_bucket_id == OFPG15_BUCKET_LAST) { + struct ofputil_bucket *new_first; + const struct ofputil_bucket *first; + + first = ofputil_bucket_list_front(&ofgroup->buckets); + new_first = ofputil_bucket_find(&new_ofgroup->buckets, + first->bucket_id); + + list_splice(new_ofgroup->buckets.next, &new_first->list_node, + &new_ofgroup->buckets); + } else if (command_bucket_id <= OFPG15_BUCKET_MAX && last) { + struct ofputil_bucket *after; + + /* Presence of bucket is checked above so after should never be NULL */ + after = ofputil_bucket_find(&new_ofgroup->buckets, command_bucket_id); + + list_splice(after->list_node.next, new_ofgroup->buckets.next, + last->list_node.next); + } + + return 0; +} + +/* Appends all of the a copy of all the buckets from 'ofgroup' to 'new_ofgroup' + * with the exception of the bucket whose bucket id is 'command_bucket_id'. + * Special 'command_bucket_id' values OFPG15_BUCKET_FIRST, OFPG15_BUCKET_LAST + * and OFPG15_BUCKET_ALL are also honored. */ +static enum ofperr +copy_buckets_for_remove_bucket(const struct ofgroup *ofgroup, + struct ofgroup *new_ofgroup, + uint32_t command_bucket_id) +{ + const struct ofputil_bucket *skip = NULL; + + if (command_bucket_id == OFPG15_BUCKET_ALL) { + return 0; + } + + if (command_bucket_id == OFPG15_BUCKET_FIRST) { + if (!list_is_empty(&ofgroup->buckets)) { + skip = ofputil_bucket_list_front(&ofgroup->buckets); + } + } else if (command_bucket_id == OFPG15_BUCKET_LAST) { + if (!list_is_empty(&ofgroup->buckets)) { + skip = ofputil_bucket_list_back(&ofgroup->buckets); + } + } else { + skip = ofputil_bucket_find(&ofgroup->buckets, command_bucket_id); + if (!skip) { + return OFPERR_OFPGMFC_UNKNOWN_BUCKET; + } + } + + ofputil_bucket_clone_list(&new_ofgroup->buckets, &ofgroup->buckets, skip); + + return 0; +} + +/* Implements OFPGC11_MODIFY, OFPGC15_INSERT_BUCKET and + * OFPGC15_REMOVE_BUCKET. Returns 0 on success or an OpenFlow error code * on failure. * * Note that the group is re-created and then replaces the old group in @@ -5658,6 +6417,18 @@ modify_group(struct ofproto *ofproto, struct ofputil_group_mod *gm) goto out; } + /* Manipulate bucket list for bucket commands */ + if (gm->command == OFPGC15_INSERT_BUCKET) { + error = copy_buckets_for_insert_bucket(ofgroup, new_ofgroup, + gm->command_bucket_id); + } else if (gm->command == OFPGC15_REMOVE_BUCKET) { + error = copy_buckets_for_remove_bucket(ofgroup, new_ofgroup, + gm->command_bucket_id); + } + if (error) { + goto out; + } + /* The group creation time does not change during modification. */ *CONST_CAST(long long int *, &(new_ofgroup->created)) = ofgroup->created; *CONST_CAST(long long int *, &(new_ofgroup->modified)) = time_msec(); @@ -5763,6 +6534,12 @@ handle_group_mod(struct ofconn *ofconn, const struct ofp_header *oh) delete_group(ofproto, gm.group_id); return 0; + case OFPGC15_INSERT_BUCKET: + return modify_group(ofproto, &gm); + + case OFPGC15_REMOVE_BUCKET: + return modify_group(ofproto, &gm); + default: if (gm.command > OFPGC11_DELETE) { VLOG_WARN_RL(&rl, "%s: Invalid group_mod command type %d", @@ -5772,35 +6549,32 @@ handle_group_mod(struct ofconn *ofconn, const struct ofp_header *oh) } } -enum ofproto_table_config -ofproto_table_get_config(const struct ofproto *ofproto, uint8_t table_id) +enum ofputil_table_miss +ofproto_table_get_miss_config(const struct ofproto *ofproto, uint8_t table_id) { - unsigned int value; - atomic_read(&ofproto->tables[table_id].config, &value); - return (enum ofproto_table_config)value; + enum ofputil_table_miss value; + + atomic_read_relaxed(&ofproto->tables[table_id].miss_config, &value); + return value; } static enum ofperr table_mod(struct ofproto *ofproto, const struct ofputil_table_mod *tm) { - /* Only accept currently supported configurations */ - if (tm->config & ~OFPTC11_TABLE_MISS_MASK) { - return OFPERR_OFPTMFC_BAD_CONFIG; - } - - if (tm->table_id == OFPTT_ALL) { - int i; - for (i = 0; i < ofproto->n_tables; i++) { - atomic_store(&ofproto->tables[i].config, - (unsigned int)tm->config); - } - } else if (!check_table_id(ofproto, tm->table_id)) { + if (!check_table_id(ofproto, tm->table_id)) { return OFPERR_OFPTMFC_BAD_TABLE; - } else { - atomic_store(&ofproto->tables[tm->table_id].config, - (unsigned int)tm->config); + } else if (tm->miss_config != OFPUTIL_TABLE_MISS_DEFAULT) { + if (tm->table_id == OFPTT_ALL) { + int i; + for (i = 0; i < ofproto->n_tables; i++) { + atomic_store_relaxed(&ofproto->tables[i].miss_config, + tm->miss_config); + } + } else { + atomic_store_relaxed(&ofproto->tables[tm->table_id].miss_config, + tm->miss_config); + } } - return 0; } @@ -5825,12 +6599,220 @@ handle_table_mod(struct ofconn *ofconn, const struct ofp_header *oh) } static enum ofperr -handle_bundle_control(struct ofconn *ofconn, const struct ofp_header *oh) +do_bundle_flow_mod_start(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct ofp_bundle_entry *be) + OVS_REQUIRES(ofproto_mutex) +{ + switch (fm->command) { + case OFPFC_ADD: + return add_flow_start(ofproto, fm, &be->old_rules.stub[0], + &be->new_rules.stub[0]); + case OFPFC_MODIFY: + return modify_flows_start_loose(ofproto, fm, &be->old_rules, + &be->new_rules); + case OFPFC_MODIFY_STRICT: + return modify_flow_start_strict(ofproto, fm, &be->old_rules, + &be->new_rules); + case OFPFC_DELETE: + return delete_flows_start_loose(ofproto, fm, &be->old_rules); + + case OFPFC_DELETE_STRICT: + return delete_flow_start_strict(ofproto, fm, &be->old_rules); + } + + return OFPERR_OFPFMFC_BAD_COMMAND; +} + +static void +do_bundle_flow_mod_revert(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + struct ofp_bundle_entry *be) + OVS_REQUIRES(ofproto_mutex) +{ + switch (fm->command) { + case OFPFC_ADD: + add_flow_revert(ofproto, fm, be->old_rules.stub[0], + be->new_rules.stub[0]); + break; + + case OFPFC_MODIFY: + case OFPFC_MODIFY_STRICT: + modify_flows_revert(ofproto, fm, &be->old_rules, &be->new_rules); + break; + + case OFPFC_DELETE: + case OFPFC_DELETE_STRICT: + delete_flows_revert(ofproto, &be->old_rules); + break; + + default: + break; + } +} + +static void +do_bundle_flow_mod_finish(struct ofproto *ofproto, struct ofputil_flow_mod *fm, + const struct flow_mod_requester *req, + struct ofp_bundle_entry *be) + OVS_REQUIRES(ofproto_mutex) +{ + switch (fm->command) { + case OFPFC_ADD: + add_flow_finish(ofproto, fm, req, be->old_rules.stub[0], + be->new_rules.stub[0]); + break; + + case OFPFC_MODIFY: + case OFPFC_MODIFY_STRICT: + modify_flows_finish(ofproto, fm, req, &be->old_rules, &be->new_rules); + break; + + case OFPFC_DELETE: + case OFPFC_DELETE_STRICT: + delete_flows_finish(ofproto, fm, req, &be->old_rules); + break; + + default: + break; + } +} + +/* Commit phases (all while locking ofproto_mutex): + * + * 1. Begin: Gather resources and make changes visible in the next version. + * - Mark affected rules for removal in the next version. + * - Create new replacement rules, make visible in the next + * version. + * - Do not send any events or notifications. + * + * 2. Revert: Fail if any errors are found. After this point no errors are + * possible. No visible changes were made, so rollback is minimal (remove + * added invisible rules, restore visibility of rules marked for removal). + * + * 3. Finish: Make the changes visible for lookups. Insert replacement rules to + * the ofproto provider. Remove replaced and deleted rules from ofproto data + * structures, and Schedule postponed removal of deleted rules from the + * classifier. Send notifications, buffered packets, etc. + */ +static enum ofperr +do_bundle_commit(struct ofconn *ofconn, uint32_t id, uint16_t flags) { + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + cls_version_t visible_version = ofproto->tables_version; + struct ofp_bundle *bundle; + struct ofp_bundle_entry *be; enum ofperr error; + + bundle = ofconn_get_bundle(ofconn, id); + + if (!bundle) { + return OFPERR_OFPBFC_BAD_ID; + } + if (bundle->flags != flags) { + error = OFPERR_OFPBFC_BAD_FLAGS; + } else { + bool prev_is_port_mod = false; + + error = 0; + ovs_mutex_lock(&ofproto_mutex); + + /* 1. Begin. */ + LIST_FOR_EACH (be, node, &bundle->msg_list) { + if (be->type == OFPTYPE_PORT_MOD) { + /* Our port mods are not atomic. */ + if (flags & OFPBF_ATOMIC) { + error = OFPERR_OFPBFC_MSG_FAILED; + } else { + prev_is_port_mod = true; + error = port_mod_start(ofconn, &be->pm, &be->port); + } + } else if (be->type == OFPTYPE_FLOW_MOD) { + /* Flow mods between port mods are applied as a single + * version, but the versions are published only after + * we know the commit is successful. */ + if (prev_is_port_mod) { + ++ofproto->tables_version; + } + prev_is_port_mod = false; + error = do_bundle_flow_mod_start(ofproto, &be->fm, be); + } else { + OVS_NOT_REACHED(); + } + if (error) { + break; + } else { + /* Store the version in which the changes should take + * effect. */ + be->version = ofproto->tables_version + 1; + } + } + + if (error) { + /* Send error referring to the original message. */ + if (error) { + ofconn_send_error(ofconn, be->ofp_msg, error); + error = OFPERR_OFPBFC_MSG_FAILED; + } + + /* 2. Revert. Undo all the changes made above. */ + LIST_FOR_EACH_REVERSE_CONTINUE(be, node, &bundle->msg_list) { + if (be->type == OFPTYPE_FLOW_MOD) { + do_bundle_flow_mod_revert(ofproto, &be->fm, be); + } + /* Nothing needs to be reverted for a port mod. */ + } + } else { + /* 4. Finish. */ + LIST_FOR_EACH (be, node, &bundle->msg_list) { + /* Bump the lookup version to the one of the current message. + * This makes all the changes in the bundle at this version + * visible to lookups at once. */ + if (visible_version < be->version) { + visible_version = be->version; + ofproto->ofproto_class->set_tables_version( + ofproto, visible_version); + } + if (be->type == OFPTYPE_FLOW_MOD) { + struct flow_mod_requester req = { ofconn, be->ofp_msg }; + + do_bundle_flow_mod_finish(ofproto, &be->fm, &req, be); + } else if (be->type == OFPTYPE_PORT_MOD) { + /* Perform the actual port mod. This is not atomic, i.e., + * the effects will be immediately seen by upcall + * processing regardless of the lookup version. It should + * be noted that port configuration changes can originate + * also from OVSDB changes asynchronously to all upcall + * processing. */ + port_mod_finish(ofconn, &be->pm, be->port); + } + } + } + + /* Reset the tables_version. */ + ofproto->tables_version = visible_version; + + ofmonitor_flush(ofproto->connmgr); + ovs_mutex_unlock(&ofproto_mutex); + + run_rule_executes(ofproto); + } + + /* The bundle is discarded regardless the outcome. */ + ofp_bundle_remove__(ofconn, bundle, !error); + return error; +} + +static enum ofperr +handle_bundle_control(struct ofconn *ofconn, const struct ofp_header *oh) +{ struct ofputil_bundle_ctrl_msg bctrl; - struct ofpbuf *buf; struct ofputil_bundle_ctrl_msg reply; + struct ofpbuf *buf; + enum ofperr error; + + error = reject_slave_controller(ofconn); + if (error) { + return error; + } error = ofputil_decode_bundle_ctrl(oh, &bctrl); if (error) { @@ -5849,7 +6831,7 @@ handle_bundle_control(struct ofconn *ofconn, const struct ofp_header *oh) reply.type = OFPBCT_CLOSE_REPLY;; break; case OFPBCT_COMMIT_REQUEST: - error = ofp_bundle_commit(ofconn, bctrl.bundle_id, bctrl.flags); + error = do_bundle_commit(ofconn, bctrl.bundle_id, bctrl.flags); reply.type = OFPBCT_COMMIT_REPLY; break; case OFPBCT_DISCARD_REQUEST: @@ -5872,26 +6854,103 @@ handle_bundle_control(struct ofconn *ofconn, const struct ofp_header *oh) return error; } - static enum ofperr handle_bundle_add(struct ofconn *ofconn, const struct ofp_header *oh) { + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); enum ofperr error; struct ofputil_bundle_add_msg badd; + struct ofp_bundle_entry *bmsg; + enum ofptype type; + + error = reject_slave_controller(ofconn); + if (error) { + return error; + } + + error = ofputil_decode_bundle_add(oh, &badd, &type); + if (error) { + return error; + } - error = ofputil_decode_bundle_add(oh, &badd); + bmsg = ofp_bundle_entry_alloc(type, badd.msg); + + if (type == OFPTYPE_PORT_MOD) { + error = ofputil_decode_port_mod(badd.msg, &bmsg->pm, false); + } else if (type == OFPTYPE_FLOW_MOD) { + struct ofpbuf ofpacts; + uint64_t ofpacts_stub[1024 / 8]; + + ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub); + error = ofputil_decode_flow_mod(&bmsg->fm, badd.msg, + ofconn_get_protocol(ofconn), + &ofpacts, + u16_to_ofp(ofproto->max_ports), + ofproto->n_tables); + /* Move actions to heap. */ + bmsg->fm.ofpacts = ofpbuf_steal_data(&ofpacts); + + if (!error && bmsg->fm.ofpacts_len) { + error = ofproto_check_ofpacts(ofproto, bmsg->fm.ofpacts, + bmsg->fm.ofpacts_len); + } + } else { + OVS_NOT_REACHED(); + } + + if (!error) { + error = ofp_bundle_add_message(ofconn, badd.bundle_id, badd.flags, + bmsg); + } + + if (error) { + ofp_bundle_entry_free(bmsg); + } + + return error; +} + +static enum ofperr +handle_geneve_table_mod(struct ofconn *ofconn, const struct ofp_header *oh) +{ + struct ofputil_geneve_table_mod gtm; + enum ofperr error; + + error = reject_slave_controller(ofconn); + if (error) { + return error; + } + + error = ofputil_decode_geneve_table_mod(oh, >m); if (error) { return error; } - return ofp_bundle_add_message(ofconn, &badd); + error = tun_metadata_table_mod(>m); + + ofputil_uninit_geneve_table(>m.mappings); + return error; +} + +static enum ofperr +handle_geneve_table_request(struct ofconn *ofconn, const struct ofp_header *oh) +{ + struct ofputil_geneve_table_reply gtr; + struct ofpbuf *b; + + tun_metadata_table_request(>r); + b = ofputil_encode_geneve_table_reply(oh, >r); + ofputil_uninit_geneve_table(>r.mappings); + + ofconn_send_reply(ofconn, b); + return 0; } static enum ofperr handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) OVS_EXCLUDED(ofproto_mutex) { - const struct ofp_header *oh = ofpbuf_data(msg); + const struct ofp_header *oh = msg->data; enum ofptype type; enum ofperr error; @@ -5988,6 +7047,9 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_TABLE_STATS_REQUEST: return handle_table_stats_request(ofconn, oh); + case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: + return handle_table_features_request(ofconn, oh); + case OFPTYPE_PORT_STATS_REQUEST: return handle_port_stats_request(ofconn, oh); @@ -6025,6 +7087,12 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_BUNDLE_ADD_MESSAGE: return handle_bundle_add(ofconn, oh); + case OFPTYPE_NXT_GENEVE_TABLE_MOD: + return handle_geneve_table_mod(ofconn, oh); + + case OFPTYPE_NXT_GENEVE_TABLE_REQUEST: + return handle_geneve_table_request(ofconn, oh); + case OFPTYPE_HELLO: case OFPTYPE_ERROR: case OFPTYPE_FEATURES_REPLY: @@ -6052,9 +7120,9 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_METER_STATS_REPLY: case OFPTYPE_METER_CONFIG_STATS_REPLY: case OFPTYPE_METER_FEATURES_STATS_REPLY: - case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: case OFPTYPE_TABLE_FEATURES_STATS_REPLY: case OFPTYPE_ROLE_STATUS: + case OFPTYPE_NXT_GENEVE_TABLE_REPLY: default: if (ofpmsg_is_stat_request(oh)) { return OFPERR_OFPBRC_BAD_STAT; @@ -6068,27 +7136,29 @@ static void handle_openflow(struct ofconn *ofconn, const struct ofpbuf *ofp_msg) OVS_EXCLUDED(ofproto_mutex) { - int error = handle_openflow__(ofconn, ofp_msg); + enum ofperr error = handle_openflow__(ofconn, ofp_msg); + if (error) { - ofconn_send_error(ofconn, ofpbuf_data(ofp_msg), error); + ofconn_send_error(ofconn, ofp_msg->data, error); } COVERAGE_INC(ofproto_recv_openflow); } /* Asynchronous operations. */ -static enum ofperr -send_buffered_packet(struct ofconn *ofconn, uint32_t buffer_id, +static void +send_buffered_packet(const struct flow_mod_requester *req, uint32_t buffer_id, struct rule *rule) OVS_REQUIRES(ofproto_mutex) { - enum ofperr error = 0; - if (ofconn && buffer_id != UINT32_MAX) { - struct ofproto *ofproto = ofconn_get_ofproto(ofconn); - struct ofpbuf *packet; + if (req && req->ofconn && buffer_id != UINT32_MAX) { + struct ofproto *ofproto = ofconn_get_ofproto(req->ofconn); + struct dp_packet *packet; ofp_port_t in_port; + enum ofperr error; - error = ofconn_pktbuf_retrieve(ofconn, buffer_id, &packet, &in_port); + error = ofconn_pktbuf_retrieve(req->ofconn, buffer_id, &packet, + &in_port); if (packet) { struct rule_execute *re; @@ -6102,12 +7172,13 @@ send_buffered_packet(struct ofconn *ofconn, uint32_t buffer_id, if (!guarded_list_push_back(&ofproto->rule_executes, &re->list_node, 1024)) { ofproto_rule_unref(rule); - ofpbuf_delete(re->packet); + dp_packet_delete(re->packet); free(re); } + } else { + ofconn_send_error(req->ofconn, req->request, error); } } - return error; } static uint64_t @@ -6386,14 +7457,13 @@ static void oftable_init(struct oftable *table) { memset(table, 0, sizeof *table); - classifier_init(&table->cls, flow_segment_u32s); + classifier_init(&table->cls, flow_segment_u64s); table->max_flows = UINT_MAX; - atomic_init(&table->config, (unsigned int)OFPROTO_TABLE_MISS_DEFAULT); + table->n_flows = 0; + atomic_init(&table->miss_config, OFPUTIL_TABLE_MISS_DEFAULT); - fat_rwlock_wrlock(&table->cls.rwlock); classifier_set_prefix_fields(&table->cls, default_prefix_fields, ARRAY_SIZE(default_prefix_fields)); - fat_rwlock_unlock(&table->cls.rwlock); atomic_init(&table->n_matched, 0); atomic_init(&table->n_missed, 0); @@ -6405,9 +7475,7 @@ oftable_init(struct oftable *table) static void oftable_destroy(struct oftable *table) { - fat_rwlock_rdlock(&table->cls.rwlock); ovs_assert(classifier_is_empty(&table->cls)); - fat_rwlock_unlock(&table->cls.rwlock); oftable_disable_eviction(table); classifier_destroy(&table->cls); free(table->name); @@ -6468,7 +7536,6 @@ oftable_enable_eviction(struct oftable *table, const struct mf_subfield *fields, size_t n_fields) OVS_REQUIRES(ofproto_mutex) { - struct cls_cursor cursor; struct rule *rule; if (table->eviction_fields @@ -6489,24 +7556,39 @@ oftable_enable_eviction(struct oftable *table, hmap_init(&table->eviction_groups_by_id); heap_init(&table->eviction_groups_by_size); - fat_rwlock_rdlock(&table->cls.rwlock); - cls_cursor_init(&cursor, &table->cls, NULL); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH (rule, cr, &table->cls) { eviction_group_add_rule(rule); } - fat_rwlock_unlock(&table->cls.rwlock); } -/* Removes 'rule' from the oftable that contains it. */ +/* Inserts 'rule' from the ofproto data structures BEFORE caller has inserted + * it to the classifier. */ static void -oftable_remove_rule__(struct ofproto *ofproto, struct rule *rule) +ofproto_rule_insert__(struct ofproto *ofproto, struct rule *rule) OVS_REQUIRES(ofproto_mutex) { - struct classifier *cls = &ofproto->tables[rule->table_id].cls; + const struct rule_actions *actions = rule_get_actions(rule); + + ovs_assert(rule->removed); - fat_rwlock_wrlock(&cls->rwlock); - classifier_remove(cls, CONST_CAST(struct cls_rule *, &rule->cr)); - fat_rwlock_unlock(&cls->rwlock); + if (rule->hard_timeout || rule->idle_timeout) { + list_insert(&ofproto->expirable, &rule->expirable); + } + cookies_insert(ofproto, rule); + eviction_group_add_rule(rule); + if (actions->has_meter) { + meter_insert_rule(rule); + } + rule->removed = false; +} + +/* Removes 'rule' from the ofproto data structures. Caller may have deferred + * the removal from the classifier. */ +static void +ofproto_rule_remove__(struct ofproto *ofproto, struct rule *rule) + OVS_REQUIRES(ofproto_mutex) +{ + ovs_assert(!rule->removed); cookies_remove(ofproto, rule); @@ -6518,13 +7600,8 @@ oftable_remove_rule__(struct ofproto *ofproto, struct rule *rule) list_remove(&rule->meter_list_node); list_init(&rule->meter_list_node); } -} -static void -oftable_remove_rule(struct rule *rule) - OVS_REQUIRES(ofproto_mutex) -{ - oftable_remove_rule__(rule->ofproto, rule); + rule->removed = true; } /* unixctl commands. */ @@ -6589,19 +7666,16 @@ ofproto_get_vlan_usage(struct ofproto *ofproto, unsigned long int *vlan_bitmap) match_init_catchall(&match); match_set_vlan_vid_masked(&match, htons(VLAN_CFI), htons(VLAN_CFI)); - cls_rule_init(&target, &match, 0); + cls_rule_init(&target, &match, 0, CLS_MAX_VERSION); free(ofproto->vlan_bitmap); ofproto->vlan_bitmap = bitmap_allocate(4096); ofproto->vlans_changed = false; OFPROTO_FOR_EACH_TABLE (oftable, ofproto) { - struct cls_cursor cursor; struct rule *rule; - fat_rwlock_rdlock(&oftable->cls.rwlock); - cls_cursor_init(&cursor, &oftable->cls, &target); - CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { + CLS_FOR_EACH_TARGET (rule, cr, &oftable->cls, &target) { if (minimask_get_vid_mask(&rule->cr.match.mask) == VLAN_VID_MASK) { uint16_t vid = miniflow_get_vid(&rule->cr.match.flow); @@ -6609,7 +7683,6 @@ ofproto_get_vlan_usage(struct ofproto *ofproto, unsigned long int *vlan_bitmap) bitmap_set1(ofproto->vlan_bitmap, vid); } } - fat_rwlock_unlock(&oftable->cls.rwlock); } cls_rule_destroy(&target);