ReactOS 0.4.15-dev-5666-gc548b97
event.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/ksfilter/ks/event.c
5 * PURPOSE: KS Event functions
6 * PROGRAMMER: Johannes Anderwald
7 */
8
9#include "precomp.h"
10
11#define NDEBUG
12#include <debug.h>
13
16 IN KSEVENTS_LOCKTYPE EventsFlags,
17 IN PVOID EventsLock,
18 IN PKSEVENT_SYNCHRONIZED_ROUTINE SynchronizedRoutine,
19 IN PKSEVENT_CTX Ctx)
20{
22 KIRQL OldLevel;
23
24 if (EventsFlags == KSEVENTS_NONE)
25 {
26 /* no synchronization required */
27 Result = SynchronizedRoutine(Ctx);
28 }
29 else if (EventsFlags == KSEVENTS_SPINLOCK)
30 {
31 /* use spin lock */
32 KeAcquireSpinLock((PKSPIN_LOCK)EventsLock, &OldLevel);
33 Result = SynchronizedRoutine(Ctx);
34 KeReleaseSpinLock((PKSPIN_LOCK)EventsLock, OldLevel);
35 }
36 else if (EventsFlags == KSEVENTS_MUTEX)
37 {
38 /* use a mutex */
40 Result = SynchronizedRoutine(Ctx);
41 KeReleaseMutex((PRKMUTEX)EventsLock, FALSE);
42 }
43 else if (EventsFlags == KSEVENTS_FMUTEX)
44 {
45 /* use a fast mutex */
47 Result = SynchronizedRoutine(Ctx);
49 }
50 else if (EventsFlags == KSEVENTS_FMUTEXUNSAFE)
51 {
52 /* acquire fast mutex unsafe */
55 Result = SynchronizedRoutine(Ctx);
58 }
59 else if (EventsFlags == KSEVENTS_INTERRUPT)
60 {
61 /* use interrupt for locking */
62 Result = KeSynchronizeExecution((PKINTERRUPT)EventsLock, (PKSYNCHRONIZE_ROUTINE)SynchronizedRoutine, (PVOID)Ctx);
63 }
64 else if (EventsFlags == KSEVENTS_ERESOURCE)
65 {
66 /* use an eresource */
69 Result = SynchronizedRoutine(Ctx);
72 }
73
74 return Result;
75}
76
81{
82 InsertTailList(Context->List, &Context->EventEntry->ListEntry);
83 return TRUE;
84}
85
88 IN PIRP Irp,
89 IN ULONG EventSetsCount,
90 IN const KSEVENT_SET* EventSet,
91 IN OUT PLIST_ENTRY EventsList OPTIONAL,
92 IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL,
93 IN PVOID EventsLock OPTIONAL,
94 IN PFNKSALLOCATOR Allocator OPTIONAL,
95 IN ULONG EventItemSize OPTIONAL)
96{
97 PIO_STACK_LOCATION IoStack;
100 PKSEVENT_ITEM EventItem, FoundEventItem;
101 PKSEVENTDATA EventData;
102 const KSEVENT_SET *FoundEventSet;
103 PKSEVENT_ENTRY EventEntry;
104 ULONG Index, SubIndex, Size;
106 KSEVENT_CTX Ctx;
107 LPGUID Guid;
108
109 /* get current stack location */
111
112 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSEVENT))
113 {
114 /* invalid parameter */
116 }
117
118 if (Irp->RequestorMode == UserMode)
119 {
121 {
122 ProbeForRead(IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT), sizeof(UCHAR));
123 ProbeForRead(Irp->UserBuffer, IoStack->Parameters.DeviceIoControl.OutputBufferLength, sizeof(UCHAR));
124 RtlMoveMemory(&Event, IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT));
126 }
128 {
129 /* Exception, get the error code */
131 }
132 _SEH2_END;
133
134 /* check for success */
135 if (!NT_SUCCESS(Status))
136 {
137 /* failed to probe parameters */
138 return Status;
139 }
140 }
141 else
142 {
143 /* copy event struct */
144 RtlMoveMemory(&Event, IoStack->Parameters.DeviceIoControl.Type3InputBuffer, sizeof(KSEVENT));
145 }
146
147 FoundEventItem = NULL;
148 FoundEventSet = NULL;
149
150
151 if (IsEqualGUIDAligned(&Event.Set, &GUID_NULL) && Event.Id == 0 && Event.Flags == KSEVENT_TYPE_SETSUPPORT)
152 {
153 // store output size
154 Irp->IoStatus.Information = sizeof(GUID) * EventSetsCount;
155 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(GUID) * EventSetsCount)
156 {
157 // buffer too small
158 return STATUS_MORE_ENTRIES;
159 }
160
161 // get output buffer
162 Guid = (LPGUID)Irp->UserBuffer;
163
164 // copy property guids from property sets
165 for(Index = 0; Index < EventSetsCount; Index++)
166 {
167 RtlMoveMemory(&Guid[Index], EventSet[Index].Set, sizeof(GUID));
168 }
169 return STATUS_SUCCESS;
170 }
171
172 /* now try to find event set */
173 for(Index = 0; Index < EventSetsCount; Index++)
174 {
175 if (IsEqualGUIDAligned(&Event.Set, EventSet[Index].Set))
176 {
177 EventItem = (PKSEVENT_ITEM)EventSet[Index].EventItem;
178
179 /* sanity check */
180 ASSERT(EventSet[Index].EventsCount);
181 ASSERT(EventItem);
182
183 /* now find matching event id */
184 for(SubIndex = 0; SubIndex < EventSet[Index].EventsCount; SubIndex++)
185 {
186 if (EventItem[SubIndex].EventId == Event.Id)
187 {
188 /* found event item */
189 FoundEventItem = &EventItem[SubIndex];
190 FoundEventSet = &EventSet[Index];
191 break;
192 }
193 }
194
195 if (FoundEventSet)
196 break;
197 }
198 }
199
200 if (!FoundEventSet)
201 {
203
205
206 DPRINT("Guid %S Id %u Flags %x not found\n", GuidString.Buffer, Event.Id, Event.Flags);
209
210
211 }
212
213 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < FoundEventItem->DataInput)
214 {
215 /* buffer too small */
216 DPRINT1("Got %u expected %u\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength, FoundEventItem->DataInput);
217 return STATUS_SUCCESS;
218 }
219
220 if (!FoundEventItem->AddHandler && !EventsList)
221 {
222 /* no add handler and no list to add the new entry to */
224 }
225
226 /* get event data */
227 EventData = Irp->UserBuffer;
228
229 /* sanity check */
230 ASSERT(EventData);
231
232 if (Irp->RequestorMode == UserMode)
233 {
235 {
236 /* get semaphore object handle */
238
239 if (!NT_SUCCESS(Status))
240 {
241 /* invalid semaphore handle */
243 }
244 }
245 else if (EventData->NotificationType == KSEVENTF_EVENT_HANDLE)
246 {
247 /* get event object handle */
249
250 if (!NT_SUCCESS(Status))
251 {
252 /* invalid event handle */
254 }
255 }
256 else
257 {
258 /* user mode client can only pass an event or semaphore handle */
260 }
261 }
262 else
263 {
264 if (EventData->NotificationType != KSEVENTF_EVENT_OBJECT &&
265 EventData->NotificationType != KSEVENTF_SEMAPHORE_OBJECT &&
266 EventData->NotificationType != KSEVENTF_DPC &&
267 EventData->NotificationType != KSEVENTF_WORKITEM &&
268 EventData->NotificationType != KSEVENTF_KSWORKITEM)
269 {
270 /* invalid type requested */
272 }
273 }
274
275
276 /* calculate request size */
277 Size = sizeof(KSEVENT_ENTRY) + FoundEventItem->ExtraEntryData;
278
279 /* do we have an allocator */
280 if (Allocator)
281 {
282 /* allocate event entry */
283 Status = Allocator(Irp, Size, FALSE);
284
285 if (!NT_SUCCESS(Status))
286 {
287 /* failed */
288 return Status;
289 }
290
291 /* assume the caller put it there */
292 EventEntry = KSEVENT_ENTRY_IRP_STORAGE(Irp);
293
294 }
295 else
296 {
297 /* allocate it from nonpaged pool */
298 EventEntry = AllocateItem(NonPagedPool, Size);
299 }
300
301 if (!EventEntry)
302 {
303 /* not enough memory */
305 }
306
307 /* zero event entry */
308 RtlZeroMemory(EventEntry, Size);
309
310 /* initialize event entry */
311 EventEntry->EventData = EventData;
312 EventEntry->NotificationType = EventData->NotificationType;
313 EventEntry->EventItem = FoundEventItem;
314 EventEntry->EventSet = FoundEventSet;
315 EventEntry->FileObject = IoStack->FileObject;
316
317 switch(EventEntry->NotificationType)
318 {
320 EventEntry->Object = Object;
321 EventEntry->Reserved = 0;
322 break;
324 EventEntry->Object = Object;
325 EventEntry->SemaphoreAdjustment = EventData->SemaphoreHandle.Adjustment;
326 EventEntry->Reserved = 0;
327 break;
328 case KSEVENTF_EVENT_OBJECT:
329 EventEntry->Object = EventData->EventObject.Event;
330 EventEntry->Reserved = EventData->EventObject.Increment;
331 break;
332 case KSEVENTF_SEMAPHORE_OBJECT:
333 EventEntry->Object = EventData->SemaphoreObject.Semaphore;
334 EventEntry->SemaphoreAdjustment = EventData->SemaphoreObject.Adjustment;
335 EventEntry->Reserved = EventData->SemaphoreObject.Increment;
336 break;
337 case KSEVENTF_DPC:
338 EventEntry->Object = EventData->Dpc.Dpc;
339 EventData->Dpc.ReferenceCount = 0;
340 break;
341 case KSEVENTF_WORKITEM:
342 EventEntry->Object = EventData->WorkItem.WorkQueueItem;
343 EventEntry->BufferItem = (PKSBUFFER_ITEM)UlongToPtr(EventData->WorkItem.WorkQueueType);
344 break;
345 case KSEVENTF_KSWORKITEM:
346 EventEntry->Object = EventData->KsWorkItem.KsWorkerObject;
347 EventEntry->DpcItem = (PKSDPC_ITEM)EventData->KsWorkItem.WorkQueueItem;
348 break;
349 default:
350 /* should not happen */
351 ASSERT(0);
352 }
353
354 if (FoundEventItem->AddHandler)
355 {
356 /* now add the event */
357 Status = FoundEventItem->AddHandler(Irp, EventData, EventEntry);
358
359 if (!NT_SUCCESS(Status))
360 {
361 /* discard event entry */
362 KsDiscardEvent(EventEntry);
363 }
364 }
365 else
366 {
367 /* setup context */
368 Ctx.List = EventsList;
369 Ctx.EventEntry = EventEntry;
370
371 /* add the event */
372 (void)KspSynchronizedEventRoutine(EventsFlags, EventsLock, SyncAddEvent, &Ctx);
373
375 }
376
377 /* done */
378 return Status;
379}
380
381/*
382 @implemented
383*/
386NTAPI
388 IN PIRP Irp,
389 IN ULONG EventSetsCount,
390 IN KSEVENT_SET* EventSet,
391 IN OUT PLIST_ENTRY EventsList OPTIONAL,
392 IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL,
393 IN PVOID EventsLock OPTIONAL)
394{
395 return KspEnableEvent(Irp, EventSetsCount, EventSet, EventsList, EventsFlags, EventsLock, NULL, 0);
396}
397
398/*
399 @implemented
400*/
404NTAPI
405KsEnableEventWithAllocator(
406 _In_ PIRP Irp,
407 _In_ ULONG EventSetsCount,
408 _In_reads_(EventSetsCount) const KSEVENT_SET* EventSet,
409 _Inout_opt_ PLIST_ENTRY EventsList,
410 _In_opt_ KSEVENTS_LOCKTYPE EventsFlags,
411 _In_opt_ PVOID EventsLock,
412 _In_opt_ PFNKSALLOCATOR Allocator,
413 _In_opt_ ULONG EventItemSize)
414{
415 return KspEnableEvent(Irp, EventSetsCount, EventSet, EventsList, EventsFlags, EventsLock, Allocator, EventItemSize);
416}
417
419NTAPI
421 IN PKSEVENT_CTX Ctx)
422{
423 PIO_STACK_LOCATION IoStack;
424 PKSEVENTDATA EventData;
425 PKSEVENT_ENTRY EventEntry;
427
428 if (!Ctx || !Ctx->List || !Ctx->FileObject || !Ctx->Irp)
429 {
430 /* invalid parameter */
431 return FALSE;
432 }
433
434 /* get current irp stack location */
435 IoStack = IoGetCurrentIrpStackLocation(Ctx->Irp);
436
437 /* get event data */
438 EventData = (PKSEVENTDATA)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
439
440 /* point to first entry */
441 Entry = Ctx->List->Flink;
442
443 while(Entry != Ctx->List)
444 {
445 /* get event entry */
446 EventEntry = (PKSEVENT_ENTRY)CONTAINING_RECORD(Entry, KSEVENT_ENTRY, ListEntry);
447
448 if (EventEntry->EventData == EventData && EventEntry->FileObject == Ctx->FileObject)
449 {
450 /* found the entry */
451 RemoveEntryList(&EventEntry->ListEntry);
452 Ctx->EventEntry = EventEntry;
453 return TRUE;
454 }
455
456 /* move to next item */
457 Entry = Entry->Flink;
458 }
459 /* entry not found */
460 return TRUE;
461}
462
463/*
464 @implemented
465*/
468NTAPI
470 IN PIRP Irp,
471 IN OUT PLIST_ENTRY EventsList,
472 IN KSEVENTS_LOCKTYPE EventsFlags,
473 IN PVOID EventsLock)
474{
475 PIO_STACK_LOCATION IoStack;
476 KSEVENT_CTX Ctx;
477
478 /* get current irp stack location */
480
481 /* is there a event entry */
482 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSEVENTDATA))
483 {
484 if (IoStack->Parameters.DeviceIoControl.InputBufferLength == 0)
485 {
486 /* caller wants to free event items */
487 KsFreeEventList(IoStack->FileObject, EventsList, EventsFlags, EventsLock);
488 return STATUS_SUCCESS;
489 }
490 /* invalid parameter */
492 }
493
494 /* setup event ctx */
495 Ctx.List = EventsList;
496 Ctx.FileObject = IoStack->FileObject;
497 Ctx.Irp = Irp;
498 Ctx.EventEntry = NULL;
499
500 if (KspSynchronizedEventRoutine(EventsFlags, EventsLock, KspDisableEvent, &Ctx))
501 {
502 /* was the event entry found */
503 if (Ctx.EventEntry)
504 {
505 /* discard event */
507 return STATUS_SUCCESS;
508 }
509 /* event was not found */
510 return STATUS_UNSUCCESSFUL;
511 }
512
513 /* invalid parameters */
515}
516
517/*
518 @implemented
519*/
521VOID
522NTAPI
524 IN PKSEVENT_ENTRY EventEntry)
525{
526 /* sanity check */
527 ASSERT(EventEntry->Object);
528
529 if (EventEntry->NotificationType == KSEVENTF_SEMAPHORE_HANDLE || EventEntry->NotificationType == KSEVENTF_EVENT_HANDLE)
530 {
531 /* release object */
532 ObDereferenceObject(EventEntry->Object);
533 }
534
535 /* free event entry */
536 FreeItem(EventEntry);
537}
538
539
541NTAPI
543 IN PKSEVENT_CTX Ctx)
544{
546 PKSEVENT_ENTRY EventEntry;
547
548 /* check valid input */
549 if (!Ctx || !Ctx->List)
550 return FALSE;
551
552 if (IsListEmpty(Ctx->List))
553 return FALSE;
554
555 /* remove first entry */
556 Entry = RemoveHeadList(Ctx->List);
557 if (!Entry)
558 {
559 /* list is empty, bye-bye */
560 return FALSE;
561 }
562
563 /* get event entry */
564 EventEntry = (PKSEVENT_ENTRY)CONTAINING_RECORD(Entry, KSEVENT_ENTRY, ListEntry);
565
566 /* store event entry */
567 Ctx->EventEntry = EventEntry;
568 /* return success */
569 return TRUE;
570}
571
572
573/*
574 @implemented
575*/
577VOID
578NTAPI
581 IN OUT PLIST_ENTRY EventsList,
582 IN KSEVENTS_LOCKTYPE EventsFlags,
583 IN PVOID EventsLock)
584{
585 KSEVENT_CTX Ctx;
586
587 /* setup event ctx */
588 Ctx.List = EventsList;
590 Ctx.EventEntry = NULL;
591
592 while(KspSynchronizedEventRoutine(EventsFlags, EventsLock, KspFreeEventList, &Ctx))
593 {
594 if (Ctx.EventEntry)
595 {
597 }
598 }
599}
600
601
602/*
603 @implemented
604*/
607NTAPI
609 IN PKSEVENT_ENTRY EntryEvent)
610{
611 if (EntryEvent->NotificationType == KSEVENTF_EVENT_HANDLE || EntryEvent->NotificationType == KSEVENTF_EVENT_OBJECT)
612 {
613 /* signal event */
614 KeSetEvent(EntryEvent->Object, EntryEvent->Reserved, FALSE);
615 }
616 else if (EntryEvent->NotificationType == KSEVENTF_SEMAPHORE_HANDLE || EntryEvent->NotificationType == KSEVENTF_SEMAPHORE_OBJECT)
617 {
618 /* release semaphore */
619 KeReleaseSemaphore(EntryEvent->Object, EntryEvent->Reserved, EntryEvent->SemaphoreAdjustment, FALSE);
620 }
621 else if (EntryEvent->NotificationType == KSEVENTF_DPC)
622 {
623 /* increment reference count to indicate dpc is pending */
624 InterlockedIncrement((PLONG)&EntryEvent->EventData->Dpc.ReferenceCount);
625 /* queue dpc */
626 KeInsertQueueDpc((PRKDPC)EntryEvent->Object, NULL, NULL);
627 }
628 else if (EntryEvent->NotificationType == KSEVENTF_WORKITEM)
629 {
630 /* queue work item */
631 ExQueueWorkItem((PWORK_QUEUE_ITEM)EntryEvent->Object, PtrToUlong(EntryEvent->BufferItem));
632 }
633 else if (EntryEvent->NotificationType == KSEVENTF_KSWORKITEM)
634 {
635 /* queue work item of ks worker */
636 return KsQueueWorkItem((PKSWORKER)EntryEvent->Object, (PWORK_QUEUE_ITEM)EntryEvent->DpcItem);
637 }
638 else
639 {
640 /* unsupported type requested */
642 }
643
644 return STATUS_SUCCESS;
645}
646
647/*
648 @unimplemented
649*/
652NTAPI
654 IN PKSEVENT_ENTRY EventEntry,
656 IN PVOID Data)
657{
659 return STATUS_UNSUCCESSFUL;
660}
661
662/*
663 @unimplemented
664*/
666VOID
667NTAPI
670 IN ULONG EventId,
671 IN PLIST_ENTRY EventsList,
672 IN KSEVENTS_LOCKTYPE EventsFlags,
673 IN PVOID EventsLock)
674{
676}
677
678/*
679 @implemented
680*/
682VOID
683NTAPI
686 IN PKSEVENT_ENTRY EventEntry)
687{
689
690 ExInterlockedInsertTailList(&Header->EventList, &EventEntry->ListEntry, &Header->EventListLock);
691}
692
693/*
694 @implemented
695*/
697NTAPI
699 IN PIRP Irp,
700 IN PKSEVENTDATA EventData,
701 IN OUT PKSEVENT_ENTRY EventEntry)
702{
703 PIO_STACK_LOCATION IoStack;
704 PKSIOBJECT_HEADER ObjectHeader;
706
707 /* first get the io stack location */
709
710 /* now get the object header */
711 ObjectHeader =(PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
712
713 /* sanity check */
714 ASSERT(ObjectHeader->ObjectType);
715
716 /* obtain basic header */
717 Header = (PKSBASIC_HEADER)((ULONG_PTR)ObjectHeader->ObjectType - sizeof(KSBASIC_HEADER));
718
719 /* now insert the event entry */
720 ExInterlockedInsertTailList(&Header->EventList, &EventEntry->ListEntry, &Header->EventListLock);
721
722 /* done */
723 return STATUS_SUCCESS;
724}
725
726
727
728/*
729 @unimplemented
730*/
732void
733NTAPI
736 IN const GUID* EventSet OPTIONAL,
737 IN ULONG EventId,
740 IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
742{
744}
unsigned char BOOLEAN
#define InterlockedIncrement
Definition: armddk.h:53
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define UNIMPLEMENTED
Definition: debug.h:115
Definition: Header.h:9
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
BOOLEAN NTAPI KeInsertQueueDpc(IN PKDPC Dpc, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: dpc.c:725
KSDDKAPI void NTAPI KsGenerateEvents(IN PVOID Object, IN const GUID *EventSet OPTIONAL, IN ULONG EventId, IN ULONG DataSize, IN PVOID Data OPTIONAL, IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL, IN PVOID CallBackContext OPTIONAL)
Definition: event.c:734
BOOLEAN NTAPI KspFreeEventList(IN PKSEVENT_CTX Ctx)
Definition: event.c:542
BOOLEAN KspSynchronizedEventRoutine(IN KSEVENTS_LOCKTYPE EventsFlags, IN PVOID EventsLock, IN PKSEVENT_SYNCHRONIZED_ROUTINE SynchronizedRoutine, IN PKSEVENT_CTX Ctx)
Definition: event.c:15
KSDDKAPI NTSTATUS NTAPI KsEnableEvent(IN PIRP Irp, IN ULONG EventSetsCount, IN KSEVENT_SET *EventSet, IN OUT PLIST_ENTRY EventsList OPTIONAL, IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL, IN PVOID EventsLock OPTIONAL)
Definition: event.c:387
BOOLEAN NTAPI SyncAddEvent(PKSEVENT_CTX Context)
Definition: event.c:79
KSDDKAPI NTSTATUS NTAPI KsGenerateEvent(IN PKSEVENT_ENTRY EntryEvent)
Definition: event.c:608
BOOLEAN NTAPI KspDisableEvent(IN PKSEVENT_CTX Ctx)
Definition: event.c:420
KSDDKAPI NTSTATUS NTAPI KsDisableEvent(IN PIRP Irp, IN OUT PLIST_ENTRY EventsList, IN KSEVENTS_LOCKTYPE EventsFlags, IN PVOID EventsLock)
Definition: event.c:469
KSDDKAPI VOID NTAPI KsFreeEventList(IN PFILE_OBJECT FileObject, IN OUT PLIST_ENTRY EventsList, IN KSEVENTS_LOCKTYPE EventsFlags, IN PVOID EventsLock)
Definition: event.c:579
KSDDKAPI VOID NTAPI KsAddEvent(IN PVOID Object, IN PKSEVENT_ENTRY EventEntry)
Definition: event.c:684
KSDDKAPI VOID NTAPI KsGenerateEventList(IN GUID *Set OPTIONAL, IN ULONG EventId, IN PLIST_ENTRY EventsList, IN KSEVENTS_LOCKTYPE EventsFlags, IN PVOID EventsLock)
Definition: event.c:668
NTSTATUS NTAPI KsDefaultAddEventHandler(IN PIRP Irp, IN PKSEVENTDATA EventData, IN OUT PKSEVENT_ENTRY EventEntry)
Definition: event.c:698
NTSTATUS KspEnableEvent(IN PIRP Irp, IN ULONG EventSetsCount, IN const KSEVENT_SET *EventSet, IN OUT PLIST_ENTRY EventsList OPTIONAL, IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL, IN PVOID EventsLock OPTIONAL, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG EventItemSize OPTIONAL)
Definition: event.c:87
KSDDKAPI NTSTATUS NTAPI KsGenerateDataEvent(IN PKSEVENT_ENTRY EventEntry, IN ULONG DataSize, IN PVOID Data)
Definition: event.c:653
KSDDKAPI VOID NTAPI KsDiscardEvent(IN PKSEVENT_ENTRY EventEntry)
Definition: event.c:523
#define UlongToPtr(u)
Definition: config.h:106
#define PtrToUlong(u)
Definition: config.h:107
#define _IRQL_requires_max_(irql)
Definition: driverspecs.h:230
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
ERESOURCE * PERESOURCE
Definition: env_spec_w32.h:595
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
#define NonPagedPool
Definition: env_spec_w32.h:307
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
Status
Definition: gdiplustypes.h:25
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
#define GUID_NULL
Definition: ks.h:106
KSEVENTS_LOCKTYPE
Definition: ks.h:1231
@ KSEVENTS_FMUTEXUNSAFE
Definition: ks.h:1236
@ KSEVENTS_INTERRUPT
Definition: ks.h:1237
@ KSEVENTS_SPINLOCK
Definition: ks.h:1233
@ KSEVENTS_NONE
Definition: ks.h:1232
@ KSEVENTS_MUTEX
Definition: ks.h:1234
@ KSEVENTS_FMUTEX
Definition: ks.h:1235
@ KSEVENTS_ERESOURCE
Definition: ks.h:1238
struct _KSEVENT_ENTRY * PKSEVENT_ENTRY
Definition: ks.h:2101
#define KSEVENT_TYPE_SETSUPPORT
Definition: ks.h:1792
struct KSEVENTDATA * PKSEVENTDATA
#define KSEVENTF_EVENT_HANDLE
Definition: ks.h:1778
struct _KSEVENT_ENTRY KSEVENT_ENTRY
Definition: ks.h:2101
#define KSEVENTF_SEMAPHORE_HANDLE
Definition: ks.h:1779
#define KSDDKAPI
Definition: ks.h:40
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:30
VOID FreeItem(IN PVOID Item)
Definition: misc.c:43
struct KSBASIC_HEADER * PKSBASIC_HEADER
struct KSIOBJECT_HEADER * PKSIOBJECT_HEADER
BOOLEAN(NTAPI * PKSEVENT_SYNCHRONIZED_ROUTINE)(PKSEVENT_CTX Context)
Definition: kstypes.h:142
if(dx< 0)
Definition: linetemp.h:194
signed int * PLONG
Definition: retypes.h:5
unsigned int ULONG
Definition: retypes.h:1
#define ASSERT(a)
Definition: mode.c:44
static PWSTR GuidString
Definition: apphelp.c:93
#define _Inout_opt_
Definition: ms_sal.h:379
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
#define _In_reads_(size)
Definition: ms_sal.h:319
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
#define KernelMode
Definition: asm.h:34
#define UserMode
Definition: asm.h:35
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
POBJECT_TYPE ExEventObjectType
Definition: event.c:18
VOID FASTCALL ExReleaseFastMutexUnsafe(IN OUT PFAST_MUTEX FastMutex)
Definition: fmutex.c:86
VOID FASTCALL ExAcquireFastMutexUnsafe(IN OUT PFAST_MUTEX FastMutex)
Definition: fmutex.c:75
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
BOOLEAN NTAPI KeSynchronizeExecution(IN OUT PKINTERRUPT Interrupt, IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, IN PVOID SynchronizeContext OPTIONAL)
Definition: interrupt.c:231
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189
#define STATUS_INVALID_BUFFER_SIZE
Definition: ntstatus.h:650
#define STATUS_PROPSET_NOT_FOUND
Definition: ntstatus.h:692
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
static BOOL Set
Definition: pageheap.c:10
GUID * LPGUID
Definition: guiddef.h:81
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
POBJECT_TYPE ExSemaphoreObjectType
Definition: sem.c:22
LONG NTAPI KeReleaseSemaphore(IN PKSEMAPHORE Semaphore, IN KPRIORITY Increment, IN LONG Adjustment, IN BOOLEAN Wait)
Definition: semphobj.c:54
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
base of all file and directory entries
Definition: entries.h:83
HANDLE Semaphore
Definition: ks.h:1740
LONG Adjustment
Definition: ks.h:1742
ULONG NotificationType
Definition: ks.h:1733
struct KSEVENTDATA::@3000::@3003 SemaphoreHandle
struct KSEVENTDATA::@3000::@3002 EventHandle
HANDLE Event
Definition: ks.h:1736
PFILE_OBJECT FileObject
Definition: kstypes.h:137
PIRP Irp
Definition: kstypes.h:139
PKSEVENT_ENTRY EventEntry
Definition: kstypes.h:138
PLIST_ENTRY List
Definition: kstypes.h:136
PVOID ObjectType
Definition: kstypes.h:30
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
Definition: ketypes.h:687
Definition: typedefs.h:120
#define NTAPI
Definition: typedefs.h:36
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define OUT
Definition: typedefs.h:40
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_MORE_ENTRIES
Definition: udferr_usr.h:124
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
IN PVOID CallBackContext
Definition: usbmport.h:466
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
_In_ WDFCOLLECTION _In_ ULONG Index
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762
#define IsEqualGUIDAligned(guid1, guid2)
Definition: wdm.template.h:235
#define SEMAPHORE_MODIFY_STATE
Definition: winbase.h:161
#define EVENT_MODIFY_STATE
Definition: winbase.h:163
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
KSDDKAPI NTSTATUS NTAPI KsQueueWorkItem(IN PKSWORKER Worker, IN PWORK_QUEUE_ITEM WorkItem)
Definition: worker.c:252
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
* PFAST_MUTEX
Definition: extypes.h:17
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
* PFILE_OBJECT
Definition: iotypes.h:1998
@ Executive
Definition: ketypes.h:403
KSYNCHRONIZE_ROUTINE * PKSYNCHRONIZE_ROUTINE
Definition: ketypes.h:863
#define ObDereferenceObject
Definition: obfuncs.h:203
unsigned char UCHAR
Definition: xmlstorage.h:181