foyer-rs · MrCroxx · Mar 26, 2025 · Mar 26, 2025
diff --git a/foyer-storage/src/device/direct_file.rs b/foyer-storage/src/device/direct_file.rs
@@ -75,7 +75,7 @@
 }
 
 impl DirectFileDevice {
-    fn assert_io_range(&self, region: Option<RegionId>, offset: u64, len: usize) {
+    fn check_io_range(&self, region: Option<RegionId>, offset: u64, len: usize) -> Result<()> {
         let offset = if let Some(region) = region {
             self.region_size as u64 * region as u64 + offset
         } else {
@@ -86,24 +86,29 @@
         bits::assert_aligned(PAGE, offset as _);
         bits::assert_aligned(PAGE, len);
 
+        let e = Error::InvalidIoRange {
+            range: offset as usize..offset as usize + len,
+            region_size: self.region_size(),
+            capacity: self.capacity(),
+        };
+
         // Assert file capacity bound.
-        assert!(
-            offset as usize + len <= self.capacity(),
-            "offset ({offset}) + len ({len}) = total ({total}) <= capacity ({capacity})",
-            total = offset as usize + len,
-            capacity = self.capacity,
-        );
+        if offset as usize + len > self.capacity() {
+            tracing::error!(?e, "[direct fs]: io range out of capacity");
+            return Err(e);
+        }
 
         // Assert region capacity bound if region is given.
         if region.is_some() && len != 0 {
             let start_region = offset as usize / self.region_size;
             let end_region = (offset as usize + len - 1) / self.region_size;
-            assert_eq!(
-                start_region, end_region,
-                "io range are not in the same region, region_size: {region_size}, offset: {offset}, len: {len}, start region: {start_region}, end region: {end_region}",
-                region_size = self.region_size,
-            );
+            if start_region != end_region {
+                tracing::error!(?e, "[direct fs]: io range not in the same region");
+                return Err(e);
+            }
         }
+
+        Ok(())
     }
 
     /// Positioned write API for the direct file device.
@@ -117,7 +122,9 @@
         B: IoBuf,
     {
         let len = buf.len();
-        self.assert_io_range(None, offset, len);
+        if let Err(e) = self.check_io_range(None, offset, len) {
+            return (buf, Err(e));
+        }
 
         let file = self.file.clone();
         asyncify_with_runtime(self.runtime.write(), move || {
@@ -159,7 +166,9 @@
         B: IoBufMut,
     {
         let len = buf.len();
-        self.assert_io_range(None, offset, len);
+        if let Err(e) = self.check_io_range(None, offset, len) {
+            return (buf, Err(e));
+        }
 
         let file = self.file.clone();
         asyncify_with_runtime(self.runtime.read(), move || {
@@ -253,7 +262,9 @@
         B: IoBuf,
     {
         let len = buf.len();
-        self.assert_io_range(Some(region), offset, len);
+        if let Err(e) = self.check_io_range(Some(region), offset, len) {
+            return (buf, Err(e));
+        }
 
         let poffset = offset + region as u64 * self.region_size as u64;
         self.pwrite(buf, poffset).await
@@ -265,7 +276,9 @@
         B: IoBufMut,
     {
         let len = buf.len();
-        self.assert_io_range(Some(region), offset, len);
+        if let Err(e) = self.check_io_range(Some(region), offset, len) {
+            return (buf, Err(e));
+        }
 
         let poffset = offset + region as u64 * self.region_size as u64;
         self.pread(buf, poffset).await

diff --git a/foyer-storage/src/device/direct_fs.rs b/foyer-storage/src/device/direct_fs.rs
@@ -88,31 +88,36 @@
         &self.inner.files[region as usize]
     }
 
-    fn assert_io_range(&self, region: RegionId, offset: u64, len: usize) {
+    fn check_io_range(&self, region: RegionId, offset: u64, len: usize) -> Result<()> {
         let offset = self.inner.file_size as u64 * region as u64 + offset;
 
         // Assert alignment.
         bits::assert_aligned(PAGE, offset as _);
         bits::assert_aligned(PAGE, len);
 
+        let e = Error::InvalidIoRange {
+            range: offset as usize..offset as usize + len,
+            region_size: self.region_size(),
+            capacity: self.capacity(),
+        };
+
         // Assert file capacity bound.
-        assert!(
-            offset as usize + len <= self.capacity(),
-            "offset ({offset}) + len ({len}) = total ({total}) <= capacity ({capacity})",
-            total = offset as usize + len,
-            capacity = self.inner.capacity,
-        );
+        if offset as usize + len > self.capacity() {
+            tracing::error!(?e, "[direct fs]: io range out of capacity");
+            return Err(e);
+        }
 
         // Assert region capacity bound if region is given.
         if len != 0 {
             let start_region = offset as usize / self.inner.file_size;
             let end_region = (offset as usize + len - 1) / self.inner.file_size;
-            assert_eq!(
-                start_region, end_region,
-                "io range are not in the same region, region_size: {region_size}, offset: {offset}, len: {len}, start region: {start_region}, end region: {end_region}",
-                region_size = self.inner.file_size,
-            );
+            if start_region != end_region {
+                tracing::error!(?e, "[direct fs]: io range not in the same region");
+                return Err(e);
+            }
         }
+
+        Ok(())
     }
 }
 
@@ -177,7 +182,9 @@
         B: IoBuf,
     {
         let len = buf.len();
-        self.assert_io_range(region, offset, len);
+        if let Err(e) = self.check_io_range(region, offset, len) {
+            return (buf, Err(e));
+        }
 
         let file = self.file(region).clone();
         asyncify_with_runtime(self.inner.runtime.write(), move || {
@@ -214,7 +221,9 @@
         B: IoBufMut,
     {
         let len = buf.len();
-        self.assert_io_range(region, offset, len);
+        if let Err(e) = self.check_io_range(region, offset, len) {
+            return (buf, Err(e));
+        }
 
         let file = self.file(region).clone();
         asyncify_with_runtime(self.inner.runtime.read(), move || {

diff --git a/foyer-storage/src/error.rs b/foyer-storage/src/error.rs
@@ -56,6 +56,16 @@ pub enum Error {
         /// Gotten range.
         get: Range<usize>,
     },
+    /// Invalid I/O range.
+    #[error("invalid io range: {range:?}, region size: {region_size}, capacity: {capacity}")]
+    InvalidIoRange {
+        /// I/O range
+        range: Range<usize>,
+        /// Region size
+        region_size: usize,
+        /// Capacity
+        capacity: usize,
+    },
     /// Compression algorithm not supported.
     #[error("compression algorithm not supported: {0}")]
     CompressionAlgorithmNotSupported(u8),

diff --git a/foyer-storage/src/large/generic.rs b/foyer-storage/src/large/generic.rs
@@ -353,7 +353,21 @@
 
             let buf = IoBuffer::new(bits::align_up(PAGE, addr.len as _));
             let (buf, res) = device.read(buf, addr.region, addr.offset as _).await;
-            res?;
+            match res {
+                Ok(_) => {}
+                Err(e @ Error::InvalidIoRange { .. }) => {
+                    tracing::warn!(?e, "[lodc load]: invalid io range, remove this entry and skip");
+                    indexer.remove(hash);
+                    metrics.storage_miss.increase(1);
+                    metrics.storage_miss_duration.record(now.elapsed().as_secs_f64());
+                    return Ok(None);
+                }
+                Err(e) => {
+                    tracing::error!(hash, ?addr, ?e, "[lodc load]: load error");
+                    metrics.storage_error.increase(1);
+                    return Err(e);
+                }
+            }
 
             stats
                 .cache_read_bytes
@@ -364,8 +378,9 @@
                 Err(e @ Error::MagicMismatch { .. })
                 | Err(e @ Error::ChecksumMismatch { .. })
                 | Err(e @ Error::CompressionAlgorithmNotSupported(_))
-                | Err(e @ Error::OutOfRange { .. }) => {
-                    tracing::trace!(
+                | Err(e @ Error::OutOfRange { .. })
+                | Err(e @ Error::InvalidIoRange { .. }) => {
+                    tracing::warn!(
                         hash,
                         ?addr,
                         ?e,
@@ -376,7 +391,11 @@
                     metrics.storage_miss_duration.record(now.elapsed().as_secs_f64());
                     return Ok(None);
                 }
-                Err(e) => return Err(e),
+                Err(e) => {
+                    tracing::error!(hash, ?addr, ?e, "[lodc load]: load error");
+                    metrics.storage_error.increase(1);
+                    return Err(e);
+                }
             };
 
             let (k, v) = {
@@ -391,8 +410,9 @@
                     Ok(res) => res,
                     Err(e @ Error::MagicMismatch { .. })
                     | Err(e @ Error::ChecksumMismatch { .. })
-                    | Err(e @ Error::OutOfRange { .. }) => {
-                        tracing::trace!(
+                    | Err(e @ Error::OutOfRange { .. })
+                    | Err(e @ Error::InvalidIoRange { .. }) => {
+                        tracing::warn!(
                             hash,
                             ?addr,
                             ?header,