system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-10-15 20:33:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Kernel: Refactor PageFault for use in the aarch64 port

Browse source 
The class used to look at the x86_64 specific exception code to figure
out what kind of page fault happend, however this refactor allows
aarch64 to use the same class.
This commit is contained in:
Timon Kruiper 2023-01-08 17:03:40 +01:00 committed by Andreas Kling
parent fb10774862
commit ade27fa6b9
2 changed files with 48 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
Kernel/Arch/PageFault.h
View file

@ -8,10 +8,12 @@
#include <AK/Platform.h>
#include <AK/Types.h>
#include <Kernel/ExecutionMode.h>
#include <Kernel/VirtualAddress.h>
namespace Kernel {
// NOTE: These flags are x86_64 specific.
struct PageFaultFlags {
enum Flags {
NotPresent = 0x00,
@ -28,8 +30,17 @@ struct PageFaultFlags {
class PageFault {
public:
PageFault(u16 code, VirtualAddress vaddr)
: m_code(code)
, m_vaddr(vaddr)
: m_vaddr(vaddr)
{
m_type = (Type)(code & PageFaultFlags::ProtectionViolation);
m_access = (Access)(code & PageFaultFlags::Write);
m_execution_mode = (code & PageFaultFlags::UserMode) != 0 ? ExecutionMode::User : ExecutionMode::Kernel;
m_is_reserved_bit_violation = (code & PageFaultFlags::ReservedBitViolation) != 0;
m_is_instruction_fetch = (code & PageFaultFlags::InstructionFetch) != 0;
}
explicit PageFault(VirtualAddress vaddr)
: m_vaddr(vaddr)
{
}
@ -44,21 +55,42 @@ public:
};
VirtualAddress vaddr() const { return m_vaddr; }
u16 code() const { return m_code; }
u16 code() const
{
u16 code = 0;
code |= (u16)m_type;
code |= (u16)m_access;
code |= m_execution_mode == ExecutionMode::User ? PageFaultFlags::UserMode : 0;
code |= m_is_reserved_bit_violation ? PageFaultFlags::ReservedBitViolation : 0;
code |= m_is_instruction_fetch ? PageFaultFlags::InstructionFetch : 0;
return code;
}
Type type() const { return (Type)(m_code & 1); }
Access access() const { return (Access)(m_code & 2); }
void set_type(Type type) { m_type = type; }
Type type() const { return m_type; }
bool is_not_present() const { return (m_code & 1) == PageFaultFlags::NotPresent; }
bool is_protection_violation() const { return (m_code & 1) == PageFaultFlags::ProtectionViolation; }
bool is_read() const { return (m_code & 2) == PageFaultFlags::Read; }
bool is_write() const { return (m_code & 2) == PageFaultFlags::Write; }
bool is_user() const { return (m_code & 4) == PageFaultFlags::UserMode; }
bool is_supervisor() const { return (m_code & 4) == PageFaultFlags::SupervisorMode; }
bool is_instruction_fetch() const { return (m_code & 16) == PageFaultFlags::InstructionFetch; }
void set_access(Access access) { m_access = access; }
Access access() const { return m_access; }
void set_mode(ExecutionMode execution_mode) { m_execution_mode = execution_mode; }
ExecutionMode mode() const { return m_execution_mode; }
bool is_not_present() const { return m_type == Type::PageNotPresent; }
bool is_protection_violation() const { return m_type == Type::ProtectionViolation; }
bool is_read() const { return m_access == Access::Read; }
bool is_write() const { return m_access == Access::Write; }
bool is_user() const { return m_execution_mode == ExecutionMode::User; }
bool is_kernel() const { return m_execution_mode == ExecutionMode::Kernel; }
bool is_reserved_bit_violation() const { return m_is_reserved_bit_violation; }
bool is_instruction_fetch() const { return m_is_instruction_fetch; }
private:
u16 m_code;
Type m_type;
Access m_access;
ExecutionMode m_execution_mode;
bool m_is_reserved_bit_violation { false };
bool m_is_instruction_fetch { false };
VirtualAddress m_vaddr;
};

6
Kernel/Arch/x86_64/Interrupts.cpp
View file

@ -263,9 +263,9 @@ void page_fault_handler(TrapFrame* trap)
}
dbgln("Unrecoverable page fault, {}{}{} address {}",
regs.exception_code & PageFaultFlags::ReservedBitViolation ? "reserved bit violation / " : "",
regs.exception_code & PageFaultFlags::InstructionFetch ? "instruction fetch / " : "",
regs.exception_code & PageFaultFlags::Write ? "write to" : "read from",
fault.is_reserved_bit_violation() ? "reserved bit violation / " : "",
fault.is_instruction_fetch() ? "instruction fetch / " : "",
fault.is_write() ? "write to" : "read from",
VirtualAddress(fault_address));
constexpr FlatPtr malloc_scrub_pattern = explode_byte(MALLOC_SCRUB_BYTE);
constexpr FlatPtr free_scrub_pattern = explode_byte(FREE_SCRUB_BYTE);