accel: Move has_work() from SysemuCPUOps to AccelOpsClass
v5 cover accel: Move has_work() from SysemuCPUOps to AccelOpsClass
Missing review:
- 0001-target-arm-Implement-arm_v7m_cpu_has_work.patch
- 0005-sysemu-Introduce-AccelOpsClass-has_work.patch
- 0008-accel-tcg-Implement-AccelOpsClass-has_work-as-stub.patch
- 0010-target-arm-Restrict-has_work-handler-to-sysemu-and-T.patch
- 0012-target-cris-Restrict-has_work-handler-to-sysemu.patch
Hi,
CPU has_work() is a per-accelerator handler. This series
- explicit the KVM / WHPX implementations
- moves TCG implementations in AccelOpsClass
- explicit missing implementations (returning 'false').
Since v4:
- Implement arm_v7m_cpu_has_work() (new patch)
- Assert has_work() handlers are set, don't use default value
- Fix ARM v7M and cris CPUs
- Reset R-b tags on modified patches
Since v3:
- Remove pointless CONFIG_TCG uses (rth)
- Rework PPC patches, still using indirection
Since v2:
- Full rewrite, no more RFC.
$ git backport-diff v3..v4 [----] : patches are identical [####] : number of functional differences between upstream/downstream patch [down] : patch is downstream-only The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively
001/31:[down] 'target/arm: Implement arm_v7m_cpu_has_work()'
002/31:[----] [--] 'accel/tcg: Restrict cpu_handle_halt() to sysemu' 003/31:[----] [--] 'hw/core: Restrict cpu_has_work() to sysemu' 004/31:[----] [--] 'hw/core: Un-inline cpu_has_work()'
005/31:[0006] [FC] 'sysemu: Introduce AccelOpsClass::has_work()' 006/31:[----] [--] 'accel/kvm: Implement AccelOpsClass::has_work()' 007/31:[----] [--] 'accel/whpx: Implement AccelOpsClass::has_work()' 008/31:[0004] [FC] 'accel/tcg: Implement AccelOpsClass::has_work() as stub' 009/31:[----] [--] 'target/alpha: Restrict has_work() handler to sysemu' 010/31:[0002] [FC] 'target/arm: Restrict has_work() handler to sysemu and TCG' 011/31:[----] [--] 'target/avr: Restrict has_work() handler to sysemu' 012/31:[0001] [FC] 'target/cris: Restrict has_work() handler to sysemu' 013/31:[----] [--] 'target/hexagon: Remove unused has_work() handler' 014/31:[----] [--] 'target/hppa: Restrict has_work() handler to sysemu' 015/31:[----] [--] 'target/i386: Restrict has_work() handler to sysemu and TCG' 016/31:[----] [--] 'target/m68k: Restrict has_work() handler to sysemu' 017/31:[----] [--] 'target/microblaze: Restrict has_work() handler to sysemu' 018/31:[----] [--] 'target/mips: Restrict has_work() handler to sysemu and TCG' 019/31:[----] [--] 'target/nios2: Restrict has_work() handler to sysemu' 020/31:[----] [--] 'target/openrisc: Restrict has_work() handler to sysemu' 021/31:[----] [--] 'target/ppc: Introduce PowerPCCPUClass::has_work()' 022/31:[----] [--] 'target/ppc: Restrict has_work() handlers to sysemu and TCG' 023/31:[----] [--] 'target/riscv: Restrict has_work() handler to sysemu and TCG' 024/31:[----] [--] 'target/rx: Restrict has_work() handler to sysemu' 025/31:[----] [--] 'target/s390x: Restrict has_work() handler to sysemu and TCG' 026/31:[----] [--] 'target/sh4: Restrict has_work() handler to sysemu' 027/31:[----] [--] 'target/sparc: Remove pointless use of CONFIG_TCG definition' 028/31:[----] [--] 'target/sparc: Restrict has_work() handler to sysemu' 029/31:[----] [--] 'target/tricore: Restrict has_work() handler to sysemu' 030/31:[----] [--] 'target/xtensa: Restrict has_work() handler to sysemu' 031/31:[0006] [FC] 'accel: Add missing AccelOpsClass::has_work() and drop SysemuCPUOps one'
Philippe Mathieu-Daudé (31):
target/arm: Implement arm_v7m_cpu_has_work()
accel/tcg: Restrict cpu_handle_halt() to sysemu
hw/core: Restrict cpu_has_work() to sysemu
hw/core: Un-inline cpu_has_work()
sysemu: Introduce AccelOpsClass::has_work()
accel/kvm: Implement AccelOpsClass::has_work()
accel/whpx: Implement AccelOpsClass::has_work()
accel/tcg: Implement AccelOpsClass::has_work() as stub target/alpha: Restrict has_work() handler to sysemu target/arm: Restrict has_work() handler to sysemu and TCG target/avr: Restrict has_work() handler to sysemu target/cris: Restrict has_work() handler to sysemu target/hexagon: Remove unused has_work() handler target/hppa: Restrict has_work() handler to sysemu target/i386: Restrict has_work() handler to sysemu and TCG target/m68k: Restrict has_work() handler to sysemu target/microblaze: Restrict has_work() handler to sysemu target/mips: Restrict has_work() handler to sysemu and TCG target/nios2: Restrict has_work() handler to sysemu target/openrisc: Restrict has_work() handler to sysemu target/ppc: Introduce PowerPCCPUClass::has_work() target/ppc: Restrict has_work() handlers to sysemu and TCG target/riscv: Restrict has_work() handler to sysemu and TCG target/rx: Restrict has_work() handler to sysemu target/s390x: Restrict has_work() handler to sysemu and TCG target/sh4: Restrict has_work() handler to sysemu target/sparc: Remove pointless use of CONFIG_TCG definition target/sparc: Restrict has_work() handler to sysemu target/tricore: Restrict has_work() handler to sysemu target/xtensa: Restrict has_work() handler to sysemu
accel: Add missing AccelOpsClass::has_work() and drop SysemuCPUOps one
include/hw/core/cpu.h | 28 +++++++++-------------- include/hw/core/tcg-cpu-ops.h | 4 ++++ include/sysemu/accel-ops.h | 5 +++++ target/ppc/cpu-qom.h | 3 +++ accel/hvf/hvf-accel-ops.c | 6 +++++ accel/kvm/kvm-accel-ops.c | 6 +++++ accel/qtest/qtest.c | 6 +++++ accel/tcg/cpu-exec.c | 6 +++-- accel/tcg/tcg-accel-ops.c | 10 +++++++++ accel/xen/xen-all.c | 6 +++++ hw/core/cpu-common.c | 6 ----- softmmu/cpus.c | 10 ++++++--- target/alpha/cpu.c | 4 +++- target/arm/cpu.c | 7 ++++-- target/arm/cpu_tcg.c | 6 +++++ target/avr/cpu.c | 2 +- target/cris/cpu.c | 5 ++++- target/hexagon/cpu.c | 6 ----- target/hppa/cpu.c | 4 +++- target/i386/cpu.c | 6 ----- target/i386/hax/hax-accel-ops.c | 6 +++++ target/i386/nvmm/nvmm-accel-ops.c | 6 +++++ target/i386/tcg/tcg-cpu.c | 8 ++++++- target/i386/whpx/whpx-accel-ops.c | 6 +++++ target/m68k/cpu.c | 4 +++- target/microblaze/cpu.c | 8 +++---- target/mips/cpu.c | 4 +++- target/nios2/cpu.c | 4 +++- target/openrisc/cpu.c | 4 +++- target/ppc/cpu_init.c | 37 ++++++++++++++++++++++--------- target/riscv/cpu.c | 8 +++---- target/rx/cpu.c | 4 +++- target/s390x/cpu.c | 4 +++- target/sh4/cpu.c | 5 +++-- target/sparc/cpu.c | 6 ++--- target/tricore/cpu.c | 6 ++++- target/xtensa/cpu.c | 14 ++++++------ 37 files changed, 184 insertions(+), 86 deletions(-)
Signature · 1 line
2.31.1
PATCH v5 1/31 target/arm: Implement arm_v7m_cpu_has_work()
Implement SysemuCPUOps::has_work() handler for the ARM v7M CPU.
See the comments added in commit 7ecdaa4a963 ("armv7m: Fix condition check for taking exceptions") which eventually forgot to implement this has_work() handler:
* ARMv7-M interrupt masking works differently than -A or -R.
* There is no FIQ/IRQ distinction.
The NVIC signal any pending interrupt by raising ARM_CPU_IRQ (see commit 56b7c66f498: "armv7m: QOMify the armv7m container") which ends setting the CPU_INTERRUPT_HARD bit in interrupt_request.
Thus arm_v7m_cpu_has_work() implementation is thus quite trivial, we simply need to check for this bit.
--- target/arm/cpu_tcg.c | 6 ++++++ 1 file changed, 6 insertions(+)
target/arm/cpu_tcg.c +6 -0
@@ -23,6 +23,11 @@ #if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64) #if !defined(CONFIG_USER_ONLY) && defined(CONFIG_TCG) +static bool arm_v7m_cpu_has_work(CPUState *cs) +{ + return cs->interrupt_request & CPU_INTERRUPT_HARD; +} + static bool arm_v7m_cpu_exec_interrupt(CPUState *cs, int interrupt_request) { CPUClass *cc = CPU_GET_CLASS(cs);
@@ -920,6 +925,7 @@ static void arm_v7m_class_init(ObjectClass *oc, void *data) acc->info = data;#ifdef CONFIG_TCG + cc->has_work = arm_v7m_cpu_has_work; cc->tcg_ops = &arm_v7m_tcg_ops;#endif /* CONFIG_TCG */
Signature · 1 line
2.31.1
Re: [PATCH v5 01/31] target/arm: Implement arm_v7m_cpu_has_work()
Quoted 6 lines · Philippe Mathieu-Daudé
Implement
SysemuCPUOps::has_work()handler for the ARM v7M CPU.See the comments added in commit
7ecdaa4a963("armv7m: Fix condition check for taking exceptions") which eventually forgot to implement thishas_work()handler:
Huh? M-profile and A-profile share the same arm_cpu_has_work() function. Some of the checks the code there does are perhaps unnecessary for M-profile, but they're harmless.
Quoted 22 lines
* ARMv7-M interrupt masking works differently than -A or -R.
* There is no FIQ/IRQ distinction.The NVIC signal any pending interrupt by raising
ARM_CPU_IRQ(see commit56b7c66f498: "armv7m: QOMify the armv7m container") which ends setting theCPU_INTERRUPT_HARDbit ininterrupt_request.Thus
arm_v7m_cpu_has_work()implementation is thus quite trivial, we simply need to check for this bit.Cc Peter Maydell <[email protected]>Cc Michael Davidsaver <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>--- target/arm/cpu_tcg.c | 6 ++++++ 1 file changed, 6 insertions(+)target/arm/cpu_tcg.c +0
-0
target/arm/cpu_tcg.c line 29
Quoted 7 lines
target/arm/cpu_tcg.c +4
-0@@ -23,6 +23,11 @@#if !defined(CONFIG_USER_ONLY ) || !defined(TARGET_AARCH64 )#if !defined(CONFIG_USER_ONLY ) && defined(CONFIG_TCG ) +static bool arm_v7m_cpu_has_work (CPUState *cs) +{ +return cs->interrupt_request &CPU_INTERRUPT_HARD ; +}
This seems to be missing at least the check on cpu->power_state and the CPU_INTERRUPT_EXITTB test.
Is there any reason why we shouldn't just continue to share the same function between A and M profile, and avoid the extra function and the ifdefs ?
-- PMM
Re: [PATCH v5 01/31] target/arm: Implement arm_v7m_cpu_has_work()
Quoted 45 lines · Peter Maydell
Quoted 6 lines · Philippe Mathieu-Daudé
Implement
SysemuCPUOps::has_work()handler for the ARM v7M CPU.See the comments added in commit
7ecdaa4a963("armv7m: Fix condition check for taking exceptions") which eventually forgot to implement thishas_work()handler:Huh? M-profile and A-profile share the same
arm_cpu_has_work()function. Some of the checks the code there does are perhaps unnecessary for M-profile, but they're harmless.Quoted 22 lines
* ARMv7-M interrupt masking works differently than -A or -R.
* There is no FIQ/IRQ distinction.The NVIC signal any pending interrupt by raising
ARM_CPU_IRQ(see commit56b7c66f498: "armv7m: QOMify the armv7m container") which ends setting theCPU_INTERRUPT_HARDbit ininterrupt_request.Thus
arm_v7m_cpu_has_work()implementation is thus quite trivial, we simply need to check for this bit.Cc Peter Maydell <[email protected]>Cc Michael Davidsaver <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>--- target/arm/cpu_tcg.c | 6 ++++++ 1 file changed, 6 insertions(+)target/arm/cpu_tcg.c +0
-0target/arm/cpu_tcg.c line 29
Quoted 7 lines
target/arm/cpu_tcg.c +4
-0@@ -23,6 +23,11 @@#if !defined(CONFIG_USER_ONLY ) || !defined(TARGET_AARCH64 )#if !defined(CONFIG_USER_ONLY ) && defined(CONFIG_TCG ) +static bool arm_v7m_cpu_has_work (CPUState *cs) +{ +return cs->interrupt_request &CPU_INTERRUPT_HARD ; +}This seems to be missing at least the check on
cpu->power_stateand theCPU_INTERRUPT_EXITTBtest.
Quoted 3 lines
Is there any reason why we shouldn't just continue to share the same function between A and M profile, and avoid the extra function and the ifdefs ?
The only reason I can think of is I should have been resting instead of posting this patch :/ I'll re-use arm_cpu_has_work() which is, as you said, harmless and safer.
Re: [PATCH v5 01/31] target/arm: Implement arm_v7m_cpu_has_work()
Hi Peter,
Quoted 5 lines · Philippe Mathieu-Daudé
Quoted 4 lines · Peter Maydell
Quoted 3 lines · Philippe Mathieu-Daudé
Implement
SysemuCPUOps::has_work()handler for the ARM v7M CPU.
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines
See the comments added in commit
7ecdaa4a963("armv7m: Fix condition check for taking exceptions") which eventually forgot to implement thishas_work()handler:Huh? M-profile and A-profile share the same
arm_cpu_has_work()function. Some of the checks the code there does are perhaps unnecessary for M-profile, but they're harmless.
A v7M core is registered as (example for Cortex-M0):
static const ARMCPUInfo arm_tcg_cpus[] = {
...
{ .name = "cortex-m0", .initfn = cortex_m0_initfn,
.class_init = arm_v7m_class_init },static void arm_tcg_cpu_register_types(void)
{
...
for (i = 0; i < ARRAY_SIZE(arm_tcg_cpus); ++i) {
arm_cpu_register(&arm_tcg_cpus[i]);void arm_cpu_register(const ARMCPUInfo *info)
{
TypeInfo type_info = {
.parent = TYPE_ARM_CPU,
.instance_size = sizeof(ARMCPU),
.instance_align = __alignof__(ARMCPU),
.instance_init = arm_cpu_instance_init,
.class_size = sizeof(ARMCPUClass),
.class_init = info->class_init ?: cpu_register_class_init,
.class_data = (void *)info,
};Since we provide info->class_init as arm_v7m_class_init(), only tcg_ops and gdb_core_xml_file from CPUClass are set:
static void arm_v7m_class_init(ObjectClass *oc, void *data)
{
ARMCPUClass *acc = ARM_CPU_CLASS(oc);
CPUClass *cc = CPU_CLASS(oc);
acc->info = data;
#ifdef CONFIG_TCG
cc->tcg_ops = &arm_v7m_tcg_ops;#endif /* CONFIG_TCG */
cc->gdb_core_xml_file = "arm-m-profile.xml"; }
Thus v7M cores end calling cpu_common_has_work() registered by cpu_class_init(), which is:
static bool cpu_common_has_work(CPUState *cs)
{
return false;
}What am I missing?
Quoted 42 lines
Quoted 34 lines
Quoted 23 lines
* ARMv7-M interrupt masking works differently than -A or -R.
* There is no FIQ/IRQ distinction.The NVIC signal any pending interrupt by raising
ARM_CPU_IRQ(see commit56b7c66f498: "armv7m: QOMify the armv7m container") which ends setting theCPU_INTERRUPT_HARDbit ininterrupt_request.Thus
arm_v7m_cpu_has_work()implementation is thus quite trivial, we simply need to check for this bit.Cc Peter Maydell <[email protected]>Cc Michael Davidsaver <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
target/arm/cpu_tcg.c| 6 ++++++1 file changed, 6 insertions(+)target/arm/cpu_tcg.c +0
-0target/arm/cpu_tcg.c line 29
Quoted 7 lines
target/arm/cpu_tcg.c +4
-0@@ -23,6 +23,11 @@ #if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64) #if !defined(CONFIG_USER_ONLY) && defined(CONFIG_TCG) +static bool arm_v7m_cpu_has_work (CPUState *cs) +{ + return cs->interrupt_request & CPU_INTERRUPT_HARD; +}This seems to be missing at least the check on
cpu->power_stateand theCPU_INTERRUPT_EXITTBtest.Quoted 3 lines
Is there any reason why we shouldn't just continue to share the same function between A and M profile, and avoid the extra function and the ifdefs ?
The only reason I can think of is I should have been resting instead of posting this patch :/ I'll re-use
arm_cpu_has_work()which is, as you said, harmless and safer.
Re: [PATCH v5 01/31] target/arm: Implement arm_v7m_cpu_has_work()
Quoted 11 lines · Philippe Mathieu-Daudé
Since we provide
info->class_initasarm_v7m_class_init(), onlytcg_opsandgdb_core_xml_filefrom CPUClass are set:static void
arm_v7m_class_init(ObjectClass *oc, void *data){ ARMCPUClass *acc = ARM_CPU_CLASS(oc); CPUClass *cc = CPU_CLASS(oc); acc->info = data; #ifdef CONFIG_TCG cc->tcg_ops = &arm_v7m_tcg_ops;
Quoted 4 lines
#endif /*
CONFIG_TCG*/cc->gdb_core_xml_file = "arm-m-profile.xml"; }
This class's parent type is TYPE_ARM_CPU; so TYPE_ARM_CPU's class_init runs first and sets up most of the class fields. This function only needs to set the ones which must be different on a M-profile core.
-- PMM
Re: [PATCH v5 01/31] target/arm: Implement arm_v7m_cpu_has_work()
Quoted 14 lines · Peter Maydell
Quoted 13 lines · Philippe Mathieu-Daudé
Since we provide
info->class_initasarm_v7m_class_init(), onlytcg_opsandgdb_core_xml_filefrom CPUClass are set:static void
arm_v7m_class_init(ObjectClass *oc, void *data){ ARMCPUClass *acc = ARM_CPU_CLASS(oc); CPUClass *cc = CPU_CLASS(oc); acc->info = data; #ifdef CONFIG_TCG cc->tcg_ops = &arm_v7m_tcg_ops;#endif /*
CONFIG_TCG*/
Quoted 6 lines
Quoted 2 lines
cc->gdb_core_xml_file = "arm-m-profile.xml"; }This class's parent type is
TYPE_ARM_CPU; so TYPE_ARM_CPU'sclass_initruns first and sets up most of the class fields. This function only needs to set the ones which must be different on a M-profile core.
Of course... Thanks!
PATCH v5 2/31 accel/tcg: Restrict cpu_handle_halt() to sysemu
In reply to Philippe Mathieu-DaudéCommit 372579427a5 ("tcg: enable thread-per-vCPU") added the following comment describing EXCP_HALTED in qemu_tcg_cpu_thread_fn():
case EXCP_HALTED:
/* during start-up the vCPU is reset and the thread is
* kicked several times. If we don't ensure we go back
* to sleep in the halted state we won't cleanly
* start-up when the vCPU is enabled.
*
* cpu->halted should ensure we sleep in wait_io_event
*/
g_assert(cpu->halted);
break;qemu_wait_io_event() is sysemu-specific, so we can restrict the cpu_handle_halt() call in cpu_exec() to system emulation.
--- accel/tcg/cpu-exec.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
accel/tcg/cpu-exec.c +4 -2
@@ -588,8 +588,9 @@ static inline void tb_add_jump(TranslationBlock *tb, int n, static inline bool cpu_handle_halt(CPUState *cpu) { +#ifndef CONFIG_USER_ONLY if (cpu->halted) { -#if defined(TARGET_I386 ) && !defined(CONFIG_USER_ONLY ) +#if defined(TARGET_I386) if (cpu->interrupt_request & CPU_INTERRUPT_POLL) { X86CPU *x86_cpu = X86_CPU(cpu); qemu_mutex_lock_iothread();
@@ -597,13 +598,14 @@ static inline bool cpu_handle_halt(CPUState *cpu)cpu_reset_interrupt (cpu,CPU_INTERRUPT_POLL );qemu_mutex_unlock_iothread (); } -#endif +#endif /* TARGET_I386 */ if (!cpu_has_work (cpu)) {return true; } cpu->halted =0 ; } +#endif /* !CONFIG_USER_ONLY */ return false; }
Signature · 1 line
2.31.1
PATCH v5 3/31 hw/core: Restrict cpu_has_work() to sysemu
In reply to Philippe Mathieu-Daudécpu_has_work() is only called from system emulation code.
--- include/hw/core/cpu.h | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)
include/hw/core/cpu.h +16 -16
@@ -538,6 +538,22 @@ enum CPUDumpFlags {void cpu_dump_state (CPUState *cpu,FILE *f,int flags);#ifndef CONFIG_USER_ONLY +/** +* cpu_has_work: +* @cpu: The vCPU to check. +* +* Checks whether the CPU has work to do. +* +* Returns: %true if the CPU has work, %false otherwise. +*/ +static inline bool cpu_has_work (CPUState *cpu) +{ +CPUClass *cc =CPU_GET_CLASS (cpu); + +g_assert (cc->has_work); +return cc->has_work (cpu); +} +/** * cpu_get_phys_page_attrs_debug: * @cpu: The CPU to obtain the physical page address for.
@@ -636,22 +652,6 @@ CPUState *cpu_create(const char *typename);*/ const char *parse_cpu_option (const char *cpu_option); -/** -* cpu_has_work: -* @cpu: The vCPU to check. -* -* Checks whether the CPU has work to do. -* -* Returns: %true if the CPU has work, %false otherwise. -*/ -static inline bool cpu_has_work (CPUState *cpu) -{ -CPUClass *cc =CPU_GET_CLASS (cpu); - -g_assert (cc->has_work); -return cc->has_work (cpu); -} -/** * qemu_cpu_is_self: * @cpu: The vCPU to check against.
Signature · 1 line
2.31.1
PATCH v5 4/31 hw/core: Un-inline cpu_has_work()
In reply to Philippe Mathieu-DaudéWe want to make cpu_has_work() per-accelerator. Only declare its prototype and move its definition to softmmu/cpus.c.
--- include/hw/core/cpu.h | 8 +------- softmmu/cpus.c | 8 ++++++++ 2 files changed, 9 insertions(+), 7 deletions(-)
include/hw/core/cpu.h +1 -7
@@ -546,13 +546,7 @@ void cpu_dump_state(CPUState *cpu, FILE *f, int flags);* * Returns: %true if the CPU has work, %false otherwise. */ -static inline bool cpu_has_work (CPUState *cpu) -{ -CPUClass *cc =CPU_GET_CLASS (cpu); - -g_assert (cc->has_work); -return cc->has_work (cpu); -} +bool cpu_has_work (CPUState *cpu);/** * cpu_get_phys_page_attrs_debug:
softmmu/cpus.c +8 -0
@@ -251,6 +251,14 @@ void cpu_interrupt(CPUState *cpu, int mask) } } +bool cpu_has_work (CPUState *cpu) +{ +CPUClass *cc =CPU_GET_CLASS (cpu); + +g_assert (cc->has_work); +return cc->has_work (cpu); +} +static int do_vm_stop (RunState state,bool send_stop) {int ret =0 ;
Signature · 1 line
2.31.1
PATCH v5 5/31 sysemu: Introduce AccelOpsClass::has_work()
In reply to Philippe Mathieu-DaudéIntroduce an accelerator-specific has_work() handler. Eventually call it from cpu_has_work().
--- include/sysemu/accel-ops.h | 5 +++++ softmmu/cpus.c | 9 +++++++-- 2 files changed, 12 insertions(+), 2 deletions(-)
include/sysemu/accel-ops.h +5 -0
@@ -31,6 +31,11 @@ struct AccelOpsClass {void (*create_vcpu_thread)(CPUState *cpu);/* MANDATORY NON-NULL */ void (*kick_vcpu_thread)(CPUState *cpu); +/** +* @has_work: Callback for checking if there is work to do. +*/ +bool (*has_work)(CPUState *cpu); +void (*synchronize_post_reset)(CPUState *cpu);void (*synchronize_post_init)(CPUState *cpu);void (*synchronize_state)(CPUState *cpu);
softmmu/cpus.c +7 -2
@@ -255,8 +255,13 @@ bool cpu_has_work(CPUState *cpu) {CPUClass *cc =CPU_GET_CLASS (cpu); -g_assert (cc->has_work); -return cc->has_work (cpu); +if (cc->has_work) { +return cc->has_work (cpu); + } +if (cpus_accel->has_work) { +return cpus_accel->has_work (cpu); + } +g_assert_not_reached (); }static int do_vm_stop (RunState state,bool send_stop)
Signature · 1 line
2.31.1
Re: [PATCH v5 05/31] sysemu: Introduce AccelOpsClass::has_work()
softmmu/cpus.c bool cpu_has_work(CPUState *cpu) · line 264
Quoted 9 lines · Philippe Mathieu-Daudé
softmmu/cpus.c +7
-2-g_assert (cc->has_work); -return cc->has_work (cpu); +if (cc->has_work) { +return cc->has_work (cpu); + } +if (cpus_accel->has_work) { +return cpus_accel->has_work (cpu); + } +g_assert_not_reached ();
This might be close to the end result, but it isn't what we begin with in cpu_thread_is_idle.
You'd want
if (cc->has_work && cc->has_work(cpu)) {
return true;
}
if (cpus_accel->has_work && cpus_accel->has_work(cpu)) {
return true;
}
return false;to start. After the cpus_accel hook is filled in you can assert and return from cpus_accel->has_work. And of course after cc->has_work is removed, that clause is gone.
r~
Re: [PATCH v5 05/31] sysemu: Introduce AccelOpsClass::has_work()
Quoted 23 lines · Richard Henderson
Quoted 9 lines · Philippe Mathieu-Daudé
-
g_assert(cc->has_work);
- returncc->has_work(cpu);
+ if (cc->has_work) {
+ returncc->has_work(cpu);
+ }
+ if (cpus_accel->has_work) {
+ returncpus_accel->has_work(cpu);
+ }
+g_assert_not_reached();This might be close to the end result, but it isn't what we begin with in
cpu_thread_is_idle.You'd want
if (
cc->has_work&&cc->has_work(cpu)) { return true;
}
if (cpus_accel->has_work&&cpus_accel->has_work(cpu)) { return true;
}
return false;
Quoted 1 line
to start. After the
cpus_accelhook is filled in you can assert and return from cpus_accel->has_work. And of course aftercc->has_workis removed, that clause is gone.
Much cleaner, thank you for the hints :)
PATCH v5 6/31 accel/kvm: Implement AccelOpsClass::has_work()
In reply to Philippe Mathieu-DaudéImplement KVM has_work() handler in AccelOpsClass and remove it from cpu_thread_is_idle() since cpu_has_work() is already called.
--- accel/kvm/kvm-accel-ops.c | 6 ++++++ softmmu/cpus.c | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-)
accel/kvm/kvm-accel-ops.c +6 -0
@@ -74,6 +74,11 @@ static void kvm_start_vcpu_thread(CPUState *cpu) cpu, QEMU_THREAD_JOINABLE); } +static bool kvm_cpu_has_work (CPUState *cpu) +{ +return kvm_halt_in_kernel (); +} +static void kvm_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc);
@@ -83,6 +88,7 @@ static void kvm_accel_ops_class_init(ObjectClass *oc, void *data) ops->synchronize_post_init = kvm_cpu_synchronize_post_init; ops->synchronize_state = kvm_cpu_synchronize_state; ops->synchronize_pre_loadvm = kvm_cpu_synchronize_pre_loadvm; + ops->has_work = kvm_cpu_has_work; }static const TypeInfo kvm_accel_ops_type = {
softmmu/cpus.c +1 -1
@@ -90,7 +90,7 @@ bool cpu_thread_is_idle(CPUState *cpu)return true; }if (!cpu->halted ||cpu_has_work (cpu) || -kvm_halt_in_kernel () ||whpx_apic_in_platform ()) { +whpx_apic_in_platform ()) {return false; }return true;
Signature · 1 line
2.31.1
PATCH v5 7/31 accel/whpx: Implement AccelOpsClass::has_work()
In reply to Philippe Mathieu-DaudéImplement WHPX has_work() handler in AccelOpsClass and remove it from cpu_thread_is_idle() since cpu_has_work() is already called.
--- softmmu/cpus.c | 4 +--- target/i386/whpx/whpx-accel-ops.c | 6 ++++++ 2 files changed, 7 insertions(+), 3 deletions(-)
softmmu/cpus.c +1 -3
@@ -41,7 +41,6 @@#include "sysemu/replay.h" #include "sysemu/runstate.h" #include "sysemu/cpu-timers.h" -#include "sysemu/whpx.h" #include "hw/boards.h" #include "hw/hw.h" #include "trace.h"
@@ -89,8 +88,7 @@ bool cpu_thread_is_idle(CPUState *cpu)if (cpu_is_stopped (cpu)) {return true; } -if (!cpu->halted ||cpu_has_work (cpu) || -whpx_apic_in_platform ()) { +if (!cpu->halted ||cpu_has_work (cpu)) {return false; }return true;
target/i386/whpx/whpx-accel-ops.c +6 -0
@@ -83,6 +83,11 @@ static void whpx_kick_vcpu_thread(CPUState *cpu) } } +static bool whpx_cpu_has_work (CPUState *cpu) +{ +return whpx_apic_in_platform (); +} +static void whpx_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc);
@@ -94,6 +99,7 @@ static void whpx_accel_ops_class_init(ObjectClass *oc, void *data) ops->synchronize_post_init = whpx_cpu_synchronize_post_init; ops->synchronize_state = whpx_cpu_synchronize_state; ops->synchronize_pre_loadvm = whpx_cpu_synchronize_pre_loadvm; + ops->has_work = whpx_cpu_has_work; }static const TypeInfo whpx_accel_ops_type = {
Signature · 1 line
2.31.1
PATCH v5 8/31 accel/tcg: Implement AccelOpsClass::has_work() as stub
In reply to Philippe Mathieu-DaudéAdd TCG target-specific has_work() handler in TCGCPUOps, and add tcg_cpu_has_work() as AccelOpsClass has_work() implementation.
--- include/hw/core/tcg-cpu-ops.h | 4 ++++ accel/tcg/tcg-accel-ops.c | 10 ++++++++++ 2 files changed, 14 insertions(+)
include/hw/core/tcg-cpu-ops.h +4 -0
@@ -66,6 +66,10 @@ struct TCGCPUOps {void (*do_interrupt)(CPUState *cpu);#endif /* !CONFIG_USER_ONLY || !TARGET_I386 */ #ifdef CONFIG_SOFTMMU +/** +* @has_work: Callback for checking if there is work to do. +*/ +bool (*has_work)(CPUState *cpu);/** @cpu_exec_interrupt: Callback for processing interrupts in cpu_exec */ bool (*cpu_exec_interrupt)(CPUState *cpu,int interrupt_request);/**
accel/tcg/tcg-accel-ops.c +10 -0
@@ -32,6 +32,7 @@#include "qemu/main-loop.h" #include "qemu/guest-random.h" #include "exec/exec-all.h" +#include "hw/core/tcg-cpu-ops.h" #include "tcg-accel-ops.h" #include "tcg-accel-ops-mttcg.h"
@@ -73,6 +74,14 @@ int tcg_cpus_exec(CPUState *cpu)return ret; } +static bool tcg_cpu_has_work (CPUState *cpu) +{ +CPUClass *cc =CPU_GET_CLASS (cpu); + +g_assert (cc->tcg_ops->has_work); +return cc->tcg_ops->has_work (cpu); +} +/* mask must never be zero, except for A20 change call */ void tcg_handle_interrupt (CPUState *cpu,int mask) {
@@ -108,6 +117,7 @@ static void tcg_accel_ops_init(AccelOpsClass *ops) ops->kick_vcpu_thread = rr_kick_vcpu_thread; ops->handle_interrupt = tcg_handle_interrupt; } + ops->has_work = tcg_cpu_has_work; }static void tcg_accel_ops_class_init (ObjectClass *oc,void *data)
Signature · 1 line
2.31.1
Re: [PATCH v5 08/31] accel/tcg: Implement AccelOpsClass::has_work() as stub
accel/tcg/tcg-accel-ops.c int tcg_cpus_exec(CPUState *cpu) · line 83
Quoted 7 lines · Philippe Mathieu-Daudé
accel/tcg/tcg-accel-ops.c +7
-0+static bool tcg_cpu_has_work (CPUState *cpu) +{ +CPUClass *cc =CPU_GET_CLASS (cpu); + +g_assert (cc->tcg_ops->has_work); +return cc->tcg_ops->has_work (cpu); +}
Now, you're expecting cc->has_work to disappear as cc->tcg_ops->has_work appears. If we're expecting cc->has_work to not affect other accelerators, then I think you should first move cc->has_work to this function, *before* you add the tcg_ops hook.
r~
Re: [PATCH v5 08/31] accel/tcg: Implement AccelOpsClass::has_work() as stub
Quoted 10 lines · Richard Henderson
accel/tcg/tcg-accel-ops.c int tcg_cpus_exec(CPUState *cpu) · line 83
Quoted 7 lines · Philippe Mathieu-Daudé
accel/tcg/tcg-accel-ops.c +7
-0+static bool tcg_cpu_has_work (CPUState *cpu) +{ + CPUClass *cc = CPU_GET_CLASS(cpu); + + g_assert(cc->tcg_ops->has_work); + return cc->tcg_ops->has_work(cpu); +}Now, you're expecting
cc->has_workto disappear ascc->tcg_ops->has_workappears. If we're expectingcc->has_workto not affect other accelerators, then I think you should first movecc->has_workto this function, *before* you add thetcg_opshook.
Indeed, thanks.
PATCH v5 9/31 target/alpha: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/alpha/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/alpha/cpu.c +3 -1
@@ -33,6 +33,7 @@ static void alpha_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.pc = value; } +#if !defined(CONFIG_USER_ONLY )static bool alpha_cpu_has_work (CPUState *cs) {/* Here we are checking to see if the CPU should wake up from HALT.
@@ -47,6 +48,7 @@ static bool alpha_cpu_has_work(CPUState *cs) | CPU_INTERRUPT_SMP | CPU_INTERRUPT_MCHK); } +#endif /* !CONFIG_USER_ONLY */ static void alpha_cpu_disas_set_info (CPUState *cpu,disassemble_info *info) {
@@ -221,6 +223,7 @@ static const struct TCGCPUOps alpha_tcg_ops = { .tlb_fill = alpha_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = alpha_cpu_has_work, .cpu_exec_interrupt = alpha_cpu_exec_interrupt, .do_interrupt = alpha_cpu_do_interrupt, .do_transaction_failed = alpha_cpu_do_transaction_failed,
@@ -238,7 +241,6 @@ static void alpha_cpu_class_init(ObjectClass *oc, void *data) &acc->parent_realize); cc->class_by_name = alpha_cpu_class_by_name; - cc->has_work = alpha_cpu_has_work; cc->dump_state = alpha_cpu_dump_state; cc->set_pc = alpha_cpu_set_pc; cc->gdb_read_register = alpha_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 10/31 target/arm: Restrict has_work() handler to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict has_work() to TCG sysemu.
--- target/arm/cpu.c | 7 +++++-- target/arm/cpu_tcg.c | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-)
target/arm/cpu.c +5 -2
@@ -73,8 +73,8 @@ void arm_cpu_synchronize_from_tb(CPUState *cs, env->regs[15 ] = tb->pc; } } -#endif /* CONFIG_TCG */ +#ifndef CONFIG_USER_ONLY static bool arm_cpu_has_work (CPUState *cs) {ARMCPU *cpu =ARM_CPU (cs);
@@ -85,6 +85,9 @@ static bool arm_cpu_has_work(CPUState *cs) | CPU_INTERRUPT_VFIQ | CPU_INTERRUPT_VIRQ | CPU_INTERRUPT_EXITTB); } +#endif /* !CONFIG_USER_ONLY */ + +#endif /* CONFIG_TCG */ void arm_register_pre_el_change_hook (ARMCPU *cpu,ARMELChangeHookFn *hook,void *opaque)
@@ -2017,6 +2020,7 @@ static const struct TCGCPUOps arm_tcg_ops = { .debug_excp_handler = arm_debug_excp_handler,#if !defined(CONFIG_USER_ONLY ) + .has_work = arm_cpu_has_work, .cpu_exec_interrupt = arm_cpu_exec_interrupt, .do_interrupt = arm_cpu_do_interrupt, .do_transaction_failed = arm_cpu_do_transaction_failed,
@@ -2041,7 +2045,6 @@ static void arm_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, arm_cpu_reset, &acc->parent_reset); cc->class_by_name = arm_cpu_class_by_name; - cc->has_work = arm_cpu_has_work; cc->dump_state = arm_cpu_dump_state; cc->set_pc = arm_cpu_set_pc; cc->gdb_read_register = arm_cpu_gdb_read_register;
target/arm/cpu_tcg.c +1 -1
@@ -907,6 +907,7 @@ static const struct TCGCPUOps arm_v7m_tcg_ops = { .debug_excp_handler = arm_debug_excp_handler,#if !defined(CONFIG_USER_ONLY ) + .has_work = arm_v7m_cpu_has_work, .cpu_exec_interrupt = arm_v7m_cpu_exec_interrupt, .do_interrupt = arm_v7m_cpu_do_interrupt, .do_transaction_failed = arm_cpu_do_transaction_failed,
@@ -925,7 +926,6 @@ static void arm_v7m_class_init(ObjectClass *oc, void *data) acc->info = data;#ifdef CONFIG_TCG - cc->has_work = arm_v7m_cpu_has_work; cc->tcg_ops = &arm_v7m_tcg_ops;#endif /* CONFIG_TCG */
Signature · 1 line
2.31.1
Re: [PATCH v5 10/31] target/arm: Restrict has_work() handler to sysemu and TCG
Quoted 7 lines · Philippe Mathieu-Daudé
Restrict
has_work()to TCG sysemu.Signed-off-by Philippe Mathieu-Daudé<[email protected]>--- target/arm/cpu.c | 7 +++++-- target/arm/cpu_tcg.c | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-)
r~
PATCH v5 11/31 target/avr: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/avr/cpu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
target/avr/cpu.c +1 -1
@@ -195,6 +195,7 @@ static const struct SysemuCPUOps avr_sysemu_ops = {static const struct TCGCPUOps avr_tcg_ops = { .initialize = avr_cpu_tcg_init, .synchronize_from_tb = avr_cpu_synchronize_from_tb, + .has_work = avr_cpu_has_work, .cpu_exec_interrupt = avr_cpu_exec_interrupt, .tlb_fill = avr_cpu_tlb_fill, .do_interrupt = avr_cpu_do_interrupt,
@@ -211,7 +212,6 @@ static void avr_cpu_class_init(ObjectClass *oc, void *data) cc->class_by_name = avr_cpu_class_by_name; - cc->has_work = avr_cpu_has_work; cc->dump_state = avr_cpu_dump_state; cc->set_pc = avr_cpu_set_pc; cc->memory_rw_debug = avr_cpu_memory_rw_debug;
Signature · 1 line
2.31.1
PATCH v5 12/31 target/cris: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/cris/cpu.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
target/cris/cpu.c +4 -1
@@ -35,10 +35,12 @@ static void cris_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.pc = value; } +#if !defined(CONFIG_USER_ONLY )static bool cris_cpu_has_work (CPUState *cs) {return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); } +#endif /* !CONFIG_USER_ONLY */ static void cris_cpu_reset (DeviceState *dev) {
@@ -208,6 +210,7 @@ static const struct TCGCPUOps crisv10_tcg_ops = { .tlb_fill = cris_cpu_tlb_fill,#ifndef CONFIG_USER_ONLY + .has_work = cris_cpu_has_work, .cpu_exec_interrupt = cris_cpu_exec_interrupt, .do_interrupt = crisv10_cpu_do_interrupt,#endif /* !CONFIG_USER_ONLY */
@@ -218,6 +221,7 @@ static const struct TCGCPUOps crisv32_tcg_ops = { .tlb_fill = cris_cpu_tlb_fill,#ifndef CONFIG_USER_ONLY + .has_work = cris_cpu_has_work, .cpu_exec_interrupt = cris_cpu_exec_interrupt, .do_interrupt = cris_cpu_do_interrupt,#endif /* !CONFIG_USER_ONLY */
@@ -294,7 +298,6 @@ static void cris_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, cris_cpu_reset, &ccc->parent_reset); cc->class_by_name = cris_cpu_class_by_name; - cc->has_work = cris_cpu_has_work; cc->dump_state = cris_cpu_dump_state; cc->set_pc = cris_cpu_set_pc; cc->gdb_read_register = cris_cpu_gdb_read_register;
Signature · 1 line
2.31.1
Re: [PATCH v5 12/31] target/cris: Restrict has_work() handler to sysemu
Quoted 6 lines · Philippe Mathieu-Daudé
Restrict
has_work()to sysemu.Signed-off-by Philippe Mathieu-Daudé<[email protected]>--- target/cris/cpu.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
r~
PATCH v5 13/31 target/hexagon: Remove unused has_work() handler
In reply to Philippe Mathieu-Daudéhas_work() is sysemu specific, and Hexagon target only provides a linux-user implementation. Remove the unused hexagon_cpu_has_work().
--- target/hexagon/cpu.c | 6 ------ 1 file changed, 6 deletions(-)
target/hexagon/cpu.c +0 -6
@@ -189,11 +189,6 @@ static void hexagon_cpu_synchronize_from_tb(CPUState *cs, env->gpr[HEX_REG_PC ] = tb->pc; } -static bool hexagon_cpu_has_work (CPUState *cs) -{ -return true; -} -void restore_state_to_opc (CPUHexagonState *env,TranslationBlock *tb,target_ulong *data) {
@@ -287,7 +282,6 @@ static void hexagon_cpu_class_init(ObjectClass *c, void *data)device_class_set_parent_reset (dc, hexagon_cpu_reset, &mcc->parent_reset); cc->class_by_name = hexagon_cpu_class_by_name; - cc->has_work = hexagon_cpu_has_work; cc->dump_state = hexagon_dump_state; cc->set_pc = hexagon_cpu_set_pc; cc->gdb_read_register = hexagon_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 14/31 target/hppa: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/hppa/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/hppa/cpu.c +3 -1
@@ -60,10 +60,12 @@ static void hppa_cpu_synchronize_from_tb(CPUState *cs, cpu->env.psw_n = (tb->flags &PSW_N ) !=0 ; } +#if !defined(CONFIG_USER_ONLY )static bool hppa_cpu_has_work (CPUState *cs) {return cs->interrupt_request &CPU_INTERRUPT_HARD ; } +#endif /* !CONFIG_USER_ONLY */ static void hppa_cpu_disas_set_info (CPUState *cs,disassemble_info *info) {
@@ -147,6 +149,7 @@ static const struct TCGCPUOps hppa_tcg_ops = { .tlb_fill = hppa_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = hppa_cpu_has_work, .cpu_exec_interrupt = hppa_cpu_exec_interrupt, .do_interrupt = hppa_cpu_do_interrupt, .do_unaligned_access = hppa_cpu_do_unaligned_access,
@@ -163,7 +166,6 @@ static void hppa_cpu_class_init(ObjectClass *oc, void *data) &acc->parent_realize); cc->class_by_name = hppa_cpu_class_by_name; - cc->has_work = hppa_cpu_has_work; cc->dump_state = hppa_cpu_dump_state; cc->set_pc = hppa_cpu_set_pc; cc->gdb_read_register = hppa_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 15/31 target/i386: Restrict has_work() handler to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict has_work() to TCG sysemu.
--- target/i386/cpu.c | 6 ------ target/i386/tcg/tcg-cpu.c | 8 +++++++- 2 files changed, 7 insertions(+), 7 deletions(-)
target/i386/cpu.c +0 -6
@@ -6554,11 +6554,6 @@ int x86_cpu_pending_interrupt(CPUState *cs, int interrupt_request)return 0 ; } -static bool x86_cpu_has_work (CPUState *cs) -{ -return x86_cpu_pending_interrupt (cs, cs->interrupt_request) !=0 ; -} -static void x86_disas_set_info (CPUState *cs,disassemble_info *info) {X86CPU *cpu =X86_CPU (cs);
@@ -6763,7 +6758,6 @@ static void x86_cpu_common_class_init(ObjectClass *oc, void *data) cc->class_by_name = x86_cpu_class_by_name; cc->parse_features = x86_cpu_parse_featurestr; - cc->has_work = x86_cpu_has_work; cc->dump_state = x86_cpu_dump_state; cc->set_pc = x86_cpu_set_pc; cc->gdb_read_register = x86_cpu_gdb_read_register;
target/i386/tcg/tcg-cpu.c +7 -1
@@ -55,6 +55,11 @@ static void x86_cpu_synchronize_from_tb(CPUState *cs, }#ifndef CONFIG_USER_ONLY +static bool x86_cpu_has_work (CPUState *cs) +{ +return x86_cpu_pending_interrupt (cs, cs->interrupt_request) !=0 ; +} +static bool x86_debug_check_breakpoint (CPUState *cs) {X86CPU *cpu =X86_CPU (cs);
@@ -63,7 +68,7 @@ static bool x86_debug_check_breakpoint(CPUState *cs)/* RF disables all architectural breakpoints. */ return !(env->eflags & RF_MASK); } -#endif +#endif /* CONFIG_USER_ONLY */ #include "hw/core/tcg-cpu-ops.h"
@@ -76,6 +81,7 @@ static const struct TCGCPUOps x86_tcg_ops = {#ifdef CONFIG_USER_ONLY .fake_user_interrupt = x86_cpu_do_interrupt, #else + .has_work = x86_cpu_has_work, .do_interrupt = x86_cpu_do_interrupt, .cpu_exec_interrupt = x86_cpu_exec_interrupt, .debug_excp_handler = breakpoint_handler,
Signature · 1 line
2.31.1
PATCH v5 16/31 target/m68k: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/m68k/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/m68k/cpu.c +3 -1
@@ -31,10 +31,12 @@ static void m68k_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.pc = value; } +#if !defined(CONFIG_USER_ONLY )static bool m68k_cpu_has_work (CPUState *cs) {return cs->interrupt_request &CPU_INTERRUPT_HARD ; } +#endif /* !CONFIG_USER_ONLY */ static void m68k_set_feature (CPUM68KState *env,int feature) {
@@ -518,6 +520,7 @@ static const struct TCGCPUOps m68k_tcg_ops = { .tlb_fill = m68k_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = m68k_cpu_has_work, .cpu_exec_interrupt = m68k_cpu_exec_interrupt, .do_interrupt = m68k_cpu_do_interrupt, .do_transaction_failed = m68k_cpu_transaction_failed,
@@ -535,7 +538,6 @@ static void m68k_cpu_class_init(ObjectClass *c, void *data)device_class_set_parent_reset (dc, m68k_cpu_reset, &mcc->parent_reset); cc->class_by_name = m68k_cpu_class_by_name; - cc->has_work = m68k_cpu_has_work; cc->dump_state = m68k_cpu_dump_state; cc->set_pc = m68k_cpu_set_pc; cc->gdb_read_register = m68k_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 17/31 target/microblaze: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/microblaze/cpu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
target/microblaze/cpu.c +4 -4
@@ -92,12 +92,13 @@ static void mb_cpu_synchronize_from_tb(CPUState *cs, cpu->env.iflags = tb->flags &IFLAGS_TB_MASK ; } +#ifndef CONFIG_USER_ONLY +static bool mb_cpu_has_work (CPUState *cs) {return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); } -#ifndef CONFIG_USER_ONLY static void mb_cpu_ns_axi_dp (void *opaque,int irq,int level) {MicroBlazeCPU *cpu = opaque;
@@ -142,7 +143,7 @@ static void microblaze_cpu_set_irq(void *opaque, int irq, int level) cpu_reset_interrupt(cs, type); } } -#endif +#endif /* !CONFIG_USER_ONLY */ static void mb_cpu_reset (DeviceState *dev) {
@@ -368,6 +369,7 @@ static const struct TCGCPUOps mb_tcg_ops = { .tlb_fill = mb_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = mb_cpu_has_work, .cpu_exec_interrupt = mb_cpu_exec_interrupt, .do_interrupt = mb_cpu_do_interrupt, .do_transaction_failed = mb_cpu_transaction_failed,
@@ -386,8 +388,6 @@ static void mb_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, mb_cpu_reset, &mcc->parent_reset); cc->class_by_name = mb_cpu_class_by_name; - cc->has_work = mb_cpu_has_work; - cc->dump_state = mb_cpu_dump_state; cc->set_pc = mb_cpu_set_pc; cc->gdb_read_register = mb_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 18/31 target/mips: Restrict has_work() handler to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict has_work() to TCG sysemu.
--- target/mips/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/mips/cpu.c +3 -1
@@ -128,6 +128,7 @@ static void mips_cpu_set_pc(CPUState *cs, vaddr value)mips_env_set_pc (&cpu->env, value); } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool mips_cpu_has_work (CPUState *cs) {MIPSCPU *cpu =MIPS_CPU (cs);
@@ -172,6 +173,7 @@ static bool mips_cpu_has_work(CPUState *cs) }return has_work; } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ #include "cpu-defs.c.inc"
@@ -542,6 +544,7 @@ static const struct TCGCPUOps mips_tcg_ops = { .tlb_fill = mips_cpu_tlb_fill,#if !defined(CONFIG_USER_ONLY ) + .has_work = mips_cpu_has_work, .cpu_exec_interrupt = mips_cpu_exec_interrupt, .do_interrupt = mips_cpu_do_interrupt, .do_transaction_failed = mips_cpu_do_transaction_failed,
@@ -563,7 +566,6 @@ static void mips_cpu_class_init(ObjectClass *c, void *data)device_class_set_props (dc, mips_cpu_properties); cc->class_by_name = mips_cpu_class_by_name; - cc->has_work = mips_cpu_has_work; cc->dump_state = mips_cpu_dump_state; cc->set_pc = mips_cpu_set_pc; cc->gdb_read_register = mips_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 19/31 target/nios2: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/nios2/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/nios2/cpu.c +3 -1
@@ -34,10 +34,12 @@ static void nios2_cpu_set_pc(CPUState *cs, vaddr value) env->regs[R_PC ] = value; } +#if !defined(CONFIG_USER_ONLY )static bool nios2_cpu_has_work (CPUState *cs) {return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_NMI ); } +#endif /* !CONFIG_USER_ONLY */ static void nios2_cpu_reset (DeviceState *dev) {
@@ -223,6 +225,7 @@ static const struct TCGCPUOps nios2_tcg_ops = { .tlb_fill = nios2_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = nios2_cpu_has_work, .cpu_exec_interrupt = nios2_cpu_exec_interrupt, .do_interrupt = nios2_cpu_do_interrupt, .do_unaligned_access = nios2_cpu_do_unaligned_access,
@@ -241,7 +244,6 @@ static void nios2_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, nios2_cpu_reset, &ncc->parent_reset); cc->class_by_name = nios2_cpu_class_by_name; - cc->has_work = nios2_cpu_has_work; cc->dump_state = nios2_cpu_dump_state; cc->set_pc = nios2_cpu_set_pc; cc->disas_set_info = nios2_cpu_disas_set_info;
Signature · 1 line
2.31.1
PATCH v5 20/31 target/openrisc: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/openrisc/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/openrisc/cpu.c +3 -1
@@ -30,11 +30,13 @@ static void openrisc_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.dflag =0 ; } +#if !defined(CONFIG_USER_ONLY )static bool openrisc_cpu_has_work (CPUState *cs) {return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_TIMER ); } +#endif /* !CONFIG_USER_ONLY */ static void openrisc_disas_set_info (CPUState *cpu,disassemble_info *info) {
@@ -189,6 +191,7 @@ static const struct TCGCPUOps openrisc_tcg_ops = { .tlb_fill = openrisc_cpu_tlb_fill,#ifndef CONFIG_USER_ONLY + .has_work = openrisc_cpu_has_work, .cpu_exec_interrupt = openrisc_cpu_exec_interrupt, .do_interrupt = openrisc_cpu_do_interrupt,#endif /* !CONFIG_USER_ONLY */
@@ -205,7 +208,6 @@ static void openrisc_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, openrisc_cpu_reset, &occ->parent_reset); cc->class_by_name = openrisc_cpu_class_by_name; - cc->has_work = openrisc_cpu_has_work; cc->dump_state = openrisc_cpu_dump_state; cc->set_pc = openrisc_cpu_set_pc; cc->gdb_read_register = openrisc_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 21/31 target/ppc: Introduce PowerPCCPUClass::has_work()
In reply to Philippe Mathieu-DaudéWe're moving the hook from CPUState to TCGCPUOps. TCGCPUOps is a const structure, so to avoid creating multiple versions of the same structure, simply changing the has_work() handler, introduce yet another indirection with a has_work() handler in PowerPCCPUClass, and ppc_cpu_has_work() method which dispatch to it.
--- target/ppc/cpu-qom.h | 1 + target/ppc/cpu_init.c | 23 ++++++++++++++--------- 2 files changed, 15 insertions(+), 9 deletions(-)
target/ppc/cpu-qom.h +1 -0
@@ -188,6 +188,7 @@ struct PowerPCCPUClass {uint32_t flags;int bfd_mach;uint32_t l1_dcache_size, l1_icache_size; +bool (*has_work)(CPUState *cpu);#ifndef CONFIG_USER_ONLY unsigned int gdb_num_sprs;const char *gdb_spr_xml;
target/ppc/cpu_init.c +14 -9
@@ -7621,7 +7621,6 @@ POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data) {DeviceClass *dc =DEVICE_CLASS (oc);PowerPCCPUClass *pcc =POWERPC_CPU_CLASS (oc); -CPUClass *cc =CPU_CLASS (oc); dc->fw_name ="PowerPC,POWER7" ; dc->desc ="POWER7" ;
@@ -7630,7 +7629,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; + pcc->has_work = 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 |
@@ -7789,7 +7788,6 @@ POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data) {DeviceClass *dc =DEVICE_CLASS (oc);PowerPCCPUClass *pcc =POWERPC_CPU_CLASS (oc); -CPUClass *cc =CPU_CLASS (oc); dc->fw_name ="PowerPC,POWER8" ; dc->desc ="POWER8" ;
@@ -7798,7 +7796,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; + pcc->has_work = 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 |
@@ -8003,7 +8001,6 @@ POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data) {DeviceClass *dc =DEVICE_CLASS (oc);PowerPCCPUClass *pcc =POWERPC_CPU_CLASS (oc); -CPUClass *cc =CPU_CLASS (oc); dc->fw_name ="PowerPC,POWER9" ; dc->desc ="POWER9" ;
@@ -8013,7 +8010,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; + pcc->has_work = 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 |
@@ -8212,7 +8209,6 @@ POWERPC_FAMILY(POWER10)(ObjectClass *oc, void *data) {DeviceClass *dc =DEVICE_CLASS (oc);PowerPCCPUClass *pcc =POWERPC_CPU_CLASS (oc); -CPUClass *cc =CPU_CLASS (oc); dc->fw_name ="PowerPC,POWER10" ; dc->desc ="POWER10" ;
@@ -8223,7 +8219,7 @@ POWERPC_FAMILY(POWER10)(ObjectClass *oc, void *data)PCR_COMPAT_2_06 |PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER10; pcc->check_pow = check_pow_nocheck; - cc->has_work = cpu_has_work_POWER10; + pcc->has_work = cpu_has_work_POWER10; 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 |
@@ -8790,7 +8786,7 @@ static void ppc_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.nip = value; } -static bool ppc_cpu_has_work (CPUState *cs) +static bool cpu_has_work_default (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);CPUPPCState *env = &cpu->env;
@@ -8798,6 +8794,14 @@ static bool ppc_cpu_has_work(CPUState *cs)return msr_ee && (cs->interrupt_request &CPU_INTERRUPT_HARD ); } +static bool ppc_cpu_has_work (CPUState *cs) +{ +PowerPCCPU *cpu =POWERPC_CPU (cs); +PowerPCCPUClass *pcc =POWERPC_CPU_GET_CLASS (cpu); + +return pcc->has_work (cs); +} +static void ppc_cpu_reset (DeviceState *dev) {CPUState *s =CPU (dev);
@@ -9037,6 +9041,7 @@ static void ppc_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_unrealize (dc, ppc_cpu_unrealize, &pcc->parent_unrealize); pcc->pvr_match = ppc_pvr_match_default; + pcc->has_work = cpu_has_work_default;device_class_set_props (dc, ppc_cpu_properties);device_class_set_parent_reset (dc, ppc_cpu_reset, &pcc->parent_reset);
Signature · 1 line
2.31.1
PATCH v5 22/31 target/ppc: Restrict has_work() handlers to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict PowerPCCPUClass::has_work() and ppc_cpu_has_work()
- SysemuCPUOps::has_work() implementation - to TCG sysemu.
--- target/ppc/cpu-qom.h | 4 +++- target/ppc/cpu_init.c | 24 ++++++++++++++++++------ 2 files changed, 21 insertions(+), 7 deletions(-)
target/ppc/cpu-qom.h +3 -1
@@ -188,8 +188,10 @@ struct PowerPCCPUClass {uint32_t flags;int bfd_mach;uint32_t l1_dcache_size, l1_icache_size; -bool (*has_work)(CPUState *cpu);#ifndef CONFIG_USER_ONLY +#ifdef CONFIG_TCG +bool (*has_work)(CPUState *cpu); +#endif /* CONFIG_TCG */ unsigned int gdb_num_sprs;const char *gdb_spr_xml;#endif
target/ppc/cpu_init.c +18 -6
@@ -7583,6 +7583,7 @@ static bool ppc_pvr_match_power7(PowerPCCPUClass *pcc, uint32_t pvr)return false; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool cpu_has_work_POWER7 (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);
@@ -7616,6 +7617,7 @@ static bool cpu_has_work_POWER7(CPUState *cs) return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD); } } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ POWERPC_FAMILY (POWER7 )(ObjectClass *oc,void *data) {
@@ -7629,7 +7631,6 @@ 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; - pcc->has_work = 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 |
@@ -7672,6 +7673,7 @@ POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data) pcc->lpcr_pm =LPCR_P7_PECE0 |LPCR_P7_PECE1 |LPCR_P7_PECE2 ; pcc->mmu_model =POWERPC_MMU_2_06 ;#if defined(CONFIG_SOFTMMU ) + pcc->has_work = cpu_has_work_POWER7; pcc->hash64_opts = &ppc_hash64_opts_POWER7; pcc->lrg_decr_bits =32 ;#endif
@@ -7742,6 +7744,7 @@ static bool ppc_pvr_match_power8(PowerPCCPUClass *pcc, uint32_t pvr)return false; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool cpu_has_work_POWER8 (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);
@@ -7783,6 +7786,7 @@ static bool cpu_has_work_POWER8(CPUState *cs) return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD); } } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ POWERPC_FAMILY (POWER8 )(ObjectClass *oc,void *data) {
@@ -7796,7 +7800,6 @@ 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; - pcc->has_work = 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 |
@@ -7846,6 +7849,7 @@ POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)LPCR_P8_PECE3 |LPCR_P8_PECE4 ; pcc->mmu_model =POWERPC_MMU_2_07 ;#if defined(CONFIG_SOFTMMU ) + pcc->has_work = cpu_has_work_POWER8; pcc->hash64_opts = &ppc_hash64_opts_POWER7; pcc->lrg_decr_bits =32 ; pcc->n_host_threads =8 ;
@@ -7939,6 +7943,7 @@ static bool ppc_pvr_match_power9(PowerPCCPUClass *pcc, uint32_t pvr)return false; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool cpu_has_work_POWER9 (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);
@@ -7996,6 +8001,7 @@ static bool cpu_has_work_POWER9(CPUState *cs) return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD); } } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ POWERPC_FAMILY (POWER9 )(ObjectClass *oc,void *data) {
@@ -8010,7 +8016,6 @@ POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER9; pcc->check_pow = check_pow_nocheck; - pcc->has_work = 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 |
@@ -8059,6 +8064,7 @@ POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data) pcc->lpcr_pm =LPCR_PDEE |LPCR_HDEE |LPCR_EEE |LPCR_DEE |LPCR_OEE ; pcc->mmu_model =POWERPC_MMU_3_00 ;#if defined(CONFIG_SOFTMMU ) + pcc->has_work = cpu_has_work_POWER9;/* segment page size remain the same */ pcc->hash64_opts = &ppc_hash64_opts_POWER7; pcc->radix_page_info = &POWER9_radix_page_info;
@@ -8147,6 +8153,7 @@ static bool ppc_pvr_match_power10(PowerPCCPUClass *pcc, uint32_t pvr)return false; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool cpu_has_work_POWER10 (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);
@@ -8204,6 +8211,7 @@ static bool cpu_has_work_POWER10(CPUState *cs) return msr_ee && (cs->interrupt_request & CPU_INTERRUPT_HARD); } } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ POWERPC_FAMILY (POWER10 )(ObjectClass *oc,void *data) {
@@ -8219,7 +8227,6 @@ POWERPC_FAMILY(POWER10)(ObjectClass *oc, void *data)PCR_COMPAT_2_06 |PCR_COMPAT_2_05 ; pcc->init_proc = init_proc_POWER10; pcc->check_pow = check_pow_nocheck; - pcc->has_work = cpu_has_work_POWER10; 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 |
@@ -8271,6 +8278,7 @@ POWERPC_FAMILY(POWER10)(ObjectClass *oc, void *data) pcc->lpcr_pm =LPCR_PDEE |LPCR_HDEE |LPCR_EEE |LPCR_DEE |LPCR_OEE ; pcc->mmu_model =POWERPC_MMU_3_00 ;#if defined(CONFIG_SOFTMMU ) + pcc->has_work = cpu_has_work_POWER10;/* segment page size remain the same */ pcc->hash64_opts = &ppc_hash64_opts_POWER7; pcc->radix_page_info = &POWER10_radix_page_info;
@@ -8786,6 +8794,7 @@ static void ppc_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.nip = value; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool cpu_has_work_default (CPUState *cs) {PowerPCCPU *cpu =POWERPC_CPU (cs);
@@ -8801,6 +8810,7 @@ static bool ppc_cpu_has_work(CPUState *cs) return pcc->has_work(cs); } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ static void ppc_cpu_reset (DeviceState *dev) {
@@ -9021,6 +9031,7 @@ static const struct TCGCPUOps ppc_tcg_ops = { .tlb_fill = ppc_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = ppc_cpu_has_work, .cpu_exec_interrupt = ppc_cpu_exec_interrupt, .do_interrupt = ppc_cpu_do_interrupt, .cpu_exec_enter = ppc_cpu_exec_enter,
@@ -9041,13 +9052,11 @@ static void ppc_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_unrealize (dc, ppc_cpu_unrealize, &pcc->parent_unrealize); pcc->pvr_match = ppc_pvr_match_default; - pcc->has_work = cpu_has_work_default;device_class_set_props (dc, ppc_cpu_properties);device_class_set_parent_reset (dc, ppc_cpu_reset, &pcc->parent_reset); cc->class_by_name = ppc_cpu_class_by_name; - cc->has_work = ppc_cpu_has_work; cc->dump_state = ppc_cpu_dump_state; cc->set_pc = ppc_cpu_set_pc; cc->gdb_read_register = ppc_cpu_gdb_read_register;
@@ -9078,6 +9087,9 @@ static void ppc_cpu_class_init(ObjectClass *oc, void *data)#ifdef CONFIG_TCG cc->tcg_ops = &ppc_tcg_ops; +#ifndef CONFIG_USER_ONLY + pcc->has_work = cpu_has_work_default; +#endif #endif /* CONFIG_TCG */ }
Signature · 1 line
2.31.1
PATCH v5 23/31 target/riscv: Restrict has_work() handler to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict has_work() to TCG sysemu.
--- target/riscv/cpu.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
target/riscv/cpu.c +3 -5
@@ -335,9 +335,9 @@ static void riscv_cpu_synchronize_from_tb(CPUState *cs, env->pc = tb->pc; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool riscv_cpu_has_work (CPUState *cs) { -#ifndef CONFIG_USER_ONLY RISCVCPU *cpu =RISCV_CPU (cs);CPURISCVState *env = &cpu->env;/*
@@ -345,10 +345,8 @@ static bool riscv_cpu_has_work(CPUState *cs)* mode and delegation registers, but respect individual enables */ return (env->mip & env->mie) != 0; -#else -return true; -#endif } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ void restore_state_to_opc (CPURISCVState *env,TranslationBlock *tb,target_ulong *data)
@@ -647,6 +645,7 @@ static const struct TCGCPUOps riscv_tcg_ops = { .tlb_fill = riscv_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = riscv_cpu_has_work, .cpu_exec_interrupt = riscv_cpu_exec_interrupt, .do_interrupt = riscv_cpu_do_interrupt, .do_transaction_failed = riscv_cpu_do_transaction_failed,
@@ -666,7 +665,6 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data)device_class_set_parent_reset (dc, riscv_cpu_reset, &mcc->parent_reset); cc->class_by_name = riscv_cpu_class_by_name; - cc->has_work = riscv_cpu_has_work; cc->dump_state = riscv_cpu_dump_state; cc->set_pc = riscv_cpu_set_pc; cc->gdb_read_register = riscv_cpu_gdb_read_register;
Signature · 1 line
2.31.1
Re: [PATCH v5 23/31] target/riscv: Restrict has_work() handler to sysemu and TCG
Quoted 5 lines · Philippe Mathieu-Daudé
Restrict
has_work()to TCG sysemu.Reviewed-by Richard Henderson <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>
Alistair
Quoted 51 lines
--- target/riscv/cpu.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)target/riscv/cpu.c +3
-6@@ -335,9 +335,9 @@ static void riscv_cpu_synchronize_from_tb(CPUState *cs, env->pc = tb->pc; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool riscv_cpu_has_work (CPUState *cs) { -#ifndef CONFIG_USER_ONLY RISCVCPU *cpu =RISCV_CPU (cs);CPURISCVState *env = &cpu->env;/* @@ -345,10 +345,8 @@ static bool riscv_cpu_has_work(CPUState *cs)* mode and delegation registers, but respect individual enables */ return (env->mip & env->mie) != 0; -#else -return true; -#endif } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ void restore_state_to_opc (CPURISCVState *env,TranslationBlock *tb,target_ulong *data)@@ -647,6 +645,7 @@ static const struct TCGCPUOps riscv_tcg_ops = { .tlb_fill = riscv_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = riscv_cpu_has_work, .cpu_exec_interrupt = riscv_cpu_exec_interrupt, .do_interrupt = riscv_cpu_do_interrupt, .do_transaction_failed = riscv_cpu_do_transaction_failed,@@ -666,7 +665,6 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data)device_class_set_parent_reset (dc, riscv_cpu_reset, &mcc->parent_reset); cc->class_by_name = riscv_cpu_class_by_name; - cc->has_work = riscv_cpu_has_work; cc->dump_state = riscv_cpu_dump_state; cc->set_pc = riscv_cpu_set_pc; cc->gdb_read_register = riscv_cpu_gdb_read_register; --2.31.1
PATCH v5 24/31 target/rx: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/rx/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/rx/cpu.c +3 -1
@@ -41,11 +41,13 @@ static void rx_cpu_synchronize_from_tb(CPUState *cs, cpu->env.pc = tb->pc; } +#if !defined(CONFIG_USER_ONLY )static bool rx_cpu_has_work (CPUState *cs) {return cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_FIR ); } +#endif /* !CONFIG_USER_ONLY */ static void rx_cpu_reset (DeviceState *dev) {
@@ -189,6 +191,7 @@ static const struct TCGCPUOps rx_tcg_ops = { .tlb_fill = rx_cpu_tlb_fill,#ifndef CONFIG_USER_ONLY + .has_work = rx_cpu_has_work, .cpu_exec_interrupt = rx_cpu_exec_interrupt, .do_interrupt = rx_cpu_do_interrupt,#endif /* !CONFIG_USER_ONLY */
@@ -206,7 +209,6 @@ static void rx_cpu_class_init(ObjectClass *klass, void *data) &rcc->parent_reset); cc->class_by_name = rx_cpu_class_by_name; - cc->has_work = rx_cpu_has_work; cc->dump_state = rx_cpu_dump_state; cc->set_pc = rx_cpu_set_pc;
Signature · 1 line
2.31.1
PATCH v5 25/31 target/s390x: Restrict has_work() handler to sysemu and TCG
In reply to Philippe Mathieu-DaudéRestrict has_work() to TCG sysemu.
--- target/s390x/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/s390x/cpu.c +3 -1
@@ -88,6 +88,7 @@ static void s390_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.psw.addr = value; } +#if defined(CONFIG_TCG ) && !defined(CONFIG_USER_ONLY )static bool s390_cpu_has_work (CPUState *cs) {S390CPU *cpu =S390_CPU (cs);
@@ -104,6 +105,7 @@ static bool s390_cpu_has_work(CPUState *cs) return s390_cpu_has_int(cpu); } +#endif /* CONFIG_TCG && !CONFIG_USER_ONLY */ /* S390CPUClass::reset() */ static void s390_cpu_reset (CPUState *s,cpu_reset_type type)
@@ -269,6 +271,7 @@ static const struct TCGCPUOps s390_tcg_ops = { .tlb_fill = s390_cpu_tlb_fill,#if !defined(CONFIG_USER_ONLY ) + .has_work = s390_cpu_has_work, .cpu_exec_interrupt = s390_cpu_exec_interrupt, .do_interrupt = s390_cpu_do_interrupt, .debug_excp_handler = s390x_cpu_debug_excp_handler,
@@ -292,7 +295,6 @@ static void s390_cpu_class_init(ObjectClass *oc, void *data) scc->reset = s390_cpu_reset; cc->class_by_name = s390_cpu_class_by_name, - cc->has_work = s390_cpu_has_work; cc->dump_state = s390_cpu_dump_state; cc->set_pc = s390_cpu_set_pc; cc->gdb_read_register = s390_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 26/31 target/sh4: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/sh4/cpu.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
target/sh4/cpu.c +3 -2
@@ -58,13 +58,14 @@ static bool superh_io_recompile_replay_branch(CPUState *cs, }return false; } -#endif static bool superh_cpu_has_work (CPUState *cs) {return cs->interrupt_request &CPU_INTERRUPT_HARD ; } +#endif /* !CONFIG_USER_ONLY */ +static void superh_cpu_reset (DeviceState *dev) {CPUState *s =CPU (dev);
@@ -239,6 +240,7 @@ static const struct TCGCPUOps superh_tcg_ops = { .tlb_fill = superh_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = superh_cpu_has_work, .cpu_exec_interrupt = superh_cpu_exec_interrupt, .do_interrupt = superh_cpu_do_interrupt, .do_unaligned_access = superh_cpu_do_unaligned_access,
@@ -258,7 +260,6 @@ static void superh_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, superh_cpu_reset, &scc->parent_reset); cc->class_by_name = superh_cpu_class_by_name; - cc->has_work = superh_cpu_has_work; cc->dump_state = superh_cpu_dump_state; cc->set_pc = superh_cpu_set_pc; cc->gdb_read_register = superh_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 27/31 target/sparc: Remove pointless use of CONFIG_TCG definition
In reply to Philippe Mathieu-DaudéThe SPARC target only support TCG acceleration. Remove the CONFIG_TCG definition introduced by mistake in commit 78271684719 ("cpu: tcg_ops:
move to tcg-cpu-ops.h, keep a pointer in CPUClass").
--- target/sparc/cpu.c | 2 -- 1 file changed, 2 deletions(-)
target/sparc/cpu.c +0 -2
@@ -859,7 +859,6 @@ static const struct SysemuCPUOps sparc_sysemu_ops = { };#endif -#ifdef CONFIG_TCG #include "hw/core/tcg-cpu-ops.h" static const struct TCGCPUOps sparc_tcg_ops = {
@@ -874,7 +873,6 @@ static const struct TCGCPUOps sparc_tcg_ops = { .do_unaligned_access = sparc_cpu_do_unaligned_access,#endif /* !CONFIG_USER_ONLY */ }; -#endif /* CONFIG_TCG */ static void sparc_cpu_class_init (ObjectClass *oc,void *data) {
Signature · 1 line
2.31.1
PATCH v5 28/31 target/sparc: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/sparc/cpu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
target/sparc/cpu.c +3 -1
@@ -702,6 +702,7 @@ static void sparc_cpu_synchronize_from_tb(CPUState *cs, cpu->env.npc = tb->cs_base; } +#if !defined(CONFIG_USER_ONLY )static bool sparc_cpu_has_work (CPUState *cs) {SPARCCPU *cpu =SPARC_CPU (cs);
@@ -710,6 +711,7 @@ static bool sparc_cpu_has_work(CPUState *cs)return (cs->interrupt_request &CPU_INTERRUPT_HARD ) && cpu_interrupts_enabled(env); } +#endif /* !CONFIG_USER_ONLY */ static char *sparc_cpu_type_name (const char *cpu_model) {
@@ -867,6 +869,7 @@ static const struct TCGCPUOps sparc_tcg_ops = { .tlb_fill = sparc_cpu_tlb_fill, #ifndef CONFIG_USER_ONLY + .has_work = sparc_cpu_has_work, .cpu_exec_interrupt = sparc_cpu_exec_interrupt, .do_interrupt = sparc_cpu_do_interrupt, .do_transaction_failed = sparc_cpu_do_transaction_failed,
@@ -888,7 +891,6 @@ 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->dump_state = sparc_cpu_dump_state;#if !defined(TARGET_SPARC64 ) && !defined(CONFIG_USER_ONLY ) cc->memory_rw_debug = sparc_cpu_memory_rw_debug;
Signature · 1 line
2.31.1
PATCH v5 29/31 target/tricore: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/tricore/cpu.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
target/tricore/cpu.c +5 -1
@@ -62,10 +62,12 @@ static void tricore_cpu_reset(DeviceState *dev)cpu_state_reset (env); } +#if !defined(CONFIG_USER_ONLY )static bool tricore_cpu_has_work (CPUState *cs) {return true; } +#endif /* !CONFIG_USER_ONLY */ static void tricore_cpu_realizefn (DeviceState *dev,Error **errp) {
@@ -154,6 +156,9 @@ static const struct TCGCPUOps tricore_tcg_ops = { .initialize = tricore_tcg_init, .synchronize_from_tb = tricore_cpu_synchronize_from_tb, .tlb_fill = tricore_cpu_tlb_fill, +#if !defined(CONFIG_USER_ONLY ) + .has_work = tricore_cpu_has_work, +#endif };static void tricore_cpu_class_init (ObjectClass *c,void *data)
@@ -167,7 +172,6 @@ static void tricore_cpu_class_init(ObjectClass *c, void *data)device_class_set_parent_reset (dc, tricore_cpu_reset, &mcc->parent_reset); cc->class_by_name = tricore_cpu_class_by_name; - cc->has_work = tricore_cpu_has_work; cc->gdb_read_register = tricore_cpu_gdb_read_register; cc->gdb_write_register = tricore_cpu_gdb_write_register;
Signature · 1 line
2.31.1
PATCH v5 30/31 target/xtensa: Restrict has_work() handler to sysemu
In reply to Philippe Mathieu-DaudéRestrict has_work() to sysemu.
--- target/xtensa/cpu.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
target/xtensa/cpu.c +7 -7
@@ -43,18 +43,17 @@ static void xtensa_cpu_set_pc(CPUState *cs, vaddr value) cpu->env.pc = value; } +#ifndef CONFIG_USER_ONLY +static bool xtensa_cpu_has_work (CPUState *cs) { -#ifndef CONFIG_USER_ONLY XtensaCPU *cpu =XTENSA_CPU (cs);return !cpu->env.runstall && cpu->env.pending_irq_level; -#else -return true; -#endif } -#ifdef CONFIG_USER_ONLY +#else /* CONFIG_USER_ONLY*/ +static bool abi_call0;void xtensa_set_abi_call0 (void )
@@ -66,7 +65,8 @@ bool xtensa_abi_call0(void) {return abi_call0; } -#endif + +#endif /* CONFIG_USER_ONLY */ static void xtensa_cpu_reset (DeviceState *dev) {
@@ -196,6 +196,7 @@ static const struct TCGCPUOps xtensa_tcg_ops = { .debug_excp_handler = xtensa_breakpoint_handler, #ifndef CONFIG_USER_ONLY + .has_work = xtensa_cpu_has_work, .cpu_exec_interrupt = xtensa_cpu_exec_interrupt, .do_interrupt = xtensa_cpu_do_interrupt, .do_transaction_failed = xtensa_cpu_do_transaction_failed,
@@ -215,7 +216,6 @@ static void xtensa_cpu_class_init(ObjectClass *oc, void *data)device_class_set_parent_reset (dc, xtensa_cpu_reset, &xcc->parent_reset); cc->class_by_name = xtensa_cpu_class_by_name; - cc->has_work = xtensa_cpu_has_work; cc->dump_state = xtensa_cpu_dump_state; cc->set_pc = xtensa_cpu_set_pc; cc->gdb_read_register = xtensa_cpu_gdb_read_register;
Signature · 1 line
2.31.1
PATCH v5 31/31 accel: Add missing AccelOpsClass::has_work() and drop SysemuCPUOps one
In reply to Philippe Mathieu-Daudécpu_common_has_work() is the default has_work() implementation and returns 'false'.
Explicit it for the QTest / HAX / HVF / NVMM / Xen accelerators and remove cpu_common_has_work().
Since there are no more implementations of SysemuCPUOps::has_work, remove it along with the assertion in cpu_has_work().
--- include/hw/core/cpu.h | 2 -- accel/hvf/hvf-accel-ops.c | 6 ++++++ accel/qtest/qtest.c | 6 ++++++ accel/xen/xen-all.c | 6 ++++++ hw/core/cpu-common.c | 6 ------ softmmu/cpus.c | 11 ++--------- target/i386/hax/hax-accel-ops.c | 6 ++++++ target/i386/nvmm/nvmm-accel-ops.c | 6 ++++++ 8 files changed, 32 insertions(+), 17 deletions(-)
include/hw/core/cpu.h +0 -2
@@ -89,7 +89,6 @@ struct SysemuCPUOps;* instantiatable CPU type. * @parse_features: Callback to parse command line arguments. * @reset_dump_flags: #CPUDumpFlags to use for reset logging. -* @has_work: Callback for checking if there is work to do. * @memory_rw_debug: Callback for GDB memory access. * @dump_state: Callback for dumping state. * @get_arch_id: Callback for getting architecture-dependent CPU ID.
@@ -132,7 +131,6 @@ struct CPUClass {void (*parse_features)(const char *typename,char *str,Error **errp);int reset_dump_flags; -bool (*has_work)(CPUState *cpu);int (*memory_rw_debug)(CPUState *cpu,vaddr addr,uint8_t *buf,int len,bool is_write);void (*dump_state)(CPUState *cpu,FILE *,int flags);
accel/hvf/hvf-accel-ops.c +6 -0
@@ -446,6 +446,11 @@ static void hvf_start_vcpu_thread(CPUState *cpu) cpu, QEMU_THREAD_JOINABLE); } +static bool hvf_cpu_has_work (CPUState *cpu) +{ +return false; +} +static void hvf_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc);
@@ -456,6 +461,7 @@ static void hvf_accel_ops_class_init(ObjectClass *oc, void *data) ops->synchronize_post_init = hvf_cpu_synchronize_post_init; ops->synchronize_state = hvf_cpu_synchronize_state; ops->synchronize_pre_loadvm = hvf_cpu_synchronize_pre_loadvm; + ops->has_work = hvf_cpu_has_work; };static const TypeInfo hvf_accel_ops_type = { .name =ACCEL_OPS_NAME ("hvf" ),
accel/qtest/qtest.c +6 -0
@@ -47,12 +47,18 @@ static const TypeInfo qtest_accel_type = { };module_obj (TYPE_QTEST_ACCEL ); +static bool qtest_cpu_has_work (CPUState *cpu) +{ +return false; +} +static void qtest_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc); ops->create_vcpu_thread = dummy_start_vcpu_thread; ops->get_virtual_clock = qtest_get_virtual_clock; + ops->has_work = qtest_cpu_has_work; };static const TypeInfo qtest_accel_ops_type = {
accel/xen/xen-all.c +6 -0
@@ -215,11 +215,17 @@ static const TypeInfo xen_accel_type = { .class_init = xen_accel_class_init, }; +static bool xen_cpu_has_work (CPUState *cpu) +{ +return false; +} +static void xen_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc); ops->create_vcpu_thread = dummy_start_vcpu_thread; + ops->has_work = xen_cpu_has_work; }static const TypeInfo xen_accel_ops_type = {
hw/core/cpu-common.c +0 -6
@@ -143,11 +143,6 @@ static void cpu_common_reset(DeviceState *dev) } } -static bool cpu_common_has_work (CPUState *cs) -{ -return false; -} -ObjectClass *cpu_class_by_name (const char *typename,const char *cpu_model) {CPUClass *cc =CPU_CLASS (object_class_by_name (typename));
@@ -279,7 +274,6 @@ static void cpu_class_init(ObjectClass *klass, void *data) k->parse_features = cpu_common_parse_features; k->get_arch_id = cpu_common_get_arch_id; - k->has_work = cpu_common_has_work; k->gdb_read_register = cpu_common_gdb_read_register; k->gdb_write_register = cpu_common_gdb_write_register;set_bit (DEVICE_CATEGORY_CPU , dc->categories);
softmmu/cpus.c +2 -9
@@ -251,15 +251,8 @@ void cpu_interrupt(CPUState *cpu, int mask)bool cpu_has_work (CPUState *cpu) { -CPUClass *cc =CPU_GET_CLASS (cpu); - -if (cc->has_work) { -return cc->has_work (cpu); - } -if (cpus_accel->has_work) { -return cpus_accel->has_work (cpu); - } -g_assert_not_reached (); +g_assert (cpus_accel->has_work); +return cpus_accel->has_work (cpu); }static int do_vm_stop (RunState state,bool send_stop)
target/i386/hax/hax-accel-ops.c +6 -0
@@ -74,6 +74,11 @@ static void hax_start_vcpu_thread(CPUState *cpu)#endif } +static bool hax_cpu_has_work (CPUState *cpu) +{ +return false; +} +static void hax_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc);
@@ -85,6 +90,7 @@ static void hax_accel_ops_class_init(ObjectClass *oc, void *data) ops->synchronize_post_init = hax_cpu_synchronize_post_init; ops->synchronize_state = hax_cpu_synchronize_state; ops->synchronize_pre_loadvm = hax_cpu_synchronize_pre_loadvm; + ops->has_work = hax_cpu_has_work; }static const TypeInfo hax_accel_ops_type = {
target/i386/nvmm/nvmm-accel-ops.c +6 -0
@@ -83,6 +83,11 @@ static void nvmm_kick_vcpu_thread(CPUState *cpu)cpus_kick_thread (cpu); } +static bool nvmm_cpu_has_work (CPUState *cpu) +{ +return false; +} +static void nvmm_accel_ops_class_init (ObjectClass *oc,void *data) {AccelOpsClass *ops =ACCEL_OPS_CLASS (oc);
@@ -94,6 +99,7 @@ static void nvmm_accel_ops_class_init(ObjectClass *oc, void *data) ops->synchronize_post_init = nvmm_cpu_synchronize_post_init; ops->synchronize_state = nvmm_cpu_synchronize_state; ops->synchronize_pre_loadvm = nvmm_cpu_synchronize_pre_loadvm; + ops->has_work = nvmm_cpu_has_work; }static const TypeInfo nvmm_accel_ops_type = {
Signature · 1 line
2.31.1