bpo-29640: Protect key list during fork()

[stratakis]

When a thread is modifying the key list and a fork() happens in another thread, the forked process can be left with an inconsistent key list. More info at: http://bugs.python.org/issue29640

This PR adds two new functions, _PyThread_AcquireKeyLock and _PyThread_ReleaseKeyLock, which are used to lock the key mutex around fork() calls.

https://bugs.python.org/issue29640

[henrik-koren]

@the-knights-who-say-ni do you have an ETA to merge this commit
Thanks

[nicopauss]

I have an issue with this patch.
Python2.7 will hang forever while using PyGILState_GetThisThreadState in the prepare callback of pthread_atfork.

See https://github.com/nicopauss/test_python_fork_hanging

[encukou]

If pthread_atfork is available, the locking can be done there (though I can imagine error handling will not be trivial).
If it's not available, then we can to keep this solution.

[encukou]

@nicopauss, just for reference, could you share your use case for PyGILState_GetThisThreadState in an atfork handler?

[vstinner]

At least in the child process, I don't think that it's safe to use keymutex just after fork.

A few lines below, PyOS_AfterFork() is called if we are in the child process, this function calls PyThread_ReInitTLS():

void
PyThread_ReInitTLS(void)
{
    ...
    /* As with interpreter_lock in PyEval_ReInitThreads()
       we just create a new lock without freeing the old one */
    keymutex = PyThread_allocate_lock();
    ...
}

So keymutex is replaced in the child process.

[vstinner]

Maybe a compromise would be only unlock in the parent process. _PyThread_ReleaseKeyLock(); in the parent is safe, whereas _PyThread_ReleaseKeyLock(); in the child can be simply... ignored, since we replace keymutex a few instructions later (see my previous comment).

[bedevere-bot]

A Python core developer has requested some changes be made to your pull request before we can consider merging it. If you could please address their requests along with any other requests in other reviews from core developers that would be appreciated.

Once you have made the requested changes, please leave a comment on this pull request containing the phrase I have made the requested changes; please review again. I will then notify any core developers who have left a review that you're ready for them to take another look at this pull request.

[vstinner]

You should add a comment explaining the rationale of this lock. I understand that it's a workaround to make the Python TLS implementation "fork-safe".

[vstinner]

Maybe a compromise would be only unlock in the parent process. _PyThread_ReleaseKeyLock(); in the parent is safe, whereas _PyThread_ReleaseKeyLock(); in the child can be simply... ignored, since we replace keymutex a few instructions later (see my previous comment).

[vstinner]

I changed the PR title to make @bedevere-bot happy (to fix bedevere/issue-number test).

[vstinner]

Maybe we can add a special case if the mutex wasn't created yet: if keymutex is NULL, well, just do nothing, no?

I guess that that the keymutex variable is protected by the GIL.

[encukou]

I think this could just be assert(keymutex != NULL);.
keymutex is first initialized from Py_Initialize → _PyGILState_Init.

[encukou]

See #5141 for a more comprehensive (but still unfinished) solution.