2 ReactOS Kernel Streaming
11 KSDDKAPI NTSTATUS NTAPI
14 OUT KSRESET
* ResetValue
)
17 return STATUS_UNSUCCESSFUL
;
26 KsAddIrpToCancelableQueue(
27 IN OUT PLIST_ENTRY QueueHead
,
28 IN PKSPIN_LOCK SpinLock
,
30 IN KSLIST_ENTRY_LOCATION ListLocation
,
31 IN PDRIVER_CANCEL DriverCancel OPTIONAL
)
35 if (!QueueHead
|| !SpinLock
|| !Irp
)
38 Entry
= ExAllocatePool(NonPagedPool
, sizeof(QUEUE_ENTRY
));
43 // setup cancel routine
48 if (ListLocation
== KsListEntryTail
)
49 ExInterlockedInsertTailList(QueueHead
, &Entry
->Entry
, SpinLock
);
51 ExInterlockedInsertHeadList(QueueHead
, &Entry
->Entry
, SpinLock
);
58 KSDDKAPI NTSTATUS NTAPI
59 KsAddObjectCreateItemToObjectHeader(
60 IN KSOBJECT_HEADER Header
,
61 IN PDRIVER_DISPATCH Create
,
63 IN PWCHAR ObjectClass
,
64 IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
67 return STATUS_UNSUCCESSFUL
;
77 KsAddObjectCreateItemToDeviceHeader(
78 IN KSDEVICE_HEADER DevHeader
,
79 IN PDRIVER_DISPATCH Create
,
81 IN PWCHAR ObjectClass
,
82 IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
84 PKSIDEVICE_HEADER Header
;
85 ULONG FreeIndex
, Index
;
87 Header
= (PKSIDEVICE_HEADER
)DevHeader
;
89 DPRINT1("KsAddObjectCreateItemToDeviceHeader entered\n");
91 /* check if a device header has been provided */
93 return STATUS_INVALID_PARAMETER_1
;
95 /* check if a create item has been provided */
97 return STATUS_INVALID_PARAMETER_2
;
99 /* check if a object class has been provided */
101 return STATUS_INVALID_PARAMETER_4
;
103 FreeIndex
= (ULONG
)-1;
104 /* now scan the list and check for a free item */
105 for(Index
= 0; Index
< Header
->MaxItems
; Index
++)
107 if (!Header
->ItemList
[Index
].bCreated
)
109 if (FreeIndex
== (ULONG
)-1)
114 else if (!wcsicmp(ObjectClass
, Header
->ItemList
[Index
].CreateItem
.ObjectClass
.Buffer
))
116 /* the same object class already exists */
117 return STATUS_OBJECT_NAME_COLLISION
;
120 /* found a free index */
121 if (FreeIndex
== (ULONG
)-1)
123 /* allocate a new device entry */
124 PDEVICE_ITEM Item
= ExAllocatePoolWithTag(NonPagedPool
, sizeof(DEVICE_ITEM
) * (Header
->MaxItems
+ 1), TAG_DEVICE_HEADER
);
126 return STATUS_INSUFFICIENT_RESOURCES
;
128 RtlMoveMemory(Item
, Header
->ItemList
, Header
->MaxItems
* sizeof(DEVICE_ITEM
));
129 ExFreePoolWithTag(Header
->ItemList
, TAG_DEVICE_HEADER
);
131 Header
->ItemList
= Item
;
132 FreeIndex
= Header
->MaxItems
;
136 /* store the new item */
137 Header
->ItemList
[FreeIndex
].bCreated
= TRUE
;
138 Header
->ItemList
[FreeIndex
].CreateItem
.Create
= Create
;
139 Header
->ItemList
[FreeIndex
].CreateItem
.Context
= Context
;
140 RtlInitUnicodeString(&Header
->ItemList
[FreeIndex
].CreateItem
.ObjectClass
, ObjectClass
);
141 Header
->ItemList
[FreeIndex
].CreateItem
.SecurityDescriptor
= SecurityDescriptor
;
142 Header
->ItemList
[FreeIndex
].CreateItem
.Flags
= 0;
143 return STATUS_SUCCESS
;
152 KsAllocateDeviceHeader(
153 OUT KSDEVICE_HEADER
* OutHeader
,
155 IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL
)
158 PKSIDEVICE_HEADER Header
;
161 return STATUS_INVALID_PARAMETER
;
163 /* allocate a device header */
164 Header
= ExAllocatePoolWithTag(PagedPool
, sizeof(KSIDEVICE_HEADER
), TAG_DEVICE_HEADER
);
166 /* check for success */
168 return STATUS_INSUFFICIENT_RESOURCES
;
170 /* clear all memory */
171 RtlZeroMemory(Header
, sizeof(KSIDEVICE_HEADER
));
173 /* initialize spin lock */
174 KeInitializeSpinLock(&Header
->ItemListLock
);
176 /* are there any create items provided */
177 if (ItemsCount
&& ItemsList
)
179 /* allocate space for device item list */
180 Header
->ItemList
= ExAllocatePoolWithTag(NonPagedPool
, sizeof(DEVICE_ITEM
) * ItemsCount
, TAG_DEVICE_HEADER
);
181 if (!Header
->ItemList
)
183 ExFreePoolWithTag(Header
, TAG_DEVICE_HEADER
);
184 return STATUS_INSUFFICIENT_RESOURCES
;
186 RtlZeroMemory(Header
->ItemList
, sizeof(DEVICE_ITEM
) * ItemsCount
);
188 for(Index
= 0; Index
< ItemsCount
; Index
++)
190 /* copy provided create items */
191 RtlMoveMemory(&Header
->ItemList
[Index
].CreateItem
, &ItemsList
[Index
], sizeof(KSOBJECT_CREATE_ITEM
));
192 if (ItemsList
[Index
].Create
!= NULL
)
194 Header
->ItemList
[Index
].bCreated
= TRUE
;
197 Header
->MaxItems
= ItemsCount
;
203 return STATUS_SUCCESS
;
209 http://www.osronline.com/DDKx/stream/ksfunc_3sc3.htm
214 KsAllocateObjectCreateItem(
215 IN KSDEVICE_HEADER DevHeader
,
216 IN PKSOBJECT_CREATE_ITEM CreateItem
,
217 IN BOOLEAN AllocateEntry
,
218 IN PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL
)
220 PKSIDEVICE_HEADER Header
;
222 Header
= (PKSIDEVICE_HEADER
)DevHeader
;
225 return STATUS_INVALID_PARAMETER_1
;
228 return STATUS_INVALID_PARAMETER_2
;
231 //handle ItemFreeCallback
233 if (AllocateEntry
&& ItemFreeCallback
)
234 DPRINT1("Ignoring ItemFreeCallback\n");
236 return KsAddObjectCreateItemToDeviceHeader(DevHeader
, CreateItem
->Create
, CreateItem
->Context
, CreateItem
->ObjectClass
.Buffer
, CreateItem
->SecurityDescriptor
);
247 IN KSDEVICE_HEADER DevHeader
)
249 PKSIDEVICE_HEADER Header
;
251 Header
= (PKSIDEVICE_HEADER
)DevHeader
;
256 ExFreePoolWithTag(Header
->ItemList
, TAG_DEVICE_HEADER
);
257 ExFreePoolWithTag(Header
, TAG_DEVICE_HEADER
);
263 KSDDKAPI NTSTATUS NTAPI
267 OUT PVOID
* ExtraBuffer
)
270 return STATUS_UNSUCCESSFUL
;
276 Initialize the required file context header.
277 Allocates KSOBJECT_HEADER structure.
278 Irp is an IRP_MJ_CREATE structure.
279 Driver must allocate KSDISPATCH_TABLE and initialize it first.
281 http://www.osronline.com/DDKx/stream/ksfunc_0u2b.htm
286 KsAllocateObjectHeader(
287 OUT KSOBJECT_HEADER
*Header
,
289 IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL
,
291 IN KSDISPATCH_TABLE
* Table
)
293 PIO_STACK_LOCATION IoStack
;
294 PDEVICE_EXTENSION DeviceExtension
;
295 PKSIDEVICE_HEADER DeviceHeader
;
296 PKSIOBJECT_HEADER ObjectHeader
;
297 WCHAR ObjectClass
[50];
300 return STATUS_INVALID_PARAMETER_1
;
303 return STATUS_INVALID_PARAMETER_4
;
306 return STATUS_INVALID_PARAMETER_5
;
308 /* get current stack location */
309 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
310 /* get device extension */
311 DeviceExtension
= (PDEVICE_EXTENSION
)IoStack
->DeviceObject
->DeviceExtension
;
312 /* get device header */
313 DeviceHeader
= DeviceExtension
->DeviceHeader
;
315 ObjectClass
[0] = L
'\0';
316 /* check for an file object */
317 if (IoStack
->FileObject
!= NULL
)
319 /* validate the file name */
320 if (IoStack
->FileObject
->FileName
.Length
>= 38)
322 RtlMoveMemory(ObjectClass
, IoStack
->FileObject
->FileName
.Buffer
, 38 * sizeof(WCHAR
));
323 ObjectClass
[38] = L
'\0';
324 DPRINT("ObjectClass %S\n", ObjectClass
);
327 /* allocate the object header */
328 ObjectHeader
= ExAllocatePoolWithTag(NonPagedPool
, sizeof(KSIOBJECT_HEADER
), TAG_DEVICE_HEADER
);
330 return STATUS_INSUFFICIENT_RESOURCES
;
332 /* initialize object header */
333 RtlZeroMemory(ObjectHeader
, sizeof(KSIOBJECT_HEADER
));
335 /* do we have a name */
338 ObjectHeader
->ObjectClass
= ExAllocatePoolWithTag(NonPagedPool
, 40 * sizeof(WCHAR
), TAG_DEVICE_HEADER
);
339 if (ObjectHeader
->ObjectClass
)
341 wcscpy(ObjectHeader
->ObjectClass
, ObjectClass
);
345 /* copy dispatch table */
346 RtlCopyMemory(&ObjectHeader
->DispatchTable
, Table
, sizeof(KSDISPATCH_TABLE
));
347 /* store create items */
348 if (ItemsCount
&& ItemsList
)
350 ObjectHeader
->ItemCount
= ItemsCount
;
351 ObjectHeader
->CreateItem
= ItemsList
;
354 /* was the request for a pin/clock/node */
355 if (IoStack
->FileObject
)
357 /* store the object in the file object */
358 ASSERT(IoStack
->FileObject
->FsContext
== NULL
);
359 IoStack
->FileObject
->FsContext
= ObjectHeader
;
363 /* the object header is for device */
364 ASSERT(DeviceHeader
->DeviceIndex
< DeviceHeader
->MaxItems
);
365 DeviceHeader
->ItemList
[DeviceHeader
->DeviceIndex
].ObjectHeader
= ObjectHeader
;
369 *Header
= ObjectHeader
;
372 DPRINT("KsAllocateObjectHeader ObjectClass %S FileObject %p, ObjectHeader %p\n", ObjectClass
, IoStack
->FileObject
, ObjectHeader
);
374 return STATUS_SUCCESS
;
396 IN OUT PLIST_ENTRY QueueHead
,
397 IN PKSPIN_LOCK SpinLock
)
407 IN PDEVICE_OBJECT DeviceObject
,
416 KSDDKAPI NTSTATUS NTAPI
417 KsDefaultDeviceIoCompletion(
418 IN PDEVICE_OBJECT DeviceObject
,
422 return STATUS_UNSUCCESSFUL
;
428 KSDDKAPI BOOLEAN NTAPI
429 KsDispatchFastIoDeviceControlFailure(
430 IN PFILE_OBJECT FileObject
,
432 IN PVOID InputBuffer OPTIONAL
,
433 IN ULONG InputBufferLength
,
434 OUT PVOID OutputBuffer OPTIONAL
,
435 IN ULONG OutputBufferLength
,
436 IN ULONG IoControlCode
,
437 OUT PIO_STATUS_BLOCK IoStatus
,
438 IN PDEVICE_OBJECT DeviceObject
) /* always return false */
446 KSDDKAPI BOOLEAN NTAPI
447 KsDispatchFastReadFailure(
448 IN PFILE_OBJECT FileObject
,
449 IN PLARGE_INTEGER FileOffset
,
454 OUT PIO_STATUS_BLOCK IoStatus
,
455 IN PDEVICE_OBJECT DeviceObject
) /* always return false */
461 Used in dispatch table entries that aren't handled and need to return
462 STATUS_INVALID_DEVICE_REQUEST.
464 KSDDKAPI NTSTATUS NTAPI
465 KsDispatchInvalidDeviceRequest(
466 IN PDEVICE_OBJECT DeviceObject
,
469 Irp
->IoStatus
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
470 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
472 return STATUS_INVALID_DEVICE_REQUEST
;
478 KSDDKAPI NTSTATUS NTAPI
479 KsDispatchSpecificMethod(
481 IN PFNKSHANDLER Handler
)
484 return STATUS_UNSUCCESSFUL
;
490 KSDDKAPI NTSTATUS NTAPI
491 KsDispatchSpecificProperty(
493 IN PFNKSHANDLER Handler
)
496 return STATUS_UNSUCCESSFUL
;
502 KSDDKAPI NTSTATUS NTAPI
503 KsForwardAndCatchIrp(
504 IN PDEVICE_OBJECT DeviceObject
,
506 IN PFILE_OBJECT FileObject
,
507 IN KSSTACK_USE StackUse
)
510 return STATUS_UNSUCCESSFUL
;
516 KSDDKAPI NTSTATUS NTAPI
519 IN PFILE_OBJECT FileObject
,
520 IN BOOLEAN ReuseStackLocation
)
523 return STATUS_UNSUCCESSFUL
;
529 KSDDKAPI NTSTATUS NTAPI
530 KsGetChildCreateParameter(
532 OUT PVOID
* CreateParameter
)
535 return STATUS_UNSUCCESSFUL
;
541 KSDDKAPI NTSTATUS NTAPI
542 KsMoveIrpsOnCancelableQueue(
543 IN OUT PLIST_ENTRY SourceList
,
544 IN PKSPIN_LOCK SourceLock
,
545 IN OUT PLIST_ENTRY DestinationList
,
546 IN PKSPIN_LOCK DestinationLock OPTIONAL
,
547 IN KSLIST_ENTRY_LOCATION ListLocation
,
548 IN PFNKSIRPLISTCALLBACK ListCallback
,
552 return STATUS_UNSUCCESSFUL
;
558 KSDDKAPI NTSTATUS NTAPI
565 return STATUS_UNSUCCESSFUL
;
571 KSDDKAPI NTSTATUS NTAPI
572 KsQueryInformationFile(
573 IN PFILE_OBJECT FileObject
,
574 OUT PVOID FileInformation
,
576 IN FILE_INFORMATION_CLASS FileInformationClass
)
579 return STATUS_UNSUCCESSFUL
;
585 KSDDKAPI ACCESS_MASK NTAPI
586 KsQueryObjectAccessMask(
587 IN KSOBJECT_HEADER Header
)
590 return STATUS_UNSUCCESSFUL
;
596 KSDDKAPI PKSOBJECT_CREATE_ITEM NTAPI
597 KsQueryObjectCreateItem(
598 IN KSOBJECT_HEADER Header
)
601 /* return STATUS_UNSUCCESSFUL; */
608 KSDDKAPI NTSTATUS NTAPI
610 IN PFILE_OBJECT FileObject
,
611 IN PKEVENT Event OPTIONAL
,
612 IN PVOID PortContext OPTIONAL
,
613 OUT PIO_STATUS_BLOCK IoStatusBlock
,
616 IN ULONG Key OPTIONAL
,
617 IN KPROCESSOR_MODE RequestorMode
)
620 return STATUS_UNSUCCESSFUL
;
627 KsReleaseIrpOnCancelableQueue(
629 IN PDRIVER_CANCEL DriverCancel OPTIONAL
)
640 KsRemoveIrpFromCancelableQueue(
641 IN OUT PLIST_ENTRY QueueHead
,
642 IN PKSPIN_LOCK SpinLock
,
643 IN KSLIST_ENTRY_LOCATION ListLocation
,
644 IN KSIRP_REMOVAL_OPERATION RemovalOperation
)
646 PQUEUE_ENTRY Entry
= NULL
;
650 if (!QueueHead
|| !SpinLock
)
653 if (ListLocation
!= KsListEntryTail
&& ListLocation
!= KsListEntryHead
)
656 if (RemovalOperation
!= KsAcquireOnly
&& RemovalOperation
!= KsAcquireAndRemove
)
659 KeAcquireSpinLock(SpinLock
, &OldIrql
);
661 if (!IsListEmpty(QueueHead
))
663 if (RemovalOperation
== KsAcquireOnly
)
665 if (ListLocation
== KsListEntryHead
)
666 Entry
= (PQUEUE_ENTRY
)QueueHead
->Flink
;
668 Entry
= (PQUEUE_ENTRY
)QueueHead
->Blink
;
670 else if (RemovalOperation
== KsAcquireAndRemove
)
672 if (ListLocation
== KsListEntryTail
)
673 Entry
= (PQUEUE_ENTRY
)RemoveTailList(QueueHead
);
675 Entry
= (PQUEUE_ENTRY
)RemoveHeadList(QueueHead
);
678 KeReleaseSpinLock(SpinLock
, OldIrql
);
685 if (RemovalOperation
== KsAcquireAndRemove
)
695 KsRemoveSpecificIrpFromCancelableQueue(
704 KSDDKAPI NTSTATUS NTAPI
705 KsSetInformationFile(
706 IN PFILE_OBJECT FileObject
,
707 IN PVOID FileInformation
,
709 IN FILE_INFORMATION_CLASS FileInformationClass
)
712 return STATUS_UNSUCCESSFUL
;
720 IN PDEVICE_OBJECT DeviceObject
,
723 //PIO_STACK_LOCATION IoStack;
724 PDEVICE_EXTENSION DeviceExtension
;
725 PKSIDEVICE_HEADER DeviceHeader
;
727 NTSTATUS Status
= STATUS_SUCCESS
;
730 DPRINT("KS / CREATE\n");
731 /* get current stack location */
732 //IoStack = IoGetCurrentIrpStackLocation(Irp);
733 /* get device extension */
734 DeviceExtension
= (PDEVICE_EXTENSION
)DeviceObject
->DeviceExtension
;
735 /* get device header */
736 DeviceHeader
= DeviceExtension
->DeviceHeader
;
738 /* acquire list lock */
739 KeAcquireSpinLock(&DeviceHeader
->ItemListLock
, &OldLevel
);
740 /* loop all device items */
741 for(Index
= 0; Index
< DeviceHeader
->MaxItems
; Index
++)
743 if (DeviceHeader
->ItemList
[Index
].bCreated
&& DeviceHeader
->ItemList
[Index
].ObjectHeader
== NULL
)
745 DeviceHeader
->DeviceIndex
= Index
;
746 /* set object create item */
747 KSCREATE_ITEM_IRP_STORAGE(Irp
) = &DeviceHeader
->ItemList
[Index
].CreateItem
;
748 Status
= DeviceHeader
->ItemList
[Index
].CreateItem
.Create(DeviceObject
, Irp
);
753 KeReleaseSpinLock(&DeviceHeader
->ItemListLock
, OldLevel
);
760 IN PDEVICE_OBJECT DeviceObject
,
763 PIO_STACK_LOCATION IoStack
;
764 PKSIOBJECT_HEADER ObjectHeader
;
766 /* get current stack location */
767 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
769 DPRINT("KS / CLOSE\n");
771 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
773 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
775 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
776 return ObjectHeader
->DispatchTable
.Close(DeviceObject
, Irp
);
780 DPRINT1("Expected Object Header\n");
781 return STATUS_SUCCESS
;
788 IN PDEVICE_OBJECT DeviceObject
,
791 PIO_STACK_LOCATION IoStack
;
792 PKSIOBJECT_HEADER ObjectHeader
;
794 /* get current stack location */
795 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
797 DPRINT("KS / DeviceControl\n");
798 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
800 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
802 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
803 return ObjectHeader
->DispatchTable
.DeviceIoControl(DeviceObject
, Irp
);
807 DPRINT1("Expected Object Header\n");
808 KeBugCheckEx(0, 0, 0, 0, 0);
809 return STATUS_SUCCESS
;
816 IN PDEVICE_OBJECT DeviceObject
,
819 PIO_STACK_LOCATION IoStack
;
820 PKSIOBJECT_HEADER ObjectHeader
;
822 /* get current stack location */
823 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
825 DPRINT("KS / Read\n");
826 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
828 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
830 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
831 return ObjectHeader
->DispatchTable
.Read(DeviceObject
, Irp
);
835 DPRINT1("Expected Object Header\n");
836 KeBugCheckEx(0, 0, 0, 0, 0);
837 return STATUS_SUCCESS
;
844 IN PDEVICE_OBJECT DeviceObject
,
847 PIO_STACK_LOCATION IoStack
;
848 PKSIOBJECT_HEADER ObjectHeader
;
850 /* get current stack location */
851 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
853 DPRINT("KS / Write\n");
854 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
856 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
858 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
859 return ObjectHeader
->DispatchTable
.Write(DeviceObject
, Irp
);
863 DPRINT1("Expected Object Header %p\n", IoStack
->FileObject
);
864 KeBugCheckEx(0, 0, 0, 0, 0);
865 return STATUS_SUCCESS
;
872 IN PDEVICE_OBJECT DeviceObject
,
875 PIO_STACK_LOCATION IoStack
;
876 PKSIOBJECT_HEADER ObjectHeader
;
878 /* get current stack location */
879 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
881 DPRINT("KS / FlushBuffers\n");
882 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
884 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
886 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
887 return ObjectHeader
->DispatchTable
.Flush(DeviceObject
, Irp
);
891 DPRINT1("Expected Object Header\n");
892 KeBugCheckEx(0, 0, 0, 0, 0);
893 return STATUS_SUCCESS
;
900 IN PDEVICE_OBJECT DeviceObject
,
903 PIO_STACK_LOCATION IoStack
;
904 PKSIOBJECT_HEADER ObjectHeader
;
906 /* get current stack location */
907 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
909 DPRINT("KS / QuerySecurity\n");
910 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
912 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
914 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
915 return ObjectHeader
->DispatchTable
.QuerySecurity(DeviceObject
, Irp
);
919 DPRINT1("Expected Object Header\n");
920 KeBugCheckEx(0, 0, 0, 0, 0);
921 return STATUS_SUCCESS
;
928 IN PDEVICE_OBJECT DeviceObject
,
931 PIO_STACK_LOCATION IoStack
;
932 PKSIOBJECT_HEADER ObjectHeader
;
934 /* get current stack location */
935 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
937 DPRINT("KS / SetSecurity\n");
938 if (IoStack
->FileObject
&& IoStack
->FileObject
->FsContext
)
940 ObjectHeader
= (PKSIOBJECT_HEADER
) IoStack
->FileObject
->FsContext
;
942 KSCREATE_ITEM_IRP_STORAGE(Irp
) = ObjectHeader
->CreateItem
;
943 return ObjectHeader
->DispatchTable
.SetSecurity(DeviceObject
, Irp
);
947 DPRINT1("Expected Object Header\n");
948 KeBugCheckEx(0, 0, 0, 0, 0);
949 return STATUS_SUCCESS
;
956 KSDDKAPI NTSTATUS NTAPI
957 KsSetMajorFunctionHandler(
958 IN PDRIVER_OBJECT DriverObject
,
959 IN ULONG MajorFunction
)
962 Sets a DriverObject's major function handler to point to an internal
963 function we implement.
965 TODO: Deal with KSDISPATCH_FASTIO
968 switch ( MajorFunction
)
971 DriverObject
->MajorFunction
[MajorFunction
] = KsCreate
;
974 DriverObject
->MajorFunction
[MajorFunction
] = KsClose
;
976 case IRP_MJ_DEVICE_CONTROL
:
977 DriverObject
->MajorFunction
[MajorFunction
] = KsDeviceControl
;
980 DriverObject
->MajorFunction
[MajorFunction
] = KsRead
;
983 DriverObject
->MajorFunction
[MajorFunction
] = KsWrite
;
985 case IRP_MJ_FLUSH_BUFFERS
:
986 DriverObject
->MajorFunction
[MajorFunction
] = KsFlushBuffers
;
988 case IRP_MJ_QUERY_SECURITY
:
989 DriverObject
->MajorFunction
[MajorFunction
] = KsQuerySecurity
;
991 case IRP_MJ_SET_SECURITY
:
992 DriverObject
->MajorFunction
[MajorFunction
] = KsSetSecurity
;
996 return STATUS_INVALID_PARAMETER
; /* is this right? */
999 return STATUS_SUCCESS
;
1009 IN PDEVICE_OBJECT DeviceObject
,
1012 PIO_STACK_LOCATION IoStack
;
1014 /* Calls a dispatch routine corresponding to the function code of the IRP */
1016 First we need to get the dispatch table. An opaque header is pointed to by
1017 FsContext. The first element points to this table. This table is the key
1018 to dispatching the IRP correctly.
1021 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
1022 DPRINT("KsDispatchIrp %x\n", IoStack
->MajorFunction
);
1024 switch (IoStack
->MajorFunction
)
1027 return KsCreate(DeviceObject
, Irp
);
1029 return KsClose(DeviceObject
, Irp
);
1031 case IRP_MJ_DEVICE_CONTROL
:
1032 return KsDeviceControl(DeviceObject
, Irp
);
1035 return KsRead(DeviceObject
, Irp
);
1038 return KsWrite(DeviceObject
, Irp
);
1040 case IRP_MJ_FLUSH_BUFFERS
:
1041 return KsFlushBuffers(DeviceObject
, Irp
);
1043 case IRP_MJ_QUERY_SECURITY
:
1044 return KsQuerySecurity(DeviceObject
, Irp
);
1046 case IRP_MJ_SET_SECURITY
:
1047 return KsSetSecurity(DeviceObject
, Irp
);
1050 return STATUS_INVALID_PARAMETER
; /* is this right? */
1062 IN PFILE_OBJECT FileObject
,
1063 IN PKEVENT Event OPTIONAL
,
1064 IN PVOID PortContext OPTIONAL
,
1065 IN PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
,
1066 IN PVOID CompletionContext OPTIONAL
,
1067 IN KSCOMPLETION_INVOCATION CompletionInvocationFlags OPTIONAL
,
1068 OUT PIO_STATUS_BLOCK IoStatusBlock
,
1069 IN OUT PVOID StreamHeaders
,
1072 IN KPROCESSOR_MODE RequestorMode
)
1075 PIO_STACK_LOCATION IoStack
;
1076 PDEVICE_OBJECT DeviceObject
;
1079 LARGE_INTEGER Offset
;
1080 PKSIOBJECT_HEADER ObjectHeader
;
1083 if (Flags
== KSSTREAM_READ
)
1085 else if (Flags
== KSSTREAM_WRITE
)
1086 Code
= IRP_MJ_WRITE
;
1088 return STATUS_INVALID_PARAMETER
;
1090 DeviceObject
= IoGetRelatedDeviceObject(FileObject
);
1092 return STATUS_INVALID_PARAMETER
;
1096 KeResetEvent(Event
);
1099 //ASSERT(DeviceObject->DeviceType == FILE_DEVICE_KS);
1100 ObjectHeader
= (PKSIOBJECT_HEADER
)FileObject
->FsContext
;
1101 ASSERT(ObjectHeader
);
1102 if (Code
== IRP_MJ_READ
)
1104 if (ObjectHeader
->DispatchTable
.FastRead
)
1106 if (ObjectHeader
->DispatchTable
.FastRead(FileObject
, NULL
, Length
, FALSE
, 0, StreamHeaders
, IoStatusBlock
, DeviceObject
))
1108 return STATUS_SUCCESS
;
1114 if (ObjectHeader
->DispatchTable
.FastWrite
)
1116 if (ObjectHeader
->DispatchTable
.FastWrite(FileObject
, NULL
, Length
, FALSE
, 0, StreamHeaders
, IoStatusBlock
, DeviceObject
))
1118 return STATUS_SUCCESS
;
1123 Offset
.QuadPart
= 0LL;
1124 Irp
= IoBuildSynchronousFsdRequest(Code
, DeviceObject
, (PVOID
)StreamHeaders
, Length
, &Offset
, Event
, IoStatusBlock
);
1127 return STATUS_UNSUCCESSFUL
;
1131 if (CompletionRoutine
)
1133 IoSetCompletionRoutine(Irp
,
1136 (CompletionInvocationFlags
& KsInvokeOnSuccess
),
1137 (CompletionInvocationFlags
& KsInvokeOnError
),
1138 (CompletionInvocationFlags
& KsInvokeOnCancel
));
1141 IoStack
= IoGetNextIrpStackLocation(Irp
);
1142 IoStack
->FileObject
= FileObject
;
1144 Status
= IoCallDriver(DeviceObject
, Irp
);
1151 KSDDKAPI NTSTATUS NTAPI
1153 IN PFILE_OBJECT FileObject
,
1154 IN PKEVENT Event OPTIONAL
,
1155 IN PVOID PortContext OPTIONAL
,
1156 OUT PIO_STATUS_BLOCK IoStatusBlock
,
1159 IN ULONG Key OPTIONAL
,
1160 IN KPROCESSOR_MODE RequestorMode
)
1163 return STATUS_UNSUCCESSFUL
;
1169 KSDDKAPI NTSTATUS NTAPI
1170 KsDefaultForwardIrp(
1171 IN PDEVICE_OBJECT DeviceObject
,
1175 Irp
->IoStatus
.Information
= 0;
1176 Irp
->IoStatus
.Status
= STATUS_UNSUCCESSFUL
;
1177 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
1178 return STATUS_UNSUCCESSFUL
;