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 OUT PVOID WnodeEventItem);
1178
1179 NTKERNELAPI
1180 VOID
1181 NTAPI
1182 IoWriteErrorLogEntry(
1183   IN PVOID ElEntry);
1184
1185 NTKERNELAPI
1186 PIRP
1187 NTAPI
1188 IoGetTopLevelIrp(VOID);
1189
1190 NTKERNELAPI
1191 NTSTATUS
1192 NTAPI
1193 IoRegisterLastChanceShutdownNotification(
1194   IN PDEVICE_OBJECT DeviceObject);
1195
1196 NTKERNELAPI
1197 VOID
1198 NTAPI
1199 IoSetTopLevelIrp(
1200   IN PIRP Irp OPTIONAL);
1201
1202 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
1203
1204 #if (NTDDI_VERSION >= NTDDI_WINXP)
1205
1206 NTKERNELAPI
1207 NTSTATUS
1208 NTAPI
1209 IoCsqInitialize(
1210   IN PIO_CSQ Csq,
1211   IN PIO_CSQ_INSERT_IRP CsqInsertIrp,
1212   IN PIO_CSQ_REMOVE_IRP CsqRemoveIrp,
1213   IN PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp,
1214   IN PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock,
1215   IN PIO_CSQ_RELEASE_LOCK CsqReleaseLock,
1216   IN PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp);
1217
1218 NTKERNELAPI
1219 VOID
1220 NTAPI
1221 IoCsqInsertIrp(
1222   IN PIO_CSQ Csq,
1223   IN PIRP Irp,
1224   IN PIO_CSQ_IRP_CONTEXT Context OPTIONAL);
1225
1226 NTKERNELAPI
1227 PIRP
1228 NTAPI
1229 IoCsqRemoveIrp(
1230   IN PIO_CSQ Csq,
1231   IN PIO_CSQ_IRP_CONTEXT Context);
1232
1233 NTKERNELAPI
1234 PIRP
1235 NTAPI
1236 IoCsqRemoveNextIrp(
1237   IN PIO_CSQ Csq,
1238   IN PVOID PeekContext OPTIONAL);
1239
1240 NTKERNELAPI
1241 BOOLEAN
1242 NTAPI
1243 IoForwardIrpSynchronously(
1244   IN PDEVICE_OBJECT DeviceObject,
1245   IN PIRP Irp);
1246
1247 #define IoForwardAndCatchIrp IoForwardIrpSynchronously
1248
1249 NTKERNELAPI
1250 VOID
1251 NTAPI
1252 IoFreeErrorLogEntry(
1253   PVOID ElEntry);
1254
1255 NTKERNELAPI
1256 NTSTATUS
1257 NTAPI
1258 IoSetCompletionRoutineEx(
1259   IN PDEVICE_OBJECT DeviceObject,
1260   IN PIRP Irp,
1261   IN PIO_COMPLETION_ROUTINE CompletionRoutine,
1262   IN PVOID Context,
1263   IN BOOLEAN InvokeOnSuccess,
1264   IN BOOLEAN InvokeOnError,
1265   IN BOOLEAN InvokeOnCancel);
1266
1267 VOID
1268 NTAPI
1269 IoSetStartIoAttributes(
1270   IN PDEVICE_OBJECT DeviceObject,
1271   IN BOOLEAN DeferredStartIo,
1272   IN BOOLEAN NonCancelable);
1273
1274 NTKERNELAPI
1275 NTSTATUS
1276 NTAPI
1277 IoWMIDeviceObjectToInstanceName(
1278   IN PVOID DataBlockObject,
1279   IN PDEVICE_OBJECT DeviceObject,
1280   OUT PUNICODE_STRING InstanceName);
1281
1282 NTKERNELAPI
1283 NTSTATUS
1284 NTAPI
1285 IoWMIExecuteMethod(
1286   IN PVOID DataBlockObject,
1287   IN PUNICODE_STRING InstanceName,
1288   IN ULONG MethodId,
1289   IN ULONG InBufferSize,
1290   IN OUT PULONG OutBufferSize,
1291   IN OUT  PUCHAR InOutBuffer);
1292
1293 NTKERNELAPI
1294 NTSTATUS
1295 NTAPI
1296 IoWMIHandleToInstanceName(
1297   IN PVOID DataBlockObject,
1298   IN HANDLE FileHandle,
1299   OUT PUNICODE_STRING InstanceName);
1300
1301 NTKERNELAPI
1302 NTSTATUS
1303 NTAPI
1304 IoWMIOpenBlock(
1305   IN GUID *DataBlockGuid,
1306   IN ULONG DesiredAccess,
1307   OUT PVOID *DataBlockObject);
1308
1309 NTKERNELAPI
1310 NTSTATUS
1311 NTAPI
1312 IoWMIQueryAllData(
1313   IN PVOID DataBlockObject,
1314   IN OUT ULONG *InOutBufferSize,
1315   OUT PVOID OutBuffer);
1316
1317 NTKERNELAPI
1318 NTSTATUS
1319 NTAPI
1320 IoWMIQueryAllDataMultiple(
1321   IN PVOID *DataBlockObjectList,
1322   IN ULONG ObjectCount,
1323   IN OUT ULONG *InOutBufferSize,
1324   OUT PVOID OutBuffer);
1325
1326 NTKERNELAPI
1327 NTSTATUS
1328 NTAPI
1329 IoWMIQuerySingleInstance(
1330   IN PVOID DataBlockObject,
1331   IN PUNICODE_STRING InstanceName,
1332   IN OUT ULONG *InOutBufferSize,
1333   OUT PVOID OutBuffer);
1334
1335 NTKERNELAPI
1336 NTSTATUS
1337 NTAPI
1338 IoWMISetNotificationCallback(
1339   IN OUT PVOID Object,
1340   IN WMI_NOTIFICATION_CALLBACK Callback,
1341   IN PVOID Context OPTIONAL);
1342
1343 NTKERNELAPI
1344 NTSTATUS
1345 NTAPI
1346 IoWMISetSingleInstance(
1347   IN PVOID DataBlockObject,
1348   IN PUNICODE_STRING InstanceName,
1349   IN ULONG Version,
1350   IN ULONG ValueBufferSize,
1351   IN PVOID ValueBuffer);
1352
1353 NTKERNELAPI
1354 NTSTATUS
1355 NTAPI
1356 IoWMISetSingleItem(
1357   IN PVOID DataBlockObject,
1358   IN PUNICODE_STRING InstanceName,
1359   IN ULONG DataItemId,
1360   IN ULONG Version,
1361   IN ULONG ValueBufferSize,
1362   IN PVOID ValueBuffer);
1363
1364 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
1365
1366 #if (NTDDI_VERSION >= NTDDI_WINXPSP1)
1367 NTKERNELAPI
1368 NTSTATUS
1369 NTAPI
1370 IoValidateDeviceIoControlAccess(
1371   IN PIRP Irp,
1372   IN ULONG RequiredAccess);
1373 #endif
1374
1375 #if (NTDDI_VERSION >= NTDDI_WS03)
1376
1377 NTKERNELAPI
1378 NTSTATUS
1379 NTAPI
1380 IoCsqInitializeEx(
1381   IN PIO_CSQ Csq,
1382   IN PIO_CSQ_INSERT_IRP_EX CsqInsertIrp,
1383   IN PIO_CSQ_REMOVE_IRP CsqRemoveIrp,
1384   IN PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp,
1385   IN PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock,
1386   IN PIO_CSQ_RELEASE_LOCK CsqReleaseLock,
1387   IN PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp);
1388
1389 NTKERNELAPI
1390 NTSTATUS
1391 NTAPI
1392 IoCsqInsertIrpEx(
1393   IN PIO_CSQ Csq,
1394   IN PIRP Irp,
1395   IN PIO_CSQ_IRP_CONTEXT Context OPTIONAL,
1396   IN PVOID InsertContext OPTIONAL);
1397
1398 #endif
1399
1400 #if (NTDDI_VERSION >= NTDDI_VISTA)
1401
1402 NTKERNELAPI
1403 NTSTATUS
1404 NTAPI
1405 IoGetBootDiskInformationLite(
1406   OUT PBOOTDISK_INFORMATION_LITE *BootDiskInformation);
1407
1408 NTKERNELAPI
1409 NTSTATUS
1410 NTAPI
1411 IoCheckShareAccessEx(
1412   IN ACCESS_MASK DesiredAccess,
1413   IN ULONG DesiredShareAccess,
1414   IN OUT PFILE_OBJECT FileObject,
1415   IN OUT PSHARE_ACCESS ShareAccess,
1416   IN BOOLEAN Update,
1417   IN PBOOLEAN WritePermission);
1418
1419 NTKERNELAPI
1420 NTSTATUS
1421 NTAPI
1422 IoConnectInterruptEx(
1423   IN OUT PIO_CONNECT_INTERRUPT_PARAMETERS Parameters);
1424
1425 NTKERNELAPI
1426 VOID
1427 NTAPI
1428 IoDisconnectInterruptEx(
1429   IN PIO_DISCONNECT_INTERRUPT_PARAMETERS Parameters);
1430
1431 LOGICAL
1432 NTAPI
1433 IoWithinStackLimits(
1434   IN ULONG_PTR RegionStart,
1435   IN SIZE_T RegionSize);
1436
1437 NTKERNELAPI
1438 VOID
1439 NTAPI
1440 IoSetShareAccessEx(
1441   IN ACCESS_MASK DesiredAccess,
1442   IN ULONG DesiredShareAccess,
1443   IN OUT PFILE_OBJECT FileObject,
1444   OUT PSHARE_ACCESS ShareAccess,
1445   IN PBOOLEAN WritePermission);
1446
1447 ULONG
1448 NTAPI
1449 IoSizeofWorkItem(VOID);
1450
1451 VOID
1452 NTAPI
1453 IoInitializeWorkItem(
1454   IN PVOID IoObject,
1455   IN PIO_WORKITEM IoWorkItem);
1456
1457 VOID
1458 NTAPI
1459 IoUninitializeWorkItem(
1460   IN PIO_WORKITEM IoWorkItem);
1461
1462 VOID
1463 NTAPI
1464 IoQueueWorkItemEx(
1465   IN PIO_WORKITEM IoWorkItem,
1466   IN PIO_WORKITEM_ROUTINE_EX WorkerRoutine,
1467   IN WORK_QUEUE_TYPE QueueType,
1468   IN PVOID Context OPTIONAL);
1469
1470 IO_PRIORITY_HINT
1471 NTAPI
1472 IoGetIoPriorityHint(
1473   IN PIRP Irp);
1474
1475 NTSTATUS
1476 NTAPI
1477 IoSetIoPriorityHint(
1478   IN PIRP Irp,
1479   IN IO_PRIORITY_HINT PriorityHint);
1480
1481 NTSTATUS
1482 NTAPI
1483 IoAllocateSfioStreamIdentifier(
1484   IN PFILE_OBJECT FileObject,
1485   IN ULONG Length,
1486   IN PVOID Signature,
1487   OUT PVOID *StreamIdentifier);
1488
1489 PVOID
1490 NTAPI
1491 IoGetSfioStreamIdentifier(
1492   IN PFILE_OBJECT FileObject,
1493   IN PVOID Signature);
1494
1495 NTSTATUS
1496 NTAPI
1497 IoFreeSfioStreamIdentifier(
1498   IN PFILE_OBJECT FileObject,
1499   IN PVOID Signature);
1500
1501 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
1502
1503 #define IoCallDriverStackSafeDefault(a, b) IoCallDriver(a, b)
1504
1505 #if (NTDDI_VERSION >= NTDDI_WIN7)
1506
1507 NTKERNELAPI
1508 NTSTATUS
1509 NTAPI
1510 IoGetAffinityInterrupt(
1511   IN PKINTERRUPT InterruptObject,
1512   OUT PGROUP_AFFINITY GroupAffinity);
1513
1514 NTSTATUS
1515 NTAPI
1516 IoGetContainerInformation(
1517   IN IO_CONTAINER_INFORMATION_CLASS InformationClass,
1518   IN PVOID ContainerObject OPTIONAL,
1519   IN OUT PVOID Buffer OPTIONAL,
1520   IN ULONG BufferLength);
1521
1522 NTSTATUS
1523 NTAPI
1524 IoRegisterContainerNotification(
1525   IN IO_CONTAINER_NOTIFICATION_CLASS NotificationClass,
1526   IN PIO_CONTAINER_NOTIFICATION_FUNCTION CallbackFunction,
1527   IN PVOID NotificationInformation OPTIONAL,
1528   IN ULONG NotificationInformationLength,
1529   OUT PVOID CallbackRegistration);
1530
1531 VOID
1532 NTAPI
1533 IoUnregisterContainerNotification(
1534   IN PVOID CallbackRegistration);
1535
1536 #endif
1537
1538 #if defined(_WIN64)
1539 NTKERNELAPI
1540 ULONG
1541 NTAPI
1542 IoWMIDeviceObjectToProviderId(
1543   IN PDEVICE_OBJECT DeviceObject);
1544 #else
1545 #define IoWMIDeviceObjectToProviderId(DeviceObject) ((ULONG)(DeviceObject))
1546 #endif
1547
1548 /*
1549  * USHORT
1550  * IoSizeOfIrp(
1551  *   IN CCHAR  StackSize)
1552  */
1553 #define IoSizeOfIrp(_StackSize) \
1554   ((USHORT) (sizeof(IRP) + ((_StackSize) * (sizeof(IO_STACK_LOCATION)))))
1555
1556 FORCEINLINE
1557 VOID
1558 IoSkipCurrentIrpStackLocation(
1559   IN OUT PIRP Irp)
1560 {
1561   ASSERT(Irp->CurrentLocation <= Irp->StackCount);
1562   Irp->CurrentLocation++;
1563   Irp->Tail.Overlay.CurrentStackLocation++;
1564 }
1565
1566 FORCEINLINE
1567 VOID
1568 IoSetNextIrpStackLocation(
1569   IN OUT PIRP Irp)
1570 {
1571   ASSERT(Irp->CurrentLocation > 0);
1572   Irp->CurrentLocation--;
1573   Irp->Tail.Overlay.CurrentStackLocation--;
1574 }
1575
1576 FORCEINLINE
1577 PIO_STACK_LOCATION
1578 IoGetNextIrpStackLocation(
1579   IN PIRP Irp)
1580 {
1581   ASSERT(Irp->CurrentLocation > 0);
1582   return ((Irp)->Tail.Overlay.CurrentStackLocation - 1 );
1583 }
1584
1585 FORCEINLINE
1586 VOID
1587 IoSetCompletionRoutine(
1588   IN PIRP Irp,
1589   IN PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
1590   IN PVOID Context OPTIONAL,
1591   IN BOOLEAN InvokeOnSuccess,
1592   IN BOOLEAN InvokeOnError,
1593   IN BOOLEAN InvokeOnCancel)
1594 {
1595   PIO_STACK_LOCATION irpSp;
1596   ASSERT( (InvokeOnSuccess || InvokeOnError || InvokeOnCancel) ? (CompletionRoutine != NULL) : TRUE );
1597   irpSp = IoGetNextIrpStackLocation(Irp);
1598   irpSp->CompletionRoutine = CompletionRoutine;
1599   irpSp->Context = Context;
1600   irpSp->Control = 0;
1601
1602   if (InvokeOnSuccess) {
1603     irpSp->Control = SL_INVOKE_ON_SUCCESS;
1604   }
1605
1606   if (InvokeOnError) {
1607     irpSp->Control |= SL_INVOKE_ON_ERROR;
1608   }
1609
1610   if (InvokeOnCancel) {
1611     irpSp->Control |= SL_INVOKE_ON_CANCEL;
1612   }
1613 }
1614
1615 /*
1616  * PDRIVER_CANCEL
1617  * IoSetCancelRoutine(
1618  *   IN PIRP  Irp,
1619  *   IN PDRIVER_CANCEL  CancelRoutine)
1620  */
1621 #define IoSetCancelRoutine(_Irp, \
1622                            _CancelRoutine) \
1623   ((PDRIVER_CANCEL) (ULONG_PTR) InterlockedExchangePointer( \
1624     (PVOID *) &(_Irp)->CancelRoutine, (PVOID) (ULONG_PTR) (_CancelRoutine)))
1625
1626 /*
1627  * VOID
1628  * IoRequestDpc(
1629  *   IN PDEVICE_OBJECT  DeviceObject,
1630  *   IN PIRP  Irp,
1631  *   IN PVOID  Context);
1632  */
1633 #define IoRequestDpc(DeviceObject, Irp, Context)( \
1634   KeInsertQueueDpc(&(DeviceObject)->Dpc, (Irp), (Context)))
1635
1636 /*
1637  * VOID
1638  * IoReleaseRemoveLock(
1639  *   IN PIO_REMOVE_LOCK  RemoveLock,
1640  *   IN PVOID  Tag)
1641  */
1642 #define IoReleaseRemoveLock(_RemoveLock, \
1643                             _Tag) \
1644   IoReleaseRemoveLockEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
1645
1646 /*
1647  * VOID
1648  * IoReleaseRemoveLockAndWait(
1649  *   IN PIO_REMOVE_LOCK  RemoveLock,
1650  *   IN PVOID  Tag)
1651  */
1652 #define IoReleaseRemoveLockAndWait(_RemoveLock, \
1653                                    _Tag) \
1654   IoReleaseRemoveLockAndWaitEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK))
1655
1656 #if defined(_WIN64)
1657 NTKERNELAPI
1658 BOOLEAN
1659 IoIs32bitProcess(
1660   IN PIRP Irp OPTIONAL);
1661 #endif
1662
1663 #define PLUGPLAY_REGKEY_DEVICE                            1
1664 #define PLUGPLAY_REGKEY_DRIVER                            2
1665 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE                 4
1666
1667 FORCEINLINE
1668 PIO_STACK_LOCATION
1669 IoGetCurrentIrpStackLocation(
1670   IN PIRP Irp)
1671 {
1672   ASSERT(Irp->CurrentLocation <= Irp->StackCount + 1);
1673   return Irp->Tail.Overlay.CurrentStackLocation;
1674 }
1675
1676 FORCEINLINE
1677 VOID
1678 IoMarkIrpPending(
1679   IN OUT PIRP Irp)
1680 {
1681   IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED;
1682 }
1683
1684 /*
1685  * BOOLEAN
1686  * IoIsErrorUserInduced(
1687  *   IN NTSTATUS  Status);
1688  */
1689 #define IoIsErrorUserInduced(Status) \
1690    ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \
1691    ((Status) == STATUS_IO_TIMEOUT) || \
1692    ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \
1693    ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \
1694    ((Status) == STATUS_VERIFY_REQUIRED) || \
1695    ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \
1696    ((Status) == STATUS_WRONG_VOLUME)))
1697
1698 /* VOID
1699  * IoInitializeRemoveLock(
1700  *   IN PIO_REMOVE_LOCK  Lock,
1701  *   IN ULONG  AllocateTag,
1702  *   IN ULONG  MaxLockedMinutes,
1703  *   IN ULONG  HighWatermark)
1704  */
1705 #define IoInitializeRemoveLock( \
1706   Lock, AllocateTag, MaxLockedMinutes, HighWatermark) \
1707   IoInitializeRemoveLockEx(Lock, AllocateTag, MaxLockedMinutes, \
1708     HighWatermark, sizeof(IO_REMOVE_LOCK))
1709
1710 VOID
1711 FORCEINLINE
1712 IoInitializeDpcRequest(
1713   IN PDEVICE_OBJECT DeviceObject,
1714   IN PIO_DPC_ROUTINE DpcRoutine)
1715 {
1716   KeInitializeDpc( &DeviceObject->Dpc,
1717                    (PKDEFERRED_ROUTINE) DpcRoutine,
1718                    DeviceObject );
1719 }
1720
1721 #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001
1722
1723 /*
1724  * ULONG
1725  * IoGetFunctionCodeFromCtlCode(
1726  *   IN ULONG  ControlCode)
1727  */
1728 #define IoGetFunctionCodeFromCtlCode(_ControlCode) \
1729   (((_ControlCode) >> 2) & 0x00000FFF)
1730
1731 FORCEINLINE
1732 VOID
1733 IoCopyCurrentIrpStackLocationToNext(
1734   IN OUT PIRP Irp)
1735 {
1736   PIO_STACK_LOCATION irpSp;
1737   PIO_STACK_LOCATION nextIrpSp;
1738   irpSp = IoGetCurrentIrpStackLocation(Irp);
1739   nextIrpSp = IoGetNextIrpStackLocation(Irp);
1740   RtlCopyMemory( nextIrpSp, irpSp, FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine));
1741   nextIrpSp->Control = 0;
1742 }
1743
1744 NTKERNELAPI
1745 VOID
1746 NTAPI
1747 IoGetStackLimits(
1748   OUT PULONG_PTR LowLimit,
1749   OUT PULONG_PTR HighLimit);
1750
1751 FORCEINLINE
1752 ULONG_PTR
1753 IoGetRemainingStackSize(VOID)
1754 {
1755   ULONG_PTR End, Begin;
1756   ULONG_PTR Result;
1757
1758   IoGetStackLimits(&Begin, &End);
1759   Result = (ULONG_PTR)(&End) - Begin;
1760   return Result;
1761 }
1762
1763 #if (NTDDI_VERSION >= NTDDI_WS03)
1764 VOID
1765 FORCEINLINE
1766 IoInitializeThreadedDpcRequest(
1767   IN PDEVICE_OBJECT DeviceObject,
1768   IN PIO_DPC_ROUTINE DpcRoutine)
1769 {
1770   KeInitializeThreadedDpc(&DeviceObject->Dpc,
1771                           (PKDEFERRED_ROUTINE) DpcRoutine,
1772                           DeviceObject );
1773 }
1774 #endif
1775