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 if (sw_if_index != (
u32) ~ 0)
56 u32 *fib_index_by_sw_if_index = is_ip4 ?
60 return vec_elt (fib_index_by_sw_if_index, sw_if_index);
67 .next_index = VXLAN_INPUT_NEXT_DROP,
68 .error = VXLAN_ERROR_NO_SUCH_TUNNEL
73 .next_index = VXLAN_INPUT_NEXT_DROP,
74 .error = VXLAN_ERROR_BAD_FLAGS
94 (key4.
key[0] == cache->
key[0] && key4.
key[1] == cache->
key[1]))
203 u32 pkts_dropped = 0;
217 u32 stats_if0 = ~0, stats_if1 = ~0;
219 while (n_left_from >= 4)
337 while (n_left_from > 0)
418 #define vxlan_error(n,s) s, 426 .name =
"vxlan4-input",
427 .vector_size =
sizeof (
u32),
433 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 441 .name =
"vxlan6-input",
442 .vector_size =
sizeof (
u32),
447 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n, 468 u32 *from, *to_next, n_left_from, n_left_to_next, next_index;
486 while (n_left_from > 0)
490 while (n_left_from >= 4 && n_left_to_next >= 2)
496 u32 bi0, ip_len0, udp_len0, flags0, next0;
497 u32 bi1, ip_len1, udp_len1, flags1, next1;
498 i32 len_diff0, len_diff1;
499 u8 error0, good_udp0, proto0;
500 u8 error1, good_udp1, proto1;
516 bi0 = to_next[0] = from[0];
517 bi1 = to_next[1] = from[1];
554 if (proto0 != IP_PROTOCOL_UDP)
562 if (udp0->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
586 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
593 ip_len0 = clib_net_to_host_u16 (ip40->
length);
596 udp_len0 = clib_net_to_host_u16 (udp0->
length);
597 len_diff0 = ip_len0 - udp_len0;
602 if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
609 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
615 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
616 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
620 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
621 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
626 b0->
error = error0 ? error_node->
errors[error0] : 0;
640 if (proto1 != IP_PROTOCOL_UDP)
648 if (udp1->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
672 good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
679 ip_len1 = clib_net_to_host_u16 (ip41->
length);
682 udp_len1 = clib_net_to_host_u16 (udp1->
length);
683 len_diff1 = ip_len1 - udp_len1;
688 if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
695 (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
701 error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
702 error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
706 error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
707 error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
712 b1->
error = error1 ? error_node->
errors[error1] : 0;
726 to_next, n_left_to_next,
727 bi0, bi1, next0, next1);
730 while (n_left_from > 0 && n_left_to_next > 0)
736 u32 bi0, ip_len0, udp_len0, flags0, next0;
738 u8 error0, good_udp0, proto0;
740 bi0 = to_next[0] = from[0];
762 if (proto0 != IP_PROTOCOL_UDP)
770 if (udp0->
dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
794 good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
801 ip_len0 = clib_net_to_host_u16 (ip40->
length);
804 udp_len0 = clib_net_to_host_u16 (udp0->
length);
805 len_diff0 = ip_len0 - udp_len0;
810 if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
817 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
823 error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
824 error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
828 error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
829 error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
834 b0->
error = error0 ? error_node->
errors[error0] : 0;
848 to_next, n_left_to_next,
868 .name =
"ip4-vxlan-bypass",
869 .vector_size =
sizeof (
u32),
900 .name =
"ip6-vxlan-bypass",
901 .vector_size =
sizeof (
u32),
922 #define foreach_vxlan_flow_input_next \ 923 _(DROP, "error-drop") \ 924 _(L2_INPUT, "l2-input") 928 #define _(s,n) VXLAN_FLOW_NEXT_##s, 934 #define foreach_vxlan_flow_error \ 935 _(NONE, "no error") \ 936 _(IP_CHECKSUM_ERROR, "Rx ip checksum errors") \ 937 _(IP_HEADER_ERROR, "Rx ip header errors") \ 938 _(UDP_CHECKSUM_ERROR, "Rx udp checksum errors") \ 939 _(UDP_LENGTH_ERROR, "Rx udp length errors") 943 #define _(f,s) VXLAN_FLOW_ERROR_##f, 966 if ((flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
973 return (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
982 u8 good_csum = (b->
flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0 ||
992 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
993 u16 expected = payload_len +
sizeof *hdr;
994 return ip_len > expected || hdr->ip4.ttl == 0
995 || hdr->ip4.ip_version_and_header_length != 0x45;
1002 u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
1003 u16 udp_len = clib_net_to_host_u16 (hdr->udp.length);
1004 return udp_len > ip_len;
1010 u8 error0 = VXLAN_FLOW_ERROR_NONE;
1012 error0 = VXLAN_FLOW_ERROR_IP_HEADER_ERROR;
1014 error0 = VXLAN_FLOW_ERROR_UDP_LENGTH_ERROR;
1016 error0 = VXLAN_FLOW_ERROR_UDP_CHECKSUM_ERROR;
1025 { payload_offset =
sizeof (ip4_vxlan_header_t) };
1030 [VXLAN_FLOW_NEXT_DROP] =
1032 [VXLAN_FLOW_NEXT_L2_INPUT] =
1038 u32 n_left_from = f->n_vectors;
1039 u32 next_index = VXLAN_FLOW_NEXT_L2_INPUT;
1041 while (n_left_from > 0)
1043 u32 n_left_to_next, *to_next;
1047 while (n_left_from > 3 && n_left_to_next > 3)
1049 u32 bi0 = to_next[0] = from[0];
1050 u32 bi1 = to_next[1] = from[1];
1051 u32 bi2 = to_next[2] = from[2];
1052 u32 bi3 = to_next[3] = from[3];
1056 n_left_to_next -= 4;
1073 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT, next1 =
1074 VXLAN_FLOW_NEXT_L2_INPUT, next2 =
1075 VXLAN_FLOW_NEXT_L2_INPUT, next3 = VXLAN_FLOW_NEXT_L2_INPUT;
1081 u8 ip_err = ip_err0 | ip_err1 | ip_err2 | ip_err3;
1087 u8 udp_err = udp_err0 | udp_err1 | udp_err2 | udp_err3;
1093 u8 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1105 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1110 if (ip_err0 || udp_err0 || csum_err0)
1112 next0 = VXLAN_FLOW_NEXT_DROP;
1114 b0->
error = node->errors[error0];
1116 if (ip_err1 || udp_err1 || csum_err1)
1118 next1 = VXLAN_FLOW_NEXT_DROP;
1120 b1->
error = node->errors[error1];
1122 if (ip_err2 || udp_err2 || csum_err2)
1124 next2 = VXLAN_FLOW_NEXT_DROP;
1126 b2->
error = node->errors[error2];
1128 if (ip_err3 || udp_err3 || csum_err3)
1130 next3 = VXLAN_FLOW_NEXT_DROP;
1132 b3->
error = node->errors[error3];
1172 sw_if_index0, 1, len0);
1174 sw_if_index1, 1, len1);
1176 sw_if_index2, 1, len2);
1178 sw_if_index3, 1, len3);
1184 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
1194 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
1204 if (b2->
flags & VLIB_BUFFER_IS_TRACED)
1214 if (b3->
flags & VLIB_BUFFER_IS_TRACED)
1226 (vm, node, next_index, to_next, n_left_to_next,
1227 bi0, bi1, bi2, bi3, next0, next1, next2, next3);
1229 while (n_left_from > 0 && n_left_to_next > 0)
1231 u32 bi0 = to_next[0] = from[0];
1241 u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT;
1249 if (ip_err0 || udp_err0 || csum_err0)
1251 next0 = VXLAN_FLOW_NEXT_DROP;
1253 b0->
error = node->errors[error0];
1266 sw_if_index0, 1, len0);
1279 to_next, n_left_to_next,
1286 return f->n_vectors;
1290 #ifndef CLIB_MULTIARCH_VARIANT 1292 .name =
"vxlan-flow-input",
1294 .vector_size =
sizeof (
u32),
1303 #define _(s,n) [VXLAN_FLOW_NEXT_##s] = n, static_always_inline u8 vxlan_validate_udp_csum(vlib_main_t *vm, vlib_buffer_t *b)
#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)
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
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 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)
#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).
vlib_error_t error
Error code for buffers to be enqueued to error handler.
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
#define VLIB_REGISTER_NODE(x,...)
static u32 vnet_get_vni(vxlan_header_t *h)
u32 flow_id
Generic flow identifier.
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)
static void ip6_address_set_zero(ip6_address_t *a)
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)
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 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)
#define vec_elt(v, i)
Get vector value at index i.
struct _vlib_node_registration vlib_node_registration_t
template key/value backing page structure
static u32 buf_fib_index(vlib_buffer_t *b, u32 is_ip4)
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)
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
#define hash_get_mem(h, key)
static u8 * format_vxlan_rx_trace(u8 *s, va_list *args)
ip4_main_t ip4_main
Global ip4 main structure.
clib_bihash_16_8_t vxlan4_tunnel_by_key
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
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
u32 * fib_index_by_sw_if_index
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)