ARM64 KVM : KVM_SET_ONE_REG KVM_GET_ONE_REG

KVM_SET_ONE_REG 从名字上看就是设置一个寄存器的值。

KVM_GET_ONE_REG 从名字上看就是取一个寄存器值。 我们一起看看吧。

user space 和 kernel  space 通用struct

struct kvm_one_reg {

    __u64 id;
    __u64 addr;
};

User space

#define AARCH64_CORE_REG(x) (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(x))

  reg.id = AARCH64_CORE_REG(regs.pc);
  reg.addr = (__u64)&value;
  ret = ioctl(vcpu_fd, KVM_SET_ONE_REG, &reg);
  assert(ret >= 0);

./asm/kvm.h:#define KVM_REG_ARM_CORE_REG(name)    (offsetof(struct kvm_regs, name) / sizeof(__u32))
就是计算一个成员在struct 中的位置

Kernel space

long kvm_arch_vcpu_ioctl(struct file *filp,
             unsigned int ioctl, unsigned long arg)
{
...
    case KVM_SET_ONE_REG:
    case KVM_GET_ONE_REG: {
        struct kvm_one_reg reg;

        r = -ENOEXEC;
        if (unlikely(!kvm_vcpu_initialized(vcpu)))
            break;

        r = -EFAULT;
        if (copy_from_user(&reg, argp, sizeof(reg)))
            break;

        if (ioctl == KVM_SET_ONE_REG)
            r = kvm_arm_set_reg(vcpu, &reg);
        else
            r = kvm_arm_get_reg(vcpu, &reg);
        break;
    }

int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
    /* We currently use nothing arch-specific in upper 32 bits */
    if ((reg->id & ~KVM_REG_SIZE_MASK) >> 32 != KVM_REG_ARM64 >> 32)
        return -EINVAL;

    switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
    case KVM_REG_ARM_CORE:    return set_core_reg(vcpu, reg);
    case KVM_REG_ARM_FW:    return kvm_arm_set_fw_reg(vcpu, reg);
    case KVM_REG_ARM64_SVE:    return set_sve_reg(vcpu, reg);
    }

    if (is_timer_reg(reg->id))
        return set_timer_reg(vcpu, reg);

    return kvm_arm_sys_reg_set_reg(vcpu, reg);
}

static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
    __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
    int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);
    __uint128_t tmp;
    void *valp = &tmp, *addr;
    u64 off;
    int err = 0;

    /* Our ID is an index into the kvm_regs struct. */
    off = core_reg_offset_from_id(reg->id);
    if (off >= nr_regs ||
        (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
        return -ENOENT;

    addr = core_reg_addr(vcpu, reg);
    if (!addr)
        return -EINVAL;

    if (KVM_REG_SIZE(reg->id) > sizeof(tmp))
        return -EINVAL;

    if (copy_from_user(valp, uaddr, KVM_REG_SIZE(reg->id))) {
        err = -EFAULT;
        goto out;
    }
   ...

        //addr 寄存器在 vcpu中的地址 
        //valp user space 数值的地址
        //user space 赋值
        //  reg.id = AARCH64_CORE_REG(regs.pc);
         //  reg.addr = (__u64)&value;  //& 地址

       //这样就把user space 的值  memcpy到vcpu对应的寄存器中

    memcpy(addr, valp, KVM_REG_SIZE(reg->id));

//取 寄存器 在vcpu 中的地址
static void *core_reg_addr(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
    u64 off = core_reg_offset_from_id(reg->id);
    int size = core_reg_size_from_offset(vcpu, off);

    if (size < 0)
        return NULL;

    if (KVM_REG_SIZE(reg->id) != size)
        return NULL;

    switch (off) {
    case KVM_REG_ARM_CORE_REG(regs.regs[0]) ...
         KVM_REG_ARM_CORE_REG(regs.regs[30]):
        off -= KVM_REG_ARM_CORE_REG(regs.regs[0]);
        off /= 2;
        return &vcpu->arch.ctxt.regs.regs[off];

    case KVM_REG_ARM_CORE_REG(regs.sp):
        return &vcpu->arch.ctxt.regs.sp;

    case KVM_REG_ARM_CORE_REG(regs.pc):
        return &vcpu->arch.ctxt.regs.pc;

    case KVM_REG_ARM_CORE_REG(regs.pstate):
        return &vcpu->arch.ctxt.regs.pstate;

    case KVM_REG_ARM_CORE_REG(sp_el1):
        return __ctxt_sys_reg(&vcpu->arch.ctxt, SP_EL1);

    case KVM_REG_ARM_CORE_REG(elr_el1):
        return __ctxt_sys_reg(&vcpu->arch.ctxt, ELR_EL1);

    case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_EL1]):
        return __ctxt_sys_reg(&vcpu->arch.ctxt, SPSR_EL1);

    case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_ABT]):
        return &vcpu->arch.ctxt.spsr_abt;

    case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_UND]):
        return &vcpu->arch.ctxt.spsr_und;

    case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_IRQ]):
        return &vcpu->arch.ctxt.spsr_irq;

    case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_FIQ]):
        return &vcpu->arch.ctxt.spsr_fiq;

    case KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]) ...
         KVM_REG_ARM_CORE_REG(fp_regs.vregs[31]):
        off -= KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]);
        off /= 4;
        return &vcpu->arch.ctxt.fp_regs.vregs[off];

    case KVM_REG_ARM_CORE_REG(fp_regs.fpsr):
        return &vcpu->arch.ctxt.fp_regs.fpsr;

    case KVM_REG_ARM_CORE_REG(fp_regs.fpcr):
        return &vcpu->arch.ctxt.fp_regs.fpcr;

    default:
        return NULL;
    }
}

//get 的逻辑正好相反
static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
    /*
     * Because the kvm_regs structure is a mix of 32, 64 and
     * 128bit fields, we index it as if it was a 32bit
     * array. Hence below, nr_regs is the number of entries, and
     * off the index in the "array".
     */
    __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
    int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);
    void *addr;
    u32 off;

    /* Our ID is an index into the kvm_regs struct. */
    off = core_reg_offset_from_id(reg->id);
    if (off >= nr_regs ||
        (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
        return -ENOENT;

    addr = core_reg_addr(vcpu, reg);
    if (!addr)
        return -EINVAL;

        //把addr, 就是要得到寄存器的地址，其实就是vcpu 结构体的一个成员， copy 到uaddr , 这个是user space 地址
    if (copy_to_user(uaddr, addr, KVM_REG_SIZE(reg->id)))
        return -EFAULT;

    return 0;
}