1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 fn extract_bit(byte: u8, index: usize) -> bool {
20 let bit_index = if cfg!(target_endian = "big") {
21 7 - (index % 8)
22 } else {
23 index % 8
24 };
25 let mask = 1 << bit_index;
26 byte & mask == mask
27 }
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 Self::extract_bit(byte, index)
34 }
35 #[inline]
36 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38 let byte_index = index / 8;
39 let byte = unsafe {
40 *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
41 };
42 Self::extract_bit(byte, index)
43 }
44 #[inline]
45 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
46 let bit_index = if cfg!(target_endian = "big") {
47 7 - (index % 8)
48 } else {
49 index % 8
50 };
51 let mask = 1 << bit_index;
52 if val {
53 byte | mask
54 } else {
55 byte & !mask
56 }
57 }
58 #[inline]
59 pub fn set_bit(&mut self, index: usize, val: bool) {
60 debug_assert!(index / 8 < self.storage.as_ref().len());
61 let byte_index = index / 8;
62 let byte = &mut self.storage.as_mut()[byte_index];
63 *byte = Self::change_bit(*byte, index, val);
64 }
65 #[inline]
66 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
67 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
68 let byte_index = index / 8;
69 let byte = unsafe {
70 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
71 };
72 unsafe { *byte = Self::change_bit(*byte, index, val) };
73 }
74 #[inline]
75 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
76 debug_assert!(bit_width <= 64);
77 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
78 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
79 let mut val = 0;
80 for i in 0..(bit_width as usize) {
81 if self.get_bit(i + bit_offset) {
82 let index = if cfg!(target_endian = "big") {
83 bit_width as usize - 1 - i
84 } else {
85 i
86 };
87 val |= 1 << index;
88 }
89 }
90 val
91 }
92 #[inline]
93 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
94 debug_assert!(bit_width <= 64);
95 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
96 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
97 let mut val = 0;
98 for i in 0..(bit_width as usize) {
99 if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
100 let index = if cfg!(target_endian = "big") {
101 bit_width as usize - 1 - i
102 } else {
103 i
104 };
105 val |= 1 << index;
106 }
107 }
108 val
109 }
110 #[inline]
111 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
112 debug_assert!(bit_width <= 64);
113 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
114 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
115 for i in 0..(bit_width as usize) {
116 let mask = 1 << i;
117 let val_bit_is_set = val & mask == mask;
118 let index = if cfg!(target_endian = "big") {
119 bit_width as usize - 1 - i
120 } else {
121 i
122 };
123 self.set_bit(index + bit_offset, val_bit_is_set);
124 }
125 }
126 #[inline]
127 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
128 debug_assert!(bit_width <= 64);
129 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
130 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
131 for i in 0..(bit_width as usize) {
132 let mask = 1 << i;
133 let val_bit_is_set = val & mask == mask;
134 let index = if cfg!(target_endian = "big") {
135 bit_width as usize - 1 - i
136 } else {
137 i
138 };
139 unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
140 }
141 }
142}
143#[repr(C)]
144#[derive(Default)]
145pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
146impl<T> __IncompleteArrayField<T> {
147 #[inline]
148 pub const fn new() -> Self {
149 __IncompleteArrayField(::std::marker::PhantomData, [])
150 }
151 #[inline]
152 pub fn as_ptr(&self) -> *const T {
153 self as *const _ as *const T
154 }
155 #[inline]
156 pub fn as_mut_ptr(&mut self) -> *mut T {
157 self as *mut _ as *mut T
158 }
159 #[inline]
160 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
161 ::std::slice::from_raw_parts(self.as_ptr(), len)
162 }
163 #[inline]
164 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
165 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
166 }
167}
168impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
169 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
170 fmt.write_str("__IncompleteArrayField")
171 }
172}
173pub const FSP_FSCTL_PRODUCT_NAME: &[u8; 7] = b"WinFsp\0";
174pub const FSP_FSCTL_PRODUCT_FILE_NAME: &[u8; 7] = b"winfsp\0";
175pub const FSP_FSCTL_DRIVER_NAME: &[u8; 7] = b"WinFsp\0";
176pub const FSP_FSCTL_DISK_DEVICE_NAME: &[u8; 12] = b"WinFsp.Disk\0";
177pub const FSP_FSCTL_NET_DEVICE_NAME: &[u8; 11] = b"WinFsp.Net\0";
178pub const FSP_FSCTL_MUP_DEVICE_NAME: &[u8; 11] = b"WinFsp.Mup\0";
179pub const FSP_FSCTL_PRODUCT_REGKEY: &[u8; 16] = b"Software\\WinFsp\0";
180pub const FSP_FSCTL_PRODUCT_REGKEY_WOW64: u32 = 512;
181pub const FSP_FSCTL_PRODUCT_FULL_REGKEY: &[u8; 28] = b"Software\\WOW6432Node\\WinFsp\0";
182pub const FSP_FSCTL_PRODUCT_FILE_ARCH: &[u8; 4] = b"x64\0";
183pub const FSP_FSCTL_DEFAULT_ALIGNMENT: u32 = 8;
184pub const FSP_FSCTL_VOLUME_PARAMS_PREFIX: &[u8; 15] = b"\\VolumeParams=\0";
185pub const FSP_FSCTL_TRANSACT_REQ_SIZEMAX: u32 = 16320;
186pub const FSP_FSCTL_TRANSACT_RSP_SIZEMAX: u32 = 16384;
187pub const FSP_FSCTL_TRANSACT_BATCH_BUFFER_SIZEMIN: u32 = 65536;
188pub const FSP_FSCTL_TRANSACT_BUFFER_SIZEMIN: u32 = 16320;
189pub const FSP_FSCTL_DEVICECONTROL_SIZEMAX: u32 = 4096;
190pub const FSP_DLLNAME: &[u8; 15] = b"winfsp-x64.dll\0";
191pub const FSP_DLLPATH: &[u8; 19] = b"bin\\winfsp-x64.dll\0";
192pub const FSP_LAUNCH_REGKEY: &[u8; 25] = b"Software\\WinFsp\\Services\0";
193pub const FSP_LAUNCH_REGKEY_WOW64: u32 = 512;
194pub const FSP_LAUNCH_FULL_REGKEY: &[u8; 37] = b"Software\\WOW6432Node\\WinFsp\\Services\0";
195pub const FSP_LAUNCH_PIPE_NAME: &[u8; 55] =
196 b"\\\\.\\pipe\\WinFsp.{14E7137D-22B4-437A-B0C1-D21D1BDF3767}\0";
197pub const FSP_LAUNCH_PIPE_BUFFER_SIZE: u32 = 4096;
198pub const FSP_LAUNCH_PIPE_SDDL: &[u8; 52] =
199 b"O:SYG:SYD:P(A;;GA;;;SY)(A;;GA;;;BA)(A;;GRDCCR;;;WD)\0";
200pub const FSP_LAUNCH_SERVICE_DEFAULT_SDDL: &[u8; 36] = b"D:P(A;;RPWPLC;;;SY)(A;;RPWPLC;;;BA)\0";
201pub const FSP_LAUNCH_SERVICE_WORLD_SDDL: &[u8; 20] = b"D:P(A;;RPWPLC;;;WD)\0";
202pub type va_list = *mut ::std::os::raw::c_char;
203pub type wchar_t = ::std::os::raw::c_ushort;
204pub type ULONG = ::std::os::raw::c_ulong;
205pub type PULONG = *mut ULONG;
206pub type USHORT = ::std::os::raw::c_ushort;
207pub type UCHAR = ::std::os::raw::c_uchar;
208pub type DWORD = ::std::os::raw::c_ulong;
209pub type BYTE = ::std::os::raw::c_uchar;
210pub type WORD = ::std::os::raw::c_ushort;
211pub type UINT8 = ::std::os::raw::c_uchar;
212pub type UINT16 = ::std::os::raw::c_ushort;
213pub type UINT32 = ::std::os::raw::c_uint;
214pub type PUINT32 = *mut ::std::os::raw::c_uint;
215pub type UINT64 = ::std::os::raw::c_ulonglong;
216pub type ULONG_PTR = ::std::os::raw::c_ulonglong;
217pub type SIZE_T = ULONG_PTR;
218pub type PSIZE_T = *mut ULONG_PTR;
219pub type PVOID = *mut ::std::os::raw::c_void;
220pub type CHAR = ::std::os::raw::c_char;
221pub type LONG = ::std::os::raw::c_long;
222pub type WCHAR = wchar_t;
223pub type PWCHAR = *mut WCHAR;
224pub type PWSTR = *mut WCHAR;
225pub type HANDLE = *mut ::std::os::raw::c_void;
226pub type PHANDLE = *mut HANDLE;
227pub type BOOLEAN = BYTE;
228pub type PBOOLEAN = *mut BOOLEAN;
229#[repr(C)]
230#[derive(Debug, Copy, Clone)]
231pub struct _LIST_ENTRY {
232 pub Flink: *mut _LIST_ENTRY,
233 pub Blink: *mut _LIST_ENTRY,
234}
235#[allow(clippy::unnecessary_operation, clippy::identity_op)]
236const _: () = {
237 ["Size of _LIST_ENTRY"][::std::mem::size_of::<_LIST_ENTRY>() - 16usize];
238 ["Alignment of _LIST_ENTRY"][::std::mem::align_of::<_LIST_ENTRY>() - 8usize];
239 ["Offset of field: _LIST_ENTRY::Flink"][::std::mem::offset_of!(_LIST_ENTRY, Flink) - 0usize];
240 ["Offset of field: _LIST_ENTRY::Blink"][::std::mem::offset_of!(_LIST_ENTRY, Blink) - 8usize];
241};
242impl Default for _LIST_ENTRY {
243 fn default() -> Self {
244 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
245 unsafe {
246 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
247 s.assume_init()
248 }
249 }
250}
251pub type LIST_ENTRY = _LIST_ENTRY;
252#[repr(C)]
253#[derive(Debug, Default, Copy, Clone)]
254pub struct _GUID {
255 pub Data1: ::std::os::raw::c_ulong,
256 pub Data2: ::std::os::raw::c_ushort,
257 pub Data3: ::std::os::raw::c_ushort,
258 pub Data4: [::std::os::raw::c_uchar; 8usize],
259}
260#[allow(clippy::unnecessary_operation, clippy::identity_op)]
261const _: () = {
262 ["Size of _GUID"][::std::mem::size_of::<_GUID>() - 16usize];
263 ["Alignment of _GUID"][::std::mem::align_of::<_GUID>() - 4usize];
264 ["Offset of field: _GUID::Data1"][::std::mem::offset_of!(_GUID, Data1) - 0usize];
265 ["Offset of field: _GUID::Data2"][::std::mem::offset_of!(_GUID, Data2) - 4usize];
266 ["Offset of field: _GUID::Data3"][::std::mem::offset_of!(_GUID, Data3) - 6usize];
267 ["Offset of field: _GUID::Data4"][::std::mem::offset_of!(_GUID, Data4) - 8usize];
268};
269pub type GUID = _GUID;
270pub type PSECURITY_DESCRIPTOR = PVOID;
271pub type PSID = PVOID;
272pub type ACCESS_MASK = DWORD;
273#[repr(C)]
274#[derive(Debug, Default, Copy, Clone)]
275pub struct _GENERIC_MAPPING {
276 pub GenericRead: ACCESS_MASK,
277 pub GenericWrite: ACCESS_MASK,
278 pub GenericExecute: ACCESS_MASK,
279 pub GenericAll: ACCESS_MASK,
280}
281#[allow(clippy::unnecessary_operation, clippy::identity_op)]
282const _: () = {
283 ["Size of _GENERIC_MAPPING"][::std::mem::size_of::<_GENERIC_MAPPING>() - 16usize];
284 ["Alignment of _GENERIC_MAPPING"][::std::mem::align_of::<_GENERIC_MAPPING>() - 4usize];
285 ["Offset of field: _GENERIC_MAPPING::GenericRead"]
286 [::std::mem::offset_of!(_GENERIC_MAPPING, GenericRead) - 0usize];
287 ["Offset of field: _GENERIC_MAPPING::GenericWrite"]
288 [::std::mem::offset_of!(_GENERIC_MAPPING, GenericWrite) - 4usize];
289 ["Offset of field: _GENERIC_MAPPING::GenericExecute"]
290 [::std::mem::offset_of!(_GENERIC_MAPPING, GenericExecute) - 8usize];
291 ["Offset of field: _GENERIC_MAPPING::GenericAll"]
292 [::std::mem::offset_of!(_GENERIC_MAPPING, GenericAll) - 12usize];
293};
294pub type GENERIC_MAPPING = _GENERIC_MAPPING;
295pub type PGENERIC_MAPPING = *mut GENERIC_MAPPING;
296pub type SECURITY_INFORMATION = DWORD;
297#[repr(C)]
298#[derive(Debug, Copy, Clone)]
299pub struct _RTL_CRITICAL_SECTION_DEBUG {
300 pub Type: WORD,
301 pub CreatorBackTraceIndex: WORD,
302 pub CriticalSection: *mut _RTL_CRITICAL_SECTION,
303 pub ProcessLocksList: LIST_ENTRY,
304 pub EntryCount: DWORD,
305 pub ContentionCount: DWORD,
306 pub Flags: DWORD,
307 pub CreatorBackTraceIndexHigh: WORD,
308 pub Identifier: WORD,
309}
310#[allow(clippy::unnecessary_operation, clippy::identity_op)]
311const _: () = {
312 ["Size of _RTL_CRITICAL_SECTION_DEBUG"]
313 [::std::mem::size_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 48usize];
314 ["Alignment of _RTL_CRITICAL_SECTION_DEBUG"]
315 [::std::mem::align_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 8usize];
316 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Type"]
317 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Type) - 0usize];
318 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndex"]
319 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex) - 2usize];
320 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CriticalSection"]
321 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CriticalSection) - 8usize];
322 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ProcessLocksList"]
323 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList) - 16usize];
324 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::EntryCount"]
325 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, EntryCount) - 32usize];
326 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ContentionCount"]
327 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ContentionCount) - 36usize];
328 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Flags"]
329 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Flags) - 40usize];
330 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndexHigh"]
331 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndexHigh) - 44usize];
332 ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Identifier"]
333 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Identifier) - 46usize];
334};
335impl Default for _RTL_CRITICAL_SECTION_DEBUG {
336 fn default() -> Self {
337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
338 unsafe {
339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
340 s.assume_init()
341 }
342 }
343}
344pub type PRTL_CRITICAL_SECTION_DEBUG = *mut _RTL_CRITICAL_SECTION_DEBUG;
345#[repr(C)]
346#[derive(Debug, Copy, Clone)]
347pub struct _RTL_CRITICAL_SECTION {
348 pub DebugInfo: PRTL_CRITICAL_SECTION_DEBUG,
349 pub LockCount: LONG,
350 pub RecursionCount: LONG,
351 pub OwningThread: HANDLE,
352 pub LockSemaphore: HANDLE,
353 pub SpinCount: ULONG_PTR,
354}
355#[allow(clippy::unnecessary_operation, clippy::identity_op)]
356const _: () = {
357 ["Size of _RTL_CRITICAL_SECTION"][::std::mem::size_of::<_RTL_CRITICAL_SECTION>() - 40usize];
358 ["Alignment of _RTL_CRITICAL_SECTION"]
359 [::std::mem::align_of::<_RTL_CRITICAL_SECTION>() - 8usize];
360 ["Offset of field: _RTL_CRITICAL_SECTION::DebugInfo"]
361 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, DebugInfo) - 0usize];
362 ["Offset of field: _RTL_CRITICAL_SECTION::LockCount"]
363 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockCount) - 8usize];
364 ["Offset of field: _RTL_CRITICAL_SECTION::RecursionCount"]
365 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, RecursionCount) - 12usize];
366 ["Offset of field: _RTL_CRITICAL_SECTION::OwningThread"]
367 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, OwningThread) - 16usize];
368 ["Offset of field: _RTL_CRITICAL_SECTION::LockSemaphore"]
369 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockSemaphore) - 24usize];
370 ["Offset of field: _RTL_CRITICAL_SECTION::SpinCount"]
371 [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, SpinCount) - 32usize];
372};
373impl Default for _RTL_CRITICAL_SECTION {
374 fn default() -> Self {
375 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
376 unsafe {
377 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
378 s.assume_init()
379 }
380 }
381}
382pub type RTL_CRITICAL_SECTION = _RTL_CRITICAL_SECTION;
383#[repr(C)]
384#[derive(Debug, Copy, Clone)]
385pub struct _RTL_SRWLOCK {
386 pub Ptr: PVOID,
387}
388#[allow(clippy::unnecessary_operation, clippy::identity_op)]
389const _: () = {
390 ["Size of _RTL_SRWLOCK"][::std::mem::size_of::<_RTL_SRWLOCK>() - 8usize];
391 ["Alignment of _RTL_SRWLOCK"][::std::mem::align_of::<_RTL_SRWLOCK>() - 8usize];
392 ["Offset of field: _RTL_SRWLOCK::Ptr"][::std::mem::offset_of!(_RTL_SRWLOCK, Ptr) - 0usize];
393};
394impl Default for _RTL_SRWLOCK {
395 fn default() -> Self {
396 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
397 unsafe {
398 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
399 s.assume_init()
400 }
401 }
402}
403pub type RTL_SRWLOCK = _RTL_SRWLOCK;
404#[repr(C)]
405#[derive(Debug, Default, Copy, Clone)]
406pub struct _FILETIME {
407 pub dwLowDateTime: DWORD,
408 pub dwHighDateTime: DWORD,
409}
410#[allow(clippy::unnecessary_operation, clippy::identity_op)]
411const _: () = {
412 ["Size of _FILETIME"][::std::mem::size_of::<_FILETIME>() - 8usize];
413 ["Alignment of _FILETIME"][::std::mem::align_of::<_FILETIME>() - 4usize];
414 ["Offset of field: _FILETIME::dwLowDateTime"]
415 [::std::mem::offset_of!(_FILETIME, dwLowDateTime) - 0usize];
416 ["Offset of field: _FILETIME::dwHighDateTime"]
417 [::std::mem::offset_of!(_FILETIME, dwHighDateTime) - 4usize];
418};
419pub type PFILETIME = *mut _FILETIME;
420pub type CRITICAL_SECTION = RTL_CRITICAL_SECTION;
421pub type SRWLOCK = RTL_SRWLOCK;
422pub type NTSTATUS = LONG;
423pub type PNTSTATUS = *mut NTSTATUS;
424#[repr(C)]
425#[derive(Debug, Default, Copy, Clone)]
426pub struct SERVICE_STATUS_HANDLE__ {
427 pub unused: ::std::os::raw::c_int,
428}
429#[allow(clippy::unnecessary_operation, clippy::identity_op)]
430const _: () = {
431 ["Size of SERVICE_STATUS_HANDLE__"][::std::mem::size_of::<SERVICE_STATUS_HANDLE__>() - 4usize];
432 ["Alignment of SERVICE_STATUS_HANDLE__"]
433 [::std::mem::align_of::<SERVICE_STATUS_HANDLE__>() - 4usize];
434 ["Offset of field: SERVICE_STATUS_HANDLE__::unused"]
435 [::std::mem::offset_of!(SERVICE_STATUS_HANDLE__, unused) - 0usize];
436};
437pub type SERVICE_STATUS_HANDLE = *mut SERVICE_STATUS_HANDLE__;
438#[repr(C)]
439#[derive(Debug, Default, Copy, Clone)]
440pub struct _SERVICE_STATUS {
441 pub dwServiceType: DWORD,
442 pub dwCurrentState: DWORD,
443 pub dwControlsAccepted: DWORD,
444 pub dwWin32ExitCode: DWORD,
445 pub dwServiceSpecificExitCode: DWORD,
446 pub dwCheckPoint: DWORD,
447 pub dwWaitHint: DWORD,
448}
449#[allow(clippy::unnecessary_operation, clippy::identity_op)]
450const _: () = {
451 ["Size of _SERVICE_STATUS"][::std::mem::size_of::<_SERVICE_STATUS>() - 28usize];
452 ["Alignment of _SERVICE_STATUS"][::std::mem::align_of::<_SERVICE_STATUS>() - 4usize];
453 ["Offset of field: _SERVICE_STATUS::dwServiceType"]
454 [::std::mem::offset_of!(_SERVICE_STATUS, dwServiceType) - 0usize];
455 ["Offset of field: _SERVICE_STATUS::dwCurrentState"]
456 [::std::mem::offset_of!(_SERVICE_STATUS, dwCurrentState) - 4usize];
457 ["Offset of field: _SERVICE_STATUS::dwControlsAccepted"]
458 [::std::mem::offset_of!(_SERVICE_STATUS, dwControlsAccepted) - 8usize];
459 ["Offset of field: _SERVICE_STATUS::dwWin32ExitCode"]
460 [::std::mem::offset_of!(_SERVICE_STATUS, dwWin32ExitCode) - 12usize];
461 ["Offset of field: _SERVICE_STATUS::dwServiceSpecificExitCode"]
462 [::std::mem::offset_of!(_SERVICE_STATUS, dwServiceSpecificExitCode) - 16usize];
463 ["Offset of field: _SERVICE_STATUS::dwCheckPoint"]
464 [::std::mem::offset_of!(_SERVICE_STATUS, dwCheckPoint) - 20usize];
465 ["Offset of field: _SERVICE_STATUS::dwWaitHint"]
466 [::std::mem::offset_of!(_SERVICE_STATUS, dwWaitHint) - 24usize];
467};
468pub type SERVICE_STATUS = _SERVICE_STATUS;
469#[repr(C)]
470#[derive(Copy, Clone)]
471pub struct _IO_STATUS_BLOCK {
472 pub __bindgen_anon_1: _IO_STATUS_BLOCK__bindgen_ty_1,
473 pub Information: ULONG_PTR,
474}
475#[repr(C)]
476#[derive(Copy, Clone)]
477pub union _IO_STATUS_BLOCK__bindgen_ty_1 {
478 pub Status: NTSTATUS,
479 pub Pointer: PVOID,
480}
481#[allow(clippy::unnecessary_operation, clippy::identity_op)]
482const _: () = {
483 ["Size of _IO_STATUS_BLOCK__bindgen_ty_1"]
484 [::std::mem::size_of::<_IO_STATUS_BLOCK__bindgen_ty_1>() - 8usize];
485 ["Alignment of _IO_STATUS_BLOCK__bindgen_ty_1"]
486 [::std::mem::align_of::<_IO_STATUS_BLOCK__bindgen_ty_1>() - 8usize];
487 ["Offset of field: _IO_STATUS_BLOCK__bindgen_ty_1::Status"]
488 [::std::mem::offset_of!(_IO_STATUS_BLOCK__bindgen_ty_1, Status) - 0usize];
489 ["Offset of field: _IO_STATUS_BLOCK__bindgen_ty_1::Pointer"]
490 [::std::mem::offset_of!(_IO_STATUS_BLOCK__bindgen_ty_1, Pointer) - 0usize];
491};
492impl Default for _IO_STATUS_BLOCK__bindgen_ty_1 {
493 fn default() -> Self {
494 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
495 unsafe {
496 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
497 s.assume_init()
498 }
499 }
500}
501#[allow(clippy::unnecessary_operation, clippy::identity_op)]
502const _: () = {
503 ["Size of _IO_STATUS_BLOCK"][::std::mem::size_of::<_IO_STATUS_BLOCK>() - 16usize];
504 ["Alignment of _IO_STATUS_BLOCK"][::std::mem::align_of::<_IO_STATUS_BLOCK>() - 8usize];
505 ["Offset of field: _IO_STATUS_BLOCK::Information"]
506 [::std::mem::offset_of!(_IO_STATUS_BLOCK, Information) - 8usize];
507};
508impl Default for _IO_STATUS_BLOCK {
509 fn default() -> Self {
510 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
511 unsafe {
512 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
513 s.assume_init()
514 }
515 }
516}
517pub type PIO_STATUS_BLOCK = *mut _IO_STATUS_BLOCK;
518unsafe extern "C" {
519 pub static FspFsctlDeviceClassGuid: GUID;
520}
521unsafe extern "C" {
522 pub static FspFsvrtDeviceClassGuid: GUID;
523}
524pub const FspFsctlTransactReservedKind: _bindgen_ty_4 = 0;
525pub const FspFsctlTransactCreateKind: _bindgen_ty_4 = 1;
526pub const FspFsctlTransactOverwriteKind: _bindgen_ty_4 = 2;
527pub const FspFsctlTransactCleanupKind: _bindgen_ty_4 = 3;
528pub const FspFsctlTransactCloseKind: _bindgen_ty_4 = 4;
529pub const FspFsctlTransactReadKind: _bindgen_ty_4 = 5;
530pub const FspFsctlTransactWriteKind: _bindgen_ty_4 = 6;
531pub const FspFsctlTransactQueryInformationKind: _bindgen_ty_4 = 7;
532pub const FspFsctlTransactSetInformationKind: _bindgen_ty_4 = 8;
533pub const FspFsctlTransactQueryEaKind: _bindgen_ty_4 = 9;
534pub const FspFsctlTransactSetEaKind: _bindgen_ty_4 = 10;
535pub const FspFsctlTransactFlushBuffersKind: _bindgen_ty_4 = 11;
536pub const FspFsctlTransactQueryVolumeInformationKind: _bindgen_ty_4 = 12;
537pub const FspFsctlTransactSetVolumeInformationKind: _bindgen_ty_4 = 13;
538pub const FspFsctlTransactQueryDirectoryKind: _bindgen_ty_4 = 14;
539pub const FspFsctlTransactFileSystemControlKind: _bindgen_ty_4 = 15;
540pub const FspFsctlTransactDeviceControlKind: _bindgen_ty_4 = 16;
541pub const FspFsctlTransactShutdownKind: _bindgen_ty_4 = 17;
542pub const FspFsctlTransactLockControlKind: _bindgen_ty_4 = 18;
543pub const FspFsctlTransactQuerySecurityKind: _bindgen_ty_4 = 19;
544pub const FspFsctlTransactSetSecurityKind: _bindgen_ty_4 = 20;
545pub const FspFsctlTransactQueryStreamInformationKind: _bindgen_ty_4 = 21;
546pub const FspFsctlTransactKindCount: _bindgen_ty_4 = 22;
547pub type _bindgen_ty_4 = ::std::os::raw::c_int;
548pub const FspFsctlTransactTimeoutMinimum: _bindgen_ty_5 = 1000;
549pub const FspFsctlTransactTimeoutMaximum: _bindgen_ty_5 = 10000;
550pub const FspFsctlTransactTimeoutDefault: _bindgen_ty_5 = 1000;
551pub const FspFsctlIrpTimeoutMinimum: _bindgen_ty_5 = 60000;
552pub const FspFsctlIrpTimeoutMaximum: _bindgen_ty_5 = 600000;
553pub const FspFsctlIrpTimeoutDefault: _bindgen_ty_5 = 300000;
554pub const FspFsctlIrpTimeoutDebug: _bindgen_ty_5 = 142;
555pub const FspFsctlIrpCapacityMinimum: _bindgen_ty_5 = 100;
556pub const FspFsctlIrpCapacityMaximum: _bindgen_ty_5 = 1000;
557pub const FspFsctlIrpCapacityDefault: _bindgen_ty_5 = 1000;
558pub type _bindgen_ty_5 = ::std::os::raw::c_int;
559#[repr(C)]
560#[derive(Debug, Copy, Clone)]
561pub struct FSP_FSCTL_VOLUME_PARAMS_V0 {
562 pub Version: UINT16,
563 pub SectorSize: UINT16,
564 pub SectorsPerAllocationUnit: UINT16,
565 pub MaxComponentLength: UINT16,
566 pub VolumeCreationTime: UINT64,
567 pub VolumeSerialNumber: UINT32,
568 pub TransactTimeout: UINT32,
569 pub IrpTimeout: UINT32,
570 pub IrpCapacity: UINT32,
571 pub FileInfoTimeout: UINT32,
572 pub _bitfield_align_1: [u8; 0],
573 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
574 pub Prefix: [WCHAR; 192usize],
575 pub FileSystemName: [WCHAR; 16usize],
576}
577#[allow(clippy::unnecessary_operation, clippy::identity_op)]
578const _: () = {
579 ["Size of FSP_FSCTL_VOLUME_PARAMS_V0"]
580 [::std::mem::size_of::<FSP_FSCTL_VOLUME_PARAMS_V0>() - 456usize];
581 ["Alignment of FSP_FSCTL_VOLUME_PARAMS_V0"]
582 [::std::mem::align_of::<FSP_FSCTL_VOLUME_PARAMS_V0>() - 8usize];
583 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::Version"]
584 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, Version) - 0usize];
585 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::SectorSize"]
586 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, SectorSize) - 2usize];
587 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::SectorsPerAllocationUnit"]
588 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, SectorsPerAllocationUnit) - 4usize];
589 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::MaxComponentLength"]
590 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, MaxComponentLength) - 6usize];
591 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::VolumeCreationTime"]
592 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, VolumeCreationTime) - 8usize];
593 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::VolumeSerialNumber"]
594 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, VolumeSerialNumber) - 16usize];
595 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::TransactTimeout"]
596 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, TransactTimeout) - 20usize];
597 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::IrpTimeout"]
598 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, IrpTimeout) - 24usize];
599 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::IrpCapacity"]
600 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, IrpCapacity) - 28usize];
601 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::FileInfoTimeout"]
602 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, FileInfoTimeout) - 32usize];
603 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::Prefix"]
604 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, Prefix) - 40usize];
605 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::FileSystemName"]
606 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, FileSystemName) - 424usize];
607};
608impl Default for FSP_FSCTL_VOLUME_PARAMS_V0 {
609 fn default() -> Self {
610 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
611 unsafe {
612 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
613 s.assume_init()
614 }
615 }
616}
617impl FSP_FSCTL_VOLUME_PARAMS_V0 {
618 #[inline]
619 pub fn CaseSensitiveSearch(&self) -> UINT32 {
620 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
621 }
622 #[inline]
623 pub fn set_CaseSensitiveSearch(&mut self, val: UINT32) {
624 unsafe {
625 let val: u32 = ::std::mem::transmute(val);
626 self._bitfield_1.set(0usize, 1u8, val as u64)
627 }
628 }
629 #[inline]
630 pub unsafe fn CaseSensitiveSearch_raw(this: *const Self) -> UINT32 {
631 unsafe {
632 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
633 ::std::ptr::addr_of!((*this)._bitfield_1),
634 0usize,
635 1u8,
636 ) as u32)
637 }
638 }
639 #[inline]
640 pub unsafe fn set_CaseSensitiveSearch_raw(this: *mut Self, val: UINT32) {
641 unsafe {
642 let val: u32 = ::std::mem::transmute(val);
643 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
644 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
645 0usize,
646 1u8,
647 val as u64,
648 )
649 }
650 }
651 #[inline]
652 pub fn CasePreservedNames(&self) -> UINT32 {
653 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
654 }
655 #[inline]
656 pub fn set_CasePreservedNames(&mut self, val: UINT32) {
657 unsafe {
658 let val: u32 = ::std::mem::transmute(val);
659 self._bitfield_1.set(1usize, 1u8, val as u64)
660 }
661 }
662 #[inline]
663 pub unsafe fn CasePreservedNames_raw(this: *const Self) -> UINT32 {
664 unsafe {
665 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
666 ::std::ptr::addr_of!((*this)._bitfield_1),
667 1usize,
668 1u8,
669 ) as u32)
670 }
671 }
672 #[inline]
673 pub unsafe fn set_CasePreservedNames_raw(this: *mut Self, val: UINT32) {
674 unsafe {
675 let val: u32 = ::std::mem::transmute(val);
676 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
677 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
678 1usize,
679 1u8,
680 val as u64,
681 )
682 }
683 }
684 #[inline]
685 pub fn UnicodeOnDisk(&self) -> UINT32 {
686 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
687 }
688 #[inline]
689 pub fn set_UnicodeOnDisk(&mut self, val: UINT32) {
690 unsafe {
691 let val: u32 = ::std::mem::transmute(val);
692 self._bitfield_1.set(2usize, 1u8, val as u64)
693 }
694 }
695 #[inline]
696 pub unsafe fn UnicodeOnDisk_raw(this: *const Self) -> UINT32 {
697 unsafe {
698 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
699 ::std::ptr::addr_of!((*this)._bitfield_1),
700 2usize,
701 1u8,
702 ) as u32)
703 }
704 }
705 #[inline]
706 pub unsafe fn set_UnicodeOnDisk_raw(this: *mut Self, val: UINT32) {
707 unsafe {
708 let val: u32 = ::std::mem::transmute(val);
709 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
710 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
711 2usize,
712 1u8,
713 val as u64,
714 )
715 }
716 }
717 #[inline]
718 pub fn PersistentAcls(&self) -> UINT32 {
719 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
720 }
721 #[inline]
722 pub fn set_PersistentAcls(&mut self, val: UINT32) {
723 unsafe {
724 let val: u32 = ::std::mem::transmute(val);
725 self._bitfield_1.set(3usize, 1u8, val as u64)
726 }
727 }
728 #[inline]
729 pub unsafe fn PersistentAcls_raw(this: *const Self) -> UINT32 {
730 unsafe {
731 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
732 ::std::ptr::addr_of!((*this)._bitfield_1),
733 3usize,
734 1u8,
735 ) as u32)
736 }
737 }
738 #[inline]
739 pub unsafe fn set_PersistentAcls_raw(this: *mut Self, val: UINT32) {
740 unsafe {
741 let val: u32 = ::std::mem::transmute(val);
742 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
743 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
744 3usize,
745 1u8,
746 val as u64,
747 )
748 }
749 }
750 #[inline]
751 pub fn ReparsePoints(&self) -> UINT32 {
752 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
753 }
754 #[inline]
755 pub fn set_ReparsePoints(&mut self, val: UINT32) {
756 unsafe {
757 let val: u32 = ::std::mem::transmute(val);
758 self._bitfield_1.set(4usize, 1u8, val as u64)
759 }
760 }
761 #[inline]
762 pub unsafe fn ReparsePoints_raw(this: *const Self) -> UINT32 {
763 unsafe {
764 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
765 ::std::ptr::addr_of!((*this)._bitfield_1),
766 4usize,
767 1u8,
768 ) as u32)
769 }
770 }
771 #[inline]
772 pub unsafe fn set_ReparsePoints_raw(this: *mut Self, val: UINT32) {
773 unsafe {
774 let val: u32 = ::std::mem::transmute(val);
775 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
776 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
777 4usize,
778 1u8,
779 val as u64,
780 )
781 }
782 }
783 #[inline]
784 pub fn ReparsePointsAccessCheck(&self) -> UINT32 {
785 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
786 }
787 #[inline]
788 pub fn set_ReparsePointsAccessCheck(&mut self, val: UINT32) {
789 unsafe {
790 let val: u32 = ::std::mem::transmute(val);
791 self._bitfield_1.set(5usize, 1u8, val as u64)
792 }
793 }
794 #[inline]
795 pub unsafe fn ReparsePointsAccessCheck_raw(this: *const Self) -> UINT32 {
796 unsafe {
797 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
798 ::std::ptr::addr_of!((*this)._bitfield_1),
799 5usize,
800 1u8,
801 ) as u32)
802 }
803 }
804 #[inline]
805 pub unsafe fn set_ReparsePointsAccessCheck_raw(this: *mut Self, val: UINT32) {
806 unsafe {
807 let val: u32 = ::std::mem::transmute(val);
808 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
809 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
810 5usize,
811 1u8,
812 val as u64,
813 )
814 }
815 }
816 #[inline]
817 pub fn NamedStreams(&self) -> UINT32 {
818 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
819 }
820 #[inline]
821 pub fn set_NamedStreams(&mut self, val: UINT32) {
822 unsafe {
823 let val: u32 = ::std::mem::transmute(val);
824 self._bitfield_1.set(6usize, 1u8, val as u64)
825 }
826 }
827 #[inline]
828 pub unsafe fn NamedStreams_raw(this: *const Self) -> UINT32 {
829 unsafe {
830 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
831 ::std::ptr::addr_of!((*this)._bitfield_1),
832 6usize,
833 1u8,
834 ) as u32)
835 }
836 }
837 #[inline]
838 pub unsafe fn set_NamedStreams_raw(this: *mut Self, val: UINT32) {
839 unsafe {
840 let val: u32 = ::std::mem::transmute(val);
841 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
842 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
843 6usize,
844 1u8,
845 val as u64,
846 )
847 }
848 }
849 #[inline]
850 pub fn HardLinks(&self) -> UINT32 {
851 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
852 }
853 #[inline]
854 pub fn set_HardLinks(&mut self, val: UINT32) {
855 unsafe {
856 let val: u32 = ::std::mem::transmute(val);
857 self._bitfield_1.set(7usize, 1u8, val as u64)
858 }
859 }
860 #[inline]
861 pub unsafe fn HardLinks_raw(this: *const Self) -> UINT32 {
862 unsafe {
863 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
864 ::std::ptr::addr_of!((*this)._bitfield_1),
865 7usize,
866 1u8,
867 ) as u32)
868 }
869 }
870 #[inline]
871 pub unsafe fn set_HardLinks_raw(this: *mut Self, val: UINT32) {
872 unsafe {
873 let val: u32 = ::std::mem::transmute(val);
874 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
875 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
876 7usize,
877 1u8,
878 val as u64,
879 )
880 }
881 }
882 #[inline]
883 pub fn ExtendedAttributes(&self) -> UINT32 {
884 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
885 }
886 #[inline]
887 pub fn set_ExtendedAttributes(&mut self, val: UINT32) {
888 unsafe {
889 let val: u32 = ::std::mem::transmute(val);
890 self._bitfield_1.set(8usize, 1u8, val as u64)
891 }
892 }
893 #[inline]
894 pub unsafe fn ExtendedAttributes_raw(this: *const Self) -> UINT32 {
895 unsafe {
896 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
897 ::std::ptr::addr_of!((*this)._bitfield_1),
898 8usize,
899 1u8,
900 ) as u32)
901 }
902 }
903 #[inline]
904 pub unsafe fn set_ExtendedAttributes_raw(this: *mut Self, val: UINT32) {
905 unsafe {
906 let val: u32 = ::std::mem::transmute(val);
907 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
908 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
909 8usize,
910 1u8,
911 val as u64,
912 )
913 }
914 }
915 #[inline]
916 pub fn ReadOnlyVolume(&self) -> UINT32 {
917 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
918 }
919 #[inline]
920 pub fn set_ReadOnlyVolume(&mut self, val: UINT32) {
921 unsafe {
922 let val: u32 = ::std::mem::transmute(val);
923 self._bitfield_1.set(9usize, 1u8, val as u64)
924 }
925 }
926 #[inline]
927 pub unsafe fn ReadOnlyVolume_raw(this: *const Self) -> UINT32 {
928 unsafe {
929 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
930 ::std::ptr::addr_of!((*this)._bitfield_1),
931 9usize,
932 1u8,
933 ) as u32)
934 }
935 }
936 #[inline]
937 pub unsafe fn set_ReadOnlyVolume_raw(this: *mut Self, val: UINT32) {
938 unsafe {
939 let val: u32 = ::std::mem::transmute(val);
940 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
941 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
942 9usize,
943 1u8,
944 val as u64,
945 )
946 }
947 }
948 #[inline]
949 pub fn PostCleanupWhenModifiedOnly(&self) -> UINT32 {
950 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
951 }
952 #[inline]
953 pub fn set_PostCleanupWhenModifiedOnly(&mut self, val: UINT32) {
954 unsafe {
955 let val: u32 = ::std::mem::transmute(val);
956 self._bitfield_1.set(10usize, 1u8, val as u64)
957 }
958 }
959 #[inline]
960 pub unsafe fn PostCleanupWhenModifiedOnly_raw(this: *const Self) -> UINT32 {
961 unsafe {
962 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
963 ::std::ptr::addr_of!((*this)._bitfield_1),
964 10usize,
965 1u8,
966 ) as u32)
967 }
968 }
969 #[inline]
970 pub unsafe fn set_PostCleanupWhenModifiedOnly_raw(this: *mut Self, val: UINT32) {
971 unsafe {
972 let val: u32 = ::std::mem::transmute(val);
973 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
974 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
975 10usize,
976 1u8,
977 val as u64,
978 )
979 }
980 }
981 #[inline]
982 pub fn PassQueryDirectoryPattern(&self) -> UINT32 {
983 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
984 }
985 #[inline]
986 pub fn set_PassQueryDirectoryPattern(&mut self, val: UINT32) {
987 unsafe {
988 let val: u32 = ::std::mem::transmute(val);
989 self._bitfield_1.set(11usize, 1u8, val as u64)
990 }
991 }
992 #[inline]
993 pub unsafe fn PassQueryDirectoryPattern_raw(this: *const Self) -> UINT32 {
994 unsafe {
995 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
996 ::std::ptr::addr_of!((*this)._bitfield_1),
997 11usize,
998 1u8,
999 ) as u32)
1000 }
1001 }
1002 #[inline]
1003 pub unsafe fn set_PassQueryDirectoryPattern_raw(this: *mut Self, val: UINT32) {
1004 unsafe {
1005 let val: u32 = ::std::mem::transmute(val);
1006 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1007 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1008 11usize,
1009 1u8,
1010 val as u64,
1011 )
1012 }
1013 }
1014 #[inline]
1015 pub fn AlwaysUseDoubleBuffering(&self) -> UINT32 {
1016 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
1017 }
1018 #[inline]
1019 pub fn set_AlwaysUseDoubleBuffering(&mut self, val: UINT32) {
1020 unsafe {
1021 let val: u32 = ::std::mem::transmute(val);
1022 self._bitfield_1.set(12usize, 1u8, val as u64)
1023 }
1024 }
1025 #[inline]
1026 pub unsafe fn AlwaysUseDoubleBuffering_raw(this: *const Self) -> UINT32 {
1027 unsafe {
1028 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1029 ::std::ptr::addr_of!((*this)._bitfield_1),
1030 12usize,
1031 1u8,
1032 ) as u32)
1033 }
1034 }
1035 #[inline]
1036 pub unsafe fn set_AlwaysUseDoubleBuffering_raw(this: *mut Self, val: UINT32) {
1037 unsafe {
1038 let val: u32 = ::std::mem::transmute(val);
1039 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1040 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1041 12usize,
1042 1u8,
1043 val as u64,
1044 )
1045 }
1046 }
1047 #[inline]
1048 pub fn PassQueryDirectoryFileName(&self) -> UINT32 {
1049 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
1050 }
1051 #[inline]
1052 pub fn set_PassQueryDirectoryFileName(&mut self, val: UINT32) {
1053 unsafe {
1054 let val: u32 = ::std::mem::transmute(val);
1055 self._bitfield_1.set(13usize, 1u8, val as u64)
1056 }
1057 }
1058 #[inline]
1059 pub unsafe fn PassQueryDirectoryFileName_raw(this: *const Self) -> UINT32 {
1060 unsafe {
1061 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1062 ::std::ptr::addr_of!((*this)._bitfield_1),
1063 13usize,
1064 1u8,
1065 ) as u32)
1066 }
1067 }
1068 #[inline]
1069 pub unsafe fn set_PassQueryDirectoryFileName_raw(this: *mut Self, val: UINT32) {
1070 unsafe {
1071 let val: u32 = ::std::mem::transmute(val);
1072 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1073 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1074 13usize,
1075 1u8,
1076 val as u64,
1077 )
1078 }
1079 }
1080 #[inline]
1081 pub fn FlushAndPurgeOnCleanup(&self) -> UINT32 {
1082 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
1083 }
1084 #[inline]
1085 pub fn set_FlushAndPurgeOnCleanup(&mut self, val: UINT32) {
1086 unsafe {
1087 let val: u32 = ::std::mem::transmute(val);
1088 self._bitfield_1.set(14usize, 1u8, val as u64)
1089 }
1090 }
1091 #[inline]
1092 pub unsafe fn FlushAndPurgeOnCleanup_raw(this: *const Self) -> UINT32 {
1093 unsafe {
1094 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1095 ::std::ptr::addr_of!((*this)._bitfield_1),
1096 14usize,
1097 1u8,
1098 ) as u32)
1099 }
1100 }
1101 #[inline]
1102 pub unsafe fn set_FlushAndPurgeOnCleanup_raw(this: *mut Self, val: UINT32) {
1103 unsafe {
1104 let val: u32 = ::std::mem::transmute(val);
1105 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1106 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1107 14usize,
1108 1u8,
1109 val as u64,
1110 )
1111 }
1112 }
1113 #[inline]
1114 pub fn DeviceControl(&self) -> UINT32 {
1115 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
1116 }
1117 #[inline]
1118 pub fn set_DeviceControl(&mut self, val: UINT32) {
1119 unsafe {
1120 let val: u32 = ::std::mem::transmute(val);
1121 self._bitfield_1.set(15usize, 1u8, val as u64)
1122 }
1123 }
1124 #[inline]
1125 pub unsafe fn DeviceControl_raw(this: *const Self) -> UINT32 {
1126 unsafe {
1127 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1128 ::std::ptr::addr_of!((*this)._bitfield_1),
1129 15usize,
1130 1u8,
1131 ) as u32)
1132 }
1133 }
1134 #[inline]
1135 pub unsafe fn set_DeviceControl_raw(this: *mut Self, val: UINT32) {
1136 unsafe {
1137 let val: u32 = ::std::mem::transmute(val);
1138 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1139 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1140 15usize,
1141 1u8,
1142 val as u64,
1143 )
1144 }
1145 }
1146 #[inline]
1147 pub fn UmFileContextIsUserContext2(&self) -> UINT32 {
1148 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
1149 }
1150 #[inline]
1151 pub fn set_UmFileContextIsUserContext2(&mut self, val: UINT32) {
1152 unsafe {
1153 let val: u32 = ::std::mem::transmute(val);
1154 self._bitfield_1.set(16usize, 1u8, val as u64)
1155 }
1156 }
1157 #[inline]
1158 pub unsafe fn UmFileContextIsUserContext2_raw(this: *const Self) -> UINT32 {
1159 unsafe {
1160 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1161 ::std::ptr::addr_of!((*this)._bitfield_1),
1162 16usize,
1163 1u8,
1164 ) as u32)
1165 }
1166 }
1167 #[inline]
1168 pub unsafe fn set_UmFileContextIsUserContext2_raw(this: *mut Self, val: UINT32) {
1169 unsafe {
1170 let val: u32 = ::std::mem::transmute(val);
1171 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1172 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1173 16usize,
1174 1u8,
1175 val as u64,
1176 )
1177 }
1178 }
1179 #[inline]
1180 pub fn UmFileContextIsFullContext(&self) -> UINT32 {
1181 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
1182 }
1183 #[inline]
1184 pub fn set_UmFileContextIsFullContext(&mut self, val: UINT32) {
1185 unsafe {
1186 let val: u32 = ::std::mem::transmute(val);
1187 self._bitfield_1.set(17usize, 1u8, val as u64)
1188 }
1189 }
1190 #[inline]
1191 pub unsafe fn UmFileContextIsFullContext_raw(this: *const Self) -> UINT32 {
1192 unsafe {
1193 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1194 ::std::ptr::addr_of!((*this)._bitfield_1),
1195 17usize,
1196 1u8,
1197 ) as u32)
1198 }
1199 }
1200 #[inline]
1201 pub unsafe fn set_UmFileContextIsFullContext_raw(this: *mut Self, val: UINT32) {
1202 unsafe {
1203 let val: u32 = ::std::mem::transmute(val);
1204 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1205 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1206 17usize,
1207 1u8,
1208 val as u64,
1209 )
1210 }
1211 }
1212 #[inline]
1213 pub fn UmNoReparsePointsDirCheck(&self) -> UINT32 {
1214 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
1215 }
1216 #[inline]
1217 pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT32) {
1218 unsafe {
1219 let val: u32 = ::std::mem::transmute(val);
1220 self._bitfield_1.set(18usize, 1u8, val as u64)
1221 }
1222 }
1223 #[inline]
1224 pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT32 {
1225 unsafe {
1226 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1227 ::std::ptr::addr_of!((*this)._bitfield_1),
1228 18usize,
1229 1u8,
1230 ) as u32)
1231 }
1232 }
1233 #[inline]
1234 pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT32) {
1235 unsafe {
1236 let val: u32 = ::std::mem::transmute(val);
1237 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1238 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1239 18usize,
1240 1u8,
1241 val as u64,
1242 )
1243 }
1244 }
1245 #[inline]
1246 pub fn UmReservedFlags(&self) -> UINT32 {
1247 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 5u8) as u32) }
1248 }
1249 #[inline]
1250 pub fn set_UmReservedFlags(&mut self, val: UINT32) {
1251 unsafe {
1252 let val: u32 = ::std::mem::transmute(val);
1253 self._bitfield_1.set(19usize, 5u8, val as u64)
1254 }
1255 }
1256 #[inline]
1257 pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT32 {
1258 unsafe {
1259 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1260 ::std::ptr::addr_of!((*this)._bitfield_1),
1261 19usize,
1262 5u8,
1263 ) as u32)
1264 }
1265 }
1266 #[inline]
1267 pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT32) {
1268 unsafe {
1269 let val: u32 = ::std::mem::transmute(val);
1270 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1271 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1272 19usize,
1273 5u8,
1274 val as u64,
1275 )
1276 }
1277 }
1278 #[inline]
1279 pub fn AllowOpenInKernelMode(&self) -> UINT32 {
1280 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
1281 }
1282 #[inline]
1283 pub fn set_AllowOpenInKernelMode(&mut self, val: UINT32) {
1284 unsafe {
1285 let val: u32 = ::std::mem::transmute(val);
1286 self._bitfield_1.set(24usize, 1u8, val as u64)
1287 }
1288 }
1289 #[inline]
1290 pub unsafe fn AllowOpenInKernelMode_raw(this: *const Self) -> UINT32 {
1291 unsafe {
1292 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1293 ::std::ptr::addr_of!((*this)._bitfield_1),
1294 24usize,
1295 1u8,
1296 ) as u32)
1297 }
1298 }
1299 #[inline]
1300 pub unsafe fn set_AllowOpenInKernelMode_raw(this: *mut Self, val: UINT32) {
1301 unsafe {
1302 let val: u32 = ::std::mem::transmute(val);
1303 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1304 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1305 24usize,
1306 1u8,
1307 val as u64,
1308 )
1309 }
1310 }
1311 #[inline]
1312 pub fn CasePreservedExtendedAttributes(&self) -> UINT32 {
1313 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
1314 }
1315 #[inline]
1316 pub fn set_CasePreservedExtendedAttributes(&mut self, val: UINT32) {
1317 unsafe {
1318 let val: u32 = ::std::mem::transmute(val);
1319 self._bitfield_1.set(25usize, 1u8, val as u64)
1320 }
1321 }
1322 #[inline]
1323 pub unsafe fn CasePreservedExtendedAttributes_raw(this: *const Self) -> UINT32 {
1324 unsafe {
1325 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1326 ::std::ptr::addr_of!((*this)._bitfield_1),
1327 25usize,
1328 1u8,
1329 ) as u32)
1330 }
1331 }
1332 #[inline]
1333 pub unsafe fn set_CasePreservedExtendedAttributes_raw(this: *mut Self, val: UINT32) {
1334 unsafe {
1335 let val: u32 = ::std::mem::transmute(val);
1336 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1337 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1338 25usize,
1339 1u8,
1340 val as u64,
1341 )
1342 }
1343 }
1344 #[inline]
1345 pub fn WslFeatures(&self) -> UINT32 {
1346 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
1347 }
1348 #[inline]
1349 pub fn set_WslFeatures(&mut self, val: UINT32) {
1350 unsafe {
1351 let val: u32 = ::std::mem::transmute(val);
1352 self._bitfield_1.set(26usize, 1u8, val as u64)
1353 }
1354 }
1355 #[inline]
1356 pub unsafe fn WslFeatures_raw(this: *const Self) -> UINT32 {
1357 unsafe {
1358 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1359 ::std::ptr::addr_of!((*this)._bitfield_1),
1360 26usize,
1361 1u8,
1362 ) as u32)
1363 }
1364 }
1365 #[inline]
1366 pub unsafe fn set_WslFeatures_raw(this: *mut Self, val: UINT32) {
1367 unsafe {
1368 let val: u32 = ::std::mem::transmute(val);
1369 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1370 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1371 26usize,
1372 1u8,
1373 val as u64,
1374 )
1375 }
1376 }
1377 #[inline]
1378 pub fn DirectoryMarkerAsNextOffset(&self) -> UINT32 {
1379 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
1380 }
1381 #[inline]
1382 pub fn set_DirectoryMarkerAsNextOffset(&mut self, val: UINT32) {
1383 unsafe {
1384 let val: u32 = ::std::mem::transmute(val);
1385 self._bitfield_1.set(27usize, 1u8, val as u64)
1386 }
1387 }
1388 #[inline]
1389 pub unsafe fn DirectoryMarkerAsNextOffset_raw(this: *const Self) -> UINT32 {
1390 unsafe {
1391 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1392 ::std::ptr::addr_of!((*this)._bitfield_1),
1393 27usize,
1394 1u8,
1395 ) as u32)
1396 }
1397 }
1398 #[inline]
1399 pub unsafe fn set_DirectoryMarkerAsNextOffset_raw(this: *mut Self, val: UINT32) {
1400 unsafe {
1401 let val: u32 = ::std::mem::transmute(val);
1402 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1403 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1404 27usize,
1405 1u8,
1406 val as u64,
1407 )
1408 }
1409 }
1410 #[inline]
1411 pub fn RejectIrpPriorToTransact0(&self) -> UINT32 {
1412 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
1413 }
1414 #[inline]
1415 pub fn set_RejectIrpPriorToTransact0(&mut self, val: UINT32) {
1416 unsafe {
1417 let val: u32 = ::std::mem::transmute(val);
1418 self._bitfield_1.set(28usize, 1u8, val as u64)
1419 }
1420 }
1421 #[inline]
1422 pub unsafe fn RejectIrpPriorToTransact0_raw(this: *const Self) -> UINT32 {
1423 unsafe {
1424 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1425 ::std::ptr::addr_of!((*this)._bitfield_1),
1426 28usize,
1427 1u8,
1428 ) as u32)
1429 }
1430 }
1431 #[inline]
1432 pub unsafe fn set_RejectIrpPriorToTransact0_raw(this: *mut Self, val: UINT32) {
1433 unsafe {
1434 let val: u32 = ::std::mem::transmute(val);
1435 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1436 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1437 28usize,
1438 1u8,
1439 val as u64,
1440 )
1441 }
1442 }
1443 #[inline]
1444 pub fn SupportsPosixUnlinkRename(&self) -> UINT32 {
1445 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
1446 }
1447 #[inline]
1448 pub fn set_SupportsPosixUnlinkRename(&mut self, val: UINT32) {
1449 unsafe {
1450 let val: u32 = ::std::mem::transmute(val);
1451 self._bitfield_1.set(29usize, 1u8, val as u64)
1452 }
1453 }
1454 #[inline]
1455 pub unsafe fn SupportsPosixUnlinkRename_raw(this: *const Self) -> UINT32 {
1456 unsafe {
1457 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1458 ::std::ptr::addr_of!((*this)._bitfield_1),
1459 29usize,
1460 1u8,
1461 ) as u32)
1462 }
1463 }
1464 #[inline]
1465 pub unsafe fn set_SupportsPosixUnlinkRename_raw(this: *mut Self, val: UINT32) {
1466 unsafe {
1467 let val: u32 = ::std::mem::transmute(val);
1468 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1469 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1470 29usize,
1471 1u8,
1472 val as u64,
1473 )
1474 }
1475 }
1476 #[inline]
1477 pub fn PostDispositionWhenNecessaryOnly(&self) -> UINT32 {
1478 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
1479 }
1480 #[inline]
1481 pub fn set_PostDispositionWhenNecessaryOnly(&mut self, val: UINT32) {
1482 unsafe {
1483 let val: u32 = ::std::mem::transmute(val);
1484 self._bitfield_1.set(30usize, 1u8, val as u64)
1485 }
1486 }
1487 #[inline]
1488 pub unsafe fn PostDispositionWhenNecessaryOnly_raw(this: *const Self) -> UINT32 {
1489 unsafe {
1490 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1491 ::std::ptr::addr_of!((*this)._bitfield_1),
1492 30usize,
1493 1u8,
1494 ) as u32)
1495 }
1496 }
1497 #[inline]
1498 pub unsafe fn set_PostDispositionWhenNecessaryOnly_raw(this: *mut Self, val: UINT32) {
1499 unsafe {
1500 let val: u32 = ::std::mem::transmute(val);
1501 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1502 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1503 30usize,
1504 1u8,
1505 val as u64,
1506 )
1507 }
1508 }
1509 #[inline]
1510 pub fn KmReservedFlags(&self) -> UINT32 {
1511 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
1512 }
1513 #[inline]
1514 pub fn set_KmReservedFlags(&mut self, val: UINT32) {
1515 unsafe {
1516 let val: u32 = ::std::mem::transmute(val);
1517 self._bitfield_1.set(31usize, 1u8, val as u64)
1518 }
1519 }
1520 #[inline]
1521 pub unsafe fn KmReservedFlags_raw(this: *const Self) -> UINT32 {
1522 unsafe {
1523 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1524 ::std::ptr::addr_of!((*this)._bitfield_1),
1525 31usize,
1526 1u8,
1527 ) as u32)
1528 }
1529 }
1530 #[inline]
1531 pub unsafe fn set_KmReservedFlags_raw(this: *mut Self, val: UINT32) {
1532 unsafe {
1533 let val: u32 = ::std::mem::transmute(val);
1534 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1535 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1536 31usize,
1537 1u8,
1538 val as u64,
1539 )
1540 }
1541 }
1542 #[inline]
1543 pub fn new_bitfield_1(
1544 CaseSensitiveSearch: UINT32,
1545 CasePreservedNames: UINT32,
1546 UnicodeOnDisk: UINT32,
1547 PersistentAcls: UINT32,
1548 ReparsePoints: UINT32,
1549 ReparsePointsAccessCheck: UINT32,
1550 NamedStreams: UINT32,
1551 HardLinks: UINT32,
1552 ExtendedAttributes: UINT32,
1553 ReadOnlyVolume: UINT32,
1554 PostCleanupWhenModifiedOnly: UINT32,
1555 PassQueryDirectoryPattern: UINT32,
1556 AlwaysUseDoubleBuffering: UINT32,
1557 PassQueryDirectoryFileName: UINT32,
1558 FlushAndPurgeOnCleanup: UINT32,
1559 DeviceControl: UINT32,
1560 UmFileContextIsUserContext2: UINT32,
1561 UmFileContextIsFullContext: UINT32,
1562 UmNoReparsePointsDirCheck: UINT32,
1563 UmReservedFlags: UINT32,
1564 AllowOpenInKernelMode: UINT32,
1565 CasePreservedExtendedAttributes: UINT32,
1566 WslFeatures: UINT32,
1567 DirectoryMarkerAsNextOffset: UINT32,
1568 RejectIrpPriorToTransact0: UINT32,
1569 SupportsPosixUnlinkRename: UINT32,
1570 PostDispositionWhenNecessaryOnly: UINT32,
1571 KmReservedFlags: UINT32,
1572 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1573 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1574 __bindgen_bitfield_unit.set(0usize, 1u8, {
1575 let CaseSensitiveSearch: u32 = unsafe { ::std::mem::transmute(CaseSensitiveSearch) };
1576 CaseSensitiveSearch as u64
1577 });
1578 __bindgen_bitfield_unit.set(1usize, 1u8, {
1579 let CasePreservedNames: u32 = unsafe { ::std::mem::transmute(CasePreservedNames) };
1580 CasePreservedNames as u64
1581 });
1582 __bindgen_bitfield_unit.set(2usize, 1u8, {
1583 let UnicodeOnDisk: u32 = unsafe { ::std::mem::transmute(UnicodeOnDisk) };
1584 UnicodeOnDisk as u64
1585 });
1586 __bindgen_bitfield_unit.set(3usize, 1u8, {
1587 let PersistentAcls: u32 = unsafe { ::std::mem::transmute(PersistentAcls) };
1588 PersistentAcls as u64
1589 });
1590 __bindgen_bitfield_unit.set(4usize, 1u8, {
1591 let ReparsePoints: u32 = unsafe { ::std::mem::transmute(ReparsePoints) };
1592 ReparsePoints as u64
1593 });
1594 __bindgen_bitfield_unit.set(5usize, 1u8, {
1595 let ReparsePointsAccessCheck: u32 =
1596 unsafe { ::std::mem::transmute(ReparsePointsAccessCheck) };
1597 ReparsePointsAccessCheck as u64
1598 });
1599 __bindgen_bitfield_unit.set(6usize, 1u8, {
1600 let NamedStreams: u32 = unsafe { ::std::mem::transmute(NamedStreams) };
1601 NamedStreams as u64
1602 });
1603 __bindgen_bitfield_unit.set(7usize, 1u8, {
1604 let HardLinks: u32 = unsafe { ::std::mem::transmute(HardLinks) };
1605 HardLinks as u64
1606 });
1607 __bindgen_bitfield_unit.set(8usize, 1u8, {
1608 let ExtendedAttributes: u32 = unsafe { ::std::mem::transmute(ExtendedAttributes) };
1609 ExtendedAttributes as u64
1610 });
1611 __bindgen_bitfield_unit.set(9usize, 1u8, {
1612 let ReadOnlyVolume: u32 = unsafe { ::std::mem::transmute(ReadOnlyVolume) };
1613 ReadOnlyVolume as u64
1614 });
1615 __bindgen_bitfield_unit.set(10usize, 1u8, {
1616 let PostCleanupWhenModifiedOnly: u32 =
1617 unsafe { ::std::mem::transmute(PostCleanupWhenModifiedOnly) };
1618 PostCleanupWhenModifiedOnly as u64
1619 });
1620 __bindgen_bitfield_unit.set(11usize, 1u8, {
1621 let PassQueryDirectoryPattern: u32 =
1622 unsafe { ::std::mem::transmute(PassQueryDirectoryPattern) };
1623 PassQueryDirectoryPattern as u64
1624 });
1625 __bindgen_bitfield_unit.set(12usize, 1u8, {
1626 let AlwaysUseDoubleBuffering: u32 =
1627 unsafe { ::std::mem::transmute(AlwaysUseDoubleBuffering) };
1628 AlwaysUseDoubleBuffering as u64
1629 });
1630 __bindgen_bitfield_unit.set(13usize, 1u8, {
1631 let PassQueryDirectoryFileName: u32 =
1632 unsafe { ::std::mem::transmute(PassQueryDirectoryFileName) };
1633 PassQueryDirectoryFileName as u64
1634 });
1635 __bindgen_bitfield_unit.set(14usize, 1u8, {
1636 let FlushAndPurgeOnCleanup: u32 =
1637 unsafe { ::std::mem::transmute(FlushAndPurgeOnCleanup) };
1638 FlushAndPurgeOnCleanup as u64
1639 });
1640 __bindgen_bitfield_unit.set(15usize, 1u8, {
1641 let DeviceControl: u32 = unsafe { ::std::mem::transmute(DeviceControl) };
1642 DeviceControl as u64
1643 });
1644 __bindgen_bitfield_unit.set(16usize, 1u8, {
1645 let UmFileContextIsUserContext2: u32 =
1646 unsafe { ::std::mem::transmute(UmFileContextIsUserContext2) };
1647 UmFileContextIsUserContext2 as u64
1648 });
1649 __bindgen_bitfield_unit.set(17usize, 1u8, {
1650 let UmFileContextIsFullContext: u32 =
1651 unsafe { ::std::mem::transmute(UmFileContextIsFullContext) };
1652 UmFileContextIsFullContext as u64
1653 });
1654 __bindgen_bitfield_unit.set(18usize, 1u8, {
1655 let UmNoReparsePointsDirCheck: u32 =
1656 unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
1657 UmNoReparsePointsDirCheck as u64
1658 });
1659 __bindgen_bitfield_unit.set(19usize, 5u8, {
1660 let UmReservedFlags: u32 = unsafe { ::std::mem::transmute(UmReservedFlags) };
1661 UmReservedFlags as u64
1662 });
1663 __bindgen_bitfield_unit.set(24usize, 1u8, {
1664 let AllowOpenInKernelMode: u32 =
1665 unsafe { ::std::mem::transmute(AllowOpenInKernelMode) };
1666 AllowOpenInKernelMode as u64
1667 });
1668 __bindgen_bitfield_unit.set(25usize, 1u8, {
1669 let CasePreservedExtendedAttributes: u32 =
1670 unsafe { ::std::mem::transmute(CasePreservedExtendedAttributes) };
1671 CasePreservedExtendedAttributes as u64
1672 });
1673 __bindgen_bitfield_unit.set(26usize, 1u8, {
1674 let WslFeatures: u32 = unsafe { ::std::mem::transmute(WslFeatures) };
1675 WslFeatures as u64
1676 });
1677 __bindgen_bitfield_unit.set(27usize, 1u8, {
1678 let DirectoryMarkerAsNextOffset: u32 =
1679 unsafe { ::std::mem::transmute(DirectoryMarkerAsNextOffset) };
1680 DirectoryMarkerAsNextOffset as u64
1681 });
1682 __bindgen_bitfield_unit.set(28usize, 1u8, {
1683 let RejectIrpPriorToTransact0: u32 =
1684 unsafe { ::std::mem::transmute(RejectIrpPriorToTransact0) };
1685 RejectIrpPriorToTransact0 as u64
1686 });
1687 __bindgen_bitfield_unit.set(29usize, 1u8, {
1688 let SupportsPosixUnlinkRename: u32 =
1689 unsafe { ::std::mem::transmute(SupportsPosixUnlinkRename) };
1690 SupportsPosixUnlinkRename as u64
1691 });
1692 __bindgen_bitfield_unit.set(30usize, 1u8, {
1693 let PostDispositionWhenNecessaryOnly: u32 =
1694 unsafe { ::std::mem::transmute(PostDispositionWhenNecessaryOnly) };
1695 PostDispositionWhenNecessaryOnly as u64
1696 });
1697 __bindgen_bitfield_unit.set(31usize, 1u8, {
1698 let KmReservedFlags: u32 = unsafe { ::std::mem::transmute(KmReservedFlags) };
1699 KmReservedFlags as u64
1700 });
1701 __bindgen_bitfield_unit
1702 }
1703}
1704#[repr(C)]
1705#[derive(Debug, Copy, Clone)]
1706pub struct FSP_FSCTL_VOLUME_PARAMS {
1707 pub Version: UINT16,
1708 pub SectorSize: UINT16,
1709 pub SectorsPerAllocationUnit: UINT16,
1710 pub MaxComponentLength: UINT16,
1711 pub VolumeCreationTime: UINT64,
1712 pub VolumeSerialNumber: UINT32,
1713 pub TransactTimeout: UINT32,
1714 pub IrpTimeout: UINT32,
1715 pub IrpCapacity: UINT32,
1716 pub FileInfoTimeout: UINT32,
1717 pub _bitfield_align_1: [u8; 0],
1718 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1719 pub Prefix: [WCHAR; 192usize],
1720 pub FileSystemName: [WCHAR; 16usize],
1721 pub _bitfield_align_2: [u32; 0],
1722 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
1723 pub VolumeInfoTimeout: UINT32,
1724 pub DirInfoTimeout: UINT32,
1725 pub SecurityTimeout: UINT32,
1726 pub StreamInfoTimeout: UINT32,
1727 pub EaTimeout: UINT32,
1728 pub FsextControlCode: UINT32,
1729 pub Reserved32: [UINT32; 1usize],
1730 pub Reserved64: [UINT64; 2usize],
1731}
1732#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1733const _: () = {
1734 ["Size of FSP_FSCTL_VOLUME_PARAMS"]
1735 [::std::mem::size_of::<FSP_FSCTL_VOLUME_PARAMS>() - 504usize];
1736 ["Alignment of FSP_FSCTL_VOLUME_PARAMS"]
1737 [::std::mem::align_of::<FSP_FSCTL_VOLUME_PARAMS>() - 8usize];
1738 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Version"]
1739 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Version) - 0usize];
1740 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SectorSize"]
1741 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SectorSize) - 2usize];
1742 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SectorsPerAllocationUnit"]
1743 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SectorsPerAllocationUnit) - 4usize];
1744 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::MaxComponentLength"]
1745 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, MaxComponentLength) - 6usize];
1746 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeCreationTime"]
1747 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeCreationTime) - 8usize];
1748 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeSerialNumber"]
1749 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeSerialNumber) - 16usize];
1750 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::TransactTimeout"]
1751 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, TransactTimeout) - 20usize];
1752 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::IrpTimeout"]
1753 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, IrpTimeout) - 24usize];
1754 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::IrpCapacity"]
1755 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, IrpCapacity) - 28usize];
1756 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FileInfoTimeout"]
1757 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FileInfoTimeout) - 32usize];
1758 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Prefix"]
1759 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Prefix) - 40usize];
1760 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FileSystemName"]
1761 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FileSystemName) - 424usize];
1762 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeInfoTimeout"]
1763 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeInfoTimeout) - 460usize];
1764 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::DirInfoTimeout"]
1765 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, DirInfoTimeout) - 464usize];
1766 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SecurityTimeout"]
1767 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SecurityTimeout) - 468usize];
1768 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::StreamInfoTimeout"]
1769 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, StreamInfoTimeout) - 472usize];
1770 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::EaTimeout"]
1771 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, EaTimeout) - 476usize];
1772 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FsextControlCode"]
1773 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FsextControlCode) - 480usize];
1774 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Reserved32"]
1775 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Reserved32) - 484usize];
1776 ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Reserved64"]
1777 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Reserved64) - 488usize];
1778};
1779impl Default for FSP_FSCTL_VOLUME_PARAMS {
1780 fn default() -> Self {
1781 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1782 unsafe {
1783 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1784 s.assume_init()
1785 }
1786 }
1787}
1788impl FSP_FSCTL_VOLUME_PARAMS {
1789 #[inline]
1790 pub fn CaseSensitiveSearch(&self) -> UINT32 {
1791 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1792 }
1793 #[inline]
1794 pub fn set_CaseSensitiveSearch(&mut self, val: UINT32) {
1795 unsafe {
1796 let val: u32 = ::std::mem::transmute(val);
1797 self._bitfield_1.set(0usize, 1u8, val as u64)
1798 }
1799 }
1800 #[inline]
1801 pub unsafe fn CaseSensitiveSearch_raw(this: *const Self) -> UINT32 {
1802 unsafe {
1803 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1804 ::std::ptr::addr_of!((*this)._bitfield_1),
1805 0usize,
1806 1u8,
1807 ) as u32)
1808 }
1809 }
1810 #[inline]
1811 pub unsafe fn set_CaseSensitiveSearch_raw(this: *mut Self, val: UINT32) {
1812 unsafe {
1813 let val: u32 = ::std::mem::transmute(val);
1814 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1815 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1816 0usize,
1817 1u8,
1818 val as u64,
1819 )
1820 }
1821 }
1822 #[inline]
1823 pub fn CasePreservedNames(&self) -> UINT32 {
1824 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1825 }
1826 #[inline]
1827 pub fn set_CasePreservedNames(&mut self, val: UINT32) {
1828 unsafe {
1829 let val: u32 = ::std::mem::transmute(val);
1830 self._bitfield_1.set(1usize, 1u8, val as u64)
1831 }
1832 }
1833 #[inline]
1834 pub unsafe fn CasePreservedNames_raw(this: *const Self) -> UINT32 {
1835 unsafe {
1836 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1837 ::std::ptr::addr_of!((*this)._bitfield_1),
1838 1usize,
1839 1u8,
1840 ) as u32)
1841 }
1842 }
1843 #[inline]
1844 pub unsafe fn set_CasePreservedNames_raw(this: *mut Self, val: UINT32) {
1845 unsafe {
1846 let val: u32 = ::std::mem::transmute(val);
1847 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1848 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1849 1usize,
1850 1u8,
1851 val as u64,
1852 )
1853 }
1854 }
1855 #[inline]
1856 pub fn UnicodeOnDisk(&self) -> UINT32 {
1857 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1858 }
1859 #[inline]
1860 pub fn set_UnicodeOnDisk(&mut self, val: UINT32) {
1861 unsafe {
1862 let val: u32 = ::std::mem::transmute(val);
1863 self._bitfield_1.set(2usize, 1u8, val as u64)
1864 }
1865 }
1866 #[inline]
1867 pub unsafe fn UnicodeOnDisk_raw(this: *const Self) -> UINT32 {
1868 unsafe {
1869 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1870 ::std::ptr::addr_of!((*this)._bitfield_1),
1871 2usize,
1872 1u8,
1873 ) as u32)
1874 }
1875 }
1876 #[inline]
1877 pub unsafe fn set_UnicodeOnDisk_raw(this: *mut Self, val: UINT32) {
1878 unsafe {
1879 let val: u32 = ::std::mem::transmute(val);
1880 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1881 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1882 2usize,
1883 1u8,
1884 val as u64,
1885 )
1886 }
1887 }
1888 #[inline]
1889 pub fn PersistentAcls(&self) -> UINT32 {
1890 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1891 }
1892 #[inline]
1893 pub fn set_PersistentAcls(&mut self, val: UINT32) {
1894 unsafe {
1895 let val: u32 = ::std::mem::transmute(val);
1896 self._bitfield_1.set(3usize, 1u8, val as u64)
1897 }
1898 }
1899 #[inline]
1900 pub unsafe fn PersistentAcls_raw(this: *const Self) -> UINT32 {
1901 unsafe {
1902 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1903 ::std::ptr::addr_of!((*this)._bitfield_1),
1904 3usize,
1905 1u8,
1906 ) as u32)
1907 }
1908 }
1909 #[inline]
1910 pub unsafe fn set_PersistentAcls_raw(this: *mut Self, val: UINT32) {
1911 unsafe {
1912 let val: u32 = ::std::mem::transmute(val);
1913 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1914 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1915 3usize,
1916 1u8,
1917 val as u64,
1918 )
1919 }
1920 }
1921 #[inline]
1922 pub fn ReparsePoints(&self) -> UINT32 {
1923 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1924 }
1925 #[inline]
1926 pub fn set_ReparsePoints(&mut self, val: UINT32) {
1927 unsafe {
1928 let val: u32 = ::std::mem::transmute(val);
1929 self._bitfield_1.set(4usize, 1u8, val as u64)
1930 }
1931 }
1932 #[inline]
1933 pub unsafe fn ReparsePoints_raw(this: *const Self) -> UINT32 {
1934 unsafe {
1935 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1936 ::std::ptr::addr_of!((*this)._bitfield_1),
1937 4usize,
1938 1u8,
1939 ) as u32)
1940 }
1941 }
1942 #[inline]
1943 pub unsafe fn set_ReparsePoints_raw(this: *mut Self, val: UINT32) {
1944 unsafe {
1945 let val: u32 = ::std::mem::transmute(val);
1946 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1947 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1948 4usize,
1949 1u8,
1950 val as u64,
1951 )
1952 }
1953 }
1954 #[inline]
1955 pub fn ReparsePointsAccessCheck(&self) -> UINT32 {
1956 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1957 }
1958 #[inline]
1959 pub fn set_ReparsePointsAccessCheck(&mut self, val: UINT32) {
1960 unsafe {
1961 let val: u32 = ::std::mem::transmute(val);
1962 self._bitfield_1.set(5usize, 1u8, val as u64)
1963 }
1964 }
1965 #[inline]
1966 pub unsafe fn ReparsePointsAccessCheck_raw(this: *const Self) -> UINT32 {
1967 unsafe {
1968 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1969 ::std::ptr::addr_of!((*this)._bitfield_1),
1970 5usize,
1971 1u8,
1972 ) as u32)
1973 }
1974 }
1975 #[inline]
1976 pub unsafe fn set_ReparsePointsAccessCheck_raw(this: *mut Self, val: UINT32) {
1977 unsafe {
1978 let val: u32 = ::std::mem::transmute(val);
1979 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1980 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1981 5usize,
1982 1u8,
1983 val as u64,
1984 )
1985 }
1986 }
1987 #[inline]
1988 pub fn NamedStreams(&self) -> UINT32 {
1989 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1990 }
1991 #[inline]
1992 pub fn set_NamedStreams(&mut self, val: UINT32) {
1993 unsafe {
1994 let val: u32 = ::std::mem::transmute(val);
1995 self._bitfield_1.set(6usize, 1u8, val as u64)
1996 }
1997 }
1998 #[inline]
1999 pub unsafe fn NamedStreams_raw(this: *const Self) -> UINT32 {
2000 unsafe {
2001 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2002 ::std::ptr::addr_of!((*this)._bitfield_1),
2003 6usize,
2004 1u8,
2005 ) as u32)
2006 }
2007 }
2008 #[inline]
2009 pub unsafe fn set_NamedStreams_raw(this: *mut Self, val: UINT32) {
2010 unsafe {
2011 let val: u32 = ::std::mem::transmute(val);
2012 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2013 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2014 6usize,
2015 1u8,
2016 val as u64,
2017 )
2018 }
2019 }
2020 #[inline]
2021 pub fn HardLinks(&self) -> UINT32 {
2022 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2023 }
2024 #[inline]
2025 pub fn set_HardLinks(&mut self, val: UINT32) {
2026 unsafe {
2027 let val: u32 = ::std::mem::transmute(val);
2028 self._bitfield_1.set(7usize, 1u8, val as u64)
2029 }
2030 }
2031 #[inline]
2032 pub unsafe fn HardLinks_raw(this: *const Self) -> UINT32 {
2033 unsafe {
2034 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2035 ::std::ptr::addr_of!((*this)._bitfield_1),
2036 7usize,
2037 1u8,
2038 ) as u32)
2039 }
2040 }
2041 #[inline]
2042 pub unsafe fn set_HardLinks_raw(this: *mut Self, val: UINT32) {
2043 unsafe {
2044 let val: u32 = ::std::mem::transmute(val);
2045 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2046 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2047 7usize,
2048 1u8,
2049 val as u64,
2050 )
2051 }
2052 }
2053 #[inline]
2054 pub fn ExtendedAttributes(&self) -> UINT32 {
2055 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
2056 }
2057 #[inline]
2058 pub fn set_ExtendedAttributes(&mut self, val: UINT32) {
2059 unsafe {
2060 let val: u32 = ::std::mem::transmute(val);
2061 self._bitfield_1.set(8usize, 1u8, val as u64)
2062 }
2063 }
2064 #[inline]
2065 pub unsafe fn ExtendedAttributes_raw(this: *const Self) -> UINT32 {
2066 unsafe {
2067 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2068 ::std::ptr::addr_of!((*this)._bitfield_1),
2069 8usize,
2070 1u8,
2071 ) as u32)
2072 }
2073 }
2074 #[inline]
2075 pub unsafe fn set_ExtendedAttributes_raw(this: *mut Self, val: UINT32) {
2076 unsafe {
2077 let val: u32 = ::std::mem::transmute(val);
2078 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2079 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2080 8usize,
2081 1u8,
2082 val as u64,
2083 )
2084 }
2085 }
2086 #[inline]
2087 pub fn ReadOnlyVolume(&self) -> UINT32 {
2088 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
2089 }
2090 #[inline]
2091 pub fn set_ReadOnlyVolume(&mut self, val: UINT32) {
2092 unsafe {
2093 let val: u32 = ::std::mem::transmute(val);
2094 self._bitfield_1.set(9usize, 1u8, val as u64)
2095 }
2096 }
2097 #[inline]
2098 pub unsafe fn ReadOnlyVolume_raw(this: *const Self) -> UINT32 {
2099 unsafe {
2100 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2101 ::std::ptr::addr_of!((*this)._bitfield_1),
2102 9usize,
2103 1u8,
2104 ) as u32)
2105 }
2106 }
2107 #[inline]
2108 pub unsafe fn set_ReadOnlyVolume_raw(this: *mut Self, val: UINT32) {
2109 unsafe {
2110 let val: u32 = ::std::mem::transmute(val);
2111 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2112 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2113 9usize,
2114 1u8,
2115 val as u64,
2116 )
2117 }
2118 }
2119 #[inline]
2120 pub fn PostCleanupWhenModifiedOnly(&self) -> UINT32 {
2121 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2122 }
2123 #[inline]
2124 pub fn set_PostCleanupWhenModifiedOnly(&mut self, val: UINT32) {
2125 unsafe {
2126 let val: u32 = ::std::mem::transmute(val);
2127 self._bitfield_1.set(10usize, 1u8, val as u64)
2128 }
2129 }
2130 #[inline]
2131 pub unsafe fn PostCleanupWhenModifiedOnly_raw(this: *const Self) -> UINT32 {
2132 unsafe {
2133 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2134 ::std::ptr::addr_of!((*this)._bitfield_1),
2135 10usize,
2136 1u8,
2137 ) as u32)
2138 }
2139 }
2140 #[inline]
2141 pub unsafe fn set_PostCleanupWhenModifiedOnly_raw(this: *mut Self, val: UINT32) {
2142 unsafe {
2143 let val: u32 = ::std::mem::transmute(val);
2144 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2145 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2146 10usize,
2147 1u8,
2148 val as u64,
2149 )
2150 }
2151 }
2152 #[inline]
2153 pub fn PassQueryDirectoryPattern(&self) -> UINT32 {
2154 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2155 }
2156 #[inline]
2157 pub fn set_PassQueryDirectoryPattern(&mut self, val: UINT32) {
2158 unsafe {
2159 let val: u32 = ::std::mem::transmute(val);
2160 self._bitfield_1.set(11usize, 1u8, val as u64)
2161 }
2162 }
2163 #[inline]
2164 pub unsafe fn PassQueryDirectoryPattern_raw(this: *const Self) -> UINT32 {
2165 unsafe {
2166 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2167 ::std::ptr::addr_of!((*this)._bitfield_1),
2168 11usize,
2169 1u8,
2170 ) as u32)
2171 }
2172 }
2173 #[inline]
2174 pub unsafe fn set_PassQueryDirectoryPattern_raw(this: *mut Self, val: UINT32) {
2175 unsafe {
2176 let val: u32 = ::std::mem::transmute(val);
2177 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2178 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2179 11usize,
2180 1u8,
2181 val as u64,
2182 )
2183 }
2184 }
2185 #[inline]
2186 pub fn AlwaysUseDoubleBuffering(&self) -> UINT32 {
2187 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2188 }
2189 #[inline]
2190 pub fn set_AlwaysUseDoubleBuffering(&mut self, val: UINT32) {
2191 unsafe {
2192 let val: u32 = ::std::mem::transmute(val);
2193 self._bitfield_1.set(12usize, 1u8, val as u64)
2194 }
2195 }
2196 #[inline]
2197 pub unsafe fn AlwaysUseDoubleBuffering_raw(this: *const Self) -> UINT32 {
2198 unsafe {
2199 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2200 ::std::ptr::addr_of!((*this)._bitfield_1),
2201 12usize,
2202 1u8,
2203 ) as u32)
2204 }
2205 }
2206 #[inline]
2207 pub unsafe fn set_AlwaysUseDoubleBuffering_raw(this: *mut Self, val: UINT32) {
2208 unsafe {
2209 let val: u32 = ::std::mem::transmute(val);
2210 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2211 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2212 12usize,
2213 1u8,
2214 val as u64,
2215 )
2216 }
2217 }
2218 #[inline]
2219 pub fn PassQueryDirectoryFileName(&self) -> UINT32 {
2220 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2221 }
2222 #[inline]
2223 pub fn set_PassQueryDirectoryFileName(&mut self, val: UINT32) {
2224 unsafe {
2225 let val: u32 = ::std::mem::transmute(val);
2226 self._bitfield_1.set(13usize, 1u8, val as u64)
2227 }
2228 }
2229 #[inline]
2230 pub unsafe fn PassQueryDirectoryFileName_raw(this: *const Self) -> UINT32 {
2231 unsafe {
2232 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2233 ::std::ptr::addr_of!((*this)._bitfield_1),
2234 13usize,
2235 1u8,
2236 ) as u32)
2237 }
2238 }
2239 #[inline]
2240 pub unsafe fn set_PassQueryDirectoryFileName_raw(this: *mut Self, val: UINT32) {
2241 unsafe {
2242 let val: u32 = ::std::mem::transmute(val);
2243 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2244 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2245 13usize,
2246 1u8,
2247 val as u64,
2248 )
2249 }
2250 }
2251 #[inline]
2252 pub fn FlushAndPurgeOnCleanup(&self) -> UINT32 {
2253 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2254 }
2255 #[inline]
2256 pub fn set_FlushAndPurgeOnCleanup(&mut self, val: UINT32) {
2257 unsafe {
2258 let val: u32 = ::std::mem::transmute(val);
2259 self._bitfield_1.set(14usize, 1u8, val as u64)
2260 }
2261 }
2262 #[inline]
2263 pub unsafe fn FlushAndPurgeOnCleanup_raw(this: *const Self) -> UINT32 {
2264 unsafe {
2265 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2266 ::std::ptr::addr_of!((*this)._bitfield_1),
2267 14usize,
2268 1u8,
2269 ) as u32)
2270 }
2271 }
2272 #[inline]
2273 pub unsafe fn set_FlushAndPurgeOnCleanup_raw(this: *mut Self, val: UINT32) {
2274 unsafe {
2275 let val: u32 = ::std::mem::transmute(val);
2276 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2277 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2278 14usize,
2279 1u8,
2280 val as u64,
2281 )
2282 }
2283 }
2284 #[inline]
2285 pub fn DeviceControl(&self) -> UINT32 {
2286 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2287 }
2288 #[inline]
2289 pub fn set_DeviceControl(&mut self, val: UINT32) {
2290 unsafe {
2291 let val: u32 = ::std::mem::transmute(val);
2292 self._bitfield_1.set(15usize, 1u8, val as u64)
2293 }
2294 }
2295 #[inline]
2296 pub unsafe fn DeviceControl_raw(this: *const Self) -> UINT32 {
2297 unsafe {
2298 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2299 ::std::ptr::addr_of!((*this)._bitfield_1),
2300 15usize,
2301 1u8,
2302 ) as u32)
2303 }
2304 }
2305 #[inline]
2306 pub unsafe fn set_DeviceControl_raw(this: *mut Self, val: UINT32) {
2307 unsafe {
2308 let val: u32 = ::std::mem::transmute(val);
2309 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2310 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2311 15usize,
2312 1u8,
2313 val as u64,
2314 )
2315 }
2316 }
2317 #[inline]
2318 pub fn UmFileContextIsUserContext2(&self) -> UINT32 {
2319 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2320 }
2321 #[inline]
2322 pub fn set_UmFileContextIsUserContext2(&mut self, val: UINT32) {
2323 unsafe {
2324 let val: u32 = ::std::mem::transmute(val);
2325 self._bitfield_1.set(16usize, 1u8, val as u64)
2326 }
2327 }
2328 #[inline]
2329 pub unsafe fn UmFileContextIsUserContext2_raw(this: *const Self) -> UINT32 {
2330 unsafe {
2331 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2332 ::std::ptr::addr_of!((*this)._bitfield_1),
2333 16usize,
2334 1u8,
2335 ) as u32)
2336 }
2337 }
2338 #[inline]
2339 pub unsafe fn set_UmFileContextIsUserContext2_raw(this: *mut Self, val: UINT32) {
2340 unsafe {
2341 let val: u32 = ::std::mem::transmute(val);
2342 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2343 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2344 16usize,
2345 1u8,
2346 val as u64,
2347 )
2348 }
2349 }
2350 #[inline]
2351 pub fn UmFileContextIsFullContext(&self) -> UINT32 {
2352 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
2353 }
2354 #[inline]
2355 pub fn set_UmFileContextIsFullContext(&mut self, val: UINT32) {
2356 unsafe {
2357 let val: u32 = ::std::mem::transmute(val);
2358 self._bitfield_1.set(17usize, 1u8, val as u64)
2359 }
2360 }
2361 #[inline]
2362 pub unsafe fn UmFileContextIsFullContext_raw(this: *const Self) -> UINT32 {
2363 unsafe {
2364 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2365 ::std::ptr::addr_of!((*this)._bitfield_1),
2366 17usize,
2367 1u8,
2368 ) as u32)
2369 }
2370 }
2371 #[inline]
2372 pub unsafe fn set_UmFileContextIsFullContext_raw(this: *mut Self, val: UINT32) {
2373 unsafe {
2374 let val: u32 = ::std::mem::transmute(val);
2375 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2376 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2377 17usize,
2378 1u8,
2379 val as u64,
2380 )
2381 }
2382 }
2383 #[inline]
2384 pub fn UmNoReparsePointsDirCheck(&self) -> UINT32 {
2385 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
2386 }
2387 #[inline]
2388 pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT32) {
2389 unsafe {
2390 let val: u32 = ::std::mem::transmute(val);
2391 self._bitfield_1.set(18usize, 1u8, val as u64)
2392 }
2393 }
2394 #[inline]
2395 pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT32 {
2396 unsafe {
2397 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2398 ::std::ptr::addr_of!((*this)._bitfield_1),
2399 18usize,
2400 1u8,
2401 ) as u32)
2402 }
2403 }
2404 #[inline]
2405 pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT32) {
2406 unsafe {
2407 let val: u32 = ::std::mem::transmute(val);
2408 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2409 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2410 18usize,
2411 1u8,
2412 val as u64,
2413 )
2414 }
2415 }
2416 #[inline]
2417 pub fn UmReservedFlags(&self) -> UINT32 {
2418 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 5u8) as u32) }
2419 }
2420 #[inline]
2421 pub fn set_UmReservedFlags(&mut self, val: UINT32) {
2422 unsafe {
2423 let val: u32 = ::std::mem::transmute(val);
2424 self._bitfield_1.set(19usize, 5u8, val as u64)
2425 }
2426 }
2427 #[inline]
2428 pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT32 {
2429 unsafe {
2430 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2431 ::std::ptr::addr_of!((*this)._bitfield_1),
2432 19usize,
2433 5u8,
2434 ) as u32)
2435 }
2436 }
2437 #[inline]
2438 pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT32) {
2439 unsafe {
2440 let val: u32 = ::std::mem::transmute(val);
2441 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2442 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2443 19usize,
2444 5u8,
2445 val as u64,
2446 )
2447 }
2448 }
2449 #[inline]
2450 pub fn AllowOpenInKernelMode(&self) -> UINT32 {
2451 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
2452 }
2453 #[inline]
2454 pub fn set_AllowOpenInKernelMode(&mut self, val: UINT32) {
2455 unsafe {
2456 let val: u32 = ::std::mem::transmute(val);
2457 self._bitfield_1.set(24usize, 1u8, val as u64)
2458 }
2459 }
2460 #[inline]
2461 pub unsafe fn AllowOpenInKernelMode_raw(this: *const Self) -> UINT32 {
2462 unsafe {
2463 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2464 ::std::ptr::addr_of!((*this)._bitfield_1),
2465 24usize,
2466 1u8,
2467 ) as u32)
2468 }
2469 }
2470 #[inline]
2471 pub unsafe fn set_AllowOpenInKernelMode_raw(this: *mut Self, val: UINT32) {
2472 unsafe {
2473 let val: u32 = ::std::mem::transmute(val);
2474 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2475 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2476 24usize,
2477 1u8,
2478 val as u64,
2479 )
2480 }
2481 }
2482 #[inline]
2483 pub fn CasePreservedExtendedAttributes(&self) -> UINT32 {
2484 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
2485 }
2486 #[inline]
2487 pub fn set_CasePreservedExtendedAttributes(&mut self, val: UINT32) {
2488 unsafe {
2489 let val: u32 = ::std::mem::transmute(val);
2490 self._bitfield_1.set(25usize, 1u8, val as u64)
2491 }
2492 }
2493 #[inline]
2494 pub unsafe fn CasePreservedExtendedAttributes_raw(this: *const Self) -> UINT32 {
2495 unsafe {
2496 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2497 ::std::ptr::addr_of!((*this)._bitfield_1),
2498 25usize,
2499 1u8,
2500 ) as u32)
2501 }
2502 }
2503 #[inline]
2504 pub unsafe fn set_CasePreservedExtendedAttributes_raw(this: *mut Self, val: UINT32) {
2505 unsafe {
2506 let val: u32 = ::std::mem::transmute(val);
2507 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2508 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2509 25usize,
2510 1u8,
2511 val as u64,
2512 )
2513 }
2514 }
2515 #[inline]
2516 pub fn WslFeatures(&self) -> UINT32 {
2517 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
2518 }
2519 #[inline]
2520 pub fn set_WslFeatures(&mut self, val: UINT32) {
2521 unsafe {
2522 let val: u32 = ::std::mem::transmute(val);
2523 self._bitfield_1.set(26usize, 1u8, val as u64)
2524 }
2525 }
2526 #[inline]
2527 pub unsafe fn WslFeatures_raw(this: *const Self) -> UINT32 {
2528 unsafe {
2529 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2530 ::std::ptr::addr_of!((*this)._bitfield_1),
2531 26usize,
2532 1u8,
2533 ) as u32)
2534 }
2535 }
2536 #[inline]
2537 pub unsafe fn set_WslFeatures_raw(this: *mut Self, val: UINT32) {
2538 unsafe {
2539 let val: u32 = ::std::mem::transmute(val);
2540 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2541 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2542 26usize,
2543 1u8,
2544 val as u64,
2545 )
2546 }
2547 }
2548 #[inline]
2549 pub fn DirectoryMarkerAsNextOffset(&self) -> UINT32 {
2550 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
2551 }
2552 #[inline]
2553 pub fn set_DirectoryMarkerAsNextOffset(&mut self, val: UINT32) {
2554 unsafe {
2555 let val: u32 = ::std::mem::transmute(val);
2556 self._bitfield_1.set(27usize, 1u8, val as u64)
2557 }
2558 }
2559 #[inline]
2560 pub unsafe fn DirectoryMarkerAsNextOffset_raw(this: *const Self) -> UINT32 {
2561 unsafe {
2562 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2563 ::std::ptr::addr_of!((*this)._bitfield_1),
2564 27usize,
2565 1u8,
2566 ) as u32)
2567 }
2568 }
2569 #[inline]
2570 pub unsafe fn set_DirectoryMarkerAsNextOffset_raw(this: *mut Self, val: UINT32) {
2571 unsafe {
2572 let val: u32 = ::std::mem::transmute(val);
2573 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2574 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2575 27usize,
2576 1u8,
2577 val as u64,
2578 )
2579 }
2580 }
2581 #[inline]
2582 pub fn RejectIrpPriorToTransact0(&self) -> UINT32 {
2583 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
2584 }
2585 #[inline]
2586 pub fn set_RejectIrpPriorToTransact0(&mut self, val: UINT32) {
2587 unsafe {
2588 let val: u32 = ::std::mem::transmute(val);
2589 self._bitfield_1.set(28usize, 1u8, val as u64)
2590 }
2591 }
2592 #[inline]
2593 pub unsafe fn RejectIrpPriorToTransact0_raw(this: *const Self) -> UINT32 {
2594 unsafe {
2595 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2596 ::std::ptr::addr_of!((*this)._bitfield_1),
2597 28usize,
2598 1u8,
2599 ) as u32)
2600 }
2601 }
2602 #[inline]
2603 pub unsafe fn set_RejectIrpPriorToTransact0_raw(this: *mut Self, val: UINT32) {
2604 unsafe {
2605 let val: u32 = ::std::mem::transmute(val);
2606 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2607 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2608 28usize,
2609 1u8,
2610 val as u64,
2611 )
2612 }
2613 }
2614 #[inline]
2615 pub fn SupportsPosixUnlinkRename(&self) -> UINT32 {
2616 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
2617 }
2618 #[inline]
2619 pub fn set_SupportsPosixUnlinkRename(&mut self, val: UINT32) {
2620 unsafe {
2621 let val: u32 = ::std::mem::transmute(val);
2622 self._bitfield_1.set(29usize, 1u8, val as u64)
2623 }
2624 }
2625 #[inline]
2626 pub unsafe fn SupportsPosixUnlinkRename_raw(this: *const Self) -> UINT32 {
2627 unsafe {
2628 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2629 ::std::ptr::addr_of!((*this)._bitfield_1),
2630 29usize,
2631 1u8,
2632 ) as u32)
2633 }
2634 }
2635 #[inline]
2636 pub unsafe fn set_SupportsPosixUnlinkRename_raw(this: *mut Self, val: UINT32) {
2637 unsafe {
2638 let val: u32 = ::std::mem::transmute(val);
2639 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2640 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2641 29usize,
2642 1u8,
2643 val as u64,
2644 )
2645 }
2646 }
2647 #[inline]
2648 pub fn PostDispositionWhenNecessaryOnly(&self) -> UINT32 {
2649 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
2650 }
2651 #[inline]
2652 pub fn set_PostDispositionWhenNecessaryOnly(&mut self, val: UINT32) {
2653 unsafe {
2654 let val: u32 = ::std::mem::transmute(val);
2655 self._bitfield_1.set(30usize, 1u8, val as u64)
2656 }
2657 }
2658 #[inline]
2659 pub unsafe fn PostDispositionWhenNecessaryOnly_raw(this: *const Self) -> UINT32 {
2660 unsafe {
2661 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2662 ::std::ptr::addr_of!((*this)._bitfield_1),
2663 30usize,
2664 1u8,
2665 ) as u32)
2666 }
2667 }
2668 #[inline]
2669 pub unsafe fn set_PostDispositionWhenNecessaryOnly_raw(this: *mut Self, val: UINT32) {
2670 unsafe {
2671 let val: u32 = ::std::mem::transmute(val);
2672 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2673 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2674 30usize,
2675 1u8,
2676 val as u64,
2677 )
2678 }
2679 }
2680 #[inline]
2681 pub fn KmReservedFlags(&self) -> UINT32 {
2682 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
2683 }
2684 #[inline]
2685 pub fn set_KmReservedFlags(&mut self, val: UINT32) {
2686 unsafe {
2687 let val: u32 = ::std::mem::transmute(val);
2688 self._bitfield_1.set(31usize, 1u8, val as u64)
2689 }
2690 }
2691 #[inline]
2692 pub unsafe fn KmReservedFlags_raw(this: *const Self) -> UINT32 {
2693 unsafe {
2694 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2695 ::std::ptr::addr_of!((*this)._bitfield_1),
2696 31usize,
2697 1u8,
2698 ) as u32)
2699 }
2700 }
2701 #[inline]
2702 pub unsafe fn set_KmReservedFlags_raw(this: *mut Self, val: UINT32) {
2703 unsafe {
2704 let val: u32 = ::std::mem::transmute(val);
2705 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2706 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2707 31usize,
2708 1u8,
2709 val as u64,
2710 )
2711 }
2712 }
2713 #[inline]
2714 pub fn new_bitfield_1(
2715 CaseSensitiveSearch: UINT32,
2716 CasePreservedNames: UINT32,
2717 UnicodeOnDisk: UINT32,
2718 PersistentAcls: UINT32,
2719 ReparsePoints: UINT32,
2720 ReparsePointsAccessCheck: UINT32,
2721 NamedStreams: UINT32,
2722 HardLinks: UINT32,
2723 ExtendedAttributes: UINT32,
2724 ReadOnlyVolume: UINT32,
2725 PostCleanupWhenModifiedOnly: UINT32,
2726 PassQueryDirectoryPattern: UINT32,
2727 AlwaysUseDoubleBuffering: UINT32,
2728 PassQueryDirectoryFileName: UINT32,
2729 FlushAndPurgeOnCleanup: UINT32,
2730 DeviceControl: UINT32,
2731 UmFileContextIsUserContext2: UINT32,
2732 UmFileContextIsFullContext: UINT32,
2733 UmNoReparsePointsDirCheck: UINT32,
2734 UmReservedFlags: UINT32,
2735 AllowOpenInKernelMode: UINT32,
2736 CasePreservedExtendedAttributes: UINT32,
2737 WslFeatures: UINT32,
2738 DirectoryMarkerAsNextOffset: UINT32,
2739 RejectIrpPriorToTransact0: UINT32,
2740 SupportsPosixUnlinkRename: UINT32,
2741 PostDispositionWhenNecessaryOnly: UINT32,
2742 KmReservedFlags: UINT32,
2743 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2744 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2745 __bindgen_bitfield_unit.set(0usize, 1u8, {
2746 let CaseSensitiveSearch: u32 = unsafe { ::std::mem::transmute(CaseSensitiveSearch) };
2747 CaseSensitiveSearch as u64
2748 });
2749 __bindgen_bitfield_unit.set(1usize, 1u8, {
2750 let CasePreservedNames: u32 = unsafe { ::std::mem::transmute(CasePreservedNames) };
2751 CasePreservedNames as u64
2752 });
2753 __bindgen_bitfield_unit.set(2usize, 1u8, {
2754 let UnicodeOnDisk: u32 = unsafe { ::std::mem::transmute(UnicodeOnDisk) };
2755 UnicodeOnDisk as u64
2756 });
2757 __bindgen_bitfield_unit.set(3usize, 1u8, {
2758 let PersistentAcls: u32 = unsafe { ::std::mem::transmute(PersistentAcls) };
2759 PersistentAcls as u64
2760 });
2761 __bindgen_bitfield_unit.set(4usize, 1u8, {
2762 let ReparsePoints: u32 = unsafe { ::std::mem::transmute(ReparsePoints) };
2763 ReparsePoints as u64
2764 });
2765 __bindgen_bitfield_unit.set(5usize, 1u8, {
2766 let ReparsePointsAccessCheck: u32 =
2767 unsafe { ::std::mem::transmute(ReparsePointsAccessCheck) };
2768 ReparsePointsAccessCheck as u64
2769 });
2770 __bindgen_bitfield_unit.set(6usize, 1u8, {
2771 let NamedStreams: u32 = unsafe { ::std::mem::transmute(NamedStreams) };
2772 NamedStreams as u64
2773 });
2774 __bindgen_bitfield_unit.set(7usize, 1u8, {
2775 let HardLinks: u32 = unsafe { ::std::mem::transmute(HardLinks) };
2776 HardLinks as u64
2777 });
2778 __bindgen_bitfield_unit.set(8usize, 1u8, {
2779 let ExtendedAttributes: u32 = unsafe { ::std::mem::transmute(ExtendedAttributes) };
2780 ExtendedAttributes as u64
2781 });
2782 __bindgen_bitfield_unit.set(9usize, 1u8, {
2783 let ReadOnlyVolume: u32 = unsafe { ::std::mem::transmute(ReadOnlyVolume) };
2784 ReadOnlyVolume as u64
2785 });
2786 __bindgen_bitfield_unit.set(10usize, 1u8, {
2787 let PostCleanupWhenModifiedOnly: u32 =
2788 unsafe { ::std::mem::transmute(PostCleanupWhenModifiedOnly) };
2789 PostCleanupWhenModifiedOnly as u64
2790 });
2791 __bindgen_bitfield_unit.set(11usize, 1u8, {
2792 let PassQueryDirectoryPattern: u32 =
2793 unsafe { ::std::mem::transmute(PassQueryDirectoryPattern) };
2794 PassQueryDirectoryPattern as u64
2795 });
2796 __bindgen_bitfield_unit.set(12usize, 1u8, {
2797 let AlwaysUseDoubleBuffering: u32 =
2798 unsafe { ::std::mem::transmute(AlwaysUseDoubleBuffering) };
2799 AlwaysUseDoubleBuffering as u64
2800 });
2801 __bindgen_bitfield_unit.set(13usize, 1u8, {
2802 let PassQueryDirectoryFileName: u32 =
2803 unsafe { ::std::mem::transmute(PassQueryDirectoryFileName) };
2804 PassQueryDirectoryFileName as u64
2805 });
2806 __bindgen_bitfield_unit.set(14usize, 1u8, {
2807 let FlushAndPurgeOnCleanup: u32 =
2808 unsafe { ::std::mem::transmute(FlushAndPurgeOnCleanup) };
2809 FlushAndPurgeOnCleanup as u64
2810 });
2811 __bindgen_bitfield_unit.set(15usize, 1u8, {
2812 let DeviceControl: u32 = unsafe { ::std::mem::transmute(DeviceControl) };
2813 DeviceControl as u64
2814 });
2815 __bindgen_bitfield_unit.set(16usize, 1u8, {
2816 let UmFileContextIsUserContext2: u32 =
2817 unsafe { ::std::mem::transmute(UmFileContextIsUserContext2) };
2818 UmFileContextIsUserContext2 as u64
2819 });
2820 __bindgen_bitfield_unit.set(17usize, 1u8, {
2821 let UmFileContextIsFullContext: u32 =
2822 unsafe { ::std::mem::transmute(UmFileContextIsFullContext) };
2823 UmFileContextIsFullContext as u64
2824 });
2825 __bindgen_bitfield_unit.set(18usize, 1u8, {
2826 let UmNoReparsePointsDirCheck: u32 =
2827 unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
2828 UmNoReparsePointsDirCheck as u64
2829 });
2830 __bindgen_bitfield_unit.set(19usize, 5u8, {
2831 let UmReservedFlags: u32 = unsafe { ::std::mem::transmute(UmReservedFlags) };
2832 UmReservedFlags as u64
2833 });
2834 __bindgen_bitfield_unit.set(24usize, 1u8, {
2835 let AllowOpenInKernelMode: u32 =
2836 unsafe { ::std::mem::transmute(AllowOpenInKernelMode) };
2837 AllowOpenInKernelMode as u64
2838 });
2839 __bindgen_bitfield_unit.set(25usize, 1u8, {
2840 let CasePreservedExtendedAttributes: u32 =
2841 unsafe { ::std::mem::transmute(CasePreservedExtendedAttributes) };
2842 CasePreservedExtendedAttributes as u64
2843 });
2844 __bindgen_bitfield_unit.set(26usize, 1u8, {
2845 let WslFeatures: u32 = unsafe { ::std::mem::transmute(WslFeatures) };
2846 WslFeatures as u64
2847 });
2848 __bindgen_bitfield_unit.set(27usize, 1u8, {
2849 let DirectoryMarkerAsNextOffset: u32 =
2850 unsafe { ::std::mem::transmute(DirectoryMarkerAsNextOffset) };
2851 DirectoryMarkerAsNextOffset as u64
2852 });
2853 __bindgen_bitfield_unit.set(28usize, 1u8, {
2854 let RejectIrpPriorToTransact0: u32 =
2855 unsafe { ::std::mem::transmute(RejectIrpPriorToTransact0) };
2856 RejectIrpPriorToTransact0 as u64
2857 });
2858 __bindgen_bitfield_unit.set(29usize, 1u8, {
2859 let SupportsPosixUnlinkRename: u32 =
2860 unsafe { ::std::mem::transmute(SupportsPosixUnlinkRename) };
2861 SupportsPosixUnlinkRename as u64
2862 });
2863 __bindgen_bitfield_unit.set(30usize, 1u8, {
2864 let PostDispositionWhenNecessaryOnly: u32 =
2865 unsafe { ::std::mem::transmute(PostDispositionWhenNecessaryOnly) };
2866 PostDispositionWhenNecessaryOnly as u64
2867 });
2868 __bindgen_bitfield_unit.set(31usize, 1u8, {
2869 let KmReservedFlags: u32 = unsafe { ::std::mem::transmute(KmReservedFlags) };
2870 KmReservedFlags as u64
2871 });
2872 __bindgen_bitfield_unit
2873 }
2874 #[inline]
2875 pub fn VolumeInfoTimeoutValid(&self) -> UINT32 {
2876 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
2877 }
2878 #[inline]
2879 pub fn set_VolumeInfoTimeoutValid(&mut self, val: UINT32) {
2880 unsafe {
2881 let val: u32 = ::std::mem::transmute(val);
2882 self._bitfield_2.set(0usize, 1u8, val as u64)
2883 }
2884 }
2885 #[inline]
2886 pub unsafe fn VolumeInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
2887 unsafe {
2888 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2889 ::std::ptr::addr_of!((*this)._bitfield_2),
2890 0usize,
2891 1u8,
2892 ) as u32)
2893 }
2894 }
2895 #[inline]
2896 pub unsafe fn set_VolumeInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
2897 unsafe {
2898 let val: u32 = ::std::mem::transmute(val);
2899 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2900 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
2901 0usize,
2902 1u8,
2903 val as u64,
2904 )
2905 }
2906 }
2907 #[inline]
2908 pub fn DirInfoTimeoutValid(&self) -> UINT32 {
2909 unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u32) }
2910 }
2911 #[inline]
2912 pub fn set_DirInfoTimeoutValid(&mut self, val: UINT32) {
2913 unsafe {
2914 let val: u32 = ::std::mem::transmute(val);
2915 self._bitfield_2.set(1usize, 1u8, val as u64)
2916 }
2917 }
2918 #[inline]
2919 pub unsafe fn DirInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
2920 unsafe {
2921 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2922 ::std::ptr::addr_of!((*this)._bitfield_2),
2923 1usize,
2924 1u8,
2925 ) as u32)
2926 }
2927 }
2928 #[inline]
2929 pub unsafe fn set_DirInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
2930 unsafe {
2931 let val: u32 = ::std::mem::transmute(val);
2932 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2933 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
2934 1usize,
2935 1u8,
2936 val as u64,
2937 )
2938 }
2939 }
2940 #[inline]
2941 pub fn SecurityTimeoutValid(&self) -> UINT32 {
2942 unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u32) }
2943 }
2944 #[inline]
2945 pub fn set_SecurityTimeoutValid(&mut self, val: UINT32) {
2946 unsafe {
2947 let val: u32 = ::std::mem::transmute(val);
2948 self._bitfield_2.set(2usize, 1u8, val as u64)
2949 }
2950 }
2951 #[inline]
2952 pub unsafe fn SecurityTimeoutValid_raw(this: *const Self) -> UINT32 {
2953 unsafe {
2954 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2955 ::std::ptr::addr_of!((*this)._bitfield_2),
2956 2usize,
2957 1u8,
2958 ) as u32)
2959 }
2960 }
2961 #[inline]
2962 pub unsafe fn set_SecurityTimeoutValid_raw(this: *mut Self, val: UINT32) {
2963 unsafe {
2964 let val: u32 = ::std::mem::transmute(val);
2965 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2966 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
2967 2usize,
2968 1u8,
2969 val as u64,
2970 )
2971 }
2972 }
2973 #[inline]
2974 pub fn StreamInfoTimeoutValid(&self) -> UINT32 {
2975 unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u32) }
2976 }
2977 #[inline]
2978 pub fn set_StreamInfoTimeoutValid(&mut self, val: UINT32) {
2979 unsafe {
2980 let val: u32 = ::std::mem::transmute(val);
2981 self._bitfield_2.set(3usize, 1u8, val as u64)
2982 }
2983 }
2984 #[inline]
2985 pub unsafe fn StreamInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
2986 unsafe {
2987 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
2988 ::std::ptr::addr_of!((*this)._bitfield_2),
2989 3usize,
2990 1u8,
2991 ) as u32)
2992 }
2993 }
2994 #[inline]
2995 pub unsafe fn set_StreamInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
2996 unsafe {
2997 let val: u32 = ::std::mem::transmute(val);
2998 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
2999 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
3000 3usize,
3001 1u8,
3002 val as u64,
3003 )
3004 }
3005 }
3006 #[inline]
3007 pub fn EaTimeoutValid(&self) -> UINT32 {
3008 unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u32) }
3009 }
3010 #[inline]
3011 pub fn set_EaTimeoutValid(&mut self, val: UINT32) {
3012 unsafe {
3013 let val: u32 = ::std::mem::transmute(val);
3014 self._bitfield_2.set(4usize, 1u8, val as u64)
3015 }
3016 }
3017 #[inline]
3018 pub unsafe fn EaTimeoutValid_raw(this: *const Self) -> UINT32 {
3019 unsafe {
3020 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
3021 ::std::ptr::addr_of!((*this)._bitfield_2),
3022 4usize,
3023 1u8,
3024 ) as u32)
3025 }
3026 }
3027 #[inline]
3028 pub unsafe fn set_EaTimeoutValid_raw(this: *mut Self, val: UINT32) {
3029 unsafe {
3030 let val: u32 = ::std::mem::transmute(val);
3031 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
3032 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
3033 4usize,
3034 1u8,
3035 val as u64,
3036 )
3037 }
3038 }
3039 #[inline]
3040 pub fn KmAdditionalReservedFlags(&self) -> UINT32 {
3041 unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 27u8) as u32) }
3042 }
3043 #[inline]
3044 pub fn set_KmAdditionalReservedFlags(&mut self, val: UINT32) {
3045 unsafe {
3046 let val: u32 = ::std::mem::transmute(val);
3047 self._bitfield_2.set(5usize, 27u8, val as u64)
3048 }
3049 }
3050 #[inline]
3051 pub unsafe fn KmAdditionalReservedFlags_raw(this: *const Self) -> UINT32 {
3052 unsafe {
3053 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
3054 ::std::ptr::addr_of!((*this)._bitfield_2),
3055 5usize,
3056 27u8,
3057 ) as u32)
3058 }
3059 }
3060 #[inline]
3061 pub unsafe fn set_KmAdditionalReservedFlags_raw(this: *mut Self, val: UINT32) {
3062 unsafe {
3063 let val: u32 = ::std::mem::transmute(val);
3064 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
3065 ::std::ptr::addr_of_mut!((*this)._bitfield_2),
3066 5usize,
3067 27u8,
3068 val as u64,
3069 )
3070 }
3071 }
3072 #[inline]
3073 pub fn new_bitfield_2(
3074 VolumeInfoTimeoutValid: UINT32,
3075 DirInfoTimeoutValid: UINT32,
3076 SecurityTimeoutValid: UINT32,
3077 StreamInfoTimeoutValid: UINT32,
3078 EaTimeoutValid: UINT32,
3079 KmAdditionalReservedFlags: UINT32,
3080 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3081 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3082 __bindgen_bitfield_unit.set(0usize, 1u8, {
3083 let VolumeInfoTimeoutValid: u32 =
3084 unsafe { ::std::mem::transmute(VolumeInfoTimeoutValid) };
3085 VolumeInfoTimeoutValid as u64
3086 });
3087 __bindgen_bitfield_unit.set(1usize, 1u8, {
3088 let DirInfoTimeoutValid: u32 = unsafe { ::std::mem::transmute(DirInfoTimeoutValid) };
3089 DirInfoTimeoutValid as u64
3090 });
3091 __bindgen_bitfield_unit.set(2usize, 1u8, {
3092 let SecurityTimeoutValid: u32 = unsafe { ::std::mem::transmute(SecurityTimeoutValid) };
3093 SecurityTimeoutValid as u64
3094 });
3095 __bindgen_bitfield_unit.set(3usize, 1u8, {
3096 let StreamInfoTimeoutValid: u32 =
3097 unsafe { ::std::mem::transmute(StreamInfoTimeoutValid) };
3098 StreamInfoTimeoutValid as u64
3099 });
3100 __bindgen_bitfield_unit.set(4usize, 1u8, {
3101 let EaTimeoutValid: u32 = unsafe { ::std::mem::transmute(EaTimeoutValid) };
3102 EaTimeoutValid as u64
3103 });
3104 __bindgen_bitfield_unit.set(5usize, 27u8, {
3105 let KmAdditionalReservedFlags: u32 =
3106 unsafe { ::std::mem::transmute(KmAdditionalReservedFlags) };
3107 KmAdditionalReservedFlags as u64
3108 });
3109 __bindgen_bitfield_unit
3110 }
3111}
3112#[repr(C)]
3113#[derive(Debug, Default, Copy, Clone)]
3114pub struct FSP_FSCTL_VOLUME_INFO {
3115 pub TotalSize: UINT64,
3116 pub FreeSize: UINT64,
3117 pub VolumeLabelLength: UINT16,
3118 pub VolumeLabel: [WCHAR; 32usize],
3119}
3120#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3121const _: () = {
3122 ["Size of FSP_FSCTL_VOLUME_INFO"][::std::mem::size_of::<FSP_FSCTL_VOLUME_INFO>() - 88usize];
3123 ["Alignment of FSP_FSCTL_VOLUME_INFO"]
3124 [::std::mem::align_of::<FSP_FSCTL_VOLUME_INFO>() - 8usize];
3125 ["Offset of field: FSP_FSCTL_VOLUME_INFO::TotalSize"]
3126 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, TotalSize) - 0usize];
3127 ["Offset of field: FSP_FSCTL_VOLUME_INFO::FreeSize"]
3128 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, FreeSize) - 8usize];
3129 ["Offset of field: FSP_FSCTL_VOLUME_INFO::VolumeLabelLength"]
3130 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, VolumeLabelLength) - 16usize];
3131 ["Offset of field: FSP_FSCTL_VOLUME_INFO::VolumeLabel"]
3132 [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, VolumeLabel) - 18usize];
3133};
3134#[repr(C)]
3135#[derive(Debug, Default, Copy, Clone)]
3136pub struct FSP_FSCTL_FILE_INFO {
3137 pub FileAttributes: UINT32,
3138 pub ReparseTag: UINT32,
3139 pub AllocationSize: UINT64,
3140 pub FileSize: UINT64,
3141 pub CreationTime: UINT64,
3142 pub LastAccessTime: UINT64,
3143 pub LastWriteTime: UINT64,
3144 pub ChangeTime: UINT64,
3145 pub IndexNumber: UINT64,
3146 pub HardLinks: UINT32,
3147 pub EaSize: UINT32,
3148}
3149#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3150const _: () = {
3151 ["Size of FSP_FSCTL_FILE_INFO"][::std::mem::size_of::<FSP_FSCTL_FILE_INFO>() - 72usize];
3152 ["Alignment of FSP_FSCTL_FILE_INFO"][::std::mem::align_of::<FSP_FSCTL_FILE_INFO>() - 8usize];
3153 ["Offset of field: FSP_FSCTL_FILE_INFO::FileAttributes"]
3154 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, FileAttributes) - 0usize];
3155 ["Offset of field: FSP_FSCTL_FILE_INFO::ReparseTag"]
3156 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, ReparseTag) - 4usize];
3157 ["Offset of field: FSP_FSCTL_FILE_INFO::AllocationSize"]
3158 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, AllocationSize) - 8usize];
3159 ["Offset of field: FSP_FSCTL_FILE_INFO::FileSize"]
3160 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, FileSize) - 16usize];
3161 ["Offset of field: FSP_FSCTL_FILE_INFO::CreationTime"]
3162 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, CreationTime) - 24usize];
3163 ["Offset of field: FSP_FSCTL_FILE_INFO::LastAccessTime"]
3164 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, LastAccessTime) - 32usize];
3165 ["Offset of field: FSP_FSCTL_FILE_INFO::LastWriteTime"]
3166 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, LastWriteTime) - 40usize];
3167 ["Offset of field: FSP_FSCTL_FILE_INFO::ChangeTime"]
3168 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, ChangeTime) - 48usize];
3169 ["Offset of field: FSP_FSCTL_FILE_INFO::IndexNumber"]
3170 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, IndexNumber) - 56usize];
3171 ["Offset of field: FSP_FSCTL_FILE_INFO::HardLinks"]
3172 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, HardLinks) - 64usize];
3173 ["Offset of field: FSP_FSCTL_FILE_INFO::EaSize"]
3174 [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, EaSize) - 68usize];
3175};
3176#[repr(C)]
3177#[derive(Debug, Copy, Clone)]
3178pub struct FSP_FSCTL_OPEN_FILE_INFO {
3179 pub FileInfo: FSP_FSCTL_FILE_INFO,
3180 pub NormalizedName: PWSTR,
3181 pub NormalizedNameSize: UINT16,
3182}
3183#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3184const _: () = {
3185 ["Size of FSP_FSCTL_OPEN_FILE_INFO"]
3186 [::std::mem::size_of::<FSP_FSCTL_OPEN_FILE_INFO>() - 88usize];
3187 ["Alignment of FSP_FSCTL_OPEN_FILE_INFO"]
3188 [::std::mem::align_of::<FSP_FSCTL_OPEN_FILE_INFO>() - 8usize];
3189 ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::FileInfo"]
3190 [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, FileInfo) - 0usize];
3191 ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::NormalizedName"]
3192 [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, NormalizedName) - 72usize];
3193 ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::NormalizedNameSize"]
3194 [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, NormalizedNameSize) - 80usize];
3195};
3196impl Default for FSP_FSCTL_OPEN_FILE_INFO {
3197 fn default() -> Self {
3198 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3199 unsafe {
3200 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3201 s.assume_init()
3202 }
3203 }
3204}
3205#[repr(C)]
3206pub struct FSP_FSCTL_DIR_INFO {
3207 pub Size: UINT16,
3208 pub FileInfo: FSP_FSCTL_FILE_INFO,
3209 pub __bindgen_anon_1: FSP_FSCTL_DIR_INFO__bindgen_ty_1,
3210 pub FileNameBuf: __IncompleteArrayField<WCHAR>,
3211}
3212#[repr(C)]
3213#[derive(Copy, Clone)]
3214pub union FSP_FSCTL_DIR_INFO__bindgen_ty_1 {
3215 pub NextOffset: UINT64,
3216 pub Padding: [UINT8; 24usize],
3217}
3218#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3219const _: () = {
3220 ["Size of FSP_FSCTL_DIR_INFO__bindgen_ty_1"]
3221 [::std::mem::size_of::<FSP_FSCTL_DIR_INFO__bindgen_ty_1>() - 24usize];
3222 ["Alignment of FSP_FSCTL_DIR_INFO__bindgen_ty_1"]
3223 [::std::mem::align_of::<FSP_FSCTL_DIR_INFO__bindgen_ty_1>() - 8usize];
3224 ["Offset of field: FSP_FSCTL_DIR_INFO__bindgen_ty_1::NextOffset"]
3225 [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO__bindgen_ty_1, NextOffset) - 0usize];
3226 ["Offset of field: FSP_FSCTL_DIR_INFO__bindgen_ty_1::Padding"]
3227 [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO__bindgen_ty_1, Padding) - 0usize];
3228};
3229impl Default for FSP_FSCTL_DIR_INFO__bindgen_ty_1 {
3230 fn default() -> Self {
3231 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3232 unsafe {
3233 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3234 s.assume_init()
3235 }
3236 }
3237}
3238#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3239const _: () = {
3240 ["Size of FSP_FSCTL_DIR_INFO"][::std::mem::size_of::<FSP_FSCTL_DIR_INFO>() - 104usize];
3241 ["Alignment of FSP_FSCTL_DIR_INFO"][::std::mem::align_of::<FSP_FSCTL_DIR_INFO>() - 8usize];
3242 ["Offset of field: FSP_FSCTL_DIR_INFO::Size"]
3243 [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, Size) - 0usize];
3244 ["Offset of field: FSP_FSCTL_DIR_INFO::FileInfo"]
3245 [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, FileInfo) - 8usize];
3246 ["Offset of field: FSP_FSCTL_DIR_INFO::FileNameBuf"]
3247 [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, FileNameBuf) - 104usize];
3248};
3249impl Default for FSP_FSCTL_DIR_INFO {
3250 fn default() -> Self {
3251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3252 unsafe {
3253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3254 s.assume_init()
3255 }
3256 }
3257}
3258#[repr(C)]
3259#[derive(Debug, Default)]
3260pub struct FSP_FSCTL_STREAM_INFO {
3261 pub Size: UINT16,
3262 pub StreamSize: UINT64,
3263 pub StreamAllocationSize: UINT64,
3264 pub StreamNameBuf: __IncompleteArrayField<WCHAR>,
3265}
3266#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3267const _: () = {
3268 ["Size of FSP_FSCTL_STREAM_INFO"][::std::mem::size_of::<FSP_FSCTL_STREAM_INFO>() - 24usize];
3269 ["Alignment of FSP_FSCTL_STREAM_INFO"]
3270 [::std::mem::align_of::<FSP_FSCTL_STREAM_INFO>() - 8usize];
3271 ["Offset of field: FSP_FSCTL_STREAM_INFO::Size"]
3272 [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, Size) - 0usize];
3273 ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamSize"]
3274 [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamSize) - 8usize];
3275 ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamAllocationSize"]
3276 [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamAllocationSize) - 16usize];
3277 ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamNameBuf"]
3278 [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamNameBuf) - 24usize];
3279};
3280#[repr(C)]
3281#[derive(Debug, Default)]
3282pub struct FSP_FSCTL_NOTIFY_INFO {
3283 pub Size: UINT16,
3284 pub Filter: UINT32,
3285 pub Action: UINT32,
3286 pub FileNameBuf: __IncompleteArrayField<WCHAR>,
3287}
3288#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3289const _: () = {
3290 ["Size of FSP_FSCTL_NOTIFY_INFO"][::std::mem::size_of::<FSP_FSCTL_NOTIFY_INFO>() - 12usize];
3291 ["Alignment of FSP_FSCTL_NOTIFY_INFO"]
3292 [::std::mem::align_of::<FSP_FSCTL_NOTIFY_INFO>() - 4usize];
3293 ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Size"]
3294 [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Size) - 0usize];
3295 ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Filter"]
3296 [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Filter) - 4usize];
3297 ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Action"]
3298 [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Action) - 8usize];
3299 ["Offset of field: FSP_FSCTL_NOTIFY_INFO::FileNameBuf"]
3300 [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, FileNameBuf) - 12usize];
3301};
3302#[repr(C)]
3303#[derive(Debug, Default, Copy, Clone)]
3304pub struct FSP_FSCTL_TRANSACT_FULL_CONTEXT {
3305 pub UserContext: UINT64,
3306 pub UserContext2: UINT64,
3307}
3308#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3309const _: () = {
3310 ["Size of FSP_FSCTL_TRANSACT_FULL_CONTEXT"]
3311 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_FULL_CONTEXT>() - 16usize];
3312 ["Alignment of FSP_FSCTL_TRANSACT_FULL_CONTEXT"]
3313 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_FULL_CONTEXT>() - 8usize];
3314 ["Offset of field: FSP_FSCTL_TRANSACT_FULL_CONTEXT::UserContext"]
3315 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_FULL_CONTEXT, UserContext) - 0usize];
3316 ["Offset of field: FSP_FSCTL_TRANSACT_FULL_CONTEXT::UserContext2"]
3317 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_FULL_CONTEXT, UserContext2) - 8usize];
3318};
3319#[repr(C)]
3320#[derive(Debug, Default, Copy, Clone)]
3321pub struct FSP_FSCTL_TRANSACT_BUF {
3322 pub Offset: UINT16,
3323 pub Size: UINT16,
3324}
3325#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3326const _: () = {
3327 ["Size of FSP_FSCTL_TRANSACT_BUF"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_BUF>() - 4usize];
3328 ["Alignment of FSP_FSCTL_TRANSACT_BUF"]
3329 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_BUF>() - 2usize];
3330 ["Offset of field: FSP_FSCTL_TRANSACT_BUF::Offset"]
3331 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_BUF, Offset) - 0usize];
3332 ["Offset of field: FSP_FSCTL_TRANSACT_BUF::Size"]
3333 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_BUF, Size) - 2usize];
3334};
3335#[repr(C)]
3336pub struct FSP_FSCTL_TRANSACT_REQ {
3337 pub Version: UINT16,
3338 pub Size: UINT16,
3339 pub Kind: UINT32,
3340 pub Hint: UINT64,
3341 pub Req: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
3342 pub FileName: FSP_FSCTL_TRANSACT_BUF,
3343 pub __bindgen_padding_0: [u8; 4usize],
3344 pub Buffer: __IncompleteArrayField<UINT8>,
3345}
3346#[repr(C)]
3347#[derive(Copy, Clone)]
3348pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1 {
3349 pub Create: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3350 pub Overwrite: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
3351 pub Cleanup: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
3352 pub Close: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
3353 pub Read: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
3354 pub Write: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
3355 pub QueryInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
3356 pub SetInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
3357 pub QueryEa: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
3358 pub SetEa: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
3359 pub FlushBuffers: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
3360 pub SetVolumeInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
3361 pub QueryDirectory: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
3362 pub FileSystemControl: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
3363 pub DeviceControl: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
3364 pub QuerySecurity: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
3365 pub SetSecurity: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
3366 pub QueryStreamInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
3367}
3368#[repr(C)]
3369#[derive(Debug, Default, Copy, Clone)]
3370pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1 {
3371 pub CreateOptions: UINT32,
3372 pub FileAttributes: UINT32,
3373 pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
3374 pub AllocationSize: UINT64,
3375 pub AccessToken: UINT64,
3376 pub DesiredAccess: UINT32,
3377 pub GrantedAccess: UINT32,
3378 pub ShareAccess: UINT32,
3379 pub Ea: FSP_FSCTL_TRANSACT_BUF,
3380 pub _bitfield_align_1: [u32; 0],
3381 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
3382 pub NamedStream: UINT16,
3383}
3384#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3385const _: () = {
3386 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1"]
3387 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1>() - 64usize];
3388 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1"]
3389 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1>() - 8usize];
3390 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::CreateOptions"][::std::mem::offset_of!(
3391 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3392 CreateOptions
3393 )
3394 - 0usize];
3395 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::FileAttributes"][::std::mem::offset_of!(
3396 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3397 FileAttributes
3398 )
3399 - 4usize];
3400 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::SecurityDescriptor"][::std::mem::offset_of!(
3401 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3402 SecurityDescriptor
3403 )
3404 - 8usize];
3405 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::AllocationSize"][::std::mem::offset_of!(
3406 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3407 AllocationSize
3408 )
3409 - 16usize];
3410 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::AccessToken"][::std::mem::offset_of!(
3411 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3412 AccessToken
3413 )
3414 - 24usize];
3415 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::DesiredAccess"][::std::mem::offset_of!(
3416 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3417 DesiredAccess
3418 )
3419 - 32usize];
3420 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::GrantedAccess"][::std::mem::offset_of!(
3421 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3422 GrantedAccess
3423 )
3424 - 36usize];
3425 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::ShareAccess"][::std::mem::offset_of!(
3426 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3427 ShareAccess
3428 )
3429 - 40usize];
3430 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::Ea"]
3431 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1, Ea) - 44usize];
3432 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::NamedStream"][::std::mem::offset_of!(
3433 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
3434 NamedStream
3435 )
3436 - 56usize];
3437};
3438impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1 {
3439 #[inline]
3440 pub fn UserMode(&self) -> UINT32 {
3441 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3442 }
3443 #[inline]
3444 pub fn set_UserMode(&mut self, val: UINT32) {
3445 unsafe {
3446 let val: u32 = ::std::mem::transmute(val);
3447 self._bitfield_1.set(0usize, 1u8, val as u64)
3448 }
3449 }
3450 #[inline]
3451 pub unsafe fn UserMode_raw(this: *const Self) -> UINT32 {
3452 unsafe {
3453 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3454 ::std::ptr::addr_of!((*this)._bitfield_1),
3455 0usize,
3456 1u8,
3457 ) as u32)
3458 }
3459 }
3460 #[inline]
3461 pub unsafe fn set_UserMode_raw(this: *mut Self, val: UINT32) {
3462 unsafe {
3463 let val: u32 = ::std::mem::transmute(val);
3464 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3465 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3466 0usize,
3467 1u8,
3468 val as u64,
3469 )
3470 }
3471 }
3472 #[inline]
3473 pub fn HasTraversePrivilege(&self) -> UINT32 {
3474 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3475 }
3476 #[inline]
3477 pub fn set_HasTraversePrivilege(&mut self, val: UINT32) {
3478 unsafe {
3479 let val: u32 = ::std::mem::transmute(val);
3480 self._bitfield_1.set(1usize, 1u8, val as u64)
3481 }
3482 }
3483 #[inline]
3484 pub unsafe fn HasTraversePrivilege_raw(this: *const Self) -> UINT32 {
3485 unsafe {
3486 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3487 ::std::ptr::addr_of!((*this)._bitfield_1),
3488 1usize,
3489 1u8,
3490 ) as u32)
3491 }
3492 }
3493 #[inline]
3494 pub unsafe fn set_HasTraversePrivilege_raw(this: *mut Self, val: UINT32) {
3495 unsafe {
3496 let val: u32 = ::std::mem::transmute(val);
3497 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3498 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3499 1usize,
3500 1u8,
3501 val as u64,
3502 )
3503 }
3504 }
3505 #[inline]
3506 pub fn HasBackupPrivilege(&self) -> UINT32 {
3507 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3508 }
3509 #[inline]
3510 pub fn set_HasBackupPrivilege(&mut self, val: UINT32) {
3511 unsafe {
3512 let val: u32 = ::std::mem::transmute(val);
3513 self._bitfield_1.set(2usize, 1u8, val as u64)
3514 }
3515 }
3516 #[inline]
3517 pub unsafe fn HasBackupPrivilege_raw(this: *const Self) -> UINT32 {
3518 unsafe {
3519 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3520 ::std::ptr::addr_of!((*this)._bitfield_1),
3521 2usize,
3522 1u8,
3523 ) as u32)
3524 }
3525 }
3526 #[inline]
3527 pub unsafe fn set_HasBackupPrivilege_raw(this: *mut Self, val: UINT32) {
3528 unsafe {
3529 let val: u32 = ::std::mem::transmute(val);
3530 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3531 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3532 2usize,
3533 1u8,
3534 val as u64,
3535 )
3536 }
3537 }
3538 #[inline]
3539 pub fn HasRestorePrivilege(&self) -> UINT32 {
3540 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3541 }
3542 #[inline]
3543 pub fn set_HasRestorePrivilege(&mut self, val: UINT32) {
3544 unsafe {
3545 let val: u32 = ::std::mem::transmute(val);
3546 self._bitfield_1.set(3usize, 1u8, val as u64)
3547 }
3548 }
3549 #[inline]
3550 pub unsafe fn HasRestorePrivilege_raw(this: *const Self) -> UINT32 {
3551 unsafe {
3552 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3553 ::std::ptr::addr_of!((*this)._bitfield_1),
3554 3usize,
3555 1u8,
3556 ) as u32)
3557 }
3558 }
3559 #[inline]
3560 pub unsafe fn set_HasRestorePrivilege_raw(this: *mut Self, val: UINT32) {
3561 unsafe {
3562 let val: u32 = ::std::mem::transmute(val);
3563 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3564 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3565 3usize,
3566 1u8,
3567 val as u64,
3568 )
3569 }
3570 }
3571 #[inline]
3572 pub fn OpenTargetDirectory(&self) -> UINT32 {
3573 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3574 }
3575 #[inline]
3576 pub fn set_OpenTargetDirectory(&mut self, val: UINT32) {
3577 unsafe {
3578 let val: u32 = ::std::mem::transmute(val);
3579 self._bitfield_1.set(4usize, 1u8, val as u64)
3580 }
3581 }
3582 #[inline]
3583 pub unsafe fn OpenTargetDirectory_raw(this: *const Self) -> UINT32 {
3584 unsafe {
3585 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3586 ::std::ptr::addr_of!((*this)._bitfield_1),
3587 4usize,
3588 1u8,
3589 ) as u32)
3590 }
3591 }
3592 #[inline]
3593 pub unsafe fn set_OpenTargetDirectory_raw(this: *mut Self, val: UINT32) {
3594 unsafe {
3595 let val: u32 = ::std::mem::transmute(val);
3596 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3597 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3598 4usize,
3599 1u8,
3600 val as u64,
3601 )
3602 }
3603 }
3604 #[inline]
3605 pub fn CaseSensitive(&self) -> UINT32 {
3606 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3607 }
3608 #[inline]
3609 pub fn set_CaseSensitive(&mut self, val: UINT32) {
3610 unsafe {
3611 let val: u32 = ::std::mem::transmute(val);
3612 self._bitfield_1.set(5usize, 1u8, val as u64)
3613 }
3614 }
3615 #[inline]
3616 pub unsafe fn CaseSensitive_raw(this: *const Self) -> UINT32 {
3617 unsafe {
3618 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3619 ::std::ptr::addr_of!((*this)._bitfield_1),
3620 5usize,
3621 1u8,
3622 ) as u32)
3623 }
3624 }
3625 #[inline]
3626 pub unsafe fn set_CaseSensitive_raw(this: *mut Self, val: UINT32) {
3627 unsafe {
3628 let val: u32 = ::std::mem::transmute(val);
3629 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3630 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3631 5usize,
3632 1u8,
3633 val as u64,
3634 )
3635 }
3636 }
3637 #[inline]
3638 pub fn HasTrailingBackslash(&self) -> UINT32 {
3639 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3640 }
3641 #[inline]
3642 pub fn set_HasTrailingBackslash(&mut self, val: UINT32) {
3643 unsafe {
3644 let val: u32 = ::std::mem::transmute(val);
3645 self._bitfield_1.set(6usize, 1u8, val as u64)
3646 }
3647 }
3648 #[inline]
3649 pub unsafe fn HasTrailingBackslash_raw(this: *const Self) -> UINT32 {
3650 unsafe {
3651 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3652 ::std::ptr::addr_of!((*this)._bitfield_1),
3653 6usize,
3654 1u8,
3655 ) as u32)
3656 }
3657 }
3658 #[inline]
3659 pub unsafe fn set_HasTrailingBackslash_raw(this: *mut Self, val: UINT32) {
3660 unsafe {
3661 let val: u32 = ::std::mem::transmute(val);
3662 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3663 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3664 6usize,
3665 1u8,
3666 val as u64,
3667 )
3668 }
3669 }
3670 #[inline]
3671 pub fn AcceptsSecurityDescriptor(&self) -> UINT32 {
3672 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3673 }
3674 #[inline]
3675 pub fn set_AcceptsSecurityDescriptor(&mut self, val: UINT32) {
3676 unsafe {
3677 let val: u32 = ::std::mem::transmute(val);
3678 self._bitfield_1.set(7usize, 1u8, val as u64)
3679 }
3680 }
3681 #[inline]
3682 pub unsafe fn AcceptsSecurityDescriptor_raw(this: *const Self) -> UINT32 {
3683 unsafe {
3684 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3685 ::std::ptr::addr_of!((*this)._bitfield_1),
3686 7usize,
3687 1u8,
3688 ) as u32)
3689 }
3690 }
3691 #[inline]
3692 pub unsafe fn set_AcceptsSecurityDescriptor_raw(this: *mut Self, val: UINT32) {
3693 unsafe {
3694 let val: u32 = ::std::mem::transmute(val);
3695 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3696 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3697 7usize,
3698 1u8,
3699 val as u64,
3700 )
3701 }
3702 }
3703 #[inline]
3704 pub fn EaIsReparsePoint(&self) -> UINT32 {
3705 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3706 }
3707 #[inline]
3708 pub fn set_EaIsReparsePoint(&mut self, val: UINT32) {
3709 unsafe {
3710 let val: u32 = ::std::mem::transmute(val);
3711 self._bitfield_1.set(8usize, 1u8, val as u64)
3712 }
3713 }
3714 #[inline]
3715 pub unsafe fn EaIsReparsePoint_raw(this: *const Self) -> UINT32 {
3716 unsafe {
3717 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3718 ::std::ptr::addr_of!((*this)._bitfield_1),
3719 8usize,
3720 1u8,
3721 ) as u32)
3722 }
3723 }
3724 #[inline]
3725 pub unsafe fn set_EaIsReparsePoint_raw(this: *mut Self, val: UINT32) {
3726 unsafe {
3727 let val: u32 = ::std::mem::transmute(val);
3728 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3729 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3730 8usize,
3731 1u8,
3732 val as u64,
3733 )
3734 }
3735 }
3736 #[inline]
3737 pub fn ReservedFlags(&self) -> UINT32 {
3738 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 24u8) as u32) }
3739 }
3740 #[inline]
3741 pub fn set_ReservedFlags(&mut self, val: UINT32) {
3742 unsafe {
3743 let val: u32 = ::std::mem::transmute(val);
3744 self._bitfield_1.set(32usize, 24u8, val as u64)
3745 }
3746 }
3747 #[inline]
3748 pub unsafe fn ReservedFlags_raw(this: *const Self) -> UINT32 {
3749 unsafe {
3750 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
3751 ::std::ptr::addr_of!((*this)._bitfield_1),
3752 32usize,
3753 24u8,
3754 ) as u32)
3755 }
3756 }
3757 #[inline]
3758 pub unsafe fn set_ReservedFlags_raw(this: *mut Self, val: UINT32) {
3759 unsafe {
3760 let val: u32 = ::std::mem::transmute(val);
3761 <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
3762 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3763 32usize,
3764 24u8,
3765 val as u64,
3766 )
3767 }
3768 }
3769 #[inline]
3770 pub fn new_bitfield_1(
3771 UserMode: UINT32,
3772 HasTraversePrivilege: UINT32,
3773 HasBackupPrivilege: UINT32,
3774 HasRestorePrivilege: UINT32,
3775 OpenTargetDirectory: UINT32,
3776 CaseSensitive: UINT32,
3777 HasTrailingBackslash: UINT32,
3778 AcceptsSecurityDescriptor: UINT32,
3779 EaIsReparsePoint: UINT32,
3780 ReservedFlags: UINT32,
3781 ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
3782 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> = Default::default();
3783 __bindgen_bitfield_unit.set(0usize, 1u8, {
3784 let UserMode: u32 = unsafe { ::std::mem::transmute(UserMode) };
3785 UserMode as u64
3786 });
3787 __bindgen_bitfield_unit.set(1usize, 1u8, {
3788 let HasTraversePrivilege: u32 = unsafe { ::std::mem::transmute(HasTraversePrivilege) };
3789 HasTraversePrivilege as u64
3790 });
3791 __bindgen_bitfield_unit.set(2usize, 1u8, {
3792 let HasBackupPrivilege: u32 = unsafe { ::std::mem::transmute(HasBackupPrivilege) };
3793 HasBackupPrivilege as u64
3794 });
3795 __bindgen_bitfield_unit.set(3usize, 1u8, {
3796 let HasRestorePrivilege: u32 = unsafe { ::std::mem::transmute(HasRestorePrivilege) };
3797 HasRestorePrivilege as u64
3798 });
3799 __bindgen_bitfield_unit.set(4usize, 1u8, {
3800 let OpenTargetDirectory: u32 = unsafe { ::std::mem::transmute(OpenTargetDirectory) };
3801 OpenTargetDirectory as u64
3802 });
3803 __bindgen_bitfield_unit.set(5usize, 1u8, {
3804 let CaseSensitive: u32 = unsafe { ::std::mem::transmute(CaseSensitive) };
3805 CaseSensitive as u64
3806 });
3807 __bindgen_bitfield_unit.set(6usize, 1u8, {
3808 let HasTrailingBackslash: u32 = unsafe { ::std::mem::transmute(HasTrailingBackslash) };
3809 HasTrailingBackslash as u64
3810 });
3811 __bindgen_bitfield_unit.set(7usize, 1u8, {
3812 let AcceptsSecurityDescriptor: u32 =
3813 unsafe { ::std::mem::transmute(AcceptsSecurityDescriptor) };
3814 AcceptsSecurityDescriptor as u64
3815 });
3816 __bindgen_bitfield_unit.set(8usize, 1u8, {
3817 let EaIsReparsePoint: u32 = unsafe { ::std::mem::transmute(EaIsReparsePoint) };
3818 EaIsReparsePoint as u64
3819 });
3820 __bindgen_bitfield_unit.set(32usize, 24u8, {
3821 let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) };
3822 ReservedFlags as u64
3823 });
3824 __bindgen_bitfield_unit
3825 }
3826}
3827#[repr(C)]
3828#[derive(Debug, Default, Copy, Clone)]
3829pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2 {
3830 pub UserContext: UINT64,
3831 pub UserContext2: UINT64,
3832 pub FileAttributes: UINT32,
3833 pub AllocationSize: UINT64,
3834 pub _bitfield_align_1: [u8; 0],
3835 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3836 pub __bindgen_padding_0: u16,
3837 pub Ea: FSP_FSCTL_TRANSACT_BUF,
3838}
3839#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3840const _: () = {
3841 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2"]
3842 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2>() - 40usize];
3843 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2"]
3844 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2>() - 8usize];
3845 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::UserContext"][::std::mem::offset_of!(
3846 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
3847 UserContext
3848 )
3849 - 0usize];
3850 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::UserContext2"][::std::mem::offset_of!(
3851 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
3852 UserContext2
3853 )
3854 - 8usize];
3855 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::FileAttributes"][::std::mem::offset_of!(
3856 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
3857 FileAttributes
3858 )
3859 - 16usize];
3860 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::AllocationSize"][::std::mem::offset_of!(
3861 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
3862 AllocationSize
3863 )
3864 - 24usize];
3865 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::Ea"]
3866 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2, Ea) - 36usize];
3867};
3868impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2 {
3869 #[inline]
3870 pub fn Supersede(&self) -> UINT32 {
3871 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3872 }
3873 #[inline]
3874 pub fn set_Supersede(&mut self, val: UINT32) {
3875 unsafe {
3876 let val: u32 = ::std::mem::transmute(val);
3877 self._bitfield_1.set(0usize, 1u8, val as u64)
3878 }
3879 }
3880 #[inline]
3881 pub unsafe fn Supersede_raw(this: *const Self) -> UINT32 {
3882 unsafe {
3883 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3884 ::std::ptr::addr_of!((*this)._bitfield_1),
3885 0usize,
3886 1u8,
3887 ) as u32)
3888 }
3889 }
3890 #[inline]
3891 pub unsafe fn set_Supersede_raw(this: *mut Self, val: UINT32) {
3892 unsafe {
3893 let val: u32 = ::std::mem::transmute(val);
3894 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3895 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3896 0usize,
3897 1u8,
3898 val as u64,
3899 )
3900 }
3901 }
3902 #[inline]
3903 pub fn new_bitfield_1(Supersede: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3904 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3905 __bindgen_bitfield_unit.set(0usize, 1u8, {
3906 let Supersede: u32 = unsafe { ::std::mem::transmute(Supersede) };
3907 Supersede as u64
3908 });
3909 __bindgen_bitfield_unit
3910 }
3911}
3912#[repr(C)]
3913#[derive(Debug, Default, Copy, Clone)]
3914pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3 {
3915 pub UserContext: UINT64,
3916 pub UserContext2: UINT64,
3917 pub _bitfield_align_1: [u8; 0],
3918 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3919 pub __bindgen_padding_0: [u8; 7usize],
3920}
3921#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3922const _: () = {
3923 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3"]
3924 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3>() - 24usize];
3925 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3"]
3926 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3>() - 8usize];
3927 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3::UserContext"][::std::mem::offset_of!(
3928 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
3929 UserContext
3930 )
3931 - 0usize];
3932 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3::UserContext2"][::std::mem::offset_of!(
3933 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
3934 UserContext2
3935 )
3936 - 8usize];
3937};
3938impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3 {
3939 #[inline]
3940 pub fn Delete(&self) -> UINT32 {
3941 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3942 }
3943 #[inline]
3944 pub fn set_Delete(&mut self, val: UINT32) {
3945 unsafe {
3946 let val: u32 = ::std::mem::transmute(val);
3947 self._bitfield_1.set(0usize, 1u8, val as u64)
3948 }
3949 }
3950 #[inline]
3951 pub unsafe fn Delete_raw(this: *const Self) -> UINT32 {
3952 unsafe {
3953 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3954 ::std::ptr::addr_of!((*this)._bitfield_1),
3955 0usize,
3956 1u8,
3957 ) as u32)
3958 }
3959 }
3960 #[inline]
3961 pub unsafe fn set_Delete_raw(this: *mut Self, val: UINT32) {
3962 unsafe {
3963 let val: u32 = ::std::mem::transmute(val);
3964 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3965 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3966 0usize,
3967 1u8,
3968 val as u64,
3969 )
3970 }
3971 }
3972 #[inline]
3973 pub fn SetAllocationSize(&self) -> UINT32 {
3974 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3975 }
3976 #[inline]
3977 pub fn set_SetAllocationSize(&mut self, val: UINT32) {
3978 unsafe {
3979 let val: u32 = ::std::mem::transmute(val);
3980 self._bitfield_1.set(1usize, 1u8, val as u64)
3981 }
3982 }
3983 #[inline]
3984 pub unsafe fn SetAllocationSize_raw(this: *const Self) -> UINT32 {
3985 unsafe {
3986 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3987 ::std::ptr::addr_of!((*this)._bitfield_1),
3988 1usize,
3989 1u8,
3990 ) as u32)
3991 }
3992 }
3993 #[inline]
3994 pub unsafe fn set_SetAllocationSize_raw(this: *mut Self, val: UINT32) {
3995 unsafe {
3996 let val: u32 = ::std::mem::transmute(val);
3997 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3998 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3999 1usize,
4000 1u8,
4001 val as u64,
4002 )
4003 }
4004 }
4005 #[inline]
4006 pub fn SetArchiveBit(&self) -> UINT32 {
4007 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
4008 }
4009 #[inline]
4010 pub fn set_SetArchiveBit(&mut self, val: UINT32) {
4011 unsafe {
4012 let val: u32 = ::std::mem::transmute(val);
4013 self._bitfield_1.set(2usize, 1u8, val as u64)
4014 }
4015 }
4016 #[inline]
4017 pub unsafe fn SetArchiveBit_raw(this: *const Self) -> UINT32 {
4018 unsafe {
4019 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4020 ::std::ptr::addr_of!((*this)._bitfield_1),
4021 2usize,
4022 1u8,
4023 ) as u32)
4024 }
4025 }
4026 #[inline]
4027 pub unsafe fn set_SetArchiveBit_raw(this: *mut Self, val: UINT32) {
4028 unsafe {
4029 let val: u32 = ::std::mem::transmute(val);
4030 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4031 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4032 2usize,
4033 1u8,
4034 val as u64,
4035 )
4036 }
4037 }
4038 #[inline]
4039 pub fn SetLastAccessTime(&self) -> UINT32 {
4040 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4041 }
4042 #[inline]
4043 pub fn set_SetLastAccessTime(&mut self, val: UINT32) {
4044 unsafe {
4045 let val: u32 = ::std::mem::transmute(val);
4046 self._bitfield_1.set(3usize, 1u8, val as u64)
4047 }
4048 }
4049 #[inline]
4050 pub unsafe fn SetLastAccessTime_raw(this: *const Self) -> UINT32 {
4051 unsafe {
4052 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4053 ::std::ptr::addr_of!((*this)._bitfield_1),
4054 3usize,
4055 1u8,
4056 ) as u32)
4057 }
4058 }
4059 #[inline]
4060 pub unsafe fn set_SetLastAccessTime_raw(this: *mut Self, val: UINT32) {
4061 unsafe {
4062 let val: u32 = ::std::mem::transmute(val);
4063 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4064 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4065 3usize,
4066 1u8,
4067 val as u64,
4068 )
4069 }
4070 }
4071 #[inline]
4072 pub fn SetLastWriteTime(&self) -> UINT32 {
4073 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4074 }
4075 #[inline]
4076 pub fn set_SetLastWriteTime(&mut self, val: UINT32) {
4077 unsafe {
4078 let val: u32 = ::std::mem::transmute(val);
4079 self._bitfield_1.set(4usize, 1u8, val as u64)
4080 }
4081 }
4082 #[inline]
4083 pub unsafe fn SetLastWriteTime_raw(this: *const Self) -> UINT32 {
4084 unsafe {
4085 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4086 ::std::ptr::addr_of!((*this)._bitfield_1),
4087 4usize,
4088 1u8,
4089 ) as u32)
4090 }
4091 }
4092 #[inline]
4093 pub unsafe fn set_SetLastWriteTime_raw(this: *mut Self, val: UINT32) {
4094 unsafe {
4095 let val: u32 = ::std::mem::transmute(val);
4096 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4097 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4098 4usize,
4099 1u8,
4100 val as u64,
4101 )
4102 }
4103 }
4104 #[inline]
4105 pub fn SetChangeTime(&self) -> UINT32 {
4106 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4107 }
4108 #[inline]
4109 pub fn set_SetChangeTime(&mut self, val: UINT32) {
4110 unsafe {
4111 let val: u32 = ::std::mem::transmute(val);
4112 self._bitfield_1.set(5usize, 1u8, val as u64)
4113 }
4114 }
4115 #[inline]
4116 pub unsafe fn SetChangeTime_raw(this: *const Self) -> UINT32 {
4117 unsafe {
4118 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4119 ::std::ptr::addr_of!((*this)._bitfield_1),
4120 5usize,
4121 1u8,
4122 ) as u32)
4123 }
4124 }
4125 #[inline]
4126 pub unsafe fn set_SetChangeTime_raw(this: *mut Self, val: UINT32) {
4127 unsafe {
4128 let val: u32 = ::std::mem::transmute(val);
4129 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4130 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4131 5usize,
4132 1u8,
4133 val as u64,
4134 )
4135 }
4136 }
4137 #[inline]
4138 pub fn new_bitfield_1(
4139 Delete: UINT32,
4140 SetAllocationSize: UINT32,
4141 SetArchiveBit: UINT32,
4142 SetLastAccessTime: UINT32,
4143 SetLastWriteTime: UINT32,
4144 SetChangeTime: UINT32,
4145 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4146 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4147 __bindgen_bitfield_unit.set(0usize, 1u8, {
4148 let Delete: u32 = unsafe { ::std::mem::transmute(Delete) };
4149 Delete as u64
4150 });
4151 __bindgen_bitfield_unit.set(1usize, 1u8, {
4152 let SetAllocationSize: u32 = unsafe { ::std::mem::transmute(SetAllocationSize) };
4153 SetAllocationSize as u64
4154 });
4155 __bindgen_bitfield_unit.set(2usize, 1u8, {
4156 let SetArchiveBit: u32 = unsafe { ::std::mem::transmute(SetArchiveBit) };
4157 SetArchiveBit as u64
4158 });
4159 __bindgen_bitfield_unit.set(3usize, 1u8, {
4160 let SetLastAccessTime: u32 = unsafe { ::std::mem::transmute(SetLastAccessTime) };
4161 SetLastAccessTime as u64
4162 });
4163 __bindgen_bitfield_unit.set(4usize, 1u8, {
4164 let SetLastWriteTime: u32 = unsafe { ::std::mem::transmute(SetLastWriteTime) };
4165 SetLastWriteTime as u64
4166 });
4167 __bindgen_bitfield_unit.set(5usize, 1u8, {
4168 let SetChangeTime: u32 = unsafe { ::std::mem::transmute(SetChangeTime) };
4169 SetChangeTime as u64
4170 });
4171 __bindgen_bitfield_unit
4172 }
4173}
4174#[repr(C)]
4175#[derive(Debug, Default, Copy, Clone)]
4176pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4 {
4177 pub UserContext: UINT64,
4178 pub UserContext2: UINT64,
4179}
4180#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4181const _: () = {
4182 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4"]
4183 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4>() - 16usize];
4184 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4"]
4185 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4>() - 8usize];
4186 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4::UserContext"][::std::mem::offset_of!(
4187 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
4188 UserContext
4189 )
4190 - 0usize];
4191 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4::UserContext2"][::std::mem::offset_of!(
4192 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
4193 UserContext2
4194 )
4195 - 8usize];
4196};
4197#[repr(C)]
4198#[derive(Debug, Default, Copy, Clone)]
4199pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5 {
4200 pub UserContext: UINT64,
4201 pub UserContext2: UINT64,
4202 pub Address: UINT64,
4203 pub Offset: UINT64,
4204 pub Length: UINT32,
4205 pub Key: UINT32,
4206}
4207#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4208const _: () = {
4209 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5"]
4210 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5>() - 40usize];
4211 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5"]
4212 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5>() - 8usize];
4213 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::UserContext"][::std::mem::offset_of!(
4214 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
4215 UserContext
4216 )
4217 - 0usize];
4218 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::UserContext2"][::std::mem::offset_of!(
4219 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
4220 UserContext2
4221 )
4222 - 8usize];
4223 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Address"][::std::mem::offset_of!(
4224 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
4225 Address
4226 ) - 16usize];
4227 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Offset"][::std::mem::offset_of!(
4228 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
4229 Offset
4230 ) - 24usize];
4231 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Length"][::std::mem::offset_of!(
4232 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
4233 Length
4234 ) - 32usize];
4235 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Key"]
4236 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5, Key) - 36usize];
4237};
4238#[repr(C)]
4239#[derive(Debug, Default, Copy, Clone)]
4240pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6 {
4241 pub UserContext: UINT64,
4242 pub UserContext2: UINT64,
4243 pub Address: UINT64,
4244 pub Offset: UINT64,
4245 pub Length: UINT32,
4246 pub Key: UINT32,
4247 pub _bitfield_align_1: [u8; 0],
4248 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4249 pub __bindgen_padding_0: [u8; 7usize],
4250}
4251#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4252const _: () = {
4253 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6"]
4254 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6>() - 48usize];
4255 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6"]
4256 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6>() - 8usize];
4257 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::UserContext"][::std::mem::offset_of!(
4258 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
4259 UserContext
4260 )
4261 - 0usize];
4262 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::UserContext2"][::std::mem::offset_of!(
4263 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
4264 UserContext2
4265 )
4266 - 8usize];
4267 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Address"][::std::mem::offset_of!(
4268 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
4269 Address
4270 ) - 16usize];
4271 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Offset"][::std::mem::offset_of!(
4272 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
4273 Offset
4274 ) - 24usize];
4275 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Length"][::std::mem::offset_of!(
4276 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
4277 Length
4278 ) - 32usize];
4279 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Key"]
4280 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6, Key) - 36usize];
4281};
4282impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6 {
4283 #[inline]
4284 pub fn ConstrainedIo(&self) -> UINT32 {
4285 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4286 }
4287 #[inline]
4288 pub fn set_ConstrainedIo(&mut self, val: UINT32) {
4289 unsafe {
4290 let val: u32 = ::std::mem::transmute(val);
4291 self._bitfield_1.set(0usize, 1u8, val as u64)
4292 }
4293 }
4294 #[inline]
4295 pub unsafe fn ConstrainedIo_raw(this: *const Self) -> UINT32 {
4296 unsafe {
4297 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4298 ::std::ptr::addr_of!((*this)._bitfield_1),
4299 0usize,
4300 1u8,
4301 ) as u32)
4302 }
4303 }
4304 #[inline]
4305 pub unsafe fn set_ConstrainedIo_raw(this: *mut Self, val: UINT32) {
4306 unsafe {
4307 let val: u32 = ::std::mem::transmute(val);
4308 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4309 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4310 0usize,
4311 1u8,
4312 val as u64,
4313 )
4314 }
4315 }
4316 #[inline]
4317 pub fn new_bitfield_1(ConstrainedIo: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4318 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4319 __bindgen_bitfield_unit.set(0usize, 1u8, {
4320 let ConstrainedIo: u32 = unsafe { ::std::mem::transmute(ConstrainedIo) };
4321 ConstrainedIo as u64
4322 });
4323 __bindgen_bitfield_unit
4324 }
4325}
4326#[repr(C)]
4327#[derive(Debug, Default, Copy, Clone)]
4328pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7 {
4329 pub UserContext: UINT64,
4330 pub UserContext2: UINT64,
4331}
4332#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4333const _: () = {
4334 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7"]
4335 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7>() - 16usize];
4336 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7"]
4337 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7>() - 8usize];
4338 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7::UserContext"][::std::mem::offset_of!(
4339 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
4340 UserContext
4341 )
4342 - 0usize];
4343 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7::UserContext2"][::std::mem::offset_of!(
4344 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
4345 UserContext2
4346 )
4347 - 8usize];
4348};
4349#[repr(C)]
4350#[derive(Copy, Clone)]
4351pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8 {
4352 pub UserContext: UINT64,
4353 pub UserContext2: UINT64,
4354 pub FileInformationClass: UINT32,
4355 pub Info: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4356}
4357#[repr(C)]
4358#[derive(Copy, Clone)]
4359pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
4360 pub Allocation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
4361 pub Basic: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4362 pub Disposition: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
4363 pub DispositionEx:
4364 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
4365 pub EndOfFile: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
4366 pub Rename: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
4367 pub RenameEx: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4368}
4369#[repr(C)]
4370#[derive(Debug, Default, Copy, Clone)]
4371pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1 {
4372 pub AllocationSize: UINT64,
4373}
4374#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4375const _: () = {
4376 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1"]
4377 [::std::mem::size_of::<
4378 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
4379 >() - 8usize];
4380 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1"]
4381 [::std::mem::align_of::<
4382 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
4383 >() - 8usize];
4384 [
4385 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1::AllocationSize",
4386 ][::std::mem::offset_of!(
4387 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
4388 AllocationSize
4389 ) - 0usize];
4390};
4391#[repr(C)]
4392#[derive(Debug, Default, Copy, Clone)]
4393pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2 {
4394 pub FileAttributes: UINT32,
4395 pub CreationTime: UINT64,
4396 pub LastAccessTime: UINT64,
4397 pub LastWriteTime: UINT64,
4398 pub ChangeTime: UINT64,
4399}
4400#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4401const _: () = {
4402 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2"]
4403 [::std::mem::size_of::<
4404 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4405 >() - 40usize];
4406 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2"]
4407 [::std::mem::align_of::<
4408 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4409 >() - 8usize];
4410 [
4411 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::FileAttributes",
4412 ][::std::mem::offset_of!(
4413 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4414 FileAttributes
4415 ) - 0usize];
4416 [
4417 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::CreationTime",
4418 ][::std::mem::offset_of!(
4419 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4420 CreationTime
4421 ) - 8usize];
4422 [
4423 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::LastAccessTime",
4424 ][::std::mem::offset_of!(
4425 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4426 LastAccessTime
4427 ) - 16usize];
4428 [
4429 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::LastWriteTime",
4430 ][::std::mem::offset_of!(
4431 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4432 LastWriteTime
4433 ) - 24usize];
4434 [
4435 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::ChangeTime",
4436 ][::std::mem::offset_of!(
4437 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
4438 ChangeTime
4439 ) - 32usize];
4440};
4441#[repr(C)]
4442#[repr(align(4))]
4443#[derive(Debug, Default, Copy, Clone)]
4444pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3 {
4445 pub _bitfield_align_1: [u8; 0],
4446 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4447 pub __bindgen_padding_0: [u8; 3usize],
4448}
4449#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4450const _: () = {
4451 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3"]
4452 [::std::mem::size_of::<
4453 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
4454 >() - 4usize];
4455 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3"]
4456 [::std::mem::align_of::<
4457 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
4458 >() - 4usize];
4459};
4460impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3 {
4461 #[inline]
4462 pub fn Delete(&self) -> UINT32 {
4463 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4464 }
4465 #[inline]
4466 pub fn set_Delete(&mut self, val: UINT32) {
4467 unsafe {
4468 let val: u32 = ::std::mem::transmute(val);
4469 self._bitfield_1.set(0usize, 1u8, val as u64)
4470 }
4471 }
4472 #[inline]
4473 pub unsafe fn Delete_raw(this: *const Self) -> UINT32 {
4474 unsafe {
4475 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4476 ::std::ptr::addr_of!((*this)._bitfield_1),
4477 0usize,
4478 1u8,
4479 ) as u32)
4480 }
4481 }
4482 #[inline]
4483 pub unsafe fn set_Delete_raw(this: *mut Self, val: UINT32) {
4484 unsafe {
4485 let val: u32 = ::std::mem::transmute(val);
4486 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4487 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4488 0usize,
4489 1u8,
4490 val as u64,
4491 )
4492 }
4493 }
4494 #[inline]
4495 pub fn new_bitfield_1(Delete: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4496 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4497 __bindgen_bitfield_unit.set(0usize, 1u8, {
4498 let Delete: u32 = unsafe { ::std::mem::transmute(Delete) };
4499 Delete as u64
4500 });
4501 __bindgen_bitfield_unit
4502 }
4503}
4504#[repr(C)]
4505#[derive(Debug, Default, Copy, Clone)]
4506pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4 {
4507 pub Flags: UINT32,
4508}
4509#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4510const _: () = {
4511 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4"]
4512 [::std::mem::size_of::<
4513 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
4514 >() - 4usize];
4515 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4"]
4516 [::std::mem::align_of::<
4517 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
4518 >() - 4usize];
4519 [
4520 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4::Flags",
4521 ][::std::mem::offset_of!(
4522 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
4523 Flags
4524 ) - 0usize];
4525};
4526#[repr(C)]
4527#[derive(Debug, Default, Copy, Clone)]
4528pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5 {
4529 pub FileSize: UINT64,
4530}
4531#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4532const _: () = {
4533 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5"]
4534 [::std::mem::size_of::<
4535 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
4536 >() - 8usize];
4537 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5"]
4538 [::std::mem::align_of::<
4539 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
4540 >() - 8usize];
4541 [
4542 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5::FileSize",
4543 ][::std::mem::offset_of!(
4544 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
4545 FileSize
4546 ) - 0usize];
4547};
4548#[repr(C)]
4549#[derive(Debug, Default, Copy, Clone)]
4550pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6 {
4551 pub NewFileName: FSP_FSCTL_TRANSACT_BUF,
4552 pub AccessToken: UINT64,
4553}
4554#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4555const _: () = {
4556 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6"]
4557 [::std::mem::size_of::<
4558 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
4559 >() - 16usize];
4560 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6"]
4561 [::std::mem::align_of::<
4562 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
4563 >() - 8usize];
4564 [
4565 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6::NewFileName",
4566 ][::std::mem::offset_of!(
4567 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
4568 NewFileName
4569 ) - 0usize];
4570 [
4571 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6::AccessToken",
4572 ][::std::mem::offset_of!(
4573 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
4574 AccessToken
4575 ) - 8usize];
4576};
4577#[repr(C)]
4578#[derive(Debug, Default, Copy, Clone)]
4579pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7 {
4580 pub NewFileName: FSP_FSCTL_TRANSACT_BUF,
4581 pub AccessToken: UINT64,
4582 pub Flags: UINT32,
4583}
4584#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4585const _: () = {
4586 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7"]
4587 [::std::mem::size_of::<
4588 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4589 >() - 24usize];
4590 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7"]
4591 [::std::mem::align_of::<
4592 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4593 >() - 8usize];
4594 [
4595 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::NewFileName",
4596 ][::std::mem::offset_of!(
4597 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4598 NewFileName
4599 ) - 0usize];
4600 [
4601 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::AccessToken",
4602 ][::std::mem::offset_of!(
4603 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4604 AccessToken
4605 ) - 8usize];
4606 [
4607 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::Flags",
4608 ][::std::mem::offset_of!(
4609 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
4610 Flags
4611 ) - 16usize];
4612};
4613#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4614const _: () = {
4615 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1"][::std::mem::size_of::<
4616 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4617 >() - 40usize];
4618 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1"]
4619 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1>(
4620 ) - 8usize];
4621 [
4622 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Allocation",
4623 ][::std::mem::offset_of!(
4624 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4625 Allocation
4626 ) - 0usize];
4627 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Basic"][::std::mem::offset_of!(
4628 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4629 Basic
4630 )
4631 - 0usize];
4632 [
4633 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Disposition",
4634 ][::std::mem::offset_of!(
4635 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4636 Disposition
4637 ) - 0usize];
4638 [
4639 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::DispositionEx",
4640 ][::std::mem::offset_of!(
4641 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4642 DispositionEx
4643 ) - 0usize];
4644 [
4645 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::EndOfFile",
4646 ][::std::mem::offset_of!(
4647 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4648 EndOfFile
4649 ) - 0usize];
4650 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Rename"][::std::mem::offset_of!(
4651 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4652 Rename
4653 )
4654 - 0usize];
4655 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::RenameEx"]
4656 [::std::mem::offset_of!(
4657 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
4658 RenameEx
4659 ) - 0usize];
4660};
4661impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
4662 fn default() -> Self {
4663 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4664 unsafe {
4665 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4666 s.assume_init()
4667 }
4668 }
4669}
4670#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4671const _: () = {
4672 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8"]
4673 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8>() - 64usize];
4674 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8"]
4675 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8>() - 8usize];
4676 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::UserContext"][::std::mem::offset_of!(
4677 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
4678 UserContext
4679 )
4680 - 0usize];
4681 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::UserContext2"][::std::mem::offset_of!(
4682 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
4683 UserContext2
4684 )
4685 - 8usize];
4686 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::FileInformationClass"][::std::mem::offset_of!(
4687 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
4688 FileInformationClass
4689 )
4690 - 16usize];
4691 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::Info"][::std::mem::offset_of!(
4692 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
4693 Info
4694 ) - 24usize];
4695};
4696impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8 {
4697 fn default() -> Self {
4698 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4699 unsafe {
4700 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4701 s.assume_init()
4702 }
4703 }
4704}
4705#[repr(C)]
4706#[derive(Debug, Default, Copy, Clone)]
4707pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9 {
4708 pub UserContext: UINT64,
4709 pub UserContext2: UINT64,
4710}
4711#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4712const _: () = {
4713 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9"]
4714 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9>() - 16usize];
4715 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9"]
4716 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9>() - 8usize];
4717 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9::UserContext"][::std::mem::offset_of!(
4718 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
4719 UserContext
4720 )
4721 - 0usize];
4722 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9::UserContext2"][::std::mem::offset_of!(
4723 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
4724 UserContext2
4725 )
4726 - 8usize];
4727};
4728#[repr(C)]
4729#[derive(Debug, Default, Copy, Clone)]
4730pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10 {
4731 pub UserContext: UINT64,
4732 pub UserContext2: UINT64,
4733 pub Ea: FSP_FSCTL_TRANSACT_BUF,
4734}
4735#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4736const _: () = {
4737 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10"]
4738 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10>() - 24usize];
4739 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10"]
4740 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10>() - 8usize];
4741 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::UserContext"][::std::mem::offset_of!(
4742 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
4743 UserContext
4744 )
4745 - 0usize];
4746 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::UserContext2"][::std::mem::offset_of!(
4747 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
4748 UserContext2
4749 )
4750 - 8usize];
4751 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::Ea"]
4752 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10, Ea) - 16usize];
4753};
4754#[repr(C)]
4755#[derive(Debug, Default, Copy, Clone)]
4756pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11 {
4757 pub UserContext: UINT64,
4758 pub UserContext2: UINT64,
4759}
4760#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4761const _: () = {
4762 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11"]
4763 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11>() - 16usize];
4764 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11"]
4765 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11>() - 8usize];
4766 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11::UserContext"][::std::mem::offset_of!(
4767 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
4768 UserContext
4769 )
4770 - 0usize];
4771 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11::UserContext2"][::std::mem::offset_of!(
4772 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
4773 UserContext2
4774 )
4775 - 8usize];
4776};
4777#[repr(C)]
4778#[derive(Copy, Clone)]
4779pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12 {
4780 pub FsInformationClass: UINT32,
4781 pub Info: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1,
4782}
4783#[repr(C)]
4784#[derive(Copy, Clone)]
4785pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
4786 pub Label: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
4787}
4788#[repr(C)]
4789#[derive(Debug, Default, Copy, Clone)]
4790pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1 {
4791 pub VolumeLabel: FSP_FSCTL_TRANSACT_BUF,
4792}
4793#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4794const _: () = {
4795 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1"]
4796 [::std::mem::size_of::<
4797 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
4798 >() - 4usize];
4799 [
4800 "Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1",
4801 ][::std::mem::align_of::<
4802 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
4803 >() - 2usize];
4804 [
4805 "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1::VolumeLabel",
4806 ][::std::mem::offset_of!(
4807 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
4808 VolumeLabel
4809 ) - 0usize];
4810};
4811#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4812const _: () = {
4813 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1"]
4814 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1>(
4815 ) - 4usize];
4816 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1"]
4817 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1>(
4818 ) - 2usize];
4819 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1::Label"][::std::mem::offset_of!(
4820 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1,
4821 Label
4822 )
4823 - 0usize];
4824};
4825impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
4826 fn default() -> Self {
4827 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4828 unsafe {
4829 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4830 s.assume_init()
4831 }
4832 }
4833}
4834#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4835const _: () = {
4836 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12"]
4837 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12>() - 8usize];
4838 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12"]
4839 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12>() - 4usize];
4840 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12::FsInformationClass"][::std::mem::offset_of!(
4841 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
4842 FsInformationClass
4843 )
4844 - 0usize];
4845 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12::Info"][::std::mem::offset_of!(
4846 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
4847 Info
4848 ) - 4usize];
4849};
4850impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12 {
4851 fn default() -> Self {
4852 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4853 unsafe {
4854 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4855 s.assume_init()
4856 }
4857 }
4858}
4859#[repr(C)]
4860#[derive(Debug, Default, Copy, Clone)]
4861pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13 {
4862 pub UserContext: UINT64,
4863 pub UserContext2: UINT64,
4864 pub Address: UINT64,
4865 pub Length: UINT32,
4866 pub Pattern: FSP_FSCTL_TRANSACT_BUF,
4867 pub Marker: FSP_FSCTL_TRANSACT_BUF,
4868 pub _bitfield_align_1: [u8; 0],
4869 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4870 pub __bindgen_padding_0: [u8; 3usize],
4871}
4872#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4873const _: () = {
4874 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13"]
4875 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13>() - 40usize];
4876 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13"]
4877 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13>() - 8usize];
4878 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::UserContext"][::std::mem::offset_of!(
4879 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4880 UserContext
4881 )
4882 - 0usize];
4883 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::UserContext2"][::std::mem::offset_of!(
4884 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4885 UserContext2
4886 )
4887 - 8usize];
4888 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Address"][::std::mem::offset_of!(
4889 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4890 Address
4891 ) - 16usize];
4892 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Length"][::std::mem::offset_of!(
4893 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4894 Length
4895 ) - 24usize];
4896 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Pattern"][::std::mem::offset_of!(
4897 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4898 Pattern
4899 ) - 28usize];
4900 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Marker"][::std::mem::offset_of!(
4901 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
4902 Marker
4903 ) - 32usize];
4904};
4905impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13 {
4906 #[inline]
4907 pub fn CaseSensitive(&self) -> UINT32 {
4908 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4909 }
4910 #[inline]
4911 pub fn set_CaseSensitive(&mut self, val: UINT32) {
4912 unsafe {
4913 let val: u32 = ::std::mem::transmute(val);
4914 self._bitfield_1.set(0usize, 1u8, val as u64)
4915 }
4916 }
4917 #[inline]
4918 pub unsafe fn CaseSensitive_raw(this: *const Self) -> UINT32 {
4919 unsafe {
4920 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4921 ::std::ptr::addr_of!((*this)._bitfield_1),
4922 0usize,
4923 1u8,
4924 ) as u32)
4925 }
4926 }
4927 #[inline]
4928 pub unsafe fn set_CaseSensitive_raw(this: *mut Self, val: UINT32) {
4929 unsafe {
4930 let val: u32 = ::std::mem::transmute(val);
4931 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4932 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4933 0usize,
4934 1u8,
4935 val as u64,
4936 )
4937 }
4938 }
4939 #[inline]
4940 pub fn PatternIsFileName(&self) -> UINT32 {
4941 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4942 }
4943 #[inline]
4944 pub fn set_PatternIsFileName(&mut self, val: UINT32) {
4945 unsafe {
4946 let val: u32 = ::std::mem::transmute(val);
4947 self._bitfield_1.set(1usize, 1u8, val as u64)
4948 }
4949 }
4950 #[inline]
4951 pub unsafe fn PatternIsFileName_raw(this: *const Self) -> UINT32 {
4952 unsafe {
4953 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
4954 ::std::ptr::addr_of!((*this)._bitfield_1),
4955 1usize,
4956 1u8,
4957 ) as u32)
4958 }
4959 }
4960 #[inline]
4961 pub unsafe fn set_PatternIsFileName_raw(this: *mut Self, val: UINT32) {
4962 unsafe {
4963 let val: u32 = ::std::mem::transmute(val);
4964 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
4965 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4966 1usize,
4967 1u8,
4968 val as u64,
4969 )
4970 }
4971 }
4972 #[inline]
4973 pub fn new_bitfield_1(
4974 CaseSensitive: UINT32,
4975 PatternIsFileName: UINT32,
4976 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4977 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4978 __bindgen_bitfield_unit.set(0usize, 1u8, {
4979 let CaseSensitive: u32 = unsafe { ::std::mem::transmute(CaseSensitive) };
4980 CaseSensitive as u64
4981 });
4982 __bindgen_bitfield_unit.set(1usize, 1u8, {
4983 let PatternIsFileName: u32 = unsafe { ::std::mem::transmute(PatternIsFileName) };
4984 PatternIsFileName as u64
4985 });
4986 __bindgen_bitfield_unit
4987 }
4988}
4989#[repr(C)]
4990#[derive(Debug, Default, Copy, Clone)]
4991pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14 {
4992 pub UserContext: UINT64,
4993 pub UserContext2: UINT64,
4994 pub FsControlCode: UINT32,
4995 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
4996 pub TargetOnFileSystem: UINT16,
4997}
4998#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4999const _: () = {
5000 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14"]
5001 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14>() - 32usize];
5002 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14"]
5003 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14>() - 8usize];
5004 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::UserContext"][::std::mem::offset_of!(
5005 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
5006 UserContext
5007 )
5008 - 0usize];
5009 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::UserContext2"][::std::mem::offset_of!(
5010 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
5011 UserContext2
5012 )
5013 - 8usize];
5014 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::FsControlCode"][::std::mem::offset_of!(
5015 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
5016 FsControlCode
5017 )
5018 - 16usize];
5019 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::Buffer"][::std::mem::offset_of!(
5020 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
5021 Buffer
5022 ) - 20usize];
5023 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::TargetOnFileSystem"][::std::mem::offset_of!(
5024 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
5025 TargetOnFileSystem
5026 )
5027 - 24usize];
5028};
5029#[repr(C)]
5030#[derive(Debug, Default, Copy, Clone)]
5031pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15 {
5032 pub UserContext: UINT64,
5033 pub UserContext2: UINT64,
5034 pub IoControlCode: UINT32,
5035 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
5036 pub OutputLength: UINT32,
5037}
5038#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5039const _: () = {
5040 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15"]
5041 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15>() - 32usize];
5042 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15"]
5043 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15>() - 8usize];
5044 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::UserContext"][::std::mem::offset_of!(
5045 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
5046 UserContext
5047 )
5048 - 0usize];
5049 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::UserContext2"][::std::mem::offset_of!(
5050 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
5051 UserContext2
5052 )
5053 - 8usize];
5054 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::IoControlCode"][::std::mem::offset_of!(
5055 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
5056 IoControlCode
5057 )
5058 - 16usize];
5059 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::Buffer"][::std::mem::offset_of!(
5060 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
5061 Buffer
5062 ) - 20usize];
5063 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::OutputLength"][::std::mem::offset_of!(
5064 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
5065 OutputLength
5066 )
5067 - 24usize];
5068};
5069#[repr(C)]
5070#[derive(Debug, Default, Copy, Clone)]
5071pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16 {
5072 pub UserContext: UINT64,
5073 pub UserContext2: UINT64,
5074}
5075#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5076const _: () = {
5077 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16"]
5078 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16>() - 16usize];
5079 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16"]
5080 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16>() - 8usize];
5081 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16::UserContext"][::std::mem::offset_of!(
5082 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
5083 UserContext
5084 )
5085 - 0usize];
5086 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16::UserContext2"][::std::mem::offset_of!(
5087 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
5088 UserContext2
5089 )
5090 - 8usize];
5091};
5092#[repr(C)]
5093#[derive(Debug, Default, Copy, Clone)]
5094pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17 {
5095 pub UserContext: UINT64,
5096 pub UserContext2: UINT64,
5097 pub SecurityInformation: UINT32,
5098 pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
5099}
5100#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5101const _: () = {
5102 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17"]
5103 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17>() - 24usize];
5104 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17"]
5105 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17>() - 8usize];
5106 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::UserContext"][::std::mem::offset_of!(
5107 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
5108 UserContext
5109 )
5110 - 0usize];
5111 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::UserContext2"][::std::mem::offset_of!(
5112 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
5113 UserContext2
5114 )
5115 - 8usize];
5116 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::SecurityInformation"][::std::mem::offset_of!(
5117 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
5118 SecurityInformation
5119 )
5120 - 16usize];
5121 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::SecurityDescriptor"][::std::mem::offset_of!(
5122 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
5123 SecurityDescriptor
5124 )
5125 - 20usize];
5126};
5127#[repr(C)]
5128#[derive(Debug, Default, Copy, Clone)]
5129pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18 {
5130 pub UserContext: UINT64,
5131 pub UserContext2: UINT64,
5132}
5133#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5134const _: () = {
5135 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18"]
5136 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18>() - 16usize];
5137 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18"]
5138 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18>() - 8usize];
5139 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18::UserContext"][::std::mem::offset_of!(
5140 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
5141 UserContext
5142 )
5143 - 0usize];
5144 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18::UserContext2"][::std::mem::offset_of!(
5145 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
5146 UserContext2
5147 )
5148 - 8usize];
5149};
5150#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5151const _: () = {
5152 ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1"]
5153 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1>() - 64usize];
5154 ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1"]
5155 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1>() - 8usize];
5156 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Create"]
5157 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Create) - 0usize];
5158 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Overwrite"]
5159 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Overwrite) - 0usize];
5160 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Cleanup"]
5161 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Cleanup) - 0usize];
5162 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Close"]
5163 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Close) - 0usize];
5164 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Read"]
5165 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Read) - 0usize];
5166 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Write"]
5167 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Write) - 0usize];
5168 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryInformation"]
5169 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryInformation) - 0usize];
5170 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetInformation"]
5171 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetInformation) - 0usize];
5172 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryEa"]
5173 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryEa) - 0usize];
5174 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetEa"]
5175 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetEa) - 0usize];
5176 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::FlushBuffers"]
5177 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, FlushBuffers) - 0usize];
5178 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetVolumeInformation"][::std::mem::offset_of!(
5179 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
5180 SetVolumeInformation
5181 ) - 0usize];
5182 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryDirectory"]
5183 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryDirectory) - 0usize];
5184 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::FileSystemControl"]
5185 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, FileSystemControl) - 0usize];
5186 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::DeviceControl"]
5187 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, DeviceControl) - 0usize];
5188 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QuerySecurity"]
5189 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QuerySecurity) - 0usize];
5190 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetSecurity"]
5191 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetSecurity) - 0usize];
5192 ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryStreamInformation"][::std::mem::offset_of!(
5193 FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
5194 QueryStreamInformation
5195 ) - 0usize];
5196};
5197impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1 {
5198 fn default() -> Self {
5199 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5200 unsafe {
5201 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5202 s.assume_init()
5203 }
5204 }
5205}
5206#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5207const _: () = {
5208 ["Size of FSP_FSCTL_TRANSACT_REQ"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ>() - 88usize];
5209 ["Alignment of FSP_FSCTL_TRANSACT_REQ"]
5210 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ>() - 8usize];
5211 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Version"]
5212 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Version) - 0usize];
5213 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Size"]
5214 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Size) - 2usize];
5215 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Kind"]
5216 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Kind) - 4usize];
5217 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Hint"]
5218 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Hint) - 8usize];
5219 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Req"]
5220 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Req) - 16usize];
5221 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::FileName"]
5222 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, FileName) - 80usize];
5223 ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Buffer"]
5224 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Buffer) - 88usize];
5225};
5226impl Default for FSP_FSCTL_TRANSACT_REQ {
5227 fn default() -> Self {
5228 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5229 unsafe {
5230 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5231 s.assume_init()
5232 }
5233 }
5234}
5235#[repr(C)]
5236pub struct FSP_FSCTL_TRANSACT_RSP {
5237 pub Version: UINT16,
5238 pub Size: UINT16,
5239 pub Kind: UINT32,
5240 pub Hint: UINT64,
5241 pub IoStatus: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1,
5242 pub Rsp: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
5243 pub Buffer: __IncompleteArrayField<UINT8>,
5244}
5245#[repr(C)]
5246#[derive(Debug, Default, Copy, Clone)]
5247pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1 {
5248 pub Information: UINT32,
5249 pub Status: UINT32,
5250}
5251#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5252const _: () = {
5253 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1"]
5254 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1>() - 8usize];
5255 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1"]
5256 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1>() - 4usize];
5257 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1::Information"]
5258 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1, Information) - 0usize];
5259 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1::Status"]
5260 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1, Status) - 4usize];
5261};
5262#[repr(C)]
5263#[derive(Copy, Clone)]
5264pub union FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2 {
5265 pub Create: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
5266 pub Overwrite: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2,
5267 pub Write: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3,
5268 pub QueryInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4,
5269 pub SetInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5,
5270 pub QueryEa: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6,
5271 pub SetEa: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7,
5272 pub FlushBuffers: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8,
5273 pub QueryVolumeInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9,
5274 pub SetVolumeInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10,
5275 pub FileSystemControl: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11,
5276 pub DeviceControl: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12,
5277 pub QuerySecurity: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13,
5278 pub SetSecurity: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14,
5279 pub QueryStreamInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15,
5280}
5281#[repr(C)]
5282#[derive(Copy, Clone)]
5283pub union FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1 {
5284 pub Opened: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5285 pub Reparse: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
5286}
5287#[repr(C)]
5288#[derive(Debug, Default, Copy, Clone)]
5289pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
5290 pub UserContext: UINT64,
5291 pub UserContext2: UINT64,
5292 pub GrantedAccess: UINT32,
5293 pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
5294 pub FileInfo: FSP_FSCTL_FILE_INFO,
5295 pub FileName: FSP_FSCTL_TRANSACT_BUF,
5296 pub _bitfield_align_1: [u8; 0],
5297 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5298 pub __bindgen_padding_0: [u8; 3usize],
5299}
5300#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5301const _: () = {
5302 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
5303 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5304 >()
5305 - 104usize];
5306 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"]
5307 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1>(
5308 ) - 8usize];
5309 [
5310 "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::UserContext",
5311 ][::std::mem::offset_of!(
5312 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5313 UserContext
5314 ) - 0usize];
5315 [
5316 "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::UserContext2",
5317 ][::std::mem::offset_of!(
5318 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5319 UserContext2
5320 ) - 8usize];
5321 [
5322 "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::GrantedAccess",
5323 ][::std::mem::offset_of!(
5324 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5325 GrantedAccess
5326 ) - 16usize];
5327 [
5328 "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::SecurityDescriptor",
5329 ][::std::mem::offset_of!(
5330 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5331 SecurityDescriptor
5332 ) - 20usize];
5333 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::FileInfo"]
5334 [::std::mem::offset_of!(
5335 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5336 FileInfo
5337 ) - 24usize];
5338 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::FileName"]
5339 [::std::mem::offset_of!(
5340 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
5341 FileName
5342 ) - 96usize];
5343};
5344impl FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
5345 #[inline]
5346 pub fn DisableCache(&self) -> UINT32 {
5347 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5348 }
5349 #[inline]
5350 pub fn set_DisableCache(&mut self, val: UINT32) {
5351 unsafe {
5352 let val: u32 = ::std::mem::transmute(val);
5353 self._bitfield_1.set(0usize, 1u8, val as u64)
5354 }
5355 }
5356 #[inline]
5357 pub unsafe fn DisableCache_raw(this: *const Self) -> UINT32 {
5358 unsafe {
5359 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5360 ::std::ptr::addr_of!((*this)._bitfield_1),
5361 0usize,
5362 1u8,
5363 ) as u32)
5364 }
5365 }
5366 #[inline]
5367 pub unsafe fn set_DisableCache_raw(this: *mut Self, val: UINT32) {
5368 unsafe {
5369 let val: u32 = ::std::mem::transmute(val);
5370 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5371 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5372 0usize,
5373 1u8,
5374 val as u64,
5375 )
5376 }
5377 }
5378 #[inline]
5379 pub fn HasSecurityDescriptor(&self) -> UINT32 {
5380 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5381 }
5382 #[inline]
5383 pub fn set_HasSecurityDescriptor(&mut self, val: UINT32) {
5384 unsafe {
5385 let val: u32 = ::std::mem::transmute(val);
5386 self._bitfield_1.set(1usize, 1u8, val as u64)
5387 }
5388 }
5389 #[inline]
5390 pub unsafe fn HasSecurityDescriptor_raw(this: *const Self) -> UINT32 {
5391 unsafe {
5392 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
5393 ::std::ptr::addr_of!((*this)._bitfield_1),
5394 1usize,
5395 1u8,
5396 ) as u32)
5397 }
5398 }
5399 #[inline]
5400 pub unsafe fn set_HasSecurityDescriptor_raw(this: *mut Self, val: UINT32) {
5401 unsafe {
5402 let val: u32 = ::std::mem::transmute(val);
5403 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
5404 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5405 1usize,
5406 1u8,
5407 val as u64,
5408 )
5409 }
5410 }
5411 #[inline]
5412 pub fn new_bitfield_1(
5413 DisableCache: UINT32,
5414 HasSecurityDescriptor: UINT32,
5415 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5416 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5417 __bindgen_bitfield_unit.set(0usize, 1u8, {
5418 let DisableCache: u32 = unsafe { ::std::mem::transmute(DisableCache) };
5419 DisableCache as u64
5420 });
5421 __bindgen_bitfield_unit.set(1usize, 1u8, {
5422 let HasSecurityDescriptor: u32 =
5423 unsafe { ::std::mem::transmute(HasSecurityDescriptor) };
5424 HasSecurityDescriptor as u64
5425 });
5426 __bindgen_bitfield_unit
5427 }
5428}
5429#[repr(C)]
5430#[derive(Debug, Default, Copy, Clone)]
5431pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2 {
5432 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
5433}
5434#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5435const _: () = {
5436 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2"][::std::mem::size_of::<
5437 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
5438 >() - 4usize];
5439 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2"]
5440 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2>(
5441 ) - 2usize];
5442 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2::Buffer"][::std::mem::offset_of!(
5443 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
5444 Buffer
5445 )
5446 - 0usize];
5447};
5448#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5449const _: () = {
5450 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1"]
5451 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1>() - 104usize];
5452 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1"]
5453 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1>() - 8usize];
5454 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1::Opened"][::std::mem::offset_of!(
5455 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
5456 Opened
5457 ) - 0usize];
5458 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1::Reparse"][::std::mem::offset_of!(
5459 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
5460 Reparse
5461 ) - 0usize];
5462};
5463impl Default for FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1 {
5464 fn default() -> Self {
5465 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5466 unsafe {
5467 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5468 s.assume_init()
5469 }
5470 }
5471}
5472#[repr(C)]
5473#[derive(Debug, Default, Copy, Clone)]
5474pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2 {
5475 pub FileInfo: FSP_FSCTL_FILE_INFO,
5476}
5477#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5478const _: () = {
5479 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2"]
5480 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2>() - 72usize];
5481 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2"]
5482 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2>() - 8usize];
5483 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2::FileInfo"][::std::mem::offset_of!(
5484 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2,
5485 FileInfo
5486 ) - 0usize];
5487};
5488#[repr(C)]
5489#[derive(Debug, Default, Copy, Clone)]
5490pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3 {
5491 pub FileInfo: FSP_FSCTL_FILE_INFO,
5492}
5493#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5494const _: () = {
5495 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3"]
5496 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3>() - 72usize];
5497 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3"]
5498 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3>() - 8usize];
5499 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3::FileInfo"][::std::mem::offset_of!(
5500 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3,
5501 FileInfo
5502 ) - 0usize];
5503};
5504#[repr(C)]
5505#[derive(Debug, Default, Copy, Clone)]
5506pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4 {
5507 pub FileInfo: FSP_FSCTL_FILE_INFO,
5508}
5509#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5510const _: () = {
5511 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4"]
5512 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4>() - 72usize];
5513 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4"]
5514 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4>() - 8usize];
5515 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4::FileInfo"][::std::mem::offset_of!(
5516 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4,
5517 FileInfo
5518 ) - 0usize];
5519};
5520#[repr(C)]
5521#[derive(Debug, Default, Copy, Clone)]
5522pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5 {
5523 pub FileInfo: FSP_FSCTL_FILE_INFO,
5524}
5525#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5526const _: () = {
5527 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5"]
5528 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5>() - 72usize];
5529 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5"]
5530 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5>() - 8usize];
5531 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5::FileInfo"][::std::mem::offset_of!(
5532 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5,
5533 FileInfo
5534 ) - 0usize];
5535};
5536#[repr(C)]
5537#[derive(Debug, Default, Copy, Clone)]
5538pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6 {
5539 pub Ea: FSP_FSCTL_TRANSACT_BUF,
5540}
5541#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5542const _: () = {
5543 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6"]
5544 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6>() - 4usize];
5545 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6"]
5546 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6>() - 2usize];
5547 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6::Ea"]
5548 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6, Ea) - 0usize];
5549};
5550#[repr(C)]
5551#[derive(Debug, Default, Copy, Clone)]
5552pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7 {
5553 pub FileInfo: FSP_FSCTL_FILE_INFO,
5554 pub Ea: FSP_FSCTL_TRANSACT_BUF,
5555}
5556#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5557const _: () = {
5558 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7"]
5559 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7>() - 80usize];
5560 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7"]
5561 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7>() - 8usize];
5562 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7::FileInfo"][::std::mem::offset_of!(
5563 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7,
5564 FileInfo
5565 ) - 0usize];
5566 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7::Ea"]
5567 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7, Ea) - 72usize];
5568};
5569#[repr(C)]
5570#[derive(Debug, Default, Copy, Clone)]
5571pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8 {
5572 pub FileInfo: FSP_FSCTL_FILE_INFO,
5573}
5574#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5575const _: () = {
5576 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8"]
5577 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8>() - 72usize];
5578 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8"]
5579 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8>() - 8usize];
5580 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8::FileInfo"][::std::mem::offset_of!(
5581 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8,
5582 FileInfo
5583 ) - 0usize];
5584};
5585#[repr(C)]
5586#[derive(Debug, Default, Copy, Clone)]
5587pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9 {
5588 pub VolumeInfo: FSP_FSCTL_VOLUME_INFO,
5589}
5590#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5591const _: () = {
5592 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9"]
5593 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9>() - 88usize];
5594 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9"]
5595 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9>() - 8usize];
5596 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9::VolumeInfo"][::std::mem::offset_of!(
5597 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9,
5598 VolumeInfo
5599 ) - 0usize];
5600};
5601#[repr(C)]
5602#[derive(Debug, Default, Copy, Clone)]
5603pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10 {
5604 pub VolumeInfo: FSP_FSCTL_VOLUME_INFO,
5605}
5606#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5607const _: () = {
5608 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10"]
5609 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10>() - 88usize];
5610 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10"]
5611 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10>() - 8usize];
5612 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10::VolumeInfo"][::std::mem::offset_of!(
5613 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10,
5614 VolumeInfo
5615 )
5616 - 0usize];
5617};
5618#[repr(C)]
5619#[derive(Debug, Default, Copy, Clone)]
5620pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11 {
5621 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
5622}
5623#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5624const _: () = {
5625 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11"]
5626 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11>() - 4usize];
5627 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11"]
5628 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11>() - 2usize];
5629 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11::Buffer"][::std::mem::offset_of!(
5630 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11,
5631 Buffer
5632 ) - 0usize];
5633};
5634#[repr(C)]
5635#[derive(Debug, Default, Copy, Clone)]
5636pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12 {
5637 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
5638}
5639#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5640const _: () = {
5641 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12"]
5642 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12>() - 4usize];
5643 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12"]
5644 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12>() - 2usize];
5645 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12::Buffer"][::std::mem::offset_of!(
5646 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12,
5647 Buffer
5648 ) - 0usize];
5649};
5650#[repr(C)]
5651#[derive(Debug, Default, Copy, Clone)]
5652pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13 {
5653 pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
5654}
5655#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5656const _: () = {
5657 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13"]
5658 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13>() - 4usize];
5659 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13"]
5660 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13>() - 2usize];
5661 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13::SecurityDescriptor"][::std::mem::offset_of!(
5662 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13,
5663 SecurityDescriptor
5664 )
5665 - 0usize];
5666};
5667#[repr(C)]
5668#[derive(Debug, Default, Copy, Clone)]
5669pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14 {
5670 pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
5671}
5672#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5673const _: () = {
5674 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14"]
5675 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14>() - 4usize];
5676 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14"]
5677 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14>() - 2usize];
5678 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14::SecurityDescriptor"][::std::mem::offset_of!(
5679 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14,
5680 SecurityDescriptor
5681 )
5682 - 0usize];
5683};
5684#[repr(C)]
5685#[derive(Debug, Default, Copy, Clone)]
5686pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15 {
5687 pub Buffer: FSP_FSCTL_TRANSACT_BUF,
5688}
5689#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5690const _: () = {
5691 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15"]
5692 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15>() - 4usize];
5693 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15"]
5694 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15>() - 2usize];
5695 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15::Buffer"][::std::mem::offset_of!(
5696 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15,
5697 Buffer
5698 ) - 0usize];
5699};
5700#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5701const _: () = {
5702 ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2"]
5703 [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2>() - 104usize];
5704 ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2"]
5705 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2>() - 8usize];
5706 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Create"]
5707 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Create) - 0usize];
5708 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Overwrite"]
5709 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Overwrite) - 0usize];
5710 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Write"]
5711 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Write) - 0usize];
5712 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryInformation"]
5713 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QueryInformation) - 0usize];
5714 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetInformation"]
5715 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetInformation) - 0usize];
5716 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryEa"]
5717 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QueryEa) - 0usize];
5718 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetEa"]
5719 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetEa) - 0usize];
5720 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::FlushBuffers"]
5721 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, FlushBuffers) - 0usize];
5722 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryVolumeInformation"][::std::mem::offset_of!(
5723 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
5724 QueryVolumeInformation
5725 ) - 0usize];
5726 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetVolumeInformation"][::std::mem::offset_of!(
5727 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
5728 SetVolumeInformation
5729 ) - 0usize];
5730 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::FileSystemControl"]
5731 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, FileSystemControl) - 0usize];
5732 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::DeviceControl"]
5733 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, DeviceControl) - 0usize];
5734 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QuerySecurity"]
5735 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QuerySecurity) - 0usize];
5736 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetSecurity"]
5737 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetSecurity) - 0usize];
5738 ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryStreamInformation"][::std::mem::offset_of!(
5739 FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
5740 QueryStreamInformation
5741 ) - 0usize];
5742};
5743impl Default for FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2 {
5744 fn default() -> Self {
5745 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5746 unsafe {
5747 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5748 s.assume_init()
5749 }
5750 }
5751}
5752#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5753const _: () = {
5754 ["Size of FSP_FSCTL_TRANSACT_RSP"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP>() - 128usize];
5755 ["Alignment of FSP_FSCTL_TRANSACT_RSP"]
5756 [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP>() - 8usize];
5757 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Version"]
5758 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Version) - 0usize];
5759 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Size"]
5760 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Size) - 2usize];
5761 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Kind"]
5762 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Kind) - 4usize];
5763 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Hint"]
5764 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Hint) - 8usize];
5765 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::IoStatus"]
5766 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, IoStatus) - 16usize];
5767 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Rsp"]
5768 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Rsp) - 24usize];
5769 ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Buffer"]
5770 [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Buffer) - 128usize];
5771};
5772impl Default for FSP_FSCTL_TRANSACT_RSP {
5773 fn default() -> Self {
5774 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5775 unsafe {
5776 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5777 s.assume_init()
5778 }
5779 }
5780}
5781unsafe extern "C" {
5782 pub fn FspFsctlCreateVolume(
5783 DevicePath: PWSTR,
5784 VolumeParams: *const FSP_FSCTL_VOLUME_PARAMS,
5785 VolumeNameBuf: PWCHAR,
5786 VolumeNameSize: SIZE_T,
5787 PVolumeHandle: PHANDLE,
5788 ) -> NTSTATUS;
5789}
5790unsafe extern "C" {
5791 pub fn FspFsctlMakeMountdev(
5792 VolumeHandle: HANDLE,
5793 Persistent: BOOLEAN,
5794 UniqueId: *mut GUID,
5795 ) -> NTSTATUS;
5796}
5797unsafe extern "C" {
5798 pub fn FspFsctlUseMountmgr(VolumeHandle: HANDLE, MountPoint: PWSTR) -> NTSTATUS;
5799}
5800unsafe extern "C" {
5801 pub fn FspFsctlTransact(
5802 VolumeHandle: HANDLE,
5803 ResponseBuf: PVOID,
5804 ResponseBufSize: SIZE_T,
5805 RequestBuf: PVOID,
5806 PRequestBufSize: *mut SIZE_T,
5807 Batch: BOOLEAN,
5808 ) -> NTSTATUS;
5809}
5810unsafe extern "C" {
5811 pub fn FspFsctlStop(VolumeHandle: HANDLE) -> NTSTATUS;
5812}
5813unsafe extern "C" {
5814 pub fn FspFsctlStop0(VolumeHandle: HANDLE) -> NTSTATUS;
5815}
5816unsafe extern "C" {
5817 pub fn FspFsctlNotify(
5818 VolumeHandle: HANDLE,
5819 NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
5820 Size: SIZE_T,
5821 ) -> NTSTATUS;
5822}
5823unsafe extern "C" {
5824 pub fn FspFsctlGetVolumeList(
5825 DevicePath: PWSTR,
5826 VolumeListBuf: PWCHAR,
5827 PVolumeListSize: PSIZE_T,
5828 ) -> NTSTATUS;
5829}
5830unsafe extern "C" {
5831 pub fn FspFsctlPreflight(DevicePath: PWSTR) -> NTSTATUS;
5832}
5833unsafe extern "C" {
5834 pub fn FspFsctlServiceVersion(PVersion: PUINT32) -> NTSTATUS;
5835}
5836unsafe extern "C" {
5837 pub fn FspFsctlStartService() -> NTSTATUS;
5838}
5839unsafe extern "C" {
5840 pub fn FspFsctlStopService() -> NTSTATUS;
5841}
5842unsafe extern "C" {
5843 pub fn FspFsctlEnumServices(
5844 EnumFn: ::std::option::Option<
5845 unsafe extern "C" fn(Context: PVOID, ServiceName: PWSTR, Running: BOOLEAN),
5846 >,
5847 Context: PVOID,
5848 ) -> NTSTATUS;
5849}
5850#[repr(C)]
5851#[derive(Debug, Copy, Clone)]
5852pub struct FSP_MOUNT_DESC {
5853 pub VolumeHandle: HANDLE,
5854 pub VolumeName: PWSTR,
5855 pub Security: PSECURITY_DESCRIPTOR,
5856 pub Reserved: UINT64,
5857 pub MountPoint: PWSTR,
5858 pub MountHandle: HANDLE,
5859}
5860#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5861const _: () = {
5862 ["Size of FSP_MOUNT_DESC"][::std::mem::size_of::<FSP_MOUNT_DESC>() - 48usize];
5863 ["Alignment of FSP_MOUNT_DESC"][::std::mem::align_of::<FSP_MOUNT_DESC>() - 8usize];
5864 ["Offset of field: FSP_MOUNT_DESC::VolumeHandle"]
5865 [::std::mem::offset_of!(FSP_MOUNT_DESC, VolumeHandle) - 0usize];
5866 ["Offset of field: FSP_MOUNT_DESC::VolumeName"]
5867 [::std::mem::offset_of!(FSP_MOUNT_DESC, VolumeName) - 8usize];
5868 ["Offset of field: FSP_MOUNT_DESC::Security"]
5869 [::std::mem::offset_of!(FSP_MOUNT_DESC, Security) - 16usize];
5870 ["Offset of field: FSP_MOUNT_DESC::Reserved"]
5871 [::std::mem::offset_of!(FSP_MOUNT_DESC, Reserved) - 24usize];
5872 ["Offset of field: FSP_MOUNT_DESC::MountPoint"]
5873 [::std::mem::offset_of!(FSP_MOUNT_DESC, MountPoint) - 32usize];
5874 ["Offset of field: FSP_MOUNT_DESC::MountHandle"]
5875 [::std::mem::offset_of!(FSP_MOUNT_DESC, MountHandle) - 40usize];
5876};
5877impl Default for FSP_MOUNT_DESC {
5878 fn default() -> Self {
5879 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5880 unsafe {
5881 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5882 s.assume_init()
5883 }
5884 }
5885}
5886unsafe extern "C" {
5887 pub fn FspMountSet(Desc: *mut FSP_MOUNT_DESC) -> NTSTATUS;
5888}
5889unsafe extern "C" {
5890 pub fn FspMountRemove(Desc: *mut FSP_MOUNT_DESC) -> NTSTATUS;
5891}
5892#[repr(C)]
5893#[derive(Debug, Default, Copy, Clone)]
5894pub struct _FILE_FULL_EA_INFORMATION {
5895 pub NextEntryOffset: ULONG,
5896 pub Flags: UCHAR,
5897 pub EaNameLength: UCHAR,
5898 pub EaValueLength: USHORT,
5899 pub EaName: [CHAR; 1usize],
5900}
5901#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5902const _: () = {
5903 ["Size of _FILE_FULL_EA_INFORMATION"]
5904 [::std::mem::size_of::<_FILE_FULL_EA_INFORMATION>() - 12usize];
5905 ["Alignment of _FILE_FULL_EA_INFORMATION"]
5906 [::std::mem::align_of::<_FILE_FULL_EA_INFORMATION>() - 4usize];
5907 ["Offset of field: _FILE_FULL_EA_INFORMATION::NextEntryOffset"]
5908 [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, NextEntryOffset) - 0usize];
5909 ["Offset of field: _FILE_FULL_EA_INFORMATION::Flags"]
5910 [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, Flags) - 4usize];
5911 ["Offset of field: _FILE_FULL_EA_INFORMATION::EaNameLength"]
5912 [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaNameLength) - 5usize];
5913 ["Offset of field: _FILE_FULL_EA_INFORMATION::EaValueLength"]
5914 [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaValueLength) - 6usize];
5915 ["Offset of field: _FILE_FULL_EA_INFORMATION::EaName"]
5916 [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaName) - 8usize];
5917};
5918pub type PFILE_FULL_EA_INFORMATION = *mut _FILE_FULL_EA_INFORMATION;
5919#[doc = " @group File System\n\n A user mode file system is a program that uses the WinFsp API to expose a file system to\n Windows. The user mode file system must implement the operations in FSP_FILE_SYSTEM_INTERFACE,\n create a file system object using FspFileSystemCreate and start its dispatcher using\n FspFileSystemStartDispatcher. At that point it will start receiving file system requests on the\n FSP_FILE_SYSTEM_INTERFACE operations."]
5920pub type FSP_FILE_SYSTEM = _FSP_FILE_SYSTEM;
5921pub type FSP_FILE_SYSTEM_OPERATION_GUARD = ::std::option::Option<
5922 unsafe extern "C" fn(
5923 arg1: *mut FSP_FILE_SYSTEM,
5924 arg2: *mut FSP_FSCTL_TRANSACT_REQ,
5925 arg3: *mut FSP_FSCTL_TRANSACT_RSP,
5926 ) -> NTSTATUS,
5927>;
5928pub type FSP_FILE_SYSTEM_OPERATION = ::std::option::Option<
5929 unsafe extern "C" fn(
5930 arg1: *mut FSP_FILE_SYSTEM,
5931 arg2: *mut FSP_FSCTL_TRANSACT_REQ,
5932 arg3: *mut FSP_FSCTL_TRANSACT_RSP,
5933 ) -> NTSTATUS,
5934>;
5935pub const FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FINE:
5936 FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = 0;
5937pub const FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_COARSE : FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = 1 ;
5938#[doc = " User mode file system locking strategy.\n\n Two concurrency models are provided:\n\n 1. A fine-grained concurrency model where file system NAMESPACE accesses\n are guarded using an exclusive-shared (read-write) lock. File I/O is not\n guarded and concurrent reads/writes/etc. are possible. [Note that the FSD\n will still apply an exclusive-shared lock PER INDIVIDUAL FILE, but it will\n not limit I/O operations for different files.]\n\n The fine-grained concurrency model applies the exclusive-shared lock as\n follows:\n <ul>\n <li>EXCL: SetVolumeLabel, Flush(Volume),\n Create, Cleanup(Delete), SetInformation(Rename)</li>\n <li>SHRD: GetVolumeInfo, Open, SetInformation(Disposition), ReadDirectory</li>\n <li>NONE: all other operations</li>\n </ul>\n\n 2. A coarse-grained concurrency model where all file system accesses are\n guarded by a mutually exclusive lock.\n\n @see FspFileSystemSetOperationGuardStrategy"]
5939pub type FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = ::std::os::raw::c_int;
5940pub const FspCleanupDelete: _bindgen_ty_6 = 1;
5941pub const FspCleanupSetAllocationSize: _bindgen_ty_6 = 2;
5942pub const FspCleanupSetArchiveBit: _bindgen_ty_6 = 16;
5943pub const FspCleanupSetLastAccessTime: _bindgen_ty_6 = 32;
5944pub const FspCleanupSetLastWriteTime: _bindgen_ty_6 = 64;
5945pub const FspCleanupSetChangeTime: _bindgen_ty_6 = 128;
5946pub type _bindgen_ty_6 = ::std::os::raw::c_int;
5947#[doc = " @class FSP_FILE_SYSTEM\n File system interface.\n\n The operations in this interface must be implemented by the user mode\n file system. Not all operations need be implemented. For example,\n a user mode file system that does not wish to support reparse points,\n need not implement the reparse point operations.\n\n Most of the operations accept a FileContext parameter. This parameter\n has different meanings depending on the value of the FSP_FSCTL_VOLUME_PARAMS\n flags UmFileContextIsUserContext2 and UmFileContextIsFullContext.\n\n There are three cases to consider:\n <ul>\n <li>When both of these flags are unset (default), the FileContext parameter\n represents the file node. The file node is a void pointer (or an integer\n that can fit in a pointer) that is used to uniquely identify an open file.\n Opening the same file name should always yield the same file node value\n for as long as the file with that name remains open anywhere in the system.\n </li>\n <li>When the UmFileContextIsUserContext2 is set, the FileContext parameter\n represents the file descriptor. The file descriptor is a void pointer (or\n an integer that can fit in a pointer) that is used to identify an open\n instance of a file. Opening the same file name may yield a different file\n descriptor.\n </li>\n <li>When the UmFileContextIsFullContext is set, the FileContext parameter\n is a pointer to a FSP_FSCTL_TRANSACT_FULL_CONTEXT. This allows a user mode\n file system to access the low-level UserContext and UserContext2 values.\n The UserContext is used to store the file node and the UserContext2 is\n used to store the file descriptor for an open file.\n </li>\n </ul>"]
5948#[repr(C)]
5949#[derive(Debug, Default, Copy, Clone)]
5950pub struct _FSP_FILE_SYSTEM_INTERFACE {
5951 #[doc = " Get volume information.\n\n @param FileSystem\n The file system on which this request is posted.\n @param VolumeInfo [out]\n Pointer to a structure that will receive the volume information on successful return\n from this call.\n @return\n STATUS_SUCCESS or error code."]
5952 pub GetVolumeInfo: ::std::option::Option<
5953 unsafe extern "C" fn(
5954 FileSystem: *mut FSP_FILE_SYSTEM,
5955 VolumeInfo: *mut FSP_FSCTL_VOLUME_INFO,
5956 ) -> NTSTATUS,
5957 >,
5958 #[doc = " Set volume label.\n\n @param FileSystem\n The file system on which this request is posted.\n @param VolumeLabel\n The new label for the volume.\n @param VolumeInfo [out]\n Pointer to a structure that will receive the volume information on successful return\n from this call.\n @return\n STATUS_SUCCESS or error code."]
5959 pub SetVolumeLabelW: ::std::option::Option<
5960 unsafe extern "C" fn(
5961 FileSystem: *mut FSP_FILE_SYSTEM,
5962 VolumeLabel: PWSTR,
5963 VolumeInfo: *mut FSP_FSCTL_VOLUME_INFO,
5964 ) -> NTSTATUS,
5965 >,
5966 #[doc = " Get file or directory attributes and security descriptor given a file name.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileName\n The name of the file or directory to get the attributes and security descriptor for.\n @param PFileAttributes\n Pointer to a memory location that will receive the file attributes on successful return\n from this call. May be NULL.\n\n If this call returns STATUS_REPARSE, the file system MAY place here the index of the\n first reparse point within FileName. The file system MAY also leave this at its default\n value of 0.\n @param SecurityDescriptor\n Pointer to a buffer that will receive the file security descriptor on successful return\n from this call. May be NULL.\n @param PSecurityDescriptorSize [in,out]\n Pointer to the security descriptor buffer size. On input it contains the size of the\n security descriptor buffer. On output it will contain the actual size of the security\n descriptor copied into the security descriptor buffer. May be NULL.\n @return\n STATUS_SUCCESS, STATUS_REPARSE or error code.\n\n STATUS_REPARSE should be returned by file systems that support reparse points when\n they encounter a FileName that contains reparse points anywhere but the final path\n component."]
5967 pub GetSecurityByName: ::std::option::Option<
5968 unsafe extern "C" fn(
5969 FileSystem: *mut FSP_FILE_SYSTEM,
5970 FileName: PWSTR,
5971 PFileAttributes: PUINT32,
5972 SecurityDescriptor: PSECURITY_DESCRIPTOR,
5973 PSecurityDescriptorSize: *mut SIZE_T,
5974 ) -> NTSTATUS,
5975 >,
5976 #[doc = " Create new file or directory.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileName\n The name of the file or directory to be created.\n @param CreateOptions\n Create options for this request. This parameter has the same meaning as the\n CreateOptions parameter of the NtCreateFile API. User mode file systems should typically\n only be concerned with the flag FILE_DIRECTORY_FILE, which is an instruction to create a\n directory rather than a file. Some file systems may also want to pay attention to the\n FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH flags, although these are\n typically handled by the FSD component.\n @param GrantedAccess\n Determines the specific access rights that have been granted for this request. Upon\n receiving this call all access checks have been performed and the user mode file system\n need not perform any additional checks. However this parameter may be useful to a user\n mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n which flags to use in its POSIX open() call.\n @param FileAttributes\n File attributes to apply to the newly created file or directory.\n @param SecurityDescriptor\n Security descriptor to apply to the newly created file or directory. This security\n descriptor will always be in self-relative format. Its length can be retrieved using the\n Windows GetSecurityDescriptorLength API. Will be NULL for named streams.\n @param AllocationSize\n Allocation size for the newly created file.\n @param PFileContext [out]\n Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
5977 pub Create: ::std::option::Option<
5978 unsafe extern "C" fn(
5979 FileSystem: *mut FSP_FILE_SYSTEM,
5980 FileName: PWSTR,
5981 CreateOptions: UINT32,
5982 GrantedAccess: UINT32,
5983 FileAttributes: UINT32,
5984 SecurityDescriptor: PSECURITY_DESCRIPTOR,
5985 AllocationSize: UINT64,
5986 PFileContext: *mut PVOID,
5987 FileInfo: *mut FSP_FSCTL_FILE_INFO,
5988 ) -> NTSTATUS,
5989 >,
5990 #[doc = " Open a file or directory.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileName\n The name of the file or directory to be opened.\n @param CreateOptions\n Create options for this request. This parameter has the same meaning as the\n CreateOptions parameter of the NtCreateFile API. User mode file systems typically\n do not need to do anything special with respect to this parameter. Some file systems may\n also want to pay attention to the FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH\n flags, although these are typically handled by the FSD component.\n @param GrantedAccess\n Determines the specific access rights that have been granted for this request. Upon\n receiving this call all access checks have been performed and the user mode file system\n need not perform any additional checks. However this parameter may be useful to a user\n mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n which flags to use in its POSIX open() call.\n @param PFileContext [out]\n Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
5991 pub Open: ::std::option::Option<
5992 unsafe extern "C" fn(
5993 FileSystem: *mut FSP_FILE_SYSTEM,
5994 FileName: PWSTR,
5995 CreateOptions: UINT32,
5996 GrantedAccess: UINT32,
5997 PFileContext: *mut PVOID,
5998 FileInfo: *mut FSP_FSCTL_FILE_INFO,
5999 ) -> NTSTATUS,
6000 >,
6001 #[doc = " Overwrite a file.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to overwrite.\n @param FileAttributes\n File attributes to apply to the overwritten file.\n @param ReplaceFileAttributes\n When TRUE the existing file attributes should be replaced with the new ones.\n When FALSE the existing file attributes should be merged (or'ed) with the new ones.\n @param AllocationSize\n Allocation size for the overwritten file.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6002 pub Overwrite: ::std::option::Option<
6003 unsafe extern "C" fn(
6004 FileSystem: *mut FSP_FILE_SYSTEM,
6005 FileContext: PVOID,
6006 FileAttributes: UINT32,
6007 ReplaceFileAttributes: BOOLEAN,
6008 AllocationSize: UINT64,
6009 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6010 ) -> NTSTATUS,
6011 >,
6012 #[doc = " Cleanup a file.\n\n When CreateFile is used to open or create a file the kernel creates a kernel mode file\n object (type FILE_OBJECT) and a handle for it, which it returns to user-mode. The handle may\n be duplicated (using DuplicateHandle), but all duplicate handles always refer to the same\n file object. When all handles for a particular file object get closed (using CloseHandle)\n the system sends a Cleanup request to the file system.\n\n There will be a Cleanup operation for every Create or Open operation posted to the user mode\n file system. However the Cleanup operation is <b>not</b> the final close operation on a file.\n The file system must be ready to receive additional operations until close time. This is true\n even when the file is being deleted!\n\n The Flags parameter contains information about the cleanup operation:\n <ul>\n <li>FspCleanupDelete -\n An important function of the Cleanup operation is to complete a delete operation. Deleting\n a file or directory in Windows is a three-stage process where the file is first opened, then\n tested to see if the delete can proceed and if the answer is positive the file is then\n deleted during Cleanup.\n\n If the file system supports POSIX unlink (FSP_FSCTL_VOLUME_PARAMS ::\n SupportsPosixUnlinkRename), then a Cleanup / FspCleanupDelete operation may arrive while\n there are other open file handles for this particular file node. If the file system does not\n support POSIX unlink, then a Cleanup / FspCleanupDelete operation will always be the last\n outstanding cleanup for this particular file node.\n </li>\n <li>FspCleanupSetAllocationSize -\n The NTFS and FAT file systems reset a file's allocation size when they receive the last\n outstanding cleanup for a particular file node. User mode file systems that implement\n allocation size and wish to duplicate the NTFS and FAT behavior can use this flag.\n </li>\n <li>\n FspCleanupSetArchiveBit -\n File systems that support the archive bit should set the file node's archive bit when this\n flag is set.\n </li>\n <li>FspCleanupSetLastAccessTime, FspCleanupSetLastWriteTime, FspCleanupSetChangeTime - File\n systems should set the corresponding file time when each one of these flags is set. Note that\n updating the last access time is expensive and a file system may choose to not implement it.\n </ul>\n\n There is no way to report failure of this operation. This is a Windows limitation.\n\n As an optimization a file system may specify the FSP_FSCTL_VOLUME_PARAMS ::\n PostCleanupWhenModifiedOnly flag. In this case the FSD will only post Cleanup requests when\n the file was modified/deleted.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to cleanup.\n @param FileName\n The name of the file or directory to cleanup. Sent only when a Delete is requested.\n @param Flags\n These flags determine whether the file was modified and whether to delete the file.\n @see\n Close\n CanDelete\n SetDelete"]
6013 pub Cleanup: ::std::option::Option<
6014 unsafe extern "C" fn(
6015 FileSystem: *mut FSP_FILE_SYSTEM,
6016 FileContext: PVOID,
6017 FileName: PWSTR,
6018 Flags: ULONG,
6019 ),
6020 >,
6021 #[doc = " Close a file.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to be closed."]
6022 pub Close: ::std::option::Option<
6023 unsafe extern "C" fn(FileSystem: *mut FSP_FILE_SYSTEM, FileContext: PVOID),
6024 >,
6025 #[doc = " Read a file.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to be read.\n @param Buffer\n Pointer to a buffer that will receive the results of the read operation.\n @param Offset\n Offset within the file to read from.\n @param Length\n Length of data to read.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes read.\n @return\n STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n operation."]
6026 pub Read: ::std::option::Option<
6027 unsafe extern "C" fn(
6028 FileSystem: *mut FSP_FILE_SYSTEM,
6029 FileContext: PVOID,
6030 Buffer: PVOID,
6031 Offset: UINT64,
6032 Length: ULONG,
6033 PBytesTransferred: PULONG,
6034 ) -> NTSTATUS,
6035 >,
6036 #[doc = " Write a file.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to be written.\n @param Buffer\n Pointer to a buffer that contains the data to write.\n @param Offset\n Offset within the file to write to.\n @param Length\n Length of data to write.\n @param WriteToEndOfFile\n When TRUE the file system must write to the current end of file. In this case the Offset\n parameter will contain the value -1.\n @param ConstrainedIo\n When TRUE the file system must not extend the file (i.e. change the file size).\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes written.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n operation."]
6037 pub Write: ::std::option::Option<
6038 unsafe extern "C" fn(
6039 FileSystem: *mut FSP_FILE_SYSTEM,
6040 FileContext: PVOID,
6041 Buffer: PVOID,
6042 Offset: UINT64,
6043 Length: ULONG,
6044 WriteToEndOfFile: BOOLEAN,
6045 ConstrainedIo: BOOLEAN,
6046 PBytesTransferred: PULONG,
6047 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6048 ) -> NTSTATUS,
6049 >,
6050 #[doc = " Flush a file or volume.\n\n Note that the FSD will also flush all file/volume caches prior to invoking this operation.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to be flushed. When NULL the whole volume is being flushed.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc. Used when\n flushing file (not volume).\n @return\n STATUS_SUCCESS or error code."]
6051 pub Flush: ::std::option::Option<
6052 unsafe extern "C" fn(
6053 FileSystem: *mut FSP_FILE_SYSTEM,
6054 FileContext: PVOID,
6055 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6056 ) -> NTSTATUS,
6057 >,
6058 #[doc = " Get file or directory information.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to get information for.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6059 pub GetFileInfo: ::std::option::Option<
6060 unsafe extern "C" fn(
6061 FileSystem: *mut FSP_FILE_SYSTEM,
6062 FileContext: PVOID,
6063 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6064 ) -> NTSTATUS,
6065 >,
6066 #[doc = " Set file or directory basic information.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to set information for.\n @param FileAttributes\n File attributes to apply to the file or directory. If the value INVALID_FILE_ATTRIBUTES\n is sent, the file attributes should not be changed.\n @param CreationTime\n Creation time to apply to the file or directory. If the value 0 is sent, the creation\n time should not be changed.\n @param LastAccessTime\n Last access time to apply to the file or directory. If the value 0 is sent, the last\n access time should not be changed.\n @param LastWriteTime\n Last write time to apply to the file or directory. If the value 0 is sent, the last\n write time should not be changed.\n @param ChangeTime\n Change time to apply to the file or directory. If the value 0 is sent, the change time\n should not be changed.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6067 pub SetBasicInfo: ::std::option::Option<
6068 unsafe extern "C" fn(
6069 FileSystem: *mut FSP_FILE_SYSTEM,
6070 FileContext: PVOID,
6071 FileAttributes: UINT32,
6072 CreationTime: UINT64,
6073 LastAccessTime: UINT64,
6074 LastWriteTime: UINT64,
6075 ChangeTime: UINT64,
6076 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6077 ) -> NTSTATUS,
6078 >,
6079 #[doc = " Set file/allocation size.\n\n This function is used to change a file's sizes. Windows file systems maintain two kinds\n of sizes: the file size is where the End Of File (EOF) is, and the allocation size is the\n actual size that a file takes up on the \"disk\".\n\n The rules regarding file/allocation size are:\n <ul>\n <li>Allocation size must always be aligned to the allocation unit boundary. The allocation\n unit is the product <code>(UINT64)SectorSize * (UINT64)SectorsPerAllocationUnit</code> from\n the FSP_FSCTL_VOLUME_PARAMS structure. The FSD will always send properly aligned allocation\n sizes when setting the allocation size.</li>\n <li>Allocation size is always greater or equal to the file size.</li>\n <li>A file size of more than the current allocation size will also extend the allocation\n size to the next allocation unit boundary.</li>\n <li>An allocation size of less than the current file size should also truncate the current\n file size.</li>\n </ul>\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to set the file/allocation size for.\n @param NewSize\n New file/allocation size to apply to the file.\n @param SetAllocationSize\n If TRUE, then the allocation size is being set. if FALSE, then the file size is being set.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6080 pub SetFileSize: ::std::option::Option<
6081 unsafe extern "C" fn(
6082 FileSystem: *mut FSP_FILE_SYSTEM,
6083 FileContext: PVOID,
6084 NewSize: UINT64,
6085 SetAllocationSize: BOOLEAN,
6086 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6087 ) -> NTSTATUS,
6088 >,
6089 #[doc = " Determine whether a file or directory can be deleted.\n\n This function tests whether a file or directory can be safely deleted. This function does\n not need to perform access checks, but may performs tasks such as check for empty\n directories, etc.\n\n This function should <b>NEVER</b> delete the file or directory in question. Deletion should\n happen during Cleanup with the FspCleanupDelete flag set.\n\n This function gets called when Win32 API's such as DeleteFile or RemoveDirectory are used.\n It does not get called when a file or directory is opened with FILE_DELETE_ON_CLOSE.\n\n NOTE: If both CanDelete and SetDelete are defined, SetDelete takes precedence. However\n most file systems need only implement the CanDelete operation.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to test for deletion.\n @param FileName\n The name of the file or directory to test for deletion.\n @return\n STATUS_SUCCESS or error code.\n @see\n Cleanup\n SetDelete"]
6090 pub CanDelete: ::std::option::Option<
6091 unsafe extern "C" fn(
6092 FileSystem: *mut FSP_FILE_SYSTEM,
6093 FileContext: PVOID,
6094 FileName: PWSTR,
6095 ) -> NTSTATUS,
6096 >,
6097 #[doc = " Renames a file or directory.\n\n The kernel mode FSD provides certain guarantees prior to posting a rename operation:\n <ul>\n <li>A file cannot be renamed if a file with the same name exists and has open handles.</li>\n <li>A directory cannot be renamed if it or any of its subdirectories contains a file that\n has open handles.</li>\n </ul>\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to be renamed.\n @param FileName\n The current name of the file or directory to rename.\n @param NewFileName\n The new name for the file or directory.\n @param ReplaceIfExists\n Whether to replace a file that already exists at NewFileName.\n @return\n STATUS_SUCCESS or error code."]
6098 pub Rename: ::std::option::Option<
6099 unsafe extern "C" fn(
6100 FileSystem: *mut FSP_FILE_SYSTEM,
6101 FileContext: PVOID,
6102 FileName: PWSTR,
6103 NewFileName: PWSTR,
6104 ReplaceIfExists: BOOLEAN,
6105 ) -> NTSTATUS,
6106 >,
6107 #[doc = " Get file or directory security descriptor.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to get the security descriptor for.\n @param SecurityDescriptor\n Pointer to a buffer that will receive the file security descriptor on successful return\n from this call. May be NULL.\n @param PSecurityDescriptorSize [in,out]\n Pointer to the security descriptor buffer size. On input it contains the size of the\n security descriptor buffer. On output it will contain the actual size of the security\n descriptor copied into the security descriptor buffer. Cannot be NULL.\n @return\n STATUS_SUCCESS or error code."]
6108 pub GetSecurity: ::std::option::Option<
6109 unsafe extern "C" fn(
6110 FileSystem: *mut FSP_FILE_SYSTEM,
6111 FileContext: PVOID,
6112 SecurityDescriptor: PSECURITY_DESCRIPTOR,
6113 PSecurityDescriptorSize: *mut SIZE_T,
6114 ) -> NTSTATUS,
6115 >,
6116 #[doc = " Set file or directory security descriptor.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to set the security descriptor for.\n @param SecurityInformation\n Describes what parts of the file or directory security descriptor should\n be modified.\n @param ModificationDescriptor\n Describes the modifications to apply to the file or directory security descriptor.\n @return\n STATUS_SUCCESS or error code.\n @see\n FspSetSecurityDescriptor\n FspDeleteSecurityDescriptor"]
6117 pub SetSecurity: ::std::option::Option<
6118 unsafe extern "C" fn(
6119 FileSystem: *mut FSP_FILE_SYSTEM,
6120 FileContext: PVOID,
6121 SecurityInformation: SECURITY_INFORMATION,
6122 ModificationDescriptor: PSECURITY_DESCRIPTOR,
6123 ) -> NTSTATUS,
6124 >,
6125 #[doc = " Read a directory.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the directory to be read.\n @param Pattern\n The pattern to match against files in this directory. Can be NULL. The file system\n can choose to ignore this parameter as the FSD will always perform its own pattern\n matching on the returned results.\n @param Marker\n A file name that marks where in the directory to start reading. Files with names\n that are greater than (not equal to) this marker (in the directory order determined\n by the file system) should be returned. Can be NULL.\n @param Buffer\n Pointer to a buffer that will receive the results of the read operation.\n @param Length\n Length of data to read.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes read.\n @return\n STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n operation.\n @see\n FspFileSystemAddDirInfo"]
6126 pub ReadDirectory: ::std::option::Option<
6127 unsafe extern "C" fn(
6128 FileSystem: *mut FSP_FILE_SYSTEM,
6129 FileContext: PVOID,
6130 Pattern: PWSTR,
6131 Marker: PWSTR,
6132 Buffer: PVOID,
6133 Length: ULONG,
6134 PBytesTransferred: PULONG,
6135 ) -> NTSTATUS,
6136 >,
6137 #[doc = " Resolve reparse points.\n\n Reparse points are a general mechanism for attaching special behavior to files.\n A file or directory can contain a reparse point. A reparse point is data that has\n special meaning to the file system, Windows or user applications. For example, NTFS\n and Windows use reparse points to implement symbolic links. As another example,\n a particular file system may use reparse points to emulate UNIX FIFO's.\n\n This function is expected to resolve as many reparse points as possible. If a reparse\n point is encountered that is not understood by the file system further reparse point\n resolution should stop; the reparse point data should be returned to the FSD with status\n STATUS_REPARSE/reparse-tag. If a reparse point (symbolic link) is encountered that is\n understood by the file system but points outside it, the reparse point should be\n resolved, but further reparse point resolution should stop; the resolved file name\n should be returned to the FSD with status STATUS_REPARSE/IO_REPARSE.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileName\n The name of the file or directory to have its reparse points resolved.\n @param ReparsePointIndex\n The index of the first reparse point within FileName.\n @param ResolveLastPathComponent\n If FALSE, the last path component of FileName should not be resolved, even\n if it is a reparse point that can be resolved. If TRUE, all path components\n should be resolved if possible.\n @param PIoStatus\n Pointer to storage that will receive the status to return to the FSD. When\n this function succeeds it must set PIoStatus->Status to STATUS_REPARSE and\n PIoStatus->Information to either IO_REPARSE or the reparse tag.\n @param Buffer\n Pointer to a buffer that will receive the resolved file name (IO_REPARSE) or\n reparse data (reparse tag). If the function returns a file name, it should\n not be NULL terminated.\n @param PSize [in,out]\n Pointer to the buffer size. On input it contains the size of the buffer.\n On output it will contain the actual size of data copied.\n @return\n STATUS_REPARSE or error code."]
6138 pub ResolveReparsePoints: ::std::option::Option<
6139 unsafe extern "C" fn(
6140 FileSystem: *mut FSP_FILE_SYSTEM,
6141 FileName: PWSTR,
6142 ReparsePointIndex: UINT32,
6143 ResolveLastPathComponent: BOOLEAN,
6144 PIoStatus: PIO_STATUS_BLOCK,
6145 Buffer: PVOID,
6146 PSize: PSIZE_T,
6147 ) -> NTSTATUS,
6148 >,
6149 #[doc = " Get reparse point.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the reparse point.\n @param FileName\n The file name of the reparse point.\n @param Buffer\n Pointer to a buffer that will receive the results of this operation. If\n the function returns a symbolic link path, it should not be NULL terminated.\n @param PSize [in,out]\n Pointer to the buffer size. On input it contains the size of the buffer.\n On output it will contain the actual size of data copied.\n @return\n STATUS_SUCCESS or error code.\n @see\n SetReparsePoint"]
6150 pub GetReparsePoint: ::std::option::Option<
6151 unsafe extern "C" fn(
6152 FileSystem: *mut FSP_FILE_SYSTEM,
6153 FileContext: PVOID,
6154 FileName: PWSTR,
6155 Buffer: PVOID,
6156 PSize: PSIZE_T,
6157 ) -> NTSTATUS,
6158 >,
6159 #[doc = " Set reparse point.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the reparse point.\n @param FileName\n The file name of the reparse point.\n @param Buffer\n Pointer to a buffer that contains the data for this operation. If this buffer\n contains a symbolic link path, it should not be assumed to be NULL terminated.\n @param Size\n Size of data to write.\n @return\n STATUS_SUCCESS or error code.\n @see\n GetReparsePoint"]
6160 pub SetReparsePoint: ::std::option::Option<
6161 unsafe extern "C" fn(
6162 FileSystem: *mut FSP_FILE_SYSTEM,
6163 FileContext: PVOID,
6164 FileName: PWSTR,
6165 Buffer: PVOID,
6166 Size: SIZE_T,
6167 ) -> NTSTATUS,
6168 >,
6169 #[doc = " Delete reparse point.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the reparse point.\n @param FileName\n The file name of the reparse point.\n @param Buffer\n Pointer to a buffer that contains the data for this operation.\n @param Size\n Size of data to write.\n @return\n STATUS_SUCCESS or error code."]
6170 pub DeleteReparsePoint: ::std::option::Option<
6171 unsafe extern "C" fn(
6172 FileSystem: *mut FSP_FILE_SYSTEM,
6173 FileContext: PVOID,
6174 FileName: PWSTR,
6175 Buffer: PVOID,
6176 Size: SIZE_T,
6177 ) -> NTSTATUS,
6178 >,
6179 #[doc = " Get named streams information.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to get stream information for.\n @param Buffer\n Pointer to a buffer that will receive the stream information.\n @param Length\n Length of buffer.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes stored.\n @return\n STATUS_SUCCESS or error code.\n @see\n FspFileSystemAddStreamInfo"]
6180 pub GetStreamInfo: ::std::option::Option<
6181 unsafe extern "C" fn(
6182 FileSystem: *mut FSP_FILE_SYSTEM,
6183 FileContext: PVOID,
6184 Buffer: PVOID,
6185 Length: ULONG,
6186 PBytesTransferred: PULONG,
6187 ) -> NTSTATUS,
6188 >,
6189 #[doc = " Get directory information for a single file or directory within a parent directory.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the parent directory.\n @param FileName\n The name of the file or directory to get information for. This name is relative\n to the parent directory and is a single path component.\n @param DirInfo [out]\n Pointer to a structure that will receive the directory information on successful\n return from this call. This information includes the file name, but also file\n attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6190 pub GetDirInfoByName: ::std::option::Option<
6191 unsafe extern "C" fn(
6192 FileSystem: *mut FSP_FILE_SYSTEM,
6193 FileContext: PVOID,
6194 FileName: PWSTR,
6195 DirInfo: *mut FSP_FSCTL_DIR_INFO,
6196 ) -> NTSTATUS,
6197 >,
6198 #[doc = " Process control code.\n\n This function is called when a program uses the DeviceIoControl API.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to be controled.\n @param ControlCode\n The control code for the operation. This code must have a DeviceType with bit\n 0x8000 set and must have a TransferType of METHOD_BUFFERED.\n @param InputBuffer\n Pointer to a buffer that contains the input data.\n @param InputBufferLength\n Input data length.\n @param OutputBuffer\n Pointer to a buffer that will receive the output data.\n @param OutputBufferLength\n Output data length.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes transferred.\n @return\n STATUS_SUCCESS or error code."]
6199 pub Control: ::std::option::Option<
6200 unsafe extern "C" fn(
6201 FileSystem: *mut FSP_FILE_SYSTEM,
6202 FileContext: PVOID,
6203 ControlCode: UINT32,
6204 InputBuffer: PVOID,
6205 InputBufferLength: ULONG,
6206 OutputBuffer: PVOID,
6207 OutputBufferLength: ULONG,
6208 PBytesTransferred: PULONG,
6209 ) -> NTSTATUS,
6210 >,
6211 #[doc = " Set the file delete flag.\n\n This function sets a flag to indicates whether the FSD file should delete a file\n when it is closed. This function does not need to perform access checks, but may\n performs tasks such as check for empty directories, etc.\n\n This function should <b>NEVER</b> delete the file or directory in question. Deletion should\n happen during Cleanup with the FspCleanupDelete flag set.\n\n This function gets called when Win32 API's such as DeleteFile or RemoveDirectory are used.\n It does not get called when a file or directory is opened with FILE_DELETE_ON_CLOSE.\n\n NOTE: If both CanDelete and SetDelete are defined, SetDelete takes precedence. However\n most file systems need only implement the CanDelete operation.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file or directory to set the delete flag for.\n @param FileName\n The name of the file or directory to set the delete flag for.\n @param DeleteFile\n If set to TRUE the FSD indicates that the file will be deleted on Cleanup; otherwise\n it will not be deleted. It is legal to receive multiple SetDelete calls for the same\n file with different DeleteFile parameters.\n @return\n STATUS_SUCCESS or error code.\n @see\n Cleanup\n CanDelete"]
6212 pub SetDelete: ::std::option::Option<
6213 unsafe extern "C" fn(
6214 FileSystem: *mut FSP_FILE_SYSTEM,
6215 FileContext: PVOID,
6216 FileName: PWSTR,
6217 DeleteFileW: BOOLEAN,
6218 ) -> NTSTATUS,
6219 >,
6220 #[doc = " Create new file or directory.\n\n This function works like Create, except that it also accepts an extra buffer that\n may contain extended attributes or a reparse point.\n\n NOTE: If both Create and CreateEx are defined, CreateEx takes precedence.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileName\n The name of the file or directory to be created.\n @param CreateOptions\n Create options for this request. This parameter has the same meaning as the\n CreateOptions parameter of the NtCreateFile API. User mode file systems should typically\n only be concerned with the flag FILE_DIRECTORY_FILE, which is an instruction to create a\n directory rather than a file. Some file systems may also want to pay attention to the\n FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH flags, although these are\n typically handled by the FSD component.\n @param GrantedAccess\n Determines the specific access rights that have been granted for this request. Upon\n receiving this call all access checks have been performed and the user mode file system\n need not perform any additional checks. However this parameter may be useful to a user\n mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n which flags to use in its POSIX open() call.\n @param FileAttributes\n File attributes to apply to the newly created file or directory.\n @param SecurityDescriptor\n Security descriptor to apply to the newly created file or directory. This security\n descriptor will always be in self-relative format. Its length can be retrieved using the\n Windows GetSecurityDescriptorLength API. Will be NULL for named streams.\n @param AllocationSize\n Allocation size for the newly created file.\n @param ExtraBuffer\n Extended attributes or reparse point buffer.\n @param ExtraLength\n Extended attributes or reparse point buffer length.\n @param ExtraBufferIsReparsePoint\n FALSE: extra buffer is extended attributes; TRUE: extra buffer is reparse point.\n @param PFileContext [out]\n Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6221 pub CreateEx: ::std::option::Option<
6222 unsafe extern "C" fn(
6223 FileSystem: *mut FSP_FILE_SYSTEM,
6224 FileName: PWSTR,
6225 CreateOptions: UINT32,
6226 GrantedAccess: UINT32,
6227 FileAttributes: UINT32,
6228 SecurityDescriptor: PSECURITY_DESCRIPTOR,
6229 AllocationSize: UINT64,
6230 ExtraBuffer: PVOID,
6231 ExtraLength: ULONG,
6232 ExtraBufferIsReparsePoint: BOOLEAN,
6233 PFileContext: *mut PVOID,
6234 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6235 ) -> NTSTATUS,
6236 >,
6237 #[doc = " Overwrite a file.\n\n This function works like Overwrite, except that it also accepts EA (extended attributes).\n\n NOTE: If both Overwrite and OverwriteEx are defined, OverwriteEx takes precedence.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to overwrite.\n @param FileAttributes\n File attributes to apply to the overwritten file.\n @param ReplaceFileAttributes\n When TRUE the existing file attributes should be replaced with the new ones.\n When FALSE the existing file attributes should be merged (or'ed) with the new ones.\n @param AllocationSize\n Allocation size for the overwritten file.\n @param Ea\n Extended attributes buffer.\n @param EaLength\n Extended attributes buffer length.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code."]
6238 pub OverwriteEx: ::std::option::Option<
6239 unsafe extern "C" fn(
6240 FileSystem: *mut FSP_FILE_SYSTEM,
6241 FileContext: PVOID,
6242 FileAttributes: UINT32,
6243 ReplaceFileAttributes: BOOLEAN,
6244 AllocationSize: UINT64,
6245 Ea: PFILE_FULL_EA_INFORMATION,
6246 EaLength: ULONG,
6247 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6248 ) -> NTSTATUS,
6249 >,
6250 #[doc = " Get extended attributes.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to get extended attributes for.\n @param Ea\n Extended attributes buffer.\n @param EaLength\n Extended attributes buffer length.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes transferred.\n @return\n STATUS_SUCCESS or error code.\n @see\n SetEa\n FspFileSystemAddEa"]
6251 pub GetEa: ::std::option::Option<
6252 unsafe extern "C" fn(
6253 FileSystem: *mut FSP_FILE_SYSTEM,
6254 FileContext: PVOID,
6255 Ea: PFILE_FULL_EA_INFORMATION,
6256 EaLength: ULONG,
6257 PBytesTransferred: PULONG,
6258 ) -> NTSTATUS,
6259 >,
6260 #[doc = " Set extended attributes.\n\n @param FileSystem\n The file system on which this request is posted.\n @param FileContext\n The file context of the file to set extended attributes for.\n @param Ea\n Extended attributes buffer.\n @param EaLength\n Extended attributes buffer length.\n @param FileInfo [out]\n Pointer to a structure that will receive the file information on successful return\n from this call. This information includes file attributes, file times, etc.\n @return\n STATUS_SUCCESS or error code.\n @see\n GetEa"]
6261 pub SetEa: ::std::option::Option<
6262 unsafe extern "C" fn(
6263 FileSystem: *mut FSP_FILE_SYSTEM,
6264 FileContext: PVOID,
6265 Ea: PFILE_FULL_EA_INFORMATION,
6266 EaLength: ULONG,
6267 FileInfo: *mut FSP_FSCTL_FILE_INFO,
6268 ) -> NTSTATUS,
6269 >,
6270 pub Obsolete0: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
6271 #[doc = " Inform the file system that its dispatcher has been stopped.\n\n Prior to WinFsp v2.0 the FSD would never unmount a file system volume unless\n the user mode file system requested the unmount. Since WinFsp v2.0 it is possible\n for the FSD to unmount a file system volume without an explicit user mode file system\n request. For example, this happens when the FSD is being uninstalled.\n\n A user mode file system can use this operation to determine when its dispatcher\n has been stopped. The Normally parameter can be used to determine why the dispatcher\n was stopped: it is TRUE when the file system is being stopped via\n FspFileSystemStopDispatcher and FALSE otherwise.\n\n When the file system receives a request with Normally == TRUE it need not take any\n extra steps. This case is the same as for pre-v2.0 versions: since the file system\n stopped the dispatcher via FspFileSystemStopDispatcher, it will likely exit its\n process soon.\n\n When the file system receives a request with Normally == FALSE it may need to take\n extra steps to exit its process as this is not done by default.\n\n A file system that uses the FspService infrastructure may use the\n FspFileSystemStopServiceIfNecessary API to correctly handle all cases.\n\n This operation is the last one that a file system will receive.\n\n @param FileSystem\n The file system on which this request is posted.\n @param Normally\n TRUE if the file system is being stopped via FspFileSystemStopDispatcher.\n FALSE if the file system is being stopped because of another reason such\n as driver unload/uninstall.\n @see\n FspFileSystemStopServiceIfNecessary"]
6272 pub DispatcherStopped: ::std::option::Option<
6273 unsafe extern "C" fn(FileSystem: *mut FSP_FILE_SYSTEM, Normally: BOOLEAN),
6274 >,
6275 pub Reserved: [::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>; 31usize],
6276}
6277#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6278const _: () = {
6279 ["Size of _FSP_FILE_SYSTEM_INTERFACE"]
6280 [::std::mem::size_of::<_FSP_FILE_SYSTEM_INTERFACE>() - 512usize];
6281 ["Alignment of _FSP_FILE_SYSTEM_INTERFACE"]
6282 [::std::mem::align_of::<_FSP_FILE_SYSTEM_INTERFACE>() - 8usize];
6283 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetVolumeInfo"]
6284 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetVolumeInfo) - 0usize];
6285 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetVolumeLabelW"]
6286 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetVolumeLabelW) - 8usize];
6287 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetSecurityByName"]
6288 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetSecurityByName) - 16usize];
6289 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Create"]
6290 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Create) - 24usize];
6291 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Open"]
6292 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Open) - 32usize];
6293 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Overwrite"]
6294 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Overwrite) - 40usize];
6295 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Cleanup"]
6296 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Cleanup) - 48usize];
6297 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Close"]
6298 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Close) - 56usize];
6299 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Read"]
6300 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Read) - 64usize];
6301 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Write"]
6302 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Write) - 72usize];
6303 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Flush"]
6304 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Flush) - 80usize];
6305 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetFileInfo"]
6306 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetFileInfo) - 88usize];
6307 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetBasicInfo"]
6308 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetBasicInfo) - 96usize];
6309 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetFileSize"]
6310 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetFileSize) - 104usize];
6311 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::CanDelete"]
6312 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, CanDelete) - 112usize];
6313 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Rename"]
6314 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Rename) - 120usize];
6315 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetSecurity"]
6316 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetSecurity) - 128usize];
6317 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetSecurity"]
6318 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetSecurity) - 136usize];
6319 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::ReadDirectory"]
6320 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, ReadDirectory) - 144usize];
6321 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::ResolveReparsePoints"]
6322 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, ResolveReparsePoints) - 152usize];
6323 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetReparsePoint"]
6324 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetReparsePoint) - 160usize];
6325 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetReparsePoint"]
6326 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetReparsePoint) - 168usize];
6327 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::DeleteReparsePoint"]
6328 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, DeleteReparsePoint) - 176usize];
6329 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetStreamInfo"]
6330 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetStreamInfo) - 184usize];
6331 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetDirInfoByName"]
6332 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetDirInfoByName) - 192usize];
6333 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Control"]
6334 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Control) - 200usize];
6335 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetDelete"]
6336 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetDelete) - 208usize];
6337 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::CreateEx"]
6338 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, CreateEx) - 216usize];
6339 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::OverwriteEx"]
6340 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, OverwriteEx) - 224usize];
6341 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetEa"]
6342 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetEa) - 232usize];
6343 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetEa"]
6344 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetEa) - 240usize];
6345 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Obsolete0"]
6346 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Obsolete0) - 248usize];
6347 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::DispatcherStopped"]
6348 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, DispatcherStopped) - 256usize];
6349 ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Reserved"]
6350 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Reserved) - 264usize];
6351};
6352#[doc = " @class FSP_FILE_SYSTEM\n File system interface.\n\n The operations in this interface must be implemented by the user mode\n file system. Not all operations need be implemented. For example,\n a user mode file system that does not wish to support reparse points,\n need not implement the reparse point operations.\n\n Most of the operations accept a FileContext parameter. This parameter\n has different meanings depending on the value of the FSP_FSCTL_VOLUME_PARAMS\n flags UmFileContextIsUserContext2 and UmFileContextIsFullContext.\n\n There are three cases to consider:\n <ul>\n <li>When both of these flags are unset (default), the FileContext parameter\n represents the file node. The file node is a void pointer (or an integer\n that can fit in a pointer) that is used to uniquely identify an open file.\n Opening the same file name should always yield the same file node value\n for as long as the file with that name remains open anywhere in the system.\n </li>\n <li>When the UmFileContextIsUserContext2 is set, the FileContext parameter\n represents the file descriptor. The file descriptor is a void pointer (or\n an integer that can fit in a pointer) that is used to identify an open\n instance of a file. Opening the same file name may yield a different file\n descriptor.\n </li>\n <li>When the UmFileContextIsFullContext is set, the FileContext parameter\n is a pointer to a FSP_FSCTL_TRANSACT_FULL_CONTEXT. This allows a user mode\n file system to access the low-level UserContext and UserContext2 values.\n The UserContext is used to store the file node and the UserContext2 is\n used to store the file descriptor for an open file.\n </li>\n </ul>"]
6353pub type FSP_FILE_SYSTEM_INTERFACE = _FSP_FILE_SYSTEM_INTERFACE;
6354#[repr(C)]
6355#[derive(Debug, Copy, Clone)]
6356pub struct _FSP_FILE_SYSTEM {
6357 pub Version: UINT16,
6358 pub UserContext: PVOID,
6359 pub VolumeName: [WCHAR; 256usize],
6360 pub VolumeHandle: HANDLE,
6361 pub EnterOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
6362 pub LeaveOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
6363 pub Operations: [FSP_FILE_SYSTEM_OPERATION; 22usize],
6364 pub Interface: *const FSP_FILE_SYSTEM_INTERFACE,
6365 pub DispatcherThread: HANDLE,
6366 pub DispatcherThreadCount: ULONG,
6367 pub DispatcherResult: NTSTATUS,
6368 pub MountPoint: PWSTR,
6369 pub MountHandle: HANDLE,
6370 pub DebugLog: UINT32,
6371 pub OpGuardStrategy: FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY,
6372 pub OpGuardLock: SRWLOCK,
6373 pub UmFileContextIsUserContext2: BOOLEAN,
6374 pub UmFileContextIsFullContext: BOOLEAN,
6375 pub _bitfield_align_1: [u16; 0],
6376 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
6377 pub __bindgen_padding_0: u32,
6378}
6379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6380const _: () = {
6381 ["Size of _FSP_FILE_SYSTEM"][::std::mem::size_of::<_FSP_FILE_SYSTEM>() - 792usize];
6382 ["Alignment of _FSP_FILE_SYSTEM"][::std::mem::align_of::<_FSP_FILE_SYSTEM>() - 8usize];
6383 ["Offset of field: _FSP_FILE_SYSTEM::Version"]
6384 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Version) - 0usize];
6385 ["Offset of field: _FSP_FILE_SYSTEM::UserContext"]
6386 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UserContext) - 8usize];
6387 ["Offset of field: _FSP_FILE_SYSTEM::VolumeName"]
6388 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, VolumeName) - 16usize];
6389 ["Offset of field: _FSP_FILE_SYSTEM::VolumeHandle"]
6390 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, VolumeHandle) - 528usize];
6391 ["Offset of field: _FSP_FILE_SYSTEM::EnterOperation"]
6392 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, EnterOperation) - 536usize];
6393 ["Offset of field: _FSP_FILE_SYSTEM::LeaveOperation"]
6394 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, LeaveOperation) - 544usize];
6395 ["Offset of field: _FSP_FILE_SYSTEM::Operations"]
6396 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Operations) - 552usize];
6397 ["Offset of field: _FSP_FILE_SYSTEM::Interface"]
6398 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Interface) - 728usize];
6399 ["Offset of field: _FSP_FILE_SYSTEM::DispatcherThread"]
6400 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherThread) - 736usize];
6401 ["Offset of field: _FSP_FILE_SYSTEM::DispatcherThreadCount"]
6402 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherThreadCount) - 744usize];
6403 ["Offset of field: _FSP_FILE_SYSTEM::DispatcherResult"]
6404 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherResult) - 748usize];
6405 ["Offset of field: _FSP_FILE_SYSTEM::MountPoint"]
6406 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, MountPoint) - 752usize];
6407 ["Offset of field: _FSP_FILE_SYSTEM::MountHandle"]
6408 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, MountHandle) - 760usize];
6409 ["Offset of field: _FSP_FILE_SYSTEM::DebugLog"]
6410 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DebugLog) - 768usize];
6411 ["Offset of field: _FSP_FILE_SYSTEM::OpGuardStrategy"]
6412 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, OpGuardStrategy) - 772usize];
6413 ["Offset of field: _FSP_FILE_SYSTEM::OpGuardLock"]
6414 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, OpGuardLock) - 776usize];
6415 ["Offset of field: _FSP_FILE_SYSTEM::UmFileContextIsUserContext2"]
6416 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UmFileContextIsUserContext2) - 784usize];
6417 ["Offset of field: _FSP_FILE_SYSTEM::UmFileContextIsFullContext"]
6418 [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UmFileContextIsFullContext) - 785usize];
6419};
6420impl Default for _FSP_FILE_SYSTEM {
6421 fn default() -> Self {
6422 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6423 unsafe {
6424 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6425 s.assume_init()
6426 }
6427 }
6428}
6429impl _FSP_FILE_SYSTEM {
6430 #[inline]
6431 pub fn UmNoReparsePointsDirCheck(&self) -> UINT16 {
6432 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
6433 }
6434 #[inline]
6435 pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT16) {
6436 unsafe {
6437 let val: u16 = ::std::mem::transmute(val);
6438 self._bitfield_1.set(0usize, 1u8, val as u64)
6439 }
6440 }
6441 #[inline]
6442 pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT16 {
6443 unsafe {
6444 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
6445 ::std::ptr::addr_of!((*this)._bitfield_1),
6446 0usize,
6447 1u8,
6448 ) as u16)
6449 }
6450 }
6451 #[inline]
6452 pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT16) {
6453 unsafe {
6454 let val: u16 = ::std::mem::transmute(val);
6455 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
6456 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6457 0usize,
6458 1u8,
6459 val as u64,
6460 )
6461 }
6462 }
6463 #[inline]
6464 pub fn UmReservedFlags(&self) -> UINT16 {
6465 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 14u8) as u16) }
6466 }
6467 #[inline]
6468 pub fn set_UmReservedFlags(&mut self, val: UINT16) {
6469 unsafe {
6470 let val: u16 = ::std::mem::transmute(val);
6471 self._bitfield_1.set(1usize, 14u8, val as u64)
6472 }
6473 }
6474 #[inline]
6475 pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT16 {
6476 unsafe {
6477 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
6478 ::std::ptr::addr_of!((*this)._bitfield_1),
6479 1usize,
6480 14u8,
6481 ) as u16)
6482 }
6483 }
6484 #[inline]
6485 pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT16) {
6486 unsafe {
6487 let val: u16 = ::std::mem::transmute(val);
6488 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
6489 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6490 1usize,
6491 14u8,
6492 val as u64,
6493 )
6494 }
6495 }
6496 #[inline]
6497 pub fn DispatcherStopping(&self) -> UINT16 {
6498 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
6499 }
6500 #[inline]
6501 pub fn set_DispatcherStopping(&mut self, val: UINT16) {
6502 unsafe {
6503 let val: u16 = ::std::mem::transmute(val);
6504 self._bitfield_1.set(15usize, 1u8, val as u64)
6505 }
6506 }
6507 #[inline]
6508 pub unsafe fn DispatcherStopping_raw(this: *const Self) -> UINT16 {
6509 unsafe {
6510 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
6511 ::std::ptr::addr_of!((*this)._bitfield_1),
6512 15usize,
6513 1u8,
6514 ) as u16)
6515 }
6516 }
6517 #[inline]
6518 pub unsafe fn set_DispatcherStopping_raw(this: *mut Self, val: UINT16) {
6519 unsafe {
6520 let val: u16 = ::std::mem::transmute(val);
6521 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
6522 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6523 15usize,
6524 1u8,
6525 val as u64,
6526 )
6527 }
6528 }
6529 #[inline]
6530 pub fn new_bitfield_1(
6531 UmNoReparsePointsDirCheck: UINT16,
6532 UmReservedFlags: UINT16,
6533 DispatcherStopping: UINT16,
6534 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
6535 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
6536 __bindgen_bitfield_unit.set(0usize, 1u8, {
6537 let UmNoReparsePointsDirCheck: u16 =
6538 unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
6539 UmNoReparsePointsDirCheck as u64
6540 });
6541 __bindgen_bitfield_unit.set(1usize, 14u8, {
6542 let UmReservedFlags: u16 = unsafe { ::std::mem::transmute(UmReservedFlags) };
6543 UmReservedFlags as u64
6544 });
6545 __bindgen_bitfield_unit.set(15usize, 1u8, {
6546 let DispatcherStopping: u16 = unsafe { ::std::mem::transmute(DispatcherStopping) };
6547 DispatcherStopping as u64
6548 });
6549 __bindgen_bitfield_unit
6550 }
6551}
6552#[repr(C)]
6553#[derive(Debug, Copy, Clone)]
6554pub struct _FSP_FILE_SYSTEM_OPERATION_CONTEXT {
6555 pub Request: *mut FSP_FSCTL_TRANSACT_REQ,
6556 pub Response: *mut FSP_FSCTL_TRANSACT_RSP,
6557}
6558#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6559const _: () = {
6560 ["Size of _FSP_FILE_SYSTEM_OPERATION_CONTEXT"]
6561 [::std::mem::size_of::<_FSP_FILE_SYSTEM_OPERATION_CONTEXT>() - 16usize];
6562 ["Alignment of _FSP_FILE_SYSTEM_OPERATION_CONTEXT"]
6563 [::std::mem::align_of::<_FSP_FILE_SYSTEM_OPERATION_CONTEXT>() - 8usize];
6564 ["Offset of field: _FSP_FILE_SYSTEM_OPERATION_CONTEXT::Request"]
6565 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_OPERATION_CONTEXT, Request) - 0usize];
6566 ["Offset of field: _FSP_FILE_SYSTEM_OPERATION_CONTEXT::Response"]
6567 [::std::mem::offset_of!(_FSP_FILE_SYSTEM_OPERATION_CONTEXT, Response) - 8usize];
6568};
6569impl Default for _FSP_FILE_SYSTEM_OPERATION_CONTEXT {
6570 fn default() -> Self {
6571 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6572 unsafe {
6573 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6574 s.assume_init()
6575 }
6576 }
6577}
6578pub type FSP_FILE_SYSTEM_OPERATION_CONTEXT = _FSP_FILE_SYSTEM_OPERATION_CONTEXT;
6579unsafe extern "C" {
6580 #[doc = " Check whether creating a file system object is possible.\n\n @param DevicePath\n The name of the control device for this file system. This must be either\n FSP_FSCTL_DISK_DEVICE_NAME or FSP_FSCTL_NET_DEVICE_NAME.\n @param MountPoint\n The mount point for the new file system. A value of NULL means that the file system should\n use the next available drive letter counting downwards from Z: as its mount point.\n @return\n STATUS_SUCCESS or error code."]
6581 pub fn FspFileSystemPreflight(DevicePath: PWSTR, MountPoint: PWSTR) -> NTSTATUS;
6582}
6583unsafe extern "C" {
6584 #[doc = " Create a file system object.\n\n @param DevicePath\n The name of the control device for this file system. This must be either\n FSP_FSCTL_DISK_DEVICE_NAME or FSP_FSCTL_NET_DEVICE_NAME.\n @param VolumeParams\n Volume parameters for the newly created file system.\n @param Interface\n A pointer to the operations that implement this user mode file system.\n @param PFileSystem [out]\n Pointer that will receive the file system object created on successful return from this\n call.\n @return\n STATUS_SUCCESS or error code."]
6585 pub fn FspFileSystemCreate(
6586 DevicePath: PWSTR,
6587 VolumeParams: *const FSP_FSCTL_VOLUME_PARAMS,
6588 Interface: *const FSP_FILE_SYSTEM_INTERFACE,
6589 PFileSystem: *mut *mut FSP_FILE_SYSTEM,
6590 ) -> NTSTATUS;
6591}
6592unsafe extern "C" {
6593 #[doc = " Delete a file system object.\n\n @param FileSystem\n The file system object."]
6594 pub fn FspFileSystemDelete(FileSystem: *mut FSP_FILE_SYSTEM);
6595}
6596unsafe extern "C" {
6597 #[doc = " Set the mount point for a file system.\n\n This function supports drive letters (X:) or directories as mount points:\n <ul>\n <li>Drive letters: Refer to the documentation of the DefineDosDevice Windows API\n to better understand how they are created.</li>\n <li>Directories: They can be used as mount points for disk based file systems. They cannot\n be used for network file systems. This is a limitation that Windows imposes on junctions.</li>\n </ul>\n\n @param FileSystem\n The file system object.\n @param MountPoint\n The mount point for the new file system. A value of NULL means that the file system should\n use the next available drive letter counting downwards from Z: as its mount point.\n @return\n STATUS_SUCCESS or error code."]
6598 pub fn FspFileSystemSetMountPoint(
6599 FileSystem: *mut FSP_FILE_SYSTEM,
6600 MountPoint: PWSTR,
6601 ) -> NTSTATUS;
6602}
6603unsafe extern "C" {
6604 pub fn FspFileSystemSetMountPointEx(
6605 FileSystem: *mut FSP_FILE_SYSTEM,
6606 MountPoint: PWSTR,
6607 SecurityDescriptor: PSECURITY_DESCRIPTOR,
6608 ) -> NTSTATUS;
6609}
6610unsafe extern "C" {
6611 #[doc = " Remove the mount point for a file system.\n\n @param FileSystem\n The file system object."]
6612 pub fn FspFileSystemRemoveMountPoint(FileSystem: *mut FSP_FILE_SYSTEM);
6613}
6614unsafe extern "C" {
6615 #[doc = " Start the file system dispatcher.\n\n The file system dispatcher is used to dispatch operations posted by the FSD to the user mode\n file system. Once this call starts executing the user mode file system will start receiving\n file system requests from the kernel.\n\n @param FileSystem\n The file system object.\n @param ThreadCount\n The number of threads for the file system dispatcher. A value of 0 will create a default\n number of threads and should be chosen in most cases.\n @return\n STATUS_SUCCESS or error code."]
6616 pub fn FspFileSystemStartDispatcher(
6617 FileSystem: *mut FSP_FILE_SYSTEM,
6618 ThreadCount: ULONG,
6619 ) -> NTSTATUS;
6620}
6621unsafe extern "C" {
6622 #[doc = " Stop the file system dispatcher.\n\n @param FileSystem\n The file system object."]
6623 pub fn FspFileSystemStopDispatcher(FileSystem: *mut FSP_FILE_SYSTEM);
6624}
6625unsafe extern "C" {
6626 #[doc = " Send a response to the FSD.\n\n This call is not required when the user mode file system performs synchronous processing of\n requests. It is possible however for the following FSP_FILE_SYSTEM_INTERFACE operations to be\n processed asynchronously:\n <ul>\n <li>Read</li>\n <li>Write</li>\n <li>ReadDirectory</li>\n </ul>\n\n These operations are allowed to return STATUS_PENDING to postpone sending a response to the FSD.\n At a later time the file system can use FspFileSystemSendResponse to send the response.\n\n @param FileSystem\n The file system object.\n @param Response\n The response buffer."]
6627 pub fn FspFileSystemSendResponse(
6628 FileSystem: *mut FSP_FILE_SYSTEM,
6629 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6630 );
6631}
6632unsafe extern "C" {
6633 #[doc = " Begin notifying Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n This operation blocks concurrent file rename operations. File rename\n operations may interfere with file notification, because a file being\n notified may also be concurrently renamed. After all file change\n notifications have been issued, you must make sure to call\n FspFileSystemNotifyEnd to allow file rename operations to proceed.\n\n @param FileSystem\n The file system object.\n @return\n STATUS_SUCCESS or error code. The error code STATUS_CANT_WAIT means that\n a file rename operation is currently in progress and the operation must be\n retried at a later time."]
6634 pub fn FspFileSystemNotifyBegin(FileSystem: *mut FSP_FILE_SYSTEM, Timeout: ULONG) -> NTSTATUS;
6635}
6636unsafe extern "C" {
6637 #[doc = " End notifying Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n This operation allows any blocked file rename operations to proceed.\n\n @param FileSystem\n The file system object.\n @return\n STATUS_SUCCESS or error code."]
6638 pub fn FspFileSystemNotifyEnd(FileSystem: *mut FSP_FILE_SYSTEM) -> NTSTATUS;
6639}
6640unsafe extern "C" {
6641 #[doc = " Notify Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n Note that FspFileSystemNotify requires file names to be normalized. A\n normalized file name is one that contains the correct case of all characters\n in the file name.\n\n For case-sensitive file systems all file names are normalized by definition.\n For case-insensitive file systems that implement file name normalization,\n a normalized file name is the one that the file system specifies in the\n response to Create or Open (see also FspFileSystemGetOpenFileInfo). For\n case-insensitive file systems that do not implement file name normalization\n a normalized file name is the upper case version of the file name used\n to open the file.\n\n @param FileSystem\n The file system object.\n @param NotifyInfo\n Buffer containing information about file changes.\n @param Size\n Size of buffer.\n @return\n STATUS_SUCCESS or error code."]
6642 pub fn FspFileSystemNotify(
6643 FileSystem: *mut FSP_FILE_SYSTEM,
6644 NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
6645 Size: SIZE_T,
6646 ) -> NTSTATUS;
6647}
6648unsafe extern "C" {
6649 #[doc = " Get the current operation context.\n\n This function may be used only when servicing one of the FSP_FILE_SYSTEM_INTERFACE operations.\n The current operation context is stored in thread local storage. It allows access to the\n Request and Response associated with this operation.\n\n @return\n The current operation context."]
6650 pub fn FspFileSystemGetOperationContext() -> *mut FSP_FILE_SYSTEM_OPERATION_CONTEXT;
6651}
6652unsafe extern "C" {
6653 pub fn FspFileSystemMountPointF(FileSystem: *mut FSP_FILE_SYSTEM) -> PWSTR;
6654}
6655unsafe extern "C" {
6656 pub fn FspFileSystemEnterOperationF(
6657 FileSystem: *mut FSP_FILE_SYSTEM,
6658 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6659 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6660 ) -> NTSTATUS;
6661}
6662unsafe extern "C" {
6663 pub fn FspFileSystemLeaveOperationF(
6664 FileSystem: *mut FSP_FILE_SYSTEM,
6665 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6666 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6667 ) -> NTSTATUS;
6668}
6669unsafe extern "C" {
6670 pub fn FspFileSystemSetOperationGuardF(
6671 FileSystem: *mut FSP_FILE_SYSTEM,
6672 EnterOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
6673 LeaveOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
6674 );
6675}
6676unsafe extern "C" {
6677 pub fn FspFileSystemSetOperationGuardStrategyF(
6678 FileSystem: *mut FSP_FILE_SYSTEM,
6679 GuardStrategy: FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY,
6680 );
6681}
6682unsafe extern "C" {
6683 pub fn FspFileSystemSetOperationF(
6684 FileSystem: *mut FSP_FILE_SYSTEM,
6685 Index: ULONG,
6686 Operation: FSP_FILE_SYSTEM_OPERATION,
6687 );
6688}
6689unsafe extern "C" {
6690 pub fn FspFileSystemGetDispatcherResultF(
6691 FileSystem: *mut FSP_FILE_SYSTEM,
6692 PDispatcherResult: *mut NTSTATUS,
6693 );
6694}
6695unsafe extern "C" {
6696 pub fn FspFileSystemSetDispatcherResultF(
6697 FileSystem: *mut FSP_FILE_SYSTEM,
6698 DispatcherResult: NTSTATUS,
6699 );
6700}
6701unsafe extern "C" {
6702 pub fn FspFileSystemSetDebugLogF(FileSystem: *mut FSP_FILE_SYSTEM, DebugLog: UINT32);
6703}
6704unsafe extern "C" {
6705 pub fn FspFileSystemIsOperationCaseSensitiveF() -> BOOLEAN;
6706}
6707unsafe extern "C" {
6708 pub fn FspFileSystemOperationProcessIdF() -> UINT32;
6709}
6710unsafe extern "C" {
6711 pub fn FspFileSystemOpEnter(
6712 FileSystem: *mut FSP_FILE_SYSTEM,
6713 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6714 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6715 ) -> NTSTATUS;
6716}
6717unsafe extern "C" {
6718 pub fn FspFileSystemOpLeave(
6719 FileSystem: *mut FSP_FILE_SYSTEM,
6720 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6721 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6722 ) -> NTSTATUS;
6723}
6724unsafe extern "C" {
6725 pub fn FspFileSystemOpCreate(
6726 FileSystem: *mut FSP_FILE_SYSTEM,
6727 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6728 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6729 ) -> NTSTATUS;
6730}
6731unsafe extern "C" {
6732 pub fn FspFileSystemOpOverwrite(
6733 FileSystem: *mut FSP_FILE_SYSTEM,
6734 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6735 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6736 ) -> NTSTATUS;
6737}
6738unsafe extern "C" {
6739 pub fn FspFileSystemOpCleanup(
6740 FileSystem: *mut FSP_FILE_SYSTEM,
6741 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6742 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6743 ) -> NTSTATUS;
6744}
6745unsafe extern "C" {
6746 pub fn FspFileSystemOpClose(
6747 FileSystem: *mut FSP_FILE_SYSTEM,
6748 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6749 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6750 ) -> NTSTATUS;
6751}
6752unsafe extern "C" {
6753 pub fn FspFileSystemOpRead(
6754 FileSystem: *mut FSP_FILE_SYSTEM,
6755 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6756 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6757 ) -> NTSTATUS;
6758}
6759unsafe extern "C" {
6760 pub fn FspFileSystemOpWrite(
6761 FileSystem: *mut FSP_FILE_SYSTEM,
6762 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6763 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6764 ) -> NTSTATUS;
6765}
6766unsafe extern "C" {
6767 pub fn FspFileSystemOpQueryInformation(
6768 FileSystem: *mut FSP_FILE_SYSTEM,
6769 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6770 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6771 ) -> NTSTATUS;
6772}
6773unsafe extern "C" {
6774 pub fn FspFileSystemOpSetInformation(
6775 FileSystem: *mut FSP_FILE_SYSTEM,
6776 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6777 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6778 ) -> NTSTATUS;
6779}
6780unsafe extern "C" {
6781 pub fn FspFileSystemOpQueryEa(
6782 FileSystem: *mut FSP_FILE_SYSTEM,
6783 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6784 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6785 ) -> NTSTATUS;
6786}
6787unsafe extern "C" {
6788 pub fn FspFileSystemOpSetEa(
6789 FileSystem: *mut FSP_FILE_SYSTEM,
6790 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6791 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6792 ) -> NTSTATUS;
6793}
6794unsafe extern "C" {
6795 pub fn FspFileSystemOpFlushBuffers(
6796 FileSystem: *mut FSP_FILE_SYSTEM,
6797 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6798 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6799 ) -> NTSTATUS;
6800}
6801unsafe extern "C" {
6802 pub fn FspFileSystemOpQueryVolumeInformation(
6803 FileSystem: *mut FSP_FILE_SYSTEM,
6804 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6805 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6806 ) -> NTSTATUS;
6807}
6808unsafe extern "C" {
6809 pub fn FspFileSystemOpSetVolumeInformation(
6810 FileSystem: *mut FSP_FILE_SYSTEM,
6811 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6812 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6813 ) -> NTSTATUS;
6814}
6815unsafe extern "C" {
6816 pub fn FspFileSystemOpQueryDirectory(
6817 FileSystem: *mut FSP_FILE_SYSTEM,
6818 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6819 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6820 ) -> NTSTATUS;
6821}
6822unsafe extern "C" {
6823 pub fn FspFileSystemOpFileSystemControl(
6824 FileSystem: *mut FSP_FILE_SYSTEM,
6825 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6826 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6827 ) -> NTSTATUS;
6828}
6829unsafe extern "C" {
6830 pub fn FspFileSystemOpDeviceControl(
6831 FileSystem: *mut FSP_FILE_SYSTEM,
6832 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6833 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6834 ) -> NTSTATUS;
6835}
6836unsafe extern "C" {
6837 pub fn FspFileSystemOpQuerySecurity(
6838 FileSystem: *mut FSP_FILE_SYSTEM,
6839 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6840 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6841 ) -> NTSTATUS;
6842}
6843unsafe extern "C" {
6844 pub fn FspFileSystemOpSetSecurity(
6845 FileSystem: *mut FSP_FILE_SYSTEM,
6846 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6847 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6848 ) -> NTSTATUS;
6849}
6850unsafe extern "C" {
6851 pub fn FspFileSystemOpQueryStreamInformation(
6852 FileSystem: *mut FSP_FILE_SYSTEM,
6853 Request: *mut FSP_FSCTL_TRANSACT_REQ,
6854 Response: *mut FSP_FSCTL_TRANSACT_RSP,
6855 ) -> NTSTATUS;
6856}
6857unsafe extern "C" {
6858 #[doc = " Add directory information to a buffer.\n\n This is a helper for implementing the ReadDirectory operation.\n\n @param DirInfo\n The directory information to add. A value of NULL acts as an EOF marker for a ReadDirectory\n operation.\n @param Buffer\n Pointer to a buffer that will receive the results of the read operation. This should contain\n the same value passed to the ReadDirectory Buffer parameter.\n @param Length\n Length of data to read. This should contain the same value passed to the ReadDirectory\n Length parameter.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes read. This should\n contain the same value passed to the ReadDirectory PBytesTransferred parameter.\n FspFileSystemAddDirInfo uses the value pointed by this parameter to track how much of the\n buffer has been used so far.\n @return\n TRUE if the directory information was added, FALSE if there was not enough space to add it.\n @see\n ReadDirectory"]
6859 pub fn FspFileSystemAddDirInfo(
6860 DirInfo: *mut FSP_FSCTL_DIR_INFO,
6861 Buffer: PVOID,
6862 Length: ULONG,
6863 PBytesTransferred: PULONG,
6864 ) -> BOOLEAN;
6865}
6866unsafe extern "C" {
6867 #[doc = " Find reparse point in file name.\n\n Given a file name this function returns an index to the first path component that is a reparse\n point. The function will call the supplied GetReparsePointByName function for every path\n component until it finds a reparse point or the whole path is processed.\n\n This is a helper for implementing the GetSecurityByName operation in file systems\n that support reparse points.\n\n @param FileSystem\n The file system object.\n @param GetReparsePointByName\n Pointer to function that can retrieve reparse point information by name. The\n FspFileSystemFindReparsePoint will call this function with the Buffer and PSize\n arguments set to NULL. The function should return STATUS_SUCCESS if the passed\n FileName is a reparse point or STATUS_NOT_A_REPARSE_POINT (or other error code)\n otherwise.\n @param Context\n User context to supply to GetReparsePointByName.\n @param FileName\n The name of the file or directory.\n @param PReparsePointIndex\n Pointer to a memory location that will receive the index of the first reparse point\n within FileName. A value is only placed in this memory location if the function returns\n TRUE. May be NULL.\n @return\n TRUE if a reparse point was found, FALSE otherwise.\n @see\n GetSecurityByName"]
6868 pub fn FspFileSystemFindReparsePoint(
6869 FileSystem: *mut FSP_FILE_SYSTEM,
6870 GetReparsePointByName: ::std::option::Option<
6871 unsafe extern "C" fn(
6872 FileSystem: *mut FSP_FILE_SYSTEM,
6873 Context: PVOID,
6874 FileName: PWSTR,
6875 IsDirectory: BOOLEAN,
6876 Buffer: PVOID,
6877 PSize: PSIZE_T,
6878 ) -> NTSTATUS,
6879 >,
6880 Context: PVOID,
6881 FileName: PWSTR,
6882 PReparsePointIndex: PUINT32,
6883 ) -> BOOLEAN;
6884}
6885unsafe extern "C" {
6886 #[doc = " Resolve reparse points.\n\n Given a file name (and an index where to start resolving) this function will attempt to\n resolve as many reparse points as possible. The function will call the supplied\n GetReparsePointByName function for every path component until it resolves the reparse points\n or the whole path is processed.\n\n This is a helper for implementing the ResolveReparsePoints operation in file systems\n that support reparse points.\n\n @param FileSystem\n The file system object.\n @param GetReparsePointByName\n Pointer to function that can retrieve reparse point information by name. The function\n should return STATUS_SUCCESS if the passed FileName is a reparse point or\n STATUS_NOT_A_REPARSE_POINT (or other error code) otherwise.\n @param Context\n User context to supply to GetReparsePointByName.\n @param FileName\n The name of the file or directory to have its reparse points resolved.\n @param ReparsePointIndex\n The index of the first reparse point within FileName.\n @param ResolveLastPathComponent\n If FALSE, the last path component of FileName should not be resolved, even\n if it is a reparse point that can be resolved. If TRUE, all path components\n should be resolved if possible.\n @param PIoStatus\n Pointer to storage that will receive the status to return to the FSD. When\n this function succeeds it must set PIoStatus->Status to STATUS_REPARSE and\n PIoStatus->Information to either IO_REPARSE or the reparse tag.\n @param Buffer\n Pointer to a buffer that will receive the resolved file name (IO_REPARSE) or\n reparse data (reparse tag). If the function returns a file name, it should\n not be NULL terminated.\n @param PSize [in,out]\n Pointer to the buffer size. On input it contains the size of the buffer.\n On output it will contain the actual size of data copied.\n @return\n STATUS_REPARSE or error code.\n @see\n ResolveReparsePoints"]
6887 pub fn FspFileSystemResolveReparsePoints(
6888 FileSystem: *mut FSP_FILE_SYSTEM,
6889 GetReparsePointByName: ::std::option::Option<
6890 unsafe extern "C" fn(
6891 FileSystem: *mut FSP_FILE_SYSTEM,
6892 Context: PVOID,
6893 FileName: PWSTR,
6894 IsDirectory: BOOLEAN,
6895 Buffer: PVOID,
6896 PSize: PSIZE_T,
6897 ) -> NTSTATUS,
6898 >,
6899 Context: PVOID,
6900 FileName: PWSTR,
6901 ReparsePointIndex: UINT32,
6902 ResolveLastPathComponent: BOOLEAN,
6903 PIoStatus: PIO_STATUS_BLOCK,
6904 Buffer: PVOID,
6905 PSize: PSIZE_T,
6906 ) -> NTSTATUS;
6907}
6908unsafe extern "C" {
6909 #[doc = " Test whether reparse data can be replaced.\n\n This is a helper for implementing the SetReparsePoint/DeleteReparsePoint operation\n in file systems that support reparse points.\n\n @param CurrentReparseData\n Pointer to the current reparse data.\n @param CurrentReparseDataSize\n Pointer to the current reparse data size.\n @param ReplaceReparseData\n Pointer to the replacement reparse data.\n @param ReplaceReparseDataSize\n Pointer to the replacement reparse data size.\n @return\n STATUS_SUCCESS or error code.\n @see\n SetReparsePoint\n DeleteReparsePoint"]
6910 pub fn FspFileSystemCanReplaceReparsePoint(
6911 CurrentReparseData: PVOID,
6912 CurrentReparseDataSize: SIZE_T,
6913 ReplaceReparseData: PVOID,
6914 ReplaceReparseDataSize: SIZE_T,
6915 ) -> NTSTATUS;
6916}
6917unsafe extern "C" {
6918 #[doc = " Add named stream information to a buffer.\n\n This is a helper for implementing the GetStreamInfo operation.\n\n @param StreamInfo\n The stream information to add. A value of NULL acts as an EOF marker for a GetStreamInfo\n operation.\n @param Buffer\n Pointer to a buffer that will receive the stream information. This should contain\n the same value passed to the GetStreamInfo Buffer parameter.\n @param Length\n Length of buffer. This should contain the same value passed to the GetStreamInfo\n Length parameter.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes stored. This should\n contain the same value passed to the GetStreamInfo PBytesTransferred parameter.\n @return\n TRUE if the stream information was added, FALSE if there was not enough space to add it.\n @see\n GetStreamInfo"]
6919 pub fn FspFileSystemAddStreamInfo(
6920 StreamInfo: *mut FSP_FSCTL_STREAM_INFO,
6921 Buffer: PVOID,
6922 Length: ULONG,
6923 PBytesTransferred: PULONG,
6924 ) -> BOOLEAN;
6925}
6926unsafe extern "C" {
6927 #[doc = " Enumerate extended attributes in a buffer.\n\n This is a helper for implementing the CreateEx and SetEa operations in file systems\n that support extended attributes.\n\n @param FileSystem\n The file system object.\n @param EnumerateEa\n Pointer to function that receives a single extended attribute. The function\n should return STATUS_SUCCESS or an error code if unsuccessful.\n @param Context\n User context to supply to EnumEa.\n @param Ea\n Extended attributes buffer.\n @param EaLength\n Extended attributes buffer length.\n @return\n STATUS_SUCCESS or error code from EnumerateEa."]
6928 pub fn FspFileSystemEnumerateEa(
6929 FileSystem: *mut FSP_FILE_SYSTEM,
6930 EnumerateEa: ::std::option::Option<
6931 unsafe extern "C" fn(
6932 FileSystem: *mut FSP_FILE_SYSTEM,
6933 Context: PVOID,
6934 SingleEa: PFILE_FULL_EA_INFORMATION,
6935 ) -> NTSTATUS,
6936 >,
6937 Context: PVOID,
6938 Ea: PFILE_FULL_EA_INFORMATION,
6939 EaLength: ULONG,
6940 ) -> NTSTATUS;
6941}
6942unsafe extern "C" {
6943 #[doc = " Add extended attribute to a buffer.\n\n This is a helper for implementing the GetEa operation.\n\n @param SingleEa\n The extended attribute to add. A value of NULL acts as an EOF marker for a GetEa\n operation.\n @param Ea\n Pointer to a buffer that will receive the extended attribute. This should contain\n the same value passed to the GetEa Ea parameter.\n @param EaLength\n Length of buffer. This should contain the same value passed to the GetEa\n EaLength parameter.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes stored. This should\n contain the same value passed to the GetEa PBytesTransferred parameter.\n @return\n TRUE if the extended attribute was added, FALSE if there was not enough space to add it.\n @see\n GetEa"]
6944 pub fn FspFileSystemAddEa(
6945 SingleEa: PFILE_FULL_EA_INFORMATION,
6946 Ea: PFILE_FULL_EA_INFORMATION,
6947 EaLength: ULONG,
6948 PBytesTransferred: PULONG,
6949 ) -> BOOLEAN;
6950}
6951unsafe extern "C" {
6952 #[doc = " Add notify information to a buffer.\n\n This is a helper for filling a buffer to use with FspFileSystemNotify.\n\n @param NotifyInfo\n The notify information to add.\n @param Buffer\n Pointer to a buffer that will receive the notify information.\n @param Length\n Length of buffer.\n @param PBytesTransferred [out]\n Pointer to a memory location that will receive the actual number of bytes stored. This should\n be initialized to 0 prior to the first call to FspFileSystemAddNotifyInfo for a particular\n buffer.\n @return\n TRUE if the notify information was added, FALSE if there was not enough space to add it.\n @see\n FspFileSystemNotify"]
6953 pub fn FspFileSystemAddNotifyInfo(
6954 NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
6955 Buffer: PVOID,
6956 Length: ULONG,
6957 PBytesTransferred: PULONG,
6958 ) -> BOOLEAN;
6959}
6960unsafe extern "C" {
6961 #[doc = " Stop a file system service, if any.\n\n This is a helper for implementing the DispatcherStopped operation, but only for file systems\n that use the FspService infrastructure.\n\n @param FileSystem\n The file system object.\n @param Normally\n TRUE if the file system is being stopped via FspFileSystemStopDispatcher.\n FALSE if the file system is being stopped because of another reason such\n as driver unload/uninstall.\n @see\n DispatcherStopped"]
6962 pub fn FspFileSystemStopServiceIfNecessary(FileSystem: *mut FSP_FILE_SYSTEM, Normally: BOOLEAN);
6963}
6964unsafe extern "C" {
6965 pub fn FspFileSystemAcquireDirectoryBufferEx(
6966 PDirBuffer: *mut PVOID,
6967 Reset: BOOLEAN,
6968 CapacityHint: ULONG,
6969 PResult: PNTSTATUS,
6970 ) -> BOOLEAN;
6971}
6972unsafe extern "C" {
6973 pub fn FspFileSystemAcquireDirectoryBuffer(
6974 PDirBuffer: *mut PVOID,
6975 Reset: BOOLEAN,
6976 PResult: PNTSTATUS,
6977 ) -> BOOLEAN;
6978}
6979unsafe extern "C" {
6980 pub fn FspFileSystemFillDirectoryBuffer(
6981 PDirBuffer: *mut PVOID,
6982 DirInfo: *mut FSP_FSCTL_DIR_INFO,
6983 PResult: PNTSTATUS,
6984 ) -> BOOLEAN;
6985}
6986unsafe extern "C" {
6987 pub fn FspFileSystemReleaseDirectoryBuffer(PDirBuffer: *mut PVOID);
6988}
6989unsafe extern "C" {
6990 pub fn FspFileSystemReadDirectoryBuffer(
6991 PDirBuffer: *mut PVOID,
6992 Marker: PWSTR,
6993 Buffer: PVOID,
6994 Length: ULONG,
6995 PBytesTransferred: PULONG,
6996 );
6997}
6998unsafe extern "C" {
6999 pub fn FspFileSystemDeleteDirectoryBuffer(PDirBuffer: *mut PVOID);
7000}
7001unsafe extern "C" {
7002 pub fn FspGetFileGenericMapping() -> PGENERIC_MAPPING;
7003}
7004unsafe extern "C" {
7005 pub fn FspAccessCheckEx(
7006 FileSystem: *mut FSP_FILE_SYSTEM,
7007 Request: *mut FSP_FSCTL_TRANSACT_REQ,
7008 CheckParentOrMain: BOOLEAN,
7009 AllowTraverseCheck: BOOLEAN,
7010 DesiredAccess: UINT32,
7011 PGrantedAccess: PUINT32,
7012 PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
7013 ) -> NTSTATUS;
7014}
7015unsafe extern "C" {
7016 pub fn FspCreateSecurityDescriptor(
7017 FileSystem: *mut FSP_FILE_SYSTEM,
7018 Request: *mut FSP_FSCTL_TRANSACT_REQ,
7019 ParentDescriptor: PSECURITY_DESCRIPTOR,
7020 PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
7021 ) -> NTSTATUS;
7022}
7023unsafe extern "C" {
7024 #[doc = " Modify security descriptor.\n\n This is a helper for implementing the SetSecurity operation.\n\n @param InputDescriptor\n The input security descriptor to be modified.\n @param SecurityInformation\n Describes what parts of the InputDescriptor should be modified. This should contain\n the same value passed to the SetSecurity SecurityInformation parameter.\n @param ModificationDescriptor\n Describes the modifications to apply to the InputDescriptor. This should contain\n the same value passed to the SetSecurity ModificationDescriptor parameter.\n @param PSecurityDescriptor [out]\n Pointer to a memory location that will receive the resulting security descriptor.\n This security descriptor can be later freed using FspDeleteSecurityDescriptor.\n @return\n STATUS_SUCCESS or error code.\n @see\n SetSecurity\n FspDeleteSecurityDescriptor"]
7025 pub fn FspSetSecurityDescriptor(
7026 InputDescriptor: PSECURITY_DESCRIPTOR,
7027 SecurityInformation: SECURITY_INFORMATION,
7028 ModificationDescriptor: PSECURITY_DESCRIPTOR,
7029 PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
7030 ) -> NTSTATUS;
7031}
7032unsafe extern "C" {
7033 #[doc = " Delete security descriptor.\n\n This is a helper for implementing the SetSecurity operation.\n\n @param SecurityDescriptor\n The security descriptor to be deleted.\n @param CreateFunc\n Function used to create the security descriptor. This parameter should be\n set to FspSetSecurityDescriptor for the public API.\n @return\n STATUS_SUCCESS or error code.\n @see\n SetSecurity\n FspSetSecurityDescriptor"]
7034 pub fn FspDeleteSecurityDescriptor(
7035 SecurityDescriptor: PSECURITY_DESCRIPTOR,
7036 CreateFunc: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
7037 );
7038}
7039unsafe extern "C" {
7040 pub fn FspPosixSetUidMap(Uid: *mut UINT32, Sid: *mut PSID, Count: ULONG) -> NTSTATUS;
7041}
7042unsafe extern "C" {
7043 pub fn FspPosixMapUidToSid(Uid: UINT32, PSid: *mut PSID) -> NTSTATUS;
7044}
7045unsafe extern "C" {
7046 pub fn FspPosixMapSidToUid(Sid: PSID, PUid: PUINT32) -> NTSTATUS;
7047}
7048unsafe extern "C" {
7049 pub fn FspDeleteSid(
7050 Sid: PSID,
7051 CreateFunc: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
7052 );
7053}
7054unsafe extern "C" {
7055 pub fn FspPosixMapPermissionsToSecurityDescriptor(
7056 Uid: UINT32,
7057 Gid: UINT32,
7058 Mode: UINT32,
7059 PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
7060 ) -> NTSTATUS;
7061}
7062unsafe extern "C" {
7063 pub fn FspPosixMergePermissionsToSecurityDescriptor(
7064 Uid: UINT32,
7065 Gid: UINT32,
7066 Mode: UINT32,
7067 ExistingSecurityDescriptor: PSECURITY_DESCRIPTOR,
7068 PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
7069 ) -> NTSTATUS;
7070}
7071unsafe extern "C" {
7072 pub fn FspPosixMapSecurityDescriptorToPermissions(
7073 SecurityDescriptor: PSECURITY_DESCRIPTOR,
7074 PUid: PUINT32,
7075 PGid: PUINT32,
7076 PMode: PUINT32,
7077 ) -> NTSTATUS;
7078}
7079unsafe extern "C" {
7080 pub fn FspPosixMapWindowsToPosixPathEx(
7081 WindowsPath: PWSTR,
7082 PPosixPath: *mut *mut ::std::os::raw::c_char,
7083 Translate: BOOLEAN,
7084 ) -> NTSTATUS;
7085}
7086unsafe extern "C" {
7087 pub fn FspPosixMapPosixToWindowsPathEx(
7088 PosixPath: *const ::std::os::raw::c_char,
7089 PWindowsPath: *mut PWSTR,
7090 Translate: BOOLEAN,
7091 ) -> NTSTATUS;
7092}
7093unsafe extern "C" {
7094 pub fn FspPosixDeletePath(Path: *mut ::std::os::raw::c_void);
7095}
7096unsafe extern "C" {
7097 pub fn FspPosixEncodeWindowsPath(WindowsPath: PWSTR, Size: ULONG);
7098}
7099unsafe extern "C" {
7100 pub fn FspPosixDecodeWindowsPath(WindowsPath: PWSTR, Size: ULONG);
7101}
7102unsafe extern "C" {
7103 pub fn FspPathPrefix(Path: PWSTR, PPrefix: *mut PWSTR, PRemain: *mut PWSTR, Root: PWSTR);
7104}
7105unsafe extern "C" {
7106 pub fn FspPathSuffix(Path: PWSTR, PRemain: *mut PWSTR, PSuffix: *mut PWSTR, Root: PWSTR);
7107}
7108unsafe extern "C" {
7109 pub fn FspPathCombine(Prefix: PWSTR, Suffix: PWSTR);
7110}
7111#[doc = " @group Service Framework\n\n User mode file systems typically are run as Windows services. WinFsp provides an API to make\n the creation of Windows services easier. This API is provided for convenience and is not\n necessary to expose a user mode file system to Windows."]
7112pub type FSP_SERVICE = _FSP_SERVICE;
7113pub type FSP_SERVICE_START = ::std::option::Option<
7114 unsafe extern "C" fn(arg1: *mut FSP_SERVICE, arg2: ULONG, arg3: *mut PWSTR) -> NTSTATUS,
7115>;
7116pub type FSP_SERVICE_STOP =
7117 ::std::option::Option<unsafe extern "C" fn(arg1: *mut FSP_SERVICE) -> NTSTATUS>;
7118pub type FSP_SERVICE_CONTROL = ::std::option::Option<
7119 unsafe extern "C" fn(arg1: *mut FSP_SERVICE, arg2: ULONG, arg3: ULONG, arg4: PVOID) -> NTSTATUS,
7120>;
7121#[repr(C)]
7122#[derive(Debug)]
7123pub struct _FSP_SERVICE {
7124 pub Version: UINT16,
7125 pub UserContext: PVOID,
7126 pub OnStart: FSP_SERVICE_START,
7127 pub OnStop: FSP_SERVICE_STOP,
7128 pub OnControl: FSP_SERVICE_CONTROL,
7129 pub AcceptControl: ULONG,
7130 pub ExitCode: ULONG,
7131 pub StatusHandle: SERVICE_STATUS_HANDLE,
7132 pub ServiceStatus: SERVICE_STATUS,
7133 pub ServiceStatusGuard: CRITICAL_SECTION,
7134 pub ServiceStopGuard: CRITICAL_SECTION,
7135 pub AllowConsoleMode: BOOLEAN,
7136 pub ServiceName: __IncompleteArrayField<WCHAR>,
7137}
7138#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7139const _: () = {
7140 ["Size of _FSP_SERVICE"][::std::mem::size_of::<_FSP_SERVICE>() - 176usize];
7141 ["Alignment of _FSP_SERVICE"][::std::mem::align_of::<_FSP_SERVICE>() - 8usize];
7142 ["Offset of field: _FSP_SERVICE::Version"]
7143 [::std::mem::offset_of!(_FSP_SERVICE, Version) - 0usize];
7144 ["Offset of field: _FSP_SERVICE::UserContext"]
7145 [::std::mem::offset_of!(_FSP_SERVICE, UserContext) - 8usize];
7146 ["Offset of field: _FSP_SERVICE::OnStart"]
7147 [::std::mem::offset_of!(_FSP_SERVICE, OnStart) - 16usize];
7148 ["Offset of field: _FSP_SERVICE::OnStop"]
7149 [::std::mem::offset_of!(_FSP_SERVICE, OnStop) - 24usize];
7150 ["Offset of field: _FSP_SERVICE::OnControl"]
7151 [::std::mem::offset_of!(_FSP_SERVICE, OnControl) - 32usize];
7152 ["Offset of field: _FSP_SERVICE::AcceptControl"]
7153 [::std::mem::offset_of!(_FSP_SERVICE, AcceptControl) - 40usize];
7154 ["Offset of field: _FSP_SERVICE::ExitCode"]
7155 [::std::mem::offset_of!(_FSP_SERVICE, ExitCode) - 44usize];
7156 ["Offset of field: _FSP_SERVICE::StatusHandle"]
7157 [::std::mem::offset_of!(_FSP_SERVICE, StatusHandle) - 48usize];
7158 ["Offset of field: _FSP_SERVICE::ServiceStatus"]
7159 [::std::mem::offset_of!(_FSP_SERVICE, ServiceStatus) - 56usize];
7160 ["Offset of field: _FSP_SERVICE::ServiceStatusGuard"]
7161 [::std::mem::offset_of!(_FSP_SERVICE, ServiceStatusGuard) - 88usize];
7162 ["Offset of field: _FSP_SERVICE::ServiceStopGuard"]
7163 [::std::mem::offset_of!(_FSP_SERVICE, ServiceStopGuard) - 128usize];
7164 ["Offset of field: _FSP_SERVICE::AllowConsoleMode"]
7165 [::std::mem::offset_of!(_FSP_SERVICE, AllowConsoleMode) - 168usize];
7166 ["Offset of field: _FSP_SERVICE::ServiceName"]
7167 [::std::mem::offset_of!(_FSP_SERVICE, ServiceName) - 170usize];
7168};
7169impl Default for _FSP_SERVICE {
7170 fn default() -> Self {
7171 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7172 unsafe {
7173 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7174 s.assume_init()
7175 }
7176 }
7177}
7178unsafe extern "C" {
7179 #[doc = " Run a service.\n\n This function wraps calls to FspServiceCreate, FspServiceLoop and FspServiceDelete to create,\n run and delete a service. It is intended to be used from a service's main/wmain function.\n\n This function runs a service with console mode allowed.\n\n @param ServiceName\n The name of the service.\n @param OnStart\n Function to call when the service starts.\n @param OnStop\n Function to call when the service stops.\n @param OnControl\n Function to call when the service receives a service control code.\n @return\n Service process exit code."]
7180 pub fn FspServiceRunEx(
7181 ServiceName: PWSTR,
7182 OnStart: FSP_SERVICE_START,
7183 OnStop: FSP_SERVICE_STOP,
7184 OnControl: FSP_SERVICE_CONTROL,
7185 UserContext: PVOID,
7186 ) -> ULONG;
7187}
7188unsafe extern "C" {
7189 #[doc = " Create a service object.\n\n @param ServiceName\n The name of the service.\n @param OnStart\n Function to call when the service starts.\n @param OnStop\n Function to call when the service stops.\n @param OnControl\n Function to call when the service receives a service control code.\n @param PService [out]\n Pointer that will receive the service object created on successful return from this\n call.\n @return\n STATUS_SUCCESS or error code."]
7190 pub fn FspServiceCreate(
7191 ServiceName: PWSTR,
7192 OnStart: FSP_SERVICE_START,
7193 OnStop: FSP_SERVICE_STOP,
7194 OnControl: FSP_SERVICE_CONTROL,
7195 PService: *mut *mut FSP_SERVICE,
7196 ) -> NTSTATUS;
7197}
7198unsafe extern "C" {
7199 #[doc = " Delete a service object.\n\n @param Service\n The service object."]
7200 pub fn FspServiceDelete(Service: *mut FSP_SERVICE);
7201}
7202unsafe extern "C" {
7203 #[doc = " Allow a service to run in console mode.\n\n A service that is run in console mode runs with a console attached and outside the control of\n the Service Control Manager. This is useful for debugging and testing a service during\n development.\n\n User mode file systems that wish to use the WinFsp Launcher functionality must also use this\n call. The WinFsp Launcher is a Windows service that can be configured to launch and manage\n multiple instances of a user mode file system.\n\n @param Service\n The service object."]
7204 pub fn FspServiceAllowConsoleMode(Service: *mut FSP_SERVICE);
7205}
7206unsafe extern "C" {
7207 #[doc = " Configure the control codes that a service accepts.\n\n This API should be used prior to Start operations.\n\n @param Service\n The service object.\n @param Control\n The control codes to accept. Note that the SERVICE_ACCEPT_PAUSE_CONTINUE code is silently\n ignored."]
7208 pub fn FspServiceAcceptControl(Service: *mut FSP_SERVICE, Control: ULONG);
7209}
7210unsafe extern "C" {
7211 #[doc = " Request additional time from the Service Control Manager.\n\n This API should be used during Start and Stop operations only.\n\n @param Service\n The service object.\n @param Time\n Additional time (in milliseconds)."]
7212 pub fn FspServiceRequestTime(Service: *mut FSP_SERVICE, Time: ULONG);
7213}
7214unsafe extern "C" {
7215 #[doc = " Set the service process exit code.\n\n @param Service\n The service object.\n @param ExitCode\n Service process exit code."]
7216 pub fn FspServiceSetExitCode(Service: *mut FSP_SERVICE, ExitCode: ULONG);
7217}
7218unsafe extern "C" {
7219 #[doc = " Get the service process exit code.\n\n @param Service\n The service object.\n @return\n Service process exit code."]
7220 pub fn FspServiceGetExitCode(Service: *mut FSP_SERVICE) -> ULONG;
7221}
7222unsafe extern "C" {
7223 #[doc = " Run a service main loop.\n\n This function starts and runs a service. It executes the Windows StartServiceCtrlDispatcher API\n to connect the service process to the Service Control Manager. If the Service Control Manager is\n not available (and console mode is allowed) it will enter console mode.\n\n This function should be called once per process.\n\n @param Service\n The service object.\n @return\n STATUS_SUCCESS or error code."]
7224 pub fn FspServiceLoop(Service: *mut FSP_SERVICE) -> NTSTATUS;
7225}
7226unsafe extern "C" {
7227 #[doc = " Stops a running service.\n\n Stopping a service usually happens when the Service Control Manager instructs the service to\n stop. In some situations (e.g. fatal errors) the service may wish to stop itself. It can do so\n in a clean manner by calling this function.\n\n @param Service\n The service object.\n @return\n STATUS_SUCCESS or error code."]
7228 pub fn FspServiceStop(Service: *mut FSP_SERVICE);
7229}
7230unsafe extern "C" {
7231 #[doc = " Determine if the current process is running in user interactive mode.\n\n @return\n TRUE if the process is running in running user interactive mode."]
7232 pub fn FspServiceIsInteractive() -> BOOLEAN;
7233}
7234unsafe extern "C" {
7235 #[doc = " Check if the supplied token is from the service context.\n\n @param Token\n Token to check. Pass NULL to check the current process token.\n @param PIsLocalSystem\n Pointer to a boolean that will receive a TRUE value if the token belongs to LocalSystem\n and FALSE otherwise. May be NULL.\n @return\n STATUS_SUCCESS if the token is from the service context. STATUS_ACCESS_DENIED if it is not.\n Other error codes are possible."]
7236 pub fn FspServiceContextCheck(Token: HANDLE, PIsLocalSystem: PBOOLEAN) -> NTSTATUS;
7237}
7238unsafe extern "C" {
7239 #[doc = " Log a service message.\n\n This function can be used to log an arbitrary message to the Windows Event Log or to the current\n console if running in user interactive mode.\n\n @param Type\n One of EVENTLOG_INFORMATION_TYPE, EVENTLOG_WARNING_TYPE, EVENTLOG_ERROR_TYPE.\n @param Format\n Format specification. This function uses the Windows wsprintf API for formatting. Refer to\n that API's documentation for details on the format specification."]
7240 pub fn FspServiceLog(Type: ULONG, Format: PWSTR, ...);
7241}
7242unsafe extern "C" {
7243 pub fn FspServiceLogV(Type: ULONG, Format: PWSTR, ap: va_list);
7244}
7245unsafe extern "C" {
7246 pub fn FspNtStatusFromWin32(Error: DWORD) -> NTSTATUS;
7247}
7248unsafe extern "C" {
7249 pub fn FspWin32FromNtStatus(Status: NTSTATUS) -> DWORD;
7250}
7251unsafe extern "C" {
7252 pub fn FspEventLog(Type: ULONG, Format: PWSTR, ...);
7253}
7254unsafe extern "C" {
7255 pub fn FspEventLogV(Type: ULONG, Format: PWSTR, ap: va_list);
7256}
7257unsafe extern "C" {
7258 pub fn FspDebugLogSetHandle(Handle: HANDLE);
7259}
7260unsafe extern "C" {
7261 pub fn FspDebugLog(Format: *const ::std::os::raw::c_char, ...);
7262}
7263unsafe extern "C" {
7264 pub fn FspDebugLogSD(
7265 Format: *const ::std::os::raw::c_char,
7266 SecurityDescriptor: PSECURITY_DESCRIPTOR,
7267 );
7268}
7269unsafe extern "C" {
7270 pub fn FspDebugLogSid(format: *const ::std::os::raw::c_char, Sid: PSID);
7271}
7272unsafe extern "C" {
7273 pub fn FspDebugLogFT(Format: *const ::std::os::raw::c_char, FileTime: PFILETIME);
7274}
7275unsafe extern "C" {
7276 pub fn FspDebugLogRequest(Request: *mut FSP_FSCTL_TRANSACT_REQ);
7277}
7278unsafe extern "C" {
7279 pub fn FspDebugLogResponse(Response: *mut FSP_FSCTL_TRANSACT_RSP);
7280}
7281unsafe extern "C" {
7282 pub fn FspCallNamedPipeSecurely(
7283 PipeName: PWSTR,
7284 InBuffer: PVOID,
7285 InBufferSize: ULONG,
7286 OutBuffer: PVOID,
7287 OutBufferSize: ULONG,
7288 PBytesTransferred: PULONG,
7289 Timeout: ULONG,
7290 Sid: PSID,
7291 ) -> NTSTATUS;
7292}
7293unsafe extern "C" {
7294 pub fn FspCallNamedPipeSecurelyEx(
7295 PipeName: PWSTR,
7296 InBuffer: PVOID,
7297 InBufferSize: ULONG,
7298 OutBuffer: PVOID,
7299 OutBufferSize: ULONG,
7300 PBytesTransferred: PULONG,
7301 Timeout: ULONG,
7302 AllowImpersonation: BOOLEAN,
7303 Sid: PSID,
7304 ) -> NTSTATUS;
7305}
7306unsafe extern "C" {
7307 pub fn FspVersion(PVersion: PUINT32) -> NTSTATUS;
7308}
7309unsafe extern "C" {
7310 pub fn FspSxsIdent() -> PWSTR;
7311}
7312pub const FspLaunchCmdStart: _bindgen_ty_7 = 83;
7313pub const FspLaunchCmdStartWithSecret: _bindgen_ty_7 = 88;
7314pub const FspLaunchCmdStop: _bindgen_ty_7 = 84;
7315pub const FspLaunchCmdGetInfo: _bindgen_ty_7 = 73;
7316pub const FspLaunchCmdGetNameList: _bindgen_ty_7 = 76;
7317pub const FspLaunchCmdDefineDosDevice: _bindgen_ty_7 = 68;
7318pub const FspLaunchCmdQuit: _bindgen_ty_7 = 81;
7319pub type _bindgen_ty_7 = ::std::os::raw::c_int;
7320pub const FspLaunchCmdSuccess: _bindgen_ty_8 = 36;
7321pub const FspLaunchCmdFailure: _bindgen_ty_8 = 33;
7322pub type _bindgen_ty_8 = ::std::os::raw::c_int;
7323unsafe extern "C" {
7324 #[doc = " @group Launch Control\n/\n/**\n Call launcher pipe.\n\n This function is used to send a command to the launcher and receive a response.\n\n @param Command\n Launcher command to send. For example, the 'L' launcher command instructs\n the launcher to list all running service instances.\n @param Argc\n Command argument count. May be 0.\n @param Argv\n Command argument array. May be NULL.\n @param Argl\n Command argument length array. May be NULL. If this is NULL all command arguments\n are assumed to be NULL-terminated strings. It is also possible for specific arguments\n to be NULL-terminated; in this case pass -1 in the corresponding Argl position.\n @param Buffer\n Buffer that receives the command response. May be NULL.\n @param PSize\n Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7325 pub fn FspLaunchCallLauncherPipe(
7326 Command: WCHAR,
7327 Argc: ULONG,
7328 Argv: *mut PWSTR,
7329 Argl: *mut ULONG,
7330 Buffer: PWSTR,
7331 PSize: PULONG,
7332 PLauncherError: PULONG,
7333 ) -> NTSTATUS;
7334}
7335unsafe extern "C" {
7336 #[doc = " Call launcher pipe.\n\n This function is used to send a command to the launcher and receive a response.\n\n @param Command\n Launcher command to send. For example, the 'L' launcher command instructs\n the launcher to list all running service instances.\n @param Argc\n Command argument count. May be 0.\n @param Argv\n Command argument array. May be NULL.\n @param Argl\n Command argument length array. May be NULL. If this is NULL all command arguments\n are assumed to be NULL-terminated strings. It is also possible for specific arguments\n to be NULL-terminated; in this case pass -1 in the corresponding Argl position.\n @param Buffer\n Buffer that receives the command response. May be NULL.\n @param PSize\n Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n contains the number of bytes transferred. May be NULL.\n @param AllowImpersonation\n Allow caller to be impersonated by launcher.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7337 pub fn FspLaunchCallLauncherPipeEx(
7338 Command: WCHAR,
7339 Argc: ULONG,
7340 Argv: *mut PWSTR,
7341 Argl: *mut ULONG,
7342 Buffer: PWSTR,
7343 PSize: PULONG,
7344 AllowImpersonation: BOOLEAN,
7345 PLauncherError: PULONG,
7346 ) -> NTSTATUS;
7347}
7348unsafe extern "C" {
7349 #[doc = " Start a service instance.\n\n @param ClassName\n Class name of the service instance to start.\n @param InstanceName\n Instance name of the service instance to start.\n @param Argc\n Service instance argument count. May be 0.\n @param Argv\n Service instance argument array. May be NULL.\n @param HasSecret\n Whether the last argument in Argv is assumed to be a secret (e.g. password) or not.\n Secrets are passed to service instances through standard input rather than the command\n line.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7350 pub fn FspLaunchStart(
7351 ClassName: PWSTR,
7352 InstanceName: PWSTR,
7353 Argc: ULONG,
7354 Argv: *mut PWSTR,
7355 HasSecret: BOOLEAN,
7356 PLauncherError: PULONG,
7357 ) -> NTSTATUS;
7358}
7359unsafe extern "C" {
7360 #[doc = " Start a service instance.\n\n @param ClassName\n Class name of the service instance to start.\n @param InstanceName\n Instance name of the service instance to start.\n @param Argc\n Service instance argument count. May be 0.\n @param Argv\n Service instance argument array. May be NULL.\n @param HasSecret\n Whether the last argument in Argv is assumed to be a secret (e.g. password) or not.\n Secrets are passed to service instances through standard input rather than the command\n line.\n @param AllowImpersonation\n Allow caller to be impersonated by launcher.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7361 pub fn FspLaunchStartEx(
7362 ClassName: PWSTR,
7363 InstanceName: PWSTR,
7364 Argc: ULONG,
7365 Argv: *mut PWSTR,
7366 HasSecret: BOOLEAN,
7367 AllowImpersonation: BOOLEAN,
7368 PLauncherError: PULONG,
7369 ) -> NTSTATUS;
7370}
7371unsafe extern "C" {
7372 #[doc = " Stop a service instance.\n\n @param ClassName\n Class name of the service instance to stop.\n @param InstanceName\n Instance name of the service instance to stop.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7373 pub fn FspLaunchStop(ClassName: PWSTR, InstanceName: PWSTR, PLauncherError: PULONG)
7374 -> NTSTATUS;
7375}
7376unsafe extern "C" {
7377 #[doc = " Get information about a service instance.\n\n The information is a list of NULL-terminated strings: the class name of the service instance,\n the instance name of the service instance and the full command line used to start the service\n instance.\n\n @param ClassName\n Class name of the service instance to stop.\n @param InstanceName\n Instance name of the service instance to stop.\n @param Buffer\n Buffer that receives the command response. May be NULL.\n @param PSize\n Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7378 pub fn FspLaunchGetInfo(
7379 ClassName: PWSTR,
7380 InstanceName: PWSTR,
7381 Buffer: PWSTR,
7382 PSize: PULONG,
7383 PLauncherError: PULONG,
7384 ) -> NTSTATUS;
7385}
7386unsafe extern "C" {
7387 #[doc = " List service instances.\n\n The information is a list of pairs of NULL-terminated strings. Each pair contains the class\n name and instance name of a service instance. All currently running service instances are\n listed.\n\n @param Buffer\n Buffer that receives the command response. May be NULL.\n @param PSize\n Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n returns an error. Other status codes indicate a communication error. Launcher errors are\n reported through PLauncherError."]
7388 pub fn FspLaunchGetNameList(Buffer: PWSTR, PSize: PULONG, PLauncherError: PULONG) -> NTSTATUS;
7389}
7390#[doc = " Service registry record."]
7391#[repr(C)]
7392#[derive(Debug)]
7393pub struct _FSP_LAUNCH_REG_RECORD {
7394 pub Agent: PWSTR,
7395 pub Executable: PWSTR,
7396 pub CommandLine: PWSTR,
7397 pub WorkDirectory: PWSTR,
7398 pub RunAs: PWSTR,
7399 pub Security: PWSTR,
7400 pub AuthPackage: PWSTR,
7401 pub Stderr: PWSTR,
7402 pub Reserved0: [PVOID; 4usize],
7403 pub JobControl: ULONG,
7404 pub Credentials: ULONG,
7405 pub AuthPackageId: ULONG,
7406 pub Recovery: ULONG,
7407 pub Reserved1: [ULONG; 4usize],
7408 pub Buffer: __IncompleteArrayField<UINT8>,
7409}
7410#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7411const _: () = {
7412 ["Size of _FSP_LAUNCH_REG_RECORD"][::std::mem::size_of::<_FSP_LAUNCH_REG_RECORD>() - 128usize];
7413 ["Alignment of _FSP_LAUNCH_REG_RECORD"]
7414 [::std::mem::align_of::<_FSP_LAUNCH_REG_RECORD>() - 8usize];
7415 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Agent"]
7416 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Agent) - 0usize];
7417 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Executable"]
7418 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Executable) - 8usize];
7419 ["Offset of field: _FSP_LAUNCH_REG_RECORD::CommandLine"]
7420 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, CommandLine) - 16usize];
7421 ["Offset of field: _FSP_LAUNCH_REG_RECORD::WorkDirectory"]
7422 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, WorkDirectory) - 24usize];
7423 ["Offset of field: _FSP_LAUNCH_REG_RECORD::RunAs"]
7424 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, RunAs) - 32usize];
7425 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Security"]
7426 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Security) - 40usize];
7427 ["Offset of field: _FSP_LAUNCH_REG_RECORD::AuthPackage"]
7428 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, AuthPackage) - 48usize];
7429 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Stderr"]
7430 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Stderr) - 56usize];
7431 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Reserved0"]
7432 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Reserved0) - 64usize];
7433 ["Offset of field: _FSP_LAUNCH_REG_RECORD::JobControl"]
7434 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, JobControl) - 96usize];
7435 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Credentials"]
7436 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Credentials) - 100usize];
7437 ["Offset of field: _FSP_LAUNCH_REG_RECORD::AuthPackageId"]
7438 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, AuthPackageId) - 104usize];
7439 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Recovery"]
7440 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Recovery) - 108usize];
7441 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Reserved1"]
7442 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Reserved1) - 112usize];
7443 ["Offset of field: _FSP_LAUNCH_REG_RECORD::Buffer"]
7444 [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Buffer) - 128usize];
7445};
7446impl Default for _FSP_LAUNCH_REG_RECORD {
7447 fn default() -> Self {
7448 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7449 unsafe {
7450 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7451 s.assume_init()
7452 }
7453 }
7454}
7455#[doc = " Service registry record."]
7456pub type FSP_LAUNCH_REG_RECORD = _FSP_LAUNCH_REG_RECORD;
7457unsafe extern "C" {
7458 #[doc = " Add/change/delete a service registry record.\n\n @param ClassName\n The service class name.\n @param Record\n The record to set in the registry. If NULL, the registry record is deleted.\n @return\n STATUS_SUCCESS or error code."]
7459 pub fn FspLaunchRegSetRecord(
7460 ClassName: PWSTR,
7461 Record: *const FSP_LAUNCH_REG_RECORD,
7462 ) -> NTSTATUS;
7463}
7464unsafe extern "C" {
7465 #[doc = " Get a service registry record.\n\n @param ClassName\n The service class name.\n @param Agent\n The name of the agent that is retrieving the service record. This API matches\n the supplied Agent against the Agent in the service record and it only returns\n the record if they match. Pass NULL to match any Agent.\n @param PRecord\n Pointer to a record pointer. Memory for the service record will be allocated\n and a pointer to it will be stored at this address. This memory must be later\n freed using FspLaunchRegFreeRecord.\n @return\n STATUS_SUCCESS or error code.\n @see\n FspLaunchRegFreeRecord"]
7466 pub fn FspLaunchRegGetRecord(
7467 ClassName: PWSTR,
7468 Agent: PWSTR,
7469 PRecord: *mut *mut FSP_LAUNCH_REG_RECORD,
7470 ) -> NTSTATUS;
7471}
7472unsafe extern "C" {
7473 #[doc = " Free a service registry record.\n\n @param Record\n The service record to free.\n @see\n FspLaunchRegGetRecord"]
7474 pub fn FspLaunchRegFreeRecord(Record: *mut FSP_LAUNCH_REG_RECORD);
7475}