Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

13.3 KB
Raw Blame
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(())
}