}
}
+static bool
+any_pending_ops(const struct ofproto *p)
+{
+ return !list_is_empty(&p->pending);
+}
+
int
ofproto_run(struct ofproto *p)
{
case S_EVICT:
connmgr_run(p->connmgr, NULL);
ofproto_evict(p);
- if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
+ if (!any_pending_ops(p)) {
p->state = S_OPENFLOW;
}
break;
case S_FLUSH:
connmgr_run(p->connmgr, NULL);
ofproto_flush__(p);
- if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
+ if (!any_pending_ops(p)) {
connmgr_flushed(p->connmgr);
p->state = S_OPENFLOW;
}
case S_EVICT:
case S_FLUSH:
connmgr_wait(p->connmgr, false);
- if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
+ if (!any_pending_ops(p)) {
poll_immediate_wake();
}
break;
static void
ofproto_rule_destroy__(struct rule *rule)
{
- cls_rule_destroy(&rule->cr);
+ cls_rule_destroy(CONST_CAST(struct cls_rule *, &rule->cr));
rule_actions_unref(rule->actions);
- ovs_mutex_destroy(&rule->timeout_mutex);
ovs_mutex_destroy(&rule->mutex);
rule->ofproto->ofproto_class->rule_dealloc(rule);
}
/* Returns true if 'rule' has an OpenFlow OFPAT_OUTPUT or OFPAT_ENQUEUE action
* that outputs to 'port' (output to OFPP_FLOOD and OFPP_ALL doesn't count). */
-bool
+static bool
ofproto_rule_has_out_port(const struct rule *rule, ofp_port_t port)
{
return (port == OFPP_ANY
}
/* Returns true if 'rule' has group and equals group_id. */
-bool
+static bool
ofproto_rule_has_out_group(const struct rule *rule, uint32_t group_id)
{
return (group_id == OFPG11_ANY
* Rules with priority higher than UINT16_MAX are set up by ofproto itself
* (e.g. by in-band control) and are intentionally hidden from the
* controller. */
-bool
+static bool
ofproto_rule_is_hidden(const struct rule *rule)
{
return rule->cr.priority > UINT16_MAX;
fs.ofpacts = rule->actions->ofpacts;
fs.ofpacts_len = rule->actions->ofpacts_len;
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
fs.idle_timeout = rule->idle_timeout;
fs.hard_timeout = rule->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
fs.flags = rule->flags;
return false;
}
-static enum ofperr
-evict_rule_from_table(struct ofproto *ofproto, struct oftable *table)
+static bool
+should_evict_a_rule(struct oftable *table, unsigned int extra_space)
{
- struct rule *rule;
- size_t n_rules;
+ size_t count;
ovs_rwlock_rdlock(&table->cls.rwlock);
- n_rules = classifier_count(&table->cls);
+ count = classifier_count(&table->cls);
ovs_rwlock_unlock(&table->cls.rwlock);
- if (n_rules < table->max_flows) {
- return 0;
- } else if (!choose_rule_to_evict(table, &rule)) {
- return OFPERR_OFPFMFC_TABLE_FULL;
- } else if (rule->pending) {
- ovs_mutex_unlock(&rule->mutex);
- return OFPROTO_POSTPONE;
- } else {
- struct ofopgroup *group;
+ return count + extra_space > table->max_flows;
+}
- group = ofopgroup_create_unattached(ofproto);
- delete_flow__(rule, group, OFPRR_EVICTION);
- ofopgroup_submit(group);
+static enum ofperr
+evict_rules_from_table(struct ofproto *ofproto, struct oftable *table,
+ unsigned int extra_space)
+{
+ while (should_evict_a_rule(table, extra_space)) {
+ struct rule *rule;
- return 0;
+ if (!choose_rule_to_evict(table, &rule)) {
+ return OFPERR_OFPFMFC_TABLE_FULL;
+ } else if (rule->pending) {
+ ovs_mutex_unlock(&rule->mutex);
+ return OFPROTO_POSTPONE;
+ } else {
+ struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
+ ofoperation_create(group, rule,
+ OFOPERATION_DELETE, OFPRR_EVICTION);
+ oftable_remove_rule(rule);
+ ofproto->ofproto_class->rule_delete(rule);
+ }
}
+
+ return 0;
}
/* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT
}
/* If necessary, evict an existing rule to clear out space. */
- error = evict_rule_from_table(ofproto, table);
+ error = evict_rules_from_table(ofproto, table, 1);
if (error) {
cls_rule_destroy(&cr);
return error;
}
/* Initialize base state. */
- rule->ofproto = ofproto;
- cls_rule_move(&rule->cr, &cr);
+ *CONST_CAST(struct ofproto **, &rule->ofproto) = ofproto;
+ cls_rule_move(CONST_CAST(struct cls_rule *, &rule->cr), &cr);
atomic_init(&rule->ref_count, 1);
rule->pending = NULL;
rule->flow_cookie = fm->new_cookie;
rule->created = rule->modified = rule->used = time_msec();
- ovs_mutex_init(&rule->timeout_mutex);
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_init(&rule->mutex);
+ ovs_mutex_lock(&rule->mutex);
rule->idle_timeout = fm->idle_timeout;
rule->hard_timeout = fm->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
- rule->table_id = table - ofproto->tables;
+ *CONST_CAST(uint8_t *, &rule->table_id) = table - ofproto->tables;
rule->flags = fm->flags & OFPUTIL_FF_STATE;
rule->actions = rule_actions_create(fm->ofpacts, fm->ofpacts_len);
list_init(&rule->meter_list_node);
rule->monitor_flags = 0;
rule->add_seqno = 0;
rule->modify_seqno = 0;
- ovs_mutex_init(&rule->mutex);
/* Construct rule, initializing derived state. */
error = ofproto->ofproto_class->rule_construct(rule);
ofproto_rule_change_cookie(ofproto, rule, fm->new_cookie);
}
if (type == OFOPERATION_REPLACE) {
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
rule->idle_timeout = fm->idle_timeout;
rule->hard_timeout = fm->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
rule->flags = fm->flags & OFPUTIL_FF_STATE;
if (fm->idle_timeout || fm->hard_timeout) {
fr.table_id = rule->table_id;
calc_duration(rule->created, time_msec(),
&fr.duration_sec, &fr.duration_nsec);
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
fr.idle_timeout = rule->idle_timeout;
fr.hard_timeout = rule->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
rule->ofproto->ofproto_class->rule_get_stats(rule, &fr.packet_count,
&fr.byte_count);
void
ofproto_rule_reduce_timeouts(struct rule *rule,
uint16_t idle_timeout, uint16_t hard_timeout)
- OVS_EXCLUDED(ofproto_mutex, rule->timeout_mutex)
+ OVS_EXCLUDED(ofproto_mutex, rule->mutex)
{
if (!idle_timeout && !hard_timeout) {
return;
}
ovs_mutex_unlock(&ofproto_mutex);
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
reduce_timeout(idle_timeout, &rule->idle_timeout);
reduce_timeout(hard_timeout, &rule->hard_timeout);
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
}
\f
static enum ofperr
fu.event = (flags & (NXFMF_INITIAL | NXFMF_ADD)
? NXFME_ADDED : NXFME_MODIFIED);
fu.reason = 0;
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
fu.idle_timeout = rule->idle_timeout;
fu.hard_timeout = rule->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
fu.table_id = rule->table_id;
fu.cookie = rule->flow_cookie;
minimatch_expand(&rule->cr.match, &match);
}
} else {
ofproto_rule_change_cookie(ofproto, rule, op->flow_cookie);
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
rule->idle_timeout = op->idle_timeout;
rule->hard_timeout = op->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
if (op->actions) {
struct rule_actions *old_actions;
op->type = type;
op->reason = reason;
op->flow_cookie = rule->flow_cookie;
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
op->idle_timeout = rule->idle_timeout;
op->hard_timeout = rule->hard_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
op->flags = rule->flags;
group->n_running++;
static void
ofproto_evict(struct ofproto *ofproto)
{
- struct ofopgroup *group;
struct oftable *table;
- group = ofopgroup_create_unattached(ofproto);
OFPROTO_FOR_EACH_TABLE (table, ofproto) {
- while (table->eviction_fields) {
- struct rule *rule;
- size_t n_rules;
-
- ovs_rwlock_rdlock(&table->cls.rwlock);
- n_rules = classifier_count(&table->cls);
- ovs_rwlock_unlock(&table->cls.rwlock);
-
- if (n_rules <= table->max_flows) {
- break;
- }
-
- if (!choose_rule_to_evict(table, &rule)) {
- break;
- }
-
- if (rule->pending) {
- ovs_mutex_unlock(&rule->mutex);
- break;
- }
-
- ofoperation_create(group, rule,
- OFOPERATION_DELETE, OFPRR_EVICTION);
- oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_delete(rule);
- }
+ evict_rules_from_table(ofproto, table, 0);
}
- ofopgroup_submit(group);
}
\f
/* Eviction groups. */
uint32_t expiration_offset;
/* Calculate time of expiration. */
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
hard_expiration = (rule->hard_timeout
? rule->modified + rule->hard_timeout * 1000
: LLONG_MAX);
? rule->used + rule->idle_timeout * 1000
: LLONG_MAX);
expiration = MIN(hard_expiration, idle_expiration);
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
if (expiration == LLONG_MAX) {
return 0;
}
struct oftable *table = &ofproto->tables[rule->table_id];
bool has_timeout;
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
has_timeout = rule->hard_timeout || rule->idle_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
if (table->eviction_fields && has_timeout) {
struct eviction_group *evg;
struct rule *rule)
OVS_REQ_WRLOCK(cls->rwlock) OVS_RELEASES(rule->mutex)
{
- classifier_remove(cls, &rule->cr);
+ classifier_remove(cls, CONST_CAST(struct cls_rule *, &rule->cr));
ovs_mutex_lock(&ofproto_mutex);
cookies_remove(ofproto, rule);
struct oftable *table = &ofproto->tables[rule->table_id];
bool may_expire;
- ovs_mutex_lock(&rule->timeout_mutex);
+ ovs_mutex_lock(&rule->mutex);
may_expire = rule->hard_timeout || rule->idle_timeout;
- ovs_mutex_unlock(&rule->timeout_mutex);
+ ovs_mutex_unlock(&rule->mutex);
if (may_expire) {
ovs_mutex_lock(&ofproto_mutex);
list_insert(&meter->rules, &rule->meter_list_node);
}
ovs_rwlock_wrlock(&table->cls.rwlock);
- classifier_insert(&table->cls, &rule->cr);
+ classifier_insert(&table->cls, CONST_CAST(struct cls_rule *, &rule->cr));
ovs_rwlock_unlock(&table->cls.rwlock);
eviction_group_add_rule(rule);
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff