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