From patchwork Fri Sep 13 18:19:42 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145059 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 7A2F7912 for ; Fri, 13 Sep 2019 18:21:11 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 57B9B214D8 for ; Fri, 13 Sep 2019 18:21:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="aA1y+Yoa" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 57B9B214D8 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=Oxb/icvyYAtgtPn5hvULwPNT83gA/6zjcYJuoP7XVDg=; b=aA1y+YoarQiquHdR9N9IRCU2Hi sfLJ2ycs+z/g1PMmiRW1drY7mW/JrFMyRrayc4QGvb4hF7wC8q3SWqsiWUGy3bw1kaZfSnTITrmPT A5Y6hYti5eDILjCckTTfrnhTLNNBuNMitNGRLpkABp0hskV23ejCEvh6xpPflvlZH4Vlpztl3Rw7q 0IA9D9zwG4r5xNX3BMg+me248ZjQcEgBEpoZvcpsoHb0VSFxArBJNvl8ikocMIDW5CX5qpZYe602F 5/JXdZzRu/RHPMM3AdDGyt1jzRRFWNWmTXNSsTXugbUtazES9sPb1bkuApM6CXCuFCtVhNh6cMcHa YpElp7Xw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBt-0005C5-S8; Fri, 13 Sep 2019 18:21:05 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBc-0004vF-FE for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:20:50 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id C3D401570; Fri, 13 Sep 2019 11:20:47 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 5644C3F71F; Fri, 13 Sep 2019 11:20:45 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 01/12] smp: add generic SMP-stop support to common code Date: Fri, 13 Sep 2019 19:19:42 +0100 Message-Id: <20190913181953.45748-2-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112048_595134_97AA2516 X-CRM114-Status: GOOD ( 19.01 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org There was a lot of code duplication across architectures regarding the SMP stop procedures' logic; moreover some of this duplicated code logic happened to be similarly faulty across a few architectures: while fixing such logic, move such generic logic as much as possible inside common code. Collect all the common logic related to SMP stop operations into the common SMP code; any architecture willing to use such centralized logic can select CONFIG_ARCH_USE_COMMON_STOP=y and provide the related arch-specific helpers: in such a scenario, those architectures will transparently start using the common code provided by smp_send_stop() common function. On the other side, Architectures not willing to use common code SMP stop logic will simply leave CONFIG_ARCH_USE_COMMON_STOP undefined and carry on executing their local arch-specific smp_send_stop() as before. Suggested-by: Dave Martin Signed-off-by: Cristian Marussi --- v1 --> v2 - moved related Kconfig to common code inside arch/Kconfig - introduced additional CONFIG_USE_COMMON_STOP selected by CONFIG_ARCH_USE_COMMON_STOP - introduced helpers to let architectures optionally alter the default common code behaviour while waiting for CPUs: change timeout or wait for ever. (will be needed by x86) --- arch/Kconfig | 7 +++++ include/linux/smp.h | 55 +++++++++++++++++++++++++++++++++++++ kernel/smp.c | 67 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 129 insertions(+) diff --git a/arch/Kconfig b/arch/Kconfig index a7b57dd42c26..89766e6c0ac8 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -166,6 +166,13 @@ config ARCH_USE_BUILTIN_BSWAP instructions should set this. And it shouldn't hurt to set it on architectures that don't have such instructions. +config ARCH_USE_COMMON_SMP_STOP + def_bool n + +config USE_COMMON_SMP_STOP + depends on SMP && ARCH_USE_COMMON_SMP_STOP + def_bool y + config KRETPROBES def_bool y depends on KPROBES && HAVE_KRETPROBES diff --git a/include/linux/smp.h b/include/linux/smp.h index 6fc856c9eda5..381a14bfcd96 100644 --- a/include/linux/smp.h +++ b/include/linux/smp.h @@ -77,6 +77,61 @@ int smp_call_function_single_async(int cpu, call_single_data_t *csd); */ extern void smp_send_stop(void); +#ifdef CONFIG_USE_COMMON_SMP_STOP +static atomic_t wait_forever; +static atomic_t wait_timeout = ATOMIC_INIT(USEC_PER_SEC); + +/* + * An Architecture can optionally decide to use this helper to change the + * waiting behaviour of common STOP logic, forcing to wait forever for + * all CPUs to be stopped. + */ +static inline void smp_stop_set_wait_forever(int wait) +{ + atomic_set(&wait_forever, wait); + /* ensure wait atomic-op is visible */ + smp_mb__after_atomic(); +} + +/* + * An Architecture can optionally decide to use this helper to change the + * waiting timeout of common STOP logic. A ZERO timeout means no timeout + * at all as long as wait_forever was not previously set. + * + * Note that wait_forever and timeout must remain individually selectable: + * so you can temporarily request wait_forever while keeping the same timeout + * settings. + */ +static inline void smp_stop_set_wait_timeout_us(unsigned long timeout) +{ + atomic_set(&wait_timeout, timeout); + /* ensure timeout atomic-op is visible */ + smp_mb__after_atomic(); +} + +/* Retrieve the current wait settings. */ +static inline bool smp_stop_get_wait_timeout_us(unsigned long *timeout) +{ + if (timeout) + *timeout = atomic_read(&wait_timeout); + return atomic_read(&wait_forever); +} + +/* + * Any Architecture willing to use STOP common logic implementation + * MUST at least provide the arch_smp_stop_call() helper which is in + * charge of its own arch-specific CPU-stop mechanism. + */ +extern void arch_smp_stop_call(cpumask_t *cpus); + +/* + * An Architecture CAN also provide the arch_smp_cpus_stop_complete() + * dedicated helper, to perform any final arch-specific operation on + * the local CPU once the other CPUs have been successfully stopped. + */ +void arch_smp_cpus_stop_complete(void); +#endif + /* * sends a 'reschedule' event to another CPU: */ diff --git a/kernel/smp.c b/kernel/smp.c index 7dbcb402c2fc..72f99bf13fd0 100644 --- a/kernel/smp.c +++ b/kernel/smp.c @@ -20,6 +20,7 @@ #include #include #include +#include #include "smpboot.h" @@ -817,3 +818,69 @@ int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par, bool phys) return sscs.ret; } EXPORT_SYMBOL_GPL(smp_call_on_cpu); + +#ifdef CONFIG_USE_COMMON_SMP_STOP +void __weak arch_smp_cpus_stop_complete(void) { } + +static inline bool any_other_cpus_online(cpumask_t *mask, + unsigned int this_cpu_id) +{ + cpumask_copy(mask, cpu_online_mask); + cpumask_clear_cpu(this_cpu_id, mask); + + return !cpumask_empty(mask); +} + +/* + * This centralizes the common logic to: + * + * - evaluate which CPUs are online and needs to be notified for stop, + * while considering properly the status of the calling CPU + * + * - call the arch-specific helpers to request the effective stop + * + * - wait for the stop operation to be completed across all involved CPUs + * monitoring the cpu_online_mask + */ +void smp_send_stop(void) +{ + unsigned int this_cpu_id; + cpumask_t mask; + + this_cpu_id = smp_processor_id(); + if (any_other_cpus_online(&mask, this_cpu_id)) { + bool wait; + unsigned long timeout; + unsigned int this_cpu_online = cpu_online(this_cpu_id); + + if (system_state <= SYSTEM_RUNNING) + pr_crit("stopping secondary CPUs\n"); + arch_smp_stop_call(&mask); + + /* + * Defaults to wait up to one second for other CPUs to stop; + * architectures can modify the default timeout or request + * to wait forever. + * + * Here we rely simply on cpu_online_mask to sync with + * arch-specific stop code without bloating the code with an + * additional atomic_t ad-hoc counter. + * + * As a consequence we'll need proper explicit memory barriers + * in case the other CPUs running the arch-specific stop-code + * would need to commit to memory some data (like saved_regs). + */ + wait = smp_stop_get_wait_timeout_us(&timeout); + while (num_online_cpus() > this_cpu_online && + (wait || timeout--)) + udelay(1); + /* ensure any stopping-CPUs memory access is made visible */ + smp_rmb(); + if (num_online_cpus() > this_cpu_online) + pr_warn("failed to stop secondary CPUs %*pbl\n", + cpumask_pr_args(cpu_online_mask)); + } + /* Perform final (possibly arch-specific) work on this CPU */ + arch_smp_cpus_stop_complete(); +} +#endif From patchwork Fri Sep 13 18:19:43 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145061 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8CDB9912 for ; Fri, 13 Sep 2019 18:21:25 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 64C23208C2 for ; Fri, 13 Sep 2019 18:21:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Q0bgqa2L" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 64C23208C2 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=0CGtF07G/ikq1XRJ0pvFdD9qOC5cqqdkBAK3qtf5XOo=; b=Q0bgqa2LYbFhXRilksjSH+GebW Uq4t2c9iY4/kkdLX+e5qdC8z6+0WHPTMHyNepHq1wD3yH5NM9l/aw65U0mCo2dSww5zz25mbDssTp /C+05Ob1rY+5NIHpt5YDxCDg83p+D467xdQDXmJmqIRHZCvlDHirvroF9EQ3IuVE+cKS93YBIQObw y/OFURODoWv6KkU4GXmtj7RPj8iFaecsbWlVjessqIoz1HOilFTqpQGDZfhzazHblVAK8FUhfII5C Fu6NYKJCvhuDH/FnvgfKGs5mQm7mWuiNDxUG95sYxf5osDfjHEZ1Xkl+rj+g15NjEkvR6SOojPfaO abjVLDWQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qCC-0005VR-QK; Fri, 13 Sep 2019 18:21:24 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBg-0004wt-4B for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:20:54 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 8DB8715A2; Fri, 13 Sep 2019 11:20:50 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 0598B3F71F; Fri, 13 Sep 2019 11:20:47 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 02/12] smp: unify crash_ and smp_send_stop() logic Date: Fri, 13 Sep 2019 19:19:43 +0100 Message-Id: <20190913181953.45748-3-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112052_382907_45E67A29 X-CRM114-Status: GOOD ( 22.18 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org crash_smp_send_stop() logic was fairly similar to smp_send_stop(): a lot of logic and code was duplicated between the two code paths and across a few different architectures. Unify this underlying common logic into the existing SMP common stop code: use a common workhorse function for both paths to perform the common tasks while taking care to propagate to the underlying architecture code the intent of the stop operation: a simple stop or a crash dump stop. Relocate the __weak crash_smp_send_stop() function from panic.c to smp.c, since it is the crash dump entry point for the crash stop process and now calls into this new common logic (only if this latter is enabled by ARCH_USE_COMMON_SMP_STOP=y). Introduce a few more helpers so that the architectures willing to use the common code logic can provide their arch-specific bits to handle the differences between a stop and a crash stop; architectures can anyway decide to override as a whole the common logic providing their own custom solution in crash_smp_send_stop() (as it was before). Provide also a new common code method to inquiry on the outcome of an ongoing crash_stop procedure: smp_crash_stop_failed(). Signed-off-by: Cristian Marussi --- v1 --> v2 - using new CONFIG_USE_COMMON_SMP_STOP - added arch_smp_cpus_crash_complete() --- include/linux/smp.h | 34 +++++++++++++++++++++++ kernel/panic.c | 26 ----------------- kernel/smp.c | 68 ++++++++++++++++++++++++++++++++++++++++++--- 3 files changed, 98 insertions(+), 30 deletions(-) diff --git a/include/linux/smp.h b/include/linux/smp.h index 381a14bfcd96..0f95bbd2cb5c 100644 --- a/include/linux/smp.h +++ b/include/linux/smp.h @@ -130,8 +130,36 @@ extern void arch_smp_stop_call(cpumask_t *cpus); * the local CPU once the other CPUs have been successfully stopped. */ void arch_smp_cpus_stop_complete(void); + +/* + * An Architecture CAN also provide the arch_smp_cpus_crash_complete() + * dedicated helper, to perform any final arch-specific operation on + * the local CPU once the other CPUs have been successfully crash stopped. + * When not overridden by the user, this defaults to call straight away + * arch_smp_cpus_stop_complete() + */ +void arch_smp_cpus_crash_complete(void); + +/* + * An Architecture CAN additionally provide the arch_smp_crash_call() + * helper which implements the arch-specific crash dump related operations. + * + * If such arch wants to fully support crash dump, this MUST be provided; + * when not provided the crash dump procedure will fallback to behave like + * a normal stop. (no saved regs, no arch-specific features disabled) + */ +extern void arch_smp_crash_call(cpumask_t *cpus); + +/* Helper to query the outcome of an ongoing crash_stop operation */ +bool smp_crash_stop_failed(void); #endif +/* + * stops all CPUs but the current one propagating to all other CPUs + * the information that a crash_kexec is ongoing: + */ +void crash_smp_send_stop(void); + /* * sends a 'reschedule' event to another CPU: */ @@ -195,6 +223,12 @@ static inline int get_boot_cpu_id(void) static inline void smp_send_stop(void) { } +static inline void crash_smp_send_stop(void) { } + +#ifdef CONFIG_USE_COMMON_SMP_STOP +static inline bool smp_crash_stop_failed(void) { } +#endif + /* * These macros fold the SMP functionality into a single CPU system */ diff --git a/kernel/panic.c b/kernel/panic.c index 057540b6eee9..bc0dbf9c9b75 100644 --- a/kernel/panic.c +++ b/kernel/panic.c @@ -86,32 +86,6 @@ void __weak nmi_panic_self_stop(struct pt_regs *regs) panic_smp_self_stop(); } -/* - * Stop other CPUs in panic. Architecture dependent code may override this - * with more suitable version. For example, if the architecture supports - * crash dump, it should save registers of each stopped CPU and disable - * per-CPU features such as virtualization extensions. - */ -void __weak crash_smp_send_stop(void) -{ - static int cpus_stopped; - - /* - * This function can be called twice in panic path, but obviously - * we execute this only once. - */ - if (cpus_stopped) - return; - - /* - * Note smp_send_stop is the usual smp shutdown function, which - * unfortunately means it may not be hardened to work in a panic - * situation. - */ - smp_send_stop(); - cpus_stopped = 1; -} - atomic_t panic_cpu = ATOMIC_INIT(PANIC_CPU_INVALID); /* diff --git a/kernel/smp.c b/kernel/smp.c index 72f99bf13fd0..b05d2648a168 100644 --- a/kernel/smp.c +++ b/kernel/smp.c @@ -820,8 +820,14 @@ int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par, bool phys) EXPORT_SYMBOL_GPL(smp_call_on_cpu); #ifdef CONFIG_USE_COMMON_SMP_STOP + void __weak arch_smp_cpus_stop_complete(void) { } +void __weak arch_smp_cpus_crash_complete(void) +{ + arch_smp_cpus_stop_complete(); +} + static inline bool any_other_cpus_online(cpumask_t *mask, unsigned int this_cpu_id) { @@ -831,6 +837,12 @@ static inline bool any_other_cpus_online(cpumask_t *mask, return !cpumask_empty(mask); } +void __weak arch_smp_crash_call(cpumask_t *cpus) +{ + pr_debug("SMP: Using generic %s() as SMP crash call.\n", __func__); + arch_smp_stop_call(cpus); +} + /* * This centralizes the common logic to: * @@ -842,7 +854,7 @@ static inline bool any_other_cpus_online(cpumask_t *mask, * - wait for the stop operation to be completed across all involved CPUs * monitoring the cpu_online_mask */ -void smp_send_stop(void) +static inline void __smp_send_stop_all(bool reason_crash) { unsigned int this_cpu_id; cpumask_t mask; @@ -855,8 +867,11 @@ void smp_send_stop(void) if (system_state <= SYSTEM_RUNNING) pr_crit("stopping secondary CPUs\n"); - arch_smp_stop_call(&mask); - + /* smp and crash arch-backends helpers are kept distinct */ + if (!reason_crash) + arch_smp_stop_call(&mask); + else + arch_smp_crash_call(&mask); /* * Defaults to wait up to one second for other CPUs to stop; * architectures can modify the default timeout or request @@ -881,6 +896,51 @@ void smp_send_stop(void) cpumask_pr_args(cpu_online_mask)); } /* Perform final (possibly arch-specific) work on this CPU */ - arch_smp_cpus_stop_complete(); + if (!reason_crash) + arch_smp_cpus_stop_complete(); + else + arch_smp_cpus_crash_complete(); +} + +void smp_send_stop(void) +{ + __smp_send_stop_all(false); } + +bool __weak smp_crash_stop_failed(void) +{ + return (num_online_cpus() > cpu_online(smp_processor_id())); +} +#endif + +/* + * Stop other CPUs while passing down the additional information that a + * crash_kexec is ongoing: it's up to the architecture implementation + * decide what to do. + * + * For example, Architectures supporting crash dump should provide + * specialized support for saving registers and disabling per-CPU features + * like virtualization extensions. + * + * Behaviour in the CONFIG_USE_COMMON_SMP_STOP=n case is preserved + * as it was before. + */ +void __weak crash_smp_send_stop(void) +{ + static int cpus_stopped; + + /* + * This function can be called twice in panic path, but obviously + * we execute this only once. + */ + if (cpus_stopped) + return; + +#ifdef CONFIG_USE_COMMON_SMP_STOP + __smp_send_stop_all(true); +#else + smp_send_stop(); #endif + + cpus_stopped = 1; +} From patchwork Fri Sep 13 18:19:44 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145063 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 1F62A912 for ; Fri, 13 Sep 2019 18:21:47 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id F1897206A5 for ; Fri, 13 Sep 2019 18:21:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ri5Z4hG5" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F1897206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=LjPYKHYE3z8j42ACvSf6Jfq1hWbtXRBw0rXIJr1sYC4=; b=ri5Z4hG5vyByvykujU0fcbUQgO 7vB8BP8DpdlOnjsNxMZFFrwsx+Fat8EcUkmtsLfig42rOXCbxdUvHmMQ5sugB4ragX7HzYjauBTBV dEWNaZm8qYAuMFH9MMbfW6koQCd3zQ59pjz953TFIOvmeMkb4wC1BQJxhyZ3pGjF3T3brRtNykn3Q CbYZPfOgxg8AbHe2mBfkIduoCbSDsDbvmXKU72ajhrwj6ZxMds3bbBKhQY0ssSJVCtb/cG4ES4Fi1 sHg3pgoqvUdzJ2ntM8ukQatcoFFvECTxFxZiDkNo8q9abOhky8QAR/Ae0QMmnQxrujONQ+KyNU4mV C158A38A==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qCT-0005nz-Mh; Fri, 13 Sep 2019 18:21:41 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBh-0004yl-Gh for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:20:55 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 3DC4515AB; Fri, 13 Sep 2019 11:20:53 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id C3CAD3F71F; Fri, 13 Sep 2019 11:20:50 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 03/12] smp: coordinate concurrent crash/smp stop calls Date: Fri, 13 Sep 2019 19:19:44 +0100 Message-Id: <20190913181953.45748-4-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112053_754467_F9B97BBA X-CRM114-Status: GOOD ( 16.96 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Once a stop request is in progress on one CPU, it must be carefully evaluated what to do if another stop request is issued concurrently on another CPU. Given that panic and crash dump code flows are mutually exclusive, the only alternative possible scenario which instead could lead to concurrent stop requests, is represented by the simultaneous stop requests possibly triggered by a concurrent halt/reboot/shutdown. In such a case, prioritize the panic/crash procedure and most importantly immediately park the offending CPU that was attempting the concurrent stop request: force it to idle quietly, waiting for the ongoing stop/dump requests to arrive. Failing to do so would result in the offending CPU being effectively lost on the next possible reboot triggered by the crash dump. [1] Another scenario, where the crash/stop code path was known to be executed twice, was during a normal panic/crash with crash_kexec_post_notifiers=1; since this issue is similar, fold also this case-handling into this new logic. [1] <<<<<---------- TRIGGERED PANIC [ 225.676014] ------------[ cut here ]------------ [ 225.676656] kernel BUG at arch/arm64/kernel/cpufeature.c:852! [ 225.677253] Internal error: Oops - BUG: 0 [#1] PREEMPT SMP [ 225.677660] Modules linked in: [ 225.678458] CPU: 3 PID: 0 Comm: swapper/3 Kdump: loaded Not tainted 5.3.0-rc5-00004-gb8a210cd3c32-dirty #2 [ 225.678621] Hardware name: Foundation-v8A (DT) [ 225.678868] pstate: 000001c5 (nzcv dAIF -PAN -UAO) [ 225.679523] pc : has_cpuid_feature+0x35c/0x360 [ 225.679649] lr : verify_local_elf_hwcaps+0x6c/0xf0 [ 225.679759] sp : ffff0000118cbf60 [ 225.679855] x29: ffff0000118cbf60 x28: 0000000000000000 [ 225.680026] x27: 0000000000000000 x26: 0000000000000000 [ 225.680115] x25: ffff00001167a010 x24: ffff0000112f59f8 [ 225.680207] x23: 0000000000000000 x22: 0000000000000000 [ 225.680290] x21: ffff0000112ea018 x20: ffff000010fe5538 [ 225.680372] x19: ffff000010ba3f30 x18: 000000000000001e [ 225.680465] x17: 0000000000000000 x16: 0000000000000000 [ 225.680546] x15: 0000000000000000 x14: 0000000000000008 [ 225.680629] x13: 0209018b7a9404f4 x12: 0000000000000001 [ 225.680719] x11: 0000000000000080 x10: 00400032b5503510 [ 225.680803] x9 : 0000000000000000 x8 : ffff000010b93204 [ 225.680884] x7 : 00000000800001d8 x6 : 0000000000000005 [ 225.680975] x5 : 0000000000000000 x4 : 0000000000000000 [ 225.681056] x3 : 0000000000000000 x2 : 0000000000008000 [ 225.681139] x1 : 0000000000180480 x0 : 0000000000180480 [ 225.681423] Call trace: [ 225.681669] has_cpuid_feature+0x35c/0x360 [ 225.681762] verify_local_elf_hwcaps+0x6c/0xf0 [ 225.681836] check_local_cpu_capabilities+0x88/0x118 [ 225.681939] secondary_start_kernel+0xc4/0x168 [ 225.682432] Code: d53801e0 17ffff58 d5380600 17ffff56 (d4210000) [ 225.683998] smp: stopping secondary CPUs [ 225.684130] Delaying stop.... <<<<<------ INSTRUMENTED DEBUG_DELAY Rebooting. <<<<<------ MANUAL SIMULTANEOUS REBOOT [ 232.647472] reboot: Restarting system [ 232.648363] Reboot failed -- System halted [ 239.552413] smp: failed to stop secondary CPUs 0 [ 239.554730] Starting crashdump kernel... [ 239.555194] ------------[ cut here ]------------ [ 239.555406] Some CPUs may be stale, kdump will be unreliable. [ 239.555802] WARNING: CPU: 3 PID: 0 at arch/arm64/kernel/machine_kexec.c:156 machine_kexec+0x3c/0x2b0 [ 239.556044] Modules linked in: [ 239.556244] CPU: 3 PID: 0 Comm: swapper/3 Kdump: loaded Not tainted 5.3.0-rc5-00004-gb8a210cd3c32-dirty #2 [ 239.556340] Hardware name: Foundation-v8A (DT) [ 239.556459] pstate: 600003c5 (nZCv DAIF -PAN -UAO) [ 239.556587] pc : machine_kexec+0x3c/0x2b0 [ 239.556700] lr : machine_kexec+0x3c/0x2b0 [ 239.556775] sp : ffff0000118cbad0 [ 239.556876] x29: ffff0000118cbad0 x28: ffff80087a8c3700 [ 239.557012] x27: 0000000000000000 x26: 0000000000000000 [ 239.557278] x25: ffff000010fe3ef0 x24: 00000000000003c0 .... [ 239.561568] Bye! [ 0.000000] Booting Linux on physical CPU 0x0000000003 [0x410fd0f0] [ 0.000000] Linux version 5.2.0-rc4-00001-g93bd4bc234d5-dirty [ 0.000000] Machine model: Foundation-v8A ... [ 0.197991] smp: Bringing up secondary CPUs ... [ 0.232643] psci: failed to boot CPU1 (-22) <<<<--- LOST CPU ON REBOOT [ 0.232861] CPU1: failed to boot: -22 [ 0.306291] Detected PIPT I-cache on CPU2 [ 0.310524] GICv3: CPU2: found redistributor 1 region 0:0x000000002f120000 [ 0.315618] CPU2: Booted secondary processor 0x0000000001 [0x410fd0f0] [ 0.395576] Detected PIPT I-cache on CPU3 [ 0.400431] GICv3: CPU3: found redistributor 2 region 0:0x000000002f140000 [ 0.407252] CPU3: Booted secondary processor 0x0000000002 [0x410fd0f0] [ 0.431811] smp: Brought up 1 node, 3 CPUs [ 0.439898] SMP: Total of 3 processors activated. Signed-off-by: Cristian Marussi --- v1 --> v2 - using new CONFIG_USE_COMMON_SMP_STOP --- include/linux/smp.h | 3 +++ kernel/smp.c | 48 ++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 46 insertions(+), 5 deletions(-) diff --git a/include/linux/smp.h b/include/linux/smp.h index 0f95bbd2cb5c..2ae7dd48b33c 100644 --- a/include/linux/smp.h +++ b/include/linux/smp.h @@ -152,6 +152,9 @@ extern void arch_smp_crash_call(cpumask_t *cpus); /* Helper to query the outcome of an ongoing crash_stop operation */ bool smp_crash_stop_failed(void); + +/* A generic cpu parking helper, possibly overridden by architecture code */ +void arch_smp_cpu_park(void) __noreturn; #endif /* diff --git a/kernel/smp.c b/kernel/smp.c index b05d2648a168..d92ce59ae538 100644 --- a/kernel/smp.c +++ b/kernel/smp.c @@ -821,6 +821,12 @@ EXPORT_SYMBOL_GPL(smp_call_on_cpu); #ifdef CONFIG_USE_COMMON_SMP_STOP +void __weak arch_smp_cpu_park(void) +{ + while (1) + cpu_relax(); +} + void __weak arch_smp_cpus_stop_complete(void) { } void __weak arch_smp_cpus_crash_complete(void) @@ -843,6 +849,9 @@ void __weak arch_smp_crash_call(cpumask_t *cpus) arch_smp_stop_call(cpus); } +#define REASON_STOP 1 +#define REASON_CRASH 2 + /* * This centralizes the common logic to: * @@ -858,8 +867,38 @@ static inline void __smp_send_stop_all(bool reason_crash) { unsigned int this_cpu_id; cpumask_t mask; + static atomic_t stopping; + int was_reason; this_cpu_id = smp_processor_id(); + /* make sure that concurrent stop requests are handled properly */ + was_reason = atomic_cmpxchg(&stopping, 0, + reason_crash ? REASON_CRASH : REASON_STOP); + if (was_reason) { + /* + * This function can be called twice in panic path if + * crash_kexec is called with crash_kexec_post_notifiers=1, + * but obviously we execute this only once. + */ + if (reason_crash && was_reason == REASON_CRASH) + return; + /* + * In case of other concurrent STOP calls (like in a REBOOT + * started simultaneously as an ongoing PANIC/CRASH/REBOOT) + * we want to prioritize the ongoing PANIC/KEXEC call and + * force here the offending CPU that was attempting the + * concurrent STOP to just sit idle waiting to die. + * Failing to do so would result in a lost CPU on the next + * possible reboot triggered by crash_kexec(). + */ + if (!reason_crash) { + pr_crit("CPU%d - kernel already stopping, parking myself.\n", + this_cpu_id); + local_irq_enable(); + /* does not return */ + arch_smp_cpu_park(); + } + } if (any_other_cpus_online(&mask, this_cpu_id)) { bool wait; unsigned long timeout; @@ -927,6 +966,9 @@ bool __weak smp_crash_stop_failed(void) */ void __weak crash_smp_send_stop(void) { +#ifdef CONFIG_USE_COMMON_SMP_STOP + __smp_send_stop_all(true); +#else static int cpus_stopped; /* @@ -936,11 +978,7 @@ void __weak crash_smp_send_stop(void) if (cpus_stopped) return; -#ifdef CONFIG_USE_COMMON_SMP_STOP - __smp_send_stop_all(true); -#else smp_send_stop(); -#endif - cpus_stopped = 1; +#endif } From patchwork Fri Sep 13 18:19:45 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145065 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 9552A912 for ; Fri, 13 Sep 2019 18:21:59 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 732C8206A5 for ; Fri, 13 Sep 2019 18:21:59 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="nRAkPR6R" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 732C8206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=EiDYKzpbYNp7SWqcvhO3Ae4cH8uHXjubfh1k3S6lZRI=; b=nRAkPR6RS5qKZQHBilpxb/uq7J ae7Dy46AoB1clQPG7+9SbMOcUs7M5BYROAYmzWBE+j22IpktZRPj5ayTIb4NjVAtAgINmDOrLuQeD eibDt7ssxituiQMo2sfdFKBVykW4OqZTVIsZ++Au/tz+i/SqibKSGckt8So2+mt6vsjXZoPguvviB 2UzNByLhKKlizmj01/zbZPZ/DKhEKg1lSa7s5h6iLYykOljtEZ9WYJjE+xPHql06yxffM/tXALgHn lRwZEzTODia9K0f0a7dS5q/rVHX973ZIMMZuayiAZesAXEOschBhCz3dNals70ntqqVw8AP1aqPrw /l8rMlXg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qCk-00062s-57; Fri, 13 Sep 2019 18:21:58 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBk-00052i-DS for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:20:58 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E33BA28; Fri, 13 Sep 2019 11:20:55 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 73E803F71F; Fri, 13 Sep 2019 11:20:53 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 04/12] smp: address races of starting CPUs while stopping Date: Fri, 13 Sep 2019 19:19:45 +0100 Message-Id: <20190913181953.45748-5-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112056_623244_6B58F588 X-CRM114-Status: GOOD ( 18.99 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add to SMP stop common code a best-effort retry logic, re-issuing a stop request when any CPU is detected to be still online after the first stop request cycle has completed. While retrying provide to architectures' helpers an 'attempt' argument so that, after a possible first failed attempt, they can autonomously decide to adopt different approaches in subsequent retries. Address the case in which some CPUs could still be starting up when the stop process is initiated, remaining so undetected and coming fully online only after the SMP stop procedure was already started: such officially still offline CPUs would be missed by an ongoing stop procedure. Being a best effort approach, though, it is not always guaranteed to be able to stop any CPU that happened to finally come online after the whole SMP stop retry cycle has completed. (i.e. the race-window is reduced but not eliminated) Signed-off-by: Cristian Marussi --- v1 --> v2 - added attempt_num param to arch helpers, to let arch implementation know if a retry is ongoing because some CPU failed to stop. (some arch like x86 attempts the retry with different means like NMI) - added some helpers to let archs decide on the number of retries --- A more deterministic approach has been also attempted in order to catch any concurrently starting CPUs at the very last moment and make them kill themselves by: - adding a new set_cpus_stopping() in cpumask.h used to set a __cpus_stopping atomic internal flag - modifying set_cpu_online() to check on __cpus_stopping only when coming online, and force the offending CPU to kill itself in that case Anyway it has proved tricky and complex (beside faulty) to implement the above 'kill-myself' phase in a reliable way while remaining architecture agnostic and still distingushing properly regular stops from crash kexec. So given that the main idea underlying this patch series was instead of simplifying and unifying code and the residual races not caught by the best-effort logic seemed not very likely, this more deterministic approach has been dropped in favour of the best effort retry logic. Moreover, the current retry logic will be anyway needed to support some architectures, like x86, that prefer to use different CPU's stopping methods in subsequent retries. --- include/linux/smp.h | 21 +++++++++++++++++++-- kernel/smp.c | 19 ++++++++++++------- 2 files changed, 31 insertions(+), 9 deletions(-) diff --git a/include/linux/smp.h b/include/linux/smp.h index 2ae7dd48b33c..63e4322d52e1 100644 --- a/include/linux/smp.h +++ b/include/linux/smp.h @@ -78,8 +78,11 @@ int smp_call_function_single_async(int cpu, call_single_data_t *csd); extern void smp_send_stop(void); #ifdef CONFIG_USE_COMMON_SMP_STOP +#define DEFAULT_MAX_STOP_RETRIES 2 + static atomic_t wait_forever; static atomic_t wait_timeout = ATOMIC_INIT(USEC_PER_SEC); +static atomic_t max_stop_retries = ATOMIC_INIT(DEFAULT_MAX_STOP_RETRIES); /* * An Architecture can optionally decide to use this helper to change the @@ -117,12 +120,26 @@ static inline bool smp_stop_get_wait_timeout_us(unsigned long *timeout) return atomic_read(&wait_forever); } +/* Change common SMP STOP logic maximum retries */ +static inline void smp_stop_set_max_retries(unsigned int max_retries) +{ + atomic_set(&max_stop_retries, max_retries); + /* ensure retries atomics are visible */ + smp_mb__after_atomic(); +} + +/* Get currently set maximum retries attempt */ +static inline unsigned int smp_stop_get_max_retries(void) +{ + return atomic_read(&max_stop_retries); +} + /* * Any Architecture willing to use STOP common logic implementation * MUST at least provide the arch_smp_stop_call() helper which is in * charge of its own arch-specific CPU-stop mechanism. */ -extern void arch_smp_stop_call(cpumask_t *cpus); +extern void arch_smp_stop_call(cpumask_t *cpus, unsigned int attempt_num); /* * An Architecture CAN also provide the arch_smp_cpus_stop_complete() @@ -148,7 +165,7 @@ void arch_smp_cpus_crash_complete(void); * when not provided the crash dump procedure will fallback to behave like * a normal stop. (no saved regs, no arch-specific features disabled) */ -extern void arch_smp_crash_call(cpumask_t *cpus); +extern void arch_smp_crash_call(cpumask_t *cpus, unsigned int attempt_num); /* Helper to query the outcome of an ongoing crash_stop operation */ bool smp_crash_stop_failed(void); diff --git a/kernel/smp.c b/kernel/smp.c index d92ce59ae538..5b966c62d557 100644 --- a/kernel/smp.c +++ b/kernel/smp.c @@ -843,10 +843,10 @@ static inline bool any_other_cpus_online(cpumask_t *mask, return !cpumask_empty(mask); } -void __weak arch_smp_crash_call(cpumask_t *cpus) +void __weak arch_smp_crash_call(cpumask_t *cpus, unsigned int attempt_num) { pr_debug("SMP: Using generic %s() as SMP crash call.\n", __func__); - arch_smp_stop_call(cpus); + arch_smp_stop_call(cpus, attempt_num); } #define REASON_STOP 1 @@ -865,10 +865,10 @@ void __weak arch_smp_crash_call(cpumask_t *cpus) */ static inline void __smp_send_stop_all(bool reason_crash) { - unsigned int this_cpu_id; cpumask_t mask; static atomic_t stopping; int was_reason; + unsigned int this_cpu_id, max_retries, attempt = 0; this_cpu_id = smp_processor_id(); /* make sure that concurrent stop requests are handled properly */ @@ -899,7 +899,9 @@ static inline void __smp_send_stop_all(bool reason_crash) arch_smp_cpu_park(); } } - if (any_other_cpus_online(&mask, this_cpu_id)) { + max_retries = smp_stop_get_max_retries(); + while (++attempt <= max_retries && + any_other_cpus_online(&mask, this_cpu_id)) { bool wait; unsigned long timeout; unsigned int this_cpu_online = cpu_online(this_cpu_id); @@ -908,9 +910,9 @@ static inline void __smp_send_stop_all(bool reason_crash) pr_crit("stopping secondary CPUs\n"); /* smp and crash arch-backends helpers are kept distinct */ if (!reason_crash) - arch_smp_stop_call(&mask); + arch_smp_stop_call(&mask, attempt); else - arch_smp_crash_call(&mask); + arch_smp_crash_call(&mask, attempt); /* * Defaults to wait up to one second for other CPUs to stop; * architectures can modify the default timeout or request @@ -930,9 +932,12 @@ static inline void __smp_send_stop_all(bool reason_crash) udelay(1); /* ensure any stopping-CPUs memory access is made visible */ smp_rmb(); - if (num_online_cpus() > this_cpu_online) + if (num_online_cpus() > this_cpu_online) { pr_warn("failed to stop secondary CPUs %*pbl\n", cpumask_pr_args(cpu_online_mask)); + if (attempt < max_retries) + pr_warn("Retrying SMP stop call...\n"); + } } /* Perform final (possibly arch-specific) work on this CPU */ if (!reason_crash) From patchwork Fri Sep 13 18:19:46 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145067 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 786A2912 for ; Fri, 13 Sep 2019 18:22:18 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 56386206A5 for ; Fri, 13 Sep 2019 18:22:18 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="us8a+uUj" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 56386206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=6yrLMYI/HobkxHnxhH1X3C6AIWguT+yo0DcfoyOv7dI=; b=us8a+uUjarlyrrK2Fvkv/n6po3 +XaKGatS2EanIscpBBrOJJE/GjKlpoNePsHXbab6k5JCYeH6IU97+E1cCFE8TicmXJUvVee/DBZT/ fhpG+6OelR18AE+6O1ZTxRIhjYqPfc2a4veDRVn7/2P5cY+5/HkpqNXWZ1UAc/S7VsxrIBAKznGf3 MsOk92EzoEg8Z3emDiAxtVGFCoDMXsiwpgD/3jfFMCSE8sZEyW9Nq8n5dkAmN5irgtVGhFZGRCBYK 4rFVp4hmjYgDPxrJZ596XWGNy+E9euwWD5GGDq0yq6FFgXm/ThmZD2jwydkBXWWslVU9oucLWG59V uzf/ybxw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qD3-0006Ig-IA; Fri, 13 Sep 2019 18:22:17 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBm-00055j-QX for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:00 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 90EF61570; Fri, 13 Sep 2019 11:20:58 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 237793F71F; Fri, 13 Sep 2019 11:20:56 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 05/12] arm64: smp: use generic SMP stop common code Date: Fri, 13 Sep 2019 19:19:46 +0100 Message-Id: <20190913181953.45748-6-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112058_963450_73EBDC0F X-CRM114-Status: GOOD ( 15.69 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make arm64 use the generic SMP-stop logic provided by common code unified smp_send_stop() function. arm64 smp_send_stop() logic had a bug in it: it failed to consider the online status of the calling CPU when evaluating if any stop message needed to be sent to other CPus at all: this resulted, on a 2-CPUs system, in the failure to stop all cpus if one paniced while starting up, leaving such system in an unexpected lively state. [root@arch ~]# echo 1 > /sys/devices/system/cpu/cpu1/online [root@arch ~]# [ 152.583368] ------------[ cut here ]------------ [ 152.583872] kernel BUG at arch/arm64/kernel/cpufeature.c:852! [ 152.584693] Internal error: Oops - BUG: 0 [#1] PREEMPT SMP [ 152.585228] Modules linked in: [ 152.586040] CPU: 1 PID: 0 Comm: swapper/1 Not tainted 5.3.0-rc5-00001-gcabd12118c4a-dirty #2 [ 152.586218] Hardware name: Foundation-v8A (DT) [ 152.586478] pstate: 000001c5 (nzcv dAIF -PAN -UAO) [ 152.587260] pc : has_cpuid_feature+0x35c/0x360 [ 152.587398] lr : verify_local_elf_hwcaps+0x6c/0xf0 [ 152.587520] sp : ffff0000118bbf60 [ 152.587605] x29: ffff0000118bbf60 x28: 0000000000000000 [ 152.587784] x27: 0000000000000000 x26: 0000000000000000 [ 152.587882] x25: ffff00001167a010 x24: ffff0000112f59f8 [ 152.587992] x23: 0000000000000000 x22: 0000000000000000 [ 152.588085] x21: ffff0000112ea018 x20: ffff000010fe5518 [ 152.588180] x19: ffff000010ba3f30 x18: 0000000000000036 [ 152.588285] x17: 0000000000000000 x16: 0000000000000000 [ 152.588380] x15: 0000000000000000 x14: ffff80087a821210 [ 152.588481] x13: 0000000000000000 x12: 0000000000000000 [ 152.588599] x11: 0000000000000080 x10: 00400032b5503510 [ 152.588709] x9 : 0000000000000000 x8 : ffff000010b93204 [ 152.588810] x7 : 00000000800001d8 x6 : 0000000000000005 [ 152.588910] x5 : 0000000000000000 x4 : 0000000000000000 [ 152.589021] x3 : 0000000000000000 x2 : 0000000000008000 [ 152.589121] x1 : 0000000000180480 x0 : 0000000000180480 [ 152.589379] Call trace: [ 152.589646] has_cpuid_feature+0x35c/0x360 [ 152.589763] verify_local_elf_hwcaps+0x6c/0xf0 [ 152.589858] check_local_cpu_capabilities+0x88/0x118 [ 152.589968] secondary_start_kernel+0xc4/0x168 [ 152.590530] Code: d53801e0 17ffff58 d5380600 17ffff56 (d4210000) [ 152.592215] ---[ end trace 80ea98416149c87e ]--- [ 152.592734] Kernel panic - not syncing: Attempted to kill the idle task! [ 152.593173] Kernel Offset: disabled [ 152.593501] CPU features: 0x0004,20c02008 [ 152.593678] Memory Limit: none [ 152.594208] ---[ end Kernel panic - not syncing: Attempted to kill the idle task! ]--- [root@arch ~]# bash: echo: write error: Input/output error [root@arch ~]# [root@arch ~]# [root@arch ~]# echo HELO HELO Get rid of such bug, switching arm64 to use the common SMP stop code. Reported-by: Dave Martin Signed-off-by: Cristian Marussi --- v1 --> v2 - now selecting arch/Kconfig ARCH_USE_COMMON_SMP_STOP - added attempt_num arch_smp_stop_call() helper --- arch/arm64/Kconfig | 1 + arch/arm64/kernel/smp.c | 29 ++++++----------------------- 2 files changed, 7 insertions(+), 23 deletions(-) diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 3adcec05b1f6..33f88381702b 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -67,6 +67,7 @@ config ARM64 select ARCH_USE_CMPXCHG_LOCKREF select ARCH_USE_QUEUED_RWLOCKS select ARCH_USE_QUEUED_SPINLOCKS + select ARCH_USE_COMMON_SMP_STOP select ARCH_SUPPORTS_MEMORY_FAILURE select ARCH_SUPPORTS_ATOMIC_RMW select ARCH_SUPPORTS_INT128 if GCC_VERSION >= 50000 || CC_IS_CLANG diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c index 018a33e01b0e..3e87fdbb9f74 100644 --- a/arch/arm64/kernel/smp.c +++ b/arch/arm64/kernel/smp.c @@ -953,33 +953,16 @@ void tick_broadcast(const struct cpumask *mask) } #endif -void smp_send_stop(void) +void arch_smp_cpus_stop_complete(void) { - unsigned long timeout; - - if (num_online_cpus() > 1) { - cpumask_t mask; - - cpumask_copy(&mask, cpu_online_mask); - cpumask_clear_cpu(smp_processor_id(), &mask); - - if (system_state <= SYSTEM_RUNNING) - pr_crit("SMP: stopping secondary CPUs\n"); - smp_cross_call(&mask, IPI_CPU_STOP); - } - - /* Wait up to one second for other CPUs to stop */ - timeout = USEC_PER_SEC; - while (num_online_cpus() > 1 && timeout--) - udelay(1); - - if (num_online_cpus() > 1) - pr_warning("SMP: failed to stop secondary CPUs %*pbl\n", - cpumask_pr_args(cpu_online_mask)); - sdei_mask_local_cpu(); } +void arch_smp_stop_call(cpumask_t *cpus, unsigned int __unused) +{ + smp_cross_call(cpus, IPI_CPU_STOP); +} + #ifdef CONFIG_KEXEC_CORE void crash_smp_send_stop(void) { From patchwork Fri Sep 13 18:19:47 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145069 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 18DAE1599 for ; Fri, 13 Sep 2019 18:22:36 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id EAF8A206A5 for ; Fri, 13 Sep 2019 18:22:35 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ABzJE4dv" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org EAF8A206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=tHofaoZ/9MxbWjsHhjqzbCZxnbODaBLilFi1zI+tFbY=; b=ABzJE4dvpREZHf7rm2RohHZur2 HacDrYffBhSnXruzPdOOB//oMXFx+GsOVOQ2PtekZD/6f3dFBusc4IX8aO9XSysjt+vlsEwqVmj5D d7sGGF49DCvIvp8StSeGnbAgtRW7ijp0i/A6V88reWbH/Mtc1ZBJNMbFh7+1tq9vVE5mC0FB/pnAY rpRrqSUYBBu1M7lhelMgK8sGyZkg+WA+5tx0kH/jfNyhou+KPkwi7q1cFCDFJ5CqTm/dhGj4coi/2 U4TD5FrxCi2RbjdrjC06yZeipaEKK5WpGhju1KzhxdsulhKYkp8GoyKMSye6dLZVGDh5+kRx7Qb8K sty2pJUg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qDL-0006Xa-8V; Fri, 13 Sep 2019 18:22:35 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBp-00059H-O5 for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:03 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 4111B15A2; Fri, 13 Sep 2019 11:21:01 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id C6E753F71F; Fri, 13 Sep 2019 11:20:58 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 06/12] arm64: smp: use SMP crash-stop common code Date: Fri, 13 Sep 2019 19:19:47 +0100 Message-Id: <20190913181953.45748-7-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112102_181510_CDCB624D X-CRM114-Status: GOOD ( 14.56 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make arm64 use the SMP common implementation of crash_smp_send_stop() and its generic logic, by removing the arm64 crash_smp_send_stop() definition and providing the needed arch specific helpers. Additionally, simplify the arch-specific stop and crash dump ISRs backends (which are in charge of effectively receiving and interpreting the stop/crash messages) and unify them as much as possible. Using the SMP common code, it is no more needed to make use of an atomic_t counter to make sure that each CPU had time to perform its crash dump related shutdown-ops before the world ends: simply take care to synchronize on cpu_online_mask, and add proper explicit memory barriers where needed. Moreover, remove arm64 specific smp_crash_stop_failed() helper as a whole and rely on the common code provided homonym function to lookup the state of an ongoing crash_stop operation. Signed-off-by: Cristian Marussi v1 --> v2 - added attempt_num param to arch_smp_crash_call() --- arch/arm64/include/asm/smp.h | 2 - arch/arm64/kernel/smp.c | 100 +++++++++-------------------------- 2 files changed, 26 insertions(+), 76 deletions(-) diff --git a/arch/arm64/include/asm/smp.h b/arch/arm64/include/asm/smp.h index a0c8a0b65259..d98c409f9225 100644 --- a/arch/arm64/include/asm/smp.h +++ b/arch/arm64/include/asm/smp.h @@ -150,8 +150,6 @@ static inline void cpu_panic_kernel(void) */ bool cpus_are_stuck_in_kernel(void); -extern void crash_smp_send_stop(void); -extern bool smp_crash_stop_failed(void); #endif /* ifndef __ASSEMBLY__ */ diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c index 3e87fdbb9f74..f0cc2bf84aaa 100644 --- a/arch/arm64/kernel/smp.c +++ b/arch/arm64/kernel/smp.c @@ -825,12 +825,30 @@ void arch_irq_work_raise(void) } #endif -static void local_cpu_stop(void) +static void local_cpu_crash_or_stop(struct pt_regs *crash_regs) { - set_cpu_online(smp_processor_id(), false); + unsigned int cpu = smp_processor_id(); - local_daif_mask(); + if (IS_ENABLED(CONFIG_KEXEC_CORE) && crash_regs) { +#ifdef CONFIG_KEXEC_CORE + /* crash stop requested: save regs before going offline */ + crash_save_cpu(crash_regs, cpu); +#endif + local_irq_disable(); + } else { + local_daif_mask(); + } sdei_mask_local_cpu(); + /* ensure dumped regs are visible once cpu is seen offline */ + smp_wmb(); + set_cpu_online(cpu, false); + /* ensure all writes are globally visible before cpu parks */ + wmb(); +#if defined(CONFIG_KEXEC_CORE) && defined(CONFIG_HOTPLUG_CPU) + if (cpu_ops[cpu]->cpu_die) + cpu_ops[cpu]->cpu_die(cpu); +#endif + /* just in case */ cpu_park_loop(); } @@ -841,31 +859,7 @@ static void local_cpu_stop(void) */ void panic_smp_self_stop(void) { - local_cpu_stop(); -} - -#ifdef CONFIG_KEXEC_CORE -static atomic_t waiting_for_crash_ipi = ATOMIC_INIT(0); -#endif - -static void ipi_cpu_crash_stop(unsigned int cpu, struct pt_regs *regs) -{ -#ifdef CONFIG_KEXEC_CORE - crash_save_cpu(regs, cpu); - - atomic_dec(&waiting_for_crash_ipi); - - local_irq_disable(); - sdei_mask_local_cpu(); - -#ifdef CONFIG_HOTPLUG_CPU - if (cpu_ops[cpu]->cpu_die) - cpu_ops[cpu]->cpu_die(cpu); -#endif - - /* just in case */ - cpu_park_loop(); -#endif + local_cpu_crash_or_stop(NULL); } /* @@ -894,14 +888,14 @@ void handle_IPI(int ipinr, struct pt_regs *regs) case IPI_CPU_STOP: irq_enter(); - local_cpu_stop(); + local_cpu_crash_or_stop(NULL); irq_exit(); break; case IPI_CPU_CRASH_STOP: if (IS_ENABLED(CONFIG_KEXEC_CORE)) { irq_enter(); - ipi_cpu_crash_stop(cpu, regs); + local_cpu_crash_or_stop(regs); unreachable(); } @@ -963,52 +957,10 @@ void arch_smp_stop_call(cpumask_t *cpus, unsigned int __unused) smp_cross_call(cpus, IPI_CPU_STOP); } -#ifdef CONFIG_KEXEC_CORE -void crash_smp_send_stop(void) +void arch_smp_crash_call(cpumask_t *cpus, unsigned int __unused) { - static int cpus_stopped; - cpumask_t mask; - unsigned long timeout; - - /* - * This function can be called twice in panic path, but obviously - * we execute this only once. - */ - if (cpus_stopped) - return; - - cpus_stopped = 1; - - if (num_online_cpus() == 1) { - sdei_mask_local_cpu(); - return; - } - - cpumask_copy(&mask, cpu_online_mask); - cpumask_clear_cpu(smp_processor_id(), &mask); - - atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); - - pr_crit("SMP: stopping secondary CPUs\n"); - smp_cross_call(&mask, IPI_CPU_CRASH_STOP); - - /* Wait up to one second for other CPUs to stop */ - timeout = USEC_PER_SEC; - while ((atomic_read(&waiting_for_crash_ipi) > 0) && timeout--) - udelay(1); - - if (atomic_read(&waiting_for_crash_ipi) > 0) - pr_warning("SMP: failed to stop secondary CPUs %*pbl\n", - cpumask_pr_args(&mask)); - - sdei_mask_local_cpu(); -} - -bool smp_crash_stop_failed(void) -{ - return (atomic_read(&waiting_for_crash_ipi) > 0); + smp_cross_call(cpus, IPI_CPU_CRASH_STOP); } -#endif /* * not supported here From patchwork Fri Sep 13 18:19:48 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145071 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C8CE51599 for ; Fri, 13 Sep 2019 18:22:51 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A7057206A5 for ; Fri, 13 Sep 2019 18:22:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="WSq1phtT" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A7057206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=NLIZ1FmHs+sZ4TTffzlvCT4iCfrKjn58eNqobUaYDfA=; b=WSq1phtTu6O24tdGjZn5e8VKQX 6fSRkw+XpC2kI9a5IhXVFhyhP5ccxtU3JgZeanAFGYN2ie5L36e90rzaKRwGs9Q76rXiQCwCkC18a wx0Ge81/5S0BL3MMnAaYBVbcL8bAkW7yMeb2tDKXjUfj6+Gb2ZLKRgLW8B/ZQwmADZ/cBM0CDAGGS vGS+SyJchKyycve2QAfQ9azpSx9rM/ezQpsjgV3VM/s7eclWDh/gJWAgge4wabUMd/OhtCMYyccl5 IvsK16G5h4HIHLLo/uHibGE7YSDvFpPNcljciKUJPz2BvNkp67lETrjXJab3Bmt4wzPpc5QbuvWXj 8pOj03QA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qDb-0006nf-3H; Fri, 13 Sep 2019 18:22:51 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBs-0005C4-AM for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:05 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E41D228; Fri, 13 Sep 2019 11:21:03 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 765133F71F; Fri, 13 Sep 2019 11:21:01 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 07/12] arm64: smp: add arch specific cpu parking helper Date: Fri, 13 Sep 2019 19:19:48 +0100 Message-Id: <20190913181953.45748-8-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112104_513988_B3E163A3 X-CRM114-Status: UNSURE ( 7.01 ) X-CRM114-Notice: Please train this message. X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add an arm64 specific helper which parks the cpu in a more architecture efficient way. Signed-off-by: Cristian Marussi --- arch/arm64/kernel/smp.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/arch/arm64/kernel/smp.c b/arch/arm64/kernel/smp.c index f0cc2bf84aaa..539e8db5c1ba 100644 --- a/arch/arm64/kernel/smp.c +++ b/arch/arm64/kernel/smp.c @@ -947,6 +947,12 @@ void tick_broadcast(const struct cpumask *mask) } #endif +void arch_smp_cpu_park(void) +{ + while (1) + cpu_park_loop(); +} + void arch_smp_cpus_stop_complete(void) { sdei_mask_local_cpu(); From patchwork Fri Sep 13 18:19:49 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145073 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6B99D912 for ; Fri, 13 Sep 2019 18:23:07 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 49D60206A5 for ; Fri, 13 Sep 2019 18:23:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="U9KihjBZ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 49D60206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=SSRh2j3P55uDwTANfuj7S72jzD+GJVs1sJrs8ukhb4Q=; b=U9KihjBZm9DQ12L2WLmL2bxlhm 57gWmzYsS73yhTvGc2aWr23/mPYvP7Z927bldU4E3Ie1H4SgcvqhY90aXTvQNs7EWrvtPnAzKQbZ7 h8LA809cmhI2Q/g/dcCIthFU7+IapvC7DZaNufL5R355DRXEF+2VkLHf6gNGbzZ2ydDOBsJ+g/Ph9 3Af09iS2bEW3Nt6hjQVChd+DnlfFgoZPPFjIbGfMikPFP+NvO1PtEsBSNdfCb+rNFlonoosjrGqA8 5xG6xrobb6jUW/LBVSBPpq7jp6PrOrSKbBVSPpfyXWVx2Z6yxqelq5F7YxRUlprVh72T7ZX0iLRqq YE9H93Qw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qDq-00071J-2U; Fri, 13 Sep 2019 18:23:06 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBu-0005Ek-UG for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:08 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 935531570; Fri, 13 Sep 2019 11:21:06 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 25A573F71F; Fri, 13 Sep 2019 11:21:04 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 08/12] x86: smp: use generic SMP stop common code Date: Fri, 13 Sep 2019 19:19:49 +0100 Message-Id: <20190913181953.45748-9-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112107_080141_D0347688 X-CRM114-Status: GOOD ( 18.90 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make x86 use the generic SMP-stop logic provided by common code unified smp_send_stop() function. Introduce needed arch_smp_stop_call()/arch_smp_cpus_stop_complete() helpers that implement the backend architectures specific functionalities previously provided by native_stop_other_cpus(): common logic is now delegated to common SMP stop code. Remove arch-specific smp_send_stop(), and redefine original function native_stop_other_cpus() to rely instead on the unified common code version of smp_send_stop(): native_stop_other_cpus() is anyway kept since it is wired to smp_ops.stop_other_cpus() which get called at reboot time with particular waiting settings. Signed-off-by: Cristian Marussi --- Note that in this patch we kept in use the original x86 local handling of 'stopping_cpu' variable: atomic_cmpxchg(&stopping_cpu, -1, safe_smp_processor_id()); Instead, common SMP stop code could have been easily extended to keep and expose to architectures backends such value using some additional helper like smp_stop_get_stopping_cpu_id(). This has not been addressed in this series. --- arch/x86/Kconfig | 1 + arch/x86/include/asm/smp.h | 5 -- arch/x86/kernel/smp.c | 95 ++++++++++++++++---------------------- 3 files changed, 41 insertions(+), 60 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 222855cc0158..0fcee2f03a5b 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -92,6 +92,7 @@ config X86 select ARCH_USE_BUILTIN_BSWAP select ARCH_USE_QUEUED_RWLOCKS select ARCH_USE_QUEUED_SPINLOCKS + select ARCH_USE_COMMON_SMP_STOP select ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH select ARCH_WANTS_DYNAMIC_TASK_STRUCT select ARCH_WANT_HUGE_PMD_SHARE diff --git a/arch/x86/include/asm/smp.h b/arch/x86/include/asm/smp.h index e1356a3b8223..5cf590259d68 100644 --- a/arch/x86/include/asm/smp.h +++ b/arch/x86/include/asm/smp.h @@ -67,11 +67,6 @@ extern void set_cpu_sibling_map(int cpu); #ifdef CONFIG_SMP extern struct smp_ops smp_ops; -static inline void smp_send_stop(void) -{ - smp_ops.stop_other_cpus(0); -} - static inline void stop_other_cpus(void) { smp_ops.stop_other_cpus(1); diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c index 96421f97e75c..0942cae46fee 100644 --- a/arch/x86/kernel/smp.c +++ b/arch/x86/kernel/smp.c @@ -179,78 +179,63 @@ asmlinkage __visible void smp_reboot_interrupt(void) irq_exit(); } -static void native_stop_other_cpus(int wait) +void arch_smp_stop_call(cpumask_t *cpus, unsigned int attempt_num) { - unsigned long flags; - unsigned long timeout; - if (reboot_force) return; - /* - * Use an own vector here because smp_call_function - * does lots of things not suitable in a panic situation. - */ - - /* - * We start by using the REBOOT_VECTOR irq. - * The irq is treated as a sync point to allow critical - * regions of code on other cpus to release their spin locks - * and re-enable irqs. Jumping straight to an NMI might - * accidentally cause deadlocks with further shutdown/panic - * code. By syncing, we give the cpus up to one second to - * finish their work before we force them off with the NMI. - */ - if (num_online_cpus() > 1) { - /* did someone beat us here? */ - if (atomic_cmpxchg(&stopping_cpu, -1, safe_smp_processor_id()) != -1) - return; - - /* sync above data before sending IRQ */ - wmb(); - - apic->send_IPI_allbutself(REBOOT_VECTOR); - + if (attempt_num == 1) { /* - * Don't wait longer than a second if the caller - * didn't ask us to wait. + * We start by using the REBOOT_VECTOR irq. + * The irq is treated as a sync point to allow critical + * regions of code on other cpus to release their spin locks + * and re-enable irqs. Jumping straight to an NMI might + * accidentally cause deadlocks with further shutdown/panic + * code. By syncing, we give the cpus up to one second to + * finish their work before we force them off with the NMI. */ - timeout = USEC_PER_SEC; - while (num_online_cpus() > 1 && (wait || timeout--)) - udelay(1); - } - - /* if the REBOOT_VECTOR didn't work, try with the NMI */ - if ((num_online_cpus() > 1) && (!smp_no_nmi_ipi)) { - if (register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback, - NMI_FLAG_FIRST, "smp_stop")) - /* Note: we ignore failures here */ - /* Hope the REBOOT_IRQ is good enough */ - goto finish; + + /* Used by NMI handler callback to skip the stopping_cpu. */ + atomic_cmpxchg(&stopping_cpu, -1, safe_smp_processor_id()); /* sync above data before sending IRQ */ wmb(); - - pr_emerg("Shutting down cpus with NMI\n"); - - apic->send_IPI_allbutself(NMI_VECTOR); - - /* - * Don't wait longer than a 10 ms if the caller - * didn't ask us to wait. - */ - timeout = USEC_PER_MSEC * 10; - while (num_online_cpus() > 1 && (wait || timeout--)) - udelay(1); + apic->send_IPI_mask(cpus, REBOOT_VECTOR); + } else if (attempt_num > 1 && !smp_no_nmi_ipi) { + /* if the REBOOT_VECTOR didn't work, try with the NMI */ + + /* Don't wait longer than 10 ms when not asked to wait */ + smp_stop_set_wait_timeout_us(USEC_PER_MSEC * 10); + + /* Note: we ignore failures here */ + /* Hope the REBOOT_IRQ was good enough */ + if (!register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback, + NMI_FLAG_FIRST, "smp_stop")) { + /* sync above data before sending IRQ */ + wmb(); + pr_emerg("Shutting down cpus with NMI\n"); + apic->send_IPI_mask(cpus, NMI_VECTOR); + } } +} + +void arch_smp_cpus_stop_complete(void) +{ + unsigned long flags; -finish: local_irq_save(flags); disable_local_APIC(); mcheck_cpu_clear(this_cpu_ptr(&cpu_info)); local_irq_restore(flags); } +static void native_stop_other_cpus(int wait) +{ + smp_stop_set_wait_forever(wait); + /* use common SMP stop code */ + smp_send_stop(); +} + /* * Reschedule call back. KVM uses this interrupt to force a cpu out of * guest mode From patchwork Fri Sep 13 18:19:50 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145075 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E065A912 for ; Fri, 13 Sep 2019 18:23:26 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BDADB206A5 for ; Fri, 13 Sep 2019 18:23:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="XLr+7pEI" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BDADB206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=QoFFKFyRSDJKG21bJUCBrfEYtWbA8387YO2olz6KSWk=; b=XLr+7pEIJODt5vrIzyAIe1OOPd nBS11HeXk9JVPtgCENfAMqF7cXAJILjHmv+1c6Yw4vr4lVThhIJ65nK9nGoJtN3p8xHUZQsi0mbJw AL4o+t1iyzoJDWuMG2iSePtNbWO82JY/XJRsZ+B91Sp5rAIEyla1fxLobAAGAVyjDuJuVWRg1Xr1E yW3t32LOwbwRv14Njtn7pqx864ipULASykCAH/4FmXwnFP+Nq/d7bI0EZZq8akEzD5fbA+p0eLPTo 129i5yItQfns2/IxiK6pSgfaD7WjUBYTrfdjjnBf7YHeOsiOlLgzSkd8BQBuw2lFyAjva9CGN3Ov+ H/Eb7QIg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qE5-0007FY-0B; Fri, 13 Sep 2019 18:23:21 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qBx-0005Ib-VW for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:12 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 430AC28; Fri, 13 Sep 2019 11:21:09 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id C94E53F71F; Fri, 13 Sep 2019 11:21:06 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 09/12] x86: smp: use SMP crash-stop common code Date: Fri, 13 Sep 2019 19:19:50 +0100 Message-Id: <20190913181953.45748-10-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112110_296046_95DD0BAE X-CRM114-Status: GOOD ( 18.83 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make x86 use the SMP common implementation of crash_smp_send_stop() and its generic logic, by removing the x86 crash_smp_send_stop() definition and providing the needed arch specific helpers. Remove also redundant smp_ops.crash_stop_other_cpus(); add shared util function common_nmi_shootdown_cpus(), which is a generalization of the previous nmi_shootdown_cpus(), and it is used by architecture backend helper arch_smp_crash_call(). Modify original crash_nmi_callback() to properly set cpu offline flag and adding needed memory barriers. Modify original nmi_shootdown_cpus() to rely on common code logic provided by generic crash_smp_send_stop(): this was needed because the original nmi_shootdown_cpus() was used also on the emergency reboot path, employing a different callback. Reuse the same shootdown_callback mechanism to properly handle both a crash and an emergency reboot through the same common code crash path. Signed-off-by: Cristian Marussi --- Note that in this patch we kept in use the original x86 local handling of 'crashing_cpu' variable: crashing_cpu = safe_smp_processor_id(); Instead, common SMP stop code could have been easily extended to keep and expose to architectures backends such value using some additional helper like smp_stop_get_stopping_cpu_id(). This has not been addressed in this series. --- arch/x86/include/asm/reboot.h | 2 ++ arch/x86/include/asm/smp.h | 1 - arch/x86/kernel/crash.c | 27 ++++--------------- arch/x86/kernel/reboot.c | 50 ++++++++++++++++++++++------------- arch/x86/kernel/smp.c | 3 --- 5 files changed, 38 insertions(+), 45 deletions(-) diff --git a/arch/x86/include/asm/reboot.h b/arch/x86/include/asm/reboot.h index 04c17be9b5fd..a1a9cbed6df5 100644 --- a/arch/x86/include/asm/reboot.h +++ b/arch/x86/include/asm/reboot.h @@ -3,6 +3,7 @@ #define _ASM_X86_REBOOT_H #include +#include struct pt_regs; @@ -28,6 +29,7 @@ void __noreturn machine_real_restart(unsigned int type); typedef void (*nmi_shootdown_cb)(int, struct pt_regs*); void nmi_panic_self_stop(struct pt_regs *regs); void nmi_shootdown_cpus(nmi_shootdown_cb callback); +void common_nmi_shootdown_cpus(cpumask_t *cpus, nmi_shootdown_cb callback); void run_crash_ipi_callback(struct pt_regs *regs); #endif /* _ASM_X86_REBOOT_H */ diff --git a/arch/x86/include/asm/smp.h b/arch/x86/include/asm/smp.h index 5cf590259d68..684643ad71e4 100644 --- a/arch/x86/include/asm/smp.h +++ b/arch/x86/include/asm/smp.h @@ -49,7 +49,6 @@ struct smp_ops { void (*smp_cpus_done)(unsigned max_cpus); void (*stop_other_cpus)(int wait); - void (*crash_stop_other_cpus)(void); void (*smp_send_reschedule)(int cpu); int (*cpu_up)(unsigned cpu, struct task_struct *tidle); diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c index 2bf70a2fed90..8fff06c7cd26 100644 --- a/arch/x86/kernel/crash.c +++ b/arch/x86/kernel/crash.c @@ -96,34 +96,16 @@ static void kdump_nmi_callback(int cpu, struct pt_regs *regs) disable_local_APIC(); } -void kdump_nmi_shootdown_cpus(void) +void arch_smp_crash_call(cpumask_t *cpus, unsigned int __unused) { - nmi_shootdown_cpus(kdump_nmi_callback); - - disable_local_APIC(); + common_nmi_shootdown_cpus(cpus, kdump_nmi_callback); } -/* Override the weak function in kernel/panic.c */ -void crash_smp_send_stop(void) +void arch_smp_cpus_crash_complete(void) { - static int cpus_stopped; - - if (cpus_stopped) - return; - - if (smp_ops.crash_stop_other_cpus) - smp_ops.crash_stop_other_cpus(); - else - smp_send_stop(); - - cpus_stopped = 1; + disable_local_APIC(); } -#else -void crash_smp_send_stop(void) -{ - /* There are no cpus to shootdown */ -} #endif void native_machine_crash_shutdown(struct pt_regs *regs) @@ -139,6 +121,7 @@ void native_machine_crash_shutdown(struct pt_regs *regs) /* The kernel is broken so disable interrupts */ local_irq_disable(); + /* calling into SMP common stop code */ crash_smp_send_stop(); /* diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c index 09d6bded3c1e..69f894e28fec 100644 --- a/arch/x86/kernel/reboot.c +++ b/arch/x86/kernel/reboot.c @@ -799,7 +799,6 @@ int crashing_cpu = -1; static nmi_shootdown_cb shootdown_callback; -static atomic_t waiting_for_crash_ipi; static int crash_ipi_issued; static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) @@ -819,7 +818,12 @@ static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) shootdown_callback(cpu, regs); - atomic_dec(&waiting_for_crash_ipi); + /* ensure all shootdown writes are visible once cpu is seen offline */ + smp_wmb(); + set_cpu_online(cpu, false); + /* ensure all writes are globally visible before cpu parks */ + wmb(); + /* Assume hlt works */ halt(); for (;;) @@ -828,29 +832,44 @@ static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) return NMI_HANDLED; } -static void smp_send_nmi_allbutself(void) -{ - apic->send_IPI_allbutself(NMI_VECTOR); -} - /* * Halt all other CPUs, calling the specified function on each of them * * This function can be used to halt all other CPUs on crash * or emergency reboot time. The function passed as parameter * will be called inside a NMI handler on all CPUs. + * + * It relies on crash_smp_send_stop() common code logic to shutdown CPUs. */ void nmi_shootdown_cpus(nmi_shootdown_cb callback) { - unsigned long msecs; + local_irq_disable(); + + shootdown_callback = callback; + /* ensure callback in place before calling into common crash code */ + wmb(); + /* call into common SMP Crash Stop to reuse the logic */ + crash_smp_send_stop(); +} + +/* + * Halt the specified @cpus, calling the provided @callback on each of them + * unless a shootdown_callback was already installed previously: this way + * we can handle here also the emergency reboot requests issued via + * nmi_shootdown_cpus() and routed via usual common code crash_smp_send_stop() + * + * Called by arch_smp_crash_call() arch-helper. + */ +void common_nmi_shootdown_cpus(cpumask_t *cpus, nmi_shootdown_cb callback) +{ local_irq_disable(); /* Make a note of crashing cpu. Will be used in NMI callback. */ crashing_cpu = safe_smp_processor_id(); - shootdown_callback = callback; - - atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); + /* skip when the callback has been already set by nmi_shootdown_cpus */ + if (!shootdown_callback) + shootdown_callback = callback; /* Would it be better to replace the trap vector here? */ if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, NMI_FLAG_FIRST, "crash")) @@ -860,18 +879,11 @@ void nmi_shootdown_cpus(nmi_shootdown_cb callback) * out the NMI */ wmb(); - - smp_send_nmi_allbutself(); + apic->send_IPI_mask(cpus, NMI_VECTOR); /* Kick CPUs looping in NMI context. */ WRITE_ONCE(crash_ipi_issued, 1); - msecs = 1000; /* Wait at most a second for the other cpus to stop */ - while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { - mdelay(1); - msecs--; - } - /* Leave the nmi callback set */ } diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c index 0942cae46fee..d718b185c6a9 100644 --- a/arch/x86/kernel/smp.c +++ b/arch/x86/kernel/smp.c @@ -295,9 +295,6 @@ struct smp_ops smp_ops = { .smp_cpus_done = native_smp_cpus_done, .stop_other_cpus = native_stop_other_cpus, -#if defined(CONFIG_KEXEC_CORE) - .crash_stop_other_cpus = kdump_nmi_shootdown_cpus, -#endif .smp_send_reschedule = native_smp_send_reschedule, .cpu_up = native_cpu_up, From patchwork Fri Sep 13 18:19:51 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145077 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 98036912 for ; Fri, 13 Sep 2019 18:23:37 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 763D6206A5 for ; Fri, 13 Sep 2019 18:23:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ld5C/ZPc" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 763D6206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=j1H9bAfK/Whgt/v5klUXYNOwSGXM3J11/apYQHwfR7k=; b=ld5C/ZPc2ThQSIx6Qn5SwwVJZg Lb6zBtx4BoeIVHDVrMN6rz4enpwC96lLZh1hmpbgka00vQTpMxcPiaTZitOg7ZWcocv1AmXW1QxEj kxwCDYKWE3lvFRngslUp7LP4YBLc7l7ni5H4Co7vpJTw2jvu7+1rR6Duq6qLwKbnQLYXK565wkare fIoc3TpPgpY5ZPtsTIk3jlKtnwSmax/Al1ISa/xg7UaxjX5SiyG3nh31DxccACKNMOuARPLZ/+VW3 m2cJL9JbXAjAkIYjWbpQHKupaxiKi+x5O7FM9wQoybEn3K0wOy7rvWGZRk26wCZuKU6/A+mXq08SA zrdaRcuQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qEK-0007UG-Uf; Fri, 13 Sep 2019 18:23:37 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qC0-0005Ke-8E for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:13 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E67231570; Fri, 13 Sep 2019 11:21:11 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 78C773F71F; Fri, 13 Sep 2019 11:21:09 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 10/12] arm: smp: use generic SMP stop common code Date: Fri, 13 Sep 2019 19:19:51 +0100 Message-Id: <20190913181953.45748-11-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112112_498008_C0C3A886 X-CRM114-Status: GOOD ( 11.62 ) X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make arm use the generic SMP-stop logic provided by common code unified smp_send_stop() function. Signed-off-by: Cristian Marussi --- arch/arm/Kconfig | 1 + arch/arm/kernel/smp.c | 18 ++---------------- 2 files changed, 3 insertions(+), 16 deletions(-) diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 24360211534a..0a3a9c9a0b2e 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -34,6 +34,7 @@ config ARM select ARCH_SUPPORTS_ATOMIC_RMW select ARCH_USE_BUILTIN_BSWAP select ARCH_USE_CMPXCHG_LOCKREF + select ARCH_USE_COMMON_SMP_STOP select ARCH_WANT_IPC_PARSE_VERSION select BINFMT_FLAT_ARGVP_ENVP_ON_STACK select BUILDTIME_EXTABLE_SORT if MMU diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c index aab8ba40ce38..bf5c04691fab 100644 --- a/arch/arm/kernel/smp.c +++ b/arch/arm/kernel/smp.c @@ -703,23 +703,9 @@ void smp_send_reschedule(int cpu) smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE); } -void smp_send_stop(void) +void arch_smp_stop_call(cpumask_t *cpus, unsigned int __unused) { - unsigned long timeout; - struct cpumask mask; - - cpumask_copy(&mask, cpu_online_mask); - cpumask_clear_cpu(smp_processor_id(), &mask); - if (!cpumask_empty(&mask)) - smp_cross_call(&mask, IPI_CPU_STOP); - - /* Wait up to one second for other CPUs to stop */ - timeout = USEC_PER_SEC; - while (num_online_cpus() > 1 && timeout--) - udelay(1); - - if (num_online_cpus() > 1) - pr_warn("SMP: failed to stop secondary CPUs\n"); + smp_cross_call(cpus, IPI_CPU_STOP); } /* In case panic() and panic() called at the same time on CPU1 and CPU2, From patchwork Fri Sep 13 18:19:52 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145079 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id BF0041599 for ; Fri, 13 Sep 2019 18:23:57 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9D6F1206A5 for ; Fri, 13 Sep 2019 18:23:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="IE74zwY3" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9D6F1206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=BiUduIca3PqIIqIOyS2T9uD6w43a1bldL4Yr57HmAKg=; b=IE74zwY3JEt4VquLGJnhQwObMr SmOn/v+UmIBNbD4duMGmkn9jM6aoakRoWEhHze5D248EIN7+14YDl2LNzapXXL2y450pnwGsb7is8 LhFF6yFkb7xhVDjqOVxLDDqI9lQCWP/3zxz2GzwtTTi1m/aTOU0UKOPeIs6rth41LvENB0Iyg1r72 TS8dLZqURbi52I8KUIfkPLf8LSxN+Oo0843tqCBx4bYO50hy4LpFslufH1JqUnE/7YcYUPA4HuU4e vXh7Jf2m0Rph5IGaeMmY0oKQFLEfliRnn0W33EiBA0P/Cw9pA5dUhGLiesdmSy6VeBwh5+fdXkJbw piH40z1Q==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qEe-0007mO-7K; Fri, 13 Sep 2019 18:23:56 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qC2-0005NE-Qn for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:16 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 955F115A2; Fri, 13 Sep 2019 11:21:14 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 281FD3F71F; Fri, 13 Sep 2019 11:21:12 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 11/12] arm: smp: use SMP crash-stop common code Date: Fri, 13 Sep 2019 19:19:52 +0100 Message-Id: <20190913181953.45748-12-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112115_172616_E83FF1F2 X-CRM114-Status: UNSURE ( 9.75 ) X-CRM114-Notice: Please train this message. X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make arm use the SMP common implementation of crash_smp_send_stop() and its generic logic, by removing the arm crash_smp_send_stop() definition and providing the needed arch specific helpers. Signed-off-by: Cristian Marussi --- arch/arm/kernel/machine_kexec.c | 27 ++++++--------------------- 1 file changed, 6 insertions(+), 21 deletions(-) diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c index 76300f3813e8..d53973cae362 100644 --- a/arch/arm/kernel/machine_kexec.c +++ b/arch/arm/kernel/machine_kexec.c @@ -29,8 +29,6 @@ extern unsigned long kexec_indirection_page; extern unsigned long kexec_mach_type; extern unsigned long kexec_boot_atags; -static atomic_t waiting_for_crash_ipi; - /* * Provide a dummy crash_notes definition while crash dump arrives to arm. * This prevents breakage of crash_notes attribute in kernel/ksysfs.c. @@ -89,34 +87,21 @@ void machine_crash_nonpanic_core(void *unused) crash_save_cpu(®s, smp_processor_id()); flush_cache_all(); + /* ensure saved regs writes are visible before going offline */ + smp_wmb(); set_cpu_online(smp_processor_id(), false); - atomic_dec(&waiting_for_crash_ipi); + /* ensure all writes visible before parking */ + wmb(); while (1) { cpu_relax(); wfe(); } } -void crash_smp_send_stop(void) +void arch_smp_crash_call(cpumask_t *cpus, unsigned int __unused) { - static int cpus_stopped; - unsigned long msecs; - - if (cpus_stopped) - return; - - atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); - smp_call_function(machine_crash_nonpanic_core, NULL, false); - msecs = 1000; /* Wait at most a second for the other cpus to stop */ - while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { - mdelay(1); - msecs--; - } - if (atomic_read(&waiting_for_crash_ipi) > 0) - pr_warn("Non-crashing CPUs did not react to IPI\n"); - - cpus_stopped = 1; + smp_call_function_many(cpus, machine_crash_nonpanic_core, NULL, false); } static void machine_kexec_mask_interrupts(void) From patchwork Fri Sep 13 18:19:53 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11145081 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 4B870912 for ; Fri, 13 Sep 2019 18:24:16 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 29D71206A5 for ; Fri, 13 Sep 2019 18:24:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="uUICvAeQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 29D71206A5 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=yC1rEYIfUBKGOxXkve+zcbmjz+PAGcfuQ/YX238WGeg=; b=uUICvAeQNxXAXY5BRwaxHKSn1T MOspfa3a3n+1rqidn7kaVQO8GLcuWTxT1TIFlpp2SVJGz75jbpVnJ9fsp+0JLrdbaDq/MKbpekFbD 0nBcSj30viWvC0nhF+tZ88PaKF9x1HR5/wstDK8MqPYzfd09RYefwHQJuErdZyiNxC4gANL3y9rZY IC7h+mHOMUrYyKR3FZMbL9xq7oGer3AviDGV/sWmpji13eNP16LBRP4hFUNbY9jAzAZf8S0xcB9HM sVY5u9TW7aEHIXAIifY4nHBGSooEdByJX38RNM+c55kL8iD0Rm6mdINKUCtuXlU9bGFxpSPQrNify GalWGTBA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qEs-00081N-Pa; Fri, 13 Sep 2019 18:24:10 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1i8qC5-0005QS-HY for linux-arm-kernel@lists.infradead.org; Fri, 13 Sep 2019 18:21:18 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 455AC28; Fri, 13 Sep 2019 11:21:17 -0700 (PDT) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id CBF3B3F71F; Fri, 13 Sep 2019 11:21:14 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org Subject: [RFC PATCH v2 12/12] sparc64: smp: use generic SMP stop common code Date: Fri, 13 Sep 2019 19:19:53 +0100 Message-Id: <20190913181953.45748-13-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190913181953.45748-1-cristian.marussi@arm.com> References: <20190913181953.45748-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190913_112117_801070_DF20ED65 X-CRM114-Status: UNSURE ( 9.82 ) X-CRM114-Notice: Please train this message. X-Spam-Score: 0.0 (/) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (0.0 points) pts rule name description ---- ---------------------- -------------------------------------------------- 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, mark.rutland@arm.com, sparclinux@vger.kernel.org, dzickus@redhat.com, ehabkost@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, x86@kernel.org, linux@armlinux.org.uk, davem@davemloft.net, hch@infradead.org, takahiro.akashi@linaro.org, mingo@redhat.com, james.morse@arm.com, hidehiro.kawai.ez@hitachi.com, tglx@linutronix.de, will@kernel.org, dave.martin@arm.com, linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make sparc64 use the generic SMP-stop logic provided by common code unified smp_send_stop() function. Signed-off-by: Cristian Marussi --- arch/sparc/Kconfig | 1 + arch/sparc/kernel/smp_64.c | 15 ++++++++------- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig index 7926a2e11bdc..67d8bb741378 100644 --- a/arch/sparc/Kconfig +++ b/arch/sparc/Kconfig @@ -95,6 +95,7 @@ config SPARC64 select ARCH_HAS_PTE_SPECIAL select PCI_DOMAINS if PCI select ARCH_HAS_GIGANTIC_PAGE + select ARCH_USE_COMMON_SMP_STOP config ARCH_DEFCONFIG string diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c index a8275fea4b70..759e5fd867c5 100644 --- a/arch/sparc/kernel/smp_64.c +++ b/arch/sparc/kernel/smp_64.c @@ -1537,7 +1537,12 @@ static void stop_this_cpu(void *dummy) prom_stopself(); } -void smp_send_stop(void) +void arch_smp_cpus_stop_complete(void) +{ + smp_call_function(stop_this_cpu, NULL, 0); +} + +void arch_smp_stop_call(cpumask_t *cpus, unsigned int __unused) { int cpu; @@ -1546,10 +1551,7 @@ void smp_send_stop(void) #ifdef CONFIG_SERIAL_SUNHV sunhv_migrate_hvcons_irq(this_cpu); #endif - for_each_online_cpu(cpu) { - if (cpu == this_cpu) - continue; - + for_each_cpu(cpu, cpus) { set_cpu_online(cpu, false); #ifdef CONFIG_SUN_LDOMS if (ldom_domaining_enabled) { @@ -1562,8 +1564,7 @@ void smp_send_stop(void) #endif prom_stopcpu_cpuid(cpu); } - } else - smp_call_function(stop_this_cpu, NULL, 0); + } } /**