ARM64 KVM : KVM_SET_ONE_REG KVM_GET_ONE_REG

最新推荐文章于 2024-09-14 20:52:11 发布

原创最新推荐文章于 2024-09-14 20:52:11 发布 · 310 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#linux

博客详细解析了KVM（Kernel-based Virtual Machine）在ARM64架构上如何通过KVM_SET_ONE_REG和KVM_GET_ONE_REG内核接口来设置和获取虚拟CPU（VCPU）的寄存器值。用户空间通过ioctl调用，传递struct kvm_one_reg结构，包含寄存器ID和地址，从而实现与内核空间的数据交互。内核空间接收到请求后，通过kvm_arm_set_reg和kvm_arm_get_reg函数进行具体操作，涉及核心寄存器、浮点寄存器等，并通过memcpy进行内存拷贝完成寄存器值的设置和读取。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;