修改mmio－buddy代码结构和函数名 (#184)

* 修改mmio-buddy结构和函数名

kernel/src/mm/mmio_buddy.rs

@@ -1,3 +1,4 @@
+use crate::libs::spinlock::{SpinLock, SpinLockGuard};
 use crate::{
     arch::asm::current::current_pcb,
     include::bindings::bindings::{
@@ -6,7 +7,6 @@ use crate::{
         PAGE_2M_SIZE, PAGE_4K_SHIFT, PAGE_4K_SIZE, VM_DONTCOPY, VM_IO,
     },
     kdebug, kerror,
-    libs::spinlock::{SpinLock, SpinLockGuard},
 };
 use alloc::{boxed::Box, collections::LinkedList, vec::Vec};
 use core::{mem, ptr::null_mut};
@@ -57,7 +57,7 @@ impl MmioBuddyMemPool {
     /// @param vaddr 虚拟地址
     ///
     /// @return 创建好的地址区域结构体
-    fn __create_region(&self, vaddr: u64) -> Box<MmioBuddyAddrRegion> {
+    fn create_region(&self, vaddr: u64) -> Box<MmioBuddyAddrRegion> {
         let mut region: Box<MmioBuddyAddrRegion> = Box::new(MmioBuddyAddrRegion::new());
         region.vaddr = vaddr;
         return region;
@@ -74,16 +74,16 @@ impl MmioBuddyMemPool {
     /// @return Ok(i32) 返回0
     ///
     /// @return Err(i32) 返回错误码
-    fn __give_back_block(&self, vaddr: u64, exp: u32) -> Result<i32, i32> {
+    fn give_back_block(&self, vaddr: u64, exp: u32) -> Result<i32, i32> {
         // 确保内存对齐，低位都要为0
         if (vaddr & ((1 << exp) - 1)) != 0 {
             return Err(-(EINVAL as i32));
         }
-        let region: Box<MmioBuddyAddrRegion> = self.__create_region(vaddr);
+        let region: Box<MmioBuddyAddrRegion> = self.create_region(vaddr);
         // 加入buddy
         let list_guard: &mut SpinLockGuard<MmioFreeRegionList> =
-            &mut self.free_regions[__exp2index(exp)].lock();
-        self.__buddy_add_region_obj(region, list_guard);
+            &mut self.free_regions[exp2index(exp)].lock();
+        self.push_block(region, list_guard);
         return Ok(0);
     }
 
@@ -94,16 +94,16 @@ impl MmioBuddyMemPool {
     /// @param exp 要被分割的地址区域的大小的幂
     ///
     /// @param list_guard 【exp-1】对应的链表
-    fn __buddy_split(
+    fn split_block(
         &self,
         region: Box<MmioBuddyAddrRegion>,
         exp: u32,
         low_list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
     ) {
-        let vaddr: u64 = self.__buddy_block_vaddr(region.vaddr, exp - 1);
-        let new_region: Box<MmioBuddyAddrRegion> = self.__create_region(vaddr);
-        self.__buddy_add_region_obj(region, low_list_guard);
-        self.__buddy_add_region_obj(new_region, low_list_guard);
+        let vaddr: u64 = self.calculate_block_vaddr(region.vaddr, exp - 1);
+        let new_region: Box<MmioBuddyAddrRegion> = self.create_region(vaddr);
+        self.push_block(region, low_list_guard);
+        self.push_block(new_region, low_list_guard);
     }
 
     /// @brief 从buddy中申请一块指定大小的内存区域
@@ -118,14 +118,14 @@ impl MmioBuddyMemPool {
     /// - 没有满足要求的内存块时，返回ENOFOUND
     /// - 申请的内存块大小超过合法范围，返回WRONGEXP
     /// - 调用函数出错时，返回出错函数对应错误码
-    fn __query_addr_region(
+    fn query_addr_region(
         &self,
         exp: u32,
         list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
     ) -> Result<Box<MmioBuddyAddrRegion>, MmioResult> {
         // 申请范围错误
         if exp < MMIO_BUDDY_MIN_EXP || exp > MMIO_BUDDY_MAX_EXP {
-            kdebug!("__query_addr_region: exp wrong");
+            kdebug!("query_addr_region: exp wrong");
             return Err(MmioResult::WRONGEXP);
         }
         // 没有恰好符合要求的内存块
@@ -134,23 +134,21 @@ impl MmioBuddyMemPool {
             // 找到最小符合申请范围的内存块
             // 将大的内存块依次分成小块内存，直到能够满足exp大小，即将exp+1分成两块exp
             for e in exp + 1..MMIO_BUDDY_MAX_EXP + 1 {
-                if self.free_regions[__exp2index(e) as usize].lock().num_free == 0 {
+                if self.free_regions[exp2index(e) as usize].lock().num_free == 0 {
                     continue;
                 }
                 for e2 in (exp + 1..e + 1).rev() {
-                    match self
-                        .__buddy_pop_region(&mut self.free_regions[__exp2index(e2) as usize].lock())
-                    {
+                    match self.pop_block(&mut self.free_regions[exp2index(e2) as usize].lock()) {
                         Ok(region) => {
                             if e2 != exp + 1 {
                                 // 要将分裂后的内存块插入到更小的链表中
                                 let low_list_guard: &mut SpinLockGuard<MmioFreeRegionList> =
-                                    &mut self.free_regions[__exp2index(e2 - 1) as usize].lock();
-                                self.__buddy_split(region, e2, low_list_guard);
+                                    &mut self.free_regions[exp2index(e2 - 1) as usize].lock();
+                                self.split_block(region, e2, low_list_guard);
                             } else {
                                 // 由于exp对应的链表list_guard已经被锁住了 不能再加锁
                                 // 所以直接将list_guard传入
-                                self.__buddy_split(region, e2, list_guard);
+                                self.split_block(region, e2, list_guard);
                             }
                         }
                         Err(err) => {
@@ -171,10 +169,10 @@ impl MmioBuddyMemPool {
             for e in MMIO_BUDDY_MIN_EXP..exp {
                 if e != exp - 1 {
                     let high_list_guard: &mut SpinLockGuard<MmioFreeRegionList> =
-                        &mut self.free_regions[__exp2index(exp + 1)].lock();
-                    match self.__buddy_merge(
+                        &mut self.free_regions[exp2index(exp + 1)].lock();
+                    match self.merge_all_exp(
                         e,
-                        &mut self.free_regions[__exp2index(e) as usize].lock(),
+                        &mut self.free_regions[exp2index(e) as usize].lock(),
                         high_list_guard,
                     ) {
                         Ok(_) => continue,
@@ -183,9 +181,9 @@ impl MmioBuddyMemPool {
                         }
                     }
                 } else {
-                    match self.__buddy_merge(
+                    match self.merge_all_exp(
                         e,
-                        &mut self.free_regions[__exp2index(e) as usize].lock(),
+                        &mut self.free_regions[exp2index(e) as usize].lock(),
                         list_guard,
                     ) {
                         Ok(_) => continue,
@@ -217,8 +215,8 @@ impl MmioBuddyMemPool {
         exp: u32,
     ) -> Result<Box<MmioBuddyAddrRegion>, MmioResult> {
         let list_guard: &mut SpinLockGuard<MmioFreeRegionList> =
-            &mut self.free_regions[__exp2index(exp)].lock();
-        match self.__query_addr_region(exp, list_guard) {
+            &mut self.free_regions[exp2index(exp)].lock();
+        match self.query_addr_region(exp, list_guard) {
             Ok(ret) => return Ok(ret),
             Err(err) => {
                 kdebug!("mmio_buddy_query_addr_region failed");
@@ -231,7 +229,7 @@ impl MmioBuddyMemPool {
     /// @param region 要被添加的地址结构体
     ///
     /// @param list_guard 目标链表
-    fn __buddy_add_region_obj(
+    fn push_block(
         &self,
         region: Box<MmioBuddyAddrRegion>,
         list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
@@ -242,7 +240,7 @@ impl MmioBuddyMemPool {
 
     /// @brief 根据地址和内存块大小，计算伙伴块虚拟内存的地址
     #[inline(always)]
-    fn __buddy_block_vaddr(&self, vaddr: u64, exp: u32) -> u64 {
+    fn calculate_block_vaddr(&self, vaddr: u64, exp: u32) -> u64 {
         return vaddr ^ (1 << exp);
     }
 
@@ -258,7 +256,7 @@ impl MmioBuddyMemPool {
     /// @return Err(MmioResult)
     /// - 当链表为空，返回ISEMPTY
     /// - 没有找到伙伴块，返回ENOFOUND
-    fn __pop_buddy_block(
+    fn pop_buddy_block(
         &self,
         vaddr: u64,
         exp: u32,
@@ -268,7 +266,7 @@ impl MmioBuddyMemPool {
             return Err(MmioResult::ISEMPTY);
         } else {
             //计算伙伴块的地址
-            let buddy_vaddr = self.__buddy_block_vaddr(vaddr, exp);
+            let buddy_vaddr = self.calculate_block_vaddr(vaddr, exp);
 
             // element 只会有一个元素
             let mut element: Vec<Box<MmioBuddyAddrRegion>> = list_guard
@@ -292,7 +290,7 @@ impl MmioBuddyMemPool {
     /// @return Ok(Box<MmioBuddyAddrRegion>) 内存块信息结构体的引用。
     ///
     /// @return Err(MmioResult) 当链表为空，无法删除时，返回ISEMPTY
-    fn __buddy_pop_region(
+    fn pop_block(
         &self,
         list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
     ) -> Result<Box<MmioBuddyAddrRegion>, MmioResult> {
@@ -314,9 +312,9 @@ impl MmioBuddyMemPool {
     /// @return Ok(MmioResult) 合并成功返回SUCCESS
     /// @return Err(MmioResult)
     /// - 内存块过少，无法合并，返回EINVAL
-    /// - __pop_buddy_block调用出错，返回其错误码
-    /// - __buddy_merge_blocks调用出错，返回其错误码
-    fn __buddy_merge(
+    /// - pop_buddy_block调用出错，返回其错误码
+    /// - merge_blocks调用出错，返回其错误码
+    fn merge_all_exp(
         &self,
         exp: u32,
         list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
@@ -333,7 +331,7 @@ impl MmioBuddyMemPool {
             // 获取内存块
             let vaddr: u64 = list_guard.list.back().unwrap().vaddr;
             // 获取伙伴内存块
-            match self.__pop_buddy_block(vaddr, exp, list_guard) {
+            match self.pop_buddy_block(vaddr, exp, list_guard) {
                 Err(err) => {
                     return Err(err);
                 }
@@ -343,11 +341,11 @@ impl MmioBuddyMemPool {
                         vaddr: region.vaddr,
                     });
                     // 在两块内存都被取出之后才进行合并
-                    match self.__buddy_merge_blocks(region, buddy_region, exp, high_list_guard) {
+                    match self.merge_blocks(region, buddy_region, exp, high_list_guard) {
                         Err(err) => {
                             // 如果合并失败了要将取出来的元素放回去
-                            self.__buddy_add_region_obj(copy_region, list_guard);
-                            kdebug!("__buddy_merge: __buddy_merge_blocks failed");
+                            self.push_block(copy_region, list_guard);
+                            kdebug!("merge_all_exp: merge_blocks failed");
                             return Err(err);
                         }
                         Ok(_) => continue,
@@ -367,7 +365,7 @@ impl MmioBuddyMemPool {
     /// @return Ok(MmioResult) 成功返回SUCCESS
     ///
     /// @return Err(MmioResult) 两个内存块不是伙伴块,返回EINVAL
-    fn __buddy_merge_blocks(
+    fn merge_blocks(
         &self,
         region_1: Box<MmioBuddyAddrRegion>,
         region_2: Box<MmioBuddyAddrRegion>,
@@ -375,13 +373,192 @@ impl MmioBuddyMemPool {
         high_list_guard: &mut SpinLockGuard<MmioFreeRegionList>,
     ) -> Result<MmioResult, MmioResult> {
         // 判断是否为伙伴块
-        if region_1.vaddr != self.__buddy_block_vaddr(region_2.vaddr, exp) {
+        if region_1.vaddr != self.calculate_block_vaddr(region_2.vaddr, exp) {
             return Err(MmioResult::EINVAL);
         }
         // 将大的块放进下一级链表
-        self.__buddy_add_region_obj(region_1, high_list_guard);
+        self.push_block(region_1, high_list_guard);
         return Ok(MmioResult::SUCCESS);
     }
+
+    /// @brief 创建一块mmio区域，并将vma绑定到initial_mm
+    ///
+    /// @param size mmio区域的大小（字节）
+    ///
+    /// @param vm_flags 要把vma设置成的标志
+    ///
+    /// @param res_vaddr 返回值-分配得到的虚拟地址
+    ///
+    /// @param res_length 返回值-分配的虚拟地址空间长度
+    ///
+    /// @return Ok(i32) 成功返回0
+    ///
+    /// @return Err(i32) 失败返回错误码
+    fn create_mmio(
+        &self,
+        size: u32,
+        vm_flags: vm_flags_t,
+        res_vaddr: *mut u64,
+        res_length: *mut u64,
+    ) -> Result<i32, i32> {
+        if size > PAGE_1G_SIZE || size == 0 {
+            return Err(-(EPERM as i32));
+        }
+        let mut retval: i32 = 0;
+        // 计算前导0
+        let mut size_exp: u32 = 31 - size.leading_zeros();
+        // 记录最终申请的空间大小
+        let mut new_size: u32 = size;
+        // 对齐要申请的空间大小
+        // 如果要申请的空间大小小于4k，则分配4k
+        if size_exp < PAGE_4K_SHIFT {
+            new_size = PAGE_4K_SIZE;
+            size_exp = PAGE_4K_SHIFT;
+        } else if (new_size & (!(1 << size_exp))) != 0 {
+            // 向左对齐空间大小
+            size_exp += 1;
+            new_size = 1 << size_exp;
+        }
+        match MMIO_POOL.mmio_buddy_query_addr_region(size_exp) {
+            Ok(region) => {
+                unsafe {
+                    *res_vaddr = region.vaddr;
+                    *res_length = new_size as u64;
+                }
+                // 创建vma
+                let flags: u64 = vm_flags | (VM_IO | VM_DONTCOPY) as u64;
+                let len_4k: u64 = (new_size % PAGE_2M_SIZE) as u64;
+                let len_2m: u64 = new_size as u64 - len_4k;
+                let mut loop_i: u64 = 0;
+                // 先分配2M的vma
+                loop {
+                    if loop_i >= len_2m {
+                        break;
+                    }
+                    let vma: *mut *mut vm_area_struct = null_mut();
+                    retval = unsafe {
+                        mm_create_vma(
+                            &mut initial_mm,
+                            region.vaddr + loop_i,
+                            PAGE_2M_SIZE.into(),
+                            flags,
+                            null_mut(),
+                            vma,
+                        )
+                    };
+                    if retval != 0 {
+                        kdebug!(
+                            "failed to create mmio 2m vma. pid = {:?}",
+                            current_pcb().pid
+                        );
+                        unsafe {
+                            vm_area_del(*vma);
+                            vm_area_free(*vma);
+                        }
+                        return Err(retval);
+                    }
+                    loop_i += PAGE_2M_SIZE as u64;
+                }
+                // 分配4K的vma
+                loop_i = len_2m;
+                loop {
+                    if loop_i >= size as u64 {
+                        break;
+                    }
+                    let vma: *mut *mut vm_area_struct = null_mut();
+                    retval = unsafe {
+                        mm_create_vma(
+                            &mut initial_mm,
+                            region.vaddr + loop_i,
+                            PAGE_4K_SIZE.into(),
+                            flags,
+                            null_mut(),
+                            vma,
+                        )
+                    };
+                    if retval != 0 {
+                        kdebug!(
+                            "failed to create mmio 4k vma. pid = {:?}",
+                            current_pcb().pid
+                        );
+                        unsafe {
+                            vm_area_del(*vma);
+                            vm_area_free(*vma);
+                        }
+                        return Err(retval);
+                    }
+                    loop_i += PAGE_4K_SIZE as u64;
+                }
+            }
+            Err(_) => {
+                kdebug!("failed to create mmio vma.pid = {:?}", current_pcb().pid);
+                return Err(-(ENOMEM as i32));
+            }
+        }
+        return Ok(retval);
+    }
+
+    /// @brief 取消mmio的映射并将地址空间归还到buddy中
+    ///
+    /// @param vaddr 起始的虚拟地址
+    ///
+    /// @param length 要归还的地址空间的长度
+    ///
+    /// @return Ok(i32) 成功返回0
+    ///
+    /// @return Err(i32) 失败返回错误码
+    fn release_mmio(&self, vaddr: u64, length: u64) -> Result<i32, i32> {
+        //先将要释放的空间取消映射
+        unsafe {
+            mm_unmap(&mut initial_mm, vaddr, length, false);
+        }
+        let mut loop_i: u64 = 0;
+        loop {
+            if loop_i >= length {
+                break;
+            }
+            // 获取要释放的vma的结构体
+            let vma: *mut vm_area_struct = unsafe { vma_find(&mut initial_mm, vaddr + loop_i) };
+            if vma == null_mut() {
+                kdebug!(
+                    "mmio_release failed: vma not found. At address: {:?}, pid = {:?}",
+                    vaddr + loop_i,
+                    current_pcb().pid
+                );
+                return Err(-(EINVAL as i32));
+            }
+            // 检查vma起始地址是否正确
+            if unsafe { (*vma).vm_start != (vaddr + loop_i) } {
+                kdebug!(
+                    "mmio_release failed: addr_start is not equal to current: {:?}. pid = {:?}",
+                    vaddr + loop_i,
+                    current_pcb().pid
+                );
+                return Err(-(EINVAL as i32));
+            }
+            // 将vma对应空间归还
+            match MMIO_POOL.give_back_block(unsafe { (*vma).vm_start }, unsafe {
+                31 - ((*vma).vm_end - (*vma).vm_start).leading_zeros()
+            }) {
+                Ok(_) => {
+                    loop_i += unsafe { (*vma).vm_end - (*vma).vm_start };
+                    unsafe {
+                        vm_area_del(vma);
+                        vm_area_free(vma);
+                    }
+                }
+                Err(err) => {
+                    // vma对应空间没有成功归还的话，就不删除vma
+                    kdebug!(
+                        "mmio_release give_back failed: pid = {:?}",
+                        current_pcb().pid
+                    );
+                    return Err(err);
+                }
+            }
+        }
+        return Ok(0);
+    }
 }
 
 /// @brief mmio伙伴系统内部的地址区域结构体
@@ -433,7 +610,7 @@ pub extern "C" fn __mmio_buddy_init() {
     let cnt_1g_blocks: u32 = ((MMIO_TOP - MMIO_BASE) / PAGE_1G_SIZE as i64) as u32;
     let mut vaddr_base: u64 = MMIO_BASE as u64;
     for _ in 0..cnt_1g_blocks {
-        match MMIO_POOL.__give_back_block(vaddr_base, PAGE_1G_SHIFT) {
+        match MMIO_POOL.give_back_block(vaddr_base, PAGE_1G_SHIFT) {
             Ok(_) => {
                 vaddr_base += PAGE_1G_SIZE as u64;
             }
@@ -451,7 +628,7 @@ pub extern "C" fn __mmio_buddy_init() {
 ///
 /// @return 内存池数组下标
 #[inline(always)]
-fn __exp2index(exp: u32) -> usize {
+fn exp2index(exp: u32) -> usize {
     return (exp - 12) as usize;
 }
 
@@ -473,101 +650,11 @@ pub extern "C" fn mmio_create(
     res_vaddr: *mut u64,
     res_length: *mut u64,
 ) -> i32 {
-    if size > PAGE_1G_SIZE || size == 0 {
-        return -(EPERM as i32);
-    }
-    let mut retval: i32 = 0;
-    // 计算前导0
-    let mut size_exp: u32 = 31 - size.leading_zeros();
-    // 记录最终申请的空间大小
-    let mut new_size: u32 = size;
-    // 对齐要申请的空间大小
-    // 如果要申请的空间大小小于4k，则分配4k
-    if size_exp < PAGE_4K_SHIFT {
-        new_size = PAGE_4K_SIZE;
-        size_exp = PAGE_4K_SHIFT;
-    } else if (new_size & (!(1 << size_exp))) != 0 {
-        // 向左对齐空间大小
-        size_exp += 1;
-        new_size = 1 << size_exp;
+    if let Err(err) = MMIO_POOL.create_mmio(size, vm_flags, res_vaddr, res_length) {
+        return err;
+    } else {
+        return 0;
     }
-    match MMIO_POOL.mmio_buddy_query_addr_region(size_exp) {
-        Ok(region) => {
-            unsafe {
-                *res_vaddr = region.vaddr;
-                *res_length = new_size as u64;
-            }
-            // 创建vma
-            let flags: u64 = vm_flags | (VM_IO | VM_DONTCOPY) as u64;
-            let len_4k: u64 = (new_size % PAGE_2M_SIZE) as u64;
-            let len_2m: u64 = new_size as u64 - len_4k;
-            let mut loop_i: u64 = 0;
-            // 先分配2M的vma
-            loop {
-                if loop_i >= len_2m {
-                    break;
-                }
-                let vma: *mut *mut vm_area_struct = null_mut();
-                retval = unsafe {
-                    mm_create_vma(
-                        &mut initial_mm,
-                        region.vaddr + loop_i,
-                        PAGE_2M_SIZE.into(),
-                        flags,
-                        null_mut(),
-                        vma,
-                    )
-                };
-                if retval != 0 {
-                    kdebug!(
-                        "failed to create mmio 2m vma. pid = {:?}",
-                        current_pcb().pid
-                    );
-                    unsafe {
-                        vm_area_del(*vma);
-                        vm_area_free(*vma);
-                    }
-                    return retval;
-                }
-                loop_i += PAGE_2M_SIZE as u64;
-            }
-            // 分配4K的vma
-            loop_i = len_2m;
-            loop {
-                if loop_i >= size as u64 {
-                    break;
-                }
-                let vma: *mut *mut vm_area_struct = null_mut();
-                retval = unsafe {
-                    mm_create_vma(
-                        &mut initial_mm,
-                        region.vaddr + loop_i,
-                        PAGE_4K_SIZE.into(),
-                        flags,
-                        null_mut(),
-                        vma,
-                    )
-                };
-                if retval != 0 {
-                    kdebug!(
-                        "failed to create mmio 4k vma. pid = {:?}",
-                        current_pcb().pid
-                    );
-                    unsafe {
-                        vm_area_del(*vma);
-                        vm_area_free(*vma);
-                    }
-                    return retval;
-                }
-                loop_i += PAGE_4K_SIZE as u64;
-            }
-        }
-        Err(_) => {
-            kdebug!("failed to create mmio vma.pid = {:?}", current_pcb().pid);
-            return -(ENOMEM as i32);
-        }
-    }
-    return retval;
 }
 
 /// @brief 取消mmio的映射并将地址空间归还到buddy中
@@ -581,54 +668,9 @@ pub extern "C" fn mmio_create(
 /// @return Err(i32) 失败返回错误码
 #[no_mangle]
 pub extern "C" fn mmio_release(vaddr: u64, length: u64) -> i32 {
-    //先将要释放的空间取消映射
-    unsafe {
-        mm_unmap(&mut initial_mm, vaddr, length, false);
-    }
-    let mut loop_i: u64 = 0;
-    loop {
-        if loop_i >= length {
-            break;
-        }
-        // 获取要释放的vma的结构体
-        let vma: *mut vm_area_struct = unsafe { vma_find(&mut initial_mm, vaddr + loop_i) };
-        if vma == null_mut() {
-            kdebug!(
-                "mmio_release failed: vma not found. At address: {:?}, pid = {:?}",
-                vaddr + loop_i,
-                current_pcb().pid
-            );
-            return -(EINVAL as i32);
-        }
-        // 检查vma起始地址是否正确
-        if unsafe { (*vma).vm_start != (vaddr + loop_i) } {
-            kdebug!(
-                "mmio_release failed: addr_start is not equal to current: {:?}. pid = {:?}",
-                vaddr + loop_i,
-                current_pcb().pid
-            );
-            return -(EINVAL as i32);
-        }
-        // 将vma对应空间归还
-        match MMIO_POOL.__give_back_block(unsafe { (*vma).vm_start }, unsafe {
-            31 - ((*vma).vm_end - (*vma).vm_start).leading_zeros()
-        }) {
-            Ok(_) => {
-                loop_i += unsafe { (*vma).vm_end - (*vma).vm_start };
-                unsafe {
-                    vm_area_del(vma);
-                    vm_area_free(vma);
-                }
-            }
-            Err(err) => {
-                // vma对应空间没有成功归还的话，就不删除vma
-                kdebug!(
-                    "mmio_release give_back failed: pid = {:?}",
-                    current_pcb().pid
-                );
-                return err;
-            }
-        }
+    if let Err(err) = MMIO_POOL.release_mmio(vaddr, length) {
+        return err;
+    } else {
+        return 0;
     }
-    return 0;
 }