KVM中断虚拟化浅析
2017-08-24
今天咱们聊聊KVM中断虚拟化，虚拟机的中断源大致有两种方式，来自于用户空间qemu和来自于KVM内部。
中断虚拟化起始关键在于对中断控制器的虚拟化，中断控制器目前主要有APIC，这种架构下设备控制器通过某种触发方式通知IO APIC，IO APIC根据自身维护的重定向表pci irq routing table格式化出一条中断消息，把中断消息发送给local APIC，local APIC局部与CPU，即每个CPU一个，local APIC 具备传统中断控制器的相关功能以及各个寄存器，中断请求寄存器IRR，中断屏蔽寄存器IMR，中断服务寄存器ISR等，针对这些关键部件的虚拟化是中断虚拟化的重点。在KVM架构下，每个KVM虚拟机维护一个Io APIC，但是每个VCPU有一个local APIC。
核心数据结构介绍：
kvm_irq_routing_table
struct kvm_irq_routing_table { /*ue->gsi*/ int chip[KVM_NR_IRQCHIPS][KVM_IRQCHIP_NUM_PINS]; struct kvm_kernel_irq_routing_entry *rt_entries; u32 nr_rt_entries; /* * Array indexed by gsi. Each entry contains list of irq chips * the gsi is connected to. */ struct hlist_head map[0]; };
这个是一个中断路由表，每个KVM都有一个， chip是一个二维数组，表示三个芯片的各个管脚，每个芯片有24个管脚，每个数组项纪录对应管脚的GSI号；rt_entries是一个指针，指向一个kvm_kernel_irq_routing_entry数组，数组中共有nr_rt_entries项，每项对应一个IRQ；map其实可以理解为一个链表头数组，可以根据GSi号作为索引，找到同一IRQ关联的所有kvm_kernel_irq_routing_entry。具体中断路由表的初始化部分见本文最后一节
struct kvm_kernel_irq_routing_entry { u32 gsi; u32 type; int (*set)(struct kvm_kernel_irq_routing_entry *e, struct kvm *kvm, int irq_source_id, int level, bool line_status); union { struct { unsigned irqchip; unsigned pin; } irqchip; struct msi_msg msi; }; struct hlist_node link; };
gsi是该entry对应的gsi号，一般和IRQ是一样，set方法是该IRQ关联的触发方法，通过该方法把IRQ传递给IO-APIC，；link就是连接点，连接在上面同一IRQ对应的map上；
中断注入在KVM内部流程起始于一个函数kvm_set_irq
int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level, bool line_status) { struct kvm_kernel_irq_routing_entry *e, irq_set[KVM_NR_IRQCHIPS]; int ret = -1, i = 0; struct kvm_irq_routing_table *irq_rt; trace_kvm_set_irq(irq, level, irq_source_id); /* Not possible to detect if the guest uses the PIC or the * IOAPIC. So set the bit in both. The guest will ignore * writes to the unused one. */ rcu_read_lock(); irq_rt = rcu_dereference(kvm->irq_routing); if (irq < irq_rt->nr_rt_entries) hlist_for_each_entry(e, &irq_rt->map[irq], link) irq_set[i++] = *e; rcu_read_unlock(); /*依次调用同一个irq上的所有芯片的set方法*/ while(i--) { int r; /*kvm_set_pic_irq kvm_set_ioapic_irq*/ r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level, line_status); if (r < 0) continue; ret = r + ((ret < 0) ? 0 : ret); } return ret; }
kvm指定特定的虚拟机，irq_source_id是中断源ID，一般有KVM_USERSPACE_IRQ_SOURCE_ID和KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID；irq是全局的中断号，level指定高低电平，需要注意的是，针对边沿触发，需要两个电平触发来模拟，先高电平再低电平。回到函数中，首先要收集的是同一irq上注册的所有的设备信息，这主要在于irq共享的情况，非共享的情况下最多就一个。设备信息抽象成一个kvm_kernel_irq_routing_entry，这里临时放到irq_set数组中。然后对于数组中的每个元素，调用其set方法，目前大都是APIC架构，因此set方法基本都是kvm_set_ioapic_irq，在传统pic情况下，是kvm_set_pic_irq。我们以kvm_set_ioapic_irq为例进行分析，该函数没有实质性的操作，就调用了kvm_ioapic_set_irq函数
int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int irq_source_id, int level, bool line_status) { u32 old_irr; u32 mask = 1 << irq;//irq对应的位 union kvm_ioapic_redirect_entry entry; int ret, irq_level; BUG_ON(irq < 0 || irq >= IOAPIC_NUM_PINS); spin_lock(&ioapic->lock); old_irr = ioapic->irr; /*判断请求高电平还是低电平*/ irq_level = __kvm_irq_line_state(&ioapic->irq_states[irq], irq_source_id, level); entry = ioapic->redirtbl[irq]; irq_level ^= entry.fields.polarity; /*模拟低电平*/ if (!irq_level) { ioapic->irr &= ~mask; ret = 1; } else { /*判断触发方式*/ int edge = (entry.fields.trig_mode == IOAPIC_EDGE_TRIG); if (irq == RTC_GSI && line_status && rtc_irq_check_coalesced(ioapic)) { ret = 0; /* coalesced */ goto out; } /*设置中断信号到中断请求寄存器*/ ioapic->irr |= mask; /*如果是电平触发且旧的irr和请求的irr不相等，调用ioapic_service*/ if ((edge && old_irr != ioapic->irr) || (!edge && !entry.fields.remote_irr)) ret = ioapic_service(ioapic, irq, line_status); else ret = 0; /* report coalesced interrupt */ } out: trace_kvm_ioapic_set_irq(entry.bits, irq, ret == 0); spin_unlock(&ioapic->lock); return ret; }
到这里，中断已经到达模拟的IO-APIC了，IO-APIC最重要的就是它的重定向表，针对重定向表的操作主要在ioapic_service中，之前都是做一些准备工作，在进入ioapic_service函数之前，主要有两个任务：1、判断触发方式，主要是区分电平触发和边沿触发。2、设置ioapic的irr寄存器。之前我们说过，电触发需要两个边沿触发来模拟，前后电平相反。这里就要先做判断是对应哪一次。只有首次触发才会进行后续的操作，而二次触发相当于reset操作，就是把ioapic的irr寄存器清除。在电平触发模式下且请求的irq和ioapic中保存的irq不一致，就会对其进行更新，进入ioapic_service函数。
static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx, bool line_status) { union kvm_ioapic_redirect_entry *pent; int injected = -1; /*获取重定向表项*/ pent = &ioapic->redirtbl[idx]; if (!pent->fields.mask) { /*send irq to local apic*/ injected = ioapic_deliver(ioapic, idx, line_status); if (injected && pent->fields.trig_mode == IOAPIC_LEVEL_TRIG) pent->fields.remote_irr = 1; } return injected; }
该函数比较简单，就是获取根据irq号，获取重定向表中的一项，然后向本地APIC传递，即调用ioapic_deliver函数，当然前提是kvm_ioapic_redirect_entry没有设置mask，ioapic_deliver主要任务就是根据kvm_ioapic_redirect_entry，构建kvm_lapic_irq，这就类似于在总线上的传递过程。构建之后调用kvm_irq_delivery_to_apic，该函数会把消息传递给相应的VCPU ，具体需要调用kvm_apic_set_irq函数，继而调用__apic_accept_irq，该函数中会根据不同的传递模式处理消息,大部分情况都是APIC_DM_FIXED，在该模式下，中断被传递到特定的CPU，其中会调用kvm_x86_ops->deliver_posted_interrupt，实际上对应于vmx.c中的vmx_deliver_posted_interrupt
static void vmx_deliver_posted_interrupt(struct kvm_vcpu *vcpu, int vector) { struct vcpu_vmx *vmx = to_vmx(vcpu); int r; /*设置位图*/ if (pi_test_and_set_pir(vector, &vmx->pi_desc)) return; /*标记位图更新标志*/ r = pi_test_and_set_on(&vmx->pi_desc); kvm_make_request(KVM_REQ_EVENT, vcpu); #ifdef CONFIG_SMP if (!r && (vcpu->mode == IN_GUEST_MODE)); else #endif kvm_vcpu_kick(vcpu); }
这里主要是设置vmx->pi_desc中的位图即struct pi_desc 中的pir字段，其是一个32位的数组，共8项。因此最大标记256个中断，每个中断向量对应一位。设置好后，请求KVM_REQ_EVENT事件，在下次vm-entry的时候会进行中断注入。
具体注入过程：
在vcpu_enter_guest (x86.c)函数中,有这么一段代码
if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win) { kvm_apic_accept_events(vcpu); if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) { r = 1; goto out; } /*注入中断在vcpu加载到真实cpu上后，相当于某些位已经被设置*/ inject_pending_event(vcpu);//中断注入 ……
即在进入非跟模式之前会检查KVM_REQ_EVENT事件，如果存在pending的事件，则调用kvm_apic_accept_events接收，这里主要是处理APIC初始化期间和IPI中断的，暂且不关注。之后会调用inject_pending_event，在这里会检查当前是否有可注入的中断，而具体检查过程时首先会通过kvm_cpu_has_injectable_intr函数，其中调用kvm_apic_has_interrupt->apic_find_highest_irr->vmx_sync_pir_to_irr,vmx_sync_pir_to_irr函数对中断进行收集，就是检查vmx->pi_desc中的位图，如果有，则会调用kvm_apic_update_irr把信息更新到apic寄存器里。然后调用apic_search_irr获取IRR寄存器中的中断，没找到的话会返回-1.找到后调用kvm_queue_interrupt，把中断记录到vcpu中。
static inline void kvm_queue_interrupt(struct kvm_vcpu *vcpu, u8 vector, bool soft) { vcpu->arch.interrupt.pending = true; vcpu->arch.interrupt.soft = soft; vcpu->arch.interrupt.nr = vector; }
最后会调用kvm_x86_ops->set_irq，进行中断注入的最后一步，即写入到vmcs结构中。该函数指针指向vmx_inject_irq
static void vmx_inject_irq(struct kvm_vcpu *vcpu) { struct vcpu_vmx *vmx = to_vmx(vcpu); uint32_t intr; int irq = vcpu->arch.interrupt.nr;//中断号 trace_kvm_inj_virq(irq); ++vcpu->stat.irq_injections; if (vmx->rmode.vm86_active) { int inc_eip = 0; if (vcpu->arch.interrupt.soft) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, irq, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } intr = irq | INTR_INFO_VALID_MASK;//设置有中断向量的有效性 if (vcpu->arch.interrupt.soft) {//如果是软件中断 intr |= INTR_TYPE_SOFT_INTR;//内部中断 vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len);//软件中断需要写入指令长度 } else intr |= INTR_TYPE_EXT_INTR;//标记外部中断 vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr); }
最终会写入到vmcs的VM_ENTRY_INTR_INFO_FIELD中，这需要按照一定的格式。具体格式详见intel手册。0-7位是向量号，8-10位是中断类型（硬件中断或者软件中断），最高位是有效位，12位是NMI标志。
#define INTR_INFO_VECTOR_MASK 0xff /* 7:0 */ #define INTR_INFO_INTR_TYPE_MASK 0x700 /* 10:8 */ #define INTR_INFO_DELIVER_CODE_MASK 0x800 /* 11 */ #define INTR_INFO_UNBLOCK_NMI 0x1000 /* 12 */ #define INTR_INFO_VALID_MASK 0x80000000 /* 31 */
中断路由表的初始化
用户空间qemu通过KVM_CREATE_DEVICE API接口进入KVM的kvm_vm_ioctl处理函数，继而进入kvm_arch_vm_ioctl，根据参数中的KVM_CREATE_IRQCHIP标志进入初始化中断控制器的流程，首先肯定是注册pic和io APIC，这里我们就不详细阐述，重点在于后面对中断路由表的初始化过程。中断路由表的初始化通过kvm_setup_default_irq_routing函数实现，
int kvm_setup_default_irq_routing(struct kvm *kvm) { return kvm_set_irq_routing(kvm, default_routing, ARRAY_SIZE(default_routing), 0); }
首个参数kvm指定特定的虚拟机，后面default_routing是一个全局的kvm_irq_routing_entry数组，就定义在irq_comm.c中，该数组没别的作用，就是初始化kvm_irq_routing_table，看下kvm_set_irq_routing
int kvm_set_irq_routing(struct kvm *kvm, const struct kvm_irq_routing_entry *ue, unsigned nr, unsigned flags) { struct kvm_irq_routing_table *new, *old; u32 i, j, nr_rt_entries = 0; int r; /*正常情况下，nr_rt_entries=nr*/ for (i = 0; i < nr; ++i) { if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES) return -EINVAL; nr_rt_entries = max(nr_rt_entries, ue[i].gsi); } nr_rt_entries += 1; /*为中断路由表申请空间*/ new = kzalloc(sizeof(*new) + (nr_rt_entries * sizeof(struct hlist_head)) + (nr * sizeof(struct kvm_kernel_irq_routing_entry)), GFP_KERNEL); if (!new) return -ENOMEM; /*设置指针*/ new->rt_entries = (void *)&new->map[nr_rt_entries]; new->nr_rt_entries = nr_rt_entries; for (i = 0; i < KVM_NR_IRQCHIPS; i++) for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++) new->chip[i][j] = -1; /*初始化每一项kvm_kernel_irq_routing_entry*/ for (i = 0; i < nr; ++i) { r = -EINVAL; if (ue->flags) goto out; r = setup_routing_entry(new, &new->rt_entries[i], ue); if (r) goto out; ++ue; } mutex_lock(&kvm->irq_lock); old = kvm->irq_routing; kvm_irq_routing_update(kvm, new); mutex_unlock(&kvm->irq_lock); synchronize_rcu(); /*释放old*/ new = old; r = 0; out: kfree(new); return r; }
可以参考一个宏：
#define IOAPIC_ROUTING_ENTRY(irq) \
{ .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP, .u.irqchip.irqchip = KVM_IRQCHIP_IOAPIC, .u.irqchip.pin = (irq) }
这是初始化default_routing的一个关键宏，没一项都是通过该宏传递irq号（0-23）64位下是0-47,可见gsi就是irq号，所以实际上，回到函数中nr_rt_entries就是数组中项数，接着为kvm_irq_routing_table分配空间，注意分配的空间包含三部分：kvm_irq_routing_table结构、nr_rt_entries个hlist_head和nr个kvm_kernel_irq_routing_entry，所以kvm_irq_routing_table的大小是和全局数组的大小一样的。整个结构如下图所示
根据上图就可以理解new->rt_entries = (void *)&new->map[nr_rt_entries];这行代码的含义，接下来是对没项的table的chip数组做初始化，这里初始化为-1.接下来就是一个循环，对每一个kvm_kernel_irq_routing_entry做初始化，该过程是通过setup_routing_entry函数实现的，这里看下该函数
static int setup_routing_entry(struct kvm_irq_routing_table *rt, struct kvm_kernel_irq_routing_entry *e, const struct kvm_irq_routing_entry *ue) { int r = -EINVAL; struct kvm_kernel_irq_routing_entry *ei; /* * Do not allow GSI to be mapped to the same irqchip more than once. * Allow only one to one mapping between GSI and MSI. */ hlist_for_each_entry(ei, &rt->map[ue->gsi], link) if (ei->type == KVM_IRQ_ROUTING_MSI || ue->type == KVM_IRQ_ROUTING_MSI || ue->u.irqchip.irqchip == ei->irqchip.irqchip) return r; e->gsi = ue->gsi; e->type = ue->type; r = kvm_set_routing_entry(rt, e, ue); if (r) goto out; hlist_add_head(&e->link, &rt->map[e->gsi]); r = 0; out: return r; }
之前的初始化过程我们已经看见了，.type为KVM_IRQ_ROUTING_IRQCHIP，所以这里实际上就是把e->gsi = ue->gsi;e->type = ue->type;然后调用了kvm_set_routing_entry，该函数中主要是设置了kvm_kernel_irq_routing_entry中的set函数，APIC的话设置的是kvm_set_ioapic_irq函数，而pic的话设置kvm_set_pic_irq函数，然后设置irqchip的类型和管脚，对于IOAPIC也是直接复制过来，ＰＩＣ由于管脚计算是irq%8，所以这里需要加上8的偏移。之后设置table的chip为gis号。回到setup_routing_entry函数中，就把kvm_kernel_irq_routing_entry以gsi号位索引，加入到了map数组中对应的双链表中。再回到kvm_set_irq_routing函数中，接下来就是更新kvm结构中的irq_routing指针了。
中断虚拟化流程
kvm_set_irq
kvm_ioapic_set_irq
ioapic_service
ioapic_deliver
kvm_irq_delivery_to_apic
kvm_apic_set_irq
__apic_accept_irq
vmx_deliver_posted_interrupt
具体注入阶段
vcpu_enter_guest
kvm_apic_accept_events
inject_pending_event
kvm_queue_interrupt
vmx_inject_irq
vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr);
中断路由表初始化
x86.c kvm_arch_vm_ioctl
kvm_setup_default_irq_routing irq_common.c
kvm_set_irq_routing irq_chip.c
setup_routing_entry irq_chip.c
kvm_set_routing_entry irq_chip.c
e->set = kvm_set_ioapic_irq; irq_common.c
以马内利！
参考资料：
LInux3.10.1源码
