1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// Copyright 2024 The Tari Project
// SPDX-License-Identifier: BSD-3-Clause
use std::ptr::NonNull;
use wasmer::{
MemoryError,
MemoryStyle,
MemoryType,
Pages,
TableStyle,
TableType,
sys::{
Tunables,
vm::{VMMemory, VMMemoryDefinition, VMTable, VMTableDefinition},
},
};
/// A custom tunables that allows you to set a memory limit.
///
/// After adjusting the memory limits, it delegates all other logic
/// to the base tunables.
pub struct LimitingTunables<T: Tunables> {
/// The maximum a linear memory is allowed to be (in Wasm pages, 64 KiB each).
/// Since Wasmer ensures there is only none or one memory, this is practically
/// an upper limit for the guest memory.
limit: Pages,
/// The base implementation we delegate all the logic to
base: T,
}
impl<T: Tunables> LimitingTunables<T> {
pub fn new(base: T, limit: Pages) -> Self {
Self { limit, base }
}
/// Takes an input memory type as requested by the guest and sets
/// a maximum if missing. The resulting memory type is final if
/// valid. However, this can produce invalid types, such that
/// validate_memory must be called before creating the memory.
fn adjust_memory(&self, requested: &MemoryType) -> MemoryType {
let mut adjusted = *requested;
if requested.maximum.is_none() {
adjusted.maximum = Some(self.limit);
}
adjusted
}
/// Ensures a given memory type does not exceed the memory limit.
/// Call this after adjusting the memory.
fn validate_memory(&self, ty: &MemoryType) -> Result<(), MemoryError> {
if ty.minimum > self.limit {
return Err(MemoryError::Generic(format!(
"Minimum {} exceeds the allowed memory limit {}",
ty.minimum.0, self.limit.0
)));
}
if let Some(max) = ty.maximum {
if max > self.limit {
return Err(MemoryError::Generic(format!(
"Maximum {} exceeds the allowed memory limit {}",
max.0, self.limit.0
)));
}
} else {
return Err(MemoryError::Generic("Maximum not set".to_string()));
}
Ok(())
}
}
impl<T: Tunables> Tunables for LimitingTunables<T> {
/// Construct a `MemoryStyle` for the provided `MemoryType`
///
/// Delegated to base.
fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
let adjusted = self.adjust_memory(memory);
self.base.memory_style(&adjusted)
}
/// Construct a `TableStyle` for the provided `TableType`
///
/// Delegated to base.
fn table_style(&self, table: &TableType) -> TableStyle {
self.base.table_style(table)
}
/// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`].
///
/// The requested memory type is validated, adjusted to the limited and then passed to base.
fn create_host_memory(&self, ty: &MemoryType, style: &MemoryStyle) -> Result<VMMemory, MemoryError> {
let adjusted = self.adjust_memory(ty);
self.validate_memory(&adjusted)?;
self.base.create_host_memory(&adjusted, style)
}
/// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`].
///
/// Delegated to base.
unsafe fn create_vm_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
vm_definition_location: NonNull<VMMemoryDefinition>,
) -> Result<VMMemory, MemoryError> {
let adjusted = self.adjust_memory(ty);
self.validate_memory(&adjusted)?;
unsafe { self.base.create_vm_memory(&adjusted, style, vm_definition_location) }
}
/// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
///
/// Delegated to base.
fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
self.base.create_host_table(ty, style)
}
/// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`].
///
/// Delegated to base.
unsafe fn create_vm_table(
&self,
ty: &TableType,
style: &TableStyle,
vm_definition_location: NonNull<VMTableDefinition>,
) -> Result<VMTable, String> {
unsafe { self.base.create_vm_table(ty, style, vm_definition_location) }
}
}