xtos: heap: check all SYS_ allocations

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 <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

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;

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");
+		return -ENOMEM;
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);

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");
+		return -ENOMEM;
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);

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");
+		return -ENOMEM;
+	}
 	ipc_set_drvdata(ipc, iipc);
 #else
 	ipc_set_drvdata(ipc, NULL);

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;

src/lib/pm_runtime.c

@@ -33,6 +33,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);
@@ -149,6 +153,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();

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;

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;

src/schedule/edf_schedule.c

@@ -258,6 +258,11 @@ int scheduler_init_edf(void)
 
 	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;
 

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;