include/xdk/iofuncs.h

   1 /******************************************************************************
   2  *                         I/O Manager Functions                              *
   3  ******************************************************************************/
   4
   5 #if !defined(_M_AMD64)
   6 NTHALAPI
   7 VOID
   8 NTAPI
   9 READ_PORT_BUFFER_UCHAR(
  10   IN PUCHAR Port,
  11   IN PUCHAR Buffer,
  12   IN ULONG Count);
  13
  14 NTHALAPI
  15 VOID
  16 NTAPI
  17 READ_PORT_BUFFER_ULONG(
  18   IN PULONG Port,
  19   IN PULONG Buffer,
  20   IN ULONG Count);
  21
  22 NTHALAPI
  23 VOID
  24 NTAPI
  25 READ_PORT_BUFFER_USHORT(
  26   IN PUSHORT Port,
  27   IN PUSHORT Buffer,
  28   IN ULONG Count);
  29
  30 NTHALAPI
  31 UCHAR
  32 NTAPI
  33 READ_PORT_UCHAR(
  34   IN PUCHAR Port);
  35
  36 NTHALAPI
  37 ULONG
  38 NTAPI
  39 READ_PORT_ULONG(
  40   IN PULONG Port);
  41
  42 NTHALAPI
  43 USHORT
  44 NTAPI
  45 READ_PORT_USHORT(
  46   IN PUSHORT Port);
  47
  48 NTKERNELAPI
  49 VOID
  50 NTAPI
  51 READ_REGISTER_BUFFER_UCHAR(
  52   IN PUCHAR Register,
  53   IN PUCHAR Buffer,
  54   IN ULONG Count);
  55
  56 NTKERNELAPI
  57 VOID
  58 NTAPI
  59 READ_REGISTER_BUFFER_ULONG(
  60   IN PULONG Register,
  61   IN PULONG Buffer,
  62   IN ULONG Count);
  63
  64 NTKERNELAPI
  65 VOID
  66 NTAPI
  67 READ_REGISTER_BUFFER_USHORT(
  68   IN PUSHORT Register,
  69   IN PUSHORT Buffer,
  70   IN ULONG Count);
  71
  72 NTKERNELAPI
  73 UCHAR
  74 NTAPI
  75 READ_REGISTER_UCHAR(
  76   IN PUCHAR Register);
  77
  78 NTKERNELAPI
  79 ULONG
  80 NTAPI
  81 READ_REGISTER_ULONG(
  82   IN PULONG Register);
  83
  84 NTKERNELAPI
  85 USHORT
  86 NTAPI
  87 READ_REGISTER_USHORT(
  88   IN PUSHORT Register);
  89
  90 NTHALAPI
  91 VOID
  92 NTAPI
  93 WRITE_PORT_BUFFER_UCHAR(
  94   IN PUCHAR Port,
  95   IN PUCHAR Buffer,
  96   IN ULONG Count);
  97
  98 NTHALAPI
  99 VOID
 100 NTAPI
 101 WRITE_PORT_BUFFER_ULONG(
 102   IN PULONG Port,
 103   IN PULONG Buffer,
 104   IN ULONG Count);
 105
 106 NTHALAPI
 107 VOID
 108 NTAPI
 109 WRITE_PORT_BUFFER_USHORT(
 110   IN PUSHORT Port,
 111   IN PUSHORT Buffer,
 112   IN ULONG Count);
 113
 114 NTHALAPI
 115 VOID
 116 NTAPI
 117 WRITE_PORT_UCHAR(
 118   IN PUCHAR Port,
 119   IN UCHAR Value);
 120
 121 NTHALAPI
 122 VOID
 123 NTAPI
 124 WRITE_PORT_ULONG(
 125   IN PULONG Port,
 126   IN ULONG Value);
 127
 128 NTHALAPI
 129 VOID
 130 NTAPI
 131 WRITE_PORT_USHORT(
 132   IN PUSHORT Port,
 133   IN USHORT Value);
 134
 135 NTKERNELAPI
 136 VOID
 137 NTAPI
 138 WRITE_REGISTER_BUFFER_UCHAR(
 139   IN PUCHAR Register,
 140   IN PUCHAR Buffer,
 141   IN ULONG Count);
 142
 143 NTKERNELAPI
 144 VOID
 145 NTAPI
 146 WRITE_REGISTER_BUFFER_ULONG(
 147   IN PULONG Register,
 148   IN PULONG Buffer,
 149   IN ULONG Count);
 150
 151 NTKERNELAPI
 152 VOID
 153 NTAPI
 154 WRITE_REGISTER_BUFFER_USHORT(
 155   IN PUSHORT Register,
 156   IN PUSHORT Buffer,
 157   IN ULONG Count);
 158
 159 NTKERNELAPI
 160 VOID
 161 NTAPI
 162 WRITE_REGISTER_UCHAR(
 163   IN PUCHAR Register,
 164   IN UCHAR Value);
 165
 166 NTKERNELAPI
 167 VOID
 168 NTAPI
 169 WRITE_REGISTER_ULONG(
 170   IN PULONG Register,
 171   IN ULONG Value);
 172
 173 NTKERNELAPI
 174 VOID
 175 NTAPI
 176 WRITE_REGISTER_USHORT(
 177   IN PUSHORT Register,
 178   IN USHORT Value);
 179
 180 #else
 181
 182 FORCEINLINE
 183 VOID
 184 READ_PORT_BUFFER_UCHAR(
 185   IN PUCHAR Port,
 186   IN PUCHAR Buffer,
 187   IN ULONG Count)
 188 {
 189   __inbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 190 }
 191
 192 FORCEINLINE
 193 VOID
 194 READ_PORT_BUFFER_ULONG(
 195   IN PULONG Port,
 196   IN PULONG Buffer,
 197   IN ULONG Count)
 198 {
 199   __indwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 200 }
 201
 202 FORCEINLINE
 203 VOID
 204 READ_PORT_BUFFER_USHORT(
 205   IN PUSHORT Port,
 206   IN PUSHORT Buffer,
 207   IN ULONG Count)
 208 {
 209   __inwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 210 }
 211
 212 FORCEINLINE
 213 UCHAR
 214 READ_PORT_UCHAR(
 215   IN PUCHAR Port)
 216 {
 217   return __inbyte((USHORT)(ULONG_PTR)Port);
 218 }
 219
 220 FORCEINLINE
 221 ULONG
 222 READ_PORT_ULONG(
 223   IN PULONG Port)
 224 {
 225   return __indword((USHORT)(ULONG_PTR)Port);
 226 }
 227
 228 FORCEINLINE
 229 USHORT
 230 READ_PORT_USHORT(
 231   IN PUSHORT Port)
 232 {
 233   return __inword((USHORT)(ULONG_PTR)Port);
 234 }
 235
 236 FORCEINLINE
 237 VOID
 238 READ_REGISTER_BUFFER_UCHAR(
 239   IN PUCHAR Register,
 240   IN PUCHAR Buffer,
 241   IN ULONG Count)
 242 {
 243   __movsb(Register, Buffer, Count);
 244 }
 245
 246 FORCEINLINE
 247 VOID
 248 READ_REGISTER_BUFFER_ULONG(
 249   IN PULONG Register,
 250   IN PULONG Buffer,
 251   IN ULONG Count)
 252 {
 253   __movsd(Register, Buffer, Count);
 254 }
 255
 256 FORCEINLINE
 257 VOID
 258 READ_REGISTER_BUFFER_USHORT(
 259   IN PUSHORT Register,
 260   IN PUSHORT Buffer,
 261   IN ULONG Count)
 262 {
 263   __movsw(Register, Buffer, Count);
 264 }
 265
 266 FORCEINLINE
 267 UCHAR
 268 READ_REGISTER_UCHAR(
 269   IN volatile UCHAR *Register)
 270 {
 271   return *Register;
 272 }
 273
 274 FORCEINLINE
 275 ULONG
 276 READ_REGISTER_ULONG(
 277   IN volatile ULONG *Register)
 278 {
 279   return *Register;
 280 }
 281
 282 FORCEINLINE
 283 USHORT
 284 READ_REGISTER_USHORT(
 285   IN volatile USHORT *Register)
 286 {
 287   return *Register;
 288 }
 289
 290 FORCEINLINE
 291 VOID
 292 WRITE_PORT_BUFFER_UCHAR(
 293   IN PUCHAR Port,
 294   IN PUCHAR Buffer,
 295   IN ULONG Count)
 296 {
 297   __outbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 298 }
 299
 300 FORCEINLINE
 301 VOID
 302 WRITE_PORT_BUFFER_ULONG(
 303   IN PULONG Port,
 304   IN PULONG Buffer,
 305   IN ULONG Count)
 306 {
 307   __outdwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 308 }
 309
 310 FORCEINLINE
 311 VOID
 312 WRITE_PORT_BUFFER_USHORT(
 313   IN PUSHORT Port,
 314   IN PUSHORT Buffer,
 315   IN ULONG Count)
 316 {
 317   __outwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
 318 }
 319
 320 FORCEINLINE
 321 VOID
 322 WRITE_PORT_UCHAR(
 323   IN PUCHAR Port,
 324   IN UCHAR Value)
 325 {
 326   __outbyte((USHORT)(ULONG_PTR)Port, Value);
 327 }
 328
 329 FORCEINLINE
 330 VOID
 331 WRITE_PORT_ULONG(
 332   IN PULONG Port,
 333   IN ULONG Value)
 334 {
 335   __outdword((USHORT)(ULONG_PTR)Port, Value);
 336 }
 337
 338 FORCEINLINE
 339 VOID
 340 WRITE_PORT_USHORT(
 341   IN PUSHORT Port,
 342   IN USHORT Value)
 343 {
 344   __outword((USHORT)(ULONG_PTR)Port, Value);
 345 }
 346
 347 FORCEINLINE
 348 VOID
 349 WRITE_REGISTER_BUFFER_UCHAR(
 350   IN PUCHAR Register,
 351   IN PUCHAR Buffer,
 352   IN ULONG Count)
 353 {
 354   LONG Synch;
 355   __movsb(Register, Buffer, Count);
 356   InterlockedOr(&Synch, 1);
 357 }
 358
 359 FORCEINLINE
 360 VOID
 361 WRITE_REGISTER_BUFFER_ULONG(
 362   IN PULONG Register,
 363   IN PULONG Buffer,
 364   IN ULONG Count)
 365 {
 366   LONG Synch;
 367   __movsd(Register, Buffer, Count);
 368   InterlockedOr(&Synch, 1);
 369 }
 370
 371 FORCEINLINE
 372 VOID
 373 WRITE_REGISTER_BUFFER_USHORT(
 374   IN PUSHORT Register,
 375   IN PUSHORT Buffer,
 376   IN ULONG Count)
 377 {
 378   LONG Synch;
 379   __movsw(Register, Buffer, Count);
 380   InterlockedOr(&Synch, 1);
 381 }
 382
 383 FORCEINLINE
 384 VOID
 385 WRITE_REGISTER_UCHAR(
 386   IN volatile UCHAR *Register,
 387   IN UCHAR Value)
 388 {
 389   LONG Synch;
 390   *Register = Value;
 391   InterlockedOr(&Synch, 1);
 392 }
 393
 394 FORCEINLINE
 395 VOID
 396 WRITE_REGISTER_ULONG(
 397   IN volatile ULONG *Register,
 398   IN ULONG Value)
 399 {
 400   LONG Synch;
 401   *Register = Value;
 402   InterlockedOr(&Synch, 1);
 403 }
 404
 405 FORCEINLINE
 406 VOID
 407 WRITE_REGISTER_USHORT(
 408   IN volatile USHORT *Register,
 409   IN USHORT Value)
 410 {
 411   LONG Sync;
 412   *Register = Value;
 413   InterlockedOr(&Sync, 1);
 414 }
 415 #endif
 416
 417 #if defined(USE_DMA_MACROS) && !defined(_NTHAL_) && \
 418    (defined(_NTDDK_) || defined(_NTDRIVER_)) || defined(_WDM_INCLUDED_)
 419
 420 #define DMA_MACROS_DEFINED
 421
 422 FORCEINLINE
 423 NTSTATUS
 424 IoAllocateAdapterChannel(
 425   IN PDMA_ADAPTER DmaAdapter,
 426   IN PDEVICE_OBJECT DeviceObject,
 427   IN ULONG NumberOfMapRegisters,
 428   IN PDRIVER_CONTROL ExecutionRoutine,
 429   IN PVOID Context)
 430 {
 431   PALLOCATE_ADAPTER_CHANNEL AllocateAdapterChannel;
 432   AllocateAdapterChannel =
 433       *(DmaAdapter)->DmaOperations->AllocateAdapterChannel;
 434   ASSERT(AllocateAdapterChannel);
 435   return AllocateAdapterChannel(DmaAdapter,
 436                                 DeviceObject,
 437                                 NumberOfMapRegisters,
 438                                 ExecutionRoutine,
 439                                 Context );
 440 }
 441
 442 FORCEINLINE
 443 BOOLEAN
 444 NTAPI
 445 IoFlushAdapterBuffers(
 446   IN PDMA_ADAPTER DmaAdapter,
 447   IN PMDL Mdl,
 448   IN PVOID MapRegisterBase,
 449   IN PVOID CurrentVa,
 450   IN ULONG Length,
 451   IN BOOLEAN WriteToDevice)
 452 {
 453   PFLUSH_ADAPTER_BUFFERS FlushAdapterBuffers;
 454   FlushAdapterBuffers = *(DmaAdapter)->DmaOperations->FlushAdapterBuffers;
 455   ASSERT(FlushAdapterBuffers);
 456   return FlushAdapterBuffers(DmaAdapter,
 457                              Mdl,
 458                              MapRegisterBase,
 459                              CurrentVa,
 460                              Length,
 461                              WriteToDevice);
 462 }
 463
 464 FORCEINLINE
 465 VOID
 466 NTAPI
 467 IoFreeAdapterChannel(
 468   IN PDMA_ADAPTER DmaAdapter)
 469 {
 470   PFREE_ADAPTER_CHANNEL FreeAdapterChannel;
 471   FreeAdapterChannel = *(DmaAdapter)->DmaOperations->FreeAdapterChannel;
 472   ASSERT(FreeAdapterChannel);
 473   FreeAdapterChannel(DmaAdapter);
 474 }
 475
 476 FORCEINLINE
 477 VOID
 478 NTAPI
 479 IoFreeMapRegisters(
 480   IN PDMA_ADAPTER DmaAdapter,
 481   IN PVOID MapRegisterBase,
 482   IN ULONG NumberOfMapRegisters)
 483 {
 484   PFREE_MAP_REGISTERS FreeMapRegisters;
 485   FreeMapRegisters = *(DmaAdapter)->DmaOperations->FreeMapRegisters;
 486   ASSERT(FreeMapRegisters);
 487   FreeMapRegisters(DmaAdapter, MapRegisterBase, NumberOfMapRegisters);
 488 }
 489
 490 FORCEINLINE
 491 PHYSICAL_ADDRESS
 492 NTAPI
 493 IoMapTransfer(
 494   IN PDMA_ADAPTER DmaAdapter,
 495   IN PMDL Mdl,
 496   IN PVOID MapRegisterBase,
 497   IN PVOID CurrentVa,
 498   IN OUT PULONG Length,
 499   IN BOOLEAN WriteToDevice)
 500 {
 501   PMAP_TRANSFER MapTransfer;
 502
 503   MapTransfer = *(DmaAdapter)->DmaOperations->MapTransfer;
 504   ASSERT(MapTransfer);
 505   return MapTransfer(DmaAdapter,
 506                      Mdl,
 507                      MapRegisterBase,
 508                      CurrentVa,
 509                      Length,
 510                      WriteToDevice);
 511 }
 512 #endif
 513
 514 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 515
 516 NTKERNELAPI
 517 VOID
 518 NTAPI
 519 IoAcquireCancelSpinLock(
 520   OUT PKIRQL Irql);
 521
 522 NTKERNELAPI
 523 NTSTATUS
 524 NTAPI
 525 IoAcquireRemoveLockEx(
 526   IN PIO_REMOVE_LOCK RemoveLock,
 527   IN PVOID Tag OPTIONAL,
 528   IN PCSTR File,
 529   IN ULONG Line,
 530   IN ULONG RemlockSize);
 531
 532 #endif
 533
 534 /*
 535  * NTSTATUS
 536  * IoAcquireRemoveLock(
 537  *   IN PIO_REMOVE_LOCK  RemoveLock,
 538  *   IN OPTIONAL PVOID  Tag)
 539  */
 540 #if DBG
 541 #define IoAcquireRemoveLock(RemoveLock, Tag) \
 542   IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof (IO_REMOVE_LOCK))
 543 #else
 544 #define IoAcquireRemoveLock(RemoveLock, Tag) \
 545   IoAcquireRemoveLockEx(RemoveLock, Tag, "", 1, sizeof (IO_REMOVE_LOCK))
 546 #endif
 547
 548 /*
 549  * VOID
 550  * IoAdjustPagingPathCount(
 551  *   IN PLONG  Count,
 552  *   IN BOOLEAN  Increment)
 553  */
 554 #define IoAdjustPagingPathCount(_Count, \
 555                                 _Increment) \
 556 { \
 557   if (_Increment) \
 558     { \
 559       InterlockedIncrement(_Count); \
 560     } \
 561   else \
 562     { \
 563       InterlockedDecrement(_Count); \
 564     } \
 565 }
 566
 567 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 568
 569 NTKERNELAPI
 570 NTSTATUS
 571 NTAPI
 572 IoAllocateDriverObjectExtension(
 573   IN PDRIVER_OBJECT DriverObject,
 574   IN PVOID ClientIdentificationAddress,
 575   IN ULONG DriverObjectExtensionSize,
 576   OUT PVOID *DriverObjectExtension);
 577
 578 NTKERNELAPI
 579 PVOID
 580 NTAPI
 581 IoAllocateErrorLogEntry(
 582   IN PVOID IoObject,
 583   IN UCHAR EntrySize);
 584
 585 NTKERNELAPI
 586 PIRP
 587 NTAPI
 588 IoAllocateIrp(
 589   IN CCHAR StackSize,
 590   IN BOOLEAN ChargeQuota);
 591
 592 NTKERNELAPI
 593 PMDL
 594 NTAPI
 595 IoAllocateMdl(
 596   IN PVOID VirtualAddress OPTIONAL,
 597   IN ULONG Length,
 598   IN BOOLEAN SecondaryBuffer,
 599   IN BOOLEAN ChargeQuota,
 600   IN OUT PIRP Irp OPTIONAL);
 601
 602 NTKERNELAPI
 603 PIO_WORKITEM
 604 NTAPI
 605 IoAllocateWorkItem(
 606   IN PDEVICE_OBJECT DeviceObject);
 607
 608 NTKERNELAPI
 609 NTSTATUS
 610 NTAPI
 611 IoAttachDevice(
 612   IN PDEVICE_OBJECT SourceDevice,
 613   IN PUNICODE_STRING TargetDevice,
 614   OUT PDEVICE_OBJECT *AttachedDevice);
 615
 616 NTKERNELAPI
 617 PDEVICE_OBJECT
 618 NTAPI
 619 IoAttachDeviceToDeviceStack(
 620   IN PDEVICE_OBJECT SourceDevice,
 621   IN PDEVICE_OBJECT TargetDevice);
 622
 623 NTKERNELAPI
 624 PIRP
 625 NTAPI
 626 IoBuildAsynchronousFsdRequest(
 627   IN ULONG MajorFunction,
 628   IN PDEVICE_OBJECT DeviceObject,
 629   IN OUT PVOID Buffer OPTIONAL,
 630   IN ULONG Length OPTIONAL,
 631   IN PLARGE_INTEGER StartingOffset OPTIONAL,
 632   IN PIO_STATUS_BLOCK IoStatusBlock OPTIONAL);
 633
 634 NTKERNELAPI
 635 PIRP
 636 NTAPI
 637 IoBuildDeviceIoControlRequest(
 638   IN ULONG IoControlCode,
 639   IN PDEVICE_OBJECT DeviceObject,
 640   IN PVOID InputBuffer OPTIONAL,
 641   IN ULONG InputBufferLength,
 642   OUT PVOID OutputBuffer OPTIONAL,
 643   IN ULONG OutputBufferLength,
 644   IN BOOLEAN InternalDeviceIoControl,
 645   IN PKEVENT Event,
 646   OUT PIO_STATUS_BLOCK IoStatusBlock);
 647
 648 NTKERNELAPI
 649 VOID
 650 NTAPI
 651 IoBuildPartialMdl(
 652   IN PMDL SourceMdl,
 653   IN OUT PMDL TargetMdl,
 654   IN PVOID VirtualAddress,
 655   IN ULONG Length);
 656
 657 NTKERNELAPI
 658 PIRP
 659 NTAPI
 660 IoBuildSynchronousFsdRequest(
 661   IN ULONG MajorFunction,
 662   IN PDEVICE_OBJECT DeviceObject,
 663   IN OUT PVOID Buffer OPTIONAL,
 664   IN ULONG Length OPTIONAL,
 665   IN PLARGE_INTEGER StartingOffset OPTIONAL,
 666   IN PKEVENT Event,
 667   OUT PIO_STATUS_BLOCK IoStatusBlock);
 668
 669 NTKERNELAPI
 670 NTSTATUS
 671 FASTCALL
 672 IofCallDriver(
 673   IN PDEVICE_OBJECT DeviceObject,
 674   IN OUT PIRP Irp);
 675 #define IoCallDriver IofCallDriver
 676
 677 NTKERNELAPI
 678 VOID
 679 FASTCALL
 680 IofCompleteRequest(
 681   IN PIRP Irp,
 682   IN CCHAR PriorityBoost);
 683 #define IoCompleteRequest IofCompleteRequest
 684
 685 NTKERNELAPI
 686 BOOLEAN
 687 NTAPI
 688 IoCancelIrp(
 689   IN PIRP Irp);
 690
 691 NTKERNELAPI
 692 NTSTATUS
 693 NTAPI
 694 IoCheckShareAccess(
 695   IN ACCESS_MASK DesiredAccess,
 696   IN ULONG DesiredShareAccess,
 697   IN OUT PFILE_OBJECT FileObject,
 698   IN OUT PSHARE_ACCESS ShareAccess,
 699   IN BOOLEAN Update);
 700
 701 NTKERNELAPI
 702 VOID
 703 FASTCALL
 704 IofCompleteRequest(
 705   IN PIRP Irp,
 706   IN CCHAR PriorityBoost);
 707
 708 NTKERNELAPI
 709 NTSTATUS
 710 NTAPI
 711 IoConnectInterrupt(
 712   OUT PKINTERRUPT *InterruptObject,
 713   IN PKSERVICE_ROUTINE ServiceRoutine,
 714   IN PVOID ServiceContext OPTIONAL,
 715   IN PKSPIN_LOCK SpinLock OPTIONAL,
 716   IN ULONG Vector,
 717   IN KIRQL Irql,
 718   IN KIRQL SynchronizeIrql,
 719   IN KINTERRUPT_MODE InterruptMode,
 720   IN BOOLEAN ShareVector,
 721   IN KAFFINITY ProcessorEnableMask,
 722   IN BOOLEAN FloatingSave);
 723
 724 NTKERNELAPI
 725 NTSTATUS
 726 NTAPI
 727 IoCreateDevice(
 728   IN PDRIVER_OBJECT DriverObject,
 729   IN ULONG DeviceExtensionSize,
 730   IN PUNICODE_STRING DeviceName OPTIONAL,
 731   IN DEVICE_TYPE DeviceType,
 732   IN ULONG DeviceCharacteristics,
 733   IN BOOLEAN Exclusive,
 734   OUT PDEVICE_OBJECT *DeviceObject);
 735
 736 NTKERNELAPI
 737 NTSTATUS
 738 NTAPI
 739 IoCreateFile(
 740   OUT PHANDLE FileHandle,
 741   IN ACCESS_MASK DesiredAccess,
 742   IN POBJECT_ATTRIBUTES ObjectAttributes,
 743   OUT PIO_STATUS_BLOCK IoStatusBlock,
 744   IN PLARGE_INTEGER AllocationSize OPTIONAL,
 745   IN ULONG FileAttributes,
 746   IN ULONG ShareAccess,
 747   IN ULONG Disposition,
 748   IN ULONG CreateOptions,
 749   IN PVOID EaBuffer OPTIONAL,
 750   IN ULONG EaLength,
 751   IN CREATE_FILE_TYPE CreateFileType,
 752   IN PVOID InternalParameters OPTIONAL,
 753   IN ULONG Options);
 754
 755 NTKERNELAPI
 756 PKEVENT
 757 NTAPI
 758 IoCreateNotificationEvent(
 759   IN PUNICODE_STRING EventName,
 760   OUT PHANDLE EventHandle);
 761
 762 NTKERNELAPI
 763 NTSTATUS
 764 NTAPI
 765 IoCreateSymbolicLink(
 766   IN PUNICODE_STRING SymbolicLinkName,
 767   IN PUNICODE_STRING DeviceName);
 768
 769 NTKERNELAPI
 770 PKEVENT
 771 NTAPI
 772 IoCreateSynchronizationEvent(
 773   IN PUNICODE_STRING EventName,
 774   OUT PHANDLE EventHandle);
 775
 776 NTKERNELAPI
 777 NTSTATUS
 778 NTAPI
 779 IoCreateUnprotectedSymbolicLink(
 780   IN PUNICODE_STRING SymbolicLinkName,
 781   IN PUNICODE_STRING DeviceName);
 782
 783 NTKERNELAPI
 784 VOID
 785 NTAPI
 786 IoDeleteDevice(
 787   IN PDEVICE_OBJECT DeviceObject);
 788
 789 NTKERNELAPI
 790 NTSTATUS
 791 NTAPI
 792 IoDeleteSymbolicLink(
 793   IN PUNICODE_STRING SymbolicLinkName);
 794
 795 NTKERNELAPI
 796 VOID
 797 NTAPI
 798 IoDetachDevice(
 799   IN OUT PDEVICE_OBJECT TargetDevice);
 800
 801 NTKERNELAPI
 802 VOID
 803 NTAPI
 804 IoDisconnectInterrupt(
 805   IN PKINTERRUPT InterruptObject);
 806
 807 NTKERNELAPI
 808 VOID
 809 NTAPI
 810 IoFreeIrp(
 811   IN PIRP Irp);
 812
 813 NTKERNELAPI
 814 VOID
 815 NTAPI
 816 IoFreeMdl(
 817   IN PMDL Mdl);
 818
 819 NTKERNELAPI
 820 VOID
 821 NTAPI
 822 IoFreeWorkItem(
 823   IN PIO_WORKITEM IoWorkItem);
 824
 825 NTKERNELAPI
 826 PDEVICE_OBJECT
 827 NTAPI
 828 IoGetAttachedDevice(
 829   IN PDEVICE_OBJECT DeviceObject);
 830
 831 NTKERNELAPI
 832 PDEVICE_OBJECT
 833 NTAPI
 834 IoGetAttachedDeviceReference(
 835   IN PDEVICE_OBJECT DeviceObject);
 836
 837 NTKERNELAPI
 838 NTSTATUS
 839 NTAPI
 840 IoGetBootDiskInformation(
 841   IN OUT PBOOTDISK_INFORMATION BootDiskInformation,
 842   IN ULONG Size);
 843
 844 NTKERNELAPI
 845 NTSTATUS
 846 NTAPI
 847 IoGetDeviceInterfaceAlias(
 848   IN PUNICODE_STRING SymbolicLinkName,
 849   IN CONST GUID *AliasInterfaceClassGuid,
 850   OUT PUNICODE_STRING AliasSymbolicLinkName);
 851
 852 NTKERNELAPI
 853 PEPROCESS
 854 NTAPI
 855 IoGetCurrentProcess(VOID);
 856
 857 NTKERNELAPI
 858 NTSTATUS
 859 NTAPI
 860 IoGetDeviceInterfaces(
 861   IN CONST GUID *InterfaceClassGuid,
 862   IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
 863   IN ULONG Flags,
 864   OUT PWSTR *SymbolicLinkList);
 865
 866 NTKERNELAPI
 867 NTSTATUS
 868 NTAPI
 869 IoGetDeviceObjectPointer(
 870   IN PUNICODE_STRING ObjectName,
 871   IN ACCESS_MASK DesiredAccess,
 872   OUT PFILE_OBJECT *FileObject,
 873   OUT PDEVICE_OBJECT *DeviceObject);
 874
 875 NTKERNELAPI
 876 NTSTATUS
 877 NTAPI
 878 IoGetDeviceProperty(
 879   IN PDEVICE_OBJECT DeviceObject,
 880   IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
 881   IN ULONG BufferLength,
 882   OUT PVOID PropertyBuffer,
 883   OUT PULONG ResultLength);
 884
 885 NTKERNELAPI
 886 PDMA_ADAPTER
 887 NTAPI
 888 IoGetDmaAdapter(
 889   IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
 890   IN PDEVICE_DESCRIPTION DeviceDescription,
 891   IN OUT PULONG NumberOfMapRegisters);
 892
 893 NTKERNELAPI
 894 PVOID
 895 NTAPI
 896 IoGetDriverObjectExtension(
 897   IN PDRIVER_OBJECT DriverObject,
 898   IN PVOID ClientIdentificationAddress);
 899
 900 NTKERNELAPI
 901 PVOID
 902 NTAPI
 903 IoGetInitialStack(VOID);
 904
 905 NTKERNELAPI
 906 PDEVICE_OBJECT
 907 NTAPI
 908 IoGetRelatedDeviceObject(
 909   IN PFILE_OBJECT FileObject);
 910
 911 NTKERNELAPI
 912 VOID
 913 NTAPI
 914 IoQueueWorkItem(
 915   IN PIO_WORKITEM IoWorkItem,
 916   IN PIO_WORKITEM_ROUTINE WorkerRoutine,
 917   IN WORK_QUEUE_TYPE QueueType,
 918   IN PVOID Context OPTIONAL);
 919
 920 NTKERNELAPI
 921 VOID
 922 NTAPI
 923 IoInitializeIrp(
 924   IN OUT PIRP Irp,
 925   IN USHORT PacketSize,
 926   IN CCHAR StackSize);
 927
 928 NTKERNELAPI
 929 VOID
 930 NTAPI
 931 IoInitializeRemoveLockEx(
 932   IN PIO_REMOVE_LOCK Lock,
 933   IN ULONG AllocateTag,
 934   IN ULONG MaxLockedMinutes,
 935   IN ULONG HighWatermark,
 936   IN ULONG RemlockSize);
 937
 938 NTKERNELAPI
 939 NTSTATUS
 940 NTAPI
 941 IoInitializeTimer(
 942   IN PDEVICE_OBJECT DeviceObject,
 943   IN PIO_TIMER_ROUTINE TimerRoutine,
 944   IN PVOID Context OPTIONAL);
 945
 946 NTKERNELAPI
 947 VOID
 948 NTAPI
 949 IoInvalidateDeviceRelations(
 950   IN PDEVICE_OBJECT DeviceObject,
 951   IN DEVICE_RELATION_TYPE Type);
 952
 953 NTKERNELAPI
 954 VOID
 955 NTAPI
 956 IoInvalidateDeviceState(
 957   IN PDEVICE_OBJECT PhysicalDeviceObject);
 958
 959 NTKERNELAPI
 960 BOOLEAN
 961 NTAPI
 962 IoIsWdmVersionAvailable(
 963   IN UCHAR MajorVersion,
 964   IN UCHAR MinorVersion);
 965
 966 NTKERNELAPI
 967 NTSTATUS
 968 NTAPI
 969 IoOpenDeviceInterfaceRegistryKey(
 970   IN PUNICODE_STRING SymbolicLinkName,
 971   IN ACCESS_MASK DesiredAccess,
 972   OUT PHANDLE DeviceInterfaceKey);
 973
 974 NTKERNELAPI
 975 NTSTATUS
 976 NTAPI
 977 IoOpenDeviceRegistryKey(
 978   IN PDEVICE_OBJECT DeviceObject,
 979   IN ULONG DevInstKeyType,
 980   IN ACCESS_MASK DesiredAccess,
 981   OUT PHANDLE DevInstRegKey);
 982
 983 NTKERNELAPI
 984 NTSTATUS
 985 NTAPI
 986 IoRegisterDeviceInterface(
 987   IN PDEVICE_OBJECT PhysicalDeviceObject,
 988   IN CONST GUID *InterfaceClassGuid,
 989   IN PUNICODE_STRING ReferenceString OPTIONAL,
 990   OUT PUNICODE_STRING SymbolicLinkName);
 991
 992 NTKERNELAPI
 993 NTSTATUS
 994 NTAPI
 995 IoRegisterPlugPlayNotification(
 996   IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory,
 997   IN ULONG EventCategoryFlags,
 998   IN PVOID EventCategoryData OPTIONAL,
 999   IN PDRIVER_OBJECT DriverObject,
1000   IN PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine,
1001   IN OUT PVOID Context OPTIONAL,
1002   OUT PVOID *NotificationEntry);
1003
1004 NTKERNELAPI
1005 NTSTATUS
1006 NTAPI
1007 IoRegisterShutdownNotification(
1008   IN PDEVICE_OBJECT DeviceObject);
1009
1010 NTKERNELAPI
1011 VOID
1012 NTAPI
1013 IoReleaseCancelSpinLock(
1014   IN KIRQL Irql);
1015
1016 NTKERNELAPI
1017 VOID
1018 NTAPI
1019 IoReleaseRemoveLockAndWaitEx(
1020   IN PIO_REMOVE_LOCK RemoveLock,
1021   IN PVOID Tag OPTIONAL,
1022   IN ULONG RemlockSize);
1023
1024 NTKERNELAPI
1025 VOID
1026 NTAPI
1027 IoReleaseRemoveLockEx(
1028   IN PIO_REMOVE_LOCK RemoveLock,
1029   IN PVOID Tag OPTIONAL,
1030   IN ULONG RemlockSize);
1031
1032 NTKERNELAPI
1033 VOID
1034 NTAPI
1035 IoRemoveShareAccess(
1036   IN PFILE_OBJECT FileObject,
1037   IN OUT PSHARE_ACCESS ShareAccess);
1038
1039 NTKERNELAPI
1040 NTSTATUS
1041 NTAPI
1042 IoReportTargetDeviceChange(
1043   IN PDEVICE_OBJECT PhysicalDeviceObject,
1044   IN PVOID NotificationStructure);
1045
1046 NTKERNELAPI
1047 NTSTATUS
1048 NTAPI
1049 IoReportTargetDeviceChangeAsynchronous(
1050   IN PDEVICE_OBJECT PhysicalDeviceObject,
1051   IN PVOID NotificationStructure,
1052   IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
1053   IN PVOID Context OPTIONAL);
1054
1055 NTKERNELAPI
1056 VOID
1057 NTAPI
1058 IoRequestDeviceEject(
1059   IN PDEVICE_OBJECT PhysicalDeviceObject);
1060
1061 NTKERNELAPI
1062 VOID
1063 NTAPI
1064 IoReuseIrp(
1065   IN OUT PIRP Irp,
1066   IN NTSTATUS Status);
1067
1068 NTKERNELAPI
1069 NTSTATUS
1070 NTAPI
1071 IoSetDeviceInterfaceState(
1072   IN PUNICODE_STRING SymbolicLinkName,
1073   IN BOOLEAN Enable);
1074
1075 NTKERNELAPI
1076 VOID
1077 NTAPI
1078 IoSetShareAccess(
1079   IN ACCESS_MASK DesiredAccess,
1080   IN ULONG DesiredShareAccess,
1081   IN OUT PFILE_OBJECT FileObject,
1082   OUT PSHARE_ACCESS ShareAccess);
1083
1084 NTKERNELAPI
1085 VOID
1086 NTAPI
1087 IoStartNextPacket(
1088   IN PDEVICE_OBJECT DeviceObject,
1089   IN BOOLEAN Cancelable);
1090
1091 NTKERNELAPI
1092 VOID
1093 NTAPI
1094 IoStartNextPacketByKey(
1095   IN PDEVICE_OBJECT DeviceObject,
1096   IN BOOLEAN Cancelable,
1097   IN ULONG Key);
1098
1099 NTKERNELAPI
1100 VOID
1101 NTAPI
1102 IoStartPacket(
1103   IN PDEVICE_OBJECT DeviceObject,
1104   IN PIRP Irp,
1105   IN PULONG Key OPTIONAL,
1106   IN PDRIVER_CANCEL CancelFunction OPTIONAL);
1107
1108 NTKERNELAPI
1109 VOID
1110 NTAPI
1111 IoStartTimer(
1112   IN PDEVICE_OBJECT DeviceObject);
1113
1114 NTKERNELAPI
1115 VOID
1116 NTAPI
1117 IoStopTimer(
1118   IN PDEVICE_OBJECT DeviceObject);
1119
1120 NTKERNELAPI
1121 NTSTATUS
1122 NTAPI
1123 IoUnregisterPlugPlayNotification(
1124   IN PVOID NotificationEntry);
1125
1126 NTKERNELAPI
1127 VOID
1128 NTAPI
1129 IoUnregisterShutdownNotification(
1130   IN PDEVICE_OBJECT DeviceObject);
1131
1132 NTKERNELAPI
1133 VOID
1134 NTAPI
1135 IoUpdateShareAccess(
1136   IN PFILE_OBJECT FileObject,
1137   IN OUT PSHARE_ACCESS ShareAccess);
1138
1139 NTKERNELAPI
1140 NTSTATUS
1141 NTAPI
1142 IoWMIAllocateInstanceIds(
1143   IN GUID *Guid,
1144   IN ULONG InstanceCount,
1145   OUT ULONG *FirstInstanceId);
1146
1147 NTKERNELAPI
1148 NTSTATUS
1149 NTAPI
1150 IoWMIQuerySingleInstanceMultiple(
1151   IN PVOID *DataBlockObjectList,
1152   IN PUNICODE_STRING InstanceNames,
1153   IN ULONG ObjectCount,
1154   IN OUT ULONG *InOutBufferSize,
1155   OUT PVOID OutBuffer);
1156
1157 NTKERNELAPI
1158 NTSTATUS
1159 NTAPI
1160 IoWMIRegistrationControl(
1161   IN PDEVICE_OBJECT DeviceObject,
1162   IN ULONG Action);
1163
1164 NTKERNELAPI
1165 NTSTATUS
1166 NTAPI
1167 IoWMISuggestInstanceName(
1168   IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
1169   IN PUNICODE_STRING SymbolicLinkName OPTIONAL,
1170   IN BOOLEAN CombineNames,
1171   OUT PUNICODE_STRING SuggestedInstanceName);
1172
1173 NTKERNELAPI
1174 NTSTATUS
1175 NTAPI
1176 IoWMIWriteEvent(
1177   IN PVOID WnodeEventItem);
1178
1179 NTKERNELAPI
1180 VOID
1181 NTAPI
1182 IoWriteErrorLogEntry(
1183   IN PVOID ElEntry);
1184
1185 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
1186
1187 #if (NTDDI_VERSION >= NTDDI_WINXP)
1188
1189 NTKERNELAPI
1190 NTSTATUS
1191 NTAPI
1192 IoCsqInitialize(
1193   IN PIO_CSQ Csq,
1194   IN PIO_CSQ_INSERT_IRP CsqInsertIrp,
1195   IN PIO_CSQ_REMOVE_IRP CsqRemoveIrp,
1196   IN PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp,
1197   IN PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock,
1198   IN PIO_CSQ_RELEASE_LOCK CsqReleaseLock,
1199   IN PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp);
1200
1201 NTKERNELAPI
1202 VOID
1203 NTAPI
1204 IoCsqInsertIrp(
1205   IN PIO_CSQ Csq,
1206   IN PIRP Irp,
1207   IN PIO_CSQ_IRP_CONTEXT Context OPTIONAL);
1208
1209 NTKERNELAPI
1210 PIRP
1211 NTAPI
1212 IoCsqRemoveIrp(
1213   IN PIO_CSQ Csq,
1214   IN PIO_CSQ_IRP_CONTEXT Context);
1215
1216 NTKERNELAPI
1217 PIRP
1218 NTAPI
1219 IoCsqRemoveNextIrp(
1220   IN PIO_CSQ Csq,
1221   IN PVOID PeekContext);
1222
1223 NTKERNELAPI
1224 BOOLEAN
1225 NTAPI
1226 IoForwardIrpSynchronously(
1227   IN PDEVICE_OBJECT DeviceObject,
1228   IN PIRP Irp);
1229
1230 #define IoForwardAndCatchIrp IoForwardIrpSynchronously
1231
1232 NTKERNELAPI
1233 VOID
1234 NTAPI
1235 IoFreeErrorLogEntry(
1236   PVOID ElEntry);
1237
1238 NTKERNELAPI
1239 NTSTATUS
1240 NTAPI
1241 IoSetCompletionRoutineEx(
1242   IN PDEVICE_OBJECT DeviceObject,
1243   IN PIRP Irp,
1244   IN PIO_COMPLETION_ROUTINE CompletionRoutine,
1245   IN PVOID Context,
1246   IN BOOLEAN InvokeOnSuccess,
1247   IN BOOLEAN InvokeOnError,
1248   IN BOOLEAN InvokeOnCancel);
1249
1250 VOID
1251 NTAPI
1252 IoSetStartIoAttributes(
1253   IN PDEVICE_OBJECT DeviceObject,
1254   IN BOOLEAN DeferredStartIo,
1255   IN BOOLEAN NonCancelable);
1256
1257 NTKERNELAPI
1258 NTSTATUS
1259 NTAPI
1260 IoWMIDeviceObjectToInstanceName(
1261   IN PVOID DataBlockObject,
1262   IN PDEVICE_OBJECT DeviceObject,
1263   OUT PUNICODE_STRING InstanceName);
1264
1265 NTKERNELAPI
1266 NTSTATUS
1267 NTAPI
1268 IoWMIExecuteMethod(
1269   IN PVOID DataBlockObject,
1270   IN PUNICODE_STRING InstanceName,
1271   IN ULONG MethodId,
1272   IN ULONG InBufferSize,
1273   IN OUT PULONG OutBufferSize,
1274   IN OUT  PUCHAR InOutBuffer);
1275
1276 NTKERNELAPI
1277 NTSTATUS
1278 NTAPI
1279 IoWMIHandleToInstanceName(
1280   IN PVOID DataBlockObject,
1281   IN HANDLE FileHandle,
1282   OUT PUNICODE_STRING InstanceName);
1283
1284 NTKERNELAPI
1285 NTSTATUS
1286 NTAPI
1287 IoWMIOpenBlock(
1288   IN GUID *DataBlockGuid,
1289   IN ULONG DesiredAccess,
1290   OUT PVOID *DataBlockObject);
1291
1292 NTKERNELAPI
1293 NTSTATUS
1294 NTAPI
1295 IoWMIQueryAllData(
1296   IN PVOID DataBlockObject,
1297   IN OUT ULONG *InOutBufferSize,
1298   OUT PVOID OutBuffer);
1299
1300 NTKERNELAPI
1301 NTSTATUS
1302 NTAPI
1303 IoWMIQueryAllDataMultiple(
1304   IN PVOID *DataBlockObjectList,
1305   IN ULONG ObjectCount,
1306   IN OUT ULONG *InOutBufferSize,
1307   OUT PVOID OutBuffer);
1308
1309 NTKERNELAPI
1310 NTSTATUS
1311 NTAPI
1312 IoWMIQuerySingleInstance(
1313   IN PVOID DataBlockObject,
1314   IN PUNICODE_STRING InstanceName,
1315   IN OUT ULONG *InOutBufferSize,
1316   OUT PVOID OutBuffer);
1317
1318 NTKERNELAPI
1319 NTSTATUS
1320 NTAPI
1321 IoWMISetNotificationCallback(
1322   IN OUT PVOID Object,
1323   IN WMI_NOTIFICATION_CALLBACK Callback,
1324   IN PVOID Context OPTIONAL);
1325
1326 NTKERNELAPI
1327 NTSTATUS
1328 NTAPI
1329 IoWMISetSingleInstance(
1330   IN PVOID DataBlockObject,
1331   IN PUNICODE_STRING InstanceName,
1332   IN ULONG Version,
1333   IN ULONG ValueBufferSize,
1334   IN PVOID ValueBuffer);
1335
1336 NTKERNELAPI
1337 NTSTATUS
1338 NTAPI
1339 IoWMISetSingleItem(
1340   IN PVOID DataBlockObject,
1341   IN PUNICODE_STRING InstanceName,
1342   IN ULONG DataItemId,
1343   IN ULONG Version,
1344   IN ULONG ValueBufferSize,
1345   IN PVOID ValueBuffer);
1346
1347 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
1348
1349 #if defined(_WIN64)
1350 NTKERNELAPI
1351 ULONG
1352 NTAPI
1353 IoWMIDeviceObjectToProviderId(
1354   IN PDEVICE_OBJECT DeviceObject);
1355 #else
1356 #define IoWMIDeviceObjectToProviderId(DeviceObject) ((ULONG)(DeviceObject))
1357 #endif
1358
1359 /*
1360  * USHORT
1361  * IoSizeOfIrp(
1362  *   IN CCHAR  StackSize)
1363  */
1364 #define IoSizeOfIrp(_StackSize) \
1365   ((USHORT) (sizeof(IRP) + ((_StackSize) * (sizeof(IO_STACK_LOCATION)))))
1366
1367 FORCEINLINE
1368 VOID
1369 IoSkipCurrentIrpStackLocation(
1370   IN OUT PIRP Irp)
1371 {
1372   ASSERT(Irp->CurrentLocation <= Irp->StackCount);
1373   Irp->CurrentLocation++;
1374   Irp->Tail.Overlay.CurrentStackLocation++;
1375 }
1376
1377 FORCEINLINE
1378 VOID
1379 IoSetNextIrpStackLocation(
1380   IN OUT PIRP Irp)
1381 {
1382   ASSERT(Irp->CurrentLocation > 0);
1383   Irp->CurrentLocation--;
1384   Irp->Tail.Overlay.CurrentStackLocation--;
1385 }
1386
1387 FORCEINLINE
1388 PIO_STACK_LOCATION
1389 IoGetNextIrpStackLocation(
1390   IN PIRP Irp)
1391 {
1392   ASSERT(Irp->CurrentLocation > 0);
1393   return ((Irp)->Tail.Overlay.CurrentStackLocation - 1 );
1394 }
1395
1396 FORCEINLINE
1397 VOID
1398 IoSetCompletionRoutine(
1399   IN PIRP Irp,
1400   IN PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
1401   IN PVOID Context OPTIONAL,
1402   IN BOOLEAN InvokeOnSuccess,
1403   IN BOOLEAN InvokeOnError,
1404   IN BOOLEAN InvokeOnCancel)
1405 {
1406   PIO_STACK_LOCATION irpSp;
1407   ASSERT( (InvokeOnSuccess || InvokeOnError || InvokeOnCancel) ? (CompletionRoutine != NULL) : TRUE );
1408   irpSp = IoGetNextIrpStackLocation(Irp);
1409   irpSp->CompletionRoutine = CompletionRoutine;
1410   irpSp->Context = Context;
1411   irpSp->Control = 0;
1412
1413   if (InvokeOnSuccess) {
1414     irpSp->Control = SL_INVOKE_ON_SUCCESS;
1415   }
1416
1417   if (InvokeOnError) {
1418     irpSp->Control |= SL_INVOKE_ON_ERROR;
1419   }
1420
1421   if (InvokeOnCancel) {
1422     irpSp->Control |= SL_INVOKE_ON_CANCEL;
1423   }
1424 }
1425
1426 /*
1427  * PDRIVER_CANCEL
1428  * IoSetCancelRoutine(
1429  *   IN PIRP  Irp,
1430  *   IN PDRIVER_CANCEL  CancelRoutine)
1431  */
1432 #define IoSetCancelRoutine(_Irp, \
1433                            _CancelRoutine) \
1434   ((PDRIVER_CANCEL) (ULONG_PTR) InterlockedExchangePointer( \
1435     (PVOID *) &(_Irp)->CancelRoutine, (PVOID) (ULONG_PTR) (_CancelRoutine)))
1436
1437 /*
1438  * VOID
1439  * IoRequestDpc(
1440  *   IN PDEVICE_OBJECT  DeviceObject,
1441  *   IN PIRP  Irp,
1442  *   IN PVOID  Context);
1443  */
1444 #define IoRequestDpc(DeviceObject, Irp, Context)( \
1445   KeInsertQueueDpc(&(DeviceObject)->Dpc, (Irp), (Context)))
1446
1447 /*
1448  * VOID
1449  * IoReleaseRemoveLock(
1450  *   IN PIO_REMOVE_LOCK  RemoveLock,
1451  *   IN PVOID  Tag)
1452  */
1453 #define IoReleaseRemoveLock(_RemoveLock, \
1454                             _Tag) \
1455   IoReleaseRemoveLockEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
1456
1457 /*
1458  * VOID
1459  * IoReleaseRemoveLockAndWait(
1460  *   IN PIO_REMOVE_LOCK  RemoveLock,
1461  *   IN PVOID  Tag)
1462  */
1463 #define IoReleaseRemoveLockAndWait(_RemoveLock, \
1464                                    _Tag) \
1465   IoReleaseRemoveLockAndWaitEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
1466
1467 #if defined(_WIN64)
1468 NTKERNELAPI
1469 BOOLEAN
1470 IoIs32bitProcess(
1471   IN PIRP Irp OPTIONAL);
1472 #endif
1473
1474 #define PLUGPLAY_REGKEY_DEVICE                            1
1475 #define PLUGPLAY_REGKEY_DRIVER                            2
1476 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE                 4
1477
1478 FORCEINLINE
1479 PIO_STACK_LOCATION
1480 IoGetCurrentIrpStackLocation(
1481   IN PIRP Irp)
1482 {
1483   ASSERT(Irp->CurrentLocation <= Irp->StackCount + 1);
1484   return Irp->Tail.Overlay.CurrentStackLocation;
1485 }
1486
1487 FORCEINLINE
1488 VOID
1489 IoMarkIrpPending(
1490   IN OUT PIRP Irp)
1491 {
1492   IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED;
1493 }
1494
1495 /*
1496  * BOOLEAN
1497  * IoIsErrorUserInduced(
1498  *   IN NTSTATUS  Status);
1499  */
1500 #define IoIsErrorUserInduced(Status) \
1501    ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \
1502    ((Status) == STATUS_IO_TIMEOUT) || \
1503    ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \
1504    ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \
1505    ((Status) == STATUS_VERIFY_REQUIRED) || \
1506    ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \
1507    ((Status) == STATUS_WRONG_VOLUME)))
1508
1509 /* VOID
1510  * IoInitializeRemoveLock(
1511  *   IN PIO_REMOVE_LOCK  Lock,
1512  *   IN ULONG  AllocateTag,
1513  *   IN ULONG  MaxLockedMinutes,
1514  *   IN ULONG  HighWatermark)
1515  */
1516 #define IoInitializeRemoveLock( \
1517   Lock, AllocateTag, MaxLockedMinutes, HighWatermark) \
1518   IoInitializeRemoveLockEx(Lock, AllocateTag, MaxLockedMinutes, \
1519     HighWatermark, sizeof(IO_REMOVE_LOCK))
1520
1521 VOID
1522 FORCEINLINE
1523 IoInitializeDpcRequest(
1524   IN PDEVICE_OBJECT DeviceObject,
1525   IN PIO_DPC_ROUTINE DpcRoutine)
1526 {
1527   KeInitializeDpc( &DeviceObject->Dpc,
1528                    (PKDEFERRED_ROUTINE) DpcRoutine,
1529                    DeviceObject );
1530 }
1531
1532 #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001
1533
1534 /*
1535  * ULONG
1536  * IoGetFunctionCodeFromCtlCode(
1537  *   IN ULONG  ControlCode)
1538  */
1539 #define IoGetFunctionCodeFromCtlCode(_ControlCode) \
1540   (((_ControlCode) >> 2) & 0x00000FFF)
1541
1542 FORCEINLINE
1543 VOID
1544 IoCopyCurrentIrpStackLocationToNext(
1545   IN PIRP Irp)
1546 {
1547   PIO_STACK_LOCATION irpSp;
1548   PIO_STACK_LOCATION nextIrpSp;
1549   irpSp = IoGetCurrentIrpStackLocation(Irp);
1550   nextIrpSp = IoGetNextIrpStackLocation(Irp);
1551   RtlCopyMemory( nextIrpSp, irpSp, FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine));
1552   nextIrpSp->Control = 0;
1553 }
1554
1555 NTKERNELAPI
1556 VOID
1557 NTAPI
1558 IoGetStackLimits(
1559   OUT PULONG_PTR LowLimit,
1560   OUT PULONG_PTR HighLimit);
1561
1562 FORCEINLINE
1563 ULONG_PTR
1564 IoGetRemainingStackSize(VOID)
1565 {
1566   ULONG_PTR End, Begin;
1567   ULONG_PTR Result;
1568
1569   IoGetStackLimits(&Begin, &End);
1570   Result = (ULONG_PTR)(&End) - Begin;
1571   return Result;
1572 }
1573