----- On Sep 12, 2019, at 11:47 AM, Will Deacon w...@kernel.org wrote: > On Thu, Sep 12, 2019 at 03:24:35PM +0100, Linus Torvalds wrote: >> On Thu, Sep 12, 2019 at 2:48 PM Will Deacon <w...@kernel.org> wrote: >> > >> > So the man page for sys_membarrier states that the expedited variants >> > "never >> > block", which feels pretty strong. Do any other system calls claim to >> > provide this guarantee without a failure path if blocking is necessary? >> >> The traditional semantics for "we don't block" is that "we block on >> memory allocations and locking and user accesses etc, but we don't >> wait for our own IO". >> >> So there may be new IO started (and waited on) as part of allocating >> new memory etc, or in just paging in user memory, but the IO that the >> operation _itself_ explicitly starts is not waited on. > > Thanks, that makes sense, and I'd be inclined to suggest an update to the > sys_membarrier manpage to make this more clear since the "never blocks" > phrasing doesn't seem to be used like this for other system calls.
The current wording from membarrier(2) is: The "expedited" commands complete faster than the non-expedited ones; they never block, but have the downside of causing extra overhead. We could simply remove the "; they never block" part then ? > >> No system call should ever be considered "atomic" in any sense. If >> you're doing RT, you should maybe expect "getpid()" to not ever block, >> but that's just about the exclusive list of truly nonblocking system >> calls, and even that can be preempted. > > In which case, why can't we just use GFP_KERNEL for the cpumask allocation > instead of GFP_NOWAIT and then remove the failure path altogether? Mathieu? Looking at: #define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS) I notice that it does not include __GFP_NOFAIL. What prevents GFP_KERNEL from failing, and where is this guarantee documented ? Regarding __GFP_NOFAIL, its use seems to be discouraged in linux/gfp.h: * %__GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller * cannot handle allocation failures. The allocation could block * indefinitely but will never return with failure. Testing for * failure is pointless. * New users should be evaluated carefully (and the flag should be * used only when there is no reasonable failure policy) but it is * definitely preferable to use the flag rather than opencode endless * loop around allocator. * Using this flag for costly allocations is _highly_ discouraged. So I am reluctant to use it. But if we can agree on the right combination of flags that guarantees there is no failure, I would be perfectly fine with using them to remove the fallback code. Thanks, Mathieu -- Mathieu Desnoyers EfficiOS Inc. http://www.efficios.com