为dragonos进行配置（目前内存分配器无法创建memspace

build.rs

@@ -53,8 +53,8 @@ fn main() {
             generate_bindings(&p);
         });
 
-    cc::Build::new()
-        .flag("-nostdinc")
+    let mut c = cc::Build::new();
+    c.flag("-nostdinc")
         .flag("-nostdlib")
         .include(&format!("{}/include", crate_dir))
         .include(&format!("{}/target/include", crate_dir))
@@ -65,8 +65,15 @@ fn main() {
             fs::read_dir("src/c")
                 .expect("src/c directory missing")
                 .map(|res| res.expect("read_dir error").path()),
-        )
-        .compile("relibc_c");
+        );
+
+    #[cfg(target_os = "dragonos")]
+    {
+        // for dragonos only
+        c.define("HAVE_MMAP", "0");
+    }
+
+    c.compile("relibc_c");
 
     println!("cargo:rustc-link-lib=static=relibc_c");
 }

src/ld_so/mod.rs

@@ -154,7 +154,7 @@ pub unsafe fn init(sp: &'static Stack) {
     {
         const ARCH_GET_FS: usize = 0x1003;
         // syscall!(ARCH_PRCTL, ARCH_GET_FS, &mut tp as *mut usize);
-        unimplemented!()
+        // unimplemented!()
     }
     #[cfg(all(target_os = "redox", target_arch = "aarch64"))]
     {
@@ -196,6 +196,7 @@ pub unsafe fn init(sp: &'static Stack) {
         tp = env.fsbase as usize;
     }
 
+    #[cfg(not(target_os = "dragonos"))]
     if tp == 0 {
         static_init(sp);
     }

src/ld_so/src/lib.rs

@@ -24,7 +24,7 @@ _start:
     ud2
 ");
 
-#[cfg(target_arch = "x86_64")]
+#[cfg(all(target_arch = "x86_64", not(target_os = "dragonos")))]
 global_asm!("
 .globl _start
 _start:
@@ -55,6 +55,37 @@ _start:
     jmp rax
 ");
 
+#[cfg(all(target_arch = "x86_64", target_os = "dragonos"))]
+global_asm!("
+.globl _start
+_start:
+    # rsi = _start + 5
+    call 2f
+2:  pop rsi
+
+    # Save original stack and align stack to 16 bytes
+    mov rbp, rsp
+    and rsp, 0xFFFFFFFFFFFFFFF0
+
+    # Call ld_so_start(stack, entry)
+    mov rdi, rbp
+    sub rsi, 5
+    # call relibc_ld_so_start
+
+    # Restore original stack, clear registers, and jump to new start function
+    mov rsp, rbp
+    xor rcx, rcx
+    xor rdx, rdx
+    xor rdi, rdi
+    xor rsi, rsi
+    xor r8, r8
+    xor r9, r9
+    xor r10, r10
+    xor r11, r11
+    fninit
+    jmp rax
+");
+
 #[no_mangle]
 pub unsafe extern "C" fn main(_argc: isize, _argv: *const *const i8) -> usize {
     // LD

src/ld_so/tcb.rs

@@ -1,3 +1,4 @@
+use crate::println;
 use alloc::vec::Vec;
 use core::{arch::asm, mem, ptr, slice};
 use goblin::error::{Error, Result};
@@ -78,6 +79,7 @@ impl Tcb {
     }
 
     /// Get the current TCB
+    #[cfg(not(target_os = "dragonos"))]
     pub unsafe fn current() -> Option<&'static mut Self> {
         let tcb_ptr = Self::arch_read(offset_of!(Self, tcb_ptr)) as *mut Self;
         let tcb_len = Self::arch_read(offset_of!(Self, tcb_len));
@@ -88,6 +90,12 @@ impl Tcb {
         }
     }
 
+    /// Not yet implemented for dragonos
+    #[cfg(target_os = "dragonos")]
+    pub unsafe fn current() -> Option<&'static mut Self> {
+        return None;
+    }
+
     /// A slice for all of the TLS data
     pub unsafe fn tls(&self) -> Option<&'static mut [u8]> {
         if self.tls_end.is_null() || self.tls_len == 0 {
@@ -255,7 +263,7 @@ impl Tcb {
         const ARCH_SET_FS: usize = 0x1002;
         syscall!(ARCH_PRCTL, ARCH_SET_FS, tls_end);
     }
-    
+
     /// OS and architecture specific code to activate TLS - DragonOS x86_64
     #[cfg(all(target_os = "dragonos", target_arch = "x86_64"))]
     unsafe fn os_arch_activate(tls_end: usize, _tls_len: usize) {

src/platform/allocator/dlmalloc.rs

@@ -8,6 +8,7 @@ use super::types::*;
 
 extern "C" {
     fn create_mspace(capacity: size_t, locked: c_int) -> usize;
+    fn create_mspace_with_base(base: *mut c_void, capacity: size_t, locked: c_int) -> usize;
     fn mspace_malloc(msp: usize, bytes: size_t) -> *mut c_void;
     fn mspace_memalign(msp: usize, alignment: size_t, bytes: size_t) -> *mut c_void;
     fn mspace_realloc(msp: usize, oldmem: *mut c_void, bytes: size_t) -> *mut c_void;
@@ -60,6 +61,22 @@ pub unsafe fn free(ptr: *mut c_void) {
     mspace_free(ALLOCATOR.get_book_keeper(), ptr)
 }
 
+#[cfg(not(target_os = "dragonos"))]
 pub fn new_mspace() -> usize {
-    unsafe { create_mspace(0, 0) }
+    unsafe { create_mspace(0, 0) };
+}
+
+#[cfg(target_os = "dragonos")]
+pub fn new_mspace() -> usize {
+    use core::sync::atomic::AtomicU8;
+
+    static mut space: [[u8; 128 * 8]; 2] = [[0; 128 * 8]; 2];
+    static cnt: AtomicU8 = AtomicU8::new(0);
+    let x = cnt.fetch_add(1, Ordering::Relaxed);
+    if x > 2 {
+        panic!("new_mspace: too many mspace");
+    }
+    let r = unsafe { create_mspace_with_base(space[x as usize].as_mut_ptr() as *mut c_void, 128 * 8, 0) };
+    println!("new_mspace: {:#018x}", r);
+    return r;
 }

src/platform/dragonos/mod.rs

@@ -4,7 +4,7 @@ use core_io::Write;
 use super::{errno, types::*, Pal};
 use crate::{
     c_str::CStr,
-    header::{dirent::dirent, signal::SIGCHLD, sys_stat::S_IFIFO},
+    header::{dirent::dirent, errno::ENOSYS, signal::SIGCHLD, sys_stat::S_IFIFO},
 };
 // use header::sys_resource::rusage;
 use crate::header::{
@@ -112,7 +112,8 @@ impl Pal for Sys {
 
     fn clock_gettime(clk_id: clockid_t, tp: *mut timespec) -> c_int {
         // e(unsafe { syscall!(CLOCK_GETTIME, clk_id, tp) }) as c_int
-        unimplemented!()
+        // unimplemented!()
+        return -ENOSYS;
     }
 
     fn close(fildes: c_int) -> c_int {
@@ -368,7 +369,12 @@ impl Pal for Sys {
         off: off_t,
     ) -> *mut c_void {
         // e(syscall!(MMAP, addr, len, prot, flags, fildes, off)) as *mut c_void
-        unimplemented!()
+
+        // Due to DragonOS has not implement mmap yet,
+        // set the return value here as 0xFFFF_FFFF_FFFF_FFFF to match dlmalloc's requirements.
+        // See https://opengrok.ringotek.cn/xref/dragonos-relibc/src/c/dlmalloc.c?r=031194b9#5439
+        return !(0usize) as *mut c_void;
+        // unimplemented!()
     }
 
     unsafe fn mprotect(addr: *mut c_void, len: usize, prot: c_int) -> c_int {
@@ -539,6 +545,7 @@ impl Pal for Sys {
     fn verify() -> bool {
         // GETPID on Linux is 39, which does not exist on Redox
         // e(unsafe { dsc::syscall5(dsc::nr::GETPID, !0, !0, !0, !0, !0) }) != !0
-        unimplemented!()
+        // unimplemented!()
+        return true;
     }
 }

src/start.rs

@@ -1,5 +1,5 @@
 use alloc::{boxed::Box, vec::Vec};
-use core::{intrinsics, ptr};
+use core::{intrinsics, ptr, fmt::Debug};
 
 use crate::{
     header::{libgen, stdio, stdlib},
@@ -35,8 +35,19 @@ impl Stack {
     }
 }
 
+impl Debug for Stack{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Stack")
+            .field("argc", &self.argc)
+            .field("argv0", &self.argv0)
+            .finish()
+    }
+}
+
 unsafe fn copy_string_array(array: *const *const c_char, len: usize) -> Vec<*mut c_char> {
+    println!("copy_string_array: array: {:p}, len: {}", array, len);
     let mut vec = Vec::with_capacity(len + 1);
+    println!("new vec ok");
     for i in 0..len {
         let item = *array.add(i);
         let mut len = 0;
@@ -169,17 +180,21 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         fn _init();
         fn main(argc: isize, argv: *mut *mut c_char, envp: *mut *mut c_char) -> c_int;
     }
-
+    println!("relibc_start: sp={:?}", sp);
     // Ensure correct host system before executing more system calls
     relibc_verify_host();
-
+    use core::arch::asm;
+    
     // Initialize TLS, if necessary
     ld_so::init(sp);
 
+    println!("alloc init");
+
     // Set up the right allocator...
     // if any memory rust based memory allocation happen before this step .. we are doomed.
     alloc_init();
 
+    println!("alloc init ok");
     if let Some(tcb) = ld_so::tcb::Tcb::current() {
         // Update TCB mspace
         tcb.mspace = ALLOCATOR.get_book_keeper();
@@ -192,17 +207,19 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
             tcb.linker_ptr = Box::into_raw(Box::new(Mutex::new(linker)));
         }
     }
-
+    println!("to copy args");
     // Set up argc and argv
     let argc = sp.argc;
     let argv = sp.argv();
     platform::inner_argv = copy_string_array(argv, argc as usize);
+    println!("copy args ok");
     platform::argv = platform::inner_argv.as_mut_ptr();
     // Special code for program_invocation_name and program_invocation_short_name
     if let Some(arg) = platform::inner_argv.get(0) {
         platform::program_invocation_name = *arg;
         platform::program_invocation_short_name = libgen::basename(*arg);
     }
+    println!("to check environ");
     // We check for NULL here since ld.so might already have initialized it for us, and we don't
     // want to overwrite it if constructors in .init_array of dependency libraries have called
     // setenv.
@@ -216,14 +233,17 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         platform::OUR_ENVIRON = copy_string_array(envp, len);
         platform::environ = platform::OUR_ENVIRON.as_mut_ptr();
     }
+    println!("to get auxvs");
     let auxvs = get_auxvs(sp.auxv().cast());
+    println!("to init platform");
     crate::platform::init(auxvs);
 
     // Setup signal stack, otherwise we cannot handle any signals besides SIG_IGN/SIG_DFL behavior.
     #[cfg(target_os = "redox")]
     setup_sigstack();
-
+    println!("before init_array()");
     init_array();
+    println!("init_array() ok");
 
     // Run preinit array
     {
@@ -235,8 +255,10 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         }
     }
 
+    println!("before _init()");
     // Call init section
     _init();
+    println!("after _init()");
 
     // Run init array
     {
@@ -247,7 +269,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
             f = f.offset(1);
         }
     }
-
+    println!("to run main()");
     // not argv or envp, because programs like bash try to modify this *const* pointer :|
     stdlib::exit(main(argc, platform::argv, platform::environ));