133 lines
3.6 KiB
Rust
133 lines
3.6 KiB
Rust
//! Simple wrapper around a FAT32 image exposed to the kernel.
|
|
//!
|
|
//! Implements a minimal disk backend and exposes a global FILE_SYSTEM used by
|
|
//! the kernel to load user binaries.
|
|
|
|
use core::fmt::Debug;
|
|
|
|
use alloc::boxed::Box;
|
|
use bffs::{Fat32FileSystem, ReadSeek, entry::DirEntry, file::File};
|
|
|
|
use io::{IoBase, Read, Seek, Write};
|
|
|
|
use crate::virtual_fs::{VirtualFileSystem, VirtualNode};
|
|
|
|
const DISK_ADDR: *const u8 = 0xA000_0000 as *const _;
|
|
|
|
#[derive(Debug)]
|
|
/// Simple disk backend that reads from a fixed memory region.
|
|
///
|
|
/// The `Disk` struct provides `Read` and `Seek` implementations over a
|
|
/// contiguous in-memory image exposed at DISK_ADDR.
|
|
pub struct Disk {
|
|
pos: u64,
|
|
size: u64,
|
|
}
|
|
|
|
impl Disk {
|
|
/// Create a new `Disk` representing an in-memory image of `size` bytes.
|
|
pub fn new(size: u64) -> Self {
|
|
Self { pos: 0, size }
|
|
}
|
|
}
|
|
|
|
impl IoBase for Disk {
|
|
type Error = ();
|
|
}
|
|
|
|
impl Seek for Disk {
|
|
fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
|
|
match pos {
|
|
io::SeekFrom::Start(pos) => self.pos = pos,
|
|
io::SeekFrom::End(_) => unimplemented!(),
|
|
io::SeekFrom::Current(pos) => self.pos = (self.pos as i64 + pos) as u64,
|
|
}
|
|
Ok(self.pos)
|
|
}
|
|
}
|
|
|
|
impl Read for Disk {
|
|
/// Read bytes from the in-memory disk image into `buf`.
|
|
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
|
|
if self.pos >= self.size {
|
|
return Ok(0);
|
|
}
|
|
let size = usize::min(buf.len(), (self.size - self.pos) as usize);
|
|
unsafe {
|
|
core::ptr::copy_nonoverlapping(
|
|
DISK_ADDR.byte_add(self.pos as usize),
|
|
buf.as_mut_ptr(),
|
|
size,
|
|
);
|
|
}
|
|
self.pos += size as u64;
|
|
Ok(size)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Fat32VirtualNode<'a, T> {
|
|
kind: Fat32VirtualNodeType<'a, T>,
|
|
_entry: DirEntry<'a, T>,
|
|
}
|
|
#[derive(Debug)]
|
|
enum Fat32VirtualNodeType<'a, T> {
|
|
Dir,
|
|
File(File<'a, T>),
|
|
}
|
|
|
|
impl<'a, T: ReadSeek> Fat32VirtualNode<'a, T> {
|
|
pub unsafe fn new(entry: DirEntry<'a, T>) -> Self {
|
|
let kind = if entry.is_dir() {
|
|
Fat32VirtualNodeType::Dir
|
|
} else {
|
|
Fat32VirtualNodeType::File(entry.to_file())
|
|
};
|
|
Self {
|
|
kind,
|
|
_entry: entry,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ReadSeek + Debug> VirtualNode for Fat32VirtualNode<'_, T> {}
|
|
|
|
impl<T> IoBase for Fat32VirtualNode<'_, T> {
|
|
type Error = ();
|
|
}
|
|
|
|
impl<T: ReadSeek + Debug> Seek for Fat32VirtualNode<'_, T> {
|
|
fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
|
|
match &mut self.kind {
|
|
Fat32VirtualNodeType::Dir => todo!(),
|
|
Fat32VirtualNodeType::File(file) => file.seek(pos).map_err(|_| ()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ReadSeek + Debug> Read for Fat32VirtualNode<'_, T> {
|
|
fn read(&mut self, buf: &mut [u8]) -> Result<usize, ()> {
|
|
match &mut self.kind {
|
|
Fat32VirtualNodeType::Dir => unimplemented!(),
|
|
Fat32VirtualNodeType::File(file) => file.read(buf).map_err(|_| ()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ReadSeek + Debug> Write for Fat32VirtualNode<'_, T> {
|
|
fn write(&mut self, _buf: &[u8]) -> Result<usize, ()> {
|
|
todo!()
|
|
}
|
|
|
|
fn flush(&mut self) -> Result<(), Self::Error> {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl<T: ReadSeek + Debug> VirtualFileSystem for Fat32FileSystem<T> {
|
|
fn open(&mut self, path: &bffs::path::Path) -> Result<Box<dyn VirtualNode + '_>, ()> {
|
|
let entry = self.open_entry(path).unwrap();
|
|
Ok(Box::new(unsafe { Fat32VirtualNode::new(entry) }))
|
|
}
|
|
}
|