vnet/vnet/ethernet/node.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  * ethernet_node.c: ethernet packet processing
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vlib/vlib.h>
  41 #include <vnet/pg/pg.h>
  42 #include <vnet/ethernet/ethernet.h>
  43 #include <vppinfra/sparse_vec.h>
  44 #include <vnet/l2/l2_bvi.h>
  45
  46
  47 #define foreach_ethernet_input_next             \
  48   _ (PUNT, "error-punt")                        \
  49   _ (DROP, "error-drop")                        \
  50   _ (LLC, "llc-input")
  51
  52 typedef enum {
  53 #define _(s,n) ETHERNET_INPUT_NEXT_##s,
  54   foreach_ethernet_input_next
  55 #undef _
  56   ETHERNET_INPUT_N_NEXT,
  57 } ethernet_input_next_t;
  58
  59 typedef struct {
  60   u8 packet_data[32];
  61 } ethernet_input_trace_t;
  62
  63 static u8 * format_ethernet_input_trace (u8 * s, va_list * va)
  64 {
  65   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
  66   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
  67   ethernet_input_trace_t * t = va_arg (*va, ethernet_input_trace_t *);
  68
  69   s = format (s, "%U", format_ethernet_header, t->packet_data);
  70
  71   return s;
  72 }
  73
  74 vlib_node_registration_t ethernet_input_node;
  75
  76 typedef enum {
  77   ETHERNET_INPUT_VARIANT_ETHERNET,
  78   ETHERNET_INPUT_VARIANT_ETHERNET_TYPE,
  79   ETHERNET_INPUT_VARIANT_VLAN,
  80   ETHERNET_INPUT_VARIANT_NOT_L2,
  81 } ethernet_input_variant_t;
  82
  83
  84 // Compare two ethernet macs. Return 1 if they are the same, 0 if different
  85 static_always_inline u32
  86 eth_mac_equal (u8 * mac1, u8 * mac2) {
  87   return (*((u32 *)(mac1+0)) == *((u32 *)(mac2+0)) &&
  88           *((u32 *)(mac1+2)) == *((u32 *)(mac2+2)));
  89 }
  90
  91
  92 // Parse the ethernet header to extract vlan tags and innermost ethertype
  93 static_always_inline void
  94 parse_header (ethernet_input_variant_t variant,
  95               vlib_buffer_t * b0,
  96               u16 * type,
  97               u16 * orig_type,
  98               u16 * outer_id,
  99               u16 * inner_id,
 100               u32 * match_flags) {
 101
 102   if (variant == ETHERNET_INPUT_VARIANT_ETHERNET
 103       || variant == ETHERNET_INPUT_VARIANT_NOT_L2) {
 104     ethernet_header_t * e0;
 105
 106     e0 = (void *) (b0->data + b0->current_data);
 107
 108     vnet_buffer (b0)->ethernet.start_of_ethernet_header = b0->current_data;
 109
 110     vlib_buffer_advance (b0, sizeof (e0[0]));
 111
 112     *type = clib_net_to_host_u16(e0->type);
 113   } else if (variant == ETHERNET_INPUT_VARIANT_ETHERNET_TYPE) {
 114     // here when prior node was LLC/SNAP processing
 115     u16 * e0;
 116
 117     e0 = (void *) (b0->data + b0->current_data);
 118
 119     vlib_buffer_advance (b0, sizeof (e0[0]));
 120
 121     *type = clib_net_to_host_u16(e0[0]);
 122   }
 123
 124   // save for distinguishing between dot1q and dot1ad later
 125   *orig_type = *type;
 126
 127   // default the tags to 0 (used if there is no corresponding tag)
 128   *outer_id = 0;
 129   *inner_id = 0;
 130
 131   *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_0_TAG;
 132
 133   // check for vlan encaps
 134   if ((*type == ETHERNET_TYPE_VLAN) ||
 135       (*type == ETHERNET_TYPE_DOT1AD) ||
 136       (*type == ETHERNET_TYPE_VLAN_9100) ||
 137       (*type == ETHERNET_TYPE_VLAN_9200))
 138   {
 139     ethernet_vlan_header_t * h0;
 140     u16 tag;
 141
 142     *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_1_TAG;
 143
 144     h0 = (void *) (b0->data + b0->current_data);
 145
 146     tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
 147
 148     *outer_id = tag & 0xfff;
 149
 150     *type = clib_net_to_host_u16(h0->type);
 151
 152     vlib_buffer_advance (b0, sizeof (h0[0]));
 153
 154     if (*type == ETHERNET_TYPE_VLAN) {
 155       // Double tagged packet
 156       *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_2_TAG;
 157
 158       h0 = (void *) (b0->data + b0->current_data);
 159
 160       tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
 161
 162       *inner_id = tag & 0xfff;
 163
 164       *type = clib_net_to_host_u16(h0->type);
 165
 166       vlib_buffer_advance (b0, sizeof (h0[0]));
 167
 168       if (*type == ETHERNET_TYPE_VLAN) {
 169         // More than double tagged packet
 170         *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_3_TAG;
 171       }
 172     }
 173   }
 174 }
 175
 176 // Determine the subinterface for this packet, given the result of the
 177 // vlan table lookups and vlan header parsing. Check the most specific
 178 // matches first.
 179 static_always_inline void
 180 identify_subint (vnet_hw_interface_t * hi,
 181                  vlib_buffer_t * b0,
 182                  u32 match_flags,
 183                  main_intf_t * main_intf,
 184                  vlan_intf_t * vlan_intf,
 185                  qinq_intf_t * qinq_intf,
 186                  u32 * new_sw_if_index,
 187                  u8 * error0,
 188                  u32 * is_l2)
 189 {
 190   u32 matched;
 191
 192   matched = eth_identify_subint (hi, b0, match_flags,
 193                                  main_intf, vlan_intf, qinq_intf,
 194                                  new_sw_if_index, error0, is_l2);
 195
 196   if (matched) {
 197
 198     // Perform L3 my-mac filter
 199     // A unicast packet arriving on an L3 interface must have a dmac matching the interface mac.
 200     // This is required for promiscuous mode, else we will forward packets we aren't supposed to.
 201     if (!(*is_l2)) {
 202       ethernet_header_t * e0;
 203       e0 = (void *) (b0->data + vnet_buffer (b0)->ethernet.start_of_ethernet_header);
 204
 205       if (!(ethernet_address_cast(e0->dst_address))) {
 206         if (!eth_mac_equal((u8 *)e0, hi->hw_address)) {
 207           *error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
 208         }
 209       }
 210     }
 211
 212     // Check for down subinterface
 213     *error0 = (*new_sw_if_index) != ~0 ? (*error0) : ETHERNET_ERROR_DOWN;
 214   }
 215 }
 216
 217 static_always_inline void
 218 determine_next_node (ethernet_main_t * em,
 219                      ethernet_input_variant_t variant,
 220                      u32 is_l20,
 221                      u32 type0,
 222                      vlib_buffer_t * b0,
 223                      u8 * error0,
 224                      u8 * next0)
 225 {
 226   if (PREDICT_FALSE (*error0 != ETHERNET_ERROR_NONE)) {
 227     // some error occurred
 228     *next0 = ETHERNET_INPUT_NEXT_DROP;
 229   } else if (is_l20) {
 230     *next0 = em->l2_next;
 231     // record the L2 len and reset the buffer so the L2 header is preserved
 232     vnet_buffer(b0)->l2.l2_len = b0->current_data;
 233     vlib_buffer_advance (b0, -(b0->current_data));
 234
 235   // check for common IP/MPLS ethertypes
 236   } else if (type0 == ETHERNET_TYPE_IP4) {
 237     *next0 = em->l3_next.input_next_ip4;
 238   } else if (type0 == ETHERNET_TYPE_IP6) {
 239     *next0 = em->l3_next.input_next_ip6;
 240   } else if (type0 == ETHERNET_TYPE_MPLS_UNICAST) {
 241     *next0 = em->l3_next.input_next_mpls;
 242
 243   } else if (em->redirect_l3) {
 244     // L3 Redirect is on, the cached common next nodes will be
 245     // pointing to the redirect node, catch the uncommon types here
 246     *next0 = em->redirect_l3_next;
 247   } else {
 248     // uncommon ethertype, check table
 249     u32 i0;
 250     i0 = sparse_vec_index (em->l3_next.input_next_by_type, type0);
 251     *next0 = vec_elt (em->l3_next.input_next_by_type, i0);
 252     *error0 = i0 == SPARSE_VEC_INVALID_INDEX ? ETHERNET_ERROR_UNKNOWN_TYPE : *error0;
 253
 254     // The table is not populated with LLC values, so check that now.
 255     // If variant is variant_ethernet then we came from LLC processing. Don't
 256     // go back there; drop instead using by keeping the drop/bad table result.
 257     if ((type0 < 0x600) && (variant == ETHERNET_INPUT_VARIANT_ETHERNET)) {
 258       *next0 = ETHERNET_INPUT_NEXT_LLC;
 259     }
 260   }
 261 }
 262
 263 static_always_inline uword
 264 ethernet_input_inline (vlib_main_t * vm,
 265                        vlib_node_runtime_t * node,
 266                        vlib_frame_t * from_frame,
 267                        ethernet_input_variant_t variant)
 268 {
 269   vnet_main_t * vnm = vnet_get_main();
 270   ethernet_main_t * em = &ethernet_main;
 271   vlib_node_runtime_t * error_node;
 272   u32 n_left_from, next_index, * from, * to_next;
 273   u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
 274   u32 cpu_index = os_get_cpu_number();
 275
 276   if (variant != ETHERNET_INPUT_VARIANT_ETHERNET)
 277     error_node = vlib_node_get_runtime (vm, ethernet_input_node.index);
 278   else
 279     error_node = node;
 280
 281   from = vlib_frame_vector_args (from_frame);
 282   n_left_from = from_frame->n_vectors;
 283
 284   if (node->flags & VLIB_NODE_FLAG_TRACE)
 285     vlib_trace_frame_buffers_only (vm, node,
 286                                    from,
 287                                    n_left_from,
 288                                    sizeof (from[0]),
 289                                    sizeof (ethernet_input_trace_t));
 290
 291   next_index = node->cached_next_index;
 292   stats_sw_if_index = node->runtime_data[0];
 293   stats_n_packets = stats_n_bytes = 0;
 294
 295   while (n_left_from > 0)
 296     {
 297       u32 n_left_to_next;
 298
 299       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 300
 301       while (n_left_from >= 4 && n_left_to_next >= 2)
 302         {
 303           u32 bi0, bi1;
 304           vlib_buffer_t * b0, * b1;
 305           u8 next0, next1, error0, error1;
 306           u16 type0, orig_type0, type1, orig_type1;
 307           u16 outer_id0, inner_id0, outer_id1, inner_id1;
 308           u32 match_flags0, match_flags1;
 309           u32 old_sw_if_index0, new_sw_if_index0, len0, old_sw_if_index1, new_sw_if_index1, len1;
 310           vnet_hw_interface_t * hi0, * hi1;
 311           main_intf_t * main_intf0, * main_intf1;
 312           vlan_intf_t * vlan_intf0, * vlan_intf1;
 313           qinq_intf_t * qinq_intf0, * qinq_intf1;
 314           u32 is_l20, is_l21;
 315
 316           /* Prefetch next iteration. */
 317           {
 318             vlib_buffer_t * b2, * b3;
 319
 320             b2 = vlib_get_buffer (vm, from[2]);
 321             b3 = vlib_get_buffer (vm, from[3]);
 322
 323             vlib_prefetch_buffer_header (b2, STORE);
 324             vlib_prefetch_buffer_header (b3, STORE);
 325
 326             CLIB_PREFETCH (b2->data, sizeof (ethernet_header_t), LOAD);
 327             CLIB_PREFETCH (b3->data, sizeof (ethernet_header_t), LOAD);
 328           }
 329
 330           bi0 = from[0];
 331           bi1 = from[1];
 332           to_next[0] = bi0;
 333           to_next[1] = bi1;
 334           from += 2;
 335           to_next += 2;
 336           n_left_to_next -= 2;
 337           n_left_from -= 2;
 338
 339           b0 = vlib_get_buffer (vm, bi0);
 340           b1 = vlib_get_buffer (vm, bi1);
 341
 342           error0 = error1 = ETHERNET_ERROR_NONE;
 343
 344           parse_header (variant,
 345                         b0,
 346                         &type0,
 347                         &orig_type0,
 348                         &outer_id0,
 349                         &inner_id0,
 350                         &match_flags0);
 351
 352           parse_header (variant,
 353                         b1,
 354                         &type1,
 355                         &orig_type1,
 356                         &outer_id1,
 357                         &inner_id1,
 358                         &match_flags1);
 359
 360           old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 361           old_sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
 362
 363           eth_vlan_table_lookups (em,
 364                               vnm,
 365                               old_sw_if_index0,
 366                               orig_type0,
 367                               outer_id0,
 368                               inner_id0,
 369                               &hi0,
 370                               &main_intf0,
 371                               &vlan_intf0,
 372                               &qinq_intf0);
 373
 374           eth_vlan_table_lookups (em,
 375                               vnm,
 376                               old_sw_if_index1,
 377                               orig_type1,
 378                               outer_id1,
 379                               inner_id1,
 380                               &hi1,
 381                               &main_intf1,
 382                               &vlan_intf1,
 383                               &qinq_intf1);
 384
 385           identify_subint (hi0,
 386                            b0,
 387                            match_flags0,
 388                            main_intf0,
 389                            vlan_intf0,
 390                            qinq_intf0,
 391                            &new_sw_if_index0,
 392                            &error0,
 393                            &is_l20);
 394
 395           identify_subint (hi1,
 396                            b1,
 397                            match_flags1,
 398                            main_intf1,
 399                            vlan_intf1,
 400                            qinq_intf1,
 401                            &new_sw_if_index1,
 402                            &error1,
 403                            &is_l21);
 404
 405           // Save RX sw_if_index for later nodes
 406           vnet_buffer (b0)->sw_if_index[VLIB_RX] = error0 != ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
 407           vnet_buffer (b1)->sw_if_index[VLIB_RX] = error1 != ETHERNET_ERROR_NONE ? old_sw_if_index1 : new_sw_if_index1;
 408
 409           // Check if there is a stat to take (valid and non-main sw_if_index for pkt 0 or pkt 1)
 410           if (((new_sw_if_index0 != ~0) && (new_sw_if_index0 != old_sw_if_index0)) ||
 411               ((new_sw_if_index1 != ~0) && (new_sw_if_index1 != old_sw_if_index1))) {
 412
 413             len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
 414                    - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
 415             len1 = vlib_buffer_length_in_chain (vm, b1) + b1->current_data
 416                    - vnet_buffer (b1)->ethernet.start_of_ethernet_header;
 417
 418             stats_n_packets += 2;
 419             stats_n_bytes += len0 + len1;
 420
 421               if (PREDICT_FALSE (! (new_sw_if_index0 == stats_sw_if_index && new_sw_if_index1 == stats_sw_if_index)))
 422                 {
 423                   stats_n_packets -= 2;
 424                   stats_n_bytes -= len0 + len1;
 425
 426                   if (new_sw_if_index0 != old_sw_if_index0 && new_sw_if_index0 != ~0)
 427                     vlib_increment_combined_counter
 428                         (vnm->interface_main.combined_sw_if_counters
 429                          + VNET_INTERFACE_COUNTER_RX,
 430                          cpu_index,
 431                          new_sw_if_index0,
 432                          1,
 433                          len0);
 434                   if (new_sw_if_index1 != old_sw_if_index1 && new_sw_if_index1 != ~0)
 435                     vlib_increment_combined_counter
 436                         (vnm->interface_main.combined_sw_if_counters
 437                          + VNET_INTERFACE_COUNTER_RX,
 438                          cpu_index,
 439                          new_sw_if_index1,
 440                          1,
 441                          len1);
 442
 443                   if (new_sw_if_index0 == new_sw_if_index1)
 444                     {
 445                       if (stats_n_packets > 0)
 446                         {
 447                           vlib_increment_combined_counter
 448                               (vnm->interface_main.combined_sw_if_counters
 449                                + VNET_INTERFACE_COUNTER_RX,
 450                                cpu_index,
 451                                stats_sw_if_index,
 452                                stats_n_packets,
 453                                stats_n_bytes);
 454                           stats_n_packets = stats_n_bytes = 0;
 455                         }
 456                       stats_sw_if_index = new_sw_if_index0;
 457                     }
 458                 }
 459             }
 460
 461           if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
 462               is_l20 = is_l21 = 0;
 463
 464           determine_next_node(em, variant, is_l20, type0, b0, &error0, &next0);
 465           determine_next_node(em, variant, is_l21, type1, b1, &error1, &next1);
 466
 467           b0->error = error_node->errors[error0];
 468           b1->error = error_node->errors[error1];
 469
 470           // verify speculative enqueue
 471           vlib_validate_buffer_enqueue_x2(vm,node,next_index,to_next,n_left_to_next,bi0,bi1,next0,next1);
 472         }
 473
 474       while (n_left_from > 0 && n_left_to_next > 0)
 475         {
 476           u32 bi0;
 477           vlib_buffer_t * b0;
 478           u8 error0, next0;
 479           u16 type0, orig_type0;
 480           u16 outer_id0, inner_id0;
 481           u32 match_flags0;
 482           u32 old_sw_if_index0, new_sw_if_index0, len0;
 483           vnet_hw_interface_t * hi0;
 484           main_intf_t * main_intf0;
 485           vlan_intf_t * vlan_intf0;
 486           qinq_intf_t * qinq_intf0;
 487           u32 is_l20;
 488
 489           // Prefetch next iteration
 490           if (n_left_from > 1) {
 491             vlib_buffer_t * p2;
 492
 493             p2 = vlib_get_buffer (vm, from[1]);
 494             vlib_prefetch_buffer_header (p2, STORE);
 495             CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, LOAD);
 496           }
 497
 498           bi0 = from[0];
 499           to_next[0] = bi0;
 500           from += 1;
 501           to_next += 1;
 502           n_left_from -= 1;
 503           n_left_to_next -= 1;
 504
 505           b0 = vlib_get_buffer (vm, bi0);
 506
 507           error0 = ETHERNET_ERROR_NONE;
 508
 509           parse_header (variant,
 510                         b0,
 511                         &type0,
 512                         &orig_type0,
 513                         &outer_id0,
 514                         &inner_id0,
 515                         &match_flags0);
 516
 517           old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 518
 519           eth_vlan_table_lookups (em,
 520                               vnm,
 521                               old_sw_if_index0,
 522                               orig_type0,
 523                               outer_id0,
 524                               inner_id0,
 525                               &hi0,
 526                               &main_intf0,
 527                               &vlan_intf0,
 528                               &qinq_intf0);
 529
 530           identify_subint (hi0,
 531                            b0,
 532                            match_flags0,
 533                            main_intf0,
 534                            vlan_intf0,
 535                            qinq_intf0,
 536                            &new_sw_if_index0,
 537                            &error0,
 538                            &is_l20);
 539
 540           // Save RX sw_if_index for later nodes
 541           vnet_buffer (b0)->sw_if_index[VLIB_RX] = error0 != ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
 542
 543           // Increment subinterface stats
 544           // Note that interface-level counters have already been incremented
 545           // prior to calling this function. Thus only subinterface counters
 546           // are incremented here.
 547           //
 548           // Interface level counters include packets received on the main
 549           // interface and all subinterfaces. Subinterface level counters
 550           // include only those packets received on that subinterface
 551           // Increment stats if the subint is valid and it is not the main intf
 552           if ((new_sw_if_index0 != ~0) && (new_sw_if_index0 != old_sw_if_index0)) {
 553
 554             len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
 555                 - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
 556
 557             stats_n_packets += 1;
 558             stats_n_bytes += len0;
 559
 560             // Batch stat increments from the same subinterface so counters
 561             // don't need to be incremented for every packet.
 562             if (PREDICT_FALSE (new_sw_if_index0 != stats_sw_if_index)) {
 563               stats_n_packets -= 1;
 564               stats_n_bytes -= len0;
 565
 566               if (new_sw_if_index0 != ~0)
 567                 vlib_increment_combined_counter
 568                     (vnm->interface_main.combined_sw_if_counters
 569                      + VNET_INTERFACE_COUNTER_RX,
 570                      cpu_index,
 571                      new_sw_if_index0,
 572                      1,
 573                      len0);
 574               if (stats_n_packets > 0) {
 575                 vlib_increment_combined_counter
 576                     (vnm->interface_main.combined_sw_if_counters
 577                      + VNET_INTERFACE_COUNTER_RX,
 578                      cpu_index,
 579                      stats_sw_if_index,
 580                      stats_n_packets,
 581                      stats_n_bytes);
 582                 stats_n_packets = stats_n_bytes = 0;
 583               }
 584               stats_sw_if_index = new_sw_if_index0;
 585             }
 586           }
 587
 588           if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
 589               is_l20 = 0;
 590
 591           determine_next_node(em, variant, is_l20, type0, b0, &error0, &next0);
 592
 593           b0->error = error_node->errors[error0];
 594
 595           // verify speculative enqueue
 596           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 597                                            to_next, n_left_to_next,
 598                                            bi0, next0);
 599         }
 600
 601       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 602     }
 603
 604     // Increment any remaining batched stats
 605     if (stats_n_packets > 0)
 606     {
 607       vlib_increment_combined_counter
 608           (vnm->interface_main.combined_sw_if_counters
 609            + VNET_INTERFACE_COUNTER_RX,
 610            cpu_index,
 611            stats_sw_if_index,
 612            stats_n_packets,
 613            stats_n_bytes);
 614       node->runtime_data[0] = stats_sw_if_index;
 615     }
 616
 617   return from_frame->n_vectors;
 618 }
 619
 620 static uword
 621 ethernet_input (vlib_main_t * vm,
 622                 vlib_node_runtime_t * node,
 623                 vlib_frame_t * from_frame)
 624 { return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_ETHERNET); }
 625
 626 static uword
 627 ethernet_input_type (vlib_main_t * vm,
 628                      vlib_node_runtime_t * node,
 629                      vlib_frame_t * from_frame)
 630 { return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_ETHERNET_TYPE); }
 631
 632 static uword
 633 ethernet_input_not_l2 (vlib_main_t * vm,
 634                        vlib_node_runtime_t * node,
 635                      vlib_frame_t * from_frame)
 636 { return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_NOT_L2); }
 637
 638
 639 // Return the subinterface config struct for the given sw_if_index
 640 // Also return via parameter the appropriate match flags for the
 641 // configured number of tags.
 642 // On error (unsupported or not ethernet) return 0.
 643 static subint_config_t *
 644 ethernet_sw_interface_get_config (vnet_main_t * vnm,
 645                                   u32 sw_if_index,
 646                                   u32 * flags,
 647                                   u32 * unsupported) {
 648   ethernet_main_t * em = &ethernet_main;
 649   vnet_hw_interface_t * hi;
 650   vnet_sw_interface_t * si;
 651   main_intf_t * main_intf;
 652   vlan_table_t * vlan_table;
 653   qinq_table_t * qinq_table;
 654   subint_config_t * subint = 0;
 655
 656   hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
 657
 658   if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) {
 659     *unsupported = 0;
 660     goto done;  // non-ethernet interface
 661   }
 662
 663   // ensure there's an entry for the main intf (shouldn't really be necessary)
 664   vec_validate (em->main_intfs, hi->hw_if_index);
 665   main_intf = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
 666
 667   // Locate the subint for the given ethernet config
 668   si = vnet_get_sw_interface (vnm, sw_if_index);
 669
 670   if (si->sub.eth.flags.default_sub) {
 671     subint = &main_intf->default_subint;
 672     *flags = SUBINT_CONFIG_MATCH_0_TAG |
 673              SUBINT_CONFIG_MATCH_1_TAG |
 674              SUBINT_CONFIG_MATCH_2_TAG |
 675              SUBINT_CONFIG_MATCH_3_TAG;
 676   } else if ((si->sub.eth.flags.no_tags) ||
 677              (si->sub.eth.raw_flags == 0)) {
 678     // if no flags are set then this is a main interface
 679     // so treat as untagged
 680     subint = &main_intf->untagged_subint;
 681     *flags = SUBINT_CONFIG_MATCH_0_TAG;
 682   } else {
 683     // one or two tags
 684     // first get the vlan table
 685     if (si->sub.eth.flags.dot1ad) {
 686       if (main_intf->dot1ad_vlans == 0) {
 687         // Allocate a vlan table from the pool
 688         pool_get(em->vlan_pool, vlan_table);
 689         main_intf->dot1ad_vlans = vlan_table - em->vlan_pool;
 690       } else {
 691         // Get ptr to existing vlan table
 692         vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
 693       }
 694     } else { // dot1q
 695       if (main_intf->dot1q_vlans == 0) {
 696         // Allocate a vlan table from the pool
 697         pool_get(em->vlan_pool, vlan_table);
 698         main_intf->dot1q_vlans = vlan_table - em->vlan_pool;
 699       } else {
 700         // Get ptr to existing vlan table
 701         vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
 702       }
 703     }
 704
 705     if (si->sub.eth.flags.one_tag) {
 706       *flags = si->sub.eth.flags.exact_match ?
 707         SUBINT_CONFIG_MATCH_1_TAG :
 708         (SUBINT_CONFIG_MATCH_1_TAG |
 709          SUBINT_CONFIG_MATCH_2_TAG |
 710          SUBINT_CONFIG_MATCH_3_TAG);
 711
 712       if (si->sub.eth.flags.outer_vlan_id_any) {
 713         // not implemented yet
 714         *unsupported =1;
 715         goto done;
 716       } else {
 717         // a single vlan, a common case
 718         subint = &vlan_table->vlans[si->sub.eth.outer_vlan_id].single_tag_subint;
 719       }
 720
 721     } else {
 722       // Two tags
 723       *flags = si->sub.eth.flags.exact_match ?
 724         SUBINT_CONFIG_MATCH_2_TAG :
 725         (SUBINT_CONFIG_MATCH_2_TAG |
 726          SUBINT_CONFIG_MATCH_3_TAG);
 727
 728       if (si->sub.eth.flags.outer_vlan_id_any && si->sub.eth.flags.inner_vlan_id_any) {
 729         // not implemented yet
 730         *unsupported = 1;
 731         goto done;
 732       }
 733
 734       if (si->sub.eth.flags.inner_vlan_id_any) {
 735         // a specific outer and "any" inner
 736         // don't need a qinq table for this
 737         subint = &vlan_table->vlans[si->sub.eth.outer_vlan_id].inner_any_subint;
 738         if (si->sub.eth.flags.exact_match) {
 739           *flags = SUBINT_CONFIG_MATCH_2_TAG;
 740         } else {
 741           *flags = SUBINT_CONFIG_MATCH_2_TAG |
 742                    SUBINT_CONFIG_MATCH_3_TAG;
 743         }
 744       } else {
 745         // a specific outer + specifc innner vlan id, a common case
 746
 747         // get the qinq table
 748         if (vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs == 0) {
 749           // Allocate a qinq table from the pool
 750           pool_get(em->qinq_pool, qinq_table);
 751           vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs = qinq_table - em->qinq_pool;
 752         } else {
 753           // Get ptr to existing qinq table
 754           qinq_table = vec_elt_at_index (em->qinq_pool, vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs);
 755         }
 756         subint = &qinq_table->vlans[si->sub.eth.inner_vlan_id].subint;
 757       }
 758     }
 759   }
 760
 761  done:
 762   return subint;
 763 }
 764
 765 clib_error_t *
 766 ethernet_sw_interface_up_down (vnet_main_t * vnm,
 767                                u32 sw_if_index,
 768                                u32 flags)
 769 {
 770   subint_config_t * subint;
 771   u32 dummy_flags;
 772   u32 dummy_unsup;
 773   clib_error_t * error = 0;
 774
 775   // Find the config for this subinterface
 776   subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags, &dummy_unsup);
 777
 778   if (subint == 0) {
 779     // not implemented yet or not ethernet
 780     goto done;
 781   }
 782
 783   subint->sw_if_index =
 784     ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? sw_if_index : ~0);
 785
 786  done:
 787   return error;
 788 }
 789
 790 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ethernet_sw_interface_up_down);
 791
 792
 793 // Set the L2/L3 mode for the subinterface
 794 void
 795 ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm,
 796                                    u32 sw_if_index,
 797                                    u32 l2)
 798 {
 799   subint_config_t *subint;
 800   u32 dummy_flags;
 801   u32 dummy_unsup;
 802   int is_port;
 803   vnet_sw_interface_t * sw = vnet_get_sw_interface (vnm, sw_if_index);
 804
 805   is_port = !(sw->type == VNET_SW_INTERFACE_TYPE_SUB);
 806
 807   // Find the config for this subinterface
 808   subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags, &dummy_unsup);
 809
 810   if (subint == 0) {
 811     // unimplemented or not ethernet
 812     goto done;
 813   }
 814
 815   // Double check that the config we found is for our interface (or the interface is down)
 816   ASSERT ((subint->sw_if_index == sw_if_index) | (subint->sw_if_index == ~0));
 817
 818   if (l2) {
 819     subint->flags |= SUBINT_CONFIG_L2;
 820     if (is_port)
 821         subint->flags |=
 822             SUBINT_CONFIG_MATCH_0_TAG | SUBINT_CONFIG_MATCH_1_TAG
 823             | SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
 824   } else {
 825     subint->flags &= ~SUBINT_CONFIG_L2;
 826     if (is_port)
 827         subint->flags &=
 828             ~(SUBINT_CONFIG_MATCH_1_TAG | SUBINT_CONFIG_MATCH_2_TAG
 829                     | SUBINT_CONFIG_MATCH_3_TAG);
 830   }
 831
 832  done:
 833   return;
 834 }
 835
 836
 837 static clib_error_t *
 838 ethernet_sw_interface_add_del (vnet_main_t * vnm,
 839                                u32 sw_if_index,
 840                                u32 is_create)
 841 {
 842   clib_error_t * error = 0;
 843   subint_config_t *subint;
 844   u32 match_flags;
 845   u32 unsupported=0;
 846
 847   // Find the config for this subinterface
 848   subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &match_flags, &unsupported);
 849
 850   if (subint == 0) {
 851     // not implemented yet or not ethernet
 852     if (unsupported) {
 853       // this is the NYI case
 854       error = clib_error_return (0, "not implemented yet");
 855     }
 856     goto done;
 857   }
 858
 859  if (!is_create) {
 860    subint->flags = 0;
 861    return error;
 862  }
 863
 864   // Initialize the subint
 865   if (subint->flags & SUBINT_CONFIG_VALID) {
 866     // Error vlan already in use
 867     error = clib_error_return (0, "vlan is already in use");
 868   } else {
 869     // Note that config is L3 by defaulty
 870     subint->flags = SUBINT_CONFIG_VALID | match_flags;
 871     subint->sw_if_index = ~0;  // because interfaces are initially down
 872   }
 873
 874  done:
 875   return error;
 876 }
 877
 878 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ethernet_sw_interface_add_del);
 879
 880 static char * ethernet_error_strings[] = {
 881 #define ethernet_error(n,c,s) s,
 882 #include "error.def"
 883 #undef ethernet_error
 884 };
 885
 886 VLIB_REGISTER_NODE (ethernet_input_node) = {
 887   .function = ethernet_input,
 888   .name = "ethernet-input",
 889   /* Takes a vector of packets. */
 890   .vector_size = sizeof (u32),
 891
 892   .n_errors = ETHERNET_N_ERROR,
 893   .error_strings = ethernet_error_strings,
 894
 895   .n_next_nodes = ETHERNET_INPUT_N_NEXT,
 896   .next_nodes = {
 897 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
 898     foreach_ethernet_input_next
 899 #undef _
 900   },
 901
 902   .format_buffer = format_ethernet_header_with_length,
 903   .format_trace = format_ethernet_input_trace,
 904   .unformat_buffer = unformat_ethernet_header,
 905 };
 906
 907 VLIB_REGISTER_NODE (ethernet_input_type_node,static) = {
 908   .function = ethernet_input_type,
 909   .name = "ethernet-input-type",
 910   /* Takes a vector of packets. */
 911   .vector_size = sizeof (u32),
 912
 913   .n_next_nodes = ETHERNET_INPUT_N_NEXT,
 914   .next_nodes = {
 915 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
 916     foreach_ethernet_input_next
 917 #undef _
 918   },
 919 };
 920
 921 VLIB_REGISTER_NODE (ethernet_input_not_l2_node,static) = {
 922   .function = ethernet_input_not_l2,
 923   .name = "ethernet-input-not-l2",
 924   /* Takes a vector of packets. */
 925   .vector_size = sizeof (u32),
 926
 927   .n_next_nodes = ETHERNET_INPUT_N_NEXT,
 928   .next_nodes = {
 929 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
 930     foreach_ethernet_input_next
 931 #undef _
 932   },
 933 };
 934
 935 void ethernet_set_rx_redirect (vnet_main_t * vnm,
 936                                vnet_hw_interface_t * hi,
 937                                u32 enable)
 938 {
 939   // Insure all packets go to ethernet-input (i.e. untagged ipv4 packets
 940   // don't go directly to ip4-input)
 941   vnet_hw_interface_rx_redirect_to_node
 942       (vnm, hi->hw_if_index, enable ? ethernet_input_node.index : ~0);
 943 }
 944
 945
 946 /*
 947  * Initialization and registration for the next_by_ethernet structure
 948  */
 949
 950 clib_error_t * next_by_ethertype_init (next_by_ethertype_t * l3_next)
 951 {
 952   l3_next->input_next_by_type = sparse_vec_new
 953     (/* elt bytes */ sizeof (l3_next->input_next_by_type[0]),
 954      /* bits in index */ BITS (((ethernet_header_t *) 0)->type));
 955
 956   vec_validate (l3_next->sparse_index_by_input_next_index, ETHERNET_INPUT_NEXT_DROP);
 957   vec_validate (l3_next->sparse_index_by_input_next_index, ETHERNET_INPUT_NEXT_PUNT);
 958   l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_DROP]
 959     = SPARSE_VEC_INVALID_INDEX;
 960   l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_PUNT]
 961     = SPARSE_VEC_INVALID_INDEX;
 962
 963   /*
 964    * Make sure we don't wipe out an ethernet registration by mistake
 965    * Can happen if init function ordering constraints are missing.
 966    */
 967   if (CLIB_DEBUG > 0)
 968     {
 969       ethernet_main_t * em = &ethernet_main;
 970       ASSERT(em->next_by_ethertype_register_called == 0);
 971     }
 972
 973   return 0;
 974 }
 975
 976 // Add an ethertype -> next index mapping to the structure
 977 clib_error_t * next_by_ethertype_register (next_by_ethertype_t * l3_next,
 978                                            u32                   ethertype,
 979                                            u32                   next_index)
 980 {
 981   u32 i;
 982   u16 * n;
 983   ethernet_main_t * em = &ethernet_main;
 984
 985   if (CLIB_DEBUG > 0)
 986     {
 987       ethernet_main_t * em = &ethernet_main;
 988       em->next_by_ethertype_register_called = 1;
 989     }
 990
 991   /* Setup ethernet type -> next index sparse vector mapping. */
 992   n = sparse_vec_validate (l3_next->input_next_by_type, ethertype);
 993   n[0] = next_index;
 994
 995   /* Rebuild next index -> sparse index inverse mapping when sparse vector
 996      is updated. */
 997   vec_validate (l3_next->sparse_index_by_input_next_index, next_index);
 998   for (i = 1; i < vec_len (l3_next->input_next_by_type); i++)
 999     l3_next->sparse_index_by_input_next_index[l3_next->input_next_by_type[i]] = i;
1000
1001   // do not allow the cached next index's to be updated if L3
1002   // redirect is enabled, as it will have overwritten them
1003   if (!em->redirect_l3) {
1004     // Cache common ethertypes directly
1005     if (ethertype == ETHERNET_TYPE_IP4) {
1006       l3_next->input_next_ip4 = next_index;
1007     } else if (ethertype == ETHERNET_TYPE_IP6) {
1008       l3_next->input_next_ip6 = next_index;
1009     } else if (ethertype == ETHERNET_TYPE_MPLS_UNICAST) {
1010       l3_next->input_next_mpls = next_index;
1011     }
1012   }
1013   return 0;
1014 }
1015
1016
1017 static clib_error_t * ethernet_input_init (vlib_main_t * vm)
1018 {
1019   ethernet_main_t * em = &ethernet_main;
1020   __attribute__((unused)) vlan_table_t * invalid_vlan_table;
1021   __attribute__((unused)) qinq_table_t * invalid_qinq_table;
1022
1023   ethernet_setup_node (vm, ethernet_input_node.index);
1024   ethernet_setup_node (vm, ethernet_input_type_node.index);
1025   ethernet_setup_node (vm, ethernet_input_not_l2_node.index);
1026
1027   next_by_ethertype_init (&em->l3_next);
1028
1029   // Initialize pools and vector for vlan parsing
1030   vec_validate (em->main_intfs, 10);  // 10 main interfaces
1031   pool_alloc(em->vlan_pool, 10);
1032   pool_alloc(em->qinq_pool, 1);
1033
1034   // The first vlan pool will always be reserved for an invalid table
1035   pool_get(em->vlan_pool, invalid_vlan_table); // first id = 0
1036   // The first qinq pool will always be reserved for an invalid table
1037   pool_get(em->qinq_pool, invalid_qinq_table); // first id = 0
1038
1039   return 0;
1040 }
1041
1042 VLIB_INIT_FUNCTION (ethernet_input_init);
1043
1044 void
1045 ethernet_register_input_type (vlib_main_t * vm,
1046                               ethernet_type_t type,
1047                               u32 node_index)
1048 {
1049   ethernet_main_t * em = &ethernet_main;
1050   ethernet_type_info_t * ti;
1051   u32 i;
1052
1053   {
1054     clib_error_t * error = vlib_call_init_function (vm, ethernet_init);
1055     if (error)
1056       clib_error_report (error);
1057   }
1058
1059   ti = ethernet_get_type_info (em, type);
1060   ti->node_index = node_index;
1061   ti->next_index = vlib_node_add_next (vm,
1062                                        ethernet_input_node.index,
1063                                        node_index);
1064   i = vlib_node_add_next (vm,
1065                           ethernet_input_type_node.index,
1066                           node_index);
1067   ASSERT (i == ti->next_index);
1068
1069   i = vlib_node_add_next (vm,
1070                           ethernet_input_not_l2_node.index,
1071                           node_index);
1072   ASSERT (i == ti->next_index);
1073
1074   // Add the L3 node for this ethertype to the next nodes structure
1075   next_by_ethertype_register (&em->l3_next, type, ti->next_index);
1076
1077   // Call the registration functions for other nodes that want a mapping
1078   l2bvi_register_input_type (vm, type, node_index);
1079 }
1080
1081 void
1082 ethernet_register_l2_input (vlib_main_t * vm,
1083                             u32 node_index)
1084 {
1085   ethernet_main_t * em = &ethernet_main;
1086   u32 i;
1087
1088   em->l2_next = vlib_node_add_next (vm, ethernet_input_node.index, node_index);
1089
1090   /*
1091    * Even if we never use these arcs, we have to align the next indices...
1092    */
1093   i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
1094
1095   ASSERT (i == em->l2_next);
1096
1097   i = vlib_node_add_next (vm,
1098                           ethernet_input_not_l2_node.index,
1099                           node_index);
1100   ASSERT (i == em->l2_next);
1101 }
1102
1103 // Register a next node for L3 redirect, and enable L3 redirect
1104 void
1105 ethernet_register_l3_redirect (vlib_main_t * vm,
1106                                u32 node_index)
1107 {
1108   ethernet_main_t * em = &ethernet_main;
1109   u32 i;
1110
1111   em->redirect_l3 = 1;
1112   em->redirect_l3_next = vlib_node_add_next(vm,
1113                                             ethernet_input_node.index,
1114                                             node_index);
1115   /*
1116    * Change the cached next nodes to the redirect node
1117    */
1118   em->l3_next.input_next_ip4 = em->redirect_l3_next;
1119   em->l3_next.input_next_ip6 = em->redirect_l3_next;
1120   em->l3_next.input_next_mpls = em->redirect_l3_next;
1121
1122   /*
1123    * Even if we never use these arcs, we have to align the next indices...
1124    */
1125   i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
1126
1127   ASSERT (i == em->redirect_l3_next);
1128 }