use a distinct memory for each process

currently no support for sharing memory across threads, no clue how/if mmap works now,
will fix later.

Author: tombl

arch/wasm/Kconfig

@@ -21,7 +21,6 @@ config WASM
 	select PAGE_SIZE_64KB
 	select SMP
 	select THREAD_INFO_IN_TASK
-	select UACCESS_MEMCPY if !MMU
 
 config CMDLINE
 	string "Kernel command string to append"

arch/wasm/drivers/virtio_wasm.c

@@ -12,17 +12,6 @@
 #include <linux/virtio_ring.h>
 #include <linux/virtio.h>
 
-void wasm_import(virtio, set_features)(u32 id, u64 features);
-
-void wasm_import(virtio, setup)(u32 id, u32 irq, bool *is_config,
-				bool *is_vring, u8 *config, u32 config_len);
-
-void wasm_import(virtio, enable_vring)(u32 id, u32 index, u32 size,
-				       dma_addr_t desc);
-void wasm_import(virtio, disable_vring)(u32 id, u32 index);
-
-void wasm_import(virtio, notify)(u32 id, u32 index);
-
 #define to_virtio_wasm_device(_plat_dev) \
 	container_of(_plat_dev, struct virtio_wasm_device, vdev)
 

arch/wasm/include/asm/uaccess.h

@@ -1,7 +1,23 @@
 #ifndef _WASM_UACCESS_H
 #define _WASM_UACCESS_H
 
-// TODO(wasm): when implementing mmu, swap generic/CONFIG_UACCESS_MEMCPY for custom impl
+#include <asm/wasm_imports.h>
+
+#define __access_ok __access_ok
+static inline int __access_ok(const void __user *ptr, unsigned long size)
+{
+	unsigned long limit = TASK_SIZE;
+	unsigned long addr = (unsigned long)ptr;
+
+	return (size <= limit) && (addr <= (limit - size));
+}
+
+#define raw_copy_from_user wasm_user_read
+#define raw_copy_to_user wasm_user_write
+#define __clear_user wasm_user_write_zeroes
+
+#define INLINE_COPY_FROM_USER
+#define INLINE_COPY_TO_USER
 
 #include <asm-generic/uaccess.h>
 

arch/wasm/include/asm/wasm_imports.h

@@ -7,6 +7,9 @@
 	__attribute__((import_module(#ns), import_name(#name))) \
 	wasm_##ns##_##name
 
+void wasm_import(boot, get_devicetree)(char *buf, size_t size);
+int wasm_import(boot, get_initramfs)(char *buf, size_t size);
+
 void wasm_import(kernel, breakpoint)(void);
 void wasm_import(kernel, halt)(void);
 void wasm_import(kernel, restart)(void);
@@ -25,4 +28,26 @@ void wasm_import(kernel, spawn_worker)(void (*fn)(void *), void *arg,
 
 void wasm_import(kernel, run_on_main)(void (*fn)(void *), void *arg);
 
+int wasm_import(user, compile)(u8 *bytes, u32 len);
+void wasm_import(user, instantiate)(u32 stack, u32 memory, u32 table_size);
+
+int wasm_import(user, read)(void *to, const void __user *from, unsigned long n);
+int wasm_import(user, write)(void __user *to, const void *from, unsigned long n);
+int wasm_import(user, write_zeroes)(void __user *to, unsigned long n);
+
+#ifdef CONFIG_VIRTIO_WASM
+void wasm_import(virtio, set_features)(u32 id, u64 features);
+
+void wasm_import(virtio, setup)(u32 id, u32 irq, bool *is_config,
+				bool *is_vring, u8 *config, u32 config_len);
+
+void wasm_import(virtio, enable_vring)(u32 id, u32 index, u32 size,
+				       dma_addr_t desc);
+void wasm_import(virtio, disable_vring)(u32 id, u32 index);
+
+void wasm_import(virtio, notify)(u32 id, u32 index);
+#endif
+
+#undef wasm_import
+
 #endif

arch/wasm/kernel/binfmt_wasm.c

@@ -161,9 +161,6 @@ static int get_wasm_dylink_mem_info(u8 *code, loff_t size,
 	return ret;
 }
 
-int wasm_import(user, compile)(u8 *bytes, u32 len);
-void wasm_import(user, instantiate)(u32 stack, u32 memory, u32 table_size);
-
 static int load_wasm_binary(struct linux_binprm *bprm)
 {
 	int ret;

arch/wasm/kernel/setup.c

@@ -15,8 +15,6 @@ void __wasm_call_ctors(void);
 int __init setup_early_printk(char *buf);
 void __init smp_init_cpus(unsigned int ncpus);
 void __init init_sections(unsigned long node);
-void wasm_import(boot, get_devicetree)(char *buf, size_t size);
-int wasm_import(boot, get_initramfs)(char *buf, size_t size);
 
 char *__initramfs_start;
 unsigned long __initramfs_size;

tools/wasm/src/index.ts

@@ -167,6 +167,9 @@ export class Machine extends EventEmitter<{
       user: {
         compile: unavailable,
         instantiate: unavailable,
+        read: unavailable,
+        write: unavailable,
+        write_zeroes: unavailable,
       },
       virtio: virtio_imports({
         memory: this.#memory,

tools/wasm/src/init2.cpio

@@ -37,6 +37,9 @@ export interface Imports {
   user: {
     compile(buf: number, size: number): number;
     instantiate(stack: number, memory: number, table_size: number): void;
+    read(to: number, from: number, n: number): number;
+    write(to: number, from: number, n: number): number;
+    write_zeroes(to: number, n: number): number;
   };
   virtio: {
     set_features(dev: number, features: bigint): void;

tools/wasm/src/wasm.ts

@@ -21,10 +21,12 @@ const postMessage = self.postMessage as (message: WorkerMessage) => void;
 
 let user_module: WebAssembly.Module | null = null;
 let user_instance: WebAssembly.Instance | null = null;
+let user_memory: WebAssembly.Memory | null = null;
+let user_memory_buffer: Uint8Array | null = null;
 
 self.onmessage = (event: MessageEvent<InitMessage>) => {
   const { fn, arg, vmlinux, memory } = event.data;
-  const mem = new Uint8Array(memory.buffer);
+  const memory_buffer = new Uint8Array(memory.buffer);
 
   const imports = {
     env: { memory },
@@ -34,46 +36,57 @@ self.onmessage = (event: MessageEvent<InitMessage>) => {
     },
     user: {
       compile(buf, size) {
-        const bytes = new Uint8Array(mem.slice(buf, buf + size));
+        const bytes = new Uint8Array(memory_buffer.slice(buf, buf + size));
         try {
           user_module = new WebAssembly.Module(bytes);
           return 0;
         } catch {
           return -8; // exec format error
         }
       },
-      instantiate(stack, memory_base, table_size) {
+      instantiate() {
         assert(user_module);
 
+        // TODO: shared memory support by postMessage-ing the buffer back to the main thread
+        // and having it pass all known memories back to newly spawned workers.
+        // TODO: read the real initial size from the module.
+        // TOOD: enforce rlimit via maximum.
+        user_memory = new WebAssembly.Memory({
+          initial: 10,
+          maximum: 100,
+        });
+        user_memory_buffer = new Uint8Array(user_memory.buffer);
+
         try {
           user_instance = new WebAssembly.Instance(user_module, {
-            env: {
-              memory,
-              __stack_pointer: new WebAssembly.Global({
-                value: "i32",
-                mutable: true,
-              }, stack),
-              __memory_base: memory_base,
-              __indirect_function_table: new WebAssembly.Table({
-                element: "anyfunc",
-                initial: table_size,
-              }),
-              __table_base: 0,
-            },
+            env: { memory: user_memory },
             linux: {
               syscall: instance.exports.syscall,
               get_thread_area: instance.exports.get_thread_area,
             },
           });
-
-          const { __wasm_apply_data_relocs } = user_instance.exports;
-          if (typeof __wasm_apply_data_relocs === "function") {
-            __wasm_apply_data_relocs();
-          }
         } catch (error) {
           console.warn("error instantiating user module:", error);
         }
-    },
+      },
+      read(to, from, n) {
+        assert(user_memory_buffer);
+        const slice = user_memory_buffer.subarray(from, from + n);
+        memory_buffer.set(slice, to);
+        return n - slice.length;
+      },
+      write(to, from, n) {
+        assert(user_memory_buffer);
+        const slice = memory_buffer.subarray(from, from + n);
+        user_memory_buffer.set(slice, to);
+        return n - slice.length;
+      },
+      write_zeroes(to, n) {
+        assert(user_memory_buffer);
+        const slice = user_memory_buffer.subarray(to, to + n);
+        slice.fill(0);
+        return n - slice.length;
+      },
     },
     kernel: kernel_imports({
       is_worker: true,