LocalApic Class Reference

Local APIC 驱动类 More...

#include <local_apic.h>

Collaboration diagram for LocalApic:

Public Member Functions
auto	Init () -> Expected< void >
	初始化 Local APIC
auto	GetApicVersion () const -> uint32_t
	获取 APIC 版本信息
auto	SendEoi () const -> void
	发送中断结束信号 (EOI)
auto	SendIpi (uint32_t destination_apic_id, uint8_t vector) const -> Expected< void >
	发送处理器间中断 (IPI)
auto	BroadcastIpi (uint8_t vector) const -> Expected< void >
	广播 IPI 到所有其他 CPU
auto	SetTaskPriority (uint8_t priority) const -> void
	设置任务优先级
auto	GetTaskPriority () const -> uint8_t
	获取任务优先级
auto	EnableTimer (uint32_t initial_count, uint32_t divide_value, uint8_t vector, bool periodic=true) const -> void
	启用 Local APIC 定时器
auto	DisableTimer () const -> void
	禁用 Local APIC 定时器
auto	GetTimerCurrentCount () const -> uint32_t
	获取定时器当前计数值
auto	SetupPeriodicTimer (uint32_t frequency_hz, uint8_t vector) const -> void
	设置周期性定时器
auto	SetupOneShotTimer (uint32_t microseconds, uint8_t vector) const -> void
	设置单次定时器
auto	SendInitIpi (uint32_t destination_apic_id) const -> void
	发送 INIT IPI
auto	SendStartupIpi (uint32_t destination_apic_id, uint8_t start_page) const -> void
	发送 SIPI (Startup IPI)
auto	WakeupAp (uint32_t destination_apic_id, uint8_t start_vector) const -> void
	唤醒应用处理器 (AP)
auto	ConfigureLvtEntries () const -> void
	配置 Local Vector Table 条目
auto	ReadErrorStatus () const -> uint32_t
	读取错误状态
auto	PrintInfo () const -> void
	打印 Local APIC 信息（调试用）
构造/析构函数
	LocalApic ()=default
	LocalApic (const LocalApic &)=delete
	LocalApic (LocalApic &&)=default
auto	operator= (const LocalApic &) -> LocalApic &=delete
auto	operator= (LocalApic &&) -> LocalApic &=default
	~LocalApic ()=default

Private Member Functions
auto	CheckX2ApicSupport () const -> bool
	检查 CPU 是否支持 x2APIC
auto	EnableXApic () const -> bool
	启用传统 xAPIC 模式
auto	DisableXApic () const -> bool
	禁用传统 xAPIC 模式
auto	IsXApicEnabled () const -> bool
	检查传统 xAPIC 是否启用
auto	EnableX2Apic () const -> bool
	启用 x2APIC 模式
auto	DisableX2Apic () const -> bool
	禁用 x2APIC 模式
auto	IsX2ApicEnabled () const -> bool
	检查 x2APIC 是否启用

Private Attributes
bool	is_x2apic_mode_ {false}
	当前 APIC 模式（true = x2APIC, false = xAPIC）
uint64_t	apic_base_ {kDefaultApicBase}
	APIC 基地址（仅用于 xAPIC 模式）

Static Private Attributes
xAPIC 寄存器偏移量常数
APIC ID 寄存器偏移
static constexpr uint32_t	kXApicIdOffset = 0x20
static constexpr uint32_t	kXApicVersionOffset = 0x30
	版本寄存器偏移
static constexpr uint32_t	kXApicTprOffset = 0x80
	任务优先级寄存器偏移
static constexpr uint32_t	kXApicEoiOffset = 0xB0
	EOI 寄存器偏移
static constexpr uint32_t	kXApicSivrOffset = 0xF0
	虚假中断向量寄存器偏移
static constexpr uint32_t	kXApicEsrOffset = 0x280
	错误状态寄存器偏移
static constexpr uint32_t	kXApicIcrLowOffset = 0x300
	ICR 低位寄存器偏移
static constexpr uint32_t	kXApicIcrHighOffset = 0x310
	ICR 高位寄存器偏移
static constexpr uint32_t	kXApicLvtTimerOffset = 0x320
	LVT 定时器寄存器偏移
static constexpr uint32_t	kXApicLvtLint0Offset = 0x350
	LVT LINT0 寄存器偏移
static constexpr uint32_t	kXApicLvtLint1Offset = 0x360
	LVT LINT1 寄存器偏移
static constexpr uint32_t	kXApicLvtErrorOffset = 0x370
	LVT 错误寄存器偏移
static constexpr uint32_t	kXApicTimerInitCountOffset = 0x380
	定时器初始计数寄存器偏移
static constexpr uint32_t	kXApicTimerCurrCountOffset = 0x390
	定时器当前计数寄存器偏移
static constexpr uint32_t	kXApicTimerDivideOffset = 0x3E0
	定时器分频寄存器偏移
位掩码和位移常数
xAPIC ID 位移
static constexpr uint32_t	kApicIdShift = 24
static constexpr uint32_t	kApicIdMask = 0xFF
	xAPIC ID 掩码
static constexpr uint32_t	kApicSoftwareEnableBit = 0x100
	APIC 软件启用位
static constexpr uint32_t	kSpuriousVector = 0xFF
	虚假中断向量
static constexpr uint32_t	kLvtMaskBit = 0x10000
	LVT 掩码位
static constexpr uint32_t	kLvtPeriodicMode = 0x20000
	LVT 周期模式位
static constexpr uint32_t	kIcrDeliveryStatusBit = 0x1000
	ICR 传递状态位
static constexpr uint32_t	kIcrDestShift = 24
	ICR 目标位移
static constexpr uint32_t	kIcrBroadcastMode = 0xC0000
	ICR 广播模式位
static constexpr uint32_t	kInitIpiMode = 0x500
	INIT IPI 模式
static constexpr uint32_t	kSipiMode = 0x600
	SIPI 模式
static constexpr uint32_t	kExtIntMode = 0x700
	ExtINT 传递模式
static constexpr uint32_t	kNmiMode = 0x400
	NMI 传递模式
static constexpr uint8_t	kErrorVector = 0xEF
	错误中断向量
定时器相关常数
默认 APIC 时钟频率 (100MHz)
static constexpr uint32_t	kDefaultApicClockHz = 100000000
static constexpr uint32_t	kTimerDivideBy1 = 0x0B
	定时器分频 1
static constexpr uint32_t	kTimerDivideBy16 = 0x03
	定时器分频 16
static constexpr uint32_t	kCalibrationCount = 0xFFFFFFFF
	校准用的计数值
static constexpr uint32_t	kCalibrationDelayLoop = 1000000
	校准延时循环次数
static constexpr uint32_t	kCalibrationMultiplier = 100
	校准倍数 (10ms -> 1s)
static constexpr uint32_t	kMicrosecondsPerSecond = 1000000
	每秒微秒数
APIC 基地址相关常数
默认 APIC 基地址
static constexpr uint64_t	kDefaultApicBase = 0xFEE00000
static constexpr uint64_t	kApicBaseMask = 0xFFFFF000ULL
	APIC 基地址掩码
static constexpr uint64_t	kApicGlobalEnableBit = 1ULL << 11
	APIC 全局启用位
static constexpr uint64_t	kX2ApicEnableBit = 1ULL << 10
	x2APIC 启用位
static constexpr uint64_t	kApicBaseControlMask = 0xFFF
	APIC 基地址控制位掩码

Detailed Description

Local APIC 驱动类

Copyright

Copyright The SimpleKernel Contributors

Note

支持 xAPIC 和 x2APIC 模式，优先使用 x2APIC

Definition at line 18 of file local_apic.h.

Constructor & Destructor Documentation

LocalApic() [1/3]

LocalApic::LocalApic ( )

default

LocalApic() [2/3]

LocalApic::LocalApic ( const LocalApic &  )

delete

LocalApic() [3/3]

LocalApic::LocalApic ( LocalApic &&  )

default

~LocalApic()

LocalApic::~LocalApic ( )

default

Member Function Documentation

BroadcastIpi()

auto LocalApic::BroadcastIpi

(

uint8_t

vector

)

const -> Expected<void>

广播 IPI 到所有其他 CPU

Parameters

vector

中断向量

Returns

Expected<void> 广播成功返回空值，失败返回错误

Definition at line 136 of file local_apic.cpp.

                                                                   {
  if (is_x2apic_mode_) {
    auto icr = static_cast<uint64_t>(vector);
    // 目标简写：除自己外的所有 CPU
    icr |= 0x80000;
 
    cpu_io::msr::apic::WriteIcr(icr);
 
    while ((cpu_io::msr::apic::ReadIcr() & kIcrDeliveryStatusBit) != 0) {
      ;
    }
  } else {
    // 广播到除自己外的所有 CPU(目标简写模式)
    // ICR_HIGH 设为 0(不使用具体目标 ID)
    etl::io_port_wo<uint32_t> icr_high_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrHighOffset)};
    icr_high_reg.write(0);
 
    // ICR_LOW：向量 + 目标简写模式(位 18-19 = 11)
    auto icr_low = static_cast<uint32_t>(vector) | kIcrBroadcastMode;
    etl::io_port_wo<uint32_t> icr_low_wo{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
    icr_low_wo.write(icr_low);
 
    {
      etl::io_port_ro<uint32_t> icr_low_ro{
          reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
      while ((icr_low_ro.read() & kIcrDeliveryStatusBit) != 0) {
        ;
      }
    }
  }
  return {};
}

CheckX2ApicSupport()

auto LocalApic::CheckX2ApicSupport ( ) const -> bool

private

检查 CPU 是否支持 x2APIC

Returns

true 支持 x2APIC

false 不支持 x2APIC

Definition at line 462 of file local_apic.cpp.

                                                 {
  return cpu_io::cpuid::HasX2Apic();
}

Here is the caller graph for this function:

ConfigureLvtEntries()

auto LocalApic::ConfigureLvtEntries

(

)

const -> void

配置 Local Vector Table 条目

Definition at line 364 of file local_apic.cpp.

                                                  {
  if (is_x2apic_mode_) {
    // 配置 LINT0 (通常连接到 8259 PIC 的 INTR)
    cpu_io::msr::apic::WriteLvtLint0(kExtIntMode);
 
    // 配置 LINT1 (通常连接到 NMI)
    cpu_io::msr::apic::WriteLvtLint1(kNmiMode);
 
    // 配置错误中断
    cpu_io::msr::apic::WriteLvtError(kErrorVector);
  } else {
    // 配置 LINT0 (偏移 0x350)
    etl::io_port_wo<uint32_t> lint0_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint0Offset)};
    lint0_reg.write(kExtIntMode);
 
    // 配置 LINT1 (偏移 0x360)
    etl::io_port_wo<uint32_t> lint1_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint1Offset)};
    lint1_reg.write(kNmiMode);
 
    // 配置错误中断 (偏移 0x370)
    etl::io_port_wo<uint32_t> error_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtErrorOffset)};
    error_reg.write(kErrorVector);
  }
}

DisableTimer()

auto LocalApic::DisableTimer

(

)

const -> void

禁用 Local APIC 定时器

Definition at line 227 of file local_apic.cpp.

                                           {
  if (is_x2apic_mode_) {
    auto lvt_timer = cpu_io::msr::apic::ReadLvtTimer();
    lvt_timer |= kLvtMaskBit;
    cpu_io::msr::apic::WriteLvtTimer(lvt_timer);
    cpu_io::msr::apic::WriteTimerInitCount(0);
  } else {
    etl::io_port_rw<uint32_t> lvt_timer_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtTimerOffset)};
    auto lvt_timer = lvt_timer_reg.read();
    lvt_timer |= kLvtMaskBit;
    lvt_timer_reg.write(lvt_timer);
    etl::io_port_wo<uint32_t> init_count_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTimerInitCountOffset)};
    init_count_reg.write(0);
  }
}

DisableX2Apic()

auto LocalApic::DisableX2Apic ( ) const -> bool

private

禁用 x2APIC 模式

Returns

true 禁用成功

false 禁用失败或x2APIC未启用

Definition at line 500 of file local_apic.cpp.

                                            {
  // 清除 IA32_APIC_BASE.x2APIC_Enable (位10) = 0
  cpu_io::msr::apic::DisableX2Apic();
  return !IsX2ApicEnabled();
}

Here is the call graph for this function:

DisableXApic()

auto LocalApic::DisableXApic ( ) const -> bool

private

禁用传统 xAPIC 模式

Returns

true 禁用成功

false 禁用失败或xAPIC未启用

Definition at line 474 of file local_apic.cpp.

                                           {
  // 清除 IA32_APIC_BASE.Global_Enable (位11) = 0
  cpu_io::msr::apic::DisableGlobally();
  return !IsXApicEnabled();
}

Here is the call graph for this function:

EnableTimer()

auto LocalApic::EnableTimer	(	uint32_t	initial_count,
		uint32_t	divide_value,
		uint8_t	vector,
		bool	periodic = true
	)		const -> void

启用 Local APIC 定时器

Parameters

initial_count	初始计数值
divide_value	分频值
vector	定时器中断向量
periodic	是否为周期性定时器

Definition at line 192 of file local_apic.cpp.

                                                                         {
  if (is_x2apic_mode_) {
    cpu_io::msr::apic::WriteTimerDivide(divide_value);
 
    auto lvt_timer = static_cast<uint32_t>(vector);
    if (periodic) {
      lvt_timer |= kLvtPeriodicMode;
    }
 
    cpu_io::msr::apic::WriteLvtTimer(lvt_timer);
    cpu_io::msr::apic::WriteTimerInitCount(initial_count);
  } else {
    // 设置分频器(偏移 0x3E0)
    etl::io_port_wo<uint32_t> divide_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTimerDivideOffset)};
    divide_reg.write(divide_value);
 
    // 设置 LVT 定时器寄存器(偏移 0x320)
    auto lvt_timer = static_cast<uint32_t>(vector);
    if (periodic) {
      lvt_timer |= kLvtPeriodicMode;
    }
 
    etl::io_port_wo<uint32_t> lvt_timer_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtTimerOffset)};
    lvt_timer_reg.write(lvt_timer);
 
    // 设置初始计数值(偏移 0x380)
    etl::io_port_wo<uint32_t> init_count_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTimerInitCountOffset)};
    init_count_reg.write(initial_count);
  }
}

EnableX2Apic()

auto LocalApic::EnableX2Apic ( ) const -> bool

private

启用 x2APIC 模式

Returns

true 启用成功

false 启用失败

Definition at line 486 of file local_apic.cpp.

                                           {
  // 检查 CPU 是否支持 x2APIC
  if (!CheckX2ApicSupport()) {
    return false;
  }
 
  // 设置 IA32_APIC_BASE.x2APIC_Enable (位10) = 1
  // 同时确保 IA32_APIC_BASE.Global_Enable (位11) = 1
  cpu_io::msr::apic::EnableX2Apic();
 
  // 验证 x2APIC 是否成功启用
  return IsX2ApicEnabled();
}

Here is the call graph for this function:

EnableXApic()

auto LocalApic::EnableXApic ( ) const -> bool

private

启用传统 xAPIC 模式

Returns

true 启用成功

false 启用失败

Definition at line 466 of file local_apic.cpp.

                                          {
  // 设置 IA32_APIC_BASE.Global_Enable (位11) = 1
  cpu_io::msr::apic::EnableGlobally();
  // 清除 IA32_APIC_BASE.x2APIC_Enable (位10) = 0
  cpu_io::msr::apic::DisableX2Apic();
  return IsXApicEnabled();
}

Here is the call graph for this function:

GetApicVersion()

auto LocalApic::GetApicVersion

(

)

const -> uint32_t

获取 APIC 版本信息

Returns

uint32_t APIC 版本

Definition at line 77 of file local_apic.cpp.

                                                 {
  if (is_x2apic_mode_) {
    return cpu_io::msr::apic::ReadVersion();
  } else {
    // 版本寄存器在偏移 0x30 处
    etl::io_port_ro<uint32_t> ver_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicVersionOffset)};
    return ver_reg.read();
  }
}

Here is the caller graph for this function:

GetTaskPriority()

auto LocalApic::GetTaskPriority

(

)

const -> uint8_t

获取任务优先级

Returns

uint8_t 当前任务优先级

Definition at line 181 of file local_apic.cpp.

                                                 {
  if (is_x2apic_mode_) {
    return static_cast<uint8_t>(cpu_io::msr::apic::ReadTpr() & kApicIdMask);
  } else {
    etl::io_port_ro<uint32_t> tpr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTprOffset)};
    auto tpr = tpr_reg.read();
    return static_cast<uint8_t>(tpr & kApicIdMask);
  }
}

Here is the caller graph for this function:

GetTimerCurrentCount()

auto LocalApic::GetTimerCurrentCount

(

)

const -> uint32_t

获取定时器当前计数值

Returns

uint32_t 当前计数值

Definition at line 245 of file local_apic.cpp.

                                                       {
  if (is_x2apic_mode_) {
    return cpu_io::msr::apic::ReadTimerCurrCount();
  } else {
    // 当前计数寄存器在偏移 0x390 处
    etl::io_port_ro<uint32_t> curr_count_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTimerCurrCountOffset)};
    return curr_count_reg.read();
  }
}

Here is the caller graph for this function:

Init()

auto LocalApic::Init

(

)

-> Expected<void>

初始化 Local APIC

Returns

Expected<void> 初始化成功返回空值，失败返回错误

Copyright

Copyright The SimpleKernel Contributors

Definition at line 10 of file local_apic.cpp.

                                       {
  // 检查 APIC 是否全局启用
  if (!cpu_io::msr::apic::IsGloballyEnabled()) {
    cpu_io::msr::apic::EnableGlobally();
  }
 
  // 首先尝试启用 x2APIC 模式
  if (EnableX2Apic()) {
    is_x2apic_mode_ = true;
  } else {
    if (!EnableXApic()) {
      klog::Err("Failed to enable APIC in any mode");
      return std::unexpected(Error(ErrorCode::kApicInitFailed));
    }
    is_x2apic_mode_ = false;
  }
 
  // 启用 Local APIC(通过设置 SIVR)
  uint32_t sivr;
  if (is_x2apic_mode_) {
    sivr = cpu_io::msr::apic::ReadSivr();
  } else {
    etl::io_port_ro<uint32_t> sivr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicSivrOffset)};
    sivr = sivr_reg.read();
  }
 
  // 设置 APIC Software Enable 位
  sivr |= kApicSoftwareEnableBit;
  // 设置虚假中断向量为 0xFF
  sivr |= kSpuriousVector;
 
  if (is_x2apic_mode_) {
    cpu_io::msr::apic::WriteSivr(sivr);
  } else {
    etl::io_port_wo<uint32_t> sivr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicSivrOffset)};
    sivr_reg.write(sivr);
  }
 
  // 清除任务优先级
  SetTaskPriority(0);
 
  // 禁用所有 LVT 条目(设置 mask 位)
  if (is_x2apic_mode_) {
    cpu_io::msr::apic::WriteLvtTimer(kLvtMaskBit);
    cpu_io::msr::apic::WriteLvtLint0(kLvtMaskBit);
    cpu_io::msr::apic::WriteLvtLint1(kLvtMaskBit);
    cpu_io::msr::apic::WriteLvtError(kLvtMaskBit);
  } else {
    // xAPIC 模式下通过内存映射写入
    etl::io_port_wo<uint32_t> lvt_timer{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtTimerOffset)};
    lvt_timer.write(kLvtMaskBit);
    etl::io_port_wo<uint32_t> lvt_lint0{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint0Offset)};
    lvt_lint0.write(kLvtMaskBit);
    etl::io_port_wo<uint32_t> lvt_lint1{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint1Offset)};
    lvt_lint1.write(kLvtMaskBit);
    etl::io_port_wo<uint32_t> lvt_error{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtErrorOffset)};
    lvt_error.write(kLvtMaskBit);
  }
  return {};
}

Here is the call graph for this function:

IsX2ApicEnabled()

auto LocalApic::IsX2ApicEnabled ( ) const -> bool

private

检查 x2APIC 是否启用

Returns

true x2APIC 已启用

false x2APIC 未启用

Definition at line 506 of file local_apic.cpp.

                                              {
  return cpu_io::msr::apic::IsX2ApicEnabled();
}

Here is the caller graph for this function:

IsXApicEnabled()

auto LocalApic::IsXApicEnabled ( ) const -> bool

private

检查传统 xAPIC 是否启用

Returns

true xAPIC 已启用

false xAPIC 未启用

Definition at line 480 of file local_apic.cpp.

                                             {
  // Global_Enable = 1 && x2APIC_Enable = 0
  return cpu_io::msr::apic::IsGloballyEnabled() &&
         !cpu_io::msr::apic::IsX2ApicEnabled();
}

Here is the caller graph for this function:

operator=() [1/2]

auto LocalApic::operator= ( const LocalApic &  ) -> LocalApic &=delete

delete

operator=() [2/2]

auto LocalApic::operator= ( LocalApic &&  ) -> LocalApic &=default

default

PrintInfo()

auto LocalApic::PrintInfo

(

)

const -> void

打印 Local APIC 信息（调试用）

Definition at line 407 of file local_apic.cpp.

                                        {
  klog::Info("APIC Version: {:#x}", GetApicVersion());
  klog::Info("Mode: {}", is_x2apic_mode_ ? "x2APIC" : "xAPIC");
  klog::Info("x2APIC Enabled: {}", IsX2ApicEnabled() ? "Yes" : "No");
  klog::Info("Task Priority: {:#x}", GetTaskPriority());
  klog::Info("Timer Current Count: {}", GetTimerCurrentCount());
 
  // 读取各种寄存器状态
  if (is_x2apic_mode_) {
    uint32_t sivr = cpu_io::msr::apic::ReadSivr();
    klog::Info("SIVR: {:#x} (APIC {})", sivr,
               (sivr & kApicSoftwareEnableBit) ? "Enabled" : "Disabled");
 
    uint32_t lvt_timer = cpu_io::msr::apic::ReadLvtTimer();
    klog::Info("LVT Timer: {:#x}", lvt_timer);
 
    uint32_t lvt_lint0 = cpu_io::msr::apic::ReadLvtLint0();
    klog::Info("LVT LINT0: {:#x}", lvt_lint0);
 
    uint32_t lvt_lint1 = cpu_io::msr::apic::ReadLvtLint1();
    klog::Info("LVT LINT1: {:#x}", lvt_lint1);
 
    uint32_t lvt_error = cpu_io::msr::apic::ReadLvtError();
    klog::Info("LVT Error: {:#x}", lvt_error);
  } else {
    etl::io_port_ro<uint32_t> sivr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicSivrOffset)};
    uint32_t sivr = sivr_reg.read();
    klog::Info("SIVR: {:#x} (APIC {})", sivr,
               (sivr & kApicSoftwareEnableBit) ? "Enabled" : "Disabled");
 
    etl::io_port_ro<uint32_t> lvt_timer_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtTimerOffset)};
    uint32_t lvt_timer = lvt_timer_reg.read();
    klog::Info("LVT Timer: {:#x}", lvt_timer);
 
    etl::io_port_ro<uint32_t> lvt_lint0_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint0Offset)};
    uint32_t lvt_lint0 = lvt_lint0_reg.read();
    klog::Info("LVT LINT0: {:#x}", lvt_lint0);
 
    etl::io_port_ro<uint32_t> lvt_lint1_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtLint1Offset)};
    uint32_t lvt_lint1 = lvt_lint1_reg.read();
    klog::Info("LVT LINT1: {:#x}", lvt_lint1);
 
    etl::io_port_ro<uint32_t> lvt_error_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicLvtErrorOffset)};
    uint32_t lvt_error = lvt_error_reg.read();
    klog::Info("LVT Error: {:#x}", lvt_error);
 
    klog::Info("APIC Base Address: {:#x}", apic_base_);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadErrorStatus()

auto LocalApic::ReadErrorStatus

(

)

const -> uint32_t

读取错误状态

Returns

uint32_t 错误状态寄存器值

Definition at line 392 of file local_apic.cpp.

                                                  {
  if (is_x2apic_mode_) {
    // x2APIC 模式下没有直接的 ESR 访问方式
    // 这里返回 0 表示没有错误
    return 0;
  } else {
    // 取 ESR (Error Status Register, 偏移 0x280)
    // 读取 ESR 之前需要先写入 0
    etl::io_port_rw<uint32_t> esr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicEsrOffset)};
    esr_reg.write(0);
    return esr_reg.read();
  }
}

SendEoi()

auto LocalApic::SendEoi

(

)

const -> void

发送中断结束信号 (EOI)

Definition at line 88 of file local_apic.cpp.

                                      {
  if (is_x2apic_mode_) {
    cpu_io::msr::apic::WriteEoi(0);
  } else {
    // 写入 EOI 寄存器(偏移 0xB0)
    etl::io_port_wo<uint32_t> eoi_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicEoiOffset)};
    eoi_reg.write(0);
  }
}

Here is the caller graph for this function:

SendInitIpi()

auto LocalApic::SendInitIpi

(

uint32_t

destination_apic_id

)

const -> void

发送 INIT IPI

Parameters

destination_apic_id

目标 APIC ID

Definition at line 294 of file local_apic.cpp.

                                                                      {
  if (is_x2apic_mode_) {
    auto icr = kInitIpiMode;
    icr |= static_cast<uint64_t>(destination_apic_id) << 32;
 
    cpu_io::msr::apic::WriteIcr(icr);
 
    while ((cpu_io::msr::apic::ReadIcr() & kIcrDeliveryStatusBit) != 0) {
      ;
    }
  } else {
    // 设置目标 APIC ID(ICR_HIGH)
    auto icr_high = (destination_apic_id & kApicIdMask) << kIcrDestShift;
    etl::io_port_wo<uint32_t> icr_high_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrHighOffset)};
    icr_high_reg.write(icr_high);
 
    // 发送 INIT IPI(ICR_LOW)
    auto icr_low = kInitIpiMode;
    etl::io_port_wo<uint32_t> icr_low_wo{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
    icr_low_wo.write(icr_low);
 
    {
      etl::io_port_ro<uint32_t> icr_low_ro{
          reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
      while ((icr_low_ro.read() & kIcrDeliveryStatusBit) != 0) {
        ;
      }
    }
  }
 
  klog::Info("INIT IPI sent to APIC ID {:#x}", destination_apic_id);
}

Here is the call graph for this function:

SendIpi()

auto LocalApic::SendIpi	(	uint32_t	destination_apic_id,
		uint8_t	vector
	)		const -> Expected<void>

发送处理器间中断 (IPI)

Parameters

destination_apic_id	目标 APIC ID
vector	中断向量

Returns

Expected<void> 发送成功返回空值，失败返回错误

Definition at line 99 of file local_apic.cpp.

                      {
  if (is_x2apic_mode_) {
    auto icr = static_cast<uint64_t>(vector);
    icr |= static_cast<uint64_t>(destination_apic_id) << 32;
 
    cpu_io::msr::apic::WriteIcr(icr);
 
    while ((cpu_io::msr::apic::ReadIcr() & kIcrDeliveryStatusBit) != 0) {
      ;
    }
  } else {
    // ICR 分为两个 32 位寄存器：ICR_LOW (0x300) 和 ICR_HIGH (0x310)
 
    // 设置目标 APIC ID(ICR_HIGH 的位 24-31)
    auto icr_high = (destination_apic_id & kApicIdMask) << kIcrDestShift;
    etl::io_port_wo<uint32_t> icr_high_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrHighOffset)};
    icr_high_reg.write(icr_high);
 
    // 设置向量和传递模式(ICR_LOW)
    auto icr_low = static_cast<uint32_t>(vector);
    etl::io_port_wo<uint32_t> icr_low_wo{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
    icr_low_wo.write(icr_low);
 
    {
      etl::io_port_ro<uint32_t> icr_low_ro{
          reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
      while ((icr_low_ro.read() & kIcrDeliveryStatusBit) != 0) {
        ;
      }
    }
  }
  return {};
}

SendStartupIpi()

auto LocalApic::SendStartupIpi	(	uint32_t	destination_apic_id,
		uint8_t	start_page
	)		const -> void

发送 SIPI (Startup IPI)

Parameters

destination_apic_id	目标 APIC ID
start_page	启动页面地址（4KB 页面）

Definition at line 329 of file local_apic.cpp.

                                                                 {
  if (is_x2apic_mode_) {
    // SIPI with start page (delivery mode = 110b)
    auto icr = kSipiMode | start_page;
    icr |= static_cast<uint64_t>(destination_apic_id) << 32;
 
    cpu_io::msr::apic::WriteIcr(icr);
 
    while ((cpu_io::msr::apic::ReadIcr() & kIcrDeliveryStatusBit) != 0) {
      ;
    }
  } else {
    // 设置目标 APIC ID(ICR_HIGH)
    uint32_t icr_high = (destination_apic_id & kApicIdMask) << kIcrDestShift;
    etl::io_port_wo<uint32_t> icr_high_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrHighOffset)};
    icr_high_reg.write(icr_high);
 
    // 发送 SIPI(ICR_LOW)
    uint32_t icr_low = kSipiMode | start_page;
    etl::io_port_wo<uint32_t> icr_low_wo{
        reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
    icr_low_wo.write(icr_low);
 
    {
      etl::io_port_ro<uint32_t> icr_low_ro{
          reinterpret_cast<void*>(apic_base_ + kXApicIcrLowOffset)};
      while ((icr_low_ro.read() & kIcrDeliveryStatusBit) != 0) {
        ;
      }
    }
  }
}

SetTaskPriority()

auto LocalApic::SetTaskPriority

(

uint8_t

priority

)

const -> void

设置任务优先级

Parameters

priority

优先级值

Definition at line 171 of file local_apic.cpp.

                                                              {
  if (is_x2apic_mode_) {
    cpu_io::msr::apic::WriteTpr(static_cast<uint32_t>(priority));
  } else {
    etl::io_port_wo<uint32_t> tpr_reg{
        reinterpret_cast<void*>(apic_base_ + kXApicTprOffset)};
    tpr_reg.write(static_cast<uint32_t>(priority));
  }
}

SetupOneShotTimer()

auto LocalApic::SetupOneShotTimer	(	uint32_t	microseconds,
		uint8_t	vector
	)		const -> void

设置单次定时器

Parameters

microseconds	延时时间（微秒）
vector	定时器中断向量

Definition at line 275 of file local_apic.cpp.

            {
  // 假设 APIC 时钟频率为 100MHz
 
  // 计算初始计数值(微秒转换为时钟周期)
  auto initial_count =
      (kDefaultApicClockHz / kMicrosecondsPerSecond) * microseconds;
 
  // 选择合适的分频值
  auto divide_value = kTimerDivideBy1;
  if (initial_count > 0xFFFFFFFF) {
    divide_value = kTimerDivideBy16;
    initial_count =
        ((kDefaultApicClockHz / 16) / kMicrosecondsPerSecond) * microseconds;
  }
 
  EnableTimer(initial_count, divide_value, vector, false);
}

SetupPeriodicTimer()

auto LocalApic::SetupPeriodicTimer	(	uint32_t	frequency_hz,
		uint8_t	vector
	)		const -> void

设置周期性定时器

Parameters

frequency_hz	定时器频率（Hz）
vector	定时器中断向量

Definition at line 256 of file local_apic.cpp.

            {
  // 使用 APIC 定时器的典型配置
  // 假设 APIC 时钟频率为 100MHz(实际应从 CPU 频率计算)
 
  // 计算初始计数值
  auto initial_count = kDefaultApicClockHz / frequency_hz;
 
  // 选择合适的分频值以获得更好的精度
  auto divide_value = kTimerDivideBy1;
  if (initial_count > 0xFFFFFFFF) {
    // 如果计数值太大，使用分频
    divide_value = kTimerDivideBy16;
    initial_count = (kDefaultApicClockHz / 16) / frequency_hz;
  }
 
  EnableTimer(initial_count, divide_value, vector, true);
}

WakeupAp()

auto LocalApic::WakeupAp	(	uint32_t	destination_apic_id,
		uint8_t	start_vector
	)		const -> void

唤醒应用处理器 (AP)

Parameters

destination_apic_id	目标 APIC ID
start_vector	启动向量（启动代码的物理地址 / 4096）

Returns

true 唤醒成功

Note

执行标准的 INIT-SIPI-SIPI 序列来唤醒 AP

Definition at line 510 of file local_apic.cpp.

                                                             {
  // 发送 INIT IPI
  SendInitIpi(destination_apic_id);
 
  // 等待 10ms (INIT IPI 后的标准等待时间)
  auto delay = 10 * kCalibrationDelayLoop;
  while (delay--) {
    __asm__ volatile("nop");
  }
 
  // 发送第一个 SIPI
  SendStartupIpi(destination_apic_id, start_vector);
 
  // 等待 200μs (SIPI 后的标准等待时间)
  delay = 200 * (kCalibrationDelayLoop / 1000);
  while (delay--) {
    __asm__ volatile("nop");
  }
 
  // 发送第二个 SIPI (为了可靠性)
  SendStartupIpi(destination_apic_id, start_vector);
 
  // 等待 200μs
  delay = 200 * (kCalibrationDelayLoop / 1000);
  while (delay--) {
    __asm__ volatile("nop");
  }
}

Member Data Documentation

apic_base_

uint64_t LocalApic::apic_base_ {kDefaultApicBase}

private

APIC 基地址（仅用于 xAPIC 模式）

Definition at line 253 of file local_apic.h.

{kDefaultApicBase};

is_x2apic_mode_

bool LocalApic::is_x2apic_mode_ {false}

private

当前 APIC 模式（true = x2APIC, false = xAPIC）

Definition at line 250 of file local_apic.h.

{false};

kApicBaseControlMask

constexpr uint64_t LocalApic::kApicBaseControlMask = 0xFFF

staticconstexprprivate

APIC 基地址控制位掩码

Definition at line 246 of file local_apic.h.

kApicBaseMask

constexpr uint64_t LocalApic::kApicBaseMask = 0xFFFFF000ULL

staticconstexprprivate

APIC 基地址掩码

Definition at line 240 of file local_apic.h.

kApicGlobalEnableBit

constexpr uint64_t LocalApic::kApicGlobalEnableBit = 1ULL << 11

staticconstexprprivate

APIC 全局启用位

Definition at line 242 of file local_apic.h.

kApicIdMask

constexpr uint32_t LocalApic::kApicIdMask = 0xFF

staticconstexprprivate

xAPIC ID 掩码

Definition at line 190 of file local_apic.h.

kApicIdShift

constexpr uint32_t LocalApic::kApicIdShift = 24

staticconstexprprivate

Definition at line 188 of file local_apic.h.

kApicSoftwareEnableBit

constexpr uint32_t LocalApic::kApicSoftwareEnableBit = 0x100

staticconstexprprivate

APIC 软件启用位

Definition at line 192 of file local_apic.h.

kCalibrationCount

constexpr uint32_t LocalApic::kCalibrationCount = 0xFFFFFFFF

staticconstexprprivate

校准用的计数值

Definition at line 226 of file local_apic.h.

kCalibrationDelayLoop

constexpr uint32_t LocalApic::kCalibrationDelayLoop = 1000000

staticconstexprprivate

校准延时循环次数

Definition at line 228 of file local_apic.h.

kCalibrationMultiplier

constexpr uint32_t LocalApic::kCalibrationMultiplier = 100

staticconstexprprivate

校准倍数 (10ms -> 1s)

Definition at line 230 of file local_apic.h.

kDefaultApicBase

constexpr uint64_t LocalApic::kDefaultApicBase = 0xFEE00000

staticconstexprprivate

Definition at line 238 of file local_apic.h.

kDefaultApicClockHz

constexpr uint32_t LocalApic::kDefaultApicClockHz = 100000000

staticconstexprprivate

Definition at line 220 of file local_apic.h.

kErrorVector

constexpr uint8_t LocalApic::kErrorVector = 0xEF

staticconstexprprivate

错误中断向量

Definition at line 214 of file local_apic.h.

kExtIntMode

constexpr uint32_t LocalApic::kExtIntMode = 0x700

staticconstexprprivate

ExtINT 传递模式

Definition at line 210 of file local_apic.h.

kIcrBroadcastMode

constexpr uint32_t LocalApic::kIcrBroadcastMode = 0xC0000

staticconstexprprivate

ICR 广播模式位

Definition at line 204 of file local_apic.h.

kIcrDeliveryStatusBit

constexpr uint32_t LocalApic::kIcrDeliveryStatusBit = 0x1000

staticconstexprprivate

ICR 传递状态位

Definition at line 200 of file local_apic.h.

kIcrDestShift

constexpr uint32_t LocalApic::kIcrDestShift = 24

staticconstexprprivate

ICR 目标位移

Definition at line 202 of file local_apic.h.

kInitIpiMode

constexpr uint32_t LocalApic::kInitIpiMode = 0x500

staticconstexprprivate

INIT IPI 模式

Definition at line 206 of file local_apic.h.

kLvtMaskBit

constexpr uint32_t LocalApic::kLvtMaskBit = 0x10000

staticconstexprprivate

LVT 掩码位

Definition at line 196 of file local_apic.h.

kLvtPeriodicMode

constexpr uint32_t LocalApic::kLvtPeriodicMode = 0x20000

staticconstexprprivate

LVT 周期模式位

Definition at line 198 of file local_apic.h.

kMicrosecondsPerSecond

constexpr uint32_t LocalApic::kMicrosecondsPerSecond = 1000000

staticconstexprprivate

每秒微秒数

Definition at line 232 of file local_apic.h.

kNmiMode

constexpr uint32_t LocalApic::kNmiMode = 0x400

staticconstexprprivate

NMI 传递模式

Definition at line 212 of file local_apic.h.

kSipiMode

constexpr uint32_t LocalApic::kSipiMode = 0x600

staticconstexprprivate

SIPI 模式

Definition at line 208 of file local_apic.h.

kSpuriousVector

constexpr uint32_t LocalApic::kSpuriousVector = 0xFF

staticconstexprprivate

虚假中断向量

Definition at line 194 of file local_apic.h.

kTimerDivideBy1

constexpr uint32_t LocalApic::kTimerDivideBy1 = 0x0B

staticconstexprprivate

定时器分频 1

Definition at line 222 of file local_apic.h.

kTimerDivideBy16

constexpr uint32_t LocalApic::kTimerDivideBy16 = 0x03

staticconstexprprivate

定时器分频 16

Definition at line 224 of file local_apic.h.

kX2ApicEnableBit

constexpr uint64_t LocalApic::kX2ApicEnableBit = 1ULL << 10

staticconstexprprivate

x2APIC 启用位

Definition at line 244 of file local_apic.h.

kXApicEoiOffset

constexpr uint32_t LocalApic::kXApicEoiOffset = 0xB0

staticconstexprprivate

EOI 寄存器偏移

Definition at line 160 of file local_apic.h.

kXApicEsrOffset

constexpr uint32_t LocalApic::kXApicEsrOffset = 0x280

staticconstexprprivate

错误状态寄存器偏移

Definition at line 164 of file local_apic.h.

kXApicIcrHighOffset

constexpr uint32_t LocalApic::kXApicIcrHighOffset = 0x310

staticconstexprprivate

ICR 高位寄存器偏移

Definition at line 168 of file local_apic.h.

kXApicIcrLowOffset

constexpr uint32_t LocalApic::kXApicIcrLowOffset = 0x300

staticconstexprprivate

ICR 低位寄存器偏移

Definition at line 166 of file local_apic.h.

kXApicIdOffset

constexpr uint32_t LocalApic::kXApicIdOffset = 0x20

staticconstexprprivate

Definition at line 154 of file local_apic.h.

kXApicLvtErrorOffset

constexpr uint32_t LocalApic::kXApicLvtErrorOffset = 0x370

staticconstexprprivate

LVT 错误寄存器偏移

Definition at line 176 of file local_apic.h.

kXApicLvtLint0Offset

constexpr uint32_t LocalApic::kXApicLvtLint0Offset = 0x350

staticconstexprprivate

LVT LINT0 寄存器偏移

Definition at line 172 of file local_apic.h.

kXApicLvtLint1Offset

constexpr uint32_t LocalApic::kXApicLvtLint1Offset = 0x360

staticconstexprprivate

LVT LINT1 寄存器偏移

Definition at line 174 of file local_apic.h.

kXApicLvtTimerOffset

constexpr uint32_t LocalApic::kXApicLvtTimerOffset = 0x320

staticconstexprprivate

LVT 定时器寄存器偏移

Definition at line 170 of file local_apic.h.

kXApicSivrOffset

constexpr uint32_t LocalApic::kXApicSivrOffset = 0xF0

staticconstexprprivate

虚假中断向量寄存器偏移

Definition at line 162 of file local_apic.h.

kXApicTimerCurrCountOffset

constexpr uint32_t LocalApic::kXApicTimerCurrCountOffset = 0x390

staticconstexprprivate

定时器当前计数寄存器偏移

Definition at line 180 of file local_apic.h.

kXApicTimerDivideOffset

constexpr uint32_t LocalApic::kXApicTimerDivideOffset = 0x3E0

staticconstexprprivate

定时器分频寄存器偏移

Definition at line 182 of file local_apic.h.

kXApicTimerInitCountOffset

constexpr uint32_t LocalApic::kXApicTimerInitCountOffset = 0x380

staticconstexprprivate

定时器初始计数寄存器偏移

Definition at line 178 of file local_apic.h.

kXApicTprOffset

constexpr uint32_t LocalApic::kXApicTprOffset = 0x80

staticconstexprprivate

任务优先级寄存器偏移

Definition at line 158 of file local_apic.h.

kXApicVersionOffset

constexpr uint32_t LocalApic::kXApicVersionOffset = 0x30

staticconstexprprivate

版本寄存器偏移

Definition at line 156 of file local_apic.h.

---

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

• /workspaces/SimpleKernel/src/arch/x86_64/apic/include/local_apic.h
• /workspaces/SimpleKernel/src/arch/x86_64/apic/local_apic.cpp