minos 2.6 中断虚拟化——虚拟中断子系统

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

Hypervisor 需要对每个虚机的虚拟中断进行管理，这其中涉及的一系列数据结构和操作就是虚拟中断子系统

VIRQ

虚拟中断描述符

struct vcpu {
    uint32_t vcpu_id;
...........
    /*
     * member to record the irq list which the
     * vcpu is handling now
     */
    struct virq_struct *virq_struct;

...........
} __cache_line_align;

minos 对于每个物理 CPU 定义了 struct pcpu 来管理其相关状态，同样的，minos 对于每个 vm 的 vcpu，也定义了一个结构体来管理 struct vcpu。每个 vcpu 里面又有一个 virq_struct 字段来管理该 vcpu 关于中断的一些信息，具体来看：

struct virq_struct {
    int nr_lrs;           // LR 寄存器个数
    int last_fail_virq;   // 上一个因分配 LR 失败的 virq
    atomic_t pending_virq;  // 有多少个 virq 处于 pending 状态
    uint32_t active_virq;   // 有多少个 virq 处于 active 状态
    struct virq_desc local_desc[VM_LOCAL_VIRQ_NR];  // virq 描述符(PPI+SGI)
    unsigned long *pending_bitmap;  // virq pending 位图（PPI+SGI+SPI)
    unsigned long *active_bitmap;  // virq active 位图
    unsigned long lrs_bitmap[BITS_TO_LONGS(VGIC_MAX_LRS)];  // LR 位图
};
//..........................
#define VM_SGI_VIRQ_NR      (CONFIG_NR_SGI_IRQS)   //16
#define VM_PPI_VIRQ_NR      (CONFIG_NR_PPI_IRQS)   //16
#define VM_LOCAL_VIRQ_NR    (VM_SGI_VIRQ_NR + VM_PPI_VIRQ_NR)

在 minos 中，每个物理中断都有一个 irq_desc 来描述，同样的每个虚拟中断都有一个 virq_desc 描述符，定义如下：

struct virq_desc {
    int32_t flags;
    uint16_t vno;    // virq number
    uint16_t hno;    // 如果该 virq 关联了一个 hwirq，记录该 hwirq number
    uint8_t id;      // LR 寄存器编号
    uint8_t state;   // 状态
    uint8_t pr;      // 优先级
    uint8_t src;     // SGI 中断下，记录源 vcpu id
    uint8_t type;    // edge or level
    uint8_t vcpu_id; // vcpu id
    uint8_t vmid;    // vm id
    uint8_t padding;
} __packed;

SGI 和 PPI 可以看作是 percpu 中断，所以这里将这两种虚拟中断描述符定义在了 vcpu->virq_struct 结构体中，那 SPI 类型的中断呢，SPI 类型的中断时所有 CPU 共享的，在虚拟化的情况下就是所有 VCPU 共享，它定义在 struct vm 中：

struct vm {
    int vmid;
..................
    uint32_t vspi_nr;     // 当前 vm spi 中断个数
    struct virq_desc *vspi_desc;  // spi 类型中断描述符数组
    unsigned long *vspi_map;   // 分配 virq_desc 时使用的位图
    struct virq_chip *virq_chip;   // vgic 指针
..................
} __align(sizeof(unsigned long));

初始化操作

上述涉及了很多的结构体及其字段信息，这里来看一下它们的初始化流程

// 初始化 vm 的 virq 信息
static int virq_create_vm(void *item, void *args)
{
    uint32_t size, vdesc_size, vdesc_bitmap_size, status_bitmap_size;
    struct vm *vm = (struct vm *)item;
    struct virq_struct *vs;
    void *base;
    int i;

    /*
     * Total size:
     * 1 - sizeof(struct virq_desc) * vspi_nr
     * 3 - vitmap_size(spi_nr)
     * 2 - vcpu_nr * bitmap_size * (SGI + PPI + SPI) * 2
     */
    // 获取最大的 vspi 数量
    vm->vspi_nr = vm_max_virq_line(vm);
    // 计算需要的 virq_desc 大小
    vdesc_size = sizeof(struct virq_desc) * vm->vspi_nr;
    // 对齐
    vdesc_size = BALIGN(vdesc_size, sizeof(unsigned long));
    // 根据数量 vspi_nr 计算位图大小
    vdesc_bitmap_size = BITMAP_SIZE(vm->vspi_nr);
    // 计算一个位图大小
    // 包括所有类型的中断：PPI+SGI+SPI
    status_bitmap_size = BITMAP_SIZE(vm->vspi_nr + VM_LOCAL_VIRQ_NR);

    // 需要分配的总大小 = virq_descs + spi_bitmap + pending_bitmap + active_bitmap
    size = vdesc_size + vdesc_bitmap_size +
        (status_bitmap_size * vm->vcpu_nr * 2);
    size = PAGE_BALIGN(size);

    pr_notice("allocate 0x%x bytes for virq struct\n", size);
    // 根据大小分配内存
    base = get_free_pages(PAGE_NR(size));
    if (!base) {
        pr_err("no more page for virq struct\n");
        return -ENOMEM;
    }
    // 相关地址信息记录到 vm 对应字段
    memset(base, 0, size);
    vm->vspi_desc = (struct virq_desc *)base;
    vm->vspi_map = (unsigned long *)(base + vdesc_size);
    // 初始化 vcpu 的 pending 和 active 位图
    base = base + vdesc_size + vdesc_bitmap_size;
    for (i = 0; i < vm->vcpu_nr; i++) {
        vs = vm->vcpus[i]->virq_struct;
        ASSERT(vs != NULL);
        vs->pending_bitmap = base;
        base += status_bitmap_size;
        vs->active_bitmap = base;
        base += status_bitmap_size;
    }

    return 0;
}

在创建 vm 的时候会调用 virq_create_vm 来初始化 virq 的基本信息，就是上述所提到的一些值

// virq_struct 初始化
void vcpu_virq_struct_init(struct vcpu *vcpu)
{
    struct virq_struct *virq_struct = vcpu->virq_struct;
    struct virq_desc *desc;
    int i;

    virq_struct->active_virq = 0;
    atomic_set(0, &virq_struct->pending_virq);

    // 所有 desc 重置清零，设置为 0
    memset(&virq_struct->local_desc, 0,
        sizeof(struct virq_desc) * VM_LOCAL_VIRQ_NR);

    // 初始化每个 desc，所欲字段设置为默认值
    for (i = 0; i < VM_LOCAL_VIRQ_NR; i++) {
        desc = &virq_struct->local_desc[i];
        virq_clear_hw(desc);
        virq_set_enable(desc);

        /* this is just for ppi or sgi */
        desc->vcpu_id = VIRQ_AFFINITY_VCPU_ANY;
        desc->vmid = VIRQ_AFFINITY_VM_ANY;
        desc->vno = i;
        desc->hno = 0;
        desc->id = VIRQ_INVALID_ID;
        desc->state = VIRQ_STATE_INACTIVE;
    }
}

// 重置 vm 中所有 virq_desc
void vm_virq_reset(struct vm *vm)
{
    struct virq_desc *desc;
    int i;

    /* reset the all the spi virq for the vm */
    for ( i = 0; i < vm->vspi_nr; i++) {
        desc = &vm->vspi_desc[i];
        virq_clear_enable(desc); //屏蔽该 virq
        desc->pr = 0xa0;   //优先级
        desc->type = 0x0;  
        desc->id = VIRQ_INVALID_ID;
        desc->state = VIRQ_STATE_INACTIVE;

        if (virq_is_hw(desc))  //如果是 hw interrupt
            irq_mask(desc->hno); //芯片级屏蔽
    }
}

还有一些如上所示的一些重置函数，比较简单了，这里不再详述，大家可以自行阅读相关代码

注册虚拟中断

// 注册普通的 virq
int request_virq(struct vm *vm, uint32_t virq, unsigned long flags)
{   
    // hwirq 设置为 0，该 virq 没有与物理物理中断关联
    return request_hw_virq(vm, virq, 0, flags);
}

// 注册中断衍生函数
int request_hw_virq(struct vm *vm, uint32_t virq, uint32_t hwirq,
            unsigned long flags)
{
    if (virq >= vm_max_virq_line(vm)) {
        pr_err("invaild virq-%d for vm-%d\n", virq, vm->vmid);
        return -EINVAL;
    } else {
        // 默认将所有的中断都发送给 vcpu0
        return request_virq_affinity(vm, virq, hwirq, 0, flags);
    }
}

// 注册中断的一个衍生函数
int request_virq_affinity(struct vm *vm, uint32_t virq, uint32_t hwirq,
            int affinity, unsigned long flags)
{
    struct vcpu *vcpu;
    struct virq_desc *desc;

    // 获取 vcpu0，这里的 affinity 其实就是一个 vcpu_id
    vcpu = get_vcpu_in_vm(vm, affinity);
    if (!vcpu) {
        pr_err("request virq fail no vcpu-%d in vm-%d\n",
                affinity, vm->vmid);
        return -EINVAL;
    }

    // 获取对应的 desc
    desc = get_virq_desc(vcpu, virq);
    if (!desc) {
        pr_err("virq-%d not exist vm-%d", virq, vm->vmid);
        return -ENOENT;
    }

    // 注册中断
    return __request_virq(vcpu, desc, virq, hwirq, flags);
}

上述是注册虚拟中断的一系列衍生函数，有一个注意点：request_hw_virq 调用 request_virq_affinity 时，affinity 参数默认是 0，也就是说后续默认将 virq 发送到 vcpu0。以前看过 KVM 的代码，KVM 也是这么处理的，默认将 SPI 中断发送到 virq0，对于 MAC ARM 使用的 HVF，虽然闭源，但是从结果上来看也是这样处理的，这是为了方便处理？存疑

// 根据 virq 获取对应的 virq_desc 结构体
// local virq(sgi ppi) 为每个 cpu 拥有的，所以将 local_desc 定义于 vcpu 中
// spi 为所有该 vm 中的 vcpu 中共享，所以将 vspi_desc 定义与 vm 中
struct virq_desc *get_virq_desc(struct vcpu *vcpu, uint32_t virq)
{
    struct vm *vm = vcpu->vm;

    // if virq < 32
    if (virq < VM_LOCAL_VIRQ_NR)
        // 直接返回对应的 virq_desc
        return &vcpu->virq_struct->local_desc[virq];

    // 如果 virq 大于了最大号数
    if (virq >= VM_VIRQ_NR(vm->vspi_nr))
        return NULL;
    
    // virq-32 即为对应的下标值
    return &vm->vspi_desc[VIRQ_SPI_OFFSET(virq)];
}

get_virq_desc 根据 virq 虚拟中断号获取对应的 virq_desc 虚拟中断描述符，如果是 percpu 中断，从 vcpu->virq_struct 获取，如果是 SPI 类型中断，从 vm->vspi_desc 中获取

// 注册 virq
static int __request_virq(struct vcpu *vcpu, struct virq_desc *desc,
            uint32_t virq, uint32_t hwirq, unsigned long flags)
{
    if (test_and_set_bit(VIRQS_REQUESTED_BIT,
                (unsigned long *)&desc->flags)) {
        pr_warn("virq-%d may has been requested\n", virq);
        return -EBUSY;
    }

    // 设置 desc 字段值
    desc->vno = virq;  // virq
    desc->hno = hwirq; // hwirq
    desc->vcpu_id = get_vcpu_id(vcpu); // vcpu_id
    desc->pr = 0xa0; // 优先级
    desc->vmid = get_vmid(vcpu); // vmid
    desc->id = VIRQ_INVALID_ID; // LR 编号，send_virq 的时候分配
    desc->state = VIRQ_STATE_INACTIVE; //刚注册，inactive

    /* mask the bits in spi_irq_bitmap, if it is a SPI */
    // 如果大于 VM_LOCAL_VIRQ_NR，则为 SPI 类型的中断
    if (virq >= VM_LOCAL_VIRQ_NR)
        set_bit(VIRQ_SPI_OFFSET(virq), vcpu->vm->vspi_map);

    /* if the virq affinity to a hwirq need to request
     * the hw irq */
    // 如果有对应的 hwirq
    if (hwirq) {
        // 设置芯片级别的 cpu 亲和性
        irq_set_affinity(hwirq, vcpu_affinity(vcpu));
        // 设置 VIRQS_HW 标志
        virq_set_hw(desc);
        // 在 hyp 下注册 hwirq 中断
        request_irq(hwirq, guest_irq_handler, IRQ_FLAGS_VCPU,
                vcpu->task->name, (void *)desc);
        irq_mask(desc->hno);
    // 否则清除 desc 的 VIRQS_HW 标志
    } else {
        virq_clear_hw(desc);
    }

    // 更新 virq 的 一些标志信息
    update_virq_cap(desc, flags);

    return 0;
}

想想之前注册物理中断所做的事情，主要就是设置物理中断号 irq 对应的物理中断描述符 irq_desc，其重点设置了该中断对应的 handler。注册虚拟中断类似，但有一点不同，虚拟中断在 host 侧是没有 handler 的，所以上述只是在 virq_desc 中设置了该中断的中断号、状态、各个 id 等等信息，就是没有 handler。因为 host 只是负责向虚机注入虚拟中断，处理是虚机做的事情。

另外如果一个虚拟中断关联了一个物理中断，那么需要在 host 注册该物理中断，其 handler 为 guest_irq_handler：

// hw 类型的 virq 将会注册到 hyp，注册时的 handler 便为此 guest_irq_handler，它会将中断路由到某具体的 vcpu
static int guest_irq_handler(uint32_t irq, void *data)
{
    struct vcpu *vcpu;
    struct virq_desc *desc = (struct virq_desc *)data;

    if ((!desc) || (!virq_is_hw(desc))) {
        pr_notice("virq %d is not a hw irq\n", desc->vno);
        return -EINVAL;
    }

    /* send the virq to the guest */
    // 如果 vmid 和 vcpu_id 都没有指定，很随便的话，那么就选择当前的 vcpu
    if ((desc->vmid == VIRQ_AFFINITY_VM_ANY) &&
            (desc->vcpu_id == VIRQ_AFFINITY_VCPU_ANY))
        vcpu = get_current_vcpu();
    else
        // 获取 desc 指定的 vcpu
        vcpu = get_vcpu_by_id(desc->vmid, desc->vcpu_id);

    // send virq 给某 vcpu
    return send_virq(vcpu, desc);
}

该函数主要做的事情就是调用 send_virq 来向目标 vcpu 发送虚拟中断。

中断注入

// 发送 virq 给某个 vcpu
static int send_virq(struct vcpu *vcpu, struct virq_desc *desc)
{
.......
    ret = __send_virq(vcpu, desc);
.......
    return 0;
}

// send virq，主要就是设置 vcpu 中对应的 virq_struct pending 位图
static int inline __send_virq(struct vcpu *vcpu, struct virq_desc *desc)
{
    struct virq_struct *virq_struct = vcpu->virq_struct;

    /*
     * if the virq is already at the pending state, do
     * nothing, other case need to send it to the vcpu
     * if the virq is in offline state, send it to vcpu
     * directly.
     *
     * SGI need set the irq source.
     */
    //将 virq 设置到 pending_bitmap
    if (test_and_set_bit(desc->vno, virq_struct->pending_bitmap))
        return 0;
    
    // pending_virq ++
    atomic_inc(&virq_struct->pending_virq);
    // 如果是 sgi 类型的 virq，设置来源 cpu 为当前 cpu
    if (desc->vno < VM_SGI_VIRQ_NR)
        desc->src = get_vcpu_id(get_current_vcpu());

    return 0;
}

先暂时略去 send_virq 中一些复杂逻辑，中断注入的主要流程如上所示，会发现就是简单的设置 pending 位图操作。这样就完了吗，当然不是，前文 minos 4.5 中断虚拟化——vGIC 我们提到过，在 host 侧发送虚拟中断的操作实际上是获取并写一个 LR 寄存器，所以实际的中断注入操作如下：

// 进入 guest 
int vgic_irq_enter_to_guest(struct vcpu *vcpu, void *data)
{
    struct virq_struct *vs = vcpu->virq_struct;
    struct vm *vm = vcpu->vm;
    struct virq_desc *virq;
    int id = 0, bit, flags = 0, size, old;

    bit = vs->last_fail_virq;
    size = vm_irq_count(vm) - bit;
    old = vs->last_fail_virq;
    vs->last_fail_virq = 0;

repeat:
    // 遍历该 vcpu 的 pending_map
    for_each_set_bit_from(bit, vs->pending_bitmap, size) {
        // 获取该 virq 对应的 virq_desc
        virq = get_virq_desc(vcpu, bit);
        if (virq == NULL) {
            pr_err("bad virq %d for vm %s\n", bit, vm->name);
            clear_bit(bit, vs->pending_bitmap);
            continue;
        }

        /*
         * do not send this virq if there is same virq in
         * active state, need wait the previous virq done.
         */
        // 如果它也存在于 active_map，continue
        // 说明这里处理 pending_and_active 中断的方式是不重复 trigger
        if (test_bit(bit, vs->active_bitmap))
            continue;

        /* allocate a id for the virq */
        // 分配一个 LR 寄存器
        id = find_first_zero_bit(vs->lrs_bitmap, vs->nr_lrs);
        // 分配失败
        if (id >= vs->nr_lrs) {
            pr_err("VM%d no space to send new irq %d\n",
                    vm->vmid, virq->vno);
            // 记录分配 LR 失败的 virq
            vs->last_fail_virq = bit;
            break;
        }

        /*
         * indicate that FIQ has been inject.
         */
        // 如果存在标志就说明该 FIQ 已经被注入了？？？？？？？？
        if (virq->flags & VIRQS_FIQ)
            flags |= FIQ_HAS_INJECT;
        flags++;
        virq->id = id;   // 设置刚分配的 lr_id
        set_bit(id, vs->lrs_bitmap);
        
        // 芯片级别 send_virq，核心是写 gich_lr 寄存器
        virqchip_send_virq(vcpu, virq);
        // 状态转移
        virq->state = VIRQ_STATE_PENDING;

        /*
         * mark this virq as pending state and add it
         * to the active bitmap.
         */
        // 设置为 active
        set_bit(bit, vs->active_bitmap);
        vs->active_virq++;

        /*
         * remove this virq from pending bitmap.
         */
        // pending_nr --
        atomic_dec(&vs->pending_virq);
        // 清除在 pending map 中的比特位
        clear_bit(bit, vs->pending_bitmap);
    }

    // old ！= 0 表示上次想要 send virq 时，但是没有空闲的 lr 寄存器了，且发送失败的 virq 号记录到了 bit
    // vs->last_fail_virq == 0 表示这次很可能有空闲的 lr 寄存器
    // 所以调整 size 为上次失败的 virq 号，让上面的循环能够触及该失败的 virq 号，且为其分配 lr 寄存器
    if ((old != 0) && (vs->last_fail_virq == 0)) {
        bit = 0;
        size = old;
        old = 0;
        goto repeat;
    }

    return flags;
}

该函数有点长，但同样的略去一些“无关紧要”的代码，主要逻辑就是遍历 pending 位图，为每一个 pending 状态的 virq 分配一个 LR 寄存器，然后将该 virq 的信息记录到 LR 寄存器，该 virq 的状态从 pending 变为 active。在分配 LR 寄存器的时候可能因为没有空闲的 LR 导致分配失败，处理方式是记录下来下次 enter guest 的时候处理。

// 退出 guest
int vgic_irq_exit_from_guest(struct vcpu *vcpu, void *data)
{
    struct virq_struct *vs = vcpu->virq_struct;
    struct virq_desc *virq;
    int bit;

    // 遍历该 vcpu 所有的 active_bitmap，这也就是说，可能出现多个 active interrupt
    for_each_set_bit(bit, vs->active_bitmap, vm_irq_count(vcpu->vm)) {
        // 获取对应的 virq_desc
        virq = get_virq_desc(vcpu, bit);
        if (virq == NULL) {
            pr_err("bad active virq %d\n", virq);
            clear_bit(bit, vs->active_bitmap);
            continue;
        }

        /*
         * the virq has been handled by the VCPU, if
         * the virq is not pending again, delete it
         * otherwise add the virq to the pending list
         * again
         */
        // 获取状态
        virq->state = virqchip_get_virq_state(vcpu, virq);
        // 如果该 virq 已经是 inactive，说明已处理完成
        // 重置 virq 对应的 LR 为空闲状态
        if (virq->state == VIRQ_STATE_INACTIVE) {
            virqchip_update_virq(vcpu, virq, VIRQ_ACTION_CLEAR);
            clear_bit(virq->id, vs->lrs_bitmap);
            virq->id = VIRQ_INVALID_ID;
            vs->active_virq--;
            clear_bit(bit, vs->active_bitmap);
        }
    }

    return 0;
}

对应的，当虚机退出 guest 会执行上述函数检查中断处理的情况，具体的会遍历 active 位图，对每一个 active virq，获取其对应的 LR.state，查看其状态，如果是 inactive，表明该 virq 已经处理完成，那么重置 LR 为空闲状态

总结xxxxxxxxxxxxxxxxxxx

Exception

前面讲述了虚拟中断，这里讲述虚机异常，也就是在 EL0、EL1 状态下发生的异常处理流程。Exception 的处理流程前文 minos 4.2 中断虚拟化——异常处理流程 讲述过，流程没有变，只是对于虚拟化多了几种异常，定义如下：

/* type defination is at armv8-spec 1906 */
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_WFx, EC_TYPE_BOTH, wfi_wfe_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_UNKNOWN, EC_TYPE_BOTH, unknown_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP15_32, EC_TYPE_BOTH, mcr_mrc_cp15_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP15_64, EC_TYPE_AARCH32, mcrr_mrrc_cp15_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP14_MR, EC_TYPE_AARCH32, mcr_mrc_cp14_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP14_LS, EC_TYPE_AARCH32, ldc_stc_cp14_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_FP_ASIMD, EC_TYPE_BOTH, access_simd_reg_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP10_ID, EC_TYPE_AARCH32, mcr_mrc_cp10_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_CP14_64, EC_TYPE_AARCH32, mrrc_cp14_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_ILL, EC_TYPE_BOTH, illegal_exe_state_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_SYS64, EC_TYPE_AARCH64, access_system_reg_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_IABT_LOW, EC_TYPE_BOTH, insabort_tfl_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_PC_ALIGN, EC_TYPE_BOTH, misaligned_pc_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_DABT_LOW, EC_TYPE_BOTH, dataabort_tfl_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_SP_ALIGN, EC_TYPE_BOTH, stack_misalign_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_FP_EXC32, EC_TYPE_AARCH32, floating_aarch32_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_FP_EXC64, EC_TYPE_AARCH64, floating_aarch64_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_SERROR, EC_TYPE_BOTH, serror_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_HVC32, EC_TYPE_AARCH32, aarch64_hypercall_handler, 1, 0);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_HVC64, EC_TYPE_AARCH64, aarch64_hypercall_handler, 1, 0);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_SMC32, EC_TYPE_AARCH32, aarch64_smccall_handler, 1, 4);
DEFINE_SYNC_DESC(guest_ESR_ELx_EC_SMC64, EC_TYPE_AARCH64, aarch64_smccall_handler, 1, 4);

static struct sync_desc *guest_sync_descs[] = {
    [0 ... ESR_ELx_EC_MAX]  = &sync_desc_guest_ESR_ELx_EC_UNKNOWN,
    [ESR_ELx_EC_WFx]    = &sync_desc_guest_ESR_ELx_EC_WFx,
    [ESR_ELx_EC_CP15_32]    = &sync_desc_guest_ESR_ELx_EC_CP15_32,
    [ESR_ELx_EC_CP15_64]    = &sync_desc_guest_ESR_ELx_EC_CP15_64,
    [ESR_ELx_EC_CP14_MR]    = &sync_desc_guest_ESR_ELx_EC_CP14_MR,
    [ESR_ELx_EC_CP14_LS]    = &sync_desc_guest_ESR_ELx_EC_CP14_LS,
    [ESR_ELx_EC_FP_ASIMD]   = &sync_desc_guest_ESR_ELx_EC_FP_ASIMD,
    [ESR_ELx_EC_CP10_ID]    = &sync_desc_guest_ESR_ELx_EC_CP10_ID,
    [ESR_ELx_EC_CP14_64]    = &sync_desc_guest_ESR_ELx_EC_CP14_64,
    [ESR_ELx_EC_ILL]    = &sync_desc_guest_ESR_ELx_EC_ILL,
    [ESR_ELx_EC_SYS64]  = &sync_desc_guest_ESR_ELx_EC_SYS64,
    [ESR_ELx_EC_IABT_LOW]   = &sync_desc_guest_ESR_ELx_EC_IABT_LOW,
    [ESR_ELx_EC_PC_ALIGN]   = &sync_desc_guest_ESR_ELx_EC_PC_ALIGN,
    [ESR_ELx_EC_DABT_LOW]   = &sync_desc_guest_ESR_ELx_EC_DABT_LOW,
    [ESR_ELx_EC_SP_ALIGN]   = &sync_desc_guest_ESR_ELx_EC_SP_ALIGN,
    [ESR_ELx_EC_FP_EXC32]   = &sync_desc_guest_ESR_ELx_EC_FP_EXC32,
    [ESR_ELx_EC_FP_EXC64]   = &sync_desc_guest_ESR_ELx_EC_FP_EXC64,
    [ESR_ELx_EC_SERROR] = &sync_desc_guest_ESR_ELx_EC_SERROR,
    [ESR_ELx_EC_HVC32]  = &sync_desc_guest_ESR_ELx_EC_HVC32,
    [ESR_ELx_EC_HVC64]  = &sync_desc_guest_ESR_ELx_EC_HVC64,
    [ESR_ELx_EC_SMC32]  = &sync_desc_guest_ESR_ELx_EC_SMC32,
    [ESR_ELx_EC_SMC64]  = &sync_desc_guest_ESR_ELx_EC_SMC64,
};

这个就不一一解释了，主要来看几个比较重要的异常，看看它们是如何处理的，最后结合前面讲述的串一下总体流程

系统调用

为什么分特权等级，很重要的一个原因就是为了安全，底层总是对上层保持不信任的态度。底层的一些核心功能不能直接交由上层来执行。上层只能发出请求，然后底层调用相关 handler 来帮忙处理，将结果返回给上层。

ARM 有 4 种特权等级，因此有了 3 种系统调用：SVC(Supervisor Call)、HVC(Hypervisor Call) 、SMC(Secure Monitor Call) 。通过上图，以及从名字上来看，SVC 就是请求 EL1 的服务，只能 EL0 调用；HVC 请求 EL2，之恶能 EL1 调用；SMC 请求 EL3，只能 EL1 和 EL2 调用。一般情况下是这样，但 ARM 比较灵活，EL2 也可以使用 SVC 指令，但是并不是请求 EL1 的服务，而是请求 EL2 它自己的服务

struct svc_desc {
    char *name;   // 服务名字
    uint16_t type_start;  // 服务号
    uint16_t type_end;    // 同服务号，目前 start、end 都只是表示服务号
    svc_handler_t handler; 
};


// 通过该宏定义一个 hvc 调用
#define DEFINE_HVC_HANDLER(n, start, end, h)    \
    static struct svc_desc __hvc_##h __used \
    __section(".__hvc_handler") = { \
        .name = n,  \
        .type_start = start, \
        .type_end = end, \
        .handler = h, \
    }

// 两个例子
DEFINE_HVC_HANDLER("vm_hvc_handler", HVC_TYPE_VM0,
        HVC_TYPE_VM0, vm_hvc_handler);

DEFINE_HVC_HANDLER("misc_hvc_handler", HVC_TYPE_MISC,
        HVC_TYPE_MISC, misc_hvc_handler);

每个系统调用都有一个 svc_desc 描述符，记录了服务名字、服务号、handler。DEFINE_HVC_HANDLER 该宏定义一个静态全局的 svc_desc，并将它放在 __hvc_handler节里面。

在 boot 阶段解析 __hvc_handler 节来动态的加载服务例程：

// minos.ld.S
    __hvc_handler_start = .;
    .__hvc_handler : {
        *(.__hvc_handler)
    }
    __hvc_handler_end = .;

    . = ALIGN(8);

//.............................................
// svc_service.c
// 定义一系列的 svc_desc 指针，boot 阶段初始化
static struct svc_desc *smc_descs[SVC_STYPE_MAX];
static struct svc_desc *hvc_descs[SVC_STYPE_MAX];

static int __init_text svc_service_init(void)
{
    pr_notice("parsing SMC/HVC handler\n");

    parse_svc_desc((unsigned long)&__hvc_handler_start,
               (unsigned long)&__hvc_handler_end, hvc_descs);
    parse_svc_desc((unsigned long)&__smc_handler_start,
               (unsigned long)&__smc_handler_end, smc_descs);

    return 0;
}

// 解析 __hvc_handler/__smc_handler 节，注册服务例程到对应的 table
static void parse_svc_desc(unsigned long start, unsigned long end,
               struct svc_desc **table)
{
    struct svc_desc *desc;
    int32_t j;
    // 从 start 开始遍历每一个 svc_desc 描述符
    section_for_each_item_addr(start, end, desc) {
        BUG_ON((desc->type_start > desc->type_end) ||
               (desc->type_end >= SVC_STYPE_MAX));
        // 注册该 svc_desc 到 hvc_descs/smc_descs table
        for (j = desc->type_start; j <= desc->type_end; j++) {
            if (table[j])
                pr_warn("overwrite SVC_DESC:%d %s\n", j,
                    desc->name);
            table[j] = desc;
        }
    }
}

上述流程简述：

1. 首先定义了一系列的 svc_desc 描述符，编译期间将它们存放在 __hvc_handler 节里面
2. boot 阶段，解析 __hvc_handler 节，遍历每一个 svc_desc，将它们的信息记录到 hvc_descs table 里面

这样做的好处我能想到的就是动态加载，如果不需要某个服务例程，可以直接在编译期间就剔除，不将它们编译到镜像，但其实像 sync_descn 这种定义感觉也行呢。

__smc_handler 和 smc_descs 类似，它们的定义和初始化流程不再赘述。但有朋友可能疑惑，smc，secure monitor call，其服务例程应该定义在 EL3，minos 不是运行在 EL2 的 hypervisor 吗，为什么 EL2 也有 smc handler？这是因为 EL2 有能力 trap smc 指令，当 HCR_EL2.TSC = 1 时，smc 指令并不会 trap 到 EL3，而是 trap 到 EL2，由 EL2 处理。

了解了 svc_desc 定义之后，我们来看其处理流程：

// __sync_exception_from_lower_el -> sync_exception_from_lower_el

void sync_exception_from_lower_el(gp_regs *regs)
{
#ifdef CONFIG_VIRT
    extern void handle_vcpu_sync_exception(gp_regs *regs);

    /*
     * check whether this task is a vcpu task or a normal
     * userspace task.
     * 1 - TGE bit means a normal task
     * 2 - current->flags
     */
    // HCR_EL2.TGE = 1 表示所有 trap 到 EL1 的异常都会 trap 到 EL2 处理
    if ((current->flags & TASK_FLAGS_VCPU) && !(read_hcr_el2() & HCR_EL2_TGE))
        handle_vcpu_sync_exception(regs);
    else
#endif
        handle_sync_exception(regs);
}

首先从 vector.S 中的 __sync_exception_from_lower_el 开始，表示从低特权等级来的一个异常。只有当前 cpu 上运行的是 vcpu 线程，cpu 上运行的是 guest os，一个异常才有可能来自低特权等级。HCR_EL2.TGE = 1 表示所有 trap 到 EL1 的异常都会 trap 到 EL2 处理，比如说用户态(EL0) 执行 svc 请求内核 (EL1) 的服务也会被 trap 到 EL2 处理，我们不应该是这种情况，trap 到 EL1 就直接让 EL1 自己处理，所以应该设置 HCR_EL2.TGE = 0

void handle_vcpu_sync_exception(gp_regs *regs)
{
    int cpuid = smp_processor_id();
    uint32_t esr_value;
    int ec_type;
    struct sync_desc *ec;
    struct vcpu *vcpu = get_current_vcpu();

    if ((!vcpu) || (vcpu->task->affinity != cpuid))
        panic("this vcpu is not belong to the pcpu");

    // 读取 ESR.ec 值，可以当作 exception number
    esr_value = read_esr_el2();
    ec_type = (esr_value & ESR_ELx_EC_MASK) >> ESR_ELx_EC_SHIFT;

    if (ec_type >= ESR_ELx_EC_MAX) {
        pr_err("unknown sync exception type from guest %d\n", ec_type);
        goto out;
    }

    pr_debug("sync from lower EL, handle 0x%x\n", ec_type);
    // 获取该 exception 对应的描述符
    ec = guest_sync_descs[ec_type];
    if (ec->irq_safe)
        local_irq_enable();
    // 返回地址修正
    regs->pc += ec->ret_addr_adjust;
    // 处理该异常
    ec->handler(regs, ec_type, esr_value);
out:
    local_irq_disable();
}

该函数从 ESR.ec 里面取出异常号，然后执行相应的 handler，对于 hvc handler 为 aarch64_hypercall_handler

int aarch64_hypercall_handler(gp_regs *reg, int ec, uint32_t esr_value)
{
    struct vcpu *vcpu = get_current_vcpu();
    struct arm_virt_data *arm_data = vcpu->vm->arch_data;

    if (arm_data->hvc_handler)
        return arm_data->hvc_handler(vcpu, reg, read_esr_el2());
    else
        return __arm_svc_handler(reg, 0);
}

static int __arm_svc_handler(gp_regs *reg, int smc)
{
    uint32_t id;
    unsigned long args[6];

    // 第一个参数是服务号
    id = reg->x0;
    args[0] = reg->x1;
    args[1] = reg->x2;
    args[2] = reg->x3;
    args[3] = reg->x4;
    args[4] = reg->x5;
    args[5] = reg->x6;

    if (!(id & SVC_CTYPE_MASK))
        local_irq_enable();
    // 执行服务号对应的 handler
    return do_svc_handler(reg, id, args, smc);
}

// 系统调用 handler
int do_svc_handler(gp_regs *regs, uint32_t svc_id, uint64_t *args, int smc)
{
    uint16_t type;
    struct svc_desc **table;
    struct svc_desc *desc;

    // 如果是 smc 调用，调用 smc handler，反之调用 hvc handler
    if (smc)
        table = smc_descs;
    else
        table = hvc_descs;

    // 获取服务号
    // bit[29:24]   : service call ranges SVC_STYPE_XX
    type = (svc_id & SVC_STYPE_MASK) >> 24;

    if (unlikely(type > SVC_STYPE_MAX)) {
        pr_err("Unsupported SVC type %d\n", type);
        goto invalid;
    }
    // 获取该服务号对应的 svc_desc
    desc = table[type];
    if (unlikely(!desc))
        goto invalid;

    pr_debug("doing SVC Call %s:0x%x\n", desc->name, svc_id);
    // 执行 handler
    return desc->handler(regs, svc_id, args);

invalid:
    SVC_RET1(regs, -EINVAL);
}

流程很简单，看注释应该能明白，这里不赘述，最后我们以 guest OS 调用 hvc 为例梳理一下系统调用的流程

hvc #xx
    __sync_exception_from_lower_el
        sync_exception_from_lower_el
            handle_vcpu_sync_exception
                esr_value = read_esr_el2();  //异常原因
                ec_type = (esr_value & ESR_ELx_EC_MASK) >> ESR_ELx_EC_SHIFT; //异常号
                ec = guest_sync_descs[ec_type];   //异常描述符
                regs->pc += ec->ret_addr_adjust;  //返回地址修正
                ec->handler(regs, ec_type, esr_value);  //异常处理
                    __arm_svc_handler
                        id = reg->x0;   //服务号
                        do_svc_handler  
                            type = (svc_id & SVC_STYPE_MASK) >> 24;  //具体的服务号
                            desc = table[type];   //服务描述符
                            desc->handler(regs, svc_id, args);  //执行该服务例程

minos 中还有一个特殊的系统调用，在调度 sys_sched() 中，底层实际上就是一个 svc #0 系统调用，这就是前面所说的例外，并不是说只有 EL0 才能使用 svc 来请求 EL1 的服务。EL2 也能使用 svc 指令，来调用 EL2 自己的一个服务例程。有了异常、系统调用的了解，我们再来回顾一下之前提到的调度：

svc #0    // EL2 下使用 svc 指令
    __sync_exception_from_current_el  // 来自当前特权级的异常
        mrs    x1, ESR_EL2         // 获取异常原因
        ubfx   x2, x1, #ESR_ELx_EC_SHIFT, #ESR_ELx_EC_WIDTH 
        cmp x2, #ESR_ELx_EC_SVC64      // 如果 x2 == ESR_ELx_EC_SVC64 表示一个 svc 指令
        b.eq   __sync_current_out     // 跳去 __sync_current_out
            exception_return
                exception_return_handler
                    __exception_return_handler
                        pick_next_task   // 调度策略挑选下一个 task
                        switch_to_task   // 切换 task

因为 minos 目前在 EL2 中使用 svc 只有这么一种情况，所以直接在 vector.S 里面做了判断，并没有为其定义 svc_desc 描述符等，直接判断如果是 svc 指令那么就异常返回，在异常返回中执行调度操作。

首发公号：Rand_cs