867 lines
28 KiB
Plaintext
867 lines
28 KiB
Plaintext
unit EM.winioctl;
|
|
|
|
// John Newbigin
|
|
// from winioctl.h
|
|
|
|
{$A+,Z+}
|
|
|
|
interface
|
|
uses WinApi.Windows;
|
|
|
|
const
|
|
Large0 : _Large_Integer = (LowPart : 0; HighPart : 0) ;
|
|
|
|
function div2(a : LongInt; b : LongInt) : LongInt;
|
|
|
|
{ function DeviceIoControl(hDevice : THandle; dwIoControlCode : DWORD;
|
|
var lpInBuffer; nInBuffer : DWORD;
|
|
var lpOutuffer; nOutBuffer : DWORD;
|
|
var BytesReturned: DWORD; Overlapped : pOverlapped):BOOL; stdcall;
|
|
}
|
|
function DeviceIoControl(hDevice : THandle; dwIoControlCode : DWORD;
|
|
lpInBuffer : Pointer; nInBuffer : DWORD;
|
|
lpOutuffer : Pointer; nOutBuffer : DWORD;
|
|
var BytesReturned: DWORD; Overlapped : pOverlapped):BOOL; stdcall;
|
|
|
|
function ReadFile2(hFile: THandle; Buffer : Pointer; nNumberOfBytesToRead: DWORD;
|
|
var lpNumberOfBytesRead: DWORD; lpOverlapped: POverlapped): BOOL; stdcall;
|
|
function WriteFile2(hFile: THandle; Buffer : Pointer; nNumberOfBytesToWrite: DWORD;
|
|
var lpNumberOfBytesWritten: DWORD; lpOverlapped: POverlapped): BOOL; stdcall;
|
|
|
|
|
|
type
|
|
DEVICE_TYPE=DWORD;
|
|
|
|
|
|
const
|
|
FILE_DEVICE_BEEP = $00000001;
|
|
FILE_DEVICE_CD_ROM = $00000002;
|
|
FILE_DEVICE_CD_ROM_FILE_SYSTEM = $00000003;
|
|
FILE_DEVICE_CONTROLLER = $00000004;
|
|
FILE_DEVICE_DATALINK = $00000005;
|
|
FILE_DEVICE_DFS = $00000006;
|
|
FILE_DEVICE_DISK = $00000007;
|
|
FILE_DEVICE_DISK_FILE_SYSTEM = $00000008;
|
|
FILE_DEVICE_FILE_SYSTEM = $00000009;
|
|
FILE_DEVICE_INPORT_PORT = $0000000a;
|
|
FILE_DEVICE_KEYBOARD = $0000000b;
|
|
FILE_DEVICE_MAILSLOT = $0000000c;
|
|
FILE_DEVICE_MIDI_IN = $0000000d;
|
|
FILE_DEVICE_MIDI_OUT = $0000000e;
|
|
FILE_DEVICE_MOUSE = $0000000f;
|
|
FILE_DEVICE_MULTI_UNC_PROVIDER = $00000010;
|
|
FILE_DEVICE_NAMED_PIPE = $00000011;
|
|
FILE_DEVICE_NETWORK = $00000012;
|
|
FILE_DEVICE_NETWORK_BROWSER = $00000013;
|
|
FILE_DEVICE_NETWORK_FILE_SYSTEM= $00000014;
|
|
FILE_DEVICE_NULL = $00000015;
|
|
FILE_DEVICE_PARALLEL_PORT = $00000016;
|
|
FILE_DEVICE_PHYSICAL_NETCARD = $00000017;
|
|
FILE_DEVICE_PRINTER = $00000018;
|
|
FILE_DEVICE_SCANNER = $00000019;
|
|
FILE_DEVICE_SERIAL_MOUSE_PORT = $0000001a;
|
|
FILE_DEVICE_SERIAL_PORT = $0000001b;
|
|
FILE_DEVICE_SCREEN = $0000001c;
|
|
FILE_DEVICE_SOUND = $0000001d;
|
|
FILE_DEVICE_STREAMS = $0000001e;
|
|
FILE_DEVICE_TAPE = $0000001f;
|
|
FILE_DEVICE_TAPE_FILE_SYSTEM = $00000020;
|
|
FILE_DEVICE_TRANSPORT = $00000021;
|
|
FILE_DEVICE_UNKNOWN = $00000022;
|
|
FILE_DEVICE_VIDEO = $00000023;
|
|
FILE_DEVICE_VIRTUAL_DISK = $00000024;
|
|
FILE_DEVICE_WAVE_IN = $00000025;
|
|
FILE_DEVICE_WAVE_OUT = $00000026;
|
|
FILE_DEVICE_8042_PORT = $00000027;
|
|
FILE_DEVICE_NETWORK_REDIRECTOR = $00000028;
|
|
FILE_DEVICE_BATTERY = $00000029;
|
|
FILE_DEVICE_BUS_EXTENDER = $0000002a;
|
|
FILE_DEVICE_MODEM = $0000002b;
|
|
FILE_DEVICE_VDM = $0000002c;
|
|
FILE_DEVICE_MASS_STORAGE = $0000002d;
|
|
|
|
IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE;
|
|
{//
|
|
// 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.
|
|
//
|
|
|
|
#define CTL_CODE( DeviceType, Function, Method, Access ) ( \
|
|
((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
|
|
)
|
|
|
|
//
|
|
// Define the method codes for how buffers are passed for I/O and FS controls
|
|
//}
|
|
|
|
const
|
|
METHOD_BUFFERED = 0;
|
|
METHOD_IN_DIRECT = 1;
|
|
METHOD_OUT_DIRECT = 2;
|
|
METHOD_NEITHER = 3;
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
const
|
|
FILE_ANY_ACCESS = $00;
|
|
FILE_READ_ACCESS = $01; // file & pipe
|
|
FILE_WRITE_ACCESS = $02; // file & pipe
|
|
|
|
// end_ntddk end_nthal end_ntifs
|
|
|
|
//
|
|
// IoControlCode values for disk devices.
|
|
//
|
|
|
|
const
|
|
IOCTL_DISK_GET_DRIVE_GEOMETRY = $00070000;
|
|
|
|
//
|
|
// Define the partition types returnable by known disk drivers.
|
|
//
|
|
|
|
const
|
|
PARTITION_ENTRY_UNUSED = $00; // Entry unused
|
|
PARTITION_FAT_12 = $01; // 12-bit FAT entries
|
|
PARTITION_XENIX_1 = $02; // Xenix
|
|
PARTITION_XENIX_2 = $03; // Xenix
|
|
PARTITION_FAT_16 = $04; // 16-bit FAT entries
|
|
PARTITION_EXTENDED = $05; // Extended partition entry
|
|
PARTITION_HUGE = $06; // Huge partition MS-DOS V4
|
|
PARTITION_IFS = $07; // IFS Partition
|
|
PARTITION_UNIX = $63; // Unix
|
|
PARTITION_LINUX_SWAP = $82; // Linux Swap Partition
|
|
PARTITION_LINUX = $83; // Linux Native Partition
|
|
|
|
VALID_NTFT = $C0; // NTFT uses high order bits
|
|
|
|
PARTITION_EXTENDED_LINUX = $85; // Extended partition entry
|
|
PARTITION_EXTENDED_WIN98 = $0f; // Extended partition entry
|
|
|
|
EXTENDED_PARTITIONS = [ PARTITION_EXTENDED, PARTITION_EXTENDED_LINUX, PARTITION_EXTENDED_WIN98 ];
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
//--
|
|
{
|
|
#define IsRecognizedPartition( PartitionType ) ( \
|
|
(((PartitionType & ~0xC0) == PARTITION_FAT_12) || \
|
|
((PartitionType & ~0xC0) == PARTITION_FAT_16) || \
|
|
((PartitionType & ~0xC0) == PARTITION_IFS) || \
|
|
((PartitionType & ~0xC0) == PARTITION_HUGE)) )
|
|
}
|
|
//
|
|
// 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
|
|
|
|
//
|
|
// Define the media types supported by the driver.
|
|
//
|
|
|
|
{typedef enum _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
|
|
MEDIA_TYPE, *PMEDIA_TYPE;}
|
|
|
|
const
|
|
Media_Type_Unknown = 0; // Format is unknown
|
|
Media_Type_F5_1Pt2_512 = 1; // 5.25", 1.2MB, 512 bytes/sector
|
|
Media_Type_F3_1Pt44_512 = 2; // 3.5", 1.44MB, 512 bytes/sector
|
|
Media_Type_F3_2Pt88_512 = 3; // 3.5", 2.88MB, 512 bytes/sector
|
|
Media_Type_F3_20Pt8_512 = 4; // 3.5", 20.8MB, 512 bytes/sector
|
|
Media_Type_F3_720_512 = 5; // 3.5", 720KB, 512 bytes/sector
|
|
Media_Type_F5_360_512 = 6; // 5.25", 360KB, 512 bytes/sector
|
|
Media_Type_F5_320_512 = 7; // 5.25", 320KB, 512 bytes/sector
|
|
Media_Type_F5_320_1024 = 8; // 5.25", 320KB, 1024 bytes/sector
|
|
Media_Type_F5_180_512 = 9; // 5.25", 180KB, 512 bytes/sector
|
|
Media_Type_F5_160_512 = 10; // 5.25", 160KB, 512 bytes/sector
|
|
Media_Type_RemovableMedia= 11; // Removable media other than floppy
|
|
Media_Type_FixedMedia = 12; // Fixed hard disk media
|
|
|
|
//
|
|
// Define the input buffer structure for the driver, when
|
|
// it is called with IOCTL_DISK_FORMAT_TRACKS.
|
|
//
|
|
|
|
const
|
|
DFP_RECEIVE_DRIVE_DATA = $0007c088;
|
|
|
|
type
|
|
USHORT = Word;
|
|
//----------- IDE Serial 얻기 위한 선언들 (시작)....
|
|
PDRIVERSTATUS = ^TDRIVERSTATUS;
|
|
TDRIVERSTATUS = 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;
|
|
//} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
|
|
|
|
|
|
TSENDCMDOUTPARAMS = packed record
|
|
cBufferSize : DWORD; // Size of bBuffer in bytes
|
|
DriverStatus : TDRIVERSTATUS; // Driver status structure.
|
|
bBuffer : array[0..511] of BYTE; // Buffer of arbitrary length
|
|
end;
|
|
PIDSECTOR = ^TIDSECTOR;
|
|
TIDSECTOR = packed record
|
|
wGenConfig : USHORT;
|
|
wNumCyls : USHORT;
|
|
wReserved : USHORT;
|
|
wNumHeads : USHORT;
|
|
wBytesPerTrack : USHORT;
|
|
wBytesPerSector : USHORT;
|
|
wSectorsPerTrack : USHORT;
|
|
wVendorUnique : array[0..2] of USHORT;
|
|
sSerialNumber : array[0..19] of char;
|
|
wBufferType : USHORT;
|
|
wBufferSize : USHORT;
|
|
wECCSize : USHORT;
|
|
sFirmwareRev : array[0..7] of char;
|
|
sModelNumber : array[0..39] of char;
|
|
wMoreVendorUnique,
|
|
wDoubleWordIO,
|
|
wCapabilities,
|
|
wReserved1,
|
|
wPIOTiming,
|
|
wDMATiming,
|
|
wBS,
|
|
wNumCurrentCyls,
|
|
wNumCurrentHeads,
|
|
wNumCurrentSectorsPerTrack : USHORT;
|
|
ulCurrentSectorCapacity : ULONG ;
|
|
wMultSectorStuff : USHORT;
|
|
ulTotalAddressableSectors : ULONG ;
|
|
wSingleWordDMA : USHORT ;
|
|
wMultiWordDMA : USHORT ;
|
|
bReserved : array[0..127] of BYTE;
|
|
end;
|
|
|
|
TIDEREGS = packed record
|
|
bFeaturesReg, // Used for specifying SMART "commands".
|
|
bSectorCountReg, // IDE sector count register
|
|
bSectorNumberReg, // IDE sector number register
|
|
bCylLowReg, // IDE low order cylinder value
|
|
bCylHighReg, // IDE high order cylinder value
|
|
bDriveHeadReg, // IDE drive/head register
|
|
bCommandReg, // Actual IDE command.
|
|
bReserved : BYTE; // reserved for future use. Must be zero.
|
|
end;
|
|
//} IDEREGS, *PIDEREGS, *LPIDEREGS;
|
|
|
|
|
|
PSENDCMDINPARAMS = ^TSENDCMDINPARAMS;
|
|
TSENDCMDINPARAMS = packed record
|
|
cBufferSize : DWORD; // Buffer size in bytes
|
|
irDriveRegs : TIDEREGS; // 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;// SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
|
|
|
|
//----------- IDE Serial 얻기 위한 선언들 (끝)....
|
|
|
|
PDISK_EXTENT = ^TDISK_EXTENT;
|
|
TDISK_EXTENT = record
|
|
DiskNumber : DWORD;
|
|
StartingOffset : LARGE_INTEGER ;
|
|
ExtentLength : LARGE_INTEGER;
|
|
end;
|
|
|
|
PVOLUME_DISK_EXTENTS = ^TVOLUME_DISK_EXTENTS;
|
|
TVOLUME_DISK_EXTENTS = record
|
|
NumberOfDiskExtents : DWORD ;
|
|
Extents : array[0..1] of TDISK_EXTENT;
|
|
end;
|
|
|
|
TFORMAT_PARAMETERS = record
|
|
MediaType : DWORD;
|
|
StartCylinderNumber : DWORD ;
|
|
EndCylinderNumber : DWORD ;
|
|
StartHeadNumber : DWORD ;
|
|
EndHeadNumber : DWORD ;
|
|
end;
|
|
PFORMAT_PARAMETERS = ^TFORMAT_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.
|
|
//
|
|
|
|
//typedef WORD BAD_TRACK_NUMBER;
|
|
//typedef WORD *PBAD_TRACK_NUMBER;
|
|
|
|
//
|
|
// Define the input buffer structure for the driver, when
|
|
// it is called with IOCTL_DISK_FORMAT_TRACKS_EX.
|
|
//
|
|
|
|
type
|
|
TFORMAT_EX_PARAMETERS = record
|
|
MediaType : DWORD;
|
|
StartCylinderNumber : DWORD;
|
|
EndCylinderNumber : DWORD;
|
|
StartHeadNumber : DWORD;
|
|
EndHeadNumber : DWORD;
|
|
FormatGapLength : WORD;
|
|
SectorsPerTrack : WORD;
|
|
SectorNumber : array[0..0] of WORD;
|
|
end;
|
|
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
type
|
|
TDISK_GEOMETRY = packed record
|
|
Cylinders : _LARGE_INTEGER;//TLargeInteger ;//LARGE_INTEGER ;
|
|
MediaType : DWord;
|
|
TracksPerCylinder : DWORD;
|
|
SectorsPerTrack : DWORD;
|
|
BytesPerSector : DWORD;
|
|
end;
|
|
PDISK_GEOMETRY = ^TDISK_GEOMETRY;
|
|
|
|
TDISK_GEOMETRY_EX = packed record
|
|
Geometry : TDISK_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;
|
|
PDISK_GEOMETRY_EX = ^TDISK_GEOMETRY_EX;
|
|
|
|
//
|
|
// The following structure is passed in on an IOCTL_DISK_VERIFY request.
|
|
// The offset and length parameters are both given in bytes.
|
|
//
|
|
{$ifdef xxx}
|
|
typedef struct _VERIFY_INFORMATION {
|
|
LARGE_INTEGER StartingOffset;
|
|
DWORD Length;
|
|
} VERIFY_INFORMATION, *PVERIFY_INFORMATION;
|
|
|
|
//
|
|
// The following structure is passed in on an IOCTL_DISK_REASSIGN_BLOCKS
|
|
// request.
|
|
//
|
|
|
|
typedef struct _REASSIGN_BLOCKS {
|
|
WORD Reserved;
|
|
WORD Count;
|
|
DWORD BlockNumber[1];
|
|
} REASSIGN_BLOCKS, *PREASSIGN_BLOCKS;
|
|
|
|
//
|
|
// IOCTL_DISK_MEDIA_REMOVAL disables the mechanism
|
|
// on a SCSI device that ejects media. This function
|
|
// may or may not be supported on SCSI devices that
|
|
// support removable media.
|
|
//
|
|
// TRUE means prevent media from being removed.
|
|
// FALSE means allow media removal.
|
|
//
|
|
|
|
typedef struct _PREVENT_MEDIA_REMOVAL {
|
|
BOOLEAN PreventMediaRemoval;
|
|
} PREVENT_MEDIA_REMOVAL, *PPREVENT_MEDIA_REMOVAL;
|
|
|
|
///////////////////////////////////////////////////////
|
|
// //
|
|
// 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.
|
|
//
|
|
|
|
typedef struct _DISK_PERFORMANCE {
|
|
LARGE_INTEGER BytesRead;
|
|
LARGE_INTEGER BytesWritten;
|
|
LARGE_INTEGER ReadTime;
|
|
LARGE_INTEGER WriteTime;
|
|
DWORD ReadCount;
|
|
DWORD WriteCount;
|
|
DWORD QueueDepth;
|
|
} DISK_PERFORMANCE, *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.
|
|
//
|
|
|
|
typedef struct _DISK_RECORD {
|
|
LARGE_INTEGER ByteOffset;
|
|
LARGE_INTEGER StartTime;
|
|
LARGE_INTEGER EndTime;
|
|
PVOID VirtualAddress;
|
|
DWORD NumberOfBytes;
|
|
BYTE DeviceNumber;
|
|
BOOLEAN ReadRequest;
|
|
} DISK_RECORD, *PDISK_RECORD;
|
|
|
|
//
|
|
// The following structure is exchanged on an IOCTL_DISK_LOG request.
|
|
// Not all fields are valid with each function type.
|
|
//
|
|
|
|
typedef struct _DISK_LOGGING {
|
|
BYTE Function;
|
|
PVOID BufferAddress;
|
|
DWORD BufferSize;
|
|
} DISK_LOGGING, *PDISK_LOGGING;
|
|
|
|
//
|
|
// Disk logging functions
|
|
//
|
|
// Start disk logging. Only the Function and BufferSize fields are valid.
|
|
//
|
|
|
|
#define DISK_LOGGING_START 0
|
|
|
|
//
|
|
// Stop disk logging. Only the Function field is valid.
|
|
//
|
|
|
|
#define DISK_LOGGING_STOP 1
|
|
|
|
//
|
|
// Return disk log. All fields are valid. Data will be copied from internal
|
|
// buffer to buffer specified for the number of bytes requested.
|
|
//
|
|
|
|
#define DISK_LOGGING_DUMP 2
|
|
|
|
//
|
|
// 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+.
|
|
//
|
|
|
|
#define DISK_BINNING 3
|
|
|
|
//
|
|
// Bin types
|
|
//
|
|
|
|
typedef enum _BIN_TYPES {
|
|
RequestSize,
|
|
RequestLocation
|
|
} BIN_TYPES;
|
|
|
|
//
|
|
// Bin ranges
|
|
//
|
|
|
|
typedef struct _BIN_RANGE {
|
|
LARGE_INTEGER StartValue;
|
|
LARGE_INTEGER Length;
|
|
} BIN_RANGE, *PBIN_RANGE;
|
|
|
|
//
|
|
// Bin definition
|
|
//
|
|
|
|
typedef struct _PERF_BIN {
|
|
DWORD NumberOfBins;
|
|
DWORD TypeOfBin;
|
|
BIN_RANGE BinsRanges[1];
|
|
} PERF_BIN, *PPERF_BIN ;
|
|
|
|
//
|
|
// Bin count
|
|
//
|
|
|
|
typedef struct _BIN_COUNT {
|
|
BIN_RANGE BinRange;
|
|
DWORD BinCount;
|
|
} BIN_COUNT, *PBIN_COUNT;
|
|
|
|
//
|
|
// Bin results
|
|
//
|
|
|
|
typedef struct _BIN_RESULTS {
|
|
DWORD NumberOfBins;
|
|
BIN_COUNT BinCounts[1];
|
|
} BIN_RESULTS, *PBIN_RESULTS;
|
|
|
|
|
|
#define IOCTL_SERIAL_LSRMST_INSERT CTL_CODE(FILE_DEVICE_SERIAL_PORT,31,METHOD_BUFFERED,FILE_ANY_ACCESS)
|
|
|
|
|
|
//
|
|
// The following values follow the escape designator in the
|
|
// data stream if the LSRMST_INSERT mode has been turned on.
|
|
//
|
|
#define SERIAL_LSRMST_ESCAPE ((BYTE )0x00)
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
#define SERIAL_LSRMST_LSR_DATA ((BYTE )0x01)
|
|
|
|
//
|
|
// Following this value is the contents of the line status
|
|
// register. No error character follows
|
|
//
|
|
#define SERIAL_LSRMST_LSR_NODATA ((BYTE )0x02)
|
|
|
|
//
|
|
// Following this value is the contents of the modem status
|
|
// register.
|
|
//
|
|
#define SERIAL_LSRMST_MST ((BYTE )0x03)
|
|
|
|
|
|
#define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_UNLOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_DISMOUNT_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_MOUNT_DBLS_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM,13, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_GET_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM,15, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_SET_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM,16, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
#define FSCTL_READ_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM,17, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
#define FSCTL_WRITE_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM,18, METHOD_NEITHER, FILE_ANY_ACCESS)
|
|
|
|
|
|
#endif // _WINIOCTL_
|
|
{$endif}
|
|
|
|
// 2010-07-26 추가 sunk
|
|
const
|
|
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}
|
|
|
|
type
|
|
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_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;
|
|
|
|
|
|
_NTFS_RECORD_HEADER = record
|
|
Type_ : array[1..4] of AnsiChar;
|
|
UsaOffset: WORD;
|
|
UsaCount: WORD;
|
|
Usn: LONGLONG;
|
|
end;
|
|
NTFS_RECORD_HEADER = _NTFS_RECORD_HEADER;
|
|
PNTFS_RECORD_HEADER = ^NTFS_RECORD_HEADER;
|
|
TNtfsRecordHeader = NTFS_RECORD_HEADER;
|
|
PNtfsRecordHeader = ^TNtfsRecordHeader;
|
|
|
|
_FILE_RECORD_HEADER = record
|
|
Ntfs: NTFS_RECORD_HEADER;
|
|
SequenceNumber: USHORT;
|
|
LinkCount: USHORT;
|
|
AttributesOffset: USHORT;
|
|
Flags: USHORT; // 0x0001 = InUse, 0x0002 = Directory
|
|
BytesInUse: ULONG;
|
|
BytesAllocated: ULONG;
|
|
BaseFileRecord: ULONGLONG;
|
|
NextAttributeNumber: USHORT;
|
|
end;
|
|
FILE_RECORD_HEADER = _FILE_RECORD_HEADER;
|
|
PFILE_RECORD_HEADER = ^FILE_RECORD_HEADER;
|
|
TFileRecordHeader = FILE_RECORD_HEADER;
|
|
PFileRecordHeader = ^TFileRecordHeader;
|
|
|
|
const
|
|
//Type d'attribut d'un FILE_RECORD_HEADER
|
|
AttributeStandardInformation = $10;
|
|
AttributeAttributeList = $20;
|
|
AttributeFileName = $30;
|
|
AttributeObjectId = $40;
|
|
AttributeSecurityDescriptor = $50;
|
|
AttributeVolumeName = $60;
|
|
AttributeVolumeInformation = $70;
|
|
AttributeData = $80;
|
|
AttributeIndexRoot = $90;
|
|
AttributeIndexAllocation = $A0;
|
|
AttributeBitmap = $B0;
|
|
AttributeReparsePoint = $C0;
|
|
AttributeEAInformation = $D0;
|
|
AttributeEA = $E0;
|
|
AttributePropertySet = $F0;
|
|
AttributeLoggedUtilityStream = $100;
|
|
|
|
//Attribut resident d'un FILE_RECORD_HEADER
|
|
type
|
|
ATTRIBUTE_TYPE = AttributeStandardInformation..AttributeLoggedUtilityStream;
|
|
PATTRIBUTE_TYPE = ^ATTRIBUTE_TYPE;
|
|
TAttributeType = ATTRIBUTE_TYPE;
|
|
|
|
_ATTRIBUTE = record
|
|
AttributeType: ATTRIBUTE_TYPE;
|
|
Length: ULONG;
|
|
Nonresident: ByteBool;
|
|
NameLength: UCHAR;
|
|
NameOffset: USHORT;
|
|
Flags: USHORT; // 0x0001 = Compressed
|
|
AttributeNumber: USHORT;
|
|
end;
|
|
ATTRIBUTE = _ATTRIBUTE;
|
|
PATTRIBUTE = ^ATTRIBUTE;
|
|
TAttribute = ATTRIBUTE;
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
function CtlCode(DeviceType : DWORD; Func : DWord; Method : DWord; Access : DWord) : DWORD;
|
|
//#define CTL_CODE( DeviceType, Function, Method, Access ) ( \
|
|
// ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
|
|
|
|
|
|
function MediaDescription(Media : Integer) : String;
|
|
|
|
implementation
|
|
|
|
// like div but rounds up
|
|
function div2(a : LongInt; b : LongInt) : LongInt;
|
|
begin
|
|
Result := a div b;
|
|
if (a mod b) > 0 then
|
|
begin
|
|
Inc(Result);
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function CtlCode(DeviceType : DWORD; Func : DWord; Method : DWord; Access : DWord) : DWORD;
|
|
begin
|
|
result := (DeviceType shl 16) or (Access shl 14) or (Func shl 2) or (Method);
|
|
end;
|
|
|
|
function DeviceIoControl; external 'kernel32.dll';
|
|
function ReadFile2; external kernel32 name 'ReadFile';
|
|
function WriteFile2; external kernel32 name 'WriteFile';
|
|
|
|
function MediaDescription(Media : Integer) : String;
|
|
begin
|
|
case Media of
|
|
Media_Type_F5_1Pt2_512: Result := '5.25, 1.2MB, 512 bytes/sector';
|
|
Media_Type_F3_1Pt44_512: Result := '3.5, 1.44MB, 512 bytes/sector';
|
|
Media_Type_F3_2Pt88_512: Result := '3.5, 2.88MB, 512 bytes/sector';
|
|
Media_Type_F3_20Pt8_512: Result := '3.5, 20.8MB, 512 bytes/sector';
|
|
Media_Type_F3_720_512: Result := '3.5, 720KB, 512 bytes/sector';
|
|
Media_Type_F5_360_512: Result := '5.25, 360KB, 512 bytes/sector';
|
|
Media_Type_F5_320_512: Result := '5.25, 320KB, 512 bytes/sector';
|
|
Media_Type_F5_320_1024: Result := '5.25, 320KB, 1024 bytes/sector';
|
|
Media_Type_F5_180_512: Result := '5.25, 180KB, 512 bytes/sector';
|
|
Media_Type_F5_160_512: Result := '5.25, 160KB, 512 bytes/sector';
|
|
Media_Type_RemovableMedia: Result := 'Removable media other than floppy';
|
|
Media_Type_FixedMedia: Result := 'Fixed hard disk media';
|
|
else
|
|
Result := 'Unknown';
|
|
end;
|
|
end;
|
|
|
|
end.
|