size_t n_fields);
static void oftable_remove_rule(struct rule *rule) OVS_REQUIRES(ofproto_mutex);
-static void oftable_remove_rule__(struct ofproto *ofproto,
- struct classifier *cls, struct rule *rule)
+static void oftable_remove_rule__(struct ofproto *, struct rule *)
OVS_REQUIRES(ofproto_mutex);
static void oftable_insert_rule(struct rule *);
}
static void
-ofproto_rule_delete__(struct ofproto *ofproto, struct classifier *cls,
- struct rule *rule)
+ofproto_rule_delete__(struct ofproto *ofproto, struct rule *rule)
OVS_REQUIRES(ofproto_mutex)
{
struct ofopgroup *group;
ovs_assert(!rule->pending);
- ovs_assert(cls == &ofproto->tables[rule->table_id].cls);
group = ofopgroup_create_unattached(ofproto);
delete_flow__(rule, group, OFPRR_DELETE);
* ofproto implementation.
*
* This function implements steps 4.4 and 4.5 in the section titled "Rule Life
- * Cycle" in ofproto-provider.h.
-
- * The 'cls' argument is redundant (it is &ofproto->tables[rule->table_id].cls)
- * but it allows Clang to do better checking. */
+ * Cycle" in ofproto-provider.h. */
void
-ofproto_rule_delete(struct ofproto *ofproto, struct classifier *cls,
- struct rule *rule)
+ofproto_rule_delete(struct ofproto *ofproto, struct rule *rule)
OVS_EXCLUDED(ofproto_mutex)
{
struct ofopgroup *group;
ovs_mutex_lock(&ofproto_mutex);
ovs_assert(!rule->pending);
- ovs_assert(cls == &ofproto->tables[rule->table_id].cls);
group = ofopgroup_create_unattached(ofproto);
ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE);
- oftable_remove_rule__(ofproto, cls, rule);
+ oftable_remove_rule__(ofproto, rule);
ofproto->ofproto_class->rule_delete(rule);
ofopgroup_submit(group);
ovs_rwlock_unlock(&table->cls.rwlock);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) {
if (!rule->pending) {
- ofproto_rule_delete__(ofproto, &table->cls, rule);
+ ofproto_rule_delete__(ofproto, rule);
}
}
}
* OFPERR_* OpenFlow error code on failure, or OFPROTO_POSTPONE if the
* operation cannot be initiated now but may be retried later.
*
- * This is a helper function for in-band control and fail-open. */
+ * This is a helper function for in-band control and fail-open and the "learn"
+ * action. */
int
ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm)
OVS_EXCLUDED(ofproto_mutex)
rule->ofproto->ofproto_class->rule_dealloc(rule);
}
+static uint32_t get_provider_meter_id(const struct ofproto *,
+ uint32_t of_meter_id);
+
/* Creates and returns a new 'struct rule_actions', with a ref_count of 1,
* whose actions are a copy of from the 'ofpacts_len' bytes of 'ofpacts'. */
struct rule_actions *
-rule_actions_create(const struct ofpact *ofpacts, size_t ofpacts_len)
+rule_actions_create(const struct ofproto *ofproto,
+ const struct ofpact *ofpacts, size_t ofpacts_len)
{
struct rule_actions *actions;
atomic_init(&actions->ref_count, 1);
actions->ofpacts = xmemdup(ofpacts, ofpacts_len);
actions->ofpacts_len = ofpacts_len;
- actions->meter_id = ofpacts_get_meter(ofpacts, ofpacts_len);
+ actions->provider_meter_id
+ = get_provider_meter_id(ofproto,
+ ofpacts_get_meter(ofpacts, ofpacts_len));
+
return actions;
}
atomic_sub(&actions->ref_count, 1, &orig);
if (orig == 1) {
+ free(actions->ofpacts);
free(actions);
} else {
ovs_assert(orig != 0);
}
mid = ofpacts_get_meter(ofpacts, ofpacts_len);
- if (mid && ofproto_get_provider_meter_id(ofproto, mid) == UINT32_MAX) {
+ if (mid && get_provider_meter_id(ofproto, mid) == UINT32_MAX) {
return OFPERR_OFPMMFC_INVALID_METER;
}
return 0;
for (i = 0; i < p->n_tables; i++) {
ots[i].table_id = i;
sprintf(ots[i].name, "table%zu", i);
- ots[i].match = htonll(OFPXMT12_MASK);
- ots[i].wildcards = htonll(OFPXMT12_MASK);
+ 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(OFPXMT12_MASK);
- ots[i].apply_setfields = htonll(OFPXMT12_MASK);
- ots[i].metadata_match = htonll(UINT64_MAX);
- ots[i].metadata_write = htonll(UINT64_MAX);
+ 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. */
struct rule_collection *rules)
OVS_REQUIRES(ofproto_mutex)
{
- if (ofproto_rule_is_hidden(rule)) {
+ /* We ordinarily want to skip hidden rules, but there has to be a way for
+ * code internal to OVS to modify and delete them, so if the criteria
+ * specify a priority that can only be for a hidden flow, then allow hidden
+ * rules to be selected. (This doesn't allow OpenFlow clients to meddle
+ * with hidden flows because OpenFlow uses only a 16-bit field to specify
+ * priority.) */
+ if (ofproto_rule_is_hidden(rule) && c->cr.priority <= UINT16_MAX) {
return 0;
} else if (rule->pending) {
return OFPROTO_POSTPONE;
goto exit;
}
- if (criteria->cookie_mask == htonll(UINT64_MAX)) {
+ if (criteria->cookie_mask == OVS_BE64_MAX) {
struct rule *rule;
HINDEX_FOR_EACH_WITH_HASH (rule, cookie_node,
goto exit;
}
- if (criteria->cookie_mask == htonll(UINT64_MAX)) {
+ if (criteria->cookie_mask == OVS_BE64_MAX) {
struct rule *rule;
HINDEX_FOR_EACH_WITH_HASH (rule, cookie_node,
*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);
+ rule->actions = rule_actions_create(ofproto, fm->ofpacts, fm->ofpacts_len);
list_init(&rule->meter_list_node);
rule->eviction_group = NULL;
list_init(&rule->expirable);
op = ofoperation_create(group, rule, type, 0);
- if (fm->modify_cookie && fm->new_cookie != htonll(UINT64_MAX)) {
+ if (fm->modify_cookie && fm->new_cookie != OVS_BE64_MAX) {
ofproto_rule_change_cookie(ofproto, rule, fm->new_cookie);
}
if (type == OFOPERATION_REPLACE) {
struct rule_actions *new_actions;
op->actions = rule->actions;
- new_actions = rule_actions_create(fm->ofpacts, fm->ofpacts_len);
+ new_actions = rule_actions_create(ofproto,
+ fm->ofpacts, fm->ofpacts_len);
ovs_mutex_lock(&rule->mutex);
rule->actions = new_actions;
struct ofputil_flow_mod *fm, const struct ofp_header *request)
OVS_REQUIRES(ofproto_mutex)
{
- if (fm->cookie_mask != htonll(0) || fm->new_cookie == htonll(UINT64_MAX)) {
+ if (fm->cookie_mask != htonll(0) || fm->new_cookie == OVS_BE64_MAX) {
return 0;
}
return add_flow(ofproto, ofconn, fm, request);
OVS_REQUIRES(ofproto_mutex)
{
struct ofproto *ofproto = rule->ofproto;
- struct classifier *cls = &ofproto->tables[rule->table_id].cls;
ovs_assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT
|| reason == OFPRR_DELETE || reason == OFPRR_GROUP_DELETE);
ofproto_rule_send_removed(rule, reason);
- ofproto_rule_delete__(ofproto, cls, rule);
+ ofproto_rule_delete__(ofproto, rule);
}
/* Reduces '*timeout' to no more than 'max'. A value of zero in either case
/*
* This is used in instruction validation at flow set-up time,
* as flows may not use non-existing meters.
- * This is also used by ofproto-providers to translate OpenFlow meter_ids
- * in METER instructions to the corresponding provider meter IDs.
* Return value of UINT32_MAX signifies an invalid meter.
*/
-uint32_t
-ofproto_get_provider_meter_id(const struct ofproto * ofproto,
- uint32_t of_meter_id)
+static uint32_t
+get_provider_meter_id(const struct ofproto *ofproto, uint32_t of_meter_id)
{
if (of_meter_id && of_meter_id <= ofproto->meter_features.max_meters) {
const struct meter *meter = ofproto->meters[of_meter_id];
ovs_assert(provider_meter_id.uint32 != UINT32_MAX);
*meterp = meter_create(&mm->meter, provider_meter_id);
}
- return 0;
+ return error;
}
static enum ofperr
{
struct meter *meter = ofproto->meters[mm->meter.meter_id];
enum ofperr error;
+ uint32_t provider_meter_id;
if (!meter) {
return OFPERR_OFPMMFC_UNKNOWN_METER;
}
+ provider_meter_id = meter->provider_meter_id.uint32;
error = ofproto->ofproto_class->meter_set(ofproto,
&meter->provider_meter_id,
&mm->meter);
- ovs_assert(meter->provider_meter_id.uint32 != UINT32_MAX);
+ ovs_assert(meter->provider_meter_id.uint32 == provider_meter_id);
if (!error) {
meter_update(meter, &mm->meter);
}
/* Removes 'rule' from the oftable that contains it. */
static void
-oftable_remove_rule__(struct ofproto *ofproto, struct classifier *cls,
- struct rule *rule)
+oftable_remove_rule__(struct ofproto *ofproto, struct rule *rule)
OVS_REQUIRES(ofproto_mutex)
{
+ struct classifier *cls = &ofproto->tables[rule->table_id].cls;
+
ovs_rwlock_wrlock(&cls->rwlock);
classifier_remove(cls, CONST_CAST(struct cls_rule *, &rule->cr));
ovs_rwlock_unlock(&cls->rwlock);
oftable_remove_rule(struct rule *rule)
OVS_REQUIRES(ofproto_mutex)
{
- struct ofproto *ofproto = rule->ofproto;
- struct oftable *table = &ofproto->tables[rule->table_id];
-
- oftable_remove_rule__(ofproto, &table->cls, rule);
+ oftable_remove_rule__(rule->ofproto, rule);
}
/* Inserts 'rule' into its oftable, which must not already contain any rule for
cookies_insert(ofproto, rule);
- if (rule->actions->meter_id) {
- struct meter *meter = ofproto->meters[rule->actions->meter_id];
+ if (rule->actions->provider_meter_id != UINT32_MAX) {
+ uint32_t meter_id = ofpacts_get_meter(rule->actions->ofpacts,
+ rule->actions->ofpacts_len);
+ struct meter *meter = ofproto->meters[meter_id];
list_insert(&meter->rules, &rule->meter_list_node);
}
ovs_rwlock_wrlock(&table->cls.rwlock);