vnet/vnet/l2/l2_classify.c

   1 /*
   2  * Copyright (c) 2015 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 /*
  16  * l2_classify.c
  17  */
  18
  19 #include <vnet/l2/l2_classify.h>
  20 #include <vnet/api_errno.h>
  21
  22 typedef struct {
  23   /* per-pkt trace data */
  24   u32 sw_if_index;
  25   u32 next_index;
  26   u32 table_index;
  27   u32 session_offset;
  28 } l2_classify_trace_t;
  29
  30 typedef struct {
  31   vnet_classify_main_t * vcm;
  32   l2_classify_main_t * l2cm;
  33 } l2_classify_runtime_t;
  34
  35 /* packet trace format function */
  36 static u8 * format_l2_classify_trace (u8 * s, va_list * args)
  37 {
  38   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  39   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  40   l2_classify_trace_t * t = va_arg (*args, l2_classify_trace_t *);
  41
  42   s = format (s, "l2-classify: sw_if_index %d, table %d, offset %x, next %d",
  43               t->sw_if_index, t->table_index, t->session_offset, t->next_index);
  44   return s;
  45 }
  46
  47 l2_classify_main_t l2_classify_main;
  48
  49 vlib_node_registration_t l2_classify_node;
  50
  51 #define foreach_l2_classify_error               \
  52 _(MISS, "Classify misses")                      \
  53 _(HIT, "Classify hits")                         \
  54 _(CHAIN_HIT, "Classify hits after chain walk")  \
  55 _(DROP, "L2 Classify Drops")
  56
  57 typedef enum {
  58 #define _(sym,str) L2_CLASSIFY_ERROR_##sym,
  59   foreach_l2_classify_error
  60 #undef _
  61   L2_CLASSIFY_N_ERROR,
  62 } l2_classify_error_t;
  63
  64 static char * l2_classify_error_strings[] = {
  65 #define _(sym,string) string,
  66   foreach_l2_classify_error
  67 #undef _
  68 };
  69
  70 static uword
  71 l2_classify_node_fn (vlib_main_t * vm,
  72                   vlib_node_runtime_t * node,
  73                   vlib_frame_t * frame)
  74 {
  75   u32 n_left_from, * from, * to_next;
  76   l2_classify_next_t next_index;
  77   l2_classify_main_t * cm = &l2_classify_main;
  78   vnet_classify_main_t * vcm = cm->vnet_classify_main;
  79   l2_classify_runtime_t * rt = (l2_classify_runtime_t *)node->runtime_data;
  80   u32 feature_bitmap;
  81   u32 hits = 0;
  82   u32 misses = 0;
  83   u32 chain_hits = 0;
  84   f64 now;
  85
  86   now = vlib_time_now(vm);
  87
  88   n_left_from = frame->n_vectors;
  89   from = vlib_frame_vector_args (frame);
  90
  91   /* First pass: compute hash */
  92
  93   while (n_left_from > 2)
  94     {
  95       vlib_buffer_t * b0, * b1;
  96       u32 bi0, bi1;
  97       ethernet_header_t * h0, * h1;
  98       u32 sw_if_index0, sw_if_index1;
  99       u16 type0, type1;
 100       int type_index0, type_index1;
 101       vnet_classify_table_t * t0, * t1;
 102       u32 table_index0, table_index1;
 103       u64 hash0, hash1;
 104
 105
 106       /* prefetch next iteration */
 107         {
 108           vlib_buffer_t * p1, * p2;
 109
 110           p1 = vlib_get_buffer (vm, from[1]);
 111           p2 = vlib_get_buffer (vm, from[2]);
 112
 113           vlib_prefetch_buffer_header (p1, STORE);
 114           CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE);
 115           vlib_prefetch_buffer_header (p2, STORE);
 116           CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
 117         }
 118
 119       bi0 = from[0];
 120       b0 = vlib_get_buffer (vm, bi0);
 121       h0 = vlib_buffer_get_current (b0);
 122
 123       bi1 = from[1];
 124       b1 = vlib_get_buffer (vm, bi1);
 125       h1 = vlib_buffer_get_current (b1);
 126
 127       sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
 128       vnet_buffer(b0)->l2_classify.table_index = ~0;
 129
 130       sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX];
 131       vnet_buffer(b1)->l2_classify.table_index = ~0;
 132
 133       /* Select classifier table based on ethertype */
 134       type0 = clib_net_to_host_u16 (h0->type);
 135       type1 = clib_net_to_host_u16 (h1->type);
 136
 137       type_index0 = (type0 == ETHERNET_TYPE_IP4)
 138           ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER;
 139       type_index0 = (type0 == ETHERNET_TYPE_IP6)
 140           ? L2_CLASSIFY_TABLE_IP6 : type_index0;
 141
 142       type_index1 = (type1 == ETHERNET_TYPE_IP4)
 143           ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER;
 144       type_index1 = (type1 == ETHERNET_TYPE_IP6)
 145           ? L2_CLASSIFY_TABLE_IP6 : type_index1;
 146
 147       vnet_buffer(b0)->l2_classify.table_index =
 148           table_index0 =
 149           rt->l2cm->classify_table_index_by_sw_if_index
 150           [type_index0][sw_if_index0];
 151
 152       if (table_index0 != ~0)
 153         {
 154           t0 = pool_elt_at_index (vcm->tables, table_index0);
 155
 156           vnet_buffer(b0)->l2_classify.hash = hash0 =
 157               vnet_classify_hash_packet (t0, (u8 *) h0);
 158           vnet_classify_prefetch_bucket (t0, hash0);
 159         }
 160
 161       vnet_buffer(b1)->l2_classify.table_index =
 162         table_index1 =
 163         rt->l2cm->classify_table_index_by_sw_if_index
 164         [type_index1][sw_if_index1];
 165
 166       if (table_index1 != ~0)
 167         {
 168           t1 = pool_elt_at_index (vcm->tables, table_index1);
 169
 170           vnet_buffer(b1)->l2_classify.hash = hash1 =
 171             vnet_classify_hash_packet (t1, (u8 *) h1);
 172           vnet_classify_prefetch_bucket (t1, hash1);
 173         }
 174
 175       from += 2;
 176       n_left_from -= 2;
 177     }
 178
 179   while (n_left_from > 0)
 180     {
 181       vlib_buffer_t * b0;
 182       u32 bi0;
 183       ethernet_header_t * h0;
 184       u32 sw_if_index0;
 185       u16 type0;
 186       u32 type_index0;
 187       vnet_classify_table_t * t0;
 188       u32 table_index0;
 189       u64 hash0;
 190
 191       bi0 = from[0];
 192       b0 = vlib_get_buffer (vm, bi0);
 193       h0 = vlib_buffer_get_current (b0);
 194
 195       sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
 196       vnet_buffer(b0)->l2_classify.table_index = ~0;
 197
 198       /* Select classifier table based on ethertype */
 199       type0 = clib_net_to_host_u16 (h0->type);
 200
 201       type_index0 = (type0 == ETHERNET_TYPE_IP4)
 202           ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER;
 203       type_index0 = (type0 == ETHERNET_TYPE_IP6)
 204           ? L2_CLASSIFY_TABLE_IP6 : type_index0;
 205
 206       vnet_buffer(b0)->l2_classify.table_index =
 207           table_index0 = rt->l2cm->classify_table_index_by_sw_if_index
 208           [type_index0][sw_if_index0];
 209
 210       if (table_index0 != ~0)
 211         {
 212           t0 = pool_elt_at_index (vcm->tables, table_index0);
 213
 214           vnet_buffer(b0)->l2_classify.hash = hash0 =
 215             vnet_classify_hash_packet (t0, (u8 *) h0);
 216           vnet_classify_prefetch_bucket (t0, hash0);
 217         }
 218       from++;
 219       n_left_from--;
 220     }
 221
 222   next_index = node->cached_next_index;
 223   from = vlib_frame_vector_args (frame);
 224   n_left_from = frame->n_vectors;
 225
 226   while (n_left_from > 0)
 227     {
 228       u32 n_left_to_next;
 229
 230       vlib_get_next_frame (vm, node, next_index,
 231                            to_next, n_left_to_next);
 232
 233       /* Not enough load/store slots to dual loop... */
 234       while (n_left_from > 0 && n_left_to_next > 0)
 235         {
 236           u32 bi0;
 237           vlib_buffer_t * b0;
 238           u32 next0 = L2_CLASSIFY_NEXT_ETHERNET_INPUT;
 239           ethernet_header_t * h0;
 240           u32 table_index0;
 241           u64 hash0;
 242           vnet_classify_table_t * t0;
 243           vnet_classify_entry_t * e0;
 244
 245           if (PREDICT_TRUE (n_left_from > 2))
 246             {
 247               vlib_buffer_t * p2 = vlib_get_buffer(vm, from[2]);
 248               u64 phash2;
 249               u32 table_index2;
 250               vnet_classify_table_t * tp2;
 251
 252               /*
 253                * Prefetch table entry two ahead. Buffer / data
 254                * were prefetched above...
 255                */
 256               table_index2 = vnet_buffer(p2)->l2_classify.table_index;
 257
 258               if (PREDICT_TRUE (table_index2 != ~0))
 259                 {
 260                   tp2 = pool_elt_at_index (vcm->tables, table_index2);
 261                   phash2 = vnet_buffer(p2)->l2_classify.hash;
 262                   vnet_classify_prefetch_entry (tp2, phash2);
 263                 }
 264             }
 265
 266           /* speculatively enqueue b0 to the current next frame */
 267           bi0 = from[0];
 268           to_next[0] = bi0;
 269           from += 1;
 270           to_next += 1;
 271           n_left_from -= 1;
 272           n_left_to_next -= 1;
 273
 274           b0 = vlib_get_buffer (vm, bi0);
 275           h0 = vlib_buffer_get_current(b0);
 276           table_index0 = vnet_buffer(b0)->l2_classify.table_index;
 277           e0 = 0;
 278           vnet_buffer(b0)->l2_classify.opaque_index = ~0;
 279
 280           if (PREDICT_TRUE(table_index0 != ~0))
 281             {
 282               hash0 = vnet_buffer(b0)->l2_classify.hash;
 283               t0 = pool_elt_at_index (vcm->tables, table_index0);
 284
 285               e0 = vnet_classify_find_entry (t0, (u8 *) h0,
 286                                              hash0, now);
 287               if (e0)
 288                 {
 289                   vnet_buffer(b0)->l2_classify.opaque_index
 290                     = e0->opaque_index;
 291                   vlib_buffer_advance (b0, e0->advance);
 292                   next0 = (e0->next_index < L2_CLASSIFY_N_NEXT)?
 293                            e0->next_index:next0;
 294                   hits++;
 295                 }
 296               else
 297                 {
 298                   while (1)
 299                     {
 300                       if (t0->next_table_index != ~0)
 301                         t0 = pool_elt_at_index (vcm->tables,
 302                                                 t0->next_table_index);
 303                       else
 304                         {
 305                           next0 = (t0->miss_next_index < L2_CLASSIFY_N_NEXT)?
 306                                    t0->miss_next_index:next0;
 307                           misses++;
 308                           break;
 309                         }
 310
 311                       hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
 312                       e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
 313                       if (e0)
 314                         {
 315                           vnet_buffer(b0)->l2_classify.opaque_index
 316                             = e0->opaque_index;
 317                           vlib_buffer_advance (b0, e0->advance);
 318                           next0 = (e0->next_index < L2_CLASSIFY_N_NEXT)?
 319                                    e0->next_index:next0;
 320                           hits++;
 321                           chain_hits++;
 322                           break;
 323                         }
 324                     }
 325                 }
 326             }
 327
 328           if (PREDICT_FALSE(next0 == 0))
 329             b0->error = node->errors[L2_CLASSIFY_ERROR_DROP];
 330
 331           if (PREDICT_FALSE (next0 == ~0))
 332             {
 333
 334               // Remove ourself from the feature bitmap
 335               feature_bitmap = vnet_buffer(b0)->l2.feature_bitmap
 336                 & ~L2INPUT_FEAT_CLASSIFY;
 337
 338               // save for next feature graph nodes
 339               vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap;
 340
 341               // Determine the next node
 342               next0 = feat_bitmap_get_next_node_index(cm->feat_next_node_index,
 343                                                       feature_bitmap);
 344             }
 345
 346           if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
 347                             && (b0->flags & VLIB_BUFFER_IS_TRACED)))
 348             {
 349               l2_classify_trace_t *t =
 350                 vlib_add_trace (vm, node, b0, sizeof (*t));
 351               t->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX];
 352               t->table_index = table_index0;
 353               t->next_index = next0;
 354               t->session_offset = e0 ? vnet_classify_get_offset (t0, e0) : 0;
 355             }
 356
 357           /* verify speculative enqueue, maybe switch current next frame */
 358           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 359                                            to_next, n_left_to_next,
 360                                            bi0, next0);
 361         }
 362
 363       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 364     }
 365
 366   vlib_node_increment_counter (vm, node->node_index,
 367                                L2_CLASSIFY_ERROR_MISS,
 368                                misses);
 369   vlib_node_increment_counter (vm, node->node_index,
 370                                L2_CLASSIFY_ERROR_HIT,
 371                                hits);
 372   vlib_node_increment_counter (vm, node->node_index,
 373                                L2_CLASSIFY_ERROR_CHAIN_HIT,
 374                                chain_hits);
 375   return frame->n_vectors;
 376 }
 377
 378 VLIB_REGISTER_NODE (l2_classify_node) = {
 379   .function = l2_classify_node_fn,
 380   .name = "l2-classify",
 381   .vector_size = sizeof (u32),
 382   .format_trace = format_l2_classify_trace,
 383   .type = VLIB_NODE_TYPE_INTERNAL,
 384
 385   .n_errors = ARRAY_LEN(l2_classify_error_strings),
 386   .error_strings = l2_classify_error_strings,
 387
 388   .runtime_data_bytes = sizeof (l2_classify_runtime_t),
 389
 390   .n_next_nodes = L2_CLASSIFY_N_NEXT,
 391
 392   /* edit / add dispositions here */
 393   .next_nodes = {
 394        [L2_CLASSIFY_NEXT_DROP]  = "error-drop",
 395        [L2_CLASSIFY_NEXT_ETHERNET_INPUT] = "ethernet-input-not-l2",
 396        [L2_CLASSIFY_NEXT_IP4_INPUT] = "ip4-input",
 397        [L2_CLASSIFY_NEXT_IP6_INPUT] = "ip6-input",
 398        [L2_CLASSIFY_NEXT_LI] = "li-hit",
 399   },
 400 };
 401
 402 VLIB_NODE_FUNCTION_MULTIARCH (l2_classify_node, l2_classify_node_fn)
 403
 404 clib_error_t *l2_classify_init (vlib_main_t *vm)
 405 {
 406   l2_classify_main_t * cm = &l2_classify_main;
 407   l2_classify_runtime_t * rt;
 408
 409   rt = vlib_node_get_runtime_data (vm, l2_classify_node.index);
 410
 411   cm->vlib_main = vm;
 412   cm->vnet_main = vnet_get_main();
 413   cm->vnet_classify_main = &vnet_classify_main;
 414
 415   // Initialize the feature next-node indexes
 416   feat_bitmap_init_next_nodes(vm,
 417                               l2_classify_node.index,
 418                               L2INPUT_N_FEAT,
 419                               l2input_get_feat_names(),
 420                               cm->feat_next_node_index);
 421   rt->l2cm = cm;
 422   rt->vcm = cm->vnet_classify_main;
 423
 424   return 0;
 425 }
 426
 427 VLIB_INIT_FUNCTION (l2_classify_init);
 428
 429
 430 void vnet_l2_classify_enable_disable (u32 sw_if_index,
 431                                       int enable_disable)
 432 {
 433   vlib_main_t * vm = vlib_get_main();
 434   vnet_main_t * vnm = vnet_get_main();
 435
 436   if (enable_disable)
 437     set_int_l2_mode (vm, vnm, MODE_L2_CLASSIFY, sw_if_index,
 438                      0, 0, 0, 0);
 439   else
 440     set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index,
 441                      0, 0, 0, 0);
 442 }
 443
 444 int vnet_l2_classify_set_tables (u32 sw_if_index,
 445                                  u32 ip4_table_index,
 446                                  u32 ip6_table_index,
 447                                  u32 other_table_index)
 448 {
 449   l2_classify_main_t * cm = &l2_classify_main;
 450   vnet_classify_main_t * vcm = cm->vnet_classify_main;
 451
 452   /* Assume that we've validated sw_if_index in the API layer */
 453
 454   if (ip4_table_index != ~0 &&
 455       pool_is_free_index (vcm->tables, ip4_table_index))
 456     return VNET_API_ERROR_NO_SUCH_TABLE;
 457
 458   if (ip6_table_index != ~0 &&
 459       pool_is_free_index (vcm->tables, ip6_table_index))
 460     return VNET_API_ERROR_NO_SUCH_TABLE2;
 461
 462   if (other_table_index != ~0 &&
 463       pool_is_free_index (vcm->tables, other_table_index))
 464     return VNET_API_ERROR_NO_SUCH_TABLE3;
 465
 466   vec_validate
 467     (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4],
 468      sw_if_index);
 469
 470   vec_validate
 471     (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6],
 472      sw_if_index);
 473
 474   vec_validate
 475     (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER],
 476      sw_if_index);
 477
 478   cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4]
 479     [sw_if_index] = ip4_table_index;
 480
 481   cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6]
 482     [sw_if_index] = ip6_table_index;
 483
 484   cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER]
 485     [sw_if_index] = other_table_index;
 486
 487   return 0;
 488 }
 489
 490 static clib_error_t *
 491 int_l2_classify_command_fn (vlib_main_t * vm,
 492                             unformat_input_t * input,
 493                             vlib_cli_command_t * cmd)
 494 {
 495   vnet_main_t * vnm = vnet_get_main();
 496   u32 sw_if_index = ~0;
 497   u32 ip4_table_index = ~0;
 498   u32 ip6_table_index = ~0;
 499   u32 other_table_index = ~0;
 500   int rv;
 501
 502   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
 503     {
 504       if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
 505                     vnm, &sw_if_index))
 506         ;
 507       else if (unformat (input, "ip4-table %d", &ip4_table_index))
 508         ;
 509       else if (unformat (input, "ip6-table %d", &ip6_table_index))
 510         ;
 511       else if (unformat (input, "other-table %d", &other_table_index))
 512         ;
 513       else
 514         break;
 515     }
 516
 517   if (sw_if_index == ~0)
 518     return clib_error_return (0, "interface must be specified");
 519
 520
 521   if (ip4_table_index == ~0 && ip6_table_index == ~0
 522       && other_table_index == ~0)
 523     {
 524       vlib_cli_output (vm, "L2 classification disabled");
 525       vnet_l2_classify_enable_disable (sw_if_index, 0 /* enable */);
 526       return 0;
 527     }
 528
 529   rv = vnet_l2_classify_set_tables (sw_if_index, ip4_table_index,
 530                                     ip6_table_index, other_table_index);
 531   switch(rv)
 532     {
 533     case 0:
 534       vnet_l2_classify_enable_disable (sw_if_index, 1 /* enable */);
 535       break;
 536
 537     default:
 538       return clib_error_return (0, "vnet_l2_classify_set_tables: %d",
 539                                 rv);
 540       break;
 541     }
 542
 543   return 0;
 544 }
 545
 546 VLIB_CLI_COMMAND (int_l2_classify_cli, static) = {
 547   .path = "set interface l2 classify",
 548   .short_help =
 549   "set interface l2 classify intfc <int> [ip4-table <n>]\n"
 550   "  [ip6-table <n>] [other-table <n>]",
 551   .function = int_l2_classify_command_fn,
 552 };
 553
 554