add lseek

Signed-off-by: Julien CLEMENT <julien.clement@epita.fr>

src/boot/boot.asm

@@ -170,7 +170,7 @@ p2_table:
     resb 4096
 
 stack_bottom:
-    resb 4 * 4096
+    resb 100 * 4096
 stack_top:
 
 

src/drivers/atapi/interrupt.rs

@@ -3,26 +3,24 @@ use core::pin::Pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::task::{Context, Poll};
 
-use lazy_static::lazy_static;
 use futures_util::task::AtomicWaker;
+use lazy_static::lazy_static;
 
 lazy_static! {
     pub static ref INTERRUPT_FUTURE: InterruptFuture = InterruptFuture::new();
-
     static ref INTERRUPT: AtomicBool = AtomicBool::new(false);
 }
 
 static WAKER: AtomicWaker = AtomicWaker::new();
 
-
 pub(crate) fn mark_interrupt() {
     INTERRUPT.store(true, Ordering::Relaxed);
     WAKER.wake();
 }
 
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
 pub struct InterruptFuture {
-    _private:(),
+    _private: (),
 }
 
 impl InterruptFuture {
@@ -51,7 +49,7 @@ impl Future for InterruptFuture {
             true => {
                 WAKER.take();
                 Poll::Ready(())
-            },
+            }
             false => Poll::Pending,
         }
     }

src/drivers/atapi/mod.rs

@@ -1,20 +1,20 @@
-mod scsi;
 pub mod interrupt;
+mod scsi;
 
 use crate::{println, serial_println};
-use scsi::{SCSIPacket};
-use interrupt::{INTERRUPT_FUTURE};
+use interrupt::INTERRUPT_FUTURE;
+use scsi::SCSIPacket;
 
 use core::convert::TryInto;
 
-use lazy_static::lazy_static;
 use crate::utils::AsyncMutex;
+use lazy_static::lazy_static;
 use x86_64::instructions::port::Port;
 
 const CD_SECTOR_SIZE: usize = 2048;
 
 // Data buses
-const ATA_BUS_PRIMARY: u16= 0x1f0;
+const ATA_BUS_PRIMARY: u16 = 0x1f0;
 const ATA_BUS_SECONDARY: u16 = 0x170;
 
 // Drives
@@ -54,16 +54,13 @@ static ATAPI_SIG: [u8; 4] = [
     ATAPI_SIG_SC,
     ATAPI_SIG_LBA_LO,
     ATAPI_SIG_LBA_MI,
-    ATAPI_SIG_LBA_HI
+    ATAPI_SIG_LBA_HI,
 ];
 
 lazy_static! {
-    pub static ref DRIVE: AsyncMutex<Option<ATABus>> = {
-        AsyncMutex::new(ATABus::discover_atapi_drive())
-    };
+    pub static ref DRIVE: AsyncMutex<Option<ATABus>> = AsyncMutex::new(ATABus::discover_atapi_drive());
 }
 
-
 pub async fn init() {
     println!("Detecting drives");
     match DRIVE.lock().await.as_ref() {
@@ -72,12 +69,12 @@ pub async fn init() {
             let drive_type = match drive.current_drive {
                 ATA_DRIVE_MASTER => "master",
                 ATA_DRIVE_SLAVE => "slave",
-                _ => "bad"
+                _ => "bad",
             };
             let bus = match drive.base_port {
                 ATA_BUS_PRIMARY => "primary",
                 ATA_BUS_SECONDARY => "secondary",
-                _ => "bad"
+                _ => "bad",
             };
             println!("Detected {} drive on {} bus", drive_type, bus);
         }
@@ -204,7 +201,7 @@ impl ATABus {
         self.wait_packet_request();
 
         for i in (0..raw_packet.len()).step_by(2) {
-            let word = u16::from_le_bytes(raw_packet[i..i+2].try_into().unwrap());
+            let word = u16::from_le_bytes(raw_packet[i..i + 2].try_into().unwrap());
             unsafe {
                 self.data.write(word);
             }
@@ -323,9 +320,12 @@ impl ATABus {
     }
 }
 
-
 #[allow(dead_code)]
 pub async fn print_block(lba: u32) {
     let block = DRIVE.lock().await.as_mut().unwrap().read_block(lba).await;
     serial_println!("{:x?}", block);
 }
+
+pub async fn read_block(lba: u32) -> [u8; CD_SECTOR_SIZE] {
+    DRIVE.lock().await.as_mut().unwrap().read_block(lba).await
+}

src/drivers/atapi/scsi.rs

@@ -1,5 +1,5 @@
-use postcard::{to_vec};
-use serde::{Serialize, Deserialize};
+use postcard::to_vec;
+use serde::{Deserialize, Serialize};
 
 #[derive(Default, Serialize, Deserialize, Debug, Eq, PartialEq)]
 #[repr(C, packed)]
@@ -15,7 +15,7 @@ pub struct SCSIPacket {
     transfer_length_milo: u8,
     transfer_length_lo: u8,
     flags_hi: u8,
-    control: u8
+    control: u8,
 }
 
 impl SCSIPacket {

src/drivers/mod.rs

@@ -1,3 +1,3 @@
+pub mod atapi;
 pub mod serial;
 pub mod vga;
-pub mod atapi;

src/fd/mod.rs

@@ -1,26 +1,26 @@
 use crate::println;
 use crate::utils::AsyncMutex;
 
-use alloc::{collections::BTreeMap, sync::Arc, boxed::Box};
+use alloc::{boxed::Box, collections::BTreeMap, sync::Arc};
 use async_trait::async_trait;
 use core::cell::RefCell;
+use core::sync::atomic::{AtomicU32, Ordering};
 use lazy_static::lazy_static;
 
 pub type FDt = Arc<RefCell<dyn FileDescriptor>>;
 
 lazy_static! {
-    pub static ref FD_TABLE: AsyncMutex<FDTable> = {
-        AsyncMutex::new(FDTable::new())
-    };
+    pub static ref FD_TABLE: AsyncMutex<FDTable> = AsyncMutex::new(FDTable::new());
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct FDId(u64);
+pub struct FDId(u32);
 
 impl FDId {
     pub fn new() -> Self {
         // TODO: search for first available fd
-        FDId(1)
+        static NEXT_ID: AtomicU32 = AtomicU32::new(0);
+        FDId(NEXT_ID.fetch_add(1, Ordering::Relaxed))
     }
 }
 
@@ -30,13 +30,25 @@ pub struct FDTable {
 
 impl FDTable {
     pub fn new() -> Self {
-        FDTable { table: BTreeMap::new() }
+        FDTable {
+            table: BTreeMap::new(),
+        }
     }
 
-    pub async fn register_fd(&mut self, fd: FDt) {
-        // TODO
+    pub fn unregister_fd(&mut self, fd: &dyn FileDescriptor) {
+        self.table.remove(&fd.get_fd());
+        println!(
+            "Unregistered fd: {:?}",
+            fd.get_fd()
+        );
+    }
+
+    pub fn register_fd(&mut self, fd: FDt) {
         self.table.insert(fd.borrow().get_fd(), fd.clone());
-        println!("Registered fd: {:?}", self.table.get(&FDId(1)).unwrap().borrow().get_fd());
+        println!(
+            "Registered fd: {:?}",
+            self.table.get(&FDId(0)).unwrap().borrow().get_fd()
+        );
     }
 }
 
@@ -44,5 +56,7 @@ impl FDTable {
 pub trait FileDescriptor {
     fn get_fd(&self) -> FDId;
     async fn write(&mut self, buf: &[u8], count: usize) -> isize;
-    async fn read(&mut self, buf: &[u8], count: usize) -> isize;
+    async fn read(&mut self, buf: &mut [u8], count: usize) -> isize;
+    async fn close(&mut self);
+    async fn lseek(&mut self, offset: i32, whence: u32) -> i32;
 }

src/fs/iso/fd.rs

@@ -1,19 +1,30 @@
-use crate::println;
-use crate::fd::{FDId, FileDescriptor, FDt};
+use crate::drivers::atapi::read_block;
+use crate::fd::{FDId, FDt, FileDescriptor, FD_TABLE};
 
-use alloc::{sync::Arc, boxed::Box};
+use super::iso9660::{IsoDir, ISO_BLOCK_SIZE};
+
+use alloc::{boxed::Box, sync::Arc};
 use async_trait::async_trait;
 use core::cell::RefCell;
 
 pub struct IsoFD {
     pub fd: FDId,
+    offset: u32,
+    lba: u32,
+    size: u32
 }
 
 impl IsoFD {
-    pub fn new() -> FDt {
-        Arc::new(RefCell::new(IsoFD {
+    pub async fn new(entry: &IsoDir) -> FDt {
+        let fd = Arc::new(RefCell::new(IsoFD {
             fd: FDId::new(),
-        }))
+            offset: 0,
+            lba: entry.data_blk.le,
+            size: entry.file_size.le,
+        }));
+
+        FD_TABLE.lock().await.register_fd(fd.clone());
+        fd
     }
 }
 
@@ -23,12 +34,45 @@ impl FileDescriptor for IsoFD {
         self.fd
     }
 
-    async fn write(&mut self, buf: &[u8], count: usize) -> isize {
-        0
+    async fn write(&mut self, _buf: &[u8], _count: usize) -> isize {
+        -1
     }
 
-    async fn read(&mut self, buf: &[u8], count: usize) -> isize {
-        println!("Read from fd");
-        0
+    #[allow(unaligned_references)]
+    async fn read(&mut self, buf: &mut [u8], count: usize) -> isize {
+        let mut block_offset = self.offset / ISO_BLOCK_SIZE;
+        let mut content = read_block(self.lba + block_offset).await;
+        let mut read: isize = 0;
+        for _ in 0..count {
+            if self.offset >= self.size {
+                break;
+            }
+
+            buf[read as usize] = content[(self.offset % ISO_BLOCK_SIZE) as usize];
+            read += 1;
+            self.offset += 1;
+
+            if self.offset % ISO_BLOCK_SIZE == 0 {
+                block_offset += 1;
+                content = read_block(self.lba + block_offset).await;
+            }
+        }
+
+        read
+    }
+
+    async fn close(&mut self) {
+        FD_TABLE.lock().await.unregister_fd(self);
+    }
+
+    async fn lseek(&mut self, offset: i32, whence: u32) -> i32 {
+        use crate::syscalls::io::*;
+        match whence {
+            w if w == SEEK_SET => self.offset = offset as u32,
+            w if w == SEEK_CUR => self.offset = (self.offset as i32 + offset) as u32,
+            w if w == SEEK_END => self.offset = (self.size as i32 + offset) as u32,
+            _ => {}
+        };
+        self.offset as i32
     }
 }

src/fs/iso/iso9660.rs

@@ -1,22 +1,21 @@
-const ISO_BLOCK_SIZE: usize = 2048;
+pub const ISO_BLOCK_SIZE: u32 = 2048;
 
 // Twin values structs
 
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub struct MultiEndian32 {
-    le: u32, // Little endian value
-    be: u32, // Big endian value
+    pub le: u32, // Little endian value
+    pub be: u32, // Big endian value
 }
 
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub struct MultiEndian16 {
-    le: u16, // Little endian value
-    be: u16, // Big endian value
+    pub le: u16, // Little endian value
+    pub be: u16, // Big endian value
 }
 
-
 // Path table structure
 
 #[repr(C, packed)]
@@ -26,63 +25,77 @@ struct IsoPathTable {
     ext_size: u8,    // Extended attribute record length
     data_blk: u8,    // File data block index
     parent_dir: u16, // Number of the parent dir
-    idf: [u8; 0] // Directory name, of size Self::idf_len
+    idf: [u8; 0],    // Directory name, of size Self::idf_len
 }
 
+#[allow(dead_code)]
 impl IsoPathTable {
     #[allow(unaligned_references)]
     pub fn get_idf(&self) -> &[u8] {
-        unsafe {
-            core::slice::from_raw_parts(self.idf.as_ptr(), self.idf_len as usize)
-        }
+        unsafe { core::slice::from_raw_parts(self.idf.as_ptr(), self.idf_len as usize) }
     }
 }
 
-
 // Directory structure
 
+#[allow(dead_code)]
+const ISO_MAX_DIR_DEPTH: usize = 8;
 const ISO_DATE_LEN: usize = 7;
 
 #[repr(u8)]
-#[derive(Copy, Clone)]
-enum IsoFileType {
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[allow(dead_code)]
+pub enum IsoFileType {
     HIDDEN = 0x1,    // Hidden file
     ISDIR = 0x2,     // Directory
     ASSOCIAT = 0x4,  // Associated
     USEEXT = 0x8,    //
     USEPERM = 0x10,  //
-    MULTIDIR = 0x80 // 
+    MULTIDIR = 0x80, //
 }
 
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub struct IsoDir {
-    dir_size: u8, // Length of directory record
-    ext_size: u8, // Length of extended attribute record
-    data_blk: MultiEndian32, // File data block index
-    file_size: MultiEndian32, // File size
-    date: [u8; ISO_DATE_LEN],
-    file_type: IsoFileType,
+    pub dir_size: u8,             // Length of directory record
+    pub ext_size: u8,             // Length of extended attribute record
+    pub data_blk: MultiEndian32,  // File data block index
+    pub file_size: MultiEndian32, // File size
+    pub date: [u8; ISO_DATE_LEN],
+    pub file_type: IsoFileType,
 
-    unit_size: u8,
-    gap_size: u8,
+    pub unit_size: u8,
+    pub gap_size: u8,
 
-    vol_seq: MultiEndian16,
+    pub vol_seq: MultiEndian16,
 
-    idf_len: u8, // File name length
-    idf: [u8; 0], // File name
+    pub idf_len: u8,  // File name length
+    pub idf: [u8; 0], // File name
 }
 
 impl IsoDir {
     #[allow(unaligned_references)]
     pub fn get_idf(&self) -> &[u8] {
+        let mut len: usize = self.idf_len as usize;
         unsafe { 
-            core::slice::from_raw_parts(self.idf.as_ptr(), self.idf_len as usize)
+            let mut idf = core::slice::from_raw_parts(self.idf.as_ptr(), len as usize);
+            if len > 2 && idf[len - 2] == b';' && idf[len - 1] == b'1' {
+                len -= 2;
+                idf = core::slice::from_raw_parts(self.idf.as_ptr(), len as usize);
             }
+            idf
+        }
+    }
+
+    pub fn next_entry(&self) -> &IsoDir {
+        crate::utils::ref_raw_offset(self, self.dir_size as isize)
+    }
+
+    pub fn matches(&self, path: &str) -> bool {
+        self.get_idf() == path.as_bytes()
     }
 }
 
-
 // Primary volume descriptor structure
 
 pub const ISO_PRIM_VOLDESC_BLOCK: u32 = 16;

src/fs/iso/mod.rs

@@ -1,37 +1,83 @@
-pub mod iso9660;
 mod fd;
+pub mod iso9660;
 
-use crate::println;
-use crate::drivers::atapi::{DRIVE};
-use crate::fd::{FD_TABLE, FDt};
+use crate::drivers::atapi::read_block;
+use crate::fd::{FDt};
 use crate::utils::unserialize;
 
-use iso9660::{IsoPrimVolDesc, IsoDir};
+use super::FileSystem;
 use fd::IsoFD;
+use iso9660::{IsoDir, IsoPrimVolDesc};
 
-pub async fn get_prim_vol_desc() -> IsoPrimVolDesc {
-    let desc_block = DRIVE
-        .lock()
-        .await
-        .as_mut()
-        .unwrap()
-        .read_block(iso9660::ISO_PRIM_VOLDESC_BLOCK)
-        .await;
-    *unserialize::<IsoPrimVolDesc>(desc_block.as_ptr())
-}
+use alloc::{boxed::Box, string::String, vec::Vec};
+use async_trait::async_trait;
 
-pub async fn open(path: &str, flags: u32) -> Option<FDt> {
+pub struct IsoFS {}
+
+#[async_trait(?Send)]
+#[allow(unaligned_references)]
+impl FileSystem for IsoFS {
+    async fn open(&mut self, path: &str, flags: u32) -> Option<FDt> {
+        // ISO is a read only file system
         if flags != crate::syscalls::io::O_RDONLY {
             return None;
         }
 
         let voldesc = get_prim_vol_desc().await;
 
+        // Invalid ISO
         if voldesc.std_identifier != "CD001".as_bytes() {
             return None;
         }
 
-    let fd = IsoFD::new();
-    FD_TABLE.lock().await.register_fd(fd.clone()).await;
-    Some(fd)
+        let root: &IsoDir = &voldesc.root_dir;
+        let mut curr_entry_block: [u8; iso9660::ISO_BLOCK_SIZE as usize] = read_block(root.data_blk.le).await;
+
+        let mut curr_entry: &IsoDir = unserialize(curr_entry_block.as_ptr());
+
+        let path_s: String = String::from(path);
+        let path_split: Vec<&str> = path_s.split("/").collect();
+        let path_it = path_s
+            .split("/")
+            .filter(|p| p != &"");
+
+        for path_component in path_it {
+            let mut found = false;
+            while curr_entry.idf_len != 0 {
+
+                // Found entry
+                if curr_entry.matches(path_component) {
+                    found = true;
+
+                    // Not the last component, go 1 directory deeper
+                    if path_component != path_split[path_split.len() - 1] {
+                        // Not a directory
+                        if curr_entry.file_type != iso9660::IsoFileType::ISDIR {
+                            return None;
+                        }
+                        // Deeper entries
+                        curr_entry_block = read_block(curr_entry.data_blk.le).await;
+                        curr_entry = unserialize(curr_entry_block.as_ptr());
+                    }
+                    break;
+                }
+
+                // Next entry
+                curr_entry = curr_entry.next_entry();
+            }
+
+            // File not found
+            if !found {
+                return None;
+            }
+        }
+
+        Some(IsoFD::new(curr_entry).await)
+    }
+}
+
+
+pub async fn get_prim_vol_desc() -> IsoPrimVolDesc {
+    let desc_block = read_block(iso9660::ISO_PRIM_VOLDESC_BLOCK).await;
+    *unserialize::<IsoPrimVolDesc>(desc_block.as_ptr())
 }

src/fs/mod.rs

@@ -1 +1,39 @@
 pub mod iso;
+
+use crate::fd::FDt;
+use crate::utils::mutex::AsyncMutex;
+
+use alloc::{boxed::Box, sync::Arc};
+use async_trait::async_trait;
+use core::cell::RefCell;
+use lazy_static::lazy_static;
+
+pub type FSt = Arc<RefCell<dyn FileSystem>>;
+
+lazy_static! {
+    pub static ref VIRTUAL_FS: AsyncMutex<VirtualFS> = AsyncMutex::new(VirtualFS::new());
+}
+
+#[async_trait(?Send)]
+pub trait FileSystem {
+    async fn open(&mut self, path: &str, flags: u32) -> Option<FDt>;
+}
+
+pub struct VirtualFS {
+    fs: FSt,
+}
+
+impl VirtualFS {
+    fn new() -> Self {
+        VirtualFS {
+            fs: Arc::new(RefCell::new(iso::IsoFS {})),
+        }
+    }
+}
+
+#[async_trait(?Send)]
+impl FileSystem for VirtualFS {
+    async fn open(&mut self, path: &str, flags: u32) -> Option<FDt> {
+        self.fs.borrow_mut().open(path, flags).await
+    }
+}

src/interrupts/mod.rs

@@ -4,12 +4,8 @@ use crate::memory::gdt;
 use crate::println;
 use lazy_static::lazy_static;
 use pic::{
-    init_pic,
-    keyboard_interrupt_handler,
-    timer_interrupt_handler,
-    disk1_interrupt_handler,
-    disk2_interrupt_handler,
-    InterruptIndex
+    disk1_interrupt_handler, disk2_interrupt_handler, init_pic, keyboard_interrupt_handler,
+    timer_interrupt_handler, InterruptIndex,
 };
 use x86_64::structures::idt::PageFaultErrorCode;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};

src/interrupts/pic/mod.rs

@@ -1,12 +1,12 @@
 use crate::println;
+pub use disk::{disk1_interrupt_handler, disk2_interrupt_handler};
 pub use keyboard::keyboard_interrupt_handler;
 use pic8259::ChainedPics;
 pub use pit::timer_interrupt_handler;
-pub use disk::{disk1_interrupt_handler, disk2_interrupt_handler};
 
+pub mod disk;
 pub mod keyboard;
 pub mod pit;
-pub mod disk;
 
 pub const PIC_1_OFFSET: u8 = 32;
 pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;

src/lib.rs

@@ -4,18 +4,19 @@
 #![feature(alloc_error_handler)]
 
 mod drivers;
+mod fd;
+mod fs;
 mod interrupts;
 mod memory;
-mod task;
-mod fs;
-mod utils;
-mod fd;
 mod syscalls;
+mod task;
+mod utils;
 
 //#[macro_use]
 extern crate alloc;
 extern crate multiboot2;
 
+use crate::fs::FileSystem;
 use core::panic::PanicInfo;
 use drivers::vga::{self, Color, ColorCode};
 use multiboot2::BootInformation;
@@ -63,8 +64,23 @@ pub extern "C" fn julios_main(multiboot_info_addr: usize) -> ! {
     executor.run();
 }
 
-
 async fn get_file() {
-    let fd = fs::iso::open("test", syscalls::io::O_RDONLY).await.unwrap();
-    fd.borrow_mut().read(&[], 0).await;
+    let fd = fs::VIRTUAL_FS
+        .lock()
+        .await
+        .open("///boot/grub//grub.cfg", syscalls::io::O_RDONLY)
+        .await
+        .unwrap();
+    let mut buf: [u8; 100] = [0; 100];
+    let read = fd.borrow_mut().read(&mut buf, 100).await;
+
+    serial_println!("{:?}", read);
+    serial_println!("{}", alloc::str::from_utf8(&buf).unwrap());
+
+    fd.borrow_mut().lseek(10, syscalls::io::SEEK_SET).await;
+
+    fd.borrow_mut().read(&mut buf, 100).await;
+    serial_println!("{}", alloc::str::from_utf8(&buf).unwrap());
+
+    fd.borrow_mut().close().await;
 }

src/syscalls/io.rs

@@ -2,9 +2,6 @@
 pub const O_RDONLY: u32 = 0;
 
 // seek flags
-#[allow(dead_code)]
 pub const SEEK_SET: u32 = 0;
-#[allow(dead_code)]
 pub const SEEK_CUR: u32 = 1;
-#[allow(dead_code)]
 pub const SEEK_END: u32 = 2;

src/utils/mod.rs

@@ -1,5 +1,19 @@
-pub mod serialize;
 pub mod mutex;
+pub mod serialize;
 
-pub use serialize::unserialize;
 pub use mutex::AsyncMutex;
+pub use serialize::unserialize;
+
+pub fn ref_offset<T>(r: &T, off: isize) -> &T {
+    let ref_ptr: *const T = r;
+    unsafe {
+        return &*ref_ptr.offset(off);
+    }
+}
+
+pub fn ref_raw_offset<T>(r: &T, off: isize) -> &T {
+    let ref_ptr: *const T = r;
+    unsafe {
+        return &*ref_ptr.cast::<u8>().offset(off).cast::<T>();
+    }
+}

src/utils/mutex.rs

@@ -1,10 +1,10 @@
-use core::future::Future;
-use core::pin::Pin;
+use alloc::sync::Arc;
 use core::cell::UnsafeCell;
+use core::future::Future;
 use core::ops::{Deref, DerefMut, Drop};
+use core::pin::Pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::task::{Context, Poll};
-use alloc::sync::Arc;
 
 use futures_util::task::AtomicWaker;
 
@@ -14,7 +14,7 @@ struct Lock {
     waker: Arc<AtomicWaker>,
 }
 
-pub struct AsyncMutex<T> {
+pub struct AsyncMutex<T: ?Sized> {
     lock: Lock,
     inner: UnsafeCell<T>,
 }
@@ -23,7 +23,7 @@ pub struct AsyncMutexGuard<'a, T>
 where
     T: 'a,
 {
-    mutex: &'a AsyncMutex<T>
+    mutex: &'a AsyncMutex<T>,
 }
 
 impl Lock {
@@ -58,7 +58,7 @@ impl Future for Lock {
             false => {
                 self.waker.take();
                 Poll::Ready(())
-            },
+            }
             true => Poll::Pending,
         }
     }
@@ -98,16 +98,12 @@ impl<T> Drop for AsyncMutexGuard<'_, T> {
 impl<T> Deref for AsyncMutexGuard<'_, T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
-        unsafe {
-            &*self.mutex.inner.get()
-        }
+        unsafe { &*self.mutex.inner.get() }
     }
 }
 
 impl<T> DerefMut for AsyncMutexGuard<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe {
-            &mut *self.mutex.inner.get()
-        }
+        unsafe { &mut *self.mutex.inner.get() }
     }
 }

src/utils/serialize.rs

@@ -1,6 +1,4 @@
 pub fn unserialize<T>(ptr: *const u8) -> &'static T {
     let path_table_ptr: *const T = ptr as *const T;
-    unsafe {
-        &*path_table_ptr
-    }
+    unsafe { &*path_table_ptr }
 }