diff --git a/fs/erofs/rust/erofs_sys/map.rs b/fs/erofs/rust/erofs_sys/map.rs
index 757e8083c8f1..f56f31cefcd5 100644
--- a/fs/erofs/rust/erofs_sys/map.rs
+++ b/fs/erofs/rust/erofs_sys/map.rs
@@ -1,7 +1,10 @@
 // Copyright 2024 Yiyang Wu
 // SPDX-License-Identifier: MIT or GPL-2.0-or-later
 
+use super::inode::*;
+use super::superblock::*;
 use super::*;
+
 pub(crate) const MAP_MAPPED: u32 = 0x0001;
 pub(crate) const MAP_META: u32 = 0x0002;
 pub(crate) const MAP_ENCODED: u32 = 0x0004;
@@ -43,3 +46,54 @@ fn from(value: MapType) -> Self {
 }
 
 pub(crate) type MapResult = PosixResult<Map>;
+
+/// Iterates over the data map represented by an inode.
+pub(crate) struct MapIter<'a, 'b, FS, I>
+where
+    FS: FileSystem<I>,
+    I: Inode,
+{
+    fs: &'a FS,
+    inode: &'b I,
+    offset: Off,
+    len: Off,
+}
+
+impl<'a, 'b, FS, I> MapIter<'a, 'b, FS, I>
+where
+    FS: FileSystem<I>,
+    I: Inode,
+{
+    pub(crate) fn new(fs: &'a FS, inode: &'b I, offset: Off) -> Self {
+        Self {
+            fs,
+            inode,
+            offset,
+            len: inode.info().file_size(),
+        }
+    }
+}
+
+impl<'a, 'b, FS, I> Iterator for MapIter<'a, 'b, FS, I>
+where
+    FS: FileSystem<I>,
+    I: Inode,
+{
+    type Item = MapResult;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.offset >= self.len {
+            None
+        } else {
+            let result = self.fs.map(self.inode, self.offset);
+            match result {
+                Ok(m) => {
+                    let accessor = self.fs.superblock().blk_access(m.physical.start);
+                    let len = m.physical.len.min(accessor.len);
+                    self.offset += len;
+                    Some(Ok(m))
+                }
+                Err(e) => Some(Err(e)),
+            }
+        }
+    }
+}
diff --git a/fs/erofs/rust/erofs_sys/superblock.rs b/fs/erofs/rust/erofs_sys/superblock.rs
index 940ab0b03a26..fc6b3cb00b18 100644
--- a/fs/erofs/rust/erofs_sys/superblock.rs
+++ b/fs/erofs/rust/erofs_sys/superblock.rs
@@ -8,8 +8,11 @@
 use super::data::*;
 use super::devices::*;
 use super::inode::*;
+use super::map::*;
 use super::*;
 
+use crate::round;
+
 /// The ondisk superblock structure.
 #[derive(Debug, Clone, Copy, Default)]
 #[repr(C)]
@@ -135,6 +138,10 @@ pub(crate) fn blk_round_up(&self, addr: Off) -> Blk {
     pub(crate) fn iloc(&self, nid: Nid) -> Off {
         self.blkpos(self.meta_blkaddr) + ((nid as Off) << (5 as Off))
     }
+    pub(crate) fn chunk_access(&self, format: ChunkFormat, address: Off) -> Accessor {
+        let chunkbits = format.chunkbits() + self.blkszbits as u16;
+        Accessor::new(address, chunkbits as Off)
+    }
 }
 
 pub(crate) trait FileSystem<I>
@@ -145,6 +152,128 @@ pub(crate) trait FileSystem<I>
     fn backend(&self) -> &dyn Backend;
     fn as_filesystem(&self) -> &dyn FileSystem<I>;
     fn device_info(&self) -> &DeviceInfo;
+    fn flatmap(&self, inode: &I, offset: Off, inline: bool) -> MapResult {
+        let sb = self.superblock();
+        let nblocks = sb.blk_round_up(inode.info().file_size());
+        let blkaddr = match inode.info().spec() {
+            Spec::RawBlk(blkaddr) => Ok(blkaddr),
+            _ => Err(EUCLEAN),
+        }?;
+
+        let lastblk = if inline { nblocks - 1 } else { nblocks };
+        if offset < sb.blkpos(lastblk) {
+            let len = inode.info().file_size().min(sb.blkpos(lastblk)) - offset;
+            Ok(Map {
+                logical: Segment { start: offset, len },
+                physical: Segment {
+                    start: sb.blkpos(blkaddr) + offset,
+                    len,
+                },
+                algorithm_format: 0,
+                device_id: 0,
+                map_type: MapType::Normal,
+            })
+        } else if inline {
+            let len = inode.info().file_size() - offset;
+            let accessor = sb.blk_access(offset);
+            Ok(Map {
+                logical: Segment { start: offset, len },
+                physical: Segment {
+                    start: sb.iloc(inode.nid())
+                        + inode.info().inode_size()
+                        + inode.info().xattr_size()
+                        + accessor.off,
+                    len,
+                },
+                algorithm_format: 0,
+                device_id: 0,
+                map_type: MapType::Meta,
+            })
+        } else {
+            Err(EUCLEAN)
+        }
+    }
+
+    fn chunk_map(&self, inode: &I, offset: Off) -> MapResult {
+        let sb = self.superblock();
+        let chunkformat = match inode.info().spec() {
+            Spec::Chunk(chunkformat) => Ok(chunkformat),
+            _ => Err(EUCLEAN),
+        }?;
+        let accessor = sb.chunk_access(chunkformat, offset);
+
+        if chunkformat.is_chunkindex() {
+            let unit = size_of::<ChunkIndex>() as Off;
+            let pos = round!(
+                UP,
+                self.superblock().iloc(inode.nid())
+                    + inode.info().inode_size()
+                    + inode.info().xattr_size()
+                    + unit * accessor.nr,
+                unit
+            );
+            let mut buf = [0u8; size_of::<ChunkIndex>()];
+            self.backend().fill(&mut buf, pos)?;
+            let chunk_index = ChunkIndex::from(buf);
+            if chunk_index.blkaddr == u32::MAX {
+                Err(EUCLEAN)
+            } else {
+                Ok(Map {
+                    logical: Segment {
+                        start: accessor.base + accessor.off,
+                        len: accessor.len,
+                    },
+                    physical: Segment {
+                        start: sb.blkpos(chunk_index.blkaddr) + accessor.off,
+                        len: accessor.len,
+                    },
+                    algorithm_format: 0,
+                    device_id: chunk_index.device_id & self.device_info().mask,
+                    map_type: MapType::Normal,
+                })
+            }
+        } else {
+            let unit = 4;
+            let pos = round!(
+                UP,
+                sb.iloc(inode.nid())
+                    + inode.info().inode_size()
+                    + inode.info().xattr_size()
+                    + unit * accessor.nr,
+                unit
+            );
+            let mut buf = [0u8; 4];
+            self.backend().fill(&mut buf, pos)?;
+            let blkaddr = u32::from_le_bytes(buf);
+            let len = accessor.len.min(inode.info().file_size() - offset);
+            if blkaddr == u32::MAX {
+                Err(EUCLEAN)
+            } else {
+                Ok(Map {
+                    logical: Segment {
+                        start: accessor.base + accessor.off,
+                        len,
+                    },
+                    physical: Segment {
+                        start: sb.blkpos(blkaddr) + accessor.off,
+                        len,
+                    },
+                    algorithm_format: 0,
+                    device_id: 0,
+                    map_type: MapType::Normal,
+                })
+            }
+        }
+    }
+
+    fn map(&self, inode: &I, offset: Off) -> MapResult {
+        match inode.info().format().layout() {
+            Layout::FlatInline => self.flatmap(inode, offset, true),
+            Layout::FlatPlain => self.flatmap(inode, offset, false),
+            Layout::Chunk => self.chunk_map(inode, offset),
+            _ => todo!(),
+        }
+    }
 }
 
 pub(crate) struct SuperblockInfo<I, C, T>
