lkml.org 
[lkml]   [2022]   [Jun]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    Subject[PATCH v2 114/144] KVM: selftests: Convert hypercalls test away from vm_create_default()
    From
    Use a combination of vm_create(), vm_create_with_vcpus(), and
    vm_vcpu_add() to convert vgic_init from vm_create_default_with_vcpus(),
    and away from referncing vCPUs by ID.

    Thus continues the march toward total annihilation of "default" helpers.

    Signed-off-by: Sean Christopherson <seanjc@google.com>
    ---
    .../selftests/kvm/aarch64/hypercalls.c | 51 +++++++++----------
    1 file changed, 24 insertions(+), 27 deletions(-)

    diff --git a/tools/testing/selftests/kvm/aarch64/hypercalls.c b/tools/testing/selftests/kvm/aarch64/hypercalls.c
    index 44ca840e8219..fefa39dc9bc8 100644
    --- a/tools/testing/selftests/kvm/aarch64/hypercalls.c
    +++ b/tools/testing/selftests/kvm/aarch64/hypercalls.c
    @@ -150,23 +150,19 @@ struct st_time {
    #define STEAL_TIME_SIZE ((sizeof(struct st_time) + 63) & ~63)
    #define ST_GPA_BASE (1 << 30)

    -static void steal_time_init(struct kvm_vm *vm)
    +static void steal_time_init(struct kvm_vcpu *vcpu)
    {
    uint64_t st_ipa = (ulong)ST_GPA_BASE;
    unsigned int gpages;
    - struct kvm_device_attr dev = {
    - .group = KVM_ARM_VCPU_PVTIME_CTRL,
    - .attr = KVM_ARM_VCPU_PVTIME_IPA,
    - .addr = (uint64_t)&st_ipa,
    - };

    gpages = vm_calc_num_guest_pages(VM_MODE_DEFAULT, STEAL_TIME_SIZE);
    - vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0);
    + vm_userspace_mem_region_add(vcpu->vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0);

    - vcpu_ioctl(vm, 0, KVM_SET_DEVICE_ATTR, &dev);
    + vcpu_device_attr_set(vcpu->vm, vcpu->id, KVM_ARM_VCPU_PVTIME_CTRL,
    + KVM_ARM_VCPU_PVTIME_IPA, &st_ipa);
    }

    -static void test_fw_regs_before_vm_start(struct kvm_vm *vm)
    +static void test_fw_regs_before_vm_start(struct kvm_vcpu *vcpu)
    {
    uint64_t val;
    unsigned int i;
    @@ -176,18 +172,18 @@ static void test_fw_regs_before_vm_start(struct kvm_vm *vm)
    const struct kvm_fw_reg_info *reg_info = &fw_reg_info[i];

    /* First 'read' should be an upper limit of the features supported */
    - vcpu_get_reg(vm, 0, reg_info->reg, &val);
    + vcpu_get_reg(vcpu->vm, vcpu->id, reg_info->reg, &val);
    TEST_ASSERT(val == FW_REG_ULIMIT_VAL(reg_info->max_feat_bit),
    "Expected all the features to be set for reg: 0x%lx; expected: 0x%lx; read: 0x%lx\n",
    reg_info->reg, FW_REG_ULIMIT_VAL(reg_info->max_feat_bit), val);

    /* Test a 'write' by disabling all the features of the register map */
    - ret = __vcpu_set_reg(vm, 0, reg_info->reg, 0);
    + ret = __vcpu_set_reg(vcpu->vm, vcpu->id, reg_info->reg, 0);
    TEST_ASSERT(ret == 0,
    "Failed to clear all the features of reg: 0x%lx; ret: %d\n",
    reg_info->reg, errno);

    - vcpu_get_reg(vm, 0, reg_info->reg, &val);
    + vcpu_get_reg(vcpu->vm, vcpu->id, reg_info->reg, &val);
    TEST_ASSERT(val == 0,
    "Expected all the features to be cleared for reg: 0x%lx\n", reg_info->reg);

    @@ -196,7 +192,7 @@ static void test_fw_regs_before_vm_start(struct kvm_vm *vm)
    * Avoid this check if all the bits are occupied.
    */
    if (reg_info->max_feat_bit < 63) {
    - ret = __vcpu_set_reg(vm, 0, reg_info->reg, BIT(reg_info->max_feat_bit + 1));
    + ret = __vcpu_set_reg(vcpu->vm, vcpu->id, reg_info->reg, BIT(reg_info->max_feat_bit + 1));
    TEST_ASSERT(ret != 0 && errno == EINVAL,
    "Unexpected behavior or return value (%d) while setting an unsupported feature for reg: 0x%lx\n",
    errno, reg_info->reg);
    @@ -204,7 +200,7 @@ static void test_fw_regs_before_vm_start(struct kvm_vm *vm)
    }
    }

    -static void test_fw_regs_after_vm_start(struct kvm_vm *vm)
    +static void test_fw_regs_after_vm_start(struct kvm_vcpu *vcpu)
    {
    uint64_t val;
    unsigned int i;
    @@ -217,7 +213,7 @@ static void test_fw_regs_after_vm_start(struct kvm_vm *vm)
    * Before starting the VM, the test clears all the bits.
    * Check if that's still the case.
    */
    - vcpu_get_reg(vm, 0, reg_info->reg, &val);
    + vcpu_get_reg(vcpu->vm, vcpu->id, reg_info->reg, &val);
    TEST_ASSERT(val == 0,
    "Expected all the features to be cleared for reg: 0x%lx\n",
    reg_info->reg);
    @@ -227,26 +223,26 @@ static void test_fw_regs_after_vm_start(struct kvm_vm *vm)
    * the registers and should return EBUSY. Set the registers and check for
    * the expected errno.
    */
    - ret = __vcpu_set_reg(vm, 0, reg_info->reg, FW_REG_ULIMIT_VAL(reg_info->max_feat_bit));
    + ret = __vcpu_set_reg(vcpu->vm, vcpu->id, reg_info->reg, FW_REG_ULIMIT_VAL(reg_info->max_feat_bit));
    TEST_ASSERT(ret != 0 && errno == EBUSY,
    "Unexpected behavior or return value (%d) while setting a feature while VM is running for reg: 0x%lx\n",
    errno, reg_info->reg);
    }
    }

    -static struct kvm_vm *test_vm_create(void)
    +static struct kvm_vm *test_vm_create(struct kvm_vcpu **vcpu)
    {
    struct kvm_vm *vm;

    - vm = vm_create_default(0, 0, guest_code);
    + vm = vm_create_with_one_vcpu(vcpu, guest_code);

    ucall_init(vm, NULL);
    - steal_time_init(vm);
    + steal_time_init(*vcpu);

    return vm;
    }

    -static void test_guest_stage(struct kvm_vm **vm)
    +static void test_guest_stage(struct kvm_vm **vm, struct kvm_vcpu **vcpu)
    {
    int prev_stage = stage;

    @@ -258,12 +254,12 @@ static void test_guest_stage(struct kvm_vm **vm)

    switch (prev_stage) {
    case TEST_STAGE_REG_IFACE:
    - test_fw_regs_after_vm_start(*vm);
    + test_fw_regs_after_vm_start(*vcpu);
    break;
    case TEST_STAGE_HVC_IFACE_FEAT_DISABLED:
    /* Start a new VM so that all the features are now enabled by default */
    kvm_vm_free(*vm);
    - *vm = test_vm_create();
    + *vm = test_vm_create(vcpu);
    break;
    case TEST_STAGE_HVC_IFACE_FEAT_ENABLED:
    case TEST_STAGE_HVC_IFACE_FALSE_INFO:
    @@ -275,20 +271,21 @@ static void test_guest_stage(struct kvm_vm **vm)

    static void test_run(void)
    {
    + struct kvm_vcpu *vcpu;
    struct kvm_vm *vm;
    struct ucall uc;
    bool guest_done = false;

    - vm = test_vm_create();
    + vm = test_vm_create(&vcpu);

    - test_fw_regs_before_vm_start(vm);
    + test_fw_regs_before_vm_start(vcpu);

    while (!guest_done) {
    - vcpu_run(vm, 0);
    + vcpu_run(vcpu->vm, vcpu->id);

    - switch (get_ucall(vm, 0, &uc)) {
    + switch (get_ucall(vcpu->vm, vcpu->id, &uc)) {
    case UCALL_SYNC:
    - test_guest_stage(&vm);
    + test_guest_stage(&vm, &vcpu);
    break;
    case UCALL_DONE:
    guest_done = true;
    --
    2.36.1.255.ge46751e96f-goog
    \
     
     \ /
      Last update: 2022-06-03 03:02    [W:3.134 / U:0.744 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site