Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601/* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS system libraries * PURPOSE: Timer Queue implementation * FILE: lib/rtl/timerqueue.c * PROGRAMMER: */
/* INCLUDES *****************************************************************/
#include <rtl.h>
#define NDEBUG#include <debug.h>
#undef LIST_FOR_EACH#undef LIST_FOR_EACH_SAFE#include <wine/list.h>
/* FUNCTIONS ***************************************************************/
extern PRTL_START_POOL_THREAD RtlpStartThreadFunc;extern PRTL_EXIT_POOL_THREAD RtlpExitThreadFunc;HANDLE TimerThreadHandle = NULL;
NTSTATUSRtlpInitializeTimerThread(VOID){ return STATUS_NOT_IMPLEMENTED;}
static inline PLARGE_INTEGER get_nt_timeout( PLARGE_INTEGER pTime, ULONG timeout ){ if (timeout == INFINITE) return NULL; pTime->QuadPart = (ULONGLONG)timeout * -10000; return pTime;}
struct timer_queue;struct queue_timer{ struct timer_queue *q; struct list entry; ULONG runcount; /* number of callbacks pending execution */ WAITORTIMERCALLBACKFUNC callback; PVOID param; DWORD period; ULONG flags; ULONGLONG expire; BOOL destroy; /* timer should be deleted; once set, never unset */ HANDLE event; /* removal event */};
struct timer_queue{ DWORD magic; RTL_CRITICAL_SECTION cs; struct list timers; /* sorted by expiration time */ BOOL quit; /* queue should be deleted; once set, never unset */ HANDLE event; HANDLE thread;};
#define EXPIRE_NEVER (~(ULONGLONG) 0)#define TIMER_QUEUE_MAGIC 0x516d6954 /* TimQ */
static void queue_remove_timer(struct queue_timer *t){ /* 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);}
static void timer_cleanup_callback(struct queue_timer *t){ 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);}
static VOID WINAPI timer_callback_wrapper(LPVOID p){ struct queue_timer *t = p; t->callback(t->param, TRUE); timer_cleanup_callback(t);}
static inline ULONGLONG queue_current_time(void){ LARGE_INTEGER now, freq; NtQueryPerformanceCounter(&now, &freq); return now.QuadPart * 1000 / freq.QuadPart;}
static void queue_add_timer(struct queue_timer *t, ULONGLONG time, BOOL set_event){ /* 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);}
static inline void queue_move_timer(struct queue_timer *t, ULONGLONG time, BOOL set_event){ /* We MUST hold the queue cs while calling this function. */ list_remove(&t->entry); queue_add_timer(t, time, set_event);}
static void queue_timer_expire(struct timer_queue *q){ 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); } }}
static ULONG queue_get_timeout(struct timer_queue *q){ 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;}
static DWORD WINAPI timer_queue_thread_proc(LPVOID p){ 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;}
static void queue_destroy_timer(struct queue_timer *t){ /* 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);}
/*********************************************************************** * RtlCreateTimerQueue (NTDLL.@) * * Creates a timer queue object and returns a handle to it. * * PARAMS * NewTimerQueue [O] The newly created queue. * * RETURNS * Success: STATUS_SUCCESS. * Failure: Any NTSTATUS code. */NTSTATUS WINAPI RtlCreateTimerQueue(PHANDLE NewTimerQueue){ 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;}
/*********************************************************************** * RtlDeleteTimerQueueEx (NTDLL.@) * * Deletes a timer queue object. * * PARAMS * TimerQueue [I] The timer queue to destroy. * CompletionEvent [I] If NULL, return immediately. If INVALID_HANDLE_VALUE, * wait until all timers are finished firing before * returning. Otherwise, return immediately and set the * event when all timers are done. * * RETURNS * Success: STATUS_SUCCESS if synchronous, STATUS_PENDING if not. * Failure: Any NTSTATUS code. */NTSTATUS WINAPI RtlDeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent){ 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;}
static struct timer_queue *get_timer_queue(HANDLE TimerQueue){ 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; }}
/*********************************************************************** * RtlCreateTimer (NTDLL.@) * * Creates a new timer associated with the given queue. * * PARAMS * NewTimer [O] The newly created timer. * TimerQueue [I] The queue to hold the timer. * Callback [I] The callback to fire. * Parameter [I] The argument for the callback. * DueTime [I] The delay, in milliseconds, before first firing the * timer. * Period [I] The period, in milliseconds, at which to fire the timer * after the first callback. If zero, the timer will only * fire once. It still needs to be deleted with * RtlDeleteTimer. * Flags [I] Flags controlling the execution of the callback. In * addition to the WT_* thread pool flags (see * RtlQueueWorkItem), WT_EXECUTEINTIMERTHREAD and * WT_EXECUTEONLYONCE are supported. * * RETURNS * Success: STATUS_SUCCESS. * Failure: Any NTSTATUS code. */NTSTATUS WINAPI RtlCreateTimer(HANDLE TimerQueue, PHANDLE NewTimer, WAITORTIMERCALLBACKFUNC Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags){ 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;}
NTSTATUSWINAPIRtlSetTimer( HANDLE TimerQueue, PHANDLE NewTimer, WAITORTIMERCALLBACKFUNC Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags){ return RtlCreateTimer(TimerQueue, NewTimer, Callback, Parameter, DueTime, Period, Flags);}
/*********************************************************************** * RtlUpdateTimer (NTDLL.@) * * Changes the time at which a timer expires. * * PARAMS * TimerQueue [I] The queue that holds the timer. * Timer [I] The timer to update. * DueTime [I] The delay, in milliseconds, before next firing the timer. * Period [I] The period, in milliseconds, at which to fire the timer * after the first callback. If zero, the timer will not * refire once. It still needs to be deleted with * RtlDeleteTimer. * * RETURNS * Success: STATUS_SUCCESS. * Failure: Any NTSTATUS code. */NTSTATUS WINAPI RtlUpdateTimer(HANDLE TimerQueue, HANDLE Timer, DWORD DueTime, DWORD Period){ 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;}
/*********************************************************************** * RtlDeleteTimer (NTDLL.@) * * Cancels a timer-queue timer. * * PARAMS * TimerQueue [I] The queue that holds the timer. * Timer [I] The timer to update. * CompletionEvent [I] If NULL, return immediately. If INVALID_HANDLE_VALUE, * wait until the timer is finished firing all pending * callbacks before returning. Otherwise, return * immediately and set the timer is done. * * RETURNS * Success: STATUS_SUCCESS if the timer is done, STATUS_PENDING if not, or if the completion event is NULL. * Failure: Any NTSTATUS code. */NTSTATUS WINAPI RtlDeleteTimer(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent){ 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;}
/* * @implemented */NTSTATUSNTAPIRtlCancelTimer(HANDLE TimerQueue, HANDLE Timer){ return RtlDeleteTimer(TimerQueue, Timer, NULL);}
/* * @implemented */NTSTATUSNTAPIRtlDeleteTimerQueue(HANDLE TimerQueue){ return RtlDeleteTimerQueueEx(TimerQueue, INVALID_HANDLE_VALUE);}
/* EOF */