From 88182c306effe7ccdbfaa8c41c3eee65aec1c827 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 19:55:05 -0400 Subject: [PATCH 01/19] kernel: msgq: return once to simplify tracing Return once simplifying tracing macros. Signed-off-by: Anas Nashif --- kernel/msg_q.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) 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, From f8cde28f8d55767317edcc0edc728510b52e4a25 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Tue, 29 Jul 2025 19:16:19 -0400 Subject: [PATCH 02/19] tracing: add semihosting backend Using semihosting on supported architectures (arm, xtensa, riscv) it now possible to generate tracing giles easily and without being restricted by size. Using qemu for example, it is now possible to generate the tracing file simply by running: west build -p -b mps2/an385 tests/kernel/msgq/msgq_api/ \ -t run --snippet semihost-tracing This will generate a tracing file in the build/ directory which can be viewed with babeltrace. Signed-off-by: Anas Nashif --- subsys/tracing/CMakeLists.txt | 5 +++ subsys/tracing/Kconfig | 8 +++++ subsys/tracing/tracing_backend_semihosting.c | 37 ++++++++++++++++++++ 3 files changed, 50 insertions(+) create mode 100644 subsys/tracing/tracing_backend_semihosting.c 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/tracing_backend_semihosting.c b/subsys/tracing/tracing_backend_semihosting.c new file mode 100644 index 0000000000000..405fbe19e845e --- /dev/null +++ b/subsys/tracing/tracing_backend_semihosting.c @@ -0,0 +1,37 @@ +/* + * 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); From 6e44349f639c89497feac48fbebba69824d2cc33 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 16:03:07 -0400 Subject: [PATCH 03/19] tracing: ctf: add missing return value for mutex_unlock Add missing return for mutex_unlock. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.h | 2 +- subsys/tracing/ctf/tsdl/metadata | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index d1461086a6fb1..bdc5978b6beaa 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -403,7 +403,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 */ diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 00bc7c364ab39..5723f0138cd29 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; }; }; From 5db037f68f5d33f36bc6d5dfaddb54ecd2e6b31f Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 16:19:30 -0400 Subject: [PATCH 04/19] tracing: ctf: add tracing for memory slabs Add hooks for memory slabs. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 49 ++++++++++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 37 +++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 27 +++++++++++---- subsys/tracing/ctf/tsdl/metadata | 56 ++++++++++++++++++++++++++++++++ 4 files changed, 163 insertions(+), 6 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 97a0920ceb5b8..02261dd851a0c 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -219,6 +219,55 @@ void sys_trace_idle_exit(void) } } +/* 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 + ); +} + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) { diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index bdc5978b6beaa..edaab8153239b 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -190,6 +190,13 @@ 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, } ctf_event_t; typedef struct { @@ -326,6 +333,36 @@ 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); +} /* Semaphore */ static inline void ctf_top_semaphore_init(uint32_t sem_id, diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index efb9a92f3e742..0968e566aa269 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -323,12 +323,18 @@ 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_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) #define sys_port_trace_k_event_post_enter(event, events, events_mask) @@ -414,6 +420,15 @@ 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); +/* 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); + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 5723f0138cd29..f4dbbaf4673bc 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1066,3 +1066,59 @@ 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; + }; +}; \ No newline at end of file From 12ca2ae7a4557e002fa142ec011bbbdb9f5beec7 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 18:20:28 -0400 Subject: [PATCH 05/19] tracing: ctf: add tracing for message queues Add hooks for message queues. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 129 ++++++++++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 99 +++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 67 +++++++++++---- subsys/tracing/ctf/tsdl/metadata | 142 ++++++++++++++++++++++++++++++- 4 files changed, 420 insertions(+), 17 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 02261dd851a0c..b0adeb1b6bf22 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -268,6 +268,134 @@ 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) +{ + 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 + ); +} + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) { @@ -277,6 +405,7 @@ void sys_trace_k_sem_init(struct k_sem *sem, int ret) ); } + void sys_trace_k_sem_take_enter(struct k_sem *sem, k_timeout_t timeout) { ctf_top_semaphore_take_enter( diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index edaab8153239b..dd11ee7d521f6 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -197,6 +197,24 @@ typedef enum { 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, } ctf_event_t; typedef struct { @@ -364,6 +382,87 @@ 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); +} + + /* Semaphore */ static inline void ctf_top_semaphore_init(uint32_t sem_id, int32_t ret) diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index 0968e566aa269..e671172cef9bd 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -259,22 +259,38 @@ 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_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) #define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) @@ -429,6 +445,25 @@ void sys_trace_k_mem_slab_alloc_exit(struct k_mem_slab *slab, k_timeout_t timeou 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); + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index f4dbbaf4673bc..c890f21160eff 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1121,4 +1121,144 @@ event { fields := struct { uint32_t id; }; -}; \ No newline at end of file +}; + +/* 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; + }; +}; From 341ed3b0606ea24819d5bee340644215537a1afa Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 20:28:16 -0400 Subject: [PATCH 06/19] tracing: ctf: add condition variables Add hooks for condition variables. Signed-off-by: Anas Nashif --- include/zephyr/tracing/tracing.h | 4 +- kernel/condvar.c | 4 +- subsys/tracing/ctf/ctf_top.c | 64 +++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 44 ++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 35 ++++++--- subsys/tracing/ctf/tsdl/metadata | 72 +++++++++++++++++++ .../tracing/test/tracing_string_format_test.c | 7 +- subsys/tracing/test/tracing_test.h | 14 ++-- subsys/tracing/user/tracing_user.h | 4 +- tests/subsys/tracing/tracing_api/src/main.c | 4 +- 10 files changed, 223 insertions(+), 29 deletions(-) diff --git a/include/zephyr/tracing/tracing.h b/include/zephyr/tracing/tracing.h index 603ad8fb5129b..0e49fc6e041aa 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/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index b0adeb1b6bf22..d1f1d556b2607 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -388,6 +388,7 @@ void sys_trace_k_msgq_cleanup_enter(struct k_msgq *msgq) (uint32_t)(uintptr_t)msgq ); } + void sys_trace_k_msgq_cleanup_exit(struct k_msgq *msgq, int ret) { ctf_top_msgq_cleanup_exit( @@ -396,6 +397,69 @@ void sys_trace_k_msgq_cleanup_exit(struct k_msgq *msgq, int 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 + ); +} + + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) { diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index dd11ee7d521f6..efea5503dea31 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -215,6 +215,17 @@ typedef enum { 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, + } ctf_event_t; typedef struct { @@ -462,6 +473,39 @@ 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); +} /* Semaphore */ static inline void ctf_top_semaphore_init(uint32_t sem_id, diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index e671172cef9bd..f64ed9bbbb102 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -181,14 +181,22 @@ extern "C" { #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) @@ -464,8 +472,17 @@ 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); -/* Semaphore */ +/* 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); +/* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret); void sys_trace_k_sem_give_enter(struct k_sem *sem); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index c890f21160eff..5cfe3e66934f9 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1262,3 +1262,75 @@ event { 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; + }; +}; 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 22c243cb16ec3..02612017c759c 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) @@ -530,10 +530,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/user/tracing_user.h b/subsys/tracing/user/tracing_user.h index 70cf02ea906b9..346f6fabd49a6 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..e1c7a8e30724a 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); From c921501f463ab74e33fd47afd891b9eadf4fbc06 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 20:43:31 -0400 Subject: [PATCH 07/19] tracing: ctf: add work queues Add hooks for work queues. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 384 +++++++++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 294 +++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 202 +++++++++++---- subsys/tracing/ctf/tsdl/metadata | 431 +++++++++++++++++++++++++++++++ 4 files changed, 1261 insertions(+), 50 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index d1f1d556b2607..3fec51fde7355 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -459,6 +459,390 @@ void sys_trace_k_condvar_broadcast_exit(struct k_condvar *condvar, int 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_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 + ); +} + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index efea5503dea31..08f9b4830e796 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -226,6 +226,61 @@ typedef enum { 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, + } ctf_event_t; typedef struct { @@ -507,6 +562,245 @@ static inline void ctf_top_condvar_wait_exit(uint32_t condvar_id, uint32_t timeo 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); +} + /* Semaphore */ static inline void ctf_top_semaphore_init(uint32_t sem_id, int32_t ret) diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index f64ed9bbbb102..ae06af5bc3fc0 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -77,61 +77,108 @@ extern "C" { #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_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) -#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) + 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) -#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) + 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) + 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) + 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) -#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) + 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) #define sys_port_trace_k_poll_api_poll_enter(events) @@ -482,6 +529,61 @@ 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); + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret); void sys_trace_k_sem_give_enter(struct k_sem *sem); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 5cfe3e66934f9..ea2dc992781b4 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1334,3 +1334,434 @@ event { 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; + }; +}; From 0eb3b7354cdd51c7fde8b31b3544bbad97ea979e Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 30 Jul 2025 21:10:33 -0400 Subject: [PATCH 08/19] tracing: ctf: add poll Add hooks for poll object. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 52 ++++++++++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 45 ++++++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 30 ++++++++++++---- subsys/tracing/ctf/tsdl/metadata | 59 ++++++++++++++++++++++++++++++++ 4 files changed, 179 insertions(+), 7 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 3fec51fde7355..0b5201b135116 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -843,6 +843,58 @@ 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) +{ + 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 *signal) +{ + ctf_top_poll_signal_init( + (uint32_t)(uintptr_t)signal + ); +} + +void sys_trace_k_poll_api_signal_reset(struct k_poll_signal *signal) +{ + ctf_top_poll_signal_reset( + (uint32_t)(uintptr_t)signal + ); +} + +void sys_trace_k_poll_api_signal_check(struct k_poll_signal *signal) +{ + ctf_top_poll_signal_check( + (uint32_t)(uintptr_t)signal + ); +} + +void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *signal, int ret) +{ + ctf_top_poll_signal_raise( + (uint32_t)(uintptr_t)signal, + (int32_t)ret + ); +} + /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index 08f9b4830e796..ca884e248f56e 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -281,6 +281,15 @@ typedef enum { 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, + } ctf_event_t; typedef struct { @@ -801,6 +810,42 @@ 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) diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index ae06af5bc3fc0..2b10a8777cd44 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -180,13 +180,20 @@ extern "C" { #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) -#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_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) @@ -584,6 +591,15 @@ void sys_trace_k_work_poll_submit_exit(struct k_work_poll *work, k_timeout_t tim 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); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index ea2dc992781b4..4dfba34f4283b 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1765,3 +1765,62 @@ event { 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; + }; +}; From c21dde29e0eec1694760d95b2e761a34e2045ed2 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Thu, 31 Jul 2025 07:51:55 -0400 Subject: [PATCH 09/19] tracing: ctf: thread extended Add more thread related tracing functions. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 163 +++++++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 153 ++++++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 98 ++++++++++----- subsys/tracing/ctf/tsdl/metadata | 199 +++++++++++++++++++++++++++++++ 4 files changed, 580 insertions(+), 33 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 0b5201b135116..0c968e434aee0 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -187,6 +187,169 @@ void sys_trace_k_thread_name_set(struct k_thread *thread, int ret) } +/* 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() +{ + 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) { ctf_top_isr_enter(); diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index ca884e248f56e..8c579e06f2c12 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -290,6 +290,33 @@ typedef enum { 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, + } ctf_event_t; typedef struct { @@ -397,6 +424,132 @@ static inline void ctf_top_thread_wakeup(uint32_t thread_id, ctf_bounded_string_ thread_id, name); } +/* Thread Extended Functions */ +static inline void ctf_top_thread_foreach_enter() +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_ENTER)); +} + +static inline void ctf_top_thread_foreach_exit() +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_EXIT)); +} + +static inline void ctf_top_thread_foreach_unlocked_enter() +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_UNLOCKED_ENTER)); +} + +static inline void ctf_top_thread_foreach_unlocked_exit() +{ + 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) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_ISR_ENTER)); diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index 2b10a8777cd44..72c1820d70897 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -16,10 +16,14 @@ extern "C" { #endif -#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_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_create(new_thread) \ sys_trace_k_thread_create(new_thread, stack_size, prio) @@ -27,35 +31,49 @@ extern "C" { #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_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) -#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_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) +#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() +#define sys_port_trace_k_thread_sched_lock() \ + sys_trace_k_thread_sched_lock() -#define sys_port_trace_k_thread_sched_unlock() +#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) @@ -66,16 +84,23 @@ 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_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) +#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) +#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) +#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) @@ -457,14 +482,10 @@ 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_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); @@ -472,6 +493,7 @@ 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); @@ -498,6 +520,16 @@ 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); +/* 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); diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 4dfba34f4283b..8712e2905558e 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -1824,3 +1824,202 @@ event { 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]; + }; +}; From 6124d4bfd36fb48c48a1a55b65d3bca618f0a56f Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Thu, 31 Jul 2025 13:16:21 -0400 Subject: [PATCH 10/19] tracing: ctf: add mbox support Add hooks for mail boxes. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 74 +++++++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 75 +++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 50 ++++++++++---- subsys/tracing/ctf/tsdl/metadata | 109 +++++++++++++++++++++++++++++++ 4 files changed, 296 insertions(+), 12 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 0c968e434aee0..71528491d1c12 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -1788,3 +1788,77 @@ 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); +} diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index 8c579e06f2c12..07ceec33883be 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -317,6 +317,20 @@ typedef enum { 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, + } ctf_event_t; typedef struct { @@ -1529,4 +1543,65 @@ 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); +} + #endif /* SUBSYS_DEBUG_TRACING_CTF_TOP_H */ diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index 72c1820d70897..62c2b6e65d616 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -379,18 +379,30 @@ extern "C" { #define sys_port_trace_k_msgq_purge(msgq) \ sys_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_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) @@ -665,6 +677,20 @@ void sys_trace_k_timer_status_sync_exit(struct k_timer *timer, uint32_t result); void sys_trace_k_event_init(struct k_event *event); +/* 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); + #define sys_port_trace_socket_init(sock, family, type, proto) \ sys_trace_socket_init(sock, family, type, proto) diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index 8712e2905558e..e537e0b6dd5fe 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -2023,3 +2023,112 @@ event { 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; + }; +}; From 491c66c216393f170a2ecfdd686f735bfe72f43f Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Thu, 31 Jul 2025 13:37:50 -0400 Subject: [PATCH 11/19] tracing: ctf: add event support Add hooks for events. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 31 +++++++++++++++++ subsys/tracing/ctf/ctf_top.h | 39 +++++++++++++++++++++ subsys/tracing/ctf/tracing_ctf.h | 28 ++++++++++----- subsys/tracing/ctf/tsdl/metadata | 60 ++++++++++++++++++++++++++++++++ 4 files changed, 150 insertions(+), 8 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 71528491d1c12..9508f570b4ed2 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -1862,3 +1862,34 @@ 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 07ceec33883be..53b985ab27b86 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -331,6 +331,14 @@ typedef enum { 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 { @@ -1604,4 +1612,35 @@ 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 62c2b6e65d616..8e27bec9d8228 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -451,12 +451,18 @@ extern "C" { #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) -#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_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) @@ -675,8 +681,6 @@ void sys_trace_k_timer_status_sync_blocking(struct k_timer *timer, k_timeout_t t 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); -void sys_trace_k_event_init(struct k_event *event); - /* 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); @@ -691,6 +695,14 @@ 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) \ sys_trace_socket_init(sock, family, type, proto) diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index e537e0b6dd5fe..ff18e5ef20626 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -2132,3 +2132,63 @@ event { 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; + }; +}; From 65ed9f64e4a952257919bfb836729b0d239a5fef Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Fri, 1 Aug 2025 06:34:10 -0400 Subject: [PATCH 12/19] tracing: systemview: add tracing for message queues Add missing hooks for message queues. Signed-off-by: Anas Nashif --- subsys/tracing/sysview/SYSVIEW_Zephyr.txt | 1 + subsys/tracing/sysview/tracing_sysview.h | 60 ++++++++++++++------ subsys/tracing/sysview/tracing_sysview_ids.h | 13 +++-- 3 files changed, 52 insertions(+), 22 deletions(-) diff --git a/subsys/tracing/sysview/SYSVIEW_Zephyr.txt b/subsys/tracing/sysview/SYSVIEW_Zephyr.txt index 2edadf2137d24..8746af9d655cf 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 diff --git a/subsys/tracing/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index 6867a1476b92c..ad06b4c2b5b6b 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -343,10 +343,10 @@ 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) \ @@ -505,22 +505,50 @@ void sys_trace_thread_info(struct k_thread *thread); #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_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_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) #define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) diff --git a/subsys/tracing/sysview/tracing_sysview_ids.h b/subsys/tracing/sysview/tracing_sysview_ids.h index 1ad2b2f14832a..aa3c9b23fc117 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) From d2a9edb84c2c58ac3e746b196b7bc26fb8bdc7d5 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Fri, 1 Aug 2025 07:00:57 -0400 Subject: [PATCH 13/19] tracing: systemview: add tracing for stacks Add missing hooks for stack objects. Signed-off-by: Anas Nashif --- subsys/tracing/sysview/tracing_sysview.h | 42 ++++++++++++++++++------ 1 file changed, 32 insertions(+), 10 deletions(-) diff --git a/subsys/tracing/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index ad06b4c2b5b6b..6a2c84da4cfbd 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -494,16 +494,38 @@ 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) + +/* 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) From 7e85c7a0f151891edf38c7373fb6c8ef26ffd2ad Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Fri, 1 Aug 2025 07:06:24 -0400 Subject: [PATCH 14/19] tracing: systemview: add tracing for events Add missing hooks for events. Signed-off-by: Anas Nashif --- subsys/tracing/sysview/SYSVIEW_Zephyr.txt | 4 +++ subsys/tracing/sysview/tracing_sysview.h | 35 +++++++++++++++++--- subsys/tracing/sysview/tracing_sysview_ids.h | 6 +++- 3 files changed, 39 insertions(+), 6 deletions(-) diff --git a/subsys/tracing/sysview/SYSVIEW_Zephyr.txt b/subsys/tracing/sysview/SYSVIEW_Zephyr.txt index 8746af9d655cf..d7f3028b31b88 100644 --- a/subsys/tracing/sysview/SYSVIEW_Zephyr.txt +++ b/subsys/tracing/sysview/SYSVIEW_Zephyr.txt @@ -173,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 6a2c84da4cfbd..5cb8587390b1f 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -597,12 +597,37 @@ void sys_trace_thread_info(struct k_thread *thread); #define sys_port_trace_k_pipe_read_blocking(pipe, timeout) #define sys_port_trace_k_pipe_read_exit(pipe, 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_pipe_cleanup_enter(pipe) +#define sys_port_trace_k_pipe_cleanup_exit(pipe, ret) +#define sys_port_trace_k_pipe_alloc_init_enter(pipe) +#define sys_port_trace_k_pipe_alloc_init_exit(pipe, ret) +#define sys_port_trace_k_pipe_flush_enter(pipe) +#define sys_port_trace_k_pipe_flush_exit(pipe) +#define sys_port_trace_k_pipe_buffer_flush_enter(pipe) +#define sys_port_trace_k_pipe_buffer_flush_exit(pipe) +#define sys_port_trace_k_pipe_put_enter(pipe, timeout) +#define sys_port_trace_k_pipe_put_blocking(pipe, timeout) +#define sys_port_trace_k_pipe_put_exit(pipe, timeout, ret) +#define sys_port_trace_k_pipe_get_enter(pipe, timeout) +#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) \ + 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) diff --git a/subsys/tracing/sysview/tracing_sysview_ids.h b/subsys/tracing/sysview/tracing_sysview_ids.h index aa3c9b23fc117..246a9d58b0f40 100644 --- a/subsys/tracing/sysview/tracing_sysview_ids.h +++ b/subsys/tracing/sysview/tracing_sysview_ids.h @@ -159,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 } From b32a3ebac8166ed845c3b8007c6c1969754c6f53 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Fri, 1 Aug 2025 07:06:34 -0400 Subject: [PATCH 15/19] tracing: systemview: add tracing for mail boxes Add missing hooks for mail boxes. Signed-off-by: Anas Nashif --- subsys/tracing/sysview/tracing_sysview.h | 41 ++++++++++++++++++------ 1 file changed, 31 insertions(+), 10 deletions(-) diff --git a/subsys/tracing/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index 5cb8587390b1f..13ad1d9ea4f2a 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -572,18 +572,39 @@ void sys_trace_thread_info(struct k_thread *thread); #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) -#define sys_port_trace_k_mbox_message_put_enter(mbox, timeout) +#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) From 0d1e1136c1fb9a79391cffb4ace3c29d6aa76027 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Mon, 4 Aug 2025 19:34:08 -0400 Subject: [PATCH 16/19] snippets: add semihost tracing snippet Add semihost tracing to easy generating tracing data for existing applications/tests. Signed-off-by: Anas Nashif --- snippets/semihost-tracing/README.rst | 67 +++++++++++++++++++ .../semihost-tracing/semihost-tracing.conf | 12 ++++ snippets/semihost-tracing/snippet.yml | 6 ++ 3 files changed, 85 insertions(+) create mode 100644 snippets/semihost-tracing/README.rst create mode 100644 snippets/semihost-tracing/semihost-tracing.conf create mode 100644 snippets/semihost-tracing/snippet.yml 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 From 255afb44441fd06e04e497271925cd33f3867aa2 Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Sun, 5 Oct 2025 07:00:20 -0400 Subject: [PATCH 17/19] tracing: ctf: do not use signal as an argument Violates coding guideline rule 21.2 Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 9508f570b4ed2..fb177d037c51c 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -1029,31 +1029,31 @@ 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_init(struct k_poll_signal *sig) { ctf_top_poll_signal_init( - (uint32_t)(uintptr_t)signal + (uint32_t)(uintptr_t)sig ); } -void sys_trace_k_poll_api_signal_reset(struct k_poll_signal *signal) +void sys_trace_k_poll_api_signal_reset(struct k_poll_signal *sig) { ctf_top_poll_signal_reset( - (uint32_t)(uintptr_t)signal + (uint32_t)(uintptr_t)sig ); } -void sys_trace_k_poll_api_signal_check(struct k_poll_signal *signal) +void sys_trace_k_poll_api_signal_check(struct k_poll_signal *sig) { ctf_top_poll_signal_check( - (uint32_t)(uintptr_t)signal + (uint32_t)(uintptr_t)sig ); } -void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *signal, int ret) +void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *sig, int ret) { ctf_top_poll_signal_raise( - (uint32_t)(uintptr_t)signal, + (uint32_t)(uintptr_t)sig, (int32_t)ret ); } From 34c6e2485e673f401d7e2be8e13628328da1592b Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Sun, 5 Oct 2025 07:04:46 -0400 Subject: [PATCH 18/19] tracing: fix various style issues run clang-format and fix various checkpatch issues. Signed-off-by: Anas Nashif --- subsys/tracing/ctf/ctf_top.c | 851 ++++++------------- subsys/tracing/ctf/ctf_top.h | 312 ++++--- subsys/tracing/ctf/tracing_ctf.h | 581 ++++++------- subsys/tracing/sysview/tracing_sysview.h | 183 ++-- subsys/tracing/tracing_backend_semihosting.c | 16 +- tests/subsys/tracing/tracing_api/src/main.c | 2 +- 6 files changed, 758 insertions(+), 1187 deletions(-) diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index fb177d037c51c..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,20 @@ 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 */ @@ -203,42 +178,30 @@ void sys_trace_k_thread_foreach_unlocked_enter(void) ctf_top_thread_foreach_unlocked_enter(); } -void sys_trace_k_thread_foreach_unlocked_exit() +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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) @@ -278,7 +241,7 @@ void sys_trace_k_thread_yield(void) void sys_trace_k_thread_suspend_exit(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_exit((uint32_t)(uintptr_t)thread, name); @@ -296,7 +259,7 @@ void sys_trace_k_thread_sched_unlock(void) void sys_trace_k_thread_sched_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_sched_wakeup((uint32_t)(uintptr_t)thread, name); @@ -304,7 +267,7 @@ void sys_trace_k_thread_sched_wakeup(struct k_thread *thread) void sys_trace_k_thread_sched_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_sched_abort((uint32_t)(uintptr_t)thread, name); @@ -312,7 +275,7 @@ 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) { - ctf_bounded_string_t name = { "unknown" }; + 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); @@ -320,7 +283,7 @@ 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) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_sched_ready((uint32_t)(uintptr_t)thread, name); @@ -328,7 +291,7 @@ void sys_trace_k_thread_sched_ready(struct k_thread *thread) void sys_trace_k_thread_sched_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_sched_pend((uint32_t)(uintptr_t)thread, name); @@ -336,7 +299,7 @@ void sys_trace_k_thread_sched_pend(struct k_thread *thread) void sys_trace_k_thread_sched_resume(struct k_thread *thread) { - ctf_bounded_string_t name = { "unknown" }; + ctf_bounded_string_t name = {"unknown"}; _get_thread_name(thread, &name); ctf_top_thread_sched_resume((uint32_t)(uintptr_t)thread, name); @@ -344,7 +307,7 @@ void sys_trace_k_thread_sched_resume(struct k_thread *thread) void sys_trace_k_thread_sched_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_sched_suspend((uint32_t)(uintptr_t)thread, name); @@ -386,668 +349,479 @@ void sys_trace_idle_exit(void) 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 - ); + 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) - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) - ); + 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) - ); + 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) - ); + 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 - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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) - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) - ); + 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 - ); + 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 - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) - ); + 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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) +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) - ); + 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) +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 - ); + 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) - ); + 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 - ); + 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) +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) - ); + 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) +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 - ); + (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) - ); + 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 - ); + 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) +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 - ); + 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) +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 - ); + 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 - ); + 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 - ); + 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) +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 - ); + 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) +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 - ); + 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_work_poll_init_enter( - (uint32_t)(uintptr_t)work - ); + 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 - ); + 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) +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) - ); + 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) +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) - ); + 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) +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 - ); + (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) - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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 - ); + 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) @@ -1058,158 +832,111 @@ void sys_trace_k_poll_api_signal_raise(struct k_poll_signal *sig, int ret) ); } - /* Semaphore */ void sys_trace_k_sem_init(struct k_sem *sem, int ret) { - ctf_top_semaphore_init( - (uint32_t)(uintptr_t)sem, - (int32_t)ret - ); + 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) - ); + 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 */ @@ -1242,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)); } @@ -1257,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); } @@ -1283,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; } @@ -1306,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, @@ -1323,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++) { @@ -1332,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); @@ -1347,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) { @@ -1384,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; @@ -1392,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); @@ -1447,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) @@ -1476,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); } @@ -1492,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); } @@ -1510,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) @@ -1536,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) @@ -1554,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) @@ -1580,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) @@ -1608,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) @@ -1797,65 +1506,53 @@ 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) { - ctf_top_mbox_message_put_enter((uint32_t)(uintptr_t)mbox, - (uint32_t)timeout.ticks); + 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); + 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, + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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) @@ -1879,14 +1576,18 @@ void sys_trace_k_event_post_exit(struct k_event *event, uint32_t events, uint32_ 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) +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); + 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) +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); + 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) diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index 53b985ab27b86..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. @@ -208,7 +205,7 @@ typedef enum { 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_PEEK = 0x90, CTF_EVENT_MSGQ_PURGE = 0x91, CTF_EVENT_MSGQ_PUT_FRONT_ENTER = 0x92, CTF_EVENT_MSGQ_PUT_FRONT_EXIT = 0x93, @@ -345,25 +342,20 @@ 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) @@ -376,93 +368,75 @@ 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() +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() +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() +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() +static inline void ctf_top_thread_foreach_unlocked_exit(void) { CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_THREAD_FOREACH_UNLOCKED_EXIT)); } @@ -547,7 +521,8 @@ static inline void ctf_top_thread_sched_abort(uint32_t thread_id, ctf_bounded_st 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) +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); } @@ -692,7 +667,7 @@ static inline void ctf_top_msgq_put_front_enter(uint32_t msgq_id, uint32_t timeo 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) +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); } @@ -757,9 +732,11 @@ static inline void ctf_top_work_submit_to_queue_enter(uint32_t queue_id, uint32_ 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) +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); + 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) @@ -869,14 +846,18 @@ 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) +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); + 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) +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); + 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) @@ -889,14 +870,18 @@ static inline void ctf_top_work_schedule_exit(uint32_t dwork_id, uint32_t delay, 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) +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); + 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) +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); + 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) @@ -914,9 +899,11 @@ static inline void ctf_top_work_flush_delayable_enter(uint32_t dwork_id, uint32_ 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) +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); + 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) @@ -931,12 +918,15 @@ static inline void ctf_top_work_cancel_delayable_exit(uint32_t dwork_id, int32_t 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); + 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) +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); + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_WORK_CANCEL_DELAYABLE_SYNC_EXIT), dwork_id, + sync_id, ret); } /* Poll Work */ @@ -950,19 +940,25 @@ 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) +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); + 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) +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); + 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) +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); + 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) @@ -1022,8 +1018,7 @@ static inline void ctf_top_poll_signal_raise(uint32_t signal_id, int32_t 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); } @@ -1033,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) @@ -1072,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) @@ -1136,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); } @@ -1173,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); @@ -1203,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) @@ -1222,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) @@ -1234,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, @@ -1299,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) @@ -1323,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) @@ -1335,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) @@ -1354,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 */ @@ -1618,7 +1593,8 @@ 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) +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); } @@ -1628,14 +1604,18 @@ static inline void ctf_top_event_post_exit(uint32_t event_id, uint32_t events, u 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) +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); + 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) +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); + 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) diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index 8e27bec9d8228..c6610d0aed1db 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -15,68 +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() \ - 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_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_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_heap_assign(thread, heap) \ sys_trace_k_thread_heap_assign(thread, heap) -#define sys_port_trace_k_thread_join_enter(thread, timeout) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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_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() @@ -84,197 +65,153 @@ 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) \ - 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) \ +#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_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_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_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_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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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_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_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) \ - 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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) @@ -346,63 +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) \ - 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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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_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) @@ -438,37 +360,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) \ - sys_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_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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) @@ -504,16 +421,12 @@ 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_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_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_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); @@ -557,7 +470,6 @@ void sys_trace_k_mem_slab_alloc_exit(struct k_mem_slab *slab, k_timeout_t timeou 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); @@ -615,27 +527,40 @@ 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_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_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_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); +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_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); @@ -664,18 +589,15 @@ 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); @@ -699,84 +621,68 @@ void sys_trace_k_mbox_data_get(struct k_mbox_msg *rx_msg); 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_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 @@ -818,8 +724,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); @@ -832,18 +738,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/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index 13ad1d9ea4f2a..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, timeout) \ - SEGGER_SYSVIEW_RecordU32x2(TID_CONDVAR_WAIT, (uint32_t)(uintptr_t)condvar, (uint32_t)timeout.ticks) +#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, timeout, 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,116 +494,115 @@ 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) - /* Stack Operations */ -#define sys_port_trace_k_stack_init(stack) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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_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_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) \ +#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) \ +#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) \ +#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) \ +#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_alloc_init_exit(msgq, ret) SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_INIT) -#define sys_port_trace_k_msgq_cleanup_enter(msgq) \ +#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_cleanup_exit(msgq, ret) SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_CLEANUP) -#define sys_port_trace_k_msgq_put_enter(msgq, timeout) \ +#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_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_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_put_front_exit(msgq, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_PUT_FRONT) -#define sys_port_trace_k_msgq_get_enter(msgq, timeout) \ +#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_get_exit(msgq, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCall(TID_MSGQ_GET) -#define sys_port_trace_k_msgq_peek(msgq, ret) \ +#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) \ +#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) \ +#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) \ +#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_message_put_exit(mbox, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_PUT) -#define sys_port_trace_k_mbox_put_enter(mbox, timeout) \ +#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) \ +#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_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) \ +#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) \ +#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_get_exit(mbox, timeout, ret) \ SEGGER_SYSVIEW_RecordEndCall(TID_MBOX_GET) -#define sys_port_trace_k_mbox_data_get(rx_msg) \ +#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) @@ -633,21 +632,23 @@ 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_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_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) \ +#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_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) \ @@ -717,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) @@ -732,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); @@ -755,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/tracing_backend_semihosting.c b/subsys/tracing/tracing_backend_semihosting.c index 405fbe19e845e..117402173a0cd 100644 --- a/subsys/tracing/tracing_backend_semihosting.c +++ b/subsys/tracing/tracing_backend_semihosting.c @@ -12,9 +12,8 @@ static int tracing_fd = -1; -static void tracing_backend_semihost_output( - const struct tracing_backend *backend, - uint8_t *data, uint32_t length) +static void tracing_backend_semihost_output(const struct tracing_backend *backend, uint8_t *data, + uint32_t length) { semihost_write(tracing_fd, data, length); } @@ -22,16 +21,15 @@ static void tracing_backend_semihost_output( 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) { + __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 -}; + .init = tracing_backend_semihost_init, .output = tracing_backend_semihost_output}; TRACING_BACKEND_DEFINE(tracing_backend_semihost, tracing_backend_semihost_api); diff --git a/tests/subsys/tracing/tracing_api/src/main.c b/tests/subsys/tracing/tracing_api/src/main.c index e1c7a8e30724a..e42a4832337d5 100644 --- a/tests/subsys/tracing/tracing_api/src/main.c +++ b/tests/subsys/tracing/tracing_api/src/main.c @@ -170,7 +170,7 @@ 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,timeout); + 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); From b799802f3a19723384b36d7af7f07fd788562cad Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Mon, 6 Oct 2025 06:32:08 -0400 Subject: [PATCH 19/19] manifest: update percepio sha with fix for condvar Fix k_condvar arguments in percepio module. Signed-off-by: Anas Nashif --- west.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/west.yml b/west.yml index 622c0183aa8be..8fe30eaf305ff 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: 132ed87d617578a6cb70a2443f43e117c315e0f0 groups: - debug - name: picolibc