wasmer_types/
error.rs

1//! The WebAssembly possible errors
2use crate::{ExternType, Pages, progress::UserAbort};
3use std::io;
4use thiserror::Error;
5
6/// The Serialize error can occur when serializing a
7/// compiled Module into a binary.
8#[derive(Error, Debug)]
9pub enum SerializeError {
10    /// An IO error
11    #[error(transparent)]
12    Io(#[from] io::Error),
13    /// A generic serialization error
14    #[error("{0}")]
15    Generic(String),
16}
17
18/// The Deserialize error can occur when loading a
19/// compiled Module from a binary.
20#[derive(Error, Debug)]
21pub enum DeserializeError {
22    /// An IO error
23    #[error(transparent)]
24    Io(#[from] io::Error),
25    /// A generic deserialization error
26    #[error("{0}")]
27    Generic(String),
28    /// Incompatible serialized binary
29    #[error("incompatible binary: {0}")]
30    Incompatible(String),
31    /// The provided binary is corrupted
32    #[error("corrupted binary: {0}")]
33    CorruptedBinary(String),
34    /// The binary was valid, but we got an error when
35    /// trying to allocate the required resources.
36    #[error(transparent)]
37    Compiler(#[from] CompileError),
38    /// Input artifact bytes have an invalid length
39    #[error("invalid input bytes: expected {expected} bytes, got {got}")]
40    InvalidByteLength {
41        /// How many bytes were expected
42        expected: usize,
43        /// How many bytes the artifact contained
44        got: usize,
45    },
46}
47
48/// Error type describing things that can go wrong when operating on Wasm Memories.
49#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
50#[non_exhaustive]
51pub enum MemoryError {
52    /// Low level error with mmap.
53    #[error("Error when allocating memory: {0}")]
54    Region(String),
55    /// The operation would cause the size of the memory to exceed the maximum or would cause
56    /// an overflow leading to unindexable memory.
57    #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)]
58    CouldNotGrow {
59        /// The current size in pages.
60        current: Pages,
61        /// The attempted amount to grow by in pages.
62        attempted_delta: Pages,
63    },
64    /// Invalid memory was provided.
65    #[error("The memory is invalid because {}", reason)]
66    InvalidMemory {
67        /// The reason why the provided memory is invalid.
68        reason: String,
69    },
70    /// Caller asked for more minimum memory than we can give them.
71    #[error("The minimum requested ({} pages) memory is greater than the maximum allowed memory ({} pages)", min_requested.0, max_allowed.0)]
72    MinimumMemoryTooLarge {
73        /// The number of pages requested as the minimum amount of memory.
74        min_requested: Pages,
75        /// The maximum amount of memory we can allocate.
76        max_allowed: Pages,
77    },
78    /// Caller asked for a maximum memory greater than we can give them.
79    #[error("The maximum requested memory ({} pages) is greater than the maximum allowed memory ({} pages)", max_requested.0, max_allowed.0)]
80    MaximumMemoryTooLarge {
81        /// The number of pages requested as the maximum amount of memory.
82        max_requested: Pages,
83        /// The number of pages requested as the maximum amount of memory.
84        max_allowed: Pages,
85    },
86    /// Returned when a shared memory is required, but the given memory is not shared.
87    #[error("The memory is not shared")]
88    MemoryNotShared,
89    /// Returned when trying to call a memory operation that is not supported by
90    /// the particular memory implementation.
91    #[error("tried to call an unsupported memory operation: {message}")]
92    UnsupportedOperation {
93        /// Message describing the unsupported operation.
94        message: String,
95    },
96    /// An atomic operation failed.
97    #[error("Atomic operation failed: {0}")]
98    AtomicOperationFailed(AtomicsError),
99    /// A user defined error value, used for error cases not listed above.
100    #[error("A user-defined error occurred: {0}")]
101    Generic(String),
102}
103
104/// Error that can occur during atomic operations. (notify/wait)
105// Non-exhaustive to allow for future variants without breaking changes!
106#[derive(PartialEq, Eq, Debug, Error, Clone, Copy, Hash)]
107#[non_exhaustive]
108pub enum AtomicsError {
109    /// Atomic operations are not supported by this memory.
110    #[error("The memory does not support atomic operations")]
111    Unimplemented,
112    /// Too many waiters for address.
113    #[error("Too many waiters for address")]
114    TooManyWaiters,
115    /// Atomic operations are disabled.
116    #[error("Atomic operations are disabled for this memory")]
117    AtomicsDisabled,
118    /// The memory was already dropped.
119    #[error("The memory was already dropped")]
120    MemoryDropped,
121}
122
123/// An ImportError.
124///
125/// Note: this error is not standard to WebAssembly, but it's
126/// useful to determine the import issue on the API side.
127#[derive(Error, Debug, Clone)]
128pub enum ImportError {
129    /// Incompatible Import Type.
130    /// This error occurs when the import types mismatch.
131    #[error("incompatible import type. Expected {0:?} but received {1:?}")]
132    IncompatibleType(ExternType, ExternType),
133
134    /// Unknown Import.
135    /// This error occurs when an import was expected but not provided.
136    #[error("unknown import. Expected {0:?}")]
137    UnknownImport(ExternType),
138
139    /// Memory Error
140    #[error("memory error. {0}")]
141    MemoryError(String),
142}
143
144/// An error while preinstantiating a module.
145///
146#[derive(Error, Debug)]
147pub enum PreInstantiationError {
148    /// The module was compiled with a CPU feature that is not available on
149    /// the current host.
150    #[error("module compiled with CPU feature that is missing from host")]
151    CpuFeature(String),
152}
153
154use std::string::String;
155
156// Compilation Errors
157
158/// The WebAssembly.CompileError object indicates an error during
159/// WebAssembly decoding or validation.
160///
161/// This mirrors the WebAssembly `CompileError` API described at
162/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError>.
163#[derive(Error, Debug)]
164pub enum CompileError {
165    /// A Wasm translation error occurred.
166    #[error("WebAssembly translation error: {0}")]
167    Wasm(WasmError),
168
169    /// A compilation error occurred.
170    #[error("Compilation error: {0}")]
171    Codegen(String),
172
173    /// The module did not pass validation.
174    #[error("Validation error: {0}")]
175    Validate(String),
176
177    /// The compiler doesn't support a Wasm feature
178    #[error("Feature {0} is not yet supported")]
179    UnsupportedFeature(String),
180
181    /// The compiler cannot compile for the given target.
182    /// This can refer to the OS, the chipset or any other aspect of the target system.
183    #[error("The target {0} is not yet supported (see https://docs.wasmer.io/runtime/features)")]
184    UnsupportedTarget(String),
185
186    /// Insufficient resources available for execution.
187    #[error("Insufficient resources: {0}")]
188    Resource(String),
189
190    /// Middleware error occurred.
191    #[error("Middleware error: {0}")]
192    MiddlewareError(String),
193
194    /// Compilation aborted by a user callback.
195    #[error("Compilation aborted: {0}")]
196    Aborted(UserAbort),
197}
198
199impl From<WasmError> for CompileError {
200    fn from(original: WasmError) -> Self {
201        Self::Wasm(original)
202    }
203}
204
205impl From<UserAbort> for CompileError {
206    fn from(abort: UserAbort) -> Self {
207        Self::Aborted(abort)
208    }
209}
210
211/// A error in the middleware.
212#[derive(Error, Debug)]
213#[error("Error in middleware {name}: {message}")]
214pub struct MiddlewareError {
215    /// The name of the middleware where the error was created
216    pub name: String,
217    /// The error message
218    pub message: String,
219}
220
221impl MiddlewareError {
222    /// Create a new `MiddlewareError`
223    pub fn new<A: Into<String>, B: Into<String>>(name: A, message: B) -> Self {
224        Self {
225            name: name.into(),
226            message: message.into(),
227        }
228    }
229}
230
231impl From<MiddlewareError> for CompileError {
232    fn from(error: MiddlewareError) -> Self {
233        WasmError::Middleware(error).into()
234    }
235}
236
237/// A WebAssembly translation error.
238///
239/// When a WebAssembly function can't be translated, one of these error codes will be returned
240/// to describe the failure.
241#[derive(Error, Debug)]
242pub enum WasmError {
243    /// The input WebAssembly code is invalid.
244    ///
245    /// This error code is used by a WebAssembly translator when it encounters invalid WebAssembly
246    /// code. This should never happen for validated WebAssembly code.
247    #[error("Invalid input WebAssembly code at offset {offset}: {message}")]
248    InvalidWebAssembly {
249        /// A string describing the validation error.
250        message: String,
251        /// The bytecode offset where the error occurred.
252        offset: usize,
253    },
254
255    /// A feature used by the WebAssembly code is not supported by the embedding environment.
256    ///
257    /// Embedding environments may have their own limitations and feature restrictions.
258    #[error("Unsupported feature: {0}")]
259    Unsupported(String),
260
261    /// An implementation limit was exceeded.
262    #[error("Implementation limit exceeded")]
263    ImplLimitExceeded,
264
265    /// An error from the middleware error.
266    #[error("{0}")]
267    Middleware(MiddlewareError),
268
269    /// A generic error.
270    #[error("{0}")]
271    Generic(String),
272}
273
274impl From<MiddlewareError> for WasmError {
275    fn from(original: MiddlewareError) -> Self {
276        Self::Middleware(original)
277    }
278}
279
280/// The error that can happen while parsing a `str`
281/// to retrieve a [`CpuFeature`](crate::target::CpuFeature).
282#[derive(Error, Debug)]
283pub enum ParseCpuFeatureError {
284    /// The provided string feature doesn't exist
285    #[error("CpuFeature {0} not recognized")]
286    Missing(String),
287}
288
289/// A convenient alias for a `Result` that uses `WasmError` as the error type.
290pub type WasmResult<T> = Result<T, WasmError>;
291
292#[cfg(test)]
293mod tests {
294    use super::*;
295
296    #[test]
297    fn middleware_error_can_be_created() {
298        let msg = String::from("Something went wrong");
299        let error = MiddlewareError::new("manipulator3000", msg);
300        assert_eq!(error.name, "manipulator3000");
301        assert_eq!(error.message, "Something went wrong");
302    }
303
304    #[test]
305    fn middleware_error_be_converted_to_wasm_error() {
306        let error = WasmError::from(MiddlewareError::new("manipulator3000", "foo"));
307        match error {
308            WasmError::Middleware(MiddlewareError { name, message }) => {
309                assert_eq!(name, "manipulator3000");
310                assert_eq!(message, "foo");
311            }
312            err => panic!("Unexpected error: {err:?}"),
313        }
314    }
315}
wasmer_types/error.rs

wasmer_types/
error.rs
