/******************************************************************************
** Function: CFE_FS_EarlyInit()
**
** Purpose:
** Initialize the FS data structures before the cFE runs.
**
** Arguments:
**
** Notes:
** This function MUST be called before any FS API's are called.
**
** Return:
** CFE_SUCCESS
*/
int32 CFE_FS_EarlyInit (void)
{
int32 Stat = CFE_SUCCESS;
Stat = OS_MutSemCreate(&CFE_FS.SharedDataMutexId, "CFE_FS_SharedMutex", 0);
if( Stat != OS_SUCCESS )
{
CFE_ES_WriteToSysLog("FS Shared Data Mutex creation failed! RC=0x%08x\n",Stat);
return Stat;
}/* end if */
return Stat;
}/* end CFE_FS_EarlyInit */
/******************************************************************************
** Function: CFE_SB_EarlyInit()
**
** Purpose:
** Initialize the Software Bus routing tables.
**
** Arguments:
**
** Notes:
** This function MUST be called before any SB API's are called.
**
** Return:
** CFE_SUCCESS
*/
int32 CFE_SB_EarlyInit (void) {
int32 Stat = CFE_SUCCESS;
CFE_SB_Default_Qos.Priority = CFE_SB_QOS_LOW_PRIORITY;
CFE_SB_Default_Qos.Reliability = CFE_SB_QOS_LOW_RELIABILITY;
Stat = OS_MutSemCreate(&CFE_SB.SharedDataMutexId, "CFE_SB_DataMutex", 0);
if(Stat != OS_SUCCESS){
CFE_ES_WriteToSysLog("SB shared data mutex creation failed! RC=0x%08x\n",(unsigned int)Stat);
return Stat;
}/* end if */
/* Initialize the state of susbcription reporting */
CFE_SB.SubscriptionReporting = CFE_SB_DISABLE;
/* Initialize the state of sender reporting */
CFE_SB.SenderReporting = CFE_SB_DEFAULT_REPORT_SENDER;
/* Initialize memory partition. */
Stat = CFE_SB_InitBuffers();
if(Stat != CFE_SUCCESS){
/* error reported in CFE_SB_InitBuffers */
return Stat;
}/* end if */
/* Initialize the pipe table. */
CFE_SB_InitPipeTbl();
/* Initialize the routing index look up table */
CFE_SB_InitMsgMap();
/* Initialize the routing table. */
CFE_SB_InitRoutingTbl();
/* Initialize the SB Statistics Pkt */
CFE_SB_InitMsg(&CFE_SB.StatTlmMsg.Hdr.Pri,
CFE_SB_STATS_TLM_MID,
sizeof(CFE_SB_StatMsg_t),
TRUE);
CFE_SB.ZeroCopyTail = NULL;
return Stat;
}/* end CFE_SB_EarlyInit */
/*
** CFE_ES_CreateCDSPool will initialize a pre-allocated memory pool.
*/
int32 CFE_ES_CreateCDSPool(uint32 CDSPoolSize, uint32 StartOffset)
{
char MutexName[10] = {"CDS_POOL"};
uint32 i = 0;
uint32 Size = (CDSPoolSize & 0xfffffffc);
/* create a semphore to protect this memory pool */
OS_MutSemCreate(&(CFE_ES_CDSMemPool.MutexId), MutexName, 0);
/* Take the semaphore to ensure the mem pool is not being used during it's creation */
OS_MutSemTake(CFE_ES_CDSMemPool.MutexId);
CFE_ES_CDSMemPool.Start = StartOffset;
CFE_ES_CDSMemPool.End = StartOffset + Size;
CFE_ES_CDSMemPool.Size = Size;
CFE_ES_CDSMemPool.Current = StartOffset;
CFE_ES_CDSMemPool.SizeIndex = -1;
CFE_ES_CDSMemPool.CheckErrCntr = 0;
CFE_ES_CDSMemPool.RequestCntr = 0;
for (i=0; i<CFE_ES_CDS_NUM_BLOCK_SIZES; i++)
{
CFE_ES_CDSMemPool.SizeDesc[i].Top = 0;
CFE_ES_CDSMemPool.SizeDesc[i].NumCreated = 0;
CFE_ES_CDSMemPool.SizeDesc[i].MaxSize = CFE_ES_CDSMemPoolDefSize[i];
}
if (CDSPoolSize < (CFE_ES_CDSMemPool.MinBlockSize + sizeof(CFE_ES_CDSBlockDesc_t)))
{
/* Must be able make Pool verification, block descriptor and at least one of the smallest blocks */
CFE_ES_WriteToSysLog("CFE_ES:CreateCDSPool-Pool size(%u) too small for one CDS Block, need >=%u\n",
CDSPoolSize, (CFE_ES_CDSMemPool.MinBlockSize + sizeof(CFE_ES_CDSBlockDesc_t)));
/* Give and delete semaphore since CDS Pool creation failed */
OS_MutSemGive(CFE_ES_CDSMemPool.MutexId);
OS_MutSemDelete(CFE_ES_CDSMemPool.MutexId);
return(CFE_ES_BAD_ARGUMENT);
}
OS_MutSemGive(CFE_ES_CDSMemPool.MutexId);
return(CFE_SUCCESS);
}
void OS_Application_Startup(void)
{
uint32 status;
printf("********If You see this, we got into OS_Application_Startup****\n");
status = OS_QueueCreate( &msgq_id, "MsgQ", MSGQ_DEPTH, MSGQ_SIZE, 0);
if ( status != OS_SUCCESS )
{
printf("Error creating Message Queue\n");
}
status = OS_MutSemCreate( &mutex_id, "Mutex", 0);
if ( status != OS_SUCCESS )
{
printf("Error creating mutex\n");
}
else
{
printf("MutexSem ID = %d\n",mutex_id);
}
status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_1_STACK_SIZE, TASK_1_PRIORITY, 0);
if ( status != OS_SUCCESS )
{
printf("Error creating Task 1\n");
}
status = OS_TaskCreate( &task_2_id, "Task 2", task_2, task_2_stack, TASK_2_STACK_SIZE, TASK_2_PRIORITY, 0);
if ( status != OS_SUCCESS )
{
printf("Error creating Task 2\n");
}
status = OS_TaskCreate( &task_3_id, "Task 3", task_3, task_3_stack, TASK_3_STACK_SIZE, TASK_3_PRIORITY, 0);
if ( status != OS_SUCCESS )
{
printf("Error creating Task 3\n");
}
}
/**
** \brief Initializes CDS data constructs
**
** \par Description
** Locates and validates any pre-existing CDS memory or initializes the
** memory as a fresh CDS.
**
** \par Assumptions, External Events, and Notes:
** None
**
** \par SysLog Messages
**
**
** \return None
**
******************************************************************************/
int32 CFE_ES_CDS_EarlyInit(void)
{
uint32 MinRequiredSize = 0;
int32 Status = CFE_SUCCESS;
/* Compute the minimum size required for the CDS with the current configuration of the cFE */
MinRequiredSize = (sizeof(CFE_ES_Global.CDSVars.ValidityField) * 2) + /* Minimum size for validity fields */
(CFE_ES_CDS_MAX_NUM_ENTRIES * sizeof(CFE_ES_CDS_RegRec_t)) + /* Minimum size for CDS Registry contents */
CFE_ES_CDSReqdMinSize(CFE_ES_CDS_MAX_NUM_ENTRIES); /* Max # of Min Sized Blocks */
/* Get CDS size from OS BSP */
Status = CFE_PSP_GetCDSSize(&CFE_ES_Global.CDSVars.CDSSize);
/* If the size was obtained successfully and meets the minimum requirements, then check its contents */
if (Status == OS_SUCCESS)
{
/* Always truncate the size to the nearest 4 byte boundary */
CFE_ES_Global.CDSVars.CDSSize &= 0xfffffffc;
if (CFE_ES_Global.CDSVars.CDSSize >= MinRequiredSize)
{
Status = CFE_ES_ValidateCDS();
/* If the CDS is accessible but invalid, then create a new one */
if (Status == CFE_ES_CDS_INVALID)
{
Status = CFE_ES_InitializeCDS(CFE_ES_Global.CDSVars.CDSSize);
}
else if (Status == CFE_SUCCESS)
{
/* If a valid CDS was found, rebuild the memory pool */
Status = CFE_ES_RebuildCDS();
/* If rebuilding is not possible, then create a new one from scratch */
if (Status == CFE_ES_CDS_INVALID)
{
Status = CFE_ES_InitializeCDS(CFE_ES_Global.CDSVars.CDSSize);
}
}
else /* Unrecoverable error while reading the CDS */
{
CFE_ES_WriteToSysLog("CFE_CDS:EarlyInit-Read error validating CDS (Err=0x%08X)\n", Status);
CFE_ES_Global.CDSVars.MemPoolSize = 0;
return Status;
}
if (Status == CFE_SUCCESS)
{
/* Create CDS registry access mutex */
OS_MutSemCreate(&CFE_ES_Global.CDSVars.RegistryMutex,
CFE_ES_CDS_MUT_REG_NAME,
CFE_ES_CDS_MUT_REG_VALUE);
}
}
else /* Size < MinRequiredSize */
{
CFE_ES_WriteToSysLog("CFE_CDS:EarlyInit-CDS Size (%d) less than required (%d)\n",
CFE_ES_Global.CDSVars.CDSSize, MinRequiredSize);
CFE_ES_Global.CDSVars.MemPoolSize = 0;
return Status;
}
}
else /* Error getting the size of the CDS from the BSP */
{
CFE_ES_WriteToSysLog("CFE_CDS:EarlyInit-Unable to obtain CDS Size from BSP (Err=0x%08X)\n", Status);
CFE_ES_Global.CDSVars.MemPoolSize = 0;
return Status;
}
return(CFE_SUCCESS);
} /* End of CFE_ES_CDS_EarlyInit() */
static void test_006_001_execute(void) {
/* OS_MutSemCreate() is invoked with sem_id set to NULL, an error is
expected.*/
test_set_step(1);
{
int32 err;
err = OS_MutSemCreate(NULL, /* Error.*/
"failing semaphore",
0);
test_assert(err == OS_INVALID_POINTER, "NULL not detected");
}
/* OS_MutSemCreate() is invoked with sem_name set to NULL, an error
is expected.*/
test_set_step(2);
{
int32 err;
err = OS_MutSemCreate(&msid,
NULL, /* Error.*/
0);
test_assert(err == OS_INVALID_POINTER, "NULL not detected");
}
/* OS_MutSemCreate() is invoked with a very long timer name, an error
is expected.*/
test_set_step(3);
{
#if 0 /* Semaphore name currently not implemented.*/
int32 err;
err = OS_MutSemCreate(&msid,
"very very long semaphore name", /* Error.*/
0);
test_assert(err == OS_ERR_NAME_TOO_LONG, "name limit not detected");
#endif
}
/* OS_MutSemDelete() is invoked with timer_id set to -1, an error is
expected.*/
test_set_step(4);
{
int32 err;
err = OS_MutSemDelete((uint32)-1);
test_assert(err == OS_ERR_INVALID_ID, "wrong semaphore id not detected");
}
/* OS_MutSemCreate() is invoked twice with duplicated name, an error
is expected, then the queue is deleted using OS_MutSemDelete().*/
test_set_step(5);
{
int32 err;
uint32 msid1; /*, msid2;*/
err = OS_MutSemCreate(&msid1, "my semaphore", 0);
test_assert(err == OS_SUCCESS, "semaphore creation failed");
#if 0 /* Semaphore name currently not implemented.*/
err = OS_MutSemCreate(&msid2, "my semaphore", 0);
test_assert(err == OS_ERR_NAME_TAKEN, "name conflict not detected");
#endif
err = OS_MutSemDelete(msid1);
test_assert(err == OS_SUCCESS, "semaphore deletion failed");
}
}
int32 CFE_ES_PoolCreateEx(CFE_ES_MemHandle_t *HandlePtr,
uint8 *MemPtr,
uint32 Size,
uint32 NumBlockSizes,
uint32 *BlockSizes,
uint16 UseMutex )
{
char MutexName[10];
uint32 i;
uint32 j;
uint32 k;
uint32 *BlockSizeArrayPtr;
uint32 BlockSizeArraySize;
uint32 MinBlockSize;
/*
** Local Variables
*/
Pool_t *PoolPtr = (Pool_t *)MemPtr;
*HandlePtr = (uint32)MemPtr;
/* Force the size given to be 32 bit aligned */
Size &= 0xFFFFFFFC;
#ifdef CFE_ES_MEMPOOL_ALIGNED
/* Determine if the memory pool address is 32-bit aligned */
if ((((uint32)MemPtr) & 0x00000003) != 0)
{
CFE_ES_WriteToSysLog("CFE_ES:poolCreate Pool Address(0x%08X) is not 32-bit aligned.\n", (uint32)MemPtr);
return(CFE_ES_BAD_ARGUMENT);
}
#endif
/* If too many sizes are specified, return an error */
if (NumBlockSizes > CFE_ES_MAX_MEMPOOL_BLOCK_SIZES)
{
CFE_ES_WriteToSysLog("CFE_ES:poolCreate Num Block Sizes (%d) greater than max (%d)\n",
NumBlockSizes, CFE_ES_MAX_MEMPOOL_BLOCK_SIZES);
return(CFE_ES_BAD_ARGUMENT);
}
if ((UseMutex != CFE_ES_USE_MUTEX) && (UseMutex != CFE_ES_NO_MUTEX))
{
CFE_ES_WriteToSysLog("CFE_ES:poolCreate Invalid Mutex Usage Option (%d), must be %d or %d\n",
UseMutex, CFE_ES_NO_MUTEX, CFE_ES_USE_MUTEX);
return(CFE_ES_BAD_ARGUMENT);
}
if (UseMutex == CFE_ES_USE_MUTEX)
{
/*
** Construct a name for the Mutex from the address
** This is needed only because OS_MutSemCreate requires
** a unique name for each semaphore created.
*/
sprintf(MutexName, "%08X", (unsigned int)MemPtr);
/* create a semphore to protect this memory pool */
OS_MutSemCreate(&(PoolPtr->MutexId), MutexName, 0);
/* Take the semaphore to ensure the mem pool is not being used during its creation */
OS_MutSemTake(PoolPtr->MutexId);
}
PoolPtr->Start = (uint32 *)*HandlePtr;
PoolPtr->End = (uint32)((uint8 *)PoolPtr->Start + Size);
PoolPtr->Size = Size;
PoolPtr->Current = (uint32 *)(MemPtr + sizeof(Pool_t));
PoolPtr->SizeDescPtr = NULL;
PoolPtr->CheckErrCntr = 0;
PoolPtr->RequestCntr = 0;
PoolPtr->UseMutex = UseMutex;
for (i=0; i<CFE_ES_MAX_MEMPOOL_BLOCK_SIZES; i++)
{
PoolPtr->SizeDesc[i].NumCreated = 0;
PoolPtr->SizeDesc[i].NumFree = 0;
PoolPtr->SizeDesc[i].MaxSize = 0;
PoolPtr->SizeDesc[i].Top = NULL;
}
/* Use default block sizes if none or too many sizes are specified */
if ((NumBlockSizes == 0) || (BlockSizes == NULL))
{
BlockSizeArrayPtr = &CFE_ES_MemPoolDefSize[0];
BlockSizeArraySize = CFE_ES_MAX_MEMPOOL_BLOCK_SIZES;
}
else
{
BlockSizeArrayPtr = BlockSizes;
BlockSizeArraySize = NumBlockSizes;
}
/* Use specified block sizes but make sure they are ordered largest to smallest */
MinBlockSize = 0xffffffff;
for (i=0; i<BlockSizeArraySize; i++)
{
if ((BlockSizeArrayPtr[i] < MinBlockSize) && (BlockSizeArrayPtr[i] != 0))
{
MinBlockSize = BlockSizeArrayPtr[i];
}
j = 0;
while (j<CFE_ES_MAX_MEMPOOL_BLOCK_SIZES)
{
if (BlockSizeArrayPtr[i] > PoolPtr->SizeDesc[j].MaxSize)
{
/* Make space for new size */
for (k=i; k>j; k--)
{
PoolPtr->SizeDesc[k].MaxSize = PoolPtr->SizeDesc[k-1].MaxSize;
}
/* Insert the size in the correct location */
PoolPtr->SizeDesc[j].MaxSize = BlockSizeArrayPtr[i];
j = CFE_ES_MAX_MEMPOOL_BLOCK_SIZES;
}
else
{
j++;
}
}
}
if (Size <= (sizeof(Pool_t) + MinBlockSize + sizeof(BD_t) ) )
{ /* must be able make Pool management structure and at least one of the smallest blocks */
CFE_ES_WriteToSysLog("CFE_ES:poolCreate Pool size(%d) too small for management structure, need >=(%d)\n",
(int)Size,
(int)(sizeof(Pool_t) + MinBlockSize + sizeof(BD_t)) );
if (UseMutex == CFE_ES_USE_MUTEX)
{
/* Mutex is no longer needed with error in initialization. Give it and delete it */
OS_MutSemGive(PoolPtr->MutexId);
OS_MutSemDelete(PoolPtr->MutexId);
}
return(CFE_ES_BAD_ARGUMENT);
}
if (UseMutex == CFE_ES_USE_MUTEX)
{
OS_MutSemGive(PoolPtr->MutexId);
}
return(CFE_SUCCESS);
}
/*
** Name: CFE_ES_Main
** Purpose: This is the entry point to the cFE application code.
**
*/
void CFE_ES_Main(uint32 StartType, uint32 StartSubtype, uint32 ModeId, uint8 *StartFilePath )
{
int i;
int32 ReturnCode;
/*
** Initialize the Reset variables. This call is required
** Before most of the ES functions can be used including the
** ES System log.
*/
CFE_ES_SetupResetVariables(StartType, StartSubtype, ModeId);
/*
** Initialize the Logic Perf variables
** Because this is in the ES Reset area, it must be called after
** CFE_ES_SetupResetVariables.
*/
CFE_ES_SetupPerfVariables(StartType);
/*
** Announce the startup
*/
CFE_ES_WriteToSysLog("ES Startup: CFE_ES_Main started\n");
/*
** Create and Mount the filesystems needed
*/
CFE_ES_InitializeFileSystems(StartType);
/*
** Install exception Handlers ( Placeholder )
*/
CFE_PSP_AttachExceptions();
/*
** Initialize the ES Application Table
** to mark all entries as unused.
*/
for ( i = 0; i < CFE_ES_MAX_APPLICATIONS; i++ )
{
CFE_ES_Global.AppTable[i].RecordUsed = FALSE;
}
/*
** Initialize the ES Task Table
** to mark all entries as unused.
*/
for ( i = 0; i < OS_MAX_TASKS; i++ )
{
CFE_ES_Global.TaskTable[i].RecordUsed = FALSE;
}
/*
** Initialize the ES Generic Counter Table
** to mark all entries as unused.
*/
for ( i = 0; i < CFE_ES_MAX_GEN_COUNTERS; i++ )
{
CFE_ES_Global.CounterTable[i].RecordUsed = FALSE;
}
/*
** Create the ES Shared Data Mutex
*/
ReturnCode = OS_MutSemCreate(&(CFE_ES_Global.SharedDataMutex), "ES_DATA_MUTEX", 0 );
if(ReturnCode != OS_SUCCESS)
{
CFE_ES_WriteToSysLog("ES Startup: Error: ES Shared Data Mutex could not be created. RC=0x%08X\n",
ReturnCode);
/*
** Delay to allow the message to be read
*/
OS_TaskDelay(CFE_ES_PANIC_DELAY);
/*
** cFE Cannot continue to start up.
*/
CFE_PSP_Panic(CFE_PSP_PANIC_STARTUP_SEM);
} /* end if */
/*
** Create the ES Startup Sync Semaphore
*/
ReturnCode = OS_BinSemCreate(&(CFE_ES_Global.StartupSyncSemaphore),"ES_SYNC_SEM", 0, 0 );
if(ReturnCode != OS_SUCCESS)
{
CFE_ES_WriteToSysLog("ES Startup: Error: ES Startup Sync Semaphore could not be created. RC=0x%08X\n",
ReturnCode);
/*
** Delay to allow the message to be read
*/
OS_TaskDelay(CFE_ES_PANIC_DELAY);
/*
** cFE Cannot continue to start up.
*/
CFE_PSP_Panic(CFE_PSP_PANIC_STARTUP_SEM);
} /* end if */
/*
** Create the tasks, OS objects, and initialize hardware
*/
CFE_ES_CreateObjects();
/*
** Before the Applications are loaded, set up the state
** variables that allow the startup syncronization to work.
** This depends on a couple of things:
** 1. The fact that the cFE applications all use the CFE_ES_RunLoop Call
** 2. The StartupSyncSemaphore has been created ( see above )
** 3. The App(s) that wish to wait calls CFE_ES_WaitForStartupSync
*/
CFE_ES_Global.AppStartupCounter = 0;
CFE_ES_Global.StartupFileComplete = FALSE;
CFE_ES_Global.StartupSemaphoreReleased = FALSE;
/*
** Start the cFE Applications from the disk using the file
** specified in the CFE_ES_NONVOL_STARTUP_FILE or CFE_ES_VOLATILE_STARTUP_FILE
** ( defined in the cfe_platform_cfg.h file )
*/
CFE_ES_StartApplications(StartType, StartFilePath );
/*
** Indicate that the startup file is complete. This avoids
** certain race conditions.
*/
CFE_ES_Global.StartupFileComplete = TRUE;
/*
** Startup is complete
*/
CFE_ES_WriteToSysLog("ES Startup: CFE Core Startup Complete\n");
}
/*
** Function:
** CFE_ES_RebuildCDSPool
**
** Purpose:
**
*/
int32 CFE_ES_RebuildCDSPool(uint32 CDSPoolSize, uint32 StartOffset)
{
char MutexName[10] = {"CDS_POOL"};
uint32 i = 0;
uint32 Size = (CDSPoolSize & 0xfffffffc);
int32 Status = OS_SUCCESS;
uint32 Offset = StartOffset;
int32 BinIndex = 0;
/* create a semphore to protect this memory pool */
OS_MutSemCreate(&(CFE_ES_CDSMemPool.MutexId), MutexName, 0);
/* Take the semaphore to ensure the mem pool is not being used during it's creation */
OS_MutSemTake(CFE_ES_CDSMemPool.MutexId);
CFE_ES_CDSMemPool.Start = StartOffset;
CFE_ES_CDSMemPool.End = StartOffset + Size;
CFE_ES_CDSMemPool.Size = Size;
CFE_ES_CDSMemPool.Current = 0;
CFE_ES_CDSMemPool.SizeIndex = -1;
CFE_ES_CDSMemPool.CheckErrCntr = 0;
CFE_ES_CDSMemPool.RequestCntr = 0;
for (i=0; i<CFE_ES_CDS_NUM_BLOCK_SIZES; i++)
{
CFE_ES_CDSMemPool.SizeDesc[i].Top = 0;
CFE_ES_CDSMemPool.SizeDesc[i].NumCreated = 0;
CFE_ES_CDSMemPool.SizeDesc[i].MaxSize = CFE_ES_CDSMemPoolDefSize[i];
}
if (CDSPoolSize < (CFE_ES_CDSMemPool.MinBlockSize + sizeof(CFE_ES_CDSBlockDesc_t)))
{
/* Must be able make Pool verification, block descriptor and at least one of the smallest blocks */
CFE_ES_WriteToSysLog("CFE_ES:RebuildCDSPool-Pool size(%u) too small for one CDS Block, need >=%u\n",
CDSPoolSize, (CFE_ES_CDSMemPool.MinBlockSize + sizeof(CFE_ES_CDSBlockDesc_t)));
/* Give and delete semaphore since CDS Pool rebuild failed */
OS_MutSemGive(CFE_ES_CDSMemPool.MutexId);
OS_MutSemDelete(CFE_ES_CDSMemPool.MutexId);
return(CFE_ES_BAD_ARGUMENT);
}
/* Scan the CDS memory trying to find blocks that were created but are now free */
while ((Status == OS_SUCCESS) &&
(Offset < (CFE_ES_CDSMemPool.End - sizeof(CFE_ES_CDSBlockDesc_t))) &&
(CFE_ES_CDSMemPool.Current == 0))
{
/* Read the block descriptor for the first block in the memory pool */
Status = CFE_PSP_ReadFromCDS(&CFE_ES_CDSBlockDesc, Offset, sizeof(CFE_ES_CDSBlockDesc_t));
if (Status == OS_SUCCESS)
{
/* First, determine if the block is being or has been used */
if (CFE_ES_CDSBlockDesc.CheckBits == CFE_ES_CDS_CHECK_PATTERN)
{
/* See if the block is currently being used */
if (CFE_ES_CDSBlockDesc.AllocatedFlag != CFE_ES_CDS_BLOCK_USED)
{
/* If the block is not currently being used, */
/* then add it to the appropriate linked list in the memory pool */
BinIndex = CFE_ES_CDSGetBinIndex(CFE_ES_CDSBlockDesc.SizeUsed);
/* Sanity-check the block descriptor */
if (BinIndex >= 0)
{
CFE_ES_CDSBlockDesc.Next = CFE_ES_CDSMemPool.SizeDesc[BinIndex].Top;
CFE_ES_CDSBlockDesc.AllocatedFlag = CFE_ES_CDS_BLOCK_UNUSED;
CFE_ES_CDSMemPool.SizeDesc[BinIndex].Top = Offset;
/* Store the new CDS Block Descriptor in the CDS */
Status = CFE_PSP_WriteToCDS(&CFE_ES_CDSBlockDesc, Offset, sizeof(CFE_ES_CDSBlockDesc_t));
if (Status != OS_SUCCESS)
{
CFE_ES_WriteToSysLog("CFE_ES:RebuildCDS-Err writing to CDS (Stat=0x%08x)\n", Status);
Status = CFE_ES_CDS_ACCESS_ERROR;
}
}
else
{
CFE_ES_CDSMemPool.CheckErrCntr++;
CFE_ES_WriteToSysLog("CFE_ES:RebuildCDS-Invalid Block Descriptor \n");
Status = CFE_ES_CDS_ACCESS_ERROR;
}
}
/* Skip to the next block of memory */
Offset = Offset + CFE_ES_CDSBlockDesc.ActualSize + sizeof(CFE_ES_CDSBlockDesc_t);
}
else
{
/* If the block has never been used, then we should save the offset as the current offset */
/* which in turn will finish the scan of the CDS memory */
CFE_ES_CDSMemPool.Current = Offset;
}
}
else
{
CFE_ES_WriteToSysLog("CFE_ES:RebuildCDS-Err reading from CDS (Stat=0x%08x)\n", Status);
Status = CFE_ES_CDS_ACCESS_ERROR;
}
} /* end while */
OS_MutSemGive(CFE_ES_CDSMemPool.MutexId);
return Status;
}
