From 274ea91b5e2e5b27778d17e4a0f12e1c42a80baf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alessandro=C2=A0Decina?= Date: Wed, 5 May 2021 02:46:33 +0000 Subject: [PATCH] bpf: aya-bpf-bindings: commit generated bindings --- bpf/aya-bpf-bindings/src/aarch64/bindings.rs | 923 ++++++++++ bpf/aya-bpf-bindings/src/aarch64/getters.rs | 997 +++++++++++ bpf/aya-bpf-bindings/src/aarch64/helpers.rs | 1681 ++++++++++++++++++ bpf/aya-bpf-bindings/src/x86_64/bindings.rs | 923 ++++++++++ bpf/aya-bpf-bindings/src/x86_64/getters.rs | 997 +++++++++++ bpf/aya-bpf-bindings/src/x86_64/helpers.rs | 1681 ++++++++++++++++++ 6 files changed, 7202 insertions(+) create mode 100644 bpf/aya-bpf-bindings/src/aarch64/bindings.rs create mode 100644 bpf/aya-bpf-bindings/src/aarch64/getters.rs create mode 100644 bpf/aya-bpf-bindings/src/aarch64/helpers.rs create mode 100644 bpf/aya-bpf-bindings/src/x86_64/bindings.rs create mode 100644 bpf/aya-bpf-bindings/src/x86_64/getters.rs create mode 100644 bpf/aya-bpf-bindings/src/x86_64/helpers.rs diff --git a/bpf/aya-bpf-bindings/src/aarch64/bindings.rs b/bpf/aya-bpf-bindings/src/aarch64/bindings.rs new file mode 100644 index 00000000..63c056b7 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/aarch64/bindings.rs @@ -0,0 +1,923 @@ +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +pub const BPF_LD: u32 = 0; +pub const BPF_LDX: u32 = 1; +pub const BPF_ST: u32 = 2; +pub const BPF_STX: u32 = 3; +pub const BPF_ALU: u32 = 4; +pub const BPF_JMP: u32 = 5; +pub const BPF_RET: u32 = 6; +pub const BPF_MISC: u32 = 7; +pub const BPF_W: u32 = 0; +pub const BPF_H: u32 = 8; +pub const BPF_B: u32 = 16; +pub const BPF_IMM: u32 = 0; +pub const BPF_ABS: u32 = 32; +pub const BPF_IND: u32 = 64; +pub const BPF_MEM: u32 = 96; +pub const BPF_LEN: u32 = 128; +pub const BPF_MSH: u32 = 160; +pub const BPF_ADD: u32 = 0; +pub const BPF_SUB: u32 = 16; +pub const BPF_MUL: u32 = 32; +pub const BPF_DIV: u32 = 48; +pub const BPF_OR: u32 = 64; +pub const BPF_AND: u32 = 80; +pub const BPF_LSH: u32 = 96; +pub const BPF_RSH: u32 = 112; +pub const BPF_NEG: u32 = 128; +pub const BPF_MOD: u32 = 144; +pub const BPF_XOR: u32 = 160; +pub const BPF_JA: u32 = 0; +pub const BPF_JEQ: u32 = 16; +pub const BPF_JGT: u32 = 32; +pub const BPF_JGE: u32 = 48; +pub const BPF_JSET: u32 = 64; +pub const BPF_K: u32 = 0; +pub const BPF_X: u32 = 8; +pub const BPF_MAXINSNS: u32 = 4096; +pub const BPF_JMP32: u32 = 6; +pub const BPF_ALU64: u32 = 7; +pub const BPF_DW: u32 = 24; +pub const BPF_XADD: u32 = 192; +pub const BPF_MOV: u32 = 176; +pub const BPF_ARSH: u32 = 192; +pub const BPF_END: u32 = 208; +pub const BPF_TO_LE: u32 = 0; +pub const BPF_TO_BE: u32 = 8; +pub const BPF_FROM_LE: u32 = 0; +pub const BPF_FROM_BE: u32 = 8; +pub const BPF_JNE: u32 = 80; +pub const BPF_JLT: u32 = 160; +pub const BPF_JLE: u32 = 176; +pub const BPF_JSGT: u32 = 96; +pub const BPF_JSGE: u32 = 112; +pub const BPF_JSLT: u32 = 192; +pub const BPF_JSLE: u32 = 208; +pub const BPF_CALL: u32 = 128; +pub const BPF_EXIT: u32 = 144; +pub const BPF_F_ALLOW_OVERRIDE: u32 = 1; +pub const BPF_F_ALLOW_MULTI: u32 = 2; +pub const BPF_F_STRICT_ALIGNMENT: u32 = 1; +pub const BPF_F_ANY_ALIGNMENT: u32 = 2; +pub const BPF_F_TEST_RND_HI32: u32 = 4; +pub const BPF_F_TEST_STATE_FREQ: u32 = 8; +pub const BPF_PSEUDO_MAP_FD: u32 = 1; +pub const BPF_PSEUDO_MAP_VALUE: u32 = 2; +pub const BPF_PSEUDO_CALL: u32 = 1; +pub const BPF_ANY: u32 = 0; +pub const BPF_NOEXIST: u32 = 1; +pub const BPF_EXIST: u32 = 2; +pub const BPF_F_LOCK: u32 = 4; +pub const BPF_F_NO_PREALLOC: u32 = 1; +pub const BPF_F_NO_COMMON_LRU: u32 = 2; +pub const BPF_F_NUMA_NODE: u32 = 4; +pub const BPF_OBJ_NAME_LEN: u32 = 16; +pub const BPF_F_RDONLY: u32 = 8; +pub const BPF_F_WRONLY: u32 = 16; +pub const BPF_F_STACK_BUILD_ID: u32 = 32; +pub const BPF_F_ZERO_SEED: u32 = 64; +pub const BPF_F_RDONLY_PROG: u32 = 128; +pub const BPF_F_WRONLY_PROG: u32 = 256; +pub const BPF_F_CLONE: u32 = 512; +pub const BPF_F_QUERY_EFFECTIVE: u32 = 1; +pub const BPF_BUILD_ID_SIZE: u32 = 20; +pub const BPF_F_RECOMPUTE_CSUM: u32 = 1; +pub const BPF_F_INVALIDATE_HASH: u32 = 2; +pub const BPF_F_HDR_FIELD_MASK: u32 = 15; +pub const BPF_F_PSEUDO_HDR: u32 = 16; +pub const BPF_F_MARK_MANGLED_0: u32 = 32; +pub const BPF_F_MARK_ENFORCE: u32 = 64; +pub const BPF_F_INGRESS: u32 = 1; +pub const BPF_F_TUNINFO_IPV6: u32 = 1; +pub const BPF_F_SKIP_FIELD_MASK: u32 = 255; +pub const BPF_F_USER_STACK: u32 = 256; +pub const BPF_F_FAST_STACK_CMP: u32 = 512; +pub const BPF_F_REUSE_STACKID: u32 = 1024; +pub const BPF_F_USER_BUILD_ID: u32 = 2048; +pub const BPF_F_ZERO_CSUM_TX: u32 = 2; +pub const BPF_F_DONT_FRAGMENT: u32 = 4; +pub const BPF_F_SEQ_NUMBER: u32 = 8; +pub const BPF_F_INDEX_MASK: u32 = 4294967295; +pub const BPF_F_CURRENT_CPU: u32 = 4294967295; +pub const BPF_F_CTXLEN_MASK: u64 = 4503595332403200; +pub const BPF_F_CURRENT_NETNS: i32 = -1; +pub const BPF_F_ADJ_ROOM_FIXED_GSO: u32 = 1; +pub const BPF_ADJ_ROOM_ENCAP_L2_MASK: u32 = 255; +pub const BPF_ADJ_ROOM_ENCAP_L2_SHIFT: u32 = 56; +pub const BPF_F_ADJ_ROOM_ENCAP_L3_IPV4: u32 = 2; +pub const BPF_F_ADJ_ROOM_ENCAP_L3_IPV6: u32 = 4; +pub const BPF_F_ADJ_ROOM_ENCAP_L4_GRE: u32 = 8; +pub const BPF_F_ADJ_ROOM_ENCAP_L4_UDP: u32 = 16; +pub const BPF_F_SYSCTL_BASE_NAME: u32 = 1; +pub const BPF_SK_STORAGE_GET_F_CREATE: u32 = 1; +pub const BPF_TAG_SIZE: u32 = 8; +pub const BPF_SOCK_OPS_RTO_CB_FLAG: u32 = 1; +pub const BPF_SOCK_OPS_RETRANS_CB_FLAG: u32 = 2; +pub const BPF_SOCK_OPS_STATE_CB_FLAG: u32 = 4; +pub const BPF_SOCK_OPS_RTT_CB_FLAG: u32 = 8; +pub const BPF_SOCK_OPS_ALL_CB_FLAGS: u32 = 15; +pub const BPF_DEVCG_ACC_MKNOD: u32 = 1; +pub const BPF_DEVCG_ACC_READ: u32 = 2; +pub const BPF_DEVCG_ACC_WRITE: u32 = 4; +pub const BPF_DEVCG_DEV_BLOCK: u32 = 1; +pub const BPF_DEVCG_DEV_CHAR: u32 = 2; +pub const BPF_FIB_LOOKUP_DIRECT: u32 = 1; +pub const BPF_FIB_LOOKUP_OUTPUT: u32 = 2; +pub const BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG: u32 = 1; +pub const BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL: u32 = 2; +pub const BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP: u32 = 4; +pub const TC_ACT_UNSPEC: i32 = -1; +pub const TC_ACT_OK: u32 = 0; +pub const TC_ACT_RECLASSIFY: u32 = 1; +pub const TC_ACT_SHOT: u32 = 2; +pub const TC_ACT_PIPE: u32 = 3; +pub const TC_ACT_STOLEN: u32 = 4; +pub const TC_ACT_QUEUED: u32 = 5; +pub const TC_ACT_REPEAT: u32 = 6; +pub const TC_ACT_REDIRECT: u32 = 7; +pub const TC_ACT_TRAP: u32 = 8; +pub const TC_ACT_VALUE_MAX: u32 = 8; +pub const TC_ACT_EXT_VAL_MASK: u32 = 268435455; +pub type __u8 = ::aya_bpf_cty::c_uchar; +pub type __u16 = ::aya_bpf_cty::c_ushort; +pub type __s32 = ::aya_bpf_cty::c_int; +pub type __u32 = ::aya_bpf_cty::c_uint; +pub type __s64 = ::aya_bpf_cty::c_longlong; +pub type __u64 = ::aya_bpf_cty::c_ulonglong; +pub type __be16 = __u16; +pub type __be32 = __u32; +pub type __wsum = __u32; +pub const BPF_REG_0: ::aya_bpf_cty::c_uint = 0; +pub const BPF_REG_1: ::aya_bpf_cty::c_uint = 1; +pub const BPF_REG_2: ::aya_bpf_cty::c_uint = 2; +pub const BPF_REG_3: ::aya_bpf_cty::c_uint = 3; +pub const BPF_REG_4: ::aya_bpf_cty::c_uint = 4; +pub const BPF_REG_5: ::aya_bpf_cty::c_uint = 5; +pub const BPF_REG_6: ::aya_bpf_cty::c_uint = 6; +pub const BPF_REG_7: ::aya_bpf_cty::c_uint = 7; +pub const BPF_REG_8: ::aya_bpf_cty::c_uint = 8; +pub const BPF_REG_9: ::aya_bpf_cty::c_uint = 9; +pub const BPF_REG_10: ::aya_bpf_cty::c_uint = 10; +pub const __MAX_BPF_REG: ::aya_bpf_cty::c_uint = 11; +pub type _bindgen_ty_1 = ::aya_bpf_cty::c_uint; +pub mod bpf_map_type { + pub type Type = ::aya_bpf_cty::c_uint; + pub const BPF_MAP_TYPE_UNSPEC: Type = 0; + pub const BPF_MAP_TYPE_HASH: Type = 1; + pub const BPF_MAP_TYPE_ARRAY: Type = 2; + pub const BPF_MAP_TYPE_PROG_ARRAY: Type = 3; + pub const BPF_MAP_TYPE_PERF_EVENT_ARRAY: Type = 4; + pub const BPF_MAP_TYPE_PERCPU_HASH: Type = 5; + pub const BPF_MAP_TYPE_PERCPU_ARRAY: Type = 6; + pub const BPF_MAP_TYPE_STACK_TRACE: Type = 7; + pub const BPF_MAP_TYPE_CGROUP_ARRAY: Type = 8; + pub const BPF_MAP_TYPE_LRU_HASH: Type = 9; + pub const BPF_MAP_TYPE_LRU_PERCPU_HASH: Type = 10; + pub const BPF_MAP_TYPE_LPM_TRIE: Type = 11; + pub const BPF_MAP_TYPE_ARRAY_OF_MAPS: Type = 12; + pub const BPF_MAP_TYPE_HASH_OF_MAPS: Type = 13; + pub const BPF_MAP_TYPE_DEVMAP: Type = 14; + pub const BPF_MAP_TYPE_SOCKMAP: Type = 15; + pub const BPF_MAP_TYPE_CPUMAP: Type = 16; + pub const BPF_MAP_TYPE_XSKMAP: Type = 17; + pub const BPF_MAP_TYPE_SOCKHASH: Type = 18; + pub const BPF_MAP_TYPE_CGROUP_STORAGE: Type = 19; + pub const BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: Type = 20; + pub const BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE: Type = 21; + pub const BPF_MAP_TYPE_QUEUE: Type = 22; + pub const BPF_MAP_TYPE_STACK: Type = 23; + pub const BPF_MAP_TYPE_SK_STORAGE: Type = 24; + pub const BPF_MAP_TYPE_DEVMAP_HASH: Type = 25; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __sk_buff { + pub len: __u32, + pub pkt_type: __u32, + pub mark: __u32, + pub queue_mapping: __u32, + pub protocol: __u32, + pub vlan_present: __u32, + pub vlan_tci: __u32, + pub vlan_proto: __u32, + pub priority: __u32, + pub ingress_ifindex: __u32, + pub ifindex: __u32, + pub tc_index: __u32, + pub cb: [__u32; 5usize], + pub hash: __u32, + pub tc_classid: __u32, + pub data: __u32, + pub data_end: __u32, + pub napi_id: __u32, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub data_meta: __u32, + pub __bindgen_anon_1: __sk_buff__bindgen_ty_1, + pub tstamp: __u64, + pub wire_len: __u32, + pub gso_segs: __u32, + pub __bindgen_anon_2: __sk_buff__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union __sk_buff__bindgen_ty_1 { + pub flow_keys: *mut bpf_flow_keys, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl __sk_buff__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union __sk_buff__bindgen_ty_2 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl __sk_buff__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_tunnel_key { + pub tunnel_id: __u32, + pub __bindgen_anon_1: bpf_tunnel_key__bindgen_ty_1, + pub tunnel_tos: __u8, + pub tunnel_ttl: __u8, + pub tunnel_ext: __u16, + pub tunnel_label: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_tunnel_key__bindgen_ty_1 { + pub remote_ipv4: __u32, + pub remote_ipv6: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_xfrm_state { + pub reqid: __u32, + pub spi: __u32, + pub family: __u16, + pub ext: __u16, + pub __bindgen_anon_1: bpf_xfrm_state__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_xfrm_state__bindgen_ty_1 { + pub remote_ipv4: __u32, + pub remote_ipv6: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock { + pub bound_dev_if: __u32, + pub family: __u32, + pub type_: __u32, + pub protocol: __u32, + pub mark: __u32, + pub priority: __u32, + pub src_ip4: __u32, + pub src_ip6: [__u32; 4usize], + pub src_port: __u32, + pub dst_port: __u32, + pub dst_ip4: __u32, + pub dst_ip6: [__u32; 4usize], + pub state: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_tcp_sock { + pub snd_cwnd: __u32, + pub srtt_us: __u32, + pub rtt_min: __u32, + pub snd_ssthresh: __u32, + pub rcv_nxt: __u32, + pub snd_nxt: __u32, + pub snd_una: __u32, + pub mss_cache: __u32, + pub ecn_flags: __u32, + pub rate_delivered: __u32, + pub rate_interval_us: __u32, + pub packets_out: __u32, + pub retrans_out: __u32, + pub total_retrans: __u32, + pub segs_in: __u32, + pub data_segs_in: __u32, + pub segs_out: __u32, + pub data_segs_out: __u32, + pub lost_out: __u32, + pub sacked_out: __u32, + pub bytes_received: __u64, + pub bytes_acked: __u64, + pub dsack_dups: __u32, + pub delivered: __u32, + pub delivered_ce: __u32, + pub icsk_retransmits: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_tuple { + pub __bindgen_anon_1: bpf_sock_tuple__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_tuple__bindgen_ty_1 { + pub ipv4: bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1, + pub ipv6: bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2, + _bindgen_union_align: [u32; 9usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1 { + pub saddr: __be32, + pub daddr: __be32, + pub sport: __be16, + pub dport: __be16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2 { + pub saddr: [__be32; 4usize], + pub daddr: [__be32; 4usize], + pub sport: __be16, + pub dport: __be16, +} +pub mod xdp_action { + pub type Type = ::aya_bpf_cty::c_uint; + pub const XDP_ABORTED: Type = 0; + pub const XDP_DROP: Type = 1; + pub const XDP_PASS: Type = 2; + pub const XDP_TX: Type = 3; + pub const XDP_REDIRECT: Type = 4; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct xdp_md { + pub data: __u32, + pub data_end: __u32, + pub data_meta: __u32, + pub ingress_ifindex: __u32, + pub rx_queue_index: __u32, +} +pub mod sk_action { + pub type Type = ::aya_bpf_cty::c_uint; + pub const SK_DROP: Type = 0; + pub const SK_PASS: Type = 1; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sk_msg_md { + pub __bindgen_anon_1: sk_msg_md__bindgen_ty_1, + pub __bindgen_anon_2: sk_msg_md__bindgen_ty_2, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub size: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_msg_md__bindgen_ty_1 { + pub data: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_msg_md__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_msg_md__bindgen_ty_2 { + pub data_end: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_msg_md__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sk_reuseport_md { + pub __bindgen_anon_1: sk_reuseport_md__bindgen_ty_1, + pub __bindgen_anon_2: sk_reuseport_md__bindgen_ty_2, + pub len: __u32, + pub eth_protocol: __u32, + pub ip_protocol: __u32, + pub bind_inany: __u32, + pub hash: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_reuseport_md__bindgen_ty_1 { + pub data: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_reuseport_md__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_reuseport_md__bindgen_ty_2 { + pub data_end: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_reuseport_md__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_map_info { + pub type_: __u32, + pub id: __u32, + pub key_size: __u32, + pub value_size: __u32, + pub max_entries: __u32, + pub map_flags: __u32, + pub name: [::aya_bpf_cty::c_char; 16usize], + pub ifindex: __u32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub netns_dev: __u64, + pub netns_ino: __u64, + pub btf_id: __u32, + pub btf_key_type_id: __u32, + pub btf_value_type_id: __u32, +} +impl bpf_map_info { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_addr { + pub user_family: __u32, + pub user_ip4: __u32, + pub user_ip6: [__u32; 4usize], + pub user_port: __u32, + pub family: __u32, + pub type_: __u32, + pub protocol: __u32, + pub msg_src_ip4: __u32, + pub msg_src_ip6: [__u32; 4usize], + pub __bindgen_anon_1: bpf_sock_addr__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_addr__bindgen_ty_1 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl bpf_sock_addr__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_ops { + pub op: __u32, + pub __bindgen_anon_1: bpf_sock_ops__bindgen_ty_1, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub is_fullsock: __u32, + pub snd_cwnd: __u32, + pub srtt_us: __u32, + pub bpf_sock_ops_cb_flags: __u32, + pub state: __u32, + pub rtt_min: __u32, + pub snd_ssthresh: __u32, + pub rcv_nxt: __u32, + pub snd_nxt: __u32, + pub snd_una: __u32, + pub mss_cache: __u32, + pub ecn_flags: __u32, + pub rate_delivered: __u32, + pub rate_interval_us: __u32, + pub packets_out: __u32, + pub retrans_out: __u32, + pub total_retrans: __u32, + pub segs_in: __u32, + pub data_segs_in: __u32, + pub segs_out: __u32, + pub data_segs_out: __u32, + pub lost_out: __u32, + pub sacked_out: __u32, + pub sk_txhash: __u32, + pub bytes_received: __u64, + pub bytes_acked: __u64, + pub __bindgen_anon_2: bpf_sock_ops__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_ops__bindgen_ty_1 { + pub args: [__u32; 4usize], + pub reply: __u32, + pub replylong: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_ops__bindgen_ty_2 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl bpf_sock_ops__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +pub const BPF_SOCK_OPS_VOID: ::aya_bpf_cty::c_uint = 0; +pub const BPF_SOCK_OPS_TIMEOUT_INIT: ::aya_bpf_cty::c_uint = 1; +pub const BPF_SOCK_OPS_RWND_INIT: ::aya_bpf_cty::c_uint = 2; +pub const BPF_SOCK_OPS_TCP_CONNECT_CB: ::aya_bpf_cty::c_uint = 3; +pub const BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB: ::aya_bpf_cty::c_uint = 4; +pub const BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB: ::aya_bpf_cty::c_uint = 5; +pub const BPF_SOCK_OPS_NEEDS_ECN: ::aya_bpf_cty::c_uint = 6; +pub const BPF_SOCK_OPS_BASE_RTT: ::aya_bpf_cty::c_uint = 7; +pub const BPF_SOCK_OPS_RTO_CB: ::aya_bpf_cty::c_uint = 8; +pub const BPF_SOCK_OPS_RETRANS_CB: ::aya_bpf_cty::c_uint = 9; +pub const BPF_SOCK_OPS_STATE_CB: ::aya_bpf_cty::c_uint = 10; +pub const BPF_SOCK_OPS_TCP_LISTEN_CB: ::aya_bpf_cty::c_uint = 11; +pub const BPF_SOCK_OPS_RTT_CB: ::aya_bpf_cty::c_uint = 12; +pub type _bindgen_ty_2 = ::aya_bpf_cty::c_uint; +pub const BPF_TCP_ESTABLISHED: ::aya_bpf_cty::c_uint = 1; +pub const BPF_TCP_SYN_SENT: ::aya_bpf_cty::c_uint = 2; +pub const BPF_TCP_SYN_RECV: ::aya_bpf_cty::c_uint = 3; +pub const BPF_TCP_FIN_WAIT1: ::aya_bpf_cty::c_uint = 4; +pub const BPF_TCP_FIN_WAIT2: ::aya_bpf_cty::c_uint = 5; +pub const BPF_TCP_TIME_WAIT: ::aya_bpf_cty::c_uint = 6; +pub const BPF_TCP_CLOSE: ::aya_bpf_cty::c_uint = 7; +pub const BPF_TCP_CLOSE_WAIT: ::aya_bpf_cty::c_uint = 8; +pub const BPF_TCP_LAST_ACK: ::aya_bpf_cty::c_uint = 9; +pub const BPF_TCP_LISTEN: ::aya_bpf_cty::c_uint = 10; +pub const BPF_TCP_CLOSING: ::aya_bpf_cty::c_uint = 11; +pub const BPF_TCP_NEW_SYN_RECV: ::aya_bpf_cty::c_uint = 12; +pub const BPF_TCP_MAX_STATES: ::aya_bpf_cty::c_uint = 13; +pub type _bindgen_ty_3 = ::aya_bpf_cty::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_perf_event_value { + pub counter: __u64, + pub enabled: __u64, + pub running: __u64, +} +pub const BPF_FIB_LKUP_RET_SUCCESS: ::aya_bpf_cty::c_uint = 0; +pub const BPF_FIB_LKUP_RET_BLACKHOLE: ::aya_bpf_cty::c_uint = 1; +pub const BPF_FIB_LKUP_RET_UNREACHABLE: ::aya_bpf_cty::c_uint = 2; +pub const BPF_FIB_LKUP_RET_PROHIBIT: ::aya_bpf_cty::c_uint = 3; +pub const BPF_FIB_LKUP_RET_NOT_FWDED: ::aya_bpf_cty::c_uint = 4; +pub const BPF_FIB_LKUP_RET_FWD_DISABLED: ::aya_bpf_cty::c_uint = 5; +pub const BPF_FIB_LKUP_RET_UNSUPP_LWT: ::aya_bpf_cty::c_uint = 6; +pub const BPF_FIB_LKUP_RET_NO_NEIGH: ::aya_bpf_cty::c_uint = 7; +pub const BPF_FIB_LKUP_RET_FRAG_NEEDED: ::aya_bpf_cty::c_uint = 8; +pub type _bindgen_ty_4 = ::aya_bpf_cty::c_uint; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_fib_lookup { + pub family: __u8, + pub l4_protocol: __u8, + pub sport: __be16, + pub dport: __be16, + pub tot_len: __u16, + pub ifindex: __u32, + pub __bindgen_anon_1: bpf_fib_lookup__bindgen_ty_1, + pub __bindgen_anon_2: bpf_fib_lookup__bindgen_ty_2, + pub __bindgen_anon_3: bpf_fib_lookup__bindgen_ty_3, + pub h_vlan_proto: __be16, + pub h_vlan_TCI: __be16, + pub smac: [__u8; 6usize], + pub dmac: [__u8; 6usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_1 { + pub tos: __u8, + pub flowinfo: __be32, + pub rt_metric: __u32, + _bindgen_union_align: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_2 { + pub ipv4_src: __be32, + pub ipv6_src: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_3 { + pub ipv4_dst: __be32, + pub ipv6_dst: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_flow_keys { + pub nhoff: __u16, + pub thoff: __u16, + pub addr_proto: __u16, + pub is_frag: __u8, + pub is_first_frag: __u8, + pub is_encap: __u8, + pub ip_proto: __u8, + pub n_proto: __be16, + pub sport: __be16, + pub dport: __be16, + pub __bindgen_anon_1: bpf_flow_keys__bindgen_ty_1, + pub flags: __u32, + pub flow_label: __be32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_flow_keys__bindgen_ty_1 { + pub __bindgen_anon_1: bpf_flow_keys__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_2: bpf_flow_keys__bindgen_ty_1__bindgen_ty_2, + _bindgen_union_align: [u32; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_flow_keys__bindgen_ty_1__bindgen_ty_1 { + pub ipv4_src: __be32, + pub ipv4_dst: __be32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_flow_keys__bindgen_ty_1__bindgen_ty_2 { + pub ipv6_src: [__u32; 4usize], + pub ipv6_dst: [__u32; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_spin_lock { + pub val: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sysctl { + pub write: __u32, + pub file_pos: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pt_regs { + pub r15: ::aya_bpf_cty::c_ulong, + pub r14: ::aya_bpf_cty::c_ulong, + pub r13: ::aya_bpf_cty::c_ulong, + pub r12: ::aya_bpf_cty::c_ulong, + pub rbp: ::aya_bpf_cty::c_ulong, + pub rbx: ::aya_bpf_cty::c_ulong, + pub r11: ::aya_bpf_cty::c_ulong, + pub r10: ::aya_bpf_cty::c_ulong, + pub r9: ::aya_bpf_cty::c_ulong, + pub r8: ::aya_bpf_cty::c_ulong, + pub rax: ::aya_bpf_cty::c_ulong, + pub rcx: ::aya_bpf_cty::c_ulong, + pub rdx: ::aya_bpf_cty::c_ulong, + pub rsi: ::aya_bpf_cty::c_ulong, + pub rdi: ::aya_bpf_cty::c_ulong, + pub orig_rax: ::aya_bpf_cty::c_ulong, + pub rip: ::aya_bpf_cty::c_ulong, + pub cs: ::aya_bpf_cty::c_ulong, + pub eflags: ::aya_bpf_cty::c_ulong, + pub rsp: ::aya_bpf_cty::c_ulong, + pub ss: ::aya_bpf_cty::c_ulong, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_perf_event_data { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_pidns_info { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_redir_neigh { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct linux_binprm { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sockaddr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcphdr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct seq_file { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp6_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_timewait_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_request_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct udp6_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct task_struct { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct path { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct btf_ptr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct inode { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct socket { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct file { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_map_def { + pub type_: ::aya_bpf_cty::c_uint, + pub key_size: ::aya_bpf_cty::c_uint, + pub value_size: ::aya_bpf_cty::c_uint, + pub max_entries: ::aya_bpf_cty::c_uint, + pub map_flags: ::aya_bpf_cty::c_uint, +} diff --git a/bpf/aya-bpf-bindings/src/aarch64/getters.rs b/bpf/aya-bpf-bindings/src/aarch64/getters.rs new file mode 100644 index 00000000..4ae58f40 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/aarch64/getters.rs @@ -0,0 +1,997 @@ +use super::bindings::*; +impl __BindgenBitfieldUnit {} +impl __sk_buff { + pub fn len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.len) }.ok() + } + pub fn pkt_type(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.pkt_type) }.ok() + } + pub fn mark(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mark) }.ok() + } + pub fn queue_mapping(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.queue_mapping) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn vlan_present(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_present) }.ok() + } + pub fn vlan_tci(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_tci) }.ok() + } + pub fn vlan_proto(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_proto) }.ok() + } + pub fn priority(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.priority) }.ok() + } + pub fn ingress_ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ingress_ifindex) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn tc_index(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tc_index) }.ok() + } + pub fn cb(&self) -> Option<[__u32; 5usize]> { + unsafe { crate::bpf_probe_read(&self.cb) }.ok() + } + pub fn hash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.hash) }.ok() + } + pub fn tc_classid(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tc_classid) }.ok() + } + pub fn data(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data) }.ok() + } + pub fn data_end(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_end) }.ok() + } + pub fn napi_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.napi_id) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn data_meta(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_meta) }.ok() + } + pub fn flow_keys(&self) -> Option<*mut bpf_flow_keys> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.flow_keys) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn tstamp(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.tstamp) }.ok() + } + pub fn wire_len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.wire_len) }.ok() + } + pub fn gso_segs(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.gso_segs) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl __sk_buff__bindgen_ty_1 { + pub fn flow_keys(&self) -> Option<*mut bpf_flow_keys> { + let v = unsafe { crate::bpf_probe_read(&self.flow_keys) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl __sk_buff__bindgen_ty_2 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_tunnel_key { + pub fn tunnel_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tunnel_id) }.ok() + } + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv6) }.ok() + } + pub fn tunnel_tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tunnel_tos) }.ok() + } + pub fn tunnel_ttl(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tunnel_ttl) }.ok() + } + pub fn tunnel_ext(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.tunnel_ext) }.ok() + } + pub fn tunnel_label(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tunnel_label) }.ok() + } +} +impl bpf_tunnel_key__bindgen_ty_1 { + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ipv6) }.ok() + } +} +impl bpf_xfrm_state { + pub fn reqid(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.reqid) }.ok() + } + pub fn spi(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.spi) }.ok() + } + pub fn family(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn ext(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.ext) }.ok() + } + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv6) }.ok() + } +} +impl bpf_xfrm_state__bindgen_ty_1 { + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ipv6) }.ok() + } +} +impl bpf_sock { + pub fn bound_dev_if(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bound_dev_if) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn mark(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mark) }.ok() + } + pub fn priority(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.priority) }.ok() + } + pub fn src_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.src_ip4) }.ok() + } + pub fn src_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.src_ip6) }.ok() + } + pub fn src_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.src_port) }.ok() + } + pub fn dst_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dst_port) }.ok() + } + pub fn dst_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dst_ip4) }.ok() + } + pub fn dst_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.dst_ip6) }.ok() + } + pub fn state(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.state) }.ok() + } +} +impl bpf_tcp_sock { + pub fn snd_cwnd(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_cwnd) }.ok() + } + pub fn srtt_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.srtt_us) }.ok() + } + pub fn rtt_min(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rtt_min) }.ok() + } + pub fn snd_ssthresh(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_ssthresh) }.ok() + } + pub fn rcv_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rcv_nxt) }.ok() + } + pub fn snd_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_nxt) }.ok() + } + pub fn snd_una(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_una) }.ok() + } + pub fn mss_cache(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mss_cache) }.ok() + } + pub fn ecn_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ecn_flags) }.ok() + } + pub fn rate_delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_delivered) }.ok() + } + pub fn rate_interval_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_interval_us) }.ok() + } + pub fn packets_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.packets_out) }.ok() + } + pub fn retrans_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.retrans_out) }.ok() + } + pub fn total_retrans(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.total_retrans) }.ok() + } + pub fn segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_in) }.ok() + } + pub fn data_segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_in) }.ok() + } + pub fn segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_out) }.ok() + } + pub fn data_segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_out) }.ok() + } + pub fn lost_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.lost_out) }.ok() + } + pub fn sacked_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sacked_out) }.ok() + } + pub fn bytes_received(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_received) }.ok() + } + pub fn bytes_acked(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_acked) }.ok() + } + pub fn dsack_dups(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dsack_dups) }.ok() + } + pub fn delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.delivered) }.ok() + } + pub fn delivered_ce(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.delivered_ce) }.ok() + } + pub fn icsk_retransmits(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.icsk_retransmits) }.ok() + } +} +impl bpf_sock_tuple { + pub fn ipv4(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4) }.ok() + } + pub fn ipv6(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv6) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1 { + pub fn ipv4(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.ipv4) }.ok() + } + pub fn ipv6(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.ipv6) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1 { + pub fn saddr(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.saddr) }.ok() + } + pub fn daddr(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.daddr) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2 { + pub fn saddr(&self) -> Option<[__be32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.saddr) }.ok() + } + pub fn daddr(&self) -> Option<[__be32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.daddr) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } +} +impl xdp_md { + pub fn data(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data) }.ok() + } + pub fn data_end(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_end) }.ok() + } + pub fn data_meta(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_meta) }.ok() + } + pub fn ingress_ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ingress_ifindex) }.ok() + } + pub fn rx_queue_index(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rx_queue_index) }.ok() + } +} +impl sk_msg_md { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.size) }.ok() + } +} +impl sk_msg_md__bindgen_ty_1 { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_msg_md__bindgen_ty_2 { + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_reuseport_md { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.len) }.ok() + } + pub fn eth_protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.eth_protocol) }.ok() + } + pub fn ip_protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ip_protocol) }.ok() + } + pub fn bind_inany(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bind_inany) }.ok() + } + pub fn hash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.hash) }.ok() + } +} +impl sk_reuseport_md__bindgen_ty_1 { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_reuseport_md__bindgen_ty_2 { + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_map_info { + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.id) }.ok() + } + pub fn key_size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.key_size) }.ok() + } + pub fn value_size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.value_size) }.ok() + } + pub fn max_entries(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.max_entries) }.ok() + } + pub fn map_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.map_flags) }.ok() + } + pub fn name(&self) -> Option<[::aya_bpf_cty::c_char; 16usize]> { + unsafe { crate::bpf_probe_read(&self.name) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn netns_dev(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.netns_dev) }.ok() + } + pub fn netns_ino(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.netns_ino) }.ok() + } + pub fn btf_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_id) }.ok() + } + pub fn btf_key_type_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_key_type_id) }.ok() + } + pub fn btf_value_type_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_value_type_id) }.ok() + } +} +impl bpf_sock_addr { + pub fn user_family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_family) }.ok() + } + pub fn user_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_ip4) }.ok() + } + pub fn user_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.user_ip6) }.ok() + } + pub fn user_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_port) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn msg_src_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.msg_src_ip4) }.ok() + } + pub fn msg_src_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.msg_src_ip6) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_addr__bindgen_ty_1 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_ops { + pub fn op(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.op) }.ok() + } + pub fn args(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.args) }.ok() + } + pub fn reply(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.reply) }.ok() + } + pub fn replylong(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.replylong) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn is_fullsock(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.is_fullsock) }.ok() + } + pub fn snd_cwnd(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_cwnd) }.ok() + } + pub fn srtt_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.srtt_us) }.ok() + } + pub fn bpf_sock_ops_cb_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bpf_sock_ops_cb_flags) }.ok() + } + pub fn state(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.state) }.ok() + } + pub fn rtt_min(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rtt_min) }.ok() + } + pub fn snd_ssthresh(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_ssthresh) }.ok() + } + pub fn rcv_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rcv_nxt) }.ok() + } + pub fn snd_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_nxt) }.ok() + } + pub fn snd_una(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_una) }.ok() + } + pub fn mss_cache(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mss_cache) }.ok() + } + pub fn ecn_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ecn_flags) }.ok() + } + pub fn rate_delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_delivered) }.ok() + } + pub fn rate_interval_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_interval_us) }.ok() + } + pub fn packets_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.packets_out) }.ok() + } + pub fn retrans_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.retrans_out) }.ok() + } + pub fn total_retrans(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.total_retrans) }.ok() + } + pub fn segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_in) }.ok() + } + pub fn data_segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_in) }.ok() + } + pub fn segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_out) }.ok() + } + pub fn data_segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_out) }.ok() + } + pub fn lost_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.lost_out) }.ok() + } + pub fn sacked_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sacked_out) }.ok() + } + pub fn sk_txhash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sk_txhash) }.ok() + } + pub fn bytes_received(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_received) }.ok() + } + pub fn bytes_acked(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_acked) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_ops__bindgen_ty_1 { + pub fn args(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.args) }.ok() + } + pub fn reply(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.reply) }.ok() + } + pub fn replylong(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.replylong) }.ok() + } +} +impl bpf_sock_ops__bindgen_ty_2 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_perf_event_value { + pub fn counter(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.counter) }.ok() + } + pub fn enabled(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.enabled) }.ok() + } + pub fn running(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.running) }.ok() + } +} +impl bpf_fib_lookup { + pub fn family(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn l4_protocol(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.l4_protocol) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } + pub fn tot_len(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.tot_len) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.tos) }.ok() + } + pub fn flowinfo(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.flowinfo) }.ok() + } + pub fn rt_metric(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.rt_metric) }.ok() + } + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv4_src) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_3.ipv4_dst) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_3.ipv6_dst) }.ok() + } + pub fn h_vlan_proto(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.h_vlan_proto) }.ok() + } + pub fn h_vlan_TCI(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.h_vlan_TCI) }.ok() + } + pub fn smac(&self) -> Option<[__u8; 6usize]> { + unsafe { crate::bpf_probe_read(&self.smac) }.ok() + } + pub fn dmac(&self) -> Option<[__u8; 6usize]> { + unsafe { crate::bpf_probe_read(&self.dmac) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_1 { + pub fn tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tos) }.ok() + } + pub fn flowinfo(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.flowinfo) }.ok() + } + pub fn rt_metric(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rt_metric) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_2 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_src) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_src) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_3 { + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_dst) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_dst) }.ok() + } +} +impl bpf_flow_keys { + pub fn nhoff(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.nhoff) }.ok() + } + pub fn thoff(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.thoff) }.ok() + } + pub fn addr_proto(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.addr_proto) }.ok() + } + pub fn is_frag(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_frag) }.ok() + } + pub fn is_first_frag(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_first_frag) }.ok() + } + pub fn is_encap(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_encap) }.ok() + } + pub fn ip_proto(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.ip_proto) }.ok() + } + pub fn n_proto(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.n_proto) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_1.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_1.ipv4_dst) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_2.ipv6_dst) }.ok() + } + pub fn flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.flags) }.ok() + } + pub fn flow_label(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.flow_label) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4_dst) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_dst) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1__bindgen_ty_1 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_dst) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1__bindgen_ty_2 { + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_dst) }.ok() + } +} +impl bpf_spin_lock { + pub fn val(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.val) }.ok() + } +} +impl bpf_sysctl { + pub fn write(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.write) }.ok() + } + pub fn file_pos(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.file_pos) }.ok() + } +} +impl pt_regs { + pub fn r15(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r15) }.ok() + } + pub fn r14(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r14) }.ok() + } + pub fn r13(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r13) }.ok() + } + pub fn r12(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r12) }.ok() + } + pub fn rbp(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rbp) }.ok() + } + pub fn rbx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rbx) }.ok() + } + pub fn r11(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r11) }.ok() + } + pub fn r10(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r10) }.ok() + } + pub fn r9(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r9) }.ok() + } + pub fn r8(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r8) }.ok() + } + pub fn rax(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rax) }.ok() + } + pub fn rcx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rcx) }.ok() + } + pub fn rdx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rdx) }.ok() + } + pub fn rsi(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rsi) }.ok() + } + pub fn rdi(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rdi) }.ok() + } + pub fn orig_rax(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.orig_rax) }.ok() + } + pub fn rip(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rip) }.ok() + } + pub fn cs(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.cs) }.ok() + } + pub fn eflags(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.eflags) }.ok() + } + pub fn rsp(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rsp) }.ok() + } + pub fn ss(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.ss) }.ok() + } +} +impl bpf_perf_event_data {} +impl bpf_pidns_info {} +impl bpf_redir_neigh {} +impl linux_binprm {} +impl sockaddr {} +impl tcphdr {} +impl seq_file {} +impl tcp6_sock {} +impl tcp_sock {} +impl tcp_timewait_sock {} +impl tcp_request_sock {} +impl udp6_sock {} +impl task_struct {} +impl path {} +impl btf_ptr {} +impl inode {} +impl socket {} +impl file {} +impl bpf_map_def { + pub fn type_(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn key_size(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.key_size) }.ok() + } + pub fn value_size(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.value_size) }.ok() + } + pub fn max_entries(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.max_entries) }.ok() + } + pub fn map_flags(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.map_flags) }.ok() + } +} diff --git a/bpf/aya-bpf-bindings/src/aarch64/helpers.rs b/bpf/aya-bpf-bindings/src/aarch64/helpers.rs new file mode 100644 index 00000000..f3b185a4 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/aarch64/helpers.rs @@ -0,0 +1,1681 @@ +use super::bindings::*; +pub unsafe fn bpf_map_lookup_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(1usize); + fun(map, key) +} +pub unsafe fn bpf_map_update_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(2usize); + fun(map, key, value, flags) +} +pub unsafe fn bpf_map_delete_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(3usize); + fun(map, key) +} +pub unsafe fn bpf_probe_read( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(4usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_ktime_get_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(5usize); + fun() +} +pub unsafe fn bpf_get_prandom_u32() -> __u32 { + let fun: unsafe extern "C" fn() -> __u32 = ::core::mem::transmute(7usize); + fun() +} +pub unsafe fn bpf_get_smp_processor_id() -> __u32 { + let fun: unsafe extern "C" fn() -> __u32 = ::core::mem::transmute(8usize); + fun() +} +pub unsafe fn bpf_skb_store_bytes( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(9usize); + fun(skb, offset, from, len, flags) +} +pub unsafe fn bpf_l3_csum_replace( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(10usize); + fun(skb, offset, from, to, size) +} +pub unsafe fn bpf_l4_csum_replace( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(11usize); + fun(skb, offset, from, to, flags) +} +pub unsafe fn bpf_tail_call( + ctx: *mut ::aya_bpf_cty::c_void, + prog_array_map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + prog_array_map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(12usize); + fun(ctx, prog_array_map, index) +} +pub unsafe fn bpf_clone_redirect( + skb: *mut __sk_buff, + ifindex: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + ifindex: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(13usize); + fun(skb, ifindex, flags) +} +pub unsafe fn bpf_get_current_pid_tgid() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(14usize); + fun() +} +pub unsafe fn bpf_get_current_uid_gid() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(15usize); + fun() +} +pub unsafe fn bpf_get_current_comm( + buf: *mut ::aya_bpf_cty::c_void, + size_of_buf: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *mut ::aya_bpf_cty::c_void, + size_of_buf: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(16usize); + fun(buf, size_of_buf) +} +pub unsafe fn bpf_get_cgroup_classid(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(17usize); + fun(skb) +} +pub unsafe fn bpf_skb_vlan_push( + skb: *mut __sk_buff, + vlan_proto: __be16, + vlan_tci: __u16, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + vlan_proto: __be16, + vlan_tci: __u16, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(18usize); + fun(skb, vlan_proto, vlan_tci) +} +pub unsafe fn bpf_skb_vlan_pop(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(19usize); + fun(skb) +} +pub unsafe fn bpf_skb_get_tunnel_key( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(20usize); + fun(skb, key, size, flags) +} +pub unsafe fn bpf_skb_set_tunnel_key( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(21usize); + fun(skb, key, size, flags) +} +pub unsafe fn bpf_perf_event_read(map: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 { + let fun: unsafe extern "C" fn(map: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 = + ::core::mem::transmute(22usize); + fun(map, flags) +} +pub unsafe fn bpf_redirect(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(23usize); + fun(ifindex, flags) +} +pub unsafe fn bpf_get_route_realm(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(24usize); + fun(skb) +} +pub unsafe fn bpf_perf_event_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(25usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_skb_load_bytes( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(26usize); + fun(skb, offset, to, len) +} +pub unsafe fn bpf_get_stackid( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(27usize); + fun(ctx, map, flags) +} +pub unsafe fn bpf_csum_diff( + from: *mut __be32, + from_size: __u32, + to: *mut __be32, + to_size: __u32, + seed: __wsum, +) -> __s64 { + let fun: unsafe extern "C" fn( + from: *mut __be32, + from_size: __u32, + to: *mut __be32, + to_size: __u32, + seed: __wsum, + ) -> __s64 = ::core::mem::transmute(28usize); + fun(from, from_size, to, to_size, seed) +} +pub unsafe fn bpf_skb_get_tunnel_opt( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(29usize); + fun(skb, opt, size) +} +pub unsafe fn bpf_skb_set_tunnel_opt( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(30usize); + fun(skb, opt, size) +} +pub unsafe fn bpf_skb_change_proto( + skb: *mut __sk_buff, + proto: __be16, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + proto: __be16, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(31usize); + fun(skb, proto, flags) +} +pub unsafe fn bpf_skb_change_type(skb: *mut __sk_buff, type_: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, type_: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(32usize); + fun(skb, type_) +} +pub unsafe fn bpf_skb_under_cgroup( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(33usize); + fun(skb, map, index) +} +pub unsafe fn bpf_get_hash_recalc(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(34usize); + fun(skb) +} +pub unsafe fn bpf_get_current_task() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(35usize); + fun() +} +pub unsafe fn bpf_probe_write_user( + dst: *mut ::aya_bpf_cty::c_void, + src: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + src: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(36usize); + fun(dst, src, len) +} +pub unsafe fn bpf_current_task_under_cgroup( + map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(37usize); + fun(map, index) +} +pub unsafe fn bpf_skb_change_tail( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(38usize); + fun(skb, len, flags) +} +pub unsafe fn bpf_skb_pull_data(skb: *mut __sk_buff, len: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, len: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(39usize); + fun(skb, len) +} +pub unsafe fn bpf_csum_update(skb: *mut __sk_buff, csum: __wsum) -> __s64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, csum: __wsum) -> __s64 = + ::core::mem::transmute(40usize); + fun(skb, csum) +} +pub unsafe fn bpf_set_hash_invalid(skb: *mut __sk_buff) { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) = ::core::mem::transmute(41usize); + fun(skb) +} +pub unsafe fn bpf_get_numa_node_id() -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn() -> ::aya_bpf_cty::c_long = ::core::mem::transmute(42usize); + fun() +} +pub unsafe fn bpf_skb_change_head( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(43usize); + fun(skb, len, flags) +} +pub unsafe fn bpf_xdp_adjust_head( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(44usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_probe_read_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(45usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_get_socket_cookie(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(46usize); + fun(ctx) +} +pub unsafe fn bpf_get_socket_uid(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(47usize); + fun(skb) +} +pub unsafe fn bpf_set_hash(skb: *mut __sk_buff, hash: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, hash: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(48usize); + fun(skb, hash) +} +pub unsafe fn bpf_setsockopt( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(49usize); + fun(bpf_socket, level, optname, optval, optlen) +} +pub unsafe fn bpf_skb_adjust_room( + skb: *mut __sk_buff, + len_diff: __s32, + mode: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len_diff: __s32, + mode: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(50usize); + fun(skb, len_diff, mode, flags) +} +pub unsafe fn bpf_redirect_map( + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(51usize); + fun(map, key, flags) +} +pub unsafe fn bpf_sk_redirect_map( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(52usize); + fun(skb, map, key, flags) +} +pub unsafe fn bpf_sock_map_update( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(53usize); + fun(skops, map, key, flags) +} +pub unsafe fn bpf_xdp_adjust_meta( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(54usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_perf_event_read_value( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + buf: *mut bpf_perf_event_value, + buf_size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + buf: *mut bpf_perf_event_value, + buf_size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(55usize); + fun(map, flags, buf, buf_size) +} +pub unsafe fn bpf_perf_prog_read_value( + ctx: *mut bpf_perf_event_data, + buf: *mut bpf_perf_event_value, + buf_size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_perf_event_data, + buf: *mut bpf_perf_event_value, + buf_size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(56usize); + fun(ctx, buf, buf_size) +} +pub unsafe fn bpf_getsockopt( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(57usize); + fun(bpf_socket, level, optname, optval, optlen) +} +pub unsafe fn bpf_override_return(regs: *mut pt_regs, rc: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(regs: *mut pt_regs, rc: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(58usize); + fun(regs, rc) +} +pub unsafe fn bpf_sock_ops_cb_flags_set( + bpf_sock: *mut bpf_sock_ops, + argval: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_sock: *mut bpf_sock_ops, + argval: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(59usize); + fun(bpf_sock, argval) +} +pub unsafe fn bpf_msg_redirect_map( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(60usize); + fun(msg, map, key, flags) +} +pub unsafe fn bpf_msg_apply_bytes(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(61usize); + fun(msg, bytes) +} +pub unsafe fn bpf_msg_cork_bytes(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(62usize); + fun(msg, bytes) +} +pub unsafe fn bpf_msg_pull_data( + msg: *mut sk_msg_md, + start: __u32, + end: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + end: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(63usize); + fun(msg, start, end, flags) +} +pub unsafe fn bpf_bind( + ctx: *mut bpf_sock_addr, + addr: *mut sockaddr, + addr_len: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sock_addr, + addr: *mut sockaddr, + addr_len: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(64usize); + fun(ctx, addr, addr_len) +} +pub unsafe fn bpf_xdp_adjust_tail( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(65usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_skb_get_xfrm_state( + skb: *mut __sk_buff, + index: __u32, + xfrm_state: *mut bpf_xfrm_state, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + index: __u32, + xfrm_state: *mut bpf_xfrm_state, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(66usize); + fun(skb, index, xfrm_state, size, flags) +} +pub unsafe fn bpf_get_stack( + ctx: *mut ::aya_bpf_cty::c_void, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(67usize); + fun(ctx, buf, size, flags) +} +pub unsafe fn bpf_skb_load_bytes_relative( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + start_header: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + start_header: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(68usize); + fun(skb, offset, to, len, start_header) +} +pub unsafe fn bpf_fib_lookup( + ctx: *mut ::aya_bpf_cty::c_void, + params: *mut bpf_fib_lookup, + plen: ::aya_bpf_cty::c_int, + flags: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + params: *mut bpf_fib_lookup, + plen: ::aya_bpf_cty::c_int, + flags: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(69usize); + fun(ctx, params, plen, flags) +} +pub unsafe fn bpf_sock_hash_update( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(70usize); + fun(skops, map, key, flags) +} +pub unsafe fn bpf_msg_redirect_hash( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(71usize); + fun(msg, map, key, flags) +} +pub unsafe fn bpf_sk_redirect_hash( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(72usize); + fun(skb, map, key, flags) +} +pub unsafe fn bpf_lwt_push_encap( + skb: *mut __sk_buff, + type_: __u32, + hdr: *mut ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + type_: __u32, + hdr: *mut ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(73usize); + fun(skb, type_, hdr, len) +} +pub unsafe fn bpf_lwt_seg6_store_bytes( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(74usize); + fun(skb, offset, from, len) +} +pub unsafe fn bpf_lwt_seg6_adjust_srh( + skb: *mut __sk_buff, + offset: __u32, + delta: __s32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + delta: __s32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(75usize); + fun(skb, offset, delta) +} +pub unsafe fn bpf_lwt_seg6_action( + skb: *mut __sk_buff, + action: __u32, + param: *mut ::aya_bpf_cty::c_void, + param_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + action: __u32, + param: *mut ::aya_bpf_cty::c_void, + param_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(76usize); + fun(skb, action, param, param_len) +} +pub unsafe fn bpf_rc_repeat(ctx: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(77usize); + fun(ctx) +} +pub unsafe fn bpf_rc_keydown( + ctx: *mut ::aya_bpf_cty::c_void, + protocol: __u32, + scancode: __u64, + toggle: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + protocol: __u32, + scancode: __u64, + toggle: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(78usize); + fun(ctx, protocol, scancode, toggle) +} +pub unsafe fn bpf_skb_cgroup_id(skb: *mut __sk_buff) -> __u64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u64 = ::core::mem::transmute(79usize); + fun(skb) +} +pub unsafe fn bpf_get_current_cgroup_id() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(80usize); + fun() +} +pub unsafe fn bpf_get_local_storage( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(81usize); + fun(map, flags) +} +pub unsafe fn bpf_sk_select_reuseport( + reuse: *mut sk_reuseport_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + reuse: *mut sk_reuseport_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(82usize); + fun(reuse, map, key, flags) +} +pub unsafe fn bpf_skb_ancestor_cgroup_id( + skb: *mut __sk_buff, + ancestor_level: ::aya_bpf_cty::c_int, +) -> __u64 { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + ancestor_level: ::aya_bpf_cty::c_int, + ) -> __u64 = ::core::mem::transmute(83usize); + fun(skb, ancestor_level) +} +pub unsafe fn bpf_sk_lookup_tcp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(84usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_sk_lookup_udp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(85usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_sk_release(sock: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sock: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(86usize); + fun(sock) +} +pub unsafe fn bpf_map_push_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(87usize); + fun(map, value, flags) +} +pub unsafe fn bpf_map_pop_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(88usize); + fun(map, value) +} +pub unsafe fn bpf_map_peek_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(89usize); + fun(map, value) +} +pub unsafe fn bpf_msg_push_data( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(90usize); + fun(msg, start, len, flags) +} +pub unsafe fn bpf_msg_pop_data( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(91usize); + fun(msg, start, len, flags) +} +pub unsafe fn bpf_rc_pointer_rel( + ctx: *mut ::aya_bpf_cty::c_void, + rel_x: __s32, + rel_y: __s32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + rel_x: __s32, + rel_y: __s32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(92usize); + fun(ctx, rel_x, rel_y) +} +pub unsafe fn bpf_spin_lock(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(93usize); + fun(lock) +} +pub unsafe fn bpf_spin_unlock(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(94usize); + fun(lock) +} +pub unsafe fn bpf_sk_fullsock(sk: *mut bpf_sock) -> *mut bpf_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_sock = + ::core::mem::transmute(95usize); + fun(sk) +} +pub unsafe fn bpf_tcp_sock(sk: *mut bpf_sock) -> *mut bpf_tcp_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_tcp_sock = + ::core::mem::transmute(96usize); + fun(sk) +} +pub unsafe fn bpf_skb_ecn_set_ce(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(97usize); + fun(skb) +} +pub unsafe fn bpf_get_listener_sock(sk: *mut bpf_sock) -> *mut bpf_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_sock = + ::core::mem::transmute(98usize); + fun(sk) +} +pub unsafe fn bpf_skc_lookup_tcp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(99usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_tcp_check_syncookie( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(100usize); + fun(sk, iph, iph_len, th, th_len) +} +pub unsafe fn bpf_sysctl_get_name( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(101usize); + fun(ctx, buf, buf_len, flags) +} +pub unsafe fn bpf_sysctl_get_current_value( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(102usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_sysctl_get_new_value( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(103usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_sysctl_set_new_value( + ctx: *mut bpf_sysctl, + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(104usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_strtol( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_long, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_long, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(105usize); + fun(buf, buf_len, flags, res) +} +pub unsafe fn bpf_strtoul( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(106usize); + fun(buf, buf_len, flags, res) +} +pub unsafe fn bpf_sk_storage_get( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(107usize); + fun(map, sk, value, flags) +} +pub unsafe fn bpf_sk_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(108usize); + fun(map, sk) +} +pub unsafe fn bpf_send_signal(sig: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sig: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(109usize); + fun(sig) +} +pub unsafe fn bpf_tcp_gen_syncookie( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, +) -> __s64 { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, + ) -> __s64 = ::core::mem::transmute(110usize); + fun(sk, iph, iph_len, th, th_len) +} +pub unsafe fn bpf_skb_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(111usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_probe_read_user( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(112usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_kernel( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(113usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_user_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(114usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_kernel_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(115usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_tcp_send_ack( + tp: *mut ::aya_bpf_cty::c_void, + rcv_nxt: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + tp: *mut ::aya_bpf_cty::c_void, + rcv_nxt: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(116usize); + fun(tp, rcv_nxt) +} +pub unsafe fn bpf_send_signal_thread(sig: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sig: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(117usize); + fun(sig) +} +pub unsafe fn bpf_jiffies64() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(118usize); + fun() +} +pub unsafe fn bpf_read_branch_records( + ctx: *mut bpf_perf_event_data, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_perf_event_data, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(119usize); + fun(ctx, buf, size, flags) +} +pub unsafe fn bpf_get_ns_current_pid_tgid( + dev: __u64, + ino: __u64, + nsdata: *mut bpf_pidns_info, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dev: __u64, + ino: __u64, + nsdata: *mut bpf_pidns_info, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(120usize); + fun(dev, ino, nsdata, size) +} +pub unsafe fn bpf_xdp_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(121usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_get_netns_cookie(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(122usize); + fun(ctx) +} +pub unsafe fn bpf_get_current_ancestor_cgroup_id(ancestor_level: ::aya_bpf_cty::c_int) -> __u64 { + let fun: unsafe extern "C" fn(ancestor_level: ::aya_bpf_cty::c_int) -> __u64 = + ::core::mem::transmute(123usize); + fun(ancestor_level) +} +pub unsafe fn bpf_sk_assign( + ctx: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(124usize); + fun(ctx, sk, flags) +} +pub unsafe fn bpf_ktime_get_boot_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(125usize); + fun() +} +pub unsafe fn bpf_seq_printf( + m: *mut seq_file, + fmt: *const ::aya_bpf_cty::c_char, + fmt_size: __u32, + data: *const ::aya_bpf_cty::c_void, + data_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + fmt: *const ::aya_bpf_cty::c_char, + fmt_size: __u32, + data: *const ::aya_bpf_cty::c_void, + data_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(126usize); + fun(m, fmt, fmt_size, data, data_len) +} +pub unsafe fn bpf_seq_write( + m: *mut seq_file, + data: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + data: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(127usize); + fun(m, data, len) +} +pub unsafe fn bpf_sk_cgroup_id(sk: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(128usize); + fun(sk) +} +pub unsafe fn bpf_sk_ancestor_cgroup_id( + sk: *mut ::aya_bpf_cty::c_void, + ancestor_level: ::aya_bpf_cty::c_int, +) -> __u64 { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + ancestor_level: ::aya_bpf_cty::c_int, + ) -> __u64 = ::core::mem::transmute(129usize); + fun(sk, ancestor_level) +} +pub unsafe fn bpf_ringbuf_output( + ringbuf: *mut ::aya_bpf_cty::c_void, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ringbuf: *mut ::aya_bpf_cty::c_void, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(130usize); + fun(ringbuf, data, size, flags) +} +pub unsafe fn bpf_ringbuf_reserve( + ringbuf: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + ringbuf: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(131usize); + fun(ringbuf, size, flags) +} +pub unsafe fn bpf_ringbuf_submit(data: *mut ::aya_bpf_cty::c_void, flags: __u64) { + let fun: unsafe extern "C" fn(data: *mut ::aya_bpf_cty::c_void, flags: __u64) = + ::core::mem::transmute(132usize); + fun(data, flags) +} +pub unsafe fn bpf_ringbuf_discard(data: *mut ::aya_bpf_cty::c_void, flags: __u64) { + let fun: unsafe extern "C" fn(data: *mut ::aya_bpf_cty::c_void, flags: __u64) = + ::core::mem::transmute(133usize); + fun(data, flags) +} +pub unsafe fn bpf_ringbuf_query(ringbuf: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 { + let fun: unsafe extern "C" fn(ringbuf: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 = + ::core::mem::transmute(134usize); + fun(ringbuf, flags) +} +pub unsafe fn bpf_csum_level(skb: *mut __sk_buff, level: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, level: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(135usize); + fun(skb, level) +} +pub unsafe fn bpf_skc_to_tcp6_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp6_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp6_sock = + ::core::mem::transmute(136usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_sock = + ::core::mem::transmute(137usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_timewait_sock( + sk: *mut ::aya_bpf_cty::c_void, +) -> *mut tcp_timewait_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_timewait_sock = + ::core::mem::transmute(138usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_request_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_request_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_request_sock = + ::core::mem::transmute(139usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_udp6_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut udp6_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut udp6_sock = + ::core::mem::transmute(140usize); + fun(sk) +} +pub unsafe fn bpf_get_task_stack( + task: *mut task_struct, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + task: *mut task_struct, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(141usize); + fun(task, buf, size, flags) +} +pub unsafe fn bpf_load_hdr_opt( + skops: *mut bpf_sock_ops, + searchby_res: *mut ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + searchby_res: *mut ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(142usize); + fun(skops, searchby_res, len, flags) +} +pub unsafe fn bpf_store_hdr_opt( + skops: *mut bpf_sock_ops, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(143usize); + fun(skops, from, len, flags) +} +pub unsafe fn bpf_reserve_hdr_opt( + skops: *mut bpf_sock_ops, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(144usize); + fun(skops, len, flags) +} +pub unsafe fn bpf_inode_storage_get( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(145usize); + fun(map, inode, value, flags) +} +pub unsafe fn bpf_inode_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_int { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_int = ::core::mem::transmute(146usize); + fun(map, inode) +} +pub unsafe fn bpf_d_path( + path: *mut path, + buf: *mut ::aya_bpf_cty::c_char, + sz: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + path: *mut path, + buf: *mut ::aya_bpf_cty::c_char, + sz: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(147usize); + fun(path, buf, sz) +} +pub unsafe fn bpf_copy_from_user( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + user_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + user_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(148usize); + fun(dst, size, user_ptr) +} +pub unsafe fn bpf_snprintf_btf( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + ptr: *mut btf_ptr, + btf_ptr_size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + ptr: *mut btf_ptr, + btf_ptr_size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(149usize); + fun(str_, str_size, ptr, btf_ptr_size, flags) +} +pub unsafe fn bpf_seq_printf_btf( + m: *mut seq_file, + ptr: *mut btf_ptr, + ptr_size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + ptr: *mut btf_ptr, + ptr_size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(150usize); + fun(m, ptr, ptr_size, flags) +} +pub unsafe fn bpf_skb_cgroup_classid(skb: *mut __sk_buff) -> __u64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u64 = ::core::mem::transmute(151usize); + fun(skb) +} +pub unsafe fn bpf_redirect_neigh( + ifindex: __u32, + params: *mut bpf_redir_neigh, + plen: ::aya_bpf_cty::c_int, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ifindex: __u32, + params: *mut bpf_redir_neigh, + plen: ::aya_bpf_cty::c_int, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(152usize); + fun(ifindex, params, plen, flags) +} +pub unsafe fn bpf_per_cpu_ptr( + percpu_ptr: *const ::aya_bpf_cty::c_void, + cpu: __u32, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + percpu_ptr: *const ::aya_bpf_cty::c_void, + cpu: __u32, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(153usize); + fun(percpu_ptr, cpu) +} +pub unsafe fn bpf_this_cpu_ptr( + percpu_ptr: *const ::aya_bpf_cty::c_void, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + percpu_ptr: *const ::aya_bpf_cty::c_void, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(154usize); + fun(percpu_ptr) +} +pub unsafe fn bpf_redirect_peer(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(155usize); + fun(ifindex, flags) +} +pub unsafe fn bpf_task_storage_get( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(156usize); + fun(map, task, value, flags) +} +pub unsafe fn bpf_task_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(157usize); + fun(map, task) +} +pub unsafe fn bpf_get_current_task_btf() -> *mut task_struct { + let fun: unsafe extern "C" fn() -> *mut task_struct = ::core::mem::transmute(158usize); + fun() +} +pub unsafe fn bpf_bprm_opts_set(bprm: *mut linux_binprm, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(bprm: *mut linux_binprm, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(159usize); + fun(bprm, flags) +} +pub unsafe fn bpf_ktime_get_coarse_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(160usize); + fun() +} +pub unsafe fn bpf_ima_inode_hash( + inode: *mut inode, + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + inode: *mut inode, + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(161usize); + fun(inode, dst, size) +} +pub unsafe fn bpf_sock_from_file(file: *mut file) -> *mut socket { + let fun: unsafe extern "C" fn(file: *mut file) -> *mut socket = + ::core::mem::transmute(162usize); + fun(file) +} +pub unsafe fn bpf_check_mtu( + ctx: *mut ::aya_bpf_cty::c_void, + ifindex: __u32, + mtu_len: *mut __u32, + len_diff: __s32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + ifindex: __u32, + mtu_len: *mut __u32, + len_diff: __s32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(163usize); + fun(ctx, ifindex, mtu_len, len_diff, flags) +} +pub unsafe fn bpf_for_each_map_elem( + map: *mut ::aya_bpf_cty::c_void, + callback_fn: *mut ::aya_bpf_cty::c_void, + callback_ctx: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + callback_fn: *mut ::aya_bpf_cty::c_void, + callback_ctx: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(164usize); + fun(map, callback_fn, callback_ctx, flags) +} +pub unsafe fn bpf_snprintf( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + fmt: *const ::aya_bpf_cty::c_char, + data: *mut __u64, + data_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + fmt: *const ::aya_bpf_cty::c_char, + data: *mut __u64, + data_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(165usize); + fun(str_, str_size, fmt, data, data_len) +} diff --git a/bpf/aya-bpf-bindings/src/x86_64/bindings.rs b/bpf/aya-bpf-bindings/src/x86_64/bindings.rs new file mode 100644 index 00000000..63c056b7 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/x86_64/bindings.rs @@ -0,0 +1,923 @@ +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +pub const BPF_LD: u32 = 0; +pub const BPF_LDX: u32 = 1; +pub const BPF_ST: u32 = 2; +pub const BPF_STX: u32 = 3; +pub const BPF_ALU: u32 = 4; +pub const BPF_JMP: u32 = 5; +pub const BPF_RET: u32 = 6; +pub const BPF_MISC: u32 = 7; +pub const BPF_W: u32 = 0; +pub const BPF_H: u32 = 8; +pub const BPF_B: u32 = 16; +pub const BPF_IMM: u32 = 0; +pub const BPF_ABS: u32 = 32; +pub const BPF_IND: u32 = 64; +pub const BPF_MEM: u32 = 96; +pub const BPF_LEN: u32 = 128; +pub const BPF_MSH: u32 = 160; +pub const BPF_ADD: u32 = 0; +pub const BPF_SUB: u32 = 16; +pub const BPF_MUL: u32 = 32; +pub const BPF_DIV: u32 = 48; +pub const BPF_OR: u32 = 64; +pub const BPF_AND: u32 = 80; +pub const BPF_LSH: u32 = 96; +pub const BPF_RSH: u32 = 112; +pub const BPF_NEG: u32 = 128; +pub const BPF_MOD: u32 = 144; +pub const BPF_XOR: u32 = 160; +pub const BPF_JA: u32 = 0; +pub const BPF_JEQ: u32 = 16; +pub const BPF_JGT: u32 = 32; +pub const BPF_JGE: u32 = 48; +pub const BPF_JSET: u32 = 64; +pub const BPF_K: u32 = 0; +pub const BPF_X: u32 = 8; +pub const BPF_MAXINSNS: u32 = 4096; +pub const BPF_JMP32: u32 = 6; +pub const BPF_ALU64: u32 = 7; +pub const BPF_DW: u32 = 24; +pub const BPF_XADD: u32 = 192; +pub const BPF_MOV: u32 = 176; +pub const BPF_ARSH: u32 = 192; +pub const BPF_END: u32 = 208; +pub const BPF_TO_LE: u32 = 0; +pub const BPF_TO_BE: u32 = 8; +pub const BPF_FROM_LE: u32 = 0; +pub const BPF_FROM_BE: u32 = 8; +pub const BPF_JNE: u32 = 80; +pub const BPF_JLT: u32 = 160; +pub const BPF_JLE: u32 = 176; +pub const BPF_JSGT: u32 = 96; +pub const BPF_JSGE: u32 = 112; +pub const BPF_JSLT: u32 = 192; +pub const BPF_JSLE: u32 = 208; +pub const BPF_CALL: u32 = 128; +pub const BPF_EXIT: u32 = 144; +pub const BPF_F_ALLOW_OVERRIDE: u32 = 1; +pub const BPF_F_ALLOW_MULTI: u32 = 2; +pub const BPF_F_STRICT_ALIGNMENT: u32 = 1; +pub const BPF_F_ANY_ALIGNMENT: u32 = 2; +pub const BPF_F_TEST_RND_HI32: u32 = 4; +pub const BPF_F_TEST_STATE_FREQ: u32 = 8; +pub const BPF_PSEUDO_MAP_FD: u32 = 1; +pub const BPF_PSEUDO_MAP_VALUE: u32 = 2; +pub const BPF_PSEUDO_CALL: u32 = 1; +pub const BPF_ANY: u32 = 0; +pub const BPF_NOEXIST: u32 = 1; +pub const BPF_EXIST: u32 = 2; +pub const BPF_F_LOCK: u32 = 4; +pub const BPF_F_NO_PREALLOC: u32 = 1; +pub const BPF_F_NO_COMMON_LRU: u32 = 2; +pub const BPF_F_NUMA_NODE: u32 = 4; +pub const BPF_OBJ_NAME_LEN: u32 = 16; +pub const BPF_F_RDONLY: u32 = 8; +pub const BPF_F_WRONLY: u32 = 16; +pub const BPF_F_STACK_BUILD_ID: u32 = 32; +pub const BPF_F_ZERO_SEED: u32 = 64; +pub const BPF_F_RDONLY_PROG: u32 = 128; +pub const BPF_F_WRONLY_PROG: u32 = 256; +pub const BPF_F_CLONE: u32 = 512; +pub const BPF_F_QUERY_EFFECTIVE: u32 = 1; +pub const BPF_BUILD_ID_SIZE: u32 = 20; +pub const BPF_F_RECOMPUTE_CSUM: u32 = 1; +pub const BPF_F_INVALIDATE_HASH: u32 = 2; +pub const BPF_F_HDR_FIELD_MASK: u32 = 15; +pub const BPF_F_PSEUDO_HDR: u32 = 16; +pub const BPF_F_MARK_MANGLED_0: u32 = 32; +pub const BPF_F_MARK_ENFORCE: u32 = 64; +pub const BPF_F_INGRESS: u32 = 1; +pub const BPF_F_TUNINFO_IPV6: u32 = 1; +pub const BPF_F_SKIP_FIELD_MASK: u32 = 255; +pub const BPF_F_USER_STACK: u32 = 256; +pub const BPF_F_FAST_STACK_CMP: u32 = 512; +pub const BPF_F_REUSE_STACKID: u32 = 1024; +pub const BPF_F_USER_BUILD_ID: u32 = 2048; +pub const BPF_F_ZERO_CSUM_TX: u32 = 2; +pub const BPF_F_DONT_FRAGMENT: u32 = 4; +pub const BPF_F_SEQ_NUMBER: u32 = 8; +pub const BPF_F_INDEX_MASK: u32 = 4294967295; +pub const BPF_F_CURRENT_CPU: u32 = 4294967295; +pub const BPF_F_CTXLEN_MASK: u64 = 4503595332403200; +pub const BPF_F_CURRENT_NETNS: i32 = -1; +pub const BPF_F_ADJ_ROOM_FIXED_GSO: u32 = 1; +pub const BPF_ADJ_ROOM_ENCAP_L2_MASK: u32 = 255; +pub const BPF_ADJ_ROOM_ENCAP_L2_SHIFT: u32 = 56; +pub const BPF_F_ADJ_ROOM_ENCAP_L3_IPV4: u32 = 2; +pub const BPF_F_ADJ_ROOM_ENCAP_L3_IPV6: u32 = 4; +pub const BPF_F_ADJ_ROOM_ENCAP_L4_GRE: u32 = 8; +pub const BPF_F_ADJ_ROOM_ENCAP_L4_UDP: u32 = 16; +pub const BPF_F_SYSCTL_BASE_NAME: u32 = 1; +pub const BPF_SK_STORAGE_GET_F_CREATE: u32 = 1; +pub const BPF_TAG_SIZE: u32 = 8; +pub const BPF_SOCK_OPS_RTO_CB_FLAG: u32 = 1; +pub const BPF_SOCK_OPS_RETRANS_CB_FLAG: u32 = 2; +pub const BPF_SOCK_OPS_STATE_CB_FLAG: u32 = 4; +pub const BPF_SOCK_OPS_RTT_CB_FLAG: u32 = 8; +pub const BPF_SOCK_OPS_ALL_CB_FLAGS: u32 = 15; +pub const BPF_DEVCG_ACC_MKNOD: u32 = 1; +pub const BPF_DEVCG_ACC_READ: u32 = 2; +pub const BPF_DEVCG_ACC_WRITE: u32 = 4; +pub const BPF_DEVCG_DEV_BLOCK: u32 = 1; +pub const BPF_DEVCG_DEV_CHAR: u32 = 2; +pub const BPF_FIB_LOOKUP_DIRECT: u32 = 1; +pub const BPF_FIB_LOOKUP_OUTPUT: u32 = 2; +pub const BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG: u32 = 1; +pub const BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL: u32 = 2; +pub const BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP: u32 = 4; +pub const TC_ACT_UNSPEC: i32 = -1; +pub const TC_ACT_OK: u32 = 0; +pub const TC_ACT_RECLASSIFY: u32 = 1; +pub const TC_ACT_SHOT: u32 = 2; +pub const TC_ACT_PIPE: u32 = 3; +pub const TC_ACT_STOLEN: u32 = 4; +pub const TC_ACT_QUEUED: u32 = 5; +pub const TC_ACT_REPEAT: u32 = 6; +pub const TC_ACT_REDIRECT: u32 = 7; +pub const TC_ACT_TRAP: u32 = 8; +pub const TC_ACT_VALUE_MAX: u32 = 8; +pub const TC_ACT_EXT_VAL_MASK: u32 = 268435455; +pub type __u8 = ::aya_bpf_cty::c_uchar; +pub type __u16 = ::aya_bpf_cty::c_ushort; +pub type __s32 = ::aya_bpf_cty::c_int; +pub type __u32 = ::aya_bpf_cty::c_uint; +pub type __s64 = ::aya_bpf_cty::c_longlong; +pub type __u64 = ::aya_bpf_cty::c_ulonglong; +pub type __be16 = __u16; +pub type __be32 = __u32; +pub type __wsum = __u32; +pub const BPF_REG_0: ::aya_bpf_cty::c_uint = 0; +pub const BPF_REG_1: ::aya_bpf_cty::c_uint = 1; +pub const BPF_REG_2: ::aya_bpf_cty::c_uint = 2; +pub const BPF_REG_3: ::aya_bpf_cty::c_uint = 3; +pub const BPF_REG_4: ::aya_bpf_cty::c_uint = 4; +pub const BPF_REG_5: ::aya_bpf_cty::c_uint = 5; +pub const BPF_REG_6: ::aya_bpf_cty::c_uint = 6; +pub const BPF_REG_7: ::aya_bpf_cty::c_uint = 7; +pub const BPF_REG_8: ::aya_bpf_cty::c_uint = 8; +pub const BPF_REG_9: ::aya_bpf_cty::c_uint = 9; +pub const BPF_REG_10: ::aya_bpf_cty::c_uint = 10; +pub const __MAX_BPF_REG: ::aya_bpf_cty::c_uint = 11; +pub type _bindgen_ty_1 = ::aya_bpf_cty::c_uint; +pub mod bpf_map_type { + pub type Type = ::aya_bpf_cty::c_uint; + pub const BPF_MAP_TYPE_UNSPEC: Type = 0; + pub const BPF_MAP_TYPE_HASH: Type = 1; + pub const BPF_MAP_TYPE_ARRAY: Type = 2; + pub const BPF_MAP_TYPE_PROG_ARRAY: Type = 3; + pub const BPF_MAP_TYPE_PERF_EVENT_ARRAY: Type = 4; + pub const BPF_MAP_TYPE_PERCPU_HASH: Type = 5; + pub const BPF_MAP_TYPE_PERCPU_ARRAY: Type = 6; + pub const BPF_MAP_TYPE_STACK_TRACE: Type = 7; + pub const BPF_MAP_TYPE_CGROUP_ARRAY: Type = 8; + pub const BPF_MAP_TYPE_LRU_HASH: Type = 9; + pub const BPF_MAP_TYPE_LRU_PERCPU_HASH: Type = 10; + pub const BPF_MAP_TYPE_LPM_TRIE: Type = 11; + pub const BPF_MAP_TYPE_ARRAY_OF_MAPS: Type = 12; + pub const BPF_MAP_TYPE_HASH_OF_MAPS: Type = 13; + pub const BPF_MAP_TYPE_DEVMAP: Type = 14; + pub const BPF_MAP_TYPE_SOCKMAP: Type = 15; + pub const BPF_MAP_TYPE_CPUMAP: Type = 16; + pub const BPF_MAP_TYPE_XSKMAP: Type = 17; + pub const BPF_MAP_TYPE_SOCKHASH: Type = 18; + pub const BPF_MAP_TYPE_CGROUP_STORAGE: Type = 19; + pub const BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: Type = 20; + pub const BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE: Type = 21; + pub const BPF_MAP_TYPE_QUEUE: Type = 22; + pub const BPF_MAP_TYPE_STACK: Type = 23; + pub const BPF_MAP_TYPE_SK_STORAGE: Type = 24; + pub const BPF_MAP_TYPE_DEVMAP_HASH: Type = 25; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __sk_buff { + pub len: __u32, + pub pkt_type: __u32, + pub mark: __u32, + pub queue_mapping: __u32, + pub protocol: __u32, + pub vlan_present: __u32, + pub vlan_tci: __u32, + pub vlan_proto: __u32, + pub priority: __u32, + pub ingress_ifindex: __u32, + pub ifindex: __u32, + pub tc_index: __u32, + pub cb: [__u32; 5usize], + pub hash: __u32, + pub tc_classid: __u32, + pub data: __u32, + pub data_end: __u32, + pub napi_id: __u32, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub data_meta: __u32, + pub __bindgen_anon_1: __sk_buff__bindgen_ty_1, + pub tstamp: __u64, + pub wire_len: __u32, + pub gso_segs: __u32, + pub __bindgen_anon_2: __sk_buff__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union __sk_buff__bindgen_ty_1 { + pub flow_keys: *mut bpf_flow_keys, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl __sk_buff__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union __sk_buff__bindgen_ty_2 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl __sk_buff__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_tunnel_key { + pub tunnel_id: __u32, + pub __bindgen_anon_1: bpf_tunnel_key__bindgen_ty_1, + pub tunnel_tos: __u8, + pub tunnel_ttl: __u8, + pub tunnel_ext: __u16, + pub tunnel_label: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_tunnel_key__bindgen_ty_1 { + pub remote_ipv4: __u32, + pub remote_ipv6: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_xfrm_state { + pub reqid: __u32, + pub spi: __u32, + pub family: __u16, + pub ext: __u16, + pub __bindgen_anon_1: bpf_xfrm_state__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_xfrm_state__bindgen_ty_1 { + pub remote_ipv4: __u32, + pub remote_ipv6: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock { + pub bound_dev_if: __u32, + pub family: __u32, + pub type_: __u32, + pub protocol: __u32, + pub mark: __u32, + pub priority: __u32, + pub src_ip4: __u32, + pub src_ip6: [__u32; 4usize], + pub src_port: __u32, + pub dst_port: __u32, + pub dst_ip4: __u32, + pub dst_ip6: [__u32; 4usize], + pub state: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_tcp_sock { + pub snd_cwnd: __u32, + pub srtt_us: __u32, + pub rtt_min: __u32, + pub snd_ssthresh: __u32, + pub rcv_nxt: __u32, + pub snd_nxt: __u32, + pub snd_una: __u32, + pub mss_cache: __u32, + pub ecn_flags: __u32, + pub rate_delivered: __u32, + pub rate_interval_us: __u32, + pub packets_out: __u32, + pub retrans_out: __u32, + pub total_retrans: __u32, + pub segs_in: __u32, + pub data_segs_in: __u32, + pub segs_out: __u32, + pub data_segs_out: __u32, + pub lost_out: __u32, + pub sacked_out: __u32, + pub bytes_received: __u64, + pub bytes_acked: __u64, + pub dsack_dups: __u32, + pub delivered: __u32, + pub delivered_ce: __u32, + pub icsk_retransmits: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_tuple { + pub __bindgen_anon_1: bpf_sock_tuple__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_tuple__bindgen_ty_1 { + pub ipv4: bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1, + pub ipv6: bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2, + _bindgen_union_align: [u32; 9usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1 { + pub saddr: __be32, + pub daddr: __be32, + pub sport: __be16, + pub dport: __be16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2 { + pub saddr: [__be32; 4usize], + pub daddr: [__be32; 4usize], + pub sport: __be16, + pub dport: __be16, +} +pub mod xdp_action { + pub type Type = ::aya_bpf_cty::c_uint; + pub const XDP_ABORTED: Type = 0; + pub const XDP_DROP: Type = 1; + pub const XDP_PASS: Type = 2; + pub const XDP_TX: Type = 3; + pub const XDP_REDIRECT: Type = 4; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct xdp_md { + pub data: __u32, + pub data_end: __u32, + pub data_meta: __u32, + pub ingress_ifindex: __u32, + pub rx_queue_index: __u32, +} +pub mod sk_action { + pub type Type = ::aya_bpf_cty::c_uint; + pub const SK_DROP: Type = 0; + pub const SK_PASS: Type = 1; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sk_msg_md { + pub __bindgen_anon_1: sk_msg_md__bindgen_ty_1, + pub __bindgen_anon_2: sk_msg_md__bindgen_ty_2, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub size: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_msg_md__bindgen_ty_1 { + pub data: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_msg_md__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_msg_md__bindgen_ty_2 { + pub data_end: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_msg_md__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sk_reuseport_md { + pub __bindgen_anon_1: sk_reuseport_md__bindgen_ty_1, + pub __bindgen_anon_2: sk_reuseport_md__bindgen_ty_2, + pub len: __u32, + pub eth_protocol: __u32, + pub ip_protocol: __u32, + pub bind_inany: __u32, + pub hash: __u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_reuseport_md__bindgen_ty_1 { + pub data: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_reuseport_md__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sk_reuseport_md__bindgen_ty_2 { + pub data_end: *mut ::aya_bpf_cty::c_void, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl sk_reuseport_md__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_map_info { + pub type_: __u32, + pub id: __u32, + pub key_size: __u32, + pub value_size: __u32, + pub max_entries: __u32, + pub map_flags: __u32, + pub name: [::aya_bpf_cty::c_char; 16usize], + pub ifindex: __u32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub netns_dev: __u64, + pub netns_ino: __u64, + pub btf_id: __u32, + pub btf_key_type_id: __u32, + pub btf_value_type_id: __u32, +} +impl bpf_map_info { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_addr { + pub user_family: __u32, + pub user_ip4: __u32, + pub user_ip6: [__u32; 4usize], + pub user_port: __u32, + pub family: __u32, + pub type_: __u32, + pub protocol: __u32, + pub msg_src_ip4: __u32, + pub msg_src_ip6: [__u32; 4usize], + pub __bindgen_anon_1: bpf_sock_addr__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_addr__bindgen_ty_1 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl bpf_sock_addr__bindgen_ty_1 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_sock_ops { + pub op: __u32, + pub __bindgen_anon_1: bpf_sock_ops__bindgen_ty_1, + pub family: __u32, + pub remote_ip4: __u32, + pub local_ip4: __u32, + pub remote_ip6: [__u32; 4usize], + pub local_ip6: [__u32; 4usize], + pub remote_port: __u32, + pub local_port: __u32, + pub is_fullsock: __u32, + pub snd_cwnd: __u32, + pub srtt_us: __u32, + pub bpf_sock_ops_cb_flags: __u32, + pub state: __u32, + pub rtt_min: __u32, + pub snd_ssthresh: __u32, + pub rcv_nxt: __u32, + pub snd_nxt: __u32, + pub snd_una: __u32, + pub mss_cache: __u32, + pub ecn_flags: __u32, + pub rate_delivered: __u32, + pub rate_interval_us: __u32, + pub packets_out: __u32, + pub retrans_out: __u32, + pub total_retrans: __u32, + pub segs_in: __u32, + pub data_segs_in: __u32, + pub segs_out: __u32, + pub data_segs_out: __u32, + pub lost_out: __u32, + pub sacked_out: __u32, + pub sk_txhash: __u32, + pub bytes_received: __u64, + pub bytes_acked: __u64, + pub __bindgen_anon_2: bpf_sock_ops__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_ops__bindgen_ty_1 { + pub args: [__u32; 4usize], + pub reply: __u32, + pub replylong: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_sock_ops__bindgen_ty_2 { + pub sk: *mut bpf_sock, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + _bindgen_union_align: u64, +} +impl bpf_sock_ops__bindgen_ty_2 { + #[inline] + pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit + } +} +pub const BPF_SOCK_OPS_VOID: ::aya_bpf_cty::c_uint = 0; +pub const BPF_SOCK_OPS_TIMEOUT_INIT: ::aya_bpf_cty::c_uint = 1; +pub const BPF_SOCK_OPS_RWND_INIT: ::aya_bpf_cty::c_uint = 2; +pub const BPF_SOCK_OPS_TCP_CONNECT_CB: ::aya_bpf_cty::c_uint = 3; +pub const BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB: ::aya_bpf_cty::c_uint = 4; +pub const BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB: ::aya_bpf_cty::c_uint = 5; +pub const BPF_SOCK_OPS_NEEDS_ECN: ::aya_bpf_cty::c_uint = 6; +pub const BPF_SOCK_OPS_BASE_RTT: ::aya_bpf_cty::c_uint = 7; +pub const BPF_SOCK_OPS_RTO_CB: ::aya_bpf_cty::c_uint = 8; +pub const BPF_SOCK_OPS_RETRANS_CB: ::aya_bpf_cty::c_uint = 9; +pub const BPF_SOCK_OPS_STATE_CB: ::aya_bpf_cty::c_uint = 10; +pub const BPF_SOCK_OPS_TCP_LISTEN_CB: ::aya_bpf_cty::c_uint = 11; +pub const BPF_SOCK_OPS_RTT_CB: ::aya_bpf_cty::c_uint = 12; +pub type _bindgen_ty_2 = ::aya_bpf_cty::c_uint; +pub const BPF_TCP_ESTABLISHED: ::aya_bpf_cty::c_uint = 1; +pub const BPF_TCP_SYN_SENT: ::aya_bpf_cty::c_uint = 2; +pub const BPF_TCP_SYN_RECV: ::aya_bpf_cty::c_uint = 3; +pub const BPF_TCP_FIN_WAIT1: ::aya_bpf_cty::c_uint = 4; +pub const BPF_TCP_FIN_WAIT2: ::aya_bpf_cty::c_uint = 5; +pub const BPF_TCP_TIME_WAIT: ::aya_bpf_cty::c_uint = 6; +pub const BPF_TCP_CLOSE: ::aya_bpf_cty::c_uint = 7; +pub const BPF_TCP_CLOSE_WAIT: ::aya_bpf_cty::c_uint = 8; +pub const BPF_TCP_LAST_ACK: ::aya_bpf_cty::c_uint = 9; +pub const BPF_TCP_LISTEN: ::aya_bpf_cty::c_uint = 10; +pub const BPF_TCP_CLOSING: ::aya_bpf_cty::c_uint = 11; +pub const BPF_TCP_NEW_SYN_RECV: ::aya_bpf_cty::c_uint = 12; +pub const BPF_TCP_MAX_STATES: ::aya_bpf_cty::c_uint = 13; +pub type _bindgen_ty_3 = ::aya_bpf_cty::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_perf_event_value { + pub counter: __u64, + pub enabled: __u64, + pub running: __u64, +} +pub const BPF_FIB_LKUP_RET_SUCCESS: ::aya_bpf_cty::c_uint = 0; +pub const BPF_FIB_LKUP_RET_BLACKHOLE: ::aya_bpf_cty::c_uint = 1; +pub const BPF_FIB_LKUP_RET_UNREACHABLE: ::aya_bpf_cty::c_uint = 2; +pub const BPF_FIB_LKUP_RET_PROHIBIT: ::aya_bpf_cty::c_uint = 3; +pub const BPF_FIB_LKUP_RET_NOT_FWDED: ::aya_bpf_cty::c_uint = 4; +pub const BPF_FIB_LKUP_RET_FWD_DISABLED: ::aya_bpf_cty::c_uint = 5; +pub const BPF_FIB_LKUP_RET_UNSUPP_LWT: ::aya_bpf_cty::c_uint = 6; +pub const BPF_FIB_LKUP_RET_NO_NEIGH: ::aya_bpf_cty::c_uint = 7; +pub const BPF_FIB_LKUP_RET_FRAG_NEEDED: ::aya_bpf_cty::c_uint = 8; +pub type _bindgen_ty_4 = ::aya_bpf_cty::c_uint; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_fib_lookup { + pub family: __u8, + pub l4_protocol: __u8, + pub sport: __be16, + pub dport: __be16, + pub tot_len: __u16, + pub ifindex: __u32, + pub __bindgen_anon_1: bpf_fib_lookup__bindgen_ty_1, + pub __bindgen_anon_2: bpf_fib_lookup__bindgen_ty_2, + pub __bindgen_anon_3: bpf_fib_lookup__bindgen_ty_3, + pub h_vlan_proto: __be16, + pub h_vlan_TCI: __be16, + pub smac: [__u8; 6usize], + pub dmac: [__u8; 6usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_1 { + pub tos: __u8, + pub flowinfo: __be32, + pub rt_metric: __u32, + _bindgen_union_align: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_2 { + pub ipv4_src: __be32, + pub ipv6_src: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_fib_lookup__bindgen_ty_3 { + pub ipv4_dst: __be32, + pub ipv6_dst: [__u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bpf_flow_keys { + pub nhoff: __u16, + pub thoff: __u16, + pub addr_proto: __u16, + pub is_frag: __u8, + pub is_first_frag: __u8, + pub is_encap: __u8, + pub ip_proto: __u8, + pub n_proto: __be16, + pub sport: __be16, + pub dport: __be16, + pub __bindgen_anon_1: bpf_flow_keys__bindgen_ty_1, + pub flags: __u32, + pub flow_label: __be32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bpf_flow_keys__bindgen_ty_1 { + pub __bindgen_anon_1: bpf_flow_keys__bindgen_ty_1__bindgen_ty_1, + pub __bindgen_anon_2: bpf_flow_keys__bindgen_ty_1__bindgen_ty_2, + _bindgen_union_align: [u32; 8usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_flow_keys__bindgen_ty_1__bindgen_ty_1 { + pub ipv4_src: __be32, + pub ipv4_dst: __be32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_flow_keys__bindgen_ty_1__bindgen_ty_2 { + pub ipv6_src: [__u32; 4usize], + pub ipv6_dst: [__u32; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_spin_lock { + pub val: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_sysctl { + pub write: __u32, + pub file_pos: __u32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pt_regs { + pub r15: ::aya_bpf_cty::c_ulong, + pub r14: ::aya_bpf_cty::c_ulong, + pub r13: ::aya_bpf_cty::c_ulong, + pub r12: ::aya_bpf_cty::c_ulong, + pub rbp: ::aya_bpf_cty::c_ulong, + pub rbx: ::aya_bpf_cty::c_ulong, + pub r11: ::aya_bpf_cty::c_ulong, + pub r10: ::aya_bpf_cty::c_ulong, + pub r9: ::aya_bpf_cty::c_ulong, + pub r8: ::aya_bpf_cty::c_ulong, + pub rax: ::aya_bpf_cty::c_ulong, + pub rcx: ::aya_bpf_cty::c_ulong, + pub rdx: ::aya_bpf_cty::c_ulong, + pub rsi: ::aya_bpf_cty::c_ulong, + pub rdi: ::aya_bpf_cty::c_ulong, + pub orig_rax: ::aya_bpf_cty::c_ulong, + pub rip: ::aya_bpf_cty::c_ulong, + pub cs: ::aya_bpf_cty::c_ulong, + pub eflags: ::aya_bpf_cty::c_ulong, + pub rsp: ::aya_bpf_cty::c_ulong, + pub ss: ::aya_bpf_cty::c_ulong, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_perf_event_data { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_pidns_info { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_redir_neigh { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct linux_binprm { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sockaddr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcphdr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct seq_file { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp6_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_timewait_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tcp_request_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct udp6_sock { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct task_struct { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct path { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct btf_ptr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct inode { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct socket { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct file { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bpf_map_def { + pub type_: ::aya_bpf_cty::c_uint, + pub key_size: ::aya_bpf_cty::c_uint, + pub value_size: ::aya_bpf_cty::c_uint, + pub max_entries: ::aya_bpf_cty::c_uint, + pub map_flags: ::aya_bpf_cty::c_uint, +} diff --git a/bpf/aya-bpf-bindings/src/x86_64/getters.rs b/bpf/aya-bpf-bindings/src/x86_64/getters.rs new file mode 100644 index 00000000..4ae58f40 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/x86_64/getters.rs @@ -0,0 +1,997 @@ +use super::bindings::*; +impl __BindgenBitfieldUnit {} +impl __sk_buff { + pub fn len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.len) }.ok() + } + pub fn pkt_type(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.pkt_type) }.ok() + } + pub fn mark(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mark) }.ok() + } + pub fn queue_mapping(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.queue_mapping) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn vlan_present(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_present) }.ok() + } + pub fn vlan_tci(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_tci) }.ok() + } + pub fn vlan_proto(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.vlan_proto) }.ok() + } + pub fn priority(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.priority) }.ok() + } + pub fn ingress_ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ingress_ifindex) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn tc_index(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tc_index) }.ok() + } + pub fn cb(&self) -> Option<[__u32; 5usize]> { + unsafe { crate::bpf_probe_read(&self.cb) }.ok() + } + pub fn hash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.hash) }.ok() + } + pub fn tc_classid(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tc_classid) }.ok() + } + pub fn data(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data) }.ok() + } + pub fn data_end(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_end) }.ok() + } + pub fn napi_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.napi_id) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn data_meta(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_meta) }.ok() + } + pub fn flow_keys(&self) -> Option<*mut bpf_flow_keys> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.flow_keys) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn tstamp(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.tstamp) }.ok() + } + pub fn wire_len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.wire_len) }.ok() + } + pub fn gso_segs(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.gso_segs) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl __sk_buff__bindgen_ty_1 { + pub fn flow_keys(&self) -> Option<*mut bpf_flow_keys> { + let v = unsafe { crate::bpf_probe_read(&self.flow_keys) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl __sk_buff__bindgen_ty_2 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_tunnel_key { + pub fn tunnel_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tunnel_id) }.ok() + } + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv6) }.ok() + } + pub fn tunnel_tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tunnel_tos) }.ok() + } + pub fn tunnel_ttl(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tunnel_ttl) }.ok() + } + pub fn tunnel_ext(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.tunnel_ext) }.ok() + } + pub fn tunnel_label(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.tunnel_label) }.ok() + } +} +impl bpf_tunnel_key__bindgen_ty_1 { + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ipv6) }.ok() + } +} +impl bpf_xfrm_state { + pub fn reqid(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.reqid) }.ok() + } + pub fn spi(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.spi) }.ok() + } + pub fn family(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn ext(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.ext) }.ok() + } + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.remote_ipv6) }.ok() + } +} +impl bpf_xfrm_state__bindgen_ty_1 { + pub fn remote_ipv4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ipv4) }.ok() + } + pub fn remote_ipv6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ipv6) }.ok() + } +} +impl bpf_sock { + pub fn bound_dev_if(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bound_dev_if) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn mark(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mark) }.ok() + } + pub fn priority(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.priority) }.ok() + } + pub fn src_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.src_ip4) }.ok() + } + pub fn src_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.src_ip6) }.ok() + } + pub fn src_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.src_port) }.ok() + } + pub fn dst_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dst_port) }.ok() + } + pub fn dst_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dst_ip4) }.ok() + } + pub fn dst_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.dst_ip6) }.ok() + } + pub fn state(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.state) }.ok() + } +} +impl bpf_tcp_sock { + pub fn snd_cwnd(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_cwnd) }.ok() + } + pub fn srtt_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.srtt_us) }.ok() + } + pub fn rtt_min(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rtt_min) }.ok() + } + pub fn snd_ssthresh(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_ssthresh) }.ok() + } + pub fn rcv_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rcv_nxt) }.ok() + } + pub fn snd_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_nxt) }.ok() + } + pub fn snd_una(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_una) }.ok() + } + pub fn mss_cache(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mss_cache) }.ok() + } + pub fn ecn_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ecn_flags) }.ok() + } + pub fn rate_delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_delivered) }.ok() + } + pub fn rate_interval_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_interval_us) }.ok() + } + pub fn packets_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.packets_out) }.ok() + } + pub fn retrans_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.retrans_out) }.ok() + } + pub fn total_retrans(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.total_retrans) }.ok() + } + pub fn segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_in) }.ok() + } + pub fn data_segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_in) }.ok() + } + pub fn segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_out) }.ok() + } + pub fn data_segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_out) }.ok() + } + pub fn lost_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.lost_out) }.ok() + } + pub fn sacked_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sacked_out) }.ok() + } + pub fn bytes_received(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_received) }.ok() + } + pub fn bytes_acked(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_acked) }.ok() + } + pub fn dsack_dups(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.dsack_dups) }.ok() + } + pub fn delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.delivered) }.ok() + } + pub fn delivered_ce(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.delivered_ce) }.ok() + } + pub fn icsk_retransmits(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.icsk_retransmits) }.ok() + } +} +impl bpf_sock_tuple { + pub fn ipv4(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4) }.ok() + } + pub fn ipv6(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv6) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1 { + pub fn ipv4(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.ipv4) }.ok() + } + pub fn ipv6(&self) -> Option { + unsafe { crate::bpf_probe_read(&self.ipv6) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1__bindgen_ty_1 { + pub fn saddr(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.saddr) }.ok() + } + pub fn daddr(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.daddr) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } +} +impl bpf_sock_tuple__bindgen_ty_1__bindgen_ty_2 { + pub fn saddr(&self) -> Option<[__be32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.saddr) }.ok() + } + pub fn daddr(&self) -> Option<[__be32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.daddr) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } +} +impl xdp_md { + pub fn data(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data) }.ok() + } + pub fn data_end(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_end) }.ok() + } + pub fn data_meta(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_meta) }.ok() + } + pub fn ingress_ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ingress_ifindex) }.ok() + } + pub fn rx_queue_index(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rx_queue_index) }.ok() + } +} +impl sk_msg_md { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.size) }.ok() + } +} +impl sk_msg_md__bindgen_ty_1 { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_msg_md__bindgen_ty_2 { + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_reuseport_md { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } + pub fn len(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.len) }.ok() + } + pub fn eth_protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.eth_protocol) }.ok() + } + pub fn ip_protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ip_protocol) }.ok() + } + pub fn bind_inany(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bind_inany) }.ok() + } + pub fn hash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.hash) }.ok() + } +} +impl sk_reuseport_md__bindgen_ty_1 { + pub fn data(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl sk_reuseport_md__bindgen_ty_2 { + pub fn data_end(&self) -> Option<*mut ::aya_bpf_cty::c_void> { + let v = unsafe { crate::bpf_probe_read(&self.data_end) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_map_info { + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.id) }.ok() + } + pub fn key_size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.key_size) }.ok() + } + pub fn value_size(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.value_size) }.ok() + } + pub fn max_entries(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.max_entries) }.ok() + } + pub fn map_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.map_flags) }.ok() + } + pub fn name(&self) -> Option<[::aya_bpf_cty::c_char; 16usize]> { + unsafe { crate::bpf_probe_read(&self.name) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn netns_dev(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.netns_dev) }.ok() + } + pub fn netns_ino(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.netns_ino) }.ok() + } + pub fn btf_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_id) }.ok() + } + pub fn btf_key_type_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_key_type_id) }.ok() + } + pub fn btf_value_type_id(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.btf_value_type_id) }.ok() + } +} +impl bpf_sock_addr { + pub fn user_family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_family) }.ok() + } + pub fn user_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_ip4) }.ok() + } + pub fn user_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.user_ip6) }.ok() + } + pub fn user_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.user_port) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn type_(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn protocol(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.protocol) }.ok() + } + pub fn msg_src_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.msg_src_ip4) }.ok() + } + pub fn msg_src_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.msg_src_ip6) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_addr__bindgen_ty_1 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_ops { + pub fn op(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.op) }.ok() + } + pub fn args(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.args) }.ok() + } + pub fn reply(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.reply) }.ok() + } + pub fn replylong(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.replylong) }.ok() + } + pub fn family(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn remote_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_ip4) }.ok() + } + pub fn local_ip4(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_ip4) }.ok() + } + pub fn remote_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.remote_ip6) }.ok() + } + pub fn local_ip6(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.local_ip6) }.ok() + } + pub fn remote_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.remote_port) }.ok() + } + pub fn local_port(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.local_port) }.ok() + } + pub fn is_fullsock(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.is_fullsock) }.ok() + } + pub fn snd_cwnd(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_cwnd) }.ok() + } + pub fn srtt_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.srtt_us) }.ok() + } + pub fn bpf_sock_ops_cb_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.bpf_sock_ops_cb_flags) }.ok() + } + pub fn state(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.state) }.ok() + } + pub fn rtt_min(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rtt_min) }.ok() + } + pub fn snd_ssthresh(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_ssthresh) }.ok() + } + pub fn rcv_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rcv_nxt) }.ok() + } + pub fn snd_nxt(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_nxt) }.ok() + } + pub fn snd_una(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.snd_una) }.ok() + } + pub fn mss_cache(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.mss_cache) }.ok() + } + pub fn ecn_flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ecn_flags) }.ok() + } + pub fn rate_delivered(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_delivered) }.ok() + } + pub fn rate_interval_us(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rate_interval_us) }.ok() + } + pub fn packets_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.packets_out) }.ok() + } + pub fn retrans_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.retrans_out) }.ok() + } + pub fn total_retrans(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.total_retrans) }.ok() + } + pub fn segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_in) }.ok() + } + pub fn data_segs_in(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_in) }.ok() + } + pub fn segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.segs_out) }.ok() + } + pub fn data_segs_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.data_segs_out) }.ok() + } + pub fn lost_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.lost_out) }.ok() + } + pub fn sacked_out(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sacked_out) }.ok() + } + pub fn sk_txhash(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.sk_txhash) }.ok() + } + pub fn bytes_received(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_received) }.ok() + } + pub fn bytes_acked(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.bytes_acked) }.ok() + } + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_sock_ops__bindgen_ty_1 { + pub fn args(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.args) }.ok() + } + pub fn reply(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.reply) }.ok() + } + pub fn replylong(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.replylong) }.ok() + } +} +impl bpf_sock_ops__bindgen_ty_2 { + pub fn sk(&self) -> Option<*mut bpf_sock> { + let v = unsafe { crate::bpf_probe_read(&self.sk) }.ok()?; + if v.is_null() { + None + } else { + Some(v) + } + } +} +impl bpf_perf_event_value { + pub fn counter(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.counter) }.ok() + } + pub fn enabled(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.enabled) }.ok() + } + pub fn running(&self) -> Option<__u64> { + unsafe { crate::bpf_probe_read(&self.running) }.ok() + } +} +impl bpf_fib_lookup { + pub fn family(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.family) }.ok() + } + pub fn l4_protocol(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.l4_protocol) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } + pub fn tot_len(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.tot_len) }.ok() + } + pub fn ifindex(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.ifindex) }.ok() + } + pub fn tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.tos) }.ok() + } + pub fn flowinfo(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.flowinfo) }.ok() + } + pub fn rt_metric(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.rt_metric) }.ok() + } + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv4_src) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_3.ipv4_dst) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_3.ipv6_dst) }.ok() + } + pub fn h_vlan_proto(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.h_vlan_proto) }.ok() + } + pub fn h_vlan_TCI(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.h_vlan_TCI) }.ok() + } + pub fn smac(&self) -> Option<[__u8; 6usize]> { + unsafe { crate::bpf_probe_read(&self.smac) }.ok() + } + pub fn dmac(&self) -> Option<[__u8; 6usize]> { + unsafe { crate::bpf_probe_read(&self.dmac) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_1 { + pub fn tos(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.tos) }.ok() + } + pub fn flowinfo(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.flowinfo) }.ok() + } + pub fn rt_metric(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.rt_metric) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_2 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_src) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_src) }.ok() + } +} +impl bpf_fib_lookup__bindgen_ty_3 { + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_dst) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_dst) }.ok() + } +} +impl bpf_flow_keys { + pub fn nhoff(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.nhoff) }.ok() + } + pub fn thoff(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.thoff) }.ok() + } + pub fn addr_proto(&self) -> Option<__u16> { + unsafe { crate::bpf_probe_read(&self.addr_proto) }.ok() + } + pub fn is_frag(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_frag) }.ok() + } + pub fn is_first_frag(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_first_frag) }.ok() + } + pub fn is_encap(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.is_encap) }.ok() + } + pub fn ip_proto(&self) -> Option<__u8> { + unsafe { crate::bpf_probe_read(&self.ip_proto) }.ok() + } + pub fn n_proto(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.n_proto) }.ok() + } + pub fn sport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.sport) }.ok() + } + pub fn dport(&self) -> Option<__be16> { + unsafe { crate::bpf_probe_read(&self.dport) }.ok() + } + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_1.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_1.ipv4_dst) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.__bindgen_anon_2.ipv6_dst) }.ok() + } + pub fn flags(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.flags) }.ok() + } + pub fn flow_label(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.flow_label) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_1.ipv4_dst) }.ok() + } + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.__bindgen_anon_2.ipv6_dst) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1__bindgen_ty_1 { + pub fn ipv4_src(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_src) }.ok() + } + pub fn ipv4_dst(&self) -> Option<__be32> { + unsafe { crate::bpf_probe_read(&self.ipv4_dst) }.ok() + } +} +impl bpf_flow_keys__bindgen_ty_1__bindgen_ty_2 { + pub fn ipv6_src(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_src) }.ok() + } + pub fn ipv6_dst(&self) -> Option<[__u32; 4usize]> { + unsafe { crate::bpf_probe_read(&self.ipv6_dst) }.ok() + } +} +impl bpf_spin_lock { + pub fn val(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.val) }.ok() + } +} +impl bpf_sysctl { + pub fn write(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.write) }.ok() + } + pub fn file_pos(&self) -> Option<__u32> { + unsafe { crate::bpf_probe_read(&self.file_pos) }.ok() + } +} +impl pt_regs { + pub fn r15(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r15) }.ok() + } + pub fn r14(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r14) }.ok() + } + pub fn r13(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r13) }.ok() + } + pub fn r12(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r12) }.ok() + } + pub fn rbp(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rbp) }.ok() + } + pub fn rbx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rbx) }.ok() + } + pub fn r11(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r11) }.ok() + } + pub fn r10(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r10) }.ok() + } + pub fn r9(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r9) }.ok() + } + pub fn r8(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.r8) }.ok() + } + pub fn rax(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rax) }.ok() + } + pub fn rcx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rcx) }.ok() + } + pub fn rdx(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rdx) }.ok() + } + pub fn rsi(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rsi) }.ok() + } + pub fn rdi(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rdi) }.ok() + } + pub fn orig_rax(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.orig_rax) }.ok() + } + pub fn rip(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rip) }.ok() + } + pub fn cs(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.cs) }.ok() + } + pub fn eflags(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.eflags) }.ok() + } + pub fn rsp(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.rsp) }.ok() + } + pub fn ss(&self) -> Option<::aya_bpf_cty::c_ulong> { + unsafe { crate::bpf_probe_read(&self.ss) }.ok() + } +} +impl bpf_perf_event_data {} +impl bpf_pidns_info {} +impl bpf_redir_neigh {} +impl linux_binprm {} +impl sockaddr {} +impl tcphdr {} +impl seq_file {} +impl tcp6_sock {} +impl tcp_sock {} +impl tcp_timewait_sock {} +impl tcp_request_sock {} +impl udp6_sock {} +impl task_struct {} +impl path {} +impl btf_ptr {} +impl inode {} +impl socket {} +impl file {} +impl bpf_map_def { + pub fn type_(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.type_) }.ok() + } + pub fn key_size(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.key_size) }.ok() + } + pub fn value_size(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.value_size) }.ok() + } + pub fn max_entries(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.max_entries) }.ok() + } + pub fn map_flags(&self) -> Option<::aya_bpf_cty::c_uint> { + unsafe { crate::bpf_probe_read(&self.map_flags) }.ok() + } +} diff --git a/bpf/aya-bpf-bindings/src/x86_64/helpers.rs b/bpf/aya-bpf-bindings/src/x86_64/helpers.rs new file mode 100644 index 00000000..f3b185a4 --- /dev/null +++ b/bpf/aya-bpf-bindings/src/x86_64/helpers.rs @@ -0,0 +1,1681 @@ +use super::bindings::*; +pub unsafe fn bpf_map_lookup_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(1usize); + fun(map, key) +} +pub unsafe fn bpf_map_update_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(2usize); + fun(map, key, value, flags) +} +pub unsafe fn bpf_map_delete_elem( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(3usize); + fun(map, key) +} +pub unsafe fn bpf_probe_read( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(4usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_ktime_get_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(5usize); + fun() +} +pub unsafe fn bpf_get_prandom_u32() -> __u32 { + let fun: unsafe extern "C" fn() -> __u32 = ::core::mem::transmute(7usize); + fun() +} +pub unsafe fn bpf_get_smp_processor_id() -> __u32 { + let fun: unsafe extern "C" fn() -> __u32 = ::core::mem::transmute(8usize); + fun() +} +pub unsafe fn bpf_skb_store_bytes( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(9usize); + fun(skb, offset, from, len, flags) +} +pub unsafe fn bpf_l3_csum_replace( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(10usize); + fun(skb, offset, from, to, size) +} +pub unsafe fn bpf_l4_csum_replace( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: __u64, + to: __u64, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(11usize); + fun(skb, offset, from, to, flags) +} +pub unsafe fn bpf_tail_call( + ctx: *mut ::aya_bpf_cty::c_void, + prog_array_map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + prog_array_map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(12usize); + fun(ctx, prog_array_map, index) +} +pub unsafe fn bpf_clone_redirect( + skb: *mut __sk_buff, + ifindex: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + ifindex: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(13usize); + fun(skb, ifindex, flags) +} +pub unsafe fn bpf_get_current_pid_tgid() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(14usize); + fun() +} +pub unsafe fn bpf_get_current_uid_gid() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(15usize); + fun() +} +pub unsafe fn bpf_get_current_comm( + buf: *mut ::aya_bpf_cty::c_void, + size_of_buf: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *mut ::aya_bpf_cty::c_void, + size_of_buf: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(16usize); + fun(buf, size_of_buf) +} +pub unsafe fn bpf_get_cgroup_classid(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(17usize); + fun(skb) +} +pub unsafe fn bpf_skb_vlan_push( + skb: *mut __sk_buff, + vlan_proto: __be16, + vlan_tci: __u16, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + vlan_proto: __be16, + vlan_tci: __u16, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(18usize); + fun(skb, vlan_proto, vlan_tci) +} +pub unsafe fn bpf_skb_vlan_pop(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(19usize); + fun(skb) +} +pub unsafe fn bpf_skb_get_tunnel_key( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(20usize); + fun(skb, key, size, flags) +} +pub unsafe fn bpf_skb_set_tunnel_key( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + key: *mut bpf_tunnel_key, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(21usize); + fun(skb, key, size, flags) +} +pub unsafe fn bpf_perf_event_read(map: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 { + let fun: unsafe extern "C" fn(map: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 = + ::core::mem::transmute(22usize); + fun(map, flags) +} +pub unsafe fn bpf_redirect(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(23usize); + fun(ifindex, flags) +} +pub unsafe fn bpf_get_route_realm(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(24usize); + fun(skb) +} +pub unsafe fn bpf_perf_event_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(25usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_skb_load_bytes( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(26usize); + fun(skb, offset, to, len) +} +pub unsafe fn bpf_get_stackid( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(27usize); + fun(ctx, map, flags) +} +pub unsafe fn bpf_csum_diff( + from: *mut __be32, + from_size: __u32, + to: *mut __be32, + to_size: __u32, + seed: __wsum, +) -> __s64 { + let fun: unsafe extern "C" fn( + from: *mut __be32, + from_size: __u32, + to: *mut __be32, + to_size: __u32, + seed: __wsum, + ) -> __s64 = ::core::mem::transmute(28usize); + fun(from, from_size, to, to_size, seed) +} +pub unsafe fn bpf_skb_get_tunnel_opt( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(29usize); + fun(skb, opt, size) +} +pub unsafe fn bpf_skb_set_tunnel_opt( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + opt: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(30usize); + fun(skb, opt, size) +} +pub unsafe fn bpf_skb_change_proto( + skb: *mut __sk_buff, + proto: __be16, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + proto: __be16, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(31usize); + fun(skb, proto, flags) +} +pub unsafe fn bpf_skb_change_type(skb: *mut __sk_buff, type_: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, type_: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(32usize); + fun(skb, type_) +} +pub unsafe fn bpf_skb_under_cgroup( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(33usize); + fun(skb, map, index) +} +pub unsafe fn bpf_get_hash_recalc(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(34usize); + fun(skb) +} +pub unsafe fn bpf_get_current_task() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(35usize); + fun() +} +pub unsafe fn bpf_probe_write_user( + dst: *mut ::aya_bpf_cty::c_void, + src: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + src: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(36usize); + fun(dst, src, len) +} +pub unsafe fn bpf_current_task_under_cgroup( + map: *mut ::aya_bpf_cty::c_void, + index: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + index: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(37usize); + fun(map, index) +} +pub unsafe fn bpf_skb_change_tail( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(38usize); + fun(skb, len, flags) +} +pub unsafe fn bpf_skb_pull_data(skb: *mut __sk_buff, len: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, len: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(39usize); + fun(skb, len) +} +pub unsafe fn bpf_csum_update(skb: *mut __sk_buff, csum: __wsum) -> __s64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, csum: __wsum) -> __s64 = + ::core::mem::transmute(40usize); + fun(skb, csum) +} +pub unsafe fn bpf_set_hash_invalid(skb: *mut __sk_buff) { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) = ::core::mem::transmute(41usize); + fun(skb) +} +pub unsafe fn bpf_get_numa_node_id() -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn() -> ::aya_bpf_cty::c_long = ::core::mem::transmute(42usize); + fun() +} +pub unsafe fn bpf_skb_change_head( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(43usize); + fun(skb, len, flags) +} +pub unsafe fn bpf_xdp_adjust_head( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(44usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_probe_read_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(45usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_get_socket_cookie(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(46usize); + fun(ctx) +} +pub unsafe fn bpf_get_socket_uid(skb: *mut __sk_buff) -> __u32 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u32 = ::core::mem::transmute(47usize); + fun(skb) +} +pub unsafe fn bpf_set_hash(skb: *mut __sk_buff, hash: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, hash: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(48usize); + fun(skb, hash) +} +pub unsafe fn bpf_setsockopt( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(49usize); + fun(bpf_socket, level, optname, optval, optlen) +} +pub unsafe fn bpf_skb_adjust_room( + skb: *mut __sk_buff, + len_diff: __s32, + mode: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + len_diff: __s32, + mode: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(50usize); + fun(skb, len_diff, mode, flags) +} +pub unsafe fn bpf_redirect_map( + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(51usize); + fun(map, key, flags) +} +pub unsafe fn bpf_sk_redirect_map( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(52usize); + fun(skb, map, key, flags) +} +pub unsafe fn bpf_sock_map_update( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(53usize); + fun(skops, map, key, flags) +} +pub unsafe fn bpf_xdp_adjust_meta( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(54usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_perf_event_read_value( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + buf: *mut bpf_perf_event_value, + buf_size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + buf: *mut bpf_perf_event_value, + buf_size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(55usize); + fun(map, flags, buf, buf_size) +} +pub unsafe fn bpf_perf_prog_read_value( + ctx: *mut bpf_perf_event_data, + buf: *mut bpf_perf_event_value, + buf_size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_perf_event_data, + buf: *mut bpf_perf_event_value, + buf_size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(56usize); + fun(ctx, buf, buf_size) +} +pub unsafe fn bpf_getsockopt( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_socket: *mut ::aya_bpf_cty::c_void, + level: ::aya_bpf_cty::c_int, + optname: ::aya_bpf_cty::c_int, + optval: *mut ::aya_bpf_cty::c_void, + optlen: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(57usize); + fun(bpf_socket, level, optname, optval, optlen) +} +pub unsafe fn bpf_override_return(regs: *mut pt_regs, rc: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(regs: *mut pt_regs, rc: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(58usize); + fun(regs, rc) +} +pub unsafe fn bpf_sock_ops_cb_flags_set( + bpf_sock: *mut bpf_sock_ops, + argval: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + bpf_sock: *mut bpf_sock_ops, + argval: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(59usize); + fun(bpf_sock, argval) +} +pub unsafe fn bpf_msg_redirect_map( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(60usize); + fun(msg, map, key, flags) +} +pub unsafe fn bpf_msg_apply_bytes(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(61usize); + fun(msg, bytes) +} +pub unsafe fn bpf_msg_cork_bytes(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(msg: *mut sk_msg_md, bytes: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(62usize); + fun(msg, bytes) +} +pub unsafe fn bpf_msg_pull_data( + msg: *mut sk_msg_md, + start: __u32, + end: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + end: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(63usize); + fun(msg, start, end, flags) +} +pub unsafe fn bpf_bind( + ctx: *mut bpf_sock_addr, + addr: *mut sockaddr, + addr_len: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sock_addr, + addr: *mut sockaddr, + addr_len: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(64usize); + fun(ctx, addr, addr_len) +} +pub unsafe fn bpf_xdp_adjust_tail( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + xdp_md: *mut xdp_md, + delta: ::aya_bpf_cty::c_int, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(65usize); + fun(xdp_md, delta) +} +pub unsafe fn bpf_skb_get_xfrm_state( + skb: *mut __sk_buff, + index: __u32, + xfrm_state: *mut bpf_xfrm_state, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + index: __u32, + xfrm_state: *mut bpf_xfrm_state, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(66usize); + fun(skb, index, xfrm_state, size, flags) +} +pub unsafe fn bpf_get_stack( + ctx: *mut ::aya_bpf_cty::c_void, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(67usize); + fun(ctx, buf, size, flags) +} +pub unsafe fn bpf_skb_load_bytes_relative( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + start_header: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *const ::aya_bpf_cty::c_void, + offset: __u32, + to: *mut ::aya_bpf_cty::c_void, + len: __u32, + start_header: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(68usize); + fun(skb, offset, to, len, start_header) +} +pub unsafe fn bpf_fib_lookup( + ctx: *mut ::aya_bpf_cty::c_void, + params: *mut bpf_fib_lookup, + plen: ::aya_bpf_cty::c_int, + flags: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + params: *mut bpf_fib_lookup, + plen: ::aya_bpf_cty::c_int, + flags: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(69usize); + fun(ctx, params, plen, flags) +} +pub unsafe fn bpf_sock_hash_update( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(70usize); + fun(skops, map, key, flags) +} +pub unsafe fn bpf_msg_redirect_hash( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(71usize); + fun(msg, map, key, flags) +} +pub unsafe fn bpf_sk_redirect_hash( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(72usize); + fun(skb, map, key, flags) +} +pub unsafe fn bpf_lwt_push_encap( + skb: *mut __sk_buff, + type_: __u32, + hdr: *mut ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + type_: __u32, + hdr: *mut ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(73usize); + fun(skb, type_, hdr, len) +} +pub unsafe fn bpf_lwt_seg6_store_bytes( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(74usize); + fun(skb, offset, from, len) +} +pub unsafe fn bpf_lwt_seg6_adjust_srh( + skb: *mut __sk_buff, + offset: __u32, + delta: __s32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + offset: __u32, + delta: __s32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(75usize); + fun(skb, offset, delta) +} +pub unsafe fn bpf_lwt_seg6_action( + skb: *mut __sk_buff, + action: __u32, + param: *mut ::aya_bpf_cty::c_void, + param_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + action: __u32, + param: *mut ::aya_bpf_cty::c_void, + param_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(76usize); + fun(skb, action, param, param_len) +} +pub unsafe fn bpf_rc_repeat(ctx: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(77usize); + fun(ctx) +} +pub unsafe fn bpf_rc_keydown( + ctx: *mut ::aya_bpf_cty::c_void, + protocol: __u32, + scancode: __u64, + toggle: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + protocol: __u32, + scancode: __u64, + toggle: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(78usize); + fun(ctx, protocol, scancode, toggle) +} +pub unsafe fn bpf_skb_cgroup_id(skb: *mut __sk_buff) -> __u64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u64 = ::core::mem::transmute(79usize); + fun(skb) +} +pub unsafe fn bpf_get_current_cgroup_id() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(80usize); + fun() +} +pub unsafe fn bpf_get_local_storage( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(81usize); + fun(map, flags) +} +pub unsafe fn bpf_sk_select_reuseport( + reuse: *mut sk_reuseport_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + reuse: *mut sk_reuseport_md, + map: *mut ::aya_bpf_cty::c_void, + key: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(82usize); + fun(reuse, map, key, flags) +} +pub unsafe fn bpf_skb_ancestor_cgroup_id( + skb: *mut __sk_buff, + ancestor_level: ::aya_bpf_cty::c_int, +) -> __u64 { + let fun: unsafe extern "C" fn( + skb: *mut __sk_buff, + ancestor_level: ::aya_bpf_cty::c_int, + ) -> __u64 = ::core::mem::transmute(83usize); + fun(skb, ancestor_level) +} +pub unsafe fn bpf_sk_lookup_tcp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(84usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_sk_lookup_udp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(85usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_sk_release(sock: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sock: *mut ::aya_bpf_cty::c_void) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(86usize); + fun(sock) +} +pub unsafe fn bpf_map_push_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *const ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(87usize); + fun(map, value, flags) +} +pub unsafe fn bpf_map_pop_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(88usize); + fun(map, value) +} +pub unsafe fn bpf_map_peek_elem( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(89usize); + fun(map, value) +} +pub unsafe fn bpf_msg_push_data( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(90usize); + fun(msg, start, len, flags) +} +pub unsafe fn bpf_msg_pop_data( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + msg: *mut sk_msg_md, + start: __u32, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(91usize); + fun(msg, start, len, flags) +} +pub unsafe fn bpf_rc_pointer_rel( + ctx: *mut ::aya_bpf_cty::c_void, + rel_x: __s32, + rel_y: __s32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + rel_x: __s32, + rel_y: __s32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(92usize); + fun(ctx, rel_x, rel_y) +} +pub unsafe fn bpf_spin_lock(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(93usize); + fun(lock) +} +pub unsafe fn bpf_spin_unlock(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(lock: *mut bpf_spin_lock) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(94usize); + fun(lock) +} +pub unsafe fn bpf_sk_fullsock(sk: *mut bpf_sock) -> *mut bpf_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_sock = + ::core::mem::transmute(95usize); + fun(sk) +} +pub unsafe fn bpf_tcp_sock(sk: *mut bpf_sock) -> *mut bpf_tcp_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_tcp_sock = + ::core::mem::transmute(96usize); + fun(sk) +} +pub unsafe fn bpf_skb_ecn_set_ce(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(97usize); + fun(skb) +} +pub unsafe fn bpf_get_listener_sock(sk: *mut bpf_sock) -> *mut bpf_sock { + let fun: unsafe extern "C" fn(sk: *mut bpf_sock) -> *mut bpf_sock = + ::core::mem::transmute(98usize); + fun(sk) +} +pub unsafe fn bpf_skc_lookup_tcp( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, +) -> *mut bpf_sock { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + tuple: *mut bpf_sock_tuple, + tuple_size: __u32, + netns: __u64, + flags: __u64, + ) -> *mut bpf_sock = ::core::mem::transmute(99usize); + fun(ctx, tuple, tuple_size, netns, flags) +} +pub unsafe fn bpf_tcp_check_syncookie( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(100usize); + fun(sk, iph, iph_len, th, th_len) +} +pub unsafe fn bpf_sysctl_get_name( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(101usize); + fun(ctx, buf, buf_len, flags) +} +pub unsafe fn bpf_sysctl_get_current_value( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(102usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_sysctl_get_new_value( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *mut ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(103usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_sysctl_set_new_value( + ctx: *mut bpf_sysctl, + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_sysctl, + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(104usize); + fun(ctx, buf, buf_len) +} +pub unsafe fn bpf_strtol( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_long, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_long, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(105usize); + fun(buf, buf_len, flags, res) +} +pub unsafe fn bpf_strtoul( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_ulong, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + buf: *const ::aya_bpf_cty::c_char, + buf_len: ::aya_bpf_cty::c_ulong, + flags: __u64, + res: *mut ::aya_bpf_cty::c_ulong, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(106usize); + fun(buf, buf_len, flags, res) +} +pub unsafe fn bpf_sk_storage_get( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(107usize); + fun(map, sk, value, flags) +} +pub unsafe fn bpf_sk_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(108usize); + fun(map, sk) +} +pub unsafe fn bpf_send_signal(sig: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sig: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(109usize); + fun(sig) +} +pub unsafe fn bpf_tcp_gen_syncookie( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, +) -> __s64 { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + iph: *mut ::aya_bpf_cty::c_void, + iph_len: __u32, + th: *mut tcphdr, + th_len: __u32, + ) -> __s64 = ::core::mem::transmute(110usize); + fun(sk, iph, iph_len, th, th_len) +} +pub unsafe fn bpf_skb_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(111usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_probe_read_user( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(112usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_kernel( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(113usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_user_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(114usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_probe_read_kernel_str( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + unsafe_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(115usize); + fun(dst, size, unsafe_ptr) +} +pub unsafe fn bpf_tcp_send_ack( + tp: *mut ::aya_bpf_cty::c_void, + rcv_nxt: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + tp: *mut ::aya_bpf_cty::c_void, + rcv_nxt: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(116usize); + fun(tp, rcv_nxt) +} +pub unsafe fn bpf_send_signal_thread(sig: __u32) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(sig: __u32) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(117usize); + fun(sig) +} +pub unsafe fn bpf_jiffies64() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(118usize); + fun() +} +pub unsafe fn bpf_read_branch_records( + ctx: *mut bpf_perf_event_data, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut bpf_perf_event_data, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(119usize); + fun(ctx, buf, size, flags) +} +pub unsafe fn bpf_get_ns_current_pid_tgid( + dev: __u64, + ino: __u64, + nsdata: *mut bpf_pidns_info, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dev: __u64, + ino: __u64, + nsdata: *mut bpf_pidns_info, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(120usize); + fun(dev, ino, nsdata, size) +} +pub unsafe fn bpf_xdp_output( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + map: *mut ::aya_bpf_cty::c_void, + flags: __u64, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(121usize); + fun(ctx, map, flags, data, size) +} +pub unsafe fn bpf_get_netns_cookie(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(ctx: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(122usize); + fun(ctx) +} +pub unsafe fn bpf_get_current_ancestor_cgroup_id(ancestor_level: ::aya_bpf_cty::c_int) -> __u64 { + let fun: unsafe extern "C" fn(ancestor_level: ::aya_bpf_cty::c_int) -> __u64 = + ::core::mem::transmute(123usize); + fun(ancestor_level) +} +pub unsafe fn bpf_sk_assign( + ctx: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + sk: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(124usize); + fun(ctx, sk, flags) +} +pub unsafe fn bpf_ktime_get_boot_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(125usize); + fun() +} +pub unsafe fn bpf_seq_printf( + m: *mut seq_file, + fmt: *const ::aya_bpf_cty::c_char, + fmt_size: __u32, + data: *const ::aya_bpf_cty::c_void, + data_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + fmt: *const ::aya_bpf_cty::c_char, + fmt_size: __u32, + data: *const ::aya_bpf_cty::c_void, + data_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(126usize); + fun(m, fmt, fmt_size, data, data_len) +} +pub unsafe fn bpf_seq_write( + m: *mut seq_file, + data: *const ::aya_bpf_cty::c_void, + len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + data: *const ::aya_bpf_cty::c_void, + len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(127usize); + fun(m, data, len) +} +pub unsafe fn bpf_sk_cgroup_id(sk: *mut ::aya_bpf_cty::c_void) -> __u64 { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> __u64 = + ::core::mem::transmute(128usize); + fun(sk) +} +pub unsafe fn bpf_sk_ancestor_cgroup_id( + sk: *mut ::aya_bpf_cty::c_void, + ancestor_level: ::aya_bpf_cty::c_int, +) -> __u64 { + let fun: unsafe extern "C" fn( + sk: *mut ::aya_bpf_cty::c_void, + ancestor_level: ::aya_bpf_cty::c_int, + ) -> __u64 = ::core::mem::transmute(129usize); + fun(sk, ancestor_level) +} +pub unsafe fn bpf_ringbuf_output( + ringbuf: *mut ::aya_bpf_cty::c_void, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ringbuf: *mut ::aya_bpf_cty::c_void, + data: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(130usize); + fun(ringbuf, data, size, flags) +} +pub unsafe fn bpf_ringbuf_reserve( + ringbuf: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + ringbuf: *mut ::aya_bpf_cty::c_void, + size: __u64, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(131usize); + fun(ringbuf, size, flags) +} +pub unsafe fn bpf_ringbuf_submit(data: *mut ::aya_bpf_cty::c_void, flags: __u64) { + let fun: unsafe extern "C" fn(data: *mut ::aya_bpf_cty::c_void, flags: __u64) = + ::core::mem::transmute(132usize); + fun(data, flags) +} +pub unsafe fn bpf_ringbuf_discard(data: *mut ::aya_bpf_cty::c_void, flags: __u64) { + let fun: unsafe extern "C" fn(data: *mut ::aya_bpf_cty::c_void, flags: __u64) = + ::core::mem::transmute(133usize); + fun(data, flags) +} +pub unsafe fn bpf_ringbuf_query(ringbuf: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 { + let fun: unsafe extern "C" fn(ringbuf: *mut ::aya_bpf_cty::c_void, flags: __u64) -> __u64 = + ::core::mem::transmute(134usize); + fun(ringbuf, flags) +} +pub unsafe fn bpf_csum_level(skb: *mut __sk_buff, level: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff, level: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(135usize); + fun(skb, level) +} +pub unsafe fn bpf_skc_to_tcp6_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp6_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp6_sock = + ::core::mem::transmute(136usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_sock = + ::core::mem::transmute(137usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_timewait_sock( + sk: *mut ::aya_bpf_cty::c_void, +) -> *mut tcp_timewait_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_timewait_sock = + ::core::mem::transmute(138usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_tcp_request_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_request_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut tcp_request_sock = + ::core::mem::transmute(139usize); + fun(sk) +} +pub unsafe fn bpf_skc_to_udp6_sock(sk: *mut ::aya_bpf_cty::c_void) -> *mut udp6_sock { + let fun: unsafe extern "C" fn(sk: *mut ::aya_bpf_cty::c_void) -> *mut udp6_sock = + ::core::mem::transmute(140usize); + fun(sk) +} +pub unsafe fn bpf_get_task_stack( + task: *mut task_struct, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + task: *mut task_struct, + buf: *mut ::aya_bpf_cty::c_void, + size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(141usize); + fun(task, buf, size, flags) +} +pub unsafe fn bpf_load_hdr_opt( + skops: *mut bpf_sock_ops, + searchby_res: *mut ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + searchby_res: *mut ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(142usize); + fun(skops, searchby_res, len, flags) +} +pub unsafe fn bpf_store_hdr_opt( + skops: *mut bpf_sock_ops, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + from: *const ::aya_bpf_cty::c_void, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(143usize); + fun(skops, from, len, flags) +} +pub unsafe fn bpf_reserve_hdr_opt( + skops: *mut bpf_sock_ops, + len: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + skops: *mut bpf_sock_ops, + len: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(144usize); + fun(skops, len, flags) +} +pub unsafe fn bpf_inode_storage_get( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(145usize); + fun(map, inode, value, flags) +} +pub unsafe fn bpf_inode_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_int { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + inode: *mut ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_int = ::core::mem::transmute(146usize); + fun(map, inode) +} +pub unsafe fn bpf_d_path( + path: *mut path, + buf: *mut ::aya_bpf_cty::c_char, + sz: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + path: *mut path, + buf: *mut ::aya_bpf_cty::c_char, + sz: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(147usize); + fun(path, buf, sz) +} +pub unsafe fn bpf_copy_from_user( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + user_ptr: *const ::aya_bpf_cty::c_void, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + user_ptr: *const ::aya_bpf_cty::c_void, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(148usize); + fun(dst, size, user_ptr) +} +pub unsafe fn bpf_snprintf_btf( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + ptr: *mut btf_ptr, + btf_ptr_size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + ptr: *mut btf_ptr, + btf_ptr_size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(149usize); + fun(str_, str_size, ptr, btf_ptr_size, flags) +} +pub unsafe fn bpf_seq_printf_btf( + m: *mut seq_file, + ptr: *mut btf_ptr, + ptr_size: __u32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + m: *mut seq_file, + ptr: *mut btf_ptr, + ptr_size: __u32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(150usize); + fun(m, ptr, ptr_size, flags) +} +pub unsafe fn bpf_skb_cgroup_classid(skb: *mut __sk_buff) -> __u64 { + let fun: unsafe extern "C" fn(skb: *mut __sk_buff) -> __u64 = ::core::mem::transmute(151usize); + fun(skb) +} +pub unsafe fn bpf_redirect_neigh( + ifindex: __u32, + params: *mut bpf_redir_neigh, + plen: ::aya_bpf_cty::c_int, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ifindex: __u32, + params: *mut bpf_redir_neigh, + plen: ::aya_bpf_cty::c_int, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(152usize); + fun(ifindex, params, plen, flags) +} +pub unsafe fn bpf_per_cpu_ptr( + percpu_ptr: *const ::aya_bpf_cty::c_void, + cpu: __u32, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + percpu_ptr: *const ::aya_bpf_cty::c_void, + cpu: __u32, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(153usize); + fun(percpu_ptr, cpu) +} +pub unsafe fn bpf_this_cpu_ptr( + percpu_ptr: *const ::aya_bpf_cty::c_void, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + percpu_ptr: *const ::aya_bpf_cty::c_void, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(154usize); + fun(percpu_ptr) +} +pub unsafe fn bpf_redirect_peer(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(ifindex: __u32, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(155usize); + fun(ifindex, flags) +} +pub unsafe fn bpf_task_storage_get( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> *mut ::aya_bpf_cty::c_void { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + value: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> *mut ::aya_bpf_cty::c_void = ::core::mem::transmute(156usize); + fun(map, task, value, flags) +} +pub unsafe fn bpf_task_storage_delete( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + task: *mut task_struct, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(157usize); + fun(map, task) +} +pub unsafe fn bpf_get_current_task_btf() -> *mut task_struct { + let fun: unsafe extern "C" fn() -> *mut task_struct = ::core::mem::transmute(158usize); + fun() +} +pub unsafe fn bpf_bprm_opts_set(bprm: *mut linux_binprm, flags: __u64) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn(bprm: *mut linux_binprm, flags: __u64) -> ::aya_bpf_cty::c_long = + ::core::mem::transmute(159usize); + fun(bprm, flags) +} +pub unsafe fn bpf_ktime_get_coarse_ns() -> __u64 { + let fun: unsafe extern "C" fn() -> __u64 = ::core::mem::transmute(160usize); + fun() +} +pub unsafe fn bpf_ima_inode_hash( + inode: *mut inode, + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + inode: *mut inode, + dst: *mut ::aya_bpf_cty::c_void, + size: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(161usize); + fun(inode, dst, size) +} +pub unsafe fn bpf_sock_from_file(file: *mut file) -> *mut socket { + let fun: unsafe extern "C" fn(file: *mut file) -> *mut socket = + ::core::mem::transmute(162usize); + fun(file) +} +pub unsafe fn bpf_check_mtu( + ctx: *mut ::aya_bpf_cty::c_void, + ifindex: __u32, + mtu_len: *mut __u32, + len_diff: __s32, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + ctx: *mut ::aya_bpf_cty::c_void, + ifindex: __u32, + mtu_len: *mut __u32, + len_diff: __s32, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(163usize); + fun(ctx, ifindex, mtu_len, len_diff, flags) +} +pub unsafe fn bpf_for_each_map_elem( + map: *mut ::aya_bpf_cty::c_void, + callback_fn: *mut ::aya_bpf_cty::c_void, + callback_ctx: *mut ::aya_bpf_cty::c_void, + flags: __u64, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + map: *mut ::aya_bpf_cty::c_void, + callback_fn: *mut ::aya_bpf_cty::c_void, + callback_ctx: *mut ::aya_bpf_cty::c_void, + flags: __u64, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(164usize); + fun(map, callback_fn, callback_ctx, flags) +} +pub unsafe fn bpf_snprintf( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + fmt: *const ::aya_bpf_cty::c_char, + data: *mut __u64, + data_len: __u32, +) -> ::aya_bpf_cty::c_long { + let fun: unsafe extern "C" fn( + str_: *mut ::aya_bpf_cty::c_char, + str_size: __u32, + fmt: *const ::aya_bpf_cty::c_char, + data: *mut __u64, + data_len: __u32, + ) -> ::aya_bpf_cty::c_long = ::core::mem::transmute(165usize); + fun(str_, str_size, fmt, data, data_len) +}