[#closes 243] Procdump debug & Refactor console struct.

kernel-rs/src/console.rs

@@ -3,104 +3,154 @@ use crate::{
     kernel::kernel,
     param::NDEV,
     proc::myproc,
-    sleepablelock::SleepablelockGuard,
+    sleepablelock::{Sleepablelock, SleepablelockGuard},
+    spinlock::Spinlock,
     uart::Uart,
     utils::spin_loop,
     vm::{UVAddr, VAddr},
 };
-use core::fmt;
+use core::fmt::{self, Write};
 
 const CONSOLE_IN_DEVSW: usize = 1;
 /// Size of console input buffer.
 const INPUT_BUF: usize = 128;
 
+/// The integrated interface for console device.
+/// Managing every communication between real-world users and system.
 pub struct Console {
-    buf: [u8; INPUT_BUF],
+    /// An interface for user programs.
+    /// I/O interactions between users and processes are done by this interface.
+    /// Inputs: User commands.
+    /// Outputs: Graphic(text) results.
+    terminal: Sleepablelock<Terminal>,
 
-    /// Read index.
-    r: u32,
-
-    /// Write index.
-    w: u32,
-
-    /// Edit index.
-    e: u32,
+    /// A struct for println! macro.
+    /// Lock to avoid interleaving concurrent println! macros.
+    pub printer: Spinlock<Printer>,
 
+    /// A console's uart interface which guarantees uniqueness.
+    /// Interaction with UART Registers should always held by this interface.
     uart: Uart,
 }
 
-impl fmt::Write for Console {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.bytes() {
-            self.putc(c as _);
-        }
-        Ok(())
-    }
-}
-
 impl Console {
     pub const fn new() -> Self {
         Self {
-            buf: [0; INPUT_BUF],
-            r: 0,
-            w: 0,
-            e: 0,
+            terminal: Sleepablelock::new("Terminal", Terminal::new()),
+            printer: Spinlock::new("Println", Printer::new()),
             uart: Uart::new(),
         }
     }
 
+    pub fn init(&mut self, devsw: &mut [Devsw; NDEV]) {
+        self.uart.init();
+
+        // Connect read and write system calls
+        // to consoleread and consolewrite.
+        devsw[CONSOLE_IN_DEVSW] = Devsw {
+            read: Some(consoleread),
+            write: Some(consolewrite),
+        };
+    }
+
     pub fn uartintr(&self) {
         self.uart.intr()
     }
 
     /// Send one character to the uart.
-    pub fn putc(&mut self, c: i32) {
+    pub fn putc(&self, c: i32) {
         // From printf.rs.
         if kernel().is_panicked() {
             spin_loop();
         }
         if c == BACKSPACE {
             // If the user typed backspace, overwrite with a space.
-            Uart::putc_sync('\u{8}' as i32);
-            Uart::putc_sync(' ' as i32);
-            Uart::putc_sync('\u{8}' as i32);
+            self.uart.putc_sync('\u{8}' as i32);
+            self.uart.putc_sync(' ' as i32);
+            self.uart.putc_sync('\u{8}' as i32);
         } else {
-            Uart::putc_sync(c);
+            self.uart.putc_sync(c);
         };
     }
 
-    unsafe fn write(&mut self, src: UVAddr, n: i32) -> i32 {
+    unsafe fn write(&self, src: UVAddr, n: i32) -> i32 {
+        let terminal = self.terminal.lock();
+        terminal.write(src, n)
+    }
+
+    unsafe fn read(&self, dst: UVAddr, n: i32) -> i32 {
+        let mut terminal = self.terminal.lock();
+        terminal.read(dst, n)
+    }
+
+    /// The console input interrupt handler.
+    /// uartintr() calls this for input character.
+    /// Do erase/kill processing, append to TERMINAL.buf,
+    /// wake up consoleread() if a whole line has arrived.
+    pub fn intr(&self, cin: i32) {
+        let mut terminal = self.terminal.lock();
+        terminal.intr(cin);
+    }
+}
+
+/// Accept user commands and show result texts.
+pub struct Terminal {
+    buf: [u8; INPUT_BUF],
+
+    /// Read index.
+    r: u32,
+
+    /// Write index.
+    w: u32,
+
+    /// Edit index.
+    e: u32,
+}
+
+impl Terminal {
+    pub const fn new() -> Self {
+        Self {
+            buf: [0; INPUT_BUF],
+            r: 0,
+            w: 0,
+            e: 0,
+        }
+    }
+}
+
+impl SleepablelockGuard<'_, Terminal> {
+    unsafe fn write(&self, src: UVAddr, n: i32) -> i32 {
         for i in 0..n {
             let mut c = [0 as u8];
             if VAddr::copyin(&mut c, UVAddr::new(src.into_usize() + (i as usize))).is_err() {
                 return i;
             }
-            self.uart.putc(c[0] as i32);
+            kernel().console.uart.putc(c[0] as i32);
         }
         n
     }
 
-    unsafe fn read(this: &mut SleepablelockGuard<'_, Self>, mut dst: UVAddr, mut n: i32) -> i32 {
+    unsafe fn read(&mut self, mut dst: UVAddr, mut n: i32) -> i32 {
         let target = n as u32;
         while n > 0 {
             // Wait until interrupt handler has put some
             // input into CONS.buffer.
-            while this.r == this.w {
+            while self.r == self.w {
                 if (*myproc()).killed() {
                     return -1;
                 }
-                this.sleep();
+                self.sleep();
             }
-            let fresh0 = this.r;
-            this.r = this.r.wrapping_add(1);
-            let cin = this.buf[fresh0.wrapping_rem(INPUT_BUF as u32) as usize] as i32;
+            let fresh0 = self.r;
+            self.r = self.r.wrapping_add(1);
+            let cin = self.buf[fresh0.wrapping_rem(INPUT_BUF as u32) as usize] as i32;
 
             // end-of-file
             if cin == ctrl('D') {
                 if (n as u32) < target {
                     // Save ^D for next time, to make sure
                     // caller gets a 0-byte result.
-                    this.r = this.r.wrapping_sub(1)
+                    self.r = self.r.wrapping_sub(1)
                 }
                 break;
             } else {
@@ -121,58 +171,77 @@ impl Console {
         target.wrapping_sub(n as u32) as i32
     }
 
-    unsafe fn intr(this: &mut SleepablelockGuard<'_, Self>, mut cin: i32) {
+    fn intr(&mut self, mut cin: i32) {
         match cin {
             // Print process list.
-            m if m == ctrl('P') => {
+            m if m == ctrl('P') => unsafe {
                 kernel().procs.dump();
-            }
+            },
 
             // Kill line.
             m if m == ctrl('U') => {
-                while this.e != this.w
-                    && this.buf[this.e.wrapping_sub(1).wrapping_rem(INPUT_BUF as u32) as usize]
+                while self.e != self.w
+                    && self.buf[self.e.wrapping_sub(1).wrapping_rem(INPUT_BUF as u32) as usize]
                         as i32
                         != '\n' as i32
                 {
-                    this.e = this.e.wrapping_sub(1);
-                    this.putc(BACKSPACE);
+                    self.e = self.e.wrapping_sub(1);
+                    kernel().console.uart.putc(BACKSPACE);
                 }
             }
 
             // Backspace
             m if m == ctrl('H') | '\x7f' as i32 => {
-                if this.e != this.w {
-                    this.e = this.e.wrapping_sub(1);
-                    this.putc(BACKSPACE);
+                if self.e != self.w {
+                    self.e = self.e.wrapping_sub(1);
+                    kernel().console.uart.putc(BACKSPACE);
                 }
             }
+
             _ => {
-                if cin != 0 && this.e.wrapping_sub(this.r) < INPUT_BUF as u32 {
+                if cin != 0 && self.e.wrapping_sub(self.r) < INPUT_BUF as u32 {
                     cin = if cin == '\r' as i32 { '\n' as i32 } else { cin };
 
                     // Echo back to the user.
-                    this.putc(cin);
+                    kernel().console.uart.putc(cin);
 
                     // Store for consumption by consoleread().
-                    let fresh1 = this.e;
-                    this.e = this.e.wrapping_add(1);
-                    this.buf[fresh1.wrapping_rem(INPUT_BUF as u32) as usize] = cin as u8;
+                    let fresh1 = self.e;
+                    self.e = self.e.wrapping_add(1);
+                    self.buf[fresh1.wrapping_rem(INPUT_BUF as u32) as usize] = cin as u8;
                     if cin == '\n' as i32
                         || cin == ctrl('D')
-                        || this.e == this.r.wrapping_add(INPUT_BUF as u32)
+                        || self.e == self.r.wrapping_add(INPUT_BUF as u32)
                     {
                         // Wake up consoleread() if a whole line (or end-of-file)
                         // has arrived.
-                        this.w = this.e;
-                        this.wakeup();
+                        self.w = self.e;
+                        self.wakeup();
                     }
                 }
             }
         }
     }
 }
 
+/// A printer formats UTF-8 bytes.
+pub struct Printer {}
+
+impl Printer {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Write for Printer {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.bytes() {
+            kernel().console.putc(c as _);
+        }
+        Ok(())
+    }
+}
+
 /// Console input and output, to the uart.
 /// Reads are line at a time.
 /// Implements special input characters:
@@ -188,35 +257,15 @@ const fn ctrl(x: char) -> i32 {
     x as i32 - '@' as i32
 }
 
-pub unsafe fn consoleinit(devsw: &mut [Devsw; NDEV]) {
-    // Connect read and write system calls
-    // to consoleread and consolewrite.
-    devsw[CONSOLE_IN_DEVSW] = Devsw {
-        read: Some(consoleread),
-        write: Some(consolewrite),
-    };
-}
-
 /// User write()s to the console go here.
 unsafe fn consolewrite(src: UVAddr, n: i32) -> i32 {
-    let mut console = kernel().console.lock();
-    console.write(src, n)
+    kernel().console.write(src, n)
 }
 
 /// User read()s from the console go here.
 /// Copy (up to) a whole input line to dst.
 /// User_dist indicates whether dst is a user
 /// or kernel address.
 unsafe fn consoleread(dst: UVAddr, n: i32) -> i32 {
-    let mut console = kernel().console.lock();
-    Console::read(&mut console, dst, n)
-}
-
-/// The console input interrupt handler.
-/// uartintr() calls this for input character.
-/// Do erase/kill processing, append to CONS.buf,
-/// wake up consoleread() if a whole line has arrived.
-pub unsafe fn consoleintr(cin: i32) {
-    let mut console = kernel().console.lock();
-    Console::intr(&mut console, cin);
+    kernel().console.read(dst, n)
 }

kernel-rs/src/kernel.rs

@@ -5,7 +5,7 @@ use spin::Once;
 use crate::{
     arena::{ArrayArena, ArrayEntry, MruArena, MruEntry},
     bio::BufEntry,
-    console::{consoleinit, Console},
+    console::Console,
     file::{Devsw, File},
     fs::{FileSystem, Inode},
     kalloc::{end, kinit, Kmem},
@@ -19,7 +19,6 @@ use crate::{
     sleepablelock::Sleepablelock,
     spinlock::Spinlock,
     trap::{trapinit, trapinithart},
-    uart::Uart,
     virtio_disk::{virtio_disk_init, Disk},
     vm::{KVAddr, PageTable},
 };
@@ -37,7 +36,7 @@ pub struct Kernel {
     panicked: AtomicBool,
 
     /// Sleeps waiting for there are some input in console buffer.
-    pub console: Sleepablelock<Console>,
+    pub console: Console,
 
     kmem: Spinlock<Kmem>,
 
@@ -90,7 +89,7 @@ impl Kernel {
     const fn zero() -> Self {
         Self {
             panicked: AtomicBool::new(false),
-            console: Sleepablelock::new("CONS", Console::new()),
+            console: Console::new(),
             kmem: Spinlock::new("KMEM", Kmem::new()),
             page_table: PageTable::zero(),
             ticks: Sleepablelock::new("time", 0),
@@ -154,12 +153,12 @@ impl Kernel {
         Some(page)
     }
 
-    /// Prints the given formatted string with the Console.
-    pub fn console_write_fmt(&self, args: fmt::Arguments<'_>) -> fmt::Result {
+    /// Prints the given formatted string with the Printer.
+    pub fn printer_write_fmt(&self, args: fmt::Arguments<'_>) -> fmt::Result {
         if self.is_panicked() {
-            unsafe { kernel().console.get_mut_unchecked().write_fmt(args) }
+            unsafe { self.console.printer.get_mut_unchecked().write_fmt(args) }
         } else {
-            let mut lock = kernel().console.lock();
+            let mut lock = self.console.printer.lock();
             lock.write_fmt(args)
         }
     }
@@ -190,7 +189,7 @@ impl Kernel {
 #[macro_export]
 macro_rules! print {
     ($($arg:tt)*) => {
-        $crate::kernel::kernel().console_write_fmt(format_args!($($arg)*)).unwrap();
+        $crate::kernel::kernel().printer_write_fmt(format_args!($($arg)*)).unwrap();
     };
 }
 
@@ -220,8 +219,7 @@ pub unsafe fn kernel_main() -> ! {
         // Initialize the kernel.
 
         // Console.
-        Uart::init();
-        consoleinit(&mut KERNEL.devsw);
+        KERNEL.console.init(&mut KERNEL.devsw);
 
         println!();
         println!("rv6 kernel is booting");