Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-28 15:34:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated crash screen

Browse Source
This commit is contained in:
Alex 2023-02-06 19:33:48 +02:00
parent c74d19e9d2
commit 640f6a412a
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
7 changed files with 115 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
Core/Crash/CrashDetails.cpp
View File

@ -30,68 +30,76 @@ SafeFunction void DivideByZeroExceptionHandler(CHArchTrapFrame *Frame)
fixme("Divide by zero exception\n"); fixme("Divide by zero exception\n");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void DebugExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void DebugExceptionHandler(CHArchTrapFrame *Frame)
{ {
CrashHandler::EHPrint("\eDD2920System crashed!\n");
CrashHandler::EHPrint("Kernel triggered debug exception.\n"); CrashHandler::EHPrint("Kernel triggered debug exception.\n");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void NonMaskableInterruptExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void NonMaskableInterruptExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("NMI exception"); fixme("NMI exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void BreakpointExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void BreakpointExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Breakpoint exception"); fixme("Breakpoint exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void OverflowExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void OverflowExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Overflow exception"); fixme("Overflow exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void BoundRangeExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void BoundRangeExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Bound range exception"); fixme("Bound range exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void InvalidOpcodeExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void InvalidOpcodeExceptionHandler(CHArchTrapFrame *Frame)
{ {
CrashHandler::EHPrint("\eDD2920System crashed!\n");
CrashHandler::EHPrint("Kernel tried to execute an invalid opcode.\n"); CrashHandler::EHPrint("Kernel tried to execute an invalid opcode.\n");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void DeviceNotAvailableExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void DeviceNotAvailableExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Device not available exception"); fixme("Device not available exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void DoubleFaultExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void DoubleFaultExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Double fault exception"); fixme("Double fault exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void CoprocessorSegmentOverrunExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void CoprocessorSegmentOverrunExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Coprocessor segment overrun exception"); fixme("Coprocessor segment overrun exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void InvalidTSSExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void InvalidTSSExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Invalid TSS exception"); fixme("Invalid TSS exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void SegmentNotPresentExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void SegmentNotPresentExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Segment not present exception"); fixme("Segment not present exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void StackFaultExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void StackFaultExceptionHandler(CHArchTrapFrame *Frame)
{ {
CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode}; CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
CrashHandler::EHPrint("\eDD2920System crashed!\n");
CrashHandler::EHPrint("More info about the exception:\n");
#if defined(__amd64__) #if defined(__amd64__)
CrashHandler::EHPrint("Stack segment fault at address %#lx\n", Frame->rip); CrashHandler::EHPrint("Stack segment fault at address %#lx\n", Frame->rip);
#elif defined(__i386__) #elif defined(__i386__)
@ -103,13 +111,9 @@ SafeFunction void StackFaultExceptionHandler(CHArchTrapFrame *Frame)
CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx); CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx);
CrashHandler::EHPrint("Error code: %#lx\n", Frame->ErrorCode); CrashHandler::EHPrint("Error code: %#lx\n", Frame->ErrorCode);
} }
SafeFunction void GeneralProtectionExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void GeneralProtectionExceptionHandler(CHArchTrapFrame *Frame)
{ {
// staticbuffer(descbuf);
// staticbuffer(desc_ext);
// staticbuffer(desc_table);
// staticbuffer(desc_idx);
// staticbuffer(desc_tmp);
CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode}; CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
// switch (SelCode.Table) // switch (SelCode.Table)
// { // {
@ -129,21 +133,19 @@ SafeFunction void GeneralProtectionExceptionHandler(CHArchTrapFrame *Frame)
// memcpy(desc_tmp, "Unknown", 7); // memcpy(desc_tmp, "Unknown", 7);
// break; // break;
// } // }
CrashHandler::EHPrint("\eDD2920System crashed!\n");
CrashHandler::EHPrint("Kernel performed an illegal operation.\n"); CrashHandler::EHPrint("Kernel performed an illegal operation.\n");
CrashHandler::EHPrint("More info about the exception:\n");
CrashHandler::EHPrint("External: %d\n", SelCode.External); CrashHandler::EHPrint("External: %d\n", SelCode.External);
CrashHandler::EHPrint("Table: %d\n", SelCode.Table); CrashHandler::EHPrint("Table: %d\n", SelCode.Table);
CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx); CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx);
} }
SafeFunction void PageFaultExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void PageFaultExceptionHandler(CHArchTrapFrame *Frame)
{ {
CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode}; CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
CrashHandler::EHPrint("\eDD2920System crashed!\n\eFFFFFF");
#if defined(__amd64__) #if defined(__amd64__)
CrashHandler::EHPrint("An exception occurred at %#lx by %#lx\n", CPU::x64::readcr2().PFLA, Frame->rip); CrashHandler::EHPrint("\eAFAFAFAn exception occurred at %#lx by %#lx\n", CrashHandler::PageFaultAddress, Frame->rip);
#elif defined(__i386__) #elif defined(__i386__)
CrashHandler::EHPrint("An exception occurred at %#lx by %#lx\n", CPU::x64::readcr2().PFLA, Frame->eip); CrashHandler::EHPrint("\eAFAFAFAn exception occurred at %#lx by %#lx\n", CrashHandler::PageFaultAddress, Frame->eip);
#elif defined(__aarch64__) #elif defined(__aarch64__)
#endif #endif
CrashHandler::EHPrint("Page: %s\n", params.P ? "Present" : "Not Present"); CrashHandler::EHPrint("Page: %s\n", params.P ? "Present" : "Not Present");
@ -161,7 +163,7 @@ SafeFunction void PageFaultExceptionHandler(CHArchTrapFrame *Frame)
#ifdef DEBUG #ifdef DEBUG
uintptr_t CheckPageFaultAddress = 0; uintptr_t CheckPageFaultAddress = 0;
CheckPageFaultAddress = CPU::x64::readcr2().PFLA; CheckPageFaultAddress = CrashHandler::PageFaultAddress;
if (CheckPageFaultAddress == 0) if (CheckPageFaultAddress == 0)
#ifdef __amd64__ #ifdef __amd64__
CheckPageFaultAddress = Frame->rip; CheckPageFaultAddress = Frame->rip;
@ -268,36 +270,43 @@ SafeFunction void PageFaultExceptionHandler(CHArchTrapFrame *Frame)
} }
#endif #endif
} }
SafeFunction void x87FloatingPointExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void x87FloatingPointExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("x87 floating point exception"); fixme("x87 floating point exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void AlignmentCheckExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void AlignmentCheckExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Alignment check exception"); fixme("Alignment check exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void MachineCheckExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void MachineCheckExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Machine check exception"); fixme("Machine check exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void SIMDFloatingPointExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void SIMDFloatingPointExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("SIMD floating point exception"); fixme("SIMD floating point exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void VirtualizationExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void VirtualizationExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Virtualization exception"); fixme("Virtualization exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void SecurityExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void SecurityExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Security exception"); fixme("Security exception");
UNUSED(Frame); UNUSED(Frame);
} }
SafeFunction void UnknownExceptionHandler(CHArchTrapFrame *Frame) SafeFunction void UnknownExceptionHandler(CHArchTrapFrame *Frame)
{ {
fixme("Unknown exception"); fixme("Unknown exception");

80
Core/Crash/CrashHandler.cpp
View File

@ -6,6 +6,7 @@
#include <convert.h> #include <convert.h>
#include <printf.h> #include <printf.h>
#include <lock.hpp> #include <lock.hpp>
#include <rand.hpp>
#include <debug.h> #include <debug.h>
#include <smp.hpp> #include <smp.hpp>
#include <cpu.hpp> #include <cpu.hpp>
@ -25,9 +26,11 @@ NewLock(UserInputLock);
namespace CrashHandler namespace CrashHandler
{ {
uintptr_t PageFaultAddress = 0;
void *EHIntFrames[INT_FRAMES_MAX]; void *EHIntFrames[INT_FRAMES_MAX];
static bool ExceptionOccurred = false; static bool ExceptionOccurred = false;
int SBIdx = 255; int SBIdx = 255;
SafeFunction void printfWrapper(char c, void *unused) SafeFunction void printfWrapper(char c, void *unused)
{ {
Display->Print(c, SBIdx, true); Display->Print(c, SBIdx, true);
@ -146,6 +149,70 @@ namespace CrashHandler
EHPrint(" \eAAF00F%s", CPU::Vendor()); EHPrint(" \eAAF00F%s", CPU::Vendor());
EHPrint(" \eAA00FF%s", CPU::Name()); EHPrint(" \eAA00FF%s", CPU::Name());
Display->SetBufferCursor(SBIdx, 0, fi.Height + 10); Display->SetBufferCursor(SBIdx, 0, fi.Height + 10);
/* https://imgflip.com/i/77slbl */
if ((Random::rand32() % 100) >= 98)
{
debug("Easter egg activated!");
int BaseXOffset = sb->Width - 14;
int BaseYOffset = 8;
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 0, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 0, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 0, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 7, BaseYOffset + 0, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 7, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 8, BaseYOffset + 1, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 1, BaseYOffset + 2, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 2, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 2, 0xFFFFFF, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 2, 0x000000, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 2, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 2, 0xFFFFFF, SBIdx);
Display->SetPixel(BaseXOffset + 7, BaseYOffset + 2, 0x000000, SBIdx);
Display->SetPixel(BaseXOffset + 8, BaseYOffset + 2, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 1, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 7, BaseYOffset + 3, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 0, BaseYOffset + 4, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 1, BaseYOffset + 4, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 4, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 4, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 4, 0xA84832, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 4, 0xA84832, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 4, 0xA84832, SBIdx);
Display->SetPixel(BaseXOffset + 7, BaseYOffset + 4, 0xA84832, SBIdx);
Display->SetPixel(BaseXOffset + 0, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 1, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 5, 0x21852E, SBIdx);
Display->SetPixel(BaseXOffset + 0, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 1, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 2, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 3, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 4, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 5, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetPixel(BaseXOffset + 6, BaseYOffset + 6, 0x1216FF, SBIdx);
Display->SetBuffer(SBIdx);
}
} }
SafeFunction void DisplayBottomOverlay() SafeFunction void DisplayBottomOverlay()
@ -246,7 +313,7 @@ namespace CrashHandler
EHPrint("exit - Shutdown the OS.\n"); EHPrint("exit - Shutdown the OS.\n");
EHPrint("reboot - Reboot the OS.\n"); EHPrint("reboot - Reboot the OS.\n");
EHPrint("help - Display this help message.\n"); EHPrint("help - Display this help message.\n");
EHPrint("showbuf <INDEX> - Display the contents of a screen buffer.\n"); EHPrint("showbuf,sb <INDEX> - Display the contents of a screen buffer.\n");
EHPrint(" - A sleep timer will be enabled. This will cause the OS to sleep for an unknown amount of time.\n"); EHPrint(" - A sleep timer will be enabled. This will cause the OS to sleep for an unknown amount of time.\n");
EHPrint(" - \eFF4400WARNING: This can crash the system if a wrong buffer is selected.\eFAFAFA\n"); EHPrint(" - \eFF4400WARNING: This can crash the system if a wrong buffer is selected.\eFAFAFA\n");
EHPrint("ifr <COUNT> - Show interrupt frames.\n"); EHPrint("ifr <COUNT> - Show interrupt frames.\n");
@ -281,7 +348,7 @@ namespace CrashHandler
Display->SetBuffer(SBIdx); Display->SetBuffer(SBIdx);
CPU::Stop(); CPU::Stop();
} }
else if (strncmp(Input, "showbuf", 7) == 0) else if (strncmp(Input, "showbuf", 7) == 0 || strncmp(Input, "sb", 2) == 0)
{ {
char *arg = TrimWhiteSpace(Input + 7); char *arg = TrimWhiteSpace(Input + 7);
int tmpidx = SBIdx; int tmpidx = SBIdx;
@ -475,7 +542,7 @@ namespace CrashHandler
EHPrint("\e44AA000: %#lx\n", CPU::x64::readcr0()); EHPrint("\e44AA000: %#lx\n", CPU::x64::readcr0());
break; break;
case '2': case '2':
EHPrint("\e44AA002: %#lx\n", CPU::x64::readcr2()); EHPrint("\e44AA002: %#lx\n", PageFaultAddress);
break; break;
case '3': case '3':
EHPrint("\e44AA003: %#lx\n", CPU::x64::readcr3()); EHPrint("\e44AA003: %#lx\n", CPU::x64::readcr3());
@ -592,6 +659,7 @@ namespace CrashHandler
CHArchTrapFrame *Frame = (CHArchTrapFrame *)Data; CHArchTrapFrame *Frame = (CHArchTrapFrame *)Data;
#if defined(__amd64__) #if defined(__amd64__)
error("Exception: %#llx", Frame->InterruptNumber); error("Exception: %#llx", Frame->InterruptNumber);
PageFaultAddress = CPU::x64::readcr2().PFLA;
if (Frame->cs != GDT_USER_CODE && Frame->cs != GDT_USER_DATA) if (Frame->cs != GDT_USER_CODE && Frame->cs != GDT_USER_DATA)
{ {
@ -616,7 +684,7 @@ namespace CrashHandler
debug("CPU %ld data is valid", data->ID); debug("CPU %ld data is valid", data->ID);
if (data->CurrentThread->Security.IsCritical) if (data->CurrentThread->Security.IsCritical)
{ {
debug("Critical thread died"); debug("Critical thread \"%s\"(%d) died", data->CurrentThread->Name, data->CurrentThread->ID);
if (TaskManager) if (TaskManager)
TaskManager->Panic(); TaskManager->Panic();
Display->CreateBuffer(0, 0, SBIdx); Display->CreateBuffer(0, 0, SBIdx);
@ -637,7 +705,7 @@ namespace CrashHandler
Display->SetBufferCursor(SBIdx, 0, 0); Display->SetBufferCursor(SBIdx, 0, 0);
CPU::x64::CR0 cr0 = CPU::x64::readcr0(); CPU::x64::CR0 cr0 = CPU::x64::readcr0();
CPU::x64::CR2 cr2 = CPU::x64::readcr2(); CPU::x64::CR2 cr2 = CPU::x64::CR2{.PFLA = PageFaultAddress};
CPU::x64::CR3 cr3 = CPU::x64::readcr3(); CPU::x64::CR3 cr3 = CPU::x64::readcr3();
CPU::x64::CR4 cr4 = CPU::x64::readcr4(); CPU::x64::CR4 cr4 = CPU::x64::readcr4();
CPU::x64::CR8 cr8 = CPU::x64::readcr8(); CPU::x64::CR8 cr8 = CPU::x64::readcr8();
@ -699,7 +767,7 @@ namespace CrashHandler
debug("Reading control registers..."); debug("Reading control registers...");
crashdata.Frame = Frame; crashdata.Frame = Frame;
crashdata.cr0 = CPU::x64::readcr0(); crashdata.cr0 = CPU::x64::readcr0();
crashdata.cr2 = CPU::x64::readcr2(); crashdata.cr2 = CPU::x64::CR2{.PFLA = PageFaultAddress};
crashdata.cr3 = CPU::x64::readcr3(); crashdata.cr3 = CPU::x64::readcr3();
crashdata.cr4 = CPU::x64::readcr4(); crashdata.cr4 = CPU::x64::readcr4();
crashdata.cr8 = CPU::x64::readcr8(); crashdata.cr8 = CPU::x64::readcr8();

10
Core/Crash/Screens/Details.cpp
View File

@ -35,14 +35,10 @@ namespace CrashHandler
if (cpu) if (cpu)
{ {
EHPrint("\eE46CEBCPU Data Address: %#lx\n", cpu); EHPrint("\eE46CEBCPU Data Address: %#lx\n", cpu);
EHPrint("Syscalls Stack: %#lx\n", cpu->SystemCallStack); EHPrint("Syscalls Stack: %#lx, TempStack: %#lx\n", cpu->SystemCallStack, cpu->TempStack);
EHPrint("TempStack: %#lx\n", cpu->TempStack); EHPrint("Core Stack: %#lx, Core ID: %ld, Error Code: %ld\n", cpu->Stack, cpu->ID, cpu->ErrorCode);
EHPrint("Core Stack: %#lx\n", cpu->Stack);
EHPrint("Core ID: %ld\n", cpu->ID);
EHPrint("Error Code: %ld\n", cpu->ErrorCode);
EHPrint("Is Active: %s\n", cpu->IsActive ? "true" : "false"); EHPrint("Is Active: %s\n", cpu->IsActive ? "true" : "false");
EHPrint("Current Process: %#lx\n", cpu->CurrentProcess); EHPrint("Current Process: %#lx, Current Thread: %#lx\n", cpu->CurrentProcess, cpu->CurrentThread);
EHPrint("Current Thread: %#lx\n", cpu->CurrentThread);
EHPrint("Arch Specific Data: %#lx\n", cpu->Data); EHPrint("Arch Specific Data: %#lx\n", cpu->Data);
EHPrint("Checksum: 0x%X\n", cpu->Checksum); EHPrint("Checksum: 0x%X\n", cpu->Checksum);
} }

4
Core/Crash/Screens/Main.cpp
View File

@ -270,9 +270,9 @@ namespace CrashHandler
CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode}; CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
#if defined(__amd64__) #if defined(__amd64__)
EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", CPU::x64::readcr2().PFLA, Frame->rip); EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", PageFaultAddress, Frame->rip);
#elif defined(__i386__) #elif defined(__i386__)
EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", CPU::x64::readcr2().PFLA, Frame->eip); EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", PageFaultAddress, Frame->eip);
#elif defined(__aarch64__) #elif defined(__aarch64__)
#endif #endif
EHPrint("Page: %s\eFAFAFA\n", params.P ? "\e058C19Present" : "\eE85230Not Present"); EHPrint("Page: %s\eFAFAFA\n", params.P ? "\e058C19Present" : "\eE85230Not Present");

14
Core/Crash/Screens/StackFrame.cpp
View File

@ -53,31 +53,29 @@ namespace CrashHandler
} }
if (data.Process && data.Thread) if (data.Process && data.Thread)
{ {
EHPrint("\n\n\eFAFAFATracing thread RIP history..."); EHPrint("\n\n\eFAFAFATracing thread instruction pointer history...");
SymbolResolver::Symbols *sh = data.Process->ELFSymbolTable; SymbolResolver::Symbols *sh = data.Process->ELFSymbolTable;
if (!sh) if (!sh)
EHPrint("\n\eFFA500Warning: No symbol table available."); EHPrint("\n\eFFA500Warning: No symbol table available.");
int SameItr = 0; int SameItr = 0;
uintptr_t LastRIP = 0; uintptr_t LastRIP = 0;
for (int i = 0; i < 128; i++) for (size_t i = 0; i < sizeof(data.Thread->IPHistory) / sizeof(data.Thread->IPHistory[0]); i++)
{ {
if (data.Thread->IPHistory[i] == 0)
break;
if (data.Thread->IPHistory[i] == LastRIP) if (data.Thread->IPHistory[i] == LastRIP)
{ {
SameItr++; SameItr++;
if (SameItr > 3) if (SameItr > 2)
continue; continue;
} }
else else
SameItr = 0; SameItr = 0;
LastRIP = data.Thread->IPHistory[i]; LastRIP = data.Thread->IPHistory[i];
if (!sh) if (!sh)
EHPrint("\n\e2565CC%p", data.Thread->IPHistory[i]); EHPrint("\n\eCCCCCC%d: \e2565CC%p", i, data.Thread->IPHistory[i]);
else else
EHPrint("\n\e2565CC%p\e7925CC-\e25CCC9%s", data.Thread->IPHistory[i], sh->GetSymbolFromAddress(data.Thread->IPHistory[i])); EHPrint("\n\eCCCCCC%d: \e2565CC%p\e7925CC-\e25CCC9%s", i, data.Thread->IPHistory[i], sh->GetSymbolFromAddress(data.Thread->IPHistory[i]));
} }
EHPrint("\n\e7925CCNote: \e2565CCSame RIPs are not shown more than 3 times.\n"); EHPrint("\n\e7925CCNote: \e2565CCSame instruction pointers are not shown more than 3 times.\n");
} }
} }
} }

10
Core/Crash/UserHandler.cpp
View File

@ -35,7 +35,7 @@ SafeFunction void UserModeExceptionHandler(CHArchTrapFrame *Frame)
{ {
CPU::x64::CR0 cr0 = CPU::x64::readcr0(); CPU::x64::CR0 cr0 = CPU::x64::readcr0();
CPU::x64::CR2 cr2 = CPU::x64::readcr2(); CPU::x64::CR2 cr2 = CPU::x64::CR2{.PFLA = CrashHandler::PageFaultAddress};
CPU::x64::CR3 cr3 = CPU::x64::readcr3(); CPU::x64::CR3 cr3 = CPU::x64::readcr3();
CPU::x64::CR4 cr4 = CPU::x64::readcr4(); CPU::x64::CR4 cr4 = CPU::x64::readcr4();
CPU::x64::CR8 cr8 = CPU::x64::readcr8(); CPU::x64::CR8 cr8 = CPU::x64::readcr8();
@ -179,13 +179,13 @@ SafeFunction void UserModeExceptionHandler(CHArchTrapFrame *Frame)
uintptr_t CheckPageFaultAddress = 0; uintptr_t CheckPageFaultAddress = 0;
CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode}; CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
#if defined(__amd64__) #if defined(__amd64__)
CheckPageFaultAddress = CPU::x64::readcr2().PFLA; CheckPageFaultAddress = CrashHandler::PageFaultAddress;
if (CheckPageFaultAddress == 0) if (CheckPageFaultAddress == 0)
CheckPageFaultAddress = Frame->rip; CheckPageFaultAddress = Frame->rip;
error("An exception occurred at %#lx by %#lx", CPU::x64::readcr2().PFLA, Frame->rip); error("An exception occurred at %#lx by %#lx", CrashHandler::PageFaultAddress, Frame->rip);
#elif defined(__i386__) #elif defined(__i386__)
error("An exception occurred at %#lx by %#lx", CPU::x64::readcr2().PFLA, Frame->eip); error("An exception occurred at %#lx by %#lx", CrashHandler::PageFaultAddress, Frame->eip);
#elif defined(__aarch64__) #elif defined(__aarch64__)
#endif #endif
error("Page: %s", params.P ? "Present" : "Not Present"); error("Page: %s", params.P ? "Present" : "Not Present");
@ -303,7 +303,7 @@ SafeFunction void UserModeExceptionHandler(CHArchTrapFrame *Frame)
#endif #endif
if (CurCPU) if (CurCPU)
if (CurCPU->CurrentThread->Stack->Expand(CPU::x64::readcr2().raw)) if (CurCPU->CurrentThread->Stack->Expand(CrashHandler::PageFaultAddress))
{ {
debug("Stack expanded"); debug("Stack expanded");
TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Ready; TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Ready;

1
Core/crashhandler.hpp
View File

@ -8,6 +8,7 @@
namespace CrashHandler namespace CrashHandler
{ {
extern uintptr_t PageFaultAddress;
extern void *EHIntFrames[INT_FRAMES_MAX]; extern void *EHIntFrames[INT_FRAMES_MAX];
void EHPrint(const char *Format, ...); void EHPrint(const char *Format, ...);