fix alignment

--------

Cherry-picked from #158.

Author: Luv-Ray

easy-fs/src/block_cache.rs

@@ -3,11 +3,39 @@ use alloc::collections::VecDeque;
 use alloc::sync::Arc;
 use alloc::vec;
 use alloc::vec::Vec;
+use core::ptr::{addr_of, addr_of_mut};
+use core::slice;
 use lazy_static::*;
 use spin::Mutex;
 
+/// use `Vec<u64>` to ensure the alignment of addr is `8`
+struct CacheData(Vec<u64>);
+
+impl CacheData {
+    fn new() -> Self {
+        Self(vec![0u64; BLOCK_SZ / 8])
+    }
+}
+
+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) }
+    }
+}
+
+/// Cached block inside memory
 pub struct BlockCache {
-    cache: Vec<u8>,
+    /// cached block data
+    cache: CacheData,
+    /// underlying block id
     block_id: usize,
     block_device: Arc<dyn BlockDevice>,
     modified: bool,
@@ -17,18 +45,22 @@ 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,
             block_device,
             modified: false,
         }
     }
+    /// Get the address of an offset inside the cached block data
+    fn addr_of_offset(&self, offset: usize) -> *const u8 {
+        addr_of!(self.cache.as_ref()[offset])
+    }
 
-    fn addr_of_offset(&self, offset: usize) -> usize {
-        &self.cache[offset] as *const _ as usize
+    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 +69,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 +80,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 +95,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());
         }
     }
 }