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 NTKERNELAPI
 516 VOID
 517 NTAPI
 518 IoAcquireCancelSpinLock(
 519   OUT PKIRQL  Irql);
 520
 521 NTKERNELAPI
 522 NTSTATUS
 523 NTAPI
 524 IoAcquireRemoveLockEx(
 525   IN PIO_REMOVE_LOCK  RemoveLock,
 526   IN PVOID  Tag  OPTIONAL,
 527   IN PCSTR  File,
 528   IN ULONG  Line,
 529   IN ULONG  RemlockSize);
 530 #endif
 531
 532 /*
 533  * NTSTATUS
 534  * IoAcquireRemoveLock(
 535  *   IN PIO_REMOVE_LOCK  RemoveLock,
 536  *   IN OPTIONAL PVOID  Tag)
 537  */
 538 #if DBG
 539 #define IoAcquireRemoveLock(RemoveLock, Tag) \
 540   IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof (IO_REMOVE_LOCK))
 541 #else
 542 #define IoAcquireRemoveLock(RemoveLock, Tag) \
 543   IoAcquireRemoveLockEx(RemoveLock, Tag, "", 1, sizeof (IO_REMOVE_LOCK))
 544 #endif
 545
 546 /*
 547  * VOID
 548  * IoAdjustPagingPathCount(
 549  *   IN PLONG  Count,
 550  *   IN BOOLEAN  Increment)
 551  */
 552 #define IoAdjustPagingPathCount(_Count, \
 553                                 _Increment) \
 554 { \
 555   if (_Increment) \
 556     { \
 557       InterlockedIncrement(_Count); \
 558     } \
 559   else \
 560     { \
 561       InterlockedDecrement(_Count); \
 562     } \
 563 }
 564
 565 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 566
 567 NTKERNELAPI
 568 NTSTATUS
 569 NTAPI
 570 IoAllocateDriverObjectExtension(
 571   IN PDRIVER_OBJECT  DriverObject,
 572   IN PVOID  ClientIdentificationAddress,
 573   IN ULONG  DriverObjectExtensionSize,
 574   OUT PVOID  *DriverObjectExtension);
 575
 576 NTKERNELAPI
 577 PVOID
 578 NTAPI
 579 IoAllocateErrorLogEntry(
 580   IN PVOID  IoObject,
 581   IN UCHAR  EntrySize);
 582
 583 NTKERNELAPI
 584 PIRP
 585 NTAPI
 586 IoAllocateIrp(
 587   IN CCHAR  StackSize,
 588   IN BOOLEAN  ChargeQuota);
 589
 590 NTKERNELAPI
 591 PMDL
 592 NTAPI
 593 IoAllocateMdl(
 594   IN PVOID  VirtualAddress OPTIONAL,
 595   IN ULONG  Length,
 596   IN BOOLEAN  SecondaryBuffer,
 597   IN BOOLEAN  ChargeQuota,
 598   IN OUT PIRP  Irp  OPTIONAL);
 599
 600 NTKERNELAPI
 601 PIO_WORKITEM
 602 NTAPI
 603 IoAllocateWorkItem(
 604   IN PDEVICE_OBJECT  DeviceObject);
 605
 606 NTKERNELAPI
 607 NTSTATUS
 608 NTAPI
 609 IoAttachDevice(
 610   IN PDEVICE_OBJECT  SourceDevice,
 611   IN PUNICODE_STRING  TargetDevice,
 612   OUT PDEVICE_OBJECT  *AttachedDevice);
 613
 614 NTKERNELAPI
 615 PDEVICE_OBJECT
 616 NTAPI
 617 IoAttachDeviceToDeviceStack(
 618   IN PDEVICE_OBJECT  SourceDevice,
 619   IN PDEVICE_OBJECT  TargetDevice);
 620
 621 NTKERNELAPI
 622 PIRP
 623 NTAPI
 624 IoBuildAsynchronousFsdRequest(
 625   IN ULONG  MajorFunction,
 626   IN PDEVICE_OBJECT  DeviceObject,
 627   IN OUT PVOID  Buffer  OPTIONAL,
 628   IN ULONG  Length  OPTIONAL,
 629   IN PLARGE_INTEGER  StartingOffset  OPTIONAL,
 630   IN PIO_STATUS_BLOCK  IoStatusBlock  OPTIONAL);
 631
 632 NTKERNELAPI
 633 PIRP
 634 NTAPI
 635 IoBuildDeviceIoControlRequest(
 636   IN ULONG  IoControlCode,
 637   IN PDEVICE_OBJECT  DeviceObject,
 638   IN PVOID  InputBuffer  OPTIONAL,
 639   IN ULONG  InputBufferLength,
 640   OUT PVOID  OutputBuffer  OPTIONAL,
 641   IN ULONG  OutputBufferLength,
 642   IN BOOLEAN  InternalDeviceIoControl,
 643   IN PKEVENT  Event,
 644   OUT PIO_STATUS_BLOCK  IoStatusBlock);
 645
 646 NTKERNELAPI
 647 VOID
 648 NTAPI
 649 IoBuildPartialMdl(
 650   IN PMDL  SourceMdl,
 651   IN OUT PMDL  TargetMdl,
 652   IN PVOID  VirtualAddress,
 653   IN ULONG  Length);
 654
 655 NTKERNELAPI
 656 PIRP
 657 NTAPI
 658 IoBuildSynchronousFsdRequest(
 659   IN ULONG  MajorFunction,
 660   IN PDEVICE_OBJECT  DeviceObject,
 661   IN OUT PVOID  Buffer  OPTIONAL,
 662   IN ULONG  Length  OPTIONAL,
 663   IN PLARGE_INTEGER  StartingOffset  OPTIONAL,
 664   IN PKEVENT  Event,
 665   OUT PIO_STATUS_BLOCK  IoStatusBlock);
 666
 667 NTKERNELAPI
 668 NTSTATUS
 669 FASTCALL
 670 IofCallDriver(
 671   IN PDEVICE_OBJECT  DeviceObject,
 672   IN OUT PIRP  Irp);
 673 #define IoCallDriver IofCallDriver
 674
 675 NTKERNELAPI
 676 VOID
 677 FASTCALL
 678 IofCompleteRequest(
 679   IN PIRP Irp,
 680   IN CCHAR PriorityBoost);
 681 #define IoCompleteRequest IofCompleteRequest
 682
 683 NTKERNELAPI
 684 BOOLEAN
 685 NTAPI
 686 IoCancelIrp(
 687   IN PIRP  Irp);
 688
 689 NTKERNELAPI
 690 NTSTATUS
 691 NTAPI
 692 IoCheckShareAccess(
 693   IN ACCESS_MASK  DesiredAccess,
 694   IN ULONG  DesiredShareAccess,
 695   IN OUT PFILE_OBJECT  FileObject,
 696   IN OUT PSHARE_ACCESS  ShareAccess,
 697   IN BOOLEAN  Update);
 698
 699 NTKERNELAPI
 700 VOID
 701 FASTCALL
 702 IofCompleteRequest(
 703   IN PIRP  Irp,
 704   IN CCHAR  PriorityBoost);
 705
 706 NTKERNELAPI
 707 NTSTATUS
 708 NTAPI
 709 IoConnectInterrupt(
 710   OUT PKINTERRUPT  *InterruptObject,
 711   IN PKSERVICE_ROUTINE  ServiceRoutine,
 712   IN PVOID  ServiceContext OPTIONAL,
 713   IN PKSPIN_LOCK  SpinLock  OPTIONAL,
 714   IN ULONG  Vector,
 715   IN KIRQL  Irql,
 716   IN KIRQL  SynchronizeIrql,
 717   IN KINTERRUPT_MODE    InterruptMode,
 718   IN BOOLEAN  ShareVector,
 719   IN KAFFINITY  ProcessorEnableMask,
 720   IN BOOLEAN  FloatingSave);
 721
 722 NTKERNELAPI
 723 NTSTATUS
 724 NTAPI
 725 IoCreateDevice(
 726   IN PDRIVER_OBJECT  DriverObject,
 727   IN ULONG  DeviceExtensionSize,
 728   IN PUNICODE_STRING  DeviceName  OPTIONAL,
 729   IN DEVICE_TYPE  DeviceType,
 730   IN ULONG  DeviceCharacteristics,
 731   IN BOOLEAN  Exclusive,
 732   OUT PDEVICE_OBJECT  *DeviceObject);
 733
 734 NTKERNELAPI
 735 NTSTATUS
 736 NTAPI
 737 IoCreateFile(
 738   OUT PHANDLE FileHandle,
 739   IN ACCESS_MASK DesiredAccess,
 740   IN POBJECT_ATTRIBUTES ObjectAttributes,
 741   OUT PIO_STATUS_BLOCK IoStatusBlock,
 742   IN PLARGE_INTEGER AllocationSize OPTIONAL,
 743   IN ULONG FileAttributes,
 744   IN ULONG ShareAccess,
 745   IN ULONG Disposition,
 746   IN ULONG CreateOptions,
 747   IN PVOID EaBuffer OPTIONAL,
 748   IN ULONG EaLength,
 749   IN CREATE_FILE_TYPE CreateFileType,
 750   IN PVOID InternalParameters OPTIONAL,
 751   IN ULONG Options);
 752
 753 NTKERNELAPI
 754 PKEVENT
 755 NTAPI
 756 IoCreateNotificationEvent(
 757   IN PUNICODE_STRING  EventName,
 758   OUT PHANDLE  EventHandle);
 759
 760 NTKERNELAPI
 761 NTSTATUS
 762 NTAPI
 763 IoCreateSymbolicLink(
 764   IN PUNICODE_STRING  SymbolicLinkName,
 765   IN PUNICODE_STRING  DeviceName);
 766
 767 NTKERNELAPI
 768 PKEVENT
 769 NTAPI
 770 IoCreateSynchronizationEvent(
 771   IN PUNICODE_STRING  EventName,
 772   OUT PHANDLE  EventHandle);
 773
 774 NTKERNELAPI
 775 NTSTATUS
 776 NTAPI
 777 IoCreateUnprotectedSymbolicLink(
 778   IN PUNICODE_STRING  SymbolicLinkName,
 779   IN PUNICODE_STRING  DeviceName);
 780
 781 NTKERNELAPI
 782 VOID
 783 NTAPI
 784 IoDeleteDevice(
 785   IN PDEVICE_OBJECT  DeviceObject);
 786
 787 NTKERNELAPI
 788 NTSTATUS
 789 NTAPI
 790 IoDeleteSymbolicLink(
 791   IN PUNICODE_STRING  SymbolicLinkName);
 792
 793 NTKERNELAPI
 794 VOID
 795 NTAPI
 796 IoDetachDevice(
 797   IN OUT PDEVICE_OBJECT  TargetDevice);
 798
 799 NTKERNELAPI
 800 VOID
 801 NTAPI
 802 IoDisconnectInterrupt(
 803   IN PKINTERRUPT  InterruptObject);
 804
 805 NTKERNELAPI
 806 VOID
 807 NTAPI
 808 IoFreeIrp(
 809   IN PIRP Irp);
 810
 811 NTKERNELAPI
 812 VOID
 813 NTAPI
 814 IoFreeMdl(
 815   IN PMDL Mdl);
 816
 817 NTKERNELAPI
 818 VOID
 819 NTAPI
 820 IoFreeWorkItem(
 821   IN PIO_WORKITEM IoWorkItem);
 822
 823 NTKERNELAPI
 824 PDEVICE_OBJECT
 825 NTAPI
 826 IoGetAttachedDevice(
 827   IN PDEVICE_OBJECT DeviceObject);
 828
 829 NTKERNELAPI
 830 PDEVICE_OBJECT
 831 NTAPI
 832 IoGetAttachedDeviceReference(
 833   IN PDEVICE_OBJECT  DeviceObject);
 834
 835 NTKERNELAPI
 836 NTSTATUS
 837 NTAPI
 838 IoGetBootDiskInformation(
 839   IN OUT PBOOTDISK_INFORMATION  BootDiskInformation,
 840   IN ULONG  Size);
 841
 842 NTKERNELAPI
 843 NTSTATUS
 844 NTAPI
 845 IoGetDeviceInterfaceAlias(
 846   IN PUNICODE_STRING  SymbolicLinkName,
 847   IN CONST GUID  *AliasInterfaceClassGuid,
 848   OUT PUNICODE_STRING  AliasSymbolicLinkName);
 849
 850 NTKERNELAPI
 851 PEPROCESS
 852 NTAPI
 853 IoGetCurrentProcess(
 854   VOID);
 855
 856 NTKERNELAPI
 857 NTSTATUS
 858 NTAPI
 859 IoGetDeviceInterfaces(
 860   IN CONST GUID  *InterfaceClassGuid,
 861   IN PDEVICE_OBJECT  PhysicalDeviceObject  OPTIONAL,
 862   IN ULONG  Flags,
 863   OUT PWSTR  *SymbolicLinkList);
 864
 865 NTKERNELAPI
 866 NTSTATUS
 867 NTAPI
 868 IoGetDeviceObjectPointer(
 869   IN PUNICODE_STRING  ObjectName,
 870   IN ACCESS_MASK  DesiredAccess,
 871   OUT PFILE_OBJECT  *FileObject,
 872   OUT PDEVICE_OBJECT  *DeviceObject);
 873
 874 NTKERNELAPI
 875 NTSTATUS
 876 NTAPI
 877 IoGetDeviceProperty(
 878   IN PDEVICE_OBJECT  DeviceObject,
 879   IN DEVICE_REGISTRY_PROPERTY  DeviceProperty,
 880   IN ULONG  BufferLength,
 881   OUT PVOID  PropertyBuffer,
 882   OUT PULONG  ResultLength);
 883
 884 NTKERNELAPI
 885 PDMA_ADAPTER
 886 NTAPI
 887 IoGetDmaAdapter(
 888   IN PDEVICE_OBJECT  PhysicalDeviceObject OPTIONAL,
 889   IN PDEVICE_DESCRIPTION  DeviceDescription,
 890   IN OUT PULONG  NumberOfMapRegisters);
 891
 892 NTKERNELAPI
 893 PVOID
 894 NTAPI
 895 IoGetDriverObjectExtension(
 896   IN PDRIVER_OBJECT  DriverObject,
 897   IN PVOID  ClientIdentificationAddress);
 898
 899 NTKERNELAPI
 900 PVOID
 901 NTAPI
 902 IoGetInitialStack(
 903   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
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
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
1469 NTKERNELAPI
1470 BOOLEAN
1471 IoIs32bitProcess(
1472   IN PIRP  Irp  OPTIONAL);
1473
1474 #endif
1475
1476 #define PLUGPLAY_REGKEY_DEVICE                            1
1477 #define PLUGPLAY_REGKEY_DRIVER                            2
1478 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE                 4
1479
1480 FORCEINLINE
1481 PIO_STACK_LOCATION
1482 IoGetCurrentIrpStackLocation(
1483   IN PIRP Irp)
1484 {
1485   ASSERT(Irp->CurrentLocation <= Irp->StackCount + 1);
1486   return Irp->Tail.Overlay.CurrentStackLocation;
1487 }
1488
1489 FORCEINLINE
1490 VOID
1491 IoMarkIrpPending(
1492   IN OUT PIRP Irp)
1493 {
1494   IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED;
1495 }
1496
1497 /*
1498  * BOOLEAN
1499  * IoIsErrorUserInduced(
1500  *   IN NTSTATUS  Status);
1501  */
1502 #define IoIsErrorUserInduced(Status) \
1503    ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \
1504    ((Status) == STATUS_IO_TIMEOUT) || \
1505    ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \
1506    ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \
1507    ((Status) == STATUS_VERIFY_REQUIRED) || \
1508    ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \
1509    ((Status) == STATUS_WRONG_VOLUME)))
1510
1511 /* VOID
1512  * IoInitializeRemoveLock(
1513  *   IN PIO_REMOVE_LOCK  Lock,
1514  *   IN ULONG  AllocateTag,
1515  *   IN ULONG  MaxLockedMinutes,
1516  *   IN ULONG  HighWatermark)
1517  */
1518 #define IoInitializeRemoveLock( \
1519   Lock, AllocateTag, MaxLockedMinutes, HighWatermark) \
1520   IoInitializeRemoveLockEx(Lock, AllocateTag, MaxLockedMinutes, \
1521     HighWatermark, sizeof(IO_REMOVE_LOCK))
1522
1523 VOID
1524 FORCEINLINE
1525 IoInitializeDpcRequest(
1526   IN PDEVICE_OBJECT DeviceObject,
1527   IN PIO_DPC_ROUTINE DpcRoutine)
1528 {
1529   KeInitializeDpc( &DeviceObject->Dpc,
1530                    (PKDEFERRED_ROUTINE) DpcRoutine,
1531                    DeviceObject );
1532 }
1533
1534 #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001
1535
1536 /*
1537  * ULONG
1538  * IoGetFunctionCodeFromCtlCode(
1539  *   IN ULONG  ControlCode)
1540  */
1541 #define IoGetFunctionCodeFromCtlCode(_ControlCode) \
1542   (((_ControlCode) >> 2) & 0x00000FFF)
1543
1544 FORCEINLINE
1545 VOID
1546 IoCopyCurrentIrpStackLocationToNext(
1547   IN PIRP Irp)
1548 {
1549   PIO_STACK_LOCATION irpSp;
1550   PIO_STACK_LOCATION nextIrpSp;
1551   irpSp = IoGetCurrentIrpStackLocation(Irp);
1552   nextIrpSp = IoGetNextIrpStackLocation(Irp);
1553   RtlCopyMemory( nextIrpSp, irpSp, FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine));
1554   nextIrpSp->Control = 0;
1555 }
1556
1557 NTKERNELAPI
1558 VOID
1559 NTAPI
1560 IoGetStackLimits(
1561   OUT PULONG_PTR  LowLimit,
1562   OUT PULONG_PTR  HighLimit);
1563
1564 FORCEINLINE
1565 ULONG_PTR
1566 IoGetRemainingStackSize(
1567   VOID)
1568 {
1569   ULONG_PTR End, Begin;
1570   ULONG_PTR Result;
1571
1572   IoGetStackLimits(&Begin, &End);
1573   Result = (ULONG_PTR)(&End) - Begin;
1574   return Result;
1575 }
1576