init worker from 0 core

Signed-off-by: Serhiy Katsyuba <serhiy.katsyuba@intel.com>

Author: serhiy-katsyuba-intel

src/audio/module_adapter/library/userspace_proxy.c

@@ -103,16 +103,15 @@ struct user_worker {
 	struct k_event event;
 };
 
-static struct user_worker worker[CONFIG_CORE_COUNT];
+static struct user_worker worker[CONFIG_CORE_COUNT] = { { 0 } };
 
-static int user_worker_get(int cpu)
+int user_worker_create(int cpu)
 {
-	int ret = 0;
-
+	assert(cpu_is_me(0));
 	assert(cpu >= 0 && cpu < (int)ARRAY_SIZE(worker));
 
-	if (worker[cpu].reference_count) {
-		worker[cpu].reference_count++;
+	if (worker[cpu].stack_ptr) {
+		tr_err(&userspace_proxy_tr, "Userspace worker already created for core %d.", cpu);
 		return 0;
 	}
 
@@ -130,45 +129,42 @@ static int user_worker_get(int cpu)
 	worker[cpu].thread_id = k_work_user_queue_thread_get(&worker[cpu].work_queue);
 
 #ifdef CONFIG_SCHED_CPU_MASK
-	/*
-	 * k_work_user_queue_start() starts the worker thread immediately.
-	 * We need to make sure it is not running when pinning it to a specific core.
-	 */
-	k_thread_suspend(worker[cpu].thread_id);
-
-	/* Pin worker thread to the same core as the module */
-	ret = k_thread_cpu_pin(worker[cpu].thread_id, cpu);
+	int ret = k_thread_cpu_pin(worker[cpu].thread_id, cpu);
 	if (ret) {
 		tr_err(&userspace_proxy_tr, "Failed to pin worker to core %d, error: %d",
 		       cpu, ret);
 		k_panic();
 	}
-
-	k_thread_resume(worker[cpu].thread_id);
-
 #elif CONFIG_CORE_COUNT > 1
 #error "CONFIG_SCHED_CPU_MASK is not enabled"
 #endif
 
 	k_thread_access_grant(worker[cpu].thread_id, &worker[cpu].event);
 
-	worker[cpu].reference_count++;
-
 	return 0;
 }
 
-static void user_worker_put(int cpu)
+void user_worker_free(int cpu)
 {
 	assert(cpu >= 0 && cpu < (int)ARRAY_SIZE(worker));
+	assert(worker[cpu].stack_ptr);
 
-	/* Module removed so decrement counter */
-	worker[cpu].reference_count--;
+	k_thread_abort(worker[cpu].thread_id);
+	user_stack_free(worker[cpu].stack_ptr);
+	worker[cpu].stack_ptr = NULL;
+}
 
-	/* Free worker resources if no more active user space modules */
-	if (worker[cpu].reference_count == 0) {
-		k_thread_abort(worker[cpu].thread_id);
-		user_stack_free(worker[cpu].stack_ptr);
-	}
+static int user_worker_get(int cpu)
+{
+	assert(cpu >= 0 && cpu < (int)ARRAY_SIZE(worker));
+	assert(worker[cpu].stack_ptr);
+
+	return 0;
+}
+
+static void user_worker_put(int cpu)
+{
+	ARG_UNUSED(cpu);
 }
 #endif
 

src/include/sof/audio/module_adapter/library/userspace_proxy.h

@@ -81,4 +81,38 @@ struct k_work_user *userspace_proxy_register_ipc_handler(struct processing_modul
 
 #endif /* CONFIG_SOF_USERSPACE_PROXY */
 
+/*
+ * Per-core userspace IPC worker lifecycle.
+ *
+ * A userspace IPC worker is a user-mode work queue (and its worker thread) that
+ * services IPC requests targeting userspace modules running on a given core. The
+ * worker is created on, and managed from, the primary core. Configurations that do
+ * not use a dedicated per-core worker resolve these calls to no-ops.
+ */
+#if CONFIG_SOF_USERSPACE_PROXY && !CONFIG_SOF_USERSPACE_MOD_IPC_BY_DP_THREAD
+/**
+ * Create the userspace IPC worker for the given core.
+ *
+ * Must be called while running on the primary core. The worker thread is pinned to
+ * the target core. Calling it again for a core that already has a worker is a no-op.
+ *
+ * @param cpu - target core id the worker is created for
+ * @return 0 on success, negative error code otherwise.
+ */
+int user_worker_create(int cpu);
+
+/**
+ * Free the userspace IPC worker for the given core.
+ *
+ * Must be called from the primary core while the target core is still running, as it
+ * aborts the worker thread.
+ *
+ * @param cpu - target core id whose worker is freed
+ */
+void user_worker_free(int cpu);
+#else
+static inline int user_worker_create(int cpu) { return 0; }
+static inline void user_worker_free(int cpu) { }
+#endif
+
 #endif /* __SOF_AUDIO_USERSPACE_PROXY_H__ */

src/init/init.c

@@ -32,6 +32,7 @@
 #include <sof/schedule/dp_schedule.h>
 #include <sof/schedule/ll_schedule.h>
 #include <sof/schedule/ll_schedule_domain.h>
+#include <sof/audio/module_adapter/library/userspace_proxy.h>
 #include <ipc/trace.h>
 #if CONFIG_IPC_MAJOR_4
 #include <ipc4/fw_reg.h>
@@ -230,6 +231,12 @@ __cold static int primary_core_init(int argc, char *argv[], struct sof *sof)
 	zephyr_ll_user_resources_init();
 #endif
 
+	/* Create the userspace IPC worker for the primary core. Secondary cores get
+	 * theirs from cpu_enable_core(). Resolves to a no-op when unused.
+	 */
+	if (user_worker_create(cpu_get_id()) < 0)
+		sof_panic(SOF_IPC_PANIC_MEM);
+
 	/* init the platform */
 	if (platform_init(sof) < 0)
 		sof_panic(SOF_IPC_PANIC_PLATFORM);

zephyr/lib/cpu.c

@@ -22,6 +22,7 @@ static uint32_t mic_disable_status;
 #include <sof/lib/pm_runtime.h>
 #include <ipc/topology.h>
 #include <module/module/base.h>
+#include <sof/audio/module_adapter/library/userspace_proxy.h>
 #include <rtos/alloc.h>
 
 #include "../audio/copier/copier.h"
@@ -230,6 +231,8 @@ void cpu_notify_state_exit(enum pm_state state)
 
 int cpu_enable_core(int id)
 {
+	int ret = 0;
+
 	/* only called from single core, no RMW lock */
 	__ASSERT_NO_MSG(cpu_is_primary(arch_proc_id()));
 	/*
@@ -247,15 +250,18 @@ int cpu_enable_core(int id)
 	 * initialization. By reinitializing the idle thread, we would overwrite the kernel structs
 	 * and the idle thread stack.
 	 */
-	if (pm_state_next_get(id)->state == PM_STATE_ACTIVE) {
+	if (pm_state_next_get(id)->state == PM_STATE_ACTIVE)
 		k_smp_cpu_start(id, secondary_init, NULL);
-		return 0;
-	}
+	else
+		k_smp_cpu_resume(id, secondary_init, NULL, true, false);
 
-	k_smp_cpu_resume(id, secondary_init, NULL, true, false);
+	/* The core is up now; create its userspace IPC worker on the primary core.
+	 * Resolves to a no-op when no per-core userspace worker is used.
+	 */
+	ret = user_worker_create(id);
 #endif /* CONFIG_PM */
 
-	return 0;
+	return ret;
 }
 
 void cpu_disable_core(int id)
@@ -267,6 +273,12 @@ void cpu_disable_core(int id)
 		tr_warn(&zephyr_tr, "core %d is already disabled", id);
 		return;
 	}
+
+	/* Free the core's userspace IPC worker while the core is still running; the
+	 * worker thread is aborted cross-core. Resolves to a no-op when unused.
+	 */
+	user_worker_free(id);
+
 #if defined(CONFIG_PM)
 	/* TODO: before requesting core shut down check if it's not actively used */
 	if (!pm_state_force(id, &(struct pm_state_info){PM_STATE_SOFT_OFF, 0, 0})) {