Put Rust data/bss in app shared memory domain

Link an object from all of the Rust sources which allows using a linker
script to put data/bss from Rust in an app memory region.

All the globals used in libstd and any Rust libraries need to be
accessible by all Rust threads, so we put them in one memory domain
along with a mem pool to serve as a global allocator.

Currently still using the mem pool if !usermode. Could use kmalloc
instead. Also the pool is created in rust-smem.c but must be set as the
global allocator in the top level app crate. Need to somehow tie the
creation and use of those together.

Author: tylerwhall

CMakeLists.txt

@@ -5,7 +5,7 @@ cmake_minimum_required(VERSION 3.13.1)
 include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
 project(hello_world)
 
-target_sources(app PRIVATE src/main.c)
+target_sources(app PRIVATE src/main.c rust_obj.obj)
 
 # Use a clang_target known to clang so headers will be processed correctly with
 # bindgen. rust_target may point to a custom json target.
@@ -29,11 +29,6 @@ add_custom_command(OUTPUT ${rust_syscall_macros_h}
   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/gen_syscall_header.py
   )
 
-add_library(syscall_thunk OBJECT syscall_thunk.c)
-target_link_libraries(syscall_thunk zephyr_interface)
-# High level target that means all headers have been generated
-add_dependencies(syscall_thunk offsets_h)
-
 set(rust_src_dir ${CMAKE_CURRENT_SOURCE_DIR}/zephyr-bindgen)
 set(rust_build_dir ${CMAKE_CURRENT_BINARY_DIR}/zephyr-bindgen)
 set(zephyr_bindgen ${rust_build_dir}/release/zephyr-bindgen)
@@ -81,9 +76,32 @@ ExternalProject_Add(
     BUILD_BYPRODUCTS ${rust_staticlib}
 )
 
-add_library(rust_lib STATIC IMPORTED)
-add_dependencies(rust_lib rust_project)
-set_target_properties(rust_lib PROPERTIES IMPORTED_LOCATION ${rust_staticlib})
-# This should be a dependency of rust_lib, but adding it as an INTERFACE lib doesn't do anything
-target_link_libraries(app PRIVATE syscall_thunk)
-target_link_libraries(app PUBLIC rust_lib)
+add_library(rust_obj OBJECT syscall-thunk.c rust-smem.c)
+target_link_libraries(rust_obj zephyr_interface)
+# High level target that means all headers have been generated
+add_dependencies(rust_obj offsets_h)
+
+# Relocatable single object library containing all Rust code. This allows using
+# a linker script during this link to rename sections, putting data/bss in the
+# rust shared memory section. The .obj suffix is significant because
+# gen_app_partitions.py searches for specially named sections in all .obj files
+# in the build output.
+if(CONFIG_USERSPACE)
+    set(rust_ldscript -Wl,-T ${CMAKE_CURRENT_SOURCE_DIR}/rust-smem.ld)
+endif()
+set(RUST_OBJ_CFLAGS ${CMAKE_C_FLAGS})
+separate_arguments(RUST_OBJ_CFLAGS)
+add_custom_command(
+  OUTPUT rust_obj.obj
+  COMMAND ${CMAKE_C_COMPILER} ${RUST_OBJ_CFLAGS}
+    -nostdlib
+    -static
+    -no-pie
+    -Wl,-r
+    ${rust_ldscript}
+    -Wl,--whole-archive ${rust_staticlib}
+    -Wl,--no-whole-archive $<TARGET_OBJECTS:rust_obj>
+    -o rust_obj.obj
+  DEPENDS ${rust_staticlib} $<TARGET_OBJECTS:rust_obj>
+  COMMAND_EXPAND_LISTS
+)

prj.conf

@@ -4,3 +4,4 @@ CONFIG_CPLUSPLUS=y
 CONFIG_SERIAL=y
 CONFIG_UART_NATIVE_POSIX=y
 CONFIG_NATIVE_UART_0_ON_OWN_PTY=y
+CONFIG_USERSPACE=y

rust-app/rust

@@ -16,6 +16,9 @@ use zephyr::mutex::*;
 use zephyr::semaphore::*;
 use zephyr::thread::ThreadSyscalls;
 
+// Use this mem pool for global allocs instead of kmalloc
+zephyr::global_sys_mem_pool!(rust_std_mem_pool);
+
 thread_local!(static TLS: RefCell<u8> = RefCell::new(1));
 
 zephyr_macros::k_mutex_define!(MUTEX);
@@ -33,12 +36,19 @@ fn mutex_test() {
     zephyr::any::k_str_out("Unlocking\n");
 }
 
+fn thread_join_std_mem_domain(_context: zephyr::context::Kernel) {
+    use zephyr::context::Kernel as C;
+    zephyr::static_mem_domain!(rust_std_domain).add_thread::<C>(C::k_current_get());
+}
+
 #[no_mangle]
 pub extern "C" fn hello_rust_second_thread(
     _a: *const c_void,
     _b: *const c_void,
     _c: *const c_void,
 ) {
+    thread_join_std_mem_domain(zephyr::context::Kernel);
+
     println!("Hello from second thread");
 
     TLS.with(|f| {
@@ -104,7 +114,10 @@ pub extern "C" fn hello_rust() {
     });
     TLS_SEM.give::<Context>();
 
+    thread_join_std_mem_domain(Context);
     zephyr::kernel::k_thread_user_mode_enter(|| {
+        use zephyr::context::User as Context;
+
         zephyr::user::k_str_out("Hello from Rust userspace with forced user-mode syscall\n");
 
         mutex_test();

rust-app/src/lib.rs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2012-2014 Wind River Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <init.h>
+#include <misc/mempool.h>
+#include <app_memory/app_memdomain.h>
+
+struct k_mem_domain rust_std_domain;
+
+#ifdef CONFIG_USERSPACE
+K_APPMEM_PARTITION_DEFINE(rust_std_partition);
+#define RUST_STD_SECTION K_APP_DMEM_SECTION(rust_std_partition)
+#else
+#define RUST_STD_SECTION .data
+#endif
+
+#define RUST_STD_MEM_POOL_SIZE 1024
+SYS_MEM_POOL_DEFINE(rust_std_mem_pool, NULL, 16,
+                    RUST_STD_MEM_POOL_SIZE, 1, 4, RUST_STD_SECTION);
+
+static int rust_std_init(struct device *arg)
+{
+    ARG_UNUSED(arg);
+
+#ifdef CONFIG_USERSPACE
+    k_mem_domain_init(&rust_std_domain, 0, NULL);
+    k_mem_domain_add_partition(&rust_std_domain, &rust_std_partition);
+#endif
+    sys_mem_pool_init(&rust_std_mem_pool);
+
+    return 0;
+}
+
+SYS_INIT(rust_std_init, PRE_KERNEL_2, CONFIG_APPLICATION_INIT_PRIORITY);

rust-smem.c

@@ -0,0 +1,5 @@
+SECTIONS
+{
+    data_smem_rust_std_partition_data : { *librust_app.a:*(.data .data.*) }
+    data_smem_rust_std_partition_bss : { *librust_app.a:*(.bss .bss.* COMMON COMMON.*) }
+}

rust-smem.ld

@@ -12,7 +12,7 @@ extern void hello_rust_user(void);
 
 extern uint8_t hello_rust_second_thread(void *, void *, void *);
 
-#define MY_STACK_SIZE 500
+#define MY_STACK_SIZE 1024
 #define MY_PRIORITY 5
 
 K_THREAD_DEFINE(my_tid, MY_STACK_SIZE,