[rust] Allow modules to declare themselves as Rust crates

The variable RUST_CRATES contains a list of paths (from the build root)
to crates to add. For each crate: generate a call to
`cratename::must_link()` to force the crate to be linked in, allowing lk
init blocks to be included.

This makes the pl011 crate a module, so the crate will be included when
the module is included.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

engine.mk

@@ -141,6 +141,7 @@ TARGET :=
 PLATFORM :=
 ARCH :=
 ALLMODULES :=
+RUST_CRATES :=
 
 # add any external module dependencies
 MODULES := $(EXTERNAL_MODULES)

lib/rust_support/Cargo.toml.in

@@ -17,10 +17,6 @@ crate-type = ["staticlib"]
 version = "0.1.0"
 path = "@BUILDROOT@/rust/lk" # Relative to build directory.
 
-[dependencies.dev-pl011]
-version = "0.1.0"
-path = "@BUILDROOT@/rust/dev-pl011" # Relative to build directory.
-
 [profile.release]
 debug-assertions = true
 overflow-checks = true
@@ -30,3 +26,5 @@ codegen-units = 1
 [profile.dev]
 opt-level = 2
 codegen-units = 1
+
+@DEPCRATES@

lib/rust_support/expand.py

@@ -0,0 +1,65 @@
+#! /usr/bin/env python3
+
+import fileinput
+import os
+
+# This script reads a template from standard input or the named file, and
+# outputs this with some template insertions, based on some values coming from
+# the make invocation.
+
+class Substr():
+    def __init__(self):
+        self.subs = []
+
+    def add(self, name):
+        value = os.environ.get(name)
+        if value is None:
+            raise Exception(f"Environment variable {name} not set")
+        self.subs.append( (f"@{name}@", value) )
+
+        if name == "BUILDROOT":
+            self.buildroot = value
+
+    # Generate a substitution rules for a list of crates.
+    def add_depcrates(self, name):
+        crates = os.environ.get(name)
+        if crates is None:
+            raise Exception(f"Environment variable {name} not set")
+        value = ""
+        for crate in crates.split():
+            base = os.path.basename(crate)
+            value += f"[dependencies.{base}]\npath = \"{self.buildroot}/{crate}\"\n"
+            # TODO: Get the crate version from the crate's Cargo.toml file.
+            value += f"version = \"0.1.0\"\n\n"
+        self.subs.append( ("@DEPCRATES@", value) )
+
+    def add_deplinks(self, name):
+        crates = os.environ.get(name)
+        if crates is None:
+            raise Exception(f"Environment variable {name} not set")
+        value = ""
+        for crate in crates.split():
+            base = os.path.basename(crate)
+            base = base.replace("-", "_")
+            if value != "":
+                value += "    "
+            value += f"{base}::must_link();"
+        self.subs.append( (f"@DEPLINKS@", value) )
+
+    def sub(self, line):
+        for (k,v) in self.subs:
+            line = line.replace(k, v)
+        return line
+
+def subst(name):
+    value = os.environ.get(name)
+
+subber = Substr();
+
+subber.add("BUILDROOT")
+subber.add_depcrates("RUST_CRATES")
+subber.add_deplinks("RUST_CRATES")
+
+for line in fileinput.input():
+    line = subber.sub(line.rstrip())
+    print(line)

lib/rust_support/rules.mk

@@ -33,6 +33,10 @@ HAVE_RUST := 1
 
 GLOBAL_DEFINES += HAVE_RUST=$(HAVE_RUST)
 
+# Modules that contain crates should define ${RUST_CRATES} with a path from the
+# build directory to the crate. We make the assumption that the crate name
+# matches the directory name.
+
 ifeq ($(RUST_TARGET),)
 $(error RUST_TARGET is not set for rust support)
 endif
@@ -64,15 +68,16 @@ EXTRA_OBJS := $(EXTRA_OBJS) $(MODULE_OBJECT)
 
 # Bring in the source files via copy.
 # The toml file will have a substitution to fix up references to the buildroot.
+$(MODULE_BUILDDIR)/%: MODULE_SRCDIR:=$(MODULE_SRCDIR)
+
 $(MODULE_BUILDDIR)/%: $(MODULE_SRCDIR)/%.in target.phony
 	$(NOECHO)echo generating $@
 	$(NOECHO)mkdir -p $(dir $@)
-	$(NOECHO)sed 's|@BUILDROOT@|$(call TOML_ESC,$(abspath $(BUILDROOT)))|g' $< > $@.tmp
-	$(NOECHO)$(call TESTANDREPLACEFILE,$@.tmp,$@)
-$(MODULE_BUILDDIR)/src/%: $(MODULE_SRCDIR)/src/%.in target.phony
-	$(NOECHO)echo generating $@
-	$(NOECHO)mkdir -p $(dir $@)
-	$(NOECHO)cp $< $@.tmp
+	$(NOECHO)env \
+		BUILDROOT="$(abspath $(BUILDROOT))" \
+		RUST_CRATES="$(RUST_CRATES)" \
+	        python3 $(MODULE_SRCDIR)/expand.py $< > $@.tmp
+	# $(NOECHO)sed 's|@BUILDROOT@|$(call TOML_ESC,$(abspath $(BUILDROOT)))|g' $< > [email protected]
 	$(NOECHO)$(call TESTANDREPLACEFILE,$@.tmp,$@)
 
 .PHONY: target.phony

lib/rust_support/src/lib.rs.in

@@ -9,12 +9,12 @@
 #![no_std]
 
 #[unsafe(no_mangle)]
-extern "C" fn setup_rust() {
+extern "C" fn must_link_rust() {
     // Any crate that relies entirely on initialization through LK's init
     // mechanisms will need a call to some piece of code in that create to cause
     // the crate to be brought in.
     // Due to link ordering, symbols from C code referencing into rust code
     // isn't usually sufficient to bring a crate in.
-    lk::init();
-    dev_pl011::init();
+    lk::must_link();
+    @DEPLINKS@
 }

platform/qemu-virt-arm/platform.c

@@ -88,15 +88,15 @@ void platform_early_init(void) {
 }
 
 #if HAVE_RUST
-void setup_rust(void);
+void must_link_rust(void);
 #else
-static void setup_rust(void) {}
+static void must_link_rust(void) {}
 #endif
 
 void platform_init(void) {
     pl011_init(0);
 
-    setup_rust();
+    must_link_rust();
 
     // start secondary cores
     fdtwalk_setup_cpus_arm(fdt);

platform/qemu-virt-arm/rules.mk

@@ -43,6 +43,7 @@ USE_RUST ?= 0
 
 ifeq ($(USE_RUST),1)
 MODULE_DEPS += lib/rust_support
+MODULE_DEPS += rust/dev-pl011
 endif
 
 GLOBAL_DEFINES += \

rust/dev-pl011/rules.mk

@@ -0,0 +1,3 @@
+LOCAL_DIR := $(GET_LOCAL_DIR)
+RUST_CRATES += $(LOCAL_DIR)
+MODULES += $(LOCAL_DIR)

rust/dev-pl011/src/lib.rs

@@ -31,11 +31,8 @@ fn get_console_input_cbuf() -> Cbuf {
     unsafe { Cbuf::new(&raw mut console_input_cbuf) }
 }
 
-/// Init function to ensure crate is linked.
-/// This might not be needed once we provide something actually linked.
-pub fn init() {
-    // Nothing to do yet.
-}
+/// Referenced from rust_support to ensure linking.
+pub fn must_link() {}
 
 /// Representation of the UART registers for MMIO access.
 #[repr(C)]

rust/lk/src/lib.rs

@@ -26,15 +26,8 @@ pub mod lkonce;
 pub mod log;
 pub mod macros;
 
-/// Initialize the rust side of the code.
-///
-/// Due to linker optimization, without a direct call into this code, the linker will not bring in
-/// anything.
-pub fn init() {
-    unsafe {
-        sys::fputs(c"*** Rust init ***\n".as_ptr(), lk_stderr());
-    }
-}
+// Enforce linking.
+pub fn must_link() {}
 
 /// Return the current stderr from lk's simple stdio implementation.
 #[inline(always)]