clean: remove some redundant types

src/driver/e1000e.rs

@@ -2,11 +2,11 @@ use crate::prelude::*;
 
 use crate::bindings::root::kernel::hw::pci;
 use crate::kernel::interrupt::register_irq_handler;
-use crate::kernel::mem::paging::copy_to_page;
 use crate::kernel::mem::{paging, phys};
 use crate::net::netdev;
 use alloc::boxed::Box;
 use alloc::vec::Vec;
+use bindings::EFAULT;
 use paging::Page;
 use phys::{NoCachePP, PhysPtr};
 
@@ -105,9 +105,7 @@ impl netdev::Netdev for E1000eDev {
         match status & defs::STAT_SPEED_MASK {
             defs::STAT_SPEED_10M => self.speed = netdev::LinkSpeed::Speed10M,
             defs::STAT_SPEED_100M => self.speed = netdev::LinkSpeed::Speed100M,
-            defs::STAT_SPEED_1000M => {
-                self.speed = netdev::LinkSpeed::Speed1000M
-            }
+            defs::STAT_SPEED_1000M => self.speed = netdev::LinkSpeed::Speed1000M,
             _ => return Err(EINVAL),
         }
 
@@ -163,17 +161,9 @@ impl netdev::Netdev for E1000eDev {
             let len = desc.length as usize;
 
             let buffers = self.rx_buffers.as_mut().ok_or(EIO)?;
-            let data = unsafe {
-                core::slice::from_raw_parts(
-                    buffers[next_tail as usize].as_cached().as_ptr::<u8>(),
-                    len,
-                )
-            };
-
-            println_debug!(
-                "e1000e: received {len} bytes, {:?}",
-                PrintableBytes(data)
-            );
+            let data = &buffers[next_tail as usize].as_slice()[..len];
+
+            println_debug!("e1000e: received {len} bytes, {:?}", PrintableBytes(data));
             self.rx_tail = Some(next_tail);
         }
 
@@ -195,7 +185,10 @@ impl netdev::Netdev for E1000eDev {
         }
 
         let buffer_page = Page::alloc_one();
-        copy_to_page(buf, &buffer_page)?;
+        if buf.len() > buffer_page.len() {
+            return Err(EFAULT);
+        }
+        buffer_page.as_mut_slice()[..buf.len()].copy_from_slice(buf);
 
         desc.buffer = buffer_page.as_phys() as u64;
         desc.length = buf.len() as u16;
@@ -437,8 +430,7 @@ pub fn register_e1000e_driver() {
     let dev_ids = [0x100e, 0x10d3, 0x10ea, 0x153a];
 
     for id in dev_ids.into_iter() {
-        let ret =
-            unsafe { pci::register_driver_r(0x8086, id, Some(probe_device)) };
+        let ret = unsafe { pci::register_driver_r(0x8086, id, Some(probe_device)) };
 
         assert_eq!(ret, 0);
     }

src/elf.rs

@@ -2,7 +2,7 @@ use alloc::{ffi::CString, sync::Arc};
 use bitflags::bitflags;
 
 use crate::{
-    io::{RawBuffer, UninitBuffer},
+    io::{ByteBuffer, UninitBuffer},
     kernel::{
         constants::ENOEXEC,
         mem::{FileMapping, MMList, Mapping, Permission, VAddr},
@@ -204,7 +204,7 @@ impl ParsedElf32 {
         let mut header = UninitBuffer::<Elf32Header>::new();
         file.read(&mut header, 0)?;
 
-        let header = header.assume_init().ok_or(ENOEXEC)?;
+        let header = header.assume_init().map_err(|_| ENOEXEC)?;
         if !header.check_valid() {
             return Err(ENOEXEC);
         }
@@ -212,7 +212,7 @@ impl ParsedElf32 {
         // TODO: Use `UninitBuffer` for `phents` and `shents`.
         let mut phents = vec![Elf32PhEntry::default(); header.ph_entry_count as usize];
         let nread = file.read(
-            &mut RawBuffer::new_from_slice(phents.as_mut_slice()),
+            &mut ByteBuffer::from(phents.as_mut_slice()),
             header.ph_offset as usize,
         )?;
         if nread != header.ph_entry_count as usize * size_of::<Elf32PhEntry>() {
@@ -221,7 +221,7 @@ impl ParsedElf32 {
 
         let mut shents = vec![Elf32ShEntry::default(); header.sh_entry_count as usize];
         let nread = file.read(
-            &mut RawBuffer::new_from_slice(shents.as_mut_slice()),
+            &mut ByteBuffer::from(shents.as_mut_slice()),
             header.sh_offset as usize,
         )?;
         if nread != header.sh_entry_count as usize * size_of::<Elf32ShEntry>() {

src/fs/fat32.rs

@@ -11,7 +11,7 @@ use dir::Dirs as _;
 use file::ClusterRead;
 
 use crate::{
-    io::{Buffer, RawBuffer, UninitBuffer},
+    io::{Buffer, ByteBuffer, UninitBuffer},
     kernel::{
         block::{make_device, BlockDevice, BlockDeviceRequest},
         constants::{S_IFDIR, S_IFREG},
@@ -159,17 +159,13 @@ impl FatFs {
             0,
         );
 
-        let mut buffer = RawBuffer::new_from_slice(fat.as_mut_slice());
+        let mut buffer = ByteBuffer::from(fat.as_mut_slice());
 
         fatfs
             .device
             .read_some(info.reserved_sectors as usize * 512, &mut buffer)?
             .ok_or(EIO)?;
 
-        if !buffer.filled() {
-            return Err(EIO);
-        }
-
         info.volume_label
             .iter()
             .take_while(|&&c| c != ' ' as u8)

src/fs/fat32/file.rs

@@ -29,7 +29,7 @@ impl<'data, 'fat: 'data> ClusterRead<'data> for ClusterIterator<'fat> {
 
         self.skip(skip_clusters).map(move |cluster| {
             vfs.read_cluster(cluster, &buffer_page)?;
-            let data = &buffer_page.as_cached().as_slice(buffer_page.len())[inner_offset..];
+            let data = &buffer_page.as_slice()[inner_offset..];
             inner_offset = 0;
             Ok(data)
         })

src/io.rs

@@ -82,7 +82,7 @@ where
 
 pub struct UninitBuffer<'lt, T: Copy + Sized> {
     data: Box<MaybeUninit<T>>,
-    buffer: RawBuffer<'lt>,
+    buffer: ByteBuffer<'lt>,
 }
 
 impl<'lt, T: Copy + Sized> UninitBuffer<'lt, T> {
@@ -92,25 +92,25 @@ impl<'lt, T: Copy + Sized> UninitBuffer<'lt, T> {
 
         Self {
             data,
-            buffer: RawBuffer::new_from_slice(unsafe {
+            buffer: ByteBuffer::from(unsafe {
                 core::slice::from_raw_parts_mut(ptr as *mut u8, core::mem::size_of::<T>())
             }),
         }
     }
 
     pub fn assume_filled_ref(&self) -> KResult<&T> {
-        if !self.buffer.filled() {
+        if self.buffer.available() != 0 {
             Err(EFAULT)
         } else {
             Ok(unsafe { self.data.assume_init_ref() })
         }
     }
 
-    pub fn assume_init(self) -> Option<T> {
-        if self.buffer.filled() {
-            Some(unsafe { *self.data.assume_init() })
+    pub fn assume_init(self) -> KResult<T> {
+        if self.buffer.available() != 0 {
+            Err(EFAULT)
         } else {
-            None
+            Ok(unsafe { *self.data.assume_init() })
         }
     }
 }
@@ -129,78 +129,6 @@ impl<'lt, T: Copy + Sized> Buffer for UninitBuffer<'lt, T> {
     }
 }
 
-pub struct RawBuffer<'lt> {
-    buf: *mut u8,
-    tot: usize,
-    cur: usize,
-    _phantom: core::marker::PhantomData<&'lt mut u8>,
-}
-
-impl<'lt> RawBuffer<'lt> {
-    pub fn new_from_slice<T: Copy + Sized>(buf: &'lt mut [T]) -> Self {
-        Self {
-            buf: buf.as_mut_ptr() as *mut u8,
-            tot: core::mem::size_of::<T>() * buf.len(),
-            cur: 0,
-            _phantom: core::marker::PhantomData,
-        }
-    }
-
-    pub fn count(&self) -> usize {
-        self.cur
-    }
-
-    pub fn total(&self) -> usize {
-        self.tot
-    }
-
-    pub fn available(&self) -> usize {
-        self.total() - self.count()
-    }
-
-    pub fn filled(&self) -> bool {
-        self.count() == self.total()
-    }
-
-    pub fn fill(&mut self, data: &[u8]) -> KResult<FillResult> {
-        match self.available() {
-            n if n == 0 => Ok(FillResult::Full),
-            n if n < data.len() => {
-                unsafe {
-                    core::ptr::copy_nonoverlapping(data.as_ptr(), self.buf.add(self.count()), n);
-                }
-                self.cur += n;
-                Ok(FillResult::Partial(n))
-            }
-            _ => {
-                unsafe {
-                    core::ptr::copy_nonoverlapping(
-                        data.as_ptr(),
-                        self.buf.add(self.count()),
-                        data.len(),
-                    );
-                }
-                self.cur += data.len();
-                Ok(FillResult::Done(data.len()))
-            }
-        }
-    }
-}
-
-impl Buffer for RawBuffer<'_> {
-    fn total(&self) -> usize {
-        RawBuffer::total(self)
-    }
-
-    fn wrote(&self) -> usize {
-        self.count()
-    }
-
-    fn fill(&mut self, data: &[u8]) -> KResult<FillResult> {
-        RawBuffer::fill(self, data)
-    }
-}
-
 pub struct ByteBuffer<'lt> {
     buf: &'lt mut [u8],
     cur: usize,
@@ -220,6 +148,20 @@ impl<'lt> ByteBuffer<'lt> {
     }
 }
 
+impl<'lt, T: Copy + Sized> From<&'lt mut [T]> for ByteBuffer<'lt> {
+    fn from(value: &'lt mut [T]) -> Self {
+        Self {
+            buf: unsafe {
+                core::slice::from_raw_parts_mut(
+                    value.as_ptr() as *mut u8,
+                    core::mem::size_of::<T>() * value.len(),
+                )
+            },
+            cur: 0,
+        }
+    }
+}
+
 impl Buffer for ByteBuffer<'_> {
     fn total(&self) -> usize {
         self.buf.len()
@@ -227,7 +169,7 @@ impl Buffer for ByteBuffer<'_> {
 
     fn fill(&mut self, data: &[u8]) -> KResult<FillResult> {
         match self.available() {
-            n if n == 0 => Ok(FillResult::Full),
+            0 => Ok(FillResult::Full),
             n if n < data.len() => {
                 self.buf[self.cur..].copy_from_slice(&data[..n]);
                 self.cur += n;

src/kernel/block.rs

@@ -13,10 +13,7 @@ use bindings::{EEXIST, EINVAL, EIO, ENOENT};
 
 use lazy_static::lazy_static;
 
-use super::{
-    mem::{paging::Page, phys::PhysPtr},
-    vfs::DevId,
-};
+use super::{mem::paging::Page, vfs::DevId};
 
 pub fn make_device(major: u32, minor: u32) -> DevId {
     (major << 8) & 0xff00u32 | minor & 0xffu32
@@ -262,17 +259,8 @@ impl BlockDevice {
             self.read_raw(req)?;
 
             for page in pages.iter() {
-                let data = if first_sector_offset != 0 {
-                    let ret = page
-                        .as_cached()
-                        .as_slice(page.len())
-                        .split_at(first_sector_offset as usize)
-                        .1;
-                    first_sector_offset = 0;
-                    ret
-                } else {
-                    page.as_cached().as_slice(page.len())
-                };
+                let data = &page.as_slice()[first_sector_offset as usize..];
+                first_sector_offset = 0;
 
                 match buffer.fill(data)? {
                     FillResult::Done(n) => nfilled += n,

src/kernel/mem/mm_list/page_fault.rs

@@ -3,7 +3,6 @@ use bindings::{PA_A, PA_ANON, PA_COW, PA_MMAP, PA_P, PA_RW};
 use bitflags::bitflags;
 
 use crate::kernel::mem::paging::{Page, PageBuffer};
-use crate::kernel::mem::phys::{CachedPP, PhysPtr};
 use crate::kernel::mem::{Mapping, VRange};
 use crate::kernel::task::{ProcessList, Signal, Thread};
 use crate::prelude::*;
@@ -99,10 +98,7 @@ impl MMList {
             if attributes & PA_ANON as usize != 0 {
                 new_page.zero();
             } else {
-                new_page
-                    .as_cached()
-                    .as_mut_slice::<u8>(0x1000)
-                    .copy_from_slice(CachedPP::new(pfn).as_slice(0x1000));
+                new_page.as_mut_slice().copy_from_slice(page.as_slice());
             }
 
             attributes &= !(PA_A | PA_ANON) as usize;
@@ -129,12 +125,12 @@ impl MMList {
                         .map_err(|_| Signal::SIGBUS)?;
 
                     if nread < page.len() {
-                        page.as_cached().as_mut_slice::<u8>(0x1000)[nread..].fill(0);
+                        page.as_mut_slice()[nread..].fill(0);
                     }
 
                     if mapping.length - load_offset < 0x1000 {
                         let length_to_end = mapping.length - load_offset;
-                        page.as_cached().as_mut_slice::<u8>(0x1000)[length_to_end..].fill(0);
+                        page.as_mut_slice()[length_to_end..].fill(0);
                     }
                 }
                 // Otherwise, the page is kept zero emptied.

src/kernel/mem/paging.rs

@@ -1,7 +1,6 @@
 use super::address::PFN;
 use super::page_alloc::{alloc_page, alloc_pages, free_pages, PagePtr};
 use super::phys::PhysPtr;
-use crate::bindings::root::EFAULT;
 use crate::io::{Buffer, FillResult};
 use crate::kernel::mem::phys;
 use core::fmt;
@@ -81,12 +80,16 @@ impl Page {
         phys::NoCachePP::new(self.as_phys())
     }
 
-    pub fn zero(&self) {
-        use phys::PhysPtr;
+    pub fn as_slice<'r, 'lt>(&'r self) -> &'lt [u8] {
+        self.as_cached().as_slice(self.len())
+    }
 
-        unsafe {
-            core::ptr::write_bytes(self.as_cached().as_ptr::<u8>(), 0, self.len());
-        }
+    pub fn as_mut_slice<'r, 'lt>(&'r self) -> &'lt mut [u8] {
+        self.as_cached().as_mut_slice(self.len())
+    }
+
+    pub fn zero(&self) {
+        self.as_mut_slice().fill(0);
     }
 
     /// # Safety
@@ -160,16 +163,11 @@ impl PageBuffer {
     }
 
     pub fn as_slice(&self) -> &[u8] {
-        unsafe { core::slice::from_raw_parts(self.page.as_cached().as_ptr::<u8>(), self.offset) }
+        self.page.as_slice()
     }
 
     fn available_as_slice(&self) -> &mut [u8] {
-        unsafe {
-            core::slice::from_raw_parts_mut(
-                self.page.as_cached().as_ptr::<u8>().add(self.offset),
-                self.remaining(),
-            )
-        }
+        &mut self.page.as_mut_slice()[self.offset..]
     }
 }
 
@@ -198,24 +196,3 @@ impl Buffer for PageBuffer {
         }
     }
 }
-
-/// Copy data from a slice to a `Page`
-///
-/// DONT USE THIS FUNCTION TO COPY DATA TO MMIO ADDRESSES
-///
-/// # Returns
-///
-/// Returns `Err(EFAULT)` if the slice is larger than the page
-/// Returns `Ok(())` otherwise
-pub fn copy_to_page(src: &[u8], dst: &Page) -> Result<(), u32> {
-    use phys::PhysPtr;
-    if src.len() > dst.len() {
-        return Err(EFAULT);
-    }
-
-    unsafe {
-        core::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_cached().as_ptr(), src.len());
-    }
-
-    Ok(())
-}

src/kernel/syscall/procops.rs

@@ -6,8 +6,9 @@ use bitflags::bitflags;
 
 use crate::elf::ParsedElf32;
 use crate::io::Buffer;
-use crate::kernel::constants::{ENOSYS, PR_GET_NAME, PR_SET_NAME, SIG_BLOCK, SIG_SETMASK, SIG_UNBLOCK};
-use crate::kernel::mem::phys::PhysPtr;
+use crate::kernel::constants::{
+    ENOSYS, PR_GET_NAME, PR_SET_NAME, SIG_BLOCK, SIG_SETMASK, SIG_UNBLOCK,
+};
 use crate::kernel::mem::{Page, PageBuffer, VAddr};
 use crate::kernel::task::{
     ProcessList, Scheduler, Signal, SignalAction, Thread, UserDescriptor, WaitObject, WaitType,
@@ -39,9 +40,7 @@ fn do_getcwd(buffer: *mut u8, bufsize: usize) -> KResult<usize> {
     let page = Page::alloc_one();
     let mut buffer = PageBuffer::new(page.clone());
     context.cwd.lock().get_path(&context, &mut buffer)?;
-    user_buffer
-        .fill(page.as_cached().as_slice(page.len()))?
-        .ok_or(ERANGE)?;
+    user_buffer.fill(page.as_slice())?.ok_or(ERANGE)?;
 
     Ok(buffer.wrote())
 }

src/kernel/vfs/file.rs

@@ -1,10 +1,10 @@
 use core::{ops::ControlFlow, sync::atomic::Ordering};
 
 use crate::{
-    io::{Buffer, BufferFill, RawBuffer},
+    io::{Buffer, BufferFill, ByteBuffer},
     kernel::{
         constants::{TCGETS, TCSETS, TIOCGPGRP, TIOCGWINSZ, TIOCSPGRP},
-        mem::{paging::Page, phys::PhysPtr},
+        mem::paging::Page,
         task::{Signal, Thread},
         terminal::{Terminal, TerminalIORequest},
         user::{UserPointer, UserPointerMut},
@@ -518,8 +518,8 @@ impl File {
             }
 
             let batch_size = usize::min(count - tot, buffer_page.len());
-            let slice = buffer_page.as_cached().as_mut_slice::<u8>(batch_size);
-            let mut buffer = RawBuffer::new_from_slice(slice);
+            let slice = &mut buffer_page.as_mut_slice()[..batch_size];
+            let mut buffer = ByteBuffer::new(slice);
 
             let nwrote = self.read(&mut buffer)?;