2 * Copyright (c) 2018 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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * ethernet_node.c: ethernet packet processing
18 * Copyright (c) 2008 Eliot Dresselhaus
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:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
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.
40 #include <vlib/vlib.h>
41 #include <vnet/pg/pg.h>
42 #include <vnet/ethernet/ethernet.h>
43 #include <vnet/ethernet/p2p_ethernet.h>
44 #include <vnet/devices/pipe/pipe.h>
45 #include <vppinfra/sparse_vec.h>
46 #include <vnet/l2/l2_bvi.h>
47 #include <vnet/classify/trace_classify.h>
49 #define foreach_ethernet_input_next \
50 _ (PUNT, "error-punt") \
51 _ (DROP, "error-drop") \
52 _ (LLC, "llc-input") \
53 _ (IP4_INPUT, "ip4-input") \
54 _ (IP4_INPUT_NCS, "ip4-input-no-checksum")
58 #define _(s,n) ETHERNET_INPUT_NEXT_##s,
59 foreach_ethernet_input_next
61 ETHERNET_INPUT_N_NEXT,
62 } ethernet_input_next_t;
68 ethernet_input_frame_t frame_data;
69 } ethernet_input_trace_t;
72 format_ethernet_input_trace (u8 * s, va_list * va)
74 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
75 CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
76 ethernet_input_trace_t *t = va_arg (*va, ethernet_input_trace_t *);
77 u32 indent = format_get_indent (s);
81 s = format (s, "frame: flags 0x%x", t->frame_flags);
82 if (t->frame_flags & ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX)
83 s = format (s, ", hw-if-index %u, sw-if-index %u",
84 t->frame_data.hw_if_index, t->frame_data.sw_if_index);
85 s = format (s, "\n%U", format_white_space, indent);
87 s = format (s, "%U", format_ethernet_header, t->packet_data);
92 extern vlib_node_registration_t ethernet_input_node;
96 ETHERNET_INPUT_VARIANT_ETHERNET,
97 ETHERNET_INPUT_VARIANT_ETHERNET_TYPE,
98 ETHERNET_INPUT_VARIANT_NOT_L2,
99 } ethernet_input_variant_t;
102 // Parse the ethernet header to extract vlan tags and innermost ethertype
103 static_always_inline void
104 parse_header (ethernet_input_variant_t variant,
108 u16 * outer_id, u16 * inner_id, u32 * match_flags)
112 if (variant == ETHERNET_INPUT_VARIANT_ETHERNET
113 || variant == ETHERNET_INPUT_VARIANT_NOT_L2)
115 ethernet_header_t *e0;
117 e0 = (void *) (b0->data + b0->current_data);
119 vnet_buffer (b0)->l2_hdr_offset = b0->current_data;
120 b0->flags |= VNET_BUFFER_F_L2_HDR_OFFSET_VALID;
122 vlib_buffer_advance (b0, sizeof (e0[0]));
124 *type = clib_net_to_host_u16 (e0->type);
126 else if (variant == ETHERNET_INPUT_VARIANT_ETHERNET_TYPE)
128 // here when prior node was LLC/SNAP processing
131 e0 = (void *) (b0->data + b0->current_data);
133 vlib_buffer_advance (b0, sizeof (e0[0]));
135 *type = clib_net_to_host_u16 (e0[0]);
138 // save for distinguishing between dot1q and dot1ad later
141 // default the tags to 0 (used if there is no corresponding tag)
145 *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_0_TAG;
148 // check for vlan encaps
149 if (ethernet_frame_is_tagged (*type))
151 ethernet_vlan_header_t *h0;
154 *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_1_TAG;
156 h0 = (void *) (b0->data + b0->current_data);
158 tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
160 *outer_id = tag & 0xfff;
162 *match_flags &= ~SUBINT_CONFIG_MATCH_1_TAG;
164 *type = clib_net_to_host_u16 (h0->type);
166 vlib_buffer_advance (b0, sizeof (h0[0]));
169 if (*type == ETHERNET_TYPE_VLAN)
171 // Double tagged packet
172 *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_2_TAG;
174 h0 = (void *) (b0->data + b0->current_data);
176 tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
178 *inner_id = tag & 0xfff;
180 *type = clib_net_to_host_u16 (h0->type);
182 vlib_buffer_advance (b0, sizeof (h0[0]));
184 if (*type == ETHERNET_TYPE_VLAN)
186 // More than double tagged packet
187 *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_3_TAG;
189 vlib_buffer_advance (b0, sizeof (h0[0]));
190 vlan_count = 3; // "unknown" number, aka, 3-or-more
194 ethernet_buffer_set_vlan_count (b0, vlan_count);
197 static_always_inline void
198 ethernet_input_inline_dmac_check (vnet_hw_interface_t * hi,
199 u64 * dmacs, u8 * dmacs_bad,
200 u32 n_packets, ethernet_interface_t * ei,
203 // Determine the subinterface for this packet, given the result of the
204 // vlan table lookups and vlan header parsing. Check the most specific
206 static_always_inline void
207 identify_subint (vnet_hw_interface_t * hi,
210 main_intf_t * main_intf,
211 vlan_intf_t * vlan_intf,
212 qinq_intf_t * qinq_intf,
213 u32 * new_sw_if_index, u8 * error0, u32 * is_l2)
217 matched = eth_identify_subint (hi, match_flags, main_intf, vlan_intf,
218 qinq_intf, new_sw_if_index, error0, is_l2);
222 // Perform L3 my-mac filter
223 // A unicast packet arriving on an L3 interface must have a dmac matching the interface mac.
224 // This is required for promiscuous mode, else we will forward packets we aren't supposed to.
229 ethernet_header_t *e0;
230 ethernet_interface_t *ei0;
232 e0 = (void *) (b0->data + vnet_buffer (b0)->l2_hdr_offset);
233 dmacs[0] = *(u64 *) e0;
234 ei0 = ethernet_get_interface (ðernet_main, hi->hw_if_index);
236 if (ei0 && vec_len (ei0->secondary_addrs))
237 ethernet_input_inline_dmac_check (hi, dmacs, dmacs_bad,
238 1 /* n_packets */ , ei0,
239 1 /* have_sec_dmac */ );
241 ethernet_input_inline_dmac_check (hi, dmacs, dmacs_bad,
242 1 /* n_packets */ , ei0,
243 0 /* have_sec_dmac */ );
246 *error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
249 // Check for down subinterface
250 *error0 = (*new_sw_if_index) != ~0 ? (*error0) : ETHERNET_ERROR_DOWN;
254 static_always_inline void
255 determine_next_node (ethernet_main_t * em,
256 ethernet_input_variant_t variant,
258 u32 type0, vlib_buffer_t * b0, u8 * error0, u8 * next0)
260 vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
261 b0->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
263 if (PREDICT_FALSE (*error0 != ETHERNET_ERROR_NONE))
265 // some error occurred
266 *next0 = ETHERNET_INPUT_NEXT_DROP;
270 // record the L2 len and reset the buffer so the L2 header is preserved
271 u32 eth_start = vnet_buffer (b0)->l2_hdr_offset;
272 vnet_buffer (b0)->l2.l2_len = b0->current_data - eth_start;
273 *next0 = em->l2_next;
274 ASSERT (vnet_buffer (b0)->l2.l2_len ==
275 ethernet_buffer_header_size (b0));
276 vlib_buffer_advance (b0, -(vnet_buffer (b0)->l2.l2_len));
278 // check for common IP/MPLS ethertypes
280 else if (type0 == ETHERNET_TYPE_IP4)
282 *next0 = em->l3_next.input_next_ip4;
284 else if (type0 == ETHERNET_TYPE_IP6)
286 *next0 = em->l3_next.input_next_ip6;
288 else if (type0 == ETHERNET_TYPE_MPLS)
290 *next0 = em->l3_next.input_next_mpls;
293 else if (em->redirect_l3)
295 // L3 Redirect is on, the cached common next nodes will be
296 // pointing to the redirect node, catch the uncommon types here
297 *next0 = em->redirect_l3_next;
301 // uncommon ethertype, check table
303 i0 = sparse_vec_index (em->l3_next.input_next_by_type, type0);
304 *next0 = vec_elt (em->l3_next.input_next_by_type, i0);
307 SPARSE_VEC_INVALID_INDEX ? ETHERNET_ERROR_UNKNOWN_TYPE : *error0;
309 // The table is not populated with LLC values, so check that now.
310 // If variant is variant_ethernet then we came from LLC processing. Don't
311 // go back there; drop instead using by keeping the drop/bad table result.
312 if ((type0 < 0x600) && (variant == ETHERNET_INPUT_VARIANT_ETHERNET))
314 *next0 = ETHERNET_INPUT_NEXT_LLC;
320 /* following vector code relies on following assumptions */
321 STATIC_ASSERT_OFFSET_OF (vlib_buffer_t, current_data, 0);
322 STATIC_ASSERT_OFFSET_OF (vlib_buffer_t, current_length, 2);
323 STATIC_ASSERT_OFFSET_OF (vlib_buffer_t, flags, 4);
324 STATIC_ASSERT (STRUCT_OFFSET_OF (vnet_buffer_opaque_t, l2_hdr_offset) ==
325 STRUCT_OFFSET_OF (vnet_buffer_opaque_t, l3_hdr_offset) - 2,
326 "l3_hdr_offset must follow l2_hdr_offset");
328 static_always_inline void
329 eth_input_adv_and_flags_x4 (vlib_buffer_t ** b, int is_l3)
331 i16 adv = sizeof (ethernet_header_t);
332 u32 flags = VNET_BUFFER_F_L2_HDR_OFFSET_VALID |
333 VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
335 #ifdef CLIB_HAVE_VEC256
336 /* to reduce number of small loads/stores we are loading first 64 bits
337 of each buffer metadata into 256-bit register so we can advance
338 current_data, current_length and flags.
339 Observed saving of this code is ~2 clocks per packet */
342 /* vector if signed 16 bit integers used in signed vector add operation
343 to advnce current_data and current_length */
344 u32x8 flags4 = { 0, flags, 0, flags, 0, flags, 0, flags };
346 adv, -adv, 0, 0, adv, -adv, 0, 0,
347 adv, -adv, 0, 0, adv, -adv, 0, 0
350 /* load 4 x 64 bits */
351 r = u64x4_gather (b[0], b[1], b[2], b[3]);
357 radv = (u64x4) ((i16x16) r + adv4);
359 /* write 4 x 64 bits */
360 u64x4_scatter (is_l3 ? radv : r, b[0], b[1], b[2], b[3]);
362 /* use old current_data as l2_hdr_offset and new current_data as
364 r = (u64x4) u16x16_blend (r, radv << 16, 0xaa);
366 /* store both l2_hdr_offset and l3_hdr_offset in single store operation */
367 u32x8_scatter_one ((u32x8) r, 0, &vnet_buffer (b[0])->l2_hdr_offset);
368 u32x8_scatter_one ((u32x8) r, 2, &vnet_buffer (b[1])->l2_hdr_offset);
369 u32x8_scatter_one ((u32x8) r, 4, &vnet_buffer (b[2])->l2_hdr_offset);
370 u32x8_scatter_one ((u32x8) r, 6, &vnet_buffer (b[3])->l2_hdr_offset);
374 ASSERT (b[0]->current_data == vnet_buffer (b[0])->l3_hdr_offset);
375 ASSERT (b[1]->current_data == vnet_buffer (b[1])->l3_hdr_offset);
376 ASSERT (b[2]->current_data == vnet_buffer (b[2])->l3_hdr_offset);
377 ASSERT (b[3]->current_data == vnet_buffer (b[3])->l3_hdr_offset);
379 ASSERT (b[0]->current_data - vnet_buffer (b[0])->l2_hdr_offset == adv);
380 ASSERT (b[1]->current_data - vnet_buffer (b[1])->l2_hdr_offset == adv);
381 ASSERT (b[2]->current_data - vnet_buffer (b[2])->l2_hdr_offset == adv);
382 ASSERT (b[3]->current_data - vnet_buffer (b[3])->l2_hdr_offset == adv);
386 ASSERT (b[0]->current_data == vnet_buffer (b[0])->l2_hdr_offset);
387 ASSERT (b[1]->current_data == vnet_buffer (b[1])->l2_hdr_offset);
388 ASSERT (b[2]->current_data == vnet_buffer (b[2])->l2_hdr_offset);
389 ASSERT (b[3]->current_data == vnet_buffer (b[3])->l2_hdr_offset);
391 ASSERT (b[0]->current_data - vnet_buffer (b[0])->l3_hdr_offset == -adv);
392 ASSERT (b[1]->current_data - vnet_buffer (b[1])->l3_hdr_offset == -adv);
393 ASSERT (b[2]->current_data - vnet_buffer (b[2])->l3_hdr_offset == -adv);
394 ASSERT (b[3]->current_data - vnet_buffer (b[3])->l3_hdr_offset == -adv);
398 vnet_buffer (b[0])->l2_hdr_offset = b[0]->current_data;
399 vnet_buffer (b[1])->l2_hdr_offset = b[1]->current_data;
400 vnet_buffer (b[2])->l2_hdr_offset = b[2]->current_data;
401 vnet_buffer (b[3])->l2_hdr_offset = b[3]->current_data;
402 vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data + adv;
403 vnet_buffer (b[1])->l3_hdr_offset = b[1]->current_data + adv;
404 vnet_buffer (b[2])->l3_hdr_offset = b[2]->current_data + adv;
405 vnet_buffer (b[3])->l3_hdr_offset = b[3]->current_data + adv;
409 vlib_buffer_advance (b[0], adv);
410 vlib_buffer_advance (b[1], adv);
411 vlib_buffer_advance (b[2], adv);
412 vlib_buffer_advance (b[3], adv);
415 b[0]->flags |= flags;
416 b[1]->flags |= flags;
417 b[2]->flags |= flags;
418 b[3]->flags |= flags;
423 vnet_buffer (b[0])->l2.l2_len = adv;
424 vnet_buffer (b[1])->l2.l2_len = adv;
425 vnet_buffer (b[2])->l2.l2_len = adv;
426 vnet_buffer (b[3])->l2.l2_len = adv;
430 static_always_inline void
431 eth_input_adv_and_flags_x1 (vlib_buffer_t ** b, int is_l3)
433 i16 adv = sizeof (ethernet_header_t);
434 u32 flags = VNET_BUFFER_F_L2_HDR_OFFSET_VALID |
435 VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
437 vnet_buffer (b[0])->l2_hdr_offset = b[0]->current_data;
438 vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data + adv;
441 vlib_buffer_advance (b[0], adv);
442 b[0]->flags |= flags;
444 vnet_buffer (b[0])->l2.l2_len = adv;
448 static_always_inline void
449 eth_input_get_etype_and_tags (vlib_buffer_t ** b, u16 * etype, u64 * tags,
450 u64 * dmacs, int offset, int dmac_check)
452 ethernet_header_t *e;
453 e = vlib_buffer_get_current (b[offset]);
454 #ifdef CLIB_HAVE_VEC128
455 u64x2 r = u64x2_load_unaligned (((u8 *) & e->type) - 6);
456 etype[offset] = ((u16x8) r)[3];
459 etype[offset] = e->type;
460 tags[offset] = *(u64 *) (e + 1);
464 dmacs[offset] = *(u64 *) e;
467 static_always_inline u16
468 eth_input_next_by_type (u16 etype)
470 ethernet_main_t *em = ðernet_main;
472 return (etype < 0x600) ? ETHERNET_INPUT_NEXT_LLC :
473 vec_elt (em->l3_next.input_next_by_type,
474 sparse_vec_index (em->l3_next.input_next_by_type, etype));
484 u64 n_packets, n_bytes;
485 } eth_input_tag_lookup_t;
487 static_always_inline void
488 eth_input_update_if_counters (vlib_main_t * vm, vnet_main_t * vnm,
489 eth_input_tag_lookup_t * l)
491 if (l->n_packets == 0 || l->sw_if_index == ~0)
495 l->n_bytes += l->n_packets * l->len;
497 vlib_increment_combined_counter
498 (vnm->interface_main.combined_sw_if_counters +
499 VNET_INTERFACE_COUNTER_RX, vm->thread_index, l->sw_if_index,
500 l->n_packets, l->n_bytes);
503 static_always_inline void
504 eth_input_tag_lookup (vlib_main_t * vm, vnet_main_t * vnm,
505 vlib_node_runtime_t * node, vnet_hw_interface_t * hi,
506 u64 tag, u16 * next, vlib_buffer_t * b,
507 eth_input_tag_lookup_t * l, u8 dmac_bad, int is_dot1ad,
508 int main_is_l3, int check_dmac)
510 ethernet_main_t *em = ðernet_main;
512 if ((tag ^ l->tag) & l->mask)
514 main_intf_t *mif = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
517 vlan_table_t *vlan_table;
518 qinq_table_t *qinq_table;
519 u16 *t = (u16 *) & tag;
520 u16 vlan1 = clib_net_to_host_u16 (t[0]) & 0xFFF;
521 u16 vlan2 = clib_net_to_host_u16 (t[2]) & 0xFFF;
522 u32 matched, is_l2, new_sw_if_index;
524 vlan_table = vec_elt_at_index (em->vlan_pool, is_dot1ad ?
525 mif->dot1ad_vlans : mif->dot1q_vlans);
526 vif = &vlan_table->vlans[vlan1];
527 qinq_table = vec_elt_at_index (em->qinq_pool, vif->qinqs);
528 qif = &qinq_table->vlans[vlan2];
529 l->err = ETHERNET_ERROR_NONE;
530 l->type = clib_net_to_host_u16 (t[1]);
532 if (l->type == ETHERNET_TYPE_VLAN)
534 l->type = clib_net_to_host_u16 (t[3]);
536 matched = eth_identify_subint (hi, SUBINT_CONFIG_VALID |
537 SUBINT_CONFIG_MATCH_2_TAG, mif, vif,
538 qif, &new_sw_if_index, &l->err,
546 new_sw_if_index = hi->sw_if_index;
547 l->err = ETHERNET_ERROR_NONE;
549 is_l2 = main_is_l3 == 0;
552 matched = eth_identify_subint (hi, SUBINT_CONFIG_VALID |
553 SUBINT_CONFIG_MATCH_1_TAG, mif,
554 vif, qif, &new_sw_if_index,
558 if (l->sw_if_index != new_sw_if_index)
560 eth_input_update_if_counters (vm, vnm, l);
563 l->sw_if_index = new_sw_if_index;
566 l->mask = (l->n_tags == 2) ?
567 clib_net_to_host_u64 (0xffffffffffffffff) :
568 clib_net_to_host_u64 (0xffffffff00000000);
570 if (matched && l->sw_if_index == ~0)
571 l->err = ETHERNET_ERROR_DOWN;
573 l->len = sizeof (ethernet_header_t) +
574 l->n_tags * sizeof (ethernet_vlan_header_t);
576 l->adv = is_l2 ? -(int) sizeof (ethernet_header_t) :
577 l->n_tags * sizeof (ethernet_vlan_header_t);
579 l->adv = is_l2 ? 0 : l->len;
581 if (PREDICT_FALSE (l->err != ETHERNET_ERROR_NONE))
582 l->next = ETHERNET_INPUT_NEXT_DROP;
584 l->next = em->l2_next;
585 else if (l->type == ETHERNET_TYPE_IP4)
586 l->next = em->l3_next.input_next_ip4;
587 else if (l->type == ETHERNET_TYPE_IP6)
588 l->next = em->l3_next.input_next_ip6;
589 else if (l->type == ETHERNET_TYPE_MPLS)
590 l->next = em->l3_next.input_next_mpls;
591 else if (em->redirect_l3)
592 l->next = em->redirect_l3_next;
595 l->next = eth_input_next_by_type (l->type);
596 if (l->next == ETHERNET_INPUT_NEXT_PUNT)
597 l->err = ETHERNET_ERROR_UNKNOWN_TYPE;
601 if (check_dmac && l->adv > 0 && dmac_bad)
603 l->err = ETHERNET_ERROR_L3_MAC_MISMATCH;
604 next[0] = ETHERNET_INPUT_NEXT_PUNT;
609 vlib_buffer_advance (b, l->adv);
610 vnet_buffer (b)->l2.l2_len = l->len;
611 vnet_buffer (b)->l3_hdr_offset = vnet_buffer (b)->l2_hdr_offset + l->len;
613 if (l->err == ETHERNET_ERROR_NONE)
615 vnet_buffer (b)->sw_if_index[VLIB_RX] = l->sw_if_index;
616 ethernet_buffer_set_vlan_count (b, l->n_tags);
619 b->error = node->errors[l->err];
621 /* update counters */
623 l->n_bytes += vlib_buffer_length_in_chain (vm, b);
626 #define DMAC_MASK clib_net_to_host_u64 (0xFFFFFFFFFFFF0000)
627 #define DMAC_IGBIT clib_net_to_host_u64 (0x0100000000000000)
629 #ifdef CLIB_HAVE_VEC256
630 static_always_inline u32
631 is_dmac_bad_x4 (u64 * dmacs, u64 hwaddr)
633 u64x4 r0 = u64x4_load_unaligned (dmacs) & u64x4_splat (DMAC_MASK);
634 r0 = (r0 != u64x4_splat (hwaddr)) & ((r0 & u64x4_splat (DMAC_IGBIT)) == 0);
635 return u8x32_msb_mask ((u8x32) (r0));
639 static_always_inline u8
640 is_dmac_bad (u64 dmac, u64 hwaddr)
642 u64 r0 = dmac & DMAC_MASK;
643 return (r0 != hwaddr) && ((r0 & DMAC_IGBIT) == 0);
646 static_always_inline u8
647 is_sec_dmac_bad (u64 dmac, u64 hwaddr)
649 return ((dmac & DMAC_MASK) != hwaddr);
652 #ifdef CLIB_HAVE_VEC256
653 static_always_inline u32
654 is_sec_dmac_bad_x4 (u64 * dmacs, u64 hwaddr)
656 u64x4 r0 = u64x4_load_unaligned (dmacs) & u64x4_splat (DMAC_MASK);
657 r0 = (r0 != u64x4_splat (hwaddr));
658 return u8x32_msb_mask ((u8x32) (r0));
662 static_always_inline u8
663 eth_input_sec_dmac_check_x1 (u64 hwaddr, u64 * dmac, u8 * dmac_bad)
665 dmac_bad[0] &= is_sec_dmac_bad (dmac[0], hwaddr);
669 static_always_inline u32
670 eth_input_sec_dmac_check_x4 (u64 hwaddr, u64 * dmac, u8 * dmac_bad)
672 #ifdef CLIB_HAVE_VEC256
673 *(u32 *) (dmac_bad + 0) &= is_sec_dmac_bad_x4 (dmac + 0, hwaddr);
675 dmac_bad[0] &= is_sec_dmac_bad (dmac[0], hwaddr);
676 dmac_bad[1] &= is_sec_dmac_bad (dmac[1], hwaddr);
677 dmac_bad[2] &= is_sec_dmac_bad (dmac[2], hwaddr);
678 dmac_bad[3] &= is_sec_dmac_bad (dmac[3], hwaddr);
680 return *(u32 *) dmac_bad;
684 * DMAC check for ethernet_input_inline()
686 * dmacs and dmacs_bad are arrays that are 2 elements long
687 * n_packets should be 1 or 2 for ethernet_input_inline()
689 static_always_inline void
690 ethernet_input_inline_dmac_check (vnet_hw_interface_t * hi,
691 u64 * dmacs, u8 * dmacs_bad,
692 u32 n_packets, ethernet_interface_t * ei,
695 u64 hwaddr = (*(u64 *) hi->hw_address) & DMAC_MASK;
698 dmacs_bad[0] = is_dmac_bad (dmacs[0], hwaddr);
699 dmacs_bad[1] = ((n_packets > 1) & is_dmac_bad (dmacs[1], hwaddr));
701 bad = dmacs_bad[0] | dmacs_bad[1];
703 if (PREDICT_FALSE (bad && have_sec_dmac))
705 mac_address_t *sec_addr;
707 vec_foreach (sec_addr, ei->secondary_addrs)
709 hwaddr = (*(u64 *) sec_addr) & DMAC_MASK;
711 bad = (eth_input_sec_dmac_check_x1 (hwaddr, dmacs, dmacs_bad) |
712 eth_input_sec_dmac_check_x1 (hwaddr, dmacs + 1,
721 static_always_inline void
722 eth_input_process_frame_dmac_check (vnet_hw_interface_t * hi,
723 u64 * dmacs, u8 * dmacs_bad,
724 u32 n_packets, ethernet_interface_t * ei,
727 u64 hwaddr = (*(u64 *) hi->hw_address) & DMAC_MASK;
729 u8 *dmac_bad = dmacs_bad;
731 i32 n_left = n_packets;
733 #ifdef CLIB_HAVE_VEC256
736 bad |= *(u32 *) (dmac_bad + 0) = is_dmac_bad_x4 (dmac + 0, hwaddr);
737 bad |= *(u32 *) (dmac_bad + 4) = is_dmac_bad_x4 (dmac + 4, hwaddr);
747 bad |= dmac_bad[0] = is_dmac_bad (dmac[0], hwaddr);
748 bad |= dmac_bad[1] = is_dmac_bad (dmac[1], hwaddr);
749 bad |= dmac_bad[2] = is_dmac_bad (dmac[2], hwaddr);
750 bad |= dmac_bad[3] = is_dmac_bad (dmac[3], hwaddr);
759 if (have_sec_dmac && bad)
763 vec_foreach (addr, ei->secondary_addrs)
765 u64 hwaddr = ((u64 *) addr)[0] & DMAC_MASK;
766 i32 n_left = n_packets;
768 u8 *dmac_bad = dmacs_bad;
777 /* skip any that have already matched */
786 n_bad = clib_min (4, n_left);
788 /* If >= 4 left, compare 4 together */
791 bad |= eth_input_sec_dmac_check_x4 (hwaddr, dmac, dmac_bad);
796 /* handle individually */
799 bad |= eth_input_sec_dmac_check_x1 (hwaddr, dmac + adv,
810 if (!bad) /* can stop looping if everything matched */
816 /* process frame of buffers, store ethertype into array and update
817 buffer metadata fields depending on interface being l2 or l3 assuming that
818 packets are untagged. For tagged packets those fields are updated later.
819 Optionally store Destionation MAC address and tag data into arrays
820 for further processing */
822 STATIC_ASSERT (VLIB_FRAME_SIZE % 8 == 0,
823 "VLIB_FRAME_SIZE must be power of 8");
824 static_always_inline void
825 eth_input_process_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
826 vnet_hw_interface_t * hi,
827 u32 * buffer_indices, u32 n_packets, int main_is_l3,
828 int ip4_cksum_ok, int dmac_check)
830 ethernet_main_t *em = ðernet_main;
831 u16 nexts[VLIB_FRAME_SIZE], *next;
832 u16 etypes[VLIB_FRAME_SIZE], *etype = etypes;
833 u64 dmacs[VLIB_FRAME_SIZE], *dmac = dmacs;
834 u8 dmacs_bad[VLIB_FRAME_SIZE];
835 u64 tags[VLIB_FRAME_SIZE], *tag = tags;
836 u16 slowpath_indices[VLIB_FRAME_SIZE];
838 u16 next_ip4, next_ip6, next_mpls, next_l2;
839 u16 et_ip4 = clib_host_to_net_u16 (ETHERNET_TYPE_IP4);
840 u16 et_ip6 = clib_host_to_net_u16 (ETHERNET_TYPE_IP6);
841 u16 et_mpls = clib_host_to_net_u16 (ETHERNET_TYPE_MPLS);
842 u16 et_vlan = clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
843 u16 et_dot1ad = clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD);
844 i32 n_left = n_packets;
845 vlib_buffer_t *b[20];
847 ethernet_interface_t *ei = ethernet_get_interface (em, hi->hw_if_index);
849 from = buffer_indices;
853 vlib_buffer_t **ph = b + 16, **pd = b + 8;
854 vlib_get_buffers (vm, from, b, 4);
855 vlib_get_buffers (vm, from + 8, pd, 4);
856 vlib_get_buffers (vm, from + 16, ph, 4);
858 vlib_prefetch_buffer_header (ph[0], LOAD);
859 vlib_prefetch_buffer_data (pd[0], LOAD);
860 eth_input_get_etype_and_tags (b, etype, tag, dmac, 0, dmac_check);
862 vlib_prefetch_buffer_header (ph[1], LOAD);
863 vlib_prefetch_buffer_data (pd[1], LOAD);
864 eth_input_get_etype_and_tags (b, etype, tag, dmac, 1, dmac_check);
866 vlib_prefetch_buffer_header (ph[2], LOAD);
867 vlib_prefetch_buffer_data (pd[2], LOAD);
868 eth_input_get_etype_and_tags (b, etype, tag, dmac, 2, dmac_check);
870 vlib_prefetch_buffer_header (ph[3], LOAD);
871 vlib_prefetch_buffer_data (pd[3], LOAD);
872 eth_input_get_etype_and_tags (b, etype, tag, dmac, 3, dmac_check);
874 eth_input_adv_and_flags_x4 (b, main_is_l3);
885 vlib_get_buffers (vm, from, b, 4);
886 eth_input_get_etype_and_tags (b, etype, tag, dmac, 0, dmac_check);
887 eth_input_get_etype_and_tags (b, etype, tag, dmac, 1, dmac_check);
888 eth_input_get_etype_and_tags (b, etype, tag, dmac, 2, dmac_check);
889 eth_input_get_etype_and_tags (b, etype, tag, dmac, 3, dmac_check);
890 eth_input_adv_and_flags_x4 (b, main_is_l3);
901 vlib_get_buffers (vm, from, b, 1);
902 eth_input_get_etype_and_tags (b, etype, tag, dmac, 0, dmac_check);
903 eth_input_adv_and_flags_x1 (b, main_is_l3);
915 if (ei && vec_len (ei->secondary_addrs))
916 eth_input_process_frame_dmac_check (hi, dmacs, dmacs_bad, n_packets,
917 ei, 1 /* have_sec_dmac */ );
919 eth_input_process_frame_dmac_check (hi, dmacs, dmacs_bad, n_packets,
920 ei, 0 /* have_sec_dmac */ );
923 next_ip4 = em->l3_next.input_next_ip4;
924 next_ip6 = em->l3_next.input_next_ip6;
925 next_mpls = em->l3_next.input_next_mpls;
926 next_l2 = em->l2_next;
928 if (next_ip4 == ETHERNET_INPUT_NEXT_IP4_INPUT && ip4_cksum_ok)
929 next_ip4 = ETHERNET_INPUT_NEXT_IP4_INPUT_NCS;
931 #ifdef CLIB_HAVE_VEC256
932 u16x16 et16_ip4 = u16x16_splat (et_ip4);
933 u16x16 et16_ip6 = u16x16_splat (et_ip6);
934 u16x16 et16_mpls = u16x16_splat (et_mpls);
935 u16x16 et16_vlan = u16x16_splat (et_vlan);
936 u16x16 et16_dot1ad = u16x16_splat (et_dot1ad);
937 u16x16 next16_ip4 = u16x16_splat (next_ip4);
938 u16x16 next16_ip6 = u16x16_splat (next_ip6);
939 u16x16 next16_mpls = u16x16_splat (next_mpls);
940 u16x16 next16_l2 = u16x16_splat (next_l2);
942 u16x16 stairs = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
951 /* fastpath - in l3 mode hadles ip4, ip6 and mpls packets, other packets
952 are considered as slowpath, in l2 mode all untagged packets are
953 considered as fastpath */
956 #ifdef CLIB_HAVE_VEC256
960 u16x16 e16 = u16x16_load_unaligned (etype);
963 r += (e16 == et16_ip4) & next16_ip4;
964 r += (e16 == et16_ip6) & next16_ip6;
965 r += (e16 == et16_mpls) & next16_mpls;
968 r = ((e16 != et16_vlan) & (e16 != et16_dot1ad)) & next16_l2;
969 u16x16_store_unaligned (r, next);
971 if (!u16x16_is_all_zero (r == zero))
973 if (u16x16_is_all_zero (r))
975 u16x16_store_unaligned (u16x16_splat (i) + stairs,
976 slowpath_indices + n_slowpath);
981 for (int j = 0; j < 16; j++)
983 slowpath_indices[n_slowpath++] = i + j;
994 if (main_is_l3 && etype[0] == et_ip4)
996 else if (main_is_l3 && etype[0] == et_ip6)
998 else if (main_is_l3 && etype[0] == et_mpls)
1000 else if (main_is_l3 == 0 &&
1001 etype[0] != et_vlan && etype[0] != et_dot1ad)
1006 slowpath_indices[n_slowpath++] = i;
1017 vnet_main_t *vnm = vnet_get_main ();
1018 n_left = n_slowpath;
1019 u16 *si = slowpath_indices;
1020 u32 last_unknown_etype = ~0;
1021 u32 last_unknown_next = ~0;
1022 eth_input_tag_lookup_t dot1ad_lookup, dot1q_lookup = {
1024 .tag = tags[si[0]] ^ -1LL,
1028 clib_memcpy_fast (&dot1ad_lookup, &dot1q_lookup, sizeof (dot1q_lookup));
1033 u16 etype = etypes[i];
1035 if (etype == et_vlan)
1037 vlib_buffer_t *b = vlib_get_buffer (vm, buffer_indices[i]);
1038 eth_input_tag_lookup (vm, vnm, node, hi, tags[i], nexts + i, b,
1039 &dot1q_lookup, dmacs_bad[i], 0,
1040 main_is_l3, dmac_check);
1043 else if (etype == et_dot1ad)
1045 vlib_buffer_t *b = vlib_get_buffer (vm, buffer_indices[i]);
1046 eth_input_tag_lookup (vm, vnm, node, hi, tags[i], nexts + i, b,
1047 &dot1ad_lookup, dmacs_bad[i], 1,
1048 main_is_l3, dmac_check);
1052 /* untagged packet with not well known etyertype */
1053 if (last_unknown_etype != etype)
1055 last_unknown_etype = etype;
1056 etype = clib_host_to_net_u16 (etype);
1057 last_unknown_next = eth_input_next_by_type (etype);
1059 if (dmac_check && main_is_l3 && dmacs_bad[i])
1061 vlib_buffer_t *b = vlib_get_buffer (vm, buffer_indices[i]);
1062 b->error = node->errors[ETHERNET_ERROR_L3_MAC_MISMATCH];
1063 nexts[i] = ETHERNET_INPUT_NEXT_PUNT;
1066 nexts[i] = last_unknown_next;
1074 eth_input_update_if_counters (vm, vnm, &dot1q_lookup);
1075 eth_input_update_if_counters (vm, vnm, &dot1ad_lookup);
1078 vlib_buffer_enqueue_to_next (vm, node, buffer_indices, nexts, n_packets);
1081 static_always_inline void
1082 eth_input_single_int (vlib_main_t * vm, vlib_node_runtime_t * node,
1083 vnet_hw_interface_t * hi, u32 * from, u32 n_pkts,
1086 ethernet_main_t *em = ðernet_main;
1087 ethernet_interface_t *ei;
1088 ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
1089 main_intf_t *intf0 = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
1090 subint_config_t *subint0 = &intf0->untagged_subint;
1092 int main_is_l3 = (subint0->flags & SUBINT_CONFIG_L2) == 0;
1093 int promisc = (ei->flags & ETHERNET_INTERFACE_FLAG_ACCEPT_ALL) != 0;
1097 /* main interface is L3, we dont expect tagged packets and interface
1098 is not in promisc node, so we dont't need to check DMAC */
1102 eth_input_process_frame (vm, node, hi, from, n_pkts, is_l3,
1105 /* subinterfaces and promisc mode so DMAC check is needed */
1106 eth_input_process_frame (vm, node, hi, from, n_pkts, is_l3,
1112 /* untagged packets are treated as L2 */
1114 eth_input_process_frame (vm, node, hi, from, n_pkts, is_l3,
1120 static_always_inline void
1121 ethernet_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
1122 vlib_frame_t * from_frame)
1125 if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
1127 from = vlib_frame_vector_args (from_frame);
1128 n_left = from_frame->n_vectors;
1132 ethernet_input_trace_t *t0;
1133 vlib_buffer_t *b0 = vlib_get_buffer (vm, from[0]);
1135 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1137 t0 = vlib_add_trace (vm, node, b0,
1138 sizeof (ethernet_input_trace_t));
1139 clib_memcpy_fast (t0->packet_data, b0->data + b0->current_data,
1140 sizeof (t0->packet_data));
1141 t0->frame_flags = from_frame->flags;
1142 clib_memcpy_fast (&t0->frame_data,
1143 vlib_frame_scalar_args (from_frame),
1144 sizeof (ethernet_input_frame_t));
1151 /* rx pcap capture if enabled */
1152 if (PREDICT_FALSE (vlib_global_main.pcap.pcap_rx_enable))
1155 vnet_pcap_t *pp = &vlib_global_main.pcap;
1157 from = vlib_frame_vector_args (from_frame);
1158 n_left = from_frame->n_vectors;
1161 int classify_filter_result;
1166 b0 = vlib_get_buffer (vm, bi0);
1167 if (pp->filter_classify_table_index != ~0)
1169 classify_filter_result =
1170 vnet_is_packet_traced_inline
1171 (b0, pp->filter_classify_table_index, 0 /* full classify */ );
1172 if (classify_filter_result)
1173 pcap_add_buffer (&pp->pcap_main, vm, bi0,
1174 pp->max_bytes_per_pkt);
1178 if (pp->pcap_sw_if_index == 0 ||
1179 pp->pcap_sw_if_index == vnet_buffer (b0)->sw_if_index[VLIB_RX])
1181 vnet_main_t *vnm = vnet_get_main ();
1182 vnet_hw_interface_t *hi =
1183 vnet_get_sup_hw_interface
1184 (vnm, vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1186 /* Capture pkt if not filtered, or if filter hits */
1187 if (hi->trace_classify_table_index == ~0 ||
1188 vnet_is_packet_traced_inline
1189 (b0, hi->trace_classify_table_index,
1190 0 /* full classify */ ))
1191 pcap_add_buffer (&pp->pcap_main, vm, bi0,
1192 pp->max_bytes_per_pkt);
1198 static_always_inline void
1199 ethernet_input_inline (vlib_main_t * vm,
1200 vlib_node_runtime_t * node,
1201 u32 * from, u32 n_packets,
1202 ethernet_input_variant_t variant)
1204 vnet_main_t *vnm = vnet_get_main ();
1205 ethernet_main_t *em = ðernet_main;
1206 vlib_node_runtime_t *error_node;
1207 u32 n_left_from, next_index, *to_next;
1208 u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
1209 u32 thread_index = vm->thread_index;
1210 u32 cached_sw_if_index = ~0;
1211 u32 cached_is_l2 = 0; /* shut up gcc */
1212 vnet_hw_interface_t *hi = NULL; /* used for main interface only */
1213 ethernet_interface_t *ei = NULL;
1214 vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
1215 vlib_buffer_t **b = bufs;
1217 if (variant != ETHERNET_INPUT_VARIANT_ETHERNET)
1218 error_node = vlib_node_get_runtime (vm, ethernet_input_node.index);
1222 n_left_from = n_packets;
1224 next_index = node->cached_next_index;
1225 stats_sw_if_index = node->runtime_data[0];
1226 stats_n_packets = stats_n_bytes = 0;
1227 vlib_get_buffers (vm, from, bufs, n_left_from);
1229 while (n_left_from > 0)
1233 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1235 while (n_left_from >= 4 && n_left_to_next >= 2)
1238 vlib_buffer_t *b0, *b1;
1239 u8 next0, next1, error0, error1;
1240 u16 type0, orig_type0, type1, orig_type1;
1241 u16 outer_id0, inner_id0, outer_id1, inner_id1;
1242 u32 match_flags0, match_flags1;
1243 u32 old_sw_if_index0, new_sw_if_index0, len0, old_sw_if_index1,
1244 new_sw_if_index1, len1;
1245 vnet_hw_interface_t *hi0, *hi1;
1246 main_intf_t *main_intf0, *main_intf1;
1247 vlan_intf_t *vlan_intf0, *vlan_intf1;
1248 qinq_intf_t *qinq_intf0, *qinq_intf1;
1250 ethernet_header_t *e0, *e1;
1254 /* Prefetch next iteration. */
1256 vlib_prefetch_buffer_header (b[2], STORE);
1257 vlib_prefetch_buffer_header (b[3], STORE);
1259 CLIB_PREFETCH (b[2]->data, sizeof (ethernet_header_t), LOAD);
1260 CLIB_PREFETCH (b[3]->data, sizeof (ethernet_header_t), LOAD);
1269 n_left_to_next -= 2;
1276 error0 = error1 = ETHERNET_ERROR_NONE;
1277 e0 = vlib_buffer_get_current (b0);
1278 type0 = clib_net_to_host_u16 (e0->type);
1279 e1 = vlib_buffer_get_current (b1);
1280 type1 = clib_net_to_host_u16 (e1->type);
1282 /* Set the L2 header offset for all packets */
1283 vnet_buffer (b0)->l2_hdr_offset = b0->current_data;
1284 vnet_buffer (b1)->l2_hdr_offset = b1->current_data;
1285 b0->flags |= VNET_BUFFER_F_L2_HDR_OFFSET_VALID;
1286 b1->flags |= VNET_BUFFER_F_L2_HDR_OFFSET_VALID;
1288 /* Speed-path for the untagged case */
1289 if (PREDICT_TRUE (variant == ETHERNET_INPUT_VARIANT_ETHERNET
1290 && !ethernet_frame_is_any_tagged_x2 (type0,
1294 subint_config_t *subint0;
1295 u32 sw_if_index0, sw_if_index1;
1297 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
1298 sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
1299 is_l20 = cached_is_l2;
1301 /* This is probably wholly unnecessary */
1302 if (PREDICT_FALSE (sw_if_index0 != sw_if_index1))
1305 /* Now sw_if_index0 == sw_if_index1 */
1306 if (PREDICT_FALSE (cached_sw_if_index != sw_if_index0))
1308 cached_sw_if_index = sw_if_index0;
1309 hi = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1310 ei = ethernet_get_interface (em, hi->hw_if_index);
1311 intf0 = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
1312 subint0 = &intf0->untagged_subint;
1313 cached_is_l2 = is_l20 = subint0->flags & SUBINT_CONFIG_L2;
1316 if (PREDICT_TRUE (is_l20 != 0))
1318 vnet_buffer (b0)->l3_hdr_offset =
1319 vnet_buffer (b0)->l2_hdr_offset +
1320 sizeof (ethernet_header_t);
1321 vnet_buffer (b1)->l3_hdr_offset =
1322 vnet_buffer (b1)->l2_hdr_offset +
1323 sizeof (ethernet_header_t);
1324 b0->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
1325 b1->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
1326 next0 = em->l2_next;
1327 vnet_buffer (b0)->l2.l2_len = sizeof (ethernet_header_t);
1328 next1 = em->l2_next;
1329 vnet_buffer (b1)->l2.l2_len = sizeof (ethernet_header_t);
1333 dmacs[0] = *(u64 *) e0;
1334 dmacs[1] = *(u64 *) e1;
1336 if (ei && vec_len (ei->secondary_addrs))
1337 ethernet_input_inline_dmac_check (hi, dmacs,
1341 1 /* have_sec_dmac */ );
1343 ethernet_input_inline_dmac_check (hi, dmacs,
1347 0 /* have_sec_dmac */ );
1350 error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
1352 error1 = ETHERNET_ERROR_L3_MAC_MISMATCH;
1354 vlib_buffer_advance (b0, sizeof (ethernet_header_t));
1355 determine_next_node (em, variant, 0, type0, b0,
1357 vlib_buffer_advance (b1, sizeof (ethernet_header_t));
1358 determine_next_node (em, variant, 0, type1, b1,
1364 /* Slow-path for the tagged case */
1366 parse_header (variant,
1369 &orig_type0, &outer_id0, &inner_id0, &match_flags0);
1371 parse_header (variant,
1374 &orig_type1, &outer_id1, &inner_id1, &match_flags1);
1376 old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
1377 old_sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
1379 eth_vlan_table_lookups (em,
1386 &main_intf0, &vlan_intf0, &qinq_intf0);
1388 eth_vlan_table_lookups (em,
1395 &main_intf1, &vlan_intf1, &qinq_intf1);
1397 identify_subint (hi0,
1402 qinq_intf0, &new_sw_if_index0, &error0, &is_l20);
1404 identify_subint (hi1,
1409 qinq_intf1, &new_sw_if_index1, &error1, &is_l21);
1411 // Save RX sw_if_index for later nodes
1412 vnet_buffer (b0)->sw_if_index[VLIB_RX] =
1414 ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
1415 vnet_buffer (b1)->sw_if_index[VLIB_RX] =
1417 ETHERNET_ERROR_NONE ? old_sw_if_index1 : new_sw_if_index1;
1419 // Check if there is a stat to take (valid and non-main sw_if_index for pkt 0 or pkt 1)
1420 if (((new_sw_if_index0 != ~0)
1421 && (new_sw_if_index0 != old_sw_if_index0))
1422 || ((new_sw_if_index1 != ~0)
1423 && (new_sw_if_index1 != old_sw_if_index1)))
1426 len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
1427 - vnet_buffer (b0)->l2_hdr_offset;
1428 len1 = vlib_buffer_length_in_chain (vm, b1) + b1->current_data
1429 - vnet_buffer (b1)->l2_hdr_offset;
1431 stats_n_packets += 2;
1432 stats_n_bytes += len0 + len1;
1435 (!(new_sw_if_index0 == stats_sw_if_index
1436 && new_sw_if_index1 == stats_sw_if_index)))
1438 stats_n_packets -= 2;
1439 stats_n_bytes -= len0 + len1;
1441 if (new_sw_if_index0 != old_sw_if_index0
1442 && new_sw_if_index0 != ~0)
1443 vlib_increment_combined_counter (vnm->
1444 interface_main.combined_sw_if_counters
1446 VNET_INTERFACE_COUNTER_RX,
1448 new_sw_if_index0, 1,
1450 if (new_sw_if_index1 != old_sw_if_index1
1451 && new_sw_if_index1 != ~0)
1452 vlib_increment_combined_counter (vnm->
1453 interface_main.combined_sw_if_counters
1455 VNET_INTERFACE_COUNTER_RX,
1457 new_sw_if_index1, 1,
1460 if (new_sw_if_index0 == new_sw_if_index1)
1462 if (stats_n_packets > 0)
1464 vlib_increment_combined_counter
1465 (vnm->interface_main.combined_sw_if_counters
1466 + VNET_INTERFACE_COUNTER_RX,
1469 stats_n_packets, stats_n_bytes);
1470 stats_n_packets = stats_n_bytes = 0;
1472 stats_sw_if_index = new_sw_if_index0;
1477 if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
1478 is_l20 = is_l21 = 0;
1480 determine_next_node (em, variant, is_l20, type0, b0, &error0,
1482 determine_next_node (em, variant, is_l21, type1, b1, &error1,
1486 b0->error = error_node->errors[error0];
1487 b1->error = error_node->errors[error1];
1489 // verify speculative enqueue
1490 vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
1491 n_left_to_next, bi0, bi1, next0,
1495 while (n_left_from > 0 && n_left_to_next > 0)
1500 u16 type0, orig_type0;
1501 u16 outer_id0, inner_id0;
1503 u32 old_sw_if_index0, new_sw_if_index0, len0;
1504 vnet_hw_interface_t *hi0;
1505 main_intf_t *main_intf0;
1506 vlan_intf_t *vlan_intf0;
1507 qinq_intf_t *qinq_intf0;
1508 ethernet_header_t *e0;
1513 // Prefetch next iteration
1514 if (n_left_from > 1)
1516 vlib_prefetch_buffer_header (b[1], STORE);
1517 CLIB_PREFETCH (b[1]->data, CLIB_CACHE_LINE_BYTES, LOAD);
1525 n_left_to_next -= 1;
1530 error0 = ETHERNET_ERROR_NONE;
1531 e0 = vlib_buffer_get_current (b0);
1532 type0 = clib_net_to_host_u16 (e0->type);
1534 /* Set the L2 header offset for all packets */
1535 vnet_buffer (b0)->l2_hdr_offset = b0->current_data;
1536 b0->flags |= VNET_BUFFER_F_L2_HDR_OFFSET_VALID;
1538 /* Speed-path for the untagged case */
1539 if (PREDICT_TRUE (variant == ETHERNET_INPUT_VARIANT_ETHERNET
1540 && !ethernet_frame_is_tagged (type0)))
1543 subint_config_t *subint0;
1546 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
1547 is_l20 = cached_is_l2;
1549 if (PREDICT_FALSE (cached_sw_if_index != sw_if_index0))
1551 cached_sw_if_index = sw_if_index0;
1552 hi = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1553 ei = ethernet_get_interface (em, hi->hw_if_index);
1554 intf0 = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
1555 subint0 = &intf0->untagged_subint;
1556 cached_is_l2 = is_l20 = subint0->flags & SUBINT_CONFIG_L2;
1560 if (PREDICT_TRUE (is_l20 != 0))
1562 vnet_buffer (b0)->l3_hdr_offset =
1563 vnet_buffer (b0)->l2_hdr_offset +
1564 sizeof (ethernet_header_t);
1565 b0->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
1566 next0 = em->l2_next;
1567 vnet_buffer (b0)->l2.l2_len = sizeof (ethernet_header_t);
1571 dmacs[0] = *(u64 *) e0;
1573 if (ei && vec_len (ei->secondary_addrs))
1574 ethernet_input_inline_dmac_check (hi, dmacs,
1578 1 /* have_sec_dmac */ );
1580 ethernet_input_inline_dmac_check (hi, dmacs,
1584 0 /* have_sec_dmac */ );
1587 error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
1589 vlib_buffer_advance (b0, sizeof (ethernet_header_t));
1590 determine_next_node (em, variant, 0, type0, b0,
1596 /* Slow-path for the tagged case */
1597 parse_header (variant,
1600 &orig_type0, &outer_id0, &inner_id0, &match_flags0);
1602 old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
1604 eth_vlan_table_lookups (em,
1611 &main_intf0, &vlan_intf0, &qinq_intf0);
1613 identify_subint (hi0,
1618 qinq_intf0, &new_sw_if_index0, &error0, &is_l20);
1620 // Save RX sw_if_index for later nodes
1621 vnet_buffer (b0)->sw_if_index[VLIB_RX] =
1623 ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
1625 // Increment subinterface stats
1626 // Note that interface-level counters have already been incremented
1627 // prior to calling this function. Thus only subinterface counters
1628 // are incremented here.
1630 // Interface level counters include packets received on the main
1631 // interface and all subinterfaces. Subinterface level counters
1632 // include only those packets received on that subinterface
1633 // Increment stats if the subint is valid and it is not the main intf
1634 if ((new_sw_if_index0 != ~0)
1635 && (new_sw_if_index0 != old_sw_if_index0))
1638 len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
1639 - vnet_buffer (b0)->l2_hdr_offset;
1641 stats_n_packets += 1;
1642 stats_n_bytes += len0;
1644 // Batch stat increments from the same subinterface so counters
1645 // don't need to be incremented for every packet.
1646 if (PREDICT_FALSE (new_sw_if_index0 != stats_sw_if_index))
1648 stats_n_packets -= 1;
1649 stats_n_bytes -= len0;
1651 if (new_sw_if_index0 != ~0)
1652 vlib_increment_combined_counter
1653 (vnm->interface_main.combined_sw_if_counters
1654 + VNET_INTERFACE_COUNTER_RX,
1655 thread_index, new_sw_if_index0, 1, len0);
1656 if (stats_n_packets > 0)
1658 vlib_increment_combined_counter
1659 (vnm->interface_main.combined_sw_if_counters
1660 + VNET_INTERFACE_COUNTER_RX,
1662 stats_sw_if_index, stats_n_packets, stats_n_bytes);
1663 stats_n_packets = stats_n_bytes = 0;
1665 stats_sw_if_index = new_sw_if_index0;
1669 if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
1672 determine_next_node (em, variant, is_l20, type0, b0, &error0,
1676 b0->error = error_node->errors[error0];
1678 // verify speculative enqueue
1679 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1680 to_next, n_left_to_next,
1684 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1687 // Increment any remaining batched stats
1688 if (stats_n_packets > 0)
1690 vlib_increment_combined_counter
1691 (vnm->interface_main.combined_sw_if_counters
1692 + VNET_INTERFACE_COUNTER_RX,
1693 thread_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
1694 node->runtime_data[0] = stats_sw_if_index;
1698 VLIB_NODE_FN (ethernet_input_node) (vlib_main_t * vm,
1699 vlib_node_runtime_t * node,
1700 vlib_frame_t * frame)
1702 vnet_main_t *vnm = vnet_get_main ();
1703 u32 *from = vlib_frame_vector_args (frame);
1704 u32 n_packets = frame->n_vectors;
1706 ethernet_input_trace (vm, node, frame);
1708 if (frame->flags & ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX)
1710 ethernet_input_frame_t *ef = vlib_frame_scalar_args (frame);
1711 int ip4_cksum_ok = (frame->flags & ETH_INPUT_FRAME_F_IP4_CKSUM_OK) != 0;
1712 vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, ef->hw_if_index);
1713 eth_input_single_int (vm, node, hi, from, n_packets, ip4_cksum_ok);
1716 ethernet_input_inline (vm, node, from, n_packets,
1717 ETHERNET_INPUT_VARIANT_ETHERNET);
1721 VLIB_NODE_FN (ethernet_input_type_node) (vlib_main_t * vm,
1722 vlib_node_runtime_t * node,
1723 vlib_frame_t * from_frame)
1725 u32 *from = vlib_frame_vector_args (from_frame);
1726 u32 n_packets = from_frame->n_vectors;
1727 ethernet_input_trace (vm, node, from_frame);
1728 ethernet_input_inline (vm, node, from, n_packets,
1729 ETHERNET_INPUT_VARIANT_ETHERNET_TYPE);
1733 VLIB_NODE_FN (ethernet_input_not_l2_node) (vlib_main_t * vm,
1734 vlib_node_runtime_t * node,
1735 vlib_frame_t * from_frame)
1737 u32 *from = vlib_frame_vector_args (from_frame);
1738 u32 n_packets = from_frame->n_vectors;
1739 ethernet_input_trace (vm, node, from_frame);
1740 ethernet_input_inline (vm, node, from, n_packets,
1741 ETHERNET_INPUT_VARIANT_NOT_L2);
1746 // Return the subinterface config struct for the given sw_if_index
1747 // Also return via parameter the appropriate match flags for the
1748 // configured number of tags.
1749 // On error (unsupported or not ethernet) return 0.
1750 static subint_config_t *
1751 ethernet_sw_interface_get_config (vnet_main_t * vnm,
1753 u32 * flags, u32 * unsupported)
1755 ethernet_main_t *em = ðernet_main;
1756 vnet_hw_interface_t *hi;
1757 vnet_sw_interface_t *si;
1758 main_intf_t *main_intf;
1759 vlan_table_t *vlan_table;
1760 qinq_table_t *qinq_table;
1761 subint_config_t *subint = 0;
1763 hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1765 if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index))
1768 goto done; // non-ethernet interface
1771 // ensure there's an entry for the main intf (shouldn't really be necessary)
1772 vec_validate (em->main_intfs, hi->hw_if_index);
1773 main_intf = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
1775 // Locate the subint for the given ethernet config
1776 si = vnet_get_sw_interface (vnm, sw_if_index);
1778 if (si->type == VNET_SW_INTERFACE_TYPE_P2P)
1780 p2p_ethernet_main_t *p2pm = &p2p_main;
1781 u32 p2pe_sw_if_index =
1782 p2p_ethernet_lookup (hi->hw_if_index, si->p2p.client_mac);
1783 if (p2pe_sw_if_index == ~0)
1785 pool_get (p2pm->p2p_subif_pool, subint);
1786 si->p2p.pool_index = subint - p2pm->p2p_subif_pool;
1789 subint = vec_elt_at_index (p2pm->p2p_subif_pool, si->p2p.pool_index);
1790 *flags = SUBINT_CONFIG_P2P;
1792 else if (si->type == VNET_SW_INTERFACE_TYPE_PIPE)
1796 pipe = pipe_get (sw_if_index);
1797 subint = &pipe->subint;
1798 *flags = SUBINT_CONFIG_P2P;
1800 else if (si->sub.eth.flags.default_sub)
1802 subint = &main_intf->default_subint;
1803 *flags = SUBINT_CONFIG_MATCH_1_TAG |
1804 SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
1806 else if ((si->sub.eth.flags.no_tags) || (si->sub.eth.raw_flags == 0))
1808 // if no flags are set then this is a main interface
1809 // so treat as untagged
1810 subint = &main_intf->untagged_subint;
1811 *flags = SUBINT_CONFIG_MATCH_0_TAG;
1816 // first get the vlan table
1817 if (si->sub.eth.flags.dot1ad)
1819 if (main_intf->dot1ad_vlans == 0)
1821 // Allocate a vlan table from the pool
1822 pool_get (em->vlan_pool, vlan_table);
1823 main_intf->dot1ad_vlans = vlan_table - em->vlan_pool;
1827 // Get ptr to existing vlan table
1829 vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
1834 if (main_intf->dot1q_vlans == 0)
1836 // Allocate a vlan table from the pool
1837 pool_get (em->vlan_pool, vlan_table);
1838 main_intf->dot1q_vlans = vlan_table - em->vlan_pool;
1842 // Get ptr to existing vlan table
1844 vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
1848 if (si->sub.eth.flags.one_tag)
1850 *flags = si->sub.eth.flags.exact_match ?
1851 SUBINT_CONFIG_MATCH_1_TAG :
1852 (SUBINT_CONFIG_MATCH_1_TAG |
1853 SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG);
1855 if (si->sub.eth.flags.outer_vlan_id_any)
1857 // not implemented yet
1863 // a single vlan, a common case
1865 &vlan_table->vlans[si->sub.eth.
1866 outer_vlan_id].single_tag_subint;
1873 *flags = si->sub.eth.flags.exact_match ?
1874 SUBINT_CONFIG_MATCH_2_TAG :
1875 (SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG);
1877 if (si->sub.eth.flags.outer_vlan_id_any
1878 && si->sub.eth.flags.inner_vlan_id_any)
1880 // not implemented yet
1885 if (si->sub.eth.flags.inner_vlan_id_any)
1887 // a specific outer and "any" inner
1888 // don't need a qinq table for this
1890 &vlan_table->vlans[si->sub.eth.
1891 outer_vlan_id].inner_any_subint;
1892 if (si->sub.eth.flags.exact_match)
1894 *flags = SUBINT_CONFIG_MATCH_2_TAG;
1898 *flags = SUBINT_CONFIG_MATCH_2_TAG |
1899 SUBINT_CONFIG_MATCH_3_TAG;
1904 // a specific outer + specifc innner vlan id, a common case
1906 // get the qinq table
1907 if (vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs == 0)
1909 // Allocate a qinq table from the pool
1910 pool_get (em->qinq_pool, qinq_table);
1911 vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs =
1912 qinq_table - em->qinq_pool;
1916 // Get ptr to existing qinq table
1918 vec_elt_at_index (em->qinq_pool,
1919 vlan_table->vlans[si->sub.
1923 subint = &qinq_table->vlans[si->sub.eth.inner_vlan_id].subint;
1932 static clib_error_t *
1933 ethernet_sw_interface_up_down (vnet_main_t * vnm, u32 sw_if_index, u32 flags)
1935 subint_config_t *subint;
1938 clib_error_t *error = 0;
1940 // Find the config for this subinterface
1942 ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
1947 // not implemented yet or not ethernet
1951 subint->sw_if_index =
1952 ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? sw_if_index : ~0);
1958 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ethernet_sw_interface_up_down);
1961 #ifndef CLIB_MARCH_VARIANT
1962 // Set the L2/L3 mode for the subinterface
1964 ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm, u32 sw_if_index, u32 l2)
1966 subint_config_t *subint;
1970 vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index);
1972 is_port = !(sw->type == VNET_SW_INTERFACE_TYPE_SUB);
1974 // Find the config for this subinterface
1976 ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
1981 // unimplemented or not ethernet
1985 // Double check that the config we found is for our interface (or the interface is down)
1986 ASSERT ((subint->sw_if_index == sw_if_index) | (subint->sw_if_index == ~0));
1990 subint->flags |= SUBINT_CONFIG_L2;
1993 SUBINT_CONFIG_MATCH_0_TAG | SUBINT_CONFIG_MATCH_1_TAG
1994 | SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
1998 subint->flags &= ~SUBINT_CONFIG_L2;
2001 ~(SUBINT_CONFIG_MATCH_1_TAG | SUBINT_CONFIG_MATCH_2_TAG
2002 | SUBINT_CONFIG_MATCH_3_TAG);
2010 * Set the L2/L3 mode for the subinterface regardless of port
2013 ethernet_sw_interface_set_l2_mode_noport (vnet_main_t * vnm,
2014 u32 sw_if_index, u32 l2)
2016 subint_config_t *subint;
2020 /* Find the config for this subinterface */
2022 ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
2027 /* unimplemented or not ethernet */
2032 * Double check that the config we found is for our interface (or the
2033 * interface is down)
2035 ASSERT ((subint->sw_if_index == sw_if_index) | (subint->sw_if_index == ~0));
2039 subint->flags |= SUBINT_CONFIG_L2;
2043 subint->flags &= ~SUBINT_CONFIG_L2;
2051 static clib_error_t *
2052 ethernet_sw_interface_add_del (vnet_main_t * vnm,
2053 u32 sw_if_index, u32 is_create)
2055 clib_error_t *error = 0;
2056 subint_config_t *subint;
2058 u32 unsupported = 0;
2060 // Find the config for this subinterface
2062 ethernet_sw_interface_get_config (vnm, sw_if_index, &match_flags,
2067 // not implemented yet or not ethernet
2070 // this is the NYI case
2071 error = clib_error_return (0, "not implemented yet");
2082 // Initialize the subint
2083 if (subint->flags & SUBINT_CONFIG_VALID)
2085 // Error vlan already in use
2086 error = clib_error_return (0, "vlan is already in use");
2090 // Note that config is L3 by default
2091 subint->flags = SUBINT_CONFIG_VALID | match_flags;
2092 subint->sw_if_index = ~0; // because interfaces are initially down
2099 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ethernet_sw_interface_add_del);
2101 static char *ethernet_error_strings[] = {
2102 #define ethernet_error(n,c,s) s,
2103 #include "error.def"
2104 #undef ethernet_error
2108 VLIB_REGISTER_NODE (ethernet_input_node) = {
2109 .name = "ethernet-input",
2110 /* Takes a vector of packets. */
2111 .vector_size = sizeof (u32),
2112 .scalar_size = sizeof (ethernet_input_frame_t),
2113 .n_errors = ETHERNET_N_ERROR,
2114 .error_strings = ethernet_error_strings,
2115 .n_next_nodes = ETHERNET_INPUT_N_NEXT,
2117 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
2118 foreach_ethernet_input_next
2121 .format_buffer = format_ethernet_header_with_length,
2122 .format_trace = format_ethernet_input_trace,
2123 .unformat_buffer = unformat_ethernet_header,
2126 VLIB_REGISTER_NODE (ethernet_input_type_node) = {
2127 .name = "ethernet-input-type",
2128 /* Takes a vector of packets. */
2129 .vector_size = sizeof (u32),
2130 .n_next_nodes = ETHERNET_INPUT_N_NEXT,
2132 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
2133 foreach_ethernet_input_next
2138 VLIB_REGISTER_NODE (ethernet_input_not_l2_node) = {
2139 .name = "ethernet-input-not-l2",
2140 /* Takes a vector of packets. */
2141 .vector_size = sizeof (u32),
2142 .n_next_nodes = ETHERNET_INPUT_N_NEXT,
2144 #define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
2145 foreach_ethernet_input_next
2151 #ifndef CLIB_MARCH_VARIANT
2153 ethernet_set_rx_redirect (vnet_main_t * vnm,
2154 vnet_hw_interface_t * hi, u32 enable)
2156 // Insure all packets go to ethernet-input (i.e. untagged ipv4 packets
2157 // don't go directly to ip4-input)
2158 vnet_hw_interface_rx_redirect_to_node
2159 (vnm, hi->hw_if_index, enable ? ethernet_input_node.index : ~0);
2164 * Initialization and registration for the next_by_ethernet structure
2168 next_by_ethertype_init (next_by_ethertype_t * l3_next)
2170 l3_next->input_next_by_type = sparse_vec_new
2171 ( /* elt bytes */ sizeof (l3_next->input_next_by_type[0]),
2172 /* bits in index */ BITS (((ethernet_header_t *) 0)->type));
2174 vec_validate (l3_next->sparse_index_by_input_next_index,
2175 ETHERNET_INPUT_NEXT_DROP);
2176 vec_validate (l3_next->sparse_index_by_input_next_index,
2177 ETHERNET_INPUT_NEXT_PUNT);
2178 l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_DROP] =
2179 SPARSE_VEC_INVALID_INDEX;
2180 l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_PUNT] =
2181 SPARSE_VEC_INVALID_INDEX;
2184 * Make sure we don't wipe out an ethernet registration by mistake
2185 * Can happen if init function ordering constraints are missing.
2189 ethernet_main_t *em = ðernet_main;
2190 ASSERT (em->next_by_ethertype_register_called == 0);
2196 // Add an ethertype -> next index mapping to the structure
2198 next_by_ethertype_register (next_by_ethertype_t * l3_next,
2199 u32 ethertype, u32 next_index)
2203 ethernet_main_t *em = ðernet_main;
2207 ethernet_main_t *em = ðernet_main;
2208 em->next_by_ethertype_register_called = 1;
2211 /* Setup ethernet type -> next index sparse vector mapping. */
2212 n = sparse_vec_validate (l3_next->input_next_by_type, ethertype);
2215 /* Rebuild next index -> sparse index inverse mapping when sparse vector
2217 vec_validate (l3_next->sparse_index_by_input_next_index, next_index);
2218 for (i = 1; i < vec_len (l3_next->input_next_by_type); i++)
2220 sparse_index_by_input_next_index[l3_next->input_next_by_type[i]] = i;
2222 // do not allow the cached next index's to be updated if L3
2223 // redirect is enabled, as it will have overwritten them
2224 if (!em->redirect_l3)
2226 // Cache common ethertypes directly
2227 if (ethertype == ETHERNET_TYPE_IP4)
2229 l3_next->input_next_ip4 = next_index;
2231 else if (ethertype == ETHERNET_TYPE_IP6)
2233 l3_next->input_next_ip6 = next_index;
2235 else if (ethertype == ETHERNET_TYPE_MPLS)
2237 l3_next->input_next_mpls = next_index;
2244 ethernet_input_init (vlib_main_t * vm, ethernet_main_t * em)
2246 __attribute__ ((unused)) vlan_table_t *invalid_vlan_table;
2247 __attribute__ ((unused)) qinq_table_t *invalid_qinq_table;
2249 ethernet_setup_node (vm, ethernet_input_node.index);
2250 ethernet_setup_node (vm, ethernet_input_type_node.index);
2251 ethernet_setup_node (vm, ethernet_input_not_l2_node.index);
2253 next_by_ethertype_init (&em->l3_next);
2255 // Initialize pools and vector for vlan parsing
2256 vec_validate (em->main_intfs, 10); // 10 main interfaces
2257 pool_alloc (em->vlan_pool, 10);
2258 pool_alloc (em->qinq_pool, 1);
2260 // The first vlan pool will always be reserved for an invalid table
2261 pool_get (em->vlan_pool, invalid_vlan_table); // first id = 0
2262 // The first qinq pool will always be reserved for an invalid table
2263 pool_get (em->qinq_pool, invalid_qinq_table); // first id = 0
2267 ethernet_register_input_type (vlib_main_t * vm,
2268 ethernet_type_t type, u32 node_index)
2270 ethernet_main_t *em = ðernet_main;
2271 ethernet_type_info_t *ti;
2275 clib_error_t *error = vlib_call_init_function (vm, ethernet_init);
2277 clib_error_report (error);
2280 ti = ethernet_get_type_info (em, type);
2283 clib_warning ("type_info NULL for type %d", type);
2286 ti->node_index = node_index;
2287 ti->next_index = vlib_node_add_next (vm,
2288 ethernet_input_node.index, node_index);
2289 i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
2290 ASSERT (i == ti->next_index);
2292 i = vlib_node_add_next (vm, ethernet_input_not_l2_node.index, node_index);
2293 ASSERT (i == ti->next_index);
2295 // Add the L3 node for this ethertype to the next nodes structure
2296 next_by_ethertype_register (&em->l3_next, type, ti->next_index);
2298 // Call the registration functions for other nodes that want a mapping
2299 l2bvi_register_input_type (vm, type, node_index);
2303 ethernet_register_l2_input (vlib_main_t * vm, u32 node_index)
2305 ethernet_main_t *em = ðernet_main;
2309 vlib_node_add_next (vm, ethernet_input_node.index, node_index);
2312 * Even if we never use these arcs, we have to align the next indices...
2314 i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
2316 ASSERT (i == em->l2_next);
2318 i = vlib_node_add_next (vm, ethernet_input_not_l2_node.index, node_index);
2319 ASSERT (i == em->l2_next);
2322 // Register a next node for L3 redirect, and enable L3 redirect
2324 ethernet_register_l3_redirect (vlib_main_t * vm, u32 node_index)
2326 ethernet_main_t *em = ðernet_main;
2329 em->redirect_l3 = 1;
2330 em->redirect_l3_next = vlib_node_add_next (vm,
2331 ethernet_input_node.index,
2334 * Change the cached next nodes to the redirect node
2336 em->l3_next.input_next_ip4 = em->redirect_l3_next;
2337 em->l3_next.input_next_ip6 = em->redirect_l3_next;
2338 em->l3_next.input_next_mpls = em->redirect_l3_next;
2341 * Even if we never use these arcs, we have to align the next indices...
2343 i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
2345 ASSERT (i == em->redirect_l3_next);
2347 i = vlib_node_add_next (vm, ethernet_input_not_l2_node.index, node_index);
2349 ASSERT (i == em->redirect_l3_next);
2354 * fd.io coding-style-patch-verification: ON
2357 * eval: (c-set-style "gnu")