wait.c File Reference

#include <rtl.h>
#include <debug.h>

Include dependency graph for wait.c:

Go to the source code of this file.

Classes
struct	_RTLP_WAIT

Macros
#define	NDEBUG

Typedefs
typedef struct _RTLP_WAIT	RTLP_WAIT
typedef struct _RTLP_WAIT *	PRTLP_WAIT

Functions
static PLARGE_INTEGER	get_nt_timeout (PLARGE_INTEGER pTime, ULONG timeout)
static VOID NTAPI	Wait_thread_proc (LPVOID Arg)
NTSTATUS NTAPI	RtlRegisterWait (PHANDLE NewWaitObject, HANDLE Object, WAITORTIMERCALLBACKFUNC Callback, PVOID Context, ULONG Milliseconds, ULONG Flags)
NTSTATUS NTAPI	RtlDeregisterWaitEx (HANDLE WaitHandle, HANDLE CompletionEvent)
NTSTATUS NTAPI	RtlDeregisterWait (HANDLE WaitHandle)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 16 of file wait.c.

Typedef Documentation

PRTLP_WAIT

typedef struct _RTLP_WAIT * PRTLP_WAIT

RTLP_WAIT

typedef struct _RTLP_WAIT RTLP_WAIT

Function Documentation

get_nt_timeout()

static PLARGE_INTEGER get_nt_timeout ( PLARGE_INTEGER  pTime, ULONG  timeout  )

inlinestatic

Definition at line 34 of file wait.c.

{
    if (timeout == INFINITE) return NULL;
    pTime->QuadPart = (ULONGLONG)timeout * -10000;
    return pTime;
}

Referenced by Wait_thread_proc().

RtlDeregisterWait()

NTSTATUS NTAPI RtlDeregisterWait

(

HANDLE

WaitHandle

)

Definition at line 270 of file wait.c.

{
    return RtlDeregisterWaitEx(WaitHandle, NULL);
}

RtlDeregisterWaitEx()

NTSTATUS NTAPI RtlDeregisterWaitEx	(	HANDLE	WaitHandle,
		HANDLE	CompletionEvent
	)

Definition at line 202 of file wait.c.

{
    PRTLP_WAIT Wait = (PRTLP_WAIT) WaitHandle;
    NTSTATUS Status = STATUS_SUCCESS;
 
    //TRACE( "(%p)\n", WaitHandle );
 
    NtSetEvent( Wait->CancelEvent, NULL );
    if (Wait->CallbackInProgress)
    {
        if (CompletionEvent != NULL)
        {
            if (CompletionEvent == INVALID_HANDLE_VALUE)
            {
                Status = NtCreateEvent( &CompletionEvent,
                                         EVENT_ALL_ACCESS,
                                         NULL,
                                         NotificationEvent,
                                         FALSE );
 
                if (Status != STATUS_SUCCESS)
                    return Status;
 
                (void)InterlockedExchangePointer( &Wait->CompletionEvent, CompletionEvent );
 
                if (Wait->CallbackInProgress)
                    NtWaitForSingleObject( CompletionEvent, FALSE, NULL );
 
                NtClose( CompletionEvent );
            }
            else
            {
                (void)InterlockedExchangePointer( &Wait->CompletionEvent, CompletionEvent );
 
                if (Wait->CallbackInProgress)
                    Status = STATUS_PENDING;
            }
        }
        else
            Status = STATUS_PENDING;
    }
 
    if (InterlockedIncrement( &Wait->DeleteCount ) == 2 )
    {
        Status = STATUS_SUCCESS;
        NtClose( Wait->CancelEvent );
        RtlFreeHeap( RtlGetProcessHeap(), 0, Wait );
    }
 
    return Status;
}

Referenced by RtlDeregisterWait().

RtlRegisterWait()

NTSTATUS NTAPI RtlRegisterWait	(	PHANDLE	NewWaitObject,
		HANDLE	Object,
		WAITORTIMERCALLBACKFUNC	Callback,
		PVOID	Context,
		ULONG	Milliseconds,
		ULONG	Flags
	)

Definition at line 132 of file wait.c.

{
    PRTLP_WAIT Wait;
    NTSTATUS Status;
 
    //TRACE( "(%p, %p, %p, %p, %d, 0x%x)\n", NewWaitObject, Object, Callback, Context, Milliseconds, Flags );
 
    Wait = RtlAllocateHeap( RtlGetProcessHeap(), 0, sizeof(RTLP_WAIT) );
    if (!Wait)
        return STATUS_NO_MEMORY;
 
    Wait->Object = Object;
    Wait->Callback = Callback;
    Wait->Context = Context;
    Wait->Milliseconds = Milliseconds;
    Wait->Flags = Flags;
    Wait->CallbackInProgress = FALSE;
    Wait->DeleteCount = 0;
    Wait->CompletionEvent = NULL;
 
    Status = NtCreateEvent( &Wait->CancelEvent,
                             EVENT_ALL_ACCESS,
                             NULL,
                             NotificationEvent,
                             FALSE );
 
    if (Status != STATUS_SUCCESS)
    {
        RtlFreeHeap( RtlGetProcessHeap(), 0, Wait );
        return Status;
    }
 
    Flags = Flags & (WT_EXECUTEINIOTHREAD | WT_EXECUTEINPERSISTENTTHREAD |
                     WT_EXECUTELONGFUNCTION | WT_TRANSFER_IMPERSONATION);
 
    Status = RtlQueueWorkItem( Wait_thread_proc,
                               Wait,
                               Flags );
 
    if (Status != STATUS_SUCCESS)
    {
        NtClose( Wait->CancelEvent );
        RtlFreeHeap( RtlGetProcessHeap(), 0, Wait );
        return Status;
    }
 
    *NewWaitObject = Wait;
    return Status;
}

Wait_thread_proc()

static VOID NTAPI Wait_thread_proc ( LPVOID  Arg )

static

Definition at line 43 of file wait.c.

{
    PRTLP_WAIT Wait = (PRTLP_WAIT) Arg;
    NTSTATUS Status;
    BOOLEAN alertable = (Wait->Flags & WT_EXECUTEINIOTHREAD) != 0;
    HANDLE handles[2] = { Wait->CancelEvent, Wait->Object };
    LARGE_INTEGER timeout;
    HANDLE completion_event;
 
//    TRACE("\n");
 
    while (TRUE)
    {
        Status = NtWaitForMultipleObjects( 2,
                                           handles,
                                           WaitAny,
                                           alertable,
                                           get_nt_timeout( &timeout, Wait->Milliseconds ) );
 
        if (Status == STATUS_WAIT_1 || Status == STATUS_TIMEOUT)
        {
            BOOLEAN TimerOrWaitFired;
 
            if (Status == STATUS_WAIT_1)
            {
   //             TRACE( "object %p signaled, calling callback %p with context %p\n",
   //                 Wait->Object, Wait->Callback,
   //                 Wait->Context );
                TimerOrWaitFired = FALSE;
            }
            else
            {
    //            TRACE( "wait for object %p timed out, calling callback %p with context %p\n",
    //                Wait->Object, Wait->Callback,
    //                Wait->Context );
                TimerOrWaitFired = TRUE;
            }
            Wait->CallbackInProgress = TRUE;
            Wait->Callback( Wait->Context, TimerOrWaitFired );
            Wait->CallbackInProgress = FALSE;
 
            if (Wait->Flags & WT_EXECUTEONLYONCE)
                break;
        }
        else if (Status != STATUS_USER_APC)
            break;
    }
 
    completion_event = Wait->CompletionEvent;
    if (completion_event) NtSetEvent( completion_event, NULL );
 
    if (InterlockedIncrement( &Wait->DeleteCount ) == 2 )
    {
       NtClose( Wait->CancelEvent );
       RtlFreeHeap( RtlGetProcessHeap(), 0, Wait );
    }
}

Referenced by RtlRegisterWait().