예제 #1
0
MME_ERROR MME_Init(void)
{
	if (manager) {
		return MME_DRIVER_ALREADY_INITIALIZED;
	}

	manager = malloc(sizeof(MMEManager_t));
	if (NULL == manager) {
		return MME_NOMEM;
	}
	memset(manager, 0, sizeof(*manager));

	if (!EMBX_OS_MUTEX_INIT(&(manager->factoryListMutex))) {
		goto error_recovery;
	}

	if (!EMBX_OS_MUTEX_INIT(&(manager->abortMutex))) {
		goto error_recovery;
	}

	return MME_SUCCESS;

    error_recovery:
    	
    	if (manager->factoryListMutex) {
    		EMBX_OS_MUTEX_DESTROY(&(manager->factoryListMutex));
    	}
    	if (manager->abortMutex) {
    		EMBX_OS_MUTEX_DESTROY(&(manager->abortMutex));
    	}
    	EMBX_OS_MemFree(manager);
	
	return MME_NOMEM;
}
예제 #2
0
MME_ERROR MME_MessageQueue_Init(MMEMessageQueue * msgQ, int maxEntries)
{
	MME_ERROR err;
        int size = maxEntries * sizeof(MMEMessageQueueEntry);

	MME_Info(MME_INFO_QUEUE, (">>>MME_MessageQueue_Init(0x%08x, %d)\n", 
	                          (unsigned) msgQ, maxEntries));

	msgQ->maxEntries = maxEntries;

	msgQ->queue = (MMEMessageQueueEntry*) EMBX_OS_MemAlloc(size);

	if (msgQ->queue == NULL) {
		MME_Info(MME_INFO_QUEUE, ("<<<MME_MessageQueue_Init = MME_NOMEM\n"));
		return MME_NOMEM;
	}
        memset(msgQ->queue, 0, size);

	if (!EMBX_OS_MUTEX_INIT(&msgQ->queueLock)) {
		MME_Info(MME_INFO_QUEUE, ("<<<MME_MessageQueue_Init = MME_NOMEM\n"));
		return MME_NOMEM;
	}

	err = MME_MessageQueue_RemoveAll(msgQ);
	MME_Assert(MME_SUCCESS == err); /* currently has no failure path */


	MME_Info(MME_INFO_QUEUE, ("<<<MME_MessageQueue_Init = MME_SUCCESS\n"));
	return MME_SUCCESS;
}
예제 #3
0
MME_ERROR MME_HostInit(void)
#endif
{
	if (NULL != manager) {
		return MME_DRIVER_ALREADY_INITIALIZED;
	}

	manager = EMBX_OS_MemAlloc(sizeof(HostManager_t));
	if (!manager) {
		return MME_NOMEM;
	}
	memset(manager, 0, sizeof(HostManager_t));

	manager->transformerInstances = MME_LookupTable_Create(MAX_TRANSFORMER_INSTANCES, 1);
	if (!manager->transformerInstances) {
		goto error_path;
	}

	if (EMBX_FALSE == EMBX_OS_MUTEX_INIT(&manager->monitorMutex)) {
		goto error_path;
	}
	if (EMBX_FALSE == EMBX_OS_MUTEX_INIT(&manager->eventLock)) {
		goto error_path;
	}
	if (EMBX_FALSE == EMBX_OS_EVENT_INIT(&manager->waitorDone)) {
		goto error_path;
	}
	return MME_SUCCESS;

    error_path:

	if (manager->transformerInstances) {
		MME_LookupTable_Delete(manager->transformerInstances);
	}
	EMBX_OS_MemFree(manager);
	manager = NULL;
	
	return MME_NOMEM;
}
예제 #4
0
static MME_ERROR createExecutionLoop(MMEManager_t *manager, int id)
{
	const struct { MME_UINT priority; const char *name; } lookup[MME_NUM_EXECUTION_LOOPS] = {
		{ MME_TUNEABLE_EXECUTION_LOOP_LOWEST_PRIORITY,       "ExecutionLoopLowest" },
		{ MME_TUNEABLE_EXECUTION_LOOP_BELOW_NORMAL_PRIORITY, "ExecutionLoopBelowNormal" },
		{ MME_TUNEABLE_EXECUTION_LOOP_NORMAL_PRIORITY,       "ExecutionLoopNormal" },
		{ MME_TUNEABLE_EXECUTION_LOOP_ABOVE_NORMAL_PRIORITY, "ExecutionLoopAboveNormal" },
		{ MME_TUNEABLE_EXECUTION_LOOP_HIGHEST_PRIORITY,      "ExecutionLoopHighest" },
	};

	MME_Assert(manager);
	MME_Assert(id < MME_NUM_EXECUTION_LOOPS);

	if (manager->loopTasksRunning[id]) {
		return MME_SUCCESS;
	}

	MME_Assert(0 == manager->loopTasks[id]);
	MME_Assert(0 == manager->receiverLists[id]);
	
	/* this code can only be called from the manager thread and therefore needs
	 * no thread protection.
	 */
	if (!EMBX_OS_MUTEX_INIT(&(manager->receiverListMutexes[id]))) {
		return MME_NOMEM;
	}

	if (!EMBX_OS_EVENT_INIT(&(manager->commandEvents[id]))) {
		goto cleanup_mutex;
	}

	/* spawn the worker thread */
	manager->loopTasks[id] = EMBX_OS_ThreadCreate((void(*)()) executionLoopTask, 
		    (void *) id, MME_GetTuneable(lookup[id].priority), lookup[id].name);
	if (0 == manager->loopTasks[id]) {
		goto cleanup_event;
	}

	/* mark the task as running */
	manager->loopTasksRunning[id] = 1;

	return MME_SUCCESS;

   cleanup_event:
	EMBX_OS_EVENT_DESTROY(&(manager->commandEvents[id]));
	
   cleanup_mutex:
	EMBX_OS_MUTEX_DESTROY(&(manager->receiverListMutexes[id]));

	return MME_NOMEM;
}
예제 #5
0
EMBX_EVENT EMBX_OS_EventCreate(void)
{
    EMBX_EVENT ev = NULL;

    /* This is not multithread safe - perhaps use an atomic test&set ? */
    if (!cacheInitialised)
    {
        cacheInitialised = 1;
	(void) EMBX_OS_MUTEX_INIT(&cacheLock);
    }
    
    EMBX_OS_MUTEX_TAKE(&cacheLock);
    
    if ((ev = cacheHead) != NULL)
    {
        cacheHead = cacheHead->next;

	/* Mark desc as being in use */
	ev->next = (EMBX_EVENT) EMBX_HANDLE_VALID;

	EMBX_OS_MUTEX_RELEASE(&cacheLock);
    }
    else
    {
        EMBX_OS_MUTEX_RELEASE(&cacheLock);
      
	/* Dynamically allocate a new cache container
	 * and initialise the event inside it
	 */
	ev = EMBX_OS_MemAlloc(sizeof(*ev));
	
	if (ev)
	{
	    /* Mark desc as being in use */
	    ev->next = (EMBX_EVENT) EMBX_HANDLE_VALID;

	    ev->event = semaphore_create_fifo(0);
	}
    }
    
    return ev;
}
예제 #6
0
Transformer_t* MME_RemoteTransformer_Create(HostManager_t *manager, TransportInfo_t* info, EMBX_PORT adminPort)
{
	static const TransformerVTable_t vtable = {
	        RemoteTransformer_Destroy,
	        RemoteTransformer_Init,
	        RemoteTransformer_Term,
	        RemoteTransformer_Kill,
	        RemoteTransformer_AbortCommand,
		RemoteTransformer_KillCommand,
	        RemoteTransformer_SendCommand,
	        RemoteTransformer_IsStillAlive,
	        RemoteTransformer_GetTransformerCapability,
		RemoteTransformer_WaitForMessage,
		RemoteTransformer_LookupCommand,
		RemoteTransformer_ReleaseCommandSlot
	};

	RemoteTransformer_t* remoteTransformer;
	int i;
	
	remoteTransformer = EMBX_OS_MemAlloc(sizeof(RemoteTransformer_t));
	if (!remoteTransformer) {
		return NULL;
	}

	/* zero the structure */
	memset(remoteTransformer, 0, sizeof(RemoteTransformer_t));

	/* initialize the non-zero elements */
	remoteTransformer->super.vtable     = &vtable;
	remoteTransformer->super.manager    = manager;
	remoteTransformer->super.info       = info;
	remoteTransformer->adminPort        = adminPort;
	remoteTransformer->maxCommandSlots  = MAX_TRANSFORMER_SEND_OPS;

	/* allocate the command slots (used to keep track of in-flight commands) */
	remoteTransformer->commandSlots = EMBX_OS_MemAlloc(sizeof(CommandSlot_t) *
							   remoteTransformer->maxCommandSlots);
	if (0 == remoteTransformer->commandSlots) {
		goto error_recovery;
	}
	
	for (i=0; i<remoteTransformer->maxCommandSlots; i++) {
		remoteTransformer->commandSlots[i].command = 0;
		remoteTransformer->commandSlots[i].status = MME_COMMAND_COMPLETED_EVT;
	}

	if (!EMBX_OS_EVENT_INIT(&remoteTransformer->terminateWasReplied)) {
		goto error_recovery;
	}
	
	if (!EMBX_OS_MUTEX_INIT(&remoteTransformer->commandSlotLock)) {
		EMBX_OS_EVENT_DESTROY(&remoteTransformer->terminateWasReplied);	
		goto error_recovery;
	}
	
	/* reference the transport info structure (so it can't be deregistered) */
	info->referenceCount++;
	
	return &remoteTransformer->super;
	
    error_recovery:
    	
    	/* EMBX_OS_MemFree() will ignore NULL pointers */
    	EMBX_OS_MemFree(remoteTransformer->commandSlots);
    	EMBX_OS_MemFree(remoteTransformer);

    	return NULL;
}