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):
 ifsection.header['sh_addr'] +section.header['sh_size'] >end:
 end=section.header['sh_addr'] +section.header['sh_size']
 
+ifstart==0xffffffff:
+return0
+
 size=end-start
 
 returnsize

src/include/sof/lib_manager.h

@@ -116,6 +116,8 @@ struct lib_manager_module {
 unsigned intn_dependent; /* For auxiliary modules: number of dependents */
 boolmapped;
 structlib_manager_segment_descsegment[LIB_MANAGER_N_SEGMENTS];
+uintptr_tvma_base;
+size_tvma_size;
 };
 
 structlib_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