feat: 支持动态链接

kernel/Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 crate-type = ["staticlib"]
 
 [workspace]
-members = [ 
+members = [
     "crates/*",
 ]
 

kernel/src/libs/rand.rs

@@ -1,7 +1,49 @@
+use crate::arch::rand::rand;
+
 bitflags! {
     pub struct GRandFlags: u8{
         const GRND_NONBLOCK = 0x0001;
         const GRND_RANDOM = 0x0002;
         const GRND_INSECURE = 0x0004;
     }
 }
+
+/// Generates an array of random bytes of size `N`.
+///
+/// This function fills an array of size `N` with random bytes by repeatedly
+/// generating random numbers and converting them to little-endian byte arrays.
+/// The function ensures that the entire array is filled with random bytes,
+/// even if the size of the array is not a multiple of the size of `usize`.
+///
+/// # Type Parameters
+///
+/// * `N`: The size of the array to be filled with random bytes.
+///
+/// # Returns
+///
+/// An array of size `N` filled with random bytes.
+///
+/// # Example
+///
+/// ```rust
+/// let random_bytes = rand_bytes::<16>();
+/// assert_eq!(random_bytes.len(), 16);
+/// ```
+pub fn rand_bytes<const N: usize>() -> [u8; N] {
+    let mut bytes = [0u8; N];
+    let mut remaining = N;
+    let mut index = 0;
+
+    while remaining > 0 {
+        let random_num = rand();
+        let random_bytes = random_num.to_le_bytes();
+
+        let to_copy = core::cmp::min(remaining, size_of::<usize>());
+        bytes[index..index + to_copy].copy_from_slice(&random_bytes[..to_copy]);
+
+        index += to_copy;
+        remaining -= to_copy;
+    }
+
+    bytes
+}

kernel/src/mm/fault.rs

@@ -334,7 +334,6 @@ impl PageFaultHandler {
             cache_page.read_irqsave().page_cache(),
             cache_page.read_irqsave().index(),
         );
-
         ret = ret.union(Self::finish_fault(pfm));
 
         ret

kernel/src/mm/page.rs

@@ -150,6 +150,7 @@ fn page_reclaim_thread() -> i32 {
             page_reclaimer_lock_irqsave().flush_dirty_pages();
             // 休眠5秒
             // log::info!("sleep");
+
             let _ = nanosleep(PosixTimeSpec::new(5, 0));
         }
     }

kernel/src/mm/ucontext.rs

@@ -354,6 +354,11 @@ impl InnerAddressSpace {
 
         let len = page_align_up(len);
 
+        let vm_flags = VmFlags::from(prot_flags)
+            | VmFlags::from(map_flags)
+            | VmFlags::VM_MAYREAD
+            | VmFlags::VM_MAYWRITE
+            | VmFlags::VM_MAYEXEC;
         // debug!("map_anonymous: len = {}", len);
 
         let binding = ProcessManager::current_pcb().fd_table();
@@ -450,8 +455,7 @@ impl InnerAddressSpace {
         // 找到未使用的区域
         let region = match addr {
             Some(vaddr) => {
-                self.mappings
-                    .find_free_at(self.mmap_min, vaddr, page_count.bytes(), map_flags)?
+                self.find_free_at(self.mmap_min, vaddr, page_count.bytes(), map_flags)?
             }
             None => self
                 .mappings
@@ -798,6 +802,56 @@ impl InnerAddressSpace {
 
         return self.set_brk(new_brk);
     }
+
+    pub fn find_free_at(
+        &mut self,
+        min_vaddr: VirtAddr,
+        vaddr: VirtAddr,
+        size: usize,
+        flags: MapFlags,
+    ) -> Result<VirtRegion, SystemError> {
+        // 如果没有指定地址，那么就在当前进程的地址空间中寻找一个空闲的虚拟内存范围。
+        if vaddr == VirtAddr::new(0) {
+            return self
+                .mappings
+                .find_free(min_vaddr, size)
+                .ok_or(SystemError::ENOMEM);
+        }
+
+        // 如果指定了地址，那么就检查指定的地址是否可用。
+        let requested = VirtRegion::new(vaddr, size);
+
+        if requested.end() >= MMArch::USER_END_VADDR || !vaddr.check_aligned(MMArch::PAGE_SIZE) {
+            return Err(SystemError::EINVAL);
+        }
+
+        let intersect_vma = self.mappings.conflicts(requested).next();
+        if let Some(vma) = intersect_vma {
+            if flags.contains(MapFlags::MAP_FIXED_NOREPLACE) {
+                // 如果指定了 MAP_FIXED_NOREPLACE 标志，由于所指定的地址无法成功建立映射，则放弃映射，不对地址做修正
+                return Err(SystemError::EEXIST);
+            }
+
+            if flags.contains(MapFlags::MAP_FIXED) {
+                // 对已有的VMA进行覆盖
+                let intersect_region = vma.lock().region.intersect(&requested).unwrap();
+                self.munmap(
+                    VirtPageFrame::new(intersect_region.start),
+                    PageFrameCount::from_bytes(intersect_region.size).unwrap(),
+                )?;
+                return Ok(requested);
+            }
+
+            // 如果没有指定MAP_FIXED标志，那么就对地址做修正
+            let requested = self
+                .mappings
+                .find_free(min_vaddr, size)
+                .ok_or(SystemError::ENOMEM)?;
+            return Ok(requested);
+        }
+
+        return Ok(requested);
+    }
 }
 
 impl Drop for InnerAddressSpace {
@@ -949,45 +1003,6 @@ impl UserMappings {
         return Some(region);
     }
 
-    pub fn find_free_at(
-        &self,
-        min_vaddr: VirtAddr,
-        vaddr: VirtAddr,
-        size: usize,
-        flags: MapFlags,
-    ) -> Result<VirtRegion, SystemError> {
-        // 如果没有指定地址，那么就在当前进程的地址空间中寻找一个空闲的虚拟内存范围。
-        if vaddr == VirtAddr::new(0) {
-            return self.find_free(min_vaddr, size).ok_or(SystemError::ENOMEM);
-        }
-
-        // 如果指定了地址，那么就检查指定的地址是否可用。
-
-        let requested = VirtRegion::new(vaddr, size);
-
-        if requested.end() >= MMArch::USER_END_VADDR || !vaddr.check_aligned(MMArch::PAGE_SIZE) {
-            return Err(SystemError::EINVAL);
-        }
-
-        if let Some(_x) = self.conflicts(requested).next() {
-            if flags.contains(MapFlags::MAP_FIXED_NOREPLACE) {
-                // 如果指定了 MAP_FIXED_NOREPLACE 标志，由于所指定的地址无法成功建立映射，则放弃映射，不对地址做修正
-                return Err(SystemError::EEXIST);
-            }
-
-            if flags.contains(MapFlags::MAP_FIXED) {
-                // todo: 支持MAP_FIXED标志对已有的VMA进行覆盖
-                return Err(SystemError::ENOSYS);
-            }
-
-            // 如果没有指定MAP_FIXED标志，那么就对地址做修正
-            let requested = self.find_free(min_vaddr, size).ok_or(SystemError::ENOMEM)?;
-            return Ok(requested);
-        }
-
-        return Ok(requested);
-    }
-
     /// 在当前进程的地址空间中，保留一个指定大小的区域，使得该区域不在空洞中。
     /// 该函数会修改vm_holes中的空洞信息。
     ///

kernel/src/process/abi.rs

@@ -38,15 +38,15 @@ pub enum AtType {
     /// Frequency at which times() increments.
     ClkTck,
     /// Secure mode boolean.
-    Secure,
+    Secure = 23,
     /// String identifying real platform, may differ from AT_PLATFORM.
     BasePlatform,
     /// Address of 16 random bytes.
     Random,
     /// Extension of AT_HWCAP.
     HwCap2,
     /// Filename of program.
-    ExecFn,
+    ExecFn = 31,
     /// Minimal stack size for signal delivery.
     MinSigStackSize,
 }

kernel/src/process/exec.rs

@@ -159,6 +159,11 @@ impl ExecParam {
     pub fn file_mut(&mut self) -> &mut File {
         &mut self.file
     }
+
+    /// 获取File的所有权，用于将动态链接器加入文件描述符表中
+    pub fn file(self) -> File {
+        self.file
+    }
 }
 
 /// ## 加载二进制文件
@@ -201,6 +206,7 @@ pub struct ProcInitInfo {
     pub args: Vec<CString>,
     pub envs: Vec<CString>,
     pub auxv: BTreeMap<u8, usize>,
+    pub rand_num: [u8; 16],
 }
 
 impl ProcInitInfo {
@@ -210,6 +216,7 @@ impl ProcInitInfo {
             args: Vec::new(),
             envs: Vec::new(),
             auxv: BTreeMap::new(),
+            rand_num: [0u8; 16],
         }
     }
 
@@ -220,7 +227,7 @@ impl ProcInitInfo {
     ///
     /// 返回值是一个元组，第一个元素是最终的用户栈顶地址，第二个元素是环境变量pointer数组的起始地址     
     pub unsafe fn push_at(
-        &self,
+        &mut self,
         ustack: &mut UserStack,
     ) -> Result<(VirtAddr, VirtAddr), SystemError> {
         // 先把程序的名称压入栈中
@@ -235,6 +242,7 @@ impl ProcInitInfo {
                 ustack.sp()
             })
             .collect::<Vec<_>>();
+
         // 然后把参数压入栈中
         let argps = self
             .args
@@ -245,6 +253,20 @@ impl ProcInitInfo {
             })
             .collect::<Vec<_>>();
 
+        // 压入随机数，把指针放入auxv
+        self.push_slice(ustack, &[self.rand_num])?;
+        self.auxv
+            .insert(super::abi::AtType::Random as u8, ustack.sp().data());
+
+        // 实现栈的16字节对齐
+        // 用当前栈顶地址减去后续要压栈的长度，得到的压栈后的栈顶地址与0xF按位与操作得到对齐要填充的字节数
+        let length_to_push = (self.auxv.len() + envps.len() + 1 + argps.len() + 1 + 1)
+            * core::mem::align_of::<usize>();
+        self.push_slice(
+            ustack,
+            &vec![0u8; (ustack.sp().data() - length_to_push) & 0xF],
+        )?;
+
         // 压入auxv
         self.push_slice(ustack, &[null::<u8>(), null::<u8>()])?;
         for (&k, &v) in self.auxv.iter() {
@@ -258,7 +280,6 @@ impl ProcInitInfo {
         // 把参数指针压入栈中
         self.push_slice(ustack, &[null::<u8>()])?;
         self.push_slice(ustack, argps.as_slice())?;
-
         let argv_ptr = ustack.sp();
 
         // 把argc压入栈中

kernel/src/process/syscall.rs

@@ -25,6 +25,7 @@ use crate::{
         procfs::procfs_register_pid,
         vfs::{file::FileDescriptorVec, MAX_PATHLEN},
     },
+    libs::rand::rand_bytes,
     mm::{
         ucontext::{AddressSpace, UserStack},
         verify_area, MemoryManagementArch, VirtAddr,
@@ -171,6 +172,8 @@ impl Syscall {
         // debug!("argv: {:?}, envp: {:?}", argv, envp);
         param.init_info_mut().args = argv;
         param.init_info_mut().envs = envp;
+        // // 生成16字节随机数
+        param.init_info_mut().rand_num = rand_bytes::<16>();
 
         // 把proc_init_info写到用户栈上
         let mut ustack_message = unsafe {
@@ -182,7 +185,7 @@ impl Syscall {
         };
         let (user_sp, argv_ptr) = unsafe {
             param
-                .init_info()
+                .init_info_mut()
                 .push_at(
                     // address_space
                     //     .write()
@@ -271,7 +274,7 @@ impl Syscall {
     }
     /// @brief 获取当前进程的父进程id
     ///
-    /// 若为initproc则ppid设置为0   
+    /// 若为initproc则ppid设置为0
     pub fn getppid() -> Result<Pid, SystemError> {
         let current_pcb = ProcessManager::current_pcb();
         return Ok(current_pcb.basic().ppid());

kernel/src/syscall/mod.rs

@@ -894,8 +894,10 @@ impl Syscall {
             }
 
             SYS_EXIT_GROUP => {
-                warn!("SYS_EXIT_GROUP has not yet been implemented");
-                Ok(0)
+                let exit_code = args[0];
+                Self::exit(exit_code)
+                // warn!("SYS_EXIT_GROUP has not yet been implemented");
+                // Ok(0)
             }
 
             SYS_MADVISE => {

user/apps/clear/Makefile

@@ -10,12 +10,12 @@ else
 endif
 
 ifeq ($(ARCH), x86_64)
-	export RUST_TARGET=x86_64-unknown-linux-musl
+	export RUST_TARGET=x86_64-unknown-linux-gnu
 else ifeq ($(ARCH), riscv64)
 	export RUST_TARGET=riscv64gc-unknown-linux-gnu
-else 
+else
 # 默认为x86_86，用于本地编译
-	export RUST_TARGET=x86_64-unknown-linux-musl
+	export RUST_TARGET=x86_64-unknown-linux-gnu
 endif
 
 run:

user/apps/glibc/.gitignore

@@ -0,0 +1,2 @@
+glibc-2.35
+glibc-2.35.tar.gz

user/apps/glibc/Makefile

@@ -0,0 +1,2 @@
+install:
+	bash exec.sh

user/apps/glibc/default_configure.sh

@@ -0,0 +1,19 @@
+mkdir -p build
+mkdir -p install
+if [ -z "$ARCH" ] || [ "$ARCH" != "x86_64" ] && [ "$ARCH" != "riscv64" ] &&  [ "$ARCH" != "aarch64" ]; then
+    echo "No ARCH specified, use x86_64 as default"
+    export ARCH="x86_64"
+fi
+if [ "$ARCH" == "x86_64" ] || [ "$ARCH" == "riscv64" ] ||  [ "$ARCH" == "aarch64" ]; then
+    export TRIPLET=${ARCH}-linux-gnu
+fi
+export BUILD=`uname -m`
+cd build
+../configure \
+  --prefix=/ \
+  --host=${TRIPLET} \
+  --build=${BUILD}-linux-gnu \
+  CC="${TRIPLET}-gcc -m64" \
+  CXX="${TRIPLET}-g++ -m64" \
+  CFLAGS="-O2" \
+  CXXFLAGS="-O2"