cranelift_jit/memory/
mod.rs

1use cranelift_module::{ModuleError, ModuleResult};
2use std::io;
3
4mod arena;
5mod system;
6
7pub use arena::ArenaMemoryProvider;
8pub use system::SystemMemoryProvider;
9
10/// Type of branch protection to apply to executable memory.
11#[derive(Clone, Copy, Debug, PartialEq)]
12pub enum BranchProtection {
13    /// No protection.
14    None,
15    /// Use the Branch Target Identification extension of the Arm architecture.
16    BTI,
17}
18
19pub enum JITMemoryKind {
20    /// Allocate memory that will be executable once finalized.
21    Executable,
22    /// Allocate writable memory.
23    Writable,
24    /// Allocate memory that will be read-only once finalized.
25    ReadOnly,
26}
27
28/// A provider of memory for the JIT.
29pub trait JITMemoryProvider {
30    /// Allocate memory
31    fn allocate(&mut self, size: usize, align: u64, kind: JITMemoryKind) -> io::Result<*mut u8>;
32
33    /// Free the memory region.
34    unsafe fn free_memory(&mut self);
35    /// Finalize the memory region and apply memory protections.
36    fn finalize(&mut self, branch_protection: BranchProtection) -> ModuleResult<()>;
37}
38
39/// Marks the memory region as readable and executable.
40///
41/// This function deals with applies branch protection and clears the icache,
42/// but *doesn't* flush the pipeline. Callers have to ensure that
43/// [`wasmtime_jit_icache_coherence::pipeline_flush_mt`] is called before the
44/// mappings are used.
45pub(crate) fn set_readable_and_executable(
46    ptr: *mut u8,
47    len: usize,
48    branch_protection: BranchProtection,
49) -> ModuleResult<()> {
50    // Clear all the newly allocated code from cache if the processor requires it
51    //
52    // Do this before marking the memory as R+X, technically we should be able to do it after
53    // but there are some CPU's that have had errata about doing this with read only memory.
54    unsafe {
55        wasmtime_jit_icache_coherence::clear_cache(ptr as *const libc::c_void, len)
56            .expect("Failed cache clear")
57    };
58
59    unsafe {
60        region::protect(ptr, len, region::Protection::READ_EXECUTE).map_err(|e| {
61            ModuleError::Backend(
62                anyhow::Error::new(e).context("unable to make memory readable+executable"),
63            )
64        })?;
65    }
66
67    // If BTI is requested, and the architecture supports it, use mprotect to set the PROT_BTI flag.
68    if branch_protection == BranchProtection::BTI {
69        #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
70        if std::arch::is_aarch64_feature_detected!("bti") {
71            let prot = libc::PROT_EXEC | libc::PROT_READ | /* PROT_BTI */ 0x10;
72
73            unsafe {
74                if libc::mprotect(ptr as *mut libc::c_void, len, prot) < 0 {
75                    return Err(ModuleError::Backend(
76                        anyhow::Error::new(io::Error::last_os_error())
77                            .context("unable to make memory readable+executable"),
78                    ));
79                }
80            }
81        }
82    }
83
84    Ok(())
85}
cranelift_jit/memory/mod.rs

cranelift_jit/memory/
mod.rs
