chore: use FsResult<T = ()> instead of Result

Author: GZTimeWalker

src/0x06/pkg/kernel/src/drivers/ata/bus.rs

@@ -131,7 +131,7 @@ impl AtaBus {
     /// Writes the given command
     ///
     /// reference: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
-    fn write_command(&mut self, drive: u8, block: u32, cmd: AtaCommand) -> storage::Result<()> {
+    fn write_command(&mut self, drive: u8, block: u32, cmd: AtaCommand) -> storage::FsResult {
         let bytes = block.to_le_bytes(); // a trick to convert u32 to [u8; 4]
         unsafe {
             // just 1 sector for current implementation
@@ -164,7 +164,7 @@ impl AtaBus {
     /// Identifies the drive at the given `drive` number (0 or 1).
     ///
     /// reference: https://wiki.osdev.org/ATA_PIO_Mode#IDENTIFY_command
-    pub(super) fn identify_drive(&mut self, drive: u8) -> storage::Result<AtaDeviceType> {
+    pub(super) fn identify_drive(&mut self, drive: u8) -> storage::FsResult<AtaDeviceType> {
         info!("Identifying drive {}", drive);
 
         // FIXME: use `AtaCommand::IdentifyDevice` to identify the drive
@@ -194,7 +194,7 @@ impl AtaBus {
         drive: u8,
         block: u32,
         buf: &mut [u8],
-    ) -> storage::Result<()> {
+    ) -> storage::FsResult {
         self.write_command(drive, block, AtaCommand::ReadPio)?;
 
         // FIXME: read the data from the data port into the buffer
@@ -215,7 +215,7 @@ impl AtaBus {
     ///
     /// reference: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
     /// reference: https://wiki.osdev.org/IDE#Read.2FWrite_From_ATA_Drive
-    pub(super) fn write_pio(&mut self, drive: u8, block: u32, buf: &[u8]) -> storage::Result<()> {
+    pub(super) fn write_pio(&mut self, drive: u8, block: u32, buf: &[u8]) -> storage::FsResult {
         self.write_command(drive, block, AtaCommand::WritePio)?;
 
         // FIXME: write the data from the buffer into the data port

src/0x06/pkg/kernel/src/drivers/ata/mod.rs

@@ -78,19 +78,19 @@ impl core::fmt::Display for AtaDrive {
 use storage::{Block512, BlockDevice};
 
 impl BlockDevice<Block512> for AtaDrive {
-    fn block_count(&self) -> storage::Result<usize> {
+    fn block_count(&self) -> storage::FsResult<usize> {
         // FIXME: return the block count
         todo!()
     }
 
-    fn read_block(&self, offset: usize, block: &mut Block512) -> storage::Result<()> {
+    fn read_block(&self, offset: usize, block: &mut Block512) -> storage::FsResult {
         // FIXME: read the block
         //      - use `BUSES` and `self` to get bus
         //      - use `read_pio` to get data
         todo!()
     }
 
-    fn write_block(&self, offset: usize, block: &Block512) -> storage::Result<()> {
+    fn write_block(&self, offset: usize, block: &Block512) -> storage::FsResult {
         // FIXME: write the block
         //      - use `BUSES` and `self` to get bus
         //      - use `write_pio` to write data

src/0x06/pkg/storage/src/common/device.rs

@@ -6,13 +6,13 @@ where
     B: BlockTrait,
 {
     /// Returns the number of blocks in the device
-    fn block_count(&self) -> Result<usize>;
+    fn block_count(&self) -> FsResult<usize>;
 
     /// Reads a block from the device into the provided buffer
-    fn read_block(&self, offset: usize, block: &mut B) -> Result<()>;
+    fn read_block(&self, offset: usize, block: &mut B) -> FsResult;
 
     /// Writes a block to the device from the provided buffer
-    fn write_block(&self, offset: usize, block: &B) -> Result<()>;
+    fn write_block(&self, offset: usize, block: &B) -> FsResult;
 
     /// Returns the block size of the device
     fn block_size(&self) -> usize {

src/0x06/pkg/storage/src/common/error.rs

@@ -1,6 +1,6 @@
 use crate::*;
 
-pub type Result<T> = core::result::Result<T, FsError>;
+pub type FsResult<T = ()> = core::result::Result<T, FsError>;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum FsError {

src/0x06/pkg/storage/src/common/filesystem.rs

@@ -6,53 +6,53 @@ use core::fmt::Debug;
 /// File system trait
 pub trait FileSystem: Debug + Sync + Send {
     /// Iterates over all direct children of this directory path
-    fn read_dir(&self, path: &str) -> Result<Box<dyn Iterator<Item = Metadata> + Send>>;
+    fn read_dir(&self, path: &str) -> FsResult<Box<dyn Iterator<Item = Metadata> + Send>>;
 
     /// Opens the file at this path for reading
-    fn open_file(&self, path: &str) -> Result<FileHandle>;
+    fn open_file(&self, path: &str) -> FsResult<FileHandle>;
 
     /// Returns the file metadata for the file at this path
-    fn metadata(&self, path: &str) -> Result<Metadata>;
+    fn metadata(&self, path: &str) -> FsResult<Metadata>;
 
     /// Returns true if a file or directory at path exists, false otherwise
-    fn exists(&self, path: &str) -> Result<bool>;
+    fn exists(&self, path: &str) -> FsResult<bool>;
 
     // ----------------------------------------------------
     // NOTE: following functions are not implemented (optional)
     // ----------------------------------------------------
 
     /// Creates a file at this path for writing
-    fn create_file(&self, _path: &str) -> Result<FileHandle> {
+    fn create_file(&self, _path: &str) -> FsResult<FileHandle> {
         Err(FsError::NotSupported)
     }
 
     /// Opens the file at this path for appending
-    fn append_file(&self, _path: &str) -> Result<FileHandle> {
+    fn append_file(&self, _path: &str) -> FsResult<FileHandle> {
         Err(FsError::NotSupported)
     }
 
     /// Removes the file at this path
-    fn remove_file(&self, _path: &str) -> Result<FileHandle> {
+    fn remove_file(&self, _path: &str) -> FsResult<FileHandle> {
         Err(FsError::NotSupported)
     }
 
     /// Removes the directory at this path
-    fn remove_dir(&self, _path: &str) -> Result<FileHandle> {
+    fn remove_dir(&self, _path: &str) -> FsResult<FileHandle> {
         Err(FsError::NotSupported)
     }
 
     /// Copies the src path to the destination path within the same filesystem
-    fn copy_file(&self, _src: &str, _dst: &str) -> Result<()> {
+    fn copy_file(&self, _src: &str, _dst: &str) -> FsResult {
         Err(FsError::NotSupported)
     }
 
     /// Moves the src path to the destination path within the same filesystem
-    fn move_file(&self, _src: &str, _dst: &str) -> Result<()> {
+    fn move_file(&self, _src: &str, _dst: &str) -> FsResult {
         Err(FsError::NotSupported)
     }
 
     /// Moves the src directory to the destination path within the same filesystem
-    fn move_dir(&self, _src: &str, _dst: &str) -> Result<()> {
+    fn move_dir(&self, _src: &str, _dst: &str) -> FsResult {
         Err(FsError::NotSupported)
     }
 }

src/0x06/pkg/storage/src/common/io.rs

@@ -4,10 +4,10 @@ use crate::*;
 pub trait Read {
     /// Pull some bytes from this source into the specified buffer, returning
     /// how many bytes were read.
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+    fn read(&mut self, buf: &mut [u8]) -> FsResult<usize>;
 
     /// Read all bytes until EOF in this source, placing them into `buf`.
-    fn read_all(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
+    fn read_all(&mut self, buf: &mut Vec<u8>) -> FsResult<usize> {
         let mut start_len = buf.len();
         loop {
             // FIXME: read data into the buffer
@@ -23,14 +23,14 @@ pub trait Read {
 /// NOTE: Leave here to ensure flexibility for the optional lab task.
 pub trait Write {
     /// Write a buffer into this writer, returning how many bytes were written.
-    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+    fn write(&mut self, buf: &[u8]) -> FsResult<usize>;
 
     /// Flush this output stream, ensuring that all intermediately buffered
     /// contents reach their destination.
-    fn flush(&mut self) -> Result<()>;
+    fn flush(&mut self) -> FsResult;
 
     /// Attempts to write an entire buffer into this writer.
-    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
+    fn write_all(&mut self, mut buf: &[u8]) -> FsResult {
         // not required for lab
         todo!()
     }
@@ -52,7 +52,7 @@ pub enum SeekFrom {
 /// The `Seek` trait provides a cursor within byte stream.
 pub trait Seek {
     /// Seek to an offset, in bytes, in a stream.
-    fn seek(&mut self, pos: SeekFrom) -> Result<usize>;
+    fn seek(&mut self, pos: SeekFrom) -> FsResult<usize>;
 }
 
 pub trait FileIO: Read + Write + Seek {}

src/0x06/pkg/storage/src/common/mount.rs

@@ -22,22 +22,22 @@ impl Mount {
 
 impl FileSystem for Mount {
     #[inline]
-    fn read_dir(&self, path: &str) -> Result<Box<dyn Iterator<Item = Metadata> + Send>> {
+    fn read_dir(&self, path: &str) -> FsResult<Box<dyn Iterator<Item = Metadata> + Send>> {
         self.fs.read_dir(self.trim_mount_point(path))
     }
 
     #[inline]
-    fn open_file(&self, path: &str) -> Result<FileHandle> {
+    fn open_file(&self, path: &str) -> FsResult<FileHandle> {
         self.fs.open_file(self.trim_mount_point(path))
     }
 
     #[inline]
-    fn metadata(&self, path: &str) -> Result<Metadata> {
+    fn metadata(&self, path: &str) -> FsResult<Metadata> {
         self.fs.metadata(self.trim_mount_point(path))
     }
 
     #[inline]
-    fn exists(&self, path: &str) -> Result<bool> {
+    fn exists(&self, path: &str) -> FsResult<bool> {
         self.fs.exists(self.trim_mount_point(path))
     }
 }

src/0x06/pkg/storage/src/fs/fat16/bpb.rs

@@ -4,6 +4,8 @@
 //! - <https://en.wikipedia.org/wiki/BIOS_parameter_block>
 //! - <https://wiki.osdev.org/FAT#Boot_Record>
 
+use crate::*;
+
 /// Represents a Boot Parameter Block.
 ///
 /// This is the first sector of a FAT 16 formatted partition,
@@ -14,12 +16,12 @@ pub struct Fat16Bpb {
 
 impl Fat16Bpb {
     /// Attempt to parse a Boot Parameter Block from a 512 byte sector.
-    pub fn new(data: &[u8]) -> Result<Fat16Bpb, &'static str> {
+    pub fn new(data: &[u8]) -> FsResult<Fat16Bpb> {
         let data = data.try_into().unwrap();
         let bpb = Fat16Bpb { data };
 
         if bpb.data.len() != 512 || bpb.trail() != 0xAA55 {
-            return Err("Bad BPB format");
+            return Err(FsError::InvalidOperation);
         }
 
         Ok(bpb)

src/0x06/pkg/storage/src/fs/fat16/direntry.rs

@@ -52,7 +52,7 @@ impl DirEntry {
     /// For Standard 8.3 format
     ///
     /// reference: https://osdev.org/FAT#Standard_8.3_format
-    pub fn parse(data: &[u8]) -> Result<DirEntry> {
+    pub fn parse(data: &[u8]) -> FsResult<DirEntry> {
         let filename = ShortFileName::new(&data[..11]);
 
         // FIXME: parse the rest of the fields
@@ -120,7 +120,7 @@ impl ShortFileName {
     }
 
     /// Parse a short file name from a string
-    pub fn parse(name: &str) -> Result<ShortFileName> {
+    pub fn parse(name: &str) -> FsResult<ShortFileName> {
         // FIXME: implement the parse function
         //      use `FilenameError` and into `FsError`
         //      use different error types for following conditions:

src/0x06/pkg/storage/src/fs/fat16/file.rs

@@ -32,7 +32,7 @@ impl File {
 }
 
 impl Read for File {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> FsResult<usize> {
         // FIXME: read file content from disk
         //      CAUTION: file length / buffer size / offset
         //
@@ -47,18 +47,18 @@ impl Read for File {
 
 // NOTE: `Seek` trait is not required for this lab
 impl Seek for File {
-    fn seek(&mut self, pos: SeekFrom) -> Result<usize> {
+    fn seek(&mut self, pos: SeekFrom) -> FsResult<usize> {
         unimplemented!()
     }
 }
 
 // NOTE: `Write` trait is not required for this lab
 impl Write for File {
-    fn write(&mut self, _buf: &[u8]) -> Result<usize> {
+    fn write(&mut self, _buf: &[u8]) -> FsResult<usize> {
         unimplemented!()
     }
 
-    fn flush(&mut self) -> Result<()> {
+    fn flush(&mut self) -> FsResult {
         unimplemented!()
     }
 }