mirror of
https://github.com/reactos/wine.git
synced 2024-12-05 02:07:16 +00:00
1036 lines
31 KiB
C
1036 lines
31 KiB
C
/*
|
|
* Thread pooling
|
|
*
|
|
* Copyright (c) 2006 Robert Shearman
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdarg.h>
|
|
#include <limits.h>
|
|
|
|
#define NONAMELESSUNION
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "winternl.h"
|
|
|
|
#include "wine/debug.h"
|
|
#include "wine/list.h"
|
|
|
|
#include "ntdll_misc.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(threadpool);
|
|
|
|
#define WORKER_TIMEOUT 30000 /* 30 seconds */
|
|
|
|
static LONG num_workers;
|
|
static LONG num_work_items;
|
|
static LONG num_busy_workers;
|
|
|
|
static struct list work_item_list = LIST_INIT(work_item_list);
|
|
static HANDLE work_item_event;
|
|
|
|
static RTL_CRITICAL_SECTION threadpool_cs;
|
|
static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
|
|
{
|
|
0, 0, &threadpool_cs,
|
|
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
|
|
0, 0, { (DWORD_PTR)(__FILE__ ": threadpool_cs") }
|
|
};
|
|
static RTL_CRITICAL_SECTION threadpool_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
|
|
|
|
static HANDLE compl_port = NULL;
|
|
static RTL_CRITICAL_SECTION threadpool_compl_cs;
|
|
static RTL_CRITICAL_SECTION_DEBUG critsect_compl_debug =
|
|
{
|
|
0, 0, &threadpool_compl_cs,
|
|
{ &critsect_compl_debug.ProcessLocksList, &critsect_compl_debug.ProcessLocksList },
|
|
0, 0, { (DWORD_PTR)(__FILE__ ": threadpool_compl_cs") }
|
|
};
|
|
static RTL_CRITICAL_SECTION threadpool_compl_cs = { &critsect_compl_debug, -1, 0, 0, 0, 0 };
|
|
|
|
struct work_item
|
|
{
|
|
struct list entry;
|
|
PRTL_WORK_ITEM_ROUTINE function;
|
|
PVOID context;
|
|
};
|
|
|
|
static inline LONG interlocked_inc( PLONG dest )
|
|
{
|
|
return interlocked_xchg_add( dest, 1 ) + 1;
|
|
}
|
|
|
|
static inline LONG interlocked_dec( PLONG dest )
|
|
{
|
|
return interlocked_xchg_add( dest, -1 ) - 1;
|
|
}
|
|
|
|
static void WINAPI worker_thread_proc(void * param)
|
|
{
|
|
interlocked_inc(&num_workers);
|
|
|
|
/* free the work item memory sooner to reduce memory usage */
|
|
while (TRUE)
|
|
{
|
|
if (num_work_items > 0)
|
|
{
|
|
struct list *item;
|
|
RtlEnterCriticalSection(&threadpool_cs);
|
|
item = list_head(&work_item_list);
|
|
if (item)
|
|
{
|
|
struct work_item *work_item_ptr = LIST_ENTRY(item, struct work_item, entry);
|
|
struct work_item work_item;
|
|
list_remove(&work_item_ptr->entry);
|
|
interlocked_dec(&num_work_items);
|
|
|
|
RtlLeaveCriticalSection(&threadpool_cs);
|
|
|
|
work_item = *work_item_ptr;
|
|
RtlFreeHeap(GetProcessHeap(), 0, work_item_ptr);
|
|
|
|
TRACE("executing %p(%p)\n", work_item.function, work_item.context);
|
|
|
|
interlocked_inc(&num_busy_workers);
|
|
|
|
/* do the work */
|
|
work_item.function(work_item.context);
|
|
|
|
interlocked_dec(&num_busy_workers);
|
|
}
|
|
else
|
|
RtlLeaveCriticalSection(&threadpool_cs);
|
|
}
|
|
else
|
|
{
|
|
NTSTATUS status;
|
|
LARGE_INTEGER timeout;
|
|
timeout.QuadPart = -(WORKER_TIMEOUT * (ULONGLONG)10000);
|
|
status = NtWaitForSingleObject(work_item_event, FALSE, &timeout);
|
|
if (status != STATUS_WAIT_0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
interlocked_dec(&num_workers);
|
|
|
|
RtlExitUserThread(0);
|
|
|
|
/* never reached */
|
|
}
|
|
|
|
static NTSTATUS add_work_item_to_queue(struct work_item *work_item)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
RtlEnterCriticalSection(&threadpool_cs);
|
|
list_add_tail(&work_item_list, &work_item->entry);
|
|
num_work_items++;
|
|
RtlLeaveCriticalSection(&threadpool_cs);
|
|
|
|
if (!work_item_event)
|
|
{
|
|
HANDLE sem;
|
|
status = NtCreateSemaphore(&sem, SEMAPHORE_ALL_ACCESS, NULL, 1, INT_MAX);
|
|
if (interlocked_cmpxchg_ptr( &work_item_event, sem, 0 ))
|
|
NtClose(sem); /* somebody beat us to it */
|
|
}
|
|
else
|
|
status = NtReleaseSemaphore(work_item_event, 1, NULL);
|
|
|
|
return status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* RtlQueueWorkItem (NTDLL.@)
|
|
*
|
|
* Queues a work item into a thread in the thread pool.
|
|
*
|
|
* PARAMS
|
|
* Function [I] Work function to execute.
|
|
* Context [I] Context to pass to the work function when it is executed.
|
|
* Flags [I] Flags. See notes.
|
|
*
|
|
* RETURNS
|
|
* Success: STATUS_SUCCESS.
|
|
* Failure: Any NTSTATUS code.
|
|
*
|
|
* NOTES
|
|
* Flags can be one or more of the following:
|
|
*|WT_EXECUTEDEFAULT - Executes the work item in a non-I/O worker thread.
|
|
*|WT_EXECUTEINIOTHREAD - Executes the work item in an I/O worker thread.
|
|
*|WT_EXECUTEINPERSISTENTTHREAD - Executes the work item in a thread that is persistent.
|
|
*|WT_EXECUTELONGFUNCTION - Hints that the execution can take a long time.
|
|
*|WT_TRANSFER_IMPERSONATION - Executes the function with the current access token.
|
|
*/
|
|
NTSTATUS WINAPI RtlQueueWorkItem(PRTL_WORK_ITEM_ROUTINE Function, PVOID Context, ULONG Flags)
|
|
{
|
|
HANDLE thread;
|
|
NTSTATUS status;
|
|
struct work_item *work_item = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(struct work_item));
|
|
|
|
if (!work_item)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
work_item->function = Function;
|
|
work_item->context = Context;
|
|
|
|
if (Flags & ~WT_EXECUTELONGFUNCTION)
|
|
FIXME("Flags 0x%x not supported\n", Flags);
|
|
|
|
status = add_work_item_to_queue(work_item);
|
|
|
|
/* FIXME: tune this algorithm to not be as aggressive with creating threads
|
|
* if WT_EXECUTELONGFUNCTION isn't specified */
|
|
if ((status == STATUS_SUCCESS) &&
|
|
((num_workers == 0) || (num_workers == num_busy_workers)))
|
|
{
|
|
status = RtlCreateUserThread( GetCurrentProcess(), NULL, FALSE,
|
|
NULL, 0, 0,
|
|
worker_thread_proc, NULL, &thread, NULL );
|
|
if (status == STATUS_SUCCESS)
|
|
NtClose( thread );
|
|
|
|
/* NOTE: we don't care if we couldn't create the thread if there is at
|
|
* least one other available to process the request */
|
|
if ((num_workers > 0) && (status != STATUS_SUCCESS))
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
RtlEnterCriticalSection(&threadpool_cs);
|
|
|
|
interlocked_dec(&num_work_items);
|
|
list_remove(&work_item->entry);
|
|
RtlFreeHeap(GetProcessHeap(), 0, work_item);
|
|
|
|
RtlLeaveCriticalSection(&threadpool_cs);
|
|
|
|
return status;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* iocp_poller - get completion events and run callbacks
|
|
*/
|
|
static DWORD CALLBACK iocp_poller(LPVOID Arg)
|
|
{
|
|
while( TRUE )
|
|
{
|
|
PRTL_OVERLAPPED_COMPLETION_ROUTINE callback;
|
|
LPVOID overlapped;
|
|
IO_STATUS_BLOCK iosb;
|
|
NTSTATUS res = NtRemoveIoCompletion( compl_port, (PULONG_PTR)&callback, (PULONG_PTR)&overlapped, &iosb, NULL );
|
|
if (res)
|
|
{
|
|
ERR("NtRemoveIoCompletion failed: 0x%x\n", res);
|
|
}
|
|
else
|
|
{
|
|
DWORD transferred = 0;
|
|
DWORD err = 0;
|
|
|
|
if (iosb.u.Status == STATUS_SUCCESS)
|
|
transferred = iosb.Information;
|
|
else
|
|
err = RtlNtStatusToDosError(iosb.u.Status);
|
|
|
|
callback( err, transferred, overlapped );
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* RtlSetIoCompletionCallback (NTDLL.@)
|
|
*
|
|
* Binds a handle to a thread pool's completion port, and possibly
|
|
* starts a non-I/O thread to monitor this port and call functions back.
|
|
*
|
|
* PARAMS
|
|
* FileHandle [I] Handle to bind to a completion port.
|
|
* Function [I] Callback function to call on I/O completions.
|
|
* Flags [I] Not used.
|
|
*
|
|
* RETURNS
|
|
* Success: STATUS_SUCCESS.
|
|
* Failure: Any NTSTATUS code.
|
|
*
|
|
*/
|
|
NTSTATUS WINAPI RtlSetIoCompletionCallback(HANDLE FileHandle, PRTL_OVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
|
|
{
|
|
IO_STATUS_BLOCK iosb;
|
|
FILE_COMPLETION_INFORMATION info;
|
|
|
|
if (Flags) FIXME("Unknown value Flags=0x%x\n", Flags);
|
|
|
|
if (!compl_port)
|
|
{
|
|
NTSTATUS res = STATUS_SUCCESS;
|
|
|
|
RtlEnterCriticalSection(&threadpool_compl_cs);
|
|
if (!compl_port)
|
|
{
|
|
HANDLE cport;
|
|
|
|
res = NtCreateIoCompletion( &cport, IO_COMPLETION_ALL_ACCESS, NULL, 0 );
|
|
if (!res)
|
|
{
|
|
/* FIXME native can start additional threads in case of e.g. hung callback function. */
|
|
res = RtlQueueWorkItem( iocp_poller, NULL, WT_EXECUTEDEFAULT );
|
|
if (!res)
|
|
compl_port = cport;
|
|
else
|
|
NtClose( cport );
|
|
}
|
|
}
|
|
RtlLeaveCriticalSection(&threadpool_compl_cs);
|
|
if (res) return res;
|
|
}
|
|
|
|
info.CompletionPort = compl_port;
|
|
info.CompletionKey = (ULONG_PTR)Function;
|
|
|
|
return NtSetInformationFile( FileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
|
|
}
|
|
|
|
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 wait_work_item
|
|
{
|
|
HANDLE Object;
|
|
HANDLE CancelEvent;
|
|
WAITORTIMERCALLBACK Callback;
|
|
PVOID Context;
|
|
ULONG Milliseconds;
|
|
ULONG Flags;
|
|
HANDLE CompletionEvent;
|
|
LONG DeleteCount;
|
|
BOOLEAN CallbackInProgress;
|
|
};
|
|
|
|
static void delete_wait_work_item(struct wait_work_item *wait_work_item)
|
|
{
|
|
NtClose( wait_work_item->CancelEvent );
|
|
RtlFreeHeap( GetProcessHeap(), 0, wait_work_item );
|
|
}
|
|
|
|
static DWORD CALLBACK wait_thread_proc(LPVOID Arg)
|
|
{
|
|
struct wait_work_item *wait_work_item = Arg;
|
|
NTSTATUS status;
|
|
BOOLEAN alertable = (wait_work_item->Flags & WT_EXECUTEINIOTHREAD) ? TRUE : FALSE;
|
|
HANDLE handles[2] = { wait_work_item->Object, wait_work_item->CancelEvent };
|
|
LARGE_INTEGER timeout;
|
|
HANDLE completion_event;
|
|
|
|
TRACE("\n");
|
|
|
|
while (TRUE)
|
|
{
|
|
status = NtWaitForMultipleObjects( 2, handles, FALSE, alertable,
|
|
get_nt_timeout( &timeout, wait_work_item->Milliseconds ) );
|
|
if (status == STATUS_WAIT_0 || status == STATUS_TIMEOUT)
|
|
{
|
|
BOOLEAN TimerOrWaitFired;
|
|
|
|
if (status == STATUS_WAIT_0)
|
|
{
|
|
TRACE( "object %p signaled, calling callback %p with context %p\n",
|
|
wait_work_item->Object, wait_work_item->Callback,
|
|
wait_work_item->Context );
|
|
TimerOrWaitFired = FALSE;
|
|
}
|
|
else
|
|
{
|
|
TRACE( "wait for object %p timed out, calling callback %p with context %p\n",
|
|
wait_work_item->Object, wait_work_item->Callback,
|
|
wait_work_item->Context );
|
|
TimerOrWaitFired = TRUE;
|
|
}
|
|
wait_work_item->CallbackInProgress = TRUE;
|
|
wait_work_item->Callback( wait_work_item->Context, TimerOrWaitFired );
|
|
wait_work_item->CallbackInProgress = FALSE;
|
|
|
|
if (wait_work_item->Flags & WT_EXECUTEONLYONCE)
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
completion_event = wait_work_item->CompletionEvent;
|
|
if (completion_event) NtSetEvent( completion_event, NULL );
|
|
|
|
if (interlocked_inc( &wait_work_item->DeleteCount ) == 2 )
|
|
delete_wait_work_item( wait_work_item );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* RtlRegisterWait (NTDLL.@)
|
|
*
|
|
* Registers a wait for a handle to become signaled.
|
|
*
|
|
* PARAMS
|
|
* NewWaitObject [I] Handle to the new wait object. Use RtlDeregisterWait() to free it.
|
|
* Object [I] Object to wait to become signaled.
|
|
* Callback [I] Callback function to execute when the wait times out or the handle is signaled.
|
|
* Context [I] Context to pass to the callback function when it is executed.
|
|
* Milliseconds [I] Number of milliseconds to wait before timing out.
|
|
* Flags [I] Flags. See notes.
|
|
*
|
|
* RETURNS
|
|
* Success: STATUS_SUCCESS.
|
|
* Failure: Any NTSTATUS code.
|
|
*
|
|
* NOTES
|
|
* Flags can be one or more of the following:
|
|
*|WT_EXECUTEDEFAULT - Executes the work item in a non-I/O worker thread.
|
|
*|WT_EXECUTEINIOTHREAD - Executes the work item in an I/O worker thread.
|
|
*|WT_EXECUTEINPERSISTENTTHREAD - Executes the work item in a thread that is persistent.
|
|
*|WT_EXECUTELONGFUNCTION - Hints that the execution can take a long time.
|
|
*|WT_TRANSFER_IMPERSONATION - Executes the function with the current access token.
|
|
*/
|
|
NTSTATUS WINAPI RtlRegisterWait(PHANDLE NewWaitObject, HANDLE Object,
|
|
RTL_WAITORTIMERCALLBACKFUNC Callback,
|
|
PVOID Context, ULONG Milliseconds, ULONG Flags)
|
|
{
|
|
struct wait_work_item *wait_work_item;
|
|
NTSTATUS status;
|
|
|
|
TRACE( "(%p, %p, %p, %p, %d, 0x%x)\n", NewWaitObject, Object, Callback, Context, Milliseconds, Flags );
|
|
|
|
wait_work_item = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*wait_work_item) );
|
|
if (!wait_work_item)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
wait_work_item->Object = Object;
|
|
wait_work_item->Callback = Callback;
|
|
wait_work_item->Context = Context;
|
|
wait_work_item->Milliseconds = Milliseconds;
|
|
wait_work_item->Flags = Flags;
|
|
wait_work_item->CallbackInProgress = FALSE;
|
|
wait_work_item->DeleteCount = 0;
|
|
wait_work_item->CompletionEvent = NULL;
|
|
|
|
status = NtCreateEvent( &wait_work_item->CancelEvent, EVENT_ALL_ACCESS, NULL, TRUE, FALSE );
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
RtlFreeHeap( GetProcessHeap(), 0, wait_work_item );
|
|
return status;
|
|
}
|
|
|
|
status = RtlQueueWorkItem( wait_thread_proc, wait_work_item, Flags & ~WT_EXECUTEONLYONCE );
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
delete_wait_work_item( wait_work_item );
|
|
return status;
|
|
}
|
|
|
|
*NewWaitObject = wait_work_item;
|
|
return status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* RtlDeregisterWaitEx (NTDLL.@)
|
|
*
|
|
* Cancels a wait operation and frees the resources associated with calling
|
|
* RtlRegisterWait().
|
|
*
|
|
* PARAMS
|
|
* WaitObject [I] Handle to the wait object to free.
|
|
*
|
|
* RETURNS
|
|
* Success: STATUS_SUCCESS.
|
|
* Failure: Any NTSTATUS code.
|
|
*/
|
|
NTSTATUS WINAPI RtlDeregisterWaitEx(HANDLE WaitHandle, HANDLE CompletionEvent)
|
|
{
|
|
struct wait_work_item *wait_work_item = WaitHandle;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
TRACE( "(%p)\n", WaitHandle );
|
|
|
|
NtSetEvent( wait_work_item->CancelEvent, NULL );
|
|
if (wait_work_item->CallbackInProgress)
|
|
{
|
|
if (CompletionEvent != NULL)
|
|
{
|
|
if (CompletionEvent == INVALID_HANDLE_VALUE)
|
|
{
|
|
status = NtCreateEvent( &CompletionEvent, EVENT_ALL_ACCESS, NULL, TRUE, FALSE );
|
|
if (status != STATUS_SUCCESS)
|
|
return status;
|
|
interlocked_xchg_ptr( &wait_work_item->CompletionEvent, CompletionEvent );
|
|
if (wait_work_item->CallbackInProgress)
|
|
NtWaitForSingleObject( CompletionEvent, FALSE, NULL );
|
|
NtClose( CompletionEvent );
|
|
}
|
|
else
|
|
{
|
|
interlocked_xchg_ptr( &wait_work_item->CompletionEvent, CompletionEvent );
|
|
if (wait_work_item->CallbackInProgress)
|
|
status = STATUS_PENDING;
|
|
}
|
|
}
|
|
else
|
|
status = STATUS_PENDING;
|
|
}
|
|
|
|
if (interlocked_inc( &wait_work_item->DeleteCount ) == 2 )
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
delete_wait_work_item( wait_work_item );
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* RtlDeregisterWait (NTDLL.@)
|
|
*
|
|
* Cancels a wait operation and frees the resources associated with calling
|
|
* RtlRegisterWait().
|
|
*
|
|
* PARAMS
|
|
* WaitObject [I] Handle to the wait object to free.
|
|
*
|
|
* RETURNS
|
|
* Success: STATUS_SUCCESS.
|
|
* Failure: Any NTSTATUS code.
|
|
*/
|
|
NTSTATUS WINAPI RtlDeregisterWait(HANDLE WaitHandle)
|
|
{
|
|
return RtlDeregisterWaitEx(WaitHandle, NULL);
|
|
}
|
|
|
|
|
|
/************************** Timer Queue Impl **************************/
|
|
|
|
struct timer_queue;
|
|
struct queue_timer
|
|
{
|
|
struct timer_queue *q;
|
|
struct list entry;
|
|
ULONG runcount; /* number of callbacks pending execution */
|
|
RTL_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
|
|
{
|
|
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)
|
|
|
|
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(GetProcessHeap(), 0, t);
|
|
|
|
if (q->quit && list_count(&q->timers) == 0)
|
|
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 DWORD WINAPI timer_callback_wrapper(LPVOID p)
|
|
{
|
|
struct queue_timer *t = p;
|
|
t->callback(t->param, TRUE);
|
|
timer_cleanup_callback(t);
|
|
return 0;
|
|
}
|
|
|
|
static inline ULONGLONG queue_current_time(void)
|
|
{
|
|
LARGE_INTEGER now;
|
|
NtQuerySystemTime(&now);
|
|
return now.QuadPart / 10000;
|
|
}
|
|
|
|
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))
|
|
{
|
|
t = LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
|
|
if (!t->destroy && t->expire <= queue_current_time())
|
|
{
|
|
++t->runcount;
|
|
queue_move_timer(
|
|
t, t->period ? queue_current_time() + t->period : EXPIRE_NEVER,
|
|
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 : t->expire - time;
|
|
}
|
|
}
|
|
RtlLeaveCriticalSection(&q->cs);
|
|
|
|
return timeout;
|
|
}
|
|
|
|
static void 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_count(&q->timers) == 0)
|
|
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);
|
|
RtlFreeHeap(GetProcessHeap(), 0, q);
|
|
}
|
|
|
|
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(GetProcessHeap(), 0, sizeof *q);
|
|
if (!q)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
RtlInitializeCriticalSection(&q->cs);
|
|
list_init(&q->timers);
|
|
q->quit = FALSE;
|
|
status = NtCreateEvent(&q->event, EVENT_ALL_ACCESS, NULL, FALSE, FALSE);
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
RtlFreeHeap(GetProcessHeap(), 0, q);
|
|
return status;
|
|
}
|
|
status = RtlCreateUserThread(GetCurrentProcess(), NULL, FALSE, NULL, 0, 0,
|
|
timer_queue_thread_proc, q, &q->thread, NULL);
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
NtClose(q->event);
|
|
RtlFreeHeap(GetProcessHeap(), 0, q);
|
|
return status;
|
|
}
|
|
|
|
*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)
|
|
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)
|
|
{
|
|
FIXME("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 *default_timer_queue;
|
|
|
|
static struct timer_queue *get_timer_queue(HANDLE TimerQueue)
|
|
{
|
|
if (TimerQueue)
|
|
return TimerQueue;
|
|
else
|
|
{
|
|
if (!default_timer_queue)
|
|
{
|
|
HANDLE q;
|
|
NTSTATUS status = RtlCreateTimerQueue(&q);
|
|
if (status == STATUS_SUCCESS)
|
|
{
|
|
PVOID p = interlocked_cmpxchg_ptr(
|
|
(void **) &default_timer_queue, q, NULL);
|
|
if (p)
|
|
/* Got beat to the punch. */
|
|
RtlDeleteTimerQueueEx(p, 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 controling 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(PHANDLE NewTimer, HANDLE TimerQueue,
|
|
RTL_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;
|
|
|
|
t = RtlAllocateHeap(GetProcessHeap(), 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(GetProcessHeap(), 0, t);
|
|
|
|
return status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* 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, FALSE, FALSE);
|
|
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);
|
|
NtClose(event);
|
|
}
|
|
|
|
return status;
|
|
}
|