/* BEGIN_ICS_COPYRIGHT4 ****************************************

Copyright (c) 2015, Intel Corporation

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors

      may be used to endorse or promote products derived from this software

      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT4   ****************************************/

#include <datatypes.h>

#include <imemory.h>

#include <ilist.h>

#include <ievent.h>

#include <stl_sd.h>

#include <sdi.h>

#include <subscribe.h>

uint32 LastClientId;

CLIENT_CONTROL_PARAMETERS DefaultClientParameters;

QUICK_LIST *pClientList = NULL;

SPIN_LOCK *pClientListLock = NULL;

// Initialize the default parameters that clients get

void

SetDefaultClientParameters(

	void

	)

{

    DefaultClientParameters.ControlParameters.RetryCount = g_SdParams.DefaultRetryCount;

    DefaultClientParameters.ControlParameters.Timeout =  g_SdParams.DefaultRetryInterval;

    DefaultClientParameters.ClientDebugFlags = g_SdParams.DefaultDebugFlags;

    DefaultClientParameters.OptionFlags = g_SdParams.DefaultOptionFlags;

	SpinLockAcquire(pClientListLock);

    LastClientId = 0;

    SpinLockRelease(pClientListLock);

}

FSTATUS

iba_sd_register(

    IN OUT CLIENT_HANDLE *ClientHandle,

    IN PCLIENT_CONTROL_PARAMETERS pClientParameters OPTIONAL

    )

{

    ClientListEntry *pClientEntry;

    //

    // Note: If the caller is running at low priority, the input pointers for

    // the client ID and the client parameters can be pageable. If the caller

    // is running at a high priority, it is the caller's responsibility to 

    // make sure that the pointers point to non-pageable memory.

    //

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, iba_sd_register);

    pClientEntry = (ClientListEntry*)MemoryAllocate2AndClear(sizeof(ClientListEntry), IBA_MEM_FLAG_NONE,

        SUBNET_DRIVER_TAG);

    if (pClientEntry == NULL)  

	{

        _DBG_ERROR(

            ("Cannot allocate memory for new client entry\n"));

        return(FINSUFFICIENT_MEMORY);

    }

	pClientEntry->ListItem.pObject = (void *)pClientEntry;

    if (pClientParameters == NULL)  

	{

		_DBG_INFO(("ClientParameters is NULL, Setting Driver Defaults\n"));

        MemoryCopy(&pClientEntry->ClientParameters, &DefaultClientParameters,

            sizeof(pClientEntry->ClientParameters));

    } else { 

        MemoryCopy(&pClientEntry->ClientParameters, pClientParameters,

            sizeof(pClientEntry->ClientParameters));

    }

    QListInit(&pClientEntry->ClientTraps);

    SpinLockAcquire(pClientListLock);

    pClientEntry->ClientId = LastClientId++;

    // 

    // Note: We are running at the priority level of the caller. If the caller

    // is running at low priority, the memory containing input client parameters

    // could be pageable and may not be touched at high priority with a spin

    // lock held. We therefor copy parameters to (non-pageable) stack location

    // before raising priority by getting a lock

    //

    QListInsertHead(pClientList, &pClientEntry->ListItem);

    SpinLockRelease(pClientListLock);

    //

    // Now we are back at the caller's priority, which could be low. In that 

    // case, it is now safe to touch the caller's potentially pageable memory.

    //

    //*pCid = Cid;

	*ClientHandle = (CLIENT_HANDLE)pClientEntry;

	_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

    return(FSUCCESS);

}

FSTATUS

iba_sd_deregister(

    IN CLIENT_HANDLE ClientHandle

    )

{

	return CommonSdDeregister(ClientHandle);

}

FSTATUS

CommonSdDeregister(

    IN CLIENT_HANDLE ClientHandle

    )

{

    ClientListEntry *pClientEntry = (ClientListEntry *)ClientHandle;

    FSTATUS Fstatus = FNOT_FOUND;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, iba_sd_deregister);

    SpinLockAcquire(pClientListLock);

	// &pClientEntry->ListItem does not dereference pClientEntry

	if(QListIsItemInList(pClientList, &pClientEntry->ListItem) == TRUE)

	{

		QListRemoveItem(pClientList, &pClientEntry->ListItem);

		Fstatus = FSUCCESS;

		_DBG_INFO(("Client Entry removal passed\n"));

	} else {

		Fstatus = FNOT_FOUND;

		_DBG_INFO(("Client Entry removal failed\n"));

	}

    SpinLockRelease(pClientListLock);

	// Clean up CompletionList and QueryList for this clienthandle

	if(Fstatus == FSUCCESS)

	{

		CancelClientQueries(ClientHandle);

		UnsubscribeClient(pClientEntry);

		MemoryDeallocate(pClientEntry);

	}

	_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

    return(Fstatus);

}

static boolean

CompareClientHandle(

	IN LIST_ITEM* pListItem,

	IN void* Context)

{

	return (((PQueryDetails)QListObj(pListItem))->ClientHandle == (CLIENT_HANDLE)Context);

}

// cancel all queries in progress for client

// if we remove them from the pQueryList, any subsequent responses will

// be discarded, same as if the query had timed out

// if we cancel just before completions are reported, we could find some

// on the completion list for this client, so we clean them up too

//

// Note that child queries are never associated to a ClientHandle.

// Hence we will not be cancelling any child queries here.

// By cancelling the parent, the child will be discarded when it comes to

// the head of the pChildQueryList or when its response arrives.

void

CancelClientQueries(

	IN CLIENT_HANDLE ClientHandle

	)

{

	QueryDetails *pQueryElement;

	boolean schedule = FALSE;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, CancelClientQueries);

	// first process the Query List

	SpinLockAcquire(&pQueryList->m_Lock);

	while (NULL != (pQueryElement = (QueryDetails*)QListFindFromHead(

											&pQueryList->m_List,

											CompareClientHandle, ClientHandle)))

	{

		QListRemoveItem(&pQueryList->m_List, &pQueryElement->QueryListItem);

		DEBUG_ASSERT( pQueryElement->QState != QueryDestroy);

		DEBUG_ASSERT( pQueryElement->pParentQuery == NULL);	// not a child

		pQueryElement->ClientHandle = NULL;	// disassociate from client

		if( pQueryElement->QState == ProcessingResponse

			|| pQueryElement->ChildProcessingResponseCount)

		{

			DEBUG_ASSERT(pQueryElement->QState == WaitingForChildToComplete

					|| ! pQueryElement->ChildProcessingResponseCount);

			// RecvHandler is still holding onto pQueryElement

			// mark state so RecvHandler will destroy it, leave off list

			pQueryElement->QState = QueryDestroy;

			SpinLockRelease(&pQueryList->m_Lock);

		} else {

			// no one else is using this element, we can unlock and change it

			SpinLockRelease(&pQueryList->m_Lock);

			if( pQueryElement->QState == WaitingForResult

				|| pQueryElement->QState == BusyRetryDelay)

				AtomicDecrementVoid(&Outstanding);

			// so we don't prempt here, defer destroy to premptable context

			pQueryElement->QState = QueryDestroy;

			LQListInsertHead(pCompletionList, &pQueryElement->QueryListItem);

			schedule = TRUE;

		}

		SpinLockAcquire(&pQueryList->m_Lock);

	}

	SpinLockRelease(&pQueryList->m_Lock);

	// now process the Completion List

	SpinLockAcquire(&pCompletionList->m_Lock);

	while (NULL != (pQueryElement = (QueryDetails*)QListFindFromHead(

											&pCompletionList->m_List,

											CompareClientHandle, ClientHandle)))

	{

		// any items in QueryDestroy state should no longer be associated to

		// a client. so we can assert that we are not in QueryDestroy state

		DEBUG_ASSERT(pQueryElement->QState == QueryComplete);

		DEBUG_ASSERT( pQueryElement->pParentQuery == NULL);	// not a child

		pQueryElement->ClientHandle = NULL;	// disassociate from client

		// so we don't prempt here, defer destroy to premptable context

		// can leave on list

		pQueryElement->QState = QueryDestroy;

		SpinLockRelease(&pCompletionList->m_Lock);

		schedule = TRUE;

		SpinLockAcquire(&pCompletionList->m_Lock);

	}

	SpinLockRelease(&pCompletionList->m_Lock);

	// completion processing will handle defered destroys

	if (schedule)

		ScheduleCompletionProcessing();

}

FSTATUS

iba_sd_get_client_control_parameters(

    IN CLIENT_HANDLE ClientHandle,

    IN OUT PCLIENT_CONTROL_PARAMETERS pClientControlParameters

    )

{

    FSTATUS Fstatus = FNOT_FOUND;

    CLIENT_CONTROL_PARAMETERS ClientParams;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, iba_sd_get_client_control_parameters);

    if (pClientControlParameters == NULL) {

		_DBG_INFO(("Invalid ClientControlParameters\n"));

		_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

        return(FINVALID_PARAMETER);

    }

    // Note: If the caller is running at low priority, the input memory for

    // the client parameters can be pageable. If the caller is running at a 

    // high priority, it is the caller's responsibility to make sure that the

    // memory is non-pageable.

	Fstatus = ValidateClientHandle(ClientHandle, &ClientParams);

    // Now we are back to the caller's priority level and can safely touch

    // the memory to which the results have to be written.

    if (Fstatus == FSUCCESS)  

	{

        MemoryCopy(pClientControlParameters, &ClientParams,

            sizeof(ClientParams));

    }

	_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

    return(Fstatus);

}

FSTATUS

iba_sd_set_client_control_parameters(

    IN CLIENT_HANDLE ClientHandle,

    IN PCLIENT_CONTROL_PARAMETERS pClientControlParameters

    )

{

    FSTATUS Fstatus = FNOT_FOUND;

    CLIENT_CONTROL_PARAMETERS ClientParams;

	LIST_ITEM *pListItem = &((ClientListEntry *)ClientHandle)->ListItem;

    _DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, iba_sd_set_client_control_parameters);

    if (pClientControlParameters == NULL) 

	{

		_DBG_INFO(("Invalid ClientControlParameters\n"));

		_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

        return(FINVALID_PARAMETER);

    }

    // Note: If the caller is running at low priority, the input memory for

    // the client parameters can be pageable. If the caller is running at a 

    // high priority, it is the caller's responsibility to make sure that the

    // memory is non-pageable.

    //

    // Note: We are running at caller's priority, which may be low. In that 

    // case, the caller could have supplied us a pointer to pageable memory that

    // cannot be touched at high priority with the spin lock held. We therefore

    // copy the parameters first to a local (non-pageable) stack location.

    MemoryCopy(&ClientParams, pClientControlParameters,

        			sizeof(ClientParams));

    SpinLockAcquire(pClientListLock);

	if (QListIsItemInList(pClientList, pListItem))

	{

    	ClientListEntry *pClientEntry = (ClientListEntry*)ClientHandle;

		Fstatus = FSUCCESS;

		MemoryCopy(&(pClientEntry->ClientParameters), &ClientParams,

                	sizeof(pClientEntry->ClientParameters));

    }

    SpinLockRelease(pClientListLock);

	_DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE );

    return(Fstatus);

}