/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <RWLockManager.h>

#include <AutoLocker.h>

#include <syscalls.h>
#include <user_thread.h>


RWLockable::RWLockable()
        :
        fOwner(-1),
        fOwnerCount(0),
        fReaderCount(0)
{
}


RWLockManager::RWLockManager()
        :
        fLock("r/w lock manager")
{
}


RWLockManager::~RWLockManager()
{
}


bool
RWLockManager::ReadLock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        if (lockable->fWaiters.IsEmpty()) {
                lockable->fReaderCount++;
                return true;
        }

        return _Wait(lockable, false, B_INFINITE_TIMEOUT) == B_OK;
}


bool
RWLockManager::TryReadLock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        if (lockable->fWaiters.IsEmpty()) {
                lockable->fReaderCount++;
                return true;
        }

        return false;
}


status_t
RWLockManager::ReadLockWithTimeout(RWLockable* lockable, bigtime_t timeout)
{
        AutoLocker<RWLockManager> locker(this);

        if (lockable->fWaiters.IsEmpty()) {
                lockable->fReaderCount++;
                return B_OK;
        }

        return _Wait(lockable, false, timeout);
}


void
RWLockManager::ReadUnlock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        if (lockable->fReaderCount <= 0) {
                debugger("RWLockManager::ReadUnlock(): Not read-locked!");
                return;
        }

        if (--lockable->fReaderCount == 0)
                _Unblock(lockable);
}


bool
RWLockManager::WriteLock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        thread_id thread = find_thread(NULL);

        if (lockable->fOwner == thread) {
                lockable->fOwnerCount++;
                return true;
        }

        if (lockable->fReaderCount == 0 && lockable->fWaiters.IsEmpty()) {
                lockable->fOwnerCount = 1;
                lockable->fOwner = find_thread(NULL);
                return true;
        }

        return _Wait(lockable, true, B_INFINITE_TIMEOUT) == B_OK;
}


bool
RWLockManager::TryWriteLock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        thread_id thread = find_thread(NULL);

        if (lockable->fOwner == thread) {
                lockable->fOwnerCount++;
                return true;
        }

        if (lockable->fReaderCount == 0 && lockable->fWaiters.IsEmpty()) {
                lockable->fOwnerCount++;
                lockable->fOwner = thread;
                return true;
        }

        return false;
}


status_t
RWLockManager::WriteLockWithTimeout(RWLockable* lockable, bigtime_t timeout)
{
        AutoLocker<RWLockManager> locker(this);

        thread_id thread = find_thread(NULL);

        if (lockable->fOwner == thread) {
                lockable->fOwnerCount++;
                return B_OK;
        }

        if (lockable->fReaderCount == 0 && lockable->fWaiters.IsEmpty()) {
                lockable->fOwnerCount++;
                lockable->fOwner = thread;
                return B_OK;
        }

        return _Wait(lockable, true, timeout);
}


void
RWLockManager::WriteUnlock(RWLockable* lockable)
{
        AutoLocker<RWLockManager> locker(this);

        if (find_thread(NULL) != lockable->fOwner) {
                debugger("RWLockManager::WriteUnlock(): Not write-locked by calling "
                        "thread!");
                return;
        }

        if (--lockable->fOwnerCount == 0) {
                lockable->fOwner = -1;
                _Unblock(lockable);
        }
}


status_t
RWLockManager::_Wait(RWLockable* lockable, bool writer, bigtime_t timeout)
{
        if (timeout == 0)
                return B_TIMED_OUT;

        // enqueue a waiter
        RWLockable::Waiter waiter(writer);
        lockable->fWaiters.Add(&waiter);
        waiter.queued = true;
        get_user_thread()->wait_status = 1;

        // wait
        Unlock();

        status_t error;
        do {
                error = _kern_block_thread(
                        timeout >= 0 ? B_RELATIVE_TIMEOUT : 0, timeout);
                        // TODO: When interrupted we should adjust the timeout, respectively
                        // convert to an absolute timeout in the first place!
        } while (error == B_INTERRUPTED);

        Lock();

        if (!waiter.queued)
                return waiter.status;

        // we're still queued, which means an error (timeout, interrupt)
        // occurred
        lockable->fWaiters.Remove(&waiter);

        _Unblock(lockable);

        return error;
}


void
RWLockManager::_Unblock(RWLockable* lockable)
{
        // Check whether there any waiting threads at all and whether anyone
        // has the write lock
        RWLockable::Waiter* waiter = lockable->fWaiters.Head();
        if (waiter == NULL || lockable->fOwner >= 0)
                return;

        // writer at head of queue?
        if (waiter->writer) {
                if (lockable->fReaderCount == 0) {
                        waiter->status = B_OK;
                        waiter->queued = false;
                        lockable->fWaiters.Remove(waiter);
                        lockable->fOwner = waiter->thread;
                        lockable->fOwnerCount = 1;

                        _kern_unblock_thread(waiter->thread, B_OK);
                }
                return;
        }

        // wake up one or more readers -- we unblock more than one reader at
        // a time to save trips to the kernel
        while (!lockable->fWaiters.IsEmpty()
                        && !lockable->fWaiters.Head()->writer) {
                static const int kMaxReaderUnblockCount = 128;
                thread_id readers[kMaxReaderUnblockCount];
                int readerCount = 0;

                while (readerCount < kMaxReaderUnblockCount
                                && (waiter = lockable->fWaiters.Head()) != NULL
                                && !waiter->writer) {
                        waiter->status = B_OK;
                        waiter->queued = false;
                        lockable->fWaiters.Remove(waiter);

                        readers[readerCount++] = waiter->thread;
                        lockable->fReaderCount++;
                }

                if (readerCount > 0)
                        _kern_unblock_threads(readers, readerCount, B_OK);
        }
}