Manages the CPU and its cores. More...

#include <cpu.h>

Public Member Functions
	CPU (GlobalDescriptorTable gdt, Multiboot multiboot)
	Constructor for the CPU class.

void	find_cores () const
	Search the madt for cores and store them.

void	init_cores ()
	Wake up all the cores.

Static Public Member Functions
static cpu_status_t *	prepare_for_panic (cpu_status_t *status=nullptr, const string &msg="")
	Ensure the CPU must panic and prepare for it if so.

static void	PANIC (const char message, cpu_status_t status=nullptr)
	Puts the CPU into a panic state and halts it. Dumps the stack trace and registers.

static void	halt ()
	Halts the CPU indefinitely.

static Core *	executing_core ()
	Gets the core that is currently executing.

static bool	check_nx ()
	Checks if the No Execute page flag is supported.

static void	get_status (cpu_status_t *status)
	Gets the current CPU status into the provided structure.

static void	set_status (cpu_status_t *status)
	Sets the CPU registers from the provided structure.

static void	print_registers (cpu_status_t *status)
	Prints the CPU registers from the provided structure.

static uint64_t	read_msr (uint32_t msr)
	Reads the value of the specified MSR.

static void	write_msr (uint32_t msr, uint64_t value)
	Writes the specified value to the specified MSR.

static void	cpuid (uint32_t leaf, uint32_t eax, uint32_t ebx, uint32_t ecx, uint32_t edx)
	Executes the CPUID instruction with the specified leaf and returns the results in the provided pointers.

static bool	check_cpu_feature (CPU_FEATURE_ECX feature)
	Checks if a CPU feature is supported (ECX Register)

static bool	check_cpu_feature (CPU_FEATURE_EDX feature)
	Checks if a CPU feature is supported (EDX Register)

static void	stack_trace (size_t, cpu_status_t *status=nullptr)
	Prints a stack trace up to the specified level.

static void	enable_write_protect ()

static void	disable_write_protect ()

Public Attributes
hardwarecommunication::AdvancedConfigurationAndPowerInterface	acpi
	The ACPI interface for the CPU.

hardwarecommunication::AdvancedProgrammableInterruptController	apic
	The APIC interface for the CPU.

Static Public Attributes
static Core *	panic_core = nullptr
	The core that triggered the panic.

static common::Spinlock	panic_lock
	Lock to prevent multiple panics at once.

static common::Vector< Core * >	cores
	The list of CPU cores in the system (populated during initialization, includes the BSP and cores that failed to start)

Detailed Description

Manages the CPU and its cores.

Definition at line 256 of file cpu.h.

Constructor & Destructor Documentation

◆ CPU()

CPU::CPU	(	GlobalDescriptorTable *	gdt,
		Multiboot *	multiboot
	)

Constructor for the CPU class.

Parameters

gdt	The global descriptor table
multiboot	The multiboot information struct

Definition at line 251 of file cpu.cpp.

: acpi(multiboot),
  apic(&acpi)
{
 
    Logger::INFO() << "Setting up CPU \n";
    find_cores();
 
    // Manually set up the BSP
    auto bsp = cores[0];
    bsp -> m_bsp = true;
    bsp -> active = true;
    bsp -> gdt = gdt;
    bsp -> local_apic = apic.local_apic();
    bsp -> init_tss();
    bsp -> init_sse();
 
}

References apic, cores, find_cores(), MaxOS::Logger::INFO(), and MaxOS::hardwarecommunication::AdvancedProgrammableInterruptController::local_apic().

Member Function Documentation

◆ check_cpu_feature() [1/2]

bool CPU::check_cpu_feature ( CPU_FEATURE_ECX feature )

static

Checks if a CPU feature is supported (ECX Register)

Parameters

feature The feature to check

Returns: If the feature is supported

Definition at line 612 of file cpu.cpp.

                                                   {
 
    // Get the CPUID
    uint32_t eax, ebx, ecx, edx;
    cpuid(0x1, &eax, &ebx, &ecx, &edx);
 
    // Check the feature
    return ecx & (uint32_t) feature;
}

References cpuid().

Referenced by MaxOS::system::Core::init_sse().

◆ check_cpu_feature() [2/2]

bool CPU::check_cpu_feature ( CPU_FEATURE_EDX feature )

static

Checks if a CPU feature is supported (EDX Register)

Parameters

feature The feature to check

Returns: True if the feature is supported

Definition at line 628 of file cpu.cpp.

                                                   {
 
    // Get the CPUID
    uint32_t eax, ebx, ecx, edx;
    cpuid(0x1, &eax, &ebx, &ecx, &edx);
 
    // Check the feature
    return edx & (uint32_t) feature;
}

References cpuid().

◆ check_nx()

bool CPU::check_nx ( )

static

Checks if the No Execute page flag is supported.

Returns: True if the NX flag is supported

Definition at line 642 of file cpu.cpp.

                   {
 
    // Get the EFER MSR
    uint64_t efer = read_msr(0xC0000080);
 
    // Check if the NX flag is supported (bit 11)
    bool supported = efer & (1 << 11);
    Logger::DEBUG() << "NX: " << (supported ? "Supported" : "Not Supported") << "\n";
 
    // Return if the NX flag is supported
    return supported;
}

References MaxOS::Logger::DEBUG(), and read_msr().

Referenced by MaxOS::memory::PhysicalMemoryManager::PhysicalMemoryManager().

◆ cpuid()

void CPU::cpuid	(	uint32_t	leaf,
		uint32_t *	eax,
		uint32_t *	ebx,
		uint32_t *	ecx,
		uint32_t *	edx
	)

static

Executes the CPUID instruction with the specified leaf and returns the results in the provided pointers.

Parameters

leaf	The CPUID leaf to query
eax	The pointer to store the EAX result
ebx	The pointer to store the EBX result
ecx	The pointer to store the ECX result
edx	The pointer to store the EDX result

Definition at line 402 of file cpu.cpp.

                                                                                         {
 
    // Call the cpuid instruction
    __get_cpuid(leaf, eax, ebx, ecx, edx);
}

Referenced by check_cpu_feature(), check_cpu_feature(), executing_core(), and MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC().

◆ disable_write_protect()

void CPU::disable_write_protect ( )

static

Definition at line 445 of file cpu.cpp.

                                {
 
    // Read the current state
    uint64_t cr0;
    asm volatile("mov %%cr0, %0" : "=r"(cr0));
 
    // Update to have WP bit disabled
    cr0 &= ~(1ULL << 16);
    asm volatile("mov %0, %%cr0" : : "r"(cr0));
 
}

◆ enable_write_protect()

void CPU::enable_write_protect ( )

static

Definition at line 433 of file cpu.cpp.

                               {
 
    // Read the current state
    uint64_t cr0;
    asm volatile("mov %%cr0, %0" : "=r"(cr0));
 
    // Update to have WP bit enabled
    cr0 |= (1ULL << 16);
    asm volatile("mov %0, %%cr0" : : "r"(cr0));
 
}

◆ executing_core()

Core * CPU::executing_core ( )

static

Gets the core that is currently executing.

Returns: The currently executing core

Definition at line 660 of file cpu.cpp.

                          {
 
    // No cores?
    if(cores.empty())
        return nullptr;
 
    // Get the id of this core
    uint32_t eax, ebx, ecx, edx;
    CPU::cpuid(1, &eax, &ebx, &ecx, &edx);
    uint32_t core_id = (ebx >> 24) & 0xFF;
 
    return cores[core_id];
}

References cores, and cpuid().

Referenced by core_main(), MaxOS::processes::GlobalScheduler::core_scheduler(), MaxOS::hardwarecommunication::GeneralProtectionHandler::get_message(), MaxOS::hardwarecommunication::InterruptManager::handle_interrupt_request(), MaxOS::processes::Thread::load_port_bitmap(), prepare_for_panic(), MaxOS::processes::GlobalScheduler::print_running_header(), MaxOS::processes::Thread::restore_sse_state(), MaxOS::processes::Thread::save_sse_state(), and MaxOS::processes::Thread::Thread().

◆ find_cores()

void CPU::find_cores ( ) const

Search the madt for cores and store them.

Todo:: Support for x2apic

Definition at line 564 of file cpu.cpp.

                           {
 
    // Now that memory is set up the vector can be used
    cores.reserve(1);
 
    // Search and setup each core
    int index = 0;
    while (true){
 
        // Try to find a processor
        MADTEntry* processor_madt = apic.io_apic()->get_madt_item(MADT_TYPE::PROCESSOR_APIC, index);
        if(!processor_madt)
            break;
 
        // Create a cpu
        auto* processor_apic = (madt_processor_apic_t*) ((uint64_t) processor_madt + sizeof(MADTEntry));
        cores.push_back(new Core(processor_apic));
        index++;
    }
}

References apic, cores, MaxOS::hardwarecommunication::IOAPIC::get_madt_item(), and MaxOS::hardwarecommunication::AdvancedProgrammableInterruptController::io_apic().

Referenced by CPU().

◆ get_status()

void CPU::get_status ( cpu_status_t * status )

static

Gets the current CPU status into the provided structure.

Parameters

status The structure to fill with the CPU status

Definition at line 286 of file cpu.cpp.

                                         {
 
    // Get the registers
    asm volatile("mov %%r15, %0" : "=r" (status->r15));
    asm volatile("mov %%r14, %0" : "=r" (status->r14));
    asm volatile("mov %%r13, %0" : "=r" (status->r13));
    asm volatile("mov %%r12, %0" : "=r" (status->r12));
    asm volatile("mov %%r11, %0" : "=r" (status->r11));
    asm volatile("mov %%r10, %0" : "=r" (status->r10));
    asm volatile("mov %%r9, %0"  : "=r" (status->r9));
    asm volatile("mov %%r8, %0"  : "=r" (status->r8));
    asm volatile("mov %%rdi, %0" : "=r" (status->rdi));
    asm volatile("mov %%rsi, %0" : "=r" (status->rsi));
    asm volatile("mov %%rbp, %0" : "=r" (status->rbp));
    asm volatile("mov %%rdx, %0" : "=r" (status->rdx));
    asm volatile("mov %%rcx, %0" : "=r" (status->rcx));
    asm volatile("mov %%rbx, %0" : "=r" (status->rbx));
    asm volatile("mov %%rax, %0" : "=r" (status->rax));
}

Referenced by PANIC().

◆ halt()

void CPU::halt ( )

static

Halts the CPU indefinitely.

Definition at line 275 of file cpu.cpp.

                            {
 
    while (true)
        asm volatile("hlt");
}

Referenced by core_main(), MaxOS::hardwarecommunication::CPUStopHandler::handle_interrupt(), and PANIC().

◆ init_cores()

void CPU::init_cores ( )

Wake up all the cores.

Definition at line 588 of file cpu.cpp.

                     {
 
    Logger::INFO() << "Waking up cores: \n";
 
    // Make sure core_start is accessible
    ASSERT((void*)&core_start == (void*)0x8000, "Core start not at expected address");
    PhysicalMemoryManager::s_current_manager->identity_map((physical_address_t*)0x8000, PRESENT | WRITE);
 
    // Set up the boot info
    auto info = (core_boot_info_t*)(core_boot_info);
    info->p4_table = (uint64_t)PhysicalMemoryManager::to_lower_region((uintptr_t)p4_table);
 
    // Start each core
    for(const auto& core : cores)
        core->wake_up(this);
}

References core_boot_info, core_start(), cores, MaxOS::memory::PhysicalMemoryManager::identity_map(), MaxOS::Logger::INFO(), p4_table, MaxOS::memory::PRESENT, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::PhysicalMemoryManager::to_lower_region(), and MaxOS::memory::WRITE.

Referenced by kernel_main().

◆ PANIC()

void CPU::PANIC	(	const char *	message,
		cpu_status_t *	status = `nullptr`
	)

static

Puts the CPU into a panic state and halts it. Dumps the stack trace and registers.

Parameters

message	The panic message
status	The CPU status at the time of the panic (if available, otherwise will be fetched)

Definition at line 463 of file cpu.cpp.

                                                         {
 
    // Ensure ready to panic  - At this point it is not an issue if it is possible can avoid the panic as it is most
    // likely called by a place that cant switch to the avoidable state
    prepare_for_panic();
    panic_lock.lock();
 
    // Get the current process
    Process* process = GlobalScheduler::current_process();
 
    // Print using the backend
    Logger::Out()   << "\n";
    Logger::ERROR() << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n";
    Logger::ERROR() << "Kernel Panic: " << message;
    Logger::ERROR() << "On Core: " << (panic_core ? panic_core->id : 0) << "\n";
 
    // Info about the running process
    Logger::ERROR() << "Process: " << (process ? process->name.c_str() : "Kernel") << "\n";
    if (process)
        Logger::ERROR() << "After running for " << process->total_ticks() << " ticks (system uptime: " << GlobalScheduler::core_scheduler()->ticks() << " ticks)\n";
 
    // Stack trace
    Logger::ERROR() << "----------------------------\n";
    Logger::ERROR() << "Stack Trace:\n";
    stack_trace(20, status);
 
    // Register dump
    Logger::ERROR() << "----------------------------\n";
    Logger::ERROR() << "Register Dump:\n";
 
    // Log the regs
    cpu_status_t new_status{};
    if (!status) {
        get_status(&new_status);
        status = &new_status;
    }
    print_registers(status);
 
    // Print some text to the user
    Logger::ERROR() << "----------------------------\n";
    Logger::ERROR() << "There has been a fatal error in MaxOS and the system has been halted.\n";
    Logger::ERROR() << "Please check the logs for more info.\n";        // TODO: save to a file
    Logger::ERROR() << "Please restart the system.\n";
 
    // Print the logo
    Logger::ERROR() << "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n";
 
    // Halt
    halt();
}

References MaxOS::processes::GlobalScheduler::core_scheduler(), MaxOS::processes::GlobalScheduler::current_process(), MaxOS::Logger::ERROR(), get_status(), halt(), MaxOS::system::Core::id, MaxOS::processes::Process::name, MaxOS::Logger::Out(), panic_core, panic_lock, prepare_for_panic(), print_registers(), stack_trace(), MaxOS::processes::Scheduler::ticks(), and MaxOS::processes::Process::total_ticks().

Referenced by MaxOS::Logger::assert(), and MaxOS::hardwarecommunication::ExceptionHandler::handle_interrupt().

◆ prepare_for_panic()

cpu_status_t * CPU::prepare_for_panic	(	cpu_status_t *	status = `nullptr`,
		const string &	msg = `""`
	)

static

Ensure the CPU must panic and prepare for it if so.

Parameters

status	The status of the CPU (if available)
msg	The message to print to diagnose the cause of the panic (prints when close program)

Returns: A CPU status to avoid having to panic or a nullptr if the CPU must panic

Definition at line 521 of file cpu.cpp.

                                                                            {
    panic_lock.lock();
 
    // If it may have occurred in a process, switch to the avoidable state
    if (GlobalScheduler::system_scheduler() != nullptr && GlobalScheduler::current_process() != nullptr) {
 
        // Get the current process
        Process* process = GlobalScheduler::current_process();
 
        // If the faulting address is in lower half just kill the process and move on
        if (status && !memory::PhysicalMemoryManager::in_higher_region(status->rip)) {
            Logger::Out() << "\n";
            Logger::ERROR() << msg;
            Logger::ERROR() << "CPU Panicked (i " << (int)status->interrupt_number << ") in process " << process->name.c_str() << " at 0x" << status->rip << " - killing process\n";
            panic_lock.unlock();
            return GlobalScheduler::force_remove_process(process);
        }
 
        // Otherwise occurred whilst the kernel was doing something for the process, thus a fault in the kernel fault
        // and is unrecoverable
    }
 
    // Kill the others to make sure everything else stops
    if (GlobalScheduler::is_active()) {
        executing_core()->local_apic->send_interrupt(0, 0x81, EXCLUDE_SELF);
        GlobalScheduler::deactivate();
    }
 
    // Prepare for printing debug messages
    FramebufferConsole::print_logo(true);
    Logger::active_logger() -> enable_all_log_writers();
 
    // Unresumable state
    panic_lock.unlock();
    panic_core = executing_core();
    return nullptr;
}

References MaxOS::Logger::active_logger(), MaxOS::processes::GlobalScheduler::current_process(), MaxOS::processes::GlobalScheduler::deactivate(), MaxOS::Logger::ERROR(), executing_core(), MaxOS::processes::GlobalScheduler::force_remove_process(), MaxOS::memory::PhysicalMemoryManager::in_higher_region(), MaxOS::processes::GlobalScheduler::is_active(), MaxOS::system::Core::local_apic, MaxOS::processes::Process::name, MaxOS::Logger::Out(), panic_core, panic_lock, MaxOS::console::FramebufferConsole::print_logo(), MaxOS::hardwarecommunication::LocalAPIC::send_interrupt(), and MaxOS::processes::GlobalScheduler::system_scheduler().

Referenced by MaxOS::hardwarecommunication::ExceptionHandler::handle_interrupt(), and PANIC().

◆ print_registers()

void CPU::print_registers ( cpu_status_t * status )

static

Prints the CPU registers from the provided structure.

Parameters

status The structure containing the CPU status

Definition at line 337 of file cpu.cpp.

                                              {
 
    // Print the registers
    Logger::ERROR() << "R15: \t0x" << status->r15 << "\n";
    Logger::ERROR() << "R14: \t0x" << status->r14 << "\n";
    Logger::ERROR() << "R13: \t0x" << status->r13 << "\n";
    Logger::ERROR() << "R12: \t0x" << status->r12 << "\n";
    Logger::ERROR() << "R11: \t0x" << status->r11 << "\n";
    Logger::ERROR() << "R10: \t0x" << status->r10 << "\n";
    Logger::ERROR() << "R9: \t0x" << status->r9 << "\n";
    Logger::ERROR() << "R8: \t0x" << status->r8 << "\n";
    Logger::ERROR() << "RDI: \t0x" << status->rdi << "\n";
    Logger::ERROR() << "RSI: \t0x" << status->rsi << "\n";
    Logger::ERROR() << "RBP: \t0x" << status->rbp << "\n";
    Logger::ERROR() << "RDX: \t0x" << status->rdx << "\n";
    Logger::ERROR() << "RCX: \t0x" << status->rcx << "\n";
    Logger::ERROR() << "RBX: \t0x" << status->rbx << "\n";
    Logger::ERROR() << "RAX: \t0x" << status->rax << "\n";
    Logger::ERROR() << "INT: \t0x" << status->interrupt_number << "\n";
    Logger::ERROR() << "ERRCD: \t0x" << status->error_code << "\n";
    Logger::ERROR() << "RIP: \t0x" << status->rip << "\n";
    Logger::ERROR() << "CS: \t0x" << status->cs << "\n";
    Logger::ERROR() << "RFlGS: \t0x" << status->rflags << "\n";
    Logger::ERROR() << "RSP: \t0x" << status->rsp << "\n";
    Logger::ERROR() << "SS: \t0x" << status->ss << "\n";
 
}

References MaxOS::Logger::ERROR().

Referenced by PANIC().

◆ read_msr()

uint64_t CPU::read_msr ( uint32_t msr )

static

Reads the value of the specified MSR.

Parameters

msr	The MSR to read

Returns: The value of the MSR

Definition at line 371 of file cpu.cpp.

                                   {
 
    // Read the MSR
    uint32_t low, high;
    asm volatile("rdmsr" : "=a" (low), "=d" (high) : "c" (msr));
 
    // Return the value
    return (uint64_t) low | ((uint64_t) high << 32);
}

Referenced by check_nx(), MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), and MaxOS::hardwarecommunication::LocalAPIC::read().

◆ set_status()

void CPU::set_status ( cpu_status_t * status )

static

Sets the CPU registers from the provided structure.

Parameters

status The structure containing the CPU status

Definition at line 311 of file cpu.cpp.

                                         {
 
    // Set the registers
    asm volatile("mov %0, %%r15" : : "r" (status->r15));
    asm volatile("mov %0, %%r14" : : "r" (status->r14));
    asm volatile("mov %0, %%r13" : : "r" (status->r13));
    asm volatile("mov %0, %%r12" : : "r" (status->r12));
    asm volatile("mov %0, %%r11" : : "r" (status->r11));
    asm volatile("mov %0, %%r10" : : "r" (status->r10));
    asm volatile("mov %0, %%r9"  : : "r" (status->r9));
    asm volatile("mov %0, %%r8"  : : "r" (status->r8));
    asm volatile("mov %0, %%rdi" : : "r" (status->rdi));
    asm volatile("mov %0, %%rsi" : : "r" (status->rsi));
    asm volatile("mov %0, %%rbp" : : "r" (status->rbp));
    asm volatile("mov %0, %%rdx" : : "r" (status->rdx));
    asm volatile("mov %0, %%rcx" : : "r" (status->rcx));
    asm volatile("mov %0, %%rbx" : : "r" (status->rbx));
    asm volatile("mov %0, %%rax" : : "r" (status->rax));
 
}

◆ stack_trace()

void CPU::stack_trace	(	size_t	level,
		cpu_status_t *	status = `nullptr`
	)

static

Prints a stack trace up to the specified level.

Parameters

level	The number of stack frames to print
status	The execution state to trace (optional, null will be interpreted as use the current state)

Definition at line 414 of file cpu.cpp.

                                                        {
 
    auto* frame = status ? (stack_frame_t*)status->rbp : (stack_frame_t*) __builtin_frame_address(0);
 
    // Loop through the frames logging
    for (size_t current_level = 0; current_level < level; current_level++) {
 
        // Print the frame
        auto function = resolve_symbol(frame->rip);
        Logger::ERROR() << "(" << current_level << "): " << (function ? function : "Unknown()")  << " at 0x" << frame->rip << "\n";
 
        // Next frame
        frame = frame->next;
        if (frame == nullptr)
            break;
 
    }
}

References MaxOS::Logger::ERROR(), and MaxOS::common::resolve_symbol().

Referenced by PANIC().

◆ write_msr()

void CPU::write_msr	(	uint32_t	msr,
		uint64_t	value
	)

static

Writes the specified value to the specified MSR.

Parameters

msr	The MSR to write to
value	The value to write

Definition at line 387 of file cpu.cpp.

                                                {
 
    // Write the MSR
    asm volatile("wrmsr" : : "a" ((uint32_t) value), "d" ((uint32_t) (value >> 32)), "c" (msr));
}

Referenced by MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), MaxOS::hardwarecommunication::LocalAPIC::send_icr(), and MaxOS::hardwarecommunication::LocalAPIC::write().

Member Data Documentation

◆ acpi

hardwarecommunication::AdvancedConfigurationAndPowerInterface MaxOS::system::CPU::acpi

The ACPI interface for the CPU.

Definition at line 263 of file cpu.h.

◆ apic

hardwarecommunication::AdvancedProgrammableInterruptController MaxOS::system::CPU::apic

The APIC interface for the CPU.

Definition at line 264 of file cpu.h.

Referenced by CPU(), find_cores(), kernel_main(), and MaxOS::system::Core::wake_up().

◆ cores

common::Vector<Core*> MaxOS::system::CPU::cores

inlinestatic

The list of CPU cores in the system (populated during initialization, includes the BSP and cores that failed to start)

Definition at line 273 of file cpu.h.

◆ panic_core

Core* MaxOS::system::CPU::panic_core = nullptr

inlinestatic

The core that triggered the panic.

Definition at line 266 of file cpu.h.

Referenced by PANIC(), and prepare_for_panic().

◆ panic_lock

common::Spinlock MaxOS::system::CPU::panic_lock

inlinestatic

Lock to prevent multiple panics at once.

Definition at line 267 of file cpu.h.

Referenced by MaxOS::console::FramebufferConsole::get_background_color(), MaxOS::console::FramebufferConsole::get_foreground_color(), PANIC(), and prepare_for_panic().

The documentation for this class was generated from the following files:

/home/runner/work/MaxOS/MaxOS/kernel/include/system/cpu.h
/home/runner/work/MaxOS/MaxOS/kernel/src/system/cpu.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CPU()

Member Function Documentation

◆ check_cpu_feature() [1/2]

◆ check_cpu_feature() [2/2]

◆ check_nx()

◆ cpuid()

◆ disable_write_protect()

◆ enable_write_protect()

◆ executing_core()

◆ find_cores()

◆ get_status()

◆ halt()

◆ init_cores()

◆ PANIC()

◆ prepare_for_panic()

◆ print_registers()

◆ read_msr()

◆ set_status()

◆ stack_trace()

◆ write_msr()

Member Data Documentation

◆ acpi

◆ apic

◆ cores

◆ panic_core

◆ panic_lock