Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this file except in compliance with the License.
       5             :  * You may obtain a copy of the License at:
       6             :  *
       7             :  *     http://www.apache.org/licenses/LICENSE-2.0
       8             :  *
       9             :  * Unless required by applicable law or agreed to in writing, software
      10             :  * distributed under the License is distributed on an "AS IS" BASIS,
      11             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             :  * See the License for the specific language governing permissions and
      13             :  * limitations under the License.
      14             :  */
      15             : #include <vlib/vlib.h>
      16             : #include <vnet/vnet.h>
      17             : #include <vppinfra/error.h>
      18             : #include <vnet/ethernet/ethernet.h>
      19             : #include <vnet/ip/ip.h>
      20             : #include <vnet/ip/ip6_hop_by_hop.h>
      21             : #include <ioam/export-common/ioam_export.h>
      22             : 
      23             : 
      24             : typedef struct
      25             : {
      26             :   u32 next_index;
      27             :   u32 flow_label;
      28             : } export_trace_t;
      29             : 
      30             : /* packet trace format function */
      31             : static u8 *
      32           0 : format_export_trace (u8 * s, va_list * args)
      33             : {
      34           0 :   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
      35           0 :   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
      36           0 :   export_trace_t *t = va_arg (*args, export_trace_t *);
      37             : 
      38           0 :   s = format (s, "EXPORT: flow_label %d, next index %d",
      39             :               t->flow_label, t->next_index);
      40           0 :   return s;
      41             : }
      42             : 
      43             : vlib_node_registration_t export_node;
      44             : extern ioam_export_main_t ioam_export_main;
      45             : 
      46             : #define foreach_export_error \
      47             : _(RECORDED, "Packets recorded for export")
      48             : 
      49             : typedef enum
      50             : {
      51             : #define _(sym,str) EXPORT_ERROR_##sym,
      52             :   foreach_export_error
      53             : #undef _
      54             :     EXPORT_N_ERROR,
      55             : } export_error_t;
      56             : 
      57             : static char *export_error_strings[] = {
      58             : #define _(sym,string) string,
      59             :   foreach_export_error
      60             : #undef _
      61             : };
      62             : 
      63             : typedef enum
      64             : {
      65             :   EXPORT_NEXT_POP_HBYH,
      66             :   EXPORT_N_NEXT,
      67             : } export_next_t;
      68             : 
      69             : always_inline void
      70           0 : copy3cachelines (void *dst, const void *src, size_t n)
      71             : {
      72             : #if 0
      73             :   if (PREDICT_FALSE (n < DEFAULT_EXPORT_SIZE))
      74             :     {
      75             :       /* Copy only the first 1/2 cache lines whatever is available */
      76             :       if (n >= 64)
      77             :         clib_mov64 ((u8 *) dst, (const u8 *) src);
      78             :       if (n >= 128)
      79             :         clib_mov64 ((u8 *) dst + 64, (const u8 *) src + 64);
      80             :       return;
      81             :     }
      82             :   clib_mov64 ((u8 *) dst, (const u8 *) src);
      83             :   clib_mov64 ((u8 *) dst + 64, (const u8 *) src + 64);
      84             :   clib_mov64 ((u8 *) dst + 128, (const u8 *) src + 128);
      85             : #endif
      86             : #if 1
      87             : 
      88             :   u64 *copy_dst, *copy_src;
      89             :   int i;
      90           0 :   copy_dst = (u64 *) dst;
      91           0 :   copy_src = (u64 *) src;
      92           0 :   if (PREDICT_FALSE (n < DEFAULT_EXPORT_SIZE))
      93             :     {
      94           0 :       for (i = 0; i < n / 64; i++)
      95             :         {
      96           0 :           copy_dst[0] = copy_src[0];
      97           0 :           copy_dst[1] = copy_src[1];
      98           0 :           copy_dst[2] = copy_src[2];
      99           0 :           copy_dst[3] = copy_src[3];
     100           0 :           copy_dst[4] = copy_src[4];
     101           0 :           copy_dst[5] = copy_src[5];
     102           0 :           copy_dst[6] = copy_src[6];
     103           0 :           copy_dst[7] = copy_src[7];
     104           0 :           copy_dst += 8;
     105           0 :           copy_src += 8;
     106             :         }
     107           0 :       return;
     108             :     }
     109           0 :   for (i = 0; i < 3; i++)
     110             :     {
     111           0 :       copy_dst[0] = copy_src[0];
     112           0 :       copy_dst[1] = copy_src[1];
     113           0 :       copy_dst[2] = copy_src[2];
     114           0 :       copy_dst[3] = copy_src[3];
     115           0 :       copy_dst[4] = copy_src[4];
     116           0 :       copy_dst[5] = copy_src[5];
     117           0 :       copy_dst[6] = copy_src[6];
     118           0 :       copy_dst[7] = copy_src[7];
     119           0 :       copy_dst += 8;
     120           0 :       copy_src += 8;
     121             :     }
     122             : #endif
     123             : }
     124             : 
     125             : static void
     126           0 : ip6_export_fixup_func (vlib_buffer_t * export_buf, vlib_buffer_t * pak_buf)
     127             : {
     128           0 :   ip6_header_t *ip6_temp =
     129           0 :       (ip6_header_t *) (export_buf->data + export_buf->current_length);
     130           0 :   u32 flow_label_temp =
     131           0 :       clib_net_to_host_u32(ip6_temp->ip_version_traffic_class_and_flow_label)
     132             :       & 0xFFF00000;
     133           0 :   flow_label_temp |=
     134           0 :       IOAM_MASK_DECAP_BIT((vnet_buffer(pak_buf)->l2_classify.opaque_index));
     135           0 :   ip6_temp->ip_version_traffic_class_and_flow_label =
     136           0 :       clib_host_to_net_u32(flow_label_temp);
     137           0 : }
     138             : 
     139             : static uword
     140           0 : ip6_export_node_fn (vlib_main_t * vm,
     141             :                     vlib_node_runtime_t * node, vlib_frame_t * frame)
     142             : {
     143           0 :   ioam_export_main_t *em = &ioam_export_main;
     144           0 :   ioam_export_node_common(em, vm, node, frame, ip6_header_t, payload_length,
     145             :                           ip_version_traffic_class_and_flow_label, 
     146             :                           EXPORT_NEXT_POP_HBYH, ip6_export_fixup_func);
     147           0 :   return frame->n_vectors;
     148             : }
     149             : 
     150             : /*
     151             :  * Node for IP6 export
     152             :  */
     153      114668 : VLIB_REGISTER_NODE (export_node) =
     154             : {
     155             :   .function = ip6_export_node_fn,
     156             :   .name = "ip6-export",
     157             :   .vector_size = sizeof (u32),
     158             :   .format_trace = format_export_trace,
     159             :   .type = VLIB_NODE_TYPE_INTERNAL,
     160             :   .n_errors = ARRAY_LEN (export_error_strings),
     161             :   .error_strings = export_error_strings,
     162             :   .n_next_nodes = EXPORT_N_NEXT,
     163             :   /* edit / add dispositions here */
     164             :   .next_nodes =
     165             :   {
     166             :     [EXPORT_NEXT_POP_HBYH] = "ip6-pop-hop-by-hop"
     167             :   },
     168             : };