ReactOS 0.4.15-dev-7693-gd0e2924
worker.c File Reference
#include "precomp.h"
#include <debug.h>
Include dependency graph for worker.c:

Go to the source code of this file.

Classes

struct  KSIWORKER
 

Macros

#define NDEBUG
 

Typedefs

typedef struct KSIWORKERPKSIWORKER
 

Functions

VOID NTAPI WorkItemRoutine (IN PVOID Context)
 
KSDDKAPI NTSTATUS NTAPI KsRegisterWorker (IN WORK_QUEUE_TYPE WorkQueueType, OUT PKSWORKER *Worker)
 
KSDDKAPI VOID NTAPI KsUnregisterWorker (IN PKSWORKER Worker)
 
KSDDKAPI NTSTATUS NTAPI KsRegisterCountedWorker (IN WORK_QUEUE_TYPE WorkQueueType, IN PWORK_QUEUE_ITEM CountedWorkItem, OUT PKSWORKER *Worker)
 
KSDDKAPI ULONG NTAPI KsDecrementCountedWorker (IN PKSWORKER Worker)
 
KSDDKAPI ULONG NTAPI KsIncrementCountedWorker (IN PKSWORKER Worker)
 
KSDDKAPI NTSTATUS NTAPI KsQueueWorkItem (IN PKSWORKER Worker, IN PWORK_QUEUE_ITEM WorkItem)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 11 of file worker.c.

Typedef Documentation

◆ PKSIWORKER

Function Documentation

◆ KsDecrementCountedWorker()

KSDDKAPI ULONG NTAPI KsDecrementCountedWorker ( IN PKSWORKER  Worker)

Definition at line 198 of file worker.c.

200{
201 PKSIWORKER KsWorker;
203
204 /* did the caller pass a work ctx */
205 if (!Worker)
207
208 /* get ks worker implementation */
209 KsWorker = (PKSIWORKER)Worker;
210 /* decrement counter */
212 /* return result */
213 return Counter;
214}
#define InterlockedDecrement
Definition: armddk.h:52
long LONG
Definition: pedump.c:60
LONG Counter
Definition: worker.c:25
static LARGE_INTEGER Counter
Definition: clock.c:43
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
struct KSIWORKER * PKSIWORKER

Referenced by CaptureAvoidPipeStarvationWorker(), CaptureGateOnWorkItem(), and IKsPin_PrepareStreamHeader().

◆ KsIncrementCountedWorker()

KSDDKAPI ULONG NTAPI KsIncrementCountedWorker ( IN PKSWORKER  Worker)

Definition at line 222 of file worker.c.

224{
225 PKSIWORKER KsWorker;
227
228 /* did the caller pass a work ctx */
229 if (!Worker)
231
232 /* get ks worker implementation */
233 KsWorker = (PKSIWORKER)Worker;
234 /* increment counter */
236 if (Counter == 1)
237 {
238 /* this is the first work item in list, so queue a real work item */
239 KsQueueWorkItem(Worker, KsWorker->CountedWorkItem);
240 }
241
242 /* return current counter */
243 return Counter;
244}
#define InterlockedIncrement
Definition: armddk.h:53
PWORK_QUEUE_ITEM CountedWorkItem
Definition: worker.c:29
KSDDKAPI NTSTATUS NTAPI KsQueueWorkItem(IN PKSWORKER Worker, IN PWORK_QUEUE_ITEM WorkItem)
Definition: worker.c:252

Referenced by IKsPin_DispatchKsStream(), and UsbAudioCaptureComplete().

◆ KsQueueWorkItem()

KSDDKAPI NTSTATUS NTAPI KsQueueWorkItem ( IN PKSWORKER  Worker,
IN PWORK_QUEUE_ITEM  WorkItem 
)

Definition at line 252 of file worker.c.

255{
256 PKSIWORKER KsWorker;
258
259 /* check for all parameters */
260 if (!Worker || !WorkItem)
262
263 /* get ks worker implementation */
264 KsWorker = (PKSIWORKER)Worker;
265 /* lock the work queue */
266 KeAcquireSpinLock(&KsWorker->Lock, &OldIrql);
267 /* insert work item to list */
268 InsertTailList(&KsWorker->QueuedWorkItems, &WorkItem->List);
269 /* increment active count */
271 /* is this the first work item */
272 if (KsWorker->QueuedWorkItemCount == 1)
273 {
274 /* clear event */
275 KeClearEvent(&KsWorker->Event);
276 /* it is, queue it */
277 ExQueueWorkItem(&KsWorker->WorkItem, KsWorker->Type);
278 }
279 /* release lock */
280 KeReleaseSpinLock(&KsWorker->Lock, OldIrql);
281
282 return STATUS_SUCCESS;
283}
#define InsertTailList(ListHead, Entry)
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
#define STATUS_SUCCESS
Definition: shellext.h:65
WORK_QUEUE_ITEM WorkItem
Definition: worker.c:20
WORK_QUEUE_TYPE Type
Definition: worker.c:24
KEVENT Event
Definition: worker.c:22
LONG QueuedWorkItemCount
Definition: worker.c:26
KSPIN_LOCK Lock
Definition: worker.c:23
LIST_ENTRY QueuedWorkItems
Definition: worker.c:27
_Must_inspect_result_ _In_ PWDF_WORKITEM_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWORKITEM * WorkItem
Definition: wdfworkitem.h:115
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by IKsProcessingObject_fnProcess(), KsGenerateEvent(), and KsIncrementCountedWorker().

◆ KsRegisterCountedWorker()

KSDDKAPI NTSTATUS NTAPI KsRegisterCountedWorker ( IN WORK_QUEUE_TYPE  WorkQueueType,
IN PWORK_QUEUE_ITEM  CountedWorkItem,
OUT PKSWORKER *  Worker 
)

Definition at line 166 of file worker.c.

170{
172 PKSIWORKER KsWorker;
173
174 /* check for counted work item parameter */
175 if (!CountedWorkItem)
177
178 /* create the work ctx */
179 Status = KsRegisterWorker(WorkQueueType, Worker);
180 /* check for success */
181 if (NT_SUCCESS(Status))
182 {
183 /* get ks worker implementation */
184 KsWorker = *(PKSIWORKER*)Worker;
185 /* store counted work item */
186 KsWorker->CountedWorkItem = CountedWorkItem;
187 }
188
189 return Status;
190}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
KSDDKAPI NTSTATUS NTAPI KsRegisterWorker(IN WORK_QUEUE_TYPE WorkQueueType, OUT PKSWORKER *Worker)
Definition: worker.c:88

Referenced by InitCapturePin(), KspCreateFilter(), and KspCreatePin().

◆ KsRegisterWorker()

KSDDKAPI NTSTATUS NTAPI KsRegisterWorker ( IN WORK_QUEUE_TYPE  WorkQueueType,
OUT PKSWORKER *  Worker 
)

Definition at line 88 of file worker.c.

91{
92 PKSIWORKER KsWorker;
93
94
95 if (WorkQueueType != CriticalWorkQueue &&
96 WorkQueueType != DelayedWorkQueue &&
97 WorkQueueType != HyperCriticalWorkQueue)
98 {
100 }
101
102 /* allocate worker context */
103 KsWorker = AllocateItem(NonPagedPool, sizeof(KSIWORKER));
104 if (!KsWorker)
106
107 /* initialize the work ctx */
108 ExInitializeWorkItem(&KsWorker->WorkItem, WorkItemRoutine, (PVOID)KsWorker);
109 /* setup type */
110 KsWorker->Type = WorkQueueType;
111 /* Initialize work item queue */
113 /* initialize work item lock */
114 KeInitializeSpinLock(&KsWorker->Lock);
115 /* initialize event */
117
118 *Worker = KsWorker;
119 return STATUS_SUCCESS;
120}
#define FALSE
Definition: types.h:117
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define NonPagedPool
Definition: env_spec_w32.h:307
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:29
@ NotificationEvent
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
VOID NTAPI WorkItemRoutine(IN PVOID Context)
Definition: worker.c:34
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
@ DelayedWorkQueue
Definition: extypes.h:190
@ CriticalWorkQueue
Definition: extypes.h:189
@ HyperCriticalWorkQueue
Definition: extypes.h:191

Referenced by KsRegisterCountedWorker().

◆ KsUnregisterWorker()

KSDDKAPI VOID NTAPI KsUnregisterWorker ( IN PKSWORKER  Worker)

Definition at line 128 of file worker.c.

130{
131 PKSIWORKER KsWorker;
133
134 if (!Worker)
135 return;
136
137 /* get ks worker implementation */
138 KsWorker = (PKSIWORKER)Worker;
139 /* acquire spinlock */
140 KeAcquireSpinLock(&KsWorker->Lock, &OldIrql);
141 /* fake status running to avoid work items to be queued by the counted worker */
142 KsWorker->Counter = 1;
143 /* is there currently a work item active */
144 if (KsWorker->QueuedWorkItemCount)
145 {
146 /* release the lock */
147 KeReleaseSpinLock(&KsWorker->Lock, OldIrql);
148 /* wait for the worker routine to finish */
150 }
151 else
152 {
153 /* no work item active, just release the lock */
154 KeReleaseSpinLock(&KsWorker->Lock, OldIrql);
155 }
156 /* free worker context */
157 FreeItem(KsWorker);
158}
#define NULL
Definition: types.h:112
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
VOID FreeItem(IN PVOID Item)
Definition: misc.c:37
#define KernelMode
Definition: asm.h:34
@ Executive
Definition: ketypes.h:415

Referenced by InitCapturePin(), and KspCreateFilter().

◆ WorkItemRoutine()

VOID NTAPI WorkItemRoutine ( IN PVOID  Context)

Definition at line 34 of file worker.c.

36{
37 PKSIWORKER KsWorker;
38 KIRQL OldLevel;
41
42
43 /* get ks worker implementation */
44 KsWorker = (PKSIWORKER)Context;
45
46 /* acquire back the lock */
47 KeAcquireSpinLock(&KsWorker->Lock, &OldLevel);
48
49 do
50 {
51 /* sanity check */
53
54 /* remove first entry */
56 /* get offset to work item */
58
59 /* release lock as the callback might call one KsWorker functions */
60 KeReleaseSpinLock(&KsWorker->Lock, OldLevel);
61
62 /* now dispatch the work */
63 WorkItem->WorkerRoutine(WorkItem->Parameter);
64
65 /* acquire back the lock */
66 KeAcquireSpinLock(&KsWorker->Lock, &OldLevel);
67
68 /* decrement queued work item count */
70
71 }while(KsWorker->QueuedWorkItemCount);
72
73 /* release the lock */
74 KeReleaseSpinLock(&KsWorker->Lock, OldLevel);
75
76 /* signal completion event */
78
79}
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
#define ASSERT(a)
Definition: mode.c:44
base of all file and directory entries
Definition: entries.h:83
Definition: typedefs.h:120
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
struct _WORK_QUEUE_ITEM * PWORK_QUEUE_ITEM
#define IO_NO_INCREMENT
Definition: iotypes.h:598

Referenced by KsRegisterWorker().