/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/**
 ***************************************************************************
 * @file lac_mem_pools.c
 *
 * @ingroup LacMemPool
 *
 * Memory Pool creation and mgmt function implementations
 *
 ***************************************************************************/

#include "cpa.h"
#include "qat_utils.h"
#include "icp_accel_devices.h"
#include "icp_adf_init.h"
#include "icp_adf_transport.h"
#include "icp_adf_debug.h"
#include "lac_lock_free_stack.h"
#include "lac_mem_pools.h"
#include "lac_mem.h"
#include "lac_common.h"
#include "cpa_dc.h"
#include "dc_session.h"
#include "dc_datapath.h"
#include "icp_qat_fw_comp.h"
#include "icp_buffer_desc.h"
#include "lac_sym.h"

#define LAC_MEM_POOLS_NUM_SUPPORTED 32000
/**< @ingroup LacMemPool
 * Number of mem pools supported */

#define LAC_MEM_POOLS_NAME_SIZE 17
/**< @ingroup LacMemPool
 * 16 bytes plus '\\0' terminator */

/**< @ingroup LacMemPool
 *     This structure is used to manage each pool created using this utility
 * feature. The client will maintain a pointer (identifier) to the created
 * structure per pool.
 */
typedef struct lac_mem_pool_hdr_s {
	lock_free_stack_t stack;
	char poolName[LAC_MEM_POOLS_NAME_SIZE]; /*16 bytes of a pool name */
	/**< up to 16 bytes of a pool name */
	unsigned int numElementsInPool;
	/**< number of elements in the Pool */
	unsigned int blkSizeInBytes;
	/**< Block size in bytes */
	unsigned int blkAlignmentInBytes;
	/**< block alignment in bytes */
	lac_mem_blk_t **trackBlks;
	/* An array of mem block pointers to track the allocated entries in pool
	 */
	volatile size_t availBlks;
	/* Number of blocks available for allocation in this pool */
} lac_mem_pool_hdr_t;

static lac_mem_pool_hdr_t *lac_mem_pools[LAC_MEM_POOLS_NUM_SUPPORTED] = {
	NULL
};
/**< @ingroup LacMemPool
 * Array of pointers to the mem pool header structure
 */

LAC_DECLARE_HIGHEST_BIT_OF(lac_mem_blk_t);
/**< @ingroup LacMemPool
 * local constant for quickening computation of additional space allocated
 * for holding lac_mem_blk_t container-structure
 */

/**
 *******************************************************************************
 * @ingroup LacMemPool
 * This function cleans up a mem pool.
 ******************************************************************************/
void Lac_MemPoolCleanUpInternal(lac_mem_pool_hdr_t *pPoolID);

static inline Cpa32U
Lac_MemPoolGetElementRealSize(Cpa32U blkSizeInBytes, Cpa32U blkAlignmentInBytes)
{
	Cpa32U addSize = (blkAlignmentInBytes >= sizeof(lac_mem_blk_t) ?
			      blkAlignmentInBytes :
			      1 << (highest_bit_of_lac_mem_blk_t + 1));
	return blkSizeInBytes + addSize;
}

CpaStatus
Lac_MemPoolCreate(lac_memory_pool_id_t *pPoolID,
		  char *poolName,
		  unsigned int numElementsInPool,   /*Number of elements*/
		  unsigned int blkSizeInBytes,      /*Block Size in bytes*/
		  unsigned int blkAlignmentInBytes, /*Block alignment (bytes)*/
		  CpaBoolean trackMemory,
		  Cpa32U node)
{
	unsigned int poolSearch = 0;
	unsigned int counter = 0;
	lac_mem_blk_t *pMemBlkCurrent = NULL;

	void *pMemBlk = NULL;

	if (pPoolID == NULL) {
		QAT_UTILS_LOG("Invalid Pool ID param\n");
		return CPA_STATUS_INVALID_PARAM; /*Error*/
	}

	/* Find First available Pool return error otherwise */
	while (lac_mem_pools[poolSearch] != NULL) {
		poolSearch++;
		if (LAC_MEM_POOLS_NUM_SUPPORTED == poolSearch) {
			QAT_UTILS_LOG(
			    "No more memory pools available for allocation.\n");
			return CPA_STATUS_FAIL;
		}
	}

	/* Allocate a Pool header */
	lac_mem_pools[poolSearch] = LAC_OS_MALLOC(sizeof(lac_mem_pool_hdr_t));
	if (NULL == lac_mem_pools[poolSearch]) {
		QAT_UTILS_LOG(
		    "Unable to allocate memory for creation of the pool.\n");
		return CPA_STATUS_RESOURCE; /*Error*/
	}
	memset(lac_mem_pools[poolSearch], 0, sizeof(lac_mem_pool_hdr_t));

	/* Copy in Pool Name */
	if (poolName != NULL) {
		snprintf(lac_mem_pools[poolSearch]->poolName,
			 LAC_MEM_POOLS_NAME_SIZE,
			 "%s",
			 poolName);
	} else {
		LAC_OS_FREE(lac_mem_pools[poolSearch]);
		lac_mem_pools[poolSearch] = NULL;
		QAT_UTILS_LOG("Invalid Pool Name pointer\n");
		return CPA_STATUS_INVALID_PARAM; /*Error*/
	}

	/* Allocate table for tracking memory blocks */
	if (CPA_TRUE == trackMemory) {
		lac_mem_pools[poolSearch]->trackBlks = LAC_OS_MALLOC(
		    (sizeof(lac_mem_blk_t *) * numElementsInPool));
		if (NULL == lac_mem_pools[poolSearch]->trackBlks) {
			LAC_OS_FREE(lac_mem_pools[poolSearch]);
			lac_mem_pools[poolSearch] = NULL;
			QAT_UTILS_LOG(
			    "Unable to allocate memory for tracking memory blocks.\n");
			return CPA_STATUS_RESOURCE; /*Error*/
		}
	} else {
		lac_mem_pools[poolSearch]->trackBlks = NULL;
	}

	lac_mem_pools[poolSearch]->availBlks = 0;
	lac_mem_pools[poolSearch]->stack = _init_stack();

	/* Calculate alignment needed for allocation   */
	for (counter = 0; counter < numElementsInPool; counter++) {
		CpaPhysicalAddr physAddr = 0;
		/* realSize is computed for allocation of  blkSize bytes +
		   additional
		   capacity for lac_mem_blk_t structure storage due to the some
		   OSes
		   (BSD) limitations for memory alignment to be power of 2;
		   sizeof(lac_mem_blk_t) is being round up to the closest power
		   of 2 -
		   optimised towards the least CPU overhead but at additional
		   memory
		   cost
		 */
		Cpa32U realSize =
		    Lac_MemPoolGetElementRealSize(blkSizeInBytes,
						  blkAlignmentInBytes);
		Cpa32U addSize = realSize - blkSizeInBytes;

		if (CPA_STATUS_SUCCESS != LAC_OS_CAMALLOC(&pMemBlk,
							  realSize,
							  blkAlignmentInBytes,
							  node)) {
			Lac_MemPoolCleanUpInternal(lac_mem_pools[poolSearch]);
			lac_mem_pools[poolSearch] = NULL;
			QAT_UTILS_LOG(
			    "Unable to allocate contiguous chunk of memory.\n");
			return CPA_STATUS_RESOURCE;
		}

		/* Calcaulate various offsets */
		physAddr = LAC_OS_VIRT_TO_PHYS_INTERNAL(
		    (void *)((LAC_ARCH_UINT)pMemBlk + addSize));

		/* physAddr is now already aligned to the greater power of 2:
		    blkAlignmentInBytes or sizeof(lac_mem_blk_t) round up
		    We safely put the structure right before the blkSize
		    real data block
		 */
		pMemBlkCurrent =
		    (lac_mem_blk_t *)(((LAC_ARCH_UINT)(pMemBlk)) + addSize -
				      sizeof(lac_mem_blk_t));

		pMemBlkCurrent->physDataPtr = physAddr;
		pMemBlkCurrent->pMemAllocPtr = pMemBlk;
		pMemBlkCurrent->pPoolID = lac_mem_pools[poolSearch];
		pMemBlkCurrent->isInUse = CPA_FALSE;
		pMemBlkCurrent->pNext = NULL;

		push(&lac_mem_pools[poolSearch]->stack, pMemBlkCurrent);

		/* Store allocated memory pointer */
		if (lac_mem_pools[poolSearch]->trackBlks != NULL) {
			(lac_mem_pools[poolSearch]->trackBlks[counter]) =
			    (lac_mem_blk_t *)pMemBlkCurrent;
		}
		__sync_add_and_fetch(&lac_mem_pools[poolSearch]->availBlks, 1);
		(lac_mem_pools[poolSearch])->numElementsInPool = counter + 1;
	}

	/* Set Pool details in the header */
	(lac_mem_pools[poolSearch])->blkSizeInBytes = blkSizeInBytes;
	(lac_mem_pools[poolSearch])->blkAlignmentInBytes = blkAlignmentInBytes;
	/* Set the Pool ID output parameter */
	*pPoolID = (LAC_ARCH_UINT)(lac_mem_pools[poolSearch]);
	/* Success */
	return CPA_STATUS_SUCCESS;
}

void *
Lac_MemPoolEntryAlloc(lac_memory_pool_id_t poolID)
{
	lac_mem_pool_hdr_t *pPoolID = (lac_mem_pool_hdr_t *)poolID;
	lac_mem_blk_t *pMemBlkCurrent = NULL;

	/* Explicitly removing NULL PoolID check for speed */
	if (pPoolID == NULL) {
		QAT_UTILS_LOG("Invalid Pool ID");
		return NULL;
	}

	/* Remove block from pool */
	pMemBlkCurrent = pop(&pPoolID->stack);
	if (NULL == pMemBlkCurrent) {
		return (void *)CPA_STATUS_RETRY;
	}
	__sync_sub_and_fetch(&pPoolID->availBlks, 1);
	pMemBlkCurrent->isInUse = CPA_TRUE;
	return (void *)((LAC_ARCH_UINT)(pMemBlkCurrent) +
			sizeof(lac_mem_blk_t));
}

void
Lac_MemPoolEntryFree(void *pEntry)
{
	lac_mem_blk_t *pMemBlk = NULL;

	/* Explicitly NULL pointer check */
	if (pEntry == NULL) {
		QAT_UTILS_LOG("Memory Handle NULL");
		return;
	}

	pMemBlk =
	    (lac_mem_blk_t *)((LAC_ARCH_UINT)pEntry - sizeof(lac_mem_blk_t));
	pMemBlk->isInUse = CPA_FALSE;

	push(&pMemBlk->pPoolID->stack, pMemBlk);
	__sync_add_and_fetch(&pMemBlk->pPoolID->availBlks, 1);
}

void
Lac_MemPoolDestroy(lac_memory_pool_id_t poolID)
{
	unsigned int poolSearch = 0;
	lac_mem_pool_hdr_t *pPoolID = (lac_mem_pool_hdr_t *)poolID;

	if (pPoolID != NULL) {
		/*Remove entry from table*/
		while (lac_mem_pools[poolSearch] != pPoolID) {
			poolSearch++;

			if (LAC_MEM_POOLS_NUM_SUPPORTED == poolSearch) {
				QAT_UTILS_LOG("Invalid Pool ID submitted.\n");
				return;
			}
		}

		lac_mem_pools[poolSearch] = NULL; /*Remove handle from pool*/

		Lac_MemPoolCleanUpInternal(pPoolID);
	}
}

void
Lac_MemPoolCleanUpInternal(lac_mem_pool_hdr_t *pPoolID)
{
	lac_mem_blk_t *pCurrentBlk = NULL;
	void *pFreePtr = NULL;
	Cpa32U count = 0;

	if (pPoolID->trackBlks == NULL) {
		pCurrentBlk = pop(&pPoolID->stack);

		while (pCurrentBlk != NULL) {
			/* Free Data Blocks */
			pFreePtr = pCurrentBlk->pMemAllocPtr;
			pCurrentBlk = pop(&pPoolID->stack);
			LAC_OS_CAFREE(pFreePtr);
		}
	} else {
		for (count = 0; count < pPoolID->numElementsInPool; count++) {
			pFreePtr = (pPoolID->trackBlks[count])->pMemAllocPtr;
			LAC_OS_CAFREE(pFreePtr);
		}
		LAC_OS_FREE(pPoolID->trackBlks);
	}
	LAC_OS_FREE(pPoolID);
}

unsigned int
Lac_MemPoolAvailableEntries(lac_memory_pool_id_t poolID)
{
	lac_mem_pool_hdr_t *pPoolID = (lac_mem_pool_hdr_t *)poolID;
	if (pPoolID == NULL) {
		QAT_UTILS_LOG("Invalid Pool ID\n");
		return 0;
	}
	return pPoolID->availBlks;
}

void
Lac_MemPoolStatsShow(void)
{
	unsigned int index = 0;
	QAT_UTILS_LOG(SEPARATOR BORDER
		      "           Memory Pools Stats\n" SEPARATOR);

	while (index < LAC_MEM_POOLS_NUM_SUPPORTED) {
		if (lac_mem_pools[index] != NULL) {
			QAT_UTILS_LOG(
			    BORDER " Pool Name:             %s \n" BORDER
				   " No. Elements in Pool:  %10u \n" BORDER
				   " Element Size in Bytes: %10u \n" BORDER
				   " Alignment in Bytes:    %10u \n" BORDER
				   " No. Available Blocks:  %10zu \n" SEPARATOR,
			    lac_mem_pools[index]->poolName,
			    lac_mem_pools[index]->numElementsInPool,
			    lac_mem_pools[index]->blkSizeInBytes,
			    lac_mem_pools[index]->blkAlignmentInBytes,
			    lac_mem_pools[index]->availBlks);
		}
		index++;
	}
}

static void
Lac_MemPoolInitSymCookies(lac_sym_cookie_t *pSymCookie)
{
	pSymCookie->keyContentDescPhyAddr =
	    LAC_OS_VIRT_TO_PHYS_INTERNAL(pSymCookie->u.keyCookie.contentDesc);
	pSymCookie->keyHashStateBufferPhyAddr = LAC_OS_VIRT_TO_PHYS_INTERNAL(
	    pSymCookie->u.keyCookie.hashStateBuffer);
	pSymCookie->keySslKeyInputPhyAddr = LAC_OS_VIRT_TO_PHYS_INTERNAL(
	    &(pSymCookie->u.keyCookie.u.sslKeyInput));
	pSymCookie->keyTlsKeyInputPhyAddr = LAC_OS_VIRT_TO_PHYS_INTERNAL(
	    &(pSymCookie->u.keyCookie.u.tlsKeyInput));
}

CpaStatus
Lac_MemPoolInitSymCookiesPhyAddr(lac_memory_pool_id_t poolID)
{
	lac_mem_pool_hdr_t *pPoolID = (lac_mem_pool_hdr_t *)poolID;
	lac_sym_cookie_t *pSymCookie = NULL;
	lac_mem_blk_t *pCurrentBlk = NULL;

	if (NULL == pPoolID) {
		QAT_UTILS_LOG("Invalid Pool ID\n");
		return CPA_STATUS_FAIL;
	}

	if (pPoolID->trackBlks == NULL) {
		pCurrentBlk = top(&pPoolID->stack);

		while (pCurrentBlk != NULL) {
			pSymCookie =
			    (lac_sym_cookie_t *)((LAC_ARCH_UINT)(pCurrentBlk) +
						 sizeof(lac_mem_blk_t));
			pCurrentBlk = pCurrentBlk->pNext;
			Lac_MemPoolInitSymCookies(pSymCookie);
		}
	} else {
		Cpa32U count = 0;

		for (count = 0; count < pPoolID->numElementsInPool; count++) {
			pCurrentBlk = pPoolID->trackBlks[count];
			pSymCookie =
			    (lac_sym_cookie_t *)((LAC_ARCH_UINT)(pCurrentBlk) +
						 sizeof(lac_mem_blk_t));
			Lac_MemPoolInitSymCookies(pSymCookie);
		}
	}
	return CPA_STATUS_SUCCESS;
}

CpaStatus
Lac_MemPoolInitDcCookiePhyAddr(lac_memory_pool_id_t poolID)
{
	lac_mem_pool_hdr_t *pPoolID = (lac_mem_pool_hdr_t *)poolID;
	lac_mem_blk_t *pCurrentBlk = NULL;

	if (NULL == pPoolID) {
		QAT_UTILS_LOG("Invalid Pool ID\n");
		return CPA_STATUS_FAIL;
	}

	if (NULL == pPoolID->trackBlks) {
		pCurrentBlk = top(&pPoolID->stack);

		while (pCurrentBlk != NULL) {
			pCurrentBlk = pCurrentBlk->pNext;
		}
	} else {
		Cpa32U count = 0;

		for (count = 0; count < pPoolID->numElementsInPool; count++) {
			pCurrentBlk = pPoolID->trackBlks[count];
		}
	}
	return CPA_STATUS_SUCCESS;
}