FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
replication.c
Go to the documentation of this file.
1 /*
2  * replication.c : packet replication
3  *
4  * Copyright (c) 2013 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vlib/vlib.h>
19 #include <vnet/vnet.h>
20 #include <vppinfra/error.h>
21 #include <vnet/ip/ip4_packet.h>
22 #include <vnet/replication.h>
23 
24 
26 
27 
30  vlib_buffer_t * b0, u32 recycle_node_index, u32 l2_packet)
31 {
34  uword cpu_number = vm->cpu_index;
35  ip4_header_t *ip;
36  u32 ctx_id;
37 
38  /* Allocate a context, reserve context 0 */
39  if (PREDICT_FALSE (rm->contexts[cpu_number] == 0))
40  pool_get_aligned (rm->contexts[cpu_number], ctx, CLIB_CACHE_LINE_BYTES);
41 
42  pool_get_aligned (rm->contexts[cpu_number], ctx, CLIB_CACHE_LINE_BYTES);
43  ctx_id = ctx - rm->contexts[cpu_number];
44 
45  /* Save state from vlib buffer */
47  ctx->current_data = b0->current_data;
48 
49  /* Set up vlib buffer hooks */
50  b0->recycle_count = ctx_id;
53 
54  /* Save feature state */
55  ctx->recycle_node_index = recycle_node_index;
56 
57  /* Save vnet state */
59  sizeof (vnet_buffer_opaque_t));
60 
61  /* Save packet contents */
62  ctx->l2_packet = l2_packet;
64  if (l2_packet)
65  {
66  /* Save ethernet header */
67  ctx->l2_header[0] = ((u64 *) ip)[0];
68  ctx->l2_header[1] = ((u64 *) ip)[1];
69  ctx->l2_header[2] = ((u64 *) ip)[2];
70  /* set ip to the true ip header */
71  ip = (ip4_header_t *) (((u8 *) ip) + vnet_buffer (b0)->l2.l2_len);
72  }
73 
74  /*
75  * Copy L3 fields.
76  * We need to save TOS for ip4 and ip6 packets.
77  * Fortunately the TOS field is
78  * in the first two bytes of both the ip4 and ip6 headers.
79  */
80  ctx->ip_tos = *((u16 *) (ip));
81 
82  /*
83  * Save the ip4 checksum as well. We just blindly save the corresponding two
84  * bytes even for ip6 packets.
85  */
86  ctx->ip4_checksum = ip->checksum;
87 
88  return ctx;
89 }
90 
91 
94 {
97  uword cpu_number = vm->cpu_index;
98  ip4_header_t *ip;
99 
100  /* Get access to the replication context */
101  ctx = pool_elt_at_index (rm->contexts[cpu_number], b0->recycle_count);
102 
103  /* Restore vnet buffer state */
104  clib_memcpy (vnet_buffer (b0), ctx->vnet_buffer,
105  sizeof (vnet_buffer_opaque_t));
106 
107  /* Restore the packet start (current_data) and length */
109 
110  /* Restore packet contents */
112  if (ctx->l2_packet)
113  {
114  /* Restore ethernet header */
115  ((u64 *) ip)[0] = ctx->l2_header[0];
116  ((u64 *) ip)[1] = ctx->l2_header[1];
117  ((u64 *) ip)[2] = ctx->l2_header[2];
118  /* set ip to the true ip header */
119  ip = (ip4_header_t *) (((u8 *) ip) + vnet_buffer (b0)->l2.l2_len);
120  }
121 
122  // Restore L3 fields
123  *((u16 *) (ip)) = ctx->ip_tos;
124  ip->checksum = ctx->ip4_checksum;
125 
126  if (is_last)
127  {
128  /*
129  * This is the last replication in the list.
130  * Restore original buffer free functionality.
131  */
133  b0->flags &= ~VLIB_BUFFER_RECYCLE;
134 
135  /* Free context back to its pool */
136  pool_put (rm->contexts[cpu_number], ctx);
137  }
138 
139  return ctx;
140 }
141 
142 
143 
144 /*
145  * fish pkts back from the recycle queue/freelist
146  * un-flatten the context chains
147  */
148 static void
150 {
151  vlib_frame_t *f = 0;
152  u32 n_left_from;
153  u32 n_left_to_next = 0;
154  u32 n_this_frame = 0;
155  u32 *from;
156  u32 *to_next = 0;
157  u32 bi0, pi0;
158  vlib_buffer_t *b0;
159  int i;
162  u32 feature_node_index = 0;
163  uword cpu_number = vm->cpu_index;
164 
165  /*
166  * All buffers in the list are destined to the same recycle node.
167  * Pull the recycle node index from the first buffer.
168  * Note: this could be sped up if the node index were stuffed into
169  * the freelist itself.
170  */
171  if (vec_len (fl->aligned_buffers) > 0)
172  {
173  bi0 = fl->aligned_buffers[0];
174  b0 = vlib_get_buffer (vm, bi0);
175  ctx = pool_elt_at_index (rm->contexts[cpu_number], b0->recycle_count);
176  feature_node_index = ctx->recycle_node_index;
177  }
178  else if (vec_len (fl->unaligned_buffers) > 0)
179  {
180  bi0 = fl->unaligned_buffers[0];
181  b0 = vlib_get_buffer (vm, bi0);
182  ctx = pool_elt_at_index (rm->contexts[cpu_number], b0->recycle_count);
183  feature_node_index = ctx->recycle_node_index;
184  }
185 
186  /* aligned, unaligned buffers */
187  for (i = 0; i < 2; i++)
188  {
189  if (i == 0)
190  {
191  from = fl->aligned_buffers;
192  n_left_from = vec_len (from);
193  }
194  else
195  {
196  from = fl->unaligned_buffers;
197  n_left_from = vec_len (from);
198  }
199 
200  while (n_left_from > 0)
201  {
202  if (PREDICT_FALSE (n_left_to_next == 0))
203  {
204  if (f)
205  {
206  f->n_vectors = n_this_frame;
207  vlib_put_frame_to_node (vm, feature_node_index, f);
208  }
209 
210  f = vlib_get_frame_to_node (vm, feature_node_index);
211  to_next = vlib_frame_vector_args (f);
212  n_left_to_next = VLIB_FRAME_SIZE;
213  n_this_frame = 0;
214  }
215 
216  bi0 = from[0];
217  if (PREDICT_TRUE (n_left_from > 1))
218  {
219  pi0 = from[1];
220  vlib_prefetch_buffer_with_index (vm, pi0, LOAD);
221  }
222 
223  b0 = vlib_get_buffer (vm, bi0);
224 
225  /* Mark that this buffer was just recycled */
227 
228 #if (CLIB_DEBUG > 0)
229 #if DPDK == 0
230  vlib_buffer_set_known_state (vm, bi0, VLIB_BUFFER_KNOWN_ALLOCATED);
231 #endif
232 #endif
233 
234  /* If buffer is traced, mark frame as traced */
236  f->flags |= VLIB_FRAME_TRACE;
237 
238  to_next[0] = bi0;
239 
240  from++;
241  to_next++;
242  n_this_frame++;
243  n_left_to_next--;
244  n_left_from--;
245  }
246  }
247 
250 
251  if (f)
252  {
253  ASSERT (n_this_frame);
254  f->n_vectors = n_this_frame;
255  vlib_put_frame_to_node (vm, feature_node_index, f);
256  }
257 }
258 
259 clib_error_t *
261 {
265  __attribute__ ((unused)) replication_context_t *ctx;
267 
268  rm->vlib_main = vm;
269  rm->vnet_main = vnet_get_main ();
270  rm->recycle_list_index =
271  vlib_buffer_create_free_list (vm, 1024 /* fictional */ ,
272  "replication-recycle");
273 
275 
277 
278  /* Verify the replication context is the expected size */
279  ASSERT (sizeof (replication_context_t) == 128); /* 2 cache lines */
280 
281  vec_validate (rm->contexts, tm->n_vlib_mains - 1);
282  return 0;
283 }
284 
286 
287 /*
288  * fd.io coding-style-patch-verification: ON
289  *
290  * Local Variables:
291  * eval: (c-set-style "gnu")
292  * End:
293  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
u32 free_list_index
Buffer free list that this buffer was allocated from and will be freed to.
Definition: buffer.h:108
#define PREDICT_TRUE(x)
Definition: clib.h:98
vlib_buffer_main_t * buffer_main
Definition: main.h:104
u32 recycle_count
Used by L2 path recycle code.
Definition: buffer.h:145
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
replication_main_t replication_main
Definition: replication.c:25
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:78
#define vlib_prefetch_buffer_with_index(vm, bi, type)
Prefetch buffer metadata by buffer index The first 64 bytes of buffer contains most header informatio...
Definition: buffer_funcs.h:170
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
u32 cpu_index
Definition: main.h:159
unsigned long u64
Definition: types.h:89
#define VLIB_FRAME_TRACE
Definition: node.h:382
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:214
#define PREDICT_FALSE(x)
Definition: clib.h:97
static void replication_recycle_callback(vlib_main_t *vm, vlib_buffer_free_list_t *fl)
Definition: replication.c:149
#define VLIB_FRAME_SIZE
Definition: node.h:328
replication_context_t * replication_prep(vlib_main_t *vm, vlib_buffer_t *b0, u32 recycle_node_index, u32 l2_packet)
Definition: replication.c:29
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:196
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:169
u16 n_vectors
Definition: node.h:344
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
#define clib_memcpy(a, b, c)
Definition: string.h:69
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:207
#define VLIB_BUFFER_RECYCLE
Definition: buffer.h:101
void(* buffers_added_to_freelist_function)(struct vlib_main_t *vm, struct vlib_buffer_free_list_t *fl)
Definition: buffer.h:294
vlib_main_t * vlib_main
Definition: replication.h:65
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
#define vnet_buffer(b)
Definition: buffer.h:361
u16 flags
Definition: node.h:335
vnet_main_t * vnet_main
Definition: replication.h:66
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:95
clib_error_t * replication_init(vlib_main_t *vm)
Definition: replication.c:260
u64 uword
Definition: types.h:112
unsigned short u16
Definition: types.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
vlib_buffer_free_list_t * buffer_free_list_pool
Definition: buffer.h:309
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:253
replication_context_t * replication_recycle(vlib_main_t *vm, vlib_buffer_t *b0, u32 is_last)
Definition: replication.c:93
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
Definition: main.c:187
#define VLIB_BUFFER_IS_RECYCLED
Definition: buffer.h:98
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
u32 vlib_buffer_create_free_list(vlib_main_t *vm, u32 n_data_bytes, char *fmt,...)
replication_context_t ** contexts
Definition: replication.h:63