]>
Commit | Line | Data |
---|---|---|
621b8064 | 1 | /* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. |
9583bc14 EJ |
2 | * |
3 | * Licensed under the Apache License, Version 2.0 (the "License"); | |
4 | * you may not use this file except in compliance with the License. | |
5 | * You may obtain a copy of the License at: | |
6 | * | |
7 | * http://www.apache.org/licenses/LICENSE-2.0 | |
8 | * | |
9 | * Unless required by applicable law or agreed to in writing, software | |
10 | * distributed under the License is distributed on an "AS IS" BASIS, | |
11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
12 | * See the License for the specific language governing permissions and | |
13 | * limitations under the License. */ | |
14 | ||
15 | #ifndef OFPROTO_DPIF_H | |
16 | #define OFPROTO_DPIF_H 1 | |
17 | ||
18 | #include <stdint.h> | |
19 | ||
003ce655 | 20 | #include "fail-open.h" |
9583bc14 | 21 | #include "hmapx.h" |
e1ec7dd4 | 22 | #include "odp-util.h" |
70742c7f | 23 | #include "ofp-util.h" |
9fbe253e | 24 | #include "ovs-thread.h" |
adcf00ba | 25 | #include "ofproto-provider.h" |
9583bc14 EJ |
26 | #include "timer.h" |
27 | #include "util.h" | |
ec89fc6f | 28 | #include "ovs-thread.h" |
9583bc14 | 29 | |
4ae48dcd SH |
30 | /* Priority for internal rules created to handle recirculation */ |
31 | #define RECIRC_RULE_PRIORITY 20 | |
32 | ||
9583bc14 | 33 | union user_action_cookie; |
70742c7f | 34 | struct dpif_flow_stats; |
f5374617 | 35 | struct ofproto; |
46c88433 | 36 | struct ofproto_dpif; |
0fb7792a | 37 | struct ofproto_packet_in; |
46c88433 | 38 | struct ofport_dpif; |
8449c4d6 | 39 | struct dpif_backer; |
70742c7f | 40 | struct OVS_LOCKABLE rule_dpif; |
f4fb341b | 41 | struct OVS_LOCKABLE group_dpif; |
9583bc14 | 42 | |
0c7812e5 AW |
43 | /* Number of implemented OpenFlow tables. */ |
44 | enum { N_TABLES = 255 }; | |
45 | enum { TBL_INTERNAL = N_TABLES - 1 }; /* Used for internal hidden rules. */ | |
46 | BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255); | |
47 | ||
e1ec7dd4 EJ |
48 | /* Ofproto-dpif -- DPIF based ofproto implementation. |
49 | * | |
50 | * Ofproto-dpif provides an ofproto implementation for those platforms which | |
51 | * implement the netdev and dpif interface defined in netdev.h and dpif.h. The | |
52 | * most important of which is the Linux Kernel Module (dpif-linux), but | |
53 | * alternatives are supported such as a userspace only implementation | |
54 | * (dpif-netdev), and a dummy implementation used for unit testing. | |
55 | * | |
56 | * Ofproto-dpif is divided into three major chunks. | |
57 | * | |
58 | * - ofproto-dpif.c | |
59 | * The main ofproto-dpif module is responsible for implementing the | |
60 | * provider interface, installing and removing datapath flows, maintaining | |
61 | * packet statistics, running protocols (BFD, LACP, STP, etc), and | |
62 | * configuring relevant submodules. | |
63 | * | |
64 | * - ofproto-dpif-upcall.c | |
65 | * Ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel, | |
66 | * processing miss upcalls, and handing more complex ones up to the main | |
67 | * ofproto-dpif module. Miss upcall processing boils down to figuring out | |
68 | * what each packet's actions are, executing them (i.e. asking the kernel to | |
69 | * forward it), and handing it up to ofproto-dpif to decided whether or not | |
70 | * to install a kernel flow. | |
71 | * | |
72 | * - ofproto-dpif-xlate.c | |
cf9cf2e8 YT |
73 | * Ofproto-dpif-xlate is responsible for translating OpenFlow actions into |
74 | * datapath actions. */ | |
e1ec7dd4 | 75 | |
b440dd8c JS |
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; | |
82 | ||
83 | /* Maximum number of MPLS label stack entries that the datapath supports | |
84 | * in a match */ | |
85 | size_t max_mpls_depth; | |
86 | ||
87 | /* True if the datapath supports masked data in OVS_ACTION_ATTR_SET | |
88 | * actions. */ | |
89 | bool masked_set_action; | |
90 | ||
91 | /* True if the datapath supports recirculation. */ | |
92 | bool recirc; | |
93 | ||
94 | /* True if the datapath supports tnl_push and pop actions. */ | |
95 | bool tnl_push_pop; | |
96 | ||
97 | /* True if the datapath supports OVS_FLOW_ATTR_UFID. */ | |
98 | bool ufid; | |
99 | }; | |
100 | ||
8bfd0fda | 101 | size_t ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *); |
adcf00ba | 102 | bool ofproto_dpif_get_enable_recirc(const struct ofproto_dpif *); |
8e1ffd75 | 103 | bool ofproto_dpif_get_enable_ufid(struct dpif_backer *backer); |
8bfd0fda | 104 | |
621b8064 JR |
105 | long long ofproto_dpif_get_tables_version(struct ofproto_dpif *); |
106 | ||
34dd0d78 | 107 | struct rule_dpif *rule_dpif_lookup_from_table(struct ofproto_dpif *, |
621b8064 | 108 | long long version, |
34dd0d78 JR |
109 | struct flow *, |
110 | struct flow_wildcards *, | |
111 | bool take_ref, | |
112 | const struct dpif_flow_stats *, | |
113 | uint8_t *table_id, | |
114 | ofp_port_t in_port, | |
115 | bool may_packet_in, | |
116 | bool honor_table_miss); | |
70742c7f | 117 | |
003ce655 JR |
118 | static inline void rule_dpif_ref(struct rule_dpif *); |
119 | static inline void rule_dpif_unref(struct rule_dpif *); | |
70742c7f | 120 | |
cd1acaab SH |
121 | void rule_dpif_credit_stats(struct rule_dpif *rule , |
122 | const struct dpif_flow_stats *); | |
70742c7f | 123 | |
003ce655 JR |
124 | static inline bool rule_dpif_is_fail_open(const struct rule_dpif *); |
125 | static inline bool rule_dpif_is_table_miss(const struct rule_dpif *); | |
126 | static inline bool rule_dpif_is_internal(const struct rule_dpif *); | |
127 | ||
adcf00ba | 128 | uint8_t rule_dpif_get_table(const struct rule_dpif *); |
70742c7f | 129 | |
56c091ec SH |
130 | bool table_is_internal(uint8_t table_id); |
131 | ||
dc723c44 | 132 | const struct rule_actions *rule_dpif_get_actions(const struct rule_dpif *); |
888ac0d7 | 133 | void rule_set_recirc_id(struct rule *, uint32_t id); |
ad3efdcb | 134 | |
70742c7f | 135 | ovs_be64 rule_dpif_get_flow_cookie(const struct rule_dpif *rule); |
9583bc14 | 136 | |
70742c7f EJ |
137 | void rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout, |
138 | uint16_t hard_timeout); | |
9583bc14 | 139 | |
70742c7f EJ |
140 | void choose_miss_rule(enum ofputil_port_config, |
141 | struct rule_dpif *miss_rule, | |
142 | struct rule_dpif *no_packet_in_rule, | |
1a7c0cd7 | 143 | struct rule_dpif **rule, bool take_ref); |
ec89fc6f | 144 | |
1e684d7d RW |
145 | void group_dpif_credit_stats(struct group_dpif *, |
146 | struct ofputil_bucket *, | |
147 | const struct dpif_flow_stats *); | |
f4fb341b SH |
148 | bool group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id, |
149 | struct group_dpif **group); | |
150 | ||
f4fb341b | 151 | void group_dpif_get_buckets(const struct group_dpif *group, |
ca6ba700 | 152 | const struct ovs_list **buckets); |
f4fb341b | 153 | enum ofp11_group_type group_dpif_get_type(const struct group_dpif *group); |
7565c3e4 | 154 | const char *group_dpif_get_selection_method(const struct group_dpif *group); |
0c4b9393 SH |
155 | uint64_t group_dpif_get_selection_method_param(const struct group_dpif *group); |
156 | const struct field_array *group_dpif_get_fields(const struct group_dpif *group); | |
f4fb341b | 157 | |
46c88433 | 158 | bool ofproto_has_vlan_splinters(const struct ofproto_dpif *); |
4e022ec0 AW |
159 | ofp_port_t vsp_realdev_to_vlandev(const struct ofproto_dpif *, |
160 | ofp_port_t realdev_ofp_port, | |
161 | ovs_be16 vlan_tci); | |
cc377352 | 162 | bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *, |
cf62fa4c | 163 | struct dp_packet *packet); |
9583bc14 | 164 | |
419460f4 AW |
165 | int ofproto_dpif_execute_actions(struct ofproto_dpif *, const struct flow *, |
166 | struct rule_dpif *, const struct ofpact *, | |
cf62fa4c | 167 | size_t ofpacts_len, struct dp_packet *); |
46c88433 | 168 | void ofproto_dpif_send_packet_in(struct ofproto_dpif *, |
0fb7792a | 169 | struct ofproto_packet_in *); |
6b83a3c5 | 170 | bool ofproto_dpif_wants_packet_in_on_miss(struct ofproto_dpif *); |
cf62fa4c | 171 | int ofproto_dpif_send_packet(const struct ofport_dpif *, struct dp_packet *); |
3d9c5e58 | 172 | void ofproto_dpif_flow_mod(struct ofproto_dpif *, struct ofputil_flow_mod *); |
1ebeaaa7 | 173 | struct rule_dpif *ofproto_dpif_refresh_rule(struct rule_dpif *); |
46c88433 | 174 | |
8449c4d6 | 175 | struct ofport_dpif *odp_port_to_ofport(const struct dpif_backer *, odp_port_t); |
e672ff9b JR |
176 | struct ofport_dpif *ofp_port_to_ofport(const struct ofproto_dpif *, |
177 | ofp_port_t); | |
8449c4d6 | 178 | |
adcf00ba | 179 | int ofproto_dpif_add_internal_flow(struct ofproto_dpif *, |
fe99c360 | 180 | const struct match *, int priority, |
290ad78a | 181 | uint16_t idle_timeout, |
adcf00ba AZ |
182 | const struct ofpbuf *ofpacts, |
183 | struct rule **rulep); | |
184 | int ofproto_dpif_delete_internal_flow(struct ofproto_dpif *, struct match *, | |
185 | int priority); | |
003ce655 JR |
186 | \f |
187 | /* struct rule_dpif has struct rule as it's first member. */ | |
188 | #define RULE_CAST(RULE) ((struct rule *)RULE) | |
809c7548 RW |
189 | #define GROUP_CAST(GROUP) ((struct ofgroup *)GROUP) |
190 | ||
191 | static inline struct group_dpif* group_dpif_ref(struct group_dpif *group) | |
192 | { | |
193 | if (group) { | |
194 | ofproto_group_ref(GROUP_CAST(group)); | |
195 | } | |
196 | return group; | |
197 | } | |
198 | ||
199 | static inline void group_dpif_unref(struct group_dpif *group) | |
200 | { | |
201 | if (group) { | |
202 | ofproto_group_unref(GROUP_CAST(group)); | |
203 | } | |
204 | } | |
003ce655 JR |
205 | |
206 | static inline void rule_dpif_ref(struct rule_dpif *rule) | |
207 | { | |
208 | if (rule) { | |
209 | ofproto_rule_ref(RULE_CAST(rule)); | |
210 | } | |
211 | } | |
212 | ||
f5d16e55 JR |
213 | static inline bool rule_dpif_try_ref(struct rule_dpif *rule) |
214 | { | |
215 | if (rule) { | |
216 | return ofproto_rule_try_ref(RULE_CAST(rule)); | |
217 | } | |
218 | return false; | |
219 | } | |
220 | ||
221 | ||
003ce655 JR |
222 | static inline void rule_dpif_unref(struct rule_dpif *rule) |
223 | { | |
224 | if (rule) { | |
225 | ofproto_rule_unref(RULE_CAST(rule)); | |
226 | } | |
227 | } | |
228 | ||
229 | static inline bool rule_dpif_is_fail_open(const struct rule_dpif *rule) | |
230 | { | |
231 | return is_fail_open_rule(RULE_CAST(rule)); | |
232 | } | |
233 | ||
234 | static inline bool rule_dpif_is_table_miss(const struct rule_dpif *rule) | |
235 | { | |
236 | return rule_is_table_miss(RULE_CAST(rule)); | |
237 | } | |
238 | ||
239 | /* Returns true if 'rule' is an internal rule, false otherwise. */ | |
240 | static inline bool rule_dpif_is_internal(const struct rule_dpif *rule) | |
241 | { | |
242 | return RULE_CAST(rule)->table_id == TBL_INTERNAL; | |
243 | } | |
244 | ||
245 | #undef RULE_CAST | |
246 | ||
a36de779 | 247 | bool ovs_native_tunneling_is_on(struct ofproto_dpif *ofproto); |
9583bc14 | 248 | #endif /* ofproto-dpif.h */ |