llext: fully relocatable llext modules in virtual memory

app/llext_relocatable.conf

@@ -1 +1,2 @@
 CONFIG_LLEXT_TYPE_ELF_RELOCATABLE=y
+CONFIG_LLEXT_EXPORT_BUILTINS_BY_SLID=y

scripts/llext_link_helper.py

@@ -77,6 +77,8 @@ def main():
 
 	command = [args.command]
 
+	is_relocatable = '-r' in args.params
+
 	executable = []
 	writable = []
 	readonly = []
@@ -111,7 +113,8 @@ def main():
 				text_found = True
 				text_addr = max_alignment(text_addr, 0x1000, s_alignment)
 				text_size = s_size
-				command.append(f'-Wl,-Ttext=0x{text_addr:x}')
+				if not is_relocatable:
+					command.append(f'-Wl,-Ttext=0x{text_addr:x}')
 			else:
 				executable.append(section)
 
@@ -164,7 +167,8 @@ def main():
 
 		dram_addr = align_up(dram_addr, s_alignment)
 
-		command.append(f'-Wl,--section-start={s_name}=0x{dram_addr:x}')
+		if not is_relocatable:
+			command.append(f'-Wl,--section-start={s_name}=0x{dram_addr:x}')
 
 		dram_addr += section.header['sh_size']
 
@@ -177,7 +181,8 @@ def main():
 
 		dram_addr = align_up(dram_addr, s_alignment)
 
-		command.append(f'-Wl,--section-start={s_name}=0x{dram_addr:x}')
+		if not is_relocatable:
+			command.append(f'-Wl,--section-start={s_name}=0x{dram_addr:x}')
 
 		dram_addr += section.header['sh_size']
 
@@ -189,7 +194,8 @@ def main():
 
 		start_addr = align_up(start_addr, s_alignment)
 
-		command.append(f'-Wl,--section-start={s_name}=0x{start_addr:x}')
+		if not is_relocatable:
+			command.append(f'-Wl,--section-start={s_name}=0x{start_addr:x}')
 
 		start_addr += section.header['sh_size']
 
@@ -201,10 +207,11 @@ def main():
 
 		start_addr = align_up(start_addr, s_alignment)
 
-		if s_name == '.data':
-			command.append(f'-Wl,-Tdata=0x{start_addr:x}')
-		else:
-			command.append(f'-Wl,--section-start={s_name}=0x{start_addr:x}')
+		if not is_relocatable:
+			if s_name == '.data':
+				command.append(f'-Wl,-Tdata=0x{start_addr:x}')
+			else:
+				command.append(f'-Wl,--section-start={s_name}=0x{start_addr:x}')
 
 		start_addr += section.header['sh_size']
 

scripts/llext_offset_calc.py

@@ -47,6 +47,9 @@ def get_elf_size(elf_name):
 			if section.header['sh_addr'] + section.header['sh_size'] > end:
 				end = section.header['sh_addr'] + section.header['sh_size']
 
+		if start == 0xffffffff:
+			return 0
+
 		size = end - start
 
 	return size

src/include/sof/lib_manager.h

@@ -116,6 +116,8 @@ struct lib_manager_module {
 	unsigned int n_dependent; /* For auxiliary modules: number of dependents */
 	bool mapped;
 	struct lib_manager_segment_desc segment[LIB_MANAGER_N_SEGMENTS];
+	uintptr_t vma_base;
+	size_t vma_size;
 };
 
 struct lib_manager_mod_ctx {

src/library_manager/Kconfig

@@ -58,10 +58,4 @@ config LIBRARY_BASE_ADDRESS
 	  automatically but the beginning of that area is platform-specific and
 	  should be set by this option.
 
-config LIBRARY_REGION_SIZE
-	hex "Size of memory region dedicated to loadable modules"
-	default 0x100000
-	help
-	  Size of the virtual memory region dedicated for loadable modules
-
 endmenu

src/library_manager/llext_manager.c

@@ -19,7 +19,7 @@
 #include <rtos/spinlock.h>
 #include <sof/lib/cpu-clk-manager.h>
 #include <sof/lib_manager.h>
-#include <sof/lib/regions_mm.h>
+#include <sof/lib/vpage.h>
 #include <sof/llext_manager.h>
 #include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/module_adapter/module/modules.h>
@@ -50,6 +50,94 @@ extern struct tr_ctx lib_manager_tr;
 
 #define PAGE_SZ		CONFIG_MM_DRV_PAGE_SIZE
 
+#include <zephyr/llext/elf.h>
+
+static uintptr_t llext_manager_alloc_vma(size_t size)
+{
+	size_t num_pages = ALIGN_UP(size, PAGE_SZ) / PAGE_SZ;
+	void *vma;
+
+	vma = vpage_reserve(num_pages);
+	if (!vma) {
+		tr_err(&lib_manager_tr, "llext_manager_alloc_vma: failed to reserve %zu pages",
+		       num_pages);
+		return 0;
+	}
+
+	return (uintptr_t)vma;
+}
+
+void llext_manager_free_vma(uintptr_t vma, size_t size)
+{
+	if (!vma || !size)
+		return;
+
+	vpage_release((void *)vma);
+}
+
+static enum llext_mem llext_manager_get_sec_mem_idx(const char *name, const elf_shdr_t *shdr)
+{
+	if (strcmp(name, ".exported_sym") == 0)
+		return LLEXT_MEM_EXPORT;
+
+	switch (shdr->sh_type) {
+	case SHT_NOBITS:
+		return LLEXT_MEM_BSS;
+	case SHT_PROGBITS:
+		if (shdr->sh_flags & SHF_EXECINSTR)
+			return LLEXT_MEM_TEXT;
+		else if (shdr->sh_flags & SHF_WRITE)
+			return LLEXT_MEM_DATA;
+		else
+			return LLEXT_MEM_RODATA;
+	case SHT_PREINIT_ARRAY:
+		return LLEXT_MEM_PREINIT;
+	case SHT_INIT_ARRAY:
+		return LLEXT_MEM_INIT;
+	case SHT_FINI_ARRAY:
+		return LLEXT_MEM_FINI;
+	default:
+		return LLEXT_MEM_COUNT;
+	}
+}
+
+static size_t llext_manager_layout_sections(uint8_t *elf_buf, uintptr_t vma_base)
+{
+	elf_ehdr_t *hdr = (elf_ehdr_t *)elf_buf;
+	elf_shdr_t *shdrs = (elf_shdr_t *)(elf_buf + hdr->e_shoff);
+	elf_shdr_t *shstr_shdr = shdrs + hdr->e_shstrndx;
+	const char *shstrtab = (const char *)(elf_buf + shstr_shdr->sh_offset);
+
+	uintptr_t current_vma = vma_base;
+	enum llext_mem last_region = LLEXT_MEM_COUNT;
+
+	for (int i = 0; i < hdr->e_shnum; i++) {
+		elf_shdr_t *shdr = shdrs + i;
+
+		if (!(shdr->sh_flags & SHF_ALLOC) || shdr->sh_size == 0)
+			continue;
+
+		const char *name = shstrtab + shdr->sh_name;
+		enum llext_mem s_region = llext_manager_get_sec_mem_idx(name, shdr);
+
+		if (s_region == LLEXT_MEM_COUNT)
+			continue;
+
+		if (last_region != LLEXT_MEM_COUNT && last_region != s_region) {
+			current_vma = ALIGN_UP(current_vma, PAGE_SZ);
+		}
+		last_region = s_region;
+
+		current_vma = ALIGN_UP(current_vma, shdr->sh_addralign);
+		if (vma_base) {
+			shdr->sh_addr = current_vma;
+		}
+		current_vma += shdr->sh_size;
+	}
+
+	return current_vma - vma_base;
+}
+
 static int llext_manager_update_flags(void __sparse_cache *vma, size_t size, uint32_t flags)
 {
 	size_t pre_pad_size = (uintptr_t)vma & (PAGE_SZ - 1);
@@ -251,19 +339,10 @@ static int llext_manager_load_module(struct lib_manager_module *mctx)
 	const struct llext_loader *ldr = &mctx->ebl->loader;
 	const struct llext *ext = mctx->llext;
 
-	/* find dedicated virtual memory zone */
-	const struct sys_mm_drv_region *virtual_memory_regions = sys_mm_drv_query_memory_regions();
-	const struct sys_mm_drv_region *virtual_region;
+	/* use the shared virtual page allocator's memory region */
+	const struct sys_mm_drv_region *virtual_region = vpage_get_region();
 
-	if (!virtual_memory_regions)
-		return -EFAULT;
-
-	SYS_MM_DRV_MEMORY_REGION_FOREACH(virtual_memory_regions, virtual_region) {
-		if (virtual_region->attr == VIRTUAL_REGION_LLEXT_LIBRARIES_ATTR)
-			break;
-	}
-
-	if (!virtual_region->size)
+	if (!virtual_region || !virtual_region->size)
 		return -EFAULT;
 
 	/* Copy Code */
@@ -383,6 +462,26 @@ static int llext_manager_link(const char *name,
 	}
 
 	if (!*llext || mctx->mapped) {
+		if (!*llext) {
+			uint8_t *elf_buf = (uint8_t *)mctx->ebl->buf;
+			size_t total_size = llext_manager_layout_sections(elf_buf, 0);
+			if (total_size == 0) {
+				tr_err(&lib_manager_tr, "llext_manager_link: layout sections failed");
+				return -EINVAL;
+			}
+
+			uintptr_t vma_base = llext_manager_alloc_vma(total_size);
+			if (!vma_base) {
+				tr_err(&lib_manager_tr, "llext_manager_link: VMA allocation failed");
+				return -ENOMEM;
+			}
+
+			mctx->vma_base = vma_base;
+			mctx->vma_size = total_size;
+
+			llext_manager_layout_sections(elf_buf, vma_base);
+		}
+
 		/*
 		 * Either the very first time loading this module, or the module
 		 * is already mapped, we just call llext_load() to refcount it
@@ -395,8 +494,15 @@ static int llext_manager_link(const char *name,
 		};
 
 		ret = llext_load(ldr, name, llext, &ldr_parm);
-		if (ret)
+		if (ret) {
+			tr_err(&lib_manager_tr, "llext_load failed: ret=%d", ret);
+			if (mctx->vma_base) {
+				llext_manager_free_vma(mctx->vma_base, mctx->vma_size);
+				mctx->vma_base = 0;
+				mctx->vma_size = 0;
+			}
 			return ret;
+		}
 	}
 
 	/* All code sections */
@@ -1104,16 +1210,3 @@ bool comp_is_llext(struct comp_dev *comp)
 	return mod && module_is_llext(mod);
 }
 
-static int llext_memory_region_init(void)
-{
-	int ret;
-
-	/* add a region for loadable libraries */
-	ret = adsp_add_virtual_memory_region(CONFIG_LIBRARY_BASE_ADDRESS,
-					     CONFIG_LIBRARY_REGION_SIZE,
-					     VIRTUAL_REGION_LLEXT_LIBRARIES_ATTR);
-
-	return ret;
-}
-
-SYS_INIT(llext_memory_region_init, POST_KERNEL, 1);

src/library_manager/llext_manager_dram.c

@@ -14,6 +14,8 @@
 
 LOG_MODULE_DECLARE(lib_manager, CONFIG_SOF_LOG_LEVEL);
 
+void llext_manager_free_vma(uintptr_t vma, size_t size);
+
 struct lib_manager_dram_storage {
 	struct ext_library ext_lib;
 	struct lib_manager_mod_ctx *ctx;
@@ -332,6 +334,9 @@ int llext_manager_restore_from_dram(void)
 			if (mod[k].llext)
 				llext_unload(&mod[k].llext);
 
+			if (mod[k].vma_base)
+				llext_manager_free_vma(mod[k].vma_base, mod[k].vma_size);
+
 			if (mod[k].ebl)
 				rfree(mod[k].ebl);
 		}

zephyr/CMakeLists.txt

@@ -289,8 +289,14 @@ if (CONFIG_SOC_SERIES_INTEL_ADSP_ACE)
 		${SOF_PLATFORM_PATH}/novalake/lib/clk.c
 	)
 
+	# vpage.c is the shared virtual-page allocator: needed by the vregion
+	# pipeline-resource allocator (CONFIG_SOF_VREGIONS) and independently by
+	# the LLEXT library manager (CONFIG_LIBRARY_MANAGER) for library VMAs.
+	if(CONFIG_SOF_VREGIONS OR CONFIG_LIBRARY_MANAGER)
+		zephyr_library_sources(lib/vpage.c)
+	endif()
+
 	zephyr_library_sources_ifdef(CONFIG_SOF_VREGIONS
-		lib/vpage.c
 		lib/vregion.c
 	)
 

zephyr/include/sof/lib/regions_mm.h

@@ -19,7 +19,6 @@
 
 /* Attributes for memory regions */
 #define VIRTUAL_REGION_SHARED_HEAP_ATTR 1U	  /*< region for shared virtual heap */
-#define VIRTUAL_REGION_LLEXT_LIBRARIES_ATTR 2U	  /*< region for LLEXT libraries */
 #define VIRTUAL_REGION_VPAGES_ATTR 3U		  /*< region for virtual page allocator */
 
 /* Dependency on ipc/topology.h created due to memory capability definitions

zephyr/include/sof/lib/vpage.h

@@ -6,6 +6,7 @@
 #define __SOF_LIB_VPAGE_H__
 
 #include <zephyr/kernel.h>
+#include <zephyr/drivers/mm/system_mm.h>
 #include <stdint.h>
 
 #ifdef __cplusplus
@@ -31,6 +32,37 @@ void *vpage_alloc(unsigned int pages);
  */
 void vpage_free(void *ptr);
 
+/**
+ * @brief Reserve virtual pages
+ * Reserves a specified number of contiguous virtual memory pages from the
+ * shared virtual page allocator, without mapping any physical memory to
+ * them. Intended for callers that need to map the pages themselves, e.g.
+ * with per-section permissions.
+ *
+ * @param[in] pages Number of pages (usually 4kB large) to reserve.
+ *
+ * @return Pointer to the reserved virtual memory region, or NULL on failure.
+ */
+void *vpage_reserve(unsigned int pages);
+
+/**
+ * @brief Release reserved virtual pages
+ * Releases virtual memory pages previously reserved with vpage_reserve().
+ * Does not unmap any physical memory - callers that mapped the pages
+ * themselves must unmap them first.
+ *
+ * @param[in] ptr Pointer to the reserved memory pages to release.
+ */
+void vpage_release(void *ptr);
+
+/**
+ * @brief Get the shared virtual page allocator's memory region
+ *
+ * @return Pointer to the virtual memory region backing the virtual page
+ * allocator.
+ */
+const struct sys_mm_drv_region *vpage_get_region(void);
+
 #ifdef __cplusplus
 }
 #endif