On Thu, Jul 07, 2016 at 12:14:54AM +0300, Sergey Fedorov wrote:
> From: Alex Bennée <alex.bennee@xxxxxxxxxx>
>
> CPUState is a fairly common pointer to pass to these helpers. This means
> if you need other arguments for the async_run_on_cpu case you end up
> having to do a g_malloc to stuff additional data into the routine. For
> the current users this isn't a massive deal but for MTTCG this gets
> cumbersome when the only other parameter is often an address.
>
> This adds the typedef run_on_cpu_func for helper functions which has an
> explicit CPUState * passed as the first parameter. All the users of
> run_on_cpu and async_run_on_cpu have had their helpers updated to use
> CPUState where available.
>
> Signed-off-by: Alex Bennée <alex.bennee@xxxxxxxxxx>
> [Sergey Fedorov:
> - eliminate more CPUState in user data;
> - remove unnecessary user data passing;
> - fix target-s390x/kvm.c and target-s390x/misc_helper.c]
> Signed-off-by: Sergey Fedorov <sergey.fedorov@xxxxxxxxxx>
ppc parts:
Acked-by: David Gibson <david@xxxxxxxxxxxxxxxxxxxxx>
> ---
>
> Changes in v2:
> - eliminate more CPUState in user data
> - remove unnecessary user data passing
> - fix target-s390x/kvm.c and target-s390x/misc_helper.c
>
> ---
> cpus.c | 15 ++++---
> hw/i386/kvm/apic.c | 3 +-
> hw/i386/kvmvapic.c | 6 +--
> hw/ppc/ppce500_spin.c | 31 +++++----------
> hw/ppc/spapr.c | 6 +--
> hw/ppc/spapr_hcall.c | 17 ++++----
> include/qom/cpu.h | 8 ++--
> kvm-all.c | 21 ++++------
> target-i386/helper.c | 19 ++++-----
> target-i386/kvm.c | 6 +--
> target-s390x/cpu.c | 4 +-
> target-s390x/cpu.h | 7 +---
> target-s390x/kvm.c | 98 +++++++++++++++++++++++-----------------------
> target-s390x/misc_helper.c | 4 +-
> 14 files changed, 108 insertions(+), 137 deletions(-)
>
> diff --git a/cpus.c b/cpus.c
> index 84c3520d446f..049c2d04e150 100644
> --- a/cpus.c
> +++ b/cpus.c
> @@ -551,9 +551,8 @@ static const VMStateDescription vmstate_timers = {
> }
> };
>
> -static void cpu_throttle_thread(void *opaque)
> +static void cpu_throttle_thread(CPUState *cpu, void *opaque)
> {
> - CPUState *cpu = opaque;
> double pct;
> double throttle_ratio;
> long sleeptime_ns;
> @@ -583,7 +582,7 @@ static void cpu_throttle_timer_tick(void *opaque)
> }
> CPU_FOREACH(cpu) {
> if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
> - async_run_on_cpu(cpu, cpu_throttle_thread, cpu);
> + async_run_on_cpu(cpu, cpu_throttle_thread, NULL);
> }
> }
>
> @@ -911,12 +910,12 @@ void qemu_init_cpu_loop(void)
> qemu_thread_get_self(&io_thread);
> }
>
> -void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
> +void run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data)
> {
> struct qemu_work_item wi;
>
> if (qemu_cpu_is_self(cpu)) {
> - func(data);
> + func(cpu, data);
> return;
> }
>
> @@ -944,12 +943,12 @@ void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
> }
> }
>
> -void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
> +void async_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data)
> {
> struct qemu_work_item *wi;
>
> if (qemu_cpu_is_self(cpu)) {
> - func(data);
> + func(cpu, data);
> return;
> }
>
> @@ -1000,7 +999,7 @@ static void flush_queued_work(CPUState *cpu)
> cpu->queued_work_last = NULL;
> }
> qemu_mutex_unlock(&cpu->work_mutex);
> - wi->func(wi->data);
> + wi->func(cpu, wi->data);
> qemu_mutex_lock(&cpu->work_mutex);
> if (wi->free) {
> g_free(wi);
> diff --git a/hw/i386/kvm/apic.c b/hw/i386/kvm/apic.c
> index c5983c79be47..9b66e741d4b4 100644
> --- a/hw/i386/kvm/apic.c
> +++ b/hw/i386/kvm/apic.c
> @@ -125,10 +125,9 @@ static void kvm_apic_vapic_base_update(APICCommonState *s)
> }
> }
>
> -static void do_inject_external_nmi(void *data)
> +static void do_inject_external_nmi(CPUState *cpu, void *data)
> {
> APICCommonState *s = data;
> - CPUState *cpu = CPU(s->cpu);
> uint32_t lvt;
> int ret;
>
> diff --git a/hw/i386/kvmvapic.c b/hw/i386/kvmvapic.c
> index 3bf1ddd97612..1bc02fb2f1a1 100644
> --- a/hw/i386/kvmvapic.c
> +++ b/hw/i386/kvmvapic.c
> @@ -483,7 +483,7 @@ typedef struct VAPICEnableTPRReporting {
> bool enable;
> } VAPICEnableTPRReporting;
>
> -static void vapic_do_enable_tpr_reporting(void *data)
> +static void vapic_do_enable_tpr_reporting(CPUState *cpu, void *data)
> {
> VAPICEnableTPRReporting *info = data;
>
> @@ -734,10 +734,10 @@ static void vapic_realize(DeviceState *dev, Error **errp)
> nb_option_roms++;
> }
>
> -static void do_vapic_enable(void *data)
> +static void do_vapic_enable(CPUState *cs, void *data)
> {
> VAPICROMState *s = data;
> - X86CPU *cpu = X86_CPU(first_cpu);
> + X86CPU *cpu = X86_CPU(cs);
>
> static const uint8_t enabled = 1;
> cpu_physical_memory_write(s->vapic_paddr + offsetof(VAPICState, enabled),
> diff --git a/hw/ppc/ppce500_spin.c b/hw/ppc/ppce500_spin.c
> index 22c584eb8dd0..8e16f651ea95 100644
> --- a/hw/ppc/ppce500_spin.c
> +++ b/hw/ppc/ppce500_spin.c
> @@ -54,11 +54,6 @@ typedef struct SpinState {
> SpinInfo spin[MAX_CPUS];
> } SpinState;
>
> -typedef struct spin_kick {
> - PowerPCCPU *cpu;
> - SpinInfo *spin;
> -} SpinKick;
> -
> static void spin_reset(void *opaque)
> {
> SpinState *s = opaque;
> @@ -89,16 +84,15 @@ static void mmubooke_create_initial_mapping(CPUPPCState *env,
> env->tlb_dirty = true;
> }
>
> -static void spin_kick(void *data)
> +static void spin_kick(CPUState *cs, void *data)
> {
> - SpinKick *kick = data;
> - CPUState *cpu = CPU(kick->cpu);
> - CPUPPCState *env = &kick->cpu->env;
> - SpinInfo *curspin = kick->spin;
> + PowerPCCPU *cpu = POWERPC_CPU(cs);
> + CPUPPCState *env = &cpu->env;
> + SpinInfo *curspin = data;
> hwaddr map_size = 64 * 1024 * 1024;
> hwaddr map_start;
>
> - cpu_synchronize_state(cpu);
> + cpu_synchronize_state(cs);
> stl_p(&curspin->pir, env->spr[SPR_BOOKE_PIR]);
> env->nip = ldq_p(&curspin->addr) & (map_size - 1);
> env->gpr[3] = ldq_p(&curspin->r3);
> @@ -112,10 +106,10 @@ static void spin_kick(void *data)
> map_start = ldq_p(&curspin->addr) & ~(map_size - 1);
> mmubooke_create_initial_mapping(env, 0, map_start, map_size);
>
> - cpu->halted = 0;
> - cpu->exception_index = -1;
> - cpu->stopped = false;
> - qemu_cpu_kick(cpu);
> + cs->halted = 0;
> + cs->exception_index = -1;
> + cs->stopped = false;
> + qemu_cpu_kick(cs);
> }
>
> static void spin_write(void *opaque, hwaddr addr, uint64_t value,
> @@ -153,12 +147,7 @@ static void spin_write(void *opaque, hwaddr addr, uint64_t value,
>
> if (!(ldq_p(&curspin->addr) & 1)) {
> /* run CPU */
> - SpinKick kick = {
> - .cpu = POWERPC_CPU(cpu),
> - .spin = curspin,
> - };
> -
> - run_on_cpu(cpu, spin_kick, &kick);
> + run_on_cpu(cpu, spin_kick, curspin);
> }
> }
>
> diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
> index 7f33a1b2b57d..882a3c621367 100644
> --- a/hw/ppc/spapr.c
> +++ b/hw/ppc/spapr.c
> @@ -2170,10 +2170,8 @@ static void spapr_machine_finalizefn(Object *obj)
> g_free(spapr->kvm_type);
> }
>
> -static void ppc_cpu_do_nmi_on_cpu(void *arg)
> +static void ppc_cpu_do_nmi_on_cpu(CPUState *cs, void *arg)
> {
> - CPUState *cs = arg;
> -
> cpu_synchronize_state(cs);
> ppc_cpu_do_system_reset(cs);
> }
> @@ -2183,7 +2181,7 @@ static void spapr_nmi(NMIState *n, int cpu_index, Error **errp)
> CPUState *cs;
>
> CPU_FOREACH(cs) {
> - async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs);
> + async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, NULL);
> }
> }
>
> diff --git a/hw/ppc/spapr_hcall.c b/hw/ppc/spapr_hcall.c
> index 73af112e1d36..e5eca67f5b71 100644
> --- a/hw/ppc/spapr_hcall.c
> +++ b/hw/ppc/spapr_hcall.c
> @@ -13,19 +13,18 @@
> #include "kvm_ppc.h"
>
> struct SPRSyncState {
> - CPUState *cs;
> int spr;
> target_ulong value;
> target_ulong mask;
> };
>
> -static void do_spr_sync(void *arg)
> +static void do_spr_sync(CPUState *cs, void *arg)
> {
> struct SPRSyncState *s = arg;
> - PowerPCCPU *cpu = POWERPC_CPU(s->cs);
> + PowerPCCPU *cpu = POWERPC_CPU(cs);
> CPUPPCState *env = &cpu->env;
>
> - cpu_synchronize_state(s->cs);
> + cpu_synchronize_state(cs);
> env->spr[s->spr] &= ~s->mask;
> env->spr[s->spr] |= s->value;
> }
> @@ -34,7 +33,6 @@ static void set_spr(CPUState *cs, int spr, target_ulong value,
> target_ulong mask)
> {
> struct SPRSyncState s = {
> - .cs = cs,
> .spr = spr,
> .value = value,
> .mask = mask
> @@ -907,17 +905,17 @@ static target_ulong cas_get_option_vector(int vector, target_ulong table)
> }
>
> typedef struct {
> - PowerPCCPU *cpu;
> uint32_t cpu_version;
> Error *err;
> } SetCompatState;
>
> -static void do_set_compat(void *arg)
> +static void do_set_compat(CPUState *cs, void *arg)
> {
> + PowerPCCPU *cpu = POWERPC_CPU(cs);
> SetCompatState *s = arg;
>
> - cpu_synchronize_state(CPU(s->cpu));
> - ppc_set_compat(s->cpu, s->cpu_version, &s->err);
> + cpu_synchronize_state(cs);
> + ppc_set_compat(cpu, s->cpu_version, &s->err);
> }
>
> #define get_compat_level(cpuver) ( \
> @@ -1013,7 +1011,6 @@ static target_ulong h_client_architecture_support(PowerPCCPU *cpu_,
> if (old_cpu_version != cpu_version) {
> CPU_FOREACH(cs) {
> SetCompatState s = {
> - .cpu = POWERPC_CPU(cs),
> .cpu_version = cpu_version,
> .err = NULL,
> };
> diff --git a/include/qom/cpu.h b/include/qom/cpu.h
> index 32f3af3e1c63..4e688f645b4a 100644
> --- a/include/qom/cpu.h
> +++ b/include/qom/cpu.h
> @@ -223,9 +223,11 @@ struct kvm_run;
> #define TB_JMP_CACHE_SIZE (1 << TB_JMP_CACHE_BITS)
>
> /* work queue */
> +typedef void (*run_on_cpu_func)(CPUState *cpu, void *data);
> +
> struct qemu_work_item {
> struct qemu_work_item *next;
> - void (*func)(void *data);
> + run_on_cpu_func func;
> void *data;
> int done;
> bool free;
> @@ -610,7 +612,7 @@ bool cpu_is_stopped(CPUState *cpu);
> *
> * Schedules the function @func for execution on the vCPU @cpu.
> */
> -void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data);
> +void run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data);
>
> /**
> * async_run_on_cpu:
> @@ -620,7 +622,7 @@ void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data);
> *
> * Schedules the function @func for execution on the vCPU @cpu asynchronously.
> */
> -void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data);
> +void async_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data);
>
> /**
> * qemu_get_cpu:
> diff --git a/kvm-all.c b/kvm-all.c
> index a88f917fda69..a8320574cc8a 100644
> --- a/kvm-all.c
> +++ b/kvm-all.c
> @@ -1828,10 +1828,8 @@ void kvm_flush_coalesced_mmio_buffer(void)
> s->coalesced_flush_in_progress = false;
> }
>
> -static void do_kvm_cpu_synchronize_state(void *arg)
> +static void do_kvm_cpu_synchronize_state(CPUState *cpu, void *arg)
> {
> - CPUState *cpu = arg;
> -
> if (!cpu->kvm_vcpu_dirty) {
> kvm_arch_get_registers(cpu);
> cpu->kvm_vcpu_dirty = true;
> @@ -1841,34 +1839,30 @@ static void do_kvm_cpu_synchronize_state(void *arg)
> void kvm_cpu_synchronize_state(CPUState *cpu)
> {
> if (!cpu->kvm_vcpu_dirty) {
> - run_on_cpu(cpu, do_kvm_cpu_synchronize_state, cpu);
> + run_on_cpu(cpu, do_kvm_cpu_synchronize_state, NULL);
> }
> }
>
> -static void do_kvm_cpu_synchronize_post_reset(void *arg)
> +static void do_kvm_cpu_synchronize_post_reset(CPUState *cpu, void *arg)
> {
> - CPUState *cpu = arg;
> -
> kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
> cpu->kvm_vcpu_dirty = false;
> }
>
> void kvm_cpu_synchronize_post_reset(CPUState *cpu)
> {
> - run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, cpu);
> + run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, NULL);
> }
>
> -static void do_kvm_cpu_synchronize_post_init(void *arg)
> +static void do_kvm_cpu_synchronize_post_init(CPUState *cpu, void *arg)
> {
> - CPUState *cpu = arg;
> -
> kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
> cpu->kvm_vcpu_dirty = false;
> }
>
> void kvm_cpu_synchronize_post_init(CPUState *cpu)
> {
> - run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, cpu);
> + run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, NULL);
> }
>
> int kvm_cpu_exec(CPUState *cpu)
> @@ -2210,7 +2204,7 @@ struct kvm_set_guest_debug_data {
> int err;
> };
>
> -static void kvm_invoke_set_guest_debug(void *data)
> +static void kvm_invoke_set_guest_debug(CPUState *unused_cpu, void *data)
> {
> struct kvm_set_guest_debug_data *dbg_data = data;
>
> @@ -2228,7 +2222,6 @@ int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
> data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
> }
> kvm_arch_update_guest_debug(cpu, &data.dbg);
> - data.cpu = cpu;
>
> run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data);
> return data.err;
> diff --git a/target-i386/helper.c b/target-i386/helper.c
> index 1c250b82452d..9bc961bff342 100644
> --- a/target-i386/helper.c
> +++ b/target-i386/helper.c
> @@ -1113,7 +1113,6 @@ out:
>
> typedef struct MCEInjectionParams {
> Monitor *mon;
> - X86CPU *cpu;
> int bank;
> uint64_t status;
> uint64_t mcg_status;
> @@ -1122,14 +1121,14 @@ typedef struct MCEInjectionParams {
> int flags;
> } MCEInjectionParams;
>
> -static void do_inject_x86_mce(void *data)
> +static void do_inject_x86_mce(CPUState *cs, void *data)
> {
> MCEInjectionParams *params = data;
> - CPUX86State *cenv = ¶ms->cpu->env;
> - CPUState *cpu = CPU(params->cpu);
> + X86CPU *cpu = X86_CPU(cs);
> + CPUX86State *cenv = &cpu->env;
> uint64_t *banks = cenv->mce_banks + 4 * params->bank;
>
> - cpu_synchronize_state(cpu);
> + cpu_synchronize_state(cs);
>
> /*
> * If there is an MCE exception being processed, ignore this SRAO MCE
> @@ -1149,7 +1148,7 @@ static void do_inject_x86_mce(void *data)
> if ((cenv->mcg_cap & MCG_CTL_P) && cenv->mcg_ctl != ~(uint64_t)0) {
> monitor_printf(params->mon,
> "CPU %d: Uncorrected error reporting disabled\n",
> - cpu->cpu_index);
> + cs->cpu_index);
> return;
> }
>
> @@ -1161,7 +1160,7 @@ static void do_inject_x86_mce(void *data)
> monitor_printf(params->mon,
> "CPU %d: Uncorrected error reporting disabled for"
> " bank %d\n",
> - cpu->cpu_index, params->bank);
> + cs->cpu_index, params->bank);
> return;
> }
>
> @@ -1170,7 +1169,7 @@ static void do_inject_x86_mce(void *data)
> monitor_printf(params->mon,
> "CPU %d: Previous MCE still in progress, raising"
> " triple fault\n",
> - cpu->cpu_index);
> + cs->cpu_index);
> qemu_log_mask(CPU_LOG_RESET, "Triple fault\n");
> qemu_system_reset_request();
> return;
> @@ -1182,7 +1181,7 @@ static void do_inject_x86_mce(void *data)
> banks[3] = params->misc;
> cenv->mcg_status = params->mcg_status;
> banks[1] = params->status;
> - cpu_interrupt(cpu, CPU_INTERRUPT_MCE);
> + cpu_interrupt(cs, CPU_INTERRUPT_MCE);
> } else if (!(banks[1] & MCI_STATUS_VAL)
> || !(banks[1] & MCI_STATUS_UC)) {
> if (banks[1] & MCI_STATUS_VAL) {
> @@ -1204,7 +1203,6 @@ void cpu_x86_inject_mce(Monitor *mon, X86CPU *cpu, int bank,
> CPUX86State *cenv = &cpu->env;
> MCEInjectionParams params = {
> .mon = mon,
> - .cpu = cpu,
> .bank = bank,
> .status = status,
> .mcg_status = mcg_status,
> @@ -1245,7 +1243,6 @@ void cpu_x86_inject_mce(Monitor *mon, X86CPU *cpu, int bank,
> if (other_cs == cs) {
> continue;
> }
> - params.cpu = X86_CPU(other_cs);
> run_on_cpu(other_cs, do_inject_x86_mce, ¶ms);
> }
> }
> diff --git a/target-i386/kvm.c b/target-i386/kvm.c
> index f3698f19b53b..a1c6e656d13c 100644
> --- a/target-i386/kvm.c
> +++ b/target-i386/kvm.c
> @@ -151,10 +151,8 @@ static int kvm_get_tsc(CPUState *cs)
> return 0;
> }
>
> -static inline void do_kvm_synchronize_tsc(void *arg)
> +static inline void do_kvm_synchronize_tsc(CPUState *cpu, void *arg)
> {
> - CPUState *cpu = arg;
> -
> kvm_get_tsc(cpu);
> }
>
> @@ -164,7 +162,7 @@ void kvm_synchronize_all_tsc(void)
>
> if (kvm_enabled()) {
> CPU_FOREACH(cpu) {
> - run_on_cpu(cpu, do_kvm_synchronize_tsc, cpu);
> + run_on_cpu(cpu, do_kvm_synchronize_tsc, NULL);
> }
> }
> }
> diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c
> index e43e2d61550b..4f09c647b7a8 100644
> --- a/target-s390x/cpu.c
> +++ b/target-s390x/cpu.c
> @@ -188,7 +188,7 @@ static void s390_cpu_machine_reset_cb(void *opaque)
> {
> S390CPU *cpu = opaque;
>
> - run_on_cpu(CPU(cpu), s390_do_cpu_full_reset, CPU(cpu));
> + run_on_cpu(CPU(cpu), s390_do_cpu_full_reset, NULL);
> }
> #endif
>
> @@ -238,7 +238,7 @@ static void s390_cpu_realizefn(DeviceState *dev, Error **errp)
> s390_cpu_gdb_init(cs);
> qemu_init_vcpu(cs);
> #if !defined(CONFIG_USER_ONLY)
> - run_on_cpu(cs, s390_do_cpu_full_reset, cs);
> + run_on_cpu(cs, s390_do_cpu_full_reset, NULL);
> #else
> cpu_reset(cs);
> #endif
> diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
> index 8bcb0f75f399..8998ce21ca13 100644
> --- a/target-s390x/cpu.h
> +++ b/target-s390x/cpu.h
> @@ -498,17 +498,14 @@ static inline hwaddr decode_basedisp_s(CPUS390XState *env, uint32_t ipb,
> #define decode_basedisp_rs decode_basedisp_s
>
> /* helper functions for run_on_cpu() */
> -static inline void s390_do_cpu_reset(void *arg)
> +static inline void s390_do_cpu_reset(CPUState *cs, void *arg)
> {
> - CPUState *cs = arg;
> S390CPUClass *scc = S390_CPU_GET_CLASS(cs);
>
> scc->cpu_reset(cs);
> }
> -static inline void s390_do_cpu_full_reset(void *arg)
> +static inline void s390_do_cpu_full_reset(CPUState *cs, void *arg)
> {
> - CPUState *cs = arg;
> -
> cpu_reset(cs);
> }
>
> diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
> index 45e94ca48abd..b37eb9d3cd8c 100644
> --- a/target-s390x/kvm.c
> +++ b/target-s390x/kvm.c
> @@ -1354,7 +1354,6 @@ static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
> }
>
> typedef struct SigpInfo {
> - S390CPU *cpu;
> uint64_t param;
> int cc;
> uint64_t *status_reg;
> @@ -1367,38 +1366,40 @@ static void set_sigp_status(SigpInfo *si, uint64_t status)
> si->cc = SIGP_CC_STATUS_STORED;
> }
>
> -static void sigp_start(void *arg)
> +static void sigp_start(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
>
> - if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPPED) {
> + if (s390_cpu_get_state(cpu) != CPU_STATE_STOPPED) {
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> return;
> }
>
> - s390_cpu_set_state(CPU_STATE_OPERATING, si->cpu);
> + s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_stop(void *arg)
> +static void sigp_stop(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
> struct kvm_s390_irq irq = {
> .type = KVM_S390_SIGP_STOP,
> };
>
> - if (s390_cpu_get_state(si->cpu) != CPU_STATE_OPERATING) {
> + if (s390_cpu_get_state(cpu) != CPU_STATE_OPERATING) {
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> return;
> }
>
> /* disabled wait - sleeping in user space */
> - if (CPU(si->cpu)->halted) {
> - s390_cpu_set_state(CPU_STATE_STOPPED, si->cpu);
> + if (cs->halted) {
> + s390_cpu_set_state(CPU_STATE_STOPPED, cpu);
> } else {
> /* execute the stop function */
> - si->cpu->env.sigp_order = SIGP_STOP;
> - kvm_s390_vcpu_interrupt(si->cpu, &irq);
> + cpu->env.sigp_order = SIGP_STOP;
> + kvm_s390_vcpu_interrupt(cpu, &irq);
> }
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
> @@ -1465,56 +1466,58 @@ static int kvm_s390_store_status(S390CPU *cpu, hwaddr addr, bool store_arch)
> return 0;
> }
>
> -static void sigp_stop_and_store_status(void *arg)
> +static void sigp_stop_and_store_status(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
> struct kvm_s390_irq irq = {
> .type = KVM_S390_SIGP_STOP,
> };
>
> /* disabled wait - sleeping in user space */
> - if (s390_cpu_get_state(si->cpu) == CPU_STATE_OPERATING &&
> - CPU(si->cpu)->halted) {
> - s390_cpu_set_state(CPU_STATE_STOPPED, si->cpu);
> + if (s390_cpu_get_state(cpu) == CPU_STATE_OPERATING && cs->halted) {
> + s390_cpu_set_state(CPU_STATE_STOPPED, cpu);
> }
>
> - switch (s390_cpu_get_state(si->cpu)) {
> + switch (s390_cpu_get_state(cpu)) {
> case CPU_STATE_OPERATING:
> - si->cpu->env.sigp_order = SIGP_STOP_STORE_STATUS;
> - kvm_s390_vcpu_interrupt(si->cpu, &irq);
> + cpu->env.sigp_order = SIGP_STOP_STORE_STATUS;
> + kvm_s390_vcpu_interrupt(cpu, &irq);
> /* store will be performed when handling the stop intercept */
> break;
> case CPU_STATE_STOPPED:
> /* already stopped, just store the status */
> - cpu_synchronize_state(CPU(si->cpu));
> - kvm_s390_store_status(si->cpu, KVM_S390_STORE_STATUS_DEF_ADDR, true);
> + cpu_synchronize_state(cs);
> + kvm_s390_store_status(cpu, KVM_S390_STORE_STATUS_DEF_ADDR, true);
> break;
> }
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_store_status_at_address(void *arg)
> +static void sigp_store_status_at_address(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
> uint32_t address = si->param & 0x7ffffe00u;
>
> /* cpu has to be stopped */
> - if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPPED) {
> + if (s390_cpu_get_state(cpu) != CPU_STATE_STOPPED) {
> set_sigp_status(si, SIGP_STAT_INCORRECT_STATE);
> return;
> }
>
> - cpu_synchronize_state(CPU(si->cpu));
> + cpu_synchronize_state(cs);
>
> - if (kvm_s390_store_status(si->cpu, address, false)) {
> + if (kvm_s390_store_status(cpu, address, false)) {
> set_sigp_status(si, SIGP_STAT_INVALID_PARAMETER);
> return;
> }
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_store_adtl_status(void *arg)
> +static void sigp_store_adtl_status(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
>
> if (!kvm_check_extension(kvm_state, KVM_CAP_S390_VECTOR_REGISTERS)) {
> @@ -1523,7 +1526,7 @@ static void sigp_store_adtl_status(void *arg)
> }
>
> /* cpu has to be stopped */
> - if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPPED) {
> + if (s390_cpu_get_state(cpu) != CPU_STATE_STOPPED) {
> set_sigp_status(si, SIGP_STAT_INCORRECT_STATE);
> return;
> }
> @@ -1534,31 +1537,32 @@ static void sigp_store_adtl_status(void *arg)
> return;
> }
>
> - cpu_synchronize_state(CPU(si->cpu));
> + cpu_synchronize_state(cs);
>
> - if (kvm_s390_store_adtl_status(si->cpu, si->param)) {
> + if (kvm_s390_store_adtl_status(cpu, si->param)) {
> set_sigp_status(si, SIGP_STAT_INVALID_PARAMETER);
> return;
> }
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_restart(void *arg)
> +static void sigp_restart(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
> struct kvm_s390_irq irq = {
> .type = KVM_S390_RESTART,
> };
>
> - switch (s390_cpu_get_state(si->cpu)) {
> + switch (s390_cpu_get_state(cpu)) {
> case CPU_STATE_STOPPED:
> /* the restart irq has to be delivered prior to any other pending irq */
> - cpu_synchronize_state(CPU(si->cpu));
> - do_restart_interrupt(&si->cpu->env);
> - s390_cpu_set_state(CPU_STATE_OPERATING, si->cpu);
> + cpu_synchronize_state(cs);
> + do_restart_interrupt(&cpu->env);
> + s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
> break;
> case CPU_STATE_OPERATING:
> - kvm_s390_vcpu_interrupt(si->cpu, &irq);
> + kvm_s390_vcpu_interrupt(cpu, &irq);
> break;
> }
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> @@ -1566,20 +1570,18 @@ static void sigp_restart(void *arg)
>
> int kvm_s390_cpu_restart(S390CPU *cpu)
> {
> - SigpInfo si = {
> - .cpu = cpu,
> - };
> + SigpInfo si = {};
>
> run_on_cpu(CPU(cpu), sigp_restart, &si);
> DPRINTF("DONE: KVM cpu restart: %p\n", &cpu->env);
> return 0;
> }
>
> -static void sigp_initial_cpu_reset(void *arg)
> +static void sigp_initial_cpu_reset(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> + S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
> SigpInfo *si = arg;
> - CPUState *cs = CPU(si->cpu);
> - S390CPUClass *scc = S390_CPU_GET_CLASS(si->cpu);
>
> cpu_synchronize_state(cs);
> scc->initial_cpu_reset(cs);
> @@ -1587,11 +1589,11 @@ static void sigp_initial_cpu_reset(void *arg)
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_cpu_reset(void *arg)
> +static void sigp_cpu_reset(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> + S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
> SigpInfo *si = arg;
> - CPUState *cs = CPU(si->cpu);
> - S390CPUClass *scc = S390_CPU_GET_CLASS(si->cpu);
>
> cpu_synchronize_state(cs);
> scc->cpu_reset(cs);
> @@ -1599,12 +1601,13 @@ static void sigp_cpu_reset(void *arg)
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> -static void sigp_set_prefix(void *arg)
> +static void sigp_set_prefix(CPUState *cs, void *arg)
> {
> + S390CPU *cpu = S390_CPU(cs);
> SigpInfo *si = arg;
> uint32_t addr = si->param & 0x7fffe000u;
>
> - cpu_synchronize_state(CPU(si->cpu));
> + cpu_synchronize_state(cs);
>
> if (!address_space_access_valid(&address_space_memory, addr,
> sizeof(struct LowCore), false)) {
> @@ -1613,13 +1616,13 @@ static void sigp_set_prefix(void *arg)
> }
>
> /* cpu has to be stopped */
> - if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPPED) {
> + if (s390_cpu_get_state(cpu) != CPU_STATE_STOPPED) {
> set_sigp_status(si, SIGP_STAT_INCORRECT_STATE);
> return;
> }
>
> - si->cpu->env.psa = addr;
> - cpu_synchronize_post_init(CPU(si->cpu));
> + cpu->env.psa = addr;
> + cpu_synchronize_post_init(cs);
> si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;
> }
>
> @@ -1627,7 +1630,6 @@ static int handle_sigp_single_dst(S390CPU *dst_cpu, uint8_t order,
> uint64_t param, uint64_t *status_reg)
> {
> SigpInfo si = {
> - .cpu = dst_cpu,
> .param = param,
> .status_reg = status_reg,
> };
> diff --git a/target-s390x/misc_helper.c b/target-s390x/misc_helper.c
> index 86da1947b984..4df2ec6c7dab 100644
> --- a/target-s390x/misc_helper.c
> +++ b/target-s390x/misc_helper.c
> @@ -126,7 +126,7 @@ static int modified_clear_reset(S390CPU *cpu)
> pause_all_vcpus();
> cpu_synchronize_all_states();
> CPU_FOREACH(t) {
> - run_on_cpu(t, s390_do_cpu_full_reset, t);
> + run_on_cpu(t, s390_do_cpu_full_reset, NULL);
> }
> s390_cmma_reset();
> subsystem_reset();
> @@ -145,7 +145,7 @@ static int load_normal_reset(S390CPU *cpu)
> pause_all_vcpus();
> cpu_synchronize_all_states();
> CPU_FOREACH(t) {
> - run_on_cpu(t, s390_do_cpu_reset, t);
> + run_on_cpu(t, s390_do_cpu_reset, NULL);
> }
> s390_cmma_reset();
> subsystem_reset();
--
David Gibson | I'll have my music baroque, and my code
david AT gibson.dropbear.id.au | minimalist, thank you. NOT _the_ _other_
| _way_ _around_!
http://www.ozlabs.org/~dgibson
Attachment:
signature.asc
Description: PGP signature
