diff --git a/include/zephyr/tracing/tracing.h b/include/zephyr/tracing/tracing.h index cb12726cabcb1..b9836b772993e 100644 --- a/include/zephyr/tracing/tracing.h +++ b/include/zephyr/tracing/tracing.h @@ -876,14 +876,14 @@ * @brief Trace Conditional Variable wait enter * @param condvar Conditional Variable object */ -#define sys_port_trace_k_condvar_wait_enter(condvar) +#define sys_port_trace_k_condvar_wait_enter(condvar, timeout) /** * @brief Trace Conditional Variable wait exit * @param condvar Conditional Variable object * @param ret Return value */ -#define sys_port_trace_k_condvar_wait_exit(condvar, ret) +#define sys_port_trace_k_condvar_wait_exit(condvar, timeout, ret) /** @} */ /* end of subsys_tracing_apis_condvar */ diff --git a/kernel/condvar.c b/kernel/condvar.c index d00eb552ff7f8..42590839c8638 100644 --- a/kernel/condvar.c +++ b/kernel/condvar.c @@ -117,7 +117,7 @@ int z_impl_k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex, k_spinlock_key_t key; int ret; - SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_condvar, wait, condvar); + SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_condvar, wait, condvar, timeout); key = k_spin_lock(&lock); k_mutex_unlock(mutex); @@ -125,7 +125,7 @@ int z_impl_k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex, ret = z_pend_curr(&lock, key, &condvar->wait_q, timeout); k_mutex_lock(mutex, K_FOREVER); - SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_condvar, wait, condvar, ret); + SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_condvar, wait, condvar, timeout, ret); return ret; } diff --git a/kernel/msg_q.c b/kernel/msg_q.c index f430262f7c985..b3ecf1ea45fbd 100644 --- a/kernel/msg_q.c +++ b/kernel/msg_q.c @@ -89,7 +89,6 @@ int z_impl_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size, } SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, alloc_init, msgq, ret); - return ret; } @@ -106,12 +105,12 @@ int z_vrfy_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size, int k_msgq_cleanup(struct k_msgq *msgq) { + int ret = 0; SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_msgq, cleanup, msgq); CHECKIF(z_waitq_head(&msgq->wait_q) != NULL) { - SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, cleanup, msgq, -EBUSY); - - return -EBUSY; + ret = -EBUSY; + goto exit; } if ((msgq->flags & K_MSGQ_FLAG_ALLOC) != 0U) { @@ -119,9 +118,9 @@ int k_msgq_cleanup(struct k_msgq *msgq) msgq->flags &= ~K_MSGQ_FLAG_ALLOC; } - SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, cleanup, msgq, 0); - - return 0; +exit: + SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, cleanup, msgq, ret); + return ret; } static inline int put_msg_in_queue(struct k_msgq *msgq, const void *data, diff --git a/snippets/semihost-tracing/README.rst b/snippets/semihost-tracing/README.rst new file mode 100644 index 0000000000000..38ef2f9b7c17c --- /dev/null +++ b/snippets/semihost-tracing/README.rst @@ -0,0 +1,67 @@ +.. _snippet-semihost-tracing: + +Semihost Tracing Snippet (semihost-tracing) +########################################### + +.. code-block:: console + + west build -S semihost-tracing [...] + +Overview +******** + +This snippet enables CTF Tracing using semihosting on a target that supports it. + +Using Qemu, you can run the example application and generate a CTF trace file +using semihosting. The trace file can then be viewed using `Babeltrace`_. + +.. code-block:: console + + (gdb) dump binary memory ram_tracing.bin ram_tracing ram_tracing+8192 + +Using `Babeltrace`_, you can view the binary file as a CTF trace: + +.. code-block:: console + + [19:00:00.023530800] (+?.?????????) thread_create: { thread_id = 2147621216, name = "unknown" } + [19:00:00.023567100] (+0.000036300) thread_info: { thread_id = 2147621216, name = "unknown", stack_base = 2147705856, stack_size = 3072 } + [19:00:00.023673700] (+0.000106600) thread_name_set: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.023731100] (+0.000057400) thread_wakeup: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.023827500] (+0.000096400) thread_switched_out: { thread_id = 2147621968, name = "main" } + [19:00:00.023904500] (+0.000077000) thread_switched_in: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.024807600] (+0.000903100) thread_create: { thread_id = 2147619320, name = "unknown" } + [19:00:00.024843800] (+0.000036200) thread_info: { thread_id = 2147619320, name = "unknown", stack_base = 2147693568, stack_size = 3072 } + [19:00:00.024898700] (+0.000054900) thread_wakeup: { thread_id = 2147619320, name = "unknown" } + [19:00:00.025020000] (+0.000121300) thread_switched_out: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.025130700] (+0.000110700) thread_switched_in: { thread_id = 2147621968, name = "main" } + [19:00:00.025249900] (+0.000119200) thread_switched_out: { thread_id = 2147621968, name = "main" } + [19:00:00.025353500] (+0.000103600) thread_switched_in: { thread_id = 2147619320, name = "unknown" } + [19:00:00.026049900] (+0.000696400) thread_switched_in: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.026759200] (+0.000709300) semaphore_give_enter: { id = 2147735664 } + [19:00:00.026773600] (+0.000014400) semaphore_give_exit: { id = 2147735664 } + [19:00:00.027346600] (+0.000573000) thread_switched_out: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.027457400] (+0.000110800) thread_switched_in: { thread_id = 2147621968, name = "main" } + [19:00:00.029552800] (+0.002095400) thread_create: { thread_id = 2147621216, name = "unknown" } + [19:00:00.029589000] (+0.000036200) thread_info: { thread_id = 2147621216, name = "unknown", stack_base = 2147705856, stack_size = 3072 } + [19:00:00.029697400] (+0.000108400) thread_name_set: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.029754800] (+0.000057400) thread_wakeup: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.029851200] (+0.000096400) thread_switched_out: { thread_id = 2147621968, name = "main" } + [19:00:00.029928200] (+0.000077000) thread_switched_in: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.029968400] (+0.000040200) semaphore_init: { id = 2147623436, ret = 0 } + [19:00:00.030851900] (+0.000883500) thread_create: { thread_id = 2147619320, name = "unknown" } + [19:00:00.030888100] (+0.000036200) thread_info: { thread_id = 2147619320, name = "unknown", stack_base = 2147693568, stack_size = 3072 } + [19:00:00.030943000] (+0.000054900) thread_wakeup: { thread_id = 2147619320, name = "unknown" } + [19:00:00.030989600] (+0.000046600) semaphore_take_enter: { id = 2147623436, timeout = 4294957296 } + [19:00:00.031005800] (+0.000016200) semaphore_take_blocking: { id = 2147623436, timeout = 4294957296 } + [19:00:00.031099600] (+0.000093800) thread_switched_out: { thread_id = 2147621216, name = "test_abort_from_isr" } + [19:00:00.031210300] (+0.000110700) thread_switched_in: { thread_id = 2147621968, name = "main" } + [19:00:00.031329500] (+0.000119200) thread_switched_out: { thread_id = 2147621968, name = "main" } + [19:00:00.031433100] (+0.000103600) thread_switched_in: { thread_id = 2147619320, name = "unknown" } + [19:00:00.031469100] (+0.000036000) semaphore_give_enter: { id = 2147623436 } + +References +********** + +.. target-notes:: + +.. _Babeltrace: https://babeltrace.org/ diff --git a/snippets/semihost-tracing/semihost-tracing.conf b/snippets/semihost-tracing/semihost-tracing.conf new file mode 100644 index 0000000000000..b0a8b4faadd12 --- /dev/null +++ b/snippets/semihost-tracing/semihost-tracing.conf @@ -0,0 +1,12 @@ +# Copyright Zephyr Project Contributors +# SPDX-License-Identifier: Apache-2.0 + + +CONFIG_DEBUG_OPTIMIZATIONS=n +CONFIG_DEBUG_THREAD_INFO=y + +CONFIG_TRACING=y +CONFIG_TRACING_CTF=y +CONFIG_TRACING_BACKEND_SEMIHOST=y +CONFIG_SEMIHOST=y +CONFIG_TRACING_SYNC=y diff --git a/snippets/semihost-tracing/snippet.yml b/snippets/semihost-tracing/snippet.yml new file mode 100644 index 0000000000000..4fd268cc7b64c --- /dev/null +++ b/snippets/semihost-tracing/snippet.yml @@ -0,0 +1,6 @@ +# Copyright Zephyr Project Contributors +# SPDX-License-Identifier: Apache-2.0 + +name: semihost-tracing +append: + EXTRA_CONF_FILE: semihost-tracing.conf diff --git a/subsys/tracing/CMakeLists.txt b/subsys/tracing/CMakeLists.txt index 38ccf0286fb1b..0c2aabe3da8f6 100644 --- a/subsys/tracing/CMakeLists.txt +++ b/subsys/tracing/CMakeLists.txt @@ -22,6 +22,11 @@ zephyr_sources_ifdef( tracing_backend_usb.c ) +zephyr_sources_ifdef( + CONFIG_TRACING_BACKEND_SEMIHOST + tracing_backend_semihosting.c + ) + zephyr_sources_ifdef( CONFIG_TRACING_BACKEND_UART tracing_backend_uart.c diff --git a/subsys/tracing/Kconfig b/subsys/tracing/Kconfig index 5e3d349345b2e..298ab8a71a1a3 100644 --- a/subsys/tracing/Kconfig +++ b/subsys/tracing/Kconfig @@ -159,6 +159,13 @@ config TRACING_BACKEND_RAM be dumped to a file at runtime with a debugger. See gdb dump binary memory documentation for example. +config TRACING_BACKEND_SEMIHOST + bool "Semihost backend" + depends on SEMIHOST + help + Use semihosting to output tracing data. This is useful + for debugging on a host machine, such as when using QEMU. + config TRACING_BACKEND_ADSP_MEMORY_WINDOW bool "Memory window in RAM" depends on SOC_FAMILY_INTEL_ADSP @@ -174,6 +181,7 @@ config TRACING_BACKEND_NAME default "tracing_backend_usb" if TRACING_BACKEND_USB default "tracing_backend_posix" if TRACING_BACKEND_POSIX default "tracing_backend_ram" if TRACING_BACKEND_RAM + default "tracing_backend_semihost" if TRACING_BACKEND_SEMIHOST default "tracing_backend_adsp_memory_window" if TRACING_BACKEND_ADSP_MEMORY_WINDOW config RAM_TRACING_BUFFER_SIZE diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 97a0920ceb5b8..34743b8144e4c 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -15,8 +15,7 @@ #include #include -static void _get_thread_name(struct k_thread *thread, - ctf_bounded_string_t *name) +static void _get_thread_name(struct k_thread *thread, ctf_bounded_string_t *name) { const char *tname = k_thread_name_get(thread); @@ -29,7 +28,7 @@ static void _get_thread_name(struct k_thread *thread, void sys_trace_k_thread_switched_out(void) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; struct k_thread *thread; thread = k_sched_current_thread_query(); @@ -41,7 +40,7 @@ void sys_trace_k_thread_switched_out(void) void sys_trace_k_thread_user_mode_enter(void) { struct k_thread *thread; - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; thread = k_sched_current_thread_query(); _get_thread_name(thread, &name); @@ -50,17 +49,16 @@ void sys_trace_k_thread_user_mode_enter(void) void sys_trace_k_thread_wakeup(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_wakeup((uint32_t)(uintptr_t)thread, name); } - void sys_trace_k_thread_switched_in(void) { struct k_thread *thread; - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; thread = k_sched_current_thread_query(); _get_thread_name(thread, &name); @@ -70,52 +68,38 @@ void sys_trace_k_thread_switched_in(void) void sys_trace_k_thread_priority_set(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); - ctf_top_thread_priority_set((uint32_t)(uintptr_t)thread, - thread->base.prio, name); + ctf_top_thread_priority_set((uint32_t)(uintptr_t)thread, thread->base.prio, name); } void sys_trace_k_thread_sleep_enter(k_timeout_t timeout) { - ctf_top_thread_sleep_enter( - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_thread_sleep_enter(k_ticks_to_us_floor32((uint32_t)timeout.ticks)); } void sys_trace_k_thread_sleep_exit(k_timeout_t timeout, int ret) { - ctf_top_thread_sleep_exit( - k_ticks_to_us_floor32((uint32_t)timeout.ticks), - (uint32_t)ret - ); + ctf_top_thread_sleep_exit(k_ticks_to_us_floor32((uint32_t)timeout.ticks), (uint32_t)ret); } void sys_trace_k_thread_create(struct k_thread *thread, size_t stack_size, int prio) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); - ctf_top_thread_create( - (uint32_t)(uintptr_t)thread, - thread->base.prio, - name - ); + ctf_top_thread_create((uint32_t)(uintptr_t)thread, thread->base.prio, name); #if defined(CONFIG_THREAD_STACK_INFO) - ctf_top_thread_info( - (uint32_t)(uintptr_t)thread, - name, - thread->stack_info.start, - thread->stack_info.size - ); + ctf_top_thread_info((uint32_t)(uintptr_t)thread, name, thread->stack_info.start, + thread->stack_info.size); #endif } void sys_trace_k_thread_abort(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_abort((uint32_t)(uintptr_t)thread, name); @@ -123,7 +107,7 @@ void sys_trace_k_thread_abort(struct k_thread *thread) void sys_trace_k_thread_suspend(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_suspend((uint32_t)(uintptr_t)thread, name); @@ -131,7 +115,7 @@ void sys_trace_k_thread_suspend(struct k_thread *thread) void sys_trace_k_thread_resume(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); @@ -140,7 +124,7 @@ void sys_trace_k_thread_resume(struct k_thread *thread) void sys_trace_k_thread_ready(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); @@ -149,12 +133,11 @@ void sys_trace_k_thread_ready(struct k_thread *thread) void sys_trace_k_thread_start(struct k_thread *thread) { - } void sys_trace_k_thread_pend(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_pend((uint32_t)(uintptr_t)thread, name); @@ -163,28 +146,171 @@ void sys_trace_k_thread_pend(struct k_thread *thread) void sys_trace_k_thread_info(struct k_thread *thread) { #if defined(CONFIG_THREAD_STACK_INFO) - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); - ctf_top_thread_info( - (uint32_t)(uintptr_t)thread, - name, - thread->stack_info.start, - thread->stack_info.size - ); + ctf_top_thread_info((uint32_t)(uintptr_t)thread, name, thread->stack_info.start, + thread->stack_info.size); #endif } void sys_trace_k_thread_name_set(struct k_thread *thread, int ret) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); - ctf_top_thread_name_set( - (uint32_t)(uintptr_t)thread, - name - ); + ctf_top_thread_name_set((uint32_t)(uintptr_t)thread, name); +} + +/* Thread Extended Functions */ +void sys_trace_k_thread_foreach_enter(void) +{ + ctf_top_thread_foreach_enter(); +} + +void sys_trace_k_thread_foreach_exit(void) +{ + ctf_top_thread_foreach_exit(); +} + +void sys_trace_k_thread_foreach_unlocked_enter(void) +{ + ctf_top_thread_foreach_unlocked_enter(); +} + +void sys_trace_k_thread_foreach_unlocked_exit(void) +{ + ctf_top_thread_foreach_unlocked_exit(); +} + +void sys_trace_k_thread_heap_assign(struct k_thread *thread, struct k_heap *heap) +{ + ctf_top_thread_heap_assign((uint32_t)(uintptr_t)thread, (uint32_t)(uintptr_t)heap); +} + +void sys_trace_k_thread_join_enter(struct k_thread *thread, k_timeout_t timeout) +{ + ctf_top_thread_join_enter((uint32_t)(uintptr_t)thread, (uint32_t)timeout.ticks); +} + +void sys_trace_k_thread_join_blocking(struct k_thread *thread, k_timeout_t timeout) +{ + ctf_top_thread_join_blocking((uint32_t)(uintptr_t)thread, (uint32_t)timeout.ticks); +} + +void sys_trace_k_thread_join_exit(struct k_thread *thread, k_timeout_t timeout, int ret) +{ + ctf_top_thread_join_exit((uint32_t)(uintptr_t)thread, (uint32_t)timeout.ticks, + (int32_t)ret); +} + +void sys_trace_k_thread_msleep_enter(int32_t ms) +{ + ctf_top_thread_msleep_enter(ms); +} + +void sys_trace_k_thread_msleep_exit(int32_t ms, int ret) +{ + ctf_top_thread_msleep_exit(ms, (int32_t)ret); +} + +void sys_trace_k_thread_usleep_enter(int32_t us) +{ + ctf_top_thread_usleep_enter(us); +} + +void sys_trace_k_thread_usleep_exit(int32_t us, int ret) +{ + ctf_top_thread_usleep_exit(us, (int32_t)ret); +} + +void sys_trace_k_thread_busy_wait_enter(uint32_t usec_to_wait) +{ + ctf_top_thread_busy_wait_enter(usec_to_wait); +} + +void sys_trace_k_thread_busy_wait_exit(uint32_t usec_to_wait) +{ + ctf_top_thread_busy_wait_exit(usec_to_wait); +} + +void sys_trace_k_thread_yield(void) +{ + ctf_top_thread_yield(); +} +void sys_trace_k_thread_suspend_exit(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_suspend_exit((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_lock(void) +{ + ctf_top_thread_sched_lock(); +} + +void sys_trace_k_thread_sched_unlock(void) +{ + ctf_top_thread_sched_unlock(); +} + +void sys_trace_k_thread_sched_wakeup(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_wakeup((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_abort(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_abort((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_priority_set(struct k_thread *thread, int prio) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_priority_set((uint32_t)(uintptr_t)thread, (int8_t)prio, name); +} + +void sys_trace_k_thread_sched_ready(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_ready((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_pend(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_pend((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_resume(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_resume((uint32_t)(uintptr_t)thread, name); +} + +void sys_trace_k_thread_sched_suspend(struct k_thread *thread) +{ + ctf_bounded_string_t name = {"unknown"}; + + _get_thread_name(thread, &name); + ctf_top_thread_sched_suspend((uint32_t)(uintptr_t)thread, name); } void sys_trace_isr_enter(void) @@ -219,156 +345,598 @@ void sys_trace_idle_exit(void) } } -/* Semaphore */ -void sys_trace_k_sem_init(struct k_sem *sem, int ret) +/* Memory Slabs */ + +void sys_trace_k_mem_slab_init(struct k_mem_slab *slab, int ret) +{ + ctf_top_mem_slab_init((uint32_t)(uintptr_t)slab, (int32_t)ret); +} + +void sys_trace_k_mem_slab_alloc_enter(struct k_mem_slab *slab, k_timeout_t timeout) +{ + ctf_top_mem_slab_alloc_enter((uint32_t)(uintptr_t)slab, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_mem_slab_alloc_blocking(struct k_mem_slab *slab, k_timeout_t timeout) +{ + ctf_top_mem_slab_alloc_blocking((uint32_t)(uintptr_t)slab, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_mem_slab_alloc_exit(struct k_mem_slab *slab, k_timeout_t timeout, int ret) +{ + ctf_top_mem_slab_alloc_exit((uint32_t)(uintptr_t)slab, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_mem_slab_free_enter(struct k_mem_slab *slab) +{ + ctf_top_mem_slab_free_enter((uint32_t)(uintptr_t)slab); +} + +void sys_trace_k_mem_slab_free_exit(struct k_mem_slab *slab) +{ + ctf_top_mem_slab_free_exit((uint32_t)(uintptr_t)slab); +} + +/* Message Queues */ +void sys_trace_k_msgq_init(struct k_msgq *msgq) +{ + ctf_top_msgq_init((uint32_t)(uintptr_t)msgq); +} + +void sys_trace_k_msgq_alloc_init_enter(struct k_msgq *msgq) +{ + ctf_top_msgq_alloc_init_enter((uint32_t)(uintptr_t)msgq); +} + +void sys_trace_k_msgq_alloc_init_exit(struct k_msgq *msgq, int ret) +{ + ctf_top_msgq_alloc_init_exit((uint32_t)(uintptr_t)msgq, (int32_t)ret); +} + +void sys_trace_k_msgq_put_enter(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_put_enter((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_get_enter(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_get_enter((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_get_blocking(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_get_blocking((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_get_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret) +{ + ctf_top_msgq_get_exit((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_msgq_put_blocking(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_put_blocking((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_put_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret) +{ + ctf_top_msgq_put_exit((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_msgq_peek(struct k_msgq *msgq, int ret) +{ + ctf_top_msgq_peek((uint32_t)(uintptr_t)msgq, (int32_t)ret); +} + +void sys_trace_k_msgq_purge(struct k_msgq *msgq) +{ + ctf_top_msgq_purge((uint32_t)(uintptr_t)msgq); +} + +void sys_trace_k_msgq_put_front_enter(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_put_front_enter((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_put_front_blocking(struct k_msgq *msgq, k_timeout_t timeout) +{ + ctf_top_msgq_put_front_blocking((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_msgq_put_front_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret) +{ + ctf_top_msgq_put_front_exit((uint32_t)(uintptr_t)msgq, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_msgq_cleanup_enter(struct k_msgq *msgq) +{ + ctf_top_msgq_cleanup_enter((uint32_t)(uintptr_t)msgq); +} + +void sys_trace_k_msgq_cleanup_exit(struct k_msgq *msgq, int ret) +{ + ctf_top_msgq_cleanup_exit((uint32_t)(uintptr_t)msgq, (int32_t)ret); +} + +/* Condition Variables */ +void sys_trace_k_condvar_init(struct k_condvar *condvar, int ret) +{ + ctf_top_condvar_init((uint32_t)(uintptr_t)condvar, (int32_t)ret); +} + +void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, k_timeout_t timeout) +{ + ctf_top_condvar_wait_enter((uint32_t)(uintptr_t)condvar, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, k_timeout_t timeout, int ret) +{ + ctf_top_condvar_wait_exit((uint32_t)(uintptr_t)condvar, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_condvar_signal_enter(struct k_condvar *condvar) +{ + ctf_top_condvar_signal_enter((uint32_t)(uintptr_t)condvar); +} + +void sys_trace_k_condvar_signal_blocking(struct k_condvar *condvar, k_timeout_t timeout) +{ + ctf_top_condvar_signal_blocking((uint32_t)(uintptr_t)condvar, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_condvar_signal_exit(struct k_condvar *condvar, int ret) +{ + ctf_top_condvar_signal_exit((uint32_t)(uintptr_t)condvar, (int32_t)ret); +} +void sys_trace_k_condvar_broadcast_enter(struct k_condvar *condvar) +{ + ctf_top_condvar_broadcast_enter((uint32_t)(uintptr_t)condvar); +} +void sys_trace_k_condvar_broadcast_exit(struct k_condvar *condvar, int ret) +{ + ctf_top_condvar_broadcast_exit((uint32_t)(uintptr_t)condvar, (int32_t)ret); +} + +/* Work Queue */ +void sys_trace_k_work_init(struct k_work *work) +{ + ctf_top_work_init((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_submit_to_queue_enter(struct k_work_q *queue, struct k_work *work) +{ + ctf_top_work_submit_to_queue_enter((uint32_t)(uintptr_t)queue, (uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_submit_to_queue_exit(struct k_work_q *queue, struct k_work *work, int ret) +{ + ctf_top_work_submit_to_queue_exit((uint32_t)(uintptr_t)queue, (uint32_t)(uintptr_t)work, + (int32_t)ret); +} + +void sys_trace_k_work_submit_enter(struct k_work *work) +{ + ctf_top_work_submit_enter((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_submit_exit(struct k_work *work, int ret) +{ + ctf_top_work_submit_exit((uint32_t)(uintptr_t)work, (int32_t)ret); +} + +void sys_trace_k_work_flush_enter(struct k_work *work) +{ + ctf_top_work_flush_enter((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_flush_blocking(struct k_work *work, k_timeout_t timeout) +{ + ctf_top_work_flush_blocking((uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_flush_exit(struct k_work *work, int ret) +{ + ctf_top_work_flush_exit((uint32_t)(uintptr_t)work, (int32_t)ret); +} + +void sys_trace_k_work_cancel_enter(struct k_work *work) +{ + ctf_top_work_cancel_enter((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_cancel_exit(struct k_work *work, int ret) +{ + ctf_top_work_cancel_exit((uint32_t)(uintptr_t)work, (int32_t)ret); +} + +void sys_trace_k_work_cancel_sync_enter(struct k_work *work, struct k_work_sync *sync) +{ + ctf_top_work_cancel_sync_enter((uint32_t)(uintptr_t)work, (uint32_t)(uintptr_t)sync); +} + +void sys_trace_k_work_cancel_sync_blocking(struct k_work *work, struct k_work_sync *sync) +{ + ctf_top_work_cancel_sync_blocking((uint32_t)(uintptr_t)work, (uint32_t)(uintptr_t)sync); +} + +void sys_trace_k_work_cancel_sync_exit(struct k_work *work, struct k_work_sync *sync, int ret) +{ + ctf_top_work_cancel_sync_exit((uint32_t)(uintptr_t)work, (uint32_t)(uintptr_t)sync, + (int32_t)ret); +} + +/* Work Queue Management */ +void sys_trace_k_work_queue_init(struct k_work_q *queue) +{ + ctf_top_work_queue_init((uint32_t)(uintptr_t)queue); +} + +void sys_trace_k_work_queue_start_enter(struct k_work_q *queue) +{ + ctf_top_work_queue_start_enter((uint32_t)(uintptr_t)queue); +} + +void sys_trace_k_work_queue_start_exit(struct k_work_q *queue) +{ + ctf_top_work_queue_start_exit((uint32_t)(uintptr_t)queue); +} + +void sys_trace_k_work_queue_stop_enter(struct k_work_q *queue, k_timeout_t timeout) +{ + ctf_top_work_queue_stop_enter((uint32_t)(uintptr_t)queue, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_queue_stop_blocking(struct k_work_q *queue, k_timeout_t timeout) +{ + ctf_top_work_queue_stop_blocking((uint32_t)(uintptr_t)queue, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_queue_stop_exit(struct k_work_q *queue, k_timeout_t timeout, int ret) +{ + ctf_top_work_queue_stop_exit((uint32_t)(uintptr_t)queue, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_work_queue_drain_enter(struct k_work_q *queue) +{ + ctf_top_work_queue_drain_enter((uint32_t)(uintptr_t)queue); +} + +void sys_trace_k_work_queue_drain_exit(struct k_work_q *queue, int ret) +{ + ctf_top_work_queue_drain_exit((uint32_t)(uintptr_t)queue, (int32_t)ret); +} + +void sys_trace_k_work_queue_unplug_enter(struct k_work_q *queue) +{ + ctf_top_work_queue_unplug_enter((uint32_t)(uintptr_t)queue); +} + +void sys_trace_k_work_queue_unplug_exit(struct k_work_q *queue, int ret) +{ + ctf_top_work_queue_unplug_exit((uint32_t)(uintptr_t)queue, (int32_t)ret); +} + +/* Delayable Work */ +void sys_trace_k_work_delayable_init(struct k_work_delayable *dwork) +{ + ctf_top_work_delayable_init((uint32_t)(uintptr_t)dwork); +} + +void sys_trace_k_work_schedule_for_queue_enter(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay) +{ + ctf_top_work_schedule_for_queue_enter((uint32_t)(uintptr_t)queue, + (uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks)); +} + +void sys_trace_k_work_schedule_for_queue_exit(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay, + int ret) +{ + ctf_top_work_schedule_for_queue_exit((uint32_t)(uintptr_t)queue, (uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks), + (int32_t)ret); +} + +void sys_trace_k_work_schedule_enter(struct k_work_delayable *dwork, k_timeout_t delay) +{ + ctf_top_work_schedule_enter((uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks)); +} + +void sys_trace_k_work_schedule_exit(struct k_work_delayable *dwork, k_timeout_t delay, int ret) +{ + ctf_top_work_schedule_exit((uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks), (int32_t)ret); +} + +void sys_trace_k_work_reschedule_for_queue_enter(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay) +{ + ctf_top_work_reschedule_for_queue_enter((uint32_t)(uintptr_t)queue, + (uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks)); +} + +void sys_trace_k_work_reschedule_for_queue_exit(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay, + int ret) +{ + ctf_top_work_reschedule_for_queue_exit( + (uint32_t)(uintptr_t)queue, (uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks), (int32_t)ret); +} + +void sys_trace_k_work_reschedule_enter(struct k_work_delayable *dwork, k_timeout_t delay) +{ + ctf_top_work_reschedule_enter((uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks)); +} + +void sys_trace_k_work_reschedule_exit(struct k_work_delayable *dwork, k_timeout_t delay, int ret) +{ + ctf_top_work_reschedule_exit((uint32_t)(uintptr_t)dwork, + k_ticks_to_us_floor32((uint32_t)delay.ticks), (int32_t)ret); +} + +void sys_trace_k_work_flush_delayable_enter(struct k_work_delayable *dwork, + struct k_work_sync *sync) +{ + ctf_top_work_flush_delayable_enter((uint32_t)(uintptr_t)dwork, (uint32_t)(uintptr_t)sync); +} + +void sys_trace_k_work_flush_delayable_exit(struct k_work_delayable *dwork, struct k_work_sync *sync, + int ret) +{ + ctf_top_work_flush_delayable_exit((uint32_t)(uintptr_t)dwork, (uint32_t)(uintptr_t)sync, + (int32_t)ret); +} + +void sys_trace_k_work_cancel_delayable_enter(struct k_work_delayable *dwork) +{ + ctf_top_work_cancel_delayable_enter((uint32_t)(uintptr_t)dwork); +} + +void sys_trace_k_work_cancel_delayable_exit(struct k_work_delayable *dwork, int ret) +{ + ctf_top_work_cancel_delayable_exit((uint32_t)(uintptr_t)dwork, (int32_t)ret); +} + +void sys_trace_k_work_cancel_delayable_sync_enter(struct k_work_delayable *dwork, + struct k_work_sync *sync) +{ + ctf_top_work_cancel_delayable_sync_enter((uint32_t)(uintptr_t)dwork, + (uint32_t)(uintptr_t)sync); +} + +void sys_trace_k_work_cancel_delayable_sync_exit(struct k_work_delayable *dwork, + struct k_work_sync *sync, int ret) +{ + ctf_top_work_cancel_delayable_sync_exit((uint32_t)(uintptr_t)dwork, + (uint32_t)(uintptr_t)sync, (int32_t)ret); +} + +/* Poll Work */ +void sys_trace_k_work_poll_init_enter(struct k_work_poll *work) { - ctf_top_semaphore_init( - (uint32_t)(uintptr_t)sem, + ctf_top_work_poll_init_enter((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_poll_init_exit(struct k_work_poll *work) +{ + ctf_top_work_poll_init_exit((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_poll_submit_to_queue_enter(struct k_work_q *work_q, struct k_work_poll *work, + k_timeout_t timeout) +{ + ctf_top_work_poll_submit_to_queue_enter((uint32_t)(uintptr_t)work_q, + (uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_poll_submit_to_queue_blocking(struct k_work_q *work_q, + struct k_work_poll *work, k_timeout_t timeout) +{ + ctf_top_work_poll_submit_to_queue_blocking((uint32_t)(uintptr_t)work_q, + (uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_poll_submit_to_queue_exit(struct k_work_q *work_q, struct k_work_poll *work, + k_timeout_t timeout, int ret) +{ + ctf_top_work_poll_submit_to_queue_exit( + (uint32_t)(uintptr_t)work_q, (uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_work_poll_submit_enter(struct k_work_poll *work, k_timeout_t timeout) +{ + ctf_top_work_poll_submit_enter((uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} + +void sys_trace_k_work_poll_submit_exit(struct k_work_poll *work, k_timeout_t timeout, int ret) +{ + ctf_top_work_poll_submit_exit((uint32_t)(uintptr_t)work, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); +} + +void sys_trace_k_work_poll_cancel_enter(struct k_work_poll *work) +{ + ctf_top_work_poll_cancel_enter((uint32_t)(uintptr_t)work); +} + +void sys_trace_k_work_poll_cancel_exit(struct k_work_poll *work, int ret) +{ + ctf_top_work_poll_cancel_exit((uint32_t)(uintptr_t)work, (int32_t)ret); +} + +/* Poll API */ +void sys_trace_k_poll_api_event_init(struct k_poll_event *event) +{ + ctf_top_poll_event_init((uint32_t)(uintptr_t)event); +} + +void sys_trace_k_poll_api_poll_enter(struct k_poll_event *events) +{ + ctf_top_poll_enter((uint32_t)(uintptr_t)events); +} + +void sys_trace_k_poll_api_poll_exit(struct k_poll_event *events, int ret) +{ + ctf_top_poll_exit((uint32_t)(uintptr_t)events, (int32_t)ret); +} + +void sys_trace_k_poll_api_signal_init(struct k_poll_signal *sig) +{ + ctf_top_poll_signal_init((uint32_t)(uintptr_t)sig); +} + +void sys_trace_k_poll_api_signal_reset(struct k_poll_signal *sig) +{ + ctf_top_poll_signal_reset((uint32_t)(uintptr_t)sig); +} + +void sys_trace_k_poll_api_signal_check(struct k_poll_signal *sig) +{ + ctf_top_poll_signal_check((uint32_t)(uintptr_t)sig); +} + +void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *sig, int ret) +{ + ctf_top_poll_signal_raise( + (uint32_t)(uintptr_t)sig, (int32_t)ret ); } -void sys_trace_k_sem_take_enter(struct k_sem *sem, k_timeout_t timeout) +/* Semaphore */ +void sys_trace_k_sem_init(struct k_sem *sem, int ret) { - ctf_top_semaphore_take_enter( - (uint32_t)(uintptr_t)sem, - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_semaphore_init((uint32_t)(uintptr_t)sem, (int32_t)ret); } +void sys_trace_k_sem_take_enter(struct k_sem *sem, k_timeout_t timeout) +{ + ctf_top_semaphore_take_enter((uint32_t)(uintptr_t)sem, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); +} void sys_trace_k_sem_take_blocking(struct k_sem *sem, k_timeout_t timeout) { - ctf_top_semaphore_take_blocking( - (uint32_t)(uintptr_t)sem, - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_semaphore_take_blocking((uint32_t)(uintptr_t)sem, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); } void sys_trace_k_sem_take_exit(struct k_sem *sem, k_timeout_t timeout, int ret) { - ctf_top_semaphore_take_exit( - (uint32_t)(uintptr_t)sem, - k_ticks_to_us_floor32((uint32_t)timeout.ticks), - (uint32_t)ret - ); + ctf_top_semaphore_take_exit((uint32_t)(uintptr_t)sem, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (uint32_t)ret); } void sys_trace_k_sem_reset(struct k_sem *sem) { - ctf_top_semaphore_reset( - (uint32_t)(uintptr_t)sem - ); + ctf_top_semaphore_reset((uint32_t)(uintptr_t)sem); } void sys_trace_k_sem_give_enter(struct k_sem *sem) { - ctf_top_semaphore_give_enter( - (uint32_t)(uintptr_t)sem - ); + ctf_top_semaphore_give_enter((uint32_t)(uintptr_t)sem); } void sys_trace_k_sem_give_exit(struct k_sem *sem) { - ctf_top_semaphore_give_exit( - (uint32_t)(uintptr_t)sem - ); + ctf_top_semaphore_give_exit((uint32_t)(uintptr_t)sem); } /* Mutex */ void sys_trace_k_mutex_init(struct k_mutex *mutex, int ret) { - ctf_top_mutex_init( - (uint32_t)(uintptr_t)mutex, - (int32_t)ret - ); + ctf_top_mutex_init((uint32_t)(uintptr_t)mutex, (int32_t)ret); } void sys_trace_k_mutex_lock_enter(struct k_mutex *mutex, k_timeout_t timeout) { - ctf_top_mutex_lock_enter( - (uint32_t)(uintptr_t)mutex, - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_mutex_lock_enter((uint32_t)(uintptr_t)mutex, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); } void sys_trace_k_mutex_lock_blocking(struct k_mutex *mutex, k_timeout_t timeout) { - ctf_top_mutex_lock_blocking( - (uint32_t)(uintptr_t)mutex, - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_mutex_lock_blocking((uint32_t)(uintptr_t)mutex, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); } void sys_trace_k_mutex_lock_exit(struct k_mutex *mutex, k_timeout_t timeout, int ret) { - ctf_top_mutex_lock_exit( - (uint32_t)(uintptr_t)mutex, - k_ticks_to_us_floor32((uint32_t)timeout.ticks), - (int32_t)ret - ); + ctf_top_mutex_lock_exit((uint32_t)(uintptr_t)mutex, + k_ticks_to_us_floor32((uint32_t)timeout.ticks), (int32_t)ret); } void sys_trace_k_mutex_unlock_enter(struct k_mutex *mutex) { - ctf_top_mutex_unlock_enter( - (uint32_t)(uintptr_t)mutex - ); + ctf_top_mutex_unlock_enter((uint32_t)(uintptr_t)mutex); } void sys_trace_k_mutex_unlock_exit(struct k_mutex *mutex, int ret) { - ctf_top_mutex_unlock_exit( - (uint32_t)(uintptr_t)mutex, - (int32_t)ret - ); + ctf_top_mutex_unlock_exit((uint32_t)(uintptr_t)mutex, (int32_t)ret); } /* Timer */ void sys_trace_k_timer_init(struct k_timer *timer) { - ctf_top_timer_init( - (uint32_t)(uintptr_t)timer); + ctf_top_timer_init((uint32_t)(uintptr_t)timer); } -void sys_trace_k_timer_start(struct k_timer *timer, k_timeout_t duration, - k_timeout_t period) +void sys_trace_k_timer_start(struct k_timer *timer, k_timeout_t duration, k_timeout_t period) { - ctf_top_timer_start( - (uint32_t)(uintptr_t)timer, - k_ticks_to_us_floor32((uint32_t)duration.ticks), - k_ticks_to_us_floor32((uint32_t)period.ticks) - ); + ctf_top_timer_start((uint32_t)(uintptr_t)timer, + k_ticks_to_us_floor32((uint32_t)duration.ticks), + k_ticks_to_us_floor32((uint32_t)period.ticks)); } void sys_trace_k_timer_stop(struct k_timer *timer) { - ctf_top_timer_stop( - (uint32_t)(uintptr_t)timer - ); + ctf_top_timer_stop((uint32_t)(uintptr_t)timer); } void sys_trace_k_timer_status_sync_enter(struct k_timer *timer) { - ctf_top_timer_status_sync_enter( - (uint32_t)(uintptr_t)timer - ); + ctf_top_timer_status_sync_enter((uint32_t)(uintptr_t)timer); } void sys_trace_k_timer_status_sync_blocking(struct k_timer *timer, k_timeout_t timeout) { - ctf_top_timer_status_sync_blocking( - (uint32_t)(uintptr_t)timer, - k_ticks_to_us_floor32((uint32_t)timeout.ticks) - ); + ctf_top_timer_status_sync_blocking((uint32_t)(uintptr_t)timer, + k_ticks_to_us_floor32((uint32_t)timeout.ticks)); } void sys_trace_k_timer_status_sync_exit(struct k_timer *timer, uint32_t result) { - ctf_top_timer_status_sync_exit( - (uint32_t)(uintptr_t)timer, - result - ); + ctf_top_timer_status_sync_exit((uint32_t)(uintptr_t)timer, result); } /* Network socket */ @@ -401,8 +969,8 @@ void sys_trace_socket_bind_enter(int sock, const struct sockaddr *addr, size_t a { ctf_net_bounded_string_t addr_str; - (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); ctf_top_socket_bind_enter(sock, addr_str, addrlen, ntohs(net_sin(addr)->sin_port)); } @@ -416,8 +984,8 @@ void sys_trace_socket_connect_enter(int sock, const struct sockaddr *addr, size_ { ctf_net_bounded_string_t addr_str; - (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); ctf_top_socket_connect_enter(sock, addr_str, addrlen); } @@ -442,16 +1010,16 @@ void sys_trace_socket_accept_enter(int sock) ctf_top_socket_accept_enter(sock); } -void sys_trace_socket_accept_exit(int sock, const struct sockaddr *addr, - const uint32_t *addrlen, int ret) +void sys_trace_socket_accept_exit(int sock, const struct sockaddr *addr, const size_t *addrlen, + int ret) { - ctf_net_bounded_string_t addr_str = { "unknown" }; + ctf_net_bounded_string_t addr_str = {"unknown"}; uint32_t addr_len = 0U; uint16_t port = 0U; if (addr != NULL) { - (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); port = net_sin(addr)->sin_port; } @@ -465,7 +1033,7 @@ void sys_trace_socket_accept_exit(int sock, const struct sockaddr *addr, void sys_trace_socket_sendto_enter(int sock, int len, int flags, const struct sockaddr *dest_addr, uint32_t addrlen) { - ctf_net_bounded_string_t addr_str = { "unknown" }; + ctf_net_bounded_string_t addr_str = {"unknown"}; if (dest_addr != NULL) { (void)net_addr_ntop(dest_addr->sa_family, &net_sin(dest_addr)->sin_addr, @@ -482,7 +1050,7 @@ void sys_trace_socket_sendto_exit(int sock, int ret) void sys_trace_socket_sendmsg_enter(int sock, const struct msghdr *msg, int flags) { - ctf_net_bounded_string_t addr = { "unknown" }; + ctf_net_bounded_string_t addr = {"unknown"}; uint32_t len = 0; for (int i = 0; msg->msg_iov != NULL && i < msg->msg_iovlen; i++) { @@ -491,8 +1059,8 @@ void sys_trace_socket_sendmsg_enter(int sock, const struct msghdr *msg, int flag if (msg->msg_name != NULL) { (void)net_addr_ntop(((struct sockaddr *)msg->msg_name)->sa_family, - &net_sin((struct sockaddr *)msg->msg_name)->sin_addr, - addr.buf, sizeof(addr.buf)); + &net_sin((struct sockaddr *)msg->msg_name)->sin_addr, addr.buf, + sizeof(addr.buf)); } ctf_top_socket_sendmsg_enter(sock, flags, (uint32_t)(uintptr_t)msg, addr, len); @@ -506,20 +1074,19 @@ void sys_trace_socket_sendmsg_exit(int sock, int ret) void sys_trace_socket_recvfrom_enter(int sock, int max_len, int flags, struct sockaddr *addr, uint32_t *addrlen) { - ctf_top_socket_recvfrom_enter(sock, max_len, flags, - (uint32_t)(uintptr_t)addr, + ctf_top_socket_recvfrom_enter(sock, max_len, flags, (uint32_t)(uintptr_t)addr, (uint32_t)(uintptr_t)addrlen); } void sys_trace_socket_recvfrom_exit(int sock, const struct sockaddr *src_addr, const uint32_t *addrlen, int ret) { - ctf_net_bounded_string_t addr_str = { "unknown" }; + ctf_net_bounded_string_t addr_str = {"unknown"}; int len = 0; if (src_addr != NULL) { - (void)net_addr_ntop(src_addr->sa_family, &net_sin(src_addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(src_addr->sa_family, &net_sin(src_addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); } if (addrlen != NULL) { @@ -543,7 +1110,7 @@ void sys_trace_socket_recvmsg_enter(int sock, const struct msghdr *msg, int flag void sys_trace_socket_recvmsg_exit(int sock, const struct msghdr *msg, int ret) { uint32_t len = 0; - ctf_net_bounded_string_t addr = { "unknown" }; + ctf_net_bounded_string_t addr = {"unknown"}; for (int i = 0; msg->msg_iov != NULL && i < msg->msg_iovlen; i++) { len += msg->msg_iov[i].iov_len; @@ -551,8 +1118,8 @@ void sys_trace_socket_recvmsg_exit(int sock, const struct msghdr *msg, int ret) if (msg->msg_name != NULL) { (void)net_addr_ntop(((struct sockaddr *)msg->msg_name)->sa_family, - &net_sin((struct sockaddr *)msg->msg_name)->sin_addr, - addr.buf, sizeof(addr.buf)); + &net_sin((struct sockaddr *)msg->msg_name)->sin_addr, addr.buf, + sizeof(addr.buf)); } ctf_top_socket_recvmsg_exit(sock, len, addr, ret); @@ -606,18 +1173,17 @@ void sys_trace_socket_getsockopt_enter(int sock, int level, int optname) ctf_top_socket_getsockopt_enter(sock, level, optname); } -void sys_trace_socket_getsockopt_exit(int sock, int level, int optname, - void *optval, size_t optlen, int ret) +void sys_trace_socket_getsockopt_exit(int sock, int level, int optname, void *optval, size_t optlen, + int ret) { - ctf_top_socket_getsockopt_exit(sock, level, optname, - (uint32_t)(uintptr_t)optval, optlen, ret); + ctf_top_socket_getsockopt_exit(sock, level, optname, (uint32_t)(uintptr_t)optval, optlen, + ret); } -void sys_trace_socket_setsockopt_enter(int sock, int level, int optname, - const void *optval, size_t optlen) +void sys_trace_socket_setsockopt_enter(int sock, int level, int optname, const void *optval, + size_t optlen) { - ctf_top_socket_setsockopt_enter(sock, level, optname, - (uint32_t)(uintptr_t)optval, optlen); + ctf_top_socket_setsockopt_enter(sock, level, optname, (uint32_t)(uintptr_t)optval, optlen); } void sys_trace_socket_setsockopt_exit(int sock, int ret) @@ -635,8 +1201,8 @@ void sys_trace_socket_getpeername_exit(int sock, struct sockaddr *addr, { ctf_net_bounded_string_t addr_str; - (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); ctf_top_socket_getpeername_exit(sock, addr_str, *addrlen, ret); } @@ -651,8 +1217,8 @@ void sys_trace_socket_getsockname_exit(int sock, const struct sockaddr *addr, { ctf_net_bounded_string_t addr_str; - (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, - addr_str.buf, sizeof(addr_str.buf)); + (void)net_addr_ntop(addr->sa_family, &net_sin(addr)->sin_addr, addr_str.buf, + sizeof(addr_str.buf)); ctf_top_socket_getsockname_exit(sock, addr_str, *addrlen, ret); } @@ -669,18 +1235,14 @@ void sys_trace_socket_socketpair_exit(int sock_A, int sock_B, int ret) void sys_trace_net_recv_data_enter(struct net_if *iface, struct net_pkt *pkt) { - ctf_top_net_recv_data_enter((int32_t)net_if_get_by_iface(iface), - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (uint32_t)net_pkt_get_len(pkt)); + ctf_top_net_recv_data_enter((int32_t)net_if_get_by_iface(iface), (uint32_t)(uintptr_t)iface, + (uint32_t)(uintptr_t)pkt, (uint32_t)net_pkt_get_len(pkt)); } void sys_trace_net_recv_data_exit(struct net_if *iface, struct net_pkt *pkt, int ret) { - ctf_top_net_recv_data_exit((int32_t)net_if_get_by_iface(iface), - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (int32_t)ret); + ctf_top_net_recv_data_exit((int32_t)net_if_get_by_iface(iface), (uint32_t)(uintptr_t)iface, + (uint32_t)(uintptr_t)pkt, (int32_t)ret); } void sys_trace_net_send_data_enter(struct net_pkt *pkt) @@ -695,10 +1257,8 @@ void sys_trace_net_send_data_enter(struct net_pkt *pkt) ifindex = net_if_get_by_iface(iface); } - ctf_top_net_send_data_enter((int32_t)ifindex, - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (uint32_t)net_pkt_get_len(pkt)); + ctf_top_net_send_data_enter((int32_t)ifindex, (uint32_t)(uintptr_t)iface, + (uint32_t)(uintptr_t)pkt, (uint32_t)net_pkt_get_len(pkt)); } void sys_trace_net_send_data_exit(struct net_pkt *pkt, int ret) @@ -713,10 +1273,8 @@ void sys_trace_net_send_data_exit(struct net_pkt *pkt, int ret) ifindex = net_if_get_by_iface(iface); } - ctf_top_net_send_data_exit((int32_t)ifindex, - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (int32_t)ret); + ctf_top_net_send_data_exit((int32_t)ifindex, (uint32_t)(uintptr_t)iface, + (uint32_t)(uintptr_t)pkt, (int32_t)ret); } void sys_trace_net_rx_time(struct net_pkt *pkt, uint32_t end_time) @@ -739,12 +1297,8 @@ void sys_trace_net_rx_time(struct net_pkt *pkt, uint32_t end_time) duration_us = k_cyc_to_ns_floor64(diff) / 1000U; } - ctf_top_net_rx_time((int32_t)ifindex, - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (uint32_t)net_pkt_priority(pkt), - (uint32_t)tc, - (uint32_t)duration_us); + ctf_top_net_rx_time((int32_t)ifindex, (uint32_t)(uintptr_t)iface, (uint32_t)(uintptr_t)pkt, + (uint32_t)net_pkt_priority(pkt), (uint32_t)tc, (uint32_t)duration_us); } void sys_trace_net_tx_time(struct net_pkt *pkt, uint32_t end_time) @@ -767,12 +1321,8 @@ void sys_trace_net_tx_time(struct net_pkt *pkt, uint32_t end_time) duration_us = k_cyc_to_ns_floor64(diff) / 1000U; } - ctf_top_net_tx_time((int32_t)ifindex, - (uint32_t)(uintptr_t)iface, - (uint32_t)(uintptr_t)pkt, - (uint32_t)net_pkt_priority(pkt), - (uint32_t)tc, - (uint32_t)duration_us); + ctf_top_net_tx_time((int32_t)ifindex, (uint32_t)(uintptr_t)iface, (uint32_t)(uintptr_t)pkt, + (uint32_t)net_pkt_priority(pkt), (uint32_t)tc, (uint32_t)duration_us); } void sys_trace_named_event(const char *name, uint32_t arg0, uint32_t arg1) @@ -947,3 +1497,100 @@ void sys_port_trace_gpio_fire_callback(const struct device *port, struct gpio_ca { ctf_top_gpio_fire_callback((uint32_t)(uintptr_t)port, (uint32_t)(uintptr_t)cb); } + +/* Mailbox */ +void sys_trace_k_mbox_init(struct k_mbox *mbox) +{ + ctf_top_mbox_init((uint32_t)(uintptr_t)mbox); +} + +void sys_trace_k_mbox_message_put_enter(struct k_mbox *mbox, k_timeout_t timeout) +{ + ctf_top_mbox_message_put_enter((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks); +} + +void sys_trace_k_mbox_message_put_blocking(struct k_mbox *mbox, k_timeout_t timeout) +{ + ctf_top_mbox_message_put_blocking((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks); +} + +void sys_trace_k_mbox_message_put_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret) +{ + ctf_top_mbox_message_put_exit((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks, + (int32_t)ret); +} + +void sys_trace_k_mbox_put_enter(struct k_mbox *mbox, k_timeout_t timeout) +{ + ctf_top_mbox_put_enter((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks); +} + +void sys_trace_k_mbox_put_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret) +{ + ctf_top_mbox_put_exit((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks, (int32_t)ret); +} + +void sys_trace_k_mbox_async_put_enter(struct k_mbox *mbox, struct k_sem *sem) +{ + ctf_top_mbox_async_put_enter((uint32_t)(uintptr_t)mbox, (uint32_t)(uintptr_t)sem); +} + +void sys_trace_k_mbox_async_put_exit(struct k_mbox *mbox, struct k_sem *sem) +{ + ctf_top_mbox_async_put_exit((uint32_t)(uintptr_t)mbox, (uint32_t)(uintptr_t)sem); +} + +void sys_trace_k_mbox_get_enter(struct k_mbox *mbox, k_timeout_t timeout) +{ + ctf_top_mbox_get_enter((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks); +} + +void sys_trace_k_mbox_get_blocking(struct k_mbox *mbox, k_timeout_t timeout) +{ + ctf_top_mbox_get_blocking((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks); +} + +void sys_trace_k_mbox_get_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret) +{ + ctf_top_mbox_get_exit((uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks, (int32_t)ret); +} + +void sys_trace_k_mbox_data_get(struct k_mbox_msg *rx_msg) +{ + ctf_top_mbox_data_get((uint32_t)(uintptr_t)rx_msg); +} + +/* Event */ +void sys_trace_k_event_init(struct k_event *event) +{ + ctf_top_event_init((uint32_t)(uintptr_t)event); +} + +void sys_trace_k_event_post_enter(struct k_event *event, uint32_t events, uint32_t events_mask) +{ + ctf_top_event_post_enter((uint32_t)(uintptr_t)event, events, events_mask); +} + +void sys_trace_k_event_post_exit(struct k_event *event, uint32_t events, uint32_t events_mask) +{ + ctf_top_event_post_exit((uint32_t)(uintptr_t)event, events, events_mask); +} + +void sys_trace_k_event_wait_enter(struct k_event *event, uint32_t events, uint32_t options, + k_timeout_t timeout) +{ + ctf_top_event_wait_enter((uint32_t)(uintptr_t)event, events, options, + (uint32_t)timeout.ticks); +} + +void sys_trace_k_event_wait_blocking(struct k_event *event, uint32_t events, uint32_t options, + k_timeout_t timeout) +{ + ctf_top_event_wait_blocking((uint32_t)(uintptr_t)event, events, options, + (uint32_t)timeout.ticks); +} + +void sys_trace_k_event_wait_exit(struct k_event *event, uint32_t events, int ret) +{ + ctf_top_event_wait_exit((uint32_t)(uintptr_t)event, events, (int32_t)ret); +} diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index d1461086a6fb1..325bd711b01ab 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -31,38 +31,35 @@ /* * Append a field to current event-packet. */ -#define CTF_INTERNAL_FIELD_APPEND(x) \ - { \ - memcpy(epacket_cursor, &(x), sizeof(x)); \ - epacket_cursor += sizeof(x); \ +#define CTF_INTERNAL_FIELD_APPEND(x) \ + { \ + memcpy(epacket_cursor, &(x), sizeof(x)); \ + epacket_cursor += sizeof(x); \ } /* * Gather fields to a contiguous event-packet, then atomically emit. */ -#define CTF_GATHER_FIELDS(...) \ - { \ - uint8_t epacket[0 MAP(CTF_INTERNAL_FIELD_SIZE, ##__VA_ARGS__)]; \ - uint8_t *epacket_cursor = &epacket[0]; \ - \ - MAP(CTF_INTERNAL_FIELD_APPEND, ##__VA_ARGS__) \ - tracing_format_raw_data(epacket, sizeof(epacket)); \ +#define CTF_GATHER_FIELDS(...) \ + { \ + uint8_t epacket[0 MAP(CTF_INTERNAL_FIELD_SIZE, ##__VA_ARGS__)]; \ + uint8_t *epacket_cursor = &epacket[0]; \ + \ + MAP(CTF_INTERNAL_FIELD_APPEND, ##__VA_ARGS__) \ + tracing_format_raw_data(epacket, sizeof(epacket)); \ } #ifdef CONFIG_TRACING_CTF_TIMESTAMP -#define CTF_EVENT(...) \ - { \ - int key = irq_lock(); \ - const uint32_t tstamp = k_cyc_to_ns_floor64(k_cycle_get_32()); \ - \ - CTF_GATHER_FIELDS(tstamp, __VA_ARGS__) \ - irq_unlock(key); \ +#define CTF_EVENT(...) \ + { \ + int key = irq_lock(); \ + const uint32_t tstamp = k_cyc_to_ns_floor64(k_cycle_get_32()); \ + \ + CTF_GATHER_FIELDS(tstamp, __VA_ARGS__) \ + irq_unlock(key); \ } #else -#define CTF_EVENT(...) \ - { \ - CTF_GATHER_FIELDS(__VA_ARGS__) \ - } +#define CTF_EVENT(...) {CTF_GATHER_FIELDS(__VA_ARGS__)} #endif /* Anonymous compound literal with 1 member. Legal since C99. @@ -190,31 +187,175 @@ typedef enum { CTF_EVENT_GPIO_FIRE_CALLBACK = 0x7E, CTF_EVENT_THREAD_SLEEP_ENTER = 0x7F, CTF_EVENT_THREAD_SLEEP_EXIT = 0x80, + /* memory slabs */ + CTF_EVENT_MEM_SLAB_INIT = 0x81, + CTF_EVENT_MEM_SLAB_ALLOC_ENTER = 0x82, + CTF_EVENT_MEM_SLAB_ALLOC_BLOCKING = 0x83, + CTF_EVENT_MEM_SLAB_ALLOC_EXIT = 0x84, + CTF_EVENT_MEM_SLAB_FREE_ENTER = 0x85, + CTF_EVENT_MEM_SLAB_FREE_EXIT = 0x86, + + /* Message Queues */ + CTF_EVENT_MSGQ_INIT = 0x87, + CTF_EVENT_MSGQ_ALLOC_INIT_ENTER = 0x88, + CTF_EVENT_MSGQ_ALLOC_INIT_EXIT = 0x89, + CTF_EVENT_MSGQ_PUT_ENTER = 0x8A, + CTF_EVENT_MSGQ_PUT_BLOCKING = 0x8B, + CTF_EVENT_MSGQ_PUT_EXIT = 0x8C, + CTF_EVENT_MSGQ_GET_ENTER = 0x8D, + CTF_EVENT_MSGQ_GET_BLOCKING = 0x8E, + CTF_EVENT_MSGQ_GET_EXIT = 0x8F, + CTF_EVENT_MSGQ_PEEK = 0x90, + CTF_EVENT_MSGQ_PURGE = 0x91, + CTF_EVENT_MSGQ_PUT_FRONT_ENTER = 0x92, + CTF_EVENT_MSGQ_PUT_FRONT_EXIT = 0x93, + CTF_EVENT_MSGQ_PUT_FRONT_BLOCKING = 0x94, + CTF_EVENT_MSGQ_CLEANUP_ENTER = 0x95, + CTF_EVENT_MSGQ_CLEANUP_EXIT = 0x96, + + /* Condition Variables */ + CTF_EVENT_CONDVAR_INIT = 0x97, + CTF_EVENT_CONDVAR_SIGNAL_ENTER = 0x98, + CTF_EVENT_CONDVAR_SIGNAL_BLOCKING = 0x99, + CTF_EVENT_CONDVAR_SIGNAL_EXIT = 0x9A, + CTF_EVENT_CONDVAR_BROADCAST_ENTER = 0x9B, + CTF_EVENT_CONDVAR_BROADCAST_EXIT = 0x9C, + CTF_EVENT_CONDVAR_WAIT_ENTER = 0x9D, + CTF_EVENT_CONDVAR_WAIT_EXIT = 0x9E, + + /* Work Queue */ + CTF_EVENT_WORK_INIT = 0x9F, + CTF_EVENT_WORK_SUBMIT_TO_QUEUE_ENTER = 0xA0, + CTF_EVENT_WORK_SUBMIT_TO_QUEUE_EXIT = 0xA1, + CTF_EVENT_WORK_SUBMIT_ENTER = 0xA2, + CTF_EVENT_WORK_SUBMIT_EXIT = 0xA3, + CTF_EVENT_WORK_FLUSH_ENTER = 0xA4, + CTF_EVENT_WORK_FLUSH_BLOCKING = 0xA5, + CTF_EVENT_WORK_FLUSH_EXIT = 0xA6, + CTF_EVENT_WORK_CANCEL_ENTER = 0xA7, + CTF_EVENT_WORK_CANCEL_EXIT = 0xA8, + CTF_EVENT_WORK_CANCEL_SYNC_ENTER = 0xA9, + CTF_EVENT_WORK_CANCEL_SYNC_BLOCKING = 0xAA, + CTF_EVENT_WORK_CANCEL_SYNC_EXIT = 0xAB, + + /* Work Queue Management */ + CTF_EVENT_WORK_QUEUE_INIT = 0xAC, + CTF_EVENT_WORK_QUEUE_START_ENTER = 0xAD, + CTF_EVENT_WORK_QUEUE_START_EXIT = 0xAE, + CTF_EVENT_WORK_QUEUE_STOP_ENTER = 0xAF, + CTF_EVENT_WORK_QUEUE_STOP_BLOCKING = 0xB0, + CTF_EVENT_WORK_QUEUE_STOP_EXIT = 0xB1, + CTF_EVENT_WORK_QUEUE_DRAIN_ENTER = 0xB2, + CTF_EVENT_WORK_QUEUE_DRAIN_EXIT = 0xB3, + CTF_EVENT_WORK_QUEUE_UNPLUG_ENTER = 0xB4, + CTF_EVENT_WORK_QUEUE_UNPLUG_EXIT = 0xB5, + + /* Delayable Work */ + CTF_EVENT_WORK_DELAYABLE_INIT = 0xB6, + CTF_EVENT_WORK_SCHEDULE_FOR_QUEUE_ENTER = 0xB7, + CTF_EVENT_WORK_SCHEDULE_FOR_QUEUE_EXIT = 0xB8, + CTF_EVENT_WORK_SCHEDULE_ENTER = 0xB9, + CTF_EVENT_WORK_SCHEDULE_EXIT = 0xBA, + CTF_EVENT_WORK_RESCHEDULE_FOR_QUEUE_ENTER = 0xBB, + CTF_EVENT_WORK_RESCHEDULE_FOR_QUEUE_EXIT = 0xBC, + CTF_EVENT_WORK_RESCHEDULE_ENTER = 0xBD, + CTF_EVENT_WORK_RESCHEDULE_EXIT = 0xBE, + CTF_EVENT_WORK_FLUSH_DELAYABLE_ENTER = 0xBF, + CTF_EVENT_WORK_FLUSH_DELAYABLE_EXIT = 0xC0, + CTF_EVENT_WORK_CANCEL_DELAYABLE_ENTER = 0xC1, + CTF_EVENT_WORK_CANCEL_DELAYABLE_EXIT = 0xC2, + CTF_EVENT_WORK_CANCEL_DELAYABLE_SYNC_ENTER = 0xC3, + CTF_EVENT_WORK_CANCEL_DELAYABLE_SYNC_EXIT = 0xC4, + + /* Poll Work */ + CTF_EVENT_WORK_POLL_INIT_ENTER = 0xC5, + CTF_EVENT_WORK_POLL_INIT_EXIT = 0xC6, + CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_ENTER = 0xC7, + CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_BLOCKING = 0xC8, + CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_EXIT = 0xC9, + CTF_EVENT_WORK_POLL_SUBMIT_ENTER = 0xCA, + CTF_EVENT_WORK_POLL_SUBMIT_EXIT = 0xCB, + CTF_EVENT_WORK_POLL_CANCEL_ENTER = 0xCC, + CTF_EVENT_WORK_POLL_CANCEL_EXIT = 0xCD, + + /* Poll API */ + CTF_EVENT_POLL_EVENT_INIT = 0xCE, + CTF_EVENT_POLL_ENTER = 0xCF, + CTF_EVENT_POLL_EXIT = 0xD0, + CTF_EVENT_POLL_SIGNAL_INIT = 0xD1, + CTF_EVENT_POLL_SIGNAL_RESET = 0xD2, + CTF_EVENT_POLL_SIGNAL_CHECK = 0xD3, + CTF_EVENT_POLL_SIGNAL_RAISE = 0xD4, + + /* Thread Extended */ + CTF_EVENT_THREAD_FOREACH_ENTER = 0xD5, + CTF_EVENT_THREAD_FOREACH_EXIT = 0xD6, + CTF_EVENT_THREAD_FOREACH_UNLOCKED_ENTER = 0xD7, + CTF_EVENT_THREAD_FOREACH_UNLOCKED_EXIT = 0xD8, + CTF_EVENT_THREAD_HEAP_ASSIGN = 0xD9, + CTF_EVENT_THREAD_JOIN_ENTER = 0xDA, + CTF_EVENT_THREAD_JOIN_BLOCKING = 0xDB, + CTF_EVENT_THREAD_JOIN_EXIT = 0xDC, + CTF_EVENT_THREAD_MSLEEP_ENTER = 0xDD, + CTF_EVENT_THREAD_MSLEEP_EXIT = 0xDE, + CTF_EVENT_THREAD_USLEEP_ENTER = 0xDF, + CTF_EVENT_THREAD_USLEEP_EXIT = 0xE0, + CTF_EVENT_THREAD_BUSY_WAIT_ENTER = 0xE1, + CTF_EVENT_THREAD_BUSY_WAIT_EXIT = 0xE2, + CTF_EVENT_THREAD_YIELD = 0xE3, + CTF_EVENT_THREAD_SUSPEND_EXIT = 0xE4, + CTF_EVENT_THREAD_SCHED_LOCK = 0xE5, + CTF_EVENT_THREAD_SCHED_UNLOCK = 0xE6, + CTF_EVENT_THREAD_SCHED_WAKEUP = 0xE7, + CTF_EVENT_THREAD_SCHED_ABORT = 0xE8, + CTF_EVENT_THREAD_SCHED_PRIORITY_SET = 0xE9, + CTF_EVENT_THREAD_SCHED_READY = 0xEA, + CTF_EVENT_THREAD_SCHED_PEND = 0xEB, + CTF_EVENT_THREAD_SCHED_RESUME = 0xEC, + CTF_EVENT_THREAD_SCHED_SUSPEND = 0xED, + + /* Mailbox */ + CTF_EVENT_MBOX_INIT = 0xEE, + CTF_EVENT_MBOX_MESSAGE_PUT_ENTER = 0xEF, + CTF_EVENT_MBOX_MESSAGE_PUT_BLOCKING = 0xF0, + CTF_EVENT_MBOX_MESSAGE_PUT_EXIT = 0xF1, + CTF_EVENT_MBOX_PUT_ENTER = 0xF2, + CTF_EVENT_MBOX_PUT_EXIT = 0xF3, + CTF_EVENT_MBOX_ASYNC_PUT_ENTER = 0xF4, + CTF_EVENT_MBOX_ASYNC_PUT_EXIT = 0xF5, + CTF_EVENT_MBOX_GET_ENTER = 0xF6, + CTF_EVENT_MBOX_GET_BLOCKING = 0xF7, + CTF_EVENT_MBOX_GET_EXIT = 0xF8, + CTF_EVENT_MBOX_DATA_GET = 0xF9, + + /* Event */ + CTF_EVENT_EVENT_INIT = 0xFA, + CTF_EVENT_EVENT_POST_ENTER = 0xFB, + CTF_EVENT_EVENT_POST_EXIT = 0xFC, + CTF_EVENT_EVENT_WAIT_ENTER = 0xFD, + CTF_EVENT_EVENT_WAIT_BLOCKING = 0xFE, + CTF_EVENT_EVENT_WAIT_EXIT = 0xFF, + } ctf_event_t; typedef struct { char buf[CTF_MAX_STRING_LEN]; } ctf_bounded_string_t; -static inline void ctf_top_thread_switched_out(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_switched_out(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SWITCHED_OUT), - thread_id, name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SWITCHED_OUT), thread_id, name); } -static inline void ctf_top_thread_switched_in(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_switched_in(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SWITCHED_IN), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SWITCHED_IN), thread_id, name); } static inline void ctf_top_thread_priority_set(uint32_t thread_id, int8_t prio, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_PRIORITY_SET), - thread_id, name, prio); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_PRIORITY_SET), thread_id, name, prio); } static inline void ctf_top_thread_sleep_enter(uint32_t timeout) @@ -227,74 +368,183 @@ static inline void ctf_top_thread_sleep_exit(uint32_t timeout, int32_t ret) CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SLEEP_EXIT), timeout, ret); } -static inline void ctf_top_thread_create(uint32_t thread_id, int8_t prio, - ctf_bounded_string_t name) +static inline void ctf_top_thread_create(uint32_t thread_id, int8_t prio, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_CREATE), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_CREATE), thread_id, name); } -static inline void ctf_top_thread_abort(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_abort(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_ABORT), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_ABORT), thread_id, name); } -static inline void ctf_top_thread_suspend(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_suspend(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SUSPEND), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SUSPEND), thread_id, name); } -static inline void ctf_top_thread_resume(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_resume(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_RESUME), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_RESUME), thread_id, name); } -static inline void ctf_top_thread_ready(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_ready(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_READY), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_READY), thread_id, name); } -static inline void ctf_top_thread_pend(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_pend(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_PENDING), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_PENDING), thread_id, name); } -static inline void ctf_top_thread_info(uint32_t thread_id, - ctf_bounded_string_t name, +static inline void ctf_top_thread_info(uint32_t thread_id, ctf_bounded_string_t name, uint32_t stack_base, uint32_t stack_size) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_INFO), thread_id, name, - stack_base, stack_size); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_INFO), thread_id, name, stack_base, + stack_size); } -static inline void ctf_top_thread_name_set(uint32_t thread_id, - ctf_bounded_string_t name) +static inline void ctf_top_thread_name_set(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_NAME_SET), thread_id, - name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_NAME_SET), thread_id, name); } - static inline void ctf_top_thread_user_mode_enter(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_USER_MODE_ENTER), - thread_id, name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_USER_MODE_ENTER), thread_id, name); } static inline void ctf_top_thread_wakeup(uint32_t thread_id, ctf_bounded_string_t name) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_WAKEUP), - thread_id, name); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_WAKEUP), thread_id, name); +} + +/* Thread Extended Functions */ +static inline void ctf_top_thread_foreach_enter(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_ENTER)); +} + +static inline void ctf_top_thread_foreach_exit(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_EXIT)); +} + +static inline void ctf_top_thread_foreach_unlocked_enter(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_UNLOCKED_ENTER)); +} + +static inline void ctf_top_thread_foreach_unlocked_exit(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_UNLOCKED_EXIT)); +} + +static inline void ctf_top_thread_heap_assign(uint32_t thread_id, uint32_t heap_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_HEAP_ASSIGN), thread_id, heap_id); +} + +static inline void ctf_top_thread_join_enter(uint32_t thread_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_JOIN_ENTER), thread_id, timeout); +} + +static inline void ctf_top_thread_join_blocking(uint32_t thread_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_JOIN_BLOCKING), thread_id, timeout); +} + +static inline void ctf_top_thread_join_exit(uint32_t thread_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_JOIN_EXIT), thread_id, timeout, ret); +} + +static inline void ctf_top_thread_msleep_enter(int32_t ms) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_MSLEEP_ENTER), ms); +} + +static inline void ctf_top_thread_msleep_exit(int32_t ms, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_MSLEEP_EXIT), ms, ret); +} + +static inline void ctf_top_thread_usleep_enter(int32_t us) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_USLEEP_ENTER), us); +} + +static inline void ctf_top_thread_usleep_exit(int32_t us, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_USLEEP_EXIT), us, ret); +} + +static inline void ctf_top_thread_busy_wait_enter(uint32_t usec_to_wait) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_BUSY_WAIT_ENTER), usec_to_wait); +} + +static inline void ctf_top_thread_busy_wait_exit(uint32_t usec_to_wait) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_BUSY_WAIT_EXIT), usec_to_wait); +} + +static inline void ctf_top_thread_yield(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_YIELD)); +} + +static inline void ctf_top_thread_suspend_exit(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SUSPEND_EXIT), thread_id, name); +} + +static inline void ctf_top_thread_sched_lock(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_LOCK)); +} + +static inline void ctf_top_thread_sched_unlock(void) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_UNLOCK)); +} + +static inline void ctf_top_thread_sched_wakeup(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_WAKEUP), thread_id, name); +} + +static inline void ctf_top_thread_sched_abort(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_ABORT), thread_id, name); +} + +static inline void ctf_top_thread_sched_priority_set(uint32_t thread_id, int8_t prio, + ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_PRIORITY_SET), thread_id, prio, name); +} + +static inline void ctf_top_thread_sched_ready(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_READY), thread_id, name); +} + +static inline void ctf_top_thread_sched_pend(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_PEND), thread_id, name); +} + +static inline void ctf_top_thread_sched_resume(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_RESUME), thread_id, name); +} + +static inline void ctf_top_thread_sched_suspend(uint32_t thread_id, ctf_bounded_string_t name) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_SCHED_SUSPEND), thread_id, name); } static inline void ctf_top_isr_enter(void) @@ -326,10 +576,449 @@ static inline void ctf_top_end_call(uint32_t id) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_ID_END_CALL), id); } +/* Memory Slabs */ +static inline void ctf_top_mem_slab_init(uint32_t slab_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_INIT), slab_id, ret); +} + +static inline void ctf_top_mem_slab_alloc_enter(uint32_t slab_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_ALLOC_ENTER), slab_id, timeout); +} + +static inline void ctf_top_mem_slab_alloc_blocking(uint32_t slab_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_ALLOC_BLOCKING), slab_id, timeout); +} + +static inline void ctf_top_mem_slab_alloc_exit(uint32_t slab_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_ALLOC_EXIT), slab_id, timeout, ret); +} + +static inline void ctf_top_mem_slab_free_enter(uint32_t slab_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_FREE_ENTER), slab_id); +} + +static inline void ctf_top_mem_slab_free_exit(uint32_t slab_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MEM_SLAB_FREE_EXIT), slab_id); +} + +/* Message Queues*/ +static inline void ctf_top_msgq_init(uint32_t msgq_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_INIT), msgq_id); +} + +static inline void ctf_top_msgq_alloc_init_enter(uint32_t msgq_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_ALLOC_INIT_ENTER), msgq_id); +} +static inline void ctf_top_msgq_alloc_init_exit(uint32_t msgq_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_ALLOC_INIT_EXIT), msgq_id, ret); +} + +static inline void ctf_top_msgq_put_enter(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_ENTER), msgq_id, timeout); +} + +static inline void ctf_top_msgq_put_blocking(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_BLOCKING), msgq_id, timeout); +} + +static inline void ctf_top_msgq_put_exit(uint32_t msgq_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_EXIT), msgq_id, timeout, ret); +} + +static inline void ctf_top_msgq_get_enter(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_GET_ENTER), msgq_id, timeout); +} + +static inline void ctf_top_msgq_get_blocking(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_GET_BLOCKING), msgq_id, timeout); +} + +static inline void ctf_top_msgq_get_exit(uint32_t msgq_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_GET_EXIT), msgq_id, timeout, ret); +} + +static inline void ctf_top_msgq_peek(uint32_t msgq_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PEEK), msgq_id, ret); +} + +static inline void ctf_top_msgq_purge(uint32_t msgq_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PURGE), msgq_id); +} + +static inline void ctf_top_msgq_put_front_enter(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_FRONT_ENTER), msgq_id, timeout); +} + +static inline void ctf_top_msgq_put_front_exit(uint32_t msgq_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_FRONT_EXIT), msgq_id, timeout, ret); +} + +static inline void ctf_top_msgq_put_front_blocking(uint32_t msgq_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_PUT_FRONT_BLOCKING), msgq_id, timeout); +} + +static inline void ctf_top_msgq_cleanup_enter(uint32_t msgq_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_CLEANUP_ENTER), msgq_id); +} + +static inline void ctf_top_msgq_cleanup_exit(uint32_t msgq_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MSGQ_CLEANUP_EXIT), msgq_id, ret); +} + +/* Condition Variables */ +static inline void ctf_top_condvar_init(uint32_t condvar_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_INIT), condvar_id, ret); +} +static inline void ctf_top_condvar_signal_enter(uint32_t condvar_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_SIGNAL_ENTER), condvar_id); +} +static inline void ctf_top_condvar_signal_blocking(uint32_t condvar_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_SIGNAL_BLOCKING), condvar_id, timeout); +} +static inline void ctf_top_condvar_signal_exit(uint32_t condvar_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_SIGNAL_EXIT), condvar_id, ret); +} +static inline void ctf_top_condvar_broadcast_enter(uint32_t condvar_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_BROADCAST_ENTER), condvar_id); +} +static inline void ctf_top_condvar_broadcast_exit(uint32_t condvar_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_BROADCAST_EXIT), condvar_id, ret); +} +static inline void ctf_top_condvar_wait_enter(uint32_t condvar_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_WAIT_ENTER), condvar_id, timeout); +} +static inline void ctf_top_condvar_wait_exit(uint32_t condvar_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_CONDVAR_WAIT_EXIT), condvar_id, timeout, ret); +} + +/* Work Queue */ +static inline void ctf_top_work_init(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_INIT), work_id); +} + +static inline void ctf_top_work_submit_to_queue_enter(uint32_t queue_id, uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SUBMIT_TO_QUEUE_ENTER), queue_id, work_id); +} + +static inline void ctf_top_work_submit_to_queue_exit(uint32_t queue_id, uint32_t work_id, + int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SUBMIT_TO_QUEUE_EXIT), queue_id, work_id, + ret); +} + +static inline void ctf_top_work_submit_enter(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SUBMIT_ENTER), work_id); +} + +static inline void ctf_top_work_submit_exit(uint32_t work_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SUBMIT_EXIT), work_id, ret); +} + +static inline void ctf_top_work_flush_enter(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_FLUSH_ENTER), work_id); +} + +static inline void ctf_top_work_flush_blocking(uint32_t work_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_FLUSH_BLOCKING), work_id, timeout); +} + +static inline void ctf_top_work_flush_exit(uint32_t work_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_FLUSH_EXIT), work_id, ret); +} + +static inline void ctf_top_work_cancel_enter(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_ENTER), work_id); +} + +static inline void ctf_top_work_cancel_exit(uint32_t work_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_EXIT), work_id, ret); +} + +static inline void ctf_top_work_cancel_sync_enter(uint32_t work_id, uint32_t sync_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_SYNC_ENTER), work_id, sync_id); +} + +static inline void ctf_top_work_cancel_sync_blocking(uint32_t work_id, uint32_t sync_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_SYNC_BLOCKING), work_id, sync_id); +} + +static inline void ctf_top_work_cancel_sync_exit(uint32_t work_id, uint32_t sync_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_SYNC_EXIT), work_id, sync_id, ret); +} + +/* Work Queue Management */ +static inline void ctf_top_work_queue_init(uint32_t queue_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_INIT), queue_id); +} + +static inline void ctf_top_work_queue_start_enter(uint32_t queue_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_START_ENTER), queue_id); +} + +static inline void ctf_top_work_queue_start_exit(uint32_t queue_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_START_EXIT), queue_id); +} + +static inline void ctf_top_work_queue_stop_enter(uint32_t queue_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_STOP_ENTER), queue_id, timeout); +} + +static inline void ctf_top_work_queue_stop_blocking(uint32_t queue_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_STOP_BLOCKING), queue_id, timeout); +} + +static inline void ctf_top_work_queue_stop_exit(uint32_t queue_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_STOP_EXIT), queue_id, timeout, ret); +} + +static inline void ctf_top_work_queue_drain_enter(uint32_t queue_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_DRAIN_ENTER), queue_id); +} + +static inline void ctf_top_work_queue_drain_exit(uint32_t queue_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_DRAIN_EXIT), queue_id, ret); +} + +static inline void ctf_top_work_queue_unplug_enter(uint32_t queue_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_UNPLUG_ENTER), queue_id); +} + +static inline void ctf_top_work_queue_unplug_exit(uint32_t queue_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_QUEUE_UNPLUG_EXIT), queue_id, ret); +} + +/* Delayable Work */ +static inline void ctf_top_work_delayable_init(uint32_t dwork_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_DELAYABLE_INIT), dwork_id); +} + +static inline void ctf_top_work_schedule_for_queue_enter(uint32_t queue_id, uint32_t dwork_id, + uint32_t delay) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SCHEDULE_FOR_QUEUE_ENTER), queue_id, dwork_id, + delay); +} + +static inline void ctf_top_work_schedule_for_queue_exit(uint32_t queue_id, uint32_t dwork_id, + uint32_t delay, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SCHEDULE_FOR_QUEUE_EXIT), queue_id, dwork_id, + delay, ret); +} + +static inline void ctf_top_work_schedule_enter(uint32_t dwork_id, uint32_t delay) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SCHEDULE_ENTER), dwork_id, delay); +} + +static inline void ctf_top_work_schedule_exit(uint32_t dwork_id, uint32_t delay, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_SCHEDULE_EXIT), dwork_id, delay, ret); +} + +static inline void ctf_top_work_reschedule_for_queue_enter(uint32_t queue_id, uint32_t dwork_id, + uint32_t delay) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_RESCHEDULE_FOR_QUEUE_ENTER), queue_id, + dwork_id, delay); +} + +static inline void ctf_top_work_reschedule_for_queue_exit(uint32_t queue_id, uint32_t dwork_id, + uint32_t delay, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_RESCHEDULE_FOR_QUEUE_EXIT), queue_id, + dwork_id, delay, ret); +} + +static inline void ctf_top_work_reschedule_enter(uint32_t dwork_id, uint32_t delay) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_RESCHEDULE_ENTER), dwork_id, delay); +} + +static inline void ctf_top_work_reschedule_exit(uint32_t dwork_id, uint32_t delay, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_RESCHEDULE_EXIT), dwork_id, delay, ret); +} + +static inline void ctf_top_work_flush_delayable_enter(uint32_t dwork_id, uint32_t sync_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_FLUSH_DELAYABLE_ENTER), dwork_id, sync_id); +} + +static inline void ctf_top_work_flush_delayable_exit(uint32_t dwork_id, uint32_t sync_id, + int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_FLUSH_DELAYABLE_EXIT), dwork_id, sync_id, + ret); +} + +static inline void ctf_top_work_cancel_delayable_enter(uint32_t dwork_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_DELAYABLE_ENTER), dwork_id); +} + +static inline void ctf_top_work_cancel_delayable_exit(uint32_t dwork_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_DELAYABLE_EXIT), dwork_id, ret); +} + +static inline void ctf_top_work_cancel_delayable_sync_enter(uint32_t dwork_id, uint32_t sync_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_DELAYABLE_SYNC_ENTER), dwork_id, + sync_id); +} + +static inline void ctf_top_work_cancel_delayable_sync_exit(uint32_t dwork_id, uint32_t sync_id, + int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_DELAYABLE_SYNC_EXIT), dwork_id, + sync_id, ret); +} + +/* Poll Work */ +static inline void ctf_top_work_poll_init_enter(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_INIT_ENTER), work_id); +} + +static inline void ctf_top_work_poll_init_exit(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_INIT_EXIT), work_id); +} + +static inline void ctf_top_work_poll_submit_to_queue_enter(uint32_t work_q_id, uint32_t work_id, + uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_ENTER), work_q_id, + work_id, timeout); +} + +static inline void ctf_top_work_poll_submit_to_queue_blocking(uint32_t work_q_id, uint32_t work_id, + uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_BLOCKING), work_q_id, + work_id, timeout); +} + +static inline void ctf_top_work_poll_submit_to_queue_exit(uint32_t work_q_id, uint32_t work_id, + uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_SUBMIT_TO_QUEUE_EXIT), work_q_id, + work_id, timeout, ret); +} + +static inline void ctf_top_work_poll_submit_enter(uint32_t work_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_SUBMIT_ENTER), work_id, timeout); +} + +static inline void ctf_top_work_poll_submit_exit(uint32_t work_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_SUBMIT_EXIT), work_id, timeout, ret); +} + +static inline void ctf_top_work_poll_cancel_enter(uint32_t work_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_CANCEL_ENTER), work_id); +} + +static inline void ctf_top_work_poll_cancel_exit(uint32_t work_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_POLL_CANCEL_EXIT), work_id, ret); +} + +/* Poll API */ +static inline void ctf_top_poll_event_init(uint32_t event_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_EVENT_INIT), event_id); +} + +static inline void ctf_top_poll_enter(uint32_t events_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_ENTER), events_id); +} + +static inline void ctf_top_poll_exit(uint32_t events_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_EXIT), events_id, ret); +} + +static inline void ctf_top_poll_signal_init(uint32_t signal_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_SIGNAL_INIT), signal_id); +} + +static inline void ctf_top_poll_signal_reset(uint32_t signal_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_SIGNAL_RESET), signal_id); +} + +static inline void ctf_top_poll_signal_check(uint32_t signal_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_SIGNAL_CHECK), signal_id); +} + +static inline void ctf_top_poll_signal_raise(uint32_t signal_id, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_POLL_SIGNAL_RAISE), signal_id, ret); +} /* Semaphore */ -static inline void ctf_top_semaphore_init(uint32_t sem_id, - int32_t ret) +static inline void ctf_top_semaphore_init(uint32_t sem_id, int32_t ret) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_INIT), sem_id, ret); } @@ -339,25 +1028,19 @@ static inline void ctf_top_semaphore_reset(uint32_t sem_id) CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_RESET), sem_id); } -static inline void ctf_top_semaphore_take_enter(uint32_t sem_id, - uint32_t timeout) +static inline void ctf_top_semaphore_take_enter(uint32_t sem_id, uint32_t timeout) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_ENTER), sem_id, - timeout); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_ENTER), sem_id, timeout); } -static inline void ctf_top_semaphore_take_blocking(uint32_t sem_id, - uint32_t timeout) +static inline void ctf_top_semaphore_take_blocking(uint32_t sem_id, uint32_t timeout) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_BLOCKING), - sem_id, timeout); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_BLOCKING), sem_id, timeout); } -static inline void ctf_top_semaphore_take_exit(uint32_t sem_id, - uint32_t timeout, int32_t ret) +static inline void ctf_top_semaphore_take_exit(uint32_t sem_id, uint32_t timeout, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_EXIT), sem_id, - timeout, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SEMAPHORE_TAKE_EXIT), sem_id, timeout, ret); } static inline void ctf_top_semaphore_give_enter(uint32_t sem_id) @@ -378,22 +1061,17 @@ static inline void ctf_top_mutex_init(uint32_t mutex_id, int32_t ret) static inline void ctf_top_mutex_lock_enter(uint32_t mutex_id, uint32_t timeout) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_ENTER), mutex_id, - timeout); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_ENTER), mutex_id, timeout); } -static inline void ctf_top_mutex_lock_blocking(uint32_t mutex_id, - uint32_t timeout) +static inline void ctf_top_mutex_lock_blocking(uint32_t mutex_id, uint32_t timeout) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_BLOCKING), mutex_id, - timeout); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_BLOCKING), mutex_id, timeout); } -static inline void ctf_top_mutex_lock_exit(uint32_t mutex_id, uint32_t timeout, - int32_t ret) +static inline void ctf_top_mutex_lock_exit(uint32_t mutex_id, uint32_t timeout, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_EXIT), mutex_id, - timeout, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_LOCK_EXIT), mutex_id, timeout, ret); } static inline void ctf_top_mutex_unlock_enter(uint32_t mutex_id) @@ -403,7 +1081,7 @@ static inline void ctf_top_mutex_unlock_enter(uint32_t mutex_id) static inline void ctf_top_mutex_unlock_exit(uint32_t mutex_id, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_UNLOCK_EXIT), mutex_id); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MUTEX_UNLOCK_EXIT), mutex_id, ret); } /* Timer */ @@ -442,8 +1120,7 @@ typedef struct { char buf[CTF_NET_MAX_STRING_LEN]; } ctf_net_bounded_string_t; -static inline void ctf_top_socket_init(int32_t sock, uint32_t family, - uint32_t type, uint32_t proto) +static inline void ctf_top_socket_init(int32_t sock, uint32_t family, uint32_t type, uint32_t proto) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_INIT), sock, family, type, proto); } @@ -479,8 +1156,7 @@ static inline void ctf_top_socket_bind_exit(int32_t sock, int32_t ret) CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_BIND_EXIT), sock, ret); } -static inline void ctf_top_socket_connect_enter(int32_t sock, - ctf_net_bounded_string_t addr, +static inline void ctf_top_socket_connect_enter(int32_t sock, ctf_net_bounded_string_t addr, uint32_t addrlen) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_CONNECT_ENTER), sock, addr, addrlen); @@ -509,15 +1185,15 @@ static inline void ctf_top_socket_accept_enter(int32_t sock) static inline void ctf_top_socket_accept_exit(int32_t sock, ctf_net_bounded_string_t addr, uint32_t addrlen, uint16_t port, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_ACCEPT_EXIT), sock, addr, addrlen, - port, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_ACCEPT_EXIT), sock, addr, addrlen, port, + ret); } static inline void ctf_top_socket_sendto_enter(int32_t sock, uint32_t len, uint32_t flags, ctf_net_bounded_string_t addr, uint32_t addrlen) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SENDTO_ENTER), sock, len, flags, - addr, addrlen); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SENDTO_ENTER), sock, len, flags, addr, + addrlen); } static inline void ctf_top_socket_sendto_exit(int32_t sock, int32_t ret) @@ -528,8 +1204,8 @@ static inline void ctf_top_socket_sendto_exit(int32_t sock, int32_t ret) static inline void ctf_top_socket_sendmsg_enter(int32_t sock, uint32_t flags, uint32_t msg, ctf_net_bounded_string_t addr, uint32_t len) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SENDMSG_ENTER), sock, flags, msg, - addr, len); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SENDMSG_ENTER), sock, flags, msg, addr, + len); } static inline void ctf_top_socket_sendmsg_exit(int32_t sock, int32_t ret) @@ -540,8 +1216,8 @@ static inline void ctf_top_socket_sendmsg_exit(int32_t sock, int32_t ret) static inline void ctf_top_socket_recvfrom_enter(int32_t sock, uint32_t max_len, uint32_t flags, uint32_t addr, uint32_t addrlen) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_RECVFROM_ENTER), sock, max_len, flags, - addr, addrlen); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_RECVFROM_ENTER), sock, max_len, flags, addr, + addrlen); } static inline void ctf_top_socket_recvfrom_exit(int32_t sock, ctf_net_bounded_string_t addr, @@ -605,15 +1281,15 @@ static inline void ctf_top_socket_getsockopt_enter(int32_t sock, uint32_t level, static inline void ctf_top_socket_getsockopt_exit(int32_t sock, uint32_t level, uint32_t optname, uint32_t optval, uint32_t optlen, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETSOCKOPT_EXIT), - sock, level, optname, optval, optlen, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETSOCKOPT_EXIT), sock, level, optname, + optval, optlen, ret); } static inline void ctf_top_socket_setsockopt_enter(int32_t sock, uint32_t level, uint32_t optname, uint32_t optval, uint32_t optlen) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SETSOCKOPT_ENTER), sock, level, - optname, optval, optlen); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SETSOCKOPT_ENTER), sock, level, optname, + optval, optlen); } static inline void ctf_top_socket_setsockopt_exit(int32_t sock, int32_t ret) @@ -629,8 +1305,8 @@ static inline void ctf_top_socket_getpeername_enter(int32_t sock) static inline void ctf_top_socket_getpeername_exit(int32_t sock, ctf_net_bounded_string_t addr, uint32_t addrlen, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETPEERNAME_EXIT), - sock, addr, addrlen, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETPEERNAME_EXIT), sock, addr, addrlen, + ret); } static inline void ctf_top_socket_getsockname_enter(int32_t sock) @@ -641,15 +1317,14 @@ static inline void ctf_top_socket_getsockname_enter(int32_t sock) static inline void ctf_top_socket_getsockname_exit(int32_t sock, ctf_net_bounded_string_t addr, uint32_t addrlen, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETSOCKNAME_EXIT), - sock, addr, addrlen, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_GETSOCKNAME_EXIT), sock, addr, addrlen, + ret); } -static inline void ctf_top_socket_socketpair_enter(uint32_t family, uint32_t type, - uint32_t proto, uint32_t sv) +static inline void ctf_top_socket_socketpair_enter(uint32_t family, uint32_t type, uint32_t proto, + uint32_t sv) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SOCKETPAIR_ENTER), family, type, - proto, sv); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SOCKETPAIR_ENTER), family, type, proto, sv); } static inline void ctf_top_socket_socketpair_exit(int32_t sock_A, int32_t sock_B, int32_t ret) @@ -660,50 +1335,44 @@ static inline void ctf_top_socket_socketpair_exit(int32_t sock_A, int32_t sock_B static inline void ctf_top_net_recv_data_enter(int32_t if_index, uint32_t iface, uint32_t pkt, uint32_t len) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RECV_DATA_ENTER), - if_index, iface, pkt, len); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RECV_DATA_ENTER), if_index, iface, pkt, len); } static inline void ctf_top_net_recv_data_exit(int32_t if_index, uint32_t iface, uint32_t pkt, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RECV_DATA_EXIT), - if_index, iface, pkt, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RECV_DATA_EXIT), if_index, iface, pkt, ret); } static inline void ctf_top_net_send_data_enter(int32_t if_index, uint32_t iface, uint32_t pkt, uint32_t len) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_SEND_DATA_ENTER), - if_index, iface, pkt, len); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_SEND_DATA_ENTER), if_index, iface, pkt, len); } static inline void ctf_top_net_send_data_exit(int32_t if_index, uint32_t iface, uint32_t pkt, int32_t ret) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_SEND_DATA_EXIT), - if_index, iface, pkt, ret); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_SEND_DATA_EXIT), if_index, iface, pkt, ret); } static inline void ctf_top_net_rx_time(int32_t if_index, uint32_t iface, uint32_t pkt, uint32_t priority, uint32_t tc, uint32_t duration) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RX_TIME), - if_index, iface, pkt, priority, tc, duration); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_RX_TIME), if_index, iface, pkt, priority, tc, + duration); } static inline void ctf_top_net_tx_time(int32_t if_index, uint32_t iface, uint32_t pkt, uint32_t priority, uint32_t tc, uint32_t duration) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_TX_TIME), - if_index, iface, pkt, priority, tc, duration); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NET_TX_TIME), if_index, iface, pkt, priority, tc, + duration); } -static inline void ctf_named_event(ctf_bounded_string_t name, uint32_t arg0, - uint32_t arg1) +static inline void ctf_named_event(ctf_bounded_string_t name, uint32_t arg0, uint32_t arg1) { - CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NAMED_EVENT), name, - arg0, arg1); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_NAMED_EVENT), name, arg0, arg1); } /* GPIO */ @@ -857,4 +1526,101 @@ static inline void ctf_top_gpio_fire_callback(uint32_t port, uint32_t cb) CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_FIRE_CALLBACK), port, cb); } +/* Mailbox */ +static inline void ctf_top_mbox_init(uint32_t mbox_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_INIT), mbox_id); +} + +static inline void ctf_top_mbox_message_put_enter(uint32_t mbox_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_MESSAGE_PUT_ENTER), mbox_id, timeout); +} + +static inline void ctf_top_mbox_message_put_blocking(uint32_t mbox_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_MESSAGE_PUT_BLOCKING), mbox_id, timeout); +} + +static inline void ctf_top_mbox_message_put_exit(uint32_t mbox_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_MESSAGE_PUT_EXIT), mbox_id, timeout, ret); +} + +static inline void ctf_top_mbox_put_enter(uint32_t mbox_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_PUT_ENTER), mbox_id, timeout); +} + +static inline void ctf_top_mbox_put_exit(uint32_t mbox_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_PUT_EXIT), mbox_id, timeout, ret); +} + +static inline void ctf_top_mbox_async_put_enter(uint32_t mbox_id, uint32_t sem_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_ASYNC_PUT_ENTER), mbox_id, sem_id); +} + +static inline void ctf_top_mbox_async_put_exit(uint32_t mbox_id, uint32_t sem_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_ASYNC_PUT_EXIT), mbox_id, sem_id); +} + +static inline void ctf_top_mbox_get_enter(uint32_t mbox_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_GET_ENTER), mbox_id, timeout); +} + +static inline void ctf_top_mbox_get_blocking(uint32_t mbox_id, uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_GET_BLOCKING), mbox_id, timeout); +} + +static inline void ctf_top_mbox_get_exit(uint32_t mbox_id, uint32_t timeout, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_GET_EXIT), mbox_id, timeout, ret); +} + +static inline void ctf_top_mbox_data_get(uint32_t msg_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_MBOX_DATA_GET), msg_id); +} + +/* Event */ +static inline void ctf_top_event_init(uint32_t event_id) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_INIT), event_id); +} + +static inline void ctf_top_event_post_enter(uint32_t event_id, uint32_t events, + uint32_t events_mask) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_POST_ENTER), event_id, events, events_mask); +} + +static inline void ctf_top_event_post_exit(uint32_t event_id, uint32_t events, uint32_t events_mask) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_POST_EXIT), event_id, events, events_mask); +} + +static inline void ctf_top_event_wait_enter(uint32_t event_id, uint32_t events, uint32_t options, + uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_WAIT_ENTER), event_id, events, options, + timeout); +} + +static inline void ctf_top_event_wait_blocking(uint32_t event_id, uint32_t events, uint32_t options, + uint32_t timeout) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_WAIT_BLOCKING), event_id, events, options, + timeout); +} + +static inline void ctf_top_event_wait_exit(uint32_t event_id, uint32_t events, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_EVENT_WAIT_EXIT), event_id, events, ret); +} + #endif /* SUBSYS_DEBUG_TRACING_CTF_TOP_H */ diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index 73bca9d1051c9..ef4b932b68377 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -15,50 +15,49 @@ extern "C" { #endif +#define sys_port_trace_k_thread_foreach_enter() sys_trace_k_thread_foreach_enter() +#define sys_port_trace_k_thread_foreach_exit() sys_trace_k_thread_foreach_exit() +#define sys_port_trace_k_thread_foreach_unlocked_enter() sys_trace_k_thread_foreach_unlocked_enter() +#define sys_port_trace_k_thread_foreach_unlocked_exit() sys_trace_k_thread_foreach_unlocked_exit() -#define sys_port_trace_k_thread_foreach_enter() -#define sys_port_trace_k_thread_foreach_exit() -#define sys_port_trace_k_thread_foreach_unlocked_enter() -#define sys_port_trace_k_thread_foreach_unlocked_exit() - -#define sys_port_trace_k_thread_create(new_thread) \ +#define sys_port_trace_k_thread_create(new_thread) \ sys_trace_k_thread_create(new_thread, stack_size, prio) -#define sys_port_trace_k_thread_user_mode_enter() \ - sys_trace_k_thread_user_mode_enter() - -#define sys_port_trace_k_thread_heap_assign(thread, heap) -#define sys_port_trace_k_thread_join_enter(thread, timeout) -#define sys_port_trace_k_thread_join_blocking(thread, timeout) -#define sys_port_trace_k_thread_join_exit(thread, timeout, ret) - -#define sys_port_trace_k_thread_sleep_enter(timeout) \ - sys_trace_k_thread_sleep_enter(timeout) -#define sys_port_trace_k_thread_sleep_exit(timeout, ret) \ - sys_trace_k_thread_sleep_exit(timeout, ret) - -#define sys_port_trace_k_thread_msleep_enter(ms) -#define sys_port_trace_k_thread_msleep_exit(ms, ret) -#define sys_port_trace_k_thread_usleep_enter(us) -#define sys_port_trace_k_thread_usleep_exit(us, ret) -#define sys_port_trace_k_thread_busy_wait_enter(usec_to_wait) -#define sys_port_trace_k_thread_busy_wait_exit(usec_to_wait) -#define sys_port_trace_k_thread_yield() -#define sys_port_trace_k_thread_wakeup(thread) sys_trace_k_thread_wakeup(thread) -#define sys_port_trace_k_thread_start(thread) sys_trace_k_thread_start(thread) -#define sys_port_trace_k_thread_abort(thread) sys_trace_k_thread_abort(thread) -#define sys_port_trace_k_thread_suspend_enter(thread) \ - sys_trace_k_thread_suspend(thread) -#define sys_port_trace_k_thread_suspend_exit(thread) -#define sys_port_trace_k_thread_resume_enter(thread) \ - sys_trace_k_thread_resume(thread) - -#define sys_port_trace_k_thread_sched_lock() - -#define sys_port_trace_k_thread_sched_unlock() - -#define sys_port_trace_k_thread_name_set(thread, ret) \ - sys_trace_k_thread_name_set(thread, ret) +#define sys_port_trace_k_thread_user_mode_enter() sys_trace_k_thread_user_mode_enter() + +#define sys_port_trace_k_thread_heap_assign(thread, heap) \ + sys_trace_k_thread_heap_assign(thread, heap) +#define sys_port_trace_k_thread_join_enter(thread, timeout) \ + sys_trace_k_thread_join_enter(thread, timeout) +#define sys_port_trace_k_thread_join_blocking(thread, timeout) \ + sys_trace_k_thread_join_blocking(thread, timeout) +#define sys_port_trace_k_thread_join_exit(thread, timeout, ret) \ + sys_trace_k_thread_join_exit(thread, timeout, ret) + +#define sys_port_trace_k_thread_sleep_enter(timeout) sys_trace_k_thread_sleep_enter(timeout) +#define sys_port_trace_k_thread_sleep_exit(timeout, ret) sys_trace_k_thread_sleep_exit(timeout, ret) + +#define sys_port_trace_k_thread_msleep_enter(ms) sys_trace_k_thread_msleep_enter(ms) +#define sys_port_trace_k_thread_msleep_exit(ms, ret) sys_trace_k_thread_msleep_exit(ms, ret) +#define sys_port_trace_k_thread_usleep_enter(us) sys_trace_k_thread_usleep_enter(us) +#define sys_port_trace_k_thread_usleep_exit(us, ret) sys_trace_k_thread_usleep_exit(us, ret) +#define sys_port_trace_k_thread_busy_wait_enter(usec_to_wait) \ + sys_trace_k_thread_busy_wait_enter(usec_to_wait) +#define sys_port_trace_k_thread_busy_wait_exit(usec_to_wait) \ + sys_trace_k_thread_busy_wait_exit(usec_to_wait) +#define sys_port_trace_k_thread_yield() sys_trace_k_thread_yield() +#define sys_port_trace_k_thread_wakeup(thread) sys_trace_k_thread_wakeup(thread) +#define sys_port_trace_k_thread_start(thread) sys_trace_k_thread_start(thread) +#define sys_port_trace_k_thread_abort(thread) sys_trace_k_thread_abort(thread) +#define sys_port_trace_k_thread_suspend_enter(thread) sys_trace_k_thread_suspend(thread) +#define sys_port_trace_k_thread_suspend_exit(thread) sys_trace_k_thread_suspend_exit(thread) +#define sys_port_trace_k_thread_resume_enter(thread) sys_trace_k_thread_resume(thread) + +#define sys_port_trace_k_thread_sched_lock() sys_trace_k_thread_sched_lock() + +#define sys_port_trace_k_thread_sched_unlock() sys_trace_k_thread_sched_unlock() + +#define sys_port_trace_k_thread_name_set(thread, ret) sys_trace_k_thread_name_set(thread, ret) #define sys_port_trace_k_thread_switched_out() sys_trace_k_thread_switched_out() @@ -66,129 +65,154 @@ extern "C" { #define sys_port_trace_k_thread_info(thread) sys_trace_k_thread_info(thread) -#define sys_port_trace_k_thread_sched_wakeup(thread) -#define sys_port_trace_k_thread_sched_abort(thread) -#define sys_port_trace_k_thread_sched_priority_set(thread, prio) -#define sys_port_trace_k_thread_sched_ready(thread) - -#define sys_port_trace_k_thread_sched_pend(thread) - -#define sys_port_trace_k_thread_sched_resume(thread) - -#define sys_port_trace_k_thread_sched_suspend(thread) - -#define sys_port_trace_k_work_init(work) -#define sys_port_trace_k_work_submit_to_queue_enter(queue, work) -#define sys_port_trace_k_work_submit_to_queue_exit(queue, work, ret) -#define sys_port_trace_k_work_submit_enter(work) -#define sys_port_trace_k_work_submit_exit(work, ret) -#define sys_port_trace_k_work_flush_enter(work) -#define sys_port_trace_k_work_flush_blocking(work, timeout) -#define sys_port_trace_k_work_flush_exit(work, ret) -#define sys_port_trace_k_work_cancel_enter(work) -#define sys_port_trace_k_work_cancel_exit(work, ret) -#define sys_port_trace_k_work_cancel_sync_enter(work, sync) -#define sys_port_trace_k_work_cancel_sync_blocking(work, sync) -#define sys_port_trace_k_work_cancel_sync_exit(work, sync, ret) - -#define sys_port_trace_k_work_queue_init(queue) -#define sys_port_trace_k_work_queue_start_enter(queue) -#define sys_port_trace_k_work_queue_start_exit(queue) -#define sys_port_trace_k_work_queue_stop_enter(queue, timeout) -#define sys_port_trace_k_work_queue_stop_blocking(queue, timeout) -#define sys_port_trace_k_work_queue_stop_exit(queue, timeout, ret) -#define sys_port_trace_k_work_queue_drain_enter(queue) -#define sys_port_trace_k_work_queue_drain_exit(queue, ret) -#define sys_port_trace_k_work_queue_unplug_enter(queue) -#define sys_port_trace_k_work_queue_unplug_exit(queue, ret) - -#define sys_port_trace_k_work_delayable_init(dwork) -#define sys_port_trace_k_work_schedule_for_queue_enter(queue, dwork, delay) -#define sys_port_trace_k_work_schedule_for_queue_exit(queue, dwork, delay, \ - ret) -#define sys_port_trace_k_work_schedule_enter(dwork, delay) -#define sys_port_trace_k_work_schedule_exit(dwork, delay, ret) -#define sys_port_trace_k_work_reschedule_for_queue_enter(queue, dwork, delay) -#define sys_port_trace_k_work_reschedule_for_queue_exit(queue, dwork, delay, \ - ret) -#define sys_port_trace_k_work_reschedule_enter(dwork, delay) -#define sys_port_trace_k_work_reschedule_exit(dwork, delay, ret) -#define sys_port_trace_k_work_flush_delayable_enter(dwork, sync) -#define sys_port_trace_k_work_flush_delayable_exit(dwork, sync, ret) -#define sys_port_trace_k_work_cancel_delayable_enter(dwork) -#define sys_port_trace_k_work_cancel_delayable_exit(dwork, ret) -#define sys_port_trace_k_work_cancel_delayable_sync_enter(dwork, sync) -#define sys_port_trace_k_work_cancel_delayable_sync_exit(dwork, sync, ret) - -#define sys_port_trace_k_work_poll_init_enter(work) -#define sys_port_trace_k_work_poll_init_exit(work) -#define sys_port_trace_k_work_poll_submit_to_queue_enter(work_q, work, \ - timeout) -#define sys_port_trace_k_work_poll_submit_to_queue_blocking(work_q, work, \ - timeout) -#define sys_port_trace_k_work_poll_submit_to_queue_exit(work_q, work, timeout, \ - ret) -#define sys_port_trace_k_work_poll_submit_enter(work, timeout) -#define sys_port_trace_k_work_poll_submit_exit(work, timeout, ret) -#define sys_port_trace_k_work_poll_cancel_enter(work) -#define sys_port_trace_k_work_poll_cancel_exit(work, ret) - -#define sys_port_trace_k_poll_api_event_init(event) -#define sys_port_trace_k_poll_api_poll_enter(events) -#define sys_port_trace_k_poll_api_poll_exit(events, ret) -#define sys_port_trace_k_poll_api_signal_init(signal) -#define sys_port_trace_k_poll_api_signal_reset(signal) -#define sys_port_trace_k_poll_api_signal_check(signal) -#define sys_port_trace_k_poll_api_signal_raise(signal, ret) - -#define sys_port_trace_k_sem_init(sem, ret) \ - sys_trace_k_sem_init(sem, ret) - -#define sys_port_trace_k_sem_give_enter(sem) sys_trace_k_sem_give_enter(sem) -#define sys_port_trace_k_sem_give_exit(sem) sys_trace_k_sem_give_exit(sem) -#define sys_port_trace_k_sem_take_enter(sem, timeout) \ - sys_trace_k_sem_take_enter(sem, timeout) -#define sys_port_trace_k_sem_take_blocking(sem, timeout) \ - sys_trace_k_sem_take_blocking(sem, timeout) -#define sys_port_trace_k_sem_take_exit(sem, timeout, ret) \ +#define sys_port_trace_k_thread_sched_wakeup(thread) sys_trace_k_thread_sched_wakeup(thread) +#define sys_port_trace_k_thread_sched_abort(thread) sys_trace_k_thread_sched_abort(thread) +#define sys_port_trace_k_thread_sched_priority_set(thread, prio) \ + sys_trace_k_thread_sched_priority_set(thread, prio) +#define sys_port_trace_k_thread_sched_ready(thread) sys_trace_k_thread_sched_ready(thread) + +#define sys_port_trace_k_thread_sched_pend(thread) sys_trace_k_thread_sched_pend(thread) + +#define sys_port_trace_k_thread_sched_resume(thread) sys_trace_k_thread_sched_resume(thread) + +#define sys_port_trace_k_thread_sched_suspend(thread) sys_trace_k_thread_sched_suspend(thread) + +#define sys_port_trace_k_work_init(work) sys_trace_k_work_init(work) +#define sys_port_trace_k_work_submit_to_queue_enter(queue, work) \ + sys_trace_k_work_submit_to_queue_enter(queue, work) +#define sys_port_trace_k_work_submit_to_queue_exit(queue, work, ret) \ + sys_trace_k_work_submit_to_queue_exit(queue, work, ret) +#define sys_port_trace_k_work_submit_enter(work) sys_trace_k_work_submit_enter(work) +#define sys_port_trace_k_work_submit_exit(work, ret) sys_trace_k_work_submit_exit(work, ret) +#define sys_port_trace_k_work_flush_enter(work) sys_trace_k_work_flush_enter(work) +#define sys_port_trace_k_work_flush_blocking(work, timeout) \ + sys_trace_k_work_flush_blocking(work, timeout) +#define sys_port_trace_k_work_flush_exit(work, ret) sys_trace_k_work_flush_exit(work, ret) +#define sys_port_trace_k_work_cancel_enter(work) sys_trace_k_work_cancel_enter(work) +#define sys_port_trace_k_work_cancel_exit(work, ret) sys_trace_k_work_cancel_exit(work, ret) +#define sys_port_trace_k_work_cancel_sync_enter(work, sync) \ + sys_trace_k_work_cancel_sync_enter(work, sync) +#define sys_port_trace_k_work_cancel_sync_blocking(work, sync) \ + sys_trace_k_work_cancel_sync_blocking(work, sync) +#define sys_port_trace_k_work_cancel_sync_exit(work, sync, ret) \ + sys_trace_k_work_cancel_sync_exit(work, sync, ret) + +#define sys_port_trace_k_work_queue_init(queue) sys_trace_k_work_queue_init(queue) +#define sys_port_trace_k_work_queue_start_enter(queue) sys_trace_k_work_queue_start_enter(queue) +#define sys_port_trace_k_work_queue_start_exit(queue) sys_trace_k_work_queue_start_exit(queue) +#define sys_port_trace_k_work_queue_stop_enter(queue, timeout) \ + sys_trace_k_work_queue_stop_enter(queue, timeout) +#define sys_port_trace_k_work_queue_stop_blocking(queue, timeout) \ + sys_trace_k_work_queue_stop_blocking(queue, timeout) +#define sys_port_trace_k_work_queue_stop_exit(queue, timeout, ret) \ + sys_trace_k_work_queue_stop_exit(queue, timeout, ret) +#define sys_port_trace_k_work_queue_drain_enter(queue) sys_trace_k_work_queue_drain_enter(queue) +#define sys_port_trace_k_work_queue_drain_exit(queue, ret) \ + sys_trace_k_work_queue_drain_exit(queue, ret) +#define sys_port_trace_k_work_queue_unplug_enter(queue) sys_trace_k_work_queue_unplug_enter(queue) +#define sys_port_trace_k_work_queue_unplug_exit(queue, ret) \ + sys_trace_k_work_queue_unplug_exit(queue, ret) + +#define sys_port_trace_k_work_delayable_init(dwork) sys_trace_k_work_delayable_init(dwork) +#define sys_port_trace_k_work_schedule_for_queue_enter(queue, dwork, delay) \ + sys_trace_k_work_schedule_for_queue_enter(queue, dwork, delay) +#define sys_port_trace_k_work_schedule_for_queue_exit(queue, dwork, delay, ret) \ + sys_trace_k_work_schedule_for_queue_exit(queue, dwork, delay, ret) +#define sys_port_trace_k_work_schedule_enter(dwork, delay) \ + sys_trace_k_work_schedule_enter(dwork, delay) +#define sys_port_trace_k_work_schedule_exit(dwork, delay, ret) \ + sys_trace_k_work_schedule_exit(dwork, delay, ret) +#define sys_port_trace_k_work_reschedule_for_queue_enter(queue, dwork, delay) \ + sys_trace_k_work_reschedule_for_queue_enter(queue, dwork, delay) +#define sys_port_trace_k_work_reschedule_for_queue_exit(queue, dwork, delay, ret) \ + sys_trace_k_work_reschedule_for_queue_exit(queue, dwork, delay, ret) +#define sys_port_trace_k_work_reschedule_enter(dwork, delay) \ + sys_trace_k_work_reschedule_enter(dwork, delay) +#define sys_port_trace_k_work_reschedule_exit(dwork, delay, ret) \ + sys_trace_k_work_reschedule_exit(dwork, delay, ret) +#define sys_port_trace_k_work_flush_delayable_enter(dwork, sync) \ + sys_trace_k_work_flush_delayable_enter(dwork, sync) +#define sys_port_trace_k_work_flush_delayable_exit(dwork, sync, ret) \ + sys_trace_k_work_flush_delayable_exit(dwork, sync, ret) +#define sys_port_trace_k_work_cancel_delayable_enter(dwork) \ + sys_trace_k_work_cancel_delayable_enter(dwork) +#define sys_port_trace_k_work_cancel_delayable_exit(dwork, ret) \ + sys_trace_k_work_cancel_delayable_exit(dwork, ret) +#define sys_port_trace_k_work_cancel_delayable_sync_enter(dwork, sync) \ + sys_trace_k_work_cancel_delayable_sync_enter(dwork, sync) +#define sys_port_trace_k_work_cancel_delayable_sync_exit(dwork, sync, ret) \ + sys_trace_k_work_cancel_delayable_sync_exit(dwork, sync, ret) + +#define sys_port_trace_k_work_poll_init_enter(work) sys_trace_k_work_poll_init_enter(work) +#define sys_port_trace_k_work_poll_init_exit(work) sys_trace_k_work_poll_init_exit(work) +#define sys_port_trace_k_work_poll_submit_to_queue_enter(work_q, work, timeout) \ + sys_trace_k_work_poll_submit_to_queue_enter(work_q, work, timeout) +#define sys_port_trace_k_work_poll_submit_to_queue_blocking(work_q, work, timeout) \ + sys_trace_k_work_poll_submit_to_queue_blocking(work_q, work, timeout) +#define sys_port_trace_k_work_poll_submit_to_queue_exit(work_q, work, timeout, ret) \ + sys_trace_k_work_poll_submit_to_queue_exit(work_q, work, timeout, ret) +#define sys_port_trace_k_work_poll_submit_enter(work, timeout) \ + sys_trace_k_work_poll_submit_enter(work, timeout) +#define sys_port_trace_k_work_poll_submit_exit(work, timeout, ret) \ + sys_trace_k_work_poll_submit_exit(work, timeout, ret) +#define sys_port_trace_k_work_poll_cancel_enter(work) sys_trace_k_work_poll_cancel_enter(work) +#define sys_port_trace_k_work_poll_cancel_exit(work, ret) \ + sys_trace_k_work_poll_cancel_exit(work, ret) + +#define sys_port_trace_k_poll_api_event_init(event) sys_trace_k_poll_api_event_init(event) +#define sys_port_trace_k_poll_api_poll_enter(events) sys_trace_k_poll_api_poll_enter(events) +#define sys_port_trace_k_poll_api_poll_exit(events, ret) sys_trace_k_poll_api_poll_exit(events, ret) +#define sys_port_trace_k_poll_api_signal_init(signal) sys_trace_k_poll_api_signal_init(signal) +#define sys_port_trace_k_poll_api_signal_reset(signal) sys_trace_k_poll_api_signal_reset(signal) +#define sys_port_trace_k_poll_api_signal_check(signal) sys_trace_k_poll_api_signal_check(signal) +#define sys_port_trace_k_poll_api_signal_raise(signal, ret) \ + sys_trace_k_poll_api_signal_raise(signal, ret) + +#define sys_port_trace_k_sem_init(sem, ret) sys_trace_k_sem_init(sem, ret) + +#define sys_port_trace_k_sem_give_enter(sem) sys_trace_k_sem_give_enter(sem) +#define sys_port_trace_k_sem_give_exit(sem) sys_trace_k_sem_give_exit(sem) +#define sys_port_trace_k_sem_take_enter(sem, timeout) sys_trace_k_sem_take_enter(sem, timeout) +#define sys_port_trace_k_sem_take_blocking(sem, timeout) sys_trace_k_sem_take_blocking(sem, timeout) +#define sys_port_trace_k_sem_take_exit(sem, timeout, ret) \ sys_trace_k_sem_take_exit(sem, timeout, ret) #define sys_port_trace_k_sem_reset(sem) sys_trace_k_sem_reset(sem) -#define sys_port_trace_k_mutex_init(mutex, ret) \ - sys_trace_k_mutex_init(mutex, ret) -#define sys_port_trace_k_mutex_lock_enter(mutex, timeout) \ +#define sys_port_trace_k_mutex_init(mutex, ret) sys_trace_k_mutex_init(mutex, ret) +#define sys_port_trace_k_mutex_lock_enter(mutex, timeout) \ sys_trace_k_mutex_lock_enter(mutex, timeout) -#define sys_port_trace_k_mutex_lock_blocking(mutex, timeout) \ +#define sys_port_trace_k_mutex_lock_blocking(mutex, timeout) \ sys_trace_k_mutex_lock_blocking(mutex, timeout) -#define sys_port_trace_k_mutex_lock_exit(mutex, timeout, ret) \ +#define sys_port_trace_k_mutex_lock_exit(mutex, timeout, ret) \ sys_trace_k_mutex_lock_exit(mutex, timeout, ret) -#define sys_port_trace_k_mutex_unlock_enter(mutex) \ - sys_trace_k_mutex_unlock_enter(mutex) -#define sys_port_trace_k_mutex_unlock_exit(mutex, ret) \ - sys_trace_k_mutex_unlock_exit(mutex, ret) +#define sys_port_trace_k_mutex_unlock_enter(mutex) sys_trace_k_mutex_unlock_enter(mutex) +#define sys_port_trace_k_mutex_unlock_exit(mutex, ret) sys_trace_k_mutex_unlock_exit(mutex, ret) /* Timer */ -#define sys_port_trace_k_timer_init(timer) \ - sys_trace_k_timer_init(timer) -#define sys_port_trace_k_timer_start(timer, duration, period) \ +#define sys_port_trace_k_timer_init(timer) sys_trace_k_timer_init(timer) +#define sys_port_trace_k_timer_start(timer, duration, period) \ sys_trace_k_timer_start(timer, duration, period) -#define sys_port_trace_k_timer_stop(timer) \ - sys_trace_k_timer_stop(timer) -#define sys_port_trace_k_timer_status_sync_enter(timer) \ - sys_trace_k_timer_status_sync_enter(timer) -#define sys_port_trace_k_timer_status_sync_blocking(timer, timeout) \ +#define sys_port_trace_k_timer_stop(timer) sys_trace_k_timer_stop(timer) +#define sys_port_trace_k_timer_status_sync_enter(timer) sys_trace_k_timer_status_sync_enter(timer) +#define sys_port_trace_k_timer_status_sync_blocking(timer, timeout) \ sys_trace_k_timer_status_sync_blocking(timer, timeout) -#define sys_port_trace_k_timer_status_sync_exit(timer, result) \ +#define sys_port_trace_k_timer_status_sync_exit(timer, result) \ sys_trace_k_timer_status_sync_exit(timer, result) -#define sys_port_trace_k_condvar_init(condvar, ret) -#define sys_port_trace_k_condvar_signal_enter(condvar) -#define sys_port_trace_k_condvar_signal_blocking(condvar, timeout) -#define sys_port_trace_k_condvar_signal_exit(condvar, ret) -#define sys_port_trace_k_condvar_broadcast_enter(condvar) -#define sys_port_trace_k_condvar_broadcast_exit(condvar, ret) -#define sys_port_trace_k_condvar_wait_enter(condvar) -#define sys_port_trace_k_condvar_wait_exit(condvar, ret) +#define sys_port_trace_k_condvar_init(condvar, ret) sys_trace_k_condvar_init(condvar, ret) +#define sys_port_trace_k_condvar_signal_enter(condvar) sys_trace_k_condvar_signal_enter(condvar) +#define sys_port_trace_k_condvar_signal_blocking(condvar, timeout) \ + sys_trace_k_condvar_signal_blocking(condvar, timeout) +#define sys_port_trace_k_condvar_signal_exit(condvar, ret) \ + sys_trace_k_condvar_signal_exit(condvar, ret) +#define sys_port_trace_k_condvar_broadcast_enter(condvar) \ + sys_trace_k_condvar_broadcast_enter(condvar) +#define sys_port_trace_k_condvar_broadcast_exit(condvar, ret) \ + sys_trace_k_condvar_broadcast_exit(condvar, ret) +#define sys_port_trace_k_condvar_wait_enter(condvar, timeout) \ + sys_trace_k_condvar_wait_enter(condvar, timeout) +#define sys_port_trace_k_condvar_wait_exit(condvar, timeout, ret) \ + sys_trace_k_condvar_wait_exit(condvar, timeout, ret) #define sys_port_trace_k_queue_init(queue) #define sys_port_trace_k_queue_cancel_wait(queue) @@ -259,35 +283,48 @@ extern "C" { #define sys_port_trace_k_stack_pop_blocking(stack, timeout) #define sys_port_trace_k_stack_pop_exit(stack, timeout, ret) -#define sys_port_trace_k_msgq_init(msgq) -#define sys_port_trace_k_msgq_alloc_init_enter(msgq) -#define sys_port_trace_k_msgq_alloc_init_exit(msgq, ret) -#define sys_port_trace_k_msgq_cleanup_enter(msgq) -#define sys_port_trace_k_msgq_cleanup_exit(msgq, ret) -#define sys_port_trace_k_msgq_put_enter(msgq, timeout) -#define sys_port_trace_k_msgq_put_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_put_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_put_front_enter(msgq, timeout) -#define sys_port_trace_k_msgq_put_front_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_put_front_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_get_enter(msgq, timeout) -#define sys_port_trace_k_msgq_get_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_get_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_peek(msgq, ret) -#define sys_port_trace_k_msgq_purge(msgq) - -#define sys_port_trace_k_mbox_init(mbox) -#define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) -#define sys_port_trace_k_mbox_message_put_blocking(mbox, timeout) -#define sys_port_trace_k_mbox_message_put_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_put_enter(mbox, timeout) -#define sys_port_trace_k_mbox_put_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_async_put_enter(mbox, sem) -#define sys_port_trace_k_mbox_async_put_exit(mbox, sem) -#define sys_port_trace_k_mbox_get_enter(mbox, timeout) -#define sys_port_trace_k_mbox_get_blocking(mbox, timeout) -#define sys_port_trace_k_mbox_get_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_data_get(rx_msg) +#define sys_port_trace_k_msgq_init(msgq) sys_trace_k_msgq_init(msgq) +#define sys_port_trace_k_msgq_alloc_init_enter(msgq) sys_trace_k_msgq_alloc_init_enter(msgq) +#define sys_port_trace_k_msgq_alloc_init_exit(msgq, ret) sys_trace_k_msgq_alloc_init_exit(msgq, ret) +#define sys_port_trace_k_msgq_cleanup_enter(msgq) sys_trace_k_msgq_cleanup_enter(msgq) +#define sys_port_trace_k_msgq_cleanup_exit(msgq, ret) sys_trace_k_msgq_cleanup_exit(msgq, ret) +#define sys_port_trace_k_msgq_put_enter(msgq, timeout) sys_trace_k_msgq_put_enter(msgq, timeout) +#define sys_port_trace_k_msgq_put_blocking(msgq, timeout) \ + sys_trace_k_msgq_put_blocking(msgq, timeout) +#define sys_port_trace_k_msgq_put_exit(msgq, timeout, ret) \ + sys_trace_k_msgq_put_exit(msgq, timeout, ret) +#define sys_port_trace_k_msgq_put_front_enter(msgq, timeout) \ + sys_trace_k_msgq_put_front_enter(msgq, timeout) +#define sys_port_trace_k_msgq_put_front_blocking(msgq, timeout) \ + sys_trace_k_msgq_put_front_blocking(msgq, timeout) +#define sys_port_trace_k_msgq_put_front_exit(msgq, timeout, ret) \ + sys_trace_k_msgq_put_front_exit(msgq, timeout, ret) +#define sys_port_trace_k_msgq_get_enter(msgq, timeout) sys_trace_k_msgq_get_enter(msgq, timeout) +#define sys_port_trace_k_msgq_get_blocking(msgq, timeout) \ + sys_trace_k_msgq_get_blocking(msgq, timeout) +#define sys_port_trace_k_msgq_get_exit(msgq, timeout, ret) \ + sys_trace_k_msgq_get_exit(msgq, timeout, ret) +#define sys_port_trace_k_msgq_peek(msgq, ret) sys_trace_k_msgq_peek(msgq, ret) +#define sys_port_trace_k_msgq_purge(msgq) sys_trace_k_msgq_purge(msgq) + +#define sys_port_trace_k_mbox_init(mbox) sys_trace_k_mbox_init(mbox) +#define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) \ + sys_trace_k_mbox_message_put_enter(mbox, timeout) +#define sys_port_trace_k_mbox_message_put_blocking(mbox, timeout) \ + sys_trace_k_mbox_message_put_blocking(mbox, timeout) +#define sys_port_trace_k_mbox_message_put_exit(mbox, timeout, ret) \ + sys_trace_k_mbox_message_put_exit(mbox, timeout, ret) +#define sys_port_trace_k_mbox_put_enter(mbox, timeout) sys_trace_k_mbox_put_enter(mbox, timeout) +#define sys_port_trace_k_mbox_put_exit(mbox, timeout, ret) \ + sys_trace_k_mbox_put_exit(mbox, timeout, ret) +#define sys_port_trace_k_mbox_async_put_enter(mbox, sem) sys_trace_k_mbox_async_put_enter(mbox, sem) +#define sys_port_trace_k_mbox_async_put_exit(mbox, sem) sys_trace_k_mbox_async_put_exit(mbox, sem) +#define sys_port_trace_k_mbox_get_enter(mbox, timeout) sys_trace_k_mbox_get_enter(mbox, timeout) +#define sys_port_trace_k_mbox_get_blocking(mbox, timeout) \ + sys_trace_k_mbox_get_blocking(mbox, timeout) +#define sys_port_trace_k_mbox_get_exit(mbox, timeout, ret) \ + sys_trace_k_mbox_get_exit(mbox, timeout, ret) +#define sys_port_trace_k_mbox_data_get(rx_msg) sys_trace_k_mbox_data_get(rx_msg) #define sys_port_trace_k_pipe_init(pipe, buffer, size) #define sys_port_trace_k_pipe_reset_enter(pipe) @@ -338,25 +375,32 @@ extern "C" { #define sys_port_trace_k_heap_sys_k_realloc_enter(heap, ptr) #define sys_port_trace_k_heap_sys_k_realloc_exit(heap, ptr, ret) -#define sys_port_trace_k_mem_slab_init(slab, rc) -#define sys_port_trace_k_mem_slab_alloc_enter(slab, timeout) -#define sys_port_trace_k_mem_slab_alloc_blocking(slab, timeout) -#define sys_port_trace_k_mem_slab_alloc_exit(slab, timeout, ret) -#define sys_port_trace_k_mem_slab_free_enter(slab) -#define sys_port_trace_k_mem_slab_free_exit(slab) - -#define sys_port_trace_k_event_init(event) -#define sys_port_trace_k_event_post_enter(event, events, events_mask) -#define sys_port_trace_k_event_post_exit(event, events, events_mask) -#define sys_port_trace_k_event_wait_enter(event, events, options, timeout) -#define sys_port_trace_k_event_wait_blocking(event, events, options, timeout) -#define sys_port_trace_k_event_wait_exit(event, events, ret) +#define sys_port_trace_k_mem_slab_init(slab, rc) sys_trace_k_mem_slab_init(slab, rc) +#define sys_port_trace_k_mem_slab_alloc_enter(slab, timeout) \ + sys_trace_k_mem_slab_alloc_enter(slab, timeout) +#define sys_port_trace_k_mem_slab_alloc_blocking(slab, timeout) \ + sys_trace_k_mem_slab_alloc_blocking(slab, timeout) +#define sys_port_trace_k_mem_slab_alloc_exit(slab, timeout, ret) \ + sys_trace_k_mem_slab_alloc_exit(slab, timeout, ret) +#define sys_port_trace_k_mem_slab_free_enter(slab) sys_trace_k_mem_slab_free_enter(slab) +#define sys_port_trace_k_mem_slab_free_exit(slab) sys_trace_k_mem_slab_free_exit(slab) + +#define sys_port_trace_k_event_init(event) sys_trace_k_event_init(event) +#define sys_port_trace_k_event_post_enter(event, events, events_mask) \ + sys_trace_k_event_post_enter(event, events, events_mask) +#define sys_port_trace_k_event_post_exit(event, events, events_mask) \ + sys_trace_k_event_post_exit(event, events, events_mask) +#define sys_port_trace_k_event_wait_enter(event, events, options, timeout) \ + sys_trace_k_event_wait_enter(event, events, options, timeout) +#define sys_port_trace_k_event_wait_blocking(event, events, options, timeout) \ + sys_trace_k_event_wait_blocking(event, events, options, timeout) +#define sys_port_trace_k_event_wait_exit(event, events, ret) \ + sys_trace_k_event_wait_exit(event, events, ret) #define sys_port_trace_k_thread_abort_exit(thread) #define sys_port_trace_k_thread_abort_enter(thread) #define sys_port_trace_k_thread_resume_exit(thread) - #define sys_port_trace_pm_system_suspend_enter(ticks) #define sys_port_trace_pm_system_suspend_exit(ticks, state) @@ -388,23 +432,16 @@ void sys_trace_k_thread_sched_ready(struct k_thread *thread); void sys_trace_k_thread_sched_resume(struct k_thread *thread); void sys_trace_k_thread_sched_suspend(struct k_thread *thread); -void sys_trace_k_thread_foreach_enter(k_thread_user_cb_t user_cb, - void *user_data); -void sys_trace_k_thread_foreach_exit(k_thread_user_cb_t user_cb, - void *user_data); -void sys_trace_k_thread_foreach_unlocked_enter(k_thread_user_cb_t user_cb, - void *user_data); -void sys_trace_k_thread_foreach_unlocked_exit(k_thread_user_cb_t user_cb, - void *user_data); -void sys_trace_k_thread_create(struct k_thread *new_thread, size_t stack_size, - int prio); +void sys_trace_k_thread_foreach_enter(void); +void sys_trace_k_thread_foreach_exit(void); +void sys_trace_k_thread_foreach_unlocked_enter(void); +void sys_trace_k_thread_foreach_unlocked_exit(void); +void sys_trace_k_thread_create(struct k_thread *new_thread, size_t stack_size, int prio); void sys_trace_k_thread_user_mode_enter(void); -void sys_trace_k_thread_heap_assign(struct k_thread *thread, - struct k_heap *heap); -void sys_trace_k_thread_join_blocking(struct k_thread *thread, - k_timeout_t timeout); -void sys_trace_k_thread_join_exit(struct k_thread *thread, k_timeout_t timeout, - int ret); +void sys_trace_k_thread_heap_assign(struct k_thread *thread, struct k_heap *heap); +void sys_trace_k_thread_join_blocking(struct k_thread *thread, k_timeout_t timeout); +void sys_trace_k_thread_join_enter(struct k_thread *thread, k_timeout_t timeout); +void sys_trace_k_thread_join_exit(struct k_thread *thread, k_timeout_t timeout, int ret); void sys_trace_k_thread_sleep_enter(k_timeout_t timeout); void sys_trace_k_thread_sleep_exit(k_timeout_t timeout, int ret); void sys_trace_k_thread_msleep_enter(int32_t ms); @@ -429,8 +466,131 @@ void sys_trace_k_thread_ready(struct k_thread *thread); void sys_trace_k_thread_pend(struct k_thread *thread); void sys_trace_k_thread_info(struct k_thread *thread); -/* Semaphore */ +/* Thread Extended Functions */ +void sys_trace_k_thread_suspend_exit(struct k_thread *thread); +void sys_trace_k_thread_sched_wakeup(struct k_thread *thread); +void sys_trace_k_thread_sched_abort(struct k_thread *thread); +void sys_trace_k_thread_sched_priority_set(struct k_thread *thread, int prio); +void sys_trace_k_thread_sched_ready(struct k_thread *thread); +void sys_trace_k_thread_sched_pend(struct k_thread *thread); +void sys_trace_k_thread_sched_resume(struct k_thread *thread); +void sys_trace_k_thread_sched_suspend(struct k_thread *thread); +/* Memory Slabs */ + +void sys_trace_k_mem_slab_init(struct k_mem_slab *slab, int ret); +void sys_trace_k_mem_slab_alloc_enter(struct k_mem_slab *slab, k_timeout_t timeout); +void sys_trace_k_mem_slab_alloc_blocking(struct k_mem_slab *slab, k_timeout_t timeout); +void sys_trace_k_mem_slab_alloc_exit(struct k_mem_slab *slab, k_timeout_t timeout, int ret); +void sys_trace_k_mem_slab_free_enter(struct k_mem_slab *slab); +void sys_trace_k_mem_slab_free_exit(struct k_mem_slab *slab); + +/* Message Queues */ +void sys_trace_k_msgq_init(struct k_msgq *msgq); +void sys_trace_k_msgq_alloc_init_enter(struct k_msgq *msgq); +void sys_trace_k_msgq_alloc_init_exit(struct k_msgq *msgq, int ret); +void sys_trace_k_msgq_cleanup_enter(struct k_msgq *msgq); +void sys_trace_k_msgq_cleanup_exit(struct k_msgq *msgq, int ret); +void sys_trace_k_msgq_put_enter(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_put_blocking(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_put_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret); +void sys_trace_k_msgq_put_front_enter(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_put_front_blocking(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_put_front_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret); +void sys_trace_k_msgq_get_enter(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_get_blocking(struct k_msgq *msgq, k_timeout_t timeout); +void sys_trace_k_msgq_get_exit(struct k_msgq *msgq, k_timeout_t timeout, int ret); +void sys_trace_k_msgq_peek(struct k_msgq *msgq, int ret); +void sys_trace_k_msgq_purge(struct k_msgq *msgq); + +/* Condition Variables */ +void sys_trace_k_condvar_init(struct k_condvar *condvar, int ret); +void sys_trace_k_condvar_signal_enter(struct k_condvar *condvar); +void sys_trace_k_condvar_signal_blocking(struct k_condvar *condvar, k_timeout_t timeout); +void sys_trace_k_condvar_signal_exit(struct k_condvar *condvar, int ret); +void sys_trace_k_condvar_broadcast_enter(struct k_condvar *condvar); +void sys_trace_k_condvar_broadcast_exit(struct k_condvar *condvar, int ret); +void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, k_timeout_t timeout); +void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, k_timeout_t timeout, int ret); + +/* Work Queue */ +void sys_trace_k_work_init(struct k_work *work); +void sys_trace_k_work_submit_to_queue_enter(struct k_work_q *queue, struct k_work *work); +void sys_trace_k_work_submit_to_queue_exit(struct k_work_q *queue, struct k_work *work, int ret); +void sys_trace_k_work_submit_enter(struct k_work *work); +void sys_trace_k_work_submit_exit(struct k_work *work, int ret); +void sys_trace_k_work_flush_enter(struct k_work *work); +void sys_trace_k_work_flush_blocking(struct k_work *work, k_timeout_t timeout); +void sys_trace_k_work_flush_exit(struct k_work *work, int ret); +void sys_trace_k_work_cancel_enter(struct k_work *work); +void sys_trace_k_work_cancel_exit(struct k_work *work, int ret); +void sys_trace_k_work_cancel_sync_enter(struct k_work *work, struct k_work_sync *sync); +void sys_trace_k_work_cancel_sync_blocking(struct k_work *work, struct k_work_sync *sync); +void sys_trace_k_work_cancel_sync_exit(struct k_work *work, struct k_work_sync *sync, int ret); + +/* Work Queue Management */ +void sys_trace_k_work_queue_init(struct k_work_q *queue); +void sys_trace_k_work_queue_start_enter(struct k_work_q *queue); +void sys_trace_k_work_queue_start_exit(struct k_work_q *queue); +void sys_trace_k_work_queue_stop_enter(struct k_work_q *queue, k_timeout_t timeout); +void sys_trace_k_work_queue_stop_blocking(struct k_work_q *queue, k_timeout_t timeout); +void sys_trace_k_work_queue_stop_exit(struct k_work_q *queue, k_timeout_t timeout, int ret); +void sys_trace_k_work_queue_drain_enter(struct k_work_q *queue); +void sys_trace_k_work_queue_drain_exit(struct k_work_q *queue, int ret); +void sys_trace_k_work_queue_unplug_enter(struct k_work_q *queue); +void sys_trace_k_work_queue_unplug_exit(struct k_work_q *queue, int ret); + +/* Delayable Work */ +void sys_trace_k_work_delayable_init(struct k_work_delayable *dwork); +void sys_trace_k_work_schedule_for_queue_enter(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay); +void sys_trace_k_work_schedule_for_queue_exit(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay, + int ret); +void sys_trace_k_work_schedule_enter(struct k_work_delayable *dwork, k_timeout_t delay); +void sys_trace_k_work_schedule_exit(struct k_work_delayable *dwork, k_timeout_t delay, int ret); +void sys_trace_k_work_reschedule_for_queue_enter(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay); +void sys_trace_k_work_reschedule_for_queue_exit(struct k_work_q *queue, + struct k_work_delayable *dwork, k_timeout_t delay, + int ret); +void sys_trace_k_work_reschedule_enter(struct k_work_delayable *dwork, k_timeout_t delay); +void sys_trace_k_work_reschedule_exit(struct k_work_delayable *dwork, k_timeout_t delay, int ret); +void sys_trace_k_work_flush_delayable_enter(struct k_work_delayable *dwork, + struct k_work_sync *sync); +void sys_trace_k_work_flush_delayable_exit(struct k_work_delayable *dwork, struct k_work_sync *sync, + int ret); +void sys_trace_k_work_cancel_delayable_enter(struct k_work_delayable *dwork); +void sys_trace_k_work_cancel_delayable_exit(struct k_work_delayable *dwork, int ret); +void sys_trace_k_work_cancel_delayable_sync_enter(struct k_work_delayable *dwork, + struct k_work_sync *sync); +void sys_trace_k_work_cancel_delayable_sync_exit(struct k_work_delayable *dwork, + struct k_work_sync *sync, int ret); + +/* Poll Work */ +void sys_trace_k_work_poll_init_enter(struct k_work_poll *work); +void sys_trace_k_work_poll_init_exit(struct k_work_poll *work); +void sys_trace_k_work_poll_submit_to_queue_enter(struct k_work_q *work_q, struct k_work_poll *work, + k_timeout_t timeout); +void sys_trace_k_work_poll_submit_to_queue_blocking(struct k_work_q *work_q, + struct k_work_poll *work, k_timeout_t timeout); +void sys_trace_k_work_poll_submit_to_queue_exit(struct k_work_q *work_q, struct k_work_poll *work, + k_timeout_t timeout, int ret); +void sys_trace_k_work_poll_submit_enter(struct k_work_poll *work, k_timeout_t timeout); +void sys_trace_k_work_poll_submit_exit(struct k_work_poll *work, k_timeout_t timeout, int ret); +void sys_trace_k_work_poll_cancel_enter(struct k_work_poll *work); +void sys_trace_k_work_poll_cancel_exit(struct k_work_poll *work, int ret); + +/* Poll API */ +void sys_trace_k_poll_api_event_init(struct k_poll_event *event); +void sys_trace_k_poll_api_poll_enter(struct k_poll_event *events); +void sys_trace_k_poll_api_poll_exit(struct k_poll_event *events, int ret); +void sys_trace_k_poll_api_signal_init(struct k_poll_signal *signal); +void sys_trace_k_poll_api_signal_reset(struct k_poll_signal *signal); +void sys_trace_k_poll_api_signal_check(struct k_poll_signal *signal); +void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *signal, int ret); + +/* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret); void sys_trace_k_sem_give_enter(struct k_sem *sem); @@ -444,99 +604,100 @@ void sys_trace_k_sem_reset(struct k_sem *sem); /* Mutex */ void sys_trace_k_mutex_init(struct k_mutex *mutex, int ret); void sys_trace_k_mutex_lock_enter(struct k_mutex *mutex, k_timeout_t timeout); -void sys_trace_k_mutex_lock_blocking(struct k_mutex *mutex, - k_timeout_t timeout); -void sys_trace_k_mutex_lock_exit(struct k_mutex *mutex, k_timeout_t timeout, - int ret); +void sys_trace_k_mutex_lock_blocking(struct k_mutex *mutex, k_timeout_t timeout); +void sys_trace_k_mutex_lock_exit(struct k_mutex *mutex, k_timeout_t timeout, int ret); void sys_trace_k_mutex_unlock_enter(struct k_mutex *mutex); void sys_trace_k_mutex_unlock_exit(struct k_mutex *mutex, int ret); /* Timer */ void sys_trace_k_timer_init(struct k_timer *timer); -void sys_trace_k_timer_start(struct k_timer *timer, k_timeout_t duration, - k_timeout_t period); +void sys_trace_k_timer_start(struct k_timer *timer, k_timeout_t duration, k_timeout_t period); void sys_trace_k_timer_stop(struct k_timer *timer); void sys_trace_k_timer_status_sync_blocking(struct k_timer *timer, k_timeout_t timeout); void sys_trace_k_timer_status_sync_enter(struct k_timer *timer); void sys_trace_k_timer_status_sync_exit(struct k_timer *timer, uint32_t result); +/* Mailbox */ +void sys_trace_k_mbox_init(struct k_mbox *mbox); +void sys_trace_k_mbox_message_put_enter(struct k_mbox *mbox, k_timeout_t timeout); +void sys_trace_k_mbox_message_put_blocking(struct k_mbox *mbox, k_timeout_t timeout); +void sys_trace_k_mbox_message_put_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret); +void sys_trace_k_mbox_put_enter(struct k_mbox *mbox, k_timeout_t timeout); +void sys_trace_k_mbox_put_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret); +void sys_trace_k_mbox_async_put_enter(struct k_mbox *mbox, struct k_sem *sem); +void sys_trace_k_mbox_async_put_exit(struct k_mbox *mbox, struct k_sem *sem); +void sys_trace_k_mbox_get_enter(struct k_mbox *mbox, k_timeout_t timeout); +void sys_trace_k_mbox_get_blocking(struct k_mbox *mbox, k_timeout_t timeout); +void sys_trace_k_mbox_get_exit(struct k_mbox *mbox, k_timeout_t timeout, int ret); +void sys_trace_k_mbox_data_get(struct k_mbox_msg *rx_msg); + +/* Event */ void sys_trace_k_event_init(struct k_event *event); +void sys_trace_k_event_post_enter(struct k_event *event, uint32_t events, uint32_t events_mask); +void sys_trace_k_event_post_exit(struct k_event *event, uint32_t events, uint32_t events_mask); +void sys_trace_k_event_wait_enter(struct k_event *event, uint32_t events, uint32_t options, + k_timeout_t timeout); +void sys_trace_k_event_wait_blocking(struct k_event *event, uint32_t events, uint32_t options, + k_timeout_t timeout); +void sys_trace_k_event_wait_exit(struct k_event *event, uint32_t events, int ret); - -#define sys_port_trace_socket_init(sock, family, type, proto) \ +#define sys_port_trace_socket_init(sock, family, type, proto) \ sys_trace_socket_init(sock, family, type, proto) -#define sys_port_trace_socket_close_enter(sock) \ - sys_trace_socket_close_enter(sock) -#define sys_port_trace_socket_close_exit(sock, ret) \ - sys_trace_socket_close_exit(sock, ret) -#define sys_port_trace_socket_shutdown_enter(sock, how) \ - sys_trace_socket_shutdown_enter(sock, how) -#define sys_port_trace_socket_shutdown_exit(sock, ret) \ - sys_trace_socket_shutdown_exit(sock, ret) -#define sys_port_trace_socket_bind_enter(sock, addr, addrlen) \ +#define sys_port_trace_socket_close_enter(sock) sys_trace_socket_close_enter(sock) +#define sys_port_trace_socket_close_exit(sock, ret) sys_trace_socket_close_exit(sock, ret) +#define sys_port_trace_socket_shutdown_enter(sock, how) sys_trace_socket_shutdown_enter(sock, how) +#define sys_port_trace_socket_shutdown_exit(sock, ret) sys_trace_socket_shutdown_exit(sock, ret) +#define sys_port_trace_socket_bind_enter(sock, addr, addrlen) \ sys_trace_socket_bind_enter(sock, addr, addrlen) -#define sys_port_trace_socket_bind_exit(sock, ret) \ - sys_trace_socket_bind_exit(sock, ret) -#define sys_port_trace_socket_connect_enter(sock, addr, addrlen) \ +#define sys_port_trace_socket_bind_exit(sock, ret) sys_trace_socket_bind_exit(sock, ret) +#define sys_port_trace_socket_connect_enter(sock, addr, addrlen) \ sys_trace_socket_connect_enter(sock, addr, addrlen) -#define sys_port_trace_socket_connect_exit(sock, ret) \ - sys_trace_socket_connect_exit(sock, ret) -#define sys_port_trace_socket_listen_enter(sock, backlog) \ +#define sys_port_trace_socket_connect_exit(sock, ret) sys_trace_socket_connect_exit(sock, ret) +#define sys_port_trace_socket_listen_enter(sock, backlog) \ sys_trace_socket_listen_enter(sock, backlog) -#define sys_port_trace_socket_listen_exit(sock, ret) \ - sys_trace_socket_listen_exit(sock, ret) -#define sys_port_trace_socket_accept_enter(sock) \ - sys_trace_socket_accept_enter(sock) -#define sys_port_trace_socket_accept_exit(sock, addr, addrlen, ret) \ +#define sys_port_trace_socket_listen_exit(sock, ret) sys_trace_socket_listen_exit(sock, ret) +#define sys_port_trace_socket_accept_enter(sock) sys_trace_socket_accept_enter(sock) +#define sys_port_trace_socket_accept_exit(sock, addr, addrlen, ret) \ sys_trace_socket_accept_exit(sock, addr, addrlen, ret) -#define sys_port_trace_socket_sendto_enter(sock, len, flags, dest_addr, addrlen) \ +#define sys_port_trace_socket_sendto_enter(sock, len, flags, dest_addr, addrlen) \ sys_trace_socket_sendto_enter(sock, len, flags, dest_addr, addrlen) -#define sys_port_trace_socket_sendto_exit(sock, ret) \ - sys_trace_socket_sendto_exit(sock, ret) -#define sys_port_trace_socket_sendmsg_enter(sock, msg, flags) \ +#define sys_port_trace_socket_sendto_exit(sock, ret) sys_trace_socket_sendto_exit(sock, ret) +#define sys_port_trace_socket_sendmsg_enter(sock, msg, flags) \ sys_trace_socket_sendmsg_enter(sock, msg, flags) -#define sys_port_trace_socket_sendmsg_exit(sock, ret) \ - sys_trace_socket_sendmsg_exit(sock, ret) -#define sys_port_trace_socket_recvfrom_enter(sock, max_len, flags, addr, addrlen) \ +#define sys_port_trace_socket_sendmsg_exit(sock, ret) sys_trace_socket_sendmsg_exit(sock, ret) +#define sys_port_trace_socket_recvfrom_enter(sock, max_len, flags, addr, addrlen) \ sys_trace_socket_recvfrom_enter(sock, max_len, flags, addr, addrlen) -#define sys_port_trace_socket_recvfrom_exit(sock, src_addr, addrlen, ret) \ +#define sys_port_trace_socket_recvfrom_exit(sock, src_addr, addrlen, ret) \ sys_trace_socket_recvfrom_exit(sock, src_addr, addrlen, ret) -#define sys_port_trace_socket_recvmsg_enter(sock, msg, flags) \ +#define sys_port_trace_socket_recvmsg_enter(sock, msg, flags) \ sys_trace_socket_recvmsg_enter(sock, msg, flags) -#define sys_port_trace_socket_recvmsg_exit(sock, msg, ret) \ +#define sys_port_trace_socket_recvmsg_exit(sock, msg, ret) \ sys_trace_socket_recvmsg_exit(sock, msg, ret) -#define sys_port_trace_socket_fcntl_enter(sock, cmd, flags) \ +#define sys_port_trace_socket_fcntl_enter(sock, cmd, flags) \ sys_trace_socket_fcntl_enter(sock, cmd, flags) -#define sys_port_trace_socket_fcntl_exit(sock, ret) \ - sys_trace_socket_fcntl_exit(sock, ret) -#define sys_port_trace_socket_ioctl_enter(sock, req) \ - sys_trace_socket_ioctl_enter(sock, req) -#define sys_port_trace_socket_ioctl_exit(sock, ret) \ - sys_trace_socket_ioctl_exit(sock, ret) -#define sys_port_trace_socket_poll_enter(fds, nfds, timeout) \ +#define sys_port_trace_socket_fcntl_exit(sock, ret) sys_trace_socket_fcntl_exit(sock, ret) +#define sys_port_trace_socket_ioctl_enter(sock, req) sys_trace_socket_ioctl_enter(sock, req) +#define sys_port_trace_socket_ioctl_exit(sock, ret) sys_trace_socket_ioctl_exit(sock, ret) +#define sys_port_trace_socket_poll_enter(fds, nfds, timeout) \ sys_trace_socket_poll_enter(fds, nfds, timeout) -#define sys_port_trace_socket_poll_exit(fds, nfds, ret) \ - sys_trace_socket_poll_exit(fds, nfds, ret) -#define sys_port_trace_socket_getsockopt_enter(sock, level, optname) \ +#define sys_port_trace_socket_poll_exit(fds, nfds, ret) sys_trace_socket_poll_exit(fds, nfds, ret) +#define sys_port_trace_socket_getsockopt_enter(sock, level, optname) \ sys_trace_socket_getsockopt_enter(sock, level, optname) -#define sys_port_trace_socket_getsockopt_exit(sock, level, optname, optval, optlen, ret) \ +#define sys_port_trace_socket_getsockopt_exit(sock, level, optname, optval, optlen, ret) \ sys_trace_socket_getsockopt_exit(sock, level, optname, optval, optlen, ret) -#define sys_port_trace_socket_setsockopt_enter(sock, level, optname, optval, optlen) \ +#define sys_port_trace_socket_setsockopt_enter(sock, level, optname, optval, optlen) \ sys_trace_socket_setsockopt_enter(sock, level, optname, optval, optlen) -#define sys_port_trace_socket_setsockopt_exit(sock, ret) \ - sys_trace_socket_setsockopt_exit(sock, ret) -#define sys_port_trace_socket_getpeername_enter(sock) \ - sys_trace_socket_getpeername_enter(sock) -#define sys_port_trace_socket_getpeername_exit(sock, addr, addrlen, ret) \ +#define sys_port_trace_socket_setsockopt_exit(sock, ret) sys_trace_socket_setsockopt_exit(sock, ret) +#define sys_port_trace_socket_getpeername_enter(sock) sys_trace_socket_getpeername_enter(sock) +#define sys_port_trace_socket_getpeername_exit(sock, addr, addrlen, ret) \ sys_trace_socket_getpeername_exit(sock, addr, addrlen, ret) -#define sys_port_trace_socket_getsockname_enter(sock) \ - sys_trace_socket_getsockname_enter(sock) -#define sys_port_trace_socket_getsockname_exit(sock, addr, addrlen, ret) \ +#define sys_port_trace_socket_getsockname_enter(sock) sys_trace_socket_getsockname_enter(sock) +#define sys_port_trace_socket_getsockname_exit(sock, addr, addrlen, ret) \ sys_trace_socket_getsockname_exit(sock, addr, addrlen, ret) -#define sys_port_trace_socket_socketpair_enter(family, type, proto, sv) \ +#define sys_port_trace_socket_socketpair_enter(family, type, proto, sv) \ sys_trace_socket_socketpair_enter(family, type, proto, sv) -#define sys_port_trace_socket_socketpair_exit(sockA, sockB, ret) \ +#define sys_port_trace_socket_socketpair_exit(sockA, sockB, ret) \ sys_trace_socket_socketpair_exit(sockA, sockB, ret) /* Do not try to include network headers as it just leads to inclusion @@ -578,8 +739,8 @@ void sys_trace_socket_ioctl_exit(int sock, int ret); void sys_trace_socket_poll_enter(const struct zvfs_pollfd *fds, int nfds, int timeout); void sys_trace_socket_poll_exit(const struct zvfs_pollfd *fds, int nfds, int ret); void sys_trace_socket_getsockopt_enter(int sock, int level, int optname); -void sys_trace_socket_getsockopt_exit(int sock, int level, int optname, void *optval, - size_t optlen, int ret); +void sys_trace_socket_getsockopt_exit(int sock, int level, int optname, void *optval, size_t optlen, + int ret); void sys_trace_socket_setsockopt_enter(int sock, int level, int optname, const void *optval, size_t optlen); void sys_trace_socket_setsockopt_exit(int sock, int ret); @@ -592,18 +753,13 @@ void sys_trace_socket_getsockname_exit(int sock, const struct sockaddr *addr, void sys_trace_socket_socketpair_enter(int family, int type, int proto, int *sv); void sys_trace_socket_socketpair_exit(int sock_A, int sock_B, int ret); -#define sys_port_trace_net_recv_data_enter(iface, pkt) \ - sys_trace_net_recv_data_enter(iface, pkt) -#define sys_port_trace_net_recv_data_exit(iface, pkt, ret) \ +#define sys_port_trace_net_recv_data_enter(iface, pkt) sys_trace_net_recv_data_enter(iface, pkt) +#define sys_port_trace_net_recv_data_exit(iface, pkt, ret) \ sys_trace_net_recv_data_exit(iface, pkt, ret) -#define sys_port_trace_net_send_data_enter(pkt) \ - sys_trace_net_send_data_enter(pkt) -#define sys_port_trace_net_send_data_exit(pkt, ret) \ - sys_trace_net_send_data_exit(pkt, ret) -#define sys_port_trace_net_rx_time(pkt, end_time) \ - sys_trace_net_rx_time(pkt, end_time) -#define sys_port_trace_net_tx_time(pkt, end_time) \ - sys_trace_net_tx_time(pkt, end_time) +#define sys_port_trace_net_send_data_enter(pkt) sys_trace_net_send_data_enter(pkt) +#define sys_port_trace_net_send_data_exit(pkt, ret) sys_trace_net_send_data_exit(pkt, ret) +#define sys_port_trace_net_rx_time(pkt, end_time) sys_trace_net_rx_time(pkt, end_time) +#define sys_port_trace_net_tx_time(pkt, end_time) sys_trace_net_tx_time(pkt, end_time) struct net_if; struct net_pkt; diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 00bc7c364ab39..ff18e5ef20626 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -274,6 +274,7 @@ event { id = 0x2D; fields := struct { uint32_t id; + int32_t ret; }; }; @@ -1065,3 +1066,1129 @@ event { uint32_t cb; }; }; + + + +/* Memory Slabs */ +event { + name = mem_slab_init; + id = 0x81; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +event { + name = mem_slab_alloc_enter; + id = 0x82; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = mem_slab_alloc_blocking; + id = 0x83; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = mem_slab_alloc_exit; + id = 0x84; + fields := struct { + uint32_t id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = mem_slab_free_enter; + id = 0x85; + fields := struct { + uint32_t id; + }; +}; + +event { + name = mem_slab_free_exit; + id = 0x86; + fields := struct { + uint32_t id; + }; +}; + +/* Message Queues */ + +event { + name = msgq_init; + id = 0x87; + fields := struct { + uint32_t id; + }; +}; + +event { + name = msgq_alloc_init_enter; + id = 0x88; + fields := struct { + uint32_t id; + }; +}; + +event { + name = msgq_alloc_init_exit; + id = 0x89; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +event { + name = msgq_put_enter; + id = 0x8A; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = msgq_put_blocking; + id = 0x8B; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = msgq_put_exit; + id = 0x8C; + fields := struct { + uint32_t id; + uint32_t timeout; + int32_t ret; + }; +}; +event { + name = msgq_get_enter; + id = 0x8D; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; +event { + name = msgq_get_blocking; + id = 0x8E; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; +event { + name = msgq_get_exit; + id = 0x8F; + fields := struct { + uint32_t id; + uint32_t timeout; + int32_t ret; + }; +}; +event { + name = msgq_peek; + id = 0x90; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; +event { + name = msgq_purge; + id = 0x91; + fields := struct { + uint32_t id; + }; +}; + +event { + name = msgq_put_front_enter; + id = 0x92; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = msgq_put_front_blocking; + id = 0x94; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = msgq_put_front_exit; + id = 0x93; + fields := struct { + uint32_t id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = msgq_cleanup_enter; + id = 0x95; + fields := struct { + uint32_t id; + }; +}; + +event { + name = msgq_cleanup_exit; + id = 0x96; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +/* Condition Variables */ +event { + name = condvar_init; + id = 0x97; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +event { + name = condvar_signal_enter; + id = 0x98; + fields := struct { + uint32_t id; + }; +}; + +event { + name = condvar_signal_blocking; + id = 0x99; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = condvar_signal_exit; + id = 0x9A; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +event { + name = condvar_broadcast_enter; + id = 0x9B; + fields := struct { + uint32_t id; + }; +}; + +event { + name = condvar_broadcast_exit; + id = 0x9C; + fields := struct { + uint32_t id; + int32_t ret; + }; +}; + +event { + name = condvar_wait_enter; + id = 0x9D; + fields := struct { + uint32_t id; + uint32_t timeout; + }; +}; + +event { + name = condvar_wait_exit; + id = 0x9E; + fields := struct { + uint32_t id; + uint32_t timeout; + int32_t ret; + }; +}; + +/* Work Queue Events */ +event { + name = work_init; + id = 0x9F; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_submit_to_queue_enter; + id = 0xA0; + fields := struct { + uint32_t queue_id; + uint32_t work_id; + }; +}; + +event { + name = work_submit_to_queue_exit; + id = 0xA1; + fields := struct { + uint32_t queue_id; + uint32_t work_id; + int32_t ret; + }; +}; + +event { + name = work_submit_enter; + id = 0xA2; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_submit_exit; + id = 0xA3; + fields := struct { + uint32_t work_id; + int32_t ret; + }; +}; + +event { + name = work_flush_enter; + id = 0xA4; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_flush_blocking; + id = 0xA5; + fields := struct { + uint32_t work_id; + uint32_t timeout; + }; +}; + +event { + name = work_flush_exit; + id = 0xA6; + fields := struct { + uint32_t work_id; + int32_t ret; + }; +}; + +event { + name = work_cancel_enter; + id = 0xA7; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_cancel_exit; + id = 0xA8; + fields := struct { + uint32_t work_id; + int32_t ret; + }; +}; + +event { + name = work_cancel_sync_enter; + id = 0xA9; + fields := struct { + uint32_t work_id; + uint32_t sync_id; + }; +}; + +event { + name = work_cancel_sync_blocking; + id = 0xAA; + fields := struct { + uint32_t work_id; + uint32_t sync_id; + }; +}; + +event { + name = work_cancel_sync_exit; + id = 0xAB; + fields := struct { + uint32_t work_id; + uint32_t sync_id; + int32_t ret; + }; +}; + +/* Work Queue Management */ +event { + name = work_queue_init; + id = 0xAC; + fields := struct { + uint32_t queue_id; + }; +}; + +event { + name = work_queue_start_enter; + id = 0xAD; + fields := struct { + uint32_t queue_id; + }; +}; + +event { + name = work_queue_start_exit; + id = 0xAE; + fields := struct { + uint32_t queue_id; + }; +}; + +event { + name = work_queue_stop_enter; + id = 0xAF; + fields := struct { + uint32_t queue_id; + uint32_t timeout; + }; +}; + +event { + name = work_queue_stop_blocking; + id = 0xB0; + fields := struct { + uint32_t queue_id; + uint32_t timeout; + }; +}; + +event { + name = work_queue_stop_exit; + id = 0xB1; + fields := struct { + uint32_t queue_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = work_queue_drain_enter; + id = 0xB2; + fields := struct { + uint32_t queue_id; + }; +}; + +event { + name = work_queue_drain_exit; + id = 0xB3; + fields := struct { + uint32_t queue_id; + int32_t ret; + }; +}; + +event { + name = work_queue_unplug_enter; + id = 0xB4; + fields := struct { + uint32_t queue_id; + }; +}; + +event { + name = work_queue_unplug_exit; + id = 0xB5; + fields := struct { + uint32_t queue_id; + int32_t ret; + }; +}; + +/* Delayable Work */ +event { + name = work_delayable_init; + id = 0xB6; + fields := struct { + uint32_t dwork_id; + }; +}; + +event { + name = work_schedule_for_queue_enter; + id = 0xB7; + fields := struct { + uint32_t queue_id; + uint32_t dwork_id; + uint32_t delay; + }; +}; + +event { + name = work_schedule_for_queue_exit; + id = 0xB8; + fields := struct { + uint32_t queue_id; + uint32_t dwork_id; + uint32_t delay; + int32_t ret; + }; +}; + +event { + name = work_schedule_enter; + id = 0xB9; + fields := struct { + uint32_t dwork_id; + uint32_t delay; + }; +}; + +event { + name = work_schedule_exit; + id = 0xBA; + fields := struct { + uint32_t dwork_id; + uint32_t delay; + int32_t ret; + }; +}; + +event { + name = work_reschedule_for_queue_enter; + id = 0xBB; + fields := struct { + uint32_t queue_id; + uint32_t dwork_id; + uint32_t delay; + }; +}; + +event { + name = work_reschedule_for_queue_exit; + id = 0xBC; + fields := struct { + uint32_t queue_id; + uint32_t dwork_id; + uint32_t delay; + int32_t ret; + }; +}; + +event { + name = work_reschedule_enter; + id = 0xBD; + fields := struct { + uint32_t dwork_id; + uint32_t delay; + }; +}; + +event { + name = work_reschedule_exit; + id = 0xBE; + fields := struct { + uint32_t dwork_id; + uint32_t delay; + int32_t ret; + }; +}; + +event { + name = work_flush_delayable_enter; + id = 0xBF; + fields := struct { + uint32_t dwork_id; + uint32_t sync_id; + }; +}; + +event { + name = work_flush_delayable_exit; + id = 0xC0; + fields := struct { + uint32_t dwork_id; + uint32_t sync_id; + int32_t ret; + }; +}; + +event { + name = work_cancel_delayable_enter; + id = 0xC1; + fields := struct { + uint32_t dwork_id; + }; +}; + +event { + name = work_cancel_delayable_exit; + id = 0xC2; + fields := struct { + uint32_t dwork_id; + int32_t ret; + }; +}; + +event { + name = work_cancel_delayable_sync_enter; + id = 0xC3; + fields := struct { + uint32_t dwork_id; + uint32_t sync_id; + }; +}; + +event { + name = work_cancel_delayable_sync_exit; + id = 0xC4; + fields := struct { + uint32_t dwork_id; + uint32_t sync_id; + int32_t ret; + }; +}; + +/* Poll Work */ +event { + name = work_poll_init_enter; + id = 0xC5; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_poll_init_exit; + id = 0xC6; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_poll_submit_to_queue_enter; + id = 0xC7; + fields := struct { + uint32_t work_q_id; + uint32_t work_id; + uint32_t timeout; + }; +}; + +event { + name = work_poll_submit_to_queue_blocking; + id = 0xC8; + fields := struct { + uint32_t work_q_id; + uint32_t work_id; + uint32_t timeout; + }; +}; + +event { + name = work_poll_submit_to_queue_exit; + id = 0xC9; + fields := struct { + uint32_t work_q_id; + uint32_t work_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = work_poll_submit_enter; + id = 0xCA; + fields := struct { + uint32_t work_id; + uint32_t timeout; + }; +}; + +event { + name = work_poll_submit_exit; + id = 0xCB; + fields := struct { + uint32_t work_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = work_poll_cancel_enter; + id = 0xCC; + fields := struct { + uint32_t work_id; + }; +}; + +event { + name = work_poll_cancel_exit; + id = 0xCD; + fields := struct { + uint32_t work_id; + int32_t ret; + }; +}; + +/* Poll API */ +event { + name = poll_event_init; + id = 0xCE; + fields := struct { + uint32_t event_id; + }; +}; + +event { + name = poll_enter; + id = 0xCF; + fields := struct { + uint32_t events_id; + }; +}; + +event { + name = poll_exit; + id = 0xD0; + fields := struct { + uint32_t events_id; + int32_t ret; + }; +}; + +event { + name = poll_signal_init; + id = 0xD1; + fields := struct { + uint32_t signal_id; + }; +}; + +event { + name = poll_signal_reset; + id = 0xD2; + fields := struct { + uint32_t signal_id; + }; +}; + +event { + name = poll_signal_check; + id = 0xD3; + fields := struct { + uint32_t signal_id; + }; +}; + +event { + name = poll_signal_raise; + id = 0xD4; + fields := struct { + uint32_t signal_id; + int32_t ret; + }; +}; + +event { + name = thread_foreach_enter; + id = 0xD5; + fields := struct {}; +}; + +event { + name = thread_foreach_exit; + id = 0xD6; + fields := struct {}; +}; + +event { + name = thread_foreach_unlocked_enter; + id = 0xD7; + fields := struct {}; +}; + +event { + name = thread_foreach_unlocked_exit; + id = 0xD8; + fields := struct {}; +}; + +event { + name = thread_heap_assign; + id = 0xD9; + fields := struct { + uint32_t thread_id; + uint32_t heap_id; + }; +}; + +event { + name = thread_join_enter; + id = 0xDA; + fields := struct { + uint32_t thread_id; + uint32_t timeout; + }; +}; + +event { + name = thread_join_blocking; + id = 0xDB; + fields := struct { + uint32_t thread_id; + uint32_t timeout; + }; +}; + +event { + name = thread_join_exit; + id = 0xDC; + fields := struct { + uint32_t thread_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = thread_msleep_enter; + id = 0xDD; + fields := struct { + int32_t ms; + }; +}; + +event { + name = thread_msleep_exit; + id = 0xDE; + fields := struct { + int32_t ms; + int32_t ret; + }; +}; + +event { + name = thread_usleep_enter; + id = 0xDF; + fields := struct { + int32_t us; + }; +}; + +event { + name = thread_usleep_exit; + id = 0xE0; + fields := struct { + int32_t us; + int32_t ret; + }; +}; + +event { + name = thread_busy_wait_enter; + id = 0xE1; + fields := struct { + uint32_t usec_to_wait; + }; +}; + +event { + name = thread_busy_wait_exit; + id = 0xE2; + fields := struct { + uint32_t usec_to_wait; + }; +}; + +event { + name = thread_yield; + id = 0xE3; +}; + +event { + name = thread_suspend_exit; + id = 0xE4; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_lock; + id = 0xE5; +}; + +event { + name = thread_sched_unlock; + id = 0xE6; +}; + +event { + name = thread_sched_wakeup; + id = 0xE7; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_abort; + id = 0xE8; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_priority_set; + id = 0xE9; + fields := struct { + uint32_t thread_id; + int8_t prio; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_ready; + id = 0xEA; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_pend; + id = 0xEB; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_resume; + id = 0xEC; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = thread_sched_suspend; + id = 0xED; + fields := struct { + uint32_t thread_id; + ctf_bounded_string_t name[20]; + }; +}; + +event { + name = mbox_init; + id = 0xEE; + fields := struct { + uint32_t mbox_id; + }; +}; + +event { + name = mbox_message_put_enter; + id = 0xEF; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + }; +}; + +event { + name = mbox_message_put_blocking; + id = 0xF0; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + }; +}; + +event { + name = mbox_message_put_exit; + id = 0xF1; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = mbox_put_enter; + id = 0xF2; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + }; +}; + +event { + name = mbox_put_exit; + id = 0xF3; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = mbox_async_put_enter; + id = 0xF4; + fields := struct { + uint32_t mbox_id; + uint32_t sem_id; + }; +}; + +event { + name = mbox_async_put_exit; + id = 0xF5; + fields := struct { + uint32_t mbox_id; + uint32_t sem_id; + }; +}; + +event { + name = mbox_get_enter; + id = 0xF6; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + }; +}; + +event { + name = mbox_get_blocking; + id = 0xF7; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + }; +}; + +event { + name = mbox_get_exit; + id = 0xF8; + fields := struct { + uint32_t mbox_id; + uint32_t timeout; + int32_t ret; + }; +}; + +event { + name = mbox_data_get; + id = 0xF9; + fields := struct { + uint32_t msg_id; + }; +}; + +event { + name = event_init; + id = 0xFA; + fields := struct { + uint32_t event_id; + }; +}; + +event { + name = event_post_enter; + id = 0xFB; + fields := struct { + uint32_t event_id; + uint32_t events; + uint32_t events_mask; + }; +}; + +event { + name = event_post_exit; + id = 0xFC; + fields := struct { + uint32_t event_id; + uint32_t events; + uint32_t events_mask; + }; +}; + +event { + name = event_wait_enter; + id = 0xFD; + fields := struct { + uint32_t event_id; + uint32_t events; + uint32_t options; + uint32_t timeout; + }; +}; + +event { + name = event_wait_blocking; + id = 0xFE; + fields := struct { + uint32_t event_id; + uint32_t events; + uint32_t options; + uint32_t timeout; + }; +}; + +event { + name = event_wait_exit; + id = 0xFF; + fields := struct { + uint32_t event_id; + uint32_t events; + int32_t ret; + }; +}; diff --git a/subsys/tracing/sysview/SYSVIEW_Zephyr.txt b/subsys/tracing/sysview/SYSVIEW_Zephyr.txt index 2edadf2137d24..d7f3028b31b88 100644 --- a/subsys/tracing/sysview/SYSVIEW_Zephyr.txt +++ b/subsys/tracing/sysview/SYSVIEW_Zephyr.txt @@ -67,6 +67,7 @@ TaskState 0xBF 1=dummy, 2=Waiting, 4=New, 8=Terminated, 16=Suspended, 32=Termina 62 k_msgq_cleanup msgq=%I | Returns %ErrCodePosix 63 k_msgq_peek msgq=%I, data=%p | Returns %ErrCodeMsg 64 k_msgq_purge msgq=%I +134 k_msgq_put_front msgq=%I, data=%p, Timeout=%TimeOut | Returns %ErrCodeMsg 65 k_mbox_init mbox=%I 66 k_mbox_put mbox=%I, tx_msg=%p, Timeout=%TimeOut | Returns %ErrCodeMsg @@ -172,3 +173,7 @@ TaskState 0xBF 1=dummy, 2=Waiting, 4=New, 8=Terminated, 16=Suspended, 32=Termina 162 syscall name=%s 163 named_event name=%s arg0=%u arg1=%u + +164 k_event_init event=%I +165 k_event_post event=%I, events=%u, events_mask=%u +166 k_event_wait event=%I, events=%u, options=%u, Timeout=%TimeOut diff --git a/subsys/tracing/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index 96ae6c2b256bc..fddc1634200f8 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -81,8 +81,7 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_thread_abort_enter(thread) \ SEGGER_SYSVIEW_RecordU32(TID_THREAD_ABORT, (uint32_t)(uintptr_t)thread) -#define sys_port_trace_k_thread_abort_exit(thread) \ - SEGGER_SYSVIEW_RecordEndCall(TID_THREAD_ABORT) +#define sys_port_trace_k_thread_abort_exit(thread) SEGGER_SYSVIEW_RecordEndCall(TID_THREAD_ABORT) #define sys_port_trace_k_thread_suspend_enter(thread) \ SEGGER_SYSVIEW_RecordU32(TID_THREAD_SUSPEND, (uint32_t)(uintptr_t)thread) @@ -99,9 +98,10 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_thread_sched_unlock() -#define sys_port_trace_k_thread_name_set(thread, ret) do { \ - SEGGER_SYSVIEW_RecordU32(TID_THREAD_NAME_SET, (uint32_t)(uintptr_t)thread); \ - sys_trace_thread_info(thread); \ +#define sys_port_trace_k_thread_name_set(thread, ret) \ + do { \ + SEGGER_SYSVIEW_RecordU32(TID_THREAD_NAME_SET, (uint32_t)(uintptr_t)thread); \ + sys_trace_thread_info(thread); \ } while (false) #define sys_port_trace_k_thread_switched_out() sys_trace_k_thread_switched_out() @@ -170,9 +170,8 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_work_cancel_sync_exit(work, sync, ret) \ SEGGER_SYSVIEW_RecordEndCallU32(TID_WORK_CANCEL_SYNC, (uint32_t)ret) -#define sys_port_trace_k_work_queue_init(queue) \ - SEGGER_SYSVIEW_RecordU32(TID_WORK_QUEUE_INIT, \ - (uint32_t)(uintptr_t)queue) +#define sys_port_trace_k_work_queue_init(queue) \ + SEGGER_SYSVIEW_RecordU32(TID_WORK_QUEUE_INIT, (uint32_t)(uintptr_t)queue) #define sys_port_trace_k_work_queue_start_enter(queue) \ SEGGER_SYSVIEW_RecordU32(TID_WORK_QUEUE_START, (uint32_t)(uintptr_t)queue) @@ -343,10 +342,11 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_condvar_broadcast_exit(condvar, ret) \ SEGGER_SYSVIEW_RecordEndCallU32(TID_CONDVAR_BROADCAST, (uint32_t)ret) -#define sys_port_trace_k_condvar_wait_enter(condvar) \ - SEGGER_SYSVIEW_RecordU32(TID_CONDVAR_WAIT, (uint32_t)(uintptr_t)condvar) +#define sys_port_trace_k_condvar_wait_enter(condvar, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_CONDVAR_WAIT, (uint32_t)(uintptr_t)condvar, \ + (uint32_t)timeout.ticks) -#define sys_port_trace_k_condvar_wait_exit(condvar, ret) \ +#define sys_port_trace_k_condvar_wait_exit(condvar, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCallU32(TID_CONDVAR_WAIT, (uint32_t)ret) #define sys_port_trace_k_queue_init(queue) \ @@ -494,46 +494,116 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_lifo_get_exit(lifo, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCall(TID_LIFO_GET) -#define sys_port_trace_k_stack_init(stack) -#define sys_port_trace_k_stack_alloc_init_enter(stack) -#define sys_port_trace_k_stack_alloc_init_exit(stack, ret) -#define sys_port_trace_k_stack_cleanup_enter(stack) -#define sys_port_trace_k_stack_cleanup_exit(stack, ret) -#define sys_port_trace_k_stack_push_enter(stack) -#define sys_port_trace_k_stack_push_exit(stack, ret) -#define sys_port_trace_k_stack_pop_enter(stack, timeout) -#define sys_port_trace_k_stack_pop_blocking(stack, timeout) -#define sys_port_trace_k_stack_pop_exit(stack, timeout, ret) - -#define sys_port_trace_k_msgq_init(msgq) -#define sys_port_trace_k_msgq_alloc_init_enter(msgq) -#define sys_port_trace_k_msgq_alloc_init_exit(msgq, ret) -#define sys_port_trace_k_msgq_cleanup_enter(msgq) -#define sys_port_trace_k_msgq_cleanup_exit(msgq, ret) -#define sys_port_trace_k_msgq_put_enter(msgq, timeout) +/* Stack Operations */ + +#define sys_port_trace_k_stack_init(stack) \ + SEGGER_SYSVIEW_RecordU32(TID_STACK_INIT, (uint32_t)(uintptr_t)stack) + +#define sys_port_trace_k_stack_alloc_init_enter(stack) \ + SEGGER_SYSVIEW_RecordU32(TID_STACK_INIT, (uint32_t)(uintptr_t)stack) + +#define sys_port_trace_k_stack_alloc_init_exit(stack, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_STACK_INIT) + +#define sys_port_trace_k_stack_cleanup_enter(stack) \ + SEGGER_SYSVIEW_RecordU32(TID_QUEUE_STACK_CLEANUP, (uint32_t)(uintptr_t)stack) + +#define sys_port_trace_k_stack_cleanup_exit(stack, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_QUEUE_STACK_CLEANUP) + +#define sys_port_trace_k_stack_push_enter(stack) \ + SEGGER_SYSVIEW_RecordU32(TID_STACK_PUSH, (uint32_t)(uintptr_t)stack) + +#define sys_port_trace_k_stack_push_exit(stack, ret) SEGGER_SYSVIEW_RecordEndCall(TID_STACK_PUSH) + +#define sys_port_trace_k_stack_pop_enter(stack, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_STACK_POP, (uint32_t)(uintptr_t)stack, \ + (uint32_t)timeout.ticks) + +#define sys_port_trace_k_stack_pop_blocking(stack, timeout) \ + SEGGER_SYSVIEW_OnTaskStartExec((uint32_t)(uintptr_t)stack) + +#define sys_port_trace_k_stack_pop_exit(stack, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_STACK_POP) + +#define sys_port_trace_k_msgq_init(msgq) \ + SEGGER_SYSVIEW_RecordU32(TID_MSGQ_INIT, (uint32_t)(uintptr_t)msgq) + +#define sys_port_trace_k_msgq_alloc_init_enter(msgq) \ + SEGGER_SYSVIEW_RecordU32(TID_MSGQ_INIT, (uint32_t)(uintptr_t)msgq) + +#define sys_port_trace_k_msgq_alloc_init_exit(msgq, ret) SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_INIT) + +#define sys_port_trace_k_msgq_cleanup_enter(msgq) \ + SEGGER_SYSVIEW_RecordU32(TID_MSGQ_CLEANUP, (uint32_t)(uintptr_t)msgq) + +#define sys_port_trace_k_msgq_cleanup_exit(msgq, ret) SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_CLEANUP) + +#define sys_port_trace_k_msgq_put_enter(msgq, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MSGQ_PUT, (uint32_t)(uintptr_t)msgq, (uint32_t)timeout.ticks) + #define sys_port_trace_k_msgq_put_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_put_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_put_front_enter(msgq, timeout) + +#define sys_port_trace_k_msgq_put_exit(msgq, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_PUT) + +#define sys_port_trace_k_msgq_put_front_enter(msgq, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MSGQ_PUT_FRONT, (uint32_t)(uintptr_t)msgq, \ + (uint32_t)timeout.ticks) + #define sys_port_trace_k_msgq_put_front_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_put_front_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_get_enter(msgq, timeout) + +#define sys_port_trace_k_msgq_put_front_exit(msgq, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_PUT_FRONT) + +#define sys_port_trace_k_msgq_get_enter(msgq, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MSGQ_GET, (uint32_t)(uintptr_t)msgq, (uint32_t)timeout.ticks) + #define sys_port_trace_k_msgq_get_blocking(msgq, timeout) -#define sys_port_trace_k_msgq_get_exit(msgq, timeout, ret) -#define sys_port_trace_k_msgq_peek(msgq, ret) -#define sys_port_trace_k_msgq_purge(msgq) -#define sys_port_trace_k_mbox_init(mbox) -#define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) +#define sys_port_trace_k_msgq_get_exit(msgq, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_GET) + +#define sys_port_trace_k_msgq_peek(msgq, ret) \ + SEGGER_SYSVIEW_RecordU32(TID_MSGQ_PEEK, (uint32_t)(uintptr_t)msgq) + +#define sys_port_trace_k_msgq_purge(msgq) \ + SEGGER_SYSVIEW_RecordU32(TID_MSGQ_PURGE, (uint32_t)(uintptr_t)msgq) + +#define sys_port_trace_k_mbox_init(mbox) \ + SEGGER_SYSVIEW_RecordU32(TID_MBOX_INIT, (uint32_t)(uintptr_t)mbox) + +#define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MBOX_PUT, (uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks) + #define sys_port_trace_k_mbox_message_put_blocking(mbox, timeout) -#define sys_port_trace_k_mbox_message_put_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_put_enter(mbox, timeout) -#define sys_port_trace_k_mbox_put_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_async_put_enter(mbox, sem) -#define sys_port_trace_k_mbox_async_put_exit(mbox, sem) -#define sys_port_trace_k_mbox_get_enter(mbox, timeout) + +#define sys_port_trace_k_mbox_message_put_exit(mbox, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_PUT) + +#define sys_port_trace_k_mbox_put_enter(mbox, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MBOX_PUT, (uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks) + +#define sys_port_trace_k_mbox_put_exit(mbox, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_PUT) + +#define sys_port_trace_k_mbox_async_put_enter(mbox, sem) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MBOX_ASYNC_PUT, (uint32_t)(uintptr_t)mbox, \ + (uint32_t)(uintptr_t)sem) + +#define sys_port_trace_k_mbox_async_put_exit(mbox, sem) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_ASYNC_PUT) + +#define sys_port_trace_k_mbox_get_enter(mbox, timeout) \ + SEGGER_SYSVIEW_RecordU32x2(TID_MBOX_GET, (uint32_t)(uintptr_t)mbox, (uint32_t)timeout.ticks) + #define sys_port_trace_k_mbox_get_blocking(mbox, timeout) -#define sys_port_trace_k_mbox_get_exit(mbox, timeout, ret) -#define sys_port_trace_k_mbox_data_get(rx_msg) + +#define sys_port_trace_k_mbox_get_exit(mbox, timeout, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_GET) + +#define sys_port_trace_k_mbox_data_get(rx_msg) \ + SEGGER_SYSVIEW_RecordU32(TID_MBOX_DATA_GET, (uint32_t)(uintptr_t)rx_msg) #define sys_port_trace_k_pipe_init(pipe, buffer, size) #define sys_port_trace_k_pipe_reset_enter(pipe) @@ -562,12 +632,24 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_pipe_get_blocking(pipe, timeout) #define sys_port_trace_k_pipe_get_exit(pipe, timeout, ret) -#define sys_port_trace_k_event_init(event) -#define sys_port_trace_k_event_post_enter(event, events, events_mask) -#define sys_port_trace_k_event_post_exit(event, events, events_mask) -#define sys_port_trace_k_event_wait_enter(event, events, options, timeout) +#define sys_port_trace_k_event_init(event) \ + SEGGER_SYSVIEW_RecordU32(TID_EVENT_INIT, (uint32_t)(uintptr_t)event) + +#define sys_port_trace_k_event_post_enter(event, events, events_mask) \ + SEGGER_SYSVIEW_RecordU32x3(TID_EVENT_POST, (uint32_t)(uintptr_t)event, (uint32_t)events, \ + (uint32_t)events_mask) + +#define sys_port_trace_k_event_post_exit(event, events, events_mask) \ + SEGGER_SYSVIEW_RecordEndCall(TID_EVENT_POST) + +#define sys_port_trace_k_event_wait_enter(event, events, options, timeout) \ + SEGGER_SYSVIEW_RecordU32x4(TID_EVENT_WAIT, (uint32_t)(uintptr_t)event, (uint32_t)events, \ + (uint32_t)options, (uint32_t)timeout.ticks) + #define sys_port_trace_k_event_wait_blocking(event, events, options, timeout) -#define sys_port_trace_k_event_wait_exit(event, events, ret) + +#define sys_port_trace_k_event_wait_exit(event, events, ret) \ + SEGGER_SYSVIEW_RecordEndCall(TID_EVENT_WAIT) #define sys_port_trace_k_heap_init(heap) \ SEGGER_SYSVIEW_RecordU32(TID_HEAP_INIT, (uint32_t)(uintptr_t)heap) @@ -636,9 +718,9 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_timer_init(timer) \ SEGGER_SYSVIEW_RecordU32(TID_TIMER_INIT, (uint32_t)(uintptr_t)timer) -#define sys_port_trace_k_timer_start(timer, duration, period) \ - SEGGER_SYSVIEW_RecordU32x3(TID_TIMER_START, (uint32_t)(uintptr_t)timer, \ - (uint32_t)duration.ticks, (uint32_t)period.ticks) +#define sys_port_trace_k_timer_start(timer, duration, period) \ + SEGGER_SYSVIEW_RecordU32x3(TID_TIMER_START, (uint32_t)(uintptr_t)timer, \ + (uint32_t)duration.ticks, (uint32_t)period.ticks) #define sys_port_trace_k_timer_stop(timer) \ SEGGER_SYSVIEW_RecordU32(TID_TIMER_STOP, (uint32_t)(uintptr_t)timer) @@ -651,11 +733,10 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_timer_status_sync_exit(timer, result) \ SEGGER_SYSVIEW_RecordEndCallU32(TID_TIMER_STATUS_SYNC, (uint32_t)result) -#define sys_port_trace_syscall_enter(id, name, ...) \ +#define sys_port_trace_syscall_enter(id, name, ...) \ SEGGER_SYSVIEW_RecordString(TID_SYSCALL, (const char *)#name) -#define sys_port_trace_syscall_exit(id, name, ...) \ - SEGGER_SYSVIEW_RecordEndCall(TID_SYSCALL) +#define sys_port_trace_syscall_exit(id, name, ...) SEGGER_SYSVIEW_RecordEndCall(TID_SYSCALL) void sys_trace_idle(void); void sys_trace_idle_exit(void); @@ -674,41 +755,32 @@ void sys_trace_k_thread_info(struct k_thread *thread); void sys_trace_named_event(const char *name, uint32_t arg0, uint32_t arg1); -#define sys_port_trace_pm_system_suspend_enter(ticks) \ +#define sys_port_trace_pm_system_suspend_enter(ticks) \ SEGGER_SYSVIEW_RecordU32(TID_PM_SYSTEM_SUSPEND, (uint32_t)ticks) -#define sys_port_trace_pm_system_suspend_exit(ticks, state) \ +#define sys_port_trace_pm_system_suspend_exit(ticks, state) \ SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_SYSTEM_SUSPEND, (uint32_t)state) -#define sys_port_trace_pm_device_runtime_get_enter(dev) \ - SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_GET, \ - (uint32_t)(uintptr_t)dev) -#define sys_port_trace_pm_device_runtime_get_exit(dev, ret) \ - SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_GET, \ - (uint32_t)ret) -#define sys_port_trace_pm_device_runtime_put_enter(dev) \ - SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_PUT, \ - (uint32_t)(uintptr_t)dev) -#define sys_port_trace_pm_device_runtime_put_exit(dev, ret) \ - SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_PUT, \ - (uint32_t)ret) -#define sys_port_trace_pm_device_runtime_put_async_enter(dev, delay) \ - SEGGER_SYSVIEW_RecordU32x2(TID_PM_DEVICE_RUNTIME_PUT_ASYNC, \ - (uint32_t)(uintptr_t)dev, (uint32_t)delay.ticks) -#define sys_port_trace_pm_device_runtime_put_async_exit(dev, delay, ret) \ - SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_PUT_ASYNC, \ - (uint32_t)ret) -#define sys_port_trace_pm_device_runtime_enable_enter(dev) \ - SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_ENABLE, \ - (uint32_t)(uintptr_t)dev) -#define sys_port_trace_pm_device_runtime_enable_exit(dev, ret) \ - SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_ENABLE, \ - (uint32_t)ret) -#define sys_port_trace_pm_device_runtime_disable_enter(dev) \ - SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_DISABLE, \ - (uint32_t)(uintptr_t)dev) -#define sys_port_trace_pm_device_runtime_disable_exit(dev, ret) \ - SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_DISABLE, \ - (uint32_t)ret) +#define sys_port_trace_pm_device_runtime_get_enter(dev) \ + SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_GET, (uint32_t)(uintptr_t)dev) +#define sys_port_trace_pm_device_runtime_get_exit(dev, ret) \ + SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_GET, (uint32_t)ret) +#define sys_port_trace_pm_device_runtime_put_enter(dev) \ + SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_PUT, (uint32_t)(uintptr_t)dev) +#define sys_port_trace_pm_device_runtime_put_exit(dev, ret) \ + SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_PUT, (uint32_t)ret) +#define sys_port_trace_pm_device_runtime_put_async_enter(dev, delay) \ + SEGGER_SYSVIEW_RecordU32x2(TID_PM_DEVICE_RUNTIME_PUT_ASYNC, (uint32_t)(uintptr_t)dev, \ + (uint32_t)delay.ticks) +#define sys_port_trace_pm_device_runtime_put_async_exit(dev, delay, ret) \ + SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_PUT_ASYNC, (uint32_t)ret) +#define sys_port_trace_pm_device_runtime_enable_enter(dev) \ + SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_ENABLE, (uint32_t)(uintptr_t)dev) +#define sys_port_trace_pm_device_runtime_enable_exit(dev, ret) \ + SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_ENABLE, (uint32_t)ret) +#define sys_port_trace_pm_device_runtime_disable_enter(dev) \ + SEGGER_SYSVIEW_RecordU32(TID_PM_DEVICE_RUNTIME_DISABLE, (uint32_t)(uintptr_t)dev) +#define sys_port_trace_pm_device_runtime_disable_exit(dev, ret) \ + SEGGER_SYSVIEW_RecordEndCallU32(TID_PM_DEVICE_RUNTIME_DISABLE, (uint32_t)ret) #define sys_trace_sys_init_enter(...) #define sys_trace_sys_init_exit(...) diff --git a/subsys/tracing/sysview/tracing_sysview_ids.h b/subsys/tracing/sysview/tracing_sysview_ids.h index 1ad2b2f14832a..246a9d58b0f40 100644 --- a/subsys/tracing/sysview/tracing_sysview_ids.h +++ b/subsys/tracing/sysview/tracing_sysview_ids.h @@ -47,12 +47,13 @@ extern "C" { #define TID_STACK_POP (25u + TID_OFFSET) #define TID_QUEUE_STACK_CLEANUP (26u + TID_OFFSET) -#define TID_MSGQ_INIT (27u + TID_OFFSET) -#define TID_MSGQ_PUT (28u + TID_OFFSET) -#define TID_MSGQ_GET (29u + TID_OFFSET) -#define TID_MSGQ_CLEANUP (30u + TID_OFFSET) -#define TID_MSQG_PEEK (31u + TID_OFFSET) -#define TID_MSGQ_PURGE (32u + TID_OFFSET) +#define TID_MSGQ_INIT (27u + TID_OFFSET) +#define TID_MSGQ_PUT (28u + TID_OFFSET) +#define TID_MSGQ_GET (29u + TID_OFFSET) +#define TID_MSGQ_CLEANUP (30u + TID_OFFSET) +#define TID_MSGQ_PEEK (31u + TID_OFFSET) +#define TID_MSGQ_PURGE (32u + TID_OFFSET) +#define TID_MSGQ_PUT_FRONT (50u + TID_OFFSET) #define TID_MBOX_INIT (33u + TID_OFFSET) #define TID_MBOX_PUT (34u + TID_OFFSET) @@ -158,7 +159,11 @@ extern "C" { #define TID_NAMED_EVENT (131u + TID_OFFSET) -/* latest ID is 130 */ +#define TID_EVENT_INIT (132u + TID_OFFSET) +#define TID_EVENT_POST (133u + TID_OFFSET) +#define TID_EVENT_WAIT (134u + TID_OFFSET) + +/* latest ID is 134 */ #ifdef __cplusplus } diff --git a/subsys/tracing/test/tracing_string_format_test.c b/subsys/tracing/test/tracing_string_format_test.c index 0dda01f50cba1..65250b9f08523 100644 --- a/subsys/tracing/test/tracing_string_format_test.c +++ b/subsys/tracing/test/tracing_string_format_test.c @@ -243,14 +243,13 @@ void sys_trace_k_condvar_signal_exit(struct k_condvar *condvar, int ret) TRACING_STRING("%s: %p\n", __func__, condvar); } -void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, struct k_mutex *mutex, - k_timeout_t timeout) +void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, k_timeout_t timeout) { TRACING_STRING("%s: %p\n", __func__, condvar); } -void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, struct k_mutex *mutex, - k_timeout_t timeout, int ret) +void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, k_timeout_t timeout, + int ret) { TRACING_STRING("%s: %p\n", __func__, condvar); } diff --git a/subsys/tracing/test/tracing_test.h b/subsys/tracing/test/tracing_test.h index 80a3fa8932888..e5025c895421d 100644 --- a/subsys/tracing/test/tracing_test.h +++ b/subsys/tracing/test/tracing_test.h @@ -152,10 +152,10 @@ sys_trace_k_condvar_broadcast_enter(condvar) #define sys_port_trace_k_condvar_broadcast_exit(condvar, ret) \ sys_trace_k_condvar_broadcast_exit(condvar, ret) -#define sys_port_trace_k_condvar_wait_enter(condvar) \ - sys_trace_k_condvar_wait_enter(condvar, mutex, timeout) -#define sys_port_trace_k_condvar_wait_exit(condvar, ret) \ - sys_trace_k_condvar_wait_exit(condvar, mutex, timeout, ret) +#define sys_port_trace_k_condvar_wait_enter(condvar, timeout) \ + sys_trace_k_condvar_wait_enter(condvar, timeout) +#define sys_port_trace_k_condvar_wait_exit(condvar, timeout, ret) \ + sys_trace_k_condvar_wait_exit(condvar, timeout, ret) #define sys_port_trace_k_queue_init(queue) sys_trace_k_queue_init(queue) #define sys_port_trace_k_queue_cancel_wait(queue) sys_trace_k_queue_cancel_wait(queue) @@ -555,10 +555,8 @@ void sys_trace_k_condvar_signal_blocking(struct k_condvar *condvar); void sys_trace_k_condvar_signal_exit(struct k_condvar *condvar, int ret); void sys_trace_k_condvar_broadcast_enter(struct k_condvar *condvar); void sys_trace_k_condvar_broadcast_exit(struct k_condvar *condvar, int ret); -void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, struct k_mutex *mutex, - k_timeout_t timeout); -void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, struct k_mutex *mutex, - k_timeout_t timeout, int ret); +void sys_trace_k_condvar_wait_enter(struct k_condvar *condvar, k_timeout_t timeout); +void sys_trace_k_condvar_wait_exit(struct k_condvar *condvar, k_timeout_t timeout, int ret); void sys_trace_k_queue_init(struct k_queue *queue); void sys_trace_k_queue_cancel_wait(struct k_queue *queue); diff --git a/subsys/tracing/tracing_backend_semihosting.c b/subsys/tracing/tracing_backend_semihosting.c new file mode 100644 index 0000000000000..117402173a0cd --- /dev/null +++ b/subsys/tracing/tracing_backend_semihosting.c @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2021 IoT.bzh + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include + +static int tracing_fd = -1; + +static void tracing_backend_semihost_output(const struct tracing_backend *backend, uint8_t *data, + uint32_t length) +{ + semihost_write(tracing_fd, data, length); +} + +static void tracing_backend_semihost_init(void) +{ + const char *tracing_file = "./tracing.bin"; + + tracing_fd = semihost_open(tracing_file, SEMIHOST_OPEN_AB_PLUS); + __ASSERT(tracing_fd >= 0, "semihost_open() returned %d", tracing_fd); + if (tracing_fd < 0) { + k_panic(); + } +} + +const struct tracing_backend_api tracing_backend_semihost_api = { + .init = tracing_backend_semihost_init, .output = tracing_backend_semihost_output}; + +TRACING_BACKEND_DEFINE(tracing_backend_semihost, tracing_backend_semihost_api); diff --git a/subsys/tracing/user/tracing_user.h b/subsys/tracing/user/tracing_user.h index 0cef2626ee075..feb84c7bdd685 100644 --- a/subsys/tracing/user/tracing_user.h +++ b/subsys/tracing/user/tracing_user.h @@ -224,8 +224,8 @@ void sys_trace_gpio_fire_callback_user(const struct device *port, struct gpio_ca #define sys_port_trace_k_condvar_signal_exit(condvar, ret) #define sys_port_trace_k_condvar_broadcast_enter(condvar) #define sys_port_trace_k_condvar_broadcast_exit(condvar, ret) -#define sys_port_trace_k_condvar_wait_enter(condvar) -#define sys_port_trace_k_condvar_wait_exit(condvar, ret) +#define sys_port_trace_k_condvar_wait_enter(condvar, timeout) +#define sys_port_trace_k_condvar_wait_exit(condvar, timeout, ret) #define sys_port_trace_k_queue_init(queue) #define sys_port_trace_k_queue_cancel_wait(queue) diff --git a/tests/subsys/tracing/tracing_api/src/main.c b/tests/subsys/tracing/tracing_api/src/main.c index 89f1478f63330..e42a4832337d5 100644 --- a/tests/subsys/tracing/tracing_api/src/main.c +++ b/tests/subsys/tracing/tracing_api/src/main.c @@ -170,8 +170,8 @@ ZTEST(tracing_api, test_tracing_sys_api) sys_trace_k_condvar_signal_enter(&condvar); sys_trace_k_condvar_signal_blocking(&condvar); sys_trace_k_condvar_signal_exit(&condvar, ret); - sys_trace_k_condvar_wait_enter(&condvar, &mutex, timeout); - sys_trace_k_condvar_wait_exit(&condvar, &mutex, timeout, ret); + sys_trace_k_condvar_wait_enter(&condvar, timeout); + sys_trace_k_condvar_wait_exit(&condvar, timeout, ret); /* sem api */ sys_trace_k_sem_init(&sem, ret); sys_trace_k_sem_give_enter(&sem); diff --git a/west.yml b/west.yml index 7aedb6ef19634..d23de074dba28 100644 --- a/west.yml +++ b/west.yml @@ -352,7 +352,7 @@ manifest: path: modules/lib/openthread - name: percepio path: modules/debug/percepio - revision: 49e6dc202aa38c2a3edbafcc2dab85dec6aee973 + revision: pull/15/head groups: - debug - name: picolibc