procfs: add /proc/cmdline for kernel cmdline

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/arch/x86_64/mod.rs

@@ -160,10 +160,12 @@ extern "C" fn x86_64_aero_main(boot_info: &'static StivaleStruct) -> ! {
 
     // Parse the kernel command line.
     let command_line: &'static _ = boot_info.command_line().map_or("", |cmd| unsafe {
+        let cmdline = crate::PHYSICAL_MEMORY_OFFSET + cmd.command_line;
+
         // SAFETY: The bootloader has provided a pointer that points to a valid C
         // string with a NULL terminator of size less than `usize::MAX`, whose content
         // remain valid and has a static lifetime.
-        mem::c_str_as_str(cmd.command_line as *const u8)
+        mem::c_str_as_str(cmdline.as_ptr())
     });
 
     let command_line = cmdline::parse(command_line, modules);

src/aero_kernel/src/cmdline.rs

@@ -1,9 +1,12 @@
 use core::num::ParseIntError;
 
+use spin::Once;
 use stivale_boot::v2::StivaleModuleTag;
 
 use crate::rendy;
 
+static RAW_CMDLINE_STR: Once<&'static str> = Once::new();
+
 pub struct CommandLine {
     /// If set, then the kernel logs will be redirected onto the framebuffer until
     /// the kernel thread jumps to userland.
@@ -47,7 +50,9 @@ fn parse_number(mut string: &str) -> Result<usize, ParseIntError> {
     }
 }
 
-pub fn parse(cmdline: &str, modules: &'static StivaleModuleTag) -> CommandLine {
+pub fn parse(cmdline: &'static str, modules: &'static StivaleModuleTag) -> CommandLine {
+    RAW_CMDLINE_STR.call_once(|| cmdline);
+
     // Chew up the leading spaces.
     let cmdline = cmdline.trim();
     let mut result = CommandLine::new();
@@ -97,6 +102,17 @@ pub fn parse(cmdline: &str, modules: &'static StivaleModuleTag) -> CommandLine {
     result
 }
 
+/// Returns the raw kernel command line string.
+///
+/// ## Panics
+/// * If this function was invoked before the kernel command line was
+/// parsed using [`self::parse`].
+pub fn get_raw_cmdline() -> &'static str {
+    RAW_CMDLINE_STR
+        .get()
+        .expect("get_raw_cmdline: called before cmdline was parsed")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/aero_kernel/src/fs/procfs.rs

@@ -25,6 +25,19 @@ fn push_string_if_some(map: &mut serde_json::Value, key: &str, value: Option<Str
     }
 }
 
+fn get_cmdline_cached() -> &'static str {
+    static CACHED: Once<String> = Once::new();
+
+    CACHED.call_once(|| {
+        use serde_json::*;
+
+        json!({
+            "cmdline": crate::cmdline::get_raw_cmdline(),
+        })
+        .to_string()
+    })
+}
+
 fn get_cpuinfo_cached() -> &'static str {
     static CACHED: Once<String> = Once::new();
 
@@ -78,6 +91,8 @@ struct ProcINode {
 
 enum FileContents {
     CpuInfo,
+    CmdLine,
+
     None,
 }
 
@@ -90,7 +105,6 @@ impl Default for FileContents {
 struct LockedProcINode(RwLock<ProcINode>);
 
 impl LockedProcINode {
-    #[inline]
     fn new(node: ProcINode) -> Self {
         Self(RwLock::new(node))
     }
@@ -123,16 +137,13 @@ impl LockedProcINode {
             return Err(FileSystemError::EntryExists);
         }
 
-        let filesystem = this
-            .filesystem
-            .upgrade()
-            .expect("Failed to upgrade to strong filesystem");
+        let filesystem = this.filesystem.upgrade().unwrap();
 
         let inode = filesystem.allocate_inode(file_type, contents);
         let inode_cached = icache.make_item_no_cache(CachedINode::new(inode));
 
         downcast::<dyn INodeInterface, LockedProcINode>(&inode_cached.inner())
-            .expect("Failed to downcast cached inode on creation")
+            .unwrap()
             .init(
                 &this.node,
                 &inode_cached.downgrade(),
@@ -151,18 +162,17 @@ impl INodeInterface for LockedProcINode {
     fn read_at(&self, offset: usize, buffer: &mut [u8]) -> Result<usize> {
         let this = self.0.read();
 
-        match &this.contents {
-            FileContents::CpuInfo => {
-                let data = get_cpuinfo_cached();
+        let data = match &this.contents {
+            FileContents::CpuInfo => Ok(get_cpuinfo_cached()),
+            FileContents::CmdLine => Ok(get_cmdline_cached()),
 
-                let count = core::cmp::min(buffer.len(), data.len() - offset);
-                buffer[..count].copy_from_slice(&data.as_bytes()[offset..]);
+            _ => Err(FileSystemError::NotSupported),
+        }?;
 
-                Ok(count)
-            }
+        let count = core::cmp::min(buffer.len(), data.len() - offset);
+        buffer[..count].copy_from_slice(&data.as_bytes()[offset..offset + count]);
 
-            _ => Err(FileSystemError::NotSupported),
-        }
+        Ok(count)
     }
 
     fn lookup(&self, dir: DirCacheItem, name: &str) -> Result<DirCacheItem> {
@@ -253,8 +263,7 @@ impl ProcFs {
 
         root_dir.filesystem.call_once(|| Arc::downgrade(&copy));
 
-        let down = downcast::<dyn INodeInterface, LockedProcINode>(root_cached.inner())
-            .expect("cannot downcast inode to ram inode");
+        let down = downcast::<dyn INodeInterface, LockedProcINode>(root_cached.inner()).unwrap();
 
         down.init(
             &ramfs.root_inode.downgrade(),
@@ -264,6 +273,8 @@ impl ProcFs {
         );
 
         down.make_inode("cpuinfo", FileType::File, FileContents::CpuInfo)?;
+        down.make_inode("cmdline", FileType::File, FileContents::CmdLine)?;
+
         Ok(ramfs)
     }