Merge pull request #158 from Luv-Ray/fix-align

fix alignment of cache

Author: wyfcyx

easy-fs/src/block_cache.rs

@@ -1,13 +1,55 @@
+use core::alloc::Layout;
+use core::mem::ManuallyDrop;
+use core::ptr::{addr_of, addr_of_mut};
+use core::slice;
+
 use super::{BlockDevice, BLOCK_SZ};
+use alloc::boxed::Box;
 use alloc::collections::VecDeque;
 use alloc::sync::Arc;
-use alloc::vec;
-use alloc::vec::Vec;
 use lazy_static::*;
 use spin::Mutex;
 
+/// Use `ManuallyDrop` to ensure data is deallocated with an alignment of `BLOCK_SZ`
+struct CacheData(ManuallyDrop<Box<[u8; BLOCK_SZ]>>);
+
+impl CacheData {
+    pub fn new() -> Self {
+        let data = unsafe {
+            let raw = alloc::alloc::alloc(Self::layout());
+            Box::from_raw(raw as *mut [u8; BLOCK_SZ])
+        };
+        Self(ManuallyDrop::new(data))
+    }
+
+    fn layout() -> Layout {
+        Layout::from_size_align(BLOCK_SZ, BLOCK_SZ).unwrap()
+    }
+}
+
+impl Drop for CacheData {
+    fn drop(&mut self) {
+        let ptr = self.0.as_mut_ptr();
+        unsafe { alloc::alloc::dealloc(ptr, Self::layout()) };
+    }
+}
+
+impl AsRef<[u8]> for CacheData {
+    fn as_ref(&self) -> &[u8] {
+        let ptr = self.0.as_ptr() as *const u8;
+        unsafe { slice::from_raw_parts(ptr, BLOCK_SZ) }
+    }
+}
+
+impl AsMut<[u8]> for CacheData {
+    fn as_mut(&mut self) -> &mut [u8] {
+        let ptr = self.0.as_mut_ptr() as *mut u8;
+        unsafe { slice::from_raw_parts_mut(ptr, BLOCK_SZ) }
+    }
+}
+
 pub struct BlockCache {
-    cache: Vec<u8>,
+    cache: CacheData,
     block_id: usize,
     block_device: Arc<dyn BlockDevice>,
     modified: bool,
@@ -17,8 +59,8 @@ impl BlockCache {
     /// Load a new BlockCache from disk.
     pub fn new(block_id: usize, block_device: Arc<dyn BlockDevice>) -> Self {
         // for alignment and move effciency
-        let mut cache = vec![0u8; BLOCK_SZ];
-        block_device.read_block(block_id, &mut cache);
+        let mut cache = CacheData::new();
+        block_device.read_block(block_id, cache.as_mut());
         Self {
             cache,
             block_id,
@@ -27,8 +69,12 @@ impl BlockCache {
         }
     }
 
-    fn addr_of_offset(&self, offset: usize) -> usize {
-        &self.cache[offset] as *const _ as usize
+    fn addr_of_offset(&self, offset: usize) -> *const u8 {
+        addr_of!(self.cache.as_ref()[offset])
+    }
+
+    fn addr_of_offset_mut(&mut self, offset: usize) -> *mut u8 {
+        addr_of_mut!(self.cache.as_mut()[offset])
     }
 
     pub fn get_ref<T>(&self, offset: usize) -> &T
@@ -37,8 +83,8 @@ impl BlockCache {
     {
         let type_size = core::mem::size_of::<T>();
         assert!(offset + type_size <= BLOCK_SZ);
-        let addr = self.addr_of_offset(offset);
-        unsafe { &*(addr as *const T) }
+        let addr = self.addr_of_offset(offset) as *const T;
+        unsafe { &*addr }
     }
 
     pub fn get_mut<T>(&mut self, offset: usize) -> &mut T
@@ -48,8 +94,8 @@ impl BlockCache {
         let type_size = core::mem::size_of::<T>();
         assert!(offset + type_size <= BLOCK_SZ);
         self.modified = true;
-        let addr = self.addr_of_offset(offset);
-        unsafe { &mut *(addr as *mut T) }
+        let addr = self.addr_of_offset_mut(offset) as *mut T;
+        unsafe { &mut *addr }
     }
 
     pub fn read<T, V>(&self, offset: usize, f: impl FnOnce(&T) -> V) -> V {
@@ -63,7 +109,8 @@ impl BlockCache {
     pub fn sync(&mut self) {
         if self.modified {
             self.modified = false;
-            self.block_device.write_block(self.block_id, &self.cache);
+            self.block_device
+                .write_block(self.block_id, self.cache.as_ref());
         }
     }
 }