minos 2.3 中断虚拟化—

首发公号：Rand_cs
该项目来自乐敏大佬：https://github.com/minosproject/minos

硬件肯定需要软件配合，这一节就来实战 GICv2

首先准备好 GICv2 手册：https://developer.arm.com/documentation/ihi0048/bb/?lang=en，对于硬件的管理，最底层的操作就是读写硬件的寄存器，所以这里准备好手册，随时查阅手册

// gicv2.c static void *gicv2_dbase;
static void *gicv2_cbase;

首先定义了两个变量，gicc（cpu interface）和 gicd（distributor）基地值，这个值是在设备树文件中定义，然后 gic 初始化函数中映射到 hyp 虚拟地址

static inline void writeb_gicd(uint8_t val, unsigned int offset)
{writeb_relaxed(val, gicv2_dbase + offset);
}static inline void writel_gicd(uint32_t val, unsigned int offset)
{writel_relaxed(val, gicv2_dbase + offset);
}static inline uint32_t readl_gicd(unsigned int offset)
{return readl_relaxed(gicv2_dbase + offset);
}static inline void writel_gicc(uint32_t val, unsigned int offset)
{writel_relaxed(val, gicv2_cbase + offset);
}static inline uint32_t readl_gicc(unsigned int offset)
{return readl_relaxed(gicv2_cbase + offset);
}

随后定义了一系列读写寄存器的函数，就是相对 (gicc/gicd) 不同的偏移上进行读写，下面我们来看看主要需要操作哪些寄存器

GICD

GICD_ISENABLERn、 GICD_ICENABLERn

一个 GICD_ISENABLER 寄存器 32 bit，每一位控制一个中断的使能情况，n 表示第几个 GICD_ISENABLER 寄存器。向某位写 1 表示使能该中断，写 0 无效。

一个 GICD_ICENABLER 寄存器 32 bit，每一位控制一个中断的屏蔽情况，n 表示第几个 GICD_ICENABLER 寄存器。向某位写 1 表示屏蔽该中断，写 0 无效。

在 ARM 平台，使能和屏蔽一个中断是通过不同的寄存器来控制的，而不是一个寄存器使用 0 1 来分别表示屏蔽使能。这么做的好处之前有了解过是为了操作可以并行，比如说现在有操作使能第一号中断和屏蔽第二号中断，如果只使用0、1的方式来控制中断的屏蔽使能情况，第一号中断和第二号中断位于同一个寄存器，那么想要实现此操作，需要串行执行，但是如果使用 GICD_ISENABLER 来控制使能，GICD_ICENABLER 控制屏蔽，那么两个步骤就可以并行。另外因为写 0 无效，所以想要执行写操作的时候，不用先读后写（一般操作：read a，a |= x，write a，现在直接 write x）

// 屏蔽中断号为 irq 的中断
static void gicv2_mask_irq(uint32_t irq)
{unsigned long flags;spin_lock_irqsave(&gicv2_lock, flags);// 写 0 无效，所以可以直接写入值 1UL << (irq % 32)// irq / 32 表示第几个 GICD_ICENABLER 寄存器// (irq / 32) * 4，按字节算偏移，乘以 4writel_gicd(1UL << (irq % 32), GICD_ICENABLER + (irq / 32) * 4);dsb();spin_unlock_irqrestore(&gicv2_lock, flags);
}
// 使能中断号为 irq 的中断
static void gicv2_unmask_irq(uint32_t irq)
{unsigned long flags;spin_lock_irqsave(&gicv2_lock, flags);writel_gicd(1UL << (irq % 32), GICD_ISENABLER + (irq / 32) * 4);dsb();spin_unlock_irqrestore(&gicv2_lock, flags);
}

GICD_ICFGRn

Interrupt Configuration Registers，用来配置中断的类型

中断类型：边沿触发、电平触发

中断模型：

1-N 模型，只有一个 cpu 能够处理该中断，这指的是一个中断发送给多个 cpu，当此中断被某个 cpu 响应之后，gic 会清除掉此中断在其他所有 cpu 上的 pending 状态。
1. 这是专门用来描述 SPI 类型中断的。试想，磁盘数据好了，发送磁盘中断信号给 cpu，每个 cpu 都可以处理，但是肯定只能有一个 cpu 处理，否则数据紊乱
2. 当 CPU 从 GICC_IAR 读取中断号的时候，可能会读取到正确的中断号，这是响应 cpu。其他 cpu 会读取到 1023，这表示一个伪中断。
N-N 模型，所有 cpu 都会独立的收到该中断信号，当一个 cpu 相响应中断后，只是为该 cpu 清除掉此中断的 pending 状态。此中断对于其他 cpu 来说仍然是 pending 状态，其他 cpu 仍然需要响应处理此中断

GICD_ICFGR 寄存器就是用来配置一个中断的类型和模型

一个 GICD_ICFGR 寄存器 32bits，一个中断占 2bits

bit[0] 表示中断模型，为 0 表示 N-N 模型，为 1 表示 1-N 模型

bit[1] 表示中断类型，为 0 表示电平触发，为 1 表示边沿触发

static int gicv2_set_irq_type(uint32_t irq, uint32_t type)
{uint32_t cfg, edgebit;if (irq < 16)return 0;spin_lock(&gicv2_lock);/* Set edge / level */cfg = readl_gicd(GICD_ICFGR + (irq / 16) * 4);edgebit = 2u << (2 * (irq % 16));  // 边沿触发if ( type & IRQ_FLAGS_LEVEL_BOTH)cfg &= ~edgebit;else if (type & IRQ_FLAGS_EDGE_BOTH)cfg |= edgebit;writel_gicd(cfg, GICD_ICFGR + (irq / 16) * 4);spin_unlock(&gicv2_lock);return 0;
}

GICD_IPRIORITYR

Interrupt Priority Registers，设置每个中断的优先级

一个 GICD_IPRIORITYR 寄存器 32 bits，分为 4 组，每 8 bits 表示一个中断的优先级

static int gicv2_set_irq_affinity(uint32_t irq, uint32_t pcpu)
{if (pcpu > NR_GIC_CPU_IF || irq < 32)return -EINVAL;spin_lock(&gicv2_lock);/* Set target CPU mask (RAZ/WI on uniprocessor) */writeb_gicd(1 << pcpu, GICD_ITARGETSR + irq);spin_unlock(&gicv2_lock);return 0;
}

GICD_ITARGETSR

Interrupt Processor Targets Registers，设置中断亲和性

一个 GICD_ITARGETSR 寄存器 32 bits，分为 4 组，每 8 bits 表示一个中断的亲和性。举个例子，如果某个中断的亲和性设置 3(0b11)，那么这个中断将会被 distributor 转发给 0、1 号 cpu interface。

另外，前面提到过，SPI 的中断号从 32 开始，所以 GICD_ITARGETSR0~GICD_ITARGETSR7 “无用”，读取GICD_ITARGETSR0~GICD_ITARGETSR7会返回执行读取操作 cpu 的 id 值

static int gicv2_set_irq_affinity(uint32_t irq, uint32_t pcpu)
{if (pcpu > NR_GIC_CPU_IF || irq < 32)return -EINVAL;spin_lock(&gicv2_lock);/* Set target CPU mask (RAZ/WI on uniprocessor) */writeb_gicd(1 << pcpu, GICD_ITARGETSR + irq);spin_unlock(&gicv2_lock);return 0;
}

GICD_SGIR

Software Generated Interrupt Register，写这个寄存器来产生 SGI 中断

关注两个字段：

TargetListFilter
- 0b00，表示向位于 CPUTargetList 位图中的 CPU Interface集合发送 SGI
- 0b01，表示向所有 CPU Interface发送一个 SGI 中断
- 0b10，表示向自己发送一个 SGI
- 0b11，reserved
CPUTargetList，一个 CPU 位图，某一位为 1 表示要向该 CPU Interface 发送一个 SGI（TargetListFilter=0b00 的情况下）

static void gicv2_send_sgi(uint32_t sgi, enum sgi_mode mode, cpumask_t *mask)
{unsigned int cpu;unsigned int value = 0;switch (mode) {// 发送一个 SGI 给所有 CPUcase SGI_TO_OTHERS:writel_gicd(GICD_SGI_TARGET_OTHERS | sgi, GICD_SGIR);break;// 给自己发送一个 SGIcase SGI_TO_SELF:writel_gicd(GICD_SGI_TARGET_SELF | sgi, GICD_SGIR);break;// 发送一个 SGI 给目标 CPU 组case SGI_TO_LIST:for_each_cpu(cpu, mask)value |= gic_cpu_mask[cpu];// 填写目标 CPU 位图集合writel_gicd(GICD_SGI_TARGET_LIST |(value << GICD_SGI_TARGET_SHIFT) | sgi,GICD_SGIR);isb();break;default:break;;}
}

NOTE，Distributor 只会向 CPU Interface 转发中断请求，CPU Interface 才会向 CPU 发送中断信号

GICD_TYPER

Interrupt Controller Type Register，有关 GICD 的一些信息

ITLinesNumber：支持的中断个数

CPUNumber：CPU 个数

GICC

GICC_EOIR、GICC_DIR

当一个中断完成的时候，CPU 必须发送一个 “complete” 信号给 GIC，“complete” 步骤分为两步：

Priority drop，优先级降低。中断状态并未改变，仍然是 active。优先级降低指的是当前 CPU 上 “running priority”，降低之后 cpu interface 可以继续发送优先级较低的中断给 cpu。
Interrupt deactivation，真正改变中断状态了。可以从 active->inactive，active and pending->pending

这涉及到了 3 个寄存器，GICC_EOIR（End of Interrupt Register），GICC_DIR（Deactivate Interrupt Register），GICC_CTLR（CPU Interface Control Register）

当 GICC_CTLR.EOImode = 1 时，Priority drop 和 Interrupt deactivation 两个步骤是分开的，也就是说写 GICC_EOIR 会 Priority drop，写 GICC_DIR 会 Interrupt deactivation

当 GICC_CTLR.EOImode = 0 是，Priority drop 和 Interrupt deactivation 两个步骤是在一起的，写 GICC_EOIR 寄存器就表示完成两个步骤

GICC_DIR 和 GICC_EOIR 格式都如下所示：

static void gicv2_eoi_irq(uint32_t irq)
{writel_gicc(irq, GICC_EOIR);dsb();
}static void gicv2_dir_irq(uint32_t irq)
{writel_gicc(irq, GICC_DIR);dsb();
}

用法也很简单，写入相应的中断号就行

GICC_IAR

Interrupt Acknowledge Register，CPU 读取此寄存器来获取中断号，并且也是一个 ACK 操作

static uint32_t gicv2_read_irq(void)
{uint32_t irq;irq = readl_gicc(GICC_IAR);isb();irq = irq & GICC_IA_IRQ;return irq;
}

格式同前 EOIR，操作也是很简单，从低 10 bits 获取中断号

GICC_PMR

Interrupt Priority Mask Register，只有优先级比 GICC_PMR 里面设置的高，才会将该中断信号发送给 cpu

格式如上，一般我们写 0xff，表示不屏蔽任何中断（值越大，优先级越低）

GIC INIT

gicv2_dist_init

static void __init_text gicv2_dist_init(void)
{uint32_t type;uint32_t cpumask;uint32_t gic_cpus;unsigned int nr_lines;int i;// 所有中断都往 pcpu0 发送cpumask = readl_gicd(GICD_ITARGETSR) & 0xff;cpumask = (cpumask == 0) ? (1 << 0) : cpumask;cpumask |= cpumask << 8;cpumask |= cpumask << 16;/* Disable the distributor */writel_gicd(0, GICD_CTLR);// 从 GICD_TYPER 寄存器里面获取 cpu 数量和支持的中断数type = readl_gicd(GICD_TYPER);nr_lines = 32 * ((type & GICD_TYPE_LINES) + 1);gic_cpus = 1 + ((type & GICD_TYPE_CPUS) >> 5);pr_notice("GICv2: %d lines, %d cpu%s%s (IID %x).\n",nr_lines, gic_cpus, (gic_cpus == 1) ? "" : "s",(type & GICD_TYPE_SEC) ? ", secure" : "",readl_gicd(GICD_IIDR));/* Default all global IRQs to level, active low */// 配置所有 irq 为边沿触发for ( i = 32; i < nr_lines; i += 16 )writel_gicd(0x0, GICD_ICFGR + (i / 16) * 4);/* Route all global IRQs to this CPU */// 配置所有中断的亲和性为 cpu0for ( i = 32; i < nr_lines; i += 4 )writel_gicd(cpumask, GICD_ITARGETSR + (i / 4) * 4);/* Default priority for global interrupts */for ( i = 32; i < nr_lines; i += 4 )writel_gicd(GIC_PRI_IRQ << 24 | GIC_PRI_IRQ << 16 |GIC_PRI_IRQ << 8 | GIC_PRI_IRQ,GICD_IPRIORITYR + (i / 4) * 4);/* Disable all global interrupts */// 屏蔽所有中断for ( i = 32; i < nr_lines; i += 32 )writel_gicd(~0x0, GICD_ICENABLER + (i / 32) * 4);/* Only 1020 interrupts are supported */// 从支持的中断数和 1020 之中选一个小的gicv2_nr_lines = min(1020U, nr_lines);/* Turn on the distributor */// 使能所有中断writel_gicd(GICD_CTL_ENABLE, GICD_CTLR);dsb();
}

gicv2_cpu_init

static void __init_text gicv2_cpu_init(void)
{int i;int cpuid = smp_processor_id();// 读取 GICD_ITARGETSR0 会返回当前 cpuidgic_cpu_mask[cpuid] = readl_gicd(GICD_ITARGETSR) & 0xff;pr_debug("gicv2 gic mask of cpu%d: 0x%x\n", cpuid, gic_cpu_mask[cpuid]);if (gic_cpu_mask[cpuid] == 0)gic_cpu_mask[cpuid] = 1 << cpuid;/* The first 32 interrupts (PPI and SGI) are banked per-cpu, so* even though they are controlled with GICD registers, they must* be set up here with the other per-cpu state. */// TODO ???writel_gicd(0xffff0000, GICD_ICENABLER); /* Disable all PPI */writel_gicd(0x0000ffff, GICD_ISENABLER); /* Enable all SGI *//* Set SGI priorities */// 设置 SGI 的优先级，IPIs must preempt normal interruptsfor ( i = 0; i < 16; i += 4 )writel_gicd(GIC_PRI_IPI << 24 | GIC_PRI_IPI << 16 |GIC_PRI_IPI << 8 | GIC_PRI_IPI,GICD_IPRIORITYR + (i / 4) * 4);/* Set PPI priorities */// 设置 PPI 的优先级for ( i = 16; i < 32; i += 4 )writel_gicd(GIC_PRI_IRQ << 24 | GIC_PRI_IRQ << 16 |GIC_PRI_IRQ << 8 | GIC_PRI_IRQ,GICD_IPRIORITYR + (i / 4) * 4);/* Local settings: interface controller *//* Don't mask by priority */writel_gicc(0xff, GICC_PMR);/* Finest granularity of priority */writel_gicc(0x0, GICC_BPR);/* Turn on delivery */// GICC_CTL_ENABLE 允许 group1（非安全中断，目前minos里面都是）中断发送给 cpu// GICC_CTL_EOI drop priority 和 deactivate interrupt 分开writel_gicc(GICC_CTL_ENABLE|GICC_CTL_EOI, GICC_CTLR);dsb();
}

gicv2_init

static struct irq_chip gicv2_chip = {.irq_mask       = gicv2_mask_irq,.irq_mask_cpu       = gicv2_mask_irq_cpu,.irq_unmask         = gicv2_unmask_irq,.irq_unmask_cpu     = gicv2_unmask_irq_cpu,.irq_eoi        = gicv2_eoi_irq,.irq_dir        = gicv2_dir_irq,.irq_set_type       = gicv2_set_irq_type,.irq_set_affinity   = gicv2_set_irq_affinity,.send_sgi       = gicv2_send_sgi,.get_pending_irq    = gicv2_read_irq,.irq_set_priority   = gicv2_set_irq_priority,.irq_xlate      = gic_xlate_irq,.init           = gicv2_init,.secondary_init     = gicv2_secondary_init,
};

irq_chip 是一个 gic 芯片抽象，对于 gicv2 的抽象定义在了 gicv2_chip，大多操作我们都讲述了

gicv2_init 涉及设备树操作以以及虚拟化的初始化，后面讲述。gicv2_secondary_init 这是级联相关（一个 gic 芯片不够，多个 gic 芯片连接起来共同工作）目前不涉及

首发公号：Rand_cs