mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 13:57:35 +00:00
Kernel: Move TTY-related files into Kernel/TTY/.
This commit is contained in:
parent
f9864940eb
commit
9fca94269e
17 changed files with 16 additions and 16 deletions
103
Kernel/TTY/MasterPTY.cpp
Normal file
103
Kernel/TTY/MasterPTY.cpp
Normal file
|
@ -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;
|
||||
}
|
36
Kernel/TTY/MasterPTY.h
Normal file
36
Kernel/TTY/MasterPTY.h
Normal file
|
@ -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;
|
||||
};
|
51
Kernel/TTY/PTYMultiplexer.cpp
Normal file
51
Kernel/TTY/PTYMultiplexer.cpp
Normal file
|
@ -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
|
||||
}
|
32
Kernel/TTY/PTYMultiplexer.h
Normal file
32
Kernel/TTY/PTYMultiplexer.h
Normal file
|
@ -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;
|
||||
};
|
65
Kernel/TTY/SlavePTY.cpp
Normal file
65
Kernel/TTY/SlavePTY.cpp
Normal file
|
@ -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>());
|
||||
}
|
36
Kernel/TTY/SlavePTY.h
Normal file
36
Kernel/TTY/SlavePTY.h
Normal file
|
@ -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;
|
||||
};
|
||||
|
183
Kernel/TTY/TTY.cpp
Normal file
183
Kernel/TTY/TTY.cpp
Normal file
|
@ -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);
|
||||
}
|
54
Kernel/TTY/TTY.h
Normal file
54
Kernel/TTY/TTY.h
Normal file
|
@ -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 };
|
||||
};
|
||||
|
524
Kernel/TTY/VirtualConsole.cpp
Normal file
524
Kernel/TTY/VirtualConsole.cpp
Normal file
|
@ -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));
|
||||
}
|
81
Kernel/TTY/VirtualConsole.h
Normal file
81
Kernel/TTY/VirtualConsole.h
Normal file
|
@ -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 };
|
||||
};
|
Loading…
Add table
Add a link
Reference in a new issue