恢复更改&条件编译

修复dragonos_malloc的对齐问题

relibc

@@ -1 +0,0 @@
-Subproject commit 7016e5c833af9fe4182462e6a86e498cd5e8c738

src/c/dlmalloc.c

@@ -532,6 +532,7 @@ MAX_RELEASE_CHECK_RATE   default: 4095 unless not HAVE_MMAP
 #define USE_SPIN_LOCKS 1
 #define malloc_getpagesize ((size_t)4096U)
 /* } Customizations */
+
 /* Version identifier to allow people to support multiple versions */
 #ifndef DLMALLOC_VERSION
 #define DLMALLOC_VERSION 20806
@@ -667,7 +668,7 @@ MAX_RELEASE_CHECK_RATE   default: 4095 unless not HAVE_MMAP
 
 #ifndef HAVE_MORECORE
 #if ONLY_MSPACES
-#define HAVE_MORECORE 1
+#define HAVE_MORECORE 0
 #else   /* ONLY_MSPACES */
 #define HAVE_MORECORE 1
 #endif  /* ONLY_MSPACES */
@@ -1681,7 +1682,7 @@ static FORCEINLINE void* win32mmap(size_t size) {
 
 /* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
 static FORCEINLINE void* win32direct_mmap(size_t size) {
-  void* ptr = VirtualAlloc(0, size, MEMORECOREM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
+  void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
                            PAGE_READWRITE);
   return (ptr != 0)? ptr: MFAIL;
 }
@@ -5445,39 +5446,20 @@ mspace create_mspace(size_t capacity, int locked) {
   return (mspace)m;
 }
 
-/* for testing */
-size_t create_mspace_with_base_(void* base, size_t capacity, int locked) {
-  mstate m = 0;
-  size_t msize;
-  ensure_initialization();
-  // (void)(mparams.magic != 0 || init_mparams())
-  msize = pad_request(sizeof(struct malloc_state));
-  if (capacity > msize + TOP_FOOT_SIZE &&
-      capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size) ) {
-    return TOP_FOOT_SIZE;
-    m = init_user_mstate((char*)base, capacity);
-    m->seg.sflags = EXTERN_BIT;
-    set_lock(m, locked);
-  }
-  //return (mspace)m;
-  return 1222222;//(size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size);
-}
 
 mspace create_mspace_with_base(void* base, size_t capacity, int locked) {
   mstate m = 0;
   size_t msize;
   ensure_initialization();
-  // (void)(mparams.magic != 0 || init_mparams())
   msize = pad_request(sizeof(struct malloc_state));
   if (capacity > msize + TOP_FOOT_SIZE &&
       capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
     m = init_user_mstate((char*)base, capacity);
     m->seg.sflags = EXTERN_BIT;
     set_lock(m, locked);
-    return (mspace)m;
   }
-  
-  return 0;
+
+  return (mspace)m;
 }
 
 int mspace_track_large_chunks(mspace msp, int enable) {
@@ -5546,7 +5528,7 @@ void* mspace_malloc(mspace msp, size_t bytes) {
         idx += ~smallbits & 1;       /* Uses next bin if idx empty */
         b = smallbin_at(ms, idx);
         p = b->fd;
-        assert(chunksize(p) == small_i"0"ndex2size(idx));
+        assert(chunksize(p) == small_index2size(idx));
         unlink_first_small_chunk(ms, b, p, idx);
         set_inuse_and_pinuse(ms, p, small_index2size(idx));
         mem = chunk2mem(p);

src/c/malloc.c → src/c/dragonos_malloc.c

@@ -15,18 +15,16 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 // Or you can visit https://www.gnu.org/licenses/gpl-2.0.html
 
-#include <unistd.h>
 #include <errno.h>
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
 
 #define PAGE_4K_SHIFT 12
 #define PAGE_2M_SHIFT 21
 #define PAGE_1G_SHIFT 30
 #define PAGE_GDT_SHIFT 39
 
-
-
 /***************************/
 
 // 不同大小的页的容量
@@ -38,9 +36,11 @@
 #define PAGE_4K_MASK (~(PAGE_4K_SIZE - 1))
 #define PAGE_2M_MASK (~(PAGE_2M_SIZE - 1))
 
+#define ALIGN_UP16(x) (((x) + 15) & ~15)
+
 // 将addr按照x的上边界对齐
-//#define PAGE_4K_ALIGN(addr) (((unsigned long)(addr) + PAGE_4K_SIZE - 1) & PAGE_4K_MASK)
-//#define PAGE_2M_ALIGN(addr) (((unsigned long)(addr) + PAGE_2M_SIZE - 1) & PAGE_2M_MASK)
+// #define PAGE_4K_ALIGN(addr) (((unsigned long)(addr) + PAGE_4K_SIZE - 1) & PAGE_4K_MASK)
+// #define PAGE_2M_ALIGN(addr) (((unsigned long)(addr) + PAGE_2M_SIZE - 1) & PAGE_2M_MASK)
 
 /**
  * @brief 显式链表的结点
@@ -48,7 +48,7 @@
  */
 typedef struct malloc_mem_chunk_t
 {
-    uint64_t length;                 // 整个块所占用的内存区域的大小
+    uint64_t length; // 整个块所占用的内存区域的大小
     uint64_t padding;
     struct malloc_mem_chunk_t *prev; // 上一个结点的指针
     struct malloc_mem_chunk_t *next; // 下一个结点的指针
@@ -165,7 +165,7 @@ static int malloc_enlarge(int64_t size)
             brk_max_addr = sbrk((0));
         else
         {
-            //put_string("malloc_enlarge(): no_mem\n", COLOR_YELLOW, COLOR_BLACK);
+            // put_string("malloc_enlarge(): no_mem\n", COLOR_YELLOW, COLOR_BLACK);
             return -ENOMEM;
         }
 
@@ -177,7 +177,8 @@ static int malloc_enlarge(int64_t size)
     // printf("managed addr = %#018lx\n", brk_managed_addr);
     malloc_mem_chunk_t *new_ck = (malloc_mem_chunk_t *)brk_managed_addr;
     new_ck->length = brk_max_addr - brk_managed_addr;
-    // printf("new_ck->start_addr=%#018lx\tbrk_max_addr=%#018lx\tbrk_managed_addr=%#018lx\n", (uint64_t)new_ck, brk_max_addr, brk_managed_addr);
+    // printf("new_ck->start_addr=%#018lx\tbrk_max_addr=%#018lx\tbrk_managed_addr=%#018lx\n", (uint64_t)new_ck,
+    // brk_max_addr, brk_managed_addr);
     new_ck->prev = NULL;
     new_ck->next = NULL;
     brk_managed_addr = brk_max_addr;
@@ -290,20 +291,19 @@ static void malloc_insert_free_list(malloc_mem_chunk_t *ck)
  */
 void *_dragonos_malloc(ssize_t size)
 {
-    
     // 计算需要分配的块的大小
-    // reserve for len
-    if (size + 2*sizeof(uint64_t) <= sizeof(malloc_mem_chunk_t))
+    if (size < sizeof(malloc_mem_chunk_t) - 16)
         size = sizeof(malloc_mem_chunk_t);
-    else
-        size += 2*sizeof(uint64_t);
+
+    // 16字节对齐
+    size = ALIGN_UP16(size);
 
     // 采用best fit
     malloc_mem_chunk_t *ck = malloc_query_free_chunk_bf(size);
 
     if (ck == NULL) // 没有空闲块
     {
-        
+
         // printf("no free blocks\n");
         // 尝试合并空闲块
         malloc_merge_free_chunk();
@@ -357,7 +357,7 @@ found:;
     }
     // printf("malloc done: %#018lx, length=%#018lx\n", ((uint64_t)ck + sizeof(uint64_t)), ck->length);
     // 此时链表结点的指针的空间被分配出去
-    return (void *)((uint64_t)ck + sizeof(uint64_t));
+    return (void *)((uint64_t)ck + 2 * sizeof(uint64_t));
 }
 
 /**
@@ -373,13 +373,14 @@ static void release_brk()
         printf("release(): free list end is null. \n");
         return;
     }
-    if ((uint64_t)malloc_free_list_end + malloc_free_list_end->length == brk_max_addr && (uint64_t)malloc_free_list_end <= brk_max_addr - (PAGE_2M_SIZE << 1))
+    if ((uint64_t)malloc_free_list_end + malloc_free_list_end->length == brk_max_addr &&
+        (uint64_t)malloc_free_list_end <= brk_max_addr - (PAGE_2M_SIZE << 1))
     {
         int64_t delta = ((brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK) - PAGE_2M_SIZE;
-        // printf("(brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK=%#018lx\n ", (brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK);
-        // printf("PAGE_2M_SIZE=%#018lx\n", PAGE_2M_SIZE);
-        // printf("tdfghgbdfggkmfn=%#018lx\n ", (brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK - PAGE_2M_SIZE);
-        // printf("delta=%#018lx\n ", delta);
+        // printf("(brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK=%#018lx\n ", (brk_max_addr -
+        // (uint64_t)malloc_free_list_end) & PAGE_2M_MASK); printf("PAGE_2M_SIZE=%#018lx\n", PAGE_2M_SIZE);
+        // printf("tdfghgbdfggkmfn=%#018lx\n ", (brk_max_addr - (uint64_t)malloc_free_list_end) & PAGE_2M_MASK -
+        // PAGE_2M_SIZE); printf("delta=%#018lx\n ", delta);
         if (delta <= 0) // 不用释放内存
             return;
         sbrk(-delta);
@@ -397,7 +398,7 @@ static void release_brk()
 void _dragonos_free(void *ptr)
 {
     // 找到结点（此时prev和next都处于未初始化的状态）
-    malloc_mem_chunk_t *ck = (malloc_mem_chunk_t *)((uint64_t)ptr - sizeof(uint64_t));
+    malloc_mem_chunk_t *ck = (malloc_mem_chunk_t *)((uint64_t)ptr - 2 * sizeof(uint64_t));
     // printf("free(): addr = %#018lx\t len=%#018lx\n", (uint64_t)ck, ck->length);
     count_last_free_size += ck->length;
 

src/lib.rs

@@ -1,6 +1,4 @@
 #![no_std]
-
-#![feature(vec_into_raw_parts)]
 #![allow(non_camel_case_types)]
 #![allow(non_upper_case_globals)]
 #![allow(unused_variables)]
@@ -17,6 +15,7 @@
 #![feature(stmt_expr_attributes)]
 #![feature(str_internals)]
 #![feature(thread_local)]
+#![feature(vec_into_raw_parts)]
 #![allow(clippy::cast_lossless)]
 #![allow(clippy::cast_ptr_alignment)]
 #![allow(clippy::derive_hash_xor_eq)]

src/platform/allocator/dlmalloc.rs

@@ -9,7 +9,6 @@ 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 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;

src/platform/allocator/dragonos_malloc.rs

@@ -0,0 +1,75 @@
+use crate::ALLOCATOR;
+use core::{
+    alloc::{GlobalAlloc, Layout},
+    ptr::null_mut,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+use super::types::*;
+
+extern "C" {
+    fn _dragonos_free(ptr: *mut c_void) -> *mut c_void;
+    fn _dragonos_malloc(size: usize) -> *mut c_void;
+}
+
+pub struct Allocator {
+    mstate: AtomicUsize,
+}
+
+pub const NEWALLOCATOR: Allocator = Allocator {
+    mstate: AtomicUsize::new(0),
+};
+
+impl Allocator {
+    pub fn set_book_keeper(&self, mstate: usize) {
+        self.mstate.store(mstate, Ordering::Relaxed);
+    }
+    pub fn get_book_keeper(&self) -> usize {
+        self.mstate.load(Ordering::Relaxed)
+    }
+}
+
+unsafe impl<'a> GlobalAlloc for Allocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        alloc(layout.size()) as *mut u8
+        //alloc_align(layout.size(), layout.align()) as *mut u8
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+        free(ptr as *mut c_void);
+    }
+}
+
+pub unsafe fn alloc(size: usize) -> *mut c_void {
+    // println!("alloc size: {}", size);
+    _dragonos_malloc(size)
+    //mspace_malloc(ALLOCATOR.get_book_keeper(), size)
+}
+
+fn align_up(addr: usize, align: usize) -> usize {
+    (addr + align - 1) & !(align - 1)
+}
+pub unsafe fn alloc_align(mut size: usize, alignment: usize) -> *mut c_void {
+    // println!("alloc align size: {}, alignment: {}", size, alignment);
+    size = align_up(size, alignment);
+    
+    // TODO: 实现对齐分配
+    _dragonos_malloc(size)
+    //mspace_memalign(ALLOCATOR.get_book_keeper(), alignment, size)
+}
+
+pub unsafe fn realloc(ptr: *mut c_void, size: size_t) -> *mut c_void {
+    todo!()
+}
+
+pub unsafe fn free(ptr: *mut c_void) {
+    // println!("free ptr: {:#018x}", ptr as usize);
+    _dragonos_free(ptr);
+    //mspace_free(ALLOCATOR.get_book_keeper(), ptr)
+}
+
+#[cfg(target_os = "dragonos")]
+pub fn new_mspace() -> usize {
+    // dbg!("new_mspace");
+    1
+}

src/platform/allocator/malloc.rs

@@ -1,96 +0,0 @@
-use crate::ALLOCATOR;
-use core::{
-    alloc::{GlobalAlloc, Layout},
-    sync::atomic::{AtomicUsize, Ordering}, ptr::null_mut,
-};
-
-use super::types::*;
-
-extern "C" {
-    fn _dragonos_free(ptr:*mut c_void)->*mut c_void;
-    fn _dragonos_malloc(size:usize)->*mut c_void;
-}
-
-pub struct Allocator {
-    mstate: AtomicUsize,
-}
-
-pub const NEWALLOCATOR: Allocator = Allocator {
-    mstate: AtomicUsize::new(0),
-};
-
-impl Allocator {
-    pub fn set_book_keeper(&self, mstate: usize) {
-        dbg!("set book keeper,{}");
-        dbg!(mstate);
-        self.mstate.store(mstate, Ordering::Relaxed);
-        dbg!("have set book keeper");//,mstate);
-    }
-    pub fn get_book_keeper(&self) -> usize {
-        self.mstate.load(Ordering::Relaxed)
-    }
-}
-
-unsafe impl<'a> GlobalAlloc for Allocator {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        alloc(layout.size()) as *mut u8
-        //alloc_align(layout.size(), layout.align()) as *mut u8
-    }
-
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        free(ptr as *mut c_void);
-    }
-}
-
-pub unsafe fn alloc(size: usize) -> *mut c_void {
-    println!("alloc size: {}", size);
-    _dragonos_malloc(size)
-    //mspace_malloc(ALLOCATOR.get_book_keeper(), size)
-}
-
-pub unsafe fn alloc_align(size: usize, alignment: usize) -> *mut c_void {
-    println!("alloc align size: {}, alignment: {}", size, alignment);
-    // TODO: 实现对齐分配
-    _dragonos_malloc(size)
-    //mspace_memalign(ALLOCATOR.get_book_keeper(), alignment, size)
-}
-
-pub unsafe fn realloc(ptr: *mut c_void, size: size_t) -> *mut c_void {
-    todo!()
-    //null_mut()
-    //mspace_realloc(ALLOCATOR.get_book_keeper(), ptr, size)
-}
-
-pub unsafe fn free(ptr: *mut c_void) {
-    println!("free ptr: {:#018x}", ptr as usize);
-    _dragonos_free(ptr);
-    //mspace_free(ALLOCATOR.get_book_keeper(), ptr)
-}
-
-#[cfg(not(target_os = "dragonos"))]
-pub fn new_mspace() -> usize {
-    unsafe { create_mspace(0, 0) };
-}
-
-#[cfg(target_os = "dragonos")]
-pub fn new_mspace() -> usize {
-
-    dbg!("new_mspace");
-    // use core::sync::atomic::AtomicU8;
-
-    // static mut space: [[u8; 128 * 16]; 2] = [[0; 128 * 16]; 2];
-    // static cnt: AtomicU8 = AtomicU8::new(0);
-    // let x = cnt.fetch_add(1, Ordering::Relaxed);
-    // if x > 2 {
-    //     panic!("new_mspace: too many mspace");
-    // }
-    // println!("I am here");
-    // println!("{:#?}",unsafe{space[x as usize].as_mut_ptr()});
-    // let r=unsafe{malloc(128 * 16)} as usize;
-    // //let r = unsafe { create_mspace_with_base(space[x as usize].as_mut_ptr() as *mut c_void, 128 * 16, 0) };
-    // println!("new_mspace: {:#018x}", r);
-    // dbg!("new mspace");
-    // let rsize=core::ptr::addr_of!(r);
-    // return unsafe { *rsize };
-    1
-}

src/platform/mod.rs

@@ -4,8 +4,12 @@ use core::{fmt, ptr};
 
 pub use self::allocator::*;
 
-#[cfg(not(feature = "ralloc"))]
-#[path = "allocator/malloc.rs"]
+#[cfg(all(not(feature = "ralloc"), not(target_os = "dragonos")))]
+#[path = "allocator/dlmalloc.rs"]
+mod allocator;
+
+#[cfg(all(not(feature = "ralloc"), target_os = "dragonos"))]
+#[path = "allocator/dragonos_malloc.rs"]
 mod allocator;
 
 #[cfg(feature = "ralloc")]

src/start.rs

@@ -1,5 +1,5 @@
 use alloc::{boxed::Box, vec::Vec};
-use core::{intrinsics, ptr, fmt::Debug};
+use core::{fmt::Debug, intrinsics, ptr};
 
 use crate::{
     header::{libgen, stdio, stdlib},
@@ -9,7 +9,6 @@ use crate::{
     ALLOCATOR,
 };
 
-
 #[repr(C)]
 pub struct Stack {
     pub argc: isize,
@@ -30,13 +29,13 @@ impl Stack {
             let mut envp = self.envp();
             while !(*envp).is_null() {
                 envp = envp.add(1);
-            }//timer_init
+            }
             envp.add(1) as *const (usize, usize)
         }
     }
 }
 
-impl Debug for Stack{
+impl Debug for Stack {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Stack")
             .field("argc", &self.argc)
@@ -46,14 +45,10 @@ impl Debug for Stack{
 }
 
 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);
-    
+    // println!("copy_string_array: array: {:p}, len: {}", array, len);
+
     let mut vec = Vec::with_capacity(len + 1);
-    
-    let x = vec.into_raw_parts();
-    println!("{:#018x?}",x.0);
-    let mut vec=alloc::vec::Vec::from_raw_parts(x.0, x.1, x.2);
-    println!("new vec ok");
+
     for i in 0..len {
         let item = *array.add(i);
         let mut len = 0;
@@ -96,18 +91,18 @@ fn alloc_init() {
         }
     }
     unsafe {
-        dbg!("in alloc init");
+        // dbg!("in alloc init");
         if let Some(tcb) = ld_so::tcb::Tcb::current() {
-            println!("tcb.mspace {}",tcb.mspace);
+            // println!("tcb.mspace {}",tcb.mspace);
             if tcb.mspace != 0 {
                 ALLOCATOR.set_book_keeper(tcb.mspace);
             } else if ALLOCATOR.get_book_keeper() == 0 {
                 ALLOCATOR.set_book_keeper(new_mspace());
             }
         } else if ALLOCATOR.get_book_keeper() == 0 {
-            dbg!("TRY");
+            // dbg!("TRY");
             ALLOCATOR.set_book_keeper(new_mspace());
-            dbg!("ALLOCATOR OWARI DAWA");
+            // dbg!("ALLOCATOR OWARI DAWA");
         }
     }
 }
@@ -144,7 +139,7 @@ extern "C" fn init_array() {
 
 fn io_init() {
     unsafe {
-        // Initialize stdin/stdout/stderr, 
+        // Initialize stdin/stdout/stderr,
         // see https://github.com/rust-lang/rust/issues/51718
         stdio::stdin = stdio::default_stdin.get();
         stdio::stdout = stdio::default_stdout.get();
@@ -193,23 +188,20 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         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");
+    // println!("alloc init");
 
-    //println!("alloc init ok_________________");
-    
     // 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");
+    // println!("alloc init ok");
 
     if let Some(tcb) = ld_so::tcb::Tcb::current() {
         // Update TCB mspace
@@ -224,21 +216,22 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         }
     }
 
-    println!("to copy args");
+    // 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");
+    // 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");
+    // 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.
@@ -252,17 +245,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");
+    // println!("to get auxvs");
     let auxvs = get_auxvs(sp.auxv().cast());
-    println!("to init platform");
+    // 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()");
+    // println!("before init_array()");
     init_array();
-    println!("init_array() ok");
+    // println!("init_array() ok");
 
     // Run preinit array
     {
@@ -274,10 +267,10 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         }
     }
 
-    println!("before _init()");
+    // println!("before _init()");
     // Call init section
     _init();
-    println!("after _init()");
+    // println!("after _init()");
     // Run init array
     {
         let mut f = &__init_array_start as *const _;
@@ -288,7 +281,7 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
         }
     }
 
-    println!("to run main()");
+    // 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));