X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Fmain.c;h=949a77d3d71c1b0419ab50b7a1ed628e2f398339;hb=7c03ed47d5acfa39820f9553999caa01cf47dba4;hp=666b869915fdc8c09ad92c7823219c885c5cdc88;hpb=3ae2873e568dd441a22903ab9f8c7954835b0bf1;p=vpp.git diff --git a/src/vlib/main.c b/src/vlib/main.c index 666b869915f..949a77d3d71 100644 --- a/src/vlib/main.c +++ b/src/vlib/main.c @@ -384,6 +384,7 @@ vlib_get_next_frame_internal (vlib_main_t * vm, { nf->flags &= ~VLIB_FRAME_PENDING; f->n_vectors = 0; + f->flags = 0; } /* Allocate new frame if current one is already full. */ @@ -944,21 +945,69 @@ add_trajectory_trace (vlib_buffer_t * b, u32 node_index) #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) @@ -968,15 +1017,7 @@ dispatch_pcap_trace (vlib_main_t * vm, 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++) { @@ -984,27 +1025,64 @@ dispatch_pcap_trace (vlib_main_t * vm, { 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) { @@ -1990,6 +2068,9 @@ pcap_dispatch_trace_command_internal (vlib_main_t * vm, 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)) @@ -2086,6 +2167,27 @@ pcap_dispatch_trace_command_internal (vlib_main_t * vm, } 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 { @@ -2173,7 +2275,11 @@ pcap_dispatch_trace_command_fn (vlib_main_t * vm, * @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} @@ -2190,7 +2296,8 @@ pcap_dispatch_trace_command_fn (vlib_main_t * vm, VLIB_CLI_COMMAND (pcap_dispatch_trace_command, static) = { .path = "pcap dispatch trace", .short_help = - "pcap dispatch trace [on|off] [max ] [file ] [status]", + "pcap dispatch trace [on|off] [max ] [file ] [status]\n" + " [buffer-trace ]", .function = pcap_dispatch_trace_command_fn, }; /* *INDENT-ON* */