Artifact 21d3d57439478e49b67c0b7350bbeff2da11f21e
- File
src/win32/winioctl.d
-
2015-05-05 06:49:05
- part of checkin
[9b639cf2d6]
on branch trunk
- Working version for update to 2.067.
The problem was __gshared. Replacing it with TLS fixed the issue. Remaining problem is that "hack.d"'s CloseHandle hack is not working anymore.
(user: kinaba) [annotate]
-
2015-05-05 06:49:05
- part of checkin
[9b639cf2d6]
on branch trunk
- Working version for update to 2.067.
/***********************************************************************\
* winioctl.d *
* *
* Windows API header module *
* *
* Translated from MinGW Windows headers *
* by Stewart Gordon *
* *
* Placed into public domain *
\***********************************************************************/
module win32.winioctl;
// FIXME: check types of some constants
private import win32.basetyps, win32.windef;
const size_t
HIST_NO_OF_BUCKETS = 24,
HISTOGRAM_BUCKET_SIZE = HISTOGRAM_BUCKET.sizeof,
DISK_HISTOGRAM_SIZE = DISK_HISTOGRAM.sizeof;
alias DWORD DEVICE_TYPE;
enum : DEVICE_TYPE {
FILE_DEVICE_BEEP = 1,
FILE_DEVICE_CD_ROM,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
FILE_DEVICE_CONTROLLER,
FILE_DEVICE_DATALINK,
FILE_DEVICE_DFS,
FILE_DEVICE_DISK,
FILE_DEVICE_DISK_FILE_SYSTEM,
FILE_DEVICE_FILE_SYSTEM,
FILE_DEVICE_INPORT_PORT,
FILE_DEVICE_KEYBOARD,
FILE_DEVICE_MAILSLOT,
FILE_DEVICE_MIDI_IN,
FILE_DEVICE_MIDI_OUT,
FILE_DEVICE_MOUSE,
FILE_DEVICE_MULTI_UNC_PROVIDER,
FILE_DEVICE_NAMED_PIPE,
FILE_DEVICE_NETWORK,
FILE_DEVICE_NETWORK_BROWSER,
FILE_DEVICE_NETWORK_FILE_SYSTEM,
FILE_DEVICE_NULL,
FILE_DEVICE_PARALLEL_PORT,
FILE_DEVICE_PHYSICAL_NETCARD,
FILE_DEVICE_PRINTER,
FILE_DEVICE_SCANNER,
FILE_DEVICE_SERIAL_MOUSE_PORT,
FILE_DEVICE_SERIAL_PORT,
FILE_DEVICE_SCREEN,
FILE_DEVICE_SOUND,
FILE_DEVICE_STREAMS,
FILE_DEVICE_TAPE,
FILE_DEVICE_TAPE_FILE_SYSTEM,
FILE_DEVICE_TRANSPORT,
FILE_DEVICE_UNKNOWN,
FILE_DEVICE_VIDEO,
FILE_DEVICE_VIRTUAL_DISK,
FILE_DEVICE_WAVE_IN,
FILE_DEVICE_WAVE_OUT,
FILE_DEVICE_8042_PORT,
FILE_DEVICE_NETWORK_REDIRECTOR,
FILE_DEVICE_BATTERY,
FILE_DEVICE_BUS_EXTENDER,
FILE_DEVICE_MODEM,
FILE_DEVICE_VDM,
FILE_DEVICE_MASS_STORAGE,
FILE_DEVICE_SMB,
FILE_DEVICE_KS,
FILE_DEVICE_CHANGER,
FILE_DEVICE_SMARTCARD,
FILE_DEVICE_ACPI,
FILE_DEVICE_DVD,
FILE_DEVICE_FULLSCREEN_VIDEO,
FILE_DEVICE_DFS_FILE_SYSTEM,
FILE_DEVICE_DFS_VOLUME,
FILE_DEVICE_SERENUM,
FILE_DEVICE_TERMSRV,
FILE_DEVICE_KSEC // = 57
}
enum {
METHOD_BUFFERED,
METHOD_IN_DIRECT,
METHOD_OUT_DIRECT,
METHOD_NEITHER
}
enum {
FILE_ANY_ACCESS,
FILE_SPECIAL_ACCESS = 0,
FILE_READ_ACCESS,
FILE_WRITE_ACCESS
}
/* Bit pattern:
* tttttttt tttttttt aaffffff ffffffmm
*/
/+
#define CTL_CODE(t, f, m, a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
+/
template CTL_CODE_T(DEVICE_TYPE t, uint f, uint m, uint a) {
const DWORD CTL_CODE_T = (t << 16) | (a << 14) | (f << 2) | m;
}
DEVICE_TYPE DEVICE_TYPE_FROM_CTL_CODE(DWORD c) {
return (c & 0xFFFF0000) >> 16;
}
const DEVICE_TYPE
IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE,
IOCTL_DISK_BASE = FILE_DEVICE_DISK,
IOCTL_VOLUME_BASE = 'V';
enum : DWORD {
IOCTL_STORAGE_CHECK_VERIFY = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_CHECK_VERIFY2 = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_MEDIA_REMOVAL = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_EJECT_MEDIA = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_LOAD_MEDIA = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_LOAD_MEDIA2 = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_RESERVE = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_RELEASE = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_FIND_NEW_DEVICES = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_EJECTION_CONTROL = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0250, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_MCN_CONTROL = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0251, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_GET_MEDIA_TYPES = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_GET_MEDIA_TYPES_EX = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0301, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_RESET_BUS = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_RESET_DEVICE = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_STORAGE_GET_DEVICE_NUMBER = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0420, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_STORAGE_PREDICT_FAILURE = CTL_CODE_T!(IOCTL_STORAGE_BASE, 0x0440, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_GET_DRIVE_GEOMETRY = CTL_CODE_T!(IOCTL_DISK_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_GET_PARTITION_INFO = CTL_CODE_T!(IOCTL_DISK_BASE, 1, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_SET_PARTITION_INFO = CTL_CODE_T!(IOCTL_DISK_BASE, 2, METHOD_BUFFERED, FILE_READ_ACCESS|FILE_WRITE_ACCESS),
IOCTL_DISK_GET_DRIVE_LAYOUT = CTL_CODE_T!(IOCTL_DISK_BASE, 3, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_SET_DRIVE_LAYOUT = CTL_CODE_T!(IOCTL_DISK_BASE, 4, METHOD_BUFFERED, FILE_READ_ACCESS|FILE_WRITE_ACCESS),
IOCTL_DISK_VERIFY = CTL_CODE_T!(IOCTL_DISK_BASE, 5, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_FORMAT_TRACKS = CTL_CODE_T!(IOCTL_DISK_BASE, 6, METHOD_BUFFERED, FILE_READ_ACCESS|FILE_WRITE_ACCESS),
IOCTL_DISK_REASSIGN_BLOCKS = CTL_CODE_T!(IOCTL_DISK_BASE, 7, METHOD_BUFFERED, FILE_READ_ACCESS|FILE_WRITE_ACCESS),
IOCTL_DISK_PERFORMANCE = CTL_CODE_T!(IOCTL_DISK_BASE, 8, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_IS_WRITABLE = CTL_CODE_T!(IOCTL_DISK_BASE, 9, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_LOGGING = CTL_CODE_T!(IOCTL_DISK_BASE, 10, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_FORMAT_TRACKS_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 11, METHOD_BUFFERED, FILE_READ_ACCESS|FILE_WRITE_ACCESS),
IOCTL_DISK_HISTOGRAM_STRUCTURE = CTL_CODE_T!(IOCTL_DISK_BASE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_HISTOGRAM_DATA = CTL_CODE_T!(IOCTL_DISK_BASE, 13, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_HISTOGRAM_RESET = CTL_CODE_T!(IOCTL_DISK_BASE, 14, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_REQUEST_STRUCTURE = CTL_CODE_T!(IOCTL_DISK_BASE, 15, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_REQUEST_DATA = CTL_CODE_T!(IOCTL_DISK_BASE, 16, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_GET_PARTITION_INFO_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 0x12, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_SET_PARTITION_INFO_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 0x13, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_GET_DRIVE_LAYOUT_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 0x14, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_SET_DRIVE_LAYOUT_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 0x15, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_CREATE_DISK = CTL_CODE_T!(IOCTL_DISK_BASE, 0x16, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_GET_LENGTH_INFO = CTL_CODE_T!(IOCTL_DISK_BASE, 0x17, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_PERFORMANCE_OFF = CTL_CODE_T!(IOCTL_DISK_BASE, 0x18, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_GET_DRIVE_GEOMETRY_EX = CTL_CODE_T!(IOCTL_DISK_BASE, 0x28, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_GROW_PARTITION = CTL_CODE_T!(IOCTL_DISK_BASE, 0x34, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_GET_CACHE_INFORMATION = CTL_CODE_T!(IOCTL_DISK_BASE, 0x35, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_SET_CACHE_INFORMATION = CTL_CODE_T!(IOCTL_DISK_BASE, 0x36, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_DELETE_DRIVE_LAYOUT = CTL_CODE_T!(IOCTL_DISK_BASE, 0x40, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_DISK_UPDATE_PROPERTIES = CTL_CODE_T!(IOCTL_DISK_BASE, 0x50, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_CHECK_VERIFY = CTL_CODE_T!(IOCTL_DISK_BASE, 0x200, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_MEDIA_REMOVAL = CTL_CODE_T!(IOCTL_DISK_BASE, 0x201, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_EJECT_MEDIA = CTL_CODE_T!(IOCTL_DISK_BASE, 0x202, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_LOAD_MEDIA = CTL_CODE_T!(IOCTL_DISK_BASE, 0x203, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_RESERVE = CTL_CODE_T!(IOCTL_DISK_BASE, 0x204, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_RELEASE = CTL_CODE_T!(IOCTL_DISK_BASE, 0x205, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_FIND_NEW_DEVICES = CTL_CODE_T!(IOCTL_DISK_BASE, 0x206, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_REMOVE_DEVICE = CTL_CODE_T!(IOCTL_DISK_BASE, 0x207, METHOD_BUFFERED, FILE_READ_ACCESS),
IOCTL_DISK_GET_MEDIA_TYPES = CTL_CODE_T!(IOCTL_DISK_BASE, 0x300, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_DISK_UPDATE_DRIVE_SIZE = CTL_CODE_T!(IOCTL_DISK_BASE, 0x0032, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
IOCTL_SERIAL_LSRMST_INSERT = CTL_CODE_T!(FILE_DEVICE_SERIAL_PORT, 31, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS = CTL_CODE_T!(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS),
IOCTL_VOLUME_IS_CLUSTERED = CTL_CODE_T!(IOCTL_VOLUME_BASE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_LOCK_VOLUME = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_UNLOCK_VOLUME = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_DISMOUNT_VOLUME = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_MOUNT_DBLS_VOLUME = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 13, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_GET_COMPRESSION = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 15, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_SET_COMPRESSION = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 16, METHOD_BUFFERED, FILE_READ_DATA|FILE_WRITE_DATA),
FSCTL_READ_COMPRESSION = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 17, METHOD_NEITHER, FILE_READ_DATA),
FSCTL_WRITE_COMPRESSION = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 18, METHOD_NEITHER, FILE_WRITE_DATA),
FSCTL_GET_NTFS_VOLUME_DATA = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 25, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_GET_VOLUME_BITMAP = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 27, METHOD_NEITHER, FILE_ANY_ACCESS),
FSCTL_GET_RETRIEVAL_POINTERS = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 28, METHOD_NEITHER, FILE_ANY_ACCESS),
FSCTL_MOVE_FILE = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 29, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_GET_REPARSE_POINT = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_SET_REPARSE_POINT = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_DELETE_REPARSE_POINT = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_ANY_ACCESS),
FSCTL_SET_SPARSE = CTL_CODE_T!(FILE_DEVICE_FILE_SYSTEM, 49, METHOD_BUFFERED, FILE_SPECIAL_ACCESS),
}
enum : BYTE {
PARTITION_ENTRY_UNUSED,
PARTITION_FAT_12,
PARTITION_XENIX_1,
PARTITION_XENIX_2,
PARTITION_FAT_16,
PARTITION_EXTENDED,
PARTITION_HUGE,
PARTITION_IFS, // = 0x07
PARTITION_FAT32 = 0x0B,
PARTITION_FAT32_XINT13 = 0x0C,
PARTITION_XINT13 = 0x0E,
PARTITION_XINT13_EXTENDED = 0x0F,
PARTITION_PREP = 0x41,
PARTITION_LDM = 0x42,
PARTITION_UNIX = 0x63
}
const BYTE
PARTITION_NTFT = 0x80,
VALID_NTFT = 0xC0;
enum {
SERIAL_LSRMST_ESCAPE,
SERIAL_LSRMST_LSR_DATA,
SERIAL_LSRMST_LSR_NODATA,
SERIAL_LSRMST_MST
}
enum {
DISK_LOGGING_START,
DISK_LOGGING_STOP,
DISK_LOGGING_DUMP,
DISK_BINNING
}
alias WORD BAD_TRACK_NUMBER;
alias WORD* PBAD_TRACK_NUMBER;
enum BIN_TYPES {
RequestSize, RequestLocation
}
struct BIN_RANGE {
LARGE_INTEGER StartValue;
LARGE_INTEGER Length;
}
alias BIN_RANGE* PBIN_RANGE;
struct BIN_COUNT {
BIN_RANGE BinRange;
DWORD BinCount;
}
alias BIN_COUNT* PBIN_COUNT;
struct BIN_RESULTS {
DWORD NumberOfBins;
BIN_COUNT _BinCounts;
BIN_COUNT* BinCounts() { return &_BinCounts; }
}
alias BIN_RESULTS* PBIN_RESULTS;
enum PARTITION_STYLE {
PARTITION_STYLE_MBR,
PARTITION_STYLE_GPT,
PARTITION_STYLE_RAW
}
struct CREATE_DISK_GPT {
GUID DiskId;
DWORD MaxPartitionCount;
}
alias CREATE_DISK_GPT* PCREATE_DISK_GPT;
struct CREATE_DISK_MBR {
DWORD Signature;
}
alias CREATE_DISK_MBR* PCREATE_DISK_MBR;
struct CREATE_DISK {
PARTITION_STYLE PartitionStyle;
union {
CREATE_DISK_MBR Mbr;
CREATE_DISK_GPT Gpt;
}
}
alias CREATE_DISK* PCREATE_DISK;
enum DISK_CACHE_RETENTION_PRIORITY {
EqualPriority,
KeepPrefetchedData,
KeepReadData
}
struct DISK_CACHE_INFORMATION {
BOOLEAN ParametersSavable;
BOOLEAN ReadCacheEnabled;
BOOLEAN WriteCacheEnabled;
DISK_CACHE_RETENTION_PRIORITY ReadRetentionPriority;
DISK_CACHE_RETENTION_PRIORITY WriteRetentionPriority;
WORD DisablePrefetchTransferLength;
BOOLEAN PrefetchScalar;
union {
struct _ScalarPrefetch {
WORD Minimum;
WORD Maximum;
WORD MaximumBlocks;
}
_ScalarPrefetch ScalarPrefetch;
struct _BlockPrefetch {
WORD Minimum;
WORD Maximum;
}
_BlockPrefetch BlockPrefetch;
}
}
alias DISK_CACHE_INFORMATION* PDISK_CACHE_INFORMATION;
enum DETECTION_TYPE {
DetectNone,
DetectInt13,
DetectExInt13
}
struct DISK_INT13_INFO {
WORD DriveSelect;
DWORD MaxCylinders;
WORD SectorsPerTrack;
WORD MaxHeads;
WORD NumberDrives;
}
alias DISK_INT13_INFO* PDISK_INT13_INFO;
struct DISK_EX_INT13_INFO {
WORD ExBufferSize;
WORD ExFlags;
DWORD ExCylinders;
DWORD ExHeads;
DWORD ExSectorsPerTrack;
DWORD64 ExSectorsPerDrive;
WORD ExSectorSize;
WORD ExReserved;
}
alias DISK_EX_INT13_INFO* PDISK_EX_INT13_INFO;
struct DISK_DETECTION_INFO {
DWORD SizeOfDetectInfo;
DETECTION_TYPE DetectionType;
DISK_INT13_INFO Int13;
DISK_EX_INT13_INFO ExInt13;
}
alias DISK_DETECTION_INFO* PDISK_DETECTION_INFO;
enum MEDIA_TYPE {
Unknown,
F5_1Pt2_512,
F3_1Pt44_512,
F3_2Pt88_512,
F3_20Pt8_512,
F3_720_512,
F5_360_512,
F5_320_512,
F5_320_1024,
F5_180_512,
F5_160_512,
RemovableMedia,
FixedMedia,
F3_120M_512,
F3_640_512,
F5_640_512,
F5_720_512,
F3_1Pt2_512,
F3_1Pt23_1024,
F5_1Pt23_1024,
F3_128Mb_512,
F3_230Mb_512,
F8_256_128,
F3_200Mb_512,
F3_240M_512,
F3_32M_512
}
alias MEDIA_TYPE* PMEDIA_TYPE;
struct DISK_GEOMETRY {
LARGE_INTEGER Cylinders;
MEDIA_TYPE MediaType;
DWORD TracksPerCylinder;
DWORD SectorsPerTrack;
DWORD BytesPerSector;
}
alias DISK_GEOMETRY* PDISK_GEOMETRY;
struct DISK_GEOMETRY_EX {
DISK_GEOMETRY Geometry;
LARGE_INTEGER DiskSize;
BYTE _Data;
BYTE* Data() { return &_Data; }
}
alias DISK_GEOMETRY_EX* PDISK_GEOMETRY_EX;
struct DISK_GROW_PARTITION {
DWORD PartitionNumber;
LARGE_INTEGER BytesToGrow;
}
alias DISK_GROW_PARTITION* PDISK_GROW_PARTITION;
struct DISK_PARTITION_INFO {
DWORD SizeOfPartitionInfo;
PARTITION_STYLE PartitionStyle;
union {
//struct {
DWORD Signature;
//} Mbr;
//struct {
GUID DiskId;
//} Gpt;
}
}
alias DISK_PARTITION_INFO* PDISK_PARTITION_INFO;
struct DISK_PERFORMANCE {
LARGE_INTEGER BytesRead;
LARGE_INTEGER BytesWritten;
LARGE_INTEGER ReadTime;
LARGE_INTEGER WriteTime;
DWORD ReadCount;
DWORD WriteCount;
DWORD QueueDepth;
}
alias DISK_PERFORMANCE* PDISK_PERFORMANCE;
struct DISK_RECORD {
LARGE_INTEGER ByteOffset;
LARGE_INTEGER StartTime;
LARGE_INTEGER EndTime;
PVOID VirtualAddress;
DWORD NumberOfBytes;
BYTE DeviceNumber;
BOOLEAN ReadRequest;
}
alias DISK_RECORD* PDISK_RECORD;
struct DISK_LOGGING {
BYTE Function;
PVOID BufferAddress;
DWORD BufferSize;
}
alias DISK_LOGGING* PDISK_LOGGING;
struct DISKQUOTA_USER_INFORMATION {
LONGLONG QuotaUsed;
LONGLONG QuotaThreshold;
LONGLONG QuotaLimit;
}
alias DISKQUOTA_USER_INFORMATION* PDISKQUOTA_USER_INFORMATION;
struct FORMAT_PARAMETERS {
MEDIA_TYPE MediaType;
DWORD StartCylinderNumber;
DWORD EndCylinderNumber;
DWORD StartHeadNumber;
DWORD EndHeadNumber;
}
alias FORMAT_PARAMETERS* PFORMAT_PARAMETERS;
struct FORMAT_EX_PARAMETERS {
MEDIA_TYPE MediaType;
DWORD StartCylinderNumber;
DWORD EndCylinderNumber;
DWORD StartHeadNumber;
DWORD EndHeadNumber;
WORD FormatGapLength;
WORD SectorsPerTrack;
WORD _SectorNumber;
WORD* SectorNumber() { return &_SectorNumber; }
}
alias FORMAT_EX_PARAMETERS* PFORMAT_EX_PARAMETERS;
struct GET_LENGTH_INFORMATION {
LARGE_INTEGER Length;
}
struct HISTOGRAM_BUCKET {
DWORD Reads;
DWORD Writes;
}
alias HISTOGRAM_BUCKET* PHISTOGRAM_BUCKET;
struct DISK_HISTOGRAM {
LARGE_INTEGER DiskSize;
LARGE_INTEGER Start;
LARGE_INTEGER End;
LARGE_INTEGER Average;
LARGE_INTEGER AverageRead;
LARGE_INTEGER AverageWrite;
DWORD Granularity;
DWORD Size;
DWORD ReadCount;
DWORD WriteCount;
PHISTOGRAM_BUCKET Histogram;
}
alias DISK_HISTOGRAM* PDISK_HISTOGRAM;
struct DISK_EXTENT {
DWORD DiskNumber;
LARGE_INTEGER StartingOffset;
LARGE_INTEGER ExtentLength;
}
alias DISK_EXTENT* PDISK_EXTENT;
struct VOLUME_DISK_EXTENTS {
DWORD NumberOfDiskExtents;
DISK_EXTENT _Extents;
DISK_EXTENT* Extents() { return &_Extents; }
}
alias VOLUME_DISK_EXTENTS* PVOLUME_DISK_EXTENTS;
struct PARTITION_INFORMATION {
LARGE_INTEGER StartingOffset;
LARGE_INTEGER PartitionLength;
DWORD HiddenSectors;
DWORD PartitionNumber;
BYTE PartitionType;
BOOLEAN BootIndicator;
BOOLEAN RecognizedPartition;
BOOLEAN RewritePartition;
}
alias PARTITION_INFORMATION* PPARTITION_INFORMATION;
struct DRIVE_LAYOUT_INFORMATION {
DWORD PartitionCount;
DWORD Signature;
PARTITION_INFORMATION _PartitionEntry;
PARTITION_INFORMATION* PartitionEntry() { return &_PartitionEntry; }
}
alias DRIVE_LAYOUT_INFORMATION* PDRIVE_LAYOUT_INFORMATION;
struct DRIVE_LAYOUT_INFORMATION_GPT {
GUID DiskId;
LARGE_INTEGER StartingUsableOffset;
LARGE_INTEGER UsableLength;
ULONG MaxPartitionCount;
}
alias DRIVE_LAYOUT_INFORMATION_GPT* PDRIVE_LAYOUT_INFORMATION_GPT;
struct DRIVE_LAYOUT_INFORMATION_MBR {
ULONG Signature;
}
alias DRIVE_LAYOUT_INFORMATION_MBR* PDRIVE_LAYOUT_INFORMATION_MBR;
struct PARTITION_INFORMATION_MBR {
BYTE PartitionType;
BOOLEAN BootIndicator;
BOOLEAN RecognizedPartition;
DWORD HiddenSectors;
}
struct PARTITION_INFORMATION_GPT {
GUID PartitionType;
GUID PartitionId;
DWORD64 Attributes;
WCHAR[36] Name;
}
struct PARTITION_INFORMATION_EX {
PARTITION_STYLE PartitionStyle;
LARGE_INTEGER StartingOffset;
LARGE_INTEGER PartitionLength;
DWORD PartitionNumber;
BOOLEAN RewritePartition;
union {
PARTITION_INFORMATION_MBR Mbr;
PARTITION_INFORMATION_GPT Gpt;
}
}
struct DRIVE_LAYOUT_INFORMATION_EX {
DWORD PartitionStyle;
DWORD PartitionCount;
union {
DRIVE_LAYOUT_INFORMATION_MBR Mbr;
DRIVE_LAYOUT_INFORMATION_GPT Gpt;
}
PARTITION_INFORMATION_EX _PartitionEntry;
PARTITION_INFORMATION_EX* PartitionEntry() { return &_PartitionEntry; }
}
alias DRIVE_LAYOUT_INFORMATION_EX* PDRIVE_LAYOUT_INFORMATION_EX;
struct MOVE_FILE_DATA {
HANDLE FileHandle;
LARGE_INTEGER StartingVcn;
LARGE_INTEGER StartingLcn;
DWORD ClusterCount;
}
alias MOVE_FILE_DATA* PMOVE_FILE_DATA;
struct PERF_BIN {
DWORD NumberOfBins;
DWORD TypeOfBin;
BIN_RANGE _BinsRanges;
BIN_RANGE* BinsRanges() { return &_BinsRanges; }
}
alias PERF_BIN* PPERF_BIN;
struct PREVENT_MEDIA_REMOVAL {
BOOLEAN PreventMediaRemoval;
}
alias PREVENT_MEDIA_REMOVAL* PPREVENT_MEDIA_REMOVAL;
struct RETRIEVAL_POINTERS_BUFFER {
DWORD ExtentCount;
LARGE_INTEGER StartingVcn;
// In MinGW, this is declared as struct { ... } Extents[1];
struct Extent {
LARGE_INTEGER NextVcn;
LARGE_INTEGER Lcn;
}
Extent _Extents;
Extent* Extents() { return &_Extents; }
}
alias RETRIEVAL_POINTERS_BUFFER* PRETRIEVAL_POINTERS_BUFFER;
struct REASSIGN_BLOCKS {
WORD Reserved;
WORD Count;
DWORD _BlockNumber;
DWORD* BlockNumber() { return &_BlockNumber; }
}
alias REASSIGN_BLOCKS* PREASSIGN_BLOCKS;
struct SET_PARTITION_INFORMATION {
BYTE PartitionType;
}
alias SET_PARTITION_INFORMATION* PSET_PARTITION_INFORMATION;
struct STARTING_LCN_INPUT_BUFFER {
LARGE_INTEGER StartingLcn;
}
alias STARTING_LCN_INPUT_BUFFER* PSTARTING_LCN_INPUT_BUFFER;
struct STARTING_VCN_INPUT_BUFFER {
LARGE_INTEGER StartingVcn;
}
alias STARTING_VCN_INPUT_BUFFER* PSTARTING_VCN_INPUT_BUFFER;
struct VERIFY_INFORMATION {
LARGE_INTEGER StartingOffset;
DWORD Length;
}
alias VERIFY_INFORMATION* PVERIFY_INFORMATION;
struct VOLUME_BITMAP_BUFFER {
LARGE_INTEGER StartingLcn;
LARGE_INTEGER BitmapSize;
BYTE _Buffer;
BYTE* Buffer() { return &_Buffer; }
}
alias VOLUME_BITMAP_BUFFER* PVOLUME_BITMAP_BUFFER;
struct NTFS_VOLUME_DATA_BUFFER {
LARGE_INTEGER VolumeSerialNumber;
LARGE_INTEGER NumberSectors;
LARGE_INTEGER TotalClusters;
LARGE_INTEGER FreeClusters;
LARGE_INTEGER TotalReserved;
DWORD BytesPerSector;
DWORD BytesPerCluster;
DWORD BytesPerFileRecordSegment;
DWORD ClustersPerFileRecordSegment;
LARGE_INTEGER MftValidDataLength;
LARGE_INTEGER MftStartLcn;
LARGE_INTEGER Mft2StartLcn;
LARGE_INTEGER MftZoneStart;
LARGE_INTEGER MftZoneEnd;
}
alias NTFS_VOLUME_DATA_BUFFER* PNTFS_VOLUME_DATA_BUFFER;
bool IsRecognizedPartition(BYTE t) {
return ((t & PARTITION_NTFT)
&& ((t & ~VALID_NTFT) == PARTITION_FAT_12
|| (t & ~VALID_NTFT) == PARTITION_FAT_16
|| (t & ~VALID_NTFT) == PARTITION_IFS
|| (t & ~VALID_NTFT) == PARTITION_HUGE
|| (t & ~VALID_NTFT) == PARTITION_FAT32
|| (t & ~VALID_NTFT) == PARTITION_FAT32_XINT13
|| (t & ~VALID_NTFT) == PARTITION_XINT13))
|| (t & ~PARTITION_NTFT) == PARTITION_FAT_12
|| (t & ~PARTITION_NTFT) == PARTITION_FAT_16
|| (t & ~PARTITION_NTFT) == PARTITION_IFS
|| (t & ~PARTITION_NTFT) == PARTITION_HUGE
|| (t & ~PARTITION_NTFT) == PARTITION_FAT32
|| (t & ~PARTITION_NTFT) == PARTITION_FAT32_XINT13
|| (t & ~PARTITION_NTFT) == PARTITION_XINT13;
}
bool IsContainerPartition(BYTE t) {
return ((t & PARTITION_NTFT)
&& ((t & ~VALID_NTFT) == PARTITION_EXTENDED
|| (t & ~VALID_NTFT) == PARTITION_XINT13_EXTENDED))
|| (t & ~PARTITION_NTFT) == PARTITION_EXTENDED
|| (t & ~PARTITION_NTFT) == PARTITION_XINT13_EXTENDED;
}