| Message ID | 20191202140146.3910-3-frankja@linux.ibm.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | s390x: Increase architectural compliance | expand |
On 02.12.19 15:01, Janosch Frank wrote: > Up to now we only had an ioctl to reset vcpu data QEMU couldn't reach > for the initial reset, which was also called for the clear reset. To > be architecture compliant, we also need to clear local interrupts on a > normal reset. > > Because of this and the upcoming protvirt support we need to add > ioctls for the missing clear and normal resets. > > Signed-off-by: Janosch Frank <frankja@linux.ibm.com> > --- > target/s390x/cpu.c | 14 ++++++++++++-- > target/s390x/kvm-stub.c | 10 +++++++++- > target/s390x/kvm.c | 42 ++++++++++++++++++++++++++++++++-------- > target/s390x/kvm_s390x.h | 4 +++- > 4 files changed, 58 insertions(+), 12 deletions(-) > > diff --git a/target/s390x/cpu.c b/target/s390x/cpu.c > index 829ce6ad54..906285888e 100644 > --- a/target/s390x/cpu.c > +++ b/target/s390x/cpu.c > @@ -139,8 +139,18 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type) > } > > /* Reset state inside the kernel that we cannot access yet from QEMU. */ > - if (kvm_enabled() && type != S390_CPU_RESET_NORMAL) { > - kvm_s390_reset_vcpu(cpu); > + if (kvm_enabled()) { > + switch (type) { > + case S390_CPU_RESET_CLEAR: > + kvm_s390_reset_vcpu_clear(cpu); > + break; > + case S390_CPU_RESET_INITIAL: > + kvm_s390_reset_vcpu_initial(cpu); > + break; > + case S390_CPU_RESET_NORMAL: > + kvm_s390_reset_vcpu_normal(cpu); > + break; > + } > } > } > > diff --git a/target/s390x/kvm-stub.c b/target/s390x/kvm-stub.c > index 5152e2bdf1..c4cd497f85 100644 > --- a/target/s390x/kvm-stub.c > +++ b/target/s390x/kvm-stub.c > @@ -83,7 +83,15 @@ void kvm_s390_cmma_reset(void) > { > } > > -void kvm_s390_reset_vcpu(S390CPU *cpu) > +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) > +{ > +} > + > +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) > +{ > +} > + > +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) > { > } > > diff --git a/target/s390x/kvm.c b/target/s390x/kvm.c > index ad6e38c876..7a2ec8b9f8 100644 > --- a/target/s390x/kvm.c > +++ b/target/s390x/kvm.c > @@ -151,6 +151,7 @@ static int cap_s390_irq; > static int cap_ri; > static int cap_gs; > static int cap_hpage_1m; > +static int cap_vcpu_resets; > > static int active_cmma; > > @@ -342,6 +343,7 @@ int kvm_arch_init(MachineState *ms, KVMState *s) > cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF); > cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP); > cap_s390_irq = kvm_check_extension(s, KVM_CAP_S390_INJECT_IRQ); > + cap_vcpu_resets = kvm_check_extension(s, KVM_CAP_S390_VCPU_RESETS); > > if (!kvm_check_extension(s, KVM_CAP_S390_GMAP) > || !kvm_check_extension(s, KVM_CAP_S390_COW)) { > @@ -403,20 +405,44 @@ int kvm_arch_destroy_vcpu(CPUState *cs) > return 0; > } > > -void kvm_s390_reset_vcpu(S390CPU *cpu) > +static void kvm_s390_reset_vcpu(S390CPU *cpu, unsigned long type) > { > CPUState *cs = CPU(cpu); > > - /* The initial reset call is needed here to reset in-kernel > - * vcpu data that we can't access directly from QEMU > - * (i.e. with older kernels which don't support sync_regs/ONE_REG). > - * Before this ioctl cpu_synchronize_state() is called in common kvm > - * code (kvm-all) */ > - if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) { > - error_report("Initial CPU reset failed on CPU %i", cs->cpu_index); > + /* > + * The reset call is needed here to reset in-kernel vcpu data that > + * we can't access directly from QEMU (i.e. with older kernels > + * which don't support sync_regs/ONE_REG). Before this ioctl > + * cpu_synchronize_state() is called in common kvm code > + * (kvm-all). > + */ > + if (kvm_vcpu_ioctl(cs, type)) { > + error_report("CPU reset failed on CPU %i", cs->cpu_index); > } > } > > +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) > +{ > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > +} > + > +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) > +{ > + if (!cap_vcpu_resets) { > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > + } else { > + kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); > + } > +} > + > +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) > +{ > + if (!cap_vcpu_resets) { > + return; > + } > + kvm_s390_reset_vcpu(cpu, KVM_S390_NORMAL_RESET); if (cap_vcpu_resets) { kvm_s390_reset_vcpu(cpu, KVM_S390_NORMAL_RESET); } saves one LOC ;) Acked-by: David Hildenbrand <david@redhat.com>
On 02/12/2019 15.01, Janosch Frank wrote: > Up to now we only had an ioctl to reset vcpu data QEMU couldn't reach > for the initial reset, which was also called for the clear reset. To > be architecture compliant, we also need to clear local interrupts on a > normal reset. > > Because of this and the upcoming protvirt support we need to add > ioctls for the missing clear and normal resets. > > Signed-off-by: Janosch Frank <frankja@linux.ibm.com> > --- [...] > @@ -403,20 +405,44 @@ int kvm_arch_destroy_vcpu(CPUState *cs) > return 0; > } > > -void kvm_s390_reset_vcpu(S390CPU *cpu) > +static void kvm_s390_reset_vcpu(S390CPU *cpu, unsigned long type) > { > CPUState *cs = CPU(cpu); > > - /* The initial reset call is needed here to reset in-kernel > - * vcpu data that we can't access directly from QEMU > - * (i.e. with older kernels which don't support sync_regs/ONE_REG). > - * Before this ioctl cpu_synchronize_state() is called in common kvm > - * code (kvm-all) */ > - if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) { > - error_report("Initial CPU reset failed on CPU %i", cs->cpu_index); > + /* > + * The reset call is needed here to reset in-kernel vcpu data that > + * we can't access directly from QEMU (i.e. with older kernels > + * which don't support sync_regs/ONE_REG). Before this ioctl > + * cpu_synchronize_state() is called in common kvm code > + * (kvm-all). > + */ > + if (kvm_vcpu_ioctl(cs, type)) { > + error_report("CPU reset failed on CPU %i", cs->cpu_index); In case you respin, maybe also print the "type" variable here? > } > } > > +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) > +{ > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > +} > + > +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) > +{ > + if (!cap_vcpu_resets) { > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > + } else { > + kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); > + } Cosmetic nit: It's a tiny bit nicer the other way round: if (cap_vcpu_resets) { kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); } else { kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); } Anyway, Reviewed-by: Thomas Huth <thuth@redhat.com>
On Mon, 2 Dec 2019 09:01:45 -0500 Janosch Frank <frankja@linux.ibm.com> wrote: > Up to now we only had an ioctl to reset vcpu data QEMU couldn't reach > for the initial reset, which was also called for the clear reset. To s/which/and that/ ? > be architecture compliant, we also need to clear local interrupts on a > normal reset. > > Because of this and the upcoming protvirt support we need to add > ioctls for the missing clear and normal resets. > > Signed-off-by: Janosch Frank <frankja@linux.ibm.com> > --- > target/s390x/cpu.c | 14 ++++++++++++-- > target/s390x/kvm-stub.c | 10 +++++++++- > target/s390x/kvm.c | 42 ++++++++++++++++++++++++++++++++-------- > target/s390x/kvm_s390x.h | 4 +++- > 4 files changed, 58 insertions(+), 12 deletions(-) > > diff --git a/target/s390x/cpu.c b/target/s390x/cpu.c > index 829ce6ad54..906285888e 100644 > --- a/target/s390x/cpu.c > +++ b/target/s390x/cpu.c > @@ -139,8 +139,18 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type) > } > > /* Reset state inside the kernel that we cannot access yet from QEMU. */ Hm, why does this comment talk about 'yet'? Did we have any plans to change that? > - if (kvm_enabled() && type != S390_CPU_RESET_NORMAL) { > - kvm_s390_reset_vcpu(cpu); > + if (kvm_enabled()) { > + switch (type) { > + case S390_CPU_RESET_CLEAR: > + kvm_s390_reset_vcpu_clear(cpu); > + break; > + case S390_CPU_RESET_INITIAL: > + kvm_s390_reset_vcpu_initial(cpu); > + break; > + case S390_CPU_RESET_NORMAL: > + kvm_s390_reset_vcpu_normal(cpu); > + break; Add a default case to catch errors? > + } > } > } > (...) > diff --git a/target/s390x/kvm.c b/target/s390x/kvm.c > index ad6e38c876..7a2ec8b9f8 100644 > --- a/target/s390x/kvm.c > +++ b/target/s390x/kvm.c > @@ -151,6 +151,7 @@ static int cap_s390_irq; > static int cap_ri; > static int cap_gs; > static int cap_hpage_1m; > +static int cap_vcpu_resets; > > static int active_cmma; > > @@ -342,6 +343,7 @@ int kvm_arch_init(MachineState *ms, KVMState *s) > cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF); > cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP); > cap_s390_irq = kvm_check_extension(s, KVM_CAP_S390_INJECT_IRQ); > + cap_vcpu_resets = kvm_check_extension(s, KVM_CAP_S390_VCPU_RESETS); > > if (!kvm_check_extension(s, KVM_CAP_S390_GMAP) > || !kvm_check_extension(s, KVM_CAP_S390_COW)) { > @@ -403,20 +405,44 @@ int kvm_arch_destroy_vcpu(CPUState *cs) > return 0; > } > > -void kvm_s390_reset_vcpu(S390CPU *cpu) > +static void kvm_s390_reset_vcpu(S390CPU *cpu, unsigned long type) > { > CPUState *cs = CPU(cpu); > > - /* The initial reset call is needed here to reset in-kernel > - * vcpu data that we can't access directly from QEMU > - * (i.e. with older kernels which don't support sync_regs/ONE_REG). > - * Before this ioctl cpu_synchronize_state() is called in common kvm > - * code (kvm-all) */ > - if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) { > - error_report("Initial CPU reset failed on CPU %i", cs->cpu_index); > + /* > + * The reset call is needed here to reset in-kernel vcpu data that > + * we can't access directly from QEMU (i.e. with older kernels > + * which don't support sync_regs/ONE_REG). Before this ioctl Is the reference to sync_regs/ONE_REG still relevant? I'm a bit confused here, especially with regard to what we'll need for protected virt. > + * cpu_synchronize_state() is called in common kvm code > + * (kvm-all). > + */ > + if (kvm_vcpu_ioctl(cs, type)) { > + error_report("CPU reset failed on CPU %i", cs->cpu_index); > } > } > > +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) > +{ > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > +} > + > +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) > +{ > + if (!cap_vcpu_resets) { > + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); > + } else { > + kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); > + } kvm_s390_reset_vcpu(cpu, cap_vcpu_resets ? KVM_S390_CLEAR_RESET : KVM_S390_INITIAL_RESET); One line, but maybe the conventional if is still better :) > +} > + > +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) > +{ > + if (!cap_vcpu_resets) { > + return; > + } > + kvm_s390_reset_vcpu(cpu, KVM_S390_NORMAL_RESET); > +} > + > static int can_sync_regs(CPUState *cs, int regs) > { > return cap_sync_regs && (cs->kvm_run->kvm_valid_regs & regs) == regs; > diff --git a/target/s390x/kvm_s390x.h b/target/s390x/kvm_s390x.h > index caf985955b..0b21789796 100644 > --- a/target/s390x/kvm_s390x.h > +++ b/target/s390x/kvm_s390x.h > @@ -34,7 +34,9 @@ int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch, > int vq, bool assign); > int kvm_s390_cmma_active(void); > void kvm_s390_cmma_reset(void); > -void kvm_s390_reset_vcpu(S390CPU *cpu); > +void kvm_s390_reset_vcpu_clear(S390CPU *cpu); > +void kvm_s390_reset_vcpu_normal(S390CPU *cpu); > +void kvm_s390_reset_vcpu_initial(S390CPU *cpu); > int kvm_s390_set_mem_limit(uint64_t new_limit, uint64_t *hw_limit); > void kvm_s390_set_max_pagesize(uint64_t pagesize, Error **errp); > void kvm_s390_crypto_reset(void);
On 12/2/19 4:46 PM, Cornelia Huck wrote: > On Mon, 2 Dec 2019 09:01:45 -0500 > Janosch Frank <frankja@linux.ibm.com> wrote: > >> Up to now we only had an ioctl to reset vcpu data QEMU couldn't reach >> for the initial reset, which was also called for the clear reset. To > > s/which/and that/ ? Ok > >> be architecture compliant, we also need to clear local interrupts on a >> normal reset. >> >> Because of this and the upcoming protvirt support we need to add >> ioctls for the missing clear and normal resets. >> >> Signed-off-by: Janosch Frank <frankja@linux.ibm.com> >> --- >> target/s390x/cpu.c | 14 ++++++++++++-- >> target/s390x/kvm-stub.c | 10 +++++++++- >> target/s390x/kvm.c | 42 ++++++++++++++++++++++++++++++++-------- >> target/s390x/kvm_s390x.h | 4 +++- >> 4 files changed, 58 insertions(+), 12 deletions(-) >> >> diff --git a/target/s390x/cpu.c b/target/s390x/cpu.c >> index 829ce6ad54..906285888e 100644 >> --- a/target/s390x/cpu.c >> +++ b/target/s390x/cpu.c >> @@ -139,8 +139,18 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type) >> } >> >> /* Reset state inside the kernel that we cannot access yet from QEMU. */ > > Hm, why does this comment talk about 'yet'? Did we have any plans to > change that? You're asking the wrong person :) > >> - if (kvm_enabled() && type != S390_CPU_RESET_NORMAL) { >> - kvm_s390_reset_vcpu(cpu); >> + if (kvm_enabled()) { >> + switch (type) { >> + case S390_CPU_RESET_CLEAR: >> + kvm_s390_reset_vcpu_clear(cpu); >> + break; >> + case S390_CPU_RESET_INITIAL: >> + kvm_s390_reset_vcpu_initial(cpu); >> + break; >> + case S390_CPU_RESET_NORMAL: >> + kvm_s390_reset_vcpu_normal(cpu); >> + break; > > Add a default case to catch errors? Sure, just did > >> + } >> } >> } >> > > (...) > >> diff --git a/target/s390x/kvm.c b/target/s390x/kvm.c >> index ad6e38c876..7a2ec8b9f8 100644 >> --- a/target/s390x/kvm.c >> +++ b/target/s390x/kvm.c >> @@ -151,6 +151,7 @@ static int cap_s390_irq; >> static int cap_ri; >> static int cap_gs; >> static int cap_hpage_1m; >> +static int cap_vcpu_resets; >> >> static int active_cmma; >> >> @@ -342,6 +343,7 @@ int kvm_arch_init(MachineState *ms, KVMState *s) >> cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF); >> cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP); >> cap_s390_irq = kvm_check_extension(s, KVM_CAP_S390_INJECT_IRQ); >> + cap_vcpu_resets = kvm_check_extension(s, KVM_CAP_S390_VCPU_RESETS); >> >> if (!kvm_check_extension(s, KVM_CAP_S390_GMAP) >> || !kvm_check_extension(s, KVM_CAP_S390_COW)) { >> @@ -403,20 +405,44 @@ int kvm_arch_destroy_vcpu(CPUState *cs) >> return 0; >> } >> >> -void kvm_s390_reset_vcpu(S390CPU *cpu) >> +static void kvm_s390_reset_vcpu(S390CPU *cpu, unsigned long type) >> { >> CPUState *cs = CPU(cpu); >> >> - /* The initial reset call is needed here to reset in-kernel >> - * vcpu data that we can't access directly from QEMU >> - * (i.e. with older kernels which don't support sync_regs/ONE_REG). >> - * Before this ioctl cpu_synchronize_state() is called in common kvm >> - * code (kvm-all) */ >> - if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) { >> - error_report("Initial CPU reset failed on CPU %i", cs->cpu_index); >> + /* >> + * The reset call is needed here to reset in-kernel vcpu data that >> + * we can't access directly from QEMU (i.e. with older kernels >> + * which don't support sync_regs/ONE_REG). Before this ioctl > > Is the reference to sync_regs/ONE_REG still relevant? I'm a bit > confused here, especially with regard to what we'll need for protected > virt. I just didn't want to move/remove stuff Even with kvm_run we do a lot of stuff for the initial reset. > >> + * cpu_synchronize_state() is called in common kvm code >> + * (kvm-all). >> + */ >> + if (kvm_vcpu_ioctl(cs, type)) { >> + error_report("CPU reset failed on CPU %i", cs->cpu_index); >> } >> } >> >> +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) >> +{ >> + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); >> +} >> + >> +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) >> +{ >> + if (!cap_vcpu_resets) { >> + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); >> + } else { >> + kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); >> + } > > kvm_s390_reset_vcpu(cpu, cap_vcpu_resets ? KVM_S390_CLEAR_RESET : KVM_S390_INITIAL_RESET); > > One line, but maybe the conventional if is still better :) I'd like to keep it as is. > >> +} >> + >> +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) >> +{ >> + if (!cap_vcpu_resets) { >> + return; >> + } >> + kvm_s390_reset_vcpu(cpu, KVM_S390_NORMAL_RESET); >> +} >> + >> static int can_sync_regs(CPUState *cs, int regs) >> { >> return cap_sync_regs && (cs->kvm_run->kvm_valid_regs & regs) == regs; >> diff --git a/target/s390x/kvm_s390x.h b/target/s390x/kvm_s390x.h >> index caf985955b..0b21789796 100644 >> --- a/target/s390x/kvm_s390x.h >> +++ b/target/s390x/kvm_s390x.h >> @@ -34,7 +34,9 @@ int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch, >> int vq, bool assign); >> int kvm_s390_cmma_active(void); >> void kvm_s390_cmma_reset(void); >> -void kvm_s390_reset_vcpu(S390CPU *cpu); >> +void kvm_s390_reset_vcpu_clear(S390CPU *cpu); >> +void kvm_s390_reset_vcpu_normal(S390CPU *cpu); >> +void kvm_s390_reset_vcpu_initial(S390CPU *cpu); >> int kvm_s390_set_mem_limit(uint64_t new_limit, uint64_t *hw_limit); >> void kvm_s390_set_max_pagesize(uint64_t pagesize, Error **errp); >> void kvm_s390_crypto_reset(void); > >
diff --git a/target/s390x/cpu.c b/target/s390x/cpu.c index 829ce6ad54..906285888e 100644 --- a/target/s390x/cpu.c +++ b/target/s390x/cpu.c @@ -139,8 +139,18 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type) } /* Reset state inside the kernel that we cannot access yet from QEMU. */ - if (kvm_enabled() && type != S390_CPU_RESET_NORMAL) { - kvm_s390_reset_vcpu(cpu); + if (kvm_enabled()) { + switch (type) { + case S390_CPU_RESET_CLEAR: + kvm_s390_reset_vcpu_clear(cpu); + break; + case S390_CPU_RESET_INITIAL: + kvm_s390_reset_vcpu_initial(cpu); + break; + case S390_CPU_RESET_NORMAL: + kvm_s390_reset_vcpu_normal(cpu); + break; + } } } diff --git a/target/s390x/kvm-stub.c b/target/s390x/kvm-stub.c index 5152e2bdf1..c4cd497f85 100644 --- a/target/s390x/kvm-stub.c +++ b/target/s390x/kvm-stub.c @@ -83,7 +83,15 @@ void kvm_s390_cmma_reset(void) { } -void kvm_s390_reset_vcpu(S390CPU *cpu) +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) +{ +} + +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) +{ +} + +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) { } diff --git a/target/s390x/kvm.c b/target/s390x/kvm.c index ad6e38c876..7a2ec8b9f8 100644 --- a/target/s390x/kvm.c +++ b/target/s390x/kvm.c @@ -151,6 +151,7 @@ static int cap_s390_irq; static int cap_ri; static int cap_gs; static int cap_hpage_1m; +static int cap_vcpu_resets; static int active_cmma; @@ -342,6 +343,7 @@ int kvm_arch_init(MachineState *ms, KVMState *s) cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF); cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP); cap_s390_irq = kvm_check_extension(s, KVM_CAP_S390_INJECT_IRQ); + cap_vcpu_resets = kvm_check_extension(s, KVM_CAP_S390_VCPU_RESETS); if (!kvm_check_extension(s, KVM_CAP_S390_GMAP) || !kvm_check_extension(s, KVM_CAP_S390_COW)) { @@ -403,20 +405,44 @@ int kvm_arch_destroy_vcpu(CPUState *cs) return 0; } -void kvm_s390_reset_vcpu(S390CPU *cpu) +static void kvm_s390_reset_vcpu(S390CPU *cpu, unsigned long type) { CPUState *cs = CPU(cpu); - /* The initial reset call is needed here to reset in-kernel - * vcpu data that we can't access directly from QEMU - * (i.e. with older kernels which don't support sync_regs/ONE_REG). - * Before this ioctl cpu_synchronize_state() is called in common kvm - * code (kvm-all) */ - if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) { - error_report("Initial CPU reset failed on CPU %i", cs->cpu_index); + /* + * The reset call is needed here to reset in-kernel vcpu data that + * we can't access directly from QEMU (i.e. with older kernels + * which don't support sync_regs/ONE_REG). Before this ioctl + * cpu_synchronize_state() is called in common kvm code + * (kvm-all). + */ + if (kvm_vcpu_ioctl(cs, type)) { + error_report("CPU reset failed on CPU %i", cs->cpu_index); } } +void kvm_s390_reset_vcpu_initial(S390CPU *cpu) +{ + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); +} + +void kvm_s390_reset_vcpu_clear(S390CPU *cpu) +{ + if (!cap_vcpu_resets) { + kvm_s390_reset_vcpu(cpu, KVM_S390_INITIAL_RESET); + } else { + kvm_s390_reset_vcpu(cpu, KVM_S390_CLEAR_RESET); + } +} + +void kvm_s390_reset_vcpu_normal(S390CPU *cpu) +{ + if (!cap_vcpu_resets) { + return; + } + kvm_s390_reset_vcpu(cpu, KVM_S390_NORMAL_RESET); +} + static int can_sync_regs(CPUState *cs, int regs) { return cap_sync_regs && (cs->kvm_run->kvm_valid_regs & regs) == regs; diff --git a/target/s390x/kvm_s390x.h b/target/s390x/kvm_s390x.h index caf985955b..0b21789796 100644 --- a/target/s390x/kvm_s390x.h +++ b/target/s390x/kvm_s390x.h @@ -34,7 +34,9 @@ int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch, int vq, bool assign); int kvm_s390_cmma_active(void); void kvm_s390_cmma_reset(void); -void kvm_s390_reset_vcpu(S390CPU *cpu); +void kvm_s390_reset_vcpu_clear(S390CPU *cpu); +void kvm_s390_reset_vcpu_normal(S390CPU *cpu); +void kvm_s390_reset_vcpu_initial(S390CPU *cpu); int kvm_s390_set_mem_limit(uint64_t new_limit, uint64_t *hw_limit); void kvm_s390_set_max_pagesize(uint64_t pagesize, Error **errp); void kvm_s390_crypto_reset(void);
Up to now we only had an ioctl to reset vcpu data QEMU couldn't reach for the initial reset, which was also called for the clear reset. To be architecture compliant, we also need to clear local interrupts on a normal reset. Because of this and the upcoming protvirt support we need to add ioctls for the missing clear and normal resets. Signed-off-by: Janosch Frank <frankja@linux.ibm.com> --- target/s390x/cpu.c | 14 ++++++++++++-- target/s390x/kvm-stub.c | 10 +++++++++- target/s390x/kvm.c | 42 ++++++++++++++++++++++++++++++++-------- target/s390x/kvm_s390x.h | 4 +++- 4 files changed, 58 insertions(+), 12 deletions(-)