/*
 * Copyright (c) 2015 Michael Neumann <mneumann@ntecs.de>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _LINUX_WW_MUTEX_H_
#define _LINUX_WW_MUTEX_H_

/*
 * A basic, unoptimized implementation of wound/wait mutexes for DragonFly
 * modelled after the Linux API [1].
 *
 * [1]: http://lxr.free-electrons.com/source/include/linux/ww_mutex.h
 */

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/param.h>
#include <sys/mutex.h>
#include <machine/intr.h>
#include <linux/mutex.h>

struct ww_class {
	volatile u_long			stamp;
	const char			*name;
};

struct ww_acquire_ctx {
	u_long				stamp;
	struct ww_class			*ww_class;
};

struct ww_mutex {
	struct mutex			base;
	volatile int			acquired;
	struct ww_acquire_ctx		*ctx;
	volatile struct proc		*owner;
};

#define DEFINE_WW_CLASS(classname)	\
	struct ww_class classname = {	\
		.stamp = 0,		\
		.name = #classname	\
	}

#define DEFINE_WD_CLASS(classname)	\
	struct ww_class classname = {	\
		.stamp = 0,		\
		.name = #classname	\
	}

static inline void
ww_acquire_init(struct ww_acquire_ctx *ctx, struct ww_class *ww_class) {
	ctx->stamp = __sync_fetch_and_add(&ww_class->stamp, 1);
	ctx->ww_class = ww_class;
}

static inline void
ww_acquire_done(__unused struct ww_acquire_ctx *ctx) {
}

static inline void
ww_acquire_fini(__unused struct ww_acquire_ctx *ctx) {
}

static inline void
ww_mutex_init(struct ww_mutex *lock, struct ww_class *ww_class) {
	mtx_init(&lock->base, IPL_NONE);
	lock->acquired = 0;
	lock->ctx = NULL;
	lock->owner = NULL;
}

static inline bool
ww_mutex_is_locked(struct ww_mutex *lock) {
	bool res = false;
	mtx_enter(&lock->base);
	if (lock->acquired > 0) res = true;
	mtx_leave(&lock->base);
	return res;
}

/*
 * Return 1 if lock could be acquired, else 0 (contended).
 */
static inline int
ww_mutex_trylock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) {
	int res = 0;

	mtx_enter(&lock->base);
	/*
	 * In case no one holds the ww_mutex yet, we acquire it.
	 */
	if (lock->acquired == 0) {
		KASSERT(lock->ctx == NULL);
		lock->acquired = 1;
		lock->owner = curproc;
		res = 1;
	}
	mtx_leave(&lock->base);
	return res;
}

/*
 * When `slow` is `true`, it will always block if the ww_mutex is contended.
 * It is assumed that the called will not hold any (ww_mutex) resources when
 * calling the slow path as this could lead to deadlocks.
 *
 * When `intr` is `true`, the ssleep will be interruptible.
 */
static inline int
__ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx, bool slow, bool intr) {
	int err;

	mtx_enter(&lock->base);
	for (;;) {
		/*
		 * In case no one holds the ww_mutex yet, we acquire it.
		 */
		if (lock->acquired == 0) {
			KASSERT(lock->ctx == NULL);
			lock->acquired = 1;
			lock->ctx = ctx;
			lock->owner = curproc;
			err = 0;
			break;
		}
		/*
		 * In case we already hold the return -EALREADY.
		 */
		else if (lock->owner == curproc) {
			err = -EALREADY;
			break;
		}
		/*
		 * This is the contention case where the ww_mutex is
		 * already held by another context.
		 */
		else {
			/*
			 * Three cases:
			 *
			 * - We are in the slow-path (first lock to obtain).
                         *
			 * - No context was specified. We assume a single
			 *   resource, so there is no danger of a deadlock.
                         *
			 * - An `older` process (`ctx`) tries to acquire a
			 *   lock already held by a `younger` process.
                         *   We put the `older` process to sleep until
                         *   the `younger` process gives up all it's
                         *   resources.
			 */
			if (slow || ctx == NULL ||
			    (lock->ctx && ctx->stamp < lock->ctx->stamp)) {
				KASSERT(!cold);
				int s = msleep_nsec(lock, &lock->base,
				    intr ? PCATCH : 0,
				    ctx ? ctx->ww_class->name : "ww_mutex_lock",
				    INFSLP);
				if (intr && (s == EINTR || s == ERESTART)) {
					// XXX: Should we handle ERESTART?
					err = -EINTR;
					break;
				}
			}
			/*
			 * If a `younger` process tries to acquire a lock
			 * already held by an `older` process, we `wound` it,
			 * i.e. we return -EDEADLK because there is a potential
			 * risk for a deadlock. The `younger` process then
			 * should give up all it's resources and try again to
			 * acquire the lock in question, this time in a
			 * blocking manner.
			 */
			else {
				err = -EDEADLK;
				break;
			}
		}

	} /* for */
	mtx_leave(&lock->base);
	return err;
}

static inline int
ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) {
	return __ww_mutex_lock(lock, ctx, false, false);
}
	
static inline void
ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) {
	(void)__ww_mutex_lock(lock, ctx, true, false);
}

static inline int
ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) {
	return __ww_mutex_lock(lock, ctx, false, true);
}
	
static inline int __must_check
ww_mutex_lock_slow_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) {
	return __ww_mutex_lock(lock, ctx, true, true);
}

static inline void
ww_mutex_unlock(struct ww_mutex *lock) {
	mtx_enter(&lock->base);
	KASSERT(lock->owner == curproc);
	KASSERT(lock->acquired == 1);

	lock->acquired = 0;
	lock->ctx = NULL;
	lock->owner = NULL;
	mtx_leave(&lock->base);
	wakeup(lock);
}

static inline void
ww_mutex_destroy(struct ww_mutex *lock) {
	KASSERT(lock->acquired == 0);
	KASSERT(lock->ctx == NULL);
	KASSERT(lock->owner == NULL);
}

#endif	/* _LINUX_WW_MUTEX_H_ */