wait.c File Reference

#include "srv.h"
#include <debug.h>

Include dependency graph for wait.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	CsrInitializeWait (IN CSR_WAIT_FUNCTION WaitFunction, IN PCSR_THREAD CsrWaitThread, IN OUT PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext, OUT PCSR_WAIT_BLOCK *NewWaitBlock)
BOOLEAN NTAPI	CsrNotifyWaitBlock (IN PCSR_WAIT_BLOCK WaitBlock, IN PLIST_ENTRY WaitList, IN PVOID WaitArgument1, IN PVOID WaitArgument2, IN ULONG WaitFlags, IN BOOLEAN DereferenceThread)
BOOLEAN NTAPI	CsrCreateWait (IN PLIST_ENTRY WaitList, IN CSR_WAIT_FUNCTION WaitFunction, IN PCSR_THREAD CsrWaitThread, IN OUT PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext)
VOID NTAPI	CsrDereferenceWait (IN PLIST_ENTRY WaitList)
VOID NTAPI	CsrMoveSatisfiedWait (IN PLIST_ENTRY DestinationList, IN PLIST_ENTRY WaitList)
BOOLEAN NTAPI	CsrNotifyWait (IN PLIST_ENTRY WaitList, IN BOOLEAN NotifyAll, IN PVOID WaitArgument1, IN PVOID WaitArgument2)

Variables
RTL_CRITICAL_SECTION	CsrWaitListsLock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file wait.c.

Function Documentation

CsrCreateWait()

BOOLEAN NTAPI CsrCreateWait	(	IN PLIST_ENTRY	WaitList,
		IN CSR_WAIT_FUNCTION	WaitFunction,
		IN PCSR_THREAD	CsrWaitThread,
		IN OUT PCSR_API_MESSAGE	WaitApiMessage,
		IN PVOID	WaitContext
	)

Definition at line 209 of file wait.c.

{
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Initialize the wait */
    if (!CsrInitializeWait(WaitFunction,
                           CsrWaitThread,
                           WaitApiMessage,
                           WaitContext,
                           &WaitBlock))
    {
        return FALSE;
    }
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Make sure the thread wasn't destroyed */
    if (CsrWaitThread->Flags & CsrThreadTerminated)
    {
        /* Fail the wait */
        RtlFreeHeap(CsrHeap, 0, WaitBlock);
        CsrReleaseWaitLock();
        return FALSE;
    }
 
    /* Associate the newly created wait to the waiting thread */
    CsrWaitThread->WaitBlock = WaitBlock;
 
    /* Insert the wait in the queue */
    InsertTailList(WaitList, &WaitBlock->WaitList);
 
    /* Return */
    CsrReleaseWaitLock();
    return TRUE;
}

Referenced by DoWriteConsole(), and WaitBeforeReading().

CsrDereferenceWait()

VOID NTAPI CsrDereferenceWait

(

IN PLIST_ENTRY

WaitList

)

Definition at line 266 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Acquire the Process and Wait Locks */
    CsrAcquireProcessLock();
    CsrAcquireWaitLock();
 
    /* Set the list pointers */
    NextEntry = WaitList->Flink;
 
    /* Start the loop */
    while (NextEntry != WaitList)
    {
        /* Get the wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there's no Wait Routine (satisfied wait) */
        if (WaitBlock->WaitFunction == NULL)
        {
            /* Remove it from the Wait List */
            if (WaitBlock->WaitList.Flink)
            {
                RemoveEntryList(&WaitBlock->WaitList);
            }
 
            /* Dereference the thread waiting on it */
            CsrDereferenceThread(WaitBlock->WaitThread);
 
            /* Free the block */
            RtlFreeHeap(CsrHeap, 0, WaitBlock);
        }
    }
 
    /* Release the locks */
    CsrReleaseWaitLock();
    CsrReleaseProcessLock();
}

Referenced by ConioUnpause(), ConSrvCloseHandle(), and PostprocessInput().

CsrInitializeWait()

BOOLEAN NTAPI CsrInitializeWait	(	IN CSR_WAIT_FUNCTION	WaitFunction,
		IN PCSR_THREAD	CsrWaitThread,
		IN OUT PCSR_API_MESSAGE	WaitApiMessage,
		IN PVOID	WaitContext,
		OUT PCSR_WAIT_BLOCK *	NewWaitBlock
	)

Definition at line 50 of file wait.c.

{
    ULONG Size;
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Calculate the size of the wait block */
    Size = sizeof(CSR_WAIT_BLOCK) -
           sizeof(WaitBlock->WaitApiMessage) +
           WaitApiMessage->Header.u1.s1.TotalLength;
 
    /* Allocate the Wait Block */
    WaitBlock = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, Size);
    if (!WaitBlock)
    {
        /* Fail */
        WaitApiMessage->Status = STATUS_NO_MEMORY;
        return FALSE;
    }
 
    /* Initialize it */
    WaitBlock->Size           = Size;
    WaitBlock->WaitThread     = CsrWaitThread;
    WaitBlock->WaitContext    = WaitContext;
    WaitBlock->WaitFunction   = WaitFunction;
    WaitBlock->WaitList.Flink = NULL;
    WaitBlock->WaitList.Blink = NULL;
 
    /* Copy the message */
    RtlCopyMemory(&WaitBlock->WaitApiMessage,
                  WaitApiMessage,
                  WaitApiMessage->Header.u1.s1.TotalLength);
 
    /* Return the block */
    *NewWaitBlock = WaitBlock;
    return TRUE;
}

Referenced by CsrCreateWait().

CsrMoveSatisfiedWait()

VOID NTAPI CsrMoveSatisfiedWait	(	IN PLIST_ENTRY	DestinationList,
		IN PLIST_ENTRY	WaitList
	)

Definition at line 330 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Set the List pointers */
    NextEntry = WaitList->Flink;
 
    /* Start looping */
    while (NextEntry != WaitList)
    {
        /* Get the Wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there's no Wait Routine (satisfied wait) */
        if (WaitBlock->WaitFunction == NULL)
        {
            /* Remove it from the Wait Block Queue */
            RemoveEntryList(&WaitBlock->WaitList);
 
            /* Insert the wait into the destination list */
            InsertTailList(DestinationList, &WaitBlock->WaitList);
        }
    }
 
    /* Release the wait lock */
    CsrReleaseWaitLock();
}

CsrNotifyWait()

BOOLEAN NTAPI CsrNotifyWait	(	IN PLIST_ENTRY	WaitList,
		IN BOOLEAN	NotifyAll,
		IN PVOID	WaitArgument1,
		IN PVOID	WaitArgument2
	)

Definition at line 388 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
    BOOLEAN NotifySuccess = FALSE;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Set the List pointers */
    NextEntry = WaitList->Flink;
 
    /* Start looping */
    while (NextEntry != WaitList)
    {
        /* Get the Wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there is a Wait Routine */
        if (WaitBlock->WaitFunction != NULL)
        {
            /* Notify the Waiter */
            NotifySuccess |= CsrNotifyWaitBlock(WaitBlock,
                                                WaitList,
                                                WaitArgument1,
                                                WaitArgument2,
                                                0,
                                                FALSE);
 
            /*
             * We've already done a wait, so leave unless
             * we want to notify all the waits...
             */
            if (!NotifyAll) break;
        }
    }
 
    /* Release the wait lock and return */
    CsrReleaseWaitLock();
    return NotifySuccess;
}

Referenced by ConioUnpause(), ConSrvCloseHandle(), and PostprocessInput().

CsrNotifyWaitBlock()

BOOLEAN NTAPI CsrNotifyWaitBlock	(	IN PCSR_WAIT_BLOCK	WaitBlock,
		IN PLIST_ENTRY	WaitList,
		IN PVOID	WaitArgument1,
		IN PVOID	WaitArgument2,
		IN ULONG	WaitFlags,
		IN BOOLEAN	DereferenceThread
	)

Definition at line 120 of file wait.c.

{
    /* Call the wait function */
    if (WaitBlock->WaitFunction(WaitList,
                                WaitBlock->WaitThread,
                                &WaitBlock->WaitApiMessage,
                                WaitBlock->WaitContext,
                                WaitArgument1,
                                WaitArgument2,
                                WaitFlags))
    {
        /* The wait is done, clear the block */
        WaitBlock->WaitThread->WaitBlock = NULL;
 
        /* Check for captured arguments */
        if (WaitBlock->WaitApiMessage.CsrCaptureData)
        {
            /* Release them */
            CsrReleaseCapturedArguments(&WaitBlock->WaitApiMessage);
        }
 
        /* Reply to the port */
        NtReplyPort(WaitBlock->WaitThread->Process->ClientPort,
                    &WaitBlock->WaitApiMessage.Header);
 
        /* Check if we should dereference the thread */
        if (DereferenceThread)
        {
            /* Remove it from the Wait List */
            if (WaitBlock->WaitList.Flink)
            {
                RemoveEntryList(&WaitBlock->WaitList);
            }
 
            /* Dereference the thread */
            CsrDereferenceThread(WaitBlock->WaitThread);
 
            /* Free the wait block */
            RtlFreeHeap(CsrHeap, 0, WaitBlock);
        }
        else
        {
            /* The wait is complete, but the thread is being kept alive */
            WaitBlock->WaitFunction = NULL;
        }
 
        /* The wait succeeded */
        return TRUE;
    }
 
    /* The wait failed */
    return FALSE;
}

Referenced by CsrDestroyProcess(), CsrDestroyThread(), and CsrNotifyWait().

Variable Documentation

CsrWaitListsLock

RTL_CRITICAL_SECTION CsrWaitListsLock

Definition at line 19 of file wait.c.