{******************************************************************************}
{                                                                              }
{ I/O Control Codes API interface Unit for Object Pascal                       }
{                                                                              }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
{ Corporation. All Rights Reserved.                                            }
{                                                                              }
{ The original file is: winioctl.h, released June 2000. The original Pascal    }
{ code is: WinIoCtl.pas, released December 2000. The initial developer of the  }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
{                                                                              }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
{ Marcel van Brakel. All Rights Reserved.                                      }
{                                                                              }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
{                                                                              }
{ You may retrieve the latest version of this file at the Project JEDI         }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
{                                                                              }
{ The contents of this file are used with permission, subject to the Mozilla   }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at      }
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
{                                                                              }
{ Software distributed under the License is distributed on an "AS IS" basis,   }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License.    }
{                                                                              }
{ Alternatively, the contents of this file may be used under the terms of the  }
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
{ provisions of the LGPL License are applicable instead of those above.        }
{ If you wish to allow use of your version of this file only under the terms   }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the LGPL      }
{ License.  If you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the MPL or the LGPL License.          }
{                                                                              }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{                                                                              }
{******************************************************************************}

// $Id: JwaWinIoctl.pas,v 1.7 2005/09/03 14:27:49 marquardt Exp $

unit JwaWinIoctl;

{$WEAKPACKAGEUNIT}

{$HPPEMIT ''}
{$HPPEMIT '#include "WinIoCtl.h"'}
{$HPPEMIT ''}

{$I jediapilib.inc}

interface

uses
  JwaWindows;

//
// Device interface class GUIDs.
//
// need these GUIDs outside conditional includes so that user can
//   #include <winioctl.h> in precompiled header
//   #include <initguid.h> in a single source file
//   #include <winioctl.h> in that source file a second time to instantiate the GUIDs
//

const
  GUID_DEVINTERFACE_DISK: TGUID = (
    D1:$53f56307; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_DISK}
  GUID_DEVINTERFACE_CDROM: TGUID = (
    D1:$53f56308; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_CDROM}
  GUID_DEVINTERFACE_PARTITION: TGUID = (
    D1:$53f5630a; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_PARTITION}
  GUID_DEVINTERFACE_TAPE: TGUID = (
    D1:$53f5630b; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_TAPE}
  GUID_DEVINTERFACE_WRITEONCEDISK: TGUID = (
    D1:$53f5630c; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_WRITEONCEDISK}
  GUID_DEVINTERFACE_VOLUME: TGUID = (
    D1:$53f5630d; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_VOLUME}
  GUID_DEVINTERFACE_MEDIUMCHANGER: TGUID = (
    D1:$53f56310; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_MEDIUMCHANGER}
  GUID_DEVINTERFACE_FLOPPY: TGUID = (
    D1:$53f56311; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_FLOPPY}
  GUID_DEVINTERFACE_CDCHANGER: TGUID = (
    D1:$53f56312; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_CDCHANGER}
  GUID_DEVINTERFACE_STORAGEPORT: TGUID = (
    D1:$2accfe60; D2:$c130; D3:$11d2; D4:($b0, $82, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM GUID_DEVINTERFACE_STORAGEPORT}
  GUID_DEVINTERFACE_COMPORT: TGUID = (
    D1:$86e0d1e0; D2:$8089; D3:$11d0; D4:($9c, $e4, $08, $00, $3e, $30, $1f, $73));
  {$EXTERNALSYM GUID_DEVINTERFACE_COMPORT}
  GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR: TGUID = (
    D1:$4D36E978; D2:$E325; D3:$11CE; D4:($BF, $C1, $08, $00, $2B, $E1, $03, $18));
  {$EXTERNALSYM GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR}

//
// Obsolete device interface class GUID names.
// (use of above GUID_DEVINTERFACE_* names is recommended).
//

  // MVB: Note that these "constants" are in reality aliases for the list above. Unfortunately you can't
  // define a GUID without using a type constant and you can't alias a type constant in Delphi...

  DiskClassGuid: TGUID = (
    D1:$53f56307; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM DiskClassGuid}
  CdRomClassGuid: TGUID = (
    D1:$53f56308; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM CdRomClassGuid}
  PartitionClassGuid: TGUID = (
    D1:$53f5630a; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM PartitionClassGuid}
  TapeClassGuid: TGUID = (
    D1:$53f5630b; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM TapeClassGuid}
  WriteOnceDiskClassGuid: TGUID = (
    D1:$53f5630c; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM WriteOnceDiskClassGuid}
  VolumeClassGuid: TGUID = (
    D1:$53f5630d; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM VolumeClassGuid}
  MediumChangerClassGuid: TGUID = (
    D1:$53f56310; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM MediumChangerClassGuid}
  FloppyClassGuid: TGUID = (
    D1:$53f56311; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM FloppyClassGuid}
  CdChangerClassGuid: TGUID = (
    D1:$53f56312; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM CdChangerClassGuid}
  StoragePortClassGuid: TGUID = (
    D1:$2accfe60; D2:$c130; D3:$11d2; D4:($b0, $82, $00, $a0, $c9, $1e, $fb, $8b));
  {$EXTERNALSYM StoragePortClassGuid}
  GUID_CLASS_COMPORT: TGUID = (
    D1:$86e0d1e0; D2:$8089; D3:$11d0; D4:($9c, $e4, $08, $00, $3e, $30, $1f, $73));
  {$EXTERNALSYM GUID_CLASS_COMPORT}
  GUID_SERENUM_BUS_ENUMERATOR: TGUID = (
    D1:$4D36E978; D2:$E325; D3:$11CE; D4:($BF, $C1, $08, $00, $2B, $E1, $03, $18));
  {$EXTERNALSYM GUID_SERENUM_BUS_ENUMERATOR}

//
// Define the various device type values.  Note that values used by Microsoft
// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
// by customers.
//

type
  DEVICE_TYPE = DWORD;
  {$EXTERNALSYM DEVICE_TYPE}

const
  FILE_DEVICE_BEEP                = $00000001;
  {$EXTERNALSYM FILE_DEVICE_BEEP}
  FILE_DEVICE_CD_ROM              = $00000002;
  {$EXTERNALSYM FILE_DEVICE_CD_ROM}
  FILE_DEVICE_CD_ROM_FILE_SYSTEM  = $00000003;
  {$EXTERNALSYM FILE_DEVICE_CD_ROM_FILE_SYSTEM}
  FILE_DEVICE_CONTROLLER          = $00000004;
  {$EXTERNALSYM FILE_DEVICE_CONTROLLER}
  FILE_DEVICE_DATALINK            = $00000005;
  {$EXTERNALSYM FILE_DEVICE_DATALINK}
  FILE_DEVICE_DFS                 = $00000006;
  {$EXTERNALSYM FILE_DEVICE_DFS}
  FILE_DEVICE_DISK                = $00000007;
  {$EXTERNALSYM FILE_DEVICE_DISK}
  FILE_DEVICE_DISK_FILE_SYSTEM    = $00000008;
  {$EXTERNALSYM FILE_DEVICE_DISK_FILE_SYSTEM}
  FILE_DEVICE_FILE_SYSTEM         = $00000009;
  {$EXTERNALSYM FILE_DEVICE_FILE_SYSTEM}
  FILE_DEVICE_INPORT_PORT         = $0000000a;
  {$EXTERNALSYM FILE_DEVICE_INPORT_PORT}
  FILE_DEVICE_KEYBOARD            = $0000000b;
  {$EXTERNALSYM FILE_DEVICE_KEYBOARD}
  FILE_DEVICE_MAILSLOT            = $0000000c;
  {$EXTERNALSYM FILE_DEVICE_MAILSLOT}
  FILE_DEVICE_MIDI_IN             = $0000000d;
  {$EXTERNALSYM FILE_DEVICE_MIDI_IN}
  FILE_DEVICE_MIDI_OUT            = $0000000e;
  {$EXTERNALSYM FILE_DEVICE_MIDI_OUT}
  FILE_DEVICE_MOUSE               = $0000000f;
  {$EXTERNALSYM FILE_DEVICE_MOUSE}
  FILE_DEVICE_MULTI_UNC_PROVIDER  = $00000010;
  {$EXTERNALSYM FILE_DEVICE_MULTI_UNC_PROVIDER}
  FILE_DEVICE_NAMED_PIPE          = $00000011;
  {$EXTERNALSYM FILE_DEVICE_NAMED_PIPE}
  FILE_DEVICE_NETWORK             = $00000012;
  {$EXTERNALSYM FILE_DEVICE_NETWORK}
  FILE_DEVICE_NETWORK_BROWSER     = $00000013;
  {$EXTERNALSYM FILE_DEVICE_NETWORK_BROWSER}
  FILE_DEVICE_NETWORK_FILE_SYSTEM = $00000014;
  {$EXTERNALSYM FILE_DEVICE_NETWORK_FILE_SYSTEM}
  FILE_DEVICE_NULL                = $00000015;
  {$EXTERNALSYM FILE_DEVICE_NULL}
  FILE_DEVICE_PARALLEL_PORT       = $00000016;
  {$EXTERNALSYM FILE_DEVICE_PARALLEL_PORT}
  FILE_DEVICE_PHYSICAL_NETCARD    = $00000017;
  {$EXTERNALSYM FILE_DEVICE_PHYSICAL_NETCARD}
  FILE_DEVICE_PRINTER             = $00000018;
  {$EXTERNALSYM FILE_DEVICE_PRINTER}
  FILE_DEVICE_SCANNER             = $00000019;
  {$EXTERNALSYM FILE_DEVICE_SCANNER}
  FILE_DEVICE_SERIAL_MOUSE_PORT   = $0000001a;
  {$EXTERNALSYM FILE_DEVICE_SERIAL_MOUSE_PORT}
  FILE_DEVICE_SERIAL_PORT         = $0000001b;
  {$EXTERNALSYM FILE_DEVICE_SERIAL_PORT}
  FILE_DEVICE_SCREEN              = $0000001c;
  {$EXTERNALSYM FILE_DEVICE_SCREEN}
  FILE_DEVICE_SOUND               = $0000001d;
  {$EXTERNALSYM FILE_DEVICE_SOUND}
  FILE_DEVICE_STREAMS             = $0000001e;
  {$EXTERNALSYM FILE_DEVICE_STREAMS}
  FILE_DEVICE_TAPE                = $0000001f;
  {$EXTERNALSYM FILE_DEVICE_TAPE}
  FILE_DEVICE_TAPE_FILE_SYSTEM    = $00000020;
  {$EXTERNALSYM FILE_DEVICE_TAPE_FILE_SYSTEM}
  FILE_DEVICE_TRANSPORT           = $00000021;
  {$EXTERNALSYM FILE_DEVICE_TRANSPORT}
  FILE_DEVICE_UNKNOWN             = $00000022;
  {$EXTERNALSYM FILE_DEVICE_UNKNOWN}
  FILE_DEVICE_VIDEO               = $00000023;
  {$EXTERNALSYM FILE_DEVICE_VIDEO}
  FILE_DEVICE_VIRTUAL_DISK        = $00000024;
  {$EXTERNALSYM FILE_DEVICE_VIRTUAL_DISK}
  FILE_DEVICE_WAVE_IN             = $00000025;
  {$EXTERNALSYM FILE_DEVICE_WAVE_IN}
  FILE_DEVICE_WAVE_OUT            = $00000026;
  {$EXTERNALSYM FILE_DEVICE_WAVE_OUT}
  FILE_DEVICE_8042_PORT           = $00000027;
  {$EXTERNALSYM FILE_DEVICE_8042_PORT}
  FILE_DEVICE_NETWORK_REDIRECTOR  = $00000028;
  {$EXTERNALSYM FILE_DEVICE_NETWORK_REDIRECTOR}
  FILE_DEVICE_BATTERY             = $00000029;
  {$EXTERNALSYM FILE_DEVICE_BATTERY}
  FILE_DEVICE_BUS_EXTENDER        = $0000002a;
  {$EXTERNALSYM FILE_DEVICE_BUS_EXTENDER}
  FILE_DEVICE_MODEM               = $0000002b;
  {$EXTERNALSYM FILE_DEVICE_MODEM}
  FILE_DEVICE_VDM                 = $0000002c;
  {$EXTERNALSYM FILE_DEVICE_VDM}
  FILE_DEVICE_MASS_STORAGE        = $0000002d;
  {$EXTERNALSYM FILE_DEVICE_MASS_STORAGE}
  FILE_DEVICE_SMB                 = $0000002e;
  {$EXTERNALSYM FILE_DEVICE_SMB}
  FILE_DEVICE_KS                  = $0000002f;
  {$EXTERNALSYM FILE_DEVICE_KS}
  FILE_DEVICE_CHANGER             = $00000030;
  {$EXTERNALSYM FILE_DEVICE_CHANGER}
  FILE_DEVICE_SMARTCARD           = $00000031;
  {$EXTERNALSYM FILE_DEVICE_SMARTCARD}
  FILE_DEVICE_ACPI                = $00000032;
  {$EXTERNALSYM FILE_DEVICE_ACPI}
  FILE_DEVICE_DVD                 = $00000033;
  {$EXTERNALSYM FILE_DEVICE_DVD}
  FILE_DEVICE_FULLSCREEN_VIDEO    = $00000034;
  {$EXTERNALSYM FILE_DEVICE_FULLSCREEN_VIDEO}
  FILE_DEVICE_DFS_FILE_SYSTEM     = $00000035;
  {$EXTERNALSYM FILE_DEVICE_DFS_FILE_SYSTEM}
  FILE_DEVICE_DFS_VOLUME          = $00000036;
  {$EXTERNALSYM FILE_DEVICE_DFS_VOLUME}
  FILE_DEVICE_SERENUM             = $00000037;
  {$EXTERNALSYM FILE_DEVICE_SERENUM}
  FILE_DEVICE_TERMSRV             = $00000038;
  {$EXTERNALSYM FILE_DEVICE_TERMSRV}
  FILE_DEVICE_KSEC                = $00000039;
  {$EXTERNALSYM FILE_DEVICE_KSEC}
  FILE_DEVICE_FIPS                = $0000003A;
  {$EXTERNALSYM FILE_DEVICE_FIPS}
  FILE_DEVICE_INFINIBAND          = $0000003B;
  {$EXTERNALSYM FILE_DEVICE_INFINIBAND}

//
// Macro definition for defining IOCTL and FSCTL function control codes.  Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.
//

function CTL_CODE(DeviceType, Func, Method, Access: WORD): DWORD;
{$EXTERNALSYM CTL_CODE}

//
// Macro to extract device type out of the device io control code
//

function DEVICE_TYPE_FROM_CTL_CODE(CtrlCode: DWORD): WORD;
{$EXTERNALSYM DEVICE_TYPE_FROM_CTL_CODE}

//
// Define the method codes for how buffers are passed for I/O and FS controls
//

const
  METHOD_BUFFERED   = 0;
  {$EXTERNALSYM METHOD_BUFFERED}
  METHOD_IN_DIRECT  = 1;
  {$EXTERNALSYM METHOD_IN_DIRECT}
  METHOD_OUT_DIRECT = 2;
  {$EXTERNALSYM METHOD_OUT_DIRECT}
  METHOD_NEITHER    = 3;
  {$EXTERNALSYM METHOD_NEITHER}

//
// Define some easier to comprehend aliases:
//   METHOD_DIRECT_TO_HARDWARE (writes, aka METHOD_IN_DIRECT)
//   METHOD_DIRECT_FROM_HARDWARE (reads, aka METHOD_OUT_DIRECT)
//

  METHOD_DIRECT_TO_HARDWARE     = METHOD_IN_DIRECT;
  {$EXTERNALSYM METHOD_DIRECT_TO_HARDWARE}
  METHOD_DIRECT_FROM_HARDWARE   = METHOD_OUT_DIRECT;
  {$EXTERNALSYM METHOD_DIRECT_FROM_HARDWARE}

//
// Define the access check value for any access
//
//
// The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
// ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
// constants *MUST* always be in sync.
//
//
// FILE_SPECIAL_ACCESS is checked by the NT I/O system the same as FILE_ANY_ACCESS.
// The file systems, however, may add additional access checks for I/O and FS controls
// that use this value.
//

const
  FILE_ANY_ACCESS     = 0;
  {$EXTERNALSYM FILE_ANY_ACCESS}
  FILE_SPECIAL_ACCESS = FILE_ANY_ACCESS;
  {$EXTERNALSYM FILE_SPECIAL_ACCESS}
  FILE_READ_ACCESS    = $0001;           // file & pipe
  {$EXTERNALSYM FILE_READ_ACCESS}
  FILE_WRITE_ACCESS   = $0002;           // file & pipe
  {$EXTERNALSYM FILE_WRITE_ACCESS}

//
// IoControlCode values for storage devices
//

  IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE;
  {$EXTERNALSYM IOCTL_STORAGE_BASE}

//
// The following device control codes are common for all class drivers.  They
// should be used in place of the older IOCTL_DISK, IOCTL_CDROM and IOCTL_TAPE
// common codes
//

const
  IOCTL_STORAGE_CHECK_VERIFY = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0200 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_CHECK_VERIFY}
  IOCTL_STORAGE_CHECK_VERIFY2 = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0200 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_CHECK_VERIFY2}
  IOCTL_STORAGE_MEDIA_REMOVAL = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0201 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_MEDIA_REMOVAL}
  IOCTL_STORAGE_EJECT_MEDIA = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0202 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_EJECT_MEDIA}
  IOCTL_STORAGE_LOAD_MEDIA = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0203 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_LOAD_MEDIA}
  IOCTL_STORAGE_LOAD_MEDIA2 = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0203 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_LOAD_MEDIA2}
  IOCTL_STORAGE_RESERVE = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0204 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_RESERVE}
  IOCTL_STORAGE_RELEASE = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0205 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_RELEASE}
  IOCTL_STORAGE_FIND_NEW_DEVICES = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0206 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_FIND_NEW_DEVICES}

  IOCTL_STORAGE_EJECTION_CONTROL = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0250 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_EJECTION_CONTROL}
  IOCTL_STORAGE_MCN_CONTROL = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0251 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_MCN_CONTROL}

  IOCTL_STORAGE_GET_MEDIA_TYPES = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0300 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_GET_MEDIA_TYPES}
  IOCTL_STORAGE_GET_MEDIA_TYPES_EX = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0301 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_GET_MEDIA_TYPES_EX}
  IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0304 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER}
  IOCTL_STORAGE_GET_HOTPLUG_INFO = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0305 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_GET_HOTPLUG_INFO}
  IOCTL_STORAGE_SET_HOTPLUG_INFO = (
    (IOCTL_STORAGE_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0306 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_SET_HOTPLUG_INFO}

  IOCTL_STORAGE_RESET_BUS = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0400 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_RESET_BUS}
  IOCTL_STORAGE_RESET_DEVICE = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0401 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_RESET_DEVICE}
  IOCTL_STORAGE_BREAK_RESERVATION = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0405 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_BREAK_RESERVATION}

  IOCTL_STORAGE_GET_DEVICE_NUMBER = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0420 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_GET_DEVICE_NUMBER}

  IOCTL_STORAGE_PREDICT_FAILURE = (
    (IOCTL_STORAGE_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0440 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_STORAGE_PREDICT_FAILURE}

//
// These ioctl codes are obsolete.  They are defined here to avoid resuing them
// and to allow class drivers to respond to them more easily.
//

  OBSOLETE_IOCTL_STORAGE_RESET_BUS = (
    (IOCTL_STORAGE_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0400 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM OBSOLETE_IOCTL_STORAGE_RESET_BUS}

  OBSOLETE_IOCTL_STORAGE_RESET_DEVICE = (
    (IOCTL_STORAGE_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0401 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM OBSOLETE_IOCTL_STORAGE_RESET_DEVICE}

//
// IOCTL_STORAGE_GET_HOTPLUG_INFO
//

type
  PSTORAGE_HOTPLUG_INFO = ^STORAGE_HOTPLUG_INFO;
  {$EXTERNALSYM PSTORAGE_HOTPLUG_INFO}
  _STORAGE_HOTPLUG_INFO = record
    Size: DWORD; // version
    MediaRemovable: BOOLEAN; // ie. zip, jaz, cdrom, mo, etc. vs hdd
    MediaHotplug: BOOLEAN;   // ie. does the device succeed a lock even though its not lockable media?
    DeviceHotplug: BOOLEAN;  // ie. 1394, USB, etc.
    WriteCacheEnableOverride: BOOLEAN; // This field should not be relied upon because it is no longer used
  end;
  {$EXTERNALSYM _STORAGE_HOTPLUG_INFO}
  STORAGE_HOTPLUG_INFO = _STORAGE_HOTPLUG_INFO;
  {$EXTERNALSYM STORAGE_HOTPLUG_INFO}
  TStorageHotplugInfo = STORAGE_HOTPLUG_INFO;
  PStorageHotplugInfo = PSTORAGE_HOTPLUG_INFO;

//
// IOCTL_STORAGE_GET_DEVICE_NUMBER
//
// input - none
//
// output - STORAGE_DEVICE_NUMBER structure
//          The values in the STORAGE_DEVICE_NUMBER structure are guaranteed
//          to remain unchanged until the system is rebooted.  They are not
//          guaranteed to be persistant across boots.
//

type
  PSTORAGE_DEVICE_NUMBER = ^STORAGE_DEVICE_NUMBER;
  {$EXTERNALSYM PSTORAGE_DEVICE_NUMBER}
  _STORAGE_DEVICE_NUMBER = record
    //
    // The FILE_DEVICE_XXX type for this device.
    //
    DeviceType: DEVICE_TYPE;
    //
    // The number of this device
    //
    DeviceNumber: DWORD;
    //
    // If the device is partitionable, the partition number of the device.
    // Otherwise -1
    //
    PartitionNumber: DWORD;
  end;
  {$EXTERNALSYM _STORAGE_DEVICE_NUMBER}
  STORAGE_DEVICE_NUMBER = _STORAGE_DEVICE_NUMBER;
  {$EXTERNALSYM STORAGE_DEVICE_NUMBER}
  TStorageDeviceNumber = STORAGE_DEVICE_NUMBER;
  PStorageDeviceNumber = PSTORAGE_DEVICE_NUMBER;

//
// Define the structures for scsi resets
//

  PSTORAGE_BUS_RESET_REQUEST = ^STORAGE_BUS_RESET_REQUEST;
  {$EXTERNALSYM PSTORAGE_BUS_RESET_REQUEST}
  _STORAGE_BUS_RESET_REQUEST = record
    PathId: BYTE;
  end;
  {$EXTERNALSYM _STORAGE_BUS_RESET_REQUEST}
  STORAGE_BUS_RESET_REQUEST = _STORAGE_BUS_RESET_REQUEST;
  {$EXTERNALSYM STORAGE_BUS_RESET_REQUEST}
  TStorageBusResetRequest = STORAGE_BUS_RESET_REQUEST;
  PStorageBusResetRequest = PSTORAGE_BUS_RESET_REQUEST;

//
// Break reservation is sent to the Adapter/FDO with the given lun information.
//

  STORAGE_BREAK_RESERVATION_REQUEST = record
    Length: DWORD;
    _unused: Byte;
    PathId: Byte;
    TargetId: Byte;
    Lun: Byte;
  end;
  {$EXTERNALSYM STORAGE_BREAK_RESERVATION_REQUEST}
  PSTORAGE_BREAK_RESERVATION_REQUEST = ^STORAGE_BREAK_RESERVATION_REQUEST;
  {$EXTERNALSYM PSTORAGE_BREAK_RESERVATION_REQUEST}
  TStorageBreakReservationRequest = STORAGE_BREAK_RESERVATION_REQUEST;
  PStorageBreakReservationRequest = PSTORAGE_BREAK_RESERVATION_REQUEST;  

//
// IOCTL_STORAGE_MEDIA_REMOVAL disables the mechanism
// on a storage device that ejects media. This function
// may or may not be supported on storage devices that
// support removable media.
//
// TRUE means prevent media from being removed.
// FALSE means allow media removal.
//

  PPREVENT_MEDIA_REMOVAL = ^PREVENT_MEDIA_REMOVAL;
  {$EXTERNALSYM PPREVENT_MEDIA_REMOVAL}
  _PREVENT_MEDIA_REMOVAL = record
    PreventMediaRemoval: ByteBool;
  end;
  {$EXTERNALSYM _PREVENT_MEDIA_REMOVAL}
  PREVENT_MEDIA_REMOVAL = _PREVENT_MEDIA_REMOVAL;
  {$EXTERNALSYM PREVENT_MEDIA_REMOVAL}
  TPreventMediaRemoval = PREVENT_MEDIA_REMOVAL;
  PPreventMediaRemoval = PPREVENT_MEDIA_REMOVAL;

//
//  This is the format of TARGET_DEVICE_CUSTOM_NOTIFICATION.CustomDataBuffer
//  passed to applications by the classpnp autorun code (via IoReportTargetDeviceChangeAsynchronous).
//

  _CLASS_MEDIA_CHANGE_CONTEXT = record
    MediaChangeCount: DWORD;
    NewState: DWORD;  // see MEDIA_CHANGE_DETECTION_STATE enum in classpnp.h in DDK
  end;
  {$EXTERNALSYM _CLASS_MEDIA_CHANGE_CONTEXT}
  CLASS_MEDIA_CHANGE_CONTEXT = _CLASS_MEDIA_CHANGE_CONTEXT;
  {$EXTERNALSYM CLASS_MEDIA_CHANGE_CONTEXT}
  PCLASS_MEDIA_CHANGE_CONTEXT = ^CLASS_MEDIA_CHANGE_CONTEXT;
  {$EXTERNALSYM PCLASS_MEDIA_CHANGE_CONTEXT}
  TClassMediaChangeContext = CLASS_MEDIA_CHANGE_CONTEXT;
  PClassMediaChangeContext = PCLASS_MEDIA_CHANGE_CONTEXT;

  PTAPE_STATISTICS = ^TAPE_STATISTICS;
  {$EXTERNALSYM PTAPE_STATISTICS}
  _TAPE_STATISTICS = record
    Version: DWORD;
    Flags: DWORD;
    RecoveredWrites: LARGE_INTEGER;
    UnrecoveredWrites: LARGE_INTEGER;
    RecoveredReads: LARGE_INTEGER;
    UnrecoveredReads: LARGE_INTEGER;
    CompressionRatioReads: BYTE;
    CompressionRatioWrites: BYTE;
  end;
  {$EXTERNALSYM _TAPE_STATISTICS}
  TAPE_STATISTICS = _TAPE_STATISTICS;
  {$EXTERNALSYM TAPE_STATISTICS}
  TTapeStatistics = TAPE_STATISTICS;
  PTapeStatistics = PTAPE_STATISTICS;

const
  RECOVERED_WRITES_VALID       = $00000001;
  {$EXTERNALSYM RECOVERED_WRITES_VALID}
  UNRECOVERED_WRITES_VALID     = $00000002;
  {$EXTERNALSYM UNRECOVERED_WRITES_VALID}
  RECOVERED_READS_VALID        = $00000004;
  {$EXTERNALSYM RECOVERED_READS_VALID}
  UNRECOVERED_READS_VALID      = $00000008;
  {$EXTERNALSYM UNRECOVERED_READS_VALID}
  WRITE_COMPRESSION_INFO_VALID = $00000010;
  {$EXTERNALSYM WRITE_COMPRESSION_INFO_VALID}
  READ_COMPRESSION_INFO_VALID  = $00000020;
  {$EXTERNALSYM READ_COMPRESSION_INFO_VALID}

type
  PTAPE_GET_STATISTICS = ^TAPE_GET_STATISTICS;
  {$EXTERNALSYM PTAPE_GET_STATISTICS}
  _TAPE_GET_STATISTICS = record
    Operation: DWORD;
  end;
  {$EXTERNALSYM _TAPE_GET_STATISTICS}
  TAPE_GET_STATISTICS = _TAPE_GET_STATISTICS;
  {$EXTERNALSYM TAPE_GET_STATISTICS}
  TTapeGetStatistics = TAPE_GET_STATISTICS;
  PTapeGetStatistics = PTAPE_GET_STATISTICS;

const
  TAPE_RETURN_STATISTICS = 0;
  {$EXTERNALSYM TAPE_RETURN_STATISTICS}
  TAPE_RETURN_ENV_INFO   = 1;
  {$EXTERNALSYM TAPE_RETURN_ENV_INFO}
  TAPE_RESET_STATISTICS  = 2;
  {$EXTERNALSYM TAPE_RESET_STATISTICS}

//
// IOCTL_STORAGE_GET_MEDIA_TYPES_EX will return an array of DEVICE_MEDIA_INFO
// structures, one per supported type, embedded in the GET_MEDIA_TYPES struct.
//

const

  //
  // Following are defined in ntdddisk.h in the MEDIA_TYPE enum
  //
  // Unknown,                // Format is unknown
  // F5_1Pt2_512,            // 5.25", 1.2MB,  512 bytes/sector
  // F3_1Pt44_512,           // 3.5",  1.44MB, 512 bytes/sector
  // F3_2Pt88_512,           // 3.5",  2.88MB, 512 bytes/sector
  // F3_20Pt8_512,           // 3.5",  20.8MB, 512 bytes/sector
  // F3_720_512,             // 3.5",  720KB,  512 bytes/sector
  // F5_360_512,             // 5.25", 360KB,  512 bytes/sector
  // F5_320_512,             // 5.25", 320KB,  512 bytes/sector
  // F5_320_1024,            // 5.25", 320KB,  1024 bytes/sector
  // F5_180_512,             // 5.25", 180KB,  512 bytes/sector
  // F5_160_512,             // 5.25", 160KB,  512 bytes/sector
  // RemovableMedia,         // Removable media other than floppy
  // FixedMedia,             // Fixed hard disk media
  // F3_120M_512,            // 3.5", 120M Floppy
  // F3_640_512,             // 3.5" ,  640KB,  512 bytes/sector
  // F5_640_512,             // 5.25",  640KB,  512 bytes/sector
  // F5_720_512,             // 5.25",  720KB,  512 bytes/sector
  // F3_1Pt2_512,            // 3.5" ,  1.2Mb,  512 bytes/sector
  // F3_1Pt23_1024,          // 3.5" ,  1.23Mb, 1024 bytes/sector
  // F5_1Pt23_1024,          // 5.25",  1.23MB, 1024 bytes/sector
  // F3_128Mb_512,           // 3.5" MO 128Mb   512 bytes/sector
  // F3_230Mb_512,           // 3.5" MO 230Mb   512 bytes/sector
  // F8_256_128,             // 8",     256KB,  128 bytes/sector
  // F3_200Mb_512,           // 3.5",   200M Floppy (HiFD)  
  //

  DDS_4mm            = $20;  // Tape - DAT DDS1,2,... (all vendors)
  MiniQic            = $21;  // Tape - miniQIC Tape
  Travan             = $22;  // Tape - Travan TR-1,2,3,...
  QIC                = $23;  // Tape - QIC
  MP_8mm             = $24;  // Tape - 8mm Exabyte Metal Particle
  AME_8mm            = $25;  // Tape - 8mm Exabyte Advanced Metal Evap
  AIT1_8mm           = $26;  // Tape - 8mm Sony AIT
  DLT                = $27;  // Tape - DLT Compact IIIxt, IV
  NCTP               = $28;  // Tape - Philips NCTP
  IBM_3480           = $29;  // Tape - IBM 3480
  IBM_3490E          = $2A;  // Tape - IBM 3490E
  IBM_Magstar_3590   = $2B;  // Tape - IBM Magstar 3590
  IBM_Magstar_MP     = $2C;  // Tape - IBM Magstar MP
  STK_DATA_D3        = $2D;  // Tape - STK Data D3
  SONY_DTF           = $2E;  // Tape - Sony DTF
  DV_6mm             = $2F;  // Tape - 6mm Digital Video
  DMI                = $30;  // Tape - Exabyte DMI and compatibles
  SONY_D2            = $31;  // Tape - Sony D2S and D2L
  CLEANER_CARTRIDGE  = $32;  // Cleaner - All Drive types that support Drive Cleaners
  CD_ROM             = $33;  // Opt_Disk - CD
  CD_R               = $34;  // Opt_Disk - CD-Recordable (Write Once)
  CD_RW              = $35;  // Opt_Disk - CD-Rewriteable
  DVD_ROM            = $36;  // Opt_Disk - DVD-ROM
  DVD_R              = $37;  // Opt_Disk - DVD-Recordable (Write Once)
  DVD_RW             = $38;  // Opt_Disk - DVD-Rewriteable
  MO_3_RW            = $39;  // Opt_Disk - 3.5" Rewriteable MO Disk
  MO_5_WO            = $3A;  // Opt_Disk - MO 5.25" Write Once
  MO_5_RW            = $3B;  // Opt_Disk - MO 5.25" Rewriteable (not LIMDOW)
  MO_5_LIMDOW        = $3C;  // Opt_Disk - MO 5.25" Rewriteable (LIMDOW)
  PC_5_WO            = $3D;  // Opt_Disk - Phase Change 5.25" Write Once Optical
  PC_5_RW            = $3E;  // Opt_Disk - Phase Change 5.25" Rewriteable
  PD_5_RW            = $3F;  // Opt_Disk - PhaseChange Dual Rewriteable
  ABL_5_WO           = $40;  // Opt_Disk - Ablative 5.25" Write Once Optical
  PINNACLE_APEX_5_RW = $41;  // Opt_Disk - Pinnacle Apex 4.6GB Rewriteable Optical
  SONY_12_WO         = $42;  // Opt_Disk - Sony 12" Write Once
  PHILIPS_12_WO      = $43;  // Opt_Disk - Philips/LMS 12" Write Once
  HITACHI_12_WO      = $44;  // Opt_Disk - Hitachi 12" Write Once
  CYGNET_12_WO       = $45;  // Opt_Disk - Cygnet/ATG 12" Write Once
  KODAK_14_WO        = $46;  // Opt_Disk - Kodak 14" Write Once
  MO_NFR_525         = $47;  // Opt_Disk - Near Field Recording (Terastor)
  NIKON_12_RW        = $48;  // Opt_Disk - Nikon 12" Rewriteable
  IOMEGA_ZIP         = $49;  // Mag_Disk - Iomega Zip
  IOMEGA_JAZ         = $4A;  // Mag_Disk - Iomega Jaz
  SYQUEST_EZ135      = $4B;  // Mag_Disk - Syquest EZ135
  SYQUEST_EZFLYER    = $4C;  // Mag_Disk - Syquest EzFlyer
  SYQUEST_SYJET      = $4D;  // Mag_Disk - Syquest SyJet
  AVATAR_F2          = $4E;  // Mag_Disk - 2.5" Floppy
  MP2_8mm            = $4F;  // Tape - 8mm Hitachi
  DST_S              = $50;  // Ampex DST Small Tapes
  DST_M              = $51;  // Ampex DST Medium Tapes
  DST_L              = $52;  // Ampex DST Large Tapes
  VXATape_1          = $53;  // Ecrix 8mm Tape
  VXATape_2          = $54;  // Ecrix 8mm Tape
  STK_9840           = $55;  // STK 9840
  LTO_Ultrium        = $56;  // IBM, HP, Seagate LTO Ultrium
  LTO_Accelis        = $57;  // IBM, HP, Seagate LTO Accelis
  DVD_RAM            = $58;  // Opt_Disk - DVD-RAM
  AIT_8mm            = $59;  // AIT2 or higher
  ADR_1              = $5A;  // OnStream ADR Mediatypes
  ADR_2              = $5B;
  STK_9940           = $5C;  // STK 9940

type
  STORAGE_MEDIA_TYPE = DWORD;
  {$EXTERNALSYM STORAGE_MEDIA_TYPE}
  PSTORAGE_MEDIA_TYPE = ^STORAGE_MEDIA_TYPE;
  {$EXTERNALSYM PSTORAGE_MEDIA_TYPE}
  TStorageMediaType = STORAGE_MEDIA_TYPE;
  PStorageMediaType = ^TStorageMediaType;

const
  MEDIA_ERASEABLE  = $00000001;
  {$EXTERNALSYM MEDIA_ERASEABLE}
  MEDIA_WRITE_ONCE = $00000002;
  {$EXTERNALSYM MEDIA_WRITE_ONCE}
  MEDIA_READ_ONLY  = $00000004;
  {$EXTERNALSYM MEDIA_READ_ONLY}
  MEDIA_READ_WRITE = $00000008;
  {$EXTERNALSYM MEDIA_READ_WRITE}

  MEDIA_WRITE_PROTECTED   = $00000100;
  {$EXTERNALSYM MEDIA_WRITE_PROTECTED}
  MEDIA_CURRENTLY_MOUNTED = DWORD($80000000);
  {$EXTERNALSYM MEDIA_CURRENTLY_MOUNTED}

//
// Define the different storage bus types
// Bus types below 128 (0x80) are reserved for Microsoft use
//

const
  BusTypeUnknown     = 0;
  BusTypeScsi        = 1;
  BusTypeAtapi       = 2;
  BusTypeAta         = 3;
  BusType1394        = 4;
  BusTypeSsa         = 5;
  BusTypeFibre       = 6;
  BusTypeUsb         = 7;
  BusTypeRAID        = 8;
  BusTypeMaxReserved = $7F;

type
  STORAGE_BUS_TYPE = DWORD;
  {$EXTERNALSYM STORAGE_BUS_TYPE}
  PSTORAGE_BUS_TYPE = ^STORAGE_BUS_TYPE;
  {$EXTERNALSYM PSTORAGE_BUS_TYPE}
  TStorageBusType = STORAGE_BUS_TYPE;
  PStorageBusType = PSTORAGE_BUS_TYPE;

  TDMIDiskInfo = record
    Cylinders: LARGE_INTEGER;
    MediaType: STORAGE_MEDIA_TYPE;
    TracksPerCylinder: DWORD;
    SectorsPerTrack: DWORD;
    BytesPerSector: DWORD;
    NumberMediaSides: DWORD;
    MediaCharacteristics: DWORD; // Bitmask of MEDIA_XXX values.
  end;

  TDMIRemovableDiskInfo = record
    Cylinders: LARGE_INTEGER;
    MediaType: STORAGE_MEDIA_TYPE;
    TracksPerCylinder: DWORD;
    SectorsPerTrack: DWORD;
    BytesPerSector: DWORD;
    NumberMediaSides: DWORD;
    MediaCharacteristics: DWORD; // Bitmask of MEDIA_XXX values.
  end;

  TDMITapeInfo = record
    MediaType: STORAGE_MEDIA_TYPE;
    MediaCharacteristics: DWORD; // Bitmask of MEDIA_XXX values.
    CurrentBlockSize: DWORD;
    BusType: STORAGE_BUS_TYPE;
    //
    // Bus specific information describing the medium supported.
    //
    case Integer of {BusSpecificData}
      0: ( {ScsiInformation}
        MediumType: BYTE;
        DensityCode: BYTE);
  end;

  PDEVICE_MEDIA_INFO = ^DEVICE_MEDIA_INFO;
  {$EXTERNALSYM PDEVICE_MEDIA_INFO}
  _DEVICE_MEDIA_INFO = record
    case Integer of
      0: (DiskInfo: TDMIDiskInfo);
      1: (RemovableDiskInfo: TDMIRemovableDiskInfo);
      2: (TapeInfo: TDMITapeInfo);
  end;
  {$EXTERNALSYM _DEVICE_MEDIA_INFO}
  DEVICE_MEDIA_INFO = _DEVICE_MEDIA_INFO;
  {$EXTERNALSYM DEVICE_MEDIA_INFO}
  TDeviceMediaInfo = DEVICE_MEDIA_INFO;
  PDeviceMediaInfo = PDEVICE_MEDIA_INFO;

  PGET_MEDIA_TYPES = ^GET_MEDIA_TYPES;
  {$EXTERNALSYM PGET_MEDIA_TYPES}
  _GET_MEDIA_TYPES = record
    DeviceType: DWORD; // FILE_DEVICE_XXX values
    MediaInfoCount: DWORD;
    MediaInfo: array [0..0] of DEVICE_MEDIA_INFO;
  end;
  {$EXTERNALSYM _GET_MEDIA_TYPES}
  GET_MEDIA_TYPES = _GET_MEDIA_TYPES;
  {$EXTERNALSYM GET_MEDIA_TYPES}
  TGetMediaTypes = GET_MEDIA_TYPES;
  PGetMediaTypes = PGET_MEDIA_TYPES;

//
// IOCTL_STORAGE_PREDICT_FAILURE
//
// input - none
//
// output - STORAGE_PREDICT_FAILURE structure
//          PredictFailure returns zero if no failure predicted and non zero
//                         if a failure is predicted.
//
//          VendorSpecific returns 512 bytes of vendor specific information
//                         if a failure is predicted
//

  PSTORAGE_PREDICT_FAILURE = ^STORAGE_PREDICT_FAILURE;
  {$EXTERNALSYM PSTORAGE_PREDICT_FAILURE}
  _STORAGE_PREDICT_FAILURE = record
    PredictFailure: DWORD;
    VendorSpecific: array [0..511] of BYTE;
  end;
  {$EXTERNALSYM _STORAGE_PREDICT_FAILURE}
  STORAGE_PREDICT_FAILURE = _STORAGE_PREDICT_FAILURE;
  {$EXTERNALSYM STORAGE_PREDICT_FAILURE}
  TStoragePredictFailure = STORAGE_PREDICT_FAILURE;
  PStoragePredictFailure = PSTORAGE_PREDICT_FAILURE;

//
// IoControlCode values for disk devices.
//

const
  IOCTL_DISK_BASE = FILE_DEVICE_DISK;
  {$EXTERNALSYM IOCTL_DISK_BASE}

  IOCTL_DISK_GET_DRIVE_GEOMETRY = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0000 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_DRIVE_GEOMETRY}

  IOCTL_DISK_GET_PARTITION_INFO = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0001 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_PARTITION_INFO}

  IOCTL_DISK_SET_PARTITION_INFO = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0002 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SET_PARTITION_INFO}

  IOCTL_DISK_GET_DRIVE_LAYOUT = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0003 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_DRIVE_LAYOUT}

  IOCTL_DISK_SET_DRIVE_LAYOUT = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0004 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SET_DRIVE_LAYOUT}

  IOCTL_DISK_VERIFY = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0005 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_VERIFY}

  IOCTL_DISK_FORMAT_TRACKS = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0006 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_FORMAT_TRACKS}

  IOCTL_DISK_REASSIGN_BLOCKS = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0007 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_REASSIGN_BLOCKS}

  IOCTL_DISK_PERFORMANCE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0008 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_PERFORMANCE}

  IOCTL_DISK_IS_WRITABLE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0009 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_IS_WRITABLE}

  IOCTL_DISK_LOGGING = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($000a shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_LOGGING}

  IOCTL_DISK_FORMAT_TRACKS_EX = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($000b shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_FORMAT_TRACKS_EX}

  IOCTL_DISK_HISTOGRAM_STRUCTURE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($000c shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_HISTOGRAM_STRUCTURE}

  IOCTL_DISK_HISTOGRAM_DATA = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($000d shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_HISTOGRAM_DATA}

  IOCTL_DISK_HISTOGRAM_RESET = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($000e shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_HISTOGRAM_RESET}

  IOCTL_DISK_REQUEST_STRUCTURE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($000f shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_REQUEST_STRUCTURE}

  IOCTL_DISK_REQUEST_DATA = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0010 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_REQUEST_DATA}

  IOCTL_DISK_PERFORMANCE_OFF = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0018 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_PERFORMANCE_OFF}

  IOCTL_DISK_CONTROLLER_NUMBER = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0011 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_CONTROLLER_NUMBER}

//
// IOCTL support for SMART drive fault prediction.
//

  SMART_GET_VERSION = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0020 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM SMART_GET_VERSION}

  SMART_SEND_DRIVE_COMMAND = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0021 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM SMART_SEND_DRIVE_COMMAND}

  SMART_RCV_DRIVE_DATA = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0022 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM SMART_RCV_DRIVE_DATA}

//
// New IOCTLs for GUID Partition tabled disks.
//

// 23-11-2002: various bugs reported by Carsten Grafflage corrected

  IOCTL_DISK_GET_PARTITION_INFO_EX = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0012 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_PARTITION_INFO_EX}

  IOCTL_DISK_SET_PARTITION_INFO_EX = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0013 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SET_PARTITION_INFO_EX}

  IOCTL_DISK_GET_DRIVE_LAYOUT_EX = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0014 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_DRIVE_LAYOUT_EX}

  IOCTL_DISK_SET_DRIVE_LAYOUT_EX = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0015 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SET_DRIVE_LAYOUT_EX}

  IOCTL_DISK_CREATE_DISK = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0016 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_CREATE_DISK}

  IOCTL_DISK_GET_LENGTH_INFO = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0017 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_LENGTH_INFO}

  IOCTL_DISK_GET_DRIVE_GEOMETRY_EX = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0028 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_DRIVE_GEOMETRY_EX}

  IOCTL_DISK_UPDATE_DRIVE_SIZE = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0032 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_UPDATE_DRIVE_SIZE}

  IOCTL_DISK_GROW_PARTITION = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0034 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GROW_PARTITION}

  IOCTL_DISK_GET_CACHE_INFORMATION = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0035 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_CACHE_INFORMATION}

  IOCTL_DISK_SET_CACHE_INFORMATION = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0036 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SET_CACHE_INFORMATION}

  OBSOLETE_DISK_GET_WRITE_CACHE_STATE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0037 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM OBSOLETE_DISK_GET_WRITE_CACHE_STATE}

  IOCTL_DISK_DELETE_DRIVE_LAYOUT = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0040 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_DELETE_DRIVE_LAYOUT}

//
// Called to flush cached information that the driver may have about this
// device's characteristics.  Not all drivers cache characteristics, and not
// cached properties can be flushed.  This simply serves as an update to the
// driver that it may want to do an expensive reexamination of the device's
// characteristics now (fixed media size, partition table, etc...)
//

  IOCTL_DISK_UPDATE_PROPERTIES = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0050 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_UPDATE_PROPERTIES}

//
//  Special IOCTLs needed to support PC-98 machines in Japan
//

  IOCTL_DISK_FORMAT_DRIVE = (
    (IOCTL_DISK_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($00f3 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_FORMAT_DRIVE}

  IOCTL_DISK_SENSE_DEVICE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($00f8 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_SENSE_DEVICE}

//
// The following device control codes are common for all class drivers.  The
// functions codes defined here must match all of the other class drivers.
//
// Warning: these codes will be replaced in the future by equivalent
// IOCTL_STORAGE codes
//

  IOCTL_DISK_CHECK_VERIFY = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0200 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_CHECK_VERIFY}

  IOCTL_DISK_MEDIA_REMOVAL = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0201 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_MEDIA_REMOVAL}

  IOCTL_DISK_EJECT_MEDIA = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0202 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_EJECT_MEDIA}

  IOCTL_DISK_LOAD_MEDIA = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0203 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_LOAD_MEDIA}

  IOCTL_DISK_RESERVE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0204 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_RESERVE}

  IOCTL_DISK_RELEASE = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0205 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_RELEASE}

  IOCTL_DISK_FIND_NEW_DEVICES = (
    (IOCTL_DISK_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0206 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_FIND_NEW_DEVICES}

  IOCTL_DISK_GET_MEDIA_TYPES = (
    (IOCTL_DISK_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    ($0300 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_DISK_GET_MEDIA_TYPES}

//
// Define the partition types returnable by known disk drivers.
//

const
  PARTITION_ENTRY_UNUSED    = $00; // Entry unused
  {$EXTERNALSYM PARTITION_ENTRY_UNUSED}
  PARTITION_FAT_12          = $01; // 12-bit FAT entries
  {$EXTERNALSYM PARTITION_FAT_12}
  PARTITION_XENIX_1         = $02; // Xenix
  {$EXTERNALSYM PARTITION_XENIX_1}
  PARTITION_XENIX_2         = $03; // Xenix
  {$EXTERNALSYM PARTITION_XENIX_2}
  PARTITION_FAT_16          = $04; // 16-bit FAT entries
  {$EXTERNALSYM PARTITION_FAT_16}
  PARTITION_EXTENDED        = $05; // Extended partition entry
  {$EXTERNALSYM PARTITION_EXTENDED}
  PARTITION_HUGE            = $06; // Huge partition MS-DOS V4
  {$EXTERNALSYM PARTITION_HUGE}
  PARTITION_IFS             = $07; // IFS Partition
  {$EXTERNALSYM PARTITION_IFS}
  PARTITION_OS2BOOTMGR      = $0A; // OS/2 Boot Manager/OPUS/Coherent swap
  {$EXTERNALSYM PARTITION_OS2BOOTMGR}
  PARTITION_FAT32           = $0B; // FAT32
  {$EXTERNALSYM PARTITION_FAT32}
  PARTITION_FAT32_XINT13    = $0C; // FAT32 using extended int13 services
  {$EXTERNALSYM PARTITION_FAT32_XINT13}
  PARTITION_XINT13          = $0E; // Win95 partition using extended int13 services
  {$EXTERNALSYM PARTITION_XINT13}
  PARTITION_XINT13_EXTENDED = $0F; // Same as type 5 but uses extended int13 services
  {$EXTERNALSYM PARTITION_XINT13_EXTENDED}
  PARTITION_PREP            = $41; // PowerPC Reference Platform (PReP) Boot Partition
  {$EXTERNALSYM PARTITION_PREP}
  PARTITION_LDM             = $42; // Logical Disk Manager partition
  {$EXTERNALSYM PARTITION_LDM}
  PARTITION_UNIX            = $63; // Unix
  {$EXTERNALSYM PARTITION_UNIX}

  VALID_NTFT                = $C0; // NTFT uses high order bits
  {$EXTERNALSYM VALID_NTFT}

//
// The high bit of the partition type code indicates that a partition
// is part of an NTFT mirror or striped array.
//

  PARTITION_NTFT = $80; // NTFT partition
  {$EXTERNALSYM PARTITION_NTFT}

//
// The following macro is used to determine which partitions should be
// assigned drive letters.
//

//++
//
// BOOLEAN
// IsRecognizedPartition(
//     IN DWORD PartitionType
//     )
//
// Routine Description:
//
//     This macro is used to determine to which partitions drive letters
//     should be assigned.
//
// Arguments:
//
//     PartitionType - Supplies the type of the partition being examined.
//
// Return Value:
//
//     The return value is TRUE if the partition type is recognized,
//     otherwise FALSE is returned.
//
//--

function IsRecognizedPartition(PartitionType: DWORD): Boolean;
{$EXTERNALSYM IsRecognizedPartition}

//++
//
// BOOLEAN
// IsContainerPartition(
//     IN DWORD PartitionType
//     )
//
// Routine Description:
//
//     This macro is used to determine to which partition types are actually
//     containers for other partitions (ie, extended partitions).
//
// Arguments:
//
//     PartitionType - Supplies the type of the partition being examined.
//
// Return Value:
//
//     The return value is TRUE if the partition type is a container,
//     otherwise FALSE is returned.
//
//--

function IsContainerPartition(PartitionType: DWORD): Boolean;
{$EXTERNALSYM IsContainerPartition}

//++
//
// BOOLEAN
// IsFTPartition(
//     IN DWORD PartitionType
//     )
//
// Routine Description:
//
//     This macro is used to determine if the given partition is an FT
//     partition.
//
// Arguments:
//
//     PartitionType - Supplies the type of the partition being examined.
//
// Return Value:
//
//     The return value is TRUE if the partition type is an FT partition,
//     otherwise FALSE is returned.
//
//--

function IsFTPartition(PartitionType: DWORD): Boolean;
{$EXTERNALSYM IsFTPartition}

//
// Define the media types supported by the driver.
//

type
  _MEDIA_TYPE = (
    Unknown,                // Format is unknown
    F5_1Pt2_512,            // 5.25", 1.2MB,  512 bytes/sector
    F3_1Pt44_512,           // 3.5",  1.44MB, 512 bytes/sector
    F3_2Pt88_512,           // 3.5",  2.88MB, 512 bytes/sector
    F3_20Pt8_512,           // 3.5",  20.8MB, 512 bytes/sector
    F3_720_512,             // 3.5",  720KB,  512 bytes/sector
    F5_360_512,             // 5.25", 360KB,  512 bytes/sector
    F5_320_512,             // 5.25", 320KB,  512 bytes/sector
    F5_320_1024,            // 5.25", 320KB,  1024 bytes/sector
    F5_180_512,             // 5.25", 180KB,  512 bytes/sector
    F5_160_512,             // 5.25", 160KB,  512 bytes/sector
    RemovableMedia,         // Removable media other than floppy
    FixedMedia,             // Fixed hard disk media
    F3_120M_512,            // 3.5", 120M Floppy
    F3_640_512,             // 3.5" ,  640KB,  512 bytes/sector
    F5_640_512,             // 5.25",  640KB,  512 bytes/sector
    F5_720_512,             // 5.25",  720KB,  512 bytes/sector
    F3_1Pt2_512,            // 3.5" ,  1.2Mb,  512 bytes/sector
    F3_1Pt23_1024,          // 3.5" ,  1.23Mb, 1024 bytes/sector
    F5_1Pt23_1024,          // 5.25",  1.23MB, 1024 bytes/sector
    F3_128Mb_512,           // 3.5" MO 128Mb   512 bytes/sector
    F3_230Mb_512,           // 3.5" MO 230Mb   512 bytes/sector
    F8_256_128,             // 8",     256KB,  128 bytes/sector
    F3_200Mb_512,           // 3.5",   200M Floppy (HiFD)
    F3_240M_512,            // 3.5",   240Mb Floppy (HiFD)
    F3_32M_512);            // 3.5",   32Mb Floppy
  {$EXTERNALSYM _MEDIA_TYPE}
  MEDIA_TYPE = _MEDIA_TYPE;
  {$EXTERNALSYM MEDIA_TYPE}
  PMEDIA_TYPE = ^MEDIA_TYPE;
  {$EXTERNALSYM PMEDIA_TYPE}
  TMediaType = MEDIA_TYPE;
  PMediaType = PMEDIA_TYPE;

//
// Define the input buffer structure for the driver, when
// it is called with IOCTL_DISK_FORMAT_TRACKS.
//

  PFORMAT_PARAMETERS = ^FORMAT_PARAMETERS;
  {$EXTERNALSYM PFORMAT_PARAMETERS}
  _FORMAT_PARAMETERS = record
    MediaType: MEDIA_TYPE;
    StartCylinderNumber: DWORD;
    EndCylinderNumber: DWORD;
    StartHeadNumber: DWORD;
    EndHeadNumber: DWORD;
  end;
  {$EXTERNALSYM _FORMAT_PARAMETERS}
  FORMAT_PARAMETERS = _FORMAT_PARAMETERS;
  {$EXTERNALSYM FORMAT_PARAMETERS}
  TFormatParameters = FORMAT_PARAMETERS;
  PFormatParameters = PFORMAT_PARAMETERS;

//
// Define the BAD_TRACK_NUMBER type. An array of elements of this type is
// returned by the driver on IOCTL_DISK_FORMAT_TRACKS requests, to indicate
// what tracks were bad during formatting. The length of that array is
// reported in the `Information' field of the I/O Status Block.
//

  BAD_TRACK_NUMBER = WORD;
  {$EXTERNALSYM BAD_TRACK_NUMBER}
  PBAD_TRACK_NUMBER = ^WORD;
  {$EXTERNALSYM PBAD_TRACK_NUMBER}

//
// Define the input buffer structure for the driver, when
// it is called with IOCTL_DISK_FORMAT_TRACKS_EX.
//

  PFORMAT_EX_PARAMETERS = ^FORMAT_EX_PARAMETERS;
  {$EXTERNALSYM PFORMAT_EX_PARAMETERS}
  _FORMAT_EX_PARAMETERS = record
    MediaType: MEDIA_TYPE;
    StartCylinderNumber: DWORD;
    EndCylinderNumber: DWORD;
    StartHeadNumber: DWORD;
    EndHeadNumber: DWORD;
    FormatGapLength: WORD;
    SectorsPerTrack: WORD;
    SectorNumber: array [0..0] of WORD;
  end;
  {$EXTERNALSYM _FORMAT_EX_PARAMETERS}
  FORMAT_EX_PARAMETERS = _FORMAT_EX_PARAMETERS;
  {$EXTERNALSYM FORMAT_EX_PARAMETERS}
  TFormatExParameters = FORMAT_EX_PARAMETERS;
  PFormatExParameters = PFORMAT_EX_PARAMETERS;

//
// The following structure is returned on an IOCTL_DISK_GET_DRIVE_GEOMETRY
// request and an array of them is returned on an IOCTL_DISK_GET_MEDIA_TYPES
// request.
//

  PDISK_GEOMETRY = ^DISK_GEOMETRY;
  {$EXTERNALSYM PDISK_GEOMETRY}
  _DISK_GEOMETRY = record
    Cylinders: LARGE_INTEGER;
    MediaType: MEDIA_TYPE;
    TracksPerCylinder: DWORD;
    SectorsPerTrack: DWORD;
    BytesPerSector: DWORD;
  end;
  {$EXTERNALSYM _DISK_GEOMETRY}
  DISK_GEOMETRY = _DISK_GEOMETRY;
  {$EXTERNALSYM DISK_GEOMETRY}
  TDiskGeometry = DISK_GEOMETRY;
  PDiskGeometry = PDISK_GEOMETRY;

//
// This wmi guid returns a DISK_GEOMETRY structure
//

const
  WMI_DISK_GEOMETRY_GUID: TGUID = (
    D1:$25007f51; D2:$57c2; D3:$11d1; D4:($a5, $28, $00, $a0, $c9, $06, $29, $10));
  {$EXTERNALSYM WMI_DISK_GEOMETRY_GUID}

//
// The following structure is returned on an IOCTL_DISK_GET_PARTITION_INFO
// and an IOCTL_DISK_GET_DRIVE_LAYOUT request.  It is also used in a request
// to change the drive layout, IOCTL_DISK_SET_DRIVE_LAYOUT.
//

type
  PPARTITION_INFORMATION = ^PARTITION_INFORMATION;
  {$EXTERNALSYM PPARTITION_INFORMATION}
  _PARTITION_INFORMATION = record
    StartingOffset: LARGE_INTEGER;
    PartitionLength: LARGE_INTEGER;
    HiddenSectors: DWORD;
    PartitionNumber: DWORD;
    PartitionType: BYTE;
    BootIndicator: ByteBool;
    RecognizedPartition: ByteBool;
    RewritePartition: ByteBool;
  end;
  {$EXTERNALSYM _PARTITION_INFORMATION}
  PARTITION_INFORMATION = _PARTITION_INFORMATION;
  {$EXTERNALSYM PARTITION_INFORMATION}
  TPartitionInformation = PARTITION_INFORMATION;
  PPartitionInformation = PPARTITION_INFORMATION;

//
// The following structure is used to change the partition type of a
// specified disk partition using an IOCTL_DISK_SET_PARTITION_INFO
// request.
//

  PSET_PARTITION_INFORMATION = ^SET_PARTITION_INFORMATION;
  {$EXTERNALSYM PSET_PARTITION_INFORMATION}
  _SET_PARTITION_INFORMATION = record
    PartitionType: BYTE;
  end;
  {$EXTERNALSYM _SET_PARTITION_INFORMATION}
  SET_PARTITION_INFORMATION = _SET_PARTITION_INFORMATION;
  {$EXTERNALSYM SET_PARTITION_INFORMATION}
  TSetPartitionInformation = _SET_PARTITION_INFORMATION;
  PSetPartitionInformation = PSET_PARTITION_INFORMATION;

//
// The following structures is returned on an IOCTL_DISK_GET_DRIVE_LAYOUT
// request and given as input to an IOCTL_DISK_SET_DRIVE_LAYOUT request.
//

  PDRIVE_LAYOUT_INFORMATION = ^DRIVE_LAYOUT_INFORMATION;
  {$EXTERNALSYM PDRIVE_LAYOUT_INFORMATION}
  _DRIVE_LAYOUT_INFORMATION = record
    PartitionCount: DWORD;
    Signature: DWORD;
    PartitionEntry: array [0..0] of PARTITION_INFORMATION;
  end;
  {$EXTERNALSYM _DRIVE_LAYOUT_INFORMATION}
  DRIVE_LAYOUT_INFORMATION = _DRIVE_LAYOUT_INFORMATION;
  {$EXTERNALSYM DRIVE_LAYOUT_INFORMATION}
  TDriveLayoutInformation = DRIVE_LAYOUT_INFORMATION;
  PDriveLayoutInformation = PDRIVE_LAYOUT_INFORMATION;

//
// The following structure is passed in on an IOCTL_DISK_VERIFY request.
// The offset and length parameters are both given in bytes.
//

  PVERIFY_INFORMATION = ^VERIFY_INFORMATION;
  {$EXTERNALSYM PVERIFY_INFORMATION}
  _VERIFY_INFORMATION = record
    StartingOffset: LARGE_INTEGER;
    Length: DWORD;
  end;
  {$EXTERNALSYM _VERIFY_INFORMATION}
  VERIFY_INFORMATION = _VERIFY_INFORMATION;
  {$EXTERNALSYM VERIFY_INFORMATION}
  TVerifyInformation = VERIFY_INFORMATION;
  PVerifyInformation = PVERIFY_INFORMATION;

//
// The following structure is passed in on an IOCTL_DISK_REASSIGN_BLOCKS
// request.
//

  PREASSIGN_BLOCKS = ^REASSIGN_BLOCKS;
  {$EXTERNALSYM PREASSIGN_BLOCKS}
  _REASSIGN_BLOCKS = record
    Reserved: WORD;
    Count: WORD;
    BlockNumber: array [0..0] of DWORD;
  end;
  {$EXTERNALSYM _REASSIGN_BLOCKS}
  REASSIGN_BLOCKS = _REASSIGN_BLOCKS;
  {$EXTERNALSYM REASSIGN_BLOCKS}
  TReassignBlocks = REASSIGN_BLOCKS;
  PReassignBlocks = PREASSIGN_BLOCKS;

//
// Support for GUID Partition Table (GPT) disks.
//

//
// There are currently two ways a disk can be partitioned. With a traditional
// AT-style master boot record (PARTITION_STYLE_MBR) and with a new, GPT
// partition table (PARTITION_STYLE_GPT). RAW is for an unrecognizable
// partition style. There are a very limited number of things you can
// do with a RAW partititon.
//

type
  _PARTITION_STYLE = (
    PARTITION_STYLE_MBR,
    PARTITION_STYLE_GPT,
    PARTITION_STYLE_RAW);
  {$EXTERNALSYM _PARTITION_STYLE}
  PARTITION_STYLE = _PARTITION_STYLE;
  {$EXTERNALSYM PARTITION_STYLE}
  TPartitionStyle = PARTITION_STYLE;

//
// The following structure defines information in a GPT partition that is
// not common to both GPT and MBR partitions.
//

  PPARTITION_INFORMATION_GPT = ^PARTITION_INFORMATION_GPT;
  {$EXTERNALSYM PPARTITION_INFORMATION_GPT}
  _PARTITION_INFORMATION_GPT = record
    PartitionType: GUID; // Partition type. See table 16-3.
    PartitionId: GUID; // Unique GUID for this partition.
    Attributes: DWORD64; // See table 16-4.
    Name: array [0..35] of WCHAR; // Partition Name in Unicode.
  end;
  {$EXTERNALSYM _PARTITION_INFORMATION_GPT}
  PARTITION_INFORMATION_GPT = _PARTITION_INFORMATION_GPT;
  {$EXTERNALSYM PARTITION_INFORMATION_GPT}
  TPartitionInformationGpt = PARTITION_INFORMATION_GPT;
  PPartitionInformationGpt = PPARTITION_INFORMATION_GPT;

//
//  The following are GPT partition attributes applicable for any
//  partition type. These attributes are not OS-specific
//

const
  GPT_ATTRIBUTE_PLATFORM_REQUIRED = $0000000000000001;
  {$EXTERNALSYM GPT_ATTRIBUTE_PLATFORM_REQUIRED}

//
// The following are GPT partition attributes applicable when the
// PartitionType is PARTITION_BASIC_DATA_GUID.
//

  GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER = DWORD($8000000000000000);
  {$EXTERNALSYM GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER}
  GPT_BASIC_DATA_ATTRIBUTE_HIDDEN          = $4000000000000000;
  {$EXTERNALSYM GPT_BASIC_DATA_ATTRIBUTE_HIDDEN}
  GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY       = $1000000000000000;
  {$EXTERNALSYM GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY}

//
// The following structure defines information in an MBR partition that is not
// common to both GPT and MBR partitions.
//

type
  PPARTITION_INFORMATION_MBR = ^PARTITION_INFORMATION_MBR;
  {$EXTERNALSYM PPARTITION_INFORMATION_MBR}
  _PARTITION_INFORMATION_MBR = record
    PartitionType: BYTE;
    BootIndicator: BOOLEAN;
    RecognizedPartition: BOOLEAN;
    HiddenSectors: DWORD;
  end;
  {$EXTERNALSYM _PARTITION_INFORMATION_MBR}
  PARTITION_INFORMATION_MBR = _PARTITION_INFORMATION_MBR;
  {$EXTERNALSYM PARTITION_INFORMATION_MBR}
  TPartitionInformationMbr = PARTITION_INFORMATION_MBR;
  PPartitionInformationMbr = PPARTITION_INFORMATION_MBR;

//
// The structure SET_PARTITION_INFO_EX is used with the ioctl
// IOCTL_SET_PARTITION_INFO_EX to set information about a specific
// partition. Note that for MBR partitions, you can only set the partition
// signature, whereas GPT partitions allow setting of all fields that
// you can get.
//

  SET_PARTITION_INFORMATION_MBR = SET_PARTITION_INFORMATION;
  {$EXTERNALSYM SET_PARTITION_INFORMATION_MBR}
  TSetPartitionInformationMbr = SET_PARTITION_INFORMATION_MBR;
  SET_PARTITION_INFORMATION_GPT = PARTITION_INFORMATION_GPT;
  {$EXTERNALSYM SET_PARTITION_INFORMATION_GPT}
  TSetPartitionInformationGpt = SET_PARTITION_INFORMATION_GPT;

  PSET_PARTITION_INFORMATION_EX = ^SET_PARTITION_INFORMATION_EX;
  {$EXTERNALSYM PSET_PARTITION_INFORMATION_EX}
  _SET_PARTITION_INFORMATION_EX = record
    PartitionStyle: PARTITION_STYLE;
    case Integer of
      0: (Mbr: SET_PARTITION_INFORMATION_MBR);
      1: (Gpt: SET_PARTITION_INFORMATION_GPT);
  end;
  {$EXTERNALSYM _SET_PARTITION_INFORMATION_EX}
  SET_PARTITION_INFORMATION_EX = _SET_PARTITION_INFORMATION_EX;
  {$EXTERNALSYM SET_PARTITION_INFORMATION_EX}
  TSetPartitionInformationEx = SET_PARTITION_INFORMATION_EX;
  PSetPartitionInformationEx = PSET_PARTITION_INFORMATION_EX;

//
// The structure CREATE_DISK_GPT with the ioctl IOCTL_DISK_CREATE_DISK
// to initialize an virgin disk with an empty GPT partition table.
//

  PCREATE_DISK_GPT = ^CREATE_DISK_GPT;
  {$EXTERNALSYM PCREATE_DISK_GPT}
  _CREATE_DISK_GPT = record
    DiskId: GUID; // Unique disk id for the disk.
    MaxPartitionCount: DWORD; // Maximim number of partitions allowable.
  end;
  {$EXTERNALSYM _CREATE_DISK_GPT}
  CREATE_DISK_GPT = _CREATE_DISK_GPT;
  {$EXTERNALSYM CREATE_DISK_GPT}
  TCreateDiskGpt = CREATE_DISK_GPT;
  PCreateDiskGpt = PCREATE_DISK_GPT;

//
// The structure CREATE_DISK_MBR with the ioctl IOCTL_DISK_CREATE_DISK
// to initialize an virgin disk with an empty MBR partition table.
//

  PCREATE_DISK_MBR = ^CREATE_DISK_MBR;
  {$EXTERNALSYM PCREATE_DISK_MBR}
  _CREATE_DISK_MBR = record
    Signature: DWORD;
  end;
  {$EXTERNALSYM _CREATE_DISK_MBR}
  CREATE_DISK_MBR = _CREATE_DISK_MBR;
  {$EXTERNALSYM CREATE_DISK_MBR}
  TCreateDiskMbr = CREATE_DISK_MBR;
  PCreateDiskMbr = PCREATE_DISK_MBR;

  PCREATE_DISK = ^CREATE_DISK;
  {$EXTERNALSYM PCREATE_DISK}
  _CREATE_DISK = record
    PartitionStyle: PARTITION_STYLE;
    case Integer of
      0: (Mbr: CREATE_DISK_MBR);
      1: (Gpt: CREATE_DISK_GPT);
  end;
  {$EXTERNALSYM _CREATE_DISK}
  CREATE_DISK = _CREATE_DISK;
  {$EXTERNALSYM CREATE_DISK}
  TCreateDisk = CREATE_DISK;
  PCreateDisk = PCREATE_DISK;

//
// The structure GET_LENGTH_INFORMATION is used with the ioctl
// IOCTL_DISK_GET_LENGTH_INFO to obtain the length, in bytes, of the
// disk, partition, or volume.
//

  PGET_LENGTH_INFORMATION = ^GET_LENGTH_INFORMATION;
  {$EXTERNALSYM PGET_LENGTH_INFORMATION}
  _GET_LENGTH_INFORMATION = record
    Length: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _GET_LENGTH_INFORMATION}
  GET_LENGTH_INFORMATION = _GET_LENGTH_INFORMATION;
  {$EXTERNALSYM GET_LENGTH_INFORMATION}
  TGetLengthInformation = GET_LENGTH_INFORMATION;
  PGetLengthInformation = PGET_LENGTH_INFORMATION;

//
// The PARTITION_INFORMATION_EX structure is used with the
// IOCTL_DISK_GET_DRIVE_LAYOUT_EX, IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
// IOCTL_DISK_GET_PARTITION_INFO_EX and IOCTL_DISK_GET_PARTITION_INFO_EX calls.
//

  PPARTITION_INFORMATION_EX = ^PARTITION_INFORMATION_EX;
  {$EXTERNALSYM PPARTITION_INFORMATION_EX}
  _PARTITION_INFORMATION_EX = record
    PartitionStyle: PARTITION_STYLE;
    StartingOffset: LARGE_INTEGER;
    PartitionLength: LARGE_INTEGER;
    PartitionNumber: DWORD;
    RewritePartition: BOOLEAN;
    case Integer of
      0: (Mbr: PARTITION_INFORMATION_MBR);
      1: (Gpt: PARTITION_INFORMATION_GPT);
  end;
  {$EXTERNALSYM _PARTITION_INFORMATION_EX}
  PARTITION_INFORMATION_EX = _PARTITION_INFORMATION_EX;
  {$EXTERNALSYM PARTITION_INFORMATION_EX}
  TPartitionInformationEx = PARTITION_INFORMATION_EX;
  PPartitionInformationEx = PPARTITION_INFORMATION_EX;

//
// GPT specific drive layout information.
//

  PDRIVE_LAYOUT_INFORMATION_GPT = ^DRIVE_LAYOUT_INFORMATION_GPT;
  {$EXTERNALSYM PDRIVE_LAYOUT_INFORMATION_GPT}
  _DRIVE_LAYOUT_INFORMATION_GPT = record
    DiskId: GUID;
    StartingUsableOffset: LARGE_INTEGER;
    UsableLength: LARGE_INTEGER;
    MaxPartitionCount: DWORD;
  end;
  {$EXTERNALSYM _DRIVE_LAYOUT_INFORMATION_GPT}
  DRIVE_LAYOUT_INFORMATION_GPT = _DRIVE_LAYOUT_INFORMATION_GPT;
  {$EXTERNALSYM DRIVE_LAYOUT_INFORMATION_GPT}
  TDriveLayoutInformationGpt = DRIVE_LAYOUT_INFORMATION_GPT;
  PDriveLayoutInformationGpt = PDRIVE_LAYOUT_INFORMATION_GPT;

//
// MBR specific drive layout information.
//

  PDRIVE_LAYOUT_INFORMATION_MBR = ^DRIVE_LAYOUT_INFORMATION_MBR;
  {$EXTERNALSYM PDRIVE_LAYOUT_INFORMATION_MBR}
  _DRIVE_LAYOUT_INFORMATION_MBR = record
    Signature: DWORD;
  end;
  {$EXTERNALSYM _DRIVE_LAYOUT_INFORMATION_MBR}
  DRIVE_LAYOUT_INFORMATION_MBR = _DRIVE_LAYOUT_INFORMATION_MBR;
  {$EXTERNALSYM DRIVE_LAYOUT_INFORMATION_MBR}
  TDriveLayoutInformationMbr = DRIVE_LAYOUT_INFORMATION_MBR;
  PDriveLayoutInformationMbr = PDRIVE_LAYOUT_INFORMATION_MBR;

//
// The structure DRIVE_LAYOUT_INFORMATION_EX is used with the
// IOCTL_SET_DRIVE_LAYOUT_EX and IOCTL_GET_DRIVE_LAYOUT_EX calls.
//

  PDRIVE_LAYOUT_INFORMATION_EX = ^DRIVE_LAYOUT_INFORMATION_EX;
  {$EXTERNALSYM PDRIVE_LAYOUT_INFORMATION_EX}
  _DRIVE_LAYOUT_INFORMATION_EX = record
    PartitionStyle: DWORD;
    PartitionCount: DWORD;
    Union: record
      case Integer of
        0: (Mbr: DRIVE_LAYOUT_INFORMATION_MBR);
        1: (Gpt: DRIVE_LAYOUT_INFORMATION_GPT);
    end;
    PartitionEntry: array [0..0] of PARTITION_INFORMATION_EX;
  end;
  {$EXTERNALSYM _DRIVE_LAYOUT_INFORMATION_EX}
  DRIVE_LAYOUT_INFORMATION_EX = _DRIVE_LAYOUT_INFORMATION_EX;
  {$EXTERNALSYM DRIVE_LAYOUT_INFORMATION_EX}
  TDriveLayoutInformationEx = DRIVE_LAYOUT_INFORMATION_EX;
  PDriveLayoutInformationEx = PDRIVE_LAYOUT_INFORMATION_EX;

//
// The DISK_GEOMETRY_EX structure is returned on issuing an
// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX ioctl.
//

  _DETECTION_TYPE = (
    DetectNone,
    DetectInt13,
    DetectExInt13);
  {$EXTERNALSYM _DETECTION_TYPE}
  DETECTION_TYPE = _DETECTION_TYPE;
  {$EXTERNALSYM DETECTION_TYPE}
  TDetectionType = DETECTION_TYPE;

  PDISK_INT13_INFO = ^DISK_INT13_INFO;
  {$EXTERNALSYM PDISK_INT13_INFO}
  _DISK_INT13_INFO = record
    DriveSelect: WORD;
    MaxCylinders: DWORD;
    SectorsPerTrack: WORD;
    MaxHeads: WORD;
    NumberDrives: WORD;
  end;
  {$EXTERNALSYM _DISK_INT13_INFO}
  DISK_INT13_INFO = _DISK_INT13_INFO;
  {$EXTERNALSYM DISK_INT13_INFO}
  TDiskInt13Info = DISK_INT13_INFO;
  PDiskInt13Info = PDISK_INT13_INFO;

  PDISK_EX_INT13_INFO = ^DISK_EX_INT13_INFO;
  {$EXTERNALSYM PDISK_EX_INT13_INFO}
  _DISK_EX_INT13_INFO = record
    ExBufferSize: WORD;
    ExFlags: WORD;
    ExCylinders: DWORD;
    ExHeads: DWORD;
    ExSectorsPerTrack: DWORD;
    ExSectorsPerDrive: DWORD64;
    ExSectorSize: WORD;
    ExReserved: WORD;
  end;
  {$EXTERNALSYM _DISK_EX_INT13_INFO}
  DISK_EX_INT13_INFO = _DISK_EX_INT13_INFO;
  {$EXTERNALSYM DISK_EX_INT13_INFO}
  TDiskExInt13Info = DISK_EX_INT13_INFO;
  PDiskExInt13Info = PDISK_EX_INT13_INFO;

  PDISK_DETECTION_INFO = ^DISK_DETECTION_INFO;
  {$EXTERNALSYM PDISK_DETECTION_INFO}
  _DISK_DETECTION_INFO = record
    SizeOfDetectInfo: DWORD;
    DetectionType: DETECTION_TYPE;
    case Integer of
      0: (
        //
        // If DetectionType == DETECTION_INT13 then we have just the Int13
        // information.
        //
        Int13: DISK_INT13_INFO;
        //
        // If DetectionType == DETECTION_EX_INT13, then we have the
        // extended int 13 information.
        //
        ExInt13: DISK_EX_INT13_INFO); // If DetectionType == DetectExInt13
  end;
  {$EXTERNALSYM _DISK_DETECTION_INFO}
  DISK_DETECTION_INFO = _DISK_DETECTION_INFO;
  {$EXTERNALSYM DISK_DETECTION_INFO}
  TDiskDetectionInfo = DISK_DETECTION_INFO;
  PDiskDetectionInfo = PDISK_DETECTION_INFO;

  PDISK_PARTITION_INFO = ^DISK_PARTITION_INFO;
  {$EXTERNALSYM PDISK_PARTITION_INFO}
  _DISK_PARTITION_INFO = record
    SizeOfPartitionInfo: DWORD;
    PartitionStyle: PARTITION_STYLE; // PartitionStyle = RAW, GPT or MBR
    case Integer of
      0: (                           // If PartitionStyle == MBR
        Signature: DWORD; // MBR Signature
        CheckSum: DWORD); // MBR CheckSum
      1: (                           // If PartitionStyle == GPT
        DiskId: GUID);
  end;
  {$EXTERNALSYM _DISK_PARTITION_INFO}
  DISK_PARTITION_INFO = _DISK_PARTITION_INFO;
  {$EXTERNALSYM DISK_PARTITION_INFO}
  TDiskPartitionInfo = DISK_PARTITION_INFO;
  PDiskPartitionInfo = PDISK_PARTITION_INFO;

//
// The Geometry structure is a variable length structure composed of a
// DISK_GEOMETRY_EX structure followed by a DISK_PARTITION_INFO structure
// followed by a DISK_DETECTION_DATA structure.
//

type
  PDISK_GEOMETRY_EX = ^DISK_GEOMETRY_EX;
  {$EXTERNALSYM PDISK_GEOMETRY_EX}
  _DISK_GEOMETRY_EX = record
    Geometry: DISK_GEOMETRY;    // Standard disk geometry: may be faked by driver.
    DiskSize: LARGE_INTEGER;    // Must always be correct
    Data: array [0..0] of BYTE; // Partition, Detect info
  end;
  {$EXTERNALSYM _DISK_GEOMETRY_EX}
  DISK_GEOMETRY_EX = _DISK_GEOMETRY_EX;
  {$EXTERNALSYM DISK_GEOMETRY_EX}
  TDiskGeometryEx = DISK_GEOMETRY_EX;
  PDiskGeometryEx = PDISK_GEOMETRY_EX;

function DiskGeometryGetPartition(Geometry: PDiskGeometryEx): PDiskPartitionInfo;
{$EXTERNALSYM DiskGeometryGetPartition}

function DiskGeometryGetDetect(Geometry: PDiskGeometryEx): PDiskDetectionInfo;
{$EXTERNALSYM DiskGeometryGetDetect}

//
// IOCTL_DISK_CONTROLLER_NUMBER returns the controller and disk
// number for the handle.  This is used to determine if a disk
// is attached to the primary or secondary IDE controller.
//
type
  PDISK_CONTROLLER_NUMBER = ^DISK_CONTROLLER_NUMBER;
  {$EXTERNALSYM PDISK_CONTROLLER_NUMBER}
  _DISK_CONTROLLER_NUMBER = record
    ControllerNumber: DWORD;
    DiskNumber: DWORD;
  end;
  {$EXTERNALSYM _DISK_CONTROLLER_NUMBER}
  DISK_CONTROLLER_NUMBER = _DISK_CONTROLLER_NUMBER;
  {$EXTERNALSYM DISK_CONTROLLER_NUMBER}
  TDiskControllerNumber = DISK_CONTROLLER_NUMBER;
  PDiskControllerNumber = PDISK_CONTROLLER_NUMBER;

//
// IOCTL_DISK_SET_CACHE allows the caller to get or set the state of the disk
// read/write caches.
//
// If the structure is provided as the input buffer for the ioctl the read &
// write caches will be enabled or disabled depending on the parameters
// provided.
//
// If the structure is provided as an output buffer for the ioctl the state
// of the read & write caches will be returned. If both input and outut buffers
// are provided the output buffer will contain the cache state BEFORE any
// changes are made
//

  DISK_CACHE_RETENTION_PRIORITY = (EqualPriority, KeepPrefetchedData, KeepReadData);
  {$EXTERNALSYM DISK_CACHE_RETENTION_PRIORITY}
  TDiskCacheRetentionPriority = DISK_CACHE_RETENTION_PRIORITY;

  TDCIScalarPrefetch = record
    Minimum: WORD;
    Maximum: WORD;
    //
    // The maximum number of blocks which will be prefetched - useful
    // with the scalar limits to set definite upper limits.
    //
    MaximumBlocks: WORD;
  end;

  TDCIBlockPrefetch = record
    Minimum: WORD;
    Maximum: WORD;
  end;

  PDISK_CACHE_INFORMATION = ^DISK_CACHE_INFORMATION;
  {$EXTERNALSYM PDISK_CACHE_INFORMATION}
  _DISK_CACHE_INFORMATION = record

    //
    // on return indicates that the device is capable of saving any parameters
    // in non-volatile storage.  On send indicates that the device should
    // save the state in non-volatile storage.
    //

    ParametersSavable: ByteBool;

    //
    // Indicates whether the write and read caches are enabled.
    //

    ReadCacheEnabled: ByteBool;
    WriteCacheEnabled: ByteBool;

    //
    // Controls the likelyhood of data remaining in the cache depending on how
    // it got there.  Data cached from a READ or WRITE operation may be given
    // higher, lower or equal priority to data entered into the cache for other
    // means (like prefetch)
    //

    ReadRetentionPriority: DISK_CACHE_RETENTION_PRIORITY;
    WriteRetentionPriority: DISK_CACHE_RETENTION_PRIORITY;

    //
    // Requests for a larger number of blocks than this may have prefetching
    // disabled.  If this value is set to 0 prefetch will be disabled.
    //

    DisablePrefetchTransferLength: WORD;

    //
    // If TRUE then ScalarPrefetch (below) will be valid.  If FALSE then
    // the minimum and maximum values should be treated as a block count
    // (BlockPrefetch)
    //

    PrefetchScalar: ByteBool;

    //
    // Contains the minimum and maximum amount of data which will be
    // will be prefetched into the cache on a disk operation.  This value
    // may either be a scalar multiplier of the transfer length of the request,
    // or an abolute number of disk blocks.  PrefetchScalar (above) indicates
    // which interpretation is used.
    //

    case Integer of
      0: (ScalarPrefetch: TDCIScalarPrefetch);
      1: (BlockPrefetch: TDCIBlockPrefetch);

  end;
  {$EXTERNALSYM _DISK_CACHE_INFORMATION}
  DISK_CACHE_INFORMATION = _DISK_CACHE_INFORMATION;
  {$EXTERNALSYM DISK_CACHE_INFORMATION}
  TDiskCacheInformation = DISK_CACHE_INFORMATION;
  PDiskCacheInformation = PDISK_CACHE_INFORMATION;

//
// IOCTL_DISK_GROW_PARTITION will update the size of a partition
// by adding sectors to the length. The number of sectors must be
// predetermined by examining PARTITION_INFORMATION.
//

  PDISK_GROW_PARTITION = ^DISK_GROW_PARTITION;
  {$EXTERNALSYM PDISK_GROW_PARTITION}
  _DISK_GROW_PARTITION = record
    PartitionNumber: DWORD;
    BytesToGrow: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _DISK_GROW_PARTITION}
  DISK_GROW_PARTITION = _DISK_GROW_PARTITION;
  {$EXTERNALSYM DISK_GROW_PARTITION}
  TDiskGrowPartition = DISK_GROW_PARTITION;
  PDiskGrowPartition = PDISK_GROW_PARTITION;

///////////////////////////////////////////////////////
//                                                   //
// The following structures define disk performance  //
// statistics: specifically the locations of all the //
// reads and writes which have occured on the disk.  //
//                                                   //
// To use these structures, you must issue an IOCTL_ //
// DISK_HIST_STRUCTURE (with a DISK_HISTOGRAM) to    //
// obtain the basic histogram information. The       //
// number of buckets which must allocated is part of //
// this structure. Allocate the required number of   //
// buckets and call an IOCTL_DISK_HIST_DATA to fill  //
// in the data                                       //
//                                                   //
///////////////////////////////////////////////////////

const
  HIST_NO_OF_BUCKETS = 24;
  {$EXTERNALSYM HIST_NO_OF_BUCKETS}

type
  PHISTOGRAM_BUCKET = ^HISTOGRAM_BUCKET;
  {$EXTERNALSYM PHISTOGRAM_BUCKET}
  _HISTOGRAM_BUCKET = record
    Reads: DWORD;
    Writes: DWORD;
  end;
  {$EXTERNALSYM _HISTOGRAM_BUCKET}
  HISTOGRAM_BUCKET = _HISTOGRAM_BUCKET;
  {$EXTERNALSYM HISTOGRAM_BUCKET}
  THistogramBucket = HISTOGRAM_BUCKET;
  PHistogramBucket = PHISTOGRAM_BUCKET;

const
  HISTOGRAM_BUCKET_SIZE = SizeOf(HISTOGRAM_BUCKET);
  {$EXTERNALSYM HISTOGRAM_BUCKET_SIZE}

type
  PDISK_HISTOGRAM = ^DISK_HISTOGRAM;
  {$EXTERNALSYM PDISK_HISTOGRAM}
  _DISK_HISTOGRAM = record
    DiskSize: LARGE_INTEGER;
    Start: LARGE_INTEGER;
    End_: LARGE_INTEGER;
    Average: LARGE_INTEGER;
    AverageRead: LARGE_INTEGER;
    AverageWrite: LARGE_INTEGER;
    Granularity: DWORD;
    Size: DWORD;
    ReadCount: DWORD;
    WriteCount: DWORD;
    Histogram: PHISTOGRAM_BUCKET;
  end;
  {$EXTERNALSYM _DISK_HISTOGRAM}
  DISK_HISTOGRAM = _DISK_HISTOGRAM;
  {$EXTERNALSYM DISK_HISTOGRAM}
  TDiskHistogram = DISK_HISTOGRAM;
  PDiskHistogram = PDISK_HISTOGRAM;

const
  DISK_HISTOGRAM_SIZE = SizeOf(DISK_HISTOGRAM);
  {$EXTERNALSYM DISK_HISTOGRAM_SIZE}

///////////////////////////////////////////////////////
//                                                   //
// The following structures define disk debugging    //
// capabilities. The IOCTLs are directed to one of   //
// the two disk filter drivers.                      //
//                                                   //
// DISKPERF is a utilty for collecting disk request  //
// statistics.                                       //
//                                                   //
// SIMBAD is a utility for injecting faults in       //
// IO requests to disks.                             //
//                                                   //
///////////////////////////////////////////////////////

//
// The following structure is exchanged on an IOCTL_DISK_GET_PERFORMANCE
// request. This ioctl collects summary disk request statistics used
// in measuring performance.
//

type
  PDISK_PERFORMANCE = ^DISK_PERFORMANCE;
  {$EXTERNALSYM PDISK_PERFORMANCE}
  _DISK_PERFORMANCE = record
    BytesRead: LARGE_INTEGER;
    BytesWritten: LARGE_INTEGER;
    ReadTime: LARGE_INTEGER;
    WriteTime: LARGE_INTEGER;
    IdleTime: LARGE_INTEGER;
    ReadCount: DWORD;
    WriteCount: DWORD;
    QueueDepth: DWORD;
    SplitCount: DWORD;
    QueryTime: LARGE_INTEGER;
    StorageDeviceNumber: DWORD;
    StorageManagerName: array [0..7] of WCHAR;
  end;
  {$EXTERNALSYM _DISK_PERFORMANCE}
  DISK_PERFORMANCE = _DISK_PERFORMANCE;
  {$EXTERNALSYM DISK_PERFORMANCE}
  TDiskPerformance = DISK_PERFORMANCE;
  PDiskPerformance = PDISK_PERFORMANCE;

//
// This structure defines the disk logging record. When disk logging
// is enabled, one of these is written to an internal buffer for each
// disk request.
//

  PDISK_RECORD = ^DISK_RECORD;
  {$EXTERNALSYM PDISK_RECORD}
  _DISK_RECORD = record
    ByteOffset: LARGE_INTEGER;
    StartTime: LARGE_INTEGER;
    EndTime: LARGE_INTEGER;
    VirtualAddress: PVOID;
    NumberOfBytes: DWORD;
    DeviceNumber: BYTE;
    ReadRequest: ByteBool;
  end;
  {$EXTERNALSYM _DISK_RECORD}
  DISK_RECORD = _DISK_RECORD;
  {$EXTERNALSYM DISK_RECORD}
  TDiskRecord = DISK_RECORD;
  PDiskRecord = PDISK_RECORD;

//
// The following structure is exchanged on an IOCTL_DISK_LOG request.
// Not all fields are valid with each function type.
//

  PDISK_LOGGING = ^DISK_LOGGING;
  {$EXTERNALSYM PDISK_LOGGING}
  _DISK_LOGGING = record
    Function_: BYTE;
    BufferAddress: PVOID;
    BufferSize: DWORD;
  end;
  {$EXTERNALSYM _DISK_LOGGING}
  DISK_LOGGING = _DISK_LOGGING;
  {$EXTERNALSYM DISK_LOGGING}
  TDiskLogging = DISK_LOGGING;
  PDiskLogging = PDISK_LOGGING;

//
// Disk logging functions
//
// Start disk logging. Only the Function and BufferSize fields are valid.
//

const
  DISK_LOGGING_START = 0;
  {$EXTERNALSYM DISK_LOGGING_START}

//
// Stop disk logging. Only the Function field is valid.
//

  DISK_LOGGING_STOP = 1;
  {$EXTERNALSYM DISK_LOGGING_STOP}

//
// Return disk log. All fields are valid. Data will be copied from internal
// buffer to buffer specified for the number of bytes requested.
//

  DISK_LOGGING_DUMP = 2;
  {$EXTERNALSYM DISK_LOGGING_DUMP}

//
// DISK BINNING
//
// DISKPERF will keep counters for IO that falls in each of these ranges.
// The application determines the number and size of the ranges.
// Joe Lin wanted me to keep it flexible as possible, for instance, IO
// sizes are interesting in ranges like 0-4096, 4097-16384, 16385-65536, 65537+.
//

  DISK_BINNING = 3;
  {$EXTERNALSYM DISK_BINNING}

//
// Bin types
//

type
  _BIN_TYPES = (RequestSize, RequestLocation);
  {$EXTERNALSYM _BIN_TYPES}
  BIN_TYPES = _BIN_TYPES;
  {$EXTERNALSYM BIN_TYPES}
  TBinTypes = _BIN_TYPES;

//
// Bin ranges
//

  PBIN_RANGE = ^BIN_RANGE;
  {$EXTERNALSYM PBIN_RANGE}
  _BIN_RANGE = record
    StartValue: LARGE_INTEGER;
    Length: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _BIN_RANGE}
  BIN_RANGE = _BIN_RANGE;
  {$EXTERNALSYM BIN_RANGE}
  TBinRange = BIN_RANGE;
  PBinRange = PBIN_RANGE;

//
// Bin definition
//

  PPERF_BIN = ^PERF_BIN;
  {$EXTERNALSYM PPERF_BIN}
  _PERF_BIN = record
    NumberOfBins: DWORD;
    TypeOfBin: DWORD;
    BinsRanges: array [0..0] of BIN_RANGE;
  end;
  {$EXTERNALSYM _PERF_BIN}
  PERF_BIN = _PERF_BIN;
  {$EXTERNALSYM PERF_BIN}
  TPerfBin = PERF_BIN;
  PPerfBin = PPERF_BIN;

//
// Bin count
//

  PBIN_COUNT = ^BIN_COUNT;
  {$EXTERNALSYM PBIN_COUNT}
  _BIN_COUNT = record
    BinRange: BIN_RANGE;
    BinCount: DWORD;
  end;
  {$EXTERNALSYM _BIN_COUNT}
  BIN_COUNT = _BIN_COUNT;
  {$EXTERNALSYM BIN_COUNT}
  TBinCount = BIN_COUNT;
  PBinCount = PBIN_COUNT;

//
// Bin results
//

  PBIN_RESULTS = ^BIN_RESULTS;
  {$EXTERNALSYM PBIN_RESULTS}
  _BIN_RESULTS = record
    NumberOfBins: DWORD;
    BinCounts: array [0..0] of BIN_COUNT;
  end;
  {$EXTERNALSYM _BIN_RESULTS}
  BIN_RESULTS = _BIN_RESULTS;
  {$EXTERNALSYM BIN_RESULTS}
  TBinResults = BIN_RESULTS;
  PBinResults = PBIN_RESULTS;

//
// Data structures for SMART drive fault prediction.
//
// GETVERSIONINPARAMS contains the data returned from the
// Get Driver Version function.
//

//#include <pshpack1.h>

  LPGETVERSIONINPARAMS = ^GETVERSIONINPARAMS;
  {$EXTERNALSYM LPGETVERSIONINPARAMS}
  _GETVERSIONINPARAMS = packed record
    bVersion: BYTE;                    // Binary driver version.
    bRevision: BYTE;                   // Binary driver revision.
    bReserved: BYTE;                   // Not used.
    bIDEDeviceMap: BYTE;               // Bit map of IDE devices.
    fCapabilities: DWORD;              // Bit mask of driver capabilities.
    dwReserved: array [0..3] of DWORD; // For future use.
  end;
  {$EXTERNALSYM _GETVERSIONINPARAMS}
  GETVERSIONINPARAMS = _GETVERSIONINPARAMS;
  {$EXTERNALSYM GETVERSIONINPARAMS}
  TGetVersionInParams = GETVERSIONINPARAMS;
  PGetVersionInParams = LPGETVERSIONINPARAMS;

//#include <poppack.h>

//
// Bits returned in the fCapabilities member of GETVERSIONINPARAMS
//

const
  CAP_ATA_ID_CMD   = 1;         // ATA ID command supported
  {$EXTERNALSYM CAP_ATA_ID_CMD}
  CAP_ATAPI_ID_CMD = 2;         // ATAPI ID command supported
  {$EXTERNALSYM CAP_ATAPI_ID_CMD}
  CAP_SMART_CMD    = 4;         // SMART commannds supported
  {$EXTERNALSYM CAP_SMART_CMD}

//
// IDE registers
//

//#include <pshpack1.h>

type
  LPIDEREGS = ^IDEREGS;
  {$EXTERNALSYM LPIDEREGS}
  _IDEREGS = packed record
    bFeaturesReg: BYTE;     // Used for specifying SMART "commands".
    bSectorCountReg: BYTE;  // IDE sector count register
    bSectorNumberReg: BYTE; // IDE sector number register
    bCylLowReg: BYTE;       // IDE low order cylinder value
    bCylHighReg: BYTE;      // IDE high order cylinder value
    bDriveHeadReg: BYTE;    // IDE drive/head register
    bCommandReg: BYTE;      // Actual IDE command.
    bReserved: BYTE;        // reserved for future use.  Must be zero.
  end;
  {$EXTERNALSYM _IDEREGS}
  IDEREGS = _IDEREGS;
  {$EXTERNALSYM IDEREGS}
  TIdeRegs = IDEREGS;
  PIdeRegs = LPIDEREGS;

//#include <poppack.h>

//
// Valid values for the bCommandReg member of IDEREGS.
//

const
  ATAPI_ID_CMD = $A1;       // Returns ID sector for ATAPI.
  {$EXTERNALSYM ATAPI_ID_CMD}
  ID_CMD       = $EC;       // Returns ID sector for ATA.
  {$EXTERNALSYM ID_CMD}
  SMART_CMD    = $B0;       // Performs SMART cmd.
                            // Requires valid bFeaturesReg,
                            // bCylLowReg, and bCylHighReg
  {$EXTERNALSYM SMART_CMD}

//
// Cylinder register defines for SMART command
//

  SMART_CYL_LOW = $4F;
  {$EXTERNALSYM SMART_CYL_LOW}
  SMART_CYL_HI  = $C2;
  {$EXTERNALSYM SMART_CYL_HI}

//
// SENDCMDINPARAMS contains the input parameters for the
// Send Command to Drive function.
//

//#include <pshpack1.h>

type
  LPSENDCMDINPARAMS = ^SENDCMDINPARAMS;
  {$EXTERNALSYM LPSENDCMDINPARAMS}
  _SENDCMDINPARAMS = packed record
    cBufferSize: DWORD;   // Buffer size in bytes
    irDriveRegs: IDEREGS; // Structure with drive register values.
    bDriveNumber: BYTE;   // Physical drive number to send
                          // command to (0,1,2,3).
    bReserved: array [0..2] of BYTE;   // Reserved for future expansion.
    dwReserved: array [0..3] of DWORD; // For future use.
    bBuffer: array [0..0] of BYTE;     // Input buffer.
  end;
  {$EXTERNALSYM _SENDCMDINPARAMS}
  SENDCMDINPARAMS = _SENDCMDINPARAMS;
  {$EXTERNALSYM SENDCMDINPARAMS}
  TSendCmdInParams = SENDCMDINPARAMS;
  PSendCmdInParams = LPSENDCMDINPARAMS;

//#include <poppack.h>

//
// Status returned from driver
//

//#include <pshpack1.h>

  LPDRIVERSTATUS = ^DRIVERSTATUS;
  {$EXTERNALSYM LPDRIVERSTATUS}
  _DRIVERSTATUS = packed record
    bDriverError: BYTE; // Error code from driver,
                        // or 0 if no error.
    bIDEError: BYTE;    // Contents of IDE Error register.
                        // Only valid when bDriverError
                        // is SMART_IDE_ERROR.
    bReserved: array [0..1] of BYTE;   // Reserved for future expansion.
    dwReserved: array [0..1] of DWORD; // Reserved for future expansion.
  end;
  {$EXTERNALSYM _DRIVERSTATUS}
  DRIVERSTATUS = _DRIVERSTATUS;
  {$EXTERNALSYM DRIVERSTATUS}
  TDriverStatus = DRIVERSTATUS;
  PDriverStatus = LPDRIVERSTATUS;

//#include <poppack.h>

//
// bDriverError values
//

const
  SMART_NO_ERROR         = 0; // No error
  {$EXTERNALSYM SMART_NO_ERROR}
  SMART_IDE_ERROR        = 1; // Error from IDE controller
  {$EXTERNALSYM SMART_IDE_ERROR}
  SMART_INVALID_FLAG     = 2; // Invalid command flag
  {$EXTERNALSYM SMART_INVALID_FLAG}
  SMART_INVALID_COMMAND  = 3; // Invalid command byte
  {$EXTERNALSYM SMART_INVALID_COMMAND}
  SMART_INVALID_BUFFER   = 4; // Bad buffer (null, invalid addr..)
  {$EXTERNALSYM SMART_INVALID_BUFFER}
  SMART_INVALID_DRIVE    = 5; // Drive number not valid
  {$EXTERNALSYM SMART_INVALID_DRIVE}
  SMART_INVALID_IOCTL    = 6; // Invalid IOCTL
  {$EXTERNALSYM SMART_INVALID_IOCTL}
  SMART_ERROR_NO_MEM     = 7; // Could not lock user's buffer
  {$EXTERNALSYM SMART_ERROR_NO_MEM}
  SMART_INVALID_REGISTER = 8; // Some IDE Register not valid
  {$EXTERNALSYM SMART_INVALID_REGISTER}
  SMART_NOT_SUPPORTED    = 9; // Invalid cmd flag set
  {$EXTERNALSYM SMART_NOT_SUPPORTED}
  SMART_NO_IDE_DEVICE    = 10; // Cmd issued to device not present
  {$EXTERNALSYM SMART_NO_IDE_DEVICE}
                               // although drive number is valid

//
// SMART sub commands for execute offline diags
//

  SMART_OFFLINE_ROUTINE_OFFLINE   = 0;
  {$EXTERNALSYM SMART_OFFLINE_ROUTINE_OFFLINE}
  SMART_SHORT_SELFTEST_OFFLINE    = 1;
  {$EXTERNALSYM SMART_SHORT_SELFTEST_OFFLINE}
  SMART_EXTENDED_SELFTEST_OFFLINE = 2;
  {$EXTERNALSYM SMART_EXTENDED_SELFTEST_OFFLINE}
  SMART_ABORT_OFFLINE_SELFTEST    = 127;
  {$EXTERNALSYM SMART_ABORT_OFFLINE_SELFTEST}
  SMART_SHORT_SELFTEST_CAPTIVE    = 129;
  {$EXTERNALSYM SMART_SHORT_SELFTEST_CAPTIVE}
  SMART_EXTENDED_SELFTEST_CAPTIVE = 130;
  {$EXTERNALSYM SMART_EXTENDED_SELFTEST_CAPTIVE}

//#include <pshpack1.h>

type
  LPSENDCMDOUTPARAMS = ^SENDCMDOUTPARAMS;
  {$EXTERNALSYM LPSENDCMDOUTPARAMS}
  _SENDCMDOUTPARAMS = packed record
    cBufferSize: DWORD;            // Size of bBuffer in bytes
    DriverStatus: DRIVERSTATUS;    // Driver status structure.
    bBuffer: array [0..0] of BYTE; // Buffer of arbitrary length in which to store the data read from the                                                                                  // drive.
  end;
  {$EXTERNALSYM _SENDCMDOUTPARAMS}
  SENDCMDOUTPARAMS = _SENDCMDOUTPARAMS;
  {$EXTERNALSYM SENDCMDOUTPARAMS}
  TSendCmdOutParams = SENDCMDOUTPARAMS;
  PSendCmdOutParams = LPSENDCMDOUTPARAMS;

//#include <poppack.h>

const
  READ_ATTRIBUTE_BUFFER_SIZE = 512;
  {$EXTERNALSYM READ_ATTRIBUTE_BUFFER_SIZE}
  IDENTIFY_BUFFER_SIZE       = 512;
  {$EXTERNALSYM IDENTIFY_BUFFER_SIZE}
  READ_THRESHOLD_BUFFER_SIZE = 512;
  {$EXTERNALSYM READ_THRESHOLD_BUFFER_SIZE}
  SMART_LOG_SECTOR_SIZE      = 512;
  {$EXTERNALSYM SMART_LOG_SECTOR_SIZE}

//
// Feature register defines for SMART "sub commands"
//

  READ_ATTRIBUTES             = $D0;
  {$EXTERNALSYM READ_ATTRIBUTES}
  READ_THRESHOLDS             = $D1;
  {$EXTERNALSYM READ_THRESHOLDS}
  ENABLE_DISABLE_AUTOSAVE     = $D2;
  {$EXTERNALSYM ENABLE_DISABLE_AUTOSAVE}
  SAVE_ATTRIBUTE_VALUES       = $D3;
  {$EXTERNALSYM SAVE_ATTRIBUTE_VALUES}
  EXECUTE_OFFLINE_DIAGS       = $D4;
  {$EXTERNALSYM EXECUTE_OFFLINE_DIAGS}
  SMART_READ_LOG              = $D5;
  {$EXTERNALSYM SMART_READ_LOG}
  SMART_WRITE_LOG             = $d6;
  {$EXTERNALSYM SMART_WRITE_LOG}
  ENABLE_SMART                = $D8;
  {$EXTERNALSYM ENABLE_SMART}
  DISABLE_SMART               = $D9;
  {$EXTERNALSYM DISABLE_SMART}
  RETURN_SMART_STATUS         = $DA;
  {$EXTERNALSYM RETURN_SMART_STATUS}
  ENABLE_DISABLE_AUTO_OFFLINE = $DB;
  {$EXTERNALSYM ENABLE_DISABLE_AUTO_OFFLINE}

  IOCTL_CHANGER_BASE = FILE_DEVICE_CHANGER;
  {$EXTERNALSYM IOCTL_CHANGER_BASE}

  IOCTL_CHANGER_GET_PARAMETERS = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0000 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_GET_PARAMETERS}

  IOCTL_CHANGER_GET_STATUS = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0001 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_GET_STATUS}

  IOCTL_CHANGER_GET_PRODUCT_DATA = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0002 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_GET_PRODUCT_DATA}

  IOCTL_CHANGER_SET_ACCESS = (
    (IOCTL_CHANGER_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0004 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_SET_ACCESS}

  IOCTL_CHANGER_GET_ELEMENT_STATUS = (
    (IOCTL_CHANGER_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($0005 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_GET_ELEMENT_STATUS}

  IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0006 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS}

  IOCTL_CHANGER_SET_POSITION = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0007 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_SET_POSITION}

  IOCTL_CHANGER_EXCHANGE_MEDIUM = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0008 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_EXCHANGE_MEDIUM}

  IOCTL_CHANGER_MOVE_MEDIUM = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($0009 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_MOVE_MEDIUM}

  IOCTL_CHANGER_REINITIALIZE_TRANSPORT = (
    (IOCTL_CHANGER_BASE shl 16) or (FILE_READ_ACCESS shl 14) or
    ($000A shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_REINITIALIZE_TRANSPORT}

  IOCTL_CHANGER_QUERY_VOLUME_TAGS = (
    (IOCTL_CHANGER_BASE shl 16) or ((FILE_READ_ACCESS or FILE_WRITE_ACCESS) shl 14) or
    ($000B shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_CHANGER_QUERY_VOLUME_TAGS}

  MAX_VOLUME_ID_SIZE       = 36;
  {$EXTERNALSYM MAX_VOLUME_ID_SIZE}
  MAX_VOLUME_TEMPLATE_SIZE = 40;
  {$EXTERNALSYM MAX_VOLUME_TEMPLATE_SIZE}

  VENDOR_ID_LENGTH     = 8;
  {$EXTERNALSYM VENDOR_ID_LENGTH}
  PRODUCT_ID_LENGTH    = 16;
  {$EXTERNALSYM PRODUCT_ID_LENGTH}
  REVISION_LENGTH      = 4;
  {$EXTERNALSYM REVISION_LENGTH}
  SERIAL_NUMBER_LENGTH = 32;
  {$EXTERNALSYM SERIAL_NUMBER_LENGTH}

//
// Common structures describing elements.
//

type
  _ELEMENT_TYPE = (
    AllElements,        // As defined by SCSI
    ChangerTransport,   // As defined by SCSI
    ChangerSlot,        // As defined by SCSI
    ChangerIEPort,      // As defined by SCSI
    ChangerDrive,       // As defined by SCSI
    ChangerDoor,        // Front panel, used to access internal of cabinet.
    ChangerKeypad,      // Keypad/input on front panel.
    ChangerMaxElement); // Placeholder only. Not a valid type.
  {$EXTERNALSYM _ELEMENT_TYPE}
  ELEMENT_TYPE = _ELEMENT_TYPE;
  {$EXTERNALSYM ELEMENT_TYPE}
  PELEMENT_TYPE = ^ELEMENT_TYPE;
  {$EXTERNALSYM PELEMENT_TYPE}
  TElementType = ELEMENT_TYPE;
  PElementType = PELEMENT_TYPE;

  PCHANGER_ELEMENT = ^CHANGER_ELEMENT;
  {$EXTERNALSYM PCHANGER_ELEMENT}
  _CHANGER_ELEMENT = record
    ElementType: ELEMENT_TYPE;
    ElementAddress: DWORD;
  end;
  {$EXTERNALSYM _CHANGER_ELEMENT}
  CHANGER_ELEMENT = _CHANGER_ELEMENT;
  {$EXTERNALSYM CHANGER_ELEMENT}
  TChangerElement = CHANGER_ELEMENT;
  PChangerElement = PCHANGER_ELEMENT;

  PCHANGER_ELEMENT_LIST = ^CHANGER_ELEMENT_LIST;
  {$EXTERNALSYM PCHANGER_ELEMENT_LIST}
  _CHANGER_ELEMENT_LIST = record
    Element: CHANGER_ELEMENT;
    NumberOfElements: DWORD;
  end;
  {$EXTERNALSYM _CHANGER_ELEMENT_LIST}
  CHANGER_ELEMENT_LIST = _CHANGER_ELEMENT_LIST;
  {$EXTERNALSYM CHANGER_ELEMENT_LIST}
  TChangerElementList = CHANGER_ELEMENT_LIST;
  PChangerElementList = PCHANGER_ELEMENT_LIST;

//
// Definitions for  IOCTL_CHANGER_GET_PARAMETERS
//

//
// Definitions for Features0 of GET_CHANGER_PARAMETERS
//

const
  CHANGER_BAR_CODE_SCANNER_INSTALLED  = $00000001; // The medium-changer has a bar code scanner installed.
  {$EXTERNALSYM CHANGER_BAR_CODE_SCANNER_INSTALLED}
  CHANGER_INIT_ELEM_STAT_WITH_RANGE   = $00000002; // The medium-changer has the ability to initialize elements within a specified range.
  {$EXTERNALSYM CHANGER_INIT_ELEM_STAT_WITH_RANGE}
  CHANGER_CLOSE_IEPORT                = $00000004; // The medium-changer has the ability to close the i/e port door.
  {$EXTERNALSYM CHANGER_CLOSE_IEPORT}
  CHANGER_OPEN_IEPORT                 = $00000008; // The medium-changer can open the i/e port door.
  {$EXTERNALSYM CHANGER_OPEN_IEPORT}

  CHANGER_STATUS_NON_VOLATILE         = $00000010; // The medium-changer uses non-volatile memory for element status information.
  {$EXTERNALSYM CHANGER_STATUS_NON_VOLATILE}
  CHANGER_EXCHANGE_MEDIA              = $00000020; // The medium-changer supports exchange operations.
  {$EXTERNALSYM CHANGER_EXCHANGE_MEDIA}
  CHANGER_CLEANER_SLOT                = $00000040; // The medium-changer has a fixed slot designated for cleaner cartridges.
  {$EXTERNALSYM CHANGER_CLEANER_SLOT}
  CHANGER_LOCK_UNLOCK                 = $00000080; // The medium-changer can be (un)secured to (allow)prevent media removal.
  {$EXTERNALSYM CHANGER_LOCK_UNLOCK}

  CHANGER_CARTRIDGE_MAGAZINE          = $00000100; // The medium-changer uses cartridge magazines for some storage slots.
  {$EXTERNALSYM CHANGER_CARTRIDGE_MAGAZINE}
  CHANGER_MEDIUM_FLIP                 = $00000200; // The medium-changer can flip medium.
  {$EXTERNALSYM CHANGER_MEDIUM_FLIP}
  CHANGER_POSITION_TO_ELEMENT         = $00000400; // The medium-changer can position the transport to a particular element.
  {$EXTERNALSYM CHANGER_POSITION_TO_ELEMENT}
  CHANGER_REPORT_IEPORT_STATE         = $00000800; // The medium-changer can determine whether media is present
  {$EXTERNALSYM CHANGER_REPORT_IEPORT_STATE}
                                                   // in the IE Port.

  CHANGER_STORAGE_DRIVE               = $00001000; // The medium-changer can use a drive as an independent storage element.
  {$EXTERNALSYM CHANGER_STORAGE_DRIVE}
  CHANGER_STORAGE_IEPORT              = $00002000; // The medium-changer can use a i/e port as an independent storage element.
  {$EXTERNALSYM CHANGER_STORAGE_IEPORT}
  CHANGER_STORAGE_SLOT                = $00004000; // The medium-changer can use a slot as an independent storage element.
  {$EXTERNALSYM CHANGER_STORAGE_SLOT}
  CHANGER_STORAGE_TRANSPORT           = $00008000; // The medium-changer can use a transport as an independent storage element.
  {$EXTERNALSYM CHANGER_STORAGE_TRANSPORT}

  CHANGER_DRIVE_CLEANING_REQUIRED     = $00010000; // The drives controlled by the medium changer require periodic cleaning
  {$EXTERNALSYM CHANGER_DRIVE_CLEANING_REQUIRED}
                                                   // initiated by an application.

  CHANGER_PREDISMOUNT_EJECT_REQUIRED  = $00020000; // The medium-changer requires a drive eject command to be issued, before a changer
  {$EXTERNALSYM CHANGER_PREDISMOUNT_EJECT_REQUIRED}
                                                   // move / exchange command can be issued to the drive.

  CHANGER_CLEANER_ACCESS_NOT_VALID    = $00040000; // The access bit in GES isn't valid for cleaner cartridges.
  {$EXTERNALSYM CHANGER_CLEANER_ACCESS_NOT_VALID}
  CHANGER_PREMOUNT_EJECT_REQUIRED     = $00080000; // The medium-changer requires a drive eject command to be issued
  {$EXTERNALSYM CHANGER_PREMOUNT_EJECT_REQUIRED}
                                                   // before a move / exchange command can be issued with the drive as src/dst.

  CHANGER_VOLUME_IDENTIFICATION       = $00100000; // The medium-changer supports volume identification.
  {$EXTERNALSYM CHANGER_VOLUME_IDENTIFICATION}
  CHANGER_VOLUME_SEARCH               = $00200000; // The medium-changer can search for volume information.
  {$EXTERNALSYM CHANGER_VOLUME_SEARCH}
  CHANGER_VOLUME_ASSERT               = $00400000; // The medium-changer can verify volume information.
  {$EXTERNALSYM CHANGER_VOLUME_ASSERT}
  CHANGER_VOLUME_REPLACE              = $00800000; // The medium-changer can replace volume information.
  {$EXTERNALSYM CHANGER_VOLUME_REPLACE}
  CHANGER_VOLUME_UNDEFINE             = $01000000; // The medium-changer can undefine volume information.
  {$EXTERNALSYM CHANGER_VOLUME_UNDEFINE}

  CHANGER_SERIAL_NUMBER_VALID         = $04000000; // The serial number reported in GetProductData is valid
  {$EXTERNALSYM CHANGER_SERIAL_NUMBER_VALID}
                                                   // and unique.

  CHANGER_DEVICE_REINITIALIZE_CAPABLE = $08000000; // The medium-changer can be issued a ChangerReinitializeUnit.
  {$EXTERNALSYM CHANGER_DEVICE_REINITIALIZE_CAPABLE}
  CHANGER_KEYPAD_ENABLE_DISABLE       = $10000000; // Indicates that the keypad can be enabled/disabled.
  {$EXTERNALSYM CHANGER_KEYPAD_ENABLE_DISABLE}
  CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS  = $20000000; // Drives must be empty before access via the door is possible.
  {$EXTERNALSYM CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS}

  CHANGER_RESERVED_BIT                = DWORD($80000000); // Will be used to indicate Features1 capability bits.
  {$EXTERNALSYM CHANGER_RESERVED_BIT}

//
// Definitions for Features1 of GET_CHANGER_PARAMETERS
//

  CHANGER_PREDISMOUNT_ALIGN_TO_SLOT  = DWORD($80000001); // The transport must be prepositioned to the slot prior to ejecting the media.
  {$EXTERNALSYM CHANGER_PREDISMOUNT_ALIGN_TO_SLOT}
  CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE = DWORD($80000002); // The transport must be prepositioned to the drive prior to ejecting the media.
  {$EXTERNALSYM CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE}
  CHANGER_CLEANER_AUTODISMOUNT       = DWORD($80000004); // The device will move the cleaner cartridge back into the slot when cleaning has completed.
  {$EXTERNALSYM CHANGER_CLEANER_AUTODISMOUNT}
  CHANGER_TRUE_EXCHANGE_CAPABLE      = DWORD($80000008); // Device can do src -> dest2 exchanges.
  {$EXTERNALSYM CHANGER_TRUE_EXCHANGE_CAPABLE}
  CHANGER_SLOTS_USE_TRAYS            = DWORD($80000010); // Slots have removable trays, requiring multiple moves for inject/eject.
  {$EXTERNALSYM CHANGER_SLOTS_USE_TRAYS}
  CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR = DWORD($80000020); // Media must be returned to the slot from which it originated after a move to another element.
  {$EXTERNALSYM CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR}
  CHANGER_CLEANER_OPS_NOT_SUPPORTED  = DWORD($80000040); // Automated cleaning operations are not supported on this device.
  {$EXTERNALSYM CHANGER_CLEANER_OPS_NOT_SUPPORTED}
  CHANGER_IEPORT_USER_CONTROL_OPEN   = DWORD($80000080); // Indicates that user action is necessary to open a closed ieport.
  {$EXTERNALSYM CHANGER_IEPORT_USER_CONTROL_OPEN}
  CHANGER_IEPORT_USER_CONTROL_CLOSE  = DWORD($80000100); // Indicates that user action is necessary to close an opened ieport.
  {$EXTERNALSYM CHANGER_IEPORT_USER_CONTROL_CLOSE}
  CHANGER_MOVE_EXTENDS_IEPORT        = DWORD($80000200); // Indicates that a move media to the ieport extends the tray.
  {$EXTERNALSYM CHANGER_MOVE_EXTENDS_IEPORT}
  CHANGER_MOVE_RETRACTS_IEPORT       = DWORD($80000400); // Indicates that a move media from the ieport retracts the tray.
  {$EXTERNALSYM CHANGER_MOVE_RETRACTS_IEPORT}

//
// Definitions for MoveFrom, ExchangeFrom, and PositionCapabilities
//

  CHANGER_TO_TRANSPORT = $01; // The device can carry out the operation to a transport from the specified element.
  {$EXTERNALSYM CHANGER_TO_TRANSPORT}
  CHANGER_TO_SLOT      = $02; // The device can carry out the operation to a slot from the specified element.
  {$EXTERNALSYM CHANGER_TO_SLOT}
  CHANGER_TO_IEPORT    = $04; // The device can carry out the operation to an IE Port from the specified element.
  {$EXTERNALSYM CHANGER_TO_IEPORT}
  CHANGER_TO_DRIVE     = $08; // The device can carry out the operation to a drive from the specified element.
  {$EXTERNALSYM CHANGER_TO_DRIVE}

//
// Definitions for LockUnlockCapabilities
//

  LOCK_UNLOCK_IEPORT = $01; // The device can lock/unlock the ieport(s).
  {$EXTERNALSYM LOCK_UNLOCK_IEPORT}
  LOCK_UNLOCK_DOOR   = $02; // The device can lock/unlock the door(s).
  {$EXTERNALSYM LOCK_UNLOCK_DOOR}
  LOCK_UNLOCK_KEYPAD = $04; // The device can lock/unlock the keypad.
  {$EXTERNALSYM LOCK_UNLOCK_KEYPAD}

type
  PGET_CHANGER_PARAMETERS = ^GET_CHANGER_PARAMETERS;
  {$EXTERNALSYM PGET_CHANGER_PARAMETERS}
  _GET_CHANGER_PARAMETERS = record
    //
    // Size of the structure. Can be used for versioning.
    //
    Size: DWORD;
    //
    // Number of N element(s) as defined by the Element Address Page (or equivalent...).
    //
    NumberTransportElements: WORD;
    NumberStorageElements: WORD; // for data cartridges only
    NumberCleanerSlots: WORD; // for cleaner cartridges
    NumberIEElements: WORD;
    NumberDataTransferElements: WORD;
    //
    // Number of doors/front panels (allows user entry into the cabinet).
    //
    NumberOfDoors: WORD;
    //
    // The device-specific address (from user manual of the device) of the first N element. Used
    // by the UI to relate the various elements to the user.
    //
    FirstSlotNumber: WORD;
    FirstDriveNumber: WORD;
    FirstTransportNumber: WORD;
    FirstIEPortNumber: WORD;
    FirstCleanerSlotAddress: WORD;
    //
    // Indicates the capacity of each magazine, if they exist.
    //
    MagazineSize: WORD;
    //
    // Specifies the approximate number of seconds for when a cleaning should be completed.
    // Only applicable if drive cleaning is supported. See Features0.
    //
    DriveCleanTimeout: DWORD;
    //
    // See features bits, above.
    //
    Features0: DWORD;
    Features1: DWORD;
    //
    // Bitmask defining Move from N element to element. Defined by Device Capabilities Page (or equivalent).
    // AND-masking with the TO_XXX values will indicate legal destinations.
    //
    MoveFromTransport: BYTE;
    MoveFromSlot: BYTE;
    MoveFromIePort: BYTE;
    MoveFromDrive: BYTE;
    //
    // Bitmask defining Exchange from N element to element. Defined by Device Capabilities Page (or equivalent).
    // AND-masking with the TO_XXX values will indicate legal destinations.
    //
    ExchangeFromTransport: BYTE;
    ExchangeFromSlot: BYTE;
    ExchangeFromIePort: BYTE;
    ExchangeFromDrive: BYTE;
    //
    // Bitmask defining which elements are capable of lock/unlock. Valid only if
    // CHANGER_LOCK_UNLOCK is set in Features0.
    //
    LockUnlockCapabilities: BYTE;
    //
    // Bitmask defining which elements valid for positioning operations. Valid only if
    // CHANGER_POSITION_TO_ELEMENT is set in Features0.
    //
    PositionCapabilities: BYTE;
    //
    // For future expansion.
    //
    Reserved1: array [0..1] of BYTE;
    Reserved2: array [0..1] of DWORD;
  end;
  {$EXTERNALSYM _GET_CHANGER_PARAMETERS}
  GET_CHANGER_PARAMETERS = _GET_CHANGER_PARAMETERS;
  {$EXTERNALSYM GET_CHANGER_PARAMETERS}
  TGetChangerParameters = GET_CHANGER_PARAMETERS;
  PGetChangerParameters = PGET_CHANGER_PARAMETERS;

//
// Definitions for IOCTL_CHANGER_GET_PRODUCT_DATA
//

  PCHANGER_PRODUCT_DATA = ^CHANGER_PRODUCT_DATA;
  {$EXTERNALSYM PCHANGER_PRODUCT_DATA}
  _CHANGER_PRODUCT_DATA = record
    //
    // Device manufacturer's name - based on inquiry data
    //
    VendorId: array [0..VENDOR_ID_LENGTH - 1] of BYTE;
    //
    // Product identification as defined by the vendor - based on Inquiry data
    //
    ProductId: array [0..PRODUCT_ID_LENGTH - 1] of BYTE;
    //
    // Product revision as defined by the vendor.
    //
    Revision: array [0..REVISION_LENGTH - 1] of BYTE;
    //
    // Vendor unique value used to globally identify this device. Can
    // be from Vital Product Data, for example.
    //
    SerialNumber: array [0..SERIAL_NUMBER_LENGTH - 1] of BYTE;
    //
    // Indicates device type of data transports, as defined by SCSI-2.
    //
    DeviceType: BYTE;
  end;
  {$EXTERNALSYM _CHANGER_PRODUCT_DATA}
  CHANGER_PRODUCT_DATA = _CHANGER_PRODUCT_DATA;
  {$EXTERNALSYM CHANGER_PRODUCT_DATA}
  TChangerProductData = CHANGER_PRODUCT_DATA;
  PChangerProductData = PCHANGER_PRODUCT_DATA;

//
// Definitions for IOCTL_CHANGER_SET_ACCESS
//

const
  LOCK_ELEMENT   = 0;
  {$EXTERNALSYM LOCK_ELEMENT}
  UNLOCK_ELEMENT = 1;
  {$EXTERNALSYM UNLOCK_ELEMENT}
  EXTEND_IEPORT  = 2;
  {$EXTERNALSYM EXTEND_IEPORT}
  RETRACT_IEPORT = 3;
  {$EXTERNALSYM RETRACT_IEPORT}

type
  PCHANGER_SET_ACCESS = ^CHANGER_SET_ACCESS;
  {$EXTERNALSYM PCHANGER_SET_ACCESS}
  _CHANGER_SET_ACCESS = record
    //
    // Element can be ChangerIEPort, ChangerDoor, ChangerKeypad
    //
    Element: CHANGER_ELEMENT;
    //
    // See above for possible operations.
    //
    Control: DWORD;
  end;
  {$EXTERNALSYM _CHANGER_SET_ACCESS}
  CHANGER_SET_ACCESS = _CHANGER_SET_ACCESS;
  {$EXTERNALSYM CHANGER_SET_ACCESS}
  TChangerSetAccess = CHANGER_SET_ACCESS;
  PChangerSetAccess = PCHANGER_SET_ACCESS;

//
// Definitions for IOCTL_CHANGER_GET_ELEMENT_STATUS
//

//
// Input buffer.
//

  PCHANGER_READ_ELEMENT_STATUS = ^CHANGER_READ_ELEMENT_STATUS;
  {$EXTERNALSYM PCHANGER_READ_ELEMENT_STATUS}
  _CHANGER_READ_ELEMENT_STATUS = record
    //
    // List describing the elements and range on which to return information.
    //
    ElementList: CHANGER_ELEMENT_LIST;
    //
    // Indicates whether volume tag information is to be returned.
    //
    VolumeTagInfo: ByteBool;
  end;
  {$EXTERNALSYM _CHANGER_READ_ELEMENT_STATUS}
  CHANGER_READ_ELEMENT_STATUS = _CHANGER_READ_ELEMENT_STATUS;
  {$EXTERNALSYM CHANGER_READ_ELEMENT_STATUS}
  TChangerReadElementStatus = CHANGER_READ_ELEMENT_STATUS;
  PChangerReadElementStatus = PCHANGER_READ_ELEMENT_STATUS;

//
// Output buffer.
//

  PCHANGER_ELEMENT_STATUS = ^CHANGER_ELEMENT_STATUS;
  {$EXTERNALSYM PCHANGER_ELEMENT_STATUS}
  _CHANGER_ELEMENT_STATUS = record
    //
    // Element to which this structure refers.
    //
    Element: CHANGER_ELEMENT;
    //
    // Address of the element from which the media was originally moved.
    // Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
    // Needs to be converted to a zero-based offset from the device-unique value.
    //
    SrcElementAddress: CHANGER_ELEMENT;
    //
    // See below.
    //
    Flags: DWORD;
    //
    // See below for possible values.
    //
    ExceptionCode: DWORD;
    //
    // Scsi Target Id of this element.
    // Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
    //
    TargetId: BYTE;
    //
    // LogicalUnitNumber of this element.
    // Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
    //
    Lun: BYTE;
    Reserved: WORD;
    //
    // Primary volume identification for the media.
    // Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
    //
    PrimaryVolumeID: array [0..MAX_VOLUME_ID_SIZE - 1] of BYTE;
    //
    // Alternate volume identification for the media.
    // Valid for two-sided media only, and pertains to the id. of the inverted side.
    // Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
    //
    AlternateVolumeID: array [0..MAX_VOLUME_ID_SIZE - 1] of BYTE;
  end;
  {$EXTERNALSYM _CHANGER_ELEMENT_STATUS}
  CHANGER_ELEMENT_STATUS = _CHANGER_ELEMENT_STATUS;
  {$EXTERNALSYM CHANGER_ELEMENT_STATUS}
  TChangerElementStatus = CHANGER_ELEMENT_STATUS;
  PChangerElementStatus = PCHANGER_ELEMENT_STATUS;

  PCHANGER_ELEMENT_STATUS_EX = ^CHANGER_ELEMENT_STATUS_EX;
  {$EXTERNALSYM PCHANGER_ELEMENT_STATUS_EX}
  _CHANGER_ELEMENT_STATUS_EX = record
    //
    // Element to which this structure refers.
    //
    Element: CHANGER_ELEMENT;
    //
    // Address of the element from which the media was originally moved.
    // Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
    // Needs to be converted to a zero-based offset from the device-unique value.
    //
    SrcElementAddress: CHANGER_ELEMENT;
    //
    // See below.
    //
    Flags: DWORD;
    //
    // See below for possible values.
    //
    ExceptionCode: DWORD;
    //
    // Scsi Target Id of this element.
    // Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
    //
    TargetId: BYTE;
    //
    // LogicalUnitNumber of this element.
    // Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
    //
    Lun: BYTE;
    Reserved: WORD;
    //
    // Primary volume identification for the media.
    // Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
    //
    PrimaryVolumeID: array [0..MAX_VOLUME_ID_SIZE - 1] of BYTE;
    //
    // Alternate volume identification for the media.
    // Valid for two-sided media only, and pertains to the id. of the inverted side.
    // Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
    //
    AlternateVolumeID: array [0..MAX_VOLUME_ID_SIZE - 1] of BYTE;
    //
    // Vendor ID
    //
    VendorIdentification: array [0..VENDOR_ID_LENGTH - 1] of BYTE;
    //
    // Product ID
    //
    ProductIdentification: array [0..PRODUCT_ID_LENGTH - 1] of BYTE;
    //
    // Serial number
    //
    SerialNumber: array [0..SERIAL_NUMBER_LENGTH - 1] of BYTE;
  end;
  {$EXTERNALSYM _CHANGER_ELEMENT_STATUS_EX}
  CHANGER_ELEMENT_STATUS_EX = _CHANGER_ELEMENT_STATUS_EX;
  {$EXTERNALSYM CHANGER_ELEMENT_STATUS_EX}
  TChangerElementStatusEx = CHANGER_ELEMENT_STATUS_EX;
  PChangerElementStatusEx = PCHANGER_ELEMENT_STATUS_EX;

//
// Possible flag values
//

const
  ELEMENT_STATUS_FULL      = $00000001; // Element contains a unit of media.
  {$EXTERNALSYM ELEMENT_STATUS_FULL}
  ELEMENT_STATUS_IMPEXP    = $00000002; // Media in i/e port was placed there by an operator.
  {$EXTERNALSYM ELEMENT_STATUS_IMPEXP}
  ELEMENT_STATUS_EXCEPT    = $00000004; // Element is in an abnormal state; check ExceptionCode field for more information.
  {$EXTERNALSYM ELEMENT_STATUS_EXCEPT}
  ELEMENT_STATUS_ACCESS    = $00000008; // Access to the i/e port from the medium changer is allowed.
  {$EXTERNALSYM ELEMENT_STATUS_ACCESS}
  ELEMENT_STATUS_EXENAB    = $00000010; // Export of media is supported.
  {$EXTERNALSYM ELEMENT_STATUS_EXENAB}
  ELEMENT_STATUS_INENAB    = $00000020; // Import of media is supported.
  {$EXTERNALSYM ELEMENT_STATUS_INENAB}

  ELEMENT_STATUS_PRODUCT_DATA = $00000040; // Serial number valid for the drive
  {$EXTERNALSYM ELEMENT_STATUS_PRODUCT_DATA}

  ELEMENT_STATUS_LUN_VALID = $00001000; // Lun information is valid.
  {$EXTERNALSYM ELEMENT_STATUS_LUN_VALID}
  ELEMENT_STATUS_ID_VALID  = $00002000; // SCSI Id information is valid.
  {$EXTERNALSYM ELEMENT_STATUS_ID_VALID}
  ELEMENT_STATUS_NOT_BUS   = $00008000; // Lun and SCSI Id fields are not on same bus as medium changer.
  {$EXTERNALSYM ELEMENT_STATUS_NOT_BUS}
  ELEMENT_STATUS_INVERT    = $00400000; // Media in element was inverted (valid only if ELEMENT_STATUS_SVALID bit is set)
  {$EXTERNALSYM ELEMENT_STATUS_INVERT}

  ELEMENT_STATUS_SVALID    = $00800000; // SourceElementAddress field and ELEMENT_STATUS_INVERT bit are valid.
  {$EXTERNALSYM ELEMENT_STATUS_SVALID}
  ELEMENT_STATUS_PVOLTAG   = $10000000; // Primary volume information is valid.
  {$EXTERNALSYM ELEMENT_STATUS_PVOLTAG}
  ELEMENT_STATUS_AVOLTAG   = $20000000; // Alternate volume information is valid.
  {$EXTERNALSYM ELEMENT_STATUS_AVOLTAG}

//
// ExceptionCode values.
//

  ERROR_LABEL_UNREADABLE    = $00000001; // Bar code scanner could not read bar code label.
  {$EXTERNALSYM ERROR_LABEL_UNREADABLE}
  ERROR_LABEL_QUESTIONABLE  = $00000002; // Label could be invalid due to unit attention condition.
  {$EXTERNALSYM ERROR_LABEL_QUESTIONABLE}
  ERROR_SLOT_NOT_PRESENT    = $00000004; // Slot is currently not addressable in the device.
  {$EXTERNALSYM ERROR_SLOT_NOT_PRESENT}
  ERROR_DRIVE_NOT_INSTALLED = $00000008; // Drive is not installed.
  {$EXTERNALSYM ERROR_DRIVE_NOT_INSTALLED}
  ERROR_TRAY_MALFUNCTION    = $00000010; // Media tray is malfunctioning/broken.
  {$EXTERNALSYM ERROR_TRAY_MALFUNCTION}
  ERROR_INIT_STATUS_NEEDED  = $00000011; // An Initialize Element Status command is needed.
  {$EXTERNALSYM ERROR_INIT_STATUS_NEEDED}
  ERROR_UNHANDLED_ERROR     = DWORD($FFFFFFFF); // Unknown error condition
  {$EXTERNALSYM ERROR_UNHANDLED_ERROR}

//
// Definitions for IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS
//

type
  PCHANGER_INITIALIZE_ELEMENT_STATUS = ^CHANGER_INITIALIZE_ELEMENT_STATUS;
  {$EXTERNALSYM PCHANGER_INITIALIZE_ELEMENT_STATUS}
  _CHANGER_INITIALIZE_ELEMENT_STATUS = record
    //
    // List describing the elements and range on which to initialize.
    //
    ElementList: CHANGER_ELEMENT_LIST;
    //
    // Indicates whether a bar code scan should be used. Only applicable if
    // CHANGER_BAR_CODE_SCANNER_INSTALLED is set in Features0 of CHANGER_GET_PARAMETERS.
    //
    BarCodeScan: ByteBool;
  end;
  {$EXTERNALSYM _CHANGER_INITIALIZE_ELEMENT_STATUS}
  CHANGER_INITIALIZE_ELEMENT_STATUS = _CHANGER_INITIALIZE_ELEMENT_STATUS;
  {$EXTERNALSYM CHANGER_INITIALIZE_ELEMENT_STATUS}
  TChangerInitializeElementStatus = CHANGER_INITIALIZE_ELEMENT_STATUS;
  PChangerInitializeElementStatus = PCHANGER_INITIALIZE_ELEMENT_STATUS;

//
// Definitions for IOCTL_CHANGER_SET_POSITION
//

  PCHANGER_SET_POSITION = ^CHANGER_SET_POSITION;
  {$EXTERNALSYM PCHANGER_SET_POSITION}
  _CHANGER_SET_POSITION = record
    //
    // Indicates which transport to move.
    //
    Transport: CHANGER_ELEMENT;
    //
    // Indicates the final destination of the transport.
    //
    Destination: CHANGER_ELEMENT;
    //
    // Indicates whether the media currently carried by Transport, should be flipped.
    //
    Flip: ByteBool;
  end;
  {$EXTERNALSYM _CHANGER_SET_POSITION}
  CHANGER_SET_POSITION = _CHANGER_SET_POSITION;
  {$EXTERNALSYM CHANGER_SET_POSITION}
  TChangerSetPosition = CHANGER_SET_POSITION;
  PChangerSetPosition = PCHANGER_SET_POSITION;

//
// Definitions for IOCTL_CHANGER_EXCHANGE_MEDIUM
//

  PCHANGER_EXCHANGE_MEDIUM = ^CHANGER_EXCHANGE_MEDIUM;
  {$EXTERNALSYM PCHANGER_EXCHANGE_MEDIUM}
  _CHANGER_EXCHANGE_MEDIUM = record
    //
    // Indicates which transport to use for the exchange operation.
    //
    Transport: CHANGER_ELEMENT;
    //
    // Indicates the source for the media that is to be moved.
    //
    Source: CHANGER_ELEMENT;
    //
    // Indicates the final destination of the media originally at Source.
    //
    Destination1: CHANGER_ELEMENT;
    //
    // Indicates the destination of the media moved from Destination1.
    //
    Destination2: CHANGER_ELEMENT;
    //
    // Indicates whether the medium should be flipped.
    //
    Flip1: ByteBool;
    Flip2: ByteBool;
  end;
  {$EXTERNALSYM _CHANGER_EXCHANGE_MEDIUM}
  CHANGER_EXCHANGE_MEDIUM = _CHANGER_EXCHANGE_MEDIUM;
  {$EXTERNALSYM CHANGER_EXCHANGE_MEDIUM}
  TChangerExchangeMedium = CHANGER_EXCHANGE_MEDIUM;
  PChangerExchangeMedium = PCHANGER_EXCHANGE_MEDIUM;

//
// Definitions for IOCTL_CHANGER_MOVE_MEDIUM
//

  PCHANGER_MOVE_MEDIUM = ^CHANGER_MOVE_MEDIUM;
  {$EXTERNALSYM PCHANGER_MOVE_MEDIUM}
  _CHANGER_MOVE_MEDIUM = record
    //
    // Indicates which transport to use for the move operation.
    //
    Transport: CHANGER_ELEMENT;
    //
    // Indicates the source for the media that is to be moved.
    //
    Source: CHANGER_ELEMENT;
    //
    // Indicates the destination of the media originally at Source.
    //
    Destination: CHANGER_ELEMENT;
    //
    // Indicates whether the media should be flipped.
    //
    Flip: ByteBool;
  end;
  {$EXTERNALSYM _CHANGER_MOVE_MEDIUM}
  CHANGER_MOVE_MEDIUM = _CHANGER_MOVE_MEDIUM;
  {$EXTERNALSYM CHANGER_MOVE_MEDIUM}
  TChangerMoveMedium = CHANGER_MOVE_MEDIUM;
  PChangerMoveMedium = PCHANGER_MOVE_MEDIUM;

//
// Definitions for IOCTL_QUERY_VOLUME_TAGS
//

//
// Input buffer.
//

  PCHANGER_SEND_VOLUME_TAG_INFORMATION = ^CHANGER_SEND_VOLUME_TAG_INFORMATION;
  {$EXTERNALSYM PCHANGER_SEND_VOLUME_TAG_INFORMATION}
  _CHANGER_SEND_VOLUME_TAG_INFORMATION = record
    //
    // Describes the starting element for which to return information.
    //
    StartingElement: CHANGER_ELEMENT;
    //
    // Indicates the specific action to perform. See below.
    //
    ActionCode: DWORD;
    //
    // Template used by the device to search for volume ids.
    //
    VolumeIDTemplate: array [0..MAX_VOLUME_TEMPLATE_SIZE - 1] of BYTE;
  end;
  {$EXTERNALSYM _CHANGER_SEND_VOLUME_TAG_INFORMATION}
  CHANGER_SEND_VOLUME_TAG_INFORMATION = _CHANGER_SEND_VOLUME_TAG_INFORMATION;
  {$EXTERNALSYM CHANGER_SEND_VOLUME_TAG_INFORMATION}
  TChangerSendVolumeTagInformation = CHANGER_SEND_VOLUME_TAG_INFORMATION;
  PChangerSendVolumeTagInformation = PCHANGER_SEND_VOLUME_TAG_INFORMATION;

//
// Output buffer.
//

  PREAD_ELEMENT_ADDRESS_INFO = ^READ_ELEMENT_ADDRESS_INFO;
  {$EXTERNALSYM PREAD_ELEMENT_ADDRESS_INFO}
  _READ_ELEMENT_ADDRESS_INFO = record
    //
    // Number of elements matching criteria set forth by ActionCode.
    //
    NumberOfElements: DWORD;
    //
    // Array of CHANGER_ELEMENT_STATUS structures, one for each element that corresponded
    // with the information passed in with the CHANGER_SEND_VOLUME_TAG_INFORMATION structure.
    //
    ElementStatus: array [0..0] of CHANGER_ELEMENT_STATUS;
  end;
  {$EXTERNALSYM _READ_ELEMENT_ADDRESS_INFO}
  READ_ELEMENT_ADDRESS_INFO = _READ_ELEMENT_ADDRESS_INFO;
  {$EXTERNALSYM READ_ELEMENT_ADDRESS_INFO}
  TReadElementAddressInfo = READ_ELEMENT_ADDRESS_INFO;
  PReadElementAddressInfo = PREAD_ELEMENT_ADDRESS_INFO;

//
// Possible ActionCode values. See Features0 of CHANGER_GET_PARAMETERS for compatibility with
// the current device.
//

const
  SEARCH_ALL         = $0; // Translate - search all defined volume tags.
  {$EXTERNALSYM SEARCH_ALL}
  SEARCH_PRIMARY     = $1; // Translate - search only primary volume tags.
  {$EXTERNALSYM SEARCH_PRIMARY}
  SEARCH_ALTERNATE   = $2; // Translate - search only alternate volume tags.
  {$EXTERNALSYM SEARCH_ALTERNATE}
  SEARCH_ALL_NO_SEQ  = $4; // Translate - search all defined volume tags but ignore sequence numbers.
  {$EXTERNALSYM SEARCH_ALL_NO_SEQ}
  SEARCH_PRI_NO_SEQ  = $5; // Translate - search only primary volume tags but ignore sequence numbers.
  {$EXTERNALSYM SEARCH_PRI_NO_SEQ}
  SEARCH_ALT_NO_SEQ  = $6; // Translate - search only alternate volume tags but ignore sequence numbers.
  {$EXTERNALSYM SEARCH_ALT_NO_SEQ}

  ASSERT_PRIMARY     = $8; // Assert - as the primary volume tag - if tag now undefined.
  {$EXTERNALSYM ASSERT_PRIMARY}
  ASSERT_ALTERNATE   = $9; // Assert - as the alternate volume tag - if tag now undefined.
  {$EXTERNALSYM ASSERT_ALTERNATE}

  REPLACE_PRIMARY    = $A; // Replace - the primary volume tag - current tag ignored.
  {$EXTERNALSYM REPLACE_PRIMARY}
  REPLACE_ALTERNATE  = $B; // Replace - the alternate volume tag - current tag ignored.
  {$EXTERNALSYM REPLACE_ALTERNATE}

  UNDEFINE_PRIMARY   = $C; // Undefine - the primary volume tag - current tag ignored.
  {$EXTERNALSYM UNDEFINE_PRIMARY}
  UNDEFINE_ALTERNATE = $D; // Undefine - the alternate volume tag - current tag ignored.
  {$EXTERNALSYM UNDEFINE_ALTERNATE}

//
// Changer diagnostic test related definitions
//

type
  _CHANGER_DEVICE_PROBLEM_TYPE = (
   DeviceProblemNone,
   DeviceProblemHardware,
   DeviceProblemCHMError,
   DeviceProblemDoorOpen,
   DeviceProblemCalibrationError,
   DeviceProblemTargetFailure,
   DeviceProblemCHMMoveError,
   DeviceProblemCHMZeroError,
   DeviceProblemCartridgeInsertError,
   DeviceProblemPositionError,
   DeviceProblemSensorError,
   DeviceProblemCartridgeEjectError,
   DeviceProblemGripperError,
   DeviceProblemDriveError);
  {$EXTERNALSYM _CHANGER_DEVICE_PROBLEM_TYPE}
  CHANGER_DEVICE_PROBLEM_TYPE = _CHANGER_DEVICE_PROBLEM_TYPE;
  {$EXTERNALSYM CHANGER_DEVICE_PROBLEM_TYPE}
  PCHANGER_DEVICE_PROBLEM_TYPE = ^CHANGER_DEVICE_PROBLEM_TYPE;
  {$EXTERNALSYM PCHANGER_DEVICE_PROBLEM_TYPE}
  TChangerDeviceProblemType = CHANGER_DEVICE_PROBLEM_TYPE;
  PChangerDeviceProblemType = PCHANGER_DEVICE_PROBLEM_TYPE;

const
  IOCTL_SERIAL_LSRMST_INSERT = (
    (FILE_DEVICE_SERIAL_PORT shl 16) or (FILE_ANY_ACCESS shl 14) or
    (31 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_SERIAL_LSRMST_INSERT}

  IOCTL_SERENUM_EXPOSE_HARDWARE = (
    (FILE_DEVICE_SERENUM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (128 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_SERENUM_EXPOSE_HARDWARE}

  IOCTL_SERENUM_REMOVE_HARDWARE = (
    (FILE_DEVICE_SERENUM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (129 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_SERENUM_REMOVE_HARDWARE}

  IOCTL_SERENUM_PORT_DESC = (
    (FILE_DEVICE_SERENUM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (130 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_SERENUM_PORT_DESC}

  IOCTL_SERENUM_GET_PORT_NAME = (
    (FILE_DEVICE_SERENUM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (131 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_SERENUM_GET_PORT_NAME}

//
// The following values follow the escape designator in the
// data stream if the LSRMST_INSERT mode has been turned on.
//

  SERIAL_LSRMST_ESCAPE = BYTE($00);
  {$EXTERNALSYM SERIAL_LSRMST_ESCAPE}

//
// Following this value is the contents of the line status
// register, and then the character in the RX hardware when
// the line status register was encountered.
//

  SERIAL_LSRMST_LSR_DATA = BYTE($01);
  {$EXTERNALSYM SERIAL_LSRMST_LSR_DATA}

//
// Following this value is the contents of the line status
// register.  No error character follows
//

  SERIAL_LSRMST_LSR_NODATA = BYTE($02);
  {$EXTERNALSYM SERIAL_LSRMST_LSR_NODATA}

//
// Following this value is the contents of the modem status
// register.
//

  SERIAL_LSRMST_MST = BYTE($03);
  {$EXTERNALSYM SERIAL_LSRMST_MST}

//
// Bit values for FIFO Control Register
//

  SERIAL_IOC_FCR_FIFO_ENABLE      = DWORD($00000001);
  {$EXTERNALSYM SERIAL_IOC_FCR_FIFO_ENABLE}
  SERIAL_IOC_FCR_RCVR_RESET       = DWORD($00000002);
  {$EXTERNALSYM SERIAL_IOC_FCR_RCVR_RESET}
  SERIAL_IOC_FCR_XMIT_RESET       = DWORD($00000004);
  {$EXTERNALSYM SERIAL_IOC_FCR_XMIT_RESET}
  SERIAL_IOC_FCR_DMA_MODE         = DWORD($00000008);
  {$EXTERNALSYM SERIAL_IOC_FCR_DMA_MODE}
  SERIAL_IOC_FCR_RES1             = DWORD($00000010);
  {$EXTERNALSYM SERIAL_IOC_FCR_RES1}
  SERIAL_IOC_FCR_RES2             = DWORD($00000020);
  {$EXTERNALSYM SERIAL_IOC_FCR_RES2}
  SERIAL_IOC_FCR_RCVR_TRIGGER_LSB = DWORD($00000040);
  {$EXTERNALSYM SERIAL_IOC_FCR_RCVR_TRIGGER_LSB}
  SERIAL_IOC_FCR_RCVR_TRIGGER_MSB = DWORD($00000080);
  {$EXTERNALSYM SERIAL_IOC_FCR_RCVR_TRIGGER_MSB}

//
// Bit values for Modem Control Register
//

  SERIAL_IOC_MCR_DTR  = DWORD($00000001);
  {$EXTERNALSYM SERIAL_IOC_MCR_DTR}
  SERIAL_IOC_MCR_RTS  = DWORD($00000002);
  {$EXTERNALSYM SERIAL_IOC_MCR_RTS}
  SERIAL_IOC_MCR_OUT1 = DWORD($00000004);
  {$EXTERNALSYM SERIAL_IOC_MCR_OUT1}
  SERIAL_IOC_MCR_OUT2 = DWORD($00000008);
  {$EXTERNALSYM SERIAL_IOC_MCR_OUT2}
  SERIAL_IOC_MCR_LOOP = DWORD($00000010);
  {$EXTERNALSYM SERIAL_IOC_MCR_LOOP}

//
// The following is a list of the native file system fsctls followed by
// additional network file system fsctls.  Some values have been
// decommissioned.
//

  FSCTL_REQUEST_OPLOCK_LEVEL_1 = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (0 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_REQUEST_OPLOCK_LEVEL_1}

  FSCTL_REQUEST_OPLOCK_LEVEL_2 = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (1 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_REQUEST_OPLOCK_LEVEL_2}

  FSCTL_REQUEST_BATCH_OPLOCK = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (2 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_REQUEST_BATCH_OPLOCK}

  FSCTL_OPLOCK_BREAK_ACKNOWLEDGE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (3 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_OPLOCK_BREAK_ACKNOWLEDGE}

  FSCTL_OPBATCH_ACK_CLOSE_PENDING = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (4 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_OPBATCH_ACK_CLOSE_PENDING}

  FSCTL_OPLOCK_BREAK_NOTIFY = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (5 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_OPLOCK_BREAK_NOTIFY}

  FSCTL_LOCK_VOLUME = (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or (6 shl 2) or METHOD_BUFFERED;
  {$EXTERNALSYM FSCTL_LOCK_VOLUME}

  FSCTL_UNLOCK_VOLUME = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (7 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_UNLOCK_VOLUME}

  FSCTL_DISMOUNT_VOLUME = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (8 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_DISMOUNT_VOLUME}

// decommissioned fsctl value                                              9

  FSCTL_IS_VOLUME_MOUNTED = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (10 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_IS_VOLUME_MOUNTED}

  FSCTL_IS_PATHNAME_VALID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (11 shl 2) or METHOD_BUFFERED);    // PATHNAME_BUFFER,
  {$EXTERNALSYM FSCTL_IS_PATHNAME_VALID}

  FSCTL_MARK_VOLUME_DIRTY = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (12 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_MARK_VOLUME_DIRTY}

// decommissioned fsctl value                                             13

  FSCTL_QUERY_RETRIEVAL_POINTERS = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (14 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_QUERY_RETRIEVAL_POINTERS}

  FSCTL_GET_COMPRESSION = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (15 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_COMPRESSION}

  FSCTL_SET_COMPRESSION = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or ((FILE_READ_DATA or FILE_WRITE_DATA) shl 14) or
    (16 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_COMPRESSION}

// decommissioned fsctl value                                             17
// decommissioned fsctl value                                             18

  FSCTL_MARK_AS_SYSTEM_HIVE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (19 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_MARK_AS_SYSTEM_HIVE}

  FSCTL_OPLOCK_BREAK_ACK_NO_2 = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (20 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_OPLOCK_BREAK_ACK_NO_2}

  FSCTL_INVALIDATE_VOLUMES = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (21 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_INVALIDATE_VOLUMES}

  FSCTL_QUERY_FAT_BPB = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (22 shl 2) or METHOD_BUFFERED); // FSCTL_QUERY_FAT_BPB_BUFFER
  {$EXTERNALSYM FSCTL_QUERY_FAT_BPB}

  FSCTL_REQUEST_FILTER_OPLOCK = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (23 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_REQUEST_FILTER_OPLOCK}

  FSCTL_FILESYSTEM_GET_STATISTICS = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (24 shl 2) or METHOD_BUFFERED); // FILESYSTEM_STATISTICS
  {$EXTERNALSYM FSCTL_FILESYSTEM_GET_STATISTICS}

  FSCTL_GET_NTFS_VOLUME_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (25 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_NTFS_VOLUME_DATA}

  FSCTL_GET_NTFS_FILE_RECORD = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (26 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_NTFS_FILE_RECORD}

  FSCTL_GET_VOLUME_BITMAP = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (27 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_GET_VOLUME_BITMAP}

  FSCTL_GET_RETRIEVAL_POINTERS = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (28 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_GET_RETRIEVAL_POINTERS}

  FSCTL_MOVE_FILE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (29 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_MOVE_FILE}

  FSCTL_IS_VOLUME_DIRTY = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (30 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_IS_VOLUME_DIRTY}

// decomissioned fsctl value  31
(*  FSCTL_GET_HFS_INFORMATION = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (31 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_HFS_INFORMATION}
*)

  FSCTL_ALLOW_EXTENDED_DASD_IO = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (32 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_ALLOW_EXTENDED_DASD_IO}

// decommissioned fsctl value                                             33
// decommissioned fsctl value                                             34

(*
  FSCTL_READ_PROPERTY_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (33 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_READ_PROPERTY_DATA}

  FSCTL_WRITE_PROPERTY_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (34 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_WRITE_PROPERTY_DATA}
*)

  FSCTL_FIND_FILES_BY_SID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (35 shl 2) or METHOD_NEITHER);  
  {$EXTERNALSYM FSCTL_FIND_FILES_BY_SID}

// decommissioned fsctl value                                             36
// decommissioned fsctl value                                             37

(*  FSCTL_DUMP_PROPERTY_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (37 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_DUMP_PROPERTY_DATA}
*)

  FSCTL_SET_OBJECT_ID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (38 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_OBJECT_ID}

  FSCTL_GET_OBJECT_ID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (39 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_OBJECT_ID}

  FSCTL_DELETE_OBJECT_ID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (40 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_DELETE_OBJECT_ID}

  FSCTL_SET_REPARSE_POINT = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (41 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_REPARSE_POINT}

  FSCTL_GET_REPARSE_POINT = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (42 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_GET_REPARSE_POINT}

  FSCTL_DELETE_REPARSE_POINT = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (43 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_DELETE_REPARSE_POINT}

  FSCTL_ENUM_USN_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (44 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_ENUM_USN_DATA}

  FSCTL_SECURITY_ID_CHECK = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_READ_DATA shl 14) or
    (45 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_SECURITY_ID_CHECK}

  FSCTL_READ_USN_JOURNAL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (46 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_READ_USN_JOURNAL}

  FSCTL_SET_OBJECT_ID_EXTENDED = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (47 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_OBJECT_ID_EXTENDED}

  FSCTL_CREATE_OR_GET_OBJECT_ID = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (48 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_CREATE_OR_GET_OBJECT_ID}

  FSCTL_SET_SPARSE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (49 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_SPARSE}

  FSCTL_SET_ZERO_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_WRITE_DATA shl 14) or
    (50 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SET_ZERO_DATA}

  FSCTL_QUERY_ALLOCATED_RANGES = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_READ_DATA shl 14) or
    (51 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_QUERY_ALLOCATED_RANGES}

// decommissioned fsctl value                                             52
(*
  FSCTL_ENABLE_UPGRADE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_WRITE_DATA shl 14) or
    (52 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_ENABLE_UPGRADE}
*)

  FSCTL_SET_ENCRYPTION = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (53 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_SET_ENCRYPTION}

  FSCTL_ENCRYPTION_FSCTL_IO = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (54 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_ENCRYPTION_FSCTL_IO}

  FSCTL_WRITE_RAW_ENCRYPTED = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (55 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_WRITE_RAW_ENCRYPTED}

  FSCTL_READ_RAW_ENCRYPTED = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (56 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_READ_RAW_ENCRYPTED}

  FSCTL_CREATE_USN_JOURNAL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (57 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_CREATE_USN_JOURNAL}

  FSCTL_READ_FILE_USN_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (58 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_READ_FILE_USN_DATA}

  FSCTL_WRITE_USN_CLOSE_RECORD = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (59 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_WRITE_USN_CLOSE_RECORD}

  FSCTL_EXTEND_VOLUME = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (60 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_EXTEND_VOLUME}

  FSCTL_QUERY_USN_JOURNAL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (61 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_QUERY_USN_JOURNAL}

  FSCTL_DELETE_USN_JOURNAL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (62 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_DELETE_USN_JOURNAL}

  FSCTL_MARK_HANDLE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (63 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_MARK_HANDLE}

  FSCTL_SIS_COPYFILE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (64 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SIS_COPYFILE}

  FSCTL_SIS_LINK_FILES = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or ((FILE_READ_DATA or FILE_WRITE_DATA) shl 14) or
    (65 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_SIS_LINK_FILES}

  FSCTL_HSM_MSG = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or ((FILE_READ_DATA or FILE_WRITE_DATA) shl 14) or
    (66 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_HSM_MSG}

// decommissioned fsctl value                                             67
(*
  FSCTL_NSS_CONTROL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_WRITE_DATA shl 14) or
    (67 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_NSS_CONTROL}
*)

  FSCTL_HSM_DATA = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or ((FILE_READ_DATA or FILE_WRITE_DATA) shl 14) or
    (68 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_HSM_DATA}

  FSCTL_RECALL_FILE = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_ANY_ACCESS shl 14) or
    (69 shl 2) or METHOD_NEITHER);
  {$EXTERNALSYM FSCTL_RECALL_FILE}

// decommissioned fsctl value                                             70
(*
  FSCTL_NSS_RCONTROL = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_READ_DATA shl 14) or
    (70 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_NSS_RCONTROL}
*)

  FSCTL_READ_FROM_PLEX = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_READ_DATA shl 14) or
    (71 shl 2) or METHOD_OUT_DIRECT);
  {$EXTERNALSYM FSCTL_READ_FROM_PLEX}

  FSCTL_FILE_PREFETCH = (
    (FILE_DEVICE_FILE_SYSTEM shl 16) or (FILE_SPECIAL_ACCESS shl 14) or
    (72 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM FSCTL_FILE_PREFETCH}

//
// The following long list of structs are associated with the preceeding
// file system fsctls.
//
// Note that the structs for the property sets fsctls are not included
// in this file.  They can be found in ntfsprop.h where they should stay
// because of their dependency on objidl.h.
//

//
// Structure for FSCTL_IS_PATHNAME_VALID
//

type
  PPATHNAME_BUFFER = ^PATHNAME_BUFFER;
  {$EXTERNALSYM PPATHNAME_BUFFER}
  _PATHNAME_BUFFER = record
    PathNameLength: DWORD;
    Name: array [0..0] of WCHAR;
  end;
  {$EXTERNALSYM _PATHNAME_BUFFER}
  PATHNAME_BUFFER = _PATHNAME_BUFFER;
  {$EXTERNALSYM PATHNAME_BUFFER}
  TPathnameBuffer = PATHNAME_BUFFER;
  PPathnameBuffer = PPATHNAME_BUFFER;

//
// Structure for FSCTL_QUERY_BPB_INFO
//

  PFSCTL_QUERY_FAT_BPB_BUFFER = ^FSCTL_QUERY_FAT_BPB_BUFFER;
  {$EXTERNALSYM PFSCTL_QUERY_FAT_BPB_BUFFER}
  _FSCTL_QUERY_FAT_BPB_BUFFER = record
    First0x24BytesOfBootSector: array [0..$23] of BYTE;
  end;
  {$EXTERNALSYM _FSCTL_QUERY_FAT_BPB_BUFFER}
  FSCTL_QUERY_FAT_BPB_BUFFER = _FSCTL_QUERY_FAT_BPB_BUFFER;
  {$EXTERNALSYM FSCTL_QUERY_FAT_BPB_BUFFER}
  TFsctlQueryFatBpbBuffer = FSCTL_QUERY_FAT_BPB_BUFFER;
  PFsctlQueryFatBpbBuffer = PFSCTL_QUERY_FAT_BPB_BUFFER;

//
// Structures for FSCTL_GET_NTFS_VOLUME_DATA.
// The user must pass the basic buffer below.  Ntfs
// will return as many fields as available in the extended
// buffer which follows immediately after the VOLUME_DATA_BUFFER.
//

  PNTFS_VOLUME_DATA_BUFFER = ^NTFS_VOLUME_DATA_BUFFER;
  {$EXTERNALSYM PNTFS_VOLUME_DATA_BUFFER}
  NTFS_VOLUME_DATA_BUFFER = record
    VolumeSerialNumber: LARGE_INTEGER;
    NumberSectors: LARGE_INTEGER;
    TotalClusters: LARGE_INTEGER;
    FreeClusters: LARGE_INTEGER;
    TotalReserved: LARGE_INTEGER;
    BytesPerSector: DWORD;
    BytesPerCluster: DWORD;
    BytesPerFileRecordSegment: DWORD;
    ClustersPerFileRecordSegment: DWORD;
    MftValidDataLength: LARGE_INTEGER;
    MftStartLcn: LARGE_INTEGER;
    Mft2StartLcn: LARGE_INTEGER;
    MftZoneStart: LARGE_INTEGER;
    MftZoneEnd: LARGE_INTEGER;
  end;
  {$EXTERNALSYM NTFS_VOLUME_DATA_BUFFER}
  TNtfsVolumeDataBuffer = NTFS_VOLUME_DATA_BUFFER;
  PNtfsVolumeDataBuffer = PNTFS_VOLUME_DATA_BUFFER;

  PNTFS_EXTENDED_VOLUME_DATA = ^NTFS_EXTENDED_VOLUME_DATA;
  {$EXTERNALSYM PNTFS_EXTENDED_VOLUME_DATA}
  NTFS_EXTENDED_VOLUME_DATA = record
    ByteCount: DWORD;
    MajorVersion: WORD;
    MinorVersion: WORD;
  end;
  {$EXTERNALSYM NTFS_EXTENDED_VOLUME_DATA}
  TNtfsExtendedVolumeData = NTFS_EXTENDED_VOLUME_DATA;
  PNtfsExtendedVolumeData = PNTFS_EXTENDED_VOLUME_DATA;

//
// Structure for FSCTL_GET_VOLUME_BITMAP
//

  PSTARTING_LCN_INPUT_BUFFER = ^STARTING_LCN_INPUT_BUFFER;
  {$EXTERNALSYM PSTARTING_LCN_INPUT_BUFFER}
  STARTING_LCN_INPUT_BUFFER = record
    StartingLcn: LARGE_INTEGER;
  end;
  {$EXTERNALSYM STARTING_LCN_INPUT_BUFFER}
  TStartingLcnInputBuffer = STARTING_LCN_INPUT_BUFFER;
  PStartingLcnInputBuffer = PSTARTING_LCN_INPUT_BUFFER;

  PVOLUME_BITMAP_BUFFER = ^VOLUME_BITMAP_BUFFER;
  {$EXTERNALSYM PVOLUME_BITMAP_BUFFER}
  VOLUME_BITMAP_BUFFER = record
    StartingLcn: LARGE_INTEGER;
    BitmapSize: LARGE_INTEGER;
    Buffer: array [0..0] of BYTE;
  end;
  {$EXTERNALSYM VOLUME_BITMAP_BUFFER}
  TVolumeBitmapBuffer = VOLUME_BITMAP_BUFFER;
  PVolumeBitmapBuffer = PVOLUME_BITMAP_BUFFER;

//
// Structure for FSCTL_GET_RETRIEVAL_POINTERS
//

  PSTARTING_VCN_INPUT_BUFFER = ^STARTING_VCN_INPUT_BUFFER;
  {$EXTERNALSYM PSTARTING_VCN_INPUT_BUFFER}
  STARTING_VCN_INPUT_BUFFER = record
    StartingVcn: LARGE_INTEGER;
  end;
  {$EXTERNALSYM STARTING_VCN_INPUT_BUFFER}
  TStartingVcnInputBuffer = STARTING_VCN_INPUT_BUFFER;
  PStartingVcnInputBuffer = PSTARTING_VCN_INPUT_BUFFER;

  TRPBExtends = record
    NextVcn: LARGE_INTEGER;
    Lcn: LARGE_INTEGER;
  end;

  PRETRIEVAL_POINTERS_BUFFER = ^RETRIEVAL_POINTERS_BUFFER;
  {$EXTERNALSYM PRETRIEVAL_POINTERS_BUFFER}
  RETRIEVAL_POINTERS_BUFFER = record
    ExtentCount: DWORD;
    StartingVcn: LARGE_INTEGER;
    Extends: array [0..0] of TRPBExtends;
  end;
  {$EXTERNALSYM RETRIEVAL_POINTERS_BUFFER}
  TRetrievalPointersBuffer = RETRIEVAL_POINTERS_BUFFER;
  PRetrievalPointersBuffer = PRETRIEVAL_POINTERS_BUFFER;

//
// Structures for FSCTL_GET_NTFS_FILE_RECORD
//

  PNTFS_FILE_RECORD_INPUT_BUFFER = ^NTFS_FILE_RECORD_INPUT_BUFFER;
  {$EXTERNALSYM PNTFS_FILE_RECORD_INPUT_BUFFER}
  NTFS_FILE_RECORD_INPUT_BUFFER = record
    FileReferenceNumber: LARGE_INTEGER;
  end;
  {$EXTERNALSYM NTFS_FILE_RECORD_INPUT_BUFFER}
  TNtfsFileRecordInputBuffer = NTFS_FILE_RECORD_INPUT_BUFFER;
  PNtfsFileRecordInputBuffer = PNTFS_FILE_RECORD_INPUT_BUFFER;

  PNTFS_FILE_RECORD_OUTPUT_BUFFER = ^NTFS_FILE_RECORD_OUTPUT_BUFFER;
  {$EXTERNALSYM PNTFS_FILE_RECORD_OUTPUT_BUFFER}
  NTFS_FILE_RECORD_OUTPUT_BUFFER = record
    FileReferenceNumber: LARGE_INTEGER;
    FileRecordLength: DWORD;
    FileRecordBuffer: array [0..0] of BYTE;
  end;
  {$EXTERNALSYM NTFS_FILE_RECORD_OUTPUT_BUFFER}
  TNtfsFileRecordOutputBuffer = NTFS_FILE_RECORD_OUTPUT_BUFFER;
  PNtfsFileRecordOutputBuffer = PNTFS_FILE_RECORD_OUTPUT_BUFFER;

//
// Structure for FSCTL_MOVE_FILE
//

  PMOVE_FILE_DATA = ^MOVE_FILE_DATA;
  {$EXTERNALSYM PMOVE_FILE_DATA}
  MOVE_FILE_DATA = record
    FileHandle: HANDLE;
    StartingVcn: LARGE_INTEGER;
    StartingLcn: LARGE_INTEGER;
    ClusterCount: DWORD;
  end;
  {$EXTERNALSYM MOVE_FILE_DATA}
  TMoveFileData = MOVE_FILE_DATA;
  PMoveFileData = PMOVE_FILE_DATA;

{$IFDEF _WIN64}

//
//  32/64 Bit thunking support structure
//

  _MOVE_FILE_DATA32 = record
    FileHandle: UINT32;
    StartingVcn: LARGE_INTEGER;
    StartingLcn: LARGE_INTEGER;
    ClusterCount: DWORD;
  end;
  {$EXTERNALSYM _MOVE_FILE_DATA32}
  MOVE_FILE_DATA32 = _MOVE_FILE_DATA32;
  {$EXTERNALSYM MOVE_FILE_DATA32}
  PMOVE_FILE_DATA32 = ^MOVE_FILE_DATA32;
  {$EXTERNALSYM PMOVE_FILE_DATA32}
  TMoveFileData32 = MOVE_FILE_DATA32;
  PMoveFileData32 = PMOVE_FILE_DATA32;
  
{$ENDIF _WIN64}

//
// Structures for FSCTL_FIND_FILES_BY_SID
//

  PFIND_BY_SID_DATA = ^FIND_BY_SID_DATA;
  {$EXTERNALSYM PFIND_BY_SID_DATA}
  FIND_BY_SID_DATA = record
    Restart: DWORD;
    Sid: SID;
  end;
  {$EXTERNALSYM FIND_BY_SID_DATA}
  TFindBySidData = FIND_BY_SID_DATA;
  PFindBySidData = PFIND_BY_SID_DATA;

  FIND_BY_SID_OUTPUT = record
    NextEntryOffset: DWORD;
    FileIndex: DWORD;
    FileNameLength: DWORD;
    FileName: array [0..0] of WCHAR;
  end;
  {$EXTERNALSYM FIND_BY_SID_OUTPUT}
  PFIND_BY_SID_OUTPUT = ^FIND_BY_SID_OUTPUT;
  TFindBySidOutput = FIND_BY_SID_OUTPUT;
  PFindBySidOutput = PFIND_BY_SID_OUTPUT;  

//
//  The following structures apply to Usn operations.
//

//
// Structure for FSCTL_ENUM_USN_DATA
//

  PMFT_ENUM_DATA = ^MFT_ENUM_DATA;
  {$EXTERNALSYM PMFT_ENUM_DATA}
  MFT_ENUM_DATA = record
    StartFileReferenceNumber: DWORDLONG;
    LowUsn: USN;
    HighUsn: USN;
  end;
  {$EXTERNALSYM MFT_ENUM_DATA}
  TMftEnumData = MFT_ENUM_DATA;
  PMftEnumData = PMFT_ENUM_DATA;

//
// Structure for FSCTL_CREATE_USN_JOURNAL
//

  PCREATE_USN_JOURNAL_DATA = ^CREATE_USN_JOURNAL_DATA;
  {$EXTERNALSYM PCREATE_USN_JOURNAL_DATA}
  CREATE_USN_JOURNAL_DATA = record
    MaximumSize: DWORDLONG;
    AllocationDelta: DWORDLONG;
  end;
  {$EXTERNALSYM CREATE_USN_JOURNAL_DATA}
  TCreateUsnJournalData = CREATE_USN_JOURNAL_DATA;
  PCreateUsnJournalData = PCREATE_USN_JOURNAL_DATA;

//
// Structure for FSCTL_READ_USN_JOURNAL
//

  PREAD_USN_JOURNAL_DATA = ^READ_USN_JOURNAL_DATA;
  {$EXTERNALSYM PREAD_USN_JOURNAL_DATA}
  READ_USN_JOURNAL_DATA = record
    StartUsn: USN;
    ReasonMask: DWORD;
    ReturnOnlyOnClose: DWORD;
    Timeout: DWORDLONG;
    BytesToWaitFor: DWORDLONG;
    UsnJournalID: DWORDLONG;
  end;
  {$EXTERNALSYM READ_USN_JOURNAL_DATA}
  TReadUsnJournalData = READ_USN_JOURNAL_DATA;
  PReadUsnJournalData = PREAD_USN_JOURNAL_DATA;

//
//  The initial Major.Minor version of the Usn record will be 2.0.
//  In general, the MinorVersion may be changed if fields are added
//  to this structure in such a way that the previous version of the
//  software can still correctly the fields it knows about.  The
//  MajorVersion should only be changed if the previous version of
//  any software using this structure would incorrectly handle new
//  records due to structure changes.
//
//  The first update to this will force the structure to version 2.0.
//  This will add the extended information about the source as
//  well as indicate the file name offset within the structure.
//
//  The following structure is returned with these fsctls.
//
//      FSCTL_READ_USN_JOURNAL
//      FSCTL_READ_FILE_USN_DATA
//      FSCTL_ENUM_USN_DATA
//

  PUSN_RECORD = ^USN_RECORD;
  {$EXTERNALSYM PUSN_RECORD}
  USN_RECORD = record
    RecordLength: DWORD;
    MajorVersion: WORD;
    MinorVersion: WORD;
    FileReferenceNumber: DWORDLONG;
    ParentFileReferenceNumber: DWORDLONG;
    Usn: USN;
    TimeStamp: LARGE_INTEGER;
    Reason: DWORD;
    SourceInfo: DWORD;
    SecurityId: DWORD;
    FileAttributes: DWORD;
    FileNameLength: WORD;
    FileNameOffset: WORD;
    FileName: array [0..0] of WCHAR;
  end;
  {$EXTERNALSYM USN_RECORD}
  TUsnRecord = USN_RECORD;
  PUsnRecord = PUSN_RECORD;

const
  USN_PAGE_SIZE = $1000;
  {$EXTERNALSYM USN_PAGE_SIZE}

  USN_REASON_DATA_OVERWRITE        = $00000001;
  {$EXTERNALSYM USN_REASON_DATA_OVERWRITE}
  USN_REASON_DATA_EXTEND           = $00000002;
  {$EXTERNALSYM USN_REASON_DATA_EXTEND}
  USN_REASON_DATA_TRUNCATION       = $00000004;
  {$EXTERNALSYM USN_REASON_DATA_TRUNCATION}
  USN_REASON_NAMED_DATA_OVERWRITE  = $00000010;
  {$EXTERNALSYM USN_REASON_NAMED_DATA_OVERWRITE}
  USN_REASON_NAMED_DATA_EXTEND     = $00000020;
  {$EXTERNALSYM USN_REASON_NAMED_DATA_EXTEND}
  USN_REASON_NAMED_DATA_TRUNCATION = $00000040;
  {$EXTERNALSYM USN_REASON_NAMED_DATA_TRUNCATION}
  USN_REASON_FILE_CREATE           = $00000100;
  {$EXTERNALSYM USN_REASON_FILE_CREATE}
  USN_REASON_FILE_DELETE           = $00000200;
  {$EXTERNALSYM USN_REASON_FILE_DELETE}
  USN_REASON_EA_CHANGE             = $00000400;
  {$EXTERNALSYM USN_REASON_EA_CHANGE}
  USN_REASON_SECURITY_CHANGE       = $00000800;
  {$EXTERNALSYM USN_REASON_SECURITY_CHANGE}
  USN_REASON_RENAME_OLD_NAME       = $00001000;
  {$EXTERNALSYM USN_REASON_RENAME_OLD_NAME}
  USN_REASON_RENAME_NEW_NAME       = $00002000;
  {$EXTERNALSYM USN_REASON_RENAME_NEW_NAME}
  USN_REASON_INDEXABLE_CHANGE      = $00004000;
  {$EXTERNALSYM USN_REASON_INDEXABLE_CHANGE}
  USN_REASON_BASIC_INFO_CHANGE     = $00008000;
  {$EXTERNALSYM USN_REASON_BASIC_INFO_CHANGE}
  USN_REASON_HARD_LINK_CHANGE      = $00010000;
  {$EXTERNALSYM USN_REASON_HARD_LINK_CHANGE}
  USN_REASON_COMPRESSION_CHANGE    = $00020000;
  {$EXTERNALSYM USN_REASON_COMPRESSION_CHANGE}
  USN_REASON_ENCRYPTION_CHANGE     = $00040000;
  {$EXTERNALSYM USN_REASON_ENCRYPTION_CHANGE}
  USN_REASON_OBJECT_ID_CHANGE      = $00080000;
  {$EXTERNALSYM USN_REASON_OBJECT_ID_CHANGE}
  USN_REASON_REPARSE_POINT_CHANGE  = $00100000;
  {$EXTERNALSYM USN_REASON_REPARSE_POINT_CHANGE}
  USN_REASON_STREAM_CHANGE         = $00200000;
  {$EXTERNALSYM USN_REASON_STREAM_CHANGE}

  USN_REASON_CLOSE = DWORD($80000000);
  {$EXTERNALSYM USN_REASON_CLOSE}

//
//  Structure for FSCTL_QUERY_USN_JOUNAL
//

type
  PUSN_JOURNAL_DATA = ^USN_JOURNAL_DATA;
  {$EXTERNALSYM PUSN_JOURNAL_DATA}
  USN_JOURNAL_DATA = record
    UsnJournalID: DWORDLONG;
    FirstUsn: USN;
    NextUsn: USN;
    LowestValidUsn: USN;
    MaxUsn: USN;
    MaximumSize: DWORDLONG;
    AllocationDelta: DWORDLONG;
  end;
  {$EXTERNALSYM USN_JOURNAL_DATA}
  TUsnJournalData = USN_JOURNAL_DATA;
  PUsnJournalData = PUSN_JOURNAL_DATA;

//
//  Structure for FSCTL_DELETE_USN_JOURNAL
//

  PDELETE_USN_JOURNAL_DATA = ^DELETE_USN_JOURNAL_DATA;
  {$EXTERNALSYM PDELETE_USN_JOURNAL_DATA}
  DELETE_USN_JOURNAL_DATA = record
    UsnJournalID: DWORDLONG;
    DeleteFlags: DWORD;
  end;
  {$EXTERNALSYM DELETE_USN_JOURNAL_DATA}
  TDeleteUsnJournalData = DELETE_USN_JOURNAL_DATA;
  PDeleteUsnJournalData = PDELETE_USN_JOURNAL_DATA;

const
  USN_DELETE_FLAG_DELETE = $00000001;
  {$EXTERNALSYM USN_DELETE_FLAG_DELETE}
  USN_DELETE_FLAG_NOTIFY = $00000002;
  {$EXTERNALSYM USN_DELETE_FLAG_NOTIFY}

  USN_DELETE_VALID_FLAGS = $00000003;
  {$EXTERNALSYM USN_DELETE_VALID_FLAGS}

//
//  Structure for FSCTL_MARK_HANDLE
//

type
  PMARK_HANDLE_INFO = ^MARK_HANDLE_INFO;
  {$EXTERNALSYM PMARK_HANDLE_INFO}
  MARK_HANDLE_INFO = record
    UsnSourceInfo: DWORD;
    VolumeHandle: HANDLE;
    HandleInfo: DWORD;
  end;
  {$EXTERNALSYM MARK_HANDLE_INFO}
  TMarkHandleInfo = MARK_HANDLE_INFO;
  PMarkHandleInfo = PMARK_HANDLE_INFO;

{$IFDEF _WIN64}

//
//  32/64 Bit thunking support structure
//

  MARK_HANDLE_INFO32 = record
    UsnSourceInfo: DWORD;
    VolumeHandle: UINT32;
    HandleInfo: DWORD;
  end;
  {$EXTERNALSYM MARK_HANDLE_INFO32}
  PMARK_HANDLE_INFO32 = ^MARK_HANDLE_INFO32;
  {$EXTERNALSYM PMARK_HANDLE_INFO32}
  TMarkHandleInfo32 = MARK_HANDLE_INFO32;
  PMarkHandleInfo32 = PMARK_HANDLE_INFO32;

{$ENDIF _WIN64}

//
//  Flags for the additional source information above.
//
//      USN_SOURCE_DATA_MANAGEMENT - Service is not modifying the external view
//          of any part of the file.  Typical case is HSM moving data to
//          and from external storage.
//
//      USN_SOURCE_AUXILIARY_DATA - Service is not modifying the external view
//          of the file with regard to the application that created this file.
//          Can be used to add private data streams to a file.
//
//      USN_SOURCE_REPLICATION_MANAGEMENT - Service is modifying a file to match
//          the contents of the same file which exists in another member of the
//          replica set.
//

const
  USN_SOURCE_DATA_MANAGEMENT        = $00000001;
  {$EXTERNALSYM USN_SOURCE_DATA_MANAGEMENT}
  USN_SOURCE_AUXILIARY_DATA         = $00000002;
  {$EXTERNALSYM USN_SOURCE_AUXILIARY_DATA}
  USN_SOURCE_REPLICATION_MANAGEMENT = $00000004;
  {$EXTERNALSYM USN_SOURCE_REPLICATION_MANAGEMENT}

//
//  Flags for the HandleInfo field above
//
//  MARK_HANDLE_PROTECT_CLUSTERS - disallow any defragmenting (FSCTL_MOVE_FILE) until the
//      the handle is closed
//

  MARK_HANDLE_PROTECT_CLUSTERS      = $00000001;
  {$EXTERNALSYM MARK_HANDLE_PROTECT_CLUSTERS}

//
// Structure for FSCTL_SECURITY_ID_CHECK
//

type
  PBULK_SECURITY_TEST_DATA = ^BULK_SECURITY_TEST_DATA;
  {$EXTERNALSYM PBULK_SECURITY_TEST_DATA}
  BULK_SECURITY_TEST_DATA = record
    DesiredAccess: ACCESS_MASK;
    SecurityIds: array [0..0] of DWORD;
  end;
  {$EXTERNALSYM BULK_SECURITY_TEST_DATA}
  TBulkSecurityTestData = BULK_SECURITY_TEST_DATA;
  PBulkSecurityTestData = PBULK_SECURITY_TEST_DATA;

//
//  Output flags for the FSCTL_IS_VOLUME_DIRTY
//

const
  VOLUME_IS_DIRTY          = $00000001;
  {$EXTERNALSYM VOLUME_IS_DIRTY}
  VOLUME_UPGRADE_SCHEDULED = $00000002;
  {$EXTERNALSYM VOLUME_UPGRADE_SCHEDULED}

//
// Structures for FSCTL_FILE_PREFETCH
//

type
  _FILE_PREFETCH = record
    Type_: DWORD;
    Count: DWORD;
    Prefetch: array [0..0] of DWORDLONG;
  end;
  {$EXTERNALSYM _FILE_PREFETCH}
  FILE_PREFETCH = _FILE_PREFETCH;
  {$EXTERNALSYM FILE_PREFETCH}
  PFILE_PREFETCH = ^FILE_PREFETCH;
  {$EXTERNALSYM PFILE_PREFETCH}
  TFilePrefetch = FILE_PREFETCH;
  PFilePrefetch = PFILE_PREFETCH;  

const
  FILE_PREFETCH_TYPE_FOR_CREATE = $1;
  {$EXTERNALSYM FILE_PREFETCH_TYPE_FOR_CREATE}
//
// Structures for FSCTL_FILESYSTEM_GET_STATISTICS
//
// Filesystem performance counters
//

type
  PFILESYSTEM_STATISTICS = ^FILESYSTEM_STATISTICS;
  {$EXTERNALSYM PFILESYSTEM_STATISTICS}
  _FILESYSTEM_STATISTICS = record
    FileSystemType: WORD;
    Version: WORD;                  // currently version 1
    SizeOfCompleteStructure: DWORD; // must by a mutiple of 64 bytes
    UserFileReads: DWORD;
    UserFileReadBytes: DWORD;
    UserDiskReads: DWORD;
    UserFileWrites: DWORD;
    UserFileWriteBytes: DWORD;
    UserDiskWrites: DWORD;
    MetaDataReads: DWORD;
    MetaDataReadBytes: DWORD;
    MetaDataDiskReads: DWORD;
    MetaDataWrites: DWORD;
    MetaDataWriteBytes: DWORD;
    MetaDataDiskWrites: DWORD;
    //
    //  The file system's private structure is appended here.
    //
  end;
  {$EXTERNALSYM _FILESYSTEM_STATISTICS}
  FILESYSTEM_STATISTICS = _FILESYSTEM_STATISTICS;
  {$EXTERNALSYM FILESYSTEM_STATISTICS}
  TFilesystemStatistics = FILESYSTEM_STATISTICS;
  PFilesystemStatistics = PFILESYSTEM_STATISTICS;

// values for FS_STATISTICS.FileSystemType

const
  FILESYSTEM_STATISTICS_TYPE_NTFS = 1;
  {$EXTERNALSYM FILESYSTEM_STATISTICS_TYPE_NTFS}
  FILESYSTEM_STATISTICS_TYPE_FAT  = 2;
  {$EXTERNALSYM FILESYSTEM_STATISTICS_TYPE_FAT}

//
//  File System Specific Statistics Data
//

type
  PFAT_STATISTICS = ^FAT_STATISTICS;
  {$EXTERNALSYM PFAT_STATISTICS}
  _FAT_STATISTICS = record
    CreateHits: DWORD;
    SuccessfulCreates: DWORD;
    FailedCreates: DWORD;
    NonCachedReads: DWORD;
    NonCachedReadBytes: DWORD;
    NonCachedWrites: DWORD;
    NonCachedWriteBytes: DWORD;
    NonCachedDiskReads: DWORD;
    NonCachedDiskWrites: DWORD;
  end;
  {$EXTERNALSYM _FAT_STATISTICS}
  FAT_STATISTICS = _FAT_STATISTICS;
  {$EXTERNALSYM FAT_STATISTICS}
  TFatStatistics = FAT_STATISTICS;
  PFatStatistics = PFAT_STATISTICS;

  // NTFS Statistics

  TMftWritesUserLevel = record
    Write: WORD;
    Create: WORD;
    SetInfo: WORD;
    Flush: WORD;
  end;

  TMft2WritesUserLevel = record
    Write: WORD;
    Create: WORD;
    SetInfo: WORD;
    Flush: WORD;
  end;

  TBitmapWritesUserLevel = record
    Write: WORD;
    Create: WORD;
    SetInfo: WORD;
  end;

  TMftBitmapWritesUserLevel = record
    Write: WORD;
    Create: WORD;
    SetInfo: WORD;
    Flush: WORD;
  end;

  TAllocate = record
    Calls: DWORD;                // number of individual calls to allocate clusters
    Clusters: DWORD;             // number of clusters allocated
    Hints: DWORD;                // number of times a hint was specified

    RunsReturned: DWORD;         // number of runs used to satisify all the requests

    HintsHonored: DWORD;         // number of times the hint was useful
    HintsClusters: DWORD;        // number of clusters allocated via the hint
    Cache: DWORD;                // number of times the cache was useful other than the hint
    CacheClusters: DWORD;        // number of clusters allocated via the cache other than the hint
    CacheMiss: DWORD;            // number of times the cache wasn't useful
    CacheMissClusters: DWORD;    // number of clusters allocated without the cache
  end;

  {$EXTERNALSYM NTFS_STATISTICS}
  PNTFS_STATISTICS = ^NTFS_STATISTICS;
  _NTFS_STATISTICS  = record

    LogFileFullExceptions: DWORD;
    OtherExceptions: DWORD;

    //
    // Other meta data io's
    //

    MftReads: DWORD;
    MftReadBytes: DWORD;
    MftWrites: DWORD;
    MftWriteBytes: DWORD;
    MftWritesUserLevel: TMftWritesUserLevel;

    MftWritesFlushForLogFileFull: WORD;
    MftWritesLazyWriter: WORD;
    MftWritesUserRequest: WORD;

    Mft2Writes: DWORD;
    Mft2WriteBytes: DWORD;
    Mft2WritesUserLevel: TMft2WritesUserLevel;

    Mft2WritesFlushForLogFileFull: WORD;
    Mft2WritesLazyWriter: WORD;
    Mft2WritesUserRequest: WORD;

    RootIndexReads: DWORD;
    RootIndexReadBytes: DWORD;
    RootIndexWrites: DWORD;
    RootIndexWriteBytes: DWORD;

    BitmapReads: DWORD;
    BitmapReadBytes: DWORD;
    BitmapWrites: DWORD;
    BitmapWriteBytes: DWORD;

    BitmapWritesFlushForLogFileFull: WORD;
    BitmapWritesLazyWriter: WORD;
    BitmapWritesUserRequest: WORD;

    BitmapWritesUserLevel: TBitmapWritesUserLevel;

    MftBitmapReads: DWORD;
    MftBitmapReadBytes: DWORD;
    MftBitmapWrites: DWORD;
    MftBitmapWriteBytes: DWORD;

    MftBitmapWritesFlushForLogFileFull: WORD;
    MftBitmapWritesLazyWriter: WORD;
    MftBitmapWritesUserRequest: WORD;
    MftBitmapWritesUserLevel: TMftBitmapWritesUserLevel;

    UserIndexReads: DWORD;
    UserIndexReadBytes: DWORD;
    UserIndexWrites: DWORD;
    UserIndexWriteBytes: DWORD;

    //
    // Additions for NT 5.0
    //

    LogFileReads: DWORD;
    LogFileReadBytes: DWORD;
    LogFileWrites: DWORD;
    LogFileWriteBytes: DWORD;

    Allocate: TAllocate;
  end;
  {$EXTERNALSYM _NTFS_STATISTICS}
  NTFS_STATISTICS = _NTFS_STATISTICS;
  {$EXTERNALSYM PNTFS_STATISTICS}
  TNTFSStatistics = NTFS_STATISTICS;
  PNTFSStatistics = PNTFS_STATISTICS;

//
// Structure for FSCTL_SET_OBJECT_ID, FSCTL_GET_OBJECT_ID, and FSCTL_CREATE_OR_GET_OBJECT_ID
//

  PFILE_OBJECTID_BUFFER = ^FILE_OBJECTID_BUFFER;
  {$EXTERNALSYM PFILE_OBJECTID_BUFFER}
  _FILE_OBJECTID_BUFFER = record

    //
    //  This is the portion of the object id that is indexed.
    //

    ObjectId: array [0..15] of BYTE;

    //
    //  This portion of the object id is not indexed, it's just
    //  some metadata for the user's benefit.
    //

    case Integer of
      0: (
        BirthVolumeId: array [0..15] of BYTE;
        BirthObjectId: array [0..15] of BYTE;
        DomainId: array [0..15] of BYTE);
      1: (
        ExtendedInfo: array [0..47] of BYTE);
  end;
  {$EXTERNALSYM _FILE_OBJECTID_BUFFER}
  FILE_OBJECTID_BUFFER = _FILE_OBJECTID_BUFFER;
  {$EXTERNALSYM FILE_OBJECTID_BUFFER}
  TFileObjectIdBuffer = FILE_OBJECTID_BUFFER;
  PFileObjectIdBuffer = PFILE_OBJECTID_BUFFER;

//
// Structure for FSCTL_SET_SPARSE
//

  PFILE_SET_SPARSE_BUFFER = ^FILE_SET_SPARSE_BUFFER;
  {$EXTERNALSYM PFILE_SET_SPARSE_BUFFER}
  _FILE_SET_SPARSE_BUFFER = record
    SetSparse: ByteBool;
  end;
  {$EXTERNALSYM _FILE_SET_SPARSE_BUFFER}
  FILE_SET_SPARSE_BUFFER = _FILE_SET_SPARSE_BUFFER;
  {$EXTERNALSYM FILE_SET_SPARSE_BUFFER}
  TFileSetSparseBuffer = FILE_SET_SPARSE_BUFFER;
  PFileSetSparseBuffer = PFILE_SET_SPARSE_BUFFER;

//
// Structure for FSCTL_SET_ZERO_DATA
//

  PFILE_ZERO_DATA_INFORMATION = ^FILE_ZERO_DATA_INFORMATION;
  {$EXTERNALSYM PFILE_ZERO_DATA_INFORMATION}
  _FILE_ZERO_DATA_INFORMATION = record
    FileOffset: LARGE_INTEGER;
    BeyondFinalZero: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _FILE_ZERO_DATA_INFORMATION}
  FILE_ZERO_DATA_INFORMATION = _FILE_ZERO_DATA_INFORMATION;
  {$EXTERNALSYM FILE_ZERO_DATA_INFORMATION}
  TFileZeroDataInformation = FILE_ZERO_DATA_INFORMATION;
  PFileZeroDataInformation = PFILE_ZERO_DATA_INFORMATION;

//
// Structure for FSCTL_QUERY_ALLOCATED_RANGES
//

//
// Querying the allocated ranges requires an output buffer to store the
// allocated ranges and an input buffer to specify the range to query.
// The input buffer contains a single entry, the output buffer is an
// array of the following structure.
//

  PFILE_ALLOCATED_RANGE_BUFFER = ^FILE_ALLOCATED_RANGE_BUFFER;
  {$EXTERNALSYM PFILE_ALLOCATED_RANGE_BUFFER}
  _FILE_ALLOCATED_RANGE_BUFFER = record
    FileOffset: LARGE_INTEGER;
    Length: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _FILE_ALLOCATED_RANGE_BUFFER}
  FILE_ALLOCATED_RANGE_BUFFER = _FILE_ALLOCATED_RANGE_BUFFER;
  {$EXTERNALSYM FILE_ALLOCATED_RANGE_BUFFER}
  TFileAllocatedRangeBuffer = FILE_ALLOCATED_RANGE_BUFFER;
  PFileAllocatedRangeBuffer = PFILE_ALLOCATED_RANGE_BUFFER;

//
// Structures for FSCTL_SET_ENCRYPTION, FSCTL_WRITE_RAW_ENCRYPTED, and FSCTL_READ_RAW_ENCRYPTED
//

//
//  The input buffer to set encryption indicates whether we are to encrypt/decrypt a file
//  or an individual stream.
//

  PENCRYPTION_BUFFER = ^ENCRYPTION_BUFFER;
  {$EXTERNALSYM PENCRYPTION_BUFFER}
  _ENCRYPTION_BUFFER = record
    EncryptionOperation: DWORD;
    Private_: array [0..0] of BYTE;
  end;
  {$EXTERNALSYM _ENCRYPTION_BUFFER}
  ENCRYPTION_BUFFER = _ENCRYPTION_BUFFER;
  {$EXTERNALSYM ENCRYPTION_BUFFER}
  TEncryptionBuffer = ENCRYPTION_BUFFER;
  PEncryptionBuffer = PENCRYPTION_BUFFER;

const
  FILE_SET_ENCRYPTION      = $00000001;
  {$EXTERNALSYM FILE_SET_ENCRYPTION}
  FILE_CLEAR_ENCRYPTION    = $00000002;
  {$EXTERNALSYM FILE_CLEAR_ENCRYPTION}
  STREAM_SET_ENCRYPTION    = $00000003;
  {$EXTERNALSYM STREAM_SET_ENCRYPTION}
  STREAM_CLEAR_ENCRYPTION  = $00000004;
  {$EXTERNALSYM STREAM_CLEAR_ENCRYPTION}

  MAXIMUM_ENCRYPTION_VALUE = $00000004;
  {$EXTERNALSYM MAXIMUM_ENCRYPTION_VALUE}

//
//  The optional output buffer to set encryption indicates that the last encrypted
//  stream in a file has been marked as decrypted.
//

type
  PDECRYPTION_STATUS_BUFFER = ^DECRYPTION_STATUS_BUFFER;
  {$EXTERNALSYM PDECRYPTION_STATUS_BUFFER}
  _DECRYPTION_STATUS_BUFFER = record
    NoEncryptedStreams: ByteBool;
  end;
  {$EXTERNALSYM _DECRYPTION_STATUS_BUFFER}
  DECRYPTION_STATUS_BUFFER = _DECRYPTION_STATUS_BUFFER;
  {$EXTERNALSYM DECRYPTION_STATUS_BUFFER}
  TDecryptionStatusBuffer = DECRYPTION_STATUS_BUFFER;
  PDecryptionStatusBuffer = PDECRYPTION_STATUS_BUFFER;

const
  ENCRYPTION_FORMAT_DEFAULT = $01;
  {$EXTERNALSYM ENCRYPTION_FORMAT_DEFAULT}

  COMPRESSION_FORMAT_SPARSE = $4000;
  {$EXTERNALSYM COMPRESSION_FORMAT_SPARSE}

//
//  Request Encrypted Data structure.  This is used to indicate
//  the range of the file to read.  It also describes the
//  output buffer used to return the data.
//

type
  PREQUEST_RAW_ENCRYPTED_DATA = ^REQUEST_RAW_ENCRYPTED_DATA;
  {$EXTERNALSYM PREQUEST_RAW_ENCRYPTED_DATA}
  _REQUEST_RAW_ENCRYPTED_DATA = record
    //
    //  Requested file offset and requested length to read.
    //  The fsctl will round the starting offset down
    //  to a file system boundary.  It will also
    //  round the length up to a file system boundary.
    //
    FileOffset: LONGLONG;
    Length: DWORD;
  end;
  {$EXTERNALSYM _REQUEST_RAW_ENCRYPTED_DATA}
  REQUEST_RAW_ENCRYPTED_DATA = _REQUEST_RAW_ENCRYPTED_DATA;
  {$EXTERNALSYM REQUEST_RAW_ENCRYPTED_DATA}
  TRequestRawEncryptedData = REQUEST_RAW_ENCRYPTED_DATA;
  PRequestRawEncryptedData = PREQUEST_RAW_ENCRYPTED_DATA;

//
//  Encrypted Data Information structure.  This structure
//  is used to return raw encrypted data from a file in
//  order to perform off-line recovery.  The data will be
//  encrypted or encrypted and compressed.  The off-line
//  service will need to use the encryption and compression
//  format information to recover the file data.  In the
//  event that the data is both encrypted and compressed then
//  the decryption must occur before decompression.  All
//  the data units below must be encrypted and compressed
//  with the same format.
//
//  The data will be returned in units.  The data unit size
//  will be fixed per request.  If the data is compressed
//  then the data unit size will be the compression unit size.
//
//  This structure is at the beginning of the buffer used to
//  return the encrypted data.  The actual raw bytes from
//  the file will follow this buffer.  The offset of the
//  raw bytes from the beginning of this structure is
//  specified in the REQUEST_RAW_ENCRYPTED_DATA structure
//  described above.
//

  PENCRYPTED_DATA_INFO = ^ENCRYPTED_DATA_INFO;
  {$EXTERNALSYM PENCRYPTED_DATA_INFO}
  _ENCRYPTED_DATA_INFO = record

    //
    //  This is the file offset for the first entry in the
    //  data block array.  The file system will round
    //  the requested start offset down to a boundary
    //  that is consistent with the format of the file.
    //

    StartingFileOffset: DWORDLONG;

    //
    //  Data offset in output buffer.  The output buffer
    //  begins with an ENCRYPTED_DATA_INFO structure.
    //  The file system will then store the raw bytes from
    //  disk beginning at the following offset within the
    //  output buffer.
    //

    OutputBufferOffset: DWORD;

    //
    //  The number of bytes being returned that are within
    //  the size of the file.  If this value is less than
    //  (NumberOfDataBlocks << DataUnitShift), it means the
    //  end of the file occurs within this transfer.  Any
    //  data beyond file size is invalid and was never
    //  passed to the encryption driver.
    //

    BytesWithinFileSize: DWORD;

    //
    //  The number of bytes being returned that are below
    //  valid data length.  If this value is less than
    //  (NumberOfDataBlocks << DataUnitShift), it means the
    //  end of the valid data occurs within this transfer.
    //  After decrypting the data from this transfer, any
    //  byte(s) beyond valid data length must be zeroed.
    //

    BytesWithinValidDataLength: DWORD;

    //
    //  Code for the compression format as defined in
    //  ntrtl.h.  Note that COMPRESSION_FORMAT_NONE
    //  and COMPRESSION_FORMAT_DEFAULT are invalid if
    //  any of the described chunks are compressed.
    //

    CompressionFormat: WORD;

    //
    //  The DataUnit is the granularity used to access the
    //  disk.  It will be the same as the compression unit
    //  size for a compressed file.  For an uncompressed
    //  file, it will be some cluster-aligned power of 2 that
    //  the file system deems convenient.  A caller should
    //  not expect that successive calls will have the
    //  same data unit shift value as the previous call.
    //
    //  Since chunks and compression units are expected to be
    //  powers of 2 in size, we express them log2.  So, for
    //  example (1 << ChunkShift) == ChunkSizeInBytes.  The
    //  ClusterShift indicates how much space must be saved
    //  to successfully compress a compression unit - each
    //  successfully compressed data unit must occupy
    //  at least one cluster less in bytes than an uncompressed
    //  data block unit.
    //

    DataUnitShift: BYTE;
    ChunkShift: BYTE;
    ClusterShift: BYTE;

    //
    //  The format for the encryption.
    //

    EncryptionFormat: BYTE;

    //
    //  This is the number of entries in the data block size
    //  array.
    //

    NumberOfDataBlocks: WORD;

    //
    //  This is an array of sizes in the data block array.  There
    //  must be one entry in this array for each data block
    //  read from disk.  The size has a different meaning
    //  depending on whether the file is compressed.
    //
    //  A size of zero always indicates that the final data consists entirely
    //  of zeroes.  There is no decryption or decompression to
    //  perform.
    //
    //  If the file is compressed then the data block size indicates
    //  whether this block is compressed.  A size equal to
    //  the block size indicates that the corresponding block did
    //  not compress.  Any other non-zero size indicates the
    //  size of the compressed data which needs to be
    //  decrypted/decompressed.
    //
    //  If the file is not compressed then the data block size
    //  indicates the amount of data within the block that
    //  needs to be decrypted.  Any other non-zero size indicates
    //  that the remaining bytes in the data unit within the file
    //  consists of zeros.  An example of this is when the
    //  the read spans the valid data length of the file.  There
    //  is no data to decrypt past the valid data length.
    //

    DataBlockSize: array [0..ANYSIZE_ARRAY - 1] of DWORD;
  end;
  {$EXTERNALSYM _ENCRYPTED_DATA_INFO}
  ENCRYPTED_DATA_INFO = _ENCRYPTED_DATA_INFO;
  {$EXTERNALSYM ENCRYPTED_DATA_INFO}
  TEncryptedDataInfo = ENCRYPTED_DATA_INFO;
  PEncryptedDataInfo = PENCRYPTED_DATA_INFO;

//
//  FSCTL_READ_FROM_PLEX support
//  Request Plex Read Data structure.  This is used to indicate
//  the range of the file to read.  It also describes
//  which plex to perform the read from.
//

  _PLEX_READ_DATA_REQUEST = record

    //
    //  Requested offset and length to read.
    //  The offset can be the virtual offset (vbo) in to a file,
    //  or a volume. In the case of a file offset,
    //  the fsd will round the starting offset down
    //  to a file system boundary.  It will also
    //  round the length up to a file system boundary and
    //  enforce any other applicable limits.
    //

    ByteOffset: LARGE_INTEGER;
    ByteLength: DWORD;
    PlexNumber: DWORD;
  end;
  {$EXTERNALSYM _PLEX_READ_DATA_REQUEST}
  PLEX_READ_DATA_REQUEST = _PLEX_READ_DATA_REQUEST;
  {$EXTERNALSYM PLEX_READ_DATA_REQUEST}
  PPLEX_READ_DATA_REQUEST = ^PLEX_READ_DATA_REQUEST;
  {$EXTERNALSYM PPLEX_READ_DATA_REQUEST}
  TPlexReadDataRequest = PLEX_READ_DATA_REQUEST;
  PPlexReadDataRequest = PPLEX_READ_DATA_REQUEST;  

//
// FSCTL_SIS_COPYFILE support
// Source and destination file names are passed in the FileNameBuffer.
// Both strings are null terminated, with the source name starting at
// the beginning of FileNameBuffer, and the destination name immediately
// following.  Length fields include terminating nulls.
//

  PSI_COPYFILE = ^SI_COPYFILE;
  {$EXTERNALSYM PSI_COPYFILE}
  _SI_COPYFILE = record
    SourceFileNameLength: DWORD;
    DestinationFileNameLength: DWORD;
    Flags: DWORD;
    FileNameBuffer: array [0..0] of WCHAR;
  end;
  {$EXTERNALSYM _SI_COPYFILE}
  SI_COPYFILE = _SI_COPYFILE;
  {$EXTERNALSYM SI_COPYFILE}
  TSiCopyfile = SI_COPYFILE;
  PSiCopyfile = PSI_COPYFILE;

const
  COPYFILE_SIS_LINK    = $0001; // Copy only if source is SIS
  {$EXTERNALSYM COPYFILE_SIS_LINK}
  COPYFILE_SIS_REPLACE = $0002; // Replace destination if it exists, otherwise don't.
  {$EXTERNALSYM COPYFILE_SIS_REPLACE}
  COPYFILE_SIS_FLAGS   = $0003;
  {$EXTERNALSYM COPYFILE_SIS_FLAGS}

//
// These IOCTLs are handled by hard disk volumes.
//

  IOCTL_VOLUME_BASE = DWORD('V');
  {$EXTERNALSYM IOCTL_VOLUME_BASE}

  IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS = (
    (IOCTL_VOLUME_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    (0 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS}

  IOCTL_VOLUME_IS_CLUSTERED = (
    (IOCTL_VOLUME_BASE shl 16) or (FILE_ANY_ACCESS shl 14) or
    (12 shl 2) or METHOD_BUFFERED);
  {$EXTERNALSYM IOCTL_VOLUME_IS_CLUSTERED}

//
// Disk extent definition.
//

type
  PDISK_EXTENT = ^DISK_EXTENT;
  {$EXTERNALSYM PDISK_EXTENT}
  _DISK_EXTENT = record
    DiskNumber: DWORD;
    StartingOffset: LARGE_INTEGER;
    ExtentLength: LARGE_INTEGER;
  end;
  {$EXTERNALSYM _DISK_EXTENT}
  DISK_EXTENT = _DISK_EXTENT;
  {$EXTERNALSYM DISK_EXTENT}
  TDiskExtent = DISK_EXTENT;
  PDiskExtent = PDISK_EXTENT;

//
// Output structure for IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS.
//

  PVOLUME_DISK_EXTENTS = ^VOLUME_DISK_EXTENTS;
  {$EXTERNALSYM PVOLUME_DISK_EXTENTS}
  _VOLUME_DISK_EXTENTS = record
    NumberOfDiskExtents: DWORD;
    Extents: array [0..0] of DISK_EXTENT;
  end;
  {$EXTERNALSYM _VOLUME_DISK_EXTENTS}
  VOLUME_DISK_EXTENTS = _VOLUME_DISK_EXTENTS;
  {$EXTERNALSYM VOLUME_DISK_EXTENTS}
  TVolumeDiskExtents = VOLUME_DISK_EXTENTS;
  PVolumeDiskExtents = PVOLUME_DISK_EXTENTS;

implementation

function CTL_CODE(DeviceType, Func, Method, Access: WORD): DWORD;
begin
  Result := (DeviceType shl 16) or (Access shl 14) or (Func shl 2) or Method;
end;

function DEVICE_TYPE_FROM_CTL_CODE(CtrlCode: DWORD): WORD;
begin
  Result := (CtrlCode and DWORD($FFFF0000)) shr 16;
end;

{
#define IsRecognizedPartition( PartitionType ) (    \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT_12)) ||  \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_IFS)) ||  \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_HUGE)) ||  \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32)) ||  \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32_XINT13)) ||  \
     ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_XINT13)) ||  \
     ((PartitionType) == PARTITION_FAT_12)          ||  \
     ((PartitionType) == PARTITION_FAT_16)          ||  \
     ((PartitionType) == PARTITION_IFS)             ||  \
     ((PartitionType) == PARTITION_HUGE)            ||  \
     ((PartitionType) == PARTITION_FAT32)           ||  \
     ((PartitionType) == PARTITION_FAT32_XINT13)    ||  \
     ((PartitionType) == PARTITION_XINT13) )
}

function IsRecognizedPartition(PartitionType: DWORD): Boolean;
begin
  Result :=
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_FAT_12)) or
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_IFS)) or
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_HUGE)) or
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_FAT32)) or
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_FAT32_XINT13)) or
    (((PartitionType and PARTITION_NTFT) <> 0) and ((PartitionType and not $C0) = PARTITION_XINT13)) or
    ((PartitionType) = PARTITION_FAT_12) or
    ((PartitionType) = PARTITION_FAT_16) or
    ((PartitionType) = PARTITION_IFS) or
    ((PartitionType) = PARTITION_HUGE) or
    ((PartitionType) = PARTITION_FAT32) or
    ((PartitionType) = PARTITION_FAT32_XINT13) or
    ((PartitionType) = PARTITION_XINT13);
end;

function IsContainerPartition(PartitionType: DWORD): Boolean;
begin
  Result :=
    (PartitionType = PARTITION_EXTENDED) or
    (PartitionType = PARTITION_XINT13_EXTENDED);
end;

function IsFTPartition(PartitionType: DWORD): Boolean;
begin
  Result := ((PartitionType and PARTITION_NTFT) <> 0) and IsRecognizedPartition(PartitionType);
end;

function DiskGeometryGetPartition(Geometry: PDiskGeometryEx): PDiskPartitionInfo;
begin
  Result := @Geometry^.Data[0];
end;

function DiskGeometryGetDetect(Geometry: PDiskGeometryEx): PDiskDetectionInfo;
var
  Partition: PDiskPartitionInfo;
begin
  Partition := DiskGeometryGetPartition(Geometry);
  Result := PDiskDetectionInfo(PChar(Partition) + Partition^.SizeOfPartitionInfo*SizeOf(DWORD));
end;

end.