22 #ifndef CLIB_MARCH_VARIANT 43 return format (s,
"VXLAN decap error - tunnel for vni %d does not exist",
45 return format (s,
"VXLAN decap from vxlan_tunnel%d vni %d next %d error %d",
53 .next_index = VXLAN_INPUT_NEXT_DROP,
54 .error = VXLAN_ERROR_NO_SUCH_TUNNEL
59 .next_index = VXLAN_INPUT_NEXT_DROP,
60 .error = VXLAN_ERROR_BAD_FLAGS
83 (key4.
key[0] == cache->
key[0] && key4.
key[1] == cache->
key[1]))
195 u32 pkts_dropped = 0;
209 u32 stats_if0 = ~0, stats_if1 = ~0;
211 while (n_left_from >= 4)
329 while (n_left_from > 0)
410 #define vxlan_error(n,s) s, 418 .name =
"vxlan4-input",
419 .vector_size =
sizeof (
u32),
425 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 433 .name =
"vxlan6-input",
434 .vector_size =
sizeof (
u32),
439 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 463 vtep4_key_t last_vtep4;
465 vtep6_key_t last_vtep6;
492 while (n_left_from > 0)
496 while (n_left_from >= 4 && n_left_to_next >= 2)
503 u32 bi0, ip_len0, udp_len0, flags0, next0;
504 u32 bi1, ip_len1, udp_len1, flags1, next1;
505 i32 len_diff0, len_diff1;
506 u8 error0, good_udp0, proto0;
507 u8 error1, good_udp1, proto1;
508 u32 stats_if0 = ~0, stats_if1 = ~0;
519 bi0 = to_next[0] = from[0];
520 bi1 = to_next[1] = from[1];
558 if (proto0 != IP_PROTOCOL_UDP)
581 #ifdef CLIB_HAVE_VEC512 582 if (!vtep4_check_vector (&vxm->
vtep_table, b0, ip40, &last_vtep4,
596 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
603 ip_len0 = clib_net_to_host_u16 (ip40->
length);
606 udp_len0 = clib_net_to_host_u16 (udp0->
length);
607 len_diff0 = ip_len0 - udp_len0;
616 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
621 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
622 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
626 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
627 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
632 b0->
error = error0 ? error_node->
errors[error0] : 0;
646 if (proto1 != IP_PROTOCOL_UDP)
669 #ifdef CLIB_HAVE_VEC512 670 if (!vtep4_check_vector (&vxm->
vtep_table, b1, ip41, &last_vtep4,
684 good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
691 ip_len1 = clib_net_to_host_u16 (ip41->
length);
694 udp_len1 = clib_net_to_host_u16 (udp1->
length);
695 len_diff1 = ip_len1 - udp_len1;
704 good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
709 error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
710 error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
714 error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
715 error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
720 b1->
error = error1 ? error_node->
errors[error1] : 0;
734 to_next, n_left_to_next,
735 bi0, bi1, next0, next1);
738 while (n_left_from > 0 && n_left_to_next > 0)
745 u32 bi0, ip_len0, udp_len0, flags0, next0;
747 u8 error0, good_udp0, proto0;
750 bi0 = to_next[0] = from[0];
773 if (proto0 != IP_PROTOCOL_UDP)
796 #ifdef CLIB_HAVE_VEC512 797 if (!vtep4_check_vector (&vxm->
vtep_table, b0, ip40, &last_vtep4,
811 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
818 ip_len0 = clib_net_to_host_u16 (ip40->
length);
821 udp_len0 = clib_net_to_host_u16 (udp0->
length);
822 len_diff0 = ip_len0 - udp_len0;
831 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
836 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
837 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
841 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
842 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
847 b0->
error = error0 ? error_node->
errors[error0] : 0;
861 to_next, n_left_to_next,
881 .name =
"ip4-vxlan-bypass",
882 .vector_size =
sizeof (
u32),
913 .name =
"ip6-vxlan-bypass",
914 .vector_size =
sizeof (
u32),
935 #define foreach_vxlan_flow_input_next \ 936 _(DROP, "error-drop") \ 937 _(L2_INPUT, "l2-input") 941 #define _(s,n) VXLAN_FLOW_NEXT_##s, 947 #define foreach_vxlan_flow_error \ 948 _(NONE, "no error") \ 949 _(IP_CHECKSUM_ERROR, "Rx ip checksum errors") \ 950 _(IP_HEADER_ERROR, "Rx ip header errors") \ 951 _(UDP_CHECKSUM_ERROR, "Rx udp checksum errors") \ 952 _(UDP_LENGTH_ERROR, "Rx udp length errors") 956 #define _(f,s) VXLAN_FLOW_ERROR_##f, 979 if ((flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
986 return (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
995 u8 good_csum = (b->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0 ||
1005 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
1006 u16 expected = payload_len +
sizeof *hdr;
1007 return ip_len > expected || hdr->ip4.ttl == 0
1008 || hdr->ip4.ip_version_and_header_length != 0x45;
1015 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
1016 u16 udp_len = clib_net_to_host_u16 (hdr->udp.length);
1017 return udp_len > ip_len;
1023 u8 error0 = VXLAN_FLOW_ERROR_NONE;
1025 error0 = VXLAN_FLOW_ERROR_IP_HEADER_ERROR;
1027 error0 = VXLAN_FLOW_ERROR_UDP_LENGTH_ERROR;
1029 error0 = VXLAN_FLOW_ERROR_UDP_CHECKSUM_ERROR;
1038 { payload_offset =
sizeof (ip4_vxlan_header_t) };
1043 [VXLAN_FLOW_NEXT_DROP] =
1045 [VXLAN_FLOW_NEXT_L2_INPUT] =
1054 while (n_left_from > 0)
1056 u32 n_left_to_next, *to_next;
1060 while (n_left_from > 3 && n_left_to_next > 3)
1062 u32 bi0 = to_next[0] = from[0];
1063 u32 bi1 = to_next[1] = from[1];
1064 u32 bi2 = to_next[2] = from[2];
1065 u32 bi3 = to_next[3] = from[3];
1069 n_left_to_next -= 4;
1086 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT, next1 =
1087 VXLAN_FLOW_NEXT_L2_INPUT, next2 =
1088 VXLAN_FLOW_NEXT_L2_INPUT, next3 = VXLAN_FLOW_NEXT_L2_INPUT;
1094 u8 ip_err = ip_err0 | ip_err1 | ip_err2 | ip_err3;
1100 u8 udp_err = udp_err0 | udp_err1 | udp_err2 | udp_err3;
1106 u8 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1118 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1123 if (ip_err0 || udp_err0 || csum_err0)
1125 next0 = VXLAN_FLOW_NEXT_DROP;
1129 if (ip_err1 || udp_err1 || csum_err1)
1131 next1 = VXLAN_FLOW_NEXT_DROP;
1135 if (ip_err2 || udp_err2 || csum_err2)
1137 next2 = VXLAN_FLOW_NEXT_DROP;
1141 if (ip_err3 || udp_err3 || csum_err3)
1143 next3 = VXLAN_FLOW_NEXT_DROP;
1185 sw_if_index0, 1, len0);
1187 sw_if_index1, 1, len1);
1189 sw_if_index2, 1, len2);
1191 sw_if_index3, 1, len3);
1197 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1207 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
1217 if (b2->
flags & VLIB_BUFFER_IS_TRACED)
1227 if (b3->
flags & VLIB_BUFFER_IS_TRACED)
1239 (vm,
node, next_index, to_next, n_left_to_next,
1240 bi0, bi1, bi2, bi3, next0, next1, next2, next3);
1242 while (n_left_from > 0 && n_left_to_next > 0)
1244 u32 bi0 = to_next[0] = from[0];
1254 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT;
1262 if (ip_err0 || udp_err0 || csum_err0)
1264 next0 = VXLAN_FLOW_NEXT_DROP;
1279 sw_if_index0, 1, len0);
1292 to_next, n_left_to_next,
1303 #ifndef CLIB_MULTIARCH_VARIANT 1305 .name =
"vxlan-flow-input",
1307 .vector_size =
sizeof (
u32),
1316 #define _(s,n) [VXLAN_FLOW_NEXT_##s] = n, u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
vlib_node_registration_t vxlan6_input_node
(constructor) VLIB_REGISTER_NODE (vxlan6_input_node)
static uword ip_vxlan_bypass_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u32 is_ip4)
static uword vxlan_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u32 is_ip4)
vl_api_wireguard_peer_flags_t flags
clib_bihash_24_8_t vxlan6_tunnel_by_key
vlib_main_t vlib_node_runtime_t vlib_frame_t * from_frame
static_always_inline u8 vxlan_check_ip(vlib_buffer_t *b, u16 payload_len)
static vxlan_decap_info_t vxlan6_find_tunnel(vxlan_main_t *vxm, last_tunnel_cache6 *cache, u32 fib_index, ip6_header_t *ip6_0, vxlan_header_t *vxlan0, u32 *stats_sw_if_index)
vnet_interface_main_t interface_main
#define foreach_vxlan_input_next
u16 nexts[VLIB_FRAME_SIZE]
vlib_increment_combined_counter(ccm, ti, sw_if_index, n_buffers, n_bytes)
vlib_node_registration_t vxlan4_input_node
(constructor) VLIB_REGISTER_NODE (vxlan4_input_node)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
#define vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, bi2, bi3, next0, next1, next2, next3)
Finish enqueueing four buffers forward in the graph.
#define VLIB_NODE_FN(node)
static uword ip4_address_is_multicast(const ip4_address_t *a)
vlib_node_registration_t ip4_vxlan_bypass_node
(constructor) VLIB_REGISTER_NODE (ip4_vxlan_bypass_node)
vlib_error_t * errors
Vector of errors for this node.
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
vlib_node_registration_t ip6_vxlan_bypass_node
(constructor) VLIB_REGISTER_NODE (ip6_vxlan_bypass_node)
static const vxlan_decap_info_t decap_not_found
static u32 vlib_buffer_get_ip_fib_index(vlib_buffer_t *b, u8 is_ip4)
static int ip4_is_fragment(const ip4_header_t *i)
static int clib_bihash_key_compare_24_8(u64 *a, u64 *b)
#define static_always_inline
#define VLIB_INIT_FUNCTION(x)
vlib_get_buffers(vm, from, b, n_left_from)
vlib_combined_counter_main_t * combined_sw_if_counters
description fragment has unexpected format
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
static vxlan_decap_info_t vxlan4_find_tunnel(vxlan_main_t *vxm, last_tunnel_cache4 *cache, u32 fib_index, ip4_header_t *ip4_0, vxlan_header_t *vxlan0, u32 *stats_sw_if_index)
static void * ip4_next_header(ip4_header_t *i)
vlib_buffer_enqueue_to_next(vm, node, from,(u16 *) nexts, frame->n_vectors)
static_always_inline u8 vxlan_err_code(u8 ip_err0, u8 udp_err0, u8 csum_err0)
static void vtep4_key_init(vtep4_key_t *k4)
vlib_error_t error
Error code for buffers to be enqueued to error handler.
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
vlib_node_registration_t ip4_input_node
Global ip4 input node.
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
static u8 * format_vxlan_rx_trace(u8 *s, va_list *args)
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
vlib_node_registration_t vxlan4_flow_input_node
(constructor) VLIB_REGISTER_NODE (vxlan4_flow_input_node)
static u8 vtep6_check(vtep_table_t *t, vlib_buffer_t *b0, ip6_header_t *ip60, vtep6_key_t *last_k6)
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
static u8 vtep4_check(vtep_table_t *t, vlib_buffer_t *b0, ip4_header_t *ip40, vtep4_key_t *last_k4)
static const vxlan_decap_info_t decap_bad_flags
#define VLIB_REGISTER_NODE(x,...)
static u32 vnet_get_vni(vxlan_header_t *h)
static_always_inline uword vlib_get_thread_index(void)
#define CLIB_PREFETCH(addr, size, type)
vxlan6_tunnel_key_t last_tunnel_cache6
u32 flow_id
Generic flow identifier.
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
vnet_interface_main_t * im
#define foreach_vxlan_flow_error
static clib_error_t * ip6_vxlan_bypass_init(vlib_main_t *vm)
static void * ip6_next_header(ip6_header_t *i)
static char * vxlan_flow_error_strings[]
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
static clib_error_t * ip4_vxlan_bypass_init(vlib_main_t *vm)
static void vtep6_key_init(vtep6_key_t *k6)
vlib_put_next_frame(vm, node, next_index, 0)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
static_always_inline u8 vxlan_validate_udp_csum(vlib_main_t *vm, vlib_buffer_t *b)
nat44_ei_hairpin_src_next_t next_index
static uword ip6_address_is_equal(const ip6_address_t *a, const ip6_address_t *b)
static uword ip6_address_is_multicast(const ip6_address_t *a)
struct _vlib_node_registration vlib_node_registration_t
template key/value backing page structure
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
vlib_main_t vlib_node_runtime_t * node
void ip4_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
VLIB buffer representation.
vxlan4_tunnel_key_t last_tunnel_cache4
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
A collection of combined counters.
static_always_inline u8 vxlan_check_ip_udp_len(vlib_buffer_t *b)
u32 * tunnel_index_by_sw_if_index
#define foreach_vxlan_flow_input_next
clib_bihash_16_8_t vxlan4_tunnel_by_key
static_always_inline u8 vxlan_check_udp_csum(vlib_main_t *vm, vlib_buffer_t *b)
u16 flags
Copy of main node flags.
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
#define VLIB_NODE_FLAG_TRACE
#define CLIB_CACHE_LINE_BYTES
vlib_buffer_t * bufs[VLIB_FRAME_SIZE]
static char * vxlan_error_strings[]
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)