/*
 * $Id: stdlib_malloc.c,v 1.20 2008-09-30 14:09:00 obarthel Exp $
 *
 * :ts=4
 *
 * Portable ISO 'C' (1994) runtime library for the Amiga computer
 * Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Neither the name of Olaf Barthel nor the names of contributors
 *     may be used to endorse or promote products derived from this
 *     software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*#define DEBUG*/

#ifndef _STDLIB_HEADERS_H
#include "stdlib_headers.h"
#endif /* _STDLIB_HEADERS_H */

/****************************************************************************/

#ifndef _STDLIB_MEMORY_H
#include "stdlib_memory.h"
#endif /* _STDLIB_MEMORY_H */

/****************************************************************************/

#ifndef _STDLIB_CONSTRUCTOR_H
#include "stdlib_constructor.h"
#endif /* _STDLIB_CONSTRUCTOR_H */

/****************************************************************************/

#undef malloc
#undef __malloc

/****************************************************************************/

unsigned long NOCOMMON __maximum_memory_allocated;
unsigned long NOCOMMON __current_memory_allocated;
unsigned long NOCOMMON __maximum_num_memory_chunks_allocated;
unsigned long NOCOMMON __current_num_memory_chunks_allocated;

/****************************************************************************/

#if defined(__MEM_DEBUG) && defined(__USE_MEM_TREES)
struct MemoryTree NOCOMMON __memory_tree;
#endif /* __MEM_DEBUG && __USE_MEM_TREES */

/****************************************************************************/

APTR			NOCOMMON __memory_pool;
struct MinList	NOCOMMON __memory_list;

/****************************************************************************/

void *
__allocate_memory(size_t size,BOOL never_free,const char *debug_file_name UNUSED,int debug_line_number UNUSED)
{
	struct MemoryNode * mn;
	size_t allocation_size;
	void * result = NULL;

	#if defined(UNIX_PATH_SEMANTICS)
	size_t original_size;

	{
		original_size = size;

		/* The libunix.a flavour accepts zero length memory allocations
		   and quietly turns them into a pointer sized allocations. */
		if(size == 0)
			size = sizeof(char *);
	}
	#endif /* UNIX_PATH_SEMANTICS */

	__memory_lock();

	/* Zero length allocations are by default rejected. */
	if(size == 0)
	{
		__set_errno(EINVAL);
		goto out;
	}

	if(__free_memory_threshold > 0 && AvailMem(MEMF_ANY|MEMF_LARGEST) < __free_memory_threshold)
	{
		SHOWMSG("not enough free memory available to safely proceed with allocation");
		goto out;
	}

	#ifdef __MEM_DEBUG
	{
		assert( MALLOC_HEAD_SIZE > 0 && (MALLOC_HEAD_SIZE % 4) == 0 );
		assert( MALLOC_TAIL_SIZE > 0 && (MALLOC_TAIL_SIZE % 4) == 0 );
		assert( (sizeof(*mn) % 4) == 0 );

		allocation_size = sizeof(*mn) + MALLOC_HEAD_SIZE + size + MALLOC_TAIL_SIZE;
	}
	#else
	{
		/* Round up allocation to a multiple of 32 bits. */
		if((size & 3) != 0)
			size += 4 - (size & 3);

		allocation_size = sizeof(*mn) + size;
	}
	#endif /* __MEM_DEBUG */

	/* Integer overflow has occured? */
	if(size == 0 || allocation_size < size)
	{
		__set_errno(ENOMEM);
		goto out;
	}

	/* We reuse the MemoryNode.mn_Size field to mark
	 * allocations are not suitable for use with
	 * free() and realloc(). This limits allocation
	 * sizes to a little less than 2 GBytes.
	 */
	if(allocation_size & MN_SIZE_NEVERFREE)
	{
		__set_errno(ENOMEM);
		goto out;
	}

	#if defined(__USE_SLAB_ALLOCATOR)
	{
		/* Are we using the slab allocator? */
		if(__slab_data.sd_InUse)
		{
			mn = __slab_allocate(allocation_size);
		}
		else
		{
			if (__memory_pool != NULL)
			{
				PROFILE_OFF();
				mn = AllocPooled(__memory_pool,allocation_size);
				PROFILE_ON();
			}
			else
			{
				#ifdef __MEM_DEBUG
				{
					PROFILE_OFF();
					mn = AllocMem(allocation_size,MEMF_ANY);
					PROFILE_ON();
				}
				#else
				{
					struct MinNode * mln;

					PROFILE_OFF();
					mln = AllocMem(sizeof(*mln) + allocation_size,MEMF_ANY);
					PROFILE_ON();

					if(mln != NULL)
					{
						AddTail((struct List *)&__memory_list,(struct Node *)mln);

						mn = (struct MemoryNode *)&mln[1];
					}
					else
					{
						mn = NULL;
					}
				}
				#endif /* __MEM_DEBUG */
			}
		}
	}
	#else
	{
		if(__memory_pool != NULL)
		{
			PROFILE_OFF();
			mn = AllocPooled(__memory_pool,allocation_size);
			PROFILE_ON();
		}
		else
		{
			#ifdef __MEM_DEBUG
			{
				PROFILE_OFF();
				mn = AllocMem(allocation_size,MEMF_ANY);
				PROFILE_ON();
			}
			#else
			{
				struct MinNode * mln;

				PROFILE_OFF();
				mln = AllocMem(sizeof(*mln) + allocation_size,MEMF_ANY);
				PROFILE_ON();

				if(mln != NULL)
				{
					AddTail((struct List *)&__memory_list,(struct Node *)mln);

					mn = (struct MemoryNode *)&mln[1];
				}
				else
				{
					mn = NULL;
				}
			}
			#endif /* __MEM_DEBUG */
		}
	}
	#endif /* __USE_SLAB_ALLOCATOR */

	if(mn == NULL)
	{
		SHOWMSG("not enough memory");
		goto out;
	}

	mn->mn_Size = size;

	if(never_free)
		SET_FLAG(mn->mn_Size, MN_SIZE_NEVERFREE);

	__current_memory_allocated += allocation_size;
	if(__maximum_memory_allocated < __current_memory_allocated)
		__maximum_memory_allocated = __current_memory_allocated;

	__current_num_memory_chunks_allocated++;
	if(__maximum_num_memory_chunks_allocated < __current_num_memory_chunks_allocated)
		__maximum_num_memory_chunks_allocated = __current_num_memory_chunks_allocated;

	#ifdef __MEM_DEBUG
	{
		char * head = (char *)(mn + 1);
		char * body = head + MALLOC_HEAD_SIZE;
		char * tail = body + size;

		AddTail((struct List *)&__memory_list,(struct Node *)mn);

		mn->mn_AlreadyFree		= FALSE;
		mn->mn_Allocation		= body;
		mn->mn_AllocationSize	= allocation_size;
		mn->mn_File				= (char *)debug_file_name;
		mn->mn_Line				= debug_line_number;
		mn->mn_FreeFile			= NULL;
		mn->mn_FreeLine			= 0;

		memset(head,MALLOC_HEAD_FILL,MALLOC_HEAD_SIZE);
		memset(body,MALLOC_NEW_FILL,size);
		memset(tail,MALLOC_TAIL_FILL,MALLOC_TAIL_SIZE);

		#ifdef __MEM_DEBUG_LOG
		{
			kprintf("[%s] + %10ld 0x%08lx [",__program_name,size,body);

			kprintf("allocated at %s:%ld]\n",debug_file_name,debug_line_number);
		}
		#endif /* __MEM_DEBUG_LOG */

		#ifdef __USE_MEM_TREES
		{
			__red_black_tree_insert(&__memory_tree,mn);
		}
		#endif /* __USE_MEM_TREES */

		result = mn->mn_Allocation;
	}
	#else
	{
		result = &mn[1];
	}
	#endif /* __MEM_DEBUG */

	#if defined(UNIX_PATH_SEMANTICS)
	{
		/* Set the zero length allocation contents to NULL. */
		if(original_size == 0)
			*(char **)result = NULL;
	}
	#endif /* UNIX_PATH_SEMANTICS */

	assert( (((ULONG)result) & 3) == 0 );

 out:

	#ifdef __MEM_DEBUG_LOG
	{
		if(result == NULL)
		{
			kprintf("[%s] + %10ld 0x%08lx [",__program_name,size,NULL);

			kprintf("FAILED: allocated at %s:%ld]\n",debug_file_name,debug_line_number);
		}
	}
	#endif /* __MEM_DEBUG_LOG */

	__memory_unlock();

	return(result);
}

/****************************************************************************/

__static void *
__malloc(size_t size,const char * file,int line)
{
	void * result = NULL;

	__memory_lock();

	/* Try to get rid of now unused memory. */
	if(__alloca_cleanup != NULL)
		(*__alloca_cleanup)(file,line);

	__memory_unlock();

	#ifdef __MEM_DEBUG
	{
		/*if((rand() % 16) == 0)
			__check_memory_allocations(file,line);*/
	}
	#endif /* __MEM_DEBUG */

	/* Allocate memory which can be put through realloc() and free(). */
	result = __allocate_memory(size,FALSE,file,line);

	return(result);
}

/****************************************************************************/

void *
malloc(size_t size)
{
	void * result;

	result = __malloc(size,NULL,0);

	return(result);
}

/****************************************************************************/

#if defined(__THREAD_SAFE)

/****************************************************************************/

static struct SignalSemaphore * memory_semaphore;

/****************************************************************************/

void
__memory_lock(void)
{
	PROFILE_OFF();

	if(memory_semaphore != NULL)
		ObtainSemaphore(memory_semaphore);

	PROFILE_ON();
}

/****************************************************************************/

void
__memory_unlock(void)
{
	PROFILE_OFF();

	if(memory_semaphore != NULL)
		ReleaseSemaphore(memory_semaphore);

	PROFILE_ON();
}

/****************************************************************************/

#endif /* __THREAD_SAFE */

/****************************************************************************/

STDLIB_DESTRUCTOR(stdlib_memory_exit)
{
	ENTER();

	#ifdef __MEM_DEBUG
	{
		kprintf("[%s] %ld bytes still allocated upon exit, maximum of %ld bytes allocated at a time.\n",
			__program_name,__current_memory_allocated,__maximum_memory_allocated);

		kprintf("[%s] %ld chunks of memory still allocated upon exit, maximum of %ld chunks allocated at a time.\n",
			__program_name,__current_num_memory_chunks_allocated,__maximum_num_memory_chunks_allocated);

		__check_memory_allocations(__FILE__,__LINE__);

		__never_free = FALSE;

		if(__memory_list.mlh_Head != NULL)
		{
			while(NOT IsMinListEmpty(&__memory_list))
			{
				((struct MemoryNode *)__memory_list.mlh_Head)->mn_AlreadyFree = FALSE;

				__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,__FILE__,__LINE__);
			}
		}

		#if defined(__USE_MEM_TREES)
		{
			__initialize_red_black_tree(&__memory_tree);
		}
		#endif /* __USE_MEM_TREES */
	}
	#endif /* __MEM_DEBUG */

	#if defined(__USE_SLAB_ALLOCATOR)
	{
		/* Is the slab memory allocator enabled? */
		if (__slab_data.sd_InUse)
		{
			__slab_exit();
		}
		else
		{
			if (__memory_pool != NULL)
			{
				NewList((struct List *)&__memory_list);

				DeletePool(__memory_pool);
				__memory_pool = NULL;
			}
			else if (__memory_list.mlh_Head != NULL)
			{
				#ifdef __MEM_DEBUG
				{
					while(NOT IsMinListEmpty(&__memory_list))
						__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,__FILE__,__LINE__);
				}
				#else
				{
					while(NOT IsMinListEmpty(&__memory_list))
						__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,NULL,0);
				}
				#endif /* __MEM_DEBUG */
			}
		}
	}
	#else
	{
		if (__memory_pool != NULL)
		{
			NewList((struct List *)&__memory_list);

			DeletePool(__memory_pool);
			__memory_pool = NULL;
		}
		else if (__memory_list.mlh_Head != NULL)
		{
			#ifdef __MEM_DEBUG
			{
				while(NOT IsMinListEmpty(&__memory_list))
					__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,__FILE__,__LINE__);
			}
			#else
			{
				while(NOT IsMinListEmpty(&__memory_list))
					__free_memory_node((struct MemoryNode *)__memory_list.mlh_Head,NULL,0);
			}
			#endif /* __MEM_DEBUG */
		}
	}
	#endif /* __USE_SLAB_ALLOCATOR */

	#if defined(__THREAD_SAFE)
	{
		__delete_semaphore(memory_semaphore);
		memory_semaphore = NULL;
	}
	#endif /* __THREAD_SAFE */

	LEAVE();
}

/****************************************************************************/

STDLIB_CONSTRUCTOR(stdlib_memory_init)
{
	BOOL success = FALSE;

	ENTER();

	#if defined(__THREAD_SAFE)
	{
		memory_semaphore = __create_semaphore();
		if(memory_semaphore == NULL)
			goto out;
	}
	#endif /* __THREAD_SAFE */

	#if defined(__USE_MEM_TREES) && defined(__MEM_DEBUG)
	{
		__initialize_red_black_tree(&__memory_tree);
	}
	#endif /* __USE_MEM_TREES && __MEM_DEBUG */

	NewList((struct List *)&__memory_list);

	#if defined(__USE_SLAB_ALLOCATOR)
	{
		/* ZZZ this is just for the purpose of testing */
		#if DEBUG
		{
			TEXT slab_size_var[20];

			if(GetVar("SLAB_SIZE", slab_size_var, sizeof(slab_size_var), 0) > 0)
			{
				LONG value;

				if(StrToLong(slab_size_var,&value) > 0 && value > 0)
					__slab_max_size = (size_t)value;
			}
		}
		#endif

		/* Enable the slab memory allocator? */
		if(__slab_max_size > 0)
		{
			__slab_init(__slab_max_size);
		}
		else
		{
			#if defined(__amigaos4__)
			{
				__memory_pool = CreatePool(MEMF_PRIVATE,(ULONG)__default_pool_size,(ULONG)__default_puddle_size);
			}
			#else
			{
				/* There is no support for memory pools in the operating system
				 * prior to Kickstart 3.0 (V39).
				 */
				if(((struct Library *)SysBase)->lib_Version >= 39)
					__memory_pool = CreatePool(MEMF_ANY,(ULONG)__default_pool_size,(ULONG)__default_puddle_size);
			}
			#endif /* __amigaos4__ */
		}
	}
	#else
	{
		#if defined(__amigaos4__)
		{
			__memory_pool = CreatePool(MEMF_PRIVATE,(ULONG)__default_pool_size,(ULONG)__default_puddle_size);
		}
		#else
		{
			/* There is no support for memory pools in the operating system
			 * prior to Kickstart 3.0 (V39).
			 */
			if(((struct Library *)SysBase)->lib_Version >= 39)
				__memory_pool = CreatePool(MEMF_ANY,(ULONG)__default_pool_size,(ULONG)__default_puddle_size);
		}
		#endif /* __amigaos4__ */
	}
	#endif /* __USE_SLAB_ALLOCATOR) */

	success = TRUE;

 out:

	SHOWVALUE(success);
	LEAVE();

	if(success)
		CONSTRUCTOR_SUCCEED();
	else
		CONSTRUCTOR_FAIL();
}