test: iop.h Source File

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# iop.h

Go to the documentation of this file.

    00001 /*++ BUILD Version: 0002
    00002
    00003 Copyright (c) 1989  Microsoft Corporation
    00004
    00005 Module Name:
    00006
    00007     iop.h
    00008
    00009 Abstract:
    00010
    00011     This module contains the private structure definitions and APIs used by
    00012     the NT I/O system.
    00013
    00014 Author:
    00015
    00016     Darryl E. Havens (darrylh) 17-Apr-1989
    00017
    00018
    00019 Revision History:
    00020
    00021
    00022 --*/
    00023
    00024 #ifndef _IOP_
    00025 #define _IOP_
    00026
    00027 #ifndef FAR
    00028 #define FAR
    00029 #endif
    00030
    00031 #include "ntos.h"
    00032 #include "ntdddisk.h"
    00033 #include "ntddscsi.h"
    00034 #include "mountmgr.h"
    00035 #include "ntiodump.h"
    00036 #include "ntiolog.h"
    00037 #include "ntiologc.h"
    00038 #include "ntseapi.h"
    00039 #include "zwapi.h"
    00040 #include "stdio.h"
    00041 #include "stdlib.h"
    00042 #include "string.h"
    00043 #include "fsrtl.h"
    00044 #include "pnpiop.h"
    00045 #include "ioverifier.h"
    00046
    00047 #ifdef POOL_TAGGING
    00048 #undef ExAllocatePool
    00049 #define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'  oI')
    00050 #undef ExAllocatePoolWithQuota
    00051 #define ExAllocatePoolWithQuota(a,b) ExAllocatePoolWithQuotaTag(a,b,'  oI')
    00052 #endif
    00053
    00054
    00055 #include "safeboot.h"
    00056
    00057 extern ULONG BreakDiskByteOffset;
    00058 extern ULONG BreakPfn;
    00059
    00060 //
    00061 // Define Information fields values for the return value from popups when a
    00062 // volume mount is in progress but failed.
    00063 //
    00064
    00065 #define IOP_ABORT                       1
    00066
    00067 //
    00068 // Define transfer types for process counters.
    00069 //
    00070
    00071 typedef enum _TRANSFER_TYPE {
    00072     ReadTransfer,
    00073     WriteTransfer,
    00074     OtherTransfer
    00075 } TRANSFER_TYPE, *PTRANSFER_TYPE;
    00076
    00077 //
    00078 // Define the maximum amount of memory that can be allocated for all
    00079 // outstanding error log packets.
    00080 //
    00081
    00082 #define IOP_MAXIMUM_LOG_ALLOCATION PAGE_SIZE
    00083
    00084 //
    00085 // Define an error log entry.
    00086 //
    00087
    00088 typedef struct _ERROR_LOG_ENTRY {
    00089     USHORT Type;
    00090     USHORT Size;
    00091     LIST_ENTRY ListEntry;
    00092     PDEVICE_OBJECT DeviceObject;
    00093     PDRIVER_OBJECT DriverObject;
    00094     LARGE_INTEGER TimeStamp;
    00095 } ERROR_LOG_ENTRY, *PERROR_LOG_ENTRY;
    00096
    00097 //
    00098 //  Define both the global IOP_HARD_ERROR_QUEUE and IOP_HARD_ERROR_PACKET
    00099 //  structures.   Also set the maximum number of outstanding hard error
    00100 //  packets allowed.
    00101 //
    00102
    00103 typedef struct _IOP_HARD_ERROR_QUEUE {
    00104     WORK_QUEUE_ITEM ExWorkItem;
    00105     LIST_ENTRY WorkQueue;
    00106     KSPIN_LOCK WorkQueueSpinLock;
    00107     KSEMAPHORE WorkQueueSemaphore;
    00108     BOOLEAN ThreadStarted;
    00109     ULONG   NumPendingApcPopups;
    00110 } IOP_HARD_ERROR_QUEUE, *PIOP_HARD_ERROR_QUEUE;
    00111
    00112 typedef struct _IOP_HARD_ERROR_PACKET {
    00113     LIST_ENTRY WorkQueueLinks;
    00114     NTSTATUS ErrorStatus;
    00115     UNICODE_STRING String;
    00116 } IOP_HARD_ERROR_PACKET, *PIOP_HARD_ERROR_PACKET;
    00117
    00118 typedef struct _IOP_APC_HARD_ERROR_PACKET {
    00119     WORK_QUEUE_ITEM Item;
    00120     PIRP Irp;
    00121     PVPB Vpb;
    00122     PDEVICE_OBJECT RealDeviceObject;
    00123 } IOP_APC_HARD_ERROR_PACKET, *PIOP_APC_HARD_ERROR_PACKET;
    00124
    00125 typedef
    00126 NTSTATUS
    00127 (FASTCALL *PIO_CALL_DRIVER) (
    00128     IN PDEVICE_OBJECT DeviceObject,
    00129     IN PIRP Irp
    00130     );
    00131
    00132 typedef
    00133 VOID
    00134 (FASTCALL *PIO_COMPLETE_REQUEST) (
    00135     IN PIRP Irp,
    00136     IN CCHAR PriorityBoost
    00137     );
    00138
    00139 typedef
    00140 VOID
    00141 (*PIO_FREE_IRP) (
    00142     IN struct _IRP *Irp
    00143     );
    00144
    00145 typedef
    00146 PIRP
    00147 (*PIO_ALLOCATE_IRP) (
    00148     IN CCHAR   StackSize,
    00149     IN BOOLEAN ChargeQuota
    00150     );
    00151
    00152 extern IOP_HARD_ERROR_QUEUE IopHardError;
    00153 extern PIOP_HARD_ERROR_PACKET IopCurrentHardError;
    00154
    00155 #define IOP_MAXIMUM_OUTSTANDING_HARD_ERRORS 25
    00156
    00157 typedef struct _IO_WORKITEM {
    00158     WORK_QUEUE_ITEM WorkItem;
    00159     PIO_WORKITEM_ROUTINE Routine;
    00160     PDEVICE_OBJECT DeviceObject;
    00161     PVOID Context;
    00162 #if DBG
    00163     ULONG Size;
    00164 #endif
    00165 } IO_WORKITEM;
    00166
    00167 //
    00168 // Define the global data for the error logger and I/O system.
    00169 //
    00170
    00171 extern WORK_QUEUE_ITEM IopErrorLogWorkItem;
    00172 extern BOOLEAN IopErrorLogPortPending;
    00173 extern BOOLEAN IopErrorLogDisabledThisBoot;
    00174 extern KSPIN_LOCK IopErrorLogLock;
    00175 extern LIST_ENTRY IopErrorLogListHead;
    00176 extern ULONG IopErrorLogAllocation;
    00177 extern KSPIN_LOCK IopErrorLogAllocationLock;
    00178 extern KSPIN_LOCK IopCancelSpinLock;
    00179 extern KSPIN_LOCK IopVpbSpinLock;
    00180 extern GENERIC_MAPPING IopFileMapping;
    00181 extern GENERIC_MAPPING IopCompletionMapping;
    00182
    00183 //
    00184 // Define a dummy file object for use on stack for fast open operations.
    00185 //
    00186
    00187 typedef struct _DUMMY_FILE_OBJECT {
    00188     OBJECT_HEADER ObjectHeader;
    00189     CHAR FileObjectBody[ sizeof( FILE_OBJECT ) ];
    00190 } DUMMY_FILE_OBJECT, *PDUMMY_FILE_OBJECT;
    00191
    00192 //
    00193 // Define the structures private to the I/O system.
    00194 //
    00195
    00196 #define OPEN_PACKET_PATTERN  0xbeaa0251
    00197
    00198 //
    00199 // Define an Open Packet (OP).  An OP is used to communicate information
    00200 // between the NtCreateFile service executing in the context of the caller
    00201 // and the device object parse routine.  It is the parse routine who actually
    00202 // creates the file object for the file.
    00203 //
    00204
    00205 typedef struct _OPEN_PACKET {
    00206     CSHORT Type;
    00207     CSHORT Size;
    00208     PFILE_OBJECT FileObject;
    00209     NTSTATUS FinalStatus;
    00210     ULONG_PTR Information;
    00211     ULONG ParseCheck;
    00212     PFILE_OBJECT RelatedFileObject;
    00213
    00214     //
    00215     // The following are the open-specific parameters.  Notice that the desired
    00216     // access field is passed through to the parse routine via the object
    00217     // management architecture, so it does not need to be repeated here.  Also
    00218     // note that the same is true for the file name.
    00219     //
    00220
    00221     LARGE_INTEGER AllocationSize;
    00222     ULONG CreateOptions;
    00223     USHORT FileAttributes;
    00224     USHORT ShareAccess;
    00225     PVOID EaBuffer;
    00226     ULONG EaLength;
    00227     ULONG Options;
    00228     ULONG Disposition;
    00229
    00230     //
    00231     // The following is used when performing a fast query during open to get
    00232     // back the file attributes for a file.
    00233     //
    00234
    00235     PFILE_BASIC_INFORMATION BasicInformation;
    00236
    00237     //
    00238     // The following is used when performing a fast network query during open
    00239     // to get back the network file attributes for a file.
    00240     //
    00241
    00242     PFILE_NETWORK_OPEN_INFORMATION NetworkInformation;
    00243
    00244     //
    00245     // The type of file to create.
    00246     //
    00247
    00248     CREATE_FILE_TYPE CreateFileType;
    00249
    00250     //
    00251     // The following pointer provides a way of passing the parameters
    00252     // specific to the file type of the file being created to the parse
    00253     // routine.
    00254     //
    00255
    00256     PVOID ExtraCreateParameters;
    00257
    00258     //
    00259     // The following is used to indicate that an open of a device has been
    00260     // performed and the access check for the device has already been done,
    00261     // but because of a reparse, the I/O system has been called again for
    00262     // the same device.  Since the access check has already been made, the
    00263     // state cannot handle being called again (access was already granted)
    00264     // and it need not anyway since the check has already been made.
    00265     //
    00266
    00267     BOOLEAN Override;
    00268
    00269     //
    00270     // The following is used to indicate that a file is being opened for the
    00271     // sole purpose of querying its attributes.  This causes a considerable
    00272     // number of shortcuts to be taken in the parse, query, and close paths.
    00273     //
    00274
    00275     BOOLEAN QueryOnly;
    00276
    00277     //
    00278     // The following is used to indicate that a file is being opened for the
    00279     // sole purpose of deleting it.  This causes a considerable number of
    00280     // shortcurs to be taken in the parse and close paths.
    00281     //
    00282
    00283     BOOLEAN DeleteOnly;
    00284
    00285     //
    00286     // The following is used to indicate that a file being opened for a query
    00287     // only is being opened to query its network attributes rather than just
    00288     // its FAT file attributes.
    00289     //
    00290
    00291     BOOLEAN FullAttributes;
    00292
    00293     //
    00294     // The following pointer is used when a fast open operation for a fast
    00295     // delete or fast query attributes call is being made rather than a
    00296     // general file open.  The dummy file object is actually stored on the
    00297     // the caller's stack rather than allocated pool to speed things up.
    00298     //
    00299
    00300     PDUMMY_FILE_OBJECT LocalFileObject;
    00301
    00302 } OPEN_PACKET, *POPEN_PACKET;
    00303
    00304 //
    00305 // Define a Load Packet (LDP).  An LDP is used to communicate load and unload
    00306 // driver information between the appropriate system services and the routine
    00307 // that actually performs the work.  This is implemented using a packet
    00308 // because various drivers need to be initialized in the context of THE
    00309 // system process because they create threads within its context which open
    00310 // handles to objects that henceforth are only valid in the context of that
    00311 // process.
    00312 //
    00313
    00314 typedef struct _LOAD_PACKET {
    00315     WORK_QUEUE_ITEM WorkQueueItem;
    00316     KEVENT Event;
    00317     PDRIVER_OBJECT DriverObject;
    00318     PUNICODE_STRING DriverServiceName;
    00319     NTSTATUS FinalStatus;
    00320 } LOAD_PACKET, *PLOAD_PACKET;
    00321
    00322 //
    00323 // Define a Link Tracking Packet.  A link tracking packet is used to open the
    00324 // user-mode link tracking service's LPC port so that information about objects
    00325 // which have been moved can be tracked.
    00326 //
    00327
    00328 typedef struct _LINK_TRACKING_PACKET {
    00329     WORK_QUEUE_ITEM WorkQueueItem;
    00330     KEVENT Event;
    00331     NTSTATUS FinalStatus;
    00332 } LINK_TRACKING_PACKET, *PLINK_TRACKING_PACKET;
    00333
    00334 //
    00335 // Define the type for entries placed on the driver reinitialization queue.
    00336 // These entries are entered onto the tail when the driver requests that
    00337 // it be reinitialized, and removed from the head by the code that actually
    00338 // performs the reinitialization.
    00339 //
    00340
    00341 typedef struct _REINIT_PACKET {
    00342     LIST_ENTRY ListEntry;
    00343     PDRIVER_OBJECT DriverObject;
    00344     PDRIVER_REINITIALIZE DriverReinitializationRoutine;
    00345     PVOID Context;
    00346 } REINIT_PACKET, *PREINIT_PACKET;
    00347
    00348 //
    00349 // Define the type for entries placed on the driver shutdown notification queue.
    00350 // These entries represent those drivers that would like to be notified that the
    00351 // system is begin shutdown before it actually goes down.
    00352 //
    00353
    00354 typedef struct _SHUTDOWN_PACKET {
    00355     LIST_ENTRY ListEntry;
    00356     PDEVICE_OBJECT DeviceObject;
    00357 } SHUTDOWN_PACKET, *PSHUTDOWN_PACKET;
    00358
    00359 //
    00360 // Define the type for entries placed on the file system registration change
    00361 // notification queue.
    00362 //
    00363
    00364 typedef struct _NOTIFICATION_PACKET {
    00365     LIST_ENTRY ListEntry;
    00366     PDRIVER_OBJECT DriverObject;
    00367     PDRIVER_FS_NOTIFICATION NotificationRoutine;
    00368 } NOTIFICATION_PACKET, *PNOTIFICATION_PACKET;
    00369
    00370 //
    00371 // Define I/O completion packet types.
    00372 //
    00373
    00374 typedef enum _COMPLETION_PACKET_TYPE {
    00375     IopCompletionPacketIrp,
    00376     IopCompletionPacketMini,
    00377     IopCompletionPacketQuota
    00378 } COMPLETION_PACKET_TYPE, *PCOMPLETION_PACKET_TYPE;
    00379
    00380 //
    00381 // Define the type for completion packets inserted onto completion ports when
    00382 // there is no full I/O request packet that was used to perform the I/O
    00383 // operation.  This occurs when the fast I/O path is used, and when the user
    00384 // directly inserts a completion message.
    00385 //
    00386 typedef struct _IOP_MINI_COMPLETION_PACKET {
    00387
    00388     //
    00389     // The following unnamed structure must be exactly identical
    00390     // to the unnamed structure used in the IRP overlay section used
    00391     // for completion queue entries.
    00392     //
    00393
    00394     struct {
    00395
    00396         //
    00397         // List entry - used to queue the packet to completion queue, among
    00398         // others.
    00399         //
    00400
    00401         LIST_ENTRY ListEntry;
    00402
    00403         union {
    00404
    00405             //
    00406             // Current stack location - contains a pointer to the current
    00407             // IO_STACK_LOCATION structure in the IRP stack.  This field
    00408             // should never be directly accessed by drivers.  They should
    00409             // use the standard functions.
    00410             //
    00411
    00412             struct _IO_STACK_LOCATION *CurrentStackLocation;
    00413
    00414             //
    00415             // Minipacket type.
    00416             //
    00417
    00418             ULONG PacketType;
    00419         };
    00420     };
    00421
    00422     PVOID KeyContext;
    00423     PVOID ApcContext;
    00424     NTSTATUS IoStatus;
    00425     ULONG_PTR IoStatusInformation;
    00426 } IOP_MINI_COMPLETION_PACKET, *PIOP_MINI_COMPLETION_PACKET;
    00427
    00428 //
    00429 // Define the type for a dump control block.  This structure is used to describe
    00430 // all of the data, drivers, and memory necessary to dump all of physical memory
    00431 // to the disk after a bugcheck.
    00432 //
    00433
    00434 typedef struct _MINIPORT_NODE {
    00435     LIST_ENTRY ListEntry;
    00436     PLDR_DATA_TABLE_ENTRY DriverEntry;
    00437     ULONG DriverChecksum;
    00438 } MINIPORT_NODE, *PMINIPORT_NODE;
    00439
    00440 #define IO_TYPE_DCB                     0xff
    00441
    00442 #define DCB_DUMP_ENABLED                 0x01
    00443 #define DCB_SUMMARY_ENABLED              0x02
    00444 #define DCB_AUTO_REBOOT                  0x04
    00445 #define DCB_DUMP_HEADER_ENABLED          0x10
    00446 #define DCB_SUMMARY_DUMP_ENABLED         0x20
    00447 #define DCB_TRIAGE_DUMP_ENABLED          0x40
    00448 #define DCB_TRIAGE_DUMP_ACT_UPON_ENABLED 0x80
    00449
    00450 typedef struct _DUMP_CONTROL_BLOCK {
    00451     UCHAR Type;
    00452     CHAR Flags;
    00453     USHORT Size;
    00454     CCHAR NumberProcessors;
    00455     CHAR Reserved;
    00456     USHORT ProcessorArchitecture;
    00457     PDUMP_STACK_CONTEXT DumpStack;
    00458     PPHYSICAL_MEMORY_DESCRIPTOR MemoryDescriptor;
    00459     ULONG MemoryDescriptorLength;
    00460     PLARGE_INTEGER FileDescriptorArray;
    00461     ULONG FileDescriptorSize;
    00462     PULONG HeaderPage;
    00463     PFN_NUMBER HeaderPfn;
    00464     ULONG MajorVersion;
    00465     ULONG MinorVersion;
    00466     ULONG BuildNumber;
    00467     CHAR VersionUser[32];
    00468     ULONG HeaderSize;               // Size of dump header includes summary dump.
    00469     LARGE_INTEGER DumpFileSize;     // Size of dump file.
    00470     ULONG TriageDumpFlags;          // Flags for triage dump.
    00471     PUCHAR TriageDumpBuffer;        // Buffer for triage dump.
    00472     ULONG TriageDumpBufferSize;     // Size of triage dump buffer.
    00473 } DUMP_CONTROL_BLOCK, *PDUMP_CONTROL_BLOCK;
    00474
    00475
    00476 //
    00477 // Define the global data for the I/O system.
    00478 //
    00479
    00480 #define IOP_FIXED_SIZE_MDL_PFNS        0x17
    00481
    00482 extern KSPIN_LOCK IopDatabaseLock;
    00483 extern ERESOURCE IopDatabaseResource;
    00484 extern ERESOURCE IopSecurityResource;
    00485 extern LIST_ENTRY IopDiskFileSystemQueueHead;
    00486 extern LIST_ENTRY IopCdRomFileSystemQueueHead;
    00487 extern LIST_ENTRY IopNetworkFileSystemQueueHead;
    00488 extern LIST_ENTRY IopTapeFileSystemQueueHead;
    00489 extern LIST_ENTRY IopBootDriverReinitializeQueueHead;
    00490 extern LIST_ENTRY IopDriverReinitializeQueueHead;
    00491 extern LIST_ENTRY IopNotifyShutdownQueueHead;
    00492 extern LIST_ENTRY IopNotifyLastChanceShutdownQueueHead;
    00493 extern LIST_ENTRY IopFsNotifyChangeQueueHead;
    00494 extern KSPIN_LOCK IoStatisticsLock;
    00495 extern KSEMAPHORE IopRegistrySemaphore;
    00496 extern KSPIN_LOCK IopTimerLock;
    00497 extern LIST_ENTRY IopTimerQueueHead;
    00498 extern KDPC IopTimerDpc;
    00499 extern KTIMER IopTimer;
    00500 extern ULONG IopTimerCount;
    00501 extern ULONG IopLargeIrpStackLocations;
    00502 extern KSPIN_LOCK IopCompletionLock;
    00503
    00504 extern POBJECT_TYPE IoAdapterObjectType;
    00505 extern POBJECT_TYPE IoCompletionObjectType;
    00506 extern POBJECT_TYPE IoControllerObjectType;
    00507 extern POBJECT_TYPE IoDeviceObjectType;
    00508 extern POBJECT_TYPE IoDriverObjectType;
    00509 extern POBJECT_TYPE IoDeviceHandlerObjectType;
    00510 extern POBJECT_TYPE IoFileObjectType;
    00511 extern ULONG        IoDeviceHandlerObjectSize;
    00512
    00513 extern NPAGED_LOOKASIDE_LIST IopLargeIrpLookasideList;
    00514 extern NPAGED_LOOKASIDE_LIST IopSmallIrpLookasideList;
    00515 extern NPAGED_LOOKASIDE_LIST IopMdlLookasideList;
    00516 extern NPAGED_LOOKASIDE_LIST IopCompletionLookasideList;
    00517
    00518 extern UCHAR IopQueryOperationLength[];
    00519 extern UCHAR IopSetOperationLength[];
    00520 extern ULONG IopQueryOperationAccess[];
    00521 extern ULONG IopSetOperationAccess[];
    00522 extern UCHAR IopQuerySetAlignmentRequirement[];
    00523 extern UCHAR IopQueryFsOperationLength[];
    00524 extern UCHAR IopSetFsOperationLength[];
    00525 extern ULONG IopQueryFsOperationAccess[];
    00526 extern ULONG IopSetFsOperationAccess[];
    00527 extern UCHAR IopQuerySetFsAlignmentRequirement[];
    00528
    00529 extern UNICODE_STRING IoArcBootDeviceName;
    00530 extern UNICODE_STRING IoArcHalDeviceName;
    00531 extern PUCHAR IoLoaderArcBootDeviceName;
    00532 extern PDUMP_CONTROL_BLOCK IopDumpControlBlock;
    00533 extern ULONG IopDumpControlBlockChecksum;
    00534
    00535 extern LONG IopUniqueDeviceObjectNumber;
    00536
    00537 extern PVOID IopLinkTrackingServiceObject;
    00538 extern PKEVENT IopLinkTrackingServiceEvent;
    00539 extern KEVENT IopLinkTrackingPortObject;
    00540 extern LINK_TRACKING_PACKET IopLinkTrackingPacket;
    00541
    00542 extern PVOID IopLoaderBlock;
    00543
    00544 extern BOOLEAN IopRemoteBootCardInitialized;
    00545
    00546 extern ULONG IopLookasideIrpFloat;
    00547 extern ULONG IopLookasideIrpLimit;
    00548 extern BOOLEAN  IopVerifierOn;
    00549
    00550 extern PIO_CALL_DRIVER        pIofCallDriver;
    00551 extern PIO_COMPLETE_REQUEST   pIofCompleteRequest;
    00552 extern PIO_FREE_IRP           pIoFreeIrp;
    00553 extern PIO_ALLOCATE_IRP       pIoAllocateIrp;
    00554
    00555 //
    00556 // The following declaration cannot go in EX.H since POBJECT_TYPE is not defined
    00557 // until OB.H, which depends on EX.H.  Hence, it is not exported by the EX
    00558 // component at all.
    00559 //
    00560
    00561 extern POBJECT_TYPE ExEventObjectType;
    00562
    00563 //
    00564 // Define routines private to the I/O system.
    00565 //
    00566
    00567 VOID
    00568 IopAbortRequest(
    00569     IN PKAPC Apc
    00570     );
    00571
    00572 //+
    00573 //
    00574 // BOOLEAN
    00575 // IopAcquireFastLock(
    00576 //     IN PFILE_OBJECT FileObject
    00577 // )
    00578 //
    00579 // Routine Description:
    00580 //
    00581 //     This routine is invoked to acquire the fast lock for a file object.
    00582 //     This lock protects the busy indicator in the file object resource.
    00583 //
    00584 // Arguments:
    00585 //
    00586 //     FileObject - Pointer to the file object to be locked.
    00587 //
    00588 // Return Values:
    00589 //
    00590 //      FALSE - the fileobject was not locked (it was busy)
    00591 //      TRUE  - the fileobject was locked & the busy flag has been set to TRUE
    00592 //
    00593 //-
    00594
    00595 #define IopAcquireFastLock( FileObject )    \
    00596     ( InterlockedExchange( &FileObject->Busy, (ULONG) TRUE ) == FALSE )
    00597
    00598 #define IopAcquireCancelSpinLockAtDpcLevel()    \
    00599     ExAcquireSpinLockAtDpcLevel (&IopCancelSpinLock)
    00600
    00601 #define IopReleaseCancelSpinLockFromDpcLevel()  \
    00602     ExReleaseSpinLockFromDpcLevel (&IopCancelSpinLock)
    00603
    00604 #define IopAllocateIrp(StackSize, ChargeQuota) \
    00605         IoAllocateIrp((StackSize), (ChargeQuota))
    00606
    00607 #define IsIoVerifierOn()    IopVerifierOn
    00608
    00609
    00610 NTSTATUS
    00611 IopAcquireFileObjectLock(
    00612     IN PFILE_OBJECT FileObject,
    00613     IN KPROCESSOR_MODE RequestorMode,
    00614     IN BOOLEAN Alertable,
    00615     OUT PBOOLEAN Interrupted
    00616     );
    00617
    00618
    00619 VOID
    00620 IopAllocateIrpCleanup(
    00621     IN PFILE_OBJECT FileObject,
    00622     IN PKEVENT EventObject OPTIONAL
    00623     );
    00624
    00625 PIRP
    00626 IopAllocateIrpMustSucceed(
    00627     IN CCHAR StackSize
    00628     );
    00629
    00630 VOID
    00631 IopApcHardError(
    00632     IN PVOID StartContext
    00633     );
    00634
    00635 VOID
    00636 IopCancelAlertedRequest(
    00637     IN PKEVENT Event,
    00638     IN PIRP Irp
    00639     );
    00640
    00641 VOID
    00642 IopCheckBackupRestorePrivilege(
    00643     IN PACCESS_STATE AccessState,
    00644     IN OUT PULONG CreateOptions,
    00645     IN KPROCESSOR_MODE PreviousMode,
    00646     IN ULONG Disposition
    00647     );
    00648
    00649 NTSTATUS
    00650 IopCheckGetQuotaBufferValidity(
    00651     IN PFILE_GET_QUOTA_INFORMATION QuotaBuffer,
    00652     IN ULONG QuotaLength,
    00653     OUT PULONG_PTR ErrorOffset
    00654     );
    00655
    00656 VOID
    00657 IopCloseFile(
    00658     IN PEPROCESS Process OPTIONAL,
    00659     IN PVOID Object,
    00660     IN ULONG GrantedAccess,
    00661     IN ULONG ProcessHandleCount,
    00662     IN ULONG SystemHandleCount
    00663     );
    00664
    00665 VOID
    00666 IopCompleteUnloadOrDelete(
    00667     IN PDEVICE_OBJECT DeviceObject,
    00668     IN KIRQL Irql
    00669     );
    00670
    00671 VOID
    00672 IopCompletePageWrite(
    00673     IN PKAPC Apc,
    00674     IN PKNORMAL_ROUTINE *NormalRoutine,
    00675     IN PVOID *NormalContext,
    00676     IN PVOID *SystemArgument1,
    00677     IN PVOID *SystemArgument2
    00678     );
    00679
    00680 VOID
    00681 IopCompleteRequest(
    00682     IN PKAPC Apc,
    00683     IN PKNORMAL_ROUTINE *NormalRoutine,
    00684     IN PVOID *NormalContext,
    00685     IN PVOID *SystemArgument1,
    00686     IN PVOID *SystemArgument2
    00687     );
    00688
    00689 VOID
    00690 IopConnectLinkTrackingPort(
    00691     IN PVOID Parameter
    00692     );
    00693
    00694 VOID
    00695 IopCreateVpb (
    00696     IN PDEVICE_OBJECT DeviceObject
    00697     );
    00698
    00699 VOID
    00700 IopDeallocateApc(
    00701     IN PKAPC Apc,
    00702     IN PKNORMAL_ROUTINE *NormalRoutine,
    00703     IN PVOID *NormalContext,
    00704     IN PVOID *SystemArgument1,
    00705     IN PVOID *SystemArgument2
    00706     );
    00707
    00708 VOID
    00709 IopDecrementDeviceObjectRef(
    00710     IN PDEVICE_OBJECT DeviceObject,
    00711     IN BOOLEAN AlwaysUnload
    00712     );
    00713
    00714 VOID
    00715 IopDeleteDriver(
    00716     IN PVOID Object
    00717     );
    00718
    00719 VOID
    00720 IopDeleteDevice(
    00721     IN PVOID Object
    00722     );
    00723
    00724 VOID
    00725 IopDeleteFile(
    00726     IN PVOID Object
    00727     );
    00728
    00729 VOID
    00730 IopDeleteIoCompletion(
    00731     IN PVOID Object
    00732     );
    00733
    00734 //+
    00735 //
    00736 // VOID
    00737 // IopDequeueThreadIrp(
    00738 //     IN PIRP Irp
    00739 //     )
    00740 //
    00741 // Routine Description:
    00742 //
    00743 //     This routine dequeues the specified I/O Request Packet (IRP) from the
    00744 //     thread IRP queue which it is currently queued.
    00745 //
    00746 //     In checked we set Flink == Blink so we can assert free's of queue'd IRPs
    00747 //
    00748 // Arguments:
    00749 //
    00750 //     Irp - Specifies the IRP that is dequeued.
    00751 //
    00752 // Return Value:
    00753 //
    00754 //     None.
    00755 //
    00756 //-
    00757
    00758 #define IopDequeueThreadIrp( Irp ) \
    00759    { \
    00760    RemoveEntryList( &Irp->ThreadListEntry ); \
    00761    InitializeListHead( &Irp->ThreadListEntry ) ; \
    00762    }
    00763
    00764
    00765 #ifdef  _WIN64
    00766 #define IopApcRoutinePresent(ApcRoutine)    ARGUMENT_PRESENT((ULONG_PTR)(ApcRoutine) & ~1)
    00767 #else
    00768 #define IopApcRoutinePresent(ApcRoutine)    ARGUMENT_PRESENT(ApcRoutine)
    00769 #endif
    00770
    00771 VOID
    00772 IopDisassociateThreadIrp(
    00773     VOID
    00774     );
    00775
    00776 BOOLEAN
    00777 IopDmaDispatch(
    00778     IN PKINTERRUPT Interrupt,
    00779     IN PVOID ServiceContext
    00780     );
    00781
    00782 VOID
    00783 IopDropIrp(
    00784     IN PIRP Irp,
    00785     IN PFILE_OBJECT FileObject
    00786     );
    00787
    00788 LONG
    00789 IopExceptionFilter(
    00790     IN PEXCEPTION_POINTERS ExceptionPointers,
    00791     OUT PNTSTATUS ExceptionCode
    00792     );
    00793
    00794 VOID
    00795 IopExceptionCleanup(
    00796     IN PFILE_OBJECT FileObject,
    00797     IN PIRP Irp,
    00798     IN PKEVENT EventObject OPTIONAL,
    00799     IN PKEVENT KernelEvent OPTIONAL
    00800     );
    00801
    00802 VOID
    00803 IopErrorLogThread(
    00804     IN PVOID StartContext
    00805     );
    00806
    00807 VOID
    00808 IopFreeIrpAndMdls(
    00809     IN PIRP Irp
    00810     );
    00811
    00812 PDEVICE_OBJECT
    00813 IopGetDeviceAttachmentBase(
    00814     IN PDEVICE_OBJECT DeviceObject
    00815     );
    00816
    00817 PDEVICE_OBJECT
    00818 IopGetDeviceAttachmentBaseRef(
    00819     IN PDEVICE_OBJECT DeviceObject
    00820     );
    00821
    00822 NTSTATUS
    00823 IopGetDriverNameFromKeyNode(
    00824     IN HANDLE KeyHandle,
    00825     OUT PUNICODE_STRING DriverName
    00826     );
    00827
    00828 ULONG
    00829 IopGetDumpControlBlockCheck (
    00830     IN PDUMP_CONTROL_BLOCK  Dcb
    00831     );
    00832
    00833 NTSTATUS
    00834 IopGetFileName(
    00835     IN PFILE_OBJECT FileObject,
    00836     IN ULONG Length,
    00837     OUT PVOID FileInformation,
    00838     OUT PULONG ReturnedLength
    00839     );
    00840
    00841 BOOLEAN
    00842 IopGetMountFlag(
    00843     IN PDEVICE_OBJECT DeviceObject
    00844     );
    00845
    00846 NTSTATUS
    00847 IopGetRegistryKeyInformation(
    00848     IN HANDLE KeyHandle,
    00849     OUT PKEY_FULL_INFORMATION *Information
    00850     );
    00851
    00852 NTSTATUS
    00853 IopGetRegistryValue(
    00854     IN HANDLE KeyHandle,
    00855     IN PWSTR  ValueName,
    00856     OUT PKEY_VALUE_FULL_INFORMATION *Information
    00857     );
    00858
    00859 NTSTATUS
    00860 IopGetRegistryValues(
    00861     IN HANDLE KeyHandle,
    00862     IN PKEY_VALUE_FULL_INFORMATION *ValueList
    00863     );
    00864
    00865 NTSTATUS
    00866 IopGetRegistryValues(
    00867     IN HANDLE KeyHandle,
    00868     IN PKEY_VALUE_FULL_INFORMATION *ValueList
    00869     );
    00870
    00871 NTSTATUS
    00872 IopGetSetObjectId(
    00873     IN PFILE_OBJECT FileObject,
    00874     IN OUT PVOID Buffer,
    00875     IN ULONG Length,
    00876     IN ULONG OperationFlags
    00877     );
    00878
    00879 NTSTATUS
    00880 IopGetSetSecurityObject(
    00881     IN PVOID Object,
    00882     IN SECURITY_OPERATION_CODE OperationCode,
    00883     IN PSECURITY_INFORMATION SecurityInformation,
    00884     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
    00885     IN OUT PULONG CapturedLength,
    00886     IN OUT PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
    00887     IN POOL_TYPE PoolType,
    00888     IN PGENERIC_MAPPING GenericMapping
    00889     );
    00890
    00891 NTSTATUS
    00892 IopGetVolumeId(
    00893     IN PFILE_OBJECT FileObject,
    00894     IN OUT PLINK_TRACKING_INFORMATION ObjectId,
    00895     IN ULONG Length
    00896     );
    00897
    00898 VOID
    00899 IopHardErrorThread(
    00900     PVOID StartContext
    00901     );
    00902
    00903 //++
    00904 //
    00905 // VOID
    00906 // IopInitializeIrp(
    00907 //     IN OUT PIRP Irp,
    00908 //     IN USHORT PacketSize,
    00909 //     IN CCHAR StackSize
    00910 //     )
    00911 //
    00912 // Routine Description:
    00913 //
    00914 //     Initializes an IRP.
    00915 //
    00916 // Arguments:
    00917 //
    00918 //     Irp - a pointer to the IRP to initialize.
    00919 //
    00920 //     PacketSize - length, in bytes, of the IRP.
    00921 //
    00922 //     StackSize - Number of stack locations in the IRP.
    00923 //
    00924 // Return Value:
    00925 //
    00926 //     None.
    00927 //
    00928 //--
    00929
    00930 #define IopInitializeIrp( Irp, PacketSize, StackSize ) {          \
    00931     RtlZeroMemory( (Irp), (PacketSize) );                         \
    00932     (Irp)->Type = (CSHORT) IO_TYPE_IRP;                           \
    00933     (Irp)->Size = (USHORT) ((PacketSize));                        \
    00934     (Irp)->StackCount = (CCHAR) ((StackSize));                    \
    00935     (Irp)->CurrentLocation = (CCHAR) ((StackSize) + 1);           \
    00936     (Irp)->ApcEnvironment = KeGetCurrentApcEnvironment();         \
    00937     InitializeListHead (&(Irp)->ThreadListEntry);                 \
    00938     (Irp)->Tail.Overlay.CurrentStackLocation =                    \
    00939         ((PIO_STACK_LOCATION) ((UCHAR *) (Irp) +                  \
    00940             sizeof( IRP ) +                                       \
    00941             ( (StackSize) * sizeof( IO_STACK_LOCATION )))); }
    00942
    00943 VOID
    00944 IopInitializeResourceMap (
    00945     PLOADER_PARAMETER_BLOCK LoaderBlock
    00946     );
    00947
    00948 VOID
    00949 IopInsertRemoveDevice(
    00950     IN PDRIVER_OBJECT DriverObject,
    00951     IN PDEVICE_OBJECT DeviceObject,
    00952     IN BOOLEAN Insert
    00953     );
    00954
    00955 NTSTATUS
    00956 IopInvalidDeviceRequest(
    00957     IN PDEVICE_OBJECT DeviceObject,
    00958     IN PIRP Irp
    00959     );
    00960
    00961 NTSTATUS
    00962 IopInvalidateVolumesForDevice(
    00963     IN PDEVICE_OBJECT DeviceObject
    00964     );
    00965
    00966 BOOLEAN
    00967 IopIsSameMachine(
    00968     IN PFILE_OBJECT SourceFile,
    00969     IN HANDLE TargetFile
    00970     );
    00971
    00972 NTSTATUS
    00973 IopLoadDriver(
    00974     IN HANDLE KeyHandle,
    00975     IN BOOLEAN CheckForSafeBoot
    00976     );
    00977
    00978 VOID
    00979 IopLoadFileSystemDriver(
    00980     IN PDEVICE_OBJECT DeviceObject
    00981     );
    00982
    00983 VOID
    00984 IopLoadUnloadDriver(
    00985     IN PVOID Parameter
    00986     );
    00987
    00988 NTSTATUS
    00989 IopLookupBusStringFromID (
    00990     IN  HANDLE KeyHandle,
    00991     IN  INTERFACE_TYPE InterfaceType,
    00992     OUT PWCHAR Buffer,
    00993     IN  ULONG Length,
    00994     OUT PULONG BusFlags OPTIONAL
    00995     );
    00996
    00997 NTSTATUS
    00998 IopMountVolume(
    00999     IN PDEVICE_OBJECT DeviceObject,
    01000     IN BOOLEAN AllowRawMount,
    01001     IN BOOLEAN DeviceLockAlreadyHeld,
    01002     IN BOOLEAN Alertable
    01003     );
    01004
    01005 BOOLEAN
    01006 IopNotifyPnpWhenChainDereferenced(
    01007     IN PDEVICE_OBJECT *PhysicalDeviceObjects,
    01008     IN ULONG DeviceObjectCount,
    01009     IN BOOLEAN Query,
    01010     OUT PDEVICE_OBJECT *VetoingDevice
    01011     );
    01012
    01013 NTSTATUS
    01014 IopOpenLinkOrRenameTarget(
    01015     OUT PHANDLE TargetHandle,
    01016     IN PIRP Irp,
    01017     IN PVOID RenameBuffer,
    01018     IN PFILE_OBJECT FileObject
    01019     );
    01020
    01021 NTSTATUS
    01022 IopOpenRegistryKey(
    01023     OUT PHANDLE Handle,
    01024     IN HANDLE BaseHandle OPTIONAL,
    01025     IN PUNICODE_STRING KeyName,
    01026     IN ACCESS_MASK DesiredAccess,
    01027     IN BOOLEAN Create
    01028     );
    01029
    01030 NTSTATUS
    01031 IopParseDevice(
    01032     IN PVOID ParseObject,
    01033     IN PVOID ObjectType,
    01034     IN PACCESS_STATE AccessState,
    01035     IN KPROCESSOR_MODE AccessMode,
    01036     IN ULONG Attributes,
    01037     IN OUT PUNICODE_STRING CompleteName,
    01038     IN OUT PUNICODE_STRING RemainingName,
    01039     IN OUT PVOID Context OPTIONAL,
    01040     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
    01041     OUT PVOID *Object
    01042     );
    01043
    01044 NTSTATUS
    01045 IopParseFile(
    01046     IN PVOID ParseObject,
    01047     IN PVOID ObjectType,
    01048     IN PACCESS_STATE AccessState,
    01049     IN KPROCESSOR_MODE AccessMode,
    01050     IN ULONG Attributes,
    01051     IN OUT PUNICODE_STRING CompleteName,
    01052     IN OUT PUNICODE_STRING RemainingName,
    01053     IN OUT PVOID Context OPTIONAL,
    01054     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
    01055     OUT PVOID *Object
    01056     );
    01057
    01058 BOOLEAN
    01059 IopProtectSystemPartition(
    01060     IN PLOADER_PARAMETER_BLOCK LoaderBlock
    01061     );
    01062
    01063 NTSTATUS
    01064 IopQueryName(
    01065     IN PVOID Object,
    01066     IN BOOLEAN HasObjectName,
    01067     OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
    01068     IN ULONG Length,
    01069     OUT PULONG ReturnLength
    01070     );
    01071
    01072 NTSTATUS
    01073 IopQueryXxxInformation(
    01074     IN PFILE_OBJECT FileObject,
    01075     IN ULONG InformationClass,
    01076     IN ULONG Length,
    01077     OUT PVOID Information,
    01078     OUT PULONG ReturnedLength,
    01079     IN BOOLEAN FileInformation
    01080     );
    01081
    01082 //+
    01083 // VOID
    01084 // IopQueueThreadIrp(
    01085 //     IN PIRP Irp
    01086 //     )
    01087 //
    01088 // Routine Description:
    01089 //
    01090 //     This routine queues the specified I/O Request Packet (IRP) to the thread
    01091 //     whose TCB address is stored in the packet.
    01092 //
    01093 // Arguments:
    01094 //
    01095 //     Irp - Supplies the IRP to be queued for the specified thread.
    01096 //
    01097 // Return Value:
    01098 //
    01099 //     None.
    01100 //
    01101 //-
    01102
    01103 #define IopQueueThreadIrp( Irp ) {                      \
    01104     KIRQL irql;                                         \
    01105     KeRaiseIrql( APC_LEVEL, &irql );                    \
    01106     InsertHeadList( &Irp->Tail.Overlay.Thread->IrpList, \
    01107                     &Irp->ThreadListEntry );            \
    01108     KeLowerIrql( irql );                                \
    01109     }
    01110
    01111 VOID
    01112 IopQueueWorkRequest(
    01113     IN PIRP Irp
    01114     );
    01115
    01116 VOID
    01117 IopRaiseHardError(
    01118     IN PVOID NormalContext,
    01119     IN PVOID SystemArgument1,
    01120     IN PVOID SystemArgument2
    01121     );
    01122
    01123 VOID
    01124 IopRaiseInformationalHardError(
    01125     IN PVOID NormalContext,
    01126     IN PVOID SystemArgument1,
    01127     IN PVOID SystemArgument2
    01128     );
    01129
    01130 VOID
    01131 IopReadyDeviceObjects(
    01132     IN PDRIVER_OBJECT DriverObject
    01133     );
    01134
    01135 //+
    01136 //
    01137 // VOID
    01138 // IopReleaseFileObjectLock(
    01139 //     IN PFILE_OBJECT FileObject
    01140 // )
    01141 //
    01142 // Routine Description:
    01143 //
    01144 //     This routine is invoked to release ownership of the file object lock.
    01145 //
    01146 // Arguments:
    01147 //
    01148 //     FileObject - Pointer to the file object whose ownership is to be
    01149 //         released.
    01150 //
    01151 // Return Value:
    01152 //
    01153 //     None.
    01154 //
    01155 //-
    01156
    01157 #define IopReleaseFileObjectLock( FileObject ) {    \
    01158     ULONG Result;                                   \
    01159     Result = InterlockedExchange( &FileObject->Busy, FALSE ); \
    01160     ASSERT(Result != FALSE);                        \
    01161     if (FileObject->Waiters != 0) {                 \
    01162         KeSetEvent( &FileObject->Lock, 0, FALSE );  \
    01163     }                                               \
    01164 }
    01165
    01166 #if _WIN32_WINNT >= 0x0500
    01167 NTSTATUS
    01168 IopSendMessageToTrackService(
    01169     IN PLINK_TRACKING_INFORMATION SourceVolumeId,
    01170     IN PFILE_OBJECTID_BUFFER SourceObjectId,
    01171     IN PFILE_TRACKING_INFORMATION TargetObjectInformation
    01172     );
    01173 #endif
    01174
    01175 NTSTATUS
    01176 IopSetEaOrQuotaInformationFile(
    01177     IN HANDLE FileHandle,
    01178     OUT PIO_STATUS_BLOCK IoStatusBlock,
    01179     IN PVOID Buffer,
    01180     IN ULONG Length,
    01181     IN BOOLEAN SetEa
    01182     );
    01183
    01184 NTSTATUS
    01185 IopSetRemoteLink(
    01186     IN PFILE_OBJECT FileObject,
    01187     IN PFILE_OBJECT DestinationFileObject OPTIONAL,
    01188     IN PFILE_TRACKING_INFORMATION FileInformation OPTIONAL
    01189     );
    01190
    01191 VOID
    01192 IopStartApcHardError(
    01193     IN PVOID StartContext
    01194     );
    01195
    01196 NTSTATUS
    01197 IopSynchronousApiServiceTail(
    01198     IN NTSTATUS ReturnedStatus,
    01199     IN PKEVENT Event,
    01200     IN PIRP Irp,
    01201     IN KPROCESSOR_MODE RequestorMode,
    01202     IN PIO_STATUS_BLOCK LocalIoStatus,
    01203     OUT PIO_STATUS_BLOCK IoStatusBlock
    01204     );
    01205
    01206 NTSTATUS
    01207 IopSynchronousServiceTail(
    01208     IN PDEVICE_OBJECT DeviceObject,
    01209     IN PIRP Irp,
    01210     IN PFILE_OBJECT FileObject,
    01211     IN BOOLEAN DeferredIoCompletion,
    01212     IN KPROCESSOR_MODE RequestorMode,
    01213     IN BOOLEAN SynchronousIo,
    01214     IN TRANSFER_TYPE TransferType
    01215     );
    01216
    01217 VOID
    01218 IopTimerDispatch(
    01219     IN PKDPC Dpc,
    01220     IN PVOID DeferredContext,
    01221     IN PVOID SystemArgument1,
    01222     IN PVOID SystemArgument2
    01223     );
    01224
    01225 NTSTATUS
    01226 IopTrackLink(
    01227     IN PFILE_OBJECT FileObject,
    01228     IN OUT PIO_STATUS_BLOCK IoStatusBlock,
    01229     IN PFILE_TRACKING_INFORMATION FileInformation,
    01230     IN ULONG Length,
    01231     IN PKEVENT Event,
    01232     IN KPROCESSOR_MODE RequestorMode
    01233     );
    01234
    01235
    01236 VOID
    01237 IopUserCompletion(
    01238     IN PKAPC Apc,
    01239     IN PKNORMAL_ROUTINE *NormalRoutine,
    01240     IN PVOID *NormalContext,
    01241     IN PVOID *SystemArgument1,
    01242     IN PVOID *SystemArgument2
    01243     );
    01244
    01245 NTSTATUS
    01246 IopXxxControlFile(
    01247     IN HANDLE FileHandle,
    01248     IN HANDLE Event OPTIONAL,
    01249     IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
    01250     IN PVOID ApcContext OPTIONAL,
    01251     OUT PIO_STATUS_BLOCK IoStatusBlock,
    01252     IN ULONG IoControlCode,
    01253     IN PVOID InputBuffer OPTIONAL,
    01254     IN ULONG InputBufferLength,
    01255     OUT PVOID OutputBuffer OPTIONAL,
    01256     IN ULONG OutputBufferLength,
    01257     IN BOOLEAN DeviceIoControl
    01258     );
    01259
    01260 NTSTATUS
    01261 IopReportResourceUsage(
    01262     IN PUNICODE_STRING DriverClassName OPTIONAL,
    01263     IN PDRIVER_OBJECT DriverObject,
    01264     IN PCM_RESOURCE_LIST DriverList OPTIONAL,
    01265     IN ULONG DriverListSize OPTIONAL,
    01266     IN PDEVICE_OBJECT DeviceObject OPTIONAL,
    01267     IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
    01268     IN ULONG DeviceListSize OPTIONAL,
    01269     IN BOOLEAN OverrideConflict,
    01270     OUT PBOOLEAN ConflictDetected
    01271     );
    01272
    01273 NTSTATUS
    01274 IopAddRemoteBootValuesToRegistry (
    01275     PLOADER_PARAMETER_BLOCK LoaderBlock
    01276     );
    01277
    01278 NTSTATUS
    01279 IopStartNetworkForRemoteBoot (
    01280     PLOADER_PARAMETER_BLOCK LoaderBlock
    01281     );
    01282
    01283 #if defined(REMOTE_BOOT)
    01284 VOID
    01285 IopShutdownCsc (
    01286     VOID
    01287     );
    01288 #endif
    01289
    01290 NTSTATUS
    01291 IopStartTcpIpForRemoteBoot (
    01292     PLOADER_PARAMETER_BLOCK LoaderBlock
    01293     );
    01294
    01295 BOOLEAN
    01296 IopIsRemoteBootCard(
    01297     IN PDEVICE_NODE DeviceNode,
    01298     IN PLOADER_PARAMETER_BLOCK LoaderBlock,
    01299     IN PWCHAR HwIds
    01300     );
    01301
    01302 NTSTATUS
    01303 IopSetupRemoteBootCard(
    01304     IN PLOADER_PARAMETER_BLOCK LoaderBlock,
    01305     IN HANDLE UniqueIdHandle,
    01306     IN PUNICODE_STRING UnicodeDeviceInstance
    01307     );
    01308
    01309 BOOLEAN
    01310 IopSafebootDriverLoad(
    01311     PUNICODE_STRING DriverId
    01312     );
    01313
    01314 PSECURITY_DESCRIPTOR
    01315 IopCreateDefaultDeviceSecurityDescriptor(
    01316     IN DEVICE_TYPE DeviceType,
    01317     IN ULONG DeviceCharacteristics,
    01318     IN BOOLEAN DeviceHasName,
    01319     IN PUCHAR Buffer,
    01320     OUT PACL *AllocatedAcl,
    01321     OUT PSECURITY_INFORMATION SecurityInformation OPTIONAL
    01322     );
    01323
    01324 VOID
    01325 IopDoNameTransmogrify(
    01326     IN PIRP Irp,
    01327     IN PFILE_OBJECT FileObject,
    01328     IN PREPARSE_DATA_BUFFER ReparseBuffer
    01329     );
    01330
    01331 NTSTATUS
    01332 IopQueryDeviceCapabilities(
    01333     IN PDEVICE_NODE DeviceNode,
    01334     OUT PDEVICE_CAPABILITIES Capabilities
    01335     );
    01336
    01337 //
    01338 // dump support routines
    01339 //
    01340 //Used for error logging
    01341 NTSTATUS
    01342 IopLogErrorEvent(
    01343     IN ULONG            SequenceNumber,
    01344     IN ULONG            UniqueErrorValue,
    01345     IN NTSTATUS         FinalStatus,
    01346     IN NTSTATUS         SpecificIOStatus,
    01347     IN ULONG            LengthOfInsert1,
    01348     IN PWCHAR           Insert1,
    01349     IN ULONG            LengthOfInsert2,
    01350     IN PWCHAR           Insert2
    01351     );
    01352
    01353 BOOLEAN
    01354 IopConfigureCrashDump(
    01355     IN HANDLE HandlePagingFile
    01356     );
    01357
    01358 VOID
    01359 IopUpdateOtherOperationCount(
    01360     VOID
    01361     );
    01362
    01363 VOID
    01364 IopUpdateReadOperationCount(
    01365     VOID
    01366     );
    01367
    01368 VOID
    01369 IopUpdateWriteOperationCount(
    01370     VOID
    01371     );
    01372
    01373 VOID
    01374 IopUpdateOtherTransferCount(
    01375     IN ULONG TransferCount
    01376     );
    01377
    01378 VOID
    01379 IopUpdateReadTransferCount(
    01380     IN ULONG TransferCount
    01381     );
    01382
    01383 VOID
    01384 IopUpdateWriteTransferCount(
    01385     IN ULONG TransferCount
    01386     );
    01387
    01388 NTSTATUS
    01389 FASTCALL
    01390 IopfCallDriver(
    01391     PDEVICE_OBJECT  DeviceObject,
    01392     PIRP            Irp
    01393     );
    01394
    01395 VOID
    01396 FASTCALL
    01397 IopfCompleteRequest(
    01398     IN  PIRP    Irp,
    01399     IN  CCHAR   PriorityBost
    01400     );
    01401
    01402
    01403 PIRP
    01404 IopAllocateIrpPrivate(
    01405     IN  CCHAR   StackSize,
    01406     IN  BOOLEAN ChargeQuota
    01407     );
    01408
    01409 VOID
    01410 IopFreeIrp(
    01411     IN  PIRP    Irp
    01412     );
    01413
    01414 PVOID
    01415 IopAllocateErrorLogEntry(
    01416     IN PDEVICE_OBJECT deviceObject,
    01417     IN PDRIVER_OBJECT driverObject,
    01418     IN UCHAR EntrySize
    01419     );
    01420 #endif // _IOP_