Remove debugging messages, launch elf on APs

arch/x86_64/src/memory/mod.rs

@@ -62,9 +62,6 @@ pub unsafe fn init(kernel_start: usize, kernel_end: usize) {
     // Copy memory map from bootloader location
     for (i, mut entry) in MEMORY_MAP.iter_mut().enumerate() {
         *entry = *(0x500 as *const MemoryArea).offset(i as isize);
-        if entry.length > 0 {
-            println!("{:?}", entry);
-        }
     }
 
     *ALLOCATOR.lock() = Some(AreaFrameAllocator::new(kernel_start, kernel_end, MemoryAreaIter::new(MEMORY_AREA_FREE)));

arch/x86_64/src/start.rs

@@ -212,7 +212,6 @@ pub unsafe fn usermode(ip: usize, sp: usize) -> ! {
         mov rax, 0x23
         push rax # Push code segment
         push rcx # Push rip
-        xchg bx, bx
         iretq"
         :
         : "{rbx}"(sp), "{rcx}"(ip)

kernel/context/mod.rs

@@ -80,7 +80,6 @@ impl ContextList {
             }
             context.arch.set_stack(stack.as_ptr() as usize + offset);
             context.kstack = Some(stack);
-            println!("{}: {:X}", context.id, func as usize);
         }
         Ok(context_lock)
     }

kernel/elf.rs

@@ -56,11 +56,6 @@ impl<'a> Elf<'a> {
         let mut active_table = unsafe { ActivePageTable::new() };
 
         for segment in self.segments() {
-            println!("Segment {:X} flags {:X} off {:X} virt {:X} phys {:X} file {} mem {} align {}",
-                        segment.p_type, segment.p_flags, segment.p_offset,
-                        segment.p_vaddr, segment.p_paddr, segment.p_filesz,
-                        segment.p_memsz, segment.p_align);
-
             if segment.p_type == program_header::PT_LOAD {
                 let start_page = Page::containing_address(VirtualAddress::new(segment.p_vaddr as usize));
                 let end_page = Page::containing_address(VirtualAddress::new((segment.p_vaddr + segment.p_memsz) as usize));

kernel/lib.rs

@@ -133,14 +133,9 @@ pub extern fn kmain() {
     let pid = syscall::getpid();
     println!("BSP: {:?}", pid);
 
-    let stdin = syscall::open("debug:".as_bytes(), 0);
-    println!("STDIN: {:?}", stdin);
-
-    let stdout = syscall::open("debug:".as_bytes(), 0);
-    println!("STDOUT: {:?}", stdout);
-
-    let stderr = syscall::open("debug:".as_bytes(), 0);
-    println!("STDERR: {:?}", stderr);
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(0));
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(1));
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(2));
 
     let elf = elf::Elf::from(include_bytes!("../build/userspace/init")).expect("could not load elf");
     elf.run();
@@ -168,6 +163,13 @@ pub extern fn kmain_ap(id: usize) {
     let pid = syscall::getpid();
     println!("AP {}: {:?}", id, pid);
 
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(0));
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(1));
+    assert_eq!(syscall::open("debug:".as_bytes(), 0), Ok(2));
+
+    let elf = elf::Elf::from(include_bytes!("../build/userspace/init")).expect("could not load elf");
+    elf.run();
+
     loop {
         unsafe { interrupt::enable_and_halt() }
     }

kernel/scheme/debug.rs

@@ -7,7 +7,6 @@ pub struct DebugScheme;
 
 impl Scheme for DebugScheme {
     fn open(&mut self, path: &[u8], _flags: usize) -> Result<usize> {
-        println!("DebugScheme::open: {}", unsafe { str::from_utf8_unchecked(path) });
         Ok(0)
     }
 

kernel/syscall/fs.rs

@@ -7,8 +7,6 @@ use super::{Error, Result};
 
 /// Read syscall
 pub fn read(fd: usize, buf: &mut [u8]) -> Result<usize> {
-    println!("Read {}: {:X} {}", fd, buf.as_ptr() as usize, buf.len());
-
     let file = {
         let contexts = context::contexts();
         let context_lock = contexts.current().ok_or(Error::NoProcess)?;
@@ -17,8 +15,6 @@ pub fn read(fd: usize, buf: &mut [u8]) -> Result<usize> {
         file
     };
 
-    println!("{:?}", file);
-
     let schemes = scheme::schemes();
     let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
     let result = scheme_mutex.lock().read(file.number, buf);
@@ -27,8 +23,6 @@ pub fn read(fd: usize, buf: &mut [u8]) -> Result<usize> {
 
 /// Write syscall
 pub fn write(fd: usize, buf: &[u8]) -> Result<usize> {
-    println!("Write {}: {:X} {}", fd, buf.as_ptr() as usize, buf.len());
-
     let file = {
         let contexts = context::contexts();
         let context_lock = contexts.current().ok_or(Error::NoProcess)?;
@@ -37,8 +31,6 @@ pub fn write(fd: usize, buf: &[u8]) -> Result<usize> {
         file
     };
 
-    println!("{:?}: {:?}", file, ::core::str::from_utf8(buf));
-
     let schemes = scheme::schemes();
     let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
     let result = scheme_mutex.lock().write(file.number, buf);
@@ -50,7 +42,6 @@ pub fn open(path: &[u8], flags: usize) -> Result<usize> {
     let mut parts = path.splitn(2, |&b| b == b':');
     let namespace_opt = parts.next();
     let reference_opt = parts.next();
-    println!("Open namespace {:?} reference {:?}: {:X}", namespace_opt.map(::core::str::from_utf8), reference_opt.map(::core::str::from_utf8), flags);
 
     let (scheme_id, file_id) = {
         let namespace = namespace_opt.ok_or(Error::NoEntry)?;
@@ -71,6 +62,16 @@ pub fn open(path: &[u8], flags: usize) -> Result<usize> {
 
 /// Close syscall
 pub fn close(fd: usize) -> Result<usize> {
-    println!("Close {}", fd);
-    Ok(0)
+    let file = {
+        let contexts = context::contexts();
+        let context_lock = contexts.current().ok_or(Error::NoProcess)?;
+        let context = context_lock.read();
+        let file = context.files.get(fd).ok_or(Error::BadFile)?.ok_or(Error::BadFile)?;
+        file
+    };
+
+    let schemes = scheme::schemes();
+    let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
+    let result = scheme_mutex.lock().close(file.number).and(Ok(0));
+    result
 }