reactos/include/ddk/iofuncs.h

   1 /* $Id: iofuncs.h,v 1.6 2000/03/05 19:17:37 ea Exp $ */
   2 /* IO MANAGER ***************************************************************/
   3
   4 BOOLEAN
   5 IoRaiseInformationalHardError (
   6         NTSTATUS        ErrorStatus,
   7         PUNICODE_STRING String,
   8         PKTHREAD        Thread
   9         );
  10
  11
  12 /*
  13  * FUNCTION: Registers the driver with WMI
  14  * ARGUMENTS:
  15  *          DeviceObject = Device to register
  16  *          Action = Action to take
  17  * RETURNS: Status (?)
  18  */
  19 //NTSTATUS IoWMIRegistrationControl(DeviceObject, WMIREGACTION Action);
  20
  21 /*
  22  * FUNCTION: Synchronizes cancelable-state transistions for IRPs in a
  23  * multiprocessor-safe way
  24  * ARGUMENTS:
  25  *          Irpl = Variable to store the current IRQ level
  26  */
  27 VOID
  28 IoAcquireCancelSpinLock (
  29         PKIRQL  Irpl
  30         );
  31
  32 typedef
  33 IO_ALLOCATION_ACTION
  34 (*PDRIVER_CONTROL) (
  35         PDEVICE_OBJECT  DeviceObject,
  36         PIRP            irp,
  37         PVOID           MapRegisterBase,
  38         PVOID           Context
  39         );
  40
  41 /*
  42  * FUNCTION: Allocates an adaptor object for a DMA operation on the target
  43  * device
  44  * ARGUMENTS:
  45  *         Adaptor = Adapter channel or busmaster adapter to be allocated
  46  *         DeviceObject = Target device for DMA
  47  *         NumberOfMapRegisters = Number of map registers
  48  *         ExecutionRoutine = Routine to be called when the adaptor is
  49  *                            available
  50  *         Context = driver defined contex that will be passed to the
  51  *                   execution routine
  52  * RETURNS: Success or failure code
  53  */
  54 NTSTATUS
  55 IoAllocateAdapterChannel (
  56         PADAPTER_OBJECT AdaperObject,
  57         PDEVICE_OBJECT  DeviceObject,
  58         ULONG           NumberOfMapRegisters,
  59         PDRIVER_CONTROL ExecutionRoutine,
  60         PVOID           Context
  61         );
  62
  63 /*
  64  * FUNCTION: Sets up a call to a driver supplied controller object as
  65  * soon as it is available
  66  * ARGUMENTS:
  67  *        ControllerObject = Driver created controller object
  68  *        DeviceObject = target device
  69  *        ExecutionObject = Routine to be called
  70  *        Context = Driver determined context to be based to the routine
  71  */
  72 VOID
  73 IoAllocateController (
  74         PCONTROLLER_OBJECT      ControllerObject,
  75         PDEVICE_OBJECT          DeviceObject,
  76         PDRIVER_CONTROL         ExecutionRoutine,
  77         PVOID                   Context
  78         );
  79
  80 /*
  81  * FUNCTION: Allocates an error log packet
  82  * ARGUMENTS:
  83  *         IoObject = Object which found the error
  84  *         EntrySize = Size in bytes of the packet to be allocated
  85  * RETURNS: On success a pointer to the allocated packet
  86  *          On failure returns NULL
  87  */
  88 PVOID
  89 IoAllocateErrorLogEntry (
  90         PVOID   IoObject,
  91         UCHAR   EntrySize
  92         );
  93
  94 /*
  95  * FUNCTION: Allocates an IRP
  96  * ARGUMENTS:
  97  *        StackSize = number of stack locations to allocate
  98  *        ChargeQuota = Who knows
  99  * RETURNS: On success the allocated IRP
 100  *          On failure NULL
 101  */
 102 PIRP
 103 IoAllocateIrp (
 104         CCHAR   StackSize,
 105         BOOLEAN ChargeQuota
 106         );
 107
 108 /*
 109  * FUNCTION: Allocates an MDL large enough to map the supplied buffer
 110  * ARGUMENTS:
 111  *        VirtualAddress = base virtual address of the buffer to be mapped
 112  *        Length = length of the buffer to be mapped
 113  *        SecondaryBuffer = Whether the buffer is primary or secondary
 114  *        ChargeQuota = Charge non-paged pool quota to current thread
 115  *        Irp = Optional irp to be associated with the MDL
 116  * RETURNS: On the success the allocated MDL
 117  *          On failure NULL
 118  */
 119 PMDL
 120 IoAllocateMdl (
 121         PVOID   VirtualAddress,
 122         ULONG   Length,
 123         BOOLEAN SecondaryBuffer,
 124         BOOLEAN ChargeQuota,
 125         PIRP    Irp
 126         );
 127
 128 /*
 129  * FUNCTION: Creates a symbolic link between the ARC name of a physical
 130  * device and the name of the corresponding device object
 131  * ARGUMENTS:
 132  *        ArcName = ARC name of the device
 133  *        DeviceName = Name of the device object
 134  */
 135 VOID
 136 IoAssignArcName (
 137         PUNICODE_STRING ArcName,
 138         PUNICODE_STRING DeviceName
 139         );
 140
 141 enum
 142 {
 143    IO_NO_INCREMENT,
 144 };
 145
 146 /*
 147  * FUNCTION: Takes a list of requested hardware resources and allocates them
 148  * ARGUMENTS:
 149  *        RegisterPath =
 150  *        DriverClassName =
 151  *        DriverObject = Driver object passed to the DriverEntry routine
 152  *        DeviceObject =
 153  *        RequestedResources = List of resources
 154  * RETURNS:
 155  */
 156 NTSTATUS
 157 IoAssignResources (
 158         PUNICODE_STRING                 RegistryPath,
 159         PUNICODE_STRING                 DriverClassName,
 160         PDRIVER_OBJECT                  DriverObject,
 161         PDEVICE_OBJECT                  DeviceObject,
 162         PIO_RESOURCE_REQUIREMENTS_LIST  RequestedResources,
 163         PCM_RESOURCE_LIST               * AllocatedResources
 164         );
 165
 166 /*
 167  * FUNCTION: Attaches the callers device object to a named target device
 168  * ARGUMENTS:
 169  *        SourceDevice = caller's device
 170  *        TargetDevice = Name of the target device
 171  *        AttachedDevice = Caller allocated storage. On return contains
 172  *                         a pointer to the target device
 173  * RETURNS: Success or failure code
 174  */
 175 NTSTATUS
 176 IoAttachDevice (
 177         PDEVICE_OBJECT  SourceDevice,
 178         PUNICODE_STRING TargetDevice,
 179         PDEVICE_OBJECT  * AttachedDevice
 180         );
 181
 182 /*
 183  * FUNCTION: Obsolete
 184  * ARGUMENTS:
 185  *       SourceDevice = device to attach
 186  *       TargetDevice = device to be attached to
 187  * RETURNS: Success or failure code
 188  */
 189 NTSTATUS
 190 IoAttachDeviceByPointer (
 191         PDEVICE_OBJECT  SourceDevice,
 192         PDEVICE_OBJECT  TargetDevice
 193         );
 194
 195 /*
 196  * FUNCTION: Attaches the callers device to the highest device in the chain
 197  * ARGUMENTS:
 198  *       SourceDevice = caller's device
 199  *       TargetDevice = Device to attach
 200  * RETURNS: On success the previously highest device
 201  *          On failure NULL
 202  */
 203 PDEVICE_OBJECT
 204 IoAttachDeviceToDeviceStack (
 205         PDEVICE_OBJECT  SourceDevice,
 206         PDEVICE_OBJECT  TargetDevice
 207         );
 208
 209 /*
 210  * FUNCTION: Builds a irp to be sent to lower level drivers
 211  * ARGUMENTS:
 212  *       MajorFunction = Major function code to be set in the IRP
 213  *       DeviceObject = Next lower device object
 214  *       Buffer = Buffer (only required for some major function codes)
 215  *       Length = Length in bytes of the buffer
 216  *       StartingOffset = Starting offset on the target device
 217  *       IoStatusBlock = Storage for status about the operation (optional)
 218  * RETURNS: On success the IRP allocated
 219  *          On failure NULL
 220  */
 221 PIRP
 222 IoBuildAsynchronousFsdRequest (
 223         ULONG                   MajorFunction,
 224         PDEVICE_OBJECT          DeviceObject,
 225         PVOID                   Buffer,
 226         ULONG                   Length,
 227         PLARGE_INTEGER          StartingOffset,
 228         PIO_STATUS_BLOCK        IoStatusBlock
 229         );
 230
 231 /*
 232  * FUNCTION: Allocates and sets up an IRP for a device control request
 233  * ARGUMENTS:
 234  *        IoControlCode = Type of request
 235  *        DeviceObject = Target device
 236  *        InputBuffer = Optional input buffer to the driver
 237  *        InputBufferLength = Length of the input buffer
 238  *        OutputBuffer = Optional output buffer
 239  *        OutputBufferLength = Length of the output buffer
 240  *        InternalDeviceIoControl = TRUE if the request is internal
 241  *        Event = Initialized event for the caller to wait for the request
 242  *                to be completed
 243  *        IoStatusBlock = I/O status block to be set when the request is
 244  *                        completed
 245  * RETURNS: Returns the IRP created
 246  */
 247 PIRP
 248 IoBuildDeviceIoControlRequest (
 249         ULONG                   IoControlCode,
 250         PDEVICE_OBJECT          DeviceObject,
 251         PVOID                   InputBuffer,
 252         ULONG                   InputBufferLength,
 253         PVOID                   OutputBuffer,
 254         ULONG                   OutputBufferLength,
 255         BOOLEAN                 InternalDeviceIoControl,
 256         PKEVENT                 Event,
 257         PIO_STATUS_BLOCK        IoStatusBlock
 258         );
 259
 260
 261 VOID
 262 IoBuildPartialMdl (
 263         PMDL    SourceMdl,
 264         PMDL    TargetMdl,
 265         PVOID   VirtualAddress,
 266         ULONG   Length
 267         );
 268
 269 PIRP
 270 IoBuildSynchronousFsdRequest (
 271         ULONG                   MajorFunction,
 272         PDEVICE_OBJECT          DeviceObject,
 273         PVOID                   Buffer,
 274         ULONG                   Length,
 275         PLARGE_INTEGER          StartingOffset,
 276         PKEVENT                 Event,
 277         PIO_STATUS_BLOCK        IoStatusBlock
 278         );
 279
 280 /*
 281  * FUNCTION: Sends an irp to the next lower driver
 282  */
 283 NTSTATUS
 284 IoCallDriver (
 285         PDEVICE_OBJECT  DeviceObject,
 286         PIRP            irp
 287         );
 288
 289 BOOLEAN
 290 IoCancelIrp (
 291         PIRP    Irp
 292         );
 293
 294 NTSTATUS
 295 IoCheckShareAccess (
 296         ACCESS_MASK     DesiredAccess,
 297         ULONG           DesiredShareAccess,
 298         PFILE_OBJECT    FileObject,
 299         PSHARE_ACCESS   ShareAccess,
 300         BOOLEAN         Update
 301         );
 302
 303 /*
 304  * FUNCTION: Indicates the caller has finished all processing for a given
 305  * I/O request and is returning the given IRP to the I/O manager
 306  * ARGUMENTS:
 307  *         Irp = Irp to be cancelled
 308  *         PriorityBoost = Increment by which to boost the priority of the
 309  *                         thread making the request
 310  */
 311 VOID
 312 IoCompleteRequest (
 313         PIRP    Irp,
 314         CCHAR   PriorityBoost
 315         );
 316
 317 NTSTATUS
 318 IoConnectInterrupt (
 319         PKINTERRUPT             * InterruptObject,
 320         PKSERVICE_ROUTINE       ServiceRoutine,
 321         PVOID                   ServiceContext,
 322         PKSPIN_LOCK             SpinLock,
 323         ULONG                   Vector,
 324         KIRQL                   Irql,
 325         KIRQL                   SynchronizeIrql,
 326         KINTERRUPT_MODE         InterruptMode,
 327         BOOLEAN                 ShareVector,
 328         KAFFINITY               ProcessorEnableMask,
 329         BOOLEAN                 FloatingSave
 330         );
 331
 332 PCONTROLLER_OBJECT
 333 IoCreateController (
 334         ULONG   Size
 335         );
 336
 337 /*
 338  * FUNCTION: Allocates memory for and intializes a device object for use for
 339  * a driver
 340  * ARGUMENTS:
 341  *         DriverObject : Driver object passed by iomgr when the driver was
 342  *                        loaded
 343  *         DeviceExtensionSize : Number of bytes for the device extension
 344  *         DeviceName : Unicode name of device
 345  *         DeviceType : Device type
 346  *         DeviceCharacteristics : Bit mask of device characteristics
 347  *         Exclusive : True if only one thread can access the device at a
 348  *                     time
 349  * RETURNS:
 350  *         Success or failure
 351  *         DeviceObject : Contains a pointer to allocated device object
 352  *                        if the call succeeded
 353  * NOTES: See the DDK documentation for more information
 354  */
 355 NTSTATUS
 356 IoCreateDevice (
 357         PDRIVER_OBJECT  DriverObject,
 358         ULONG           DeviceExtensionSize,
 359         PUNICODE_STRING DeviceName,
 360         DEVICE_TYPE     DeviceType,
 361         ULONG           DeviceCharacteristics,
 362         BOOLEAN         Exclusive,
 363         PDEVICE_OBJECT  * DeviceObject
 364         );
 365
 366 NTSTATUS
 367 STDCALL
 368 IoCreateFile (
 369         OUT     PHANDLE                 FileHandle,
 370         IN      ACCESS_MASK             DesiredAccess,
 371         IN      POBJECT_ATTRIBUTES      ObjectAttributes,
 372         OUT     PIO_STATUS_BLOCK        IoStatusBlock,
 373         IN      PLARGE_INTEGER          AllocationSize          OPTIONAL,
 374         IN      ULONG                   FileAttributes,
 375         IN      ULONG                   ShareAccess,
 376         IN      ULONG                   CreateDisposition,
 377         IN      ULONG                   CreateOptions,
 378         IN      PVOID                   EaBuffer                OPTIONAL,
 379         IN      ULONG                   EaLength,
 380         IN      CREATE_FILE_TYPE        CreateFileType,
 381         IN      ULONG                   ExtraCreateParameters,
 382         IN      ULONG                   Options
 383         );
 384 PKEVENT
 385 IoCreateNotificationEvent (
 386         PUNICODE_STRING EventName,
 387         PHANDLE EventHandle
 388         );
 389
 390 NTSTATUS
 391 STDCALL
 392 IoCreateSymbolicLink (
 393         PUNICODE_STRING SymbolicLinkName,
 394         PUNICODE_STRING DeviceName
 395         );
 396
 397 PKEVENT
 398 IoCreateSynchronizationEvent (
 399         PUNICODE_STRING EventName,
 400         PHANDLE EventHandle
 401         );
 402
 403 NTSTATUS
 404 STDCALL
 405 IoCreateUnprotectedSymbolicLink (
 406         PUNICODE_STRING SymbolicLinkName,
 407         PUNICODE_STRING DeviceName
 408         );
 409
 410
 411 VOID
 412 IoDeassignArcName (
 413         PUNICODE_STRING ArcName
 414         );
 415
 416 VOID
 417 IoDeleteController (
 418         PCONTROLLER_OBJECT      ControllerObject
 419         );
 420
 421 VOID
 422 IoDeleteDevice (
 423         PDEVICE_OBJECT  DeviceObject
 424         );
 425
 426 NTSTATUS
 427 STDCALL
 428 IoDeleteSymbolicLink (
 429         PUNICODE_STRING SymbolicLinkName
 430         );
 431
 432 VOID
 433 IoDetachDevice (
 434         PDEVICE_OBJECT  TargetDevice
 435         );
 436
 437 VOID
 438 IoDisconnectInterrupt (
 439         PKINTERRUPT     InterruptObject
 440         );
 441
 442 BOOLEAN
 443 IoFlushAdapterBuffers (
 444         PADAPTER_OBJECT AdapterObject,
 445         PMDL            Mdl,
 446         PVOID           MapRegisterBase,
 447         PVOID           CurrentVa,
 448         ULONG           Length,
 449         BOOLEAN         WriteToDevice
 450         );
 451
 452 VOID
 453 IoFreeAdapterChannel (
 454         PADAPTER_OBJECT AdapterObject
 455         );
 456
 457 VOID
 458 IoFreeController (
 459         PCONTROLLER_OBJECT      ControllerObject
 460         );
 461
 462 VOID
 463 IoFreeIrp (
 464         PIRP    Irp
 465         );
 466
 467 VOID
 468 IoFreeMapRegisters (
 469         PADAPTER_OBJECT AdapterObject,
 470         PVOID           MapRegisterBase,
 471         ULONG           NumberOfMapRegisters
 472         );
 473
 474 VOID
 475 IoFreeMdl (
 476         PMDL    Mdl
 477         );
 478 PDEVICE_OBJECT
 479 STDCALL
 480 IoGetBaseFileSystemDeviceObject (
 481         IN      PFILE_OBJECT    FileObject
 482         );
 483 PCONFIGURATION_INFORMATION
 484 IoGetConfigurationInformation (VOID);
 485
 486
 487 /*
 488  * FUNCTION: Returns a pointer to the callers stack location in the irp
 489  */
 490 PIO_STACK_LOCATION
 491 IoGetCurrentIrpStackLocation (
 492         IRP     * irp
 493         );
 494
 495 struct _EPROCESS *
 496 IoGetCurrentProcess (VOID);
 497
 498 NTSTATUS
 499 IoGetDeviceObjectPointer (
 500         PUNICODE_STRING ObjectName,
 501         ACCESS_MASK     DesiredAccess,
 502         PFILE_OBJECT    * FileObject,
 503         PDEVICE_OBJECT  * DeviceObject
 504         );
 505
 506 PDEVICE_OBJECT
 507 IoGetDeviceToVerify (
 508         PETHREAD        Thread
 509         );
 510
 511 PGENERIC_MAPPING
 512 IoGetFileObjectGenericMapping (VOID);
 513
 514 ULONG
 515 IoGetFunctionCodeFromCtlCode (
 516         ULONG   ControlCode
 517         );
 518
 519 PVOID
 520 IoGetInitialStack (VOID);
 521
 522 /*
 523  * FUNCTION:
 524  */
 525 PIO_STACK_LOCATION
 526 IoGetNextIrpStackLocation (
 527         IRP     * irp
 528         );
 529
 530 PDEVICE_OBJECT
 531 STDCALL
 532 IoGetRelatedDeviceObject (
 533         PFILE_OBJECT    FileObject
 534         );
 535
 536 VOID
 537 IoInitializeDpcRequest (
 538         PDEVICE_OBJECT  DeviceObject,
 539         PIO_DPC_ROUTINE DpcRoutine
 540         );
 541
 542 /*
 543  * FUNCTION: Initalizes an irp allocated by the caller
 544  * ARGUMENTS:
 545  *          Irp = IRP to initalize
 546  *          PacketSize = Size in bytes of the IRP
 547  *          StackSize = Number of stack locations in the IRP
 548  */
 549 VOID
 550 IoInitializeIrp (
 551         PIRP    Irp,
 552         USHORT  PacketSize,
 553         CCHAR   StackSize
 554         );
 555
 556 NTSTATUS
 557 IoInitializeTimer (
 558         PDEVICE_OBJECT          DeviceObject,
 559         PIO_TIMER_ROUTINE       TimerRoutine,
 560         PVOID                   Context
 561         );
 562
 563 BOOLEAN
 564 IoIsErrorUserInduced (
 565         NTSTATUS        Status
 566         );
 567
 568 BOOLEAN
 569 IoIsTotalDeviceFailure (
 570         NTSTATUS        Status
 571         );
 572
 573 PIRP
 574 IoMakeAssociatedIrp (
 575         PIRP    Irp,
 576         CCHAR   StackSize
 577         );
 578
 579 PHYSICAL_ADDRESS
 580 IoMapTransfer (
 581         PADAPTER_OBJECT AdapterObject,
 582         PMDL            Mdl,
 583         PVOID           MapRegisterBase,
 584         PVOID           CurrentVa,
 585         PULONG          Length,
 586         BOOLEAN         WriteToDevice
 587         );
 588
 589 /*
 590  * FUNCTION: Marks an IRP as pending
 591  * ARGUMENTS:
 592  *         Irp = Irp to mark
 593  * NOTE: If a driver doesn't complete the irp in its dispatch routine it
 594  * must mark it pending otherwise the I/O manager will complete it on
 595  * return from the dispatch routine.
 596  */
 597 VOID
 598 IoMarkIrpPending (
 599         PIRP    Irp
 600         );
 601
 602 NTSTATUS
 603 IoQueryDeviceDescription (
 604         PINTERFACE_TYPE                 BusType,
 605         PULONG                          BusNumber,
 606         PCONFIGURATION_TYPE             ControllerType,
 607         PULONG                          ControllerNumber,
 608         PCONFIGURATION_TYPE             PeripheralType,
 609         PULONG                          PeripheralNumber,
 610         PIO_QUERY_DEVICE_ROUTINE        CalloutRoutine,
 611         PVOID                           Context
 612         );
 613
 614 VOID
 615 IoRaiseHardError (
 616         PIRP            Irp,
 617         PVPB            Vpb,
 618         PDEVICE_OBJECT  RealDeviceObject
 619         );
 620
 621 BOOLEAN
 622 IoRaiseHardInformationalError (
 623         NTSTATUS        ErrorStatus,
 624         PUNICODE_STRING String,
 625         PKTHREAD        Thread
 626         );
 627
 628 NTSTATUS
 629 IoReadPartitionTable (
 630         PDEVICE_OBJECT                          DeviceObject,
 631         ULONG                                   SectorSize,
 632         BOOLEAN                                 ReturnedRecognizedPartitions,
 633         struct _DRIVE_LAYOUT_INFORMATION        ** PBuffer
 634         );
 635
 636 VOID
 637 IoRegisterDriverReinitialization (
 638         PDRIVER_OBJECT          DriverObject,
 639         PDRIVER_REINITIALIZE    ReinitRoutine,
 640         PVOID                   Context
 641         );
 642
 643 NTSTATUS
 644 IoRegisterShutdownNotification (
 645         PDEVICE_OBJECT  DeviceObject
 646         );
 647
 648 VOID
 649 IoReleaseCancelSpinLock (
 650         KIRQL   Irql
 651         );
 652
 653 VOID
 654 IoRemoveShareAccess (
 655         PFILE_OBJECT    FileObject,
 656         PSHARE_ACCESS   ShareAccess
 657         );
 658
 659 NTSTATUS
 660 IoReportResourceUsage (
 661         PUNICODE_STRING         DriverClassName,
 662         PDRIVER_OBJECT          DriverObject,
 663         PCM_RESOURCE_LIST       DriverList,
 664         ULONG                   DriverListSize,
 665         PDEVICE_OBJECT          DeviceObject,
 666         PCM_RESOURCE_LIST       DeviceList,
 667         ULONG                   DeviceListSize,
 668         BOOLEAN                 OverrideConflict,
 669         PBOOLEAN                ConflictDetected
 670         );
 671
 672 VOID
 673 IoRequestDpc (
 674         PDEVICE_OBJECT  DeviceObject,
 675         PIRP            Irp,
 676         PVOID           Context
 677         );
 678
 679 PDRIVER_CANCEL
 680 IoSetCancelRoutine (
 681         PIRP            Irp,
 682         PDRIVER_CANCEL  CancelRoutine
 683         );
 684
 685 VOID
 686 IoSetCompletionRoutine (
 687         PIRP                    Irp,
 688         PIO_COMPLETION_ROUTINE  CompletionRoutine,
 689         PVOID                   Context,
 690         BOOLEAN                 InvokeOnSuccess,
 691         BOOLEAN                 InvokeOnError,
 692         BOOLEAN                 InvokeOnCancel
 693         );
 694
 695 VOID
 696 IoSetHardErrorOrVerifyDevice (
 697         PIRP            Irp,
 698         PDEVICE_OBJECT  DeviceObject
 699         );
 700
 701 VOID
 702 IoSetNextIrpStackLocation (
 703         PIRP    Irp
 704         );
 705
 706 NTSTATUS
 707 IoSetPartitionInformation (
 708         PDEVICE_OBJECT  DeviceObject,
 709         ULONG           SectorSize,
 710         ULONG           PartitionNumber,
 711         ULONG           PartitionType
 712         );
 713
 714 VOID
 715 IoSetShareAccess (
 716         ACCESS_MASK     DesiredAccess,
 717         ULONG           DesiredShareAccess,
 718         PFILE_OBJECT    FileObject,
 719         PSHARE_ACCESS   ShareAccess
 720         );
 721
 722 /*
 723  * FUNCTION:  Determines the size of an IRP
 724  * ARGUMENTS:
 725  *           StackSize = number of stack locations in the IRP
 726  * RETURNS: The size of the IRP in bytes
 727  */
 728 USHORT
 729 IoSizeOfIrp (
 730         CCHAR   StackSize
 731         );
 732
 733 /*
 734  * FUNCTION: Dequeues the next IRP from the device's associated queue and
 735  * calls its StartIo routine
 736  * ARGUMENTS:
 737  *          DeviceObject = Device object
 738  *          Cancelable = True if IRPs in the queue can be cancelled
 739  */
 740 VOID
 741 IoStartNextPacket (
 742         PDEVICE_OBJECT  DeviceObject,
 743         BOOLEAN         Cancelable
 744         );
 745
 746 VOID
 747 IoStartNextPacketByKey (
 748         PDEVICE_OBJECT  DeviceObject,
 749         BOOLEAN         Cancelable,
 750         ULONG           Key
 751         );
 752
 753 /*
 754  * FUNCTION: Calls the drivers StartIO routine with the IRP or queues it if
 755  * the device is busy
 756  * ARGUMENTS:
 757  *         DeviceObject = Device to pass the IRP to
 758  *         Irp = Irp to be processed
 759  *         Key = Optional value for where to insert the IRP
 760  *         CancelFunction = Entry point for a driver supplied cancel function
 761  */
 762 VOID
 763 IoStartPacket (
 764         PDEVICE_OBJECT  DeviceObject,
 765         PIRP            Irp,
 766         PULONG          Key,
 767         PDRIVER_CANCEL  CancelFunction
 768         );
 769
 770 VOID
 771 IoStartTimer (
 772         PDEVICE_OBJECT  DeviceObject
 773         );
 774
 775 VOID
 776 IoStopTimer (
 777         PDEVICE_OBJECT  DeviceObject
 778         );
 779
 780 VOID
 781 IoUnregisterShutdownNotification (
 782         PDEVICE_OBJECT  DeviceObject
 783         );
 784
 785 VOID
 786 IoUpdateShareAccess (
 787         PFILE_OBJECT    FileObject,
 788         PSHARE_ACCESS   ShareAccess
 789         );
 790
 791 VOID
 792 IoWriteErrorLogEntry (
 793         PVOID   ElEntry
 794         );
 795
 796 NTSTATUS
 797 IoWritePartitionTable (
 798         PDEVICE_OBJECT  DeviceObject,
 799         ULONG SectorSize,
 800         ULONG SectorsPerTrack,
 801         ULONG NumberOfHeads,
 802         struct _DRIVE_LAYOUT_INFORMATION* PBuffer
 803         );
 804
 805
 806 // Preliminary guess
 807 NTKERNELAPI
 808 NTSTATUS
 809 IoQueryFileVolumeInformation (
 810         IN      PFILE_OBJECT            FileObject,
 811         IN      FS_INFORMATION_CLASS    FsInformationClass,
 812         IN      ULONG                   Length,
 813         OUT     PVOID                   FsInformation,
 814         OUT     PULONG                  ReturnedLength
 815         );
 816
 817 NTKERNELAPI // confirmed - Undocumented because it does not require a valid file handle
 818 NTSTATUS
 819 IoQueryFileInformation (
 820         IN      PFILE_OBJECT            FileObject,
 821         IN      FILE_INFORMATION_CLASS  FileInformationClass,
 822         IN      ULONG                   Length,
 823         OUT     PVOID                   FileInformation,
 824         OUT     PULONG                  ReturnedLength
 825         );
 826
 827 VOID
 828 IoRegisterFileSystem (
 829         PDEVICE_OBJECT  DeviceObject
 830         );
 831
 832 PDEVICE_OBJECT
 833 IoGetAttachedDevice (
 834         PDEVICE_OBJECT  DeviceObject
 835         );
 836
 837 PFILE_OBJECT
 838 IoCreateStreamFileObject (
 839         PFILE_OBJECT    FileObject,
 840         PDEVICE_OBJECT  DeviceObject
 841         );
 842