queue.c File Reference

#include <assert.h>
#include "initguid.h"
#include "rtworkq.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for queue.c:

Go to the source code of this file.

Classes
struct	queue_handle
struct	work_item
struct	queue_ops
struct	queue_desc
class	queue< _Tp, _Sequence >
struct	async_result
struct	periodic_callback

Macros
#define	COBJMACROS
#define	FIRST_USER_QUEUE_HANDLE   5
#define	MAX_USER_QUEUE_HANDLES   124
#define	WAIT_ITEM_KEY_MASK   (0x82000000)
#define	SCHEDULED_ITEM_KEY_MASK   (0x80000000)

Enumerations
enum	rtwq_callback_queue_id {   RTWQ_CALLBACK_QUEUE_UNDEFINED = 0x00000000 , RTWQ_CALLBACK_QUEUE_STANDARD = 0x00000001 , RTWQ_CALLBACK_QUEUE_RT = 0x00000002 , RTWQ_CALLBACK_QUEUE_IO = 0x00000003 ,   RTWQ_CALLBACK_QUEUE_TIMER = 0x00000004 , RTWQ_CALLBACK_QUEUE_MULTITHREADED = 0x00000005 , RTWQ_CALLBACK_QUEUE_LONG_FUNCTION = 0x00000007 , RTWQ_CALLBACK_QUEUE_PRIVATE_MASK = 0xffff0000 ,   RTWQ_CALLBACK_QUEUE_ALL = 0xffffffff }
enum	rtwq_callback_flags {   RTWQ_FAST_IO_PROCESSING_CALLBACK = 0x00000001 , RTWQ_SIGNAL_CALLBACK = 0x00000002 , RTWQ_BLOCKING_CALLBACK = 0x00000004 , RTWQ_REPLY_CALLBACK = 0x00000008 ,   RTWQ_LOCALIZE_REMOTE_CALLBACK = 0x00000010 }
enum	system_queue_index {   SYS_QUEUE_STANDARD = 0 , SYS_QUEUE_RT , SYS_QUEUE_IO , SYS_QUEUE_TIMER ,   SYS_QUEUE_MULTITHREADED , SYS_QUEUE_DO_NOT_USE , SYS_QUEUE_LONG_FUNCTION , SYS_QUEUE_COUNT }
enum	work_item_type { WORK_ITEM_WORK , WORK_ITEM_TIMER , WORK_ITEM_WAIT }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mfplat)
static RTWQWORKITEM_KEY	get_item_key (DWORD mask, DWORD key)
static RTWQWORKITEM_KEY	generate_item_key (DWORD mask)
static struct queue_handle *	get_queue_obj (DWORD handle)
static struct work_item *	work_item_impl_from_IUnknown (IUnknown *iface)
static void	shutdown_queue (struct queue *queue)
static HRESULT	lock_user_queue (DWORD queue)
static HRESULT	unlock_user_queue (DWORD queue)
static struct queue *	queue_impl_from_IRtwqAsyncCallback (IRtwqAsyncCallback *iface)
static HRESULT WINAPI	queue_serial_callback_QueryInterface (IRtwqAsyncCallback *iface, REFIID riid, void **obj)
static ULONG WINAPI	queue_serial_callback_AddRef (IRtwqAsyncCallback *iface)
static ULONG WINAPI	queue_serial_callback_Release (IRtwqAsyncCallback *iface)
static HRESULT WINAPI	queue_serial_callback_GetParameters (IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue_id)
static HRESULT WINAPI	queue_serial_callback_Invoke (IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
static struct queue *	get_system_queue (DWORD queue_id)
static HRESULT	grab_queue (DWORD queue_id, struct queue **ret)
static void CALLBACK	standard_queue_cleanup_callback (void *object_data, void *group_data)
static HRESULT	pool_queue_init (const struct queue_desc *desc, struct queue *queue)
static BOOL	pool_queue_shutdown (struct queue *queue)
static void CALLBACK	standard_queue_worker (TP_CALLBACK_INSTANCE *instance, void *context, TP_WORK *work)
static void	pool_queue_submit (struct queue *queue, struct work_item *item)
static struct work_item *	serial_queue_get_next (struct queue *queue, struct work_item *item)
static void CALLBACK	serial_queue_finalization_callback (PTP_CALLBACK_INSTANCE instance, void *user_data)
static HRESULT	serial_queue_init (const struct queue_desc *desc, struct queue *queue)
static BOOL	serial_queue_shutdown (struct queue *queue)
static struct work_item *	serial_queue_is_ack_token (struct queue *queue, struct work_item *item)
static void	serial_queue_submit (struct queue *queue, struct work_item *item)
static HRESULT WINAPI	work_item_QueryInterface (IUnknown *iface, REFIID riid, void **obj)
static ULONG WINAPI	work_item_AddRef (IUnknown *iface)
static ULONG WINAPI	work_item_Release (IUnknown *iface)
static struct work_item *	alloc_work_item (struct queue *queue, LONG priority, IRtwqAsyncResult *result)
static void	init_work_queue (const struct queue_desc *desc, struct queue *queue)
static HRESULT	queue_submit_item (struct queue *queue, LONG priority, IRtwqAsyncResult *result)
static HRESULT	queue_put_work_item (DWORD queue_id, LONG priority, IRtwqAsyncResult *result)
static HRESULT	invoke_async_callback (IRtwqAsyncResult *result)
static BOOL	queue_release_pending_item (struct work_item *item)
static void CALLBACK	waiting_item_callback (TP_CALLBACK_INSTANCE *instance, void *context, TP_WAIT *wait, TP_WAIT_RESULT wait_result)
static void CALLBACK	waiting_item_cancelable_callback (TP_CALLBACK_INSTANCE *instance, void *context, TP_WAIT *wait, TP_WAIT_RESULT wait_result)
static void CALLBACK	scheduled_item_callback (TP_CALLBACK_INSTANCE *instance, void *context, TP_TIMER *timer)
static void CALLBACK	scheduled_item_cancelable_callback (TP_CALLBACK_INSTANCE *instance, void *context, TP_TIMER *timer)
static void CALLBACK	periodic_item_callback (TP_CALLBACK_INSTANCE *instance, void *context, TP_TIMER *timer)
static void	queue_mark_item_pending (DWORD mask, struct work_item *item, RTWQWORKITEM_KEY *key)
static HRESULT	queue_submit_wait (struct queue *queue, HANDLE event, LONG priority, IRtwqAsyncResult *result, RTWQWORKITEM_KEY *key)
static HRESULT	queue_submit_timer (struct queue *queue, IRtwqAsyncResult *result, INT64 timeout, DWORD period, RTWQWORKITEM_KEY *key)
static HRESULT	queue_cancel_item (struct queue *queue, RTWQWORKITEM_KEY key)
static HRESULT	alloc_user_queue (const struct queue_desc *desc, DWORD *queue_id)
static struct async_result *	impl_from_IRtwqAsyncResult (IRtwqAsyncResult *iface)
static HRESULT WINAPI	async_result_QueryInterface (IRtwqAsyncResult *iface, REFIID riid, void **obj)
static ULONG WINAPI	async_result_AddRef (IRtwqAsyncResult *iface)
static ULONG WINAPI	async_result_Release (IRtwqAsyncResult *iface)
static HRESULT WINAPI	async_result_GetState (IRtwqAsyncResult *iface, IUnknown **state)
static HRESULT WINAPI	async_result_GetStatus (IRtwqAsyncResult *iface)
static HRESULT WINAPI	async_result_SetStatus (IRtwqAsyncResult *iface, HRESULT status)
static HRESULT WINAPI	async_result_GetObject (IRtwqAsyncResult *iface, IUnknown **object)
static IUnknown *WINAPI	async_result_GetStateNoAddRef (IRtwqAsyncResult *iface)
static HRESULT	create_async_result (IUnknown *object, IRtwqAsyncCallback *callback, IUnknown *state, IRtwqAsyncResult **out)
HRESULT WINAPI	RtwqCreateAsyncResult (IUnknown *object, IRtwqAsyncCallback *callback, IUnknown *state, IRtwqAsyncResult **out)
HRESULT WINAPI	RtwqLockPlatform (void)
HRESULT WINAPI	RtwqUnlockPlatform (void)
static void	init_system_queues (void)
HRESULT WINAPI	RtwqStartup (void)
static void	shutdown_system_queues (void)
HRESULT WINAPI	RtwqShutdown (void)
HRESULT WINAPI	RtwqPutWaitingWorkItem (HANDLE event, LONG priority, IRtwqAsyncResult *result, RTWQWORKITEM_KEY *key)
static HRESULT	schedule_work_item (IRtwqAsyncResult *result, INT64 timeout, RTWQWORKITEM_KEY *key)
HRESULT WINAPI	RtwqScheduleWorkItem (IRtwqAsyncResult *result, INT64 timeout, RTWQWORKITEM_KEY *key)
static struct periodic_callback *	impl_from_IRtwqAsyncCallback (IRtwqAsyncCallback *iface)
static HRESULT WINAPI	periodic_callback_QueryInterface (IRtwqAsyncCallback *iface, REFIID riid, void **obj)
static ULONG WINAPI	periodic_callback_AddRef (IRtwqAsyncCallback *iface)
static ULONG WINAPI	periodic_callback_Release (IRtwqAsyncCallback *iface)
static HRESULT WINAPI	periodic_callback_GetParameters (IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
static HRESULT WINAPI	periodic_callback_Invoke (IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
static HRESULT	create_periodic_callback_obj (RTWQPERIODICCALLBACK callback, IRtwqAsyncCallback **out)
HRESULT WINAPI	RtwqAddPeriodicCallback (RTWQPERIODICCALLBACK callback, IUnknown *context, DWORD *key)
HRESULT WINAPI	RtwqRemovePeriodicCallback (DWORD key)
HRESULT WINAPI	RtwqCancelWorkItem (RTWQWORKITEM_KEY key)
HRESULT WINAPI	RtwqInvokeCallback (IRtwqAsyncResult *result)
HRESULT WINAPI	RtwqPutWorkItem (DWORD queue, LONG priority, IRtwqAsyncResult *result)
HRESULT WINAPI	RtwqAllocateWorkQueue (RTWQ_WORKQUEUE_TYPE queue_type, DWORD *queue)
HRESULT WINAPI	RtwqLockWorkQueue (DWORD queue)
HRESULT WINAPI	RtwqUnlockWorkQueue (DWORD queue)
HRESULT WINAPI	RtwqSetLongRunning (DWORD queue_id, BOOL enable)
HRESULT WINAPI	RtwqLockSharedWorkQueue (const WCHAR *usageclass, LONG priority, DWORD *taskid, DWORD *queue)
HRESULT WINAPI	RtwqSetDeadline (DWORD queue_id, LONGLONG deadline, HANDLE *request)
HRESULT WINAPI	RtwqSetDeadline2 (DWORD queue_id, LONGLONG deadline, LONGLONG predeadline, HANDLE *request)
HRESULT WINAPI	RtwqCancelDeadline (HANDLE request)
HRESULT WINAPI	RtwqAllocateSerialWorkQueue (DWORD target_queue, DWORD *queue)
HRESULT WINAPI	RtwqJoinWorkQueue (DWORD queue, HANDLE hFile, HANDLE *cookie)
HRESULT WINAPI	RtwqUnjoinWorkQueue (DWORD queue, HANDLE cookie)
HRESULT WINAPI	RtwqGetWorkQueueMMCSSClass (DWORD queue, WCHAR *class, DWORD *length)
HRESULT WINAPI	RtwqGetWorkQueueMMCSSTaskId (DWORD queue, DWORD *taskid)
HRESULT WINAPI	RtwqGetWorkQueueMMCSSPriority (DWORD queue, LONG *priority)
HRESULT WINAPI	RtwqRegisterPlatformWithMMCSS (const WCHAR *class, DWORD *taskid, LONG priority)
HRESULT WINAPI	RtwqUnregisterPlatformFromMMCSS (void)
HRESULT WINAPI	RtwqBeginRegisterWorkQueueWithMMCSS (DWORD queue, const WCHAR *class, DWORD taskid, LONG priority, IRtwqAsyncCallback *callback, IUnknown *state)
HRESULT WINAPI	RtwqEndRegisterWorkQueueWithMMCSS (IRtwqAsyncResult *result, DWORD *taskid)
HRESULT WINAPI	RtwqBeginUnregisterWorkQueueWithMMCSS (DWORD queue, IRtwqAsyncCallback *callback, IUnknown *state)
HRESULT WINAPI	RtwqEndUnregisterWorkQueueWithMMCSS (IRtwqAsyncResult *result)
HRESULT WINAPI	RtwqRegisterPlatformEvents (IRtwqPlatformEvents *events)
HRESULT WINAPI	RtwqUnregisterPlatformEvents (IRtwqPlatformEvents *events)

Variables
static LONG	next_item_key
static struct queue_handle	user_queues [MAX_USER_QUEUE_HANDLES]
static struct queue_handle *	next_free_user_queue
static struct queue_handle *	next_unused_user_queue = user_queues
static WORD	queue_generation
static DWORD	shared_mt_queue
static CRITICAL_SECTION	queues_section = { &queues_critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	queues_critsect_debug
static LONG	platform_lock
static CO_MTA_USAGE_COOKIE	mta_cookie
static const TP_CALLBACK_PRIORITY	priorities []
static const IRtwqAsyncCallbackVtbl	queue_serial_callback_vtbl
static struct queue	system_queues [SYS_QUEUE_COUNT]
static const struct queue_ops	pool_queue_ops
static const struct queue_ops	serial_queue_ops
static const IUnknownVtbl	work_item_vtbl
static const IRtwqAsyncResultVtbl	async_result_vtbl
static const IRtwqAsyncCallbackVtbl	periodic_callback_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file queue.c.

FIRST_USER_QUEUE_HANDLE

#define FIRST_USER_QUEUE_HANDLE   5

Definition at line 29 of file queue.c.

MAX_USER_QUEUE_HANDLES

#define MAX_USER_QUEUE_HANDLES   124

Definition at line 30 of file queue.c.

SCHEDULED_ITEM_KEY_MASK

#define SCHEDULED_ITEM_KEY_MASK   (0x80000000)

Definition at line 33 of file queue.c.

WAIT_ITEM_KEY_MASK

#define WAIT_ITEM_KEY_MASK   (0x82000000)

Definition at line 32 of file queue.c.

Enumeration Type Documentation

rtwq_callback_flags

enum rtwq_callback_flags

Enumerator
RTWQ_FAST_IO_PROCESSING_CALLBACK
RTWQ_SIGNAL_CALLBACK
RTWQ_BLOCKING_CALLBACK
RTWQ_REPLY_CALLBACK
RTWQ_LOCALIZE_REMOTE_CALLBACK

Definition at line 100 of file queue.c.

{
    RTWQ_FAST_IO_PROCESSING_CALLBACK = 0x00000001,
    RTWQ_SIGNAL_CALLBACK             = 0x00000002,
    RTWQ_BLOCKING_CALLBACK           = 0x00000004,
    RTWQ_REPLY_CALLBACK              = 0x00000008,
    RTWQ_LOCALIZE_REMOTE_CALLBACK    = 0x00000010,
};

rtwq_callback_queue_id

enum rtwq_callback_queue_id

Enumerator
RTWQ_CALLBACK_QUEUE_UNDEFINED
RTWQ_CALLBACK_QUEUE_STANDARD
RTWQ_CALLBACK_QUEUE_RT
RTWQ_CALLBACK_QUEUE_IO
RTWQ_CALLBACK_QUEUE_TIMER
RTWQ_CALLBACK_QUEUE_MULTITHREADED
RTWQ_CALLBACK_QUEUE_LONG_FUNCTION
RTWQ_CALLBACK_QUEUE_PRIVATE_MASK
RTWQ_CALLBACK_QUEUE_ALL

Definition at line 86 of file queue.c.

{
    RTWQ_CALLBACK_QUEUE_UNDEFINED     = 0x00000000,
    RTWQ_CALLBACK_QUEUE_STANDARD      = 0x00000001,
    RTWQ_CALLBACK_QUEUE_RT            = 0x00000002,
    RTWQ_CALLBACK_QUEUE_IO            = 0x00000003,
    RTWQ_CALLBACK_QUEUE_TIMER         = 0x00000004,
    RTWQ_CALLBACK_QUEUE_MULTITHREADED = 0x00000005,
    RTWQ_CALLBACK_QUEUE_LONG_FUNCTION = 0x00000007,
    RTWQ_CALLBACK_QUEUE_PRIVATE_MASK  = 0xffff0000,
    RTWQ_CALLBACK_QUEUE_ALL           = 0xffffffff,
};

system_queue_index

enum system_queue_index

Enumerator
SYS_QUEUE_STANDARD
SYS_QUEUE_RT
SYS_QUEUE_IO
SYS_QUEUE_TIMER
SYS_QUEUE_MULTITHREADED
SYS_QUEUE_DO_NOT_USE
SYS_QUEUE_LONG_FUNCTION
SYS_QUEUE_COUNT

Definition at line 109 of file queue.c.

{
    SYS_QUEUE_STANDARD = 0,
    SYS_QUEUE_RT,
    SYS_QUEUE_IO,
    SYS_QUEUE_TIMER,
    SYS_QUEUE_MULTITHREADED,
    SYS_QUEUE_DO_NOT_USE,
    SYS_QUEUE_LONG_FUNCTION,
    SYS_QUEUE_COUNT,
};

work_item_type

enum work_item_type

Enumerator
WORK_ITEM_WORK
WORK_ITEM_TIMER
WORK_ITEM_WAIT

Definition at line 121 of file queue.c.

{
    WORK_ITEM_WORK,
    WORK_ITEM_TIMER,
    WORK_ITEM_WAIT,
};

Function Documentation

alloc_user_queue()

static HRESULT alloc_user_queue ( const struct queue_desc *  desc, DWORD *  queue_id  )

static

Definition at line 949 of file queue.c.

{
    struct queue_handle *entry;
    struct queue *queue;
    unsigned int idx;
 
    *queue_id = RTWQ_CALLBACK_QUEUE_UNDEFINED;
 
    if (platform_lock <= 0)
        return RTWQ_E_SHUTDOWN;
 
    if (!(queue = calloc(1, sizeof(*queue))))
        return E_OUTOFMEMORY;
 
    init_work_queue(desc, queue);
 
    EnterCriticalSection(&queues_section);
 
    entry = next_free_user_queue;
    if (entry)
        next_free_user_queue = entry->obj;
    else if (next_unused_user_queue < user_queues + MAX_USER_QUEUE_HANDLES)
        entry = next_unused_user_queue++;
    else
    {
        LeaveCriticalSection(&queues_section);
        free(queue);
        WARN("Out of user queue handles.\n");
        return E_OUTOFMEMORY;
    }
 
    entry->refcount = 1;
    entry->obj = queue;
    if (++queue_generation == 0xffff) queue_generation = 1;
    entry->generation = queue_generation;
    idx = entry - user_queues + FIRST_USER_QUEUE_HANDLE;
    *queue_id = (idx << 16) | entry->generation;
 
    LeaveCriticalSection(&queues_section);
 
    return S_OK;
}

Referenced by RtwqAllocateSerialWorkQueue(), RtwqAllocateWorkQueue(), and RtwqLockSharedWorkQueue().

alloc_work_item()

static struct work_item * alloc_work_item ( struct queue *  queue, LONG  priority, IRtwqAsyncResult *  result  )

static

Definition at line 589 of file queue.c.

{
    RTWQASYNCRESULT *async_result = (RTWQASYNCRESULT *)result;
    DWORD flags = 0, queue_id = 0;
    struct work_item *item;
 
    item = calloc(1, sizeof(*item));
 
    item->IUnknown_iface.lpVtbl = &work_item_vtbl;
    item->result = result;
    IRtwqAsyncResult_AddRef(item->result);
    item->refcount = 1;
    item->queue = queue;
    list_init(&item->entry);
    item->priority = priority;
 
    if (SUCCEEDED(IRtwqAsyncCallback_GetParameters(async_result->pCallback, &flags, &queue_id)))
        item->flags = flags;
 
    return item;
}

Referenced by queue_submit_item(), queue_submit_timer(), and queue_submit_wait().

async_result_AddRef()

static ULONG WINAPI async_result_AddRef ( IRtwqAsyncResult *  iface )

static

Definition at line 1022 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
    ULONG refcount = InterlockedIncrement(&result->refcount);
 
    TRACE("%p, %lu.\n", iface, refcount);
 
    return refcount;
}

async_result_GetObject()

static HRESULT WINAPI async_result_GetObject ( IRtwqAsyncResult *  iface, IUnknown **  object  )

static

Definition at line 1092 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
 
    TRACE("%p, %p.\n", iface, object);
 
    if (!result->object)
        return E_POINTER;
 
    *object = result->object;
    IUnknown_AddRef(*object);
 
    return S_OK;
}

async_result_GetState()

static HRESULT WINAPI async_result_GetState ( IRtwqAsyncResult *  iface, IUnknown **  state  )

static

Definition at line 1057 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
 
    TRACE("%p, %p.\n", iface, state);
 
    if (!result->state)
        return E_POINTER;
 
    *state = result->state;
    IUnknown_AddRef(*state);
 
    return S_OK;
}

async_result_GetStateNoAddRef()

static IUnknown *WINAPI async_result_GetStateNoAddRef ( IRtwqAsyncResult *  iface )

static

Definition at line 1107 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
 
    TRACE("%p.\n", iface);
 
    return result->state;
}

async_result_GetStatus()

static HRESULT WINAPI async_result_GetStatus ( IRtwqAsyncResult *  iface )

static

Definition at line 1072 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
 
    TRACE("%p.\n", iface);
 
    return result->result.hrStatusResult;
}

async_result_QueryInterface()

static HRESULT WINAPI async_result_QueryInterface ( IRtwqAsyncResult *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1005 of file queue.c.

{
    TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IRtwqAsyncResult) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IRtwqAsyncResult_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    WARN("Unsupported interface %s.\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

async_result_Release()

static ULONG WINAPI async_result_Release ( IRtwqAsyncResult *  iface )

static

Definition at line 1032 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
    ULONG refcount = InterlockedDecrement(&result->refcount);
 
    TRACE("%p, %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        if (result->result.pCallback)
            IRtwqAsyncCallback_Release(result->result.pCallback);
        if (result->object)
            IUnknown_Release(result->object);
        if (result->state)
            IUnknown_Release(result->state);
        if (result->result.hEvent)
            CloseHandle(result->result.hEvent);
        free(result);
 
        RtwqUnlockPlatform();
    }
 
    return refcount;
}

async_result_SetStatus()

static HRESULT WINAPI async_result_SetStatus ( IRtwqAsyncResult *  iface, HRESULT  status  )

static

Definition at line 1081 of file queue.c.

{
    struct async_result *result = impl_from_IRtwqAsyncResult(iface);
 
    TRACE("%p, %#lx.\n", iface, status);
 
    result->result.hrStatusResult = status;
 
    return S_OK;
}

create_async_result()

static HRESULT create_async_result ( IUnknown *  object, IRtwqAsyncCallback *  callback, IUnknown *  state, IRtwqAsyncResult **  out  )

static

Definition at line 1128 of file queue.c.

{
    struct async_result *result;
 
    if (!out)
        return E_INVALIDARG;
 
    if (!(result = calloc(1, sizeof(*result))))
        return E_OUTOFMEMORY;
 
    RtwqLockPlatform();
 
    result->result.AsyncResult.lpVtbl = &async_result_vtbl;
    result->refcount = 1;
    result->object = object;
    if (result->object)
        IUnknown_AddRef(result->object);
    result->result.pCallback = callback;
    if (result->result.pCallback)
        IRtwqAsyncCallback_AddRef(result->result.pCallback);
    result->state = state;
    if (result->state)
        IUnknown_AddRef(result->state);
 
    *out = &result->result.AsyncResult;
 
    TRACE("Created async result object %p.\n", *out);
 
    return S_OK;
}

Referenced by RtwqAddPeriodicCallback(), and RtwqCreateAsyncResult().

create_periodic_callback_obj()

static HRESULT create_periodic_callback_obj ( RTWQPERIODICCALLBACK  callback, IRtwqAsyncCallback **  out  )

static

Definition at line 1362 of file queue.c.

{
    struct periodic_callback *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IRtwqAsyncCallback_iface.lpVtbl = &periodic_callback_vtbl;
    object->refcount = 1;
    object->callback = callback;
 
    *out = &object->IRtwqAsyncCallback_iface;
 
    return S_OK;
}

Referenced by RtwqAddPeriodicCallback().

generate_item_key()

static RTWQWORKITEM_KEY generate_item_key ( DWORD  mask )

static

Definition at line 42 of file queue.c.

{
    return get_item_key(mask, InterlockedIncrement(&next_item_key));
}

Referenced by queue_mark_item_pending().

get_item_key()

static RTWQWORKITEM_KEY get_item_key ( DWORD  mask, DWORD  key  )

static

Definition at line 37 of file queue.c.

{
    return ((RTWQWORKITEM_KEY)mask << 32) | key;
}

Referenced by generate_item_key(), and RtwqRemovePeriodicCallback().

get_queue_obj()

static struct queue_handle * get_queue_obj ( DWORD  handle )

static

Definition at line 72 of file queue.c.

{
    unsigned int idx = HIWORD(handle) - FIRST_USER_QUEUE_HANDLE;
 
    if (idx < MAX_USER_QUEUE_HANDLES && user_queues[idx].refcount)
    {
        if (LOWORD(handle) == user_queues[idx].generation)
            return &user_queues[idx];
    }
 
    return NULL;
}

Referenced by grab_queue(), lock_user_queue(), and unlock_user_queue().

get_system_queue()

static struct queue * get_system_queue ( DWORD  queue_id )

static

Definition at line 297 of file queue.c.

{
    switch (queue_id)
    {
        case RTWQ_CALLBACK_QUEUE_STANDARD:
        case RTWQ_CALLBACK_QUEUE_RT:
        case RTWQ_CALLBACK_QUEUE_IO:
        case RTWQ_CALLBACK_QUEUE_TIMER:
        case RTWQ_CALLBACK_QUEUE_MULTITHREADED:
        case RTWQ_CALLBACK_QUEUE_LONG_FUNCTION:
            return &system_queues[queue_id - 1];
        default:
            return NULL;
    }
}

Referenced by grab_queue().

grab_queue()

static HRESULT grab_queue ( DWORD  queue_id, struct queue **  ret  )

static

Definition at line 623 of file queue.c.

{
    struct queue *queue = get_system_queue(queue_id);
    RTWQ_WORKQUEUE_TYPE queue_type;
    struct queue_handle *entry;
 
    *ret = NULL;
 
    if (!system_queues[SYS_QUEUE_STANDARD].pool)
        return RTWQ_E_SHUTDOWN;
 
    if (queue && queue->pool)
    {
        *ret = queue;
        return S_OK;
    }
    else if (queue)
    {
        struct queue_desc desc;
 
        EnterCriticalSection(&queues_section);
        switch (queue_id)
        {
            case RTWQ_CALLBACK_QUEUE_IO:
            case RTWQ_CALLBACK_QUEUE_MULTITHREADED:
            case RTWQ_CALLBACK_QUEUE_LONG_FUNCTION:
                queue_type = RTWQ_MULTITHREADED_WORKQUEUE;
                break;
            default:
                queue_type = RTWQ_STANDARD_WORKQUEUE;
        }
 
        desc.queue_type = queue_type;
        desc.ops = &pool_queue_ops;
        desc.target_queue = 0;
        init_work_queue(&desc, queue);
        LeaveCriticalSection(&queues_section);
        *ret = queue;
        return S_OK;
    }
 
    /* Handles user queues. */
    if ((entry = get_queue_obj(queue_id)))
        *ret = entry->obj;
 
    return *ret ? S_OK : RTWQ_E_INVALID_WORKQUEUE;
}

Referenced by queue_put_work_item(), RtwqAddPeriodicCallback(), RtwqCancelWorkItem(), RtwqPutWaitingWorkItem(), RtwqRemovePeriodicCallback(), RtwqSetLongRunning(), schedule_work_item(), serial_queue_finalization_callback(), and serial_queue_submit().

impl_from_IRtwqAsyncCallback()

static struct periodic_callback * impl_from_IRtwqAsyncCallback ( IRtwqAsyncCallback *  iface )

static

Definition at line 1290 of file queue.c.

{
    return CONTAINING_RECORD(iface, struct periodic_callback, IRtwqAsyncCallback_iface);
}

Referenced by periodic_callback_AddRef(), periodic_callback_Invoke(), and periodic_callback_Release().

impl_from_IRtwqAsyncResult()

static struct async_result * impl_from_IRtwqAsyncResult ( IRtwqAsyncResult *  iface )

static

Definition at line 1000 of file queue.c.

{
    return CONTAINING_RECORD(iface, struct async_result, result.AsyncResult);
}

Referenced by async_result_AddRef(), async_result_GetObject(), async_result_GetState(), async_result_GetStateNoAddRef(), async_result_GetStatus(), async_result_Release(), and async_result_SetStatus().

init_system_queues()

static void init_system_queues ( void  )

static

Definition at line 1181 of file queue.c.

{
    struct queue_desc desc;
    HRESULT hr;
 
    /* Always initialize standard queue, keep the rest lazy. */
 
    EnterCriticalSection(&queues_section);
 
    if (system_queues[SYS_QUEUE_STANDARD].pool)
    {
        LeaveCriticalSection(&queues_section);
        return;
    }
 
    if (FAILED(hr = CoIncrementMTAUsage(&mta_cookie)))
        WARN("Failed to initialize MTA, hr %#lx.\n", hr);
 
    desc.queue_type = RTWQ_STANDARD_WORKQUEUE;
    desc.ops = &pool_queue_ops;
    desc.target_queue = 0;
    init_work_queue(&desc, &system_queues[SYS_QUEUE_STANDARD]);
 
    LeaveCriticalSection(&queues_section);
}

Referenced by RtwqStartup().

init_work_queue()

static void init_work_queue ( const struct queue_desc *  desc, struct queue *  queue  )

static

Definition at line 611 of file queue.c.

{
    assert(desc->ops != NULL);
 
    queue->ops = desc->ops;
    if (SUCCEEDED(queue->ops->init(desc, queue)))
    {
        list_init(&queue->pending_items);
        InitializeCriticalSection(&queue->cs);
    }
}

Referenced by alloc_user_queue(), grab_queue(), and init_system_queues().

invoke_async_callback()

static HRESULT invoke_async_callback ( IRtwqAsyncResult *  result )

static

Definition at line 714 of file queue.c.

{
    RTWQASYNCRESULT *result_data = (RTWQASYNCRESULT *)result;
    DWORD queue = RTWQ_CALLBACK_QUEUE_STANDARD, flags;
    HRESULT hr;
 
    if (FAILED(IRtwqAsyncCallback_GetParameters(result_data->pCallback, &flags, &queue)))
        queue = RTWQ_CALLBACK_QUEUE_STANDARD;
 
    if (FAILED(lock_user_queue(queue)))
        queue = RTWQ_CALLBACK_QUEUE_STANDARD;
 
    hr = queue_put_work_item(queue, 0, result);
 
    unlock_user_queue(queue);
 
    return hr;
}

Referenced by periodic_item_callback(), queue_cancel_item(), RtwqInvokeCallback(), scheduled_item_callback(), scheduled_item_cancelable_callback(), waiting_item_callback(), and waiting_item_cancelable_callback().

lock_user_queue()

static HRESULT lock_user_queue ( DWORD  queue )

static

Definition at line 194 of file queue.c.

{
    HRESULT hr = RTWQ_E_INVALID_WORKQUEUE;
    struct queue_handle *entry;
 
    if (!(queue & RTWQ_CALLBACK_QUEUE_PRIVATE_MASK))
        return S_OK;
 
    EnterCriticalSection(&queues_section);
    entry = get_queue_obj(queue);
    if (entry && entry->refcount)
    {
        entry->refcount++;
        hr = S_OK;
    }
    LeaveCriticalSection(&queues_section);
    return hr;
}

Referenced by invoke_async_callback(), RtwqLockSharedWorkQueue(), RtwqLockWorkQueue(), RtwqSetLongRunning(), and serial_queue_init().

periodic_callback_AddRef()

static ULONG WINAPI periodic_callback_AddRef ( IRtwqAsyncCallback *  iface )

static

Definition at line 1309 of file queue.c.

{
    struct periodic_callback *callback = impl_from_IRtwqAsyncCallback(iface);
    ULONG refcount = InterlockedIncrement(&callback->refcount);
 
    TRACE("%p, %lu.\n", iface, refcount);
 
    return refcount;
}

periodic_callback_GetParameters()

static HRESULT WINAPI periodic_callback_GetParameters ( IRtwqAsyncCallback *  iface, DWORD *  flags, DWORD *  queue  )

static

Definition at line 1332 of file queue.c.

{
    return E_NOTIMPL;
}

periodic_callback_Invoke()

static HRESULT WINAPI periodic_callback_Invoke ( IRtwqAsyncCallback *  iface, IRtwqAsyncResult *  result  )

static

Definition at line 1337 of file queue.c.

{
    struct periodic_callback *callback = impl_from_IRtwqAsyncCallback(iface);
    IUnknown *context = NULL;
 
    if (FAILED(IRtwqAsyncResult_GetObject(result, &context)))
        WARN("Expected object to be set for result object.\n");
 
    callback->callback(context);
 
    if (context)
        IUnknown_Release(context);
 
    return S_OK;
}

periodic_callback_QueryInterface()

static HRESULT WINAPI periodic_callback_QueryInterface ( IRtwqAsyncCallback *  iface, REFIID  riid, void **  obj  )

static

Definition at line 1295 of file queue.c.

{
    if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IRtwqAsyncCallback_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

periodic_callback_Release()

static ULONG WINAPI periodic_callback_Release ( IRtwqAsyncCallback *  iface )

static

Definition at line 1319 of file queue.c.

{
    struct periodic_callback *callback = impl_from_IRtwqAsyncCallback(iface);
    ULONG refcount = InterlockedDecrement(&callback->refcount);
 
    TRACE("%p, %lu.\n", iface, refcount);
 
    if (!refcount)
        free(callback);
 
    return refcount;
}

periodic_item_callback()

static void CALLBACK periodic_item_callback ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_TIMER *  timer  )

static

Definition at line 800 of file queue.c.

{
    struct work_item *item = context;
 
    IUnknown_AddRef(&item->IUnknown_iface);
 
    invoke_async_callback(item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by queue_submit_timer().

pool_queue_init()

static HRESULT pool_queue_init ( const struct queue_desc *  desc, struct queue *  queue  )

static

Definition at line 319 of file queue.c.

{
    TP_CALLBACK_ENVIRON_V3 env;
    unsigned int max_thread, i;
 
    queue->pool = CreateThreadpool(NULL);
 
    memset(&env, 0, sizeof(env));
    env.Version = 3;
    env.Size = sizeof(env);
    env.Pool = queue->pool;
    env.CleanupGroup = CreateThreadpoolCleanupGroup();
    env.CleanupGroupCancelCallback = standard_queue_cleanup_callback;
    env.CallbackPriority = TP_CALLBACK_PRIORITY_NORMAL;
    for (i = 0; i < ARRAY_SIZE(queue->envs); ++i)
    {
        queue->envs[i] = env;
        queue->envs[i].CallbackPriority = priorities[i];
    }
    list_init(&queue->pending_items);
    InitializeCriticalSection(&queue->cs);
 
    max_thread = (desc->queue_type == RTWQ_STANDARD_WORKQUEUE || desc->queue_type == RTWQ_WINDOW_WORKQUEUE) ? 1 : 4;
 
    SetThreadpoolThreadMinimum(queue->pool, 1);
    SetThreadpoolThreadMaximum(queue->pool, max_thread);
 
    if (desc->queue_type == RTWQ_WINDOW_WORKQUEUE)
        FIXME("RTWQ_WINDOW_WORKQUEUE is not supported.\n");
 
    return S_OK;
}

pool_queue_shutdown()

static BOOL pool_queue_shutdown ( struct queue *  queue )

static

Definition at line 352 of file queue.c.

{
    if (!queue->pool)
        return FALSE;
 
    CloseThreadpoolCleanupGroupMembers(queue->envs[0].CleanupGroup, TRUE, NULL);
    CloseThreadpool(queue->pool);
    queue->pool = NULL;
 
    return TRUE;
}

pool_queue_submit()

static void pool_queue_submit ( struct queue *  queue, struct work_item *  item  )

static

Definition at line 380 of file queue.c.

{
    TP_CALLBACK_PRIORITY callback_priority;
    TP_CALLBACK_ENVIRON_V3 env;
 
    if (item->priority == 0)
        callback_priority = TP_CALLBACK_PRIORITY_NORMAL;
    else if (item->priority < 0)
        callback_priority = TP_CALLBACK_PRIORITY_LOW;
    else
        callback_priority = TP_CALLBACK_PRIORITY_HIGH;
 
    env = queue->envs[callback_priority];
    env.FinalizationCallback = item->finalization_callback;
    /* Worker pool callback will release one reference. Grab one more to keep object alive when
       we need finalization callback. */
    if (item->finalization_callback)
        IUnknown_AddRef(&item->IUnknown_iface);
    item->u.work_object = CreateThreadpoolWork(standard_queue_worker, item, (TP_CALLBACK_ENVIRON *)&env);
    item->type = WORK_ITEM_WORK;
    SubmitThreadpoolWork(item->u.work_object);
 
    TRACE("dispatched %p.\n", item->result);
}

queue_cancel_item()

static HRESULT queue_cancel_item ( struct queue *  queue, RTWQWORKITEM_KEY  key  )

static

Definition at line 884 of file queue.c.

{
    TP_WAIT *wait_object;
    TP_TIMER *timer_object;
    struct work_item *item;
 
    EnterCriticalSection(&queue->cs);
    LIST_FOR_EACH_ENTRY(item, &queue->pending_items, struct work_item, entry)
    {
        if (item->key == key)
        {
            /* We can't immediately release the item here, because the callback could already be
             * running somewhere else. And if we release it here, the callback will access freed memory.
             * So instead we have to make sure the callback is really stopped, or has really finished
             * running before we do that. And we can't do that in this critical section, which would be a
             * deadlock. So we first keep an extra reference to it, then leave the critical section to
             * wait for the thread-pool objects, finally we re-enter critical section to release it. */
            key >>= 32;
            IUnknown_AddRef(&item->IUnknown_iface);
            if ((key & WAIT_ITEM_KEY_MASK) == WAIT_ITEM_KEY_MASK)
            {
                wait_object = item->u.wait_object;
                item->u.wait_object = NULL;
                LeaveCriticalSection(&queue->cs);
 
                SetThreadpoolWait(wait_object, NULL, NULL);
                WaitForThreadpoolWaitCallbacks(wait_object, TRUE);
                CloseThreadpoolWait(wait_object);
            }
            else if ((key & SCHEDULED_ITEM_KEY_MASK) == SCHEDULED_ITEM_KEY_MASK)
            {
                timer_object = item->u.timer_object;
                item->u.timer_object = NULL;
                LeaveCriticalSection(&queue->cs);
 
                SetThreadpoolTimer(timer_object, NULL, 0, 0);
                WaitForThreadpoolTimerCallbacks(timer_object, TRUE);
                CloseThreadpoolTimer(timer_object);
            }
            else
            {
                WARN("Unknown item key mask %#I64x.\n", key);
                LeaveCriticalSection(&queue->cs);
            }
 
            if (queue_release_pending_item(item))
            {
                /* This means the callback wasn't run during our wait, so we can invoke the
                 * callback with a canceled status, and release the work item. */
                if ((key & WAIT_ITEM_KEY_MASK) == WAIT_ITEM_KEY_MASK)
                {
                    IRtwqAsyncResult_SetStatus(item->result, RTWQ_E_OPERATION_CANCELLED);
                    invoke_async_callback(item->result);
                }
                IUnknown_Release(&item->IUnknown_iface);
            }
            IUnknown_Release(&item->IUnknown_iface);
            return S_OK;
        }
    }
    LeaveCriticalSection(&queue->cs);
 
    return RTWQ_E_NOT_FOUND;
}

Referenced by RtwqCancelWorkItem(), and RtwqRemovePeriodicCallback().

queue_impl_from_IRtwqAsyncCallback()

static struct queue * queue_impl_from_IRtwqAsyncCallback ( IRtwqAsyncCallback *  iface )

static

Definition at line 239 of file queue.c.

{
    return CONTAINING_RECORD(iface, struct queue, IRtwqAsyncCallback_iface);
}

Referenced by queue_serial_callback_GetParameters().

queue_mark_item_pending()

static void queue_mark_item_pending ( DWORD  mask, struct work_item *  item, RTWQWORKITEM_KEY *  key  )

static

Definition at line 811 of file queue.c.

{
    *key = generate_item_key(mask);
    item->key = *key;
 
    EnterCriticalSection(&item->queue->cs);
    list_add_tail(&item->queue->pending_items, &item->entry);
    IUnknown_AddRef(&item->IUnknown_iface);
    LeaveCriticalSection(&item->queue->cs);
}

Referenced by queue_submit_timer(), and queue_submit_wait().

queue_put_work_item()

static HRESULT queue_put_work_item ( DWORD  queue_id, LONG  priority, IRtwqAsyncResult *  result  )

static

Definition at line 703 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
 
    if (FAILED(hr = grab_queue(queue_id, &queue)))
        return hr;
 
    return queue_submit_item(queue, priority, result);
}

Referenced by invoke_async_callback(), and RtwqPutWorkItem().

queue_release_pending_item()

static BOOL queue_release_pending_item ( struct work_item *  item )

static

Definition at line 735 of file queue.c.

{
    struct queue *queue = item->queue;
    BOOL ret = FALSE;
 
    EnterCriticalSection(&queue->cs);
    if (item->key)
    {
        list_remove(&item->entry);
        ret = TRUE;
        item->key = 0;
        IUnknown_Release(&item->IUnknown_iface);
    }
    LeaveCriticalSection(&queue->cs);
    return ret;
}

Referenced by queue_cancel_item(), scheduled_item_cancelable_callback(), and waiting_item_cancelable_callback().

queue_serial_callback_AddRef()

static ULONG WINAPI queue_serial_callback_AddRef ( IRtwqAsyncCallback *  iface )

static

Definition at line 258 of file queue.c.

{
    return 2;
}

queue_serial_callback_GetParameters()

static HRESULT WINAPI queue_serial_callback_GetParameters ( IRtwqAsyncCallback *  iface, DWORD *  flags, DWORD *  queue_id  )

static

Definition at line 268 of file queue.c.

{
    struct queue *queue = queue_impl_from_IRtwqAsyncCallback(iface);
 
    *flags = 0;
    *queue_id = queue->id;
 
    return S_OK;
}

queue_serial_callback_Invoke()

static HRESULT WINAPI queue_serial_callback_Invoke ( IRtwqAsyncCallback *  iface, IRtwqAsyncResult *  result  )

static

Definition at line 278 of file queue.c.

{
    /* Reply callback won't be called in a regular way, pending items and chained queues will make it
       unnecessary complicated to reach actual work queue that's able to execute this item. Instead
       serial queues are cleaned up right away on submit(). */
    return S_OK;
}

queue_serial_callback_QueryInterface()

static HRESULT WINAPI queue_serial_callback_QueryInterface ( IRtwqAsyncCallback *  iface, REFIID  riid, void **  obj  )

static

Definition at line 244 of file queue.c.

{
    if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
            IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IRtwqAsyncCallback_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

queue_serial_callback_Release()

static ULONG WINAPI queue_serial_callback_Release ( IRtwqAsyncCallback *  iface )

static

Definition at line 263 of file queue.c.

{
    return 1;
}

queue_submit_item()

static HRESULT queue_submit_item ( struct queue *  queue, LONG  priority, IRtwqAsyncResult *  result  )

static

Definition at line 691 of file queue.c.

{
    struct work_item *item;
 
    if (!(item = alloc_work_item(queue, priority, result)))
        return E_OUTOFMEMORY;
 
    queue->ops->submit(queue, item);
 
    return S_OK;
}

Referenced by queue_put_work_item().

queue_submit_timer()

static HRESULT queue_submit_timer ( struct queue *  queue, IRtwqAsyncResult *  result, INT64  timeout, DWORD  period, RTWQWORKITEM_KEY *  key  )

static

Definition at line 849 of file queue.c.

{
    PTP_TIMER_CALLBACK callback;
    struct work_item *item;
    FILETIME filetime;
    LARGE_INTEGER t;
 
    if (!(item = alloc_work_item(queue, 0, result)))
        return E_OUTOFMEMORY;
 
    if (key)
    {
        queue_mark_item_pending(SCHEDULED_ITEM_KEY_MASK, item, key);
    }
 
    if (period)
        callback = periodic_item_callback;
    else
        callback = key ? scheduled_item_cancelable_callback : scheduled_item_callback;
 
    t.QuadPart = timeout * 1000 * 10;
    filetime.dwLowDateTime = t.u.LowPart;
    filetime.dwHighDateTime = t.u.HighPart;
 
    item->u.timer_object = CreateThreadpoolTimer(callback, item,
            (TP_CALLBACK_ENVIRON *)&queue->envs[TP_CALLBACK_PRIORITY_NORMAL]);
    item->type = WORK_ITEM_TIMER;
    SetThreadpoolTimer(item->u.timer_object, &filetime, period, 0);
 
    TRACE("dispatched %p.\n", result);
 
    return S_OK;
}

Referenced by RtwqAddPeriodicCallback(), and schedule_work_item().

queue_submit_wait()

static HRESULT queue_submit_wait ( struct queue *  queue, HANDLE  event, LONG  priority, IRtwqAsyncResult *  result, RTWQWORKITEM_KEY *  key  )

static

Definition at line 822 of file queue.c.

{
    PTP_WAIT_CALLBACK callback;
    struct work_item *item;
 
    if (!(item = alloc_work_item(queue, priority, result)))
        return E_OUTOFMEMORY;
 
    if (key)
    {
        queue_mark_item_pending(WAIT_ITEM_KEY_MASK, item, key);
        callback = waiting_item_cancelable_callback;
    }
    else
        callback = waiting_item_callback;
 
    item->u.wait_object = CreateThreadpoolWait(callback, item,
            (TP_CALLBACK_ENVIRON *)&queue->envs[TP_CALLBACK_PRIORITY_NORMAL]);
    item->type = WORK_ITEM_WAIT;
    SetThreadpoolWait(item->u.wait_object, event, NULL);
 
    TRACE("dispatched %p.\n", result);
 
    return S_OK;
}

Referenced by RtwqPutWaitingWorkItem().

RtwqAddPeriodicCallback()

HRESULT WINAPI RtwqAddPeriodicCallback	(	RTWQPERIODICCALLBACK	callback,
		IUnknown *	context,
		DWORD *	key
	)

Definition at line 1378 of file queue.c.

{
    IRtwqAsyncCallback *periodic_callback;
    RTWQWORKITEM_KEY workitem_key;
    IRtwqAsyncResult *result;
    struct queue *queue;
    HRESULT hr;
 
    TRACE("%p, %p, %p.\n", callback, context, key);
 
    if (FAILED(hr = grab_queue(RTWQ_CALLBACK_QUEUE_TIMER, &queue)))
        return hr;
 
    if (FAILED(hr = create_periodic_callback_obj(callback, &periodic_callback)))
        return hr;
 
    hr = create_async_result(context, periodic_callback, NULL, &result);
    IRtwqAsyncCallback_Release(periodic_callback);
    if (FAILED(hr))
        return hr;
 
    /* Same period MFGetTimerPeriodicity() returns. */
    hr = queue_submit_timer(queue, result, 0, 10, key ? &workitem_key : NULL);
 
    IRtwqAsyncResult_Release(result);
 
    if (key)
        *key = workitem_key;
 
    return S_OK;
}

RtwqAllocateSerialWorkQueue()

HRESULT WINAPI RtwqAllocateSerialWorkQueue	(	DWORD	target_queue,
		DWORD *	queue
	)

Definition at line 1553 of file queue.c.

{
    struct queue_desc desc;
 
    TRACE("%#lx, %p.\n", target_queue, queue);
 
    desc.queue_type = RTWQ_STANDARD_WORKQUEUE;
    desc.ops = &serial_queue_ops;
    desc.target_queue = target_queue;
    return alloc_user_queue(&desc, queue);
}

RtwqAllocateWorkQueue()

HRESULT WINAPI RtwqAllocateWorkQueue	(	RTWQ_WORKQUEUE_TYPE	queue_type,
		DWORD *	queue
	)

Definition at line 1450 of file queue.c.

{
    struct queue_desc desc;
 
    TRACE("%d, %p.\n", queue_type, queue);
 
    desc.queue_type = queue_type;
    desc.ops = &pool_queue_ops;
    desc.target_queue = 0;
    return alloc_user_queue(&desc, queue);
}

RtwqBeginRegisterWorkQueueWithMMCSS()

HRESULT WINAPI RtwqBeginRegisterWorkQueueWithMMCSS	(	DWORD	queue,
		const WCHAR *	class,
		DWORD	taskid,
		LONG	priority,
		IRtwqAsyncCallback *	callback,
		IUnknown *	state
	)

Definition at line 1614 of file queue.c.

{
    FIXME("%#lx, %s, %lu, %ld, %p, %p.\n", queue, debugstr_w(class), taskid, priority, callback, state);
 
    return E_NOTIMPL;
}

RtwqBeginUnregisterWorkQueueWithMMCSS()

HRESULT WINAPI RtwqBeginUnregisterWorkQueueWithMMCSS	(	DWORD	queue,
		IRtwqAsyncCallback *	callback,
		IUnknown *	state
	)

Definition at line 1629 of file queue.c.

{
    FIXME("%#lx, %p, %p.\n", queue, callback, state);
 
    return E_NOTIMPL;
}

RtwqCancelDeadline()

HRESULT WINAPI RtwqCancelDeadline

(

HANDLE

request

)

Definition at line 1546 of file queue.c.

{
    FIXME("%p.\n", request);
 
    return E_NOTIMPL;
}

RtwqCancelWorkItem()

HRESULT WINAPI RtwqCancelWorkItem

(

RTWQWORKITEM_KEY

key

)

Definition at line 1423 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
 
    TRACE("%s.\n", wine_dbgstr_longlong(key));
 
    if (FAILED(hr = grab_queue(RTWQ_CALLBACK_QUEUE_TIMER, &queue)))
        return hr;
 
    return queue_cancel_item(queue, key);
}

RtwqCreateAsyncResult()

HRESULT WINAPI RtwqCreateAsyncResult	(	IUnknown *	object,
		IRtwqAsyncCallback *	callback,
		IUnknown *	state,
		IRtwqAsyncResult **	out
	)

Definition at line 1159 of file queue.c.

{
    TRACE("%p, %p, %p, %p.\n", object, callback, state, out);
 
    return create_async_result(object, callback, state, out);
}

Referenced by serial_queue_submit().

RtwqEndRegisterWorkQueueWithMMCSS()

HRESULT WINAPI RtwqEndRegisterWorkQueueWithMMCSS	(	IRtwqAsyncResult *	result,
		DWORD *	taskid
	)

Definition at line 1622 of file queue.c.

{
    FIXME("%p, %p.\n", result, taskid);
 
    return E_NOTIMPL;
}

RtwqEndUnregisterWorkQueueWithMMCSS()

HRESULT WINAPI RtwqEndUnregisterWorkQueueWithMMCSS

(

IRtwqAsyncResult *

result

)

Definition at line 1636 of file queue.c.

{
    FIXME("%p.\n", result);
 
    return E_NOTIMPL;
}

RtwqGetWorkQueueMMCSSClass()

HRESULT WINAPI RtwqGetWorkQueueMMCSSClass	(	DWORD	queue,
		WCHAR *	class,
		DWORD *	length
	)

Definition at line 1579 of file queue.c.

{
    FIXME("%#lx, %p, %p.\n", queue, class, length);
 
    return E_NOTIMPL;
}

RtwqGetWorkQueueMMCSSPriority()

HRESULT WINAPI RtwqGetWorkQueueMMCSSPriority	(	DWORD	queue,
		LONG *	priority
	)

Definition at line 1593 of file queue.c.

{
    FIXME("%#lx, %p.\n", queue, priority);
 
    return E_NOTIMPL;
}

RtwqGetWorkQueueMMCSSTaskId()

HRESULT WINAPI RtwqGetWorkQueueMMCSSTaskId	(	DWORD	queue,
		DWORD *	taskid
	)

Definition at line 1586 of file queue.c.

{
    FIXME("%#lx, %p.\n", queue, taskid);
 
    return E_NOTIMPL;
}

RtwqInvokeCallback()

HRESULT WINAPI RtwqInvokeCallback

(

IRtwqAsyncResult *

result

)

Definition at line 1436 of file queue.c.

{
    TRACE("%p.\n", result);
 
    return invoke_async_callback(result);
}

RtwqJoinWorkQueue()

HRESULT WINAPI RtwqJoinWorkQueue	(	DWORD	queue,
		HANDLE	hFile,
		HANDLE *	cookie
	)

Definition at line 1565 of file queue.c.

{
    FIXME("%#lx, %p, %p.\n", queue, hFile, cookie);
 
    return E_NOTIMPL;
}

RtwqLockPlatform()

HRESULT WINAPI RtwqLockPlatform

(

void

)

Definition at line 1167 of file queue.c.

{
    InterlockedIncrement(&platform_lock);
 
    return S_OK;
}

Referenced by create_async_result().

RtwqLockSharedWorkQueue()

HRESULT WINAPI RtwqLockSharedWorkQueue	(	const WCHAR *	usageclass,
		LONG	priority,
		DWORD *	taskid,
		DWORD *	queue
	)

Definition at line 1497 of file queue.c.

{
    struct queue_desc desc;
    HRESULT hr;
 
    TRACE("%s, %ld, %p, %p.\n", debugstr_w(usageclass), priority, taskid, queue);
 
    if (!usageclass)
        return E_POINTER;
 
    if (!*usageclass && taskid)
        return E_INVALIDARG;
 
    if (*usageclass)
        FIXME("Class name is ignored.\n");
 
    EnterCriticalSection(&queues_section);
 
    if (shared_mt_queue)
        hr = lock_user_queue(shared_mt_queue);
    else
    {
        desc.queue_type = RTWQ_MULTITHREADED_WORKQUEUE;
        desc.ops = &pool_queue_ops;
        desc.target_queue = 0;
        hr = alloc_user_queue(&desc, &shared_mt_queue);
    }
 
    *queue = shared_mt_queue;
 
    LeaveCriticalSection(&queues_section);
 
    return hr;
}

RtwqLockWorkQueue()

HRESULT WINAPI RtwqLockWorkQueue

(

DWORD

queue

)

Definition at line 1462 of file queue.c.

{
    TRACE("%#lx.\n", queue);
 
    return lock_user_queue(queue);
}

RtwqPutWaitingWorkItem()

HRESULT WINAPI RtwqPutWaitingWorkItem	(	HANDLE	event,
		LONG	priority,
		IRtwqAsyncResult *	result,
		RTWQWORKITEM_KEY *	key
	)

Definition at line 1248 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
 
    TRACE("%p, %ld, %p, %p.\n", event, priority, result, key);
 
    if (FAILED(hr = grab_queue(RTWQ_CALLBACK_QUEUE_TIMER, &queue)))
        return hr;
 
    hr = queue_submit_wait(queue, event, priority, result, key);
 
    return hr;
}

RtwqPutWorkItem()

HRESULT WINAPI RtwqPutWorkItem	(	DWORD	queue,
		LONG	priority,
		IRtwqAsyncResult *	result
	)

Definition at line 1443 of file queue.c.

{
    TRACE("%#lx, %ld, %p.\n", queue, priority, result);
 
    return queue_put_work_item(queue, priority, result);
}

RtwqRegisterPlatformEvents()

HRESULT WINAPI RtwqRegisterPlatformEvents

(

IRtwqPlatformEvents *

events

)

Definition at line 1643 of file queue.c.

{
    FIXME("%p.\n", events);
 
    return E_NOTIMPL;
}

RtwqRegisterPlatformWithMMCSS()

HRESULT WINAPI RtwqRegisterPlatformWithMMCSS	(	const WCHAR *	class,
		DWORD *	taskid,
		LONG	priority
	)

Definition at line 1600 of file queue.c.

{
    FIXME("%s, %p, %ld.\n", debugstr_w(class), taskid, priority);
 
    return E_NOTIMPL;
}

RtwqRemovePeriodicCallback()

HRESULT WINAPI RtwqRemovePeriodicCallback

(

DWORD

key

)

Definition at line 1410 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
 
    TRACE("%#lx.\n", key);
 
    if (FAILED(hr = grab_queue(RTWQ_CALLBACK_QUEUE_TIMER, &queue)))
        return hr;
 
    return queue_cancel_item(queue, get_item_key(SCHEDULED_ITEM_KEY_MASK, key));
}

RtwqScheduleWorkItem()

HRESULT WINAPI RtwqScheduleWorkItem	(	IRtwqAsyncResult *	result,
		INT64	timeout,
		RTWQWORKITEM_KEY *	key
	)

Definition at line 1276 of file queue.c.

{
    TRACE("%p, %s, %p.\n", result, wine_dbgstr_longlong(timeout), key);
 
    return schedule_work_item(result, timeout, key);
}

RtwqSetDeadline()

HRESULT WINAPI RtwqSetDeadline	(	DWORD	queue_id,
		LONGLONG	deadline,
		HANDLE *	request
	)

Definition at line 1532 of file queue.c.

{
    FIXME("%#lx, %s, %p.\n", queue_id, wine_dbgstr_longlong(deadline), request);
 
    return E_NOTIMPL;
}

RtwqSetDeadline2()

HRESULT WINAPI RtwqSetDeadline2	(	DWORD	queue_id,
		LONGLONG	deadline,
		LONGLONG	predeadline,
		HANDLE *	request
	)

Definition at line 1539 of file queue.c.

{
    FIXME("%#lx, %s, %s, %p.\n", queue_id, wine_dbgstr_longlong(deadline), wine_dbgstr_longlong(predeadline), request);
 
    return E_NOTIMPL;
}

RtwqSetLongRunning()

HRESULT WINAPI RtwqSetLongRunning	(	DWORD	queue_id,
		BOOL	enable
	)

Definition at line 1476 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
    int i;
 
    TRACE("%#lx, %d.\n", queue_id, enable);
 
    lock_user_queue(queue_id);
 
    if (SUCCEEDED(hr = grab_queue(queue_id, &queue)))
    {
        for (i = 0; i < ARRAY_SIZE(queue->envs); ++i)
            queue->envs[i].u.s.LongFunction = !!enable;
    }
 
    unlock_user_queue(queue_id);
 
    return hr;
}

RtwqShutdown()

HRESULT WINAPI RtwqShutdown

(

void

)

Definition at line 1235 of file queue.c.

{
    if (platform_lock <= 0)
        return S_OK;
 
    if (InterlockedExchangeAdd(&platform_lock, -1) == 1)
    {
        shutdown_system_queues();
    }
 
    return S_OK;
}

Referenced by test_platform_init().

RtwqStartup()

HRESULT WINAPI RtwqStartup

(

void

)

Definition at line 1207 of file queue.c.

{
    if (InterlockedIncrement(&platform_lock) == 1)
    {
        init_system_queues();
    }
 
    return S_OK;
}

Referenced by test_platform_init().

RtwqUnjoinWorkQueue()

HRESULT WINAPI RtwqUnjoinWorkQueue	(	DWORD	queue,
		HANDLE	cookie
	)

Definition at line 1572 of file queue.c.

{
    FIXME("%#lx, %p.\n", queue, cookie);
 
    return E_NOTIMPL;
}

RtwqUnlockPlatform()

HRESULT WINAPI RtwqUnlockPlatform

(

void

)

Definition at line 1174 of file queue.c.

{
    InterlockedDecrement(&platform_lock);
 
    return S_OK;
}

Referenced by async_result_Release().

RtwqUnlockWorkQueue()

HRESULT WINAPI RtwqUnlockWorkQueue

(

DWORD

queue

)

Definition at line 1469 of file queue.c.

{
    TRACE("%#lx.\n", queue);
 
    return unlock_user_queue(queue);
}

RtwqUnregisterPlatformEvents()

HRESULT WINAPI RtwqUnregisterPlatformEvents

(

IRtwqPlatformEvents *

events

)

Definition at line 1650 of file queue.c.

{
    FIXME("%p.\n", events);
 
    return E_NOTIMPL;
}

RtwqUnregisterPlatformFromMMCSS()

HRESULT WINAPI RtwqUnregisterPlatformFromMMCSS

(

void

)

Definition at line 1607 of file queue.c.

{
    FIXME("\n");
 
    return E_NOTIMPL;
}

schedule_work_item()

static HRESULT schedule_work_item ( IRtwqAsyncResult *  result, INT64  timeout, RTWQWORKITEM_KEY *  key  )

static

Definition at line 1263 of file queue.c.

{
    struct queue *queue;
    HRESULT hr;
 
    if (FAILED(hr = grab_queue(RTWQ_CALLBACK_QUEUE_TIMER, &queue)))
        return hr;
 
    TRACE("%p, %s, %p.\n", result, wine_dbgstr_longlong(timeout), key);
 
    return queue_submit_timer(queue, result, timeout, 0, key);
}

Referenced by RtwqScheduleWorkItem().

scheduled_item_callback()

static void CALLBACK scheduled_item_callback ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_TIMER *  timer  )

static

Definition at line 777 of file queue.c.

{
    struct work_item *item = context;
 
    TRACE("result object %p.\n", item->result);
 
    invoke_async_callback(item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by queue_submit_timer().

scheduled_item_cancelable_callback()

static void CALLBACK scheduled_item_cancelable_callback ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_TIMER *  timer  )

static

Definition at line 788 of file queue.c.

{
    struct work_item *item = context;
 
    TRACE("result object %p.\n", item->result);
 
    if (queue_release_pending_item(item))
        invoke_async_callback(item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by queue_submit_timer().

serial_queue_finalization_callback()

static void CALLBACK serial_queue_finalization_callback ( PTP_CALLBACK_INSTANCE  instance, void *  user_data  )

static

Definition at line 423 of file queue.c.

{
    struct work_item *item = (struct work_item *)user_data, *next_item;
    struct queue *target_queue, *queue = item->queue;
    HRESULT hr;
 
    EnterCriticalSection(&queue->cs);
 
    if ((next_item = serial_queue_get_next(queue, item)))
    {
        if (SUCCEEDED(hr = grab_queue(queue->target_queue, &target_queue)))
            target_queue->ops->submit(target_queue, next_item);
        else
            WARN("Failed to grab queue for id %#lx, hr %#lx.\n", queue->target_queue, hr);
    }
 
    LeaveCriticalSection(&queue->cs);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by serial_queue_init().

serial_queue_get_next()

static struct work_item * serial_queue_get_next ( struct queue *  queue, struct work_item *  item  )

static

Definition at line 412 of file queue.c.

{
    struct work_item *next_item = NULL;
 
    list_remove(&item->entry);
    if (!list_empty(&item->queue->pending_items))
        next_item = LIST_ENTRY(list_head(&item->queue->pending_items), struct work_item, entry);
 
    return next_item;
}

Referenced by serial_queue_finalization_callback(), and serial_queue_submit().

serial_queue_init()

static HRESULT serial_queue_init ( const struct queue_desc *  desc, struct queue *  queue  )

static

Definition at line 444 of file queue.c.

{
    queue->IRtwqAsyncCallback_iface.lpVtbl = &queue_serial_callback_vtbl;
    queue->target_queue = desc->target_queue;
    lock_user_queue(queue->target_queue);
    queue->finalization_callback = serial_queue_finalization_callback;
 
    return S_OK;
}

serial_queue_is_ack_token()

static struct work_item * serial_queue_is_ack_token ( struct queue *  queue, struct work_item *  item  )

static

Definition at line 461 of file queue.c.

{
    RTWQASYNCRESULT *async_result = (RTWQASYNCRESULT *)item->result;
    struct work_item *head;
 
    if (list_empty(&queue->pending_items))
        return NULL;
 
    head = LIST_ENTRY(list_head(&queue->pending_items), struct work_item, entry);
    if (head->reply_result == item->result && async_result->pCallback == &queue->IRtwqAsyncCallback_iface)
        return head;
 
    return NULL;
}

Referenced by serial_queue_submit().

serial_queue_shutdown()

static BOOL serial_queue_shutdown ( struct queue *  queue )

static

Definition at line 454 of file queue.c.

{
    unlock_user_queue(queue->target_queue);
 
    return TRUE;
}

serial_queue_submit()

static void serial_queue_submit ( struct queue *  queue, struct work_item *  item  )

static

Definition at line 476 of file queue.c.

{
    struct work_item *head, *next_item = NULL;
    struct queue *target_queue;
    HRESULT hr;
 
    /* In reply mode queue will advance when 'reply_result' is invoked, in regular mode it will advance automatically,
       via finalization callback. */
 
    if (item->flags & RTWQ_REPLY_CALLBACK)
    {
        if (FAILED(hr = RtwqCreateAsyncResult(NULL, &queue->IRtwqAsyncCallback_iface, NULL, &item->reply_result)))
            WARN("Failed to create reply object, hr %#lx.\n", hr);
    }
    else
        item->finalization_callback = queue->finalization_callback;
 
    /* Serial queues could be chained together, detach from current queue before transitioning item to this one.
       Items are not detached when submitted to pool queues, because pool queues won't forward them further. */
    EnterCriticalSection(&item->queue->cs);
    list_remove(&item->entry);
    LeaveCriticalSection(&item->queue->cs);
 
    EnterCriticalSection(&queue->cs);
 
    item->queue = queue;
 
    if ((head = serial_queue_is_ack_token(queue, item)))
    {
        /* Ack receipt token - pop waiting item, advance. */
        next_item = serial_queue_get_next(queue, head);
        IUnknown_Release(&head->IUnknown_iface);
    }
    else
    {
        if (list_empty(&queue->pending_items))
            next_item = item;
        list_add_tail(&queue->pending_items, &item->entry);
        IUnknown_AddRef(&item->IUnknown_iface);
    }
 
    if (next_item)
    {
        if (SUCCEEDED(hr = grab_queue(queue->target_queue, &target_queue)))
            target_queue->ops->submit(target_queue, next_item);
        else
            WARN("Failed to grab queue for id %#lx, hr %#lx.\n", queue->target_queue, hr);
    }
 
    LeaveCriticalSection(&queue->cs);
}

shutdown_queue()

static void shutdown_queue ( struct queue *  queue )

static

Definition at line 671 of file queue.c.

{
    struct work_item *item, *item2;
 
    if (!queue->ops || !queue->ops->shutdown(queue))
        return;
 
    EnterCriticalSection(&queue->cs);
    LIST_FOR_EACH_ENTRY_SAFE(item, item2, &queue->pending_items, struct work_item, entry)
    {
        list_remove(&item->entry);
        IUnknown_Release(&item->IUnknown_iface);
    }
    LeaveCriticalSection(&queue->cs);
 
    DeleteCriticalSection(&queue->cs);
 
    memset(queue, 0, sizeof(*queue));
}

Referenced by shutdown_system_queues(), and unlock_user_queue().

shutdown_system_queues()

static void shutdown_system_queues ( void  )

static

Definition at line 1217 of file queue.c.

{
    unsigned int i;
    HRESULT hr;
 
    EnterCriticalSection(&queues_section);
 
    for (i = 0; i < ARRAY_SIZE(system_queues); ++i)
    {
        shutdown_queue(&system_queues[i]);
    }
 
    if (FAILED(hr = CoDecrementMTAUsage(mta_cookie)))
        WARN("Failed to uninitialize MTA, hr %#lx.\n", hr);
 
    LeaveCriticalSection(&queues_section);
}

Referenced by RtwqShutdown().

standard_queue_cleanup_callback()

static void CALLBACK standard_queue_cleanup_callback ( void *  object_data, void *  group_data  )

static

Definition at line 315 of file queue.c.

{
}

Referenced by pool_queue_init().

standard_queue_worker()

static void CALLBACK standard_queue_worker ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_WORK *  work  )

static

Definition at line 364 of file queue.c.

{
    struct work_item *item = context;
    RTWQASYNCRESULT *result = (RTWQASYNCRESULT *)item->result;
 
    TRACE("result object %p.\n", result);
 
    /* Submitting from serial queue in reply mode, use different result object acting as receipt token.
       It's submitted to user callback still, but when invoked, special serial queue callback will be used
       to ensure correct destination queue. */
 
    IRtwqAsyncCallback_Invoke(result->pCallback, item->reply_result ? item->reply_result : item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by pool_queue_submit().

unlock_user_queue()

static HRESULT unlock_user_queue ( DWORD  queue )

static

Definition at line 213 of file queue.c.

{
    HRESULT hr = RTWQ_E_INVALID_WORKQUEUE;
    struct queue_handle *entry;
 
    if (!(queue & RTWQ_CALLBACK_QUEUE_PRIVATE_MASK))
        return S_OK;
 
    EnterCriticalSection(&queues_section);
    entry = get_queue_obj(queue);
    if (entry && entry->refcount)
    {
        if (--entry->refcount == 0)
        {
            if (shared_mt_queue == queue) shared_mt_queue = 0;
            shutdown_queue((struct queue *)entry->obj);
            free(entry->obj);
            entry->obj = next_free_user_queue;
            next_free_user_queue = entry;
        }
        hr = S_OK;
    }
    LeaveCriticalSection(&queues_section);
    return hr;
}

Referenced by invoke_async_callback(), RtwqSetLongRunning(), RtwqUnlockWorkQueue(), and serial_queue_shutdown().

waiting_item_callback()

static void CALLBACK waiting_item_callback ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_WAIT *  wait, TP_WAIT_RESULT  wait_result  )

static

Definition at line 752 of file queue.c.

{
    struct work_item *item = context;
 
    TRACE("result object %p.\n", item->result);
 
    invoke_async_callback(item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by queue_submit_wait().

waiting_item_cancelable_callback()

static void CALLBACK waiting_item_cancelable_callback ( TP_CALLBACK_INSTANCE *  instance, void *  context, TP_WAIT *  wait, TP_WAIT_RESULT  wait_result  )

static

Definition at line 764 of file queue.c.

{
    struct work_item *item = context;
 
    TRACE("result object %p.\n", item->result);
 
    if (queue_release_pending_item(item))
        invoke_async_callback(item->result);
 
    IUnknown_Release(&item->IUnknown_iface);
}

Referenced by queue_submit_wait().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mfplat

)

work_item_AddRef()

static ULONG WINAPI work_item_AddRef ( IUnknown *  iface )

static

Definition at line 548 of file queue.c.

{
    struct work_item *item = work_item_impl_from_IUnknown(iface);
    return InterlockedIncrement(&item->refcount);
}

work_item_impl_from_IUnknown()

static struct work_item * work_item_impl_from_IUnknown ( IUnknown *  iface )

static

Definition at line 149 of file queue.c.

{
    return CONTAINING_RECORD(iface, struct work_item, IUnknown_iface);
}

Referenced by work_item_AddRef(), and work_item_Release().

work_item_QueryInterface()

static HRESULT WINAPI work_item_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  obj  )

static

Definition at line 535 of file queue.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        *obj = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    *obj = NULL;
    return E_NOINTERFACE;
}

work_item_Release()

static ULONG WINAPI work_item_Release ( IUnknown *  iface )

static

Definition at line 554 of file queue.c.

{
    struct work_item *item = work_item_impl_from_IUnknown(iface);
    ULONG refcount = InterlockedDecrement(&item->refcount);
 
    if (!refcount)
    {
        switch (item->type)
        {
            case WORK_ITEM_WORK:
                if (item->u.work_object) CloseThreadpoolWork(item->u.work_object);
                break;
            case WORK_ITEM_WAIT:
                if (item->u.wait_object) CloseThreadpoolWait(item->u.wait_object);
                break;
            case WORK_ITEM_TIMER:
                if (item->u.timer_object) CloseThreadpoolTimer(item->u.timer_object);
                break;
        }
        if (item->reply_result)
            IRtwqAsyncResult_Release(item->reply_result);
        IRtwqAsyncResult_Release(item->result);
        free(item);
    }
 
    return refcount;
}

Variable Documentation

async_result_vtbl

const IRtwqAsyncResultVtbl async_result_vtbl

static

Initial value:

=
{
    async_result_QueryInterface,
    async_result_AddRef,
    async_result_Release,
    async_result_GetState,
    async_result_GetStatus,
    async_result_SetStatus,
    async_result_GetObject,
    async_result_GetStateNoAddRef,
}

Definition at line 1116 of file queue.c.

Referenced by create_async_result().

mta_cookie

CO_MTA_USAGE_COOKIE mta_cookie

static

Definition at line 70 of file queue.c.

next_free_user_queue

struct queue_handle* next_free_user_queue

static

Definition at line 55 of file queue.c.

Referenced by alloc_user_queue(), and unlock_user_queue().

next_item_key

LONG next_item_key

static

Definition at line 35 of file queue.c.

Referenced by generate_item_key().

next_unused_user_queue

struct queue_handle* next_unused_user_queue = user_queues

static

Definition at line 56 of file queue.c.

Referenced by alloc_user_queue().

periodic_callback_vtbl

const IRtwqAsyncCallbackVtbl periodic_callback_vtbl

static

Initial value:

=
{
    periodic_callback_QueryInterface,
    periodic_callback_AddRef,
    periodic_callback_Release,
    periodic_callback_GetParameters,
    periodic_callback_Invoke,
}

Definition at line 1353 of file queue.c.

Referenced by create_periodic_callback_obj().

platform_lock

LONG platform_lock

static

Definition at line 69 of file queue.c.

Referenced by alloc_user_queue(), RtwqLockPlatform(), RtwqShutdown(), RtwqStartup(), and RtwqUnlockPlatform().

pool_queue_ops

const struct queue_ops pool_queue_ops

static

Initial value:

=
{
    pool_queue_init,
    pool_queue_shutdown,
    pool_queue_submit,
}

Definition at line 405 of file queue.c.

Referenced by grab_queue(), init_system_queues(), RtwqAllocateWorkQueue(), and RtwqLockSharedWorkQueue().

priorities

const TP_CALLBACK_PRIORITY priorities[]

static

Initial value:

=
{
    TP_CALLBACK_PRIORITY_HIGH,
    TP_CALLBACK_PRIORITY_NORMAL,
    TP_CALLBACK_PRIORITY_LOW,
}

Definition at line 154 of file queue.c.

queue_generation

WORD queue_generation

static

Definition at line 57 of file queue.c.

Referenced by alloc_user_queue().

queue_serial_callback_vtbl

const IRtwqAsyncCallbackVtbl queue_serial_callback_vtbl

static

Initial value:

=
{
    queue_serial_callback_QueryInterface,
    queue_serial_callback_AddRef,
    queue_serial_callback_Release,
    queue_serial_callback_GetParameters,
    queue_serial_callback_Invoke,
}

Definition at line 286 of file queue.c.

Referenced by serial_queue_init().

queues_critsect_debug

CRITICAL_SECTION_DEBUG queues_critsect_debug

static

Initial value:

=
{
    0, 0, &queues_section,
    { &queues_critsect_debug.ProcessLocksList, &queues_critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": queues_section") }
}

Definition at line 61 of file queue.c.

queues_section

static CRITICAL_SECTION queues_section = { &queues_critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 60 of file queue.c.

Referenced by alloc_user_queue(), grab_queue(), init_system_queues(), lock_user_queue(), RtwqLockSharedWorkQueue(), shutdown_system_queues(), and unlock_user_queue().

serial_queue_ops

const struct queue_ops serial_queue_ops

static

Initial value:

=
{
    serial_queue_init,
    serial_queue_shutdown,
    serial_queue_submit,
}

Definition at line 528 of file queue.c.

Referenced by RtwqAllocateSerialWorkQueue().

shared_mt_queue

DWORD shared_mt_queue

static

Definition at line 58 of file queue.c.

Referenced by RtwqLockSharedWorkQueue(), and unlock_user_queue().

system_queues

struct queue system_queues[SYS_QUEUE_COUNT]

static

Definition at line 295 of file queue.c.

Referenced by get_system_queue(), grab_queue(), init_system_queues(), and shutdown_system_queues().

user_queues

struct queue_handle user_queues[MAX_USER_QUEUE_HANDLES]

static

Definition at line 54 of file queue.c.

Referenced by alloc_user_queue(), and get_queue_obj().

work_item_vtbl

const IUnknownVtbl work_item_vtbl

static

Initial value:

=
{
    work_item_QueryInterface,
    work_item_AddRef,
    work_item_Release,
}

Definition at line 582 of file queue.c.

Referenced by alloc_work_item().