aboutsummaryrefslogtreecommitdiffstats
path: root/src/vlib
diff options
context:
space:
mode:
Diffstat (limited to 'src/vlib')
-rw-r--r--src/vlib/CMakeLists.txt1
-rw-r--r--src/vlib/buffer.c2
-rw-r--r--src/vlib/buffer.h42
-rw-r--r--src/vlib/handoff_trace.c125
-rw-r--r--src/vlib/main.c7
-rw-r--r--src/vlib/threads.c6
-rw-r--r--src/vlib/trace_funcs.h26
7 files changed, 192 insertions, 17 deletions
diff --git a/src/vlib/CMakeLists.txt b/src/vlib/CMakeLists.txt
index acd66359f9b..1cecf5fb17d 100644
--- a/src/vlib/CMakeLists.txt
+++ b/src/vlib/CMakeLists.txt
@@ -52,6 +52,7 @@ add_vpp_library(vlib
drop.c
error.c
format.c
+ handoff_trace.c
i2c.c
init.c
linux/pci.c
diff --git a/src/vlib/buffer.c b/src/vlib/buffer.c
index 21e91026b3e..a49200d1b8f 100644
--- a/src/vlib/buffer.c
+++ b/src/vlib/buffer.c
@@ -112,7 +112,7 @@ format_vlib_buffer (u8 * s, va_list * args)
b->total_length_not_including_first_buffer);
if (b->flags & VLIB_BUFFER_IS_TRACED)
- s = format (s, ", trace 0x%x", b->trace_index);
+ s = format (s, ", trace handle 0x%x", b->trace_handle);
if (a)
s = format (s, "\n%U%v", format_white_space, indent, a);
diff --git a/src/vlib/buffer.h b/src/vlib/buffer.h
index 0fd57f5275b..c8761af4d20 100644
--- a/src/vlib/buffer.h
+++ b/src/vlib/buffer.h
@@ -158,9 +158,9 @@ typedef union
/** start of 2nd cache line */
CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
- /** Specifies index into trace buffer if VLIB_PACKET_IS_TRACED flag is
+ /** Specifies trace buffer handle if VLIB_PACKET_IS_TRACED flag is
* set. */
- u32 trace_index;
+ u32 trace_handle;
/** Only valid for first buffer in chain. Current length plus total length
* given here give total number of bytes in buffer chain. */
@@ -354,6 +354,44 @@ vlib_buffer_make_headroom (vlib_buffer_t * b, u8 size)
return vlib_buffer_get_current (b);
}
+/** \brief Construct a trace handle from thread and pool index
+ * @param thread Thread id
+ * @param pool_index Pool index
+ * @return trace handle
+ */
+always_inline u32
+vlib_buffer_make_trace_handle (u32 thread, u32 pool_index)
+{
+ u32 rv;
+ ASSERT (thread < 0xff);
+ ASSERT (pool_index < 0x00FFFFFF);
+ rv = (thread << 24) | (pool_index & 0x00FFFFFF);
+ return rv;
+}
+
+/** \brief Extract the thread id from a trace handle
+ * @param trace_handle the trace handle
+ * @return the thread id
+ */
+always_inline u32
+vlib_buffer_get_trace_thread (vlib_buffer_t * b)
+{
+ u32 trace_handle = b->trace_handle;
+
+ return trace_handle >> 24;
+}
+
+/** \brief Extract the trace (pool) index from a trace handle
+ * @param trace_handle the trace handle
+ * @return the trace index
+ */
+always_inline u32
+vlib_buffer_get_trace_index (vlib_buffer_t * b)
+{
+ u32 trace_handle = b->trace_handle;
+ return trace_handle & 0x00FFFFFF;
+}
+
/** \brief Retrieve bytes from buffer head
* @param b pointer to the buffer
* @param size number of bytes to pull
diff --git a/src/vlib/handoff_trace.c b/src/vlib/handoff_trace.c
new file mode 100644
index 00000000000..7a6743885da
--- /dev/null
+++ b/src/vlib/handoff_trace.c
@@ -0,0 +1,125 @@
+/*
+ * handoff_trace.c - used to generate handoff trace records
+ *
+ * Copyright (c) 2019 Cisco Systems and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <vlib/vlib.h>
+#include <vnet/vnet.h>
+#include <vnet/pg/pg.h>
+#include <vppinfra/error.h>
+
+typedef struct
+{
+ u32 prev_thread;
+ u32 prev_trace_index;
+} handoff_trace_t;
+
+/* packet trace format function */
+static u8 *
+format_handoff_trace (u8 * s, va_list * args)
+{
+ CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
+ CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
+ handoff_trace_t *t = va_arg (*args, handoff_trace_t *);
+
+ s = format (s, "HANDED-OFF: from thread %d trace index %d",
+ t->prev_thread, t->prev_trace_index);
+ return s;
+}
+
+static vlib_node_registration_t handoff_trace_node;
+
+#define foreach_handoff_trace_error \
+_(BUGS, "Warning: packets sent to the handoff trace node!")
+
+typedef enum
+{
+#define _(sym,str) HANDOFF_TRACE_ERROR_##sym,
+ foreach_handoff_trace_error
+#undef _
+ HANDOFF_TRACE_N_ERROR,
+} handoff_trace_error_t;
+
+static char *handoff_trace_error_strings[] = {
+#define _(sym,string) string,
+ foreach_handoff_trace_error
+#undef _
+};
+
+static uword
+handoff_trace_node_fn (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
+{
+ vlib_buffer_free (vm, vlib_frame_vector_args (frame), frame->n_vectors);
+
+ vlib_node_increment_counter (vm, node->node_index,
+ HANDOFF_TRACE_ERROR_BUGS, frame->n_vectors);
+
+ return frame->n_vectors;
+}
+
+typedef enum
+{
+ HANDOFF_TRACE_NEXT_DROP,
+ HANDOFF_TRACE_N_NEXT,
+} tdummy_next_t;
+
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (handoff_trace_node, static) =
+{
+ .name = "handoff_trace",
+ .function = handoff_trace_node_fn,
+ .vector_size = sizeof (u32),
+ .format_trace = format_handoff_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+ .n_next_nodes = HANDOFF_TRACE_N_NEXT,
+
+ /* edit / add dispositions here */
+ .next_nodes = {
+ [HANDOFF_TRACE_NEXT_DROP] = "error-drop",
+ },
+
+ .n_errors = ARRAY_LEN(handoff_trace_error_strings),
+ .error_strings = handoff_trace_error_strings,
+};
+/* *INDENT-ON* */
+
+void
+vlib_add_handoff_trace (vlib_main_t * vm, vlib_buffer_t * b)
+{
+ u32 prev_thread = vlib_buffer_get_trace_thread (b);
+ u32 prev_trace_index = vlib_buffer_get_trace_index (b);
+ handoff_trace_t *t;
+ vlib_node_runtime_t *node
+ = vlib_node_get_runtime (vm, handoff_trace_node.index);
+
+ vlib_trace_buffer (vm, node, 0 /* fake next frame index */ ,
+ b, 1 /* folllow chain */ );
+
+ t = vlib_add_trace (vm, node, b, sizeof (*t));
+
+ t->prev_thread = prev_thread;
+ t->prev_trace_index = prev_trace_index;
+}
+
+
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/vlib/main.c b/src/vlib/main.c
index 43400f8594c..3c0e754169f 100644
--- a/src/vlib/main.c
+++ b/src/vlib/main.c
@@ -1019,8 +1019,8 @@ format_buffer_metadata (u8 * s, va_list * args)
(u32) (b->error), (u32) (b->ref_count),
(u32) (b->buffer_pool_index));
s = format (s,
- "trace_index: %d, len_not_first_buf: %d\n",
- b->trace_index, b->total_length_not_including_first_buffer);
+ "trace_handle: 0x%x, len_not_first_buf: %d\n",
+ b->trace_handle, b->total_length_not_including_first_buffer);
return s;
}
@@ -1091,7 +1091,8 @@ dispatch_pcap_trace (vlib_main_t * vm,
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);
+ = pool_elt_at_index (tm->trace_buffer_pool,
+ vlib_buffer_get_trace_index (b));
vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
format_vlib_trace, vm, h[0], 0);
diff --git a/src/vlib/threads.c b/src/vlib/threads.c
index 297c977c464..91125387248 100644
--- a/src/vlib/threads.c
+++ b/src/vlib/threads.c
@@ -1673,6 +1673,7 @@ vlib_frame_queue_dequeue (vlib_main_t * vm, vlib_frame_queue_main_t * fqm)
while (1)
{
+ vlib_buffer_t *b;
if (fq->head == fq->tail)
{
fq->head_hint = fq->head;
@@ -1695,6 +1696,11 @@ vlib_frame_queue_dequeue (vlib_main_t * vm, vlib_frame_queue_main_t * fqm)
f = vlib_get_frame_to_node (vm, fqm->node_index);
+ /* If the first vector is traced, set the frame trace flag */
+ b = vlib_get_buffer (vm, from[0]);
+ if (b->flags & VLIB_BUFFER_IS_TRACED)
+ f->frame_flags |= VLIB_NODE_FLAG_TRACE;
+
to = vlib_frame_vector_args (f);
n_left_to_node = elt->n_vectors;
diff --git a/src/vlib/trace_funcs.h b/src/vlib/trace_funcs.h
index 56cbfc7b6a2..257c3a3a4ff 100644
--- a/src/vlib/trace_funcs.h
+++ b/src/vlib/trace_funcs.h
@@ -45,14 +45,12 @@ extern u8 *vnet_trace_dummy;
always_inline void
vlib_validate_trace (vlib_trace_main_t * tm, vlib_buffer_t * b)
{
- /*
- * this assert seems right, but goes off constantly.
- * disabling it appears to make the pain go away
- */
- ASSERT (1 || b->flags & VLIB_BUFFER_IS_TRACED);
- ASSERT (!pool_is_free_index (tm->trace_buffer_pool, b->trace_index));
+ ASSERT (!pool_is_free_index (tm->trace_buffer_pool,
+ vlib_buffer_get_trace_index (b)));
}
+void vlib_add_handoff_trace (vlib_main_t * vm, vlib_buffer_t * b);
+
always_inline void *
vlib_add_trace (vlib_main_t * vm,
vlib_node_runtime_t * r, vlib_buffer_t * b, u32 n_data_bytes)
@@ -76,11 +74,15 @@ vlib_add_trace (vlib_main_t * vm,
return vnet_trace_dummy;
}
+ /* Are we trying to trace a handoff case? */
+ if (PREDICT_FALSE (vlib_buffer_get_trace_thread (b) != vm->thread_index))
+ vlib_add_handoff_trace (vm, b);
+
vlib_validate_trace (tm, b);
n_data_bytes = round_pow2 (n_data_bytes, sizeof (h[0]));
n_data_words = n_data_bytes / sizeof (h[0]);
- vec_add2_aligned (tm->trace_buffer_pool[b->trace_index], h,
+ vec_add2_aligned (tm->trace_buffer_pool[vlib_buffer_get_trace_index (b)], h,
1 + n_data_words, sizeof (h[0]));
h->time = vm->cpu_time_last_node_dispatch;
@@ -100,9 +102,10 @@ always_inline void
vlib_free_trace (vlib_main_t * vm, vlib_buffer_t * b)
{
vlib_trace_main_t *tm = &vm->trace_main;
+ u32 trace_index = vlib_buffer_get_trace_index (b);
vlib_validate_trace (tm, b);
- _vec_len (tm->trace_buffer_pool[b->trace_index]) = 0;
- pool_put_index (tm->trace_buffer_pool, b->trace_index);
+ _vec_len (tm->trace_buffer_pool[trace_index]) = 0;
+ pool_put_index (tm->trace_buffer_pool, trace_index);
}
always_inline void
@@ -149,7 +152,8 @@ vlib_trace_buffer (vlib_main_t * vm,
do
{
b->flags |= VLIB_BUFFER_IS_TRACED;
- b->trace_index = h - tm->trace_buffer_pool;
+ b->trace_handle = vlib_buffer_make_trace_handle
+ (vm->thread_index, h - tm->trace_buffer_pool);
}
while (follow_chain && (b = vlib_get_next_buffer (vm, b)));
}
@@ -160,7 +164,7 @@ vlib_buffer_copy_trace_flag (vlib_main_t * vm, vlib_buffer_t * b,
{
vlib_buffer_t *b_target = vlib_get_buffer (vm, bi_target);
b_target->flags |= b->flags & VLIB_BUFFER_IS_TRACED;
- b_target->trace_index = b->trace_index;
+ b_target->trace_handle = b->trace_handle;
}
always_inline u32