diff --git a/kernel/src/arch/x86_64/mm/fault.rs b/kernel/src/arch/x86_64/mm/fault.rs
index e55216242..1098d863e 100644
--- a/kernel/src/arch/x86_64/mm/fault.rs
+++ b/kernel/src/arch/x86_64/mm/fault.rs
@@ -272,6 +272,7 @@ impl X86_64MMArch {
                         address.data(),
                         flags
                     );
+                    log::error!("fault rip: {:#x}", regs.rip);
                     let pid = ProcessManager::current_pid();
                     let mut info =
                         SigInfo::new(Signal::SIGSEGV, 0, SigCode::User, SigType::Kill(pid));
diff --git a/kernel/src/arch/x86_64/process/syscall.rs b/kernel/src/arch/x86_64/process/syscall.rs
index a10bd57de..25ce12448 100644
--- a/kernel/src/arch/x86_64/process/syscall.rs
+++ b/kernel/src/arch/x86_64/process/syscall.rs
@@ -53,6 +53,7 @@ impl Syscall {
     }
 
     /// ## 用于控制和查询与体系结构相关的进程特定选项
+    /// https://code.dragonos.org.cn/xref/linux-6.6.21/arch/x86/kernel/process_64.c#913
     pub fn arch_prctl(option: usize, arg2: usize) -> Result<usize, SystemError> {
         let pcb = ProcessManager::current_pcb();
         if let Err(SystemError::EINVAL) = Self::do_arch_prctl_64(&pcb, option, arg2, true) {
@@ -109,8 +110,13 @@ impl Syscall {
     }
 
     #[allow(dead_code)]
-    pub fn do_arch_prctl_common(_option: usize, _arg2: usize) -> Result<usize, SystemError> {
-        todo!("do_arch_prctl_common not unimplemented");
+    pub fn do_arch_prctl_common(option: usize, arg2: usize) -> Result<usize, SystemError> {
+        // Don't use 0x3001-0x3004 because of old glibcs
+        if (0x3001..=0x3004).contains(&option) {
+            return Err(SystemError::EINVAL);
+        }
+
+        todo!("do_arch_prctl_common not unimplemented, option: {}, arg2: {}", option, arg2);
     }
 }
 
diff --git a/kernel/src/arch/x86_64/syscall/mod.rs b/kernel/src/arch/x86_64/syscall/mod.rs
index 30b4c118b..92817d4e4 100644
--- a/kernel/src/arch/x86_64/syscall/mod.rs
+++ b/kernel/src/arch/x86_64/syscall/mod.rs
@@ -90,7 +90,7 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
     mfence();
     let pid = ProcessManager::current_pcb().pid();
     let show = false;
-    // let show = if syscall_num != SYS_SCHED && pid.data() >= 7 {
+    // let show = if syscall_num != SYS_SCHED && pid.data() >= 9{
     //     true
     // } else {
     //     false
diff --git a/kernel/src/debug/panic/mod.rs b/kernel/src/debug/panic/mod.rs
index 8a6425b8c..14a2d0f7c 100644
--- a/kernel/src/debug/panic/mod.rs
+++ b/kernel/src/debug/panic/mod.rs
@@ -1,4 +1,4 @@
-mod hook;
+pub mod hook;
 use alloc::boxed::Box;
 use cfg_if::cfg_if;
 
diff --git a/kernel/src/driver/base/device/dd.rs b/kernel/src/driver/base/device/dd.rs
index 358c51950..81adaa184 100644
--- a/kernel/src/driver/base/device/dd.rs
+++ b/kernel/src/driver/base/device/dd.rs
@@ -144,6 +144,7 @@ impl DeviceManager {
     /// - Err(SystemError): 匹配过程中出现意外错误,没有匹配成功
     ///
     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/dd.c#899
+    #[inline(never)]
     fn do_device_attach_driver(
         &self,
         driver: &Arc<dyn Driver>,
diff --git a/kernel/src/driver/base/device/driver.rs b/kernel/src/driver/base/device/driver.rs
index c2f77a598..dad6682c3 100644
--- a/kernel/src/driver/base/device/driver.rs
+++ b/kernel/src/driver/base/device/driver.rs
@@ -171,6 +171,7 @@ impl dyn Driver {
     /// ## 注意
     ///
     /// 这里的默认实现很低效，请为特定的驱动自行实现高效的查询
+    #[inline(never)]
     pub fn find_device_by_name(&self, name: &str) -> Option<Arc<dyn Device>> {
         if let Some(r) = self.__find_device_by_name_fast(name) {
             return Some(r);
diff --git a/kernel/src/driver/char/virtio_console.rs b/kernel/src/driver/char/virtio_console.rs
index 463622888..ded391ab9 100644
--- a/kernel/src/driver/char/virtio_console.rs
+++ b/kernel/src/driver/char/virtio_console.rs
@@ -72,7 +72,7 @@ pub fn virtio_console(
     log::debug!(
         "virtio_console: dev_id: {:?}, parent: {:?}",
         dev_id,
-        dev_parent
+        dev_parent.as_ref().map(|x|x.name())
     );
     let device = VirtIOConsoleDevice::new(transport, dev_id.clone());
     if device.is_none() {
@@ -560,9 +560,7 @@ impl Driver for VirtIOConsoleDriver {
             virtio_con_dev.dev_id(),
         );
         }
-        log::debug!("virtio console: add_device: to lock inner");
         let mut inner = self.inner();
-        log::debug!("virtio console: add_device: inner.locked");
         let dev_name = inner.alloc_id();
         if dev_name.is_none() {
             panic!("Failed to allocate ID for VirtIO console device: '{:?}', virtio console device limit exceeded.", virtio_con_dev.dev_id())
diff --git a/kernel/src/driver/pci/pci.rs b/kernel/src/driver/pci/pci.rs
index 82bb20c9e..8be45ee9a 100644
--- a/kernel/src/driver/pci/pci.rs
+++ b/kernel/src/driver/pci/pci.rs
@@ -1063,7 +1063,12 @@ pub fn pci_init() {
         let common_header = box_pci_device.common_header();
         match box_pci_device.header_type() {
             HeaderType::Standard if common_header.status & 0x10 != 0 => {
-                info!("Found pci standard device with class code ={} subclass={} status={:#x} cap_pointer={:#x}  vendor={:#x}, device id={:#x},bdf={}", common_header.class_code, common_header.subclass, common_header.status, box_pci_device.as_standard_device().unwrap().capabilities_pointer,common_header.vendor_id, common_header.device_id,common_header.bus_device_function);
+                info!(
+                    "Found pci standard device with class code ={} subclass={}, bdf={}",
+                    common_header.class_code,
+                    common_header.subclass,
+                    common_header.bus_device_function
+                );
             }
             HeaderType::Standard => {
                 info!(
diff --git a/kernel/src/driver/tty/tty_ldisc/mod.rs b/kernel/src/driver/tty/tty_ldisc/mod.rs
index e46ec3253..f00e41c23 100644
--- a/kernel/src/driver/tty/tty_ldisc/mod.rs
+++ b/kernel/src/driver/tty/tty_ldisc/mod.rs
@@ -99,6 +99,7 @@ impl TtyLdiscManager {
     /// ### 参数
     /// - tty：需要设置的tty
     /// - o_tty: other tty 用于pty pair
+    #[inline(never)]
     pub fn ldisc_setup(tty: Arc<TtyCore>, o_tty: Option<Arc<TtyCore>>) -> Result<(), SystemError> {
         let ld = tty.ldisc();
 
diff --git a/kernel/src/driver/virtio/sysfs.rs b/kernel/src/driver/virtio/sysfs.rs
index c51f3d114..2749155ca 100644
--- a/kernel/src/driver/virtio/sysfs.rs
+++ b/kernel/src/driver/virtio/sysfs.rs
@@ -196,7 +196,7 @@ impl VirtIODeviceManager {
         dev.set_virtio_device_index(virtio_index);
         dev.set_device_name(format!("virtio{}", virtio_index.data()));
 
-        log::debug!("virtio_device_add: dev: {:?}", dev);
+        log::debug!("virtio_device_add: dev: {:?}", dev.name());
         // 添加设备到设备管理器
         device_manager().add_device(dev.clone() as Arc<dyn Device>)?;
         let r = device_manager()
diff --git a/kernel/src/filesystem/fat/fs.rs b/kernel/src/filesystem/fat/fs.rs
index 88712c458..110710117 100644
--- a/kernel/src/filesystem/fat/fs.rs
+++ b/kernel/src/filesystem/fat/fs.rs
@@ -1450,7 +1450,6 @@ impl IndexNode for LockedFATInode {
         let page_cache = self.0.lock().page_cache.clone();
         if let Some(page_cache) = page_cache {
             let r = page_cache.lock_irqsave().read(offset, &mut buf[0..len]);
-            // self.0.lock_irqsave().update_metadata();
             return r;
         } else {
             return self.read_direct(offset, len, buf, data);
diff --git a/kernel/src/filesystem/page_cache.rs b/kernel/src/filesystem/page_cache.rs
index 7f5959331..6057044cb 100644
--- a/kernel/src/filesystem/page_cache.rs
+++ b/kernel/src/filesystem/page_cache.rs
@@ -105,13 +105,14 @@ impl InnerPageCache {
     /// - `Ok(usize)` 成功读取的长度
     /// - `Err(SystemError)` 失败返回错误码
     pub fn read(&mut self, offset: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
-        let inode = self
+        let inode: Arc<dyn IndexNode> = self
             .page_cache_ref
             .upgrade()
             .unwrap()
             .inode
             .upgrade()
             .unwrap();
+
         let file_size = inode.metadata().unwrap().size;
 
         let len = if offset < file_size as usize {
@@ -174,6 +175,7 @@ impl InnerPageCache {
         for (page_index, count) in not_exist {
             // TODO 这里使用buffer避免多次读取磁盘，将来引入异步IO直接写入页面，减少内存开销和拷贝
             let mut page_buf = vec![0u8; MMArch::PAGE_SIZE * count];
+
             inode.read_sync(page_index * MMArch::PAGE_SIZE, page_buf.as_mut())?;
 
             self.create_pages(page_index, page_buf.as_mut())?;
@@ -341,6 +343,13 @@ impl PageCache {
     }
 
     pub fn lock_irqsave(&self) -> SpinLockGuard<InnerPageCache> {
+        if self.inner.is_locked() {
+            log::error!("page cache already locked");
+        }
         self.inner.lock_irqsave()
     }
+
+    pub fn is_locked(&self) -> bool {
+        self.inner.is_locked()
+    }
 }
diff --git a/kernel/src/libs/elf.rs b/kernel/src/libs/elf.rs
index fc5311252..9ff0b60e1 100644
--- a/kernel/src/libs/elf.rs
+++ b/kernel/src/libs/elf.rs
@@ -7,10 +7,10 @@ use core::{
 
 use alloc::vec::Vec;
 use elf::{
-    abi::{PT_GNU_PROPERTY, PT_INTERP},
+    abi::{ET_DYN, ET_EXEC, PT_GNU_PROPERTY, PT_INTERP, PT_LOAD},
     endian::AnyEndian,
     file::FileHeader,
-    segment::ProgramHeader,
+    segment::{ProgramHeader, SegmentTable},
 };
 use log::error;
 use system_error::SystemError;
@@ -18,7 +18,6 @@ use system_error::SystemError;
 use crate::{
     arch::{CurrentElfArch, MMArch},
     driver::base::block::SeekFrom,
-    filesystem::vfs::file::File,
     libs::align::page_align_up,
     mm::{
         allocator::page_frame::{PageFrameCount, VirtPageFrame},
@@ -28,7 +27,9 @@ use crate::{
     },
     process::{
         abi::AtType,
-        exec::{BinaryLoader, BinaryLoaderResult, ExecError, ExecLoadMode, ExecParam},
+        exec::{
+            BinaryLoader, BinaryLoaderResult, ExecError, ExecLoadMode, ExecParam, ExecParamFlags,
+        },
         ProcessFlags, ProcessManager,
     },
     syscall::user_access::{clear_user, copy_to_user},
@@ -134,8 +135,8 @@ impl ElfLoader {
         end: VirtAddr,
         prot_flags: ProtFlags,
     ) -> Result<(), ExecError> {
-        let start = self.elf_page_start(start);
-        let end = self.elf_page_align_up(end);
+        let start = Self::elf_page_start(start);
+        let end = Self::elf_page_align_up(end);
         // debug!("set_elf_brk: start={:?}, end={:?}", start, end);
         if end > start {
             let r = user_vm_guard.map_anonymous(
@@ -158,15 +159,15 @@ impl ElfLoader {
     }
 
     /// 计算addr在ELF PAGE内的偏移
-    fn elf_page_offset(&self, addr: VirtAddr) -> usize {
+    fn elf_page_offset(addr: VirtAddr) -> usize {
         addr.data() & (CurrentElfArch::ELF_PAGE_SIZE - 1)
     }
 
-    fn elf_page_start(&self, addr: VirtAddr) -> VirtAddr {
+    fn elf_page_start(addr: VirtAddr) -> VirtAddr {
         VirtAddr::new(addr.data() & (!(CurrentElfArch::ELF_PAGE_SIZE - 1)))
     }
 
-    fn elf_page_align_up(&self, addr: VirtAddr) -> VirtAddr {
+    fn elf_page_align_up(addr: VirtAddr) -> VirtAddr {
         VirtAddr::new(
             (addr.data() + CurrentElfArch::ELF_PAGE_SIZE - 1)
                 & (!(CurrentElfArch::ELF_PAGE_SIZE - 1)),
@@ -174,7 +175,7 @@ impl ElfLoader {
     }
 
     /// 根据ELF的p_flags生成对应的ProtFlags
-    fn make_prot(&self, p_flags: u32, _has_interpreter: bool, _is_interpreter: bool) -> ProtFlags {
+    fn make_prot(p_flags: u32, _has_interpreter: bool, _is_interpreter: bool) -> ProtFlags {
         let mut prot = ProtFlags::empty();
         if p_flags & elf::abi::PF_R != 0 {
             prot |= ProtFlags::PROT_READ;
@@ -211,7 +212,6 @@ impl ElfLoader {
     /// - `Ok((VirtAddr, bool))`：如果成功加载，则bool值为true，否则为false. VirtAddr为加载的地址
     #[allow(clippy::too_many_arguments)]
     fn load_elf_segment(
-        &self,
         user_vm_guard: &mut RwLockWriteGuard<'_, InnerAddressSpace>,
         param: &mut ExecParam,
         phent: &ProgramHeader,
@@ -223,11 +223,11 @@ impl ElfLoader {
         // debug!("load_elf_segment: addr_to_map={:?}", addr_to_map);
 
         // 映射位置的偏移量（页内偏移）
-        let beginning_page_offset = self.elf_page_offset(addr_to_map);
-        addr_to_map = self.elf_page_start(addr_to_map);
+        let beginning_page_offset = Self::elf_page_offset(addr_to_map);
+        addr_to_map = Self::elf_page_start(addr_to_map);
         // 计算要映射的内存的大小
         let map_size = phent.p_filesz as usize + beginning_page_offset;
-        let map_size = self.elf_page_align_up(VirtAddr::new(map_size)).data();
+        let map_size = Self::elf_page_align_up(VirtAddr::new(map_size)).data();
         // 当前段在文件中的大小
         let seg_in_file_size = phent.p_filesz as usize;
         // 当前段在文件中的偏移量
@@ -266,7 +266,9 @@ impl ElfLoader {
         // So we first map the 'big' image - and unmap the remainder at
         // the end. (which unmap is needed for ELF images with holes.)
         if total_size != 0 {
-            let total_size = self.elf_page_align_up(VirtAddr::new(total_size)).data();
+            let total_size = Self::elf_page_align_up(VirtAddr::new(total_size)).data();
+
+            // log::debug!("total_size={}", total_size);
 
             map_addr = user_vm_guard
                 .map_anonymous(addr_to_map, total_size, tmp_prot, *map_flags, false, true)
@@ -282,7 +284,7 @@ impl ElfLoader {
             )?;
 
             // 加载文件到内存
-            self.do_load_file(
+            Self::do_load_file(
                 map_addr + beginning_page_offset,
                 seg_in_file_size,
                 file_offset,
@@ -307,7 +309,7 @@ impl ElfLoader {
             // );
 
             // 加载文件到内存
-            self.do_load_file(
+            Self::do_load_file(
                 map_addr + beginning_page_offset,
                 seg_in_file_size,
                 file_offset,
@@ -326,6 +328,152 @@ impl ElfLoader {
         return Ok((map_addr, true));
     }
 
+    /// 加载elf动态链接器
+    ///
+    /// ## 参数
+    ///
+    /// - `interp_elf_ex`:动态链接器
+    /// - `load_bias`偏移量
+    ///
+    /// ## TODO
+    ///
+    /// 添加一个Arch state抽象，描述架构相关的elf state(参考 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#592)
+    fn load_elf_interp(
+        interp_elf_ex: &mut ExecParam,
+        load_bias: usize,
+    ) -> Result<BinaryLoaderResult, ExecError> {
+        // log::debug!("loading elf interp");
+        let mut head_buf = [0u8; 512];
+        interp_elf_ex
+            .file_mut()
+            .lseek(SeekFrom::SeekSet(0))
+            .map_err(|_| ExecError::NotSupported)?;
+        let _bytes = interp_elf_ex
+            .file_mut()
+            .read(512, &mut head_buf)
+            .map_err(|_| ExecError::NotSupported)?;
+        let interp_hdr =
+            Self::parse_ehdr(head_buf.as_ref()).map_err(|_| ExecError::NotExecutable)?;
+        if interp_hdr.e_type != ET_EXEC && interp_hdr.e_type != ET_DYN {
+            return Err(ExecError::NotExecutable);
+        }
+        let mut phdr_buf = Vec::new();
+        let phdr_table = Self::parse_segments(interp_elf_ex, &interp_hdr, &mut phdr_buf)
+            .map_err(|_| ExecError::ParseError)?
+            .ok_or(ExecError::ParseError)?;
+        //TODO 架构相关检查 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#610
+        let mut total_size = Self::total_mapping_size(&phdr_table);
+
+        if total_size == 0 {
+            return Err(ExecError::InvalidParemeter);
+        }
+
+        let mut load_addr_set = false;
+        let mut load_addr: VirtAddr = VirtAddr::new(0);
+        let mut elf_bss: VirtAddr = VirtAddr::new(0);
+        let mut last_bss: VirtAddr = VirtAddr::new(0);
+        let mut bss_prot: Option<ProtFlags> = None;
+        for section in phdr_table {
+            if section.p_type == PT_LOAD {
+                // log::debug!("loading {:?}", section);
+                let mut elf_type = MapFlags::MAP_PRIVATE;
+                let elf_prot = Self::make_prot(section.p_flags, true, true);
+                let vaddr = TryInto::<usize>::try_into(section.p_vaddr).unwrap();
+                let mut addr_to_map = load_addr + vaddr;
+                if interp_hdr.e_type == ET_EXEC || load_addr_set {
+                    elf_type.insert(MapFlags::MAP_FIXED) //TODO 应当为MapFlags::MAP_FIXED，暂时未支持
+                } else if load_bias != 0 && interp_hdr.e_type == ET_DYN {
+                    addr_to_map = VirtAddr::new(0);
+                }
+                let map_addr = Self::load_elf_segment(
+                    &mut interp_elf_ex.vm().clone().write(),
+                    interp_elf_ex,
+                    &section,
+                    addr_to_map,
+                    &elf_prot,
+                    &elf_type,
+                    total_size,
+                )
+                .map_err(|e| {
+                    log::error!("Failed to load elf interpreter :{:?}", e);
+                    return ExecError::InvalidParemeter;
+                })?;
+                if !map_addr.1 {
+                    return Err(ExecError::BadAddress(Some(map_addr.0)));
+                }
+                let map_addr = map_addr.0;
+                total_size = 0;
+                if !load_addr_set && interp_hdr.e_type == ET_DYN {
+                    load_addr =
+                        VirtAddr::new(map_addr - Self::elf_page_start(VirtAddr::new(vaddr)));
+                    load_addr_set = true;
+                }
+                let addr = load_addr + TryInto::<usize>::try_into(section.p_vaddr).unwrap();
+                if addr >= MMArch::USER_END_VADDR
+                    || section.p_filesz > section.p_memsz
+                    || TryInto::<usize>::try_into(section.p_memsz).unwrap()
+                        > MMArch::USER_END_VADDR.data()
+                    || MMArch::USER_END_VADDR - TryInto::<usize>::try_into(section.p_memsz).unwrap()
+                        < addr
+                {
+                    return Err(ExecError::OutOfMemory);
+                }
+
+                let addr = load_addr
+                    + TryInto::<usize>::try_into(section.p_vaddr + section.p_filesz).unwrap();
+                if addr > elf_bss {
+                    elf_bss = addr;
+                }
+
+                let addr = load_addr
+                    + TryInto::<usize>::try_into(section.p_vaddr + section.p_memsz).unwrap();
+                if addr > last_bss {
+                    last_bss = addr;
+                    bss_prot = Some(elf_prot);
+                }
+            }
+        }
+        Self::pad_zero(elf_bss).map_err(|_| return ExecError::BadAddress(Some(elf_bss)))?;
+        elf_bss = Self::elf_page_align_up(elf_bss);
+        last_bss = Self::elf_page_align_up(last_bss);
+        if last_bss > elf_bss {
+            if bss_prot.is_none() {
+                return Err(ExecError::InvalidParemeter);
+            }
+            let mut bss_prot = bss_prot.unwrap();
+            if bss_prot.contains(ProtFlags::PROT_EXEC) {
+                bss_prot = ProtFlags::PROT_EXEC;
+            } else {
+                bss_prot = ProtFlags::PROT_NONE;
+            }
+            interp_elf_ex
+                .vm()
+                .clone()
+                .write()
+                .map_anonymous(
+                    elf_bss,
+                    last_bss - elf_bss,
+                    bss_prot,
+                    MapFlags::MAP_ANONYMOUS | MapFlags::MAP_FIXED_NOREPLACE,
+                    false,
+                    true,
+                )
+                .map_err(|e| match e {
+                    SystemError::EINVAL => ExecError::InvalidParemeter,
+                    SystemError::ENOMEM => ExecError::OutOfMemory,
+                    _ => return ExecError::InvalidParemeter,
+                })?;
+        }
+        load_addr += TryInto::<usize>::try_into(interp_hdr.e_entry).unwrap();
+        if load_addr > MMArch::USER_END_VADDR {
+            return Err(ExecError::BadAddress(Some(
+                load_addr + TryInto::<usize>::try_into(interp_hdr.e_entry).unwrap(),
+            )));
+        }
+        // log::debug!("sucessfully load elf interp");
+        return Ok(BinaryLoaderResult::new(load_addr));
+    }
+
     /// 加载ELF文件到用户空间
     ///
     /// ## 参数
@@ -335,7 +483,6 @@ impl ElfLoader {
     /// - `offset_in_file`：在文件内的偏移量
     /// - `param`：执行参数
     fn do_load_file(
-        &self,
         mut vaddr: VirtAddr,
         size: usize,
         offset_in_file: usize,
@@ -367,8 +514,8 @@ impl ElfLoader {
     }
 
     /// 我们需要显式的把数据段之后剩余的内存页都清零。
-    fn pad_zero(&self, elf_bss: VirtAddr) -> Result<(), SystemError> {
-        let nbyte = self.elf_page_offset(elf_bss);
+    fn pad_zero(elf_bss: VirtAddr) -> Result<(), SystemError> {
+        let nbyte = Self::elf_page_offset(elf_bss);
         if nbyte > 0 {
             let nbyte = CurrentElfArch::ELF_PAGE_SIZE - nbyte;
             unsafe { clear_user(elf_bss, nbyte).map_err(|_| SystemError::EFAULT) }?;
@@ -376,6 +523,37 @@ impl ElfLoader {
         return Ok(());
     }
 
+    /// 参考https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#1158，获取要加载的total_size
+    fn total_mapping_size(ehdr_table: &SegmentTable<'_, AnyEndian>) -> usize {
+        let mut has_load = false;
+        let mut min_address = VirtAddr::new(usize::MAX);
+        let mut max_address = VirtAddr::new(0usize);
+        let loadable_sections = ehdr_table
+            .into_iter()
+            .filter(|seg| seg.p_type == elf::abi::PT_LOAD);
+        for seg_to_load in loadable_sections {
+            min_address = min(
+                min_address,
+                Self::elf_page_start(VirtAddr::new(seg_to_load.p_vaddr.try_into().unwrap())),
+            );
+            max_address = max(
+                max_address,
+                VirtAddr::new(
+                    (seg_to_load.p_vaddr + seg_to_load.p_memsz)
+                        .try_into()
+                        .unwrap(),
+                ),
+            );
+            has_load = true;
+        }
+        let total_size = if has_load {
+            max_address - min_address
+        } else {
+            0
+        };
+        return total_size;
+    }
+
     /// 创建auxv
     ///
     /// ## 参数
@@ -562,7 +740,7 @@ impl BinaryLoader for ElfLoader {
             .map_err(|_| ExecError::ParseError)?
             .ok_or(ExecError::ParseError)?;
         let mut _gnu_property_data: Option<ProgramHeader> = None;
-        let interpreter: Option<File> = None;
+        let mut interpreter: Option<ExecParam> = None;
         for seg in phdr_table {
             if seg.p_type == PT_GNU_PROPERTY {
                 _gnu_property_data = Some(seg);
@@ -594,8 +772,8 @@ impl BinaryLoader for ElfLoader {
                 log::error!("Failed to load interpreter ");
                 return Err(ExecError::NotSupported);
             }
-            let _interpreter_path = core::str::from_utf8(
-                &buffer[0..TryInto::<usize>::try_into(seg.p_filesz).unwrap() - 1], //
+            let interpreter_path = core::str::from_utf8(
+                &buffer[0..TryInto::<usize>::try_into(seg.p_filesz).unwrap() - 1],
             )
             .map_err(|e| {
                 ExecError::Other(format!(
@@ -603,9 +781,17 @@ impl BinaryLoader for ElfLoader {
                     e
                 ))
             })?;
-
-            //TODO 加入对动态链接器的加载，参照 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#890
+            // log::debug!("opening interpreter at :{}", interpreter_path);
+            interpreter = Some(
+                ExecParam::new(interpreter_path, param.vm().clone(), ExecParamFlags::EXEC)
+                    .map_err(|e| {
+                        log::error!("Failed to load interpreter {interpreter_path}: {:?}", e);
+                        return ExecError::NotSupported;
+                    })?,
+            );
         }
+        //TODO 缺少一部分逻辑 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#931
+
         if interpreter.is_some() {
             /* Some simple consistency checks for the interpreter */
             // 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#950
@@ -627,39 +813,14 @@ impl BinaryLoader for ElfLoader {
         // program header的虚拟地址
         let mut phdr_vaddr: Option<VirtAddr> = None;
         let mut _reloc_func_desc = 0usize;
-        // 参考https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#1158，获取要加载的total_size
-        let mut has_load = false;
-        let mut min_address = VirtAddr::new(usize::MAX);
-        let mut max_address = VirtAddr::new(0usize);
-        let loadable_sections = phdr_table
-            .into_iter()
-            .filter(|seg| seg.p_type == elf::abi::PT_LOAD);
 
-        for seg_to_load in loadable_sections {
-            min_address = min(
-                min_address,
-                self.elf_page_start(VirtAddr::new(seg_to_load.p_vaddr.try_into().unwrap())),
-            );
-            max_address = max(
-                max_address,
-                VirtAddr::new(
-                    (seg_to_load.p_vaddr + seg_to_load.p_memsz)
-                        .try_into()
-                        .unwrap(),
-                ),
-            );
-            has_load = true;
-        }
-        let total_size = if has_load {
-            max_address - min_address
-        } else {
-            0
-        };
+        let total_size = Self::total_mapping_size(&phdr_table);
         let loadable_sections = phdr_table
             .into_iter()
             .filter(|seg| seg.p_type == elf::abi::PT_LOAD);
+
         for seg_to_load in loadable_sections {
-            // debug!("seg_to_load = {:?}", seg_to_load);
+            // log::debug!("seg_to_load = {:?}", seg_to_load);
             if unlikely(elf_brk > elf_bss) {
                 // debug!(
                 //     "to set brk, elf_brk = {:?}, elf_bss = {:?}",
@@ -672,7 +833,7 @@ impl BinaryLoader for ElfLoader {
                     elf_brk + load_bias,
                     bss_prot_flags,
                 )?;
-                let nbyte = self.elf_page_offset(elf_bss);
+                let nbyte = Self::elf_page_offset(elf_bss);
                 if nbyte > 0 {
                     let nbyte = min(CurrentElfArch::ELF_PAGE_SIZE - nbyte, elf_brk - elf_bss);
                     unsafe {
@@ -684,7 +845,7 @@ impl BinaryLoader for ElfLoader {
             }
 
             // 生成ProtFlags.
-            let elf_prot_flags = self.make_prot(seg_to_load.p_flags, interpreter.is_some(), false);
+            let elf_prot_flags = Self::make_prot(seg_to_load.p_flags, interpreter.is_some(), false);
 
             let mut elf_map_flags = MapFlags::MAP_PRIVATE;
 
@@ -713,37 +874,33 @@ impl BinaryLoader for ElfLoader {
                         load_bias = 0;
                     }
                 }
-                load_bias = self
-                    .elf_page_start(VirtAddr::new(
-                        load_bias - TryInto::<usize>::try_into(seg_to_load.p_vaddr).unwrap(),
-                    ))
-                    .data();
+                load_bias = Self::elf_page_start(VirtAddr::new(
+                    load_bias - TryInto::<usize>::try_into(seg_to_load.p_vaddr).unwrap(),
+                ))
+                .data();
                 if total_size == 0 {
                     return Err(ExecError::InvalidParemeter);
                 }
             }
 
             // 加载这个段到用户空间
-            // debug!("to load elf segment");
-            let e = self
-                .load_elf_segment(
-                    &mut user_vm,
-                    param,
-                    &seg_to_load,
-                    vaddr + load_bias,
-                    &elf_prot_flags,
-                    &elf_map_flags,
-                    total_size,
-                )
-                .map_err(|e| {
-                    error!("load_elf_segment failed: {:?}", e);
-                    match e {
-                        SystemError::EFAULT => ExecError::BadAddress(None),
-                        SystemError::ENOMEM => ExecError::OutOfMemory,
-                        _ => ExecError::Other(format!("load_elf_segment failed: {:?}", e)),
-                    }
-                })?;
 
+            // log::debug!("bias: {load_bias}");
+            let e = Self::load_elf_segment(
+                &mut user_vm,
+                param,
+                &seg_to_load,
+                vaddr + load_bias,
+                &elf_prot_flags,
+                &elf_map_flags,
+                total_size,
+            )
+            .map_err(|e| match e {
+                SystemError::EFAULT => ExecError::BadAddress(None),
+                SystemError::ENOMEM => ExecError::OutOfMemory,
+                _ => ExecError::Other(format!("load_elf_segment failed: {:?}", e)),
+            })?;
+            // log::debug!("e.0={:?}", e.0);
             // 如果地址不对，那么就报错
             if !e.1 {
                 return Err(ExecError::BadAddress(Some(e.0)));
@@ -754,12 +911,10 @@ impl BinaryLoader for ElfLoader {
                 if elf_type == ElfType::DSO {
                     // todo: 在这里增加对load_bias和reloc_func_desc的更新代码
                     load_bias += e.0.data()
-                        - self
-                            .elf_page_start(VirtAddr::new(
-                                load_bias
-                                    + TryInto::<usize>::try_into(seg_to_load.p_vaddr).unwrap(),
-                            ))
-                            .data();
+                        - Self::elf_page_start(VirtAddr::new(
+                            load_bias + TryInto::<usize>::try_into(seg_to_load.p_vaddr).unwrap(),
+                        ))
+                        .data();
                     _reloc_func_desc = load_bias;
                 }
             }
@@ -793,7 +948,7 @@ impl BinaryLoader for ElfLoader {
             // 如果程序段要加载的目标地址不在用户空间内，或者是其他不合法的情况，那么就报错
             if !p_vaddr.check_user()
                 || seg_to_load.p_filesz > seg_to_load.p_memsz
-                || self.elf_page_align_up(p_vaddr + seg_to_load.p_memsz as usize)
+                || Self::elf_page_align_up(p_vaddr + seg_to_load.p_memsz as usize)
                     >= MMArch::USER_END_VADDR
             {
                 // debug!("ERR:     p_vaddr={p_vaddr:?}");
@@ -801,7 +956,7 @@ impl BinaryLoader for ElfLoader {
             }
 
             // end vaddr of this segment(code+data+bss)
-            let seg_end_vaddr_f = self.elf_page_align_up(VirtAddr::new(
+            let seg_end_vaddr_f = Self::elf_page_align_up(VirtAddr::new(
                 (seg_to_load.p_vaddr + seg_to_load.p_filesz) as usize,
             ));
 
@@ -839,7 +994,7 @@ impl BinaryLoader for ElfLoader {
         end_code = end_code.map(|v| v + load_bias);
         start_data = start_data.map(|v| v + load_bias);
         end_data = end_data.map(|v| v + load_bias);
-
+        let mut interp_load_addr: Option<VirtAddr> = None;
         // debug!(
         //     "to set brk: elf_bss: {:?}, elf_brk: {:?}, bss_prot_flags: {:?}",
         //     elf_bss,
@@ -848,16 +1003,27 @@ impl BinaryLoader for ElfLoader {
         // );
         self.set_elf_brk(&mut user_vm, elf_bss, elf_brk, bss_prot_flags)?;
 
-        if likely(elf_bss != elf_brk) && unlikely(self.pad_zero(elf_bss).is_err()) {
+        if likely(elf_bss != elf_brk) && unlikely(Self::pad_zero(elf_bss).is_err()) {
             // debug!("elf_bss = {elf_bss:?}, elf_brk = {elf_brk:?}");
             return Err(ExecError::BadAddress(Some(elf_bss)));
         }
-        if interpreter.is_some() {
-            // TODO 添加对动态加载器的处理
+        drop(user_vm);
+        if let Some(mut interpreter) = interpreter {
             // 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#1249
+            let elf_entry = Self::load_elf_interp(&mut interpreter, load_bias)?.entry_point();
+            interp_load_addr = Some(elf_entry);
+            _reloc_func_desc = elf_entry.data();
+            //参考 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/binfmt_elf.c#1269
+            //TODO allow_write_access(interpreter);
+            ProcessManager::current_pcb()
+                .fd_table()
+                .write()
+                .alloc_fd(interpreter.file(), None)
+                .map(|fd| fd as usize)
+                .map_err(|_| ExecError::InvalidParemeter)?;
         }
         // debug!("to create auxv");
-
+        let mut user_vm = binding.write();
         self.create_auxv(param, program_entrypoint, phdr_vaddr, &ehdr)?;
 
         // debug!("auxv create ok");
@@ -866,8 +1032,8 @@ impl BinaryLoader for ElfLoader {
         user_vm.start_data = start_data.unwrap_or(VirtAddr::new(0));
         user_vm.end_data = end_data.unwrap_or(VirtAddr::new(0));
 
-        let result = BinaryLoaderResult::new(program_entrypoint);
-        // debug!("elf load OK!!!");
+        let result = BinaryLoaderResult::new(interp_load_addr.unwrap_or(program_entrypoint));
+        // kdebug!("elf load OK!!!");
         return Ok(result);
     }
 }
diff --git a/kernel/src/libs/futex/futex.rs b/kernel/src/libs/futex/futex.rs
index cc651ad2e..59e3d4318 100644
--- a/kernel/src/libs/futex/futex.rs
+++ b/kernel/src/libs/futex/futex.rs
@@ -677,7 +677,7 @@ impl RobustListHead {
     /// - head_uaddr：robust list head用户空间地址
     /// - len：robust list head的长度    
     pub fn set_robust_list(head_uaddr: VirtAddr, len: usize) -> Result<usize, SystemError> {
-        let robust_list_head_len = mem::size_of::<&RobustListHead>();
+        let robust_list_head_len = mem::size_of::<RobustListHead>();
         if unlikely(len != robust_list_head_len) {
             return Err(SystemError::EINVAL);
         }
diff --git a/kernel/src/libs/rand.rs b/kernel/src/libs/rand.rs
index 2bd3c810a..d001c9ea9 100644
--- a/kernel/src/libs/rand.rs
+++ b/kernel/src/libs/rand.rs
@@ -1,3 +1,5 @@
+use crate::arch::rand::rand;
+
 bitflags! {
     pub struct GRandFlags: u8{
         const GRND_NONBLOCK = 0x0001;
@@ -6,6 +8,46 @@ bitflags! {
     }
 }
 
+/// 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
+}
+
 // 软件实现的随机数生成器
 #[allow(dead_code)]
 pub fn soft_rand() -> usize {
diff --git a/kernel/src/mm/fault.rs b/kernel/src/mm/fault.rs
index 0fa8e6b0e..f171954d1 100644
--- a/kernel/src/mm/fault.rs
+++ b/kernel/src/mm/fault.rs
@@ -316,7 +316,6 @@ impl PageFaultHandler {
         } else {
             return VmFaultReason::VM_FAULT_OOM;
         }
-
         ret = ret.union(Self::finish_fault(pfm));
 
         ret
@@ -624,7 +623,8 @@ impl PageFaultHandler {
         let mapper = &mut pfm.mapper;
         let mut ret = VmFaultReason::empty();
 
-        if let Some(page) = page_cache.lock_irqsave().get_page(file_pgoff) {
+        let page = page_cache.lock_irqsave().get_page(file_pgoff);
+        if let Some(page) = page {
             // TODO 异步从磁盘中预读页面进PageCache
 
             // 直接将PageCache中的页面作为要映射的页面
diff --git a/kernel/src/mm/ucontext.rs b/kernel/src/mm/ucontext.rs
index 04d953b28..0524301d8 100644
--- a/kernel/src/mm/ucontext.rs
+++ b/kernel/src/mm/ucontext.rs
@@ -451,8 +451,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
@@ -799,6 +798,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 +998,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中的空洞信息。
     ///
diff --git a/kernel/src/net/net_core.rs b/kernel/src/net/net_core.rs
index b90a35aa6..1987fac21 100644
--- a/kernel/src/net/net_core.rs
+++ b/kernel/src/net/net_core.rs
@@ -37,7 +37,7 @@ impl TimerFunction for NetWorkPollFunc {
 }
 
 pub fn net_init() -> Result<(), SystemError> {
-    dhcp_query()?;
+    // dhcp_query()?;
     // Init poll timer function
     // let next_time = next_n_ms_timer_jiffies(5);
     // let timer = Timer::new(Box::new(NetWorkPollFunc), next_time);
diff --git a/kernel/src/process/abi.rs b/kernel/src/process/abi.rs
index cbaab9d0a..a39f4ff3a 100644
--- a/kernel/src/process/abi.rs
+++ b/kernel/src/process/abi.rs
@@ -38,7 +38,7 @@ 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.
@@ -46,7 +46,7 @@ pub enum AtType {
     /// Extension of AT_HWCAP.
     HwCap2,
     /// Filename of program.
-    ExecFn,
+    ExecFn = 31,
     /// Minimal stack size for signal delivery.
     MinSigStackSize,
 }
diff --git a/kernel/src/process/exec.rs b/kernel/src/process/exec.rs
index 12af4c339..9d0cba351 100644
--- a/kernel/src/process/exec.rs
+++ b/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压入栈中
diff --git a/kernel/src/process/mod.rs b/kernel/src/process/mod.rs
index 4dd61252d..363809ad9 100644
--- a/kernel/src/process/mod.rs
+++ b/kernel/src/process/mod.rs
@@ -1574,8 +1574,8 @@ pub struct KernelStack {
 }
 
 impl KernelStack {
-    pub const SIZE: usize = 0x4000;
-    pub const ALIGN: usize = 0x4000;
+    pub const SIZE: usize = 0x8000;
+    pub const ALIGN: usize = 0x8000;
 
     pub fn new() -> Result<Self, SystemError> {
         return Ok(Self {
diff --git a/kernel/src/process/syscall.rs b/kernel/src/process/syscall.rs
index 5d5d9fa60..8d3754bb0 100644
--- a/kernel/src/process/syscall.rs
+++ b/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,
@@ -50,10 +51,10 @@ pub struct PosixOldUtsName {
 
 impl PosixOldUtsName {
     pub fn new() -> Self {
-        const SYS_NAME: &[u8] = b"DragonOS";
+        const SYS_NAME: &[u8] = b"Linux";
         const NODENAME: &[u8] = b"DragonOS";
-        const RELEASE: &[u8] = env!("CARGO_PKG_VERSION").as_bytes();
-        const VERSION: &[u8] = env!("CARGO_PKG_VERSION").as_bytes();
+        const RELEASE: &[u8] = b"5.19.0";
+        const VERSION: &[u8] = b"5.19.0";
 
         #[cfg(target_arch = "x86_64")]
         const MACHINE: &[u8] = b"x86_64";
@@ -174,6 +175,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 {
@@ -185,7 +188,7 @@ impl Syscall {
         };
         let (user_sp, argv_ptr) = unsafe {
             param
-                .init_info()
+                .init_info_mut()
                 .push_at(
                     // address_space
                     //     .write()
@@ -334,7 +337,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());
diff --git a/kernel/src/syscall/mod.rs b/kernel/src/syscall/mod.rs
index 9ee5f8829..88a08ff08 100644
--- a/kernel/src/syscall/mod.rs
+++ b/kernel/src/syscall/mod.rs
@@ -914,8 +914,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 => {
@@ -1063,7 +1065,7 @@ impl Syscall {
 
             SYS_RSEQ => {
                 warn!("SYS_RSEQ has not yet been implemented");
-                Ok(0)
+                Err(SystemError::ENOSYS)
             }
 
             #[cfg(target_arch = "x86_64")]
diff --git a/user/apps/clear/Makefile b/user/apps/clear/Makefile
index 0d1403539..71b0da988 100644
--- a/user/apps/clear/Makefile
+++ b/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:
diff --git a/user/apps/test-backlog/Makefile b/user/apps/test-backlog/Makefile
index 99b095d51..13482ec17 100644
--- a/user/apps/test-backlog/Makefile
+++ b/user/apps/test-backlog/Makefile
@@ -10,13 +10,13 @@ else
 endif
 
 ifeq ($(ARCH), x86_64)
-	export RUST_TARGET=x86_64-unknown-linux-musl
-	export CC=x86_64-linux-musl-gcc
+	export RUST_TARGET=x86_64-unknown-linux-gnu
+	export CC=x86_64-linux-gnu-gcc
 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:
diff --git a/user/apps/test-for-robustfutex/Makefile b/user/apps/test-for-robustfutex/Makefile
index 352c0562c..cedb5e1d3 100644
--- a/user/apps/test-for-robustfutex/Makefile
+++ b/user/apps/test-for-robustfutex/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:
diff --git a/user/apps/test-mount/Makefile b/user/apps/test-mount/Makefile
index 352c0562c..cedb5e1d3 100644
--- a/user/apps/test-mount/Makefile
+++ b/user/apps/test-mount/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:
diff --git a/user/apps/test_alarm/Makefile b/user/apps/test_alarm/Makefile
index 352c0562c..cedb5e1d3 100644
--- a/user/apps/test_alarm/Makefile
+++ b/user/apps/test_alarm/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:
diff --git a/user/apps/test_lo/Makefile b/user/apps/test_lo/Makefile
index 7522ea16c..775904d9d 100644
--- a/user/apps/test_lo/Makefile
+++ b/user/apps/test_lo/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:
diff --git a/user/apps/test_socket/Makefile b/user/apps/test_socket/Makefile
index 352c0562c..cedb5e1d3 100644
--- a/user/apps/test_socket/Makefile
+++ b/user/apps/test_socket/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:
diff --git a/user/apps/test_statx/Makefile b/user/apps/test_statx/Makefile
index 0d1403539..71b0da988 100644
--- a/user/apps/test_statx/Makefile
+++ b/user/apps/test_statx/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:
diff --git a/user/apps/test_tokio/Makefile b/user/apps/test_tokio/Makefile
index 352c0562c..cedb5e1d3 100644
--- a/user/apps/test_tokio/Makefile
+++ b/user/apps/test_tokio/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:
diff --git a/user/apps/user-manage/Makefile b/user/apps/user-manage/Makefile
index b1691ea47..16b153ced 100644
--- a/user/apps/user-manage/Makefile
+++ b/user/apps/user-manage/Makefile
@@ -13,12 +13,12 @@ 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
 
 build: