Skip to content

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

debugger: expose shared memories to gdbstub (#14087)

Alisina Karimid45a6f862f4a
diff --git a/Cargo.toml b/Cargo.toml
index 38a5e11f8b..2a82d3745e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -596,7 +596,7 @@ profiling = ["wasmtime/profiling", "wasmtime/call-hook"]
coredump = ["wasmtime-cli-flags/coredump"]
addr2line = ["wasmtime/addr2line"]
debug-builtins = ["wasmtime/debug-builtins"]
-threads = ["wasmtime-cli-flags/threads"]
+threads = ["wasmtime-cli-flags/threads", "wasmtime-debugger?/threads"]
gc = ["wasmtime-cli-flags/gc", "wasmtime/gc"]
gc-drc = ["gc", "wasmtime/gc-drc", "wasmtime-cli-flags/gc-drc"]
gc-null = ["gc", "wasmtime/gc-null", "wasmtime-cli-flags/gc-null"]
diff --git a/crates/debugger/Cargo.toml b/crates/debugger/Cargo.toml
index 9aeb815d96..95e8833233 100644
--- a/crates/debugger/Cargo.toml
+++ b/crates/debugger/Cargo.toml
@@ -27,3 +27,4 @@ env_logger = { workspace = true }
[features]
default = []
+threads = ["wasmtime/threads"]
diff --git a/crates/debugger/src/host/api.rs b/crates/debugger/src/host/api.rs
index 064c6b15d3..d470fc7439 100644
--- a/crates/debugger/src/host/api.rs
+++ b/crates/debugger/src/host/api.rs
@@ -7,11 +7,33 @@ use std::pin::Pin;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use wasmtime::{
- Engine, ExnRef, FrameHandle, Func, Global, Instance, Memory, Module, OwnedRooted, Result,
- Table, Tag, Val, component::Resource, component::ResourceTable,
+ Engine, ExnRef, FrameHandle, Func, Global, Instance, Module, OwnedRooted, Result, Table, Tag,
+ Val, component::Resource, component::ResourceTable,
};
use wasmtime_wasi::p2::{DynPollable, Pollable, subscribe};
+/// A memory exposed through the debugger API.
+///
+/// The component-level resource is deliberately shared by both kinds of
+/// Wasmtime linear memory. Shared memories use their own host API and do not
+/// belong to a `Store`, unlike ordinary memories.
+#[derive(Clone)]
+pub enum Memory {
+ Unshared(wasmtime::Memory),
+ #[cfg(feature = "threads")]
+ Shared(wasmtime::SharedMemory),
+}
+
+impl Memory {
+ fn unique_id(&self) -> u64 {
+ match self {
+ Memory::Unshared(memory) => memory.debug_index_in_store(),
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => memory.debug_index_in_store(),
+ }
+ }
+}
+
/// Representation of one debuggee: a store with debugged code inside,
/// under the control of the debugger.
pub struct Debuggee {
@@ -446,7 +468,7 @@ impl wit::HostModule for ResourceTable {
impl wit::HostMemory for ResourceTable {
async fn size_bytes(&mut self, self_: Resource<Memory>, d: Resource<Debuggee>) -> Result<u64> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_size_bytes(memory).await
}
@@ -456,7 +478,7 @@ impl wit::HostMemory for ResourceTable {
self_: Resource<Memory>,
d: Resource<Debuggee>,
) -> Result<u64> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_page_size(memory).await
}
@@ -467,7 +489,7 @@ impl wit::HostMemory for ResourceTable {
d: Resource<Debuggee>,
delta_bytes: u64,
) -> Result<u64> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_grow(memory, delta_bytes).await
}
@@ -479,7 +501,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
len: u64,
) -> Result<Vec<u8>> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
Ok(d.memory_read_bytes(memory, addr, len)
.await?
@@ -493,7 +515,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
bytes: Vec<u8>,
) -> Result<()> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_write_bytes(memory, addr, bytes)
.await?
@@ -507,7 +529,7 @@ impl wit::HostMemory for ResourceTable {
d: Resource<Debuggee>,
addr: u64,
) -> Result<u8> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
Ok(d.memory_read_u8(memory, addr)
.await?
@@ -520,7 +542,7 @@ impl wit::HostMemory for ResourceTable {
d: Resource<Debuggee>,
addr: u64,
) -> Result<u16> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
Ok(d.memory_read_u16(memory, addr)
.await?
@@ -533,7 +555,7 @@ impl wit::HostMemory for ResourceTable {
d: Resource<Debuggee>,
addr: u64,
) -> Result<u32> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
Ok(d.memory_read_u32(memory, addr)
.await?
@@ -546,7 +568,7 @@ impl wit::HostMemory for ResourceTable {
d: Resource<Debuggee>,
addr: u64,
) -> Result<u64> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
Ok(d.memory_read_u64(memory, addr)
.await?
@@ -560,7 +582,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
value: u8,
) -> Result<()> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_write_u8(memory, addr, value)
.await?
@@ -575,7 +597,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
value: u16,
) -> Result<()> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_write_u16(memory, addr, value)
.await?
@@ -590,7 +612,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
value: u32,
) -> Result<()> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_write_u32(memory, addr, value)
.await?
@@ -605,7 +627,7 @@ impl wit::HostMemory for ResourceTable {
addr: u64,
value: u64,
) -> Result<()> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
let d = debugger(self, &d)?;
d.memory_write_u64(memory, addr, value)
.await?
@@ -614,12 +636,12 @@ impl wit::HostMemory for ResourceTable {
}
async fn clone(&mut self, self_: Resource<Memory>) -> Result<Resource<Memory>> {
- let memory = *self.get(&self_)?;
+ let memory = self.get(&self_)?.clone();
Ok(self.push(memory)?)
}
async fn unique_id(&mut self, self_: Resource<Memory>) -> Result<u64> {
- Ok(self.get(&self_)?.debug_index_in_store())
+ Ok(self.get(&self_)?.unique_id())
}
async fn drop(&mut self, rep: Resource<Memory>) -> Result<()> {
diff --git a/crates/debugger/src/host/bindings.rs b/crates/debugger/src/host/bindings.rs
index fbf698bf28..91263b8058 100644
--- a/crates/debugger/src/host/bindings.rs
+++ b/crates/debugger/src/host/bindings.rs
@@ -23,7 +23,7 @@ wasmtime::component::bindgen!({
"bytecodealliance:wasmtime/debuggee.module": wasmtime::Module,
"bytecodealliance:wasmtime/debuggee.table": wasmtime::Table,
"bytecodealliance:wasmtime/debuggee.global": wasmtime::Global,
- "bytecodealliance:wasmtime/debuggee.memory": wasmtime::Memory,
+ "bytecodealliance:wasmtime/debuggee.memory": super::api::Memory,
"bytecodealliance:wasmtime/debuggee.wasm-tag": wasmtime::Tag,
"bytecodealliance:wasmtime/debuggee.wasm-func": wasmtime::Func,
"bytecodealliance:wasmtime/debuggee.wasm-exception": super::api::WasmException,
diff --git a/crates/debugger/src/host/opaque.rs b/crates/debugger/src/host/opaque.rs
index cce93b9d96..7214403459 100644
--- a/crates/debugger/src/host/opaque.rs
+++ b/crates/debugger/src/host/opaque.rs
@@ -2,12 +2,55 @@
//! within a resource.
use crate::host::wit;
-use crate::host::{api::WasmValue, bindings::val_type_to_wasm_type};
+use crate::host::{
+ api::{Memory, WasmValue},
+ bindings::val_type_to_wasm_type,
+};
+#[cfg(feature = "threads")]
+use std::sync::atomic::{AtomicU8, Ordering};
use wasmtime::{
- Engine, ExnRef, ExnRefPre, ExnType, FrameHandle, Func, FuncType, Global, Instance, Memory,
- Module, OwnedRooted, Result, Table, Tag, TagType, Val, ValType,
+ Engine, ExnRef, ExnRefPre, ExnType, FrameHandle, Func, FuncType, Global, Instance, Module,
+ OwnedRooted, Result, Table, Tag, TagType, Val, ValType,
};
+#[cfg(feature = "threads")]
+fn shared_memory_read_bytes(
+ memory: &wasmtime::SharedMemory,
+ addr: u64,
+ len: u64,
+) -> Option<Vec<u8>> {
+ let addr = usize::try_from(addr).ok()?;
+ let len = usize::try_from(len).ok()?;
+ let end = addr.checked_add(len)?;
+ let data = memory.data().get(addr..end)?;
+ Some(
+ data.iter()
+ .map(|byte| {
+ // SAFETY: `byte` is a valid byte from `SharedMemory::data`,
+ // and `AtomicU8` has the same alignment requirement as `u8`.
+ unsafe { AtomicU8::from_ptr(byte.get()).load(Ordering::Relaxed) }
+ })
+ .collect(),
+ )
+}
+
+#[cfg(feature = "threads")]
+fn shared_memory_write_bytes(
+ memory: &wasmtime::SharedMemory,
+ addr: u64,
+ bytes: &[u8],
+) -> Option<()> {
+ let addr = usize::try_from(addr).ok()?;
+ let end = addr.checked_add(bytes.len())?;
+ let data = memory.data().get(addr..end)?;
+ for (byte, value) in data.iter().zip(bytes) {
+ // SAFETY: `byte` is a valid byte from `SharedMemory::data`, and
+ // `AtomicU8` has the same alignment requirement as `u8`.
+ unsafe { AtomicU8::from_ptr(byte.get()).store(*value, Ordering::Relaxed) };
+ }
+ Some(())
+}
+
/// Type-erased interface to the `Debugger<T>` implementing all
/// functionality necessary for the interfaces here. This needs to be
/// type-erased because the host-side resource APIs do not support
@@ -168,8 +211,17 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
instance: Instance,
idx: u32,
) -> Result<Option<Memory>> {
- self.with_store(move |mut store| instance.debug_memory(&mut store, idx))
- .await
+ self.with_store(move |mut store| {
+ let memory = instance.debug_memory(&mut store, idx).map(Memory::Unshared);
+ #[cfg(feature = "threads")]
+ let memory = memory.or_else(|| {
+ instance
+ .debug_shared_memory(&mut store, idx)
+ .map(Memory::Shared)
+ });
+ memory
+ })
+ .await
}
async fn instance_get_global(
@@ -197,24 +249,43 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
}
async fn memory_size_bytes(&mut self, memory: Memory) -> Result<u64> {
- self.with_store(move |store| u64::try_from(memory.data_size(&store)).unwrap())
- .await
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => u64::try_from(memory.data_size(&store)).unwrap(),
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => u64::try_from(memory.data_size()).unwrap(),
+ })
+ .await
}
async fn memory_page_size(&mut self, memory: Memory) -> Result<u64> {
- self.with_store(move |store| memory.page_size(&store)).await
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => memory.page_size(&store),
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => memory.page_size(),
+ })
+ .await
}
async fn memory_grow(&mut self, memory: Memory, delta_bytes: u64) -> Result<u64> {
self.with_store(move |mut store| -> Result<u64> {
- let page_size = memory.page_size(&store);
+ let page_size = match &memory {
+ Memory::Unshared(memory) => memory.page_size(&store),
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => memory.page_size(),
+ };
if delta_bytes & (page_size - 1) != 0 {
return Err(wit::Error::MemoryGrowFailure.into());
}
let delta_pages = delta_bytes / page_size;
- let old_pages = memory
- .grow(&mut store, delta_pages)
- .map_err(|_| wit::Error::MemoryGrowFailure)?;
+ let old_pages = match memory {
+ Memory::Unshared(memory) => memory
+ .grow(&mut store, delta_pages)
+ .map_err(|_| wit::Error::MemoryGrowFailure)?,
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => memory
+ .grow(delta_pages)
+ .map_err(|_| wit::Error::MemoryGrowFailure)?,
+ };
Ok(old_pages * page_size)
})
.await?
@@ -226,11 +297,16 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
len: u64,
) -> Result<Option<Vec<u8>>> {
- self.with_store(move |store| {
- let data = memory.data(&store);
- let addr = usize::try_from(addr).unwrap();
- let len = usize::try_from(len).unwrap();
- data.get(addr..addr + len).map(|s| s.to_vec())
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data(&store);
+ let addr = usize::try_from(addr).ok()?;
+ let len = usize::try_from(len).ok()?;
+ let end = addr.checked_add(len)?;
+ data.get(addr..end).map(|s| s.to_vec())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => shared_memory_read_bytes(&memory, addr, len),
})
.await
}
@@ -241,62 +317,95 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
bytes: Vec<u8>,
) -> Result<Option<()>> {
- self.with_store(move |mut store| {
- let data = memory.data_mut(&mut store);
- let addr = usize::try_from(addr).unwrap();
- let dest = data.get_mut(addr..addr + bytes.len())?;
- dest.copy_from_slice(&bytes);
- Some(())
+ self.with_store(move |mut store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data_mut(&mut store);
+ let addr = usize::try_from(addr).ok()?;
+ let end = addr.checked_add(bytes.len())?;
+ let dest = data.get_mut(addr..end)?;
+ dest.copy_from_slice(&bytes);
+ Some(())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => shared_memory_write_bytes(&memory, addr, &bytes),
})
.await
}
async fn memory_read_u8(&mut self, memory: Memory, addr: u64) -> Result<Option<u8>> {
- self.with_store(move |store| {
- let data = memory.data(&store);
- let addr = usize::try_from(addr).unwrap();
- Some(*data.get(addr)?)
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data(&store);
+ let addr = usize::try_from(addr).ok()?;
+ Some(*data.get(addr)?)
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => Some(shared_memory_read_bytes(&memory, addr, 1)?[0]),
})
.await
}
async fn memory_read_u16(&mut self, memory: Memory, addr: u64) -> Result<Option<u16>> {
- self.with_store(move |store| {
- let data = memory.data(&store);
- let addr = usize::try_from(addr).unwrap();
- Some(u16::from_le_bytes([*data.get(addr)?, *data.get(addr + 1)?]))
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data(&store);
+ let addr = usize::try_from(addr).ok()?;
+ Some(u16::from_le_bytes([*data.get(addr)?, *data.get(addr + 1)?]))
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => Some(u16::from_le_bytes(
+ shared_memory_read_bytes(&memory, addr, 2)?
+ .try_into()
+ .unwrap(),
+ )),
})
.await
}
async fn memory_read_u32(&mut self, memory: Memory, addr: u64) -> Result<Option<u32>> {
- self.with_store(move |store| {
- let data = memory.data(&store);
- let addr = usize::try_from(addr).unwrap();
- Some(u32::from_le_bytes([
- *data.get(addr)?,
- *data.get(addr + 1)?,
- *data.get(addr + 2)?,
- *data.get(addr + 3)?,
- ]))
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data(&store);
+ let addr = usize::try_from(addr).ok()?;
+ Some(u32::from_le_bytes([
+ *data.get(addr)?,
+ *data.get(addr + 1)?,
+ *data.get(addr + 2)?,
+ *data.get(addr + 3)?,
+ ]))
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => Some(u32::from_le_bytes(
+ shared_memory_read_bytes(&memory, addr, 4)?
+ .try_into()
+ .unwrap(),
+ )),
})
.await
}
async fn memory_read_u64(&mut self, memory: Memory, addr: u64) -> Result<Option<u64>> {
- self.with_store(move |store| {
- let data = memory.data(&store);
- let addr = usize::try_from(addr).unwrap();
- Some(u64::from_le_bytes([
- *data.get(addr)?,
- *data.get(addr + 1)?,
- *data.get(addr + 2)?,
- *data.get(addr + 3)?,
- *data.get(addr + 4)?,
- *data.get(addr + 5)?,
- *data.get(addr + 6)?,
- *data.get(addr + 7)?,
- ]))
+ self.with_store(move |store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data(&store);
+ let addr = usize::try_from(addr).ok()?;
+ Some(u64::from_le_bytes([
+ *data.get(addr)?,
+ *data.get(addr + 1)?,
+ *data.get(addr + 2)?,
+ *data.get(addr + 3)?,
+ *data.get(addr + 4)?,
+ *data.get(addr + 5)?,
+ *data.get(addr + 6)?,
+ *data.get(addr + 7)?,
+ ]))
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => Some(u64::from_le_bytes(
+ shared_memory_read_bytes(&memory, addr, 8)?
+ .try_into()
+ .unwrap(),
+ )),
})
.await
}
@@ -307,11 +416,15 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
value: u8,
) -> Result<Option<()>> {
- self.with_store(move |mut store| {
- let data = memory.data_mut(&mut store);
- let addr = usize::try_from(addr).unwrap();
- *data.get_mut(addr)? = value;
- Some(())
+ self.with_store(move |mut store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data_mut(&mut store);
+ let addr = usize::try_from(addr).ok()?;
+ *data.get_mut(addr)? = value;
+ Some(())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => shared_memory_write_bytes(&memory, addr, &[value]),
})
.await
}
@@ -322,12 +435,19 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
value: u16,
) -> Result<Option<()>> {
- self.with_store(move |mut store| {
- let data = memory.data_mut(&mut store);
- let addr = usize::try_from(addr).unwrap();
- data.get_mut(addr..(addr + 2))?
- .copy_from_slice(&value.to_le_bytes());
- Some(())
+ self.with_store(move |mut store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data_mut(&mut store);
+ let addr = usize::try_from(addr).ok()?;
+ let end = addr.checked_add(2)?;
+ data.get_mut(addr..end)?
+ .copy_from_slice(&value.to_le_bytes());
+ Some(())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => {
+ shared_memory_write_bytes(&memory, addr, &value.to_le_bytes())
+ }
})
.await
}
@@ -338,12 +458,19 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
value: u32,
) -> Result<Option<()>> {
- self.with_store(move |mut store| {
- let data = memory.data_mut(&mut store);
- let addr = usize::try_from(addr).unwrap();
- data.get_mut(addr..(addr + 4))?
- .copy_from_slice(&value.to_le_bytes());
- Some(())
+ self.with_store(move |mut store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data_mut(&mut store);
+ let addr = usize::try_from(addr).ok()?;
+ let end = addr.checked_add(4)?;
+ data.get_mut(addr..end)?
+ .copy_from_slice(&value.to_le_bytes());
+ Some(())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => {
+ shared_memory_write_bytes(&memory, addr, &value.to_le_bytes())
+ }
})
.await
}
@@ -354,12 +481,19 @@ impl<T: Send + 'static> OpaqueDebugger for crate::Debuggee<T> {
addr: u64,
value: u64,
) -> Result<Option<()>> {
- self.with_store(move |mut store| {
- let data = memory.data_mut(&mut store);
- let addr = usize::try_from(addr).unwrap();
- data.get_mut(addr..(addr + 8))?
- .copy_from_slice(&value.to_le_bytes());
- Some(())
+ self.with_store(move |mut store| match memory {
+ Memory::Unshared(memory) => {
+ let data = memory.data_mut(&mut store);
+ let addr = usize::try_from(addr).ok()?;
+ let end = addr.checked_add(8)?;
+ data.get_mut(addr..end)?
+ .copy_from_slice(&value.to_le_bytes());
+ Some(())
+ }
+ #[cfg(feature = "threads")]
+ Memory::Shared(memory) => {
+ shared_memory_write_bytes(&memory, addr, &value.to_le_bytes())
+ }
})
.await
}
diff --git a/crates/wasmtime/src/runtime/memory.rs b/crates/wasmtime/src/runtime/memory.rs
index ab418253d4..3955d541c7 100644
--- a/crates/wasmtime/src/runtime/memory.rs
+++ b/crates/wasmtime/src/runtime/memory.rs
@@ -978,6 +978,13 @@ impl SharedMemory {
}
}
+ /// Returns a stable identifier for this shared memory when introspecting
+ /// it through the debug APIs.
+ #[cfg(feature = "debug")]
+ pub fn debug_index_in_store(&self) -> u64 {
+ u64::try_from(self.vm.vmmemory_ptr().as_ptr().addr()).unwrap()
+ }
+
/// Equivalent of the WebAssembly `memory.atomic.notify` instruction for
/// this shared memory.
///
diff --git a/tests/all/guest_debug/mod.rs b/tests/all/guest_debug/mod.rs
index 2a1342e597..5147b20154 100644
--- a/tests/all/guest_debug/mod.rs
+++ b/tests/all/guest_debug/mod.rs
@@ -128,18 +128,21 @@ impl WasmtimeWithGdbstub {
fn lldb_with_gdbstub_script(port: u16, script: &str) -> Result<String> {
let _ = env_logger::try_init();
- let mut cmd = Command::new(lldb_path());
- cmd.arg("--batch");
- cmd.arg("-o").arg(format!(
+ let mut script_file = tempfile::Builder::new().suffix(".lldb").tempfile()?;
+ writeln!(
+ script_file,
"process connect --plugin wasm connect://127.0.0.1:{port}"
- ));
+ )?;
for line in script.lines() {
let line = line.trim();
if !line.is_empty() {
- cmd.arg("-o").arg(line);
+ writeln!(script_file, "{line}")?;
}
}
+ let mut cmd = Command::new(lldb_path());
+ cmd.args(["--batch", "-s"]).arg(script_file.path());
+
eprintln!("Running LLDB: {cmd:?}");
let output = cmd.output()?;
@@ -240,6 +243,55 @@ check: fib
Ok(())
}
+/// Shared linear memories should be readable through the synthetic Wasm
+/// address space after the guest stops.
+#[cfg(feature = "threads")]
+#[test]
+#[ignore]
+fn guest_debug_cli_shared_memory() -> Result<()> {
+ let mut module = tempfile::Builder::new().suffix(".wat").tempfile()?;
+ module.write_all(
+ br#"(module
+ (memory (export "memory") 1 1 shared)
+ (func (export "_start")
+ i32.const 0
+ i32.const 42
+ i32.store
+ unreachable))
+"#,
+ )?;
+ let module = module.into_temp_path();
+ let module_path = module
+ .to_str()
+ .ok_or_else(|| format_err!("temporary module path is not UTF-8"))?;
+
+ let port = free_port();
+ let mut wt = WasmtimeWithGdbstub::spawn(
+ "run",
+ port,
+ &["-Ccache=n", "-W", "threads=y,shared-memory=y", module_path],
+ Duration::from_secs(30),
+ )?;
+
+ let output = lldb_with_gdbstub_script(
+ port,
+ r#"
+continue
+memory read --size 4 --format decimal --count 1 0x0
+"#,
+ )?;
+ wt.child.kill().ok();
+ wt.child.wait()?;
+
+ check_output(
+ &output,
+ r#"
+check: 42
+"#,
+ )?;
+ Ok(())
+}
+
/// Helper: send an HTTP/1.0 request and return the full response.
fn http_request(addr: SocketAddr, path: &str) -> Result<String> {
let mut tcp = TcpStream::connect_timeout(&addr, Duration::from_secs(5))?;