1#![allow(dead_code)]
18#![allow(non_upper_case_globals)]
19#![allow(non_camel_case_types)]
20#![allow(non_snake_case)]
21#![allow(deref_nullptr)] #![allow(clippy::all)]
23#[repr(C)]
24#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct __BindgenBitfieldUnit<Storage> {
26 storage: Storage,
27}
28impl<Storage> __BindgenBitfieldUnit<Storage> {
29 #[inline]
30 pub const fn new(storage: Storage) -> Self {
31 Self { storage }
32 }
33}
34impl<Storage> __BindgenBitfieldUnit<Storage>
35where
36 Storage: AsRef<[u8]> + AsMut<[u8]>,
37{
38 #[inline]
39 fn extract_bit(byte: u8, index: usize) -> bool {
40 let bit_index = if cfg!(target_endian = "big") {
41 7 - (index % 8)
42 } else {
43 index % 8
44 };
45 let mask = 1 << bit_index;
46 byte & mask == mask
47 }
48 #[inline]
49 pub fn get_bit(&self, index: usize) -> bool {
50 debug_assert!(index / 8 < self.storage.as_ref().len());
51 let byte_index = index / 8;
52 let byte = self.storage.as_ref()[byte_index];
53 Self::extract_bit(byte, index)
54 }
55 #[inline]
56 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
57 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
58 let byte_index = index / 8;
59 let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
60 Self::extract_bit(byte, index)
61 }
62 #[inline]
63 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
64 let bit_index = if cfg!(target_endian = "big") {
65 7 - (index % 8)
66 } else {
67 index % 8
68 };
69 let mask = 1 << bit_index;
70 if val {
71 byte | mask
72 } else {
73 byte & !mask
74 }
75 }
76 #[inline]
77 pub fn set_bit(&mut self, index: usize, val: bool) {
78 debug_assert!(index / 8 < self.storage.as_ref().len());
79 let byte_index = index / 8;
80 let byte = &mut self.storage.as_mut()[byte_index];
81 *byte = Self::change_bit(*byte, index, val);
82 }
83 #[inline]
84 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
85 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
86 let byte_index = index / 8;
87 let byte =
88 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
89 *byte = Self::change_bit(*byte, index, val);
90 }
91 #[inline]
92 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
93 debug_assert!(bit_width <= 64);
94 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
95 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
96 let mut val = 0;
97 for i in 0..(bit_width as usize) {
98 if self.get_bit(i + bit_offset) {
99 let index = if cfg!(target_endian = "big") {
100 bit_width as usize - 1 - i
101 } else {
102 i
103 };
104 val |= 1 << index;
105 }
106 }
107 val
108 }
109 #[inline]
110 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
111 debug_assert!(bit_width <= 64);
112 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
113 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
114 let mut val = 0;
115 for i in 0..(bit_width as usize) {
116 if Self::raw_get_bit(this, i + bit_offset) {
117 let index = if cfg!(target_endian = "big") {
118 bit_width as usize - 1 - i
119 } else {
120 i
121 };
122 val |= 1 << index;
123 }
124 }
125 val
126 }
127 #[inline]
128 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
129 debug_assert!(bit_width <= 64);
130 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
131 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
132 for i in 0..(bit_width as usize) {
133 let mask = 1 << i;
134 let val_bit_is_set = val & mask == mask;
135 let index = if cfg!(target_endian = "big") {
136 bit_width as usize - 1 - i
137 } else {
138 i
139 };
140 self.set_bit(index + bit_offset, val_bit_is_set);
141 }
142 }
143 #[inline]
144 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
145 debug_assert!(bit_width <= 64);
146 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
147 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
148 for i in 0..(bit_width as usize) {
149 let mask = 1 << i;
150 let val_bit_is_set = val & mask == mask;
151 let index = if cfg!(target_endian = "big") {
152 bit_width as usize - 1 - i
153 } else {
154 i
155 };
156 Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
157 }
158 }
159}
160#[repr(C)]
161#[derive(Default)]
162pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
163impl<T> __IncompleteArrayField<T> {
164 #[inline]
165 pub const fn new() -> Self {
166 __IncompleteArrayField(::std::marker::PhantomData, [])
167 }
168 #[inline]
169 pub fn as_ptr(&self) -> *const T {
170 self as *const _ as *const T
171 }
172 #[inline]
173 pub fn as_mut_ptr(&mut self) -> *mut T {
174 self as *mut _ as *mut T
175 }
176 #[inline]
177 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
178 ::std::slice::from_raw_parts(self.as_ptr(), len)
179 }
180 #[inline]
181 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
182 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
183 }
184}
185impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
186 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
187 fmt.write_str("__IncompleteArrayField")
188 }
189}
190pub const PERF_PMU_TYPE_SHIFT: u32 = 32;
191pub const PERF_HW_EVENT_MASK: u32 = 4294967295;
192pub const PERF_ATTR_SIZE_VER0: u32 = 64;
193pub const PERF_ATTR_SIZE_VER1: u32 = 72;
194pub const PERF_ATTR_SIZE_VER2: u32 = 80;
195pub const PERF_ATTR_SIZE_VER3: u32 = 96;
196pub const PERF_ATTR_SIZE_VER4: u32 = 104;
197pub const PERF_ATTR_SIZE_VER5: u32 = 112;
198pub const PERF_ATTR_SIZE_VER6: u32 = 120;
199pub const PERF_ATTR_SIZE_VER7: u32 = 128;
200pub const PERF_ATTR_SIZE_VER8: u32 = 136;
201pub const PERF_ATTR_SIZE_VER9: u32 = 144;
202pub const PERF_RECORD_MISC_CPUMODE_MASK: u32 = 7;
203pub const PERF_RECORD_MISC_CPUMODE_UNKNOWN: u32 = 0;
204pub const PERF_RECORD_MISC_KERNEL: u32 = 1;
205pub const PERF_RECORD_MISC_USER: u32 = 2;
206pub const PERF_RECORD_MISC_HYPERVISOR: u32 = 3;
207pub const PERF_RECORD_MISC_GUEST_KERNEL: u32 = 4;
208pub const PERF_RECORD_MISC_GUEST_USER: u32 = 5;
209pub const PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT: u32 = 4096;
210pub const PERF_RECORD_MISC_MMAP_DATA: u32 = 8192;
211pub const PERF_RECORD_MISC_COMM_EXEC: u32 = 8192;
212pub const PERF_RECORD_MISC_FORK_EXEC: u32 = 8192;
213pub const PERF_RECORD_MISC_SWITCH_OUT: u32 = 8192;
214pub const PERF_RECORD_MISC_EXACT_IP: u32 = 16384;
215pub const PERF_RECORD_MISC_SWITCH_OUT_PREEMPT: u32 = 16384;
216pub const PERF_RECORD_MISC_MMAP_BUILD_ID: u32 = 16384;
217pub const PERF_RECORD_MISC_EXT_RESERVED: u32 = 32768;
218pub const PERF_RECORD_KSYMBOL_FLAGS_UNREGISTER: u32 = 1;
219pub const PERF_MAX_STACK_DEPTH: u32 = 127;
220pub const PERF_MAX_CONTEXTS_PER_STACK: u32 = 8;
221pub const PERF_AUX_FLAG_TRUNCATED: u32 = 1;
222pub const PERF_AUX_FLAG_OVERWRITE: u32 = 2;
223pub const PERF_AUX_FLAG_PARTIAL: u32 = 4;
224pub const PERF_AUX_FLAG_COLLISION: u32 = 8;
225pub const PERF_AUX_FLAG_PMU_FORMAT_TYPE_MASK: u32 = 65280;
226pub const PERF_AUX_FLAG_CORESIGHT_FORMAT_CORESIGHT: u32 = 0;
227pub const PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW: u32 = 256;
228pub const PERF_FLAG_FD_NO_GROUP: u32 = 1;
229pub const PERF_FLAG_FD_OUTPUT: u32 = 2;
230pub const PERF_FLAG_PID_CGROUP: u32 = 4;
231pub const PERF_FLAG_FD_CLOEXEC: u32 = 8;
232pub const PERF_MEM_OP_NA: u32 = 1;
233pub const PERF_MEM_OP_LOAD: u32 = 2;
234pub const PERF_MEM_OP_STORE: u32 = 4;
235pub const PERF_MEM_OP_PFETCH: u32 = 8;
236pub const PERF_MEM_OP_EXEC: u32 = 16;
237pub const PERF_MEM_OP_SHIFT: u32 = 0;
238pub const PERF_MEM_LVL_NA: u32 = 1;
239pub const PERF_MEM_LVL_HIT: u32 = 2;
240pub const PERF_MEM_LVL_MISS: u32 = 4;
241pub const PERF_MEM_LVL_L1: u32 = 8;
242pub const PERF_MEM_LVL_LFB: u32 = 16;
243pub const PERF_MEM_LVL_L2: u32 = 32;
244pub const PERF_MEM_LVL_L3: u32 = 64;
245pub const PERF_MEM_LVL_LOC_RAM: u32 = 128;
246pub const PERF_MEM_LVL_REM_RAM1: u32 = 256;
247pub const PERF_MEM_LVL_REM_RAM2: u32 = 512;
248pub const PERF_MEM_LVL_REM_CCE1: u32 = 1024;
249pub const PERF_MEM_LVL_REM_CCE2: u32 = 2048;
250pub const PERF_MEM_LVL_IO: u32 = 4096;
251pub const PERF_MEM_LVL_UNC: u32 = 8192;
252pub const PERF_MEM_LVL_SHIFT: u32 = 5;
253pub const PERF_MEM_REMOTE_REMOTE: u32 = 1;
254pub const PERF_MEM_REMOTE_SHIFT: u32 = 37;
255pub const PERF_MEM_LVLNUM_L1: u32 = 1;
256pub const PERF_MEM_LVLNUM_L2: u32 = 2;
257pub const PERF_MEM_LVLNUM_L3: u32 = 3;
258pub const PERF_MEM_LVLNUM_L4: u32 = 4;
259pub const PERF_MEM_LVLNUM_L2_MHB: u32 = 5;
260pub const PERF_MEM_LVLNUM_MSC: u32 = 6;
261pub const PERF_MEM_LVLNUM_L0: u32 = 7;
262pub const PERF_MEM_LVLNUM_UNC: u32 = 8;
263pub const PERF_MEM_LVLNUM_CXL: u32 = 9;
264pub const PERF_MEM_LVLNUM_IO: u32 = 10;
265pub const PERF_MEM_LVLNUM_ANY_CACHE: u32 = 11;
266pub const PERF_MEM_LVLNUM_LFB: u32 = 12;
267pub const PERF_MEM_LVLNUM_RAM: u32 = 13;
268pub const PERF_MEM_LVLNUM_PMEM: u32 = 14;
269pub const PERF_MEM_LVLNUM_NA: u32 = 15;
270pub const PERF_MEM_LVLNUM_SHIFT: u32 = 33;
271pub const PERF_MEM_SNOOP_NA: u32 = 1;
272pub const PERF_MEM_SNOOP_NONE: u32 = 2;
273pub const PERF_MEM_SNOOP_HIT: u32 = 4;
274pub const PERF_MEM_SNOOP_MISS: u32 = 8;
275pub const PERF_MEM_SNOOP_HITM: u32 = 16;
276pub const PERF_MEM_SNOOP_SHIFT: u32 = 19;
277pub const PERF_MEM_SNOOPX_FWD: u32 = 1;
278pub const PERF_MEM_SNOOPX_PEER: u32 = 2;
279pub const PERF_MEM_SNOOPX_SHIFT: u32 = 38;
280pub const PERF_MEM_LOCK_NA: u32 = 1;
281pub const PERF_MEM_LOCK_LOCKED: u32 = 2;
282pub const PERF_MEM_LOCK_SHIFT: u32 = 24;
283pub const PERF_MEM_TLB_NA: u32 = 1;
284pub const PERF_MEM_TLB_HIT: u32 = 2;
285pub const PERF_MEM_TLB_MISS: u32 = 4;
286pub const PERF_MEM_TLB_L1: u32 = 8;
287pub const PERF_MEM_TLB_L2: u32 = 16;
288pub const PERF_MEM_TLB_WK: u32 = 32;
289pub const PERF_MEM_TLB_OS: u32 = 64;
290pub const PERF_MEM_TLB_SHIFT: u32 = 26;
291pub const PERF_MEM_BLK_NA: u32 = 1;
292pub const PERF_MEM_BLK_DATA: u32 = 2;
293pub const PERF_MEM_BLK_ADDR: u32 = 4;
294pub const PERF_MEM_BLK_SHIFT: u32 = 40;
295pub const PERF_MEM_HOPS_0: u32 = 1;
296pub const PERF_MEM_HOPS_1: u32 = 2;
297pub const PERF_MEM_HOPS_2: u32 = 3;
298pub const PERF_MEM_HOPS_3: u32 = 4;
299pub const PERF_MEM_HOPS_SHIFT: u32 = 43;
300pub const PERF_MEM_REGION_NA: u32 = 0;
301pub const PERF_MEM_REGION_RSVD: u32 = 1;
302pub const PERF_MEM_REGION_L_SHARE: u32 = 2;
303pub const PERF_MEM_REGION_L_NON_SHARE: u32 = 3;
304pub const PERF_MEM_REGION_O_IO: u32 = 4;
305pub const PERF_MEM_REGION_O_SHARE: u32 = 5;
306pub const PERF_MEM_REGION_O_NON_SHARE: u32 = 6;
307pub const PERF_MEM_REGION_MMIO: u32 = 7;
308pub const PERF_MEM_REGION_MEM0: u32 = 8;
309pub const PERF_MEM_REGION_MEM1: u32 = 9;
310pub const PERF_MEM_REGION_MEM2: u32 = 10;
311pub const PERF_MEM_REGION_MEM3: u32 = 11;
312pub const PERF_MEM_REGION_MEM4: u32 = 12;
313pub const PERF_MEM_REGION_MEM5: u32 = 13;
314pub const PERF_MEM_REGION_MEM6: u32 = 14;
315pub const PERF_MEM_REGION_MEM7: u32 = 15;
316pub const PERF_MEM_REGION_SHIFT: u32 = 46;
317pub const PERF_BRANCH_ENTRY_INFO_BITS_MAX: u32 = 33;
318pub const __NR_perf_event_open: u32 = 298;
319pub type __u8 = ::std::os::raw::c_uchar;
320pub type __u16 = ::std::os::raw::c_ushort;
321pub type __s32 = ::std::os::raw::c_int;
322pub type __u32 = ::std::os::raw::c_uint;
323pub type __s64 = ::std::os::raw::c_longlong;
324pub type __u64 = ::std::os::raw::c_ulonglong;
325pub const PERF_TYPE_HARDWARE: perf_type_id = 0;
326pub const PERF_TYPE_SOFTWARE: perf_type_id = 1;
327pub const PERF_TYPE_TRACEPOINT: perf_type_id = 2;
328pub const PERF_TYPE_HW_CACHE: perf_type_id = 3;
329pub const PERF_TYPE_RAW: perf_type_id = 4;
330pub const PERF_TYPE_BREAKPOINT: perf_type_id = 5;
331pub const PERF_TYPE_MAX: perf_type_id = 6;
332pub type perf_type_id = ::std::os::raw::c_uint;
333pub const PERF_COUNT_HW_CPU_CYCLES: perf_hw_id = 0;
334pub const PERF_COUNT_HW_INSTRUCTIONS: perf_hw_id = 1;
335pub const PERF_COUNT_HW_CACHE_REFERENCES: perf_hw_id = 2;
336pub const PERF_COUNT_HW_CACHE_MISSES: perf_hw_id = 3;
337pub const PERF_COUNT_HW_BRANCH_INSTRUCTIONS: perf_hw_id = 4;
338pub const PERF_COUNT_HW_BRANCH_MISSES: perf_hw_id = 5;
339pub const PERF_COUNT_HW_BUS_CYCLES: perf_hw_id = 6;
340pub const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND: perf_hw_id = 7;
341pub const PERF_COUNT_HW_STALLED_CYCLES_BACKEND: perf_hw_id = 8;
342pub const PERF_COUNT_HW_REF_CPU_CYCLES: perf_hw_id = 9;
343pub const PERF_COUNT_HW_MAX: perf_hw_id = 10;
344pub type perf_hw_id = ::std::os::raw::c_uint;
345pub const PERF_COUNT_HW_CACHE_L1D: perf_hw_cache_id = 0;
346pub const PERF_COUNT_HW_CACHE_L1I: perf_hw_cache_id = 1;
347pub const PERF_COUNT_HW_CACHE_LL: perf_hw_cache_id = 2;
348pub const PERF_COUNT_HW_CACHE_DTLB: perf_hw_cache_id = 3;
349pub const PERF_COUNT_HW_CACHE_ITLB: perf_hw_cache_id = 4;
350pub const PERF_COUNT_HW_CACHE_BPU: perf_hw_cache_id = 5;
351pub const PERF_COUNT_HW_CACHE_NODE: perf_hw_cache_id = 6;
352pub const PERF_COUNT_HW_CACHE_MAX: perf_hw_cache_id = 7;
353pub type perf_hw_cache_id = ::std::os::raw::c_uint;
354pub const PERF_COUNT_HW_CACHE_OP_READ: perf_hw_cache_op_id = 0;
355pub const PERF_COUNT_HW_CACHE_OP_WRITE: perf_hw_cache_op_id = 1;
356pub const PERF_COUNT_HW_CACHE_OP_PREFETCH: perf_hw_cache_op_id = 2;
357pub const PERF_COUNT_HW_CACHE_OP_MAX: perf_hw_cache_op_id = 3;
358pub type perf_hw_cache_op_id = ::std::os::raw::c_uint;
359pub const PERF_COUNT_HW_CACHE_RESULT_ACCESS: perf_hw_cache_op_result_id = 0;
360pub const PERF_COUNT_HW_CACHE_RESULT_MISS: perf_hw_cache_op_result_id = 1;
361pub const PERF_COUNT_HW_CACHE_RESULT_MAX: perf_hw_cache_op_result_id = 2;
362pub type perf_hw_cache_op_result_id = ::std::os::raw::c_uint;
363pub const PERF_COUNT_SW_CPU_CLOCK: perf_sw_ids = 0;
364pub const PERF_COUNT_SW_TASK_CLOCK: perf_sw_ids = 1;
365pub const PERF_COUNT_SW_PAGE_FAULTS: perf_sw_ids = 2;
366pub const PERF_COUNT_SW_CONTEXT_SWITCHES: perf_sw_ids = 3;
367pub const PERF_COUNT_SW_CPU_MIGRATIONS: perf_sw_ids = 4;
368pub const PERF_COUNT_SW_PAGE_FAULTS_MIN: perf_sw_ids = 5;
369pub const PERF_COUNT_SW_PAGE_FAULTS_MAJ: perf_sw_ids = 6;
370pub const PERF_COUNT_SW_ALIGNMENT_FAULTS: perf_sw_ids = 7;
371pub const PERF_COUNT_SW_EMULATION_FAULTS: perf_sw_ids = 8;
372pub const PERF_COUNT_SW_DUMMY: perf_sw_ids = 9;
373pub const PERF_COUNT_SW_BPF_OUTPUT: perf_sw_ids = 10;
374pub const PERF_COUNT_SW_CGROUP_SWITCHES: perf_sw_ids = 11;
375pub const PERF_COUNT_SW_MAX: perf_sw_ids = 12;
376pub type perf_sw_ids = ::std::os::raw::c_uint;
377pub const PERF_SAMPLE_IP: perf_event_sample_format = 1;
378pub const PERF_SAMPLE_TID: perf_event_sample_format = 2;
379pub const PERF_SAMPLE_TIME: perf_event_sample_format = 4;
380pub const PERF_SAMPLE_ADDR: perf_event_sample_format = 8;
381pub const PERF_SAMPLE_READ: perf_event_sample_format = 16;
382pub const PERF_SAMPLE_CALLCHAIN: perf_event_sample_format = 32;
383pub const PERF_SAMPLE_ID: perf_event_sample_format = 64;
384pub const PERF_SAMPLE_CPU: perf_event_sample_format = 128;
385pub const PERF_SAMPLE_PERIOD: perf_event_sample_format = 256;
386pub const PERF_SAMPLE_STREAM_ID: perf_event_sample_format = 512;
387pub const PERF_SAMPLE_RAW: perf_event_sample_format = 1024;
388pub const PERF_SAMPLE_BRANCH_STACK: perf_event_sample_format = 2048;
389pub const PERF_SAMPLE_REGS_USER: perf_event_sample_format = 4096;
390pub const PERF_SAMPLE_STACK_USER: perf_event_sample_format = 8192;
391pub const PERF_SAMPLE_WEIGHT: perf_event_sample_format = 16384;
392pub const PERF_SAMPLE_DATA_SRC: perf_event_sample_format = 32768;
393pub const PERF_SAMPLE_IDENTIFIER: perf_event_sample_format = 65536;
394pub const PERF_SAMPLE_TRANSACTION: perf_event_sample_format = 131072;
395pub const PERF_SAMPLE_REGS_INTR: perf_event_sample_format = 262144;
396pub const PERF_SAMPLE_PHYS_ADDR: perf_event_sample_format = 524288;
397pub const PERF_SAMPLE_AUX: perf_event_sample_format = 1048576;
398pub const PERF_SAMPLE_CGROUP: perf_event_sample_format = 2097152;
399pub const PERF_SAMPLE_DATA_PAGE_SIZE: perf_event_sample_format = 4194304;
400pub const PERF_SAMPLE_CODE_PAGE_SIZE: perf_event_sample_format = 8388608;
401pub const PERF_SAMPLE_WEIGHT_STRUCT: perf_event_sample_format = 16777216;
402pub const PERF_SAMPLE_MAX: perf_event_sample_format = 33554432;
403pub type perf_event_sample_format = ::std::os::raw::c_uint;
404pub const PERF_SAMPLE_BRANCH_USER_SHIFT: perf_branch_sample_type_shift = 0;
405pub const PERF_SAMPLE_BRANCH_KERNEL_SHIFT: perf_branch_sample_type_shift = 1;
406pub const PERF_SAMPLE_BRANCH_HV_SHIFT: perf_branch_sample_type_shift = 2;
407pub const PERF_SAMPLE_BRANCH_ANY_SHIFT: perf_branch_sample_type_shift = 3;
408pub const PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT: perf_branch_sample_type_shift = 4;
409pub const PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT: perf_branch_sample_type_shift = 5;
410pub const PERF_SAMPLE_BRANCH_IND_CALL_SHIFT: perf_branch_sample_type_shift = 6;
411pub const PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT: perf_branch_sample_type_shift = 7;
412pub const PERF_SAMPLE_BRANCH_IN_TX_SHIFT: perf_branch_sample_type_shift = 8;
413pub const PERF_SAMPLE_BRANCH_NO_TX_SHIFT: perf_branch_sample_type_shift = 9;
414pub const PERF_SAMPLE_BRANCH_COND_SHIFT: perf_branch_sample_type_shift = 10;
415pub const PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT: perf_branch_sample_type_shift = 11;
416pub const PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT: perf_branch_sample_type_shift = 12;
417pub const PERF_SAMPLE_BRANCH_CALL_SHIFT: perf_branch_sample_type_shift = 13;
418pub const PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT: perf_branch_sample_type_shift = 14;
419pub const PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT: perf_branch_sample_type_shift = 15;
420pub const PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT: perf_branch_sample_type_shift = 16;
421pub const PERF_SAMPLE_BRANCH_HW_INDEX_SHIFT: perf_branch_sample_type_shift = 17;
422pub const PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT: perf_branch_sample_type_shift = 18;
423pub const PERF_SAMPLE_BRANCH_COUNTERS_SHIFT: perf_branch_sample_type_shift = 19;
424pub const PERF_SAMPLE_BRANCH_MAX_SHIFT: perf_branch_sample_type_shift = 20;
425pub type perf_branch_sample_type_shift = ::std::os::raw::c_uint;
426pub const PERF_SAMPLE_BRANCH_USER: perf_branch_sample_type = 1;
427pub const PERF_SAMPLE_BRANCH_KERNEL: perf_branch_sample_type = 2;
428pub const PERF_SAMPLE_BRANCH_HV: perf_branch_sample_type = 4;
429pub const PERF_SAMPLE_BRANCH_ANY: perf_branch_sample_type = 8;
430pub const PERF_SAMPLE_BRANCH_ANY_CALL: perf_branch_sample_type = 16;
431pub const PERF_SAMPLE_BRANCH_ANY_RETURN: perf_branch_sample_type = 32;
432pub const PERF_SAMPLE_BRANCH_IND_CALL: perf_branch_sample_type = 64;
433pub const PERF_SAMPLE_BRANCH_ABORT_TX: perf_branch_sample_type = 128;
434pub const PERF_SAMPLE_BRANCH_IN_TX: perf_branch_sample_type = 256;
435pub const PERF_SAMPLE_BRANCH_NO_TX: perf_branch_sample_type = 512;
436pub const PERF_SAMPLE_BRANCH_COND: perf_branch_sample_type = 1024;
437pub const PERF_SAMPLE_BRANCH_CALL_STACK: perf_branch_sample_type = 2048;
438pub const PERF_SAMPLE_BRANCH_IND_JUMP: perf_branch_sample_type = 4096;
439pub const PERF_SAMPLE_BRANCH_CALL: perf_branch_sample_type = 8192;
440pub const PERF_SAMPLE_BRANCH_NO_FLAGS: perf_branch_sample_type = 16384;
441pub const PERF_SAMPLE_BRANCH_NO_CYCLES: perf_branch_sample_type = 32768;
442pub const PERF_SAMPLE_BRANCH_TYPE_SAVE: perf_branch_sample_type = 65536;
443pub const PERF_SAMPLE_BRANCH_HW_INDEX: perf_branch_sample_type = 131072;
444pub const PERF_SAMPLE_BRANCH_PRIV_SAVE: perf_branch_sample_type = 262144;
445pub const PERF_SAMPLE_BRANCH_COUNTERS: perf_branch_sample_type = 524288;
446pub const PERF_SAMPLE_BRANCH_MAX: perf_branch_sample_type = 1048576;
447pub type perf_branch_sample_type = ::std::os::raw::c_uint;
448pub const PERF_BR_UNKNOWN: _bindgen_ty_1 = 0;
449pub const PERF_BR_COND: _bindgen_ty_1 = 1;
450pub const PERF_BR_UNCOND: _bindgen_ty_1 = 2;
451pub const PERF_BR_IND: _bindgen_ty_1 = 3;
452pub const PERF_BR_CALL: _bindgen_ty_1 = 4;
453pub const PERF_BR_IND_CALL: _bindgen_ty_1 = 5;
454pub const PERF_BR_RET: _bindgen_ty_1 = 6;
455pub const PERF_BR_SYSCALL: _bindgen_ty_1 = 7;
456pub const PERF_BR_SYSRET: _bindgen_ty_1 = 8;
457pub const PERF_BR_COND_CALL: _bindgen_ty_1 = 9;
458pub const PERF_BR_COND_RET: _bindgen_ty_1 = 10;
459pub const PERF_BR_ERET: _bindgen_ty_1 = 11;
460pub const PERF_BR_IRQ: _bindgen_ty_1 = 12;
461pub const PERF_BR_SERROR: _bindgen_ty_1 = 13;
462pub const PERF_BR_NO_TX: _bindgen_ty_1 = 14;
463pub const PERF_BR_EXTEND_ABI: _bindgen_ty_1 = 15;
464pub const PERF_BR_MAX: _bindgen_ty_1 = 16;
465pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
466pub const PERF_BR_SPEC_NA: _bindgen_ty_2 = 0;
467pub const PERF_BR_SPEC_WRONG_PATH: _bindgen_ty_2 = 1;
468pub const PERF_BR_NON_SPEC_CORRECT_PATH: _bindgen_ty_2 = 2;
469pub const PERF_BR_SPEC_CORRECT_PATH: _bindgen_ty_2 = 3;
470pub const PERF_BR_SPEC_MAX: _bindgen_ty_2 = 4;
471pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
472pub const PERF_BR_NEW_FAULT_ALGN: _bindgen_ty_3 = 0;
473pub const PERF_BR_NEW_FAULT_DATA: _bindgen_ty_3 = 1;
474pub const PERF_BR_NEW_FAULT_INST: _bindgen_ty_3 = 2;
475pub const PERF_BR_NEW_ARCH_1: _bindgen_ty_3 = 3;
476pub const PERF_BR_NEW_ARCH_2: _bindgen_ty_3 = 4;
477pub const PERF_BR_NEW_ARCH_3: _bindgen_ty_3 = 5;
478pub const PERF_BR_NEW_ARCH_4: _bindgen_ty_3 = 6;
479pub const PERF_BR_NEW_ARCH_5: _bindgen_ty_3 = 7;
480pub const PERF_BR_NEW_MAX: _bindgen_ty_3 = 8;
481pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
482pub const PERF_BR_PRIV_UNKNOWN: _bindgen_ty_4 = 0;
483pub const PERF_BR_PRIV_USER: _bindgen_ty_4 = 1;
484pub const PERF_BR_PRIV_KERNEL: _bindgen_ty_4 = 2;
485pub const PERF_BR_PRIV_HV: _bindgen_ty_4 = 3;
486pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
487pub const PERF_SAMPLE_REGS_ABI_NONE: perf_sample_regs_abi = 0;
488pub const PERF_SAMPLE_REGS_ABI_32: perf_sample_regs_abi = 1;
489pub const PERF_SAMPLE_REGS_ABI_64: perf_sample_regs_abi = 2;
490pub type perf_sample_regs_abi = ::std::os::raw::c_uint;
491pub const PERF_TXN_ELISION: _bindgen_ty_5 = 1;
492pub const PERF_TXN_TRANSACTION: _bindgen_ty_5 = 2;
493pub const PERF_TXN_SYNC: _bindgen_ty_5 = 4;
494pub const PERF_TXN_ASYNC: _bindgen_ty_5 = 8;
495pub const PERF_TXN_RETRY: _bindgen_ty_5 = 16;
496pub const PERF_TXN_CONFLICT: _bindgen_ty_5 = 32;
497pub const PERF_TXN_CAPACITY_WRITE: _bindgen_ty_5 = 64;
498pub const PERF_TXN_CAPACITY_READ: _bindgen_ty_5 = 128;
499pub const PERF_TXN_MAX: _bindgen_ty_5 = 256;
500pub const PERF_TXN_ABORT_MASK: _bindgen_ty_5 = 18446744069414584320;
501pub const PERF_TXN_ABORT_SHIFT: _bindgen_ty_5 = 32;
502pub type _bindgen_ty_5 = ::std::os::raw::c_ulong;
503pub const PERF_FORMAT_TOTAL_TIME_ENABLED: perf_event_read_format = 1;
504pub const PERF_FORMAT_TOTAL_TIME_RUNNING: perf_event_read_format = 2;
505pub const PERF_FORMAT_ID: perf_event_read_format = 4;
506pub const PERF_FORMAT_GROUP: perf_event_read_format = 8;
507pub const PERF_FORMAT_LOST: perf_event_read_format = 16;
508pub const PERF_FORMAT_MAX: perf_event_read_format = 32;
509pub type perf_event_read_format = ::std::os::raw::c_uint;
510#[repr(C)]
511#[derive(Copy, Clone)]
512pub struct perf_event_attr {
513 pub type_: __u32,
514 pub size: __u32,
515 pub config: __u64,
516 pub __bindgen_anon_1: perf_event_attr__bindgen_ty_1,
517 pub sample_type: __u64,
518 pub read_format: __u64,
519 pub _bitfield_align_1: [u32; 0],
520 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
521 pub __bindgen_anon_2: perf_event_attr__bindgen_ty_2,
522 pub bp_type: __u32,
523 pub __bindgen_anon_3: perf_event_attr__bindgen_ty_3,
524 pub __bindgen_anon_4: perf_event_attr__bindgen_ty_4,
525 pub branch_sample_type: __u64,
526 pub sample_regs_user: __u64,
527 pub sample_stack_user: __u32,
528 pub clockid: __s32,
529 pub sample_regs_intr: __u64,
530 pub aux_watermark: __u32,
531 pub sample_max_stack: __u16,
532 pub __reserved_2: __u16,
533 pub aux_sample_size: __u32,
534 pub __bindgen_anon_5: perf_event_attr__bindgen_ty_5,
535 pub sig_data: __u64,
536 pub config3: __u64,
537 pub config4: __u64,
538}
539#[repr(C)]
540#[derive(Copy, Clone)]
541pub union perf_event_attr__bindgen_ty_1 {
542 pub sample_period: __u64,
543 pub sample_freq: __u64,
544}
545#[allow(clippy::unnecessary_operation, clippy::identity_op)]
546const _: () = {
547 ["Size of perf_event_attr__bindgen_ty_1"]
548 [::std::mem::size_of::<perf_event_attr__bindgen_ty_1>() - 8usize];
549 ["Alignment of perf_event_attr__bindgen_ty_1"]
550 [::std::mem::align_of::<perf_event_attr__bindgen_ty_1>() - 8usize];
551 ["Offset of field: perf_event_attr__bindgen_ty_1::sample_period"]
552 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_1, sample_period) - 0usize];
553 ["Offset of field: perf_event_attr__bindgen_ty_1::sample_freq"]
554 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_1, sample_freq) - 0usize];
555};
556impl Default for perf_event_attr__bindgen_ty_1 {
557 fn default() -> Self {
558 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
559 unsafe {
560 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
561 s.assume_init()
562 }
563 }
564}
565impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_1 {
566 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
567 write!(f, "perf_event_attr__bindgen_ty_1 {{ union }}")
568 }
569}
570#[repr(C)]
571#[derive(Copy, Clone)]
572pub union perf_event_attr__bindgen_ty_2 {
573 pub wakeup_events: __u32,
574 pub wakeup_watermark: __u32,
575}
576#[allow(clippy::unnecessary_operation, clippy::identity_op)]
577const _: () = {
578 ["Size of perf_event_attr__bindgen_ty_2"]
579 [::std::mem::size_of::<perf_event_attr__bindgen_ty_2>() - 4usize];
580 ["Alignment of perf_event_attr__bindgen_ty_2"]
581 [::std::mem::align_of::<perf_event_attr__bindgen_ty_2>() - 4usize];
582 ["Offset of field: perf_event_attr__bindgen_ty_2::wakeup_events"]
583 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_2, wakeup_events) - 0usize];
584 ["Offset of field: perf_event_attr__bindgen_ty_2::wakeup_watermark"]
585 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_2, wakeup_watermark) - 0usize];
586};
587impl Default for perf_event_attr__bindgen_ty_2 {
588 fn default() -> Self {
589 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
590 unsafe {
591 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
592 s.assume_init()
593 }
594 }
595}
596impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_2 {
597 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
598 write!(f, "perf_event_attr__bindgen_ty_2 {{ union }}")
599 }
600}
601#[repr(C)]
602#[derive(Copy, Clone)]
603pub union perf_event_attr__bindgen_ty_3 {
604 pub bp_addr: __u64,
605 pub kprobe_func: __u64,
606 pub uprobe_path: __u64,
607 pub config1: __u64,
608}
609#[allow(clippy::unnecessary_operation, clippy::identity_op)]
610const _: () = {
611 ["Size of perf_event_attr__bindgen_ty_3"]
612 [::std::mem::size_of::<perf_event_attr__bindgen_ty_3>() - 8usize];
613 ["Alignment of perf_event_attr__bindgen_ty_3"]
614 [::std::mem::align_of::<perf_event_attr__bindgen_ty_3>() - 8usize];
615 ["Offset of field: perf_event_attr__bindgen_ty_3::bp_addr"]
616 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_3, bp_addr) - 0usize];
617 ["Offset of field: perf_event_attr__bindgen_ty_3::kprobe_func"]
618 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_3, kprobe_func) - 0usize];
619 ["Offset of field: perf_event_attr__bindgen_ty_3::uprobe_path"]
620 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_3, uprobe_path) - 0usize];
621 ["Offset of field: perf_event_attr__bindgen_ty_3::config1"]
622 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_3, config1) - 0usize];
623};
624impl Default for perf_event_attr__bindgen_ty_3 {
625 fn default() -> Self {
626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
627 unsafe {
628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
629 s.assume_init()
630 }
631 }
632}
633impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_3 {
634 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
635 write!(f, "perf_event_attr__bindgen_ty_3 {{ union }}")
636 }
637}
638#[repr(C)]
639#[derive(Copy, Clone)]
640pub union perf_event_attr__bindgen_ty_4 {
641 pub bp_len: __u64,
642 pub kprobe_addr: __u64,
643 pub probe_offset: __u64,
644 pub config2: __u64,
645}
646#[allow(clippy::unnecessary_operation, clippy::identity_op)]
647const _: () = {
648 ["Size of perf_event_attr__bindgen_ty_4"]
649 [::std::mem::size_of::<perf_event_attr__bindgen_ty_4>() - 8usize];
650 ["Alignment of perf_event_attr__bindgen_ty_4"]
651 [::std::mem::align_of::<perf_event_attr__bindgen_ty_4>() - 8usize];
652 ["Offset of field: perf_event_attr__bindgen_ty_4::bp_len"]
653 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_4, bp_len) - 0usize];
654 ["Offset of field: perf_event_attr__bindgen_ty_4::kprobe_addr"]
655 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_4, kprobe_addr) - 0usize];
656 ["Offset of field: perf_event_attr__bindgen_ty_4::probe_offset"]
657 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_4, probe_offset) - 0usize];
658 ["Offset of field: perf_event_attr__bindgen_ty_4::config2"]
659 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_4, config2) - 0usize];
660};
661impl Default for perf_event_attr__bindgen_ty_4 {
662 fn default() -> Self {
663 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
664 unsafe {
665 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
666 s.assume_init()
667 }
668 }
669}
670impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_4 {
671 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
672 write!(f, "perf_event_attr__bindgen_ty_4 {{ union }}")
673 }
674}
675#[repr(C)]
676#[derive(Copy, Clone)]
677pub union perf_event_attr__bindgen_ty_5 {
678 pub aux_action: __u32,
679 pub __bindgen_anon_1: perf_event_attr__bindgen_ty_5__bindgen_ty_1,
680}
681#[repr(C)]
682#[derive(Debug, Default, Copy, Clone)]
683pub struct perf_event_attr__bindgen_ty_5__bindgen_ty_1 {
684 pub _bitfield_align_1: [u32; 0],
685 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
686}
687#[allow(clippy::unnecessary_operation, clippy::identity_op)]
688const _: () = {
689 ["Size of perf_event_attr__bindgen_ty_5__bindgen_ty_1"]
690 [::std::mem::size_of::<perf_event_attr__bindgen_ty_5__bindgen_ty_1>() - 4usize];
691 ["Alignment of perf_event_attr__bindgen_ty_5__bindgen_ty_1"]
692 [::std::mem::align_of::<perf_event_attr__bindgen_ty_5__bindgen_ty_1>() - 4usize];
693};
694impl perf_event_attr__bindgen_ty_5__bindgen_ty_1 {
695 #[inline]
696 pub fn aux_start_paused(&self) -> __u32 {
697 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
698 }
699 #[inline]
700 pub fn set_aux_start_paused(&mut self, val: __u32) {
701 unsafe {
702 let val: u32 = ::std::mem::transmute(val);
703 self._bitfield_1.set(0usize, 1u8, val as u64)
704 }
705 }
706 #[inline]
707 pub unsafe fn aux_start_paused_raw(this: *const Self) -> __u32 {
708 unsafe {
709 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
710 ::std::ptr::addr_of!((*this)._bitfield_1),
711 0usize,
712 1u8,
713 ) as u32)
714 }
715 }
716 #[inline]
717 pub unsafe fn set_aux_start_paused_raw(this: *mut Self, val: __u32) {
718 unsafe {
719 let val: u32 = ::std::mem::transmute(val);
720 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
721 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
722 0usize,
723 1u8,
724 val as u64,
725 )
726 }
727 }
728 #[inline]
729 pub fn aux_pause(&self) -> __u32 {
730 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
731 }
732 #[inline]
733 pub fn set_aux_pause(&mut self, val: __u32) {
734 unsafe {
735 let val: u32 = ::std::mem::transmute(val);
736 self._bitfield_1.set(1usize, 1u8, val as u64)
737 }
738 }
739 #[inline]
740 pub unsafe fn aux_pause_raw(this: *const Self) -> __u32 {
741 unsafe {
742 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
743 ::std::ptr::addr_of!((*this)._bitfield_1),
744 1usize,
745 1u8,
746 ) as u32)
747 }
748 }
749 #[inline]
750 pub unsafe fn set_aux_pause_raw(this: *mut Self, val: __u32) {
751 unsafe {
752 let val: u32 = ::std::mem::transmute(val);
753 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
754 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
755 1usize,
756 1u8,
757 val as u64,
758 )
759 }
760 }
761 #[inline]
762 pub fn aux_resume(&self) -> __u32 {
763 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
764 }
765 #[inline]
766 pub fn set_aux_resume(&mut self, val: __u32) {
767 unsafe {
768 let val: u32 = ::std::mem::transmute(val);
769 self._bitfield_1.set(2usize, 1u8, val as u64)
770 }
771 }
772 #[inline]
773 pub unsafe fn aux_resume_raw(this: *const Self) -> __u32 {
774 unsafe {
775 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
776 ::std::ptr::addr_of!((*this)._bitfield_1),
777 2usize,
778 1u8,
779 ) as u32)
780 }
781 }
782 #[inline]
783 pub unsafe fn set_aux_resume_raw(this: *mut Self, val: __u32) {
784 unsafe {
785 let val: u32 = ::std::mem::transmute(val);
786 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
787 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
788 2usize,
789 1u8,
790 val as u64,
791 )
792 }
793 }
794 #[inline]
795 pub fn __reserved_3(&self) -> __u32 {
796 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) }
797 }
798 #[inline]
799 pub fn set___reserved_3(&mut self, val: __u32) {
800 unsafe {
801 let val: u32 = ::std::mem::transmute(val);
802 self._bitfield_1.set(3usize, 29u8, val as u64)
803 }
804 }
805 #[inline]
806 pub unsafe fn __reserved_3_raw(this: *const Self) -> __u32 {
807 unsafe {
808 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
809 ::std::ptr::addr_of!((*this)._bitfield_1),
810 3usize,
811 29u8,
812 ) as u32)
813 }
814 }
815 #[inline]
816 pub unsafe fn set___reserved_3_raw(this: *mut Self, val: __u32) {
817 unsafe {
818 let val: u32 = ::std::mem::transmute(val);
819 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
820 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
821 3usize,
822 29u8,
823 val as u64,
824 )
825 }
826 }
827 #[inline]
828 pub fn new_bitfield_1(
829 aux_start_paused: __u32,
830 aux_pause: __u32,
831 aux_resume: __u32,
832 __reserved_3: __u32,
833 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
834 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
835 __bindgen_bitfield_unit.set(0usize, 1u8, {
836 let aux_start_paused: u32 = unsafe { ::std::mem::transmute(aux_start_paused) };
837 aux_start_paused as u64
838 });
839 __bindgen_bitfield_unit.set(1usize, 1u8, {
840 let aux_pause: u32 = unsafe { ::std::mem::transmute(aux_pause) };
841 aux_pause as u64
842 });
843 __bindgen_bitfield_unit.set(2usize, 1u8, {
844 let aux_resume: u32 = unsafe { ::std::mem::transmute(aux_resume) };
845 aux_resume as u64
846 });
847 __bindgen_bitfield_unit.set(3usize, 29u8, {
848 let __reserved_3: u32 = unsafe { ::std::mem::transmute(__reserved_3) };
849 __reserved_3 as u64
850 });
851 __bindgen_bitfield_unit
852 }
853}
854#[allow(clippy::unnecessary_operation, clippy::identity_op)]
855const _: () = {
856 ["Size of perf_event_attr__bindgen_ty_5"]
857 [::std::mem::size_of::<perf_event_attr__bindgen_ty_5>() - 4usize];
858 ["Alignment of perf_event_attr__bindgen_ty_5"]
859 [::std::mem::align_of::<perf_event_attr__bindgen_ty_5>() - 4usize];
860 ["Offset of field: perf_event_attr__bindgen_ty_5::aux_action"]
861 [::std::mem::offset_of!(perf_event_attr__bindgen_ty_5, aux_action) - 0usize];
862};
863impl Default for perf_event_attr__bindgen_ty_5 {
864 fn default() -> Self {
865 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
866 unsafe {
867 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
868 s.assume_init()
869 }
870 }
871}
872impl ::std::fmt::Debug for perf_event_attr__bindgen_ty_5 {
873 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
874 write!(f, "perf_event_attr__bindgen_ty_5 {{ union }}")
875 }
876}
877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
878const _: () = {
879 ["Size of perf_event_attr"][::std::mem::size_of::<perf_event_attr>() - 144usize];
880 ["Alignment of perf_event_attr"][::std::mem::align_of::<perf_event_attr>() - 8usize];
881 ["Offset of field: perf_event_attr::type_"]
882 [::std::mem::offset_of!(perf_event_attr, type_) - 0usize];
883 ["Offset of field: perf_event_attr::size"]
884 [::std::mem::offset_of!(perf_event_attr, size) - 4usize];
885 ["Offset of field: perf_event_attr::config"]
886 [::std::mem::offset_of!(perf_event_attr, config) - 8usize];
887 ["Offset of field: perf_event_attr::sample_type"]
888 [::std::mem::offset_of!(perf_event_attr, sample_type) - 24usize];
889 ["Offset of field: perf_event_attr::read_format"]
890 [::std::mem::offset_of!(perf_event_attr, read_format) - 32usize];
891 ["Offset of field: perf_event_attr::bp_type"]
892 [::std::mem::offset_of!(perf_event_attr, bp_type) - 52usize];
893 ["Offset of field: perf_event_attr::branch_sample_type"]
894 [::std::mem::offset_of!(perf_event_attr, branch_sample_type) - 72usize];
895 ["Offset of field: perf_event_attr::sample_regs_user"]
896 [::std::mem::offset_of!(perf_event_attr, sample_regs_user) - 80usize];
897 ["Offset of field: perf_event_attr::sample_stack_user"]
898 [::std::mem::offset_of!(perf_event_attr, sample_stack_user) - 88usize];
899 ["Offset of field: perf_event_attr::clockid"]
900 [::std::mem::offset_of!(perf_event_attr, clockid) - 92usize];
901 ["Offset of field: perf_event_attr::sample_regs_intr"]
902 [::std::mem::offset_of!(perf_event_attr, sample_regs_intr) - 96usize];
903 ["Offset of field: perf_event_attr::aux_watermark"]
904 [::std::mem::offset_of!(perf_event_attr, aux_watermark) - 104usize];
905 ["Offset of field: perf_event_attr::sample_max_stack"]
906 [::std::mem::offset_of!(perf_event_attr, sample_max_stack) - 108usize];
907 ["Offset of field: perf_event_attr::__reserved_2"]
908 [::std::mem::offset_of!(perf_event_attr, __reserved_2) - 110usize];
909 ["Offset of field: perf_event_attr::aux_sample_size"]
910 [::std::mem::offset_of!(perf_event_attr, aux_sample_size) - 112usize];
911 ["Offset of field: perf_event_attr::sig_data"]
912 [::std::mem::offset_of!(perf_event_attr, sig_data) - 120usize];
913 ["Offset of field: perf_event_attr::config3"]
914 [::std::mem::offset_of!(perf_event_attr, config3) - 128usize];
915 ["Offset of field: perf_event_attr::config4"]
916 [::std::mem::offset_of!(perf_event_attr, config4) - 136usize];
917};
918impl Default for perf_event_attr {
919 fn default() -> Self {
920 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
921 unsafe {
922 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
923 s.assume_init()
924 }
925 }
926}
927impl ::std::fmt::Debug for perf_event_attr {
928 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
929 write ! (f , "perf_event_attr {{ type: {:?}, size: {:?}, config: {:?}, __bindgen_anon_1: {:?}, sample_type: {:?}, read_format: {:?}, disabled : {:?}, inherit : {:?}, pinned : {:?}, exclusive : {:?}, exclude_user : {:?}, exclude_kernel : {:?}, exclude_hv : {:?}, exclude_idle : {:?}, mmap : {:?}, comm : {:?}, freq : {:?}, inherit_stat : {:?}, enable_on_exec : {:?}, task : {:?}, watermark : {:?}, precise_ip : {:?}, mmap_data : {:?}, sample_id_all : {:?}, exclude_host : {:?}, exclude_guest : {:?}, exclude_callchain_kernel : {:?}, exclude_callchain_user : {:?}, mmap2 : {:?}, comm_exec : {:?}, use_clockid : {:?}, context_switch : {:?}, write_backward : {:?}, namespaces : {:?}, ksymbol : {:?}, bpf_event : {:?}, aux_output : {:?}, cgroup : {:?}, text_poke : {:?}, build_id : {:?}, inherit_thread : {:?}, remove_on_exec : {:?}, sigtrap : {:?}, defer_callchain : {:?}, defer_output : {:?}, __reserved_1 : {:?}, __bindgen_anon_2: {:?}, bp_type: {:?}, __bindgen_anon_3: {:?}, __bindgen_anon_4: {:?}, branch_sample_type: {:?}, sample_regs_user: {:?}, sample_stack_user: {:?}, clockid: {:?}, sample_regs_intr: {:?}, aux_watermark: {:?}, sample_max_stack: {:?}, __reserved_2: {:?}, aux_sample_size: {:?}, __bindgen_anon_5: {:?}, sig_data: {:?}, config3: {:?}, config4: {:?} }}" , self . type_ , self . size , self . config , self . __bindgen_anon_1 , self . sample_type , self . read_format , self . disabled () , self . inherit () , self . pinned () , self . exclusive () , self . exclude_user () , self . exclude_kernel () , self . exclude_hv () , self . exclude_idle () , self . mmap () , self . comm () , self . freq () , self . inherit_stat () , self . enable_on_exec () , self . task () , self . watermark () , self . precise_ip () , self . mmap_data () , self . sample_id_all () , self . exclude_host () , self . exclude_guest () , self . exclude_callchain_kernel () , self . exclude_callchain_user () , self . mmap2 () , self . comm_exec () , self . use_clockid () , self . context_switch () , self . write_backward () , self . namespaces () , self . ksymbol () , self . bpf_event () , self . aux_output () , self . cgroup () , self . text_poke () , self . build_id () , self . inherit_thread () , self . remove_on_exec () , self . sigtrap () , self . defer_callchain () , self . defer_output () , self . __reserved_1 () , self . __bindgen_anon_2 , self . bp_type , self . __bindgen_anon_3 , self . __bindgen_anon_4 , self . branch_sample_type , self . sample_regs_user , self . sample_stack_user , self . clockid , self . sample_regs_intr , self . aux_watermark , self . sample_max_stack , self . __reserved_2 , self . aux_sample_size , self . __bindgen_anon_5 , self . sig_data , self . config3 , self . config4)
930 }
931}
932impl perf_event_attr {
933 #[inline]
934 pub fn disabled(&self) -> __u64 {
935 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
936 }
937 #[inline]
938 pub fn set_disabled(&mut self, val: __u64) {
939 unsafe {
940 let val: u64 = ::std::mem::transmute(val);
941 self._bitfield_1.set(0usize, 1u8, val as u64)
942 }
943 }
944 #[inline]
945 pub unsafe fn disabled_raw(this: *const Self) -> __u64 {
946 unsafe {
947 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
948 ::std::ptr::addr_of!((*this)._bitfield_1),
949 0usize,
950 1u8,
951 ) as u64)
952 }
953 }
954 #[inline]
955 pub unsafe fn set_disabled_raw(this: *mut Self, val: __u64) {
956 unsafe {
957 let val: u64 = ::std::mem::transmute(val);
958 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
959 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
960 0usize,
961 1u8,
962 val as u64,
963 )
964 }
965 }
966 #[inline]
967 pub fn inherit(&self) -> __u64 {
968 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
969 }
970 #[inline]
971 pub fn set_inherit(&mut self, val: __u64) {
972 unsafe {
973 let val: u64 = ::std::mem::transmute(val);
974 self._bitfield_1.set(1usize, 1u8, val as u64)
975 }
976 }
977 #[inline]
978 pub unsafe fn inherit_raw(this: *const Self) -> __u64 {
979 unsafe {
980 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
981 ::std::ptr::addr_of!((*this)._bitfield_1),
982 1usize,
983 1u8,
984 ) as u64)
985 }
986 }
987 #[inline]
988 pub unsafe fn set_inherit_raw(this: *mut Self, val: __u64) {
989 unsafe {
990 let val: u64 = ::std::mem::transmute(val);
991 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
992 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
993 1usize,
994 1u8,
995 val as u64,
996 )
997 }
998 }
999 #[inline]
1000 pub fn pinned(&self) -> __u64 {
1001 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1002 }
1003 #[inline]
1004 pub fn set_pinned(&mut self, val: __u64) {
1005 unsafe {
1006 let val: u64 = ::std::mem::transmute(val);
1007 self._bitfield_1.set(2usize, 1u8, val as u64)
1008 }
1009 }
1010 #[inline]
1011 pub unsafe fn pinned_raw(this: *const Self) -> __u64 {
1012 unsafe {
1013 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1014 ::std::ptr::addr_of!((*this)._bitfield_1),
1015 2usize,
1016 1u8,
1017 ) as u64)
1018 }
1019 }
1020 #[inline]
1021 pub unsafe fn set_pinned_raw(this: *mut Self, val: __u64) {
1022 unsafe {
1023 let val: u64 = ::std::mem::transmute(val);
1024 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1025 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1026 2usize,
1027 1u8,
1028 val as u64,
1029 )
1030 }
1031 }
1032 #[inline]
1033 pub fn exclusive(&self) -> __u64 {
1034 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1035 }
1036 #[inline]
1037 pub fn set_exclusive(&mut self, val: __u64) {
1038 unsafe {
1039 let val: u64 = ::std::mem::transmute(val);
1040 self._bitfield_1.set(3usize, 1u8, val as u64)
1041 }
1042 }
1043 #[inline]
1044 pub unsafe fn exclusive_raw(this: *const Self) -> __u64 {
1045 unsafe {
1046 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1047 ::std::ptr::addr_of!((*this)._bitfield_1),
1048 3usize,
1049 1u8,
1050 ) as u64)
1051 }
1052 }
1053 #[inline]
1054 pub unsafe fn set_exclusive_raw(this: *mut Self, val: __u64) {
1055 unsafe {
1056 let val: u64 = ::std::mem::transmute(val);
1057 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1058 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1059 3usize,
1060 1u8,
1061 val as u64,
1062 )
1063 }
1064 }
1065 #[inline]
1066 pub fn exclude_user(&self) -> __u64 {
1067 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1068 }
1069 #[inline]
1070 pub fn set_exclude_user(&mut self, val: __u64) {
1071 unsafe {
1072 let val: u64 = ::std::mem::transmute(val);
1073 self._bitfield_1.set(4usize, 1u8, val as u64)
1074 }
1075 }
1076 #[inline]
1077 pub unsafe fn exclude_user_raw(this: *const Self) -> __u64 {
1078 unsafe {
1079 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1080 ::std::ptr::addr_of!((*this)._bitfield_1),
1081 4usize,
1082 1u8,
1083 ) as u64)
1084 }
1085 }
1086 #[inline]
1087 pub unsafe fn set_exclude_user_raw(this: *mut Self, val: __u64) {
1088 unsafe {
1089 let val: u64 = ::std::mem::transmute(val);
1090 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1091 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1092 4usize,
1093 1u8,
1094 val as u64,
1095 )
1096 }
1097 }
1098 #[inline]
1099 pub fn exclude_kernel(&self) -> __u64 {
1100 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1101 }
1102 #[inline]
1103 pub fn set_exclude_kernel(&mut self, val: __u64) {
1104 unsafe {
1105 let val: u64 = ::std::mem::transmute(val);
1106 self._bitfield_1.set(5usize, 1u8, val as u64)
1107 }
1108 }
1109 #[inline]
1110 pub unsafe fn exclude_kernel_raw(this: *const Self) -> __u64 {
1111 unsafe {
1112 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1113 ::std::ptr::addr_of!((*this)._bitfield_1),
1114 5usize,
1115 1u8,
1116 ) as u64)
1117 }
1118 }
1119 #[inline]
1120 pub unsafe fn set_exclude_kernel_raw(this: *mut Self, val: __u64) {
1121 unsafe {
1122 let val: u64 = ::std::mem::transmute(val);
1123 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1124 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1125 5usize,
1126 1u8,
1127 val as u64,
1128 )
1129 }
1130 }
1131 #[inline]
1132 pub fn exclude_hv(&self) -> __u64 {
1133 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1134 }
1135 #[inline]
1136 pub fn set_exclude_hv(&mut self, val: __u64) {
1137 unsafe {
1138 let val: u64 = ::std::mem::transmute(val);
1139 self._bitfield_1.set(6usize, 1u8, val as u64)
1140 }
1141 }
1142 #[inline]
1143 pub unsafe fn exclude_hv_raw(this: *const Self) -> __u64 {
1144 unsafe {
1145 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1146 ::std::ptr::addr_of!((*this)._bitfield_1),
1147 6usize,
1148 1u8,
1149 ) as u64)
1150 }
1151 }
1152 #[inline]
1153 pub unsafe fn set_exclude_hv_raw(this: *mut Self, val: __u64) {
1154 unsafe {
1155 let val: u64 = ::std::mem::transmute(val);
1156 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1157 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1158 6usize,
1159 1u8,
1160 val as u64,
1161 )
1162 }
1163 }
1164 #[inline]
1165 pub fn exclude_idle(&self) -> __u64 {
1166 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1167 }
1168 #[inline]
1169 pub fn set_exclude_idle(&mut self, val: __u64) {
1170 unsafe {
1171 let val: u64 = ::std::mem::transmute(val);
1172 self._bitfield_1.set(7usize, 1u8, val as u64)
1173 }
1174 }
1175 #[inline]
1176 pub unsafe fn exclude_idle_raw(this: *const Self) -> __u64 {
1177 unsafe {
1178 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1179 ::std::ptr::addr_of!((*this)._bitfield_1),
1180 7usize,
1181 1u8,
1182 ) as u64)
1183 }
1184 }
1185 #[inline]
1186 pub unsafe fn set_exclude_idle_raw(this: *mut Self, val: __u64) {
1187 unsafe {
1188 let val: u64 = ::std::mem::transmute(val);
1189 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1190 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1191 7usize,
1192 1u8,
1193 val as u64,
1194 )
1195 }
1196 }
1197 #[inline]
1198 pub fn mmap(&self) -> __u64 {
1199 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
1200 }
1201 #[inline]
1202 pub fn set_mmap(&mut self, val: __u64) {
1203 unsafe {
1204 let val: u64 = ::std::mem::transmute(val);
1205 self._bitfield_1.set(8usize, 1u8, val as u64)
1206 }
1207 }
1208 #[inline]
1209 pub unsafe fn mmap_raw(this: *const Self) -> __u64 {
1210 unsafe {
1211 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1212 ::std::ptr::addr_of!((*this)._bitfield_1),
1213 8usize,
1214 1u8,
1215 ) as u64)
1216 }
1217 }
1218 #[inline]
1219 pub unsafe fn set_mmap_raw(this: *mut Self, val: __u64) {
1220 unsafe {
1221 let val: u64 = ::std::mem::transmute(val);
1222 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1223 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1224 8usize,
1225 1u8,
1226 val as u64,
1227 )
1228 }
1229 }
1230 #[inline]
1231 pub fn comm(&self) -> __u64 {
1232 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
1233 }
1234 #[inline]
1235 pub fn set_comm(&mut self, val: __u64) {
1236 unsafe {
1237 let val: u64 = ::std::mem::transmute(val);
1238 self._bitfield_1.set(9usize, 1u8, val as u64)
1239 }
1240 }
1241 #[inline]
1242 pub unsafe fn comm_raw(this: *const Self) -> __u64 {
1243 unsafe {
1244 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1245 ::std::ptr::addr_of!((*this)._bitfield_1),
1246 9usize,
1247 1u8,
1248 ) as u64)
1249 }
1250 }
1251 #[inline]
1252 pub unsafe fn set_comm_raw(this: *mut Self, val: __u64) {
1253 unsafe {
1254 let val: u64 = ::std::mem::transmute(val);
1255 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1256 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1257 9usize,
1258 1u8,
1259 val as u64,
1260 )
1261 }
1262 }
1263 #[inline]
1264 pub fn freq(&self) -> __u64 {
1265 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
1266 }
1267 #[inline]
1268 pub fn set_freq(&mut self, val: __u64) {
1269 unsafe {
1270 let val: u64 = ::std::mem::transmute(val);
1271 self._bitfield_1.set(10usize, 1u8, val as u64)
1272 }
1273 }
1274 #[inline]
1275 pub unsafe fn freq_raw(this: *const Self) -> __u64 {
1276 unsafe {
1277 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1278 ::std::ptr::addr_of!((*this)._bitfield_1),
1279 10usize,
1280 1u8,
1281 ) as u64)
1282 }
1283 }
1284 #[inline]
1285 pub unsafe fn set_freq_raw(this: *mut Self, val: __u64) {
1286 unsafe {
1287 let val: u64 = ::std::mem::transmute(val);
1288 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1289 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1290 10usize,
1291 1u8,
1292 val as u64,
1293 )
1294 }
1295 }
1296 #[inline]
1297 pub fn inherit_stat(&self) -> __u64 {
1298 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
1299 }
1300 #[inline]
1301 pub fn set_inherit_stat(&mut self, val: __u64) {
1302 unsafe {
1303 let val: u64 = ::std::mem::transmute(val);
1304 self._bitfield_1.set(11usize, 1u8, val as u64)
1305 }
1306 }
1307 #[inline]
1308 pub unsafe fn inherit_stat_raw(this: *const Self) -> __u64 {
1309 unsafe {
1310 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1311 ::std::ptr::addr_of!((*this)._bitfield_1),
1312 11usize,
1313 1u8,
1314 ) as u64)
1315 }
1316 }
1317 #[inline]
1318 pub unsafe fn set_inherit_stat_raw(this: *mut Self, val: __u64) {
1319 unsafe {
1320 let val: u64 = ::std::mem::transmute(val);
1321 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1322 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1323 11usize,
1324 1u8,
1325 val as u64,
1326 )
1327 }
1328 }
1329 #[inline]
1330 pub fn enable_on_exec(&self) -> __u64 {
1331 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1332 }
1333 #[inline]
1334 pub fn set_enable_on_exec(&mut self, val: __u64) {
1335 unsafe {
1336 let val: u64 = ::std::mem::transmute(val);
1337 self._bitfield_1.set(12usize, 1u8, val as u64)
1338 }
1339 }
1340 #[inline]
1341 pub unsafe fn enable_on_exec_raw(this: *const Self) -> __u64 {
1342 unsafe {
1343 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1344 ::std::ptr::addr_of!((*this)._bitfield_1),
1345 12usize,
1346 1u8,
1347 ) as u64)
1348 }
1349 }
1350 #[inline]
1351 pub unsafe fn set_enable_on_exec_raw(this: *mut Self, val: __u64) {
1352 unsafe {
1353 let val: u64 = ::std::mem::transmute(val);
1354 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1355 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1356 12usize,
1357 1u8,
1358 val as u64,
1359 )
1360 }
1361 }
1362 #[inline]
1363 pub fn task(&self) -> __u64 {
1364 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
1365 }
1366 #[inline]
1367 pub fn set_task(&mut self, val: __u64) {
1368 unsafe {
1369 let val: u64 = ::std::mem::transmute(val);
1370 self._bitfield_1.set(13usize, 1u8, val as u64)
1371 }
1372 }
1373 #[inline]
1374 pub unsafe fn task_raw(this: *const Self) -> __u64 {
1375 unsafe {
1376 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1377 ::std::ptr::addr_of!((*this)._bitfield_1),
1378 13usize,
1379 1u8,
1380 ) as u64)
1381 }
1382 }
1383 #[inline]
1384 pub unsafe fn set_task_raw(this: *mut Self, val: __u64) {
1385 unsafe {
1386 let val: u64 = ::std::mem::transmute(val);
1387 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1388 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1389 13usize,
1390 1u8,
1391 val as u64,
1392 )
1393 }
1394 }
1395 #[inline]
1396 pub fn watermark(&self) -> __u64 {
1397 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
1398 }
1399 #[inline]
1400 pub fn set_watermark(&mut self, val: __u64) {
1401 unsafe {
1402 let val: u64 = ::std::mem::transmute(val);
1403 self._bitfield_1.set(14usize, 1u8, val as u64)
1404 }
1405 }
1406 #[inline]
1407 pub unsafe fn watermark_raw(this: *const Self) -> __u64 {
1408 unsafe {
1409 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1410 ::std::ptr::addr_of!((*this)._bitfield_1),
1411 14usize,
1412 1u8,
1413 ) as u64)
1414 }
1415 }
1416 #[inline]
1417 pub unsafe fn set_watermark_raw(this: *mut Self, val: __u64) {
1418 unsafe {
1419 let val: u64 = ::std::mem::transmute(val);
1420 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1421 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1422 14usize,
1423 1u8,
1424 val as u64,
1425 )
1426 }
1427 }
1428 #[inline]
1429 pub fn precise_ip(&self) -> __u64 {
1430 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 2u8) as u64) }
1431 }
1432 #[inline]
1433 pub fn set_precise_ip(&mut self, val: __u64) {
1434 unsafe {
1435 let val: u64 = ::std::mem::transmute(val);
1436 self._bitfield_1.set(15usize, 2u8, val as u64)
1437 }
1438 }
1439 #[inline]
1440 pub unsafe fn precise_ip_raw(this: *const Self) -> __u64 {
1441 unsafe {
1442 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1443 ::std::ptr::addr_of!((*this)._bitfield_1),
1444 15usize,
1445 2u8,
1446 ) as u64)
1447 }
1448 }
1449 #[inline]
1450 pub unsafe fn set_precise_ip_raw(this: *mut Self, val: __u64) {
1451 unsafe {
1452 let val: u64 = ::std::mem::transmute(val);
1453 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1454 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1455 15usize,
1456 2u8,
1457 val as u64,
1458 )
1459 }
1460 }
1461 #[inline]
1462 pub fn mmap_data(&self) -> __u64 {
1463 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
1464 }
1465 #[inline]
1466 pub fn set_mmap_data(&mut self, val: __u64) {
1467 unsafe {
1468 let val: u64 = ::std::mem::transmute(val);
1469 self._bitfield_1.set(17usize, 1u8, val as u64)
1470 }
1471 }
1472 #[inline]
1473 pub unsafe fn mmap_data_raw(this: *const Self) -> __u64 {
1474 unsafe {
1475 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1476 ::std::ptr::addr_of!((*this)._bitfield_1),
1477 17usize,
1478 1u8,
1479 ) as u64)
1480 }
1481 }
1482 #[inline]
1483 pub unsafe fn set_mmap_data_raw(this: *mut Self, val: __u64) {
1484 unsafe {
1485 let val: u64 = ::std::mem::transmute(val);
1486 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1487 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1488 17usize,
1489 1u8,
1490 val as u64,
1491 )
1492 }
1493 }
1494 #[inline]
1495 pub fn sample_id_all(&self) -> __u64 {
1496 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
1497 }
1498 #[inline]
1499 pub fn set_sample_id_all(&mut self, val: __u64) {
1500 unsafe {
1501 let val: u64 = ::std::mem::transmute(val);
1502 self._bitfield_1.set(18usize, 1u8, val as u64)
1503 }
1504 }
1505 #[inline]
1506 pub unsafe fn sample_id_all_raw(this: *const Self) -> __u64 {
1507 unsafe {
1508 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1509 ::std::ptr::addr_of!((*this)._bitfield_1),
1510 18usize,
1511 1u8,
1512 ) as u64)
1513 }
1514 }
1515 #[inline]
1516 pub unsafe fn set_sample_id_all_raw(this: *mut Self, val: __u64) {
1517 unsafe {
1518 let val: u64 = ::std::mem::transmute(val);
1519 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1520 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1521 18usize,
1522 1u8,
1523 val as u64,
1524 )
1525 }
1526 }
1527 #[inline]
1528 pub fn exclude_host(&self) -> __u64 {
1529 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
1530 }
1531 #[inline]
1532 pub fn set_exclude_host(&mut self, val: __u64) {
1533 unsafe {
1534 let val: u64 = ::std::mem::transmute(val);
1535 self._bitfield_1.set(19usize, 1u8, val as u64)
1536 }
1537 }
1538 #[inline]
1539 pub unsafe fn exclude_host_raw(this: *const Self) -> __u64 {
1540 unsafe {
1541 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1542 ::std::ptr::addr_of!((*this)._bitfield_1),
1543 19usize,
1544 1u8,
1545 ) as u64)
1546 }
1547 }
1548 #[inline]
1549 pub unsafe fn set_exclude_host_raw(this: *mut Self, val: __u64) {
1550 unsafe {
1551 let val: u64 = ::std::mem::transmute(val);
1552 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1553 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1554 19usize,
1555 1u8,
1556 val as u64,
1557 )
1558 }
1559 }
1560 #[inline]
1561 pub fn exclude_guest(&self) -> __u64 {
1562 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
1563 }
1564 #[inline]
1565 pub fn set_exclude_guest(&mut self, val: __u64) {
1566 unsafe {
1567 let val: u64 = ::std::mem::transmute(val);
1568 self._bitfield_1.set(20usize, 1u8, val as u64)
1569 }
1570 }
1571 #[inline]
1572 pub unsafe fn exclude_guest_raw(this: *const Self) -> __u64 {
1573 unsafe {
1574 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1575 ::std::ptr::addr_of!((*this)._bitfield_1),
1576 20usize,
1577 1u8,
1578 ) as u64)
1579 }
1580 }
1581 #[inline]
1582 pub unsafe fn set_exclude_guest_raw(this: *mut Self, val: __u64) {
1583 unsafe {
1584 let val: u64 = ::std::mem::transmute(val);
1585 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1586 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1587 20usize,
1588 1u8,
1589 val as u64,
1590 )
1591 }
1592 }
1593 #[inline]
1594 pub fn exclude_callchain_kernel(&self) -> __u64 {
1595 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
1596 }
1597 #[inline]
1598 pub fn set_exclude_callchain_kernel(&mut self, val: __u64) {
1599 unsafe {
1600 let val: u64 = ::std::mem::transmute(val);
1601 self._bitfield_1.set(21usize, 1u8, val as u64)
1602 }
1603 }
1604 #[inline]
1605 pub unsafe fn exclude_callchain_kernel_raw(this: *const Self) -> __u64 {
1606 unsafe {
1607 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1608 ::std::ptr::addr_of!((*this)._bitfield_1),
1609 21usize,
1610 1u8,
1611 ) as u64)
1612 }
1613 }
1614 #[inline]
1615 pub unsafe fn set_exclude_callchain_kernel_raw(this: *mut Self, val: __u64) {
1616 unsafe {
1617 let val: u64 = ::std::mem::transmute(val);
1618 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1619 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1620 21usize,
1621 1u8,
1622 val as u64,
1623 )
1624 }
1625 }
1626 #[inline]
1627 pub fn exclude_callchain_user(&self) -> __u64 {
1628 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
1629 }
1630 #[inline]
1631 pub fn set_exclude_callchain_user(&mut self, val: __u64) {
1632 unsafe {
1633 let val: u64 = ::std::mem::transmute(val);
1634 self._bitfield_1.set(22usize, 1u8, val as u64)
1635 }
1636 }
1637 #[inline]
1638 pub unsafe fn exclude_callchain_user_raw(this: *const Self) -> __u64 {
1639 unsafe {
1640 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1641 ::std::ptr::addr_of!((*this)._bitfield_1),
1642 22usize,
1643 1u8,
1644 ) as u64)
1645 }
1646 }
1647 #[inline]
1648 pub unsafe fn set_exclude_callchain_user_raw(this: *mut Self, val: __u64) {
1649 unsafe {
1650 let val: u64 = ::std::mem::transmute(val);
1651 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1652 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1653 22usize,
1654 1u8,
1655 val as u64,
1656 )
1657 }
1658 }
1659 #[inline]
1660 pub fn mmap2(&self) -> __u64 {
1661 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
1662 }
1663 #[inline]
1664 pub fn set_mmap2(&mut self, val: __u64) {
1665 unsafe {
1666 let val: u64 = ::std::mem::transmute(val);
1667 self._bitfield_1.set(23usize, 1u8, val as u64)
1668 }
1669 }
1670 #[inline]
1671 pub unsafe fn mmap2_raw(this: *const Self) -> __u64 {
1672 unsafe {
1673 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1674 ::std::ptr::addr_of!((*this)._bitfield_1),
1675 23usize,
1676 1u8,
1677 ) as u64)
1678 }
1679 }
1680 #[inline]
1681 pub unsafe fn set_mmap2_raw(this: *mut Self, val: __u64) {
1682 unsafe {
1683 let val: u64 = ::std::mem::transmute(val);
1684 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1685 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1686 23usize,
1687 1u8,
1688 val as u64,
1689 )
1690 }
1691 }
1692 #[inline]
1693 pub fn comm_exec(&self) -> __u64 {
1694 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
1695 }
1696 #[inline]
1697 pub fn set_comm_exec(&mut self, val: __u64) {
1698 unsafe {
1699 let val: u64 = ::std::mem::transmute(val);
1700 self._bitfield_1.set(24usize, 1u8, val as u64)
1701 }
1702 }
1703 #[inline]
1704 pub unsafe fn comm_exec_raw(this: *const Self) -> __u64 {
1705 unsafe {
1706 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1707 ::std::ptr::addr_of!((*this)._bitfield_1),
1708 24usize,
1709 1u8,
1710 ) as u64)
1711 }
1712 }
1713 #[inline]
1714 pub unsafe fn set_comm_exec_raw(this: *mut Self, val: __u64) {
1715 unsafe {
1716 let val: u64 = ::std::mem::transmute(val);
1717 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1718 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1719 24usize,
1720 1u8,
1721 val as u64,
1722 )
1723 }
1724 }
1725 #[inline]
1726 pub fn use_clockid(&self) -> __u64 {
1727 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
1728 }
1729 #[inline]
1730 pub fn set_use_clockid(&mut self, val: __u64) {
1731 unsafe {
1732 let val: u64 = ::std::mem::transmute(val);
1733 self._bitfield_1.set(25usize, 1u8, val as u64)
1734 }
1735 }
1736 #[inline]
1737 pub unsafe fn use_clockid_raw(this: *const Self) -> __u64 {
1738 unsafe {
1739 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1740 ::std::ptr::addr_of!((*this)._bitfield_1),
1741 25usize,
1742 1u8,
1743 ) as u64)
1744 }
1745 }
1746 #[inline]
1747 pub unsafe fn set_use_clockid_raw(this: *mut Self, val: __u64) {
1748 unsafe {
1749 let val: u64 = ::std::mem::transmute(val);
1750 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1751 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1752 25usize,
1753 1u8,
1754 val as u64,
1755 )
1756 }
1757 }
1758 #[inline]
1759 pub fn context_switch(&self) -> __u64 {
1760 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
1761 }
1762 #[inline]
1763 pub fn set_context_switch(&mut self, val: __u64) {
1764 unsafe {
1765 let val: u64 = ::std::mem::transmute(val);
1766 self._bitfield_1.set(26usize, 1u8, val as u64)
1767 }
1768 }
1769 #[inline]
1770 pub unsafe fn context_switch_raw(this: *const Self) -> __u64 {
1771 unsafe {
1772 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1773 ::std::ptr::addr_of!((*this)._bitfield_1),
1774 26usize,
1775 1u8,
1776 ) as u64)
1777 }
1778 }
1779 #[inline]
1780 pub unsafe fn set_context_switch_raw(this: *mut Self, val: __u64) {
1781 unsafe {
1782 let val: u64 = ::std::mem::transmute(val);
1783 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1784 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1785 26usize,
1786 1u8,
1787 val as u64,
1788 )
1789 }
1790 }
1791 #[inline]
1792 pub fn write_backward(&self) -> __u64 {
1793 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
1794 }
1795 #[inline]
1796 pub fn set_write_backward(&mut self, val: __u64) {
1797 unsafe {
1798 let val: u64 = ::std::mem::transmute(val);
1799 self._bitfield_1.set(27usize, 1u8, val as u64)
1800 }
1801 }
1802 #[inline]
1803 pub unsafe fn write_backward_raw(this: *const Self) -> __u64 {
1804 unsafe {
1805 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1806 ::std::ptr::addr_of!((*this)._bitfield_1),
1807 27usize,
1808 1u8,
1809 ) as u64)
1810 }
1811 }
1812 #[inline]
1813 pub unsafe fn set_write_backward_raw(this: *mut Self, val: __u64) {
1814 unsafe {
1815 let val: u64 = ::std::mem::transmute(val);
1816 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1817 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1818 27usize,
1819 1u8,
1820 val as u64,
1821 )
1822 }
1823 }
1824 #[inline]
1825 pub fn namespaces(&self) -> __u64 {
1826 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
1827 }
1828 #[inline]
1829 pub fn set_namespaces(&mut self, val: __u64) {
1830 unsafe {
1831 let val: u64 = ::std::mem::transmute(val);
1832 self._bitfield_1.set(28usize, 1u8, val as u64)
1833 }
1834 }
1835 #[inline]
1836 pub unsafe fn namespaces_raw(this: *const Self) -> __u64 {
1837 unsafe {
1838 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1839 ::std::ptr::addr_of!((*this)._bitfield_1),
1840 28usize,
1841 1u8,
1842 ) as u64)
1843 }
1844 }
1845 #[inline]
1846 pub unsafe fn set_namespaces_raw(this: *mut Self, val: __u64) {
1847 unsafe {
1848 let val: u64 = ::std::mem::transmute(val);
1849 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1850 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1851 28usize,
1852 1u8,
1853 val as u64,
1854 )
1855 }
1856 }
1857 #[inline]
1858 pub fn ksymbol(&self) -> __u64 {
1859 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
1860 }
1861 #[inline]
1862 pub fn set_ksymbol(&mut self, val: __u64) {
1863 unsafe {
1864 let val: u64 = ::std::mem::transmute(val);
1865 self._bitfield_1.set(29usize, 1u8, val as u64)
1866 }
1867 }
1868 #[inline]
1869 pub unsafe fn ksymbol_raw(this: *const Self) -> __u64 {
1870 unsafe {
1871 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1872 ::std::ptr::addr_of!((*this)._bitfield_1),
1873 29usize,
1874 1u8,
1875 ) as u64)
1876 }
1877 }
1878 #[inline]
1879 pub unsafe fn set_ksymbol_raw(this: *mut Self, val: __u64) {
1880 unsafe {
1881 let val: u64 = ::std::mem::transmute(val);
1882 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1883 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1884 29usize,
1885 1u8,
1886 val as u64,
1887 )
1888 }
1889 }
1890 #[inline]
1891 pub fn bpf_event(&self) -> __u64 {
1892 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
1893 }
1894 #[inline]
1895 pub fn set_bpf_event(&mut self, val: __u64) {
1896 unsafe {
1897 let val: u64 = ::std::mem::transmute(val);
1898 self._bitfield_1.set(30usize, 1u8, val as u64)
1899 }
1900 }
1901 #[inline]
1902 pub unsafe fn bpf_event_raw(this: *const Self) -> __u64 {
1903 unsafe {
1904 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1905 ::std::ptr::addr_of!((*this)._bitfield_1),
1906 30usize,
1907 1u8,
1908 ) as u64)
1909 }
1910 }
1911 #[inline]
1912 pub unsafe fn set_bpf_event_raw(this: *mut Self, val: __u64) {
1913 unsafe {
1914 let val: u64 = ::std::mem::transmute(val);
1915 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1916 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1917 30usize,
1918 1u8,
1919 val as u64,
1920 )
1921 }
1922 }
1923 #[inline]
1924 pub fn aux_output(&self) -> __u64 {
1925 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
1926 }
1927 #[inline]
1928 pub fn set_aux_output(&mut self, val: __u64) {
1929 unsafe {
1930 let val: u64 = ::std::mem::transmute(val);
1931 self._bitfield_1.set(31usize, 1u8, val as u64)
1932 }
1933 }
1934 #[inline]
1935 pub unsafe fn aux_output_raw(this: *const Self) -> __u64 {
1936 unsafe {
1937 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1938 ::std::ptr::addr_of!((*this)._bitfield_1),
1939 31usize,
1940 1u8,
1941 ) as u64)
1942 }
1943 }
1944 #[inline]
1945 pub unsafe fn set_aux_output_raw(this: *mut Self, val: __u64) {
1946 unsafe {
1947 let val: u64 = ::std::mem::transmute(val);
1948 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1949 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1950 31usize,
1951 1u8,
1952 val as u64,
1953 )
1954 }
1955 }
1956 #[inline]
1957 pub fn cgroup(&self) -> __u64 {
1958 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
1959 }
1960 #[inline]
1961 pub fn set_cgroup(&mut self, val: __u64) {
1962 unsafe {
1963 let val: u64 = ::std::mem::transmute(val);
1964 self._bitfield_1.set(32usize, 1u8, val as u64)
1965 }
1966 }
1967 #[inline]
1968 pub unsafe fn cgroup_raw(this: *const Self) -> __u64 {
1969 unsafe {
1970 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1971 ::std::ptr::addr_of!((*this)._bitfield_1),
1972 32usize,
1973 1u8,
1974 ) as u64)
1975 }
1976 }
1977 #[inline]
1978 pub unsafe fn set_cgroup_raw(this: *mut Self, val: __u64) {
1979 unsafe {
1980 let val: u64 = ::std::mem::transmute(val);
1981 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1982 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1983 32usize,
1984 1u8,
1985 val as u64,
1986 )
1987 }
1988 }
1989 #[inline]
1990 pub fn text_poke(&self) -> __u64 {
1991 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
1992 }
1993 #[inline]
1994 pub fn set_text_poke(&mut self, val: __u64) {
1995 unsafe {
1996 let val: u64 = ::std::mem::transmute(val);
1997 self._bitfield_1.set(33usize, 1u8, val as u64)
1998 }
1999 }
2000 #[inline]
2001 pub unsafe fn text_poke_raw(this: *const Self) -> __u64 {
2002 unsafe {
2003 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2004 ::std::ptr::addr_of!((*this)._bitfield_1),
2005 33usize,
2006 1u8,
2007 ) as u64)
2008 }
2009 }
2010 #[inline]
2011 pub unsafe fn set_text_poke_raw(this: *mut Self, val: __u64) {
2012 unsafe {
2013 let val: u64 = ::std::mem::transmute(val);
2014 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2015 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2016 33usize,
2017 1u8,
2018 val as u64,
2019 )
2020 }
2021 }
2022 #[inline]
2023 pub fn build_id(&self) -> __u64 {
2024 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
2025 }
2026 #[inline]
2027 pub fn set_build_id(&mut self, val: __u64) {
2028 unsafe {
2029 let val: u64 = ::std::mem::transmute(val);
2030 self._bitfield_1.set(34usize, 1u8, val as u64)
2031 }
2032 }
2033 #[inline]
2034 pub unsafe fn build_id_raw(this: *const Self) -> __u64 {
2035 unsafe {
2036 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2037 ::std::ptr::addr_of!((*this)._bitfield_1),
2038 34usize,
2039 1u8,
2040 ) as u64)
2041 }
2042 }
2043 #[inline]
2044 pub unsafe fn set_build_id_raw(this: *mut Self, val: __u64) {
2045 unsafe {
2046 let val: u64 = ::std::mem::transmute(val);
2047 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2048 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2049 34usize,
2050 1u8,
2051 val as u64,
2052 )
2053 }
2054 }
2055 #[inline]
2056 pub fn inherit_thread(&self) -> __u64 {
2057 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
2058 }
2059 #[inline]
2060 pub fn set_inherit_thread(&mut self, val: __u64) {
2061 unsafe {
2062 let val: u64 = ::std::mem::transmute(val);
2063 self._bitfield_1.set(35usize, 1u8, val as u64)
2064 }
2065 }
2066 #[inline]
2067 pub unsafe fn inherit_thread_raw(this: *const Self) -> __u64 {
2068 unsafe {
2069 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2070 ::std::ptr::addr_of!((*this)._bitfield_1),
2071 35usize,
2072 1u8,
2073 ) as u64)
2074 }
2075 }
2076 #[inline]
2077 pub unsafe fn set_inherit_thread_raw(this: *mut Self, val: __u64) {
2078 unsafe {
2079 let val: u64 = ::std::mem::transmute(val);
2080 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2081 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2082 35usize,
2083 1u8,
2084 val as u64,
2085 )
2086 }
2087 }
2088 #[inline]
2089 pub fn remove_on_exec(&self) -> __u64 {
2090 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
2091 }
2092 #[inline]
2093 pub fn set_remove_on_exec(&mut self, val: __u64) {
2094 unsafe {
2095 let val: u64 = ::std::mem::transmute(val);
2096 self._bitfield_1.set(36usize, 1u8, val as u64)
2097 }
2098 }
2099 #[inline]
2100 pub unsafe fn remove_on_exec_raw(this: *const Self) -> __u64 {
2101 unsafe {
2102 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2103 ::std::ptr::addr_of!((*this)._bitfield_1),
2104 36usize,
2105 1u8,
2106 ) as u64)
2107 }
2108 }
2109 #[inline]
2110 pub unsafe fn set_remove_on_exec_raw(this: *mut Self, val: __u64) {
2111 unsafe {
2112 let val: u64 = ::std::mem::transmute(val);
2113 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2114 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2115 36usize,
2116 1u8,
2117 val as u64,
2118 )
2119 }
2120 }
2121 #[inline]
2122 pub fn sigtrap(&self) -> __u64 {
2123 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
2124 }
2125 #[inline]
2126 pub fn set_sigtrap(&mut self, val: __u64) {
2127 unsafe {
2128 let val: u64 = ::std::mem::transmute(val);
2129 self._bitfield_1.set(37usize, 1u8, val as u64)
2130 }
2131 }
2132 #[inline]
2133 pub unsafe fn sigtrap_raw(this: *const Self) -> __u64 {
2134 unsafe {
2135 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2136 ::std::ptr::addr_of!((*this)._bitfield_1),
2137 37usize,
2138 1u8,
2139 ) as u64)
2140 }
2141 }
2142 #[inline]
2143 pub unsafe fn set_sigtrap_raw(this: *mut Self, val: __u64) {
2144 unsafe {
2145 let val: u64 = ::std::mem::transmute(val);
2146 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2147 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2148 37usize,
2149 1u8,
2150 val as u64,
2151 )
2152 }
2153 }
2154 #[inline]
2155 pub fn defer_callchain(&self) -> __u64 {
2156 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
2157 }
2158 #[inline]
2159 pub fn set_defer_callchain(&mut self, val: __u64) {
2160 unsafe {
2161 let val: u64 = ::std::mem::transmute(val);
2162 self._bitfield_1.set(38usize, 1u8, val as u64)
2163 }
2164 }
2165 #[inline]
2166 pub unsafe fn defer_callchain_raw(this: *const Self) -> __u64 {
2167 unsafe {
2168 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2169 ::std::ptr::addr_of!((*this)._bitfield_1),
2170 38usize,
2171 1u8,
2172 ) as u64)
2173 }
2174 }
2175 #[inline]
2176 pub unsafe fn set_defer_callchain_raw(this: *mut Self, val: __u64) {
2177 unsafe {
2178 let val: u64 = ::std::mem::transmute(val);
2179 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2180 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2181 38usize,
2182 1u8,
2183 val as u64,
2184 )
2185 }
2186 }
2187 #[inline]
2188 pub fn defer_output(&self) -> __u64 {
2189 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
2190 }
2191 #[inline]
2192 pub fn set_defer_output(&mut self, val: __u64) {
2193 unsafe {
2194 let val: u64 = ::std::mem::transmute(val);
2195 self._bitfield_1.set(39usize, 1u8, val as u64)
2196 }
2197 }
2198 #[inline]
2199 pub unsafe fn defer_output_raw(this: *const Self) -> __u64 {
2200 unsafe {
2201 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2202 ::std::ptr::addr_of!((*this)._bitfield_1),
2203 39usize,
2204 1u8,
2205 ) as u64)
2206 }
2207 }
2208 #[inline]
2209 pub unsafe fn set_defer_output_raw(this: *mut Self, val: __u64) {
2210 unsafe {
2211 let val: u64 = ::std::mem::transmute(val);
2212 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2213 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2214 39usize,
2215 1u8,
2216 val as u64,
2217 )
2218 }
2219 }
2220 #[inline]
2221 pub fn __reserved_1(&self) -> __u64 {
2222 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 24u8) as u64) }
2223 }
2224 #[inline]
2225 pub fn set___reserved_1(&mut self, val: __u64) {
2226 unsafe {
2227 let val: u64 = ::std::mem::transmute(val);
2228 self._bitfield_1.set(40usize, 24u8, val as u64)
2229 }
2230 }
2231 #[inline]
2232 pub unsafe fn __reserved_1_raw(this: *const Self) -> __u64 {
2233 unsafe {
2234 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2235 ::std::ptr::addr_of!((*this)._bitfield_1),
2236 40usize,
2237 24u8,
2238 ) as u64)
2239 }
2240 }
2241 #[inline]
2242 pub unsafe fn set___reserved_1_raw(this: *mut Self, val: __u64) {
2243 unsafe {
2244 let val: u64 = ::std::mem::transmute(val);
2245 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2246 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2247 40usize,
2248 24u8,
2249 val as u64,
2250 )
2251 }
2252 }
2253 #[inline]
2254 pub fn new_bitfield_1(
2255 disabled: __u64,
2256 inherit: __u64,
2257 pinned: __u64,
2258 exclusive: __u64,
2259 exclude_user: __u64,
2260 exclude_kernel: __u64,
2261 exclude_hv: __u64,
2262 exclude_idle: __u64,
2263 mmap: __u64,
2264 comm: __u64,
2265 freq: __u64,
2266 inherit_stat: __u64,
2267 enable_on_exec: __u64,
2268 task: __u64,
2269 watermark: __u64,
2270 precise_ip: __u64,
2271 mmap_data: __u64,
2272 sample_id_all: __u64,
2273 exclude_host: __u64,
2274 exclude_guest: __u64,
2275 exclude_callchain_kernel: __u64,
2276 exclude_callchain_user: __u64,
2277 mmap2: __u64,
2278 comm_exec: __u64,
2279 use_clockid: __u64,
2280 context_switch: __u64,
2281 write_backward: __u64,
2282 namespaces: __u64,
2283 ksymbol: __u64,
2284 bpf_event: __u64,
2285 aux_output: __u64,
2286 cgroup: __u64,
2287 text_poke: __u64,
2288 build_id: __u64,
2289 inherit_thread: __u64,
2290 remove_on_exec: __u64,
2291 sigtrap: __u64,
2292 defer_callchain: __u64,
2293 defer_output: __u64,
2294 __reserved_1: __u64,
2295 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2296 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2297 __bindgen_bitfield_unit.set(0usize, 1u8, {
2298 let disabled: u64 = unsafe { ::std::mem::transmute(disabled) };
2299 disabled as u64
2300 });
2301 __bindgen_bitfield_unit.set(1usize, 1u8, {
2302 let inherit: u64 = unsafe { ::std::mem::transmute(inherit) };
2303 inherit as u64
2304 });
2305 __bindgen_bitfield_unit.set(2usize, 1u8, {
2306 let pinned: u64 = unsafe { ::std::mem::transmute(pinned) };
2307 pinned as u64
2308 });
2309 __bindgen_bitfield_unit.set(3usize, 1u8, {
2310 let exclusive: u64 = unsafe { ::std::mem::transmute(exclusive) };
2311 exclusive as u64
2312 });
2313 __bindgen_bitfield_unit.set(4usize, 1u8, {
2314 let exclude_user: u64 = unsafe { ::std::mem::transmute(exclude_user) };
2315 exclude_user as u64
2316 });
2317 __bindgen_bitfield_unit.set(5usize, 1u8, {
2318 let exclude_kernel: u64 = unsafe { ::std::mem::transmute(exclude_kernel) };
2319 exclude_kernel as u64
2320 });
2321 __bindgen_bitfield_unit.set(6usize, 1u8, {
2322 let exclude_hv: u64 = unsafe { ::std::mem::transmute(exclude_hv) };
2323 exclude_hv as u64
2324 });
2325 __bindgen_bitfield_unit.set(7usize, 1u8, {
2326 let exclude_idle: u64 = unsafe { ::std::mem::transmute(exclude_idle) };
2327 exclude_idle as u64
2328 });
2329 __bindgen_bitfield_unit.set(8usize, 1u8, {
2330 let mmap: u64 = unsafe { ::std::mem::transmute(mmap) };
2331 mmap as u64
2332 });
2333 __bindgen_bitfield_unit.set(9usize, 1u8, {
2334 let comm: u64 = unsafe { ::std::mem::transmute(comm) };
2335 comm as u64
2336 });
2337 __bindgen_bitfield_unit.set(10usize, 1u8, {
2338 let freq: u64 = unsafe { ::std::mem::transmute(freq) };
2339 freq as u64
2340 });
2341 __bindgen_bitfield_unit.set(11usize, 1u8, {
2342 let inherit_stat: u64 = unsafe { ::std::mem::transmute(inherit_stat) };
2343 inherit_stat as u64
2344 });
2345 __bindgen_bitfield_unit.set(12usize, 1u8, {
2346 let enable_on_exec: u64 = unsafe { ::std::mem::transmute(enable_on_exec) };
2347 enable_on_exec as u64
2348 });
2349 __bindgen_bitfield_unit.set(13usize, 1u8, {
2350 let task: u64 = unsafe { ::std::mem::transmute(task) };
2351 task as u64
2352 });
2353 __bindgen_bitfield_unit.set(14usize, 1u8, {
2354 let watermark: u64 = unsafe { ::std::mem::transmute(watermark) };
2355 watermark as u64
2356 });
2357 __bindgen_bitfield_unit.set(15usize, 2u8, {
2358 let precise_ip: u64 = unsafe { ::std::mem::transmute(precise_ip) };
2359 precise_ip as u64
2360 });
2361 __bindgen_bitfield_unit.set(17usize, 1u8, {
2362 let mmap_data: u64 = unsafe { ::std::mem::transmute(mmap_data) };
2363 mmap_data as u64
2364 });
2365 __bindgen_bitfield_unit.set(18usize, 1u8, {
2366 let sample_id_all: u64 = unsafe { ::std::mem::transmute(sample_id_all) };
2367 sample_id_all as u64
2368 });
2369 __bindgen_bitfield_unit.set(19usize, 1u8, {
2370 let exclude_host: u64 = unsafe { ::std::mem::transmute(exclude_host) };
2371 exclude_host as u64
2372 });
2373 __bindgen_bitfield_unit.set(20usize, 1u8, {
2374 let exclude_guest: u64 = unsafe { ::std::mem::transmute(exclude_guest) };
2375 exclude_guest as u64
2376 });
2377 __bindgen_bitfield_unit.set(21usize, 1u8, {
2378 let exclude_callchain_kernel: u64 =
2379 unsafe { ::std::mem::transmute(exclude_callchain_kernel) };
2380 exclude_callchain_kernel as u64
2381 });
2382 __bindgen_bitfield_unit.set(22usize, 1u8, {
2383 let exclude_callchain_user: u64 =
2384 unsafe { ::std::mem::transmute(exclude_callchain_user) };
2385 exclude_callchain_user as u64
2386 });
2387 __bindgen_bitfield_unit.set(23usize, 1u8, {
2388 let mmap2: u64 = unsafe { ::std::mem::transmute(mmap2) };
2389 mmap2 as u64
2390 });
2391 __bindgen_bitfield_unit.set(24usize, 1u8, {
2392 let comm_exec: u64 = unsafe { ::std::mem::transmute(comm_exec) };
2393 comm_exec as u64
2394 });
2395 __bindgen_bitfield_unit.set(25usize, 1u8, {
2396 let use_clockid: u64 = unsafe { ::std::mem::transmute(use_clockid) };
2397 use_clockid as u64
2398 });
2399 __bindgen_bitfield_unit.set(26usize, 1u8, {
2400 let context_switch: u64 = unsafe { ::std::mem::transmute(context_switch) };
2401 context_switch as u64
2402 });
2403 __bindgen_bitfield_unit.set(27usize, 1u8, {
2404 let write_backward: u64 = unsafe { ::std::mem::transmute(write_backward) };
2405 write_backward as u64
2406 });
2407 __bindgen_bitfield_unit.set(28usize, 1u8, {
2408 let namespaces: u64 = unsafe { ::std::mem::transmute(namespaces) };
2409 namespaces as u64
2410 });
2411 __bindgen_bitfield_unit.set(29usize, 1u8, {
2412 let ksymbol: u64 = unsafe { ::std::mem::transmute(ksymbol) };
2413 ksymbol as u64
2414 });
2415 __bindgen_bitfield_unit.set(30usize, 1u8, {
2416 let bpf_event: u64 = unsafe { ::std::mem::transmute(bpf_event) };
2417 bpf_event as u64
2418 });
2419 __bindgen_bitfield_unit.set(31usize, 1u8, {
2420 let aux_output: u64 = unsafe { ::std::mem::transmute(aux_output) };
2421 aux_output as u64
2422 });
2423 __bindgen_bitfield_unit.set(32usize, 1u8, {
2424 let cgroup: u64 = unsafe { ::std::mem::transmute(cgroup) };
2425 cgroup as u64
2426 });
2427 __bindgen_bitfield_unit.set(33usize, 1u8, {
2428 let text_poke: u64 = unsafe { ::std::mem::transmute(text_poke) };
2429 text_poke as u64
2430 });
2431 __bindgen_bitfield_unit.set(34usize, 1u8, {
2432 let build_id: u64 = unsafe { ::std::mem::transmute(build_id) };
2433 build_id as u64
2434 });
2435 __bindgen_bitfield_unit.set(35usize, 1u8, {
2436 let inherit_thread: u64 = unsafe { ::std::mem::transmute(inherit_thread) };
2437 inherit_thread as u64
2438 });
2439 __bindgen_bitfield_unit.set(36usize, 1u8, {
2440 let remove_on_exec: u64 = unsafe { ::std::mem::transmute(remove_on_exec) };
2441 remove_on_exec as u64
2442 });
2443 __bindgen_bitfield_unit.set(37usize, 1u8, {
2444 let sigtrap: u64 = unsafe { ::std::mem::transmute(sigtrap) };
2445 sigtrap as u64
2446 });
2447 __bindgen_bitfield_unit.set(38usize, 1u8, {
2448 let defer_callchain: u64 = unsafe { ::std::mem::transmute(defer_callchain) };
2449 defer_callchain as u64
2450 });
2451 __bindgen_bitfield_unit.set(39usize, 1u8, {
2452 let defer_output: u64 = unsafe { ::std::mem::transmute(defer_output) };
2453 defer_output as u64
2454 });
2455 __bindgen_bitfield_unit.set(40usize, 24u8, {
2456 let __reserved_1: u64 = unsafe { ::std::mem::transmute(__reserved_1) };
2457 __reserved_1 as u64
2458 });
2459 __bindgen_bitfield_unit
2460 }
2461}
2462#[repr(C)]
2463#[derive(Debug, Default)]
2464pub struct perf_event_query_bpf {
2465 pub ids_len: __u32,
2466 pub prog_cnt: __u32,
2467 pub ids: __IncompleteArrayField<__u32>,
2468}
2469#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2470const _: () = {
2471 ["Size of perf_event_query_bpf"][::std::mem::size_of::<perf_event_query_bpf>() - 8usize];
2472 ["Alignment of perf_event_query_bpf"][::std::mem::align_of::<perf_event_query_bpf>() - 4usize];
2473 ["Offset of field: perf_event_query_bpf::ids_len"]
2474 [::std::mem::offset_of!(perf_event_query_bpf, ids_len) - 0usize];
2475 ["Offset of field: perf_event_query_bpf::prog_cnt"]
2476 [::std::mem::offset_of!(perf_event_query_bpf, prog_cnt) - 4usize];
2477 ["Offset of field: perf_event_query_bpf::ids"]
2478 [::std::mem::offset_of!(perf_event_query_bpf, ids) - 8usize];
2479};
2480pub const PERF_IOC_FLAG_GROUP: perf_event_ioc_flags = 1;
2481pub type perf_event_ioc_flags = ::std::os::raw::c_uint;
2482#[repr(C)]
2483#[derive(Copy, Clone)]
2484pub struct perf_event_mmap_page {
2485 pub version: __u32,
2486 pub compat_version: __u32,
2487 pub lock: __u32,
2488 pub index: __u32,
2489 pub offset: __s64,
2490 pub time_enabled: __u64,
2491 pub time_running: __u64,
2492 pub __bindgen_anon_1: perf_event_mmap_page__bindgen_ty_1,
2493 pub pmc_width: __u16,
2494 pub time_shift: __u16,
2495 pub time_mult: __u32,
2496 pub time_offset: __u64,
2497 pub time_zero: __u64,
2498 pub size: __u32,
2499 pub __reserved_1: __u32,
2500 pub time_cycles: __u64,
2501 pub time_mask: __u64,
2502 pub __reserved: [__u8; 928usize],
2503 pub data_head: __u64,
2504 pub data_tail: __u64,
2505 pub data_offset: __u64,
2506 pub data_size: __u64,
2507 pub aux_head: __u64,
2508 pub aux_tail: __u64,
2509 pub aux_offset: __u64,
2510 pub aux_size: __u64,
2511}
2512#[repr(C)]
2513#[derive(Copy, Clone)]
2514pub union perf_event_mmap_page__bindgen_ty_1 {
2515 pub capabilities: __u64,
2516 pub __bindgen_anon_1: perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1,
2517}
2518#[repr(C)]
2519#[derive(Debug, Default, Copy, Clone)]
2520pub struct perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1 {
2521 pub _bitfield_align_1: [u64; 0],
2522 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2523}
2524#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2525const _: () = {
2526 ["Size of perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1"]
2527 [::std::mem::size_of::<perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1>() - 8usize];
2528 ["Alignment of perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1"]
2529 [::std::mem::align_of::<perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1>() - 8usize];
2530};
2531impl perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1 {
2532 #[inline]
2533 pub fn cap_bit0(&self) -> __u64 {
2534 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
2535 }
2536 #[inline]
2537 pub fn set_cap_bit0(&mut self, val: __u64) {
2538 unsafe {
2539 let val: u64 = ::std::mem::transmute(val);
2540 self._bitfield_1.set(0usize, 1u8, val as u64)
2541 }
2542 }
2543 #[inline]
2544 pub unsafe fn cap_bit0_raw(this: *const Self) -> __u64 {
2545 unsafe {
2546 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2547 ::std::ptr::addr_of!((*this)._bitfield_1),
2548 0usize,
2549 1u8,
2550 ) as u64)
2551 }
2552 }
2553 #[inline]
2554 pub unsafe fn set_cap_bit0_raw(this: *mut Self, val: __u64) {
2555 unsafe {
2556 let val: u64 = ::std::mem::transmute(val);
2557 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2558 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2559 0usize,
2560 1u8,
2561 val as u64,
2562 )
2563 }
2564 }
2565 #[inline]
2566 pub fn cap_bit0_is_deprecated(&self) -> __u64 {
2567 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
2568 }
2569 #[inline]
2570 pub fn set_cap_bit0_is_deprecated(&mut self, val: __u64) {
2571 unsafe {
2572 let val: u64 = ::std::mem::transmute(val);
2573 self._bitfield_1.set(1usize, 1u8, val as u64)
2574 }
2575 }
2576 #[inline]
2577 pub unsafe fn cap_bit0_is_deprecated_raw(this: *const Self) -> __u64 {
2578 unsafe {
2579 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2580 ::std::ptr::addr_of!((*this)._bitfield_1),
2581 1usize,
2582 1u8,
2583 ) as u64)
2584 }
2585 }
2586 #[inline]
2587 pub unsafe fn set_cap_bit0_is_deprecated_raw(this: *mut Self, val: __u64) {
2588 unsafe {
2589 let val: u64 = ::std::mem::transmute(val);
2590 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2591 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2592 1usize,
2593 1u8,
2594 val as u64,
2595 )
2596 }
2597 }
2598 #[inline]
2599 pub fn cap_user_rdpmc(&self) -> __u64 {
2600 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
2601 }
2602 #[inline]
2603 pub fn set_cap_user_rdpmc(&mut self, val: __u64) {
2604 unsafe {
2605 let val: u64 = ::std::mem::transmute(val);
2606 self._bitfield_1.set(2usize, 1u8, val as u64)
2607 }
2608 }
2609 #[inline]
2610 pub unsafe fn cap_user_rdpmc_raw(this: *const Self) -> __u64 {
2611 unsafe {
2612 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2613 ::std::ptr::addr_of!((*this)._bitfield_1),
2614 2usize,
2615 1u8,
2616 ) as u64)
2617 }
2618 }
2619 #[inline]
2620 pub unsafe fn set_cap_user_rdpmc_raw(this: *mut Self, val: __u64) {
2621 unsafe {
2622 let val: u64 = ::std::mem::transmute(val);
2623 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2624 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2625 2usize,
2626 1u8,
2627 val as u64,
2628 )
2629 }
2630 }
2631 #[inline]
2632 pub fn cap_user_time(&self) -> __u64 {
2633 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
2634 }
2635 #[inline]
2636 pub fn set_cap_user_time(&mut self, val: __u64) {
2637 unsafe {
2638 let val: u64 = ::std::mem::transmute(val);
2639 self._bitfield_1.set(3usize, 1u8, val as u64)
2640 }
2641 }
2642 #[inline]
2643 pub unsafe fn cap_user_time_raw(this: *const Self) -> __u64 {
2644 unsafe {
2645 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2646 ::std::ptr::addr_of!((*this)._bitfield_1),
2647 3usize,
2648 1u8,
2649 ) as u64)
2650 }
2651 }
2652 #[inline]
2653 pub unsafe fn set_cap_user_time_raw(this: *mut Self, val: __u64) {
2654 unsafe {
2655 let val: u64 = ::std::mem::transmute(val);
2656 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2657 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2658 3usize,
2659 1u8,
2660 val as u64,
2661 )
2662 }
2663 }
2664 #[inline]
2665 pub fn cap_user_time_zero(&self) -> __u64 {
2666 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
2667 }
2668 #[inline]
2669 pub fn set_cap_user_time_zero(&mut self, val: __u64) {
2670 unsafe {
2671 let val: u64 = ::std::mem::transmute(val);
2672 self._bitfield_1.set(4usize, 1u8, val as u64)
2673 }
2674 }
2675 #[inline]
2676 pub unsafe fn cap_user_time_zero_raw(this: *const Self) -> __u64 {
2677 unsafe {
2678 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2679 ::std::ptr::addr_of!((*this)._bitfield_1),
2680 4usize,
2681 1u8,
2682 ) as u64)
2683 }
2684 }
2685 #[inline]
2686 pub unsafe fn set_cap_user_time_zero_raw(this: *mut Self, val: __u64) {
2687 unsafe {
2688 let val: u64 = ::std::mem::transmute(val);
2689 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2690 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2691 4usize,
2692 1u8,
2693 val as u64,
2694 )
2695 }
2696 }
2697 #[inline]
2698 pub fn cap_user_time_short(&self) -> __u64 {
2699 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
2700 }
2701 #[inline]
2702 pub fn set_cap_user_time_short(&mut self, val: __u64) {
2703 unsafe {
2704 let val: u64 = ::std::mem::transmute(val);
2705 self._bitfield_1.set(5usize, 1u8, val as u64)
2706 }
2707 }
2708 #[inline]
2709 pub unsafe fn cap_user_time_short_raw(this: *const Self) -> __u64 {
2710 unsafe {
2711 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2712 ::std::ptr::addr_of!((*this)._bitfield_1),
2713 5usize,
2714 1u8,
2715 ) as u64)
2716 }
2717 }
2718 #[inline]
2719 pub unsafe fn set_cap_user_time_short_raw(this: *mut Self, val: __u64) {
2720 unsafe {
2721 let val: u64 = ::std::mem::transmute(val);
2722 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2723 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2724 5usize,
2725 1u8,
2726 val as u64,
2727 )
2728 }
2729 }
2730 #[inline]
2731 pub fn cap_____res(&self) -> __u64 {
2732 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 58u8) as u64) }
2733 }
2734 #[inline]
2735 pub fn set_cap_____res(&mut self, val: __u64) {
2736 unsafe {
2737 let val: u64 = ::std::mem::transmute(val);
2738 self._bitfield_1.set(6usize, 58u8, val as u64)
2739 }
2740 }
2741 #[inline]
2742 pub unsafe fn cap_____res_raw(this: *const Self) -> __u64 {
2743 unsafe {
2744 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2745 ::std::ptr::addr_of!((*this)._bitfield_1),
2746 6usize,
2747 58u8,
2748 ) as u64)
2749 }
2750 }
2751 #[inline]
2752 pub unsafe fn set_cap_____res_raw(this: *mut Self, val: __u64) {
2753 unsafe {
2754 let val: u64 = ::std::mem::transmute(val);
2755 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2756 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2757 6usize,
2758 58u8,
2759 val as u64,
2760 )
2761 }
2762 }
2763 #[inline]
2764 pub fn new_bitfield_1(
2765 cap_bit0: __u64,
2766 cap_bit0_is_deprecated: __u64,
2767 cap_user_rdpmc: __u64,
2768 cap_user_time: __u64,
2769 cap_user_time_zero: __u64,
2770 cap_user_time_short: __u64,
2771 cap_____res: __u64,
2772 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2773 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2774 __bindgen_bitfield_unit.set(0usize, 1u8, {
2775 let cap_bit0: u64 = unsafe { ::std::mem::transmute(cap_bit0) };
2776 cap_bit0 as u64
2777 });
2778 __bindgen_bitfield_unit.set(1usize, 1u8, {
2779 let cap_bit0_is_deprecated: u64 =
2780 unsafe { ::std::mem::transmute(cap_bit0_is_deprecated) };
2781 cap_bit0_is_deprecated as u64
2782 });
2783 __bindgen_bitfield_unit.set(2usize, 1u8, {
2784 let cap_user_rdpmc: u64 = unsafe { ::std::mem::transmute(cap_user_rdpmc) };
2785 cap_user_rdpmc as u64
2786 });
2787 __bindgen_bitfield_unit.set(3usize, 1u8, {
2788 let cap_user_time: u64 = unsafe { ::std::mem::transmute(cap_user_time) };
2789 cap_user_time as u64
2790 });
2791 __bindgen_bitfield_unit.set(4usize, 1u8, {
2792 let cap_user_time_zero: u64 = unsafe { ::std::mem::transmute(cap_user_time_zero) };
2793 cap_user_time_zero as u64
2794 });
2795 __bindgen_bitfield_unit.set(5usize, 1u8, {
2796 let cap_user_time_short: u64 = unsafe { ::std::mem::transmute(cap_user_time_short) };
2797 cap_user_time_short as u64
2798 });
2799 __bindgen_bitfield_unit.set(6usize, 58u8, {
2800 let cap_____res: u64 = unsafe { ::std::mem::transmute(cap_____res) };
2801 cap_____res as u64
2802 });
2803 __bindgen_bitfield_unit
2804 }
2805}
2806#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2807const _: () = {
2808 ["Size of perf_event_mmap_page__bindgen_ty_1"]
2809 [::std::mem::size_of::<perf_event_mmap_page__bindgen_ty_1>() - 8usize];
2810 ["Alignment of perf_event_mmap_page__bindgen_ty_1"]
2811 [::std::mem::align_of::<perf_event_mmap_page__bindgen_ty_1>() - 8usize];
2812 ["Offset of field: perf_event_mmap_page__bindgen_ty_1::capabilities"]
2813 [::std::mem::offset_of!(perf_event_mmap_page__bindgen_ty_1, capabilities) - 0usize];
2814};
2815impl Default for perf_event_mmap_page__bindgen_ty_1 {
2816 fn default() -> Self {
2817 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2818 unsafe {
2819 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2820 s.assume_init()
2821 }
2822 }
2823}
2824impl ::std::fmt::Debug for perf_event_mmap_page__bindgen_ty_1 {
2825 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2826 write!(f, "perf_event_mmap_page__bindgen_ty_1 {{ union }}")
2827 }
2828}
2829#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2830const _: () = {
2831 ["Size of perf_event_mmap_page"][::std::mem::size_of::<perf_event_mmap_page>() - 1088usize];
2832 ["Alignment of perf_event_mmap_page"][::std::mem::align_of::<perf_event_mmap_page>() - 8usize];
2833 ["Offset of field: perf_event_mmap_page::version"]
2834 [::std::mem::offset_of!(perf_event_mmap_page, version) - 0usize];
2835 ["Offset of field: perf_event_mmap_page::compat_version"]
2836 [::std::mem::offset_of!(perf_event_mmap_page, compat_version) - 4usize];
2837 ["Offset of field: perf_event_mmap_page::lock"]
2838 [::std::mem::offset_of!(perf_event_mmap_page, lock) - 8usize];
2839 ["Offset of field: perf_event_mmap_page::index"]
2840 [::std::mem::offset_of!(perf_event_mmap_page, index) - 12usize];
2841 ["Offset of field: perf_event_mmap_page::offset"]
2842 [::std::mem::offset_of!(perf_event_mmap_page, offset) - 16usize];
2843 ["Offset of field: perf_event_mmap_page::time_enabled"]
2844 [::std::mem::offset_of!(perf_event_mmap_page, time_enabled) - 24usize];
2845 ["Offset of field: perf_event_mmap_page::time_running"]
2846 [::std::mem::offset_of!(perf_event_mmap_page, time_running) - 32usize];
2847 ["Offset of field: perf_event_mmap_page::pmc_width"]
2848 [::std::mem::offset_of!(perf_event_mmap_page, pmc_width) - 48usize];
2849 ["Offset of field: perf_event_mmap_page::time_shift"]
2850 [::std::mem::offset_of!(perf_event_mmap_page, time_shift) - 50usize];
2851 ["Offset of field: perf_event_mmap_page::time_mult"]
2852 [::std::mem::offset_of!(perf_event_mmap_page, time_mult) - 52usize];
2853 ["Offset of field: perf_event_mmap_page::time_offset"]
2854 [::std::mem::offset_of!(perf_event_mmap_page, time_offset) - 56usize];
2855 ["Offset of field: perf_event_mmap_page::time_zero"]
2856 [::std::mem::offset_of!(perf_event_mmap_page, time_zero) - 64usize];
2857 ["Offset of field: perf_event_mmap_page::size"]
2858 [::std::mem::offset_of!(perf_event_mmap_page, size) - 72usize];
2859 ["Offset of field: perf_event_mmap_page::__reserved_1"]
2860 [::std::mem::offset_of!(perf_event_mmap_page, __reserved_1) - 76usize];
2861 ["Offset of field: perf_event_mmap_page::time_cycles"]
2862 [::std::mem::offset_of!(perf_event_mmap_page, time_cycles) - 80usize];
2863 ["Offset of field: perf_event_mmap_page::time_mask"]
2864 [::std::mem::offset_of!(perf_event_mmap_page, time_mask) - 88usize];
2865 ["Offset of field: perf_event_mmap_page::__reserved"]
2866 [::std::mem::offset_of!(perf_event_mmap_page, __reserved) - 96usize];
2867 ["Offset of field: perf_event_mmap_page::data_head"]
2868 [::std::mem::offset_of!(perf_event_mmap_page, data_head) - 1024usize];
2869 ["Offset of field: perf_event_mmap_page::data_tail"]
2870 [::std::mem::offset_of!(perf_event_mmap_page, data_tail) - 1032usize];
2871 ["Offset of field: perf_event_mmap_page::data_offset"]
2872 [::std::mem::offset_of!(perf_event_mmap_page, data_offset) - 1040usize];
2873 ["Offset of field: perf_event_mmap_page::data_size"]
2874 [::std::mem::offset_of!(perf_event_mmap_page, data_size) - 1048usize];
2875 ["Offset of field: perf_event_mmap_page::aux_head"]
2876 [::std::mem::offset_of!(perf_event_mmap_page, aux_head) - 1056usize];
2877 ["Offset of field: perf_event_mmap_page::aux_tail"]
2878 [::std::mem::offset_of!(perf_event_mmap_page, aux_tail) - 1064usize];
2879 ["Offset of field: perf_event_mmap_page::aux_offset"]
2880 [::std::mem::offset_of!(perf_event_mmap_page, aux_offset) - 1072usize];
2881 ["Offset of field: perf_event_mmap_page::aux_size"]
2882 [::std::mem::offset_of!(perf_event_mmap_page, aux_size) - 1080usize];
2883};
2884impl Default for perf_event_mmap_page {
2885 fn default() -> Self {
2886 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2887 unsafe {
2888 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2889 s.assume_init()
2890 }
2891 }
2892}
2893impl ::std::fmt::Debug for perf_event_mmap_page {
2894 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2895 write ! (f , "perf_event_mmap_page {{ version: {:?}, compat_version: {:?}, lock: {:?}, index: {:?}, offset: {:?}, time_enabled: {:?}, time_running: {:?}, __bindgen_anon_1: {:?}, pmc_width: {:?}, time_shift: {:?}, time_mult: {:?}, time_offset: {:?}, time_zero: {:?}, size: {:?}, __reserved_1: {:?}, time_cycles: {:?}, time_mask: {:?}, __reserved: {:?}, data_head: {:?}, data_tail: {:?}, data_offset: {:?}, data_size: {:?}, aux_head: {:?}, aux_tail: {:?}, aux_offset: {:?}, aux_size: {:?} }}" , self . version , self . compat_version , self . lock , self . index , self . offset , self . time_enabled , self . time_running , self . __bindgen_anon_1 , self . pmc_width , self . time_shift , self . time_mult , self . time_offset , self . time_zero , self . size , self . __reserved_1 , self . time_cycles , self . time_mask , self . __reserved , self . data_head , self . data_tail , self . data_offset , self . data_size , self . aux_head , self . aux_tail , self . aux_offset , self . aux_size)
2896 }
2897}
2898#[repr(C)]
2899#[derive(Debug, Default, Copy, Clone)]
2900pub struct perf_event_header {
2901 pub type_: __u32,
2902 pub misc: __u16,
2903 pub size: __u16,
2904}
2905#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2906const _: () = {
2907 ["Size of perf_event_header"][::std::mem::size_of::<perf_event_header>() - 8usize];
2908 ["Alignment of perf_event_header"][::std::mem::align_of::<perf_event_header>() - 4usize];
2909 ["Offset of field: perf_event_header::type_"]
2910 [::std::mem::offset_of!(perf_event_header, type_) - 0usize];
2911 ["Offset of field: perf_event_header::misc"]
2912 [::std::mem::offset_of!(perf_event_header, misc) - 4usize];
2913 ["Offset of field: perf_event_header::size"]
2914 [::std::mem::offset_of!(perf_event_header, size) - 6usize];
2915};
2916#[repr(C)]
2917#[derive(Debug, Default, Copy, Clone)]
2918pub struct perf_ns_link_info {
2919 pub dev: __u64,
2920 pub ino: __u64,
2921}
2922#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2923const _: () = {
2924 ["Size of perf_ns_link_info"][::std::mem::size_of::<perf_ns_link_info>() - 16usize];
2925 ["Alignment of perf_ns_link_info"][::std::mem::align_of::<perf_ns_link_info>() - 8usize];
2926 ["Offset of field: perf_ns_link_info::dev"]
2927 [::std::mem::offset_of!(perf_ns_link_info, dev) - 0usize];
2928 ["Offset of field: perf_ns_link_info::ino"]
2929 [::std::mem::offset_of!(perf_ns_link_info, ino) - 8usize];
2930};
2931pub const NET_NS_INDEX: _bindgen_ty_6 = 0;
2932pub const UTS_NS_INDEX: _bindgen_ty_6 = 1;
2933pub const IPC_NS_INDEX: _bindgen_ty_6 = 2;
2934pub const PID_NS_INDEX: _bindgen_ty_6 = 3;
2935pub const USER_NS_INDEX: _bindgen_ty_6 = 4;
2936pub const MNT_NS_INDEX: _bindgen_ty_6 = 5;
2937pub const CGROUP_NS_INDEX: _bindgen_ty_6 = 6;
2938pub const NR_NAMESPACES: _bindgen_ty_6 = 7;
2939pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
2940pub const PERF_RECORD_MMAP: perf_event_type = 1;
2941pub const PERF_RECORD_LOST: perf_event_type = 2;
2942pub const PERF_RECORD_COMM: perf_event_type = 3;
2943pub const PERF_RECORD_EXIT: perf_event_type = 4;
2944pub const PERF_RECORD_THROTTLE: perf_event_type = 5;
2945pub const PERF_RECORD_UNTHROTTLE: perf_event_type = 6;
2946pub const PERF_RECORD_FORK: perf_event_type = 7;
2947pub const PERF_RECORD_READ: perf_event_type = 8;
2948pub const PERF_RECORD_SAMPLE: perf_event_type = 9;
2949pub const PERF_RECORD_MMAP2: perf_event_type = 10;
2950pub const PERF_RECORD_AUX: perf_event_type = 11;
2951pub const PERF_RECORD_ITRACE_START: perf_event_type = 12;
2952pub const PERF_RECORD_LOST_SAMPLES: perf_event_type = 13;
2953pub const PERF_RECORD_SWITCH: perf_event_type = 14;
2954pub const PERF_RECORD_SWITCH_CPU_WIDE: perf_event_type = 15;
2955pub const PERF_RECORD_NAMESPACES: perf_event_type = 16;
2956pub const PERF_RECORD_KSYMBOL: perf_event_type = 17;
2957pub const PERF_RECORD_BPF_EVENT: perf_event_type = 18;
2958pub const PERF_RECORD_CGROUP: perf_event_type = 19;
2959pub const PERF_RECORD_TEXT_POKE: perf_event_type = 20;
2960pub const PERF_RECORD_AUX_OUTPUT_HW_ID: perf_event_type = 21;
2961pub const PERF_RECORD_CALLCHAIN_DEFERRED: perf_event_type = 22;
2962pub const PERF_RECORD_MAX: perf_event_type = 23;
2963pub type perf_event_type = ::std::os::raw::c_uint;
2964pub const PERF_RECORD_KSYMBOL_TYPE_UNKNOWN: perf_record_ksymbol_type = 0;
2965pub const PERF_RECORD_KSYMBOL_TYPE_BPF: perf_record_ksymbol_type = 1;
2966pub const PERF_RECORD_KSYMBOL_TYPE_OOL: perf_record_ksymbol_type = 2;
2967pub const PERF_RECORD_KSYMBOL_TYPE_MAX: perf_record_ksymbol_type = 3;
2968pub type perf_record_ksymbol_type = ::std::os::raw::c_uint;
2969pub const PERF_BPF_EVENT_UNKNOWN: perf_bpf_event_type = 0;
2970pub const PERF_BPF_EVENT_PROG_LOAD: perf_bpf_event_type = 1;
2971pub const PERF_BPF_EVENT_PROG_UNLOAD: perf_bpf_event_type = 2;
2972pub const PERF_BPF_EVENT_MAX: perf_bpf_event_type = 3;
2973pub type perf_bpf_event_type = ::std::os::raw::c_uint;
2974pub const PERF_CONTEXT_HV: perf_callchain_context = 18446744073709551584;
2975pub const PERF_CONTEXT_KERNEL: perf_callchain_context = 18446744073709551488;
2976pub const PERF_CONTEXT_USER: perf_callchain_context = 18446744073709551104;
2977pub const PERF_CONTEXT_USER_DEFERRED: perf_callchain_context = 18446744073709550976;
2978pub const PERF_CONTEXT_GUEST: perf_callchain_context = 18446744073709549568;
2979pub const PERF_CONTEXT_GUEST_KERNEL: perf_callchain_context = 18446744073709549440;
2980pub const PERF_CONTEXT_GUEST_USER: perf_callchain_context = 18446744073709549056;
2981pub const PERF_CONTEXT_MAX: perf_callchain_context = 18446744073709547521;
2982pub type perf_callchain_context = ::std::os::raw::c_ulong;
2983#[repr(C)]
2984#[derive(Copy, Clone)]
2985pub union perf_mem_data_src {
2986 pub val: __u64,
2987 pub __bindgen_anon_1: perf_mem_data_src__bindgen_ty_1,
2988}
2989#[repr(C)]
2990#[repr(align(8))]
2991#[derive(Debug, Default, Copy, Clone)]
2992pub struct perf_mem_data_src__bindgen_ty_1 {
2993 pub _bitfield_align_1: [u16; 0],
2994 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2995}
2996#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2997const _: () = {
2998 ["Size of perf_mem_data_src__bindgen_ty_1"]
2999 [::std::mem::size_of::<perf_mem_data_src__bindgen_ty_1>() - 8usize];
3000 ["Alignment of perf_mem_data_src__bindgen_ty_1"]
3001 [::std::mem::align_of::<perf_mem_data_src__bindgen_ty_1>() - 8usize];
3002};
3003impl perf_mem_data_src__bindgen_ty_1 {
3004 #[inline]
3005 pub fn mem_op(&self) -> __u64 {
3006 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u64) }
3007 }
3008 #[inline]
3009 pub fn set_mem_op(&mut self, val: __u64) {
3010 unsafe {
3011 let val: u64 = ::std::mem::transmute(val);
3012 self._bitfield_1.set(0usize, 5u8, val as u64)
3013 }
3014 }
3015 #[inline]
3016 pub unsafe fn mem_op_raw(this: *const Self) -> __u64 {
3017 unsafe {
3018 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3019 ::std::ptr::addr_of!((*this)._bitfield_1),
3020 0usize,
3021 5u8,
3022 ) as u64)
3023 }
3024 }
3025 #[inline]
3026 pub unsafe fn set_mem_op_raw(this: *mut Self, val: __u64) {
3027 unsafe {
3028 let val: u64 = ::std::mem::transmute(val);
3029 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3030 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3031 0usize,
3032 5u8,
3033 val as u64,
3034 )
3035 }
3036 }
3037 #[inline]
3038 pub fn mem_lvl(&self) -> __u64 {
3039 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 14u8) as u64) }
3040 }
3041 #[inline]
3042 pub fn set_mem_lvl(&mut self, val: __u64) {
3043 unsafe {
3044 let val: u64 = ::std::mem::transmute(val);
3045 self._bitfield_1.set(5usize, 14u8, val as u64)
3046 }
3047 }
3048 #[inline]
3049 pub unsafe fn mem_lvl_raw(this: *const Self) -> __u64 {
3050 unsafe {
3051 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3052 ::std::ptr::addr_of!((*this)._bitfield_1),
3053 5usize,
3054 14u8,
3055 ) as u64)
3056 }
3057 }
3058 #[inline]
3059 pub unsafe fn set_mem_lvl_raw(this: *mut Self, val: __u64) {
3060 unsafe {
3061 let val: u64 = ::std::mem::transmute(val);
3062 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3063 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3064 5usize,
3065 14u8,
3066 val as u64,
3067 )
3068 }
3069 }
3070 #[inline]
3071 pub fn mem_snoop(&self) -> __u64 {
3072 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 5u8) as u64) }
3073 }
3074 #[inline]
3075 pub fn set_mem_snoop(&mut self, val: __u64) {
3076 unsafe {
3077 let val: u64 = ::std::mem::transmute(val);
3078 self._bitfield_1.set(19usize, 5u8, val as u64)
3079 }
3080 }
3081 #[inline]
3082 pub unsafe fn mem_snoop_raw(this: *const Self) -> __u64 {
3083 unsafe {
3084 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3085 ::std::ptr::addr_of!((*this)._bitfield_1),
3086 19usize,
3087 5u8,
3088 ) as u64)
3089 }
3090 }
3091 #[inline]
3092 pub unsafe fn set_mem_snoop_raw(this: *mut Self, val: __u64) {
3093 unsafe {
3094 let val: u64 = ::std::mem::transmute(val);
3095 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3096 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3097 19usize,
3098 5u8,
3099 val as u64,
3100 )
3101 }
3102 }
3103 #[inline]
3104 pub fn mem_lock(&self) -> __u64 {
3105 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u64) }
3106 }
3107 #[inline]
3108 pub fn set_mem_lock(&mut self, val: __u64) {
3109 unsafe {
3110 let val: u64 = ::std::mem::transmute(val);
3111 self._bitfield_1.set(24usize, 2u8, val as u64)
3112 }
3113 }
3114 #[inline]
3115 pub unsafe fn mem_lock_raw(this: *const Self) -> __u64 {
3116 unsafe {
3117 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3118 ::std::ptr::addr_of!((*this)._bitfield_1),
3119 24usize,
3120 2u8,
3121 ) as u64)
3122 }
3123 }
3124 #[inline]
3125 pub unsafe fn set_mem_lock_raw(this: *mut Self, val: __u64) {
3126 unsafe {
3127 let val: u64 = ::std::mem::transmute(val);
3128 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3129 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3130 24usize,
3131 2u8,
3132 val as u64,
3133 )
3134 }
3135 }
3136 #[inline]
3137 pub fn mem_dtlb(&self) -> __u64 {
3138 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 7u8) as u64) }
3139 }
3140 #[inline]
3141 pub fn set_mem_dtlb(&mut self, val: __u64) {
3142 unsafe {
3143 let val: u64 = ::std::mem::transmute(val);
3144 self._bitfield_1.set(26usize, 7u8, val as u64)
3145 }
3146 }
3147 #[inline]
3148 pub unsafe fn mem_dtlb_raw(this: *const Self) -> __u64 {
3149 unsafe {
3150 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3151 ::std::ptr::addr_of!((*this)._bitfield_1),
3152 26usize,
3153 7u8,
3154 ) as u64)
3155 }
3156 }
3157 #[inline]
3158 pub unsafe fn set_mem_dtlb_raw(this: *mut Self, val: __u64) {
3159 unsafe {
3160 let val: u64 = ::std::mem::transmute(val);
3161 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3162 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3163 26usize,
3164 7u8,
3165 val as u64,
3166 )
3167 }
3168 }
3169 #[inline]
3170 pub fn mem_lvl_num(&self) -> __u64 {
3171 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 4u8) as u64) }
3172 }
3173 #[inline]
3174 pub fn set_mem_lvl_num(&mut self, val: __u64) {
3175 unsafe {
3176 let val: u64 = ::std::mem::transmute(val);
3177 self._bitfield_1.set(33usize, 4u8, val as u64)
3178 }
3179 }
3180 #[inline]
3181 pub unsafe fn mem_lvl_num_raw(this: *const Self) -> __u64 {
3182 unsafe {
3183 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3184 ::std::ptr::addr_of!((*this)._bitfield_1),
3185 33usize,
3186 4u8,
3187 ) as u64)
3188 }
3189 }
3190 #[inline]
3191 pub unsafe fn set_mem_lvl_num_raw(this: *mut Self, val: __u64) {
3192 unsafe {
3193 let val: u64 = ::std::mem::transmute(val);
3194 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3195 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3196 33usize,
3197 4u8,
3198 val as u64,
3199 )
3200 }
3201 }
3202 #[inline]
3203 pub fn mem_remote(&self) -> __u64 {
3204 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
3205 }
3206 #[inline]
3207 pub fn set_mem_remote(&mut self, val: __u64) {
3208 unsafe {
3209 let val: u64 = ::std::mem::transmute(val);
3210 self._bitfield_1.set(37usize, 1u8, val as u64)
3211 }
3212 }
3213 #[inline]
3214 pub unsafe fn mem_remote_raw(this: *const Self) -> __u64 {
3215 unsafe {
3216 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3217 ::std::ptr::addr_of!((*this)._bitfield_1),
3218 37usize,
3219 1u8,
3220 ) as u64)
3221 }
3222 }
3223 #[inline]
3224 pub unsafe fn set_mem_remote_raw(this: *mut Self, val: __u64) {
3225 unsafe {
3226 let val: u64 = ::std::mem::transmute(val);
3227 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3228 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3229 37usize,
3230 1u8,
3231 val as u64,
3232 )
3233 }
3234 }
3235 #[inline]
3236 pub fn mem_snoopx(&self) -> __u64 {
3237 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 2u8) as u64) }
3238 }
3239 #[inline]
3240 pub fn set_mem_snoopx(&mut self, val: __u64) {
3241 unsafe {
3242 let val: u64 = ::std::mem::transmute(val);
3243 self._bitfield_1.set(38usize, 2u8, val as u64)
3244 }
3245 }
3246 #[inline]
3247 pub unsafe fn mem_snoopx_raw(this: *const Self) -> __u64 {
3248 unsafe {
3249 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3250 ::std::ptr::addr_of!((*this)._bitfield_1),
3251 38usize,
3252 2u8,
3253 ) as u64)
3254 }
3255 }
3256 #[inline]
3257 pub unsafe fn set_mem_snoopx_raw(this: *mut Self, val: __u64) {
3258 unsafe {
3259 let val: u64 = ::std::mem::transmute(val);
3260 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3261 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3262 38usize,
3263 2u8,
3264 val as u64,
3265 )
3266 }
3267 }
3268 #[inline]
3269 pub fn mem_blk(&self) -> __u64 {
3270 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 3u8) as u64) }
3271 }
3272 #[inline]
3273 pub fn set_mem_blk(&mut self, val: __u64) {
3274 unsafe {
3275 let val: u64 = ::std::mem::transmute(val);
3276 self._bitfield_1.set(40usize, 3u8, val as u64)
3277 }
3278 }
3279 #[inline]
3280 pub unsafe fn mem_blk_raw(this: *const Self) -> __u64 {
3281 unsafe {
3282 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3283 ::std::ptr::addr_of!((*this)._bitfield_1),
3284 40usize,
3285 3u8,
3286 ) as u64)
3287 }
3288 }
3289 #[inline]
3290 pub unsafe fn set_mem_blk_raw(this: *mut Self, val: __u64) {
3291 unsafe {
3292 let val: u64 = ::std::mem::transmute(val);
3293 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3294 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3295 40usize,
3296 3u8,
3297 val as u64,
3298 )
3299 }
3300 }
3301 #[inline]
3302 pub fn mem_hops(&self) -> __u64 {
3303 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 3u8) as u64) }
3304 }
3305 #[inline]
3306 pub fn set_mem_hops(&mut self, val: __u64) {
3307 unsafe {
3308 let val: u64 = ::std::mem::transmute(val);
3309 self._bitfield_1.set(43usize, 3u8, val as u64)
3310 }
3311 }
3312 #[inline]
3313 pub unsafe fn mem_hops_raw(this: *const Self) -> __u64 {
3314 unsafe {
3315 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3316 ::std::ptr::addr_of!((*this)._bitfield_1),
3317 43usize,
3318 3u8,
3319 ) as u64)
3320 }
3321 }
3322 #[inline]
3323 pub unsafe fn set_mem_hops_raw(this: *mut Self, val: __u64) {
3324 unsafe {
3325 let val: u64 = ::std::mem::transmute(val);
3326 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3327 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3328 43usize,
3329 3u8,
3330 val as u64,
3331 )
3332 }
3333 }
3334 #[inline]
3335 pub fn mem_region(&self) -> __u64 {
3336 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 5u8) as u64) }
3337 }
3338 #[inline]
3339 pub fn set_mem_region(&mut self, val: __u64) {
3340 unsafe {
3341 let val: u64 = ::std::mem::transmute(val);
3342 self._bitfield_1.set(46usize, 5u8, val as u64)
3343 }
3344 }
3345 #[inline]
3346 pub unsafe fn mem_region_raw(this: *const Self) -> __u64 {
3347 unsafe {
3348 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3349 ::std::ptr::addr_of!((*this)._bitfield_1),
3350 46usize,
3351 5u8,
3352 ) as u64)
3353 }
3354 }
3355 #[inline]
3356 pub unsafe fn set_mem_region_raw(this: *mut Self, val: __u64) {
3357 unsafe {
3358 let val: u64 = ::std::mem::transmute(val);
3359 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3360 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3361 46usize,
3362 5u8,
3363 val as u64,
3364 )
3365 }
3366 }
3367 #[inline]
3368 pub fn mem_rsvd(&self) -> __u64 {
3369 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 13u8) as u64) }
3370 }
3371 #[inline]
3372 pub fn set_mem_rsvd(&mut self, val: __u64) {
3373 unsafe {
3374 let val: u64 = ::std::mem::transmute(val);
3375 self._bitfield_1.set(51usize, 13u8, val as u64)
3376 }
3377 }
3378 #[inline]
3379 pub unsafe fn mem_rsvd_raw(this: *const Self) -> __u64 {
3380 unsafe {
3381 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3382 ::std::ptr::addr_of!((*this)._bitfield_1),
3383 51usize,
3384 13u8,
3385 ) as u64)
3386 }
3387 }
3388 #[inline]
3389 pub unsafe fn set_mem_rsvd_raw(this: *mut Self, val: __u64) {
3390 unsafe {
3391 let val: u64 = ::std::mem::transmute(val);
3392 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3393 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3394 51usize,
3395 13u8,
3396 val as u64,
3397 )
3398 }
3399 }
3400 #[inline]
3401 pub fn new_bitfield_1(
3402 mem_op: __u64,
3403 mem_lvl: __u64,
3404 mem_snoop: __u64,
3405 mem_lock: __u64,
3406 mem_dtlb: __u64,
3407 mem_lvl_num: __u64,
3408 mem_remote: __u64,
3409 mem_snoopx: __u64,
3410 mem_blk: __u64,
3411 mem_hops: __u64,
3412 mem_region: __u64,
3413 mem_rsvd: __u64,
3414 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3415 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3416 __bindgen_bitfield_unit.set(0usize, 5u8, {
3417 let mem_op: u64 = unsafe { ::std::mem::transmute(mem_op) };
3418 mem_op as u64
3419 });
3420 __bindgen_bitfield_unit.set(5usize, 14u8, {
3421 let mem_lvl: u64 = unsafe { ::std::mem::transmute(mem_lvl) };
3422 mem_lvl as u64
3423 });
3424 __bindgen_bitfield_unit.set(19usize, 5u8, {
3425 let mem_snoop: u64 = unsafe { ::std::mem::transmute(mem_snoop) };
3426 mem_snoop as u64
3427 });
3428 __bindgen_bitfield_unit.set(24usize, 2u8, {
3429 let mem_lock: u64 = unsafe { ::std::mem::transmute(mem_lock) };
3430 mem_lock as u64
3431 });
3432 __bindgen_bitfield_unit.set(26usize, 7u8, {
3433 let mem_dtlb: u64 = unsafe { ::std::mem::transmute(mem_dtlb) };
3434 mem_dtlb as u64
3435 });
3436 __bindgen_bitfield_unit.set(33usize, 4u8, {
3437 let mem_lvl_num: u64 = unsafe { ::std::mem::transmute(mem_lvl_num) };
3438 mem_lvl_num as u64
3439 });
3440 __bindgen_bitfield_unit.set(37usize, 1u8, {
3441 let mem_remote: u64 = unsafe { ::std::mem::transmute(mem_remote) };
3442 mem_remote as u64
3443 });
3444 __bindgen_bitfield_unit.set(38usize, 2u8, {
3445 let mem_snoopx: u64 = unsafe { ::std::mem::transmute(mem_snoopx) };
3446 mem_snoopx as u64
3447 });
3448 __bindgen_bitfield_unit.set(40usize, 3u8, {
3449 let mem_blk: u64 = unsafe { ::std::mem::transmute(mem_blk) };
3450 mem_blk as u64
3451 });
3452 __bindgen_bitfield_unit.set(43usize, 3u8, {
3453 let mem_hops: u64 = unsafe { ::std::mem::transmute(mem_hops) };
3454 mem_hops as u64
3455 });
3456 __bindgen_bitfield_unit.set(46usize, 5u8, {
3457 let mem_region: u64 = unsafe { ::std::mem::transmute(mem_region) };
3458 mem_region as u64
3459 });
3460 __bindgen_bitfield_unit.set(51usize, 13u8, {
3461 let mem_rsvd: u64 = unsafe { ::std::mem::transmute(mem_rsvd) };
3462 mem_rsvd as u64
3463 });
3464 __bindgen_bitfield_unit
3465 }
3466}
3467#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3468const _: () = {
3469 ["Size of perf_mem_data_src"][::std::mem::size_of::<perf_mem_data_src>() - 8usize];
3470 ["Alignment of perf_mem_data_src"][::std::mem::align_of::<perf_mem_data_src>() - 8usize];
3471 ["Offset of field: perf_mem_data_src::val"]
3472 [::std::mem::offset_of!(perf_mem_data_src, val) - 0usize];
3473};
3474impl Default for perf_mem_data_src {
3475 fn default() -> Self {
3476 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3477 unsafe {
3478 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3479 s.assume_init()
3480 }
3481 }
3482}
3483impl ::std::fmt::Debug for perf_mem_data_src {
3484 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3485 write!(f, "perf_mem_data_src {{ union }}")
3486 }
3487}
3488#[repr(C)]
3489#[derive(Debug, Default, Copy, Clone)]
3490pub struct perf_branch_entry {
3491 pub from: __u64,
3492 pub to: __u64,
3493 pub _bitfield_align_1: [u32; 0],
3494 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3495}
3496#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3497const _: () = {
3498 ["Size of perf_branch_entry"][::std::mem::size_of::<perf_branch_entry>() - 24usize];
3499 ["Alignment of perf_branch_entry"][::std::mem::align_of::<perf_branch_entry>() - 8usize];
3500 ["Offset of field: perf_branch_entry::from"]
3501 [::std::mem::offset_of!(perf_branch_entry, from) - 0usize];
3502 ["Offset of field: perf_branch_entry::to"]
3503 [::std::mem::offset_of!(perf_branch_entry, to) - 8usize];
3504};
3505impl perf_branch_entry {
3506 #[inline]
3507 pub fn mispred(&self) -> __u64 {
3508 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3509 }
3510 #[inline]
3511 pub fn set_mispred(&mut self, val: __u64) {
3512 unsafe {
3513 let val: u64 = ::std::mem::transmute(val);
3514 self._bitfield_1.set(0usize, 1u8, val as u64)
3515 }
3516 }
3517 #[inline]
3518 pub unsafe fn mispred_raw(this: *const Self) -> __u64 {
3519 unsafe {
3520 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3521 ::std::ptr::addr_of!((*this)._bitfield_1),
3522 0usize,
3523 1u8,
3524 ) as u64)
3525 }
3526 }
3527 #[inline]
3528 pub unsafe fn set_mispred_raw(this: *mut Self, val: __u64) {
3529 unsafe {
3530 let val: u64 = ::std::mem::transmute(val);
3531 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3532 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3533 0usize,
3534 1u8,
3535 val as u64,
3536 )
3537 }
3538 }
3539 #[inline]
3540 pub fn predicted(&self) -> __u64 {
3541 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
3542 }
3543 #[inline]
3544 pub fn set_predicted(&mut self, val: __u64) {
3545 unsafe {
3546 let val: u64 = ::std::mem::transmute(val);
3547 self._bitfield_1.set(1usize, 1u8, val as u64)
3548 }
3549 }
3550 #[inline]
3551 pub unsafe fn predicted_raw(this: *const Self) -> __u64 {
3552 unsafe {
3553 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3554 ::std::ptr::addr_of!((*this)._bitfield_1),
3555 1usize,
3556 1u8,
3557 ) as u64)
3558 }
3559 }
3560 #[inline]
3561 pub unsafe fn set_predicted_raw(this: *mut Self, val: __u64) {
3562 unsafe {
3563 let val: u64 = ::std::mem::transmute(val);
3564 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3565 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3566 1usize,
3567 1u8,
3568 val as u64,
3569 )
3570 }
3571 }
3572 #[inline]
3573 pub fn in_tx(&self) -> __u64 {
3574 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
3575 }
3576 #[inline]
3577 pub fn set_in_tx(&mut self, val: __u64) {
3578 unsafe {
3579 let val: u64 = ::std::mem::transmute(val);
3580 self._bitfield_1.set(2usize, 1u8, val as u64)
3581 }
3582 }
3583 #[inline]
3584 pub unsafe fn in_tx_raw(this: *const Self) -> __u64 {
3585 unsafe {
3586 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3587 ::std::ptr::addr_of!((*this)._bitfield_1),
3588 2usize,
3589 1u8,
3590 ) as u64)
3591 }
3592 }
3593 #[inline]
3594 pub unsafe fn set_in_tx_raw(this: *mut Self, val: __u64) {
3595 unsafe {
3596 let val: u64 = ::std::mem::transmute(val);
3597 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3598 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3599 2usize,
3600 1u8,
3601 val as u64,
3602 )
3603 }
3604 }
3605 #[inline]
3606 pub fn abort(&self) -> __u64 {
3607 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
3608 }
3609 #[inline]
3610 pub fn set_abort(&mut self, val: __u64) {
3611 unsafe {
3612 let val: u64 = ::std::mem::transmute(val);
3613 self._bitfield_1.set(3usize, 1u8, val as u64)
3614 }
3615 }
3616 #[inline]
3617 pub unsafe fn abort_raw(this: *const Self) -> __u64 {
3618 unsafe {
3619 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3620 ::std::ptr::addr_of!((*this)._bitfield_1),
3621 3usize,
3622 1u8,
3623 ) as u64)
3624 }
3625 }
3626 #[inline]
3627 pub unsafe fn set_abort_raw(this: *mut Self, val: __u64) {
3628 unsafe {
3629 let val: u64 = ::std::mem::transmute(val);
3630 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3631 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3632 3usize,
3633 1u8,
3634 val as u64,
3635 )
3636 }
3637 }
3638 #[inline]
3639 pub fn cycles(&self) -> __u64 {
3640 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 16u8) as u64) }
3641 }
3642 #[inline]
3643 pub fn set_cycles(&mut self, val: __u64) {
3644 unsafe {
3645 let val: u64 = ::std::mem::transmute(val);
3646 self._bitfield_1.set(4usize, 16u8, val as u64)
3647 }
3648 }
3649 #[inline]
3650 pub unsafe fn cycles_raw(this: *const Self) -> __u64 {
3651 unsafe {
3652 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3653 ::std::ptr::addr_of!((*this)._bitfield_1),
3654 4usize,
3655 16u8,
3656 ) as u64)
3657 }
3658 }
3659 #[inline]
3660 pub unsafe fn set_cycles_raw(this: *mut Self, val: __u64) {
3661 unsafe {
3662 let val: u64 = ::std::mem::transmute(val);
3663 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3664 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3665 4usize,
3666 16u8,
3667 val as u64,
3668 )
3669 }
3670 }
3671 #[inline]
3672 pub fn type_(&self) -> __u64 {
3673 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 4u8) as u64) }
3674 }
3675 #[inline]
3676 pub fn set_type(&mut self, val: __u64) {
3677 unsafe {
3678 let val: u64 = ::std::mem::transmute(val);
3679 self._bitfield_1.set(20usize, 4u8, val as u64)
3680 }
3681 }
3682 #[inline]
3683 pub unsafe fn type__raw(this: *const Self) -> __u64 {
3684 unsafe {
3685 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3686 ::std::ptr::addr_of!((*this)._bitfield_1),
3687 20usize,
3688 4u8,
3689 ) as u64)
3690 }
3691 }
3692 #[inline]
3693 pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
3694 unsafe {
3695 let val: u64 = ::std::mem::transmute(val);
3696 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3697 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3698 20usize,
3699 4u8,
3700 val as u64,
3701 )
3702 }
3703 }
3704 #[inline]
3705 pub fn spec(&self) -> __u64 {
3706 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u64) }
3707 }
3708 #[inline]
3709 pub fn set_spec(&mut self, val: __u64) {
3710 unsafe {
3711 let val: u64 = ::std::mem::transmute(val);
3712 self._bitfield_1.set(24usize, 2u8, val as u64)
3713 }
3714 }
3715 #[inline]
3716 pub unsafe fn spec_raw(this: *const Self) -> __u64 {
3717 unsafe {
3718 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3719 ::std::ptr::addr_of!((*this)._bitfield_1),
3720 24usize,
3721 2u8,
3722 ) as u64)
3723 }
3724 }
3725 #[inline]
3726 pub unsafe fn set_spec_raw(this: *mut Self, val: __u64) {
3727 unsafe {
3728 let val: u64 = ::std::mem::transmute(val);
3729 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3730 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3731 24usize,
3732 2u8,
3733 val as u64,
3734 )
3735 }
3736 }
3737 #[inline]
3738 pub fn new_type(&self) -> __u64 {
3739 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 4u8) as u64) }
3740 }
3741 #[inline]
3742 pub fn set_new_type(&mut self, val: __u64) {
3743 unsafe {
3744 let val: u64 = ::std::mem::transmute(val);
3745 self._bitfield_1.set(26usize, 4u8, val as u64)
3746 }
3747 }
3748 #[inline]
3749 pub unsafe fn new_type_raw(this: *const Self) -> __u64 {
3750 unsafe {
3751 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3752 ::std::ptr::addr_of!((*this)._bitfield_1),
3753 26usize,
3754 4u8,
3755 ) as u64)
3756 }
3757 }
3758 #[inline]
3759 pub unsafe fn set_new_type_raw(this: *mut Self, val: __u64) {
3760 unsafe {
3761 let val: u64 = ::std::mem::transmute(val);
3762 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3763 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3764 26usize,
3765 4u8,
3766 val as u64,
3767 )
3768 }
3769 }
3770 #[inline]
3771 pub fn priv_(&self) -> __u64 {
3772 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 3u8) as u64) }
3773 }
3774 #[inline]
3775 pub fn set_priv(&mut self, val: __u64) {
3776 unsafe {
3777 let val: u64 = ::std::mem::transmute(val);
3778 self._bitfield_1.set(30usize, 3u8, val as u64)
3779 }
3780 }
3781 #[inline]
3782 pub unsafe fn priv__raw(this: *const Self) -> __u64 {
3783 unsafe {
3784 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3785 ::std::ptr::addr_of!((*this)._bitfield_1),
3786 30usize,
3787 3u8,
3788 ) as u64)
3789 }
3790 }
3791 #[inline]
3792 pub unsafe fn set_priv_raw(this: *mut Self, val: __u64) {
3793 unsafe {
3794 let val: u64 = ::std::mem::transmute(val);
3795 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3796 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3797 30usize,
3798 3u8,
3799 val as u64,
3800 )
3801 }
3802 }
3803 #[inline]
3804 pub fn reserved(&self) -> __u64 {
3805 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 31u8) as u64) }
3806 }
3807 #[inline]
3808 pub fn set_reserved(&mut self, val: __u64) {
3809 unsafe {
3810 let val: u64 = ::std::mem::transmute(val);
3811 self._bitfield_1.set(33usize, 31u8, val as u64)
3812 }
3813 }
3814 #[inline]
3815 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
3816 unsafe {
3817 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3818 ::std::ptr::addr_of!((*this)._bitfield_1),
3819 33usize,
3820 31u8,
3821 ) as u64)
3822 }
3823 }
3824 #[inline]
3825 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
3826 unsafe {
3827 let val: u64 = ::std::mem::transmute(val);
3828 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3829 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3830 33usize,
3831 31u8,
3832 val as u64,
3833 )
3834 }
3835 }
3836 #[inline]
3837 pub fn new_bitfield_1(
3838 mispred: __u64,
3839 predicted: __u64,
3840 in_tx: __u64,
3841 abort: __u64,
3842 cycles: __u64,
3843 type_: __u64,
3844 spec: __u64,
3845 new_type: __u64,
3846 priv_: __u64,
3847 reserved: __u64,
3848 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3849 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3850 __bindgen_bitfield_unit.set(0usize, 1u8, {
3851 let mispred: u64 = unsafe { ::std::mem::transmute(mispred) };
3852 mispred as u64
3853 });
3854 __bindgen_bitfield_unit.set(1usize, 1u8, {
3855 let predicted: u64 = unsafe { ::std::mem::transmute(predicted) };
3856 predicted as u64
3857 });
3858 __bindgen_bitfield_unit.set(2usize, 1u8, {
3859 let in_tx: u64 = unsafe { ::std::mem::transmute(in_tx) };
3860 in_tx as u64
3861 });
3862 __bindgen_bitfield_unit.set(3usize, 1u8, {
3863 let abort: u64 = unsafe { ::std::mem::transmute(abort) };
3864 abort as u64
3865 });
3866 __bindgen_bitfield_unit.set(4usize, 16u8, {
3867 let cycles: u64 = unsafe { ::std::mem::transmute(cycles) };
3868 cycles as u64
3869 });
3870 __bindgen_bitfield_unit.set(20usize, 4u8, {
3871 let type_: u64 = unsafe { ::std::mem::transmute(type_) };
3872 type_ as u64
3873 });
3874 __bindgen_bitfield_unit.set(24usize, 2u8, {
3875 let spec: u64 = unsafe { ::std::mem::transmute(spec) };
3876 spec as u64
3877 });
3878 __bindgen_bitfield_unit.set(26usize, 4u8, {
3879 let new_type: u64 = unsafe { ::std::mem::transmute(new_type) };
3880 new_type as u64
3881 });
3882 __bindgen_bitfield_unit.set(30usize, 3u8, {
3883 let priv_: u64 = unsafe { ::std::mem::transmute(priv_) };
3884 priv_ as u64
3885 });
3886 __bindgen_bitfield_unit.set(33usize, 31u8, {
3887 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3888 reserved as u64
3889 });
3890 __bindgen_bitfield_unit
3891 }
3892}
3893#[repr(C)]
3894#[derive(Copy, Clone)]
3895pub union perf_sample_weight {
3896 pub full: __u64,
3897 pub __bindgen_anon_1: perf_sample_weight__bindgen_ty_1,
3898}
3899#[repr(C)]
3900#[derive(Debug, Default, Copy, Clone)]
3901pub struct perf_sample_weight__bindgen_ty_1 {
3902 pub var1_dw: __u32,
3903 pub var2_w: __u16,
3904 pub var3_w: __u16,
3905}
3906#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3907const _: () = {
3908 ["Size of perf_sample_weight__bindgen_ty_1"]
3909 [::std::mem::size_of::<perf_sample_weight__bindgen_ty_1>() - 8usize];
3910 ["Alignment of perf_sample_weight__bindgen_ty_1"]
3911 [::std::mem::align_of::<perf_sample_weight__bindgen_ty_1>() - 4usize];
3912 ["Offset of field: perf_sample_weight__bindgen_ty_1::var1_dw"]
3913 [::std::mem::offset_of!(perf_sample_weight__bindgen_ty_1, var1_dw) - 0usize];
3914 ["Offset of field: perf_sample_weight__bindgen_ty_1::var2_w"]
3915 [::std::mem::offset_of!(perf_sample_weight__bindgen_ty_1, var2_w) - 4usize];
3916 ["Offset of field: perf_sample_weight__bindgen_ty_1::var3_w"]
3917 [::std::mem::offset_of!(perf_sample_weight__bindgen_ty_1, var3_w) - 6usize];
3918};
3919#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3920const _: () = {
3921 ["Size of perf_sample_weight"][::std::mem::size_of::<perf_sample_weight>() - 8usize];
3922 ["Alignment of perf_sample_weight"][::std::mem::align_of::<perf_sample_weight>() - 8usize];
3923 ["Offset of field: perf_sample_weight::full"]
3924 [::std::mem::offset_of!(perf_sample_weight, full) - 0usize];
3925};
3926impl Default for perf_sample_weight {
3927 fn default() -> Self {
3928 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3929 unsafe {
3930 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3931 s.assume_init()
3932 }
3933 }
3934}
3935impl ::std::fmt::Debug for perf_sample_weight {
3936 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3937 write!(f, "perf_sample_weight {{ union }}")
3938 }
3939}
3940pub const HW_BREAKPOINT_LEN_1: _bindgen_ty_7 = 1;
3941pub const HW_BREAKPOINT_LEN_2: _bindgen_ty_7 = 2;
3942pub const HW_BREAKPOINT_LEN_3: _bindgen_ty_7 = 3;
3943pub const HW_BREAKPOINT_LEN_4: _bindgen_ty_7 = 4;
3944pub const HW_BREAKPOINT_LEN_5: _bindgen_ty_7 = 5;
3945pub const HW_BREAKPOINT_LEN_6: _bindgen_ty_7 = 6;
3946pub const HW_BREAKPOINT_LEN_7: _bindgen_ty_7 = 7;
3947pub const HW_BREAKPOINT_LEN_8: _bindgen_ty_7 = 8;
3948pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
3949pub const HW_BREAKPOINT_EMPTY: _bindgen_ty_8 = 0;
3950pub const HW_BREAKPOINT_R: _bindgen_ty_8 = 1;
3951pub const HW_BREAKPOINT_W: _bindgen_ty_8 = 2;
3952pub const HW_BREAKPOINT_RW: _bindgen_ty_8 = 3;
3953pub const HW_BREAKPOINT_X: _bindgen_ty_8 = 4;
3954pub const HW_BREAKPOINT_INVALID: _bindgen_ty_8 = 7;
3955pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
3956pub const PERF_REG_X86_AX: perf_event_x86_regs = 0;
3957pub const PERF_REG_X86_BX: perf_event_x86_regs = 1;
3958pub const PERF_REG_X86_CX: perf_event_x86_regs = 2;
3959pub const PERF_REG_X86_DX: perf_event_x86_regs = 3;
3960pub const PERF_REG_X86_SI: perf_event_x86_regs = 4;
3961pub const PERF_REG_X86_DI: perf_event_x86_regs = 5;
3962pub const PERF_REG_X86_BP: perf_event_x86_regs = 6;
3963pub const PERF_REG_X86_SP: perf_event_x86_regs = 7;
3964pub const PERF_REG_X86_IP: perf_event_x86_regs = 8;
3965pub const PERF_REG_X86_FLAGS: perf_event_x86_regs = 9;
3966pub const PERF_REG_X86_CS: perf_event_x86_regs = 10;
3967pub const PERF_REG_X86_SS: perf_event_x86_regs = 11;
3968pub const PERF_REG_X86_DS: perf_event_x86_regs = 12;
3969pub const PERF_REG_X86_ES: perf_event_x86_regs = 13;
3970pub const PERF_REG_X86_FS: perf_event_x86_regs = 14;
3971pub const PERF_REG_X86_GS: perf_event_x86_regs = 15;
3972pub const PERF_REG_X86_R8: perf_event_x86_regs = 16;
3973pub const PERF_REG_X86_R9: perf_event_x86_regs = 17;
3974pub const PERF_REG_X86_R10: perf_event_x86_regs = 18;
3975pub const PERF_REG_X86_R11: perf_event_x86_regs = 19;
3976pub const PERF_REG_X86_R12: perf_event_x86_regs = 20;
3977pub const PERF_REG_X86_R13: perf_event_x86_regs = 21;
3978pub const PERF_REG_X86_R14: perf_event_x86_regs = 22;
3979pub const PERF_REG_X86_R15: perf_event_x86_regs = 23;
3980pub const PERF_REG_X86_32_MAX: perf_event_x86_regs = 16;
3981pub const PERF_REG_X86_64_MAX: perf_event_x86_regs = 24;
3982pub const PERF_REG_X86_XMM0: perf_event_x86_regs = 32;
3983pub const PERF_REG_X86_XMM1: perf_event_x86_regs = 34;
3984pub const PERF_REG_X86_XMM2: perf_event_x86_regs = 36;
3985pub const PERF_REG_X86_XMM3: perf_event_x86_regs = 38;
3986pub const PERF_REG_X86_XMM4: perf_event_x86_regs = 40;
3987pub const PERF_REG_X86_XMM5: perf_event_x86_regs = 42;
3988pub const PERF_REG_X86_XMM6: perf_event_x86_regs = 44;
3989pub const PERF_REG_X86_XMM7: perf_event_x86_regs = 46;
3990pub const PERF_REG_X86_XMM8: perf_event_x86_regs = 48;
3991pub const PERF_REG_X86_XMM9: perf_event_x86_regs = 50;
3992pub const PERF_REG_X86_XMM10: perf_event_x86_regs = 52;
3993pub const PERF_REG_X86_XMM11: perf_event_x86_regs = 54;
3994pub const PERF_REG_X86_XMM12: perf_event_x86_regs = 56;
3995pub const PERF_REG_X86_XMM13: perf_event_x86_regs = 58;
3996pub const PERF_REG_X86_XMM14: perf_event_x86_regs = 60;
3997pub const PERF_REG_X86_XMM15: perf_event_x86_regs = 62;
3998pub const PERF_REG_X86_XMM_MAX: perf_event_x86_regs = 64;
3999pub type perf_event_x86_regs = ::std::os::raw::c_uint;
4000pub const ENABLE: perf_event_ioctls = 9216;
4001pub const DISABLE: perf_event_ioctls = 9217;
4002pub const REFRESH: perf_event_ioctls = 9218;
4003pub const RESET: perf_event_ioctls = 9219;
4004pub const PERIOD: perf_event_ioctls = 1074275332;
4005pub const SET_OUTPUT: perf_event_ioctls = 9221;
4006pub const SET_FILTER: perf_event_ioctls = 1074275334;
4007pub const ID: perf_event_ioctls = 2148017159;
4008pub const SET_BPF: perf_event_ioctls = 1074013192;
4009pub const PAUSE_OUTPUT: perf_event_ioctls = 1074013193;
4010pub const QUERY_BPF: perf_event_ioctls = 3221758986;
4011pub const MODIFY_ATTRIBUTES: perf_event_ioctls = 1074275339;
4012pub type perf_event_ioctls = ::std::os::raw::c_uint;