rust-kernel

//! The console "tty": keyboard input with a tiny line discipline, and the
//! `File` behind file descriptors 0, 1 and 2.
//!
//! Like a Linux terminal in canonical mode: typed characters are echoed and
//! collected in a line buffer (Backspace edits it), and only when Enter is
//! pressed does the whole line become readable from fd 0. So a user program's
//! `read(0, ...)` gets a complete, already-edited line.

use crate::errno::Errno;
use crate::fs::file::File;
use crate::{print, serial_print, vga_buffer};
use alloc::string::String;
use conquer_once::spin::OnceCell;
use crossbeam_queue::ArrayQueue;
use spin::Mutex;

/// The line being typed (not yet readable).
static LINE: Mutex<String> = Mutex::new(String::new());
/// Finished lines, as bytes, waiting for `read(0, ...)`.
static INPUT: OnceCell<ArrayQueue<u8>> = OnceCell::uninit();

fn input() -> &'static ArrayQueue<u8> {
    INPUT.get_or_init(|| ArrayQueue::new(4096))
}

/// Called by the keyboard task for every typed character.
pub fn input_char(c: char) {
    let mut line = LINE.lock();
    match c {
        '\u{8}' => {
            // Backspace: only erase what's in the current line.
            if line.pop().is_some() {
                vga_buffer::backspace();
                serial_print!("\x08"); // uart_16550 turns this into "\x08 \x08"
            }
        }
        '\n' => {
            print!("\n");
            serial_print!("\n");
            for b in line.bytes().chain(Some(b'\n')) {
                let _ = input().push(b); // queue full: drop (nobody is reading)
            }
            line.clear();
        }
        c => {
            print!("{}", c);
            serial_print!("{}", c);
            line.push(c);
        }
    }
}

/// The console as a file: reading gets keyboard lines, writing prints to the
/// screen and serial port.
pub struct Console;

impl File for Console {
    /// Blocks until a line is available, then returns up to `buf.len()`
    /// bytes of it (stopping after the '\n').
    fn read(&self, buf: &mut [u8]) -> Result<usize, Errno> {
        if buf.is_empty() {
            return Ok(0);
        }
        // Sleep until a line arrives. Syscalls run with interrupts enabled,
        // so `hlt` wakes on the next interrupt (and the timer may switch to
        // other threads meanwhile). Lines are queued whole, so once the
        // first byte is there, the rest of the line is too.
        while input().is_empty() {
            x86_64::instructions::hlt();
        }
        let mut n = 0;
        while n < buf.len() {
            let Some(b) = input().pop() else { break };
            buf[n] = b;
            n += 1;
            if b == b'\n' {
                break;
            }
        }
        Ok(n)
    }

    fn write(&self, buf: &[u8]) -> Result<usize, Errno> {
        // Print valid UTF-8 as is, anything else as '?'.
        for chunk in buf.utf8_chunks() {
            print!("{}", chunk.valid());
            serial_print!("{}", chunk.valid());
            if !chunk.invalid().is_empty() {
                print!("?");
                serial_print!("?");
            }
        }
        Ok(buf.len())
    }
}