schedule: limit schedule_free() to testing only

schedule_free() is only called from testbench and stand-alone ztest.
Remove it and all scheduler .scheduler_free() methods for all other
builds. Also fix memory leaks in the Zephyr LL version.

Signed-off-by: Guennadi Liakhovetski <guennadi.liakhovetski@linux.intel.com>

Author: lyakh

src/include/sof/schedule/schedule.h

@@ -140,6 +140,7 @@ struct scheduler_ops {
 	 */
 	int (*schedule_task_free)(void *data, struct task *task);
 
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 	/**
 	 * Frees scheduler's resources.
 	 * @param data Private data of selected scheduler.
@@ -149,6 +150,7 @@ struct scheduler_ops {
 	 * This operation is optional.
 	 */
 	void (*scheduler_free)(void *data, uint32_t flags);
+#endif
 
 	/**
 	 * Initializes context
@@ -309,6 +311,8 @@ static inline int schedule_task_free(struct task *task)
 	return sch->ops->schedule_task_free(sch->data, task);
 }
 
+/* Only used in a stand-alone test and in a testbench test */
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 /** See scheduler_ops::scheduler_free */
 static inline void schedule_free(uint32_t flags)
 {
@@ -322,6 +326,7 @@ static inline void schedule_free(uint32_t flags)
 			sch->ops->scheduler_free(sch->data, flags);
 	}
 }
+#endif
 
 /** See scheduler_ops::scheduler_init_context */
 static inline struct k_thread *scheduler_init_context(struct task *task)

src/platform/library/schedule/edf_schedule.c

@@ -49,10 +49,12 @@ static int schedule_edf_task(void *data, struct task *task, uint64_t start,
 	return 0;
 }
 
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 static void edf_scheduler_free(void *data, uint32_t flags)
 {
 	free(data);
 }
+#endif
 
 static int schedule_edf_task_cancel(void *data, struct task *task)
 {
@@ -83,7 +85,9 @@ static struct scheduler_ops schedule_edf_ops = {
 	.reschedule_task	= NULL,
 	.schedule_task_cancel	= schedule_edf_task_cancel,
 	.schedule_task_free	= schedule_edf_task_free,
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 	.scheduler_free		= edf_scheduler_free,
+#endif
 };
 
 int schedule_task_init_edf(struct task *task, const struct sof_uuid_entry *uid,

src/platform/library/schedule/ll_schedule.c

@@ -66,10 +66,12 @@ static int schedule_ll_task(void *data, struct task *task, uint64_t start,
 	return 0;
 }
 
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 static void ll_scheduler_free(void *data, uint32_t flags)
 {
 	free(data);
 }
+#endif
 
 /* TODO: scheduler free and cancel APIs can merge as part of Zephyr */
 static int schedule_ll_task_cancel(void *data, struct task *task)
@@ -96,7 +98,9 @@ static struct scheduler_ops schedule_ll_ops = {
 	.reschedule_task	= NULL,
 	.schedule_task_cancel	= schedule_ll_task_cancel,
 	.schedule_task_free	= schedule_ll_task_free,
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 	.scheduler_free		= ll_scheduler_free,
+#endif
 };
 
 int schedule_task_init_ll(struct task *task,

src/schedule/ll_schedule_xtos.c

@@ -724,6 +724,7 @@ static int reschedule_ll_task(void *data, struct task *task, uint64_t start)
 }
 #endif
 
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 static void scheduler_free_ll(void *data, uint32_t flags)
 {
 	struct ll_schedule_data *sch = data;
@@ -739,6 +740,7 @@ static void scheduler_free_ll(void *data, uint32_t flags)
 
 	irq_local_enable(irq_flags);
 }
+#endif
 
 static void ll_scheduler_recalculate_tasks(struct ll_schedule_data *sch,
 					   struct clock_notify_data *clk_data)
@@ -807,6 +809,8 @@ static const struct scheduler_ops schedule_ll_ops = {
 	.schedule_task_free	= schedule_ll_task_free,
 	.schedule_task_cancel	= schedule_ll_task_cancel,
 	.reschedule_task	= reschedule_ll_task,
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 	.scheduler_free		= scheduler_free_ll,
+#endif
 	.schedule_task_running	= NULL,
 };

src/schedule/zephyr_ll.c

@@ -546,25 +546,28 @@ static int zephyr_ll_task_cancel(void *data, struct task *task)
 	return 0;
 }
 
-/*
- * Runs on secondary cores in their shutdown sequence. In theory tasks can still
- * be active, but other schedulers ignore them too... And we don't need to free
- * the scheduler data - it's allocated in the SYS zone.
- */
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 static void zephyr_ll_scheduler_free(void *data, uint32_t flags)
 {
 	struct zephyr_ll *sch = data;
 
 	zephyr_ll_assert_core(sch);
 
+#if CONFIG_SOF_USERSPACE_LL
+	zephyr_ll_locks[sch->core] = NULL;
+	k_object_free(sch->lock);
+#endif
+
 	if (sch->n_tasks)
 		tr_err(&ll_tr, "%u tasks are still active!",
 		       sch->n_tasks);
 
 #if CONFIG_SOF_USERSPACE_LL
 	domain_thread_free(sch->ll_domain, sch->n_tasks);
 #endif
+	sof_heap_free(sch->heap, sch);
 }
+#endif
 
 #if CONFIG_SOF_USERSPACE_LL
 struct k_thread *zephyr_ll_init_context(void *data, struct task *task)
@@ -601,7 +604,9 @@ static const struct scheduler_ops zephyr_ll_ops = {
 	.schedule_task_after	= zephyr_ll_task_schedule_after,
 	.schedule_task_free	= zephyr_ll_task_free,
 	.schedule_task_cancel	= zephyr_ll_task_cancel,
+#if CONFIG_SOF_BOOT_TEST_STANDALONE || CONFIG_LIBRARY
 	.scheduler_free		= zephyr_ll_scheduler_free,
+#endif
 #if CONFIG_SOF_USERSPACE_LL
 	.scheduler_init_context	= zephyr_ll_init_context,
 #endif