Kernel: Move TTY-related files into Kernel/TTY/.

Kernel/TTY/MasterPTY.cpp

@@ -0,0 +1,103 @@
+#include "MasterPTY.h"
+#include "SlavePTY.h"
+#include "PTYMultiplexer.h"
+#include <Kernel/Process.h>
+#include <LibC/errno_numbers.h>
+#include <LibC/signal_numbers.h>
+#include <LibC/sys/ioctl_numbers.h>
+
+//#define MASTERPTY_DEBUG
+
+MasterPTY::MasterPTY(unsigned index)
+    : CharacterDevice(10, index)
+    , m_slave(adopt(*new SlavePTY(*this, index)))
+    , m_index(index)
+{
+    set_uid(current->process().uid());
+    set_gid(current->process().gid());
+}
+
+MasterPTY::~MasterPTY()
+{
+#ifdef MASTERPTY_DEBUG
+    dbgprintf("~MasterPTY(%u)\n", m_index);
+#endif
+    PTYMultiplexer::the().notify_master_destroyed(Badge<MasterPTY>(), m_index);
+}
+
+String MasterPTY::pts_name() const
+{
+    return String::format("/dev/pts/%u", m_index);
+}
+
+ssize_t MasterPTY::read(Process&, byte* buffer, ssize_t size)
+{
+    if (!m_slave && m_buffer.is_empty())
+        return 0;
+    return m_buffer.read(buffer, size);
+}
+
+ssize_t MasterPTY::write(Process&, const byte* buffer, ssize_t size)
+{
+    if (!m_slave)
+        return -EIO;
+    m_slave->on_master_write(buffer, size);
+    return size;
+}
+
+bool MasterPTY::can_read(Process&) const
+{
+    if (!m_slave)
+        return true;
+    return !m_buffer.is_empty();
+}
+
+bool MasterPTY::can_write(Process&) const
+{
+    return true;
+}
+
+void MasterPTY::notify_slave_closed(Badge<SlavePTY>)
+{
+#ifdef MASTERPTY_DEBUG
+    dbgprintf("MasterPTY(%u): slave closed, my retains: %u, slave retains: %u\n", m_index, retain_count(), m_slave->retain_count());
+#endif
+    // +1 retain for my MasterPTY::m_slave
+    // +1 retain for FileDescriptor::m_device
+    if (m_slave->retain_count() == 2)
+        m_slave = nullptr;
+}
+
+ssize_t MasterPTY::on_slave_write(const byte* data, ssize_t size)
+{
+    if (m_closed)
+        return -EIO;
+    m_buffer.write(data, size);
+    return size;
+}
+
+bool MasterPTY::can_write_from_slave() const
+{
+    if (m_closed)
+        return true;
+    return m_buffer.bytes_in_write_buffer() < 4096;
+}
+
+void MasterPTY::close()
+{
+    if (retain_count() == 2) {
+        InterruptDisabler disabler;
+        // After the closing FileDescriptor dies, slave is the only thing keeping me alive.
+        // From this point, let's consider ourselves closed.
+        m_closed = true;
+
+        m_slave->hang_up();
+    }
+}
+
+int MasterPTY::ioctl(Process& process, unsigned request, unsigned arg)
+{
+    if (request == TIOCSWINSZ)
+        return m_slave->ioctl(process, request, arg);
+    return -EINVAL;
+}

Kernel/TTY/MasterPTY.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <AK/Badge.h>
+#include <Kernel/CharacterDevice.h>
+#include <Kernel/DoubleBuffer.h>
+
+class SlavePTY;
+
+class MasterPTY final : public CharacterDevice {
+public:
+    explicit MasterPTY(unsigned index);
+    virtual ~MasterPTY() override;
+
+    unsigned index() const { return m_index; }
+    String pts_name() const;
+    ssize_t on_slave_write(const byte*, ssize_t);
+    bool can_write_from_slave() const;
+    void notify_slave_closed(Badge<SlavePTY>);
+    bool is_closed() const { return m_closed; }
+
+private:
+    // ^CharacterDevice
+    virtual ssize_t read(Process&, byte*, ssize_t) override;
+    virtual ssize_t write(Process&, const byte*, ssize_t) override;
+    virtual bool can_read(Process&) const override;
+    virtual bool can_write(Process&) const override;
+    virtual void close() override;
+    virtual bool is_master_pty() const override { return true; }
+    virtual int ioctl(Process&, unsigned request, unsigned arg) override;
+    virtual const char* class_name() const override { return "MasterPTY"; }
+
+    RetainPtr<SlavePTY> m_slave;
+    unsigned m_index;
+    bool m_closed { false };
+    DoubleBuffer m_buffer;
+};

Kernel/TTY/PTYMultiplexer.cpp

@@ -0,0 +1,51 @@
+#include "PTYMultiplexer.h"
+#include "MasterPTY.h"
+#include <Kernel/Process.h>
+#include <LibC/errno_numbers.h>
+
+//#define PTMX_DEBUG
+
+static const unsigned s_max_pty_pairs = 8;
+static PTYMultiplexer* s_the;
+
+PTYMultiplexer& PTYMultiplexer::the()
+{
+    ASSERT(s_the);
+    return *s_the;
+}
+
+PTYMultiplexer::PTYMultiplexer()
+    : CharacterDevice(5, 2)
+    , m_lock("PTYMultiplexer")
+{
+    s_the = this;
+    m_freelist.ensure_capacity(s_max_pty_pairs);
+    for (int i = s_max_pty_pairs; i > 0; --i)
+        m_freelist.unchecked_append(i - 1);
+}
+
+PTYMultiplexer::~PTYMultiplexer()
+{
+}
+
+KResultOr<Retained<FileDescriptor>> PTYMultiplexer::open(int options)
+{
+    LOCKER(m_lock);
+    if (m_freelist.is_empty())
+        return KResult(-EBUSY);
+    auto master_index = m_freelist.take_last();
+    auto master = adopt(*new MasterPTY(master_index));
+#ifdef PTMX_DEBUG
+    dbgprintf("PTYMultiplexer::open: Vending master %u\n", master->index());
+#endif
+    return VFS::the().open(move(master), options);
+}
+
+void PTYMultiplexer::notify_master_destroyed(Badge<MasterPTY>, unsigned index)
+{
+    LOCKER(m_lock);
+    m_freelist.append(index);
+#ifdef PTMX_DEBUG
+    dbgprintf("PTYMultiplexer: %u added to freelist\n", index);
+#endif
+}

Kernel/TTY/PTYMultiplexer.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <Kernel/CharacterDevice.h>
+#include <AK/Badge.h>
+#include <Kernel/Lock.h>
+
+class MasterPTY;
+
+class PTYMultiplexer final : public CharacterDevice {
+    AK_MAKE_ETERNAL
+public:
+    PTYMultiplexer();
+    virtual ~PTYMultiplexer() override;
+
+    static PTYMultiplexer& the();
+
+    // ^CharacterDevice
+    virtual KResultOr<Retained<FileDescriptor>> open(int options) override;
+    virtual ssize_t read(Process&, byte*, ssize_t) override { return 0; }
+    virtual ssize_t write(Process&, const byte*, ssize_t) override { return 0; }
+    virtual bool can_read(Process&) const override { return true; }
+    virtual bool can_write(Process&) const override { return true; }
+
+    void notify_master_destroyed(Badge<MasterPTY>, unsigned index);
+
+private:
+    // ^CharacterDevice
+    virtual const char* class_name() const override { return "PTYMultiplexer"; }
+
+    Lock m_lock;
+    Vector<unsigned> m_freelist;
+};

Kernel/TTY/SlavePTY.cpp

@@ -0,0 +1,65 @@
+#include "SlavePTY.h"
+#include "MasterPTY.h"
+#include <Kernel/FileSystem/DevPtsFS.h>
+#include <Kernel/Process.h>
+
+//#define SLAVEPTY_DEBUG
+
+SlavePTY::SlavePTY(MasterPTY& master, unsigned index)
+    : TTY(11, index)
+    , m_master(master)
+    , m_index(index)
+{
+    set_uid(current->process().uid());
+    set_gid(current->process().gid());
+    DevPtsFS::the().register_slave_pty(*this);
+    set_size(80, 25);
+}
+
+SlavePTY::~SlavePTY()
+{
+#ifdef SLAVEPTY_DEBUG
+    dbgprintf("~SlavePTY(%u)\n", m_index);
+#endif
+    DevPtsFS::the().unregister_slave_pty(*this);
+}
+
+String SlavePTY::tty_name() const
+{
+    return String::format("/dev/pts/%u", m_index);
+}
+
+void SlavePTY::on_master_write(const byte* buffer, ssize_t size)
+{
+    for (ssize_t i = 0; i < size; ++i)
+        emit(buffer[i]);
+}
+
+ssize_t SlavePTY::on_tty_write(const byte* data, ssize_t size)
+{
+    return m_master->on_slave_write(data, size);
+}
+
+bool SlavePTY::can_write(Process&) const
+{
+    return m_master->can_write_from_slave();
+}
+
+bool SlavePTY::can_read(Process& process) const
+{
+    if (m_master->is_closed())
+        return true;
+    return TTY::can_read(process);
+}
+
+ssize_t SlavePTY::read(Process& process, byte* buffer, ssize_t size)
+{
+    if (m_master->is_closed())
+        return 0;
+    return TTY::read(process, buffer, size);
+}
+
+void SlavePTY::close()
+{
+    m_master->notify_slave_closed(Badge<SlavePTY>());
+}

Kernel/TTY/SlavePTY.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Kernel/TTY/TTY.h>
+
+class MasterPTY;
+
+class SlavePTY final : public TTY {
+public:
+    virtual ~SlavePTY() override;
+
+    void on_master_write(const byte*, ssize_t);
+    unsigned index() const { return m_index; }
+
+    InodeIdentifier devpts_inode_id() const { return m_devpts_inode_id; }
+    void set_devpts_inode_id(InodeIdentifier inode_id) { m_devpts_inode_id = inode_id; }
+
+private:
+    // ^TTY
+    virtual String tty_name() const override;
+    virtual ssize_t on_tty_write(const byte*, ssize_t) override;
+
+    // ^CharacterDevice
+    virtual bool can_read(Process&) const override;
+    virtual ssize_t read(Process&, byte*, ssize_t) override;
+    virtual bool can_write(Process&) const override;
+    virtual const char* class_name() const override { return "SlavePTY"; }
+    virtual void close() override;
+
+    friend class MasterPTY;
+    SlavePTY(MasterPTY&, unsigned index);
+
+    RetainPtr<MasterPTY> m_master;
+    unsigned m_index;
+    InodeIdentifier m_devpts_inode_id;
+};
+

Kernel/TTY/TTY.cpp

@@ -0,0 +1,183 @@
+#include <Kernel/TTY/TTY.h>
+#include "Process.h"
+#include <LibC/errno_numbers.h>
+#include <LibC/signal_numbers.h>
+#include <LibC/sys/ioctl_numbers.h>
+
+//#define TTY_DEBUG
+
+TTY::TTY(unsigned major, unsigned minor)
+    : CharacterDevice(major, minor)
+{
+    set_default_termios();
+}
+
+TTY::~TTY()
+{
+}
+
+void TTY::set_default_termios()
+{
+    memset(&m_termios, 0, sizeof(m_termios));
+    m_termios.c_lflag |= ISIG | ECHO;
+    static const char default_cc[32] = "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0";
+    memcpy(m_termios.c_cc, default_cc, sizeof(default_cc));
+}
+
+ssize_t TTY::read(Process&, byte* buffer, ssize_t size)
+{
+    return m_buffer.read(buffer, size);
+}
+
+ssize_t TTY::write(Process&, const byte* buffer, ssize_t size)
+{
+#ifdef TTY_DEBUG
+    dbgprintf("TTY::write {%u} ", size);
+    for (size_t i = 0; i < size; ++i) {
+        dbgprintf("%b ", buffer[i]);
+    }
+    dbgprintf("\n");
+#endif
+    on_tty_write(buffer, size);
+    return size;
+}
+
+bool TTY::can_read(Process&) const
+{
+    return !m_buffer.is_empty();
+}
+
+bool TTY::can_write(Process&) const
+{
+    return true;
+}
+
+void TTY::emit(byte ch)
+{
+    if (should_generate_signals()) {
+        if (ch == m_termios.c_cc[VINTR]) {
+            dbgprintf("%s: VINTR pressed!\n", tty_name().characters());
+            generate_signal(SIGINT);
+            return;
+        }
+        if (ch == m_termios.c_cc[VQUIT]) {
+            dbgprintf("%s: VQUIT pressed!\n", tty_name().characters());
+            generate_signal(SIGQUIT);
+            return;
+        }
+    }
+    m_buffer.write(&ch, 1);
+}
+
+void TTY::generate_signal(int signal)
+{
+    if (!pgid())
+        return;
+    dbgprintf("%s: Send signal %d to everyone in pgrp %d\n", tty_name().characters(), signal, pgid());
+    InterruptDisabler disabler; // FIXME: Iterate over a set of process handles instead?
+    Process::for_each_in_pgrp(pgid(), [&] (auto& process) {
+        dbgprintf("%s: Send signal %d to %d\n", tty_name().characters(), signal, process.pid());
+        process.send_signal(signal, nullptr);
+        return true;
+    });
+}
+
+void TTY::set_termios(const termios& t)
+{
+    m_termios = t;
+    dbgprintf("%s set_termios: ECHO=%u, ISIG=%u, ICANON=%u\n",
+        tty_name().characters(),
+        should_echo_input(),
+        should_generate_signals(),
+        in_canonical_mode()
+    );
+    dbgprintf("%s set_termios: ECHOE=%u, ECHOK=%u, ECHONL=%u\n",
+              tty_name().characters(),
+              (m_termios.c_lflag & ECHOE) != 0,
+              (m_termios.c_lflag & ECHOK) != 0,
+              (m_termios.c_lflag & ECHONL) != 0
+              );
+    dbgprintf("%s set_termios: ISTRIP=%u, ICRNL=%u, INLCR=%u, IGNCR=%u\n",
+              tty_name().characters(),
+              (m_termios.c_iflag & ISTRIP) != 0,
+              (m_termios.c_iflag & ICRNL) != 0,
+              (m_termios.c_iflag & INLCR) != 0,
+              (m_termios.c_iflag & IGNCR) != 0
+              );
+}
+
+int TTY::ioctl(Process& process, unsigned request, unsigned arg)
+{
+    pid_t pgid;
+    termios* tp;
+    winsize* ws;
+
+#if 0
+    // FIXME: When should we block things?
+    //        How do we make this work together with MasterPTY forwarding to us?
+    if (process.tty() && process.tty() != this) {
+        return -ENOTTY;
+    }
+#endif
+    switch (request) {
+    case TIOCGPGRP:
+        return m_pgid;
+    case TIOCSPGRP:
+        // FIXME: Validate pgid fully.
+        pgid = static_cast<pid_t>(arg);
+        if (pgid < 0)
+            return -EINVAL;
+        m_pgid = pgid;
+        return 0;
+    case TCGETS:
+        tp = reinterpret_cast<termios*>(arg);
+        if (!process.validate_write(tp, sizeof(termios)))
+            return -EFAULT;
+        *tp = m_termios;
+        return 0;
+    case TCSETS:
+    case TCSETSF:
+    case TCSETSW:
+        tp = reinterpret_cast<termios*>(arg);
+        if (!process.validate_read(tp, sizeof(termios)))
+            return -EFAULT;
+        set_termios(*tp);
+        return 0;
+    case TIOCGWINSZ:
+        ws = reinterpret_cast<winsize*>(arg);
+        if (!process.validate_write(ws, sizeof(winsize)))
+            return -EFAULT;
+        ws->ws_row = m_rows;
+        ws->ws_col = m_columns;
+        return 0;
+    case TIOCSWINSZ:
+        ws = reinterpret_cast<winsize*>(arg);
+        if (!process.validate_read(ws, sizeof(winsize)))
+            return -EFAULT;
+        if (ws->ws_col == m_columns && ws->ws_row == m_rows)
+            return 0;
+        m_rows = ws->ws_row;
+        m_columns = ws->ws_col;
+        generate_signal(SIGWINCH);
+        return 0;
+    case TIOCSCTTY:
+        process.set_tty(this);
+        return 0;
+    case TIOCNOTTY:
+        process.set_tty(nullptr);
+        return 0;
+    }
+    ASSERT_NOT_REACHED();
+    return -EINVAL;
+}
+
+void TTY::set_size(unsigned short columns, unsigned short rows)
+{
+    m_rows = rows;
+    m_columns = columns;
+}
+
+void TTY::hang_up()
+{
+    generate_signal(SIGHUP);
+}

Kernel/TTY/TTY.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "DoubleBuffer.h"
+#include <Kernel/CharacterDevice.h>
+#include <Kernel/UnixTypes.h>
+
+class Process;
+
+class TTY : public CharacterDevice {
+public:
+    virtual ~TTY() override;
+
+    virtual ssize_t read(Process&, byte*, ssize_t) override;
+    virtual ssize_t write(Process&, const byte*, ssize_t) override;
+    virtual bool can_read(Process&) const override;
+    virtual bool can_write(Process&) const override;
+    virtual int ioctl(Process&, unsigned request, unsigned arg) override final;
+
+    virtual String tty_name() const = 0;
+
+    unsigned short rows() const { return m_rows; }
+    unsigned short columns() const { return m_columns; }
+
+    void set_pgid(pid_t pgid) { m_pgid = pgid; }
+    pid_t pgid() const { return m_pgid; }
+
+    void set_termios(const termios&);
+    bool should_generate_signals() const { return m_termios.c_lflag & ISIG; }
+    bool should_echo_input() const { return m_termios.c_lflag & ECHO; }
+    bool in_canonical_mode() const { return m_termios.c_lflag & ICANON; }
+
+    void set_default_termios();
+    void hang_up();
+
+protected:
+    virtual ssize_t on_tty_write(const byte*, ssize_t) = 0;
+    void set_size(unsigned short columns, unsigned short rows);
+
+    TTY(unsigned major, unsigned minor);
+    void emit(byte);
+
+    void generate_signal(int signal);
+
+private:
+    // ^CharacterDevice
+    virtual bool is_tty() const final override { return true; }
+
+    DoubleBuffer m_buffer;
+    pid_t m_pgid { 0 };
+    termios m_termios;
+    unsigned short m_rows { 0 };
+    unsigned short m_columns { 0 };
+};
+

Kernel/TTY/VirtualConsole.cpp

@@ -0,0 +1,524 @@
+#include "VirtualConsole.h"
+#include "kmalloc.h"
+#include "i386.h"
+#include "IO.h"
+#include "StdLib.h"
+#include "KeyboardDevice.h"
+#include <AK/AKString.h>
+
+static byte* s_vga_buffer;
+static VirtualConsole* s_consoles[6];
+static int s_active_console;
+
+void VirtualConsole::get_vga_cursor(byte& row, byte& column)
+{
+    word value;
+    IO::out8(0x3d4, 0x0e);
+    value = IO::in8(0x3d5) << 8;
+    IO::out8(0x3d4, 0x0f);
+    value |= IO::in8(0x3d5);
+    row = value / columns();
+    column = value % columns();
+}
+
+void VirtualConsole::flush_vga_cursor()
+{
+    word value = m_current_vga_start_address + (m_cursor_row * columns() + m_cursor_column);
+    IO::out8(0x3d4, 0x0e);
+    IO::out8(0x3d5, MSB(value));
+    IO::out8(0x3d4, 0x0f);
+    IO::out8(0x3d5, LSB(value));
+}
+
+void VirtualConsole::initialize()
+{
+    s_vga_buffer = (byte*)0xb8000;
+    memset(s_consoles, 0, sizeof(s_consoles));
+    s_active_console = -1;
+}
+
+VirtualConsole::VirtualConsole(unsigned index, InitialContents initial_contents)
+    : TTY(4, index)
+    , m_index(index)
+{
+    set_size(80, 25);
+    m_horizontal_tabs = static_cast<byte*>(kmalloc(columns()));
+    for (unsigned i = 0; i < columns(); ++i)
+        m_horizontal_tabs[i] = (i % 8) == 0;
+    // Rightmost column is always last tab on line.
+    m_horizontal_tabs[columns() - 1] = 1;
+
+    s_consoles[index] = this;
+    m_buffer = (byte*)kmalloc_eternal(rows() * columns() * 2);
+    if (initial_contents == AdoptCurrentVGABuffer) {
+        memcpy(m_buffer, s_vga_buffer, rows() * columns() * 2);
+        get_vga_cursor(m_cursor_row, m_cursor_column);
+    } else {
+        word* line_mem = reinterpret_cast<word*>(m_buffer);
+        for (word i = 0; i < rows() * columns(); ++i)
+            line_mem[i] = 0x0720;
+    }
+}
+
+VirtualConsole::~VirtualConsole()
+{
+    kfree(m_horizontal_tabs);
+    m_horizontal_tabs = nullptr;
+}
+
+void VirtualConsole::clear()
+{
+    word* linemem = m_active ? (word*)s_vga_buffer : (word*)m_buffer;
+    for (word i = 0; i < rows() * columns(); ++i)
+        linemem[i] = 0x0720;
+    if (m_active)
+        set_vga_start_row(0);
+    set_cursor(0, 0);
+}
+
+void VirtualConsole::switch_to(unsigned index)
+{
+    if ((int)index == s_active_console)
+        return;
+    dbgprintf("VC: Switch to %u (%p)\n", index, s_consoles[index]);
+    ASSERT(index < 6);
+    ASSERT(s_consoles[index]);
+    InterruptDisabler disabler;
+    if (s_active_console != -1)
+        s_consoles[s_active_console]->set_active(false);
+    s_active_console = index;
+    s_consoles[s_active_console]->set_active(true);
+    Console::the().set_implementation(s_consoles[s_active_console]);
+}
+
+void VirtualConsole::set_active(bool b)
+{
+    if (b == m_active)
+        return;
+
+    InterruptDisabler disabler;
+
+    m_active = b;
+    if (!m_active) {
+        memcpy(m_buffer, m_current_vga_window, rows() * columns() * 2);
+        return;
+    }
+
+    memcpy(s_vga_buffer, m_buffer, rows() * columns() * 2);
+    set_vga_start_row(0);
+    flush_vga_cursor();
+
+#if 0
+    Keyboard::the().set_client(this);
+#endif
+}
+
+inline bool is_valid_parameter_character(byte ch)
+{
+    return ch >= 0x30 && ch <= 0x3f;
+}
+
+inline bool is_valid_intermediate_character(byte ch)
+{
+    return ch >= 0x20 && ch <= 0x2f;
+}
+
+inline bool is_valid_final_character(byte ch)
+{
+    return ch >= 0x40 && ch <= 0x7e;
+}
+
+unsigned parse_uint(const String& str, bool& ok)
+{
+    unsigned value = 0;
+    for (size_t i = 0; i < str.length(); ++i) {
+        if (str[i] < '0' || str[i] > '9') {
+            ok = false;
+            return 0;
+        }
+        value = value * 10;
+        value += str[i] - '0';
+    }
+    ok = true;
+    return value;
+}
+
+enum class VGAColor : byte {
+    Black = 0,
+    Blue,
+    Green,
+    Cyan,
+    Red,
+    Magenta,
+    Brown,
+    LightGray,
+    DarkGray,
+    BrightBlue,
+    BrightGreen,
+    BrightCyan,
+    BrightRed,
+    BrightMagenta,
+    Yellow,
+    White,
+};
+
+enum class ANSIColor : byte {
+    Black = 0,
+    Red,
+    Green,
+    Brown,
+    Blue,
+    Magenta,
+    Cyan,
+    LightGray,
+    DarkGray,
+    BrightRed,
+    BrightGreen,
+    Yellow,
+    BrightBlue,
+    BrightMagenta,
+    BrightCyan,
+    White,
+};
+
+static inline VGAColor ansi_color_to_vga(ANSIColor color)
+{
+    switch (color) {
+    case ANSIColor::Black: return VGAColor::Black;
+    case ANSIColor::Red: return VGAColor::Red;
+    case ANSIColor::Brown: return VGAColor::Brown;
+    case ANSIColor::Blue: return VGAColor::Blue;
+    case ANSIColor::Magenta: return VGAColor::Magenta;
+    case ANSIColor::Green: return VGAColor::Green;
+    case ANSIColor::Cyan: return VGAColor::Cyan;
+    case ANSIColor::LightGray: return VGAColor::LightGray;
+    case ANSIColor::DarkGray: return VGAColor::DarkGray;
+    case ANSIColor::BrightRed: return VGAColor::BrightRed;
+    case ANSIColor::BrightGreen: return VGAColor::BrightGreen;
+    case ANSIColor::Yellow: return VGAColor::Yellow;
+    case ANSIColor::BrightBlue: return VGAColor::BrightBlue;
+    case ANSIColor::BrightMagenta: return VGAColor::BrightMagenta;
+    case ANSIColor::BrightCyan: return VGAColor::BrightCyan;
+    case ANSIColor::White: return VGAColor::White;
+    }
+    ASSERT_NOT_REACHED();
+    return VGAColor::LightGray;
+}
+
+static inline byte ansi_color_to_vga(byte color)
+{
+    return (byte)ansi_color_to_vga((ANSIColor)color);
+}
+
+void VirtualConsole::escape$m(const Vector<unsigned>& params)
+{
+    for (auto param : params) {
+        switch (param) {
+        case 0:
+            // Reset
+            m_current_attribute = 0x07;
+            break;
+        case 1:
+            // Bold
+            m_current_attribute |= 8;
+            break;
+        case 30:
+        case 31:
+        case 32:
+        case 33:
+        case 34:
+        case 35:
+        case 36:
+        case 37:
+            // Foreground color
+            m_current_attribute &= ~0x7;
+            m_current_attribute |= ansi_color_to_vga(param - 30);
+            break;
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+        case 45:
+        case 46:
+        case 47:
+            // Background color
+            m_current_attribute &= ~0x70;
+            m_current_attribute |= ansi_color_to_vga(param - 30) << 8;
+            break;
+        }
+    }
+}
+
+void VirtualConsole::escape$s(const Vector<unsigned>&)
+{
+    m_saved_cursor_row = m_cursor_row;
+    m_saved_cursor_column = m_cursor_column;
+}
+
+void VirtualConsole::escape$u(const Vector<unsigned>&)
+{
+    set_cursor(m_saved_cursor_row, m_saved_cursor_column);
+}
+
+void VirtualConsole::escape$H(const Vector<unsigned>& params)
+{
+    unsigned row = 1;
+    unsigned col = 1;
+    if (params.size() >= 1)
+        row = params[0];
+    if (params.size() >= 2)
+        col = params[1];
+    set_cursor(row - 1, col - 1);
+}
+
+void VirtualConsole::escape$A(const Vector<unsigned>& params)
+{
+    int num = 1;
+    if (params.size() >= 1)
+        num = params[0];
+    int new_row = (int)m_cursor_row - num;
+    if (new_row < 0)
+        new_row = 0;
+    set_cursor(new_row, m_cursor_column);
+}
+
+void VirtualConsole::escape$D(const Vector<unsigned>& params)
+{
+    int num = 1;
+    if (params.size() >= 1)
+        num = params[0];
+    int new_column = (int)m_cursor_column - num;
+    if (new_column < 0)
+        new_column = 0;
+    set_cursor(m_cursor_row, new_column);
+}
+
+void VirtualConsole::escape$J(const Vector<unsigned>& params)
+{
+    int mode = 0;
+    if (params.size() >= 1)
+        mode = params[0];
+    switch (mode) {
+    case 0:
+        // FIXME: Clear from cursor to end of screen.
+        not_implemented();
+        break;
+    case 1:
+        // FIXME: Clear from cursor to beginning of screen.
+        not_implemented();
+        break;
+    case 2:
+        clear();
+        break;
+    case 3:
+        // FIXME: <esc>[3J should also clear the scrollback buffer.
+        clear();
+        break;
+    }
+}
+
+void VirtualConsole::execute_escape_sequence(byte final)
+{
+    auto paramparts = String((const char*)m_parameters.data(), m_parameters.size()).split(';');
+    Vector<unsigned> params;
+    for (auto& parampart : paramparts) {
+        bool ok;
+        unsigned value = parse_uint(parampart, ok);
+        if (!ok) {
+            // FIXME: Should we do something else?
+            return;
+        }
+        params.append(value);
+    }
+    switch (final) {
+    case 'A': escape$A(params); break;
+    case 'D': escape$D(params); break;
+    case 'H': escape$H(params); break;
+    case 'J': escape$J(params); break;
+    case 'm': escape$m(params); break;
+    case 's': escape$s(params); break;
+    case 'u': escape$u(params); break;
+    default: break;
+    }
+
+    m_parameters.clear();
+    m_intermediates.clear();
+}
+
+void VirtualConsole::clear_vga_row(word row)
+{
+    word* linemem = (word*)&m_current_vga_window[row * 160];
+    for (word i = 0; i < columns(); ++i)
+        linemem[i] = 0x0720;
+}
+
+void VirtualConsole::scroll_up()
+{
+    if (m_cursor_row == (rows() - 1)) {
+        if (m_active) {
+            if (m_vga_start_row >= 160) {
+                memcpy(s_vga_buffer, m_current_vga_window + 160, (rows() - 1) * columns() * 2);
+                set_vga_start_row(0);
+                clear_vga_row(24);
+            } else {
+                set_vga_start_row(m_vga_start_row + 1);
+                clear_vga_row(24);
+            }
+        } else {
+            memcpy(m_buffer, m_buffer + 160, 160 * 24);
+            word* linemem = (word*)&m_buffer[24 * 160];
+            for (word i = 0; i < columns(); ++i)
+                linemem[i] = 0x0720;
+        }
+    } else {
+        ++m_cursor_row;
+    }
+    m_cursor_column = 0;
+}
+
+void VirtualConsole::set_cursor(unsigned row, unsigned column)
+{
+    ASSERT(row < rows());
+    ASSERT(column < columns());
+    m_cursor_row = row;
+    m_cursor_column = column;
+    if (m_active)
+        flush_vga_cursor();
+}
+
+void VirtualConsole::put_character_at(unsigned row, unsigned column, byte ch)
+{
+    ASSERT(row < rows());
+    ASSERT(column < columns());
+    word cur = (row * 160) + (column * 2);
+    if (m_active) {
+        word cur = (row * 160) + (column * 2);
+        m_current_vga_window[cur] = ch;
+        m_current_vga_window[cur + 1] = m_current_attribute;
+    } else {
+        m_buffer[cur] = ch;
+        m_buffer[cur + 1] = m_current_attribute;
+    }
+}
+
+void VirtualConsole::on_char(byte ch)
+{
+    switch (m_escape_state) {
+    case ExpectBracket:
+        if (ch == '[')
+            m_escape_state = ExpectParameter;
+        else
+            m_escape_state = Normal;
+        return;
+    case ExpectParameter:
+        if (is_valid_parameter_character(ch)) {
+            m_parameters.append(ch);
+            return;
+        }
+        m_escape_state = ExpectIntermediate;
+        [[fallthrough]];
+    case ExpectIntermediate:
+        if (is_valid_intermediate_character(ch)) {
+            m_intermediates.append(ch);
+            return;
+        }
+        m_escape_state = ExpectFinal;
+        [[fallthrough]];
+    case ExpectFinal:
+        if (is_valid_final_character(ch)) {
+            m_escape_state = Normal;
+            execute_escape_sequence(ch);
+            return;
+        }
+        m_escape_state = Normal;
+        return;
+    case Normal:
+        break;
+    }
+
+    switch (ch) {
+    case '\0':
+        return;
+    case '\033':
+        m_escape_state = ExpectBracket;
+        return;
+    case 8: // Backspace
+        if (m_cursor_column) {
+            set_cursor(m_cursor_row, m_cursor_column - 1);
+            put_character_at(m_cursor_row, m_cursor_column, ' ');
+            return;
+        }
+        break;
+    case '\a':
+        // FIXME: Bell!
+        return;
+    case '\t': {
+        for (unsigned i = m_cursor_column; i < columns(); ++i) {
+            if (m_horizontal_tabs[i]) {
+                set_cursor(m_cursor_row, i);
+                return;
+            }
+        }
+        return;
+    }
+    case '\n':
+        scroll_up();
+        set_cursor(m_cursor_row, m_cursor_column);
+        return;
+    }
+
+    put_character_at(m_cursor_row, m_cursor_column, ch);
+
+    ++m_cursor_column;
+    if (m_cursor_column >= columns())
+        scroll_up();
+    set_cursor(m_cursor_row, m_cursor_column);
+}
+
+void VirtualConsole::on_key_pressed(KeyboardDevice::Event key)
+{
+    if (key.ctrl()) {
+        if (key.character >= 'a' && key.character <= 'z') {
+            emit(key.character - 'a' + 1);
+            return;
+        } else if (key.character == '\\') {
+            emit(0x1c);
+            return;
+        }
+    }
+    emit(key.character);
+}
+
+void VirtualConsole::on_sysconsole_receive(byte ch)
+{
+    InterruptDisabler disabler;
+    auto old_attribute = m_current_attribute;
+    m_current_attribute = 0x03;
+    on_char(ch);
+    m_current_attribute = old_attribute;
+}
+
+ssize_t VirtualConsole::on_tty_write(const byte* data, ssize_t size)
+{
+    InterruptDisabler disabler;
+    for (ssize_t i = 0; i < size; ++i)
+        on_char(data[i]);
+    return size;
+}
+
+String VirtualConsole::tty_name() const
+{
+    return String::format("/dev/tty%u", m_index);
+}
+
+void VirtualConsole::set_vga_start_row(word row)
+{
+    m_vga_start_row = row;
+    m_current_vga_start_address = row * columns();
+    m_current_vga_window = s_vga_buffer + row * 160;
+    IO::out8(0x3d4, 0x0c);
+    IO::out8(0x3d5, MSB(m_current_vga_start_address));
+    IO::out8(0x3d4, 0x0d);
+    IO::out8(0x3d5, LSB(m_current_vga_start_address));
+}

Kernel/TTY/VirtualConsole.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <Kernel/TTY/TTY.h>
+#include "KeyboardDevice.h"
+#include "Console.h"
+
+class VirtualConsole final : public TTY, public KeyboardClient, public ConsoleImplementation {
+    AK_MAKE_ETERNAL
+public:
+    enum InitialContents { Cleared, AdoptCurrentVGABuffer };
+
+    VirtualConsole(unsigned index, InitialContents = Cleared);
+    virtual ~VirtualConsole() override;
+
+    static void switch_to(unsigned);
+    static void initialize();
+
+private:
+    // ^KeyboardClient
+    virtual void on_key_pressed(KeyboardDevice::Event) override;
+
+    // ^ConsoleImplementation
+    virtual void on_sysconsole_receive(byte) override;
+
+    // ^TTY
+    virtual ssize_t on_tty_write(const byte*, ssize_t) override;
+    virtual String tty_name() const override;
+
+    // ^CharacterDevice
+    virtual const char* class_name() const override { return "VirtualConsole"; }
+
+    void set_active(bool);
+    void on_char(byte);
+
+    void get_vga_cursor(byte& row, byte& column);
+    void flush_vga_cursor();
+
+    byte* m_buffer;
+    unsigned m_index;
+    bool m_active { false };
+
+    void scroll_up();
+    void set_cursor(unsigned row, unsigned column);
+    void put_character_at(unsigned row, unsigned column, byte ch);
+
+    void escape$A(const Vector<unsigned>&);
+    void escape$D(const Vector<unsigned>&);
+    void escape$H(const Vector<unsigned>&);
+    void escape$J(const Vector<unsigned>&);
+    void escape$m(const Vector<unsigned>&);
+    void escape$s(const Vector<unsigned>&);
+    void escape$u(const Vector<unsigned>&);
+
+    void clear();
+
+    byte m_cursor_row { 0 };
+    byte m_cursor_column { 0 };
+    byte m_saved_cursor_row { 0 };
+    byte m_saved_cursor_column { 0 };
+    byte m_current_attribute { 0x07 };
+
+    void clear_vga_row(word row);
+    void set_vga_start_row(word row);
+    word m_vga_start_row { 0 };
+    word m_current_vga_start_address { 0 };
+    byte* m_current_vga_window { nullptr };
+
+    void execute_escape_sequence(byte final);
+
+    enum EscapeState {
+        Normal,
+        ExpectBracket,
+        ExpectParameter,
+        ExpectIntermediate,
+        ExpectFinal,
+    };
+    EscapeState m_escape_state { Normal };
+    Vector<byte> m_parameters;
+    Vector<byte> m_intermediates;
+    byte* m_horizontal_tabs { nullptr };
+};