Function InterruptInit

src/arch/riscv64/interrupt_main.cpp:155–218

}

auto InterruptInit(int, const char**) -> void {
  InterruptSingleton::create();

  // 注册中断处理函数
  RegisterInterrupts();

  // 初始化 plic
  auto [plic_addr, plic_size, ndev, context_count] =
      KernelFdtSingleton::instance().GetPlic().value();
  VirtualMemorySingleton::instance()
      .MapMMIO(plic_addr, plic_size)
      .or_else([](Error err) -> Expected<void*> {
        klog::Err("Failed to map PLIC MMIO: {}", err.message());
        while (true) {
          cpu_io::Pause();
        }
        return std::unexpected(err);
      });
  InterruptSingleton::instance().InitPlic(plic_addr, ndev, context_count);

  // 设置 trap vector
  auto success =
      cpu_io::Stvec::SetDirect(reinterpret_cast<uint64_t>(trap_entry));
  if (!success) {
    klog::Err("Failed to set trap vector");
  }

  // 开启 Supervisor 中断
  cpu_io::Sstatus::Sie::Set();

  // 开启内部中断
  cpu_io::Sie::Ssie::Set();

  // 开启外部中断
  cpu_io::Sie::Seie::Set();

  // 通过统一接口注册串口外部中断（先注册 handler，再启用 PLIC）
  auto serial_irq =
      std::get<2>(KernelFdtSingleton::instance().GetSerial().value());
  InterruptSingleton::instance()
      .RegisterExternalInterrupt(serial_irq, cpu_io::GetCurrentCoreId(), 1,
                                 InterruptDelegate::create<SerialIrqHandler>())
      .or_else([](Error err) -> Expected<void> {
        klog::Err("Failed to register serial IRQ: {}", err.message());
        return std::unexpected(err);
      });

  // 通过统一接口注册 virtio-blk 外部中断
  auto& blk_driver = VirtioDriverSingleton::instance();
  auto blk_irq = blk_driver.GetIrq();
  if (blk_irq != 0) {
    InterruptSingleton::instance()
        .RegisterExternalInterrupt(
            blk_irq, cpu_io::GetCurrentCoreId(), 1,
            InterruptDelegate::create<VirtioBlkIrqHandler>())
        .or_else([blk_irq](Error err) -> Expected<void> {
          klog::Err("Failed to register virtio-blk IRQ {}: {}", blk_irq,
                    err.message());