pagealloc 1.0.0

Low-level, cross-platform page allocation library
Documentation 
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

use crate::{Error, OsError, Protection, Result};
use core::ffi::c_void;
use core::mem::MaybeUninit;
use core::ptr::NonNull;
use windows_sys::Win32;

pub type RawOsError = i32;

pub unsafe fn alloc(location: *mut u8, size: usize, protection: Protection) -> Result<NonNull<u8>> {
    unsafe {
        let r = Win32::System::Memory::VirtualAlloc(
            location as *mut c_void,
            size,
            Win32::System::Memory::MEM_RESERVE | Win32::System::Memory::MEM_COMMIT,
            protection_flag(protection),
        );
        NonNull::new(r as *mut u8).ok_or_else(error)
    }
}

pub unsafe fn dealloc(start: NonNull<u8>, _: usize) -> Result<()> {
    unsafe {
        if Win32::System::Memory::VirtualFree(
            start.as_ptr() as *mut c_void,
            0,
            Win32::System::Memory::MEM_RELEASE,
        ) != 0
        {
            Ok(())
        } else {
            Err(error())
        }
    }
}

pub unsafe fn clear(start: NonNull<u8>, size: usize, protection: Protection) -> Result<()> {
    unsafe {
        if Win32::System::Memory::VirtualFree(
            start.as_ptr() as *mut c_void,
            0,
            Win32::System::Memory::MEM_DECOMMIT,
        ) != 0
            && !Win32::System::Memory::VirtualAlloc(
                start.as_ptr() as *mut c_void,
                size,
                Win32::System::Memory::MEM_COMMIT,
                protection_flag(protection),
            )
            .is_null()
        {
            Ok(())
        } else {
            Err(error())
        }
    }
}

pub unsafe fn protect(start: NonNull<u8>, size: usize, protection: Protection) -> Result<()> {
    unsafe {
        if Win32::System::Memory::VirtualProtect(
            start.as_ptr() as *mut c_void,
            size,
            protection_flag(protection),
            &mut 0,
        ) != 0
        {
            Ok(())
        } else {
            Err(error())
        }
    }
}

pub unsafe fn advise_free(start: NonNull<u8>, size: usize) -> Result<()> {
    unsafe {
        if !Win32::System::Memory::VirtualAlloc(
            start.as_ptr() as *mut c_void,
            size,
            Win32::System::Memory::MEM_RESET,
            Win32::System::Memory::PAGE_NOACCESS,
        )
        .is_null()
        {
            Ok(())
        } else {
            Err(error())
        }
    }
}

pub fn page_size() -> usize {
    let mut info = MaybeUninit::uninit();
    let info = unsafe {
        Win32::System::SystemInformation::GetSystemInfo(info.as_mut_ptr());
        info.assume_init()
    };

    info.dwPageSize as usize
}

pub fn alloc_granularity() -> usize {
    let mut info = MaybeUninit::uninit();
    let info = unsafe {
        Win32::System::SystemInformation::GetSystemInfo(info.as_mut_ptr());
        info.assume_init()
    };

    info.dwAllocationGranularity as usize
}

fn protection_flag(protection: Protection) -> Win32::System::Memory::PAGE_PROTECTION_FLAGS {
    match protection {
        Protection::None => Win32::System::Memory::PAGE_NOACCESS,
        Protection::Read => Win32::System::Memory::PAGE_READONLY,
        Protection::ReadWrite => Win32::System::Memory::PAGE_READWRITE,
        Protection::Exec => Win32::System::Memory::PAGE_EXECUTE,
        Protection::ExecRead => Win32::System::Memory::PAGE_EXECUTE_READ,
        Protection::ExecReadWrite => Win32::System::Memory::PAGE_EXECUTE_READWRITE,
    }
}

#[cold]
fn error() -> Error {
    unsafe { Error::Os(OsError(Win32::Foundation::GetLastError() as i32)) }
}