/* See the end of this file for copyright and license terms. */

#include <arch/atom.h>

#include <gay/clist.h>
#include <gay/mutex.h>
#include <gay/sched.h>

#include <errno.h>

void spin_init(spin_t *spin)
{
	atom_write(&spin->lock, 0);
}

void spin_lock(spin_t *spin)
{
	while (atom_write(&spin->lock, 1) != 0);
		/* nothing */
}

int spin_trylock(spin_t *spin)
{
	if (atom_write(&spin->lock, 1) != 0)
		return -EAGAIN;
	return 0;
}

void spin_unlock(spin_t *spin)
{
	atom_write(&spin->lock, 0);
}

void mtx_init(struct mtx *mtx)
{
	atom_write(&mtx->lock, 0);
	spin_init(&mtx->wait_queue_lock);
	clist_init(&mtx->wait_queue);
}

void mtx_lock(struct mtx *mtx)
{
	/*
	 * acquire a lock on the wait queue before trying to claim the
	 * mutex itself to make sure the mutex isn't released while we
	 * are inserting ourselves into the wait queue
	 */
	spin_lock(&mtx->wait_queue_lock);
	if (atom_write(&mtx->lock, 1) == 0) {
		spin_unlock(&mtx->wait_queue_lock);
	} else {
		struct task *task = current;
		/*
		 * It might not be the smartest idea to allocate this thing on
		 * the stack because it's gonna blow up if the task somehow dies
		 * before returning here.  Let's see how this turns out.
		 */
		struct lock_waiter waiter = {
			.task = task,
		};
		clist_add(&mtx->wait_queue, &waiter.clink);
		spin_unlock(&mtx->wait_queue_lock);

		task->state = TASK_BLOCKED;
		/*
		 * This is only gonna return when the task currently owning the
		 * lock releases it.  In that case, it doesn't unlock the mutex
		 * but merely switches back to us directly and thereby implicitly
		 * transfers the ownership of the mutex to us (see mtx_unlock()).
		 */
		schedule();
	}
}

int mtx_trylock(struct mtx *mtx)
{
	if (atom_write(&mtx->lock, 1) != 0)
		return -EAGAIN;
	return 0;
}

void mtx_unlock(struct mtx *mtx)
{
	spin_lock(&mtx->wait_queue_lock);
	if (!clist_is_empty(&mtx->wait_queue)) {
		struct lock_waiter *waiter =
			clist_first_entry(&mtx->wait_queue, typeof(*waiter), clink);
		clist_del(&waiter->clink);
		spin_unlock(&mtx->wait_queue_lock);
		waiter->task->state = TASK_READY;
		switch_to(waiter->task, current);
	} else {
		atom_write(&mtx->lock, 0);
		spin_unlock(&mtx->wait_queue_lock);
	}
}

/*
 * This file is part of GayBSD.
 * Copyright (c) 2021 fef <owo@fef.moe>.
 *
 * GayBSD is nonviolent software: you may only use, redistribute, and/or
 * modify it under the terms of the Cooperative Nonviolent Public License
 * (CNPL) as found in the LICENSE file in the source code root directory
 * or at <https://git.pixie.town/thufie/npl-builder>; either version 7
 * of the license, or (at your option) any later version.
 *
 * GayBSD comes with ABSOLUTELY NO WARRANTY, to the extent
 * permitted by applicable law.  See the CNPL for details.
 */