src/vnet/mpls/mpls_input.c

   1 /*
   2  * node.c: MPLS input
   3  *
   4  * Copyright (c) 2012-2014 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/pg/pg.h>
  20 #include <vnet/mpls/mpls.h>
  21 #include <vnet/feature/feature.h>
  22
  23 typedef struct {
  24   u32 next_index;
  25   u32 label_net_byte_order;
  26 } mpls_input_trace_t;
  27
  28 #define foreach_mpls_input_next                 \
  29 _(DROP, "error-drop")                           \
  30 _(LOOKUP, "mpls-lookup")
  31
  32 typedef enum {
  33 #define _(s,n) MPLS_INPUT_NEXT_##s,
  34   foreach_mpls_input_next
  35 #undef _
  36   MPLS_INPUT_N_NEXT,
  37 } mpls_input_next_t;
  38
  39 static u8 *
  40 format_mpls_input_trace (u8 * s, va_list * args)
  41 {
  42   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  43   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  44   mpls_input_trace_t * t = va_arg (*args, mpls_input_trace_t *);
  45   char * next_name;
  46   u32 label;
  47   next_name = "BUG!";
  48   label = clib_net_to_host_u32(t->label_net_byte_order);
  49
  50 #define _(a,b) if (t->next_index == MPLS_INPUT_NEXT_##a) next_name = b;
  51   foreach_mpls_input_next;
  52 #undef _
  53
  54   s = format (s, "MPLS: next %s[%d]  label %d ttl %d exp %d",
  55               next_name, t->next_index,
  56               vnet_mpls_uc_get_label(label),
  57               vnet_mpls_uc_get_ttl(label),
  58               vnet_mpls_uc_get_exp(label));
  59
  60   return s;
  61 }
  62
  63 vlib_node_registration_t mpls_input_node;
  64
  65 typedef struct {
  66   u32 last_label;
  67   u32 last_inner_fib_index;
  68   u32 last_outer_fib_index;
  69   mpls_main_t * mpls_main;
  70 } mpls_input_runtime_t;
  71
  72 static inline uword
  73 mpls_input_inline (vlib_main_t * vm,
  74                    vlib_node_runtime_t * node,
  75                    vlib_frame_t * from_frame)
  76 {
  77   u32 n_left_from, next_index, * from, * to_next;
  78   mpls_main_t * mm = &mpls_main;
  79   u32 thread_index = vlib_get_thread_index();
  80   vlib_simple_counter_main_t * cm;
  81   vnet_main_t * vnm = vnet_get_main();
  82
  83   from = vlib_frame_vector_args (from_frame);
  84   n_left_from = from_frame->n_vectors;
  85
  86   next_index = node->cached_next_index;
  87
  88   cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
  89                          VNET_INTERFACE_COUNTER_MPLS);
  90
  91   while (n_left_from > 0)
  92     {
  93       u32 n_left_to_next;
  94
  95       vlib_get_next_frame (vm, node, next_index,
  96                            to_next, n_left_to_next);
  97
  98       while (n_left_from >= 4 && n_left_to_next >= 2)
  99         {
 100           u32 bi0, next0, sw_if_index0;
 101           u32 bi1, next1, sw_if_index1;
 102           vlib_buffer_t *b0, *b1;
 103           char *h0, *h1;
 104
 105           /* Prefetch next iteration. */
 106           {
 107               vlib_buffer_t * p2, * p3;
 108
 109               p2 = vlib_get_buffer (vm, from[2]);
 110               p3 = vlib_get_buffer (vm, from[3]);
 111
 112               vlib_prefetch_buffer_header (p2, STORE);
 113               vlib_prefetch_buffer_header (p3, STORE);
 114
 115               CLIB_PREFETCH (p2->data, sizeof (h0[0]), STORE);
 116               CLIB_PREFETCH (p3->data, sizeof (h1[0]), STORE);
 117           }
 118
 119           bi0 = to_next[0] = from[0];
 120           bi1 = to_next[1] = from[1];
 121
 122           from += 2;
 123           to_next += 2;
 124           n_left_from -= 2;
 125           n_left_to_next -= 2;
 126
 127           b0 = vlib_get_buffer (vm, bi0);
 128           b1 = vlib_get_buffer (vm, bi1);
 129
 130           h0 = vlib_buffer_get_current (b0);
 131           h1 = vlib_buffer_get_current (b1);
 132
 133           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 134           sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
 135
 136           /* TTL expired? */
 137           if (PREDICT_FALSE(h0[3] == 0))
 138           {
 139               next0 = MPLS_INPUT_NEXT_DROP;
 140               b0->error = node->errors[MPLS_ERROR_TTL_EXPIRED];
 141           }
 142           else
 143           {
 144               next0 = MPLS_INPUT_NEXT_LOOKUP;
 145               vnet_feature_arc_start(mm->input_feature_arc_index,
 146                                      sw_if_index0, &next0, b0);
 147               vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
 148           }
 149
 150           if (PREDICT_FALSE(h1[3] == 0))
 151           {
 152               next1 = MPLS_INPUT_NEXT_DROP;
 153               b1->error = node->errors[MPLS_ERROR_TTL_EXPIRED];
 154           }
 155           else
 156           {
 157               next1 = MPLS_INPUT_NEXT_LOOKUP;
 158               vnet_feature_arc_start(mm->input_feature_arc_index,
 159                                      sw_if_index1, &next1, b1);
 160               vlib_increment_simple_counter (cm, thread_index, sw_if_index1, 1);
 161           }
 162
 163           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 164           {
 165               mpls_input_trace_t *tr = vlib_add_trace (vm, node,
 166                                                        b0, sizeof (*tr));
 167               tr->next_index = next0;
 168               tr->label_net_byte_order = *((u32*)h0);
 169           }
 170           if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
 171           {
 172               mpls_input_trace_t *tr = vlib_add_trace (vm, node,
 173                                                        b1, sizeof (*tr));
 174               tr->next_index = next1;
 175               tr->label_net_byte_order = *((u32*)h1);
 176           }
 177
 178           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 179                                            to_next, n_left_to_next,
 180                                            bi0, bi1,
 181                                            next0, next1);
 182         }
 183
 184       while (n_left_from > 0 && n_left_to_next > 0)
 185         {
 186           u32 sw_if_index0, next0, bi0;
 187           vlib_buffer_t * b0;
 188           char * h0;
 189
 190           bi0 = from[0];
 191           to_next[0] = bi0;
 192           from += 1;
 193           to_next += 1;
 194           n_left_from -= 1;
 195           n_left_to_next -= 1;
 196
 197           b0 = vlib_get_buffer (vm, bi0);
 198           h0 = vlib_buffer_get_current (b0);
 199           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 200
 201           /* TTL expired? */
 202           if (PREDICT_FALSE(h0[3] == 0))
 203            {
 204               next0 = MPLS_INPUT_NEXT_DROP;
 205               b0->error = node->errors[MPLS_ERROR_TTL_EXPIRED];
 206             }
 207           else
 208             {
 209               next0 = MPLS_INPUT_NEXT_LOOKUP;
 210               vnet_feature_arc_start(mm->input_feature_arc_index, sw_if_index0, &next0, b0);
 211               vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
 212             }
 213
 214           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 215             {
 216               mpls_input_trace_t *tr = vlib_add_trace (vm, node,
 217                                                        b0, sizeof (*tr));
 218               tr->next_index = next0;
 219               tr->label_net_byte_order = *(u32*)h0;
 220             }
 221
 222           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 223                                            to_next, n_left_to_next,
 224                                            bi0, next0);
 225         }
 226
 227       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 228     }
 229   vlib_node_increment_counter (vm, mpls_input_node.index,
 230                                MPLS_ERROR_PKTS_DECAP, from_frame->n_vectors);
 231   return from_frame->n_vectors;
 232 }
 233
 234 static uword
 235 mpls_input (vlib_main_t * vm,
 236             vlib_node_runtime_t * node,
 237             vlib_frame_t * from_frame)
 238 {
 239   return mpls_input_inline (vm, node, from_frame);
 240 }
 241
 242 static char * mpls_error_strings[] = {
 243 #define mpls_error(n,s) s,
 244 #include "error.def"
 245 #undef mpls_error
 246 };
 247
 248 VLIB_REGISTER_NODE (mpls_input_node) = {
 249   .function = mpls_input,
 250   .name = "mpls-input",
 251   /* Takes a vector of packets. */
 252   .vector_size = sizeof (u32),
 253
 254   .runtime_data_bytes = sizeof(mpls_input_runtime_t),
 255
 256   .n_errors = MPLS_N_ERROR,
 257   .error_strings = mpls_error_strings,
 258
 259   .n_next_nodes = MPLS_INPUT_N_NEXT,
 260   .next_nodes = {
 261 #define _(s,n) [MPLS_INPUT_NEXT_##s] = n,
 262     foreach_mpls_input_next
 263 #undef _
 264   },
 265
 266   .format_buffer = format_mpls_unicast_header_net_byte_order,
 267   .format_trace = format_mpls_input_trace,
 268 };
 269
 270 VLIB_NODE_FUNCTION_MULTIARCH (mpls_input_node, mpls_input)
 271
 272 static void
 273 mpls_setup_nodes (vlib_main_t * vm)
 274 {
 275   pg_node_t * pn;
 276
 277   pn = pg_get_node (mpls_input_node.index);
 278   pn->unformat_edit = unformat_pg_mpls_header;
 279
 280   ethernet_register_input_type (vm, ETHERNET_TYPE_MPLS,
 281                                 mpls_input_node.index);
 282 }
 283
 284 static clib_error_t * mpls_input_init (vlib_main_t * vm)
 285 {
 286   clib_error_t * error;
 287
 288   error = vlib_call_init_function (vm, mpls_init);
 289   if (error)
 290     clib_error_report (error);
 291
 292   mpls_setup_nodes (vm);
 293
 294   return 0;
 295 }
 296
 297 VLIB_INIT_FUNCTION (mpls_input_init);