per-CPU locks
v7 cover per-CPU locks
v6: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg07650.html
All patches in the series have reviews now. Thanks everyone!
I've tested all patches with `make check-qtest -j' for all targets. The series is checkpatch-clean (just some warnings about __COVERITY__).
You can fetch the series from:
https://github.com/cota/qemu/tree/cpu-lock-v7
---v6->v7:
- Rebase on master
- Add a cpu_halted_set call to arm code that wasn't there in v6
- Add R-b's and Ack's.
- Add comment to patch 3's log to explain why the bitmap is added there, even though it only gains a user at the end of the series.
- Fix "prevent deadlock" comments before assertions; use "enforce locking order" instead, which is more accurate.
- Add a few more comments, as suggested by Alex.
v6->v7 diff (before rebase) below.
Thanks,
Emilio
---
accel/tcg/cpu-exec.c +1 -1
@@ -435,7 +435,7 @@ static inline bool cpu_handle_halt_locked(CPUState *cpu) && replay_interrupt()) {X86CPU *x86_cpu =X86_CPU (cpu); -/* prevent deadlock; cpu_mutex must be acquired _after_ the BQL */ +/* locking order: cpu_mutex must be acquired _after_ the BQL */ cpu_mutex_unlock (cpu);qemu_mutex_lock_iothread ();cpu_mutex_lock (cpu);
cpus.c +1 -1
@@ -2062,7 +2062,7 @@ void qemu_mutex_lock_iothread_impl(const char *file, int line) {QemuMutexLockFunc bql_lock =atomic_read (&qemu_bql_mutex_lock_func); -/* prevent deadlock with CPU mutex */ +/* enforce locking order */ g_assert (no_cpu_mutex_locked ());g_assert (!qemu_mutex_iothread_locked ());
include/qom/cpu.h +3 -1
@@ -322,7 +322,8 @@ struct qemu_work_item;* @mem_io_pc: Host Program Counter at which the memory was accessed. * @mem_io_vaddr: Target virtual address at which the memory was accessed. * @kvm_fd: vCPU file descriptor for KVM. -* @lock: Lock to prevent multiple access to per-CPU fields. +* @lock: Lock to prevent multiple access to per-CPU fields. Must be acquired +* after the BQL. * @cond: Condition variable for per-CPU events. * @work_list: List of pending asynchronous work. * @halted: Nonzero if the CPU is in suspended state.
@@ -804,6 +805,7 @@ static inline bool cpu_has_work(CPUState *cpu)bool (*func)(CPUState *cpu);bool ret; +/* some targets require us to hold the BQL when checking for work */ if (cc->has_work_with_iothread_lock) {if (qemu_mutex_iothread_locked ()) { func = cc->has_work_with_iothread_lock;
target/i386/kvm.c +4 -0
@@ -3216,6 +3216,10 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)qemu_mutex_lock_iothread (); } +/* +* We might have cleared some bits in cpu->interrupt_request since reading +* it; read it again. +*/ interrupt_request =cpu_interrupt_request (cpu);/* Force the VCPU out of its inner loop to process any INIT requests
PATCH v7 1/73 cpu: convert queued work to a QSIMPLEQ
Instead of open-coding it.
While at it, make sure that all accesses to the list are performed while holding the list's lock.
--- include/qom/cpu.h | 6 +++--- cpus-common.c | 25 ++++++++----------------- cpus.c | 14 ++++++++++++-- qom/cpu.c | 1 + 4 files changed, 24 insertions(+), 22 deletions(-)
include/qom/cpu.h +3 -3
@@ -333,8 +333,8 @@ struct qemu_work_item;* @mem_io_pc: Host Program Counter at which the memory was accessed. * @mem_io_vaddr: Target virtual address at which the memory was accessed. * @kvm_fd: vCPU file descriptor for KVM. -* @work_mutex: Lock to prevent multiple access to queued_work_*. -* @queued_work_first: First asynchronous work pending. +* @work_mutex: Lock to prevent multiple access to @work_list. +* @work_list: List of pending asynchronous work. * @trace_dstate_delayed: Delayed changes to trace_dstate (includes all changes * to @trace_dstate). * @trace_dstate: Dynamic tracing state of events for this vCPU (bitmask).
@@ -375,7 +375,7 @@ struct CPUState {sigjmp_buf jmp_env;QemuMutex work_mutex; -struct qemu_work_item *queued_work_first, *queued_work_last; + QSIMPLEQ_HEAD(, qemu_work_item) work_list;CPUAddressSpace *cpu_ases;int num_ases;
cpus-common.c +8 -17
@@ -107,7 +107,7 @@ void cpu_list_remove(CPUState *cpu) }struct qemu_work_item { -struct qemu_work_item *next; +QSIMPLEQ_ENTRY (qemu_work_item) node;run_on_cpu_func func;run_on_cpu_data data;bool free, exclusive, done;
@@ -116,13 +116,7 @@ struct qemu_work_item {static void queue_work_on_cpu (CPUState *cpu,struct qemu_work_item *wi) {qemu_mutex_lock (&cpu->work_mutex); -if (cpu->queued_work_first ==NULL ) { - cpu->queued_work_first = wi; - }else { - cpu->queued_work_last->next = wi; - } - cpu->queued_work_last = wi; - wi->next =NULL ; +QSIMPLEQ_INSERT_TAIL (&cpu->work_list, wi, node); wi->done = false;qemu_mutex_unlock (&cpu->work_mutex);
@@ -314,17 +308,14 @@ void process_queued_cpu_work(CPUState *cpu) {struct qemu_work_item *wi; -if (cpu->queued_work_first ==NULL ) { +qemu_mutex_lock (&cpu->work_mutex); +if (QSIMPLEQ_EMPTY (&cpu->work_list)) { +qemu_mutex_unlock (&cpu->work_mutex);return ; } - -qemu_mutex_lock (&cpu->work_mutex); -while (cpu->queued_work_first !=NULL ) { - wi = cpu->queued_work_first; - cpu->queued_work_first = wi->next; -if (!cpu->queued_work_first) { - cpu->queued_work_last =NULL ; - } +while (!QSIMPLEQ_EMPTY (&cpu->work_list)) { + wi =QSIMPLEQ_FIRST (&cpu->work_list); +QSIMPLEQ_REMOVE_HEAD (&cpu->work_list, node);qemu_mutex_unlock (&cpu->work_mutex);if (wi->exclusive) {/* Running work items outside the BQL avoids the following deadlock:
cpus.c +12 -2
@@ -88,9 +88,19 @@ bool cpu_is_stopped(CPUState *cpu)return cpu->stopped || !runstate_is_running (); } +static inline bool cpu_work_list_empty (CPUState *cpu) +{ +bool ret; + +qemu_mutex_lock (&cpu->work_mutex); + ret =QSIMPLEQ_EMPTY (&cpu->work_list); +qemu_mutex_unlock (&cpu->work_mutex); +return ret; +} +static bool cpu_thread_is_idle (CPUState *cpu) { -if (cpu->stop || cpu->queued_work_first) { +if (cpu->stop || !cpu_work_list_empty (cpu)) {return false; }if (cpu_is_stopped (cpu)) {
@@ -1514,7 +1524,7 @@ static void *qemu_tcg_rr_cpu_thread_fn(void *arg) cpu = first_cpu; } -while (cpu && !cpu->queued_work_first && !cpu->exit_request) { +while (cpu &&cpu_work_list_empty (cpu) && !cpu->exit_request) {atomic_mb_set (&tcg_current_rr_cpu, cpu); current_cpu = cpu;
qom/cpu.c +1 -0
@@ -372,6 +372,7 @@ static void cpu_common_initfn(Object *obj) cpu->nr_threads =1 ;qemu_mutex_init (&cpu->work_mutex); +QSIMPLEQ_INIT (&cpu->work_list);QTAILQ_INIT (&cpu->breakpoints);QTAILQ_INIT (&cpu->watchpoints);
Signature · 1 line
2.17.1
PATCH v7 2/73 cpu: rename cpu->work_mutex to cpu->lock
In reply to Emilio G. CotaThis lock will soon protect more fields of the struct. Give it a more appropriate name.
--- include/qom/cpu.h | 6 ++++-- cpus-common.c | 14 +++++++------- cpus.c | 4 ++-- qom/cpu.c | 2 +- 4 files changed, 14 insertions(+), 12 deletions(-)
include/qom/cpu.h +4 -2
@@ -333,7 +333,8 @@ struct qemu_work_item;* @mem_io_pc: Host Program Counter at which the memory was accessed. * @mem_io_vaddr: Target virtual address at which the memory was accessed. * @kvm_fd: vCPU file descriptor for KVM. -* @work_mutex: Lock to prevent multiple access to @work_list. +* @lock: Lock to prevent multiple access to per-CPU fields. Must be acquired +* after the BQL. * @work_list: List of pending asynchronous work. * @trace_dstate_delayed: Delayed changes to trace_dstate (includes all changes * to @trace_dstate).
@@ -374,7 +375,8 @@ struct CPUState {int64_t icount_extra;sigjmp_buf jmp_env; -QemuMutex work_mutex; +QemuMutex lock; +/* fields below protected by @lock */ QSIMPLEQ_HEAD(, qemu_work_item) work_list;CPUAddressSpace *cpu_ases;
cpus-common.c +7 -7
@@ -115,10 +115,10 @@ struct qemu_work_item {static void queue_work_on_cpu (CPUState *cpu,struct qemu_work_item *wi) { -qemu_mutex_lock (&cpu->work_mutex); +qemu_mutex_lock (&cpu->lock);QSIMPLEQ_INSERT_TAIL (&cpu->work_list, wi, node); wi->done = false; -qemu_mutex_unlock (&cpu->work_mutex); +qemu_mutex_unlock (&cpu->lock);qemu_cpu_kick (cpu); }
@@ -308,15 +308,15 @@ void process_queued_cpu_work(CPUState *cpu) {struct qemu_work_item *wi; -qemu_mutex_lock (&cpu->work_mutex); +qemu_mutex_lock (&cpu->lock);if (QSIMPLEQ_EMPTY (&cpu->work_list)) { -qemu_mutex_unlock (&cpu->work_mutex); +qemu_mutex_unlock (&cpu->lock);return ; }while (!QSIMPLEQ_EMPTY (&cpu->work_list)) { wi =QSIMPLEQ_FIRST (&cpu->work_list);QSIMPLEQ_REMOVE_HEAD (&cpu->work_list, node); -qemu_mutex_unlock (&cpu->work_mutex); +qemu_mutex_unlock (&cpu->lock);if (wi->exclusive) {/* Running work items outside the BQL avoids the following deadlock: * 1) start_exclusive() is called with the BQL taken while another
@@ -332,13 +332,13 @@ void process_queued_cpu_work(CPUState *cpu) }else { wi->func (cpu, wi->data); } -qemu_mutex_lock (&cpu->work_mutex); +qemu_mutex_lock (&cpu->lock);if (wi->free) {g_free (wi); }else {atomic_mb_set (&wi->done, true); } } -qemu_mutex_unlock (&cpu->work_mutex); +qemu_mutex_unlock (&cpu->lock);qemu_cond_broadcast (&qemu_work_cond); }
cpus.c +2 -2
@@ -92,9 +92,9 @@ static inline bool cpu_work_list_empty(CPUState *cpu) {bool ret; -qemu_mutex_lock (&cpu->work_mutex); +qemu_mutex_lock (&cpu->lock); ret =QSIMPLEQ_EMPTY (&cpu->work_list); -qemu_mutex_unlock (&cpu->work_mutex); +qemu_mutex_unlock (&cpu->lock);return ret; }
qom/cpu.c +1 -1
@@ -371,7 +371,7 @@ static void cpu_common_initfn(Object *obj) cpu->nr_cores =1 ; cpu->nr_threads =1 ; -qemu_mutex_init (&cpu->work_mutex); +qemu_mutex_init (&cpu->lock);QSIMPLEQ_INIT (&cpu->work_list);QTAILQ_INIT (&cpu->breakpoints);QTAILQ_INIT (&cpu->watchpoints);
Signature · 1 line
2.17.1
PATCH v7 3/73 cpu: introduce cpu_mutex_lock/unlock
In reply to Emilio G. CotaThe few direct users of &cpu->lock will be converted soon.
The per-thread bitmap introduced here might seem unnecessary, since a bool could just do. However, once we complete the conversion to per-vCPU locks, we will need to cover the use case where all vCPUs are locked by the same thread, which explains why the bitmap is introduced here.
--- include/qom/cpu.h | 33 +++++++++++++++++++++++++++++++ cpus.c | 48 +++++++++++++++++++++++++++++++++++++++++++-- stubs/cpu-lock.c | 28 ++++++++++++++++++++++++++ stubs/Makefile.objs | 1 + 4 files changed, 108 insertions(+), 2 deletions(-) create mode 100644 stubs/cpu-lock.c
include/qom/cpu.h +33 -0
@@ -467,6 +467,39 @@ extern CPUTailQ cpus;extern __threadCPUState *current_cpu; +/** +* cpu_mutex_lock - lock a CPU's mutex +* @cpu: the CPU whose mutex is to be locked +* +* To avoid deadlock, a CPU's mutex must be acquired after the BQL. +*/ +#define cpu_mutex_lock (cpu) \ + cpu_mutex_lock_impl(cpu, __FILE__, __LINE__) +void cpu_mutex_lock_impl (CPUState *cpu,const char *file,int line); + +/** +* cpu_mutex_unlock - unlock a CPU's mutex +* @cpu: the CPU whose mutex is to be unlocked +*/ +#define cpu_mutex_unlock (cpu) \ + cpu_mutex_unlock_impl(cpu, __FILE__, __LINE__) +void cpu_mutex_unlock_impl (CPUState *cpu,const char *file,int line); + +/** +* cpu_mutex_locked - check whether a CPU's mutex is locked +* @cpu: the CPU of interest +* +* Returns true if the calling thread is currently holding the CPU's mutex. +*/ +bool cpu_mutex_locked (const CPUState *cpu); + +/** +* no_cpu_mutex_locked - check whether any CPU mutex is held +* +* Returns true if the calling thread is not holding any CPU mutex. +*/ +bool no_cpu_mutex_locked (void ); +static inline void cpu_tb_jmp_cache_clear (CPUState *cpu) {unsigned int i;
cpus.c +46 -2
67 lines not on this page · raw message
stubs/cpu-lock.c new file +28 -0
@@ -0,0 +1,28 @@ +#include "qemu/osdep.h" +#include "qom/cpu.h" + +void cpu_mutex_lock_impl (CPUState *cpu,const char *file,int line) +{ +/* coverity gets confused by the indirect function call */ +#ifdef __COVERITY__ +qemu_mutex_lock_impl (&cpu->lock, file, line); +#else +QemuMutexLockFunc f =atomic_read (&qemu_mutex_lock_func); +f (&cpu->lock, file, line); +#endif +} + +void cpu_mutex_unlock_impl (CPUState *cpu,const char *file,int line) +{ +qemu_mutex_unlock_impl (&cpu->lock, file, line); +} + +bool cpu_mutex_locked (const CPUState *cpu) +{ +return true; +} + +bool no_cpu_mutex_locked (void ) +{ +return true; +}
stubs/Makefile.objs +1 -0
@@ -4,6 +4,7 @@ stub-obj-y += blockdev-close-all-bdrv-states.o stub-obj-y += clock-warp.o stub-obj-y += cpu-get-clock.o stub-obj-y += cpu-get-icount.o +stub-obj-y += cpu-lock.o stub-obj-y += dump.o stub-obj-y += error-printf.o stub-obj-y += fdset.o
Signature · 1 line
2.17.1
PATCH v7 4/73 cpu: make qemu_work_cond per-cpu
In reply to Emilio G. CotaThis eliminates the need to use the BQL to queue CPU work.
While at it, give the per-cpu field a generic name ("cond") since it will soon be used for more than just queueing CPU work.
--- include/qom/cpu.h | 6 ++-- cpus-common.c | 72 ++++++++++++++++++++++++++++++++++++++--------- cpus.c | 2 +- qom/cpu.c | 1 + 4 files changed, 63 insertions(+), 18 deletions(-)
include/qom/cpu.h +3 -3
@@ -335,6 +335,7 @@ struct qemu_work_item;* @kvm_fd: vCPU file descriptor for KVM. * @lock: Lock to prevent multiple access to per-CPU fields. Must be acquired * after the BQL. +* @cond: Condition variable for per-CPU events. * @work_list: List of pending asynchronous work. * @trace_dstate_delayed: Delayed changes to trace_dstate (includes all changes * to @trace_dstate).
@@ -377,6 +378,7 @@ struct CPUState {QemuMutex lock;/* fields below protected by @lock */ +QemuCond cond; QSIMPLEQ_HEAD(, qemu_work_item) work_list;CPUAddressSpace *cpu_ases;
@@ -784,12 +786,10 @@ bool cpu_is_stopped(CPUState *cpu);* @cpu: The vCPU to run on. * @func: The function to be executed. * @data: Data to pass to the function. -* @mutex: Mutex to release while waiting for @func to run. * * Used internally in the implementation of run_on_cpu. */ -void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data, -QemuMutex *mutex); +void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data);/** * run_on_cpu:
cpus-common.c +58 -14
132 lines not on this page · raw message
cpus.c +1 -1
@@ -1236,7 +1236,7 @@ void qemu_init_cpu_loop(void)void run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) { -do_run_on_cpu (cpu, func, data, &qemu_global_mutex); +do_run_on_cpu (cpu, func, data); }static void qemu_kvm_destroy_vcpu (CPUState *cpu)
qom/cpu.c +1 -0
@@ -372,6 +372,7 @@ static void cpu_common_initfn(Object *obj) cpu->nr_threads =1 ;qemu_mutex_init (&cpu->lock); +qemu_cond_init (&cpu->cond);QSIMPLEQ_INIT (&cpu->work_list);QTAILQ_INIT (&cpu->breakpoints);QTAILQ_INIT (&cpu->watchpoints);
Signature · 1 line
2.17.1
PATCH v7 5/73 cpu: move run_on_cpu to cpus-common
In reply to Emilio G. CotaWe don't pass a pointer to qemu_global_mutex anymore.
--- include/qom/cpu.h | 10 ---------- cpus-common.c | 2 +- cpus.c | 5 ----- 3 files changed, 1 insertion(+), 16 deletions(-)
include/qom/cpu.h +0 -10
@@ -781,16 +781,6 @@ void qemu_cpu_kick(CPUState *cpu);*/ bool cpu_is_stopped (CPUState *cpu); -/** -* do_run_on_cpu: -* @cpu: The vCPU to run on. -* @func: The function to be executed. -* @data: Data to pass to the function. -* -* Used internally in the implementation of run_on_cpu. -*/ -void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data); -/** * run_on_cpu: * @cpu: The vCPU to run on.
cpus-common.c +1 -1
@@ -127,7 +127,7 @@ static void queue_work_on_cpu(CPUState *cpu, struct qemu_work_item *wi)cpu_mutex_unlock (cpu); } -void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) +void run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) {struct qemu_work_item wi;bool has_bql =qemu_mutex_iothread_locked ();
cpus.c +0 -5
@@ -1234,11 +1234,6 @@ void qemu_init_cpu_loop(void)qemu_thread_get_self (&io_thread); } -void run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) -{ -do_run_on_cpu (cpu, func, data); -} -static void qemu_kvm_destroy_vcpu (CPUState *cpu) {if (kvm_destroy_vcpu (cpu) <0 ) {
Signature · 1 line
2.17.1
PATCH v7 6/73 cpu: introduce process_queued_cpu_work_locked
In reply to Emilio G. CotaThis completes the conversion to cpu_mutex_lock/unlock in the file.
--- cpus-common.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
cpus-common.c +11 -6
@@ -337,20 +337,19 @@ void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func,queue_work_on_cpu (cpu, wi); } -void process_queued_cpu_work (CPUState *cpu) +/* Called with the CPU's lock held */ +static void process_queued_cpu_work_locked (CPUState *cpu) {struct qemu_work_item *wi;bool has_bql =qemu_mutex_iothread_locked (); -qemu_mutex_lock (&cpu->lock);if (QSIMPLEQ_EMPTY (&cpu->work_list)) { -qemu_mutex_unlock (&cpu->lock);return ; }while (!QSIMPLEQ_EMPTY (&cpu->work_list)) { wi =QSIMPLEQ_FIRST (&cpu->work_list);QSIMPLEQ_REMOVE_HEAD (&cpu->work_list, node); -qemu_mutex_unlock (&cpu->lock); +cpu_mutex_unlock (cpu);if (wi->exclusive) {/* Running work items outside the BQL avoids the following deadlock: * 1) start_exclusive() is called with the BQL taken while another
@@ -376,13 +375,19 @@ void process_queued_cpu_work(CPUState *cpu)qemu_mutex_unlock_iothread (); } } -qemu_mutex_lock (&cpu->lock); +cpu_mutex_lock (cpu);if (wi->free) {g_free (wi); }else {atomic_mb_set (&wi->done, true); } } -qemu_mutex_unlock (&cpu->lock);qemu_cond_broadcast (&cpu->cond); } + +void process_queued_cpu_work (CPUState *cpu) +{ +cpu_mutex_lock (cpu); +process_queued_cpu_work_locked (cpu); +cpu_mutex_unlock (cpu); +}
Signature · 1 line
2.17.1
PATCH v7 7/73 cpu: make per-CPU locks an alias of the BQL in TCG rr mode
In reply to Emilio G. CotaBefore we can switch from the BQL to per-CPU locks in the CPU loop, we have to accommodate the fact that TCG rr mode (i.e. !MTTCG) cannot work with separate per-vCPU locks. That would lead to deadlock since we need a single lock/condvar pair on which to wait for events that affect any vCPU, e.g. in qemu_tcg_rr_wait_io_event.
At the same time, we are moving towards an interface where the BQL and CPU locks are independent, and the only requirement is that the locking order is respected, i.e. the BQL is acquired first if both locks have to be held at the same time.
In this patch we make the BQL a recursive lock under the hood. This allows us to (1) keep the BQL and CPU locks interfaces separate, and (2) use a single lock for all vCPUs in TCG rr mode.
Note that the BQL's API (qemu_mutex_lock/unlock_iothread) remains non-recursive.
--- include/qom/cpu.h | 2 +- cpus-common.c | 2 +- cpus.c | 90 +++++++++++++++++++++++++++++++++++++++++------ qom/cpu.c | 3 +- stubs/cpu-lock.c | 6 ++-- 5 files changed, 86 insertions(+), 17 deletions(-)
include/qom/cpu.h +1 -1
@@ -376,7 +376,7 @@ struct CPUState {int64_t icount_extra;sigjmp_buf jmp_env; -QemuMutex lock; +QemuMutex *lock;/* fields below protected by @lock */ QemuCond cond; QSIMPLEQ_HEAD(, qemu_work_item) work_list;
cpus-common.c +1 -1
@@ -171,7 +171,7 @@ void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)while (!atomic_mb_read (&wi.done)) {CPUState *self_cpu = current_cpu; -qemu_cond_wait (&cpu->cond, &cpu->lock); +qemu_cond_wait (&cpu->cond, cpu->lock); current_cpu = self_cpu; }cpu_mutex_unlock (cpu);
cpus.c +79 -11
145 lines not on this page · raw message
qom/cpu.c +2 -1
@@ -371,7 +371,8 @@ static void cpu_common_initfn(Object *obj) cpu->nr_cores =1 ; cpu->nr_threads =1 ; -qemu_mutex_init (&cpu->lock); + cpu->lock =g_new (QemuMutex,1 ); +qemu_mutex_init (cpu->lock);qemu_cond_init (&cpu->cond);QSIMPLEQ_INIT (&cpu->work_list);QTAILQ_INIT (&cpu->breakpoints);
stubs/cpu-lock.c +3 -3
@@ -5,16 +5,16 @@ void cpu_mutex_lock_impl(CPUState *cpu, const char *file, int line) {/* coverity gets confused by the indirect function call */ #ifdef __COVERITY__ -qemu_mutex_lock_impl (&cpu->lock, file, line); +qemu_mutex_lock_impl (cpu->lock, file, line);#else QemuMutexLockFunc f =atomic_read (&qemu_mutex_lock_func); -f (&cpu->lock, file, line); +f (cpu->lock, file, line);#endif }void cpu_mutex_unlock_impl (CPUState *cpu,const char *file,int line) { -qemu_mutex_unlock_impl (&cpu->lock, file, line); +qemu_mutex_unlock_impl (cpu->lock, file, line); }bool cpu_mutex_locked (const CPUState *cpu)
Signature · 1 line
2.17.1
PATCH v7 8/73 tcg-runtime: define helper_cpu_halted_set
In reply to Emilio G. Cota--- accel/tcg/tcg-runtime.h | 2 ++ accel/tcg/tcg-runtime.c | 7 +++++++ 2 files changed, 9 insertions(+)
accel/tcg/tcg-runtime.h +2 -0
@@ -28,6 +28,8 @@ DEF_HELPER_FLAGS_1(lookup_tb_ptr, TCG_CALL_NO_WG_SE, ptr, env) DEF_HELPER_FLAGS_1(exit_atomic, TCG_CALL_NO_WG, noreturn, env) +DEF_HELPER_FLAGS_2(cpu_halted_set, TCG_CALL_NO_RWG, void, env, i32) +#ifdef CONFIG_SOFTMMU DEF_HELPER_FLAGS_5(atomic_cmpxchgb, TCG_CALL_NO_WG,
accel/tcg/tcg-runtime.c +7 -0
@@ -167,3 +167,10 @@ void HELPER(exit_atomic)(CPUArchState *env) {cpu_loop_exit_atomic (ENV_GET_CPU (env),GETPC ()); } + +void HELPER (cpu_halted_set )(CPUArchState *env,uint32_t val) +{ +CPUState *cpu =ENV_GET_CPU (env); + + cpu->halted = val; +}
Signature · 1 line
2.17.1
PATCH v7 9/73 ppc: convert to helper_cpu_halted_set
In reply to Emilio G. Cota--- target/ppc/translate.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
target/ppc/translate.c +2 -4
@@ -1572,8 +1572,7 @@ GEN_LOGICAL2(nor, tcg_gen_nor_tl, 0x03, PPC_INTEGER);static void gen_pause (DisasContext *ctx) {TCGv_i32 t0 =tcg_const_i32 (0 ); -tcg_gen_st_i32 (t0, cpu_env, - -offsetof(PowerPCCPU , env) + offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, t0);tcg_temp_free_i32 (t0);/* Stop translation, this gives other CPUs a chance to run */
@@ -3547,8 +3546,7 @@ static void gen_sync(DisasContext *ctx)static void gen_wait (DisasContext *ctx) {TCGv_i32 t0 =tcg_const_i32 (1 ); -tcg_gen_st_i32 (t0, cpu_env, - -offsetof(PowerPCCPU , env) + offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, t0);tcg_temp_free_i32 (t0);/* Stop translation, as the CPU is supposed to sleep from now */ gen_exception_nip (ctx,EXCP_HLT , ctx->base.pc_next);
Signature · 1 line
2.17.1
PATCH v7 10/73 cris: convert to helper_cpu_halted_set
In reply to Emilio G. CotaAnd fix the temp leak along the way.
--- target/cris/translate.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
target/cris/translate.c +3 -2
@@ -2829,8 +2829,9 @@ static int dec_rfe_etc(CPUCRISState *env, DisasContext *dc)cris_cc_mask (dc,0 );if (dc->op2 ==15 ) { -tcg_gen_st_i32 (tcg_const_i32 (1 ), cpu_env, - -offsetof(CRISCPU , env) + offsetof(CPUState , halted)); +TCGv_i32 tmp =tcg_const_i32 (1 ); +gen_helper_cpu_halted_set (cpu_env, tmp); +tcg_temp_free_i32 (tmp);tcg_gen_movi_tl (env_pc, dc->pc +2 );t_gen_raise_exception (EXCP_HLT );return 2 ;
Signature · 1 line
2.17.1
PATCH v7 11/73 hppa: convert to helper_cpu_halted_set
In reply to Emilio G. Cota--- target/hppa/translate.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
target/hppa/translate.c +1 -2
@@ -2662,8 +2662,7 @@ static bool trans_or(DisasContext *ctx, arg_rrr_cf *a)/* Tell the qemu main loop to halt until this cpu has work. */ tmp =tcg_const_i32 (1 ); -tcg_gen_st_i32 (tmp, cpu_env, -offsetof(HPPACPU , env) + - offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, tmp);tcg_temp_free_i32 (tmp);gen_excp_1 (EXCP_HALTED ); ctx->base.is_jmp =DISAS_NORETURN ;
Signature · 1 line
2.17.1
PATCH v7 12/73 m68k: convert to helper_cpu_halted_set
In reply to Emilio G. Cota--- target/m68k/translate.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
target/m68k/translate.c +4 -5
@@ -43,7 +43,6 @@#undef DEFO32#undef DEFO64 -static TCGv_i32 cpu_halted;static TCGv_i32 cpu_exception_index;static char cpu_reg_names[2 *8 *3 +5 *4 ];
@@ -79,9 +78,6 @@ void m68k_tcg_init(void)#undef DEFO32#undef DEFO64 - cpu_halted =tcg_global_mem_new_i32 (cpu_env, - -offsetof(M68kCPU , env) + - offsetof(CPUState , halted),"HALTED" ); cpu_exception_index = tcg_global_mem_new_i32(cpu_env, -offsetof(M68kCPU, env) + offsetof(CPUState, exception_index),
@@ -4637,6 +4633,7 @@ DISAS_INSN(halt)DISAS_INSN (stop) {uint16_t ext; +TCGv_i32 tmp;if (IS_USER (s)) {gen_exception (s, s->base.pc_next,EXCP_PRIVILEGE );
@@ -4646,7 +4643,9 @@ DISAS_INSN(stop) ext =read_im16 (env, s);gen_set_sr_im (s, ext,0 ); -tcg_gen_movi_i32 (cpu_halted,1 ); + tmp =tcg_const_i32 (1 ); +gen_helper_cpu_halted_set (cpu_env, tmp); +tcg_temp_free_i32 (tmp);gen_exception (s, s->pc,EXCP_HLT ); }
Signature · 1 line
2.17.1
PATCH v7 13/73 alpha: convert to helper_cpu_halted_set
In reply to Emilio G. Cota--- target/alpha/translate.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
target/alpha/translate.c +2 -4
@@ -1226,8 +1226,7 @@ static DisasJumpType gen_call_pal(DisasContext *ctx, int palcode)/* WTINT */ {TCGv_i32 tmp =tcg_const_i32 (1 ); -tcg_gen_st_i32 (tmp, cpu_env, -offsetof(AlphaCPU , env) + - offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, tmp);tcg_temp_free_i32 (tmp); }tcg_gen_movi_i64 (ctx->ir[IR_V0 ],0 );
@@ -1382,8 +1381,7 @@ static DisasJumpType gen_mtpr(DisasContext *ctx, TCGv vb, int regno)/* WAIT */ {TCGv_i32 tmp =tcg_const_i32 (1 ); -tcg_gen_st_i32 (tmp, cpu_env, -offsetof(AlphaCPU , env) + - offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, tmp);tcg_temp_free_i32 (tmp); }return gen_excp (ctx,EXCP_HALTED ,0 );
Signature · 1 line
2.17.1
PATCH v7 14/73 microblaze: convert to helper_cpu_halted_set
In reply to Emilio G. Cota--- target/microblaze/translate.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
target/microblaze/translate.c +1 -3
@@ -1233,9 +1233,7 @@ static void dec_br(DisasContext *dc)LOG_DIS ("sleep\n" );t_sync_flags (dc); -tcg_gen_st_i32 (tmp_1, cpu_env, - -offsetof(MicroBlazeCPU , env) - +offsetof(CPUState , halted)); +gen_helper_cpu_halted_set (cpu_env, tmp_1);tcg_gen_movi_i64 (cpu_SR[SR_PC ], dc->pc +4 );gen_helper_raise_exception (cpu_env, tmp_hlt);tcg_temp_free_i32 (tmp_hlt);
Signature · 1 line
2.17.1
PATCH v7 15/73 cpu: define cpu_halted helpers
In reply to Emilio G. Cotacpu->halted will soon be protected by cpu->lock. We will use these helpers to ease the transition, since right now cpu->halted has many direct callers.
--- include/qom/cpu.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
include/qom/cpu.h +24 -0
@@ -502,6 +502,30 @@ bool cpu_mutex_locked(const CPUState *cpu);*/ bool no_cpu_mutex_locked (void ); +static inline uint32_t cpu_halted (CPUState *cpu) +{ +uint32_t ret; + +if (cpu_mutex_locked (cpu)) { +return cpu->halted; + } +cpu_mutex_lock (cpu); + ret = cpu->halted; +cpu_mutex_unlock (cpu); +return ret; +} + +static inline void cpu_halted_set (CPUState *cpu,uint32_t val) +{ +if (cpu_mutex_locked (cpu)) { + cpu->halted = val; +return ; + } +cpu_mutex_lock (cpu); + cpu->halted = val; +cpu_mutex_unlock (cpu); +} +static inline void cpu_tb_jmp_cache_clear (CPUState *cpu) {unsigned int i;
Signature · 1 line
2.17.1
PATCH v7 16/73 tcg-runtime: convert to cpu_halted_set
In reply to Emilio G. Cota--- accel/tcg/tcg-runtime.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
accel/tcg/tcg-runtime.c +1 -1
@@ -172,5 +172,5 @@ void HELPER(cpu_halted_set)(CPUArchState *env, uint32_t val) {CPUState *cpu =ENV_GET_CPU (env); - cpu->halted = val; +cpu_halted_set (cpu, val); }
Signature · 1 line
2.17.1
PATCH v7 17/73 arm: convert to cpu_halted
In reply to Emilio G. Cota--- hw/arm/omap1.c | 4 ++-- hw/arm/pxa2xx_gpio.c | 2 +- hw/arm/pxa2xx_pic.c | 2 +- target/arm/arm-powerctl.c | 6 +++--- target/arm/cpu.c | 2 +- target/arm/op_helper.c | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-)
hw/arm/omap1.c +2 -2
@@ -1769,7 +1769,7 @@ static uint64_t omap_clkdsp_read(void *opaque, hwaddr addr,case 0x18 :/* DSP_SYSST */ cpu =CPU (s->cpu);return (s->clkm.clocking_scheme <<11 ) | s->clkm.cold_start | - (cpu->halted <<6 );/* Quite useless... */ + (cpu_halted (cpu) <<6 );/* Quite useless... */ }OMAP_BAD_REG (addr);
@@ -3790,7 +3790,7 @@ void omap_mpu_wakeup(void *opaque, int irq, int req)struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque;CPUState *cpu =CPU (mpu->cpu); -if (cpu->halted) { +if (cpu_halted (cpu)) {cpu_interrupt (cpu,CPU_INTERRUPT_EXITTB ); } }
hw/arm/pxa2xx_gpio.c +1 -1
@@ -128,7 +128,7 @@ static void pxa2xx_gpio_set(void *opaque, int line, int level)pxa2xx_gpio_irq_update (s);/* Wake-up GPIOs */ -if (cpu->halted && (mask & ~s->dir[bank] & pxa2xx_gpio_wake[bank])) { +if (cpu_halted (cpu) && (mask & ~s->dir[bank] & pxa2xx_gpio_wake[bank])) {cpu_interrupt (cpu,CPU_INTERRUPT_EXITTB ); } }
hw/arm/pxa2xx_pic.c +1 -1
@@ -58,7 +58,7 @@ static void pxa2xx_pic_update(void *opaque)PXA2xxPICState *s = (PXA2xxPICState *) opaque;CPUState *cpu =CPU (s->cpu); -if (cpu->halted) { +if (cpu_halted (cpu)) { mask[0 ] = s->int_pending[0 ] & (s->int_enabled[0 ] | s->int_idle); mask[1 ] = s->int_pending[1 ] & (s->int_enabled[1 ] | s->int_idle);if (mask[0 ] || mask[1 ]) {
target/arm/arm-powerctl.c +3 -3
@@ -64,7 +64,7 @@ static void arm_set_cpu_on_async_work(CPUState *target_cpu_state,/* Initialize the cpu we are turning on */ cpu_reset (target_cpu_state); - target_cpu_state->halted =0 ; +cpu_halted_set (target_cpu_state,0 ); if (info->target_aa64) { if ((info->target_el < 3) && arm_feature(&target_cpu->env,
@@ -235,7 +235,7 @@ static void arm_set_cpu_on_and_reset_async_work(CPUState *target_cpu_state,/* Initialize the cpu we are turning on */ cpu_reset (target_cpu_state); - target_cpu_state->halted =0 ; +cpu_halted_set (target_cpu_state,0 );/* Finally set the power status */ assert (qemu_mutex_iothread_locked ());
@@ -291,7 +291,7 @@ static void arm_set_cpu_off_async_work(CPUState *target_cpu_state,assert (qemu_mutex_iothread_locked ()); target_cpu->power_state =PSCI_OFF ; - target_cpu_state->halted =1 ; +cpu_halted_set (target_cpu_state,1 ); target_cpu_state->exception_index =EXCP_HLT ; }
target/arm/cpu.c +1 -1
@@ -173,7 +173,7 @@ static void arm_cpu_reset(CPUState *s) env->vfp.xregs[ARM_VFP_MVFR2 ] = cpu->isar.mvfr2; cpu->power_state = cpu->start_powered_off ?PSCI_OFF :PSCI_ON ; - s->halted = cpu->start_powered_off; +cpu_halted_set (s, cpu->start_powered_off);if (arm_feature (env,ARM_FEATURE_IWMMXT )) { env->iwmmxt.cregs[ARM_IWMMXT_wCID] =0x69051000 |'Q' ;
target/arm/op_helper.c +1 -1
@@ -479,7 +479,7 @@ void HELPER(wfi)(CPUARMState *env, uint32_t insn_len) } cs->exception_index =EXCP_HLT ; - cs->halted =1 ; +cpu_halted_set (cs,1 );cpu_loop_exit (cs); }
Signature · 1 line
2.17.1
PATCH v7 18/73 ppc: convert to cpu_halted
In reply to Emilio G. CotaIn ppce500_spin.c, acquire the lock just once to update both cpu->halted and cpu->stopped.
In hw/ppc/spapr_hcall.c, acquire the lock just once to update cpu->halted and call cpu_has_work, since later in the series we'll acquire the BQL (if not already held) from cpu_has_work.
--- target/ppc/helper_regs.h | 2 +- hw/ppc/e500.c | 4 ++-- hw/ppc/ppc.c | 10 +++++----- hw/ppc/ppce500_spin.c | 6 ++++-- hw/ppc/spapr_cpu_core.c | 4 ++-- hw/ppc/spapr_hcall.c | 4 +++- hw/ppc/spapr_rtas.c | 6 +++--- target/ppc/excp_helper.c | 4 ++-- target/ppc/kvm.c | 4 ++-- target/ppc/translate_init.inc.c | 6 +++--- 10 files changed, 27 insertions(+), 23 deletions(-)
target/ppc/helper_regs.h +1 -1
@@ -161,7 +161,7 @@ static inline int hreg_store_msr(CPUPPCState *env, target_ulong value,#if !defined(CONFIG_USER_ONLY )if (unlikely (msr_pow ==1 )) {if (!env->pending_interrupts && (*env->check_pow)(env)) { - cs->halted =1 ; +cpu_halted_set (cs,1 ); excp =EXCP_HALTED ; } }
hw/ppc/e500.c +2 -2
@@ -657,7 +657,7 @@ static void ppce500_cpu_reset_sec(void *opaque)/* Secondary CPU starts in halted state for now. Needs to change when implementing non-kernel boot. */ - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; }
@@ -671,7 +671,7 @@ static void ppce500_cpu_reset(void *opaque)cpu_reset (cs);/* Set initial guest state. */ - cs->halted =0 ; +cpu_halted_set (cs,0 ); env->gpr[1 ] = (16 * MiB) -8 ; env->gpr[3 ] = bi->dt_base; env->gpr[4 ] =0 ;
hw/ppc/ppc.c +5 -5
@@ -149,7 +149,7 @@ static void ppc6xx_set_irq(void *opaque, int pin, int level)/* XXX: Note that the only way to restart the CPU is to reset it */ if (level) {LOG_IRQ ("%s: stop the CPU\n" , __func__); - cs->halted =1 ; +cpu_halted_set (cs,1 ); }break ;case PPC6xx_INPUT_HRESET:
@@ -228,10 +228,10 @@ static void ppc970_set_irq(void *opaque, int pin, int level)/* XXX: TODO: relay the signal to CKSTP_OUT pin */ if (level) {LOG_IRQ ("%s: stop the CPU\n" , __func__); - cs->halted =1 ; +cpu_halted_set (cs,1 ); }else {LOG_IRQ ("%s: restart the CPU\n" , __func__); - cs->halted =0 ; +cpu_halted_set (cs,0 );qemu_cpu_kick (cs); }break ;
@@ -457,10 +457,10 @@ static void ppc40x_set_irq(void *opaque, int pin, int level)/* Level sensitive - active low */ if (level) {LOG_IRQ ("%s: stop the CPU\n" , __func__); - cs->halted =1 ; +cpu_halted_set (cs,1 ); }else {LOG_IRQ ("%s: restart the CPU\n" , __func__); - cs->halted =0 ; +cpu_halted_set (cs,0 );qemu_cpu_kick (cs); }break ;
hw/ppc/ppce500_spin.c +4 -2
@@ -107,9 +107,11 @@ static void spin_kick(CPUState *cs, run_on_cpu_data data) map_start =ldq_p (&curspin->addr) & ~(map_size -1 );mmubooke_create_initial_mapping (env,0 , map_start, map_size); - cs->halted =0 ; - cs->exception_index =-1 ; +cpu_mutex_lock (cs); +cpu_halted_set (cs,0 ); cs->stopped = false; +cpu_mutex_unlock (cs); + cs->exception_index =-1 ;qemu_cpu_kick (cs); }
hw/ppc/spapr_cpu_core.c +2 -2
@@ -36,7 +36,7 @@ static void spapr_cpu_reset(void *opaque)/* All CPUs start halted. CPU0 is unhalted from the machine level * reset code and the rest are explicitly started up by the guest * using an RTAS call */ - cs->halted =1 ; +cpu_halted_set (cs,1 );/* Set compatibility mode to match the boot CPU, which was either set * by the machine reset code or by CAS. This should never fail.
@@ -90,7 +90,7 @@ void spapr_cpu_set_entry_state(PowerPCCPU *cpu, target_ulong nip, target_ulong r env->nip = nip; env->gpr[3 ] = r3;kvmppc_set_reg_ppc_online (cpu,1 ); -CPU (cpu)->halted =0 ; +cpu_halted_set (CPU (cpu),0 );/* Enable Power-saving mode Exit Cause exceptions */ ppc_store_lpcr (cpu, env->spr[SPR_LPCR ] | pcc->lpcr_pm); }
hw/ppc/spapr_hcall.c +3 -1
@@ -1057,11 +1057,13 @@ static target_ulong h_cede(PowerPCCPU *cpu, sPAPRMachineState *spapr, env->msr |= (1ULL <<MSR_EE );hreg_compute_hflags (env); +cpu_mutex_lock (cs);if (!cpu_has_work (cs)) { - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; cs->exit_request =1 ; } +cpu_mutex_unlock (cs);return H_SUCCESS ; }
hw/ppc/spapr_rtas.c +3 -3
@@ -109,7 +109,7 @@ static void rtas_query_cpu_stopped_state(PowerPCCPU *cpu_, id =rtas_ld (args,0 ); cpu =spapr_find_cpu (id);if (cpu !=NULL ) { -if (CPU (cpu)->halted) { +if (cpu_halted (CPU (cpu))) {rtas_st (rets,1 ,0 ); }else {rtas_st (rets,1 ,2 );
@@ -153,7 +153,7 @@ static void rtas_start_cpu(PowerPCCPU *callcpu, sPAPRMachineState *spapr, env = &newcpu->env; pcc =POWERPC_CPU_GET_CLASS (newcpu); -if (!CPU (newcpu)->halted) { +if (!cpu_halted (CPU (newcpu))) {rtas_st (rets,0 ,RTAS_OUT_HW_ERROR );return ; }
@@ -207,7 +207,7 @@ static void rtas_stop_self(PowerPCCPU *cpu, sPAPRMachineState *spapr,* This could deliver an interrupt on a dying CPU and crash the * guest */ ppc_store_lpcr (cpu, env->spr[SPR_LPCR ] & ~pcc->lpcr_pm); - cs->halted =1 ; +cpu_halted_set (cs,1 );kvmppc_set_reg_ppc_online (cpu,0 );qemu_cpu_kick (cs); }
target/ppc/excp_helper.c +2 -2
@@ -220,7 +220,7 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)qemu_log ("Machine check while not allowed. " "Entering checkstop state\n" ); } - cs->halted =1 ; +cpu_halted_set (cs,1 );cpu_interrupt_exittb (cs); }if (env->msr_mask &MSR_HVB ) {
@@ -1005,7 +1005,7 @@ void helper_pminsn(CPUPPCState *env, powerpc_pm_insn_t insn)CPUState *cs; cs =CPU (ppc_env_get_cpu (env)); - cs->halted =1 ; +cpu_halted_set (cs,1 );/* The architecture specifies that HDEC interrupts are * discarded in PM states
target/ppc/kvm.c +2 -2
@@ -1373,7 +1373,7 @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)int kvm_arch_process_async_events (CPUState *cs) { -return cs->halted; +return cpu_halted (cs); }static int kvmppc_handle_halt (PowerPCCPU *cpu)
@@ -1382,7 +1382,7 @@ static int kvmppc_handle_halt(PowerPCCPU *cpu)CPUPPCState *env = &cpu->env;if (!(cs->interrupt_request &CPU_INTERRUPT_HARD ) && (msr_ee)) { - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; }
target/ppc/translate_init.inc.c +3 -3
@@ -8468,7 +8468,7 @@ static bool cpu_has_work_POWER7(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -if (cs->halted) { +if (cpu_halted (cs)) {if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) {return false; }
@@ -8622,7 +8622,7 @@ static bool cpu_has_work_POWER8(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -if (cs->halted) { +if (cpu_halted (cs)) {if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) {return false; }
@@ -8814,7 +8814,7 @@ static bool cpu_has_work_POWER9(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -if (cs->halted) { +if (cpu_halted (cs)) {uint64_t psscr = env->spr[SPR_PSSCR ];if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) {
Signature · 1 line
2.17.1
PATCH v7 19/73 sh4: convert to cpu_halted
In reply to Emilio G. Cota--- target/sh4/op_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/sh4/op_helper.c +1 -1
@@ -105,7 +105,7 @@ void helper_sleep(CPUSH4State *env) {CPUState *cs =CPU (sh_env_get_cpu (env)); - cs->halted =1 ; +cpu_halted_set (cs,1 ); env->in_sleep =1 ;raise_exception (env,EXCP_HLT ,0 ); }
Signature · 1 line
2.17.1
PATCH v7 20/73 i386: convert to cpu_halted
In reply to Emilio G. Cota--- target/i386/cpu.h | 2 +- target/i386/cpu.c | 2 +- target/i386/hax-all.c | 4 ++-- target/i386/helper.c | 4 ++-- target/i386/hvf/hvf.c | 4 ++-- target/i386/hvf/x86hvf.c | 4 ++-- target/i386/kvm.c | 10 +++++----- target/i386/misc_helper.c | 2 +- target/i386/whpx-all.c | 6 +++--- 9 files changed, 19 insertions(+), 19 deletions(-)
target/i386/cpu.h +1 -1
@@ -1617,7 +1617,7 @@ static inline void cpu_x86_load_seg_cache_sipi(X86CPU *cpu, sipi_vector <<12 , env->segs[R_CS ].limit, env->segs[R_CS].flags); - cs->halted =0 ; +cpu_halted_set (cs,0 ); } int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
target/i386/cpu.c +1 -1
@@ -4731,7 +4731,7 @@ static void x86_cpu_reset(CPUState *s)/* We hard-wire the BSP to the first CPU. */ apic_designate_bsp (cpu->apic_state, s->cpu_index ==0 ); - s->halted = !cpu_is_bsp (cpu); +cpu_halted_set (s, !cpu_is_bsp (cpu));if (kvm_enabled ()) {kvm_arch_reset_vcpu (cpu);
target/i386/hax-all.c +2 -2
@@ -471,7 +471,7 @@ static int hax_vcpu_hax_exec(CPUArchState *env)return 0 ; } - cpu->halted =0 ; +cpu_halted_set (cpu,0 );if (cpu->interrupt_request &CPU_INTERRUPT_POLL ) { cpu->interrupt_request &= ~CPU_INTERRUPT_POLL ;
@@ -548,7 +548,7 @@ static int hax_vcpu_hax_exec(CPUArchState *env) !(cpu->interrupt_request & CPU_INTERRUPT_NMI)) {/* hlt instruction with interrupt disabled is shutdown */ env->eflags |=IF_MASK ; - cpu->halted =1 ; +cpu_halted_set (cpu,1 ); cpu->exception_index =EXCP_HLT ; ret =1 ; }
target/i386/helper.c +2 -2
@@ -454,7 +454,7 @@ void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf, (env->hflags >>HF_INHIBIT_IRQ_SHIFT ) &1 , (env->a20_mask >>20 ) &1 , (env->hflags >>HF_SMM_SHIFT ) &1 , - cs->halted); + cpu_halted(cs)); } else#endif {
@@ -481,7 +481,7 @@ void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf, (env->hflags >>HF_INHIBIT_IRQ_SHIFT ) &1 , (env->a20_mask >>20 ) &1 , (env->hflags >>HF_SMM_SHIFT ) &1 , - cs->halted); + cpu_halted(cs)); }for (i =0 ; i <6 ; i++) {
target/i386/hvf/hvf.c +2 -2
@@ -672,7 +672,7 @@ int hvf_vcpu_exec(CPUState *cpu)vmx_update_tpr (cpu);qemu_mutex_unlock_iothread (); -if (!cpu_is_bsp (X86_CPU (cpu)) && cpu->halted) { +if (!cpu_is_bsp (X86_CPU (cpu)) &&cpu_halted (cpu)) {qemu_mutex_lock_iothread ();return EXCP_HLT ; }
@@ -706,7 +706,7 @@ int hvf_vcpu_exec(CPUState *cpu) (EFLAGS(env) & IF_MASK)) && !(cpu->interrupt_request & CPU_INTERRUPT_NMI) && !(idtvec_info & VMCS_IDT_VEC_VALID)) { - cpu->halted =1 ; +cpu_halted_set (cpu,1 ); ret =EXCP_HLT ; } ret =EXCP_INTERRUPT ;
target/i386/hvf/x86hvf.c +2 -2
@@ -446,7 +446,7 @@ int hvf_process_events(CPUState *cpu_state)if (((cpu_state->interrupt_request &CPU_INTERRUPT_HARD ) && (EFLAGS (env) &IF_MASK )) || (cpu_state->interrupt_request &CPU_INTERRUPT_NMI )) { - cpu_state->halted =0 ; +cpu_halted_set (cpu_state,0 ); }if (cpu_state->interrupt_request &CPU_INTERRUPT_SIPI ) {hvf_cpu_synchronize_state (cpu_state);
@@ -458,5 +458,5 @@ int hvf_process_events(CPUState *cpu_state)apic_handle_tpr_access_report (cpu->apic_state, env->eip, env->tpr_access_type); } -return cpu_state->halted; +return cpu_halted (cpu); }
target/i386/kvm.c +5 -5
@@ -2836,7 +2836,7 @@ static int kvm_get_mp_state(X86CPU *cpu) } env->mp_state = mp_state.mp_state;if (kvm_irqchip_in_kernel ()) { - cs->halted = (mp_state.mp_state ==KVM_MP_STATE_HALTED ); +cpu_halted_set (cs, mp_state.mp_state ==KVM_MP_STATE_HALTED ); }return 0 ; }
@@ -3320,7 +3320,7 @@ int kvm_arch_process_async_events(CPUState *cs) env->exception_injected =EXCP12_MCHK ; env->has_error_code =0 ; - cs->halted =0 ; +cpu_halted_set (cs,0 );if (kvm_irqchip_in_kernel () && env->mp_state ==KVM_MP_STATE_HALTED ) { env->mp_state =KVM_MP_STATE_RUNNABLE ; }
@@ -3343,7 +3343,7 @@ int kvm_arch_process_async_events(CPUState *cs)if (((cs->interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) || (cs->interrupt_request &CPU_INTERRUPT_NMI )) { - cs->halted =0 ; +cpu_halted_set (cs,0 ); }if (cs->interrupt_request &CPU_INTERRUPT_SIPI ) {kvm_cpu_synchronize_state (cs);
@@ -3356,7 +3356,7 @@ int kvm_arch_process_async_events(CPUState *cs) env->tpr_access_type); } -return cs->halted; +return cpu_halted (cs); }static int kvm_handle_halt (X86CPU *cpu)
@@ -3367,7 +3367,7 @@ static int kvm_handle_halt(X86CPU *cpu)if (!((cs->interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) && !(cs->interrupt_request &CPU_INTERRUPT_NMI )) { - cs->halted =1 ; +cpu_halted_set (cs,1 );return EXCP_HLT ; }
target/i386/misc_helper.c +1 -1
@@ -554,7 +554,7 @@ static void do_hlt(X86CPU *cpu)CPUX86State *env = &cpu->env; env->hflags &= ~HF_INHIBIT_IRQ_MASK ;/* needed if sti is just before */ - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ;cpu_loop_exit (cs); }
target/i386/whpx-all.c +3 -3
@@ -697,7 +697,7 @@ static int whpx_handle_halt(CPUState *cpu) (env->eflags & IF_MASK)) && !(cpu->interrupt_request & CPU_INTERRUPT_NMI)) { cpu->exception_index =EXCP_HLT ; - cpu->halted = true; +cpu_halted_set (cpu, true); ret =1 ; }qemu_mutex_unlock_iothread ();
@@ -857,7 +857,7 @@ static void whpx_vcpu_process_async_events(CPUState *cpu)if (((cpu->interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) || (cpu->interrupt_request &CPU_INTERRUPT_NMI )) { - cpu->halted = false; +cpu_halted_set (cpu, false); }if (cpu->interrupt_request &CPU_INTERRUPT_SIPI ) {
@@ -887,7 +887,7 @@ static int whpx_vcpu_run(CPUState *cpu)int ret;whpx_vcpu_process_async_events (cpu); -if (cpu->halted) { +if (cpu_halted (cpu)) { cpu->exception_index =EXCP_HLT ;atomic_set (&cpu->exit_request, false);return 0 ;
Signature · 1 line
2.17.1
PATCH v7 21/73 lm32: convert to cpu_halted
In reply to Emilio G. Cota--- target/lm32/op_helper.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
target/lm32/op_helper.c +2 -2
@@ -31,7 +31,7 @@ void HELPER(hlt)(CPULM32State *env) {CPUState *cs =CPU (lm32_env_get_cpu (env)); - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ;cpu_loop_exit (cs); }
@@ -44,7 +44,7 @@ void HELPER(ill)(CPULM32State *env)"Connect a debugger or switch to the monitor console " "to find out more.\n");vm_stop (RUN_STATE_PAUSED ); - cs->halted =1 ; +cpu_halted_set (cs,1 );raise_exception (env,EXCP_HALTED );#endif }
Signature · 1 line
2.17.1
PATCH v7 22/73 m68k: convert to cpu_halted
In reply to Emilio G. Cota--- target/m68k/op_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/m68k/op_helper.c +1 -1
@@ -237,7 +237,7 @@ static void cf_interrupt_all(CPUM68KState *env, int is_hw)do_m68k_semihosting (env, env->dregs[0 ]);return ; } - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ;cpu_loop_exit (cs);return ;
Signature · 1 line
2.17.1
PATCH v7 23/73 mips: convert to cpu_halted
In reply to Emilio G. Cota--- hw/mips/cps.c | 2 +- hw/misc/mips_itu.c | 4 ++-- target/mips/kvm.c | 2 +- target/mips/op_helper.c | 8 ++++---- target/mips/translate.c | 4 ++-- 5 files changed, 10 insertions(+), 10 deletions(-)
hw/mips/cps.c +1 -1
@@ -49,7 +49,7 @@ static void main_cpu_reset(void *opaque)cpu_reset (cs);/* All VPs are halted on reset. Leave powering up to CPC. */ - cs->halted =1 ; +cpu_halted_set (cs,1 ); }static bool cpu_mips_itu_supported (CPUMIPSState *env)
hw/misc/mips_itu.c +2 -2
@@ -181,7 +181,7 @@ static void wake_blocked_threads(ITCStorageCell *c) {CPUState *cs;CPU_FOREACH (cs) { -if (cs->halted && (c->blocked_threads & (1ULL << cs->cpu_index))) { +if (cpu_halted (cs) && (c->blocked_threads & (1ULL << cs->cpu_index))) {cpu_interrupt (cs,CPU_INTERRUPT_WAKE ); } }
@@ -191,7 +191,7 @@ static void wake_blocked_threads(ITCStorageCell *c) static void QEMU_NORETURN block_thread_and_exit(ITCStorageCell *c) { c->blocked_threads |=1ULL << current_cpu->cpu_index; - current_cpu->halted =1 ; +cpu_halted_set (current_cpu,1 ); current_cpu->exception_index =EXCP_HLT ;cpu_loop_exit_restore (current_cpu, current_cpu->mem_io_pc); }
target/mips/kvm.c +1 -1
@@ -156,7 +156,7 @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)int kvm_arch_process_async_events (CPUState *cs) { -return cs->halted; +return cpu_halted (cs); }int kvm_arch_handle_exit (CPUState *cs,struct kvm_run *run)
target/mips/op_helper.c +4 -4
@@ -623,7 +623,7 @@ static bool mips_vpe_is_wfi(MIPSCPU *c)/* If the VPE is halted but otherwise active, it means it's waiting for an interrupt. */ -return cpu->halted &&mips_vpe_active (env); +return cpu_halted (cpu) &&mips_vpe_active (env); }static bool mips_vp_is_wfi (MIPSCPU *c)
@@ -631,7 +631,7 @@ static bool mips_vp_is_wfi(MIPSCPU *c)CPUState *cpu =CPU (c);CPUMIPSState *env = &c->env; -return cpu->halted &&mips_vp_active (env); +return cpu_halted (cpu) &&mips_vp_active (env); }static inline void mips_vpe_wake (MIPSCPU *c)
@@ -650,7 +650,7 @@ static inline void mips_vpe_sleep(MIPSCPU *cpu)/* The VPE was shut off, really go to bed. Reset any old _WAKE requests. */ - cs->halted =1 ; +cpu_halted_set (cs,1 );cpu_reset_interrupt (cs,CPU_INTERRUPT_WAKE ); }
@@ -2635,7 +2635,7 @@ void helper_wait(CPUMIPSState *env) {CPUState *cs =CPU (mips_env_get_cpu (env)); - cs->halted =1 ; +cpu_halted_set (cs,1 );cpu_reset_interrupt (cs,CPU_INTERRUPT_WAKE );/* Last instruction in the block, PC was updated before - no need to recover PC and icount */
target/mips/translate.c +2 -2
@@ -30044,7 +30044,7 @@ void cpu_state_reset(CPUMIPSState *env) env->tcs[i].CP0_TCHalt =1 ; } env->active_tc.CP0_TCHalt =1 ; - cs->halted =1 ; +cpu_halted_set (cs,1 );if (cs->cpu_index ==0 ) {/* VPE0 starts up enabled. */
@@ -30052,7 +30052,7 @@ void cpu_state_reset(CPUMIPSState *env) env->CP0_VPEConf0 |= (1 <<CP0VPEC0_MVP ) | (1 <<CP0VPEC0_VPA );/* TC0 starts up unhalted. */ - cs->halted =0 ; +cpu_halted_set (cs,0 ); env->active_tc.CP0_TCHalt =0 ; env->tcs[0 ].CP0_TCHalt =0 ;/* With thread 0 active. */
Signature · 1 line
2.17.1
PATCH v7 24/73 riscv: convert to cpu_halted
In reply to Emilio G. Cota--- target/riscv/op_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/riscv/op_helper.c +1 -1
@@ -135,7 +135,7 @@ void helper_wfi(CPURISCVState *env) get_field(env->mstatus, MSTATUS_TW)) { riscv_raise_exception(env, RISCV_EXCP_ILLEGAL_INST, GETPC()); } else { - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ;cpu_loop_exit (cs); }
Signature · 1 line
2.17.1
PATCH v7 25/73 s390x: convert to cpu_halted
In reply to Emilio G. Cota--- hw/intc/s390_flic.c | 2 +- target/s390x/cpu.c | 22 +++++++++++++++------- target/s390x/excp_helper.c | 2 +- target/s390x/kvm.c | 2 +- target/s390x/sigp.c | 8 ++++---- 5 files changed, 22 insertions(+), 14 deletions(-)
hw/intc/s390_flic.c +1 -1
@@ -198,7 +198,7 @@ static void qemu_s390_flic_notify(uint32_t type) }/* we always kick running CPUs for now, this is tricky */ -if (cs->halted) { +if (cpu_halted (cs)) {/* don't check for subclasses, CPUs double check when waking up */ if (type &FLIC_PENDING_SERVICE ) {if (!(cpu->env.psw.mask &PSW_MASK_EXT )) {
target/s390x/cpu.c +15 -7
@@ -285,7 +285,7 @@ static void s390_cpu_initfn(Object *obj)CPUS390XState *env = &cpu->env; cs->env_ptr = env; - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ;object_property_add (obj,"crash-information" ,"GuestPanicInformation" , s390_cpu_get_crash_info_qom,NULL ,NULL ,NULL ,NULL );
@@ -310,8 +310,8 @@ static void s390_cpu_finalize(Object *obj)#if !defined(CONFIG_USER_ONLY )static bool disabled_wait (CPUState *cpu) { -return cpu->halted && !(S390_CPU (cpu)->env.psw.mask & - (PSW_MASK_IO |PSW_MASK_EXT |PSW_MASK_MCHECK )); +return cpu_halted (cpu) && !(S390_CPU (cpu)->env.psw.mask & + (PSW_MASK_IO |PSW_MASK_EXT |PSW_MASK_MCHECK )); }static unsigned s390_count_running_cpus (void )
@@ -337,10 +337,16 @@ unsigned int s390_cpu_halt(S390CPU *cpu)CPUState *cs =CPU (cpu);trace_cpu_halt (cs->cpu_index); -if (!cs->halted) { - cs->halted =1 ; +/* +* cpu_halted and cpu_halted_set acquire the cpu lock if it +* isn't already held, so acquire it first. +*/ +cpu_mutex_lock (cs); +if (!cpu_halted (cs)) { +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; } +cpu_mutex_unlock (cs);return s390_count_running_cpus (); }
@@ -350,10 +356,12 @@ void s390_cpu_unhalt(S390CPU *cpu)CPUState *cs =CPU (cpu);trace_cpu_unhalt (cs->cpu_index); -if (cs->halted) { - cs->halted =0 ; +cpu_mutex_lock (cs); +if (cpu_halted (cs)) { +cpu_halted_set (cs,0 ); cs->exception_index =-1 ; } +cpu_mutex_unlock (cs); }unsigned int s390_cpu_set_state (uint8_t cpu_state,S390CPU *cpu)
target/s390x/excp_helper.c +1 -1
@@ -461,7 +461,7 @@ try_deliver:if ((env->psw.mask &PSW_MASK_WAIT ) || stopped) {/* don't trigger a cpu_loop_exit(), use an interrupt instead */ cpu_interrupt (CPU (cpu),CPU_INTERRUPT_HALT ); - }else if (cs->halted) { + }else if (cpu_halted (cs)) {/* unhalt if we had a WAIT PSW somehwere in our injection chain */ s390_cpu_unhalt (cpu); }
target/s390x/kvm.c +1 -1
@@ -1003,7 +1003,7 @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)int kvm_arch_process_async_events (CPUState *cs) { -return cs->halted; +return cpu_halted (cs); } static int s390_kvm_irq_to_interrupt(struct kvm_s390_irq *irq,
target/s390x/sigp.c +4 -4
@@ -115,7 +115,7 @@ static void sigp_stop(CPUState *cs, run_on_cpu_data arg) }/* disabled wait - sleeping in user space */ -if (cs->halted) { +if (cpu_halted (cs)) {s390_cpu_set_state (S390_CPU_STATE_STOPPED , cpu); }else {/* execute the stop function */
@@ -131,7 +131,7 @@ static void sigp_stop_and_store_status(CPUState *cs, run_on_cpu_data arg)SigpInfo *si = arg.host_ptr;/* disabled wait - sleeping in user space */ -if (s390_cpu_get_state (cpu) ==S390_CPU_STATE_OPERATING && cs->halted) { +if (s390_cpu_get_state (cpu) ==S390_CPU_STATE_OPERATING &&cpu_halted (cs)) {s390_cpu_set_state (S390_CPU_STATE_STOPPED , cpu); }
@@ -313,7 +313,7 @@ static void sigp_cond_emergency(S390CPU *src_cpu, S390CPU *dst_cpu, }/* this looks racy, but these values are only used when STOPPED */ - idle =CPU (dst_cpu)->halted; + idle =cpu_halted (CPU (dst_cpu)); psw_addr = dst_cpu->env.psw.addr; psw_mask = dst_cpu->env.psw.mask; asn = si->param;
@@ -347,7 +347,7 @@ static void sigp_sense_running(S390CPU *dst_cpu, SigpInfo *si) }/* If halted (which includes also STOPPED), it is not running */ -if (CPU (dst_cpu)->halted) { +if (cpu_halted (CPU (dst_cpu))) { si->cc =SIGP_CC_ORDER_CODE_ACCEPTED ; }else {set_sigp_status (si,SIGP_STAT_NOT_RUNNING );
Signature · 1 line
2.17.1
PATCH v7 26/73 sparc: convert to cpu_halted
In reply to Emilio G. Cota--- hw/sparc/leon3.c | 2 +- hw/sparc/sun4m.c | 8 ++++---- hw/sparc64/sparc64.c | 4 ++-- target/sparc/helper.c | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-)
hw/sparc/leon3.c +1 -1
@@ -61,7 +61,7 @@ static void main_cpu_reset(void *opaque)cpu_reset (cpu); - cpu->halted =0 ; +cpu_halted_set (cpu,0 ); env->pc = s->entry; env->npc = s->entry +4 ; env->regbase[6 ] = s->sp;
hw/sparc/sun4m.c +4 -4
@@ -167,7 +167,7 @@ static void cpu_kick_irq(SPARCCPU *cpu)CPUSPARCState *env = &cpu->env;CPUState *cs =CPU (cpu); - cs->halted =0 ; +cpu_halted_set (cs,0 );cpu_check_irqs (env);qemu_cpu_kick (cs); }
@@ -198,7 +198,7 @@ static void main_cpu_reset(void *opaque)CPUState *cs =CPU (cpu);cpu_reset (cs); - cs->halted =0 ; +cpu_halted_set (cs,0 ); }static void secondary_cpu_reset (void *opaque)
@@ -207,7 +207,7 @@ static void secondary_cpu_reset(void *opaque)CPUState *cs =CPU (cpu);cpu_reset (cs); - cs->halted =1 ; +cpu_halted_set (cs,1 ); }static void cpu_halt_signal (void *opaque,int irq,int level)
@@ -828,7 +828,7 @@ static void cpu_devinit(const char *cpu_type, unsigned int id, }else {qemu_register_reset (secondary_cpu_reset, cpu); cs =CPU (cpu); - cs->halted =1 ; +cpu_halted_set (cs,1 ); } *cpu_irqs =qemu_allocate_irqs (cpu_set_irq, cpu,MAX_PILS ); env->prom_addr = prom_addr;
hw/sparc64/sparc64.c +2 -2
@@ -100,7 +100,7 @@ static void cpu_kick_irq(SPARCCPU *cpu)CPUState *cs =CPU (cpu);CPUSPARCState *env = &cpu->env; - cs->halted =0 ; +cpu_halted_set (cs,0 );cpu_check_irqs (env);qemu_cpu_kick (cs); }
@@ -115,7 +115,7 @@ void sparc64_cpu_set_ivec_irq(void *opaque, int irq, int level)if (!(env->ivec_status &0x20 )) {trace_sparc64_cpu_ivec_raise_irq (irq); cs =CPU (cpu); - cs->halted =0 ; +cpu_halted_set (cs,0 ); env->interrupt_index =TT_IVEC ; env->ivec_status |=0x20 ; env->ivec_data[0 ] = (0x1f <<6 ) | irq;
target/sparc/helper.c +1 -1
@@ -245,7 +245,7 @@ void helper_power_down(CPUSPARCState *env) {CPUState *cs =CPU (sparc_env_get_cpu (env)); - cs->halted =1 ; +cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; env->pc = env->npc; env->npc = env->pc +4 ;
Signature · 1 line
2.17.1
PATCH v7 27/73 xtensa: convert to cpu_halted
In reply to Emilio G. Cota--- target/xtensa/cpu.c | 2 +- target/xtensa/exc_helper.c | 2 +- target/xtensa/helper.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
target/xtensa/cpu.c +1 -1
@@ -86,7 +86,7 @@ static void xtensa_cpu_reset(CPUState *s)#ifndef CONFIG_USER_ONLY reset_mmu (env); - s->halted = env->runstall; +cpu_halted_set (s, env->runstall);#endif }
target/xtensa/exc_helper.c +1 -1
@@ -116,7 +116,7 @@ void HELPER(waiti)(CPUXtensaState *env, uint32_t pc, uint32_t intlevel) } cpu =CPU (xtensa_env_get_cpu (env)); - cpu->halted =1 ; +cpu_halted_set (cpu,1 );HELPER (exception)(env,EXCP_HLT ); }
target/xtensa/helper.c +1 -1
@@ -318,7 +318,7 @@ void xtensa_runstall(CPUXtensaState *env, bool runstall)CPUState *cpu =CPU (xtensa_env_get_cpu (env)); env->runstall = runstall; - cpu->halted = runstall; +cpu_halted_set (cpu, runstall);if (runstall) {cpu_interrupt (cpu,CPU_INTERRUPT_HALT ); }else {
Signature · 1 line
2.17.1
PATCH v7 28/73 gdbstub: convert to cpu_halted
In reply to Emilio G. Cota--- gdbstub.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
gdbstub.c +2 -2
@@ -1664,13 +1664,13 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)object_get_canonical_path_component (OBJECT (cpu)); len =snprintf ((char *)mem_buf,sizeof (buf) /2 ,"%s %s [%s]" , cpu_model, cpu_name, - cpu->halted ?"halted " :"running" ); +cpu_halted (cpu) ?"halted " :"running" );g_free (cpu_name); }else {/* memtohex() doubles the required space */ len =snprintf ((char *)mem_buf,sizeof (buf) /2 ,"CPU#%d [%s]" , cpu->cpu_index, - cpu->halted ?"halted " :"running" ); +cpu_halted (cpu) ?"halted " :"running" ); }trace_gdbstub_op_extra_info ((char *)mem_buf);memtohex (buf, mem_buf, len);
Signature · 1 line
2.17.1
PATCH v7 29/73 openrisc: convert to cpu_halted
In reply to Emilio G. Cota--- target/openrisc/sys_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/openrisc/sys_helper.c +1 -1
@@ -137,7 +137,7 @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb)if (env->pmr &PMR_DME || env->pmr &PMR_SME ) {cpu_restore_state (cs,GETPC (), true); env->pc +=4 ; - cs->halted =1 ; +cpu_halted_set (cs,1 );raise_exception (cpu,EXCP_HALTED ); }break ;
Signature · 1 line
2.17.1
PATCH v7 30/73 cpu-exec: convert to cpu_halted
In reply to Emilio G. Cota--- accel/tcg/cpu-exec.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)
accel/tcg/cpu-exec.c +21 -4
@@ -425,14 +425,21 @@ static inline TranslationBlock *tb_find(CPUState *cpu,return tb; } -static inline bool cpu_handle_halt (CPUState *cpu) +static inline bool cpu_handle_halt_locked (CPUState *cpu) { -if (cpu->halted) { +g_assert (cpu_mutex_locked (cpu)); + +if (cpu_halted (cpu)) {#if defined(TARGET_I386 ) && !defined(CONFIG_USER_ONLY )if ((cpu->interrupt_request &CPU_INTERRUPT_POLL ) &&replay_interrupt ()) {X86CPU *x86_cpu =X86_CPU (cpu); + +/* prevent deadlock; cpu_mutex must be acquired _after_ the BQL */ +cpu_mutex_unlock (cpu);qemu_mutex_lock_iothread (); +cpu_mutex_lock (cpu); +apic_poll_irq (x86_cpu->apic_state);cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );qemu_mutex_unlock_iothread ();
@@ -442,12 +449,22 @@ static inline bool cpu_handle_halt(CPUState *cpu)return true; } - cpu->halted =0 ; +cpu_halted_set (cpu,0 ); }return false; } +static inline bool cpu_handle_halt (CPUState *cpu) +{ +bool ret; + +cpu_mutex_lock (cpu); + ret =cpu_handle_halt_locked (cpu); +cpu_mutex_unlock (cpu); +return ret; +} +static inline void cpu_handle_debug_exception (CPUState *cpu) {CPUClass *cc =CPU_GET_CLASS (cpu);
@@ -546,7 +563,7 @@ static inline bool cpu_handle_interrupt(CPUState *cpu, }else if (interrupt_request &CPU_INTERRUPT_HALT ) {replay_interrupt (); cpu->interrupt_request &= ~CPU_INTERRUPT_HALT ; - cpu->halted =1 ; +cpu_halted_set (cpu,1 ); cpu->exception_index =EXCP_HLT ;qemu_mutex_unlock_iothread ();return true;
Signature · 1 line
2.17.1
PATCH v7 31/73 cpu: convert to cpu_halted
In reply to Emilio G. CotaThis finishes the conversion to cpu_halted.
--- accel/tcg/cpu-exec.c | 2 +- cpus.c | 8 ++++---- qom/cpu.c | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-)
accel/tcg/cpu-exec.c +1 -1
@@ -435,7 +435,7 @@ static inline bool cpu_handle_halt_locked(CPUState *cpu) && replay_interrupt()) {X86CPU *x86_cpu =X86_CPU (cpu); -/* prevent deadlock; cpu_mutex must be acquired _after_ the BQL */ +/* locking order: cpu_mutex must be acquired _after_ the BQL */ cpu_mutex_unlock (cpu);qemu_mutex_lock_iothread ();cpu_mutex_lock (cpu);
cpus.c +4 -4
@@ -204,7 +204,7 @@ static bool cpu_thread_is_idle(CPUState *cpu)if (cpu_is_stopped (cpu)) {return true; } -if (!cpu->halted ||cpu_has_work (cpu) || +if (!cpu_halted (cpu) ||cpu_has_work (cpu) ||kvm_halt_in_kernel ()) {return false; }
@@ -1687,7 +1687,7 @@ static void *qemu_hax_cpu_thread_fn(void *arg) cpu->thread_id =qemu_get_thread_id (); cpu->created = true; - cpu->halted =0 ; +cpu_halted_set (cpu,0 ); current_cpu = cpu;hax_init_vcpu (cpu);
@@ -1846,7 +1846,7 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)* * cpu->halted should ensure we sleep in wait_io_event */ -g_assert (cpu->halted); +g_assert (cpu_halted (cpu));break ;case EXCP_ATOMIC :qemu_mutex_unlock_iothread ();
@@ -2343,7 +2343,7 @@ CpuInfoList *qmp_query_cpus(Error **errp) info->value =g_malloc0 (sizeof (*info->value)); info->value->CPU = cpu->cpu_index; info->value->current = (cpu == first_cpu); - info->value->halted = cpu->halted; + info->value->halted =cpu_halted (cpu); info->value->qom_path =object_get_canonical_path (OBJECT (cpu)); info->value->thread_id = cpu->thread_id;#if defined(TARGET_I386 )
qom/cpu.c +1 -1
@@ -261,7 +261,7 @@ static void cpu_common_reset(CPUState *cpu) } cpu->interrupt_request =0 ; - cpu->halted =0 ; +cpu_halted_set (cpu,0 ); cpu->mem_io_pc =0 ; cpu->mem_io_vaddr =0 ; cpu->icount_extra =0 ;
Signature · 1 line
2.17.1
PATCH v7 32/73 cpu: define cpu_interrupt_request helpers
In reply to Emilio G. CotaAdd a comment about how atomic_read works here. The comment refers to a "BQL-less CPU loop", which will materialize toward the end of this series.
Note that the modifications to cpu_reset_interrupt are there to avoid deadlock during the CPU lock transition; once that is complete, cpu_interrupt_request will be simple again.
--- include/qom/cpu.h | 37 +++++++++++++++++++++++++++++++++++++ qom/cpu.c | 27 +++++++++++++++++++++------ 2 files changed, 58 insertions(+), 6 deletions(-)
include/qom/cpu.h +37 -0
@@ -526,6 +526,43 @@ static inline void cpu_halted_set(CPUState *cpu, uint32_t val)cpu_mutex_unlock (cpu); } +/* +* When sending an interrupt, setters OR the appropriate bit and kick the +* destination vCPU. The latter can then read interrupt_request without +* acquiring the CPU lock, because once the kick-induced completes, they'll read +* an up-to-date interrupt_request. +* Setters always acquire the lock, which guarantees that (1) concurrent +* updates from different threads won't result in data races, and (2) the +* BQL-less CPU loop will always see an up-to-date interrupt_request, since the +* loop holds the CPU lock. +*/ +static inline uint32_t cpu_interrupt_request (CPUState *cpu) +{ +return atomic_read (&cpu->interrupt_request); +} + +static inline void cpu_interrupt_request_or (CPUState *cpu,uint32_t mask) +{ +if (cpu_mutex_locked (cpu)) { +atomic_set (&cpu->interrupt_request, cpu->interrupt_request | mask); +return ; + } +cpu_mutex_lock (cpu); +atomic_set (&cpu->interrupt_request, cpu->interrupt_request | mask); +cpu_mutex_unlock (cpu); +} + +static inline void cpu_interrupt_request_set (CPUState *cpu,uint32_t val) +{ +if (cpu_mutex_locked (cpu)) { +atomic_set (&cpu->interrupt_request, val); +return ; + } +cpu_mutex_lock (cpu); +atomic_set (&cpu->interrupt_request, val); +cpu_mutex_unlock (cpu); +} +static inline void cpu_tb_jmp_cache_clear (CPUState *cpu) {unsigned int i;
qom/cpu.c +21 -6
@@ -98,14 +98,29 @@ static void cpu_common_get_memory_mapping(CPUState *cpu,* BQL here if we need to. cpu_interrupt assumes it is held.*/ void cpu_reset_interrupt (CPUState *cpu,int mask) { -bool need_lock = !qemu_mutex_iothread_locked (); +bool has_bql =qemu_mutex_iothread_locked (); +bool has_cpu_lock =cpu_mutex_locked (cpu); -if (need_lock) { -qemu_mutex_lock_iothread (); +if (has_bql) { +if (has_cpu_lock) { +atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); + }else { +cpu_mutex_lock (cpu); +atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); +cpu_mutex_unlock (cpu); + } +return ; + } + +if (has_cpu_lock) { +cpu_mutex_unlock (cpu); } - cpu->interrupt_request &= ~mask; -if (need_lock) { -qemu_mutex_unlock_iothread (); +qemu_mutex_lock_iothread (); +cpu_mutex_lock (cpu); +atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); +qemu_mutex_unlock_iothread (); +if (!has_cpu_lock) { +cpu_mutex_unlock (cpu); } }
Signature · 1 line
2.17.1
PATCH v7 33/73 ppc: use cpu_reset_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- target/ppc/excp_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/ppc/excp_helper.c +1 -1
@@ -931,7 +931,7 @@ bool ppc_cpu_exec_interrupt(CPUState *cs, int interrupt_request)if (interrupt_request &CPU_INTERRUPT_HARD ) {ppc_hw_interrupt (env);if (env->pending_interrupts ==0 ) { - cs->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); }return true; }
Signature · 1 line
2.17.1
PATCH v7 34/73 exec: use cpu_reset_interrupt
In reply to Emilio G. Cota--- exec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
exec.c +1 -1
@@ -779,7 +779,7 @@ static int cpu_common_post_load(void *opaque, int version_id)/* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the version_id is increased. */ - cpu->interrupt_request &= ~0x01 ; +cpu_reset_interrupt (cpu,1 );tlb_flush (cpu);/* loadvm has just updated the content of RAM, bypassing the
Signature · 1 line
2.17.1
PATCH v7 35/73 i386: use cpu_reset_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- 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
@@ -424,7 +424,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 ); } }
@@ -474,7 +474,7 @@ static int hax_vcpu_hax_exec(CPUArchState *env)cpu_halted_set (cpu,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
@@ -2893,7 +2893,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 ;
@@ -3189,7 +3189,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 );
@@ -3200,7 +3200,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 );
@@ -3236,7 +3236,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;
@@ -3307,7 +3307,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);
@@ -3337,7 +3337,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) &&
@@ -3350,7 +3350,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
@@ -1332,7 +1332,7 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)switch (interrupt_request) {#if !defined(CONFIG_USER_ONLY )case CPU_INTERRUPT_POLL : - cs->interrupt_request &= ~CPU_INTERRUPT_POLL ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL );apic_poll_irq (cpu->apic_state);break ;#endif
@@ -1341,23 +1341,22 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)break ;case CPU_INTERRUPT_SMI :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);break ;case CPU_INTERRUPT_NMI :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 );break ;case CPU_INTERRUPT_MCE : - cs->interrupt_request &= ~CPU_INTERRUPT_MCE ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_MCE );do_interrupt_x86_hardirq (env,EXCP12_MCHK ,0 );break ;case CPU_INTERRUPT_HARD :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);
@@ -1372,7 +1371,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 );break ;#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_GUEST_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
PATCH v7 36/73 s390x: use cpu_reset_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- target/s390x/excp_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/s390x/excp_helper.c +1 -1
@@ -454,7 +454,7 @@ try_deliver:/* we might still have pending interrupts, but not deliverable */ if (!env->pending_int && !qemu_s390_flic_has_any (flic)) { - cs->interrupt_request &= ~CPU_INTERRUPT_HARD ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); }/* WAIT PSW during interrupt injection or STOP interrupt */
Signature · 1 line
2.17.1
PATCH v7 37/73 openrisc: use cpu_reset_interrupt
In reply to Emilio G. CotaFrom: Paolo Bonzini <[email protected]>
--- target/openrisc/sys_helper.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/openrisc/sys_helper.c +1 -1
@@ -170,7 +170,7 @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb) env->ttmr = (rb & ~TTMR_IP ) | ip; }else {/* Clear IP bit. */ env->ttmr = rb & ~TTMR_IP ; - cs->interrupt_request &= ~CPU_INTERRUPT_TIMER ; +cpu_reset_interrupt (cs,CPU_INTERRUPT_TIMER ); }cpu_openrisc_timer_update (cpu);
Signature · 1 line
2.17.1
PATCH v7 38/73 arm: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/arm/cpu.c | 6 +++--- target/arm/helper.c | 16 +++++++--------- target/arm/machine.c | 2 +- 3 files changed, 11 insertions(+), 13 deletions(-)
target/arm/cpu.c +3 -3
@@ -73,7 +73,7 @@ static bool arm_cpu_has_work(CPUState *cs)ARMCPU *cpu =ARM_CPU (cs);return (cpu->power_state !=PSCI_OFF ) - && cs->interrupt_request & + &&cpu_interrupt_request (cs) & (CPU_INTERRUPT_FIQ |CPU_INTERRUPT_HARD |CPU_INTERRUPT_VFIQ |CPU_INTERRUPT_VIRQ |CPU_INTERRUPT_EXITTB );
@@ -484,7 +484,7 @@ void arm_cpu_update_virq(ARMCPU *cpu)bool new_state = (env->cp15.hcr_el2 &HCR_VI ) || (env->irq_line_state &CPU_INTERRUPT_VIRQ ); -if (new_state != ((cs->interrupt_request &CPU_INTERRUPT_VIRQ ) !=0 )) { +if (new_state != ((cpu_interrupt_request (cs) &CPU_INTERRUPT_VIRQ ) !=0 )) {if (new_state) {cpu_interrupt (cs,CPU_INTERRUPT_VIRQ ); }else {
@@ -505,7 +505,7 @@ void arm_cpu_update_vfiq(ARMCPU *cpu)bool new_state = (env->cp15.hcr_el2 &HCR_VF ) || (env->irq_line_state &CPU_INTERRUPT_VFIQ ); -if (new_state != ((cs->interrupt_request &CPU_INTERRUPT_VFIQ ) !=0 )) { +if (new_state != ((cpu_interrupt_request (cs) &CPU_INTERRUPT_VFIQ ) !=0 )) {if (new_state) {cpu_interrupt (cs,CPU_INTERRUPT_VFIQ ); }else {
target/arm/helper.c +7 -9
@@ -1893,23 +1893,24 @@ static uint64_t isr_read(CPUARMState *env, const ARMCPRegInfo *ri)CPUState *cs =ENV_GET_CPU (env);uint64_t hcr_el2 =arm_hcr_el2_eff (env);uint64_t ret =0 ; +uint32_t interrupt_request =cpu_interrupt_request (cs);if (hcr_el2 &HCR_IMO ) { -if (cs->interrupt_request &CPU_INTERRUPT_VIRQ ) { +if (interrupt_request &CPU_INTERRUPT_VIRQ ) { ret |=CPSR_I ; } }else { -if (cs->interrupt_request &CPU_INTERRUPT_HARD ) { +if (interrupt_request &CPU_INTERRUPT_HARD ) { ret |=CPSR_I ; } }if (hcr_el2 &HCR_FMO ) { -if (cs->interrupt_request &CPU_INTERRUPT_VFIQ ) { +if (interrupt_request &CPU_INTERRUPT_VFIQ ) { ret |=CPSR_F ; } }else { -if (cs->interrupt_request &CPU_INTERRUPT_FIQ ) { +if (interrupt_request &CPU_INTERRUPT_FIQ ) { ret |=CPSR_F ; } }
@@ -9647,10 +9648,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);
@@ -9665,7 +9663,7 @@ void arm_cpu_do_interrupt(CPUState *cs)arm_call_el_change_hook (cpu);if (!kvm_enabled ()) { - cs->interrupt_request |=CPU_INTERRUPT_EXITTB ; +cpu_interrupt_request_or (cs,CPU_INTERRUPT_EXITTB ); } }#endif /* !CONFIG_USER_ONLY */
target/arm/machine.c +1 -1
@@ -693,7 +693,7 @@ static int cpu_post_load(void *opaque, int version_id)if (env->irq_line_state ==UINT32_MAX ) {CPUState *cs =CPU (cpu); - env->irq_line_state = cs->interrupt_request & + env->irq_line_state =cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_FIQ |CPU_INTERRUPT_VIRQ |CPU_INTERRUPT_VFIQ ); }
Signature · 1 line
2.17.1
PATCH v7 39/73 i386: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/i386/cpu.c | 2 +- target/i386/helper.c | 4 ++-- target/i386/svm_helper.c | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-)
target/i386/cpu.c +1 -1
@@ -5686,7 +5686,7 @@ int x86_cpu_pending_interrupt(CPUState *cs, int interrupt_request)static bool x86_cpu_has_work (CPUState *cs) { -return x86_cpu_pending_interrupt (cs, cs->interrupt_request) !=0 ; +return x86_cpu_pending_interrupt (cs,cpu_interrupt_request (cs)) !=0 ; }static void x86_disas_set_info (CPUState *cs,disassemble_info *info)
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 =cpu_interrupt_request (cs) &CPU_INTERRUPT_SIPI ; *save = *env;cpu_reset (cs); - cs->interrupt_request = sipi; +cpu_interrupt_request_set (cs, sipi);memcpy (&env->start_init_save, &save->start_init_save, offsetof(CPUX86State , end_init_save) - offsetof(CPUX86State , start_init_save));
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 ; +cpu_interrupt_request_or (cs,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 (cpu_interrupt_request (cs) &CPU_INTERRUPT_VIRQ ) { int_ctl |=V_IRQ_MASK ; } x86_stl_phys(cs,
Signature · 1 line
2.17.1
PATCH v7 40/73 i386/kvm: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/i386/kvm.c | 58 ++++++++++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 23 deletions(-)
target/i386/kvm.c +35 -23
@@ -2888,11 +2888,14 @@ static int kvm_put_vcpu_events(X86CPU *cpu, int level) events.smi.smm = !!(env->hflags &HF_SMM_MASK ); events.smi.smm_inside_nmi = !!(env->hflags2 &HF2_SMM_INSIDE_NMI_MASK );if (kvm_irqchip_in_kernel ()) { +uint32_t interrupt_request; +/* As soon as these are moved to the kernel, remove them * from cs->interrupt_request. */ - events.smi.pending = cs->interrupt_request &CPU_INTERRUPT_SMI ; - events.smi.latched_init = cs->interrupt_request &CPU_INTERRUPT_INIT ; + interrupt_request =cpu_interrupt_request (cs); + events.smi.pending = interrupt_request &CPU_INTERRUPT_SMI ; + events.smi.latched_init = interrupt_request &CPU_INTERRUPT_INIT ;cpu_reset_interrupt (cs,CPU_INTERRUPT_INIT |CPU_INTERRUPT_SMI ); }else {/* Keep these in cs->interrupt_request. */
@@ -3183,14 +3186,14 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) {X86CPU *x86_cpu =X86_CPU (cpu);CPUX86State *env = &x86_cpu->env; +uint32_t interrupt_request;int ret; + interrupt_request =cpu_interrupt_request (cpu);/* Inject NMI */ -if (cpu->interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) { -if (cpu->interrupt_request &CPU_INTERRUPT_NMI ) { -qemu_mutex_lock_iothread (); +if (interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) { +if (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 );if (ret <0 ) {
@@ -3198,10 +3201,8 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) strerror(-ret)); } } -if (cpu->interrupt_request &CPU_INTERRUPT_SMI ) { -qemu_mutex_lock_iothread (); +if (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 );if (ret <0 ) {
@@ -3215,16 +3216,22 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)qemu_mutex_lock_iothread (); } +/* +* We might have cleared some bits in cpu->interrupt_request since reading +* it; read it again. +*/ + interrupt_request =cpu_interrupt_request (cpu); +/* Force the VCPU out of its inner loop to process any INIT requests * or (for userspace APIC, but it is cheap to combine the checks here) * pending TPR access reports. */ -if (cpu->interrupt_request & (CPU_INTERRUPT_INIT |CPU_INTERRUPT_TPR )) { -if ((cpu->interrupt_request &CPU_INTERRUPT_INIT ) && +if (interrupt_request & (CPU_INTERRUPT_INIT |CPU_INTERRUPT_TPR )) { +if ((interrupt_request &CPU_INTERRUPT_INIT ) && !(env->hflags &HF_SMM_MASK )) { cpu->exit_request =1 ; } -if (cpu->interrupt_request &CPU_INTERRUPT_TPR ) { +if (interrupt_request &CPU_INTERRUPT_TPR ) { cpu->exit_request =1 ; } }
@@ -3232,7 +3239,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)if (!kvm_pic_in_kernel ()) {/* Try to inject an interrupt if the guest can accept it */ if (run->ready_for_interrupt_injection && - (cpu->interrupt_request &CPU_INTERRUPT_HARD ) && + (interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) {int irq;
@@ -3256,7 +3263,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)* interrupt, request an interrupt window exit. This will * cause a return to userspace as soon as the guest is ready to * receive interrupts. */ -if ((cpu->interrupt_request &CPU_INTERRUPT_HARD )) { +if ((cpu_interrupt_request (cpu) &CPU_INTERRUPT_HARD )) { run->request_interrupt_window =1 ; }else { run->request_interrupt_window =0 ;
@@ -3302,8 +3309,9 @@ int kvm_arch_process_async_events(CPUState *cs) {X86CPU *cpu =X86_CPU (cs);CPUX86State *env = &cpu->env; +uint32_t interrupt_request; -if (cs->interrupt_request &CPU_INTERRUPT_MCE ) { +if (cpu_interrupt_request (cs) &CPU_INTERRUPT_MCE ) {/* We must not raise CPU_INTERRUPT_MCE if it's not supported. */ assert (env->mcg_cap);
@@ -3326,7 +3334,7 @@ int kvm_arch_process_async_events(CPUState *cs) } } -if ((cs->interrupt_request &CPU_INTERRUPT_INIT ) && +if ((cpu_interrupt_request (cs) &CPU_INTERRUPT_INIT ) && !(env->hflags &HF_SMM_MASK )) {kvm_cpu_synchronize_state (cs);do_cpu_init (cpu);
@@ -3336,20 +3344,21 @@ int kvm_arch_process_async_events(CPUState *cs)return 0 ; } -if (cs->interrupt_request &CPU_INTERRUPT_POLL ) { +if (cpu_interrupt_request (cs) &CPU_INTERRUPT_POLL ) {cpu_reset_interrupt (cs,CPU_INTERRUPT_POLL );apic_poll_irq (cpu->apic_state); } -if (((cs->interrupt_request &CPU_INTERRUPT_HARD ) && + interrupt_request =cpu_interrupt_request (cs); +if (((interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) || - (cs->interrupt_request &CPU_INTERRUPT_NMI )) { + (interrupt_request &CPU_INTERRUPT_NMI )) {cpu_halted_set (cs,0 ); } -if (cs->interrupt_request &CPU_INTERRUPT_SIPI ) { +if (interrupt_request &CPU_INTERRUPT_SIPI ) {kvm_cpu_synchronize_state (cs);do_cpu_sipi (cpu); } -if (cs->interrupt_request &CPU_INTERRUPT_TPR ) { +if (cpu_interrupt_request (cs) &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,
@@ -3363,10 +3372,13 @@ static int kvm_handle_halt(X86CPU *cpu) {CPUState *cs =CPU (cpu);CPUX86State *env = &cpu->env; +uint32_t interrupt_request; + + interrupt_request =cpu_interrupt_request (cs); -if (!((cs->interrupt_request &CPU_INTERRUPT_HARD ) && +if (!((interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) && - !(cs->interrupt_request &CPU_INTERRUPT_NMI )) { + !(interrupt_request &CPU_INTERRUPT_NMI )) {cpu_halted_set (cs,1 );return EXCP_HLT ; }
Signature · 1 line
2.17.1
PATCH v7 41/73 i386/hax-all: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/i386/hax-all.c | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-)
target/i386/hax-all.c +17 -13
@@ -284,7 +284,7 @@ int hax_vm_destroy(struct hax_vm *vm)static void hax_handle_interrupt (CPUState *cpu,int mask) { - cpu->interrupt_request |= mask; +cpu_interrupt_request_or (cpu, mask);if (!qemu_cpu_is_self (cpu)) {qemu_cpu_kick (cpu);
@@ -418,7 +418,7 @@ static int hax_vcpu_interrupt(CPUArchState *env)* Unlike KVM, HAX kernel check for the eflags, instead of qemu */ if (ht->ready_for_interrupt_injection && - (cpu->interrupt_request &CPU_INTERRUPT_HARD )) { + (cpu_interrupt_request (cpu) &CPU_INTERRUPT_HARD )) {int irq; irq =cpu_get_pic_interrupt (env);
@@ -432,7 +432,7 @@ static int hax_vcpu_interrupt(CPUArchState *env)* interrupt, request an interrupt window exit. This will * cause a return to userspace as soon as the guest is ready to * receive interrupts. */ -if ((cpu->interrupt_request &CPU_INTERRUPT_HARD )) { +if ((cpu_interrupt_request (cpu) &CPU_INTERRUPT_HARD )) { ht->request_interrupt_window =1 ; }else { ht->request_interrupt_window =0 ;
@@ -473,19 +473,19 @@ static int hax_vcpu_hax_exec(CPUArchState *env)cpu_halted_set (cpu,0 ); -if (cpu->interrupt_request &CPU_INTERRUPT_POLL ) { +if (cpu_interrupt_request (cpu) &CPU_INTERRUPT_POLL ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );apic_poll_irq (x86_cpu->apic_state); } -if (cpu->interrupt_request &CPU_INTERRUPT_INIT ) { +if (cpu_interrupt_request (cpu) &CPU_INTERRUPT_INIT ) {DPRINTF ("\nhax_vcpu_hax_exec: handling INIT for %d\n" , cpu->cpu_index);do_cpu_init (x86_cpu);hax_vcpu_sync_state (env,1 ); } -if (cpu->interrupt_request &CPU_INTERRUPT_SIPI ) { +if (cpu_interrupt_request (cpu) &CPU_INTERRUPT_SIPI ) {DPRINTF ("hax_vcpu_hax_exec: handling SIPI for %d\n" , cpu->cpu_index);hax_vcpu_sync_state (env,0 );
@@ -544,13 +544,17 @@ static int hax_vcpu_hax_exec(CPUArchState *env) ret =-1 ;break ;case HAX_EXIT_HLT : -if (!(cpu->interrupt_request &CPU_INTERRUPT_HARD ) && - !(cpu->interrupt_request &CPU_INTERRUPT_NMI )) { -/* hlt instruction with interrupt disabled is shutdown */ - env->eflags |=IF_MASK ; -cpu_halted_set (cpu,1 ); - cpu->exception_index =EXCP_HLT ; - ret =1 ; + { +uint32_t interrupt_request =cpu_interrupt_request (cpu); + +if (!(interrupt_request &CPU_INTERRUPT_HARD ) && + !(interrupt_request &CPU_INTERRUPT_NMI )) { +/* hlt instruction with interrupt disabled is shutdown */ + env->eflags |=IF_MASK ; +cpu_halted_set (cpu,1 ); + cpu->exception_index =EXCP_HLT ; + ret =1 ; + } }break ;/* these situations will continue to hax module */
Signature · 1 line
2.17.1
PATCH v7 42/73 i386/whpx-all: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/i386/whpx-all.c | 41 ++++++++++++++++++++++++----------------- 1 file changed, 24 insertions(+), 17 deletions(-)
target/i386/whpx-all.c +24 -17
@@ -690,12 +690,14 @@ static int whpx_handle_portio(CPUState *cpu,static int whpx_handle_halt (CPUState *cpu) {struct CPUX86State *env = (CPUArchState *)(cpu->env_ptr); +uint32_t interrupt_request;int ret =0 ;qemu_mutex_lock_iothread (); -if (!((cpu->interrupt_request &CPU_INTERRUPT_HARD ) && + interrupt_request =cpu_interrupt_request (cpu); +if (!((interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) && - !(cpu->interrupt_request &CPU_INTERRUPT_NMI )) { + !(interrupt_request &CPU_INTERRUPT_NMI )) { cpu->exception_index =EXCP_HLT ;cpu_halted_set (cpu, true); ret =1 ;
@@ -713,6 +715,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)struct CPUX86State *env = (CPUArchState *)(cpu->env_ptr);X86CPU *x86_cpu =X86_CPU (cpu);int irq; +uint32_t interrupt_request;uint8_t tpr;WHV_X64_PENDING_INTERRUPTION_REGISTER new_int;UINT32 reg_count =0 ;
@@ -724,17 +727,19 @@ static void whpx_vcpu_pre_run(CPUState *cpu)qemu_mutex_lock_iothread (); + interrupt_request =cpu_interrupt_request (cpu); +/* Inject NMI */ if (!vcpu->interruption_pending && - cpu->interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) { -if (cpu->interrupt_request &CPU_INTERRUPT_NMI ) { + interrupt_request & (CPU_INTERRUPT_NMI |CPU_INTERRUPT_SMI )) { +if (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 ) { +if (interrupt_request &CPU_INTERRUPT_SMI ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_SMI ); } }
@@ -743,12 +748,12 @@ static void whpx_vcpu_pre_run(CPUState *cpu)* Force the VCPU out of its inner loop to process any INIT requests or * commit pending TPR access. */ -if (cpu->interrupt_request & (CPU_INTERRUPT_INIT |CPU_INTERRUPT_TPR )) { -if ((cpu->interrupt_request &CPU_INTERRUPT_INIT ) && +if (interrupt_request & (CPU_INTERRUPT_INIT |CPU_INTERRUPT_TPR )) { +if ((interrupt_request &CPU_INTERRUPT_INIT ) && !(env->hflags &HF_SMM_MASK )) { cpu->exit_request =1 ; } -if (cpu->interrupt_request &CPU_INTERRUPT_TPR ) { +if (interrupt_request &CPU_INTERRUPT_TPR ) { cpu->exit_request =1 ; } }
@@ -757,7 +762,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)if (!vcpu->interruption_pending && vcpu->interruptable && (env->eflags &IF_MASK )) {assert (!new_int.InterruptionPending); -if (cpu->interrupt_request &CPU_INTERRUPT_HARD ) { +if (interrupt_request &CPU_INTERRUPT_HARD ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_HARD ); irq =cpu_get_pic_interrupt (env);if (irq >=0 ) {
@@ -787,7 +792,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)/* Update the state of the interrupt delivery notification */ if (!vcpu->window_registered && - cpu->interrupt_request &CPU_INTERRUPT_HARD ) { +cpu_interrupt_request (cpu) &CPU_INTERRUPT_HARD ) { reg_values[reg_count].DeliverabilityNotifications.InterruptNotification =1 ; vcpu->window_registered =1 ;
@@ -840,8 +845,9 @@ static void whpx_vcpu_process_async_events(CPUState *cpu)struct CPUX86State *env = (CPUArchState *)(cpu->env_ptr);X86CPU *x86_cpu =X86_CPU (cpu);struct whpx_vcpu *vcpu =get_whpx_vcpu (cpu); +uint32_t interrupt_request; -if ((cpu->interrupt_request &CPU_INTERRUPT_INIT ) && +if ((cpu_interrupt_request (cpu) &CPU_INTERRUPT_INIT ) && !(env->hflags &HF_SMM_MASK )) {do_cpu_init (x86_cpu);
@@ -849,25 +855,26 @@ static void whpx_vcpu_process_async_events(CPUState *cpu) vcpu->interruptable = true; } -if (cpu->interrupt_request &CPU_INTERRUPT_POLL ) { +if (cpu_interrupt_request (cpu) &CPU_INTERRUPT_POLL ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );apic_poll_irq (x86_cpu->apic_state); } -if (((cpu->interrupt_request &CPU_INTERRUPT_HARD ) && + interrupt_request =cpu_interrupt_request (cpu); +if (((interrupt_request &CPU_INTERRUPT_HARD ) && (env->eflags &IF_MASK )) || - (cpu->interrupt_request &CPU_INTERRUPT_NMI )) { + (interrupt_request &CPU_INTERRUPT_NMI )) {cpu_halted_set (cpu, false); } -if (cpu->interrupt_request &CPU_INTERRUPT_SIPI ) { +if (interrupt_request &CPU_INTERRUPT_SIPI ) {if (!cpu->vcpu_dirty) {whpx_get_registers (cpu); }do_cpu_sipi (x86_cpu); } -if (cpu->interrupt_request &CPU_INTERRUPT_TPR ) { +if (cpu_interrupt_request (cpu) &CPU_INTERRUPT_TPR ) {cpu_reset_interrupt (cpu,CPU_INTERRUPT_TPR );if (!cpu->vcpu_dirty) {whpx_get_registers (cpu);
@@ -1350,7 +1357,7 @@ static void whpx_memory_init(void)static void whpx_handle_interrupt (CPUState *cpu,int mask) { - cpu->interrupt_request |= mask; +cpu_interrupt_request_or (cpu, mask);if (!qemu_cpu_is_self (cpu)) {qemu_cpu_kick (cpu);
Signature · 1 line
2.17.1
PATCH v7 43/73 i386/hvf: convert to cpu_request_interrupt
In reply to Emilio G. Cota--- target/i386/hvf/hvf.c | 8 +++++--- target/i386/hvf/x86hvf.c | 26 +++++++++++++++----------- 2 files changed, 20 insertions(+), 14 deletions(-)
target/i386/hvf/hvf.c +5 -3
@@ -249,7 +249,7 @@ void update_apic_tpr(CPUState *cpu)static void hvf_handle_interrupt (CPUState * cpu,int mask) { - cpu->interrupt_request |= mask; +cpu_interrupt_request_or (cpu, mask);if (!qemu_cpu_is_self (cpu)) {qemu_cpu_kick (cpu); }
@@ -701,10 +701,12 @@ int hvf_vcpu_exec(CPUState *cpu) ret =0 ;switch (exit_reason) {case EXIT_REASON_HLT : { +uint32_t interrupt_request =cpu_interrupt_request (cpu); +macvm_set_rip (cpu, rip + ins_len); -if (!((cpu->interrupt_request &CPU_INTERRUPT_HARD ) && +if (!((interrupt_request &CPU_INTERRUPT_HARD ) && (EFLAGS (env) &IF_MASK )) - && !(cpu->interrupt_request &CPU_INTERRUPT_NMI ) && + && !(interrupt_request &CPU_INTERRUPT_NMI ) && !(idtvec_info &VMCS_IDT_VEC_VALID )) {cpu_halted_set (cpu,1 ); ret =EXCP_HLT ;
target/i386/hvf/x86hvf.c +15 -11
@@ -358,6 +358,7 @@ bool hvf_inject_interrupts(CPUState *cpu_state)uint8_t vector;uint64_t intr_type; +uint32_t interrupt_request;bool have_event = true;if (env->interrupt_injected !=-1 ) { vector = env->interrupt_injected;
@@ -400,7 +401,7 @@ bool hvf_inject_interrupts(CPUState *cpu_state) }; } -if (cpu_state->interrupt_request &CPU_INTERRUPT_NMI ) { +if (cpu_interrupt_request (cpu_state) &CPU_INTERRUPT_NMI ) {if (!(env->hflags2 &HF2_NMI_MASK ) && !(info &VMCS_INTR_VALID )) {cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_NMI ); info =VMCS_INTR_VALID |VMCS_INTR_T_NMI |NMI_VEC ;
@@ -411,7 +412,7 @@ bool hvf_inject_interrupts(CPUState *cpu_state) }if (!(env->hflags &HF_INHIBIT_IRQ_MASK ) && - (cpu_state->interrupt_request &CPU_INTERRUPT_HARD ) && + (cpu_interrupt_request (cpu_state) &CPU_INTERRUPT_HARD ) && (EFLAGS (env) &IF_MASK ) && !(info &VMCS_INTR_VALID )) {int line =cpu_get_pic_interrupt (&x86cpu->env);cpu_reset_interrupt (cpu_state,CPU_INTERRUPT_HARD );
@@ -420,39 +421,42 @@ bool hvf_inject_interrupts(CPUState *cpu_state) VMCS_INTR_VALID | VMCS_INTR_T_HWINTR); } } -if (cpu_state->interrupt_request &CPU_INTERRUPT_HARD ) { +if (cpu_interrupt_request (cpu_state) &CPU_INTERRUPT_HARD ) {vmx_set_int_window_exiting (cpu_state); } -return (cpu_state->interrupt_request - & (CPU_INTERRUPT_INIT |CPU_INTERRUPT_TPR )); +return cpu_interrupt_request (cpu_state) & (CPU_INTERRUPT_INIT | +CPU_INTERRUPT_TPR ); }int hvf_process_events (CPUState *cpu_state) {X86CPU *cpu =X86_CPU (cpu_state);CPUX86State *env = &cpu->env; +uint32_t interrupt_request;EFLAGS (env) =rreg (cpu_state->hvf_fd,HV_X86_RFLAGS ); -if (cpu_state->interrupt_request &CPU_INTERRUPT_INIT ) { +if (cpu_interrupt_request (cpu_state) &CPU_INTERRUPT_INIT ) {hvf_cpu_synchronize_state (cpu_state);do_cpu_init (cpu); } -if (cpu_state->interrupt_request &CPU_INTERRUPT_POLL ) { +if (cpu_interrupt_request (cpu_state) &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 ) && + + interrupt_request =cpu_interrupt_request (cpu_state); +if (((interrupt_request &CPU_INTERRUPT_HARD ) && (EFLAGS (env) &IF_MASK )) || - (cpu_state->interrupt_request &CPU_INTERRUPT_NMI )) { + (interrupt_request &CPU_INTERRUPT_NMI )) {cpu_halted_set (cpu_state,0 ); } -if (cpu_state->interrupt_request &CPU_INTERRUPT_SIPI ) { +if (interrupt_request &CPU_INTERRUPT_SIPI ) {hvf_cpu_synchronize_state (cpu_state);do_cpu_sipi (cpu); } -if (cpu_state->interrupt_request &CPU_INTERRUPT_TPR ) { +if (cpu_interrupt_request (cpu_state) &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,
Signature · 1 line
2.17.1
PATCH v7 44/73 ppc: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- hw/ppc/ppc.c | 2 +- target/ppc/kvm.c | 4 ++-- target/ppc/translate_init.inc.c | 14 +++++++------- 3 files changed, 10 insertions(+), 10 deletions(-)
hw/ppc/ppc.c +1 -1
@@ -89,7 +89,7 @@ void ppc_set_irq(PowerPCCPU *cpu, int n_IRQ, int level)LOG_IRQ ("%s: %p n_IRQ %d level %d => pending %08" PRIx32"req %08x\n" , __func__, env, n_IRQ, level, - env->pending_interrupts,CPU (cpu)->interrupt_request); + env->pending_interrupts,cpu_interrupt_request (CPU (cpu)));if (locked) {qemu_mutex_unlock_iothread ();
target/ppc/kvm.c +2 -2
@@ -1339,7 +1339,7 @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)* interrupt, reset, etc) in PPC-specific env->irq_input_state. */ if (!cap_interrupt_level && run->ready_for_interrupt_injection && - (cs->interrupt_request &CPU_INTERRUPT_HARD ) && + (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) && (env->irq_input_state & (1 <<PPC_INPUT_INT ))) {/* For now KVM disregards the 'irq' argument. However, in the
@@ -1381,7 +1381,7 @@ static int kvmppc_handle_halt(PowerPCCPU *cpu)CPUState *cs =CPU (cpu);CPUPPCState *env = &cpu->env; -if (!(cs->interrupt_request &CPU_INTERRUPT_HARD ) && (msr_ee)) { +if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) && (msr_ee)) {cpu_halted_set (cs,1 ); cs->exception_index =EXCP_HLT ; }
target/ppc/translate_init.inc.c +7 -7
@@ -8469,7 +8469,7 @@ static bool cpu_has_work_POWER7(CPUState *cs)CPUPPCState *env = &cpu->env;if (cpu_halted (cs)) { -if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) { +if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false; } if ((env->pending_interrupts & (1u << PPC_INTERRUPT_EXT)) &&
@@ -8493,7 +8493,7 @@ static bool cpu_has_work_POWER7(CPUState *cs) }return false; }else { -return msr_ee && (cs->interrupt_request &CPU_INTERRUPT_HARD ); +return msr_ee && (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ); } }
@@ -8623,7 +8623,7 @@ static bool cpu_has_work_POWER8(CPUState *cs)CPUPPCState *env = &cpu->env;if (cpu_halted (cs)) { -if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) { +if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false; } if ((env->pending_interrupts & (1u << PPC_INTERRUPT_EXT)) &&
@@ -8655,7 +8655,7 @@ static bool cpu_has_work_POWER8(CPUState *cs) }return false; }else { -return msr_ee && (cs->interrupt_request &CPU_INTERRUPT_HARD ); +return msr_ee && (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ); } }
@@ -8817,7 +8817,7 @@ static bool cpu_has_work_POWER9(CPUState *cs)if (cpu_halted (cs)) {uint64_t psscr = env->spr[SPR_PSSCR ]; -if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) { +if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false; }
@@ -8863,7 +8863,7 @@ static bool cpu_has_work_POWER9(CPUState *cs) }return false; }else { -return msr_ee && (cs->interrupt_request &CPU_INTERRUPT_HARD ); +return msr_ee && (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ); } }
@@ -10332,7 +10332,7 @@ static bool ppc_cpu_has_work(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; -return msr_ee && (cs->interrupt_request &CPU_INTERRUPT_HARD ); +return msr_ee && (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ); }/* CPUClass::reset() */
Signature · 1 line
2.17.1
PATCH v7 45/73 sh4: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/sh4/cpu.c | 2 +- target/sh4/helper.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
target/sh4/cpu.c +1 -1
@@ -45,7 +45,7 @@ static void superh_cpu_synchronize_from_tb(CPUState *cs, TranslationBlock *tb)static bool superh_cpu_has_work (CPUState *cs) { -return cs->interrupt_request &CPU_INTERRUPT_HARD ; +return cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ; }/* CPUClass::reset() */
target/sh4/helper.c +1 -1
@@ -83,7 +83,7 @@ void superh_cpu_do_interrupt(CPUState *cs) {SuperHCPU *cpu =SUPERH_CPU (cs);CPUSH4State *env = &cpu->env; -int do_irq = cs->interrupt_request &CPU_INTERRUPT_HARD ; +int do_irq =cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ;int do_exp, irq_vector = cs->exception_index;/* prioritize exceptions over interrupts */
Signature · 1 line
2.17.1
PATCH v7 46/73 cris: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/cris/cpu.c | 2 +- target/cris/helper.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-)
target/cris/cpu.c +1 -1
@@ -37,7 +37,7 @@ static void cris_cpu_set_pc(CPUState *cs, vaddr value)static bool cris_cpu_has_work (CPUState *cs) { -return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); }/* CPUClass::reset() */
target/cris/helper.c +3 -3
@@ -116,7 +116,7 @@ int cris_cpu_handle_mmu_fault(CPUState *cs, vaddr address, int size, int rw,if (r >0 ) {qemu_log_mask (CPU_LOG_MMU ,"%s returns %d irqreq=%x addr=%" VADDR_PRIx" phy=%x vec=%x" -" pc=%x\n" , __func__, r, cs->interrupt_request, address, +" pc=%x\n" , __func__, r,cpu_interrupt_request (cs), address, res.phy, res.bf_vec, env->pc); }return r;
@@ -130,7 +130,7 @@ void crisv10_cpu_do_interrupt(CPUState *cs)D_LOG ("exception index=%d interrupt_req=%d\n" , cs->exception_index, - cs->interrupt_request); +cpu_interrupt_request (cs));if (env->dslot) {/* CRISv10 never takes interrupts while in a delay-slot. */
@@ -192,7 +192,7 @@ void cris_cpu_do_interrupt(CPUState *cs)D_LOG ("exception index=%d interrupt_req=%d\n" , cs->exception_index, - cs->interrupt_request); +cpu_interrupt_request (cs));switch (cs->exception_index) {case EXCP_BREAK :
Signature · 1 line
2.17.1
PATCH v7 47/73 hppa: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/hppa/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/hppa/cpu.c +1 -1
@@ -60,7 +60,7 @@ static void hppa_cpu_synchronize_from_tb(CPUState *cs, TranslationBlock *tb)static bool hppa_cpu_has_work (CPUState *cs) { -return cs->interrupt_request &CPU_INTERRUPT_HARD ; +return cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ; }static void hppa_cpu_disas_set_info (CPUState *cs,disassemble_info *info)
Signature · 1 line
2.17.1
PATCH v7 48/73 lm32: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/lm32/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/lm32/cpu.c +1 -1
@@ -101,7 +101,7 @@ static void lm32_cpu_init_cfg_reg(LM32CPU *cpu)static bool lm32_cpu_has_work (CPUState *cs) { -return cs->interrupt_request &CPU_INTERRUPT_HARD ; +return cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ; }/* CPUClass::reset() */
Signature · 1 line
2.17.1
PATCH v7 49/73 m68k: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/m68k/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/m68k/cpu.c +1 -1
@@ -34,7 +34,7 @@ static void m68k_cpu_set_pc(CPUState *cs, vaddr value)static bool m68k_cpu_has_work (CPUState *cs) { -return cs->interrupt_request &CPU_INTERRUPT_HARD ; +return cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ; }static void m68k_set_feature (CPUM68KState *env,int feature)
Signature · 1 line
2.17.1
PATCH v7 50/73 mips: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/mips/cpu.c | 7 ++++--- target/mips/kvm.c | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-)
target/mips/cpu.c +4 -3
@@ -56,11 +56,12 @@ static bool mips_cpu_has_work(CPUState *cs)MIPSCPU *cpu =MIPS_CPU (cs);CPUMIPSState *env = &cpu->env;bool has_work = false; +uint32_t interrupt_request =cpu_interrupt_request (cs);/* Prior to MIPS Release 6 it is implementation dependent if non-enabled interrupts wake-up the CPU, however most of the implementations only check for interrupts that can be taken. */ -if ((cs->interrupt_request &CPU_INTERRUPT_HARD ) && +if ((interrupt_request &CPU_INTERRUPT_HARD ) &&cpu_mips_hw_interrupts_pending (env)) {if (cpu_mips_hw_interrupts_enabled (env) || (env->insn_flags &ISA_MIPS32R6 )) {
@@ -72,7 +73,7 @@ static bool mips_cpu_has_work(CPUState *cs)if (env->CP0_Config3 & (1 <<CP0C3_MT )) {/* The QEMU model will issue an _WAKE request whenever the CPUs should be woken up. */ -if (cs->interrupt_request &CPU_INTERRUPT_WAKE ) { +if (interrupt_request &CPU_INTERRUPT_WAKE ) { has_work = true; }
@@ -82,7 +83,7 @@ static bool mips_cpu_has_work(CPUState *cs) }/* MIPS Release 6 has the ability to halt the CPU. */ if (env->CP0_Config5 & (1 <<CP0C5_VP )) { -if (cs->interrupt_request &CPU_INTERRUPT_WAKE ) { +if (interrupt_request &CPU_INTERRUPT_WAKE ) { has_work = true; }if (!mips_vp_active (env)) {
target/mips/kvm.c +1 -1
@@ -135,7 +135,7 @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)qemu_mutex_lock_iothread (); -if ((cs->interrupt_request &CPU_INTERRUPT_HARD ) && +if ((cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) &&cpu_mips_io_interrupts_pending (cpu)) { intr.cpu =-1 ; intr.irq =2 ;
Signature · 1 line
2.17.1
PATCH v7 51/73 nios: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/nios2/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/nios2/cpu.c +1 -1
@@ -36,7 +36,7 @@ static void nios2_cpu_set_pc(CPUState *cs, vaddr value)static bool nios2_cpu_has_work (CPUState *cs) { -return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); }/* CPUClass::reset() */
Signature · 1 line
2.17.1
PATCH v7 52/73 s390x: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- hw/intc/s390_flic.c | 2 +- target/s390x/cpu.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
hw/intc/s390_flic.c +1 -1
@@ -189,7 +189,7 @@ static void qemu_s390_flic_notify(uint32_t type)CPU_FOREACH (cs) {S390CPU *cpu =S390_CPU (cs); - cs->interrupt_request |=CPU_INTERRUPT_HARD ; +cpu_interrupt_request_or (cs,CPU_INTERRUPT_HARD );/* ignore CPUs that are not sleeping */ if (s390_cpu_get_state(cpu) != S390_CPU_STATE_OPERATING &&
target/s390x/cpu.c +1 -1
@@ -62,7 +62,7 @@ static bool s390_cpu_has_work(CPUState *cs)return false; } -if (!(cs->interrupt_request &CPU_INTERRUPT_HARD )) { +if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false; }
Signature · 1 line
2.17.1
PATCH v7 53/73 alpha: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/alpha/cpu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
target/alpha/cpu.c +4 -4
@@ -42,10 +42,10 @@ static bool alpha_cpu_has_work(CPUState *cs)assume that if a CPU really wants to stay asleep, it will mask interrupts at the chipset level, which will prevent these bits from being set in the first place. */ -return cs->interrupt_request & (CPU_INTERRUPT_HARD - |CPU_INTERRUPT_TIMER - |CPU_INTERRUPT_SMP - |CPU_INTERRUPT_MCHK ); +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD + |CPU_INTERRUPT_TIMER + |CPU_INTERRUPT_SMP + |CPU_INTERRUPT_MCHK ); }static void alpha_cpu_disas_set_info (CPUState *cpu,disassemble_info *info)
Signature · 1 line
2.17.1
PATCH v7 54/73 moxie: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/moxie/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/moxie/cpu.c +1 -1
@@ -33,7 +33,7 @@ static void moxie_cpu_set_pc(CPUState *cs, vaddr value)static bool moxie_cpu_has_work (CPUState *cs) { -return cs->interrupt_request &CPU_INTERRUPT_HARD ; +return cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ; }static void moxie_cpu_reset (CPUState *s)
Signature · 1 line
2.17.1
PATCH v7 55/73 sparc: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- hw/sparc64/sparc64.c | 4 ++-- target/sparc/cpu.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
hw/sparc64/sparc64.c +2 -2
@@ -56,7 +56,7 @@ void cpu_check_irqs(CPUSPARCState *env)/* The bit corresponding to psrpil is (1<< psrpil), the next bit is (2 << psrpil). */ if (pil < (2 << env->psrpil)) { -if (cs->interrupt_request &CPU_INTERRUPT_HARD ) { +if (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) {trace_sparc64_cpu_check_irqs_reset_irq (env->interrupt_index); env->interrupt_index =0 ;cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD );
@@ -87,7 +87,7 @@ void cpu_check_irqs(CPUSPARCState *env)break ; } } - }else if (cs->interrupt_request &CPU_INTERRUPT_HARD ) { + }else if (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) {trace_sparc64_cpu_check_irqs_disabled (pil, env->pil_in, env->softint, env->interrupt_index); env->interrupt_index =0 ;
target/sparc/cpu.c +1 -1
@@ -708,7 +708,7 @@ static bool sparc_cpu_has_work(CPUState *cs)SPARCCPU *cpu =SPARC_CPU (cs);CPUSPARCState *env = &cpu->env; -return (cs->interrupt_request &CPU_INTERRUPT_HARD ) && +return (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) &&cpu_interrupts_enabled (env); }
Signature · 1 line
2.17.1
PATCH v7 56/73 openrisc: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- hw/openrisc/cputimer.c | 2 +- target/openrisc/cpu.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
hw/openrisc/cputimer.c +1 -1
@@ -102,7 +102,7 @@ static void openrisc_timer_cb(void *opaque)CPUState *cs =CPU (cpu); cpu->env.ttmr |=TTMR_IP ; - cs->interrupt_request |=CPU_INTERRUPT_TIMER ; +cpu_interrupt_request_or (cs,CPU_INTERRUPT_TIMER ); }switch (cpu->env.ttmr &TTMR_M ) {
target/openrisc/cpu.c +2 -2
@@ -32,8 +32,8 @@ static void openrisc_cpu_set_pc(CPUState *cs, vaddr value)static bool openrisc_cpu_has_work (CPUState *cs) { -return cs->interrupt_request & (CPU_INTERRUPT_HARD | -CPU_INTERRUPT_TIMER ); +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD | +CPU_INTERRUPT_TIMER ); }static void openrisc_disas_set_info (CPUState *cpu,disassemble_info *info)
Signature · 1 line
2.17.1
PATCH v7 57/73 unicore32: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/unicore32/cpu.c | 2 +- target/unicore32/softmmu.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
target/unicore32/cpu.c +1 -1
@@ -29,7 +29,7 @@ static void uc32_cpu_set_pc(CPUState *cs, vaddr value)static bool uc32_cpu_has_work (CPUState *cs) { -return cs->interrupt_request & +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_EXITTB ); }
target/unicore32/softmmu.c +1 -1
@@ -119,7 +119,7 @@ void uc32_cpu_do_interrupt(CPUState *cs)/* The PC already points to the proper instruction. */ env->regs[30 ] = env->regs[31 ]; env->regs[31 ] = addr; - cs->interrupt_request |=CPU_INTERRUPT_EXITTB ; +cpu_interrupt_request_or (cs,CPU_INTERRUPT_EXITTB ); } static int get_phys_addr_ucv2(CPUUniCore32State *env, uint32_t address,
Signature · 1 line
2.17.1
PATCH v7 58/73 microblaze: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- target/microblaze/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/microblaze/cpu.c +1 -1
@@ -84,7 +84,7 @@ static void mb_cpu_set_pc(CPUState *cs, vaddr value)static bool mb_cpu_has_work (CPUState *cs) { -return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); +return cpu_interrupt_request (cs) & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); }#ifndef CONFIG_USER_ONLY
Signature · 1 line
2.17.1
PATCH v7 59/73 accel/tcg: convert to cpu_interrupt_request
In reply to Emilio G. Cota--- accel/tcg/cpu-exec.c | 15 ++++++++------- accel/tcg/tcg-all.c | 12 +++++++++--- accel/tcg/translate-all.c | 2 +- 3 files changed, 18 insertions(+), 11 deletions(-)
accel/tcg/cpu-exec.c +8 -7
@@ -431,7 +431,7 @@ static inline bool cpu_handle_halt_locked(CPUState *cpu)if (cpu_halted (cpu)) {#if defined(TARGET_I386 ) && !defined(CONFIG_USER_ONLY ) -if ((cpu->interrupt_request &CPU_INTERRUPT_POLL ) +if ((cpu_interrupt_request (cpu) &CPU_INTERRUPT_POLL ) &&replay_interrupt ()) {X86CPU *x86_cpu =X86_CPU (cpu);
@@ -544,16 +544,17 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,*/ atomic_mb_set (&cpu->icount_decr.u16.high,0 ); -if (unlikely (atomic_read (&cpu->interrupt_request))) { +if (unlikely (cpu_interrupt_request (cpu))) {int interrupt_request; +qemu_mutex_lock_iothread (); - interrupt_request = cpu->interrupt_request; + interrupt_request =cpu_interrupt_request (cpu);if (unlikely (cpu->singlestep_enabled &SSTEP_NOIRQ )) {/* Mask out external interrupts for this step. */ interrupt_request &= ~CPU_INTERRUPT_SSTEP_MASK ; }if (interrupt_request &CPU_INTERRUPT_DEBUG ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_DEBUG ); cpu->exception_index =EXCP_DEBUG ;qemu_mutex_unlock_iothread ();return true;
@@ -562,7 +563,7 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,/* Do nothing */ }else if (interrupt_request &CPU_INTERRUPT_HALT ) {replay_interrupt (); - cpu->interrupt_request &= ~CPU_INTERRUPT_HALT ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_HALT );cpu_halted_set (cpu,1 ); cpu->exception_index =EXCP_HLT ;qemu_mutex_unlock_iothread ();
@@ -599,10 +600,10 @@ static inline bool cpu_handle_interrupt(CPUState *cpu, }/* The target hook may have updated the 'cpu->interrupt_request'; * reload the 'interrupt_request' value */ - interrupt_request = cpu->interrupt_request; + interrupt_request =cpu_interrupt_request (cpu); }if (interrupt_request &CPU_INTERRUPT_EXITTB ) { - cpu->interrupt_request &= ~CPU_INTERRUPT_EXITTB ; +cpu_reset_interrupt (cpu,CPU_INTERRUPT_EXITTB );/* ensure that no TB jump will be modified as the program flow was changed */ *last_tb =NULL ;
accel/tcg/tcg-all.c +9 -3
@@ -39,10 +39,16 @@ unsigned long tcg_tb_size;static void tcg_handle_interrupt (CPUState *cpu,int mask) {int old_mask; -g_assert (qemu_mutex_iothread_locked ()); - old_mask = cpu->interrupt_request; - cpu->interrupt_request |= mask; +if (!cpu_mutex_locked (cpu)) { +cpu_mutex_lock (cpu); + old_mask =cpu_interrupt_request (cpu); +cpu_interrupt_request_or (cpu, mask); +cpu_mutex_unlock (cpu); + }else { + old_mask =cpu_interrupt_request (cpu); +cpu_interrupt_request_or (cpu, mask); + }/* * If called from iothread context, wake the target cpu in
accel/tcg/translate-all.c +1 -1
@@ -2343,7 +2343,7 @@ void dump_opcount_info(FILE *f, fprintf_function cpu_fprintf)void cpu_interrupt (CPUState *cpu,int mask) {g_assert (qemu_mutex_iothread_locked ()); - cpu->interrupt_request |= mask; +cpu_interrupt_request_or (cpu, mask);atomic_set (&cpu->icount_decr.u16.high,-1 ); }
Signature · 1 line
2.17.1
PATCH v7 60/73 cpu: convert to interrupt_request
In reply to Emilio G. CotaThis finishes the conversion to interrupt_request.
--- qom/cpu.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
qom/cpu.c +2 -2
@@ -275,7 +275,7 @@ static void cpu_common_reset(CPUState *cpu)log_cpu_state (cpu, cc->reset_dump_flags); } - cpu->interrupt_request =0 ; +cpu_interrupt_request_set (cpu,0 );cpu_halted_set (cpu,0 ); cpu->mem_io_pc =0 ; cpu->mem_io_vaddr =0 ;
@@ -412,7 +412,7 @@ static vaddr cpu_adjust_watchpoint_address(CPUState *cpu, vaddr addr, int len)static void generic_handle_interrupt (CPUState *cpu,int mask) { - cpu->interrupt_request |= mask; +cpu_interrupt_request_or (cpu, mask);if (!qemu_cpu_is_self (cpu)) {qemu_cpu_kick (cpu);
Signature · 1 line
2.17.1
PATCH v7 61/73 cpu: call .cpu_has_work with the CPU lock held
In reply to Emilio G. Cota--- include/qom/cpu.h | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
include/qom/cpu.h +10 -2
@@ -85,7 +85,8 @@ struct TranslationBlock;* @parse_features: Callback to parse command line arguments. * @reset: Callback to reset the #CPUState to its initial state. * @reset_dump_flags: #CPUDumpFlags to use for reset logging. -* @has_work: Callback for checking if there is work to do. +* @has_work: Callback for checking if there is work to do. Called with the +* CPU lock held. * @do_interrupt: Callback for interrupt handling. * @do_unassigned_access: Callback for unassigned access handling. * (this is deprecated: new targets should use do_transaction_failed instead)
@@ -808,9 +809,16 @@ const char *parse_cpu_model(const char *cpu_model);static inline bool cpu_has_work (CPUState *cpu) {CPUClass *cc =CPU_GET_CLASS (cpu); +bool ret;g_assert (cc->has_work); -return cc->has_work (cpu); +if (cpu_mutex_locked (cpu)) { +return cc->has_work (cpu); + } +cpu_mutex_lock (cpu); + ret = cc->has_work (cpu); +cpu_mutex_unlock (cpu); +return ret; }/**
Signature · 1 line
2.17.1
PATCH v7 62/73 cpu: introduce cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaIt will gain some users soon.
--- include/qom/cpu.h | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
include/qom/cpu.h +34 -3
@@ -27,6 +27,7 @@#include "qapi/qapi-types-run-state.h" #include "qemu/bitmap.h" #include "qemu/fprintf-fn.h" +#include "qemu/main-loop.h" #include "qemu/rcu_queue.h" #include "qemu/queue.h" #include "qemu/thread.h"
@@ -87,6 +88,8 @@ struct TranslationBlock;* @reset_dump_flags: #CPUDumpFlags to use for reset logging. * @has_work: Callback for checking if there is work to do. Called with the * CPU lock held. +* @has_work_with_iothread_lock: Callback for checking if there is work to do. +* Called with both the BQL and the CPU lock held. * @do_interrupt: Callback for interrupt handling. * @do_unassigned_access: Callback for unassigned access handling. * (this is deprecated: new targets should use do_transaction_failed instead)
@@ -170,6 +173,7 @@ typedef struct CPUClass {void (*reset)(CPUState *cpu);int reset_dump_flags;bool (*has_work)(CPUState *cpu); +bool (*has_work_with_iothread_lock)(CPUState *cpu);void (*do_interrupt)(CPUState *cpu);CPUUnassignedAccess do_unassigned_access; void (*do_unaligned_access)(CPUState *cpu, vaddr addr,
@@ -809,14 +813,41 @@ const char *parse_cpu_model(const char *cpu_model);static inline bool cpu_has_work (CPUState *cpu) {CPUClass *cc =CPU_GET_CLASS (cpu); +bool has_cpu_lock =cpu_mutex_locked (cpu); +bool (*func)(CPUState *cpu);bool ret; +/* some targets require us to hold the BQL when checking for work */ +if (cc->has_work_with_iothread_lock) { +if (qemu_mutex_iothread_locked ()) { + func = cc->has_work_with_iothread_lock; + goto call_func; + } + +if (has_cpu_lock) { +/* avoid deadlock by acquiring the locks in order */ +cpu_mutex_unlock (cpu); + } +qemu_mutex_lock_iothread (); +cpu_mutex_lock (cpu); + + ret = cc->has_work_with_iothread_lock (cpu); + +qemu_mutex_unlock_iothread (); +if (!has_cpu_lock) { +cpu_mutex_unlock (cpu); + } +return ret; + } +g_assert (cc->has_work); -if (cpu_mutex_locked (cpu)) { -return cc->has_work (cpu); + func = cc->has_work; + call_func: +if (has_cpu_lock) { +return func (cpu); }cpu_mutex_lock (cpu); - ret = cc->has_work (cpu); + ret =func (cpu);cpu_mutex_unlock (cpu);return ret; }
Signature · 1 line
2.17.1
PATCH v7 63/73 ppc: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/ppc/translate_init.inc.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
target/ppc/translate_init.inc.c +12 -4
@@ -8468,6 +8468,8 @@ static bool cpu_has_work_POWER7(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; +g_assert (qemu_mutex_iothread_locked ()); +if (cpu_halted (cs)) {if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false;
@@ -8511,7 +8513,7 @@ POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data) pcc->pcr_supported =PCR_COMPAT_2_06 |PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER7; pcc->check_pow = check_pow_nocheck; - cc->has_work = cpu_has_work_POWER7; + cc->has_work_with_iothread_lock = cpu_has_work_POWER7; pcc->insns_flags =PPC_INSNS_BASE |PPC_ISEL |PPC_STRING |PPC_MFTB |PPC_FLOAT |PPC_FLOAT_FSEL |PPC_FLOAT_FRES | PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
@@ -8622,6 +8624,8 @@ static bool cpu_has_work_POWER8(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; +g_assert (qemu_mutex_iothread_locked ()); +if (cpu_halted (cs)) {if (!(cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD )) {return false;
@@ -8673,7 +8677,7 @@ POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data) pcc->pcr_supported =PCR_COMPAT_2_07 |PCR_COMPAT_2_06 |PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER8; pcc->check_pow = check_pow_nocheck; - cc->has_work = cpu_has_work_POWER8; + cc->has_work_with_iothread_lock = cpu_has_work_POWER8; pcc->insns_flags =PPC_INSNS_BASE |PPC_ISEL |PPC_STRING |PPC_MFTB |PPC_FLOAT |PPC_FLOAT_FSEL |PPC_FLOAT_FRES | PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
@@ -8814,6 +8818,8 @@ static bool cpu_has_work_POWER9(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; +g_assert (qemu_mutex_iothread_locked ()); +if (cpu_halted (cs)) {uint64_t psscr = env->spr[SPR_PSSCR ];
@@ -8882,7 +8888,7 @@ POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER9; pcc->check_pow = check_pow_nocheck; - cc->has_work = cpu_has_work_POWER9; + cc->has_work_with_iothread_lock = cpu_has_work_POWER9; pcc->insns_flags =PPC_INSNS_BASE |PPC_ISEL |PPC_STRING |PPC_MFTB |PPC_FLOAT |PPC_FLOAT_FSEL |PPC_FLOAT_FRES | PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
@@ -10332,6 +10338,8 @@ static bool ppc_cpu_has_work(CPUState *cs)PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env; +g_assert (qemu_mutex_iothread_locked ()); +return msr_ee && (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ); }
@@ -10531,7 +10539,7 @@ static void ppc_cpu_class_init(ObjectClass *oc, void *data) cc->class_by_name = ppc_cpu_class_by_name; pcc->parent_parse_features = cc->parse_features; cc->parse_features = ppc_cpu_parse_featurestr; - cc->has_work = ppc_cpu_has_work; + cc->has_work_with_iothread_lock = ppc_cpu_has_work; cc->do_interrupt = ppc_cpu_do_interrupt; cc->cpu_exec_interrupt = ppc_cpu_exec_interrupt; cc->dump_state = ppc_cpu_dump_state;
Signature · 1 line
2.17.1
PATCH v7 64/73 mips: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/mips/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/mips/cpu.c +3 -1
@@ -58,6 +58,8 @@ static bool mips_cpu_has_work(CPUState *cs)bool has_work = false;uint32_t interrupt_request =cpu_interrupt_request (cs); +g_assert (qemu_mutex_iothread_locked ()); +/* Prior to MIPS Release 6 it is implementation dependent if non-enabled interrupts wake-up the CPU, however most of the implementations only check for interrupts that can be taken. */
@@ -190,7 +192,7 @@ static void mips_cpu_class_init(ObjectClass *c, void *data) cc->reset = mips_cpu_reset; cc->class_by_name = mips_cpu_class_by_name; - cc->has_work = mips_cpu_has_work; + cc->has_work_with_iothread_lock = mips_cpu_has_work; cc->do_interrupt = mips_cpu_do_interrupt; cc->cpu_exec_interrupt = mips_cpu_exec_interrupt; cc->dump_state = mips_cpu_dump_state;
Signature · 1 line
2.17.1
PATCH v7 65/73 s390x: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/s390x/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/s390x/cpu.c +3 -1
@@ -56,6 +56,8 @@ static bool s390_cpu_has_work(CPUState *cs) {S390CPU *cpu =S390_CPU (cs); +g_assert (qemu_mutex_iothread_locked ()); +/* STOPPED cpus can never wake up */ if (s390_cpu_get_state (cpu) !=S390_CPU_STATE_LOAD &&s390_cpu_get_state (cpu) !=S390_CPU_STATE_OPERATING ) {
@@ -470,7 +472,7 @@ static void s390_cpu_class_init(ObjectClass *oc, void *data) scc->initial_cpu_reset = s390_cpu_initial_reset; cc->reset = s390_cpu_full_reset; cc->class_by_name = s390_cpu_class_by_name, - cc->has_work = s390_cpu_has_work; + cc->has_work_with_iothread_lock = s390_cpu_has_work;#ifdef CONFIG_TCG cc->do_interrupt = s390_cpu_do_interrupt;#endif
Signature · 1 line
2.17.1
PATCH v7 66/73 riscv: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/riscv/cpu.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
target/riscv/cpu.c +4 -1
@@ -257,6 +257,9 @@ static bool riscv_cpu_has_work(CPUState *cs)#ifndef CONFIG_USER_ONLY RISCVCPU *cpu =RISCV_CPU (cs);CPURISCVState *env = &cpu->env; + +g_assert (qemu_mutex_iothread_locked ()); +/* * Definition of the WFI instruction requires it to ignore the privilege * mode and delegation registers, but respect individual enables
@@ -343,7 +346,7 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data) cc->reset = riscv_cpu_reset; cc->class_by_name = riscv_cpu_class_by_name; - cc->has_work = riscv_cpu_has_work; + cc->has_work_with_iothread_lock = riscv_cpu_has_work; cc->do_interrupt = riscv_cpu_do_interrupt; cc->cpu_exec_interrupt = riscv_cpu_exec_interrupt; cc->dump_state = riscv_cpu_dump_state;
Signature · 1 line
2.17.1
PATCH v7 67/73 sparc: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/sparc/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/sparc/cpu.c +3 -1
@@ -708,6 +708,8 @@ static bool sparc_cpu_has_work(CPUState *cs)SPARCCPU *cpu =SPARC_CPU (cs);CPUSPARCState *env = &cpu->env; +g_assert (qemu_mutex_iothread_locked ()); +return (cpu_interrupt_request (cs) &CPU_INTERRUPT_HARD ) &&cpu_interrupts_enabled (env); }
@@ -869,7 +871,7 @@ static void sparc_cpu_class_init(ObjectClass *oc, void *data) cc->class_by_name = sparc_cpu_class_by_name; cc->parse_features = sparc_cpu_parse_features; - cc->has_work = sparc_cpu_has_work; + cc->has_work_with_iothread_lock = sparc_cpu_has_work; cc->do_interrupt = sparc_cpu_do_interrupt; cc->cpu_exec_interrupt = sparc_cpu_exec_interrupt; cc->dump_state = sparc_cpu_dump_state;
Signature · 1 line
2.17.1
PATCH v7 68/73 xtensa: convert to cpu_has_work_with_iothread_lock
In reply to Emilio G. CotaSoon we will call cpu_has_work without the BQL.
--- target/xtensa/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/xtensa/cpu.c +3 -1
@@ -47,6 +47,8 @@ static bool xtensa_cpu_has_work(CPUState *cs)#ifndef CONFIG_USER_ONLY XtensaCPU *cpu =XTENSA_CPU (cs); +g_assert (qemu_mutex_iothread_locked ()); +return !cpu->env.runstall && cpu->env.pending_irq_level;#else return true;
@@ -173,7 +175,7 @@ static void xtensa_cpu_class_init(ObjectClass *oc, void *data) cc->reset = xtensa_cpu_reset; cc->class_by_name = xtensa_cpu_class_by_name; - cc->has_work = xtensa_cpu_has_work; + cc->has_work_with_iothread_lock = xtensa_cpu_has_work; cc->do_interrupt = xtensa_cpu_do_interrupt; cc->cpu_exec_interrupt = xtensa_cpu_exec_interrupt; cc->dump_state = xtensa_cpu_dump_state;
Signature · 1 line
2.17.1
PATCH v7 69/73 cpu: rename all_cpu_threads_idle to qemu_tcg_rr_all_cpu_threads_idle
In reply to Emilio G. CotaThis function is only called from TCG rr mode, so add a prefix to mark this as well as an assertion.
--- cpus.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
cpus.c +6 -4
@@ -211,10 +211,12 @@ static bool cpu_thread_is_idle(CPUState *cpu)return true; } -static bool all_cpu_threads_idle (void ) +static bool qemu_tcg_rr_all_cpu_threads_idle (void ) {CPUState *cpu; +g_assert (qemu_is_tcg_rr ()); +CPU_FOREACH (cpu) {if (!cpu_thread_is_idle (cpu)) {return false;
@@ -692,7 +694,7 @@ void qemu_start_warp_timer(void) }if (replay_mode !=REPLAY_MODE_PLAY ) { -if (!all_cpu_threads_idle ()) { +if (!qemu_tcg_rr_all_cpu_threads_idle ()) {return ; }
@@ -1325,7 +1327,7 @@ static void qemu_tcg_rr_wait_io_event(void) {CPUState *cpu; -while (all_cpu_threads_idle ()) { +while (qemu_tcg_rr_all_cpu_threads_idle ()) {stop_tcg_kick_timer ();qemu_cond_wait (first_cpu->halt_cond, &qemu_global_mutex); }
@@ -1660,7 +1662,7 @@ static void *qemu_tcg_rr_cpu_thread_fn(void *arg)atomic_mb_set (&cpu->exit_request,0 ); } -if (use_icount &&all_cpu_threads_idle ()) { +if (use_icount &&qemu_tcg_rr_all_cpu_threads_idle ()) {/* * When all cpus are sleeping (e.g in WFI), to avoid a deadlock * in the main_loop, wake it up in order to start the warp timer.
Signature · 1 line
2.17.1
PATCH v7 70/73 cpu: protect CPU state with cpu->lock instead of the BQL
In reply to Emilio G. CotaUse the per-CPU locks to protect the CPUs' state, instead of using the BQL. These locks are uncontended (they are mostly acquired by the corresponding vCPU thread), so acquiring them is cheaper than acquiring the BQL, which particularly in MTTCG can be contended at high core counts.
In this conversion we drop qemu_cpu_cond and qemu_pause_cond, and use cpu->cond instead.
In qom/cpu.c we can finally remove the ugliness that results from having to hold both the BQL and the CPU lock; now we just have to grab the CPU lock.
--- include/qom/cpu.h | 20 ++-- cpus.c | 281 ++++++++++++++++++++++++++++++++++------------ qom/cpu.c | 29 +---- 3 files changed, 225 insertions(+), 105 deletions(-)
include/qom/cpu.h +10 -10
@@ -309,10 +309,6 @@ struct qemu_work_item;* valid under cpu_list_lock. * @created: Indicates whether the CPU thread has been successfully created. * @interrupt_request: Indicates a pending interrupt request. -* @halted: Nonzero if the CPU is in suspended state. -* @stop: Indicates a pending stop request. -* @stopped: Indicates the CPU has been artificially stopped. -* @unplug: Indicates a pending CPU unplug request. * @crash_occurred: Indicates the OS reported a crash (panic) for this CPU * @singlestep_enabled: Flags for single-stepping. * @icount_extra: Instructions until next timer event.
@@ -342,6 +338,10 @@ struct qemu_work_item;* after the BQL. * @cond: Condition variable for per-CPU events. * @work_list: List of pending asynchronous work. +* @halted: Nonzero if the CPU is in suspended state. +* @stop: Indicates a pending stop request. +* @stopped: Indicates the CPU has been artificially stopped. +* @unplug: Indicates a pending CPU unplug request. * @trace_dstate_delayed: Delayed changes to trace_dstate (includes all changes * to @trace_dstate). * @trace_dstate: Dynamic tracing state of events for this vCPU (bitmask).
@@ -365,12 +365,7 @@ struct CPUState {#endif int thread_id;bool running, has_waiter; -struct QemuCond *halt_cond;bool thread_kicked; -bool created; -bool stop; -bool stopped; -bool unplug;bool crash_occurred;bool exit_request;uint32_t cflags_next_tb;
@@ -384,7 +379,13 @@ struct CPUState {QemuMutex *lock;/* fields below protected by @lock */ QemuCond cond; +QemuCond *halt_cond; QSIMPLEQ_HEAD(, qemu_work_item) work_list; +uint32_t halted; +bool created; +bool stop; +bool stopped; +bool unplug;CPUAddressSpace *cpu_ases;int num_ases;
@@ -432,7 +433,6 @@ struct CPUState {/* TODO Move common fields from CPUArchState here. */ int cpu_index;int cluster_index; -uint32_t halted;uint32_t can_do_io;int32_t exception_index;
cpus.c +210 -71
662 lines not on this page · raw message
qom/cpu.c +5 -24
@@ -94,32 +94,13 @@ static void cpu_common_get_memory_mapping(CPUState *cpu,error_setg (errp,"Obtaining memory mappings is unsupported on this CPU." ); } -/* Resetting the IRQ comes from across the code base so we take the -* BQL here if we need to. cpu_interrupt assumes it is held.*/ void cpu_reset_interrupt (CPUState *cpu,int mask) { -bool has_bql =qemu_mutex_iothread_locked (); -bool has_cpu_lock =cpu_mutex_locked (cpu); - -if (has_bql) { -if (has_cpu_lock) { -atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); - }else { -cpu_mutex_lock (cpu); -atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); -cpu_mutex_unlock (cpu); - } -return ; - } - -if (has_cpu_lock) { -cpu_mutex_unlock (cpu); - } -qemu_mutex_lock_iothread (); -cpu_mutex_lock (cpu); -atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); -qemu_mutex_unlock_iothread (); -if (!has_cpu_lock) { +if (cpu_mutex_locked (cpu)) { +atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask); + }else { +cpu_mutex_lock (cpu); +atomic_set (&cpu->interrupt_request, cpu->interrupt_request & ~mask);cpu_mutex_unlock (cpu); } }
Signature · 1 line
2.17.1
PATCH v7 71/73 cpus-common: release BQL earlier in run_on_cpu
In reply to Emilio G. CotaAfter completing the conversion to per-CPU locks, there is no need to release the BQL after having called cpu_kick.
--- cpus-common.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-)
cpus-common.c +5 -15
@@ -145,6 +145,11 @@ void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)return ; } +/* We are going to sleep on the CPU lock, so release the BQL */ +if (has_bql) { +qemu_mutex_unlock_iothread (); + } + wi.func = func; wi.data = data; wi.done = false;
@@ -153,21 +158,6 @@ void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)cpu_mutex_lock (cpu);queue_work_on_cpu_locked (cpu, &wi); - -/* -* We are going to sleep on the CPU lock, so release the BQL. -* -* During the transition to per-CPU locks, we release the BQL _after_ -* having kicked the destination CPU (from queue_work_on_cpu_locked above). -* This makes sure that the enqueued work will be seen by the CPU -* after being woken up from the kick, since the CPU sleeps on the BQL. -* Once we complete the transition to per-CPU locks, we will release -* the BQL earlier in this function. -*/ -if (has_bql) { -qemu_mutex_unlock_iothread (); - } -while (!atomic_mb_read (&wi.done)) {CPUState *self_cpu = current_cpu;
Signature · 1 line
2.17.1
PATCH v7 72/73 cpu: add async_run_on_cpu_no_bql
In reply to Emilio G. CotaSome async jobs do not need the BQL.
--- include/qom/cpu.h | 14 ++++++++++++++ cpus-common.c | 39 ++++++++++++++++++++++++++++++++++----- 2 files changed, 48 insertions(+), 5 deletions(-)
include/qom/cpu.h +14 -0
@@ -898,9 +898,23 @@ void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data);* @data: Data to pass to the function. * * Schedules the function @func for execution on the vCPU @cpu asynchronously. +* See also: async_run_on_cpu_no_bql() */ void async_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data); +/** +* async_run_on_cpu_no_bql: +* @cpu: The vCPU to run on. +* @func: The function to be executed. +* @data: Data to pass to the function. +* +* Schedules the function @func for execution on the vCPU @cpu asynchronously. +* This function is run outside the BQL. +* See also: async_run_on_cpu() +*/ +void async_run_on_cpu_no_bql (CPUState *cpu,run_on_cpu_func func, +run_on_cpu_data data); +/** * async_safe_run_on_cpu: * @cpu: The vCPU to run on.
cpus-common.c +34 -5
@@ -109,6 +109,7 @@ struct qemu_work_item {run_on_cpu_func func;run_on_cpu_data data;bool free, exclusive, done; +bool bql; };/* Called with the CPU's lock held */
@@ -155,6 +156,7 @@ void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data) wi.done = false; wi.free = false; wi.exclusive = false; + wi.bql = true;cpu_mutex_lock (cpu);queue_work_on_cpu_locked (cpu, &wi);
@@ -179,6 +181,21 @@ void async_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data) wi->func = func; wi->data = data; wi->free = true; + wi->bql = true; + +queue_work_on_cpu (cpu, wi); +} + +void async_run_on_cpu_no_bql (CPUState *cpu,run_on_cpu_func func, +run_on_cpu_data data) +{ +struct qemu_work_item *wi; + + wi =g_malloc0 (sizeof (struct qemu_work_item )); + wi->func = func; + wi->data = data; + wi->free = true; +/* wi->bql initialized to false */ queue_work_on_cpu (cpu, wi); }
@@ -323,6 +340,7 @@ void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func, wi->data = data; wi->free = true; wi->exclusive = true; +/* wi->bql initialized to false */ queue_work_on_cpu (cpu, wi); }
@@ -347,6 +365,7 @@ static void process_queued_cpu_work_locked(CPUState *cpu)* BQL, so it goes to sleep; start_exclusive() is sleeping too, so * neither CPU can proceed. */ +g_assert (!wi->bql);if (has_bql) {qemu_mutex_unlock_iothread (); }
@@ -357,12 +376,22 @@ static void process_queued_cpu_work_locked(CPUState *cpu)qemu_mutex_lock_iothread (); } }else { -if (has_bql) { - wi->func (cpu, wi->data); +if (wi->bql) { +if (has_bql) { + wi->func (cpu, wi->data); + }else { +qemu_mutex_lock_iothread (); + wi->func (cpu, wi->data); +qemu_mutex_unlock_iothread (); + } }else { -qemu_mutex_lock_iothread (); - wi->func (cpu, wi->data); -qemu_mutex_unlock_iothread (); +if (has_bql) { +qemu_mutex_unlock_iothread (); + wi->func (cpu, wi->data); +qemu_mutex_lock_iothread (); + }else { + wi->func (cpu, wi->data); + } } }cpu_mutex_lock (cpu);
Signature · 1 line
2.17.1
PATCH v7 73/73 cputlb: queue async flush jobs without the BQL
In reply to Emilio G. CotaThis yields sizable scalability improvements, as the below results show.
Host: Two Intel E5-2683 v3 14-core CPUs at 2.00 GHz (Haswell)
Workload: Ubuntu 18.04 ppc64 compiling the linux kernel with "make -j N", where N is the number of cores in the guest.
Speedup vs a single thread (higher is better):
14 +---------------------------------------------------------------+
| + + + + + + $$$$$$ + |
| $$$$$ |
| $$$$$$ |
12 |-+ $A$$ +-|
| $$ |
| $$$ |
10 |-+ $$ ##D#####################D +-|
| $$$ #####**B**************** |
| $$####***** ***** |
| A$#***** B |
8 |-+ $$B** +-|
| $$** |
| $** |
6 |-+ $$* +-|
| A** |
| $B |
| $ |
4 |-+ $* +-|
| $ |
| $ |
2 |-+ $ +-|
| $ +cputlb-no-bql $$A$$ |
| A +per-cpu-lock ##D## |
| + + + + + + baseline **B** |
0 +---------------------------------------------------------------+
1 4 8 12 16 20 24 28
Guest vCPUs
png: https://imgur.com/zZRvS7q
Some notes:
- baseline corresponds to the commit before this series
- per-cpu-lock is the commit that converts the CPU loop to per-cpu locks.
- cputlb-no-bql is this commit.
- I'm using taskset to assign cores to threads, favouring locality whenever possible but not using SMT. When N=1, I'm using a single host core, which leads to superlinear speedups (since with more cores the I/O thread can execute while vCPU threads sleep). In the future I might use N+1 host cores for N guest cores to avoid this, or perhaps pin guest threads to cores one-by-one.
Single-threaded performance is affected very lightly. Results below for debian aarch64 bootup+test for the entire series on an Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz host:
- Before:
Performance counter stats for 'taskset -c 0 ../img/aarch64/die.sh' (10 runs):
7269.033478 task-clock (msec) # 0.998 CPUs utilized ( +- 0.06% )
30,659,870,302 cycles # 4.218 GHz ( +- 0.06% )
54,790,540,051 instructions # 1.79 insns per cycle ( +- 0.05% )
9,796,441,380 branches # 1347.695 M/sec ( +- 0.05% )
165,132,201 branch-misses # 1.69% of all branches ( +- 0.12% )7.287011656 seconds time elapsed ( +- 0.10% )
- After:
7375.924053 task-clock (msec) # 0.998 CPUs utilized ( +- 0.13% )
31,107,548,846 cycles # 4.217 GHz ( +- 0.12% )
55,355,668,947 instructions # 1.78 insns per cycle ( +- 0.05% )
9,929,917,664 branches # 1346.261 M/sec ( +- 0.04% )
166,547,442 branch-misses # 1.68% of all branches ( +- 0.09% )7.389068145 seconds time elapsed ( +- 0.13% )
That is, a 1.37% slowdown.
--- accel/tcg/cputlb.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
accel/tcg/cputlb.c +5 -5
@@ -260,7 +260,7 @@ static void flush_all_helper(CPUState *src, run_on_cpu_func fn,CPU_FOREACH (cpu) {if (cpu != src) { -async_run_on_cpu (cpu, fn, d); +async_run_on_cpu_no_bql (cpu, fn, d); } } }
@@ -336,8 +336,8 @@ void tlb_flush_by_mmuidx(CPUState *cpu, uint16_t idxmap)tlb_debug ("mmu_idx: 0x%" PRIx16"\n" , idxmap);if (cpu->created && !qemu_cpu_is_self (cpu)) { -async_run_on_cpu (cpu, tlb_flush_by_mmuidx_async_work, -RUN_ON_CPU_HOST_INT (idxmap)); +async_run_on_cpu_no_bql (cpu, tlb_flush_by_mmuidx_async_work, +RUN_ON_CPU_HOST_INT (idxmap)); }else {tlb_flush_by_mmuidx_async_work (cpu,RUN_ON_CPU_HOST_INT (idxmap)); }
@@ -481,8 +481,8 @@ void tlb_flush_page_by_mmuidx(CPUState *cpu, target_ulong addr, uint16_t idxmap) addr_and_mmu_idx |= idxmap;if (!qemu_cpu_is_self (cpu)) { -async_run_on_cpu (cpu, tlb_flush_page_by_mmuidx_async_work, -RUN_ON_CPU_TARGET_PTR (addr_and_mmu_idx)); +async_run_on_cpu_no_bql (cpu, tlb_flush_page_by_mmuidx_async_work, +RUN_ON_CPU_TARGET_PTR (addr_and_mmu_idx)); }else {tlb_flush_page_by_mmuidx_async_work ( cpu,RUN_ON_CPU_TARGET_PTR (addr_and_mmu_idx));
Signature · 1 line
2.17.1
Quoted 9 lines · Emilio G. Cota
v6: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg07650.html
All patches in the series have reviews now. Thanks everyone!
I've tested all patches with `make check-qtest -j' for all targets. The series is checkpatch-clean (just some warnings about
__COVERITY__).You can fetch the series from:
https://github.com/cota/qemu/tree/cpu-lock-v7
Just to say I've applied and tested the whole series and I'm still seeing the improvements so I think it's ready to be picked up:
Quoted 76 lines
---
v6->v7:- Rebase on master
- Add acpu_halted_setcall to arm code that wasn't there in v6- Add R-b's and Ack's.
- Add comment to patch 3's log to explain why the bitmap is added there, even though it only gains a user at the end of the series.
- Fix "prevent deadlock" comments before assertions; use "enforce locking order" instead, which is more accurate.
- Add a few more comments, as suggested by Alex.
v6->v7diff (before rebase) below.Thanks,
Emilio
---accel/tcg/cpu-exec.c +1
-1@@ -435,7 +435,7 @@ static inline bool cpu_handle_halt_locked(CPUState *cpu) && replay_interrupt()) {X86CPU *x86_cpu =X86_CPU (cpu); -/* prevent deadlock; cpu_mutex must be acquired _after_ the BQL */ +/* locking order: cpu_mutex must be acquired _after_ the BQL */ cpu_mutex_unlock (cpu);qemu_mutex_lock_iothread ();cpu_mutex_lock (cpu);cpus.c +1
-1@@ -2062,7 +2062,7 @@ void qemu_mutex_lock_iothread_impl(const char *file, int line) {QemuMutexLockFunc bql_lock =atomic_read (&qemu_bql_mutex_lock_func); -/* prevent deadlock with CPU mutex */ +/* enforce locking order */ g_assert (no_cpu_mutex_locked ());g_assert (!qemu_mutex_iothread_locked ());include/qom/cpu.h +3
-1@@ -322,7 +322,8 @@ struct qemu_work_item;* @mem_io_pc: Host Program Counter at which the memory was accessed. * @mem_io_vaddr: Target virtual address at which the memory was accessed. * @kvm_fd: vCPU file descriptor for KVM. -* @lock: Lock to prevent multiple access to per-CPU fields. +* @lock: Lock to prevent multiple access to per-CPU fields. Must be acquired +* after the BQL. * @cond: Condition variable for per-CPU events. * @work_list: List of pending asynchronous work. * @halted: Nonzero if the CPU is in suspended state. @@ -804,6 +805,7 @@ static inline bool cpu_has_work(CPUState *cpu)bool (*func)(CPUState *cpu);bool ret; +/* some targets require us to hold the BQL when checking for work */ if (cc->has_work_with_iothread_lock) {if (qemu_mutex_iothread_locked ()) { func = cc->has_work_with_iothread_lock;target/i386/kvm.c +0
-0
target/i386/kvm.c void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) · line 3225
Quoted 10 lines
target/i386/kvm.c +4
-0@@ -3216,6 +3216,10 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)qemu_mutex_lock_iothread (); } +/* +* We might have cleared some bits in cpu->interrupt_request since reading +* it; read it again. +*/ interrupt_request =cpu_interrupt_request (cpu);/* Force the VCPU out of its inner loop to process any INIT requests
--
Alex Bennée
Quoted 9 lines · Emilio G. Cota
v6: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg07650.html
All patches in the series have reviews now. Thanks everyone!
I've tested all patches with `make check-qtest -j' for all targets. The series is checkpatch-clean (just some warnings about
__COVERITY__).You can fetch the series from:
https://github.com/cota/qemu/tree/cpu-lock-v7
Having fixed the OSX build errors, Peter reported to me a hang on the x86_64 bios-tables-test with an arm32 host. I have been able to replicate this.
(gdb) info thr
Id Target Id Frame
1 Thread 0xb35a72e0 (LWP 10966) "qemu-system-x86" 0xb606d138 in
pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0
2 Thread 0xb35a3d30 (LWP 10967) "qemu-system-x86" 0xb5fe70fc in syscall ()
from /usr/lib/libc.so.6
3 Thread 0xa07fed30 (LWP 10968) "qemu-system-x86" 0xb5fe0688 in poll ()
from /usr/lib/libc.so.6
* 4 Thread 0x9fdfed30 (LWP 10969) "qemu-system-x86" 0xb606d138 in
pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0
(gdb) thr 1
[Switching to thread 1 (Thread 0xb35a72e0 (LWP 10966))]
#0 0xb606d138 in pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0 (gdb) where
#0 0xb606d138 in pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0 #1 0x009a66a4 in qemu_cond_wait_impl (cond=cond@entry=0x16727b0,
mutex=0xcad4c8 <qemu_global_mutex>,
file=file@entry=0xa057f0 "/home/rth/qemu/qemu/cpus-common.c",
line=line@entry=166) at /home/rth/qemu/qemu/util/qemu-thread-posix.c:161
#2 0x00692378 in run_on_cpu (cpu=cpu@entry=0x16725a8, func=<optimized out>,
data=...) at /home/rth/qemu/qemu/cpus-common.c:166
#3 0x00604c18 in vapic_enable_tpr_reporting (enable=<optimized out>)
at /home/rth/qemu/qemu/hw/i386/kvmvapic.c:507
#4 0x00710160 in qdev_reset_one (dev=<optimized out>, opaque=<optimized out>)
at /home/rth/qemu/qemu/hw/core/qdev.c:250(gdb) thr 4
[Switching to thread 4 (Thread 0x9fdfed30 (LWP 10969))]
#0 0xb606d138 in pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0 (gdb) where
#0 0xb606d138 in pthread_cond_wait@@GLIBC_2.4 () from /usr/lib/libpthread.so.0 #1 0x009a66a4 in qemu_cond_wait_impl (cond=0x1692ed8,
mutex=0xcad4c8 <qemu_global_mutex>,
file=file@entry=0x9d0108 "/home/rth/qemu/qemu/cpus.c",
line=line@entry=1647) at /home/rth/qemu/qemu/util/qemu-thread-posix.c:161
#2 0x00553070 in qemu_tcg_rr_cpu_thread_fn (arg=<optimized out>)
at /home/rth/qemu/qemu/cpus.c:1647
#3 0x009a5f20 in qemu_thread_start (args=<optimized out>)
at /home/rth/qemu/qemu/util/qemu-thread-posix.c:502I had hoped that I would have been able to reproduce this on another host by forcing rr mode. But so far no luck.
Thoughts?
r~
Quoted 2 lines · Richard Henderson
I had hoped that I would have been able to reproduce this on another host by forcing rr mode. But so far no luck.
Have you tried rr's "chaos mode" switch?
thanks
-- PMM
Quoted 2 lines · Richard Henderson
Peter reported to me a hang on the
x86_64
bios-tables-test with an arm32 host. I have been able to replicate this.
(snip)
I reproduced this on a power7 machine (gcc110). However, after a few git checkout->build cycles I was not able to reproduce this again (!?).
I currently have very little time to spend on this. Given how close we are to the soft freeze, I suggest we defer the merge of this series to post-v4.0.
Thanks,
Emilio