[KS]
[reactos.git] / reactos / drivers / ksfilter / ks / event.c
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
14 BOOLEAN
15 KspSynchronizedEventRoutine(
16 IN KSEVENTS_LOCKTYPE EventsFlags,
17 IN PVOID EventsLock,
18 IN PKSEVENT_SYNCHRONIZED_ROUTINE SynchronizedRoutine,
19 IN PKSEVENT_CTX Ctx)
20 {
21 BOOLEAN Result = FALSE;
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 */
39 KeWaitForSingleObject(EventsLock, Executive, KernelMode, FALSE, NULL);
40 Result = SynchronizedRoutine(Ctx);
41 KeReleaseMutex((PRKMUTEX)EventsLock, FALSE);
42 }
43 else if (EventsFlags == KSEVENTS_FMUTEX)
44 {
45 /* use a fast mutex */
46 ExAcquireFastMutex((PFAST_MUTEX)EventsLock);
47 Result = SynchronizedRoutine(Ctx);
48 ExReleaseFastMutex((PFAST_MUTEX)EventsLock);
49 }
50 else if (EventsFlags == KSEVENTS_FMUTEXUNSAFE)
51 {
52 /* acquire fast mutex unsafe */
53 KeEnterCriticalRegion();
54 ExAcquireFastMutexUnsafe((PFAST_MUTEX)EventsLock);
55 Result = SynchronizedRoutine(Ctx);
56 ExReleaseFastMutexUnsafe((PFAST_MUTEX)EventsLock);
57 KeLeaveCriticalRegion();
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 */
67 KeEnterCriticalRegion();
68 ExAcquireResourceExclusiveLite((PERESOURCE)EventsLock, TRUE);
69 Result = SynchronizedRoutine(Ctx);
70 ExReleaseResourceLite((PERESOURCE)EventsLock);
71 KeLeaveCriticalRegion();
72 }
73
74 return Result;
75 }
76
77 BOOLEAN
78 NTAPI
79 SyncAddEvent(
80 PKSEVENT_CTX Context)
81 {
82 InsertTailList(Context->List, &Context->EventEntry->ListEntry);
83 return TRUE;
84 }
85
86 NTSTATUS
87 KspEnableEvent(
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;
98 NTSTATUS Status;
99 KSEVENT Event;
100 PKSEVENT_ITEM EventItem, FoundEventItem;
101 PKSEVENTDATA EventData;
102 const KSEVENT_SET* FoundEventSet;
103 PKSEVENT_ENTRY EventEntry;
104 ULONG Index, SubIndex, Size;
105 PVOID Object;
106 KSEVENT_CTX Ctx;
107 LPGUID Guid;
108
109 /* get current stack location */
110 IoStack = IoGetCurrentIrpStackLocation(Irp);
111
112 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSEVENT))
113 {
114 /* invalid parameter */
115 return STATUS_NOT_SUPPORTED;
116 }
117
118 if (Irp->RequestorMode == UserMode)
119 {
120 _SEH2_TRY
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));
125 Status = STATUS_SUCCESS;
126 }
127 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
128 {
129 /* Exception, get the error code */
130 Status = _SEH2_GetExceptionCode();
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 {
202 UNICODE_STRING GuidString;
203
204 RtlStringFromGUID(&Event.Set, &GuidString);
205
206 DPRINT("Guid %S Id %u Flags %x not found\n", GuidString.Buffer, Event.Id, Event.Flags);
207 RtlFreeUnicodeString(&GuidString);
208 return STATUS_PROPSET_NOT_FOUND;
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 */
223 return STATUS_INVALID_PARAMETER;
224 }
225
226 /* get event data */
227 EventData = Irp->UserBuffer;
228
229 /* sanity check */
230 ASSERT(EventData);
231
232 if (Irp->RequestorMode == UserMode)
233 {
234 if (EventData->NotificationType == KSEVENTF_SEMAPHORE_HANDLE)
235 {
236 /* get semaphore object handle */
237 Status = ObReferenceObjectByHandle(EventData->SemaphoreHandle.Semaphore, SEMAPHORE_MODIFY_STATE, ExSemaphoreObjectType, Irp->RequestorMode, &Object, NULL);
238
239 if (!NT_SUCCESS(Status))
240 {
241 /* invalid semaphore handle */
242 return STATUS_INVALID_PARAMETER;
243 }
244 }
245 else if (EventData->NotificationType == KSEVENTF_EVENT_HANDLE)
246 {
247 /* get event object handle */
248 Status = ObReferenceObjectByHandle(EventData->EventHandle.Event, EVENT_MODIFY_STATE, ExEventObjectType, Irp->RequestorMode, &Object, NULL);
249
250 if (!NT_SUCCESS(Status))
251 {
252 /* invalid event handle */
253 return STATUS_INVALID_PARAMETER;
254 }
255 }
256 else
257 {
258 /* user mode client can only pass an event or semaphore handle */
259 return STATUS_INVALID_PARAMETER;
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 */
271 return STATUS_INVALID_PARAMETER;
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 */
304 return STATUS_INSUFFICIENT_RESOURCES;
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 {
319 case KSEVENTF_EVENT_HANDLE:
320 EventEntry->Object = Object;
321 EventEntry->Reserved = 0;
322 break;
323 case KSEVENTF_SEMAPHORE_HANDLE:
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
374 Status = STATUS_SUCCESS;
375 }
376
377 /* done */
378 return Status;
379 }
380
381 /*
382 @implemented
383 */
384 KSDDKAPI
385 NTSTATUS
386 NTAPI
387 KsEnableEvent(
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 */
401 _IRQL_requires_max_(PASSIVE_LEVEL)
402 KSDDKAPI
403 NTSTATUS
404 NTAPI
405 KsEnableEventWithAllocator(
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
418 BOOLEAN
419 NTAPI
420 KspDisableEvent(
421 IN PKSEVENT_CTX Ctx)
422 {
423 PIO_STACK_LOCATION IoStack;
424 PKSEVENTDATA EventData;
425 PKSEVENT_ENTRY EventEntry;
426 PLIST_ENTRY Entry;
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 */
466 KSDDKAPI
467 NTSTATUS
468 NTAPI
469 KsDisableEvent(
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 */
479 IoStack = IoGetCurrentIrpStackLocation(Irp);
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 */
491 return STATUS_INVALID_BUFFER_SIZE;
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 */
506 KsDiscardEvent(Ctx.EventEntry);
507 return STATUS_SUCCESS;
508 }
509 /* event was not found */
510 return STATUS_UNSUCCESSFUL;
511 }
512
513 /* invalid parameters */
514 return STATUS_INVALID_PARAMETER;
515 }
516
517 /*
518 @implemented
519 */
520 KSDDKAPI
521 VOID
522 NTAPI
523 KsDiscardEvent(
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
540 BOOLEAN
541 NTAPI
542 KspFreeEventList(
543 IN PKSEVENT_CTX Ctx)
544 {
545 PLIST_ENTRY Entry;
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 */
576 KSDDKAPI
577 VOID
578 NTAPI
579 KsFreeEventList(
580 IN PFILE_OBJECT FileObject,
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;
589 Ctx.FileObject = FileObject;
590 Ctx.EventEntry = NULL;
591
592 while(KspSynchronizedEventRoutine(EventsFlags, EventsLock, KspFreeEventList, &Ctx))
593 {
594 if (Ctx.EventEntry)
595 {
596 KsDiscardEvent(Ctx.EventEntry);
597 }
598 }
599 }
600
601
602 /*
603 @implemented
604 */
605 KSDDKAPI
606 NTSTATUS
607 NTAPI
608 KsGenerateEvent(
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 */
641 return STATUS_INVALID_PARAMETER;
642 }
643
644 return STATUS_SUCCESS;
645 }
646
647 /*
648 @unimplemented
649 */
650 KSDDKAPI
651 NTSTATUS
652 NTAPI
653 KsGenerateDataEvent(
654 IN PKSEVENT_ENTRY EventEntry,
655 IN ULONG DataSize,
656 IN PVOID Data)
657 {
658 UNIMPLEMENTED;
659 return STATUS_UNSUCCESSFUL;
660 }
661
662 /*
663 @unimplemented
664 */
665 KSDDKAPI
666 VOID
667 NTAPI
668 KsGenerateEventList(
669 IN GUID* Set OPTIONAL,
670 IN ULONG EventId,
671 IN PLIST_ENTRY EventsList,
672 IN KSEVENTS_LOCKTYPE EventsFlags,
673 IN PVOID EventsLock)
674 {
675 UNIMPLEMENTED
676 }
677
678 /*
679 @implemented
680 */
681 KSDDKAPI
682 VOID
683 NTAPI
684 KsAddEvent(
685 IN PVOID Object,
686 IN PKSEVENT_ENTRY EventEntry)
687 {
688 PKSBASIC_HEADER Header = (PKSBASIC_HEADER)((ULONG_PTR)Object - sizeof(KSBASIC_HEADER));
689
690 ExInterlockedInsertTailList(&Header->EventList, &EventEntry->ListEntry, &Header->EventListLock);
691 }
692
693 /*
694 @implemented
695 */
696 NTSTATUS
697 NTAPI
698 KsDefaultAddEventHandler(
699 IN PIRP Irp,
700 IN PKSEVENTDATA EventData,
701 IN OUT PKSEVENT_ENTRY EventEntry)
702 {
703 PIO_STACK_LOCATION IoStack;
704 PKSIOBJECT_HEADER ObjectHeader;
705 PKSBASIC_HEADER Header;
706
707 /* first get the io stack location */
708 IoStack = IoGetCurrentIrpStackLocation(Irp);
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 */
731 KSDDKAPI
732 void
733 NTAPI
734 KsGenerateEvents(
735 IN PVOID Object,
736 IN const GUID* EventSet OPTIONAL,
737 IN ULONG EventId,
738 IN ULONG DataSize,
739 IN PVOID Data OPTIONAL,
740 IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
741 IN PVOID CallBackContext OPTIONAL)
742 {
743 UNIMPLEMENTED
744 }