Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-05-29 07:47:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Improved symbol table + every process have one allocated

Browse Source
This commit is contained in:
Alex 2022-12-10 06:01:01 +02:00
parent 6d58f04f1f
commit a56f633709
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
6 changed files with 68 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Core/Crash/SFrame.cpp
View File

@ -23,7 +23,7 @@ namespace CrashHandler
uint64_t rip; uint64_t rip;
}; };
SafeFunction void TraceFrames(CHArchTrapFrame *Frame, int Count) SafeFunction void TraceFrames(CHArchTrapFrame *Frame, int Count, SymbolResolver::Symbols *SymHandle, bool Kernel)
{ {
#if defined(__amd64__) #if defined(__amd64__)
@ -44,9 +44,9 @@ namespace CrashHandler
#endif #endif
EHPrint("\e7925CC-"); EHPrint("\e7925CC-");
#if defined(__amd64__) #if defined(__amd64__)
EHPrint("\eAA25CC%s", KernelSymbolTable->GetSymbolFromAddress(Frame->rip)); EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->rip));
#elif defined(__i386__) #elif defined(__i386__)
EHPrint("\eAA25CC%s", KernelSymbolTable->GetSymbolFromAddress(Frame->eip)); EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->eip));
#elif defined(__aarch64__) #elif defined(__aarch64__)
#endif #endif
EHPrint("\e7981FC <- Exception"); EHPrint("\e7981FC <- Exception");
@ -57,15 +57,15 @@ namespace CrashHandler
#if defined(__amd64__) #if defined(__amd64__)
EHPrint("\e2565CC%p", (void *)Frame->rip); EHPrint("\e2565CC%p", (void *)Frame->rip);
EHPrint("\e7925CC-"); EHPrint("\e7925CC-");
if (Frame->rip >= 0xFFFFFFFF80000000 && Frame->rip <= (uint64_t)&_kernel_end) if ((Frame->rip >= 0xFFFFFFFF80000000 && Frame->rip <= (uint64_t)&_kernel_end) || !Kernel)
EHPrint("\eAA25CC%s", KernelSymbolTable->GetSymbolFromAddress(Frame->rip)); EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->rip));
else else
EHPrint("Outside Kernel"); EHPrint("Outside Kernel");
#elif defined(__i386__) #elif defined(__i386__)
EHPrint("\e2565CC%p", (void *)Frame->eip); EHPrint("\e2565CC%p", (void *)Frame->eip);
EHPrint("\e7925CC-"); EHPrint("\e7925CC-");
if (Frame->eip >= 0xC0000000 && Frame->eip <= (uint64_t)&_kernel_end) if ((Frame->eip >= 0xC0000000 && Frame->eip <= (uint64_t)&_kernel_end) || !Kernel)
EHPrint("\eAA25CC%s", KernelSymbolTable->GetSymbolFromAddress(Frame->eip)); EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->eip));
else else
EHPrint("Outside Kernel"); EHPrint("Outside Kernel");
#elif defined(__aarch64__) #elif defined(__aarch64__)
@ -78,12 +78,12 @@ namespace CrashHandler
EHPrint("\n\e2565CC%p", (void *)frames->rip); EHPrint("\n\e2565CC%p", (void *)frames->rip);
EHPrint("\e7925CC-"); EHPrint("\e7925CC-");
#if defined(__amd64__) #if defined(__amd64__)
if (frames->rip >= 0xFFFFFFFF80000000 && frames->rip <= (uint64_t)&_kernel_end) if ((frames->rip >= 0xFFFFFFFF80000000 && frames->rip <= (uint64_t)&_kernel_end) || !Kernel)
#elif defined(__i386__) #elif defined(__i386__)
if (frames->rip >= 0xC0000000 && frames->rip <= (uint64_t)&_kernel_end) if ((frames->rip >= 0xC0000000 && frames->rip <= (uint64_t)&_kernel_end) || !Kernel)
#elif defined(__aarch64__) #elif defined(__aarch64__)
#endif #endif
EHPrint("\e25CCC9%s", KernelSymbolTable->GetSymbolFromAddress(frames->rip)); EHPrint("\e25CCC9%s", SymHandle->GetSymbolFromAddress(frames->rip));
else else
EHPrint("\eFF4CA9Outside Kernel"); EHPrint("\eFF4CA9Outside Kernel");
@ -92,5 +92,6 @@ namespace CrashHandler
frames = frames->rbp; frames = frames->rbp;
} }
} }
EHPrint("\n");
} }
} }

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

@ -20,9 +20,20 @@ namespace CrashHandler
{ {
SafeFunction void DisplayStackFrameScreen(CRData data) SafeFunction void DisplayStackFrameScreen(CRData data)
{ {
EHPrint("\eFAFAFATracing 40 frames...\n"); EHPrint("\eFAFAFATracing 40 frames...");
TraceFrames(data.Frame, 40); TraceFrames(data.Frame, 40, KernelSymbolTable, true);
EHPrint("\n\n\eFAFAFATracing interrupt frames...\n"); if (data.Process)
{
EHPrint("\n\eFAFAFATracing 40 process frames...");
SymbolResolver::Symbols *sh = data.Process->ELFSymbolTable;
if (!sh)
{
EHPrint("\eFF0000< No symbol table available. >\n");
return;
}
TraceFrames(data.Frame, 40, sh, false);
}
EHPrint("\n\eFAFAFATracing interrupt frames...");
for (uint64_t i = 0; i < 8; i++) for (uint64_t i = 0; i < 8; i++)
{ {
if (EHIntFrames[i]) if (EHIntFrames[i])

2
Core/Crash/chfcts.hpp
View File

@ -256,7 +256,7 @@ namespace CrashHandler
~CrashKeyboardDriver(); ~CrashKeyboardDriver();
}; };
void TraceFrames(CHArchTrapFrame *Frame, int Count); void TraceFrames(CHArchTrapFrame *Frame, int Count, SymbolResolver::Symbols *SymHandle, bool Kernel);
void ArrowInput(uint8_t key); void ArrowInput(uint8_t key);
void UserInput(char *Input); void UserInput(char *Input);

52
Core/Symbols.cpp
View File

@ -52,13 +52,10 @@ typedef struct
namespace SymbolResolver namespace SymbolResolver
{ {
Symbols::SymbolTable SymTable[0x10000]; Symbols::Symbols(uint64_t ImageAddress)
uint64_t TotalEntries = 0;
Symbols::Symbols(uint64_t Address)
{ {
debug("Solving symbols for address: %#llx", Address); debug("Solving symbols for address: %#llx", ImageAddress);
Elf64_Ehdr *Header = (Elf64_Ehdr *)Address; Elf64_Ehdr *Header = (Elf64_Ehdr *)ImageAddress;
if (Header->e_ident[0] != 0x7F && if (Header->e_ident[0] != 0x7F &&
Header->e_ident[1] != 'E' && Header->e_ident[1] != 'E' &&
Header->e_ident[2] != 'L' && Header->e_ident[2] != 'L' &&
@ -67,7 +64,7 @@ namespace SymbolResolver
error("Invalid ELF header"); error("Invalid ELF header");
return; return;
} }
Elf64_Shdr *ElfSections = (Elf64_Shdr *)(Address + Header->e_shoff); Elf64_Shdr *ElfSections = (Elf64_Shdr *)(ImageAddress + Header->e_shoff);
Elf64_Sym *ElfSymbols = nullptr; Elf64_Sym *ElfSymbols = nullptr;
char *strtab = nullptr; char *strtab = nullptr;
@ -75,9 +72,9 @@ namespace SymbolResolver
switch (ElfSections[i].sh_type) switch (ElfSections[i].sh_type)
{ {
case SHT_SYMTAB: case SHT_SYMTAB:
ElfSymbols = (Elf64_Sym *)(Address + ElfSections[i].sh_offset); ElfSymbols = (Elf64_Sym *)(ImageAddress + ElfSections[i].sh_offset);
TotalEntries = ElfSections[i].sh_size / sizeof(Elf64_Sym); this->TotalEntries = ElfSections[i].sh_size / sizeof(Elf64_Sym);
debug("Symbol table found, %d entries", TotalEntries); debug("Symbol table found, %d entries", this->TotalEntries);
break; break;
case SHT_STRTAB: case SHT_STRTAB:
if (Header->e_shstrndx == i) if (Header->e_shstrndx == i)
@ -86,7 +83,7 @@ namespace SymbolResolver
} }
else else
{ {
strtab = (char *)Address + ElfSections[i].sh_offset; strtab = (char *)(uint64_t)ImageAddress + ElfSections[i].sh_offset;
debug("String table found, %d entries", ElfSections[i].sh_size); debug("String table found, %d entries", ElfSections[i].sh_size);
} }
break; break;
@ -95,10 +92,10 @@ namespace SymbolResolver
if (ElfSymbols != nullptr && strtab != nullptr) if (ElfSymbols != nullptr && strtab != nullptr)
{ {
size_t Index, MinimumIndex; size_t Index, MinimumIndex;
for (size_t i = 0; i < TotalEntries - 1; i++) for (size_t i = 0; i < this->TotalEntries - 1; i++)
{ {
MinimumIndex = i; MinimumIndex = i;
for (Index = i + 1; Index < TotalEntries; Index++) for (Index = i + 1; Index < this->TotalEntries; Index++)
if (ElfSymbols[Index].st_value < ElfSymbols[MinimumIndex].st_value) if (ElfSymbols[Index].st_value < ElfSymbols[MinimumIndex].st_value)
MinimumIndex = Index; MinimumIndex = Index;
Elf64_Sym tmp = ElfSymbols[MinimumIndex]; Elf64_Sym tmp = ElfSymbols[MinimumIndex];
@ -109,15 +106,28 @@ namespace SymbolResolver
while (ElfSymbols[0].st_value == 0) while (ElfSymbols[0].st_value == 0)
{ {
ElfSymbols++; ElfSymbols++;
TotalEntries--; this->TotalEntries--;
} }
trace("Symbol table loaded, %d entries (%ldKB)", TotalEntries, TO_KB(TotalEntries * sizeof(SymbolTable))); #ifdef DEBUG
for (size_t i = 0, g = TotalEntries; i < g; i++) static int once = 0;
#endif
trace("Symbol table loaded, %d entries (%ldKB)", this->TotalEntries, TO_KB(this->TotalEntries * sizeof(SymbolTable)));
for (size_t i = 0, g = this->TotalEntries; i < g; i++)
{ {
SymTable[i].Address = ElfSymbols[i].st_value; this->SymTable[i].Address = ElfSymbols[i].st_value;
SymTable[i].FunctionName = &strtab[ElfSymbols[i].st_name]; this->SymTable[i].FunctionName = &strtab[ElfSymbols[i].st_name];
#ifdef DEBUG
if (once)
debug("Symbol %d: %#llx %s", i, this->SymTable[i].Address, this->SymTable[i].FunctionName);
#endif
} }
#ifdef DEBUG
if (!once)
once++;
#endif
} }
} }
@ -126,9 +136,9 @@ namespace SymbolResolver
const __no_instrument_function char *Symbols::GetSymbolFromAddress(uint64_t Address) const __no_instrument_function char *Symbols::GetSymbolFromAddress(uint64_t Address)
{ {
Symbols::SymbolTable Result{0, (char *)"<unknown>"}; Symbols::SymbolTable Result{0, (char *)"<unknown>"};
for (size_t i = 0; i < TotalEntries; i++) for (size_t i = 0; i < this->TotalEntries; i++)
if (SymTable[i].Address <= Address && SymTable[i].Address > Result.Address) if (this->SymTable[i].Address <= Address && this->SymTable[i].Address > Result.Address)
Result = SymTable[i]; Result = this->SymTable[i];
return Result.FunctionName; return Result.FunctionName;
} }
} }

8
include/symbols.hpp
View File

@ -5,14 +5,18 @@ namespace SymbolResolver
{ {
class Symbols class Symbols
{ {
public: private:
struct SymbolTable struct SymbolTable
{ {
uint64_t Address; uint64_t Address;
char *FunctionName; char *FunctionName;
}; };
Symbols(uint64_t Address); SymbolTable SymTable[0x10000];
uint64_t TotalEntries = 0;
public:
Symbols(uint64_t ImageAddress);
~Symbols(); ~Symbols();
const char *GetSymbolFromAddress(uint64_t Address); const char *GetSymbolFromAddress(uint64_t Address);
}; };

6
include/task.hpp
View File

@ -4,9 +4,10 @@
#include <types.h> #include <types.h>
#include <interrupts.hpp> #include <interrupts.hpp>
#include <hashmap.hpp>
#include <symbols.hpp>
#include <vector.hpp> #include <vector.hpp>
#include <memory.hpp> #include <memory.hpp>
#include <hashmap.hpp>
#include <ipc.hpp> #include <ipc.hpp>
#include <debug.h> #include <debug.h>
#include <abi.h> #include <abi.h>
@ -162,6 +163,7 @@ namespace Tasking
Vector<PCB *> Children; Vector<PCB *> Children;
HashMap<InterProcessCommunication::IPCPort, uint64_t> *IPCHandles; HashMap<InterProcessCommunication::IPCPort, uint64_t> *IPCHandles;
Memory::PageTable4 *PageTable; Memory::PageTable4 *PageTable;
SymbolResolver::Symbols *ELFSymbolTable;
}; };
enum TokenTrustLevel enum TokenTrustLevel
@ -273,7 +275,7 @@ namespace Tasking
PCB *CreateProcess(PCB *Parent, PCB *CreateProcess(PCB *Parent,
const char *Name, const char *Name,
TaskTrustLevel TrustLevel); TaskTrustLevel TrustLevel, void *Image = nullptr);
TCB *CreateThread(PCB *Parent, TCB *CreateThread(PCB *Parent,
IP EntryPoint, IP EntryPoint,