#include <cpu_io.h>
#include <opensbi_interface.h>
#include "arch.h"
#include "basic_info.hpp"
#include "interrupt.h"
#include "kernel.h"
#include "kernel_fdt.hpp"
#include "kernel_log.hpp"
#include "kstd_cstdio"
#include "ns16550a/ns16550a.hpp"
#include "syscall.hpp"
#include "task_manager.hpp"
#include "virtio/virtio_driver.hpp"
#include "virtual_memory.hpp"

Include dependency graph for interrupt_main.cpp:

Functions
auto	HandleTrap (cpu_io::TrapContext context) -> cpu_io::TrapContext

auto	InterruptInit (int, const char **) -> void
	体系结构相关中断初始化

auto	InterruptInitSMP (int, const char **) -> void
	从核的体系结构相关中断初始化

Function Documentation

◆ HandleTrap()

auto HandleTrap ( cpu_io::TrapContext * context ) -> cpu_io::TrapContext*

Definition at line 149 of file interrupt_main.cpp.

                          {
  InterruptSingleton::instance().Do(context->scause, context);
  return context;
}

◆ InterruptInit()

auto InterruptInit	(	int	argc,
		const char **	argv
	)		-> void

体系结构相关中断初始化

Parameters

argc	在不同体系结构有不同含义，同 _start
argv	在不同体系结构有不同含义，同 _start

Precondition: ArchInit 已完成

Postcondition: 中断控制器已初始化，中断向量表已设置

Definition at line 155 of file interrupt_main.cpp.

                                              {
  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());
          return std::unexpected(err);
        });
  }
 
  klog::Info("Hello InterruptInit");
}

Here is the call graph for this function:

◆ InterruptInitSMP()

auto InterruptInitSMP	(	int	argc,
		const char **	argv
	)		-> void

从核的体系结构相关中断初始化