Excerpts from peterz@infradead.org's message of July 16, 2020 9:00 pm:

On Thu, Jul 16, 2020 at 08:03:36PM +1000, Nicholas Piggin wrote:

quoted

Excerpts from Peter Zijlstra's message of July 16, 2020 6:50 pm:

quoted

On Wed, Jul 15, 2020 at 10:18:20PM -0700, Andy Lutomirski wrote:

quoted

quoted

On Jul 15, 2020, at 9:15 PM, Nicholas Piggin [off-list ref] wrote:

quoted

quoted

quoted

But I’m wondering if all this deferred sync stuff is wrong. In the
brave new world of io_uring and such, perhaps kernel access matter
too.  Heck, even:

IIRC the membarrier SYNC_CORE use-case is about user-space
self-modifying code.

Userspace re-uses a text address and needs to SYNC_CORE before it can be
sure the old text is forgotten. Nothing the kernel does matters there.

I suppose the manpage could be more clear there.

True, but memory ordering of kernel stores from kernel threads for
regular mem barrier is the concern here.

Does io_uring update completion queue from kernel thread or interrupt,
for example? If it does, then membarrier will not order such stores
with user memory accesses.

So we're talking about regular membarrier() then? Not the SYNC_CORE
variant per-se.

Well, both but Andy in this case was wondering about kernel writes
vs user.

Even there, I'll argue we don't care, but perhaps Mathieu has a
different opinion. All we care about is that all other threads (or CPUs
for GLOBAL) observe an smp_mb() before it returns.

Any serialization against whatever those other threads/CPUs are running
at the instant of the syscall is external to the syscall, we make no
gauarantees about that. That is, we can fundamentally not say what
another CPU is executing concurrently. Nor should we want to.

So if you feel that your membarrier() ought to serialize against remote
execution, you need to arrange a quiecent state on the remote side
yourself.

Now, normally membarrier() is used to implement userspace RCU like
things, and there all that matters is that the remote CPUs observe the
beginngin of the new grace-period, ie counter flip, and we observe their
read-side critical sections, or smething like that, it's been a while
since I looked at all that.

It's always been the case that concurrent syscalls could change user
memory, io_uring doesn't change that, it just makes it even less well
defined when that would happen. If you want to serialize against that,
you need to arrange that externally.

membarrier does replace barrier instructions on remote CPUs, which do
order accesses performed by the kernel on the user address space. So
membarrier should too I guess.

Normal process context accesses like read(2) will do so because they
don't get filtered out from IPIs, but kernel threads using the mm may
not.

Thanks,
Nick