reactos/ntoskrnl/include/internal/io.h

   1 /*
   2 * PROJECT:         ReactOS Kernel
   3 * LICENSE:         GPL - See COPYING in the top level directory
   4 * FILE:            ntoskrnl/include/io.h
   5 * PURPOSE:         Internal header for the I/O Manager
   6 * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7 */
   8 #include "ntdddisk.h"
   9
  10 //
  11 // Define this if you want debugging support
  12 //
  13 #define _IO_DEBUG_                                      0x00
  14
  15 //
  16 // These define the Debug Masks Supported
  17 //
  18 #define IO_IRP_DEBUG                                    0x01
  19
  20 //
  21 // Debug/Tracing support
  22 //
  23 #if _IO_DEBUG_
  24 #ifdef NEW_DEBUG_SYSTEM_IMPLEMENTED // enable when Debug Filters are implemented
  25 #define IOTRACE DbgPrintEx
  26 #else
  27 #define IOTRACE(x, ...)                                 \
  28     if (x & IopTraceLevel) DbgPrint(__VA_ARGS__)
  29 #endif
  30 #else
  31 #define IOTRACE(x, ...) DPRINT(__VA_ARGS__)
  32 #endif
  33
  34 //
  35 // Returns the type of METHOD_ used in this IOCTL
  36 //
  37 #define IO_METHOD_FROM_CTL_CODE(c)                      (c & 0x00000003)
  38
  39 //
  40 // Packet Types when piggybacking on the IRP Overlay
  41 //
  42 #define IrpCompletionPacket                             0x1
  43 #define IrpMiniCompletionPacket                         0x2
  44
  45 //
  46 // Number of partition tables in the Boot Record
  47 //
  48 #define PARTITION_TBL_SIZE                              4
  49
  50 //
  51 // We can call the Ob Inlined API, it's the same thing
  52 //
  53 #define IopAllocateMdlFromLookaside                     \
  54     ObpAllocateCapturedAttributes
  55 #define IopFreeMdlFromLookaside                         \
  56     ObpFreeCapturedAttributes
  57
  58 //
  59 // Returns the size of a CM_RESOURCE_LIST
  60 //
  61 #define CM_RESOURCE_LIST_SIZE(ResList)                  \
  62     (ResList->Count == 1) ?                             \
  63         FIELD_OFFSET(                                   \
  64             CM_RESOURCE_LIST,                           \
  65             List[0].PartialResourceList.                \
  66             PartialDescriptors[(ResList)->              \
  67                                List[0].                 \
  68                                PartialResourceList.     \
  69                                Count])                  \
  70         :                                               \
  71         FIELD_OFFSET(CM_RESOURCE_LIST, List)
  72
  73 //
  74 // Determines if the IRP is Synchronous
  75 //
  76 #define IsIrpSynchronous(Irp, FileObject)               \
  77     ((Irp->Flags & IRP_SYNCHRONOUS_API)  ||             \
  78      (!(FileObject) ?                                   \
  79         FALSE :                                         \
  80         FileObject->Flags & FO_SYNCHRONOUS_IO))         \
  81
  82 //
  83 // Returns the internal Device Object Extension
  84 //
  85 #define IoGetDevObjExtension(DeviceObject)              \
  86     ((PEXTENDED_DEVOBJ_EXTENSION)                       \
  87      (DeviceObject->DeviceObjectExtension))             \
  88
  89 //
  90 // Returns the internal Driver Object Extension
  91 //
  92 #define IoGetDrvObjExtension(DriverObject)              \
  93     ((PEXTENDED_DRIVER_EXTENSION)                       \
  94      (DriverObject->DriverExtension))                   \
  95
  96 /*
  97  * VOID
  98  * IopDeviceNodeSetFlag(
  99  *   PDEVICE_NODE DeviceNode,
 100  *   ULONG Flag);
 101  */
 102 #define IopDeviceNodeSetFlag(DeviceNode, Flag)          \
 103     ((DeviceNode)->Flags |= (Flag))
 104
 105 /*
 106  * VOID
 107  * IopDeviceNodeClearFlag(
 108  *   PDEVICE_NODE DeviceNode,
 109  *   ULONG Flag);
 110  */
 111 #define IopDeviceNodeClearFlag(DeviceNode, Flag)        \
 112     ((DeviceNode)->Flags &= ~(Flag))
 113
 114 /*
 115  * BOOLEAN
 116  * IopDeviceNodeHasFlag(
 117  *   PDEVICE_NODE DeviceNode,
 118  *   ULONG Flag);
 119  */
 120 #define IopDeviceNodeHasFlag(DeviceNode, Flag)          \
 121     (((DeviceNode)->Flags & (Flag)) > 0)
 122
 123 /*
 124  * VOID
 125  * IopDeviceNodeSetUserFlag(
 126  *   PDEVICE_NODE DeviceNode,
 127  *   ULONG UserFlag);
 128  */
 129 #define IopDeviceNodeSetUserFlag(DeviceNode, UserFlag)  \
 130     ((DeviceNode)->UserFlags |= (UserFlag))
 131
 132 /*
 133  * VOID
 134  * IopDeviceNodeClearUserFlag(
 135  *   PDEVICE_NODE DeviceNode,
 136  *   ULONG UserFlag);
 137  */
 138 #define IopDeviceNodeClearUserFlag(DeviceNode, UserFlag)\
 139     ((DeviceNode)->UserFlags &= ~(UserFlag))
 140
 141 /*
 142  * BOOLEAN
 143  * IopDeviceNodeHasUserFlag(
 144  *   PDEVICE_NODE DeviceNode,
 145  *   ULONG UserFlag);
 146  */
 147 #define IopDeviceNodeHasUserFlag(DeviceNode, UserFlag)  \
 148     (((DeviceNode)->UserFlags & (UserFlag)) > 0)
 149
 150  /*
 151  * VOID
 152  * IopDeviceNodeSetProblem(
 153  *   PDEVICE_NODE DeviceNode,
 154  *   ULONG Problem);
 155  */
 156 #define IopDeviceNodeSetProblem(DeviceNode, Problem)    \
 157     ((DeviceNode)->Problem |= (Problem))
 158
 159 /*
 160  * VOID
 161  * IopDeviceNodeClearProblem(
 162  *   PDEVICE_NODE DeviceNode,
 163  *   ULONG Problem);
 164  */
 165 #define IopDeviceNodeClearProblem(DeviceNode, Problem)  \
 166     ((DeviceNode)->Problem &= ~(Problem))
 167
 168 /*
 169  * BOOLEAN
 170  * IopDeviceNodeHasProblem(
 171  *   PDEVICE_NODE DeviceNode,
 172  *   ULONG Problem);
 173  */
 174 #define IopDeviceNodeHasProblem(DeviceNode, Problem)    \
 175     (((DeviceNode)->Problem & (Problem)) > 0)
 176
 177 /*
 178  * VOID
 179  * IopInitDeviceTreeTraverseContext(
 180  *   PDEVICETREE_TRAVERSE_CONTEXT DeviceTreeTraverseContext,
 181  *   PDEVICE_NODE DeviceNode,
 182  *   DEVICETREE_TRAVERSE_ROUTINE Action,
 183  *   PVOID Context);
 184  */
 185 #define IopInitDeviceTreeTraverseContext(               \
 186     _DeviceTreeTraverseContext, _DeviceNode, _Action,   \
 187     _Context) {                                         \
 188     (_DeviceTreeTraverseContext)->FirstDeviceNode =     \
 189         (_DeviceNode);                                  \
 190     (_DeviceTreeTraverseContext)->Action = (_Action);   \
 191     (_DeviceTreeTraverseContext)->Context = (_Context); }
 192
 193 //
 194 // Device List Operations
 195 //
 196 typedef enum _IOP_DEVICE_LIST_OPERATION
 197 {
 198     IopRemove,
 199     IopAdd
 200 } IOP_DEVICE_LIST_OPERATION, *PIOP_DEVICE_LIST_OPERATION;
 201
 202 //
 203 // Transfer statistics
 204 //
 205 typedef enum _IOP_TRANSFER_TYPE
 206 {
 207     IopReadTransfer,
 208     IopWriteTransfer,
 209     IopOtherTransfer
 210 } IOP_TRANSFER_TYPE, *PIOP_TRANSFER_TYPE;
 211
 212 //
 213 // Special version of the IRP Overlay used to optimize I/O completion
 214 // by not using up a separate structure.
 215 //
 216 typedef struct _IO_COMPLETION_PACKET
 217 {
 218     struct
 219     {
 220         LIST_ENTRY ListEntry;
 221         union
 222         {
 223             struct _IO_STACK_LOCATION *CurrentStackLocation;
 224             ULONG PacketType;
 225         };
 226     };
 227     PVOID Key;
 228     PVOID Context;
 229     IO_STATUS_BLOCK IoStatus;
 230 } IO_COMPLETION_PACKET, *PIO_COMPLETION_PACKET;
 231
 232 //
 233 // I/O Wrapper around the Executive Work Item
 234 //
 235 typedef struct _IO_WORKITEM
 236 {
 237     WORK_QUEUE_ITEM Item;
 238     PDEVICE_OBJECT DeviceObject;
 239     PIO_WORKITEM_ROUTINE WorkerRoutine;
 240     PVOID Context;
 241 } IO_WORKITEM, *PIO_WORKITEM;
 242
 243 //
 244 // I/O Wrapper around the Kernel Interrupt
 245 //
 246 typedef struct _IO_INTERRUPT
 247 {
 248     KINTERRUPT FirstInterrupt;
 249     PKINTERRUPT Interrupt[MAXIMUM_PROCESSORS];
 250     KSPIN_LOCK SpinLock;
 251 } IO_INTERRUPT, *PIO_INTERRUPT;
 252
 253 //
 254 // I/O Error Log Packet Header
 255 //
 256 typedef struct _ERROR_LOG_ENTRY
 257 {
 258     CSHORT Type;
 259     CSHORT Size;
 260     LIST_ENTRY ListEntry;
 261     PDEVICE_OBJECT DeviceObject;
 262     PDRIVER_OBJECT DriverObject;
 263     LARGE_INTEGER TimeStamp;
 264 } ERROR_LOG_ENTRY, *PERROR_LOG_ENTRY;
 265
 266 //
 267 // Event Log LPC Message
 268 //
 269 typedef struct _ELF_API_MSG
 270 {
 271     PORT_MESSAGE h;
 272     ULONG Unknown[2];
 273     IO_ERROR_LOG_MESSAGE IoErrorMessage;
 274 } ELF_API_MSG, *PELF_API_MSG;
 275
 276 //
 277 // To simplify matters, the kernel is made to support both the checked and free
 278 // version of the I/O Remove Lock in the same binary. This structure includes
 279 // both, since the DDK has the structure with a compile-time #ifdef.
 280 //
 281 typedef struct _EXTENDED_IO_REMOVE_LOCK
 282 {
 283     IO_REMOVE_LOCK_COMMON_BLOCK Common;
 284     IO_REMOVE_LOCK_DBG_BLOCK Dbg;
 285 } EXTENDED_IO_REMOVE_LOCK, *PEXTENDED_IO_REMOVE_LOCK;
 286
 287 //
 288 // Dummy File Object used inside the Open Packet so that OB knows how to
 289 // deal with the Object Pointer even though it's not a real file.
 290 //
 291 typedef struct _DUMMY_FILE_OBJECT
 292 {
 293     OBJECT_HEADER ObjectHeader;
 294     CHAR FileObjectBody[sizeof(FILE_OBJECT)];
 295 } DUMMY_FILE_OBJECT, *PDUMMY_FILE_OBJECT;
 296
 297 //
 298 // Open packet used as a context for Device/File parsing so that the parse
 299 // routine can know what operation is being requested.
 300 //
 301 typedef struct _OPEN_PACKET
 302 {
 303     CSHORT Type;
 304     CSHORT Size;
 305     PFILE_OBJECT FileObject;
 306     NTSTATUS FinalStatus;
 307     ULONG_PTR Information;
 308     ULONG ParseCheck;
 309     PFILE_OBJECT RelatedFileObject;
 310     OBJECT_ATTRIBUTES OriginalAttributes;
 311     LARGE_INTEGER AllocationSize;
 312     ULONG CreateOptions;
 313     USHORT FileAttributes;
 314     USHORT ShareAccess;
 315     PVOID EaBuffer;
 316     ULONG EaLength;
 317     ULONG Options;
 318     ULONG Disposition;
 319     PFILE_BASIC_INFORMATION BasicInformation;
 320     PFILE_NETWORK_OPEN_INFORMATION NetworkInformation;
 321     CREATE_FILE_TYPE CreateFileType;
 322     PVOID MailslotOrPipeParameters;
 323     BOOLEAN Override;
 324     BOOLEAN QueryOnly;
 325     BOOLEAN DeleteOnly;
 326     BOOLEAN FullAttributes;
 327     PDUMMY_FILE_OBJECT DummyFileObject;
 328     ULONG InternalFlags;
 329     //PIO_DRIVER_CREATE_CONTEXT DriverCreateContext; Vista only, needs ROS DDK Update
 330 } OPEN_PACKET, *POPEN_PACKET;
 331
 332 //
 333 // List of Bus Type GUIDs
 334 //
 335 typedef struct _IO_BUS_TYPE_GUID_LIST
 336 {
 337     ULONG GuidCount;
 338     FAST_MUTEX Lock;
 339     GUID Guids[1];
 340 } IO_BUS_TYPE_GUID_LIST, *PIO_BUS_TYPE_GUID_LIST;
 341 extern PIO_BUS_TYPE_GUID_LIST IopBusTypeGuidList;
 342
 343 //
 344 // Shutdown entry for registed devices
 345 //
 346 typedef struct _SHUTDOWN_ENTRY
 347 {
 348     LIST_ENTRY ShutdownList;
 349     PDEVICE_OBJECT DeviceObject;
 350 } SHUTDOWN_ENTRY, *PSHUTDOWN_ENTRY;
 351
 352 //
 353 // F/S Notification entry for registered File Systems
 354 //
 355 typedef struct _FS_CHANGE_NOTIFY_ENTRY
 356 {
 357     LIST_ENTRY FsChangeNotifyList;
 358     PDRIVER_OBJECT DriverObject;
 359     PDRIVER_FS_NOTIFICATION FSDNotificationProc;
 360 } FS_CHANGE_NOTIFY_ENTRY, *PFS_CHANGE_NOTIFY_ENTRY;
 361
 362 //
 363 // Driver (Boot) Re-Initialization Entry
 364 //
 365 typedef struct _DRIVER_REINIT_ITEM
 366 {
 367     LIST_ENTRY ItemEntry;
 368     PDRIVER_OBJECT DriverObject;
 369     PDRIVER_REINITIALIZE ReinitRoutine;
 370     PVOID Context;
 371 } DRIVER_REINIT_ITEM, *PDRIVER_REINIT_ITEM;
 372
 373 //
 374 // Called on every visit of a node during a preorder-traversal of the device
 375 // node tree.
 376 // If the routine returns STATUS_UNSUCCESSFUL the traversal will stop and
 377 // STATUS_SUCCESS is returned to the caller who initiated the tree traversal.
 378 // Any other returned status code will be returned to the caller. If a status
 379 // code that indicates an error (other than STATUS_UNSUCCESSFUL) is returned,
 380 // the traversal is stopped immediately and the status code is returned to
 381 // the caller.
 382 //
 383 typedef
 384 NTSTATUS
 385 (*DEVICETREE_TRAVERSE_ROUTINE)(
 386     IN PDEVICE_NODE DeviceNode,
 387     IN PVOID Context
 388 );
 389
 390 //
 391 // Context information for traversing the device tree
 392 //
 393 typedef struct _DEVICETREE_TRAVERSE_CONTEXT
 394 {
 395     //
 396     // Current device node during a traversal
 397     //
 398     PDEVICE_NODE DeviceNode;
 399
 400     //
 401     // Initial device node where we start the traversal
 402     //
 403     PDEVICE_NODE FirstDeviceNode;
 404
 405     //
 406     // Action routine to be called for every device node
 407     //
 408     DEVICETREE_TRAVERSE_ROUTINE Action;
 409
 410     //
 411     // Context passed to the action routine
 412     //
 413     PVOID Context;
 414 } DEVICETREE_TRAVERSE_CONTEXT, *PDEVICETREE_TRAVERSE_CONTEXT;
 415
 416 //
 417 // Internal Representation of a Disk
 418 //
 419 typedef struct _DISKENTRY
 420 {
 421     LIST_ENTRY ListEntry;
 422     ULONG DiskNumber;
 423     ULONG Signature;
 424     ULONG Checksum;
 425     PDEVICE_OBJECT DeviceObject;
 426 } DISKENTRY, *PDISKENTRY;
 427
 428 //
 429 // Partition Table Entry
 430 //
 431 #include <pshpack1.h>
 432 typedef struct _PARTITION
 433 {
 434     UCHAR BootFlags;
 435     UCHAR StartingHead;
 436     UCHAR StartingSector;
 437     UCHAR StartingCylinder;
 438     UCHAR PartitionType;
 439     UCHAR EndingHead;
 440     UCHAR EndingSector;
 441     UCHAR EndingCylinder;
 442     ULONG StartingBlock;
 443     ULONG SectorCount;
 444 } PARTITION, *PPARTITION;
 445
 446 //
 447 // Boot Record Structure
 448 //
 449 typedef struct _PARTITION_SECTOR
 450 {
 451   UCHAR BootCode[440];
 452   ULONG Signature;
 453   UCHAR Reserved[2];
 454   PARTITION Partition[PARTITION_TBL_SIZE];
 455   USHORT Magic;
 456 } PARTITION_SECTOR, *PPARTITION_SECTOR;
 457 #include <poppack.h>
 458
 459 //
 460 // PNP Routines
 461 //
 462 VOID
 463 PnpInit(
 464     VOID
 465 );
 466
 467 VOID
 468 PnpInit2(
 469     VOID
 470 );
 471
 472 VOID
 473 IopInitDriverImplementation(
 474     VOID
 475 );
 476
 477 VOID
 478 IopInitPnpNotificationImplementation(
 479     VOID
 480 );
 481
 482 VOID
 483 IopNotifyPlugPlayNotification(
 484     IN PDEVICE_OBJECT DeviceObject,
 485     IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory,
 486     IN LPCGUID Event,
 487     IN PVOID EventCategoryData1,
 488     IN PVOID EventCategoryData2
 489 );
 490
 491 NTSTATUS
 492 IopGetSystemPowerDeviceObject(
 493     IN PDEVICE_OBJECT *DeviceObject
 494 );
 495
 496 NTSTATUS
 497 IopCreateDeviceNode(
 498     IN PDEVICE_NODE ParentNode,
 499     IN PDEVICE_OBJECT PhysicalDeviceObject,
 500     OUT PDEVICE_NODE *DeviceNode
 501 );
 502
 503 NTSTATUS
 504 IopFreeDeviceNode(
 505     IN PDEVICE_NODE DeviceNode
 506 );
 507
 508 NTSTATUS
 509 IopInitiatePnpIrp(
 510     IN PDEVICE_OBJECT DeviceObject,
 511     IN PIO_STATUS_BLOCK IoStatusBlock,
 512     IN ULONG MinorFunction,
 513     IN PIO_STACK_LOCATION Stack
 514 );
 515
 516 PDEVICE_NODE
 517 FASTCALL
 518 IopGetDeviceNode(
 519     IN PDEVICE_OBJECT DeviceObject
 520 );
 521
 522 NTSTATUS
 523 IopActionConfigureChildServices(
 524     IN PDEVICE_NODE DeviceNode,
 525     IN PVOID Context
 526 );
 527
 528 NTSTATUS
 529 IopActionInitChildServices(
 530     IN PDEVICE_NODE DeviceNode,
 531     IN PVOID Context,
 532     IN BOOLEAN BootDrivers
 533 );
 534
 535 NTSTATUS
 536 IoCreateDriverList(
 537     VOID
 538 );
 539
 540 NTSTATUS
 541 IoDestroyDriverList(
 542     VOID
 543 );
 544
 545 NTSTATUS
 546 INIT_FUNCTION
 547 IopInitPlugPlayEvents(VOID);
 548
 549 NTSTATUS
 550 IopQueueTargetDeviceEvent(
 551     const GUID *Guid,
 552     PUNICODE_STRING DeviceIds
 553 );
 554
 555 NTSTATUS
 556 IopInitializePnpServices(
 557     IN PDEVICE_NODE DeviceNode,
 558     IN BOOLEAN BootDrivers)
 559 ;
 560
 561 NTSTATUS
 562 IopInvalidateDeviceRelations(
 563     IN PDEVICE_NODE DeviceNode,
 564     IN DEVICE_RELATION_TYPE Type
 565 );
 566
 567 //
 568 // Initialization Routines
 569 //
 570 NTSTATUS
 571 IoCreateArcNames(
 572     VOID
 573 );
 574
 575 NTSTATUS
 576 IoCreateSystemRootLink(
 577     IN PCHAR ParameterLine
 578 );
 579
 580 //
 581 // Device/Volume Routines
 582 //
 583 NTSTATUS
 584 FASTCALL
 585 IopInitializeDevice(
 586     IN PDEVICE_NODE DeviceNode,
 587     IN PDRIVER_OBJECT DriverObject
 588 );
 589
 590 NTSTATUS
 591 IopStartDevice(
 592     IN PDEVICE_NODE DeviceNode
 593 );
 594
 595 PVPB
 596 NTAPI
 597 IopCheckVpbMounted(
 598     IN POPEN_PACKET OpenPacket,
 599     IN PDEVICE_OBJECT DeviceObject,
 600     IN PUNICODE_STRING RemainingName,
 601     OUT PNTSTATUS Status
 602 );
 603
 604 NTSTATUS
 605 NTAPI
 606 IopMountVolume(
 607     IN PDEVICE_OBJECT DeviceObject,
 608     IN BOOLEAN AllowRawMount,
 609     IN BOOLEAN DeviceIsLocked,
 610     IN BOOLEAN Alertable,
 611     OUT PVPB *Vpb
 612 );
 613
 614 PVOID
 615 IoOpenSymlink(
 616     IN PVOID SymbolicLink
 617 );
 618
 619 PVOID
 620 IoOpenFileOnDevice(
 621     IN PVOID SymbolicLink,
 622     IN PWCHAR Name
 623 );
 624
 625 NTSTATUS
 626 NTAPI
 627 IopCreateVpb(
 628     IN PDEVICE_OBJECT DeviceObject
 629 );
 630
 631 VOID
 632 NTAPI
 633 IopDereferenceVpb(
 634     IN PVPB Vpb
 635 );
 636
 637 VOID
 638 NTAPI
 639 IoInitFileSystemImplementation(
 640     VOID
 641 );
 642
 643 VOID
 644 NTAPI
 645 IoInitVpbImplementation(
 646     VOID
 647 );
 648
 649 NTSTATUS
 650 NTAPI
 651 IopReferenceDeviceObject(
 652     IN PDEVICE_OBJECT DeviceObject
 653 );
 654
 655 VOID
 656 NTAPI
 657 IopDereferenceDeviceObject(
 658     IN PDEVICE_OBJECT DeviceObject,
 659     IN BOOLEAN ForceUnload
 660 );
 661
 662 //
 663 // IRP Routines
 664 //
 665 NTSTATUS
 666 NTAPI
 667 IopCleanupFailedIrp(
 668     IN PFILE_OBJECT FileObject,
 669     IN PKEVENT EventObject,
 670     IN PVOID Buffer OPTIONAL
 671 );
 672
 673 VOID
 674 NTAPI
 675 IopAbortInterruptedIrp(
 676     IN PKEVENT EventObject,
 677     IN PIRP Irp
 678 );
 679
 680 //
 681 // Shutdown routines
 682 //
 683 VOID
 684 IoInitShutdownNotification(
 685     VOID
 686 );
 687
 688 VOID
 689 NTAPI
 690 IoShutdownRegisteredDevices(
 691     VOID
 692 );
 693
 694 VOID
 695 NTAPI
 696 IoShutdownRegisteredFileSystems(
 697     VOID
 698 );
 699
 700 //
 701 // Boot logging support
 702 //
 703 VOID
 704 IopInitBootLog(
 705     IN BOOLEAN StartBootLog
 706 );
 707
 708 VOID
 709 IopStartBootLog(
 710     VOID
 711 );
 712
 713 VOID
 714 IopStopBootLog(
 715     VOID
 716 );
 717
 718 VOID
 719 IopBootLog(
 720     IN PUNICODE_STRING DriverName,
 721     IN BOOLEAN Success
 722 );
 723
 724 VOID
 725 IopSaveBootLogToFile(
 726     VOID
 727 );
 728
 729 //
 730 // I/O Cancellation Routines
 731 //
 732 VOID
 733 STDCALL
 734 IoCancelThreadIo(
 735     IN PETHREAD Thread
 736 );
 737
 738 VOID
 739 IoInitCancelHandling(
 740     VOID
 741 );
 742
 743 //
 744 // I/O Completion
 745 //
 746 VOID
 747 NTAPI
 748 IopCompleteRequest(
 749     IN PKAPC Apc,
 750     IN PKNORMAL_ROUTINE* NormalRoutine,
 751     IN PVOID* NormalContext,
 752     IN PVOID* SystemArgument1,
 753     IN PVOID* SystemArgument2
 754 );
 755
 756 //
 757 // Error Logging Routines
 758 //
 759 VOID
 760 NTAPI
 761 IopInitErrorLog(
 762     VOID
 763 );
 764
 765 VOID
 766 NTAPI
 767 IopLogWorker(
 768     IN PVOID Parameter
 769 );
 770
 771 //
 772 // Raw File System MiniDriver
 773 //
 774 BOOLEAN
 775 RawFsIsRawFileSystemDeviceObject(
 776     IN PDEVICE_OBJECT DeviceObject
 777 );
 778
 779 NTSTATUS
 780 STDCALL
 781 RawFsDriverEntry(
 782     IN PDRIVER_OBJECT DriverObject,
 783     IN PUNICODE_STRING RegistryPath
 784 );
 785
 786 //
 787 // PnP Root MiniDriver
 788 //
 789 NTSTATUS
 790 STDCALL
 791 PnpRootDriverEntry(
 792    IN PDRIVER_OBJECT DriverObject,
 793    IN PUNICODE_STRING RegistryPath
 794 );
 795
 796 NTSTATUS
 797 PnpRootCreateDevice(
 798     IN OUT PDEVICE_OBJECT *PhysicalDeviceObject
 799 );
 800
 801 //
 802 // Driver Routines
 803 //
 804 VOID
 805 FASTCALL
 806 IopInitializeBootDrivers(
 807     VOID
 808 );
 809
 810 VOID
 811 FASTCALL
 812 IopInitializeSystemDrivers(
 813     VOID
 814 );
 815
 816 VOID
 817 NTAPI
 818 IopDeleteDriver(
 819     IN PVOID ObjectBody
 820 );
 821
 822 NTSTATUS
 823 FASTCALL
 824 IopCreateDriverObject(
 825     OUT PDRIVER_OBJECT *DriverObject,
 826     IN PUNICODE_STRING ServiceName,
 827     IN ULONG CreateAttributes,
 828     IN BOOLEAN FileSystemDriver,
 829     IN PVOID DriverImageStart,
 830     IN ULONG DriverImageSize
 831 );
 832
 833 NTSTATUS
 834 FASTCALL
 835 IopGetDriverObject(
 836     OUT PDRIVER_OBJECT *DriverObject,
 837     IN PUNICODE_STRING ServiceName,
 838     IN BOOLEAN FileSystem
 839 );
 840
 841 NTSTATUS
 842 FASTCALL
 843 IopLoadServiceModule(
 844     IN PUNICODE_STRING ServiceName,
 845     OUT PLDR_DATA_TABLE_ENTRY *ModuleObject
 846 );
 847
 848 NTSTATUS
 849 FASTCALL
 850 IopInitializeDriverModule(
 851     IN PDEVICE_NODE DeviceNode,
 852     IN PLDR_DATA_TABLE_ENTRY ModuleObject,
 853     IN PUNICODE_STRING ServiceName,
 854     IN BOOLEAN FileSystemDriver,
 855     OUT PDRIVER_OBJECT *DriverObject
 856 );
 857
 858 NTSTATUS
 859 FASTCALL
 860 IopAttachFilterDrivers(
 861     IN PDEVICE_NODE DeviceNode,
 862     IN BOOLEAN Lower
 863 );
 864
 865 VOID
 866 NTAPI
 867 IopReinitializeDrivers(
 868     VOID
 869 );
 870
 871 VOID
 872 NTAPI
 873 IopReinitializeBootDrivers(
 874     VOID
 875 );
 876
 877 //
 878 // File Routines
 879 //
 880 NTSTATUS
 881 NTAPI
 882 IopParseDevice(
 883     IN PVOID ParseObject,
 884     IN PVOID ObjectType,
 885     IN OUT PACCESS_STATE AccessState,
 886     IN KPROCESSOR_MODE AccessMode,
 887     IN ULONG Attributes,
 888     IN OUT PUNICODE_STRING CompleteName,
 889     IN OUT PUNICODE_STRING RemainingName,
 890     IN OUT PVOID Context OPTIONAL,
 891     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
 892     OUT PVOID *Object
 893 );
 894
 895 NTSTATUS
 896 NTAPI
 897 IopParseFile(
 898     IN PVOID ParseObject,
 899     IN PVOID ObjectType,
 900     IN OUT PACCESS_STATE AccessState,
 901     IN KPROCESSOR_MODE AccessMode,
 902     IN ULONG Attributes,
 903     IN OUT PUNICODE_STRING CompleteName,
 904     IN OUT PUNICODE_STRING RemainingName,
 905     IN OUT PVOID Context OPTIONAL,
 906     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
 907     OUT PVOID *Object
 908 );
 909
 910 VOID
 911 STDCALL
 912 IopDeleteFile(
 913     IN PVOID ObjectBody
 914 );
 915
 916 NTSTATUS
 917 STDCALL
 918 IopSecurityFile(
 919     IN PVOID ObjectBody,
 920     IN SECURITY_OPERATION_CODE OperationCode,
 921     IN SECURITY_INFORMATION SecurityInformation,
 922     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 923     IN OUT PULONG BufferLength,
 924     OUT PSECURITY_DESCRIPTOR *OldSecurityDescriptor,
 925     IN POOL_TYPE PoolType,
 926     IN OUT PGENERIC_MAPPING GenericMapping
 927 );
 928
 929 NTSTATUS
 930 STDCALL
 931 IopQueryNameFile(
 932     IN PVOID ObjectBody,
 933     IN BOOLEAN HasName,
 934     OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
 935     IN ULONG Length,
 936     OUT PULONG ReturnLength,
 937     IN KPROCESSOR_MODE PreviousMode
 938 );
 939
 940 VOID
 941 STDCALL
 942 IopCloseFile(
 943     IN PEPROCESS Process OPTIONAL,
 944     IN PVOID Object,
 945     IN ACCESS_MASK GrantedAccess,
 946     IN ULONG ProcessHandleCount,
 947     IN ULONG SystemHandleCount
 948 );
 949
 950 //
 951 // I/O Timer Routines
 952 //
 953 VOID
 954 FASTCALL
 955 IopInitTimerImplementation(
 956     VOID
 957 );
 958
 959 VOID
 960 STDCALL
 961 IopRemoveTimerFromTimerList(
 962     IN PIO_TIMER Timer
 963 );
 964
 965 //
 966 // I/O Completion Routines
 967 //
 968 VOID
 969 NTAPI
 970 IopDeleteIoCompletion(
 971     PVOID ObjectBody
 972 );
 973
 974 //
 975 // I/O HAL Entrypoints
 976 //
 977 NTSTATUS
 978 FASTCALL
 979 xHalQueryDriveLayout(
 980     IN PUNICODE_STRING DeviceName,
 981     OUT PDRIVE_LAYOUT_INFORMATION *LayoutInfo
 982 );
 983
 984 #undef HalExamineMBR
 985 VOID
 986 FASTCALL
 987 HalExamineMBR(
 988     IN PDEVICE_OBJECT DeviceObject,
 989     IN ULONG SectorSize,
 990     IN ULONG MBRTypeIdentifier,
 991     OUT PVOID *Buffer
 992 );
 993
 994 VOID
 995 FASTCALL
 996 xHalIoAssignDriveLetters(
 997     IN PROS_LOADER_PARAMETER_BLOCK LoaderBlock,
 998     IN PSTRING NtDeviceName,
 999     OUT PUCHAR NtSystemPath,
1000     OUT PSTRING NtSystemPathString
1001 );
1002
1003 NTSTATUS
1004 FASTCALL
1005 xHalIoReadPartitionTable(
1006     IN PDEVICE_OBJECT DeviceObject,
1007     IN ULONG SectorSize,
1008     IN BOOLEAN ReturnRecognizedPartitions,
1009     OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer
1010 );
1011
1012 NTSTATUS
1013 FASTCALL
1014 xHalIoSetPartitionInformation(
1015     IN PDEVICE_OBJECT DeviceObject,
1016     IN ULONG SectorSize,
1017     IN ULONG PartitionNumber,
1018     IN ULONG PartitionType
1019 );
1020
1021 NTSTATUS
1022 FASTCALL
1023 xHalIoWritePartitionTable(
1024     IN PDEVICE_OBJECT DeviceObject,
1025     IN ULONG SectorSize,
1026     IN ULONG SectorsPerTrack,
1027     IN ULONG NumberOfHeads,
1028     IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer
1029 );
1030
1031 //
1032 // Global I/O Data
1033 //
1034 extern POBJECT_TYPE IoCompletionType;
1035 extern PDEVICE_NODE IopRootDeviceNode;
1036 extern ULONG IopTraceLevel;
1037 extern NPAGED_LOOKASIDE_LIST IopMdlLookasideList;
1038 extern GENERIC_MAPPING IopCompletionMapping;
1039 extern GENERIC_MAPPING IopFileMapping;
1040
1041 //
1042 // Inlined Functions
1043 //
1044 #include "io_x.h"