Received-SPF: pass (google.com: domain of linux-kernel+bounces-175850-linux.lists.archive=gmail.com@vger.kernel.org designates 2604:1380:45e3:2400::1 as permitted sender) client-ip=2604:1380:45e3:2400::1;
Content-Type: text/plain;
	charset=utf-8
Precedence: bulk
Mime-Version: 1.0 (Mac OS X Mail 16.0 \(3774.500.171.1.1\))
Subject: Re: [PATCH 25/48] rcu: Mark writes to rcu_sync ->gp_count field
From: Alan Huang <mmpgouride@gmail.com>
In-Reply-To: <20240510113149.GA24764@redhat.com>
Date: Fri, 10 May 2024 22:00:07 +0800
Cc: "Paul E. McKenney" <paulmck@kernel.org>,
 "Uladzislau Rezki (Sony)" <urezki@gmail.com>,
 RCU <rcu@vger.kernel.org>,
 Neeraj upadhyay <Neeraj.Upadhyay@amd.com>,
 Boqun Feng <boqun.feng@gmail.com>,
 Hillf Danton <hdanton@sina.com>,
 Joel Fernandes <joel@joelfernandes.org>,
 LKML <linux-kernel@vger.kernel.org>,
 Oleksiy Avramchenko <oleksiy.avramchenko@sony.com>,
 Frederic Weisbecker <frederic@kernel.org>,
 Peter Zijlstra <peterz@infradead.org>
Content-Transfer-Encoding: quoted-printable
Message-Id: <5831814D-BAE2-4161-A6C1-5DE1717D1D83@gmail.com>
References: <20240507093530.3043-1-urezki@gmail.com>
 <20240507093530.3043-26-urezki@gmail.com> <ZjpAsYJIfzYSKgdA@redhat.com>
 <4c9e89b5-c981-4809-8bc2-247563ce04e9@paulmck-laptop>
 <20240509151312.GA22612@redhat.com>
 <f0a02cfe-7fc2-494c-8734-e5583f42a8f7@paulmck-laptop>
 <20240510113149.GA24764@redhat.com>
To: Oleg Nesterov <oleg@redhat.com>

> 2024=E5=B9=B45=E6=9C=8810=E6=97=A5 19:31=EF=BC=8COleg Nesterov =
<oleg@redhat.com> wrote=EF=BC=9A
>=20
> On 05/09, Paul E. McKenney wrote:
>>=20
>> On Thu, May 09, 2024 at 05:13:12PM +0200, Oleg Nesterov wrote:
>>>=20
>>> We can move these WARN_ON()'s into the ->rss_lock protected section.
>>>=20
>>> Or perhaps we can use data_race(rsp->gp_count) ? To be honest I =
thought
>>> that READ_ONCE() should be enough...
>>>=20
>>> Or we can simply kill these WARN_ON_ONCE()'s.
>>=20
>> Or we could move those WARN_ON_ONCE() under the lock.
>=20
> Sure, see above.
>=20
> But could you help me to understand this magic? I naively thought
> that READ_ONCE() is always "safe"...
>=20
> So, unless I am totally confused it turns out that, say,
>=20
> CPU 0 CPU 1
> ----- -----
>=20
> spin_lock(LOCK);
> ++X; READ_ONCE(X); // data race
> spin_unlock(LOCK);
>=20
> is data-racy accoring to KCSAN, while
>=20
> CPU 0 CPU 1
> ----- -----
>=20
> spin_lock(LOCK);
> WRITE_ONCE(X, X+1); READ_ONCE(X); // no data race
> spin_unlock(LOCK);
>=20
> is not.
>=20
> Why is that?
>=20
> Trying to read Documentation/dev-tools/kcsan.rst... it says
>=20
> KCSAN is aware of *marked atomic operations* (``READ_ONCE``, =
WRITE_ONCE``,
>=20
> ...
>=20
> if all accesses to a variable that is accessed concurrently are =
properly
> marked, KCSAN will never trigger a watchpoint
>=20
> but how can KCSAN detect that all accesses to X are properly marked? I =
see nothing
> KCSAN-related in the definition of WRITE_ONCE() or READ_ONCE().
>=20
> And what does the "all accesses" above actually mean? The 2nd version =
does
>=20
> WRITE_ONCE(X, X+1);
>=20
> but "X + 1" is the plain/unmarked access?

X + 1 and READ_ONCE(X) are two read.

>=20
> Thanks,
>=20
> Oleg.
>=20
>=20