diff options
Diffstat (limited to '')
| -rw-r--r-- | public/sdk/inc/ntdddisk.h | 695 |
1 files changed, 695 insertions, 0 deletions
diff --git a/public/sdk/inc/ntdddisk.h b/public/sdk/inc/ntdddisk.h new file mode 100644 index 000000000..296ae32ec --- /dev/null +++ b/public/sdk/inc/ntdddisk.h @@ -0,0 +1,695 @@ +/*++ BUILD Version: 0001 // Increment this if a change has global effects + +Copyright (c) 1990-1993 Microsoft Corporation + +Module Name: + + ntdddisk.h + +Abstract: + + This is the include file that defines all constants and types for + accessing the Disk device. + +Author: + + Steve Wood (stevewo) 27-May-1990 + +Revision History: + +--*/ + +#ifndef _NTDDDISK_H_ +#define _NTDDDISK_H_ + +// +// 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) + +#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 */ + + +// end_winioctl + +// +// 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) + +// 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_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_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_FAT_16)) || \ + ((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_NTFT) == PARTITION_FAT_12) || \ + ((PartitionType & ~PARTITION_NTFT) == PARTITION_FAT_16) || \ + ((PartitionType & ~PARTITION_NTFT) == PARTITION_IFS) || \ + ((PartitionType & ~PARTITION_NTFT) == PARTITION_HUGE) || \ + ((PartitionType & ~PARTITION_NTFT) == PARTITION_FAT32) || \ + ((PartitionType & ~PARTITION_NTFT) == PARTITION_FAT32_XINT13) || \ + ((PartitionType & ~PARTITION_NTFT) == 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)) + +// +// 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 +} 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; + +// +// 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 >= 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 */ + +/////////////////////////////////////////////////////// +// // +// 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; + ULONG ReadCount; + ULONG WriteCount; + ULONG 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; + 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. +// + +#pragma pack(1) +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; +#pragma pack() + +// +// 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 +// + +#pragma pack(1) +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; +#pragma pack() + +// +// 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. +// + +#pragma pack(1) +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; +#pragma pack() + +// +// Status returned from driver +// + +#pragma pack(1) +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; +#pragma pack() + +// +// 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 + +#pragma pack(1) +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; +#pragma pack() + + +#define READ_ATTRIBUTE_BUFFER_SIZE 512 +#define IDENTIFY_BUFFER_SIZE 512 +#define READ_THRESHOLD_BUFFER_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 ENABLE_SMART 0xD8 +#define DISABLE_SMART 0xD9 +#define RETURN_SMART_STATUS 0xDA +#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; + +#endif // _NTDDDISK_H_ |