xref: /dragonfly/sys/dev/drm/linux_wwmutex.c (revision 23d2c0d6)

/*-
 * Copyright (c) 2003-2011 The DragonFly Project.  All rights reserved.
 * Copyright (c) 2015 Michael Neumann <mneumann@ntecs.de>.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com> and
 *    Michael Neumann <mneumann@ntecs.de>
 *
 * 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.
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/spinlock.h>
#include <sys/spinlock2.h>

#include <machine/atomic.h>

#include <linux/ww_mutex.h>

void
ww_acquire_init(struct ww_acquire_ctx *ctx, struct ww_class *ww_class)
{
	ctx->stamp = atomic_fetchadd_long(&ww_class->stamp, 1);
	ctx->acquired = 0;
	ctx->ww_class = ww_class;
}

void
ww_acquire_done(struct ww_acquire_ctx *ctx __unused)
{
}

void
ww_acquire_fini(struct ww_acquire_ctx *ctx __unused)
{
}

void
ww_mutex_init(struct ww_mutex *ww, struct ww_class *ww_class)
{
	lockinit(&ww->base, ww_class->name, 0, LK_CANRECURSE);
	ww->ctx = NULL;
	ww->stamp = 0xFFFFFFFFFFFFFFFFLU;
	ww->blocked = 0;
}

void
ww_mutex_destroy(struct ww_mutex *ww)
{
	lockuninit(&ww->base);
}

/*
 * Optimized lock path.
 *
 * (slow) is optional as long as we block normally on the initial lock.
 * Currently not implemented.
 */
static __inline
int
__wwlock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx,
	 bool slow __unused, bool intr)
{
	int flags = LK_EXCLUSIVE;
	int error;

	if (intr)
		flags |= LK_PCATCH;

	/*
	 * Normal mutex if ctx is NULL
	 */
	if (ctx == NULL) {
		error = lockmgr(&ww->base, flags);
		if (error)
			error = -EINTR;
		return error;
	}

	/*
	 * A normal blocking lock can be used when ctx->acquired is 0 (no
	 * prior locks are held).  If prior locks are held then we cannot
	 * block here.
	 *
	 * In the non-blocking case setup our tsleep interlock using
	 * ww->blocked first.
	 */
	for (;;) {
		if (ctx->acquired != 0) {
			atomic_swap_int(&ww->blocked, 1);
			flags |= LK_NOWAIT;
			tsleep_interlock(ww, (intr ? PCATCH : 0));
		}
		error = lockmgr(&ww->base, flags);
		if (error == 0) {
			ww->ctx = ctx;
			ww->stamp = ctx->stamp;
			++ctx->acquired;
			return 0;
		}

		/*
		 * EINTR or ERESTART returns -EINTR.  ENOLCK and EWOULDBLOCK
		 * cannot happen (LK_SLEEPFAIL not set, timeout is not set).
		 */
		if (error != EBUSY)
			return -EINTR;

		/*
		 * acquired can only be non-zero in this path.
		 * NOTE: ww->ctx is not MPSAFE.
		 * NOTE: ww->stamp is heuristical, a race is possible.
		 */
		KKASSERT(ctx->acquired > 0);

		/*
		 * Unwind if we aren't the oldest.
		 */
		if (ctx->stamp > ww->stamp)
			return -EDEADLK;

		/*
		 * We have priority over the currently held lock.  We have
		 * already setup the interlock so we can tsleep() until the
		 * remote wakes us up (which may have already happened).
		 *
		 * error is zero if woken up
		 *	    EINTR / ERESTART - signal
		 *	    EWOULDBLOCK	     - timeout expired (if not 0)
		 */
		if (flags & LK_NOWAIT) {
			error = tsleep(ww, PINTERLOCKED | (intr ? PCATCH : 0),
				       ctx->ww_class->name, 0);
			if (intr && (error == EINTR || error == ERESTART))
				return -EINTR;
			flags &= ~LK_NOWAIT;
		}
		/* retry */
	}
}

int
ww_mutex_lock(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
{
	return __wwlock(ww, ctx, 0, 0);
}

int
ww_mutex_lock_slow(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
{
	return __wwlock(ww, ctx, 1, 0);
}

int
ww_mutex_lock_interruptible(struct ww_mutex *ww, struct ww_acquire_ctx *ctx)
{
	return __wwlock(ww, ctx, 0, 1);
}

int
ww_mutex_lock_slow_interruptible(struct ww_mutex *ww,
				 struct ww_acquire_ctx *ctx)
{
	return __wwlock(ww, ctx, 1, 1);
}

void
ww_mutex_unlock(struct ww_mutex *ww)
{
	struct ww_acquire_ctx *ctx;

	ctx = ww->ctx;
	if (ctx) {
		KKASSERT(ctx->acquired > 0);
		--ctx->acquired;
		ww->ctx = NULL;
		ww->stamp = 0xFFFFFFFFFFFFFFFFLU;
	}
	lockmgr(&ww->base, LK_RELEASE);
	if (atomic_swap_int(&ww->blocked, 0))
		wakeup(ww);
}