forked from openvswitch/ovs
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ofproto-dpif.h
220 lines (184 loc) · 8.25 KB
/
ofproto-dpif.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License. */
#ifndef OFPROTO_DPIF_H
#define OFPROTO_DPIF_H 1
#include <stdint.h>
#include "fail-open.h"
#include "hmapx.h"
#include "odp-util.h"
#include "ofp-util.h"
#include "ovs-thread.h"
#include "ofproto-provider.h"
#include "timer.h"
#include "util.h"
#include "ovs-thread.h"
/* Priority for internal rules created to handle recirculation */
#define RECIRC_RULE_PRIORITY 20
union user_action_cookie;
struct dpif_flow_stats;
struct ofproto;
struct ofproto_dpif;
struct ofproto_packet_in;
struct ofport_dpif;
struct dpif_backer;
struct OVS_LOCKABLE rule_dpif;
struct OVS_LOCKABLE group_dpif;
/* Number of implemented OpenFlow tables. */
enum { N_TABLES = 255 };
enum { TBL_INTERNAL = N_TABLES - 1 }; /* Used for internal hidden rules. */
BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
/* Ofproto-dpif -- DPIF based ofproto implementation.
*
* Ofproto-dpif provides an ofproto implementation for those platforms which
* implement the netdev and dpif interface defined in netdev.h and dpif.h. The
* most important of which is the Linux Kernel Module (dpif-linux), but
* alternatives are supported such as a userspace only implementation
* (dpif-netdev), and a dummy implementation used for unit testing.
*
* Ofproto-dpif is divided into three major chunks.
*
* - ofproto-dpif.c
* The main ofproto-dpif module is responsible for implementing the
* provider interface, installing and removing datapath flows, maintaining
* packet statistics, running protocols (BFD, LACP, STP, etc), and
* configuring relevant submodules.
*
* - ofproto-dpif-upcall.c
* Ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel,
* processing miss upcalls, and handing more complex ones up to the main
* ofproto-dpif module. Miss upcall processing boils down to figuring out
* what each packet's actions are, executing them (i.e. asking the kernel to
* forward it), and handing it up to ofproto-dpif to decided whether or not
* to install a kernel flow.
*
* - ofproto-dpif-xlate.c
* Ofproto-dpif-xlate is responsible for translating OpenFlow actions into
* datapath actions. */
size_t ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *);
bool ofproto_dpif_get_enable_recirc(const struct ofproto_dpif *);
bool ofproto_dpif_get_enable_ufid(struct dpif_backer *backer);
struct rule_dpif *rule_dpif_lookup_from_table(struct ofproto_dpif *,
struct flow *,
struct flow_wildcards *,
bool take_ref,
const struct dpif_flow_stats *,
uint8_t *table_id,
ofp_port_t in_port,
bool may_packet_in,
bool honor_table_miss);
static inline void rule_dpif_ref(struct rule_dpif *);
static inline void rule_dpif_unref(struct rule_dpif *);
void rule_dpif_credit_stats(struct rule_dpif *rule ,
const struct dpif_flow_stats *);
static inline bool rule_dpif_is_fail_open(const struct rule_dpif *);
static inline bool rule_dpif_is_table_miss(const struct rule_dpif *);
static inline bool rule_dpif_is_internal(const struct rule_dpif *);
uint8_t rule_dpif_get_table(const struct rule_dpif *);
bool table_is_internal(uint8_t table_id);
const struct rule_actions *rule_dpif_get_actions(const struct rule_dpif *);
void rule_set_recirc_id(struct rule *, uint32_t id);
ovs_be64 rule_dpif_get_flow_cookie(const struct rule_dpif *rule);
void rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout,
uint16_t hard_timeout);
void choose_miss_rule(enum ofputil_port_config,
struct rule_dpif *miss_rule,
struct rule_dpif *no_packet_in_rule,
struct rule_dpif **rule, bool take_ref);
void group_dpif_credit_stats(struct group_dpif *,
struct ofputil_bucket *,
const struct dpif_flow_stats *);
bool group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id,
struct group_dpif **group);
void group_dpif_get_buckets(const struct group_dpif *group,
const struct ovs_list **buckets);
enum ofp11_group_type group_dpif_get_type(const struct group_dpif *group);
const char *group_dpif_get_selection_method(const struct group_dpif *group);
uint64_t group_dpif_get_selection_method_param(const struct group_dpif *group);
const struct field_array *group_dpif_get_fields(const struct group_dpif *group);
bool ofproto_has_vlan_splinters(const struct ofproto_dpif *);
ofp_port_t vsp_realdev_to_vlandev(const struct ofproto_dpif *,
ofp_port_t realdev_ofp_port,
ovs_be16 vlan_tci);
bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *,
struct dp_packet *packet);
int ofproto_dpif_execute_actions(struct ofproto_dpif *, const struct flow *,
struct rule_dpif *, const struct ofpact *,
size_t ofpacts_len, struct dp_packet *);
void ofproto_dpif_send_packet_in(struct ofproto_dpif *,
struct ofproto_packet_in *);
bool ofproto_dpif_wants_packet_in_on_miss(struct ofproto_dpif *);
int ofproto_dpif_send_packet(const struct ofport_dpif *, struct dp_packet *);
void ofproto_dpif_flow_mod(struct ofproto_dpif *, struct ofputil_flow_mod *);
struct rule_dpif *ofproto_dpif_refresh_rule(struct rule_dpif *);
struct ofport_dpif *odp_port_to_ofport(const struct dpif_backer *, odp_port_t);
struct ofport_dpif *ofp_port_to_ofport(const struct ofproto_dpif *,
ofp_port_t);
int ofproto_dpif_add_internal_flow(struct ofproto_dpif *,
const struct match *, int priority,
uint16_t idle_timeout,
const struct ofpbuf *ofpacts,
struct rule **rulep);
int ofproto_dpif_delete_internal_flow(struct ofproto_dpif *, struct match *,
int priority);
/* struct rule_dpif has struct rule as it's first member. */
#define RULE_CAST(RULE) ((struct rule *)RULE)
#define GROUP_CAST(GROUP) ((struct ofgroup *)GROUP)
static inline struct group_dpif* group_dpif_ref(struct group_dpif *group)
{
if (group) {
ofproto_group_ref(GROUP_CAST(group));
}
return group;
}
static inline void group_dpif_unref(struct group_dpif *group)
{
if (group) {
ofproto_group_unref(GROUP_CAST(group));
}
}
static inline void rule_dpif_ref(struct rule_dpif *rule)
{
if (rule) {
ofproto_rule_ref(RULE_CAST(rule));
}
}
static inline bool rule_dpif_try_ref(struct rule_dpif *rule)
{
if (rule) {
return ofproto_rule_try_ref(RULE_CAST(rule));
}
return false;
}
static inline void rule_dpif_unref(struct rule_dpif *rule)
{
if (rule) {
ofproto_rule_unref(RULE_CAST(rule));
}
}
static inline bool rule_dpif_is_fail_open(const struct rule_dpif *rule)
{
return is_fail_open_rule(RULE_CAST(rule));
}
static inline bool rule_dpif_is_table_miss(const struct rule_dpif *rule)
{
return rule_is_table_miss(RULE_CAST(rule));
}
/* Returns true if 'rule' is an internal rule, false otherwise. */
static inline bool rule_dpif_is_internal(const struct rule_dpif *rule)
{
return RULE_CAST(rule)->table_id == TBL_INTERNAL;
}
#undef RULE_CAST
bool ovs_native_tunneling_is_on(struct ofproto_dpif *ofproto);
#endif /* ofproto-dpif.h */