A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Fix pooling allocator predicate to reset VM permissions (#13008)
Alex Crichtonac7f44fb6c63
diff --git a/crates/wasmtime/src/runtime/vm/cow.rs b/crates/wasmtime/src/runtime/vm/cow.rsindex b008e893b4..987e9c944a 100644--- a/crates/wasmtime/src/runtime/vm/cow.rs+++ b/crates/wasmtime/src/runtime/vm/cow.rs@@ -461,7 +461,7 @@ impl MemoryImageSlot {let host_page_size_log2 = u8::try_from(host_page_size().ilog2()).unwrap();if initial_size_bytes_page_aligned < self.accessible&& (tunables.memory_guard_size > 0- || ty.can_elide_bounds_check(tunables, host_page_size_log2))+ || ty.can_use_virtual_memory(tunables, host_page_size_log2)){self.set_protection(initial_size_bytes_page_aligned..self.accessible, false)?;self.accessible = initial_size_bytes_page_aligned;diff --git a/tests/all/pooling_allocator.rs b/tests/all/pooling_allocator.rsindex b798fcbf54..c14a6dbbc5 100644--- a/tests/all/pooling_allocator.rs+++ b/tests/all/pooling_allocator.rs@@ -670,103 +670,111 @@ fn instance_too_large() -> Result<()> {#[cfg_attr(miri, ignore)]fn dynamic_memory_pooling_allocator() -> Result<()> {for guard_size in [0, 1 << 16] {- let max_size = 128 << 20;- let mut pool = crate::small_pool_config();- pool.max_memory_size(max_size as usize);- let mut config = Config::new();- config.memory_reservation(max_size);- config.memory_guard_size(guard_size);- config.allocation_strategy(pool);-- let engine = Engine::new(&config)?;-- let module = Module::new(- &engine,- r#"- (module- (memory (export "memory") 1)-- (func (export "grow") (param i32) (result i32)- local.get 0- memory.grow)-- (func (export "size") (result i32)- memory.size)-- (func (export "i32.load") (param i32) (result i32)- local.get 0- i32.load)-- (func (export "i32.store") (param i32 i32)- local.get 0- local.get 1- i32.store)-- (data (i32.const 100) "x")- )- "#,- )?;-- let mut store = Store::new(&engine, ());- let instance = Instance::new(&mut store, &module, &[])?;+ for signals_based_traps in [false, true] {+ let max_size = 128 << 20;+ let mut pool = crate::small_pool_config();+ pool.max_memory_size(max_size as usize);+ let mut config = Config::new();+ config.memory_reservation(max_size);+ config.memory_guard_size(guard_size);+ config.allocation_strategy(pool);+ config.signals_based_traps(signals_based_traps);++ let engine = Engine::new(&config)?;++ let Ok(module) = Module::new(+ &engine,+ r#"+ (module+ (memory (export "memory") 1)++ (func (export "grow") (param i32) (result i32)+ local.get 0+ memory.grow)++ (func (export "size") (result i32)+ memory.size)++ (func (export "i32.load") (param i32) (result i32)+ local.get 0+ i32.load)++ (func (export "i32.store") (param i32 i32)+ local.get 0+ local.get 1+ i32.store)++ (data (i32.const 100) "x")+ )+ "#,+ ) else {+ // Ignore invalid configurations on 32-bit which can't run with+ // signals-based-traps.+ assert!(cfg!(target_pointer_width = "32") && signals_based_traps);+ continue;+ };- let grow = instance.get_typed_func::<u32, i32>(&mut store, "grow")?;- let size = instance.get_typed_func::<(), u32>(&mut store, "size")?;- let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;- let i32_store = instance.get_typed_func::<(u32, i32), ()>(&mut store, "i32.store")?;- let memory = instance.get_memory(&mut store, "memory").unwrap();-- // basic length 1 tests- // assert_eq!(memory.grow(&mut store, 1)?, 0);- assert_eq!(memory.size(&store), 1);- assert_eq!(size.call(&mut store, ())?, 1);- assert_eq!(i32_load.call(&mut store, 0)?, 0);- assert_eq!(i32_load.call(&mut store, 100)?, i32::from(b'x'));- i32_store.call(&mut store, (0, 0))?;- i32_store.call(&mut store, (100, i32::from(b'y')))?;- assert_eq!(i32_load.call(&mut store, 100)?, i32::from(b'y'));-- // basic length 2 tests- let page = 64 * 1024;- assert_eq!(grow.call(&mut store, 1)?, 1);- assert_eq!(memory.size(&store), 2);- assert_eq!(size.call(&mut store, ())?, 2);- i32_store.call(&mut store, (page, 200))?;- assert_eq!(i32_load.call(&mut store, page)?, 200);-- // test writes are visible- i32_store.call(&mut store, (2, 100))?;- assert_eq!(i32_load.call(&mut store, 2)?, 100);-- // test growth can't exceed maximum- let too_many = max_size / (64 * 1024);- assert_eq!(grow.call(&mut store, too_many as u32)?, -1);- assert!(memory.grow(&mut store, too_many).is_err());-- assert_eq!(memory.data(&store)[page as usize], 200);-- // Re-instantiate in another store.- store = Store::new(&engine, ());- let instance = Instance::new(&mut store, &module, &[])?;- let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;- let memory = instance.get_memory(&mut store, "memory").unwrap();-- // This is out of bounds...- assert!(i32_load.call(&mut store, page).is_err());- assert_eq!(memory.data_size(&store), page as usize);-- // ... but implementation-wise it should still be mapped memory from- // before if we don't have any guard pages.- //- // Note though that prior writes should all appear as zeros and we can't see- // data from the prior instance.- //- // Note that this part is only implemented on Linux which has- // `MADV_DONTNEED`.- if cfg!(target_os = "linux") && guard_size == 0 {- unsafe {- let ptr = memory.data_ptr(&store);- assert_eq!(*ptr.offset(page as isize), 0);+ let mut store = Store::new(&engine, ());+ let instance = Instance::new(&mut store, &module, &[])?;++ let grow = instance.get_typed_func::<u32, i32>(&mut store, "grow")?;+ let size = instance.get_typed_func::<(), u32>(&mut store, "size")?;+ let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;+ let i32_store = instance.get_typed_func::<(u32, i32), ()>(&mut store, "i32.store")?;+ let memory = instance.get_memory(&mut store, "memory").unwrap();++ // basic length 1 tests+ // assert_eq!(memory.grow(&mut store, 1)?, 0);+ assert_eq!(memory.size(&store), 1);+ assert_eq!(size.call(&mut store, ())?, 1);+ assert_eq!(i32_load.call(&mut store, 0)?, 0);+ assert_eq!(i32_load.call(&mut store, 100)?, i32::from(b'x'));+ i32_store.call(&mut store, (0, 0))?;+ i32_store.call(&mut store, (100, i32::from(b'y')))?;+ assert_eq!(i32_load.call(&mut store, 100)?, i32::from(b'y'));++ // basic length 2 tests+ let page = 64 * 1024;+ assert_eq!(grow.call(&mut store, 1)?, 1);+ assert_eq!(memory.size(&store), 2);+ assert_eq!(size.call(&mut store, ())?, 2);+ i32_store.call(&mut store, (page, 200))?;+ assert_eq!(i32_load.call(&mut store, page)?, 200);++ // test writes are visible+ i32_store.call(&mut store, (2, 100))?;+ assert_eq!(i32_load.call(&mut store, 2)?, 100);++ // test growth can't exceed maximum+ let too_many = max_size / (64 * 1024);+ assert_eq!(grow.call(&mut store, too_many as u32)?, -1);+ assert!(memory.grow(&mut store, too_many).is_err());++ assert_eq!(memory.data(&store)[page as usize], 200);++ // Re-instantiate in another store.+ store = Store::new(&engine, ());+ let instance = Instance::new(&mut store, &module, &[])?;+ let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;+ let memory = instance.get_memory(&mut store, "memory").unwrap();++ // This is out of bounds...+ assert!(i32_load.call(&mut store, page).is_err());+ assert_eq!(memory.data_size(&store), page as usize);++ // ... but implementation-wise it should still be mapped memory from+ // before if we don't have any guard pages.+ //+ // Note though that prior writes should all appear as zeros and we can't see+ // data from the prior instance.+ //+ // Note that this part is only implemented on Linux which has+ // `MADV_DONTNEED`.+ if cfg!(target_os = "linux") && guard_size == 0 && !signals_based_traps {+ unsafe {+ let ptr = memory.data_ptr(&store);+ assert_eq!(*ptr.offset(page as isize), 0);+ }}}}@@ -1400,6 +1408,49 @@ fn pagemap_scan_enabled_or_disabled() -> Result<()> {Ok(())}+#[test]+#[cfg_attr(miri, ignore)]+fn pooling_reuse_resets() -> Result<()> {+ let mut config = Config::new();+ let mut cfg = crate::small_pool_config();+ cfg.total_memories(1);+ cfg.max_memory_size(0x2000000);+ config.allocation_strategy(InstanceAllocationStrategy::Pooling(cfg));+ config.memory_guard_size(0);+ config.memory_reservation(0x2000000);+ let engine = Engine::new(&config)?;++ let a = Module::new(&engine, r#"(module (memory (export "m") 10 100))"#)?;+ let b = Module::new(+ &engine,+ r#"+(module $B+ (memory 5 100)+ (func (export "read_oob") (result i32)+ (i32.load (i32.const 983040))+ )+)+ "#,+ )?;++ {+ let mut store = Store::new(&engine, ());+ let instance = Instance::new(&mut store, &a, &[])?;+ let memory = instance.get_memory(&mut store, "m").unwrap();+ memory.grow(&mut store, 10)?;+ }++ {+ let mut store = Store::new(&engine, ());+ let instance = Instance::new(&mut store, &b, &[])?;+ let read_oob = instance.get_typed_func::<(), i32>(&mut store, "read_oob")?;+ let trap: Trap = read_oob.call(&mut store, ()).unwrap_err().downcast()?;+ assert_eq!(trap, Trap::MemoryOutOfBounds);+ }++ Ok(())+}+// This test instantiates a memory with an image into a slot in the pooling// allocator in a way that maps the image into the allocator but fails// instantiation. Failure here is injected with `ResourceLimiter`. Afterwardsdiff --git a/tests/misc_testsuite/pooling-oob-on-reuse.wast b/tests/misc_testsuite/pooling-oob-on-reuse.wastnew file mode 100644index 0000000000..7a3924174d--- /dev/null+++ b/tests/misc_testsuite/pooling-oob-on-reuse.wast@@ -0,0 +1,16 @@+(module)++(thread $t1+ (module $A+ (memory 10 100)+ (func (export "grow")+ (drop (memory.grow (i32.const 10)))))+ (invoke "grow")+)+(wait $t1)++(module $B+ (memory 5 100)+ (func (export "read_oob") (result i32)+ (i32.load (i32.const 983040))))+(assert_trap (invoke "read_oob") "out of bounds memory access")