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

Rework for APIC & added support for x2APIC

Browse Source
This commit is contained in:
Alex 2023-08-31 01:07:55 +03:00
parent 612e8cc726
commit 6d95cd5261
Signed by untrusted user who does not match committer: enderice2
GPG Key ID: EACC3AD603BAB4DD
12 changed files with 510 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
Architecture/amd64/cpu/AdvancedProgrammableInterruptController.cpp
View File

@ -52,23 +52,17 @@ namespace APIC
if (Register != APIC_ICRLO && if (Register != APIC_ICRLO &&
Register != APIC_ICRHI && Register != APIC_ICRHI &&
Register != APIC_ID) Register != APIC_ID)
debug("APIC::Read(%#lx) [x2=%d]", Register, x2APICSupported ? 1 : 0); debug("APIC::Read(%#lx) [x2=%d]",
Register, x2APICSupported ? 1 : 0);
#endif #endif
if (x2APICSupported) if (x2APICSupported)
{ assert(false);
if (Register != APIC_ICRHI)
return s_cst(uint32_t, rdmsr((Register >> 4) + 0x800));
else
return s_cst(uint32_t, rdmsr(0x30 + 0x800));
}
else
{
CPU::MemBar::Barrier(); CPU::MemBar::Barrier();
uint32_t ret = *((volatile uint32_t *)((uintptr_t)APICBaseAddress + Register)); uint32_t ret = *((volatile uint32_t *)((uintptr_t)APICBaseAddress + Register));
CPU::MemBar::Barrier(); CPU::MemBar::Barrier();
return ret; return ret;
} }
}
void APIC::Write(uint32_t Register, uint32_t Value) void APIC::Write(uint32_t Register, uint32_t Value)
{ {
@ -79,22 +73,16 @@ namespace APIC
Register != APIC_TICR && Register != APIC_TICR &&
Register != APIC_ICRLO && Register != APIC_ICRLO &&
Register != APIC_ICRHI) Register != APIC_ICRHI)
debug("APIC::Write(%#lx, %#lx) [x2=%d]", Register, Value, x2APICSupported ? 1 : 0); debug("APIC::Write(%#lx, %#lx) [x2=%d]",
Register, Value, x2APICSupported ? 1 : 0);
#endif #endif
if (x2APICSupported) if (x2APICSupported)
{ assert(false);
if (Register != APIC_ICRHI)
wrmsr((Register >> 4) + 0x800, Value);
else
wrmsr(MSR_X2APIC_ICR, Value);
}
else
{
CPU::MemBar::Barrier(); CPU::MemBar::Barrier();
*((volatile uint32_t *)(((uintptr_t)APICBaseAddress) + Register)) = Value; *((volatile uint32_t *)(((uintptr_t)APICBaseAddress) + Register)) = Value;
CPU::MemBar::Barrier(); CPU::MemBar::Barrier();
} }
}
void APIC::IOWrite(uint64_t Base, uint32_t Register, uint32_t Value) void APIC::IOWrite(uint64_t Base, uint32_t Register, uint32_t Value)
{ {
@ -117,30 +105,50 @@ namespace APIC
return ret; return ret;
} }
void APIC::EOI() { this->Write(APIC_EOI, 0); } void APIC::EOI()
{
if (this->x2APICSupported)
wrmsr(MSR_X2APIC_EOI, 0);
else
this->Write(APIC_EOI, 0);
}
void APIC::WaitForIPI() void APIC::WaitForIPI()
{ {
InterruptCommandRegisterLow icr = {.raw = 0}; if (this->x2APICSupported)
{
ErrorStatusRegister esr{};
esr.raw = uint32_t(rdmsr(MSR_X2APIC_ESR));
UNUSED(esr);
/* FIXME: Not sure if this is required or
how to implement it. */
}
else
{
InterruptCommandRegister icr{};
do do
{ {
icr.raw = this->Read(APIC_ICRLO); icr.split.Low = this->Read(APIC_ICRLO);
CPU::Pause(); CPU::Pause();
} while (icr.DeliveryStatus != Idle); } while (icr.DS != Idle);
}
} }
void APIC::IPI(int CPU, InterruptCommandRegisterLow icr) void APIC::ICR(InterruptCommandRegister icr)
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
if (x2APICSupported) if (x2APICSupported)
{ {
wrmsr(MSR_X2APIC_ICR, s_cst(uint32_t, icr.raw)); assert(icr.MT != LowestPriority);
assert(icr.MT != DeliveryMode);
assert(icr.MT != ExtINT);
wrmsr(MSR_X2APIC_ICR, icr.raw);
this->WaitForIPI(); this->WaitForIPI();
} }
else else
{ {
this->Write(APIC_ICRHI, (CPU << 24)); this->Write(APIC_ICRHI, icr.split.High);
this->Write(APIC_ICRLO, s_cst(uint32_t, icr.raw)); this->Write(APIC_ICRLO, icr.split.Low);
this->WaitForIPI(); this->WaitForIPI();
} }
} }
@ -148,21 +156,25 @@ namespace APIC
void APIC::SendInitIPI(int CPU) void APIC::SendInitIPI(int CPU)
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
InterruptCommandRegister icr{};
if (x2APICSupported) if (x2APICSupported)
{ {
InterruptCommandRegisterLow icr = {.raw = 0}; icr.x2.MT = INIT;
icr.DeliveryMode = INIT; icr.x2.L = Assert;
icr.Level = Assert; icr.x2.DES = uint8_t(CPU);
wrmsr(MSR_X2APIC_ICR, s_cst(uint32_t, icr.raw));
wrmsr(MSR_X2APIC_ICR, icr.raw);
this->WaitForIPI(); this->WaitForIPI();
} }
else else
{ {
InterruptCommandRegisterLow icr = {.raw = 0}; icr.MT = INIT;
icr.DeliveryMode = INIT; icr.L = Assert;
icr.Level = Assert; icr.DES = uint8_t(CPU);
this->Write(APIC_ICRHI, (CPU << 24));
this->Write(APIC_ICRLO, s_cst(uint32_t, icr.raw)); this->Write(APIC_ICRHI, icr.split.High);
this->Write(APIC_ICRLO, icr.split.Low);
this->WaitForIPI(); this->WaitForIPI();
} }
} }
@ -170,45 +182,54 @@ namespace APIC
void APIC::SendStartupIPI(int CPU, uint64_t StartupAddress) void APIC::SendStartupIPI(int CPU, uint64_t StartupAddress)
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
InterruptCommandRegister icr{};
if (x2APICSupported) if (x2APICSupported)
{ {
InterruptCommandRegisterLow icr = {.raw = 0}; icr.x2.VEC = s_cst(uint8_t, StartupAddress >> 12);
icr.Vector = s_cst(uint8_t, StartupAddress >> 12); icr.x2.MT = Startup;
icr.DeliveryMode = Startup; icr.x2.L = Assert;
icr.Level = Assert; icr.x2.DES = uint8_t(CPU);
wrmsr(MSR_X2APIC_ICR, s_cst(uint32_t, icr.raw));
wrmsr(MSR_X2APIC_ICR, icr.raw);
this->WaitForIPI(); this->WaitForIPI();
} }
else else
{ {
InterruptCommandRegisterLow icr = {.raw = 0}; icr.VEC = s_cst(uint8_t, StartupAddress >> 12);
icr.Vector = s_cst(uint8_t, StartupAddress >> 12); icr.MT = Startup;
icr.DeliveryMode = Startup; icr.L = Assert;
icr.Level = Assert; icr.DES = uint8_t(CPU);
this->Write(APIC_ICRHI, (CPU << 24));
this->Write(APIC_ICRLO, s_cst(uint32_t, icr.raw)); this->Write(APIC_ICRHI, icr.split.High);
this->Write(APIC_ICRLO, icr.split.Low);
this->WaitForIPI(); this->WaitForIPI();
} }
} }
uint32_t APIC::IOGetMaxRedirect(uint32_t APICID) uint32_t APIC::IOGetMaxRedirect(uint32_t APICID)
{ {
uint32_t TableAddress = (this->IORead((((ACPI::MADT *)PowerManager->GetMADT())->ioapic[APICID]->Address), GetIOAPICVersion)); ACPI::MADT::MADTIOApic *ioapic = ((ACPI::MADT *)PowerManager->GetMADT())->ioapic[APICID];
return ((IOAPICVersion *)&TableAddress)->MaximumRedirectionEntry; uint32_t TableAddress = (this->IORead(ioapic->Address, GetIOAPICVersion));
IOAPICVersion ver = {.raw = TableAddress};
return ver.MLE + 1;
} }
void APIC::RawRedirectIRQ(uint16_t Vector, uint32_t GSI, uint16_t Flags, int CPU, int Status) void APIC::RawRedirectIRQ(uint8_t Vector, uint32_t GSI, uint16_t Flags, uint8_t CPU, int Status)
{ {
uint64_t Value = Vector;
int64_t IOAPICTarget = -1; int64_t IOAPICTarget = -1;
for (uint64_t i = 0; ((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i] != 0; i++) ACPI::MADT *madt = (ACPI::MADT *)PowerManager->GetMADT();
if (((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i]->GSIBase <= GSI) for (size_t i = 0; i < madt->ioapic.size(); i++)
if (((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i]->GSIBase + IOGetMaxRedirect(s_cst(uint32_t, i)) > GSI) {
if (madt->ioapic[i]->GSIBase <= GSI)
{
if (madt->ioapic[i]->GSIBase + IOGetMaxRedirect(uint32_t(i)) > GSI)
{ {
IOAPICTarget = i; IOAPICTarget = i;
break; break;
} }
}
}
if (IOAPICTarget == -1) if (IOAPICTarget == -1)
{ {
@ -216,40 +237,46 @@ namespace APIC
return; return;
} }
// TODO: IOAPICRedirectEntry Entry = {.raw = 0}; IOAPICRedirectEntry Entry{};
Entry.VEC = Vector;
Entry.DES = CPU;
if (Flags & ActiveHighLow) if (Flags & ActiveHighLow)
Value |= (1 << 13); Entry.IPP = 1;
if (Flags & EdgeLevel) if (Flags & EdgeLevel)
Value |= (1 << 15); Entry.TGM = 1;
if (!Status) if (!Status)
Value |= (1 << 16); Entry.M = 1;
Value |= (((uintptr_t)CPU) << 56); uint32_t IORegister = (GSI - madt->ioapic[IOAPICTarget]->GSIBase) * 2 + 16;
uint32_t IORegister = (GSI - ((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->GSIBase) * 2 + 16; this->IOWrite(madt->ioapic[IOAPICTarget]->Address,
IORegister, Entry.split.Low);
this->IOWrite(((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->Address, IORegister, (uint32_t)Value); this->IOWrite(madt->ioapic[IOAPICTarget]->Address,
this->IOWrite(((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->Address, IORegister + 1, (uint32_t)(Value >> 32)); IORegister + 1, Entry.split.High);
} }
void APIC::RedirectIRQ(int CPU, uint16_t IRQ, int Status) void APIC::RedirectIRQ(uint8_t CPU, uint8_t IRQ, int Status)
{ {
for (uint64_t i = 0; i < ((ACPI::MADT *)PowerManager->GetMADT())->iso.size(); i++) ACPI::MADT *madt = (ACPI::MADT *)PowerManager->GetMADT();
if (((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource == IRQ) for (uint64_t i = 0; i < madt->iso.size(); i++)
if (madt->iso[i]->IRQSource == IRQ)
{ {
debug("[ISO %d] Mapping to source IRQ%#d GSI:%#lx on CPU %d", debug("[ISO %d] Mapping to source IRQ%#d GSI:%#lx on CPU %d",
i, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->GSI, CPU); i, madt->iso[i]->IRQSource, madt->iso[i]->GSI, CPU);
this->RawRedirectIRQ(((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource + 0x20, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->GSI, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->Flags, CPU, Status); this->RawRedirectIRQ(madt->iso[i]->IRQSource + 0x20,
madt->iso[i]->GSI,
madt->iso[i]->Flags,
CPU, Status);
return; return;
} }
debug("Mapping IRQ%d on CPU %d", IRQ, CPU); debug("Mapping IRQ%d on CPU %d", IRQ, CPU);
this->RawRedirectIRQ(IRQ + 0x20, IRQ, 0, CPU, Status); this->RawRedirectIRQ(IRQ + 0x20, IRQ, 0, CPU, Status);
} }
void APIC::RedirectIRQs(int CPU) void APIC::RedirectIRQs(uint8_t CPU)
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
debug("Redirecting IRQs..."); debug("Redirecting IRQs...");
@ -262,21 +289,22 @@ namespace APIC
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
APIC_BASE BaseStruct = {.raw = rdmsr(MSR_APIC_BASE)}; APIC_BASE BaseStruct = {.raw = rdmsr(MSR_APIC_BASE)};
uint64_t BaseLow = BaseStruct.ApicBaseLo; uint64_t BaseLow = BaseStruct.ABALow;
uint64_t BaseHigh = BaseStruct.ApicBaseHi; uint64_t BaseHigh = BaseStruct.ABAHigh;
this->APICBaseAddress = BaseLow << 12u | BaseHigh << 32u; this->APICBaseAddress = BaseLow << 12u | BaseHigh << 32u;
trace("APIC Address: %#lx", this->APICBaseAddress); trace("APIC Address: %#lx", this->APICBaseAddress);
Memory::Virtual().Map((void *)this->APICBaseAddress, (void *)this->APICBaseAddress, Memory::PTFlag::RW | Memory::PTFlag::PCD); Memory::Virtual().Map((void *)this->APICBaseAddress,
(void *)this->APICBaseAddress,
Memory::RW | Memory::PCD);
bool x2APICSupported = false;
if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0) if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
{ {
CPU::x86::AMD::CPUID0x00000001 cpuid; CPU::x86::AMD::CPUID0x00000001 cpuid;
cpuid.Get(); cpuid.Get();
if (cpuid.ECX.x2APIC) if (cpuid.ECX.x2APIC)
{ {
// x2APICSupported = cpuid.ECX.x2APIC; this->x2APICSupported = cpuid.ECX.x2APIC;
fixme("x2APIC is supported"); debug("x2APIC is supported");
} }
} }
else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0) else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
@ -285,39 +313,38 @@ namespace APIC
cpuid.Get(); cpuid.Get();
if (cpuid.ECX.x2APIC) if (cpuid.ECX.x2APIC)
{ {
// x2APICSupported = cpuid.ECX.x2APIC; this->x2APICSupported = cpuid.ECX.x2APIC;
fixme("x2APIC is supported"); debug("x2APIC is supported");
} }
} }
if (x2APICSupported) BaseStruct.AE = 1;
{
this->x2APICSupported = true;
wrmsr(MSR_APIC_BASE, (rdmsr(MSR_APIC_BASE) | (1 << 11)) & ~(1 << 10));
BaseStruct.EN = 1;
wrmsr(MSR_APIC_BASE, BaseStruct.raw); wrmsr(MSR_APIC_BASE, BaseStruct.raw);
}
else
{
BaseStruct.EN = 1;
wrmsr(MSR_APIC_BASE, BaseStruct.raw);
}
this->Write(APIC_TPR, 0x0); if (this->x2APICSupported)
// this->Write(APIC_SVR, this->Read(APIC_SVR) | 0x100); // 0x1FF or 0x100 ? on https://wiki.osdev.org/APIC is 0x100 {
BaseStruct.EXTD = 1;
wrmsr(MSR_APIC_BASE, BaseStruct.raw);
}
if (!this->x2APICSupported) if (!this->x2APICSupported)
{ {
this->Write(APIC_TPR, 0x0);
this->Write(APIC_DFR, 0xF0000000); this->Write(APIC_DFR, 0xF0000000);
this->Write(APIC_LDR, this->Read(APIC_ID)); this->Write(APIC_LDR, this->Read(APIC_ID));
} }
else
{
wrmsr(MSR_X2APIC_TPR, 0x0);
}
ACPI::MADT *madt = (ACPI::MADT *)PowerManager->GetMADT(); ACPI::MADT *madt = (ACPI::MADT *)PowerManager->GetMADT();
for (size_t i = 0; i < madt->nmi.size(); i++) for (size_t i = 0; i < madt->nmi.size(); i++)
{ {
if (madt->nmi[i]->processor != 0xFF && Core != madt->nmi[i]->processor) if (madt->nmi[i]->processor != 0xFF &&
return; Core != madt->nmi[i]->processor)
break;
uint32_t nmi = 0x402; uint32_t nmi = 0x402;
if (madt->nmi[i]->flags & 2) if (madt->nmi[i]->flags & 2)
@ -325,16 +352,34 @@ namespace APIC
if (madt->nmi[i]->flags & 8) if (madt->nmi[i]->flags & 8)
nmi |= 1 << 15; nmi |= 1 << 15;
if (madt->nmi[i]->lint == 0) if (madt->nmi[i]->lint == 0)
{
if (this->x2APICSupported)
wrmsr(MSR_X2APIC_LVT_LINT0, nmi);
else
this->Write(APIC_LINT0, nmi); this->Write(APIC_LINT0, nmi);
}
else if (madt->nmi[i]->lint == 1) else if (madt->nmi[i]->lint == 1)
{
if (this->x2APICSupported)
wrmsr(MSR_X2APIC_LVT_LINT1, nmi);
else
this->Write(APIC_LINT1, nmi); this->Write(APIC_LINT1, nmi);
} }
}
// Setup the spurrious interrupt vector /* Setup the spurious interrupt vector */
Spurious Spurious = {.raw = this->Read(APIC_SVR)}; Spurious svr{};
Spurious.Vector = IRQ223; // TODO: Should I map the IRQ to something? if (this->x2APICSupported)
Spurious.Software = 1; svr.raw = uint32_t(rdmsr(MSR_X2APIC_SIVR));
this->Write(APIC_SVR, s_cst(uint32_t, Spurious.raw)); else
svr.raw = this->Read(APIC_SVR);
svr.VEC = IRQ223;
svr.ASE = 1;
if (this->x2APICSupported)
wrmsr(MSR_X2APIC_SIVR, svr.raw);
else
this->Write(APIC_SVR, svr.raw);
static int once = 0; static int once = 0;
if (!once++) if (!once++)
@ -356,45 +401,85 @@ namespace APIC
void Timer::OneShot(uint32_t Vector, uint64_t Miliseconds) void Timer::OneShot(uint32_t Vector, uint64_t Miliseconds)
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
LVTTimer timer = {.raw = 0}; LVTTimer timer{};
timer.Vector = s_cst(uint8_t, Vector); timer.VEC = uint8_t(Vector);
timer.TimerMode = 0; timer.TMM = LVTTimerMode::OneShot;
if (strcmp(CPU::Hypervisor(), x86_CPUID_VENDOR_TCG) != 0)
this->lapic->Write(APIC_TDCR, DivideBy128); LVTTimerDivide Divider = DivideBy8;
if (unlikely(strcmp(CPU::Hypervisor(), x86_CPUID_VENDOR_TCG) != 0))
Divider = DivideBy128;
if (this->lapic->x2APIC)
{
wrmsr(MSR_X2APIC_DIV_CONF, Divider);
wrmsr(MSR_X2APIC_INIT_COUNT, uint32_t(Ticks * Miliseconds));
wrmsr(MSR_X2APIC_LVT_TIMER, uint32_t(timer.raw));
}
else else
this->lapic->Write(APIC_TDCR, DivideBy16); {
this->lapic->Write(APIC_TICR, s_cst(uint32_t, Ticks * Miliseconds)); this->lapic->Write(APIC_TDCR, Divider);
this->lapic->Write(APIC_TIMER, s_cst(uint32_t, timer.raw)); this->lapic->Write(APIC_TICR, uint32_t(Ticks * Miliseconds));
this->lapic->Write(APIC_TIMER, uint32_t(timer.raw));
}
} }
Timer::Timer(APIC *apic) : Interrupts::Handler(0) /* IRQ0 */ Timer::Timer(APIC *apic) : Interrupts::Handler(0) /* IRQ0 */
{ {
SmartCriticalSection(APICLock); SmartCriticalSection(APICLock);
this->lapic = apic; this->lapic = apic;
LVTTimerDivide Divider = DivideBy16; LVTTimerDivide Divider = DivideBy8;
trace("Initializing APIC timer on CPU %d", GetCurrentCPU()->ID); trace("Initializing APIC timer on CPU %d",
GetCurrentCPU()->ID);
if (this->lapic->x2APIC)
{
wrmsr(MSR_X2APIC_DIV_CONF, Divider);
wrmsr(MSR_X2APIC_INIT_COUNT, 0xFFFFFFFF);
}
else
{
this->lapic->Write(APIC_TDCR, Divider); this->lapic->Write(APIC_TDCR, Divider);
this->lapic->Write(APIC_TICR, 0xFFFFFFFF); this->lapic->Write(APIC_TICR, 0xFFFFFFFF);
}
TimeManager->Sleep(1, Time::Units::Milliseconds); TimeManager->Sleep(1, Time::Units::Milliseconds);
// Mask the timer // Mask the timer
if (this->lapic->x2APIC)
{
wrmsr(MSR_X2APIC_LVT_TIMER, 0x10000 /* LVTTimer.Mask flag */);
Ticks = 0xFFFFFFFF - rdmsr(MSR_X2APIC_CUR_COUNT);
}
else
{
this->lapic->Write(APIC_TIMER, 0x10000 /* LVTTimer.Mask flag */); this->lapic->Write(APIC_TIMER, 0x10000 /* LVTTimer.Mask flag */);
Ticks = 0xFFFFFFFF - this->lapic->Read(APIC_TCCR); Ticks = 0xFFFFFFFF - this->lapic->Read(APIC_TCCR);
}
// Config for IRQ0 timer // Config for IRQ0 timer
LVTTimer timer = {.raw = 0}; LVTTimer timer{};
timer.Vector = IRQ0; timer.VEC = IRQ0;
timer.Mask = Unmasked; timer.M = Unmasked;
timer.TimerMode = LVTTimerMode::OneShot; timer.TMM = LVTTimerMode::OneShot;
// Initialize APIC timer // Initialize APIC timer
if (this->lapic->x2APIC)
{
wrmsr(MSR_X2APIC_DIV_CONF, Divider);
wrmsr(MSR_X2APIC_INIT_COUNT, Ticks);
wrmsr(MSR_X2APIC_LVT_TIMER, timer.raw);
}
else
{
this->lapic->Write(APIC_TDCR, Divider); this->lapic->Write(APIC_TDCR, Divider);
this->lapic->Write(APIC_TICR, s_cst(uint32_t, Ticks)); this->lapic->Write(APIC_TICR, uint32_t(Ticks));
this->lapic->Write(APIC_TIMER, s_cst(uint32_t, timer.raw)); this->lapic->Write(APIC_TIMER, uint32_t(timer.raw));
trace("%d APIC Timer %d ticks in.", GetCurrentCPU()->ID, Ticks); }
trace("%d APIC Timer %d ticks in.",
GetCurrentCPU()->ID, Ticks);
KPrint("APIC Timer: \e8888FF%ld\eCCCCCC ticks.", Ticks); KPrint("APIC Timer: \e8888FF%ld\eCCCCCC ticks.", Ticks);
} }

54
Architecture/amd64/cpu/SymmetricMultiprocessing.cpp
View File

@ -53,7 +53,15 @@ SafeFunction CPUData *GetCurrentCPU()
if (unlikely(!Interrupts::apic[0])) if (unlikely(!Interrupts::apic[0]))
return &CPUs[0]; /* No APIC means we are on the BSP. */ return &CPUs[0]; /* No APIC means we are on the BSP. */
int CoreID = ((APIC::APIC *)Interrupts::apic[0])->Read(APIC::APIC_ID) >> 24; APIC::APIC *apic = (APIC::APIC *)Interrupts::apic[0];
int CoreID = 0;
if (CPUEnabled.load(std::memory_order_acquire) == true)
{
if (apic->x2APIC)
CoreID = int(CPU::x64::rdmsr(CPU::x64::MSR_X2APIC_APICID));
else
CoreID = apic->Read(APIC::APIC_ID) >> 24;
}
if (unlikely((&CPUs[CoreID])->IsActive != true)) if (unlikely((&CPUs[CoreID])->IsActive != true))
{ {
@ -94,18 +102,23 @@ namespace SMP
int Cores = madt->CPUCores + 1; int Cores = madt->CPUCores + 1;
if (Config.Cores > madt->CPUCores + 1) if (Config.Cores > madt->CPUCores + 1)
KPrint("More cores requested than available. Using %d cores", madt->CPUCores + 1); KPrint("More cores requested than available. Using %d cores",
madt->CPUCores + 1);
else if (Config.Cores != 0) else if (Config.Cores != 0)
Cores = Config.Cores; Cores = Config.Cores;
CPUCores = Cores; CPUCores = Cores;
uint64_t TrampolineLength = (uintptr_t)&_trampoline_end - (uintptr_t)&_trampoline_start; uint64_t TrampolineLength = (uintptr_t)&_trampoline_end -
(uintptr_t)&_trampoline_start;
Memory::Virtual().Map(0x0, 0x0, Memory::PTFlag::RW); Memory::Virtual().Map(0x0, 0x0, Memory::PTFlag::RW);
/* We reserved the TRAMPOLINE_START address inside Physical class. */ /* We reserved the TRAMPOLINE_START address inside Physical class. */
Memory::Virtual().Map((void *)TRAMPOLINE_START, (void *)TRAMPOLINE_START, TrampolineLength, Memory::PTFlag::RW); Memory::Virtual().Map((void *)TRAMPOLINE_START, (void *)TRAMPOLINE_START,
TrampolineLength, Memory::PTFlag::RW);
memcpy((void *)TRAMPOLINE_START, &_trampoline_start, TrampolineLength); memcpy((void *)TRAMPOLINE_START, &_trampoline_start, TrampolineLength);
debug("Trampoline address: %#lx-%#lx", TRAMPOLINE_START, TRAMPOLINE_START + TrampolineLength); debug("Trampoline address: %#lx-%#lx",
TRAMPOLINE_START,
TRAMPOLINE_START + TrampolineLength);
void *CPUTmpStack = KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE + 1)); void *CPUTmpStack = KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE + 1));
asmv("sgdt [0x580]"); asmv("sgdt [0x580]");
@ -117,26 +130,39 @@ namespace SMP
for (int i = 0; i < Cores; i++) for (int i = 0; i < Cores; i++)
{ {
ACPI::MADT::LocalAPIC *lapic = madt->lapic[i]; ACPI::MADT::LocalAPIC *lapic = madt->lapic[i];
APIC::APIC *apic = (APIC::APIC *)Interrupts::apic[0];
debug("Initializing CPU %d", lapic->APICId); debug("Initializing CPU %d", lapic->APICId);
if ((((APIC::APIC *)Interrupts::apic[0])->Read(APIC::APIC_ID) >> 24) != lapic->APICId) uint8_t APIC_ID = 0;
if (apic->x2APIC)
APIC_ID = uint8_t(CPU::x64::rdmsr(CPU::x64::MSR_X2APIC_APICID));
else
APIC_ID = uint8_t(apic->Read(APIC::APIC_ID) >> 24);
if (APIC_ID != lapic->APICId)
{ {
VPOKE(int, CORE) = i; VPOKE(int, CORE) = i;
if (!apic->x2APIC)
{
APIC::InterruptCommandRegister icr{};
icr.MT = APIC::INIT;
icr.DES = lapic->APICId;
apic->ICR(icr);
}
((APIC::APIC *)Interrupts::apic[0])->Write(APIC::APIC_ICRHI, (lapic->APICId << 24)); apic->SendInitIPI(lapic->APICId);
((APIC::APIC *)Interrupts::apic[0])->Write(APIC::APIC_ICRLO, 0x500); TimeManager->Sleep(20, Time::Units::Milliseconds);
apic->SendStartupIPI(lapic->APICId, TRAMPOLINE_START);
((APIC::APIC *)Interrupts::apic[0])->SendInitIPI(lapic->APICId);
TimeManager->Sleep(5, Time::Units::Milliseconds);
((APIC::APIC *)Interrupts::apic[0])->SendStartupIPI(lapic->APICId, TRAMPOLINE_START);
debug("Waiting for CPU %d to load...", lapic->APICId); debug("Waiting for CPU %d to load...", lapic->APICId);
uint64_t Timeout = TimeManager->CalculateTarget(2, Time::Units::Seconds); uint64_t Timeout = TimeManager->CalculateTarget(2, Time::Units::Seconds);
while (CPUEnabled.load(std::memory_order_acquire) == false) while (CPUEnabled.load(std::memory_order_acquire) == false)
{ {
if (TimeManager->GetCounter() > Timeout) if (TimeManager->GetCounter() > Timeout)
{ {
error("CPU %d failed to load!", lapic->APICId); error("CPU %d failed to load!", lapic->APICId);
KPrint("\eFF8C19CPU \e8888FF%d \eFF8C19failed to load!", lapic->APICId); KPrint("\eFF8C19CPU \e8888FF%d \eFF8C19failed to load!",
lapic->APICId);
break; break;
} }
CPU::Pause(); CPU::Pause();

346
Architecture/amd64/cpu/apic.hpp
View File

@ -27,32 +27,66 @@ namespace APIC
{ {
enum APICRegisters enum APICRegisters
{ {
// source from: https://github.com/pdoane/osdev/blob/master/intr/local_apic.c /* APIC ID Register */
APIC_ID = 0x20, // Local APIC ID APIC_ID = 0x20,
APIC_VER = 0x30, // Local APIC Version /* APIC Version Register */
APIC_TPR = 0x80, // Task Priority APIC_VER = 0x30,
APIC_APR = 0x90, // Arbitration Priority /* Task Priority Register (TPR) */
APIC_PPR = 0xA0, // Processor Priority APIC_TPR = 0x80,
APIC_EOI = 0xB0, // EOI /* Arbitration Priority Register (APR) */
APIC_RRD = 0xC0, // Remote Read APIC_APR = 0x90,
APIC_LDR = 0xD0, // Logical Destination /* Processor Priority Register (PPR) */
APIC_DFR = 0xE0, // Destination Format APIC_PPR = 0xA0,
APIC_SVR = 0xF0, // Spurious Interrupt Vector /* End of Interrupt Register (EOI) */
APIC_ISR = 0x100, // In-Service (8 registers) APIC_EOI = 0xB0,
APIC_TMR = 0x180, // Trigger Mode (8 registers) /* Remote Read Register */
APIC_IRR = 0x200, // Interrupt Request (8 registers) APIC_RRD = 0xC0,
APIC_ESR = 0x280, // Error Status /* Logical Destination Register (LDR) */
APIC_ICRLO = 0x300, // Interrupt Command APIC_LDR = 0xD0,
APIC_ICRHI = 0x310, // Interrupt Command [63:32] /* Destination Format Register (DFR) */
APIC_TIMER = 0x320, // LVT Timer APIC_DFR = 0xE0,
APIC_THERMAL = 0x330, // LVT Thermal Sensor /* Spurious Interrupt Vector Register */
APIC_PERF = 0x340, // LVT Performance Counter APIC_SVR = 0xF0,
APIC_LINT0 = 0x350, // LVT LINT0 /* In-Service Register (ISR) */
APIC_LINT1 = 0x360, // LVT LINT1 APIC_ISR = 0x100,
APIC_ERROR = 0x370, // LVT Error /* Trigger Mode Register (TMR) */
APIC_TICR = 0x380, // Initial Count (for Timer) APIC_TMR = 0x180,
APIC_TCCR = 0x390, // Current Count (for Timer) /* Interrupt Request Register (IRR) */
APIC_TDCR = 0x3E0, // Divide Configuration (for Timer) APIC_IRR = 0x200,
/* Error Status Register (ESR) */
APIC_ESR = 0x280,
/* Interrupt Command Register Low (bits 31:0) */
APIC_ICRLO = 0x300,
/* Interrupt Command Register High (bits 63:32) */
APIC_ICRHI = 0x310,
/* Timer Local Vector Table Entry */
APIC_TIMER = 0x320,
/* Thermal Local Vector Table Entry */
APIC_THERMAL = 0x330,
/* Performance Counter Local Vector Table Entry */
APIC_PERF = 0x340,
/* Local Interrupt 0 Vector Table Entry */
APIC_LINT0 = 0x350,
/* Local Interrupt 1 Vector Table Entry */
APIC_LINT1 = 0x360,
/* Error Vector Table Entry */
APIC_ERROR = 0x370,
/* Timer Initial Count Register */
APIC_TICR = 0x380,
/* Timer Current Count Register */
APIC_TCCR = 0x390,
/* Timer Divide Configuration Register */
APIC_TDCR = 0x3E0,
/* Extended APIC Feature Register */
APIC_EFR = 0x400,
/* Extended APIC Control Register */
APIC_ECR = 0x410,
/* Specific End of Interrupt Register (SEOI) */
APIC_SEOI = 0x420,
/* Interrupt Enable Registers (IER) */
APIC_IER0 = 0x480,
/* Extended Interrupt [3:0] Local Vector Table Registers */
APIC_EILVT0 = 0x500,
}; };
enum IOAPICRegisters enum IOAPICRegisters
@ -66,12 +100,12 @@ namespace APIC
EdgeLevel = 8 EdgeLevel = 8
}; };
enum APICDeliveryMode enum APICMessageType
{ {
Fixed = 0b000, Fixed = 0b000,
LowestPriority = 0b001, /* Reserved */ LowestPriority = 0b001, /* Reserved */
SMI = 0b010, SMI = 0b010,
APIC_DELIVERY_MODE_RESERVED0 = 0b011, /* Reserved */ DeliveryMode = 0b011, /* Reserved */
NMI = 0b100, NMI = 0b100,
INIT = 0b101, INIT = 0b101,
Startup = 0b110, Startup = 0b110,
@ -139,163 +173,153 @@ namespace APIC
{ {
struct struct
{ {
/** @brief Interrupt Vector */ /** Vector */
uint64_t Vector : 8; uint64_t VEC : 8;
/** @brief Reserved */ /** Reserved */
uint64_t Reserved0 : 4; uint64_t Reserved0 : 4;
/** /** Delivery Status */
* @brief Delivery Status uint64_t DS : 1;
* /** Reserved */
* 0: Idle
* 1: Send Pending
*/
uint64_t DeliveryStatus : 1;
/** @brief Reserved */
uint64_t Reserved1 : 3; uint64_t Reserved1 : 3;
/** /** Mask */
* @brief Mask uint64_t M : 1;
* /** Timer Mode */
* 0: Not masked uint64_t TMM : 1;
* 1: Masked /** Reserved */
*/
uint64_t Mask : 1;
/** @brief Timer Mode
*
* 0: One-shot
* 1: Periodic
* 2: TSC-Deadline
*/
uint64_t TimerMode : 1;
/** @brief Reserved */
uint64_t Reserved2 : 14; uint64_t Reserved2 : 14;
}; };
uint64_t raw; uint32_t raw;
} __packed LVTTimer; } __packed LVTTimer;
typedef union typedef union
{ {
struct struct
{ {
/** @brief Spurious Vector */ /** Vector */
uint64_t Vector : 8; uint64_t VEC : 8;
/** @brief Enable or disable APIC software */ /** APIC Software Enable */
uint64_t Software : 1; uint64_t ASE : 1;
/** @brief Focus Processor Checking */ /** Focus CPU Core Checking */
uint64_t FocusProcessorChecking : 1; uint64_t FCC : 1;
/** @brief Reserved */ /** Reserved */
uint64_t Reserved : 2; uint64_t Reserved0 : 22;
/** @brief Disable EOI Broadcast */
uint64_t DisableEOIBroadcast : 1;
/** @brief Reserved */
uint64_t Reserved1 : 19;
}; };
uint64_t raw; uint32_t raw;
} __packed Spurious; } __packed Spurious;
typedef union typedef union
{ {
struct struct
{ {
/** @brief Interrupt Vector */ /** Vector */
uint64_t Vector : 8; uint64_t VEC : 8;
/** @brief Delivery Mode */ /** Message Type */
uint64_t DeliveryMode : 3; uint64_t MT : 3;
/** @brief Destination Mode /** Destination Mode */
* uint64_t DM : 1;
* 0: Physical /** Delivery Status */
* 1: Logical uint64_t DS : 1;
*/ /** Reserved */
uint64_t DestinationMode : 1;
/** @brief Delivery Status
*
* @note Reserved when in x2APIC mode
*/
uint64_t DeliveryStatus : 1;
/** @brief Reserved */
uint64_t Reserved0 : 1; uint64_t Reserved0 : 1;
/** @brief Level /** Level */
* uint64_t L : 1;
* 0: Deassert /** Trigger Mode */
* 1: Assert uint64_t TGM : 1;
*/ /** Remote Read Status */
uint64_t Level : 1; uint64_t RSS : 2;
/** @brief Trigger Mode /** Destination Shorthand */
* uint64_t DSH : 2;
* 0: Edge /** Reserved */
* 1: Level uint64_t Reserved2 : 36;
*/ /** Destination */
uint64_t TriggerMode : 1; uint64_t DES : 8;
/** @brief Reserved */ };
struct
{
/** Vector */
uint64_t VEC : 8;
/** Message Type */
uint64_t MT : 3;
/** Destination Mode */
uint64_t DM : 1;
/** Reserved */
uint64_t Reserved0 : 2;
/** Level */
uint64_t L : 1;
/** Trigger Mode */
uint64_t TGM : 1;
/** Reserved */
uint64_t Reserved1 : 2; uint64_t Reserved1 : 2;
/** @brief Destination Shorthand /** Destination Shorthand */
* uint64_t DSH : 2;
* 0: No shorthand /** Reserved */
* 1: Self
* 2: All including self
* 3: All excluding self
*/
uint64_t DestinationShorthand : 2;
/** @brief Reserved */
uint64_t Reserved2 : 12; uint64_t Reserved2 : 12;
}; /** Destination */
uint64_t DES : 32;
} x2;
struct
{
uint32_t Low;
uint32_t High;
} split;
uint64_t raw; uint64_t raw;
} __packed InterruptCommandRegisterLow; } __packed InterruptCommandRegister;
typedef union typedef union
{ {
struct struct
{ {
/** @brief Reserved */ /** Reserved */
uint64_t Reserved0 : 24; uint64_t Reserved0 : 2;
/** @brief Destination */ /** Sent Accept Error */
uint64_t Destination : 8; uint64_t SAE : 1;
/** Receive Accept Error */
uint64_t RAE : 1;
/** Reserved */
uint64_t Reserved1 : 1;
/** Sent Illegal Vector */
uint64_t SIV : 1;
/** Received Illegal Vector */
uint64_t RIV : 1;
/** Illegal Register Address */
uint64_t IRA : 1;
/** Reserved */
uint64_t Reserved2 : 24;
}; };
uint64_t raw; uint32_t raw;
} __packed InterruptCommandRegisterHigh; } ErrorStatusRegister;
typedef union typedef union
{ {
struct struct
{ {
/** @brief Interrupt Vector */ /** Interrupt Vector */
uint64_t Vector : 8; uint64_t VEC : 8;
/** @brief Delivery Mode */ /** Delivery Mode */
uint64_t DeliveryMode : 3; uint64_t MT : 3;
/** @brief Destination Mode /** Destination Mode */
* uint64_t DM : 1;
* 0: Physical /** Delivery Status */
* 1: Logical uint64_t DS : 1;
*/ /** Interrupt Input Pin Polarity */
uint64_t DestinationMode : 1; uint64_t IPP : 1;
/** @brief Delivery Status */ /** Remote IRR */
uint64_t DeliveryStatus : 1; uint64_t RIR : 1;
/** @brief Interrupt Input Pin Polarity /** Trigger Mode */
* uint64_t TGM : 1;
* 0: Active High /** Mask */
* 1: Active Low uint64_t M : 1;
*/ /** Reserved */
uint64_t Polarity : 1;
/** @brief Remote IRR */
uint64_t RemoteIRR : 1;
/** @brief Trigger Mode
*
* 0: Edge
* 1: Level
*/
uint64_t TriggerMode : 1;
/** @brief Mask */
uint64_t Mask : 1;
/** @brief Reserved */
uint64_t Reserved0 : 15; uint64_t Reserved0 : 15;
/** @brief Reserved */ /** Reserved */
uint64_t Reserved1 : 24; uint64_t Reserved1 : 24;
/** @brief Destination */ /** Destination */
uint64_t DestinationID : 8; uint64_t DES : 8;
}; };
struct struct
{ {
uint64_t Low; uint32_t Low;
uint64_t High; uint32_t High;
} split; } split;
uint64_t raw; uint64_t raw;
} __packed IOAPICRedirectEntry; } __packed IOAPICRedirectEntry;
@ -304,12 +328,18 @@ namespace APIC
{ {
struct struct
{ {
uint64_t Version : 8; /** Version */
uint64_t Reserved : 8; uint64_t VER : 8;
uint64_t MaximumRedirectionEntry : 8; /** Reserved */
uint64_t Reserved2 : 8; uint64_t Reserved0 : 8;
/** Max LVT Entries */
uint64_t MLE : 8;
/** Reserved */
uint64_t Reserved1 : 7;
/** Extended APIC Register Space Present */
uint64_t EAS : 1;
}; };
uint64_t raw; uint32_t raw;
} __packed IOAPICVersion; } __packed IOAPICVersion;
class APIC class APIC
@ -319,19 +349,21 @@ namespace APIC
uint64_t APICBaseAddress = 0; uint64_t APICBaseAddress = 0;
public: public:
decltype(x2APICSupported) &x2APIC = x2APICSupported;
uint32_t Read(uint32_t Register); uint32_t Read(uint32_t Register);
void Write(uint32_t Register, uint32_t Value); void Write(uint32_t Register, uint32_t Value);
void IOWrite(uint64_t Base, uint32_t Register, uint32_t Value); void IOWrite(uint64_t Base, uint32_t Register, uint32_t Value);
uint32_t IORead(uint64_t Base, uint32_t Register); uint32_t IORead(uint64_t Base, uint32_t Register);
void EOI(); void EOI();
void RedirectIRQs(int CPU = 0); void RedirectIRQs(uint8_t CPU = 0);
void WaitForIPI(); void WaitForIPI();
void IPI(int CPU, InterruptCommandRegisterLow icr); void ICR(InterruptCommandRegister icr);
void SendInitIPI(int CPU); void SendInitIPI(int CPU);
void SendStartupIPI(int CPU, uint64_t StartupAddress); void SendStartupIPI(int CPU, uint64_t StartupAddress);
uint32_t IOGetMaxRedirect(uint32_t APICID); uint32_t IOGetMaxRedirect(uint32_t APICID);
void RawRedirectIRQ(uint16_t Vector, uint32_t GSI, uint16_t Flags, int CPU, int Status); void RawRedirectIRQ(uint8_t Vector, uint32_t GSI, uint16_t Flags, uint8_t CPU, int Status);
void RedirectIRQ(int CPU, uint16_t IRQ, int Status); void RedirectIRQ(uint8_t CPU, uint8_t IRQ, int Status);
APIC(int Core); APIC(int Core);
~APIC(); ~APIC();
}; };

10
Core/CPU.cpp
View File

@ -267,12 +267,10 @@ namespace CPU
cr4.OSXMMEXCPT = 1; cr4.OSXMMEXCPT = 1;
CPUData *CoreData = GetCPU(Core); CPUData *CoreData = GetCPU(Core);
CoreData->Data.FPU = (CPU::x64::FXState *)KernelAllocator.RequestPages(TO_PAGES(sizeof(CPU::x64::FXState) + 1)); CoreData->Data.FPU.mxcsr = 0b0001111110000000;
memset(CoreData->Data.FPU, 0, FROM_PAGES(TO_PAGES(sizeof(CPU::x64::FXState)))); CoreData->Data.FPU.mxcsrmask = 0b1111111110111111;
CoreData->Data.FPU->mxcsr = 0b0001111110000000; CoreData->Data.FPU.fcw = 0b0000001100111111;
CoreData->Data.FPU->mxcsrmask = 0b1111111110111111; CPU::x64::fxrstor(&CoreData->Data.FPU);
CoreData->Data.FPU->fcw = 0b0000001100111111;
CPU::x64::fxrstor(CoreData->Data.FPU);
SSEEnableAfter = true; SSEEnableAfter = true;
} }

2
Core/DifferentiatedSystemDescriptionTable.cpp
View File

@ -263,7 +263,7 @@ namespace ACPI
} }
} }
((APIC::APIC *)Interrupts::apic[0])->RedirectIRQ(0, acpi->FADT->SCI_Interrupt, 1); ((APIC::APIC *)Interrupts::apic[0])->RedirectIRQ(0, uint8_t(acpi->FADT->SCI_Interrupt), 1);
return; return;
} }
warn("Failed to parse _S5 in ACPI"); warn("Failed to parse _S5 in ACPI");

8
Core/InterruptsManager.cpp
View File

@ -110,7 +110,7 @@ namespace Interrupts
// TODO: This function is called by SMP too. Do not initialize timers that doesn't support multiple cores. // TODO: This function is called by SMP too. Do not initialize timers that doesn't support multiple cores.
apic[Core] = new APIC::APIC(Core); apic[Core] = new APIC::APIC(Core);
if (Core == Config.IOAPICInterruptCore) // Redirect IRQs to the specified core. if (Core == Config.IOAPICInterruptCore) // Redirect IRQs to the specified core.
((APIC::APIC *)apic[Core])->RedirectIRQs(Core); ((APIC::APIC *)apic[Core])->RedirectIRQs(uint8_t(Core));
} }
else else
{ {
@ -168,7 +168,8 @@ namespace Interrupts
Core = CoreData->ID; Core = CoreData->ID;
/* If this is false, we have a big problem. */ /* If this is false, we have a big problem. */
if (likely(Frame->InterruptNumber < CPU::x86::IRQ223 && Frame->InterruptNumber > CPU::x86::ISR0)) if (likely(Frame->InterruptNumber < CPU::x86::IRQ223 &&
Frame->InterruptNumber > CPU::x86::ISR0))
{ {
/* Halt core interrupt */ /* Halt core interrupt */
if (unlikely(Frame->InterruptNumber == CPU::x86::IRQ29)) if (unlikely(Frame->InterruptNumber == CPU::x86::IRQ29))
@ -201,7 +202,8 @@ namespace Interrupts
if (likely(apic[Core])) if (likely(apic[Core]))
{ {
((APIC::APIC *)Interrupts::apic[Core])->EOI(); APIC::APIC *this_apic = (APIC::APIC *)apic[Core];
this_apic->EOI();
// TODO: Handle PIC too // TODO: Handle PIC too
return; return;
} }

2
SystemCalls/Native.cpp
View File

@ -349,7 +349,7 @@ static int sys_fork(SysFrm *Frame)
ReturnAddress = Frame->ReturnAddress; ReturnAddress = Frame->ReturnAddress;
ChildStackPointer = Frame->StackPointer; ChildStackPointer = Frame->StackPointer;
memcpy(NewThread->FPU, Thread->FPU, sizeof(CPU::x64::FXState)); memcpy(&NewThread->FPU, &Thread->FPU, sizeof(CPU::x64::FXState));
NewThread->Stack->Fork(Thread->Stack); NewThread->Stack->Fork(Thread->Stack);
NewThread->Info = Thread->Info; NewThread->Info = Thread->Info;
NewThread->Registers = Thread->Registers; NewThread->Registers = Thread->Registers;

4
Tasking/Scheduler.cpp
View File

@ -525,7 +525,7 @@ namespace Tasking
else else
{ {
CurrentCPU->CurrentThread->Registers = *Frame; CurrentCPU->CurrentThread->Registers = *Frame;
CPU::x64::fxsave(CurrentCPU->CurrentThread->FPU); CPU::x64::fxsave(&CurrentCPU->CurrentThread->FPU);
CurrentCPU->CurrentThread->ShadowGSBase = CPU::x64::rdmsr(CPU::x64::MSR_SHADOW_GS_BASE); CurrentCPU->CurrentThread->ShadowGSBase = CPU::x64::rdmsr(CPU::x64::MSR_SHADOW_GS_BASE);
CurrentCPU->CurrentThread->GSBase = CPU::x64::rdmsr(CPU::x64::MSR_GS_BASE); CurrentCPU->CurrentThread->GSBase = CPU::x64::rdmsr(CPU::x64::MSR_GS_BASE);
CurrentCPU->CurrentThread->FSBase = CPU::x64::rdmsr(CPU::x64::MSR_FS_BASE); CurrentCPU->CurrentThread->FSBase = CPU::x64::rdmsr(CPU::x64::MSR_FS_BASE);
@ -616,7 +616,7 @@ namespace Tasking
/* Not sure if this is needed, but it's better to be safe than sorry. */ /* Not sure if this is needed, but it's better to be safe than sorry. */
asmv("movq %cr3, %rax"); asmv("movq %cr3, %rax");
asmv("movq %rax, %cr3"); asmv("movq %rax, %cr3");
CPU::x64::fxrstor(CurrentCPU->CurrentThread->FPU); CPU::x64::fxrstor(&CurrentCPU->CurrentThread->FPU);
CPU::x64::wrmsr(CPU::x64::MSR_SHADOW_GS_BASE, CurrentCPU->CurrentThread->ShadowGSBase); CPU::x64::wrmsr(CPU::x64::MSR_SHADOW_GS_BASE, CurrentCPU->CurrentThread->ShadowGSBase);
CPU::x64::wrmsr(CPU::x64::MSR_GS_BASE, CurrentCPU->CurrentThread->GSBase); CPU::x64::wrmsr(CPU::x64::MSR_GS_BASE, CurrentCPU->CurrentThread->GSBase);
CPU::x64::wrmsr(CPU::x64::MSR_FS_BASE, CurrentCPU->CurrentThread->FSBase); CPU::x64::wrmsr(CPU::x64::MSR_FS_BASE, CurrentCPU->CurrentThread->FSBase);

23
Tasking/Thread.cpp
View File

@ -458,27 +458,10 @@ namespace Tasking
this->Security.ExecutionMode = this->Security.ExecutionMode =
this->Parent->Security.ExecutionMode; this->Parent->Security.ExecutionMode;
std::size_t FXPgs = TO_PAGES(sizeof(CPU::x64::FXState) + 1);
this->FPU = (CPU::x64::FXState *)this->Memory->RequestPages(FXPgs);
memset(this->FPU, 0, sizeof(CPU::x64::FXState));
// TODO: Is really a good idea to use the FPU in kernel mode? // TODO: Is really a good idea to use the FPU in kernel mode?
this->FPU->mxcsr = 0b0001111110000000; this->FPU.mxcsr = 0b0001111110000000;
this->FPU->mxcsrmask = 0b1111111110111111; this->FPU.mxcsrmask = 0b1111111110111111;
this->FPU->fcw = 0b0000001100111111; this->FPU.fcw = 0b0000001100111111;
// CPU::x64::fxrstor(this->FPU);
// uint16_t FCW = 0b1100111111;
// asmv("fldcw %0"
// :
// : "m"(FCW)
// : "memory");
// uint32_t MXCSR = 0b1111110000000;
// asmv("ldmxcsr %0"
// :
// : "m"(MXCSR)
// : "memory");
// CPU::x64::fxsave(this->FPU);
#ifdef DEBUG #ifdef DEBUG
#ifdef a64 #ifdef a64

39
include/cpu.hpp
View File

@ -534,27 +534,36 @@ namespace CPU
{ {
struct struct
{ {
/** @brief Reserved */ /** Reserved */
uint32_t Reserved0 : 8; uint64_t Reserved0 : 8;
/** /** Boot Strap CPU Core */
* @brief BSP Flag uint64_t BSC : 1;
* @details If the BSP flag is set to 1, the processor is the bootstrap processor. /** Reserved */
*/ uint64_t Reserved1 : 1;
uint32_t BSP : 1; /** x2APIC Mode Enable */
/** @brief Reserved */ uint64_t EXTD : 1;
uint32_t Reserved1 : 1; /** APIC Enable */
/** @brief Enable x2APIC mode */ uint64_t AE : 1;
uint32_t EXTD : 1;
/** @brief APIC Global Enable */
uint32_t EN : 1;
/** @brief APIC Base Low Address */ /** @brief APIC Base Low Address */
uint32_t ApicBaseLo : 20; uint64_t ABALow : 20;
/** @brief APIC Base High Address */ /** @brief APIC Base High Address */
uint32_t ApicBaseHi : 32; uint64_t ABAHigh : 32;
/** Reserved */
uint64_t Reserved2 : 12;
}; };
uint64_t raw; uint64_t raw;
} __packed APIC_BASE; } __packed APIC_BASE;
typedef union
{
struct
{
uint64_t Reserved : 24;
uint64_t AID : 8;
};
uint32_t raw;
} __packed APIC_ID;
typedef union typedef union
{ {
struct struct

6
include/smp.hpp
View File

@ -30,11 +30,9 @@
struct CPUArchData struct CPUArchData
{ {
#if defined(a64) #if defined(a64)
CPU::x64::FXState *FPU; __aligned(16) CPU::x64::FXState FPU{};
/* TODO */
#elif defined(a32) #elif defined(a32)
CPU::x32::FXState *FPU; __aligned(16) CPU::x32::FXState FPU{};
/* TODO */
#elif defined(aa64) #elif defined(aa64)
#endif #endif
}; };

2
include/task.hpp
View File

@ -198,7 +198,7 @@ namespace Tasking
uintptr_t Registers; // TODO uintptr_t Registers; // TODO
#endif #endif
uintptr_t IPHistory[128]; uintptr_t IPHistory[128];
CPU::x64::FXState *FPU; __aligned(16) CPU::x64::FXState FPU;
/* Info & Security info */ /* Info & Security info */
struct struct