Function guards_present_pooling

tests/all/memory.rs:196–250

(config: &mut Config)

#[cfg_attr(miri, ignore)]
#[cfg_attr(asan, ignore)]
fn guards_present_pooling(config: &mut Config) -> Result<()> {
    const GUARD_SIZE: u64 = 65536;

    let mut pool = crate::small_pool_config();
    pool.total_memories(2)
        .max_memory_size(10 << 16)
        .memory_protection_keys(Enabled::No);
    config.memory_reservation(1 << 20);
    config.memory_guard_size(GUARD_SIZE);
    config.guard_before_linear_memory(true);
    config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
    let engine = Engine::new(&config)?;

    let mut store = Store::new(&engine, ());

    let mem1 = {
        let m = Module::new(&engine, "(module (memory (export \"\") 1 2))")?;
        Instance::new(&mut store, &m, &[])?
            .get_memory(&mut store, "")
            .unwrap()
    };
    let mem2 = {
        let m = Module::new(&engine, "(module (memory (export \"\") 1))")?;
        Instance::new(&mut store, &m, &[])?
            .get_memory(&mut store, "")
            .unwrap()
    };

    unsafe fn assert_guards(store: &Store<()>, mem: &Memory) {
        unsafe {
            // guards before
            println!("check pre-mem");
            assert_faults(mem.data_ptr(&store).offset(-(GUARD_SIZE as isize)));

            // unmapped just after memory
            println!("check mem");
            assert_faults(mem.data_ptr(&store).add(mem.data_size(&store)));

            // guards after memory
            println!("check post-mem");
            assert_faults(mem.data_ptr(&store).add(1 << 20));
        }
    }
    unsafe {
        assert_guards(&store, &mem1);
        assert_guards(&store, &mem2);
        println!("growing");
        mem1.grow(&mut store, 1).unwrap();
        mem2.grow(&mut store, 1).unwrap();
        assert_guards(&store, &mem1);
        assert_guards(&store, &mem2);
    }

    Ok(())
}

#[wasmtime_test]
#[cfg_attr(miri, ignore)]