FD.io VPP  v17.07.01-10-g3be13f0
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 thread_index = vm->thread_index;
35  ip4_header_t *ip;
36  u32 ctx_id;
37 
38  /* Allocate a context, reserve context 0 */
39  if (PREDICT_FALSE (rm->contexts[thread_index] == 0))
40  pool_get_aligned (rm->contexts[thread_index], ctx, CLIB_CACHE_LINE_BYTES);
41 
42  pool_get_aligned (rm->contexts[thread_index], ctx, CLIB_CACHE_LINE_BYTES);
43  ctx_id = ctx - rm->contexts[thread_index];
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 thread_index = vm->thread_index;
98  ip4_header_t *ip;
99 
100  /* Get access to the replication context */
101  ctx = pool_elt_at_index (rm->contexts[thread_index], 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[thread_index], 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 thread_index = vm->thread_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->buffers) > 0)
172  {
173  bi0 = fl->buffers[0];
174  b0 = vlib_get_buffer (vm, bi0);
175  ctx = pool_elt_at_index (rm->contexts[thread_index], b0->recycle_count);
176  feature_node_index = ctx->recycle_node_index;
177  }
178 
179  /* buffers */
180  for (i = 0; i < 2; i++)
181  {
182  if (i == 0)
183  {
184  from = fl->buffers;
185  n_left_from = vec_len (from);
186  }
187 
188  while (n_left_from > 0)
189  {
190  if (PREDICT_FALSE (n_left_to_next == 0))
191  {
192  if (f)
193  {
194  f->n_vectors = n_this_frame;
195  vlib_put_frame_to_node (vm, feature_node_index, f);
196  }
197 
198  f = vlib_get_frame_to_node (vm, feature_node_index);
199  to_next = vlib_frame_vector_args (f);
200  n_left_to_next = VLIB_FRAME_SIZE;
201  n_this_frame = 0;
202  }
203 
204  bi0 = from[0];
205  if (PREDICT_TRUE (n_left_from > 1))
206  {
207  pi0 = from[1];
208  vlib_prefetch_buffer_with_index (vm, pi0, LOAD);
209  }
210 
211  b0 = vlib_get_buffer (vm, bi0);
212 
213  /* Mark that this buffer was just recycled */
215 
216 #if (CLIB_DEBUG > 0)
217  if (vm->buffer_main->extern_buffer_mgmt == 0)
220 #endif
221 
222  /* If buffer is traced, mark frame as traced */
224  f->flags |= VLIB_FRAME_TRACE;
225 
226  to_next[0] = bi0;
227 
228  from++;
229  to_next++;
230  n_this_frame++;
231  n_left_to_next--;
232  n_left_from--;
233  }
234  }
235 
237 
238  if (f)
239  {
240  ASSERT (n_this_frame);
241  f->n_vectors = n_this_frame;
242  vlib_put_frame_to_node (vm, feature_node_index, f);
243  }
244 }
245 
246 clib_error_t *
248 {
252  __attribute__ ((unused)) replication_context_t *ctx;
254 
255  rm->vlib_main = vm;
256  rm->vnet_main = vnet_get_main ();
257  rm->recycle_list_index =
258  vlib_buffer_create_free_list (vm, 1024 /* fictional */ ,
259  "replication-recycle");
260 
262 
264 
265  /* Verify the replication context is the expected size */
266  ASSERT (sizeof (replication_context_t) == 128); /* 2 cache lines */
267 
268  vec_validate (rm->contexts, tm->n_vlib_mains - 1);
269  return 0;
270 }
271 
273 
274 /*
275  * fd.io coding-style-patch-verification: ON
276  *
277  * Local Variables:
278  * eval: (c-set-style "gnu")
279  * End:
280  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
Definition: main.c:187
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define VLIB_BUFFER_RECYCLE
Definition: buffer.h:91
static void vlib_buffer_set_known_state(vlib_main_t *vm, u32 buffer_index, vlib_buffer_known_state_t state)
Definition: buffer_funcs.h:219
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
u32 free_list_index
Buffer free list that this buffer was allocated from and will be freed to.
Definition: buffer.h:99
#define PREDICT_TRUE(x)
Definition: clib.h:98
u32 thread_index
Definition: main.h:159
vlib_buffer_main_t * buffer_main
Definition: main.h:104
u32 recycle_count
Used by L2 path recycle code.
Definition: buffer.h:139
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
replication_main_t replication_main
Definition: replication.c:25
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:67
#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
unsigned long u64
Definition: types.h:89
#define VLIB_FRAME_TRACE
Definition: node.h:383
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:397
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:188
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:241
#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:329
replication_context_t * replication_prep(vlib_main_t *vm, vlib_buffer_t *b0, u32 recycle_node_index, u32 l2_packet)
Definition: replication.c:29
#define VLIB_BUFFER_IS_RECYCLED
Definition: buffer.h:88
#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:345
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:85
#define clib_memcpy(a, b, c)
Definition: string.h:69
void(* buffers_added_to_freelist_function)(struct vlib_main_t *vm, struct vlib_buffer_free_list_t *fl)
Definition: buffer.h:365
vlib_main_t * vlib_main
Definition: replication.h:65
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
u16 flags
Definition: node.h:336
vnet_main_t * vnet_main
Definition: replication.h:66
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:201
clib_error_t * replication_init(vlib_main_t *vm)
Definition: replication.c:247
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:401
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:269
int extern_buffer_mgmt
Definition: buffer.h:420
replication_context_t * replication_recycle(vlib_main_t *vm, vlib_buffer_t *b0, u32 is_last)
Definition: replication.c:93
#define vnet_buffer(b)
Definition: buffer.h:304
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:196
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:74
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