[PATCH for-11.2 7/9] target/kvm: Pass an Error handle to kvm_arch_init_vcpu

[Eric Auger <eric.auger@redhat.com>]

The 2 callers of kvm_arch_init_vcpu(), namely kvm_rebind_vcpus()
and kvm_init_vcpu() are passed an Error handle. So it is a pity
not using it in kvm_arch_init_vcpu(). Also, in the future, the
error handle could be passed to other functions called inside.

Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
 include/system/kvm.h       |  2 +-
 accel/kvm/kvm-all.c        | 15 +++++++--------
 target/arm/kvm.c           | 26 +++++++++++++-------------
 target/i386/kvm/kvm.c      | 22 ++++++++++++----------
 target/loongarch/kvm/kvm.c | 27 +++++++++------------------
 target/ppc/kvm.c           | 10 +++++++---
 target/riscv/kvm/kvm-cpu.c |  6 +++++-
 target/s390x/kvm/kvm.c     |  2 +-
 8 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/include/system/kvm.h b/include/system/kvm.h
index d29624034c..26d55cc699 100644
--- a/include/system/kvm.h
+++ b/include/system/kvm.h
@@ -358,7 +358,7 @@ int kvm_arch_get_default_type(MachineState *ms);
 int kvm_arch_init(MachineState *ms, KVMState *s);
 
 int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp);
-int kvm_arch_init_vcpu(CPUState *cpu);
+int kvm_arch_init_vcpu(CPUState *cpu, Error **errp);
 int kvm_arch_destroy_vcpu(CPUState *cpu);
 
 #ifdef TARGET_KVM_HAVE_RESET_PARKED_VCPU
diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c
index db8fba53f3..ddc82f9775 100644
--- a/accel/kvm/kvm-all.c
+++ b/accel/kvm/kvm-all.c
@@ -504,11 +504,11 @@ static int kvm_rebind_vcpus(Error **errp)
             }
         }
 
-        ret = kvm_arch_init_vcpu(cpu);
+        ret = kvm_arch_init_vcpu(cpu, errp);
         if (ret < 0) {
-            error_setg_errno(errp, -ret,
-                             "kvm_init_vcpu: kvm_arch_init_vcpu failed (%lu)",
-                             vcpu_id);
+            error_prepend(errp,
+                          "kvm_init_vcpu: kvm_arch_init_vcpu failed (%lu)",
+                          vcpu_id);
         }
 
         close(cpu->kvm_vcpu_stats_fd);
@@ -751,11 +751,10 @@ int kvm_init_vcpu(CPUState *cpu, Error **errp)
         }
     }
 
-    ret = kvm_arch_init_vcpu(cpu);
+    ret = kvm_arch_init_vcpu(cpu, errp);
     if (ret < 0) {
-        error_setg_errno(errp, -ret,
-                         "kvm_init_vcpu: kvm_arch_init_vcpu failed (%lu)",
-                         kvm_arch_vcpu_id(cpu));
+        error_prepend(errp, "kvm_init_vcpu: kvm_arch_init_vcpu failed (%lu)",
+                      kvm_arch_vcpu_id(cpu));
     }
     cpu->kvm_vcpu_stats_fd = kvm_vcpu_ioctl(cpu, KVM_GET_STATS_FD, NULL);
 
diff --git a/target/arm/kvm.c b/target/arm/kvm.c
index d454346037..2d37c2bfb4 100644
--- a/target/arm/kvm.c
+++ b/target/arm/kvm.c
@@ -2015,17 +2015,16 @@ int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp)
     return 0;
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     int ret;
     uint64_t mpidr;
     ARMCPU *cpu = ARM_CPU(cs);
     CPUARMState *env = &cpu->env;
-    Error *local_err = NULL;
     uint64_t psciver;
 
     if (cpu->kvm_target == QEMU_KVM_ARM_TARGET_NONE) {
-        error_report("KVM is not supported for this guest CPU type");
+        error_setg(errp, "KVM is not supported for this guest CPU type");
         return -EINVAL;
     }
 
@@ -2071,16 +2070,19 @@ int kvm_arch_init_vcpu(CPUState *cs)
     /* Do KVM_ARM_VCPU_INIT ioctl */
     ret = kvm_arm_vcpu_init(cpu);
     if (ret) {
+        error_setg_errno(errp, -ret, "failed kvm_arm_vcpu_init");
         return ret;
     }
 
     if (cpu_isar_feature(aa64_sve, cpu)) {
         ret = kvm_arm_sve_set_vls(cpu);
         if (ret) {
+            error_setg_errno(errp, -ret, "failed kvm_arm_sve_set_vls");
             return ret;
         }
         ret = kvm_arm_vcpu_finalize(cpu, KVM_ARM_VCPU_SVE);
         if (ret) {
+            error_setg_errno(errp, -ret, "failed kvm_arm_vcpu_finalize");
             return ret;
         }
     }
@@ -2089,11 +2091,12 @@ int kvm_arch_init_vcpu(CPUState *cs)
         psciver = cpu->psci_version;
         ret = kvm_set_one_reg(cs, KVM_REG_ARM_PSCI_VERSION, &psciver);
         if (ret) {
-            error_report("KVM in this kernel does not support PSCI version %d.%d",
-                         (int) PSCI_VERSION_MAJOR(psciver),
-                         (int) PSCI_VERSION_MINOR(psciver));
-            error_printf("Consider setting the kvm-psci-version property on the "
-                         "migration source.\n");
+            error_setg_errno(errp, -ret,
+                             "KVM in this kernel does not support PSCI version %d.%d",
+                             (int) PSCI_VERSION_MAJOR(psciver),
+                             (int) PSCI_VERSION_MINOR(psciver));
+            error_append_hint(errp, "Consider setting the kvm-psci-version property "
+                              "on the migration source.\n");
             return ret;
         }
     }
@@ -2115,16 +2118,13 @@ int kvm_arch_init_vcpu(CPUState *cs)
      */
     ret = kvm_get_one_reg(cs, ARM64_SYS_REG(ARM_CPU_ID_MPIDR), &mpidr);
     if (ret) {
+        error_setg_errno(errp, -ret, "failed retrieving MPIDR value");
         return ret;
     }
     SET_IDREG(&cpu->isar, MPIDR, mpidr);
     cpu->mp_affinity = mpidr & ARM64_AFFINITY_MASK;
 
-    ret = kvm_arm_init_cpreg_list(cpu, &local_err);
-    if (ret < 0) {
-        error_report_err(local_err);
-    }
-    return ret;
+    return kvm_arm_init_cpreg_list(cpu, errp);
 }
 
 int kvm_arch_destroy_vcpu(CPUState *cs)
diff --git a/target/i386/kvm/kvm.c b/target/i386/kvm/kvm.c
index da922f72d7..474322b073 100644
--- a/target/i386/kvm/kvm.c
+++ b/target/i386/kvm/kvm.c
@@ -2218,7 +2218,7 @@ static void kvm_init_pmu_info(struct kvm_cpuid2 *cpuid, X86CPU *cpu)
     }
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     struct {
         struct kvm_cpuid2 cpuid;
@@ -2240,12 +2240,12 @@ int kvm_arch_init_vcpu(CPUState *cs)
     int kvm_base = KVM_CPUID_SIGNATURE;
     int max_nested_state_len;
     int r;
-    Error *local_err = NULL;
 
     if (current_machine->cgs) {
         r = x86_confidential_guest_check_features(
                 X86_CONFIDENTIAL_GUEST(current_machine->cgs), cs);
         if (r < 0) {
+            error_setg(errp, "failed x86_confidential_guest_check_features (%d)", r);
             return r;
         }
     }
@@ -2258,6 +2258,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
 
     r = kvm_arch_set_tsc_khz(cs);
     if (r < 0) {
+        error_setg(errp, "failed setting tsc_khz (%d)", r);
         return r;
     }
 
@@ -2285,14 +2286,14 @@ int kvm_arch_init_vcpu(CPUState *cs)
      * can still proceed and check/expand Hyper-V enlightenments here so legacy
      * behavior is preserved.
      */
-    if (!kvm_hyperv_expand_features(cpu, &local_err)) {
-        error_report_err(local_err);
+    if (!kvm_hyperv_expand_features(cpu, errp)) {
         return -ENOSYS;
     }
 
     if (hyperv_enabled(cpu)) {
         r = hyperv_init_vcpu(cpu);
         if (r) {
+            error_setg_errno(errp, -r, "failed hyperv_init_vcpu");
             return r;
         }
 
@@ -2371,6 +2372,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
 
         r = kvm_xen_init_vcpu(cs);
         if (r) {
+            error_setg_errno(errp, -r, "failed kvm_xen_init_vcpu");
             return r;
         }
 
@@ -2419,12 +2421,12 @@ int kvm_arch_init_vcpu(CPUState *cs)
 
         ret = kvm_get_mce_cap_supported(cs->kvm_state, &mcg_cap, &banks);
         if (ret < 0) {
-            fprintf(stderr, "kvm_get_mce_cap_supported: %s", strerror(-ret));
+            error_setg_errno(errp, -ret, "failed kvm_get_mce_cap_supported");
             return ret;
         }
 
         if (banks < (env->mcg_cap & MCG_CAP_BANKS_MASK)) {
-            error_report("kvm: Unsupported MCE bank count (QEMU = %d, KVM = %d)",
+            error_setg(errp, "kvm: Unsupported MCE bank count (QEMU = %d, KVM = %d)",
                          (int)(env->mcg_cap & MCG_CAP_BANKS_MASK), banks);
             return -ENOTSUP;
         }
@@ -2432,7 +2434,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
         unsupported_caps = env->mcg_cap & ~(mcg_cap | MCG_CAP_BANKS_MASK);
         if (unsupported_caps) {
             if (unsupported_caps & MCG_LMCE_P) {
-                error_report("kvm: LMCE not supported");
+                error_setg(errp, "kvm: LMCE not supported");
                 return -ENOTSUP;
             }
             warn_report("Unsupported MCG_CAP bits: 0x%" PRIx64,
@@ -2442,7 +2444,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
         env->mcg_cap &= mcg_cap | MCG_CAP_BANKS_MASK;
         ret = kvm_vcpu_ioctl(cs, KVM_X86_SETUP_MCE, &env->mcg_cap);
         if (ret < 0) {
-            fprintf(stderr, "KVM_X86_SETUP_MCE: %s", strerror(-ret));
+            error_setg_errno(errp, -ret, "failed KVM_X86_SETUP_MCE");
             return ret;
         }
     }
@@ -2470,9 +2472,8 @@ int kvm_arch_init_vcpu(CPUState *cs)
             error_setg(&invtsc_mig_blocker,
                        "State blocked by non-migratable CPU device"
                        " (invtsc flag)");
-            r = migrate_add_blocker(&invtsc_mig_blocker, &local_err);
+            r = migrate_add_blocker(&invtsc_mig_blocker, errp);
             if (r < 0) {
-                error_report_err(local_err);
                 return r;
             }
         }
@@ -2501,6 +2502,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
     cpuid_data.cpuid.padding = 0;
     r = kvm_vcpu_ioctl(cs, KVM_SET_CPUID2, &cpuid_data);
     if (r) {
+        error_setg_errno(errp, -r, "failed KVM_SET_CPUID2");
         goto fail;
     }
     kvm_init_xsave(env);
diff --git a/target/loongarch/kvm/kvm.c b/target/loongarch/kvm/kvm.c
index 7ca95181a1..db39267375 100644
--- a/target/loongarch/kvm/kvm.c
+++ b/target/loongarch/kvm/kvm.c
@@ -1320,11 +1320,10 @@ int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp)
     return 0;
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     uint64_t val;
     int ret;
-    Error *local_err = NULL;
     LoongArchCPU *cpu = LOONGARCH_CPU(cs);
 
     cpu->vmsentry = qemu_add_vm_change_state_handler(
@@ -1334,51 +1333,43 @@ int kvm_arch_init_vcpu(CPUState *cs)
         brk_insn = val;
     }
 
-    ret = kvm_cpu_check_lsx(cs, &local_err);
+    ret = kvm_cpu_check_lsx(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_lasx(cs, &local_err);
+    ret = kvm_cpu_check_lasx(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_lbt(cs, &local_err);
+    ret = kvm_cpu_check_lbt(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_pmu(cs, &local_err);
+    ret = kvm_cpu_check_pmu(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_pv_features(cs, &local_err);
+    ret = kvm_cpu_check_pv_features(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_ptw(cs, &local_err);
+    ret = kvm_cpu_check_ptw(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_msgint(cs, &local_err);
+    ret = kvm_cpu_check_msgint(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
-    ret = kvm_cpu_check_misc_v1_1(cs, &local_err);
+    ret = kvm_cpu_check_misc_v1_1(cs, errp);
     if (ret < 0) {
-        error_report_err(local_err);
         return ret;
     }
 
diff --git a/target/ppc/kvm.c b/target/ppc/kvm.c
index 8e89a6c665..5d72cbd9fc 100644
--- a/target/ppc/kvm.c
+++ b/target/ppc/kvm.c
@@ -484,7 +484,7 @@ int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp)
     return 0;
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     PowerPCCPU *cpu = POWERPC_CPU(cs);
     CPUPPCState *cenv = &cpu->env;
@@ -493,9 +493,10 @@ int kvm_arch_init_vcpu(CPUState *cs)
     /* Synchronize sregs with kvm */
     ret = kvm_arch_sync_sregs(cpu);
     if (ret) {
+        error_setg_errno(errp, -ret, "Register sync failed"),
         if (ret == -EINVAL) {
-            error_report("Register sync failed... If you're using kvm-hv.ko,"
-                         " only \"-cpu host\" is possible");
+            error_append_hint(errp, "If you're using kvm-hv.ko,"
+                              " only \"-cpu host\" is possible\n");
         }
         return ret;
     }
@@ -504,6 +505,9 @@ int kvm_arch_init_vcpu(CPUState *cs)
     case POWERPC_MMU_BOOKE206:
         /* This target supports access to KVM's guest TLB */
         ret = kvm_booke206_tlb_init(cpu);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "failed kvm_booke206_tlb_init"),
+        }
         break;
     case POWERPC_MMU_2_07:
         if (!cap_htm && !kvmppc_is_pr(cs->kvm_state)) {
diff --git a/target/riscv/kvm/kvm-cpu.c b/target/riscv/kvm/kvm-cpu.c
index 5a82a63b82..523b515f2a 100644
--- a/target/riscv/kvm/kvm-cpu.c
+++ b/target/riscv/kvm/kvm-cpu.c
@@ -1605,7 +1605,7 @@ int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp)
     return 0;
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     int ret = 0;
     RISCVCPU *cpu = RISCV_CPU(cs);
@@ -1615,6 +1615,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
     if (!object_dynamic_cast(OBJECT(cpu), TYPE_RISCV_CPU_HOST)) {
         ret = kvm_vcpu_set_machine_ids(cpu, cs);
         if (ret != 0) {
+            error_setg_errno(errp, -ret, "failed setting machine id");
             return ret;
         }
     }
@@ -1623,6 +1624,9 @@ int kvm_arch_init_vcpu(CPUState *cs)
     kvm_riscv_update_cpu_cfg_isa_ext(cpu, cs);
 
     ret = kvm_vcpu_enable_sbi_dbcn(cpu, cs);
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "failed kvm_vcpu_enable_sbi_dbcn");
+    }
 
     return ret;
 }
diff --git a/target/s390x/kvm/kvm.c b/target/s390x/kvm/kvm.c
index dc67e84886..76dd1e67c0 100644
--- a/target/s390x/kvm/kvm.c
+++ b/target/s390x/kvm/kvm.c
@@ -403,7 +403,7 @@ int kvm_arch_pre_create_vcpu(CPUState *cpu, Error **errp)
     return 0;
 }
 
-int kvm_arch_init_vcpu(CPUState *cs)
+int kvm_arch_init_vcpu(CPUState *cs, Error **errp)
 {
     unsigned int max_cpus = MACHINE(qdev_get_machine())->smp.max_cpus;
     S390CPU *cpu = S390_CPU(cs);
-- 
2.53.0