Re: [musl] Re: [RFC PATCH] x86/vdso/32: Add AT_SYSINFO cancellation helpers

From: Ingo Molnar
Date: Sat Mar 12 2016 - 12:00:58 EST

* Linus Torvalds <torvalds@xxxxxxxxxxxxxxxxxxxx> wrote:

> [...]
> Because if that's the case, I wonder if what you really want is not "sticky
> signals" as much as "synchronous signals" - ie the ability to say that a signal
> shouldn't ever interrupt in random places, but only at well-defined points
> (where a system call would be one such point - are there others?)

Yes, I had similar 'deferred signal delivery' thoughts after having written up the
sticky signals approach, I just couldn't map all details of the semantics: see the
'internal libc functions' problem below.

If we can do this approach then there's another advantage as well: this way the C
library does not even have to poll for cancellation at syscall boundaries: i.e.
the regular system call fast path gets faster by 2-3 instructions as well.

> So then you could make "pthread_setcanceltype()" just set that flag for the
> cancellation signal, and just know that the signal itself will always be
> deferred to such a synchronous point (ie system call entry).
> We already have the ability to catch things at system call entry (ptrace needs
> it, for example), so we could possibly make our signal delivery have a mode
> where a signal does *not* cause user space execution to be interrupted by a
> signal handler, but instead just sets a bit in the thread info state that then
> causes the next system call to take the signal.

Yes, so this would need a bit of work, to handle the problem mentioned by Rich
Felker: "internal" libc APIs (such as name server lookups) may consist of a series
of complex system calls - some of which might be blocking. It should still be
possible to execute such 'internal' system calls undisturbed, even if a 'deferred'
signal is sent.

One workable solution I think would be to prepare the internal functions for
eventual interruption by the cancellation signal. They have to be restartable
anyway, because the application can send other signals. As long as the
interruption is only transient it should be fine.

And note that this approach would also be pretty fast on the libc side: none of
the 'fast' cancellation APIs would have to do anything complex like per call
signal blocking/unblocking or other complex signal operations. They would just
activate a straightforward new SA_ flag and rely on its semantics.