1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
3 #[repr(transparent)]
4 pub struct HPSS(pub isize);
5 impl ::std::default::Default for HPSS {
default() -> Self6     fn default() -> Self {
7         unsafe { ::std::mem::zeroed() }
8     }
9 }
10 unsafe impl ::windows::runtime::Handle for HPSS {}
11 unsafe impl ::windows::runtime::Abi for HPSS {
12     type Abi = Self;
13     type DefaultType = Self;
14 }
15 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
16 #[repr(transparent)]
17 pub struct HPSSWALK(pub isize);
18 impl ::std::default::Default for HPSSWALK {
default() -> Self19     fn default() -> Self {
20         unsafe { ::std::mem::zeroed() }
21     }
22 }
23 unsafe impl ::windows::runtime::Handle for HPSSWALK {}
24 unsafe impl ::windows::runtime::Abi for HPSSWALK {
25     type Abi = Self;
26     type DefaultType = Self;
27 }
28 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
29 #[repr(C)]
30 pub struct PSS_ALLOCATOR {
31     pub Context: *mut ::std::ffi::c_void,
32     pub AllocRoutine: isize,
33     pub FreeRoutine: isize,
34 }
35 impl PSS_ALLOCATOR {}
36 impl ::std::default::Default for PSS_ALLOCATOR {
default() -> Self37     fn default() -> Self {
38         unsafe { ::std::mem::zeroed() }
39     }
40 }
41 impl ::std::fmt::Debug for PSS_ALLOCATOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result42     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
43         fmt.debug_struct("PSS_ALLOCATOR").field("Context", &self.Context).field("AllocRoutine", &self.AllocRoutine).field("FreeRoutine", &self.FreeRoutine).finish()
44     }
45 }
46 impl ::std::cmp::PartialEq for PSS_ALLOCATOR {
eq(&self, other: &Self) -> bool47     fn eq(&self, other: &Self) -> bool {
48         self.Context == other.Context && self.AllocRoutine == other.AllocRoutine && self.FreeRoutine == other.FreeRoutine
49     }
50 }
51 impl ::std::cmp::Eq for PSS_ALLOCATOR {}
52 unsafe impl ::windows::runtime::Abi for PSS_ALLOCATOR {
53     type Abi = Self;
54     type DefaultType = Self;
55 }
56 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
57 #[repr(C)]
58 pub struct PSS_AUXILIARY_PAGES_INFORMATION {
59     pub AuxPagesCaptured: u32,
60 }
61 impl PSS_AUXILIARY_PAGES_INFORMATION {}
62 impl ::std::default::Default for PSS_AUXILIARY_PAGES_INFORMATION {
default() -> Self63     fn default() -> Self {
64         unsafe { ::std::mem::zeroed() }
65     }
66 }
67 impl ::std::fmt::Debug for PSS_AUXILIARY_PAGES_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result68     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
69         fmt.debug_struct("PSS_AUXILIARY_PAGES_INFORMATION").field("AuxPagesCaptured", &self.AuxPagesCaptured).finish()
70     }
71 }
72 impl ::std::cmp::PartialEq for PSS_AUXILIARY_PAGES_INFORMATION {
eq(&self, other: &Self) -> bool73     fn eq(&self, other: &Self) -> bool {
74         self.AuxPagesCaptured == other.AuxPagesCaptured
75     }
76 }
77 impl ::std::cmp::Eq for PSS_AUXILIARY_PAGES_INFORMATION {}
78 unsafe impl ::windows::runtime::Abi for PSS_AUXILIARY_PAGES_INFORMATION {
79     type Abi = Self;
80     type DefaultType = Self;
81 }
82 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
83 #[repr(C)]
84 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
85 pub struct PSS_AUXILIARY_PAGE_ENTRY {
86     pub Address: *mut ::std::ffi::c_void,
87     pub BasicInformation: super::super::Memory::MEMORY_BASIC_INFORMATION,
88     pub CaptureTime: super::super::super::Foundation::FILETIME,
89     pub PageContents: *mut ::std::ffi::c_void,
90     pub PageSize: u32,
91 }
92 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
93 impl PSS_AUXILIARY_PAGE_ENTRY {}
94 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
95 impl ::std::default::Default for PSS_AUXILIARY_PAGE_ENTRY {
default() -> Self96     fn default() -> Self {
97         unsafe { ::std::mem::zeroed() }
98     }
99 }
100 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
101 impl ::std::fmt::Debug for PSS_AUXILIARY_PAGE_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result102     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
103         fmt.debug_struct("PSS_AUXILIARY_PAGE_ENTRY").field("Address", &self.Address).field("BasicInformation", &self.BasicInformation).field("CaptureTime", &self.CaptureTime).field("PageContents", &self.PageContents).field("PageSize", &self.PageSize).finish()
104     }
105 }
106 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
107 impl ::std::cmp::PartialEq for PSS_AUXILIARY_PAGE_ENTRY {
eq(&self, other: &Self) -> bool108     fn eq(&self, other: &Self) -> bool {
109         self.Address == other.Address && self.BasicInformation == other.BasicInformation && self.CaptureTime == other.CaptureTime && self.PageContents == other.PageContents && self.PageSize == other.PageSize
110     }
111 }
112 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
113 impl ::std::cmp::Eq for PSS_AUXILIARY_PAGE_ENTRY {}
114 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
115 unsafe impl ::windows::runtime::Abi for PSS_AUXILIARY_PAGE_ENTRY {
116     type Abi = Self;
117     type DefaultType = Self;
118 }
119 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
120 #[repr(transparent)]
121 pub struct PSS_CAPTURE_FLAGS(pub u32);
122 pub const PSS_CAPTURE_NONE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(0u32);
123 pub const PSS_CAPTURE_VA_CLONE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(1u32);
124 pub const PSS_CAPTURE_RESERVED_00000002: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(2u32);
125 pub const PSS_CAPTURE_HANDLES: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(4u32);
126 pub const PSS_CAPTURE_HANDLE_NAME_INFORMATION: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(8u32);
127 pub const PSS_CAPTURE_HANDLE_BASIC_INFORMATION: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(16u32);
128 pub const PSS_CAPTURE_HANDLE_TYPE_SPECIFIC_INFORMATION: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(32u32);
129 pub const PSS_CAPTURE_HANDLE_TRACE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(64u32);
130 pub const PSS_CAPTURE_THREADS: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(128u32);
131 pub const PSS_CAPTURE_THREAD_CONTEXT: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(256u32);
132 pub const PSS_CAPTURE_THREAD_CONTEXT_EXTENDED: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(512u32);
133 pub const PSS_CAPTURE_RESERVED_00000400: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(1024u32);
134 pub const PSS_CAPTURE_VA_SPACE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(2048u32);
135 pub const PSS_CAPTURE_VA_SPACE_SECTION_INFORMATION: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(4096u32);
136 pub const PSS_CAPTURE_IPT_TRACE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(8192u32);
137 pub const PSS_CAPTURE_RESERVED_00004000: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(16384u32);
138 pub const PSS_CREATE_BREAKAWAY_OPTIONAL: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(67108864u32);
139 pub const PSS_CREATE_BREAKAWAY: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(134217728u32);
140 pub const PSS_CREATE_FORCE_BREAKAWAY: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(268435456u32);
141 pub const PSS_CREATE_USE_VM_ALLOCATIONS: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(536870912u32);
142 pub const PSS_CREATE_MEASURE_PERFORMANCE: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(1073741824u32);
143 pub const PSS_CREATE_RELEASE_SECTION: PSS_CAPTURE_FLAGS = PSS_CAPTURE_FLAGS(2147483648u32);
144 impl ::std::convert::From<u32> for PSS_CAPTURE_FLAGS {
from(value: u32) -> Self145     fn from(value: u32) -> Self {
146         Self(value)
147     }
148 }
149 unsafe impl ::windows::runtime::Abi for PSS_CAPTURE_FLAGS {
150     type Abi = Self;
151     type DefaultType = Self;
152 }
153 impl ::std::ops::BitOr for PSS_CAPTURE_FLAGS {
154     type Output = Self;
bitor(self, rhs: Self) -> Self155     fn bitor(self, rhs: Self) -> Self {
156         Self(self.0 | rhs.0)
157     }
158 }
159 impl ::std::ops::BitAnd for PSS_CAPTURE_FLAGS {
160     type Output = Self;
bitand(self, rhs: Self) -> Self161     fn bitand(self, rhs: Self) -> Self {
162         Self(self.0 & rhs.0)
163     }
164 }
165 impl ::std::ops::BitOrAssign for PSS_CAPTURE_FLAGS {
bitor_assign(&mut self, rhs: Self)166     fn bitor_assign(&mut self, rhs: Self) {
167         self.0.bitor_assign(rhs.0)
168     }
169 }
170 impl ::std::ops::BitAndAssign for PSS_CAPTURE_FLAGS {
bitand_assign(&mut self, rhs: Self)171     fn bitand_assign(&mut self, rhs: Self) {
172         self.0.bitand_assign(rhs.0)
173     }
174 }
175 impl ::std::ops::Not for PSS_CAPTURE_FLAGS {
176     type Output = Self;
not(self) -> Self177     fn not(self) -> Self {
178         Self(self.0.not())
179     }
180 }
181 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
182 #[repr(transparent)]
183 pub struct PSS_DUPLICATE_FLAGS(pub u32);
184 pub const PSS_DUPLICATE_NONE: PSS_DUPLICATE_FLAGS = PSS_DUPLICATE_FLAGS(0u32);
185 pub const PSS_DUPLICATE_CLOSE_SOURCE: PSS_DUPLICATE_FLAGS = PSS_DUPLICATE_FLAGS(1u32);
186 impl ::std::convert::From<u32> for PSS_DUPLICATE_FLAGS {
from(value: u32) -> Self187     fn from(value: u32) -> Self {
188         Self(value)
189     }
190 }
191 unsafe impl ::windows::runtime::Abi for PSS_DUPLICATE_FLAGS {
192     type Abi = Self;
193     type DefaultType = Self;
194 }
195 impl ::std::ops::BitOr for PSS_DUPLICATE_FLAGS {
196     type Output = Self;
bitor(self, rhs: Self) -> Self197     fn bitor(self, rhs: Self) -> Self {
198         Self(self.0 | rhs.0)
199     }
200 }
201 impl ::std::ops::BitAnd for PSS_DUPLICATE_FLAGS {
202     type Output = Self;
bitand(self, rhs: Self) -> Self203     fn bitand(self, rhs: Self) -> Self {
204         Self(self.0 & rhs.0)
205     }
206 }
207 impl ::std::ops::BitOrAssign for PSS_DUPLICATE_FLAGS {
bitor_assign(&mut self, rhs: Self)208     fn bitor_assign(&mut self, rhs: Self) {
209         self.0.bitor_assign(rhs.0)
210     }
211 }
212 impl ::std::ops::BitAndAssign for PSS_DUPLICATE_FLAGS {
bitand_assign(&mut self, rhs: Self)213     fn bitand_assign(&mut self, rhs: Self) {
214         self.0.bitand_assign(rhs.0)
215     }
216 }
217 impl ::std::ops::Not for PSS_DUPLICATE_FLAGS {
218     type Output = Self;
not(self) -> Self219     fn not(self) -> Self {
220         Self(self.0.not())
221     }
222 }
223 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
224 #[repr(C)]
225 #[cfg(feature = "Win32_Foundation")]
226 pub struct PSS_HANDLE_ENTRY {
227     pub Handle: super::super::super::Foundation::HANDLE,
228     pub Flags: PSS_HANDLE_FLAGS,
229     pub ObjectType: PSS_OBJECT_TYPE,
230     pub CaptureTime: super::super::super::Foundation::FILETIME,
231     pub Attributes: u32,
232     pub GrantedAccess: u32,
233     pub HandleCount: u32,
234     pub PointerCount: u32,
235     pub PagedPoolCharge: u32,
236     pub NonPagedPoolCharge: u32,
237     pub CreationTime: super::super::super::Foundation::FILETIME,
238     pub TypeNameLength: u16,
239     pub TypeName: super::super::super::Foundation::PWSTR,
240     pub ObjectNameLength: u16,
241     pub ObjectName: super::super::super::Foundation::PWSTR,
242     pub TypeSpecificInformation: PSS_HANDLE_ENTRY_0,
243 }
244 #[cfg(feature = "Win32_Foundation")]
245 impl PSS_HANDLE_ENTRY {}
246 #[cfg(feature = "Win32_Foundation")]
247 impl ::std::default::Default for PSS_HANDLE_ENTRY {
default() -> Self248     fn default() -> Self {
249         unsafe { ::std::mem::zeroed() }
250     }
251 }
252 #[cfg(feature = "Win32_Foundation")]
253 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY {
eq(&self, _other: &Self) -> bool254     fn eq(&self, _other: &Self) -> bool {
255         unimplemented!()
256     }
257 }
258 #[cfg(feature = "Win32_Foundation")]
259 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY {}
260 #[cfg(feature = "Win32_Foundation")]
261 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY {
262     type Abi = Self;
263     type DefaultType = Self;
264 }
265 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
266 #[repr(C)]
267 #[cfg(feature = "Win32_Foundation")]
268 pub union PSS_HANDLE_ENTRY_0 {
269     pub Process: PSS_HANDLE_ENTRY_0_2,
270     pub Thread: PSS_HANDLE_ENTRY_0_5,
271     pub Mutant: PSS_HANDLE_ENTRY_0_1,
272     pub Event: PSS_HANDLE_ENTRY_0_0,
273     pub Section: PSS_HANDLE_ENTRY_0_3,
274     pub Semaphore: PSS_HANDLE_ENTRY_0_4,
275 }
276 #[cfg(feature = "Win32_Foundation")]
277 impl PSS_HANDLE_ENTRY_0 {}
278 #[cfg(feature = "Win32_Foundation")]
279 impl ::std::default::Default for PSS_HANDLE_ENTRY_0 {
default() -> Self280     fn default() -> Self {
281         unsafe { ::std::mem::zeroed() }
282     }
283 }
284 #[cfg(feature = "Win32_Foundation")]
285 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0 {
eq(&self, _other: &Self) -> bool286     fn eq(&self, _other: &Self) -> bool {
287         unimplemented!()
288     }
289 }
290 #[cfg(feature = "Win32_Foundation")]
291 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0 {}
292 #[cfg(feature = "Win32_Foundation")]
293 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0 {
294     type Abi = Self;
295     type DefaultType = Self;
296 }
297 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
298 #[repr(C)]
299 #[cfg(feature = "Win32_Foundation")]
300 pub struct PSS_HANDLE_ENTRY_0_0 {
301     pub ManualReset: super::super::super::Foundation::BOOL,
302     pub Signaled: super::super::super::Foundation::BOOL,
303 }
304 #[cfg(feature = "Win32_Foundation")]
305 impl PSS_HANDLE_ENTRY_0_0 {}
306 #[cfg(feature = "Win32_Foundation")]
307 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_0 {
default() -> Self308     fn default() -> Self {
309         unsafe { ::std::mem::zeroed() }
310     }
311 }
312 #[cfg(feature = "Win32_Foundation")]
313 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result314     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
315         fmt.debug_struct("_Event_e__Struct").field("ManualReset", &self.ManualReset).field("Signaled", &self.Signaled).finish()
316     }
317 }
318 #[cfg(feature = "Win32_Foundation")]
319 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_0 {
eq(&self, other: &Self) -> bool320     fn eq(&self, other: &Self) -> bool {
321         self.ManualReset == other.ManualReset && self.Signaled == other.Signaled
322     }
323 }
324 #[cfg(feature = "Win32_Foundation")]
325 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_0 {}
326 #[cfg(feature = "Win32_Foundation")]
327 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_0 {
328     type Abi = Self;
329     type DefaultType = Self;
330 }
331 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
332 #[repr(C)]
333 #[cfg(feature = "Win32_Foundation")]
334 pub struct PSS_HANDLE_ENTRY_0_1 {
335     pub CurrentCount: i32,
336     pub Abandoned: super::super::super::Foundation::BOOL,
337     pub OwnerProcessId: u32,
338     pub OwnerThreadId: u32,
339 }
340 #[cfg(feature = "Win32_Foundation")]
341 impl PSS_HANDLE_ENTRY_0_1 {}
342 #[cfg(feature = "Win32_Foundation")]
343 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_1 {
default() -> Self344     fn default() -> Self {
345         unsafe { ::std::mem::zeroed() }
346     }
347 }
348 #[cfg(feature = "Win32_Foundation")]
349 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result350     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
351         fmt.debug_struct("_Mutant_e__Struct").field("CurrentCount", &self.CurrentCount).field("Abandoned", &self.Abandoned).field("OwnerProcessId", &self.OwnerProcessId).field("OwnerThreadId", &self.OwnerThreadId).finish()
352     }
353 }
354 #[cfg(feature = "Win32_Foundation")]
355 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_1 {
eq(&self, other: &Self) -> bool356     fn eq(&self, other: &Self) -> bool {
357         self.CurrentCount == other.CurrentCount && self.Abandoned == other.Abandoned && self.OwnerProcessId == other.OwnerProcessId && self.OwnerThreadId == other.OwnerThreadId
358     }
359 }
360 #[cfg(feature = "Win32_Foundation")]
361 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_1 {}
362 #[cfg(feature = "Win32_Foundation")]
363 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_1 {
364     type Abi = Self;
365     type DefaultType = Self;
366 }
367 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
368 #[repr(C)]
369 pub struct PSS_HANDLE_ENTRY_0_2 {
370     pub ExitStatus: u32,
371     pub PebBaseAddress: *mut ::std::ffi::c_void,
372     pub AffinityMask: usize,
373     pub BasePriority: i32,
374     pub ProcessId: u32,
375     pub ParentProcessId: u32,
376     pub Flags: u32,
377 }
378 impl PSS_HANDLE_ENTRY_0_2 {}
379 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_2 {
default() -> Self380     fn default() -> Self {
381         unsafe { ::std::mem::zeroed() }
382     }
383 }
384 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result385     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
386         fmt.debug_struct("_Process_e__Struct")
387             .field("ExitStatus", &self.ExitStatus)
388             .field("PebBaseAddress", &self.PebBaseAddress)
389             .field("AffinityMask", &self.AffinityMask)
390             .field("BasePriority", &self.BasePriority)
391             .field("ProcessId", &self.ProcessId)
392             .field("ParentProcessId", &self.ParentProcessId)
393             .field("Flags", &self.Flags)
394             .finish()
395     }
396 }
397 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_2 {
eq(&self, other: &Self) -> bool398     fn eq(&self, other: &Self) -> bool {
399         self.ExitStatus == other.ExitStatus && self.PebBaseAddress == other.PebBaseAddress && self.AffinityMask == other.AffinityMask && self.BasePriority == other.BasePriority && self.ProcessId == other.ProcessId && self.ParentProcessId == other.ParentProcessId && self.Flags == other.Flags
400     }
401 }
402 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_2 {}
403 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_2 {
404     type Abi = Self;
405     type DefaultType = Self;
406 }
407 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
408 #[repr(C)]
409 pub struct PSS_HANDLE_ENTRY_0_3 {
410     pub BaseAddress: *mut ::std::ffi::c_void,
411     pub AllocationAttributes: u32,
412     pub MaximumSize: i64,
413 }
414 impl PSS_HANDLE_ENTRY_0_3 {}
415 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_3 {
default() -> Self416     fn default() -> Self {
417         unsafe { ::std::mem::zeroed() }
418     }
419 }
420 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result421     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
422         fmt.debug_struct("_Section_e__Struct").field("BaseAddress", &self.BaseAddress).field("AllocationAttributes", &self.AllocationAttributes).field("MaximumSize", &self.MaximumSize).finish()
423     }
424 }
425 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_3 {
eq(&self, other: &Self) -> bool426     fn eq(&self, other: &Self) -> bool {
427         self.BaseAddress == other.BaseAddress && self.AllocationAttributes == other.AllocationAttributes && self.MaximumSize == other.MaximumSize
428     }
429 }
430 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_3 {}
431 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_3 {
432     type Abi = Self;
433     type DefaultType = Self;
434 }
435 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
436 #[repr(C)]
437 pub struct PSS_HANDLE_ENTRY_0_4 {
438     pub CurrentCount: i32,
439     pub MaximumCount: i32,
440 }
441 impl PSS_HANDLE_ENTRY_0_4 {}
442 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_4 {
default() -> Self443     fn default() -> Self {
444         unsafe { ::std::mem::zeroed() }
445     }
446 }
447 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result448     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
449         fmt.debug_struct("_Semaphore_e__Struct").field("CurrentCount", &self.CurrentCount).field("MaximumCount", &self.MaximumCount).finish()
450     }
451 }
452 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_4 {
eq(&self, other: &Self) -> bool453     fn eq(&self, other: &Self) -> bool {
454         self.CurrentCount == other.CurrentCount && self.MaximumCount == other.MaximumCount
455     }
456 }
457 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_4 {}
458 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_4 {
459     type Abi = Self;
460     type DefaultType = Self;
461 }
462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
463 #[repr(C)]
464 pub struct PSS_HANDLE_ENTRY_0_5 {
465     pub ExitStatus: u32,
466     pub TebBaseAddress: *mut ::std::ffi::c_void,
467     pub ProcessId: u32,
468     pub ThreadId: u32,
469     pub AffinityMask: usize,
470     pub Priority: i32,
471     pub BasePriority: i32,
472     pub Win32StartAddress: *mut ::std::ffi::c_void,
473 }
474 impl PSS_HANDLE_ENTRY_0_5 {}
475 impl ::std::default::Default for PSS_HANDLE_ENTRY_0_5 {
default() -> Self476     fn default() -> Self {
477         unsafe { ::std::mem::zeroed() }
478     }
479 }
480 impl ::std::fmt::Debug for PSS_HANDLE_ENTRY_0_5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result481     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
482         fmt.debug_struct("_Thread_e__Struct")
483             .field("ExitStatus", &self.ExitStatus)
484             .field("TebBaseAddress", &self.TebBaseAddress)
485             .field("ProcessId", &self.ProcessId)
486             .field("ThreadId", &self.ThreadId)
487             .field("AffinityMask", &self.AffinityMask)
488             .field("Priority", &self.Priority)
489             .field("BasePriority", &self.BasePriority)
490             .field("Win32StartAddress", &self.Win32StartAddress)
491             .finish()
492     }
493 }
494 impl ::std::cmp::PartialEq for PSS_HANDLE_ENTRY_0_5 {
eq(&self, other: &Self) -> bool495     fn eq(&self, other: &Self) -> bool {
496         self.ExitStatus == other.ExitStatus && self.TebBaseAddress == other.TebBaseAddress && self.ProcessId == other.ProcessId && self.ThreadId == other.ThreadId && self.AffinityMask == other.AffinityMask && self.Priority == other.Priority && self.BasePriority == other.BasePriority && self.Win32StartAddress == other.Win32StartAddress
497     }
498 }
499 impl ::std::cmp::Eq for PSS_HANDLE_ENTRY_0_5 {}
500 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_ENTRY_0_5 {
501     type Abi = Self;
502     type DefaultType = Self;
503 }
504 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
505 #[repr(transparent)]
506 pub struct PSS_HANDLE_FLAGS(pub u32);
507 pub const PSS_HANDLE_NONE: PSS_HANDLE_FLAGS = PSS_HANDLE_FLAGS(0u32);
508 pub const PSS_HANDLE_HAVE_TYPE: PSS_HANDLE_FLAGS = PSS_HANDLE_FLAGS(1u32);
509 pub const PSS_HANDLE_HAVE_NAME: PSS_HANDLE_FLAGS = PSS_HANDLE_FLAGS(2u32);
510 pub const PSS_HANDLE_HAVE_BASIC_INFORMATION: PSS_HANDLE_FLAGS = PSS_HANDLE_FLAGS(4u32);
511 pub const PSS_HANDLE_HAVE_TYPE_SPECIFIC_INFORMATION: PSS_HANDLE_FLAGS = PSS_HANDLE_FLAGS(8u32);
512 impl ::std::convert::From<u32> for PSS_HANDLE_FLAGS {
from(value: u32) -> Self513     fn from(value: u32) -> Self {
514         Self(value)
515     }
516 }
517 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_FLAGS {
518     type Abi = Self;
519     type DefaultType = Self;
520 }
521 impl ::std::ops::BitOr for PSS_HANDLE_FLAGS {
522     type Output = Self;
bitor(self, rhs: Self) -> Self523     fn bitor(self, rhs: Self) -> Self {
524         Self(self.0 | rhs.0)
525     }
526 }
527 impl ::std::ops::BitAnd for PSS_HANDLE_FLAGS {
528     type Output = Self;
bitand(self, rhs: Self) -> Self529     fn bitand(self, rhs: Self) -> Self {
530         Self(self.0 & rhs.0)
531     }
532 }
533 impl ::std::ops::BitOrAssign for PSS_HANDLE_FLAGS {
bitor_assign(&mut self, rhs: Self)534     fn bitor_assign(&mut self, rhs: Self) {
535         self.0.bitor_assign(rhs.0)
536     }
537 }
538 impl ::std::ops::BitAndAssign for PSS_HANDLE_FLAGS {
bitand_assign(&mut self, rhs: Self)539     fn bitand_assign(&mut self, rhs: Self) {
540         self.0.bitand_assign(rhs.0)
541     }
542 }
543 impl ::std::ops::Not for PSS_HANDLE_FLAGS {
544     type Output = Self;
not(self) -> Self545     fn not(self) -> Self {
546         Self(self.0.not())
547     }
548 }
549 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
550 #[repr(C)]
551 pub struct PSS_HANDLE_INFORMATION {
552     pub HandlesCaptured: u32,
553 }
554 impl PSS_HANDLE_INFORMATION {}
555 impl ::std::default::Default for PSS_HANDLE_INFORMATION {
default() -> Self556     fn default() -> Self {
557         unsafe { ::std::mem::zeroed() }
558     }
559 }
560 impl ::std::fmt::Debug for PSS_HANDLE_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result561     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
562         fmt.debug_struct("PSS_HANDLE_INFORMATION").field("HandlesCaptured", &self.HandlesCaptured).finish()
563     }
564 }
565 impl ::std::cmp::PartialEq for PSS_HANDLE_INFORMATION {
eq(&self, other: &Self) -> bool566     fn eq(&self, other: &Self) -> bool {
567         self.HandlesCaptured == other.HandlesCaptured
568     }
569 }
570 impl ::std::cmp::Eq for PSS_HANDLE_INFORMATION {}
571 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_INFORMATION {
572     type Abi = Self;
573     type DefaultType = Self;
574 }
575 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
576 #[repr(C)]
577 #[cfg(feature = "Win32_Foundation")]
578 pub struct PSS_HANDLE_TRACE_INFORMATION {
579     pub SectionHandle: super::super::super::Foundation::HANDLE,
580     pub Size: u32,
581 }
582 #[cfg(feature = "Win32_Foundation")]
583 impl PSS_HANDLE_TRACE_INFORMATION {}
584 #[cfg(feature = "Win32_Foundation")]
585 impl ::std::default::Default for PSS_HANDLE_TRACE_INFORMATION {
default() -> Self586     fn default() -> Self {
587         unsafe { ::std::mem::zeroed() }
588     }
589 }
590 #[cfg(feature = "Win32_Foundation")]
591 impl ::std::fmt::Debug for PSS_HANDLE_TRACE_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result592     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
593         fmt.debug_struct("PSS_HANDLE_TRACE_INFORMATION").field("SectionHandle", &self.SectionHandle).field("Size", &self.Size).finish()
594     }
595 }
596 #[cfg(feature = "Win32_Foundation")]
597 impl ::std::cmp::PartialEq for PSS_HANDLE_TRACE_INFORMATION {
eq(&self, other: &Self) -> bool598     fn eq(&self, other: &Self) -> bool {
599         self.SectionHandle == other.SectionHandle && self.Size == other.Size
600     }
601 }
602 #[cfg(feature = "Win32_Foundation")]
603 impl ::std::cmp::Eq for PSS_HANDLE_TRACE_INFORMATION {}
604 #[cfg(feature = "Win32_Foundation")]
605 unsafe impl ::windows::runtime::Abi for PSS_HANDLE_TRACE_INFORMATION {
606     type Abi = Self;
607     type DefaultType = Self;
608 }
609 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
610 #[repr(transparent)]
611 pub struct PSS_OBJECT_TYPE(pub i32);
612 pub const PSS_OBJECT_TYPE_UNKNOWN: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(0i32);
613 pub const PSS_OBJECT_TYPE_PROCESS: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(1i32);
614 pub const PSS_OBJECT_TYPE_THREAD: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(2i32);
615 pub const PSS_OBJECT_TYPE_MUTANT: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(3i32);
616 pub const PSS_OBJECT_TYPE_EVENT: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(4i32);
617 pub const PSS_OBJECT_TYPE_SECTION: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(5i32);
618 pub const PSS_OBJECT_TYPE_SEMAPHORE: PSS_OBJECT_TYPE = PSS_OBJECT_TYPE(6i32);
619 impl ::std::convert::From<i32> for PSS_OBJECT_TYPE {
from(value: i32) -> Self620     fn from(value: i32) -> Self {
621         Self(value)
622     }
623 }
624 unsafe impl ::windows::runtime::Abi for PSS_OBJECT_TYPE {
625     type Abi = Self;
626     type DefaultType = Self;
627 }
628 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
629 #[repr(C)]
630 pub struct PSS_PERFORMANCE_COUNTERS {
631     pub TotalCycleCount: u64,
632     pub TotalWallClockPeriod: u64,
633     pub VaCloneCycleCount: u64,
634     pub VaCloneWallClockPeriod: u64,
635     pub VaSpaceCycleCount: u64,
636     pub VaSpaceWallClockPeriod: u64,
637     pub AuxPagesCycleCount: u64,
638     pub AuxPagesWallClockPeriod: u64,
639     pub HandlesCycleCount: u64,
640     pub HandlesWallClockPeriod: u64,
641     pub ThreadsCycleCount: u64,
642     pub ThreadsWallClockPeriod: u64,
643 }
644 impl PSS_PERFORMANCE_COUNTERS {}
645 impl ::std::default::Default for PSS_PERFORMANCE_COUNTERS {
default() -> Self646     fn default() -> Self {
647         unsafe { ::std::mem::zeroed() }
648     }
649 }
650 impl ::std::fmt::Debug for PSS_PERFORMANCE_COUNTERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result651     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
652         fmt.debug_struct("PSS_PERFORMANCE_COUNTERS")
653             .field("TotalCycleCount", &self.TotalCycleCount)
654             .field("TotalWallClockPeriod", &self.TotalWallClockPeriod)
655             .field("VaCloneCycleCount", &self.VaCloneCycleCount)
656             .field("VaCloneWallClockPeriod", &self.VaCloneWallClockPeriod)
657             .field("VaSpaceCycleCount", &self.VaSpaceCycleCount)
658             .field("VaSpaceWallClockPeriod", &self.VaSpaceWallClockPeriod)
659             .field("AuxPagesCycleCount", &self.AuxPagesCycleCount)
660             .field("AuxPagesWallClockPeriod", &self.AuxPagesWallClockPeriod)
661             .field("HandlesCycleCount", &self.HandlesCycleCount)
662             .field("HandlesWallClockPeriod", &self.HandlesWallClockPeriod)
663             .field("ThreadsCycleCount", &self.ThreadsCycleCount)
664             .field("ThreadsWallClockPeriod", &self.ThreadsWallClockPeriod)
665             .finish()
666     }
667 }
668 impl ::std::cmp::PartialEq for PSS_PERFORMANCE_COUNTERS {
eq(&self, other: &Self) -> bool669     fn eq(&self, other: &Self) -> bool {
670         self.TotalCycleCount == other.TotalCycleCount
671             && self.TotalWallClockPeriod == other.TotalWallClockPeriod
672             && self.VaCloneCycleCount == other.VaCloneCycleCount
673             && self.VaCloneWallClockPeriod == other.VaCloneWallClockPeriod
674             && self.VaSpaceCycleCount == other.VaSpaceCycleCount
675             && self.VaSpaceWallClockPeriod == other.VaSpaceWallClockPeriod
676             && self.AuxPagesCycleCount == other.AuxPagesCycleCount
677             && self.AuxPagesWallClockPeriod == other.AuxPagesWallClockPeriod
678             && self.HandlesCycleCount == other.HandlesCycleCount
679             && self.HandlesWallClockPeriod == other.HandlesWallClockPeriod
680             && self.ThreadsCycleCount == other.ThreadsCycleCount
681             && self.ThreadsWallClockPeriod == other.ThreadsWallClockPeriod
682     }
683 }
684 impl ::std::cmp::Eq for PSS_PERFORMANCE_COUNTERS {}
685 unsafe impl ::windows::runtime::Abi for PSS_PERFORMANCE_COUNTERS {
686     type Abi = Self;
687     type DefaultType = Self;
688 }
689 pub const PSS_PERF_RESOLUTION: u32 = 1000000u32;
690 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
691 #[repr(transparent)]
692 pub struct PSS_PROCESS_FLAGS(pub u32);
693 pub const PSS_PROCESS_FLAGS_NONE: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(0u32);
694 pub const PSS_PROCESS_FLAGS_PROTECTED: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(1u32);
695 pub const PSS_PROCESS_FLAGS_WOW64: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(2u32);
696 pub const PSS_PROCESS_FLAGS_RESERVED_03: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(4u32);
697 pub const PSS_PROCESS_FLAGS_RESERVED_04: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(8u32);
698 pub const PSS_PROCESS_FLAGS_FROZEN: PSS_PROCESS_FLAGS = PSS_PROCESS_FLAGS(16u32);
699 impl ::std::convert::From<u32> for PSS_PROCESS_FLAGS {
from(value: u32) -> Self700     fn from(value: u32) -> Self {
701         Self(value)
702     }
703 }
704 unsafe impl ::windows::runtime::Abi for PSS_PROCESS_FLAGS {
705     type Abi = Self;
706     type DefaultType = Self;
707 }
708 impl ::std::ops::BitOr for PSS_PROCESS_FLAGS {
709     type Output = Self;
bitor(self, rhs: Self) -> Self710     fn bitor(self, rhs: Self) -> Self {
711         Self(self.0 | rhs.0)
712     }
713 }
714 impl ::std::ops::BitAnd for PSS_PROCESS_FLAGS {
715     type Output = Self;
bitand(self, rhs: Self) -> Self716     fn bitand(self, rhs: Self) -> Self {
717         Self(self.0 & rhs.0)
718     }
719 }
720 impl ::std::ops::BitOrAssign for PSS_PROCESS_FLAGS {
bitor_assign(&mut self, rhs: Self)721     fn bitor_assign(&mut self, rhs: Self) {
722         self.0.bitor_assign(rhs.0)
723     }
724 }
725 impl ::std::ops::BitAndAssign for PSS_PROCESS_FLAGS {
bitand_assign(&mut self, rhs: Self)726     fn bitand_assign(&mut self, rhs: Self) {
727         self.0.bitand_assign(rhs.0)
728     }
729 }
730 impl ::std::ops::Not for PSS_PROCESS_FLAGS {
731     type Output = Self;
not(self) -> Self732     fn not(self) -> Self {
733         Self(self.0.not())
734     }
735 }
736 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
737 #[repr(C)]
738 #[cfg(feature = "Win32_Foundation")]
739 pub struct PSS_PROCESS_INFORMATION {
740     pub ExitStatus: u32,
741     pub PebBaseAddress: *mut ::std::ffi::c_void,
742     pub AffinityMask: usize,
743     pub BasePriority: i32,
744     pub ProcessId: u32,
745     pub ParentProcessId: u32,
746     pub Flags: PSS_PROCESS_FLAGS,
747     pub CreateTime: super::super::super::Foundation::FILETIME,
748     pub ExitTime: super::super::super::Foundation::FILETIME,
749     pub KernelTime: super::super::super::Foundation::FILETIME,
750     pub UserTime: super::super::super::Foundation::FILETIME,
751     pub PriorityClass: u32,
752     pub PeakVirtualSize: usize,
753     pub VirtualSize: usize,
754     pub PageFaultCount: u32,
755     pub PeakWorkingSetSize: usize,
756     pub WorkingSetSize: usize,
757     pub QuotaPeakPagedPoolUsage: usize,
758     pub QuotaPagedPoolUsage: usize,
759     pub QuotaPeakNonPagedPoolUsage: usize,
760     pub QuotaNonPagedPoolUsage: usize,
761     pub PagefileUsage: usize,
762     pub PeakPagefileUsage: usize,
763     pub PrivateUsage: usize,
764     pub ExecuteFlags: u32,
765     pub ImageFileName: [u16; 260],
766 }
767 #[cfg(feature = "Win32_Foundation")]
768 impl PSS_PROCESS_INFORMATION {}
769 #[cfg(feature = "Win32_Foundation")]
770 impl ::std::default::Default for PSS_PROCESS_INFORMATION {
default() -> Self771     fn default() -> Self {
772         unsafe { ::std::mem::zeroed() }
773     }
774 }
775 #[cfg(feature = "Win32_Foundation")]
776 impl ::std::fmt::Debug for PSS_PROCESS_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result777     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
778         fmt.debug_struct("PSS_PROCESS_INFORMATION")
779             .field("ExitStatus", &self.ExitStatus)
780             .field("PebBaseAddress", &self.PebBaseAddress)
781             .field("AffinityMask", &self.AffinityMask)
782             .field("BasePriority", &self.BasePriority)
783             .field("ProcessId", &self.ProcessId)
784             .field("ParentProcessId", &self.ParentProcessId)
785             .field("Flags", &self.Flags)
786             .field("CreateTime", &self.CreateTime)
787             .field("ExitTime", &self.ExitTime)
788             .field("KernelTime", &self.KernelTime)
789             .field("UserTime", &self.UserTime)
790             .field("PriorityClass", &self.PriorityClass)
791             .field("PeakVirtualSize", &self.PeakVirtualSize)
792             .field("VirtualSize", &self.VirtualSize)
793             .field("PageFaultCount", &self.PageFaultCount)
794             .field("PeakWorkingSetSize", &self.PeakWorkingSetSize)
795             .field("WorkingSetSize", &self.WorkingSetSize)
796             .field("QuotaPeakPagedPoolUsage", &self.QuotaPeakPagedPoolUsage)
797             .field("QuotaPagedPoolUsage", &self.QuotaPagedPoolUsage)
798             .field("QuotaPeakNonPagedPoolUsage", &self.QuotaPeakNonPagedPoolUsage)
799             .field("QuotaNonPagedPoolUsage", &self.QuotaNonPagedPoolUsage)
800             .field("PagefileUsage", &self.PagefileUsage)
801             .field("PeakPagefileUsage", &self.PeakPagefileUsage)
802             .field("PrivateUsage", &self.PrivateUsage)
803             .field("ExecuteFlags", &self.ExecuteFlags)
804             .field("ImageFileName", &self.ImageFileName)
805             .finish()
806     }
807 }
808 #[cfg(feature = "Win32_Foundation")]
809 impl ::std::cmp::PartialEq for PSS_PROCESS_INFORMATION {
eq(&self, other: &Self) -> bool810     fn eq(&self, other: &Self) -> bool {
811         self.ExitStatus == other.ExitStatus
812             && self.PebBaseAddress == other.PebBaseAddress
813             && self.AffinityMask == other.AffinityMask
814             && self.BasePriority == other.BasePriority
815             && self.ProcessId == other.ProcessId
816             && self.ParentProcessId == other.ParentProcessId
817             && self.Flags == other.Flags
818             && self.CreateTime == other.CreateTime
819             && self.ExitTime == other.ExitTime
820             && self.KernelTime == other.KernelTime
821             && self.UserTime == other.UserTime
822             && self.PriorityClass == other.PriorityClass
823             && self.PeakVirtualSize == other.PeakVirtualSize
824             && self.VirtualSize == other.VirtualSize
825             && self.PageFaultCount == other.PageFaultCount
826             && self.PeakWorkingSetSize == other.PeakWorkingSetSize
827             && self.WorkingSetSize == other.WorkingSetSize
828             && self.QuotaPeakPagedPoolUsage == other.QuotaPeakPagedPoolUsage
829             && self.QuotaPagedPoolUsage == other.QuotaPagedPoolUsage
830             && self.QuotaPeakNonPagedPoolUsage == other.QuotaPeakNonPagedPoolUsage
831             && self.QuotaNonPagedPoolUsage == other.QuotaNonPagedPoolUsage
832             && self.PagefileUsage == other.PagefileUsage
833             && self.PeakPagefileUsage == other.PeakPagefileUsage
834             && self.PrivateUsage == other.PrivateUsage
835             && self.ExecuteFlags == other.ExecuteFlags
836             && self.ImageFileName == other.ImageFileName
837     }
838 }
839 #[cfg(feature = "Win32_Foundation")]
840 impl ::std::cmp::Eq for PSS_PROCESS_INFORMATION {}
841 #[cfg(feature = "Win32_Foundation")]
842 unsafe impl ::windows::runtime::Abi for PSS_PROCESS_INFORMATION {
843     type Abi = Self;
844     type DefaultType = Self;
845 }
846 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
847 #[repr(transparent)]
848 pub struct PSS_QUERY_INFORMATION_CLASS(pub i32);
849 pub const PSS_QUERY_PROCESS_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(0i32);
850 pub const PSS_QUERY_VA_CLONE_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(1i32);
851 pub const PSS_QUERY_AUXILIARY_PAGES_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(2i32);
852 pub const PSS_QUERY_VA_SPACE_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(3i32);
853 pub const PSS_QUERY_HANDLE_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(4i32);
854 pub const PSS_QUERY_THREAD_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(5i32);
855 pub const PSS_QUERY_HANDLE_TRACE_INFORMATION: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(6i32);
856 pub const PSS_QUERY_PERFORMANCE_COUNTERS: PSS_QUERY_INFORMATION_CLASS = PSS_QUERY_INFORMATION_CLASS(7i32);
857 impl ::std::convert::From<i32> for PSS_QUERY_INFORMATION_CLASS {
from(value: i32) -> Self858     fn from(value: i32) -> Self {
859         Self(value)
860     }
861 }
862 unsafe impl ::windows::runtime::Abi for PSS_QUERY_INFORMATION_CLASS {
863     type Abi = Self;
864     type DefaultType = Self;
865 }
866 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
867 #[repr(C)]
868 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
869 pub struct PSS_THREAD_ENTRY {
870     pub ExitStatus: u32,
871     pub TebBaseAddress: *mut ::std::ffi::c_void,
872     pub ProcessId: u32,
873     pub ThreadId: u32,
874     pub AffinityMask: usize,
875     pub Priority: i32,
876     pub BasePriority: i32,
877     pub LastSyscallFirstArgument: *mut ::std::ffi::c_void,
878     pub LastSyscallNumber: u16,
879     pub CreateTime: super::super::super::Foundation::FILETIME,
880     pub ExitTime: super::super::super::Foundation::FILETIME,
881     pub KernelTime: super::super::super::Foundation::FILETIME,
882     pub UserTime: super::super::super::Foundation::FILETIME,
883     pub Win32StartAddress: *mut ::std::ffi::c_void,
884     pub CaptureTime: super::super::super::Foundation::FILETIME,
885     pub Flags: PSS_THREAD_FLAGS,
886     pub SuspendCount: u16,
887     pub SizeOfContextRecord: u16,
888     pub ContextRecord: *mut super::Debug::CONTEXT,
889 }
890 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
891 impl PSS_THREAD_ENTRY {}
892 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
893 impl ::std::default::Default for PSS_THREAD_ENTRY {
default() -> Self894     fn default() -> Self {
895         unsafe { ::std::mem::zeroed() }
896     }
897 }
898 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
899 impl ::std::fmt::Debug for PSS_THREAD_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result900     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
901         fmt.debug_struct("PSS_THREAD_ENTRY")
902             .field("ExitStatus", &self.ExitStatus)
903             .field("TebBaseAddress", &self.TebBaseAddress)
904             .field("ProcessId", &self.ProcessId)
905             .field("ThreadId", &self.ThreadId)
906             .field("AffinityMask", &self.AffinityMask)
907             .field("Priority", &self.Priority)
908             .field("BasePriority", &self.BasePriority)
909             .field("LastSyscallFirstArgument", &self.LastSyscallFirstArgument)
910             .field("LastSyscallNumber", &self.LastSyscallNumber)
911             .field("CreateTime", &self.CreateTime)
912             .field("ExitTime", &self.ExitTime)
913             .field("KernelTime", &self.KernelTime)
914             .field("UserTime", &self.UserTime)
915             .field("Win32StartAddress", &self.Win32StartAddress)
916             .field("CaptureTime", &self.CaptureTime)
917             .field("Flags", &self.Flags)
918             .field("SuspendCount", &self.SuspendCount)
919             .field("SizeOfContextRecord", &self.SizeOfContextRecord)
920             .field("ContextRecord", &self.ContextRecord)
921             .finish()
922     }
923 }
924 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
925 impl ::std::cmp::PartialEq for PSS_THREAD_ENTRY {
eq(&self, other: &Self) -> bool926     fn eq(&self, other: &Self) -> bool {
927         self.ExitStatus == other.ExitStatus
928             && self.TebBaseAddress == other.TebBaseAddress
929             && self.ProcessId == other.ProcessId
930             && self.ThreadId == other.ThreadId
931             && self.AffinityMask == other.AffinityMask
932             && self.Priority == other.Priority
933             && self.BasePriority == other.BasePriority
934             && self.LastSyscallFirstArgument == other.LastSyscallFirstArgument
935             && self.LastSyscallNumber == other.LastSyscallNumber
936             && self.CreateTime == other.CreateTime
937             && self.ExitTime == other.ExitTime
938             && self.KernelTime == other.KernelTime
939             && self.UserTime == other.UserTime
940             && self.Win32StartAddress == other.Win32StartAddress
941             && self.CaptureTime == other.CaptureTime
942             && self.Flags == other.Flags
943             && self.SuspendCount == other.SuspendCount
944             && self.SizeOfContextRecord == other.SizeOfContextRecord
945             && self.ContextRecord == other.ContextRecord
946     }
947 }
948 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
949 impl ::std::cmp::Eq for PSS_THREAD_ENTRY {}
950 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Diagnostics_Debug", feature = "Win32_System_SystemServices"))]
951 unsafe impl ::windows::runtime::Abi for PSS_THREAD_ENTRY {
952     type Abi = Self;
953     type DefaultType = Self;
954 }
955 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
956 #[repr(transparent)]
957 pub struct PSS_THREAD_FLAGS(pub u32);
958 pub const PSS_THREAD_FLAGS_NONE: PSS_THREAD_FLAGS = PSS_THREAD_FLAGS(0u32);
959 pub const PSS_THREAD_FLAGS_TERMINATED: PSS_THREAD_FLAGS = PSS_THREAD_FLAGS(1u32);
960 impl ::std::convert::From<u32> for PSS_THREAD_FLAGS {
from(value: u32) -> Self961     fn from(value: u32) -> Self {
962         Self(value)
963     }
964 }
965 unsafe impl ::windows::runtime::Abi for PSS_THREAD_FLAGS {
966     type Abi = Self;
967     type DefaultType = Self;
968 }
969 impl ::std::ops::BitOr for PSS_THREAD_FLAGS {
970     type Output = Self;
bitor(self, rhs: Self) -> Self971     fn bitor(self, rhs: Self) -> Self {
972         Self(self.0 | rhs.0)
973     }
974 }
975 impl ::std::ops::BitAnd for PSS_THREAD_FLAGS {
976     type Output = Self;
bitand(self, rhs: Self) -> Self977     fn bitand(self, rhs: Self) -> Self {
978         Self(self.0 & rhs.0)
979     }
980 }
981 impl ::std::ops::BitOrAssign for PSS_THREAD_FLAGS {
bitor_assign(&mut self, rhs: Self)982     fn bitor_assign(&mut self, rhs: Self) {
983         self.0.bitor_assign(rhs.0)
984     }
985 }
986 impl ::std::ops::BitAndAssign for PSS_THREAD_FLAGS {
bitand_assign(&mut self, rhs: Self)987     fn bitand_assign(&mut self, rhs: Self) {
988         self.0.bitand_assign(rhs.0)
989     }
990 }
991 impl ::std::ops::Not for PSS_THREAD_FLAGS {
992     type Output = Self;
not(self) -> Self993     fn not(self) -> Self {
994         Self(self.0.not())
995     }
996 }
997 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
998 #[repr(C)]
999 pub struct PSS_THREAD_INFORMATION {
1000     pub ThreadsCaptured: u32,
1001     pub ContextLength: u32,
1002 }
1003 impl PSS_THREAD_INFORMATION {}
1004 impl ::std::default::Default for PSS_THREAD_INFORMATION {
default() -> Self1005     fn default() -> Self {
1006         unsafe { ::std::mem::zeroed() }
1007     }
1008 }
1009 impl ::std::fmt::Debug for PSS_THREAD_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1010     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1011         fmt.debug_struct("PSS_THREAD_INFORMATION").field("ThreadsCaptured", &self.ThreadsCaptured).field("ContextLength", &self.ContextLength).finish()
1012     }
1013 }
1014 impl ::std::cmp::PartialEq for PSS_THREAD_INFORMATION {
eq(&self, other: &Self) -> bool1015     fn eq(&self, other: &Self) -> bool {
1016         self.ThreadsCaptured == other.ThreadsCaptured && self.ContextLength == other.ContextLength
1017     }
1018 }
1019 impl ::std::cmp::Eq for PSS_THREAD_INFORMATION {}
1020 unsafe impl ::windows::runtime::Abi for PSS_THREAD_INFORMATION {
1021     type Abi = Self;
1022     type DefaultType = Self;
1023 }
1024 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1025 #[repr(C)]
1026 #[cfg(feature = "Win32_Foundation")]
1027 pub struct PSS_VA_CLONE_INFORMATION {
1028     pub VaCloneHandle: super::super::super::Foundation::HANDLE,
1029 }
1030 #[cfg(feature = "Win32_Foundation")]
1031 impl PSS_VA_CLONE_INFORMATION {}
1032 #[cfg(feature = "Win32_Foundation")]
1033 impl ::std::default::Default for PSS_VA_CLONE_INFORMATION {
default() -> Self1034     fn default() -> Self {
1035         unsafe { ::std::mem::zeroed() }
1036     }
1037 }
1038 #[cfg(feature = "Win32_Foundation")]
1039 impl ::std::fmt::Debug for PSS_VA_CLONE_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1040     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1041         fmt.debug_struct("PSS_VA_CLONE_INFORMATION").field("VaCloneHandle", &self.VaCloneHandle).finish()
1042     }
1043 }
1044 #[cfg(feature = "Win32_Foundation")]
1045 impl ::std::cmp::PartialEq for PSS_VA_CLONE_INFORMATION {
eq(&self, other: &Self) -> bool1046     fn eq(&self, other: &Self) -> bool {
1047         self.VaCloneHandle == other.VaCloneHandle
1048     }
1049 }
1050 #[cfg(feature = "Win32_Foundation")]
1051 impl ::std::cmp::Eq for PSS_VA_CLONE_INFORMATION {}
1052 #[cfg(feature = "Win32_Foundation")]
1053 unsafe impl ::windows::runtime::Abi for PSS_VA_CLONE_INFORMATION {
1054     type Abi = Self;
1055     type DefaultType = Self;
1056 }
1057 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1058 #[repr(C)]
1059 #[cfg(feature = "Win32_Foundation")]
1060 pub struct PSS_VA_SPACE_ENTRY {
1061     pub BaseAddress: *mut ::std::ffi::c_void,
1062     pub AllocationBase: *mut ::std::ffi::c_void,
1063     pub AllocationProtect: u32,
1064     pub RegionSize: usize,
1065     pub State: u32,
1066     pub Protect: u32,
1067     pub Type: u32,
1068     pub TimeDateStamp: u32,
1069     pub SizeOfImage: u32,
1070     pub ImageBase: *mut ::std::ffi::c_void,
1071     pub CheckSum: u32,
1072     pub MappedFileNameLength: u16,
1073     pub MappedFileName: super::super::super::Foundation::PWSTR,
1074 }
1075 #[cfg(feature = "Win32_Foundation")]
1076 impl PSS_VA_SPACE_ENTRY {}
1077 #[cfg(feature = "Win32_Foundation")]
1078 impl ::std::default::Default for PSS_VA_SPACE_ENTRY {
default() -> Self1079     fn default() -> Self {
1080         unsafe { ::std::mem::zeroed() }
1081     }
1082 }
1083 #[cfg(feature = "Win32_Foundation")]
1084 impl ::std::fmt::Debug for PSS_VA_SPACE_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1085     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1086         fmt.debug_struct("PSS_VA_SPACE_ENTRY")
1087             .field("BaseAddress", &self.BaseAddress)
1088             .field("AllocationBase", &self.AllocationBase)
1089             .field("AllocationProtect", &self.AllocationProtect)
1090             .field("RegionSize", &self.RegionSize)
1091             .field("State", &self.State)
1092             .field("Protect", &self.Protect)
1093             .field("Type", &self.Type)
1094             .field("TimeDateStamp", &self.TimeDateStamp)
1095             .field("SizeOfImage", &self.SizeOfImage)
1096             .field("ImageBase", &self.ImageBase)
1097             .field("CheckSum", &self.CheckSum)
1098             .field("MappedFileNameLength", &self.MappedFileNameLength)
1099             .field("MappedFileName", &self.MappedFileName)
1100             .finish()
1101     }
1102 }
1103 #[cfg(feature = "Win32_Foundation")]
1104 impl ::std::cmp::PartialEq for PSS_VA_SPACE_ENTRY {
eq(&self, other: &Self) -> bool1105     fn eq(&self, other: &Self) -> bool {
1106         self.BaseAddress == other.BaseAddress
1107             && self.AllocationBase == other.AllocationBase
1108             && self.AllocationProtect == other.AllocationProtect
1109             && self.RegionSize == other.RegionSize
1110             && self.State == other.State
1111             && self.Protect == other.Protect
1112             && self.Type == other.Type
1113             && self.TimeDateStamp == other.TimeDateStamp
1114             && self.SizeOfImage == other.SizeOfImage
1115             && self.ImageBase == other.ImageBase
1116             && self.CheckSum == other.CheckSum
1117             && self.MappedFileNameLength == other.MappedFileNameLength
1118             && self.MappedFileName == other.MappedFileName
1119     }
1120 }
1121 #[cfg(feature = "Win32_Foundation")]
1122 impl ::std::cmp::Eq for PSS_VA_SPACE_ENTRY {}
1123 #[cfg(feature = "Win32_Foundation")]
1124 unsafe impl ::windows::runtime::Abi for PSS_VA_SPACE_ENTRY {
1125     type Abi = Self;
1126     type DefaultType = Self;
1127 }
1128 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1129 #[repr(C)]
1130 pub struct PSS_VA_SPACE_INFORMATION {
1131     pub RegionCount: u32,
1132 }
1133 impl PSS_VA_SPACE_INFORMATION {}
1134 impl ::std::default::Default for PSS_VA_SPACE_INFORMATION {
default() -> Self1135     fn default() -> Self {
1136         unsafe { ::std::mem::zeroed() }
1137     }
1138 }
1139 impl ::std::fmt::Debug for PSS_VA_SPACE_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1140     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1141         fmt.debug_struct("PSS_VA_SPACE_INFORMATION").field("RegionCount", &self.RegionCount).finish()
1142     }
1143 }
1144 impl ::std::cmp::PartialEq for PSS_VA_SPACE_INFORMATION {
eq(&self, other: &Self) -> bool1145     fn eq(&self, other: &Self) -> bool {
1146         self.RegionCount == other.RegionCount
1147     }
1148 }
1149 impl ::std::cmp::Eq for PSS_VA_SPACE_INFORMATION {}
1150 unsafe impl ::windows::runtime::Abi for PSS_VA_SPACE_INFORMATION {
1151     type Abi = Self;
1152     type DefaultType = Self;
1153 }
1154 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1155 #[repr(transparent)]
1156 pub struct PSS_WALK_INFORMATION_CLASS(pub i32);
1157 pub const PSS_WALK_AUXILIARY_PAGES: PSS_WALK_INFORMATION_CLASS = PSS_WALK_INFORMATION_CLASS(0i32);
1158 pub const PSS_WALK_VA_SPACE: PSS_WALK_INFORMATION_CLASS = PSS_WALK_INFORMATION_CLASS(1i32);
1159 pub const PSS_WALK_HANDLES: PSS_WALK_INFORMATION_CLASS = PSS_WALK_INFORMATION_CLASS(2i32);
1160 pub const PSS_WALK_THREADS: PSS_WALK_INFORMATION_CLASS = PSS_WALK_INFORMATION_CLASS(3i32);
1161 impl ::std::convert::From<i32> for PSS_WALK_INFORMATION_CLASS {
from(value: i32) -> Self1162     fn from(value: i32) -> Self {
1163         Self(value)
1164     }
1165 }
1166 unsafe impl ::windows::runtime::Abi for PSS_WALK_INFORMATION_CLASS {
1167     type Abi = Self;
1168     type DefaultType = Self;
1169 }
1170 #[cfg(feature = "Win32_Foundation")]
1171 #[inline]
PssCaptureSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(processhandle: Param0, captureflags: PSS_CAPTURE_FLAGS, threadcontextflags: u32, snapshothandle: *mut HPSS) -> u321172 pub unsafe fn PssCaptureSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(processhandle: Param0, captureflags: PSS_CAPTURE_FLAGS, threadcontextflags: u32, snapshothandle: *mut HPSS) -> u32 {
1173     #[cfg(windows)]
1174     {
1175         #[link(name = "windows")]
1176         extern "system" {
1177             fn PssCaptureSnapshot(processhandle: super::super::super::Foundation::HANDLE, captureflags: PSS_CAPTURE_FLAGS, threadcontextflags: u32, snapshothandle: *mut HPSS) -> u32;
1178         }
1179         ::std::mem::transmute(PssCaptureSnapshot(processhandle.into_param().abi(), ::std::mem::transmute(captureflags), ::std::mem::transmute(threadcontextflags), ::std::mem::transmute(snapshothandle)))
1180     }
1181     #[cfg(not(windows))]
1182     unimplemented!("Unsupported target OS");
1183 }
1184 #[cfg(feature = "Win32_Foundation")]
1185 #[inline]
PssDuplicateSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, HPSS>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(sourceprocesshandle: Param0, snapshothandle: Param1, targetprocesshandle: Param2, targetsnapshothandle: *mut HPSS, flags: PSS_DUPLICATE_FLAGS) -> u321186 pub unsafe fn PssDuplicateSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, HPSS>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(sourceprocesshandle: Param0, snapshothandle: Param1, targetprocesshandle: Param2, targetsnapshothandle: *mut HPSS, flags: PSS_DUPLICATE_FLAGS) -> u32 {
1187     #[cfg(windows)]
1188     {
1189         #[link(name = "windows")]
1190         extern "system" {
1191             fn PssDuplicateSnapshot(sourceprocesshandle: super::super::super::Foundation::HANDLE, snapshothandle: HPSS, targetprocesshandle: super::super::super::Foundation::HANDLE, targetsnapshothandle: *mut HPSS, flags: PSS_DUPLICATE_FLAGS) -> u32;
1192         }
1193         ::std::mem::transmute(PssDuplicateSnapshot(sourceprocesshandle.into_param().abi(), snapshothandle.into_param().abi(), targetprocesshandle.into_param().abi(), ::std::mem::transmute(targetsnapshothandle), ::std::mem::transmute(flags)))
1194     }
1195     #[cfg(not(windows))]
1196     unimplemented!("Unsupported target OS");
1197 }
1198 #[cfg(feature = "Win32_Foundation")]
1199 #[inline]
PssFreeSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, HPSS>>(processhandle: Param0, snapshothandle: Param1) -> u321200 pub unsafe fn PssFreeSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, HPSS>>(processhandle: Param0, snapshothandle: Param1) -> u32 {
1201     #[cfg(windows)]
1202     {
1203         #[link(name = "windows")]
1204         extern "system" {
1205             fn PssFreeSnapshot(processhandle: super::super::super::Foundation::HANDLE, snapshothandle: HPSS) -> u32;
1206         }
1207         ::std::mem::transmute(PssFreeSnapshot(processhandle.into_param().abi(), snapshothandle.into_param().abi()))
1208     }
1209     #[cfg(not(windows))]
1210     unimplemented!("Unsupported target OS");
1211 }
1212 #[inline]
PssQuerySnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, HPSS>>(snapshothandle: Param0, informationclass: PSS_QUERY_INFORMATION_CLASS, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u321213 pub unsafe fn PssQuerySnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, HPSS>>(snapshothandle: Param0, informationclass: PSS_QUERY_INFORMATION_CLASS, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u32 {
1214     #[cfg(windows)]
1215     {
1216         #[link(name = "windows")]
1217         extern "system" {
1218             fn PssQuerySnapshot(snapshothandle: HPSS, informationclass: PSS_QUERY_INFORMATION_CLASS, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u32;
1219         }
1220         ::std::mem::transmute(PssQuerySnapshot(snapshothandle.into_param().abi(), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer), ::std::mem::transmute(bufferlength)))
1221     }
1222     #[cfg(not(windows))]
1223     unimplemented!("Unsupported target OS");
1224 }
1225 #[inline]
PssWalkMarkerCreate(allocator: *const PSS_ALLOCATOR, walkmarkerhandle: *mut HPSSWALK) -> u321226 pub unsafe fn PssWalkMarkerCreate(allocator: *const PSS_ALLOCATOR, walkmarkerhandle: *mut HPSSWALK) -> u32 {
1227     #[cfg(windows)]
1228     {
1229         #[link(name = "windows")]
1230         extern "system" {
1231             fn PssWalkMarkerCreate(allocator: *const PSS_ALLOCATOR, walkmarkerhandle: *mut HPSSWALK) -> u32;
1232         }
1233         ::std::mem::transmute(PssWalkMarkerCreate(::std::mem::transmute(allocator), ::std::mem::transmute(walkmarkerhandle)))
1234     }
1235     #[cfg(not(windows))]
1236     unimplemented!("Unsupported target OS");
1237 }
1238 #[inline]
PssWalkMarkerFree<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0) -> u321239 pub unsafe fn PssWalkMarkerFree<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0) -> u32 {
1240     #[cfg(windows)]
1241     {
1242         #[link(name = "windows")]
1243         extern "system" {
1244             fn PssWalkMarkerFree(walkmarkerhandle: HPSSWALK) -> u32;
1245         }
1246         ::std::mem::transmute(PssWalkMarkerFree(walkmarkerhandle.into_param().abi()))
1247     }
1248     #[cfg(not(windows))]
1249     unimplemented!("Unsupported target OS");
1250 }
1251 #[inline]
PssWalkMarkerGetPosition<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0, position: *mut usize) -> u321252 pub unsafe fn PssWalkMarkerGetPosition<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0, position: *mut usize) -> u32 {
1253     #[cfg(windows)]
1254     {
1255         #[link(name = "windows")]
1256         extern "system" {
1257             fn PssWalkMarkerGetPosition(walkmarkerhandle: HPSSWALK, position: *mut usize) -> u32;
1258         }
1259         ::std::mem::transmute(PssWalkMarkerGetPosition(walkmarkerhandle.into_param().abi(), ::std::mem::transmute(position)))
1260     }
1261     #[cfg(not(windows))]
1262     unimplemented!("Unsupported target OS");
1263 }
1264 #[inline]
PssWalkMarkerSeekToBeginning<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0) -> u321265 pub unsafe fn PssWalkMarkerSeekToBeginning<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0) -> u32 {
1266     #[cfg(windows)]
1267     {
1268         #[link(name = "windows")]
1269         extern "system" {
1270             fn PssWalkMarkerSeekToBeginning(walkmarkerhandle: HPSSWALK) -> u32;
1271         }
1272         ::std::mem::transmute(PssWalkMarkerSeekToBeginning(walkmarkerhandle.into_param().abi()))
1273     }
1274     #[cfg(not(windows))]
1275     unimplemented!("Unsupported target OS");
1276 }
1277 #[inline]
PssWalkMarkerSetPosition<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0, position: usize) -> u321278 pub unsafe fn PssWalkMarkerSetPosition<'a, Param0: ::windows::runtime::IntoParam<'a, HPSSWALK>>(walkmarkerhandle: Param0, position: usize) -> u32 {
1279     #[cfg(windows)]
1280     {
1281         #[link(name = "windows")]
1282         extern "system" {
1283             fn PssWalkMarkerSetPosition(walkmarkerhandle: HPSSWALK, position: usize) -> u32;
1284         }
1285         ::std::mem::transmute(PssWalkMarkerSetPosition(walkmarkerhandle.into_param().abi(), ::std::mem::transmute(position)))
1286     }
1287     #[cfg(not(windows))]
1288     unimplemented!("Unsupported target OS");
1289 }
1290 #[inline]
PssWalkSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, HPSS>, Param2: ::windows::runtime::IntoParam<'a, HPSSWALK>>(snapshothandle: Param0, informationclass: PSS_WALK_INFORMATION_CLASS, walkmarkerhandle: Param2, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u321291 pub unsafe fn PssWalkSnapshot<'a, Param0: ::windows::runtime::IntoParam<'a, HPSS>, Param2: ::windows::runtime::IntoParam<'a, HPSSWALK>>(snapshothandle: Param0, informationclass: PSS_WALK_INFORMATION_CLASS, walkmarkerhandle: Param2, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u32 {
1292     #[cfg(windows)]
1293     {
1294         #[link(name = "windows")]
1295         extern "system" {
1296             fn PssWalkSnapshot(snapshothandle: HPSS, informationclass: PSS_WALK_INFORMATION_CLASS, walkmarkerhandle: HPSSWALK, buffer: *mut ::std::ffi::c_void, bufferlength: u32) -> u32;
1297         }
1298         ::std::mem::transmute(PssWalkSnapshot(snapshothandle.into_param().abi(), ::std::mem::transmute(informationclass), walkmarkerhandle.into_param().abi(), ::std::mem::transmute(buffer), ::std::mem::transmute(bufferlength)))
1299     }
1300     #[cfg(not(windows))]
1301     unimplemented!("Unsupported target OS");
1302 }
1303