I tried to come up with a test, but it wasn't easily possible as our testing frameworks requires global state as well. I used the following test program to verify the issue vanished:

#include <pthread.h>

#include "common.h"

void *run(void *data)
{
    int i;
    for (i = 0; i < 20; i++)
    {
        git_libgit2_init();
        git_libgit2_shutdown();
    }
    return data;
}

int main(int argc, char *argv[])
{
    pthread_t threads[10];
    unsigned i;

    for (i = 0; i < sizeof(threads) / sizeof(*threads); i++)
    {
        pthread_create(&threads[i], NULL, run, NULL);
    }

    for (i = 0; i < sizeof(threads) / sizeof(*threads); i++)
    {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

This in fact supersedes #3972 and should fix #3969

So I may not be reasoning about this correctly, but I don't think this is quite sufficient. pthread_once should ensure that the init_once function is only called once, and synchronously (with respect to other callers with the same once token).

In your sample program, you're initing and shutdowning. But if you ever have a shutdown that actually tears down the global state, you'll never bring it back. That once_init should really only ever get called once.

I suspect that - independent of threading - if you just git_libgit2_init, git_libgit2_shutdown, git_libgit2_init that you are not actually initialized and the global state is a mess...

Or am I not thinking about this correctly?

No, we do actually re-initialize the pthread_once thingy. See git_libgit2_shutdown, where we reset _once_init with pthread_once_t new_once = PTHREAD_ONCE_INIT; _once_init = new_once;.

Just to write down my thoughts and why it is correct to reset _once_init: when the last shutdown has been called, we actually do want to free all related data structures such as to avoid memory leaks in libgit2. So we are forced to reset _once_init, because when somebody calls init again we have to re-initialize all data structures.

Usually I'd advice callers to not initialize/shutdown repeatedly, but I think we should nevertheless support this use case.

No, we do actually re-initialize the pthread_once thingy. See git_libgit2_shutdown, where we reset _once_init with pthread_once_t new_once = PTHREAD_ONCE_INIT; _once_init = new_once;.

🙇 Thank you, I didn't see that. 😪😫😪

So I think that there's still a situation here. Since we increment and decrement outside of the mutex, we could have two threads racing:

Thread A enters git_libgit2_shutdown and decrements git__n_inits from 1 -> 0 and is paused before locking the mutex and performing the shutdown.
Thread B enters git_libgit2_init and increments git__n_inits from 0 -> 1. pthread_once will not run in this case.
Thread A is woken back up, locks the mutex and finally performs the shutdown.

Oh, yeah, you're right. The mutex also has to synchronize pthread_once(once_init), not only the function called by pthread_once. Thanks :)

The issue should be fixed. I synchronize over pthread_once(&_once_init, init_once) now instead of synchronizing inside of init_once.

The failing test is unrelated

I accidentally included the example demonstrating the fix. Removed the file

Fixed another issue with re-initialization when not using threads which were caught by a set of new tests