userspace context

Author: softwarecki

src/include/module/module/base.h

@@ -15,6 +15,7 @@
 
 #include "interface.h"
 #include "../ipc4/base-config.h"
+#include <rtos/userspace_helper.h>
 
 #define module_get_private_data(mod) ((mod)->priv.private)
 #define module_set_private_data(mod, data) ((mod)->priv.private = data)
@@ -180,6 +181,7 @@ struct processing_module {
 	uint32_t max_sinks;
 
 	enum module_processing_type proc_type;
+	struct userspace_context *user_ctx;
 #endif /* SOF_MODULE_PRIVATE */
 };
 

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

@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright(c) 2025 Intel Corporation. All rights reserved.
+ *
+ * Author: Jaroslaw Stelter <jaroslaw.stelter@intel.com>
+ * Author: Adrian Warecki <adrian.warecki@intel.com>
+ */
+
+#ifndef __SOF_AUDIO_USERSPACE_PROXY_H__
+#define __SOF_AUDIO_USERSPACE_PROXY_H__
+
+#if CONFIG_USERSPACE
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <zephyr/kernel.h>
+
+/* Processing module structure fields needed for user mode */
+struct userspace_context {
+	struct k_mem_domain *comp_dom;			/* Module specific memory domain	*/
+};
+
+#endif /* CONFIG_USERSPACE */
+
+#endif /* __SOF_AUDIO_USERSPACE_PROXY_H__ */

zephyr/include/rtos/userspace_helper.h

@@ -16,6 +16,9 @@
 #define DRV_HEAP_SIZE	ALIGN_UP(CONFIG_SOF_ZEPHYR_USERSPACE_MODULE_HEAP_SIZE, \
 				 CONFIG_MM_DRV_PAGE_SIZE)
 
+struct processing_module;
+struct userspace_context;
+
 /**
  * Initialize private processing module heap.
  * @param N/A.
@@ -29,8 +32,47 @@
  */
 struct sys_heap *module_driver_heap_init(void);
 
+/**
+ * Add DP scheduler created thread to module memory domain.
+ * @param thread_id - id of thread to be added to memory domain.
+ * @param module    - processing module structure
+ *
+ * @return 0 for success, error otherwise.
+ *
+ * @note
+ * Function used only when CONFIG_USERSPACE is set.
+ */
+int user_memory_init_shared(k_tid_t thread_id, struct processing_module *mod);
+
 #endif
 
+/**
+ * Allocates thread stack memory.
+ * @param stack_size Required stack size.
+ * @param options Stack configuration options
+ *        K_USER - when creating user thread
+ *        0      - when creating kernel thread
+ * @return pointer to the stack or NULL if not created.
+ *
+ * When CONFIG_USERSPACE not set function calls rballoc_align(),
+ * otherwise it uses k_thread_stack_alloc() routine.
+ *
+ */
+void *user_stack_allocate(size_t stack_size, uint32_t options);
+
+/**
+ * Free thread stack memory.
+ * @param p_stack Pointer to the stack.
+ *
+ * @return 0 for success, error otherwise.
+ *
+ * @note
+ * When CONFIG_USERSPACE not set function calls rfree(),
+ * otherwise it uses k_thread_stack_free() routine.
+ *
+ */
+int user_stack_free(void *p_stack);
+
 /**
  * Allocates memory block from private module sys_heap if exists, otherwise call rballoc_align().
  * @param sys_heap - pointer to the sys_heap structure

zephyr/lib/userspace_helper.c

@@ -16,10 +16,19 @@
 
 #include <rtos/alloc.h>
 #include <rtos/userspace_helper.h>
+#include <sof/audio/module_adapter/module/generic.h>
+#include <sof/audio/module_adapter/library/userspace_proxy.h>
 
 #define MODULE_DRIVER_HEAP_CACHED		CONFIG_SOF_ZEPHYR_HEAP_CACHED
 
+/* Zephyr includes */
+#include <zephyr/kernel.h>
+#include <zephyr/app_memory/app_memdomain.h>
+
 #if CONFIG_USERSPACE
+
+K_APPMEM_PARTITION_DEFINE(common_partition);
+
 struct sys_heap *module_driver_heap_init(void)
 {
 	struct sys_heap *mod_drv_heap = rballoc(SOF_MEM_FLAG_USER, sizeof(struct sys_heap));
@@ -122,8 +131,49 @@ void module_driver_heap_remove(struct sys_heap *mod_drv_heap)
 	}
 }
 
+void *user_stack_allocate(size_t stack_size, uint32_t options)
+{
+	return (__sparse_force void __sparse_cache *)
+		k_thread_stack_alloc(stack_size, options & K_USER);
+}
+
+int user_stack_free(void *p_stack)
+{
+	if (!p_stack)
+		return 0;
+	return k_thread_stack_free((__sparse_force void *)p_stack);
+}
+
+int user_memory_init_shared(k_tid_t thread_id, struct processing_module *mod)
+{
+	struct k_mem_domain *comp_dom = mod->user_ctx->comp_dom;
+	int ret;
+
+	ret = k_mem_domain_add_partition(comp_dom, &common_partition);
+	if (ret < 0)
+		return ret;
+
+	return k_mem_domain_add_thread(comp_dom, thread_id);
+}
+
 #else /* CONFIG_USERSPACE */
 
+void *user_stack_allocate(size_t stack_size, uint32_t options)
+{
+	/* allocate stack - must be aligned and cached so a separate alloc */
+	stack_size = K_KERNEL_STACK_LEN(stack_size);
+	void *p_stack = (__sparse_force void __sparse_cache *)
+		rballoc_align(SOF_MEM_FLAG_USER, stack_size, Z_KERNEL_STACK_OBJ_ALIGN);
+
+	return p_stack;
+}
+
+int user_stack_free(void *p_stack)
+{
+	rfree((__sparse_force void *)p_stack);
+	return 0;
+}
+
 void *module_driver_heap_rmalloc(struct sys_heap *mod_drv_heap, uint32_t flags, size_t bytes)
 {
 	return rmalloc(flags, bytes);