/*++ 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 // 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_