1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83#[repr(C)]
84#[derive(Default)]
85pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
86impl<T> __IncompleteArrayField<T> {
87 #[inline]
88 pub const fn new() -> Self {
89 __IncompleteArrayField(::std::marker::PhantomData, [])
90 }
91 #[inline]
92 pub fn as_ptr(&self) -> *const T {
93 self as *const _ as *const T
94 }
95 #[inline]
96 pub fn as_mut_ptr(&mut self) -> *mut T {
97 self as *mut _ as *mut T
98 }
99 #[inline]
100 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
101 ::std::slice::from_raw_parts(self.as_ptr(), len)
102 }
103 #[inline]
104 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
105 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
106 }
107}
108impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
109 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
110 fmt.write_str("__IncompleteArrayField")
111 }
112}
113pub const BPF_LD: u32 = 0;
114pub const BPF_LDX: u32 = 1;
115pub const BPF_ST: u32 = 2;
116pub const BPF_STX: u32 = 3;
117pub const BPF_ALU: u32 = 4;
118pub const BPF_JMP: u32 = 5;
119pub const BPF_RET: u32 = 6;
120pub const BPF_MISC: u32 = 7;
121pub const BPF_W: u32 = 0;
122pub const BPF_H: u32 = 8;
123pub const BPF_B: u32 = 16;
124pub const BPF_IMM: u32 = 0;
125pub const BPF_ABS: u32 = 32;
126pub const BPF_IND: u32 = 64;
127pub const BPF_MEM: u32 = 96;
128pub const BPF_LEN: u32 = 128;
129pub const BPF_MSH: u32 = 160;
130pub const BPF_ADD: u32 = 0;
131pub const BPF_SUB: u32 = 16;
132pub const BPF_MUL: u32 = 32;
133pub const BPF_DIV: u32 = 48;
134pub const BPF_OR: u32 = 64;
135pub const BPF_AND: u32 = 80;
136pub const BPF_LSH: u32 = 96;
137pub const BPF_RSH: u32 = 112;
138pub const BPF_NEG: u32 = 128;
139pub const BPF_MOD: u32 = 144;
140pub const BPF_XOR: u32 = 160;
141pub const BPF_JA: u32 = 0;
142pub const BPF_JEQ: u32 = 16;
143pub const BPF_JGT: u32 = 32;
144pub const BPF_JGE: u32 = 48;
145pub const BPF_JSET: u32 = 64;
146pub const BPF_K: u32 = 0;
147pub const BPF_X: u32 = 8;
148pub const BPF_MAXINSNS: u32 = 4096;
149pub const BPF_ALU64: u32 = 7;
150pub const BPF_DW: u32 = 24;
151pub const BPF_XADD: u32 = 192;
152pub const BPF_MOV: u32 = 176;
153pub const BPF_ARSH: u32 = 192;
154pub const BPF_END: u32 = 208;
155pub const BPF_TO_LE: u32 = 0;
156pub const BPF_TO_BE: u32 = 8;
157pub const BPF_FROM_LE: u32 = 0;
158pub const BPF_FROM_BE: u32 = 8;
159pub const BPF_JNE: u32 = 80;
160pub const BPF_JLT: u32 = 160;
161pub const BPF_JLE: u32 = 176;
162pub const BPF_JSGT: u32 = 96;
163pub const BPF_JSGE: u32 = 112;
164pub const BPF_JSLT: u32 = 192;
165pub const BPF_JSLE: u32 = 208;
166pub const BPF_CALL: u32 = 128;
167pub const BPF_EXIT: u32 = 144;
168pub const BPF_F_ALLOW_OVERRIDE: u32 = 1;
169pub const BPF_F_ALLOW_MULTI: u32 = 2;
170pub const BPF_F_STRICT_ALIGNMENT: u32 = 1;
171pub const BPF_F_ANY_ALIGNMENT: u32 = 2;
172pub const BPF_PSEUDO_MAP_FD: u32 = 1;
173pub const BPF_PSEUDO_CALL: u32 = 1;
174pub const BPF_ANY: u32 = 0;
175pub const BPF_NOEXIST: u32 = 1;
176pub const BPF_EXIST: u32 = 2;
177pub const BPF_F_NO_PREALLOC: u32 = 1;
178pub const BPF_F_NO_COMMON_LRU: u32 = 2;
179pub const BPF_F_NUMA_NODE: u32 = 4;
180pub const BPF_F_QUERY_EFFECTIVE: u32 = 1;
181pub const BPF_OBJ_NAME_LEN: u32 = 16;
182pub const BPF_F_RDONLY: u32 = 8;
183pub const BPF_F_WRONLY: u32 = 16;
184pub const BPF_F_STACK_BUILD_ID: u32 = 32;
185pub const BPF_BUILD_ID_SIZE: u32 = 20;
186pub const BPF_F_RECOMPUTE_CSUM: u32 = 1;
187pub const BPF_F_INVALIDATE_HASH: u32 = 2;
188pub const BPF_F_HDR_FIELD_MASK: u32 = 15;
189pub const BPF_F_PSEUDO_HDR: u32 = 16;
190pub const BPF_F_MARK_MANGLED_0: u32 = 32;
191pub const BPF_F_MARK_ENFORCE: u32 = 64;
192pub const BPF_F_INGRESS: u32 = 1;
193pub const BPF_F_TUNINFO_IPV6: u32 = 1;
194pub const BPF_F_SKIP_FIELD_MASK: u32 = 255;
195pub const BPF_F_USER_STACK: u32 = 256;
196pub const BPF_F_FAST_STACK_CMP: u32 = 512;
197pub const BPF_F_REUSE_STACKID: u32 = 1024;
198pub const BPF_F_USER_BUILD_ID: u32 = 2048;
199pub const BPF_F_ZERO_CSUM_TX: u32 = 2;
200pub const BPF_F_DONT_FRAGMENT: u32 = 4;
201pub const BPF_F_SEQ_NUMBER: u32 = 8;
202pub const BPF_F_INDEX_MASK: u32 = 4294967295;
203pub const BPF_F_CURRENT_CPU: u32 = 4294967295;
204pub const BPF_F_CTXLEN_MASK: u64 = 4503595332403200;
205pub const XDP_PACKET_HEADROOM: u32 = 256;
206pub const BPF_TAG_SIZE: u32 = 8;
207pub const BPF_SOCK_OPS_RTO_CB_FLAG: u32 = 1;
208pub const BPF_SOCK_OPS_RETRANS_CB_FLAG: u32 = 2;
209pub const BPF_SOCK_OPS_STATE_CB_FLAG: u32 = 4;
210pub const BPF_SOCK_OPS_ALL_CB_FLAGS: u32 = 7;
211pub const TCP_BPF_IW: u32 = 1001;
212pub const TCP_BPF_SNDCWND_CLAMP: u32 = 1002;
213pub const BPF_DEVCG_ACC_MKNOD: u32 = 1;
214pub const BPF_DEVCG_ACC_READ: u32 = 2;
215pub const BPF_DEVCG_ACC_WRITE: u32 = 4;
216pub const BPF_DEVCG_DEV_BLOCK: u32 = 1;
217pub const BPF_DEVCG_DEV_CHAR: u32 = 2;
218pub const BPF_FIB_LOOKUP_DIRECT: u32 = 1;
219pub const BPF_FIB_LOOKUP_OUTPUT: u32 = 2;
220pub const LOG_BUF_SIZE: u32 = 65536;
221pub const BPF_FN_PREFIX: &'static [u8; 9usize] = b".bpf.fn.\0";
222pub const STT_GNU_IFUNC: u32 = 10;
223pub type __uint8_t = ::std::os::raw::c_uchar;
224pub type __int16_t = ::std::os::raw::c_short;
225pub type __uint32_t = ::std::os::raw::c_uint;
226pub type __uint64_t = ::std::os::raw::c_ulong;
227pub type __pid_t = ::std::os::raw::c_int;
228pub type pid_t = __pid_t;
229extern "C" {
230 pub fn bpf_module_create_b(
231 filename: *const ::std::os::raw::c_char,
232 proto_filename: *const ::std::os::raw::c_char,
233 flags: ::std::os::raw::c_uint,
234 dev_name: *const ::std::os::raw::c_char,
235 ) -> *mut ::std::os::raw::c_void;
236}
237extern "C" {
238 pub fn bpf_module_create_c(
239 filename: *const ::std::os::raw::c_char,
240 flags: ::std::os::raw::c_uint,
241 cflags: *mut *const ::std::os::raw::c_char,
242 ncflags: ::std::os::raw::c_int,
243 allow_rlimit: bool,
244 dev_name: *const ::std::os::raw::c_char,
245 ) -> *mut ::std::os::raw::c_void;
246}
247extern "C" {
248 pub fn bpf_module_create_c_from_string(
249 text: *const ::std::os::raw::c_char,
250 flags: ::std::os::raw::c_uint,
251 cflags: *mut *const ::std::os::raw::c_char,
252 ncflags: ::std::os::raw::c_int,
253 allow_rlimit: bool,
254 dev_name: *const ::std::os::raw::c_char,
255 ) -> *mut ::std::os::raw::c_void;
256}
257extern "C" {
258 pub fn bpf_module_destroy(program: *mut ::std::os::raw::c_void);
259}
260extern "C" {
261 pub fn bpf_module_license(program: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_char;
262}
263extern "C" {
264 pub fn bpf_module_kern_version(program: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_uint;
265}
266extern "C" {
267 pub fn bpf_num_functions(program: *mut ::std::os::raw::c_void) -> usize;
268}
269extern "C" {
270 pub fn bpf_function_name(
271 program: *mut ::std::os::raw::c_void,
272 id: usize,
273 ) -> *const ::std::os::raw::c_char;
274}
275extern "C" {
276 pub fn bpf_function_start_id(
277 program: *mut ::std::os::raw::c_void,
278 id: usize,
279 ) -> *mut ::std::os::raw::c_void;
280}
281extern "C" {
282 pub fn bpf_function_start(
283 program: *mut ::std::os::raw::c_void,
284 name: *const ::std::os::raw::c_char,
285 ) -> *mut ::std::os::raw::c_void;
286}
287extern "C" {
288 pub fn bpf_function_size_id(program: *mut ::std::os::raw::c_void, id: usize) -> usize;
289}
290extern "C" {
291 pub fn bpf_function_size(
292 program: *mut ::std::os::raw::c_void,
293 name: *const ::std::os::raw::c_char,
294 ) -> usize;
295}
296extern "C" {
297 pub fn bpf_num_tables(program: *mut ::std::os::raw::c_void) -> usize;
298}
299extern "C" {
300 pub fn bpf_table_id(
301 program: *mut ::std::os::raw::c_void,
302 table_name: *const ::std::os::raw::c_char,
303 ) -> usize;
304}
305extern "C" {
306 pub fn bpf_table_fd(
307 program: *mut ::std::os::raw::c_void,
308 table_name: *const ::std::os::raw::c_char,
309 ) -> ::std::os::raw::c_int;
310}
311extern "C" {
312 pub fn bpf_table_fd_id(
313 program: *mut ::std::os::raw::c_void,
314 id: usize,
315 ) -> ::std::os::raw::c_int;
316}
317extern "C" {
318 pub fn bpf_table_type(
319 program: *mut ::std::os::raw::c_void,
320 table_name: *const ::std::os::raw::c_char,
321 ) -> ::std::os::raw::c_int;
322}
323extern "C" {
324 pub fn bpf_table_type_id(
325 program: *mut ::std::os::raw::c_void,
326 id: usize,
327 ) -> ::std::os::raw::c_int;
328}
329extern "C" {
330 pub fn bpf_table_max_entries(
331 program: *mut ::std::os::raw::c_void,
332 table_name: *const ::std::os::raw::c_char,
333 ) -> usize;
334}
335extern "C" {
336 pub fn bpf_table_max_entries_id(program: *mut ::std::os::raw::c_void, id: usize) -> usize;
337}
338extern "C" {
339 pub fn bpf_table_flags(
340 program: *mut ::std::os::raw::c_void,
341 table_name: *const ::std::os::raw::c_char,
342 ) -> ::std::os::raw::c_int;
343}
344extern "C" {
345 pub fn bpf_table_flags_id(
346 program: *mut ::std::os::raw::c_void,
347 id: usize,
348 ) -> ::std::os::raw::c_int;
349}
350extern "C" {
351 pub fn bpf_table_name(
352 program: *mut ::std::os::raw::c_void,
353 id: usize,
354 ) -> *const ::std::os::raw::c_char;
355}
356extern "C" {
357 pub fn bpf_table_key_desc(
358 program: *mut ::std::os::raw::c_void,
359 table_name: *const ::std::os::raw::c_char,
360 ) -> *const ::std::os::raw::c_char;
361}
362extern "C" {
363 pub fn bpf_table_key_desc_id(
364 program: *mut ::std::os::raw::c_void,
365 id: usize,
366 ) -> *const ::std::os::raw::c_char;
367}
368extern "C" {
369 pub fn bpf_table_leaf_desc(
370 program: *mut ::std::os::raw::c_void,
371 table_name: *const ::std::os::raw::c_char,
372 ) -> *const ::std::os::raw::c_char;
373}
374extern "C" {
375 pub fn bpf_table_leaf_desc_id(
376 program: *mut ::std::os::raw::c_void,
377 id: usize,
378 ) -> *const ::std::os::raw::c_char;
379}
380extern "C" {
381 pub fn bpf_table_key_size(
382 program: *mut ::std::os::raw::c_void,
383 table_name: *const ::std::os::raw::c_char,
384 ) -> usize;
385}
386extern "C" {
387 pub fn bpf_table_key_size_id(program: *mut ::std::os::raw::c_void, id: usize) -> usize;
388}
389extern "C" {
390 pub fn bpf_table_leaf_size(
391 program: *mut ::std::os::raw::c_void,
392 table_name: *const ::std::os::raw::c_char,
393 ) -> usize;
394}
395extern "C" {
396 pub fn bpf_table_leaf_size_id(program: *mut ::std::os::raw::c_void, id: usize) -> usize;
397}
398extern "C" {
399 pub fn bpf_table_key_snprintf(
400 program: *mut ::std::os::raw::c_void,
401 id: usize,
402 buf: *mut ::std::os::raw::c_char,
403 buflen: usize,
404 key: *const ::std::os::raw::c_void,
405 ) -> ::std::os::raw::c_int;
406}
407extern "C" {
408 pub fn bpf_table_leaf_snprintf(
409 program: *mut ::std::os::raw::c_void,
410 id: usize,
411 buf: *mut ::std::os::raw::c_char,
412 buflen: usize,
413 leaf: *const ::std::os::raw::c_void,
414 ) -> ::std::os::raw::c_int;
415}
416extern "C" {
417 pub fn bpf_table_key_sscanf(
418 program: *mut ::std::os::raw::c_void,
419 id: usize,
420 buf: *const ::std::os::raw::c_char,
421 key: *mut ::std::os::raw::c_void,
422 ) -> ::std::os::raw::c_int;
423}
424extern "C" {
425 pub fn bpf_table_leaf_sscanf(
426 program: *mut ::std::os::raw::c_void,
427 id: usize,
428 buf: *const ::std::os::raw::c_char,
429 leaf: *mut ::std::os::raw::c_void,
430 ) -> ::std::os::raw::c_int;
431}
432extern "C" {
433 pub fn bpf_perf_event_fields(
434 program: *mut ::std::os::raw::c_void,
435 event: *const ::std::os::raw::c_char,
436 ) -> usize;
437}
438extern "C" {
439 pub fn bpf_perf_event_field(
440 program: *mut ::std::os::raw::c_void,
441 event: *const ::std::os::raw::c_char,
442 i: usize,
443 ) -> *const ::std::os::raw::c_char;
444}
445extern "C" {
446 pub fn bcc_func_load(
447 program: *mut ::std::os::raw::c_void,
448 prog_type: ::std::os::raw::c_int,
449 name: *const ::std::os::raw::c_char,
450 insns: *const bpf_insn,
451 prog_len: ::std::os::raw::c_int,
452 license: *const ::std::os::raw::c_char,
453 kern_version: ::std::os::raw::c_uint,
454 log_level: ::std::os::raw::c_int,
455 log_buf: *mut ::std::os::raw::c_char,
456 log_buf_size: ::std::os::raw::c_uint,
457 dev_name: *const ::std::os::raw::c_char,
458 ) -> ::std::os::raw::c_int;
459}
460pub type __u8 = ::std::os::raw::c_uchar;
461pub type __s16 = ::std::os::raw::c_short;
462pub type __u16 = ::std::os::raw::c_ushort;
463pub type __s32 = ::std::os::raw::c_int;
464pub type __u32 = ::std::os::raw::c_uint;
465pub type __u64 = ::std::os::raw::c_ulonglong;
466pub type __be16 = __u16;
467pub type __be32 = __u32;
468pub const BPF_REG_0: ::std::os::raw::c_uint = 0;
469pub const BPF_REG_1: ::std::os::raw::c_uint = 1;
470pub const BPF_REG_2: ::std::os::raw::c_uint = 2;
471pub const BPF_REG_3: ::std::os::raw::c_uint = 3;
472pub const BPF_REG_4: ::std::os::raw::c_uint = 4;
473pub const BPF_REG_5: ::std::os::raw::c_uint = 5;
474pub const BPF_REG_6: ::std::os::raw::c_uint = 6;
475pub const BPF_REG_7: ::std::os::raw::c_uint = 7;
476pub const BPF_REG_8: ::std::os::raw::c_uint = 8;
477pub const BPF_REG_9: ::std::os::raw::c_uint = 9;
478pub const BPF_REG_10: ::std::os::raw::c_uint = 10;
479pub const __MAX_BPF_REG: ::std::os::raw::c_uint = 11;
480pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
481#[repr(C)]
482#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
483pub struct bpf_insn {
484 pub code: __u8,
485 pub _bitfield_align_1: [u8; 0],
486 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
487 pub off: __s16,
488 pub imm: __s32,
489}
490#[test]
491fn bindgen_test_layout_bpf_insn() {
492 assert_eq!(
493 ::std::mem::size_of::<bpf_insn>(),
494 8usize,
495 concat!("Size of: ", stringify!(bpf_insn))
496 );
497 assert_eq!(
498 ::std::mem::align_of::<bpf_insn>(),
499 4usize,
500 concat!("Alignment of ", stringify!(bpf_insn))
501 );
502 assert_eq!(
503 unsafe { &(*(::std::ptr::null::<bpf_insn>())).code as *const _ as usize },
504 0usize,
505 concat!(
506 "Offset of field: ",
507 stringify!(bpf_insn),
508 "::",
509 stringify!(code)
510 )
511 );
512 assert_eq!(
513 unsafe { &(*(::std::ptr::null::<bpf_insn>())).off as *const _ as usize },
514 2usize,
515 concat!(
516 "Offset of field: ",
517 stringify!(bpf_insn),
518 "::",
519 stringify!(off)
520 )
521 );
522 assert_eq!(
523 unsafe { &(*(::std::ptr::null::<bpf_insn>())).imm as *const _ as usize },
524 4usize,
525 concat!(
526 "Offset of field: ",
527 stringify!(bpf_insn),
528 "::",
529 stringify!(imm)
530 )
531 );
532}
533impl bpf_insn {
534 #[inline]
535 pub fn dst_reg(&self) -> __u8 {
536 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
537 }
538 #[inline]
539 pub fn set_dst_reg(&mut self, val: __u8) {
540 unsafe {
541 let val: u8 = ::std::mem::transmute(val);
542 self._bitfield_1.set(0usize, 4u8, val as u64)
543 }
544 }
545 #[inline]
546 pub fn src_reg(&self) -> __u8 {
547 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
548 }
549 #[inline]
550 pub fn set_src_reg(&mut self, val: __u8) {
551 unsafe {
552 let val: u8 = ::std::mem::transmute(val);
553 self._bitfield_1.set(4usize, 4u8, val as u64)
554 }
555 }
556 #[inline]
557 pub fn new_bitfield_1(dst_reg: __u8, src_reg: __u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
558 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
559 __bindgen_bitfield_unit.set(0usize, 4u8, {
560 let dst_reg: u8 = unsafe { ::std::mem::transmute(dst_reg) };
561 dst_reg as u64
562 });
563 __bindgen_bitfield_unit.set(4usize, 4u8, {
564 let src_reg: u8 = unsafe { ::std::mem::transmute(src_reg) };
565 src_reg as u64
566 });
567 __bindgen_bitfield_unit
568 }
569}
570#[repr(C)]
571#[derive(Debug, Default)]
572pub struct bpf_lpm_trie_key {
573 pub prefixlen: __u32,
574 pub data: __IncompleteArrayField<__u8>,
575}
576#[test]
577fn bindgen_test_layout_bpf_lpm_trie_key() {
578 assert_eq!(
579 ::std::mem::size_of::<bpf_lpm_trie_key>(),
580 4usize,
581 concat!("Size of: ", stringify!(bpf_lpm_trie_key))
582 );
583 assert_eq!(
584 ::std::mem::align_of::<bpf_lpm_trie_key>(),
585 4usize,
586 concat!("Alignment of ", stringify!(bpf_lpm_trie_key))
587 );
588 assert_eq!(
589 unsafe { &(*(::std::ptr::null::<bpf_lpm_trie_key>())).prefixlen as *const _ as usize },
590 0usize,
591 concat!(
592 "Offset of field: ",
593 stringify!(bpf_lpm_trie_key),
594 "::",
595 stringify!(prefixlen)
596 )
597 );
598 assert_eq!(
599 unsafe { &(*(::std::ptr::null::<bpf_lpm_trie_key>())).data as *const _ as usize },
600 4usize,
601 concat!(
602 "Offset of field: ",
603 stringify!(bpf_lpm_trie_key),
604 "::",
605 stringify!(data)
606 )
607 );
608}
609#[repr(C)]
610#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
611pub struct bpf_cgroup_storage_key {
612 pub cgroup_inode_id: __u64,
613 pub attach_type: __u32,
614}
615#[test]
616fn bindgen_test_layout_bpf_cgroup_storage_key() {
617 assert_eq!(
618 ::std::mem::size_of::<bpf_cgroup_storage_key>(),
619 16usize,
620 concat!("Size of: ", stringify!(bpf_cgroup_storage_key))
621 );
622 assert_eq!(
623 ::std::mem::align_of::<bpf_cgroup_storage_key>(),
624 8usize,
625 concat!("Alignment of ", stringify!(bpf_cgroup_storage_key))
626 );
627 assert_eq!(
628 unsafe {
629 &(*(::std::ptr::null::<bpf_cgroup_storage_key>())).cgroup_inode_id as *const _ as usize
630 },
631 0usize,
632 concat!(
633 "Offset of field: ",
634 stringify!(bpf_cgroup_storage_key),
635 "::",
636 stringify!(cgroup_inode_id)
637 )
638 );
639 assert_eq!(
640 unsafe {
641 &(*(::std::ptr::null::<bpf_cgroup_storage_key>())).attach_type as *const _ as usize
642 },
643 8usize,
644 concat!(
645 "Offset of field: ",
646 stringify!(bpf_cgroup_storage_key),
647 "::",
648 stringify!(attach_type)
649 )
650 );
651}
652pub const bpf_cmd_BPF_MAP_CREATE: bpf_cmd = 0;
653pub const bpf_cmd_BPF_MAP_LOOKUP_ELEM: bpf_cmd = 1;
654pub const bpf_cmd_BPF_MAP_UPDATE_ELEM: bpf_cmd = 2;
655pub const bpf_cmd_BPF_MAP_DELETE_ELEM: bpf_cmd = 3;
656pub const bpf_cmd_BPF_MAP_GET_NEXT_KEY: bpf_cmd = 4;
657pub const bpf_cmd_BPF_PROG_LOAD: bpf_cmd = 5;
658pub const bpf_cmd_BPF_OBJ_PIN: bpf_cmd = 6;
659pub const bpf_cmd_BPF_OBJ_GET: bpf_cmd = 7;
660pub const bpf_cmd_BPF_PROG_ATTACH: bpf_cmd = 8;
661pub const bpf_cmd_BPF_PROG_DETACH: bpf_cmd = 9;
662pub const bpf_cmd_BPF_PROG_TEST_RUN: bpf_cmd = 10;
663pub const bpf_cmd_BPF_PROG_GET_NEXT_ID: bpf_cmd = 11;
664pub const bpf_cmd_BPF_MAP_GET_NEXT_ID: bpf_cmd = 12;
665pub const bpf_cmd_BPF_PROG_GET_FD_BY_ID: bpf_cmd = 13;
666pub const bpf_cmd_BPF_MAP_GET_FD_BY_ID: bpf_cmd = 14;
667pub const bpf_cmd_BPF_OBJ_GET_INFO_BY_FD: bpf_cmd = 15;
668pub const bpf_cmd_BPF_PROG_QUERY: bpf_cmd = 16;
669pub const bpf_cmd_BPF_RAW_TRACEPOINT_OPEN: bpf_cmd = 17;
670pub const bpf_cmd_BPF_BTF_LOAD: bpf_cmd = 18;
671pub const bpf_cmd_BPF_BTF_GET_FD_BY_ID: bpf_cmd = 19;
672pub const bpf_cmd_BPF_TASK_FD_QUERY: bpf_cmd = 20;
673pub type bpf_cmd = ::std::os::raw::c_uint;
674pub const bpf_map_type_BPF_MAP_TYPE_UNSPEC: bpf_map_type = 0;
675pub const bpf_map_type_BPF_MAP_TYPE_HASH: bpf_map_type = 1;
676pub const bpf_map_type_BPF_MAP_TYPE_ARRAY: bpf_map_type = 2;
677pub const bpf_map_type_BPF_MAP_TYPE_PROG_ARRAY: bpf_map_type = 3;
678pub const bpf_map_type_BPF_MAP_TYPE_PERF_EVENT_ARRAY: bpf_map_type = 4;
679pub const bpf_map_type_BPF_MAP_TYPE_PERCPU_HASH: bpf_map_type = 5;
680pub const bpf_map_type_BPF_MAP_TYPE_PERCPU_ARRAY: bpf_map_type = 6;
681pub const bpf_map_type_BPF_MAP_TYPE_STACK_TRACE: bpf_map_type = 7;
682pub const bpf_map_type_BPF_MAP_TYPE_CGROUP_ARRAY: bpf_map_type = 8;
683pub const bpf_map_type_BPF_MAP_TYPE_LRU_HASH: bpf_map_type = 9;
684pub const bpf_map_type_BPF_MAP_TYPE_LRU_PERCPU_HASH: bpf_map_type = 10;
685pub const bpf_map_type_BPF_MAP_TYPE_LPM_TRIE: bpf_map_type = 11;
686pub const bpf_map_type_BPF_MAP_TYPE_ARRAY_OF_MAPS: bpf_map_type = 12;
687pub const bpf_map_type_BPF_MAP_TYPE_HASH_OF_MAPS: bpf_map_type = 13;
688pub const bpf_map_type_BPF_MAP_TYPE_DEVMAP: bpf_map_type = 14;
689pub const bpf_map_type_BPF_MAP_TYPE_SOCKMAP: bpf_map_type = 15;
690pub const bpf_map_type_BPF_MAP_TYPE_CPUMAP: bpf_map_type = 16;
691pub const bpf_map_type_BPF_MAP_TYPE_XSKMAP: bpf_map_type = 17;
692pub const bpf_map_type_BPF_MAP_TYPE_SOCKHASH: bpf_map_type = 18;
693pub const bpf_map_type_BPF_MAP_TYPE_CGROUP_STORAGE: bpf_map_type = 19;
694pub const bpf_map_type_BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: bpf_map_type = 20;
695pub type bpf_map_type = ::std::os::raw::c_uint;
696pub const bpf_prog_type_BPF_PROG_TYPE_UNSPEC: bpf_prog_type = 0;
697pub const bpf_prog_type_BPF_PROG_TYPE_SOCKET_FILTER: bpf_prog_type = 1;
698pub const bpf_prog_type_BPF_PROG_TYPE_KPROBE: bpf_prog_type = 2;
699pub const bpf_prog_type_BPF_PROG_TYPE_SCHED_CLS: bpf_prog_type = 3;
700pub const bpf_prog_type_BPF_PROG_TYPE_SCHED_ACT: bpf_prog_type = 4;
701pub const bpf_prog_type_BPF_PROG_TYPE_TRACEPOINT: bpf_prog_type = 5;
702pub const bpf_prog_type_BPF_PROG_TYPE_XDP: bpf_prog_type = 6;
703pub const bpf_prog_type_BPF_PROG_TYPE_PERF_EVENT: bpf_prog_type = 7;
704pub const bpf_prog_type_BPF_PROG_TYPE_CGROUP_SKB: bpf_prog_type = 8;
705pub const bpf_prog_type_BPF_PROG_TYPE_CGROUP_SOCK: bpf_prog_type = 9;
706pub const bpf_prog_type_BPF_PROG_TYPE_LWT_IN: bpf_prog_type = 10;
707pub const bpf_prog_type_BPF_PROG_TYPE_LWT_OUT: bpf_prog_type = 11;
708pub const bpf_prog_type_BPF_PROG_TYPE_LWT_XMIT: bpf_prog_type = 12;
709pub const bpf_prog_type_BPF_PROG_TYPE_SOCK_OPS: bpf_prog_type = 13;
710pub const bpf_prog_type_BPF_PROG_TYPE_SK_SKB: bpf_prog_type = 14;
711pub const bpf_prog_type_BPF_PROG_TYPE_CGROUP_DEVICE: bpf_prog_type = 15;
712pub const bpf_prog_type_BPF_PROG_TYPE_SK_MSG: bpf_prog_type = 16;
713pub const bpf_prog_type_BPF_PROG_TYPE_RAW_TRACEPOINT: bpf_prog_type = 17;
714pub const bpf_prog_type_BPF_PROG_TYPE_CGROUP_SOCK_ADDR: bpf_prog_type = 18;
715pub const bpf_prog_type_BPF_PROG_TYPE_LWT_SEG6LOCAL: bpf_prog_type = 19;
716pub const bpf_prog_type_BPF_PROG_TYPE_LIRC_MODE2: bpf_prog_type = 20;
717pub const bpf_prog_type_BPF_PROG_TYPE_SK_REUSEPORT: bpf_prog_type = 21;
718pub type bpf_prog_type = ::std::os::raw::c_uint;
719pub const bpf_attach_type_BPF_CGROUP_INET_INGRESS: bpf_attach_type = 0;
720pub const bpf_attach_type_BPF_CGROUP_INET_EGRESS: bpf_attach_type = 1;
721pub const bpf_attach_type_BPF_CGROUP_INET_SOCK_CREATE: bpf_attach_type = 2;
722pub const bpf_attach_type_BPF_CGROUP_SOCK_OPS: bpf_attach_type = 3;
723pub const bpf_attach_type_BPF_SK_SKB_STREAM_PARSER: bpf_attach_type = 4;
724pub const bpf_attach_type_BPF_SK_SKB_STREAM_VERDICT: bpf_attach_type = 5;
725pub const bpf_attach_type_BPF_CGROUP_DEVICE: bpf_attach_type = 6;
726pub const bpf_attach_type_BPF_SK_MSG_VERDICT: bpf_attach_type = 7;
727pub const bpf_attach_type_BPF_CGROUP_INET4_BIND: bpf_attach_type = 8;
728pub const bpf_attach_type_BPF_CGROUP_INET6_BIND: bpf_attach_type = 9;
729pub const bpf_attach_type_BPF_CGROUP_INET4_CONNECT: bpf_attach_type = 10;
730pub const bpf_attach_type_BPF_CGROUP_INET6_CONNECT: bpf_attach_type = 11;
731pub const bpf_attach_type_BPF_CGROUP_INET4_POST_BIND: bpf_attach_type = 12;
732pub const bpf_attach_type_BPF_CGROUP_INET6_POST_BIND: bpf_attach_type = 13;
733pub const bpf_attach_type_BPF_CGROUP_UDP4_SENDMSG: bpf_attach_type = 14;
734pub const bpf_attach_type_BPF_CGROUP_UDP6_SENDMSG: bpf_attach_type = 15;
735pub const bpf_attach_type_BPF_LIRC_MODE2: bpf_attach_type = 16;
736pub const bpf_attach_type_BPF_CGROUP_UDP4_RECVMSG: bpf_attach_type = 19;
737pub const bpf_attach_type_BPF_CGROUP_UDP6_RECVMSG: bpf_attach_type = 20;
738pub const bpf_attach_type___MAX_BPF_ATTACH_TYPE: bpf_attach_type = 21;
739pub type bpf_attach_type = ::std::os::raw::c_uint;
740pub const bpf_stack_build_id_status_BPF_STACK_BUILD_ID_EMPTY: bpf_stack_build_id_status = 0;
741pub const bpf_stack_build_id_status_BPF_STACK_BUILD_ID_VALID: bpf_stack_build_id_status = 1;
742pub const bpf_stack_build_id_status_BPF_STACK_BUILD_ID_IP: bpf_stack_build_id_status = 2;
743pub type bpf_stack_build_id_status = ::std::os::raw::c_uint;
744#[repr(C)]
745#[derive(Copy, Clone)]
746pub struct bpf_stack_build_id {
747 pub status: __s32,
748 pub build_id: [::std::os::raw::c_uchar; 20usize],
749 pub __bindgen_anon_1: bpf_stack_build_id__bindgen_ty_1,
750}
751#[repr(C)]
752#[derive(Copy, Clone)]
753pub union bpf_stack_build_id__bindgen_ty_1 {
754 pub offset: __u64,
755 pub ip: __u64,
756}
757#[test]
758fn bindgen_test_layout_bpf_stack_build_id__bindgen_ty_1() {
759 assert_eq!(
760 ::std::mem::size_of::<bpf_stack_build_id__bindgen_ty_1>(),
761 8usize,
762 concat!("Size of: ", stringify!(bpf_stack_build_id__bindgen_ty_1))
763 );
764 assert_eq!(
765 ::std::mem::align_of::<bpf_stack_build_id__bindgen_ty_1>(),
766 8usize,
767 concat!(
768 "Alignment of ",
769 stringify!(bpf_stack_build_id__bindgen_ty_1)
770 )
771 );
772 assert_eq!(
773 unsafe {
774 &(*(::std::ptr::null::<bpf_stack_build_id__bindgen_ty_1>())).offset as *const _ as usize
775 },
776 0usize,
777 concat!(
778 "Offset of field: ",
779 stringify!(bpf_stack_build_id__bindgen_ty_1),
780 "::",
781 stringify!(offset)
782 )
783 );
784 assert_eq!(
785 unsafe {
786 &(*(::std::ptr::null::<bpf_stack_build_id__bindgen_ty_1>())).ip as *const _ as usize
787 },
788 0usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(bpf_stack_build_id__bindgen_ty_1),
792 "::",
793 stringify!(ip)
794 )
795 );
796}
797impl Default for bpf_stack_build_id__bindgen_ty_1 {
798 fn default() -> Self {
799 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
800 unsafe {
801 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
802 s.assume_init()
803 }
804 }
805}
806impl ::std::fmt::Debug for bpf_stack_build_id__bindgen_ty_1 {
807 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
808 write!(f, "bpf_stack_build_id__bindgen_ty_1 {{ union }}")
809 }
810}
811#[test]
812fn bindgen_test_layout_bpf_stack_build_id() {
813 assert_eq!(
814 ::std::mem::size_of::<bpf_stack_build_id>(),
815 32usize,
816 concat!("Size of: ", stringify!(bpf_stack_build_id))
817 );
818 assert_eq!(
819 ::std::mem::align_of::<bpf_stack_build_id>(),
820 8usize,
821 concat!("Alignment of ", stringify!(bpf_stack_build_id))
822 );
823 assert_eq!(
824 unsafe { &(*(::std::ptr::null::<bpf_stack_build_id>())).status as *const _ as usize },
825 0usize,
826 concat!(
827 "Offset of field: ",
828 stringify!(bpf_stack_build_id),
829 "::",
830 stringify!(status)
831 )
832 );
833 assert_eq!(
834 unsafe { &(*(::std::ptr::null::<bpf_stack_build_id>())).build_id as *const _ as usize },
835 4usize,
836 concat!(
837 "Offset of field: ",
838 stringify!(bpf_stack_build_id),
839 "::",
840 stringify!(build_id)
841 )
842 );
843}
844impl Default for bpf_stack_build_id {
845 fn default() -> Self {
846 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
847 unsafe {
848 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
849 s.assume_init()
850 }
851 }
852}
853impl ::std::fmt::Debug for bpf_stack_build_id {
854 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
855 write!(
856 f,
857 "bpf_stack_build_id {{ status: {:?}, build_id: {:?}, __bindgen_anon_1: {:?} }}",
858 self.status, self.build_id, self.__bindgen_anon_1
859 )
860 }
861}
862#[repr(C)]
863#[derive(Copy, Clone)]
864pub union bpf_attr {
865 pub __bindgen_anon_1: bpf_attr__bindgen_ty_1,
866 pub __bindgen_anon_2: bpf_attr__bindgen_ty_2,
867 pub __bindgen_anon_3: bpf_attr__bindgen_ty_3,
868 pub __bindgen_anon_4: bpf_attr__bindgen_ty_4,
869 pub __bindgen_anon_5: bpf_attr__bindgen_ty_5,
870 pub test: bpf_attr__bindgen_ty_6,
871 pub __bindgen_anon_6: bpf_attr__bindgen_ty_7,
872 pub info: bpf_attr__bindgen_ty_8,
873 pub query: bpf_attr__bindgen_ty_9,
874 pub raw_tracepoint: bpf_attr__bindgen_ty_10,
875 pub __bindgen_anon_7: bpf_attr__bindgen_ty_11,
876 pub task_fd_query: bpf_attr__bindgen_ty_12,
877}
878#[repr(C)]
879#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
880pub struct bpf_attr__bindgen_ty_1 {
881 pub map_type: __u32,
882 pub key_size: __u32,
883 pub value_size: __u32,
884 pub max_entries: __u32,
885 pub map_flags: __u32,
886 pub inner_map_fd: __u32,
887 pub numa_node: __u32,
888 pub map_name: [::std::os::raw::c_char; 16usize],
889 pub map_ifindex: __u32,
890 pub btf_fd: __u32,
891 pub btf_key_type_id: __u32,
892 pub btf_value_type_id: __u32,
893}
894#[test]
895fn bindgen_test_layout_bpf_attr__bindgen_ty_1() {
896 assert_eq!(
897 ::std::mem::size_of::<bpf_attr__bindgen_ty_1>(),
898 60usize,
899 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_1))
900 );
901 assert_eq!(
902 ::std::mem::align_of::<bpf_attr__bindgen_ty_1>(),
903 4usize,
904 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_1))
905 );
906 assert_eq!(
907 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).map_type as *const _ as usize },
908 0usize,
909 concat!(
910 "Offset of field: ",
911 stringify!(bpf_attr__bindgen_ty_1),
912 "::",
913 stringify!(map_type)
914 )
915 );
916 assert_eq!(
917 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).key_size as *const _ as usize },
918 4usize,
919 concat!(
920 "Offset of field: ",
921 stringify!(bpf_attr__bindgen_ty_1),
922 "::",
923 stringify!(key_size)
924 )
925 );
926 assert_eq!(
927 unsafe {
928 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).value_size as *const _ as usize
929 },
930 8usize,
931 concat!(
932 "Offset of field: ",
933 stringify!(bpf_attr__bindgen_ty_1),
934 "::",
935 stringify!(value_size)
936 )
937 );
938 assert_eq!(
939 unsafe {
940 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).max_entries as *const _ as usize
941 },
942 12usize,
943 concat!(
944 "Offset of field: ",
945 stringify!(bpf_attr__bindgen_ty_1),
946 "::",
947 stringify!(max_entries)
948 )
949 );
950 assert_eq!(
951 unsafe {
952 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).map_flags as *const _ as usize
953 },
954 16usize,
955 concat!(
956 "Offset of field: ",
957 stringify!(bpf_attr__bindgen_ty_1),
958 "::",
959 stringify!(map_flags)
960 )
961 );
962 assert_eq!(
963 unsafe {
964 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).inner_map_fd as *const _ as usize
965 },
966 20usize,
967 concat!(
968 "Offset of field: ",
969 stringify!(bpf_attr__bindgen_ty_1),
970 "::",
971 stringify!(inner_map_fd)
972 )
973 );
974 assert_eq!(
975 unsafe {
976 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).numa_node as *const _ as usize
977 },
978 24usize,
979 concat!(
980 "Offset of field: ",
981 stringify!(bpf_attr__bindgen_ty_1),
982 "::",
983 stringify!(numa_node)
984 )
985 );
986 assert_eq!(
987 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).map_name as *const _ as usize },
988 28usize,
989 concat!(
990 "Offset of field: ",
991 stringify!(bpf_attr__bindgen_ty_1),
992 "::",
993 stringify!(map_name)
994 )
995 );
996 assert_eq!(
997 unsafe {
998 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).map_ifindex as *const _ as usize
999 },
1000 44usize,
1001 concat!(
1002 "Offset of field: ",
1003 stringify!(bpf_attr__bindgen_ty_1),
1004 "::",
1005 stringify!(map_ifindex)
1006 )
1007 );
1008 assert_eq!(
1009 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).btf_fd as *const _ as usize },
1010 48usize,
1011 concat!(
1012 "Offset of field: ",
1013 stringify!(bpf_attr__bindgen_ty_1),
1014 "::",
1015 stringify!(btf_fd)
1016 )
1017 );
1018 assert_eq!(
1019 unsafe {
1020 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).btf_key_type_id as *const _ as usize
1021 },
1022 52usize,
1023 concat!(
1024 "Offset of field: ",
1025 stringify!(bpf_attr__bindgen_ty_1),
1026 "::",
1027 stringify!(btf_key_type_id)
1028 )
1029 );
1030 assert_eq!(
1031 unsafe {
1032 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_1>())).btf_value_type_id as *const _
1033 as usize
1034 },
1035 56usize,
1036 concat!(
1037 "Offset of field: ",
1038 stringify!(bpf_attr__bindgen_ty_1),
1039 "::",
1040 stringify!(btf_value_type_id)
1041 )
1042 );
1043}
1044#[repr(C)]
1045#[derive(Copy, Clone)]
1046pub struct bpf_attr__bindgen_ty_2 {
1047 pub map_fd: __u32,
1048 pub key: __u64,
1049 pub __bindgen_anon_1: bpf_attr__bindgen_ty_2__bindgen_ty_1,
1050 pub flags: __u64,
1051}
1052#[repr(C)]
1053#[derive(Copy, Clone)]
1054pub union bpf_attr__bindgen_ty_2__bindgen_ty_1 {
1055 pub value: __u64,
1056 pub next_key: __u64,
1057}
1058#[test]
1059fn bindgen_test_layout_bpf_attr__bindgen_ty_2__bindgen_ty_1() {
1060 assert_eq!(
1061 ::std::mem::size_of::<bpf_attr__bindgen_ty_2__bindgen_ty_1>(),
1062 8usize,
1063 concat!(
1064 "Size of: ",
1065 stringify!(bpf_attr__bindgen_ty_2__bindgen_ty_1)
1066 )
1067 );
1068 assert_eq!(
1069 ::std::mem::align_of::<bpf_attr__bindgen_ty_2__bindgen_ty_1>(),
1070 8usize,
1071 concat!(
1072 "Alignment of ",
1073 stringify!(bpf_attr__bindgen_ty_2__bindgen_ty_1)
1074 )
1075 );
1076 assert_eq!(
1077 unsafe {
1078 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_2__bindgen_ty_1>())).value as *const _
1079 as usize
1080 },
1081 0usize,
1082 concat!(
1083 "Offset of field: ",
1084 stringify!(bpf_attr__bindgen_ty_2__bindgen_ty_1),
1085 "::",
1086 stringify!(value)
1087 )
1088 );
1089 assert_eq!(
1090 unsafe {
1091 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_2__bindgen_ty_1>())).next_key as *const _
1092 as usize
1093 },
1094 0usize,
1095 concat!(
1096 "Offset of field: ",
1097 stringify!(bpf_attr__bindgen_ty_2__bindgen_ty_1),
1098 "::",
1099 stringify!(next_key)
1100 )
1101 );
1102}
1103impl Default for bpf_attr__bindgen_ty_2__bindgen_ty_1 {
1104 fn default() -> Self {
1105 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1106 unsafe {
1107 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1108 s.assume_init()
1109 }
1110 }
1111}
1112impl ::std::fmt::Debug for bpf_attr__bindgen_ty_2__bindgen_ty_1 {
1113 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1114 write!(f, "bpf_attr__bindgen_ty_2__bindgen_ty_1 {{ union }}")
1115 }
1116}
1117#[test]
1118fn bindgen_test_layout_bpf_attr__bindgen_ty_2() {
1119 assert_eq!(
1120 ::std::mem::size_of::<bpf_attr__bindgen_ty_2>(),
1121 32usize,
1122 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_2))
1123 );
1124 assert_eq!(
1125 ::std::mem::align_of::<bpf_attr__bindgen_ty_2>(),
1126 8usize,
1127 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_2))
1128 );
1129 assert_eq!(
1130 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_2>())).map_fd as *const _ as usize },
1131 0usize,
1132 concat!(
1133 "Offset of field: ",
1134 stringify!(bpf_attr__bindgen_ty_2),
1135 "::",
1136 stringify!(map_fd)
1137 )
1138 );
1139 assert_eq!(
1140 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_2>())).key as *const _ as usize },
1141 8usize,
1142 concat!(
1143 "Offset of field: ",
1144 stringify!(bpf_attr__bindgen_ty_2),
1145 "::",
1146 stringify!(key)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_2>())).flags as *const _ as usize },
1151 24usize,
1152 concat!(
1153 "Offset of field: ",
1154 stringify!(bpf_attr__bindgen_ty_2),
1155 "::",
1156 stringify!(flags)
1157 )
1158 );
1159}
1160impl Default for bpf_attr__bindgen_ty_2 {
1161 fn default() -> Self {
1162 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1163 unsafe {
1164 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1165 s.assume_init()
1166 }
1167 }
1168}
1169impl ::std::fmt::Debug for bpf_attr__bindgen_ty_2 {
1170 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1171 write ! (f , "bpf_attr__bindgen_ty_2 {{ map_fd: {:?}, key: {:?}, __bindgen_anon_1: {:?}, flags: {:?} }}" , self . map_fd , self . key , self . __bindgen_anon_1 , self . flags)
1172 }
1173}
1174#[repr(C)]
1175#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1176pub struct bpf_attr__bindgen_ty_3 {
1177 pub prog_type: __u32,
1178 pub insn_cnt: __u32,
1179 pub insns: __u64,
1180 pub license: __u64,
1181 pub log_level: __u32,
1182 pub log_size: __u32,
1183 pub log_buf: __u64,
1184 pub kern_version: __u32,
1185 pub prog_flags: __u32,
1186 pub prog_name: [::std::os::raw::c_char; 16usize],
1187 pub prog_ifindex: __u32,
1188 pub expected_attach_type: __u32,
1189}
1190#[test]
1191fn bindgen_test_layout_bpf_attr__bindgen_ty_3() {
1192 assert_eq!(
1193 ::std::mem::size_of::<bpf_attr__bindgen_ty_3>(),
1194 72usize,
1195 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_3))
1196 );
1197 assert_eq!(
1198 ::std::mem::align_of::<bpf_attr__bindgen_ty_3>(),
1199 8usize,
1200 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_3))
1201 );
1202 assert_eq!(
1203 unsafe {
1204 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).prog_type as *const _ as usize
1205 },
1206 0usize,
1207 concat!(
1208 "Offset of field: ",
1209 stringify!(bpf_attr__bindgen_ty_3),
1210 "::",
1211 stringify!(prog_type)
1212 )
1213 );
1214 assert_eq!(
1215 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).insn_cnt as *const _ as usize },
1216 4usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(bpf_attr__bindgen_ty_3),
1220 "::",
1221 stringify!(insn_cnt)
1222 )
1223 );
1224 assert_eq!(
1225 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).insns as *const _ as usize },
1226 8usize,
1227 concat!(
1228 "Offset of field: ",
1229 stringify!(bpf_attr__bindgen_ty_3),
1230 "::",
1231 stringify!(insns)
1232 )
1233 );
1234 assert_eq!(
1235 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).license as *const _ as usize },
1236 16usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(bpf_attr__bindgen_ty_3),
1240 "::",
1241 stringify!(license)
1242 )
1243 );
1244 assert_eq!(
1245 unsafe {
1246 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).log_level as *const _ as usize
1247 },
1248 24usize,
1249 concat!(
1250 "Offset of field: ",
1251 stringify!(bpf_attr__bindgen_ty_3),
1252 "::",
1253 stringify!(log_level)
1254 )
1255 );
1256 assert_eq!(
1257 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).log_size as *const _ as usize },
1258 28usize,
1259 concat!(
1260 "Offset of field: ",
1261 stringify!(bpf_attr__bindgen_ty_3),
1262 "::",
1263 stringify!(log_size)
1264 )
1265 );
1266 assert_eq!(
1267 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).log_buf as *const _ as usize },
1268 32usize,
1269 concat!(
1270 "Offset of field: ",
1271 stringify!(bpf_attr__bindgen_ty_3),
1272 "::",
1273 stringify!(log_buf)
1274 )
1275 );
1276 assert_eq!(
1277 unsafe {
1278 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).kern_version as *const _ as usize
1279 },
1280 40usize,
1281 concat!(
1282 "Offset of field: ",
1283 stringify!(bpf_attr__bindgen_ty_3),
1284 "::",
1285 stringify!(kern_version)
1286 )
1287 );
1288 assert_eq!(
1289 unsafe {
1290 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).prog_flags as *const _ as usize
1291 },
1292 44usize,
1293 concat!(
1294 "Offset of field: ",
1295 stringify!(bpf_attr__bindgen_ty_3),
1296 "::",
1297 stringify!(prog_flags)
1298 )
1299 );
1300 assert_eq!(
1301 unsafe {
1302 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).prog_name as *const _ as usize
1303 },
1304 48usize,
1305 concat!(
1306 "Offset of field: ",
1307 stringify!(bpf_attr__bindgen_ty_3),
1308 "::",
1309 stringify!(prog_name)
1310 )
1311 );
1312 assert_eq!(
1313 unsafe {
1314 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).prog_ifindex as *const _ as usize
1315 },
1316 64usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(bpf_attr__bindgen_ty_3),
1320 "::",
1321 stringify!(prog_ifindex)
1322 )
1323 );
1324 assert_eq!(
1325 unsafe {
1326 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_3>())).expected_attach_type as *const _
1327 as usize
1328 },
1329 68usize,
1330 concat!(
1331 "Offset of field: ",
1332 stringify!(bpf_attr__bindgen_ty_3),
1333 "::",
1334 stringify!(expected_attach_type)
1335 )
1336 );
1337}
1338#[repr(C)]
1339#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1340pub struct bpf_attr__bindgen_ty_4 {
1341 pub pathname: __u64,
1342 pub bpf_fd: __u32,
1343 pub file_flags: __u32,
1344}
1345#[test]
1346fn bindgen_test_layout_bpf_attr__bindgen_ty_4() {
1347 assert_eq!(
1348 ::std::mem::size_of::<bpf_attr__bindgen_ty_4>(),
1349 16usize,
1350 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_4))
1351 );
1352 assert_eq!(
1353 ::std::mem::align_of::<bpf_attr__bindgen_ty_4>(),
1354 8usize,
1355 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_4))
1356 );
1357 assert_eq!(
1358 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_4>())).pathname as *const _ as usize },
1359 0usize,
1360 concat!(
1361 "Offset of field: ",
1362 stringify!(bpf_attr__bindgen_ty_4),
1363 "::",
1364 stringify!(pathname)
1365 )
1366 );
1367 assert_eq!(
1368 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_4>())).bpf_fd as *const _ as usize },
1369 8usize,
1370 concat!(
1371 "Offset of field: ",
1372 stringify!(bpf_attr__bindgen_ty_4),
1373 "::",
1374 stringify!(bpf_fd)
1375 )
1376 );
1377 assert_eq!(
1378 unsafe {
1379 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_4>())).file_flags as *const _ as usize
1380 },
1381 12usize,
1382 concat!(
1383 "Offset of field: ",
1384 stringify!(bpf_attr__bindgen_ty_4),
1385 "::",
1386 stringify!(file_flags)
1387 )
1388 );
1389}
1390#[repr(C)]
1391#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1392pub struct bpf_attr__bindgen_ty_5 {
1393 pub target_fd: __u32,
1394 pub attach_bpf_fd: __u32,
1395 pub attach_type: __u32,
1396 pub attach_flags: __u32,
1397}
1398#[test]
1399fn bindgen_test_layout_bpf_attr__bindgen_ty_5() {
1400 assert_eq!(
1401 ::std::mem::size_of::<bpf_attr__bindgen_ty_5>(),
1402 16usize,
1403 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_5))
1404 );
1405 assert_eq!(
1406 ::std::mem::align_of::<bpf_attr__bindgen_ty_5>(),
1407 4usize,
1408 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_5))
1409 );
1410 assert_eq!(
1411 unsafe {
1412 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_5>())).target_fd as *const _ as usize
1413 },
1414 0usize,
1415 concat!(
1416 "Offset of field: ",
1417 stringify!(bpf_attr__bindgen_ty_5),
1418 "::",
1419 stringify!(target_fd)
1420 )
1421 );
1422 assert_eq!(
1423 unsafe {
1424 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_5>())).attach_bpf_fd as *const _ as usize
1425 },
1426 4usize,
1427 concat!(
1428 "Offset of field: ",
1429 stringify!(bpf_attr__bindgen_ty_5),
1430 "::",
1431 stringify!(attach_bpf_fd)
1432 )
1433 );
1434 assert_eq!(
1435 unsafe {
1436 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_5>())).attach_type as *const _ as usize
1437 },
1438 8usize,
1439 concat!(
1440 "Offset of field: ",
1441 stringify!(bpf_attr__bindgen_ty_5),
1442 "::",
1443 stringify!(attach_type)
1444 )
1445 );
1446 assert_eq!(
1447 unsafe {
1448 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_5>())).attach_flags as *const _ as usize
1449 },
1450 12usize,
1451 concat!(
1452 "Offset of field: ",
1453 stringify!(bpf_attr__bindgen_ty_5),
1454 "::",
1455 stringify!(attach_flags)
1456 )
1457 );
1458}
1459#[repr(C)]
1460#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1461pub struct bpf_attr__bindgen_ty_6 {
1462 pub prog_fd: __u32,
1463 pub retval: __u32,
1464 pub data_size_in: __u32,
1465 pub data_size_out: __u32,
1466 pub data_in: __u64,
1467 pub data_out: __u64,
1468 pub repeat: __u32,
1469 pub duration: __u32,
1470}
1471#[test]
1472fn bindgen_test_layout_bpf_attr__bindgen_ty_6() {
1473 assert_eq!(
1474 ::std::mem::size_of::<bpf_attr__bindgen_ty_6>(),
1475 40usize,
1476 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_6))
1477 );
1478 assert_eq!(
1479 ::std::mem::align_of::<bpf_attr__bindgen_ty_6>(),
1480 8usize,
1481 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_6))
1482 );
1483 assert_eq!(
1484 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).prog_fd as *const _ as usize },
1485 0usize,
1486 concat!(
1487 "Offset of field: ",
1488 stringify!(bpf_attr__bindgen_ty_6),
1489 "::",
1490 stringify!(prog_fd)
1491 )
1492 );
1493 assert_eq!(
1494 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).retval as *const _ as usize },
1495 4usize,
1496 concat!(
1497 "Offset of field: ",
1498 stringify!(bpf_attr__bindgen_ty_6),
1499 "::",
1500 stringify!(retval)
1501 )
1502 );
1503 assert_eq!(
1504 unsafe {
1505 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).data_size_in as *const _ as usize
1506 },
1507 8usize,
1508 concat!(
1509 "Offset of field: ",
1510 stringify!(bpf_attr__bindgen_ty_6),
1511 "::",
1512 stringify!(data_size_in)
1513 )
1514 );
1515 assert_eq!(
1516 unsafe {
1517 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).data_size_out as *const _ as usize
1518 },
1519 12usize,
1520 concat!(
1521 "Offset of field: ",
1522 stringify!(bpf_attr__bindgen_ty_6),
1523 "::",
1524 stringify!(data_size_out)
1525 )
1526 );
1527 assert_eq!(
1528 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).data_in as *const _ as usize },
1529 16usize,
1530 concat!(
1531 "Offset of field: ",
1532 stringify!(bpf_attr__bindgen_ty_6),
1533 "::",
1534 stringify!(data_in)
1535 )
1536 );
1537 assert_eq!(
1538 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).data_out as *const _ as usize },
1539 24usize,
1540 concat!(
1541 "Offset of field: ",
1542 stringify!(bpf_attr__bindgen_ty_6),
1543 "::",
1544 stringify!(data_out)
1545 )
1546 );
1547 assert_eq!(
1548 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).repeat as *const _ as usize },
1549 32usize,
1550 concat!(
1551 "Offset of field: ",
1552 stringify!(bpf_attr__bindgen_ty_6),
1553 "::",
1554 stringify!(repeat)
1555 )
1556 );
1557 assert_eq!(
1558 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_6>())).duration as *const _ as usize },
1559 36usize,
1560 concat!(
1561 "Offset of field: ",
1562 stringify!(bpf_attr__bindgen_ty_6),
1563 "::",
1564 stringify!(duration)
1565 )
1566 );
1567}
1568#[repr(C)]
1569#[derive(Copy, Clone)]
1570pub struct bpf_attr__bindgen_ty_7 {
1571 pub __bindgen_anon_1: bpf_attr__bindgen_ty_7__bindgen_ty_1,
1572 pub next_id: __u32,
1573 pub open_flags: __u32,
1574}
1575#[repr(C)]
1576#[derive(Copy, Clone)]
1577pub union bpf_attr__bindgen_ty_7__bindgen_ty_1 {
1578 pub start_id: __u32,
1579 pub prog_id: __u32,
1580 pub map_id: __u32,
1581 pub btf_id: __u32,
1582}
1583#[test]
1584fn bindgen_test_layout_bpf_attr__bindgen_ty_7__bindgen_ty_1() {
1585 assert_eq!(
1586 ::std::mem::size_of::<bpf_attr__bindgen_ty_7__bindgen_ty_1>(),
1587 4usize,
1588 concat!(
1589 "Size of: ",
1590 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1)
1591 )
1592 );
1593 assert_eq!(
1594 ::std::mem::align_of::<bpf_attr__bindgen_ty_7__bindgen_ty_1>(),
1595 4usize,
1596 concat!(
1597 "Alignment of ",
1598 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1)
1599 )
1600 );
1601 assert_eq!(
1602 unsafe {
1603 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7__bindgen_ty_1>())).start_id as *const _
1604 as usize
1605 },
1606 0usize,
1607 concat!(
1608 "Offset of field: ",
1609 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1),
1610 "::",
1611 stringify!(start_id)
1612 )
1613 );
1614 assert_eq!(
1615 unsafe {
1616 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7__bindgen_ty_1>())).prog_id as *const _
1617 as usize
1618 },
1619 0usize,
1620 concat!(
1621 "Offset of field: ",
1622 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1),
1623 "::",
1624 stringify!(prog_id)
1625 )
1626 );
1627 assert_eq!(
1628 unsafe {
1629 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7__bindgen_ty_1>())).map_id as *const _
1630 as usize
1631 },
1632 0usize,
1633 concat!(
1634 "Offset of field: ",
1635 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1),
1636 "::",
1637 stringify!(map_id)
1638 )
1639 );
1640 assert_eq!(
1641 unsafe {
1642 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7__bindgen_ty_1>())).btf_id as *const _
1643 as usize
1644 },
1645 0usize,
1646 concat!(
1647 "Offset of field: ",
1648 stringify!(bpf_attr__bindgen_ty_7__bindgen_ty_1),
1649 "::",
1650 stringify!(btf_id)
1651 )
1652 );
1653}
1654impl Default for bpf_attr__bindgen_ty_7__bindgen_ty_1 {
1655 fn default() -> Self {
1656 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1657 unsafe {
1658 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1659 s.assume_init()
1660 }
1661 }
1662}
1663impl ::std::fmt::Debug for bpf_attr__bindgen_ty_7__bindgen_ty_1 {
1664 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1665 write!(f, "bpf_attr__bindgen_ty_7__bindgen_ty_1 {{ union }}")
1666 }
1667}
1668#[test]
1669fn bindgen_test_layout_bpf_attr__bindgen_ty_7() {
1670 assert_eq!(
1671 ::std::mem::size_of::<bpf_attr__bindgen_ty_7>(),
1672 12usize,
1673 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_7))
1674 );
1675 assert_eq!(
1676 ::std::mem::align_of::<bpf_attr__bindgen_ty_7>(),
1677 4usize,
1678 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_7))
1679 );
1680 assert_eq!(
1681 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7>())).next_id as *const _ as usize },
1682 4usize,
1683 concat!(
1684 "Offset of field: ",
1685 stringify!(bpf_attr__bindgen_ty_7),
1686 "::",
1687 stringify!(next_id)
1688 )
1689 );
1690 assert_eq!(
1691 unsafe {
1692 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_7>())).open_flags as *const _ as usize
1693 },
1694 8usize,
1695 concat!(
1696 "Offset of field: ",
1697 stringify!(bpf_attr__bindgen_ty_7),
1698 "::",
1699 stringify!(open_flags)
1700 )
1701 );
1702}
1703impl Default for bpf_attr__bindgen_ty_7 {
1704 fn default() -> Self {
1705 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1706 unsafe {
1707 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1708 s.assume_init()
1709 }
1710 }
1711}
1712impl ::std::fmt::Debug for bpf_attr__bindgen_ty_7 {
1713 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1714 write!(
1715 f,
1716 "bpf_attr__bindgen_ty_7 {{ __bindgen_anon_1: {:?}, next_id: {:?}, open_flags: {:?} }}",
1717 self.__bindgen_anon_1, self.next_id, self.open_flags
1718 )
1719 }
1720}
1721#[repr(C)]
1722#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1723pub struct bpf_attr__bindgen_ty_8 {
1724 pub bpf_fd: __u32,
1725 pub info_len: __u32,
1726 pub info: __u64,
1727}
1728#[test]
1729fn bindgen_test_layout_bpf_attr__bindgen_ty_8() {
1730 assert_eq!(
1731 ::std::mem::size_of::<bpf_attr__bindgen_ty_8>(),
1732 16usize,
1733 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_8))
1734 );
1735 assert_eq!(
1736 ::std::mem::align_of::<bpf_attr__bindgen_ty_8>(),
1737 8usize,
1738 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_8))
1739 );
1740 assert_eq!(
1741 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_8>())).bpf_fd as *const _ as usize },
1742 0usize,
1743 concat!(
1744 "Offset of field: ",
1745 stringify!(bpf_attr__bindgen_ty_8),
1746 "::",
1747 stringify!(bpf_fd)
1748 )
1749 );
1750 assert_eq!(
1751 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_8>())).info_len as *const _ as usize },
1752 4usize,
1753 concat!(
1754 "Offset of field: ",
1755 stringify!(bpf_attr__bindgen_ty_8),
1756 "::",
1757 stringify!(info_len)
1758 )
1759 );
1760 assert_eq!(
1761 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_8>())).info as *const _ as usize },
1762 8usize,
1763 concat!(
1764 "Offset of field: ",
1765 stringify!(bpf_attr__bindgen_ty_8),
1766 "::",
1767 stringify!(info)
1768 )
1769 );
1770}
1771#[repr(C)]
1772#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1773pub struct bpf_attr__bindgen_ty_9 {
1774 pub target_fd: __u32,
1775 pub attach_type: __u32,
1776 pub query_flags: __u32,
1777 pub attach_flags: __u32,
1778 pub prog_ids: __u64,
1779 pub prog_cnt: __u32,
1780}
1781#[test]
1782fn bindgen_test_layout_bpf_attr__bindgen_ty_9() {
1783 assert_eq!(
1784 ::std::mem::size_of::<bpf_attr__bindgen_ty_9>(),
1785 32usize,
1786 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_9))
1787 );
1788 assert_eq!(
1789 ::std::mem::align_of::<bpf_attr__bindgen_ty_9>(),
1790 8usize,
1791 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_9))
1792 );
1793 assert_eq!(
1794 unsafe {
1795 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).target_fd as *const _ as usize
1796 },
1797 0usize,
1798 concat!(
1799 "Offset of field: ",
1800 stringify!(bpf_attr__bindgen_ty_9),
1801 "::",
1802 stringify!(target_fd)
1803 )
1804 );
1805 assert_eq!(
1806 unsafe {
1807 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).attach_type as *const _ as usize
1808 },
1809 4usize,
1810 concat!(
1811 "Offset of field: ",
1812 stringify!(bpf_attr__bindgen_ty_9),
1813 "::",
1814 stringify!(attach_type)
1815 )
1816 );
1817 assert_eq!(
1818 unsafe {
1819 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).query_flags as *const _ as usize
1820 },
1821 8usize,
1822 concat!(
1823 "Offset of field: ",
1824 stringify!(bpf_attr__bindgen_ty_9),
1825 "::",
1826 stringify!(query_flags)
1827 )
1828 );
1829 assert_eq!(
1830 unsafe {
1831 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).attach_flags as *const _ as usize
1832 },
1833 12usize,
1834 concat!(
1835 "Offset of field: ",
1836 stringify!(bpf_attr__bindgen_ty_9),
1837 "::",
1838 stringify!(attach_flags)
1839 )
1840 );
1841 assert_eq!(
1842 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).prog_ids as *const _ as usize },
1843 16usize,
1844 concat!(
1845 "Offset of field: ",
1846 stringify!(bpf_attr__bindgen_ty_9),
1847 "::",
1848 stringify!(prog_ids)
1849 )
1850 );
1851 assert_eq!(
1852 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_9>())).prog_cnt as *const _ as usize },
1853 24usize,
1854 concat!(
1855 "Offset of field: ",
1856 stringify!(bpf_attr__bindgen_ty_9),
1857 "::",
1858 stringify!(prog_cnt)
1859 )
1860 );
1861}
1862#[repr(C)]
1863#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1864pub struct bpf_attr__bindgen_ty_10 {
1865 pub name: __u64,
1866 pub prog_fd: __u32,
1867}
1868#[test]
1869fn bindgen_test_layout_bpf_attr__bindgen_ty_10() {
1870 assert_eq!(
1871 ::std::mem::size_of::<bpf_attr__bindgen_ty_10>(),
1872 16usize,
1873 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_10))
1874 );
1875 assert_eq!(
1876 ::std::mem::align_of::<bpf_attr__bindgen_ty_10>(),
1877 8usize,
1878 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_10))
1879 );
1880 assert_eq!(
1881 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_10>())).name as *const _ as usize },
1882 0usize,
1883 concat!(
1884 "Offset of field: ",
1885 stringify!(bpf_attr__bindgen_ty_10),
1886 "::",
1887 stringify!(name)
1888 )
1889 );
1890 assert_eq!(
1891 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_10>())).prog_fd as *const _ as usize },
1892 8usize,
1893 concat!(
1894 "Offset of field: ",
1895 stringify!(bpf_attr__bindgen_ty_10),
1896 "::",
1897 stringify!(prog_fd)
1898 )
1899 );
1900}
1901#[repr(C)]
1902#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1903pub struct bpf_attr__bindgen_ty_11 {
1904 pub btf: __u64,
1905 pub btf_log_buf: __u64,
1906 pub btf_size: __u32,
1907 pub btf_log_size: __u32,
1908 pub btf_log_level: __u32,
1909}
1910#[test]
1911fn bindgen_test_layout_bpf_attr__bindgen_ty_11() {
1912 assert_eq!(
1913 ::std::mem::size_of::<bpf_attr__bindgen_ty_11>(),
1914 32usize,
1915 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_11))
1916 );
1917 assert_eq!(
1918 ::std::mem::align_of::<bpf_attr__bindgen_ty_11>(),
1919 8usize,
1920 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_11))
1921 );
1922 assert_eq!(
1923 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_11>())).btf as *const _ as usize },
1924 0usize,
1925 concat!(
1926 "Offset of field: ",
1927 stringify!(bpf_attr__bindgen_ty_11),
1928 "::",
1929 stringify!(btf)
1930 )
1931 );
1932 assert_eq!(
1933 unsafe {
1934 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_11>())).btf_log_buf as *const _ as usize
1935 },
1936 8usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(bpf_attr__bindgen_ty_11),
1940 "::",
1941 stringify!(btf_log_buf)
1942 )
1943 );
1944 assert_eq!(
1945 unsafe {
1946 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_11>())).btf_size as *const _ as usize
1947 },
1948 16usize,
1949 concat!(
1950 "Offset of field: ",
1951 stringify!(bpf_attr__bindgen_ty_11),
1952 "::",
1953 stringify!(btf_size)
1954 )
1955 );
1956 assert_eq!(
1957 unsafe {
1958 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_11>())).btf_log_size as *const _ as usize
1959 },
1960 20usize,
1961 concat!(
1962 "Offset of field: ",
1963 stringify!(bpf_attr__bindgen_ty_11),
1964 "::",
1965 stringify!(btf_log_size)
1966 )
1967 );
1968 assert_eq!(
1969 unsafe {
1970 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_11>())).btf_log_level as *const _ as usize
1971 },
1972 24usize,
1973 concat!(
1974 "Offset of field: ",
1975 stringify!(bpf_attr__bindgen_ty_11),
1976 "::",
1977 stringify!(btf_log_level)
1978 )
1979 );
1980}
1981#[repr(C)]
1982#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1983pub struct bpf_attr__bindgen_ty_12 {
1984 pub pid: __u32,
1985 pub fd: __u32,
1986 pub flags: __u32,
1987 pub buf_len: __u32,
1988 pub buf: __u64,
1989 pub prog_id: __u32,
1990 pub fd_type: __u32,
1991 pub probe_offset: __u64,
1992 pub probe_addr: __u64,
1993}
1994#[test]
1995fn bindgen_test_layout_bpf_attr__bindgen_ty_12() {
1996 assert_eq!(
1997 ::std::mem::size_of::<bpf_attr__bindgen_ty_12>(),
1998 48usize,
1999 concat!("Size of: ", stringify!(bpf_attr__bindgen_ty_12))
2000 );
2001 assert_eq!(
2002 ::std::mem::align_of::<bpf_attr__bindgen_ty_12>(),
2003 8usize,
2004 concat!("Alignment of ", stringify!(bpf_attr__bindgen_ty_12))
2005 );
2006 assert_eq!(
2007 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).pid as *const _ as usize },
2008 0usize,
2009 concat!(
2010 "Offset of field: ",
2011 stringify!(bpf_attr__bindgen_ty_12),
2012 "::",
2013 stringify!(pid)
2014 )
2015 );
2016 assert_eq!(
2017 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).fd as *const _ as usize },
2018 4usize,
2019 concat!(
2020 "Offset of field: ",
2021 stringify!(bpf_attr__bindgen_ty_12),
2022 "::",
2023 stringify!(fd)
2024 )
2025 );
2026 assert_eq!(
2027 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).flags as *const _ as usize },
2028 8usize,
2029 concat!(
2030 "Offset of field: ",
2031 stringify!(bpf_attr__bindgen_ty_12),
2032 "::",
2033 stringify!(flags)
2034 )
2035 );
2036 assert_eq!(
2037 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).buf_len as *const _ as usize },
2038 12usize,
2039 concat!(
2040 "Offset of field: ",
2041 stringify!(bpf_attr__bindgen_ty_12),
2042 "::",
2043 stringify!(buf_len)
2044 )
2045 );
2046 assert_eq!(
2047 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).buf as *const _ as usize },
2048 16usize,
2049 concat!(
2050 "Offset of field: ",
2051 stringify!(bpf_attr__bindgen_ty_12),
2052 "::",
2053 stringify!(buf)
2054 )
2055 );
2056 assert_eq!(
2057 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).prog_id as *const _ as usize },
2058 24usize,
2059 concat!(
2060 "Offset of field: ",
2061 stringify!(bpf_attr__bindgen_ty_12),
2062 "::",
2063 stringify!(prog_id)
2064 )
2065 );
2066 assert_eq!(
2067 unsafe { &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).fd_type as *const _ as usize },
2068 28usize,
2069 concat!(
2070 "Offset of field: ",
2071 stringify!(bpf_attr__bindgen_ty_12),
2072 "::",
2073 stringify!(fd_type)
2074 )
2075 );
2076 assert_eq!(
2077 unsafe {
2078 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).probe_offset as *const _ as usize
2079 },
2080 32usize,
2081 concat!(
2082 "Offset of field: ",
2083 stringify!(bpf_attr__bindgen_ty_12),
2084 "::",
2085 stringify!(probe_offset)
2086 )
2087 );
2088 assert_eq!(
2089 unsafe {
2090 &(*(::std::ptr::null::<bpf_attr__bindgen_ty_12>())).probe_addr as *const _ as usize
2091 },
2092 40usize,
2093 concat!(
2094 "Offset of field: ",
2095 stringify!(bpf_attr__bindgen_ty_12),
2096 "::",
2097 stringify!(probe_addr)
2098 )
2099 );
2100}
2101#[test]
2102fn bindgen_test_layout_bpf_attr() {
2103 assert_eq!(
2104 ::std::mem::size_of::<bpf_attr>(),
2105 72usize,
2106 concat!("Size of: ", stringify!(bpf_attr))
2107 );
2108 assert_eq!(
2109 ::std::mem::align_of::<bpf_attr>(),
2110 8usize,
2111 concat!("Alignment of ", stringify!(bpf_attr))
2112 );
2113 assert_eq!(
2114 unsafe { &(*(::std::ptr::null::<bpf_attr>())).test as *const _ as usize },
2115 0usize,
2116 concat!(
2117 "Offset of field: ",
2118 stringify!(bpf_attr),
2119 "::",
2120 stringify!(test)
2121 )
2122 );
2123 assert_eq!(
2124 unsafe { &(*(::std::ptr::null::<bpf_attr>())).info as *const _ as usize },
2125 0usize,
2126 concat!(
2127 "Offset of field: ",
2128 stringify!(bpf_attr),
2129 "::",
2130 stringify!(info)
2131 )
2132 );
2133 assert_eq!(
2134 unsafe { &(*(::std::ptr::null::<bpf_attr>())).query as *const _ as usize },
2135 0usize,
2136 concat!(
2137 "Offset of field: ",
2138 stringify!(bpf_attr),
2139 "::",
2140 stringify!(query)
2141 )
2142 );
2143 assert_eq!(
2144 unsafe { &(*(::std::ptr::null::<bpf_attr>())).raw_tracepoint as *const _ as usize },
2145 0usize,
2146 concat!(
2147 "Offset of field: ",
2148 stringify!(bpf_attr),
2149 "::",
2150 stringify!(raw_tracepoint)
2151 )
2152 );
2153 assert_eq!(
2154 unsafe { &(*(::std::ptr::null::<bpf_attr>())).task_fd_query as *const _ as usize },
2155 0usize,
2156 concat!(
2157 "Offset of field: ",
2158 stringify!(bpf_attr),
2159 "::",
2160 stringify!(task_fd_query)
2161 )
2162 );
2163}
2164impl Default for bpf_attr {
2165 fn default() -> Self {
2166 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2167 unsafe {
2168 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2169 s.assume_init()
2170 }
2171 }
2172}
2173impl ::std::fmt::Debug for bpf_attr {
2174 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2175 write!(f, "bpf_attr {{ union }}")
2176 }
2177}
2178pub const bpf_func_id_BPF_FUNC_unspec: bpf_func_id = 0;
2179pub const bpf_func_id_BPF_FUNC_map_lookup_elem: bpf_func_id = 1;
2180pub const bpf_func_id_BPF_FUNC_map_update_elem: bpf_func_id = 2;
2181pub const bpf_func_id_BPF_FUNC_map_delete_elem: bpf_func_id = 3;
2182pub const bpf_func_id_BPF_FUNC_probe_read: bpf_func_id = 4;
2183pub const bpf_func_id_BPF_FUNC_ktime_get_ns: bpf_func_id = 5;
2184pub const bpf_func_id_BPF_FUNC_trace_printk: bpf_func_id = 6;
2185pub const bpf_func_id_BPF_FUNC_get_prandom_u32: bpf_func_id = 7;
2186pub const bpf_func_id_BPF_FUNC_get_smp_processor_id: bpf_func_id = 8;
2187pub const bpf_func_id_BPF_FUNC_skb_store_bytes: bpf_func_id = 9;
2188pub const bpf_func_id_BPF_FUNC_l3_csum_replace: bpf_func_id = 10;
2189pub const bpf_func_id_BPF_FUNC_l4_csum_replace: bpf_func_id = 11;
2190pub const bpf_func_id_BPF_FUNC_tail_call: bpf_func_id = 12;
2191pub const bpf_func_id_BPF_FUNC_clone_redirect: bpf_func_id = 13;
2192pub const bpf_func_id_BPF_FUNC_get_current_pid_tgid: bpf_func_id = 14;
2193pub const bpf_func_id_BPF_FUNC_get_current_uid_gid: bpf_func_id = 15;
2194pub const bpf_func_id_BPF_FUNC_get_current_comm: bpf_func_id = 16;
2195pub const bpf_func_id_BPF_FUNC_get_cgroup_classid: bpf_func_id = 17;
2196pub const bpf_func_id_BPF_FUNC_skb_vlan_push: bpf_func_id = 18;
2197pub const bpf_func_id_BPF_FUNC_skb_vlan_pop: bpf_func_id = 19;
2198pub const bpf_func_id_BPF_FUNC_skb_get_tunnel_key: bpf_func_id = 20;
2199pub const bpf_func_id_BPF_FUNC_skb_set_tunnel_key: bpf_func_id = 21;
2200pub const bpf_func_id_BPF_FUNC_perf_event_read: bpf_func_id = 22;
2201pub const bpf_func_id_BPF_FUNC_redirect: bpf_func_id = 23;
2202pub const bpf_func_id_BPF_FUNC_get_route_realm: bpf_func_id = 24;
2203pub const bpf_func_id_BPF_FUNC_perf_event_output: bpf_func_id = 25;
2204pub const bpf_func_id_BPF_FUNC_skb_load_bytes: bpf_func_id = 26;
2205pub const bpf_func_id_BPF_FUNC_get_stackid: bpf_func_id = 27;
2206pub const bpf_func_id_BPF_FUNC_csum_diff: bpf_func_id = 28;
2207pub const bpf_func_id_BPF_FUNC_skb_get_tunnel_opt: bpf_func_id = 29;
2208pub const bpf_func_id_BPF_FUNC_skb_set_tunnel_opt: bpf_func_id = 30;
2209pub const bpf_func_id_BPF_FUNC_skb_change_proto: bpf_func_id = 31;
2210pub const bpf_func_id_BPF_FUNC_skb_change_type: bpf_func_id = 32;
2211pub const bpf_func_id_BPF_FUNC_skb_under_cgroup: bpf_func_id = 33;
2212pub const bpf_func_id_BPF_FUNC_get_hash_recalc: bpf_func_id = 34;
2213pub const bpf_func_id_BPF_FUNC_get_current_task: bpf_func_id = 35;
2214pub const bpf_func_id_BPF_FUNC_probe_write_user: bpf_func_id = 36;
2215pub const bpf_func_id_BPF_FUNC_current_task_under_cgroup: bpf_func_id = 37;
2216pub const bpf_func_id_BPF_FUNC_skb_change_tail: bpf_func_id = 38;
2217pub const bpf_func_id_BPF_FUNC_skb_pull_data: bpf_func_id = 39;
2218pub const bpf_func_id_BPF_FUNC_csum_update: bpf_func_id = 40;
2219pub const bpf_func_id_BPF_FUNC_set_hash_invalid: bpf_func_id = 41;
2220pub const bpf_func_id_BPF_FUNC_get_numa_node_id: bpf_func_id = 42;
2221pub const bpf_func_id_BPF_FUNC_skb_change_head: bpf_func_id = 43;
2222pub const bpf_func_id_BPF_FUNC_xdp_adjust_head: bpf_func_id = 44;
2223pub const bpf_func_id_BPF_FUNC_probe_read_str: bpf_func_id = 45;
2224pub const bpf_func_id_BPF_FUNC_get_socket_cookie: bpf_func_id = 46;
2225pub const bpf_func_id_BPF_FUNC_get_socket_uid: bpf_func_id = 47;
2226pub const bpf_func_id_BPF_FUNC_set_hash: bpf_func_id = 48;
2227pub const bpf_func_id_BPF_FUNC_setsockopt: bpf_func_id = 49;
2228pub const bpf_func_id_BPF_FUNC_skb_adjust_room: bpf_func_id = 50;
2229pub const bpf_func_id_BPF_FUNC_redirect_map: bpf_func_id = 51;
2230pub const bpf_func_id_BPF_FUNC_sk_redirect_map: bpf_func_id = 52;
2231pub const bpf_func_id_BPF_FUNC_sock_map_update: bpf_func_id = 53;
2232pub const bpf_func_id_BPF_FUNC_xdp_adjust_meta: bpf_func_id = 54;
2233pub const bpf_func_id_BPF_FUNC_perf_event_read_value: bpf_func_id = 55;
2234pub const bpf_func_id_BPF_FUNC_perf_prog_read_value: bpf_func_id = 56;
2235pub const bpf_func_id_BPF_FUNC_getsockopt: bpf_func_id = 57;
2236pub const bpf_func_id_BPF_FUNC_override_return: bpf_func_id = 58;
2237pub const bpf_func_id_BPF_FUNC_sock_ops_cb_flags_set: bpf_func_id = 59;
2238pub const bpf_func_id_BPF_FUNC_msg_redirect_map: bpf_func_id = 60;
2239pub const bpf_func_id_BPF_FUNC_msg_apply_bytes: bpf_func_id = 61;
2240pub const bpf_func_id_BPF_FUNC_msg_cork_bytes: bpf_func_id = 62;
2241pub const bpf_func_id_BPF_FUNC_msg_pull_data: bpf_func_id = 63;
2242pub const bpf_func_id_BPF_FUNC_bind: bpf_func_id = 64;
2243pub const bpf_func_id_BPF_FUNC_xdp_adjust_tail: bpf_func_id = 65;
2244pub const bpf_func_id_BPF_FUNC_skb_get_xfrm_state: bpf_func_id = 66;
2245pub const bpf_func_id_BPF_FUNC_get_stack: bpf_func_id = 67;
2246pub const bpf_func_id_BPF_FUNC_skb_load_bytes_relative: bpf_func_id = 68;
2247pub const bpf_func_id_BPF_FUNC_fib_lookup: bpf_func_id = 69;
2248pub const bpf_func_id_BPF_FUNC_sock_hash_update: bpf_func_id = 70;
2249pub const bpf_func_id_BPF_FUNC_msg_redirect_hash: bpf_func_id = 71;
2250pub const bpf_func_id_BPF_FUNC_sk_redirect_hash: bpf_func_id = 72;
2251pub const bpf_func_id_BPF_FUNC_lwt_push_encap: bpf_func_id = 73;
2252pub const bpf_func_id_BPF_FUNC_lwt_seg6_store_bytes: bpf_func_id = 74;
2253pub const bpf_func_id_BPF_FUNC_lwt_seg6_adjust_srh: bpf_func_id = 75;
2254pub const bpf_func_id_BPF_FUNC_lwt_seg6_action: bpf_func_id = 76;
2255pub const bpf_func_id_BPF_FUNC_rc_repeat: bpf_func_id = 77;
2256pub const bpf_func_id_BPF_FUNC_rc_keydown: bpf_func_id = 78;
2257pub const bpf_func_id_BPF_FUNC_skb_cgroup_id: bpf_func_id = 79;
2258pub const bpf_func_id_BPF_FUNC_get_current_cgroup_id: bpf_func_id = 80;
2259pub const bpf_func_id_BPF_FUNC_get_local_storage: bpf_func_id = 81;
2260pub const bpf_func_id_BPF_FUNC_sk_select_reuseport: bpf_func_id = 82;
2261pub const bpf_func_id_BPF_FUNC_skb_ancestor_cgroup_id: bpf_func_id = 83;
2262pub const bpf_func_id___BPF_FUNC_MAX_ID: bpf_func_id = 84;
2263pub type bpf_func_id = ::std::os::raw::c_uint;
2264pub const bpf_adj_room_mode_BPF_ADJ_ROOM_NET: bpf_adj_room_mode = 0;
2265pub type bpf_adj_room_mode = ::std::os::raw::c_uint;
2266pub const bpf_hdr_start_off_BPF_HDR_START_MAC: bpf_hdr_start_off = 0;
2267pub const bpf_hdr_start_off_BPF_HDR_START_NET: bpf_hdr_start_off = 1;
2268pub type bpf_hdr_start_off = ::std::os::raw::c_uint;
2269pub const bpf_lwt_encap_mode_BPF_LWT_ENCAP_SEG6: bpf_lwt_encap_mode = 0;
2270pub const bpf_lwt_encap_mode_BPF_LWT_ENCAP_SEG6_INLINE: bpf_lwt_encap_mode = 1;
2271pub type bpf_lwt_encap_mode = ::std::os::raw::c_uint;
2272#[repr(C)]
2273#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2274pub struct __sk_buff {
2275 pub len: __u32,
2276 pub pkt_type: __u32,
2277 pub mark: __u32,
2278 pub queue_mapping: __u32,
2279 pub protocol: __u32,
2280 pub vlan_present: __u32,
2281 pub vlan_tci: __u32,
2282 pub vlan_proto: __u32,
2283 pub priority: __u32,
2284 pub ingress_ifindex: __u32,
2285 pub ifindex: __u32,
2286 pub tc_index: __u32,
2287 pub cb: [__u32; 5usize],
2288 pub hash: __u32,
2289 pub tc_classid: __u32,
2290 pub data: __u32,
2291 pub data_end: __u32,
2292 pub napi_id: __u32,
2293 pub family: __u32,
2294 pub remote_ip4: __u32,
2295 pub local_ip4: __u32,
2296 pub remote_ip6: [__u32; 4usize],
2297 pub local_ip6: [__u32; 4usize],
2298 pub remote_port: __u32,
2299 pub local_port: __u32,
2300 pub data_meta: __u32,
2301}
2302#[test]
2303fn bindgen_test_layout___sk_buff() {
2304 assert_eq!(
2305 ::std::mem::size_of::<__sk_buff>(),
2306 144usize,
2307 concat!("Size of: ", stringify!(__sk_buff))
2308 );
2309 assert_eq!(
2310 ::std::mem::align_of::<__sk_buff>(),
2311 4usize,
2312 concat!("Alignment of ", stringify!(__sk_buff))
2313 );
2314 assert_eq!(
2315 unsafe { &(*(::std::ptr::null::<__sk_buff>())).len as *const _ as usize },
2316 0usize,
2317 concat!(
2318 "Offset of field: ",
2319 stringify!(__sk_buff),
2320 "::",
2321 stringify!(len)
2322 )
2323 );
2324 assert_eq!(
2325 unsafe { &(*(::std::ptr::null::<__sk_buff>())).pkt_type as *const _ as usize },
2326 4usize,
2327 concat!(
2328 "Offset of field: ",
2329 stringify!(__sk_buff),
2330 "::",
2331 stringify!(pkt_type)
2332 )
2333 );
2334 assert_eq!(
2335 unsafe { &(*(::std::ptr::null::<__sk_buff>())).mark as *const _ as usize },
2336 8usize,
2337 concat!(
2338 "Offset of field: ",
2339 stringify!(__sk_buff),
2340 "::",
2341 stringify!(mark)
2342 )
2343 );
2344 assert_eq!(
2345 unsafe { &(*(::std::ptr::null::<__sk_buff>())).queue_mapping as *const _ as usize },
2346 12usize,
2347 concat!(
2348 "Offset of field: ",
2349 stringify!(__sk_buff),
2350 "::",
2351 stringify!(queue_mapping)
2352 )
2353 );
2354 assert_eq!(
2355 unsafe { &(*(::std::ptr::null::<__sk_buff>())).protocol as *const _ as usize },
2356 16usize,
2357 concat!(
2358 "Offset of field: ",
2359 stringify!(__sk_buff),
2360 "::",
2361 stringify!(protocol)
2362 )
2363 );
2364 assert_eq!(
2365 unsafe { &(*(::std::ptr::null::<__sk_buff>())).vlan_present as *const _ as usize },
2366 20usize,
2367 concat!(
2368 "Offset of field: ",
2369 stringify!(__sk_buff),
2370 "::",
2371 stringify!(vlan_present)
2372 )
2373 );
2374 assert_eq!(
2375 unsafe { &(*(::std::ptr::null::<__sk_buff>())).vlan_tci as *const _ as usize },
2376 24usize,
2377 concat!(
2378 "Offset of field: ",
2379 stringify!(__sk_buff),
2380 "::",
2381 stringify!(vlan_tci)
2382 )
2383 );
2384 assert_eq!(
2385 unsafe { &(*(::std::ptr::null::<__sk_buff>())).vlan_proto as *const _ as usize },
2386 28usize,
2387 concat!(
2388 "Offset of field: ",
2389 stringify!(__sk_buff),
2390 "::",
2391 stringify!(vlan_proto)
2392 )
2393 );
2394 assert_eq!(
2395 unsafe { &(*(::std::ptr::null::<__sk_buff>())).priority as *const _ as usize },
2396 32usize,
2397 concat!(
2398 "Offset of field: ",
2399 stringify!(__sk_buff),
2400 "::",
2401 stringify!(priority)
2402 )
2403 );
2404 assert_eq!(
2405 unsafe { &(*(::std::ptr::null::<__sk_buff>())).ingress_ifindex as *const _ as usize },
2406 36usize,
2407 concat!(
2408 "Offset of field: ",
2409 stringify!(__sk_buff),
2410 "::",
2411 stringify!(ingress_ifindex)
2412 )
2413 );
2414 assert_eq!(
2415 unsafe { &(*(::std::ptr::null::<__sk_buff>())).ifindex as *const _ as usize },
2416 40usize,
2417 concat!(
2418 "Offset of field: ",
2419 stringify!(__sk_buff),
2420 "::",
2421 stringify!(ifindex)
2422 )
2423 );
2424 assert_eq!(
2425 unsafe { &(*(::std::ptr::null::<__sk_buff>())).tc_index as *const _ as usize },
2426 44usize,
2427 concat!(
2428 "Offset of field: ",
2429 stringify!(__sk_buff),
2430 "::",
2431 stringify!(tc_index)
2432 )
2433 );
2434 assert_eq!(
2435 unsafe { &(*(::std::ptr::null::<__sk_buff>())).cb as *const _ as usize },
2436 48usize,
2437 concat!(
2438 "Offset of field: ",
2439 stringify!(__sk_buff),
2440 "::",
2441 stringify!(cb)
2442 )
2443 );
2444 assert_eq!(
2445 unsafe { &(*(::std::ptr::null::<__sk_buff>())).hash as *const _ as usize },
2446 68usize,
2447 concat!(
2448 "Offset of field: ",
2449 stringify!(__sk_buff),
2450 "::",
2451 stringify!(hash)
2452 )
2453 );
2454 assert_eq!(
2455 unsafe { &(*(::std::ptr::null::<__sk_buff>())).tc_classid as *const _ as usize },
2456 72usize,
2457 concat!(
2458 "Offset of field: ",
2459 stringify!(__sk_buff),
2460 "::",
2461 stringify!(tc_classid)
2462 )
2463 );
2464 assert_eq!(
2465 unsafe { &(*(::std::ptr::null::<__sk_buff>())).data as *const _ as usize },
2466 76usize,
2467 concat!(
2468 "Offset of field: ",
2469 stringify!(__sk_buff),
2470 "::",
2471 stringify!(data)
2472 )
2473 );
2474 assert_eq!(
2475 unsafe { &(*(::std::ptr::null::<__sk_buff>())).data_end as *const _ as usize },
2476 80usize,
2477 concat!(
2478 "Offset of field: ",
2479 stringify!(__sk_buff),
2480 "::",
2481 stringify!(data_end)
2482 )
2483 );
2484 assert_eq!(
2485 unsafe { &(*(::std::ptr::null::<__sk_buff>())).napi_id as *const _ as usize },
2486 84usize,
2487 concat!(
2488 "Offset of field: ",
2489 stringify!(__sk_buff),
2490 "::",
2491 stringify!(napi_id)
2492 )
2493 );
2494 assert_eq!(
2495 unsafe { &(*(::std::ptr::null::<__sk_buff>())).family as *const _ as usize },
2496 88usize,
2497 concat!(
2498 "Offset of field: ",
2499 stringify!(__sk_buff),
2500 "::",
2501 stringify!(family)
2502 )
2503 );
2504 assert_eq!(
2505 unsafe { &(*(::std::ptr::null::<__sk_buff>())).remote_ip4 as *const _ as usize },
2506 92usize,
2507 concat!(
2508 "Offset of field: ",
2509 stringify!(__sk_buff),
2510 "::",
2511 stringify!(remote_ip4)
2512 )
2513 );
2514 assert_eq!(
2515 unsafe { &(*(::std::ptr::null::<__sk_buff>())).local_ip4 as *const _ as usize },
2516 96usize,
2517 concat!(
2518 "Offset of field: ",
2519 stringify!(__sk_buff),
2520 "::",
2521 stringify!(local_ip4)
2522 )
2523 );
2524 assert_eq!(
2525 unsafe { &(*(::std::ptr::null::<__sk_buff>())).remote_ip6 as *const _ as usize },
2526 100usize,
2527 concat!(
2528 "Offset of field: ",
2529 stringify!(__sk_buff),
2530 "::",
2531 stringify!(remote_ip6)
2532 )
2533 );
2534 assert_eq!(
2535 unsafe { &(*(::std::ptr::null::<__sk_buff>())).local_ip6 as *const _ as usize },
2536 116usize,
2537 concat!(
2538 "Offset of field: ",
2539 stringify!(__sk_buff),
2540 "::",
2541 stringify!(local_ip6)
2542 )
2543 );
2544 assert_eq!(
2545 unsafe { &(*(::std::ptr::null::<__sk_buff>())).remote_port as *const _ as usize },
2546 132usize,
2547 concat!(
2548 "Offset of field: ",
2549 stringify!(__sk_buff),
2550 "::",
2551 stringify!(remote_port)
2552 )
2553 );
2554 assert_eq!(
2555 unsafe { &(*(::std::ptr::null::<__sk_buff>())).local_port as *const _ as usize },
2556 136usize,
2557 concat!(
2558 "Offset of field: ",
2559 stringify!(__sk_buff),
2560 "::",
2561 stringify!(local_port)
2562 )
2563 );
2564 assert_eq!(
2565 unsafe { &(*(::std::ptr::null::<__sk_buff>())).data_meta as *const _ as usize },
2566 140usize,
2567 concat!(
2568 "Offset of field: ",
2569 stringify!(__sk_buff),
2570 "::",
2571 stringify!(data_meta)
2572 )
2573 );
2574}
2575#[repr(C)]
2576#[derive(Copy, Clone)]
2577pub struct bpf_tunnel_key {
2578 pub tunnel_id: __u32,
2579 pub __bindgen_anon_1: bpf_tunnel_key__bindgen_ty_1,
2580 pub tunnel_tos: __u8,
2581 pub tunnel_ttl: __u8,
2582 pub tunnel_ext: __u16,
2583 pub tunnel_label: __u32,
2584}
2585#[repr(C)]
2586#[derive(Copy, Clone)]
2587pub union bpf_tunnel_key__bindgen_ty_1 {
2588 pub remote_ipv4: __u32,
2589 pub remote_ipv6: [__u32; 4usize],
2590}
2591#[test]
2592fn bindgen_test_layout_bpf_tunnel_key__bindgen_ty_1() {
2593 assert_eq!(
2594 ::std::mem::size_of::<bpf_tunnel_key__bindgen_ty_1>(),
2595 16usize,
2596 concat!("Size of: ", stringify!(bpf_tunnel_key__bindgen_ty_1))
2597 );
2598 assert_eq!(
2599 ::std::mem::align_of::<bpf_tunnel_key__bindgen_ty_1>(),
2600 4usize,
2601 concat!("Alignment of ", stringify!(bpf_tunnel_key__bindgen_ty_1))
2602 );
2603 assert_eq!(
2604 unsafe {
2605 &(*(::std::ptr::null::<bpf_tunnel_key__bindgen_ty_1>())).remote_ipv4 as *const _
2606 as usize
2607 },
2608 0usize,
2609 concat!(
2610 "Offset of field: ",
2611 stringify!(bpf_tunnel_key__bindgen_ty_1),
2612 "::",
2613 stringify!(remote_ipv4)
2614 )
2615 );
2616 assert_eq!(
2617 unsafe {
2618 &(*(::std::ptr::null::<bpf_tunnel_key__bindgen_ty_1>())).remote_ipv6 as *const _
2619 as usize
2620 },
2621 0usize,
2622 concat!(
2623 "Offset of field: ",
2624 stringify!(bpf_tunnel_key__bindgen_ty_1),
2625 "::",
2626 stringify!(remote_ipv6)
2627 )
2628 );
2629}
2630impl Default for bpf_tunnel_key__bindgen_ty_1 {
2631 fn default() -> Self {
2632 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2633 unsafe {
2634 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2635 s.assume_init()
2636 }
2637 }
2638}
2639impl ::std::fmt::Debug for bpf_tunnel_key__bindgen_ty_1 {
2640 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2641 write!(f, "bpf_tunnel_key__bindgen_ty_1 {{ union }}")
2642 }
2643}
2644#[test]
2645fn bindgen_test_layout_bpf_tunnel_key() {
2646 assert_eq!(
2647 ::std::mem::size_of::<bpf_tunnel_key>(),
2648 28usize,
2649 concat!("Size of: ", stringify!(bpf_tunnel_key))
2650 );
2651 assert_eq!(
2652 ::std::mem::align_of::<bpf_tunnel_key>(),
2653 4usize,
2654 concat!("Alignment of ", stringify!(bpf_tunnel_key))
2655 );
2656 assert_eq!(
2657 unsafe { &(*(::std::ptr::null::<bpf_tunnel_key>())).tunnel_id as *const _ as usize },
2658 0usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(bpf_tunnel_key),
2662 "::",
2663 stringify!(tunnel_id)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe { &(*(::std::ptr::null::<bpf_tunnel_key>())).tunnel_tos as *const _ as usize },
2668 20usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(bpf_tunnel_key),
2672 "::",
2673 stringify!(tunnel_tos)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { &(*(::std::ptr::null::<bpf_tunnel_key>())).tunnel_ttl as *const _ as usize },
2678 21usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(bpf_tunnel_key),
2682 "::",
2683 stringify!(tunnel_ttl)
2684 )
2685 );
2686 assert_eq!(
2687 unsafe { &(*(::std::ptr::null::<bpf_tunnel_key>())).tunnel_ext as *const _ as usize },
2688 22usize,
2689 concat!(
2690 "Offset of field: ",
2691 stringify!(bpf_tunnel_key),
2692 "::",
2693 stringify!(tunnel_ext)
2694 )
2695 );
2696 assert_eq!(
2697 unsafe { &(*(::std::ptr::null::<bpf_tunnel_key>())).tunnel_label as *const _ as usize },
2698 24usize,
2699 concat!(
2700 "Offset of field: ",
2701 stringify!(bpf_tunnel_key),
2702 "::",
2703 stringify!(tunnel_label)
2704 )
2705 );
2706}
2707impl Default for bpf_tunnel_key {
2708 fn default() -> Self {
2709 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2710 unsafe {
2711 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2712 s.assume_init()
2713 }
2714 }
2715}
2716impl ::std::fmt::Debug for bpf_tunnel_key {
2717 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2718 write ! (f , "bpf_tunnel_key {{ tunnel_id: {:?}, __bindgen_anon_1: {:?}, tunnel_tos: {:?}, tunnel_ttl: {:?}, tunnel_ext: {:?}, tunnel_label: {:?} }}" , self . tunnel_id , self . __bindgen_anon_1 , self . tunnel_tos , self . tunnel_ttl , self . tunnel_ext , self . tunnel_label)
2719 }
2720}
2721#[repr(C)]
2722#[derive(Copy, Clone)]
2723pub struct bpf_xfrm_state {
2724 pub reqid: __u32,
2725 pub spi: __u32,
2726 pub family: __u16,
2727 pub ext: __u16,
2728 pub __bindgen_anon_1: bpf_xfrm_state__bindgen_ty_1,
2729}
2730#[repr(C)]
2731#[derive(Copy, Clone)]
2732pub union bpf_xfrm_state__bindgen_ty_1 {
2733 pub remote_ipv4: __u32,
2734 pub remote_ipv6: [__u32; 4usize],
2735}
2736#[test]
2737fn bindgen_test_layout_bpf_xfrm_state__bindgen_ty_1() {
2738 assert_eq!(
2739 ::std::mem::size_of::<bpf_xfrm_state__bindgen_ty_1>(),
2740 16usize,
2741 concat!("Size of: ", stringify!(bpf_xfrm_state__bindgen_ty_1))
2742 );
2743 assert_eq!(
2744 ::std::mem::align_of::<bpf_xfrm_state__bindgen_ty_1>(),
2745 4usize,
2746 concat!("Alignment of ", stringify!(bpf_xfrm_state__bindgen_ty_1))
2747 );
2748 assert_eq!(
2749 unsafe {
2750 &(*(::std::ptr::null::<bpf_xfrm_state__bindgen_ty_1>())).remote_ipv4 as *const _
2751 as usize
2752 },
2753 0usize,
2754 concat!(
2755 "Offset of field: ",
2756 stringify!(bpf_xfrm_state__bindgen_ty_1),
2757 "::",
2758 stringify!(remote_ipv4)
2759 )
2760 );
2761 assert_eq!(
2762 unsafe {
2763 &(*(::std::ptr::null::<bpf_xfrm_state__bindgen_ty_1>())).remote_ipv6 as *const _
2764 as usize
2765 },
2766 0usize,
2767 concat!(
2768 "Offset of field: ",
2769 stringify!(bpf_xfrm_state__bindgen_ty_1),
2770 "::",
2771 stringify!(remote_ipv6)
2772 )
2773 );
2774}
2775impl Default for bpf_xfrm_state__bindgen_ty_1 {
2776 fn default() -> Self {
2777 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2778 unsafe {
2779 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2780 s.assume_init()
2781 }
2782 }
2783}
2784impl ::std::fmt::Debug for bpf_xfrm_state__bindgen_ty_1 {
2785 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2786 write!(f, "bpf_xfrm_state__bindgen_ty_1 {{ union }}")
2787 }
2788}
2789#[test]
2790fn bindgen_test_layout_bpf_xfrm_state() {
2791 assert_eq!(
2792 ::std::mem::size_of::<bpf_xfrm_state>(),
2793 28usize,
2794 concat!("Size of: ", stringify!(bpf_xfrm_state))
2795 );
2796 assert_eq!(
2797 ::std::mem::align_of::<bpf_xfrm_state>(),
2798 4usize,
2799 concat!("Alignment of ", stringify!(bpf_xfrm_state))
2800 );
2801 assert_eq!(
2802 unsafe { &(*(::std::ptr::null::<bpf_xfrm_state>())).reqid as *const _ as usize },
2803 0usize,
2804 concat!(
2805 "Offset of field: ",
2806 stringify!(bpf_xfrm_state),
2807 "::",
2808 stringify!(reqid)
2809 )
2810 );
2811 assert_eq!(
2812 unsafe { &(*(::std::ptr::null::<bpf_xfrm_state>())).spi as *const _ as usize },
2813 4usize,
2814 concat!(
2815 "Offset of field: ",
2816 stringify!(bpf_xfrm_state),
2817 "::",
2818 stringify!(spi)
2819 )
2820 );
2821 assert_eq!(
2822 unsafe { &(*(::std::ptr::null::<bpf_xfrm_state>())).family as *const _ as usize },
2823 8usize,
2824 concat!(
2825 "Offset of field: ",
2826 stringify!(bpf_xfrm_state),
2827 "::",
2828 stringify!(family)
2829 )
2830 );
2831 assert_eq!(
2832 unsafe { &(*(::std::ptr::null::<bpf_xfrm_state>())).ext as *const _ as usize },
2833 10usize,
2834 concat!(
2835 "Offset of field: ",
2836 stringify!(bpf_xfrm_state),
2837 "::",
2838 stringify!(ext)
2839 )
2840 );
2841}
2842impl Default for bpf_xfrm_state {
2843 fn default() -> Self {
2844 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2845 unsafe {
2846 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2847 s.assume_init()
2848 }
2849 }
2850}
2851impl ::std::fmt::Debug for bpf_xfrm_state {
2852 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2853 write ! (f , "bpf_xfrm_state {{ reqid: {:?}, spi: {:?}, family: {:?}, ext: {:?}, __bindgen_anon_1: {:?} }}" , self . reqid , self . spi , self . family , self . ext , self . __bindgen_anon_1)
2854 }
2855}
2856pub const bpf_ret_code_BPF_OK: bpf_ret_code = 0;
2857pub const bpf_ret_code_BPF_DROP: bpf_ret_code = 2;
2858pub const bpf_ret_code_BPF_REDIRECT: bpf_ret_code = 7;
2859pub type bpf_ret_code = ::std::os::raw::c_uint;
2860#[repr(C)]
2861#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2862pub struct bpf_sock {
2863 pub bound_dev_if: __u32,
2864 pub family: __u32,
2865 pub type_: __u32,
2866 pub protocol: __u32,
2867 pub mark: __u32,
2868 pub priority: __u32,
2869 pub src_ip4: __u32,
2870 pub src_ip6: [__u32; 4usize],
2871 pub src_port: __u32,
2872}
2873#[test]
2874fn bindgen_test_layout_bpf_sock() {
2875 assert_eq!(
2876 ::std::mem::size_of::<bpf_sock>(),
2877 48usize,
2878 concat!("Size of: ", stringify!(bpf_sock))
2879 );
2880 assert_eq!(
2881 ::std::mem::align_of::<bpf_sock>(),
2882 4usize,
2883 concat!("Alignment of ", stringify!(bpf_sock))
2884 );
2885 assert_eq!(
2886 unsafe { &(*(::std::ptr::null::<bpf_sock>())).bound_dev_if as *const _ as usize },
2887 0usize,
2888 concat!(
2889 "Offset of field: ",
2890 stringify!(bpf_sock),
2891 "::",
2892 stringify!(bound_dev_if)
2893 )
2894 );
2895 assert_eq!(
2896 unsafe { &(*(::std::ptr::null::<bpf_sock>())).family as *const _ as usize },
2897 4usize,
2898 concat!(
2899 "Offset of field: ",
2900 stringify!(bpf_sock),
2901 "::",
2902 stringify!(family)
2903 )
2904 );
2905 assert_eq!(
2906 unsafe { &(*(::std::ptr::null::<bpf_sock>())).type_ as *const _ as usize },
2907 8usize,
2908 concat!(
2909 "Offset of field: ",
2910 stringify!(bpf_sock),
2911 "::",
2912 stringify!(type_)
2913 )
2914 );
2915 assert_eq!(
2916 unsafe { &(*(::std::ptr::null::<bpf_sock>())).protocol as *const _ as usize },
2917 12usize,
2918 concat!(
2919 "Offset of field: ",
2920 stringify!(bpf_sock),
2921 "::",
2922 stringify!(protocol)
2923 )
2924 );
2925 assert_eq!(
2926 unsafe { &(*(::std::ptr::null::<bpf_sock>())).mark as *const _ as usize },
2927 16usize,
2928 concat!(
2929 "Offset of field: ",
2930 stringify!(bpf_sock),
2931 "::",
2932 stringify!(mark)
2933 )
2934 );
2935 assert_eq!(
2936 unsafe { &(*(::std::ptr::null::<bpf_sock>())).priority as *const _ as usize },
2937 20usize,
2938 concat!(
2939 "Offset of field: ",
2940 stringify!(bpf_sock),
2941 "::",
2942 stringify!(priority)
2943 )
2944 );
2945 assert_eq!(
2946 unsafe { &(*(::std::ptr::null::<bpf_sock>())).src_ip4 as *const _ as usize },
2947 24usize,
2948 concat!(
2949 "Offset of field: ",
2950 stringify!(bpf_sock),
2951 "::",
2952 stringify!(src_ip4)
2953 )
2954 );
2955 assert_eq!(
2956 unsafe { &(*(::std::ptr::null::<bpf_sock>())).src_ip6 as *const _ as usize },
2957 28usize,
2958 concat!(
2959 "Offset of field: ",
2960 stringify!(bpf_sock),
2961 "::",
2962 stringify!(src_ip6)
2963 )
2964 );
2965 assert_eq!(
2966 unsafe { &(*(::std::ptr::null::<bpf_sock>())).src_port as *const _ as usize },
2967 44usize,
2968 concat!(
2969 "Offset of field: ",
2970 stringify!(bpf_sock),
2971 "::",
2972 stringify!(src_port)
2973 )
2974 );
2975}
2976pub const xdp_action_XDP_ABORTED: xdp_action = 0;
2977pub const xdp_action_XDP_DROP: xdp_action = 1;
2978pub const xdp_action_XDP_PASS: xdp_action = 2;
2979pub const xdp_action_XDP_TX: xdp_action = 3;
2980pub const xdp_action_XDP_REDIRECT: xdp_action = 4;
2981pub type xdp_action = ::std::os::raw::c_uint;
2982#[repr(C)]
2983#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2984pub struct xdp_md {
2985 pub data: __u32,
2986 pub data_end: __u32,
2987 pub data_meta: __u32,
2988 pub ingress_ifindex: __u32,
2989 pub rx_queue_index: __u32,
2990}
2991#[test]
2992fn bindgen_test_layout_xdp_md() {
2993 assert_eq!(
2994 ::std::mem::size_of::<xdp_md>(),
2995 20usize,
2996 concat!("Size of: ", stringify!(xdp_md))
2997 );
2998 assert_eq!(
2999 ::std::mem::align_of::<xdp_md>(),
3000 4usize,
3001 concat!("Alignment of ", stringify!(xdp_md))
3002 );
3003 assert_eq!(
3004 unsafe { &(*(::std::ptr::null::<xdp_md>())).data as *const _ as usize },
3005 0usize,
3006 concat!(
3007 "Offset of field: ",
3008 stringify!(xdp_md),
3009 "::",
3010 stringify!(data)
3011 )
3012 );
3013 assert_eq!(
3014 unsafe { &(*(::std::ptr::null::<xdp_md>())).data_end as *const _ as usize },
3015 4usize,
3016 concat!(
3017 "Offset of field: ",
3018 stringify!(xdp_md),
3019 "::",
3020 stringify!(data_end)
3021 )
3022 );
3023 assert_eq!(
3024 unsafe { &(*(::std::ptr::null::<xdp_md>())).data_meta as *const _ as usize },
3025 8usize,
3026 concat!(
3027 "Offset of field: ",
3028 stringify!(xdp_md),
3029 "::",
3030 stringify!(data_meta)
3031 )
3032 );
3033 assert_eq!(
3034 unsafe { &(*(::std::ptr::null::<xdp_md>())).ingress_ifindex as *const _ as usize },
3035 12usize,
3036 concat!(
3037 "Offset of field: ",
3038 stringify!(xdp_md),
3039 "::",
3040 stringify!(ingress_ifindex)
3041 )
3042 );
3043 assert_eq!(
3044 unsafe { &(*(::std::ptr::null::<xdp_md>())).rx_queue_index as *const _ as usize },
3045 16usize,
3046 concat!(
3047 "Offset of field: ",
3048 stringify!(xdp_md),
3049 "::",
3050 stringify!(rx_queue_index)
3051 )
3052 );
3053}
3054pub const sk_action_SK_DROP: sk_action = 0;
3055pub const sk_action_SK_PASS: sk_action = 1;
3056pub type sk_action = ::std::os::raw::c_uint;
3057#[repr(C)]
3058#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3059pub struct bpf_prog_info {
3060 pub type_: __u32,
3061 pub id: __u32,
3062 pub tag: [__u8; 8usize],
3063 pub jited_prog_len: __u32,
3064 pub xlated_prog_len: __u32,
3065 pub jited_prog_insns: __u64,
3066 pub xlated_prog_insns: __u64,
3067 pub load_time: __u64,
3068 pub created_by_uid: __u32,
3069 pub nr_map_ids: __u32,
3070 pub map_ids: __u64,
3071 pub name: [::std::os::raw::c_char; 16usize],
3072 pub ifindex: __u32,
3073 pub _bitfield_align_1: [u8; 0],
3074 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3075 pub netns_dev: __u64,
3076 pub netns_ino: __u64,
3077 pub nr_jited_ksyms: __u32,
3078 pub nr_jited_func_lens: __u32,
3079 pub jited_ksyms: __u64,
3080 pub jited_func_lens: __u64,
3081}
3082#[test]
3083fn bindgen_test_layout_bpf_prog_info() {
3084 assert_eq!(
3085 ::std::mem::size_of::<bpf_prog_info>(),
3086 128usize,
3087 concat!("Size of: ", stringify!(bpf_prog_info))
3088 );
3089 assert_eq!(
3090 ::std::mem::align_of::<bpf_prog_info>(),
3091 8usize,
3092 concat!("Alignment of ", stringify!(bpf_prog_info))
3093 );
3094 assert_eq!(
3095 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).type_ as *const _ as usize },
3096 0usize,
3097 concat!(
3098 "Offset of field: ",
3099 stringify!(bpf_prog_info),
3100 "::",
3101 stringify!(type_)
3102 )
3103 );
3104 assert_eq!(
3105 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).id as *const _ as usize },
3106 4usize,
3107 concat!(
3108 "Offset of field: ",
3109 stringify!(bpf_prog_info),
3110 "::",
3111 stringify!(id)
3112 )
3113 );
3114 assert_eq!(
3115 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).tag as *const _ as usize },
3116 8usize,
3117 concat!(
3118 "Offset of field: ",
3119 stringify!(bpf_prog_info),
3120 "::",
3121 stringify!(tag)
3122 )
3123 );
3124 assert_eq!(
3125 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).jited_prog_len as *const _ as usize },
3126 16usize,
3127 concat!(
3128 "Offset of field: ",
3129 stringify!(bpf_prog_info),
3130 "::",
3131 stringify!(jited_prog_len)
3132 )
3133 );
3134 assert_eq!(
3135 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).xlated_prog_len as *const _ as usize },
3136 20usize,
3137 concat!(
3138 "Offset of field: ",
3139 stringify!(bpf_prog_info),
3140 "::",
3141 stringify!(xlated_prog_len)
3142 )
3143 );
3144 assert_eq!(
3145 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).jited_prog_insns as *const _ as usize },
3146 24usize,
3147 concat!(
3148 "Offset of field: ",
3149 stringify!(bpf_prog_info),
3150 "::",
3151 stringify!(jited_prog_insns)
3152 )
3153 );
3154 assert_eq!(
3155 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).xlated_prog_insns as *const _ as usize },
3156 32usize,
3157 concat!(
3158 "Offset of field: ",
3159 stringify!(bpf_prog_info),
3160 "::",
3161 stringify!(xlated_prog_insns)
3162 )
3163 );
3164 assert_eq!(
3165 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).load_time as *const _ as usize },
3166 40usize,
3167 concat!(
3168 "Offset of field: ",
3169 stringify!(bpf_prog_info),
3170 "::",
3171 stringify!(load_time)
3172 )
3173 );
3174 assert_eq!(
3175 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).created_by_uid as *const _ as usize },
3176 48usize,
3177 concat!(
3178 "Offset of field: ",
3179 stringify!(bpf_prog_info),
3180 "::",
3181 stringify!(created_by_uid)
3182 )
3183 );
3184 assert_eq!(
3185 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).nr_map_ids as *const _ as usize },
3186 52usize,
3187 concat!(
3188 "Offset of field: ",
3189 stringify!(bpf_prog_info),
3190 "::",
3191 stringify!(nr_map_ids)
3192 )
3193 );
3194 assert_eq!(
3195 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).map_ids as *const _ as usize },
3196 56usize,
3197 concat!(
3198 "Offset of field: ",
3199 stringify!(bpf_prog_info),
3200 "::",
3201 stringify!(map_ids)
3202 )
3203 );
3204 assert_eq!(
3205 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).name as *const _ as usize },
3206 64usize,
3207 concat!(
3208 "Offset of field: ",
3209 stringify!(bpf_prog_info),
3210 "::",
3211 stringify!(name)
3212 )
3213 );
3214 assert_eq!(
3215 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).ifindex as *const _ as usize },
3216 80usize,
3217 concat!(
3218 "Offset of field: ",
3219 stringify!(bpf_prog_info),
3220 "::",
3221 stringify!(ifindex)
3222 )
3223 );
3224 assert_eq!(
3225 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).netns_dev as *const _ as usize },
3226 88usize,
3227 concat!(
3228 "Offset of field: ",
3229 stringify!(bpf_prog_info),
3230 "::",
3231 stringify!(netns_dev)
3232 )
3233 );
3234 assert_eq!(
3235 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).netns_ino as *const _ as usize },
3236 96usize,
3237 concat!(
3238 "Offset of field: ",
3239 stringify!(bpf_prog_info),
3240 "::",
3241 stringify!(netns_ino)
3242 )
3243 );
3244 assert_eq!(
3245 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).nr_jited_ksyms as *const _ as usize },
3246 104usize,
3247 concat!(
3248 "Offset of field: ",
3249 stringify!(bpf_prog_info),
3250 "::",
3251 stringify!(nr_jited_ksyms)
3252 )
3253 );
3254 assert_eq!(
3255 unsafe {
3256 &(*(::std::ptr::null::<bpf_prog_info>())).nr_jited_func_lens as *const _ as usize
3257 },
3258 108usize,
3259 concat!(
3260 "Offset of field: ",
3261 stringify!(bpf_prog_info),
3262 "::",
3263 stringify!(nr_jited_func_lens)
3264 )
3265 );
3266 assert_eq!(
3267 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).jited_ksyms as *const _ as usize },
3268 112usize,
3269 concat!(
3270 "Offset of field: ",
3271 stringify!(bpf_prog_info),
3272 "::",
3273 stringify!(jited_ksyms)
3274 )
3275 );
3276 assert_eq!(
3277 unsafe { &(*(::std::ptr::null::<bpf_prog_info>())).jited_func_lens as *const _ as usize },
3278 120usize,
3279 concat!(
3280 "Offset of field: ",
3281 stringify!(bpf_prog_info),
3282 "::",
3283 stringify!(jited_func_lens)
3284 )
3285 );
3286}
3287impl bpf_prog_info {
3288 #[inline]
3289 pub fn gpl_compatible(&self) -> __u32 {
3290 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3291 }
3292 #[inline]
3293 pub fn set_gpl_compatible(&mut self, val: __u32) {
3294 unsafe {
3295 let val: u32 = ::std::mem::transmute(val);
3296 self._bitfield_1.set(0usize, 1u8, val as u64)
3297 }
3298 }
3299 #[inline]
3300 pub fn new_bitfield_1(gpl_compatible: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3301 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3302 __bindgen_bitfield_unit.set(0usize, 1u8, {
3303 let gpl_compatible: u32 = unsafe { ::std::mem::transmute(gpl_compatible) };
3304 gpl_compatible as u64
3305 });
3306 __bindgen_bitfield_unit
3307 }
3308}
3309#[repr(C)]
3310#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3311pub struct bpf_map_info {
3312 pub type_: __u32,
3313 pub id: __u32,
3314 pub key_size: __u32,
3315 pub value_size: __u32,
3316 pub max_entries: __u32,
3317 pub map_flags: __u32,
3318 pub name: [::std::os::raw::c_char; 16usize],
3319 pub ifindex: __u32,
3320 pub _bitfield_align_1: [u8; 0],
3321 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3322 pub netns_dev: __u64,
3323 pub netns_ino: __u64,
3324 pub btf_id: __u32,
3325 pub btf_key_type_id: __u32,
3326 pub btf_value_type_id: __u32,
3327}
3328#[test]
3329fn bindgen_test_layout_bpf_map_info() {
3330 assert_eq!(
3331 ::std::mem::size_of::<bpf_map_info>(),
3332 80usize,
3333 concat!("Size of: ", stringify!(bpf_map_info))
3334 );
3335 assert_eq!(
3336 ::std::mem::align_of::<bpf_map_info>(),
3337 8usize,
3338 concat!("Alignment of ", stringify!(bpf_map_info))
3339 );
3340 assert_eq!(
3341 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).type_ as *const _ as usize },
3342 0usize,
3343 concat!(
3344 "Offset of field: ",
3345 stringify!(bpf_map_info),
3346 "::",
3347 stringify!(type_)
3348 )
3349 );
3350 assert_eq!(
3351 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).id as *const _ as usize },
3352 4usize,
3353 concat!(
3354 "Offset of field: ",
3355 stringify!(bpf_map_info),
3356 "::",
3357 stringify!(id)
3358 )
3359 );
3360 assert_eq!(
3361 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).key_size as *const _ as usize },
3362 8usize,
3363 concat!(
3364 "Offset of field: ",
3365 stringify!(bpf_map_info),
3366 "::",
3367 stringify!(key_size)
3368 )
3369 );
3370 assert_eq!(
3371 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).value_size as *const _ as usize },
3372 12usize,
3373 concat!(
3374 "Offset of field: ",
3375 stringify!(bpf_map_info),
3376 "::",
3377 stringify!(value_size)
3378 )
3379 );
3380 assert_eq!(
3381 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).max_entries as *const _ as usize },
3382 16usize,
3383 concat!(
3384 "Offset of field: ",
3385 stringify!(bpf_map_info),
3386 "::",
3387 stringify!(max_entries)
3388 )
3389 );
3390 assert_eq!(
3391 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).map_flags as *const _ as usize },
3392 20usize,
3393 concat!(
3394 "Offset of field: ",
3395 stringify!(bpf_map_info),
3396 "::",
3397 stringify!(map_flags)
3398 )
3399 );
3400 assert_eq!(
3401 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).name as *const _ as usize },
3402 24usize,
3403 concat!(
3404 "Offset of field: ",
3405 stringify!(bpf_map_info),
3406 "::",
3407 stringify!(name)
3408 )
3409 );
3410 assert_eq!(
3411 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).ifindex as *const _ as usize },
3412 40usize,
3413 concat!(
3414 "Offset of field: ",
3415 stringify!(bpf_map_info),
3416 "::",
3417 stringify!(ifindex)
3418 )
3419 );
3420 assert_eq!(
3421 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).netns_dev as *const _ as usize },
3422 48usize,
3423 concat!(
3424 "Offset of field: ",
3425 stringify!(bpf_map_info),
3426 "::",
3427 stringify!(netns_dev)
3428 )
3429 );
3430 assert_eq!(
3431 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).netns_ino as *const _ as usize },
3432 56usize,
3433 concat!(
3434 "Offset of field: ",
3435 stringify!(bpf_map_info),
3436 "::",
3437 stringify!(netns_ino)
3438 )
3439 );
3440 assert_eq!(
3441 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).btf_id as *const _ as usize },
3442 64usize,
3443 concat!(
3444 "Offset of field: ",
3445 stringify!(bpf_map_info),
3446 "::",
3447 stringify!(btf_id)
3448 )
3449 );
3450 assert_eq!(
3451 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).btf_key_type_id as *const _ as usize },
3452 68usize,
3453 concat!(
3454 "Offset of field: ",
3455 stringify!(bpf_map_info),
3456 "::",
3457 stringify!(btf_key_type_id)
3458 )
3459 );
3460 assert_eq!(
3461 unsafe { &(*(::std::ptr::null::<bpf_map_info>())).btf_value_type_id as *const _ as usize },
3462 72usize,
3463 concat!(
3464 "Offset of field: ",
3465 stringify!(bpf_map_info),
3466 "::",
3467 stringify!(btf_value_type_id)
3468 )
3469 );
3470}
3471impl bpf_map_info {
3472 #[inline]
3473 pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 4usize]> {
3474 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3475 __bindgen_bitfield_unit
3476 }
3477}
3478#[repr(C)]
3479#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3480pub struct bpf_btf_info {
3481 pub btf: __u64,
3482 pub btf_size: __u32,
3483 pub id: __u32,
3484}
3485#[test]
3486fn bindgen_test_layout_bpf_btf_info() {
3487 assert_eq!(
3488 ::std::mem::size_of::<bpf_btf_info>(),
3489 16usize,
3490 concat!("Size of: ", stringify!(bpf_btf_info))
3491 );
3492 assert_eq!(
3493 ::std::mem::align_of::<bpf_btf_info>(),
3494 8usize,
3495 concat!("Alignment of ", stringify!(bpf_btf_info))
3496 );
3497 assert_eq!(
3498 unsafe { &(*(::std::ptr::null::<bpf_btf_info>())).btf as *const _ as usize },
3499 0usize,
3500 concat!(
3501 "Offset of field: ",
3502 stringify!(bpf_btf_info),
3503 "::",
3504 stringify!(btf)
3505 )
3506 );
3507 assert_eq!(
3508 unsafe { &(*(::std::ptr::null::<bpf_btf_info>())).btf_size as *const _ as usize },
3509 8usize,
3510 concat!(
3511 "Offset of field: ",
3512 stringify!(bpf_btf_info),
3513 "::",
3514 stringify!(btf_size)
3515 )
3516 );
3517 assert_eq!(
3518 unsafe { &(*(::std::ptr::null::<bpf_btf_info>())).id as *const _ as usize },
3519 12usize,
3520 concat!(
3521 "Offset of field: ",
3522 stringify!(bpf_btf_info),
3523 "::",
3524 stringify!(id)
3525 )
3526 );
3527}
3528#[repr(C)]
3529#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3530pub struct bpf_sock_addr {
3531 pub user_family: __u32,
3532 pub user_ip4: __u32,
3533 pub user_ip6: [__u32; 4usize],
3534 pub user_port: __u32,
3535 pub family: __u32,
3536 pub type_: __u32,
3537 pub protocol: __u32,
3538 pub msg_src_ip4: __u32,
3539 pub msg_src_ip6: [__u32; 4usize],
3540}
3541#[test]
3542fn bindgen_test_layout_bpf_sock_addr() {
3543 assert_eq!(
3544 ::std::mem::size_of::<bpf_sock_addr>(),
3545 60usize,
3546 concat!("Size of: ", stringify!(bpf_sock_addr))
3547 );
3548 assert_eq!(
3549 ::std::mem::align_of::<bpf_sock_addr>(),
3550 4usize,
3551 concat!("Alignment of ", stringify!(bpf_sock_addr))
3552 );
3553 assert_eq!(
3554 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).user_family as *const _ as usize },
3555 0usize,
3556 concat!(
3557 "Offset of field: ",
3558 stringify!(bpf_sock_addr),
3559 "::",
3560 stringify!(user_family)
3561 )
3562 );
3563 assert_eq!(
3564 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).user_ip4 as *const _ as usize },
3565 4usize,
3566 concat!(
3567 "Offset of field: ",
3568 stringify!(bpf_sock_addr),
3569 "::",
3570 stringify!(user_ip4)
3571 )
3572 );
3573 assert_eq!(
3574 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).user_ip6 as *const _ as usize },
3575 8usize,
3576 concat!(
3577 "Offset of field: ",
3578 stringify!(bpf_sock_addr),
3579 "::",
3580 stringify!(user_ip6)
3581 )
3582 );
3583 assert_eq!(
3584 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).user_port as *const _ as usize },
3585 24usize,
3586 concat!(
3587 "Offset of field: ",
3588 stringify!(bpf_sock_addr),
3589 "::",
3590 stringify!(user_port)
3591 )
3592 );
3593 assert_eq!(
3594 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).family as *const _ as usize },
3595 28usize,
3596 concat!(
3597 "Offset of field: ",
3598 stringify!(bpf_sock_addr),
3599 "::",
3600 stringify!(family)
3601 )
3602 );
3603 assert_eq!(
3604 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).type_ as *const _ as usize },
3605 32usize,
3606 concat!(
3607 "Offset of field: ",
3608 stringify!(bpf_sock_addr),
3609 "::",
3610 stringify!(type_)
3611 )
3612 );
3613 assert_eq!(
3614 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).protocol as *const _ as usize },
3615 36usize,
3616 concat!(
3617 "Offset of field: ",
3618 stringify!(bpf_sock_addr),
3619 "::",
3620 stringify!(protocol)
3621 )
3622 );
3623 assert_eq!(
3624 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).msg_src_ip4 as *const _ as usize },
3625 40usize,
3626 concat!(
3627 "Offset of field: ",
3628 stringify!(bpf_sock_addr),
3629 "::",
3630 stringify!(msg_src_ip4)
3631 )
3632 );
3633 assert_eq!(
3634 unsafe { &(*(::std::ptr::null::<bpf_sock_addr>())).msg_src_ip6 as *const _ as usize },
3635 44usize,
3636 concat!(
3637 "Offset of field: ",
3638 stringify!(bpf_sock_addr),
3639 "::",
3640 stringify!(msg_src_ip6)
3641 )
3642 );
3643}
3644#[repr(C)]
3645#[derive(Copy, Clone)]
3646pub struct bpf_sock_ops {
3647 pub op: __u32,
3648 pub __bindgen_anon_1: bpf_sock_ops__bindgen_ty_1,
3649 pub family: __u32,
3650 pub remote_ip4: __u32,
3651 pub local_ip4: __u32,
3652 pub remote_ip6: [__u32; 4usize],
3653 pub local_ip6: [__u32; 4usize],
3654 pub remote_port: __u32,
3655 pub local_port: __u32,
3656 pub is_fullsock: __u32,
3657 pub snd_cwnd: __u32,
3658 pub srtt_us: __u32,
3659 pub bpf_sock_ops_cb_flags: __u32,
3660 pub state: __u32,
3661 pub rtt_min: __u32,
3662 pub snd_ssthresh: __u32,
3663 pub rcv_nxt: __u32,
3664 pub snd_nxt: __u32,
3665 pub snd_una: __u32,
3666 pub mss_cache: __u32,
3667 pub ecn_flags: __u32,
3668 pub rate_delivered: __u32,
3669 pub rate_interval_us: __u32,
3670 pub packets_out: __u32,
3671 pub retrans_out: __u32,
3672 pub total_retrans: __u32,
3673 pub segs_in: __u32,
3674 pub data_segs_in: __u32,
3675 pub segs_out: __u32,
3676 pub data_segs_out: __u32,
3677 pub lost_out: __u32,
3678 pub sacked_out: __u32,
3679 pub sk_txhash: __u32,
3680 pub bytes_received: __u64,
3681 pub bytes_acked: __u64,
3682}
3683#[repr(C)]
3684#[derive(Copy, Clone)]
3685pub union bpf_sock_ops__bindgen_ty_1 {
3686 pub args: [__u32; 4usize],
3687 pub reply: __u32,
3688 pub replylong: [__u32; 4usize],
3689}
3690#[test]
3691fn bindgen_test_layout_bpf_sock_ops__bindgen_ty_1() {
3692 assert_eq!(
3693 ::std::mem::size_of::<bpf_sock_ops__bindgen_ty_1>(),
3694 16usize,
3695 concat!("Size of: ", stringify!(bpf_sock_ops__bindgen_ty_1))
3696 );
3697 assert_eq!(
3698 ::std::mem::align_of::<bpf_sock_ops__bindgen_ty_1>(),
3699 4usize,
3700 concat!("Alignment of ", stringify!(bpf_sock_ops__bindgen_ty_1))
3701 );
3702 assert_eq!(
3703 unsafe { &(*(::std::ptr::null::<bpf_sock_ops__bindgen_ty_1>())).args as *const _ as usize },
3704 0usize,
3705 concat!(
3706 "Offset of field: ",
3707 stringify!(bpf_sock_ops__bindgen_ty_1),
3708 "::",
3709 stringify!(args)
3710 )
3711 );
3712 assert_eq!(
3713 unsafe {
3714 &(*(::std::ptr::null::<bpf_sock_ops__bindgen_ty_1>())).reply as *const _ as usize
3715 },
3716 0usize,
3717 concat!(
3718 "Offset of field: ",
3719 stringify!(bpf_sock_ops__bindgen_ty_1),
3720 "::",
3721 stringify!(reply)
3722 )
3723 );
3724 assert_eq!(
3725 unsafe {
3726 &(*(::std::ptr::null::<bpf_sock_ops__bindgen_ty_1>())).replylong as *const _ as usize
3727 },
3728 0usize,
3729 concat!(
3730 "Offset of field: ",
3731 stringify!(bpf_sock_ops__bindgen_ty_1),
3732 "::",
3733 stringify!(replylong)
3734 )
3735 );
3736}
3737impl Default for bpf_sock_ops__bindgen_ty_1 {
3738 fn default() -> Self {
3739 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3740 unsafe {
3741 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3742 s.assume_init()
3743 }
3744 }
3745}
3746impl ::std::fmt::Debug for bpf_sock_ops__bindgen_ty_1 {
3747 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3748 write!(f, "bpf_sock_ops__bindgen_ty_1 {{ union }}")
3749 }
3750}
3751#[test]
3752fn bindgen_test_layout_bpf_sock_ops() {
3753 assert_eq!(
3754 ::std::mem::size_of::<bpf_sock_ops>(),
3755 184usize,
3756 concat!("Size of: ", stringify!(bpf_sock_ops))
3757 );
3758 assert_eq!(
3759 ::std::mem::align_of::<bpf_sock_ops>(),
3760 8usize,
3761 concat!("Alignment of ", stringify!(bpf_sock_ops))
3762 );
3763 assert_eq!(
3764 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).op as *const _ as usize },
3765 0usize,
3766 concat!(
3767 "Offset of field: ",
3768 stringify!(bpf_sock_ops),
3769 "::",
3770 stringify!(op)
3771 )
3772 );
3773 assert_eq!(
3774 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).family as *const _ as usize },
3775 20usize,
3776 concat!(
3777 "Offset of field: ",
3778 stringify!(bpf_sock_ops),
3779 "::",
3780 stringify!(family)
3781 )
3782 );
3783 assert_eq!(
3784 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).remote_ip4 as *const _ as usize },
3785 24usize,
3786 concat!(
3787 "Offset of field: ",
3788 stringify!(bpf_sock_ops),
3789 "::",
3790 stringify!(remote_ip4)
3791 )
3792 );
3793 assert_eq!(
3794 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).local_ip4 as *const _ as usize },
3795 28usize,
3796 concat!(
3797 "Offset of field: ",
3798 stringify!(bpf_sock_ops),
3799 "::",
3800 stringify!(local_ip4)
3801 )
3802 );
3803 assert_eq!(
3804 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).remote_ip6 as *const _ as usize },
3805 32usize,
3806 concat!(
3807 "Offset of field: ",
3808 stringify!(bpf_sock_ops),
3809 "::",
3810 stringify!(remote_ip6)
3811 )
3812 );
3813 assert_eq!(
3814 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).local_ip6 as *const _ as usize },
3815 48usize,
3816 concat!(
3817 "Offset of field: ",
3818 stringify!(bpf_sock_ops),
3819 "::",
3820 stringify!(local_ip6)
3821 )
3822 );
3823 assert_eq!(
3824 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).remote_port as *const _ as usize },
3825 64usize,
3826 concat!(
3827 "Offset of field: ",
3828 stringify!(bpf_sock_ops),
3829 "::",
3830 stringify!(remote_port)
3831 )
3832 );
3833 assert_eq!(
3834 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).local_port as *const _ as usize },
3835 68usize,
3836 concat!(
3837 "Offset of field: ",
3838 stringify!(bpf_sock_ops),
3839 "::",
3840 stringify!(local_port)
3841 )
3842 );
3843 assert_eq!(
3844 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).is_fullsock as *const _ as usize },
3845 72usize,
3846 concat!(
3847 "Offset of field: ",
3848 stringify!(bpf_sock_ops),
3849 "::",
3850 stringify!(is_fullsock)
3851 )
3852 );
3853 assert_eq!(
3854 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).snd_cwnd as *const _ as usize },
3855 76usize,
3856 concat!(
3857 "Offset of field: ",
3858 stringify!(bpf_sock_ops),
3859 "::",
3860 stringify!(snd_cwnd)
3861 )
3862 );
3863 assert_eq!(
3864 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).srtt_us as *const _ as usize },
3865 80usize,
3866 concat!(
3867 "Offset of field: ",
3868 stringify!(bpf_sock_ops),
3869 "::",
3870 stringify!(srtt_us)
3871 )
3872 );
3873 assert_eq!(
3874 unsafe {
3875 &(*(::std::ptr::null::<bpf_sock_ops>())).bpf_sock_ops_cb_flags as *const _ as usize
3876 },
3877 84usize,
3878 concat!(
3879 "Offset of field: ",
3880 stringify!(bpf_sock_ops),
3881 "::",
3882 stringify!(bpf_sock_ops_cb_flags)
3883 )
3884 );
3885 assert_eq!(
3886 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).state as *const _ as usize },
3887 88usize,
3888 concat!(
3889 "Offset of field: ",
3890 stringify!(bpf_sock_ops),
3891 "::",
3892 stringify!(state)
3893 )
3894 );
3895 assert_eq!(
3896 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).rtt_min as *const _ as usize },
3897 92usize,
3898 concat!(
3899 "Offset of field: ",
3900 stringify!(bpf_sock_ops),
3901 "::",
3902 stringify!(rtt_min)
3903 )
3904 );
3905 assert_eq!(
3906 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).snd_ssthresh as *const _ as usize },
3907 96usize,
3908 concat!(
3909 "Offset of field: ",
3910 stringify!(bpf_sock_ops),
3911 "::",
3912 stringify!(snd_ssthresh)
3913 )
3914 );
3915 assert_eq!(
3916 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).rcv_nxt as *const _ as usize },
3917 100usize,
3918 concat!(
3919 "Offset of field: ",
3920 stringify!(bpf_sock_ops),
3921 "::",
3922 stringify!(rcv_nxt)
3923 )
3924 );
3925 assert_eq!(
3926 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).snd_nxt as *const _ as usize },
3927 104usize,
3928 concat!(
3929 "Offset of field: ",
3930 stringify!(bpf_sock_ops),
3931 "::",
3932 stringify!(snd_nxt)
3933 )
3934 );
3935 assert_eq!(
3936 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).snd_una as *const _ as usize },
3937 108usize,
3938 concat!(
3939 "Offset of field: ",
3940 stringify!(bpf_sock_ops),
3941 "::",
3942 stringify!(snd_una)
3943 )
3944 );
3945 assert_eq!(
3946 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).mss_cache as *const _ as usize },
3947 112usize,
3948 concat!(
3949 "Offset of field: ",
3950 stringify!(bpf_sock_ops),
3951 "::",
3952 stringify!(mss_cache)
3953 )
3954 );
3955 assert_eq!(
3956 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).ecn_flags as *const _ as usize },
3957 116usize,
3958 concat!(
3959 "Offset of field: ",
3960 stringify!(bpf_sock_ops),
3961 "::",
3962 stringify!(ecn_flags)
3963 )
3964 );
3965 assert_eq!(
3966 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).rate_delivered as *const _ as usize },
3967 120usize,
3968 concat!(
3969 "Offset of field: ",
3970 stringify!(bpf_sock_ops),
3971 "::",
3972 stringify!(rate_delivered)
3973 )
3974 );
3975 assert_eq!(
3976 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).rate_interval_us as *const _ as usize },
3977 124usize,
3978 concat!(
3979 "Offset of field: ",
3980 stringify!(bpf_sock_ops),
3981 "::",
3982 stringify!(rate_interval_us)
3983 )
3984 );
3985 assert_eq!(
3986 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).packets_out as *const _ as usize },
3987 128usize,
3988 concat!(
3989 "Offset of field: ",
3990 stringify!(bpf_sock_ops),
3991 "::",
3992 stringify!(packets_out)
3993 )
3994 );
3995 assert_eq!(
3996 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).retrans_out as *const _ as usize },
3997 132usize,
3998 concat!(
3999 "Offset of field: ",
4000 stringify!(bpf_sock_ops),
4001 "::",
4002 stringify!(retrans_out)
4003 )
4004 );
4005 assert_eq!(
4006 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).total_retrans as *const _ as usize },
4007 136usize,
4008 concat!(
4009 "Offset of field: ",
4010 stringify!(bpf_sock_ops),
4011 "::",
4012 stringify!(total_retrans)
4013 )
4014 );
4015 assert_eq!(
4016 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).segs_in as *const _ as usize },
4017 140usize,
4018 concat!(
4019 "Offset of field: ",
4020 stringify!(bpf_sock_ops),
4021 "::",
4022 stringify!(segs_in)
4023 )
4024 );
4025 assert_eq!(
4026 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).data_segs_in as *const _ as usize },
4027 144usize,
4028 concat!(
4029 "Offset of field: ",
4030 stringify!(bpf_sock_ops),
4031 "::",
4032 stringify!(data_segs_in)
4033 )
4034 );
4035 assert_eq!(
4036 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).segs_out as *const _ as usize },
4037 148usize,
4038 concat!(
4039 "Offset of field: ",
4040 stringify!(bpf_sock_ops),
4041 "::",
4042 stringify!(segs_out)
4043 )
4044 );
4045 assert_eq!(
4046 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).data_segs_out as *const _ as usize },
4047 152usize,
4048 concat!(
4049 "Offset of field: ",
4050 stringify!(bpf_sock_ops),
4051 "::",
4052 stringify!(data_segs_out)
4053 )
4054 );
4055 assert_eq!(
4056 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).lost_out as *const _ as usize },
4057 156usize,
4058 concat!(
4059 "Offset of field: ",
4060 stringify!(bpf_sock_ops),
4061 "::",
4062 stringify!(lost_out)
4063 )
4064 );
4065 assert_eq!(
4066 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).sacked_out as *const _ as usize },
4067 160usize,
4068 concat!(
4069 "Offset of field: ",
4070 stringify!(bpf_sock_ops),
4071 "::",
4072 stringify!(sacked_out)
4073 )
4074 );
4075 assert_eq!(
4076 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).sk_txhash as *const _ as usize },
4077 164usize,
4078 concat!(
4079 "Offset of field: ",
4080 stringify!(bpf_sock_ops),
4081 "::",
4082 stringify!(sk_txhash)
4083 )
4084 );
4085 assert_eq!(
4086 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).bytes_received as *const _ as usize },
4087 168usize,
4088 concat!(
4089 "Offset of field: ",
4090 stringify!(bpf_sock_ops),
4091 "::",
4092 stringify!(bytes_received)
4093 )
4094 );
4095 assert_eq!(
4096 unsafe { &(*(::std::ptr::null::<bpf_sock_ops>())).bytes_acked as *const _ as usize },
4097 176usize,
4098 concat!(
4099 "Offset of field: ",
4100 stringify!(bpf_sock_ops),
4101 "::",
4102 stringify!(bytes_acked)
4103 )
4104 );
4105}
4106impl Default for bpf_sock_ops {
4107 fn default() -> Self {
4108 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4109 unsafe {
4110 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4111 s.assume_init()
4112 }
4113 }
4114}
4115impl ::std::fmt::Debug for bpf_sock_ops {
4116 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4117 write ! (f , "bpf_sock_ops {{ op: {:?}, __bindgen_anon_1: {:?}, family: {:?}, remote_ip4: {:?}, local_ip4: {:?}, remote_ip6: {:?}, local_ip6: {:?}, remote_port: {:?}, local_port: {:?}, is_fullsock: {:?}, snd_cwnd: {:?}, srtt_us: {:?}, bpf_sock_ops_cb_flags: {:?}, state: {:?}, rtt_min: {:?}, snd_ssthresh: {:?}, rcv_nxt: {:?}, snd_nxt: {:?}, snd_una: {:?}, mss_cache: {:?}, ecn_flags: {:?}, rate_delivered: {:?}, rate_interval_us: {:?}, packets_out: {:?}, retrans_out: {:?}, total_retrans: {:?}, segs_in: {:?}, data_segs_in: {:?}, segs_out: {:?}, data_segs_out: {:?}, lost_out: {:?}, sacked_out: {:?}, sk_txhash: {:?}, bytes_received: {:?}, bytes_acked: {:?} }}" , self . op , self . __bindgen_anon_1 , self . family , self . remote_ip4 , self . local_ip4 , self . remote_ip6 , self . local_ip6 , self . remote_port , self . local_port , self . is_fullsock , self . snd_cwnd , self . srtt_us , self . bpf_sock_ops_cb_flags , self . state , self . rtt_min , self . snd_ssthresh , self . rcv_nxt , self . snd_nxt , self . snd_una , self . mss_cache , self . ecn_flags , self . rate_delivered , self . rate_interval_us , self . packets_out , self . retrans_out , self . total_retrans , self . segs_in , self . data_segs_in , self . segs_out , self . data_segs_out , self . lost_out , self . sacked_out , self . sk_txhash , self . bytes_received , self . bytes_acked)
4118 }
4119}
4120pub const BPF_SOCK_OPS_VOID: ::std::os::raw::c_uint = 0;
4121pub const BPF_SOCK_OPS_TIMEOUT_INIT: ::std::os::raw::c_uint = 1;
4122pub const BPF_SOCK_OPS_RWND_INIT: ::std::os::raw::c_uint = 2;
4123pub const BPF_SOCK_OPS_TCP_CONNECT_CB: ::std::os::raw::c_uint = 3;
4124pub const BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB: ::std::os::raw::c_uint = 4;
4125pub const BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB: ::std::os::raw::c_uint = 5;
4126pub const BPF_SOCK_OPS_NEEDS_ECN: ::std::os::raw::c_uint = 6;
4127pub const BPF_SOCK_OPS_BASE_RTT: ::std::os::raw::c_uint = 7;
4128pub const BPF_SOCK_OPS_RTO_CB: ::std::os::raw::c_uint = 8;
4129pub const BPF_SOCK_OPS_RETRANS_CB: ::std::os::raw::c_uint = 9;
4130pub const BPF_SOCK_OPS_STATE_CB: ::std::os::raw::c_uint = 10;
4131pub const BPF_SOCK_OPS_TCP_LISTEN_CB: ::std::os::raw::c_uint = 11;
4132pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
4133pub const BPF_TCP_ESTABLISHED: ::std::os::raw::c_uint = 1;
4134pub const BPF_TCP_SYN_SENT: ::std::os::raw::c_uint = 2;
4135pub const BPF_TCP_SYN_RECV: ::std::os::raw::c_uint = 3;
4136pub const BPF_TCP_FIN_WAIT1: ::std::os::raw::c_uint = 4;
4137pub const BPF_TCP_FIN_WAIT2: ::std::os::raw::c_uint = 5;
4138pub const BPF_TCP_TIME_WAIT: ::std::os::raw::c_uint = 6;
4139pub const BPF_TCP_CLOSE: ::std::os::raw::c_uint = 7;
4140pub const BPF_TCP_CLOSE_WAIT: ::std::os::raw::c_uint = 8;
4141pub const BPF_TCP_LAST_ACK: ::std::os::raw::c_uint = 9;
4142pub const BPF_TCP_LISTEN: ::std::os::raw::c_uint = 10;
4143pub const BPF_TCP_CLOSING: ::std::os::raw::c_uint = 11;
4144pub const BPF_TCP_NEW_SYN_RECV: ::std::os::raw::c_uint = 12;
4145pub const BPF_TCP_MAX_STATES: ::std::os::raw::c_uint = 13;
4146pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
4147#[repr(C)]
4148#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4149pub struct bpf_perf_event_value {
4150 pub counter: __u64,
4151 pub enabled: __u64,
4152 pub running: __u64,
4153}
4154#[test]
4155fn bindgen_test_layout_bpf_perf_event_value() {
4156 assert_eq!(
4157 ::std::mem::size_of::<bpf_perf_event_value>(),
4158 24usize,
4159 concat!("Size of: ", stringify!(bpf_perf_event_value))
4160 );
4161 assert_eq!(
4162 ::std::mem::align_of::<bpf_perf_event_value>(),
4163 8usize,
4164 concat!("Alignment of ", stringify!(bpf_perf_event_value))
4165 );
4166 assert_eq!(
4167 unsafe { &(*(::std::ptr::null::<bpf_perf_event_value>())).counter as *const _ as usize },
4168 0usize,
4169 concat!(
4170 "Offset of field: ",
4171 stringify!(bpf_perf_event_value),
4172 "::",
4173 stringify!(counter)
4174 )
4175 );
4176 assert_eq!(
4177 unsafe { &(*(::std::ptr::null::<bpf_perf_event_value>())).enabled as *const _ as usize },
4178 8usize,
4179 concat!(
4180 "Offset of field: ",
4181 stringify!(bpf_perf_event_value),
4182 "::",
4183 stringify!(enabled)
4184 )
4185 );
4186 assert_eq!(
4187 unsafe { &(*(::std::ptr::null::<bpf_perf_event_value>())).running as *const _ as usize },
4188 16usize,
4189 concat!(
4190 "Offset of field: ",
4191 stringify!(bpf_perf_event_value),
4192 "::",
4193 stringify!(running)
4194 )
4195 );
4196}
4197#[repr(C)]
4198#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4199pub struct bpf_cgroup_dev_ctx {
4200 pub access_type: __u32,
4201 pub major: __u32,
4202 pub minor: __u32,
4203}
4204#[test]
4205fn bindgen_test_layout_bpf_cgroup_dev_ctx() {
4206 assert_eq!(
4207 ::std::mem::size_of::<bpf_cgroup_dev_ctx>(),
4208 12usize,
4209 concat!("Size of: ", stringify!(bpf_cgroup_dev_ctx))
4210 );
4211 assert_eq!(
4212 ::std::mem::align_of::<bpf_cgroup_dev_ctx>(),
4213 4usize,
4214 concat!("Alignment of ", stringify!(bpf_cgroup_dev_ctx))
4215 );
4216 assert_eq!(
4217 unsafe { &(*(::std::ptr::null::<bpf_cgroup_dev_ctx>())).access_type as *const _ as usize },
4218 0usize,
4219 concat!(
4220 "Offset of field: ",
4221 stringify!(bpf_cgroup_dev_ctx),
4222 "::",
4223 stringify!(access_type)
4224 )
4225 );
4226 assert_eq!(
4227 unsafe { &(*(::std::ptr::null::<bpf_cgroup_dev_ctx>())).major as *const _ as usize },
4228 4usize,
4229 concat!(
4230 "Offset of field: ",
4231 stringify!(bpf_cgroup_dev_ctx),
4232 "::",
4233 stringify!(major)
4234 )
4235 );
4236 assert_eq!(
4237 unsafe { &(*(::std::ptr::null::<bpf_cgroup_dev_ctx>())).minor as *const _ as usize },
4238 8usize,
4239 concat!(
4240 "Offset of field: ",
4241 stringify!(bpf_cgroup_dev_ctx),
4242 "::",
4243 stringify!(minor)
4244 )
4245 );
4246}
4247pub const BPF_FIB_LKUP_RET_SUCCESS: ::std::os::raw::c_uint = 0;
4248pub const BPF_FIB_LKUP_RET_BLACKHOLE: ::std::os::raw::c_uint = 1;
4249pub const BPF_FIB_LKUP_RET_UNREACHABLE: ::std::os::raw::c_uint = 2;
4250pub const BPF_FIB_LKUP_RET_PROHIBIT: ::std::os::raw::c_uint = 3;
4251pub const BPF_FIB_LKUP_RET_NOT_FWDED: ::std::os::raw::c_uint = 4;
4252pub const BPF_FIB_LKUP_RET_FWD_DISABLED: ::std::os::raw::c_uint = 5;
4253pub const BPF_FIB_LKUP_RET_UNSUPP_LWT: ::std::os::raw::c_uint = 6;
4254pub const BPF_FIB_LKUP_RET_NO_NEIGH: ::std::os::raw::c_uint = 7;
4255pub const BPF_FIB_LKUP_RET_FRAG_NEEDED: ::std::os::raw::c_uint = 8;
4256pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
4257#[repr(C)]
4258#[derive(Copy, Clone)]
4259pub struct bpf_fib_lookup {
4260 pub family: __u8,
4261 pub l4_protocol: __u8,
4262 pub sport: __be16,
4263 pub dport: __be16,
4264 pub tot_len: __u16,
4265 pub ifindex: __u32,
4266 pub __bindgen_anon_1: bpf_fib_lookup__bindgen_ty_1,
4267 pub __bindgen_anon_2: bpf_fib_lookup__bindgen_ty_2,
4268 pub __bindgen_anon_3: bpf_fib_lookup__bindgen_ty_3,
4269 pub h_vlan_proto: __be16,
4270 pub h_vlan_TCI: __be16,
4271 pub smac: [__u8; 6usize],
4272 pub dmac: [__u8; 6usize],
4273}
4274#[repr(C)]
4275#[derive(Copy, Clone)]
4276pub union bpf_fib_lookup__bindgen_ty_1 {
4277 pub tos: __u8,
4278 pub flowinfo: __be32,
4279 pub rt_metric: __u32,
4280}
4281#[test]
4282fn bindgen_test_layout_bpf_fib_lookup__bindgen_ty_1() {
4283 assert_eq!(
4284 ::std::mem::size_of::<bpf_fib_lookup__bindgen_ty_1>(),
4285 4usize,
4286 concat!("Size of: ", stringify!(bpf_fib_lookup__bindgen_ty_1))
4287 );
4288 assert_eq!(
4289 ::std::mem::align_of::<bpf_fib_lookup__bindgen_ty_1>(),
4290 4usize,
4291 concat!("Alignment of ", stringify!(bpf_fib_lookup__bindgen_ty_1))
4292 );
4293 assert_eq!(
4294 unsafe {
4295 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_1>())).tos as *const _ as usize
4296 },
4297 0usize,
4298 concat!(
4299 "Offset of field: ",
4300 stringify!(bpf_fib_lookup__bindgen_ty_1),
4301 "::",
4302 stringify!(tos)
4303 )
4304 );
4305 assert_eq!(
4306 unsafe {
4307 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_1>())).flowinfo as *const _ as usize
4308 },
4309 0usize,
4310 concat!(
4311 "Offset of field: ",
4312 stringify!(bpf_fib_lookup__bindgen_ty_1),
4313 "::",
4314 stringify!(flowinfo)
4315 )
4316 );
4317 assert_eq!(
4318 unsafe {
4319 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_1>())).rt_metric as *const _ as usize
4320 },
4321 0usize,
4322 concat!(
4323 "Offset of field: ",
4324 stringify!(bpf_fib_lookup__bindgen_ty_1),
4325 "::",
4326 stringify!(rt_metric)
4327 )
4328 );
4329}
4330impl Default for bpf_fib_lookup__bindgen_ty_1 {
4331 fn default() -> Self {
4332 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4333 unsafe {
4334 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4335 s.assume_init()
4336 }
4337 }
4338}
4339impl ::std::fmt::Debug for bpf_fib_lookup__bindgen_ty_1 {
4340 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4341 write!(f, "bpf_fib_lookup__bindgen_ty_1 {{ union }}")
4342 }
4343}
4344#[repr(C)]
4345#[derive(Copy, Clone)]
4346pub union bpf_fib_lookup__bindgen_ty_2 {
4347 pub ipv4_src: __be32,
4348 pub ipv6_src: [__u32; 4usize],
4349}
4350#[test]
4351fn bindgen_test_layout_bpf_fib_lookup__bindgen_ty_2() {
4352 assert_eq!(
4353 ::std::mem::size_of::<bpf_fib_lookup__bindgen_ty_2>(),
4354 16usize,
4355 concat!("Size of: ", stringify!(bpf_fib_lookup__bindgen_ty_2))
4356 );
4357 assert_eq!(
4358 ::std::mem::align_of::<bpf_fib_lookup__bindgen_ty_2>(),
4359 4usize,
4360 concat!("Alignment of ", stringify!(bpf_fib_lookup__bindgen_ty_2))
4361 );
4362 assert_eq!(
4363 unsafe {
4364 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_2>())).ipv4_src as *const _ as usize
4365 },
4366 0usize,
4367 concat!(
4368 "Offset of field: ",
4369 stringify!(bpf_fib_lookup__bindgen_ty_2),
4370 "::",
4371 stringify!(ipv4_src)
4372 )
4373 );
4374 assert_eq!(
4375 unsafe {
4376 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_2>())).ipv6_src as *const _ as usize
4377 },
4378 0usize,
4379 concat!(
4380 "Offset of field: ",
4381 stringify!(bpf_fib_lookup__bindgen_ty_2),
4382 "::",
4383 stringify!(ipv6_src)
4384 )
4385 );
4386}
4387impl Default for bpf_fib_lookup__bindgen_ty_2 {
4388 fn default() -> Self {
4389 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4390 unsafe {
4391 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4392 s.assume_init()
4393 }
4394 }
4395}
4396impl ::std::fmt::Debug for bpf_fib_lookup__bindgen_ty_2 {
4397 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4398 write!(f, "bpf_fib_lookup__bindgen_ty_2 {{ union }}")
4399 }
4400}
4401#[repr(C)]
4402#[derive(Copy, Clone)]
4403pub union bpf_fib_lookup__bindgen_ty_3 {
4404 pub ipv4_dst: __be32,
4405 pub ipv6_dst: [__u32; 4usize],
4406}
4407#[test]
4408fn bindgen_test_layout_bpf_fib_lookup__bindgen_ty_3() {
4409 assert_eq!(
4410 ::std::mem::size_of::<bpf_fib_lookup__bindgen_ty_3>(),
4411 16usize,
4412 concat!("Size of: ", stringify!(bpf_fib_lookup__bindgen_ty_3))
4413 );
4414 assert_eq!(
4415 ::std::mem::align_of::<bpf_fib_lookup__bindgen_ty_3>(),
4416 4usize,
4417 concat!("Alignment of ", stringify!(bpf_fib_lookup__bindgen_ty_3))
4418 );
4419 assert_eq!(
4420 unsafe {
4421 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_3>())).ipv4_dst as *const _ as usize
4422 },
4423 0usize,
4424 concat!(
4425 "Offset of field: ",
4426 stringify!(bpf_fib_lookup__bindgen_ty_3),
4427 "::",
4428 stringify!(ipv4_dst)
4429 )
4430 );
4431 assert_eq!(
4432 unsafe {
4433 &(*(::std::ptr::null::<bpf_fib_lookup__bindgen_ty_3>())).ipv6_dst as *const _ as usize
4434 },
4435 0usize,
4436 concat!(
4437 "Offset of field: ",
4438 stringify!(bpf_fib_lookup__bindgen_ty_3),
4439 "::",
4440 stringify!(ipv6_dst)
4441 )
4442 );
4443}
4444impl Default for bpf_fib_lookup__bindgen_ty_3 {
4445 fn default() -> Self {
4446 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4447 unsafe {
4448 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4449 s.assume_init()
4450 }
4451 }
4452}
4453impl ::std::fmt::Debug for bpf_fib_lookup__bindgen_ty_3 {
4454 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4455 write!(f, "bpf_fib_lookup__bindgen_ty_3 {{ union }}")
4456 }
4457}
4458#[test]
4459fn bindgen_test_layout_bpf_fib_lookup() {
4460 assert_eq!(
4461 ::std::mem::size_of::<bpf_fib_lookup>(),
4462 64usize,
4463 concat!("Size of: ", stringify!(bpf_fib_lookup))
4464 );
4465 assert_eq!(
4466 ::std::mem::align_of::<bpf_fib_lookup>(),
4467 4usize,
4468 concat!("Alignment of ", stringify!(bpf_fib_lookup))
4469 );
4470 assert_eq!(
4471 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).family as *const _ as usize },
4472 0usize,
4473 concat!(
4474 "Offset of field: ",
4475 stringify!(bpf_fib_lookup),
4476 "::",
4477 stringify!(family)
4478 )
4479 );
4480 assert_eq!(
4481 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).l4_protocol as *const _ as usize },
4482 1usize,
4483 concat!(
4484 "Offset of field: ",
4485 stringify!(bpf_fib_lookup),
4486 "::",
4487 stringify!(l4_protocol)
4488 )
4489 );
4490 assert_eq!(
4491 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).sport as *const _ as usize },
4492 2usize,
4493 concat!(
4494 "Offset of field: ",
4495 stringify!(bpf_fib_lookup),
4496 "::",
4497 stringify!(sport)
4498 )
4499 );
4500 assert_eq!(
4501 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).dport as *const _ as usize },
4502 4usize,
4503 concat!(
4504 "Offset of field: ",
4505 stringify!(bpf_fib_lookup),
4506 "::",
4507 stringify!(dport)
4508 )
4509 );
4510 assert_eq!(
4511 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).tot_len as *const _ as usize },
4512 6usize,
4513 concat!(
4514 "Offset of field: ",
4515 stringify!(bpf_fib_lookup),
4516 "::",
4517 stringify!(tot_len)
4518 )
4519 );
4520 assert_eq!(
4521 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).ifindex as *const _ as usize },
4522 8usize,
4523 concat!(
4524 "Offset of field: ",
4525 stringify!(bpf_fib_lookup),
4526 "::",
4527 stringify!(ifindex)
4528 )
4529 );
4530 assert_eq!(
4531 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).h_vlan_proto as *const _ as usize },
4532 48usize,
4533 concat!(
4534 "Offset of field: ",
4535 stringify!(bpf_fib_lookup),
4536 "::",
4537 stringify!(h_vlan_proto)
4538 )
4539 );
4540 assert_eq!(
4541 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).h_vlan_TCI as *const _ as usize },
4542 50usize,
4543 concat!(
4544 "Offset of field: ",
4545 stringify!(bpf_fib_lookup),
4546 "::",
4547 stringify!(h_vlan_TCI)
4548 )
4549 );
4550 assert_eq!(
4551 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).smac as *const _ as usize },
4552 52usize,
4553 concat!(
4554 "Offset of field: ",
4555 stringify!(bpf_fib_lookup),
4556 "::",
4557 stringify!(smac)
4558 )
4559 );
4560 assert_eq!(
4561 unsafe { &(*(::std::ptr::null::<bpf_fib_lookup>())).dmac as *const _ as usize },
4562 58usize,
4563 concat!(
4564 "Offset of field: ",
4565 stringify!(bpf_fib_lookup),
4566 "::",
4567 stringify!(dmac)
4568 )
4569 );
4570}
4571impl Default for bpf_fib_lookup {
4572 fn default() -> Self {
4573 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4574 unsafe {
4575 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4576 s.assume_init()
4577 }
4578 }
4579}
4580impl ::std::fmt::Debug for bpf_fib_lookup {
4581 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4582 write ! (f , "bpf_fib_lookup {{ family: {:?}, l4_protocol: {:?}, sport: {:?}, dport: {:?}, tot_len: {:?}, ifindex: {:?}, __bindgen_anon_1: {:?}, __bindgen_anon_2: {:?}, __bindgen_anon_3: {:?}, h_vlan_proto: {:?}, h_vlan_TCI: {:?}, smac: {:?}, dmac: {:?} }}" , self . family , self . l4_protocol , self . sport , self . dport , self . tot_len , self . ifindex , self . __bindgen_anon_1 , self . __bindgen_anon_2 , self . __bindgen_anon_3 , self . h_vlan_proto , self . h_vlan_TCI , self . smac , self . dmac)
4583 }
4584}
4585pub const bpf_task_fd_type_BPF_FD_TYPE_RAW_TRACEPOINT: bpf_task_fd_type = 0;
4586pub const bpf_task_fd_type_BPF_FD_TYPE_TRACEPOINT: bpf_task_fd_type = 1;
4587pub const bpf_task_fd_type_BPF_FD_TYPE_KPROBE: bpf_task_fd_type = 2;
4588pub const bpf_task_fd_type_BPF_FD_TYPE_KRETPROBE: bpf_task_fd_type = 3;
4589pub const bpf_task_fd_type_BPF_FD_TYPE_UPROBE: bpf_task_fd_type = 4;
4590pub const bpf_task_fd_type_BPF_FD_TYPE_URETPROBE: bpf_task_fd_type = 5;
4591pub type bpf_task_fd_type = ::std::os::raw::c_uint;
4592#[repr(C)]
4593#[derive(Debug, Copy, Clone)]
4594pub struct bpf_create_map_attr {
4595 _unused: [u8; 0],
4596}
4597#[repr(C)]
4598#[derive(Debug, Copy, Clone)]
4599pub struct bpf_load_program_attr {
4600 _unused: [u8; 0],
4601}
4602pub const bpf_probe_attach_type_BPF_PROBE_ENTRY: bpf_probe_attach_type = 0;
4603pub const bpf_probe_attach_type_BPF_PROBE_RETURN: bpf_probe_attach_type = 1;
4604pub type bpf_probe_attach_type = ::std::os::raw::c_uint;
4605extern "C" {
4606 pub fn bcc_create_map(
4607 map_type: bpf_map_type,
4608 name: *const ::std::os::raw::c_char,
4609 key_size: ::std::os::raw::c_int,
4610 value_size: ::std::os::raw::c_int,
4611 max_entries: ::std::os::raw::c_int,
4612 map_flags: ::std::os::raw::c_int,
4613 ) -> ::std::os::raw::c_int;
4614}
4615extern "C" {
4616 pub fn bcc_create_map_xattr(
4617 attr: *mut bpf_create_map_attr,
4618 allow_rlimit: bool,
4619 ) -> ::std::os::raw::c_int;
4620}
4621extern "C" {
4622 pub fn bpf_update_elem(
4623 fd: ::std::os::raw::c_int,
4624 key: *mut ::std::os::raw::c_void,
4625 value: *mut ::std::os::raw::c_void,
4626 flags: ::std::os::raw::c_ulonglong,
4627 ) -> ::std::os::raw::c_int;
4628}
4629extern "C" {
4630 pub fn bpf_lookup_elem(
4631 fd: ::std::os::raw::c_int,
4632 key: *mut ::std::os::raw::c_void,
4633 value: *mut ::std::os::raw::c_void,
4634 ) -> ::std::os::raw::c_int;
4635}
4636extern "C" {
4637 pub fn bpf_delete_elem(
4638 fd: ::std::os::raw::c_int,
4639 key: *mut ::std::os::raw::c_void,
4640 ) -> ::std::os::raw::c_int;
4641}
4642extern "C" {
4643 pub fn bpf_get_first_key(
4644 fd: ::std::os::raw::c_int,
4645 key: *mut ::std::os::raw::c_void,
4646 key_size: usize,
4647 ) -> ::std::os::raw::c_int;
4648}
4649extern "C" {
4650 pub fn bpf_get_next_key(
4651 fd: ::std::os::raw::c_int,
4652 key: *mut ::std::os::raw::c_void,
4653 next_key: *mut ::std::os::raw::c_void,
4654 ) -> ::std::os::raw::c_int;
4655}
4656extern "C" {
4657 pub fn bpf_lookup_and_delete(
4658 fd: ::std::os::raw::c_int,
4659 key: *mut ::std::os::raw::c_void,
4660 value: *mut ::std::os::raw::c_void,
4661 ) -> ::std::os::raw::c_int;
4662}
4663extern "C" {
4664 pub fn bcc_prog_load(
4665 prog_type: bpf_prog_type,
4666 name: *const ::std::os::raw::c_char,
4667 insns: *const bpf_insn,
4668 prog_len: ::std::os::raw::c_int,
4669 license: *const ::std::os::raw::c_char,
4670 kern_version: ::std::os::raw::c_uint,
4671 log_level: ::std::os::raw::c_int,
4672 log_buf: *mut ::std::os::raw::c_char,
4673 log_buf_size: ::std::os::raw::c_uint,
4674 ) -> ::std::os::raw::c_int;
4675}
4676extern "C" {
4677 pub fn bcc_prog_load_xattr(
4678 attr: *mut bpf_load_program_attr,
4679 prog_len: ::std::os::raw::c_int,
4680 log_buf: *mut ::std::os::raw::c_char,
4681 log_buf_size: ::std::os::raw::c_uint,
4682 allow_rlimit: bool,
4683 ) -> ::std::os::raw::c_int;
4684}
4685extern "C" {
4686 pub fn bpf_attach_socket(
4687 sockfd: ::std::os::raw::c_int,
4688 progfd: ::std::os::raw::c_int,
4689 ) -> ::std::os::raw::c_int;
4690}
4691extern "C" {
4692 pub fn bpf_open_raw_sock(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4693}
4694pub type perf_reader_raw_cb = ::std::option::Option<
4695 unsafe extern "C" fn(
4696 cb_cookie: *mut ::std::os::raw::c_void,
4697 raw: *mut ::std::os::raw::c_void,
4698 raw_size: ::std::os::raw::c_int,
4699 ),
4700>;
4701pub type perf_reader_lost_cb =
4702 ::std::option::Option<unsafe extern "C" fn(cb_cookie: *mut ::std::os::raw::c_void, lost: u64)>;
4703extern "C" {
4704 pub fn bpf_attach_kprobe(
4705 progfd: ::std::os::raw::c_int,
4706 attach_type: bpf_probe_attach_type,
4707 ev_name: *const ::std::os::raw::c_char,
4708 fn_name: *const ::std::os::raw::c_char,
4709 fn_offset: u64,
4710 maxactive: ::std::os::raw::c_int,
4711 ) -> ::std::os::raw::c_int;
4712}
4713extern "C" {
4714 pub fn bpf_detach_kprobe(ev_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4715}
4716extern "C" {
4717 pub fn bpf_attach_uprobe(
4718 progfd: ::std::os::raw::c_int,
4719 attach_type: bpf_probe_attach_type,
4720 ev_name: *const ::std::os::raw::c_char,
4721 binary_path: *const ::std::os::raw::c_char,
4722 offset: u64,
4723 pid: pid_t,
4724 ref_ctr_offset: u32,
4725 ) -> ::std::os::raw::c_int;
4726}
4727extern "C" {
4728 pub fn bpf_detach_uprobe(ev_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4729}
4730extern "C" {
4731 pub fn bpf_attach_tracepoint(
4732 progfd: ::std::os::raw::c_int,
4733 tp_category: *const ::std::os::raw::c_char,
4734 tp_name: *const ::std::os::raw::c_char,
4735 ) -> ::std::os::raw::c_int;
4736}
4737extern "C" {
4738 pub fn bpf_detach_tracepoint(
4739 tp_category: *const ::std::os::raw::c_char,
4740 tp_name: *const ::std::os::raw::c_char,
4741 ) -> ::std::os::raw::c_int;
4742}
4743extern "C" {
4744 pub fn bpf_attach_raw_tracepoint(
4745 progfd: ::std::os::raw::c_int,
4746 tp_name: *const ::std::os::raw::c_char,
4747 ) -> ::std::os::raw::c_int;
4748}
4749extern "C" {
4750 pub fn bpf_attach_kfunc(prog_fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4751}
4752extern "C" {
4753 pub fn bpf_attach_lsm(prog_fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4754}
4755extern "C" {
4756 pub fn bpf_has_kernel_btf() -> bool;
4757}
4758extern "C" {
4759 pub fn bpf_open_perf_buffer(
4760 raw_cb: perf_reader_raw_cb,
4761 lost_cb: perf_reader_lost_cb,
4762 cb_cookie: *mut ::std::os::raw::c_void,
4763 pid: ::std::os::raw::c_int,
4764 cpu: ::std::os::raw::c_int,
4765 page_cnt: ::std::os::raw::c_int,
4766 ) -> *mut ::std::os::raw::c_void;
4767}
4768extern "C" {
4769 pub fn bpf_attach_xdp(
4770 dev_name: *const ::std::os::raw::c_char,
4771 progfd: ::std::os::raw::c_int,
4772 flags: u32,
4773 ) -> ::std::os::raw::c_int;
4774}
4775extern "C" {
4776 pub fn bpf_attach_perf_event_raw(
4777 progfd: ::std::os::raw::c_int,
4778 perf_event_attr: *mut ::std::os::raw::c_void,
4779 pid: pid_t,
4780 cpu: ::std::os::raw::c_int,
4781 group_fd: ::std::os::raw::c_int,
4782 extra_flags: ::std::os::raw::c_ulong,
4783 ) -> ::std::os::raw::c_int;
4784}
4785extern "C" {
4786 pub fn bpf_attach_perf_event(
4787 progfd: ::std::os::raw::c_int,
4788 ev_type: u32,
4789 ev_config: u32,
4790 sample_period: u64,
4791 sample_freq: u64,
4792 pid: pid_t,
4793 cpu: ::std::os::raw::c_int,
4794 group_fd: ::std::os::raw::c_int,
4795 ) -> ::std::os::raw::c_int;
4796}
4797extern "C" {
4798 pub fn bpf_open_perf_event(
4799 type_: u32,
4800 config: u64,
4801 pid: ::std::os::raw::c_int,
4802 cpu: ::std::os::raw::c_int,
4803 ) -> ::std::os::raw::c_int;
4804}
4805extern "C" {
4806 pub fn bpf_close_perf_event_fd(fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4807}
4808pub type ring_buffer_sample_fn = ::std::option::Option<
4809 unsafe extern "C" fn(
4810 ctx: *mut ::std::os::raw::c_void,
4811 data: *mut ::std::os::raw::c_void,
4812 size: usize,
4813 ) -> ::std::os::raw::c_int,
4814>;
4815#[repr(C)]
4816#[derive(Debug, Copy, Clone)]
4817pub struct ring_buffer {
4818 _unused: [u8; 0],
4819}
4820extern "C" {
4821 pub fn bpf_new_ringbuf(
4822 map_fd: ::std::os::raw::c_int,
4823 sample_cb: ring_buffer_sample_fn,
4824 ctx: *mut ::std::os::raw::c_void,
4825 ) -> *mut ::std::os::raw::c_void;
4826}
4827extern "C" {
4828 pub fn bpf_free_ringbuf(rb: *mut ring_buffer);
4829}
4830extern "C" {
4831 pub fn bpf_add_ringbuf(
4832 rb: *mut ring_buffer,
4833 map_fd: ::std::os::raw::c_int,
4834 sample_cb: ring_buffer_sample_fn,
4835 ctx: *mut ::std::os::raw::c_void,
4836 ) -> ::std::os::raw::c_int;
4837}
4838extern "C" {
4839 pub fn bpf_poll_ringbuf(
4840 rb: *mut ring_buffer,
4841 timeout_ms: ::std::os::raw::c_int,
4842 ) -> ::std::os::raw::c_int;
4843}
4844extern "C" {
4845 pub fn bpf_consume_ringbuf(rb: *mut ring_buffer) -> ::std::os::raw::c_int;
4846}
4847extern "C" {
4848 pub fn bpf_obj_pin(
4849 fd: ::std::os::raw::c_int,
4850 pathname: *const ::std::os::raw::c_char,
4851 ) -> ::std::os::raw::c_int;
4852}
4853extern "C" {
4854 pub fn bpf_obj_get(pathname: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4855}
4856extern "C" {
4857 pub fn bpf_obj_get_info(
4858 prog_map_fd: ::std::os::raw::c_int,
4859 info: *mut ::std::os::raw::c_void,
4860 info_len: *mut u32,
4861 ) -> ::std::os::raw::c_int;
4862}
4863extern "C" {
4864 pub fn bpf_prog_compute_tag(
4865 insns: *const bpf_insn,
4866 prog_len: ::std::os::raw::c_int,
4867 tag: *mut ::std::os::raw::c_ulonglong,
4868 ) -> ::std::os::raw::c_int;
4869}
4870extern "C" {
4871 pub fn bpf_prog_get_tag(
4872 fd: ::std::os::raw::c_int,
4873 tag: *mut ::std::os::raw::c_ulonglong,
4874 ) -> ::std::os::raw::c_int;
4875}
4876extern "C" {
4877 pub fn bpf_prog_get_next_id(start_id: u32, next_id: *mut u32) -> ::std::os::raw::c_int;
4878}
4879extern "C" {
4880 pub fn bpf_prog_get_fd_by_id(id: u32) -> ::std::os::raw::c_int;
4881}
4882extern "C" {
4883 pub fn bpf_map_get_fd_by_id(id: u32) -> ::std::os::raw::c_int;
4884}
4885extern "C" {
4886 pub fn bpf_obj_get_info_by_fd(
4887 prog_fd: ::std::os::raw::c_int,
4888 info: *mut ::std::os::raw::c_void,
4889 info_len: *mut u32,
4890 ) -> ::std::os::raw::c_int;
4891}
4892extern "C" {
4893 pub fn bcc_iter_attach(
4894 prog_fd: ::std::os::raw::c_int,
4895 link_info: *mut [u8; 0usize],
4896 link_info_len: u32,
4897 ) -> ::std::os::raw::c_int;
4898}
4899extern "C" {
4900 pub fn bcc_iter_create(link_fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4901}
4902extern "C" {
4903 pub fn bcc_make_parent_dir(path: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4904}
4905extern "C" {
4906 pub fn bcc_check_bpffs_path(path: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4907}
4908#[repr(C)]
4909#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4910pub struct mod_info {
4911 pub name: *mut ::std::os::raw::c_char,
4912 pub start_addr: u64,
4913 pub end_addr: u64,
4914 pub file_offset: ::std::os::raw::c_ulonglong,
4915 pub dev_major: u64,
4916 pub dev_minor: u64,
4917 pub inode: u64,
4918}
4919#[test]
4920fn bindgen_test_layout_mod_info() {
4921 assert_eq!(
4922 ::std::mem::size_of::<mod_info>(),
4923 56usize,
4924 concat!("Size of: ", stringify!(mod_info))
4925 );
4926 assert_eq!(
4927 ::std::mem::align_of::<mod_info>(),
4928 8usize,
4929 concat!("Alignment of ", stringify!(mod_info))
4930 );
4931 assert_eq!(
4932 unsafe { &(*(::std::ptr::null::<mod_info>())).name as *const _ as usize },
4933 0usize,
4934 concat!(
4935 "Offset of field: ",
4936 stringify!(mod_info),
4937 "::",
4938 stringify!(name)
4939 )
4940 );
4941 assert_eq!(
4942 unsafe { &(*(::std::ptr::null::<mod_info>())).start_addr as *const _ as usize },
4943 8usize,
4944 concat!(
4945 "Offset of field: ",
4946 stringify!(mod_info),
4947 "::",
4948 stringify!(start_addr)
4949 )
4950 );
4951 assert_eq!(
4952 unsafe { &(*(::std::ptr::null::<mod_info>())).end_addr as *const _ as usize },
4953 16usize,
4954 concat!(
4955 "Offset of field: ",
4956 stringify!(mod_info),
4957 "::",
4958 stringify!(end_addr)
4959 )
4960 );
4961 assert_eq!(
4962 unsafe { &(*(::std::ptr::null::<mod_info>())).file_offset as *const _ as usize },
4963 24usize,
4964 concat!(
4965 "Offset of field: ",
4966 stringify!(mod_info),
4967 "::",
4968 stringify!(file_offset)
4969 )
4970 );
4971 assert_eq!(
4972 unsafe { &(*(::std::ptr::null::<mod_info>())).dev_major as *const _ as usize },
4973 32usize,
4974 concat!(
4975 "Offset of field: ",
4976 stringify!(mod_info),
4977 "::",
4978 stringify!(dev_major)
4979 )
4980 );
4981 assert_eq!(
4982 unsafe { &(*(::std::ptr::null::<mod_info>())).dev_minor as *const _ as usize },
4983 40usize,
4984 concat!(
4985 "Offset of field: ",
4986 stringify!(mod_info),
4987 "::",
4988 stringify!(dev_minor)
4989 )
4990 );
4991 assert_eq!(
4992 unsafe { &(*(::std::ptr::null::<mod_info>())).inode as *const _ as usize },
4993 48usize,
4994 concat!(
4995 "Offset of field: ",
4996 stringify!(mod_info),
4997 "::",
4998 stringify!(inode)
4999 )
5000 );
5001}
5002impl Default for mod_info {
5003 fn default() -> Self {
5004 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5005 unsafe {
5006 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5007 s.assume_init()
5008 }
5009 }
5010}
5011pub type bcc_procutils_modulecb = ::std::option::Option<
5012 unsafe extern "C" fn(
5013 arg1: *mut mod_info,
5014 arg2: ::std::os::raw::c_int,
5015 arg3: *mut ::std::os::raw::c_void,
5016 ) -> ::std::os::raw::c_int,
5017>;
5018pub type bcc_procutils_ksymcb = ::std::option::Option<
5019 unsafe extern "C" fn(
5020 arg1: *const ::std::os::raw::c_char,
5021 arg2: *const ::std::os::raw::c_char,
5022 arg3: u64,
5023 arg4: *mut ::std::os::raw::c_void,
5024 ),
5025>;
5026extern "C" {
5027 pub fn bcc_procutils_which_so(
5028 libname: *const ::std::os::raw::c_char,
5029 pid: ::std::os::raw::c_int,
5030 ) -> *mut ::std::os::raw::c_char;
5031}
5032extern "C" {
5033 pub fn bcc_procutils_which(
5034 binpath: *const ::std::os::raw::c_char,
5035 ) -> *mut ::std::os::raw::c_char;
5036}
5037extern "C" {
5038 pub fn bcc_mapping_is_file_backed(
5039 mapname: *const ::std::os::raw::c_char,
5040 ) -> ::std::os::raw::c_int;
5041}
5042extern "C" {
5043 pub fn bcc_procutils_each_module(
5044 pid: ::std::os::raw::c_int,
5045 callback: bcc_procutils_modulecb,
5046 payload: *mut ::std::os::raw::c_void,
5047 ) -> ::std::os::raw::c_int;
5048}
5049extern "C" {
5050 pub fn bcc_procutils_each_ksym(
5051 callback: bcc_procutils_ksymcb,
5052 payload: *mut ::std::os::raw::c_void,
5053 ) -> ::std::os::raw::c_int;
5054}
5055extern "C" {
5056 pub fn bcc_procutils_free(ptr: *const ::std::os::raw::c_char);
5057}
5058extern "C" {
5059 pub fn bcc_procutils_language(pid: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
5060}
5061#[repr(C)]
5062#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5063pub struct bcc_symbol {
5064 pub name: *const ::std::os::raw::c_char,
5065 pub demangle_name: *const ::std::os::raw::c_char,
5066 pub module: *const ::std::os::raw::c_char,
5067 pub offset: u64,
5068}
5069#[test]
5070fn bindgen_test_layout_bcc_symbol() {
5071 assert_eq!(
5072 ::std::mem::size_of::<bcc_symbol>(),
5073 32usize,
5074 concat!("Size of: ", stringify!(bcc_symbol))
5075 );
5076 assert_eq!(
5077 ::std::mem::align_of::<bcc_symbol>(),
5078 8usize,
5079 concat!("Alignment of ", stringify!(bcc_symbol))
5080 );
5081 assert_eq!(
5082 unsafe { &(*(::std::ptr::null::<bcc_symbol>())).name as *const _ as usize },
5083 0usize,
5084 concat!(
5085 "Offset of field: ",
5086 stringify!(bcc_symbol),
5087 "::",
5088 stringify!(name)
5089 )
5090 );
5091 assert_eq!(
5092 unsafe { &(*(::std::ptr::null::<bcc_symbol>())).demangle_name as *const _ as usize },
5093 8usize,
5094 concat!(
5095 "Offset of field: ",
5096 stringify!(bcc_symbol),
5097 "::",
5098 stringify!(demangle_name)
5099 )
5100 );
5101 assert_eq!(
5102 unsafe { &(*(::std::ptr::null::<bcc_symbol>())).module as *const _ as usize },
5103 16usize,
5104 concat!(
5105 "Offset of field: ",
5106 stringify!(bcc_symbol),
5107 "::",
5108 stringify!(module)
5109 )
5110 );
5111 assert_eq!(
5112 unsafe { &(*(::std::ptr::null::<bcc_symbol>())).offset as *const _ as usize },
5113 24usize,
5114 concat!(
5115 "Offset of field: ",
5116 stringify!(bcc_symbol),
5117 "::",
5118 stringify!(offset)
5119 )
5120 );
5121}
5122impl Default for bcc_symbol {
5123 fn default() -> Self {
5124 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5125 unsafe {
5126 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5127 s.assume_init()
5128 }
5129 }
5130}
5131pub type SYM_CB = ::std::option::Option<
5132 unsafe extern "C" fn(
5133 symname: *const ::std::os::raw::c_char,
5134 addr: u64,
5135 ) -> ::std::os::raw::c_int,
5136>;
5137#[repr(C)]
5138#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5139pub struct bcc_symbol_option {
5140 pub use_debug_file: ::std::os::raw::c_int,
5141 pub check_debug_file_crc: ::std::os::raw::c_int,
5142 pub lazy_symbolize: ::std::os::raw::c_int,
5143 pub use_symbol_type: u32,
5144}
5145#[test]
5146fn bindgen_test_layout_bcc_symbol_option() {
5147 assert_eq!(
5148 ::std::mem::size_of::<bcc_symbol_option>(),
5149 16usize,
5150 concat!("Size of: ", stringify!(bcc_symbol_option))
5151 );
5152 assert_eq!(
5153 ::std::mem::align_of::<bcc_symbol_option>(),
5154 4usize,
5155 concat!("Alignment of ", stringify!(bcc_symbol_option))
5156 );
5157 assert_eq!(
5158 unsafe {
5159 &(*(::std::ptr::null::<bcc_symbol_option>())).use_debug_file as *const _ as usize
5160 },
5161 0usize,
5162 concat!(
5163 "Offset of field: ",
5164 stringify!(bcc_symbol_option),
5165 "::",
5166 stringify!(use_debug_file)
5167 )
5168 );
5169 assert_eq!(
5170 unsafe {
5171 &(*(::std::ptr::null::<bcc_symbol_option>())).check_debug_file_crc as *const _ as usize
5172 },
5173 4usize,
5174 concat!(
5175 "Offset of field: ",
5176 stringify!(bcc_symbol_option),
5177 "::",
5178 stringify!(check_debug_file_crc)
5179 )
5180 );
5181 assert_eq!(
5182 unsafe {
5183 &(*(::std::ptr::null::<bcc_symbol_option>())).lazy_symbolize as *const _ as usize
5184 },
5185 8usize,
5186 concat!(
5187 "Offset of field: ",
5188 stringify!(bcc_symbol_option),
5189 "::",
5190 stringify!(lazy_symbolize)
5191 )
5192 );
5193 assert_eq!(
5194 unsafe {
5195 &(*(::std::ptr::null::<bcc_symbol_option>())).use_symbol_type as *const _ as usize
5196 },
5197 12usize,
5198 concat!(
5199 "Offset of field: ",
5200 stringify!(bcc_symbol_option),
5201 "::",
5202 stringify!(use_symbol_type)
5203 )
5204 );
5205}
5206extern "C" {
5207 pub fn bcc_symcache_new(
5208 pid: ::std::os::raw::c_int,
5209 option: *mut bcc_symbol_option,
5210 ) -> *mut ::std::os::raw::c_void;
5211}
5212extern "C" {
5213 pub fn bcc_free_symcache(symcache: *mut ::std::os::raw::c_void, pid: ::std::os::raw::c_int);
5214}
5215extern "C" {
5216 pub fn bcc_symbol_free_demangle_name(sym: *mut bcc_symbol);
5217}
5218extern "C" {
5219 pub fn bcc_symcache_resolve(
5220 symcache: *mut ::std::os::raw::c_void,
5221 addr: u64,
5222 sym: *mut bcc_symbol,
5223 ) -> ::std::os::raw::c_int;
5224}
5225extern "C" {
5226 pub fn bcc_symcache_resolve_no_demangle(
5227 symcache: *mut ::std::os::raw::c_void,
5228 addr: u64,
5229 sym: *mut bcc_symbol,
5230 ) -> ::std::os::raw::c_int;
5231}
5232extern "C" {
5233 pub fn bcc_symcache_resolve_name(
5234 resolver: *mut ::std::os::raw::c_void,
5235 module: *const ::std::os::raw::c_char,
5236 name: *const ::std::os::raw::c_char,
5237 addr: *mut u64,
5238 ) -> ::std::os::raw::c_int;
5239}
5240extern "C" {
5241 pub fn bcc_symcache_refresh(resolver: *mut ::std::os::raw::c_void);
5242}
5243extern "C" {
5244 pub fn bcc_resolve_global_addr(
5245 pid: ::std::os::raw::c_int,
5246 module: *const ::std::os::raw::c_char,
5247 address: u64,
5248 inode_match_only: u8,
5249 global: *mut u64,
5250 ) -> ::std::os::raw::c_int;
5251}
5252extern "C" {
5253 pub fn bcc_buildsymcache_new() -> *mut ::std::os::raw::c_void;
5254}
5255extern "C" {
5256 pub fn bcc_free_buildsymcache(symcache: *mut ::std::os::raw::c_void);
5257}
5258extern "C" {
5259 pub fn bcc_buildsymcache_add_module(
5260 resolver: *mut ::std::os::raw::c_void,
5261 module_name: *const ::std::os::raw::c_char,
5262 ) -> ::std::os::raw::c_int;
5263}
5264extern "C" {
5265 pub fn bcc_buildsymcache_resolve(
5266 resolver: *mut ::std::os::raw::c_void,
5267 trace: *mut bpf_stack_build_id,
5268 sym: *mut bcc_symbol,
5269 ) -> ::std::os::raw::c_int;
5270}
5271extern "C" {
5272 pub fn bcc_foreach_function_symbol(
5273 module: *const ::std::os::raw::c_char,
5274 cb: SYM_CB,
5275 ) -> ::std::os::raw::c_int;
5276}
5277extern "C" {
5278 pub fn bcc_resolve_symname(
5279 module: *const ::std::os::raw::c_char,
5280 symname: *const ::std::os::raw::c_char,
5281 addr: u64,
5282 pid: ::std::os::raw::c_int,
5283 option: *mut bcc_symbol_option,
5284 sym: *mut bcc_symbol,
5285 ) -> ::std::os::raw::c_int;
5286}
5287#[repr(C)]
5288#[derive(Debug, Copy, Clone)]
5289pub struct perf_reader {
5290 _unused: [u8; 0],
5291}
5292extern "C" {
5293 pub fn perf_reader_new(
5294 raw_cb: perf_reader_raw_cb,
5295 lost_cb: perf_reader_lost_cb,
5296 cb_cookie: *mut ::std::os::raw::c_void,
5297 page_cnt: ::std::os::raw::c_int,
5298 ) -> *mut perf_reader;
5299}
5300extern "C" {
5301 pub fn perf_reader_free(ptr: *mut ::std::os::raw::c_void);
5302}
5303extern "C" {
5304 pub fn perf_reader_mmap(reader: *mut perf_reader) -> ::std::os::raw::c_int;
5305}
5306extern "C" {
5307 pub fn perf_reader_event_read(reader: *mut perf_reader);
5308}
5309extern "C" {
5310 pub fn perf_reader_poll(
5311 num_readers: ::std::os::raw::c_int,
5312 readers: *mut *mut perf_reader,
5313 timeout: ::std::os::raw::c_int,
5314 ) -> ::std::os::raw::c_int;
5315}
5316extern "C" {
5317 pub fn perf_reader_fd(reader: *mut perf_reader) -> ::std::os::raw::c_int;
5318}
5319extern "C" {
5320 pub fn perf_reader_set_fd(reader: *mut perf_reader, fd: ::std::os::raw::c_int);
5321}
5322extern "C" {
5323 pub fn bcc_usdt_new_frompid(
5324 pid: ::std::os::raw::c_int,
5325 path: *const ::std::os::raw::c_char,
5326 ) -> *mut ::std::os::raw::c_void;
5327}
5328extern "C" {
5329 pub fn bcc_usdt_new_frompath(
5330 path: *const ::std::os::raw::c_char,
5331 ) -> *mut ::std::os::raw::c_void;
5332}
5333extern "C" {
5334 pub fn bcc_usdt_close(usdt: *mut ::std::os::raw::c_void);
5335}
5336#[repr(C)]
5337#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5338pub struct bcc_usdt {
5339 pub provider: *const ::std::os::raw::c_char,
5340 pub name: *const ::std::os::raw::c_char,
5341 pub bin_path: *const ::std::os::raw::c_char,
5342 pub semaphore: u64,
5343 pub num_locations: ::std::os::raw::c_int,
5344 pub num_arguments: ::std::os::raw::c_int,
5345 pub semaphore_offset: u64,
5346}
5347#[test]
5348fn bindgen_test_layout_bcc_usdt() {
5349 assert_eq!(
5350 ::std::mem::size_of::<bcc_usdt>(),
5351 48usize,
5352 concat!("Size of: ", stringify!(bcc_usdt))
5353 );
5354 assert_eq!(
5355 ::std::mem::align_of::<bcc_usdt>(),
5356 8usize,
5357 concat!("Alignment of ", stringify!(bcc_usdt))
5358 );
5359 assert_eq!(
5360 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).provider as *const _ as usize },
5361 0usize,
5362 concat!(
5363 "Offset of field: ",
5364 stringify!(bcc_usdt),
5365 "::",
5366 stringify!(provider)
5367 )
5368 );
5369 assert_eq!(
5370 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).name as *const _ as usize },
5371 8usize,
5372 concat!(
5373 "Offset of field: ",
5374 stringify!(bcc_usdt),
5375 "::",
5376 stringify!(name)
5377 )
5378 );
5379 assert_eq!(
5380 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).bin_path as *const _ as usize },
5381 16usize,
5382 concat!(
5383 "Offset of field: ",
5384 stringify!(bcc_usdt),
5385 "::",
5386 stringify!(bin_path)
5387 )
5388 );
5389 assert_eq!(
5390 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).semaphore as *const _ as usize },
5391 24usize,
5392 concat!(
5393 "Offset of field: ",
5394 stringify!(bcc_usdt),
5395 "::",
5396 stringify!(semaphore)
5397 )
5398 );
5399 assert_eq!(
5400 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).num_locations as *const _ as usize },
5401 32usize,
5402 concat!(
5403 "Offset of field: ",
5404 stringify!(bcc_usdt),
5405 "::",
5406 stringify!(num_locations)
5407 )
5408 );
5409 assert_eq!(
5410 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).num_arguments as *const _ as usize },
5411 36usize,
5412 concat!(
5413 "Offset of field: ",
5414 stringify!(bcc_usdt),
5415 "::",
5416 stringify!(num_arguments)
5417 )
5418 );
5419 assert_eq!(
5420 unsafe { &(*(::std::ptr::null::<bcc_usdt>())).semaphore_offset as *const _ as usize },
5421 40usize,
5422 concat!(
5423 "Offset of field: ",
5424 stringify!(bcc_usdt),
5425 "::",
5426 stringify!(semaphore_offset)
5427 )
5428 );
5429}
5430impl Default for bcc_usdt {
5431 fn default() -> Self {
5432 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5433 unsafe {
5434 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5435 s.assume_init()
5436 }
5437 }
5438}
5439#[repr(C)]
5440#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5441pub struct bcc_usdt_location {
5442 pub address: u64,
5443 pub bin_path: *const ::std::os::raw::c_char,
5444}
5445#[test]
5446fn bindgen_test_layout_bcc_usdt_location() {
5447 assert_eq!(
5448 ::std::mem::size_of::<bcc_usdt_location>(),
5449 16usize,
5450 concat!("Size of: ", stringify!(bcc_usdt_location))
5451 );
5452 assert_eq!(
5453 ::std::mem::align_of::<bcc_usdt_location>(),
5454 8usize,
5455 concat!("Alignment of ", stringify!(bcc_usdt_location))
5456 );
5457 assert_eq!(
5458 unsafe { &(*(::std::ptr::null::<bcc_usdt_location>())).address as *const _ as usize },
5459 0usize,
5460 concat!(
5461 "Offset of field: ",
5462 stringify!(bcc_usdt_location),
5463 "::",
5464 stringify!(address)
5465 )
5466 );
5467 assert_eq!(
5468 unsafe { &(*(::std::ptr::null::<bcc_usdt_location>())).bin_path as *const _ as usize },
5469 8usize,
5470 concat!(
5471 "Offset of field: ",
5472 stringify!(bcc_usdt_location),
5473 "::",
5474 stringify!(bin_path)
5475 )
5476 );
5477}
5478impl Default for bcc_usdt_location {
5479 fn default() -> Self {
5480 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5481 unsafe {
5482 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5483 s.assume_init()
5484 }
5485 }
5486}
5487#[repr(C)]
5488#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5489pub struct bcc_usdt_argument {
5490 pub size: ::std::os::raw::c_int,
5491 pub valid: ::std::os::raw::c_int,
5492 pub constant: ::std::os::raw::c_longlong,
5493 pub deref_offset: ::std::os::raw::c_int,
5494 pub deref_ident: *const ::std::os::raw::c_char,
5495 pub base_register_name: *const ::std::os::raw::c_char,
5496 pub index_register_name: *const ::std::os::raw::c_char,
5497 pub scale: ::std::os::raw::c_int,
5498}
5499#[test]
5500fn bindgen_test_layout_bcc_usdt_argument() {
5501 assert_eq!(
5502 ::std::mem::size_of::<bcc_usdt_argument>(),
5503 56usize,
5504 concat!("Size of: ", stringify!(bcc_usdt_argument))
5505 );
5506 assert_eq!(
5507 ::std::mem::align_of::<bcc_usdt_argument>(),
5508 8usize,
5509 concat!("Alignment of ", stringify!(bcc_usdt_argument))
5510 );
5511 assert_eq!(
5512 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).size as *const _ as usize },
5513 0usize,
5514 concat!(
5515 "Offset of field: ",
5516 stringify!(bcc_usdt_argument),
5517 "::",
5518 stringify!(size)
5519 )
5520 );
5521 assert_eq!(
5522 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).valid as *const _ as usize },
5523 4usize,
5524 concat!(
5525 "Offset of field: ",
5526 stringify!(bcc_usdt_argument),
5527 "::",
5528 stringify!(valid)
5529 )
5530 );
5531 assert_eq!(
5532 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).constant as *const _ as usize },
5533 8usize,
5534 concat!(
5535 "Offset of field: ",
5536 stringify!(bcc_usdt_argument),
5537 "::",
5538 stringify!(constant)
5539 )
5540 );
5541 assert_eq!(
5542 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).deref_offset as *const _ as usize },
5543 16usize,
5544 concat!(
5545 "Offset of field: ",
5546 stringify!(bcc_usdt_argument),
5547 "::",
5548 stringify!(deref_offset)
5549 )
5550 );
5551 assert_eq!(
5552 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).deref_ident as *const _ as usize },
5553 24usize,
5554 concat!(
5555 "Offset of field: ",
5556 stringify!(bcc_usdt_argument),
5557 "::",
5558 stringify!(deref_ident)
5559 )
5560 );
5561 assert_eq!(
5562 unsafe {
5563 &(*(::std::ptr::null::<bcc_usdt_argument>())).base_register_name as *const _ as usize
5564 },
5565 32usize,
5566 concat!(
5567 "Offset of field: ",
5568 stringify!(bcc_usdt_argument),
5569 "::",
5570 stringify!(base_register_name)
5571 )
5572 );
5573 assert_eq!(
5574 unsafe {
5575 &(*(::std::ptr::null::<bcc_usdt_argument>())).index_register_name as *const _ as usize
5576 },
5577 40usize,
5578 concat!(
5579 "Offset of field: ",
5580 stringify!(bcc_usdt_argument),
5581 "::",
5582 stringify!(index_register_name)
5583 )
5584 );
5585 assert_eq!(
5586 unsafe { &(*(::std::ptr::null::<bcc_usdt_argument>())).scale as *const _ as usize },
5587 48usize,
5588 concat!(
5589 "Offset of field: ",
5590 stringify!(bcc_usdt_argument),
5591 "::",
5592 stringify!(scale)
5593 )
5594 );
5595}
5596impl Default for bcc_usdt_argument {
5597 fn default() -> Self {
5598 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5599 unsafe {
5600 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5601 s.assume_init()
5602 }
5603 }
5604}
5605pub type bcc_usdt_cb = ::std::option::Option<unsafe extern "C" fn(arg1: *mut bcc_usdt)>;
5606extern "C" {
5607 pub fn bcc_usdt_foreach(usdt: *mut ::std::os::raw::c_void, callback: bcc_usdt_cb);
5608}
5609extern "C" {
5610 pub fn bcc_usdt_get_location(
5611 usdt: *mut ::std::os::raw::c_void,
5612 provider_name: *const ::std::os::raw::c_char,
5613 probe_name: *const ::std::os::raw::c_char,
5614 index: ::std::os::raw::c_int,
5615 location: *mut bcc_usdt_location,
5616 ) -> ::std::os::raw::c_int;
5617}
5618extern "C" {
5619 pub fn bcc_usdt_get_argument(
5620 usdt: *mut ::std::os::raw::c_void,
5621 provider_name: *const ::std::os::raw::c_char,
5622 probe_name: *const ::std::os::raw::c_char,
5623 location_index: ::std::os::raw::c_int,
5624 argument_index: ::std::os::raw::c_int,
5625 argument: *mut bcc_usdt_argument,
5626 ) -> ::std::os::raw::c_int;
5627}
5628extern "C" {
5629 pub fn bcc_usdt_enable_probe(
5630 arg1: *mut ::std::os::raw::c_void,
5631 arg2: *const ::std::os::raw::c_char,
5632 arg3: *const ::std::os::raw::c_char,
5633 ) -> ::std::os::raw::c_int;
5634}
5635extern "C" {
5636 pub fn bcc_usdt_addsem_probe(
5637 arg1: *mut ::std::os::raw::c_void,
5638 arg2: *const ::std::os::raw::c_char,
5639 arg3: *const ::std::os::raw::c_char,
5640 arg4: i16,
5641 ) -> ::std::os::raw::c_int;
5642}
5643extern "C" {
5644 pub fn bcc_usdt_enable_fully_specified_probe(
5645 arg1: *mut ::std::os::raw::c_void,
5646 arg2: *const ::std::os::raw::c_char,
5647 arg3: *const ::std::os::raw::c_char,
5648 arg4: *const ::std::os::raw::c_char,
5649 ) -> ::std::os::raw::c_int;
5650}
5651extern "C" {
5652 pub fn bcc_usdt_addsem_fully_specified_probe(
5653 arg1: *mut ::std::os::raw::c_void,
5654 arg2: *const ::std::os::raw::c_char,
5655 arg3: *const ::std::os::raw::c_char,
5656 arg4: *const ::std::os::raw::c_char,
5657 arg5: i16,
5658 ) -> ::std::os::raw::c_int;
5659}
5660extern "C" {
5661 pub fn bcc_usdt_genargs(
5662 ctx_array: *mut *mut ::std::os::raw::c_void,
5663 len: ::std::os::raw::c_int,
5664 ) -> *const ::std::os::raw::c_char;
5665}
5666extern "C" {
5667 pub fn bcc_usdt_get_probe_argctype(
5668 ctx: *mut ::std::os::raw::c_void,
5669 probe_name: *const ::std::os::raw::c_char,
5670 arg_index: ::std::os::raw::c_int,
5671 ) -> *const ::std::os::raw::c_char;
5672}
5673extern "C" {
5674 pub fn bcc_usdt_get_fully_specified_probe_argctype(
5675 ctx: *mut ::std::os::raw::c_void,
5676 provider_name: *const ::std::os::raw::c_char,
5677 probe_name: *const ::std::os::raw::c_char,
5678 arg_index: ::std::os::raw::c_int,
5679 ) -> *const ::std::os::raw::c_char;
5680}
5681pub type bcc_usdt_uprobe_cb = ::std::option::Option<
5682 unsafe extern "C" fn(
5683 arg1: *const ::std::os::raw::c_char,
5684 arg2: *const ::std::os::raw::c_char,
5685 arg3: u64,
5686 arg4: ::std::os::raw::c_int,
5687 ),
5688>;
5689extern "C" {
5690 pub fn bcc_usdt_foreach_uprobe(usdt: *mut ::std::os::raw::c_void, callback: bcc_usdt_uprobe_cb);
5691}