src/vnet/l2/l2_input_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 /**
  23  * @file
  24  * @brief L2 input classifier.
  25  *
  26  * @sa @ref vnet/vnet/classify/vnet_classify.c
  27  * @sa @ref vnet/vnet/classify/vnet_classify.h
  28  */
  29
  30 /**
  31  * @brief l2_input_classifier packet trace record.
  32  */
  33 typedef struct
  34 {
  35   /** interface handle for the ith packet */
  36   u32 sw_if_index;
  37   /** graph arc index selected for this packet */
  38   u32 next_index;
  39   /** classifier table which provided the final result */
  40   u32 table_index;
  41   /** offset in classifier heap of the corresponding session */
  42   u32 session_offset;
  43 } l2_input_classify_trace_t;
  44
  45 /**
  46  * @brief vlib node runtime.
  47  */
  48 typedef struct
  49 {
  50   /** use-case independent main object pointer */
  51   vnet_classify_main_t *vcm;
  52   /** l2 input classifier main object pointer */
  53   l2_input_classify_main_t *l2cm;
  54 } l2_input_classify_runtime_t;
  55
  56 /** Packet trace format function. */
  57 static u8 *
  58 format_l2_input_classify_trace (u8 * s, va_list * args)
  59 {
  60   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  61   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  62   l2_input_classify_trace_t *t = va_arg (*args, l2_input_classify_trace_t *);
  63
  64   s = format (s, "l2-classify: sw_if_index %d, table %d, offset %x, next %d",
  65               t->sw_if_index, t->table_index, t->session_offset,
  66               t->next_index);
  67   return s;
  68 }
  69
  70 extern l2_input_classify_main_t l2_input_classify_main;
  71
  72 #ifndef CLIB_MARCH_VARIANT
  73 /** l2 input classifier main data structure. */
  74 l2_input_classify_main_t l2_input_classify_main;
  75 #endif /* CLIB_MARCH_VARIANT */
  76
  77 #define foreach_l2_input_classify_error               \
  78 _(MISS, "Classify misses")                      \
  79 _(HIT, "Classify hits")                         \
  80 _(CHAIN_HIT, "Classify hits after chain walk")  \
  81 _(DROP, "L2 Classify Drops")
  82
  83 typedef enum
  84 {
  85 #define _(sym,str) L2_INPUT_CLASSIFY_ERROR_##sym,
  86   foreach_l2_input_classify_error
  87 #undef _
  88     L2_INPUT_CLASSIFY_N_ERROR,
  89 } l2_input_classify_error_t;
  90
  91 static char *l2_input_classify_error_strings[] = {
  92 #define _(sym,string) string,
  93   foreach_l2_input_classify_error
  94 #undef _
  95 };
  96
  97 /**
  98  * @brief l2 input classifier node.
  99  * @node l2-input-classify
 100  *
 101  * This is the l2 input classifier dispatch node
 102  *
 103  * @param vm    vlib_main_t corresponding to the current thread.
 104  * @param node  vlib_node_runtime_t data for this node.
 105  * @param frame vlib_frame_t whose contents should be dispatched.
 106  *
 107  * @par Graph mechanics: buffer metadata, next index usage
 108  *
 109  * @em Uses:
 110  * - <code>(l2_input_classify_runtime_t *)
 111  *         rt->classify_table_index_by_sw_if_index</code>
 112  *      - Head of the per-interface, per-protocol classifier table chain
 113  *        for a specific interface.
 114  *      - @c ~0 => send pkts to the next feature in the L2 feature chain.
 115  * - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
 116  *      - Indicates the @c sw_if_index value of the interface that the
 117  *        packet was received on.
 118  * - <code>vnet_buffer(b0)->l2.feature_bitmap</code>
 119  *      - Used to steer packets across l2 features enabled on the interface
 120  * - <code>(vnet_classify_entry_t) e0->next_index</code>
 121  *      - Used to steer traffic when the classifier hits on a session
 122  * - <code>(vnet_classify_entry_t) e0->advance</code>
 123  *      - Signed quantity applied via <code>vlib_buffer_advance</code>
 124  *        when the classifier hits on a session
 125  * - <code>(vnet_classify_table_t) t0->miss_next_index</code>
 126  *      - Used to steer traffic when the classifier misses
 127  *
 128  * @em Sets:
 129  * - <code>vnet_buffer (b0)->l2_classify.table_index</code>
 130  *      - Classifier table index of the first classifier table in
 131  *      the classifier table chain
 132  * - <code>vnet_buffer (b0)->l2_classify.hash</code>
 133  *      - Bounded-index extensible hash corresponding to the
 134  *      masked fields in the current packet
 135  * - <code>vnet_buffer (b0)->l2.feature_bitmap</code>
 136  *      - Used to steer packets across l2 features enabled on the interface
 137  * - <code>vnet_buffer (b0)->l2_classify.opaque_index</code>
 138  *      - Copied from the classifier session object upon classifier hit
 139  *
 140  * @em Counters:
 141  * - <code>L2_INPUT_CLASSIFY_ERROR_MISS</code> Classifier misses
 142  * - <code>L2_INPUT_CLASSIFY_ERROR_HIT</code> Classifier hits
 143  * - <code>L2_INPUT_CLASSIFY_ERROR_CHAIN_HIT</code>
 144  *   Classifier hits in other than the first table
 145  */
 146
 147 VLIB_NODE_FN (l2_input_classify_node) (vlib_main_t * vm,
 148                                        vlib_node_runtime_t * node,
 149                                        vlib_frame_t * frame)
 150 {
 151   u32 n_left_from, *from, *to_next;
 152   l2_input_classify_next_t next_index;
 153   l2_input_classify_main_t *cm = &l2_input_classify_main;
 154   vnet_classify_main_t *vcm = cm->vnet_classify_main;
 155   l2_input_classify_runtime_t *rt =
 156     (l2_input_classify_runtime_t *) node->runtime_data;
 157   u32 hits = 0;
 158   u32 misses = 0;
 159   u32 chain_hits = 0;
 160   f64 now;
 161   u32 n_next_nodes;
 162
 163   n_next_nodes = node->n_next_nodes;
 164
 165   now = vlib_time_now (vm);
 166
 167   n_left_from = frame->n_vectors;
 168   from = vlib_frame_vector_args (frame);
 169
 170   /* First pass: compute hash */
 171
 172   while (n_left_from >= 4)
 173     {
 174       vlib_buffer_t *b0, *b1;
 175       u32 bi0, bi1;
 176       ethernet_header_t *h0, *h1;
 177       u32 sw_if_index0, sw_if_index1;
 178       u16 type0, type1;
 179       int type_index0, type_index1;
 180       vnet_classify_table_t *t0, *t1;
 181       u32 table_index0, table_index1;
 182       u32 hash0, hash1;
 183
 184       /* prefetch next iteration */
 185       {
 186         vlib_buffer_t *p2, *p3;
 187
 188         p2 = vlib_get_buffer (vm, from[2]);
 189         p3 = vlib_get_buffer (vm, from[3]);
 190
 191         vlib_prefetch_buffer_header (p2, STORE);
 192         clib_prefetch_store (p2->data);
 193         vlib_prefetch_buffer_header (p3, STORE);
 194         clib_prefetch_store (p3->data);
 195       }
 196
 197       bi0 = from[0];
 198       b0 = vlib_get_buffer (vm, bi0);
 199       h0 = vlib_buffer_get_current (b0);
 200
 201       bi1 = from[1];
 202       b1 = vlib_get_buffer (vm, bi1);
 203       h1 = vlib_buffer_get_current (b1);
 204
 205       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 206       vnet_buffer (b0)->l2_classify.table_index = ~0;
 207
 208       sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
 209       vnet_buffer (b1)->l2_classify.table_index = ~0;
 210
 211       /* Select classifier table based on ethertype */
 212       type0 = clib_net_to_host_u16 (h0->type);
 213       type1 = clib_net_to_host_u16 (h1->type);
 214
 215       type_index0 = (type0 == ETHERNET_TYPE_IP4)
 216         ? L2_INPUT_CLASSIFY_TABLE_IP4 : L2_INPUT_CLASSIFY_TABLE_OTHER;
 217       type_index0 = (type0 == ETHERNET_TYPE_IP6)
 218         ? L2_INPUT_CLASSIFY_TABLE_IP6 : type_index0;
 219
 220       type_index1 = (type1 == ETHERNET_TYPE_IP4)
 221         ? L2_INPUT_CLASSIFY_TABLE_IP4 : L2_INPUT_CLASSIFY_TABLE_OTHER;
 222       type_index1 = (type1 == ETHERNET_TYPE_IP6)
 223         ? L2_INPUT_CLASSIFY_TABLE_IP6 : type_index1;
 224
 225       vnet_buffer (b0)->l2_classify.table_index =
 226         table_index0 =
 227         rt->l2cm->classify_table_index_by_sw_if_index
 228         [type_index0][sw_if_index0];
 229
 230       if (table_index0 != ~0)
 231         {
 232           t0 = pool_elt_at_index (vcm->tables, table_index0);
 233
 234           vnet_buffer (b0)->l2_classify.hash = hash0 =
 235             vnet_classify_hash_packet (t0, (u8 *) h0);
 236           vnet_classify_prefetch_bucket (t0, hash0);
 237         }
 238
 239       vnet_buffer (b1)->l2_classify.table_index =
 240         table_index1 =
 241         rt->l2cm->classify_table_index_by_sw_if_index
 242         [type_index1][sw_if_index1];
 243
 244       if (table_index1 != ~0)
 245         {
 246           t1 = pool_elt_at_index (vcm->tables, table_index1);
 247
 248           vnet_buffer (b1)->l2_classify.hash = hash1 =
 249             vnet_classify_hash_packet (t1, (u8 *) h1);
 250           vnet_classify_prefetch_bucket (t1, hash1);
 251         }
 252
 253       from += 2;
 254       n_left_from -= 2;
 255     }
 256
 257   while (n_left_from > 0)
 258     {
 259       vlib_buffer_t *b0;
 260       u32 bi0;
 261       ethernet_header_t *h0;
 262       u32 sw_if_index0;
 263       u16 type0;
 264       u32 type_index0;
 265       vnet_classify_table_t *t0;
 266       u32 table_index0;
 267       u32 hash0;
 268
 269       bi0 = from[0];
 270       b0 = vlib_get_buffer (vm, bi0);
 271       h0 = vlib_buffer_get_current (b0);
 272
 273       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 274       vnet_buffer (b0)->l2_classify.table_index = ~0;
 275
 276       /* Select classifier table based on ethertype */
 277       type0 = clib_net_to_host_u16 (h0->type);
 278
 279       type_index0 = (type0 == ETHERNET_TYPE_IP4)
 280         ? L2_INPUT_CLASSIFY_TABLE_IP4 : L2_INPUT_CLASSIFY_TABLE_OTHER;
 281       type_index0 = (type0 == ETHERNET_TYPE_IP6)
 282         ? L2_INPUT_CLASSIFY_TABLE_IP6 : type_index0;
 283
 284       vnet_buffer (b0)->l2_classify.table_index =
 285         table_index0 = rt->l2cm->classify_table_index_by_sw_if_index
 286         [type_index0][sw_if_index0];
 287
 288       if (table_index0 != ~0)
 289         {
 290           t0 = pool_elt_at_index (vcm->tables, table_index0);
 291
 292           vnet_buffer (b0)->l2_classify.hash = hash0 =
 293             vnet_classify_hash_packet (t0, (u8 *) h0);
 294           vnet_classify_prefetch_bucket (t0, hash0);
 295         }
 296       from++;
 297       n_left_from--;
 298     }
 299
 300   next_index = node->cached_next_index;
 301   from = vlib_frame_vector_args (frame);
 302   n_left_from = frame->n_vectors;
 303
 304   while (n_left_from > 0)
 305     {
 306       u32 n_left_to_next;
 307
 308       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 309
 310       /* Not enough load/store slots to dual loop... */
 311       while (n_left_from > 0 && n_left_to_next > 0)
 312         {
 313           u32 bi0;
 314           vlib_buffer_t *b0;
 315           u32 next0 = ~0;       /* next l2 input feature, please... */
 316           ethernet_header_t *h0;
 317           u32 table_index0;
 318           u32 hash0;
 319           vnet_classify_table_t *t0;
 320           vnet_classify_entry_t *e0;
 321
 322           if (PREDICT_TRUE (n_left_from > 2))
 323             {
 324               vlib_buffer_t *p2 = vlib_get_buffer (vm, from[2]);
 325               u32 phash2;
 326               u32 table_index2;
 327               vnet_classify_table_t *tp2;
 328
 329               /*
 330                * Prefetch table entry two ahead. Buffer / data
 331                * were prefetched above...
 332                */
 333               table_index2 = vnet_buffer (p2)->l2_classify.table_index;
 334
 335               if (PREDICT_TRUE (table_index2 != ~0))
 336                 {
 337                   tp2 = pool_elt_at_index (vcm->tables, table_index2);
 338                   phash2 = vnet_buffer (p2)->l2_classify.hash;
 339                   vnet_classify_prefetch_entry (tp2, phash2);
 340                 }
 341             }
 342
 343           /* speculatively enqueue b0 to the current next frame */
 344           bi0 = from[0];
 345           to_next[0] = bi0;
 346           from += 1;
 347           to_next += 1;
 348           n_left_from -= 1;
 349           n_left_to_next -= 1;
 350
 351           b0 = vlib_get_buffer (vm, bi0);
 352           h0 = vlib_buffer_get_current (b0);
 353           table_index0 = vnet_buffer (b0)->l2_classify.table_index;
 354           e0 = 0;
 355           vnet_buffer (b0)->l2_classify.opaque_index = ~0;
 356
 357           if (PREDICT_TRUE (table_index0 != ~0))
 358             {
 359               hash0 = vnet_buffer (b0)->l2_classify.hash;
 360               t0 = pool_elt_at_index (vcm->tables, table_index0);
 361
 362               e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
 363               if (e0)
 364                 {
 365                   vnet_buffer (b0)->l2_classify.opaque_index
 366                     = e0->opaque_index;
 367                   vlib_buffer_advance (b0, e0->advance);
 368                   next0 = (e0->next_index < n_next_nodes) ?
 369                     e0->next_index : next0;
 370                   hits++;
 371                 }
 372               else
 373                 {
 374                   while (1)
 375                     {
 376                       if (t0->next_table_index != ~0)
 377                         t0 = pool_elt_at_index (vcm->tables,
 378                                                 t0->next_table_index);
 379                       else
 380                         {
 381                           next0 = (t0->miss_next_index < n_next_nodes) ?
 382                             t0->miss_next_index : next0;
 383                           misses++;
 384                           break;
 385                         }
 386
 387                       hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
 388                       e0 =
 389                         vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
 390                       if (e0)
 391                         {
 392                           vnet_buffer (b0)->l2_classify.opaque_index
 393                             = e0->opaque_index;
 394                           vlib_buffer_advance (b0, e0->advance);
 395                           next0 = (e0->next_index < n_next_nodes) ?
 396                             e0->next_index : next0;
 397                           hits++;
 398                           chain_hits++;
 399                           break;
 400                         }
 401                     }
 402                 }
 403             }
 404
 405           if (PREDICT_FALSE (next0 == 0))
 406             b0->error = node->errors[L2_INPUT_CLASSIFY_ERROR_DROP];
 407
 408           /* Determine the next node and remove ourself from bitmap */
 409           if (PREDICT_TRUE (next0 == ~0))
 410             next0 = vnet_l2_feature_next (b0, cm->l2_inp_feat_next,
 411                                           L2INPUT_FEAT_INPUT_CLASSIFY);
 412           else
 413             vnet_buffer (b0)->l2.feature_bitmap &=
 414               ~L2INPUT_FEAT_INPUT_CLASSIFY;
 415
 416           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
 417                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
 418             {
 419               l2_input_classify_trace_t *t =
 420                 vlib_add_trace (vm, node, b0, sizeof (*t));
 421               t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 422               t->table_index = table_index0;
 423               t->next_index = next0;
 424               t->session_offset = e0 ? vnet_classify_get_offset (t0, e0) : 0;
 425             }
 426
 427           /* verify speculative enqueue, maybe switch current next frame */
 428           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 429                                            to_next, n_left_to_next,
 430                                            bi0, next0);
 431         }
 432
 433       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 434     }
 435
 436   vlib_node_increment_counter (vm, node->node_index,
 437                                L2_INPUT_CLASSIFY_ERROR_MISS, misses);
 438   vlib_node_increment_counter (vm, node->node_index,
 439                                L2_INPUT_CLASSIFY_ERROR_HIT, hits);
 440   vlib_node_increment_counter (vm, node->node_index,
 441                                L2_INPUT_CLASSIFY_ERROR_CHAIN_HIT, chain_hits);
 442   return frame->n_vectors;
 443 }
 444
 445 VLIB_REGISTER_NODE (l2_input_classify_node) = {
 446   .name = "l2-input-classify",
 447   .vector_size = sizeof (u32),
 448   .format_trace = format_l2_input_classify_trace,
 449   .type = VLIB_NODE_TYPE_INTERNAL,
 450
 451   .n_errors = ARRAY_LEN(l2_input_classify_error_strings),
 452   .error_strings = l2_input_classify_error_strings,
 453
 454   .runtime_data_bytes = sizeof (l2_input_classify_runtime_t),
 455
 456   .n_next_nodes = L2_INPUT_CLASSIFY_N_NEXT,
 457
 458   /* edit / add dispositions here */
 459   .next_nodes = {
 460     [L2_INPUT_CLASSIFY_NEXT_DROP]  = "error-drop",
 461     [L2_INPUT_CLASSIFY_NEXT_ETHERNET_INPUT] = "ethernet-input-not-l2",
 462     [L2_INPUT_CLASSIFY_NEXT_IP4_INPUT] = "ip4-input",
 463     [L2_INPUT_CLASSIFY_NEXT_IP6_INPUT] = "ip6-input",
 464   },
 465 };
 466
 467 #ifndef CLIB_MARCH_VARIANT
 468 /** l2 input classsifier feature initialization. */
 469 clib_error_t *
 470 l2_input_classify_init (vlib_main_t * vm)
 471 {
 472   l2_input_classify_main_t *cm = &l2_input_classify_main;
 473   l2_input_classify_runtime_t *rt;
 474
 475   rt = vlib_node_get_runtime_data (vm, l2_input_classify_node.index);
 476
 477   cm->vlib_main = vm;
 478   cm->vnet_main = vnet_get_main ();
 479   cm->vnet_classify_main = &vnet_classify_main;
 480
 481   /* Initialize the feature next-node indexes */
 482   feat_bitmap_init_next_nodes (vm,
 483                                l2_input_classify_node.index,
 484                                L2INPUT_N_FEAT,
 485                                l2input_get_feat_names (),
 486                                cm->l2_inp_feat_next);
 487   rt->l2cm = cm;
 488   rt->vcm = cm->vnet_classify_main;
 489
 490   return 0;
 491 }
 492
 493 VLIB_INIT_FUNCTION (l2_input_classify_init);
 494
 495 clib_error_t *
 496 l2_input_classify_worker_init (vlib_main_t * vm)
 497 {
 498   l2_input_classify_main_t *cm = &l2_input_classify_main;
 499   l2_input_classify_runtime_t *rt;
 500
 501   rt = vlib_node_get_runtime_data (vm, l2_input_classify_node.index);
 502
 503   rt->l2cm = cm;
 504   rt->vcm = cm->vnet_classify_main;
 505
 506   return 0;
 507 }
 508
 509 VLIB_WORKER_INIT_FUNCTION (l2_input_classify_worker_init);
 510
 511 /** Enable/disable l2 input classification on a specific interface. */
 512 void
 513 vnet_l2_input_classify_enable_disable (u32 sw_if_index, int enable_disable)
 514 {
 515   l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_INPUT_CLASSIFY,
 516                               (u32) enable_disable);
 517 }
 518
 519 /** @brief Set l2 per-protocol, per-interface input classification tables.
 520  *
 521  *  @param sw_if_index  interface handle
 522  *  @param ip4_table_index  ip4 classification table index, or ~0
 523  *  @param ip6_table_index  ip6 classification table index, or ~0
 524  *  @param other_table_index  non-ip4, non-ip6 classification table index,
 525  *         or ~0
 526  *  @returns 0 on success, VNET_API_ERROR_NO_SUCH_TABLE, TABLE2, TABLE3
 527  *  if the indicated (non-~0) table does not exist.
 528  */
 529
 530 int
 531 vnet_l2_input_classify_set_tables (u32 sw_if_index,
 532                                    u32 ip4_table_index,
 533                                    u32 ip6_table_index, u32 other_table_index)
 534 {
 535   l2_input_classify_main_t *cm = &l2_input_classify_main;
 536   vnet_classify_main_t *vcm = cm->vnet_classify_main;
 537
 538   /* Assume that we've validated sw_if_index in the API layer */
 539
 540   if (ip4_table_index != ~0 &&
 541       pool_is_free_index (vcm->tables, ip4_table_index))
 542     return VNET_API_ERROR_NO_SUCH_TABLE;
 543
 544   if (ip6_table_index != ~0 &&
 545       pool_is_free_index (vcm->tables, ip6_table_index))
 546     return VNET_API_ERROR_NO_SUCH_TABLE2;
 547
 548   if (other_table_index != ~0 &&
 549       pool_is_free_index (vcm->tables, other_table_index))
 550     return VNET_API_ERROR_NO_SUCH_TABLE3;
 551
 552   vec_validate
 553     (cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4],
 554      sw_if_index);
 555
 556   vec_validate
 557     (cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6],
 558      sw_if_index);
 559
 560   vec_validate
 561     (cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER],
 562      sw_if_index);
 563
 564   cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4]
 565     [sw_if_index] = ip4_table_index;
 566
 567   cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6]
 568     [sw_if_index] = ip6_table_index;
 569
 570   cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER]
 571     [sw_if_index] = other_table_index;
 572
 573   return 0;
 574 }
 575 #endif /* CLIB_MARCH_VARIANT */
 576
 577 static clib_error_t *
 578 int_l2_input_classify_command_fn (vlib_main_t * vm,
 579                                   unformat_input_t * input,
 580                                   vlib_cli_command_t * cmd)
 581 {
 582   vnet_main_t *vnm = vnet_get_main ();
 583   u32 sw_if_index = ~0;
 584   u32 ip4_table_index = ~0;
 585   u32 ip6_table_index = ~0;
 586   u32 other_table_index = ~0;
 587   int rv;
 588
 589   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 590     {
 591       if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
 592                     vnm, &sw_if_index))
 593         ;
 594       else if (unformat (input, "ip4-table %d", &ip4_table_index))
 595         ;
 596       else if (unformat (input, "ip6-table %d", &ip6_table_index))
 597         ;
 598       else if (unformat (input, "other-table %d", &other_table_index))
 599         ;
 600       else
 601         break;
 602     }
 603
 604   if (sw_if_index == ~0)
 605     return clib_error_return (0, "interface must be specified");
 606
 607
 608   if (ip4_table_index == ~0 && ip6_table_index == ~0
 609       && other_table_index == ~0)
 610     {
 611       vlib_cli_output (vm, "L2 classification disabled");
 612       vnet_l2_input_classify_enable_disable (sw_if_index, 0 /* enable */ );
 613       return 0;
 614     }
 615
 616   rv = vnet_l2_input_classify_set_tables (sw_if_index, ip4_table_index,
 617                                           ip6_table_index, other_table_index);
 618   switch (rv)
 619     {
 620     case 0:
 621       vnet_l2_input_classify_enable_disable (sw_if_index, 1 /* enable */ );
 622       break;
 623
 624     default:
 625       return clib_error_return (0, "vnet_l2_input_classify_set_tables: %d",
 626                                 rv);
 627       break;
 628     }
 629
 630   return 0;
 631 }
 632
 633 /*?
 634  * Configure l2 input classification.
 635  *
 636  * @cliexpar
 637  * @cliexstart{set interface l2 input classify intfc <interface-name> [ip4-table <index>] [ip6-table <index>] [other-table <index>]}
 638  * @cliexend
 639  * @todo This is incomplete. This needs a detailed description and a
 640  * practical example.
 641  ?*/
 642 VLIB_CLI_COMMAND (int_l2_input_classify_cli, static) = {
 643   .path = "set interface l2 input classify",
 644   .short_help =
 645   "set interface l2 input classify intfc <interface-name> [ip4-table <n>]\n"
 646   "  [ip6-table <n>] [other-table <n>]",
 647   .function = int_l2_input_classify_command_fn,
 648 };
 649
 650 /*
 651  * fd.io coding-style-patch-verification: ON
 652  *
 653  * Local Variables:
 654  * eval: (c-set-style "gnu")
 655  * End:
 656  */