开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WinIoCtl.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：121k
源码类别：

模拟服务器

开发平台：

C/C++

WinIoCtl.h：源码内容
  1. /*++ BUILD Version: 0015    // Increment this if a change has global effects
  3. Copyright (c) Microsoft Corporation. All rights reserved.
  5. Module Name:
  7.     winioctl.h
  9. Abstract:
  11.     This module defines the 32-Bit Windows Device I/O control codes.
  13. Revision History:
  15. --*/
  18. //
  19. // Device interface class GUIDs.
  20. //
  21. // need these GUIDs outside conditional includes so that user can
  22. //   #include <winioctl.h> in precompiled header
  23. //   #include <initguid.h> in a single source file
  24. //   #include <winioctl.h> in that source file a second time to instantiate the GUIDs
  25. //
  26. #ifdef DEFINE_GUID
  27. //
  28. // Make sure FAR is defined...
  29. //
  30. #ifndef FAR
  31. #ifdef _WIN32
  32. #define FAR
  33. #else
  34. #define FAR _far
  35. #endif
  36. #endif
  38. DEFINE_GUID(GUID_DEVINTERFACE_DISK,                   0x53f56307L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  39. DEFINE_GUID(GUID_DEVINTERFACE_CDROM,                  0x53f56308L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  40. DEFINE_GUID(GUID_DEVINTERFACE_PARTITION,              0x53f5630aL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  41. DEFINE_GUID(GUID_DEVINTERFACE_TAPE,                   0x53f5630bL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  42. DEFINE_GUID(GUID_DEVINTERFACE_WRITEONCEDISK,          0x53f5630cL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  43. DEFINE_GUID(GUID_DEVINTERFACE_VOLUME,                 0x53f5630dL, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  44. DEFINE_GUID(GUID_DEVINTERFACE_MEDIUMCHANGER,          0x53f56310L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  45. DEFINE_GUID(GUID_DEVINTERFACE_FLOPPY,                 0x53f56311L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  46. DEFINE_GUID(GUID_DEVINTERFACE_CDCHANGER,              0x53f56312L, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  47. DEFINE_GUID(GUID_DEVINTERFACE_STORAGEPORT,            0x2accfe60L, 0xc130, 0x11d2, 0xb0, 0x82, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
  48. DEFINE_GUID(GUID_DEVINTERFACE_COMPORT,                0x86e0d1e0L, 0x8089, 0x11d0, 0x9c, 0xe4, 0x08, 0x00, 0x3e, 0x30, 0x1f, 0x73);
  49. DEFINE_GUID(GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR, 0x4D36E978L, 0xE325, 0x11CE, 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18);
  51. //
  52. // Obsolete device interface class GUID names.
  53. // (use of above GUID_DEVINTERFACE_* names is recommended).
  54. //
  55. #define DiskClassGuid               GUID_DEVINTERFACE_DISK
  56. #define CdRomClassGuid              GUID_DEVINTERFACE_CDROM
  57. #define PartitionClassGuid          GUID_DEVINTERFACE_PARTITION
  58. #define TapeClassGuid               GUID_DEVINTERFACE_TAPE
  59. #define WriteOnceDiskClassGuid      GUID_DEVINTERFACE_WRITEONCEDISK
  60. #define VolumeClassGuid             GUID_DEVINTERFACE_VOLUME
  61. #define MediumChangerClassGuid      GUID_DEVINTERFACE_MEDIUMCHANGER
  62. #define FloppyClassGuid             GUID_DEVINTERFACE_FLOPPY
  63. #define CdChangerClassGuid          GUID_DEVINTERFACE_CDCHANGER
  64. #define StoragePortClassGuid        GUID_DEVINTERFACE_STORAGEPORT
  65. #define GUID_CLASS_COMPORT          GUID_DEVINTERFACE_COMPORT
  66. #define GUID_SERENUM_BUS_ENUMERATOR GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR
  68. #endif // DEFINE_GUID
  70. #ifndef _WINIOCTL_
  71. #define _WINIOCTL_
  74. #ifndef _DEVIOCTL_
  75. #define _DEVIOCTL_
  77. // begin_ntddk begin_wdm begin_nthal begin_ntifs
  78. //
  79. // Define the various device type values.  Note that values used by Microsoft
  80. // Corporation are in the range 0-32767, and 32768-65535 are reserved for use
  81. // by customers.
  82. //
  84. #define DEVICE_TYPE DWORD
  86. #define FILE_DEVICE_BEEP                0x00000001
  87. #define FILE_DEVICE_CD_ROM              0x00000002
  88. #define FILE_DEVICE_CD_ROM_FILE_SYSTEM  0x00000003
  89. #define FILE_DEVICE_CONTROLLER          0x00000004
  90. #define FILE_DEVICE_DATALINK            0x00000005
  91. #define FILE_DEVICE_DFS                 0x00000006
  92. #define FILE_DEVICE_DISK                0x00000007
  93. #define FILE_DEVICE_DISK_FILE_SYSTEM    0x00000008
  94. #define FILE_DEVICE_FILE_SYSTEM         0x00000009
  95. #define FILE_DEVICE_INPORT_PORT         0x0000000a
  96. #define FILE_DEVICE_KEYBOARD            0x0000000b
  97. #define FILE_DEVICE_MAILSLOT            0x0000000c
  98. #define FILE_DEVICE_MIDI_IN             0x0000000d
  99. #define FILE_DEVICE_MIDI_OUT            0x0000000e
  100. #define FILE_DEVICE_MOUSE               0x0000000f
  101. #define FILE_DEVICE_MULTI_UNC_PROVIDER  0x00000010
  102. #define FILE_DEVICE_NAMED_PIPE          0x00000011
  103. #define FILE_DEVICE_NETWORK             0x00000012
  104. #define FILE_DEVICE_NETWORK_BROWSER     0x00000013
  105. #define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
  106. #define FILE_DEVICE_NULL                0x00000015
  107. #define FILE_DEVICE_PARALLEL_PORT       0x00000016
  108. #define FILE_DEVICE_PHYSICAL_NETCARD    0x00000017
  109. #define FILE_DEVICE_PRINTER             0x00000018
  110. #define FILE_DEVICE_SCANNER             0x00000019
  111. #define FILE_DEVICE_SERIAL_MOUSE_PORT   0x0000001a
  112. #define FILE_DEVICE_SERIAL_PORT         0x0000001b
  113. #define FILE_DEVICE_SCREEN              0x0000001c
  114. #define FILE_DEVICE_SOUND               0x0000001d
  115. #define FILE_DEVICE_STREAMS             0x0000001e
  116. #define FILE_DEVICE_TAPE                0x0000001f
  117. #define FILE_DEVICE_TAPE_FILE_SYSTEM    0x00000020
  118. #define FILE_DEVICE_TRANSPORT           0x00000021
  119. #define FILE_DEVICE_UNKNOWN             0x00000022
  120. #define FILE_DEVICE_VIDEO               0x00000023
  121. #define FILE_DEVICE_VIRTUAL_DISK        0x00000024
  122. #define FILE_DEVICE_WAVE_IN             0x00000025
  123. #define FILE_DEVICE_WAVE_OUT            0x00000026
  124. #define FILE_DEVICE_8042_PORT           0x00000027
  125. #define FILE_DEVICE_NETWORK_REDIRECTOR  0x00000028
  126. #define FILE_DEVICE_BATTERY             0x00000029
  127. #define FILE_DEVICE_BUS_EXTENDER        0x0000002a
  128. #define FILE_DEVICE_MODEM               0x0000002b
  129. #define FILE_DEVICE_VDM                 0x0000002c
  130. #define FILE_DEVICE_MASS_STORAGE        0x0000002d
  131. #define FILE_DEVICE_SMB                 0x0000002e
  132. #define FILE_DEVICE_KS                  0x0000002f
  133. #define FILE_DEVICE_CHANGER             0x00000030
  134. #define FILE_DEVICE_SMARTCARD           0x00000031
  135. #define FILE_DEVICE_ACPI                0x00000032
  136. #define FILE_DEVICE_DVD                 0x00000033
  137. #define FILE_DEVICE_FULLSCREEN_VIDEO    0x00000034
  138. #define FILE_DEVICE_DFS_FILE_SYSTEM     0x00000035
  139. #define FILE_DEVICE_DFS_VOLUME          0x00000036
  140. #define FILE_DEVICE_SERENUM             0x00000037
  141. #define FILE_DEVICE_TERMSRV             0x00000038
  142. #define FILE_DEVICE_KSEC                0x00000039
  143. #define FILE_DEVICE_FIPS 0x0000003A
  145. //
  146. // Macro definition for defining IOCTL and FSCTL function control codes.  Note
  147. // that function codes 0-2047 are reserved for Microsoft Corporation, and
  148. // 2048-4095 are reserved for customers.
  149. //
  151. #define CTL_CODE( DeviceType, Function, Method, Access ) (                 
  152.     ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) 
  153. )
  155. //
  156. // Macro to extract device type out of the device io control code
  157. //
  158. #define DEVICE_TYPE_FROM_CTL_CODE(ctrlCode)     (((DWORD)(ctrlCode & 0xffff0000)) >> 16)
  160. //
  161. // Define the method codes for how buffers are passed for I/O and FS controls
  162. //
  164. #define METHOD_BUFFERED                 0
  165. #define METHOD_IN_DIRECT                1
  166. #define METHOD_OUT_DIRECT               2
  167. #define METHOD_NEITHER                  3
  169. //
  170. // Define the access check value for any access
  171. //
  172. //
  173. // The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
  174. // ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
  175. // constants *MUST* always be in sync.
  176. //
  177. //
  178. // FILE_SPECIAL_ACCESS is checked by the NT I/O system the same as FILE_ANY_ACCESS.
  179. // The file systems, however, may add additional access checks for I/O and FS controls
  180. // that use this value.
  181. //
  184. #define FILE_ANY_ACCESS                 0
  185. #define FILE_SPECIAL_ACCESS    (FILE_ANY_ACCESS)
  186. #define FILE_READ_ACCESS          ( 0x0001 )    // file & pipe
  187. #define FILE_WRITE_ACCESS         ( 0x0002 )    // file & pipe
  189. // end_ntddk end_wdm end_nthal end_ntifs
  191. #endif // _DEVIOCTL_
  194. #ifndef _NTDDSTOR_H_
  195. #define _NTDDSTOR_H_
  197. #ifdef __cplusplus
  198. extern "C" {
  199. #endif
  201. //
  202. // IoControlCode values for storage devices
  203. //
  205. #define IOCTL_STORAGE_BASE FILE_DEVICE_MASS_STORAGE
  207. //
  208. // The following device control codes are common for all class drivers.  They
  209. // should be used in place of the older IOCTL_DISK, IOCTL_CDROM and IOCTL_TAPE
  210. // common codes
  211. //
  213. #define IOCTL_STORAGE_CHECK_VERIFY            CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)
  214. #define IOCTL_STORAGE_CHECK_VERIFY2           CTL_CODE(IOCTL_STORAGE_BASE, 0x0200, METHOD_BUFFERED, FILE_ANY_ACCESS)
  215. #define IOCTL_STORAGE_MEDIA_REMOVAL           CTL_CODE(IOCTL_STORAGE_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
  216. #define IOCTL_STORAGE_EJECT_MEDIA             CTL_CODE(IOCTL_STORAGE_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
  217. #define IOCTL_STORAGE_LOAD_MEDIA              CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
  218. #define IOCTL_STORAGE_LOAD_MEDIA2             CTL_CODE(IOCTL_STORAGE_BASE, 0x0203, METHOD_BUFFERED, FILE_ANY_ACCESS)
  219. #define IOCTL_STORAGE_RESERVE                 CTL_CODE(IOCTL_STORAGE_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)
  220. #define IOCTL_STORAGE_RELEASE                 CTL_CODE(IOCTL_STORAGE_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)
  221. #define IOCTL_STORAGE_FIND_NEW_DEVICES        CTL_CODE(IOCTL_STORAGE_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)
  223. #define IOCTL_STORAGE_EJECTION_CONTROL        CTL_CODE(IOCTL_STORAGE_BASE, 0x0250, METHOD_BUFFERED, FILE_ANY_ACCESS)
  224. #define IOCTL_STORAGE_MCN_CONTROL             CTL_CODE(IOCTL_STORAGE_BASE, 0x0251, METHOD_BUFFERED, FILE_ANY_ACCESS)
  226. #define IOCTL_STORAGE_GET_MEDIA_TYPES         CTL_CODE(IOCTL_STORAGE_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
  227. #define IOCTL_STORAGE_GET_MEDIA_TYPES_EX      CTL_CODE(IOCTL_STORAGE_BASE, 0x0301, METHOD_BUFFERED, FILE_ANY_ACCESS)
  228. #define IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER CTL_CODE(IOCTL_STORAGE_BASE, 0x0304, METHOD_BUFFERED, FILE_ANY_ACCESS)
  229. #define IOCTL_STORAGE_GET_HOTPLUG_INFO        CTL_CODE(IOCTL_STORAGE_BASE, 0x0305, METHOD_BUFFERED, FILE_ANY_ACCESS)
  230. #define IOCTL_STORAGE_SET_HOTPLUG_INFO        CTL_CODE(IOCTL_STORAGE_BASE, 0x0306, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  232. #define IOCTL_STORAGE_RESET_BUS               CTL_CODE(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS)
  233. #define IOCTL_STORAGE_RESET_DEVICE            CTL_CODE(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS)
  234. #define IOCTL_STORAGE_BREAK_RESERVATION       CTL_CODE(IOCTL_STORAGE_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS)
  236. #define IOCTL_STORAGE_GET_DEVICE_NUMBER       CTL_CODE(IOCTL_STORAGE_BASE, 0x0420, METHOD_BUFFERED, FILE_ANY_ACCESS)
  237. #define IOCTL_STORAGE_PREDICT_FAILURE         CTL_CODE(IOCTL_STORAGE_BASE, 0x0440, METHOD_BUFFERED, FILE_ANY_ACCESS)
  240. //
  241. // These ioctl codes are obsolete.  They are defined here to avoid resuing them
  242. // and to allow class drivers to respond to them more easily.
  243. //
  245. #define OBSOLETE_IOCTL_STORAGE_RESET_BUS        CTL_CODE(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  246. #define OBSOLETE_IOCTL_STORAGE_RESET_DEVICE     CTL_CODE(IOCTL_STORAGE_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  249. //
  250. // IOCTL_STORAGE_GET_HOTPLUG_INFO
  251. //
  253. typedef struct _STORAGE_HOTPLUG_INFO {
  254.     DWORD Size; // version
  255.     BOOLEAN MediaRemovable; // ie. zip, jaz, cdrom, mo, etc. vs hdd
  256.     BOOLEAN MediaHotplug;   // ie. does the device succeed a lock even though its not lockable media?
  257.     BOOLEAN DeviceHotplug;  // ie. 1394, USB, etc.
  258.     BOOLEAN WriteCacheEnableOverride; // This field should not be relied upon because it is no longer used
  259. } STORAGE_HOTPLUG_INFO, *PSTORAGE_HOTPLUG_INFO;
  261. //
  262. // IOCTL_STORAGE_GET_DEVICE_NUMBER
  263. //
  264. // input - none
  265. //
  266. // output - STORAGE_DEVICE_NUMBER structure
  267. //          The values in the STORAGE_DEVICE_NUMBER structure are guaranteed
  268. //          to remain unchanged until the system is rebooted.  They are not
  269. //          guaranteed to be persistant across boots.
  270. //
  272. typedef struct _STORAGE_DEVICE_NUMBER {
  274.     //
  275.     // The FILE_DEVICE_XXX type for this device.
  276.     //
  278.     DEVICE_TYPE DeviceType;
  280.     //
  281.     // The number of this device
  282.     //
  284.     DWORD       DeviceNumber;
  286.     //
  287.     // If the device is partitionable, the partition number of the device.
  288.     // Otherwise -1
  289.     //
  291.     DWORD       PartitionNumber;
  292. } STORAGE_DEVICE_NUMBER, *PSTORAGE_DEVICE_NUMBER;
  294. //
  295. // Define the structures for scsi resets
  296. //
  298. typedef struct _STORAGE_BUS_RESET_REQUEST {
  299.     BYTE  PathId;
  300. } STORAGE_BUS_RESET_REQUEST, *PSTORAGE_BUS_RESET_REQUEST;
  302. //
  303. // IOCTL_STORAGE_MEDIA_REMOVAL disables the mechanism
  304. // on a storage device that ejects media. This function
  305. // may or may not be supported on storage devices that
  306. // support removable media.
  307. //
  308. // TRUE means prevent media from being removed.
  309. // FALSE means allow media removal.
  310. //
  312. typedef struct _PREVENT_MEDIA_REMOVAL {
  313.     BOOLEAN PreventMediaRemoval;
  314. } PREVENT_MEDIA_REMOVAL, *PPREVENT_MEDIA_REMOVAL;
  316. // begin_ntminitape
  319. typedef struct _TAPE_STATISTICS {
  320.     DWORD Version;
  321.     DWORD Flags;
  322.     LARGE_INTEGER RecoveredWrites;
  323.     LARGE_INTEGER UnrecoveredWrites;
  324.     LARGE_INTEGER RecoveredReads;
  325.     LARGE_INTEGER UnrecoveredReads;
  326.     BYTE          CompressionRatioReads;
  327.     BYTE          CompressionRatioWrites;
  328. } TAPE_STATISTICS, *PTAPE_STATISTICS;
  330. #define RECOVERED_WRITES_VALID   0x00000001
  331. #define UNRECOVERED_WRITES_VALID 0x00000002
  332. #define RECOVERED_READS_VALID    0x00000004
  333. #define UNRECOVERED_READS_VALID  0x00000008
  334. #define WRITE_COMPRESSION_INFO_VALID  0x00000010
  335. #define READ_COMPRESSION_INFO_VALID   0x00000020
  337. typedef struct _TAPE_GET_STATISTICS {
  338.     DWORD Operation;
  339. } TAPE_GET_STATISTICS, *PTAPE_GET_STATISTICS;
  341. #define TAPE_RETURN_STATISTICS 0L
  342. #define TAPE_RETURN_ENV_INFO   1L
  343. #define TAPE_RESET_STATISTICS  2L
  345. //
  346. // IOCTL_STORAGE_GET_MEDIA_TYPES_EX will return an array of DEVICE_MEDIA_INFO
  347. // structures, one per supported type, embedded in the GET_MEDIA_TYPES struct.
  348. //
  350. typedef enum _STORAGE_MEDIA_TYPE {
  351.     //
  352.     // Following are defined in ntdddisk.h in the MEDIA_TYPE enum
  353.     //
  354.     // Unknown,                // Format is unknown
  355.     // F5_1Pt2_512,            // 5.25", 1.2MB,  512 bytes/sector
  356.     // F3_1Pt44_512,           // 3.5",  1.44MB, 512 bytes/sector
  357.     // F3_2Pt88_512,           // 3.5",  2.88MB, 512 bytes/sector
  358.     // F3_20Pt8_512,           // 3.5",  20.8MB, 512 bytes/sector
  359.     // F3_720_512,             // 3.5",  720KB,  512 bytes/sector
  360.     // F5_360_512,             // 5.25", 360KB,  512 bytes/sector
  361.     // F5_320_512,             // 5.25", 320KB,  512 bytes/sector
  362.     // F5_320_1024,            // 5.25", 320KB,  1024 bytes/sector
  363.     // F5_180_512,             // 5.25", 180KB,  512 bytes/sector
  364.     // F5_160_512,             // 5.25", 160KB,  512 bytes/sector
  365.     // RemovableMedia,         // Removable media other than floppy
  366.     // FixedMedia,             // Fixed hard disk media
  367.     // F3_120M_512,            // 3.5", 120M Floppy
  368.     // F3_640_512,             // 3.5" ,  640KB,  512 bytes/sector
  369.     // F5_640_512,             // 5.25",  640KB,  512 bytes/sector
  370.     // F5_720_512,             // 5.25",  720KB,  512 bytes/sector
  371.     // F3_1Pt2_512,            // 3.5" ,  1.2Mb,  512 bytes/sector
  372.     // F3_1Pt23_1024,          // 3.5" ,  1.23Mb, 1024 bytes/sector
  373.     // F5_1Pt23_1024,          // 5.25",  1.23MB, 1024 bytes/sector
  374.     // F3_128Mb_512,           // 3.5" MO 128Mb   512 bytes/sector
  375.     // F3_230Mb_512,           // 3.5" MO 230Mb   512 bytes/sector
  376.     // F8_256_128,             // 8",     256KB,  128 bytes/sector
  377.     // F3_200Mb_512,           // 3.5",   200M Floppy (HiFD)
  378.     //
  380.     DDS_4mm = 0x20,            // Tape - DAT DDS1,2,... (all vendors)
  381.     MiniQic,                   // Tape - miniQIC Tape
  382.     Travan,                    // Tape - Travan TR-1,2,3,...
  383.     QIC,                       // Tape - QIC
  384.     MP_8mm,                    // Tape - 8mm Exabyte Metal Particle
  385.     AME_8mm,                   // Tape - 8mm Exabyte Advanced Metal Evap
  386.     AIT1_8mm,                  // Tape - 8mm Sony AIT
  387.     DLT,                       // Tape - DLT Compact IIIxt, IV
  388.     NCTP,                      // Tape - Philips NCTP
  389.     IBM_3480,                  // Tape - IBM 3480
  390.     IBM_3490E,                 // Tape - IBM 3490E
  391.     IBM_Magstar_3590,          // Tape - IBM Magstar 3590
  392.     IBM_Magstar_MP,            // Tape - IBM Magstar MP
  393.     STK_DATA_D3,               // Tape - STK Data D3
  394.     SONY_DTF,                  // Tape - Sony DTF
  395.     DV_6mm,                    // Tape - 6mm Digital Video
  396.     DMI,                       // Tape - Exabyte DMI and compatibles
  397.     SONY_D2,                   // Tape - Sony D2S and D2L
  398.     CLEANER_CARTRIDGE,         // Cleaner - All Drive types that support Drive Cleaners
  399.     CD_ROM,                    // Opt_Disk - CD
  400.     CD_R,                      // Opt_Disk - CD-Recordable (Write Once)
  401.     CD_RW,                     // Opt_Disk - CD-Rewriteable
  402.     DVD_ROM,                   // Opt_Disk - DVD-ROM
  403.     DVD_R,                     // Opt_Disk - DVD-Recordable (Write Once)
  404.     DVD_RW,                    // Opt_Disk - DVD-Rewriteable
  405.     MO_3_RW,                   // Opt_Disk - 3.5" Rewriteable MO Disk
  406.     MO_5_WO,                   // Opt_Disk - MO 5.25" Write Once
  407.     MO_5_RW,                   // Opt_Disk - MO 5.25" Rewriteable (not LIMDOW)
  408.     MO_5_LIMDOW,               // Opt_Disk - MO 5.25" Rewriteable (LIMDOW)
  409.     PC_5_WO,                   // Opt_Disk - Phase Change 5.25" Write Once Optical
  410.     PC_5_RW,                   // Opt_Disk - Phase Change 5.25" Rewriteable
  411.     PD_5_RW,                   // Opt_Disk - PhaseChange Dual Rewriteable
  412.     ABL_5_WO,                  // Opt_Disk - Ablative 5.25" Write Once Optical
  413.     PINNACLE_APEX_5_RW,        // Opt_Disk - Pinnacle Apex 4.6GB Rewriteable Optical
  414.     SONY_12_WO,                // Opt_Disk - Sony 12" Write Once
  415.     PHILIPS_12_WO,             // Opt_Disk - Philips/LMS 12" Write Once
  416.     HITACHI_12_WO,             // Opt_Disk - Hitachi 12" Write Once
  417.     CYGNET_12_WO,              // Opt_Disk - Cygnet/ATG 12" Write Once
  418.     KODAK_14_WO,               // Opt_Disk - Kodak 14" Write Once
  419.     MO_NFR_525,                // Opt_Disk - Near Field Recording (Terastor)
  420.     NIKON_12_RW,               // Opt_Disk - Nikon 12" Rewriteable
  421.     IOMEGA_ZIP,                // Mag_Disk - Iomega Zip
  422.     IOMEGA_JAZ,                // Mag_Disk - Iomega Jaz
  423.     SYQUEST_EZ135,             // Mag_Disk - Syquest EZ135
  424.     SYQUEST_EZFLYER,           // Mag_Disk - Syquest EzFlyer
  425.     SYQUEST_SYJET,             // Mag_Disk - Syquest SyJet
  426.     AVATAR_F2,                 // Mag_Disk - 2.5" Floppy
  427.     MP2_8mm,                   // Tape - 8mm Hitachi
  428.     DST_S,                     // Ampex DST Small Tapes
  429.     DST_M,                     // Ampex DST Medium Tapes
  430.     DST_L,                     // Ampex DST Large Tapes
  431.     VXATape_1,                 // Ecrix 8mm Tape
  432.     VXATape_2,                 // Ecrix 8mm Tape
  433.     STK_9840,                  // STK 9840
  434.     LTO_Ultrium,               // IBM, HP, Seagate LTO Ultrium
  435.     LTO_Accelis,               // IBM, HP, Seagate LTO Accelis
  436.     DVD_RAM,                   // Opt_Disk - DVD-RAM
  437.     AIT_8mm,                   // AIT2 or higher
  438.     ADR_1,                     // OnStream ADR Mediatypes
  439.     ADR_2
  440. } STORAGE_MEDIA_TYPE, *PSTORAGE_MEDIA_TYPE;
  442. #define MEDIA_ERASEABLE         0x00000001
  443. #define MEDIA_WRITE_ONCE        0x00000002
  444. #define MEDIA_READ_ONLY         0x00000004
  445. #define MEDIA_READ_WRITE        0x00000008
  447. #define MEDIA_WRITE_PROTECTED   0x00000100
  448. #define MEDIA_CURRENTLY_MOUNTED 0x80000000
  450. //
  451. // Define the different storage bus types
  452. // Bus types below 128 (0x80) are reserved for Microsoft use
  453. //
  455. typedef enum _STORAGE_BUS_TYPE {
  456.     BusTypeUnknown = 0x00,
  457.     BusTypeScsi,
  458.     BusTypeAtapi,
  459.     BusTypeAta,
  460.     BusType1394,
  461.     BusTypeSsa,
  462.     BusTypeFibre,
  463.     BusTypeUsb,
  464.     BusTypeRAID,
  465.     BusTypeMaxReserved = 0x7F
  466. } STORAGE_BUS_TYPE, *PSTORAGE_BUS_TYPE;
  468. typedef struct _DEVICE_MEDIA_INFO {
  469.     union {
  470.         struct {
  471.             LARGE_INTEGER Cylinders;
  472.             STORAGE_MEDIA_TYPE MediaType;
  473.             DWORD TracksPerCylinder;
  474.             DWORD SectorsPerTrack;
  475.             DWORD BytesPerSector;
  476.             DWORD NumberMediaSides;
  477.             DWORD MediaCharacteristics; // Bitmask of MEDIA_XXX values.
  478.         } DiskInfo;
  480.         struct {
  481.             LARGE_INTEGER Cylinders;
  482.             STORAGE_MEDIA_TYPE MediaType;
  483.             DWORD TracksPerCylinder;
  484.             DWORD SectorsPerTrack;
  485.             DWORD BytesPerSector;
  486.             DWORD NumberMediaSides;
  487.             DWORD MediaCharacteristics; // Bitmask of MEDIA_XXX values.
  488.         } RemovableDiskInfo;
  490.         struct {
  491.             STORAGE_MEDIA_TYPE MediaType;
  492.             DWORD   MediaCharacteristics; // Bitmask of MEDIA_XXX values.
  493.             DWORD   CurrentBlockSize;
  494.             STORAGE_BUS_TYPE BusType;
  496.             //
  497.             // Bus specific information describing the medium supported.
  498.             //
  500.             union {
  501.                 struct {
  502.                     BYTE  MediumType;
  503.                     BYTE  DensityCode;
  504.                 } ScsiInformation;
  505.             } BusSpecificData;
  507.         } TapeInfo;
  508.     } DeviceSpecific;
  509. } DEVICE_MEDIA_INFO, *PDEVICE_MEDIA_INFO;
  511. typedef struct _GET_MEDIA_TYPES {
  512.     DWORD DeviceType;              // FILE_DEVICE_XXX values
  513.     DWORD MediaInfoCount;
  514.     DEVICE_MEDIA_INFO MediaInfo[1];
  515. } GET_MEDIA_TYPES, *PGET_MEDIA_TYPES;
  518. //
  519. // IOCTL_STORAGE_PREDICT_FAILURE
  520. //
  521. // input - none
  522. //
  523. // output - STORAGE_PREDICT_FAILURE structure
  524. //          PredictFailure returns zero if no failure predicted and non zero
  525. //                         if a failure is predicted.
  526. //
  527. //          VendorSpecific returns 512 bytes of vendor specific information
  528. //                         if a failure is predicted
  529. //
  530. typedef struct _STORAGE_PREDICT_FAILURE
  531. {
  532.     DWORD PredictFailure;
  533.     BYTE  VendorSpecific[512];
  534. } STORAGE_PREDICT_FAILURE, *PSTORAGE_PREDICT_FAILURE;
  536. // end_ntminitape
  538. #ifdef __cplusplus
  539. }
  540. #endif
  542. #endif // _NTDDSTOR_H_
  544. //
  545. // IoControlCode values for disk devices.
  546. //
  548. #define IOCTL_DISK_BASE                 FILE_DEVICE_DISK
  549. #define IOCTL_DISK_GET_DRIVE_GEOMETRY   CTL_CODE(IOCTL_DISK_BASE, 0x0000, METHOD_BUFFERED, FILE_ANY_ACCESS)
  550. #define IOCTL_DISK_GET_PARTITION_INFO   CTL_CODE(IOCTL_DISK_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
  551. #define IOCTL_DISK_SET_PARTITION_INFO   CTL_CODE(IOCTL_DISK_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  552. #define IOCTL_DISK_GET_DRIVE_LAYOUT     CTL_CODE(IOCTL_DISK_BASE, 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS)
  553. #define IOCTL_DISK_SET_DRIVE_LAYOUT     CTL_CODE(IOCTL_DISK_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  554. #define IOCTL_DISK_VERIFY               CTL_CODE(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED, FILE_ANY_ACCESS)
  555. #define IOCTL_DISK_FORMAT_TRACKS        CTL_CODE(IOCTL_DISK_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  556. #define IOCTL_DISK_REASSIGN_BLOCKS      CTL_CODE(IOCTL_DISK_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  557. #define IOCTL_DISK_PERFORMANCE          CTL_CODE(IOCTL_DISK_BASE, 0x0008, METHOD_BUFFERED, FILE_ANY_ACCESS)
  558. #define IOCTL_DISK_IS_WRITABLE          CTL_CODE(IOCTL_DISK_BASE, 0x0009, METHOD_BUFFERED, FILE_ANY_ACCESS)
  559. #define IOCTL_DISK_LOGGING              CTL_CODE(IOCTL_DISK_BASE, 0x000a, METHOD_BUFFERED, FILE_ANY_ACCESS)
  560. #define IOCTL_DISK_FORMAT_TRACKS_EX     CTL_CODE(IOCTL_DISK_BASE, 0x000b, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  561. #define IOCTL_DISK_HISTOGRAM_STRUCTURE  CTL_CODE(IOCTL_DISK_BASE, 0x000c, METHOD_BUFFERED, FILE_ANY_ACCESS)
  562. #define IOCTL_DISK_HISTOGRAM_DATA       CTL_CODE(IOCTL_DISK_BASE, 0x000d, METHOD_BUFFERED, FILE_ANY_ACCESS)
  563. #define IOCTL_DISK_HISTOGRAM_RESET      CTL_CODE(IOCTL_DISK_BASE, 0x000e, METHOD_BUFFERED, FILE_ANY_ACCESS)
  564. #define IOCTL_DISK_REQUEST_STRUCTURE    CTL_CODE(IOCTL_DISK_BASE, 0x000f, METHOD_BUFFERED, FILE_ANY_ACCESS)
  565. #define IOCTL_DISK_REQUEST_DATA         CTL_CODE(IOCTL_DISK_BASE, 0x0010, METHOD_BUFFERED, FILE_ANY_ACCESS)
  566. #define IOCTL_DISK_PERFORMANCE_OFF      CTL_CODE(IOCTL_DISK_BASE, 0x0018, METHOD_BUFFERED, FILE_ANY_ACCESS)
  570. #if(_WIN32_WINNT >= 0x0400)
  571. #define IOCTL_DISK_CONTROLLER_NUMBER    CTL_CODE(IOCTL_DISK_BASE, 0x0011, METHOD_BUFFERED, FILE_ANY_ACCESS)
  573. //
  574. // IOCTL support for SMART drive fault prediction.
  575. //
  577. #define SMART_GET_VERSION               CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)
  578. #define SMART_SEND_DRIVE_COMMAND        CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  579. #define SMART_RCV_DRIVE_DATA            CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  581. #endif /* _WIN32_WINNT >= 0x0400 */
  583. #if (_WIN32_WINNT >= 0x500)
  585. //
  586. // New IOCTLs for GUID Partition tabled disks.
  587. //
  589. #define IOCTL_DISK_GET_PARTITION_INFO_EX    CTL_CODE(IOCTL_DISK_BASE, 0x0012, METHOD_BUFFERED, FILE_ANY_ACCESS)
  590. #define IOCTL_DISK_SET_PARTITION_INFO_EX    CTL_CODE(IOCTL_DISK_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  591. #define IOCTL_DISK_GET_DRIVE_LAYOUT_EX      CTL_CODE(IOCTL_DISK_BASE, 0x0014, METHOD_BUFFERED, FILE_ANY_ACCESS)
  592. #define IOCTL_DISK_SET_DRIVE_LAYOUT_EX      CTL_CODE(IOCTL_DISK_BASE, 0x0015, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  593. #define IOCTL_DISK_CREATE_DISK              CTL_CODE(IOCTL_DISK_BASE, 0x0016, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  594. #define IOCTL_DISK_GET_LENGTH_INFO          CTL_CODE(IOCTL_DISK_BASE, 0x0017, METHOD_BUFFERED, FILE_READ_ACCESS)
  595. #define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX    CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
  597. #endif /* _WIN32_WINNT >= 0x0500 */
  600. #if(_WIN32_WINNT >= 0x0500)
  601. #define IOCTL_DISK_UPDATE_DRIVE_SIZE        CTL_CODE(IOCTL_DISK_BASE, 0x0032, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  602. #define IOCTL_DISK_GROW_PARTITION           CTL_CODE(IOCTL_DISK_BASE, 0x0034, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  604. #define IOCTL_DISK_GET_CACHE_INFORMATION    CTL_CODE(IOCTL_DISK_BASE, 0x0035, METHOD_BUFFERED, FILE_READ_ACCESS)
  605. #define IOCTL_DISK_SET_CACHE_INFORMATION    CTL_CODE(IOCTL_DISK_BASE, 0x0036, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  606. #define IOCTL_DISK_GET_WRITE_CACHE_STATE    CTL_CODE(IOCTL_DISK_BASE, 0x0037, METHOD_BUFFERED, FILE_READ_ACCESS)
  608. #define IOCTL_DISK_DELETE_DRIVE_LAYOUT      CTL_CODE(IOCTL_DISK_BASE, 0x0040, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  610. //
  611. // Called to flush cached information that the driver may have about this
  612. // device's characteristics.  Not all drivers cache characteristics, and not
  613. // cached properties can be flushed.  This simply serves as an update to the
  614. // driver that it may want to do an expensive reexamination of the device's
  615. // characteristics now (fixed media size, partition table, etc...)
  616. //
  618. #define IOCTL_DISK_UPDATE_PROPERTIES    CTL_CODE(IOCTL_DISK_BASE, 0x0050, METHOD_BUFFERED, FILE_ANY_ACCESS)
  620. //
  621. //  Special IOCTLs needed to support PC-98 machines in Japan
  622. //
  624. #define IOCTL_DISK_FORMAT_DRIVE         CTL_CODE(IOCTL_DISK_BASE, 0x00f3, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  625. #define IOCTL_DISK_SENSE_DEVICE         CTL_CODE(IOCTL_DISK_BASE, 0x00f8, METHOD_BUFFERED, FILE_ANY_ACCESS)
  627. #endif /* _WIN32_WINNT >= 0x0500 */
  629. //
  630. // The following device control codes are common for all class drivers.  The
  631. // functions codes defined here must match all of the other class drivers.
  632. //
  633. // Warning: these codes will be replaced in the future by equivalent
  634. // IOCTL_STORAGE codes
  635. //
  637. #define IOCTL_DISK_CHECK_VERIFY     CTL_CODE(IOCTL_DISK_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)
  638. #define IOCTL_DISK_MEDIA_REMOVAL    CTL_CODE(IOCTL_DISK_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
  639. #define IOCTL_DISK_EJECT_MEDIA      CTL_CODE(IOCTL_DISK_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
  640. #define IOCTL_DISK_LOAD_MEDIA       CTL_CODE(IOCTL_DISK_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
  641. #define IOCTL_DISK_RESERVE          CTL_CODE(IOCTL_DISK_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)
  642. #define IOCTL_DISK_RELEASE          CTL_CODE(IOCTL_DISK_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)
  643. #define IOCTL_DISK_FIND_NEW_DEVICES CTL_CODE(IOCTL_DISK_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)
  644. #define IOCTL_DISK_GET_MEDIA_TYPES CTL_CODE(IOCTL_DISK_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
  646. //
  647. // Define the partition types returnable by known disk drivers.
  648. //
  650. #define PARTITION_ENTRY_UNUSED          0x00      // Entry unused
  651. #define PARTITION_FAT_12                0x01      // 12-bit FAT entries
  652. #define PARTITION_XENIX_1               0x02      // Xenix
  653. #define PARTITION_XENIX_2               0x03      // Xenix
  654. #define PARTITION_FAT_16                0x04      // 16-bit FAT entries
  655. #define PARTITION_EXTENDED              0x05      // Extended partition entry
  656. #define PARTITION_HUGE                  0x06      // Huge partition MS-DOS V4
  657. #define PARTITION_IFS                   0x07      // IFS Partition
  658. #define PARTITION_OS2BOOTMGR            0x0A      // OS/2 Boot Manager/OPUS/Coherent swap
  659. #define PARTITION_FAT32                 0x0B      // FAT32
  660. #define PARTITION_FAT32_XINT13          0x0C      // FAT32 using extended int13 services
  661. #define PARTITION_XINT13                0x0E      // Win95 partition using extended int13 services
  662. #define PARTITION_XINT13_EXTENDED       0x0F      // Same as type 5 but uses extended int13 services
  663. #define PARTITION_PREP                  0x41      // PowerPC Reference Platform (PReP) Boot Partition
  664. #define PARTITION_LDM                   0x42      // Logical Disk Manager partition
  665. #define PARTITION_UNIX                  0x63      // Unix
  667. #define VALID_NTFT                      0xC0      // NTFT uses high order bits
  669. //
  670. // The high bit of the partition type code indicates that a partition
  671. // is part of an NTFT mirror or striped array.
  672. //
  674. #define PARTITION_NTFT                  0x80     // NTFT partition
  676. //
  677. // The following macro is used to determine which partitions should be
  678. // assigned drive letters.
  679. //
  681. //++
  682. //
  683. // BOOLEAN
  684. // IsRecognizedPartition(
  685. //     IN DWORD PartitionType
  686. //     )
  687. //
  688. // Routine Description:
  689. //
  690. //     This macro is used to determine to which partitions drive letters
  691. //     should be assigned.
  692. //
  693. // Arguments:
  694. //
  695. //     PartitionType - Supplies the type of the partition being examined.
  696. //
  697. // Return Value:
  698. //
  699. //     The return value is TRUE if the partition type is recognized,
  700. //     otherwise FALSE is returned.
  701. //
  702. //--
  704. #define IsRecognizedPartition( PartitionType ) (    
  705.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT_12)) ||  
  706.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_IFS)) ||  
  707.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_HUGE)) ||  
  708.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32)) ||  
  709.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_FAT32_XINT13)) ||  
  710.      ((PartitionType & PARTITION_NTFT) && ((PartitionType & ~0xC0) == PARTITION_XINT13)) ||  
  711.      ((PartitionType) == PARTITION_FAT_12)          ||  
  712.      ((PartitionType) == PARTITION_FAT_16)          ||  
  713.      ((PartitionType) == PARTITION_IFS)             ||  
  714.      ((PartitionType) == PARTITION_HUGE)            ||  
  715.      ((PartitionType) == PARTITION_FAT32)           ||  
  716.      ((PartitionType) == PARTITION_FAT32_XINT13)    ||  
  717.      ((PartitionType) == PARTITION_XINT13) )
  719. //++
  720. //
  721. // BOOLEAN
  722. // IsContainerPartition(
  723. //     IN DWORD PartitionType
  724. //     )
  725. //
  726. // Routine Description:
  727. //
  728. //     This macro is used to determine to which partition types are actually
  729. //     containers for other partitions (ie, extended partitions).
  730. //
  731. // Arguments:
  732. //
  733. //     PartitionType - Supplies the type of the partition being examined.
  734. //
  735. // Return Value:
  736. //
  737. //     The return value is TRUE if the partition type is a container,
  738. //     otherwise FALSE is returned.
  739. //
  740. //--
  742. #define IsContainerPartition( PartitionType ) 
  743.     ((PartitionType == PARTITION_EXTENDED) || (PartitionType == PARTITION_XINT13_EXTENDED))
  745. //++
  746. //
  747. // BOOLEAN
  748. // IsFTPartition(
  749. //     IN DWORD PartitionType
  750. //     )
  751. //
  752. // Routine Description:
  753. //
  754. //     This macro is used to determine if the given partition is an FT
  755. //     partition.
  756. //
  757. // Arguments:
  758. //
  759. //     PartitionType - Supplies the type of the partition being examined.
  760. //
  761. // Return Value:
  762. //
  763. //     The return value is TRUE if the partition type is an FT partition,
  764. //     otherwise FALSE is returned.
  765. //
  766. //--
  768. #define IsFTPartition( PartitionType ) 
  769.     (((PartitionType)&PARTITION_NTFT) && IsRecognizedPartition(PartitionType))
  771. //
  772. // Define the media types supported by the driver.
  773. //
  775. typedef enum _MEDIA_TYPE {
  776.     Unknown,                // Format is unknown
  777.     F5_1Pt2_512,            // 5.25", 1.2MB,  512 bytes/sector
  778.     F3_1Pt44_512,           // 3.5",  1.44MB, 512 bytes/sector
  779.     F3_2Pt88_512,           // 3.5",  2.88MB, 512 bytes/sector
  780.     F3_20Pt8_512,           // 3.5",  20.8MB, 512 bytes/sector
  781.     F3_720_512,             // 3.5",  720KB,  512 bytes/sector
  782.     F5_360_512,             // 5.25", 360KB,  512 bytes/sector
  783.     F5_320_512,             // 5.25", 320KB,  512 bytes/sector
  784.     F5_320_1024,            // 5.25", 320KB,  1024 bytes/sector
  785.     F5_180_512,             // 5.25", 180KB,  512 bytes/sector
  786.     F5_160_512,             // 5.25", 160KB,  512 bytes/sector
  787.     RemovableMedia,         // Removable media other than floppy
  788.     FixedMedia,             // Fixed hard disk media
  789.     F3_120M_512,            // 3.5", 120M Floppy
  790.     F3_640_512,             // 3.5" ,  640KB,  512 bytes/sector
  791.     F5_640_512,             // 5.25",  640KB,  512 bytes/sector
  792.     F5_720_512,             // 5.25",  720KB,  512 bytes/sector
  793.     F3_1Pt2_512,            // 3.5" ,  1.2Mb,  512 bytes/sector
  794.     F3_1Pt23_1024,          // 3.5" ,  1.23Mb, 1024 bytes/sector
  795.     F5_1Pt23_1024,          // 5.25",  1.23MB, 1024 bytes/sector
  796.     F3_128Mb_512,           // 3.5" MO 128Mb   512 bytes/sector
  797.     F3_230Mb_512,           // 3.5" MO 230Mb   512 bytes/sector
  798.     F8_256_128,             // 8",     256KB,  128 bytes/sector
  799.     F3_200Mb_512,           // 3.5",   200M Floppy (HiFD)
  800.     F3_240M_512,            // 3.5",   240Mb Floppy (HiFD)
  801.     F3_32M_512              // 3.5",   32Mb Floppy
  802. } MEDIA_TYPE, *PMEDIA_TYPE;
  804. //
  805. // Define the input buffer structure for the driver, when
  806. // it is called with IOCTL_DISK_FORMAT_TRACKS.
  807. //
  809. typedef struct _FORMAT_PARAMETERS {
  810.    MEDIA_TYPE MediaType;
  811.    DWORD StartCylinderNumber;
  812.    DWORD EndCylinderNumber;
  813.    DWORD StartHeadNumber;
  814.    DWORD EndHeadNumber;
  815. } FORMAT_PARAMETERS, *PFORMAT_PARAMETERS;
  817. //
  818. // Define the BAD_TRACK_NUMBER type. An array of elements of this type is
  819. // returned by the driver on IOCTL_DISK_FORMAT_TRACKS requests, to indicate
  820. // what tracks were bad during formatting. The length of that array is
  821. // reported in the `Information' field of the I/O Status Block.
  822. //
  824. typedef WORD   BAD_TRACK_NUMBER;
  825. typedef WORD   *PBAD_TRACK_NUMBER;
  827. //
  828. // Define the input buffer structure for the driver, when
  829. // it is called with IOCTL_DISK_FORMAT_TRACKS_EX.
  830. //
  832. typedef struct _FORMAT_EX_PARAMETERS {
  833.    MEDIA_TYPE MediaType;
  834.    DWORD StartCylinderNumber;
  835.    DWORD EndCylinderNumber;
  836.    DWORD StartHeadNumber;
  837.    DWORD EndHeadNumber;
  838.    WORD   FormatGapLength;
  839.    WORD   SectorsPerTrack;
  840.    WORD   SectorNumber[1];
  841. } FORMAT_EX_PARAMETERS, *PFORMAT_EX_PARAMETERS;
  843. //
  844. // The following structure is returned on an IOCTL_DISK_GET_DRIVE_GEOMETRY
  845. // request and an array of them is returned on an IOCTL_DISK_GET_MEDIA_TYPES
  846. // request.
  847. //
  849. typedef struct _DISK_GEOMETRY {
  850.     LARGE_INTEGER Cylinders;
  851.     MEDIA_TYPE MediaType;
  852.     DWORD TracksPerCylinder;
  853.     DWORD SectorsPerTrack;
  854.     DWORD BytesPerSector;
  855. } DISK_GEOMETRY, *PDISK_GEOMETRY;
  859. //
  860. // This wmi guid returns a DISK_GEOMETRY structure
  861. //
  862. #define WMI_DISK_GEOMETRY_GUID         { 0x25007f51, 0x57c2, 0x11d1, { 0xa5, 0x28, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0x10 } }
  866. //
  867. // The following structure is returned on an IOCTL_DISK_GET_PARTITION_INFO
  868. // and an IOCTL_DISK_GET_DRIVE_LAYOUT request.  It is also used in a request
  869. // to change the drive layout, IOCTL_DISK_SET_DRIVE_LAYOUT.
  870. //
  872. typedef struct _PARTITION_INFORMATION {
  873.     LARGE_INTEGER StartingOffset;
  874.     LARGE_INTEGER PartitionLength;
  875.     DWORD HiddenSectors;
  876.     DWORD PartitionNumber;
  877.     BYTE  PartitionType;
  878.     BOOLEAN BootIndicator;
  879.     BOOLEAN RecognizedPartition;
  880.     BOOLEAN RewritePartition;
  881. } PARTITION_INFORMATION, *PPARTITION_INFORMATION;
  883. //
  884. // The following structure is used to change the partition type of a
  885. // specified disk partition using an IOCTL_DISK_SET_PARTITION_INFO
  886. // request.
  887. //
  889. typedef struct _SET_PARTITION_INFORMATION {
  890.     BYTE  PartitionType;
  891. } SET_PARTITION_INFORMATION, *PSET_PARTITION_INFORMATION;
  893. //
  894. // The following structures is returned on an IOCTL_DISK_GET_DRIVE_LAYOUT
  895. // request and given as input to an IOCTL_DISK_SET_DRIVE_LAYOUT request.
  896. //
  898. typedef struct _DRIVE_LAYOUT_INFORMATION {
  899.     DWORD PartitionCount;
  900.     DWORD Signature;
  901.     PARTITION_INFORMATION PartitionEntry[1];
  902. } DRIVE_LAYOUT_INFORMATION, *PDRIVE_LAYOUT_INFORMATION;
  904. //
  905. // The following structure is passed in on an IOCTL_DISK_VERIFY request.
  906. // The offset and length parameters are both given in bytes.
  907. //
  909. typedef struct _VERIFY_INFORMATION {
  910.     LARGE_INTEGER StartingOffset;
  911.     DWORD Length;
  912. } VERIFY_INFORMATION, *PVERIFY_INFORMATION;
  914. //
  915. // The following structure is passed in on an IOCTL_DISK_REASSIGN_BLOCKS
  916. // request.
  917. //
  919. typedef struct _REASSIGN_BLOCKS {
  920.     WORD   Reserved;
  921.     WORD   Count;
  922.     DWORD BlockNumber[1];
  923. } REASSIGN_BLOCKS, *PREASSIGN_BLOCKS;
  926. #if(_WIN32_WINNT >= 0x500)
  928. //
  929. // Support for GUID Partition Table (GPT) disks.
  930. //
  932. //
  933. // There are currently two ways a disk can be partitioned. With a traditional
  934. // AT-style master boot record (PARTITION_STYLE_MBR) and with a new, GPT
  935. // partition table (PARTITION_STYLE_GPT). RAW is for an unrecognizable
  936. // partition style. There are a very limited number of things you can
  937. // do with a RAW partititon.
  938. //
  940. typedef enum _PARTITION_STYLE {
  941.     PARTITION_STYLE_MBR,
  942.     PARTITION_STYLE_GPT,
  943.     PARTITION_STYLE_RAW
  944. } PARTITION_STYLE;
  947. //
  948. // The following structure defines information in a GPT partition that is
  949. // not common to both GPT and MBR partitions.
  950. //
  952. typedef struct _PARTITION_INFORMATION_GPT {
  953.     GUID PartitionType;                 // Partition type. See table 16-3.
  954.     GUID PartitionId;                   // Unique GUID for this partition.
  955.     DWORD64 Attributes;                 // See table 16-4.
  956.     WCHAR Name [36];                    // Partition Name in Unicode.
  957. } PARTITION_INFORMATION_GPT, *PPARTITION_INFORMATION_GPT;
  959. //
  960. //  The following are GPT partition attributes applicable for any
  961. //  partition type. These attributes are not OS-specific
  962. //
  964. #define GPT_ATTRIBUTE_PLATFORM_REQUIRED             (0x0000000000000001)
  966. //
  967. // The following are GPT partition attributes applicable when the
  968. // PartitionType is PARTITION_BASIC_DATA_GUID.
  969. //
  971. #define GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER    (0x8000000000000000)
  972. #define GPT_BASIC_DATA_ATTRIBUTE_HIDDEN             (0x4000000000000000)
  973. #define GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY          (0x1000000000000000)
  975. //
  976. // The following structure defines information in an MBR partition that is not
  977. // common to both GPT and MBR partitions.
  978. //
  980. typedef struct _PARTITION_INFORMATION_MBR {
  981.     BYTE  PartitionType;
  982.     BOOLEAN BootIndicator;
  983.     BOOLEAN RecognizedPartition;
  984.     DWORD HiddenSectors;
  985. } PARTITION_INFORMATION_MBR, *PPARTITION_INFORMATION_MBR;
  988. //
  989. // The structure SET_PARTITION_INFO_EX is used with the ioctl
  990. // IOCTL_SET_PARTITION_INFO_EX to set information about a specific
  991. // partition. Note that for MBR partitions, you can only set the partition
  992. // signature, whereas GPT partitions allow setting of all fields that
  993. // you can get.
  994. //
  996. typedef SET_PARTITION_INFORMATION SET_PARTITION_INFORMATION_MBR;
  997. typedef PARTITION_INFORMATION_GPT SET_PARTITION_INFORMATION_GPT;
  1000. typedef struct _SET_PARTITION_INFORMATION_EX {
  1001.     PARTITION_STYLE PartitionStyle;
  1002.     union {
  1003.         SET_PARTITION_INFORMATION_MBR Mbr;
  1004.         SET_PARTITION_INFORMATION_GPT Gpt;
  1005.     };
  1006. } SET_PARTITION_INFORMATION_EX, *PSET_PARTITION_INFORMATION_EX;
  1009. //
  1010. // The structure CREATE_DISK_GPT with the ioctl IOCTL_DISK_CREATE_DISK
  1011. // to initialize an virgin disk with an empty GPT partition table.
  1012. //
  1014. typedef struct _CREATE_DISK_GPT {
  1015.     GUID DiskId;                    // Unique disk id for the disk.
  1016.     DWORD MaxPartitionCount;        // Maximim number of partitions allowable.
  1017. } CREATE_DISK_GPT, *PCREATE_DISK_GPT;
  1019. //
  1020. // The structure CREATE_DISK_MBR with the ioctl IOCTL_DISK_CREATE_DISK
  1021. // to initialize an virgin disk with an empty MBR partition table.
  1022. //
  1024. typedef struct _CREATE_DISK_MBR {
  1025.     DWORD Signature;
  1026. } CREATE_DISK_MBR, *PCREATE_DISK_MBR;
  1029. typedef struct _CREATE_DISK {
  1030.     PARTITION_STYLE PartitionStyle;
  1031.     union {
  1032.         CREATE_DISK_MBR Mbr;
  1033.         CREATE_DISK_GPT Gpt;
  1034.     };
  1035. } CREATE_DISK, *PCREATE_DISK;
  1038. //
  1039. // The structure GET_LENGTH_INFORMATION is used with the ioctl
  1040. // IOCTL_DISK_GET_LENGTH_INFO to obtain the length, in bytes, of the
  1041. // disk, partition, or volume.
  1042. //
  1044. typedef struct _GET_LENGTH_INFORMATION {
  1045.     LARGE_INTEGER   Length;
  1046. } GET_LENGTH_INFORMATION, *PGET_LENGTH_INFORMATION;
  1048. //
  1049. // The PARTITION_INFORMATION_EX structure is used with the
  1050. // IOCTL_DISK_GET_DRIVE_LAYOUT_EX, IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
  1051. // IOCTL_DISK_GET_PARTITION_INFO_EX and IOCTL_DISK_GET_PARTITION_INFO_EX calls.
  1052. //
  1054. typedef struct _PARTITION_INFORMATION_EX {
  1055.     PARTITION_STYLE PartitionStyle;
  1056.     LARGE_INTEGER StartingOffset;
  1057.     LARGE_INTEGER PartitionLength;
  1058.     DWORD PartitionNumber;
  1059.     BOOLEAN RewritePartition;
  1060.     union {
  1061.         PARTITION_INFORMATION_MBR Mbr;
  1062.         PARTITION_INFORMATION_GPT Gpt;
  1063.     };
  1064. } PARTITION_INFORMATION_EX, *PPARTITION_INFORMATION_EX;
  1067. //
  1068. // GPT specific drive layout information.
  1069. //
  1071. typedef struct _DRIVE_LAYOUT_INFORMATION_GPT {
  1072.     GUID DiskId;
  1073.     LARGE_INTEGER StartingUsableOffset;
  1074.     LARGE_INTEGER UsableLength;
  1075.     DWORD MaxPartitionCount;
  1076. } DRIVE_LAYOUT_INFORMATION_GPT, *PDRIVE_LAYOUT_INFORMATION_GPT;
  1079. //
  1080. // MBR specific drive layout information.
  1081. //
  1083. typedef struct _DRIVE_LAYOUT_INFORMATION_MBR {
  1084.     DWORD Signature;
  1085. } DRIVE_LAYOUT_INFORMATION_MBR, *PDRIVE_LAYOUT_INFORMATION_MBR;
  1087. //
  1088. // The structure DRIVE_LAYOUT_INFORMATION_EX is used with the
  1089. // IOCTL_SET_DRIVE_LAYOUT_EX and IOCTL_GET_DRIVE_LAYOUT_EX calls.
  1090. //
  1092. typedef struct _DRIVE_LAYOUT_INFORMATION_EX {
  1093.     DWORD PartitionStyle;
  1094.     DWORD PartitionCount;
  1095.     union {
  1096.         DRIVE_LAYOUT_INFORMATION_MBR Mbr;
  1097.         DRIVE_LAYOUT_INFORMATION_GPT Gpt;
  1098.     };
  1099.     PARTITION_INFORMATION_EX PartitionEntry[1];
  1100. } DRIVE_LAYOUT_INFORMATION_EX, *PDRIVE_LAYOUT_INFORMATION_EX;
  1103. #endif // (_WIN32_WINNT >= 0x0500)
  1106. #if(_WIN32_WINNT >= 0x0500)
  1108. //
  1109. // The DISK_GEOMETRY_EX structure is returned on issuing an
  1110. // IOCTL_DISK_GET_DRIVE_GEOMETRY_EX ioctl.
  1111. //
  1113. typedef enum _DETECTION_TYPE {
  1114.         DetectNone,
  1115.         DetectInt13,
  1116.         DetectExInt13
  1117. } DETECTION_TYPE;
  1119. typedef struct _DISK_INT13_INFO {
  1120.         WORD   DriveSelect;
  1121.         DWORD MaxCylinders;
  1122.         WORD   SectorsPerTrack;
  1123.         WORD   MaxHeads;
  1124.         WORD   NumberDrives;
  1125. } DISK_INT13_INFO, *PDISK_INT13_INFO;
  1127. typedef struct _DISK_EX_INT13_INFO {
  1128.         WORD   ExBufferSize;
  1129.         WORD   ExFlags;
  1130.         DWORD ExCylinders;
  1131.         DWORD ExHeads;
  1132.         DWORD ExSectorsPerTrack;
  1133.         DWORD64 ExSectorsPerDrive;
  1134.         WORD   ExSectorSize;
  1135.         WORD   ExReserved;
  1136. } DISK_EX_INT13_INFO, *PDISK_EX_INT13_INFO;
  1138. typedef struct _DISK_DETECTION_INFO {
  1139.         DWORD SizeOfDetectInfo;
  1140.         DETECTION_TYPE DetectionType;
  1141.         union {
  1142.                 struct {
  1144.                         //
  1145.                         // If DetectionType == DETECTION_INT13 then we have just the Int13
  1146.                         // information.
  1147.                         //
  1149.                         DISK_INT13_INFO Int13;
  1151.                         //
  1152.                         // If DetectionType == DETECTION_EX_INT13, then we have the
  1153.                         // extended int 13 information.
  1154.                         //
  1156.                         DISK_EX_INT13_INFO ExInt13;     // If DetectionType == DetectExInt13
  1157.                 };
  1158.         };
  1159. } DISK_DETECTION_INFO, *PDISK_DETECTION_INFO;
  1162. typedef struct _DISK_PARTITION_INFO {
  1163.         DWORD SizeOfPartitionInfo;
  1164.         PARTITION_STYLE PartitionStyle;                 // PartitionStyle = RAW, GPT or MBR
  1165.         union {
  1166.                 struct {                                                        // If PartitionStyle == MBR
  1167.                         DWORD Signature;                                // MBR Signature
  1168.                         DWORD CheckSum;                                 // MBR CheckSum
  1169.                 } Mbr;
  1170.                 struct {                                                        // If PartitionStyle == GPT
  1171.                         GUID DiskId;
  1172.                 } Gpt;
  1173.         };
  1174. } DISK_PARTITION_INFO, *PDISK_PARTITION_INFO;
  1177. //
  1178. // The Geometry structure is a variable length structure composed of a
  1179. // DISK_GEOMETRY_EX structure followed by a DISK_PARTITION_INFO structure
  1180. // followed by a DISK_DETECTION_DATA structure.
  1181. //
  1183. #define DiskGeometryGetPartition(Geometry)
  1184.                         ((PDISK_PARTITION_INFO)((Geometry)+1))
  1186. #define DiskGeometryGetDetect(Geometry)
  1187.                         ((PDISK_DETECTION_INFO)(((PBYTE)DiskGeometryGetPartition(Geometry)+
  1188.                                         DiskGeometryGetPartition(Geometry)->SizeOfPartitionInfo)))
  1190. typedef struct _DISK_GEOMETRY_EX {
  1191.         DISK_GEOMETRY Geometry;                                 // Standard disk geometry: may be faked by driver.
  1192.         LARGE_INTEGER DiskSize;                                 // Must always be correct
  1193.         BYTE  Data[1];                                                  // Partition, Detect info
  1194. } DISK_GEOMETRY_EX, *PDISK_GEOMETRY_EX;
  1196. #endif // (_WIN32_WINNT > 0x0500)
  1198. #if(_WIN32_WINNT >= 0x0400)
  1199. //
  1200. // IOCTL_DISK_CONTROLLER_NUMBER returns the controller and disk
  1201. // number for the handle.  This is used to determine if a disk
  1202. // is attached to the primary or secondary IDE controller.
  1203. //
  1205. typedef struct _DISK_CONTROLLER_NUMBER {
  1206.     DWORD ControllerNumber;
  1207.     DWORD DiskNumber;
  1208. } DISK_CONTROLLER_NUMBER, *PDISK_CONTROLLER_NUMBER;
  1209. #endif /* _WIN32_WINNT >= 0x0400 */
  1211. #if(_WIN32_WINNT >= 0x0500)
  1214. //
  1215. // IOCTL_DISK_SET_CACHE allows the caller to get or set the state of the disk
  1216. // read/write caches.
  1217. //
  1218. // If the structure is provided as the input buffer for the ioctl the read &
  1219. // write caches will be enabled or disabled depending on the parameters
  1220. // provided.
  1221. //
  1222. // If the structure is provided as an output buffer for the ioctl the state
  1223. // of the read & write caches will be returned. If both input and outut buffers
  1224. // are provided the output buffer will contain the cache state BEFORE any
  1225. // changes are made
  1226. //
  1228. typedef enum {
  1229.     EqualPriority,
  1230.     KeepPrefetchedData,
  1231.     KeepReadData
  1232. } DISK_CACHE_RETENTION_PRIORITY;
  1234. typedef enum _DISK_WRITE_CACHE_STATE {
  1235.     DiskWriteCacheNormal,
  1236.     DiskWriteCacheForceDisable,
  1237.     DiskWriteCacheDisableNotSupported
  1238. } DISK_WRITE_CACHE_STATE, *PDISK_WRITE_CACHE_STATE;
  1241. typedef struct _DISK_CACHE_INFORMATION {
  1243.     //
  1244.     // on return indicates that the device is capable of saving any parameters
  1245.     // in non-volatile storage.  On send indicates that the device should
  1246.     // save the state in non-volatile storage.
  1247.     //
  1249.     BOOLEAN ParametersSavable;
  1251.     //
  1252.     // Indicates whether the write and read caches are enabled.
  1253.     //
  1255.     BOOLEAN ReadCacheEnabled;
  1256.     BOOLEAN WriteCacheEnabled;
  1258.     //
  1259.     // Controls the likelyhood of data remaining in the cache depending on how
  1260.     // it got there.  Data cached from a READ or WRITE operation may be given
  1261.     // higher, lower or equal priority to data entered into the cache for other
  1262.     // means (like prefetch)
  1263.     //
  1265.     DISK_CACHE_RETENTION_PRIORITY ReadRetentionPriority;
  1266.     DISK_CACHE_RETENTION_PRIORITY WriteRetentionPriority;
  1268.     //
  1269.     // Requests for a larger number of blocks than this may have prefetching
  1270.     // disabled.  If this value is set to 0 prefetch will be disabled.
  1271.     //
  1273.     WORD   DisablePrefetchTransferLength;
  1275.     //
  1276.     // If TRUE then ScalarPrefetch (below) will be valid.  If FALSE then
  1277.     // the minimum and maximum values should be treated as a block count
  1278.     // (BlockPrefetch)
  1279.     //
  1281.     BOOLEAN PrefetchScalar;
  1283.     //
  1284.     // Contains the minimum and maximum amount of data which will be
  1285.     // will be prefetched into the cache on a disk operation.  This value
  1286.     // may either be a scalar multiplier of the transfer length of the request,
  1287.     // or an abolute number of disk blocks.  PrefetchScalar (above) indicates
  1288.     // which interpretation is used.
  1289.     //
  1291.     union {
  1292.         struct {
  1293.             WORD   Minimum;
  1294.             WORD   Maximum;
  1296.             //
  1297.             // The maximum number of blocks which will be prefetched - useful
  1298.             // with the scalar limits to set definite upper limits.
  1299.             //
  1301.             WORD   MaximumBlocks;
  1302.         } ScalarPrefetch;
  1304.         struct {
  1305.             WORD   Minimum;
  1306.             WORD   Maximum;
  1307.         } BlockPrefetch;
  1308.     };
  1310. } DISK_CACHE_INFORMATION, *PDISK_CACHE_INFORMATION;
  1312. //
  1313. // IOCTL_DISK_GROW_PARTITION will update the size of a partition
  1314. // by adding sectors to the length. The number of sectors must be
  1315. // predetermined by examining PARTITION_INFORMATION.
  1316. //
  1318. typedef struct _DISK_GROW_PARTITION {
  1319.     DWORD PartitionNumber;
  1320.     LARGE_INTEGER BytesToGrow;
  1321. } DISK_GROW_PARTITION, *PDISK_GROW_PARTITION;
  1322. #endif /* _WIN32_WINNT >= 0x0500 */
  1324. ///////////////////////////////////////////////////////
  1325. //                                                   //
  1326. // The following structures define disk performance  //
  1327. // statistics: specifically the locations of all the //
  1328. // reads and writes which have occured on the disk.  //
  1329. //                                                   //
  1330. // To use these structures, you must issue an IOCTL_ //
  1331. // DISK_HIST_STRUCTURE (with a DISK_HISTOGRAM) to    //
  1332. // obtain the basic histogram information. The       //
  1333. // number of buckets which must allocated is part of //
  1334. // this structure. Allocate the required number of   //
  1335. // buckets and call an IOCTL_DISK_HIST_DATA to fill  //
  1336. // in the data                                       //
  1337. //                                                   //
  1338. ///////////////////////////////////////////////////////
  1340. #define HIST_NO_OF_BUCKETS  24
  1342. typedef struct _HISTOGRAM_BUCKET {
  1343.     DWORD       Reads;
  1344.     DWORD       Writes;
  1345. } HISTOGRAM_BUCKET, *PHISTOGRAM_BUCKET;
  1347. #define HISTOGRAM_BUCKET_SIZE   sizeof(HISTOGRAM_BUCKET)
  1349. typedef struct _DISK_HISTOGRAM {
  1350.     LARGE_INTEGER   DiskSize;
  1351.     LARGE_INTEGER   Start;
  1352.     LARGE_INTEGER   End;
  1353.     LARGE_INTEGER   Average;
  1354.     LARGE_INTEGER   AverageRead;
  1355.     LARGE_INTEGER   AverageWrite;
  1356.     DWORD           Granularity;
  1357.     DWORD           Size;
  1358.     DWORD           ReadCount;
  1359.     DWORD           WriteCount;
  1360.     PHISTOGRAM_BUCKET  Histogram;
  1361. } DISK_HISTOGRAM, *PDISK_HISTOGRAM;
  1363. #define DISK_HISTOGRAM_SIZE sizeof(DISK_HISTOGRAM)
  1365. ///////////////////////////////////////////////////////
  1366. //                                                   //
  1367. // The following structures define disk debugging    //
  1368. // capabilities. The IOCTLs are directed to one of   //
  1369. // the two disk filter drivers.                      //
  1370. //                                                   //
  1371. // DISKPERF is a utilty for collecting disk request  //
  1372. // statistics.                                       //
  1373. //                                                   //
  1374. // SIMBAD is a utility for injecting faults in       //
  1375. // IO requests to disks.                             //
  1376. //                                                   //
  1377. ///////////////////////////////////////////////////////
  1379. //
  1380. // The following structure is exchanged on an IOCTL_DISK_GET_PERFORMANCE
  1381. // request. This ioctl collects summary disk request statistics used
  1382. // in measuring performance.
  1383. //
  1385. typedef struct _DISK_PERFORMANCE {
  1386.         LARGE_INTEGER BytesRead;
  1387.         LARGE_INTEGER BytesWritten;
  1388.         LARGE_INTEGER ReadTime;
  1389.         LARGE_INTEGER WriteTime;
  1390.         LARGE_INTEGER IdleTime;
  1391.         DWORD ReadCount;
  1392.         DWORD WriteCount;
  1393.         DWORD QueueDepth;
  1394.         DWORD SplitCount;
  1395.         LARGE_INTEGER QueryTime;
  1396.         DWORD   StorageDeviceNumber;
  1397.         WCHAR   StorageManagerName[8];
  1398. } DISK_PERFORMANCE, *PDISK_PERFORMANCE;
  1400. //
  1401. // This structure defines the disk logging record. When disk logging
  1402. // is enabled, one of these is written to an internal buffer for each
  1403. // disk request.
  1404. //
  1406. typedef struct _DISK_RECORD {
  1407.    LARGE_INTEGER ByteOffset;
  1408.    LARGE_INTEGER StartTime;
  1409.    LARGE_INTEGER EndTime;
  1410.    PVOID VirtualAddress;
  1411.    DWORD NumberOfBytes;
  1412.    BYTE  DeviceNumber;
  1413.    BOOLEAN ReadRequest;
  1414. } DISK_RECORD, *PDISK_RECORD;
  1416. //
  1417. // The following structure is exchanged on an IOCTL_DISK_LOG request.
  1418. // Not all fields are valid with each function type.
  1419. //
  1421. typedef struct _DISK_LOGGING {
  1422.     BYTE  Function;
  1423.     PVOID BufferAddress;
  1424.     DWORD BufferSize;
  1425. } DISK_LOGGING, *PDISK_LOGGING;
  1427. //
  1428. // Disk logging functions
  1429. //
  1430. // Start disk logging. Only the Function and BufferSize fields are valid.
  1431. //
  1433. #define DISK_LOGGING_START    0
  1435. //
  1436. // Stop disk logging. Only the Function field is valid.
  1437. //
  1439. #define DISK_LOGGING_STOP     1
  1441. //
  1442. // Return disk log. All fields are valid. Data will be copied from internal
  1443. // buffer to buffer specified for the number of bytes requested.
  1444. //
  1446. #define DISK_LOGGING_DUMP     2
  1448. //
  1449. // DISK BINNING
  1450. //
  1451. // DISKPERF will keep counters for IO that falls in each of these ranges.
  1452. // The application determines the number and size of the ranges.
  1453. // Joe Lin wanted me to keep it flexible as possible, for instance, IO
  1454. // sizes are interesting in ranges like 0-4096, 4097-16384, 16385-65536, 65537+.
  1455. //
  1457. #define DISK_BINNING          3
  1459. //
  1460. // Bin types
  1461. //
  1463. typedef enum _BIN_TYPES {
  1464.     RequestSize,
  1465.     RequestLocation
  1466. } BIN_TYPES;
  1468. //
  1469. // Bin ranges
  1470. //
  1472. typedef struct _BIN_RANGE {
  1473.     LARGE_INTEGER StartValue;
  1474.     LARGE_INTEGER Length;
  1475. } BIN_RANGE, *PBIN_RANGE;
  1477. //
  1478. // Bin definition
  1479. //
  1481. typedef struct _PERF_BIN {
  1482.     DWORD NumberOfBins;
  1483.     DWORD TypeOfBin;
  1484.     BIN_RANGE BinsRanges[1];
  1485. } PERF_BIN, *PPERF_BIN ;
  1487. //
  1488. // Bin count
  1489. //
  1491. typedef struct _BIN_COUNT {
  1492.     BIN_RANGE BinRange;
  1493.     DWORD BinCount;
  1494. } BIN_COUNT, *PBIN_COUNT;
  1496. //
  1497. // Bin results
  1498. //
  1500. typedef struct _BIN_RESULTS {
  1501.     DWORD NumberOfBins;
  1502.     BIN_COUNT BinCounts[1];
  1503. } BIN_RESULTS, *PBIN_RESULTS;
  1505. #if(_WIN32_WINNT >= 0x0400)
  1506. //
  1507. // Data structures for SMART drive fault prediction.
  1508. //
  1509. // GETVERSIONINPARAMS contains the data returned from the
  1510. // Get Driver Version function.
  1511. //
  1513. #include <pshpack1.h>
  1514. typedef struct _GETVERSIONINPARAMS {
  1515.         BYTE     bVersion;               // Binary driver version.
  1516.         BYTE     bRevision;              // Binary driver revision.
  1517.         BYTE     bReserved;              // Not used.
  1518.         BYTE     bIDEDeviceMap;          // Bit map of IDE devices.
  1519.         DWORD   fCapabilities;          // Bit mask of driver capabilities.
  1520.         DWORD   dwReserved[4];          // For future use.
  1521. } GETVERSIONINPARAMS, *PGETVERSIONINPARAMS, *LPGETVERSIONINPARAMS;
  1522. #include <poppack.h>
  1524. //
  1525. // Bits returned in the fCapabilities member of GETVERSIONINPARAMS
  1526. //
  1528. #define CAP_ATA_ID_CMD          1       // ATA ID command supported
  1529. #define CAP_ATAPI_ID_CMD        2       // ATAPI ID command supported
  1530. #define CAP_SMART_CMD           4       // SMART commannds supported
  1532. //
  1533. // IDE registers
  1534. //
  1536. #include <pshpack1.h>
  1537. typedef struct _IDEREGS {
  1538.         BYTE     bFeaturesReg;           // Used for specifying SMART "commands".
  1539.         BYTE     bSectorCountReg;        // IDE sector count register
  1540.         BYTE     bSectorNumberReg;       // IDE sector number register
  1541.         BYTE     bCylLowReg;             // IDE low order cylinder value
  1542.         BYTE     bCylHighReg;            // IDE high order cylinder value
  1543.         BYTE     bDriveHeadReg;          // IDE drive/head register
  1544.         BYTE     bCommandReg;            // Actual IDE command.
  1545.         BYTE     bReserved;                      // reserved for future use.  Must be zero.
  1546. } IDEREGS, *PIDEREGS, *LPIDEREGS;
  1547. #include <poppack.h>
  1549. //
  1550. // Valid values for the bCommandReg member of IDEREGS.
  1551. //
  1553. #define ATAPI_ID_CMD    0xA1            // Returns ID sector for ATAPI.
  1554. #define ID_CMD          0xEC            // Returns ID sector for ATA.
  1555. #define SMART_CMD       0xB0            // Performs SMART cmd.
  1556.                                         // Requires valid bFeaturesReg,
  1557.                                         // bCylLowReg, and bCylHighReg
  1559. //
  1560. // Cylinder register defines for SMART command
  1561. //
  1563. #define SMART_CYL_LOW   0x4F
  1564. #define SMART_CYL_HI    0xC2
  1567. //
  1568. // SENDCMDINPARAMS contains the input parameters for the
  1569. // Send Command to Drive function.
  1570. //
  1572. #include <pshpack1.h>
  1573. typedef struct _SENDCMDINPARAMS {
  1574.         DWORD   cBufferSize;            // Buffer size in bytes
  1575.         IDEREGS irDriveRegs;            // Structure with drive register values.
  1576.         BYTE     bDriveNumber;           // Physical drive number to send
  1577.                                                                 // command to (0,1,2,3).
  1578.         BYTE     bReserved[3];           // Reserved for future expansion.
  1579.         DWORD   dwReserved[4];          // For future use.
  1580.         BYTE     bBuffer[1];                     // Input buffer.
  1581. } SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
  1582. #include <poppack.h>
  1584. //
  1585. // Status returned from driver
  1586. //
  1588. #include <pshpack1.h>
  1589. typedef struct _DRIVERSTATUS {
  1590.         BYTE     bDriverError;           // Error code from driver,
  1591.                                                                 // or 0 if no error.
  1592.         BYTE     bIDEError;                      // Contents of IDE Error register.
  1593.                                                                 // Only valid when bDriverError
  1594.                                                                 // is SMART_IDE_ERROR.
  1595.         BYTE     bReserved[2];           // Reserved for future expansion.
  1596.         DWORD   dwReserved[2];          // Reserved for future expansion.
  1597. } DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
  1598. #include <poppack.h>
  1600. //
  1601. // bDriverError values
  1602. //
  1604. #define SMART_NO_ERROR          0       // No error
  1605. #define SMART_IDE_ERROR         1       // Error from IDE controller
  1606. #define SMART_INVALID_FLAG      2       // Invalid command flag
  1607. #define SMART_INVALID_COMMAND   3       // Invalid command byte
  1608. #define SMART_INVALID_BUFFER    4       // Bad buffer (null, invalid addr..)
  1609. #define SMART_INVALID_DRIVE     5       // Drive number not valid
  1610. #define SMART_INVALID_IOCTL     6       // Invalid IOCTL
  1611. #define SMART_ERROR_NO_MEM      7       // Could not lock user's buffer
  1612. #define SMART_INVALID_REGISTER  8       // Some IDE Register not valid
  1613. #define SMART_NOT_SUPPORTED     9       // Invalid cmd flag set
  1614. #define SMART_NO_IDE_DEVICE     10      // Cmd issued to device not present
  1615.                                         // although drive number is valid
  1616. //
  1617. // SMART sub commands for execute offline diags
  1618. //
  1619. #define SMART_OFFLINE_ROUTINE_OFFLINE       0
  1620. #define SMART_SHORT_SELFTEST_OFFLINE        1
  1621. #define SMART_EXTENDED_SELFTEST_OFFLINE     2
  1622. #define SMART_ABORT_OFFLINE_SELFTEST        127
  1623. #define SMART_SHORT_SELFTEST_CAPTIVE        129
  1624. #define SMART_EXTENDED_SELFTEST_CAPTIVE     130
  1627. #include <pshpack1.h>
  1628. typedef struct _SENDCMDOUTPARAMS {
  1629.         DWORD                   cBufferSize;            // Size of bBuffer in bytes
  1630.         DRIVERSTATUS            DriverStatus;           // Driver status structure.
  1631.         BYTE                    bBuffer[1];             // Buffer of arbitrary length in which to store the data read from the                                                                                  // drive.
  1632. } SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
  1633. #include <poppack.h>
  1636. #define READ_ATTRIBUTE_BUFFER_SIZE  512
  1637. #define IDENTIFY_BUFFER_SIZE        512
  1638. #define READ_THRESHOLD_BUFFER_SIZE  512
  1639. #define SMART_LOG_SECTOR_SIZE       512
  1641. //
  1642. // Feature register defines for SMART "sub commands"
  1643. //
  1645. #define READ_ATTRIBUTES         0xD0
  1646. #define READ_THRESHOLDS         0xD1
  1647. #define ENABLE_DISABLE_AUTOSAVE 0xD2
  1648. #define SAVE_ATTRIBUTE_VALUES   0xD3
  1649. #define EXECUTE_OFFLINE_DIAGS   0xD4
  1650. #define SMART_READ_LOG          0xD5
  1651. #define SMART_WRITE_LOG         0xd6
  1652. #define ENABLE_SMART            0xD8
  1653. #define DISABLE_SMART           0xD9
  1654. #define RETURN_SMART_STATUS     0xDA
  1655. #define ENABLE_DISABLE_AUTO_OFFLINE 0xDB
  1656. #endif /* _WIN32_WINNT >= 0x0400 */
  1660. #define IOCTL_CHANGER_BASE                FILE_DEVICE_CHANGER
  1662. #define IOCTL_CHANGER_GET_PARAMETERS         CTL_CODE(IOCTL_CHANGER_BASE, 0x0000, METHOD_BUFFERED, FILE_READ_ACCESS)
  1663. #define IOCTL_CHANGER_GET_STATUS             CTL_CODE(IOCTL_CHANGER_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
  1664. #define IOCTL_CHANGER_GET_PRODUCT_DATA       CTL_CODE(IOCTL_CHANGER_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS)
  1665. #define IOCTL_CHANGER_SET_ACCESS             CTL_CODE(IOCTL_CHANGER_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  1666. #define IOCTL_CHANGER_GET_ELEMENT_STATUS     CTL_CODE(IOCTL_CHANGER_BASE, 0x0005, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  1667. #define IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS  CTL_CODE(IOCTL_CHANGER_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS)
  1668. #define IOCTL_CHANGER_SET_POSITION           CTL_CODE(IOCTL_CHANGER_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS)
  1669. #define IOCTL_CHANGER_EXCHANGE_MEDIUM        CTL_CODE(IOCTL_CHANGER_BASE, 0x0008, METHOD_BUFFERED, FILE_READ_ACCESS)
  1670. #define IOCTL_CHANGER_MOVE_MEDIUM            CTL_CODE(IOCTL_CHANGER_BASE, 0x0009, METHOD_BUFFERED, FILE_READ_ACCESS)
  1671. #define IOCTL_CHANGER_REINITIALIZE_TRANSPORT CTL_CODE(IOCTL_CHANGER_BASE, 0x000A, METHOD_BUFFERED, FILE_READ_ACCESS)
  1672. #define IOCTL_CHANGER_QUERY_VOLUME_TAGS      CTL_CODE(IOCTL_CHANGER_BASE, 0x000B, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
  1676. #define MAX_VOLUME_ID_SIZE       36
  1677. #define MAX_VOLUME_TEMPLATE_SIZE 40
  1679. #define VENDOR_ID_LENGTH          8
  1680. #define PRODUCT_ID_LENGTH        16
  1681. #define REVISION_LENGTH           4
  1682. #define SERIAL_NUMBER_LENGTH     32
  1684. //
  1685. // Common structures describing elements.
  1686. //
  1688. typedef  enum _ELEMENT_TYPE {
  1689.     AllElements,        // As defined by SCSI
  1690.     ChangerTransport,   // As defined by SCSI
  1691.     ChangerSlot,        // As defined by SCSI
  1692.     ChangerIEPort,      // As defined by SCSI
  1693.     ChangerDrive,       // As defined by SCSI
  1694.     ChangerDoor,        // Front panel, used to access internal of cabinet.
  1695.     ChangerKeypad,      // Keypad/input on front panel.
  1696.     ChangerMaxElement   // Placeholder only. Not a valid type.
  1697. } ELEMENT_TYPE, *PELEMENT_TYPE;
  1699. typedef  struct _CHANGER_ELEMENT {
  1700.     ELEMENT_TYPE    ElementType;
  1701.     DWORD   ElementAddress;
  1702. } CHANGER_ELEMENT, *PCHANGER_ELEMENT;
  1704. typedef  struct _CHANGER_ELEMENT_LIST {
  1705.     CHANGER_ELEMENT Element;
  1706.     DWORD   NumberOfElements;
  1707. } CHANGER_ELEMENT_LIST , *PCHANGER_ELEMENT_LIST;
  1710. //
  1711. // Definitions for  IOCTL_CHANGER_GET_PARAMETERS
  1712. //
  1714. //
  1715. // Definitions for Features0 of GET_CHANGER_PARAMETERS
  1716. //
  1718. #define CHANGER_BAR_CODE_SCANNER_INSTALLED  0x00000001 // The medium-changer has a bar code scanner installed.
  1719. #define CHANGER_INIT_ELEM_STAT_WITH_RANGE   0x00000002 // The medium-changer has the ability to initialize elements within a specified range.
  1720. #define CHANGER_CLOSE_IEPORT                0x00000004 // The medium-changer has the ability to close the i/e port door.
  1721. #define CHANGER_OPEN_IEPORT                 0x00000008 // The medium-changer can open the i/e port door.
  1723. #define CHANGER_STATUS_NON_VOLATILE         0x00000010 // The medium-changer uses non-volatile memory for element status information.
  1724. #define CHANGER_EXCHANGE_MEDIA              0x00000020 // The medium-changer supports exchange operations.
  1725. #define CHANGER_CLEANER_SLOT                0x00000040 // The medium-changer has a fixed slot designated for cleaner cartridges.
  1726. #define CHANGER_LOCK_UNLOCK                 0x00000080 // The medium-changer can be (un)secured to (allow)prevent media removal.
  1728. #define CHANGER_CARTRIDGE_MAGAZINE          0x00000100 // The medium-changer uses cartridge magazines for some storage slots.
  1729. #define CHANGER_MEDIUM_FLIP                 0x00000200 // The medium-changer can flip medium.
  1730. #define CHANGER_POSITION_TO_ELEMENT         0x00000400 // The medium-changer can position the transport to a particular element.
  1731. #define CHANGER_REPORT_IEPORT_STATE         0x00000800 // The medium-changer can determine whether media is present
  1732.                                                        // in the IE Port.
  1734. #define CHANGER_STORAGE_DRIVE               0x00001000 // The medium-changer can use a drive as an independent storage element.
  1735. #define CHANGER_STORAGE_IEPORT              0x00002000 // The medium-changer can use a i/e port as an independent storage element.
  1736. #define CHANGER_STORAGE_SLOT                0x00004000 // The medium-changer can use a slot as an independent storage element.
  1737. #define CHANGER_STORAGE_TRANSPORT           0x00008000 // The medium-changer can use a transport as an independent storage element.
  1739. #define CHANGER_DRIVE_CLEANING_REQUIRED     0x00010000 // The drives controlled by the medium changer require periodic cleaning
  1740.                                                        // initiated by an application.
  1741. #define CHANGER_PREDISMOUNT_EJECT_REQUIRED  0x00020000 // The medium-changer requires a drive eject command to be issued, before a changer
  1742.                                                        // move / exchange command can be issued to the drive.
  1744. #define CHANGER_CLEANER_ACCESS_NOT_VALID    0x00040000 // The access bit in GES isn't valid for cleaner cartridges.
  1745. #define CHANGER_PREMOUNT_EJECT_REQUIRED     0x00080000 // The medium-changer requires a drive eject command to be issued
  1746.                                                        // before a move / exchange command can be issued with the drive as src/dst.
  1748. #define CHANGER_VOLUME_IDENTIFICATION       0x00100000 // The medium-changer supports volume identification.
  1749. #define CHANGER_VOLUME_SEARCH               0x00200000 // The medium-changer can search for volume information.
  1750. #define CHANGER_VOLUME_ASSERT               0x00400000 // The medium-changer can verify volume information.
  1751. #define CHANGER_VOLUME_REPLACE              0x00800000 // The medium-changer can replace volume information.
  1752. #define CHANGER_VOLUME_UNDEFINE             0x01000000 // The medium-changer can undefine volume information.
  1754. #define CHANGER_SERIAL_NUMBER_VALID         0x04000000 // The serial number reported in GetProductData is valid
  1755.                                                        // and unique.
  1757. #define CHANGER_DEVICE_REINITIALIZE_CAPABLE 0x08000000 // The medium-changer can be issued a ChangerReinitializeUnit.
  1758. #define CHANGER_KEYPAD_ENABLE_DISABLE       0x10000000 // Indicates that the keypad can be enabled/disabled.
  1759. #define CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS  0x20000000 // Drives must be empty before access via the door is possible.
  1761. #define CHANGER_RESERVED_BIT                0x80000000 // Will be used to indicate Features1 capability bits.
  1764. //
  1765. // Definitions for Features1 of GET_CHANGER_PARAMETERS
  1766. //
  1768. #define CHANGER_PREDISMOUNT_ALIGN_TO_SLOT   0x80000001 // The transport must be prepositioned to the slot prior to ejecting the media.
  1769. #define CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE  0x80000002 // The transport must be prepositioned to the drive prior to ejecting the media.
  1770. #define CHANGER_CLEANER_AUTODISMOUNT        0x80000004 // The device will move the cleaner cartridge back into the slot when cleaning has completed.
  1771. #define CHANGER_TRUE_EXCHANGE_CAPABLE       0x80000008 // Device can do src -> dest2 exchanges.
  1772. #define CHANGER_SLOTS_USE_TRAYS             0x80000010 // Slots have removable trays, requiring multiple moves for inject/eject.
  1773. #define CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR  0x80000020 // Media must be returned to the slot from which it originated after a move to another element.
  1774. #define CHANGER_CLEANER_OPS_NOT_SUPPORTED   0x80000040 // Automated cleaning operations are not supported on this device.
  1775. #define CHANGER_IEPORT_USER_CONTROL_OPEN    0x80000080 // Indicates that user action is necessary to open a closed ieport.
  1776. #define CHANGER_IEPORT_USER_CONTROL_CLOSE   0x80000100 // Indicates that user action is necessary to close an opened ieport.
  1777. #define CHANGER_MOVE_EXTENDS_IEPORT         0x80000200 // Indicates that a move media to the ieport extends the tray.
  1778. #define CHANGER_MOVE_RETRACTS_IEPORT        0x80000400 // Indicates that a move media from the ieport retracts the tray.
  1781. //
  1782. // Definitions for MoveFrom, ExchangeFrom, and PositionCapabilities
  1783. //
  1785. #define CHANGER_TO_TRANSPORT    0x01 // The device can carry out the operation to a transport from the specified element.
  1786. #define CHANGER_TO_SLOT         0x02 // The device can carry out the operation to a slot from the specified element.
  1787. #define CHANGER_TO_IEPORT       0x04 // The device can carry out the operation to an IE Port from the specified element.
  1788. #define CHANGER_TO_DRIVE        0x08 // The device can carry out the operation to a drive from the specified element.
  1790. //
  1791. // Definitions for LockUnlockCapabilities
  1792. //
  1794. #define LOCK_UNLOCK_IEPORT      0x01 // The device can lock/unlock the ieport(s).
  1795. #define LOCK_UNLOCK_DOOR        0x02 // The device can lock/unlock the door(s).
  1796. #define LOCK_UNLOCK_KEYPAD      0x04 // The device can lock/unlock the keypad.
  1798. typedef  struct _GET_CHANGER_PARAMETERS {
  1800.     //
  1801.     // Size of the structure. Can be used for versioning.
  1802.     //
  1804.     DWORD Size;
  1806.     //
  1807.     // Number of N element(s) as defined by the Element Address Page (or equivalent...).
  1808.     //
  1810.     WORD   NumberTransportElements;
  1811.     WORD   NumberStorageElements;                // for data cartridges only
  1812.     WORD   NumberCleanerSlots;                   // for cleaner cartridges
  1813.     WORD   NumberIEElements;
  1814.     WORD   NumberDataTransferElements;
  1816.     //
  1817.     // Number of doors/front panels (allows user entry into the cabinet).
  1818.     //
  1820.     WORD   NumberOfDoors;
  1822.     //
  1823.     // The device-specific address (from user manual of the device) of the first N element. Used
  1824.     // by the UI to relate the various elements to the user.
  1825.     //
  1827.     WORD   FirstSlotNumber;
  1828.     WORD   FirstDriveNumber;
  1829.     WORD   FirstTransportNumber;
  1830.     WORD   FirstIEPortNumber;
  1831.     WORD   FirstCleanerSlotAddress;
  1833.     //
  1834.     // Indicates the capacity of each magazine, if they exist.
  1835.     //
  1837.     WORD   MagazineSize;
  1839.     //
  1840.     // Specifies the approximate number of seconds for when a cleaning should be completed.
  1841.     // Only applicable if drive cleaning is supported. See Features0.
  1842.     //
  1844.     DWORD DriveCleanTimeout;
  1846.     //
  1847.     // See features bits, above.
  1848.     //
  1850.     DWORD Features0;
  1851.     DWORD Features1;
  1853.     //
  1854.     // Bitmask defining Move from N element to element. Defined by Device Capabilities Page (or equivalent).
  1855.     // AND-masking with the TO_XXX values will indicate legal destinations.
  1856.     //
  1858.     BYTE  MoveFromTransport;
  1859.     BYTE  MoveFromSlot;
  1860.     BYTE  MoveFromIePort;
  1861.     BYTE  MoveFromDrive;
  1863.     //
  1864.     // Bitmask defining Exchange from N element to element. Defined by Device Capabilities Page (or equivalent).
  1865.     // AND-masking with the TO_XXX values will indicate legal destinations.
  1866.     //
  1868.     BYTE  ExchangeFromTransport;
  1869.     BYTE  ExchangeFromSlot;
  1870.     BYTE  ExchangeFromIePort;
  1871.     BYTE  ExchangeFromDrive;
  1873.     //
  1874.     // Bitmask defining which elements are capable of lock/unlock. Valid only if
  1875.     // CHANGER_LOCK_UNLOCK is set in Features0.
  1876.     //
  1878.     BYTE  LockUnlockCapabilities;
  1880.     //
  1881.     // Bitmask defining which elements valid for positioning operations. Valid only if
  1882.     // CHANGER_POSITION_TO_ELEMENT is set in Features0.
  1883.     //
  1885.     BYTE  PositionCapabilities;
  1887.     //
  1888.     // For future expansion.
  1889.     //
  1891.     BYTE  Reserved1[2];
  1892.     DWORD Reserved2[2];
  1894. } GET_CHANGER_PARAMETERS, * PGET_CHANGER_PARAMETERS;
  1897. //
  1898. // Definitions for IOCTL_CHANGER_GET_PRODUCT_DATA
  1899. //
  1901. typedef  struct _CHANGER_PRODUCT_DATA {
  1903.     //
  1904.     // Device manufacturer's name - based on inquiry data
  1905.     //
  1907.     BYTE  VendorId[VENDOR_ID_LENGTH];
  1909.     //
  1910.     // Product identification as defined by the vendor - based on Inquiry data
  1911.     //
  1913.     BYTE  ProductId[PRODUCT_ID_LENGTH];
  1915.     //
  1916.     // Product revision as defined by the vendor.
  1917.     //
  1919.     BYTE  Revision[REVISION_LENGTH];
  1921.     //
  1922.     // Vendor unique value used to globally identify this device. Can
  1923.     // be from Vital Product Data, for example.
  1924.     //
  1926.     BYTE  SerialNumber[SERIAL_NUMBER_LENGTH];
  1928.     //
  1929.     // Indicates device type of data transports, as defined by SCSI-2.
  1930.     //
  1932.     BYTE  DeviceType;
  1934. } CHANGER_PRODUCT_DATA, *PCHANGER_PRODUCT_DATA;
  1937. //
  1938. // Definitions for IOCTL_CHANGER_SET_ACCESS
  1939. //
  1941. #define LOCK_ELEMENT        0
  1942. #define UNLOCK_ELEMENT      1
  1943. #define EXTEND_IEPORT       2
  1944. #define RETRACT_IEPORT      3
  1946. typedef struct _CHANGER_SET_ACCESS {
  1948.     //
  1949.     // Element can be ChangerIEPort, ChangerDoor, ChangerKeypad
  1950.     //
  1952.     CHANGER_ELEMENT Element;
  1954.     //
  1955.     // See above for possible operations.
  1956.     //
  1958.     DWORD           Control;
  1959. } CHANGER_SET_ACCESS, *PCHANGER_SET_ACCESS;
  1962. //
  1963. // Definitions for IOCTL_CHANGER_GET_ELEMENT_STATUS
  1964. //
  1966. //
  1967. // Input buffer.
  1968. //
  1970. typedef struct _CHANGER_READ_ELEMENT_STATUS {
  1972.     //
  1973.     // List describing the elements and range on which to return information.
  1974.     //
  1976.     CHANGER_ELEMENT_LIST ElementList;
  1978.     //
  1979.     // Indicates whether volume tag information is to be returned.
  1980.     //
  1982.     BOOLEAN VolumeTagInfo;
  1983. } CHANGER_READ_ELEMENT_STATUS, *PCHANGER_READ_ELEMENT_STATUS;
  1985. //
  1986. // Output buffer.
  1987. //
  1989. typedef  struct _CHANGER_ELEMENT_STATUS {
  1991.     //
  1992.     // Element to which this structure refers.
  1993.     //
  1995.     CHANGER_ELEMENT Element;
  1997.     //
  1998.     // Address of the element from which the media was originally moved.
  1999.     // Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
  2000.     // Needs to be converted to a zero-based offset from the device-unique value.
  2001.     //
  2003.     CHANGER_ELEMENT SrcElementAddress;
  2005.     //
  2006.     // See below.
  2007.     //
  2009.     DWORD Flags;
  2011.     //
  2012.     // See below for possible values.
  2013.     //
  2015.     DWORD ExceptionCode;
  2017.     //
  2018.     // Scsi Target Id of this element.
  2019.     // Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
  2020.     //
  2022.     BYTE  TargetId;
  2024.     //
  2025.     // LogicalUnitNumber of this element.
  2026.     // Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
  2027.     //
  2029.     BYTE  Lun;
  2030.     WORD   Reserved;
  2032.     //
  2033.     // Primary volume identification for the media.
  2034.     // Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
  2035.     //
  2037.     BYTE  PrimaryVolumeID[MAX_VOLUME_ID_SIZE];
  2039.     //
  2040.     // Alternate volume identification for the media.
  2041.     // Valid for two-sided media only, and pertains to the id. of the inverted side.
  2042.     // Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
  2043.     //
  2045.     BYTE  AlternateVolumeID[MAX_VOLUME_ID_SIZE];
  2047. } CHANGER_ELEMENT_STATUS, *PCHANGER_ELEMENT_STATUS;
  2049. //
  2050. // Output buffer. This is same as CHANGER_ELEMENT_STATUS with
  2051. // the addition of product info fields. New applications should
  2052. // use this struct instead of the older CHANGER_ELEMENT_STATUS
  2053. //
  2055. typedef  struct _CHANGER_ELEMENT_STATUS_EX {
  2057.     //
  2058.     // Element to which this structure refers.
  2059.     //
  2061.     CHANGER_ELEMENT Element;
  2063.     //
  2064.     // Address of the element from which the media was originally moved.
  2065.     // Valid if ELEMENT_STATUS_SVALID bit of Flags DWORD is set.
  2066.     // Needs to be converted to a zero-based offset from the device-unique value.
  2067.     //
  2069.     CHANGER_ELEMENT SrcElementAddress;
  2071.     //
  2072.     // See below.
  2073.     //
  2075.     DWORD Flags;
  2077.     //
  2078.     // See below for possible values.
  2079.     //
  2081.     DWORD ExceptionCode;
  2083.     //
  2084.     // Scsi Target Id of this element.
  2085.     // Valid only if ELEMENT_STATUS_ID_VALID is set in Flags.
  2086.     //
  2088.     BYTE  TargetId;
  2090.     //
  2091.     // LogicalUnitNumber of this element.
  2092.     // Valid only if ELEMENT_STATUS_LUN_VALID is set in Flags.
  2093.     //
  2095.     BYTE  Lun;
  2096.     WORD   Reserved;
  2098.     //
  2099.     // Primary volume identification for the media.
  2100.     // Valid only if ELEMENT_STATUS_PVOLTAG bit is set in Flags.
  2101.     //
  2103.     BYTE  PrimaryVolumeID[MAX_VOLUME_ID_SIZE];
  2105.     //
  2106.     // Alternate volume identification for the media.
  2107.     // Valid for two-sided media only, and pertains to the id. of the inverted side.
  2108.     // Valid only if ELEMENT_STATUS_AVOLTAG bit is set in Flags.
  2109.     //
  2111.     BYTE  AlternateVolumeID[MAX_VOLUME_ID_SIZE];
  2113.     //
  2114.     // Vendor ID
  2115.     //
  2116.     BYTE  VendorIdentification[VENDOR_ID_LENGTH];
  2118.     //
  2119.     // Product ID
  2120.     //
  2121.     BYTE  ProductIdentification[PRODUCT_ID_LENGTH];
  2123.     //
  2124.     // Serial number
  2125.     //
  2126.     BYTE  SerialNumber[SERIAL_NUMBER_LENGTH];
  2128. } CHANGER_ELEMENT_STATUS_EX, *PCHANGER_ELEMENT_STATUS_EX;
  2130. //
  2131. // Possible flag values
  2132. //
  2134. #define ELEMENT_STATUS_FULL      0x00000001 // Element contains a unit of media.
  2135. #define ELEMENT_STATUS_IMPEXP    0x00000002 // Media in i/e port was placed there by an operator.
  2136. #define ELEMENT_STATUS_EXCEPT    0x00000004 // Element is in an abnormal state; check ExceptionCode field for more information.
  2137. #define ELEMENT_STATUS_ACCESS    0x00000008 // Access to the i/e port from the medium changer is allowed.
  2138. #define ELEMENT_STATUS_EXENAB    0x00000010 // Export of media is supported.
  2139. #define ELEMENT_STATUS_INENAB    0x00000020 // Import of media is supported.
  2141. #define ELEMENT_STATUS_PRODUCT_DATA 0x00000040 // Serial number valid for the drive
  2143. #define ELEMENT_STATUS_LUN_VALID 0x00001000 // Lun information is valid.
  2144. #define ELEMENT_STATUS_ID_VALID  0x00002000 // SCSI Id information is valid.
  2145. #define ELEMENT_STATUS_NOT_BUS   0x00008000 // Lun and SCSI Id fields are not on same bus as medium changer.
  2146. #define ELEMENT_STATUS_INVERT    0x00400000 // Media in element was inverted (valid only if ELEMENT_STATUS_SVALID bit is set)
  2147. #define ELEMENT_STATUS_SVALID    0x00800000 // SourceElementAddress field and ELEMENT_STATUS_INVERT bit are valid.
  2149. #define ELEMENT_STATUS_PVOLTAG   0x10000000 // Primary volume information is valid.
  2150. #define ELEMENT_STATUS_AVOLTAG   0x20000000 // Alternate volume information is valid.
  2152. //
  2153. // ExceptionCode values.
  2154. //
  2156. #define ERROR_LABEL_UNREADABLE    0x00000001 // Bar code scanner could not read bar code label.
  2157. #define ERROR_LABEL_QUESTIONABLE  0x00000002 // Label could be invalid due to unit attention condition.
  2158. #define ERROR_SLOT_NOT_PRESENT    0x00000004 // Slot is currently not addressable in the device.
  2159. #define ERROR_DRIVE_NOT_INSTALLED 0x00000008 // Drive is not installed.
  2160. #define ERROR_TRAY_MALFUNCTION    0x00000010 // Media tray is malfunctioning/broken.
  2161. #define ERROR_INIT_STATUS_NEEDED  0x00000011 // An Initialize Element Status command is needed.
  2162. #define ERROR_UNHANDLED_ERROR     0xFFFFFFFF // Unknown error condition
  2165. //
  2166. // Definitions for IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS
  2167. //
  2169. typedef struct _CHANGER_INITIALIZE_ELEMENT_STATUS {
  2171.     //
  2172.     // List describing the elements and range on which to initialize.
  2173.     //
  2175.     CHANGER_ELEMENT_LIST ElementList;
  2177.     //
  2178.     // Indicates whether a bar code scan should be used. Only applicable if
  2179.     // CHANGER_BAR_CODE_SCANNER_INSTALLED is set in Features0 of CHANGER_GET_PARAMETERS.
  2180.     //
  2182.     BOOLEAN BarCodeScan;
  2183. } CHANGER_INITIALIZE_ELEMENT_STATUS, *PCHANGER_INITIALIZE_ELEMENT_STATUS;
  2186. //
  2187. // Definitions for IOCTL_CHANGER_SET_POSITION
  2188. //
  2190. typedef struct _CHANGER_SET_POSITION {
  2193.     //
  2194.     // Indicates which transport to move.
  2195.     //
  2197.     CHANGER_ELEMENT Transport;
  2199.     //
  2200.     // Indicates the final destination of the transport.
  2201.     //
  2203.     CHANGER_ELEMENT Destination;
  2205.     //
  2206.     // Indicates whether the media currently carried by Transport, should be flipped.
  2207.     //
  2209.     BOOLEAN         Flip;
  2210. } CHANGER_SET_POSITION, *PCHANGER_SET_POSITION;
  2213. //
  2214. // Definitions for IOCTL_CHANGER_EXCHANGE_MEDIUM
  2215. //
  2217. typedef struct _CHANGER_EXCHANGE_MEDIUM {
  2219.     //
  2220.     // Indicates which transport to use for the exchange operation.
  2221.     //
  2223.     CHANGER_ELEMENT Transport;
  2225.     //
  2226.     // Indicates the source for the media that is to be moved.
  2227.     //
  2229.     CHANGER_ELEMENT Source;
  2231.     //
  2232.     // Indicates the final destination of the media originally at Source.
  2233.     //
  2235.     CHANGER_ELEMENT Destination1;
  2237.     //
  2238.     // Indicates the destination of the media moved from Destination1.
  2239.     //
  2241.     CHANGER_ELEMENT Destination2;
  2243.     //
  2244.     // Indicates whether the medium should be flipped.
  2245.     //
  2247.     BOOLEAN         Flip1;
  2248.     BOOLEAN         Flip2;
  2249. } CHANGER_EXCHANGE_MEDIUM, *PCHANGER_EXCHANGE_MEDIUM;
  2252. //
  2253. // Definitions for IOCTL_CHANGER_MOVE_MEDIUM
  2254. //
  2256. typedef struct _CHANGER_MOVE_MEDIUM {
  2258.     //
  2259.     // Indicates which transport to use for the move operation.
  2260.     //
  2262.     CHANGER_ELEMENT Transport;
  2264.     //
  2265.     // Indicates the source for the media that is to be moved.
  2266.     //
  2268.     CHANGER_ELEMENT Source;
  2270.     //
  2271.     // Indicates the destination of the media originally at Source.
  2272.     //
  2274.     CHANGER_ELEMENT Destination;
  2276.     //
  2277.     // Indicates whether the media should be flipped.
  2278.     //
  2280.     BOOLEAN         Flip;
  2281. } CHANGER_MOVE_MEDIUM, *PCHANGER_MOVE_MEDIUM;
  2285. //
  2286. // Definitions for IOCTL_QUERY_VOLUME_TAGS
  2287. //
  2289. //
  2290. // Input buffer.
  2291. //
  2293. typedef  struct _CHANGER_SEND_VOLUME_TAG_INFORMATION {
  2295.     //
  2296.     // Describes the starting element for which to return information.
  2297.     //
  2299.     CHANGER_ELEMENT StartingElement;
  2301.     //
  2302.     // Indicates the specific action to perform. See below.
  2303.     //
  2305.     DWORD ActionCode;
  2307.     //
  2308.     // Template used by the device to search for volume ids.
  2309.     //
  2311.     BYTE  VolumeIDTemplate[MAX_VOLUME_TEMPLATE_SIZE];
  2312. } CHANGER_SEND_VOLUME_TAG_INFORMATION, *PCHANGER_SEND_VOLUME_TAG_INFORMATION;
  2315. //
  2316. // Output buffer.
  2317. //
  2319. typedef struct _READ_ELEMENT_ADDRESS_INFO {
  2321.     //
  2322.     // Number of elements matching criteria set forth by ActionCode.
  2323.     //
  2325.     DWORD NumberOfElements;
  2327.     //
  2328.     // Array of CHANGER_ELEMENT_STATUS structures, one for each element that corresponded
  2329.     // with the information passed in with the CHANGER_SEND_VOLUME_TAG_INFORMATION structure.
  2330.     //
  2332.     CHANGER_ELEMENT_STATUS ElementStatus[1];
  2333. } READ_ELEMENT_ADDRESS_INFO, *PREAD_ELEMENT_ADDRESS_INFO;
  2335. //
  2336. // Possible ActionCode values. See Features0 of CHANGER_GET_PARAMETERS for compatibility with
  2337. // the current device.
  2338. //
  2340. #define SEARCH_ALL         0x0 // Translate - search all defined volume tags.
  2341. #define SEARCH_PRIMARY     0x1 // Translate - search only primary volume tags.
  2342. #define SEARCH_ALTERNATE   0x2 // Translate - search only alternate volume tags.
  2343. #define SEARCH_ALL_NO_SEQ  0x4 // Translate - search all defined volume tags but ignore sequence numbers.
  2344. #define SEARCH_PRI_NO_SEQ  0x5 // Translate - search only primary volume tags but ignore sequence numbers.
  2345. #define SEARCH_ALT_NO_SEQ  0x6 // Translate - search only alternate volume tags but ignore sequence numbers.
  2347. #define ASSERT_PRIMARY     0x8 // Assert - as the primary volume tag - if tag now undefined.
  2348. #define ASSERT_ALTERNATE   0x9 // Assert - as the alternate volume tag - if tag now undefined.
  2350. #define REPLACE_PRIMARY    0xA // Replace - the primary volume tag - current tag ignored.
  2351. #define REPLACE_ALTERNATE  0xB // Replace - the alternate volume tag - current tag ignored.
  2353. #define UNDEFINE_PRIMARY   0xC // Undefine - the primary volume tag - current tag ignored.
  2354. #define UNDEFINE_ALTERNATE 0xD // Undefine - the alternate volume tag - current tag ignored.
  2357. //
  2358. // Changer diagnostic test related definitions
  2359. //
  2360. typedef enum _CHANGER_DEVICE_PROBLEM_TYPE {
  2361.    DeviceProblemNone,
  2362.    DeviceProblemHardware,
  2363.    DeviceProblemCHMError,
  2364.    DeviceProblemDoorOpen,
  2365.    DeviceProblemCalibrationError,
  2366.    DeviceProblemTargetFailure,
  2367.    DeviceProblemCHMMoveError,
  2368.    DeviceProblemCHMZeroError,
  2369.    DeviceProblemCartridgeInsertError,
  2370.    DeviceProblemPositionError,
  2371.    DeviceProblemSensorError,
  2372.    DeviceProblemCartridgeEjectError,
  2373.    DeviceProblemGripperError,
  2374.    DeviceProblemDriveError
  2375. } CHANGER_DEVICE_PROBLEM_TYPE, *PCHANGER_DEVICE_PROBLEM_TYPE;
  2378. #define IOCTL_SERIAL_LSRMST_INSERT      CTL_CODE(FILE_DEVICE_SERIAL_PORT,31,METHOD_BUFFERED,FILE_ANY_ACCESS)
  2380. #define IOCTL_SERENUM_EXPOSE_HARDWARE   CTL_CODE(FILE_DEVICE_SERENUM,128,METHOD_BUFFERED,FILE_ANY_ACCESS)
  2381. #define IOCTL_SERENUM_REMOVE_HARDWARE   CTL_CODE(FILE_DEVICE_SERENUM,129,METHOD_BUFFERED,FILE_ANY_ACCESS)
  2382. #define IOCTL_SERENUM_PORT_DESC         CTL_CODE(FILE_DEVICE_SERENUM,130,METHOD_BUFFERED,FILE_ANY_ACCESS)
  2383. #define IOCTL_SERENUM_GET_PORT_NAME     CTL_CODE(FILE_DEVICE_SERENUM,131,METHOD_BUFFERED,FILE_ANY_ACCESS)
  2386. //
  2387. // The following values follow the escape designator in the
  2388. // data stream if the LSRMST_INSERT mode has been turned on.
  2389. //
  2390. #define SERIAL_LSRMST_ESCAPE     ((BYTE )0x00)
  2392. //
  2393. // Following this value is the contents of the line status
  2394. // register, and then the character in the RX hardware when
  2395. // the line status register was encountered.
  2396. //
  2397. #define SERIAL_LSRMST_LSR_DATA   ((BYTE )0x01)
  2399. //
  2400. // Following this value is the contents of the line status
  2401. // register.  No error character follows
  2402. //
  2403. #define SERIAL_LSRMST_LSR_NODATA ((BYTE )0x02)
  2405. //
  2406. // Following this value is the contents of the modem status
  2407. // register.
  2408. //
  2409. #define SERIAL_LSRMST_MST        ((BYTE )0x03)
  2411. //
  2412. // Bit values for FIFO Control Register
  2413. //
  2415. #define SERIAL_IOC_FCR_FIFO_ENABLE      ((DWORD)0x00000001)
  2416. #define SERIAL_IOC_FCR_RCVR_RESET       ((DWORD)0x00000002)
  2417. #define SERIAL_IOC_FCR_XMIT_RESET       ((DWORD)0x00000004)
  2418. #define SERIAL_IOC_FCR_DMA_MODE         ((DWORD)0x00000008)
  2419. #define SERIAL_IOC_FCR_RES1             ((DWORD)0x00000010)
  2420. #define SERIAL_IOC_FCR_RES2             ((DWORD)0x00000020)
  2421. #define SERIAL_IOC_FCR_RCVR_TRIGGER_LSB ((DWORD)0x00000040)
  2422. #define SERIAL_IOC_FCR_RCVR_TRIGGER_MSB ((DWORD)0x00000080)
  2424. //
  2425. // Bit values for Modem Control Register
  2426. //
  2428. #define SERIAL_IOC_MCR_DTR              ((DWORD)0x00000001)
  2429. #define SERIAL_IOC_MCR_RTS              ((DWORD)0x00000002)
  2430. #define SERIAL_IOC_MCR_OUT1             ((DWORD)0x00000004)
  2431. #define SERIAL_IOC_MCR_OUT2             ((DWORD)0x00000008)
  2432. #define SERIAL_IOC_MCR_LOOP             ((DWORD)0x00000010)
  2434. #ifndef _FILESYSTEMFSCTL_
  2435. #define _FILESYSTEMFSCTL_
  2437. //
  2438. // The following is a list of the native file system fsctls followed by
  2439. // additional network file system fsctls.  Some values have been
  2440. // decommissioned.
  2441. //
  2443. #define FSCTL_REQUEST_OPLOCK_LEVEL_1    CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  0, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2444. #define FSCTL_REQUEST_OPLOCK_LEVEL_2    CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  1, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2445. #define FSCTL_REQUEST_BATCH_OPLOCK      CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  2, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2446. #define FSCTL_OPLOCK_BREAK_ACKNOWLEDGE  CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  3, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2447. #define FSCTL_OPBATCH_ACK_CLOSE_PENDING CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  4, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2448. #define FSCTL_OPLOCK_BREAK_NOTIFY       CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  5, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2449. #define FSCTL_LOCK_VOLUME               CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  6, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2450. #define FSCTL_UNLOCK_VOLUME             CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  7, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2451. #define FSCTL_DISMOUNT_VOLUME           CTL_CODE(FILE_DEVICE_FILE_SYSTEM,  8, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2452. // decommissioned fsctl value                                              9
  2453. #define FSCTL_IS_VOLUME_MOUNTED         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 10, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2454. #define FSCTL_IS_PATHNAME_VALID         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 11, METHOD_BUFFERED, FILE_ANY_ACCESS) // PATHNAME_BUFFER,
  2455. #define FSCTL_MARK_VOLUME_DIRTY         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2456. // decommissioned fsctl value                                             13
  2457. #define FSCTL_QUERY_RETRIEVAL_POINTERS  CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 14,  METHOD_NEITHER, FILE_ANY_ACCESS)
  2458. #define FSCTL_GET_COMPRESSION           CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 15, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2459. #define FSCTL_SET_COMPRESSION           CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 16, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
  2460. // decommissioned fsctl value                                             17
  2461. // decommissioned fsctl value                                             18
  2462. #define FSCTL_MARK_AS_SYSTEM_HIVE       CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 19,  METHOD_NEITHER, FILE_ANY_ACCESS)
  2463. #define FSCTL_OPLOCK_BREAK_ACK_NO_2     CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 20, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2464. #define FSCTL_INVALIDATE_VOLUMES        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 21, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2465. #define FSCTL_QUERY_FAT_BPB             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 22, METHOD_BUFFERED, FILE_ANY_ACCESS) // FSCTL_QUERY_FAT_BPB_BUFFER
  2466. #define FSCTL_REQUEST_FILTER_OPLOCK     CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 23, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2467. #define FSCTL_FILESYSTEM_GET_STATISTICS CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 24, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILESYSTEM_STATISTICS
  2468. #if(_WIN32_WINNT >= 0x0400)
  2469. #define FSCTL_GET_NTFS_VOLUME_DATA      CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 25, METHOD_BUFFERED, FILE_ANY_ACCESS) // NTFS_VOLUME_DATA_BUFFER
  2470. #define FSCTL_GET_NTFS_FILE_RECORD      CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 26, METHOD_BUFFERED, FILE_ANY_ACCESS) // NTFS_FILE_RECORD_INPUT_BUFFER, NTFS_FILE_RECORD_OUTPUT_BUFFER
  2471. #define FSCTL_GET_VOLUME_BITMAP         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 27,  METHOD_NEITHER, FILE_ANY_ACCESS) // STARTING_LCN_INPUT_BUFFER, VOLUME_BITMAP_BUFFER
  2472. #define FSCTL_GET_RETRIEVAL_POINTERS    CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 28,  METHOD_NEITHER, FILE_ANY_ACCESS) // STARTING_VCN_INPUT_BUFFER, RETRIEVAL_POINTERS_BUFFER
  2473. #define FSCTL_MOVE_FILE                 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 29, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // MOVE_FILE_DATA,
  2474. #define FSCTL_IS_VOLUME_DIRTY           CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 30, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2475. // decomissioned fsctl value                                              31
  2476. #define FSCTL_ALLOW_EXTENDED_DASD_IO    CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 32, METHOD_NEITHER,  FILE_ANY_ACCESS)
  2477. #endif /* _WIN32_WINNT >= 0x0400 */
  2479. #if(_WIN32_WINNT >= 0x0500)
  2480. // decommissioned fsctl value                                             33
  2481. // decommissioned fsctl value                                             34
  2482. #define FSCTL_FIND_FILES_BY_SID         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 35, METHOD_NEITHER, FILE_ANY_ACCESS)
  2483. // decommissioned fsctl value                                             36
  2484. // decommissioned fsctl value                                             37
  2485. #define FSCTL_SET_OBJECT_ID             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 38, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // FILE_OBJECTID_BUFFER
  2486. #define FSCTL_GET_OBJECT_ID             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 39, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILE_OBJECTID_BUFFER
  2487. #define FSCTL_DELETE_OBJECT_ID          CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 40, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
  2488. #define FSCTL_SET_REPARSE_POINT         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER,
  2489. #define FSCTL_GET_REPARSE_POINT         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
  2490. #define FSCTL_DELETE_REPARSE_POINT      CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER,
  2491. #define FSCTL_ENUM_USN_DATA             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 44,  METHOD_NEITHER, FILE_ANY_ACCESS) // MFT_ENUM_DATA,
  2492. #define FSCTL_SECURITY_ID_CHECK         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 45,  METHOD_NEITHER, FILE_READ_DATA)  // BULK_SECURITY_TEST_DATA,
  2493. #define FSCTL_READ_USN_JOURNAL          CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 46,  METHOD_NEITHER, FILE_ANY_ACCESS) // READ_USN_JOURNAL_DATA, USN
  2494. #define FSCTL_SET_OBJECT_ID_EXTENDED    CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 47, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
  2495. #define FSCTL_CREATE_OR_GET_OBJECT_ID   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 48, METHOD_BUFFERED, FILE_ANY_ACCESS) // FILE_OBJECTID_BUFFER
  2496. #define FSCTL_SET_SPARSE                CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
  2497. #define FSCTL_SET_ZERO_DATA             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 50, METHOD_BUFFERED, FILE_WRITE_DATA) // FILE_ZERO_DATA_INFORMATION,
  2498. #define FSCTL_QUERY_ALLOCATED_RANGES    CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 51,  METHOD_NEITHER, FILE_READ_DATA)  // FILE_ALLOCATED_RANGE_BUFFER, FILE_ALLOCATED_RANGE_BUFFER
  2499. // decommissioned fsctl value                                             52
  2500. #define FSCTL_SET_ENCRYPTION            CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 53,  METHOD_NEITHER, FILE_ANY_ACCESS) // ENCRYPTION_BUFFER, DECRYPTION_STATUS_BUFFER
  2501. #define FSCTL_ENCRYPTION_FSCTL_IO       CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 54,  METHOD_NEITHER, FILE_ANY_ACCESS)
  2502. #define FSCTL_WRITE_RAW_ENCRYPTED       CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 55,  METHOD_NEITHER, FILE_SPECIAL_ACCESS) // ENCRYPTED_DATA_INFO,
  2503. #define FSCTL_READ_RAW_ENCRYPTED        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 56,  METHOD_NEITHER, FILE_SPECIAL_ACCESS) // REQUEST_RAW_ENCRYPTED_DATA, ENCRYPTED_DATA_INFO
  2504. #define FSCTL_CREATE_USN_JOURNAL        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 57,  METHOD_NEITHER, FILE_ANY_ACCESS) // CREATE_USN_JOURNAL_DATA,
  2505. #define FSCTL_READ_FILE_USN_DATA        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 58,  METHOD_NEITHER, FILE_ANY_ACCESS) // Read the Usn Record for a file
  2506. #define FSCTL_WRITE_USN_CLOSE_RECORD    CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 59,  METHOD_NEITHER, FILE_ANY_ACCESS) // Generate Close Usn Record
  2507. #define FSCTL_EXTEND_VOLUME             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 60, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2508. #define FSCTL_QUERY_USN_JOURNAL         CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 61, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2509. #define FSCTL_DELETE_USN_JOURNAL        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 62, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2510. #define FSCTL_MARK_HANDLE               CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 63, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2511. #define FSCTL_SIS_COPYFILE              CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 64, METHOD_BUFFERED, FILE_ANY_ACCESS)
  2512. #define FSCTL_SIS_LINK_FILES            CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 65, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
  2513. #define FSCTL_HSM_MSG                   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 66, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
  2514. // decommissioned fsctl value                                             67
  2515. #define FSCTL_HSM_DATA                  CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 68, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
  2516. #define FSCTL_RECALL_FILE               CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 69, METHOD_NEITHER, FILE_ANY_ACCESS)
  2517. // decommissioned fsctl value                                             70
  2518. #define FSCTL_READ_FROM_PLEX            CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 71, METHOD_OUT_DIRECT, FILE_READ_DATA)
  2519. #define FSCTL_FILE_PREFETCH             CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 72, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // FILE_PREFETCH
  2520. #endif /* _WIN32_WINNT >= 0x0500 */
  2522. //
  2523. // The following long list of structs are associated with the preceeding
  2524. // file system fsctls.
  2525. //
  2527. //
  2528. // Structure for FSCTL_IS_PATHNAME_VALID
  2529. //
  2531. typedef struct _PATHNAME_BUFFER {
  2533.     DWORD PathNameLength;
  2534.     WCHAR Name[1];
  2536. } PATHNAME_BUFFER, *PPATHNAME_BUFFER;
  2538. //
  2539. // Structure for FSCTL_QUERY_BPB_INFO
  2540. //
  2542. typedef struct _FSCTL_QUERY_FAT_BPB_BUFFER {
  2544.     BYTE  First0x24BytesOfBootSector[0x24];
  2546. } FSCTL_QUERY_FAT_BPB_BUFFER, *PFSCTL_QUERY_FAT_BPB_BUFFER;
  2548. #if(_WIN32_WINNT >= 0x0400)
  2549. //
  2550. // Structures for FSCTL_GET_NTFS_VOLUME_DATA.
  2551. // The user must pass the basic buffer below.  Ntfs
  2552. // will return as many fields as available in the extended
  2553. // buffer which follows immediately after the VOLUME_DATA_BUFFER.
  2554. //
  2556. typedef struct {
  2558.     LARGE_INTEGER VolumeSerialNumber;
  2559.     LARGE_INTEGER NumberSectors;
  2560.     LARGE_INTEGER TotalClusters;
  2561.     LARGE_INTEGER FreeClusters;
  2562.     LARGE_INTEGER TotalReserved;
  2563.     DWORD BytesPerSector;
  2564.     DWORD BytesPerCluster;
  2565.     DWORD BytesPerFileRecordSegment;
  2566.     DWORD ClustersPerFileRecordSegment;
  2567.     LARGE_INTEGER MftValidDataLength;
  2568.     LARGE_INTEGER MftStartLcn;
  2569.     LARGE_INTEGER Mft2StartLcn;
  2570.     LARGE_INTEGER MftZoneStart;
  2571.     LARGE_INTEGER MftZoneEnd;
  2573. } NTFS_VOLUME_DATA_BUFFER, *PNTFS_VOLUME_DATA_BUFFER;
  2575. typedef struct {
  2577.     DWORD ByteCount;
  2579.     WORD   MajorVersion;
  2580.     WORD   MinorVersion;
  2582. } NTFS_EXTENDED_VOLUME_DATA, *PNTFS_EXTENDED_VOLUME_DATA;
  2583. #endif /* _WIN32_WINNT >= 0x0400 */
  2585. #if(_WIN32_WINNT >= 0x0400)
  2586. //
  2587. // Structure for FSCTL_GET_VOLUME_BITMAP
  2588. //
  2590. typedef struct {
  2592.     LARGE_INTEGER StartingLcn;
  2594. } STARTING_LCN_INPUT_BUFFER, *PSTARTING_LCN_INPUT_BUFFER;
  2596. typedef struct {
  2598.     LARGE_INTEGER StartingLcn;
  2599.     LARGE_INTEGER BitmapSize;
  2600.     BYTE  Buffer[1];
  2602. } VOLUME_BITMAP_BUFFER, *PVOLUME_BITMAP_BUFFER;
  2603. #endif /* _WIN32_WINNT >= 0x0400 */
  2605. #if(_WIN32_WINNT >= 0x0400)
  2606. //
  2607. // Structure for FSCTL_GET_RETRIEVAL_POINTERS
  2608. //
  2610. typedef struct {
  2612.     LARGE_INTEGER StartingVcn;
  2614. } STARTING_VCN_INPUT_BUFFER, *PSTARTING_VCN_INPUT_BUFFER;
  2616. typedef struct RETRIEVAL_POINTERS_BUFFER {
  2618.     DWORD ExtentCount;
  2619.     LARGE_INTEGER StartingVcn;
  2620.     struct {
  2621.         LARGE_INTEGER NextVcn;
  2622.         LARGE_INTEGER Lcn;
  2623.     } Extents[1];
  2625. } RETRIEVAL_POINTERS_BUFFER, *PRETRIEVAL_POINTERS_BUFFER;
  2626. #endif /* _WIN32_WINNT >= 0x0400 */
  2628. #if(_WIN32_WINNT >= 0x0400)
  2629. //
  2630. // Structures for FSCTL_GET_NTFS_FILE_RECORD
  2631. //
  2633. typedef struct {
  2635.     LARGE_INTEGER FileReferenceNumber;
  2637. } NTFS_FILE_RECORD_INPUT_BUFFER, *PNTFS_FILE_RECORD_INPUT_BUFFER;
  2639. typedef struct {
  2641.     LARGE_INTEGER FileReferenceNumber;
  2642.     DWORD FileRecordLength;
  2643.     BYTE  FileRecordBuffer[1];
  2645. } NTFS_FILE_RECORD_OUTPUT_BUFFER, *PNTFS_FILE_RECORD_OUTPUT_BUFFER;
  2646. #endif /* _WIN32_WINNT >= 0x0400 */
  2648. #if(_WIN32_WINNT >= 0x0400)
  2649. //
  2650. // Structure for FSCTL_MOVE_FILE
  2651. //
  2653. typedef struct {
  2655.     HANDLE FileHandle;
  2656.     LARGE_INTEGER StartingVcn;
  2657.     LARGE_INTEGER StartingLcn;
  2658.     DWORD ClusterCount;
  2660. } MOVE_FILE_DATA, *PMOVE_FILE_DATA;
  2662. #if defined(_WIN64)
  2663. //
  2664. //  32/64 Bit thunking support structure
  2665. //
  2667. typedef struct _MOVE_FILE_DATA32 {
  2669.     UINT32 FileHandle;
  2670.     LARGE_INTEGER StartingVcn;
  2671.     LARGE_INTEGER StartingLcn;
  2672.     DWORD ClusterCount;
  2674. } MOVE_FILE_DATA32, *PMOVE_FILE_DATA32;
  2675. #endif
  2676. #endif /* _WIN32_WINNT >= 0x0400 */
  2678. #if(_WIN32_WINNT >= 0x0500)
  2679. //
  2680. // Structure for FSCTL_FIND_FILES_BY_SID
  2681. //
  2683. typedef struct {
  2684.     DWORD Restart;
  2685.     SID Sid;
  2686. } FIND_BY_SID_DATA, *PFIND_BY_SID_DATA;
  2687. #endif /* _WIN32_WINNT >= 0x0500 */
  2689. #if(_WIN32_WINNT >= 0x0500)
  2690. //
  2691. //  The following structures apply to Usn operations.
  2692. //
  2694. //
  2695. // Structure for FSCTL_ENUM_USN_DATA
  2696. //
  2698. typedef struct {
  2700.     DWORDLONG StartFileReferenceNumber;
  2701.     USN LowUsn;
  2702.     USN HighUsn;
  2704. } MFT_ENUM_DATA, *PMFT_ENUM_DATA;
  2706. //
  2707. // Structure for FSCTL_CREATE_USN_JOURNAL
  2708. //
  2710. typedef struct {
  2712.     DWORDLONG MaximumSize;
  2713.     DWORDLONG AllocationDelta;
  2715. } CREATE_USN_JOURNAL_DATA, *PCREATE_USN_JOURNAL_DATA;
  2717. //
  2718. // Structure for FSCTL_READ_USN_JOURNAL
  2719. //
  2721. typedef struct {
  2723.     USN StartUsn;
  2724.     DWORD ReasonMask;
  2725.     DWORD ReturnOnlyOnClose;
  2726.     DWORDLONG Timeout;
  2727.     DWORDLONG BytesToWaitFor;
  2728.     DWORDLONG UsnJournalID;
  2730. } READ_USN_JOURNAL_DATA, *PREAD_USN_JOURNAL_DATA;
  2732. //
  2733. //  The initial Major.Minor version of the Usn record will be 2.0.
  2734. //  In general, the MinorVersion may be changed if fields are added
  2735. //  to this structure in such a way that the previous version of the
  2736. //  software can still correctly the fields it knows about.  The
  2737. //  MajorVersion should only be changed if the previous version of
  2738. //  any software using this structure would incorrectly handle new
  2739. //  records due to structure changes.
  2740. //
  2741. //  The first update to this will force the structure to version 2.0.
  2742. //  This will add the extended information about the source as
  2743. //  well as indicate the file name offset within the structure.
  2744. //
  2745. //  The following structure is returned with these fsctls.
  2746. //
  2747. //      FSCTL_READ_USN_JOURNAL
  2748. //      FSCTL_READ_FILE_USN_DATA
  2749. //      FSCTL_ENUM_USN_DATA
  2750. //
  2752. typedef struct {
  2754.     DWORD RecordLength;
  2755.     WORD   MajorVersion;
  2756.     WORD   MinorVersion;
  2757.     DWORDLONG FileReferenceNumber;
  2758.     DWORDLONG ParentFileReferenceNumber;
  2759.     USN Usn;
  2760.     LARGE_INTEGER TimeStamp;
  2761.     DWORD Reason;
  2762.     DWORD SourceInfo;
  2763.     DWORD SecurityId;
  2764.     DWORD FileAttributes;
  2765.     WORD   FileNameLength;
  2766.     WORD   FileNameOffset;
  2767.     WCHAR FileName[1];
  2769. } USN_RECORD, *PUSN_RECORD;
  2771. #define USN_PAGE_SIZE                    (0x1000)
  2773. #define USN_REASON_DATA_OVERWRITE        (0x00000001)
  2774. #define USN_REASON_DATA_EXTEND           (0x00000002)
  2775. #define USN_REASON_DATA_TRUNCATION       (0x00000004)
  2776. #define USN_REASON_NAMED_DATA_OVERWRITE  (0x00000010)
  2777. #define USN_REASON_NAMED_DATA_EXTEND     (0x00000020)
  2778. #define USN_REASON_NAMED_DATA_TRUNCATION (0x00000040)
  2779. #define USN_REASON_FILE_CREATE           (0x00000100)
  2780. #define USN_REASON_FILE_DELETE           (0x00000200)
  2781. #define USN_REASON_EA_CHANGE             (0x00000400)
  2782. #define USN_REASON_SECURITY_CHANGE       (0x00000800)
  2783. #define USN_REASON_RENAME_OLD_NAME       (0x00001000)
  2784. #define USN_REASON_RENAME_NEW_NAME       (0x00002000)
  2785. #define USN_REASON_INDEXABLE_CHANGE      (0x00004000)
  2786. #define USN_REASON_BASIC_INFO_CHANGE     (0x00008000)
  2787. #define USN_REASON_HARD_LINK_CHANGE      (0x00010000)
  2788. #define USN_REASON_COMPRESSION_CHANGE    (0x00020000)
  2789. #define USN_REASON_ENCRYPTION_CHANGE     (0x00040000)
  2790. #define USN_REASON_OBJECT_ID_CHANGE      (0x00080000)
  2791. #define USN_REASON_REPARSE_POINT_CHANGE  (0x00100000)
  2792. #define USN_REASON_STREAM_CHANGE         (0x00200000)
  2794. #define USN_REASON_CLOSE                 (0x80000000)
  2796. //
  2797. //  Structure for FSCTL_QUERY_USN_JOUNAL
  2798. //
  2800. typedef struct {
  2802.     DWORDLONG UsnJournalID;
  2803.     USN FirstUsn;
  2804.     USN NextUsn;
  2805.     USN LowestValidUsn;
  2806.     USN MaxUsn;
  2807.     DWORDLONG MaximumSize;
  2808.     DWORDLONG AllocationDelta;
  2810. } USN_JOURNAL_DATA, *PUSN_JOURNAL_DATA;
  2812. //
  2813. //  Structure for FSCTL_DELETE_USN_JOURNAL
  2814. //
  2816. typedef struct {
  2818.     DWORDLONG UsnJournalID;
  2819.     DWORD DeleteFlags;
  2821. } DELETE_USN_JOURNAL_DATA, *PDELETE_USN_JOURNAL_DATA;
  2823. #define USN_DELETE_FLAG_DELETE              (0x00000001)
  2824. #define USN_DELETE_FLAG_NOTIFY              (0x00000002)
  2826. #define USN_DELETE_VALID_FLAGS              (0x00000003)
  2828. //
  2829. //  Structure for FSCTL_MARK_HANDLE
  2830. //
  2832. typedef struct {
  2834.     DWORD UsnSourceInfo;
  2835.     HANDLE VolumeHandle;
  2836.     DWORD HandleInfo;
  2838. } MARK_HANDLE_INFO, *PMARK_HANDLE_INFO;
  2840. #if defined(_WIN64)
  2841. //
  2842. //  32/64 Bit thunking support structure
  2843. //
  2845. typedef struct {
  2847.     DWORD UsnSourceInfo;
  2848.     UINT32 VolumeHandle;
  2849.     DWORD HandleInfo;
  2851. } MARK_HANDLE_INFO32, *PMARK_HANDLE_INFO32;
  2852. #endif
  2854. //
  2855. //  Flags for the additional source information above.
  2856. //
  2857. //      USN_SOURCE_DATA_MANAGEMENT - Service is not modifying the external view
  2858. //          of any part of the file.  Typical case is HSM moving data to
  2859. //          and from external storage.
  2860. //
  2861. //      USN_SOURCE_AUXILIARY_DATA - Service is not modifying the external view
  2862. //          of the file with regard to the application that created this file.
  2863. //          Can be used to add private data streams to a file.
  2864. //
  2865. //      USN_SOURCE_REPLICATION_MANAGEMENT - Service is modifying a file to match
  2866. //          the contents of the same file which exists in another member of the
  2867. //          replica set.
  2868. //
  2870. #define USN_SOURCE_DATA_MANAGEMENT          (0x00000001)
  2871. #define USN_SOURCE_AUXILIARY_DATA           (0x00000002)
  2872. #define USN_SOURCE_REPLICATION_MANAGEMENT   (0x00000004)
  2874. //
  2875. //  Flags for the HandleInfo field above
  2876. //
  2877. //  MARK_HANDLE_PROTECT_CLUSTERS - disallow any defragmenting (FSCTL_MOVE_FILE) until the
  2878. //      the handle is closed
  2879. //
  2881. #define MARK_HANDLE_PROTECT_CLUSTERS        (0x00000001)
  2883. #endif /* _WIN32_WINNT >= 0x0500 */
  2885. #if(_WIN32_WINNT >= 0x0500)
  2886. //
  2887. // Structure for FSCTL_SECURITY_ID_CHECK
  2888. //
  2890. typedef struct {
  2892.     ACCESS_MASK DesiredAccess;
  2893.     DWORD SecurityIds[1];
  2895. } BULK_SECURITY_TEST_DATA, *PBULK_SECURITY_TEST_DATA;
  2896. #endif /* _WIN32_WINNT >= 0x0500 */
  2898. #if(_WIN32_WINNT >= 0x0500)
  2899. //
  2900. //  Output flags for the FSCTL_IS_VOLUME_DIRTY
  2901. //
  2903. #define VOLUME_IS_DIRTY                  (0x00000001)
  2904. #define VOLUME_UPGRADE_SCHEDULED         (0x00000002)
  2905. #endif /* _WIN32_WINNT >= 0x0500 */
  2907. //
  2908. // Structures for FSCTL_FILE_PREFETCH
  2909. //
  2911. typedef struct _FILE_PREFETCH {
  2912.     DWORD Type;
  2913.     DWORD Count;
  2914.     DWORDLONG Prefetch[1];
  2915. } FILE_PREFETCH, *PFILE_PREFETCH;
  2917. #define FILE_PREFETCH_TYPE_FOR_CREATE    0x1
  2919. // Structures for FSCTL_FILESYSTEM_GET_STATISTICS
  2920. //
  2921. // Filesystem performance counters
  2922. //
  2924. typedef struct _FILESYSTEM_STATISTICS {
  2926.     WORD   FileSystemType;
  2927.     WORD   Version;                     // currently version 1
  2929.     DWORD SizeOfCompleteStructure;      // must by a mutiple of 64 bytes
  2931.     DWORD UserFileReads;
  2932.     DWORD UserFileReadBytes;
  2933.     DWORD UserDiskReads;
  2934.     DWORD UserFileWrites;
  2935.     DWORD UserFileWriteBytes;
  2936.     DWORD UserDiskWrites;
  2938.     DWORD MetaDataReads;
  2939.     DWORD MetaDataReadBytes;
  2940.     DWORD MetaDataDiskReads;
  2941.     DWORD MetaDataWrites;
  2942.     DWORD MetaDataWriteBytes;
  2943.     DWORD MetaDataDiskWrites;
  2945.     //
  2946.     //  The file system's private structure is appended here.
  2947.     //
  2949. } FILESYSTEM_STATISTICS, *PFILESYSTEM_STATISTICS;
  2951. // values for FS_STATISTICS.FileSystemType
  2953. #define FILESYSTEM_STATISTICS_TYPE_NTFS     1
  2954. #define FILESYSTEM_STATISTICS_TYPE_FAT      2
  2956. //
  2957. //  File System Specific Statistics Data
  2958. //
  2960. typedef struct _FAT_STATISTICS {
  2961.     DWORD CreateHits;
  2962.     DWORD SuccessfulCreates;
  2963.     DWORD FailedCreates;
  2965.     DWORD NonCachedReads;
  2966.     DWORD NonCachedReadBytes;
  2967.     DWORD NonCachedWrites;
  2968.     DWORD NonCachedWriteBytes;
  2970.     DWORD NonCachedDiskReads;
  2971.     DWORD NonCachedDiskWrites;
  2972. } FAT_STATISTICS, *PFAT_STATISTICS;
  2974. typedef struct _NTFS_STATISTICS {
  2976.     DWORD LogFileFullExceptions;
  2977.     DWORD OtherExceptions;
  2979.     //
  2980.     // Other meta data io's
  2981.     //
  2983.     DWORD MftReads;
  2984.     DWORD MftReadBytes;
  2985.     DWORD MftWrites;
  2986.     DWORD MftWriteBytes;
  2987.     struct {
  2988.         WORD   Write;
  2989.         WORD   Create;
  2990.         WORD   SetInfo;
  2991.         WORD   Flush;
  2992.     } MftWritesUserLevel;
  2994.     WORD   MftWritesFlushForLogFileFull;
  2995.     WORD   MftWritesLazyWriter;
  2996.     WORD   MftWritesUserRequest;
  2998.     DWORD Mft2Writes;
  2999.     DWORD Mft2WriteBytes;
  3000.     struct {
  3001.         WORD   Write;
  3002.         WORD   Create;
  3003.         WORD   SetInfo;
  3004.         WORD   Flush;
  3005.     } Mft2WritesUserLevel;
  3007.     WORD   Mft2WritesFlushForLogFileFull;
  3008.     WORD   Mft2WritesLazyWriter;
  3009.     WORD   Mft2WritesUserRequest;
  3011.     DWORD RootIndexReads;
  3012.     DWORD RootIndexReadBytes;
  3013.     DWORD RootIndexWrites;
  3014.     DWORD RootIndexWriteBytes;
  3016.     DWORD BitmapReads;
  3017.     DWORD BitmapReadBytes;
  3018.     DWORD BitmapWrites;
  3019.     DWORD BitmapWriteBytes;
  3021.     WORD   BitmapWritesFlushForLogFileFull;
  3022.     WORD   BitmapWritesLazyWriter;
  3023.     WORD   BitmapWritesUserRequest;
  3025.     struct {
  3026.         WORD   Write;
  3027.         WORD   Create;
  3028.         WORD   SetInfo;
  3029.     } BitmapWritesUserLevel;
  3031.     DWORD MftBitmapReads;
  3032.     DWORD MftBitmapReadBytes;
  3033.     DWORD MftBitmapWrites;
  3034.     DWORD MftBitmapWriteBytes;
  3036.     WORD   MftBitmapWritesFlushForLogFileFull;
  3037.     WORD   MftBitmapWritesLazyWriter;
  3038.     WORD   MftBitmapWritesUserRequest;
  3040.     struct {
  3041.         WORD   Write;
  3042.         WORD   Create;
  3043.         WORD   SetInfo;
  3044.         WORD   Flush;
  3045.     } MftBitmapWritesUserLevel;
  3047.     DWORD UserIndexReads;
  3048.     DWORD UserIndexReadBytes;
  3049.     DWORD UserIndexWrites;
  3050.     DWORD UserIndexWriteBytes;
  3052.     //
  3053.     // Additions for NT 5.0
  3054.     //
  3056.     DWORD LogFileReads;
  3057.     DWORD LogFileReadBytes;
  3058.     DWORD LogFileWrites;
  3059.     DWORD LogFileWriteBytes;
  3061.     struct {
  3062.         DWORD Calls;                // number of individual calls to allocate clusters
  3063.         DWORD Clusters;             // number of clusters allocated
  3064.         DWORD Hints;                // number of times a hint was specified
  3066.         DWORD RunsReturned;         // number of runs used to satisify all the requests
  3068.         DWORD HintsHonored;         // number of times the hint was useful
  3069.         DWORD HintsClusters;        // number of clusters allocated via the hint
  3070.         DWORD Cache;                // number of times the cache was useful other than the hint
  3071.         DWORD CacheClusters;        // number of clusters allocated via the cache other than the hint
  3072.         DWORD CacheMiss;            // number of times the cache wasn't useful
  3073.         DWORD CacheMissClusters;    // number of clusters allocated without the cache
  3074.     } Allocate;
  3076. } NTFS_STATISTICS, *PNTFS_STATISTICS;
  3078. #if(_WIN32_WINNT >= 0x0500)
  3079. //
  3080. // Structure for FSCTL_SET_OBJECT_ID, FSCTL_GET_OBJECT_ID, and FSCTL_CREATE_OR_GET_OBJECT_ID
  3081. //
  3083. #if _MSC_VER >= 1200
  3084. #pragma warning(push)
  3085. #endif
  3086. #pragma warning(disable:4201)       // unnamed struct
  3088. typedef struct _FILE_OBJECTID_BUFFER {
  3090.     //
  3091.     //  This is the portion of the object id that is indexed.
  3092.     //
  3094.     BYTE  ObjectId[16];
  3096.     //
  3097.     //  This portion of the object id is not indexed, it's just
  3098.     //  some metadata for the user's benefit.
  3099.     //
  3101.     union {
  3102.         struct {
  3103.             BYTE  BirthVolumeId[16];
  3104.             BYTE  BirthObjectId[16];
  3105.             BYTE  DomainId[16];
  3106.         } ;
  3107.         BYTE  ExtendedInfo[48];
  3108.     };
  3110. } FILE_OBJECTID_BUFFER, *PFILE_OBJECTID_BUFFER;
  3112. #if _MSC_VER >= 1200
  3113. #pragma warning(pop)
  3114. #else
  3115. #pragma warning( default : 4201 )
  3116. #endif
  3118. #endif /* _WIN32_WINNT >= 0x0500 */
  3121. #if(_WIN32_WINNT >= 0x0500)
  3122. //
  3123. // Structure for FSCTL_SET_SPARSE
  3124. //
  3126. typedef struct _FILE_SET_SPARSE_BUFFER {
  3127.     BOOLEAN SetSparse;
  3128. } FILE_SET_SPARSE_BUFFER, *PFILE_SET_SPARSE_BUFFER;
  3131. #endif /* _WIN32_WINNT >= 0x0500 */
  3134. #if(_WIN32_WINNT >= 0x0500)
  3135. //
  3136. // Structure for FSCTL_SET_ZERO_DATA
  3137. //
  3139. typedef struct _FILE_ZERO_DATA_INFORMATION {
  3141.     LARGE_INTEGER FileOffset;
  3142.     LARGE_INTEGER BeyondFinalZero;
  3144. } FILE_ZERO_DATA_INFORMATION, *PFILE_ZERO_DATA_INFORMATION;
  3145. #endif /* _WIN32_WINNT >= 0x0500 */
  3147. #if(_WIN32_WINNT >= 0x0500)
  3148. //
  3149. // Structure for FSCTL_QUERY_ALLOCATED_RANGES
  3150. //
  3152. //
  3153. // Querying the allocated ranges requires an output buffer to store the
  3154. // allocated ranges and an input buffer to specify the range to query.
  3155. // The input buffer contains a single entry, the output buffer is an
  3156. // array of the following structure.
  3157. //
  3159. typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
  3161.     LARGE_INTEGER FileOffset;
  3162.     LARGE_INTEGER Length;
  3164. } FILE_ALLOCATED_RANGE_BUFFER, *PFILE_ALLOCATED_RANGE_BUFFER;
  3165. #endif /* _WIN32_WINNT >= 0x0500 */
  3167. #if(_WIN32_WINNT >= 0x0500)
  3168. //
  3169. // Structures for FSCTL_SET_ENCRYPTION, FSCTL_WRITE_RAW_ENCRYPTED, and FSCTL_READ_RAW_ENCRYPTED
  3170. //
  3172. //
  3173. //  The input buffer to set encryption indicates whether we are to encrypt/decrypt a file
  3174. //  or an individual stream.
  3175. //
  3177. typedef struct _ENCRYPTION_BUFFER {
  3179.     DWORD EncryptionOperation;
  3180.     BYTE  Private[1];
  3182. } ENCRYPTION_BUFFER, *PENCRYPTION_BUFFER;
  3184. #define FILE_SET_ENCRYPTION         0x00000001
  3185. #define FILE_CLEAR_ENCRYPTION       0x00000002
  3186. #define STREAM_SET_ENCRYPTION       0x00000003
  3187. #define STREAM_CLEAR_ENCRYPTION     0x00000004
  3189. #define MAXIMUM_ENCRYPTION_VALUE    0x00000004
  3191. //
  3192. //  The optional output buffer to set encryption indicates that the last encrypted
  3193. //  stream in a file has been marked as decrypted.
  3194. //
  3196. typedef struct _DECRYPTION_STATUS_BUFFER {
  3198.     BOOLEAN NoEncryptedStreams;
  3200. } DECRYPTION_STATUS_BUFFER, *PDECRYPTION_STATUS_BUFFER;
  3202. #define ENCRYPTION_FORMAT_DEFAULT        (0x01)
  3204. #define COMPRESSION_FORMAT_SPARSE        (0x4000)
  3206. //
  3207. //  Request Encrypted Data structure.  This is used to indicate
  3208. //  the range of the file to read.  It also describes the
  3209. //  output buffer used to return the data.
  3210. //
  3212. typedef struct _REQUEST_RAW_ENCRYPTED_DATA {
  3214.     //
  3215.     //  Requested file offset and requested length to read.
  3216.     //  The fsctl will round the starting offset down
  3217.     //  to a file system boundary.  It will also
  3218.     //  round the length up to a file system boundary.
  3219.     //
  3221.     LONGLONG FileOffset;
  3222.     DWORD Length;
  3224. } REQUEST_RAW_ENCRYPTED_DATA, *PREQUEST_RAW_ENCRYPTED_DATA;
  3226. //
  3227. //  Encrypted Data Information structure.  This structure
  3228. //  is used to return raw encrypted data from a file in
  3229. //  order to perform off-line recovery.  The data will be
  3230. //  encrypted or encrypted and compressed.  The off-line
  3231. //  service will need to use the encryption and compression
  3232. //  format information to recover the file data.  In the
  3233. //  event that the data is both encrypted and compressed then
  3234. //  the decryption must occur before decompression.  All
  3235. //  the data units below must be encrypted and compressed
  3236. //  with the same format.
  3237. //
  3238. //  The data will be returned in units.  The data unit size
  3239. //  will be fixed per request.  If the data is compressed
  3240. //  then the data unit size will be the compression unit size.
  3241. //
  3242. //  This structure is at the beginning of the buffer used to
  3243. //  return the encrypted data.  The actual raw bytes from
  3244. //  the file will follow this buffer.  The offset of the
  3245. //  raw bytes from the beginning of this structure is
  3246. //  specified in the REQUEST_RAW_ENCRYPTED_DATA structure
  3247. //  described above.
  3248. //
  3250. typedef struct _ENCRYPTED_DATA_INFO {
  3252.     //
  3253.     //  This is the file offset for the first entry in the
  3254.     //  data block array.  The file system will round
  3255.     //  the requested start offset down to a boundary
  3256.     //  that is consistent with the format of the file.
  3257.     //
  3259.     DWORDLONG StartingFileOffset;
  3261.     //
  3262.     //  Data offset in output buffer.  The output buffer
  3263.     //  begins with an ENCRYPTED_DATA_INFO structure.
  3264.     //  The file system will then store the raw bytes from
  3265.     //  disk beginning at the following offset within the
  3266.     //  output buffer.
  3267.     //
  3269.     DWORD OutputBufferOffset;
  3271.     //
  3272.     //  The number of bytes being returned that are within
  3273.     //  the size of the file.  If this value is less than
  3274.     //  (NumberOfDataBlocks << DataUnitShift), it means the
  3275.     //  end of the file occurs within this transfer.  Any
  3276.     //  data beyond file size is invalid and was never
  3277.     //  passed to the encryption driver.
  3278.     //
  3280.     DWORD BytesWithinFileSize;
  3282.     //
  3283.     //  The number of bytes being returned that are below
  3284.     //  valid data length.  If this value is less than
  3285.     //  (NumberOfDataBlocks << DataUnitShift), it means the
  3286.     //  end of the valid data occurs within this transfer.
  3287.     //  After decrypting the data from this transfer, any
  3288.     //  byte(s) beyond valid data length must be zeroed.
  3289.     //
  3291.     DWORD BytesWithinValidDataLength;
  3293.     //
  3294.     //  Code for the compression format as defined in
  3295.     //  ntrtl.h.  Note that COMPRESSION_FORMAT_NONE
  3296.     //  and COMPRESSION_FORMAT_DEFAULT are invalid if
  3297.     //  any of the described chunks are compressed.
  3298.     //
  3300.     WORD   CompressionFormat;
  3302.     //
  3303.     //  The DataUnit is the granularity used to access the
  3304.     //  disk.  It will be the same as the compression unit
  3305.     //  size for a compressed file.  For an uncompressed
  3306.     //  file, it will be some cluster-aligned power of 2 that
  3307.     //  the file system deems convenient.  A caller should
  3308.     //  not expect that successive calls will have the
  3309.     //  same data unit shift value as the previous call.
  3310.     //
  3311.     //  Since chunks and compression units are expected to be
  3312.     //  powers of 2 in size, we express them log2.  So, for
  3313.     //  example (1 << ChunkShift) == ChunkSizeInBytes.  The
  3314.     //  ClusterShift indicates how much space must be saved
  3315.     //  to successfully compress a compression unit - each
  3316.     //  successfully compressed data unit must occupy
  3317.     //  at least one cluster less in bytes than an uncompressed
  3318.     //  data block unit.
  3319.     //
  3321.     BYTE  DataUnitShift;
  3322.     BYTE  ChunkShift;
  3323.     BYTE  ClusterShift;
  3325.     //
  3326.     //  The format for the encryption.
  3327.     //
  3329.     BYTE  EncryptionFormat;
  3331.     //
  3332.     //  This is the number of entries in the data block size
  3333.     //  array.
  3334.     //
  3336.     WORD   NumberOfDataBlocks;
  3338.     //
  3339.     //  This is an array of sizes in the data block array.  There
  3340.     //  must be one entry in this array for each data block
  3341.     //  read from disk.  The size has a different meaning
  3342.     //  depending on whether the file is compressed.
  3343.     //
  3344.     //  A size of zero always indicates that the final data consists entirely
  3345.     //  of zeroes.  There is no decryption or decompression to
  3346.     //  perform.
  3347.     //
  3348.     //  If the file is compressed then the data block size indicates
  3349.     //  whether this block is compressed.  A size equal to
  3350.     //  the block size indicates that the corresponding block did
  3351.     //  not compress.  Any other non-zero size indicates the
  3352.     //  size of the compressed data which needs to be
  3353.     //  decrypted/decompressed.
  3354.     //
  3355.     //  If the file is not compressed then the data block size
  3356.     //  indicates the amount of data within the block that
  3357.     //  needs to be decrypted.  Any other non-zero size indicates
  3358.     //  that the remaining bytes in the data unit within the file
  3359.     //  consists of zeros.  An example of this is when the
  3360.     //  the read spans the valid data length of the file.  There
  3361.     //  is no data to decrypt past the valid data length.
  3362.     //
  3364.     DWORD DataBlockSize[ANYSIZE_ARRAY];
  3366. } ENCRYPTED_DATA_INFO;
  3367. typedef ENCRYPTED_DATA_INFO *PENCRYPTED_DATA_INFO;
  3368. #endif /* _WIN32_WINNT >= 0x0500 */
  3370. #if(_WIN32_WINNT >= 0x0500)
  3371. //
  3372. //  FSCTL_READ_FROM_PLEX support
  3373. //  Request Plex Read Data structure.  This is used to indicate
  3374. //  the range of the file to read.  It also describes
  3375. //  which plex to perform the read from.
  3376. //
  3378. typedef struct _PLEX_READ_DATA_REQUEST {
  3380.     //
  3381.     //  Requested offset and length to read.
  3382.     //  The offset can be the virtual offset (vbo) in to a file,
  3383.     //  or a volume. In the case of a file offset,
  3384.     //  the fsd will round the starting offset down
  3385.     //  to a file system boundary.  It will also
  3386.     //  round the length up to a file system boundary and
  3387.     //  enforce any other applicable limits.
  3388.     //
  3390.     LARGE_INTEGER ByteOffset;
  3391.     DWORD ByteLength;
  3392.     DWORD PlexNumber;
  3394. } PLEX_READ_DATA_REQUEST, *PPLEX_READ_DATA_REQUEST;
  3395. #endif /* _WIN32_WINNT >= 0x0500 */
  3397. #if(_WIN32_WINNT >= 0x0500)
  3398. //
  3399. // FSCTL_SIS_COPYFILE support
  3400. // Source and destination file names are passed in the FileNameBuffer.
  3401. // Both strings are null terminated, with the source name starting at
  3402. // the beginning of FileNameBuffer, and the destination name immediately
  3403. // following.  Length fields include terminating nulls.
  3404. //
  3406. typedef struct _SI_COPYFILE {
  3407.     DWORD SourceFileNameLength;
  3408.     DWORD DestinationFileNameLength;
  3409.     DWORD Flags;
  3410.     WCHAR FileNameBuffer[1];
  3411. } SI_COPYFILE, *PSI_COPYFILE;
  3413. #define COPYFILE_SIS_LINK       0x0001              // Copy only if source is SIS
  3414. #define COPYFILE_SIS_REPLACE    0x0002              // Replace destination if it exists, otherwise don't.
  3415. #define COPYFILE_SIS_FLAGS      0x0003
  3416. #endif /* _WIN32_WINNT >= 0x0500 */
  3418. #endif // _FILESYSTEMFSCTL_
  3421. //
  3422. // These IOCTLs are handled by hard disk volumes.
  3423. //
  3425. #define IOCTL_VOLUME_BASE   ((DWORD) 'V')
  3427. #define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS    CTL_CODE(IOCTL_VOLUME_BASE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
  3428. #define IOCTL_VOLUME_IS_CLUSTERED               CTL_CODE(IOCTL_VOLUME_BASE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
  3430. //
  3431. // Disk extent definition.
  3432. //
  3434. typedef struct _DISK_EXTENT {
  3435.     DWORD           DiskNumber;
  3436.     LARGE_INTEGER   StartingOffset;
  3437.     LARGE_INTEGER   ExtentLength;
  3438. } DISK_EXTENT, *PDISK_EXTENT;
  3440. //
  3441. // Output structure for IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS.
  3442. //
  3444. typedef struct _VOLUME_DISK_EXTENTS {
  3445.     DWORD       NumberOfDiskExtents;
  3446.     DISK_EXTENT Extents[1];
  3447. } VOLUME_DISK_EXTENTS, *PVOLUME_DISK_EXTENTS;
  3450. #endif // _WINIOCTL_