/*
 * posix_partition.c
 */
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "private.h"

extern void sysheap_suppress_leak_detection(void);
extern void sysheap_restore_leak_detection(void);

typedef struct _key_data key_data_t;
struct _key_data {
	lub_partition_t *partition;
	lub_heap_t *local_heap;
};
/*-------------------------------------------------------- */
static void lub_posix_partition_destroy_key(void *arg)
{
	key_data_t *key_data = arg;
	lub_partition_destroy_local_heap(key_data->partition,
					 key_data->local_heap);
	lub_partition_global_realloc(key_data->partition, (char **)key_data, 0,
				     LUB_HEAP_ALIGN_NATIVE);
}

/*-------------------------------------------------------- */
lub_partition_t *lub_partition_create(const lub_partition_spec_t * spec)
{
	lub_posix_partition_t *this;
	lub_partition_sysalloc_fn *alloc_fn = spec->sysalloc;
	if (!alloc_fn) {
		alloc_fn = malloc;
	}
	this = alloc_fn(sizeof(lub_posix_partition_t));
	if (this) {
		lub_posix_partition_init(this, spec);
	}
	return &this->m_base;
}

/*-------------------------------------------------------- */
void
lub_posix_partition_init(lub_posix_partition_t * this,
			 const lub_partition_spec_t * spec)
{
	memset(this, sizeof(*this), 0);
	/* initialise the base class */
	lub_partition_init(&this->m_base, spec);

	/* initialise the global mutex */
	if (0 != pthread_mutex_init(&this->m_mutex, 0)) {
		perror("pthread_mutex_init() failed!");
	}
	/* initialise the local key */
	if (0 != pthread_key_create(&this->m_key,
				    lub_posix_partition_destroy_key)) {
		perror("pthread_key_create() failed!");
	}
}

/*-------------------------------------------------------- */
void lub_partition_destroy(lub_partition_t * instance)
{
	lub_posix_partition_t *this = (void *)instance;

	/* finalise the base class */
	lub_partition_fini(&this->m_base);

	/* now clean up the global mutex */
	if (0 != pthread_mutex_destroy(&this->m_mutex)) {
		perror("pthread_mutex_destroy() failed!");
	}

	/* now clean up the local key */
	if (0 != pthread_key_delete(this->m_key)) {
		perror("pthread_key_delete() failed!");
	}

	free(this);
}

/*-------------------------------------------------------- */
lub_heap_t *lub_partition__get_local_heap(lub_partition_t * instance)
{
	lub_heap_t *result = 0;
	lub_posix_partition_t *this = (void *)instance;
	key_data_t *key_data = pthread_getspecific(this->m_key);
	if (key_data) {
		result = key_data->local_heap;
	}
	return result;
}

/*-------------------------------------------------------- */
void
lub_partition__set_local_heap(lub_partition_t * instance, lub_heap_t * heap)
{
	lub_posix_partition_t *this = (void *)instance;
	key_data_t *key_data = 0;

#if defined(__CYGWIN__)
	/* cygwin seems to leak key_data!!! so we ignore this for the time being... */
	lub_heap_leak_suppress_detection(instance->m_global_heap);
#endif				/* __CYGWIN__ */
	lub_partition_global_realloc(instance, (char **)&key_data,
				     sizeof(key_data_t), LUB_HEAP_ALIGN_NATIVE);
#if defined(__CYGWIN__)
	/* cygwin seems to leak key_data!!! so we ignore this for the time being... */
	lub_heap_leak_restore_detection(instance->m_global_heap);
#endif				/* __CYGWIN__ */
	assert(key_data);
	key_data->partition = instance;
	key_data->local_heap = heap;
	if (0 != pthread_getspecific(this->m_key)) {
		assert(NULL == "Local heap already exists!");
	}
	if (0 != pthread_setspecific(this->m_key, key_data)) {
		perror("pthread_setspecific() failed!");
	}
}

/*-------------------------------------------------------- */
void lub_partition_lock(lub_partition_t * instance)
{
	lub_posix_partition_t *this = (void *)instance;

	if (0 != pthread_mutex_lock(&this->m_mutex)) {
		perror("pthread_mutex_lock() failed!");
	}
}

/*-------------------------------------------------------- */
void lub_partition_unlock(lub_partition_t * instance)
{
	lub_posix_partition_t *this = (void *)instance;

	if (0 != pthread_mutex_unlock(&this->m_mutex)) {
		perror("pthread_mutex_unlock() failed!");
	}
}

/*-------------------------------------------------------- */