T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Migrate from winapi to windows-sys (#4346)

Browse Source 
* Migrate from `winapi` to `windows-sys`

I believe that Microsoft itself is supporting the development of
`windows-sys` and it's also used by `cap-std` now so this switches
Wasmtime's dependencies on Windows APIs from the `winapi` crate to the
`windows-sys` crate. We still have `winapi` in our dependency graph but
that may get phased out over time.

* Make windows-sys a target-specific dependency
This commit is contained in:
Alex Crichton
2022-06-28 13:02:41 -05:00
committed by GitHub
parent 27b94a4173
commit df1502531d
15 changed files with 79 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
crates/runtime/Cargo.toml
View File

@@ -33,8 +33,15 @@ mach = "0.3.2"
[target.'cfg(unix)'.dependencies]
rustix = { version = "0.35.6", features = ["mm"] }
[target.'cfg(target_os = "windows")'.dependencies]
winapi = { version = "0.3.7", features = ["winbase", "memoryapi", "errhandlingapi", "handleapi"] }
[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
version = "0.36.0"
features = [
"Win32_System_Kernel",
"Win32_System_Memory",
"Win32_System_Diagnostics_Debug",
"Win32_Storage_FileSystem",
"Win32_Security",
]
[build-dependencies]
cc = "1.0"

3
crates/runtime/src/instance/allocator/pooling/windows.rs
View File

@@ -1,6 +1,5 @@
use anyhow::{bail, Result};
use winapi::um::memoryapi::{VirtualAlloc, VirtualFree};
use winapi::um::winnt::{MEM_COMMIT, MEM_DECOMMIT, PAGE_READWRITE};
use windows_sys::Win32::System::Memory::*;
pub fn commit(addr: *mut u8, len: usize) -> Result<()> {
if len == 0 {

29
crates/runtime/src/mmap.rs
View File

@@ -87,9 +87,10 @@ impl Mmap {
use std::fs::OpenOptions;
use std::io;
use std::os::windows::prelude::*;
use winapi::um::handleapi::*;
use winapi::um::memoryapi::*;
use winapi::um::winnt::*;
use windows_sys::Win32::Foundation::*;
use windows_sys::Win32::Storage::FileSystem::*;
use windows_sys::Win32::System::Memory::*;
unsafe {
// Open the file with read/execute access and only share for
// read. This will enable us to perform the proper mmap below
@@ -111,14 +112,14 @@ impl Mmap {
// Create a file mapping that allows PAGE_EXECUTE_READ which
// we'll be using for mapped text sections in ELF images later.
let mapping = CreateFileMappingW(
file.as_raw_handle().cast(),
file.as_raw_handle() as isize,
ptr::null_mut(),
PAGE_EXECUTE_READ,
0,
0,
ptr::null(),
);
if mapping.is_null() {
if mapping == 0 {
return Err(io::Error::last_os_error())
.context("failed to create file mapping");
}
@@ -219,8 +220,7 @@ impl Mmap {
pub fn accessible_reserved(accessible_size: usize, mapping_size: usize) -> Result<Self> {
use anyhow::bail;
use std::io;
use winapi::um::memoryapi::VirtualAlloc;
use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE};
use windows_sys::Win32::System::Memory::*;
if mapping_size == 0 {
return Ok(Self::new());
@@ -299,10 +299,10 @@ impl Mmap {
#[cfg(target_os = "windows")]
pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
use anyhow::bail;
use std::ffi::c_void;
use std::io;
use winapi::ctypes::c_void;
use winapi::um::memoryapi::VirtualAlloc;
use winapi::um::winnt::{MEM_COMMIT, PAGE_READWRITE};
use windows_sys::Win32::System::Memory::*;
let page_size = region::page::size();
assert_eq!(start & (page_size - 1), 0);
assert_eq!(len & (page_size - 1), 0);
@@ -383,8 +383,7 @@ impl Mmap {
#[cfg(windows)]
{
use std::io;
use winapi::um::memoryapi::*;
use winapi::um::winnt::*;
use windows_sys::Win32::System::Memory::*;
if self.file.is_some() {
let mut old = 0;
@@ -438,9 +437,9 @@ impl Drop for Mmap {
#[cfg(target_os = "windows")]
fn drop(&mut self) {
if self.len != 0 {
use winapi::ctypes::c_void;
use winapi::um::memoryapi::*;
use winapi::um::winnt::MEM_RELEASE;
use std::ffi::c_void;
use windows_sys::Win32::System::Memory::*;
if self.file.is_none() {
let r = unsafe { VirtualFree(self.ptr as *mut c_void, 0, MEM_RELEASE) };
assert_ne!(r, 0);

22
crates/runtime/src/traphandlers/windows.rs
View File

@@ -1,13 +1,11 @@
use crate::traphandlers::{tls, wasmtime_longjmp};
use std::io;
use winapi::um::errhandlingapi::*;
use winapi::um::minwinbase::*;
use winapi::um::winnt::*;
use winapi::vc::excpt::*;
use windows_sys::Win32::Foundation::*;
use windows_sys::Win32::System::Diagnostics::Debug::*;
use windows_sys::Win32::System::Kernel::*;
/// Function which may handle custom signals while processing traps.
pub type SignalHandler<'a> =
dyn Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
pub type SignalHandler<'a> = dyn Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
pub unsafe fn platform_init() {
// our trap handler needs to go first, so that we can recover from
@@ -21,7 +19,7 @@ pub unsafe fn platform_init() {
}
}
unsafe extern "system" fn exception_handler(exception_info: PEXCEPTION_POINTERS) -> LONG {
unsafe extern "system" fn exception_handler(exception_info: *mut EXCEPTION_POINTERS) -> i32 {
// Check the kind of exception, since we only handle a subset within
// wasm code. If anything else happens we want to defer to whatever
// the rest of the system wants to do for this exception.
@@ -31,7 +29,7 @@ unsafe extern "system" fn exception_handler(exception_info: PEXCEPTION_POINTERS)
&& record.ExceptionCode != EXCEPTION_INT_DIVIDE_BY_ZERO
&& record.ExceptionCode != EXCEPTION_INT_OVERFLOW
{
return EXCEPTION_CONTINUE_SEARCH;
return ExceptionContinueSearch;
}
// FIXME: this is what the previous C++ did to make sure that TLS
@@ -43,7 +41,7 @@ unsafe extern "system" fn exception_handler(exception_info: PEXCEPTION_POINTERS)
// Rust.
//
// if (!NtCurrentTeb()->Reserved1[sThreadLocalArrayPointerIndex]) {
// return EXCEPTION_CONTINUE_SEARCH;
// return ExceptionContinueSearch;
// }
// This is basically the same as the unix version above, only with a
@@ -51,7 +49,7 @@ unsafe extern "system" fn exception_handler(exception_info: PEXCEPTION_POINTERS)
tls::with(|info| {
let info = match info {
Some(info) => info,
None => return EXCEPTION_CONTINUE_SEARCH,
None => return ExceptionContinueSearch,
};
cfg_if::cfg_if! {
if #[cfg(target_arch = "x86_64")] {
@@ -64,9 +62,9 @@ unsafe extern "system" fn exception_handler(exception_info: PEXCEPTION_POINTERS)
}
let jmp_buf = info.jmp_buf_if_trap(ip, |handler| handler(exception_info));
if jmp_buf.is_null() {
EXCEPTION_CONTINUE_SEARCH
ExceptionContinueSearch
} else if jmp_buf as usize == 1 {
EXCEPTION_CONTINUE_EXECUTION
ExceptionContinueExecution
} else {
info.capture_backtrace(ip);
wasmtime_longjmp(jmp_buf)