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,
K32EnumProcesses( lpidProcess: *mut DWORD, cb: DWORD, lpcbNeeded: LPDWORD, ) -> BOOL15     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}
K32EnumProcessModules( hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, ) -> BOOL20 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}
K32EnumProcessModulesEx( hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD, ) -> BOOL26 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,
K32GetModuleBaseNameA( hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD, ) -> DWORD33     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,
K32GetModuleBaseNameW( hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD, ) -> DWORD39     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,
K32GetModuleFileNameExA( hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD45     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,
K32GetModuleFileNameExW( hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD51     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
K32EmptyWorkingSet( hProcess: HANDLE, ) -> BOOL57 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,
K32QueryWorkingSet( hProcess: HANDLE, pv: PVOID, cb: DWORD, ) -> BOOL60     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;
K32QueryWorkingSetEx( hProcess: HANDLE, pv: PVOID, cb: DWORD, ) -> BOOL65 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;
K32InitializeProcessForWsWatch( hProcess: HANDLE, ) -> BOOL70 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;
K32GetWsChanges( hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD, ) -> BOOL73 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;
K32GetWsChangesEx( hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: PDWORD, ) -> BOOL78 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;
K32GetMappedFileNameW( hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD83 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;
K32GetMappedFileNameA( hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD89 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;
K32EnumDeviceDrivers( lpImageBase: *mut LPVOID, cb: DWORD, lpcbNeeded: LPDWORD, ) -> BOOL95 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;
K32GetDeviceDriverBaseNameA( ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD100 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;
K32GetDeviceDriverBaseNameW( ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD105 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;
K32GetDeviceDriverFileNameA( ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD110 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;
K32GetDeviceDriverFileNameW( ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD115 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;
K32GetPerformanceInfo( pPerformanceInformation: PPERFORMANCE_INFORMATION, cb: DWORD, ) -> BOOL120 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;
K32EnumPageFilesW( pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID, ) -> BOOL124 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;
K32EnumPageFilesA( pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID, ) -> BOOL128 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;
K32GetProcessImageFileNameA( hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD, ) -> DWORD132 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;
K32GetProcessImageFileNameW( hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD, ) -> DWORD137 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;
EnumProcesses( lpidProcess: *mut DWORD, cb: DWORD, lpcbNeeded: LPDWORD, ) -> BOOL142 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]
146 pub fn CTL_CODE(
K32GetProcessMemoryInfo( Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD, ) -> BOOL147     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,
EmptyWorkingSet( hProcess: HANDLE, ) -> BOOL289     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 {
EnumProcessModulesEx( hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD, ) -> BOOL311     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 {
GetDeviceDriverBaseNameA( ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD318     Version: DWORD,
319     Size: DWORD,
320     TrimEnabled: BOOLEAN,
321 }}
322 pub type PDEVICE_TRIM_DESCRIPTOR = *mut DEVICE_TRIM_DESCRIPTOR;
GetDeviceDriverBaseNameW( ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD323 //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,
GetDeviceDriverFileNameA( ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD328     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);
GetDeviceDriverFileNameW( ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD333 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,
GetMappedFileNameA( hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD338     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,
GetMappedFileNameW( hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD344     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,
GetModuleBaseNameA( hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD, ) -> DWORD350     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,
GetModuleBaseNameW( hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD, ) -> DWORD356     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,
GetModuleFileNameExA( hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD, ) -> DWORD362     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,
GetModuleFileNameExW( hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD, ) -> DWORD368     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,
GetModuleInformation( hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD, ) -> BOOL374     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,
GetPerformanceInfo( pPerformanceInformation: PPERFORMANCE_INFORMATION, cb: DWORD, ) -> BOOL380     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,
GetProcessImageFileNameA( hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD, ) -> DWORD384     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);
GetProcessImageFileNameW( hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD, ) -> DWORD389 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,
GetProcessMemoryInfo( hProcess: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD, ) -> BOOL394     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);
GetWsChanges( hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD, ) -> BOOL399 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,
GetWsChangesEx( hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: PDWORD, ) -> BOOL404     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);
InitializeProcessForWsWatch( hProcess: HANDLE, ) -> BOOL409 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,
QueryWorkingSet( hProcess: HANDLE, pv: PVOID, cb: DWORD, ) -> BOOL412     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);
QueryWorkingSetEx( hProcess: HANDLE, pv: PVOID, cb: DWORD, ) -> BOOL417 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