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
80 (key4.
key[0] == cache->
key[0] && key4.
key[1] == cache->
key[1]))
189 u32 pkts_dropped = 0;
203 u32 stats_if0 = ~0, stats_if1 = ~0;
205 while (n_left_from >= 4)
323 while (n_left_from > 0)
404 #define vxlan_error(n,s) s, 412 .name =
"vxlan4-input",
413 .vector_size =
sizeof (
u32),
419 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 427 .name =
"vxlan6-input",
428 .vector_size =
sizeof (
u32),
433 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 454 u32 *from, *to_next, n_left_from, n_left_to_next, next_index;
457 vtep4_key_t last_vtep4;
459 vtep6_key_t last_vtep6;
474 while (n_left_from > 0)
478 while (n_left_from >= 4 && n_left_to_next >= 2)
484 u32 bi0, ip_len0, udp_len0, flags0, next0;
485 u32 bi1, ip_len1, udp_len1, flags1, next1;
486 i32 len_diff0, len_diff1;
487 u8 error0, good_udp0, proto0;
488 u8 error1, good_udp1, proto1;
504 bi0 = to_next[0] = from[0];
505 bi1 = to_next[1] = from[1];
542 if (proto0 != IP_PROTOCOL_UDP)
550 if (udp0->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
566 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
573 ip_len0 = clib_net_to_host_u16 (ip40->
length);
576 udp_len0 = clib_net_to_host_u16 (udp0->
length);
577 len_diff0 = ip_len0 - udp_len0;
582 if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
589 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
595 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
596 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
600 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
601 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
606 b0->
error = error0 ? error_node->
errors[error0] : 0;
620 if (proto1 != IP_PROTOCOL_UDP)
628 if (udp1->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
644 good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
651 ip_len1 = clib_net_to_host_u16 (ip41->
length);
654 udp_len1 = clib_net_to_host_u16 (udp1->
length);
655 len_diff1 = ip_len1 - udp_len1;
660 if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
667 (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
673 error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
674 error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
678 error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
679 error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
684 b1->
error = error1 ? error_node->
errors[error1] : 0;
698 to_next, n_left_to_next,
699 bi0, bi1, next0, next1);
702 while (n_left_from > 0 && n_left_to_next > 0)
708 u32 bi0, ip_len0, udp_len0, flags0, next0;
710 u8 error0, good_udp0, proto0;
712 bi0 = to_next[0] = from[0];
734 if (proto0 != IP_PROTOCOL_UDP)
742 if (udp0->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
758 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
765 ip_len0 = clib_net_to_host_u16 (ip40->
length);
768 udp_len0 = clib_net_to_host_u16 (udp0->
length);
769 len_diff0 = ip_len0 - udp_len0;
774 if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
781 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
787 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
788 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
792 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
793 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
798 b0->
error = error0 ? error_node->
errors[error0] : 0;
812 to_next, n_left_to_next,
832 .name =
"ip4-vxlan-bypass",
833 .vector_size =
sizeof (
u32),
864 .name =
"ip6-vxlan-bypass",
865 .vector_size =
sizeof (
u32),
886 #define foreach_vxlan_flow_input_next \ 887 _(DROP, "error-drop") \ 888 _(L2_INPUT, "l2-input") 892 #define _(s,n) VXLAN_FLOW_NEXT_##s, 898 #define foreach_vxlan_flow_error \ 899 _(NONE, "no error") \ 900 _(IP_CHECKSUM_ERROR, "Rx ip checksum errors") \ 901 _(IP_HEADER_ERROR, "Rx ip header errors") \ 902 _(UDP_CHECKSUM_ERROR, "Rx udp checksum errors") \ 903 _(UDP_LENGTH_ERROR, "Rx udp length errors") 907 #define _(f,s) VXLAN_FLOW_ERROR_##f, 930 if ((flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
937 return (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
946 u8 good_csum = (b->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0 ||
956 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
957 u16 expected = payload_len +
sizeof *hdr;
958 return ip_len > expected || hdr->ip4.ttl == 0
959 || hdr->ip4.ip_version_and_header_length != 0x45;
966 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
967 u16 udp_len = clib_net_to_host_u16 (hdr->udp.length);
968 return udp_len > ip_len;
974 u8 error0 = VXLAN_FLOW_ERROR_NONE;
976 error0 = VXLAN_FLOW_ERROR_IP_HEADER_ERROR;
978 error0 = VXLAN_FLOW_ERROR_UDP_LENGTH_ERROR;
980 error0 = VXLAN_FLOW_ERROR_UDP_CHECKSUM_ERROR;
989 { payload_offset =
sizeof (ip4_vxlan_header_t) };
994 [VXLAN_FLOW_NEXT_DROP] =
996 [VXLAN_FLOW_NEXT_L2_INPUT] =
1002 u32 n_left_from = f->n_vectors;
1003 u32 next_index = VXLAN_FLOW_NEXT_L2_INPUT;
1005 while (n_left_from > 0)
1007 u32 n_left_to_next, *to_next;
1011 while (n_left_from > 3 && n_left_to_next > 3)
1013 u32 bi0 = to_next[0] = from[0];
1014 u32 bi1 = to_next[1] = from[1];
1015 u32 bi2 = to_next[2] = from[2];
1016 u32 bi3 = to_next[3] = from[3];
1020 n_left_to_next -= 4;
1037 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT, next1 =
1038 VXLAN_FLOW_NEXT_L2_INPUT, next2 =
1039 VXLAN_FLOW_NEXT_L2_INPUT, next3 = VXLAN_FLOW_NEXT_L2_INPUT;
1045 u8 ip_err = ip_err0 | ip_err1 | ip_err2 | ip_err3;
1051 u8 udp_err = udp_err0 | udp_err1 | udp_err2 | udp_err3;
1057 u8 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1069 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1074 if (ip_err0 || udp_err0 || csum_err0)
1076 next0 = VXLAN_FLOW_NEXT_DROP;
1080 if (ip_err1 || udp_err1 || csum_err1)
1082 next1 = VXLAN_FLOW_NEXT_DROP;
1086 if (ip_err2 || udp_err2 || csum_err2)
1088 next2 = VXLAN_FLOW_NEXT_DROP;
1092 if (ip_err3 || udp_err3 || csum_err3)
1094 next3 = VXLAN_FLOW_NEXT_DROP;
1136 sw_if_index0, 1, len0);
1138 sw_if_index1, 1, len1);
1140 sw_if_index2, 1, len2);
1142 sw_if_index3, 1, len3);
1148 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1158 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
1168 if (b2->
flags & VLIB_BUFFER_IS_TRACED)
1178 if (b3->
flags & VLIB_BUFFER_IS_TRACED)
1190 (vm,
node, next_index, to_next, n_left_to_next,
1191 bi0, bi1, bi2, bi3, next0, next1, next2, next3);
1193 while (n_left_from > 0 && n_left_to_next > 0)
1195 u32 bi0 = to_next[0] = from[0];
1205 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT;
1213 if (ip_err0 || udp_err0 || csum_err0)
1215 next0 = VXLAN_FLOW_NEXT_DROP;
1230 sw_if_index0, 1, len0);
1243 to_next, n_left_to_next,
1250 return f->n_vectors;
1254 #ifndef CLIB_MULTIARCH_VARIANT 1256 .name =
"vxlan-flow-input",
1258 .vector_size =
sizeof (
u32),
1267 #define _(s,n) [VXLAN_FLOW_NEXT_##s] = n, static_always_inline u8 vxlan_validate_udp_csum(vlib_main_t *vm, vlib_buffer_t *b)
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
#define foreach_vxlan_flow_error
clib_bihash_24_8_t vxlan6_tunnel_by_key
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
static char * vxlan_flow_error_strings[]
vnet_interface_main_t interface_main
vlib_node_registration_t vxlan4_input_node
(constructor) VLIB_REGISTER_NODE (vxlan4_input_node)
#define foreach_vxlan_input_next
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static const vxlan_decap_info_t decap_not_found
static const vxlan_decap_info_t decap_bad_flags
static uword vxlan_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u32 is_ip4)
#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.
vlib_node_registration_t vxlan4_flow_input_node
(constructor) VLIB_REGISTER_NODE (vxlan4_flow_input_node)
vlib_node_registration_t ip4_vxlan_bypass_node
(constructor) VLIB_REGISTER_NODE (ip4_vxlan_bypass_node)
#define VLIB_NODE_FN(node)
static uword ip4_address_is_multicast(const ip4_address_t *a)
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.
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_combined_counter_main_t * combined_sw_if_counters
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
static void * ip4_next_header(ip4_header_t *i)
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.
static_always_inline u8 vxlan_check_ip_udp_len(vlib_buffer_t *b)
vlib_node_registration_t ip4_input_node
Global ip4 input node.
vlib_node_registration_t ip6_vxlan_bypass_node
(constructor) VLIB_REGISTER_NODE (ip6_vxlan_bypass_node)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
vlib_node_registration_t vxlan6_input_node
(constructor) VLIB_REGISTER_NODE (vxlan6_input_node)
#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.
vxlan4_tunnel_key_t last_tunnel_cache4
#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).
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)
#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)
static_always_inline void vlib_buffer_enqueue_to_next(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u16 *nexts, uword count)
u32 flow_id
Generic flow identifier.
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
static_always_inline u8 vxlan_check_udp_csum(vlib_main_t *vm, vlib_buffer_t *b)
static char * vxlan_error_strings[]
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
vxlan6_tunnel_key_t last_tunnel_cache6
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
static_always_inline u8 vxlan_check_ip(vlib_buffer_t *b, u16 payload_len)
static clib_error_t * ip6_vxlan_bypass_init(vlib_main_t *vm)
vlib_main_t vlib_node_runtime_t * node
static void * ip6_next_header(ip6_header_t *i)
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
#define foreach_vxlan_flow_input_next
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)
static void vtep6_key_init(vtep6_key_t *k6)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
static uword ip6_address_is_equal(const ip6_address_t *a, const ip6_address_t *b)
static clib_error_t * ip4_vxlan_bypass_init(vlib_main_t *vm)
static uword ip6_address_is_multicast(const ip6_address_t *a)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
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)
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)
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.
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
static_always_inline u8 vxlan_err_code(u8 ip_err0, u8 udp_err0, u8 csum_err0)
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
A collection of combined counters.
u32 * tunnel_index_by_sw_if_index
static u8 * format_vxlan_rx_trace(u8 *s, va_list *args)
clib_bihash_16_8_t vxlan4_tunnel_by_key
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
u16 flags
Copy of main node flags.
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
#define VLIB_NODE_FLAG_TRACE
#define CLIB_CACHE_LINE_BYTES
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static uword ip_vxlan_bypass_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u32 is_ip4)
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)