From 260b15474103e0e676096d6682917ea9004a4e7a Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 30 Apr 2021 23:28:31 +0800 Subject: [PATCH] clean up some boot process holdovers --- kernel/bin/riscv32i-unknown-none-elf.a | Bin 9078 -> 9078 bytes kernel/bin/riscv32imac-unknown-none-elf.a | Bin 8886 -> 8886 bytes kernel/bin/riscv32imc-unknown-none-elf.a | Bin 8886 -> 8886 bytes kernel/bin/riscv64gc-unknown-none-elf.a | Bin 14254 -> 14254 bytes kernel/bin/riscv64imac-unknown-none-elf.a | Bin 14254 -> 14254 bytes kernel/src/arch/riscv.rs | 4 +- kernel/src/arch/riscv/rand.rs | 28 +++--- kernel/src/asm.S | 22 ++++- kernel/src/main.rs | 109 ++++++---------------- loader/Cargo.toml | 4 +- loader/bin/riscv32i-unknown-none-elf.a | Bin 3146 -> 3098 bytes loader/bin/riscv32imac-unknown-none-elf.a | Bin 3154 -> 3106 bytes loader/bin/riscv32imc-unknown-none-elf.a | Bin 3154 -> 3106 bytes loader/bin/riscv64gc-unknown-none-elf.a | Bin 4818 -> 4730 bytes loader/bin/riscv64imac-unknown-none-elf.a | Bin 4818 -> 4730 bytes loader/src/asm.S | 3 - loader/src/main.rs | 43 +++++++-- services/susres/Cargo.toml | 2 +- services/susres/src/main.rs | 2 +- 19 files changed, 99 insertions(+), 118 deletions(-) diff --git a/kernel/bin/riscv32i-unknown-none-elf.a b/kernel/bin/riscv32i-unknown-none-elf.a index 14a3be90c8c64e5d97eeb334fb461733bf21445b..78f087d64a5d653b8fd10b7d97268a8a8034e97c 100644 GIT binary patch delta 81 zcmez7_RVdB1|uWKW=%#bCT%WG1_nlEW-!T!#AZbjVF9x_CigK*FkYQ}ky&wa7puYK N2h1&-Ygm5C0RZDa4o(07 delta 81 zcmez7_RVdB1|uWeW=%#bCT(U;1_nlE2+0U$vtfupWZ5S7F-tI>nS7C1adH={!Q=Qcnp5P?#{)7C#?Mw^}#S@f7@;}7?1@iyq zf4INdpV5QSg^QDcfsvUROfn*|S&>9oz-$gM31$OX42+BntV}?ff%)oWL1x9t`&bMn zD=@cg-oPxvwD}mT1|y@v mvU#~+FdtC=Z+UOVoXPGA{)|PFrvu5=lb-|0vzyHo>lp!&eLCR) delta 388 zcmdnyy3KWi8lz_KA#=w6|AiS3{-4aGpin%)N#Okl`+wV+7#fNvD2e2MsQ(M(|IPpK ze{&$C2cru!Cj$c`GlXOWv)M32AhHl~7LY6uGcYnTurdK@2Ie!94Ve`uA7C+K zc>%K;)8-?rT8xZ(li#z+*YknYfB_2wBajw@@)#H(d?_@(92#EFTgU)Pk%OoC{%tj1!y(VS|hkoDX3eZC)-I i%m>u}Ti%;7YqGn7KV!k<=|FPjQcnp5P?#{)7C#?Mw^}#S@f7@;}7?1@iyq zf4INdpV5QSg^QDcfsvUROfn*|S&>9oz-$gM31$OX42+BntV}?ff%)oWL1x9t`&bMn zD=@cg-oPxvwD}mT1|y@v mvU#~+FdtC=Z+UOVoXPGA{)|PFrvu5=lb-|0vzyHo>lp!&eLCR) delta 388 zcmdnyy3KWi8lz_KA#=w6|AiS3{-4aGpin%)N#Okl`+wV+7#fNvD2e2MsQ(M(|IPpK ze{&$C2cru!Cj$c`GlXOWv)M32AhHl~7LY6uGcYnTurdK@2Ie!94Ve`uA7C+K zc>%K;)8-?rT8xZ(li#z+*YknYfB_2wBajw@@)#H(d?_@(92#EFTgU)Pk%OoC{%tj1!y(VS|hkoDX3eZC)-I i%m>u}Ti%;7YqGn7KV!k<=|FPj2M3cmBO`+}Qcnp5P?#{=@vgvzY`KCQtgr zSUf>VB>%(wKkq-p|H=O#zd4;Tg^`hKG9!z)0V^j110ypdm}CKy90)d$#Q-#(lL<(J z0rS<#iOhtS@5JdsU!^D2%fT#PQ0`-R{;4F>JeIf^#1Ohm`)XKa~#+_;`=5hFy0BlF}7Mskz$Od>cR dvp|HDCZ9KwpZpFe!paH}5dw*9&NFpj0sx=VUbFxJ delta 350 zcmZ3Nzb=1+5u@qcW9E#E4AP7r{|gH;G72*u{6CpVL7{kplfe5A`~S{n5@47-=@Vn| z1SOID5BvYT|4{!Y|AYPJOvV&OVP;MS21aHG$p~h%O+LpY&d4_T2a^ornaP37ij#k^ z7)(xJZrS{bS%zsd3)><_Mytv3?BbL6u}d)Wfmn=kU{VQ8s)0!@FlhuP&A=pB52M{= zK{nydt2mx;F*;3N&mlg!PDE_-9$_gkPant=m@Fn@0pV?~6S=@7sKda(zz)PP05o4* zoY8FZejsTzxgSW{ZC)2M3cmBO`+}Qcnp5P?#{=@vgvzY`KCQtgr zSUf>VB>%(wKkq-p|H=O#zd4;Tg^`hKG9!z)0V^j110ypdm}CKy90)d$#Q-#(lL<(J z0rS<#iOhtS@5JdsU!^D2%fT#PQ0`-R{;4F>JeIf^#1Ohm`)XKa~#+_;`=5hFy0BlF}7Mskz$Od>cR dvp|HDCZ9KwpZpFe!paH}5dw*9&NFpj0sx=VUbFxJ delta 350 zcmZ3Nzb=1+5u@qcW9E#E4AP7r{|gH;G72*u{6CpVL7{kplfe5A`~S{n5@47-=@Vn| z1SOID5BvYT|4{!Y|AYPJOvV&OVP;MS21aHG$p~h%O+LpY&d4_T2a^ornaP37ij#k^ z7)(xJZrS{bS%zsd3)><_Mytv3?BbL6u}d)Wfmn=kU{VQ8s)0!@FlhuP&A=pB52M{= zK{nydt2mx;F*;3N&mlg!PDE_-9$_gkPant=m@Fn@0pV?~6S=@7sKda(zz)PP05o4* zoY8FZejsTzxgSW{ZC) PID { PID::new(satp::read().asid() as _).unwrap() } -pub fn init(resume: bool) { +pub fn init() { unsafe { sie::set_ssoft(); sie::set_sext(); } - rand::init(resume); + rand::init(); } /// Put the core to sleep until an interrupt hits. Returns `true` diff --git a/kernel/src/arch/riscv/rand.rs b/kernel/src/arch/riscv/rand.rs index ba258139f..1491696ee 100644 --- a/kernel/src/arch/riscv/rand.rs +++ b/kernel/src/arch/riscv/rand.rs @@ -15,7 +15,7 @@ pub struct Trng { pub base: *mut usize, } -pub fn init(resume: bool) { +pub fn init() { // Map the TRNG so that we can allocate names // hardware guarantees that: // - TRNG will automatically power on @@ -23,20 +23,18 @@ pub fn init(resume: bool) { // - Kernel FIFO will fill with TRNGs such that at least the next 512 calls to get_u32() will succeed without delay // - The kernel will start a TRNG server // - All further security decisions and policies are 100% delegated to this new server. - if !resume { - MemoryManager::with_mut(|memory_manager| { - memory_manager - .map_range( - utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8, - ((TRNG_KERNEL.base as u32) & !4095) as *mut u8, - 4096, - PID::new(1).unwrap(), - MemoryFlags::R | MemoryFlags::W, - MemoryType::Default, - ) - .expect("unable to map TRNG") - }); - } + MemoryManager::with_mut(|memory_manager| { + memory_manager + .map_range( + utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u8, + ((TRNG_KERNEL.base as u32) & !4095) as *mut u8, + 4096, + PID::new(1).unwrap(), + MemoryFlags::R | MemoryFlags::W, + MemoryType::Default, + ) + .expect("unable to map TRNG") + }); let trng_kernel_csr = CSR::new(TRNG_KERNEL.base as *mut u32); while trng_kernel_csr.rf(utra::trng_kernel::STATUS_AVAIL) == 0 {} diff --git a/kernel/src/asm.S b/kernel/src/asm.S index 628eeff65..6ebe062a7 100644 --- a/kernel/src/asm.S +++ b/kernel/src/asm.S @@ -30,26 +30,38 @@ _start: /////// resume prep code // if resume flag is false (0), skip this section - beq a3, zero, coldboot + beq a7, zero, coldboot + /* + This is the resume code. The overall strategy is to have a suspend/resume cycle + occur within an interrupt context. Thus, at this point of the suspend/resume + cycle (e.g. the resume half), our strategy is to restore a minimal environment which + allows a Xous interrupt context to run, which allows the Xous return-from-interrupt + handler to set up the remainder of the resume tasks. + */ // Restore a default stack pointer li sp, 0xfffefffc - // setup sie ssoft, sext: bits 1 and 9 0b10_0000_0010 + // setup sie [ssoft, sext]. This corresponds to bits 1 and 9, or 0b10_0000_0010 li t0, 0x202 csrw sie, t0 - // restore the SIM with the previously socked away value + // restore the SIM with the value previously socked away by the interrupt handler routine during the suspend half jal ra, _enable_all_irqs - // set scause to simulate an interrupt's occurence + // set scause to simulate an interrupt's occurence -- this makes the resume "feel like" an interrupt + // vectored into the same routine that caused the suspend, but without having gone through the typical + // interrupt handler mechanisms li t0, 0x80000000 csrw scause, t0 - // Note that registers $a0-$a7 still contain the arguments + // this is the same path the suspend interrupt took, but we set it up manually + // and the loader had flipped the "resume" bit, so this should bring us into the resume branch. j _start_trap_rust coldboot: + // Note that registers $a0-$a7 still contain the kernel arguments + // Jump to a program to initialize global variables. // Note that at this point, the .data section should // have already been set up by the loader. diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 76aa67611..112046596 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -39,112 +39,61 @@ fn handle_panic(_arg: &PanicInfo) -> ! { } } -use utralib::generated::*; -pub const RESUME_KICKER: ResumeKicker = ResumeKicker { - // the manually chosen virtual address has to be in the top 4MiB as it is the only page shared among all processes - base: 0xffcd_0000 as *mut usize, // see https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md -}; - -pub struct ResumeKicker { - pub base: *mut usize, -} - #[cfg(baremetal)] #[no_mangle] /// This function is called from baremetal startup code to initialize various kernel structures /// based on arguments passed by the bootloader. It is unused when running under an operating system. -pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32, resume: bool) { - if !resume { - unsafe { args::KernelArguments::init(arg_offset) }; - let args = args::KernelArguments::get(); - // Everything needs memory, so the first thing we should do is initialize the memory manager. - crate::mem::MemoryManager::with_mut(|mm| { - mm.init_from_memory(rpt_offset, &args) - .expect("couldn't initialize memory manager") - }); - SystemServices::with_mut(|system_services| { - system_services.init_from_memory(init_offset, &args) - }); - } +pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32) { + unsafe { args::KernelArguments::init(arg_offset) }; + let args = args::KernelArguments::get(); + // Everything needs memory, so the first thing we should do is initialize the memory manager. + crate::mem::MemoryManager::with_mut(|mm| { + mm.init_from_memory(rpt_offset, &args) + .expect("couldn't initialize memory manager") + }); + SystemServices::with_mut(|system_services| { + system_services.init_from_memory(init_offset, &args) + }); // Now that the memory manager is set up, perform any arch-specific initializations. - // each sub-call will handle things differently depending on the resume state - arch::init(resume); + arch::init(); // Either map memory using a syscall, or if we're debugging the syscall // handler then directly map it. #[cfg(any(feature = "debug-print", feature = "print-panics"))] { use utralib::generated::*; - if !resume { - // Map the serial port so println!() works as expected. - mem::MemoryManager::with_mut(|memory_manager| { - memory_manager - .map_range( - utra::uart::HW_UART_BASE as *mut u8, - ((debug::SUPERVISOR_UART_ADDR as u32) & !4095) as *mut u8, - 4096, - PID::new(1).unwrap(), - MemoryFlags::R | MemoryFlags::W, - MemoryType::Default, - ) - .expect("unable to map serial port") - }); - debug::Uart{}.init(); - println!("KMAIN (clean boot): Supervisor mode started..."); - println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ); - xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize) - .expect("Couldn't claim debug interrupt"); - print!("}} "); - } else { - println!("KMAIN (resume): Loader is instructing us to resume..."); - } - - if !resume { - // Print the processed kernel arguments - let args = args::KernelArguments::get(); - println!("Kernel arguments:"); - for arg in args.iter() { - println!(" {}", arg); - } - } - } - - if !resume { - // map in the resume kicker to its fixed virtual address for the next time we start with a resume + // Map the serial port so println!() works as expected. mem::MemoryManager::with_mut(|memory_manager| { memory_manager .map_range( - utra::resumekicker::HW_RESUMEKICKER_BASE as *mut u8, - ((RESUME_KICKER.base as u32) & !4095) as *mut u8, + utra::uart::HW_UART_BASE as *mut u8, + ((debug::SUPERVISOR_UART_ADDR as u32) & !4095) as *mut u8, 4096, PID::new(1).unwrap(), MemoryFlags::R | MemoryFlags::W, MemoryType::Default, ) - .expect("unable to map resume kicker for future resume use") + .expect("unable to map serial port") }); + debug::Uart{}.init(); + println!("KMAIN (clean boot): Supervisor mode started..."); + println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ); + xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize) + .expect("Couldn't claim debug interrupt"); + print!("}} "); + + // Print the processed kernel arguments + let args = args::KernelArguments::get(); + println!("Kernel arguments:"); + for arg in args.iter() { + println!(" {}", arg); + } } // rand::init() already clears the initial pipe, but pump the TRNG a little more out of no other reason than sheer paranoia arch::rand::get_u32(); arch::rand::get_u32(); - - if resume { - println!("Resume: enabling IRQs and kicking into the resume interrupt context"); - // this will reload the SIM from its backing store in RAM - crate::arch::irq::enable_all_irqs(); - // we should already have our page mapped from a prior boot - let mut resumekicker = CSR::new(RESUME_KICKER.base as *mut u32); - - // this should trigger a pending interrupt immediately - // note that the resumekicker's "kick" signal is a wire-OR into the susres SOFT_INT bit - // and that the loader will have set EV_ENABLE on this before handing control to the kernel - resumekicker.wfo(utra::resumekicker::KICKER_KICK, 1); - // when the handler returns to this closing curly brace, - // the control flow returns to the asm.S loader - // and the very next immediate thing it does is jump to kmain() and schedule the next PID to run! - } } /// Loop through the SystemServices list to determine the next PID to be run. diff --git a/loader/Cargo.toml b/loader/Cargo.toml index 1ecd16198..e00c26420 100644 --- a/loader/Cargo.toml +++ b/loader/Cargo.toml @@ -15,8 +15,8 @@ rand = "0.7.3" [features] debug-print = [] earlyprintk = [] -default = ["debug-print"] -#default = [] +#default = ["debug-print"] +default = [] [profile.release] codegen-units = 1 # 1 better optimizations diff --git a/loader/bin/riscv32i-unknown-none-elf.a b/loader/bin/riscv32i-unknown-none-elf.a index 44a5e478357e795b7c3dbaeefd84ff379e02d306..2a092a4b01b8cb661f86d19d1d7904bd92b911f7 100644 GIT binary patch delta 378 zcmXxdu}T9$5C-6xWiN)?1R@AIIgRIC%*I$KYGD}=)LtuVOS^PI$SWiaNC*hQ##T5) zL7yOLQse<_tt_ksXLiqlo%wd|_;(gfqTy5>o{S#bI33M}e| zX2C@Oa7<79<%;H^#XI`p-ly1D9MY+=YOzAMriIT$y!xVdW2;&LEcnQ~yYy{hT#~8S N2+9Bty!$UK@CVmnHEaL? delta 411 zcmZ9IF-rqM5QS%!tX%F+P!v3fns{q&gAo!C6vR%k66`HRu(|#UOB=DVF-#*yLDbSh zI0P+J&`ukB8++5}AJCaSMexDQeDijgUG^|~iuO;`+-&ExfiIostW3KeWKe70(IQ^a zCobpnYDsAXfRwUQ3)B3p6e2e1QjgRVwppVbGmZczxeiVjO+&bu_jIhbZ3DJQf02<% zmMpc^{M=hZOzEp^Fe2kyeZ>9)t@=i9Xn+;k@(r$2*SB~90ZpuNEMhYH}0L#~~o`=Ek7dJSyU_5hCA`<48(=o?vvIo$vN diff --git a/loader/bin/riscv32imac-unknown-none-elf.a b/loader/bin/riscv32imac-unknown-none-elf.a index c7453a93170465cabe9facae736dfb568c2c686c..a307283d9c3b2c38d52fde5408964f1b5bf18b37 100644 GIT binary patch delta 397 zcmXw!u}T9$5Qb;gyLjGhp(x})jpwb&CJ|AHXz2q8Vy%!jurj@kU`peZB7{`wEDq7a zE~QP-#v+Zcp^Y=UmmmI_Z)TT&+0S&8-VashXfSHxc<^x*UPE^9Mkn}E{9<2WmnhiB zZZQcoVwtc4|jwamtv zLs%2u@|+51Tv!r^+YTWU&ON)#P0wXc)lCv)${=A|D`wFJ^4E@IgArZEHhkdyJKe=5 zJP!d5>6uT?=qt8(OMhH@WD<*gI!&zlUZh^qz%f1Y>W3zYZD|ECWy`xQcEA>1VlS}g Rn$fDZX%qoG%~#y9io1?T`S3&BigAg4Y zbZ~I#B2JEili+6m0Ppe|1V8xh`{nMqg!KG3zkR8i8=YPq-#h)I(#zQ~1Zz*UiTBwz zo~y}yC}aULrgUO8FwL&5GEOIE=5wqM*Je2Vm|pFv@fFjmbF3!Wzz$XGfjN{FmT+9n z5gs|h**}hlJEPpf1=BAJFB+Z@t{JWf2V7Y4B{-iW$O#M$2f`6F@~8ahoEiK-6v-w_ zj_O)=C~>vj<^D76x{-Zg18h@^Cp&cIYP_R9*Hil8+NP?fmE+Ks7vn7* odK$loJiSy=03U35?K0b93y-l!*o6l4>1n^|09+I;PWk_$U!+7h7XSbN diff --git a/loader/bin/riscv32imc-unknown-none-elf.a b/loader/bin/riscv32imc-unknown-none-elf.a index c7453a93170465cabe9facae736dfb568c2c686c..a307283d9c3b2c38d52fde5408964f1b5bf18b37 100644 GIT binary patch delta 397 zcmXw!u}T9$5Qb;gyLjGhp(x})jpwb&CJ|AHXz2q8Vy%!jurj@kU`peZB7{`wEDq7a zE~QP-#v+Zcp^Y=UmmmI_Z)TT&+0S&8-VashXfSHxc<^x*UPE^9Mkn}E{9<2WmnhiB zZZQcoVwtc4|jwamtv zLs%2u@|+51Tv!r^+YTWU&ON)#P0wXc)lCv)${=A|D`wFJ^4E@IgArZEHhkdyJKe=5 zJP!d5>6uT?=qt8(OMhH@WD<*gI!&zlUZh^qz%f1Y>W3zYZD|ECWy`xQcEA>1VlS}g Rn$fDZX%qoG%~#y9io1?T`S3&BigAg4Y zbZ~I#B2JEili+6m0Ppe|1V8xh`{nMqg!KG3zkR8i8=YPq-#h)I(#zQ~1Zz*UiTBwz zo~y}yC}aULrgUO8FwL&5GEOIE=5wqM*Je2Vm|pFv@fFjmbF3!Wzz$XGfjN{FmT+9n z5gs|h**}hlJEPpf1=BAJFB+Z@t{JWf2V7Y4B{-iW$O#M$2f`6F@~8ahoEiK-6v-w_ zj_O)=C~>vj<^D76x{-Zg18h@^Cp&cIYP_R9*Hil8+NP?fmE+Ks7vn7* odK$loJiSy=03U35?K0b93y-l!*o6l4>1n^|09+I;PWk_$U!+7h7XSbN diff --git a/loader/bin/riscv64gc-unknown-none-elf.a b/loader/bin/riscv64gc-unknown-none-elf.a index eacb3a42bc450fc072facea68df5132d57de29c5..72c00d1178e4aa427e4394570b3e7826137bbf6c 100644 GIT binary patch delta 382 zcmcbl`b%ZPd}dQKgNcg_7y~9=Ze%THP%zjtIht|jWGN<(%~?zi%#3-H4Vi=|Ut=|4 z%-hV(*38JLHMyT%pHX%4ejuqm`8~Thqt<424rdnC-3$<*1f*o3Y!C$#R|B%8C(q{* zmsCcQ<$-RX~zefwDn*6({TSiZd#K%x9FvX%0w- z{N#S1O1aI;c~3I}y;sa{&bVRnYJPjpbx`9DO#aMo&gsAo;bu%W7BB~@%NDR_TERVe zjes5FoXM{R?17rJ1??FFCT9c52a{I=Ny*8t1?@#WK#m0h3l<110Hic0+Y4zkHcZYI NvS-@BGkJ}W8UPZtMF;=@ delta 505 zcmeyRa!GZyhJwk4Ov01bv6?UzY<|qz%*d!cIh|dfQEl>cc6~`5gn9-8C|eguYj3{K?#vRp z7b>I#q-CIN5Cs!g1G1%BH*Aoa3X#6jw1CcozqXH=OS&m%6WiljyW%4P!6@{{|4 zvIdnN{+$sq!Ej7ug@7O-bLF!?f& zTrpW#(4O(b-RX~zefwDn*6({TSiZd#K%x9FvX%0w- z{N#S1O1aI;c~3I}y;sa{&bVRnYJPjpbx`9DO#aMo&gsAo;bu%W7BB~@%NDR_TERVe zjes5FoXM{R?17rJ1??FFCT9c52a{I=Ny*8t1?@#WK#m0h3l<110Hic0+Y4zkHcZYI NvS-@BGkJ}W8UPZtMF;=@ delta 505 zcmeyRa!GZyhJwk4Ov01bv6?UzY<|qz%*d!cIh|dfQEl>cc6~`5gn9-8C|eguYj3{K?#vRp z7b>I#q-CIN5Cs!g1G1%BH*Aoa3X#6jw1CcozqXH=OS&m%6WiljyW%4P!6@{{|4 zvIdnN{+$sq!Ej7ug@7O-bLF!?f& zTrpW#(4O(b ! { }; read_initial_config(&mut cfg); + // check to see if we are recovering from a clean suspend or not let (clean, was_forced_suspend) = check_resume(&mut cfg); + if !clean { + // cold boot path println!("no suspend marker found, doing a cold boot!"); phase_1(&mut cfg); phase_2(&mut cfg); println!("done initializing for cold boot."); } else { + // resume path use utralib::generated::*; - // setup for a resume + // TRNG virtual memory mapping already set up, but the hardware needs + // to have its pipeline flushed, as the first result is always 0. + let trng_csr = CSR::new(utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u32); + for _ in 0..4 { // only one is strictly necessary but more is no problem + while trng_csr.rf(utra::trng_kernel::STATUS_AVAIL) == 0 {} + trng_csr.rf(utra::trng_kernel::DATA_DATA); + } + + // setup the `susres` register for a resume let mut resume_csr = CSR::new(utra::susres::HW_SUSRES_BASE as *mut u32); // set the resume marker for the SUSRES server, noting the forced suspend status if was_forced_suspend { @@ -1103,7 +1115,6 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! { // trigger the interrupt; it's not immediately handled, but rather checked later on by the kernel on clean resume resume_csr.wfo(utra::susres::INTERRUPT_INTERRUPT, 1); - // SATP restore is handled by the `start_kernel` assembly pre-amble } println!("Font maps located as follows:"); @@ -1130,6 +1141,14 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! { arg_offset, ip_offset, rpt_offset, ); + // save a copy of the computed kernel registers at the bottom of the page reserved + // for the bootloader stack. Note there is no stack-smash protection for these arguments, + // so we're definitely vulnerable to e.g. buffer overrun attacks in the early bootloader. + // + // Probably the right long-term solution to this is to turn all the bootloader "loading" + // actions into "verify" actions during a clean resume (right now we just don't run them), + // so that attempts to mess with the args during a resume can't lead to overwriting + // critical parameters like these kernel arguments. unsafe { let backup_args: *mut [u32; 7] = 0x40FF_F000 as *mut[u32; 7]; (*backup_args)[0] = arg_offset as u32; @@ -1139,9 +1158,12 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! { (*backup_args)[4] = cfg.processes[0].entrypoint as u32; (*backup_args)[5] = cfg.processes[0].sp as u32; (*backup_args)[6] = if cfg.debug {1} else {0}; - println!("Backup kernel args:"); - for i in 0..7 { - println!("0x{:08x}", (*backup_args)[i]); + #[cfg(feature="debug-print")] + { + println!("Backup kernel args:"); + for i in 0..7 { + println!("0x{:08x}", (*backup_args)[i]); + } } } unsafe { @@ -1159,13 +1181,16 @@ fn boot_sequence(args: KernelArguments, _signature: u32) -> ! { } else { unsafe { let backup_args: *mut [u32; 7] = 0x40FF_F000 as *mut[u32; 7]; - println!("Using backed up kernel args:"); - for i in 0..7 { - println!("0x{:08x}", (*backup_args)[i]); + #[cfg(feature="debug-print")] + { + println!("Using backed up kernel args:"); + for i in 0..7 { + println!("0x{:08x}", (*backup_args)[i]); + } } let satp = ((*backup_args)[3] as usize) & 0x803F_FFFF | (10 << 22); //let satp = (*backup_args)[3]; - println!("Adjusting SATP was: 0x{:08x} now: 0x{:08x}", (*backup_args)[3], satp); + println!("Adjusting SATP to the sures process. Was: 0x{:08x} now: 0x{:08x}", (*backup_args)[3], satp); if true { use utralib::generated::*; diff --git a/services/susres/Cargo.toml b/services/susres/Cargo.toml index 57d2e7f83..fda9665a0 100644 --- a/services/susres/Cargo.toml +++ b/services/susres/Cargo.toml @@ -22,4 +22,4 @@ utralib = { path = "../../utralib"} [features] debugprint = [] -default = ["debugprint"] +default = [] diff --git a/services/susres/src/main.rs b/services/susres/src/main.rs index 1cfdae21e..3ec5d4668 100644 --- a/services/susres/src/main.rs +++ b/services/susres/src/main.rs @@ -72,7 +72,7 @@ mod implementation { if sr.csr.rf(utra::susres::STATE_RESUME) == 0 { println!("going into suspend"); - if false { // this is just for testing + if true { // this is just for testing let mut reboot_csr = CSR::new(REBOOT_CSR.load(Ordering::Relaxed) as *mut u32); reboot_csr.wfo(utra::reboot::SOC_RESET_SOC_RESET, 0xAC); }