/*      $OpenBSD: rthread_rwlock.c,v 1.13 2019/03/03 18:39:10 visa Exp $ */
/*
 * Copyright (c) 2019 Martin Pieuchot <mpi@openbsd.org>
 * Copyright (c) 2012 Philip Guenther <guenther@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#include <pthread.h>

#include "rthread.h"
#include "synch.h"

#define UNLOCKED        0
#define MAXREADER       0x7ffffffe
#define WRITER          0x7fffffff
#define WAITING         0x80000000
#define COUNT(v)        ((v) & WRITER)

#define SPIN_COUNT      128
#if defined(__i386__) || defined(__amd64__)
#define SPIN_WAIT()     asm volatile("pause": : : "memory")
#else
#define SPIN_WAIT()     do { } while (0)
#endif

static _atomic_lock_t rwlock_init_lock = _SPINLOCK_UNLOCKED;

int
pthread_rwlock_init(pthread_rwlock_t *lockp,
    const pthread_rwlockattr_t *attrp __unused)
{
        pthread_rwlock_t rwlock;

        rwlock = calloc(1, sizeof(*rwlock));
        if (!rwlock)
                return (errno);

        *lockp = rwlock;

        return (0);
}
DEF_STD(pthread_rwlock_init);

int
pthread_rwlock_destroy(pthread_rwlock_t *lockp)
{
        pthread_rwlock_t rwlock;

        rwlock = *lockp;
        if (rwlock) {
                if (rwlock->value != UNLOCKED) {
#define MSG "pthread_rwlock_destroy on rwlock with waiters!\n"
                        write(2, MSG, sizeof(MSG) - 1);
#undef MSG
                        return (EBUSY);
                }
                free((void *)rwlock);
                *lockp = NULL;
        }

        return (0);
}

static int
_rthread_rwlock_ensure_init(pthread_rwlock_t *rwlockp)
{
        int ret = 0;

        /*
         * If the rwlock is statically initialized, perform the dynamic
         * initialization.
         */
        if (*rwlockp == NULL) {
                _spinlock(&rwlock_init_lock);
                if (*rwlockp == NULL)
                        ret = pthread_rwlock_init(rwlockp, NULL);
                _spinunlock(&rwlock_init_lock);
        }
        return (ret);
}

static int
_rthread_rwlock_tryrdlock(pthread_rwlock_t rwlock)
{
        unsigned int val;

        do {
                val = rwlock->value;
                if (COUNT(val) == WRITER)
                        return (EBUSY);
                if (COUNT(val) == MAXREADER)
                        return (EAGAIN);
        } while (atomic_cas_uint(&rwlock->value, val, val + 1) != val);

        membar_enter_after_atomic();
        return (0);
}

static int
_rthread_rwlock_timedrdlock(pthread_rwlock_t *rwlockp, int trywait,
    const struct timespec *abs, int timed)
{
        pthread_t self = pthread_self();
        pthread_rwlock_t rwlock;
        unsigned int val, new;
        int i, error;

        if ((error = _rthread_rwlock_ensure_init(rwlockp)))
                return (error);

        rwlock = *rwlockp;
        _rthread_debug(5, "%p: rwlock_%srdlock %p (%u)\n", self,
            (timed ? "timed" : (trywait ? "try" : "")), (void *)rwlock,
            rwlock->value);

        error = _rthread_rwlock_tryrdlock(rwlock);
        if (error != EBUSY || trywait)
                return (error);

        /* Try hard to not enter the kernel. */
        for (i = 0; i < SPIN_COUNT; i++) {
                val = rwlock->value;
                if (val == UNLOCKED || (val & WAITING))
                        break;

                SPIN_WAIT();
        }

        while ((error = _rthread_rwlock_tryrdlock(rwlock)) == EBUSY) {
                val = rwlock->value;
                if (val == UNLOCKED || (COUNT(val)) != WRITER)
                        continue;
                new = val | WAITING;
                if (atomic_cas_uint(&rwlock->value, val, new) == val) {
                        error = _twait(&rwlock->value, new, CLOCK_REALTIME,
                            abs);
                }
                if (error == ETIMEDOUT)
                        break;
        }

        return (error);

}

int
pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlockp)
{
        return (_rthread_rwlock_timedrdlock(rwlockp, 1, NULL, 0));
}

int
pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlockp,
    const struct timespec *abs)
{
        return (_rthread_rwlock_timedrdlock(rwlockp, 0, abs, 1));
}

int
pthread_rwlock_rdlock(pthread_rwlock_t *rwlockp)
{
        return (_rthread_rwlock_timedrdlock(rwlockp, 0, NULL, 0));
}

static int
_rthread_rwlock_tryrwlock(pthread_rwlock_t rwlock)
{
        if (atomic_cas_uint(&rwlock->value, UNLOCKED, WRITER) != UNLOCKED)
                return (EBUSY);

        membar_enter_after_atomic();
        return (0);
}


static int
_rthread_rwlock_timedwrlock(pthread_rwlock_t *rwlockp, int trywait,
    const struct timespec *abs, int timed)
{
        pthread_t self = pthread_self();
        pthread_rwlock_t rwlock;
        unsigned int val, new;
        int i, error;

        if ((error = _rthread_rwlock_ensure_init(rwlockp)))
                return (error);

        rwlock = *rwlockp;
        _rthread_debug(5, "%p: rwlock_%swrlock %p (%u)\n", self,
            (timed ? "timed" : (trywait ? "try" : "")), (void *)rwlock,
            rwlock->value);

        error = _rthread_rwlock_tryrwlock(rwlock);
        if (error != EBUSY || trywait)
                return (error);

        /* Try hard to not enter the kernel. */
        for (i = 0; i < SPIN_COUNT; i++) {
                val = rwlock->value;
                if (val == UNLOCKED || (val & WAITING))
                        break;

                SPIN_WAIT();
        }

        while ((error = _rthread_rwlock_tryrwlock(rwlock)) == EBUSY) {
                val = rwlock->value;
                if (val == UNLOCKED)
                        continue;
                new = val | WAITING;
                if (atomic_cas_uint(&rwlock->value, val, new) == val) {
                        error = _twait(&rwlock->value, new, CLOCK_REALTIME,
                            abs);
                }
                if (error == ETIMEDOUT)
                        break;
        }

        return (error);
}

int
pthread_rwlock_trywrlock(pthread_rwlock_t *rwlockp)
{
        return (_rthread_rwlock_timedwrlock(rwlockp, 1, NULL, 0));
}

int
pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlockp,
    const struct timespec *abs)
{
        return (_rthread_rwlock_timedwrlock(rwlockp, 0, abs, 1));
}

int
pthread_rwlock_wrlock(pthread_rwlock_t *rwlockp)
{
        return (_rthread_rwlock_timedwrlock(rwlockp, 0, NULL, 0));
}

int
pthread_rwlock_unlock(pthread_rwlock_t *rwlockp)
{
        pthread_t self = pthread_self();
        pthread_rwlock_t rwlock;
        unsigned int val, new;

        rwlock = *rwlockp;
        _rthread_debug(5, "%p: rwlock_unlock %p\n", self, (void *)rwlock);

        membar_exit_before_atomic();
        do {
                val = rwlock->value;
                if (COUNT(val) == WRITER || COUNT(val) == 1)
                        new = UNLOCKED;
                else
                        new = val - 1;
        } while (atomic_cas_uint(&rwlock->value, val, new) != val);

        if (new == UNLOCKED && (val & WAITING))
                _wake(&rwlock->value, INT_MAX);

        return (0);
}