Add configuration options

Author: asensio-project

api/build.rs

@@ -23,6 +23,8 @@ fn main() {
         (97, 9),
         (106, 9),
         (115, 1),
+        (116, 1),
+        (117, 1),
     ];
 
     let mut code = String::new();

api/src/config.rs

@@ -31,6 +31,12 @@ pub struct BootloaderConfig {
     /// Configuration for changing the level of the filter of the messages that are shown in the
     /// screen when booting. The default is 'Trace'.
     pub log_level: LevelFilter,
+
+    /// Configuration for enable or disable the framebuffer logger.
+    pub frame_buffer_logger_status: LoggerStatus,
+
+    /// Configuration for enable or disable the serial being logger.
+    pub serial_logger_status: LoggerStatus,
 }
 
 impl BootloaderConfig {
@@ -39,7 +45,7 @@ impl BootloaderConfig {
         0x3D,
     ];
     #[doc(hidden)]
-    pub const SERIALIZED_LEN: usize = 116;
+    pub const SERIALIZED_LEN: usize = 118;
 
     /// Creates a new default configuration with the following values:
     ///
@@ -53,6 +59,8 @@ impl BootloaderConfig {
             mappings: Mappings::new_default(),
             frame_buffer: FrameBuffer::new_default(),
             log_level: LevelFilter::Trace,
+            frame_buffer_logger_status: LoggerStatus::Enable,
+            serial_logger_status: LoggerStatus::Enable,
         }
     }
 
@@ -67,6 +75,8 @@ impl BootloaderConfig {
             kernel_stack_size,
             frame_buffer,
             log_level,
+            frame_buffer_logger_status,
+            serial_logger_status,
         } = self;
         let ApiVersion {
             version_major,
@@ -147,7 +157,15 @@ impl BootloaderConfig {
             },
         );
 
-        concat_115_1(buf, (*log_level as u8).to_le_bytes())
+        let log_level = concat_115_1(buf, (*log_level as u8).to_le_bytes());
+
+        let frame_buffer_logger_status =
+            concat_116_1(log_level, (*frame_buffer_logger_status as u8).to_le_bytes());
+
+        concat_117_1(
+            frame_buffer_logger_status,
+            (*serial_logger_status as u8).to_le_bytes(),
+        )
     }
 
     /// Tries to deserialize a config byte array that was created using [`Self::serialize`].
@@ -267,6 +285,21 @@ impl BootloaderConfig {
             Option::None => return Err("log_level invalid"),
         };
 
+        let (&frame_buffer_logger_status, s) = split_array_ref(s);
+        let frame_buffer_logger_status =
+            LoggerStatus::from_u8(u8::from_le_bytes(frame_buffer_logger_status));
+        let frame_buffer_logger_status = match frame_buffer_logger_status {
+            Option::Some(status) => status,
+            Option::None => return Err("frame_buffer_logger_status invalid"),
+        };
+
+        let (&serial_logger_status, s) = split_array_ref(s);
+        let serial_logger_status = LoggerStatus::from_u8(u8::from_le_bytes(serial_logger_status));
+        let serial_logger_status = match serial_logger_status {
+            Option::Some(status) => status,
+            Option::None => return Err("serial_logger_status invalid"),
+        };
+
         if !s.is_empty() {
             return Err("unexpected rest");
         }
@@ -277,6 +310,8 @@ impl BootloaderConfig {
             mappings,
             frame_buffer,
             log_level,
+            frame_buffer_logger_status,
+            serial_logger_status,
         })
     }
 
@@ -288,6 +323,8 @@ impl BootloaderConfig {
             kernel_stack_size: rand::random(),
             frame_buffer: FrameBuffer::random(),
             log_level: LevelFilter::Trace,
+            frame_buffer_logger_status: LoggerStatus::Enable,
+            serial_logger_status: LoggerStatus::Enable,
         }
     }
 }
@@ -587,6 +624,27 @@ impl LevelFilter {
     }
 }
 
+/// An enum for enabling or disabling the different methods for logging.
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum LoggerStatus {
+    /// This method of logging is disabled
+    Disable,
+    /// This method of logging is enabled
+    Enable,
+}
+
+impl LoggerStatus {
+    /// Converts an u8 into a Option<LoggerStatus>
+    pub fn from_u8(value: u8) -> Option<LoggerStatus> {
+        match value {
+            0 => Some(Self::Disable),
+            1 => Some(Self::Enable),
+            _ => None,
+        }
+    }
+}
+
 /// Taken from https://github.com/rust-lang/rust/blob/e100ec5bc7cd768ec17d75448b29c9ab4a39272b/library/core/src/slice/mod.rs#L1673-L1677
 ///
 /// TODO replace with `split_array` feature in stdlib as soon as it's stabilized,

bios/stage-4/src/main.rs

@@ -3,7 +3,7 @@
 
 use crate::memory_descriptor::MemoryRegion;
 use bootloader_api::{
-    config::LevelFilter,
+    config::{LevelFilter, LoggerStatus},
     info::{FrameBufferInfo, PixelFormat},
 };
 use bootloader_x86_64_bios_common::{BiosFramebufferInfo, BiosInfo, E820MemoryRegion};
@@ -109,7 +109,12 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
     };
     let kernel = Kernel::parse(kernel_slice);
 
-    let framebuffer_info = init_logger(info.framebuffer, kernel.config.log_level);
+    let framebuffer_info = init_logger(
+        info.framebuffer,
+        kernel.config.log_level,
+        kernel.config.frame_buffer_logger_status,
+        kernel.config.serial_logger_status,
+    );
 
     log::info!("4th Stage");
     log::info!("{info:x?}");
@@ -126,7 +131,12 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
     load_and_switch_to_kernel(kernel, frame_allocator, page_tables, system_info);
 }
 
-fn init_logger(info: BiosFramebufferInfo, log_level: LevelFilter) -> FrameBufferInfo {
+fn init_logger(
+    info: BiosFramebufferInfo,
+    log_level: LevelFilter,
+    frame_buffer_logger_status: LoggerStatus,
+    serial_logger_status: LoggerStatus,
+) -> FrameBufferInfo {
     let framebuffer_info = FrameBufferInfo {
         byte_len: info.region.len.try_into().unwrap(),
         width: info.width.into(),
@@ -155,7 +165,13 @@ fn init_logger(info: BiosFramebufferInfo, log_level: LevelFilter) -> FrameBuffer
         )
     };
 
-    bootloader_x86_64_common::init_logger(framebuffer, framebuffer_info, log_level);
+    bootloader_x86_64_common::init_logger(
+        framebuffer,
+        framebuffer_info,
+        log_level,
+        frame_buffer_logger_status,
+        serial_logger_status,
+    );
 
     framebuffer_info
 }

common/src/lib.rs

@@ -4,7 +4,7 @@
 
 use crate::legacy_memory_region::{LegacyFrameAllocator, LegacyMemoryRegion};
 use bootloader_api::{
-    config::{LevelFilter, Mapping},
+    config::{LevelFilter, LoggerStatus, Mapping},
     info::{FrameBuffer, FrameBufferInfo, MemoryRegion, TlsTemplate},
     BootInfo, BootloaderConfig,
 };
@@ -33,13 +33,27 @@ pub mod level_4_entries;
 pub mod load_kernel;
 /// Provides a logger that logs output as text in various formats.
 pub mod logger;
+/// Provides a type that logs output as text to a Serial Being port.
 pub mod serial;
 
 const PAGE_SIZE: u64 = 4096;
 
 /// Initialize a text-based logger using the given pixel-based framebuffer as output.  
-pub fn init_logger(framebuffer: &'static mut [u8], info: FrameBufferInfo, log_level: LevelFilter) {
-    let logger = logger::LOGGER.get_or_init(move || logger::LockedLogger::new(framebuffer, info));
+pub fn init_logger(
+    framebuffer: &'static mut [u8],
+    info: FrameBufferInfo,
+    log_level: LevelFilter,
+    frame_buffer_logger_status: LoggerStatus,
+    serial_logger_status: LoggerStatus,
+) {
+    let logger = logger::LOGGER.get_or_init(move || {
+        logger::LockedLogger::new(
+            framebuffer,
+            info,
+            frame_buffer_logger_status,
+            serial_logger_status,
+        )
+    });
     log::set_logger(logger).expect("logger already set");
     log::set_max_level(convert_level(log_level));
     log::info!("Framebuffer info: {:?}", info);

common/src/logger.rs

@@ -1,5 +1,5 @@
 use crate::{framebuffer::FrameBufferWriter, serial::SerialPort};
-use bootloader_api::info::FrameBufferInfo;
+use bootloader_api::{config::LoggerStatus, info::FrameBufferInfo};
 use conquer_once::spin::OnceCell;
 use core::fmt::Write;
 use spinning_top::Spinlock;
@@ -8,14 +8,26 @@ use spinning_top::Spinlock;
 pub static LOGGER: OnceCell<LockedLogger> = OnceCell::uninit();
 
 /// A [`FrameBufferWriter`] instance protected by a spinlock.
-pub struct LockedLogger(Spinlock<FrameBufferWriter>, Spinlock<SerialPort>);
+pub struct LockedLogger(
+    Spinlock<FrameBufferWriter>,
+    Spinlock<SerialPort>,
+    LoggerStatus,
+    LoggerStatus,
+);
 
 impl LockedLogger {
     /// Create a new instance that logs to the given framebuffer.
-    pub fn new(framebuffer: &'static mut [u8], info: FrameBufferInfo) -> Self {
+    pub fn new(
+        framebuffer: &'static mut [u8],
+        info: FrameBufferInfo,
+        frame_buffer_logger_status: LoggerStatus,
+        serial_logger_status: LoggerStatus,
+    ) -> Self {
         LockedLogger(
             Spinlock::new(FrameBufferWriter::new(framebuffer, info)),
             Spinlock::new(SerialPort::new()),
+            frame_buffer_logger_status,
+            serial_logger_status,
         )
     }
 
@@ -37,10 +49,14 @@ impl log::Log for LockedLogger {
     }
 
     fn log(&self, record: &log::Record) {
-        let mut logger = self.0.lock();
-        let mut serial = self.1.lock();
-        writeln!(logger, "{:5}: {}", record.level(), record.args()).unwrap();
-        writeln!(serial, "{:5}: {}", record.level(), record.args()).unwrap();
+        if self.2 == LoggerStatus::Enable {
+            let mut logger = self.0.lock();
+            writeln!(logger, "{:5}: {}", record.level(), record.args()).unwrap();
+        }
+        if self.3 == LoggerStatus::Enable {
+            let mut serial = self.1.lock();
+            writeln!(serial, "{:5}: {}", record.level(), record.args()).unwrap();
+        }
     }
 
     fn flush(&self) {}

uefi/src/main.rs

@@ -420,7 +420,13 @@ fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> Option<RawFr
 
     log::info!("UEFI boot");
 
-    bootloader_x86_64_common::init_logger(slice, info, config.log_level);
+    bootloader_x86_64_common::init_logger(
+        slice,
+        info,
+        config.log_level,
+        config.frame_buffer_logger_status,
+        config.serial_logger_status,
+    );
 
     Some(RawFrameBufferInfo {
         addr: PhysAddr::new(framebuffer.as_mut_ptr() as u64),