内存管理修复bug (#297)

1.修正rwLock未修改锁持有计数的bug
2.修复PageMapper::create未清空页表的问题
3.解决x86_64不支持XD时,页表项填写错误的问题
4.调整elf加载器,使得能够正确的加载relibc的程序

Author: fslongjin

kernel/src/Makefile

@@ -33,8 +33,8 @@ main.o: main.c
 
 kernel_rust:
 	rustup default nightly
-	cargo +nightly-2023-01-21 build --target ./arch/x86_64/x86_64-unknown-none.json
-# cargo +nightly-2023-01-21 build --release --target ./arch/x86_64/x86_64-unknown-none.json
+# cargo +nightly-2023-01-21 build --target ./arch/x86_64/x86_64-unknown-none.json
+	cargo +nightly-2023-01-21 build --release --target ./arch/x86_64/x86_64-unknown-none.json
 
 all: kernel
 

kernel/src/arch/x86_64/asm/irqflags.rs

@@ -5,7 +5,7 @@ pub fn local_irq_save() -> usize {
     let x: usize;
     // x86_64::registers::rflags::
     unsafe {
-        asm!("pushfq; pop {};cli", out(reg) x, options(nomem, preserves_flags));
+        asm!("pushfq; pop {}; cli", out(reg) x, options(nomem, preserves_flags));
     }
     x
 }

kernel/src/arch/x86_64/mm/mod.rs

@@ -1,13 +1,19 @@
 pub mod barrier;
 pub mod frame;
+use alloc::vec::Vec;
+use hashbrown::HashSet;
+use x86::time::rdtsc;
+use x86_64::registers::model_specific::EferFlags;
+
 use crate::driver::uart::uart::c_uart_send_str;
 use crate::include::bindings::bindings::{
     disable_textui, enable_textui, multiboot2_get_memory, multiboot2_iter, multiboot_mmap_entry_t,
-    process_control_block, video_reinitialize,
+    video_reinitialize,
 };
 use crate::libs::align::page_align_up;
 use crate::libs::printk::PrintkWriter;
 use crate::libs::spinlock::SpinLock;
+
 use crate::mm::allocator::page_frame::{FrameAllocator, PageFrameCount};
 use crate::mm::mmio_buddy::mmio_init;
 use crate::{
@@ -24,11 +30,9 @@ use crate::{kdebug, kinfo};
 use core::arch::asm;
 use core::ffi::c_void;
 use core::fmt::{Debug, Write};
-use core::mem::{self, MaybeUninit};
-use core::ptr::read_volatile;
-use core::sync::atomic::{compiler_fence, AtomicBool, Ordering};
+use core::mem::{self};
 
-use self::barrier::mfence;
+use core::sync::atomic::{compiler_fence, AtomicBool, Ordering};
 
 pub type PageMapper =
     crate::mm::page::PageMapper<crate::arch::x86_64::mm::X86_64MMArch, LockedFrameAllocator>;
@@ -72,6 +76,9 @@ pub static mut BOOTSTRAP_MM_INFO: Option<X86_64MMBootstrapInfo> = None;
 #[derive(Debug, Clone, Copy, Hash)]
 pub struct X86_64MMArch;
 
+/// XD标志位是否被保留
+static XD_RESERVED: AtomicBool = AtomicBool::new(false);
+
 impl MemoryManagementArch for X86_64MMArch {
     /// 4K页
     const PAGE_SHIFT: usize = 12;
@@ -125,6 +132,8 @@ impl MemoryManagementArch for X86_64MMArch {
             fn _end();
         }
 
+        Self::init_xd_rsvd();
+
         let bootstrap_info = X86_64MMBootstrapInfo {
             kernel_code_start: _text as usize,
             kernel_code_end: _etext as usize,
@@ -248,8 +257,28 @@ impl X86_64MMArch {
         }
         c_uart_send_str(0x3f8, "init_memory_area_from_multiboot2 end\n\0".as_ptr());
         kinfo!("Total memory size: {} MB, total areas from multiboot2: {mb2_count}, valid areas: {areas_count}", total_mem_size / 1024 / 1024);
+
         return Ok(areas_count);
     }
+
+    fn init_xd_rsvd() {
+        // 读取ia32-EFER寄存器的值
+        let efer: EferFlags = x86_64::registers::model_specific::Efer::read();
+        if !efer.contains(EferFlags::NO_EXECUTE_ENABLE) {
+            // NO_EXECUTE_ENABLE是false，那么就设置xd_reserved为true
+            kdebug!("NO_EXECUTE_ENABLE is false, set XD_RESERVED to true");
+            XD_RESERVED.store(true, Ordering::Relaxed);
+            kdebug!("11efer.contains(EferFlags::NO_EXECUTE_ENABLE)={}, XD_RESERVED={}", efer.contains(EferFlags::NO_EXECUTE_ENABLE), XD_RESERVED.load(Ordering::Relaxed));
+        }
+        compiler_fence(Ordering::SeqCst);
+
+        kdebug!("efer.contains(EferFlags::NO_EXECUTE_ENABLE)={}, XD_RESERVED={}", efer.contains(EferFlags::NO_EXECUTE_ENABLE), XD_RESERVED.load(Ordering::Relaxed));
+    }
+
+    /// 判断XD标志位是否被保留
+    pub fn is_xd_reserved() -> bool {
+        return XD_RESERVED.load(Ordering::Relaxed);
+    }
 }
 
 impl VirtAddr {
@@ -344,7 +373,7 @@ unsafe fn allocator_init() {
 
         for area in PHYS_MEMORY_AREAS.iter() {
             // kdebug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size);
-            for i in 0..area.size / MMArch::PAGE_SIZE {
+            for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) {
                 let paddr = area.base.add(i * MMArch::PAGE_SIZE);
                 let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap();
                 let flags = kernel_page_flags::<MMArch>(vaddr);
@@ -422,6 +451,99 @@ unsafe fn allocator_init() {
     kdebug!("Text UI enabled");
 }
 
+#[no_mangle]
+pub extern "C" fn rs_test_buddy() {
+    test_buddy();
+}
+pub fn test_buddy() {
+    // 申请内存然后写入数据然后free掉
+    // 总共申请200MB内存
+    const TOTAL_SIZE: usize = 200 * 1024 * 1024;
+
+    for i in 0..10 {
+        kdebug!("Test buddy, round: {i}");
+        // 存放申请的内存块
+        let mut v: Vec<(PhysAddr, PageFrameCount)> = Vec::with_capacity(60 * 1024);
+        // 存放已经申请的内存块的地址（用于检查重复）
+        let mut addr_set: HashSet<PhysAddr> = HashSet::new();
+
+        let mut allocated = 0usize;
+
+        let mut free_count = 0usize;
+
+        while allocated < TOTAL_SIZE {
+            let mut random_size = 0u64;
+            unsafe { x86::random::rdrand64(&mut random_size) };
+            // 一次最多申请4M
+            random_size = random_size % (1024 * 4096);
+            if random_size == 0 {
+                continue;
+            }
+            let random_size =
+                core::cmp::min(page_align_up(random_size as usize), TOTAL_SIZE - allocated);
+            let random_size = PageFrameCount::from_bytes(random_size.next_power_of_two()).unwrap();
+            // 获取帧
+            let (paddr, allocated_frame_count) =
+                unsafe { LockedFrameAllocator.allocate(random_size).unwrap() };
+            assert!(allocated_frame_count.data().is_power_of_two());
+            assert!(paddr.data() % MMArch::PAGE_SIZE == 0);
+            unsafe {
+                assert!(MMArch::phys_2_virt(paddr)
+                    .as_ref()
+                    .unwrap()
+                    .check_aligned(allocated_frame_count.data() * MMArch::PAGE_SIZE));
+            }
+            allocated += allocated_frame_count.data() * MMArch::PAGE_SIZE;
+            v.push((paddr, allocated_frame_count));
+            assert!(addr_set.insert(paddr), "duplicate address: {:?}", paddr);
+
+            // 写入数据
+            let vaddr = unsafe { MMArch::phys_2_virt(paddr).unwrap() };
+            let slice = unsafe {
+                core::slice::from_raw_parts_mut(
+                    vaddr.data() as *mut u8,
+                    allocated_frame_count.data() * MMArch::PAGE_SIZE,
+                )
+            };
+            for i in 0..slice.len() {
+                slice[i] = ((i + unsafe { rdtsc() } as usize) % 256) as u8;
+            }
+
+            // 随机释放一个内存块
+            if v.len() > 0 {
+                let mut random_index = 0u64;
+                unsafe { x86::random::rdrand64(&mut random_index) };
+                // 70%概率释放
+                if random_index % 10 > 7 {
+                    continue;
+                }
+                random_index = random_index % v.len() as u64;
+                let random_index = random_index as usize;
+                let (paddr, allocated_frame_count) = v.remove(random_index);
+                assert!(addr_set.remove(&paddr));
+                unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) };
+                free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE;
+            }
+        }
+
+        kdebug!(
+            "Allocated {} MB memory, release: {} MB, no release: {} bytes",
+            allocated / 1024 / 1024,
+            free_count / 1024 / 1024,
+            (allocated - free_count)
+        );
+
+        kdebug!("Now, to release buddy memory");
+        // 释放所有的内存
+        for (paddr, allocated_frame_count) in v {
+            unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) };
+            assert!(addr_set.remove(&paddr));
+            free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE;
+        }
+
+        kdebug!("release done!, allocated: {allocated}, free_count: {free_count}");
+    }
+}
 /// 全局的页帧分配器
 #[derive(Debug, Clone, Copy, Hash)]
 pub struct LockedFrameAllocator;
@@ -459,7 +581,7 @@ pub unsafe fn kernel_page_flags<A: MemoryManagementArch>(virt: VirtAddr) -> Page
     let info: X86_64MMBootstrapInfo = BOOTSTRAP_MM_INFO.clone().unwrap();
 
     if virt.data() >= info.kernel_code_start && virt.data() < info.kernel_code_end {
-        // Remap kernel code read only, execute
+        // Remap kernel code  execute
         return PageFlags::new().set_execute(true).set_write(true);
     } else if virt.data() >= info.kernel_data_end && virt.data() < info.kernel_rodata_end {
         // Remap kernel rodata read only

kernel/src/arch/x86_64/msi.rs

@@ -12,7 +12,7 @@ pub fn ia64_pci_get_arch_msi_message_address(processor: u16) -> u32 {
 /// @return MSI Message Address
 pub fn ia64_pci_get_arch_msi_message_data(
     vector: u16,
-    processor: u16,
+    _processor: u16,
     trigger: TriggerMode,
 ) -> u32 {
     match trigger {

kernel/src/arch/x86_64/syscall.rs

@@ -11,7 +11,7 @@ use crate::{
     },
     ipc::signal::sys_rt_sigreturn,
     kdebug, kinfo,
-    mm::{ucontext::AddressSpace, verify_area, MemoryManagementArch, VirtAddr},
+    mm::{ucontext::AddressSpace, verify_area, VirtAddr},
     process::exec::{load_binary_file, ExecParam, ExecParamFlags},
     syscall::{
         user_access::{check_and_clone_cstr, check_and_clone_cstr_array},
@@ -82,26 +82,26 @@ pub extern "C" fn syscall_handler(regs: &mut pt_regs) -> () {
                 syscall_return!(SystemError::EFAULT.to_posix_errno() as u64, regs);
             } else {
                 unsafe {
-                    // syscall_return!(
-                    //     rs_do_execve(
-                    //         path_ptr as *const u8,
-                    //         argv_ptr as *const *const u8,
-                    //         env_ptr as *const *const u8,
-                    //         regs
-                    //     ),
-                    //     regs
-                    // );
                     kdebug!("syscall: execve\n");
-                    let path = String::from("/bin/about.elf");
-                    let argv = vec![String::from("/bin/about.elf")];
-                    let envp = vec![String::from("PATH=/bin")];
-                    let r = tmp_rs_execve(path, argv, envp, regs);
-                    kdebug!("syscall: execve r: {:?}\n", r);
-
                     syscall_return!(
-                        r.map(|_| 0).unwrap_or_else(|e| e.to_posix_errno() as usize),
+                        rs_do_execve(
+                            path_ptr as *const u8,
+                            argv_ptr as *const *const u8,
+                            env_ptr as *const *const u8,
+                            regs
+                        ),
                         regs
-                    )
+                    );
+                    // let path = String::from("/bin/about.elf");
+                    // let argv = vec![String::from("/bin/about.elf")];
+                    // let envp = vec![String::from("PATH=/bin")];
+                    // let r = tmp_rs_execve(path, argv, envp, regs);
+                    // kdebug!("syscall: execve r: {:?}\n", r);
+
+                    // syscall_return!(
+                    //     r.map(|_| 0).unwrap_or_else(|e| e.to_posix_errno() as usize),
+                    //     regs
+                    // )
                 }
             }
         }
@@ -217,7 +217,13 @@ fn tmp_rs_execve(
     kdebug!("to load binary file");
     let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC);
     // 加载可执行文件
-    let load_result = load_binary_file(&mut param)?;
+    let load_result = load_binary_file(&mut param).unwrap_or_else(|e| {
+        panic!(
+            "Failed to load binary file: {:?}, path: {:?}",
+            e,
+            path
+        )
+    });
     kdebug!("load binary file done");
 
     param.init_info_mut().args = argv;

kernel/src/driver/net/virtio_net.rs

@@ -9,8 +9,7 @@ use smoltcp::{phy, wire};
 use virtio_drivers::{device::net::VirtIONet, transport::Transport};
 
 use crate::{
-    driver::{virtio::virtio_impl::HalImpl, Driver},
-    kdebug, kerror, kinfo,
+    driver::{virtio::virtio_impl::HalImpl, Driver}, kerror, kinfo,
     libs::spinlock::SpinLock,
     net::{generate_iface_id, NET_DRIVERS},
     syscall::SystemError,

kernel/src/driver/pci/pci_irq.rs

@@ -6,16 +6,16 @@ use core::ptr::NonNull;
 use alloc::ffi::CString;
 use alloc::vec::Vec;
 
-use super::pci::{HeaderType, PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError};
+use super::pci::{PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError};
 use crate::arch::msi::{ia64_pci_get_arch_msi_message_address, ia64_pci_get_arch_msi_message_data};
 use crate::arch::{PciArch, TraitPciArch};
 use crate::include::bindings::bindings::{
     c_irq_install, c_irq_uninstall, pt_regs, ul, EAGAIN, EINVAL,
 };
 use crate::libs::volatile::{
-    volread, volwrite, ReadOnly, Volatile, VolatileReadable, VolatileWritable, WriteOnly,
+    volread, volwrite, Volatile, VolatileReadable, VolatileWritable,
 };
-use crate::{kdebug, kerror, kinfo, kwarn};
+
 /// MSIX表的一项
 #[repr(C)]
 struct MsixEntry {
@@ -268,7 +268,7 @@ pub trait PciInterrupt: PciDeviceStructure {
         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
     }
     /// @brief 获取指定数量的中断号 todo 需要中断重构支持
-    fn irq_alloc(num: u16) -> Option<Vec<u16>> {
+    fn irq_alloc(_num: u16) -> Option<Vec<u16>> {
         None
     }
     /// @brief 进行PCI设备中断的安装

kernel/src/driver/virtio/transport_pci.rs

@@ -5,7 +5,7 @@ use crate::driver::pci::pci::{
     PciStandardDeviceBar, PCI_CAP_ID_VNDR,
 };
 
-use crate::kdebug;
+
 use crate::libs::volatile::{
     volread, volwrite, ReadOnly, Volatile, VolatileReadable, VolatileWritable, WriteOnly,
 };

kernel/src/driver/virtio/virtio_impl.rs

@@ -1,12 +1,8 @@
 use crate::arch::mm::kernel_page_flags;
-/// 为virtio-drivers库提供的操作系统接口
-use crate::include::bindings::bindings::{
-    memory_management_struct, Page, PAGE_2M_SHIFT, PAGE_2M_SIZE, PAGE_OFFSET, PAGE_SHARED,
-    ZONE_NORMAL,
-};
+
 
 use crate::arch::MMArch;
-use crate::kdebug;
+
 use crate::mm::kernel_mapper::KernelMapper;
 use crate::mm::page::PageFlags;
 use crate::mm::{