Log::~Log()
{
if( gs_Log == this ) LogSetDefault(nullptr);
TimerDestroy(timer);
MutexDestroy(mutex);
}
// reaper callback
static void
ReapTrapReference(LIST_ITEM *pItem)
{
// Reaper uses QListObj, so we must use PARENT_STRUCT
TRAP_REFERENCE *pTrapReference = PARENT_STRUCT(pItem, TRAP_REFERENCE, ListItem);
TimerDestroy(&pTrapReference->Timer);
MemoryDeallocate(pTrapReference);
}
void udelay(int us)
{
u8 heap[0x10];
u32 msg;
s32 mqueue = -1;
s32 timer = -1;
mqueue = mqueue_create(heap, 1);
if(mqueue < 0)
goto out;
timer = TimerCreate(us, 0, mqueue, 0xbabababa);
if(timer < 0)
goto out;
mqueue_recv(mqueue, &msg, 0);
out:
if(timer > 0)
TimerDestroy(timer);
if(mqueue > 0)
mqueue_destroy(mqueue);
}
void
SubscribeTerminate()
{
LIST_ITEM *pTrapReferenceListItem;
_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, SubscribeTerminate);
SpinLockAcquire(&SubscribedTrapsListLock);
SubscribeInitialized = 0;
SpinLockRelease(&SubscribedTrapsListLock);
iba_sd_deregister(SdClientHandle);
/* no more SD callbacks will occur now, so OPQUEUED is not important */
SpinLockAcquire(&SubscribedTrapsListLock);
while ( NULL != (pTrapReferenceListItem = QListRemoveHead(&SubscribedTrapsList)))
{
TRAP_REFERENCE *pTrapReference = (TRAP_REFERENCE *)QListObj(pTrapReferenceListItem);
ASSERT(pTrapReference != NULL);
TimerStop(&pTrapReference->Timer);
// release lock so TimerDestroy can wait for callback
SpinLockRelease(&SubscribedTrapsListLock);
TimerDestroy(&pTrapReference->Timer);
MemoryDeallocate(pTrapReference);
SpinLockAcquire(&SubscribedTrapsListLock);
}
SpinLockRelease(&SubscribedTrapsListLock);
QListDestroy(&SubscribedTrapsList);
SpinLockDestroy(&SubscribedTrapsListLock);
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
}
static
FSTATUS
IncrementMcGroupUsageCount(CLIENT_HANDLE SdClientHandle,
void *pContext,
SD_MULTICAST_CALLBACK *pMulticastCallback,
uint16 McFlags,
uint64 ComponentMask,
IB_MCMEMBER_RECORD *pMcMemberRecord,
MC_GROUP_ID *pMcGroupId)
{
MC_CLIENT *pMcClientTemp;
MC_CLIENT *pMcClient = NULL;
MC_GROUP *pMcGroupTemp;
MC_GROUP *pMcGroup = NULL;
boolean StartTrapNotification;
_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, IncrementMcGroupUsageCount);
/* Allocate Everything up front to avoid locking issues */
pMcClientTemp = (MC_CLIENT *)MemoryAllocate2AndClear(sizeof(MC_CLIENT), IBA_MEM_FLAG_NONE, SUBNET_DRIVER_TAG);
if (pMcClientTemp == NULL)
{
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return FINSUFFICIENT_MEMORY;
}
pMcClientTemp->SdClientHandle = SdClientHandle;
pMcClientTemp->pContext = pContext;
pMcClientTemp->McFlags = McFlags;
pMcClientTemp->pMulticastCallback = pMulticastCallback;
pMcGroupTemp = (MC_GROUP*)MemoryAllocate2AndClear(sizeof(MC_GROUP), IBA_MEM_FLAG_SHORT_DURATION, SUBNET_DRIVER_TAG);
if (pMcGroupTemp == NULL)
{
_DBG_ERROR(("IncrementMcGroupUsageCount MemoryAllocateError\n"));
MemoryDeallocate(pMcClientTemp);
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return FINSUFFICIENT_MEMORY;
}
SpinLockAcquire(&MulticastLock);
pMcClient = FindMcClient(SdClientHandle, pMcGroupId);
if (pMcClient == NULL)
{
pMcClient= pMcClientTemp;
pMcClientTemp = NULL;
}
else
{
_DBG_ERROR(("IncrementMcGroupUsageCount Client already exists.\n"));
/*SpinLockRelease(&MulticastLock);
MemoryDeallocate(pMcGroupTemp);
MemoryDeallocate(pMcClient);
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return FDUPLICATE;*/
// continue anyway
}
StartTrapNotification = QListIsEmpty(&MasterMcGroupList);
pMcGroup = FindMcGroup(pMcGroupId);
if (pMcGroup == NULL)
{
// didn't find Mcgroup in list, let us add one
pMcGroupTemp->McGroupState = MC_GROUP_STATE_REQUEST_JOIN;
pMcGroupTemp->ComponentMask = ComponentMask;
pMcGroupTemp->McMemberRecord = *pMcMemberRecord;
pMcGroupTemp->McGroupId = *pMcGroupId;
QListInit(&pMcGroupTemp->McClientList);
QListSetObj(&pMcGroupTemp->ListItem, pMcGroupTemp);
pMcGroup = pMcGroupTemp;
pMcGroupTemp = NULL;
QListInsertTail(&MasterMcGroupList, &pMcGroup->ListItem);
TimerInitState(&pMcGroup->Timer);
TimerInit(&pMcGroup->Timer, IssueSubnetDriverCall, pMcGroup );
}
else
{
// group already exists - check state
if ( (pMcGroup->McGroupState != MC_GROUP_STATE_REQUEST_JOIN) &&
(pMcGroup->McGroupState != MC_GROUP_STATE_AVAILABLE) )
{
if (pMcGroup->McGroupState == MC_GROUP_STATE_JOIN_FAILED)
{
_DBG_ERROR(("Prior attempt to join Multicast Group failed\n"));
}
else
{
_DBG_ERROR(("IncrementMcGroupUsageCount McGroup invalid state:%d.\n",
pMcGroup->McGroupState));
}
SpinLockRelease(&MulticastLock);
MemoryDeallocate(pMcGroupTemp);
if(pMcClientTemp)
MemoryDeallocate(pMcClientTemp);
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return FDUPLICATE;
}
}
pMcClient->pMcGroup = pMcGroup;
QListSetObj(&pMcClient->ListItem, pMcClient);
QListInsertTail(&MasterMcClientList, &pMcClient->ListItem);
QListSetObj(&pMcClient->McGroupListItem, pMcClient);
QListInsertTail(&pMcGroup->McClientList, &pMcClient->McGroupListItem);
if (pMcGroupTemp == NULL)
{
/* First client joining the group - Get The Process Started */
_DBG_INFO(("new mcgroup - queuing join\n"));
QueueSubnetDriverCall(pMcGroup, MC_GROUP_STATE_REQUEST_JOIN);
}
else
{
_DBG_INFO(("existing mcgroup - checking flags %d\n",
pMcGroup->McGroupState));
if ((McJoinFlagsAdjusted(pMcGroup, pMcMemberRecord) == TRUE) &&
(pMcGroup->McGroupState == MC_GROUP_STATE_AVAILABLE)) // TODO: Check Concurrency Here
/* we had already joined and the flags changes - so rejoin */
{
_DBG_INFO(("flags changed after we joined - rejoining \n"));
QueueSubnetDriverCall(pMcGroup, MC_GROUP_STATE_REQUEST_JOIN);
}
else if (pMcGroup->McGroupState == MC_GROUP_STATE_AVAILABLE)
{
// we already had joined but we got a new client - issue callbacks
_DBG_INFO(("someone joined when state is available - issuing callbacks \n"));
CallMcClients(pMcGroup, FSUCCESS, MC_GROUP_STATE_AVAILABLE);
}
// NOTE if state is JOIN, then when that completes all clients
// including new one will be notified via callback
}
if (MaintenanceTimerActivated == FALSE)
{
MaintenanceTimerActivated = TRUE;
TimerStart(&MaintenanceTimer, 5000);
}
SpinLockRelease(&MulticastLock);
if (StartTrapNotification)
{
McSubscribeForTraps();
}
if (pMcGroupTemp)
{
TimerDestroy(&pMcGroupTemp->Timer);
QListDestroy(&pMcGroupTemp->McClientList);
MemoryDeallocate(pMcGroupTemp);
}
if (pMcClientTemp)
{
MemoryDeallocate(pMcClientTemp);
}
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return FSUCCESS;
}
FSTATUS
MulticastTerminate(void)
{
FSTATUS Status;
CLIENT_HANDLE McSdHandleTemp;
LIST_ITEM *pListItem;
_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, MulticastTerminate);
/* Just in case maintenance routine is running */
SpinLockAcquire(&MulticastLock);
McSdHandleTemp = McSdHandle;
McSdHandle = NULL;
SpinLockRelease(&MulticastLock);
if (McSdHandleTemp == NULL)
{
_DBG_ERROR(("Multicast Module Not A Registered Subnet Driver "
"Client Process.\n"));
Status = FINVALID_STATE;
goto exit;
}
if (MaintenanceTimerActivated == TRUE)
{
TimerStop(&MaintenanceTimer);
MaintenanceTimerActivated = FALSE;
}
Status = iba_sd_deregister(McSdHandleTemp);
if (Status != FSUCCESS) {
_DBG_ERROR(("Cannot Deregister With "
"Subnet Data Interface.\n"));
}
for (pListItem = QListRemoveHead(&MasterMcGroupList);
pListItem != NULL;
pListItem = QListRemoveHead(&MasterMcGroupList))
{
MC_GROUP *pMcGroup = (MC_GROUP *)QListObj(pListItem);
ASSERT(pMcGroup != NULL);
TimerStop(&pMcGroup->Timer);
TimerDestroy(&pMcGroup->Timer);
QListDestroy(&pMcGroup->McClientList);
MemoryDeallocate(pMcGroup);
}
for (pListItem = QListRemoveHead(&MasterMcClientList);
pListItem != NULL;
pListItem = QListRemoveHead(&MasterMcClientList))
{
MC_CLIENT *pMcClient = (MC_CLIENT *)QListObj(pListItem);
ASSERT(pMcClient != NULL);
MemoryDeallocate(pMcClient);
}
QListDestroy(&MasterMcGroupList);
QListDestroy(&MasterMcClientList);
TimerDestroy(&MaintenanceTimer);
SpinLockDestroy(&MulticastLock);
exit:
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
return Status;
}
static
void
McMaintenance(void *pContext)
{
LIST_ITEM *pListItem;
_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, McMaintenance);
if (McSdHandle != NULL)
{
SpinLockAcquire(&MulticastLock);
if (TimerCallbackStopped(&MaintenanceTimer))
{
// stale timer callback
SpinLockRelease(&MulticastLock);
goto done;
}
// Loop Through MasterMcClientList
pListItem = QListHead(&MasterMcClientList);
while(pListItem != NULL)
{
MC_CLIENT *pMcClient = (MC_CLIENT *)QListObj(pListItem);
ASSERT(pMcClient != NULL);
pListItem = QListNext(&MasterMcClientList, pListItem);
if ((pMcClient->McClientDelete == TRUE) &&
(pMcClient->McClientInUse == 0))
{
QListRemoveItem(&MasterMcClientList, &pMcClient->ListItem);
SpinLockRelease(&MulticastLock);
MemoryDeallocate(pMcClient);
if (McSdHandle == NULL)
{
break;
}
SpinLockAcquire(&MulticastLock);
}
}
}
if (McSdHandle != NULL)
{
// Loop Through MasterMcGroupList
pListItem = QListHead(&MasterMcGroupList);
while(pListItem != NULL)
{
MC_GROUP *pMcGroup = (MC_GROUP *)QListObj(pListItem);
ASSERT(pMcGroup != NULL);
pListItem = QListNext(&MasterMcGroupList, pListItem);
if ((pMcGroup->McGroupDelete == TRUE) &&
(pMcGroup->McGroupInUse == 0))
{
TimerDestroy(&pMcGroup->Timer);
QListDestroy(&pMcGroup->McClientList);
QListRemoveItem(&MasterMcGroupList, &pMcGroup->ListItem);
SpinLockRelease(&MulticastLock);
MemoryDeallocate(pMcGroup);
if (McSdHandle == NULL)
{
break;
}
SpinLockAcquire(&MulticastLock);
}
}
}
if (McSdHandle != NULL)
{
if (!QListIsEmpty(&MasterMcGroupList) ||
!QListIsEmpty(&MasterMcClientList))
{
/* Only Start It If There Is A Possibility Of Something To Do */
TimerStart(&MaintenanceTimer, 5000);
SpinLockRelease(&MulticastLock);
}
else
{
McUnsubscribeForTraps();
MaintenanceTimerActivated = FALSE;
SpinLockRelease(&MulticastLock);
}
}
done:
_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );
}
