mirror of
https://github.com/keymanapp/keyman.git
synced 2026-08-07 17:36:00 +00:00
5025 lines
169 KiB
ObjectPascal
5025 lines
169 KiB
ObjectPascal
{******************************************************************************}
|
|
{ }
|
|
{ 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.9 2007/09/05 11:58:54 dezipaitor Exp $
|
|
|
|
{$IFNDEF JWA_OMIT_SECTIONS}
|
|
unit JwaWinIoctl;
|
|
|
|
{$WEAKPACKAGEUNIT}
|
|
{$ENDIF JWA_OMIT_SECTIONS}
|
|
|
|
{$HPPEMIT ''}
|
|
{$HPPEMIT '#include "WinIoCtl.h"'}
|
|
{$HPPEMIT ''}
|
|
|
|
{$IFNDEF JWA_OMIT_SECTIONS}
|
|
{$I ..\Includes\JediAPILib.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
JwaWinNT, JwaWinType;
|
|
|
|
{$ENDIF JWA_OMIT_SECTIONS}
|
|
|
|
{$IFNDEF JWA_IMPLEMENTATIONSECTION}
|
|
|
|
//
|
|
// 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;
|
|
{$ENDIF JWA_IMPLEMENTATIONSECTION}
|
|
|
|
{$IFNDEF JWA_OMIT_SECTIONS}
|
|
implementation
|
|
//uses ...
|
|
{$ENDIF JWA_OMIT_SECTIONS}
|
|
|
|
{$IFNDEF JWA_INTERFACESECTION}
|
|
|
|
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(PAnsiChar(Partition) + Partition^.SizeOfPartitionInfo*SizeOf(DWORD));
|
|
end;
|
|
|
|
{$ENDIF JWA_INTERFACESECTION}
|
|
|
|
|
|
|
|
{$IFNDEF JWA_OMIT_SECTIONS}
|
|
end.
|
|
{$ENDIF JWA_OMIT_SECTIONS}
|