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