{
nf->flags &= ~VLIB_FRAME_PENDING;
f->n_vectors = 0;
+ f->flags = 0;
}
/* Allocate new frame if current one is already full. */
#endif
}
+u8 *format_vnet_buffer_flags (u8 * s, va_list * args) __attribute__ ((weak));
+u8 *
+format_vnet_buffer_flags (u8 * s, va_list * args)
+{
+ s = format (s, "BUG STUB %s", __FUNCTION__);
+ return s;
+}
+
+u8 *format_vnet_buffer_opaque (u8 * s, va_list * args) __attribute__ ((weak));
+u8 *
+format_vnet_buffer_opaque (u8 * s, va_list * args)
+{
+ s = format (s, "BUG STUB %s", __FUNCTION__);
+ return s;
+}
+
+u8 *format_vnet_buffer_opaque2 (u8 * s, va_list * args)
+ __attribute__ ((weak));
+u8 *
+format_vnet_buffer_opaque2 (u8 * s, va_list * args)
+{
+ s = format (s, "BUG STUB %s", __FUNCTION__);
+ return s;
+}
+
+static u8 *
+format_buffer_metadata (u8 * s, va_list * args)
+{
+ vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
+
+ s = format (s, "flags: %U\n", format_vnet_buffer_flags, b);
+ s = format (s, "current_data: %d, current_length: %d\n",
+ (i32) (b->current_data), (i32) (b->current_length));
+ s = format (s, "current_config_index: %d, flow_id: %x, next_buffer: %x\n",
+ b->current_config_index, b->flow_id, b->next_buffer);
+ s = format (s, "error: %d, n_add_refs: %d, buffer_pool_index: %d\n",
+ (u32) (b->error), (u32) (b->n_add_refs),
+ (u32) (b->buffer_pool_index));
+ s = format (s,
+ "trace_index: %d, recycle_count: %d, len_not_first_buf: %d\n",
+ b->trace_index, b->recycle_count,
+ b->total_length_not_including_first_buffer);
+ s = format (s, "free_list_index: %d\n", (u32) (b->free_list_index));
+ return s;
+}
+
+#define A(x) vec_add1(vm->pcap_buffer, (x))
+
static void
dispatch_pcap_trace (vlib_main_t * vm,
vlib_node_runtime_t * node, vlib_frame_t * frame)
{
int i;
vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **bufp, *b;
- u8 name_tlv[64];
pcap_main_t *pm = &vm->dispatch_pcap_main;
+ vlib_trace_main_t *tm = &vm->trace_main;
u32 capture_size;
vlib_node_t *n;
i32 n_left;
f64 time_now = vlib_time_now (vm);
u32 *from;
- u32 name_length;
u8 *d;
+ u8 string_count;
/* Input nodes don't have frames yet */
if (frame == 0 || frame->n_vectors == 0)
vlib_get_buffers (vm, from, bufs, frame->n_vectors);
bufp = bufs;
- /* Create a node name TLV, since WS can't possibly guess */
n = vlib_get_node (vm, node->node_index);
- name_length = vec_len (n->name);
- name_length = name_length < ARRAY_LEN (name_tlv) - 2 ?
- name_length : ARRAY_LEN (name_tlv) - 2;
-
- name_tlv[0] = (u8) name_length;
- clib_memcpy_fast (name_tlv + 1, n->name, name_length);
- name_tlv[name_length + 1] = 0;
for (i = 0; i < frame->n_vectors; i++)
{
{
b = bufp[i];
- /* Figure out how many bytes we're capturing */
- capture_size = (sizeof (vlib_buffer_t) - VLIB_BUFFER_PRE_DATA_SIZE) + vlib_buffer_length_in_chain (vm, b) + sizeof (u32) + +(name_length + 2); /* +2: count plus NULL byte */
+ vec_reset_length (vm->pcap_buffer);
+ string_count = 0;
+
+ /* Version, flags */
+ A ((u8) VLIB_PCAP_MAJOR_VERSION);
+ A ((u8) VLIB_PCAP_MINOR_VERSION);
+ A (0 /* string_count */ );
+ A (n->protocol_hint);
+
+ /* Buffer index (big endian) */
+ A ((from[i] >> 24) & 0xff);
+ A ((from[i] >> 16) & 0xff);
+ A ((from[i] >> 8) & 0xff);
+ A ((from[i] >> 0) & 0xff);
+
+ /* Node name, NULL-terminated ASCII */
+ vm->pcap_buffer = format (vm->pcap_buffer, "%v%c", n->name, 0);
+ string_count++;
+
+ vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
+ format_buffer_metadata, b, 0);
+ string_count++;
+ vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
+ format_vnet_buffer_opaque, b, 0);
+ string_count++;
+ vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
+ format_vnet_buffer_opaque2, b, 0);
+ string_count++;
+
+ /* Is this packet traced? */
+ if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
+ {
+ vlib_trace_header_t **h
+ = pool_elt_at_index (tm->trace_buffer_pool, b->trace_index);
- clib_spinlock_lock_if_init (&pm->lock);
- n_left = clib_min (capture_size, 512);
- d = pcap_add_packet (pm, time_now, n_left, capture_size);
+ vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
+ format_vlib_trace, vm, h[0], 0);
+ string_count++;
+ }
- /* Copy the buffer index */
- clib_memcpy_fast (d, &from[i], sizeof (u32));
- d += 4;
+ /* Save the string count */
+ vm->pcap_buffer[2] = string_count;
- /* Copy the name TLV */
- clib_memcpy_fast (d, name_tlv, name_length + 2);
- d += name_length + 2;
+ /* Figure out how many bytes in the pcap trace */
+ capture_size = vec_len (vm->pcap_buffer) +
+ +vlib_buffer_length_in_chain (vm, b);
- /* Copy the buffer metadata, but not the rewrite space */
- clib_memcpy_fast (d, b, sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE);
- d += sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE;
+ clib_spinlock_lock_if_init (&pm->lock);
+ n_left = clib_min (capture_size, 16384);
+ d = pcap_add_packet (pm, time_now, n_left, capture_size);
+
+ /* Copy the header */
+ clib_memcpy_fast (d, vm->pcap_buffer, vec_len (vm->pcap_buffer));
+ d += vec_len (vm->pcap_buffer);
- n_left = clib_min (vlib_buffer_length_in_chain (vm, b),
- 512 - (sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE));
+ n_left = clib_min
+ (vlib_buffer_length_in_chain (vm, b),
+ (16384 - vec_len (vm->pcap_buffer)));
/* Copy the packet data */
while (1)
{
int enabled = 0;
int errorFlag = 0;
clib_error_t *error = 0;
+ u32 node_index, add;
+ vlib_trace_main_t *tm;
+ vlib_trace_node_t *tn;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
}
break;
}
+ else if (unformat (line_input, "buffer-trace %U %d",
+ unformat_vlib_node, vm, &node_index, &add))
+ {
+ if (vnet_trace_dummy == 0)
+ vec_validate_aligned (vnet_trace_dummy, 2048,
+ CLIB_CACHE_LINE_BYTES);
+ vlib_cli_output (vm, "Buffer tracing of %d pkts from %U enabled...",
+ add, format_vlib_node_name, vm, node_index);
+
+ /* *INDENT-OFF* */
+ foreach_vlib_main ((
+ {
+ tm = &this_vlib_main->trace_main;
+ tm->verbose = 0; /* not sure this ever did anything... */
+ vec_validate (tm->nodes, node_index);
+ tn = tm->nodes + node_index;
+ tn->limit += add;
+ tm->trace_enable = 1;
+ }));
+ /* *INDENT-ON* */
+ }
else
{
pm->file_name = (char *) format (0, "/tmp/dispatch.pcap%c", 0);
pm->n_packets_captured = 0;
- pm->packet_type = PCAP_PACKET_TYPE_user13;
+ pm->packet_type = PCAP_PACKET_TYPE_vpp;
if (pm->lock == 0)
clib_spinlock_init (&(pm->lock));
vm->dispatch_pcap_enable = 1;
* @cliexend
* Example of how to start a dispatch trace capture:
* @cliexstart{pcap dispatch trace on max 35 file dispatchTrace.pcap}
- * pcap dispatc capture on...
+ * pcap dispatch capture on...
+ * @cliexend
+ * Example of how to start a dispatch trace capture with buffer tracing
+ * @cliexstart{pcap dispatch trace on max 10000 file dispatchTrace.pcap buffer-trace dpdk-input 1000}
+ * pcap dispatch capture on...
* @cliexend
* Example of how to display the status of a tx packet capture in progress:
* @cliexstart{pcap tx trace status}
VLIB_CLI_COMMAND (pcap_dispatch_trace_command, static) = {
.path = "pcap dispatch trace",
.short_help =
- "pcap dispatch trace [on|off] [max <nn>] [file <name>] [status]",
+ "pcap dispatch trace [on|off] [max <nn>] [file <name>] [status]\n"
+ " [buffer-trace <input-node-name> <nn>]",
.function = pcap_dispatch_trace_command_fn,
};
/* *INDENT-ON* */
Code Review / vpp.git / blobdiff