Improve handling of errors while cmdline parsing

Depending on the commandline formatting, there was a case where this
resulted in an endless loop in processing the command line. Errors were
printed using the `error!` macro, that used the logger functionality
before it was setup.

We introduce an error return value for parsing the commandline. It
returns an error whenever there was something wrong with the command
line that could lead to a misconfiguration of the runtime parameters.
For that we have two error values:
 - InvalidCmdLineOptions indicating the command line parsed fine, but
   the selected option are not supported
 - MalformedCmdLine indicating that there were issues with parsing the
   commandline that would have led to skipped arguments.

Signed-off-by: Reto Achermann <achreto@gmail.com>

Author: achreto

kernel/src/arch/x86_64/mod.rs

@@ -249,6 +249,7 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
 
     // Very early init:
     sprint!("\r\n");
+    sprint!("NRK booting on x86_64...\r\n");
     enable_sse();
     enable_fsgsbase();
     unsafe {
@@ -276,7 +277,14 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
         //   memory for us
         unsafe { transmute::<u64, &'static KernelArgs>(argc as u64) };
     // Parse the command line arguments:
-    let cmdline = CommandLineArguments::from_str(kernel_args.command_line);
+    let cmdline = match CommandLineArguments::from_str(kernel_args.command_line) {
+        Ok(cmdline) => cmdline,
+        Err(err) => {
+            sprint!("Parsing the commandline failed ({err}). Halting...\r\n");
+            halt();
+        }
+    };
+
     // Initialize cmdline arguments as global
     crate::CMDLINE.call_once(move || cmdline);
     // Initialize kernel arguments as global

kernel/src/cmdline.rs

@@ -12,6 +12,7 @@ use logos::Logos;
 use kpi::system::MachineId;
 
 use crate::arch::memory::paddr_to_kernel_vaddr;
+use crate::error::{KError, KResult};
 use crate::memory::PAddr;
 
 /// Definition to parse the kernel command-line arguments.
@@ -148,7 +149,9 @@ impl CommandLineArguments {
     /// Parse command line argument and initialize the logging infrastructure.
     ///
     /// Example: If args is './kernel log=trace' -> sets level to Level::Trace
-    pub(crate) fn from_str(args: &'static str) -> Self {
+    pub(crate) fn from_str(args: &'static str) -> KResult<Self> {
+        use klogger::sprint;
+
         // The args argument will be a physical address slice that
         // goes away once we switch to a process address space
         // make sure we translate it into a kernel virtual address:
@@ -217,8 +220,8 @@ impl CommandLineArguments {
                         prev = CmdToken::Error;
                     }
                     _ => {
-                        error!("Invalid cmd arguments: {} (skipped {})", args, slice);
-                        continue;
+                        sprint!("Invalid cmd arguments: {} (skipped {})\r\n", args, slice);
+                        return Err(KError::InvalidCmdLineOptions);
                     }
                 },
                 CmdToken::KVSeparator => {
@@ -230,8 +233,8 @@ impl CommandLineArguments {
                         && prev != CmdToken::MachineId
                         && prev != CmdToken::Workers
                     {
-                        error!("Malformed args (unexpected equal sign) in {}", args);
-                        continue;
+                        sprint!("Malformed args (unexpected equal sign) in {}\r\n", args);
+                        return Err(KError::MalformedCmdLine);
                     }
                 }
                 CmdToken::LiteralString => {
@@ -268,35 +271,41 @@ impl CommandLineArguments {
                             prev = CmdToken::Error;
                         }
                         _ => {
-                            error!("Invalid cmd arguments: {} (skipped {})", args, slice);
+                            sprint!("Invalid cmd arguments: {} (skipped {})\r\n", args, slice);
                             continue;
                         }
                     }
                 }
                 CmdToken::Error => {
-                    error!("Ignored '{}' while parsing cmd args: {}", slice, args);
-                    continue;
+                    sprint!(
+                        "Malformed commandline! Encoutered '{}' while parsing cmd args: {}\r\n",
+                        slice,
+                        args
+                    );
+                    return Err(KError::MalformedCmdLine);
                 }
             }
         }
 
         #[cfg(not(feature = "shmem"))]
         {
             if parsed_args.mode != Mode::Native && parsed_args.transport == Transport::Shmem {
-                panic!("kernel feature 'shmem' must be present to use shmem as an RPC transport");
+                sprint!("kernel feature 'shmem' must be present to use shmem as an RPC transport");
+                return Err(KError::InvalidCmdLineOptions);
             }
         }
 
         #[cfg(not(feature = "ethernet"))]
         {
             if parsed_args.mode != Mode::Native && parsed_args.transport == Transport::Ethernet {
-                panic!(
+                sprint!(
                     "kernel feature 'ethernet' must be present to use ethernet as an RPC transport"
                 );
+                return Err(KError::InvalidCmdLineOptions);
             }
         }
 
-        parsed_args
+        Ok(parsed_args)
     }
 }
 

kernel/src/error.rs

@@ -173,6 +173,10 @@ pub enum KError {
     TryFromIntError,
     /// The provided file-descriptor value was too big (>= MAX_FILES_PER_PROCESS)
     FileDescriptorTooLarge,
+    /// The command line was malformed
+    MalformedCmdLine,
+    /// The command line had invalid option configurations
+    InvalidCmdLineOptions,
     /// Rackscale: Unable to convert message ID to valid RPC type (faulty message?)
     InvalidRpcType,
     /// Rackscale: Unable to perform DCM transaction (faulty message?)