| use crate::syscalls; |
| use crate::ALLOCATOR; |
| use core::intrinsics; |
| use core::ptr; |
| |
| // _start and rust_start are the first two procedures executed when a Tock |
| // application starts. _start is invoked directly by the Tock kernel; it |
| // performs stack setup then calls rust_start. rust_start performs data |
| // relocation and sets up the heap before calling the rustc-generated main. |
| // rust_start and _start are tightly coupled. |
| // |
| // The memory layout is controlled by the linker script. |
| // |
| // When the kernel gives control to us, we get r0-r3 values that is as follows. |
| // |
| // +--------------+ <- (r2) mem.len() |
| // | Grant | |
| // +--------------+ |
| // | Unused | |
| // S +--------------+ <- (r3) app_heap_break |
| // R | Heap | (hardcoded to mem_start + 3072 in |
| // A +--------------| Processs::create which could be lesser than |
| // M | .bss | mem_start + stack + .data + .bss) |
| // +--------------| |
| // | .data | |
| // +--------------+ |
| // | Stack | |
| // +--------------+ <- (r1) mem_start |
| // |
| // +--------------+ |
| // | .text | |
| // F +--------------+ |
| // L | .crt0_header | |
| // A +--------------+ <- (r0) app_start |
| // S | Protected | |
| // H | Region | |
| // +--------------+ |
| // |
| // We want to organize the memory as follows. |
| // |
| // +--------------+ <- app_heap_break |
| // | Heap | |
| // +--------------| <- heap_start |
| // | .bss | |
| // +--------------| |
| // | .data | |
| // +--------------+ <- stack_start (stacktop) |
| // | Stack | |
| // | (grows down) | |
| // +--------------+ <- mem_start |
| // |
| // app_heap_break and mem_start are given to us by the kernel. The stack size is |
| // determined using pointer app_start, and is used with mem_start to compute |
| // stack_start (stacktop). The placement of .data and .bss are given to us by |
| // the linker script; the heap is located between the end of .bss and |
| // app_heap_break. This requires that .bss is the last (highest-address) section |
| // placed by the linker script. |
| |
| /// Tock programs' entry point. Called by the kernel at program start. Sets up |
| /// the stack then calls rust_start() for the remainder of setup. |
| #[cfg(target_arch = "arm")] |
| #[doc(hidden)] |
| #[no_mangle] |
| #[naked] |
| #[link_section = ".start"] |
| pub unsafe extern "C" fn _start( |
| app_start: usize, |
| mem_start: usize, |
| _memory_len: usize, |
| app_heap_break: usize, |
| ) -> ! { |
| asm!(" |
| // Because ROPI-RWPI support in LLVM/rustc is incomplete, Rust |
| // applications must be statically linked. An offset between the |
| // location the program is linked at and its actual location in flash |
| // would cause references in .data and .rodata to point to the wrong |
| // data. To mitigate this, this section checks that .text (and .start) |
| // are loaded at the correct location. If the application was linked and |
| // loaded correctly, the location of the first instruction (read using |
| // the Program Counter) will match the intended location of .start. We |
| // don't have an easy way to signal an error, so for now we just yield |
| // if the location is wrong. |
| sub r4, pc, #4 // r4 = pc |
| ldr r5, =.start // r5 = address of .start |
| cmp r4, r5 |
| beq .Lstack_init // Jump to stack initialization if pc was correct |
| .Lyield_loop: |
| svc 0 // yield() syscall |
| b .Lyield_loop |
| |
| .Lstack_init: |
| // Compute the stacktop (stack_start). The stacktop is computed as |
| // stack_size + mem_start plus padding to align the stack to a multiple |
| // of 8 bytes. The 8 byte alignment is to follow ARM AAPCS: |
| // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/ka4127.html |
| ldr r4, [r0, #36] // r4 = app_start->stack_size |
| add r4, r4, r1 // r4 = app_start->stack_size + mem_start |
| add r4, #7 // r4 = app_start->stack_size + mem_start + 7 |
| bic r4, r4, #7 // r4 = (app_start->stack_size + mem_start + 7) & ~0x7 |
| mov sp, r4 // sp = r4 |
| |
| // We need to pass app_start, stacktop and app_heap_break to rust_start. |
| // Temporarily store them in r6, r7 and r8 |
| mov r6, r0 |
| mov r7, sp |
| |
| // Debug support, tell the kernel the stack location |
| // |
| // memop(10, stacktop) |
| // r7 contains stacktop |
| mov r0, #10 |
| mov r1, r7 |
| svc 4 |
| |
| // Debug support, tell the kernel the heap_start location |
| mov r0, r6 |
| ldr r4, [r0, #24] // r4 = app_start->bss_start |
| ldr r5, [r0, #28] // r5 = app_start->bss_size |
| add r4, r4, r5 // r4 = bss_start + bss_size |
| // |
| // memop(11, r4) |
| mov r0, #11 |
| mov r1, r4 |
| svc 4 |
| |
| // Store heap_start (and soon to be app_heap_break) in r8 |
| mov r8, r4 |
| |
| // There is a possibility that stack + .data + .bss is greater than |
| // 3072. Therefore setup the initial app_heap_break to heap_start (that |
| // is zero initial heap) and let rust_start determine where the actual |
| // app_heap_break should go. |
| // |
| // Also, because app_heap_break is where the unprivileged MPU region |
| // ends, in case mem_start + stack + .data + .bss is greater than |
| // initial app_heap_break (mem_start + 3072), we will get a memory fault |
| // in rust_start when initializing .data and .bss. Setting |
| // app_heap_break to heap_start avoids that. |
| |
| // memop(0, r8) |
| mov r0, #0 |
| mov r1, r8 |
| svc 4 |
| |
| // NOTE: If there is a hard-fault before this point, then |
| // process_detail_fmt in kernel/src/process.rs panics which |
| // will result in us losing the PC of the instruction |
| // generating the hard-fault. Therefore any code before |
| // this point is critical code |
| |
| // Setup parameters needed by rust_start |
| // r6 (app_start), r7 (stacktop), r8 (app_heap_break) |
| mov r0, r6 |
| mov r1, r7 |
| mov r2, r8 |
| |
| // Call rust_start |
| bl rust_start" |
| : // No output operands |
| : "{r0}"(app_start), "{r1}"(mem_start), "{r3}"(app_heap_break) // Input operands |
| : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r12", |
| "cc", "memory" // Clobbers |
| : "volatile" // Options |
| ); |
| intrinsics::unreachable(); |
| } |
| |
| /// Tock programs' entry point. Called by the kernel at program start. Sets up |
| /// the stack then calls rust_start() for the remainder of setup. |
| #[cfg(target_arch = "riscv32")] |
| #[doc(hidden)] |
| #[naked] |
| #[no_mangle] |
| #[link_section = ".start"] |
| // The args for this function are: |
| // app_start: usize, |
| // mem_start: usize, |
| // memory_len: usize, |
| // app_heap_break: usize, |
| // Due to Rust issue: https://github.com/rust-lang/rust/issues/42779 we can't have |
| // args to the function |
| pub unsafe extern "C" fn _start() -> ! { |
| asm!( |
| // Compute the stack top. |
| // |
| // struct hdr* myhdr = (struct hdr*) app_start; |
| // uint32_t stacktop = (((uint32_t) mem_start + myhdr->stack_size + 7) & 0xfffffff8); |
| "lw t0, 36(a0) // t0 = myhdr->stack_size |
| addi t0, t0, 7 // t0 = myhdr->stack_size + 7 |
| add t0, t0, a1 // t0 = mem_start + myhdr->stack_size + 7 |
| li t1, 7 // t1 = 7 |
| not t1, t1 // t1 = ~0x7 |
| and t0, t0, t1 // t0 = (mem_start + myhdr->stack_size + 7) & ~0x7 |
| // |
| // Compute the app data size and where initial app brk should go. |
| // This includes the GOT, data, and BSS sections. However, we can't be sure |
| // the linker puts them back-to-back, but we do assume that BSS is last |
| // (i.e. myhdr->got_start < myhdr->bss_start && myhdr->data_start < |
| // myhdr->bss_start). With all of that true, then the size is equivalent |
| // to the end of the BSS section. |
| // |
| // uint32_t appdata_size = myhdr->bss_start + myhdr->bss_size; |
| lw t1, 24(a0) // t1 = myhdr->bss_start |
| lw t2, 28(a0) // t2 = myhdr->bss_size |
| lw t3, 4(a0) // t3 = myhdr->got_start |
| add t1, t1, t2 // t1 = bss_start + bss_size |
| // |
| // Move arguments we need to keep over to callee-saved locations. |
| mv s0, a0 // s0 = void* app_start |
| mv s1, t0 // s1 = stack_top |
| // |
| // Now we may want to move the stack pointer. If the kernel set the |
| // `app_heap_break` larger than we need (and we are going to call `brk()` |
| // to reduce it) then our stack pointer will fit and we can move it now. |
| // Otherwise after the first syscall (the memop to set the brk), the return |
| // will use a stack that is outside of the process accessible memory. |
| // |
| add t2, t0, t1 // t2 = stacktop + appdata_size |
| bgt t2, a3, skip_set_sp // Compare `app_heap_break` with new brk. |
| // If our current `app_heap_break` is larger |
| // then we need to move the stack pointer |
| // before we call the `brk` syscall. |
| mv sp, t0 // Update the stack pointer |
| |
| skip_set_sp: // Back to regularly scheduled programming. |
| |
| // Call `brk` to set to requested memory |
| |
| // memop(0, stacktop + appdata_size); |
| li a0, 4 // a0 = 4 // memop syscall |
| li a1, 0 // a1 = 0 |
| mv a2, t2 // a2 = stacktop + appdata_size |
| ecall // memop |
| // |
| // Debug support, tell the kernel the stack location |
| // |
| // memop(10, stacktop); |
| li a0, 4 // a0 = 4 // memop syscall |
| li a1, 10 // a1 = 10 |
| mv a2, s1 // a2 = stacktop |
| ecall // memop |
| // |
| // Debug support, tell the kernel the heap location |
| // |
| // memop(11, stacktop + appdata_size); |
| li a0, 4 // a0 = 4 // memop syscall |
| li a1, 11 // a1 = 10 |
| mv a2, t2 // a2 = stacktop + appdata_size |
| ecall // memop |
| // |
| // Setup initial stack pointer for normal execution |
| // Call into the rest of startup. This should never return. |
| mv sp, s1 // sp = stacktop |
| mv a0, s0 // first arg is app_start |
| mv s0, sp // Set the frame pointer to sp. |
| mv a1, s1 // second arg is stacktop |
| mv a1, s1 // second arg is stackto |
| jal rust_start" |
| : // No output operands |
| : |
| : "memory", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", |
| "t0", "t1", "t2", "t3", "t4", "t5", "t6", "ra" // Clobbers |
| : "volatile" // Options |
| ); |
| intrinsics::unreachable(); |
| } |
| |
| /// Ensure an abort symbol exists. |
| #[cfg(target_arch = "riscv32")] |
| #[link_section = ".start"] |
| #[export_name = "abort"] |
| pub extern "C" fn abort() { |
| unsafe { |
| asm! (" |
| // Simply go back to the start as if we had just booted. |
| j _start |
| " |
| : |
| : |
| : |
| : "volatile"); |
| } |
| } |
| |
| /// The header encoded at the beginning of .text by the linker script. It is |
| /// accessed by rust_start() using its app_start parameter. |
| #[repr(C)] |
| struct LayoutHeader { |
| got_sym_start: usize, |
| got_start: usize, |
| got_size: usize, |
| data_sym_start: usize, |
| data_start: usize, |
| data_size: usize, |
| bss_start: usize, |
| bss_size: usize, |
| reldata_start: usize, |
| stack_size: usize, |
| } |
| |
| /// Rust setup, called by _start. Uses the extern "C" calling convention so that |
| /// the assembly in _start knows how to call it (the Rust ABI is not defined). |
| /// Sets up the data segment (including relocations) and the heap, then calls |
| /// into the rustc-generated main(). This cannot use mutable global variables or |
| /// global references to globals until it is done setting up the data segment. |
| #[no_mangle] |
| pub unsafe extern "C" fn rust_start(app_start: usize, stacktop: usize, app_heap_break: usize) -> ! { |
| extern "C" { |
| // This function is created internally by `rustc`. See |
| // `src/lang_items.rs` for more details. |
| fn main(argc: isize, argv: *const *const u8) -> isize; |
| } |
| |
| // Copy .data into its final location in RAM (determined by the linker |
| // script -- should be immediately above the stack). |
| let layout_header: &LayoutHeader = core::mem::transmute(app_start); |
| |
| let data_flash_start_addr = app_start + layout_header.data_sym_start; |
| |
| intrinsics::copy_nonoverlapping( |
| data_flash_start_addr as *const u8, |
| stacktop as *mut u8, |
| layout_header.data_size, |
| ); |
| |
| // Zero .bss (specified by the linker script). |
| let bss_end = layout_header.bss_start + layout_header.bss_size; // 1 past the end of .bss |
| for i in layout_header.bss_start..bss_end { |
| core::ptr::write(i as *mut u8, 0); |
| } |
| |
| // TODO: Wait for rustc to have working ROPI-RWPI relocation support, then |
| // implement dynamic relocations here. At the moment, rustc does not have |
| // working ROPI-RWPI support, and it is not clear what that support would |
| // look like at the LLVM level. Once we know what the relocation strategy |
| // looks like we can write the dynamic linker. |
| |
| // Initialize the heap. Unlike libtock-c's newlib allocator, which can use |
| // `sbrk` system call to dynamically request heap memory from the kernel, we |
| // need to tell `linked_list_allocator` where the heap starts and ends. |
| // |
| // Heap size is set using `elf2tab` with `--app-heap` option, which is |
| // currently at 1024. If you change the `elf2tab` heap size, make sure to |
| // make the corresponding change here. |
| const HEAP_SIZE: usize = 1024; |
| |
| // we could have also bss_end for app_heap_start |
| let app_heap_start = app_heap_break; |
| let app_heap_end = app_heap_break + HEAP_SIZE; |
| |
| // tell the kernel the new app heap break |
| syscalls::memop(0, app_heap_end); |
| |
| ALLOCATOR.lock().init(app_heap_start, HEAP_SIZE); |
| |
| main(0, ptr::null()); |
| |
| loop { |
| syscalls::yieldk(); |
| } |
| } |
