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 == 33);
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. */
146 /* Actions to be translated on recirculation. */
147 uint32_t action_set_len; /* How much of 'ofpacts' consists of an
149 uint32_t ofpacts_len; /* Size of 'ofpacts', in bytes. */
150 struct ofpact *ofpacts; /* Sequence of "struct ofpacts". */
153 /* This maps a recirculation ID to saved state that flow translation can
154 * restore when recirculation occurs. */
155 struct recirc_id_node {
157 struct ovs_list exp_node OVS_GUARDED;
158 struct cmap_node id_node;
159 struct cmap_node metadata_node;
162 struct ovs_refcount refcount;
166 * This state should not be modified after inserting a node in the pool,
167 * hence the 'const' to emphasize that. */
168 const struct recirc_state state;
170 /* Storage for tunnel metadata. */
171 struct flow_tnl state_metadata_tunnel;
174 void recirc_init(void);
176 /* This is only used for bonds and will go away when bonds implementation is
177 * updated to use this mechanism instead of internal rules. */
178 uint32_t recirc_alloc_id(struct ofproto_dpif *);
180 uint32_t recirc_alloc_id_ctx(const struct recirc_state *);
181 uint32_t recirc_find_id(const struct recirc_state *);
182 void recirc_free_id(uint32_t recirc_id);
183 void recirc_free_ofproto(struct ofproto_dpif *, const char *ofproto_name);
185 const struct recirc_id_node *recirc_id_node_find(uint32_t recirc_id);
187 static inline bool recirc_id_node_try_ref_rcu(const struct recirc_id_node *n_)
189 struct recirc_id_node *node = CONST_CAST(struct recirc_id_node *, n_);
191 return node ? ovs_refcount_try_ref_rcu(&node->refcount) : false;
194 void recirc_id_node_unref(const struct recirc_id_node *);
196 void recirc_run(void);