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