debug_stream: text_msg: Set exception dump hooks if available

Set exception dump hooks if CONFIG_EXCEPTION_DUMP_HOOK=y. This enables
sending a simple text report of fatal exceptions. To get this working
one needs these config options:

CONFIG_EXCEPTION_DUMP_HOOK=y
CONFIG_EXCEPTION_DUMP_HOOK_ONLY=y
CONFIG_SOF_DEBUG_STREAM_SLOT=y
CONFIG_SOF_DEBUG_STREAM_TEXT_MSG=y
CONFIG_SOF_DEBUG_STREAM_SLOT_NUMBER=2
CONFIG_SOF_TELEMETRY=n
CONFIG_SOF_TELEMETRY_PERFORMANCE_MEASUREMENTS=n
CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS=n

If system hangs and the exception is reported successfully the report
can be seen with debug_stream.py (which should be installed in the
same directory with cavstool.py). It does not matter if the tool was
not running at the time. The report should be available there in the
debug slot window for debug_stream.py to decode as long as system
remains up. The report should look something like this:

CPU 2:
FATAL EXCEPTION
CPU 2 EXCCAUSE 63 (zephyr exception)
 PC 0xa003048b VADDR 0xa0031020
 PS 0x60220
   (INTLEVEL:0 EXCM: 0 UM:1 RING:0 WOE:1 OWB:2 CALLINC:2)
 A0 0xa006c2b8  SP 0xa00dd160  A2 0x4  A3 0xa00dd170
 A4 0xa00dd150  A5 0x4  A6 0x6  A7 0x4
 A8 0xa006c109  A9 0xa00dd0f0 A10 0xa00a697d A11 0xa00dd170
A12 0xa00dd150 A13 0x4 A14 0x401a6b24 A15 0x401a6b24
LBEG 0xa0044323 LEND 0xa0044330 LCOUNT 0xa006de66
SAR 0x4
 THREADPTR (nil)
BT 0xa0030488:0xa00dd160 CORRUPTED

Signed-off-by: Jyri Sarha <jyri.sarha@linux.intel.com>

src/audio/host-zephyr.c: HACK assert(0) at the begin of host_get_copy_bytes_normal()

Author: Jyri Sarha

src/audio/host-zephyr.c

@@ -432,6 +432,7 @@ static uint32_t host_get_copy_bytes_normal(struct host_data *hd, struct comp_dev
 	uint32_t dma_copy_bytes;
 	int ret;
 
+	assert(0);
 	/* get data sizes from DMA */
 	ret = host_get_status(dev, hd, &dma_stat);
 	if (ret < 0) {

src/debug/debug_stream/debug_stream_text_msg.c

@@ -8,9 +8,13 @@
 #include <soc.h>
 #include <adsp_debug_window.h>
 #include <sof/common.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/arch/exception.h>
 
 #include <user/debug_stream_text_msg.h>
 
+LOG_MODULE_REGISTER(debug_stream_text_msg);
+
 void ds_msg(const char *format, ...)
 {
 	va_list args;
@@ -33,3 +37,98 @@ void ds_msg(const char *format, ...)
 						  sizeof(buf.msg.hdr.data[0]));
 	debug_stream_slot_send_record(&buf.msg.hdr);
 }
+
+#if defined(CONFIG_EXCEPTION_DUMP_HOOK)
+/* The debug stream debug window slot is 4k, and when it is split
+ * between the cores and the header/other overhead is removed, with 5
+ * cores the size is 768 bytes. The dump record must be smaller than
+ * that to get through to the host side.
+ *
+ * Also, because of the limited circular buffer size, we should only
+ * send one exception record. Exceptions often happen in bursts in a
+ * SOF system, and sending more than one record makes the host-side
+ * decoder lose track of things.
+ */
+static struct {
+	struct debug_stream_text_msg msg;
+	char text[640];
+} __packed ds_buf[CONFIG_MP_MAX_NUM_CPUS];
+static int reports_sent_cpu[CONFIG_MP_MAX_NUM_CPUS];
+static size_t ds_pos[CONFIG_MP_MAX_NUM_CPUS];
+
+static void ds_exception_drain(bool flush)
+{
+	unsigned int cpu = arch_proc_id();
+
+	if (flush) {
+		ds_pos[cpu] = 0;
+		reports_sent_cpu[cpu] = 0;
+		return;
+	}
+
+	if (ds_pos[cpu] == 0)
+		return;
+
+	if (reports_sent_cpu[cpu] > 0)
+		return;
+
+	ds_buf[cpu].msg.hdr.id = DEBUG_STREAM_RECORD_ID_TEXT_MSG;
+	ds_buf[cpu].msg.hdr.size_words =
+		SOF_DIV_ROUND_UP(sizeof(ds_buf[cpu].msg) + ds_pos[cpu],
+				 sizeof(ds_buf[cpu].msg.hdr.data[0]));
+	/* Make sure the possible up to 3 extra bytes at end of msg are '\0' */
+	memset(ds_buf[cpu].text + ds_pos[cpu], 0,
+	       ds_buf[cpu].msg.hdr.size_words * sizeof(ds_buf[cpu].msg.hdr.data[0]) - ds_pos[cpu]);
+	debug_stream_slot_send_record(&ds_buf[cpu].msg.hdr);
+	reports_sent_cpu[cpu] = 1;
+	ds_pos[cpu] = 0;
+}
+
+static void ds_exception_dump(const char *format, va_list args)
+{
+	ssize_t len;
+	size_t avail;
+	size_t written;
+	unsigned int cpu = arch_proc_id();
+
+	if (reports_sent_cpu[cpu] > 0)
+		return;
+
+	avail = sizeof(ds_buf[cpu].text) - ds_pos[cpu];
+	if (avail == 0) {
+		ds_exception_drain(false);
+		return;
+	}
+
+	if (format[0] == '\0')
+		return;
+
+	len = vsnprintf(ds_buf[cpu].text + ds_pos[cpu], avail, format, args);
+	if (len < 0) {
+		ds_pos[cpu] = 0;
+		return;
+	}
+
+	if (len == 0)
+		return;
+
+	if ((size_t)len >= avail)
+		written = avail - 1;
+	else
+		written = (size_t)len;
+
+	ds_pos[cpu] += written;
+
+	if (ds_pos[cpu] >= sizeof(ds_buf[cpu].text))
+		ds_exception_drain(false);
+}
+
+static int init_exception_dump_hook(void)
+{
+	set_exception_dump_hook(ds_exception_dump, ds_exception_drain);
+	LOG_INF("exception_dump_hook set");
+	return 0;
+}
+
+SYS_INIT(init_exception_dump_hook, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);
+#endif