src/vnet/replication.c

   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
  25 replication_main_t replication_main;
  26
  27
  28 replication_context_t *
  29 replication_prep (vlib_main_t * vm,
  30                   vlib_buffer_t * b0, u32 recycle_node_index, u32 l2_packet)
  31 {
  32   replication_main_t *rm = &replication_main;
  33   replication_context_t *ctx;
  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 */
  46   ctx->saved_free_list_index = b0->free_list_index;
  47   ctx->current_data = b0->current_data;
  48
  49   /* Set up vlib buffer hooks */
  50   b0->recycle_count = ctx_id;
  51   b0->free_list_index = rm->recycle_list_index;
  52   b0->flags |= VLIB_BUFFER_RECYCLE;
  53
  54   /* Save feature state */
  55   ctx->recycle_node_index = recycle_node_index;
  56
  57   /* Save vnet state */
  58   clib_memcpy (ctx->vnet_buffer, vnet_buffer (b0),
  59                sizeof (vnet_buffer_opaque_t));
  60
  61   /* Save packet contents */
  62   ctx->l2_packet = l2_packet;
  63   ip = (ip4_header_t *) vlib_buffer_get_current (b0);
  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
  92 replication_context_t *
  93 replication_recycle (vlib_main_t * vm, vlib_buffer_t * b0, u32 is_last)
  94 {
  95   replication_main_t *rm = &replication_main;
  96   replication_context_t *ctx;
  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 */
 108   vlib_buffer_advance (b0, ctx->current_data - b0->current_data);
 109
 110   /* Restore packet contents */
 111   ip = (ip4_header_t *) vlib_buffer_get_current (b0);
 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        */
 132       b0->free_list_index = ctx->saved_free_list_index;
 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
 149 replication_recycle_callback (vlib_main_t * vm, vlib_buffer_free_list_t * fl)
 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;
 160   replication_main_t *rm = &replication_main;
 161   replication_context_t *ctx;
 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 */
 226           b0->flags |= VLIB_BUFFER_IS_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 */
 235           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_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
 248   vec_reset_length (fl->aligned_buffers);
 249   vec_reset_length (fl->unaligned_buffers);
 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 *
 260 replication_init (vlib_main_t * vm)
 261 {
 262   replication_main_t *rm = &replication_main;
 263   vlib_buffer_main_t *bm = vm->buffer_main;
 264   vlib_buffer_free_list_t *fl;
 265   __attribute__ ((unused)) replication_context_t *ctx;
 266   vlib_thread_main_t *tm = vlib_get_thread_main ();
 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
 274   fl = pool_elt_at_index (bm->buffer_free_list_pool, rm->recycle_list_index);
 275
 276   fl->buffers_added_to_freelist_function = replication_recycle_callback;
 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
 285 VLIB_INIT_FUNCTION (replication_init);
 286
 287 /*
 288  * fd.io coding-style-patch-verification: ON
 289  *
 290  * Local Variables:
 291  * eval: (c-set-style "gnu")
 292  * End:
 293  */