From patchwork Wed Mar 4 06:32:07 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 11419347 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 3D03C17E0 for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 21370215A4 for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 21370215A4 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9NZr-0001su-2t; Wed, 04 Mar 2020 06:32:19 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9NZp-0001sp-DV for xen-devel@lists.xenproject.org; Wed, 04 Mar 2020 06:32:17 +0000 X-Inumbo-ID: e3c62316-5de1-11ea-b52f-bc764e2007e4 Received: from mx2.suse.de (unknown [195.135.220.15]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id e3c62316-5de1-11ea-b52f-bc764e2007e4; Wed, 04 Mar 2020 06:32:16 +0000 (UTC) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id E2443AF8E; Wed, 4 Mar 2020 06:32:14 +0000 (UTC) From: Juergen Gross To: xen-devel@lists.xenproject.org Date: Wed, 4 Mar 2020 07:32:07 +0100 Message-Id: <20200304063212.20843-2-jgross@suse.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20200304063212.20843-1-jgross@suse.com> References: <20200304063212.20843-1-jgross@suse.com> Subject: [Xen-devel] [PATCH v3 1/6] xen/rcu: use rcu softirq for forcing quiescent state X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Stefano Stabellini , Julien Grall , Wei Liu , Andrew Cooper , Ian Jackson , George Dunlap , Jan Beulich MIME-Version: 1.0 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" As rcu callbacks are processed in __do_softirq() there is no need to use the scheduling softirq for forcing quiescent state. Any other softirq would do the job and the scheduling one is the most expensive. So use the already existing rcu softirq for that purpose. For telling apart why the rcu softirq was raised add a flag for the current usage. Signed-off-by: Juergen Gross Acked-by: Andrew Cooper --- xen/common/rcupdate.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/xen/common/rcupdate.c b/xen/common/rcupdate.c index d76b991627..03d84764d2 100644 --- a/xen/common/rcupdate.c +++ b/xen/common/rcupdate.c @@ -89,6 +89,8 @@ struct rcu_data { /* 3) idle CPUs handling */ struct timer idle_timer; bool idle_timer_active; + + bool process_callbacks; }; /* @@ -198,7 +200,7 @@ static void force_quiescent_state(struct rcu_data *rdp, struct rcu_ctrlblk *rcp) { cpumask_t cpumask; - raise_softirq(SCHEDULE_SOFTIRQ); + raise_softirq(RCU_SOFTIRQ); if (unlikely(rdp->qlen - rdp->last_rs_qlen > rsinterval)) { rdp->last_rs_qlen = rdp->qlen; /* @@ -206,7 +208,7 @@ static void force_quiescent_state(struct rcu_data *rdp, * rdp->cpu is the current cpu. */ cpumask_andnot(&cpumask, &rcp->cpumask, cpumask_of(rdp->cpu)); - cpumask_raise_softirq(&cpumask, SCHEDULE_SOFTIRQ); + cpumask_raise_softirq(&cpumask, RCU_SOFTIRQ); } } @@ -263,7 +265,10 @@ static void rcu_do_batch(struct rcu_data *rdp) if (!rdp->donelist) rdp->donetail = &rdp->donelist; else + { + rdp->process_callbacks = true; raise_softirq(RCU_SOFTIRQ); + } } /* @@ -414,7 +419,13 @@ static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp, static void rcu_process_callbacks(void) { - __rcu_process_callbacks(&rcu_ctrlblk, &this_cpu(rcu_data)); + struct rcu_data *rdp = &this_cpu(rcu_data); + + if ( rdp->process_callbacks ) + { + rdp->process_callbacks = false; + __rcu_process_callbacks(&rcu_ctrlblk, rdp); + } } static int __rcu_pending(struct rcu_ctrlblk *rcp, struct rcu_data *rdp) @@ -522,6 +533,9 @@ static void rcu_idle_timer_handler(void* data) void rcu_check_callbacks(int cpu) { + struct rcu_data *rdp = &this_cpu(rcu_data); + + rdp->process_callbacks = true; raise_softirq(RCU_SOFTIRQ); } From patchwork Wed Mar 4 06:32:08 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 11419351 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 8CCA018B8 for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 731F9214D8 for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 731F9214D8 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9Na0-0001uA-4V; Wed, 04 Mar 2020 06:32:28 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9NZz-0001tt-6a for xen-devel@lists.xenproject.org; Wed, 04 Mar 2020 06:32:27 +0000 X-Inumbo-ID: e3d5bcb8-5de1-11ea-b52f-bc764e2007e4 Received: from mx2.suse.de (unknown [195.135.220.15]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id e3d5bcb8-5de1-11ea-b52f-bc764e2007e4; Wed, 04 Mar 2020 06:32:16 +0000 (UTC) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 25C92AFB2; Wed, 4 Mar 2020 06:32:15 +0000 (UTC) From: Juergen Gross To: xen-devel@lists.xenproject.org Date: Wed, 4 Mar 2020 07:32:08 +0100 Message-Id: <20200304063212.20843-3-jgross@suse.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20200304063212.20843-1-jgross@suse.com> References: <20200304063212.20843-1-jgross@suse.com> Subject: [Xen-devel] [PATCH v3 2/6] xen/rcu: don't use stop_machine_run() for rcu_barrier() X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Stefano Stabellini , Julien Grall , Wei Liu , Andrew Cooper , Ian Jackson , George Dunlap , Jan Beulich MIME-Version: 1.0 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" Today rcu_barrier() is calling stop_machine_run() to synchronize all physical cpus in order to ensure all pending rcu calls have finished when returning. As stop_machine_run() is using tasklets this requires scheduling of idle vcpus on all cpus imposing the need to call rcu_barrier() on idle cpus only in case of core scheduling being active, as otherwise a scheduling deadlock would occur. There is no need at all to do the syncing of the cpus in tasklets, as rcu activity is started in __do_softirq() called whenever softirq activity is allowed. So rcu_barrier() can easily be modified to use softirq for synchronization of the cpus no longer requiring any scheduling activity. As there already is a rcu softirq reuse that for the synchronization. Remove the barrier element from struct rcu_data as it isn't used. Finally switch rcu_barrier() to return void as it now can never fail. Partially-based-on-patch-by: Igor Druzhinin Signed-off-by: Juergen Gross --- V2: - add recursion detection V3: - fix races (Igor Druzhinin) --- xen/common/rcupdate.c | 85 +++++++++++++++++++++++++++++++--------------- xen/include/xen/rcupdate.h | 2 +- 2 files changed, 59 insertions(+), 28 deletions(-) diff --git a/xen/common/rcupdate.c b/xen/common/rcupdate.c index 03d84764d2..27d597bbeb 100644 --- a/xen/common/rcupdate.c +++ b/xen/common/rcupdate.c @@ -83,7 +83,6 @@ struct rcu_data { struct rcu_head **donetail; long blimit; /* Upper limit on a processed batch */ int cpu; - struct rcu_head barrier; long last_rs_qlen; /* qlen during the last resched */ /* 3) idle CPUs handling */ @@ -91,6 +90,7 @@ struct rcu_data { bool idle_timer_active; bool process_callbacks; + bool barrier_active; }; /* @@ -143,51 +143,75 @@ static int qhimark = 10000; static int qlowmark = 100; static int rsinterval = 1000; -struct rcu_barrier_data { - struct rcu_head head; - atomic_t *cpu_count; -}; +/* + * rcu_barrier() handling: + * cpu_count holds the number of cpu required to finish barrier handling. + * Cpus are synchronized via softirq mechanism. rcu_barrier() is regarded to + * be active if cpu_count is not zero. In case rcu_barrier() is called on + * multiple cpus it is enough to check for cpu_count being not zero on entry + * and to call process_pending_softirqs() in a loop until cpu_count drops to + * zero, as syncing has been requested already and we don't need to sync + * multiple times. + * In order to avoid hangs when rcu_barrier() is called mutiple times on the + * same cpu in fast sequence and a slave cpu couldn't drop out of the + * barrier handling fast enough a second counter done_count is needed. + */ +static atomic_t cpu_count = ATOMIC_INIT(0); +static atomic_t done_count = ATOMIC_INIT(0); static void rcu_barrier_callback(struct rcu_head *head) { - struct rcu_barrier_data *data = container_of( - head, struct rcu_barrier_data, head); - atomic_inc(data->cpu_count); + atomic_dec(&cpu_count); } -static int rcu_barrier_action(void *_cpu_count) +static void rcu_barrier_action(void) { - struct rcu_barrier_data data = { .cpu_count = _cpu_count }; - - ASSERT(!local_irq_is_enabled()); - local_irq_enable(); + struct rcu_head head; /* * When callback is executed, all previously-queued RCU work on this CPU - * is completed. When all CPUs have executed their callback, data.cpu_count - * will have been incremented to include every online CPU. + * is completed. When all CPUs have executed their callback, cpu_count + * will have been decremented to 0. */ - call_rcu(&data.head, rcu_barrier_callback); + call_rcu(&head, rcu_barrier_callback); - while ( atomic_read(data.cpu_count) != num_online_cpus() ) + while ( atomic_read(&cpu_count) ) { process_pending_softirqs(); cpu_relax(); } - local_irq_disable(); - - return 0; + atomic_dec(&done_count); } -/* - * As rcu_barrier() is using stop_machine_run() it is allowed to be used in - * idle context only (see comment for stop_machine_run()). - */ -int rcu_barrier(void) +void rcu_barrier(void) { - atomic_t cpu_count = ATOMIC_INIT(0); - return stop_machine_run(rcu_barrier_action, &cpu_count, NR_CPUS); + unsigned int n_cpus; + + while ( !get_cpu_maps() ) + { + process_pending_softirqs(); + if ( !atomic_read(&cpu_count) ) + return; + + cpu_relax(); + } + + n_cpus = num_online_cpus(); + + if ( atomic_cmpxchg(&cpu_count, 0, n_cpus) == 0 ) + { + atomic_add(n_cpus, &done_count); + cpumask_raise_softirq(&cpu_online_map, RCU_SOFTIRQ); + } + + while ( atomic_read(&done_count) ) + { + process_pending_softirqs(); + cpu_relax(); + } + + put_cpu_maps(); } /* Is batch a before batch b ? */ @@ -426,6 +450,13 @@ static void rcu_process_callbacks(void) rdp->process_callbacks = false; __rcu_process_callbacks(&rcu_ctrlblk, rdp); } + + if ( atomic_read(&cpu_count) && !rdp->barrier_active ) + { + rdp->barrier_active = true; + rcu_barrier_action(); + rdp->barrier_active = false; + } } static int __rcu_pending(struct rcu_ctrlblk *rcp, struct rcu_data *rdp) diff --git a/xen/include/xen/rcupdate.h b/xen/include/xen/rcupdate.h index 174d058113..87f35b7704 100644 --- a/xen/include/xen/rcupdate.h +++ b/xen/include/xen/rcupdate.h @@ -143,7 +143,7 @@ void rcu_check_callbacks(int cpu); void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *head)); -int rcu_barrier(void); +void rcu_barrier(void); void rcu_idle_enter(unsigned int cpu); void rcu_idle_exit(unsigned int cpu); From patchwork Wed Mar 4 06:32:11 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 11419357 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 A66A3191F for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 8C6C221739 for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8C6C221739 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9NaF-000212-0B; Wed, 04 Mar 2020 06:32:43 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9NaE-00020b-6h for xen-devel@lists.xenproject.org; Wed, 04 Mar 2020 06:32:42 +0000 X-Inumbo-ID: e4a0c156-5de1-11ea-b52f-bc764e2007e4 Received: from mx2.suse.de (unknown [195.135.220.15]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id e4a0c156-5de1-11ea-b52f-bc764e2007e4; Wed, 04 Mar 2020 06:32:17 +0000 (UTC) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id DCC15B22B; Wed, 4 Mar 2020 06:32:15 +0000 (UTC) From: Juergen Gross To: xen-devel@lists.xenproject.org Date: Wed, 4 Mar 2020 07:32:11 +0100 Message-Id: <20200304063212.20843-6-jgross@suse.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20200304063212.20843-1-jgross@suse.com> References: <20200304063212.20843-1-jgross@suse.com> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v3 5/6] xen/rcu: add assertions to debug build X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Stefano Stabellini , Julien Grall , Wei Liu , Andrew Cooper , Ian Jackson , George Dunlap , Jan Beulich Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" Xen's RCU implementation relies on no softirq handling taking place while being in a RCU critical section. Add ASSERT()s in debug builds in order to catch any violations. For that purpose modify rcu_read_[un]lock() to use a dedicated percpu counter instead of preempt_[en|dis]able() as this enables to test that condition in __do_softirq() (ASSERT_NOT_IN_ATOMIC() is not usable there due to __cpu_up() calling process_pending_softirqs() while holding the cpu hotplug lock). Dropping the now no longer needed #include of preempt.h in rcupdate.h requires adding it in some sources. While at it switch the rcu_read_[un]lock() implementation to static inline functions instead of macros. Signed-off-by: Juergen Gross --- V3: - add barriers to rcu_[en|dis]able() (Roger Pau Monné) - add rcu_quiesce_allowed() to ASSERT_NOT_IN_ATOMIC (Roger Pau Monné) - convert macros to static inline functions - add sanity check in rcu_read_unlock() --- xen/common/multicall.c | 1 + xen/common/preempt.c | 5 ++++- xen/common/rcupdate.c | 4 ++++ xen/common/softirq.c | 2 ++ xen/common/wait.c | 1 + xen/include/xen/rcupdate.h | 45 +++++++++++++++++++++++++++++++++++++++++---- 6 files changed, 53 insertions(+), 5 deletions(-) diff --git a/xen/common/multicall.c b/xen/common/multicall.c index 5a199ebf8f..67f1a23485 100644 --- a/xen/common/multicall.c +++ b/xen/common/multicall.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include diff --git a/xen/common/preempt.c b/xen/common/preempt.c index 3b4178fd44..8a351e644b 100644 --- a/xen/common/preempt.c +++ b/xen/common/preempt.c @@ -21,13 +21,15 @@ #include #include +#include #include DEFINE_PER_CPU(unsigned int, __preempt_count); bool_t in_atomic(void) { - return preempt_count() || in_irq() || !local_irq_is_enabled(); + return preempt_count() || in_irq() || !local_irq_is_enabled() || + !rcu_quiesce_allowed(); } #ifndef NDEBUG @@ -36,5 +38,6 @@ void ASSERT_NOT_IN_ATOMIC(void) ASSERT(!preempt_count()); ASSERT(!in_irq()); ASSERT(local_irq_is_enabled()); + ASSERT(rcu_quiesce_allowed()); } #endif diff --git a/xen/common/rcupdate.c b/xen/common/rcupdate.c index 27d597bbeb..d1cc2f0a98 100644 --- a/xen/common/rcupdate.c +++ b/xen/common/rcupdate.c @@ -46,6 +46,10 @@ #include #include +#ifndef NDEBUG +DEFINE_PER_CPU(unsigned int, rcu_lock_cnt); +#endif + /* Global control variables for rcupdate callback mechanism. */ static struct rcu_ctrlblk { long cur; /* Current batch number. */ diff --git a/xen/common/softirq.c b/xen/common/softirq.c index 30beb27ae9..fd90b8511d 100644 --- a/xen/common/softirq.c +++ b/xen/common/softirq.c @@ -30,6 +30,8 @@ static void __do_softirq(unsigned long ignore_mask, bool rcu_allowed) unsigned int i, cpu; unsigned long pending; + ASSERT(!rcu_allowed || rcu_quiesce_allowed()); + for ( ; ; ) { /* diff --git a/xen/common/wait.c b/xen/common/wait.c index 24716e7676..9cdb174036 100644 --- a/xen/common/wait.c +++ b/xen/common/wait.c @@ -19,6 +19,7 @@ * along with this program; If not, see . */ +#include #include #include #include diff --git a/xen/include/xen/rcupdate.h b/xen/include/xen/rcupdate.h index 31c8b86d13..9f6d420898 100644 --- a/xen/include/xen/rcupdate.h +++ b/xen/include/xen/rcupdate.h @@ -34,10 +34,40 @@ #include #include #include -#include +#include +#include #define __rcu +#ifndef NDEBUG +DECLARE_PER_CPU(unsigned int, rcu_lock_cnt); + +static inline void rcu_quiesce_disable(void) +{ + this_cpu(rcu_lock_cnt)++; + arch_lock_acquire_barrier(); +} + +static inline void rcu_quiesce_enable(void) +{ + arch_lock_release_barrier(); + this_cpu(rcu_lock_cnt)--; +} + +static inline bool rcu_quiesce_allowed(void) +{ + return !this_cpu(rcu_lock_cnt); +} + +#else +static inline void rcu_quiesce_disable(void) { } +static inline void rcu_quiesce_enable(void) { } +static inline bool rcu_quiesce_allowed(void) +{ + return true; +} +#endif + /** * struct rcu_head - callback structure for use with RCU * @next: next update requests in a list @@ -91,16 +121,23 @@ typedef struct _rcu_read_lock rcu_read_lock_t; * will be deferred until the outermost RCU read-side critical section * completes. * - * It is illegal to block while in an RCU read-side critical section. + * It is illegal to process softirqs while in an RCU read-side critical section. */ -#define rcu_read_lock(x) ({ ((void)(x)); preempt_disable(); }) +static inline void rcu_read_lock(rcu_read_lock_t *lock) +{ + rcu_quiesce_disable(); +} /** * rcu_read_unlock - marks the end of an RCU read-side critical section. * * See rcu_read_lock() for more information. */ -#define rcu_read_unlock(x) ({ ((void)(x)); preempt_enable(); }) +static inline void rcu_read_unlock(rcu_read_lock_t *lock) +{ + ASSERT(!rcu_quiesce_allowed()); + rcu_quiesce_enable(); +} /* * So where is rcu_write_lock()? It does not exist, as there is no From patchwork Wed Mar 4 06:32:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 11419355 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 A1C15195A for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 8628B2166E for ; Wed, 4 Mar 2020 06:33:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8628B2166E Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9Na9-0001yf-NS; Wed, 04 Mar 2020 06:32:37 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j9Na9-0001yV-6i for xen-devel@lists.xenproject.org; Wed, 04 Mar 2020 06:32:37 +0000 X-Inumbo-ID: e4a16732-5de1-11ea-90c4-bc764e2007e4 Received: from mx2.suse.de (unknown [195.135.220.15]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id e4a16732-5de1-11ea-90c4-bc764e2007e4; Wed, 04 Mar 2020 06:32:17 +0000 (UTC) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 1F326B265; Wed, 4 Mar 2020 06:32:16 +0000 (UTC) From: Juergen Gross To: xen-devel@lists.xenproject.org Date: Wed, 4 Mar 2020 07:32:12 +0100 Message-Id: <20200304063212.20843-7-jgross@suse.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20200304063212.20843-1-jgross@suse.com> References: <20200304063212.20843-1-jgross@suse.com> Subject: [Xen-devel] [PATCH v3 6/6] xen/rcu: add per-lock counter in debug builds X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Stefano Stabellini , Julien Grall , Wei Liu , Andrew Cooper , Ian Jackson , George Dunlap , Jan Beulich MIME-Version: 1.0 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" Add a lock specific counter to rcu read locks in debug builds. This allows to test for matching lock/unlock calls. Signed-off-by: Juergen Gross --- xen/include/xen/rcupdate.h | 41 ++++++++++++++++++++++++++--------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/xen/include/xen/rcupdate.h b/xen/include/xen/rcupdate.h index 9f6d420898..44a35a809a 100644 --- a/xen/include/xen/rcupdate.h +++ b/xen/include/xen/rcupdate.h @@ -40,17 +40,28 @@ #define __rcu #ifndef NDEBUG +/* * Lock type for passing to rcu_read_{lock,unlock}. */ +struct _rcu_read_lock { + atomic_t cnt; +}; +typedef struct _rcu_read_lock rcu_read_lock_t; +#define DEFINE_RCU_READ_LOCK(x) rcu_read_lock_t x = { .cnt = ATOMIC_INIT(0) } +#define RCU_READ_LOCK_INIT(x) atomic_set(&(x)->cnt, 0) + DECLARE_PER_CPU(unsigned int, rcu_lock_cnt); -static inline void rcu_quiesce_disable(void) +static inline void rcu_quiesce_disable(rcu_read_lock_t *lock) { this_cpu(rcu_lock_cnt)++; + atomic_inc(&lock->cnt); arch_lock_acquire_barrier(); } -static inline void rcu_quiesce_enable(void) +static inline void rcu_quiesce_enable(rcu_read_lock_t *lock) { arch_lock_release_barrier(); + ASSERT(atomic_read(&lock->cnt)); + atomic_dec(&lock->cnt); this_cpu(rcu_lock_cnt)--; } @@ -60,8 +71,17 @@ static inline bool rcu_quiesce_allowed(void) } #else -static inline void rcu_quiesce_disable(void) { } -static inline void rcu_quiesce_enable(void) { } +/* + * Dummy lock type for passing to rcu_read_{lock,unlock}. Currently exists + * only to document the reason for rcu_read_lock() critical sections. + */ +struct _rcu_read_lock {}; +typedef struct _rcu_read_lock rcu_read_lock_t; +#define DEFINE_RCU_READ_LOCK(x) rcu_read_lock_t x +#define RCU_READ_LOCK_INIT(x) + +static inline void rcu_quiesce_disable(rcu_read_lock_t *lock) { } +static inline void rcu_quiesce_enable(rcu_read_lock_t *lock) { } static inline bool rcu_quiesce_allowed(void) { return true; @@ -88,15 +108,6 @@ struct rcu_head { int rcu_pending(int cpu); int rcu_needs_cpu(int cpu); -/* - * Dummy lock type for passing to rcu_read_{lock,unlock}. Currently exists - * only to document the reason for rcu_read_lock() critical sections. - */ -struct _rcu_read_lock {}; -typedef struct _rcu_read_lock rcu_read_lock_t; -#define DEFINE_RCU_READ_LOCK(x) rcu_read_lock_t x -#define RCU_READ_LOCK_INIT(x) - /** * rcu_read_lock - mark the beginning of an RCU read-side critical section. * @@ -125,7 +136,7 @@ typedef struct _rcu_read_lock rcu_read_lock_t; */ static inline void rcu_read_lock(rcu_read_lock_t *lock) { - rcu_quiesce_disable(); + rcu_quiesce_disable(lock); } /** @@ -136,7 +147,7 @@ static inline void rcu_read_lock(rcu_read_lock_t *lock) static inline void rcu_read_unlock(rcu_read_lock_t *lock) { ASSERT(!rcu_quiesce_allowed()); - rcu_quiesce_enable(); + rcu_quiesce_enable(lock); } /*