/********************************************************/
/*  ntapi: Native API core library                      */
/*  Copyright (C) 2013--2016  Z. Gilboa                 */
/*  Released under GPLv2 and GPLv3; see COPYING.NTAPI.  */
/********************************************************/

#include <psxtypes/psxtypes.h>
#include <ntapi/nt_object.h>
#include <ntapi/nt_sync.h>
#include <ntapi/nt_atomic.h>
#include <ntapi/ntapi.h>
#include "ntapi_impl.h"

static void __sync_block_memset(
	__in	nt_sync_block *	sync_block,
	__in	intptr_t	value)
{
	intptr_t * sptr = sync_block->cache_line;

	at_store(&sptr[0x0],value);
	at_store(&sptr[0x1],value);
	at_store(&sptr[0x2],value);
	at_store(&sptr[0x3],value);
	at_store(&sptr[0x4],value);
	at_store(&sptr[0x5],value);
	at_store(&sptr[0x6],value);
	at_store(&sptr[0x7],value);

	if (sizeof(intptr_t) == 4) {
		at_store(&sptr[0x8],value);
		at_store(&sptr[0x9],value);
		at_store(&sptr[0xa],value);
		at_store(&sptr[0xb],value);
		at_store(&sptr[0xc],value);
		at_store(&sptr[0xd],value);
		at_store(&sptr[0xe],value);
		at_store(&sptr[0xf],value);
	}
}

void __stdcall __ntapi_tt_sync_block_init(
	__in	nt_sync_block *	sync_block,
	__in	uint32_t	flags			__optional,
	__in	int32_t		srvtid			__optional,
	__in	int32_t		default_lock_tries	__optional,
	__in	int64_t		default_lock_wait	__optional,
	__in	void *		hsignal			__optional)
{
	__sync_block_memset(
		sync_block,0);

	at_store_32(
		&sync_block->lock_tries,
		default_lock_tries
			? default_lock_tries
			: __NT_SYNC_BLOCK_LOCK_TRIES);

	at_store_64(
		&sync_block->lock_wait.quad,
		default_lock_wait
			? default_lock_wait
			: (-1));

	at_store_32(
		(int32_t *)&sync_block->flags,
		flags);

	at_store_32(
		(int32_t *)&sync_block->srvtid,
		srvtid);

	at_store(
		(intptr_t *)&sync_block->hsignal,
		(intptr_t)hsignal);
}


int32_t __stdcall __ntapi_tt_sync_block_lock(
	__in	nt_sync_block *	sync_block,
	__in	int32_t		lock_tries	__optional,
	__in	int64_t		lock_wait	__optional,
	__in	uint32_t *	sig_flag	__optional)
{
	int32_t		status;
	int32_t		tid;
	intptr_t	lock;
	void *		hwait[2];
	nt_timeout	timeout;

	/* validation */
	if (sync_block->invalid)
		return NT_STATUS_INVALID_HANDLE;

	/* already owned? */
	tid = pe_get_current_thread_id();
	if (sync_block->tid == tid) return NT_STATUS_SUCCESS;

	/* yield to server? */
	if ((sync_block->flags & NT_SYNC_BLOCK_YIELD_TO_SERVER)
			&& ((uint32_t)tid != sync_block->srvtid)) {
		hwait[0] = sync_block->hserver;
		hwait[1] = sync_block->hsignal;

		/* signal support */
		if (sig_flag && *sig_flag)
			return NT_STATUS_ALERTED;

		/* wait */
		status = __ntapi->zw_wait_for_multiple_objects(
			2,
			hwait,
			NT_WAIT_ANY,
			NT_SYNC_NON_ALERTABLE,
			(nt_timeout *)0);

		/* signal support */
		if (sig_flag && *sig_flag)
			return NT_STATUS_ALERTED;
	}

	/* first try */
	lock = at_locked_cas_32(&sync_block->tid,0,tid);
	if (lock && !--lock_tries) return NT_STATUS_NOT_LOCKED;

	/* first-time contended case? */
	if (lock && !sync_block->hwait) {
		status = __ntapi->tt_create_inheritable_event(
			&hwait[0],
			NT_NOTIFICATION_EVENT,
			NT_EVENT_NOT_SIGNALED);

		if (status) return status;

		lock = at_locked_cas(
			(intptr_t *)&sync_block->hwait,
			0,(intptr_t)hwait);

		if (lock)
			__ntapi->zw_close(hwait);

		/* try again without a wait */
		lock = at_locked_cas_32(&sync_block->tid,0,tid);
	}

	/* contended case? */
	if (lock) {
		hwait[0] = sync_block->hwait;
		hwait[1] = sync_block->hsignal;

		lock_tries = lock_tries
			? lock_tries
			: sync_block->lock_tries;

		timeout.quad = lock_wait
			? lock_wait
			: sync_block->lock_wait.quad;

		for (; lock && lock_tries; lock_tries--) {
			/* signal support */
			if (sig_flag && *sig_flag)
				return NT_STATUS_ALERTED;

			/* wait */
			status = __ntapi->zw_wait_for_multiple_objects(
				2,
				&sync_block->hwait,
				NT_WAIT_ANY,
				NT_SYNC_NON_ALERTABLE,
				&timeout);

			/* check status */
			if ((status != NT_STATUS_TIMEOUT) && ((uint32_t)status >= NT_STATUS_WAIT_CAP))
				return status;

			/* signal support */
			if (sig_flag && *sig_flag)
				return NT_STATUS_ALERTED;

			/* try again */
			lock = at_locked_cas_32(&sync_block->tid,0,tid);
		};
	}

	if (lock) return NT_STATUS_NOT_LOCKED;

	/* shared section support */
	at_store_32(
		&sync_block->pid,
		pe_get_current_process_id());

	return NT_STATUS_SUCCESS;
}


int32_t __stdcall __ntapi_tt_sync_block_server_lock(
	__in	nt_sync_block *	sync_block,
	__in	int32_t		lock_tries	__optional,
	__in	int64_t		lock_wait	__optional,
	__in	uint32_t *	sig_flag	__optional)
{
	int32_t status;

	/* validation */
	 if (sync_block->invalid)
		return NT_STATUS_INVALID_HANDLE;

	else if (sync_block->srvtid != pe_get_current_thread_id())
		return NT_STATUS_RESOURCE_NOT_OWNED;

	/* try once without yield request */
	status = __ntapi_tt_sync_block_lock(
		sync_block,
		1,
		lock_wait,
		sig_flag);

	if (status == NT_STATUS_SUCCESS)
		return status;

	/* hserver */
	if (!sync_block->hserver) {
		status = __ntapi->tt_create_inheritable_event(
			&sync_block->hserver,
			NT_NOTIFICATION_EVENT,
			NT_EVENT_NOT_SIGNALED);

		if (status) return status;
	} else {
		status = __ntapi->zw_reset_event(
			&sync_block->hserver,
			(int32_t *)0);

		if (status) return status;
	}

	/* yield request: set */
	at_locked_or_32(
		(int32_t *)&sync_block->flags,
		NT_SYNC_BLOCK_YIELD_TO_SERVER);

	/* try again */
	status = __ntapi_tt_sync_block_lock(
		sync_block,
		lock_tries,
		lock_wait,
		sig_flag);

	/* yield request: unset */
	at_locked_xor_32(
		(int32_t *)&sync_block->flags,
		NT_SYNC_BLOCK_YIELD_TO_SERVER);

	__ntapi->zw_set_event(
		sync_block->hserver,
		(int32_t *)0);

	/* (locking not guaranteed) */
	return status;
}


int32_t __stdcall __ntapi_tt_sync_block_unlock(
	__in	nt_sync_block *	sync_block)
{
	union {
		int64_t			i64;
		nt_large_integer	nti64;
	} cmp;

	if (sync_block->invalid)
		return NT_STATUS_INVALID_HANDLE;

	cmp.nti64.ihigh = pe_get_current_process_id();
	cmp.nti64.ulow  = pe_get_current_thread_id();

	if (cmp.i64 != at_locked_cas_64(
			(int64_t *)&sync_block->tid,
			cmp.i64,0))
		return NT_STATUS_RESOURCE_NOT_OWNED;

	return NT_STATUS_SUCCESS;
}


void __stdcall __ntapi_tt_sync_block_validate(
	__in	nt_sync_block *	sync_block)
{
	at_store_32(&sync_block->invalid,0);

	return;
}


int32_t __stdcall __ntapi_tt_sync_block_invalidate(
	__in	nt_sync_block *	sync_block)
{
	int32_t invalid;

	if (!sync_block)
		return NT_STATUS_INVALID_PARAMETER;

	invalid = at_locked_cas_32(
		&sync_block->invalid,
		0,
		1);

	if (invalid)
		return NT_STATUS_INVALID_HANDLE;

	return NT_STATUS_SUCCESS;
}


int32_t __stdcall __ntapi_tt_sync_block_discard(
	__in	nt_sync_block *	sync_block)
{
	if (!sync_block)
		return NT_STATUS_INVALID_PARAMETER;

	if (sync_block->hwait)
		__ntapi->zw_close(sync_block->hwait);

	if (sync_block->hserver)
		__ntapi->zw_close(sync_block->hserver);

	__sync_block_memset(
		sync_block,-1);

	return NT_STATUS_SUCCESS;
}