diff --git a/src/mm/validate.rs b/src/mm/validate.rs
index cdb8d5746..8644c1d03 100644
--- a/src/mm/validate.rs
+++ b/src/mm/validate.rs
@@ -101,60 +101,60 @@ struct ValidBitmap {
 }
 
 impl ValidBitmap {
-    pub const fn new() -> Self {
+    const fn new() -> Self {
         ValidBitmap {
             region: MemoryRegion::from_addresses(PhysAddr::null(), PhysAddr::null()),
             bitmap: ptr::null_mut(),
         }
     }
 
-    pub fn set_region(&mut self, region: MemoryRegion<PhysAddr>) {
+    fn set_region(&mut self, region: MemoryRegion<PhysAddr>) {
         self.region = region;
     }
 
-    pub fn set_bitmap(&mut self, bitmap: *mut u64) {
+    fn set_bitmap(&mut self, bitmap: *mut u64) {
         self.bitmap = bitmap;
     }
 
-    pub fn check_addr(&self, paddr: PhysAddr) -> bool {
+    fn check_addr(&self, paddr: PhysAddr) -> bool {
         self.region.contains(paddr)
     }
 
-    pub fn bitmap_addr(&self) -> PhysAddr {
+    fn bitmap_addr(&self) -> PhysAddr {
         assert!(!self.bitmap.is_null());
         virt_to_phys(VirtAddr::from(self.bitmap))
     }
 
     #[inline(always)]
-    fn index(&self, paddr: PhysAddr) -> (isize, usize) {
+    fn index(&self, paddr: PhysAddr) -> (usize, usize) {
         let page_offset = (paddr - self.region.start()) / PAGE_SIZE;
-        let index: isize = (page_offset / 64).try_into().unwrap();
-        let bit: usize = page_offset % 64;
+        let index = page_offset / 64;
+        let bit = page_offset % 64;
 
         (index, bit)
     }
 
-    pub fn clear_all(&mut self) {
-        let (mut i, bit) = self.index(self.region.end());
-        if bit != 0 {
-            i += 1;
-        }
-        let index: usize = i.try_into().unwrap();
-
+    fn clear_all(&mut self) {
+        let len = self.bitmap_len();
         unsafe {
-            ptr::write_bytes(self.bitmap, 0, index);
+            ptr::write_bytes(self.bitmap, 0, len);
         }
     }
 
-    pub fn alloc_order(&self) -> usize {
+    fn alloc_order(&self) -> usize {
         bitmap_alloc_order(self.region)
     }
 
-    pub fn migrate(&mut self, new_bitmap: *mut u64) {
-        let (count, _) = self.index(self.region.end());
+    /// The number of u64's in the bitmap
+    fn bitmap_len(&self) -> usize {
+        let num_pages = self.region.len() / PAGE_SIZE;
+        num_pages.div_ceil(u64::BITS as usize)
+    }
 
+    fn migrate(&mut self, new_bitmap: *mut u64) {
+        let count = self.bitmap_len();
         unsafe {
-            ptr::copy_nonoverlapping(self.bitmap, new_bitmap, count as usize);
+            ptr::copy_nonoverlapping(self.bitmap, new_bitmap, count);
         }
         self.bitmap = new_bitmap;
     }
@@ -163,7 +163,7 @@ impl ValidBitmap {
         !self.bitmap.is_null()
     }
 
-    pub fn set_valid_4k(&mut self, paddr: PhysAddr) {
+    fn set_valid_4k(&mut self, paddr: PhysAddr) {
         if !self.initialized() {
             return;
         }
@@ -174,13 +174,13 @@ impl ValidBitmap {
         assert!(self.check_addr(paddr));
 
         unsafe {
-            let mut val: u64 = ptr::read(self.bitmap.offset(index));
+            let mut val: u64 = ptr::read(self.bitmap.add(index));
             val |= 1u64 << bit;
-            ptr::write(self.bitmap.offset(index), val);
+            ptr::write(self.bitmap.add(index), val);
         }
     }
 
-    pub fn clear_valid_4k(&mut self, paddr: PhysAddr) {
+    fn clear_valid_4k(&mut self, paddr: PhysAddr) {
         if !self.initialized() {
             return;
         }
@@ -191,9 +191,9 @@ impl ValidBitmap {
         assert!(self.check_addr(paddr));
 
         unsafe {
-            let mut val: u64 = ptr::read(self.bitmap.offset(index));
+            let mut val: u64 = ptr::read(self.bitmap.add(index));
             val &= !(1u64 << bit);
-            ptr::write(self.bitmap.offset(index), val);
+            ptr::write(self.bitmap.add(index), val);
         }
     }
 
@@ -202,7 +202,7 @@ impl ValidBitmap {
             return;
         }
 
-        const NR_INDEX: isize = (PAGE_SIZE_2M / (PAGE_SIZE * 64)) as isize;
+        const NR_INDEX: usize = PAGE_SIZE_2M / (PAGE_SIZE * 64);
         let (index, _) = self.index(paddr);
 
         assert!(paddr.is_aligned(PAGE_SIZE_2M));
@@ -210,23 +210,23 @@ impl ValidBitmap {
 
         for i in 0..NR_INDEX {
             unsafe {
-                ptr::write(self.bitmap.offset(index + i), val);
+                ptr::write(self.bitmap.add(index + i), val);
             }
         }
     }
 
-    pub fn set_valid_2m(&mut self, paddr: PhysAddr) {
+    fn set_valid_2m(&mut self, paddr: PhysAddr) {
         self.set_2m(paddr, !0u64);
     }
 
-    pub fn clear_valid_2m(&mut self, paddr: PhysAddr) {
+    fn clear_valid_2m(&mut self, paddr: PhysAddr) {
         self.set_2m(paddr, 0u64);
     }
 
-    fn modify_bitmap_word(&mut self, index: isize, mask: u64, new_val: u64) {
-        let val = unsafe { ptr::read(self.bitmap.offset(index)) };
+    fn modify_bitmap_word(&mut self, index: usize, mask: u64, new_val: u64) {
+        let val = unsafe { ptr::read(self.bitmap.add(index)) };
         let val = (val & !mask) | (new_val & mask);
-        unsafe { ptr::write(self.bitmap.offset(index), val) };
+        unsafe { ptr::write(self.bitmap.add(index), val) };
     }
 
     fn set_range(&mut self, paddr_begin: PhysAddr, paddr_end: PhysAddr, new_val: bool) {
@@ -246,7 +246,7 @@ impl ValidBitmap {
             self.modify_bitmap_word(index_head, mask_head, new_val);
 
             for index in (index_head + 1)..index_tail {
-                unsafe { ptr::write(self.bitmap.offset(index), new_val) };
+                unsafe { ptr::write(self.bitmap.add(index), new_val) };
             }
 
             if bit_tail_end != 0 {
@@ -260,15 +260,15 @@ impl ValidBitmap {
         }
     }
 
-    pub fn set_valid_range(&mut self, paddr_begin: PhysAddr, paddr_end: PhysAddr) {
+    fn set_valid_range(&mut self, paddr_begin: PhysAddr, paddr_end: PhysAddr) {
         self.set_range(paddr_begin, paddr_end, true);
     }
 
-    pub fn clear_valid_range(&mut self, paddr_begin: PhysAddr, paddr_end: PhysAddr) {
+    fn clear_valid_range(&mut self, paddr_begin: PhysAddr, paddr_end: PhysAddr) {
         self.set_range(paddr_begin, paddr_end, false);
     }
 
-    pub fn is_valid_4k(&self, paddr: PhysAddr) -> bool {
+    fn is_valid_4k(&self, paddr: PhysAddr) -> bool {
         if !self.initialized() {
             return false;
         }
@@ -279,7 +279,7 @@ impl ValidBitmap {
 
         unsafe {
             let mask: u64 = 1u64 << bit;
-            let val: u64 = ptr::read(self.bitmap.offset(index));
+            let val: u64 = ptr::read(self.bitmap.add(index));
 
             (val & mask) == mask
         }