device/block: Add ramdisk device

Author: marv7000

kernel/src/device/block/mod.rs

@@ -1,6 +1,7 @@
 pub mod gpt;
 pub mod io;
 pub mod partition;
+pub mod ram;
 
 use crate::device::Device;
 use crate::{

kernel/src/device/block/ram.rs

@@ -0,0 +1,89 @@
+//! A block device backed entirely by a region of physical memory.
+
+use super::{BlockCompletion, BlockDevice, BlockIo, BlockOp};
+use crate::{
+    device::Device,
+    memory::PhysAddr,
+    posix::errno::{EResult, Errno},
+    vfs::file::{FileOps, OpenFlags},
+};
+use alloc::sync::Arc;
+use core::sync::atomic::{AtomicU32, Ordering};
+
+const RAM_MAJOR: u32 = 1;
+const LBA_SIZE: usize = 512;
+
+static NEXT_MINOR: AtomicU32 = AtomicU32::new(0);
+
+pub struct RamDisk {
+    base: PhysAddr,
+    lba_count: u64,
+    minor: u32,
+}
+
+impl RamDisk {
+    /// Creates a RAM disk over `len` bytes of physical memory starting at `base`.
+    /// Any trailing bytes that don't make up a whole sector are ignored.
+    pub fn new(base: PhysAddr, len: usize) -> Self {
+        Self {
+            base,
+            lba_count: (len / LBA_SIZE) as u64,
+            minor: NEXT_MINOR.fetch_add(1, Ordering::Relaxed),
+        }
+    }
+}
+
+impl BlockDevice for RamDisk {
+    fn get_lba_size(&self) -> usize {
+        LBA_SIZE
+    }
+
+    fn lba_count(&self) -> u64 {
+        self.lba_count
+    }
+
+    fn submit_io(&self, io: &mut BlockIo) -> EResult<BlockCompletion> {
+        let Some(end_lba) = io.lba().checked_add(io.num_lbas() as u64) else {
+            return Err(Errno::EOVERFLOW);
+        };
+
+        if end_lba > self.lba_count {
+            return match io.op() {
+                BlockOp::Read => Ok(BlockCompletion { lbas: 0 }),
+                BlockOp::Write => Err(Errno::ENOSPC),
+            };
+        }
+
+        let bytes = io.num_lbas() * LBA_SIZE;
+        let segment = io.first_segment();
+
+        let store = (self.base + io.lba() as usize * LBA_SIZE).as_hhdm::<u8>();
+        let buffer = segment.phys().as_hhdm::<u8>();
+
+        // The backing store and the I/O buffer never overlap.
+        unsafe {
+            match io.op() {
+                BlockOp::Read => core::ptr::copy_nonoverlapping(store, buffer, bytes),
+                BlockOp::Write => core::ptr::copy_nonoverlapping(buffer, store, bytes),
+            }
+        }
+
+        Ok(BlockCompletion {
+            lbas: io.num_lbas(),
+        })
+    }
+}
+
+impl Device for RamDisk {
+    fn open(self: Arc<Self>, _flags: OpenFlags) -> EResult<Arc<dyn FileOps>> {
+        Ok(self.clone())
+    }
+
+    fn major(&self) -> u32 {
+        RAM_MAJOR
+    }
+
+    fn minor(&self) -> u32 {
+        self.minor
+    }
+}

kernel/src/lib.rs

@@ -54,6 +54,7 @@ pub mod util;
 pub mod vfs;
 
 use crate::{
+    device::block::ram::RamDisk,
     irq::lock::IrqLock,
     percpu::CpuData,
     process::{Identity, Process},
@@ -94,11 +95,27 @@ pub extern "C" fn main(_: usize, _: usize) {
     {
         let kernel_proc = Process::get_kernel();
         let root_dir = kernel_proc.root_dir.lock().clone();
+        let mut ramdisk_index = 0;
+
         for file in BootInfo::get().files {
-            initramfs::load(root_dir.clone(), root_dir.clone(), unsafe {
-                core::slice::from_raw_parts(file.data.as_hhdm(), file.length)
-            })
-            .expect("Failed to load one of the provided initramfs archives");
+            let data =
+                unsafe { core::slice::from_raw_parts(file.data.as_hhdm::<u8>(), file.length) };
+
+            if initramfs::is_initramfs(data) {
+                initramfs::load(root_dir.clone(), root_dir.clone(), data)
+                    .expect("Failed to load one of the provided initramfs archives");
+            } else {
+                let name = format!("ram{ramdisk_index}");
+                let disk = Arc::new(RamDisk::new(file.data, file.length));
+                device::block::register_block_device(&name, disk)
+                    .expect("Failed to register RAM disk block device");
+                log!(
+                    "Exposed module \"{}\" as RAM disk /dev/block/{}",
+                    file.name,
+                    name
+                );
+                ramdisk_index += 1;
+            }
         }
     }
 

kernel/src/vfs/fs/initramfs.rs

@@ -105,6 +105,10 @@ pub fn create_dirs(
     return Ok((current, file_name));
 }
 
+pub fn is_initramfs(data: &[u8]) -> bool {
+    data.len() >= size_of::<FileHeader>() && &data[257..262] == b"ustar"
+}
+
 pub fn load(root: PathNode, target: PathNode, data: &[u8]) -> EResult<()> {
     let mut offset = 0;
     let mut name_override = None;