Unwrap some unreachable errors

kernel/src/vm/vmar/mod.rs

@@ -270,7 +270,7 @@ impl VmarInner {
             let vm_mapping_range = vm_mapping.range();
             let intersected_range = get_intersected_range(&range, &vm_mapping_range);
 
-            let (left, taken, right) = vm_mapping.split_range(&intersected_range)?;
+            let (left, taken, right) = vm_mapping.split_range(&intersected_range);
             if let Some(left) = left {
                 self.insert(left);
             }
@@ -278,7 +278,7 @@ impl VmarInner {
                 self.insert(right);
             }
 
-            rss_delta.add(taken.rss_type(), -(taken.unmap(vm_space)? as isize));
+            rss_delta.add(taken.rss_type(), -(taken.unmap(vm_space) as isize));
         }
 
         Ok(offset..(offset + size))
@@ -460,7 +460,7 @@ impl Vmar_ {
             let intersected_range = get_intersected_range(&range, &vm_mapping_range);
 
             // Protects part of the taken `VmMapping`.
-            let (left, taken, right) = vm_mapping.split_range(&intersected_range)?;
+            let (left, taken, right) = vm_mapping.split_range(&intersected_range);
 
             let taken = taken.protect(vm_space.as_ref(), perms);
             inner.insert(taken);
@@ -551,6 +551,10 @@ impl Vmar_ {
         new_addr: Option<Vaddr>,
         new_size: usize,
     ) -> Result<Vaddr> {
+        debug_assert_eq!(old_addr % PAGE_SIZE, 0);
+        debug_assert_eq!(old_size % PAGE_SIZE, 0);
+        debug_assert_eq!(new_size % PAGE_SIZE, 0);
+
         let mut inner = self.inner.write();
         let old_mapping_addr = inner.check_lies_in_single_mapping(old_addr, old_size)?;
 
@@ -586,7 +590,7 @@ impl Vmar_ {
         // Create a new `VmMapping`.
         let old_mapping = {
             let vm_mapping = inner.remove(&old_mapping_addr).unwrap();
-            let (left, old_mapping, right) = vm_mapping.split_range(&old_range)?;
+            let (left, old_mapping, right) = vm_mapping.split_range(&old_range);
             if let Some(left) = left {
                 inner.insert(left);
             }
@@ -594,8 +598,8 @@ impl Vmar_ {
                 inner.insert(right);
             }
             if new_size < old_size {
-                let (old_mapping, taken) = old_mapping.split(old_range.start + new_size)?;
+                let (old_mapping, taken) = old_mapping.split(old_range.start + new_size).unwrap();
-                rss_delta.add(taken.rss_type(), -(taken.unmap(&self.vm_space)? as isize));
+                rss_delta.add(taken.rss_type(), -(taken.unmap(&self.vm_space) as isize));
                 old_size = new_size;
                 old_range = old_range.start..(old_range.start + old_size);
                 old_mapping
@@ -604,7 +608,7 @@ impl Vmar_ {
             }
         };
         // Now we can ensure that `new_size >= old_size`.
-        let new_mapping = old_mapping.clone_for_remap_at(new_range.start)?;
+        let new_mapping = old_mapping.clone_for_remap_at(new_range.start).unwrap();
         inner.insert(new_mapping.enlarge(new_size - old_size));
 
         // Move the mapping.

kernel/src/vm/vmar/vm_mapping.rs

@@ -444,27 +444,28 @@ impl VmMapping {
     ///
     /// Panics if the mapping does not contain the range, or if the start or
     /// end of the range is not page-aligned.
-    pub fn split_range(self, range: &Range<Vaddr>) -> Result<(Option<Self>, Self, Option<Self>)> {
+    pub fn split_range(self, range: &Range<Vaddr>) -> (Option<Self>, Self, Option<Self>) {
         let mapping_range = self.range();
         if range.start <= mapping_range.start && mapping_range.end <= range.end {
             // Condition 4.
-            return Ok((None, self, None));
+            (None, self, None)
         } else if mapping_range.start < range.start {
             let (left, within) = self.split(range.start).unwrap();
             if range.end < mapping_range.end {
                 // Condition 3.
                 let (within, right) = within.split(range.end).unwrap();
-                return Ok((Some(left), within, Some(right)));
+                (Some(left), within, Some(right))
             } else {
                 // Condition 1.
-                return Ok((Some(left), within, None));
+                (Some(left), within, None)
             }
         } else if mapping_range.contains(&range.end) {
             // Condition 2.
             let (within, right) = self.split(range.end).unwrap();
-            return Ok((None, within, Some(right)));
+            (None, within, Some(right))
+        } else {
+            panic!("The mapping does not contain the splitting range");
         }
-        panic!("The mapping does not contain the splitting range.");
     }
 }
 
@@ -473,16 +474,16 @@ impl VmMapping {
 impl VmMapping {
     /// Unmaps the mapping from the VM space,
     /// and returns the number of unmapped pages.
-    pub(super) fn unmap(self, vm_space: &VmSpace) -> Result<usize> {
+    pub(super) fn unmap(self, vm_space: &VmSpace) -> usize {
         let preempt_guard = disable_preempt();
         let range = self.range();
-        let mut cursor = vm_space.cursor_mut(&preempt_guard, &range)?;
+        let mut cursor = vm_space.cursor_mut(&preempt_guard, &range).unwrap();
 
         let num_unmapped = cursor.unmap(range.len());
         cursor.flusher().dispatch_tlb_flush();
         cursor.flusher().sync_tlb_flush();
 
-        Ok(num_unmapped)
+        num_unmapped
     }
 
     /// Change the perms of the mapping.