interrupt.cpp

Go to the documentation of this file.

 
#include "interrupt.h"
 
#include <cpu_io.h>
 
#include "arch.h"
#include "kernel.h"
#include "kernel_log.hpp"
#include "kstd_cstdio"
 
namespace {
template <uint8_t no>
__attribute__((target("general-regs-only"))) __attribute__((interrupt)) auto
TarpEntry(cpu_io::TrapContext* interrupt_context) -> void {
  InterruptSingleton::instance().Do(no, interrupt_context);
}
 
auto DefaultInterruptHandler(uint64_t cause, cpu_io::TrapContext* context)
    -> uint64_t {
  klog::Info("Default Interrupt handler [{}] {:#X}, {:#x}",
             cpu_io::IdtrInfo::kInterruptNames[cause], cause,
             reinterpret_cast<uintptr_t>(context));
  while (true) {
    ;
  }
}
}  // namespace
 
Interrupt::Interrupt() {
  // 注册默认中断处理函数
  for (auto& i : interrupt_handlers_) {
    i = InterruptDelegate::create<DefaultInterruptHandler>();
  }
 
  klog::Info("Interrupt init.");
}
 
auto Interrupt::Do(uint64_t cause, cpu_io::TrapContext* context) -> void {
  if (cause < cpu_io::IdtrInfo::kInterruptMaxCount) {
    interrupt_handlers_[cause](cause, context);
  }
}
 
auto Interrupt::RegisterInterruptFunc(uint64_t cause, InterruptDelegate func)
    -> void {
  if (cause < cpu_io::IdtrInfo::kInterruptMaxCount) {
    interrupt_handlers_[cause] = func;
    klog::Debug("RegisterInterruptFunc [{}] {:#X}",
                cpu_io::IdtrInfo::kInterruptNames[cause], cause);
  }
}
 
auto Interrupt::SetUpIdtr() -> void { SetUpIdtr<0>(); }
 
template <uint8_t no>
auto Interrupt::SetUpIdtr() -> void {
  if constexpr (no < cpu_io::IdtrInfo::kInterruptMaxCount - 1) {
    idts_[no] = cpu_io::IdtrInfo::Idt(
        reinterpret_cast<uint64_t>(TarpEntry<no>), 8, 0x0,
        cpu_io::IdtrInfo::Idt::Type::k64BitInterruptGate,
        cpu_io::IdtrInfo::Idt::DPL::kRing0, cpu_io::IdtrInfo::Idt::P::kPresent);
    SetUpIdtr<no + 1>();
  } else {
    // 写入 idtr
    static auto idtr = cpu_io::IdtrInfo::Idtr{
        .limit = sizeof(cpu_io::IdtrInfo::Idt) *
                     cpu_io::IdtrInfo::kInterruptMaxCount -
                 1,
        .base = idts_.data(),
    };
    cpu_io::Idtr::Write(idtr);
 
    // 输出 idtr 信息
    for (size_t i = 0;
         i < (cpu_io::Idtr::Read().limit + 1) / sizeof(cpu_io::IdtrInfo::Idtr);
         i++) {
      klog::Debug("idtr[{}] {:#x}", i,
                  reinterpret_cast<uintptr_t>(cpu_io::Idtr::Read().base + i));
    }
  }
}
 
auto Interrupt::SendIpi(uint64_t target_cpu_mask) -> Expected<void> {
  return std::unexpected(Error(ErrorCode::kIpiSendFailed));
}
 
auto Interrupt::BroadcastIpi() -> Expected<void> {
  return std::unexpected(Error(ErrorCode::kIpiSendFailed));
}
 
auto Interrupt::RegisterExternalInterrupt(uint32_t irq, uint32_t cpu_id,
                                          uint32_t priority,
                                          InterruptDelegate handler)
    -> Expected<void> {
  // 计算 IDT 向量号：kExternalVectorBase + irq
  auto vector = static_cast<uint64_t>(kExternalVectorBase + irq);
  if (vector >= cpu_io::IdtrInfo::kInterruptMaxCount) {
    return std::unexpected(Error(ErrorCode::kApicInvalidIrq));
  }
 
  // 先注册处理函数
  RegisterInterruptFunc(vector, handler);
 
  // 再在 IO APIC 上启用 IRQ 重定向到指定核心
  // 注: x86 APIC 优先级由向量号隐含决定，priority 参数不直接使用
  auto result = apic_.SetIrqRedirection(
      static_cast<uint8_t>(irq), static_cast<uint8_t>(vector), cpu_id, false);
  if (!result.has_value()) {
    return std::unexpected(result.error());
  }
 
  klog::Info("RegisterExternalInterrupt: IRQ {} -> vector {:#X}, cpu {}", irq,
             vector, cpu_id);
  return {};
}
 
auto Interrupt::InitApic(size_t cpu_count) -> void { apic_ = Apic(cpu_count); }