A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use wasmtime::bail;
use wasmtime::*;
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_attached_to_error() -> Result<()> {
let mut config = Config::default();
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let mut store = Store::<()>::new(&engine, ());
let wat = r#"
(module
(func $hello (import "" "hello"))
(func (export "run") (call $hello))
)
"#;
let module = Module::new(store.engine(), wat)?;
let hello_type = FuncType::new(store.engine(), None, None);
let hello_func = Func::new(&mut store, hello_type, |_, _, _| bail!("test 123"));
let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
assert!(format!("{e:?}").contains("test 123"));
assert!(
e.downcast_ref::<WasmCoreDump>().is_some(),
"error should contain a WasmCoreDump"
);
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_has_stack() -> Result<()> {
let _ = env_logger::try_init();
let mut config = Config::default();
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let mut store = Store::<()>::new(&engine, ());
let wat = r#"
(module
(func $a (export "a")
call $b
)
(func $b
call $c
)
(func $c
unreachable
)
)
"#;
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let a_func = instance.get_typed_func::<(), ()>(&mut store, "a")?;
let e = a_func.call(&mut store, ()).unwrap_err();
let cd = e.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(cd.frames().len(), 3);
assert_eq!(cd.frames()[0].func_name().unwrap(), "c");
assert_eq!(cd.frames()[1].func_name().unwrap(), "b");
assert_eq!(cd.frames()[2].func_name().unwrap(), "a");
let _ = cd.serialize(&mut store, "stack");
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_has_modules_and_instances() -> Result<()> {
let mut config = Config::default();
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let mut linker = Linker::new(&engine);
let mut store = Store::<()>::new(&engine, ());
let wat1 = r#"
(module $foo
(import "bar" "b" (func $b))
(func (export "a")
call $b
)
)
"#;
let wat2 = r#"
(module $bar
(func (export "b")
unreachable
)
)
"#;
let module1 = Module::new(store.engine(), wat1)?;
let module2 = Module::new(store.engine(), wat2)?;
let linking2 = linker.instantiate(&mut store, &module2)?;
linker.instance(&mut store, "bar", linking2)?;
let linking1 = linker.instantiate(&mut store, &module1)?;
let a_func = linking1.get_typed_func::<(), ()>(&mut store, "a")?;
let e = a_func.call(&mut store, ()).unwrap_err();
let cd = e.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(cd.modules().len(), 2);
assert_eq!(cd.instances().len(), 2);
let _ = cd.serialize(&mut store, "modules-and-instances");
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_has_host_globals_and_memory() -> Result<()> {
let mut config = Config::default();
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let module = Module::new(
&engine,
r#"
(module
(import "memory" "memory" (memory 1))
(global $myglobal (import "global" "global") (mut i32))
(func (export "a") (result i32)
unreachable
)
(export "memory" (memory 0))
(export "global" (global 0))
)
"#,
)?;
let mut store = Store::<()>::new(&engine, ());
let mut linker = Linker::new(&engine);
let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
linker.define(&mut store, "memory", "memory", memory)?;
let global = Global::new(
&mut store,
GlobalType::new(ValType::I32, Mutability::Var),
Val::I32(0),
)?;
linker.define(&mut store, "global", "global", global)?;
let instance = linker.instantiate(&mut store, &module)?;
// Each time we extract the exports, it puts them in the `StoreData`. Our
// core dumps need to be robust to duplicate entries in the `StoreData`.
for _ in 0..10 {
let _ = instance.get_global(&mut store, "global").unwrap();
let _ = instance.get_memory(&mut store, "memory").unwrap();
}
let a_func = instance.get_typed_func::<(), i32>(&mut store, "a")?;
let err = a_func.call(&mut store, ()).unwrap_err();
let core_dump = err.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(core_dump.globals().len(), 1);
assert_eq!(core_dump.memories().len(), 1);
assert_eq!(core_dump.instances().len(), 1);
let _ = core_dump.serialize(&mut store, "host-globals-and-memory");
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_has_defined_globals_and_memory() -> Result<()> {
let mut config = Config::default();
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let module = Module::new(
&engine,
r#"
(module
(global (mut i32) (i32.const 42))
(memory 1)
(func (export "a")
unreachable
)
)
"#,
)?;
let mut store = Store::<()>::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let a_func = instance.get_typed_func::<(), ()>(&mut store, "a")?;
let err = a_func.call(&mut store, ()).unwrap_err();
let core_dump = err.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(core_dump.globals().len(), 1);
assert_eq!(core_dump.memories().len(), 1);
assert_eq!(core_dump.instances().len(), 1);
let _ = core_dump.serialize(&mut store, "defined-globals-and-memory");
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_with_custom_page_size_and_partial_chunk() -> Result<()> {
let mut config = Config::default();
config.coredump_on_trap(true);
config.wasm_custom_page_sizes(true);
let engine = Engine::new(&config)?;
// Core dump serialization uses 4096-byte chunks. This 5000-byte memory
// has a partial tail with non-zero data that must not be dropped.
let module = Module::new(
&engine,
r#"
(module
(memory 5000 (pagesize 1))
(data (i32.const 4999) "\2a")
(func (export "a") unreachable)
)
"#,
)?;
let mut store = Store::<()>::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let a_func = instance.get_typed_func::<(), ()>(&mut store, "a")?;
let err = a_func.call(&mut store, ()).unwrap_err();
let core_dump = err.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(core_dump.memories().len(), 1);
let bytes = core_dump.serialize(&mut store, "custom-page-size");
let mut memory_types = vec![];
let mut saw_tail_byte = false;
for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
match payload? {
wasmparser::Payload::MemorySection(s) => {
for ty in s {
memory_types.push(ty?);
}
}
wasmparser::Payload::DataSection(s) => {
for data in s {
let data = data?;
let wasmparser::DataKind::Active { offset_expr, .. } = data.kind else {
continue;
};
let mut ops = offset_expr.get_operators_reader();
let wasmparser::Operator::I32Const { value } = ops.read()? else {
panic!("unexpected data segment offset expression");
};
let start = usize::try_from(value).unwrap();
if (start..start + data.data.len()).contains(&4999) {
assert_eq!(data.data[4999 - start], 0x2a);
saw_tail_byte = true;
}
}
}
_ => {}
}
}
assert!(saw_tail_byte, "data in the final partial chunk was dropped");
assert_eq!(memory_types.len(), 1);
assert_eq!(memory_types[0].page_size_log2, Some(0));
assert_eq!(memory_types[0].initial, 5000);
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn multiple_globals_memories_and_instances() -> Result<()> {
let mut config = Config::default();
config.wasm_multi_memory(true);
config.coredump_on_trap(true);
let engine = Engine::new(&config).unwrap();
let mut store = Store::<()>::new(&engine, ());
let mut linker = Linker::new(&engine);
let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
linker.define(&mut store, "host", "memory", memory)?;
let global = Global::new(
&mut store,
GlobalType::new(ValType::I32, Mutability::Var),
Val::I32(0),
)?;
linker.define(&mut store, "host", "global", global)?;
let module_a = Module::new(
&engine,
r#"
(module
(memory (export "memory") 1)
(global (export "global") (mut i32) (i32.const 0))
)
"#,
)?;
let instance_a = linker.instantiate(&mut store, &module_a)?;
linker.instance(&mut store, "a", instance_a)?;
let module_b = Module::new(
&engine,
r#"
(module
(import "host" "memory" (memory 1))
(import "host" "global" (global (mut i32)))
(import "a" "memory" (memory 1))
(import "a" "global" (global (mut i32)))
(func (export "trap")
unreachable
)
)
"#,
)?;
let instance_b = linker.instantiate(&mut store, &module_b)?;
let trap_func = instance_b.get_typed_func::<(), ()>(&mut store, "trap")?;
let err = trap_func.call(&mut store, ()).unwrap_err();
let core_dump = err.downcast_ref::<WasmCoreDump>().unwrap();
assert_eq!(core_dump.globals().len(), 2);
assert_eq!(core_dump.memories().len(), 2);
assert_eq!(core_dump.instances().len(), 2);
let _ = core_dump.serialize(&mut store, "multi");
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn core_dump_with_shared_memory() -> Result<()> {
if super::threads::engine().is_none() {
return Ok(());
}
let mut config = Config::new();
config.coredump_on_trap(true);
config.shared_memory(true);
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
let wat = r#"(module
(memory 1 1 shared)
(func (export "foo") unreachable)
(data (i32.const 0) "a")
)"#;
let module = Module::new(&engine, wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
let err = foo.call(&mut store, ()).unwrap_err();
let coredump = err.downcast_ref::<WasmCoreDump>().unwrap();
assert!(coredump.memories().is_empty());
let bytes = coredump.serialize(&mut store, "howdy");
for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
let payload = payload?;
if let wasmparser::Payload::DataSection(s) = payload {
assert_eq!(s.count(), 0);
}
}
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
fn coredump_with_composed_component_adapters() -> Result<()> {
use wasmtime::component::{Component, Linker};
let mut config = Config::new();
config.coredump_on_trap(true);
let engine = Engine::new(&config)?;
let component = Component::new(
&engine,
r#"
(component
(component $A
(core module $m
(func (export "f") (param i32) (result i32) unreachable)
)
(core instance $i (instantiate $m))
(func (export "f") (param "x" u32) (result u32)
(canon lift (core func $i "f")))
)
(component $B
(import "f" (func $f (param "x" u32) (result u32)))
(core func $fl (canon lower (func $f)))
(core module $m
(import "" "f" (func $f (param i32) (result i32)))
(func (export "run") (call $f (i32.const 1)) drop)
)
(core instance $i (instantiate $m
(with "" (instance (export "f" (func $fl))))))
(func (export "run") (canon lift (core func $i "run")))
)
(instance $a (instantiate $A))
(instance $b (instantiate $B (with "f" (func $a "f"))))
(func (export "run") (alias export $b "run"))
)
"#,
)?;
let mut store = Store::new(&engine, ());
let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let err = run.call(&mut store, ()).unwrap_err();
let coredump = err.downcast_ref::<WasmCoreDump>().unwrap();
let bytes = coredump.serialize(&mut store, "composed-component-adapters");
wasmparser::Validator::new().validate_all(&bytes)?;
Ok(())
}