72 s =
format (s,
"sw_if_index: %d\n%U%U",
120 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
127 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
148 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
168 int is_ip4 = (b->
flags & VNET_BUFFER_F_IS_IP4) != 0;
169 int is_ip6 = (b->
flags & VNET_BUFFER_F_IS_IP6) != 0;
171 ASSERT (!(is_ip4 && is_ip6));
181 if (b->
flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM)
183 if (b->
flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
188 if (b->
flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
194 if (b->
flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
196 if (b->
flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
200 b->
flags &= ~VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
201 b->
flags &= ~VNET_BUFFER_F_OFFLOAD_UDP_CKSUM;
202 b->
flags &= ~VNET_BUFFER_F_OFFLOAD_IP_CKSUM;
214 u32 n_left_to_tx, *from, *from_end, *to_tx;
215 u32 n_bytes, n_buffers, n_packets;
216 u32 n_bytes_b0, n_bytes_b1, n_bytes_b2, n_bytes_b3;
220 u32 current_config_index = ~0;
221 u8 arc = im->output_feature_arc_index;
259 from_end = from + n_buffers;
276 while (from < from_end)
282 while (from + 8 <= from_end && n_left_to_tx >= 4)
284 u32 bi0, bi1, bi2, bi3;
286 u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
328 n_bytes += n_bytes_b0 + n_bytes_b1;
329 n_bytes += n_bytes_b2 + n_bytes_b3;
349 thread_index, tx_swif0, 1,
358 thread_index, tx_swif1, 1,
367 thread_index, tx_swif2, 1,
375 thread_index, tx_swif3, 1,
384 (VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
385 VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
386 VNET_BUFFER_F_OFFLOAD_IP_CKSUM))
396 while (from + 1 <= from_end && n_left_to_tx >= 1)
416 n_bytes += n_bytes_b0;
430 thread_index, tx_swif0, 1,
476 u32 n_left_to_next, *from, *to_next;
477 u32 n_left_from, next_index;
484 while (n_left_from > 0)
488 while (n_left_from >= 4 && n_left_to_next >= 2)
490 u32 bi0, bi1, next0, next1;
523 n_left_to_next, bi0, bi1, next0,
527 while (n_left_from > 0 && n_left_to_next > 0)
550 n_left_to_next, bi0, next0);
569 ASSERT (ci < n->n_errors);
597 u32 n_left, *buffers;
618 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
623 if (b1->
flags & VLIB_BUFFER_IS_TRACED)
642 if (b0->
flags & VLIB_BUFFER_IS_TRACED)
660 return format (0,
"[%d], node index out of range 0x%x, error 0x%x",
661 index, node_index, e[0]);
665 return format (0,
"[%d], code %d out of range for node %v",
666 index, code, n->
name);
714 u32 *buffers, *first_buffer;
716 u32 current_counter_index, n_errors_left;
717 u32 current_sw_if_index, n_errors_current_sw_if_index;
726 first_buffer = buffers;
731 if (!memory_init[disposition])
733 memory_init[disposition] = 1;
734 memory[disposition] = b->
error;
738 n_errors_current_sw_if_index = 0;
741 current_error = memory[disposition];
742 current_counter_index =
counter_index (vm, memory[disposition]);
743 current_counter = em->
counters[current_counter_index];
754 while (n_errors_left >= 2)
760 u32 sw_if_index0, sw_if_index1;
778 n_errors_current_sw_if_index += 2;
782 current_counter += 2;
785 || e1 != current_error
786 || sw_if_index0 != current_sw_if_index
787 || sw_if_index1 != current_sw_if_index))
789 current_counter -= 2;
790 n_errors_current_sw_if_index -= 2;
807 em->
counters[current_counter_index] = current_counter;
812 if (e0 == e1 && e1 != current_error)
817 current_counter = em->
counters[current_counter_index];
821 while (n_errors_left >= 1)
826 u32 bi0, sw_if_index0;
832 current_counter += 1;
850 current_counter -= 1;
854 - em->
counters[current_counter_index]));
856 em->
counters[current_counter_index] = current_counter;
861 current_counter = em->
counters[current_counter_index];
865 if (n_errors_current_sw_if_index > 0)
870 n_errors_current_sw_if_index);
875 n_errors_current_sw_if_index);
880 - em->
counters[current_counter_index]));
883 em->
counters[current_counter_index] = current_counter;
886 memory[disposition] = current_error;
910 i16 save_current_data;
911 u16 save_current_length;
990 .name =
"error-drop",
992 .vector_size =
sizeof (
u32),
1005 .
name =
"error-punt",
1006 .vector_size =
sizeof (
u32),
1017 .name =
"interface-output",
1018 .vector_size =
sizeof (
u32),
1030 u32 last_sw_if_index = ~0;
1033 u32 *from, *to_next = 0;
1038 while (n_left_from > 0)
1050 if (
PREDICT_FALSE ((last_sw_if_index != sw_if_index0) || to_frame == 0))
1057 last_sw_if_index = sw_if_index0;
1074 .name =
"interface-tx",
1075 .vector_size =
sizeof (
u32),
1084 .arc_name =
"interface-output",
1086 .last_in_arc =
"interface-tx",
1091 .arc_name =
"interface-output",
1092 .node_name =
"span-output",
1097 .arc_name =
"interface-output",
1098 .node_name =
"ipsec-if-output",
1103 .arc_name =
"interface-output",
1104 .node_name =
"interface-tx",
1133 u32 hw_if_index,
u32 node_index)
1207 else if (
unformat (input,
"max %d", &max))
1213 else if (
unformat (input,
"intfc %U",
1217 else if (
unformat (input,
"intfc any"))
1222 else if (
unformat (input,
"file %s", &filename))
1224 u8 *chroot_filename;
1226 if (strstr ((
char *) filename,
"..")
1227 || index ((
char *) filename,
'/'))
1234 chroot_filename =
format (0,
"/tmp/%s%c", filename, 0);
1243 else if (
unformat (input,
"status"))
1270 .path =
"pcap drop trace",
1272 "pcap drop trace on off max <nn> intfc <intfc> file <name> status",
u8 * format_vnet_interface_output_trace(u8 *s, va_list *va)
vnet_config_main_t config_main
VNET_FEATURE_ARC_INIT(interface_output, static)
#define hash_set(h, key, value)
char * file_name
File name of pcap output.
vhost_user_memory_t memory
void vnet_set_interface_output_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Set interface output node - for interface registered without its output/tx nodes created because its ...
static_always_inline uword vnet_interface_output_node_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vnet_main_t *vnm, vnet_hw_interface_t *hi, int do_tx_offloads)
VLIB_NODE_FUNCTION_MULTIARCH_CLONE(vnet_interface_output_node)
#define hash_unset(h, 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 void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
u8 runtime_data[0]
Function dependent node-runtime data.
u32 n_packets_to_capture
Number of packets to capture.
u32 current_config_index
Used by feature subgraph arcs to visit enabled feature nodes.
vnet_main_t * vnet_get_main(void)
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
static uword vnet_interface_output_node(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
vnet_interface_main_t interface_main
#define clib_memcpy_fast(a, b, c)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
#define VLIB_NODE_FLAG_IS_PUNT
clib_error_t * vnet_per_buffer_interface_output_hw_interface_add_del(vnet_main_t *vnm, u32 hw_if_index, u32 is_create)
static void vnet_interface_output_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, uword n_buffers)
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static void vlib_increment_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 increment)
Increment a simple counter.
unformat_function_t unformat_vnet_sw_interface
static_always_inline int vnet_have_features(u8 arc, u32 sw_if_index)
void vnet_pcap_drop_trace_filter_add_del(u32 error_index, int is_add)
CLIB_MULTIARCH_SELECT_FN(vnet_interface_output_node)
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
struct _tcp_header tcp_header_t
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
#define static_always_inline
uword * pcap_drop_filter_hash
#define vlib_prefetch_buffer_with_index(vm, bi, type)
Prefetch buffer metadata by buffer index The first 64 bytes of buffer contains most header informatio...
static u8 * validate_error_frame(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *f)
static_always_inline void calc_checksums(vlib_main_t *vm, vlib_buffer_t *b)
static u32 counter_index(vlib_main_t *vm, vlib_error_t e)
vnet_hw_interface_flags_t flags
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
#define vlib_get_new_next_frame(vm, node, next_index, vectors, n_vectors_left)
#define clib_error_return(e, args...)
static vlib_node_registration_t drop_buffers
(constructor) VLIB_REGISTER_NODE (drop_buffers)
u8 data[128 - sizeof(u32)]
A collection of simple counters.
static void pcap_drop_trace(vlib_main_t *vm, vnet_interface_main_t *im, vlib_frame_t *f)
static vlib_node_registration_t vnet_per_buffer_interface_output_node
(constructor) VLIB_REGISTER_NODE (vnet_per_buffer_interface_output_node)
static uword interface_tx_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
format_function_t format_vnet_sw_interface_name
u16 current_length
Nbytes between current data and the end of this buffer.
static u8 * format_vnet_error_trace(u8 *s, va_list *va)
vlib_error_main_t error_main
VNET_FEATURE_INIT(span_tx, static)
uword vlib_error_drop_buffers(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u32 next_buffer_stride, u32 n_buffers, u32 next_index, u32 drop_error_node, u32 drop_error_code)
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
static void * vnet_get_config_data(vnet_config_main_t *cm, u32 *config_index, u32 *next_index, u32 n_data_bytes)
void vlib_frame_free(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_frame_t *f)
vlib_simple_counter_main_t * sw_if_counters
format_function_t * format_buffer
u32 node_index
Node index.
#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_error_t error
Error code for buffers to be enqueued to error handler.
static u32 vlib_error_get_code(vlib_node_main_t *nm, vlib_error_t e)
#define VLIB_REGISTER_NODE(x,...)
static_always_inline uword process_drop_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vnet_error_disposition_t disposition)
char ** error_strings_heap
#define vec_free(V)
Free vector's memory (no header).
#define VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
VLIB_NODE_FUNCTION_MULTIARCH(drop_buffers, process_drop)
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
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.
clib_error_t * pcap_write(pcap_main_t *pm)
Write PCAP file.
static uword process_drop(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define VLIB_CLI_COMMAND(x,...)
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
#define hash_create(elts, value_bytes)
u32 output_node_next_index
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
u8 output_feature_arc_index
u16 ip4_tcp_udp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip4_header_t *ip0)
static void trace_errors_with_buffers(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define clib_error_report(e)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
static vlib_node_registration_t interface_tx
(constructor) VLIB_REGISTER_NODE (interface_tx)
#define VNET_FEATURES(...)
static u32 vlib_error_get_node(vlib_node_main_t *nm, vlib_error_t e)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
VNET_HW_INTERFACE_ADD_DEL_FUNCTION(vnet_per_buffer_interface_output_hw_interface_add_del)
pcap_packet_type_t packet_type
Packet type.
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static_always_inline u32 vnet_get_feature_config_index(u8 arc, u32 sw_if_index)
vlib_node_main_t node_main
vnet_sw_interface_t * sw_interfaces
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
#define VLIB_NODE_FLAG_IS_DROP
static clib_error_t * pcap_drop_trace_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static void vlib_error_elog_count(vlib_main_t *vm, uword counter, uword increment)
static vlib_node_registration_t punt_buffers
(constructor) VLIB_REGISTER_NODE (punt_buffers)
static uword vnet_per_buffer_interface_output(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
void(* os_punt_frame)(struct vlib_main_t *vm, struct vlib_node_runtime_t *node, vlib_frame_t *frame)
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
u16 flags
Copy of main node flags.
static uword process_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define VLIB_NODE_FLAG_TRACE
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
static_always_inline vnet_feature_config_main_t * vnet_feature_get_config_main(u16 arc)
static void pcap_add_buffer(pcap_main_t *pm, struct vlib_main_t *vm, u32 buffer_index, u32 n_bytes_in_trace)
Add buffer (vlib_buffer_t) to the trace.
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
static void do_packet(vlib_main_t *vm, vlib_error_t a)
u32 n_packets_captured
Number of packets currently captured.
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
static u16 ip4_header_checksum(ip4_header_t *i)
static u8 * validate_error(vlib_main_t *vm, vlib_error_t *e, u32 index)