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