start writing log messages

README.md

@@ -18,9 +18,11 @@ Licensed under the GNU Public License v3. See [LICENSE](LICENSE) for details.
 - [boot.rs](src/boot.rs): Handles bootloader handoff. Gila uses Limine. Other bootloaders are NOT supported.
 - [display.rs](src/display.rs): Handles text-mode display via the VGA buffer.
 - [lib.rs](src/lib.rs): Glue to make all files accessible from [main.rs](src/main.rs).
+- [log.rs](src/log.rs): Logging structures and singletons for logging to serial or the display.
 - [main.rs](src/main.rs): The entry point that gets called by the bootloader.
 - [memory.rs](src/memory.rs): Types relating to memory regions and allocation.
 - [panic.rs](src/panic.rs): The panic handler and associated functionality.
+- [params.rs](src/params.rs): Kernel parameter handler code.
 - [process.rs](src/process.rs): Process types and functions.
 - [resources.rs](src/resources.rs): Resources that are accessible from multiple parts of the code.
 

src/main.rs

@@ -16,17 +16,25 @@ use gila::process;
 
 #[unsafe(no_mangle)]
 unsafe extern "C" fn main() -> ! {
+    // Assert supported bootloader version
     assert!(BASE_REVISION.is_supported());
 
-    let kernel_file_response = FILE_REQUEST.get_response().unwrap();
+    // Local logger fn
+    fn log(level: LogLevel, msg: &str) {
+        LOGGER.lock().log(level, msg);
+    }
 
+    // Set up some stuff based on kernel params if we get any
+    if let Some(kernel_file_response) = FILE_REQUEST.get_response() {
         let kernel_parameters = get_kernel_params(kernel_file_response.file().cmdline());
 
+        // Set up logging level from params
         if let Some(level) = kernel_parameters.get("-loglevel") {
             if let Ok(parsed_level) = LogLevel::try_from(level.as_str()) {
                 LOGGER.lock().level = parsed_level;
             }
         }
+        // Add subscribers to logger
         if let Some(device) = kernel_parameters.get("-logdev") {
             let log_device_list: vec::Vec<&str> = device.split(',').collect();
             if log_device_list.contains(&"display") {
@@ -37,8 +45,38 @@ unsafe extern "C" fn main() -> ! {
             }
         }
 
+        {
+            let kernel_cmdline_string =
+                string::String::from_utf8_lossy(kernel_file_response.file().cmdline());
+            log(
+                LogLevel::INFO,
+                &format!("Kernel cmdline: {}", kernel_cmdline_string),
+            );
+            drop(kernel_cmdline_string);
+        }
+
+        {
+            let kernel_path = string::String::from_utf8_lossy(kernel_file_response.file().path());
+            log(
+                LogLevel::INFO,
+                &format!("Kernel file path: {}", kernel_path),
+            );
+            drop(kernel_path);
+        }
+    }
+
+    log(LogLevel::INFO, "Booting Gila...");
+
     let _smp_response = SMP_REQUEST.get_response();
 
+    match _smp_response {
+        None => log(LogLevel::ERROR, "SMP response not received. Multiprocessing is disabled."),
+        Some(resp) => {
+            log(LogLevel::INFO, "SMP response received. Multiprocessing enabled.");
+            log(LogLevel::INFO, &format!("{} CPUs found.", resp.cpus().len()));
+        },
+    }
+
     loop {
         unsafe {
             asm::halt();