|
|
/*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
ntdddisk.h
Abstract:
This is the include file that defines all constants and types for accessing the Disk device.
Revision History:
--*/
#ifndef _NTDDDISK_H_#define _NTDDDISK_H_
#if _MSC_VER > 1000#pragma once#endif
#include <diskguid.h>
#ifdef __cplusplusextern "C" {#endif
//// Device Name - this string is the name of the device. It is the name// that should be passed to NtOpenFile when accessing the device.//// Note: For devices that support multiple units, it should be suffixed// with the Ascii representation of the unit number.//
#define DD_DISK_DEVICE_NAME "\\Device\\UNKNOWN"
//// NtDeviceIoControlFile
// begin_winioctl
//// IoControlCode values for disk devices.//
#define IOCTL_DISK_BASE FILE_DEVICE_DISK#define IOCTL_DISK_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_DISK_BASE, 0x0000, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_GET_PARTITION_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_SET_PARTITION_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_GET_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_SET_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_FORMAT_TRACKS CTL_CODE(IOCTL_DISK_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_REASSIGN_BLOCKS CTL_CODE(IOCTL_DISK_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_PERFORMANCE CTL_CODE(IOCTL_DISK_BASE, 0x0008, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_IS_WRITABLE CTL_CODE(IOCTL_DISK_BASE, 0x0009, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_LOGGING CTL_CODE(IOCTL_DISK_BASE, 0x000a, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_FORMAT_TRACKS_EX CTL_CODE(IOCTL_DISK_BASE, 0x000b, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_HISTOGRAM_STRUCTURE CTL_CODE(IOCTL_DISK_BASE, 0x000c, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_HISTOGRAM_DATA CTL_CODE(IOCTL_DISK_BASE, 0x000d, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_HISTOGRAM_RESET CTL_CODE(IOCTL_DISK_BASE, 0x000e, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_REQUEST_STRUCTURE CTL_CODE(IOCTL_DISK_BASE, 0x000f, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_REQUEST_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0010, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_PERFORMANCE_OFF CTL_CODE(IOCTL_DISK_BASE, 0x0018, METHOD_BUFFERED, FILE_ANY_ACCESS)
#if(_WIN32_WINNT >= 0x0400)#define IOCTL_DISK_CONTROLLER_NUMBER CTL_CODE(IOCTL_DISK_BASE, 0x0011, METHOD_BUFFERED, FILE_ANY_ACCESS)
//// IOCTL support for SMART drive fault prediction.//
#define SMART_GET_VERSION CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)#define SMART_SEND_DRIVE_COMMAND CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define SMART_RCV_DRIVE_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#endif /* _WIN32_WINNT >= 0x0400 */
#if (_WIN32_WINNT >= 0x500)
//// New IOCTLs for GUID Partition tabled disks.//
#define IOCTL_DISK_GET_PARTITION_INFO_EX CTL_CODE(IOCTL_DISK_BASE, 0x0012, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_SET_PARTITION_INFO_EX CTL_CODE(IOCTL_DISK_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_GET_DRIVE_LAYOUT_EX CTL_CODE(IOCTL_DISK_BASE, 0x0014, METHOD_BUFFERED, FILE_ANY_ACCESS)#define IOCTL_DISK_SET_DRIVE_LAYOUT_EX CTL_CODE(IOCTL_DISK_BASE, 0x0015, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_CREATE_DISK CTL_CODE(IOCTL_DISK_BASE, 0x0016, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_GET_LENGTH_INFO CTL_CODE(IOCTL_DISK_BASE, 0x0017, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
#endif /* _WIN32_WINNT >= 0x0500 */
#if(_WIN32_WINNT >= 0x0500)#define IOCTL_DISK_UPDATE_DRIVE_SIZE CTL_CODE(IOCTL_DISK_BASE, 0x0032, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_GROW_PARTITION CTL_CODE(IOCTL_DISK_BASE, 0x0034, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_DISK_GET_CACHE_INFORMATION CTL_CODE(IOCTL_DISK_BASE, 0x0035, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_SET_CACHE_INFORMATION CTL_CODE(IOCTL_DISK_BASE, 0x0036, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define OBSOLETE_DISK_GET_WRITE_CACHE_STATE CTL_CODE(IOCTL_DISK_BASE, 0x0037, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_DELETE_DRIVE_LAYOUT CTL_CODE(IOCTL_DISK_BASE, 0x0040, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
//// 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...)//
#define IOCTL_DISK_UPDATE_PROPERTIES CTL_CODE(IOCTL_DISK_BASE, 0x0050, METHOD_BUFFERED, FILE_ANY_ACCESS)
//// Special IOCTLs needed to support PC-98 machines in Japan//
#define IOCTL_DISK_FORMAT_DRIVE CTL_CODE(IOCTL_DISK_BASE, 0x00f3, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)#define IOCTL_DISK_SENSE_DEVICE CTL_CODE(IOCTL_DISK_BASE, 0x00f8, METHOD_BUFFERED, FILE_ANY_ACCESS)
#endif /* _WIN32_WINNT >= 0x0500 */
// end_winioctl
//// IOCTLs to report and modify our caching behavior//
#define IOCTL_DISK_GET_CACHE_SETTING CTL_CODE(IOCTL_DISK_BASE, 0x0038, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_SET_CACHE_SETTING CTL_CODE(IOCTL_DISK_BASE, 0x0039, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
typedef enum _DISK_CACHE_STATE{ DiskCacheNormal, DiskCacheWriteThroughNotSupported, DiskCacheModifyUnsuccessful
} DISK_CACHE_STATE, *PDISK_CACHE_STATE;
typedef struct _DISK_CACHE_SETTING{ // // The size of this structure is used for versioning // ULONG Version;
// // Indicates whether there are any issues with the disk cache // DISK_CACHE_STATE State;
// // Indicates whether the disk cache is power protected or not // BOOLEAN IsPowerProtected;
} DISK_CACHE_SETTING, *PDISK_CACHE_SETTING;
//// IOCTL for moving copying a run of sectors from one location of the disk// to another. The caller of this IOCTL needs to be prepared for the call to// fail and do the copy manually since this IOCTL will only rarely be// implemented.//
#define IOCTL_DISK_COPY_DATA CTL_CODE(IOCTL_DISK_BASE, 0x0019, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
//// This structure is passed in for a IOCTL_DISK_COPY_DATA call.//
typedef struct _DISK_COPY_DATA_PARAMETERS { LARGE_INTEGER SourceOffset; LARGE_INTEGER DestinationOffset; LARGE_INTEGER CopyLength; ULONGLONG Reserved; // Must be 0.} DISK_COPY_DATA_PARAMETERS, *PDISK_COPY_DATA_PARAMETERS;
//// Internal disk driver device controls to maintain the verify status bit// for the device object.//
#define IOCTL_DISK_INTERNAL_SET_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0100, METHOD_NEITHER, FILE_ANY_ACCESS)#define IOCTL_DISK_INTERNAL_CLEAR_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0101, METHOD_NEITHER, FILE_ANY_ACCESS)
//// Internal disk driver device control to set notification routine for// the device object. Used in DiskPerf.//
#define IOCTL_DISK_INTERNAL_SET_NOTIFY CTL_CODE(IOCTL_DISK_BASE, 0x0102, METHOD_BUFFERED, FILE_ANY_ACCESS)
// begin_winioctl//// 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//
#define IOCTL_DISK_CHECK_VERIFY CTL_CODE(IOCTL_DISK_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_MEDIA_REMOVAL CTL_CODE(IOCTL_DISK_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_EJECT_MEDIA CTL_CODE(IOCTL_DISK_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_LOAD_MEDIA CTL_CODE(IOCTL_DISK_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_RESERVE CTL_CODE(IOCTL_DISK_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_RELEASE CTL_CODE(IOCTL_DISK_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_FIND_NEW_DEVICES CTL_CODE(IOCTL_DISK_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)#define IOCTL_DISK_GET_MEDIA_TYPES CTL_CODE(IOCTL_DISK_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
// end_winioctl
//// The following file contains the IOCTL_STORAGE class ioctls//
#include <ntddstor.h>
// begin_winioctl//// Define the partition types returnable by known disk drivers.//
#define PARTITION_ENTRY_UNUSED 0x00 // Entry unused#define PARTITION_FAT_12 0x01 // 12-bit FAT entries#define PARTITION_XENIX_1 0x02 // Xenix#define PARTITION_XENIX_2 0x03 // Xenix#define PARTITION_FAT_16 0x04 // 16-bit FAT entries#define PARTITION_EXTENDED 0x05 // Extended partition entry#define PARTITION_HUGE 0x06 // Huge partition MS-DOS V4#define PARTITION_IFS 0x07 // IFS Partition#define PARTITION_OS2BOOTMGR 0x0A // OS/2 Boot Manager/OPUS/Coherent swap#define PARTITION_FAT32 0x0B // FAT32#define PARTITION_FAT32_XINT13 0x0C // FAT32 using extended int13 services#define PARTITION_XINT13 0x0E // Win95 partition using extended int13 services#define PARTITION_XINT13_EXTENDED 0x0F // Same as type 5 but uses extended int13 services#define PARTITION_PREP 0x41 // PowerPC Reference Platform (PReP) Boot Partition#define PARTITION_LDM 0x42 // Logical Disk Manager partition#define PARTITION_UNIX 0x63 // Unix
#define VALID_NTFT 0xC0 // NTFT uses high order bits
//// The high bit of the partition type code indicates that a partition// is part of an NTFT mirror or striped array.//
#define PARTITION_NTFT 0x80 // NTFT partition
//// The following macro is used to determine which partitions should be// assigned drive letters.//
//++//// BOOLEAN// IsRecognizedPartition(// IN ULONG 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 & 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) )
//++//// BOOLEAN// IsContainerPartition(// IN ULONG 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.////--
#define IsContainerPartition( PartitionType ) \ ((PartitionType == PARTITION_EXTENDED) || (PartitionType == PARTITION_XINT13_EXTENDED))
//++//// BOOLEAN// IsFTPartition(// IN ULONG 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.////--
#define IsFTPartition( PartitionType ) \ (((PartitionType)&PARTITION_NTFT) && IsRecognizedPartition(PartitionType))
//// 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 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} MEDIA_TYPE, *PMEDIA_TYPE;
//// Define the input buffer structure for the driver, when// it is called with IOCTL_DISK_FORMAT_TRACKS.//
typedef struct _FORMAT_PARAMETERS { MEDIA_TYPE MediaType; ULONG StartCylinderNumber; ULONG EndCylinderNumber; ULONG StartHeadNumber; ULONG EndHeadNumber;} FORMAT_PARAMETERS, *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.//
typedef USHORT BAD_TRACK_NUMBER;typedef USHORT *PBAD_TRACK_NUMBER;
//// Define the input buffer structure for the driver, when// it is called with IOCTL_DISK_FORMAT_TRACKS_EX.//
typedef struct _FORMAT_EX_PARAMETERS { MEDIA_TYPE MediaType; ULONG StartCylinderNumber; ULONG EndCylinderNumber; ULONG StartHeadNumber; ULONG EndHeadNumber; USHORT FormatGapLength; USHORT SectorsPerTrack; USHORT SectorNumber[1];} FORMAT_EX_PARAMETERS, *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.//
typedef struct _DISK_GEOMETRY { LARGE_INTEGER Cylinders; MEDIA_TYPE MediaType; ULONG TracksPerCylinder; ULONG SectorsPerTrack; ULONG BytesPerSector;} DISK_GEOMETRY, *PDISK_GEOMETRY;
//// This wmi guid returns a DISK_GEOMETRY structure//#define WMI_DISK_GEOMETRY_GUID { 0x25007f51, 0x57c2, 0x11d1, { 0xa5, 0x28, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0x10 } }
//// 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.//
typedef struct _PARTITION_INFORMATION { LARGE_INTEGER StartingOffset; LARGE_INTEGER PartitionLength; ULONG HiddenSectors; ULONG PartitionNumber; UCHAR PartitionType; BOOLEAN BootIndicator; BOOLEAN RecognizedPartition; BOOLEAN RewritePartition;} PARTITION_INFORMATION, *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.//
typedef struct _SET_PARTITION_INFORMATION { UCHAR PartitionType;} SET_PARTITION_INFORMATION, *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.//
typedef struct _DRIVE_LAYOUT_INFORMATION { ULONG PartitionCount; ULONG Signature; PARTITION_INFORMATION PartitionEntry[1];} DRIVE_LAYOUT_INFORMATION, *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.//
typedef struct _VERIFY_INFORMATION { LARGE_INTEGER StartingOffset; ULONG Length;} VERIFY_INFORMATION, *PVERIFY_INFORMATION;
//// The following structure is passed in on an IOCTL_DISK_REASSIGN_BLOCKS// request.//
typedef struct _REASSIGN_BLOCKS { USHORT Reserved; USHORT Count; ULONG BlockNumber[1];} REASSIGN_BLOCKS, *PREASSIGN_BLOCKS;
#if(_WIN32_WINNT >= 0x500)
//// 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.//
typedef enum _PARTITION_STYLE { PARTITION_STYLE_MBR, PARTITION_STYLE_GPT, PARTITION_STYLE_RAW} PARTITION_STYLE;
//// The following structure defines information in a GPT partition that is// not common to both GPT and MBR partitions.//
typedef struct _PARTITION_INFORMATION_GPT { GUID PartitionType; // Partition type. See table 16-3. GUID PartitionId; // Unique GUID for this partition. ULONG64 Attributes; // See table 16-4. WCHAR Name [36]; // Partition Name in Unicode.} PARTITION_INFORMATION_GPT, *PPARTITION_INFORMATION_GPT;
//// The following are GPT partition attributes applicable for any// partition type. These attributes are not OS-specific//
#define GPT_ATTRIBUTE_PLATFORM_REQUIRED (0x0000000000000001)
//// The following are GPT partition attributes applicable when the// PartitionType is PARTITION_BASIC_DATA_GUID.//
#define GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER (0x8000000000000000)#define GPT_BASIC_DATA_ATTRIBUTE_HIDDEN (0x4000000000000000)#define GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY (0x1000000000000000)
//// The following structure defines information in an MBR partition that is not// common to both GPT and MBR partitions.//
typedef struct _PARTITION_INFORMATION_MBR { UCHAR PartitionType; BOOLEAN BootIndicator; BOOLEAN RecognizedPartition; ULONG HiddenSectors;} PARTITION_INFORMATION_MBR, *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.//
typedef SET_PARTITION_INFORMATION SET_PARTITION_INFORMATION_MBR;typedef PARTITION_INFORMATION_GPT SET_PARTITION_INFORMATION_GPT;
typedef struct _SET_PARTITION_INFORMATION_EX { PARTITION_STYLE PartitionStyle; union { SET_PARTITION_INFORMATION_MBR Mbr; SET_PARTITION_INFORMATION_GPT Gpt; };} SET_PARTITION_INFORMATION_EX, *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.//
typedef struct _CREATE_DISK_GPT { GUID DiskId; // Unique disk id for the disk. ULONG MaxPartitionCount; // Maximim number of partitions allowable.} CREATE_DISK_GPT, *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.//
typedef struct _CREATE_DISK_MBR { ULONG Signature;} CREATE_DISK_MBR, *PCREATE_DISK_MBR;
typedef struct _CREATE_DISK { PARTITION_STYLE PartitionStyle; union { CREATE_DISK_MBR Mbr; CREATE_DISK_GPT Gpt; };} CREATE_DISK, *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.//
typedef struct _GET_LENGTH_INFORMATION { LARGE_INTEGER Length;} GET_LENGTH_INFORMATION, *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.//
typedef struct _PARTITION_INFORMATION_EX { PARTITION_STYLE PartitionStyle; LARGE_INTEGER StartingOffset; LARGE_INTEGER PartitionLength; ULONG PartitionNumber; BOOLEAN RewritePartition; union { PARTITION_INFORMATION_MBR Mbr; PARTITION_INFORMATION_GPT Gpt; };} PARTITION_INFORMATION_EX, *PPARTITION_INFORMATION_EX;
//// GPT specific drive layout information.//
typedef struct _DRIVE_LAYOUT_INFORMATION_GPT { GUID DiskId; LARGE_INTEGER StartingUsableOffset; LARGE_INTEGER UsableLength; ULONG MaxPartitionCount;} DRIVE_LAYOUT_INFORMATION_GPT, *PDRIVE_LAYOUT_INFORMATION_GPT;
//// MBR specific drive layout information.//
typedef struct _DRIVE_LAYOUT_INFORMATION_MBR { ULONG Signature;} DRIVE_LAYOUT_INFORMATION_MBR, *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.//
typedef struct _DRIVE_LAYOUT_INFORMATION_EX { ULONG PartitionStyle; ULONG PartitionCount; union { DRIVE_LAYOUT_INFORMATION_MBR Mbr; DRIVE_LAYOUT_INFORMATION_GPT Gpt; }; PARTITION_INFORMATION_EX PartitionEntry[1];} DRIVE_LAYOUT_INFORMATION_EX, *PDRIVE_LAYOUT_INFORMATION_EX;
#endif // (_WIN32_WINNT >= 0x0500)
#if(_WIN32_WINNT >= 0x0500)
//// The DISK_GEOMETRY_EX structure is returned on issuing an// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX ioctl.//
typedef enum _DETECTION_TYPE { DetectNone, DetectInt13, DetectExInt13} DETECTION_TYPE;
typedef struct _DISK_INT13_INFO { USHORT DriveSelect; ULONG MaxCylinders; USHORT SectorsPerTrack; USHORT MaxHeads; USHORT NumberDrives;} DISK_INT13_INFO, *PDISK_INT13_INFO;
typedef struct _DISK_EX_INT13_INFO { USHORT ExBufferSize; USHORT ExFlags; ULONG ExCylinders; ULONG ExHeads; ULONG ExSectorsPerTrack; ULONG64 ExSectorsPerDrive; USHORT ExSectorSize; USHORT ExReserved;} DISK_EX_INT13_INFO, *PDISK_EX_INT13_INFO;
typedef struct _DISK_DETECTION_INFO { ULONG SizeOfDetectInfo; DETECTION_TYPE DetectionType; union { struct {
// // If DetectionType == DETECTION_INT13 then we have just the Int13 // information. //
DISK_INT13_INFO Int13;
// // If DetectionType == DETECTION_EX_INT13, then we have the // extended int 13 information. //
DISK_EX_INT13_INFO ExInt13; // If DetectionType == DetectExInt13 }; };} DISK_DETECTION_INFO, *PDISK_DETECTION_INFO;
typedef struct _DISK_PARTITION_INFO { ULONG SizeOfPartitionInfo; PARTITION_STYLE PartitionStyle; // PartitionStyle = RAW, GPT or MBR union { struct { // If PartitionStyle == MBR ULONG Signature; // MBR Signature ULONG CheckSum; // MBR CheckSum } Mbr; struct { // If PartitionStyle == GPT GUID DiskId; } Gpt; };} DISK_PARTITION_INFO, *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.//
#define DiskGeometryGetPartition(Geometry)\ ((PDISK_PARTITION_INFO)((Geometry)->Data))
#define DiskGeometryGetDetect(Geometry)\ ((PDISK_DETECTION_INFO)(((ULONG_PTR)DiskGeometryGetPartition(Geometry)+\ DiskGeometryGetPartition(Geometry)->SizeOfPartitionInfo)))
typedef struct _DISK_GEOMETRY_EX { DISK_GEOMETRY Geometry; // Standard disk geometry: may be faked by driver. LARGE_INTEGER DiskSize; // Must always be correct UCHAR Data[1]; // Partition, Detect info} DISK_GEOMETRY_EX, *PDISK_GEOMETRY_EX;
#endif // (_WIN32_WINNT > 0x0500)
#if(_WIN32_WINNT >= 0x0400)//// 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.//
typedef struct _DISK_CONTROLLER_NUMBER { ULONG ControllerNumber; ULONG DiskNumber;} DISK_CONTROLLER_NUMBER, *PDISK_CONTROLLER_NUMBER;#endif /* _WIN32_WINNT >= 0x0400 */
#if(_WIN32_WINNT >= 0x0500)
//// 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//
typedef enum { EqualPriority, KeepPrefetchedData, KeepReadData} DISK_CACHE_RETENTION_PRIORITY;
typedef struct _DISK_CACHE_INFORMATION {
// // 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. //
BOOLEAN ParametersSavable;
// // Indicates whether the write and read caches are enabled. //
BOOLEAN ReadCacheEnabled; BOOLEAN WriteCacheEnabled;
// // 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) //
DISK_CACHE_RETENTION_PRIORITY ReadRetentionPriority; DISK_CACHE_RETENTION_PRIORITY WriteRetentionPriority;
// // Requests for a larger number of blocks than this may have prefetching // disabled. If this value is set to 0 prefetch will be disabled. //
USHORT DisablePrefetchTransferLength;
// // If TRUE then ScalarPrefetch (below) will be valid. If FALSE then // the minimum and maximum values should be treated as a block count // (BlockPrefetch) //
BOOLEAN PrefetchScalar;
// // 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. //
union { struct { USHORT Minimum; USHORT Maximum;
// // The maximum number of blocks which will be prefetched - useful // with the scalar limits to set definite upper limits. //
USHORT MaximumBlocks; } ScalarPrefetch;
struct { USHORT Minimum; USHORT Maximum; } BlockPrefetch; };
} DISK_CACHE_INFORMATION, *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.//
typedef struct _DISK_GROW_PARTITION { ULONG PartitionNumber; LARGE_INTEGER BytesToGrow;} DISK_GROW_PARTITION, *PDISK_GROW_PARTITION;#endif /* _WIN32_WINNT >= 0x0500 */
///////////////////////////////////////////////////////// //// 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 //// /////////////////////////////////////////////////////////
#define HIST_NO_OF_BUCKETS 24
typedef struct _HISTOGRAM_BUCKET { ULONG Reads; ULONG Writes;} HISTOGRAM_BUCKET, *PHISTOGRAM_BUCKET;
#define HISTOGRAM_BUCKET_SIZE sizeof(HISTOGRAM_BUCKET)
typedef struct _DISK_HISTOGRAM { LARGE_INTEGER DiskSize; LARGE_INTEGER Start; LARGE_INTEGER End; LARGE_INTEGER Average; LARGE_INTEGER AverageRead; LARGE_INTEGER AverageWrite; ULONG Granularity; ULONG Size; ULONG ReadCount; ULONG WriteCount; PHISTOGRAM_BUCKET Histogram;} DISK_HISTOGRAM, *PDISK_HISTOGRAM;
#define DISK_HISTOGRAM_SIZE sizeof(DISK_HISTOGRAM)
///////////////////////////////////////////////////////// //// 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; LARGE_INTEGER IdleTime; ULONG ReadCount; ULONG WriteCount; ULONG QueueDepth; ULONG SplitCount; LARGE_INTEGER QueryTime; ULONG StorageDeviceNumber; WCHAR StorageManagerName[8];} 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; ULONG NumberOfBytes; UCHAR 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 { UCHAR Function; PVOID BufferAddress; ULONG 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 { ULONG NumberOfBins; ULONG TypeOfBin; BIN_RANGE BinsRanges[1];} PERF_BIN, *PPERF_BIN ;
//// Bin count//
typedef struct _BIN_COUNT { BIN_RANGE BinRange; ULONG BinCount;} BIN_COUNT, *PBIN_COUNT;
//// Bin results//
typedef struct _BIN_RESULTS { ULONG NumberOfBins; BIN_COUNT BinCounts[1];} BIN_RESULTS, *PBIN_RESULTS;
#if(_WIN32_WINNT >= 0x0400)//// Data structures for SMART drive fault prediction.//// GETVERSIONINPARAMS contains the data returned from the// Get Driver Version function.//
#include <pshpack1.h>typedef struct _GETVERSIONINPARAMS { UCHAR bVersion; // Binary driver version. UCHAR bRevision; // Binary driver revision. UCHAR bReserved; // Not used. UCHAR bIDEDeviceMap; // Bit map of IDE devices. ULONG fCapabilities; // Bit mask of driver capabilities. ULONG dwReserved[4]; // For future use.} GETVERSIONINPARAMS, *PGETVERSIONINPARAMS, *LPGETVERSIONINPARAMS;#include <poppack.h>
//// Bits returned in the fCapabilities member of GETVERSIONINPARAMS//
#define CAP_ATA_ID_CMD 1 // ATA ID command supported#define CAP_ATAPI_ID_CMD 2 // ATAPI ID command supported#define CAP_SMART_CMD 4 // SMART commannds supported
//// IDE registers//
#include <pshpack1.h>typedef struct _IDEREGS { UCHAR bFeaturesReg; // Used for specifying SMART "commands". UCHAR bSectorCountReg; // IDE sector count register UCHAR bSectorNumberReg; // IDE sector number register UCHAR bCylLowReg; // IDE low order cylinder value UCHAR bCylHighReg; // IDE high order cylinder value UCHAR bDriveHeadReg; // IDE drive/head register UCHAR bCommandReg; // Actual IDE command. UCHAR bReserved; // reserved for future use. Must be zero.} IDEREGS, *PIDEREGS, *LPIDEREGS;#include <poppack.h>
//// Valid values for the bCommandReg member of IDEREGS.//
#define ATAPI_ID_CMD 0xA1 // Returns ID sector for ATAPI.#define ID_CMD 0xEC // Returns ID sector for ATA.#define SMART_CMD 0xB0 // Performs SMART cmd. // Requires valid bFeaturesReg, // bCylLowReg, and bCylHighReg
//// Cylinder register defines for SMART command//
#define SMART_CYL_LOW 0x4F#define SMART_CYL_HI 0xC2
//// SENDCMDINPARAMS contains the input parameters for the// Send Command to Drive function.//
#include <pshpack1.h>typedef struct _SENDCMDINPARAMS { ULONG cBufferSize; // Buffer size in bytes IDEREGS irDriveRegs; // Structure with drive register values. UCHAR bDriveNumber; // Physical drive number to send // command to (0,1,2,3). UCHAR bReserved[3]; // Reserved for future expansion. ULONG dwReserved[4]; // For future use. UCHAR bBuffer[1]; // Input buffer.} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;#include <poppack.h>
//// Status returned from driver//
#include <pshpack1.h>typedef struct _DRIVERSTATUS { UCHAR bDriverError; // Error code from driver, // or 0 if no error. UCHAR bIDEError; // Contents of IDE Error register. // Only valid when bDriverError // is SMART_IDE_ERROR. UCHAR bReserved[2]; // Reserved for future expansion. ULONG dwReserved[2]; // Reserved for future expansion.} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;#include <poppack.h>
//// bDriverError values//
#define SMART_NO_ERROR 0 // No error#define SMART_IDE_ERROR 1 // Error from IDE controller#define SMART_INVALID_FLAG 2 // Invalid command flag#define SMART_INVALID_COMMAND 3 // Invalid command byte#define SMART_INVALID_BUFFER 4 // Bad buffer (null, invalid addr..)#define SMART_INVALID_DRIVE 5 // Drive number not valid#define SMART_INVALID_IOCTL 6 // Invalid IOCTL#define SMART_ERROR_NO_MEM 7 // Could not lock user's buffer#define SMART_INVALID_REGISTER 8 // Some IDE Register not valid#define SMART_NOT_SUPPORTED 9 // Invalid cmd flag set#define SMART_NO_IDE_DEVICE 10 // Cmd issued to device not present // although drive number is valid//// SMART sub commands for execute offline diags//#define SMART_OFFLINE_ROUTINE_OFFLINE 0#define SMART_SHORT_SELFTEST_OFFLINE 1#define SMART_EXTENDED_SELFTEST_OFFLINE 2#define SMART_ABORT_OFFLINE_SELFTEST 127#define SMART_SHORT_SELFTEST_CAPTIVE 129#define SMART_EXTENDED_SELFTEST_CAPTIVE 130
#include <pshpack1.h>typedef struct _SENDCMDOUTPARAMS { ULONG cBufferSize; // Size of bBuffer in bytes DRIVERSTATUS DriverStatus; // Driver status structure. UCHAR bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the // drive.} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;#include <poppack.h>
#define READ_ATTRIBUTE_BUFFER_SIZE 512#define IDENTIFY_BUFFER_SIZE 512#define READ_THRESHOLD_BUFFER_SIZE 512#define SMART_LOG_SECTOR_SIZE 512
//// Feature register defines for SMART "sub commands"//
#define READ_ATTRIBUTES 0xD0#define READ_THRESHOLDS 0xD1#define ENABLE_DISABLE_AUTOSAVE 0xD2#define SAVE_ATTRIBUTE_VALUES 0xD3#define EXECUTE_OFFLINE_DIAGS 0xD4#define SMART_READ_LOG 0xD5#define SMART_WRITE_LOG 0xd6#define ENABLE_SMART 0xD8#define DISABLE_SMART 0xD9#define RETURN_SMART_STATUS 0xDA#define ENABLE_DISABLE_AUTO_OFFLINE 0xDB#endif /* _WIN32_WINNT >= 0x0400 */
// end_winioctl
//// The following device control code is for the SIMBAD simulated bad// sector facility. See SIMBAD.H in this directory for related structures.//
#define IOCTL_DISK_SIMBAD CTL_CODE(IOCTL_DISK_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
//// Queue link for mapped addresses stored for unmapping.//
typedef struct _MAPPED_ADDRESS { struct _MAPPED_ADDRESS *NextMappedAddress; PVOID MappedAddress; ULONG NumberOfBytes; LARGE_INTEGER IoAddress; ULONG BusNumber;} MAPPED_ADDRESS, *PMAPPED_ADDRESS;
#ifdef __cplusplus}#endif
#endif // _NTDDDISK_H_
|
