xtos: heap: check all SYS_ allocations

lrgirdwo · lgirdwood · commit b35aba350118 · 2025-07-10T21:04:24.000+01:00
Previously with xtos config the linker would reserve a guaranteed heap
for init system allocations that were all guaranteed to succeed. These
allocations never failed with Zephyr as they were all done at early boot.

Be more mindful and check in the unlikely result of a failure.
e.g. a Kconfig with heapsize == 0

Signed-off-by: Liam Girdwood &lt;liam.r.girdwood@linux.intel.com&gt;
diff --git a/src/audio/base_fw_intel.c b/src/audio/base_fw_intel.c
@@ -183,6 +183,10 @@ __cold static int basefw_mem_state_info(uint32_t *data_offset, char *data)
 	size = ALIGN(size, 4);
 	/* size is also saved as tuple length */
 	tuple_data = rballoc(SOF_MEM_FLAG_USER, size);
+	if (!tuple_data) {
+		LOG_ERR("basefw_mem_state_info(): allocation failed");
+		return IPC4_ERROR_INVALID_PARAM;
+	}
 
 	/* save memory info in data array since info length is variable */
 	index = 0;
diff --git a/src/drivers/imx/ipc.c b/src/drivers/imx/ipc.c
@@ -202,8 +202,9 @@ int platform_ipc_init(struct ipc *ipc)
 	/* allocate page table buffer */
 	iipc->dh_buffer.page_table = rzalloc(SOF_MEM_FLAG_USER,
 					     PLATFORM_PAGE_TABLE_SIZE);
-	if (iipc->dh_buffer.page_table)
-		bzero(iipc->dh_buffer.page_table, PLATFORM_PAGE_TABLE_SIZE);
+	if (!iipc->dh_buffer.page_table)
+		sof_panic(SOF_IPC_PANIC_IPC);
+	bzero(iipc->dh_buffer.page_table, PLATFORM_PAGE_TABLE_SIZE);
 #if CONFIG_ZEPHYR_NATIVE_DRIVERS
 	iipc->dh_buffer.dmac = sof_dma_get(SOF_DMA_DIR_HMEM_TO_LMEM, 0, SOF_DMA_DEV_HOST,
 					   SOF_DMA_ACCESS_SHARED);
diff --git a/src/drivers/interrupt.c b/src/drivers/interrupt.c
@@ -74,6 +74,11 @@ int interrupt_cascade_register(const struct irq_cascade_tmpl *tmpl)
 	}
 
 	*cascade = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(**cascade));
+	if (!*cascade) {
+		ret = -ENOMEM;
+		tr_err(&irq_tr, "cascading IRQ controller allocation failed!");
+		goto unlock;
+	}
 
 	k_spinlock_init(&(*cascade)->lock);
 
diff --git a/src/drivers/mediatek/mt818x/ipc.c b/src/drivers/mediatek/mt818x/ipc.c
@@ -128,6 +128,10 @@ int platform_ipc_init(struct ipc *ipc)
 	struct ipc_data *iipc;
 
 	iipc = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*iipc));
+	if (!iipc) {
+		tr_err(&ipc_tr, "Unable to allocate memory for IPC data");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);
@@ -143,6 +147,10 @@ int platform_ipc_init(struct ipc *ipc)
 	/* allocate page table buffer */
 	iipc->dh_buffer.page_table =
 		rzalloc(SOF_MEM_FLAG_KERNEL, PLATFORM_PAGE_TABLE_SIZE);
+	if (!iipc->dh_buffer.page_table) {
+		tr_err(&ipc_tr, "Unable to allocate host page table buffer");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	iipc->dh_buffer.dmac = dma_get(DMA_DIR_HMEM_TO_LMEM, 0, DMA_DEV_HOST, DMA_ACCESS_SHARED);
 	if (!iipc->dh_buffer.dmac) {
diff --git a/src/drivers/mediatek/mt8195/ipc.c b/src/drivers/mediatek/mt8195/ipc.c
@@ -127,6 +127,10 @@ int platform_ipc_init(struct ipc *ipc)
 	struct ipc_data *iipc;
 
 	iipc = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*iipc));
+	if (!iipc) {
+		tr_err(&ipc_tr, "Unable to allocate memory for IPC data");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);
@@ -141,6 +145,10 @@ int platform_ipc_init(struct ipc *ipc)
 	/* allocate page table buffer */
 	iipc->dh_buffer.page_table =
 		rzalloc(SOF_MEM_FLAG_KERNEL, PLATFORM_PAGE_TABLE_SIZE);
+	if (!iipc->dh_buffer.page_table) {
+		tr_err(&ipc_tr, "Unable to allocate host page table buffer");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	iipc->dh_buffer.dmac = dma_get(DMA_DIR_HMEM_TO_LMEM, 0, DMA_DEV_HOST, DMA_ACCESS_SHARED);
 	if (!iipc->dh_buffer.dmac) {
diff --git a/src/drivers/mediatek/mt8196/ipc.c b/src/drivers/mediatek/mt8196/ipc.c
@@ -127,6 +127,10 @@ int platform_ipc_init(struct ipc *ipc)
 	struct ipc_data *iipc;
 
 	iipc = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*iipc));
+	if (!iipc) {
+		tr_err(&ipc_tr, "Unable to allocate memory for IPC data");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);
@@ -142,6 +146,10 @@ int platform_ipc_init(struct ipc *ipc)
 	/* allocate page table buffer */
 	iipc->dh_buffer.page_table =
 		rzalloc(SOF_MEM_FLAG_KERNEL, PLATFORM_PAGE_TABLE_SIZE);
+	if (!iipc->dh_buffer.page_table) {
+		tr_err(&ipc_tr, "Unable to allocate host page table buffer");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	iipc->dh_buffer.dmac = dma_get(DMA_DIR_HMEM_TO_LMEM, 0, DMA_DEV_HOST, DMA_ACCESS_SHARED);
 	if (!iipc->dh_buffer.dmac) {
diff --git a/src/drivers/mediatek/mt8365/ipc.c b/src/drivers/mediatek/mt8365/ipc.c
@@ -143,7 +143,7 @@ int platform_ipc_init(struct ipc *ipc)
 	iipc = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*iipc));
 	if (!iipc) {
 		tr_err(&ipc_tr, "Unable to allocate IPC private data");
-		return -ENOMEM;
+		sof_panic(SOF_IPC_PANIC_IPC);
 	}
 	ipc_set_drvdata(ipc, iipc);
 #else
@@ -159,6 +159,10 @@ int platform_ipc_init(struct ipc *ipc)
 	/* allocate page table buffer */
 	iipc->dh_buffer.page_table =
 		rzalloc(SOF_MEM_FLAG_KERNEL, PLATFORM_PAGE_TABLE_SIZE);
+	if (!iipc->dh_buffer.page_table) {
+		tr_err(&ipc_tr, "Unable to allocate host page table buffer");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	iipc->dh_buffer.dmac = dma_get(DMA_DIR_HMEM_TO_LMEM, 0, DMA_DEV_HOST, DMA_ACCESS_SHARED);
 	if (!iipc->dh_buffer.dmac) {
diff --git a/src/include/sof/schedule/ll_schedule_domain.h b/src/include/sof/schedule/ll_schedule_domain.h
@@ -99,6 +99,8 @@ static inline struct ll_schedule_domain *domain_init
 	struct ll_schedule_domain *domain;
 
 	domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*domain));
+	if (!domain)
+		return NULL;
 	domain->type = type;
 	domain->clk = clk;
 	domain->synchronous = synchronous;
diff --git a/src/ipc/ipc-common.c b/src/ipc/ipc-common.c
@@ -293,8 +293,17 @@ __cold int ipc_init(struct sof *sof)
 
 	/* init ipc data */
 	sof->ipc = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT, sizeof(*sof->ipc));
+	if (!sof->ipc) {
+		tr_err(&ipc_tr, "Unable to allocate IPC data");
+		return -ENOMEM;
+	}
 	sof->ipc->comp_data = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
 				      SOF_IPC_MSG_MAX_SIZE);
+	if (!sof->ipc->comp_data) {
+		tr_err(&ipc_tr, "Unable to allocate IPC component data");
+		rfree(sof->ipc);
+		return -ENOMEM;
+	}
 
 	k_spinlock_init(&sof->ipc->lock);
 	list_init(&sof->ipc->msg_list);
diff --git a/src/lib/dai.c b/src/lib/dai.c
@@ -43,6 +43,11 @@ __cold static struct dai_group_list *dai_group_list_get(int core_id)
 	if (!group_list) {
 		group_list = rzalloc(SOF_MEM_FLAG_USER,
 				     sizeof(*group_list));
+		if (!group_list) {
+			tr_err(&dai_tr, "dai_group_list_get(): failed to allocate group_list for core %d",
+			       core_id);
+			return NULL;
+		}
 
 		groups[core_id] = group_list;
 		list_init(&group_list->list);
@@ -54,12 +59,19 @@ __cold static struct dai_group_list *dai_group_list_get(int core_id)
 __cold static struct dai_group *dai_group_find(uint32_t group_id)
 {
 	struct list_item *dai_groups;
+	struct dai_group_list *group_list;
 	struct list_item *group_item;
 	struct dai_group *group = NULL;
 
 	assert_can_be_cold();
 
-	dai_groups = &dai_group_list_get(cpu_get_id())->list;
+	group_list = dai_group_list_get(cpu_get_id());
+	if (!group_list) {
+		tr_err(&dai_tr, "dai_group_find(): failed to get group_list for core %d",
+		       cpu_get_id());
+		return NULL;
+	}
+	dai_groups = &group_list->list;
 
 	list_for_item(group_item, dai_groups) {
 		group = container_of(group_item, struct dai_group, list);
@@ -75,13 +87,24 @@ __cold static struct dai_group *dai_group_find(uint32_t group_id)
 
 __cold static struct dai_group *dai_group_alloc(void)
 {
-	struct list_item *dai_groups = &dai_group_list_get(cpu_get_id())->list;
+	struct dai_group_list *group_list = dai_group_list_get(cpu_get_id());
+	struct list_item *dai_groups;
 	struct dai_group *group;
 
 	assert_can_be_cold();
+	if (!group_list) {
+		tr_err(&dai_tr, "dai_group_alloc(): failed to get group_list for core %d",
+		       cpu_get_id());
+		return NULL;
+	}
+	dai_groups = &group_list->list;
 
 	group = rzalloc(SOF_MEM_FLAG_USER,
 			sizeof(*group));
+	if (!group) {
+		tr_err(&dai_tr, "dai_group_alloc(): failed to allocate dai group");
+		return NULL;
+	}
 
 	list_item_prepend(&group->list, dai_groups);
 
diff --git a/src/lib/notifier.c b/src/lib/notifier.c
@@ -196,6 +196,10 @@ void init_system_notify(struct sof *sof)
 	int i;
 	*notify = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
 			  sizeof(**notify));
+	if (!*notify) {
+		tr_err(&nt_tr, "init_system_notify(): allocation failed");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	k_spinlock_init(&(*notify)->lock);
 	for (i = NOTIFIER_ID_CPU_FREQ; i < NOTIFIER_ID_COUNT; i++)
diff --git a/src/lib/pm_runtime.c b/src/lib/pm_runtime.c
@@ -31,6 +31,10 @@ DECLARE_TR_CTX(pm_tr, SOF_UUID(pm_runtime_uuid), LOG_LEVEL_INFO);
 void pm_runtime_init(struct sof *sof)
 {
 	sof->prd = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*sof->prd));
+	if (!sof->prd) {
+		tr_err(&pm_tr, "pm_runtime_init(): allocation failed");
+		return;
+	}
 	k_spinlock_init(&sof->prd->lock);
 
 	platform_pm_runtime_init(sof->prd);
@@ -147,6 +151,10 @@ void init_dsp_r_state(enum dsp_r_state r_state)
 	struct r_counters_data *r_counters;
 
 	r_counters = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*r_counters));
+	if (!r_counters) {
+		tr_err(&pm_tr, "init_dsp_r_state(): allocation failed");
+		return;
+	}
 	prd->r_counters = r_counters;
 
 	r_counters->ts = sof_cycle_get_64();
diff --git a/src/library_manager/lib_manager.c b/src/library_manager/lib_manager.c
@@ -448,6 +448,10 @@ static void lib_manager_update_sof_ctx(void *base_addr, uint32_t lib_id)
 	/* Never freed, will panic if fails */
 	struct lib_manager_mod_ctx *ctx = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT,
 						  sizeof(*ctx));
+	if (!ctx) {
+		tr_err(&lib_manager_tr, "lib_manager_update_sof_ctx(): allocation failed");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 
 	ctx->base_addr = base_addr;
 
diff --git a/src/probe/probe.c b/src/probe/probe.c
@@ -354,6 +354,10 @@ int probe_init(const struct probe_dma *probe_dma)
 	/* alloc probes main struct */
 	sof_get()->probe = rzalloc(SOF_MEM_FLAG_USER,
 				   sizeof(*_probe));
+	if (!sof_get()->probe) {
+		tr_err(&pr_tr, "probe_init(): Alloc failed.");
+		return -ENOMEM;
+	}
 	_probe = probe_get();
 
 	if (!_probe) {
diff --git a/src/schedule/dma_multi_chan_domain.c b/src/schedule/dma_multi_chan_domain.c
@@ -370,8 +370,17 @@ struct ll_schedule_domain *dma_multi_chan_domain_init(struct dma *dma_array,
 
 	domain = domain_init(SOF_SCHEDULE_LL_DMA, clk, true,
 			     &dma_multi_chan_domain_ops);
+	if (!domain) {
+		tr_err(&ll_tr, "dma_multi_chan_domain_init(): domain init failed");
+		return NULL;
+	}
 
 	dma_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*dma_domain));
+	if (!dma_domain) {
+		tr_err(&ll_tr, "dma_multi_chan_domain_init(): allocation failed");
+		rfree(domain);
+		return NULL;
+	}
 	dma_domain->dma_array = dma_array;
 	dma_domain->num_dma = num_dma;
 	dma_domain->aggregated_irq = aggregated_irq;
diff --git a/src/schedule/dma_single_chan_domain.c b/src/schedule/dma_single_chan_domain.c
@@ -543,8 +543,17 @@ struct ll_schedule_domain *dma_single_chan_domain_init(struct dma *dma_array,
 
 	domain = domain_init(SOF_SCHEDULE_LL_DMA, clk, false,
 			     &dma_single_chan_domain_ops);
+	if (!domain) {
+		tr_err(&ll_tr, "dma_single_chan_domain_init(): domain init failed");
+		return NULL;
+	}
 
 	dma_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*dma_domain));
+	if (!dma_domain) {
+		tr_err(&ll_tr, "dma_single_chan_domain_init(): allocation failed");
+		rfree(domain);
+		return NULL;
+	}
 	dma_domain->dma_array = dma_array;
 	dma_domain->num_dma = num_dma;
 	dma_domain->owner = DMA_DOMAIN_OWNER_INVALID;
diff --git a/src/schedule/edf_schedule.c b/src/schedule/edf_schedule.c
@@ -253,11 +253,17 @@ static int schedule_edf_task_free(void *data, struct task *task)
 int scheduler_init_edf(void)
 {
 	struct edf_schedule_data *edf_sch;
+	int ret;
 
 	tr_info(&edf_tr, "edf_scheduler_init()");
 
 	edf_sch = rzalloc(SOF_MEM_FLAG_KERNEL,
 			  sizeof(*edf_sch));
+	if (!edf_sch) {
+		tr_err(&edf_tr, "scheduler_init_edf(): allocation failed");
+		return -ENOMEM;
+	}
+
 	list_init(&edf_sch->list);
 	edf_sch->clock = PLATFORM_DEFAULT_CLOCK;
 
@@ -267,15 +273,18 @@ int scheduler_init_edf(void)
 	task_main_init();
 
 	/* configure EDF scheduler interrupt */
-	edf_sch->irq = interrupt_get_irq(PLATFORM_SCHEDULE_IRQ,
-					 PLATFORM_SCHEDULE_IRQ_NAME);
-	if (edf_sch->irq < 0)
-		return edf_sch->irq;
+	ret = interrupt_get_irq(PLATFORM_SCHEDULE_IRQ,
+				PLATFORM_SCHEDULE_IRQ_NAME);
+	if (ret < 0) {
+		free(edf_sch);
+		return ret;
+	}
 
+	edf_sch->irq = ret;
 	interrupt_register(edf_sch->irq, edf_scheduler_run, edf_sch);
 	interrupt_enable(edf_sch->irq, edf_sch);
 
-	return 0;
+	return ret;
 }
 
 static void scheduler_free_edf(void *data, uint32_t flags)
diff --git a/src/schedule/ll_schedule.c b/src/schedule/ll_schedule.c
@@ -782,6 +782,10 @@ int scheduler_init_ll(struct ll_schedule_domain *domain)
 
 	/* initialize scheduler private data */
 	sch = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*sch));
+	if (!sch) {
+		tr_err(&ll_tr, "scheduler_init_ll(): allocation failed");
+		return -ENOMEM;
+	}
 	list_init(&sch->tasks);
 	atomic_init(&sch->num_tasks, 0);
 	sch->domain = domain;
diff --git a/src/schedule/schedule.c b/src/schedule/schedule.c
@@ -52,6 +52,10 @@ static void scheduler_register(struct schedule_data *scheduler)
 		/* init schedulers list */
 		*sch = rzalloc(SOF_MEM_FLAG_KERNEL,
 			       sizeof(**sch));
+		if (!*sch) {
+			tr_err(&sch_tr, "scheduler_register(): allocation failed");
+			return;
+		}
 		list_init(&(*sch)->list);
 	}
 
@@ -67,6 +71,10 @@ void scheduler_init(int type, const struct scheduler_ops *ops, void *data)
 		return;
 
 	sch = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*sch));
+	if (!sch) {
+		tr_err(&sch_tr, "scheduler_init(): allocation failed");
+		sof_panic(SOF_IPC_PANIC_IPC);
+	}
 	list_init(&sch->list);
 	sch->type = type;
 	sch->ops = ops;
diff --git a/src/schedule/task.c b/src/schedule/task.c
@@ -76,6 +76,8 @@ void task_main_init(void)
 
 	*main_task = rzalloc(SOF_MEM_FLAG_KERNEL,
 			     sizeof(**main_task));
+	if (!*main_task)
+		panic(SOF_IPC_PANIC_MEM);
 
 	ret = schedule_task_init_edf(*main_task, SOF_UUID(main_task_uuid),
 				     &ops, NULL, cpu, 0);
diff --git a/src/schedule/timer_domain.c b/src/schedule/timer_domain.c
@@ -158,8 +158,17 @@ struct ll_schedule_domain *timer_domain_init(struct timer *timer, int clk)
 
 	domain = domain_init(SOF_SCHEDULE_LL_TIMER, clk, false,
 			     &timer_domain_ops);
+	if (!domain) {
+		r_err(&ll_tr, "timer_domain_init(): domain init failed");
+		return NULL;
+	}
 
 	timer_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*timer_domain));
+	if (!timer_domain) {
+		tr_err(&ll_tr, "timer_domain_init(): allocation failed");
+		rfree(domain);
+		return NULL;
+	}
 	timer_domain->timer = timer;
 
 	ll_sch_domain_set_pdata(domain, timer_domain);
diff --git a/src/schedule/zephyr_dma_domain.c b/src/schedule/zephyr_dma_domain.c
diff --git a/src/schedule/zephyr_domain.c b/src/schedule/zephyr_domain.c
diff --git a/src/schedule/zephyr_ll.c b/src/schedule/zephyr_ll.c
diff --git a/src/trace/dma-trace.c b/src/trace/dma-trace.c
diff --git a/src/trace/trace.c b/src/trace/trace.c

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,11 @@ int interrupt_cascade_register(const struct irq_cascade_tmpl *tmpl)`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`cascade = rzalloc(SOF_MEM_FLAG_KERNEL \| SOF_MEM_FLAG_COHERENT, sizeof(*cascade));`
	`77`	`+ if (!*cascade) {`
	`78`	`+ ret = -ENOMEM;`
	`79`	`+ tr_err(&irq_tr, "cascading IRQ controller allocation failed!");`
	`80`	`+ goto unlock;`
	`81`	`+ }`
`77`	`82`
`78`	`83`	`k_spinlock_init(&(*cascade)->lock);`
`79`	`84`