roxy-loader 0.2.1

Lightweight Rust bootloader for kernel development.
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

use core::ptr::write_bytes;
use uefi::boot::{AllocateType, MemoryType, allocate_pages};

pub const PAGE_SIZE: u64 = 4096;

#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AllocationInfo {
    pub page_base: u64,
    pub page_offset: u64,
    pub alloc_size: u64,
    pub pages: usize,
}

impl AllocationInfo {
    #[must_use]
    pub fn from_region(addr: u64, size: u64) -> Self {
        let page_base = addr & !(PAGE_SIZE - 1);
        let page_offset = addr - page_base;
        let alloc_size = page_offset + size;
        let pages = alloc_size.div_ceil(PAGE_SIZE) as usize;

        Self {
            page_base,
            page_offset,
            alloc_size,
            pages,
        }
    }

    pub fn alloc(self) -> uefi::Result<*mut u8> {
        Ok(allocate_pages(
            AllocateType::Address(self.page_base),
            MemoryType::LOADER_DATA,
            self.pages,
        )?
        .as_ptr())
    }

    pub fn alloc_zeroed(self) -> uefi::Result<*mut u8> {
        let ptr = self.alloc()?;

        // The loader expects a fully zeroed backing region before segment contents are copied in.
        unsafe {
            write_bytes(ptr, 0, self.pages * PAGE_SIZE as usize);
        }

        Ok(ptr)
    }
}

#[cfg(test)]
mod tests {
    use super::{AllocationInfo, PAGE_SIZE};

    #[test]
    fn aligned_single_page_allocation() {
        assert_eq!(
            AllocationInfo::from_region(0x2000, 1),
            AllocationInfo {
                page_base: 0x2000,
                page_offset: 0,
                alloc_size: 1,
                pages: 1,
            }
        );
    }

    #[test]
    fn unaligned_address_accounts_for_offset() {
        assert_eq!(
            AllocationInfo::from_region(0x2123, 0x100),
            AllocationInfo {
                page_base: 0x2000,
                page_offset: 0x123,
                alloc_size: 0x223,
                pages: 1,
            }
        );
    }

    #[test]
    fn crossing_page_boundary_allocates_two_pages() {
        assert_eq!(
            AllocationInfo::from_region(PAGE_SIZE - 1, 2),
            AllocationInfo {
                page_base: 0,
                page_offset: PAGE_SIZE - 1,
                alloc_size: PAGE_SIZE + 1,
                pages: 2,
            }
        );
    }

    #[test]
    fn exact_multiple_of_page_size_does_not_round_up_extra() {
        assert_eq!(
            AllocationInfo::from_region(0x4000, PAGE_SIZE * 2),
            AllocationInfo {
                page_base: 0x4000,
                page_offset: 0,
                alloc_size: PAGE_SIZE * 2,
                pages: 2,
            }
        );
    }

    #[test]
    fn zero_sized_region_allocates_zero_pages() {
        assert_eq!(
            AllocationInfo::from_region(0x4000, 0),
            AllocationInfo {
                page_base: 0x4000,
                page_offset: 0,
                alloc_size: 0,
                pages: 0,
            }
        );
    }
}