2 * Distributed under the terms of the GNU GPL version 2.
3 * Copyright (c) 2007, 2008 The Board of Trustees of The Leland
4 * Stanford Junior University
10 #include <linux/module.h>
11 #include <linux/rcupdate.h>
12 #include <linux/slab.h>
13 #include <linux/spinlock.h>
15 static struct sw_table *(*create_hw_table_hook)(void);
16 static struct module *hw_table_owner;
17 static DEFINE_SPINLOCK(hook_lock);
19 /* Attempts to append 'table' to the set of tables in 'chain'. Returns 0 or
20 * negative error. If 'table' is null it is assumed that table creation failed
21 * due to out-of-memory. */
22 static int add_table(struct sw_chain *chain, struct sw_table *table)
26 if (chain->n_tables >= CHAIN_MAX_TABLES) {
27 printk("too many tables in chain\n");
28 table->destroy(table);
31 chain->tables[chain->n_tables++] = table;
35 /* Creates and returns a new chain associated with 'dp'. Returns NULL if the
36 * chain cannot be created. */
37 struct sw_chain *chain_create(struct datapath *dp)
39 struct sw_chain *chain = kzalloc(sizeof *chain, GFP_KERNEL);
43 chain->owner = try_module_get(hw_table_owner) ? hw_table_owner : NULL;
44 if (chain->owner && create_hw_table_hook) {
45 struct sw_table *hwtable = create_hw_table_hook();
46 if (!hwtable || add_table(chain, hwtable))
50 if (add_table(chain, table_hash2_create(0x1EDC6F41, TABLE_HASH_MAX_FLOWS,
51 0x741B8CD7, TABLE_HASH_MAX_FLOWS))
52 || add_table(chain, table_linear_create(TABLE_LINEAR_MAX_FLOWS)))
62 /* Searches 'chain' for a flow matching 'key', which must not have any wildcard
63 * fields. Returns the flow if successful, otherwise a null pointer.
65 * Caller must hold rcu_read_lock or dp_mutex. */
66 struct sw_flow *chain_lookup(struct sw_chain *chain,
67 const struct sw_flow_key *key)
71 BUG_ON(key->wildcards);
72 for (i = 0; i < chain->n_tables; i++) {
73 struct sw_table *t = chain->tables[i];
74 struct sw_flow *flow = t->lookup(t, key);
84 /* Inserts 'flow' into 'chain', replacing any duplicate flow. Returns 0 if
85 * successful or a negative error.
87 * If successful, 'flow' becomes owned by the chain, otherwise it is retained
90 * Caller must hold dp_mutex. */
91 int chain_insert(struct sw_chain *chain, struct sw_flow *flow)
96 for (i = 0; i < chain->n_tables; i++) {
97 struct sw_table *t = chain->tables[i];
98 if (t->insert(t, flow))
105 /* Modifies actions in 'chain' that match 'key'. If 'strict' set, wildcards
106 * and priority must match. Returns the number of flows that were modified.
108 * Expensive in the general case as currently implemented, since it requires
109 * iterating through the entire contents of each table for keys that contain
110 * wildcards. Relatively cheap for fully specified keys. */
112 chain_modify(struct sw_chain *chain, const struct sw_flow_key *key,
113 uint16_t priority, int strict,
114 const struct ofp_action *actions, int n_actions)
119 for (i = 0; i < chain->n_tables; i++) {
120 struct sw_table *t = chain->tables[i];
121 count += t->modify(t, key, priority, strict, actions, n_actions);
127 /* Deletes from 'chain' any and all flows that match 'key'. If 'strict' set,
128 * wildcards and priority must match. Returns the number of flows that were
131 * Expensive in the general case as currently implemented, since it requires
132 * iterating through the entire contents of each table for keys that contain
133 * wildcards. Relatively cheap for fully specified keys.
135 * Caller must hold dp_mutex. */
136 int chain_delete(struct sw_chain *chain, const struct sw_flow_key *key,
137 uint16_t priority, int strict)
143 for (i = 0; i < chain->n_tables; i++) {
144 struct sw_table *t = chain->tables[i];
145 count += t->delete(t, key, priority, strict);
151 /* Performs timeout processing on all the tables in 'chain'. Returns the
152 * number of flow entries deleted through expiration.
154 * Expensive as currently implemented, since it iterates through the entire
155 * contents of each table.
157 * Caller must not hold dp_mutex, because individual tables take and release it
159 int chain_timeout(struct sw_chain *chain)
165 for (i = 0; i < chain->n_tables; i++) {
166 struct sw_table *t = chain->tables[i];
167 count += t->timeout(chain->dp, t);
172 /* Destroys 'chain', which must not have any users. */
173 void chain_destroy(struct sw_chain *chain)
178 for (i = 0; i < chain->n_tables; i++) {
179 struct sw_table *t = chain->tables[i];
183 module_put(chain->owner);
187 int chain_set_hw_hook(struct sw_table *(*create_hw_table)(void),
188 struct module *owner)
192 spin_lock(&hook_lock);
193 if (!create_hw_table_hook) {
194 create_hw_table_hook = create_hw_table;
195 hw_table_owner = owner;
198 spin_unlock(&hook_lock);
202 EXPORT_SYMBOL(chain_set_hw_hook);
204 void chain_clear_hw_hook(void)
206 create_hw_table_hook = NULL;
207 hw_table_owner = NULL;
209 EXPORT_SYMBOL(chain_clear_hw_hook);