SYS-OSS/FRET-qemu
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

target/i386/kvm: Clean up return values of MSR filter related functions

Browse Source 
Before commit 0cc42e63bb54 ("kvm/i386: refactor kvm_arch_init and split
it into smaller functions"), error_report() attempts to print the error
code from kvm_filter_msr(). However, printing error code does not work
due to kvm_filter_msr() returns bool instead int.

0cc42e63bb54 fixed the error by removing error code printing, but this
lost useful error messages. Bring it back by making kvm_filter_msr()
return int.

This also makes the function call chain processing clearer, allowing for
better handling of error result propagation from kvm_filter_msr() to
kvm_arch_init(), preparing for the subsequent cleanup work of error
handling in kvm_arch_init().

Signed-off-by: Zhao Liu <zhao1.liu@intel.com>
Reviewed-by: Zide Chen <zide.chen@intel.com>
Link: https://lore.kernel.org/r/20241106030728.553238-9-zhao1.liu@intel.com
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Zhao Liu 2024-11-06 11:07:25 +08:00 committed by Paolo Bonzini
parent 26824f9cac
commit fb81c9cfdd
1 changed files with 44 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
target/i386/kvm/kvm.c
View File

@ -108,7 +108,7 @@ typedef struct {
} KVMMSRHandlers; } KVMMSRHandlers;
static void kvm_init_msrs(X86CPU *cpu); static void kvm_init_msrs(X86CPU *cpu);
static bool kvm_filter_msr(KVMState *s, uint32_t msr, QEMURDMSRHandler *rdmsr, static int kvm_filter_msr(KVMState *s, uint32_t msr, QEMURDMSRHandler *rdmsr,
QEMUWRMSRHandler *wrmsr); QEMUWRMSRHandler *wrmsr);
const KVMCapabilityInfo kvm_arch_required_capabilities[] = { const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
@ -3150,7 +3150,9 @@ static int kvm_vm_enable_notify_vmexit(KVMState *s)
static int kvm_vm_enable_userspace_msr(KVMState *s) static int kvm_vm_enable_userspace_msr(KVMState *s)
{ {
int ret = kvm_vm_enable_cap(s, KVM_CAP_X86_USER_SPACE_MSR, 0, int ret;
ret = kvm_vm_enable_cap(s, KVM_CAP_X86_USER_SPACE_MSR, 0,
KVM_MSR_EXIT_REASON_FILTER); KVM_MSR_EXIT_REASON_FILTER);
if (ret < 0) { if (ret < 0) {
error_report("Could not enable user space MSRs: %s", error_report("Could not enable user space MSRs: %s",
@ -3158,9 +3160,11 @@ static int kvm_vm_enable_userspace_msr(KVMState *s)
exit(1); exit(1);
} }
if (!kvm_filter_msr(s, MSR_CORE_THREAD_COUNT, ret = kvm_filter_msr(s, MSR_CORE_THREAD_COUNT,
kvm_rdmsr_core_thread_count, NULL)) { kvm_rdmsr_core_thread_count, NULL);
error_report("Could not install MSR_CORE_THREAD_COUNT handler!"); if (ret < 0) {
error_report("Could not install MSR_CORE_THREAD_COUNT handler: %s",
strerror(-ret));
exit(1); exit(1);
} }
@ -3169,36 +3173,37 @@ static int kvm_vm_enable_userspace_msr(KVMState *s)
static void kvm_vm_enable_energy_msrs(KVMState *s) static void kvm_vm_enable_energy_msrs(KVMState *s)
{ {
bool r; int ret;
if (s->msr_energy.enable == true) { if (s->msr_energy.enable == true) {
r = kvm_filter_msr(s, MSR_RAPL_POWER_UNIT, ret = kvm_filter_msr(s, MSR_RAPL_POWER_UNIT,
kvm_rdmsr_rapl_power_unit, NULL); kvm_rdmsr_rapl_power_unit, NULL);
if (!r) { if (ret < 0) {
error_report("Could not install MSR_RAPL_POWER_UNIT \ error_report("Could not install MSR_RAPL_POWER_UNIT handler: %s",
handler"); strerror(-ret));
exit(1); exit(1);
} }
r = kvm_filter_msr(s, MSR_PKG_POWER_LIMIT, ret = kvm_filter_msr(s, MSR_PKG_POWER_LIMIT,
kvm_rdmsr_pkg_power_limit, NULL); kvm_rdmsr_pkg_power_limit, NULL);
if (!r) { if (ret < 0) {
error_report("Could not install MSR_PKG_POWER_LIMIT \ error_report("Could not install MSR_PKG_POWER_LIMIT handler: %s",
handler"); strerror(-ret));
exit(1); exit(1);
} }
r = kvm_filter_msr(s, MSR_PKG_POWER_INFO, ret = kvm_filter_msr(s, MSR_PKG_POWER_INFO,
kvm_rdmsr_pkg_power_info, NULL); kvm_rdmsr_pkg_power_info, NULL);
if (!r) { if (ret < 0) {
error_report("Could not install MSR_PKG_POWER_INFO \ error_report("Could not install MSR_PKG_POWER_INFO handler: %s",
handler"); strerror(-ret));
exit(1); exit(1);
} }
r = kvm_filter_msr(s, MSR_PKG_ENERGY_STATUS, ret = kvm_filter_msr(s, MSR_PKG_ENERGY_STATUS,
kvm_rdmsr_pkg_energy_status, NULL); kvm_rdmsr_pkg_energy_status, NULL);
if (!r) { if (ret < 0) {
error_report("Could not install MSR_PKG_ENERGY_STATUS \ error_report("Could not install MSR_PKG_ENERGY_STATUS handler: %s",
handler"); strerror(-ret));
exit(1); exit(1);
} }
} }
@ -5841,13 +5846,13 @@ void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg)
} }
} }
static bool kvm_install_msr_filters(KVMState *s) static int kvm_install_msr_filters(KVMState *s)
{ {
uint64_t zero = 0; uint64_t zero = 0;
struct kvm_msr_filter filter = { struct kvm_msr_filter filter = {
.flags = KVM_MSR_FILTER_DEFAULT_ALLOW, .flags = KVM_MSR_FILTER_DEFAULT_ALLOW,
}; };
int r, i, j = 0; int i, j = 0;
for (i = 0; i < KVM_MSR_FILTER_MAX_RANGES; i++) { for (i = 0; i < KVM_MSR_FILTER_MAX_RANGES; i++) {
KVMMSRHandlers *handler = &msr_handlers[i]; KVMMSRHandlers *handler = &msr_handlers[i];
@ -5871,18 +5876,13 @@ static bool kvm_install_msr_filters(KVMState *s)
} }
} }
r = kvm_vm_ioctl(s, KVM_X86_SET_MSR_FILTER, &filter); return kvm_vm_ioctl(s, KVM_X86_SET_MSR_FILTER, &filter);
if (r) {
return false;
} }
return true; static int kvm_filter_msr(KVMState *s, uint32_t msr, QEMURDMSRHandler *rdmsr,
}
static bool kvm_filter_msr(KVMState *s, uint32_t msr, QEMURDMSRHandler *rdmsr,
QEMUWRMSRHandler *wrmsr) QEMUWRMSRHandler *wrmsr)
{ {
int i; int i, ret;
for (i = 0; i < ARRAY_SIZE(msr_handlers); i++) { for (i = 0; i < ARRAY_SIZE(msr_handlers); i++) {
if (!msr_handlers[i].msr) { if (!msr_handlers[i].msr) {
@ -5892,16 +5892,17 @@ static bool kvm_filter_msr(KVMState *s, uint32_t msr, QEMURDMSRHandler *rdmsr,
.wrmsr = wrmsr, .wrmsr = wrmsr,
}; };
if (!kvm_install_msr_filters(s)) { ret = kvm_install_msr_filters(s);
if (ret) {
msr_handlers[i] = (KVMMSRHandlers) { }; msr_handlers[i] = (KVMMSRHandlers) { };
return false; return ret;
} }
return true; return 0;
} }
} }
return false; return -EINVAL;
} }
static int kvm_handle_rdmsr(X86CPU *cpu, struct kvm_run *run) static int kvm_handle_rdmsr(X86CPU *cpu, struct kvm_run *run)