37
40
struct OVS_LOCKABLE rule_dpif;
38
41
struct OVS_LOCKABLE group_dpif;
40
enum rule_dpif_lookup_verdict {
41
RULE_DPIF_LOOKUP_VERDICT_MATCH, /* A match occurred. */
42
RULE_DPIF_LOOKUP_VERDICT_CONTROLLER, /* A miss occurred and the packet
45
RULE_DPIF_LOOKUP_VERDICT_DROP, /* A miss occurred and the packet
46
* should be dropped. */
47
RULE_DPIF_LOOKUP_VERDICT_DEFAULT, /* A miss occurred and the packet
48
* should handled by the default
50
* For pre-OF1.3 it should be
51
* forwarded to the controller.
52
* For OF1.3+ it should be
56
43
/* Number of implemented OpenFlow tables. */
57
44
enum { N_TABLES = 255 };
58
45
enum { TBL_INTERNAL = N_TABLES - 1 }; /* Used for internal hidden rules. */
59
46
BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
61
/* For lock annotation below only. */
62
extern struct fat_rwlock xlate_rwlock;
64
48
/* Ofproto-dpif -- DPIF based ofproto implementation.
66
50
* Ofproto-dpif provides an ofproto implementation for those platforms which
89
73
* Ofproto-dpif-xlate is responsible for translating OpenFlow actions into
90
74
* datapath actions. */
76
/* Stores the various features which the corresponding backer supports. */
77
struct dpif_backer_support {
78
/* True if the datapath supports variable-length
79
* OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions.
80
* False if the datapath supports only 8-byte (or shorter) userdata. */
81
bool variable_length_userdata;
83
/* Maximum number of MPLS label stack entries that the datapath supports
85
size_t max_mpls_depth;
87
/* True if the datapath supports masked data in OVS_ACTION_ATTR_SET
89
bool masked_set_action;
91
/* True if the datapath supports recirculation. */
94
/* True if the datapath supports tnl_push and pop actions. */
97
/* True if the datapath supports OVS_FLOW_ATTR_UFID. */
92
101
size_t ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *);
93
102
bool ofproto_dpif_get_enable_recirc(const struct ofproto_dpif *);
95
uint8_t rule_dpif_lookup(struct ofproto_dpif *, struct flow *,
96
struct flow_wildcards *, struct rule_dpif **rule,
99
/* If 'recirc_id' is set, starts looking up from internal table for
100
* post recirculation flows or packets. Otherwise, starts from table 0. */
101
static inline uint8_t
102
rule_dpif_lookup_get_init_table_id(const struct flow *flow)
104
return flow->recirc_id ? TBL_INTERNAL : 0;
107
enum rule_dpif_lookup_verdict rule_dpif_lookup_from_table(struct ofproto_dpif *,
109
struct flow_wildcards *,
110
bool force_controller_on_miss,
112
struct rule_dpif **rule,
103
bool ofproto_dpif_get_enable_ufid(struct dpif_backer *backer);
105
cls_version_t ofproto_dpif_get_tables_version(struct ofproto_dpif *);
107
struct rule_dpif *rule_dpif_lookup_from_table(struct ofproto_dpif *,
108
cls_version_t, struct flow *,
109
struct flow_wildcards *,
111
const struct dpif_flow_stats *,
115
bool honor_table_miss);
115
117
static inline void rule_dpif_ref(struct rule_dpif *);
116
118
static inline void rule_dpif_unref(struct rule_dpif *);
138
141
struct rule_dpif *no_packet_in_rule,
139
142
struct rule_dpif **rule, bool take_ref);
144
void group_dpif_credit_stats(struct group_dpif *,
145
struct ofputil_bucket *,
146
const struct dpif_flow_stats *);
141
147
bool group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id,
142
148
struct group_dpif **group);
144
void group_dpif_release(struct group_dpif *group);
146
150
void group_dpif_get_buckets(const struct group_dpif *group,
147
const struct list **buckets);
151
const struct ovs_list **buckets);
148
152
enum ofp11_group_type group_dpif_get_type(const struct group_dpif *group);
153
const char *group_dpif_get_selection_method(const struct group_dpif *group);
154
uint64_t group_dpif_get_selection_method_param(const struct group_dpif *group);
155
const struct field_array *group_dpif_get_fields(const struct group_dpif *group);
150
157
bool ofproto_has_vlan_splinters(const struct ofproto_dpif *);
151
158
ofp_port_t vsp_realdev_to_vlandev(const struct ofproto_dpif *,
152
159
ofp_port_t realdev_ofp_port,
153
160
ovs_be16 vlan_tci);
154
bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *);
161
bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *,
162
struct dp_packet *packet);
156
164
int ofproto_dpif_execute_actions(struct ofproto_dpif *, const struct flow *,
157
165
struct rule_dpif *, const struct ofpact *,
158
size_t ofpacts_len, struct ofpbuf *)
159
OVS_EXCLUDED(xlate_rwlock);
166
size_t ofpacts_len, struct dp_packet *);
160
167
void ofproto_dpif_send_packet_in(struct ofproto_dpif *,
161
168
struct ofproto_packet_in *);
162
169
bool ofproto_dpif_wants_packet_in_on_miss(struct ofproto_dpif *);
163
int ofproto_dpif_send_packet(const struct ofport_dpif *, struct ofpbuf *);
170
int ofproto_dpif_send_packet(const struct ofport_dpif *, struct dp_packet *);
164
171
void ofproto_dpif_flow_mod(struct ofproto_dpif *, struct ofputil_flow_mod *);
165
172
struct rule_dpif *ofproto_dpif_refresh_rule(struct rule_dpif *);
167
174
struct ofport_dpif *odp_port_to_ofport(const struct dpif_backer *, odp_port_t);
173
* Recirculation is a technique to allow a frame to re-enter the packet
174
* processing path for one or multiple times to achieve more flexible packet
175
* processing in the data path. MPLS handling and selecting bond slave port
178
* Data path and user space interface
179
* -----------------------------------
181
* Two new fields, recirc_id and dp_hash, are added to the current flow data
182
* structure. They are both of type uint32_t. In addition, a new action,
185
* The value recirc_id is used to distinguish a packet from multiple
186
* iterations of recirculation. A packet initially received is considered of
187
* having recirc_id of 0. Recirc_id is managed by the user space, opaque to
190
* On the other hand, dp_hash can only be computed by the data path, opaque to
191
* the user space. In fact, user space may not able to recompute the hash
192
* value. The dp_hash value should be wildcarded when for a newly received
193
* packet. RECIRC action specifies whether the hash is computed. If computed,
194
* how many fields to be included in the hash computation. The computed hash
195
* value is stored into the dp_hash field prior to recirculation.
197
* The RECIRC action computes and set the dp_hash field, set the recirc_id
198
* field and then reprocess the packet as if it was received on the same input
199
* port. RECIRC action works like a function call; actions listed behind the
200
* RECIRC action will be executed after its execution. RECIRC action can be
201
* nested, data path implementation limits the number of recirculation executed
202
* to prevent unreasonable nesting depth or infinite loop.
204
* Both flow fields and the RECIRC action are exposed as open flow fields via
207
* Post recirculation flow
208
* ------------------------
210
* At the open flow level, post recirculation rules are always hidden from the
211
* controller. They are installed in table 254 which is set up as a hidden
212
* table during boot time. Those rules are managed by the local user space
215
* To speed up the classifier look up process, recirc_id is always reflected
216
* into the metadata field, since recirc_id is required to be exactly matched.
218
* Classifier look up always starts with table 254. A post recirculation flow
219
* lookup should find its hidden rule within this table. On the other hand, A
220
* newly received packet should miss all post recirculation rules because its
221
* recirc_id is zero, then hit a pre-installed lower priority rule to redirect
222
* classifier to look up starting from table 0:
224
* * , actions=resubmit(,0)
226
* Post recirculation data path flows are managed like other data path flows.
227
* They are created on demand. Miss handling, stats collection and revalidation
228
* work the same way as regular flows.
230
* If the bridge which originates the recirculation is different from the bridge
231
* that receives the post recirculation packet (e.g. when patch port is used),
232
* the packet will be processed directly by the recirculation bridge with
233
* in_port set to OFPP_NONE. Admittedly, doing this limits the recirculation
234
* bridge from matching on in_port of post recirculation packets, and will be
235
* fixed in the near future.
237
* TODO: Always restore the correct in_port.
241
struct ofproto_dpif *ofproto_dpif_recirc_get_ofproto(const struct dpif_backer *ofproto,
243
uint32_t ofproto_dpif_alloc_recirc_id(struct ofproto_dpif *ofproto);
244
void ofproto_dpif_free_recirc_id(struct ofproto_dpif *ofproto, uint32_t recirc_id);
175
struct ofport_dpif *ofp_port_to_ofport(const struct ofproto_dpif *,
245
178
int ofproto_dpif_add_internal_flow(struct ofproto_dpif *,
246
179
const struct match *, int priority,
180
uint16_t idle_timeout,
247
181
const struct ofpbuf *ofpacts,
248
182
struct rule **rulep);
249
183
int ofproto_dpif_delete_internal_flow(struct ofproto_dpif *, struct match *,
added
removed
ofproto/ofproto-dpif.h
