1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! This module defines the 32-Bit Windows Device I/O control codes.
7 use shared::basetsd::DWORD64;
8 use shared::devpropdef::DEVPROPKEY;
9 use shared::guiddef::GUID;
10 use shared::minwindef::{BYTE, DWORD, WORD};
11 use um::winnt::{
12 ANYSIZE_ARRAY, BOOLEAN, FILE_READ_DATA, FILE_WRITE_DATA, HANDLE, LARGE_INTEGER, WCHAR,
13 };
14 DEFINE_GUID!{GUID_DEVINTERFACE_DISK,
15 0x53f56307, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
16 DEFINE_GUID!{GUID_DEVINTERFACE_CDROM,
17 0x53f56308, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
18 DEFINE_GUID!{GUID_DEVINTERFACE_PARTITION,
19 0x53f5630a, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
20 DEFINE_GUID!{GUID_DEVINTERFACE_TAPE,
21 0x53f5630b, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
22 DEFINE_GUID!{GUID_DEVINTERFACE_WRITEONCEDISK,
23 0x53f5630c, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
24 DEFINE_GUID!{GUID_DEVINTERFACE_VOLUME,
25 0x53f5630d, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
26 DEFINE_GUID!{GUID_DEVINTERFACE_MEDIUMCHANGER,
27 0x53f56310, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
28 DEFINE_GUID!{GUID_DEVINTERFACE_FLOPPY,
29 0x53f56311, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
30 DEFINE_GUID!{GUID_DEVINTERFACE_CDCHANGER,
31 0x53f56312, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
32 DEFINE_GUID!{GUID_DEVINTERFACE_STORAGEPORT,
33 0x2accfe60, 0xc130, 0x11d2, 0xb0, 0x82, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b}
34 DEFINE_GUID!{GUID_DEVINTERFACE_VMLUN,
35 0x6f416619, 0x9f29, 0x42a5, 0xb2, 0x0b, 0x37, 0xe2, 0x19, 0xca, 0x02, 0xb0}
36 DEFINE_GUID!{GUID_DEVINTERFACE_SES,
37 0x1790c9ec, 0x47d5, 0x4df3, 0xb5, 0xaf, 0x9a, 0xdf, 0x3c, 0xf2, 0x3e, 0x48}
38 DEFINE_GUID!{WDI_STORAGE_PREDICT_FAILURE_DPS_GUID,
39 0xe9f2d03a, 0x747c, 0x41c2, 0xbb, 0x9a, 0x02, 0xc6, 0x2b, 0x6d, 0x5f, 0xcb}
40 DEFINE_GUID!{GUID_DEVINTERFACE_SERVICE_VOLUME,
41 0x6ead3d82, 0x25ec, 0x46bc, 0xb7, 0xfd, 0xc1, 0xf0, 0xdf, 0x8f, 0x50, 0x37}
42 DEFINE_GUID!{GUID_DEVINTERFACE_HIDDEN_VOLUME,
43 0x7f108a28, 0x9833, 0x4b3b, 0xb7, 0x80, 0x2c, 0x6b, 0x5f, 0xa5, 0xc0, 0x62}
44 DEFINE_GUID!{GUID_DEVINTERFACE_UNIFIED_ACCESS_RPMB,
45 0x27447c21, 0xbcc3, 0x4d07, 0xa0, 0x5b, 0xa3, 0x39, 0x5b, 0xb4, 0xee, 0xe7}
46 DEFINE_GUID!{GUID_DEVINTERFACE_SCM_PHYSICAL_DEVICE,
47 0x4283609d, 0x4dc2, 0x43be, 0xbb, 0xb4, 0x4f, 0x15, 0xdf, 0xce, 0x2c, 0x61}
48 DEFINE_GUID!{GUID_SCM_PD_HEALTH_NOTIFICATION,
49 0x9da2d386, 0x72f5, 0x4ee3, 0x81, 0x55, 0xec, 0xa0, 0x67, 0x8e, 0x3b, 0x06}
50 DEFINE_GUID!{GUID_SCM_PD_PASSTHROUGH_INVDIMM,
51 0x4309AC30, 0x0D11, 0x11E4, 0x91, 0x91, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66}
52 DEFINE_GUID!{GUID_DEVINTERFACE_COMPORT,
53 0x86E0D1E0, 0x8089, 0x11D0, 0x9C, 0xE4, 0x08, 0x00, 0x3E, 0x30, 0x1F, 0x73}
54 DEFINE_GUID!{GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR,
55 0x4D36E978, 0xE325, 0x11CE, 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18}
56 //146
57 DEFINE_DEVPROPKEY!{DEVPKEY_Storage_Portable,
58 0x4d1ebee8, 0x803, 0x4774, 0x98, 0x42, 0xb7, 0x7d, 0xb5, 0x2, 0x65, 0xe9, 2}
59 DEFINE_DEVPROPKEY!{DEVPKEY_Storage_Removable_Media,
60 0x4d1ebee8, 0x803, 0x4774, 0x98, 0x42, 0xb7, 0x7d, 0xb5, 0x2, 0x65, 0xe9, 3}
61 DEFINE_DEVPROPKEY!{DEVPKEY_Storage_System_Critical,
62 0x4d1ebee8, 0x803, 0x4774, 0x98, 0x42, 0xb7, 0x7d, 0xb5, 0x2, 0x65, 0xe9, 4}
63 //177
64 pub type DEVICE_TYPE = DWORD;
65 pub const FILE_DEVICE_BEEP: DEVICE_TYPE = 0x00000001;
66 pub const FILE_DEVICE_CD_ROM: DEVICE_TYPE = 0x00000002;
67 pub const FILE_DEVICE_CD_ROM_FILE_SYSTEM: DEVICE_TYPE = 0x00000003;
68 pub const FILE_DEVICE_CONTROLLER: DEVICE_TYPE = 0x00000004;
69 pub const FILE_DEVICE_DATALINK: DEVICE_TYPE = 0x00000005;
70 pub const FILE_DEVICE_DFS: DEVICE_TYPE = 0x00000006;
71 pub const FILE_DEVICE_DISK: DEVICE_TYPE = 0x00000007;
72 pub const FILE_DEVICE_DISK_FILE_SYSTEM: DEVICE_TYPE = 0x00000008;
73 pub const FILE_DEVICE_FILE_SYSTEM: DEVICE_TYPE = 0x00000009;
74 pub const FILE_DEVICE_INPORT_PORT: DEVICE_TYPE = 0x0000000a;
75 pub const FILE_DEVICE_KEYBOARD: DEVICE_TYPE = 0x0000000b;
76 pub const FILE_DEVICE_MAILSLOT: DEVICE_TYPE = 0x0000000c;
77 pub const FILE_DEVICE_MIDI_IN: DEVICE_TYPE = 0x0000000d;
78 pub const FILE_DEVICE_MIDI_OUT: DEVICE_TYPE = 0x0000000e;
79 pub const FILE_DEVICE_MOUSE: DEVICE_TYPE = 0x0000000f;
80 pub const FILE_DEVICE_MULTI_UNC_PROVIDER: DEVICE_TYPE = 0x00000010;
81 pub const FILE_DEVICE_NAMED_PIPE: DEVICE_TYPE = 0x00000011;
82 pub const FILE_DEVICE_NETWORK: DEVICE_TYPE = 0x00000012;
83 pub const FILE_DEVICE_NETWORK_BROWSER: DEVICE_TYPE = 0x00000013;
84 pub const FILE_DEVICE_NETWORK_FILE_SYSTEM: DEVICE_TYPE = 0x00000014;
85 pub const FILE_DEVICE_NULL: DEVICE_TYPE = 0x00000015;
86 pub const FILE_DEVICE_PARALLEL_PORT: DEVICE_TYPE = 0x00000016;
87 pub const FILE_DEVICE_PHYSICAL_NETCARD: DEVICE_TYPE = 0x00000017;
88 pub const FILE_DEVICE_PRINTER: DEVICE_TYPE = 0x00000018;
89 pub const FILE_DEVICE_SCANNER: DEVICE_TYPE = 0x00000019;
90 pub const FILE_DEVICE_SERIAL_MOUSE_PORT: DEVICE_TYPE = 0x0000001a;
91 pub const FILE_DEVICE_SERIAL_PORT: DEVICE_TYPE = 0x0000001b;
92 pub const FILE_DEVICE_SCREEN: DEVICE_TYPE = 0x0000001c;
93 pub const FILE_DEVICE_SOUND: DEVICE_TYPE = 0x0000001d;
94 pub const FILE_DEVICE_STREAMS: DEVICE_TYPE = 0x0000001e;
95 pub const FILE_DEVICE_TAPE: DEVICE_TYPE = 0x0000001f;
96 pub const FILE_DEVICE_TAPE_FILE_SYSTEM: DEVICE_TYPE = 0x00000020;
97 pub const FILE_DEVICE_TRANSPORT: DEVICE_TYPE = 0x00000021;
98 pub const FILE_DEVICE_UNKNOWN: DEVICE_TYPE = 0x00000022;
99 pub const FILE_DEVICE_VIDEO: DEVICE_TYPE = 0x00000023;
100 pub const FILE_DEVICE_VIRTUAL_DISK: DEVICE_TYPE = 0x00000024;
101 pub const FILE_DEVICE_WAVE_IN: DEVICE_TYPE = 0x00000025;
102 pub const FILE_DEVICE_WAVE_OUT: DEVICE_TYPE = 0x00000026;
103 pub const FILE_DEVICE_8042_PORT: DEVICE_TYPE = 0x00000027;
104 pub const FILE_DEVICE_NETWORK_REDIRECTOR: DEVICE_TYPE = 0x00000028;
105 pub const FILE_DEVICE_BATTERY: DEVICE_TYPE = 0x00000029;
106 pub const FILE_DEVICE_BUS_EXTENDER: DEVICE_TYPE = 0x0000002a;
107 pub const FILE_DEVICE_MODEM: DEVICE_TYPE = 0x0000002b;
108 pub const FILE_DEVICE_VDM: DEVICE_TYPE = 0x0000002c;
109 pub const FILE_DEVICE_MASS_STORAGE: DEVICE_TYPE = 0x0000002d;
110 pub const FILE_DEVICE_SMB: DEVICE_TYPE = 0x0000002e;
111 pub const FILE_DEVICE_KS: DEVICE_TYPE = 0x0000002f;
112 pub const FILE_DEVICE_CHANGER: DEVICE_TYPE = 0x00000030;
113 pub const FILE_DEVICE_SMARTCARD: DEVICE_TYPE = 0x00000031;
114 pub const FILE_DEVICE_ACPI: DEVICE_TYPE = 0x00000032;
115 pub const FILE_DEVICE_DVD: DEVICE_TYPE = 0x00000033;
116 pub const FILE_DEVICE_FULLSCREEN_VIDEO: DEVICE_TYPE = 0x00000034;
117 pub const FILE_DEVICE_DFS_FILE_SYSTEM: DEVICE_TYPE = 0x00000035;
118 pub const FILE_DEVICE_DFS_VOLUME: DEVICE_TYPE = 0x00000036;
119 pub const FILE_DEVICE_SERENUM: DEVICE_TYPE = 0x00000037;
120 pub const FILE_DEVICE_TERMSRV: DEVICE_TYPE = 0x00000038;
121 pub const FILE_DEVICE_KSEC: DEVICE_TYPE = 0x00000039;
122 pub const FILE_DEVICE_FIPS: DEVICE_TYPE = 0x0000003A;
123 pub const FILE_DEVICE_INFINIBAND: DEVICE_TYPE = 0x0000003B;
124 pub const FILE_DEVICE_VMBUS: DEVICE_TYPE = 0x0000003E;
125 pub const FILE_DEVICE_CRYPT_PROVIDER: DEVICE_TYPE = 0x0000003F;
126 pub const FILE_DEVICE_WPD: DEVICE_TYPE = 0x00000040;
127 pub const FILE_DEVICE_BLUETOOTH: DEVICE_TYPE = 0x00000041;
128 pub const FILE_DEVICE_MT_COMPOSITE: DEVICE_TYPE = 0x00000042;
129 pub const FILE_DEVICE_MT_TRANSPORT: DEVICE_TYPE = 0x00000043;
130 pub const FILE_DEVICE_BIOMETRIC: DEVICE_TYPE = 0x00000044;
131 pub const FILE_DEVICE_PMI: DEVICE_TYPE = 0x00000045;
132 pub const FILE_DEVICE_EHSTOR: DEVICE_TYPE = 0x00000046;
133 pub const FILE_DEVICE_DEVAPI: DEVICE_TYPE = 0x00000047;
134 pub const FILE_DEVICE_GPIO: DEVICE_TYPE = 0x00000048;
135 pub const FILE_DEVICE_USBEX: DEVICE_TYPE = 0x00000049;
136 pub const FILE_DEVICE_CONSOLE: DEVICE_TYPE = 0x00000050;
137 pub const FILE_DEVICE_NFP: DEVICE_TYPE = 0x00000051;
138 pub const FILE_DEVICE_SYSENV: DEVICE_TYPE = 0x00000052;
139 pub const FILE_DEVICE_VIRTUAL_BLOCK: DEVICE_TYPE = 0x00000053;
140 pub const FILE_DEVICE_POINT_OF_SERVICE: DEVICE_TYPE = 0x00000054;
141 pub const FILE_DEVICE_STORAGE_REPLICATION: DEVICE_TYPE = 0x00000055;
142 pub const FILE_DEVICE_TRUST_ENV: DEVICE_TYPE = 0x00000056;
143 pub const FILE_DEVICE_UCM: DEVICE_TYPE = 0x00000057;
144 pub const FILE_DEVICE_UCMTCPCI: DEVICE_TYPE = 0x00000058;
145 #[inline]
CTL_CODE( DeviceType: DWORD, Function: DWORD, Method: DWORD, Access: DWORD, ) -> DWORD146 pub fn CTL_CODE(
147 DeviceType: DWORD,
148 Function: DWORD,
149 Method: DWORD,
150 Access: DWORD,
151 ) -> DWORD {
152 (DeviceType << 16) | (Access << 14) | (Function << 2) | Method
153 }
154 //288
155 pub const METHOD_BUFFERED: DWORD = 0;
156 pub const METHOD_IN_DIRECT: DWORD = 1;
157 pub const METHOD_OUT_DIRECT: DWORD = 2;
158 pub const METHOD_NEITHER: DWORD = 3;
159 //317
160 pub const FILE_ANY_ACCESS: DWORD = 0;
161 pub const FILE_SPECIAL_ACCESS: DWORD = FILE_ANY_ACCESS;
162 pub const FILE_READ_ACCESS: DWORD = 0x0001;
163 pub const FILE_WRITE_ACCESS: DWORD = 0x0002;
164 //347
165 pub const IOCTL_STORAGE_BASE: DWORD = FILE_DEVICE_MASS_STORAGE;
166 pub const IOCTL_STORAGE_CHECK_VERIFY: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0200,
167 METHOD_BUFFERED, FILE_READ_ACCESS);
168 pub const IOCTL_STORAGE_CHECK_VERIFY2: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0200,
169 METHOD_BUFFERED, FILE_ANY_ACCESS);
170 pub const IOCTL_STORAGE_MEDIA_REMOVAL: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0201,
171 METHOD_BUFFERED, FILE_READ_ACCESS);
172 pub const IOCTL_STORAGE_EJECT_MEDIA: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0202,
173 METHOD_BUFFERED, FILE_READ_ACCESS);
174 pub const IOCTL_STORAGE_LOAD_MEDIA: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0203,
175 METHOD_BUFFERED, FILE_READ_ACCESS);
176 pub const IOCTL_STORAGE_LOAD_MEDIA2: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0203,
177 METHOD_BUFFERED, FILE_ANY_ACCESS);
178 pub const IOCTL_STORAGE_RESERVE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0204, METHOD_BUFFERED,
179 FILE_READ_ACCESS);
180 pub const IOCTL_STORAGE_RELEASE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0205, METHOD_BUFFERED,
181 FILE_READ_ACCESS);
182 pub const IOCTL_STORAGE_FIND_NEW_DEVICES: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0206,
183 METHOD_BUFFERED, FILE_READ_ACCESS);
184 pub const IOCTL_STORAGE_EJECTION_CONTROL: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0250,
185 METHOD_BUFFERED, FILE_ANY_ACCESS);
186 pub const IOCTL_STORAGE_MCN_CONTROL: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0251,
187 METHOD_BUFFERED, FILE_ANY_ACCESS);
188 pub const IOCTL_STORAGE_GET_MEDIA_TYPES: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0300,
189 METHOD_BUFFERED, FILE_ANY_ACCESS);
190 pub const IOCTL_STORAGE_GET_MEDIA_TYPES_EX: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0301,
191 METHOD_BUFFERED, FILE_ANY_ACCESS);
192 pub const IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0304,
193 METHOD_BUFFERED, FILE_ANY_ACCESS);
194 pub const IOCTL_STORAGE_GET_HOTPLUG_INFO: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0305,
195 METHOD_BUFFERED, FILE_ANY_ACCESS);
196 pub const IOCTL_STORAGE_SET_HOTPLUG_INFO: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0306,
197 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
198 pub const IOCTL_STORAGE_RESET_BUS: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0400, METHOD_BUFFERED,
199 FILE_READ_ACCESS);
200 pub const IOCTL_STORAGE_RESET_DEVICE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0401,
201 METHOD_BUFFERED, FILE_READ_ACCESS);
202 pub const IOCTL_STORAGE_BREAK_RESERVATION: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0405,
203 METHOD_BUFFERED, FILE_READ_ACCESS);
204 pub const IOCTL_STORAGE_PERSISTENT_RESERVE_IN: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0406,
205 METHOD_BUFFERED, FILE_READ_ACCESS);
206 pub const IOCTL_STORAGE_PERSISTENT_RESERVE_OUT: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0407,
207 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
208 pub const IOCTL_STORAGE_GET_DEVICE_NUMBER: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0420,
209 METHOD_BUFFERED, FILE_ANY_ACCESS);
210 pub const IOCTL_STORAGE_PREDICT_FAILURE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0440,
211 METHOD_BUFFERED, FILE_ANY_ACCESS);
212 pub const IOCTL_STORAGE_FAILURE_PREDICTION_CONFIG: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0441,
213 METHOD_BUFFERED, FILE_ANY_ACCESS);
214 pub const IOCTL_STORAGE_READ_CAPACITY: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0450,
215 METHOD_BUFFERED, FILE_READ_ACCESS);
216 pub const IOCTL_STORAGE_GET_DEVICE_TELEMETRY: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0470,
217 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
218 pub const IOCTL_STORAGE_DEVICE_TELEMETRY_NOTIFY: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0471,
219 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
220 pub const IOCTL_STORAGE_DEVICE_TELEMETRY_QUERY_CAPS: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE,
221 0x0472, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
222 pub const IOCTL_STORAGE_GET_DEVICE_TELEMETRY_RAW: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0473,
223 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
224 pub const IOCTL_STORAGE_QUERY_PROPERTY: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0500,
225 METHOD_BUFFERED, FILE_ANY_ACCESS);
226 pub const IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0501,
227 METHOD_BUFFERED, FILE_WRITE_ACCESS);
228 pub const IOCTL_STORAGE_GET_LB_PROVISIONING_MAP_RESOURCES: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE,
229 0x0502, METHOD_BUFFERED, FILE_READ_ACCESS);
230 pub const IOCTL_STORAGE_GET_BC_PROPERTIES: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0600,
231 METHOD_BUFFERED, FILE_READ_ACCESS);
232 pub const IOCTL_STORAGE_ALLOCATE_BC_STREAM: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0601,
233 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
234 pub const IOCTL_STORAGE_FREE_BC_STREAM: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0602,
235 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
236 pub const IOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORT: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE,
237 0x0620, METHOD_BUFFERED, FILE_ANY_ACCESS);
238 pub const IOCTL_STORAGE_START_DATA_INTEGRITY_CHECK: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0621,
239 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
240 pub const IOCTL_STORAGE_STOP_DATA_INTEGRITY_CHECK: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0622,
241 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
242 pub const OBSOLETE_IOCTL_STORAGE_RESET_BUS: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0400,
243 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
244 pub const OBSOLETE_IOCTL_STORAGE_RESET_DEVICE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0401,
245 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
246 pub const IOCTL_STORAGE_ENABLE_IDLE_POWER: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0720,
247 METHOD_BUFFERED, FILE_ANY_ACCESS);
248 pub const IOCTL_STORAGE_GET_IDLE_POWERUP_REASON: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0721,
249 METHOD_BUFFERED, FILE_ANY_ACCESS);
250 pub const IOCTL_STORAGE_POWER_ACTIVE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0722,
251 METHOD_BUFFERED, FILE_ANY_ACCESS);
252 pub const IOCTL_STORAGE_POWER_IDLE: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0723,
253 METHOD_BUFFERED, FILE_ANY_ACCESS);
254 pub const IOCTL_STORAGE_EVENT_NOTIFICATION: DWORD = CTL_CODE!(IOCTL_STORAGE_BASE, 0x0724,
255 METHOD_BUFFERED, FILE_ANY_ACCESS);
256 //565
257 STRUCT!{struct STORAGE_DEVICE_NUMBER {
258 DeviceType: DEVICE_TYPE,
259 DeviceNumber: DWORD,
260 PartitionNumber: DWORD,
261 }}
262 pub type PSTORAGE_DEVICE_NUMBER = *mut STORAGE_DEVICE_NUMBER;
263 STRUCT!{struct STORAGE_DEVICE_NUMBERS {
264 NumberOfDevices: DWORD,
265 Devices: [STORAGE_DEVICE_NUMBER; ANYSIZE_ARRAY],
266 }}
267 pub type PSTORAGE_DEVICE_NUMBERS = *mut STORAGE_DEVICE_NUMBERS;
268 //1040
269 ENUM!{enum STORAGE_QUERY_TYPE {
270 PropertyStandardQuery = 0,
271 PropertyExistsQuery,
272 PropertyMaskQuery,
273 PropertyQueryMaxDefined,
274 }}
275 pub type PSTORAGE_QUERY_TYPE = *mut STORAGE_QUERY_TYPE;
276 ENUM!{enum STORAGE_PROPERTY_ID {
277 StorageDeviceProperty = 0,
278 StorageAdapterProperty,
279 StorageDeviceIdProperty,
280 StorageDeviceUniqueIdProperty,
281 StorageDeviceWriteCacheProperty,
282 StorageMiniportProperty,
283 StorageAccessAlignmentProperty,
284 StorageDeviceSeekPenaltyProperty,
285 StorageDeviceTrimProperty,
286 StorageDeviceWriteAggregationProperty,
287 StorageDeviceDeviceTelemetryProperty,
288 StorageDeviceLBProvisioningProperty,
289 StorageDevicePowerProperty,
290 StorageDeviceCopyOffloadProperty,
291 StorageDeviceResiliencyProperty,
292 StorageDeviceMediumProductType,
293 StorageAdapterCryptoProperty,
294 StorageDeviceIoCapabilityProperty = 48,
295 StorageAdapterProtocolSpecificProperty,
296 StorageDeviceProtocolSpecificProperty,
297 StorageAdapterTemperatureProperty,
298 StorageDeviceTemperatureProperty,
299 StorageAdapterPhysicalTopologyProperty,
300 StorageDevicePhysicalTopologyProperty,
301 StorageDeviceAttributesProperty,
302 StorageDeviceManagementStatus,
303 StorageAdapterSerialNumberProperty,
304 StorageDeviceLocationProperty,
305 StorageDeviceNumaProperty,
306 StorageDeviceZonedDeviceProperty,
307 StorageDeviceUnsafeShutdownCount,
308 }}
309 pub type PSTORAGE_PROPERTY_ID = *mut STORAGE_PROPERTY_ID;
310 STRUCT!{struct STORAGE_PROPERTY_QUERY {
311 PropertyId: STORAGE_PROPERTY_ID,
312 QueryType: STORAGE_QUERY_TYPE,
313 AdditionalParameters: [BYTE; 1],
314 }}
315 pub type PSTORAGE_PROPERTY_QUERY = *mut STORAGE_PROPERTY_QUERY;
316 //1574
317 STRUCT!{struct DEVICE_TRIM_DESCRIPTOR {
318 Version: DWORD,
319 Size: DWORD,
320 TrimEnabled: BOOLEAN,
321 }}
322 pub type PDEVICE_TRIM_DESCRIPTOR = *mut DEVICE_TRIM_DESCRIPTOR;
323 //7540
324 pub const IOCTL_DISK_BASE: DWORD = FILE_DEVICE_DISK;
325 pub const IOCTL_DISK_GET_DRIVE_GEOMETRY: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0000,
326 METHOD_BUFFERED, FILE_ANY_ACCESS);
327 pub const IOCTL_DISK_GET_PARTITION_INFO: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0001,
328 METHOD_BUFFERED, FILE_READ_ACCESS);
329 pub const IOCTL_DISK_SET_PARTITION_INFO: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0002,
330 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
331 pub const IOCTL_DISK_GET_DRIVE_LAYOUT: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0003,
332 METHOD_BUFFERED, FILE_READ_ACCESS);
333 pub const IOCTL_DISK_SET_DRIVE_LAYOUT: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0004,
334 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
335 pub const IOCTL_DISK_VERIFY: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED,
336 FILE_ANY_ACCESS);
337 pub const IOCTL_DISK_FORMAT_TRACKS: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0006, METHOD_BUFFERED,
338 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
339 pub const IOCTL_DISK_REASSIGN_BLOCKS: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0007, METHOD_BUFFERED,
340 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
341 pub const IOCTL_DISK_PERFORMANCE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0008, METHOD_BUFFERED,
342 FILE_ANY_ACCESS);
343 pub const IOCTL_DISK_IS_WRITABLE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0009, METHOD_BUFFERED,
344 FILE_ANY_ACCESS);
345 pub const IOCTL_DISK_LOGGING: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000a, METHOD_BUFFERED,
346 FILE_ANY_ACCESS);
347 pub const IOCTL_DISK_FORMAT_TRACKS_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000b,
348 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
349 pub const IOCTL_DISK_HISTOGRAM_STRUCTURE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000c,
350 METHOD_BUFFERED, FILE_ANY_ACCESS);
351 pub const IOCTL_DISK_HISTOGRAM_DATA: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000d, METHOD_BUFFERED,
352 FILE_ANY_ACCESS);
353 pub const IOCTL_DISK_HISTOGRAM_RESET: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000e, METHOD_BUFFERED,
354 FILE_ANY_ACCESS);
355 pub const IOCTL_DISK_REQUEST_STRUCTURE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x000f,
356 METHOD_BUFFERED, FILE_ANY_ACCESS);
357 pub const IOCTL_DISK_REQUEST_DATA: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0010, METHOD_BUFFERED,
358 FILE_ANY_ACCESS);
359 pub const IOCTL_DISK_PERFORMANCE_OFF: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0018, METHOD_BUFFERED,
360 FILE_ANY_ACCESS);
361 pub const IOCTL_DISK_CONTROLLER_NUMBER: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0011,
362 METHOD_BUFFERED, FILE_ANY_ACCESS);
363 pub const SMART_GET_VERSION: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED,
364 FILE_READ_ACCESS);
365 pub const SMART_SEND_DRIVE_COMMAND: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED,
366 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
367 pub const SMART_RCV_DRIVE_DATA: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED,
368 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
369 pub const IOCTL_DISK_GET_PARTITION_INFO_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0012,
370 METHOD_BUFFERED, FILE_ANY_ACCESS);
371 pub const IOCTL_DISK_SET_PARTITION_INFO_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0013,
372 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
373 pub const IOCTL_DISK_GET_DRIVE_LAYOUT_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0014,
374 METHOD_BUFFERED, FILE_ANY_ACCESS);
375 pub const IOCTL_DISK_SET_DRIVE_LAYOUT_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0015,
376 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
377 pub const IOCTL_DISK_CREATE_DISK: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0016, METHOD_BUFFERED,
378 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
379 pub const IOCTL_DISK_GET_LENGTH_INFO: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0017, METHOD_BUFFERED,
380 FILE_READ_ACCESS);
381 pub const IOCTL_DISK_GET_DRIVE_GEOMETRY_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0028,
382 METHOD_BUFFERED, FILE_ANY_ACCESS);
383 pub const IOCTL_DISK_REASSIGN_BLOCKS_EX: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0029,
384 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
385 pub const IOCTL_DISK_UPDATE_DRIVE_SIZE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0032,
386 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
387 pub const IOCTL_DISK_GROW_PARTITION: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0034, METHOD_BUFFERED,
388 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
389 pub const IOCTL_DISK_GET_CACHE_INFORMATION: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0035,
390 METHOD_BUFFERED, FILE_READ_ACCESS);
391 pub const IOCTL_DISK_SET_CACHE_INFORMATION: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0036,
392 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
393 pub const IOCTL_DISK_GET_WRITE_CACHE_STATE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0037,
394 METHOD_BUFFERED, FILE_READ_ACCESS);
395 pub const OBSOLETE_DISK_GET_WRITE_CACHE_STATE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0037,
396 METHOD_BUFFERED, FILE_READ_ACCESS);
397 pub const IOCTL_DISK_DELETE_DRIVE_LAYOUT: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0040,
398 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
399 pub const IOCTL_DISK_UPDATE_PROPERTIES: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0050,
400 METHOD_BUFFERED, FILE_ANY_ACCESS);
401 pub const IOCTL_DISK_FORMAT_DRIVE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x00f3, METHOD_BUFFERED,
402 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
403 pub const IOCTL_DISK_SENSE_DEVICE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x00f8, METHOD_BUFFERED,
404 FILE_ANY_ACCESS);
405 pub const IOCTL_DISK_CHECK_VERIFY: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0200, METHOD_BUFFERED,
406 FILE_READ_ACCESS);
407 pub const IOCTL_DISK_MEDIA_REMOVAL: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0201, METHOD_BUFFERED,
408 FILE_READ_ACCESS);
409 pub const IOCTL_DISK_EJECT_MEDIA: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0202, METHOD_BUFFERED,
410 FILE_READ_ACCESS);
411 pub const IOCTL_DISK_LOAD_MEDIA: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0203, METHOD_BUFFERED,
412 FILE_READ_ACCESS);
413 pub const IOCTL_DISK_RESERVE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0204, METHOD_BUFFERED,
414 FILE_READ_ACCESS);
415 pub const IOCTL_DISK_RELEASE: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0205, METHOD_BUFFERED,
416 FILE_READ_ACCESS);
417 pub const IOCTL_DISK_FIND_NEW_DEVICES: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0206,
418 METHOD_BUFFERED, FILE_READ_ACCESS);
419 pub const IOCTL_DISK_GET_MEDIA_TYPES: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0300, METHOD_BUFFERED,
420 FILE_ANY_ACCESS);
421 pub const IOCTL_DISK_GET_DISK_ATTRIBUTES: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x003c,
422 METHOD_BUFFERED, FILE_ANY_ACCESS);
423 pub const IOCTL_DISK_SET_DISK_ATTRIBUTES: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x003d,
424 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
425 pub const IOCTL_DISK_RESET_SNAPSHOT_INFO: DWORD = CTL_CODE!(IOCTL_DISK_BASE, 0x0084,
426 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
427 //7810
428 ENUM!{enum MEDIA_TYPE {
429 Unknown,
430 F5_1Pt2_512,
431 F3_1Pt44_512,
432 F3_2Pt88_512,
433 F3_20Pt8_512,
434 F3_720_512,
435 F5_360_512,
436 F5_320_512,
437 F5_320_1024,
438 F5_180_512,
439 F5_160_512,
440 RemovableMedia,
441 FixedMedia,
442 F3_120M_512,
443 F3_640_512,
444 F5_640_512,
445 F5_720_512,
446 F3_1Pt2_512,
447 F3_1Pt23_1024,
448 F5_1Pt23_1024,
449 F3_128Mb_512,
450 F3_230Mb_512,
451 F8_256_128,
452 F3_200Mb_512,
453 F3_240M_512,
454 F3_32M_512,
455 }}
456 pub type PMEDIA_TYPE = *mut MEDIA_TYPE;
457 //7884
458 STRUCT!{struct DISK_GEOMETRY {
459 Cylinders: LARGE_INTEGER,
460 MediaType: MEDIA_TYPE,
461 TracksPerCylinder: DWORD,
462 SectorsPerTrack: DWORD,
463 BytesPerSector: DWORD,
464 }}
465 pub type PDISK_GEOMETRY = *mut DISK_GEOMETRY;
466 DEFINE_GUID!{WMI_DISK_GEOMETRY_GUID,
467 0x25007f51, 0x57c2, 0x11d1, 0xa5, 0x28, 0x00, 0xa0, 0xc9, 0x06, 0x29, 0x10}
468 STRUCT!{struct PARTITION_INFORMATION {
469 StartingOffset: LARGE_INTEGER,
470 PartitionLength: LARGE_INTEGER,
471 HiddenSectors: DWORD,
472 PartitionNumber: DWORD,
473 PartitionType: BYTE,
474 BootIndicator: BOOLEAN,
475 RecognizedPartition: BOOLEAN,
476 RewritePartition: BOOLEAN,
477 }}
478 pub type PPARTITION_INFORMATION = *mut PARTITION_INFORMATION;
479 STRUCT!{struct SET_PARTITION_INFORMATION {
480 PartitionType: BYTE,
481 }}
482 pub type PSET_PARTITION_INFORMATION = *mut SET_PARTITION_INFORMATION;
483 STRUCT!{struct DRIVE_LAYOUT_INFORMATION {
484 PartitionCount: DWORD,
485 Signature: DWORD,
486 PartitionEntry: [PARTITION_INFORMATION; 1],
487 }}
488 pub type PDRIVE_LAYOUT_INFORMATION = *mut DRIVE_LAYOUT_INFORMATION;
489 STRUCT!{struct VERIFY_INFORMATION {
490 StartingOffset: LARGE_INTEGER,
491 Length: DWORD,
492 }}
493 pub type PVERIFY_INFORMATION = *mut VERIFY_INFORMATION;
494 STRUCT!{struct REASSIGN_BLOCKS {
495 Reserved: WORD,
496 Count: WORD,
497 BlockNumber: [DWORD; 1],
498 }}
499 pub type PREASSIGN_BLOCKS = *mut REASSIGN_BLOCKS;
500 STRUCT!{#[repr(packed)] struct REASSIGN_BLOCKS_EX {
501 Reserved: WORD,
502 Count: WORD,
503 BlockNumber: [LARGE_INTEGER; 1],
504 }}
505 pub type PREASSIGN_BLOCKS_EX = *mut REASSIGN_BLOCKS_EX;
506 ENUM!{enum PARTITION_STYLE {
507 PARTITION_STYLE_MBR,
508 PARTITION_STYLE_GPT,
509 PARTITION_STYLE_RAW,
510 }}
511 STRUCT!{struct PARTITION_INFORMATION_GPT {
512 PartitionType: GUID,
513 PartitionId: GUID,
514 Attributes: DWORD64,
515 Name: [WCHAR; 36],
516 }}
517 pub type PPARTITION_INFORMATION_GPT = *mut PARTITION_INFORMATION_GPT;
518 //8059
519 STRUCT!{struct PARTITION_INFORMATION_MBR {
520 PartitionType: BYTE,
521 BootIndicator: BOOLEAN,
522 RecognizedPartition: BOOLEAN,
523 HiddenSectors: DWORD,
524 PartitionId: GUID,
525 }}
526 pub type PPARTITION_INFORMATION_MBR = *mut PARTITION_INFORMATION_MBR;
527 pub type SET_PARTITION_INFORMATION_MBR = SET_PARTITION_INFORMATION;
528 pub type SET_PARTITION_INFORMATION_GPT = PARTITION_INFORMATION_GPT;
529 STRUCT!{struct SET_PARTITION_INFORMATION_EX {
530 PartitionStyle: PARTITION_STYLE,
531 u: SET_PARTITION_INFORMATION_EX_u,
532 }}
533 UNION!{union SET_PARTITION_INFORMATION_EX_u {
534 [u64; 14],
535 Mbr Mbr_mut: SET_PARTITION_INFORMATION_MBR,
536 Gpt Gpt_mut: SET_PARTITION_INFORMATION_GPT,
537 }}
538 STRUCT!{struct CREATE_DISK_GPT {
539 DiskId: GUID,
540 MaxPartitionCount: DWORD,
541 }}
542 pub type PCREATE_DISK_GPT = *mut CREATE_DISK_GPT;
543 STRUCT!{struct CREATE_DISK_MBR {
544 Signature: DWORD,
545 }}
546 pub type PCREATE_DISK_MBR = *mut CREATE_DISK_MBR;
547 STRUCT!{struct CREATE_DISK {
548 PartitionStyle: PARTITION_STYLE,
549 u: CREATE_DISK_u,
550 }}
551 pub type PCREATE_DISK = *mut CREATE_DISK;
552 UNION!{union CREATE_DISK_u {
553 [u32; 5],
554 Mbr Mbr_mut: CREATE_DISK_MBR,
555 Gpt Gpt_mut: CREATE_DISK_GPT,
556 }}
557 STRUCT!{struct GET_LENGTH_INFORMATION {
558 Length: LARGE_INTEGER,
559 }}
560 pub type PGET_LENGTH_INFORMATION = *mut GET_LENGTH_INFORMATION;
561 STRUCT!{struct PARTITION_INFORMATION_EX {
562 PartitionStyle: PARTITION_STYLE,
563 StartingOffset: LARGE_INTEGER,
564 PartitionLength: LARGE_INTEGER,
565 PartitionNumber: DWORD,
566 RewritePartition: BOOLEAN,
567 u: PARTITION_INFORMATION_EX_u,
568 }}
569 pub type PPARTITION_INFORMATION_EX = *mut PARTITION_INFORMATION_EX;
570 UNION!{union PARTITION_INFORMATION_EX_u {
571 [u64; 14],
572 Mbr Mbr_mut: PARTITION_INFORMATION_MBR,
573 Gpt Gpt_mut: PARTITION_INFORMATION_GPT,
574 }}
575 STRUCT!{struct DRIVE_LAYOUT_INFORMATION_GPT {
576 DiskId: GUID,
577 StartingUsableOffset: LARGE_INTEGER,
578 UsableLength: LARGE_INTEGER,
579 MaxPartitionCount: DWORD,
580 }}
581 pub type PDRIVE_LAYOUT_INFORMATION_GPT = *mut DRIVE_LAYOUT_INFORMATION_GPT;
582 STRUCT!{struct DRIVE_LAYOUT_INFORMATION_MBR {
583 Signature: DWORD,
584 CheckSum: DWORD,
585 }}
586 pub type PDRIVE_LAYOUT_INFORMATION_MBR = *mut DRIVE_LAYOUT_INFORMATION_MBR;
587 STRUCT!{struct DRIVE_LAYOUT_INFORMATION_EX {
588 PartitionStyle: DWORD,
589 PartitionCount: DWORD,
590 u: DRIVE_LAYOUT_INFORMATION_EX_u,
591 PartitionEntry: [PARTITION_INFORMATION_EX; 1],
592 }}
593 pub type PDRIVE_LAYOUT_INFORMATION_EX = *mut DRIVE_LAYOUT_INFORMATION_EX;
594 UNION! {union DRIVE_LAYOUT_INFORMATION_EX_u {
595 [u64; 5],
596 Mbr Mbr_mut: DRIVE_LAYOUT_INFORMATION_MBR,
597 Gpt Gpt_mut: DRIVE_LAYOUT_INFORMATION_GPT,
598 }}
599 //8350
600 STRUCT!{struct DISK_GEOMETRY_EX {
601 Geometry: DISK_GEOMETRY,
602 DiskSize: LARGE_INTEGER,
603 Data: [BYTE; 1],
604 }}
605 //8933
606 pub const IOCTL_CHANGER_BASE: DWORD = FILE_DEVICE_CHANGER;
607 pub const IOCTL_CHANGER_GET_PARAMETERS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0000,
608 METHOD_BUFFERED, FILE_READ_ACCESS);
609 pub const IOCTL_CHANGER_GET_STATUS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0001,
610 METHOD_BUFFERED, FILE_READ_ACCESS);
611 pub const IOCTL_CHANGER_GET_PRODUCT_DATA: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0002,
612 METHOD_BUFFERED, FILE_READ_ACCESS);
613 pub const IOCTL_CHANGER_SET_ACCESS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0004,
614 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
615 pub const IOCTL_CHANGER_GET_ELEMENT_STATUS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0005,
616 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
617 pub const IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0006,
618 METHOD_BUFFERED, FILE_READ_ACCESS);
619 pub const IOCTL_CHANGER_SET_POSITION: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0007,
620 METHOD_BUFFERED, FILE_READ_ACCESS);
621 pub const IOCTL_CHANGER_EXCHANGE_MEDIUM: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0008,
622 METHOD_BUFFERED, FILE_READ_ACCESS);
623 pub const IOCTL_CHANGER_MOVE_MEDIUM: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x0009,
624 METHOD_BUFFERED, FILE_READ_ACCESS);
625 pub const IOCTL_CHANGER_REINITIALIZE_TRANSPORT: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x000A,
626 METHOD_BUFFERED, FILE_READ_ACCESS);
627 pub const IOCTL_CHANGER_QUERY_VOLUME_TAGS: DWORD = CTL_CODE!(IOCTL_CHANGER_BASE, 0x000B,
628 METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS);
629 pub const IOCTL_SERIAL_LSRMST_INSERT: DWORD = CTL_CODE!(FILE_DEVICE_SERIAL_PORT, 31,
630 METHOD_BUFFERED, FILE_ANY_ACCESS);
631 pub const IOCTL_SERENUM_EXPOSE_HARDWARE: DWORD = CTL_CODE!(FILE_DEVICE_SERENUM, 128,
632 METHOD_BUFFERED, FILE_ANY_ACCESS);
633 pub const IOCTL_SERENUM_REMOVE_HARDWARE: DWORD = CTL_CODE!(FILE_DEVICE_SERENUM, 129,
634 METHOD_BUFFERED, FILE_ANY_ACCESS);
635 pub const IOCTL_SERENUM_PORT_DESC: DWORD = CTL_CODE!(FILE_DEVICE_SERENUM, 130,
636 METHOD_BUFFERED, FILE_ANY_ACCESS);
637 pub const IOCTL_SERENUM_GET_PORT_NAME: DWORD = CTL_CODE!(FILE_DEVICE_SERENUM, 131,
638 METHOD_BUFFERED, FILE_ANY_ACCESS);
639 //9717
640 pub const FSCTL_REQUEST_OPLOCK_LEVEL_1: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 0,
641 METHOD_BUFFERED, FILE_ANY_ACCESS);
642 pub const FSCTL_REQUEST_OPLOCK_LEVEL_2: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 1,
643 METHOD_BUFFERED, FILE_ANY_ACCESS);
644 pub const FSCTL_REQUEST_BATCH_OPLOCK: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 2,
645 METHOD_BUFFERED, FILE_ANY_ACCESS);
646 pub const FSCTL_OPLOCK_BREAK_ACKNOWLEDGE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 3,
647 METHOD_BUFFERED, FILE_ANY_ACCESS);
648 pub const FSCTL_OPBATCH_ACK_CLOSE_PENDING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 4,
649 METHOD_BUFFERED, FILE_ANY_ACCESS);
650 pub const FSCTL_OPLOCK_BREAK_NOTIFY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 5,
651 METHOD_BUFFERED, FILE_ANY_ACCESS);
652 pub const FSCTL_LOCK_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED,
653 FILE_ANY_ACCESS);
654 pub const FSCTL_UNLOCK_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 7, METHOD_BUFFERED,
655 FILE_ANY_ACCESS);
656 pub const FSCTL_DISMOUNT_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 8, METHOD_BUFFERED,
657 FILE_ANY_ACCESS);
658 pub const FSCTL_IS_VOLUME_MOUNTED: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 10,
659 METHOD_BUFFERED, FILE_ANY_ACCESS);
660 pub const FSCTL_IS_PATHNAME_VALID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 11,
661 METHOD_BUFFERED, FILE_ANY_ACCESS);
662 pub const FSCTL_MARK_VOLUME_DIRTY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 12,
663 METHOD_BUFFERED, FILE_ANY_ACCESS);
664 pub const FSCTL_QUERY_RETRIEVAL_POINTERS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 14,
665 METHOD_NEITHER, FILE_ANY_ACCESS);
666 pub const FSCTL_GET_COMPRESSION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 15, METHOD_BUFFERED,
667 FILE_ANY_ACCESS);
668 pub const FSCTL_SET_COMPRESSION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 16, METHOD_BUFFERED,
669 FILE_READ_DATA | FILE_WRITE_DATA);
670 pub const FSCTL_SET_BOOTLOADER_ACCESSED: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 19,
671 METHOD_NEITHER, FILE_ANY_ACCESS);
672 pub const FSCTL_MARK_AS_SYSTEM_HIVE: DWORD = FSCTL_SET_BOOTLOADER_ACCESSED;
673 pub const FSCTL_OPLOCK_BREAK_ACK_NO_2: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 20,
674 METHOD_BUFFERED, FILE_ANY_ACCESS);
675 pub const FSCTL_INVALIDATE_VOLUMES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 21,
676 METHOD_BUFFERED, FILE_ANY_ACCESS);
677 pub const FSCTL_QUERY_FAT_BPB: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 22, METHOD_BUFFERED,
678 FILE_ANY_ACCESS);
679 pub const FSCTL_REQUEST_FILTER_OPLOCK: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 23,
680 METHOD_BUFFERED, FILE_ANY_ACCESS);
681 pub const FSCTL_FILESYSTEM_GET_STATISTICS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 24,
682 METHOD_BUFFERED, FILE_ANY_ACCESS);
683 pub const FSCTL_GET_NTFS_VOLUME_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 25,
684 METHOD_BUFFERED, FILE_ANY_ACCESS);
685 pub const FSCTL_GET_NTFS_FILE_RECORD: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 26,
686 METHOD_BUFFERED, FILE_ANY_ACCESS);
687 pub const FSCTL_GET_VOLUME_BITMAP: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 27, METHOD_NEITHER,
688 FILE_ANY_ACCESS);
689 pub const FSCTL_GET_RETRIEVAL_POINTERS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 28,
690 METHOD_NEITHER, FILE_ANY_ACCESS);
691 pub const FSCTL_MOVE_FILE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 29, METHOD_BUFFERED,
692 FILE_SPECIAL_ACCESS);
693 pub const FSCTL_IS_VOLUME_DIRTY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 30, METHOD_BUFFERED,
694 FILE_ANY_ACCESS);
695 pub const FSCTL_ALLOW_EXTENDED_DASD_IO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 32,
696 METHOD_NEITHER, FILE_ANY_ACCESS);
697 pub const FSCTL_FIND_FILES_BY_SID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 35, METHOD_NEITHER,
698 FILE_ANY_ACCESS);
699 pub const FSCTL_SET_OBJECT_ID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 38, METHOD_BUFFERED,
700 FILE_SPECIAL_ACCESS);
701 pub const FSCTL_GET_OBJECT_ID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 39, METHOD_BUFFERED,
702 FILE_ANY_ACCESS);
703 pub const FSCTL_DELETE_OBJECT_ID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 40, METHOD_BUFFERED,
704 FILE_SPECIAL_ACCESS);
705 pub const FSCTL_SET_REPARSE_POINT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 41,
706 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
707 pub const FSCTL_GET_REPARSE_POINT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 42,
708 METHOD_BUFFERED, FILE_ANY_ACCESS);
709 pub const FSCTL_DELETE_REPARSE_POINT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 43,
710 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
711 pub const FSCTL_ENUM_USN_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 44,
712 METHOD_NEITHER, FILE_ANY_ACCESS);
713 pub const FSCTL_SECURITY_ID_CHECK: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 45, METHOD_NEITHER,
714 FILE_READ_DATA);
715 pub const FSCTL_READ_USN_JOURNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 46, METHOD_NEITHER,
716 FILE_ANY_ACCESS);
717 pub const FSCTL_SET_OBJECT_ID_EXTENDED: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 47,
718 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
719 pub const FSCTL_CREATE_OR_GET_OBJECT_ID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 48,
720 METHOD_BUFFERED, FILE_ANY_ACCESS);
721 pub const FSCTL_SET_SPARSE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 49, METHOD_BUFFERED,
722 FILE_SPECIAL_ACCESS);
723 pub const FSCTL_SET_ZERO_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 50, METHOD_BUFFERED,
724 FILE_WRITE_DATA);
725 pub const FSCTL_QUERY_ALLOCATED_RANGES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 51,
726 METHOD_NEITHER, FILE_READ_DATA);
727 pub const FSCTL_ENABLE_UPGRADE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 52, METHOD_BUFFERED,
728 FILE_WRITE_DATA);
729 pub const FSCTL_SET_ENCRYPTION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 53, METHOD_NEITHER,
730 FILE_ANY_ACCESS);
731 pub const FSCTL_ENCRYPTION_FSCTL_IO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 54,
732 METHOD_NEITHER, FILE_ANY_ACCESS);
733 pub const FSCTL_WRITE_RAW_ENCRYPTED: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 55,
734 METHOD_NEITHER, FILE_SPECIAL_ACCESS);
735 pub const FSCTL_READ_RAW_ENCRYPTED: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 56,
736 METHOD_NEITHER, FILE_SPECIAL_ACCESS);
737 pub const FSCTL_CREATE_USN_JOURNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 57,
738 METHOD_NEITHER, FILE_ANY_ACCESS);
739 pub const FSCTL_READ_FILE_USN_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 58,
740 METHOD_NEITHER, FILE_ANY_ACCESS);
741 pub const FSCTL_WRITE_USN_CLOSE_RECORD: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 59,
742 METHOD_NEITHER, FILE_ANY_ACCESS);
743 pub const FSCTL_EXTEND_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 60, METHOD_BUFFERED,
744 FILE_ANY_ACCESS);
745 pub const FSCTL_QUERY_USN_JOURNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 61,
746 METHOD_BUFFERED, FILE_ANY_ACCESS);
747 pub const FSCTL_DELETE_USN_JOURNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 62,
748 METHOD_BUFFERED, FILE_ANY_ACCESS);
749 pub const FSCTL_MARK_HANDLE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 63, METHOD_BUFFERED,
750 FILE_ANY_ACCESS);
751 pub const FSCTL_SIS_COPYFILE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 64, METHOD_BUFFERED,
752 FILE_ANY_ACCESS);
753 pub const FSCTL_SIS_LINK_FILES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 65, METHOD_BUFFERED,
754 FILE_READ_DATA | FILE_WRITE_DATA);
755 pub const FSCTL_RECALL_FILE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 69, METHOD_NEITHER,
756 FILE_ANY_ACCESS);
757 pub const FSCTL_READ_FROM_PLEX: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 71, METHOD_OUT_DIRECT,
758 FILE_READ_DATA);
759 pub const FSCTL_FILE_PREFETCH: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 72, METHOD_BUFFERED,
760 FILE_SPECIAL_ACCESS);
761 pub const FSCTL_MAKE_MEDIA_COMPATIBLE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 76,
762 METHOD_BUFFERED, FILE_WRITE_DATA);
763 pub const FSCTL_SET_DEFECT_MANAGEMENT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 77,
764 METHOD_BUFFERED, FILE_WRITE_DATA);
765 pub const FSCTL_QUERY_SPARING_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 78,
766 METHOD_BUFFERED, FILE_ANY_ACCESS);
767 pub const FSCTL_QUERY_ON_DISK_VOLUME_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 79,
768 METHOD_BUFFERED, FILE_ANY_ACCESS);
769 pub const FSCTL_SET_VOLUME_COMPRESSION_STATE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 80,
770 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
771 pub const FSCTL_TXFS_MODIFY_RM: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 81, METHOD_BUFFERED,
772 FILE_WRITE_DATA);
773 pub const FSCTL_TXFS_QUERY_RM_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 82,
774 METHOD_BUFFERED, FILE_READ_DATA);
775 pub const FSCTL_TXFS_ROLLFORWARD_REDO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 84,
776 METHOD_BUFFERED, FILE_WRITE_DATA);
777 pub const FSCTL_TXFS_ROLLFORWARD_UNDO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 85,
778 METHOD_BUFFERED, FILE_WRITE_DATA);
779 pub const FSCTL_TXFS_START_RM: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 86, METHOD_BUFFERED,
780 FILE_WRITE_DATA);
781 pub const FSCTL_TXFS_SHUTDOWN_RM: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 87, METHOD_BUFFERED,
782 FILE_WRITE_DATA);
783 pub const FSCTL_TXFS_READ_BACKUP_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 88,
784 METHOD_BUFFERED, FILE_READ_DATA);
785 pub const FSCTL_TXFS_WRITE_BACKUP_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 89,
786 METHOD_BUFFERED, FILE_WRITE_DATA);
787 pub const FSCTL_TXFS_CREATE_SECONDARY_RM: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 90,
788 METHOD_BUFFERED, FILE_WRITE_DATA);
789 pub const FSCTL_TXFS_GET_METADATA_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 91,
790 METHOD_BUFFERED, FILE_READ_DATA);
791 pub const FSCTL_TXFS_GET_TRANSACTED_VERSION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 92,
792 METHOD_BUFFERED, FILE_READ_DATA);
793 pub const FSCTL_TXFS_SAVEPOINT_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 94,
794 METHOD_BUFFERED, FILE_WRITE_DATA);
795 pub const FSCTL_TXFS_CREATE_MINIVERSION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 95,
796 METHOD_BUFFERED, FILE_WRITE_DATA);
797 pub const FSCTL_TXFS_TRANSACTION_ACTIVE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 99,
798 METHOD_BUFFERED, FILE_READ_DATA);
799 pub const FSCTL_SET_ZERO_ON_DEALLOCATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 101,
800 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
801 pub const FSCTL_SET_REPAIR: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 102, METHOD_BUFFERED,
802 FILE_ANY_ACCESS);
803 pub const FSCTL_GET_REPAIR: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 103, METHOD_BUFFERED,
804 FILE_ANY_ACCESS);
805 pub const FSCTL_WAIT_FOR_REPAIR: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 104, METHOD_BUFFERED,
806 FILE_ANY_ACCESS);
807 pub const FSCTL_INITIATE_REPAIR: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 106, METHOD_BUFFERED,
808 FILE_ANY_ACCESS);
809 pub const FSCTL_CSC_INTERNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 107, METHOD_NEITHER,
810 FILE_ANY_ACCESS);
811 pub const FSCTL_SHRINK_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 108, METHOD_BUFFERED,
812 FILE_SPECIAL_ACCESS);
813 pub const FSCTL_SET_SHORT_NAME_BEHAVIOR: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 109,
814 METHOD_BUFFERED, FILE_ANY_ACCESS);
815 pub const FSCTL_DFSR_SET_GHOST_HANDLE_STATE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 110,
816 METHOD_BUFFERED, FILE_ANY_ACCESS);
817 pub const FSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM,
818 120, METHOD_BUFFERED, FILE_READ_DATA);
819 pub const FSCTL_TXFS_LIST_TRANSACTIONS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 121,
820 METHOD_BUFFERED, FILE_READ_DATA);
821 pub const FSCTL_QUERY_PAGEFILE_ENCRYPTION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 122,
822 METHOD_BUFFERED, FILE_ANY_ACCESS);
823 pub const FSCTL_RESET_VOLUME_ALLOCATION_HINTS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 123,
824 METHOD_BUFFERED, FILE_ANY_ACCESS);
825 pub const FSCTL_QUERY_DEPENDENT_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 124,
826 METHOD_BUFFERED, FILE_ANY_ACCESS);
827 pub const FSCTL_SD_GLOBAL_CHANGE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 125,
828 METHOD_BUFFERED, FILE_ANY_ACCESS);
829 pub const FSCTL_TXFS_READ_BACKUP_INFORMATION2: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 126,
830 METHOD_BUFFERED, FILE_ANY_ACCESS);
831 pub const FSCTL_LOOKUP_STREAM_FROM_CLUSTER: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 127,
832 METHOD_BUFFERED, FILE_ANY_ACCESS);
833 pub const FSCTL_TXFS_WRITE_BACKUP_INFORMATION2: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 128,
834 METHOD_BUFFERED, FILE_ANY_ACCESS);
835 pub const FSCTL_FILE_TYPE_NOTIFICATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 129,
836 METHOD_BUFFERED, FILE_ANY_ACCESS);
837 pub const FSCTL_FILE_LEVEL_TRIM: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 130, METHOD_BUFFERED,
838 FILE_WRITE_DATA);
839 pub const FSCTL_GET_BOOT_AREA_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 140,
840 METHOD_BUFFERED, FILE_ANY_ACCESS);
841 pub const FSCTL_GET_RETRIEVAL_POINTER_BASE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 141,
842 METHOD_BUFFERED, FILE_ANY_ACCESS);
843 pub const FSCTL_SET_PERSISTENT_VOLUME_STATE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 142,
844 METHOD_BUFFERED, FILE_ANY_ACCESS);
845 pub const FSCTL_QUERY_PERSISTENT_VOLUME_STATE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 143,
846 METHOD_BUFFERED, FILE_ANY_ACCESS);
847 pub const FSCTL_REQUEST_OPLOCK: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 144, METHOD_BUFFERED,
848 FILE_ANY_ACCESS);
849 pub const FSCTL_CSV_TUNNEL_REQUEST: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 145,
850 METHOD_BUFFERED, FILE_ANY_ACCESS);
851 pub const FSCTL_IS_CSV_FILE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 146, METHOD_BUFFERED,
852 FILE_ANY_ACCESS);
853 pub const FSCTL_QUERY_FILE_SYSTEM_RECOGNITION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 147,
854 METHOD_BUFFERED, FILE_ANY_ACCESS);
855 pub const FSCTL_CSV_GET_VOLUME_PATH_NAME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 148,
856 METHOD_BUFFERED, FILE_ANY_ACCESS);
857 pub const FSCTL_CSV_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT: DWORD = CTL_CODE!(
858 FILE_DEVICE_FILE_SYSTEM, 149, METHOD_BUFFERED, FILE_ANY_ACCESS);
859 pub const FSCTL_CSV_GET_VOLUME_PATH_NAMES_FOR_VOLUME_NAME: DWORD = CTL_CODE!(
860 FILE_DEVICE_FILE_SYSTEM, 150, METHOD_BUFFERED, FILE_ANY_ACCESS);
861 pub const FSCTL_IS_FILE_ON_CSV_VOLUME: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 151,
862 METHOD_BUFFERED, FILE_ANY_ACCESS);
863 pub const FSCTL_CORRUPTION_HANDLING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 152,
864 METHOD_BUFFERED, FILE_ANY_ACCESS);
865 pub const FSCTL_OFFLOAD_READ: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 153, METHOD_BUFFERED,
866 FILE_READ_ACCESS);
867 pub const FSCTL_OFFLOAD_WRITE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 154, METHOD_BUFFERED,
868 FILE_WRITE_ACCESS);
869 pub const FSCTL_CSV_INTERNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 155, METHOD_BUFFERED,
870 FILE_ANY_ACCESS);
871 pub const FSCTL_SET_PURGE_FAILURE_MODE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 156,
872 METHOD_BUFFERED, FILE_ANY_ACCESS);
873 pub const FSCTL_QUERY_FILE_LAYOUT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 157,
874 METHOD_NEITHER, FILE_ANY_ACCESS);
875 pub const FSCTL_IS_VOLUME_OWNED_BYCSVFS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 158,
876 METHOD_BUFFERED, FILE_ANY_ACCESS);
877 pub const FSCTL_GET_INTEGRITY_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 159,
878 METHOD_BUFFERED, FILE_ANY_ACCESS);
879 pub const FSCTL_SET_INTEGRITY_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 160,
880 METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA);
881 pub const FSCTL_QUERY_FILE_REGIONS: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 161,
882 METHOD_BUFFERED, FILE_ANY_ACCESS);
883 pub const FSCTL_DEDUP_FILE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 165, METHOD_BUFFERED,
884 FILE_ANY_ACCESS);
885 pub const FSCTL_DEDUP_QUERY_FILE_HASHES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 166,
886 METHOD_NEITHER, FILE_READ_DATA);
887 pub const FSCTL_DEDUP_QUERY_RANGE_STATE: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 167,
888 METHOD_NEITHER, FILE_READ_DATA);
889 pub const FSCTL_DEDUP_QUERY_REPARSE_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 168,
890 METHOD_NEITHER, FILE_ANY_ACCESS);
891 pub const FSCTL_RKF_INTERNAL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 171, METHOD_NEITHER,
892 FILE_ANY_ACCESS);
893 pub const FSCTL_SCRUB_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 172, METHOD_BUFFERED,
894 FILE_ANY_ACCESS);
895 pub const FSCTL_REPAIR_COPIES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 173, METHOD_BUFFERED,
896 FILE_READ_DATA | FILE_WRITE_DATA);
897 pub const FSCTL_DISABLE_LOCAL_BUFFERING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 174,
898 METHOD_BUFFERED, FILE_ANY_ACCESS);
899 pub const FSCTL_CSV_MGMT_LOCK: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 175, METHOD_BUFFERED,
900 FILE_ANY_ACCESS);
901 pub const FSCTL_CSV_QUERY_DOWN_LEVEL_FILE_SYSTEM_CHARACTERISTICS: DWORD = CTL_CODE!(
902 FILE_DEVICE_FILE_SYSTEM, 176, METHOD_BUFFERED, FILE_ANY_ACCESS);
903 pub const FSCTL_ADVANCE_FILE_ID: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 177, METHOD_BUFFERED,
904 FILE_ANY_ACCESS);
905 pub const FSCTL_CSV_SYNC_TUNNEL_REQUEST: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 178,
906 METHOD_BUFFERED, FILE_ANY_ACCESS);
907 pub const FSCTL_CSV_QUERY_VETO_FILE_DIRECT_IO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 179,
908 METHOD_BUFFERED, FILE_ANY_ACCESS);
909 pub const FSCTL_WRITE_USN_REASON: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 180,
910 METHOD_BUFFERED, FILE_ANY_ACCESS);
911 pub const FSCTL_CSV_CONTROL: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 181, METHOD_BUFFERED,
912 FILE_ANY_ACCESS);
913 pub const FSCTL_GET_REFS_VOLUME_DATA: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 182,
914 METHOD_BUFFERED, FILE_ANY_ACCESS);
915 pub const FSCTL_CSV_H_BREAKING_SYNC_TUNNEL_REQUEST: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM,
916 185, METHOD_BUFFERED, FILE_ANY_ACCESS);
917 pub const FSCTL_QUERY_STORAGE_CLASSES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 187,
918 METHOD_BUFFERED, FILE_ANY_ACCESS);
919 pub const FSCTL_QUERY_REGION_INFO: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 188,
920 METHOD_BUFFERED, FILE_ANY_ACCESS);
921 pub const FSCTL_USN_TRACK_MODIFIED_RANGES: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 189,
922 METHOD_BUFFERED, FILE_ANY_ACCESS);
923 pub const FSCTL_QUERY_SHARED_VIRTUAL_DISK_SUPPORT: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM,
924 192, METHOD_BUFFERED, FILE_ANY_ACCESS);
925 pub const FSCTL_SVHDX_SYNC_TUNNEL_REQUEST: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 193,
926 METHOD_BUFFERED, FILE_ANY_ACCESS);
927 pub const FSCTL_SVHDX_SET_INITIATOR_INFORMATION: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 194,
928 METHOD_BUFFERED, FILE_ANY_ACCESS);
929 pub const FSCTL_SET_EXTERNAL_BACKING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 195,
930 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
931 pub const FSCTL_GET_EXTERNAL_BACKING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 196,
932 METHOD_BUFFERED, FILE_ANY_ACCESS);
933 pub const FSCTL_DELETE_EXTERNAL_BACKING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 197,
934 METHOD_BUFFERED, FILE_SPECIAL_ACCESS);
935 pub const FSCTL_ENUM_EXTERNAL_BACKING: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 198,
936 METHOD_BUFFERED, FILE_ANY_ACCESS);
937 pub const FSCTL_ENUM_OVERLAY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 199, METHOD_NEITHER,
938 FILE_ANY_ACCESS);
939 pub const FSCTL_ADD_OVERLAY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 204, METHOD_BUFFERED,
940 FILE_WRITE_DATA);
941 pub const FSCTL_REMOVE_OVERLAY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 205, METHOD_BUFFERED,
942 FILE_WRITE_DATA);
943 pub const FSCTL_UPDATE_OVERLAY: DWORD = CTL_CODE!(FILE_DEVICE_FILE_SYSTEM, 206, METHOD_BUFFERED,
944 FILE_WRITE_DATA);
945 // FILE_DEVICE_AVIO is defined nowhere
946 //pub const IOCTL_AVIO_ALLOCATE_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 1, METHOD_BUFFERED,
947 // FILE_SPECIAL_ACCESS);
948 //pub const IOCTL_AVIO_FREE_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 2, METHOD_BUFFERED,
949 // FILE_SPECIAL_ACCESS);
950 //pub const IOCTL_AVIO_MODIFY_STREAM: DWORD = CTL_CODE!(FILE_DEVICE_AVIO, 3, METHOD_BUFFERED,
951 // FILE_SPECIAL_ACCESS);
952 STRUCT!{struct PATHNAME_BUFFER {
953 PathNameLength: DWORD,
954 Name: [WCHAR; 1],
955 }}
956 pub type PPATHNAME_BUFFER = *mut PATHNAME_BUFFER;
957 STRUCT!{struct FSCTL_QUERY_FAT_BPB_BUFFER {
958 First0x24BytesOfBootSector: [BYTE; 0x24],
959 }}
960 pub type PFSCTL_QUERY_FAT_BPB_BUFFER = *mut FSCTL_QUERY_FAT_BPB_BUFFER;
961 STRUCT!{struct NTFS_VOLUME_DATA_BUFFER {
962 VolumeSerialNumber: LARGE_INTEGER,
963 NumberSectors: LARGE_INTEGER,
964 TotalClusters: LARGE_INTEGER,
965 FreeClusters: LARGE_INTEGER,
966 TotalReserved: LARGE_INTEGER,
967 BytesPerSector: DWORD,
968 BytesPerCluster: DWORD,
969 BytesPerFileRecordSegment: DWORD,
970 ClustersPerFileRecordSegment: DWORD,
971 MftValidDataLength: LARGE_INTEGER,
972 MftStartLcn: LARGE_INTEGER,
973 Mft2StartLcn: LARGE_INTEGER,
974 MftZoneStart: LARGE_INTEGER,
975 MftZoneEnd: LARGE_INTEGER,
976 }}
977 pub type PNTFS_VOLUME_DATA_BUFFER = *mut NTFS_VOLUME_DATA_BUFFER;
978 STRUCT!{struct NTFS_EXTENDED_VOLUME_DATA {
979 ByteCount: DWORD,
980 MajorVersion: WORD,
981 MinorVersion: WORD,
982 BytesPerPhysicalSector: DWORD,
983 LfsMajorVersion: WORD,
984 LfsMinorVersion: WORD,
985 MaxDeviceTrimExtentCount: DWORD,
986 MaxDeviceTrimByteCount: DWORD,
987 MaxVolumeTrimExtentCount: DWORD,
988 MaxVolumeTrimByteCount: DWORD,
989 }}
990 pub type PNTFS_EXTENDED_VOLUME_DATA = *mut NTFS_EXTENDED_VOLUME_DATA;
991 STRUCT!{struct REFS_VOLUME_DATA_BUFFER {
992 ByteCount: DWORD,
993 MajorVersion: DWORD,
994 MinorVersion: DWORD,
995 BytesPerPhysicalSector: DWORD,
996 VolumeSerialNumber: LARGE_INTEGER,
997 NumberSectors: LARGE_INTEGER,
998 TotalClusters: LARGE_INTEGER,
999 FreeClusters: LARGE_INTEGER,
1000 TotalReserved: LARGE_INTEGER,
1001 BytesPerSector: DWORD,
1002 BytesPerCluster: DWORD,
1003 MaximumSizeOfResidentFile: LARGE_INTEGER,
1004 Reserved: [LARGE_INTEGER; 10],
1005 }}
1006 pub type PREFS_VOLUME_DATA_BUFFER = *mut REFS_VOLUME_DATA_BUFFER;
1007 STRUCT!{struct STARTING_LCN_INPUT_BUFFER {
1008 StartingLcn: LARGE_INTEGER,
1009 }}
1010 pub type PSTARTING_LCN_INPUT_BUFFER = *mut STARTING_LCN_INPUT_BUFFER;
1011 STRUCT!{struct VOLUME_BITMAP_BUFFER {
1012 StartingLcn: LARGE_INTEGER,
1013 BitmapSize: LARGE_INTEGER,
1014 Buffer: [BYTE; 1],
1015 }}
1016 pub type PVOLUME_BITMAP_BUFFER = *mut VOLUME_BITMAP_BUFFER;
1017 STRUCT!{struct STARTING_VCN_INPUT_BUFFER {
1018 StartingVcn: LARGE_INTEGER,
1019 }}
1020 pub type PSTARTING_VCN_INPUT_BUFFER = *mut STARTING_VCN_INPUT_BUFFER;
1021 STRUCT!{struct RETRIEVAL_POINTERS_BUFFER_INTERNAL {
1022 NextVcn: LARGE_INTEGER,
1023 Lcn: LARGE_INTEGER,
1024 }}
1025 STRUCT!{struct RETRIEVAL_POINTERS_BUFFER {
1026 ExtentCount: DWORD,
1027 StartingVcn: LARGE_INTEGER,
1028 Extents: [RETRIEVAL_POINTERS_BUFFER_INTERNAL; 1],
1029 }}
1030 pub type PRETRIEVAL_POINTERS_BUFFER = *mut RETRIEVAL_POINTERS_BUFFER;
1031 STRUCT!{struct NTFS_FILE_RECORD_INPUT_BUFFER {
1032 FileReferenceNumber: LARGE_INTEGER,
1033 }}
1034 pub type PNTFS_FILE_RECORD_INPUT_BUFFER = *mut NTFS_FILE_RECORD_INPUT_BUFFER;
1035 STRUCT!{struct NTFS_FILE_RECORD_OUTPUT_BUFFER {
1036 FileReferenceNumber: LARGE_INTEGER,
1037 FileRecordLength: DWORD,
1038 FileRecordBuffer: [BYTE; 1],
1039 }}
1040 pub type PNTFS_FILE_RECORD_OUTPUT_BUFFER = *mut NTFS_FILE_RECORD_OUTPUT_BUFFER;
1041 STRUCT!{struct MOVE_FILE_DATA {
1042 FileHandle: HANDLE,
1043 StartingVcn: LARGE_INTEGER,
1044 StartingLcn: LARGE_INTEGER,
1045 ClusterCount: DWORD,
1046 }}
1047 pub type PMOVE_FILE_DATA = *mut MOVE_FILE_DATA;
1048 STRUCT!{struct MOVE_FILE_RECORD_DATA {
1049 FileHandle: HANDLE,
1050 SourceFileRecord: LARGE_INTEGER,
1051 TargetFileRecord: LARGE_INTEGER,
1052 }}
1053 pub type PMOVE_FILE_RECORD_DATA = *mut MOVE_FILE_RECORD_DATA;
1054 //15468
1055 pub const IOCTL_VOLUME_BASE: DWORD = 0x00000056;
1056 pub const IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS: DWORD = CTL_CODE!(IOCTL_VOLUME_BASE, 0,
1057 METHOD_BUFFERED, FILE_ANY_ACCESS);
1058 STRUCT!{struct DISK_EXTENT {
1059 DiskNumber: DWORD,
1060 StartingOffset: LARGE_INTEGER,
1061 ExtentLength: LARGE_INTEGER,
1062 }}
1063 pub type PDISK_EXTENT = *mut DISK_EXTENT;
1064 STRUCT!{struct VOLUME_DISK_EXTENTS {
1065 NumberOfDiskExtents: DWORD,
1066 Extents: [DISK_EXTENT; ANYSIZE_ARRAY],
1067 }}
1068 pub type PVOLUME_DISK_EXTENTS = *mut VOLUME_DISK_EXTENTS;
1069 pub const IOCTL_VOLUME_ONLINE: DWORD = CTL_CODE!(IOCTL_VOLUME_BASE, 2, METHOD_BUFFERED,
1070 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
1071 pub const IOCTL_VOLUME_OFFLINE: DWORD = CTL_CODE!(IOCTL_VOLUME_BASE, 3, METHOD_BUFFERED,
1072 FILE_READ_ACCESS | FILE_WRITE_ACCESS);
1073 pub const IOCTL_VOLUME_IS_CLUSTERED: DWORD = CTL_CODE!(IOCTL_VOLUME_BASE, 12, METHOD_BUFFERED,
1074 FILE_ANY_ACCESS);
1075 pub const IOCTL_VOLUME_GET_GPT_ATTRIBUTES: DWORD = CTL_CODE!(IOCTL_VOLUME_BASE, 14,
1076 METHOD_BUFFERED, FILE_ANY_ACCESS);
1077 STRUCT!{struct DISK_PERFORMANCE {
1078 BytesRead: LARGE_INTEGER,
1079 BytesWritten: LARGE_INTEGER,
1080 ReadTime: LARGE_INTEGER,
1081 WriteTime: LARGE_INTEGER,
1082 IdleTime: LARGE_INTEGER,
1083 ReadCount: DWORD,
1084 WriteCount: DWORD,
1085 QueueDepth: DWORD,
1086 SplitCount: DWORD,
1087 QueryTime: LARGE_INTEGER,
1088 StorageDeviceNumber: DWORD,
1089 StorageManagerName: [WCHAR; 8],
1090 }}
1091 pub type PDISK_PERFORMANCE = *mut DISK_PERFORMANCE;
1092