Skip to content

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

Add memory-related API coverage to the public API fuzzer (#13441)

Nick Fitzgeraldcf544ffd0cb1
diff --git a/crates/fuzzing/src/generators/api.rs b/crates/fuzzing/src/generators/api.rs
index f9cbc070ea..e84694d774 100644
--- a/crates/fuzzing/src/generators/api.rs
+++ b/crates/fuzzing/src/generators/api.rs
@@ -68,6 +68,21 @@ struct Swarm {
table_ty: bool,
table_drop: bool,
get_table_export: bool,
+ memory_type_new: bool,
+ memory_type_drop: bool,
+ memory_new: bool,
+ memory_read: bool,
+ memory_write: bool,
+ memory_data: bool,
+ memory_data_mut: bool,
+ memory_grow: bool,
+ memory_data_size: bool,
+ memory_size: bool,
+ memory_page_size: bool,
+ memory_page_size_log2: bool,
+ memory_ty: bool,
+ memory_drop: bool,
+ get_memory_export: bool,
}
/// A call to one of Wasmtime's public APIs.
@@ -168,6 +183,62 @@ pub enum ApiCall {
instance: usize,
nth: usize,
},
+ MemoryTypeNew {
+ id: usize,
+ minimum: u32,
+ maximum: Option<u32>,
+ },
+ MemoryTypeDrop {
+ id: usize,
+ },
+ MemoryNew {
+ id: usize,
+ memory_ty: usize,
+ store: usize,
+ },
+ MemoryRead {
+ memory: usize,
+ offset: usize,
+ len: usize,
+ },
+ MemoryWrite {
+ memory: usize,
+ offset: usize,
+ data: Vec<u8>,
+ },
+ MemoryData {
+ memory: usize,
+ },
+ MemoryDataMut {
+ memory: usize,
+ },
+ MemoryGrow {
+ memory: usize,
+ delta: u32,
+ },
+ MemoryDataSize {
+ memory: usize,
+ },
+ MemorySize {
+ memory: usize,
+ },
+ MemoryPageSize {
+ memory: usize,
+ },
+ MemoryPageSizeLog2 {
+ memory: usize,
+ },
+ MemoryTy {
+ memory: usize,
+ },
+ MemoryDrop {
+ id: usize,
+ },
+ GetMemoryExport {
+ id: usize,
+ instance: usize,
+ nth: usize,
+ },
}
use ApiCall::*;
@@ -198,6 +269,13 @@ struct Scope {
/// associated `store_id`.
tables: BTreeMap<usize, usize>, // table_id -> store_id
+ /// Memory types that are currently live.
+ memory_types: BTreeSet<usize>,
+
+ /// Memories that are currently live. Maps from `memory_id` to the memory's
+ /// associated `store_id`.
+ memories: BTreeMap<usize, usize>, // memory_id -> store_id
+
config: Config,
}
@@ -233,6 +311,8 @@ impl<'a> Arbitrary<'a> for ApiCalls {
globals: BTreeMap::default(),
table_types: BTreeSet::default(),
tables: BTreeMap::default(),
+ memory_types: BTreeSet::default(),
+ memories: BTreeMap::default(),
config: config.clone(),
};
@@ -271,6 +351,7 @@ impl<'a> Arbitrary<'a> for ApiCalls {
scope.instances.retain(|_, store_id| *store_id != id);
scope.globals.retain(|_, store_id| *store_id != id);
scope.tables.retain(|_, store_id| *store_id != id);
+ scope.memories.retain(|_, store_id| *store_id != id);
Ok(StoreDrop { id })
});
}
@@ -480,6 +561,149 @@ impl<'a> Arbitrary<'a> for ApiCalls {
Ok(GetTableExport { id, instance, nth })
});
}
+ if swarm.memory_type_new {
+ choices.push(|input, scope| {
+ let id = scope.next_id();
+ let minimum = u32::arbitrary(input)? % 10;
+ let has_max = bool::arbitrary(input)?;
+ let maximum = if has_max {
+ Some(minimum + u32::arbitrary(input)? % 10)
+ } else {
+ None
+ };
+ scope.memory_types.insert(id);
+ Ok(MemoryTypeNew {
+ id,
+ minimum,
+ maximum,
+ })
+ });
+ }
+ if swarm.memory_type_drop && !scope.memory_types.is_empty() {
+ choices.push(|input, scope| {
+ let types: Vec<_> = scope.memory_types.iter().collect();
+ let id = **input.choose(&types)?;
+ scope.memory_types.remove(&id);
+ Ok(MemoryTypeDrop { id })
+ });
+ }
+ if swarm.memory_new && !scope.memory_types.is_empty() && !scope.stores.is_empty() {
+ choices.push(|input, scope| {
+ let types: Vec<_> = scope.memory_types.iter().collect();
+ let memory_ty = **input.choose(&types)?;
+ let stores: Vec<_> = scope.stores.iter().collect();
+ let store = **input.choose(&stores)?;
+ let id = scope.next_id();
+ scope.memories.insert(id, store);
+ Ok(MemoryNew {
+ id,
+ memory_ty,
+ store,
+ })
+ });
+ }
+ if swarm.memory_read && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ let offset = usize::arbitrary(input)?;
+ let len = usize::arbitrary(input)? % 64;
+ Ok(MemoryRead {
+ memory,
+ offset,
+ len,
+ })
+ });
+ }
+ if swarm.memory_write && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ let offset = usize::arbitrary(input)?;
+ let data = Vec::<u8>::arbitrary(input)?;
+ Ok(MemoryWrite {
+ memory,
+ offset,
+ data,
+ })
+ });
+ }
+ if swarm.memory_data && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryData { memory })
+ });
+ }
+ if swarm.memory_data_mut && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryDataMut { memory })
+ });
+ }
+ if swarm.memory_grow && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ let delta = u32::arbitrary(input)? % 10;
+ Ok(MemoryGrow { memory, delta })
+ });
+ }
+ if swarm.memory_data_size && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryDataSize { memory })
+ });
+ }
+ if swarm.memory_size && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemorySize { memory })
+ });
+ }
+ if swarm.memory_page_size && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryPageSize { memory })
+ });
+ }
+ if swarm.memory_page_size_log2 && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryPageSizeLog2 { memory })
+ });
+ }
+ if swarm.memory_ty && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let memory = **input.choose(&memories)?;
+ Ok(MemoryTy { memory })
+ });
+ }
+ if swarm.memory_drop && !scope.memories.is_empty() {
+ choices.push(|input, scope| {
+ let memories: Vec<_> = scope.memories.keys().collect();
+ let id = **input.choose(&memories)?;
+ scope.memories.remove(&id);
+ Ok(MemoryDrop { id })
+ });
+ }
+ if swarm.get_memory_export && !scope.instances.is_empty() {
+ choices.push(|input, scope| {
+ let instances: Vec<_> = scope.instances.keys().collect();
+ let instance = **input.choose(&instances)?;
+ let nth = usize::arbitrary(input)?;
+ let id = scope.next_id();
+ let store = *scope.instances.get(&instance).unwrap();
+ scope.memories.insert(id, store);
+ Ok(GetMemoryExport { id, instance, nth })
+ });
+ }
if choices.is_empty() {
break;
diff --git a/crates/fuzzing/src/oracles/api.rs b/crates/fuzzing/src/oracles/api.rs
index 5bbfacf14e..45abd61ff2 100644
--- a/crates/fuzzing/src/oracles/api.rs
+++ b/crates/fuzzing/src/oracles/api.rs
@@ -19,6 +19,8 @@ pub fn make_api_calls(api: ApiCalls) {
let mut globals: HashMap<usize, (Global, usize)> = Default::default();
let mut table_types: HashMap<usize, TableType> = Default::default();
let mut tables: HashMap<usize, (Table, usize)> = Default::default();
+ let mut memory_types: HashMap<usize, MemoryType> = Default::default();
+ let mut memories: HashMap<usize, (Memory, usize)> = Default::default();
for call in api.calls {
match call {
@@ -35,6 +37,7 @@ pub fn make_api_calls(api: ApiCalls) {
instances.retain(|_, (_, store_id)| *store_id != id);
globals.retain(|_, (_, store_id)| *store_id != id);
tables.retain(|_, (_, store_id)| *store_id != id);
+ memories.retain(|_, (_, store_id)| *store_id != id);
stores.remove(&id);
}
@@ -358,6 +361,210 @@ pub fn make_api_calls(api: ApiCalls) {
}
tables.insert(id, (ts[nth % ts.len()], store_id));
}
+
+ ApiCall::MemoryTypeNew {
+ id,
+ minimum,
+ maximum,
+ } => {
+ log::trace!("creating memory type {id}");
+ let old = memory_types.insert(id, MemoryType::new(minimum, maximum));
+ assert!(old.is_none());
+ }
+
+ ApiCall::MemoryTypeDrop { id } => {
+ log::trace!("dropping memory type {id}");
+ memory_types.remove(&id);
+ }
+
+ ApiCall::MemoryNew {
+ id,
+ memory_ty,
+ store,
+ } => {
+ log::trace!("creating memory {id} with type {memory_ty} in store {store}");
+ let mt = match memory_types.get(&memory_ty) {
+ Some(t) => t.clone(),
+ None => continue,
+ };
+ let st = match stores.get_mut(&store) {
+ Some(s) => s,
+ None => continue,
+ };
+ match Memory::new(&mut *st, mt) {
+ Ok(m) => {
+ memories.insert(id, (m, store));
+ }
+ Err(_) => continue,
+ }
+ }
+
+ ApiCall::MemoryRead {
+ memory,
+ offset,
+ len,
+ } => {
+ log::trace!("reading {len} bytes from memory {memory} at offset {offset}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let mut buf = vec![0u8; len];
+ let _ = m.read(st, offset, &mut buf);
+ }
+
+ ApiCall::MemoryWrite {
+ memory,
+ offset,
+ ref data,
+ } => {
+ log::trace!(
+ "writing {} bytes to memory {memory} at offset {offset}",
+ data.len()
+ );
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get_mut(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.write(&mut *st, offset, data);
+ }
+
+ ApiCall::MemoryData { memory } => {
+ log::trace!("getting data slice of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.data(st);
+ }
+
+ ApiCall::MemoryDataMut { memory } => {
+ log::trace!("getting mutable data slice of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get_mut(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.data_mut(&mut *st);
+ }
+
+ ApiCall::MemoryGrow { memory, delta } => {
+ log::trace!("growing memory {memory} by {delta} pages");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get_mut(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.grow(&mut *st, delta.into());
+ }
+
+ ApiCall::MemoryDataSize { memory } => {
+ log::trace!("getting data size of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.data_size(st);
+ }
+
+ ApiCall::MemorySize { memory } => {
+ log::trace!("getting size of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.size(st);
+ }
+
+ ApiCall::MemoryPageSize { memory } => {
+ log::trace!("getting page size of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.page_size(st);
+ }
+
+ ApiCall::MemoryPageSizeLog2 { memory } => {
+ log::trace!("getting page size log2 of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.page_size_log2(st);
+ }
+
+ ApiCall::MemoryTy { memory } => {
+ log::trace!("checking type of memory {memory}");
+ let (m, store_id) = match memories.get(&memory) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let _ = m.ty(st);
+ }
+
+ ApiCall::MemoryDrop { id } => {
+ log::trace!("dropping memory {id}");
+ memories.remove(&id);
+ }
+
+ ApiCall::GetMemoryExport { id, instance, nth } => {
+ log::trace!("getting {nth}th memory export of instance {instance} as {id}");
+ let (inst, store_id) = match instances.get(&instance) {
+ Some(&x) => x,
+ None => continue,
+ };
+ let st = match stores.get_mut(&store_id) {
+ Some(s) => s,
+ None => continue,
+ };
+ let ms = inst
+ .exports(&mut *st)
+ .filter_map(|e| e.into_memory())
+ .collect::<Vec<_>>();
+ if ms.is_empty() {
+ continue;
+ }
+ memories.insert(id, (ms[nth % ms.len()], store_id));
+ }
}
}
}