]>
Commit | Line | Data |
---|---|---|
6a4d3ab5 | 1 | /* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 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 | ||
20 | #include "hmapx.h" | |
e1ec7dd4 | 21 | #include "odp-util.h" |
70742c7f | 22 | #include "ofp-util.h" |
9fbe253e | 23 | #include "ovs-thread.h" |
9583bc14 EJ |
24 | #include "timer.h" |
25 | #include "util.h" | |
ec89fc6f | 26 | #include "ovs-thread.h" |
9583bc14 EJ |
27 | |
28 | union user_action_cookie; | |
70742c7f | 29 | struct dpif_flow_stats; |
f5374617 | 30 | struct ofproto; |
46c88433 | 31 | struct ofproto_dpif; |
0fb7792a | 32 | struct ofproto_packet_in; |
46c88433 | 33 | struct ofport_dpif; |
8449c4d6 | 34 | struct dpif_backer; |
70742c7f | 35 | struct OVS_LOCKABLE rule_dpif; |
f4fb341b | 36 | struct OVS_LOCKABLE group_dpif; |
9583bc14 | 37 | |
6d328fa2 SH |
38 | enum rule_dpif_lookup_verdict { |
39 | RULE_DPIF_LOOKUP_VERDICT_MATCH, /* A match occurred. */ | |
40 | RULE_DPIF_LOOKUP_VERDICT_CONTROLLER, /* A miss occurred and the packet | |
41 | * should be passed to | |
42 | * the controller. */ | |
43 | RULE_DPIF_LOOKUP_VERDICT_DROP, /* A miss occurred and the packet | |
44 | * should be dropped. */ | |
6b83a3c5 SH |
45 | RULE_DPIF_LOOKUP_VERDICT_DEFAULT, /* A miss occurred and the packet |
46 | * should handled by the default | |
47 | * miss behaviour. | |
48 | * For pre-OF1.3 it should be | |
49 | * forwarded to the controller. | |
50 | * For OF1.3+ it should be | |
51 | * dropped. */ | |
6d328fa2 SH |
52 | }; |
53 | ||
6a4d3ab5 BP |
54 | /* For lock annotation below only. */ |
55 | extern struct ovs_rwlock xlate_rwlock; | |
56 | ||
e1ec7dd4 EJ |
57 | /* Ofproto-dpif -- DPIF based ofproto implementation. |
58 | * | |
59 | * Ofproto-dpif provides an ofproto implementation for those platforms which | |
60 | * implement the netdev and dpif interface defined in netdev.h and dpif.h. The | |
61 | * most important of which is the Linux Kernel Module (dpif-linux), but | |
62 | * alternatives are supported such as a userspace only implementation | |
63 | * (dpif-netdev), and a dummy implementation used for unit testing. | |
64 | * | |
65 | * Ofproto-dpif is divided into three major chunks. | |
66 | * | |
67 | * - ofproto-dpif.c | |
68 | * The main ofproto-dpif module is responsible for implementing the | |
69 | * provider interface, installing and removing datapath flows, maintaining | |
70 | * packet statistics, running protocols (BFD, LACP, STP, etc), and | |
71 | * configuring relevant submodules. | |
72 | * | |
73 | * - ofproto-dpif-upcall.c | |
74 | * Ofproto-dpif-upcall is responsible for retrieving upcalls from the kernel, | |
75 | * processing miss upcalls, and handing more complex ones up to the main | |
76 | * ofproto-dpif module. Miss upcall processing boils down to figuring out | |
77 | * what each packet's actions are, executing them (i.e. asking the kernel to | |
78 | * forward it), and handing it up to ofproto-dpif to decided whether or not | |
79 | * to install a kernel flow. | |
80 | * | |
81 | * - ofproto-dpif-xlate.c | |
82 | * Ofproto-dpif-xlate is responsible for translating translating OpenFlow | |
83 | * actions into datapath actions. */ | |
84 | ||
8bfd0fda BP |
85 | size_t ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *); |
86 | ||
6d328fa2 SH |
87 | uint8_t rule_dpif_lookup(struct ofproto_dpif *, const struct flow *, |
88 | struct flow_wildcards *, struct rule_dpif **rule); | |
ad3efdcb | 89 | |
6d328fa2 SH |
90 | enum rule_dpif_lookup_verdict rule_dpif_lookup_from_table(struct ofproto_dpif *, |
91 | const struct flow *, | |
92 | struct flow_wildcards *, | |
93 | bool force_controller_on_miss, | |
94 | uint8_t *table_id, | |
95 | struct rule_dpif **rule); | |
70742c7f | 96 | |
a2143702 BP |
97 | void rule_dpif_ref(struct rule_dpif *); |
98 | void rule_dpif_unref(struct rule_dpif *); | |
70742c7f | 99 | |
cd1acaab SH |
100 | void rule_dpif_credit_stats(struct rule_dpif *rule , |
101 | const struct dpif_flow_stats *); | |
70742c7f | 102 | |
ee1afdd5 | 103 | bool rule_dpif_is_fail_open(const struct rule_dpif *); |
cfa955b0 | 104 | bool rule_dpif_is_table_miss(const struct rule_dpif *); |
32260212 | 105 | bool rule_dpif_is_internal(const struct rule_dpif *); |
70742c7f | 106 | |
6f00e29b | 107 | struct rule_actions *rule_dpif_get_actions(const struct rule_dpif *); |
ad3efdcb | 108 | |
70742c7f | 109 | ovs_be64 rule_dpif_get_flow_cookie(const struct rule_dpif *rule); |
9583bc14 | 110 | |
70742c7f EJ |
111 | void rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout, |
112 | uint16_t hard_timeout); | |
9583bc14 | 113 | |
70742c7f EJ |
114 | void choose_miss_rule(enum ofputil_port_config, |
115 | struct rule_dpif *miss_rule, | |
116 | struct rule_dpif *no_packet_in_rule, | |
a2143702 | 117 | struct rule_dpif **rule); |
ec89fc6f | 118 | |
f4fb341b SH |
119 | bool group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id, |
120 | struct group_dpif **group); | |
121 | ||
122 | void group_dpif_release(struct group_dpif *group); | |
123 | ||
124 | void group_dpif_get_buckets(const struct group_dpif *group, | |
125 | const struct list **buckets); | |
126 | enum ofp11_group_type group_dpif_get_type(const struct group_dpif *group); | |
127 | ||
46c88433 | 128 | bool ofproto_has_vlan_splinters(const struct ofproto_dpif *); |
4e022ec0 AW |
129 | ofp_port_t vsp_realdev_to_vlandev(const struct ofproto_dpif *, |
130 | ofp_port_t realdev_ofp_port, | |
131 | ovs_be16 vlan_tci); | |
8449c4d6 | 132 | bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *); |
9583bc14 | 133 | |
419460f4 AW |
134 | int ofproto_dpif_execute_actions(struct ofproto_dpif *, const struct flow *, |
135 | struct rule_dpif *, const struct ofpact *, | |
6a4d3ab5 BP |
136 | size_t ofpacts_len, struct ofpbuf *) |
137 | OVS_EXCLUDED(xlate_rwlock); | |
46c88433 | 138 | void ofproto_dpif_send_packet_in(struct ofproto_dpif *, |
0fb7792a | 139 | struct ofproto_packet_in *); |
6b83a3c5 | 140 | bool ofproto_dpif_wants_packet_in_on_miss(struct ofproto_dpif *); |
91d6cd12 | 141 | int ofproto_dpif_send_packet(const struct ofport_dpif *, struct ofpbuf *); |
3d9c5e58 | 142 | void ofproto_dpif_flow_mod(struct ofproto_dpif *, struct ofputil_flow_mod *); |
46c88433 | 143 | |
8449c4d6 EJ |
144 | struct ofport_dpif *odp_port_to_ofport(const struct dpif_backer *, odp_port_t); |
145 | ||
572f732a AZ |
146 | /* |
147 | * Recirculation | |
148 | * ============= | |
149 | * | |
9b516652 YT |
150 | * Recirculation is a technique to allow a frame to re-enter the packet |
151 | * processing path for one or multiple times to achieve more flexible packet | |
152 | * processing in the data path. MPLS handling and selecting bond slave port | |
153 | * of a bond ports. | |
572f732a AZ |
154 | * |
155 | * Data path and user space interface | |
156 | * ----------------------------------- | |
157 | * | |
9b516652 YT |
158 | * Two new fields, recirc_id and dp_hash, are added to the current flow data |
159 | * structure. They are both of type uint32_t. In addition, a new action, | |
160 | * RECIRC, are added. | |
572f732a | 161 | * |
9b516652 YT |
162 | * The value recirc_id is used to distinguish a packet from multiple |
163 | * iterations of recirculation. A packet initially received is considered of | |
164 | * having recirc_id of 0. Recirc_id is managed by the user space, opaque to | |
165 | * the data path. | |
572f732a AZ |
166 | * |
167 | * On the other hand, dp_hash can only be computed by the data path, opaque to | |
9b516652 YT |
168 | * the user space. In fact, user space may not able to recompute the hash |
169 | * value. The dp_hash value should be wildcarded when for a newly received | |
170 | * packet. RECIRC action specifies whether the hash is computed. If computed, | |
171 | * how many fields to be included in the hash computation. The computed hash | |
172 | * value is stored into the dp_hash field prior to recirculation. | |
173 | * | |
174 | * The RECIRC action computes and set the dp_hash field, set the recirc_id | |
175 | * field and then reprocess the packet as if it was received on the same input | |
176 | * port. RECIRC action works like a function call; actions listed behind the | |
177 | * RECIRC action will be executed after its execution. RECIRC action can be | |
178 | * nested, data path implementation limits the number of recirculation executed | |
572f732a AZ |
179 | * to prevent unreasonable nesting depth or infinite loop. |
180 | * | |
181 | * Both flow fields and the RECIRC action are exposed as open flow fields via | |
182 | * Nicira extensions. | |
183 | * | |
184 | * Post recirculation flow | |
185 | * ------------------------ | |
186 | * | |
187 | * At the open flow level, post recirculation rules are always hidden from the | |
9b516652 YT |
188 | * controller. They are installed in table 254 which is set up as a hidden |
189 | * table during boot time. Those rules are managed by the local user space | |
190 | * program only. | |
572f732a | 191 | * |
9b516652 YT |
192 | * To speed up the classifier look up process, recirc_id is always reflected |
193 | * into the metadata field, since recirc_id is required to be exactly matched. | |
572f732a AZ |
194 | * |
195 | * Classifier look up always starts with table 254. A post recirculation flow | |
196 | * lookup should find its hidden rule within this table. On the other hand, A | |
197 | * newly received packet should miss all post recirculation rules because its | |
198 | * recirc_id is zero, then hit a pre-installed lower priority rule to redirect | |
199 | * classifier to look up starting from table 0: | |
200 | * | |
201 | * * , actions=resubmit(,0) | |
202 | * | |
203 | * Post recirculation data path flows are managed like other data path flows. | |
204 | * They are created on demand. Miss handling, stats collection and revalidation | |
205 | * work the same way as regular flows. | |
206 | */ | |
207 | ||
f5374617 AZ |
208 | uint32_t ofproto_dpif_alloc_recirc_id(struct ofproto_dpif *ofproto); |
209 | void ofproto_dpif_free_recirc_id(struct ofproto_dpif *ofproto, uint32_t recirc_id); | |
9583bc14 | 210 | #endif /* ofproto-dpif.h */ |