diff --git a/kernel/src/process/program_loader/elf/load_elf.rs b/kernel/src/process/program_loader/elf/load_elf.rs
index 1001d020b..38e9caf4a 100644
--- a/kernel/src/process/program_loader/elf/load_elf.rs
+++ b/kernel/src/process/program_loader/elf/load_elf.rs
@@ -362,7 +362,6 @@ fn map_segment_vmo(
             .new_map(segment_size, perms)?
             .vmo(segment_vmo.dup()?)
             .vmo_offset(segment_offset)
-            .vmo_limit(segment_offset + segment_size)
             .can_overwrite(true);
         vm_map_options = vm_map_options.offset(offset).handle_page_faults_around();
         let map_addr = vm_map_options.build()?;
diff --git a/kernel/src/vm/vmar/mod.rs b/kernel/src/vm/vmar/mod.rs
index d438939ab..3177e3cf2 100644
--- a/kernel/src/vm/vmar/mod.rs
+++ b/kernel/src/vm/vmar/mod.rs
@@ -829,7 +829,6 @@ pub struct VmarMapOptions<'a, R1, R2> {
     inode: Option<Arc<dyn Inode>>,
     perms: VmPerms,
     vmo_offset: usize,
-    vmo_limit: usize,
     size: usize,
     offset: Option<usize>,
     align: usize,
@@ -854,7 +853,6 @@ impl<'a, R1, R2> VmarMapOptions<'a, R1, R2> {
             inode: None,
             perms,
             vmo_offset: 0,
-            vmo_limit: usize::MAX,
             size,
             offset: None,
             align: PAGE_SIZE,
@@ -904,12 +902,6 @@ impl<'a, R1, R2> VmarMapOptions<'a, R1, R2> {
         self
     }
 
-    /// Sets the access limit offset for the binding VMO.
-    pub fn vmo_limit(mut self, limit: usize) -> Self {
-        self.vmo_limit = limit;
-        self
-    }
-
     /// Sets the mapping's alignment.
     ///
     /// The default value is the page size.
@@ -1009,7 +1001,6 @@ where
             inode,
             perms,
             vmo_offset,
-            vmo_limit,
             size: map_size,
             offset,
             align,
@@ -1059,7 +1050,7 @@ where
         };
 
         // Build the mapping.
-        let vmo = vmo.map(|vmo| MappedVmo::new(vmo.to_dyn(), vmo_offset..vmo_limit));
+        let vmo = vmo.map(|vmo| MappedVmo::new(vmo.to_dyn(), vmo_offset));
         let vm_mapping = VmMapping::new(
             NonZeroUsize::new(map_size).unwrap(),
             map_to_addr,
diff --git a/kernel/src/vm/vmar/vm_mapping.rs b/kernel/src/vm/vmar/vm_mapping.rs
index f4192a43a..f267e28f5 100644
--- a/kernel/src/vm/vmar/vm_mapping.rs
+++ b/kernel/src/vm/vmar/vm_mapping.rs
@@ -433,13 +433,10 @@ impl VmMapping {
         let (mut l_vmo, mut r_vmo) = (None, None);
 
         if let Some(vmo) = self.vmo {
-            let at_offset = vmo.range.start + at - self.map_to_addr;
+            let at_offset = vmo.offset + (at - self.map_to_addr);
 
-            let l_range = vmo.range.start..at_offset;
-            let r_range = at_offset..vmo.range.end;
-
-            l_vmo = Some(MappedVmo::new(vmo.vmo.dup()?, l_range));
-            r_vmo = Some(MappedVmo::new(vmo.vmo.dup()?, r_range));
+            l_vmo = Some(vmo.dup()?);
+            r_vmo = Some(MappedVmo::new(vmo.vmo.dup()?, at_offset));
         }
 
         let left_size = at - self.map_to_addr;
@@ -578,14 +575,14 @@ impl VmMapping {
 #[derive(Debug)]
 pub(super) struct MappedVmo {
     vmo: Vmo,
-    /// Represents the accessible range in the VMO for mappings.
-    range: Range<usize>,
+    /// Represents the mapped offset in the VMO for the mapping.
+    offset: usize,
 }
 
 impl MappedVmo {
-    /// Creates a `MappedVmo` used for mapping.
-    pub(super) fn new(vmo: Vmo, range: Range<usize>) -> Self {
-        Self { vmo, range }
+    /// Creates a `MappedVmo` used for the mapping.
+    pub(super) fn new(vmo: Vmo, offset: usize) -> Self {
+        Self { vmo, offset }
     }
 
     /// Returns the **valid** size of the `MappedVmo`.
@@ -594,7 +591,7 @@ impl MappedVmo {
     /// that actually falls within the bounds of the underlying VMO.
     fn valid_size(&self) -> usize {
         let vmo_size = self.vmo.size();
-        (self.range.start..vmo_size).len()
+        (self.offset..vmo_size).len()
     }
 
     /// Gets the committed frame at the input offset in the mapped VMO.
@@ -606,9 +603,8 @@ impl MappedVmo {
         &self,
         page_offset: usize,
     ) -> core::result::Result<UFrame, VmoCommitError> {
-        debug_assert!(page_offset < self.range.len());
         debug_assert!(page_offset % PAGE_SIZE == 0);
-        self.vmo.try_commit_page(self.range.start + page_offset)
+        self.vmo.try_commit_page(self.offset + page_offset)
     }
 
     /// Commits a page at a specific page index.
@@ -616,7 +612,6 @@ impl MappedVmo {
     /// This method may involve I/O operations if the VMO needs to fecth
     /// a page from the underlying page cache.
     pub fn commit_on(&self, page_idx: usize, commit_flags: CommitFlags) -> Result<UFrame> {
-        debug_assert!(page_idx * PAGE_SIZE < self.range.len());
         self.vmo.commit_on(page_idx, commit_flags)
     }
 
@@ -636,11 +631,7 @@ impl MappedVmo {
             &mut dyn FnMut() -> core::result::Result<UFrame, VmoCommitError>,
         ) -> core::result::Result<(), VmoCommitError>,
     {
-        debug_assert!(range.start < self.range.len());
-        debug_assert!(range.end <= self.range.len());
-
-        let range = self.range.start + range.start..self.range.start + range.end;
-
+        let range = self.offset + range.start..self.offset + range.end;
         self.vmo.try_operate_on_range(&range, operate)
     }
 
@@ -648,7 +639,7 @@ impl MappedVmo {
     pub fn dup(&self) -> Result<Self> {
         Ok(Self {
             vmo: self.vmo.dup()?,
-            range: self.range.clone(),
+            offset: self.offset,
         })
     }
 }
@@ -673,14 +664,11 @@ fn try_merge(left: &VmMapping, right: &VmMapping) -> Option<VmMapping> {
     let vmo = match (&left.vmo, &right.vmo) {
         (None, None) => None,
         (Some(l_vmo), Some(r_vmo)) if Arc::ptr_eq(&l_vmo.vmo.0, &r_vmo.vmo.0) => {
-            let is_offset_contiguous = l_vmo.range.start.checked_add(left.map_size())
-                == Some(r_vmo.range.start)
-                && l_vmo.range.end - l_vmo.range.start >= left.map_size();
+            let is_offset_contiguous = l_vmo.offset + left.map_size() == r_vmo.offset;
             if !is_offset_contiguous {
                 return None;
             }
-            let range = l_vmo.range.start..l_vmo.range.end.max(r_vmo.range.end);
-            Some(MappedVmo::new(l_vmo.vmo.dup().ok()?, range))
+            Some(l_vmo.dup().ok()?)
         }
         _ => return None,
     };