#include <stdlib.h>
#include <string.h>
#include "crc32.h"
-#include "flow.h"
#include "datapath.h"
+#include "flow.h"
+#include "switch-flow.h"
struct sw_table_hash {
struct sw_table swt;
const struct sw_flow_key *key)
{
struct sw_table_hash *th = (struct sw_table_hash *) swt;
- unsigned int crc = crc32_calculate(&th->crc32, key, sizeof *key);
+ unsigned int crc = crc32_calculate(&th->crc32, key,
+ offsetof(struct sw_flow_key, wildcards));
return &th->buckets[crc & th->bucket_mask];
}
const struct sw_flow_key *key)
{
struct sw_flow *flow = *find_bucket(swt, key);
- return flow && !memcmp(&flow->key, key, sizeof *key) ? flow : NULL;
+ return flow && !flow_compare(&flow->key.flow, &key->flow) ? flow : NULL;
}
static int table_hash_insert(struct sw_table *swt, struct sw_flow *flow)
retval = 1;
} else {
struct sw_flow *old_flow = *bucket;
- if (!memcmp(&old_flow->key, &flow->key, sizeof flow->key)) {
+ if (!flow_compare(&old_flow->key.flow, &flow->key.flow)) {
*bucket = flow;
flow_free(old_flow);
retval = 1;
return retval;
}
+static int table_hash_modify(struct sw_table *swt,
+ const struct sw_flow_key *key, uint16_t priority, int strict,
+ const struct ofp_action_header *actions, size_t actions_len)
+{
+ struct sw_table_hash *th = (struct sw_table_hash *) swt;
+ unsigned int count = 0;
+
+ if (key->wildcards == 0) {
+ struct sw_flow **bucket = find_bucket(swt, key);
+ struct sw_flow *flow = *bucket;
+ if (flow && flow_matches_desc(&flow->key, key, strict)
+ && (!strict || (flow->priority == priority))) {
+ flow_replace_acts(flow, actions, actions_len);
+ count = 1;
+ }
+ } else {
+ unsigned int i;
+
+ for (i = 0; i <= th->bucket_mask; i++) {
+ struct sw_flow **bucket = &th->buckets[i];
+ struct sw_flow *flow = *bucket;
+ if (flow && flow_matches_desc(&flow->key, key, strict)
+ && (!strict || (flow->priority == priority))) {
+ flow_replace_acts(flow, actions, actions_len);
+ count++;
+ }
+ }
+ }
+ return count;
+}
+
/* Caller must update n_flows. */
static void
do_delete(struct sw_flow **bucket)
* priority. */
static int table_hash_delete(struct sw_table *swt,
const struct sw_flow_key *key,
+ uint16_t out_port,
uint16_t priority, int strict)
{
struct sw_table_hash *th = (struct sw_table_hash *) swt;
if (key->wildcards == 0) {
struct sw_flow **bucket = find_bucket(swt, key);
struct sw_flow *flow = *bucket;
- if (flow && !memcmp(&flow->key, key, sizeof *key)) {
+ if (flow && !flow_compare(&flow->key.flow, &key->flow)
+ && flow_has_out_port(flow, out_port)) {
do_delete(bucket);
count = 1;
}
for (i = 0; i <= th->bucket_mask; i++) {
struct sw_flow **bucket = &th->buckets[i];
struct sw_flow *flow = *bucket;
- if (flow && flow_del_matches(&flow->key, key, strict)) {
+ if (flow && flow_matches_desc(&flow->key, key, strict)
+ && flow_has_out_port(flow, out_port)) {
do_delete(bucket);
count++;
}
}
static int table_hash_iterate(struct sw_table *swt,
- const struct sw_flow_key *key,
+ const struct sw_flow_key *key, uint16_t out_port,
struct sw_table_position *position,
int (*callback)(struct sw_flow *, void *private),
void *private)
if (key->wildcards == 0) {
struct sw_flow *flow = table_hash_lookup(swt, key);
position->private[0] = -1;
- return flow ? callback(flow, private) : 0;
+ if (!flow || !flow_has_out_port(flow, out_port)) {
+ return 0;
+ }
+ return callback(flow, private);
} else {
int i;
for (i = position->private[0]; i <= th->bucket_mask; i++) {
struct sw_flow *flow = th->buckets[i];
- if (flow && flow_matches(key, &flow->key)) {
+ if (flow && flow_matches_1wild(&flow->key, key)
+ && flow_has_out_port(flow, out_port)) {
int error = callback(flow, private);
if (error) {
position->private[0] = i + 1;
{
struct sw_table_hash *th = (struct sw_table_hash *) swt;
stats->name = "hash";
- stats->n_flows = th->n_flows;
+ stats->wildcards = 0; /* No wildcards are supported. */
+ stats->n_flows = th->n_flows;
stats->max_flows = th->bucket_mask + 1;
+ stats->n_lookup = swt->n_lookup;
+ stats->n_matched = swt->n_matched;
}
struct sw_table *table_hash_create(unsigned int polynomial,
th = malloc(sizeof *th);
if (th == NULL)
return NULL;
+ memset(th, '\0', sizeof *th);
assert(!(n_buckets & (n_buckets - 1)));
th->buckets = calloc(n_buckets, sizeof *th->buckets);
swt = &th->swt;
swt->lookup = table_hash_lookup;
swt->insert = table_hash_insert;
+ swt->modify = table_hash_modify;
swt->delete = table_hash_delete;
swt->timeout = table_hash_timeout;
swt->destroy = table_hash_destroy;
for (i = 0; i < 2; i++) {
struct sw_flow *flow = *find_bucket(t2->subtable[i], key);
- if (flow && !memcmp(&flow->key, key, sizeof *key))
+ if (flow && !flow_compare(&flow->key.flow, &key->flow))
return flow;
}
return NULL;
return table_hash_insert(t2->subtable[1], flow);
}
+static int table_hash2_modify(struct sw_table *swt,
+ const struct sw_flow_key *key, uint16_t priority, int strict,
+ const struct ofp_action_header *actions, size_t actions_len)
+{
+ struct sw_table_hash2 *t2 = (struct sw_table_hash2 *) swt;
+ return (table_hash_modify(t2->subtable[0], key, priority, strict,
+ actions, actions_len)
+ + table_hash_modify(t2->subtable[1], key, priority, strict,
+ actions, actions_len));
+}
+
static int table_hash2_delete(struct sw_table *swt,
const struct sw_flow_key *key,
+ uint16_t out_port,
uint16_t priority, int strict)
{
struct sw_table_hash2 *t2 = (struct sw_table_hash2 *) swt;
- return (table_hash_delete(t2->subtable[0], key, priority, strict)
- + table_hash_delete(t2->subtable[1], key, priority, strict));
+ return (table_hash_delete(t2->subtable[0], key, out_port, priority, strict)
+ + table_hash_delete(t2->subtable[1], key, out_port, priority,
+ strict));
}
static void table_hash2_timeout(struct sw_table *swt, struct list *deleted)
}
static int table_hash2_iterate(struct sw_table *swt,
- const struct sw_flow_key *key,
+ const struct sw_flow_key *key,
+ uint16_t out_port,
struct sw_table_position *position,
int (*callback)(struct sw_flow *, void *),
void *private)
int i;
for (i = position->private[1]; i < 2; i++) {
- int error = table_hash_iterate(t2->subtable[i], key, position,
- callback, private);
+ int error = table_hash_iterate(t2->subtable[i], key, out_port,
+ position, callback, private);
if (error) {
return error;
}
for (i = 0; i < 2; i++)
table_hash_stats(t2->subtable[i], &substats[i]);
stats->name = "hash2";
- stats->n_flows = substats[0].n_flows + substats[1].n_flows;
+ stats->wildcards = 0; /* No wildcards are supported. */
+ stats->n_flows = substats[0].n_flows + substats[1].n_flows;
stats->max_flows = substats[0].max_flows + substats[1].max_flows;
+ stats->n_lookup = swt->n_lookup;
+ stats->n_matched = swt->n_matched;
}
struct sw_table *table_hash2_create(unsigned int poly0, unsigned int buckets0,
t2 = malloc(sizeof *t2);
if (t2 == NULL)
return NULL;
+ memset(t2, '\0', sizeof *t2);
t2->subtable[0] = table_hash_create(poly0, buckets0);
if (t2->subtable[0] == NULL)
swt = &t2->swt;
swt->lookup = table_hash2_lookup;
swt->insert = table_hash2_insert;
+ swt->modify = table_hash2_modify;
swt->delete = table_hash2_delete;
swt->timeout = table_hash2_timeout;
swt->destroy = table_hash2_destroy;