601e8f3094
This commit removes Wasmtime's dependency on the `region` crate. The motivation for this came about when I was updating dependencies and saw that `region` had a new major version at 3.0.0 as opposed to our currently used 2.3 track. In reviewing the use cases of `region` within Wasmtime I found two trends in particular which motivated this commit: * Some unix-specific areas of `wasmtime_runtime` use `rustix::mm::mprotect` instead of `region::protect` already. This means that the usage of `region::protect` for changing virtual memory protections was already inconsistent. * Many uses of `region::protect` were already in unix-specific regions which could make use of `rustix`. Overall I opted to remove the dependency on the `region` crate to avoid chasing its versions over time. Unix-specific changes of protections were easily changed to `rustix::mm::mprotect`. There were two locations where a windows/unix split is now required and I subjectively ruled "that seems ok". Finally removing `region` also meant that the "what is the current page size" query needed to be inlined into `wasmtime_runtime`, which I have also subjectively ruled "that seems fine". Finally one final refactoring here was that the `unix.rs` and `linux.rs` split for the pooling allocator was merged. These two files already only differed in one function so I slapped a `cfg_if!` in there to help reduce the duplication.
93 lines
2.9 KiB
Rust
93 lines
2.9 KiB
Rust
// This test only works on Linux. It may be portable to MacOS as well,
|
|
// but the original author did not have a machine available to test it.
|
|
#![cfg(target_os = "linux")]
|
|
|
|
use anyhow::Result;
|
|
use wasmtime::*;
|
|
|
|
#[derive(Default)]
|
|
struct MemoryGrowFailureDetector {
|
|
current: usize,
|
|
desired: usize,
|
|
error: Option<String>,
|
|
}
|
|
|
|
impl ResourceLimiter for MemoryGrowFailureDetector {
|
|
fn memory_growing(&mut self, current: usize, desired: usize, _maximum: Option<usize>) -> bool {
|
|
self.current = current;
|
|
self.desired = desired;
|
|
true
|
|
}
|
|
fn memory_grow_failed(&mut self, err: &anyhow::Error) {
|
|
self.error = Some(err.to_string());
|
|
}
|
|
fn table_growing(&mut self, _current: u32, _desired: u32, _maximum: Option<u32>) -> bool {
|
|
true
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn custom_limiter_detect_os_oom_failure() -> Result<()> {
|
|
if std::env::var("WASMTIME_TEST_NO_HOG_MEMORY").is_ok() {
|
|
return Ok(());
|
|
}
|
|
|
|
// Default behavior of on-demand memory allocation so that a
|
|
// memory grow will hit Linux for a larger mmap.
|
|
let engine = Engine::default();
|
|
let linker = Linker::new(&engine);
|
|
let module = Module::new(&engine, r#"(module (memory (export "m") 0))"#).unwrap();
|
|
|
|
// Ask Linux to limit this process to 256MiB of memory
|
|
let process_max_memory: usize = 256 * 1024 * 1024;
|
|
unsafe {
|
|
// limit process to 256MiB memory
|
|
let rlimit = libc::rlimit {
|
|
rlim_cur: 0,
|
|
rlim_max: process_max_memory as u64,
|
|
};
|
|
let res = libc::setrlimit(libc::RLIMIT_DATA, &rlimit);
|
|
assert_eq!(res, 0, "setrlimit failed: {}", res);
|
|
};
|
|
|
|
let context = MemoryGrowFailureDetector::default();
|
|
|
|
let mut store = Store::new(&engine, context);
|
|
store.limiter(|s| s as &mut dyn ResourceLimiter);
|
|
let instance = linker.instantiate(&mut store, &module).unwrap();
|
|
let memory = instance.get_memory(&mut store, "m").unwrap();
|
|
|
|
// Small (640KiB) grow should succeed
|
|
memory.grow(&mut store, 10).unwrap();
|
|
assert!(store.data().error.is_none());
|
|
assert_eq!(store.data().current, 0);
|
|
assert_eq!(store.data().desired, 10 * 64 * 1024);
|
|
|
|
// Try to grow past the process's memory limit.
|
|
// This should fail.
|
|
let pages_exceeding_limit = process_max_memory / (64 * 1024);
|
|
let err_msg = memory
|
|
.grow(&mut store, pages_exceeding_limit as u64)
|
|
.unwrap_err()
|
|
.to_string();
|
|
assert!(
|
|
err_msg.starts_with("failed to grow memory"),
|
|
"unexpected error: {}",
|
|
err_msg
|
|
);
|
|
|
|
assert_eq!(store.data().current, 10 * 64 * 1024);
|
|
assert_eq!(
|
|
store.data().desired,
|
|
(pages_exceeding_limit + 10) * 64 * 1024
|
|
);
|
|
// The memory_grow_failed hook should show Linux gave OOM:
|
|
let err_msg = store.data().error.as_ref().unwrap();
|
|
assert!(
|
|
err_msg.starts_with("Cannot allocate memory"),
|
|
"unexpected error: {}",
|
|
err_msg
|
|
);
|
|
Ok(())
|
|
}
|