From patchwork Tue Oct 7 10:58:30 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cornelia Huck X-Patchwork-Id: 397223 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3128114009E for ; Tue, 7 Oct 2014 22:02:00 +1100 (EST) Received: from localhost ([::1]:57732 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XbSWk-0003mr-Cv for incoming@patchwork.ozlabs.org; Tue, 07 Oct 2014 07:01:58 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:51241) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XbSTr-0007lm-GC for qemu-devel@nongnu.org; Tue, 07 Oct 2014 06:59:07 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XbSTj-0007gz-FZ for qemu-devel@nongnu.org; Tue, 07 Oct 2014 06:58:59 -0400 Received: from e06smtp14.uk.ibm.com ([195.75.94.110]:36210) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XbSTj-0007gq-25 for qemu-devel@nongnu.org; Tue, 07 Oct 2014 06:58:51 -0400 Received: from /spool/local by e06smtp14.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Tue, 7 Oct 2014 11:58:50 +0100 Received: from d06dlp03.portsmouth.uk.ibm.com (9.149.20.15) by e06smtp14.uk.ibm.com (192.168.101.144) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Tue, 7 Oct 2014 11:58:47 +0100 Received: from b06cxnps3075.portsmouth.uk.ibm.com (d06relay10.portsmouth.uk.ibm.com [9.149.109.195]) by d06dlp03.portsmouth.uk.ibm.com (Postfix) with ESMTP id C36491B0805F for ; Tue, 7 Oct 2014 12:00:01 +0100 (BST) Received: from d06av05.portsmouth.uk.ibm.com (d06av05.portsmouth.uk.ibm.com [9.149.37.229]) by b06cxnps3075.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id s97Awkrk58064940 for ; Tue, 7 Oct 2014 10:58:46 GMT Received: from d06av05.portsmouth.uk.ibm.com (localhost [127.0.0.1]) by d06av05.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id s97Awko2020905 for ; Tue, 7 Oct 2014 04:58:46 -0600 Received: from gondolin.boeblingen.de.ibm.com (dyn-9-152-224-210.boeblingen.de.ibm.com [9.152.224.210]) by d06av05.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVin) with ESMTP id s97AwgZA020749; Tue, 7 Oct 2014 04:58:46 -0600 From: Cornelia Huck To: qemu-devel@nongnu.org Date: Tue, 7 Oct 2014 12:58:30 +0200 Message-Id: <1412679515-19330-4-git-send-email-cornelia.huck@de.ibm.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1412679515-19330-1-git-send-email-cornelia.huck@de.ibm.com> References: <1412679515-19330-1-git-send-email-cornelia.huck@de.ibm.com> X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 14100710-1948-0000-0000-0000015BFAB7 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 195.75.94.110 Cc: David Hildenbrand , agraf@suse.de, borntraeger@de.ibm.com, jfrei@linux.vnet.ibm.com, Cornelia Huck , Andreas Faerber Subject: [Qemu-devel] [PATCH 3/8] s390x/kvm: proper use of the cpu states OPERATING and STOPPED X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org From: David Hildenbrand This patch makes sure that halting a cpu and stopping a cpu are two different things. Stopping a cpu will also set the cpu halted - this is needed for common infrastructure to work (note that the stop and stopped flag cannot be used for our purpose because they are already used by other mechanisms). A cpu can be halted ("waiting") when it is operating. If interrupts are disabled, this is called a "disabled wait", as it can't be woken up anymore. A stopped cpu is treated like a "disabled wait" cpu, but in order to prepare for a proper cpu state synchronization with the kvm part, we need to track the real logical state of a cpu. Signed-off-by: David Hildenbrand Signed-off-by: Jens Freimann Reviewed-by: Cornelia Huck Reviewed-by: Christian Borntraeger CC: Andreas Faerber Signed-off-by: Cornelia Huck --- hw/s390x/ipl.c | 2 +- target-s390x/cpu.c | 78 +++++++++++++++++++++++++++++++------------------ target-s390x/cpu.h | 14 ++++++--- target-s390x/helper.c | 19 +++++------- target-s390x/kvm.c | 11 +++---- trace-events | 5 ++++ 6 files changed, 79 insertions(+), 50 deletions(-) diff --git a/hw/s390x/ipl.c b/hw/s390x/ipl.c index 4fa9cff..3b77c9a 100644 --- a/hw/s390x/ipl.c +++ b/hw/s390x/ipl.c @@ -176,7 +176,7 @@ static void s390_ipl_reset(DeviceState *dev) } } - s390_add_running_cpu(cpu); + s390_cpu_set_state(CPU_STATE_OPERATING, cpu); } static void s390_ipl_class_init(ObjectClass *klass, void *data) diff --git a/target-s390x/cpu.c b/target-s390x/cpu.c index 03cab74..dc89eb3 100644 --- a/target-s390x/cpu.c +++ b/target-s390x/cpu.c @@ -26,7 +26,9 @@ #include "cpu.h" #include "qemu-common.h" #include "qemu/timer.h" +#include "qemu/error-report.h" #include "hw/hw.h" +#include "trace.h" #ifndef CONFIG_USER_ONLY #include "sysemu/arch_init.h" #endif @@ -81,7 +83,7 @@ static void s390_cpu_load_normal(CPUState *s) S390CPU *cpu = S390_CPU(s); cpu->env.psw.addr = ldl_phys(s->as, 4) & PSW_MASK_ESA_ADDR; cpu->env.psw.mask = PSW_MASK_32 | PSW_MASK_64; - s390_add_running_cpu(cpu); + s390_cpu_set_state(CPU_STATE_OPERATING, cpu); } #endif @@ -93,11 +95,8 @@ static void s390_cpu_reset(CPUState *s) CPUS390XState *env = &cpu->env; env->pfault_token = -1UL; - s390_del_running_cpu(cpu); scc->parent_reset(s); -#if !defined(CONFIG_USER_ONLY) - s->halted = 1; -#endif + s390_cpu_set_state(CPU_STATE_STOPPED, cpu); tlb_flush(s, 1); } @@ -135,9 +134,8 @@ static void s390_cpu_full_reset(CPUState *s) S390CPUClass *scc = S390_CPU_GET_CLASS(cpu); CPUS390XState *env = &cpu->env; - s390_del_running_cpu(cpu); - scc->parent_reset(s); + s390_cpu_set_state(CPU_STATE_STOPPED, cpu); memset(env, 0, offsetof(CPUS390XState, cpu_num)); @@ -147,12 +145,7 @@ static void s390_cpu_full_reset(CPUState *s) env->pfault_token = -1UL; - /* set halted to 1 to make sure we can add the cpu in - * s390_ipl_cpu code, where CPUState::halted is set back to 0 - * after incrementing the cpu counter */ #if !defined(CONFIG_USER_ONLY) - s->halted = 1; - if (kvm_enabled()) { kvm_s390_reset_vcpu(cpu); } @@ -206,10 +199,7 @@ static void s390_cpu_initfn(Object *obj) env->tod_basetime = 0; env->tod_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_tod_timer, cpu); env->cpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_cpu_timer, cpu); - /* set CPUState::halted state to 1 to avoid decrementing the running - * cpu counter in s390_cpu_reset to a negative number at - * initial ipl */ - cs->halted = 1; + s390_cpu_set_state(CPU_STATE_STOPPED, cpu); #endif env->cpu_num = cpu_num++; env->ext_index = -1; @@ -230,6 +220,12 @@ static void s390_cpu_finalize(Object *obj) } #if !defined(CONFIG_USER_ONLY) +static bool disabled_wait(CPUState *cpu) +{ + return cpu->halted && !(S390_CPU(cpu)->env.psw.mask & + (PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK)); +} + static unsigned s390_count_running_cpus(void) { CPUState *cpu; @@ -239,34 +235,60 @@ static unsigned s390_count_running_cpus(void) uint8_t state = S390_CPU(cpu)->env.cpu_state; if (state == CPU_STATE_OPERATING || state == CPU_STATE_LOAD) { - nr_running++; + if (!disabled_wait(cpu)) { + nr_running++; + } } } return nr_running; } -void s390_add_running_cpu(S390CPU *cpu) +unsigned int s390_cpu_halt(S390CPU *cpu) { CPUState *cs = CPU(cpu); + trace_cpu_halt(cs->cpu_index); - if (cs->halted) { - cpu->env.cpu_state = CPU_STATE_OPERATING; - cs->halted = 0; - cs->exception_index = -1; + if (!cs->halted) { + cs->halted = 1; + cs->exception_index = EXCP_HLT; } + + return s390_count_running_cpus(); } -unsigned s390_del_running_cpu(S390CPU *cpu) +void s390_cpu_unhalt(S390CPU *cpu) { CPUState *cs = CPU(cpu); + trace_cpu_unhalt(cs->cpu_index); - if (cs->halted == 0) { - assert(s390_count_running_cpus() >= 1); - cpu->env.cpu_state = CPU_STATE_STOPPED; - cs->halted = 1; - cs->exception_index = EXCP_HLT; + if (cs->halted) { + cs->halted = 0; + cs->exception_index = -1; + } +} + +unsigned int s390_cpu_set_state(uint8_t cpu_state, S390CPU *cpu) + { + trace_cpu_set_state(CPU(cpu)->cpu_index, cpu_state); + + switch (cpu_state) { + case CPU_STATE_STOPPED: + case CPU_STATE_CHECK_STOP: + /* halt the cpu for common infrastructure */ + s390_cpu_halt(cpu); + break; + case CPU_STATE_OPERATING: + case CPU_STATE_LOAD: + /* unhalt the cpu for common infrastructure */ + s390_cpu_unhalt(cpu); + break; + default: + error_report("Requested CPU state is not a valid S390 CPU state: %u", + cpu_state); + exit(1); } + cpu->env.cpu_state = cpu_state; return s390_count_running_cpus(); } diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h index f1a3ad2..7b9300e 100644 --- a/target-s390x/cpu.h +++ b/target-s390x/cpu.h @@ -407,8 +407,9 @@ static inline void kvm_s390_service_interrupt(uint32_t parm) } #endif S390CPU *s390_cpu_addr2state(uint16_t cpu_addr); -void s390_add_running_cpu(S390CPU *cpu); -unsigned s390_del_running_cpu(S390CPU *cpu); +unsigned int s390_cpu_halt(S390CPU *cpu); +void s390_cpu_unhalt(S390CPU *cpu); +unsigned int s390_cpu_set_state(uint8_t cpu_state, S390CPU *cpu); /* service interrupts are floating therefore we must not pass an cpustate */ void s390_sclp_extint(uint32_t parm); @@ -417,11 +418,16 @@ void s390_sclp_extint(uint32_t parm); extern const hwaddr virtio_size; #else -static inline void s390_add_running_cpu(S390CPU *cpu) +static inline unsigned int s390_cpu_halt(S390CPU *cpu) +{ + return 0; +} + +static inline void s390_cpu_unhalt(S390CPU *cpu) { } -static inline unsigned s390_del_running_cpu(S390CPU *cpu) +static inline unsigned int s390_cpu_set_state(uint8_t cpu_state, S390CPU *cpu) { return 0; } diff --git a/target-s390x/helper.c b/target-s390x/helper.c index e21afe6..09aec7b 100644 --- a/target-s390x/helper.c +++ b/target-s390x/helper.c @@ -504,23 +504,18 @@ hwaddr s390_cpu_get_phys_addr_debug(CPUState *cs, vaddr vaddr) void load_psw(CPUS390XState *env, uint64_t mask, uint64_t addr) { + env->psw.addr = addr; + env->psw.mask = mask; + env->cc_op = (mask >> 44) & 3; + if (mask & PSW_MASK_WAIT) { S390CPU *cpu = s390_env_get_cpu(env); - CPUState *cs = CPU(cpu); - if (!(mask & (PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK))) { - if (s390_del_running_cpu(cpu) == 0) { + if (s390_cpu_halt(cpu) == 0) { #ifndef CONFIG_USER_ONLY - qemu_system_shutdown_request(); + qemu_system_shutdown_request(); #endif - } } - cs->halted = 1; - cs->exception_index = EXCP_HLT; } - - env->psw.addr = addr; - env->psw.mask = mask; - env->cc_op = (mask >> 44) & 3; } static uint64_t get_psw_mask(CPUS390XState *env) @@ -818,7 +813,7 @@ void s390_cpu_do_interrupt(CPUState *cs) qemu_log_mask(CPU_LOG_INT, "%s: %d at pc=%" PRIx64 "\n", __func__, cs->exception_index, env->psw.addr); - s390_add_running_cpu(cpu); + s390_cpu_set_state(CPU_STATE_OPERATING, cpu); /* handle machine checks */ if ((env->psw.mask & PSW_MASK_MCHECK) && (cs->exception_index == -1)) { diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c index a85a480..415baea 100644 --- a/target-s390x/kvm.c +++ b/target-s390x/kvm.c @@ -921,7 +921,7 @@ static void sigp_cpu_start(void *arg) CPUState *cs = arg; S390CPU *cpu = S390_CPU(cs); - s390_add_running_cpu(cpu); + s390_cpu_set_state(CPU_STATE_OPERATING, cpu); DPRINTF("DONE: KVM cpu start: %p\n", &cpu->env); } @@ -934,7 +934,7 @@ static void sigp_cpu_restart(void *arg) }; kvm_s390_vcpu_interrupt(cpu, &irq); - s390_add_running_cpu(cpu); + s390_cpu_set_state(CPU_STATE_OPERATING, cpu); } int kvm_s390_cpu_restart(S390CPU *cpu) @@ -1074,7 +1074,7 @@ static void unmanageable_intercept(S390CPU *cpu, const char *str, int pswoffset) error_report("Unmanageable %s! CPU%i new PSW: 0x%016lx:%016lx", str, cs->cpu_index, ldq_phys(cs->as, cpu->env.psa + pswoffset), ldq_phys(cs->as, cpu->env.psa + pswoffset + 8)); - s390_del_running_cpu(cpu); + s390_cpu_halt(cpu); guest_panicked(); } @@ -1103,7 +1103,8 @@ static int handle_intercept(S390CPU *cpu) break; case ICPT_WAITPSW: /* disabled wait, since enabled wait is handled in kernel */ - if (s390_del_running_cpu(cpu) == 0) { + cpu_synchronize_state(cs); + if (s390_cpu_halt(cpu) == 0) { if (is_special_wait_psw(cs)) { qemu_system_shutdown_request(); } else { @@ -1113,7 +1114,7 @@ static int handle_intercept(S390CPU *cpu) r = EXCP_HALTED; break; case ICPT_CPU_STOP: - if (s390_del_running_cpu(cpu) == 0) { + if (s390_cpu_set_state(CPU_STATE_STOPPED, cpu) == 0) { qemu_system_shutdown_request(); } r = EXCP_HALTED; diff --git a/trace-events b/trace-events index 011d105..5202f20 100644 --- a/trace-events +++ b/trace-events @@ -1372,3 +1372,8 @@ kvm_clear_cmma(int rc) "CMMA: clearing with result code %d" # hw/dma/i8257.c i8257_unregistered_dma(int nchan, int dma_pos, int dma_len) "unregistered DMA channel used nchan=%d dma_pos=%d dma_len=%d" + +# target-s390x/cpu.c +cpu_set_state(int cpu_index, uint8_t state) "setting cpu %d state to %" PRIu8 +cpu_halt(int cpu_index) "halting cpu %d" +cpu_unhalt(int cpu_index) "unhalting cpu %d"