pie-boot-loader-aarch64 0.1.1

Boot kernel code with mmu.
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

use crate::paging::PagingError;

#[cfg(feature = "console")]
use crate::debug::write_byte;

#[cfg(not(feature = "console"))]
pub fn write_byte(_b: u8) {}

pub trait Print {
    fn _print(self);
}

impl Print for usize {
    fn _print(self) {
        __print_hex(self)
    }
}

impl Print for u64 {
    fn _print(self) {
        __print_hex(self as _)
    }
}

impl Print for i32 {
    fn _print(self) {
        __print_hex(self as _)
    }
}

impl<T> Print for *mut T {
    fn _print(self) {
        __print_hex(self as _)
    }
}

impl Print for &str {
    fn _print(self) {
        __print_str(self);
    }
}

impl Print for bool {
    fn _print(self) {
        __print_str(if self { "true" } else { "false" })
    }
}

impl Print for PagingError {
    fn _print(self) {
        match self {
            PagingError::NoMemory => __print_str("NoMemory"),
            PagingError::NotAligned(e) => {
                __print_str("NotAligned: ");
                __print_str(e);
            }
            PagingError::NotMapped => __print_str("NotMapped"),
            PagingError::AlreadyMapped => __print_str("AlreadyMapped"),
        }
    }
}

impl Print for fdt_parser::FdtError<'_> {
    fn _print(self) {
        match self {
            fdt_parser::FdtError::BadCell => __print_str("BadCell"),
            fdt_parser::FdtError::NotFound(s) => {
                __print_str("NotFound: ");
                __print_str(s);
            }
            fdt_parser::FdtError::BadMagic => __print_str("BadMagic"),
            fdt_parser::FdtError::BadPtr => __print_str("BadPtr"),
            fdt_parser::FdtError::BadCellSize(s) => {
                __print_str("BadCellSize: ");
                __print_hex(s);
            }
            fdt_parser::FdtError::Eof => __print_str("Eof"),
            fdt_parser::FdtError::MissingProperty => __print_str("MissingProperty"),
            fdt_parser::FdtError::Utf8Parse { data: _ } => __print_str("Utf8Parse"),
            fdt_parser::FdtError::FromBytesUntilNull { data: _ } => {
                __print_str("FromBytesUntilNull")
            }
        }
    }
}

pub fn __print_str(s: &str) {
    for &b in s.as_bytes() {
        write_byte(b);
    }
}
pub fn __print_hex(v: usize) {
    const HEX_BUF_SIZE: usize = 20; // 最大长度，包括前缀"0x"和数字
    let mut hex_buf: [u8; HEX_BUF_SIZE] = [b'0'; HEX_BUF_SIZE];
    let mut n = v;
    __print_str("0x");

    if n == 0 {
        __print_str("0");
        return;
    }
    let mut i = 0;
    while n > 0 {
        let digit = n & 0xf;
        let ch = if digit < 10 {
            b'0' + digit as u8
        } else {
            b'a' + (digit - 10) as u8
        };
        n >>= 4; // 右移四位
        hex_buf[i] = ch;
        i += 1;
    }
    let s = &hex_buf[..i];
    for &ch in s.iter().rev() {
        write_byte(ch);
    }
}

#[macro_export]
macro_rules! early_err {
    ($f:expr) => {
        match $f {
            Ok(v) => v,
            Err(_e) => {
                $crate::println!("{}", _e);
                loop {}
            }
        }
    };
    ($f:expr, $msg:expr) => {
        match $f {
            Ok(v) => v,
            Err(_e) => {
                $crate::println!("{}:", $msg);
                $crate::println!("{}", _e);
                loop {}
            }
        }
    };
}