1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 22:57:44 +00:00

More coding style changes.

This commit is contained in:
Andreas Kling 2018-12-03 00:39:25 +01:00
parent d824442e3e
commit f6e27c2abe
39 changed files with 216 additions and 216 deletions

View file

@ -23,7 +23,7 @@ Console::~Console()
{
}
bool Console::hasDataAvailableForRead() const
bool Console::has_data_available_for_reading() const
{
return false;
}
@ -53,7 +53,7 @@ void Console::putChar(char ch)
IO::out8(0xe9, ch);
#endif
if (m_implementation)
m_implementation->onConsoleReceive(ch);
m_implementation->on_sysconsole_receive(ch);
}
ConsoleImplementation::~ConsoleImplementation()

View file

@ -7,7 +7,7 @@
class ConsoleImplementation {
public:
virtual ~ConsoleImplementation();
virtual void onConsoleReceive(byte) = 0;
virtual void on_sysconsole_receive(byte) = 0;
};
class Console final : public CharacterDevice {
@ -18,7 +18,7 @@ public:
Console();
virtual ~Console() override;
virtual bool hasDataAvailableForRead() const override;
virtual bool has_data_available_for_reading() const override;
virtual ssize_t read(byte* buffer, size_t size) override;
virtual ssize_t write(const byte* data, size_t size) override;

View file

@ -46,7 +46,7 @@ void FIFO::close(Direction direction)
bool FIFO::can_read() const
{
return !m_queue.isEmpty() || !m_writers;
return !m_queue.is_empty() || !m_writers;
}
bool FIFO::can_write() const
@ -59,7 +59,7 @@ bool FIFO::can_write() const
ssize_t FIFO::read(byte* buffer, size_t size)
{
if (!m_writers && m_queue.isEmpty())
if (!m_writers && m_queue.is_empty())
return 0;
#ifdef FIFO_DEBUG
dbgprintf("fifo: read(%u)\n",size);

View file

@ -100,7 +100,7 @@ bool IDEDiskDevice::wait_for_irq()
return true;
}
void IDEDiskDevice::handleIRQ()
void IDEDiskDevice::handle_irq()
{
#ifdef DISK_DEBUG
byte status = IO::in8(0x1f7);
@ -123,13 +123,13 @@ void IDEDiskDevice::initialize()
while (IO::in8(IDE0_STATUS) & BUSY);
enableIRQ();
enable_irq();
IO::out8(0x1F6, 0xA0); // 0xB0 for 2nd device
IO::out8(0x3F6, 0xA0); // 0xB0 for 2nd device
IO::out8(IDE0_COMMAND, IDENTIFY_DRIVE);
enableIRQ();
enable_irq();
wait_for_irq();
ByteBuffer wbuf = ByteBuffer::createUninitialized(512);
@ -180,7 +180,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
count,
start_sector);
#endif
disableIRQ();
disable_irq();
auto chs = lba_to_chs(start_sector);
@ -202,7 +202,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
IO::out8(IDE0_COMMAND, READ_SECTORS);
m_interrupted = false;
enableIRQ();
enable_irq();
wait_for_irq();
byte status = IO::in8(0x1f7);
@ -228,7 +228,7 @@ bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* da
current->pid(),
count,
start_sector);
disableIRQ();
disable_irq();
auto chs = lba_to_chs(start_sector);
@ -259,7 +259,7 @@ bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* da
}
m_interrupted = false;
enableIRQ();
enable_irq();
wait_for_irq();
return true;

View file

@ -20,7 +20,7 @@ protected:
private:
// ^IRQHandler
virtual void handleIRQ() override;
virtual void handle_irq() override;
// ^DiskDevice
virtual const char* class_name() const override;

View file

@ -3,23 +3,23 @@
#include "PIC.h"
IRQHandler::IRQHandler(byte irq)
: m_irqNumber(irq)
: m_irq_number(irq)
{
registerIRQHandler(m_irqNumber, *this);
register_irq_handler(m_irq_number, *this);
}
IRQHandler::~IRQHandler()
{
unregisterIRQHandler(m_irqNumber, *this);
unregister_irq_handler(m_irq_number, *this);
}
void IRQHandler::enableIRQ()
void IRQHandler::enable_irq()
{
PIC::enable(m_irqNumber);
PIC::enable(m_irq_number);
}
void IRQHandler::disableIRQ()
void IRQHandler::disable_irq()
{
PIC::disable(m_irqNumber);
PIC::disable(m_irq_number);
}

View file

@ -5,17 +5,17 @@
class IRQHandler {
public:
virtual ~IRQHandler();
virtual void handleIRQ() = 0;
virtual void handle_irq() = 0;
byte irqNumber() const { return m_irqNumber; }
byte irq_number() const { return m_irq_number; }
void enableIRQ();
void disableIRQ();
void enable_irq();
void disable_irq();
protected:
explicit IRQHandler(byte irq);
private:
byte m_irqNumber { 0 };
byte m_irq_number { 0 };
};

View file

@ -43,11 +43,11 @@ void Keyboard::emit(byte ch)
key.character = ch;
key.modifiers = m_modifiers;
if (m_client)
m_client->onKeyPress(key);
m_client->on_key_pressed(key);
m_queue.enqueue(key);
}
void Keyboard::handleIRQ()
void Keyboard::handle_irq()
{
while (IO::in8(0x64) & 1) {
byte ch = IO::in8(0x60);
@ -107,23 +107,23 @@ Keyboard::Keyboard()
while (IO::in8(I8042_STATUS ) & DATA_AVAILABLE)
IO::in8(I8042_BUFFER);
enableIRQ();
enable_irq();
}
Keyboard::~Keyboard()
{
}
bool Keyboard::hasDataAvailableForRead() const
bool Keyboard::has_data_available_for_reading() const
{
return !m_queue.isEmpty();
return !m_queue.is_empty();
}
ssize_t Keyboard::read(byte* buffer, size_t size)
{
ssize_t nread = 0;
while ((size_t)nread < size) {
if (m_queue.isEmpty())
if (m_queue.is_empty())
break;
buffer[nread++] = m_queue.dequeue().character;
}

View file

@ -30,16 +30,16 @@ public:
virtual ~Keyboard() override;
Keyboard();
void setClient(KeyboardClient* client) { m_client = client; }
void set_client(KeyboardClient* client) { m_client = client; }
private:
// ^IRQHandler
virtual void handleIRQ() override;
virtual void handle_irq() override;
// ^CharacterDevice
virtual ssize_t read(byte* buffer, size_t) override;
virtual ssize_t write(const byte* buffer, size_t) override;
virtual bool hasDataAvailableForRead() const override;
virtual bool has_data_available_for_reading() const override;
void emit(byte);
@ -51,5 +51,5 @@ private:
class KeyboardClient {
public:
virtual ~KeyboardClient();
virtual void onKeyPress(Keyboard::Key) = 0;
virtual void on_key_pressed(Keyboard::Key) = 0;
};

View file

@ -167,30 +167,30 @@ ByteBuffer procfs$pid_cwd(Process& process)
return VFS::the().absolute_path(*inode).toByteBuffer();
}
void ProcFS::addProcess(Process& process)
void ProcFS::add_process(Process& process)
{
InterruptDisabler disabler;
char buf[16];
ksprintf(buf, "%d", process.pid());
auto dir = addFile(create_directory(buf));
auto dir = add_file(create_directory(buf));
m_pid2inode.set(process.pid(), dir.index());
addFile(create_generated_file("vm", [&process] { return procfs$pid_vm(process); }), dir.index());
addFile(create_generated_file("vmo", [&process] { return procfs$pid_vmo(process); }), dir.index());
addFile(create_generated_file("stack", [&process] { return procfs$pid_stack(process); }), dir.index());
addFile(create_generated_file("regs", [&process] { return procfs$pid_regs(process); }), dir.index());
addFile(create_generated_file("fds", [&process] { return procfs$pid_fds(process); }), dir.index());
add_file(create_generated_file("vm", [&process] { return procfs$pid_vm(process); }), dir.index());
add_file(create_generated_file("vmo", [&process] { return procfs$pid_vmo(process); }), dir.index());
add_file(create_generated_file("stack", [&process] { return procfs$pid_stack(process); }), dir.index());
add_file(create_generated_file("regs", [&process] { return procfs$pid_regs(process); }), dir.index());
add_file(create_generated_file("fds", [&process] { return procfs$pid_fds(process); }), dir.index());
if (process.executable_inode())
addFile(create_generated_file("exe", [&process] { return procfs$pid_exe(process); }, 00120777), dir.index());
addFile(create_generated_file("cwd", [&process] { return procfs$pid_cwd(process); }, 00120777), dir.index());
add_file(create_generated_file("exe", [&process] { return procfs$pid_exe(process); }, 00120777), dir.index());
add_file(create_generated_file("cwd", [&process] { return procfs$pid_cwd(process); }, 00120777), dir.index());
}
void ProcFS::removeProcess(Process& process)
void ProcFS::remove_process(Process& process)
{
InterruptDisabler disabler;
auto pid = process.pid();
auto it = m_pid2inode.find(pid);
ASSERT(it != m_pid2inode.end());
bool success = removeFile((*it).value);
bool success = remove_file((*it).value);
ASSERT(success);
m_pid2inode.remove(pid);
}
@ -341,7 +341,7 @@ ByteBuffer procfs$summary()
process->ppid(),
process->timesScheduled(),
process->number_of_open_file_descriptors(),
process->tty() ? strrchr(process->tty()->ttyName().characters(), '/') + 1 : "n/a",
process->tty() ? strrchr(process->tty()->tty_name().characters(), '/') + 1 : "n/a",
process->name().characters());
}
*ptr = '\0';
@ -364,8 +364,8 @@ ByteBuffer procfs$vnodes()
path = vfs.absolute_path(*vnode.core_inode());
if (path.isEmpty()) {
if (auto* dev = vnode.characterDevice()) {
if (dev->isTTY())
path = static_cast<const TTY*>(dev)->ttyName();
if (dev->is_tty())
path = static_cast<const TTY*>(dev)->tty_name();
}
}
ptr += ksprintf(ptr, "vnode %03u: %02u:%08u (%u) %s\n", i, vnode.inode.fsid(), vnode.inode.index(), vnode.retain_count(), path.characters());
@ -378,13 +378,13 @@ ByteBuffer procfs$vnodes()
bool ProcFS::initialize()
{
SynthFS::initialize();
addFile(create_generated_file("mm", procfs$mm));
addFile(create_generated_file("regions", procfs$regions));
addFile(create_generated_file("mounts", procfs$mounts));
addFile(create_generated_file("kmalloc", procfs$kmalloc));
addFile(create_generated_file("summary", procfs$summary));
addFile(create_generated_file("cpuinfo", procfs$cpuinfo));
addFile(create_generated_file("vnodes", procfs$vnodes));
add_file(create_generated_file("mm", procfs$mm));
add_file(create_generated_file("regions", procfs$regions));
add_file(create_generated_file("mounts", procfs$mounts));
add_file(create_generated_file("kmalloc", procfs$kmalloc));
add_file(create_generated_file("summary", procfs$summary));
add_file(create_generated_file("cpuinfo", procfs$cpuinfo));
add_file(create_generated_file("vnodes", procfs$vnodes));
return true;
}

View file

@ -15,8 +15,8 @@ public:
virtual bool initialize() override;
virtual const char* class_name() const override;
void addProcess(Process&);
void removeProcess(Process&);
void add_process(Process&);
void remove_process(Process&);
private:
ProcFS();

View file

@ -255,7 +255,7 @@ Process* Process::fork(RegisterDump& regs)
dbgprintf("fork: child will begin executing at %w:%x with stack %w:%x\n", child->m_tss.cs, child->m_tss.eip, child->m_tss.ss, child->m_tss.esp);
#endif
ProcFS::the().addProcess(*child);
ProcFS::the().add_process(*child);
{
InterruptDisabler disabler;
@ -491,7 +491,7 @@ Process* Process::create_user_process(const String& path, uid_t uid, gid_t gid,
if (error != 0)
return nullptr;
ProcFS::the().addProcess(*process);
ProcFS::the().add_process(*process);
{
InterruptDisabler disabler;
@ -554,7 +554,7 @@ Process* Process::create_kernel_process(void (*e)(), String&& name)
g_processes->prepend(process);
system.nprocess++;
}
ProcFS::the().addProcess(*process);
ProcFS::the().add_process(*process);
#ifdef TASK_DEBUG
kprintf("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), process->m_tss.eip);
#endif
@ -684,7 +684,7 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
Process::~Process()
{
InterruptDisabler disabler;
ProcFS::the().removeProcess(*this);
ProcFS::the().remove_process(*this);
system.nprocess--;
gdt_free_entry(selector());
@ -976,9 +976,9 @@ int Process::sys$ttyname_r(int fd, char* buffer, size_t size)
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
if (!descriptor->isTTY())
if (!descriptor->is_tty())
return -ENOTTY;
auto ttyName = descriptor->tty()->ttyName();
auto ttyName = descriptor->tty()->tty_name();
if (size < ttyName.length() + 1)
return -ERANGE;
strcpy(buffer, ttyName.characters());
@ -996,7 +996,7 @@ ssize_t Process::sys$write(int fd, const void* data, size_t size)
if (!descriptor)
return -EBADF;
ssize_t nwritten = 0;
if (descriptor->isBlocking()) {
if (descriptor->is_blocking()) {
while (nwritten < (ssize_t)size) {
#ifdef IO_DEBUG
dbgprintf("while %u < %u\n", nwritten, size);
@ -1053,8 +1053,8 @@ ssize_t Process::sys$read(int fd, void* outbuf, size_t nread)
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
if (descriptor->isBlocking()) {
if (!descriptor->hasDataAvailableForRead()) {
if (descriptor->is_blocking()) {
if (!descriptor->has_data_available_for_reading()) {
m_fdBlockedOnRead = fd;
block(BlockedRead);
sched_yield();
@ -1180,7 +1180,7 @@ int Process::sys$readlink(const char* path, char* buffer, size_t size)
if (!descriptor->metadata().isSymbolicLink())
return -EINVAL;
auto contents = descriptor->readEntireFile();
auto contents = descriptor->read_entire_file();
if (!contents)
return -EIO; // FIXME: Get a more detailed error from VFS.
@ -1198,7 +1198,7 @@ int Process::sys$chdir(const char* path)
auto descriptor = VFS::the().open(path, error, 0, cwd_inode()->identifier());
if (!descriptor)
return error;
if (!descriptor->isDirectory())
if (!descriptor->is_directory())
return -ENOTDIR;
m_cwd = descriptor->vnode();
return 0;
@ -1241,7 +1241,7 @@ int Process::sys$open(const char* path, int options)
auto descriptor = VFS::the().open(path, error, options, cwd_inode()->identifier());
if (!descriptor)
return error;
if (options & O_DIRECTORY && !descriptor->isDirectory())
if (options & O_DIRECTORY && !descriptor->is_directory())
return -ENOTDIR; // FIXME: This should be handled by VFS::open.
int fd = 0;
@ -1326,7 +1326,7 @@ int Process::sys$isatty(int fd)
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
if (!descriptor->isTTY())
if (!descriptor->is_tty())
return -ENOTTY;
return 1;
}

View file

@ -51,7 +51,7 @@ bool Scheduler::pick_next()
if (process.state() == Process::BlockedRead) {
ASSERT(process.m_fdBlockedOnRead != -1);
// FIXME: Block until the amount of data wanted is available.
if (process.m_fds[process.m_fdBlockedOnRead].descriptor->hasDataAvailableForRead())
if (process.m_fds[process.m_fdBlockedOnRead].descriptor->has_data_available_for_reading())
process.unblock();
return true;
}
@ -167,9 +167,9 @@ void Scheduler::pick_next_and_switch_now()
void Scheduler::switch_now()
{
Descriptor& descriptor = getGDTEntry(current->selector());
Descriptor& descriptor = get_gdt_entry(current->selector());
descriptor.type = 9;
flushGDT();
flush_gdt();
asm("sti\n"
"ljmp *(%%eax)\n"
::"a"(&current->farPtr())
@ -204,7 +204,7 @@ bool Scheduler::context_switch(Process& process)
if (!process.selector()) {
process.setSelector(gdt_alloc_entry());
auto& descriptor = getGDTEntry(process.selector());
auto& descriptor = get_gdt_entry(process.selector());
descriptor.setBase(&process.tss());
descriptor.setLimit(0xffff);
descriptor.dpl = 0;
@ -215,9 +215,9 @@ bool Scheduler::context_switch(Process& process)
descriptor.descriptor_type = 0;
}
auto& descriptor = getGDTEntry(process.selector());
auto& descriptor = get_gdt_entry(process.selector());
descriptor.type = 11; // Busy TSS
flushGDT();
flush_gdt();
return true;
}
@ -228,7 +228,7 @@ int sched_yield()
static void initialize_redirection()
{
auto& descriptor = getGDTEntry(s_redirection.selector);
auto& descriptor = get_gdt_entry(s_redirection.selector);
descriptor.setBase(&s_redirection.tss);
descriptor.setLimit(0xffff);
descriptor.dpl = 0;
@ -238,12 +238,12 @@ static void initialize_redirection()
descriptor.operation_size = 1;
descriptor.descriptor_type = 0;
descriptor.type = 9;
flushGDT();
flush_gdt();
}
void Scheduler::prepare_for_iret_to_new_process()
{
auto& descriptor = getGDTEntry(s_redirection.selector);
auto& descriptor = get_gdt_entry(s_redirection.selector);
descriptor.type = 9;
s_redirection.tss.backlink = current->selector();
load_task_register(s_redirection.selector);

View file

@ -40,7 +40,7 @@ namespace Syscall {
void initialize()
{
registerUserCallableInterruptHandler(0x80, syscall_ISR);
register_user_callable_interrupt_handler(0x80, syscall_ISR);
kprintf("syscall: int 0x80 handler installed\n");
}

View file

@ -55,11 +55,11 @@ ssize_t TTY::write(const byte* buffer, size_t size)
#ifdef TTY_DEBUG
dbgprintf("TTY::write %b {%u}\n", buffer[0], size);
#endif
onTTYWrite(buffer, size);
on_tty_write(buffer, size);
return 0;
}
bool TTY::hasDataAvailableForRead() const
bool TTY::has_data_available_for_reading() const
{
return !m_buffer.is_empty();
}
@ -68,12 +68,12 @@ void TTY::emit(byte ch)
{
if (should_generate_signals()) {
if (ch == m_termios.c_cc[VINTR]) {
dbgprintf("%s: VINTR pressed!\n", ttyName().characters());
dbgprintf("%s: VINTR pressed!\n", tty_name().characters());
generate_signal(SIGINT);
return;
}
if (ch == m_termios.c_cc[VQUIT]) {
dbgprintf("%s: VQUIT pressed!\n", ttyName().characters());
dbgprintf("%s: VQUIT pressed!\n", tty_name().characters());
generate_signal(SIGQUIT);
return;
}
@ -85,10 +85,10 @@ void TTY::generate_signal(int signal)
{
if (!pgid())
return;
dbgprintf("%s: Send signal %d to everyone in pgrp %d\n", ttyName().characters(), signal, pgid());
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", ttyName().characters(), signal, process.pid());
dbgprintf("%s: Send signal %d to %d\n", tty_name().characters(), signal, process.pid());
process.send_signal(signal, nullptr);
return true;
});
@ -98,7 +98,7 @@ void TTY::set_termios(const Unix::termios& t)
{
m_termios = t;
dbgprintf("%s set_termios: IECHO? %u, ISIG? %u, ICANON? %u\n",
ttyName().characters(),
tty_name().characters(),
should_echo_input(),
should_generate_signals(),
in_canonical_mode()

View file

@ -34,10 +34,10 @@ public:
virtual ssize_t read(byte*, size_t) override;
virtual ssize_t write(const byte*, size_t) override;
virtual bool hasDataAvailableForRead() const override;
virtual bool has_data_available_for_reading() const override;
virtual int ioctl(Process&, unsigned request, unsigned arg) override final;
virtual String ttyName() const = 0;
virtual String tty_name() const = 0;
unsigned short rows() const { return m_rows; }
unsigned short columns() const { return m_columns; }
@ -52,7 +52,7 @@ public:
bool in_canonical_mode() const { return m_termios.c_lflag & ICANON; }
protected:
virtual void onTTYWrite(const byte*, size_t) = 0;
virtual void on_tty_write(const byte*, size_t) = 0;
void set_size(unsigned short columns, unsigned short rows);
TTY(unsigned major, unsigned minor);
@ -60,7 +60,7 @@ protected:
private:
// ^CharacterDevice
virtual bool isTTY() const final override { return true; }
virtual bool is_tty() const final override { return true; }
void generate_signal(int signal);

View file

@ -100,7 +100,7 @@ void VirtualConsole::set_active(bool b)
set_vga_start_row(0);
flush_vga_cursor();
Keyboard::the().setClient(this);
Keyboard::the().set_client(this);
}
inline bool is_valid_parameter_character(byte ch)
@ -441,7 +441,7 @@ void VirtualConsole::on_char(byte ch)
set_cursor(m_cursor_row, m_cursor_column);
}
void VirtualConsole::onKeyPress(Keyboard::Key key)
void VirtualConsole::on_key_pressed(Keyboard::Key key)
{
if (key.ctrl()) {
if (key.character >= 'a' && key.character <= 'z') {
@ -455,7 +455,7 @@ void VirtualConsole::onKeyPress(Keyboard::Key key)
emit(key.character);
}
void VirtualConsole::onConsoleReceive(byte ch)
void VirtualConsole::on_sysconsole_receive(byte ch)
{
InterruptDisabler disabler;
auto old_attribute = m_current_attribute;
@ -464,14 +464,14 @@ void VirtualConsole::onConsoleReceive(byte ch)
m_current_attribute = old_attribute;
}
void VirtualConsole::onTTYWrite(const byte* data, size_t size)
void VirtualConsole::on_tty_write(const byte* data, size_t size)
{
InterruptDisabler disabler;
for (size_t i = 0; i < size; ++i)
on_char(data[i]);
}
String VirtualConsole::ttyName() const
String VirtualConsole::tty_name() const
{
char buf[16];
ksprintf(buf, "/dev/tty%u", m_index);

View file

@ -17,14 +17,14 @@ public:
private:
// ^KeyboardClient
virtual void onKeyPress(Keyboard::Key) override;
virtual void on_key_pressed(Keyboard::Key) override;
// ^ConsoleImplementation
virtual void onConsoleReceive(byte) override;
virtual void on_sysconsole_receive(byte) override;
// ^TTY
virtual void onTTYWrite(const byte*, size_t) override;
virtual String ttyName() const override;
virtual void on_tty_write(const byte*, size_t) override;
virtual String tty_name() const override;
void set_active(bool);
void on_char(byte);

View file

@ -297,18 +297,18 @@ static void writeRawGDTEntry(word selector, dword low, dword high)
}
}
void writeGDTEntry(word selector, Descriptor& descriptor)
void write_gdt_entry(word selector, Descriptor& descriptor)
{
writeRawGDTEntry(selector, descriptor.low, descriptor.high);
}
Descriptor& getGDTEntry(word selector)
Descriptor& get_gdt_entry(word selector)
{
word i = (selector & 0xfffc) >> 3;
return *(Descriptor*)(&s_gdt[i]);
}
void flushGDT()
void flush_gdt()
{
s_gdtr.address = s_gdt;
s_gdtr.size = (s_gdtLength * 8) - 1;
@ -335,7 +335,7 @@ void gdt_init()
writeRawGDTEntry(0x0018, 0x0000ffff, 0x00cffa00);
writeRawGDTEntry(0x0020, 0x0000ffff, 0x00cff200);
flushGDT();
flush_gdt();
}
static void unimp_trap()
@ -344,34 +344,34 @@ static void unimp_trap()
HANG;
}
void registerIRQHandler(byte irq, IRQHandler& handler)
void register_irq_handler(byte irq, IRQHandler& handler)
{
ASSERT(!s_irqHandler[irq]);
s_irqHandler[irq] = &handler;
registerInterruptHandler(IRQ_VECTOR_BASE + irq, asm_irq_entry);
register_interrupt_handler(IRQ_VECTOR_BASE + irq, asm_irq_entry);
}
void unregisterIRQHandler(byte irq, IRQHandler& handler)
void unregister_irq_handler(byte irq, IRQHandler& handler)
{
ASSERT(s_irqHandler[irq] == &handler);
s_irqHandler[irq] = nullptr;
}
void registerInterruptHandler(byte index, void (*f)())
void register_interrupt_handler(byte index, void (*f)())
{
s_idt[index].low = 0x00080000 | LSW((f));
s_idt[index].high = ((dword)(f) & 0xffff0000) | 0x8e00;
flushIDT();
flush_idt();
}
void registerUserCallableInterruptHandler(byte index, void (*f)())
void register_user_callable_interrupt_handler(byte index, void (*f)())
{
s_idt[index].low = 0x00080000 | LSW((f));
s_idt[index].high = ((dword)(f) & 0xffff0000) | 0xef00;
flushIDT();
flush_idt();
}
void flushIDT()
void flush_idt()
{
asm("lidt %0"::"m"(s_idtr));
}
@ -396,34 +396,34 @@ void idt_init()
s_idtr.size = 0x100 * 8;
for (byte i = 0xff; i > 0x10; --i)
registerInterruptHandler(i, unimp_trap);
register_interrupt_handler(i, unimp_trap);
registerInterruptHandler(0x00, _exception0);
registerInterruptHandler(0x01, _exception1);
registerInterruptHandler(0x02, _exception2);
registerInterruptHandler(0x03, _exception3);
registerInterruptHandler(0x04, _exception4);
registerInterruptHandler(0x05, _exception5);
registerInterruptHandler(0x06, exception_6_entry);
registerInterruptHandler(0x07, _exception7);
registerInterruptHandler(0x08, _exception8);
registerInterruptHandler(0x09, _exception9);
registerInterruptHandler(0x0a, _exception10);
registerInterruptHandler(0x0b, _exception11);
registerInterruptHandler(0x0c, _exception12);
registerInterruptHandler(0x0d, exception_13_entry);
registerInterruptHandler(0x0e, exception_14_entry);
registerInterruptHandler(0x0f, _exception15);
registerInterruptHandler(0x10, _exception16);
register_interrupt_handler(0x00, _exception0);
register_interrupt_handler(0x01, _exception1);
register_interrupt_handler(0x02, _exception2);
register_interrupt_handler(0x03, _exception3);
register_interrupt_handler(0x04, _exception4);
register_interrupt_handler(0x05, _exception5);
register_interrupt_handler(0x06, exception_6_entry);
register_interrupt_handler(0x07, _exception7);
register_interrupt_handler(0x08, _exception8);
register_interrupt_handler(0x09, _exception9);
register_interrupt_handler(0x0a, _exception10);
register_interrupt_handler(0x0b, _exception11);
register_interrupt_handler(0x0c, _exception12);
register_interrupt_handler(0x0d, exception_13_entry);
register_interrupt_handler(0x0e, exception_14_entry);
register_interrupt_handler(0x0f, _exception15);
register_interrupt_handler(0x10, _exception16);
registerInterruptHandler(0x57, irq7_handler);
register_interrupt_handler(0x57, irq7_handler);
s_irqHandler = static_cast<IRQHandler**>(kmalloc_eternal(sizeof(IRQHandler*) * 16));
for (byte i = 0; i < 16; ++i) {
s_irqHandler[i] = nullptr;
}
flushIDT();
flush_idt();
}
void load_task_register(word selector)
@ -450,7 +450,7 @@ void handle_irq()
}
if (s_irqHandler[irq])
s_irqHandler[irq]->handleIRQ();
s_irqHandler[irq]->handle_irq();
PIC::eoi(irq);
}

View file

@ -61,17 +61,17 @@ class IRQHandler;
void gdt_init();
void idt_init();
void registerInterruptHandler(byte number, void (*f)());
void registerUserCallableInterruptHandler(byte number, void (*f)());
void registerIRQHandler(byte number, IRQHandler&);
void unregisterIRQHandler(byte number, IRQHandler&);
void flushIDT();
void flushGDT();
void register_interrupt_handler(byte number, void (*f)());
void register_user_callable_interrupt_handler(byte number, void (*f)());
void register_irq_handler(byte number, IRQHandler&);
void unregister_irq_handler(byte number, IRQHandler&);
void flush_idt();
void flush_gdt();
void load_task_register(word selector);
word gdt_alloc_entry();
void gdt_free_entry(word);
Descriptor& getGDTEntry(word selector);
void writeGDTEntry(word selector, Descriptor&);
Descriptor& get_gdt_entry(word selector);
void write_gdt_entry(word selector, Descriptor&);
#define HANG asm volatile( "cli; hlt" );
#define LSW(x) ((dword)(x) & 0xFFFF)
@ -82,7 +82,7 @@ void writeGDTEntry(word selector, Descriptor&);
#define cli() asm volatile("cli")
#define sti() asm volatile("sti")
static inline dword cpuFlags()
static inline dword cpu_flags()
{
dword flags;
asm volatile(
@ -95,14 +95,14 @@ static inline dword cpuFlags()
inline bool are_interrupts_enabled()
{
return cpuFlags() & 0x200;
return cpu_flags() & 0x200;
}
class InterruptDisabler {
public:
InterruptDisabler()
{
m_flags = cpuFlags();
m_flags = cpu_flags();
cli();
}

View file

@ -79,7 +79,7 @@ void initialize()
IO::out8(TIMER0_CTL, LSB(timer_reload));
IO::out8(TIMER0_CTL, MSB(timer_reload));
registerInterruptHandler(IRQ_VECTOR_BASE + IRQ_TIMER, tick_ISR);
register_interrupt_handler(IRQ_VECTOR_BASE + IRQ_TIMER, tick_ISR);
PIC::enable(IRQ_TIMER);
}

View file

@ -207,7 +207,7 @@ static void init_stage2()
if (!descriptor) {
kprintf("Failed to open /kernel.map\n");
} else {
auto buffer = descriptor->readEntireFile();
auto buffer = descriptor->read_entire_file();
ASSERT(buffer);
loadKsyms(buffer);
}

View file

@ -9,5 +9,5 @@ void __assertion_failed(const char* msg, const char* file, unsigned line, const
#define CRASH() do { asm volatile("ud2"); } while(0)
#define RELEASE_ASSERT(x) do { if (!(x)) CRASH(); } while(0)
#define ASSERT_NOT_REACHED() ASSERT(false)
#define ASSERT_INTERRUPTS_DISABLED() ASSERT(!(cpuFlags() & 0x200))
#define ASSERT_INTERRUPTS_ENABLED() ASSERT(cpuFlags() & 0x200)
#define ASSERT_INTERRUPTS_DISABLED() ASSERT(!(cpu_flags() & 0x200))
#define ASSERT_INTERRUPTS_ENABLED() ASSERT(cpu_flags() & 0x200)