From 722e8b72329f5462945190df7843be8a3c36edfa Mon Sep 17 00:00:00 2001 From: Andre Richter Date: Thu, 31 Mar 2022 22:09:17 +0200 Subject: [PATCH] Print a timestamp on panic --- 07_timestamps/README.md | 72 +++++++++++------- 07_timestamps/src/_arch/aarch64/time.rs | 2 + 07_timestamps/src/panic_wait.rs | 17 ++++- 07_timestamps/src/print.rs | 36 +++------ 08_hw_debug_JTAG/src/_arch/aarch64/time.rs | 2 + 08_hw_debug_JTAG/src/panic_wait.rs | 17 ++++- 08_hw_debug_JTAG/src/print.rs | 36 +++------ 09_privilege_level/src/_arch/aarch64/time.rs | 2 + 09_privilege_level/src/panic_wait.rs | 17 ++++- 09_privilege_level/src/print.rs | 36 +++------ .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- .../src/print.rs | 36 +++------ .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- 11_exceptions_part1_groundwork/src/print.rs | 36 +++------ 12_integrated_testing/README.md | 15 ++-- .../src/_arch/aarch64/time.rs | 2 + 12_integrated_testing/src/panic_wait.rs | 17 ++++- 12_integrated_testing/src/print.rs | 36 +++------ .../tests/02_exception_sync_page_fault.rs | 6 +- 13_exceptions_part2_peripheral_IRQs/README.md | 10 +-- .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- .../src/print.rs | 36 +++------ .../tests/02_exception_sync_page_fault.rs | 6 +- 14_virtual_mem_part2_mmio_remap/README.md | 8 +- .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- 14_virtual_mem_part2_mmio_remap/src/print.rs | 36 +++------ .../tests/02_exception_sync_page_fault.rs | 8 +- .../README.md | 6 +- .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- .../src/print.rs | 36 +++------ .../tests/02_exception_sync_page_fault.rs | 4 +- .../README.md | 4 +- .../src/_arch/aarch64/time.rs | 2 + .../src/panic_wait.rs | 17 ++++- .../src/print.rs | 36 +++------ .../tests/02_exception_sync_page_fault.rs | 4 +- X1_JTAG_boot/jtag_boot_rpi3.img | Bin 7808 -> 7808 bytes X1_JTAG_boot/jtag_boot_rpi4.img | Bin 6528 -> 6832 bytes X1_JTAG_boot/src/_arch/aarch64/time.rs | 2 + X1_JTAG_boot/src/panic_wait.rs | 17 ++++- X1_JTAG_boot/src/print.rs | 36 +++------ 46 files changed, 400 insertions(+), 348 deletions(-) diff --git a/07_timestamps/README.md b/07_timestamps/README.md index 3e110030..762e3cb3 100644 --- a/07_timestamps/README.md +++ b/07_timestamps/README.md @@ -248,7 +248,7 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/cpu.rs 07_timestamps/src/_arch/a diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/aarch64/time.rs --- 06_uart_chainloader/src/_arch/aarch64/time.rs +++ 07_timestamps/src/_arch/aarch64/time.rs -@@ -0,0 +1,119 @@ +@@ -0,0 +1,121 @@ +// SPDX-License-Identifier: MIT OR Apache-2.0 +// +// Copyright (c) 2018-2022 Andre Richter @@ -329,6 +329,7 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/ + // Calculate the register compare value. + let frq = CNTFRQ_EL0.get(); + let x = match frq.checked_mul(duration.as_nanos() as u64) { ++ #[allow(unused_imports)] + None => { + warn!("Spin duration too long, skipping"); + return; @@ -347,6 +348,7 @@ diff -uNr 06_uart_chainloader/src/_arch/aarch64/time.rs 07_timestamps/src/_arch/ + None + }; + ++ #[allow(unused_imports)] + if let Some(w) = warn { + warn!( + "Spin duration {} than architecturally supported, skipping", @@ -630,10 +632,40 @@ diff -uNr 06_uart_chainloader/src/main.rs 07_timestamps/src/main.rs + } } +diff -uNr 06_uart_chainloader/src/panic_wait.rs 07_timestamps/src/panic_wait.rs +--- 06_uart_chainloader/src/panic_wait.rs ++++ 07_timestamps/src/panic_wait.rs +@@ -29,10 +29,23 @@ + + #[panic_handler] + fn panic(info: &PanicInfo) -> ! { ++ use crate::time::interface::TimeManager; ++ ++ let timestamp = crate::time::time_manager().uptime(); ++ + if let Some(args) = info.message() { +- panic_println!("\nKernel panic: {}", args); ++ panic_println!( ++ "[ {:>3}.{:06}] Kernel panic: {}", ++ timestamp.as_secs(), ++ timestamp.subsec_micros(), ++ args, ++ ); + } else { +- panic_println!("\nKernel panic!"); ++ panic_println!( ++ "[ {:>3}.{:06}] Kernel panic!", ++ timestamp.as_secs(), ++ timestamp.subsec_micros(), ++ ); + } + + cpu::wait_forever() + diff -uNr 06_uart_chainloader/src/print.rs 07_timestamps/src/print.rs --- 06_uart_chainloader/src/print.rs +++ 07_timestamps/src/print.rs -@@ -36,3 +36,71 @@ +@@ -36,3 +36,59 @@ $crate::print::_print(format_args_nl!($($arg)*)); }) } @@ -642,31 +674,25 @@ diff -uNr 06_uart_chainloader/src/print.rs 07_timestamps/src/print.rs +#[macro_export] +macro_rules! info { + ($string:expr) => ({ -+ #[allow(unused_imports)] -+ use crate::time::interface::TimeManager; ++ use $crate::time::interface::TimeManager; + + let timestamp = $crate::time::time_manager().uptime(); -+ let timestamp_subsec_us = timestamp.subsec_micros(); + + $crate::print::_print(format_args_nl!( -+ concat!("[ {:>3}.{:03}{:03}] ", $string), ++ concat!("[ {:>3}.{:06}] ", $string), + timestamp.as_secs(), -+ timestamp_subsec_us / 1_000, -+ timestamp_subsec_us modulo 1_000 ++ timestamp.subsec_micros(), + )); + }); + ($format_string:expr, $($arg:tt)*) => ({ -+ #[allow(unused_imports)] -+ use crate::time::interface::TimeManager; ++ use $crate::time::interface::TimeManager; + + let timestamp = $crate::time::time_manager().uptime(); -+ let timestamp_subsec_us = timestamp.subsec_micros(); + + $crate::print::_print(format_args_nl!( -+ concat!("[ {:>3}.{:03}{:03}] ", $format_string), ++ concat!("[ {:>3}.{:06}] ", $format_string), + timestamp.as_secs(), -+ timestamp_subsec_us / 1_000, -+ timestamp_subsec_us modulo 1_000, ++ timestamp.subsec_micros(), + $($arg)* + )); + }) @@ -676,31 +702,25 @@ diff -uNr 06_uart_chainloader/src/print.rs 07_timestamps/src/print.rs +#[macro_export] +macro_rules! warn { + ($string:expr) => ({ -+ #[allow(unused_imports)] -+ use crate::time::interface::TimeManager; ++ use $crate::time::interface::TimeManager; + + let timestamp = $crate::time::time_manager().uptime(); -+ let timestamp_subsec_us = timestamp.subsec_micros(); + + $crate::print::_print(format_args_nl!( -+ concat!("[W {:>3}.{:03}{:03}] ", $string), ++ concat!("[W {:>3}.{:06}] ", $string), + timestamp.as_secs(), -+ timestamp_subsec_us / 1_000, -+ timestamp_subsec_us modulo 1_000 ++ timestamp.subsec_micros(), + )); + }); + ($format_string:expr, $($arg:tt)*) => ({ -+ #[allow(unused_imports)] -+ use crate::time::interface::TimeManager; ++ use $crate::time::interface::TimeManager; + + let timestamp = $crate::time::time_manager().uptime(); -+ let timestamp_subsec_us = timestamp.subsec_micros(); + + $crate::print::_print(format_args_nl!( -+ concat!("[W {:>3}.{:03}{:03}] ", $format_string), ++ concat!("[W {:>3}.{:06}] ", $format_string), + timestamp.as_secs(), -+ timestamp_subsec_us / 1_000, -+ timestamp_subsec_us modulo 1_000, ++ timestamp.subsec_micros(), + $($arg)* + )); + }) diff --git a/07_timestamps/src/_arch/aarch64/time.rs b/07_timestamps/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/07_timestamps/src/_arch/aarch64/time.rs +++ b/07_timestamps/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/07_timestamps/src/panic_wait.rs b/07_timestamps/src/panic_wait.rs index 946041b3..923db329 100644 --- a/07_timestamps/src/panic_wait.rs +++ b/07_timestamps/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/07_timestamps/src/print.rs b/07_timestamps/src/print.rs index 5decb292..9ec13a28 100644 --- a/07_timestamps/src/print.rs +++ b/07_timestamps/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/08_hw_debug_JTAG/src/_arch/aarch64/time.rs b/08_hw_debug_JTAG/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/08_hw_debug_JTAG/src/_arch/aarch64/time.rs +++ b/08_hw_debug_JTAG/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/08_hw_debug_JTAG/src/panic_wait.rs b/08_hw_debug_JTAG/src/panic_wait.rs index 946041b3..923db329 100644 --- a/08_hw_debug_JTAG/src/panic_wait.rs +++ b/08_hw_debug_JTAG/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/08_hw_debug_JTAG/src/print.rs b/08_hw_debug_JTAG/src/print.rs index 5decb292..9ec13a28 100644 --- a/08_hw_debug_JTAG/src/print.rs +++ b/08_hw_debug_JTAG/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/09_privilege_level/src/_arch/aarch64/time.rs b/09_privilege_level/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/09_privilege_level/src/_arch/aarch64/time.rs +++ b/09_privilege_level/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/09_privilege_level/src/panic_wait.rs b/09_privilege_level/src/panic_wait.rs index 946041b3..923db329 100644 --- a/09_privilege_level/src/panic_wait.rs +++ b/09_privilege_level/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/09_privilege_level/src/print.rs b/09_privilege_level/src/print.rs index 5decb292..9ec13a28 100644 --- a/09_privilege_level/src/print.rs +++ b/09_privilege_level/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/10_virtual_mem_part1_identity_mapping/src/_arch/aarch64/time.rs b/10_virtual_mem_part1_identity_mapping/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/10_virtual_mem_part1_identity_mapping/src/_arch/aarch64/time.rs +++ b/10_virtual_mem_part1_identity_mapping/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/10_virtual_mem_part1_identity_mapping/src/panic_wait.rs b/10_virtual_mem_part1_identity_mapping/src/panic_wait.rs index 946041b3..923db329 100644 --- a/10_virtual_mem_part1_identity_mapping/src/panic_wait.rs +++ b/10_virtual_mem_part1_identity_mapping/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/10_virtual_mem_part1_identity_mapping/src/print.rs b/10_virtual_mem_part1_identity_mapping/src/print.rs index 5decb292..9ec13a28 100644 --- a/10_virtual_mem_part1_identity_mapping/src/print.rs +++ b/10_virtual_mem_part1_identity_mapping/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/11_exceptions_part1_groundwork/src/_arch/aarch64/time.rs b/11_exceptions_part1_groundwork/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/11_exceptions_part1_groundwork/src/_arch/aarch64/time.rs +++ b/11_exceptions_part1_groundwork/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/11_exceptions_part1_groundwork/src/panic_wait.rs b/11_exceptions_part1_groundwork/src/panic_wait.rs index 946041b3..923db329 100644 --- a/11_exceptions_part1_groundwork/src/panic_wait.rs +++ b/11_exceptions_part1_groundwork/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/11_exceptions_part1_groundwork/src/print.rs b/11_exceptions_part1_groundwork/src/print.rs index 5decb292..9ec13a28 100644 --- a/11_exceptions_part1_groundwork/src/print.rs +++ b/11_exceptions_part1_groundwork/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/12_integrated_testing/README.md b/12_integrated_testing/README.md index 48fd1876..71ee3342 100644 --- a/12_integrated_testing/README.md +++ b/12_integrated_testing/README.md @@ -849,9 +849,8 @@ Compiling integration test(s) - rpi3 🦀 Testing synchronous exception handling by causing a page fault ------------------------------------------------------------------- - Writing beyond mapped area to address 9 GiB... - - Kernel panic: + [ 0.163030] Writing beyond mapped area to address 9 GiB... + [ 0.164791] Kernel panic: CPU Exception! ESR_EL1: 0x96000004 @@ -1698,8 +1697,8 @@ diff -uNr 11_exceptions_part1_groundwork/src/panic_wait.rs 12_integrated_testing /// Prints with a newline - only use from the panic handler. /// /// Carbon copy from -@@ -35,5 +52,5 @@ - panic_println!("\nKernel panic!"); +@@ -48,5 +65,5 @@ + ); } - cpu::wait_forever() @@ -1929,7 +1928,7 @@ diff -uNr 11_exceptions_part1_groundwork/tests/02_exception_sync_page_fault.rs 1 +/// or indirectly. +mod panic_exit_success; + -+use libkernel::{bsp, cpu, exception, memory, println}; ++use libkernel::{bsp, cpu, exception, info, memory, println}; + +#[no_mangle] +unsafe fn kernel_init() -> ! { @@ -1942,11 +1941,11 @@ diff -uNr 11_exceptions_part1_groundwork/tests/02_exception_sync_page_fault.rs 1 + println!("Testing synchronous exception handling by causing a page fault"); + + if let Err(string) = memory::mmu::mmu().enable_mmu_and_caching() { -+ println!("MMU: {}", string); ++ info!("MMU: {}", string); + cpu::qemu_exit_failure() + } + -+ println!("Writing beyond mapped area to address 9 GiB..."); ++ info!("Writing beyond mapped area to address 9 GiB..."); + let big_addr: u64 = 9 * 1024 * 1024 * 1024; + core::ptr::read_volatile(big_addr as *mut u64); + diff --git a/12_integrated_testing/src/_arch/aarch64/time.rs b/12_integrated_testing/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/12_integrated_testing/src/_arch/aarch64/time.rs +++ b/12_integrated_testing/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/12_integrated_testing/src/panic_wait.rs b/12_integrated_testing/src/panic_wait.rs index a20e37e1..2e56f1ce 100644 --- a/12_integrated_testing/src/panic_wait.rs +++ b/12_integrated_testing/src/panic_wait.rs @@ -46,10 +46,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } _panic_exit() diff --git a/12_integrated_testing/src/print.rs b/12_integrated_testing/src/print.rs index 5decb292..9ec13a28 100644 --- a/12_integrated_testing/src/print.rs +++ b/12_integrated_testing/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/12_integrated_testing/tests/02_exception_sync_page_fault.rs b/12_integrated_testing/tests/02_exception_sync_page_fault.rs index 1c4133e1..9be94acd 100644 --- a/12_integrated_testing/tests/02_exception_sync_page_fault.rs +++ b/12_integrated_testing/tests/02_exception_sync_page_fault.rs @@ -17,7 +17,7 @@ /// or indirectly. mod panic_exit_success; -use libkernel::{bsp, cpu, exception, memory, println}; +use libkernel::{bsp, cpu, exception, info, memory, println}; #[no_mangle] unsafe fn kernel_init() -> ! { @@ -30,11 +30,11 @@ unsafe fn kernel_init() -> ! { println!("Testing synchronous exception handling by causing a page fault"); if let Err(string) = memory::mmu::mmu().enable_mmu_and_caching() { - println!("MMU: {}", string); + info!("MMU: {}", string); cpu::qemu_exit_failure() } - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/13_exceptions_part2_peripheral_IRQs/README.md b/13_exceptions_part2_peripheral_IRQs/README.md index df20c15b..42b984b7 100644 --- a/13_exceptions_part2_peripheral_IRQs/README.md +++ b/13_exceptions_part2_peripheral_IRQs/README.md @@ -2511,15 +2511,15 @@ diff -uNr 12_integrated_testing/src/panic_wait.rs 13_exceptions_part2_peripheral use core::{fmt, panic::PanicInfo}; //-------------------------------------------------------------------------------------------------- -@@ -46,6 +46,8 @@ - - #[panic_handler] +@@ -48,6 +48,8 @@ fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + unsafe { exception::asynchronous::local_irq_mask() }; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); - } else { diff -uNr 12_integrated_testing/src/state.rs 13_exceptions_part2_peripheral_IRQs/src/state.rs --- 12_integrated_testing/src/state.rs diff --git a/13_exceptions_part2_peripheral_IRQs/src/_arch/aarch64/time.rs b/13_exceptions_part2_peripheral_IRQs/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/13_exceptions_part2_peripheral_IRQs/src/_arch/aarch64/time.rs +++ b/13_exceptions_part2_peripheral_IRQs/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/13_exceptions_part2_peripheral_IRQs/src/panic_wait.rs b/13_exceptions_part2_peripheral_IRQs/src/panic_wait.rs index 0f958f28..da7106c9 100644 --- a/13_exceptions_part2_peripheral_IRQs/src/panic_wait.rs +++ b/13_exceptions_part2_peripheral_IRQs/src/panic_wait.rs @@ -46,12 +46,25 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + unsafe { exception::asynchronous::local_irq_mask() }; + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } _panic_exit() diff --git a/13_exceptions_part2_peripheral_IRQs/src/print.rs b/13_exceptions_part2_peripheral_IRQs/src/print.rs index 5decb292..9ec13a28 100644 --- a/13_exceptions_part2_peripheral_IRQs/src/print.rs +++ b/13_exceptions_part2_peripheral_IRQs/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault.rs b/13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault.rs index 1c4133e1..9be94acd 100644 --- a/13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault.rs +++ b/13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault.rs @@ -17,7 +17,7 @@ /// or indirectly. mod panic_exit_success; -use libkernel::{bsp, cpu, exception, memory, println}; +use libkernel::{bsp, cpu, exception, info, memory, println}; #[no_mangle] unsafe fn kernel_init() -> ! { @@ -30,11 +30,11 @@ unsafe fn kernel_init() -> ! { println!("Testing synchronous exception handling by causing a page fault"); if let Err(string) = memory::mmu::mmu().enable_mmu_and_caching() { - println!("MMU: {}", string); + info!("MMU: {}", string); cpu::qemu_exit_failure() } - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/14_virtual_mem_part2_mmio_remap/README.md b/14_virtual_mem_part2_mmio_remap/README.md index 82fa51a2..3f6c78e9 100644 --- a/14_virtual_mem_part2_mmio_remap/README.md +++ b/14_virtual_mem_part2_mmio_remap/README.md @@ -3609,17 +3609,17 @@ diff -uNr 13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault println!("Testing synchronous exception handling by causing a page fault"); - if let Err(string) = memory::mmu::mmu().enable_mmu_and_caching() { -- println!("MMU: {}", string); +- info!("MMU: {}", string); + let phys_kernel_tables_base_addr = match memory::mmu::kernel_map_binary() { + Err(string) => { -+ println!("Error mapping kernel binary: {}", string); ++ info!("Error mapping kernel binary: {}", string); + cpu::qemu_exit_failure() + } + Ok(addr) => addr, + }; + + if let Err(e) = memory::mmu::enable_mmu_and_caching(phys_kernel_tables_base_addr) { -+ println!("Enabling MMU failed: {}", e); ++ info!("Enabling MMU failed: {}", e); cpu::qemu_exit_failure() } + // Printing will silently fail from here on, because the driver's MMIO is not remapped yet. @@ -3638,7 +3638,7 @@ diff -uNr 13_exceptions_part2_peripheral_IRQs/tests/02_exception_sync_page_fault + bsp::driver::driver_manager().post_early_print_device_driver_init(); + // Printing available again from here on. - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; ``` diff --git a/14_virtual_mem_part2_mmio_remap/src/_arch/aarch64/time.rs b/14_virtual_mem_part2_mmio_remap/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/14_virtual_mem_part2_mmio_remap/src/_arch/aarch64/time.rs +++ b/14_virtual_mem_part2_mmio_remap/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/14_virtual_mem_part2_mmio_remap/src/panic_wait.rs b/14_virtual_mem_part2_mmio_remap/src/panic_wait.rs index 0f958f28..da7106c9 100644 --- a/14_virtual_mem_part2_mmio_remap/src/panic_wait.rs +++ b/14_virtual_mem_part2_mmio_remap/src/panic_wait.rs @@ -46,12 +46,25 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + unsafe { exception::asynchronous::local_irq_mask() }; + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } _panic_exit() diff --git a/14_virtual_mem_part2_mmio_remap/src/print.rs b/14_virtual_mem_part2_mmio_remap/src/print.rs index 5decb292..9ec13a28 100644 --- a/14_virtual_mem_part2_mmio_remap/src/print.rs +++ b/14_virtual_mem_part2_mmio_remap/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs b/14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs index de92b2b2..e146aa3e 100644 --- a/14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs +++ b/14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs @@ -17,7 +17,7 @@ /// or indirectly. mod panic_exit_success; -use libkernel::{bsp, cpu, exception, memory, println}; +use libkernel::{bsp, cpu, exception, info, memory, println}; #[no_mangle] unsafe fn kernel_init() -> ! { @@ -30,14 +30,14 @@ unsafe fn kernel_init() -> ! { let phys_kernel_tables_base_addr = match memory::mmu::kernel_map_binary() { Err(string) => { - println!("Error mapping kernel binary: {}", string); + info!("Error mapping kernel binary: {}", string); cpu::qemu_exit_failure() } Ok(addr) => addr, }; if let Err(e) = memory::mmu::enable_mmu_and_caching(phys_kernel_tables_base_addr) { - println!("Enabling MMU failed: {}", e); + info!("Enabling MMU failed: {}", e); cpu::qemu_exit_failure() } // Printing will silently fail from here on, because the driver's MMIO is not remapped yet. @@ -56,7 +56,7 @@ unsafe fn kernel_init() -> ! { bsp::driver::driver_manager().post_early_print_device_driver_init(); // Printing available again from here on. - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/15_virtual_mem_part3_precomputed_tables/README.md b/15_virtual_mem_part3_precomputed_tables/README.md index b58ed67e..4d7cc40e 100644 --- a/15_virtual_mem_part3_precomputed_tables/README.md +++ b/15_virtual_mem_part3_precomputed_tables/README.md @@ -1739,14 +1739,14 @@ diff -uNr 14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs - - let phys_kernel_tables_base_addr = match memory::mmu::kernel_map_binary() { - Err(string) => { -- println!("Error mapping kernel binary: {}", string); +- info!("Error mapping kernel binary: {}", string); - cpu::qemu_exit_failure() - } - Ok(addr) => addr, - }; - - if let Err(e) = memory::mmu::enable_mmu_and_caching(phys_kernel_tables_base_addr) { -- println!("Enabling MMU failed: {}", e); +- info!("Enabling MMU failed: {}", e); - cpu::qemu_exit_failure() - } - // Printing will silently fail from here on, because the driver's MMIO is not remapped yet. @@ -1767,7 +1767,7 @@ diff -uNr 14_virtual_mem_part2_mmio_remap/tests/02_exception_sync_page_fault.rs + // This line will be printed as the test header. + println!("Testing synchronous exception handling by causing a page fault"); - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; diff -uNr 14_virtual_mem_part2_mmio_remap/tests/03_exception_irq_sanity.rs 15_virtual_mem_part3_precomputed_tables/tests/03_exception_irq_sanity.rs diff --git a/15_virtual_mem_part3_precomputed_tables/src/_arch/aarch64/time.rs b/15_virtual_mem_part3_precomputed_tables/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/15_virtual_mem_part3_precomputed_tables/src/_arch/aarch64/time.rs +++ b/15_virtual_mem_part3_precomputed_tables/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/15_virtual_mem_part3_precomputed_tables/src/panic_wait.rs b/15_virtual_mem_part3_precomputed_tables/src/panic_wait.rs index 0f958f28..da7106c9 100644 --- a/15_virtual_mem_part3_precomputed_tables/src/panic_wait.rs +++ b/15_virtual_mem_part3_precomputed_tables/src/panic_wait.rs @@ -46,12 +46,25 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + unsafe { exception::asynchronous::local_irq_mask() }; + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } _panic_exit() diff --git a/15_virtual_mem_part3_precomputed_tables/src/print.rs b/15_virtual_mem_part3_precomputed_tables/src/print.rs index 5decb292..9ec13a28 100644 --- a/15_virtual_mem_part3_precomputed_tables/src/print.rs +++ b/15_virtual_mem_part3_precomputed_tables/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/15_virtual_mem_part3_precomputed_tables/tests/02_exception_sync_page_fault.rs b/15_virtual_mem_part3_precomputed_tables/tests/02_exception_sync_page_fault.rs index 2cf693fc..2d4b0977 100644 --- a/15_virtual_mem_part3_precomputed_tables/tests/02_exception_sync_page_fault.rs +++ b/15_virtual_mem_part3_precomputed_tables/tests/02_exception_sync_page_fault.rs @@ -17,7 +17,7 @@ /// or indirectly. mod panic_exit_success; -use libkernel::{bsp, cpu, exception, memory, println}; +use libkernel::{bsp, cpu, exception, info, memory, println}; #[no_mangle] unsafe fn kernel_init() -> ! { @@ -28,7 +28,7 @@ unsafe fn kernel_init() -> ! { // This line will be printed as the test header. println!("Testing synchronous exception handling by causing a page fault"); - println!("Writing beyond mapped area to address 9 GiB..."); + info!("Writing beyond mapped area to address 9 GiB..."); let big_addr: u64 = 9 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/16_virtual_mem_part4_higher_half_kernel/README.md b/16_virtual_mem_part4_higher_half_kernel/README.md index bde23439..487ce443 100644 --- a/16_virtual_mem_part4_higher_half_kernel/README.md +++ b/16_virtual_mem_part4_higher_half_kernel/README.md @@ -877,9 +877,9 @@ diff -uNr 15_virtual_mem_part3_precomputed_tables/tests/02_exception_sync_page_f // This line will be printed as the test header. println!("Testing synchronous exception handling by causing a page fault"); -- println!("Writing beyond mapped area to address 9 GiB..."); +- info!("Writing beyond mapped area to address 9 GiB..."); - let big_addr: u64 = 9 * 1024 * 1024 * 1024; -+ println!("Writing to bottom of address space to address 1 GiB..."); ++ info!("Writing to bottom of address space to address 1 GiB..."); + let big_addr: u64 = 1 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/16_virtual_mem_part4_higher_half_kernel/src/_arch/aarch64/time.rs b/16_virtual_mem_part4_higher_half_kernel/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/16_virtual_mem_part4_higher_half_kernel/src/_arch/aarch64/time.rs +++ b/16_virtual_mem_part4_higher_half_kernel/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/16_virtual_mem_part4_higher_half_kernel/src/panic_wait.rs b/16_virtual_mem_part4_higher_half_kernel/src/panic_wait.rs index 0f958f28..da7106c9 100644 --- a/16_virtual_mem_part4_higher_half_kernel/src/panic_wait.rs +++ b/16_virtual_mem_part4_higher_half_kernel/src/panic_wait.rs @@ -46,12 +46,25 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + unsafe { exception::asynchronous::local_irq_mask() }; + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } _panic_exit() diff --git a/16_virtual_mem_part4_higher_half_kernel/src/print.rs b/16_virtual_mem_part4_higher_half_kernel/src/print.rs index 5decb292..9ec13a28 100644 --- a/16_virtual_mem_part4_higher_half_kernel/src/print.rs +++ b/16_virtual_mem_part4_higher_half_kernel/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) diff --git a/16_virtual_mem_part4_higher_half_kernel/tests/02_exception_sync_page_fault.rs b/16_virtual_mem_part4_higher_half_kernel/tests/02_exception_sync_page_fault.rs index b2824615..71b63e21 100644 --- a/16_virtual_mem_part4_higher_half_kernel/tests/02_exception_sync_page_fault.rs +++ b/16_virtual_mem_part4_higher_half_kernel/tests/02_exception_sync_page_fault.rs @@ -17,7 +17,7 @@ /// or indirectly. mod panic_exit_success; -use libkernel::{bsp, cpu, exception, memory, println}; +use libkernel::{bsp, cpu, exception, info, memory, println}; #[no_mangle] unsafe fn kernel_init() -> ! { @@ -28,7 +28,7 @@ unsafe fn kernel_init() -> ! { // This line will be printed as the test header. println!("Testing synchronous exception handling by causing a page fault"); - println!("Writing to bottom of address space to address 1 GiB..."); + info!("Writing to bottom of address space to address 1 GiB..."); let big_addr: u64 = 1 * 1024 * 1024 * 1024; core::ptr::read_volatile(big_addr as *mut u64); diff --git a/X1_JTAG_boot/jtag_boot_rpi3.img b/X1_JTAG_boot/jtag_boot_rpi3.img index 752daff808a7e211ccd731e16780a081ca9ffbea..64189d659354f3894c8887bc419ede120173112f 100755 GIT binary patch delta 2195 zcmai#ZA?>F7{|}KmzLY2NTC8!gqBX)f>^a6=@vtQ#6ekR(z&QxHc{r%3S*{j?!!`B zblD)fh2tT**$*OH;;t{rmSRH9vcOo3WLcat-TbtobL(vt3^UOtD|gRn%Oun3Ne;K? z-t+SO{?Gq81l9-E_iw=;f4%i4USe0E0gTXBk(-DZ0{T!Jr^cMaKsWPyxt@y9CEkg( zJqBWd9yNU{MzXOO;Su?f)+jb{J%-Q$#V3lwo=Rfj1FqOOBGoA1Is}sq`buibc^OL~ zU(N>{Y(+2egbw81;&26he~Ghha0MBHx%^^Bq8*iAlbgBAbIm9r_yR6f>z+bh%SYSPm4i!}Tr;QwOj^&awheo_+)x~2fg!(Nf?BtFt-#ts}$qbLlbTt-t zo$qr=JW8mNt&#*=Um*4w7I~XR?ySOh{yGRlvn~Edm;L!Wss#1m@+8e(1UlAZG!z zRW)&J1^`b3a7^~gcc*QbIDwSW&p@l1b^-Cs8Vymc$kD|i;unB;x|$Q&!BHbh zSbS%K&J$)5Z{Wp)5QrIwQtFMZBTR+pMih3#`kvKB`ChpVf}*SDbtPoNd7Bcn3}^Fu@eK^%w;n$mg11 zZ??|uJb1+dX>%70&qfu$%=QYASu;37fV9!B{1u9n()37v<>FW1C;@%yavwwC&2%E) zs42r}0AX~F1&9XiWF<}J7w0yvBoL`qfR{qgN@^^q+zLv?K&42wQe^aoNDYYqb<~t4 zwlEb;3NfXQp@ztQPLzyTlprONkr&_lI~}MzjxW#IP-3A?Ta;;=9zajFX$XN$QQD^U zkFzO$)TRdOLz@;Xuqj|b^^(ZvnA{joS+xSZ%7az2#Hf{7RU!V7l#dP~RJTpfUzKIK z=sYD_ZRx_y!OHJ589>O9xIo9W1^&r7xkw&|>TE-admGg$*P7>Dt3|_VaJds)F8I_z z0i5cA+<72x668${IqZYnwfZK4YH;)^aBwZlVTD@v1)PLbXxIa$je@MLVAdG8-vy4p z2WIu`6N3>W@{0p37x00(Rr(7NR>RugPkLDeL>o{z3hwr?cV?TNG~d0 zSFWcoF3tC=a|13vEb$kjaCLjY&5|0_Ci|Pg@`Fl{L*QZVvUEe$aIJTJJaF6>^m2*@1XXjHvbdR*v$xN>58zC zHb7+e0^BPkX3YkdJ&INfXp#Gmxhh82z*Vu9OaXo&M8QfPC*{!TLIb8h6}4;Hi=j>z zv<Jc5nft+IVSt3{{_M*E8SqGUG&MTt%l!tcItpcGE_kNu5=c-cwsdy}EVzqb2E~ zyDa^TmeBLMGR2re^swv1&^n0D$T1xamhBUq}xl18o}tP_OyT|=GSKC WyO*cA@xOanX?FjGy delta 2143 zcmb7FdrVtZ7(e%3N^i?+6b6j)Xaj?`DD1@maiMILb< zL5Xra#7%0lu|?Uz5w;Z~)u>GVnNznZ8|q&c(AWoWA6t!Z{Z8A(&A6y1IrN@$zWd$Z zJEfve#rOm8-E{aG3q02p1rSxdUF%dU8pA%tPE&mo4T+ z9#WCZ0w!JYKl0}_f5`_RV74$V+CEEymd)dKUXThOGffnx8$% z;pX%4xJvO^w-TXFQ%@P5gZ(*Ng6Ca4wl7#XJX<8EemM#nma4`~wlAEq5ZF<97oM*W zscETttP=oMt&UUg{h-~vE%t;p2F@2M6m;Jer@7G9?`*DLhxb`dS*J%idTHsgu@;E` z(iZ0gK|A%f0VfEG`(Z!e;^`^3s1A&B*pq|sqy^cre#tuKFG0b8OQ601FHALzJmh017E#HYw0x zvrXZg1-7xE%nT5{1WKF+WttQhyO}z3#18U+6f+-kl(Azn&4Mh9<=g;I6W{|YU>fwX z>S;hcmzacS2LNah3Myc~8rZKmQHG~KiJ~o_Ml)j%O6&#p=Kz?=cG{`e>hNjUkAwKO zeo<`#!u=C@n5pBpKaSk5K;UApoHCibOaTkR^Y2Gf4|wO_j)IdQm;ap>(T}U zFY+)2m`Jk`Z$`z~GE$5uPV#uWBpuNp&D9v=cTgKYE!J`|0Sgya>LOF>o!gaK$)xiC zCJhxra`s{a6jc?GsqU49v?p6td2w4Isfdo68@iEu3pu39N&FR|F2tcB1_d22!)c^n zl@|YeAqGszB5aE13(1%&uLkt;3kZAU(UkGkYSv)S76d&MMeheV{(Ko_I_m3-uw>_{ zFNdQ(fy2HWfm;3uBa#GYiED1T<8v^f(mDz&lDiq z1eTh>%1dCeuL3NC0@vFPHU+-dw*H>$I_IX5m~pN1285ud+6+M*&;cem@TpPIG!(D)388BQd!{%%34BEGe7Z5*n$|V2LYxM#!{elX=vRDxkJSqCH8CsDh!I`gs zqwP@+a~p4T>sBVOZ{v~s*c-^*2YHzNZEqrXFFdooWANNSYEts;OpAui*~7Xzhq>`^ z_OQ=_aMP#R!>pPcAOo}62mKxLW}+0cs+R0gV6{NKIe-Svy-)^|qX<6(GB~3Dl7%5> zWxFNIcwDq0t^$8^}UNExD2z zOCE)($x0(DGLzXeClGB`328{zt^L2>@{+UZ`N}gXVMHS-WHNoD>H&3l*%0CRw3-;y zS&1W&?UV?vaZ;ns&bSfTg$4|bm*Fqmk7$=hQ%E}18_F~hy8o4aZX|x)o#>Jq>NR{_ zCNX3@SO0Bh7;0kptj&r2fl J9CmgfDG08DvN``XFa^x>PtHc|y=D~I)&PC+6<(!mah9|~C~yH`!w zp{hA^) zldHAPv+j{q+ zb^c659iNTAyT|ID*7b?tHkf(yo6*R@?dRj8A6-gY%pXTAKYSNo^FgV3{lucy1#_CN z-)Y%TchG`JXs!iRZ4GDv4dBfKBNwDYBkMCMI=SQGFTX4wJQjUVBAJf?Fvy5%Kk6aS_@JoOzepL+5ZPcJT%{E zRyp8E6Ad9?9-;C+pxT9Ps&)WMI4LRbd_B$e3iQ@#LJw`|6O#b##}si%*L7DD+6pMY zVt-SR^icuz^TCIXQV}=3%ENRSgPy>?l$~@DdyYTg&Otwo;5iVu%I&D1KKi#lkpsBe z!~NlGIflc<+~s`reE+qZ*=jpp*o){U^&lb_d<35@U~LH1e4@&clly3HKhO^_BmeUP zxv|j(r3WW1WM*e-_a%y0-hM3a%4wjtGeB1Ypz<>;@$CRnL&Mk85)RpA95UX%n4fOP z$BkzjX|ba`RNagHh_Mn7)h4gx*6N^izmt|ZT;gkJm*23t#E(=e414J^#{8H$S0@rSSs$$(bYPhtkO4VU>v)RD zsa=)x&zu$grD0F8n6r`m#YUZ{5`(VF-A*IEtb@2-Q@W4G2adm`48{ifdY@J{+g@o_ zuEb%JxLh-AYz3DoBd^`Cu`XP;#Q9-s;N+ITJBCfzbi*-XW;^8on{TjN6(ga@4!hnE z9+TPkuGW`dH7K0M<$z)1jB*)@_XggM^$oPfhq#?G?y<{UKE-b}t|N-l%7P6~?%9I- SAKGtacDdmM$8xc#to#FRE6Ke8 delta 1214 zcmaJ=UuaWT82`?_Nt@iH)~0Fx&gI_KT2rCwV%N>;8mcgCUnJ;*RA^&RTdh?iY%s`@ zjImJ`Mh-{lL-x>h58L$*R-({OVTywIq*CkVlc~PM#1>m0G-7-G?jN!9VFxbX`TqRA z^Eu*;o9xT-wQA)=;*` zG*v|;8cf%-dh-E}NcnHfznEQV9}V)UNa+U94UmdtutXAl%x~LE?D>kHx*^nQuTera`W%F zSOu4!@<0WEY)=$up&8^6Y+}V+%R(nDZy>UghVDb({a6L$$#n{gH7dFYBBns&PrK;DEeT4oQ{6Yh??H zm4(zA%AxH7KjqQJ3Vu3^HBr<{1o6JYb35-XcR)oiZlY;S0D;SzKh{Kh-zcL6fXm-$ z0649JGy;-WZRphYQ7^mYXeR-tI09=$TG#>f55ySY;`cccoxtwDu zK0S~Sk~wQ46;X$zd-fA*!6ripD22?j<-FCu*jODb@;C&cs`rol1Rt3v)UFB)?;p9a zq~BH7&=5TQu`W0S=qzGNh*9`UjO2_e8XHS{~e9#nG0ns?{N8$Ki6 zey<*X)u7t}!x!0ttCw-241yc{Dhu^@!^9*;)&?+U`!HVwOg;NHR}G8 z-zo~5KFD_(K4A|%hq(zi>+-hl{?`b)j3)Djk5i_tQ}NiwW6{Ck*7zySUu|5>X5@cD zi?0N|qS&g2*j4YA?ds-pqY$S`TOEdvznHc@ROp@mDckJnV_~12{pwlEc6*#??JVmP F-vSWza>W1u diff --git a/X1_JTAG_boot/src/_arch/aarch64/time.rs b/X1_JTAG_boot/src/_arch/aarch64/time.rs index 57624839..c814219c 100644 --- a/X1_JTAG_boot/src/_arch/aarch64/time.rs +++ b/X1_JTAG_boot/src/_arch/aarch64/time.rs @@ -78,6 +78,7 @@ impl time::interface::TimeManager for GenericTimer { // Calculate the register compare value. let frq = CNTFRQ_EL0.get(); let x = match frq.checked_mul(duration.as_nanos() as u64) { + #[allow(unused_imports)] None => { warn!("Spin duration too long, skipping"); return; @@ -96,6 +97,7 @@ impl time::interface::TimeManager for GenericTimer { None }; + #[allow(unused_imports)] if let Some(w) = warn { warn!( "Spin duration {} than architecturally supported, skipping", diff --git a/X1_JTAG_boot/src/panic_wait.rs b/X1_JTAG_boot/src/panic_wait.rs index 946041b3..923db329 100644 --- a/X1_JTAG_boot/src/panic_wait.rs +++ b/X1_JTAG_boot/src/panic_wait.rs @@ -29,10 +29,23 @@ macro_rules! panic_println { #[panic_handler] fn panic(info: &PanicInfo) -> ! { + use crate::time::interface::TimeManager; + + let timestamp = crate::time::time_manager().uptime(); + if let Some(args) = info.message() { - panic_println!("\nKernel panic: {}", args); + panic_println!( + "[ {:>3}.{:06}] Kernel panic: {}", + timestamp.as_secs(), + timestamp.subsec_micros(), + args, + ); } else { - panic_println!("\nKernel panic!"); + panic_println!( + "[ {:>3}.{:06}] Kernel panic!", + timestamp.as_secs(), + timestamp.subsec_micros(), + ); } cpu::wait_forever() diff --git a/X1_JTAG_boot/src/print.rs b/X1_JTAG_boot/src/print.rs index 5decb292..9ec13a28 100644 --- a/X1_JTAG_boot/src/print.rs +++ b/X1_JTAG_boot/src/print.rs @@ -41,31 +41,25 @@ macro_rules! println { #[macro_export] macro_rules! info { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $string), + concat!("[ {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[ {:>3}.{:03}{:03}] ", $format_string), + concat!("[ {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); }) @@ -75,31 +69,25 @@ macro_rules! info { #[macro_export] macro_rules! warn { ($string:expr) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $string), + concat!("[W {:>3}.{:06}] ", $string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000 + timestamp.subsec_micros(), )); }); ($format_string:expr, $($arg:tt)*) => ({ - #[allow(unused_imports)] - use crate::time::interface::TimeManager; + use $crate::time::interface::TimeManager; let timestamp = $crate::time::time_manager().uptime(); - let timestamp_subsec_us = timestamp.subsec_micros(); $crate::print::_print(format_args_nl!( - concat!("[W {:>3}.{:03}{:03}] ", $format_string), + concat!("[W {:>3}.{:06}] ", $format_string), timestamp.as_secs(), - timestamp_subsec_us / 1_000, - timestamp_subsec_us % 1_000, + timestamp.subsec_micros(), $($arg)* )); })