#define _GNU_SOURCE
#include "pthread_impl.h"
#include "stdio_impl.h"
#include "libc.h"
#include <sys/mman.h>
#include <threads.h>

void *__mmap(void *, size_t, int, int, int, off_t);
int __munmap(void *, size_t);
int __mprotect(void *, size_t, int);
void __thread_enable(void);
void *__copy_tls(unsigned char *);
extern volatile size_t __pthread_tsd_size;

static void dummy_0()
{
}
weak_alias(dummy_0, __acquire_ptc);
weak_alias(dummy_0, __release_ptc);

static int start(void *p)
{
	thrd_t self = p;
	int (*start)(void*) = (int(*)(void*)) self->start;
	thrd_exit(start(self->start_arg));
	return 0;
}

#define ROUND(x) (((x)+PAGE_SIZE-1)&-PAGE_SIZE)

int thrd_create(thrd_t *res, thrd_start_t entry, void *arg)
{
	int ret = -ENOMEM;
	size_t guard = ROUND(DEFAULT_GUARD_SIZE);
	size_t size = guard + ROUND(DEFAULT_STACK_SIZE + libc.tls_size +  __pthread_tsd_size);
	struct pthread *self, *new;
	unsigned char *map, *stack, *tsd, *stack_limit;
	unsigned flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND
		| CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS
		| CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID | CLONE_DETACHED;

	if (!libc.can_do_threads) return thrd_error;
	self = __pthread_self();
	if (!libc.threaded) __thread_enable();

	__acquire_ptc();

	if (guard) {
		map = __mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANON, -1, 0);
		if (map == MAP_FAILED) goto CLEANUP;
		if (__mprotect(map+guard, size-guard, PROT_READ|PROT_WRITE)) {
			__munmap(map, size);
			goto CLEANUP;
		}
	} else {
		map = __mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
		if (map == MAP_FAILED) goto CLEANUP;
	}
	tsd = map + size - __pthread_tsd_size;
	stack = tsd - libc.tls_size;
	stack_limit = map + guard;

	new = __copy_tls(tsd - libc.tls_size);
	new->map_base = map;
	new->map_size = size;
	new->stack = stack;
	new->stack_size = stack - stack_limit;
	new->start = (void *(*)(void*))entry;
	new->start_arg = arg;
	new->self = new;
	new->tsd = (void *)tsd;
	new->locale = &libc.global_locale;
	new->unblock_cancel = self->cancel;
	new->canary = self->canary;

	a_inc(&libc.threads_minus_1);
	ret = __clone(start, stack, flags, new, &new->tid, TP_ADJ(new), &new->tid);

 CLEANUP:
	__release_ptc();

	if (ret > 0) {
          *res = new;
          ret = thrd_success;
        } else if (ret == -ENOMEM) {
          ret = thrd_nomem;
        } else {
          a_dec(&libc.threads_minus_1);
          if (map) __munmap(map, size);
          ret = thrd_error;
	}
        return ret;
}