/*
 * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2018-2023, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT license.
 */


#include <lock.h>
#include <thread.h>

extern "C" {
#       include "device.h"
#       include <sys/callout.h>
#       include <sys/mutex.h>
}

#include <util/AutoLock.h>


//#define TRACE_CALLOUT
#ifdef TRACE_CALLOUT
#       define TRACE(x...) dprintf(x)
#else
#       define TRACE(x...) ;
#endif


static struct list sTimers;
static mutex sLock;
static sem_id sWaitSem;
static callout* sCurrentCallout;
static thread_id sThread;
static bigtime_t sTimeout;


static void
invoke_callout(callout *c, struct mtx *c_mtx)
{
        if (c_mtx != NULL) {
                mtx_lock(c_mtx);

                if (c->c_due < 0 || c->c_due > 0) {
                        mtx_unlock(c_mtx);
                        return;
                }
                c->c_due = -1;
        }

        c->c_func(c->c_arg);

        if (c_mtx != NULL && (c->c_flags & CALLOUT_RETURNUNLOCKED) == 0)
                mtx_unlock(c_mtx);
}


static status_t
callout_thread(void* /*data*/)
{
        status_t status = B_NO_INIT;

        do {
                bigtime_t timeout = B_INFINITE_TIMEOUT;

                if (status == B_TIMED_OUT || status == B_OK) {
                        // scan timers for new timeout and/or execute a timer
                        if ((status = mutex_lock(&sLock)) != B_OK)
                                continue;

                        struct callout* c = NULL;
                        while (true) {
                                c = (callout*)list_get_next_item(&sTimers, c);
                                if (c == NULL)
                                        break;

                                if (c->c_due > system_time()) {
                                        // calculate new timeout
                                        if (timeout > c->c_due)
                                                timeout = c->c_due;
                                        continue;
                                }

                                // execute timer
                                list_remove_item(&sTimers, c);
                                struct mtx *c_mtx = c->c_mtx;
                                c->c_due = 0;
                                sCurrentCallout = c;

                                mutex_unlock(&sLock);

                                invoke_callout(c, c_mtx);

                                if ((status = mutex_lock(&sLock)) != B_OK)
                                        break;

                                sCurrentCallout = NULL;
                                c = NULL;
                                        // restart scanning as we unlocked the list
                        }

                        sTimeout = timeout;
                        mutex_unlock(&sLock);
                }

                status = acquire_sem_etc(sWaitSem, 1, B_ABSOLUTE_TIMEOUT, timeout);
                        // the wait sem normally can't be acquired, so we
                        // have to look at the status value the call returns:
                        //
                        // B_OK - a new timer has been added or canceled
                        // B_TIMED_OUT - look for timers to be executed
                        // B_BAD_SEM_ID - we are asked to quit
        } while (status != B_BAD_SEM_ID);

        return B_OK;
}


// #pragma mark - private API


status_t
init_callout(void)
{
        list_init_etc(&sTimers, offsetof(struct callout, c_link));
        sTimeout = B_INFINITE_TIMEOUT;

        status_t status = B_OK;
        mutex_init(&sLock, "fbsd callout");

        sWaitSem = create_sem(0, "fbsd callout wait");
        if (sWaitSem < 0) {
                status = sWaitSem;
                goto err1;
        }

        sThread = spawn_kernel_thread(callout_thread, "fbsd callout",
                B_DISPLAY_PRIORITY, NULL);
        if (sThread < 0) {
                status = sThread;
                goto err2;
        }

        return resume_thread(sThread);

err2:
        delete_sem(sWaitSem);
err1:
        mutex_destroy(&sLock);
        return status;
}


void
uninit_callout(void)
{
        delete_sem(sWaitSem);

        wait_for_thread(sThread, NULL);

        mutex_lock(&sLock);
        mutex_destroy(&sLock);
}


// #pragma mark - public API


void
callout_init(struct callout *callout, int mpsafe)
{
        if (mpsafe)
                callout_init_mtx(callout, NULL, 0);
        else
                callout_init_mtx(callout, &Giant, 0);
}


void
callout_init_mtx(struct callout *c, struct mtx *mtx, int flags)
{
        c->c_due = 0;

        c->c_arg = NULL;
        c->c_func = NULL;
        c->c_mtx = mtx;
        c->c_flags = flags;
}


static int
_callout_stop(struct callout *c, bool drain, bool locked = false)
{
        TRACE("_callout_stop %p, func %p, arg %p\n", c, c->c_func, c->c_arg);

        MutexLocker locker;
        if (!locked)
                locker.SetTo(sLock, false);

        bool lockHeld = false;
        if (!drain && c->c_mtx != NULL) {
                if (c->c_mtx != &Giant) {
                        // The documentation for callout_stop() confirms any associated locks
                        // must be held when invoking it. We depend on this behavior for
                        // synchronization with the callout thread, which can modify c_due
                        // with only the callout's lock held.
                        mtx_assert(c->c_mtx, MA_OWNED);
                        lockHeld = true;
                } else {
                        // FreeBSD is lenient and does not assert if the callout mutex is &Giant.
                        lockHeld = mtx_owned(&Giant);
                }
        }

        int ret = -1;
        if (callout_active(c)) {
                ret = 0;
                if (!drain && lockHeld && c->c_due == 0) {
                        // The callout is active, but c_due == 0 and we hold the locks: this
                        // means the callout thread has dequeued it and is waiting for c_mtx.
                        // Clear c_due to signal the callout thread.
                        c->c_due = -1;
                        ret = 1;
                }
                if (drain) {
                        locker.Unlock();
                        while (callout_active(c))
                                snooze(100);
                        locker.Lock();
                }
        }

        if (c->c_due <= 0)
                return ret;

        // this timer is scheduled, cancel it
        list_remove_item(&sTimers, c);
        c->c_due = -1;
        return (ret == -1) ? 1 : ret;
}


int
callout_reset(struct callout *c, int _ticks, void (*func)(void *), void *arg)
{
        MutexLocker locker(sLock);

        TRACE("callout_reset %p, func %p, arg %p\n", c, c->c_func, c->c_arg);

        c->c_func = func;
        c->c_arg = arg;

        if (_ticks < 0) {
                int stopped = -1;
                if (c->c_due > 0)
                        stopped = _callout_stop(c, 0, true);
                return (stopped == -1) ? 0 : 1;
        }

        int rescheduled = 0;
        if (_ticks >= 0) {
                // reschedule or add this timer
                if (c->c_due <= 0) {
                        list_add_item(&sTimers, c);
                } else {
                        rescheduled = 1;
                }

                c->c_due = system_time() + TICKS_2_USEC(_ticks);

                // notify timer about the change if necessary
                if (sTimeout > c->c_due)
                        release_sem(sWaitSem);
        }

        return rescheduled;
}


int
_callout_stop_safe(struct callout *c, int safe)
{
        if (c == NULL)
                return -1;

        return _callout_stop(c, safe);
}


int
callout_schedule(struct callout *callout, int _ticks)
{
        return callout_reset(callout, _ticks, callout->c_func, callout->c_arg);
}


int
callout_pending(struct callout *c)
{
        return c->c_due > 0;
}


int
callout_active(struct callout *c)
{
        return c == sCurrentCallout;
}