/*
 * Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include "boilerplate/tlsf/tlsf.h"
#include "copperplate/heapobj.h"
#include "copperplate/debug.h"
#include "copperplate/threadobj.h"
#include "xenomai/init.h"
#include "internal.h"

#if LONG_BIT == 32
#define TLSF_BLOCK_ALIGN  (8 * 2)
#else
#define TLSF_BLOCK_ALIGN  (16 * 2)
#endif

static int tlsf_pool_overhead;

int __heapobj_init_private(struct heapobj *hobj, const char *name,
			   size_t size, void *mem)
{
	if (mem == NULL) {
		/*
		 * When the memory area is unspecified, obtain it from
		 * the main pool, accounting for the TLSF overhead.
		 */
		size += tlsf_pool_overhead;
		mem = tlsf_malloc(size);
		if (mem == NULL)
			return __bt(-ENOMEM);
	}

	if (name)
		snprintf(hobj->name, sizeof(hobj->name), "%s", name);
	else
		snprintf(hobj->name, sizeof(hobj->name), "%p", hobj);

	hobj->pool = mem;
	/* Make sure to wipe out tlsf's signature. */
	memset(mem, 0, size < 32 ? size : 32);
	hobj->size = init_memory_pool(size, mem);
	if (hobj->size == (size_t)-1)
		return __bt(-EINVAL);

	return 0;
}

int heapobj_init_array_private(struct heapobj *hobj, const char *name,
			       size_t size, int elems)
{
	size_t poolsz;

	if (size == 0 || elems <= 0)
		return __bt(-EINVAL);

	poolsz = (size + TLSF_BLOCK_ALIGN - 1) & ~(TLSF_BLOCK_ALIGN - 1);
	poolsz *= elems;

	return __bt(__heapobj_init_private(hobj, name, poolsz, NULL));
}

int heapobj_pkg_init_private(void)
{
	size_t alloc_size, available_size;
	void *mem;

#ifdef CONFIG_XENO_PSHARED
	alloc_size = MIN_TLSF_HEAPSZ;
#else
	alloc_size = __copperplate_setup_data.mem_pool;
	if (alloc_size < MIN_TLSF_HEAPSZ)
		alloc_size = MIN_TLSF_HEAPSZ;
#endif
	/*
	 * We want to know how many bytes from a memory pool TLSF will
	 * use for its own internal use. We get the probe memory from
	 * tlsf_malloc(), so that the main pool will be set up in the
	 * same move.
	 *
	 * We include 1k of additional memory to cope with the
	 * per-block overhead for an undefined number of individual
	 * allocation requests. Ugly.
	 *
	 * CAUTION: in pshared mode, private heaps are subsidiary
	 * storage pools, so no need to pre-commit as much memory as
	 * we will be preallocating for the main shared pool,
	 * especially with memory locking in effect. In that case,
	 * creating a temporary single-page pool is enough to figure
	 * out the allocation overhead.
	 */
	mem = tlsf_malloc(alloc_size);
	available_size = init_memory_pool(alloc_size, mem);
	if (available_size == (size_t)-1)
		panic("cannot initialize TLSF memory manager");

	destroy_memory_pool(mem);
	tlsf_pool_overhead = alloc_size - available_size;
	tlsf_pool_overhead = (tlsf_pool_overhead + 1024) & ~15;
	tlsf_free(mem);

	return 0;
}