/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "pthread_private.h"

#include <syscalls.h>


static inline void
test_asynchronous_cancel(int32 flags)
{
	static const int32 kFlags = THREAD_CANCELED | THREAD_CANCEL_ENABLED
		| THREAD_CANCEL_ASYNCHRONOUS;

	if ((~flags & kFlags) == 0)
		pthread_exit(PTHREAD_CANCELED);
}


/*!	Signal handler like function invoked when this thread has been canceled.
	Has the simple signal handler signature, since it is invoked just like a
	signal handler.
*/
static void
asynchronous_cancel_thread(int)
{
	pthread_t thread = pthread_self();

	// Exit when asynchronous cancellation is enabled, otherwise we don't have
	// to do anything -- the syscall interrupting side effect is all we need.
	if ((atomic_get(&thread->flags) & THREAD_CANCEL_ASYNCHRONOUS) != 0)
		pthread_exit(PTHREAD_CANCELED);
}


// #pragma mark - public API


int
pthread_cancel(pthread_t thread)
{
	// set the canceled flag
	int32 oldFlags = atomic_or(&thread->flags, THREAD_CANCELED);

	// If the flag was already set, we're done.
	if ((oldFlags & THREAD_CANCELED) != 0)
		return 0;

	// If cancellation is enabled, notify the thread. This will call the
	// asynchronous_cancel_thread() handler.
	if ((oldFlags & THREAD_CANCEL_ENABLED) != 0) {
		int result = _kern_cancel_thread(thread->id, &asynchronous_cancel_thread);
		if (result == B_BAD_THREAD_ID)
			return ESRCH;
		return result;
	}

	return 0;
}


int
pthread_setcancelstate(int state, int *_oldState)
{
	pthread_thread* thread = pthread_self();
	if (thread == NULL)
		return EINVAL;

	// set the new flags
	int32 oldFlags;
	if (state == PTHREAD_CANCEL_ENABLE) {
		oldFlags = atomic_or(&thread->flags, THREAD_CANCEL_ENABLED);
		test_asynchronous_cancel(oldFlags | THREAD_CANCEL_ENABLED);
	} else if (state == PTHREAD_CANCEL_DISABLE) {
		oldFlags = atomic_and(&thread->flags, ~(int32)THREAD_CANCEL_ENABLED);
		test_asynchronous_cancel(oldFlags);
	} else
		return EINVAL;

	// return the old state
	if (_oldState != NULL) {
		*_oldState = (oldFlags & THREAD_CANCEL_ENABLED) != 0
			? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE;
	}

	return 0;
}


int
pthread_setcanceltype(int type, int *_oldType)
{
	pthread_thread* thread = pthread_self();
	if (thread == NULL)
		return EINVAL;

	// set the new type
	int32 oldFlags;
	if (type == PTHREAD_CANCEL_DEFERRED) {
		oldFlags = atomic_and(&thread->flags,
			~(int32)THREAD_CANCEL_ASYNCHRONOUS);
		test_asynchronous_cancel(oldFlags);
	} else if (type == PTHREAD_CANCEL_ASYNCHRONOUS) {
		oldFlags = atomic_or(&thread->flags, THREAD_CANCEL_ASYNCHRONOUS);
		test_asynchronous_cancel(oldFlags | THREAD_CANCEL_ASYNCHRONOUS);
	} else
		return EINVAL;

	// return the old type
	if (_oldType != NULL) {
		*_oldType = (oldFlags & THREAD_CANCEL_ASYNCHRONOUS) != 0
			? PTHREAD_CANCEL_ASYNCHRONOUS : PTHREAD_CANCEL_DEFERRED;
	}

	return 0;
}


void
pthread_testcancel(void)
{
	pthread_thread* thread = pthread_self();
	if (thread == NULL)
		return;

	static const int32 kFlags = THREAD_CANCELED | THREAD_CANCEL_ENABLED;

	if ((~atomic_get(&thread->flags) & kFlags) == 0)
		pthread_exit(NULL);
}