llext: add dependencies

When an LLEXT object uses symbols of another such object, it depends
on it. Such dependencies have to be tracked to prevent their
accidental unloading. Ideally we should be able to track arbitrary
numbers of such dependencies, but this is a bit difficult. In this
first implementation we use a fixed-size array, currently consisting
of 8 entries.

Signed-off-by: Guennadi Liakhovetski <[email protected]>

Author: lyakh

include/zephyr/llext/llext.h

@@ -62,6 +62,9 @@ enum llext_mem {
 struct llext_loader;
 /** @endcond */
 
+/* Maximim number of dependency LLEXTs */
+#define LLEXT_MAX_DEPENDENCIES 8
+
 /**
  * @brief Structure describing a linkable loadable extension
  *
@@ -111,6 +114,9 @@ struct llext {
 
 	/** Extension use counter, prevents unloading while in use */
 	unsigned int use_count;
+
+	/** Array of extensions, whose symbols this extension accesses */
+	struct llext *dependency[LLEXT_MAX_DEPENDENCIES];
 };
 
 /**

subsys/llext/llext.c

@@ -197,6 +197,8 @@ int llext_unload(struct llext **ext)
 	/* FIXME: protect the global list */
 	sys_slist_find_and_remove(&_llext_list, &tmp->_llext_list);
 
+	llext_dependency_remove_all(tmp);
+
 	*ext = NULL;
 	k_mutex_unlock(&llext_lock);
 

subsys/llext/llext_link.c

@@ -52,7 +52,56 @@ static size_t llext_file_offset(struct llext_loader *ldr, size_t offset)
 	return offset;
 }
 
+/*
+ * We increment use-count every time a new dependent is added, and have to
+ * decrement it again, when one is removed. Ideally we should be able to add
+ * arbitrary numbers of dependencies, but using lists for this doesn't work,
+ * because multiple extensions can have common dependencies. Dynamically
+ * allocating dependency entries would be too wasteful. In this initial
+ * implementation we use an array of dependencies, if at some point we run out
+ * of array entries, we'll implement re-allocation.
+ * We add dependencies incrementally as we discover them, but we only ever
+ * expect them to be removed all at once, when their user is removed. So the
+ * dependency array is always "dense" - it cannot have NULL entries between
+ * valid ones.
+ */
+static int llext_dependency_add(struct llext *ext, struct llext *dependency)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(ext->dependency); i++) {
+		if (ext->dependency[i] == dependency) {
+			return 0;
+		}
+
+		if (!ext->dependency[i]) {
+			ext->dependency[i] = dependency;
+			dependency->use_count++;
+
+			return 0;
+		}
+	}
+
+	return -ENOENT;
+}
+
+void llext_dependency_remove_all(struct llext *ext)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(ext->dependency) && ext->dependency[i]; i++) {
+		/*
+		 * The use-count of dependencies is tightly bound to dependent's
+		 * life cycle, so it shouldn't underrun.
+		 */
+		ext->dependency[i]->use_count--;
+		__ASSERT(ext->dependency[i]->use_count, "LLEXT dependency use-count underrun!");
+		/* No need to NULL-ify the pointer - ext is freed after this */
+	}
+}
+
 struct llext_extension_sym {
+	struct llext *ext;
 	const char *sym;
 	const void *addr;
 };
@@ -64,17 +113,21 @@ static int llext_find_extension_sym_iterate(struct llext *ext, void *arg)
 
 	if (addr) {
 		se->addr = addr;
+		se->ext = ext;
 		return 1;
 	}
 
 	return 0;
 }
 
-static const void *llext_find_extension_sym(const char *sym_name)
+static const void *llext_find_extension_sym(const char *sym_name, struct llext **ext)
 {
 	struct llext_extension_sym se = {.sym = sym_name};
 
 	llext_iterate(llext_find_extension_sym_iterate, &se);
+	if (ext) {
+		*ext = se.ext;
+	}
 
 	return se.addr;
 }
@@ -168,15 +221,23 @@ static void llext_link_plt(struct llext_loader *ldr, struct llext *ext,
 
 		switch (stb) {
 		case STB_GLOBAL:
+			/* First try the global symbol table */
 			link_addr = llext_find_sym(NULL,
 				SYM_NAME_OR_SLID(name, sym_tbl.st_value));
 
 			if (!link_addr) {
+				/* Next try internal tables */
 				link_addr = llext_find_sym(&ext->sym_tab, name);
 			}
 
 			if (!link_addr) {
-				link_addr = llext_find_extension_sym(name);
+				/* Finally try any loaded tables */
+				struct llext *dep;
+
+				link_addr = llext_find_extension_sym(name, &dep);
+				if (link_addr) {
+					llext_dependency_add(ext, dep);
+				}
 			}
 
 			if (!link_addr) {
@@ -328,6 +389,16 @@ int llext_link(struct llext_loader *ldr, struct llext *ext, bool do_local)
 				link_addr = (uintptr_t)llext_find_sym(NULL,
 					SYM_NAME_OR_SLID(name, sym.st_value));
 
+				if (link_addr == 0) {
+					/* Try loaded tables */
+					struct llext *dep;
+
+					link_addr = (uintptr_t)llext_find_extension_sym(name, &dep);
+					if (link_addr) {
+						llext_dependency_add(ext, dep);
+					}
+				}
+
 				if (link_addr == 0) {
 					LOG_ERR("Undefined symbol with no entry in "
 						"symbol table %s, offset %zd, link section %d",

subsys/llext/llext_priv.h

@@ -74,5 +74,6 @@ static inline const void *llext_loaded_sect_ptr(struct llext_loader *ldr, struct
  */
 
 int llext_link(struct llext_loader *ldr, struct llext *ext, bool do_local);
+void llext_dependency_remove_all(struct llext *ext);
 
 #endif /* ZEPHYR_SUBSYS_LLEXT_PRIV_H_ */