exec: drop BQL from interrupt handling
cover exec: drop BQL from interrupt handling
This series comes originally from a series of patches that Paolo sent to me a long time ago. I have kept most of his S-o-b tags, but I have done the forward port of the patches to the current QEMU code base, so please blame all possible bugs on me, not him.
The goal of this series is to push the BQL out of interrupt handling wherever possible. Many targets do not need the BQL to handle interrupts, so for those targets we get rid of the BQL in interrupt handling. In TCG mode, this by itself does not yield measurable performance gains. However, it is a necessary first step before tackling BQL contention when managing CPU states (i.e. exiting the exec loop always involves taking the BQL, which does not scale).
The patches:
- Patch 0 accesses icount_decr.u16 consistently with atomics. This is important because we use it across threads to signal that an interrupt is pending.
- 2-28: convert direct callers of cpu->interrupt_request to use atomic accesses or CPU helper functions that use atomics. I have broken these up into individual patches to ease review. Note that in some cases I have added many atomic_reads, most of which are probably unnecessary. However, I'd leave this up to the maintainers, since I do not want to break things by doing a single atomic_read(&cpu->interrupt_request) at the beginning of a function and then miss subsequent updates to cpu->interrupt_request.
- 29-31: drop the BQL requirement when handling cpu->interrupt_request
- 32-33: drop now unnecessary BQL acquisitions in i386 and ppc
- 34-35: push down the BQL acquisition to cpu->do_interrupt and cpu->cpu_exec_interrupt. Here I am Cc'ing everyone so that we can make sure I am not missing any target that requires the BQL on either do_interrupt or cpu_exec_interrupt.
This series is checkpatch-clean, and can be fetched from:
https://github.com/cota/qemu/tree/cpu-lock
Note that the series applies on top of patches that are already on the qemu-devel list and will hopefully soon be upstream. This series begins after commit 4ece0cbd74 ("cpus: access .qemu_icount_bias with atomic64") in that tree.
Thanks,
Emilio
PATCH 2/35 target/i386: use cpu_reset_interrupt
From: Paolo Bonzini <[email protected]>
It will be changed to an atomic operation soon.
--- target/i386/hax-all.c | 4 ++-- target/i386/hvf/x86hvf.c | 8 ++++---- target/i386/kvm.c | 14 +++++++------- target/i386/seg_helper.c | 13 ++++++------- target/i386/svm_helper.c | 2 +- target/i386/whpx-all.c | 10 +++++----- 6 files changed, 25 insertions(+), 26 deletions(-)
target/i386/hax-all.c +2 -2
@@ -433,7 +433,7 @@ static int hax_vcpu_interrupt(CPUArchState *env) irq =cpu_get_pic_interrupt (env);if (irq >=0 ) {hax_inject_interrupt (env, irq); - cpu->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_HARD ); } }
@@ -483,7 +483,7 @@ static int hax_vcpu_hax_exec(CPUArchState *env) cpu->halted =0 ;if (cpu->interrupt_request &CPU_INTERRUPT_POLL ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );apic_poll_irq (x86_cpu->apic_state); }
target/i386/hvf/x86hvf.c +4 -4
@@ -402,7 +402,7 @@ bool hvf_inject_interrupts(CPUState *cpu_state)if (cpu_state->interrupt_request &CPU_INTERRUPT_NMI ) {if (!(env->hflags2 &HF2_NMI_MASK ) && !(info &VMCS_INTR_VALID )) { - cpu_state->interrupt_request &= ~CPU_INTERRUPT_NMI ; +cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_NMI ); info =VMCS_INTR_VALID |VMCS_INTR_T_NMI |NMI_VEC ;wvmcs (cpu_state->hvf_fd,VMCS_ENTRY_INTR_INFO , info); }else {
@@ -414,7 +414,7 @@ bool hvf_inject_interrupts(CPUState *cpu_state) (cpu_state->interrupt_request & CPU_INTERRUPT_HARD) && (EFLAGS(env) & IF_MASK) && !(info & VMCS_INTR_VALID)) {int line =cpu_get_pic_interrupt (&x86cpu->env); - cpu_state->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_HARD );if (line >=0 ) {wvmcs (cpu_state->hvf_fd,VMCS_ENTRY_INTR_INFO , line |VMCS_INTR_VALID |VMCS_INTR_T_HWINTR );
@@ -440,7 +440,7 @@ int hvf_process_events(CPUState *cpu_state) }if (cpu_state->interrupt_request &CPU_INTERRUPT_POLL ) { - cpu_state->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_POLL );apic_poll_irq (cpu->apic_state); } if (((cpu_state->interrupt_request & CPU_INTERRUPT_HARD) &&
@@ -453,7 +453,7 @@ int hvf_process_events(CPUState *cpu_state)do_cpu_sipi (cpu); }if (cpu_state->interrupt_request &CPU_INTERRUPT_TPR ) { - cpu_state->interrupt_request &= ~CPU_INTERRUPT_TPR ; +cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_TPR );hvf_cpu_synchronize_state (cpu_state);apic_handle_tpr_access_report (cpu->apic_state, env->eip, env->tpr_access_type);
target/i386/kvm.c +7 -7
@@ -2709,7 +2709,7 @@ static int kvm_put_vcpu_events(X86CPU *cpu, int level)*/ events.smi.pending = cs->interrupt_request &CPU_INTERRUPT_SMI ; events.smi.latched_init = cs->interrupt_request &CPU_INTERRUPT_INIT ; - cs->interrupt_request &= ~(CPU_INTERRUPT_INIT |CPU_INTERRUPT_SMI ); +cpu_reset_interrupt (cs,CPU_INTERRUPT_INIT |CPU_INTERRUPT_SMI ); }else {/* Keep these in cs->interrupt_request. */ events.smi.pending =0 ;
@@ -3005,7 +3005,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)if (cpu->interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) {if (cpu->interrupt_request &CPU_INTERRUPT_NMI ) {qemu_mutex_lock_iothread (); - cpu->interrupt_request &= ~CPU_INTERRUPT_NMI ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_NMI );qemu_mutex_unlock_iothread ();DPRINTF ("injected NMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_NMI );
@@ -3016,7 +3016,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) }if (cpu->interrupt_request &CPU_INTERRUPT_SMI ) {qemu_mutex_lock_iothread (); - cpu->interrupt_request &= ~CPU_INTERRUPT_SMI ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_SMI );qemu_mutex_unlock_iothread ();DPRINTF ("injected SMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_SMI );
@@ -3052,7 +3052,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) (env->eflags & IF_MASK)) {int irq; - cpu->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_HARD ); irq =cpu_get_pic_interrupt (env);if (irq >=0 ) {struct kvm_interrupt intr;
@@ -3123,7 +3123,7 @@ int kvm_arch_process_async_events(CPUState *cs)/* We must not raise CPU_INTERRUPT_MCE if it's not supported. */ assert (env->mcg_cap); - cs->interrupt_request &= ~CPU_INTERRUPT_MCE ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_MCE );kvm_cpu_synchronize_state (cs);
@@ -3153,7 +3153,7 @@ int kvm_arch_process_async_events(CPUState *cs) }if (cs->interrupt_request &CPU_INTERRUPT_POLL ) { - cs->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL );apic_poll_irq (cpu->apic_state); } if (((cs->interrupt_request & CPU_INTERRUPT_HARD) &&
@@ -3166,7 +3166,7 @@ int kvm_arch_process_async_events(CPUState *cs)do_cpu_sipi (cpu); }if (cs->interrupt_request &CPU_INTERRUPT_TPR ) { - cs->interrupt_request &= ~CPU_INTERRUPT_TPR ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_TPR );kvm_cpu_synchronize_state (cs);apic_handle_tpr_access_report (cpu->apic_state, env->eip, env->tpr_access_type);
target/i386/seg_helper.c +6 -7
@@ -1323,7 +1323,7 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)#if !defined(CONFIG_USER_ONLY )if (interrupt_request &CPU_INTERRUPT_POLL ) { - cs->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL );apic_poll_irq (cpu->apic_state);/* Don't process multiple interrupt requests in a single call. This is required to make icount-driven execution deterministic. */
@@ -1337,18 +1337,18 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)if ((interrupt_request &CPU_INTERRUPT_SMI ) && !(env->hflags &HF_SMM_MASK )) {cpu_svm_check_intercept_param (env,SVM_EXIT_SMI ,0 ,0 ); - cs->interrupt_request &= ~CPU_INTERRUPT_SMI ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_SMI );do_smm_enter (cpu); ret = true; }else if ((interrupt_request &CPU_INTERRUPT_NMI ) && !(env->hflags2 &HF2_NMI_MASK )) {cpu_svm_check_intercept_param (env,SVM_EXIT_NMI ,0 ,0 ); - cs->interrupt_request &= ~CPU_INTERRUPT_NMI ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_NMI ); env->hflags2 |=HF2_NMI_MASK ;do_interrupt_x86_hardirq (env,EXCP02_NMI ,1 ); ret = true; }else if (interrupt_request &CPU_INTERRUPT_MCE ) { - cs->interrupt_request &= ~CPU_INTERRUPT_MCE ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_MCE );do_interrupt_x86_hardirq (env,EXCP12_MCHK ,0 ); ret = true; } else if ((interrupt_request & CPU_INTERRUPT_HARD) &&
@@ -1359,8 +1359,7 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request) !(env->hflags & HF_INHIBIT_IRQ_MASK))))) {int intno;cpu_svm_check_intercept_param (env,SVM_EXIT_INTR ,0 ,0 ); - cs->interrupt_request &= ~(CPU_INTERRUPT_HARD | -CPU_INTERRUPT_VIRQ ); +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD |CPU_INTERRUPT_VIRQ ); intno =cpu_get_pic_interrupt (env);qemu_log_mask (CPU_LOG_TB_IN_ASM ,"Servicing hardware INT=0x%02x\n" , intno);
@@ -1380,7 +1379,7 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)qemu_log_mask (CPU_LOG_TB_IN_ASM ,"Servicing virtual hardware INT=0x%02x\n" , intno);do_interrupt_x86_hardirq (env, intno,1 ); - cs->interrupt_request &= ~CPU_INTERRUPT_VIRQ ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_VIRQ ); ret = true;#endif }
target/i386/svm_helper.c +1 -1
@@ -700,7 +700,7 @@ void do_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1) env->hflags &= ~HF_SVMI_MASK ; env->intercept =0 ; env->intercept_exceptions =0 ; - cs->interrupt_request &= ~CPU_INTERRUPT_VIRQ ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_VIRQ ); env->tsc_offset =0 ; env->gdt.base = x86_ldq_phys(cs, env->vm_hsave + offsetof(struct vmcb,
target/i386/whpx-all.c +5 -5
@@ -728,14 +728,14 @@ static void whpx_vcpu_pre_run(CPUState *cpu)if (!vcpu->interruption_pending && cpu->interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) {if (cpu->interrupt_request &CPU_INTERRUPT_NMI ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_NMI ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_NMI ); vcpu->interruptable = false; new_int.InterruptionType = WHvX64PendingNmi; new_int.InterruptionPending =1 ; new_int.InterruptionVector =2 ; }if (cpu->interrupt_request &CPU_INTERRUPT_SMI ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_SMI ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_SMI ); } }
@@ -758,7 +758,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu) vcpu->interruptable && (env->eflags & IF_MASK)) {assert (!new_int.InterruptionPending);if (cpu->interrupt_request &CPU_INTERRUPT_HARD ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_HARD ); irq =cpu_get_pic_interrupt (env);if (irq >=0 ) { new_int.InterruptionType = WHvX64PendingInterrupt;
@@ -850,7 +850,7 @@ static void whpx_vcpu_process_async_events(CPUState *cpu) }if (cpu->interrupt_request &CPU_INTERRUPT_POLL ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );apic_poll_irq (x86_cpu->apic_state); }
@@ -868,7 +868,7 @@ static void whpx_vcpu_process_async_events(CPUState *cpu) }if (cpu->interrupt_request &CPU_INTERRUPT_TPR ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_TPR ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_TPR );if (!cpu->vcpu_dirty) {whpx_get_registers (cpu); }
Signature · 1 line
2.17.1
Re: [PATCH 02/35] target/i386: use cpu_reset_interrupt
Quoted 10 lines · Emilio G. Cota
From: Paolo Bonzini <[email protected]>
It will be changed to an atomic operation soon.
Cc Richard Henderson <[email protected]>Cc Eduardo Habkost <[email protected]>Cc Marcelo Tosatti <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
Quoted 8 lines
--- target/i386/hax-all.c | 4 ++-- target/i386/hvf/x86hvf.c | 8 ++++---- target/i386/kvm.c | 14 +++++++------- target/i386/seg_helper.c | 13 ++++++------- target/i386/svm_helper.c | 2 +- target/i386/whpx-all.c | 10 +++++----- 6 files changed, 25 insertions(+), 26 deletions(-)
r~
PATCH 8/35 target/arm: access cpu->interrupt_request with atomics
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- target/arm/cpu.c | 2 +- target/arm/helper.c | 12 +++++------- 2 files changed, 6 insertions(+), 8 deletions(-)
target/arm/cpu.c +1 -1
@@ -49,7 +49,7 @@ static bool arm_cpu_has_work(CPUState *cs)ARMCPU *cpu =ARM_CPU (cs);return (cpu->power_state !=PSCI_OFF ) - && cs->interrupt_request & + &&atomic_read (&cs->interrupt_request) & (CPU_INTERRUPT_FIQ |CPU_INTERRUPT_HARD |CPU_INTERRUPT_VFIQ |CPU_INTERRUPT_VIRQ |CPU_INTERRUPT_EXITTB );
target/arm/helper.c +5 -7
@@ -1293,12 +1293,13 @@ static void csselr_write(CPUARMState *env, const ARMCPRegInfo *ri,static uint64_t isr_read (CPUARMState *env,const ARMCPRegInfo *ri) {CPUState *cs =ENV_GET_CPU (env); +int interrupt_request =atomic_read (&cs->interrupt_request);uint64_t ret =0 ; -if (cs->interrupt_request &CPU_INTERRUPT_HARD ) { +if (interrupt_request &CPU_INTERRUPT_HARD ) { ret |=CPSR_I ; } -if (cs->interrupt_request &CPU_INTERRUPT_FIQ ) { +if (interrupt_request &CPU_INTERRUPT_FIQ ) { ret |=CPSR_F ; }/* External aborts are not possible in QEMU so A bit is always clear */
@@ -8514,10 +8515,7 @@ void arm_cpu_do_interrupt(CPUState *cs)return ; } -/* Hooks may change global state so BQL should be held, also the -* BQL needs to be held for any modification of -* cs->interrupt_request. -*/ +/* Hooks may change global state so BQL should be held */ g_assert (qemu_mutex_iothread_locked ());arm_call_pre_el_change_hook (cpu);
@@ -8532,7 +8530,7 @@ void arm_cpu_do_interrupt(CPUState *cs)arm_call_el_change_hook (cpu);if (!kvm_enabled ()) { - cs->interrupt_request |=CPU_INTERRUPT_EXITTB ; +atomic_or (&cs->interrupt_request,CPU_INTERRUPT_EXITTB ); } }
Signature · 1 line
2.17.1
PATCH 11/35 target/i386: access cpu->interrupt_request with atomics
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- target/i386/cpu.c | 7 ++++--- target/i386/helper.c | 4 ++-- target/i386/kvm.c | 44 +++++++++++++++++++++++----------------- target/i386/svm_helper.c | 4 ++-- 4 files changed, 33 insertions(+), 26 deletions(-)
target/i386/cpu.c +4 -3
@@ -5433,15 +5433,16 @@ static bool x86_cpu_has_work(CPUState *cs) {X86CPU *cpu =X86_CPU (cs);CPUX86State *env = &cpu->env; +int interrupt_request =atomic_read (&cs->interrupt_request); -return ((cs->interrupt_request & (CPU_INTERRUPT_HARD | +return ((interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_POLL )) && (env->eflags &IF_MASK )) || - (cs->interrupt_request & (CPU_INTERRUPT_NMI | + (interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_INIT |CPU_INTERRUPT_SIPI |CPU_INTERRUPT_MCE )) || - ((cs->interrupt_request &CPU_INTERRUPT_SMI ) && + ((interrupt_request &CPU_INTERRUPT_SMI ) && !(env->hflags &HF_SMM_MASK )); }
target/i386/helper.c +2 -2
@@ -1035,12 +1035,12 @@ void do_cpu_init(X86CPU *cpu)CPUState *cs =CPU (cpu);CPUX86State *env = &cpu->env;CPUX86State *save =g_new (CPUX86State,1 ); -int sipi = cs->interrupt_request &CPU_INTERRUPT_SIPI ; +int sipi =atomic_read (&cs->interrupt_request) &CPU_INTERRUPT_SIPI ; *save = *env;cpu_reset (cs); - cs->interrupt_request = sipi; +atomic_mb_set (&cs->interrupt_request, sipi);memcpy (&env->start_init_save, &save->start_init_save, offsetof(CPUX86State , end_init_save) - offsetof(CPUX86State , start_init_save));
target/i386/kvm.c +25 -19
126 lines not on this page · raw message
target/i386/svm_helper.c +2 -2
@@ -316,7 +316,7 @@ void helper_vmrun(CPUX86State *env, int aflag, int next_eip_addend)if (int_ctl &V_IRQ_MASK ) {CPUState *cs =CPU (x86_env_get_cpu (env)); - cs->interrupt_request |=CPU_INTERRUPT_VIRQ ; +atomic_or (&cs->interrupt_request,CPU_INTERRUPT_VIRQ ); }/* maybe we need to inject an event */
@@ -674,7 +674,7 @@ void do_vmexit(CPUX86State *env, uint32_t exit_code, uint64_t exit_info_1) env->vm_vmcb + offsetof(struct vmcb, control.int_ctl)); int_ctl &= ~(V_TPR_MASK |V_IRQ_MASK ); int_ctl |= env->v_tpr &V_TPR_MASK ; -if (cs->interrupt_request &CPU_INTERRUPT_VIRQ ) { +if (atomic_read (&cs->interrupt_request) &CPU_INTERRUPT_VIRQ ) { int_ctl |=V_IRQ_MASK ; } x86_stl_phys(cs,
Signature · 1 line
2.17.1
Re: [PATCH 11/35] target/i386: access cpu->interrupt_request with atomics
target/i386/helper.c void do_cpu_init(X86CPU *cpu) · line 1044
Quoted 4 lines · Emilio G. Cota
cpu_reset(cs);target/i386/helper.c +1
-1- cs->interrupt_request = sipi; +atomic_mb_set (&cs->interrupt_request, sipi); memcpy(&env->start_init_save, &save->start_init_save,
Why does this need a memory barrier?
Anyway, I think a bare mechanical conversion would be best for the first patch and then extra barriers added separately and with a description of why.
r~
Re: [PATCH 11/35] target/i386: access cpu->interrupt_request with atomics
Quoted 11 lines · Richard Henderson
target/i386/helper.c void do_cpu_init(X86CPU *cpu) · line 1044
Quoted 4 lines · Emilio G. Cota
cpu_reset(cs);target/i386/helper.c +1
-1- cs->interrupt_request = sipi; +atomic_mb_set (&cs->interrupt_request, sipi); memcpy(&env->start_init_save, &save->start_init_save,Why does this need a memory barrier?
Anyway, I think a bare mechanical conversion would be best for the first patch and then extra barriers added separately and with a description of why.
Almost no corresponding read has a barrier so it's hard to justify this one. I'll drop it.
Thanks,
Emilio
PATCH 32/35 target/i386/kvm: do not acquire the BQL to call cpu_reset_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
It's not needed anymore.
--- target/i386/kvm.c | 4 ---- 1 file changed, 4 deletions(-)
target/i386/kvm.c +0 -4
@@ -3007,9 +3007,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)/* Inject NMI */ if (interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) {if (interrupt_request &CPU_INTERRUPT_NMI ) { -qemu_mutex_lock_iothread ();cpu_reset_interrupt (cpu,CPU_INTERRUPT_NMI ); -qemu_mutex_unlock_iothread ();DPRINTF ("injected NMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_NMI );if (ret <0 ) {
@@ -3018,9 +3016,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) } }if (atomic_read (&cpu->interrupt_request) &CPU_INTERRUPT_SMI ) { -qemu_mutex_lock_iothread ();cpu_reset_interrupt (cpu,CPU_INTERRUPT_SMI ); -qemu_mutex_unlock_iothread ();DPRINTF ("injected SMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_SMI );if (ret <0 ) {
Signature · 1 line
2.17.1
Re: [PATCH 32/35] target/i386/kvm: do not acquire the BQL to call cpu_reset_interrupt
Quoted 10 lines · Emilio G. Cota
From: Paolo Bonzini <[email protected]>
It's not needed anymore.
Cc Marcelo Tosatti <[email protected]>Cc Richard Henderson <[email protected]>Cc Eduardo Habkost <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
Quoted 3 lines
--- target/i386/kvm.c | 4 ---- 1 file changed, 4 deletions(-)
r~
Re: [PATCH 32/35] target/i386/kvm: do not acquire the BQL to call cpu_reset_interrupt
In reply to Emilio G. CotaQuoted 10 lines · Emilio G. Cota
From: Paolo Bonzini <[email protected]>
It's not needed anymore.
Cc Marcelo Tosatti <[email protected]>Cc Richard Henderson <[email protected]>Cc Eduardo Habkost <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
Quoted 29 lines
--- target/i386/kvm.c | 4 ---- 1 file changed, 4 deletions(-)target/i386/kvm.c +0
-4@@ -3007,9 +3007,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)/* Inject NMI */ if (interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) {if (interrupt_request &CPU_INTERRUPT_NMI ) { -qemu_mutex_lock_iothread ();cpu_reset_interrupt (cpu,CPU_INTERRUPT_NMI ); -qemu_mutex_unlock_iothread ();DPRINTF ("injected NMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_NMI );if (ret <0 ) {@@ -3018,9 +3016,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) } }if (atomic_read (&cpu->interrupt_request) &CPU_INTERRUPT_SMI ) { -qemu_mutex_lock_iothread ();cpu_reset_interrupt (cpu,CPU_INTERRUPT_SMI ); -qemu_mutex_unlock_iothread ();DPRINTF ("injected SMI\n" ); ret =kvm_vcpu_ioctl (cpu,KVM_SMI );if (ret <0 ) {
PATCH 34/35 exec: push BQL down to cpu->do_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
cpu->do_interrupt can now be called with BQL held (from cpu->cpu_exec_interrupt) or without (from cpu_handle_exception).
Only a few targets rely on global device state in cc->do_interrupt; add checks to those targets to acquire the BQL if not already held.
--- accel/tcg/cpu-exec.c | 2 -- target/arm/helper.c | 28 ++++++++++++++++++++++++++-- target/ppc/excp_helper.c | 8 +++++++- target/s390x/excp_helper.c | 14 +++++++++++++- target/sh4/helper.c | 14 +++++++++++++- target/xtensa/helper.c | 16 ++++++++++++++-- 6 files changed, 73 insertions(+), 9 deletions(-)
accel/tcg/cpu-exec.c +0 -2
@@ -497,9 +497,7 @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret)#else if (replay_exception ()) {CPUClass *cc =CPU_GET_CLASS (cpu); -qemu_mutex_lock_iothread (); cc->do_interrupt (cpu); -qemu_mutex_unlock_iothread (); cpu->exception_index =-1 ; }else if (!replay_has_interrupt ()) {/* give a chance to iothread in replay mode */
target/arm/helper.c +26 -2
@@ -7644,7 +7644,8 @@ gen_invep:return false; } -void arm_v7m_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void arm_v7m_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;
@@ -7828,6 +7829,17 @@ void arm_v7m_cpu_do_interrupt(CPUState *cs)v7m_exception_taken (cpu, lr, false, ignore_stackfaults); } +void arm_v7m_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_v7m_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_v7m_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Function used to synchronize QEMU's AArch64 register set with AArch32 * register set. This is necessary when switching between AArch32 and AArch64 * execution state.
@@ -8482,8 +8494,9 @@ static inline bool check_for_semihosting(CPUState *cs)* Do any appropriate logging, handle PSCI calls, and then hand off * to the AArch64-entry or AArch32-entry function depending on the * target exception level's register width. +* Call with the BQL held. */ -void arm_cpu_do_interrupt (CPUState *cs) +static void arm_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;
@@ -8534,6 +8547,17 @@ void arm_cpu_do_interrupt(CPUState *cs) } } +void arm_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Return the exception level which controls this address translation regime */ static inline uint32_t regime_el (CPUARMState *env,ARMMMUIdx mmu_idx) {
target/ppc/excp_helper.c +7 -1
@@ -742,7 +742,13 @@ void ppc_cpu_do_interrupt(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -powerpc_excp (cpu, env->excp_model, cs->exception_index); +if (qemu_mutex_iothread_locked ()) { +powerpc_excp (cpu, env->excp_model, cs->exception_index); + }else { +qemu_mutex_lock_iothread (); +powerpc_excp (cpu, env->excp_model, cs->exception_index); +qemu_mutex_unlock_iothread (); + } }static void ppc_hw_interrupt (CPUPPCState *env)
target/s390x/excp_helper.c +13 -1
@@ -378,7 +378,8 @@ static void do_mchk_interrupt(CPUS390XState *env)load_psw (env, mask, addr); } -void s390_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void s390_cpu_do_interrupt_locked (CPUState *cs) {QEMUS390FLICState *flic =QEMU_S390_FLIC (s390_get_flic ());S390CPU *cpu =S390_CPU (cs);
@@ -457,6 +458,17 @@ try_deliver: } } +void s390_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +s390_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +s390_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +bool s390_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {if (interrupt_request &CPU_INTERRUPT_HARD ) {
target/sh4/helper.c +13 -1
@@ -79,7 +79,8 @@ int cpu_sh4_is_cached(CPUSH4State * env, target_ulong addr)#define MMU_DADDR_ERROR_READ (-12)#define MMU_DADDR_ERROR_WRITE (-13) -void superh_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void superh_cpu_do_interrupt_locked (CPUState *cs) {SuperHCPU *cpu =SUPERH_CPU (cs);CPUSH4State *env = &cpu->env;
@@ -211,6 +212,17 @@ void superh_cpu_do_interrupt(CPUState *cs) } } +void superh_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +superh_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +superh_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +static void update_itlb_use (CPUSH4State * env,int itlbnb) {uint8_t or_mask =0 , and_mask = (uint8_t ) -1 ;
target/xtensa/helper.c +14 -2
@@ -26,6 +26,7 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" #include "qemu/units.h" #include "cpu.h" #include "exec/exec-all.h"
@@ -251,8 +252,8 @@ static void handle_interrupt(CPUXtensaState *env) } } -/* Called from cpu_handle_interrupt with BQL held */ -void xtensa_cpu_do_interrupt (CPUState *cs) +/* Call with the BQL held */ +static void xtensa_cpu_do_interrupt_locked (CPUState *cs) {XtensaCPU *cpu =XTENSA_CPU (cs);CPUXtensaState *env = &cpu->env;
@@ -305,6 +306,17 @@ void xtensa_cpu_do_interrupt(CPUState *cs) }check_interrupts (env); } + +void xtensa_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +xtensa_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +xtensa_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +}#else void xtensa_cpu_do_interrupt (CPUState *cs) {
Signature · 1 line
2.17.1
Re: [PATCH 34/35] exec: push BQL down to cpu->do_interrupt
Quoted 29 lines · Emilio G. Cota
From: Paolo Bonzini <[email protected]>
cpu->do_interruptcan now be called with BQL held (fromcpu->cpu_exec_interrupt) or without (fromcpu_handle_exception).Only a few targets rely on global device state in
cc->do_interrupt; add checks to those targets to acquire the BQL if not already held.Cc Aleksandar Markovic <[email protected]>Cc Alexander Graf <[email protected]>Cc Anthony Green <[email protected]>Cc Artyom Tarasenko <[email protected]>Cc Aurelien Jarno <[email protected]>Cc Christian Borntraeger <[email protected]>Cc Chris Wulff <[email protected]>Cc Cornelia Huck <[email protected]>Cc David Gibson <[email protected]>Cc David Hildenbrand <[email protected]>Cc "Edgar E. Iglesias" <[email protected]>Cc Eduardo Habkost <[email protected]>Cc Guan Xuetao <[email protected]>Cc James Hogan <[email protected]>Cc Laurent Vivier <[email protected]>Cc Marcelo Tosatti <[email protected]>Cc Marek Vasut <[email protected]>Cc Mark Cave-Ayland <[email protected]>Cc Michael Walle <[email protected]>Cc Peter Crosthwaite <[email protected]>
Quoted 8 lines
Cc Peter Maydell <[email protected]>Cc Richard Henderson <[email protected]>Cc Stafford Horne <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
ppc parts
Quoted 208 lines
--- accel/tcg/cpu-exec.c | 2 -- target/arm/helper.c | 28 ++++++++++++++++++++++++++-- target/ppc/excp_helper.c | 8 +++++++- target/s390x/excp_helper.c | 14 +++++++++++++- target/sh4/helper.c | 14 +++++++++++++- target/xtensa/helper.c | 16 ++++++++++++++-- 6 files changed, 73 insertions(+), 9 deletions(-)accel/tcg/cpu-exec.c +0
-2@@ -497,9 +497,7 @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret)#else if (replay_exception ()) {CPUClass *cc =CPU_GET_CLASS (cpu); -qemu_mutex_lock_iothread (); cc->do_interrupt (cpu); -qemu_mutex_unlock_iothread (); cpu->exception_index =-1 ; }else if (!replay_has_interrupt ()) {/* give a chance to iothread in replay mode */ target/arm/helper.c +26
-2@@ -7644,7 +7644,8 @@ gen_invep:return false; } -void arm_v7m_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void arm_v7m_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;@@ -7828,6 +7829,17 @@ void arm_v7m_cpu_do_interrupt(CPUState *cs)v7m_exception_taken (cpu, lr, false, ignore_stackfaults); } +void arm_v7m_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_v7m_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_v7m_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Function used to synchronize QEMU's AArch64 register set with AArch32 * register set. This is necessary when switching between AArch32 and AArch64 * execution state. @@ -8482,8 +8494,9 @@ static inline bool check_for_semihosting(CPUState *cs)* Do any appropriate logging, handle PSCI calls, and then hand off * to the AArch64-entry or AArch32-entry function depending on the * target exception level's register width. +* Call with the BQL held. */ -void arm_cpu_do_interrupt (CPUState *cs) +static void arm_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;@@ -8534,6 +8547,17 @@ void arm_cpu_do_interrupt(CPUState *cs) } } +void arm_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Return the exception level which controls this address translation regime */ static inline uint32_t regime_el (CPUARMState *env,ARMMMUIdx mmu_idx) {target/ppc/excp_helper.c +7
-1@@ -742,7 +742,13 @@ void ppc_cpu_do_interrupt(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -powerpc_excp (cpu, env->excp_model, cs->exception_index); +if (qemu_mutex_iothread_locked ()) { +powerpc_excp (cpu, env->excp_model, cs->exception_index); + }else { +qemu_mutex_lock_iothread (); +powerpc_excp (cpu, env->excp_model, cs->exception_index); +qemu_mutex_unlock_iothread (); + } }static void ppc_hw_interrupt (CPUPPCState *env)target/s390x/excp_helper.c +13
-1@@ -378,7 +378,8 @@ static void do_mchk_interrupt(CPUS390XState *env)load_psw (env, mask, addr); } -void s390_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void s390_cpu_do_interrupt_locked (CPUState *cs) {QEMUS390FLICState *flic =QEMU_S390_FLIC (s390_get_flic ());S390CPU *cpu =S390_CPU (cs);@@ -457,6 +458,17 @@ try_deliver: } } +void s390_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +s390_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +s390_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +bool s390_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {if (interrupt_request &CPU_INTERRUPT_HARD ) {target/sh4/helper.c +13
-1@@ -79,7 +79,8 @@ int cpu_sh4_is_cached(CPUSH4State * env, target_ulong addr)#define MMU_DADDR_ERROR_READ (-12)#define MMU_DADDR_ERROR_WRITE (-13) -void superh_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void superh_cpu_do_interrupt_locked (CPUState *cs) {SuperHCPU *cpu =SUPERH_CPU (cs);CPUSH4State *env = &cpu->env;@@ -211,6 +212,17 @@ void superh_cpu_do_interrupt(CPUState *cs) } } +void superh_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +superh_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +superh_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +static void update_itlb_use (CPUSH4State * env,int itlbnb) {uint8_t or_mask =0 , and_mask = (uint8_t ) -1 ;target/xtensa/helper.c +14
-2@@ -26,6 +26,7 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" #include "qemu/units.h" #include "cpu.h" #include "exec/exec-all.h" @@ -251,8 +252,8 @@ static void handle_interrupt(CPUXtensaState *env) } } -/* Called from cpu_handle_interrupt with BQL held */ -void xtensa_cpu_do_interrupt (CPUState *cs) +/* Call with the BQL held */ +static void xtensa_cpu_do_interrupt_locked (CPUState *cs) {XtensaCPU *cpu =XTENSA_CPU (cs);CPUXtensaState *env = &cpu->env;@@ -305,6 +306,17 @@ void xtensa_cpu_do_interrupt(CPUState *cs) }check_interrupts (env); } + +void xtensa_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +xtensa_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +xtensa_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +}#else void xtensa_cpu_do_interrupt (CPUState *cs) {
Signature · 4 lines
David Gibson | I'll have my music baroque, and my code david AT gibson.dropbear.id.au | minimalist, thank you. NOT _the_ _other_ | _way_ _around_! http://www.ozlabs.org/~dgibson
Re: [PATCH 34/35] exec: push BQL down to cpu->do_interrupt
In reply to Emilio G. CotaAm 17.09.18 um 18:31 schrieb Emilio G. Cota:
Quoted 159 lines
From: Paolo Bonzini <[email protected]>
cpu->do_interruptcan now be called with BQL held (fromcpu->cpu_exec_interrupt) or without (fromcpu_handle_exception).Only a few targets rely on global device state in
cc->do_interrupt; add checks to those targets to acquire the BQL if not already held.Cc Aleksandar Markovic <[email protected]>Cc Alexander Graf <[email protected]>Cc Anthony Green <[email protected]>Cc Artyom Tarasenko <[email protected]>Cc Aurelien Jarno <[email protected]>Cc Christian Borntraeger <[email protected]>Cc Chris Wulff <[email protected]>Cc Cornelia Huck <[email protected]>Cc David Gibson <[email protected]>Cc David Hildenbrand <[email protected]>Cc "Edgar E. Iglesias" <[email protected]>Cc Eduardo Habkost <[email protected]>Cc Guan Xuetao <[email protected]>Cc James Hogan <[email protected]>Cc Laurent Vivier <[email protected]>Cc Marcelo Tosatti <[email protected]>Cc Marek Vasut <[email protected]>Cc Mark Cave-Ayland <[email protected]>Cc Michael Walle <[email protected]>Cc Peter Crosthwaite <[email protected]>Cc Peter Maydell <[email protected]>Cc Richard Henderson <[email protected]>Cc Stafford Horne <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>--- accel/tcg/cpu-exec.c | 2 -- target/arm/helper.c | 28 ++++++++++++++++++++++++++-- target/ppc/excp_helper.c | 8 +++++++- target/s390x/excp_helper.c | 14 +++++++++++++- target/sh4/helper.c | 14 +++++++++++++- target/xtensa/helper.c | 16 ++++++++++++++-- 6 files changed, 73 insertions(+), 9 deletions(-)accel/tcg/cpu-exec.c +0
-2@@ -497,9 +497,7 @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret)#else if (replay_exception ()) {CPUClass *cc =CPU_GET_CLASS (cpu); -qemu_mutex_lock_iothread (); cc->do_interrupt (cpu); -qemu_mutex_unlock_iothread (); cpu->exception_index =-1 ; }else if (!replay_has_interrupt ()) {/* give a chance to iothread in replay mode */ target/arm/helper.c +26
-2@@ -7644,7 +7644,8 @@ gen_invep:return false; } -void arm_v7m_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void arm_v7m_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;@@ -7828,6 +7829,17 @@ void arm_v7m_cpu_do_interrupt(CPUState *cs)v7m_exception_taken (cpu, lr, false, ignore_stackfaults); } +void arm_v7m_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_v7m_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_v7m_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Function used to synchronize QEMU's AArch64 register set with AArch32 * register set. This is necessary when switching between AArch32 and AArch64 * execution state. @@ -8482,8 +8494,9 @@ static inline bool check_for_semihosting(CPUState *cs)* Do any appropriate logging, handle PSCI calls, and then hand off * to the AArch64-entry or AArch32-entry function depending on the * target exception level's register width. +* Call with the BQL held. */ -void arm_cpu_do_interrupt (CPUState *cs) +static void arm_cpu_do_interrupt_locked (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);CPUARMState *env = &cpu->env;@@ -8534,6 +8547,17 @@ void arm_cpu_do_interrupt(CPUState *cs) } } +void arm_cpu_do_interrupt (CPUState *cs) +{ +if (qemu_mutex_iothread_locked ()) { +arm_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +arm_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +/* Return the exception level which controls this address translation regime */ static inline uint32_t regime_el (CPUARMState *env,ARMMMUIdx mmu_idx) {target/ppc/excp_helper.c +7
-1@@ -742,7 +742,13 @@ void ppc_cpu_do_interrupt(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -powerpc_excp (cpu, env->excp_model, cs->exception_index); +if (qemu_mutex_iothread_locked ()) { +powerpc_excp (cpu, env->excp_model, cs->exception_index); + }else { +qemu_mutex_lock_iothread (); +powerpc_excp (cpu, env->excp_model, cs->exception_index); +qemu_mutex_unlock_iothread (); + } }static void ppc_hw_interrupt (CPUPPCState *env)target/s390x/excp_helper.c +3
-1@@ -378,7 +378,8 @@ static void do_mchk_interrupt(CPUS390XState *env)load_psw (env, mask, addr); } -void s390_cpu_do_interrupt (CPUState *cs) +/* call with the BQL held */ +static void s390_cpu_do_interrupt_locked (CPUState *cs) {QEMUS390FLICState *flic =QEMU_S390_FLIC (s390_get_flic ());S390CPU *cpu =S390_CPU (cs);@@ -457,6 +458,17 @@ try_deliver: } } +void s390_cpu_do_interrupt (CPUState *cs)
target/s390x/excp_helper.c try_deliver: · line 471
Quoted 10 lines
target/s390x/excp_helper.c +10
-0+{ +if (qemu_mutex_iothread_locked ()) { +s390_cpu_do_interrupt_locked (cs); + }else { +qemu_mutex_lock_iothread (); +s390_cpu_do_interrupt_locked (cs); +qemu_mutex_unlock_iothread (); + } +} +
Yes, due to floating interrupts we need the iothread lock. This change looks sane to me from an s390x perspective:
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH 34/35] exec: push BQL down to cpu->do_interrupt
In reply to Emilio G. CotaQuoted 37 lines · On Mon, 17 Sep 2018 12:31:02 -0400 "Emilio G. Cota" <[email protected]> wrote:
From: Paolo Bonzini <[email protected]>
cpu->do_interruptcan now be called with BQL held (fromcpu->cpu_exec_interrupt) or without (fromcpu_handle_exception).Only a few targets rely on global device state in
cc->do_interrupt; add checks to those targets to acquire the BQL if not already held.Cc Aleksandar Markovic <[email protected]>Cc Alexander Graf <[email protected]>Cc Anthony Green <[email protected]>Cc Artyom Tarasenko <[email protected]>Cc Aurelien Jarno <[email protected]>Cc Christian Borntraeger <[email protected]>Cc Chris Wulff <[email protected]>Cc Cornelia Huck <[email protected]>Cc David Gibson <[email protected]>Cc David Hildenbrand <[email protected]>Cc "Edgar E. Iglesias" <[email protected]>Cc Eduardo Habkost <[email protected]>Cc Guan Xuetao <[email protected]>Cc James Hogan <[email protected]>Cc Laurent Vivier <[email protected]>Cc Marcelo Tosatti <[email protected]>Cc Marek Vasut <[email protected]>Cc Mark Cave-Ayland <[email protected]>Cc Michael Walle <[email protected]>Cc Peter Crosthwaite <[email protected]>Cc Peter Maydell <[email protected]>Cc Richard Henderson <[email protected]>Cc Stafford Horne <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
Quoted 8 lines
--- accel/tcg/cpu-exec.c | 2 -- target/arm/helper.c | 28 ++++++++++++++++++++++++++-- target/ppc/excp_helper.c | 8 +++++++- target/s390x/excp_helper.c | 14 +++++++++++++- target/sh4/helper.c | 14 +++++++++++++- target/xtensa/helper.c | 16 ++++++++++++++-- 6 files changed, 73 insertions(+), 9 deletions(-)
s390x parts:
PATCH 35/35 exec: push BQL down to cpu->cpu_exec_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
Most interrupt requests do not need to take the BQL, and in fact most architectures do not need it at all. Push the BQL acquisition down to target code.
--- docs/devel/multi-thread-tcg.txt | 7 +++++-- accel/tcg/cpu-exec.c | 9 +-------- target/arm/cpu.c | 15 ++++++++++++++- target/i386/seg_helper.c | 3 +++ target/ppc/excp_helper.c | 2 ++ target/s390x/excp_helper.c | 3 +++ 6 files changed, 28 insertions(+), 11 deletions(-)
docs/devel/multi-thread-tcg.txt +5 -2
@@ -231,8 +231,11 @@ BQL. Currently ARM targets serialise all ARM_CP_IO register accesses and also defer the reset/startup of vCPUs to the vCPU context by way of async_run_on_cpu(). -Updates to interrupt state are also protected by the BQL as they can -often be cross vCPU. +The CPUClass callbacks cpu_exec_interrupt and do_interrupt are invoked +without BQL protection. Accesses to the interrupt controller from +the vCPU thread, for example while processing CPU_INTERRUPT_HARD, must +either call qemu_mutex_lock_iothread/qemu_mutex_unlock_iothread or use +a separate mutex. Memory Consistency ==================
accel/tcg/cpu-exec.c +1 -8
@@ -524,7 +524,7 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,if (unlikely (atomic_read (&cpu->interrupt_request))) {int interrupt_request; -qemu_mutex_lock_iothread (); + interrupt_request =atomic_read (&cpu->interrupt_request);if (unlikely (cpu->singlestep_enabled &SSTEP_NOIRQ )) {/* Mask out external interrupts for this step. */
@@ -533,7 +533,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,if (interrupt_request &CPU_INTERRUPT_DEBUG ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_DEBUG ); cpu->exception_index =EXCP_DEBUG ; -qemu_mutex_unlock_iothread ();return true; }if (replay_mode ==REPLAY_MODE_PLAY && !replay_has_interrupt ()) {
@@ -543,7 +542,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,cpu_reset_interrupt (cpu,CPU_INTERRUPT_HALT ); cpu->halted =1 ; cpu->exception_index =EXCP_HLT ; -qemu_mutex_unlock_iothread ();return true; }#if defined(TARGET_I386 )
@@ -554,14 +552,12 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,cpu_svm_check_intercept_param (env,SVM_EXIT_INIT ,0 ,0 );do_cpu_init (x86_cpu); cpu->exception_index =EXCP_HALTED ; -qemu_mutex_unlock_iothread ();return true; }#else else if (interrupt_request & CPU_INTERRUPT_RESET) {replay_interrupt ();cpu_reset (cpu); -qemu_mutex_unlock_iothread ();return true; }#endif
@@ -585,9 +581,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,the program flow was changed */ *last_tb =NULL ; } - -/* If we exit via cpu_loop_exit/longjmp it is reset in cpu_exec */ -qemu_mutex_unlock_iothread (); }/* Finally, check if we need to exit to the main loop. */
target/arm/cpu.c +14 -1
@@ -347,7 +347,8 @@ static void arm_cpu_reset(CPUState *s)hw_watchpoint_update_all (cpu); } -bool arm_cpu_exec_interrupt (CPUState *cs,int interrupt_request) +/* call with the BQL held */ +static bool arm_cpu_exec_interrupt_locked (CPUState *cs,int interrupt_request) {CPUClass *cc =CPU_GET_CLASS (cs);CPUARMState *env = cs->env_ptr;
@@ -401,6 +402,16 @@ bool arm_cpu_exec_interrupt(CPUState *cs, int interrupt_request)return ret; } +bool arm_cpu_exec_interrupt (CPUState *cs,int interrupt_request) +{ +bool ret; + +qemu_mutex_lock_iothread (); + ret =arm_cpu_exec_interrupt_locked (cs, interrupt_request); +qemu_mutex_unlock_iothread (); +return ret; +} +#if !defined(CONFIG_USER_ONLY ) || !defined(TARGET_AARCH64 )static bool arm_v7m_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {
@@ -409,6 +420,7 @@ static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request)CPUARMState *env = &cpu->env;bool ret = false; +qemu_mutex_lock_iothread ();/* ARMv7-M interrupt masking works differently than -A or -R. * There is no FIQ/IRQ distinction. Instead of I and F bits * masking FIQ and IRQ interrupts, an exception is taken only
@@ -422,6 +434,7 @@ static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request) cc->do_interrupt (cs); ret = true; } +qemu_mutex_unlock_iothread ();return ret; }#endif
target/i386/seg_helper.c +3 -0
@@ -19,6 +19,7 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" #include "cpu.h" #include "qemu/log.h" #include "exec/helper-proto.h"
@@ -1324,7 +1325,9 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)#if !defined(CONFIG_USER_ONLY )if (interrupt_request &CPU_INTERRUPT_POLL ) {cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL ); +qemu_mutex_lock_iothread ();apic_poll_irq (cpu->apic_state); +qemu_mutex_unlock_iothread ();/* Don't process multiple interrupt requests in a single call. This is required to make icount-driven execution deterministic. */ return true;
target/ppc/excp_helper.c +2 -0
@@ -885,10 +885,12 @@ bool ppc_cpu_exec_interrupt(CPUState *cs, int interrupt_request)CPUPPCState *env = &cpu->env;if (interrupt_request &CPU_INTERRUPT_HARD ) { +qemu_mutex_lock_iothread ();ppc_hw_interrupt (env);if (env->pending_interrupts ==0 ) {cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); } +qemu_mutex_unlock_iothread ();return true; }return false;
target/s390x/excp_helper.c +3 -0
@@ -480,10 +480,13 @@ bool s390_cpu_exec_interrupt(CPUState *cs, int interrupt_request)the parent EXECUTE insn. */ return false; } +qemu_mutex_lock_iothread ();if (s390_cpu_has_int (cpu)) {s390_cpu_do_interrupt (cs); +qemu_mutex_unlock_iothread ();return true; } +qemu_mutex_unlock_iothread ();if (env->psw.mask &PSW_MASK_WAIT ) {/* Woken up because of a floating interrupt but it has already * been delivered. Go back to sleep. */
Signature · 1 line
2.17.1
Re: [PATCH 35/35] exec: push BQL down to cpu->cpu_exec_interrupt
Quoted 27 lines · Emilio G. Cota
From: Paolo Bonzini <[email protected]>
Most interrupt requests do not need to take the BQL, and in fact most architectures do not need it at all. Push the BQL acquisition down to target code.
Cc Aleksandar Markovic <[email protected]>Cc Alexander Graf <[email protected]>Cc Anthony Green <[email protected]>Cc Artyom Tarasenko <[email protected]>Cc Aurelien Jarno <[email protected]>Cc Christian Borntraeger <[email protected]>Cc Chris Wulff <[email protected]>Cc Cornelia Huck <[email protected]>Cc David Gibson <[email protected]>Cc David Hildenbrand <[email protected]>Cc "Edgar E. Iglesias" <[email protected]>Cc Eduardo Habkost <[email protected]>Cc Guan Xuetao <[email protected]>Cc James Hogan <[email protected]>Cc Laurent Vivier <[email protected]>Cc Marcelo Tosatti <[email protected]>Cc Marek Vasut <[email protected]>Cc Mark Cave-Ayland <[email protected]>Cc Michael Walle <[email protected]>Cc Peter Crosthwaite <[email protected]>
Quoted 8 lines
Cc Peter Maydell <[email protected]>Cc Richard Henderson <[email protected]>Cc Stafford Horne <[email protected]>Signed-off-by Paolo Bonzini <[email protected]>Signed-off-by Emilio G. Cota <[email protected]>
ppc parts
Quoted 185 lines
--- docs/devel/multi-thread-tcg.txt | 7 +++++-- accel/tcg/cpu-exec.c | 9 +-------- target/arm/cpu.c | 15 ++++++++++++++- target/i386/seg_helper.c | 3 +++ target/ppc/excp_helper.c | 2 ++ target/s390x/excp_helper.c | 3 +++ 6 files changed, 28 insertions(+), 11 deletions(-)docs/devel/multi-thread-tcg.txt +5
-2@@ -231,8 +231,11 @@ BQL. Currently ARM targets serialise all ARM_CP_IO register accesses and also defer the reset/startup of vCPUs to the vCPU context by way of async_run_on_cpu(). -Updates to interrupt state are also protected by the BQL as they can -often be cross vCPU. +The CPUClass callbacks cpu_exec_interrupt and do_interrupt are invoked +without BQL protection. Accesses to the interrupt controller from +the vCPU thread, for example while processing CPU_INTERRUPT_HARD, must +either call qemu_mutex_lock_iothread/qemu_mutex_unlock_iothread or use +a separate mutex. Memory Consistency ==================accel/tcg/cpu-exec.c +1
-8@@ -524,7 +524,7 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,if (unlikely (atomic_read (&cpu->interrupt_request))) {int interrupt_request; -qemu_mutex_lock_iothread (); + interrupt_request =atomic_read (&cpu->interrupt_request);if (unlikely (cpu->singlestep_enabled &SSTEP_NOIRQ )) {/* Mask out external interrupts for this step. */ @@ -533,7 +533,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,if (interrupt_request &CPU_INTERRUPT_DEBUG ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_DEBUG ); cpu->exception_index =EXCP_DEBUG ; -qemu_mutex_unlock_iothread ();return true; }if (replay_mode ==REPLAY_MODE_PLAY && !replay_has_interrupt ()) {@@ -543,7 +542,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,cpu_reset_interrupt (cpu,CPU_INTERRUPT_HALT ); cpu->halted =1 ; cpu->exception_index =EXCP_HLT ; -qemu_mutex_unlock_iothread ();return true; }#if defined(TARGET_I386 )@@ -554,14 +552,12 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,cpu_svm_check_intercept_param (env,SVM_EXIT_INIT ,0 ,0 );do_cpu_init (x86_cpu); cpu->exception_index =EXCP_HALTED ; -qemu_mutex_unlock_iothread ();return true; }#else else if (interrupt_request & CPU_INTERRUPT_RESET) {replay_interrupt ();cpu_reset (cpu); -qemu_mutex_unlock_iothread ();return true; }#endif @@ -585,9 +581,6 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,the program flow was changed */ *last_tb =NULL ; } - -/* If we exit via cpu_loop_exit/longjmp it is reset in cpu_exec */ -qemu_mutex_unlock_iothread (); }/* Finally, check if we need to exit to the main loop. */ target/arm/cpu.c +14
-1@@ -347,7 +347,8 @@ static void arm_cpu_reset(CPUState *s)hw_watchpoint_update_all (cpu); } -bool arm_cpu_exec_interrupt (CPUState *cs,int interrupt_request) +/* call with the BQL held */ +static bool arm_cpu_exec_interrupt_locked (CPUState *cs,int interrupt_request) {CPUClass *cc =CPU_GET_CLASS (cs);CPUARMState *env = cs->env_ptr;@@ -401,6 +402,16 @@ bool arm_cpu_exec_interrupt(CPUState *cs, int interrupt_request)return ret; } +bool arm_cpu_exec_interrupt (CPUState *cs,int interrupt_request) +{ +bool ret; + +qemu_mutex_lock_iothread (); + ret =arm_cpu_exec_interrupt_locked (cs, interrupt_request); +qemu_mutex_unlock_iothread (); +return ret; +} +#if !defined(CONFIG_USER_ONLY ) || !defined(TARGET_AARCH64 )static bool arm_v7m_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {@@ -409,6 +420,7 @@ static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request)CPUARMState *env = &cpu->env;bool ret = false; +qemu_mutex_lock_iothread ();/* ARMv7-M interrupt masking works differently than -A or -R. * There is no FIQ/IRQ distinction. Instead of I and F bits * masking FIQ and IRQ interrupts, an exception is taken only @@ -422,6 +434,7 @@ static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request) cc->do_interrupt (cs); ret = true; } +qemu_mutex_unlock_iothread ();return ret; }#endif target/i386/seg_helper.c +3
-0@@ -19,6 +19,7 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" #include "cpu.h" #include "qemu/log.h" #include "exec/helper-proto.h" @@ -1324,7 +1325,9 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)#if !defined(CONFIG_USER_ONLY )if (interrupt_request &CPU_INTERRUPT_POLL ) {cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL ); +qemu_mutex_lock_iothread ();apic_poll_irq (cpu->apic_state); +qemu_mutex_unlock_iothread ();/* Don't process multiple interrupt requests in a single call. This is required to make icount-driven execution deterministic. */ return true;target/ppc/excp_helper.c +2
-0@@ -885,10 +885,12 @@ bool ppc_cpu_exec_interrupt(CPUState *cs, int interrupt_request)CPUPPCState *env = &cpu->env;if (interrupt_request &CPU_INTERRUPT_HARD ) { +qemu_mutex_lock_iothread ();ppc_hw_interrupt (env);if (env->pending_interrupts ==0 ) {cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); } +qemu_mutex_unlock_iothread ();return true; }return false;target/s390x/excp_helper.c +3
-0@@ -480,10 +480,13 @@ bool s390_cpu_exec_interrupt(CPUState *cs, int interrupt_request)the parent EXECUTE insn. */ return false; } +qemu_mutex_lock_iothread ();if (s390_cpu_has_int (cpu)) {s390_cpu_do_interrupt (cs); +qemu_mutex_unlock_iothread ();return true; } +qemu_mutex_unlock_iothread ();if (env->psw.mask &PSW_MASK_WAIT ) {/* Woken up because of a floating interrupt but it has already * been delivered. Go back to sleep. */
Signature · 4 lines
David Gibson | I'll have my music baroque, and my code david AT gibson.dropbear.id.au | minimalist, thank you. NOT _the_ _other_ | _way_ _around_! http://www.ozlabs.org/~dgibson
Re: [PATCH 35/35] exec: push BQL down to cpu->cpu_exec_interrupt
In reply to Emilio G. Cotatarget/s390x/excp_helper.c bool s390_cpu_exec_interrupt(CPUState *cs, int interrupt_request) · line 485
Quoted 13 lines
return false;target/s390x/excp_helper.c +1
-0@@ -480,10 +480,13 @@ bool s390_cpu_exec_interrupt(CPUState *cs, int interrupt_request)the parent EXECUTE insn. */ return false; } +qemu_mutex_lock_iothread ();if (s390_cpu_has_int (cpu)) {s390_cpu_do_interrupt (cs);
You can directly use s390_cpu_do_interrupt_locked() here.
Quoted 8 lines
target/s390x/excp_helper.c +2
-0+qemu_mutex_unlock_iothread ();return true; } +qemu_mutex_unlock_iothread ();if (env->psw.mask &PSW_MASK_WAIT ) {/* Woken up because of a floating interrupt but it has already * been delivered. Go back to sleep. */
Signature · 3 lines
Thanks, David / dhildenb
Am 17.09.18 um 18:30 schrieb Emilio G. Cota:
Quoted 48 lines
This series comes originally from a series of patches that Paolo sent to me a long time ago. I have kept most of his S-o-b tags, but I have done the forward port of the patches to the current QEMU code base, so please blame all possible bugs on me, not him.
The goal of this series is to push the BQL out of interrupt handling wherever possible. Many targets do not need the BQL to handle interrupts, so for those targets we get rid of the BQL in interrupt handling. In TCG mode, this by itself does not yield measurable performance gains. However, it is a necessary first step before tackling BQL contention when managing CPU states (i.e. exiting the exec loop always involves taking the BQL, which does not scale).
The patches:
- Patch 0 accesses icount_decr.u16 consistently with atomics. This is important because we use it across threads to signal that an interrupt is pending.
- 2-28: convert direct callers of
cpu->interrupt_requestto use atomic accesses or CPU helper functions that use atomics. I have broken these up into individual patches to ease review. Note that in some cases I have added manyatomic_reads, most of which are probably unnecessary. However, I'd leave this up to the maintainers, since I do not want to break things by doing a singleatomic_read(&cpu->interrupt_request)at the beginning of a function and then miss subsequent updates tocpu->interrupt_request.- 29-31: drop the BQL requirement when handling
cpu->interrupt_request- 32-33: drop now unnecessary BQL acquisitions in i386 and ppc
- 34-35: push down the BQL acquisition to
cpu->do_interruptandcpu->cpu_exec_interrupt. Here I am Cc'ing everyone so that we can make sure I am not missing any target that requires the BQL on eitherdo_interruptorcpu_exec_interrupt.This series is checkpatch-clean, and can be fetched from:
https://github.com/cota/qemu/tree/cpu-lockNote that the series applies on top of patches that are already on the qemu-devel list and will hopefully soon be upstream. This series begins after commit
4ece0cbd74("cpus: access .qemu_icount_bias with atomic64") in that tree.
Quoted 4 lines
Thanks,
Emilio
I just did a (very slow) make -j32 of QEMU on my 16 core notebook inside a MTTCG s390x-softmmu guest with 32 VCPUs. I used the same test when reworking floating interrupt support to make sure there are no races.
As I got no deadlock, I assume you series does not break anything for s390x.
Thanks!
Signature · 3 lines
Thanks, David / dhildenb
Quoted 39 lines · Emilio G. Cota
This series comes originally from a series of patches that Paolo sent to me a long time ago. I have kept most of his S-o-b tags, but I have done the forward port of the patches to the current QEMU code base, so please blame all possible bugs on me, not him.
The goal of this series is to push the BQL out of interrupt handling wherever possible. Many targets do not need the BQL to handle interrupts, so for those targets we get rid of the BQL in interrupt handling. In TCG mode, this by itself does not yield measurable performance gains. However, it is a necessary first step before tackling BQL contention when managing CPU states (i.e. exiting the exec loop always involves taking the BQL, which does not scale).
The patches:
- Patch 0 accesses icount_decr.u16 consistently with atomics. This is important because we use it across threads to signal that an interrupt is pending.
- 2-28: convert direct callers of
cpu->interrupt_requestto use atomic accesses or CPU helper functions that use atomics. I have broken these up into individual patches to ease review. Note that in some cases I have added manyatomic_reads, most of which are probably unnecessary. However, I'd leave this up to the maintainers, since I do not want to break things by doing a singleatomic_read(&cpu->interrupt_request)at the beginning of a function and then miss subsequent updates tocpu->interrupt_request.- 29-31: drop the BQL requirement when handling
cpu->interrupt_request- 32-33: drop now unnecessary BQL acquisitions in i386 and ppc
- 34-35: push down the BQL acquisition to
cpu->do_interruptandcpu->cpu_exec_interrupt. Here I am Cc'ing everyone so that we can make sure I am not missing any target that requires the BQL on eitherdo_interruptorcpu_exec_interrupt.
Quoted 8 lines
This series is checkpatch-clean, and can be fetched from:
https://github.com/cota/qemu/tree/cpu-lockNote that the series applies on top of patches that are already on the qemu-devel list and will hopefully soon be upstream. This series begins after commit
4ece0cbd74("cpus: access .qemu_icount_bias with atomic64") in that tree.
I ran the above cpu-lock branch through my SPARC32 and SPARC64 test suite just to be sure, and everything appeared to work fine. So for the SPARC32/64 patches:
ATB,
Mark.