Пример #1
0
/*********************************************************
	Signal to waiting threads bus reset completion
*/
HRESULT	briSignalOnResetPreCompletion (void)
{
	HRESULT		hResult = NO_ERROR;
	uint32		waitingTasks = 0;

	if (!briInitialized)
	{
		hResult = E_BRI_NOT_INITIALIZED_FATAL;
		sysLogError(hResult, __LINE__, moduleName);
		return hResult;
	}

	// Exclusive exclusive access for briPreCompletionWaitingTasks (mutex)
	hResult = TCMutexLock(briPreCompletionMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	waitingTasks = briPreCompletionWaitingTasks;
	briPreCompletionWaitingTasks = 0;
	
	// Release exclusive access for briPreCompletionWaitingTasks (mutex)
	TCMutexUnlock(briPreCompletionMutexSemID);

	if (waitingTasks > 0)
	{
		while (waitingTasks--)
		{
			TCSemaphoreSignal(briPreCompletionSemID);
		}
	}

	return hResult;
}
Пример #2
0
HRESULT	crRemoveCallback(CALLBACK_DESCRIPTOR* callback)
{
	HRESULT					hResult = NO_ERROR;
	CALLBACK_DESCRIPTOR*	prev = NULL;
	CALLBACK_DESCRIPTOR*	next = NULL;

	if (crFindCallback(CR_FIND_CALLBACK_PREV, 0, 0, callback, &prev) == FALSE)
	{
		hResult = E_AVC_CR_CALLBACK_NOT_FOUND;
		sysLogError(hResult, __LINE__, moduleName);
		return hResult;
	}
	
	// exclusive access for the cr list (mutex)
	hResult = TCMutexLock(crListMutexSemID);
	if (hResult != NO_ERROR) return hResult;
	
	kvGetValue(callback, CALLBACK_DESCRIPTOR_NEXT, (uint32 *) &next);
	kvSetValue(callback, CALLBACK_DESCRIPTOR_NEXT, 0);
	kvSetValue(prev, CALLBACK_DESCRIPTOR_NEXT, (uint32) next);
	if (crDescHead == callback)
	{
		crDescHead = next;
	}

	// exclusive access for the cr list (mutex)
	TCMutexUnlock(crListMutexSemID);
	
	return hResult;	
}
Пример #3
0
/*********************************************************
	Wait for a bus reset pre completion
*/
HRESULT	briWaitOnResetPreCompletion (BOOL *bResetDetected)
{
	HRESULT		hResult = NO_ERROR;

	*bResetDetected = FALSE;

	if (!briInitialized)
	{
		hResult = E_BRI_NOT_INITIALIZED_FATAL;
		sysLogError(hResult, __LINE__, moduleName);
		return hResult;
	}

	// exclusive access for briPreCompletionWaitingTasks (mutex)
	hResult = TCMutexLock(briPreCompletionMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	if (briInBusResetProgress == TRUE &&
		briPreCompletionDone == FALSE)
	{
		*bResetDetected = TRUE;
		briPreCompletionWaitingTasks++;		
	}

	// Release exclusive access for briPreCompletionWaitingTasks (mutex)
	TCMutexUnlock(briPreCompletionMutexSemID);
	
	if (*bResetDetected == TRUE)
	{
		hResult = TCSemaphoreWait(briPreCompletionSemID);
		if (hResult != NO_ERROR) return hResult;
	}

	return hResult;
}
Пример #4
0
HRESULT crAddCallback(CALLBACK_DESCRIPTOR* callback)
{
	HRESULT		hResult = NO_ERROR;

	// First check for required key types, these are described in the cr.h
	hResult = kvIsKey(callback, CALLBACK_DESCRIPTOR_TYPE);
	if (hResult != NO_ERROR) return hResult;
	
	hResult = kvIsKey(callback, CALLBACK_DESCRIPTOR_NEXT);
	if (hResult != NO_ERROR) return hResult;
	
#ifdef _SYSDEBUG
	// check in debug mode never to allow adding of the same element twice
	if (crFindCallback(CR_FIND_CALLBACK_THIS, 0, 0, callback, &callback) == TRUE)
	{
		char*	name = NULL;
		kvGetValue(callback, CALLBACK_DESCRIPTOR_NAME, (uint32*) &name);
		sysDebugPrintf("cr error: can't add callback '%s'(0x%08X) twice\n\r", (name) ? name : "un-named", callback);
	}
#endif //_SYSDEBUG
	
	// exclusive access for the cr list (mutex)
	hResult = TCMutexLock(crListMutexSemID);
	if (hResult != NO_ERROR) return hResult;
	
	// need to link this descriptor into the list, by making the crDescHead the next element, and making this the crDescHead
	kvSetValue(callback, CALLBACK_DESCRIPTOR_NEXT, (uint32) crDescHead);
	crDescHead = callback;
	
	// exclusive access for the cr list (mutex)
	TCMutexUnlock(crListMutexSemID);

	return hResult;
}
Пример #5
0
HRESULT lhlStatusQueueCreate(STATUS_INFO **statusInfo)
{
	HRESULT		hResult = NO_ERROR;
	uint32		index;
	uint32		ptr;
	BOOL		bFound = FALSE;
	
	// exclusive access for the statusInfoQueue (mutex)
	hResult = TCMutexLock(lhlStatusQueueMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	*statusInfo = NULL;

	// find a free statusInfo from the pool
	ptr = statusInfoQueue.ptr;
	
	for (index = 0; index < STATUS_INFO_ITEMS; index++)
	{
		if (statusInfoQueue.allocated[ptr] == FALSE)
		{
			*statusInfo = &statusInfoQueue.statusInfo[ptr];
			lhlStatusQueueResetInfo(*statusInfo);
			statusInfoQueue.allocated[ptr] = TRUE;
			bFound = TRUE;

#ifdef _STATISTICS
			lhlStatistics.statusInfoInuse++;
			if (lhlStatistics.statusInfoInuseMax < lhlStatistics.statusInfoInuse)
			{
				lhlStatistics.statusInfoInuseMax = lhlStatistics.statusInfoInuse;
			}
#endif //_STATISTICS
		}

		ptr = (ptr + 1) % STATUS_INFO_ITEMS;
		
		if (bFound == TRUE)
		{
			statusInfoQueue.ptr = ptr;
			break;
		}
	}

	if (bFound == FALSE)
	{
		SYS_DEBUG(SYSDEBUG_TRACE_WARNINGS, "lhlStatusQueue: No more free status info items\n\r");
		hResult = E_NULL_PTR;
		sysLogError(hResult, __LINE__, moduleName);
	}

	// exclusive access for the statusInfoQueue (mutex)
	TCMutexUnlock(lhlStatusQueueMutexSemID);

	return hResult;
}
Пример #6
0
HRESULT lmHandleListElement(LM_CONTEXT* list, BOOL bIndexed, uint32 index, LM_HANDLE_INDEX_ELEMENT_CB callback, void **data, uint32 *arg1, uint32 *arg2)
{
	HRESULT			hResult = NO_ERROR;
	LM_ELEMENT*		elem = 0;
	
	if (list == NULL)
	{
		hResult = E_NULL_PTR;
		sysLogError(hResult, __LINE__, moduleName);
		return hResult;
	}
	
	// Exclusive access for accessing list (mutex)
	hResult = TCMutexLock(list->lmMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	elem = (LM_ELEMENT*) &(list->elements);

	if (bIndexed)
	{
		// call indexed elem
		if (index < list->elemcount)
		{

			lmMoveAheadElementSizeItems(list->elemsize, &elem, index);
			hResult = (callback) (list, index, elem, data, arg1, arg2);
		}
		else
		{
			hResult = E_LM_ELEMENT_UNAVAILABLE;
		}
	}
	else
	{
		// walk through the list elements and call for each elem
		uint32	count = 0;

		for (count = 0; count < list->elemcount; count++)
		{
			hResult = (callback) (list, count, elem, data, arg1, arg2);
			if (hResult != E_LM_ELEMENT_NOT_FOUND) break;
			lmMoveAheadElementSize(list->elemsize, &elem);
		}
		if (count == list->elemcount)
		{
			hResult = E_LM_ELEMENT_UNAVAILABLE;
		}
	}

	// Release exclusive for accessing list (mutex)
	TCMutexUnlock(list->lmMutexSemID);

	return hResult;
}
Пример #7
0
static HRESULT lhlStatusQueueDisplay(void)
{
	HRESULT		hResult = NO_ERROR;

	// exclusive access for the pending transactions table (mutex)
	hResult = TCMutexLock(lhlStatusQueueMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	hResult = __lhlStatusQueueDisplay();

	// exclusive access for the pending transactions table (mutex)
	TCMutexUnlock(lhlStatusQueueMutexSemID);

	return hResult;
}
Пример #8
0
HRESULT lmDisposeList(LM_CONTEXT* list)
{
	HRESULT		hResult = NO_ERROR;

	if (list == NULL)
	{
		hResult = E_NULL_PTR;
		sysLogError(hResult, __LINE__, moduleName);
		return hResult;
	}
	
	// Exclusive access for accessing list (mutex)
	hResult = TCMutexLock(list->lmMutexSemID);
	if (hResult != NO_ERROR) return hResult;
	
	memset(list, 0, list->listsize);
	
	// Release exclusive for accessing list (mutex)
	TCMutexUnlock(list->lmMutexSemID);
	
	return hResult;
}
Пример #9
0
HRESULT lhlStatusQueueMatch(uint32 nodeAddr, uint32 tLabel, uint32 genType, PB_PACKETTYPE packetType, STATUS_INFO **statusInfo, BOOL bRemoveEntry)
{
	HRESULT		hResult = NO_ERROR;
	uint32		index;
	STATUS_INFO	*si = NULL;
	BOOL		bFound = FALSE;

	// exclusive access for the statusInfoQueue (mutex)
	hResult = TCMutexLock(lhlStatusQueueMutexSemID);
	if (hResult != NO_ERROR) return hResult;

	if (statusInfo)
	{
		*statusInfo = NULL;
	}

	// find a matching statusInfo from the pool
	for (index = 0; index < STATUS_INFO_ITEMS; index++)
	{
		si = &statusInfoQueue.statusInfo[index];
		if (statusInfoQueue.allocated[index] == TRUE)
		{
			if (si->nodeAddr == nodeAddr &&
				si->tLabel == tLabel &&
				si->packetType == packetType &&
				si->genType == genType)
			{
				bFound = TRUE;
				if (statusInfo)
				{
					*statusInfo = si;
				}
				if (bRemoveEntry)
				{
					hResult = si->hResultFinal;
					lhlStatusQueueResetInfo(si);
					statusInfoQueue.allocated[index] = FALSE;
					statusInfoQueue.ptr = index;

#ifdef _STATISTICS
					lhlStatistics.statusInfoInuse--;
#endif //_STATISTICS
				}
				break;
			}
		}
	}

	if (bFound == FALSE ||
		(statusInfo && *statusInfo == NULL))
	{
		SYS_DEBUG(SYSDEBUG_TRACE_WARNINGS, "lhlStatusQueue: No match nodeAddr 0x%04x, tLabel 0x%04x, pckType:0x%04x, genType:0x%04x\n\r", nodeAddr, tLabel, packetType, genType);
#ifdef _SYSDEBUGERROR
		if (sysDebugIsEnabled(SYSDEBUG_TRACE_ERRORS))
		{
			sysDebugPrintf("lhlStatusQueueMatch\n\r");
			__lhlStatusQueueDisplay();
		}
#endif //_SYSDEBUGERROR
		hResult = E_NULL_PTR;
		sysLogError(hResult, __LINE__, moduleName);
	}

	// exclusive access for the statusInfoQueue (mutex)
	TCMutexUnlock(lhlStatusQueueMutexSemID);

	return hResult;
}
Пример #10
0
BOOL crFindCallback(uint32 mode, uint32 type, uint32 index, CALLBACK_DESCRIPTOR* findcallback, CALLBACK_DESCRIPTOR** callback)
{
	HRESULT					hResult = NO_ERROR;
	CALLBACK_DESCRIPTOR*	current = crDescHead;
	CALLBACK_DESCRIPTOR*	next = NULL;
	uint32					counter = 0;
	uint32					foundtype = 0;
	BOOL					bFound = FALSE;

	// exclusive access for the cr list (mutex)
	hResult = TCMutexLock(crListMutexSemID);
	if (hResult != NO_ERROR) return FALSE;
	
	while (current)
	{
		switch (mode)
		{
			case CR_FIND_CALLBACK_TYPE:
				kvGetValue(current, CALLBACK_DESCRIPTOR_TYPE, &foundtype);
				if (foundtype == type)
				{
					bFound = (counter == index);
					counter++;	
				}
				break;
			
			case CR_FIND_CALLBACK_FIRST:
				bFound = TRUE;
				break;

			case CR_FIND_CALLBACK_THIS:
				bFound = (current == findcallback);
				break;

			case CR_FIND_CALLBACK_PREV:
				kvGetValue(current, CALLBACK_DESCRIPTOR_NEXT, (uint32 *) &next);
				if (!next) break;
				bFound = (next == findcallback);
				break;

			case CR_FIND_CALLBACK_NEXT:
				kvGetValue(findcallback, CALLBACK_DESCRIPTOR_NEXT, (uint32 *) &next);
				current = next;
				if (!current) continue;
				bFound = TRUE;
				break;
		}
		
		if (bFound == TRUE)
		{
			*callback = current;
			break;
		}

		kvGetValue(current, CALLBACK_DESCRIPTOR_NEXT, (uint32 *) &next);
		if (!next) break;
						
		current = next;
	}
	
	// exclusive access for the cr list (mutex)
	TCMutexUnlock(crListMutexSemID);

	return bFound;
}