yggdrasil/src/device/tty.rs

//! Terminal driver implementation
use abi::{
    error::Error,
    io::{TerminalInputOptions, TerminalLineOptions, TerminalOptions, TerminalOutputOptions},
    process::Signal,
};

use crate::{
    proc::wait::Wait,
    sync::IrqSafeSpinlock,
    task::{process::Process, ProcessId},
};

use super::serial::SerialDevice;

#[cfg(feature = "fb_console")]
pub mod combined {
    use abi::{error::Error, io::DeviceRequest};
    use vfs::CharDevice;

    use crate::device::{
        display::{console::DisplayConsole, fb_console::FramebufferConsole},
        input::KeyboardDevice,
        serial::SerialDevice,
        Device,
    };

    use super::{CharRing, TtyDevice};

    // TODO rewrite this
    /// Helper device to combine a display and a keyboard input into a single terminal
    pub struct CombinedTerminal {
        #[allow(dead_code)]
        input: &'static dyn KeyboardDevice,
        output: &'static dyn DisplayConsole,

        input_ring: CharRing<16>,
    }

    impl CombinedTerminal {
        /// Create a combined terminal device from a keyboard and console output devices
        pub fn new(
            input: &'static dyn KeyboardDevice,
            output: &'static FramebufferConsole,
        ) -> Self {
            Self {
                input,
                output,
                input_ring: CharRing::new(),
            }
        }
    }

    impl TtyDevice<16> for CombinedTerminal {
        fn ring(&self) -> &CharRing<16> {
            &self.input_ring
        }
    }

    impl SerialDevice for CombinedTerminal {
        fn receive(&self, _blocking: bool) -> Result<u8, Error> {
            todo!()
        }

        fn send(&self, byte: u8) -> Result<(), Error> {
            self.output.write_char(byte);
            Ok(())
        }
    }

    impl Device for CombinedTerminal {
        fn name(&self) -> &'static str {
            "Combined terminal device"
        }
    }

    impl CharDevice for CombinedTerminal {
        fn read(&'static self, blocking: bool, data: &mut [u8]) -> Result<usize, Error> {
            assert!(blocking);
            self.line_read(data)
        }

        fn write(&self, blocking: bool, data: &[u8]) -> Result<usize, Error> {
            assert!(blocking);
            self.line_write(data)
        }

        fn device_request(&self, req: &mut DeviceRequest) -> Result<(), Error> {
            match req {
                &mut DeviceRequest::SetTerminalGroup(id) => {
                    self.set_signal_group(id as _);
                    Ok(())
                }
                _ => Err(Error::InvalidArgument),
            }
        }
    }
}

#[cfg(feature = "fb_console")]
pub use combined::CombinedTerminal;

struct CharRingInner<const N: usize> {
    rd: usize,
    wr: usize,
    data: [u8; N],
    flags: u8,
    process_group: Option<ProcessId>,
}

/// Ring buffer for a character device. Handles reads, writes and channel notifications for a
/// terminal device.
pub struct CharRing<const N: usize> {
    wait_read: Wait,
    wait_write: Wait,
    inner: IrqSafeSpinlock<CharRingInner<N>>,
    config: IrqSafeSpinlock<TerminalOptions>,
}

/// Terminal device interface
pub trait TtyDevice<const N: usize>: SerialDevice {
    /// Returns the ring buffer associated with the device
    fn ring(&self) -> &CharRing<N>;

    /// Returns `true` if data is ready to be read from or written to the terminal
    fn is_ready(&self, write: bool) -> Result<bool, Error> {
        let ring = self.ring();
        if write {
            todo!();
        } else {
            Ok(ring.is_readable())
        }
    }

    /// Sets the process group to which signals from this terminal should be delivered
    fn set_signal_group(&self, id: ProcessId) {
        self.ring().inner.lock().process_group = Some(id);
    }

    /// Sends a single byte to the terminal
    fn line_send(&self, byte: u8) -> Result<(), Error> {
        let config = self.ring().config.lock();

        if byte == b'\n' && config.output.contains(TerminalOutputOptions::NL_TO_CRNL) {
            self.send(b'\r').ok();
        }

        self.send(byte)
    }

    /// Receives a single byte from the terminal
    fn recv_byte(&self, mut byte: u8) {
        let ring = self.ring();
        let config = ring.config.lock();

        if byte == b'\r' && config.input.contains(TerminalInputOptions::CR_TO_NL) {
            byte = b'\n';
        }

        if byte == b'\n' {
            // TODO implement proper echo here
            let _echo = config.line.contains(TerminalLineOptions::ECHO)
                || config
                    .line
                    .contains(TerminalLineOptions::CANONICAL | TerminalLineOptions::ECHO_NL);

            if config.output.contains(TerminalOutputOptions::NL_TO_CRNL) {
                self.send(b'\r').ok();
            }
            self.send(byte).ok();
        } else if config.line.contains(TerminalLineOptions::ECHO) {
            if byte.is_ascii_control() {
                if byte != config.chars.erase && byte != config.chars.werase {
                    self.send(b'^').ok();
                    self.send(byte + 0x40).ok();
                }
            } else {
                self.send(byte).ok();
            }
        }

        // byte == config.chars.interrupt
        if byte == config.chars.interrupt && config.line.contains(TerminalLineOptions::SIGNAL) {
            drop(config);
            let pgrp = ring.inner.lock().process_group;
            if let Some(pgrp) = pgrp {
                Process::signal_group(pgrp, Signal::Interrupted);
                return;
            } else {
                debugln!("Terminal has no process group attached");
            }
        }

        ring.putc(byte, false).ok();
    }

    /// Reads and processes data from the terminal
    fn line_read(&'static self, data: &mut [u8]) -> Result<usize, Error> {
        let ring = self.ring();
        let mut config = ring.config.lock();

        if data.is_empty() {
            return Ok(0);
        }

        if !config.is_canonical() {
            let byte = ring.getc()?;
            data[0] = byte;
            Ok(1)
        } else {
            let mut rem = data.len();
            let mut off = 0;

            // Run until either end of buffer or return condition is reached
            while rem != 0 {
                drop(config);
                let byte = ring.getc()?;
                config = ring.config.lock();

                if config.is_canonical() {
                    if byte == config.chars.eof {
                        break;
                    } else if byte == config.chars.erase {
                        // Erase
                        if off != 0 {
                            self.raw_write(b"\x1b[D \x1b[D")?;
                            off -= 1;
                            rem += 1;
                        }

                        continue;
                    } else if byte == config.chars.werase {
                        todo!()
                    }
                }

                data[off] = byte;
                off += 1;
                rem -= 1;

                if byte == b'\n' || byte == b'\r' {
                    break;
                }
            }

            Ok(off)
        }
    }

    /// Processes and writes the data to the terminal
    fn line_write(&self, data: &[u8]) -> Result<usize, Error> {
        for &byte in data {
            self.line_send(byte)?;
        }
        Ok(data.len())
    }

    /// Writes raw data to the terminal bypassing the processing functions
    fn raw_write(&self, data: &[u8]) -> Result<usize, Error> {
        for &byte in data {
            self.send(byte)?;
        }
        Ok(data.len())
    }
}

impl<const N: usize> CharRingInner<N> {
    #[inline]
    const fn is_readable(&self) -> bool {
        if self.rd <= self.wr {
            (self.wr - self.rd) > 0
        } else {
            (self.wr + (N - self.rd)) > 0
        }
    }

    #[inline]
    unsafe fn read_unchecked(&mut self) -> u8 {
        let res = self.data[self.rd];
        self.rd = (self.rd + 1) % N;
        res
    }

    #[inline]
    unsafe fn write_unchecked(&mut self, ch: u8) {
        self.data[self.wr] = ch;
        self.wr = (self.wr + 1) % N;
    }
}

impl<const N: usize> CharRing<N> {
    /// Constructs an empty ring buffer
    pub const fn new() -> Self {
        Self {
            inner: IrqSafeSpinlock::new(CharRingInner {
                rd: 0,
                wr: 0,
                data: [0; N],
                flags: 0,
                process_group: None,
            }),
            wait_read: Wait::new("char_ring_read"),
            wait_write: Wait::new("char_ring_write"),
            config: IrqSafeSpinlock::new(TerminalOptions::const_default()),
        }
    }

    /// Returns `true` if the buffer has data to read
    pub fn is_readable(&self) -> bool {
        let inner = self.inner.lock();
        let config = self.config.lock();

        if config.is_canonical() {
            let mut rd = inner.rd;
            let mut count = 0usize;

            loop {
                let readable = if rd <= inner.wr {
                    (inner.wr - rd) > 0
                } else {
                    (inner.wr + (N - rd)) > 0
                };

                if !readable {
                    break;
                }

                let byte = inner.data[rd];
                if byte == b'\n' {
                    count += 1;
                }

                rd = (rd + 1) % N;
            }

            count != 0 || inner.flags != 0
        } else {
            inner.is_readable() || inner.flags != 0
        }
    }

    /// Reads a single character from the buffer, blocking until available
    pub fn getc(&'static self) -> Result<u8, Error> {
        let mut lock = self.inner.lock();
        loop {
            if !lock.is_readable() && lock.flags == 0 {
                drop(lock);
                self.wait_read.wait(None)?;
                lock = self.inner.lock();
            } else {
                break;
            }
        }

        let byte = unsafe { lock.read_unchecked() };
        drop(lock);
        self.wait_write.wakeup_one();
        // TODO WAIT_SELECT
        Ok(byte)
    }

    /// Sends a single character to the buffer
    pub fn putc(&self, ch: u8, blocking: bool) -> Result<(), Error> {
        let mut lock = self.inner.lock();
        if blocking {
            todo!();
        }
        unsafe {
            lock.write_unchecked(ch);
        }
        drop(lock);
        self.wait_read.wakeup_one();
        // TODO WAIT_SELECT
        Ok(())
    }
}