/*
 * Copyright 2008-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2023, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <pthread.h>
#include <threads.h>

#include <OS.h>
#include <Debug.h>


enum {
        STATE_UNINITIALIZED     = -1,   // keep in sync with PTHREAD_ONCE_INIT
        STATE_INITIALIZING      = -2,
        STATE_SPINNING          = -3,
        STATE_INITIALIZED       = -4
};

#if __cplusplus >= 201103L
STATIC_ASSERT(((pthread_once_t)ONCE_FLAG_INIT).state == ((pthread_once_t)PTHREAD_ONCE_INIT).state);
STATIC_ASSERT(((pthread_once_t)PTHREAD_ONCE_INIT).state == STATE_UNINITIALIZED);
#endif


/*!     Called when the thread performing the initialization function was canceled.

        \param data Pointer to the \c pthread_once_t structure in question.
*/
static void
init_function_canceled(void* data)
{
        pthread_once_t* onceControl = (pthread_once_t*)data;

        // reset the control state to uninitialized
        int32 value = atomic_get_and_set((int32*)&onceControl->state,
                        STATE_UNINITIALIZED);

        // If someone has set a semaphore, delete it.
        if (value >= 0)
                delete_sem(value);
}


// #pragma mark -


int
pthread_once(pthread_once_t* onceControl, void (*initRoutine)(void))
{
        // Algorithm:
        // The state goes through at most four states:
        // STATE_UNINITIALIZED: The initial uninitialized state.
        // STATE_INITIALIZING: Set by the first thread entering the function. It
        // will call initRoutine.
        // semaphore/STATE_SPINNING: Set by the second thread entering the function,
        // when the first thread is still executing initRoutine. The normal case is
        // that the thread manages to create a semaphore. This thread (and all
        // following threads) will block on the semaphore until the first thread is
        // done.
        // STATE_INITIALIZED: Set by the first thread when it returns from
        // initRoutine. All following threads will return right away.

        while (true) {
                int32 value = atomic_test_and_set((int32*)&onceControl->state,
                        STATE_INITIALIZING, STATE_UNINITIALIZED);

                if (value == STATE_INITIALIZED)
                        return 0;

                if (value == STATE_UNINITIALIZED) {
                        // we're the first -- perform the initialization
                        pthread_cleanup_push(&init_function_canceled, onceControl);
                        initRoutine();
                        pthread_cleanup_pop(false);

                        value = atomic_get_and_set((int32*)&onceControl->state,
                                        STATE_INITIALIZED);

                        // If someone else is waiting, we need to delete the semaphore.
                        if (value >= 0)
                                delete_sem(value);

                        return 0;
                }

                if (value == STATE_INITIALIZING) {
                        // someone is initializing -- we need to create a semaphore we can
                        // wait on
                        sem_id semaphore = create_sem(0, "pthread once");
                        if (semaphore >= 0) {
                                // successfully created -- set it
                                value = atomic_test_and_set((int32*)&onceControl->state,
                                        semaphore, STATE_INITIALIZING);
                                if (value == STATE_INITIALIZING)
                                        value = semaphore;
                                else
                                        delete_sem(semaphore);
                        } else {
                                // Failed to create the semaphore. Can only happen when the
                                // system runs out of semaphores, but we can still handle the
                                // situation gracefully by spinning.
                                value = atomic_test_and_set((int32*)&onceControl->state,
                                        STATE_SPINNING, STATE_INITIALIZING);
                                if (value == STATE_INITIALIZING)
                                        value = STATE_SPINNING;
                        }
                }

                if (value >= 0) {
                        // wait on the semaphore
                        while (acquire_sem(value) == B_INTERRUPTED);

                        return 0;
                } else if (value == STATE_SPINNING) {
                        // out of semaphores -- spin
                        while (atomic_get((int32*)&onceControl->state) == STATE_SPINNING);
                }
        }
}