pagealloc 1.0.2

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use pagealloc::page_size;
use std::{
    env,
    hint::black_box,
    mem,
    process::{Command, ExitStatus},
    ptr,
};

fn assert_segfault(status: ExitStatus) {
    cfg_if::cfg_if! {
        if #[cfg(unix)] {
            use std::os::unix::process::ExitStatusExt;
            let signal = status.signal().unwrap();
            assert!(
                signal == libc::SIGSEGV || signal == libc::SIGBUS,
                "expected sigsegv ({}) or sigbus ({}), got {}",
                libc::SIGSEGV,
                libc::SIGBUS,
                signal,
            );
        } else if #[cfg(windows)] {
            assert_eq!(status.code(), Some(101));
        }
    }
}

macro_rules! test_should_crash {
    ($name:ident, $implementation:expr) => {
        test_should_crash!($name, $implementation, |_| true);
    };

    ($name:ident, $implementation:expr, $filter:expr) => {
        #[test]
        fn $name() {
            if env::var("PAGEALLOC_SHOULD_CRASH").is_ok() {
                ($implementation)();
                return;
            }
            let output = Command::new(env::current_exe().unwrap())
                .arg(stringify!($name))
                .arg("--nocapture")
                .arg("--exact")
                .env("PAGEALLOC_SHOULD_CRASH", "")
                .output()
                .unwrap();
            if output.status.success() {
                panic!(
                    "expected test to crash, got success.\nstdout: {}\nstderr: {}",
                    String::from_utf8_lossy(&output.stdout),
                    String::from_utf8_lossy(&output.stderr),
                );
            }
            ($filter)(output.status);
        }
    };
}

test_should_crash!(
    read_without_protection,
    read_without_protection_impl,
    assert_segfault
);
fn read_without_protection_impl() {
    let ptr =
        unsafe { pagealloc::alloc(ptr::null_mut(), page_size(), pagealloc::Protection::None) }
            .unwrap();
    black_box(unsafe { *ptr.as_ptr() });
}

test_should_crash!(
    write_without_protection,
    write_without_protection_impl,
    assert_segfault
);
fn write_without_protection_impl() {
    let ptr =
        unsafe { pagealloc::alloc(ptr::null_mut(), page_size(), pagealloc::Protection::Read) }
            .unwrap();
    unsafe { *ptr.as_ptr() = 0 };
}

test_should_crash!(
    write_then_read_without_protection,
    write_then_read_without_protection_impl,
    assert_segfault
);
fn write_then_read_without_protection_impl() {
    let ptr = unsafe {
        pagealloc::alloc(
            ptr::null_mut(),
            page_size(),
            pagealloc::Protection::ReadWrite,
        )
    }
    .unwrap();
    unsafe { *ptr.as_ptr() = 0 };
    unsafe { pagealloc::protect(ptr, page_size(), pagealloc::Protection::None).unwrap() };
    black_box(unsafe { *ptr.as_ptr() });
}

test_should_crash!(
    write_then_write_without_protection,
    write_then_write_without_protection_impl,
    assert_segfault
);
fn write_then_write_without_protection_impl() {
    let ptr = unsafe {
        pagealloc::alloc(
            ptr::null_mut(),
            page_size(),
            pagealloc::Protection::ReadWrite,
        )
    }
    .unwrap();
    unsafe { *ptr.as_ptr() = 0 };
    unsafe { pagealloc::protect(ptr, page_size(), pagealloc::Protection::Read).unwrap() };
    unsafe { *ptr.as_ptr() = 0 };
}

test_should_crash!(
    exec_without_protection,
    exec_without_protection_impl,
    assert_segfault
);
fn exec_without_protection_impl() {
    fn template_func() {}

    let ptr = unsafe {
        pagealloc::alloc(
            ptr::null_mut(),
            page_size(),
            pagealloc::Protection::ReadWrite,
        )
    }
    .unwrap();

    // Copy template_func to ptr
    unsafe { ptr::copy_nonoverlapping(template_func as *const u8, ptr.as_ptr(), page_size()) };

    unsafe { mem::transmute::<*mut u8, fn()>(ptr.as_ptr())() };
}