DWORD InterfaceUtils::CleanUP() {
// This example assumes that the SLIST_ENTRY structure is the
// first member of the structure. If your structure does not
// follow this convention, you must compute the starting address
// of the structure before calling the free function.
while (true) {
pListEntry = InterlockedPopEntrySList(pListHead);
if (NULL == pListEntry)
{
printf("List is empty.\n");
break;
}
pProgramItem = (PPROGRAM_ITEM)pListEntry;
InterfaceDeleteIPAddress(pProgramItem->NTEContext);
_aligned_free(pListEntry);
}
pListEntry = InterlockedFlushSList(pListHead);
pFirstEntry = InterlockedPopEntrySList(pListHead);
if (pFirstEntry != NULL) {
printf("Error: List is not empty.\n");
return -1;
}
_aligned_free(pListHead);
return NO_ERROR;
}
static unsigned __stdcall
winmm_buffer_thread(void * user_ptr)
{
cubeb * ctx = (cubeb *) user_ptr;
XASSERT(ctx);
for (;;) {
DWORD r;
PSLIST_ENTRY item;
r = WaitForSingleObject(ctx->event, INFINITE);
XASSERT(r == WAIT_OBJECT_0);
/* Process work items in batches so that a single stream can't
starve the others by continuously adding new work to the top of
the work item stack. */
item = InterlockedFlushSList(ctx->work);
while (item != NULL) {
PSLIST_ENTRY tmp = item;
winmm_refill_stream(((struct cubeb_stream_item *) tmp)->stream);
item = item->Next;
_aligned_free(tmp);
}
if (ctx->shutdown) {
break;
}
}
return 0;
}
void freerdp_channels_free(rdpChannels* channels)
{
rdpChannelsList* list;
rdpChannelsList* prev;
InterlockedFlushSList(channels->pSyncDataList);
_aligned_free(channels->pSyncDataList);
CloseHandle(channels->event_sem);
CloseHandle(channels->signal);
/* Remove from global list */
WaitForSingleObject(g_mutex_list, INFINITE);
for (prev = NULL, list = g_channels_list; list; prev = list, list = list->next)
{
if (list->channels == channels)
break;
}
if (list)
{
if (prev)
prev->next = list->next;
else
g_channels_list = list->next;
free(list);
}
ReleaseMutex(g_mutex_list);
free(channels);
}
/// <summary>
/// Returns all items on the UMS completion list. Note that this indirectly manipulates the transfer list. This
/// will literally dequeue everything from BOTH lists and hand it to the caller.
/// </summary>
/// <returns>
/// The first UMSThreadProxy on the completion list.
/// </returns>
UMSThreadProxy *UMSSchedulerProxy::GetCompletionListItems()
{
SweepCompletionList();
InterlockedExchange(&m_pushedBackCount, 0);
//
// Yep, there's a race where we could inadvertently set the event for an item which is pushed in this window from another thread
// but popped right here. The worst thing that comes out of said race is an extra awakening of a virtual processor to check
// an empty completion list.
//
PSLIST_ENTRY pItem = InterlockedFlushSList(&m_transferList);
UMSThreadProxy *pProxy = pItem == NULL ? NULL : CONTAINING_RECORD(pItem, UMSThreadProxy, m_listEntry);
#if defined(_DEBUG)
UMSThreadProxy *pTrav = pProxy;
while (pTrav != NULL)
{
pTrav->m_UMSDebugBits |= UMS_DEBUGBIT_PULLEDFROMTRANSFERLIST;
pTrav = static_cast<UMSThreadProxy *>(pTrav->GetNextUnblockNotification());
}
#endif // _DEBUG
return pProxy;
}
// ******************************************************************
// * 0x0038 - InterlockedFlushSList()
// ******************************************************************
// Source:ReactOS
// Dxbx Note : The Xbox1 SINGLE_LIST strucures are the same as in WinNT
XBSYSAPI EXPORTNUM(56) xboxkrnl::PSINGLE_LIST_ENTRY FASTCALL xboxkrnl::KRNL(InterlockedFlushSList)
(
IN xboxkrnl::PSLIST_HEADER ListHead
)
{
LOG_FUNC_ONE_ARG(ListHead);
PSINGLE_LIST_ENTRY res = (PSINGLE_LIST_ENTRY)InterlockedFlushSList((::PSLIST_HEADER)ListHead);
RETURN(res);
}
VOID CALLBACK
HttpListenerFlushLookasideThreadProc(
__in PVOID lpParameter,
__in BOOLEAN TimerOrWaitFired
)
{
PHTTP_LISTENER listener = (PHTTP_LISTENER)lpParameter;
ULONG Index;
PSLIST_ENTRY List;
PSLIST_ENTRY NextEntry;
// TODO: Queue on timer
printf("Freeing context\n");
for (Index = 0; Index < MAX_IO_CONTEXT_PROCESSOR_CACHE; Index++)
{
List = InterlockedFlushSList(&IoContextCacheList[Index].Header);
while (List != NULL)
{
NextEntry = List->Next;
FREE_MEM(CONTAINING_RECORD(List, HTTP_IO_CONTEXT, LookAsideEntry));
List = NextEntry;
}
}
}
int TestInterlockedSList(int argc, char* argv[])
{
ULONG Count;
WINPR_PSLIST_ENTRY pFirstEntry;
WINPR_PSLIST_ENTRY pListEntry;
WINPR_PSLIST_HEADER pListHead;
PPROGRAM_ITEM pProgramItem;
/* Initialize the list header to a MEMORY_ALLOCATION_ALIGNMENT boundary. */
pListHead = (WINPR_PSLIST_HEADER) _aligned_malloc(sizeof(WINPR_SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT);
if (!pListHead)
{
printf("Memory allocation failed.\n");
return -1;
}
InitializeSListHead(pListHead);
/* Insert 10 items into the list. */
for (Count = 1; Count <= 10; Count += 1)
{
pProgramItem = (PPROGRAM_ITEM) _aligned_malloc(sizeof(PROGRAM_ITEM), MEMORY_ALLOCATION_ALIGNMENT);
if (!pProgramItem)
{
printf("Memory allocation failed.\n");
return -1;
}
pProgramItem->Signature = Count;
pFirstEntry = InterlockedPushEntrySList(pListHead, &(pProgramItem->ItemEntry));
}
/* Remove 10 items from the list and display the signature. */
for (Count = 10; Count >= 1; Count -= 1)
{
pListEntry = InterlockedPopEntrySList(pListHead);
if (!pListEntry)
{
printf("List is empty.\n");
return -1;
}
pProgramItem = (PPROGRAM_ITEM) pListEntry;
printf("Signature is %d\n", (int) pProgramItem->Signature);
/*
* This example assumes that the SLIST_ENTRY structure is the
* first member of the structure. If your structure does not
* follow this convention, you must compute the starting address
* of the structure before calling the free function.
*/
_aligned_free(pListEntry);
}
/* Flush the list and verify that the items are gone. */
pListEntry = InterlockedFlushSList(pListHead);
pFirstEntry = InterlockedPopEntrySList(pListHead);
if (pFirstEntry)
{
printf("Error: List is not empty.\n");
return -1;
}
_aligned_free(pListHead);
return 0;
}
SListEntry* SListImpl::flush()
{
return reinterpret_cast<SListEntry*>(InterlockedFlushSList(getDetail(this)));
}
~SNIMemRegion()
{
InterlockedFlushSList(&m_SListHeader);
}
