Debug stream thread info pr

src/Kconfig

@@ -23,3 +23,5 @@ rsource "math/Kconfig"
 rsource "library_manager/Kconfig"
 
 rsource "debug/telemetry/Kconfig"
+
+rsource "debug/debug_stream/Kconfig"

src/debug/debug_stream/CMakeLists.txt

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+add_local_sources_ifdef(CONFIG_SOF_DEBUG_STREAM_SLOT sof debug_stream_slot.c)
+
+add_local_sources_ifdef(CONFIG_SOF_DEBUG_STREAM_THREAD_INFO sof debug_stream_thread_info.c)

src/debug/debug_stream/Kconfig

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+config SOF_DEBUG_STREAM_SLOT
+ bool "Enable SOF debug stream debug window slot"
+ help
+ Debug stream is an abstract stream of records of debug
+ information from SOF system that are streamed from SOF DSP
+ to the host side for decoding and presentation. This option
+ enables transferring the records from DSP to host over a
+ debug window slot.
+
+if SOF_DEBUG_STREAM_SLOT
+
+config SOF_DEBUG_STREAM_SLOT_NUMBER
+ int "Debug window slot where to put debug stream slot"
+ default 3
+ range 0 14
+ help
+ Which debug slot to reserve for Debug Stream. Remember to map
+ the slot with MEMORY_WIN_2_SIZE in soc/intel/intel_adsp/Kconfig,
+ in Zephyr source tree. The slots are 4k in size and one slot is
+ used for descriptors, so for slot 3 to be mapped, the WIN_2_SIZE
+ must be (1 + 3) * 4k = 16k or greater.
+
+config SOF_DEBUG_STREAM_THREAD_INFO
+ bool "Enable Zephyr thread info reporting through Debug-Stream"
+ select INIT_STACKS
+ select THREAD_MONITOR
+ select THREAD_STACK_INFO
+ select THREAD_RUNTIME_STATS
+ help
+ This activates Zephyr thread info reporting through
+ Debug-Stream. Thread info reports some basic live data from
+ the Zephyr threads, like stack usage high-water-mark and CPU
+ usage. Please select THREAD_NAME=y for the thread names more
+ than just hex numbers.
+
+config SOF_DEBUG_STREAM_THREAD_INFO_INTERVAL
+ int "Thread information collection interval in seconds"
+ depends on SOF_DEBUG_STREAM_THREAD_INFO
+ default 2
+ range 1 10
+ help
+ Decides how often thread info runs and checks execution cycle
+ statistics and stack usage.
+
+endif

src/debug/debug_stream/debug_stream_slot.c

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2024 Intel Corporation.
+
+#include <zephyr/logging/log.h>
+#include <zephyr/spinlock.h>
+#include <adsp_debug_window.h>
+#include <adsp_memory.h>
+#include <sof/common.h>
+#include <rtos/string.h>
+#include <user/debug_stream.h>
+#include <user/debug_stream_slot.h>
+
+LOG_MODULE_REGISTER(debug_strem_slot);
+
+struct cpu_mutex {
+ struct k_mutex m;
+} __aligned(CONFIG_DCACHE_LINE_SIZE);
+
+/* CPU specific mutexes for each circular buffer */
+static struct cpu_mutex cpu_mutex[CONFIG_MP_MAX_NUM_CPUS];
+
+static const int debug_stream_slot = CONFIG_SOF_DEBUG_STREAM_SLOT_NUMBER;
+
+static struct debug_stream_slot_hdr *debug_stream_get_slot(void)
+{
+ return (struct debug_stream_slot_hdr *)ADSP_DW->slots[debug_stream_slot];
+}
+
+static
+struct debug_stream_circular_buf *
+debug_stream_get_circular_buffer(struct debug_stream_section_descriptor *desc, unsigned int core)
+{
+ struct debug_stream_slot_hdr *hdr = debug_stream_get_slot();
+ void *ptr;
+
+ if (hdr->hdr.magic != DEBUG_STREAM_IDENTIFIER) {
+ LOG_ERR("Debug stream slot not initialized.");
+ return NULL;
+ }
+
+ *desc = hdr->section_desc[core];
+ LOG_DBG("Section %u (desc %u %u %u)", core, desc->core_id, desc->buf_words, desc->offset);
+
+ return (struct debug_stream_circular_buf *) (((uint8_t *)hdr) + desc->offset);
+}
+
+int debug_stream_slot_send_record(struct debug_stream_record *rec)
+{
+ struct debug_stream_section_descriptor desc;
+ struct debug_stream_circular_buf *buf =
+ debug_stream_get_circular_buffer(&desc, arch_proc_id());
+ uint32_t record_size = rec->size_words;
+ uint32_t record_start, buf_remain;
+
+ LOG_DBG("Sending record %u id %u len %u\n", rec->seqno, rec->id, rec->size_words);
+
+ if (!buf)
+ return -ENODEV;
+
+ if (rec->size_words >= desc.buf_words) {
+ LOG_ERR("Record too big %u >= %u (desc %u %u %u)", rec->size_words,
+ desc.buf_words, desc.core_id, desc.buf_words, desc.offset);
+ return -ENOMEM;
+ }
+ k_mutex_lock(&cpu_mutex[arch_proc_id()].m, K_FOREVER);
+
+ rec->seqno = buf->next_seqno++;
+ rec->size_words = record_size + 1; /* +1 for size at the end of record */
+ record_start = buf->w_ptr;
+ buf->w_ptr = (record_start + record_size) % desc.buf_words;
+ buf_remain = desc.buf_words - record_start;
+ if (buf_remain < record_size) {
+ uint32_t rec_remain = record_size - buf_remain;
+ int ret;
+
+ ret = memcpy_s(&buf->data[record_start], buf_remain * sizeof(uint32_t),
+ rec, buf_remain * sizeof(uint32_t));
+ assert(!ret);
+ ret = memcpy_s(&buf->data[0], desc.buf_words * sizeof(uint32_t),
+ ((uint32_t *) rec) + buf_remain, rec_remain * sizeof(uint32_t));
+ assert(!ret);
+ } else {
+ int ret;
+
+ ret = memcpy_s(&buf->data[record_start], buf_remain * sizeof(uint32_t),
+ rec, record_size * sizeof(uint32_t));
+ assert(!ret);
+ }
+ /* Write record size again after the record */
+ buf->data[buf->w_ptr] = record_size + 1;
+ buf->w_ptr = (buf->w_ptr + 1) % desc.buf_words;
+
+ k_mutex_unlock(&cpu_mutex[arch_proc_id()].m);
+
+ LOG_DBG("Record %u id %u len %u sent\n", rec->seqno, rec->id, record_size);
+ return 0;
+}
+
+static int debug_stream_slot_init(void)
+{
+ struct debug_stream_slot_hdr *hdr = debug_stream_get_slot();
+ size_t hdr_size = offsetof(struct debug_stream_slot_hdr,
+ section_desc[CONFIG_MP_MAX_NUM_CPUS]);
+ size_t section_area_size = ADSP_DW_SLOT_SIZE - hdr_size;
+ size_t section_size = ALIGN_DOWN(section_area_size /
+ CONFIG_MP_MAX_NUM_CPUS,
+ CONFIG_DCACHE_LINE_SIZE);
+ size_t offset = hdr_size;
+ int i;
+
+ LOG_INF("%u sections of %u bytes, hdr %u, secton area %u\n",
+ CONFIG_MP_MAX_NUM_CPUS, section_size, hdr_size,
+ section_area_size);
+
+ if (ADSP_DW->descs[debug_stream_slot].type != 0)
+ LOG_WRN("Slot %d was not free: %u", debug_stream_slot,
+ ADSP_DW->descs[debug_stream_slot].type);
+ ADSP_DW->descs[debug_stream_slot].type = ADSP_DW_SLOT_DEBUG_STREAM;
+
+ hdr->hdr.magic = DEBUG_STREAM_IDENTIFIER;
+ hdr->hdr.hdr_size = hdr_size;
+ hdr->total_size = hdr_size + CONFIG_MP_MAX_NUM_CPUS * section_size;
+ hdr->num_sections = CONFIG_MP_MAX_NUM_CPUS;
+ for (i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
+ hdr->section_desc[i].core_id = i;
+ hdr->section_desc[i].buf_words =
+ (section_size - offsetof(struct debug_stream_circular_buf, data[0]))/
+ sizeof(uint32_t);
+ hdr->section_desc[i].offset = offset;
+ LOG_INF("sections %u, size %u, offset %u\n",
+ i, section_size, offset);
+ offset += section_size;
+ }
+ for (i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
+ struct debug_stream_section_descriptor desc;
+ struct debug_stream_circular_buf *buf =
+ debug_stream_get_circular_buffer(&desc, i);
+
+ buf->next_seqno = 0;
+ buf->w_ptr = 0;
+ k_mutex_init(&cpu_mutex[i].m);
+ /* The core specific mutexes are now .dss which is uncached so the
+ * following line is commented out. However, since the mutexes are
+ * core specific there should be nothing preventing from having them
+ * in cached memory.
+ *
+ * sys_cache_data_flush_range(&cpu_mutex[i], sizeof(cpu_mutex[i]));
+ */
+ }
+ LOG_INF("Debug stream slot initialized\n");
+
+ return 0;
+}
+
+SYS_INIT(debug_stream_slot_init, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);