aadf762d637520bf23361511cfca661a5eac726e
[reactos.git] / reactos / include / ddk / iofuncs.h
1 /* $Id: iofuncs.h,v 1.5 1999/12/26 20:21:02 ea Exp $ */
2 /* IO MANAGER ***************************************************************/
3
4 BOOLEAN
5 IoRaiseInformationalHardError (
6 NTSTATUS ErrorStatus,
7 PUNICODE_STRING String,
8 PKTHREAD Thread
9 );
10
11
12 /*
13 * FUNCTION: Registers the driver with WMI
14 * ARGUMENTS:
15 * DeviceObject = Device to register
16 * Action = Action to take
17 * RETURNS: Status (?)
18 */
19 //NTSTATUS IoWMIRegistrationControl(DeviceObject, WMIREGACTION Action);
20
21 /*
22 * FUNCTION: Synchronizes cancelable-state transistions for IRPs in a
23 * multiprocessor-safe way
24 * ARGUMENTS:
25 * Irpl = Variable to store the current IRQ level
26 */
27 VOID
28 IoAcquireCancelSpinLock (
29 PKIRQL Irpl
30 );
31
32 typedef
33 IO_ALLOCATION_ACTION
34 (*PDRIVER_CONTROL) (
35 PDEVICE_OBJECT DeviceObject,
36 PIRP irp,
37 PVOID MapRegisterBase,
38 PVOID Context
39 );
40
41 /*
42 * FUNCTION: Allocates an adaptor object for a DMA operation on the target
43 * device
44 * ARGUMENTS:
45 * Adaptor = Adapter channel or busmaster adapter to be allocated
46 * DeviceObject = Target device for DMA
47 * NumberOfMapRegisters = Number of map registers
48 * ExecutionRoutine = Routine to be called when the adaptor is
49 * available
50 * Context = driver defined contex that will be passed to the
51 * execution routine
52 * RETURNS: Success or failure code
53 */
54 NTSTATUS
55 IoAllocateAdapterChannel (
56 PADAPTER_OBJECT AdaperObject,
57 PDEVICE_OBJECT DeviceObject,
58 ULONG NumberOfMapRegisters,
59 PDRIVER_CONTROL ExecutionRoutine,
60 PVOID Context
61 );
62
63 /*
64 * FUNCTION: Sets up a call to a driver supplied controller object as
65 * soon as it is available
66 * ARGUMENTS:
67 * ControllerObject = Driver created controller object
68 * DeviceObject = target device
69 * ExecutionObject = Routine to be called
70 * Context = Driver determined context to be based to the routine
71 */
72 VOID
73 IoAllocateController (
74 PCONTROLLER_OBJECT ControllerObject,
75 PDEVICE_OBJECT DeviceObject,
76 PDRIVER_CONTROL ExecutionRoutine,
77 PVOID Context
78 );
79
80 /*
81 * FUNCTION: Allocates an error log packet
82 * ARGUMENTS:
83 * IoObject = Object which found the error
84 * EntrySize = Size in bytes of the packet to be allocated
85 * RETURNS: On success a pointer to the allocated packet
86 * On failure returns NULL
87 */
88 PVOID
89 IoAllocateErrorLogEntry (
90 PVOID IoObject,
91 UCHAR EntrySize
92 );
93
94 /*
95 * FUNCTION: Allocates an IRP
96 * ARGUMENTS:
97 * StackSize = number of stack locations to allocate
98 * ChargeQuota = Who knows
99 * RETURNS: On success the allocated IRP
100 * On failure NULL
101 */
102 PIRP
103 IoAllocateIrp (
104 CCHAR StackSize,
105 BOOLEAN ChargeQuota
106 );
107
108 /*
109 * FUNCTION: Allocates an MDL large enough to map the supplied buffer
110 * ARGUMENTS:
111 * VirtualAddress = base virtual address of the buffer to be mapped
112 * Length = length of the buffer to be mapped
113 * SecondaryBuffer = Whether the buffer is primary or secondary
114 * ChargeQuota = Charge non-paged pool quota to current thread
115 * Irp = Optional irp to be associated with the MDL
116 * RETURNS: On the success the allocated MDL
117 * On failure NULL
118 */
119 PMDL
120 IoAllocateMdl (
121 PVOID VirtualAddress,
122 ULONG Length,
123 BOOLEAN SecondaryBuffer,
124 BOOLEAN ChargeQuota,
125 PIRP Irp
126 );
127
128 /*
129 * FUNCTION: Creates a symbolic link between the ARC name of a physical
130 * device and the name of the corresponding device object
131 * ARGUMENTS:
132 * ArcName = ARC name of the device
133 * DeviceName = Name of the device object
134 */
135 VOID
136 IoAssignArcName (
137 PUNICODE_STRING ArcName,
138 PUNICODE_STRING DeviceName
139 );
140
141 enum
142 {
143 IO_NO_INCREMENT,
144 };
145
146 /*
147 * FUNCTION: Takes a list of requested hardware resources and allocates them
148 * ARGUMENTS:
149 * RegisterPath =
150 * DriverClassName =
151 * DriverObject = Driver object passed to the DriverEntry routine
152 * DeviceObject =
153 * RequestedResources = List of resources
154 * RETURNS:
155 */
156 NTSTATUS
157 IoAssignResources (
158 PUNICODE_STRING RegistryPath,
159 PUNICODE_STRING DriverClassName,
160 PDRIVER_OBJECT DriverObject,
161 PDEVICE_OBJECT DeviceObject,
162 PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
163 PCM_RESOURCE_LIST * AllocatedResources
164 );
165
166 /*
167 * FUNCTION: Attaches the callers device object to a named target device
168 * ARGUMENTS:
169 * SourceDevice = caller's device
170 * TargetDevice = Name of the target device
171 * AttachedDevice = Caller allocated storage. On return contains
172 * a pointer to the target device
173 * RETURNS: Success or failure code
174 */
175 NTSTATUS
176 IoAttachDevice (
177 PDEVICE_OBJECT SourceDevice,
178 PUNICODE_STRING TargetDevice,
179 PDEVICE_OBJECT * AttachedDevice
180 );
181
182 /*
183 * FUNCTION: Obsolete
184 * ARGUMENTS:
185 * SourceDevice = device to attach
186 * TargetDevice = device to be attached to
187 * RETURNS: Success or failure code
188 */
189 NTSTATUS
190 IoAttachDeviceByPointer (
191 PDEVICE_OBJECT SourceDevice,
192 PDEVICE_OBJECT TargetDevice
193 );
194
195 /*
196 * FUNCTION: Attaches the callers device to the highest device in the chain
197 * ARGUMENTS:
198 * SourceDevice = caller's device
199 * TargetDevice = Device to attach
200 * RETURNS: On success the previously highest device
201 * On failure NULL
202 */
203 PDEVICE_OBJECT
204 IoAttachDeviceToDeviceStack (
205 PDEVICE_OBJECT SourceDevice,
206 PDEVICE_OBJECT TargetDevice
207 );
208
209 /*
210 * FUNCTION: Builds a irp to be sent to lower level drivers
211 * ARGUMENTS:
212 * MajorFunction = Major function code to be set in the IRP
213 * DeviceObject = Next lower device object
214 * Buffer = Buffer (only required for some major function codes)
215 * Length = Length in bytes of the buffer
216 * StartingOffset = Starting offset on the target device
217 * IoStatusBlock = Storage for status about the operation (optional)
218 * RETURNS: On success the IRP allocated
219 * On failure NULL
220 */
221 PIRP
222 IoBuildAsynchronousFsdRequest (
223 ULONG MajorFunction,
224 PDEVICE_OBJECT DeviceObject,
225 PVOID Buffer,
226 ULONG Length,
227 PLARGE_INTEGER StartingOffset,
228 PIO_STATUS_BLOCK IoStatusBlock
229 );
230
231 /*
232 * FUNCTION: Allocates and sets up an IRP for a device control request
233 * ARGUMENTS:
234 * IoControlCode = Type of request
235 * DeviceObject = Target device
236 * InputBuffer = Optional input buffer to the driver
237 * InputBufferLength = Length of the input buffer
238 * OutputBuffer = Optional output buffer
239 * OutputBufferLength = Length of the output buffer
240 * InternalDeviceIoControl = TRUE if the request is internal
241 * Event = Initialized event for the caller to wait for the request
242 * to be completed
243 * IoStatusBlock = I/O status block to be set when the request is
244 * completed
245 * RETURNS: Returns the IRP created
246 */
247 PIRP
248 IoBuildDeviceIoControlRequest (
249 ULONG IoControlCode,
250 PDEVICE_OBJECT DeviceObject,
251 PVOID InputBuffer,
252 ULONG InputBufferLength,
253 PVOID OutputBuffer,
254 ULONG OutputBufferLength,
255 BOOLEAN InternalDeviceIoControl,
256 PKEVENT Event,
257 PIO_STATUS_BLOCK IoStatusBlock
258 );
259
260
261 VOID
262 IoBuildPartialMdl (
263 PMDL SourceMdl,
264 PMDL TargetMdl,
265 PVOID VirtualAddress,
266 ULONG Length
267 );
268
269 PIRP
270 IoBuildSynchronousFsdRequest (
271 ULONG MajorFunction,
272 PDEVICE_OBJECT DeviceObject,
273 PVOID Buffer,
274 ULONG Length,
275 PLARGE_INTEGER StartingOffset,
276 PKEVENT Event,
277 PIO_STATUS_BLOCK IoStatusBlock
278 );
279
280 /*
281 * FUNCTION: Sends an irp to the next lower driver
282 */
283 NTSTATUS
284 IoCallDriver (
285 PDEVICE_OBJECT DeviceObject,
286 PIRP irp
287 );
288
289 BOOLEAN
290 IoCancelIrp (
291 PIRP Irp
292 );
293
294 NTSTATUS
295 IoCheckShareAccess (
296 ACCESS_MASK DesiredAccess,
297 ULONG DesiredShareAccess,
298 PFILE_OBJECT FileObject,
299 PSHARE_ACCESS ShareAccess,
300 BOOLEAN Update
301 );
302
303 /*
304 * FUNCTION: Indicates the caller has finished all processing for a given
305 * I/O request and is returning the given IRP to the I/O manager
306 * ARGUMENTS:
307 * Irp = Irp to be cancelled
308 * PriorityBoost = Increment by which to boost the priority of the
309 * thread making the request
310 */
311 VOID
312 IoCompleteRequest (
313 PIRP Irp,
314 CCHAR PriorityBoost
315 );
316
317 NTSTATUS
318 IoConnectInterrupt (
319 PKINTERRUPT * InterruptObject,
320 PKSERVICE_ROUTINE ServiceRoutine,
321 PVOID ServiceContext,
322 PKSPIN_LOCK SpinLock,
323 ULONG Vector,
324 KIRQL Irql,
325 KIRQL SynchronizeIrql,
326 KINTERRUPT_MODE InterruptMode,
327 BOOLEAN ShareVector,
328 KAFFINITY ProcessorEnableMask,
329 BOOLEAN FloatingSave
330 );
331
332 PCONTROLLER_OBJECT
333 IoCreateController (
334 ULONG Size
335 );
336
337 /*
338 * FUNCTION: Allocates memory for and intializes a device object for use for
339 * a driver
340 * ARGUMENTS:
341 * DriverObject : Driver object passed by iomgr when the driver was
342 * loaded
343 * DeviceExtensionSize : Number of bytes for the device extension
344 * DeviceName : Unicode name of device
345 * DeviceType : Device type
346 * DeviceCharacteristics : Bit mask of device characteristics
347 * Exclusive : True if only one thread can access the device at a
348 * time
349 * RETURNS:
350 * Success or failure
351 * DeviceObject : Contains a pointer to allocated device object
352 * if the call succeeded
353 * NOTES: See the DDK documentation for more information
354 */
355 NTSTATUS
356 IoCreateDevice (
357 PDRIVER_OBJECT DriverObject,
358 ULONG DeviceExtensionSize,
359 PUNICODE_STRING DeviceName,
360 DEVICE_TYPE DeviceType,
361 ULONG DeviceCharacteristics,
362 BOOLEAN Exclusive,
363 PDEVICE_OBJECT * DeviceObject
364 );
365
366 NTSTATUS
367 STDCALL
368 IoCreateFile (
369 OUT PHANDLE FileHandle,
370 IN ACCESS_MASK DesiredAccess,
371 IN POBJECT_ATTRIBUTES ObjectAttributes,
372 OUT PIO_STATUS_BLOCK IoStatusBlock,
373 IN PLARGE_INTEGER AllocationSize OPTIONAL,
374 IN ULONG FileAttributes,
375 IN ULONG ShareAccess,
376 IN ULONG CreateDisposition,
377 IN ULONG CreateOptions,
378 IN PVOID EaBuffer OPTIONAL,
379 IN ULONG EaLength,
380 IN CREATE_FILE_TYPE CreateFileType,
381 IN ULONG ExtraCreateParameters,
382 IN ULONG Options
383 );
384 PKEVENT
385 IoCreateNotificationEvent (
386 PUNICODE_STRING EventName,
387 PHANDLE EventHandle
388 );
389
390 NTSTATUS
391 STDCALL
392 IoCreateSymbolicLink (
393 PUNICODE_STRING SymbolicLinkName,
394 PUNICODE_STRING DeviceName
395 );
396
397 PKEVENT
398 IoCreateSynchronizationEvent (
399 PUNICODE_STRING EventName,
400 PHANDLE EventHandle
401 );
402
403 NTSTATUS
404 STDCALL
405 IoCreateUnprotectedSymbolicLink (
406 PUNICODE_STRING SymbolicLinkName,
407 PUNICODE_STRING DeviceName
408 );
409
410
411 VOID
412 IoDeassignArcName (
413 PUNICODE_STRING ArcName
414 );
415
416 VOID
417 IoDeleteController (
418 PCONTROLLER_OBJECT ControllerObject
419 );
420
421 VOID
422 IoDeleteDevice (
423 PDEVICE_OBJECT DeviceObject
424 );
425
426 NTSTATUS
427 STDCALL
428 IoDeleteSymbolicLink (
429 PUNICODE_STRING SymbolicLinkName
430 );
431
432 VOID
433 IoDetachDevice (
434 PDEVICE_OBJECT TargetDevice
435 );
436
437 VOID
438 IoDisconnectInterrupt (
439 PKINTERRUPT InterruptObject
440 );
441
442 BOOLEAN
443 IoFlushAdapterBuffers (
444 PADAPTER_OBJECT AdapterObject,
445 PMDL Mdl,
446 PVOID MapRegisterBase,
447 PVOID CurrentVa,
448 ULONG Length,
449 BOOLEAN WriteToDevice
450 );
451
452 VOID
453 IoFreeAdapterChannel (
454 PADAPTER_OBJECT AdapterObject
455 );
456
457 VOID
458 IoFreeController (
459 PCONTROLLER_OBJECT ControllerObject
460 );
461
462 VOID
463 IoFreeIrp (
464 PIRP Irp
465 );
466
467 VOID
468 IoFreeMapRegisters (
469 PADAPTER_OBJECT AdapterObject,
470 PVOID MapRegisterBase,
471 ULONG NumberOfMapRegisters
472 );
473
474 VOID
475 IoFreeMdl (
476 PMDL Mdl
477 );
478
479 PCONFIGURATION_INFORMATION
480 IoGetConfigurationInformation (VOID);
481
482
483 /*
484 * FUNCTION: Returns a pointer to the callers stack location in the irp
485 */
486 PIO_STACK_LOCATION
487 IoGetCurrentIrpStackLocation (
488 IRP * irp
489 );
490
491 struct _EPROCESS *
492 IoGetCurrentProcess (VOID);
493
494 NTSTATUS
495 IoGetDeviceObjectPointer (
496 PUNICODE_STRING ObjectName,
497 ACCESS_MASK DesiredAccess,
498 PFILE_OBJECT * FileObject,
499 PDEVICE_OBJECT * DeviceObject
500 );
501
502 PDEVICE_OBJECT
503 IoGetDeviceToVerify (
504 PETHREAD Thread
505 );
506
507 PGENERIC_MAPPING
508 IoGetFileObjectGenericMapping (VOID);
509
510 ULONG
511 IoGetFunctionCodeFromCtlCode (
512 ULONG ControlCode
513 );
514
515 PVOID
516 IoGetInitialStack (VOID);
517
518 /*
519 * FUNCTION:
520 */
521 PIO_STACK_LOCATION
522 IoGetNextIrpStackLocation (
523 IRP * irp
524 );
525
526 PDEVICE_OBJECT
527 IoGetRelatedDeviceObject (
528 PFILE_OBJECT FileObject
529 );
530
531 VOID
532 IoInitializeDpcRequest (
533 PDEVICE_OBJECT DeviceObject,
534 PIO_DPC_ROUTINE DpcRoutine
535 );
536
537 /*
538 * FUNCTION: Initalizes an irp allocated by the caller
539 * ARGUMENTS:
540 * Irp = IRP to initalize
541 * PacketSize = Size in bytes of the IRP
542 * StackSize = Number of stack locations in the IRP
543 */
544 VOID
545 IoInitializeIrp (
546 PIRP Irp,
547 USHORT PacketSize,
548 CCHAR StackSize
549 );
550
551 NTSTATUS
552 IoInitializeTimer (
553 PDEVICE_OBJECT DeviceObject,
554 PIO_TIMER_ROUTINE TimerRoutine,
555 PVOID Context
556 );
557
558 BOOLEAN
559 IoIsErrorUserInduced (
560 NTSTATUS Status
561 );
562
563 BOOLEAN
564 IoIsTotalDeviceFailure (
565 NTSTATUS Status
566 );
567
568 PIRP
569 IoMakeAssociatedIrp (
570 PIRP Irp,
571 CCHAR StackSize
572 );
573
574 PHYSICAL_ADDRESS
575 IoMapTransfer (
576 PADAPTER_OBJECT AdapterObject,
577 PMDL Mdl,
578 PVOID MapRegisterBase,
579 PVOID CurrentVa,
580 PULONG Length,
581 BOOLEAN WriteToDevice
582 );
583
584 /*
585 * FUNCTION: Marks an IRP as pending
586 * ARGUMENTS:
587 * Irp = Irp to mark
588 * NOTE: If a driver doesn't complete the irp in its dispatch routine it
589 * must mark it pending otherwise the I/O manager will complete it on
590 * return from the dispatch routine.
591 */
592 VOID
593 IoMarkIrpPending (
594 PIRP Irp
595 );
596
597 NTSTATUS
598 IoQueryDeviceDescription (
599 PINTERFACE_TYPE BusType,
600 PULONG BusNumber,
601 PCONFIGURATION_TYPE ControllerType,
602 PULONG ControllerNumber,
603 PCONFIGURATION_TYPE PeripheralType,
604 PULONG PeripheralNumber,
605 PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
606 PVOID Context
607 );
608
609 VOID
610 IoRaiseHardError (
611 PIRP Irp,
612 PVPB Vpb,
613 PDEVICE_OBJECT RealDeviceObject
614 );
615
616 BOOLEAN
617 IoRaiseHardInformationalError (
618 NTSTATUS ErrorStatus,
619 PUNICODE_STRING String,
620 PKTHREAD Thread
621 );
622
623 NTSTATUS
624 IoReadPartitionTable (
625 PDEVICE_OBJECT DeviceObject,
626 ULONG SectorSize,
627 BOOLEAN ReturnedRecognizedPartitions,
628 struct _DRIVE_LAYOUT_INFORMATION ** PBuffer
629 );
630
631 VOID
632 IoRegisterDriverReinitialization (
633 PDRIVER_OBJECT DriverObject,
634 PDRIVER_REINITIALIZE ReinitRoutine,
635 PVOID Context
636 );
637
638 NTSTATUS
639 IoRegisterShutdownNotification (
640 PDEVICE_OBJECT DeviceObject
641 );
642
643 VOID
644 IoReleaseCancelSpinLock (
645 KIRQL Irql
646 );
647
648 VOID
649 IoRemoveShareAccess (
650 PFILE_OBJECT FileObject,
651 PSHARE_ACCESS ShareAccess
652 );
653
654 NTSTATUS
655 IoReportResourceUsage (
656 PUNICODE_STRING DriverClassName,
657 PDRIVER_OBJECT DriverObject,
658 PCM_RESOURCE_LIST DriverList,
659 ULONG DriverListSize,
660 PDEVICE_OBJECT DeviceObject,
661 PCM_RESOURCE_LIST DeviceList,
662 ULONG DeviceListSize,
663 BOOLEAN OverrideConflict,
664 PBOOLEAN ConflictDetected
665 );
666
667 VOID
668 IoRequestDpc (
669 PDEVICE_OBJECT DeviceObject,
670 PIRP Irp,
671 PVOID Context
672 );
673
674 PDRIVER_CANCEL
675 IoSetCancelRoutine (
676 PIRP Irp,
677 PDRIVER_CANCEL CancelRoutine
678 );
679
680 VOID
681 IoSetCompletionRoutine (
682 PIRP Irp,
683 PIO_COMPLETION_ROUTINE CompletionRoutine,
684 PVOID Context,
685 BOOLEAN InvokeOnSuccess,
686 BOOLEAN InvokeOnError,
687 BOOLEAN InvokeOnCancel
688 );
689
690 VOID
691 IoSetHardErrorOrVerifyDevice (
692 PIRP Irp,
693 PDEVICE_OBJECT DeviceObject
694 );
695
696 VOID
697 IoSetNextIrpStackLocation (
698 PIRP Irp
699 );
700
701 NTSTATUS
702 IoSetPartitionInformation (
703 PDEVICE_OBJECT DeviceObject,
704 ULONG SectorSize,
705 ULONG PartitionNumber,
706 ULONG PartitionType
707 );
708
709 VOID
710 IoSetShareAccess (
711 ACCESS_MASK DesiredAccess,
712 ULONG DesiredShareAccess,
713 PFILE_OBJECT FileObject,
714 PSHARE_ACCESS ShareAccess
715 );
716
717 /*
718 * FUNCTION: Determines the size of an IRP
719 * ARGUMENTS:
720 * StackSize = number of stack locations in the IRP
721 * RETURNS: The size of the IRP in bytes
722 */
723 USHORT
724 IoSizeOfIrp (
725 CCHAR StackSize
726 );
727
728 /*
729 * FUNCTION: Dequeues the next IRP from the device's associated queue and
730 * calls its StartIo routine
731 * ARGUMENTS:
732 * DeviceObject = Device object
733 * Cancelable = True if IRPs in the queue can be cancelled
734 */
735 VOID
736 IoStartNextPacket (
737 PDEVICE_OBJECT DeviceObject,
738 BOOLEAN Cancelable
739 );
740
741 VOID
742 IoStartNextPacketByKey (
743 PDEVICE_OBJECT DeviceObject,
744 BOOLEAN Cancelable,
745 ULONG Key
746 );
747
748 /*
749 * FUNCTION: Calls the drivers StartIO routine with the IRP or queues it if
750 * the device is busy
751 * ARGUMENTS:
752 * DeviceObject = Device to pass the IRP to
753 * Irp = Irp to be processed
754 * Key = Optional value for where to insert the IRP
755 * CancelFunction = Entry point for a driver supplied cancel function
756 */
757 VOID
758 IoStartPacket (
759 PDEVICE_OBJECT DeviceObject,
760 PIRP Irp,
761 PULONG Key,
762 PDRIVER_CANCEL CancelFunction
763 );
764
765 VOID
766 IoStartTimer (
767 PDEVICE_OBJECT DeviceObject
768 );
769
770 VOID
771 IoStopTimer (
772 PDEVICE_OBJECT DeviceObject
773 );
774
775 VOID
776 IoUnregisterShutdownNotification (
777 PDEVICE_OBJECT DeviceObject
778 );
779
780 VOID
781 IoUpdateShareAccess (
782 PFILE_OBJECT FileObject,
783 PSHARE_ACCESS ShareAccess
784 );
785
786 VOID
787 IoWriteErrorLogEntry (
788 PVOID ElEntry
789 );
790
791 NTSTATUS
792 IoWritePartitionTable (
793 PDEVICE_OBJECT DeviceObject,
794 ULONG SectorSize,
795 ULONG SectorsPerTrack,
796 ULONG NumberOfHeads,
797 struct _DRIVE_LAYOUT_INFORMATION* PBuffer
798 );
799
800
801 // Preliminary guess
802 NTKERNELAPI
803 NTSTATUS
804 IoQueryFileVolumeInformation (
805 IN PFILE_OBJECT FileObject,
806 IN FS_INFORMATION_CLASS FsInformationClass,
807 IN ULONG Length,
808 OUT PVOID FsInformation,
809 OUT PULONG ReturnedLength
810 );
811
812 NTKERNELAPI // confirmed - Undocumented because it does not require a valid file handle
813 NTSTATUS
814 IoQueryFileInformation (
815 IN PFILE_OBJECT FileObject,
816 IN FILE_INFORMATION_CLASS FileInformationClass,
817 IN ULONG Length,
818 OUT PVOID FileInformation,
819 OUT PULONG ReturnedLength
820 );
821
822 VOID
823 IoRegisterFileSystem (
824 PDEVICE_OBJECT DeviceObject
825 );
826
827 PDEVICE_OBJECT
828 IoGetAttachedDevice (
829 PDEVICE_OBJECT DeviceObject
830 );
831
832 PFILE_OBJECT
833 IoCreateStreamFileObject (
834 PFILE_OBJECT FileObject,
835 PDEVICE_OBJECT DeviceObject
836 );
837