timerqueue.c File Reference

#include <rtl.h>
#include <debug.h>
#include <wine/list.h>

Include dependency graph for timerqueue.c:

Go to the source code of this file.

Classes
struct	queue_timer
struct	timer_queue

Macros
#define	NDEBUG
#define	EXPIRE_NEVER   (~(ULONGLONG) 0)
#define	TIMER_QUEUE_MAGIC   0x516d6954 /* TimQ */

Functions
NTSTATUS	RtlpInitializeTimerThread (VOID)
static PLARGE_INTEGER	get_nt_timeout (PLARGE_INTEGER pTime, ULONG timeout)
static void	queue_remove_timer (struct queue_timer *t)
static void	timer_cleanup_callback (struct queue_timer *t)
static VOID WINAPI	timer_callback_wrapper (LPVOID p)
static ULONGLONG	queue_current_time (void)
static void	queue_add_timer (struct queue_timer *t, ULONGLONG time, BOOL set_event)
static void	queue_move_timer (struct queue_timer *t, ULONGLONG time, BOOL set_event)
static void	queue_timer_expire (struct timer_queue *q)
static ULONG	queue_get_timeout (struct timer_queue *q)
static DWORD WINAPI	timer_queue_thread_proc (LPVOID p)
static void	queue_destroy_timer (struct queue_timer *t)
NTSTATUS WINAPI	RtlCreateTimerQueue (PHANDLE NewTimerQueue)
NTSTATUS WINAPI	RtlDeleteTimerQueueEx (HANDLE TimerQueue, HANDLE CompletionEvent)
static struct timer_queue *	get_timer_queue (HANDLE TimerQueue)
NTSTATUS WINAPI	RtlCreateTimer (HANDLE TimerQueue, PHANDLE NewTimer, WAITORTIMERCALLBACKFUNC Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags)
NTSTATUS WINAPI	RtlSetTimer (HANDLE TimerQueue, PHANDLE NewTimer, WAITORTIMERCALLBACKFUNC Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags)
NTSTATUS WINAPI	RtlUpdateTimer (HANDLE TimerQueue, HANDLE Timer, DWORD DueTime, DWORD Period)
NTSTATUS WINAPI	RtlDeleteTimer (HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent)
NTSTATUS NTAPI	RtlCancelTimer (HANDLE TimerQueue, HANDLE Timer)
NTSTATUS NTAPI	RtlDeleteTimerQueue (HANDLE TimerQueue)

Variables
PRTL_START_POOL_THREAD	RtlpStartThreadFunc
PRTL_EXIT_POOL_THREAD	RtlpExitThreadFunc
HANDLE	TimerThreadHandle = NULL

Macro Definition Documentation

EXPIRE_NEVER

#define EXPIRE_NEVER   (~(ULONGLONG) 0)

Definition at line 64 of file timerqueue.c.

NDEBUG

#define NDEBUG

Definition at line 13 of file timerqueue.c.

TIMER_QUEUE_MAGIC

#define TIMER_QUEUE_MAGIC   0x516d6954 /* TimQ */

Definition at line 65 of file timerqueue.c.

Function Documentation

get_nt_timeout()

static PLARGE_INTEGER get_nt_timeout ( PLARGE_INTEGER  pTime, ULONG  timeout  )

inlinestatic

Definition at line 32 of file timerqueue.c.

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

Referenced by timer_queue_thread_proc().

get_timer_queue()

static struct timer_queue * get_timer_queue ( HANDLE  TimerQueue )

static

Definition at line 375 of file timerqueue.c.

{
    static struct timer_queue *default_timer_queue;
 
    if (TimerQueue)
        return TimerQueue;
    else
    {
        if (!default_timer_queue)
        {
            HANDLE q;
            NTSTATUS status = RtlCreateTimerQueue(&q);
            if (status == STATUS_SUCCESS)
            {
                PVOID p = InterlockedCompareExchangePointer(
                    (void **) &default_timer_queue, q, NULL);
                if (p)
                    /* Got beat to the punch.  */
                    RtlDeleteTimerQueueEx(q, NULL);
            }
        }
        return default_timer_queue;
    }
}

Referenced by RtlCreateTimer().

queue_add_timer()

static void queue_add_timer ( struct queue_timer *  t, ULONGLONG  time, BOOL  set_event  )

static

Definition at line 114 of file timerqueue.c.

{
    /* We MUST hold the queue cs while calling this function.  */
    struct timer_queue *q = t->q;
    struct list *ptr = &q->timers;
 
    assert(!q->quit || (t->destroy && time == EXPIRE_NEVER));
 
    if (time != EXPIRE_NEVER)
        LIST_FOR_EACH(ptr, &q->timers)
        {
            struct queue_timer *cur = LIST_ENTRY(ptr, struct queue_timer, entry);
            if (time < cur->expire)
                break;
        }
    list_add_before(ptr, &t->entry);
 
    t->expire = time;
 
    /* If we insert at the head of the list, we need to expire sooner
       than expected.  */
    if (set_event && &t->entry == list_head(&q->timers))
        NtSetEvent(q->event, NULL);
}

Referenced by queue_move_timer(), and RtlCreateTimer().

queue_current_time()

static ULONGLONG queue_current_time ( void  )

inlinestatic

Definition at line 107 of file timerqueue.c.

{
    LARGE_INTEGER now, freq;
    NtQueryPerformanceCounter(&now, &freq);
    return now.QuadPart * 1000 / freq.QuadPart;
}

Referenced by queue_get_timeout(), queue_timer_expire(), RtlCreateTimer(), and RtlUpdateTimer().

queue_destroy_timer()

static void queue_destroy_timer ( struct queue_timer *  t )

static

Definition at line 258 of file timerqueue.c.

{
    /* We MUST hold the queue cs while calling this function.  */
    t->destroy = TRUE;
    if (t->runcount == 0)
        /* Ensure a timer is promptly removed.  If callbacks are pending,
           it will be removed after the last one finishes by the callback
           cleanup wrapper.  */
        queue_remove_timer(t);
    else
        /* Make sure no destroyed timer masks an active timer at the head
           of the sorted list.  */
        queue_move_timer(t, EXPIRE_NEVER, FALSE);
}

Referenced by RtlDeleteTimer(), and RtlDeleteTimerQueueEx().

queue_get_timeout()

static ULONG queue_get_timeout ( struct timer_queue *  q )

static

Definition at line 193 of file timerqueue.c.

{
    struct queue_timer *t;
    ULONG timeout = INFINITE;
 
    RtlEnterCriticalSection(&q->cs);
    if (list_head(&q->timers))
    {
        t = LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
        assert(!t->destroy || t->expire == EXPIRE_NEVER);
 
        if (t->expire != EXPIRE_NEVER)
        {
            ULONGLONG time = queue_current_time();
            timeout = t->expire < time ? 0 : (ULONG)(t->expire - time);
        }
    }
    RtlLeaveCriticalSection(&q->cs);
 
    return timeout;
}

Referenced by timer_queue_thread_proc().

queue_move_timer()

static void queue_move_timer ( struct queue_timer *  t, ULONGLONG  time, BOOL  set_event  )

inlinestatic

Definition at line 140 of file timerqueue.c.

{
    /* We MUST hold the queue cs while calling this function.  */
    list_remove(&t->entry);
    queue_add_timer(t, time, set_event);
}

Referenced by queue_destroy_timer(), queue_timer_expire(), and RtlUpdateTimer().

queue_remove_timer()

static void queue_remove_timer ( struct queue_timer *  t )

static

Definition at line 67 of file timerqueue.c.

{
    /* We MUST hold the queue cs while calling this function.  This ensures
       that we cannot queue another callback for this timer.  The runcount
       being zero makes sure we don't have any already queued.  */
    struct timer_queue *q = t->q;
 
    assert(t->runcount == 0);
    assert(t->destroy);
 
    list_remove(&t->entry);
    if (t->event)
        NtSetEvent(t->event, NULL);
    RtlFreeHeap(RtlGetProcessHeap(), 0, t);
 
    if (q->quit && list_empty(&q->timers))
        NtSetEvent(q->event, NULL);
}

Referenced by queue_destroy_timer(), and timer_cleanup_callback().

queue_timer_expire()

static void queue_timer_expire ( struct timer_queue *  q )

static

Definition at line 148 of file timerqueue.c.

{
    struct queue_timer *t = NULL;
 
    RtlEnterCriticalSection(&q->cs);
    if (list_head(&q->timers))
    {
        ULONGLONG now, next;
        t = LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
        if (!t->destroy && t->expire <= ((now = queue_current_time())))
        {
            ++t->runcount;
            if (t->period)
            {
                next = t->expire + t->period;
                /* avoid trigger cascade if overloaded / hibernated */
                if (next < now)
                    next = now + t->period;
            }
            else
                next = EXPIRE_NEVER;
            queue_move_timer(t, next, FALSE);
        }
        else
            t = NULL;
    }
    RtlLeaveCriticalSection(&q->cs);
 
    if (t)
    {
        if (t->flags & WT_EXECUTEINTIMERTHREAD)
            timer_callback_wrapper(t);
        else
        {
            ULONG flags
                = (t->flags
                   & (WT_EXECUTEINIOTHREAD | WT_EXECUTEINPERSISTENTTHREAD
                      | WT_EXECUTELONGFUNCTION | WT_TRANSFER_IMPERSONATION));
            NTSTATUS status = RtlQueueWorkItem(timer_callback_wrapper, t, flags);
            if (status != STATUS_SUCCESS)
                timer_cleanup_callback(t);
        }
    }
}

Referenced by timer_queue_thread_proc().

RtlCancelTimer()

NTSTATUS NTAPI RtlCancelTimer	(	HANDLE	TimerQueue,
		HANDLE	Timer
	)

Definition at line 585 of file timerqueue.c.

{
    return RtlDeleteTimer(TimerQueue, Timer, NULL);
}

RtlCreateTimer()

NTSTATUS WINAPI RtlCreateTimer	(	HANDLE	TimerQueue,
		PHANDLE	NewTimer,
		WAITORTIMERCALLBACKFUNC	Callback,
		PVOID	Parameter,
		DWORD	DueTime,
		DWORD	Period,
		ULONG	Flags
	)

Definition at line 425 of file timerqueue.c.

{
    NTSTATUS status;
    struct queue_timer *t;
    struct timer_queue *q = get_timer_queue(TimerQueue);
 
    if (!q) return STATUS_NO_MEMORY;
    if (q->magic != TIMER_QUEUE_MAGIC) return STATUS_INVALID_HANDLE;
 
    t = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof *t);
    if (!t)
        return STATUS_NO_MEMORY;
 
    t->q = q;
    t->runcount = 0;
    t->callback = Callback;
    t->param = Parameter;
    t->period = Period;
    t->flags = Flags;
    t->destroy = FALSE;
    t->event = NULL;
 
    status = STATUS_SUCCESS;
    RtlEnterCriticalSection(&q->cs);
    if (q->quit)
        status = STATUS_INVALID_HANDLE;
    else
        queue_add_timer(t, queue_current_time() + DueTime, TRUE);
    RtlLeaveCriticalSection(&q->cs);
 
    if (status == STATUS_SUCCESS)
        *NewTimer = t;
    else
        RtlFreeHeap(RtlGetProcessHeap(), 0, t);
 
    return status;
}

RtlCreateTimerQueue()

NTSTATUS WINAPI RtlCreateTimerQueue

(

PHANDLE

NewTimerQueue

)

Definition at line 285 of file timerqueue.c.

{
    NTSTATUS status;
    struct timer_queue *q = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof *q);
    if (!q)
        return STATUS_NO_MEMORY;
 
    RtlInitializeCriticalSection(&q->cs);
    list_init(&q->timers);
    q->quit = FALSE;
    q->magic = TIMER_QUEUE_MAGIC;
    status = NtCreateEvent(&q->event, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE);
    if (status != STATUS_SUCCESS)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, q);
        return status;
    }
    status = RtlpStartThreadFunc(timer_queue_thread_proc, q, &q->thread);
    if (status != STATUS_SUCCESS)
    {
        NtClose(q->event);
        RtlFreeHeap(RtlGetProcessHeap(), 0, q);
        return status;
    }
 
    NtResumeThread(q->thread, NULL);
    *NewTimerQueue = q;
    return STATUS_SUCCESS;
}

Referenced by BasepCreateDefaultTimerQueue(), CreateTimerQueue(), and get_timer_queue().

RtlDeleteTimer()

NTSTATUS WINAPI RtlDeleteTimer	(	HANDLE	TimerQueue,
		HANDLE	Timer,
		HANDLE	CompletionEvent
	)

Definition at line 540 of file timerqueue.c.

{
    struct queue_timer *t = Timer;
    struct timer_queue *q;
    NTSTATUS status = STATUS_PENDING;
    HANDLE event = NULL;
 
    if (!Timer)
        return STATUS_INVALID_PARAMETER_1;
    q = t->q;
    if (CompletionEvent == INVALID_HANDLE_VALUE)
    {
        status = NtCreateEvent(&event, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE);
        if (status == STATUS_SUCCESS)
            status = STATUS_PENDING;
    }
    else if (CompletionEvent)
        event = CompletionEvent;
 
    RtlEnterCriticalSection(&q->cs);
    t->event = event;
    if (t->runcount == 0 && event)
        status = STATUS_SUCCESS;
    queue_destroy_timer(t);
    RtlLeaveCriticalSection(&q->cs);
 
    if (CompletionEvent == INVALID_HANDLE_VALUE && event)
    {
        if (status == STATUS_PENDING)
        {
            NtWaitForSingleObject(event, FALSE, NULL);
            status = STATUS_SUCCESS;
        }
        NtClose(event);
    }
 
    return status;
}

RtlDeleteTimerQueue()

NTSTATUS NTAPI RtlDeleteTimerQueue

(

HANDLE

TimerQueue

)

Definition at line 595 of file timerqueue.c.

{
    return RtlDeleteTimerQueueEx(TimerQueue, INVALID_HANDLE_VALUE);
}

RtlDeleteTimerQueueEx()

NTSTATUS WINAPI RtlDeleteTimerQueueEx	(	HANDLE	TimerQueue,
		HANDLE	CompletionEvent
	)

Definition at line 331 of file timerqueue.c.

{
    struct timer_queue *q = TimerQueue;
    struct queue_timer *t, *temp;
    HANDLE thread;
    NTSTATUS status;
 
    if (!q || q->magic != TIMER_QUEUE_MAGIC)
        return STATUS_INVALID_HANDLE;
 
    thread = q->thread;
 
    RtlEnterCriticalSection(&q->cs);
    q->quit = TRUE;
    if (list_head(&q->timers))
        /* When the last timer is removed, it will signal the timer thread to
           exit...  */
        LIST_FOR_EACH_ENTRY_SAFE(t, temp, &q->timers, struct queue_timer, entry)
            queue_destroy_timer(t);
    else
        /* However if we have none, we must do it ourselves.  */
        NtSetEvent(q->event, NULL);
    RtlLeaveCriticalSection(&q->cs);
 
    if (CompletionEvent == INVALID_HANDLE_VALUE)
    {
        NtWaitForSingleObject(thread, FALSE, NULL);
        status = STATUS_SUCCESS;
    }
    else
    {
        if (CompletionEvent)
        {
            DPRINT1("asynchronous return on completion event unimplemented\n");
            NtWaitForSingleObject(thread, FALSE, NULL);
            NtSetEvent(CompletionEvent, NULL);
        }
        status = STATUS_PENDING;
    }
 
    NtClose(thread);
    return status;
}

RtlpInitializeTimerThread()

NTSTATUS RtlpInitializeTimerThread

(

VOID

)

Definition at line 27 of file timerqueue.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RtlpQueueWorkerThread().

RtlSetTimer()

NTSTATUS WINAPI RtlSetTimer	(	HANDLE	TimerQueue,
		PHANDLE	NewTimer,
		WAITORTIMERCALLBACKFUNC	Callback,
		PVOID	Parameter,
		DWORD	DueTime,
		DWORD	Period,
		ULONG	Flags
	)

Definition at line 468 of file timerqueue.c.

{
    return RtlCreateTimer(TimerQueue,
                          NewTimer,
                          Callback,
                          Parameter,
                          DueTime,
                          Period,
                          Flags);
}

RtlUpdateTimer()

NTSTATUS WINAPI RtlUpdateTimer	(	HANDLE	TimerQueue,
		HANDLE	Timer,
		DWORD	DueTime,
		DWORD	Period
	)

Definition at line 504 of file timerqueue.c.

{
    struct queue_timer *t = Timer;
    struct timer_queue *q = t->q;
 
    RtlEnterCriticalSection(&q->cs);
    /* Can't change a timer if it was once-only or destroyed.  */
    if (t->expire != EXPIRE_NEVER)
    {
        t->period = Period;
        queue_move_timer(t, queue_current_time() + DueTime, TRUE);
    }
    RtlLeaveCriticalSection(&q->cs);
 
    return STATUS_SUCCESS;
}

timer_callback_wrapper()

static VOID WINAPI timer_callback_wrapper ( LPVOID  p )

static

Definition at line 100 of file timerqueue.c.

{
    struct queue_timer *t = p;
    t->callback(t->param, TRUE);
    timer_cleanup_callback(t);
}

Referenced by queue_timer_expire().

timer_cleanup_callback()

static void timer_cleanup_callback ( struct queue_timer *  t )

static

Definition at line 86 of file timerqueue.c.

{
    struct timer_queue *q = t->q;
    RtlEnterCriticalSection(&q->cs);
 
    assert(0 < t->runcount);
    --t->runcount;
 
    if (t->destroy && t->runcount == 0)
        queue_remove_timer(t);
 
    RtlLeaveCriticalSection(&q->cs);
}

Referenced by queue_timer_expire(), and timer_callback_wrapper().

timer_queue_thread_proc()

static DWORD WINAPI timer_queue_thread_proc ( LPVOID  p )

static

Definition at line 215 of file timerqueue.c.

{
    struct timer_queue *q = p;
    ULONG timeout_ms;
 
    timeout_ms = INFINITE;
    for (;;)
    {
        LARGE_INTEGER timeout;
        NTSTATUS status;
        BOOL done = FALSE;
 
        status = NtWaitForSingleObject(
            q->event, FALSE, get_nt_timeout(&timeout, timeout_ms));
 
        if (status == STATUS_WAIT_0)
        {
            /* There are two possible ways to trigger the event.  Either
               we are quitting and the last timer got removed, or a new
               timer got put at the head of the list so we need to adjust
               our timeout.  */
            RtlEnterCriticalSection(&q->cs);
            if (q->quit && list_empty(&q->timers))
                done = TRUE;
            RtlLeaveCriticalSection(&q->cs);
        }
        else if (status == STATUS_TIMEOUT)
            queue_timer_expire(q);
 
        if (done)
            break;
 
        timeout_ms = queue_get_timeout(q);
    }
 
    NtClose(q->event);
    RtlDeleteCriticalSection(&q->cs);
    q->magic = 0;
    RtlFreeHeap(RtlGetProcessHeap(), 0, q);
    RtlpExitThreadFunc(STATUS_SUCCESS);
    return 0;
}

Referenced by RtlCreateTimerQueue().

Variable Documentation

RtlpExitThreadFunc

PRTL_EXIT_POOL_THREAD RtlpExitThreadFunc

extern

Definition at line 46 of file workitem.c.

Referenced by RtlpIoWorkerThreadProc(), RtlpWorkerThreadProc(), RtlSetThreadPoolStartFunc(), and timer_queue_thread_proc().

RtlpStartThreadFunc

PRTL_START_POOL_THREAD RtlpStartThreadFunc

extern

Definition at line 45 of file workitem.c.

Referenced by RtlCreateTimerQueue(), RtlpStartWorkerThread(), and RtlSetThreadPoolStartFunc().

TimerThreadHandle

HANDLE TimerThreadHandle = NULL

Definition at line 24 of file timerqueue.c.

Referenced by RtlpQueueWorkerThread().