2 * Copyright (c) 2014, 2015 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef OFPROTO_DPIF_RID_H
18 #define OFPROTO_DPIF_RID_H
25 #include "ofp-actions.h"
26 #include "ofproto-dpif-mirror.h"
27 #include "ovs-thread.h"
36 * Recirculation is a technique to allow a frame to re-enter the datapath
37 * packet processing path to achieve more flexible packet processing, such as
38 * modifying header fields after MPLS POP action and selecting a slave port for
41 * Data path and user space interface
42 * -----------------------------------
44 * Recirculation uses two uint32_t fields, recirc_id and dp_hash, and a RECIRC
45 * action. recirc_id is used to select the next packet processing steps among
46 * multiple instances of recirculation. When a packet initially enters the
47 * datapath it is assigned with recirc_id 0, which indicates no recirculation.
48 * Recirc_ids are managed by the user space, opaque to the datapath.
50 * On the other hand, dp_hash can only be computed by the datapath, opaque to
51 * the user space, as the datapath is free to choose the hashing algorithm
52 * without informing user space about it. The dp_hash value should be
53 * wildcarded for newly received packets. HASH action specifies whether the
54 * hash is computed, and if computed, how many fields are to be included in the
55 * hash computation. The computed hash value is stored into the dp_hash field
56 * prior to recirculation.
58 * The RECIRC action sets the recirc_id field and then reprocesses the packet
59 * as if it was received again on the same input port. RECIRC action works
60 * like a function call; actions listed after the RECIRC action will be
61 * executed after recirculation. RECIRC action can be nested, but datapath
62 * implementation limits the number of nested recirculations to prevent
63 * unreasonable nesting depth or infinite loop.
65 * User space recirculation context
66 * ---------------------------------
68 * Recirculation is usually hidden from the OpenFlow controllers. Action
69 * translation code deduces when recirculation is necessary and issues a
70 * datapath recirculation action. All OpenFlow actions to be performed after
71 * recirculation are derived from the OpenFlow pipeline and are stored with the
72 * recirculation ID. When the OpenFlow tables are changed in a way affecting
73 * the recirculation flows, new recirculation ID with new metadata and actions
74 * is allocated and the old one is timed out.
76 * Recirculation ID pool
77 * ----------------------
79 * Recirculation ID needs to be unique for all datapaths. Recirculation ID
80 * pool keeps track of recirculation ids and stores OpenFlow pipeline
81 * translation context so that flow processing may continue after
84 * A Recirculation ID can be any uint32_t value, except for that the value 0 is
85 * reserved for 'no recirculation' case.
90 * All APIs are thread safe.
93 /* Metadata for restoring pipeline context after recirculation. Helpers
94 * are inlined below to keep them together with the definition for easier
96 BUILD_ASSERT_DECL(FLOW_WC_SEQ == 34);
98 struct recirc_metadata {
99 /* Metadata in struct flow. */
100 const struct flow_tnl *tunnel; /* Encapsulating tunnel parameters. */
101 ovs_be64 metadata; /* OpenFlow Metadata. */
102 uint64_t regs[FLOW_N_XREGS]; /* Registers. */
103 ofp_port_t in_port; /* Incoming port. */
104 ofp_port_t actset_output; /* Output port in action set. */
108 recirc_metadata_from_flow(struct recirc_metadata *md,
109 const struct flow *flow)
111 memset(md, 0, sizeof *md);
112 md->tunnel = &flow->tunnel;
113 md->metadata = flow->metadata;
114 memcpy(md->regs, flow->regs, sizeof md->regs);
115 md->in_port = flow->in_port.ofp_port;
116 md->actset_output = flow->actset_output;
120 recirc_metadata_to_flow(const struct recirc_metadata *md,
123 if (md->tunnel && md->tunnel->ip_dst) {
124 flow->tunnel = *md->tunnel;
126 memset(&flow->tunnel, 0, sizeof flow->tunnel);
128 flow->metadata = md->metadata;
129 memcpy(flow->regs, md->regs, sizeof flow->regs);
130 flow->in_port.ofp_port = md->in_port;
131 flow->actset_output = md->actset_output;
134 /* State that flow translation can save, to restore when recirculation
136 struct recirc_state {
137 /* Initial table for post-recirculation processing. */
140 /* Pipeline context for post-recirculation processing. */
141 struct ofproto_dpif *ofproto; /* Post-recirculation bridge. */
142 struct recirc_metadata metadata; /* Flow metadata. */
143 struct ofpbuf *stack; /* Stack if any. */
144 mirror_mask_t mirrors; /* Mirrors already output. */
145 bool conntracked; /* Conntrack occurred prior to recirc. */
147 /* Actions to be translated on recirculation. */
148 uint32_t action_set_len; /* How much of 'ofpacts' consists of an
150 uint32_t ofpacts_len; /* Size of 'ofpacts', in bytes. */
151 struct ofpact *ofpacts; /* Sequence of "struct ofpacts". */
154 /* This maps a recirculation ID to saved state that flow translation can
155 * restore when recirculation occurs. */
156 struct recirc_id_node {
158 struct ovs_list exp_node OVS_GUARDED;
159 struct cmap_node id_node;
160 struct cmap_node metadata_node;
163 struct ovs_refcount refcount;
167 * This state should not be modified after inserting a node in the pool,
168 * hence the 'const' to emphasize that. */
169 const struct recirc_state state;
171 /* Storage for tunnel metadata. */
172 struct flow_tnl state_metadata_tunnel;
175 void recirc_init(void);
177 /* This is only used for bonds and will go away when bonds implementation is
178 * updated to use this mechanism instead of internal rules. */
179 uint32_t recirc_alloc_id(struct ofproto_dpif *);
181 uint32_t recirc_alloc_id_ctx(const struct recirc_state *);
182 uint32_t recirc_find_id(const struct recirc_state *);
183 void recirc_free_id(uint32_t recirc_id);
184 void recirc_free_ofproto(struct ofproto_dpif *, const char *ofproto_name);
186 const struct recirc_id_node *recirc_id_node_find(uint32_t recirc_id);
188 static inline bool recirc_id_node_try_ref_rcu(const struct recirc_id_node *n_)
190 struct recirc_id_node *node = CONST_CAST(struct recirc_id_node *, n_);
192 return node ? ovs_refcount_try_ref_rcu(&node->refcount) : false;
195 void recirc_id_node_unref(const struct recirc_id_node *);
197 void recirc_run(void);
199 /* Recirculation IDs on which references are held. */
203 uint32_t recirc[2]; /* When n_recircs == 1 or 2 */
204 uint32_t *recircs; /* When 'n_recircs' > 2 */
208 #define RECIRC_REFS_EMPTY_INITIALIZER ((struct recirc_refs) \
210 /* Helpers to abstract the recirculation union away. */
212 recirc_refs_init(struct recirc_refs *rr)
214 *rr = RECIRC_REFS_EMPTY_INITIALIZER;
218 recirc_refs_add(struct recirc_refs *rr, uint32_t id)
220 if (OVS_LIKELY(rr->n_recircs < ARRAY_SIZE(rr->recirc))) {
221 rr->recirc[rr->n_recircs++] = id;
223 if (rr->n_recircs == ARRAY_SIZE(rr->recirc)) {
224 uint32_t *recircs = xmalloc(sizeof rr->recirc + sizeof id);
226 memcpy(recircs, rr->recirc, sizeof rr->recirc);
227 rr->recircs = recircs;
229 rr->recircs = xrealloc(rr->recircs,
230 (rr->n_recircs + 1) * sizeof id);
232 rr->recircs[rr->n_recircs++] = id;
237 recirc_refs_swap(struct recirc_refs *a, struct recirc_refs *b)
239 struct recirc_refs tmp;
247 recirc_refs_unref(struct recirc_refs *rr)
249 if (OVS_LIKELY(rr->n_recircs <= ARRAY_SIZE(rr->recirc))) {
250 for (int i = 0; i < rr->n_recircs; i++) {
251 recirc_free_id(rr->recirc[i]);
254 for (int i = 0; i < rr->n_recircs; i++) {
255 recirc_free_id(rr->recircs[i]);