const enum mf_field_id default_prefix_fields[2] =
{ MFF_IPV4_DST, MFF_IPV4_SRC };
-enum ofproto_state {
- S_OPENFLOW, /* Processing OpenFlow commands. */
- S_EVICT, /* Evicting flows from over-limit tables. */
- S_FLUSH, /* Deleting all flow table rules. */
-};
-
-enum ofoperation_type {
- OFOPERATION_ADD,
- OFOPERATION_DELETE,
- OFOPERATION_MODIFY,
- OFOPERATION_REPLACE
-};
-
-/* A single OpenFlow request can execute any number of operations. The
- * ofopgroup maintain OpenFlow state common to all of the operations, e.g. the
- * ofconn to which an error reply should be sent if necessary.
- *
- * ofproto initiates some operations internally. These operations are still
- * assigned to groups but will not have an associated ofconn. */
-struct ofopgroup {
- struct ofproto *ofproto; /* Owning ofproto. */
- struct list ofproto_node; /* In ofproto's "pending" list. */
- struct list ops; /* List of "struct ofoperation"s. */
- int n_running; /* Number of ops still pending. */
-
- /* Data needed to send OpenFlow reply on failure or to send a buffered
- * packet on success.
- *
- * If list_is_empty(ofconn_node) then this ofopgroup never had an
- * associated ofconn or its ofconn's connection dropped after it initiated
- * the operation. In the latter case 'ofconn' is a wild pointer that
- * refers to freed memory, so the 'ofconn' member must be used only if
- * !list_is_empty(ofconn_node).
- */
- struct list ofconn_node; /* In ofconn's list of pending opgroups. */
- struct ofconn *ofconn; /* ofconn for reply (but see note above). */
- struct ofp_header *request; /* Original request (truncated at 64 bytes). */
- uint32_t buffer_id; /* Buffer id from original request. */
-};
-
-static struct ofopgroup *ofopgroup_create_unattached(struct ofproto *);
-static struct ofopgroup *ofopgroup_create(struct ofproto *, struct ofconn *,
- const struct ofp_header *,
- uint32_t buffer_id);
-static void ofopgroup_submit(struct ofopgroup *);
-static void ofopgroup_complete(struct ofopgroup *);
-
-/* A single flow table operation. */
-struct ofoperation {
- struct ofopgroup *group; /* Owning group. */
- struct list group_node; /* In ofopgroup's "ops" list. */
- struct hmap_node hmap_node; /* In ofproto's "deletions" hmap. */
- struct rule *rule; /* Rule being operated upon. */
- enum ofoperation_type type; /* Type of operation. */
-
- /* OFOPERATION_MODIFY, OFOPERATION_REPLACE: The old actions, if the actions
- * are changing. */
- const struct rule_actions *actions;
-
- /* OFOPERATION_DELETE. */
- enum ofp_flow_removed_reason reason; /* Reason flow was removed. */
-
- ovs_be64 flow_cookie; /* Rule's old flow cookie. */
- uint16_t idle_timeout; /* Rule's old idle timeout. */
- uint16_t hard_timeout; /* Rule's old hard timeout. */
- enum ofputil_flow_mod_flags flags; /* Rule's old flags. */
- enum ofperr error; /* 0 if no error. */
-};
-
-static struct ofoperation *ofoperation_create(struct ofopgroup *,
- struct rule *,
- enum ofoperation_type,
- enum ofp_flow_removed_reason);
-static void ofoperation_destroy(struct ofoperation *);
-
/* oftable. */
static void oftable_init(struct oftable *);
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)
+ OVS_REQUIRES(ofproto_mutex);
static void oftable_disable_eviction(struct oftable *);
static void oftable_enable_eviction(struct oftable *,
const struct mf_subfield *fields,
static bool choose_rule_to_evict(struct oftable *table, struct rule **rulep)
OVS_REQUIRES(ofproto_mutex);
-static void ofproto_evict(struct ofproto *)
- OVS_EXCLUDED(ofproto_mutex);
static uint32_t rule_eviction_priority(struct ofproto *ofproto, struct rule *)
OVS_REQUIRES(ofproto_mutex);;
static void eviction_group_add_rule(struct rule *)
bool can_write_readonly);
static void rule_criteria_destroy(struct rule_criteria *);
+static enum ofperr collect_rules_loose(struct ofproto *,
+ const struct rule_criteria *,
+ struct rule_collection *);
+
/* A packet that needs to be passed to rule_execute().
*
* (We can't do this immediately from ofopgroup_complete() because that holds
static void run_rule_executes(struct ofproto *) OVS_EXCLUDED(ofproto_mutex);
static void destroy_rule_executes(struct ofproto *);
+struct learned_cookie {
+ union {
+ /* In struct ofproto's 'learned_cookies' hmap. */
+ struct hmap_node hmap_node OVS_GUARDED_BY(ofproto_mutex);
+
+ /* In 'dead_cookies' list when removed from hmap. */
+ struct list list_node;
+ } u;
+
+ /* Key. */
+ ovs_be64 cookie OVS_GUARDED_BY(ofproto_mutex);
+ uint8_t table_id OVS_GUARDED_BY(ofproto_mutex);
+
+ /* Number of references from "learn" actions.
+ *
+ * When this drops to 0, all of the flows in 'table_id' with the specified
+ * 'cookie' are deleted. */
+ int n OVS_GUARDED_BY(ofproto_mutex);
+};
+
+static const struct ofpact_learn *next_learn_with_delete(
+ const struct rule_actions *, const struct ofpact_learn *start);
+
+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)
+ OVS_REQUIRES(ofproto_mutex);
+static void learned_cookies_flush(struct ofproto *, struct list *dead_cookies)
+ OVS_REQUIRES(ofproto_mutex);
+
/* ofport. */
static void ofport_destroy__(struct ofport *) OVS_EXCLUDED(ofproto_mutex);
static void ofport_destroy(struct ofport *);
/* rule. */
static void ofproto_rule_send_removed(struct rule *, uint8_t reason);
-static bool rule_is_modifiable(const struct rule *rule,
- enum ofputil_flow_mod_flags flag);
+static bool rule_is_readonly(const struct rule *);
+
+/* The source of a flow_mod request, in the code that processes flow_mods.
+ *
+ * A flow table modification request can be generated externally, via OpenFlow,
+ * or internally through a function call. This structure indicates the source
+ * of an OpenFlow-generated flow_mod. For an internal flow_mod, it isn't
+ * 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. */
+};
/* OpenFlow. */
-static enum ofperr add_flow(struct ofproto *, struct ofconn *,
- struct ofputil_flow_mod *,
- const struct ofp_header *);
-static enum ofperr modify_flows__(struct ofproto *, struct ofconn *,
- struct ofputil_flow_mod *,
- const struct ofp_header *,
- const struct rule_collection *);
-static void delete_flow__(struct rule *rule, struct ofopgroup *,
- enum ofp_flow_removed_reason)
+static enum ofperr add_flow(struct ofproto *, struct ofputil_flow_mod *,
+ const struct flow_mod_requester *);
+
+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 *,
+ 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 *)
+ OVS_REQUIRES(ofproto_mutex);
+
static bool ofproto_group_exists__(const struct ofproto *ofproto,
uint32_t group_id)
OVS_REQ_RDLOCK(ofproto->groups_rwlock);
uint32_t group_id)
OVS_EXCLUDED(ofproto->groups_rwlock);
static enum ofperr add_group(struct ofproto *, struct ofputil_group_mod *);
-static bool handle_openflow(struct ofconn *, const struct ofpbuf *);
-static enum ofperr handle_flow_mod__(struct ofproto *, struct ofconn *,
+static void handle_openflow(struct ofconn *, const struct ofpbuf *);
+static enum ofperr handle_flow_mod__(struct ofproto *,
struct ofputil_flow_mod *,
- const struct ofp_header *)
+ const struct flow_mod_requester *)
OVS_EXCLUDED(ofproto_mutex);
static void calc_duration(long long int start, long long int now,
uint32_t *sec, uint32_t *nsec);
ofproto->tables = NULL;
ofproto->n_tables = 0;
hindex_init(&ofproto->cookies);
+ hmap_init(&ofproto->learned_cookies);
list_init(&ofproto->expirable);
ofproto->connmgr = connmgr_create(ofproto, datapath_name, datapath_name);
- ofproto->state = S_OPENFLOW;
- list_init(&ofproto->pending);
- ofproto->n_pending = 0;
- hmap_init(&ofproto->deletions);
guarded_list_init(&ofproto->rule_executes);
ofproto->vlan_bitmap = NULL;
ofproto->vlans_changed = false;
table->max_flows = s->max_flows;
fat_rwlock_wrlock(&table->cls.rwlock);
- if (classifier_count(&table->cls) > table->max_flows
- && table->eviction_fields) {
- /* 'table' contains more flows than allowed. We might not be able to
- * evict them right away because of the asynchronous nature of flow
- * table changes. Schedule eviction for later. */
- switch (ofproto->state) {
- case S_OPENFLOW:
- ofproto->state = S_EVICT;
- break;
- case S_EVICT:
- case S_FLUSH:
- /* We're already deleting flows, nothing more to do. */
- break;
- }
- }
-
classifier_set_prefix_fields(&table->cls,
s->prefix_fields, s->n_prefix_fields);
-
fat_rwlock_unlock(&table->cls.rwlock);
+
+ ovs_mutex_lock(&ofproto_mutex);
+ evict_rules_from_table(table, 0);
+ ovs_mutex_unlock(&ofproto_mutex);
}
\f
bool
}
static void
-ofproto_rule_delete__(struct ofproto *ofproto, struct rule *rule,
- uint8_t reason)
+ofproto_rule_delete__(struct rule *rule, uint8_t reason)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofopgroup *group;
-
- ovs_assert(!rule->pending);
+ struct rule_collection rules;
- group = ofopgroup_create_unattached(ofproto);
- delete_flow__(rule, group, reason);
- ofopgroup_submit(group);
+ rules.rules = rules.stub;
+ rules.n = 1;
+ rules.stub[0] = rule;
+ delete_flows__(&rules, reason, NULL);
}
/* Deletes 'rule' from 'ofproto'.
ofproto_rule_delete(struct ofproto *ofproto, struct rule *rule)
OVS_EXCLUDED(ofproto_mutex)
{
- struct ofopgroup *group;
-
+ /* This skips the ofmonitor and flow-removed notifications because the
+ * switch is being deleted and any OpenFlow channels have been or soon will
+ * be killed. */
ovs_mutex_lock(&ofproto_mutex);
- ovs_assert(!rule->pending);
-
- group = ofopgroup_create_unattached(ofproto);
- ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE);
oftable_remove_rule__(ofproto, rule);
ofproto->ofproto_class->rule_delete(rule);
- ofopgroup_submit(group);
-
ovs_mutex_unlock(&ofproto_mutex);
}
cls_cursor_init(&cursor, &table->cls, NULL);
fat_rwlock_unlock(&table->cls.rwlock);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) {
- if (!rule->pending) {
- ofproto_rule_delete__(ofproto, rule, OFPRR_DELETE);
- }
+ ofproto_rule_delete__(rule, OFPRR_DELETE);
}
}
ovs_mutex_unlock(&ofproto_mutex);
{
struct oftable *table;
- ovs_assert(list_is_empty(&ofproto->pending));
-
destroy_rule_executes(ofproto);
delete_group(ofproto, OFPG_ALL);
}
free(ofproto->tables);
- hmap_destroy(&ofproto->deletions);
-
ovs_assert(hindex_is_empty(&ofproto->cookies));
hindex_destroy(&ofproto->cookies);
+ ovs_assert(hmap_is_empty(&ofproto->learned_cookies));
+ hmap_destroy(&ofproto->learned_cookies);
+
free(ofproto->vlan_bitmap);
ofproto->ofproto_class->dealloc(ofproto);
}
}
-static bool
-any_pending_ops(const struct ofproto *p)
- OVS_EXCLUDED(ofproto_mutex)
-{
- bool b;
-
- ovs_mutex_lock(&ofproto_mutex);
- b = !list_is_empty(&p->pending);
- ovs_mutex_unlock(&ofproto_mutex);
-
- return b;
-}
-
int
ofproto_run(struct ofproto *p)
{
p->change_seq = new_seq;
}
- switch (p->state) {
- case S_OPENFLOW:
- connmgr_run(p->connmgr, handle_openflow);
- break;
-
- case S_EVICT:
- connmgr_run(p->connmgr, NULL);
- ofproto_evict(p);
- if (!any_pending_ops(p)) {
- p->state = S_OPENFLOW;
- }
- break;
-
- case S_FLUSH:
- connmgr_run(p->connmgr, NULL);
- ofproto_flush__(p);
- if (!any_pending_ops(p)) {
- connmgr_flushed(p->connmgr);
- p->state = S_OPENFLOW;
- }
- break;
-
- default:
- OVS_NOT_REACHED();
- }
+ connmgr_run(p->connmgr, handle_openflow);
return error;
}
p->ofproto_class->port_poll_wait(p);
}
seq_wait(connectivity_seq_get(), p->change_seq);
-
- switch (p->state) {
- case S_OPENFLOW:
- connmgr_wait(p->connmgr, true);
- break;
-
- case S_EVICT:
- case S_FLUSH:
- connmgr_wait(p->connmgr, false);
- if (!any_pending_ops(p)) {
- poll_immediate_wake();
- }
- break;
- }
+ connmgr_wait(p->connmgr);
}
bool
simap_increase(usage, "ports", hmap_count(&ofproto->ports));
- ovs_mutex_lock(&ofproto_mutex);
- simap_increase(usage, "ops",
- ofproto->n_pending + hmap_count(&ofproto->deletions));
- ovs_mutex_unlock(&ofproto_mutex);
-
n_rules = 0;
OFPROTO_FOR_EACH_TABLE (table, ofproto) {
fat_rwlock_rdlock(&table->cls.rwlock);
flow_mod_init(&fm, match, priority, ofpacts, ofpacts_len, command);
- return handle_flow_mod__(ofproto, NULL, &fm, NULL);
+ return handle_flow_mod__(ofproto, &fm, NULL);
}
/* Adds a flow to OpenFlow flow table 0 in 'p' that matches 'cls_rule' and
}
}
- return handle_flow_mod__(ofproto, NULL, fm, NULL);
+ return handle_flow_mod__(ofproto, fm, NULL);
}
/* Searches for a rule with matching criteria exactly equal to 'target' in
* ofproto's table 0 and, if it finds one, deletes it.
*
* This is a helper function for in-band control and fail-open. */
-bool
+void
ofproto_delete_flow(struct ofproto *ofproto,
const struct match *target, unsigned int priority)
OVS_EXCLUDED(ofproto_mutex)
priority));
fat_rwlock_unlock(&cls->rwlock);
if (!rule) {
- return true;
+ return;
}
- /* Fall back to a executing a full flow mod. We can't optimize this at all
- * because we didn't take enough locks above to ensure that the flow table
- * didn't already change beneath us. */
- return simple_flow_mod(ofproto, target, priority, NULL, 0,
- OFPFC_DELETE_STRICT) != OFPROTO_POSTPONE;
+ /* Execute a flow mod. We can't optimize this at all because we didn't
+ * take enough locks above to ensure that the flow table didn't already
+ * change beneath us. */
+ simple_flow_mod(ofproto, target, priority, NULL, 0, OFPFC_DELETE_STRICT);
}
-/* Starts the process of deleting all of the flows from all of ofproto's flow
- * tables and then reintroducing the flows required by in-band control and
- * fail-open. The process will complete in a later call to ofproto_run(). */
+/* Delete all of the flows from all of ofproto's flow tables, then reintroduce
+ * the flows required by in-band control and fail-open. */
void
ofproto_flush_flows(struct ofproto *ofproto)
{
COVERAGE_INC(ofproto_flush);
- ofproto->state = S_FLUSH;
+ ofproto_flush__(ofproto);
+ connmgr_flushed(ofproto->connmgr);
}
\f
static void
/* Creates and returns a new 'struct rule_actions', whose actions are a copy
* of from the 'ofpacts_len' bytes of 'ofpacts'. */
const struct rule_actions *
-rule_actions_create(const struct ofproto *ofproto,
- const struct ofpact *ofpacts, size_t ofpacts_len)
+rule_actions_create(const struct ofpact *ofpacts, size_t ofpacts_len)
{
struct rule_actions *actions;
actions = xmalloc(sizeof *actions + ofpacts_len);
actions->ofpacts_len = ofpacts_len;
- actions->provider_meter_id
- = get_provider_meter_id(ofproto,
- ofpacts_get_meter(ofpacts, ofpacts_len));
+ actions->has_meter = ofpacts_get_meter(ofpacts, ofpacts_len) != 0;
memcpy(actions->ofpacts, ofpacts, ofpacts_len);
+ actions->has_learn_with_delete = (next_learn_with_delete(actions, NULL)
+ != NULL);
+
return actions;
}
}
}
-/* Returns true if a rule related to 'op' has an OpenFlow OFPAT_OUTPUT or
- * OFPAT_ENQUEUE action that outputs to 'out_port'. */
-bool
-ofoperation_has_out_port(const struct ofoperation *op, ofp_port_t out_port)
- OVS_REQUIRES(ofproto_mutex)
-{
- if (ofproto_rule_has_out_port(op->rule, out_port)) {
- return true;
- }
-
- switch (op->type) {
- case OFOPERATION_ADD:
- case OFOPERATION_DELETE:
- return false;
-
- case OFOPERATION_MODIFY:
- case OFOPERATION_REPLACE:
- return ofpacts_output_to_port(op->actions->ofpacts,
- op->actions->ofpacts_len, out_port);
- }
-
- OVS_NOT_REACHED();
-}
-
static void
rule_execute_destroy(struct rule_execute *e)
{
}
static bool
-oftable_is_modifiable(const struct oftable *table,
- enum ofputil_flow_mod_flags flags)
+rule_is_readonly(const struct rule *rule)
{
- if (flags & OFPUTIL_FF_NO_READONLY) {
- return true;
+ const struct oftable *table = &rule->ofproto->tables[rule->table_id];
+ return (table->flags & OFTABLE_READONLY) != 0;
+}
+\f
+static uint32_t
+hash_learned_cookie(ovs_be64 cookie_, uint8_t table_id)
+{
+ uint64_t cookie = (OVS_FORCE uint64_t) cookie_;
+ return hash_3words(cookie, cookie >> 32, table_id);
+}
+
+static void
+learned_cookies_update_one__(struct ofproto *ofproto,
+ const struct ofpact_learn *learn,
+ int delta, struct list *dead_cookies)
+ OVS_REQUIRES(ofproto_mutex)
+{
+ uint32_t hash = hash_learned_cookie(learn->cookie, learn->table_id);
+ struct learned_cookie *c;
+
+ HMAP_FOR_EACH_WITH_HASH (c, u.hmap_node, hash, &ofproto->learned_cookies) {
+ if (c->cookie == learn->cookie && c->table_id == learn->table_id) {
+ c->n += delta;
+ ovs_assert(c->n >= 0);
+
+ if (!c->n) {
+ hmap_remove(&ofproto->learned_cookies, &c->u.hmap_node);
+ list_push_back(dead_cookies, &c->u.list_node);
+ }
+
+ return;
+ }
}
- return !(table->flags & OFTABLE_READONLY);
+ ovs_assert(delta > 0);
+ c = xmalloc(sizeof *c);
+ hmap_insert(&ofproto->learned_cookies, &c->u.hmap_node, hash);
+ c->cookie = learn->cookie;
+ c->table_id = learn->table_id;
+ c->n = delta;
}
-static bool
-rule_is_modifiable(const struct rule *rule, enum ofputil_flow_mod_flags flags)
+static const struct ofpact_learn *
+next_learn_with_delete(const struct rule_actions *actions,
+ const struct ofpact_learn *start)
+{
+ const struct ofpact *pos;
+
+ for (pos = start ? ofpact_next(&start->ofpact) : actions->ofpacts;
+ pos < ofpact_end(actions->ofpacts, actions->ofpacts_len);
+ pos = ofpact_next(pos)) {
+ if (pos->type == OFPACT_LEARN) {
+ const struct ofpact_learn *learn = ofpact_get_LEARN(pos);
+ if (learn->flags & NX_LEARN_F_DELETE_LEARNED) {
+ return learn;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static void
+learned_cookies_update__(struct ofproto *ofproto,
+ const struct rule_actions *actions,
+ int delta, struct list *dead_cookies)
+ OVS_REQUIRES(ofproto_mutex)
+{
+ if (actions->has_learn_with_delete) {
+ const struct ofpact_learn *learn;
+
+ for (learn = next_learn_with_delete(actions, NULL); learn;
+ learn = next_learn_with_delete(actions, learn)) {
+ learned_cookies_update_one__(ofproto, learn, delta, dead_cookies);
+ }
+ }
+}
+
+static void
+learned_cookies_inc(struct ofproto *ofproto,
+ const struct rule_actions *actions)
+ OVS_REQUIRES(ofproto_mutex)
{
- const struct oftable *rule_table;
+ learned_cookies_update__(ofproto, actions, +1, NULL);
+}
- rule_table = &rule->ofproto->tables[rule->table_id];
- return oftable_is_modifiable(rule_table, flags);
+static void
+learned_cookies_dec(struct ofproto *ofproto,
+ const struct rule_actions *actions,
+ struct 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)
+ OVS_REQUIRES(ofproto_mutex)
+{
+ struct learned_cookie *c, *next;
+
+ LIST_FOR_EACH_SAFE (c, next, 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,
+ 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);
+
+ list_remove(&c->u.list_node);
+ free(c);
+ }
}
\f
static enum ofperr
hindex_remove(&ofproto->cookies, &rule->cookie_node);
}
-static void
-ofproto_rule_change_cookie(struct ofproto *ofproto, struct rule *rule,
- ovs_be64 new_cookie)
- OVS_REQUIRES(ofproto_mutex)
-{
- if (new_cookie != rule->flow_cookie) {
- cookies_remove(ofproto, rule);
-
- ovs_mutex_lock(&rule->mutex);
- rule->flow_cookie = new_cookie;
- ovs_mutex_unlock(&rule->mutex);
-
- cookies_insert(ofproto, rule);
- }
-}
-
static void
calc_duration(long long int start, long long int now,
uint32_t *sec, uint32_t *nsec)
* check 'c->cr' itself.
*
* Increments '*n_readonly' if 'rule' wasn't added because it's read-only (and
- * 'c' only includes modifiable rules).
- *
- * Returns 0 ordinarily, but OFPROTO_POSTPONE if we would otherwise collect a
- * rule that has a pending operation. */
-static enum ofperr
+ * 'c' only includes modifiable rules). */
+static void
collect_rule(struct rule *rule, const struct rule_criteria *c,
struct rule_collection *rules, size_t *n_readonly)
OVS_REQUIRES(ofproto_mutex)
&& ofproto_rule_has_out_group(rule, c->out_group)
&& !((rule->flow_cookie ^ c->cookie) & c->cookie_mask)
&& (!rule_is_hidden(rule) || c->include_hidden)) {
- if (rule->pending) {
- return OFPROTO_POSTPONE;
- }
-
/* Rule matches all the criteria... */
- if (rule_is_modifiable(rule, 0) || c->include_readonly) {
+ if (!rule_is_readonly(rule) || c->include_readonly) {
/* ...add it. */
rule_collection_add(rules, rule);
} else {
++*n_readonly;
}
}
- return 0;
}
/* Searches 'ofproto' for rules that match the criteria in 'criteria'. Matches
hash_cookie(criteria->cookie),
&ofproto->cookies) {
if (cls_rule_is_loose_match(&rule->cr, &criteria->cr.match)) {
- error = collect_rule(rule, criteria, rules, &n_readonly);
- if (error) {
- break;
- }
+ collect_rule(rule, criteria, rules, &n_readonly);
}
}
} else {
fat_rwlock_rdlock(&table->cls.rwlock);
cls_cursor_init(&cursor, &table->cls, &criteria->cr);
CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
- error = collect_rule(rule, criteria, rules, &n_readonly);
- if (error) {
- break;
- }
+ collect_rule(rule, criteria, rules, &n_readonly);
}
fat_rwlock_unlock(&table->cls.rwlock);
}
hash_cookie(criteria->cookie),
&ofproto->cookies) {
if (cls_rule_equal(&rule->cr, &criteria->cr)) {
- error = collect_rule(rule, criteria, rules, &n_readonly);
- if (error) {
- break;
- }
+ collect_rule(rule, criteria, rules, &n_readonly);
}
}
} else {
&table->cls, &criteria->cr));
fat_rwlock_unlock(&table->cls.rwlock);
if (rule) {
- error = collect_rule(rule, criteria, rules, &n_readonly);
- if (error) {
- break;
- }
+ collect_rule(rule, criteria, rules, &n_readonly);
}
}
}
exit:
+ if (!error && !rules->n && n_readonly) {
+ /* We didn't find any rules to modify. We did find some read-only
+ * rules that we're not allowed to modify, so report that. */
+ error = OFPERR_OFPBRC_EPERM;
+ }
if (error) {
rule_collection_destroy(rules);
}
return error;
}
-static bool
-is_flow_deletion_pending(const struct ofproto *ofproto,
- const struct cls_rule *cls_rule,
- uint8_t table_id)
- OVS_REQUIRES(ofproto_mutex)
-{
- if (!hmap_is_empty(&ofproto->deletions)) {
- struct ofoperation *op;
-
- HMAP_FOR_EACH_WITH_HASH (op, hmap_node,
- cls_rule_hash(cls_rule, table_id),
- &ofproto->deletions) {
- if (op->rule->table_id == table_id
- && cls_rule_equal(cls_rule, &op->rule->cr)) {
- return true;
- }
- }
- }
-
- return false;
-}
-
static bool
should_evict_a_rule(struct oftable *table, unsigned int extra_space)
OVS_REQUIRES(ofproto_mutex)
}
static enum ofperr
-evict_rules_from_table(struct ofproto *ofproto, struct oftable *table,
- unsigned int extra_space)
+evict_rules_from_table(struct oftable *table, unsigned int extra_space)
OVS_REQUIRES(ofproto_mutex)
{
while (should_evict_a_rule(table, extra_space)) {
if (!choose_rule_to_evict(table, &rule)) {
return OFPERR_OFPFMFC_TABLE_FULL;
- } else if (rule->pending) {
- return OFPROTO_POSTPONE;
} else {
- struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
- delete_flow__(rule, group, OFPRR_EVICTION);
- ofopgroup_submit(group);
+ ofproto_rule_delete__(rule, OFPRR_EVICTION);
}
}
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static enum ofperr
-add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
- struct ofputil_flow_mod *fm, const struct ofp_header *request)
+add_flow(struct ofproto *ofproto, struct ofputil_flow_mod *fm,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
const struct rule_actions *actions;
- struct ofopgroup *group;
struct oftable *table;
struct cls_rule cr;
struct rule *rule;
}
table = &ofproto->tables[table_id];
-
- if (!oftable_is_modifiable(table, fm->flags)) {
+ if (table->flags & OFTABLE_READONLY
+ && !(fm->flags & OFPUTIL_FF_NO_READONLY)) {
return OFPERR_OFPBRC_EPERM;
}
rule = rule_from_cls_rule(classifier_find_rule_exactly(&table->cls, &cr));
fat_rwlock_unlock(&table->cls.rwlock);
if (rule) {
- cls_rule_destroy(&cr);
- if (!rule_is_modifiable(rule, fm->flags)) {
- return OFPERR_OFPBRC_EPERM;
- } else if (rule->pending) {
- return OFPROTO_POSTPONE;
- } else {
- struct rule_collection rules;
+ struct rule_collection rules;
- rule_collection_init(&rules);
- rule_collection_add(&rules, rule);
- fm->modify_cookie = true;
- error = modify_flows__(ofproto, ofconn, fm, request, &rules);
- rule_collection_destroy(&rules);
+ cls_rule_destroy(&cr);
- return error;
- }
- }
+ rule_collection_init(&rules);
+ rule_collection_add(&rules, rule);
+ fm->modify_cookie = true;
+ error = modify_flows__(ofproto, fm, &rules, req);
+ rule_collection_destroy(&rules);
- /* Serialize against pending deletion. */
- if (is_flow_deletion_pending(ofproto, &cr, table_id)) {
- cls_rule_destroy(&cr);
- return OFPROTO_POSTPONE;
+ return error;
}
/* Check for overlap, if requested. */
}
/* If necessary, evict an existing rule to clear out space. */
- error = evict_rules_from_table(ofproto, table, 1);
+ error = evict_rules_from_table(table, 1);
if (error) {
cls_rule_destroy(&cr);
return error;
*CONST_CAST(struct ofproto **, &rule->ofproto) = ofproto;
cls_rule_move(CONST_CAST(struct cls_rule *, &rule->cr), &cr);
ovs_refcount_init(&rule->ref_count);
- rule->pending = NULL;
rule->flow_cookie = fm->new_cookie;
rule->created = rule->modified = time_msec();
*CONST_CAST(uint8_t *, &rule->table_id) = table - ofproto->tables;
rule->flags = fm->flags & OFPUTIL_FF_STATE;
- actions = rule_actions_create(ofproto, fm->ofpacts, fm->ofpacts_len);
+ actions = rule_actions_create(fm->ofpacts, fm->ofpacts_len);
ovsrcu_set(&rule->actions, actions);
list_init(&rule->meter_list_node);
rule->eviction_group = NULL;
}
cookies_insert(ofproto, rule);
eviction_group_add_rule(rule);
- if (actions->provider_meter_id != UINT32_MAX) {
+ if (actions->has_meter) {
meter_insert_rule(rule);
}
classifier_insert(&table->cls, CONST_CAST(struct cls_rule *, &rule->cr));
fat_rwlock_unlock(&table->cls.rwlock);
- group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
- ofoperation_create(group, rule, OFOPERATION_ADD, 0);
- ofproto->ofproto_class->rule_insert(rule);
- ofopgroup_submit(group);
+ error = ofproto->ofproto_class->rule_insert(rule);
+ if (error) {
+ oftable_remove_rule(rule);
+ ofproto_rule_unref(rule);
+ return error;
+ }
+ learned_cookies_inc(ofproto, actions);
+
+ 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;
+ }
+ }
- return error;
+ ofmonitor_report(ofproto->connmgr, rule, NXFME_ADDED, 0,
+ req ? req->ofconn : NULL, req ? req->xid : 0);
+
+ return req ? send_buffered_packet(req->ofconn, fm->buffer_id, rule) : 0;
}
\f
/* OFPFC_MODIFY and OFPFC_MODIFY_STRICT. */
*
* Returns 0 on success, otherwise an OpenFlow error code. */
static enum ofperr
-modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
- struct ofputil_flow_mod *fm, const struct ofp_header *request,
- const struct rule_collection *rules)
+modify_flows__(struct ofproto *ofproto, struct ofputil_flow_mod *fm,
+ const struct rule_collection *rules,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
- enum ofoperation_type type;
- struct ofopgroup *group;
- enum ofperr error;
+ struct list dead_cookies = LIST_INITIALIZER(&dead_cookies);
+ enum nx_flow_update_event event;
size_t i;
if (ofproto->ofproto_class->rule_premodify_actions) {
for (i = 0; i < rules->n; i++) {
struct rule *rule = rules->rules[i];
+ enum ofperr error;
error = ofproto->ofproto_class->rule_premodify_actions(
rule, fm->ofpacts, fm->ofpacts_len);
}
}
- type = fm->command == OFPFC_ADD ? OFOPERATION_REPLACE : OFOPERATION_MODIFY;
- group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
+ event = fm->command == OFPFC_ADD ? NXFME_ADDED : NXFME_MODIFIED;
for (i = 0; i < rules->n; i++) {
struct rule *rule = rules->rules[i];
- const struct rule_actions *actions;
- struct ofoperation *op;
- bool actions_changed;
- bool reset_counters;
- /* FIXME: Implement OFPFUTIL_FF_RESET_COUNTS */
+ /* '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);
- actions = rule_get_actions(rule);
- actions_changed = !ofpacts_equal(fm->ofpacts, fm->ofpacts_len,
- actions->ofpacts,
- actions->ofpacts_len);
+ bool reset_counters = (fm->flags & OFPUTIL_FF_RESET_COUNTS) != 0;
- op = ofoperation_create(group, rule, type, 0);
+ long long int now = time_msec();
+
+ /* FIXME: Implement OFPFUTIL_FF_RESET_COUNTS */
- if (fm->modify_cookie && fm->new_cookie != OVS_BE64_MAX) {
- ofproto_rule_change_cookie(ofproto, rule, fm->new_cookie);
+ if (change_cookie) {
+ cookies_remove(ofproto, rule);
}
- if (type == OFOPERATION_REPLACE) {
- ovs_mutex_lock(&rule->mutex);
+
+ ovs_mutex_lock(&rule->mutex);
+ if (fm->command == OFPFC_ADD) {
rule->idle_timeout = fm->idle_timeout;
rule->hard_timeout = fm->hard_timeout;
- ovs_mutex_unlock(&rule->mutex);
-
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);
+
+ 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);
}
}
- reset_counters = (fm->flags & OFPUTIL_FF_RESET_COUNTS) != 0;
- if (actions_changed || reset_counters) {
- const struct rule_actions *new_actions;
+ if (change_actions) {
+ ovsrcu_set(&rule->actions, rule_actions_create(fm->ofpacts,
+ fm->ofpacts_len));
+ rule_actions_destroy(actions);
+ }
- op->actions = rule_get_actions(rule);
- new_actions = rule_actions_create(ofproto,
- fm->ofpacts, fm->ofpacts_len);
+ if (change_actions || reset_counters) {
+ ofproto->ofproto_class->rule_modify_actions(rule, reset_counters);
+ }
- ovsrcu_set(&rule->actions, new_actions);
+ if (event != NXFME_MODIFIED || change_actions || change_cookie) {
+ ofmonitor_report(ofproto->connmgr, rule, event, 0,
+ req ? req->ofconn : NULL, req ? req->xid : 0);
+ }
- ofproto->ofproto_class->rule_modify_actions(rule, reset_counters);
- } else {
- ofoperation_complete(op, 0);
+ if (change_actions) {
+ learned_cookies_inc(ofproto, rule_get_actions(rule));
+ learned_cookies_dec(ofproto, actions, &dead_cookies);
}
}
- ofopgroup_submit(group);
+ learned_cookies_flush(ofproto, &dead_cookies);
- return error;
+ 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 ofconn *ofconn,
- struct ofputil_flow_mod *fm, const struct ofp_header *request)
+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, ofconn, fm, request);
+ return add_flow(ofproto, fm, req);
}
/* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code on
* '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 ofconn *ofconn,
- struct ofputil_flow_mod *fm,
- const struct ofp_header *request)
+modify_flows_loose(struct ofproto *ofproto, struct ofputil_flow_mod *fm,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
struct rule_criteria criteria;
if (!error) {
error = (rules.n > 0
- ? modify_flows__(ofproto, ofconn, fm, request, &rules)
- : modify_flows_add(ofproto, ofconn, fm, request));
+ ? modify_flows__(ofproto, fm, &rules, req)
+ : modify_flows_add(ofproto, fm, req));
}
rule_collection_destroy(&rules);
}
/* Implements OFPFC_MODIFY_STRICT. Returns 0 on success or an OpenFlow error
- * code on failure.
- *
- * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
- * if any. */
+ * code on failure. */
static enum ofperr
-modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
- struct ofputil_flow_mod *fm,
- const struct ofp_header *request)
+modify_flow_strict(struct ofproto *ofproto, struct ofputil_flow_mod *fm,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
struct rule_criteria criteria;
if (!error) {
if (rules.n == 0) {
- error = modify_flows_add(ofproto, ofconn, fm, request);
+ error = modify_flows_add(ofproto, fm, req);
} else if (rules.n == 1) {
- error = modify_flows__(ofproto, ofconn, fm, request, &rules);
+ error = modify_flows__(ofproto, fm, &rules, req);
}
}
\f
/* OFPFC_DELETE implementation. */
+/* Deletes the rules listed in 'rules'. */
static void
-delete_flow__(struct rule *rule, struct ofopgroup *group,
- enum ofp_flow_removed_reason reason)
+delete_flows__(const struct rule_collection *rules,
+ enum ofp_flow_removed_reason reason,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofproto *ofproto = rule->ofproto;
+ if (rules->n) {
+ struct list dead_cookies = LIST_INITIALIZER(&dead_cookies);
+ struct ofproto *ofproto = rules->rules[0]->ofproto;
+ size_t i;
- ofproto_rule_send_removed(rule, reason);
+ for (i = 0; i < rules->n; i++) {
+ struct rule *rule = rules->rules[i];
+ const struct rule_actions *actions = rule_get_actions(rule);
- ofoperation_create(group, rule, OFOPERATION_DELETE, reason);
- oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_delete(rule);
-}
+ ofproto_rule_send_removed(rule, reason);
-/* Deletes the rules listed in 'rules'.
- *
- * Returns 0 on success, otherwise an OpenFlow error code. */
-static enum ofperr
-delete_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
- const struct ofp_header *request,
- const struct rule_collection *rules,
- enum ofp_flow_removed_reason reason)
- OVS_REQUIRES(ofproto_mutex)
-{
- struct ofopgroup *group;
- size_t i;
+ ofmonitor_report(ofproto->connmgr, rule, NXFME_DELETED, reason,
+ req ? req->ofconn : NULL, req ? req->xid : 0);
+ oftable_remove_rule(rule);
+ ofproto->ofproto_class->rule_delete(rule);
- group = ofopgroup_create(ofproto, ofconn, request, UINT32_MAX);
- for (i = 0; i < rules->n; i++) {
- delete_flow__(rules->rules[i], group, reason);
+ learned_cookies_dec(ofproto, actions, &dead_cookies);
+ }
+ learned_cookies_flush(ofproto, &dead_cookies);
+ ofmonitor_flush(ofproto->connmgr);
}
- ofopgroup_submit(group);
-
- return 0;
}
/* Implements OFPFC_DELETE. */
static enum ofperr
-delete_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
+delete_flows_loose(struct ofproto *ofproto,
const struct ofputil_flow_mod *fm,
- const struct ofp_header *request)
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
struct rule_criteria criteria;
rule_criteria_destroy(&criteria);
if (!error && rules.n > 0) {
- error = delete_flows__(ofproto, ofconn, request, &rules,
- fm->delete_reason);
+ delete_flows__(&rules, fm->delete_reason, req);
}
rule_collection_destroy(&rules);
/* Implements OFPFC_DELETE_STRICT. */
static enum ofperr
-delete_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
- const struct ofputil_flow_mod *fm,
- const struct ofp_header *request)
+delete_flow_strict(struct ofproto *ofproto, const struct ofputil_flow_mod *fm,
+ const struct flow_mod_requester *req)
OVS_REQUIRES(ofproto_mutex)
{
struct rule_criteria criteria;
rule_criteria_destroy(&criteria);
if (!error && rules.n > 0) {
- error = delete_flows__(ofproto, ofconn, request, &rules,
- fm->delete_reason);
+ delete_flows__(&rules, fm->delete_reason, req);
}
rule_collection_destroy(&rules);
struct ofputil_flow_removed fr;
long long int used;
- if (rule_is_hidden(rule) || !(rule->flags & OFPUTIL_FF_SEND_FLOW_REM)) {
+ if (rule_is_hidden(rule) ||
+ !(rule->flags & OFPUTIL_FF_SEND_FLOW_REM)) {
return;
}
* OFPRR_HARD_TIMEOUT or OFPRR_IDLE_TIMEOUT), and then removes 'rule' from its
* ofproto.
*
- * 'rule' must not have a pending operation (that is, 'rule->pending' must be
- * NULL).
- *
* ofproto implementation ->run() functions should use this function to expire
* OpenFlow flows. */
void
ofproto_rule_expire(struct rule *rule, uint8_t reason)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofproto *ofproto = rule->ofproto;
-
- ovs_assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT
- || reason == OFPRR_DELETE || reason == OFPRR_GROUP_DELETE);
-
- ofproto_rule_delete__(ofproto, rule, reason);
+ ofproto_rule_delete__(rule, reason);
}
/* Reduces '*timeout' to no more than 'max'. A value of zero in either case
error = ofproto_check_ofpacts(ofproto, fm.ofpacts, fm.ofpacts_len);
}
if (!error) {
- error = handle_flow_mod__(ofproto, ofconn, &fm, oh);
+ struct flow_mod_requester req;
+
+ req.ofconn = ofconn;
+ req.xid = oh->xid;
+ error = handle_flow_mod__(ofproto, &fm, &req);
}
if (error) {
goto exit_free_ofpacts;
}
static enum ofperr
-handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
- struct ofputil_flow_mod *fm, const struct ofp_header *oh)
+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);
- if (ofproto->n_pending < 50) {
- switch (fm->command) {
- case OFPFC_ADD:
- error = add_flow(ofproto, ofconn, fm, oh);
- break;
+ switch (fm->command) {
+ case OFPFC_ADD:
+ error = add_flow(ofproto, fm, req);
+ break;
- case OFPFC_MODIFY:
- error = modify_flows_loose(ofproto, ofconn, fm, oh);
- break;
+ case OFPFC_MODIFY:
+ error = modify_flows_loose(ofproto, fm, req);
+ break;
- case OFPFC_MODIFY_STRICT:
- error = modify_flow_strict(ofproto, ofconn, fm, oh);
- break;
+ case OFPFC_MODIFY_STRICT:
+ error = modify_flow_strict(ofproto, fm, req);
+ break;
- case OFPFC_DELETE:
- error = delete_flows_loose(ofproto, ofconn, fm, oh);
- break;
+ case OFPFC_DELETE:
+ error = delete_flows_loose(ofproto, fm, req);
+ break;
- case OFPFC_DELETE_STRICT:
- error = delete_flow_strict(ofproto, ofconn, fm, oh);
- break;
+ case OFPFC_DELETE_STRICT:
+ error = delete_flow_strict(ofproto, fm, req);
+ break;
- 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;
+ 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);
}
- } else {
- ovs_assert(!list_is_empty(&ofproto->pending));
- error = OFPROTO_POSTPONE;
+ error = OFPERR_OFPFMFC_BAD_COMMAND;
+ break;
}
+ ofmonitor_flush(ofproto->connmgr);
ovs_mutex_unlock(&ofproto_mutex);
run_rule_executes(ofproto);
}
if (request.role != OFPCR12_ROLE_NOCHANGE) {
- if (ofconn_get_role(ofconn) != request.role
- && ofconn_has_pending_opgroups(ofconn)) {
- return OFPROTO_POSTPONE;
- }
-
if (request.have_generation_id
&& !ofconn_set_master_election_id(ofconn, request.generation_id)) {
return OFPERR_OFPRRFC_STALE;
cur = ofconn_get_protocol(ofconn);
next = ofputil_protocol_set_base(cur, next_base);
- if (cur != next && ofconn_has_pending_opgroups(ofconn)) {
- /* Avoid sending async messages in surprising protocol. */
- return OFPROTO_POSTPONE;
- }
-
ofconn_set_protocol(ofconn, next);
+
return 0;
}
return OFPERR_OFPBRC_EPERM;
}
- if (format != ofconn_get_packet_in_format(ofconn)
- && ofconn_has_pending_opgroups(ofconn)) {
- /* Avoid sending async message in surprsing packet in format. */
- return OFPROTO_POSTPONE;
- }
-
ofconn_set_packet_in_format(ofconn, format);
return 0;
}
{
struct ofpbuf *buf;
- if (ofconn_has_pending_opgroups(ofconn)) {
- return OFPROTO_POSTPONE;
- }
-
buf = ofpraw_alloc_reply((oh->version == OFP10_VERSION
? OFPRAW_OFPT10_BARRIER_REPLY
: OFPRAW_OFPT11_BARRIER_REPLY), oh, 0);
struct list *msgs)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofoperation *op = rule->pending;
const struct rule_actions *actions;
struct ofputil_flow_update fu;
struct match match;
- if (op && op->type == OFOPERATION_ADD) {
- /* We'll report the final flow when the operation completes. Reporting
- * it now would cause a duplicate report later. */
- return;
- }
-
fu.event = (flags & (NXFMF_INITIAL | NXFMF_ADD)
? NXFME_ADDED : NXFME_MODIFIED);
fu.reason = 0;
fu.match = &match;
fu.priority = rule->cr.priority;
- if (!(flags & NXFMF_ACTIONS)) {
- actions = NULL;
- } else if (!op) {
- actions = rule_get_actions(rule);
- } else {
- /* An operation is in progress. Use the previous version of the flow's
- * actions, so that when the operation commits we report the change. */
- switch (op->type) {
- case OFOPERATION_ADD:
- OVS_NOT_REACHED();
-
- case OFOPERATION_MODIFY:
- case OFOPERATION_REPLACE:
- actions = op->actions ? op->actions : rule_get_actions(rule);
- break;
-
- case OFOPERATION_DELETE:
- actions = rule_get_actions(rule);
- break;
-
- default:
- OVS_NOT_REACHED();
- }
- }
+ actions = flags & NXFMF_ACTIONS ? rule_get_actions(rule) : NULL;
fu.ofpacts = actions ? actions->ofpacts : NULL;
fu.ofpacts_len = actions ? actions->ofpacts_len : 0;
return;
}
- if (!(rule->pending
- ? ofoperation_has_out_port(rule->pending, m->out_port)
- : ofproto_rule_has_out_port(rule, m->out_port))) {
+ if (!ofproto_rule_has_out_port(rule, m->out_port)) {
return;
}
OVS_REQUIRES(ofproto_mutex)
{
const struct ofproto *ofproto = ofconn_get_ofproto(m->ofconn);
- const struct ofoperation *op;
const struct oftable *table;
struct cls_rule target;
fat_rwlock_rdlock(&table->cls.rwlock);
cls_cursor_init(&cursor, &table->cls, &target);
CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
- ovs_assert(!rule->pending); /* XXX */
ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules);
}
fat_rwlock_unlock(&table->cls.rwlock);
}
-
- HMAP_FOR_EACH (op, hmap_node, &ofproto->deletions) {
- struct rule *rule = op->rule;
-
- if (((m->table_id == 0xff
- ? !(ofproto->tables[rule->table_id].flags & OFTABLE_HIDDEN)
- : m->table_id == rule->table_id))
- && cls_rule_is_loose_match(&rule->cr, &target.match)) {
- ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules);
- }
- }
cls_rule_destroy(&target);
}
ofmonitor_destroy(m);
error = 0;
} else {
- error = OFPERR_NXBRC_FM_BAD_ID;
+ error = OFPERR_OFPMOFC_UNKNOWN_MONITOR;
}
ovs_mutex_unlock(&ofproto_mutex);
}
static enum ofperr
-handle_delete_meter(struct ofconn *ofconn, const struct ofp_header *oh,
- struct ofputil_meter_mod *mm)
+handle_delete_meter(struct ofconn *ofconn, struct ofputil_meter_mod *mm)
OVS_EXCLUDED(ofproto_mutex)
{
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
struct rule *rule;
LIST_FOR_EACH (rule, meter_list_node, &meter->rules) {
- if (rule->pending) {
- error = OFPROTO_POSTPONE;
- goto exit;
- }
rule_collection_add(&rules, rule);
}
}
}
if (rules.n > 0) {
- delete_flows__(ofproto, ofconn, oh, &rules, OFPRR_METER_DELETE);
+ delete_flows__(&rules, OFPRR_METER_DELETE, NULL);
}
/* Delete the meters. */
meter_delete(ofproto, first, last);
-exit:
ovs_mutex_unlock(&ofproto_mutex);
rule_collection_destroy(&rules);
break;
case OFPMC13_DELETE:
- error = handle_delete_meter(ofconn, oh, &mm);
+ error = handle_delete_meter(ofconn, &mm);
break;
default:
flow_mod_init(&fm, &match, 0, NULL, 0, OFPFC_DELETE);
fm.delete_reason = OFPRR_GROUP_DELETE;
fm.out_group = ofgroup->group_id;
- handle_flow_mod__(ofproto, NULL, &fm, NULL);
+ handle_flow_mod__(ofproto, &fm, NULL);
hmap_remove(&ofproto->groups, &ofgroup->hmap_node);
/* No-one can find this group any more. */
}
}
-static bool
+static void
handle_openflow(struct ofconn *ofconn, const struct ofpbuf *ofp_msg)
OVS_EXCLUDED(ofproto_mutex)
{
int error = handle_openflow__(ofconn, ofp_msg);
- if (error && error != OFPROTO_POSTPONE) {
+ if (error) {
ofconn_send_error(ofconn, ofpbuf_data(ofp_msg), error);
}
COVERAGE_INC(ofproto_recv_openflow);
- return error != OFPROTO_POSTPONE;
}
\f
/* Asynchronous operations. */
-/* Creates and returns a new ofopgroup that is not associated with any
- * OpenFlow connection.
- *
- * The caller should add operations to the returned group with
- * ofoperation_create() and then submit it with ofopgroup_submit(). */
-static struct ofopgroup *
-ofopgroup_create_unattached(struct ofproto *ofproto)
- OVS_REQUIRES(ofproto_mutex)
-{
- struct ofopgroup *group = xzalloc(sizeof *group);
- group->ofproto = ofproto;
- list_init(&group->ofproto_node);
- list_init(&group->ops);
- list_init(&group->ofconn_node);
- return group;
-}
-
-/* Creates and returns a new ofopgroup for 'ofproto'.
- *
- * If 'ofconn' is NULL, the new ofopgroup is not associated with any OpenFlow
- * connection. The 'request' and 'buffer_id' arguments are ignored.
- *
- * If 'ofconn' is nonnull, then the new ofopgroup is associated with 'ofconn'.
- * If the ofopgroup eventually fails, then the error reply will include
- * 'request'. If the ofopgroup eventually succeeds, then the packet with
- * buffer id 'buffer_id' on 'ofconn' will be sent by 'ofconn''s ofproto.
- *
- * The caller should add operations to the returned group with
- * ofoperation_create() and then submit it with ofopgroup_submit(). */
-static struct ofopgroup *
-ofopgroup_create(struct ofproto *ofproto, struct ofconn *ofconn,
- const struct ofp_header *request, uint32_t buffer_id)
- OVS_REQUIRES(ofproto_mutex)
-{
- struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
- if (ofconn) {
- size_t request_len = ntohs(request->length);
-
- ovs_assert(ofconn_get_ofproto(ofconn) == ofproto);
-
- ofconn_add_opgroup(ofconn, &group->ofconn_node);
- group->ofconn = ofconn;
- group->request = xmemdup(request, MIN(request_len, 64));
- group->buffer_id = buffer_id;
- }
- return group;
-}
-
-/* Submits 'group' for processing.
- *
- * If 'group' contains no operations (e.g. none were ever added, or all of the
- * ones that were added completed synchronously), then it is destroyed
- * immediately. Otherwise it is added to the ofproto's list of pending
- * groups. */
-static void
-ofopgroup_submit(struct ofopgroup *group)
- OVS_REQUIRES(ofproto_mutex)
-{
- if (!group->n_running) {
- ofopgroup_complete(group);
- } else {
- list_push_back(&group->ofproto->pending, &group->ofproto_node);
- group->ofproto->n_pending++;
- }
-}
-
-static void
-ofopgroup_complete(struct ofopgroup *group)
+static enum ofperr
+send_buffered_packet(struct ofconn *ofconn, uint32_t buffer_id,
+ struct rule *rule)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofproto *ofproto = group->ofproto;
-
- struct ofconn *abbrev_ofconn;
- ovs_be32 abbrev_xid;
-
- struct ofoperation *op, *next_op;
- int error;
-
- ovs_assert(!group->n_running);
-
- error = 0;
- LIST_FOR_EACH (op, group_node, &group->ops) {
- if (op->error) {
- error = op->error;
- break;
- }
- }
-
- if (!error && group->ofconn && group->buffer_id != UINT32_MAX) {
- LIST_FOR_EACH (op, group_node, &group->ops) {
- if (op->type != OFOPERATION_DELETE) {
- struct ofpbuf *packet;
- ofp_port_t in_port;
-
- error = ofconn_pktbuf_retrieve(group->ofconn, group->buffer_id,
- &packet, &in_port);
- if (packet) {
- struct rule_execute *re;
-
- ovs_assert(!error);
-
- ofproto_rule_ref(op->rule);
-
- re = xmalloc(sizeof *re);
- re->rule = op->rule;
- re->in_port = in_port;
- re->packet = packet;
-
- if (!guarded_list_push_back(&ofproto->rule_executes,
- &re->list_node, 1024)) {
- ofproto_rule_unref(op->rule);
- ofpbuf_delete(re->packet);
- free(re);
- }
- }
- break;
- }
- }
- }
-
- if (!error && !list_is_empty(&group->ofconn_node)) {
- abbrev_ofconn = group->ofconn;
- abbrev_xid = group->request->xid;
- } else {
- abbrev_ofconn = NULL;
- abbrev_xid = htonl(0);
- }
- LIST_FOR_EACH_SAFE (op, next_op, group_node, &group->ops) {
- struct rule *rule = op->rule;
-
- /* We generally want to report the change to active OpenFlow flow
- monitors (e.g. NXST_FLOW_MONITOR). There are three exceptions:
-
- - The operation failed.
-
- - The affected rule is not visible to controllers.
-
- - The operation's only effect was to update rule->modified. */
- if (!(op->error
- || rule_is_hidden(rule)
- || (op->type == OFOPERATION_MODIFY
- && !op->actions
- && rule->flow_cookie == op->flow_cookie))) {
- enum nx_flow_update_event event_type;
-
- switch (op->type) {
- case OFOPERATION_ADD:
- case OFOPERATION_REPLACE:
- event_type = NXFME_ADDED;
- break;
+ enum ofperr error = 0;
+ if (ofconn && buffer_id != UINT32_MAX) {
+ struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
+ struct ofpbuf *packet;
+ ofp_port_t in_port;
- case OFOPERATION_DELETE:
- event_type = NXFME_DELETED;
- break;
+ error = ofconn_pktbuf_retrieve(ofconn, buffer_id, &packet, &in_port);
+ if (packet) {
+ struct rule_execute *re;
- case OFOPERATION_MODIFY:
- event_type = NXFME_MODIFIED;
- break;
+ ofproto_rule_ref(rule);
- default:
- OVS_NOT_REACHED();
- }
-
- ofmonitor_report(ofproto->connmgr, rule, event_type,
- op->reason, abbrev_ofconn, abbrev_xid);
- }
+ re = xmalloc(sizeof *re);
+ re->rule = rule;
+ re->in_port = in_port;
+ re->packet = packet;
- rule->pending = NULL;
-
- ovs_assert(!op->error || op->type == OFOPERATION_ADD);
- switch (op->type) {
- case OFOPERATION_ADD:
- if (!op->error) {
- uint16_t vid_mask;
-
- vid_mask = minimask_get_vid_mask(&rule->cr.match.mask);
- if (vid_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;
- }
- }
- } else {
- oftable_remove_rule(rule);
+ if (!guarded_list_push_back(&ofproto->rule_executes,
+ &re->list_node, 1024)) {
ofproto_rule_unref(rule);
+ ofpbuf_delete(re->packet);
+ free(re);
}
- break;
-
- case OFOPERATION_DELETE:
- ofproto_rule_unref(rule);
- op->rule = NULL;
- break;
-
- case OFOPERATION_MODIFY:
- case OFOPERATION_REPLACE: {
- long long now = time_msec();
-
- ovs_mutex_lock(&rule->mutex);
- rule->modified = now;
- if (op->type == OFOPERATION_REPLACE) {
- rule->created = now;
- }
- ovs_mutex_unlock(&rule->mutex);
- break;
}
-
- default:
- OVS_NOT_REACHED();
- }
-
- ofoperation_destroy(op);
- }
-
- ofmonitor_flush(ofproto->connmgr);
-
- if (!list_is_empty(&group->ofproto_node)) {
- ovs_assert(ofproto->n_pending > 0);
- ofproto->n_pending--;
- list_remove(&group->ofproto_node);
- }
- if (!list_is_empty(&group->ofconn_node)) {
- list_remove(&group->ofconn_node);
- if (error) {
- ofconn_send_error(group->ofconn, group->request, error);
- }
- connmgr_retry(ofproto->connmgr);
- }
- free(group->request);
- free(group);
-}
-
-/* Initiates a new operation on 'rule', of the specified 'type', within
- * 'group'. Prior to calling, 'rule' must not have any pending operation.
- *
- * For a 'type' of OFOPERATION_DELETE, 'reason' should specify the reason that
- * the flow is being deleted. For other 'type's, 'reason' is ignored (use 0).
- *
- * Returns the newly created ofoperation (which is also available as
- * rule->pending). */
-static struct ofoperation *
-ofoperation_create(struct ofopgroup *group, struct rule *rule,
- enum ofoperation_type type,
- enum ofp_flow_removed_reason reason)
- OVS_REQUIRES(ofproto_mutex)
-{
- struct ofproto *ofproto = group->ofproto;
- struct ofoperation *op;
-
- ovs_assert(!rule->pending);
-
- op = rule->pending = xzalloc(sizeof *op);
- op->group = group;
- list_push_back(&group->ops, &op->group_node);
- op->rule = rule;
- op->type = type;
- op->reason = reason;
- op->flow_cookie = rule->flow_cookie;
- ovs_mutex_lock(&rule->mutex);
- op->idle_timeout = rule->idle_timeout;
- op->hard_timeout = rule->hard_timeout;
- ovs_mutex_unlock(&rule->mutex);
- op->flags = rule->flags;
-
- group->n_running++;
-
- if (type == OFOPERATION_DELETE) {
- hmap_insert(&ofproto->deletions, &op->hmap_node,
- cls_rule_hash(&rule->cr, rule->table_id));
- }
-
- return op;
-}
-
-static void
-ofoperation_destroy(struct ofoperation *op)
- OVS_REQUIRES(ofproto_mutex)
-{
- struct ofopgroup *group = op->group;
-
- if (op->rule) {
- op->rule->pending = NULL;
- }
- if (op->type == OFOPERATION_DELETE) {
- hmap_remove(&group->ofproto->deletions, &op->hmap_node);
- }
- list_remove(&op->group_node);
- rule_actions_destroy(op->actions);
- free(op);
-}
-
-/* Indicates that 'op' completed with status 'error', which is either 0 to
- * indicate success or an OpenFlow error code on failure.
- *
- * If 'error' is 0, indicating success, the operation will be committed
- * permanently to the flow table.
- *
- * Flow modifications and deletions must always succeed. Flow additions may
- * fail, indicated by nonzero 'error'. If an "add flow" operation fails, this
- * function removes the new rule. The caller must have uninitialized any
- * derived state in the new rule, as in step 5 of in the "Life Cycle" in
- * ofproto/ofproto-provider.h. ofoperation_complete() performs steps 6 and and
- * 7 for the new rule, calling its ->rule_dealloc() function.
- *
- * Please see the large comment in ofproto/ofproto-provider.h titled
- * "Asynchronous Operation Support" for more information. */
-void
-ofoperation_complete(struct ofoperation *op, enum ofperr error)
-{
- struct ofopgroup *group = op->group;
-
- ovs_assert(group->n_running > 0);
- ovs_assert(!error || op->type == OFOPERATION_ADD);
-
- op->error = error;
- if (!--group->n_running && !list_is_empty(&group->ofproto_node)) {
- /* This function can be called from ->rule_construct(), in which case
- * ofproto_mutex is held, or it can be called from ->run(), in which
- * case ofproto_mutex is not held. But only in the latter case can we
- * arrive here, so we can safely take ofproto_mutex now. */
- ovs_mutex_lock(&ofproto_mutex);
- ovs_assert(op->rule->pending == op);
- ofopgroup_complete(group);
- ovs_mutex_unlock(&ofproto_mutex);
}
+ return error;
}
\f
static uint64_t
return false;
}
-
-/* Searches 'ofproto' for tables that have more flows than their configured
- * maximum and that have flow eviction enabled, and evicts as many flows as
- * necessary and currently feasible from them.
- *
- * This triggers only when an OpenFlow table has N flows in it and then the
- * client configures a maximum number of flows less than N. */
-static void
-ofproto_evict(struct ofproto *ofproto)
-{
- struct oftable *table;
-
- ovs_mutex_lock(&ofproto_mutex);
- OFPROTO_FOR_EACH_TABLE (table, ofproto) {
- evict_rules_from_table(ofproto, table, 0);
- }
- ovs_mutex_unlock(&ofproto_mutex);
-}
\f
/* Eviction groups. */
projects / cascardo / ovs.git / blobdiff