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 PDEVICE_OBJECT
 546 NTAPI
 547 IopGetLowestDevice(
 548     IN PDEVICE_OBJECT DeviceObject
 549 );
 550
 551 NTSTATUS
 552 INIT_FUNCTION
 553 IopInitPlugPlayEvents(VOID);
 554
 555 NTSTATUS
 556 IopQueueTargetDeviceEvent(
 557     const GUID *Guid,
 558     PUNICODE_STRING DeviceIds
 559 );
 560
 561 NTSTATUS
 562 IopInitializePnpServices(
 563     IN PDEVICE_NODE DeviceNode,
 564     IN BOOLEAN BootDrivers)
 565 ;
 566
 567 NTSTATUS
 568 IopInvalidateDeviceRelations(
 569     IN PDEVICE_NODE DeviceNode,
 570     IN DEVICE_RELATION_TYPE Type
 571 );
 572
 573 //
 574 // Initialization Routines
 575 //
 576 NTSTATUS
 577 IoCreateArcNames(
 578     VOID
 579 );
 580
 581 NTSTATUS
 582 IoCreateSystemRootLink(
 583     IN PCHAR ParameterLine
 584 );
 585
 586 //
 587 // Device/Volume Routines
 588 //
 589 NTSTATUS
 590 FASTCALL
 591 IopInitializeDevice(
 592     IN PDEVICE_NODE DeviceNode,
 593     IN PDRIVER_OBJECT DriverObject
 594 );
 595
 596 NTSTATUS
 597 IopStartDevice(
 598     IN PDEVICE_NODE DeviceNode
 599 );
 600
 601 PVPB
 602 NTAPI
 603 IopCheckVpbMounted(
 604     IN POPEN_PACKET OpenPacket,
 605     IN PDEVICE_OBJECT DeviceObject,
 606     IN PUNICODE_STRING RemainingName,
 607     OUT PNTSTATUS Status
 608 );
 609
 610 NTSTATUS
 611 NTAPI
 612 IopMountVolume(
 613     IN PDEVICE_OBJECT DeviceObject,
 614     IN BOOLEAN AllowRawMount,
 615     IN BOOLEAN DeviceIsLocked,
 616     IN BOOLEAN Alertable,
 617     OUT PVPB *Vpb
 618 );
 619
 620 PVOID
 621 IoOpenSymlink(
 622     IN PVOID SymbolicLink
 623 );
 624
 625 PVOID
 626 IoOpenFileOnDevice(
 627     IN PVOID SymbolicLink,
 628     IN PWCHAR Name
 629 );
 630
 631 NTSTATUS
 632 NTAPI
 633 IopCreateVpb(
 634     IN PDEVICE_OBJECT DeviceObject
 635 );
 636
 637 VOID
 638 NTAPI
 639 IopDereferenceVpb(
 640     IN PVPB Vpb
 641 );
 642
 643 VOID
 644 NTAPI
 645 IoInitFileSystemImplementation(
 646     VOID
 647 );
 648
 649 VOID
 650 NTAPI
 651 IoInitVpbImplementation(
 652     VOID
 653 );
 654
 655 NTSTATUS
 656 NTAPI
 657 IopReferenceDeviceObject(
 658     IN PDEVICE_OBJECT DeviceObject
 659 );
 660
 661 VOID
 662 NTAPI
 663 IopDereferenceDeviceObject(
 664     IN PDEVICE_OBJECT DeviceObject,
 665     IN BOOLEAN ForceUnload
 666 );
 667
 668 //
 669 // IRP Routines
 670 //
 671 NTSTATUS
 672 NTAPI
 673 IopCleanupFailedIrp(
 674     IN PFILE_OBJECT FileObject,
 675     IN PKEVENT EventObject
 676 );
 677
 678 VOID
 679 NTAPI
 680 IopAbortInterruptedIrp(
 681     IN PKEVENT EventObject,
 682     IN PIRP Irp
 683 );
 684
 685 //
 686 // Shutdown routines
 687 //
 688 VOID
 689 IoInitShutdownNotification(
 690     VOID
 691 );
 692
 693 VOID
 694 NTAPI
 695 IoShutdownRegisteredDevices(
 696     VOID
 697 );
 698
 699 VOID
 700 NTAPI
 701 IoShutdownRegisteredFileSystems(
 702     VOID
 703 );
 704
 705 //
 706 // Boot logging support
 707 //
 708 VOID
 709 IopInitBootLog(
 710     IN BOOLEAN StartBootLog
 711 );
 712
 713 VOID
 714 IopStartBootLog(
 715     VOID
 716 );
 717
 718 VOID
 719 IopStopBootLog(
 720     VOID
 721 );
 722
 723 VOID
 724 IopBootLog(
 725     IN PUNICODE_STRING DriverName,
 726     IN BOOLEAN Success
 727 );
 728
 729 VOID
 730 IopSaveBootLogToFile(
 731     VOID
 732 );
 733
 734 //
 735 // I/O Cancellation Routines
 736 //
 737 VOID
 738 STDCALL
 739 IoCancelThreadIo(
 740     IN PETHREAD Thread
 741 );
 742
 743 VOID
 744 IoInitCancelHandling(
 745     VOID
 746 );
 747
 748 //
 749 // I/O Completion
 750 //
 751 VOID
 752 NTAPI
 753 IopCompleteRequest(
 754     IN PKAPC Apc,
 755     IN PKNORMAL_ROUTINE* NormalRoutine,
 756     IN PVOID* NormalContext,
 757     IN PVOID* SystemArgument1,
 758     IN PVOID* SystemArgument2
 759 );
 760
 761 //
 762 // Error Logging Routines
 763 //
 764 VOID
 765 NTAPI
 766 IopInitErrorLog(
 767     VOID
 768 );
 769
 770 VOID
 771 NTAPI
 772 IopLogWorker(
 773     IN PVOID Parameter
 774 );
 775
 776 //
 777 // Raw File System MiniDriver
 778 //
 779 BOOLEAN
 780 RawFsIsRawFileSystemDeviceObject(
 781     IN PDEVICE_OBJECT DeviceObject
 782 );
 783
 784 NTSTATUS
 785 STDCALL
 786 RawFsDriverEntry(
 787     IN PDRIVER_OBJECT DriverObject,
 788     IN PUNICODE_STRING RegistryPath
 789 );
 790
 791 //
 792 // PnP Root MiniDriver
 793 //
 794 NTSTATUS
 795 STDCALL
 796 PnpRootDriverEntry(
 797    IN PDRIVER_OBJECT DriverObject,
 798    IN PUNICODE_STRING RegistryPath
 799 );
 800
 801 NTSTATUS
 802 PnpRootCreateDevice(
 803     IN OUT PDEVICE_OBJECT *PhysicalDeviceObject
 804 );
 805
 806 //
 807 // Driver Routines
 808 //
 809 VOID
 810 FASTCALL
 811 IopInitializeBootDrivers(
 812     VOID
 813 );
 814
 815 VOID
 816 FASTCALL
 817 IopInitializeSystemDrivers(
 818     VOID
 819 );
 820
 821 VOID
 822 NTAPI
 823 IopDeleteDriver(
 824     IN PVOID ObjectBody
 825 );
 826
 827 NTSTATUS
 828 FASTCALL
 829 IopCreateDriverObject(
 830     OUT PDRIVER_OBJECT *DriverObject,
 831     IN PUNICODE_STRING ServiceName,
 832     IN ULONG CreateAttributes,
 833     IN BOOLEAN FileSystemDriver,
 834     IN PVOID DriverImageStart,
 835     IN ULONG DriverImageSize
 836 );
 837
 838 NTSTATUS
 839 FASTCALL
 840 IopGetDriverObject(
 841     OUT PDRIVER_OBJECT *DriverObject,
 842     IN PUNICODE_STRING ServiceName,
 843     IN BOOLEAN FileSystem
 844 );
 845
 846 NTSTATUS
 847 FASTCALL
 848 IopLoadServiceModule(
 849     IN PUNICODE_STRING ServiceName,
 850     OUT PLDR_DATA_TABLE_ENTRY *ModuleObject
 851 );
 852
 853 NTSTATUS
 854 FASTCALL
 855 IopInitializeDriverModule(
 856     IN PDEVICE_NODE DeviceNode,
 857     IN PLDR_DATA_TABLE_ENTRY ModuleObject,
 858     IN PUNICODE_STRING ServiceName,
 859     IN BOOLEAN FileSystemDriver,
 860     OUT PDRIVER_OBJECT *DriverObject
 861 );
 862
 863 NTSTATUS
 864 FASTCALL
 865 IopAttachFilterDrivers(
 866     IN PDEVICE_NODE DeviceNode,
 867     IN BOOLEAN Lower
 868 );
 869
 870 VOID
 871 NTAPI
 872 IopReinitializeDrivers(
 873     VOID
 874 );
 875
 876 VOID
 877 NTAPI
 878 IopReinitializeBootDrivers(
 879     VOID
 880 );
 881
 882 //
 883 // File Routines
 884 //
 885 NTSTATUS
 886 NTAPI
 887 IopParseDevice(
 888     IN PVOID ParseObject,
 889     IN PVOID ObjectType,
 890     IN OUT PACCESS_STATE AccessState,
 891     IN KPROCESSOR_MODE AccessMode,
 892     IN ULONG Attributes,
 893     IN OUT PUNICODE_STRING CompleteName,
 894     IN OUT PUNICODE_STRING RemainingName,
 895     IN OUT PVOID Context OPTIONAL,
 896     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
 897     OUT PVOID *Object
 898 );
 899
 900 NTSTATUS
 901 NTAPI
 902 IopParseFile(
 903     IN PVOID ParseObject,
 904     IN PVOID ObjectType,
 905     IN OUT PACCESS_STATE AccessState,
 906     IN KPROCESSOR_MODE AccessMode,
 907     IN ULONG Attributes,
 908     IN OUT PUNICODE_STRING CompleteName,
 909     IN OUT PUNICODE_STRING RemainingName,
 910     IN OUT PVOID Context OPTIONAL,
 911     IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
 912     OUT PVOID *Object
 913 );
 914
 915 VOID
 916 STDCALL
 917 IopDeleteFile(
 918     IN PVOID ObjectBody
 919 );
 920
 921 NTSTATUS
 922 STDCALL
 923 IopSecurityFile(
 924     IN PVOID ObjectBody,
 925     IN SECURITY_OPERATION_CODE OperationCode,
 926     IN SECURITY_INFORMATION SecurityInformation,
 927     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 928     IN OUT PULONG BufferLength,
 929     OUT PSECURITY_DESCRIPTOR *OldSecurityDescriptor,
 930     IN POOL_TYPE PoolType,
 931     IN OUT PGENERIC_MAPPING GenericMapping
 932 );
 933
 934 NTSTATUS
 935 STDCALL
 936 IopQueryNameFile(
 937     IN PVOID ObjectBody,
 938     IN BOOLEAN HasName,
 939     OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
 940     IN ULONG Length,
 941     OUT PULONG ReturnLength,
 942     IN KPROCESSOR_MODE PreviousMode
 943 );
 944
 945 VOID
 946 STDCALL
 947 IopCloseFile(
 948     IN PEPROCESS Process OPTIONAL,
 949     IN PVOID Object,
 950     IN ACCESS_MASK GrantedAccess,
 951     IN ULONG ProcessHandleCount,
 952     IN ULONG SystemHandleCount
 953 );
 954
 955 //
 956 // I/O Timer Routines
 957 //
 958 VOID
 959 FASTCALL
 960 IopInitTimerImplementation(
 961     VOID
 962 );
 963
 964 VOID
 965 STDCALL
 966 IopRemoveTimerFromTimerList(
 967     IN PIO_TIMER Timer
 968 );
 969
 970 //
 971 // I/O Completion Routines
 972 //
 973 VOID
 974 NTAPI
 975 IopDeleteIoCompletion(
 976     PVOID ObjectBody
 977 );
 978
 979 //
 980 // I/O HAL Entrypoints
 981 //
 982 NTSTATUS
 983 FASTCALL
 984 xHalQueryDriveLayout(
 985     IN PUNICODE_STRING DeviceName,
 986     OUT PDRIVE_LAYOUT_INFORMATION *LayoutInfo
 987 );
 988
 989 #undef HalExamineMBR
 990 VOID
 991 FASTCALL
 992 HalExamineMBR(
 993     IN PDEVICE_OBJECT DeviceObject,
 994     IN ULONG SectorSize,
 995     IN ULONG MBRTypeIdentifier,
 996     OUT PVOID *Buffer
 997 );
 998
 999 VOID
1000 FASTCALL
1001 xHalIoAssignDriveLetters(
1002     IN PROS_LOADER_PARAMETER_BLOCK LoaderBlock,
1003     IN PSTRING NtDeviceName,
1004     OUT PUCHAR NtSystemPath,
1005     OUT PSTRING NtSystemPathString
1006 );
1007
1008 NTSTATUS
1009 FASTCALL
1010 xHalIoReadPartitionTable(
1011     IN PDEVICE_OBJECT DeviceObject,
1012     IN ULONG SectorSize,
1013     IN BOOLEAN ReturnRecognizedPartitions,
1014     OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer
1015 );
1016
1017 NTSTATUS
1018 FASTCALL
1019 xHalIoSetPartitionInformation(
1020     IN PDEVICE_OBJECT DeviceObject,
1021     IN ULONG SectorSize,
1022     IN ULONG PartitionNumber,
1023     IN ULONG PartitionType
1024 );
1025
1026 NTSTATUS
1027 FASTCALL
1028 xHalIoWritePartitionTable(
1029     IN PDEVICE_OBJECT DeviceObject,
1030     IN ULONG SectorSize,
1031     IN ULONG SectorsPerTrack,
1032     IN ULONG NumberOfHeads,
1033     IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer
1034 );
1035
1036 //
1037 // Global I/O Data
1038 //
1039 extern POBJECT_TYPE IoCompletionType;
1040 extern PDEVICE_NODE IopRootDeviceNode;
1041 extern ULONG IopTraceLevel;
1042 extern NPAGED_LOOKASIDE_LIST IopMdlLookasideList;
1043 extern GENERIC_MAPPING IopCompletionMapping;
1044 extern GENERIC_MAPPING IopFileMapping;
1045
1046 //
1047 // Inlined Functions
1048 //
1049 #include "io_x.h"