Remote code loading framework.

Cargo.toml

@@ -19,6 +19,7 @@ include = [
 ]
 
 [dependencies]
+byteorder = "1.3.1"
 errno = "0.2.4"
 structopt = "0.2.11"
 wabt = "0.7.2"
@@ -32,9 +33,10 @@ wasmer-runtime-core = { path = "lib/runtime-core" }
 wasmer-emscripten = { path = "lib/emscripten" }
 wasmer-llvm-backend = { path = "lib/llvm-backend", optional = true }
 wasmer-wasi = { path = "lib/wasi", optional = true }
+kwasm-loader = { path = "lib/kwasm-loader" }
 
 [workspace]
-members = ["lib/clif-backend", "lib/singlepass-backend", "lib/runtime", "lib/runtime-abi", "lib/runtime-core", "lib/emscripten", "lib/spectests", "lib/win-exception-handler", "lib/runtime-c-api", "lib/llvm-backend", "lib/wasi", "lib/middleware-common", "examples/plugin-for-example"]
+members = ["lib/clif-backend", "lib/singlepass-backend", "lib/runtime", "lib/runtime-abi", "lib/runtime-core", "lib/emscripten", "lib/spectests", "lib/win-exception-handler", "lib/runtime-c-api", "lib/llvm-backend", "lib/wasi", "lib/middleware-common", "lib/kwasm-loader", "examples/kernel/hello_world", "examples/pipe", "examples/plugin-for-example"]
 
 [build-dependencies]
 wabt = "0.7.2"

examples/kernel/hello_world/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "hello_world"
+version = "0.1.0"
+authors = ["Heyang Zhou <zhy20000919@hotmail.com>"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]

examples/kernel/hello_world/src/lib.rs

@@ -0,0 +1,14 @@
+extern "C" {
+    fn print_str(base: *const u8, len: usize) -> i32;
+}
+
+#[no_mangle]
+pub extern "C" fn main() -> i32 {
+    let v: Vec<i32> = (0..10).collect();
+    let s = format!("Hello world from WebAssembly. Some heap allocated integers: {:?}", v);
+    let s = s.as_bytes();
+    unsafe {
+        print_str(s.as_ptr(), s.len());
+    }
+    return 0;
+}

examples/pipe/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "pipe"
+version = "0.1.0"
+authors = ["Heyang Zhou <zhy20000919@hotmail.com>"]
+edition = "2018"
+
+[dependencies]

examples/pipe/src/main.rs

@@ -0,0 +1,13 @@
+use std::io::{Read, Write};
+
+fn main() {
+    let mut stdin = ::std::io::stdin();
+    let mut stdout = ::std::io::stdout();
+    let mut buf: Vec<u8> = vec![0; 512];
+    let mut total: u64 = 0;
+    while total < 1048576u64 * 2048 {
+        let n = stdin.read(&mut buf).unwrap();
+        stdout.write_all(&buf[..n]).unwrap();
+        total += n as u64;
+    }
+}

lib/kwasm-loader/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "kwasm-loader"
+version = "0.1.0"
+authors = ["Heyang Zhou <zhy20000919@hotmail.com>"]
+edition = "2018"
+
+[dependencies]
+libc = "0.2.49"
+wasmer-runtime-core = { path = "../runtime-core", version = "0.3.0" }

lib/kwasm-loader/src/lib.rs

@@ -0,0 +1,126 @@
+pub mod service;
+
+use wasmer_runtime_core::{
+    loader::{self, Loader, Instance},
+    backend::RunnableModule,
+    vm::{Ctx, LocalGlobal, SigId, Anyfunc},
+    module::ModuleInfo,
+    types::{Value, LocalMemoryIndex, LocalTableIndex, ImportedMemoryIndex, ImportedTableIndex, FuncIndex},
+    structures::TypedIndex,
+};
+use service::{ServiceContext, LoadProfile, RunProfile, TableEntryRequest, ImportInfo};
+
+pub struct KernelLoader;
+
+impl Loader for KernelLoader {
+    type Instance = KernelInstance;
+    type Error = String;
+
+    fn load(&self, rm: &dyn RunnableModule, module: &ModuleInfo, full_ctx: &Ctx) -> Result<Self::Instance, Self::Error> {
+        let ctx = &full_ctx.internal;
+        let code = rm.get_code().unwrap();
+        let memory = if let Some(_) = module.memories.get(LocalMemoryIndex::new(0)) {
+            Some(unsafe {
+                ::std::slice::from_raw_parts((**ctx.memories).base, (**ctx.memories).bound)
+            })
+        } else if let Some(_) = module.imported_memories.get(ImportedMemoryIndex::new(0)) {
+            return Err("imported memory is not supported".into());
+        } else {
+            None
+        };
+        let table: Option<Vec<TableEntryRequest>> = if let Some(_) = module.tables.get(LocalTableIndex::new(0)) {
+            Some(unsafe {
+                let table = &**ctx.tables;
+                let elements: &[Anyfunc] = ::std::slice::from_raw_parts(table.base as *const Anyfunc, table.count);
+                let base_addr = code.as_ptr() as usize;
+                let end_addr = base_addr + code.len();
+                elements.iter().map(|x| {
+                    let func_addr = x.func as usize;
+                    TableEntryRequest {
+                        offset: if x.func.is_null() || func_addr < base_addr || func_addr >= end_addr {
+                            ::std::usize::MAX
+                        } else {
+                            x.func as usize - base_addr
+                        },
+                        sig_id: x.sig_id.0,
+                    }
+                }).collect()
+            })
+        } else if let Some(_) = module.imported_tables.get(ImportedTableIndex::new(0)) {
+            return Err("imported table is not supported".into());
+        } else {
+            None
+        };
+        if module.imported_globals.len() > 0 {
+            return Err("imported globals are not supported".into());
+        }
+        let globals: Vec<u64> = unsafe {
+            let globals: &[*mut LocalGlobal] = ::std::slice::from_raw_parts(ctx.globals, module.globals.len());
+            globals.iter().map(|x| (**x).data).collect()
+        };
+        let mut import_names: Vec<ImportInfo> = vec![];
+        for (idx, import) in &module.imported_functions {
+            let name = format!("{}##{}", module.namespace_table.get(import.namespace_index), module.name_table.get(import.name_index));
+            let sig = module.signatures.get(
+                *module.func_assoc.get(FuncIndex::new(idx.index())).unwrap()
+            ).unwrap();
+            import_names.push(ImportInfo {
+                name: name,
+                param_count: sig.params().len(),
+            });
+        }
+        let dynamic_sigindices: &[u32] = unsafe {
+            ::std::mem::transmute::<&[SigId], &[u32]>(
+                ::std::slice::from_raw_parts(ctx.dynamic_sigindices, full_ctx.dynamic_sigindice_count())
+            )
+        };
+        let param_counts: Vec<usize> = (0..module.func_assoc.len())
+            .map(|x| module.signatures.get(*module.func_assoc.get(FuncIndex::new(x)).unwrap()).unwrap().params().len())
+            .collect();
+        let profile = LoadProfile {
+            code: code,
+            memory: memory,
+            memory_max: 0,
+            globals: &globals,
+            imports: &import_names,
+            dynamic_sigindices: dynamic_sigindices,
+            table: table.as_ref().map(|x| x.as_slice()),
+        };
+        let sc = ServiceContext::new(profile).map_err(|x| format!("{:?}", x))?;
+        Ok(KernelInstance {
+            context: sc,
+            offsets: rm.get_offsets().unwrap(),
+            param_counts: param_counts,
+        })
+    }
+}
+
+pub struct KernelInstance {
+    context: ServiceContext,
+    offsets: Vec<usize>,
+    param_counts: Vec<usize>, // FIXME: Full signature check
+}
+
+impl Instance for KernelInstance {
+    type Error = String;
+    fn call(&mut self, id: usize, args: &[Value]) -> Result<u64, String> {
+        if args.len() != self.param_counts[id] {
+            return Err("param count mismatch".into());
+        }
+        let args: Vec<u64> = args.iter().map(|x| x.to_u64()).collect();
+
+        let ret = self.context.run_code(RunProfile {
+            entry_offset: self.offsets[id] as u32,
+            params: &args,
+        }).map_err(|x| format!("{:?}", x))?;
+        Ok(ret)
+    }
+
+    fn read_memory(&mut self, offset: u32, len: u32) -> Result<Vec<u8>, String> {
+        self.context.read_memory(offset, len).map_err(|x| format!("{:?}", x))
+    }
+
+    fn write_memory(&mut self, offset: u32, len: u32, buf: &[u8]) -> Result<(), String> {
+        self.context.write_memory(offset, len, buf).map_err(|x| format!("{:?}", x))
+    }
+}