Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 1 | // Copyright 2022, The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | //! Rust entry point. |
| 16 | |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 17 | use crate::{ |
Pierre-Clément Tosi | 38a3621 | 2024-06-06 11:30:39 +0100 | [diff] [blame] | 18 | bionic, console, heap, hyp, |
Pierre-Clément Tosi | 075aade | 2024-06-18 20:08:13 +0100 | [diff] [blame] | 19 | layout::{UART_ADDRESSES, UART_PAGE_ADDR}, |
Pierre-Clément Tosi | 38a3621 | 2024-06-06 11:30:39 +0100 | [diff] [blame] | 20 | logger, |
Pierre-Clément Tosi | 1f7c523 | 2024-08-13 19:51:25 +0100 | [diff] [blame] | 21 | memory::{PAGE_SIZE, SIZE_16KB, SIZE_4KB}, |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 22 | power::{reboot, shutdown}, |
Pierre-Clément Tosi | 62ffc0d | 2023-06-30 09:31:56 +0000 | [diff] [blame] | 23 | rand, |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 24 | }; |
Pierre-Clément Tosi | 62ffc0d | 2023-06-30 09:31:56 +0000 | [diff] [blame] | 25 | use core::mem::size_of; |
Pierre-Clément Tosi | c08e63c | 2024-05-14 11:17:47 +0100 | [diff] [blame] | 26 | use static_assertions::const_assert_eq; |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 27 | |
| 28 | fn try_console_init() -> Result<(), hyp::Error> { |
Pierre-Clément Tosi | a9b345f | 2024-04-27 01:01:42 +0100 | [diff] [blame] | 29 | if let Some(mmio_guard) = hyp::get_mmio_guard() { |
Pierre-Clément Tosi | 15ae4a5 | 2023-07-11 13:31:31 +0000 | [diff] [blame] | 30 | mmio_guard.enroll()?; |
Pierre-Clément Tosi | 32d9679 | 2024-04-29 01:19:37 +0100 | [diff] [blame] | 31 | |
| 32 | // TODO(ptosi): Use MmioSharer::share() to properly track this MMIO_GUARD_MAP. |
| 33 | // |
Pierre-Clément Tosi | c08e63c | 2024-05-14 11:17:47 +0100 | [diff] [blame] | 34 | // The following call shares the UART but also anything else present in 0..granule. |
| 35 | // |
| 36 | // For 4KiB, that's only the UARTs. For 16KiB, it also covers the RTC and watchdog but, as |
| 37 | // neither is used by vmbase clients (and as both are outside of the UART page), they |
| 38 | // will never have valid stage-1 mappings to those devices. As a result, this |
| 39 | // MMIO_GUARD_MAP isn't affected by the granule size in any visible way. Larger granule |
| 40 | // sizes will need to be checked separately, if needed. |
| 41 | assert!({ |
| 42 | let granule = mmio_guard.granule()?; |
| 43 | granule == SIZE_4KB || granule == SIZE_16KB |
| 44 | }); |
| 45 | // Validate the assumption above by ensuring that the UART is not moved to another page: |
Pierre-Clément Tosi | 38a3621 | 2024-06-06 11:30:39 +0100 | [diff] [blame] | 46 | const_assert_eq!(UART_PAGE_ADDR, 0); |
| 47 | mmio_guard.map(UART_PAGE_ADDR)?; |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 48 | } |
| 49 | |
Pierre-Clément Tosi | 8e92d1a | 2024-06-18 16:15:14 +0100 | [diff] [blame] | 50 | // SAFETY: UART_PAGE is mapped at stage-1 (see entry.S) and was just MMIO-guarded. |
Pierre-Clément Tosi | 075aade | 2024-06-18 20:08:13 +0100 | [diff] [blame] | 51 | unsafe { console::init(&UART_ADDRESSES) }; |
Pierre-Clément Tosi | 8e92d1a | 2024-06-18 16:15:14 +0100 | [diff] [blame] | 52 | |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 53 | Ok(()) |
| 54 | } |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 55 | |
| 56 | /// This is the entry point to the Rust code, called from the binary entry point in `entry.S`. |
| 57 | #[no_mangle] |
Andrew Walbran | e03395a | 2022-04-29 15:15:49 +0000 | [diff] [blame] | 58 | extern "C" fn rust_entry(x0: u64, x1: u64, x2: u64, x3: u64) -> ! { |
Andrew Walbran | 2e059cc | 2024-10-15 18:22:05 +0100 | [diff] [blame] | 59 | heap::init(); |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 60 | |
| 61 | if try_console_init().is_err() { |
| 62 | // Don't panic (or log) here to avoid accessing the console. |
| 63 | reboot() |
| 64 | } |
| 65 | |
| 66 | logger::init().expect("Failed to initialize the logger"); |
| 67 | // We initialize the logger to Off (like the log crate) and clients should log::set_max_level. |
| 68 | |
Pierre-Clément Tosi | 62ffc0d | 2023-06-30 09:31:56 +0000 | [diff] [blame] | 69 | const SIZE_OF_STACK_GUARD: usize = size_of::<u64>(); |
| 70 | let mut stack_guard = [0u8; SIZE_OF_STACK_GUARD]; |
| 71 | // We keep a null byte at the top of the stack guard to act as a string terminator. |
| 72 | let random_guard = &mut stack_guard[..(SIZE_OF_STACK_GUARD - 1)]; |
| 73 | |
Pierre-Clément Tosi | 20daaef | 2023-10-26 11:34:55 +0100 | [diff] [blame] | 74 | if let Err(e) = rand::init() { |
| 75 | panic!("Failed to initialize a source of entropy: {e}"); |
| 76 | } |
| 77 | |
| 78 | if let Err(e) = rand::fill_with_entropy(random_guard) { |
| 79 | panic!("Failed to get stack canary entropy: {e}"); |
| 80 | } |
| 81 | |
Pierre-Clément Tosi | 62ffc0d | 2023-06-30 09:31:56 +0000 | [diff] [blame] | 82 | bionic::__get_tls().stack_guard = u64::from_ne_bytes(stack_guard); |
| 83 | |
| 84 | // Note: If rust_entry ever returned (which it shouldn't by being -> !), the compiler-injected |
| 85 | // stack guard comparison would detect a mismatch and call __stack_chk_fail. |
| 86 | |
Andrew Walbran | c06e734 | 2023-07-05 14:00:51 +0000 | [diff] [blame] | 87 | // SAFETY: `main` is provided by the application using the `main!` macro, and we make sure it |
| 88 | // has the right type. |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 89 | unsafe { |
Andrew Walbran | e03395a | 2022-04-29 15:15:49 +0000 | [diff] [blame] | 90 | main(x0, x1, x2, x3); |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 91 | } |
| 92 | shutdown(); |
| 93 | } |
| 94 | |
| 95 | extern "Rust" { |
| 96 | /// Main function provided by the application using the `main!` macro. |
Andrew Walbran | e03395a | 2022-04-29 15:15:49 +0000 | [diff] [blame] | 97 | fn main(arg0: u64, arg1: u64, arg2: u64, arg3: u64); |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | /// Marks the main function of the binary. |
| 101 | /// |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 102 | /// Once main is entered, it can assume that: |
| 103 | /// - The panic_handler has been configured and panic!() and friends are available; |
| 104 | /// - The global_allocator has been configured and heap memory is available; |
| 105 | /// - The logger has been configured and the log::{info, warn, error, ...} macros are available. |
| 106 | /// |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 107 | /// Example: |
| 108 | /// |
| 109 | /// ```rust |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 110 | /// use vmbase::main; |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 111 | /// use log::{info, LevelFilter}; |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 112 | /// |
| 113 | /// main!(my_main); |
| 114 | /// |
| 115 | /// fn my_main() { |
Pierre-Clément Tosi | d330548 | 2023-06-29 15:03:48 +0000 | [diff] [blame] | 116 | /// log::set_max_level(LevelFilter::Info); |
Jakob Vukalovic | ef99629 | 2023-04-13 14:28:34 +0000 | [diff] [blame] | 117 | /// info!("Hello world"); |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 118 | /// } |
| 119 | /// ``` |
| 120 | #[macro_export] |
| 121 | macro_rules! main { |
| 122 | ($name:path) => { |
| 123 | // Export a symbol with a name matching the extern declaration above. |
| 124 | #[export_name = "main"] |
Andrew Walbran | e03395a | 2022-04-29 15:15:49 +0000 | [diff] [blame] | 125 | fn __main(arg0: u64, arg1: u64, arg2: u64, arg3: u64) { |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 126 | // Ensure that the main function provided by the application has the correct type. |
Andrew Walbran | e03395a | 2022-04-29 15:15:49 +0000 | [diff] [blame] | 127 | $name(arg0, arg1, arg2, arg3) |
Andrew Walbran | b996b4a | 2022-04-22 15:15:41 +0000 | [diff] [blame] | 128 | } |
| 129 | }; |
| 130 | } |
Pierre-Clément Tosi | 1f7c523 | 2024-08-13 19:51:25 +0100 | [diff] [blame] | 131 | |
| 132 | /// Prepends a Linux kernel header to the generated binary image. |
| 133 | /// |
| 134 | /// See https://docs.kernel.org/arch/arm64/booting.html |
| 135 | /// ``` |
| 136 | #[macro_export] |
| 137 | macro_rules! generate_image_header { |
| 138 | () => { |
| 139 | #[cfg(not(target_endian = "little"))] |
| 140 | compile_error!("Image header uses wrong endianness: bootloaders expect LE!"); |
| 141 | |
| 142 | core::arch::global_asm!( |
| 143 | // This section gets linked at the start of the image. |
| 144 | ".section .init.head, \"ax\"", |
| 145 | // This prevents the macro from being called more than once. |
| 146 | ".global image_header", |
| 147 | "image_header:", |
| 148 | // Linux uses a special NOP to be ELF-compatible; we're not. |
| 149 | "nop", // code0 |
| 150 | "b entry", // code1 |
| 151 | ".quad 0", // text_offset |
| 152 | ".quad bin_end - image_header", // image_size |
| 153 | ".quad (1 << 1)", // flags (PAGE_SIZE=4KiB) |
| 154 | ".quad 0", // res2 |
| 155 | ".quad 0", // res3 |
| 156 | ".quad 0", // res4 |
| 157 | ".ascii \"ARM\x64\"", // magic |
| 158 | ".long 0", // res5 |
| 159 | ); |
| 160 | }; |
| 161 | } |
| 162 | |
| 163 | // If this fails, the image header flags are out-of-sync with PAGE_SIZE! |
| 164 | static_assertions::const_assert_eq!(PAGE_SIZE, SIZE_4KB); |