/* Generated by ./gen_bpf_attr_check.sh from bpf_attr.h; do not edit. */ #include "defs.h" #ifdef HAVE_LINUX_BPF_H # include <linux/bpf.h> # include "bpf_attr.h" # include "static_assert.h" # ifdef HAVE_UNION_BPF_ATTR_MAP_TYPE static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_type) == sizeof_field(union bpf_attr, map_type), "BPF_MAP_CREATE_struct.map_type size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_type) == offsetof(union bpf_attr, map_type), "BPF_MAP_CREATE_struct.map_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_KEY_SIZE static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, key_size) == sizeof_field(union bpf_attr, key_size), "BPF_MAP_CREATE_struct.key_size size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, key_size) == offsetof(union bpf_attr, key_size), "BPF_MAP_CREATE_struct.key_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KEY_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_VALUE_SIZE static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, value_size) == sizeof_field(union bpf_attr, value_size), "BPF_MAP_CREATE_struct.value_size size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, value_size) == offsetof(union bpf_attr, value_size), "BPF_MAP_CREATE_struct.value_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_VALUE_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_MAX_ENTRIES static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, max_entries) == sizeof_field(union bpf_attr, max_entries), "BPF_MAP_CREATE_struct.max_entries size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, max_entries) == offsetof(union bpf_attr, max_entries), "BPF_MAP_CREATE_struct.max_entries offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAX_ENTRIES */ # ifdef HAVE_UNION_BPF_ATTR_MAP_FLAGS static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_flags) == sizeof_field(union bpf_attr, map_flags), "BPF_MAP_CREATE_struct.map_flags size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_flags) == offsetof(union bpf_attr, map_flags), "BPF_MAP_CREATE_struct.map_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_INNER_MAP_FD static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, inner_map_fd) == sizeof_field(union bpf_attr, inner_map_fd), "BPF_MAP_CREATE_struct.inner_map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, inner_map_fd) == offsetof(union bpf_attr, inner_map_fd), "BPF_MAP_CREATE_struct.inner_map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INNER_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_NUMA_NODE static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, numa_node) == sizeof_field(union bpf_attr, numa_node), "BPF_MAP_CREATE_struct.numa_node size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, numa_node) == offsetof(union bpf_attr, numa_node), "BPF_MAP_CREATE_struct.numa_node offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_NUMA_NODE */ # ifdef HAVE_UNION_BPF_ATTR_MAP_NAME static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_name) == sizeof_field(union bpf_attr, map_name), "BPF_MAP_CREATE_struct.map_name size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_name) == offsetof(union bpf_attr, map_name), "BPF_MAP_CREATE_struct.map_name offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_NAME */ # ifdef HAVE_UNION_BPF_ATTR_MAP_IFINDEX static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_ifindex) == sizeof_field(union bpf_attr, map_ifindex), "BPF_MAP_CREATE_struct.map_ifindex size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_ifindex) == offsetof(union bpf_attr, map_ifindex), "BPF_MAP_CREATE_struct.map_ifindex offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_IFINDEX */ # ifdef HAVE_UNION_BPF_ATTR_BTF_FD static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_fd) == sizeof_field(union bpf_attr, btf_fd), "BPF_MAP_CREATE_struct.btf_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_fd) == offsetof(union bpf_attr, btf_fd), "BPF_MAP_CREATE_struct.btf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_FD */ # ifdef HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_key_type_id) == sizeof_field(union bpf_attr, btf_key_type_id), "BPF_MAP_CREATE_struct.btf_key_type_id size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_key_type_id) == offsetof(union bpf_attr, btf_key_type_id), "BPF_MAP_CREATE_struct.btf_key_type_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID */ # ifdef HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_value_type_id) == sizeof_field(union bpf_attr, btf_value_type_id), "BPF_MAP_CREATE_struct.btf_value_type_id size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_value_type_id) == offsetof(union bpf_attr, btf_value_type_id), "BPF_MAP_CREATE_struct.btf_value_type_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID */ # ifdef HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == sizeof_field(union bpf_attr, btf_vmlinux_value_type_id), "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == offsetof(union bpf_attr, btf_vmlinux_value_type_id), "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID */ # ifdef HAVE_UNION_BPF_ATTR_MAP_EXTRA static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_extra) == sizeof_field(union bpf_attr, map_extra), "BPF_MAP_CREATE_struct.map_extra size mismatch"); static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_extra) == offsetof(union bpf_attr, map_extra), "BPF_MAP_CREATE_struct.map_extra offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_EXTRA */ static_assert(BPF_MAP_CREATE_struct_size == expected_BPF_MAP_CREATE_struct_size, "BPF_MAP_CREATE_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_FD static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd), "BPF_MAP_LOOKUP_ELEM_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd), "BPF_MAP_LOOKUP_ELEM_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_KEY static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, key) == sizeof_field(union bpf_attr, key), "BPF_MAP_LOOKUP_ELEM_struct.key size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, key) == offsetof(union bpf_attr, key), "BPF_MAP_LOOKUP_ELEM_struct.key offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KEY */ # ifdef HAVE_UNION_BPF_ATTR_VALUE static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, value) == sizeof_field(union bpf_attr, value), "BPF_MAP_LOOKUP_ELEM_struct.value size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, value) == offsetof(union bpf_attr, value), "BPF_MAP_LOOKUP_ELEM_struct.value offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_VALUE */ # ifdef HAVE_UNION_BPF_ATTR_FLAGS static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags), "BPF_MAP_LOOKUP_ELEM_struct.flags size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == offsetof(union bpf_attr, flags), "BPF_MAP_LOOKUP_ELEM_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FLAGS */ static_assert(BPF_MAP_LOOKUP_ELEM_struct_size == expected_BPF_MAP_LOOKUP_ELEM_struct_size, "BPF_MAP_LOOKUP_ELEM_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_FD static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd), "BPF_MAP_UPDATE_ELEM_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd), "BPF_MAP_UPDATE_ELEM_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_KEY static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, key) == sizeof_field(union bpf_attr, key), "BPF_MAP_UPDATE_ELEM_struct.key size mismatch"); static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, key) == offsetof(union bpf_attr, key), "BPF_MAP_UPDATE_ELEM_struct.key offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KEY */ # ifdef HAVE_UNION_BPF_ATTR_VALUE static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, value) == sizeof_field(union bpf_attr, value), "BPF_MAP_UPDATE_ELEM_struct.value size mismatch"); static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, value) == offsetof(union bpf_attr, value), "BPF_MAP_UPDATE_ELEM_struct.value offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_VALUE */ # ifdef HAVE_UNION_BPF_ATTR_FLAGS static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags), "BPF_MAP_UPDATE_ELEM_struct.flags size mismatch"); static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, flags) == offsetof(union bpf_attr, flags), "BPF_MAP_UPDATE_ELEM_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FLAGS */ static_assert(BPF_MAP_UPDATE_ELEM_struct_size == expected_BPF_MAP_UPDATE_ELEM_struct_size, "BPF_MAP_UPDATE_ELEM_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_FD static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd), "BPF_MAP_DELETE_ELEM_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd), "BPF_MAP_DELETE_ELEM_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_KEY static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, key) == sizeof_field(union bpf_attr, key), "BPF_MAP_DELETE_ELEM_struct.key size mismatch"); static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, key) == offsetof(union bpf_attr, key), "BPF_MAP_DELETE_ELEM_struct.key offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KEY */ static_assert(BPF_MAP_DELETE_ELEM_struct_size == expected_BPF_MAP_DELETE_ELEM_struct_size, "BPF_MAP_DELETE_ELEM_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_FD static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == sizeof_field(union bpf_attr, map_fd), "BPF_MAP_GET_NEXT_KEY_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == offsetof(union bpf_attr, map_fd), "BPF_MAP_GET_NEXT_KEY_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_KEY static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, key) == sizeof_field(union bpf_attr, key), "BPF_MAP_GET_NEXT_KEY_struct.key size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, key) == offsetof(union bpf_attr, key), "BPF_MAP_GET_NEXT_KEY_struct.key offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KEY */ # ifdef HAVE_UNION_BPF_ATTR_NEXT_KEY static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == sizeof_field(union bpf_attr, next_key), "BPF_MAP_GET_NEXT_KEY_struct.next_key size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == offsetof(union bpf_attr, next_key), "BPF_MAP_GET_NEXT_KEY_struct.next_key offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_NEXT_KEY */ static_assert(BPF_MAP_GET_NEXT_KEY_struct_size == expected_BPF_MAP_GET_NEXT_KEY_struct_size, "BPF_MAP_GET_NEXT_KEY_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_FD static_assert(sizeof_field(struct BPF_MAP_FREEZE_struct, map_fd) == sizeof_field(union bpf_attr, map_fd), "BPF_MAP_FREEZE_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_FREEZE_struct, map_fd) == offsetof(union bpf_attr, map_fd), "BPF_MAP_FREEZE_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */ static_assert(BPF_MAP_FREEZE_struct_size == expected_BPF_MAP_FREEZE_struct_size, "BPF_MAP_FREEZE_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_PROG_TYPE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_type) == sizeof_field(union bpf_attr, prog_type), "BPF_PROG_LOAD_struct.prog_type size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_type) == offsetof(union bpf_attr, prog_type), "BPF_PROG_LOAD_struct.prog_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_INSN_CNT static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insn_cnt) == sizeof_field(union bpf_attr, insn_cnt), "BPF_PROG_LOAD_struct.insn_cnt size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, insn_cnt) == offsetof(union bpf_attr, insn_cnt), "BPF_PROG_LOAD_struct.insn_cnt offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INSN_CNT */ # ifdef HAVE_UNION_BPF_ATTR_INSNS static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insns) == sizeof_field(union bpf_attr, insns), "BPF_PROG_LOAD_struct.insns size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, insns) == offsetof(union bpf_attr, insns), "BPF_PROG_LOAD_struct.insns offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INSNS */ # ifdef HAVE_UNION_BPF_ATTR_LICENSE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, license) == sizeof_field(union bpf_attr, license), "BPF_PROG_LOAD_struct.license size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, license) == offsetof(union bpf_attr, license), "BPF_PROG_LOAD_struct.license offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LICENSE */ # ifdef HAVE_UNION_BPF_ATTR_LOG_LEVEL static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_level) == sizeof_field(union bpf_attr, log_level), "BPF_PROG_LOAD_struct.log_level size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_level) == offsetof(union bpf_attr, log_level), "BPF_PROG_LOAD_struct.log_level offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LOG_LEVEL */ # ifdef HAVE_UNION_BPF_ATTR_LOG_SIZE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_size) == sizeof_field(union bpf_attr, log_size), "BPF_PROG_LOAD_struct.log_size size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_size) == offsetof(union bpf_attr, log_size), "BPF_PROG_LOAD_struct.log_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LOG_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_LOG_BUF static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_buf) == sizeof_field(union bpf_attr, log_buf), "BPF_PROG_LOAD_struct.log_buf size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_buf) == offsetof(union bpf_attr, log_buf), "BPF_PROG_LOAD_struct.log_buf offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LOG_BUF */ # ifdef HAVE_UNION_BPF_ATTR_KERN_VERSION static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, kern_version) == sizeof_field(union bpf_attr, kern_version), "BPF_PROG_LOAD_struct.kern_version size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, kern_version) == offsetof(union bpf_attr, kern_version), "BPF_PROG_LOAD_struct.kern_version offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_KERN_VERSION */ # ifdef HAVE_UNION_BPF_ATTR_PROG_FLAGS static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_flags) == sizeof_field(union bpf_attr, prog_flags), "BPF_PROG_LOAD_struct.prog_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_flags) == offsetof(union bpf_attr, prog_flags), "BPF_PROG_LOAD_struct.prog_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_PROG_NAME static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_name) == sizeof_field(union bpf_attr, prog_name), "BPF_PROG_LOAD_struct.prog_name size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_name) == offsetof(union bpf_attr, prog_name), "BPF_PROG_LOAD_struct.prog_name offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_NAME */ # ifdef HAVE_UNION_BPF_ATTR_PROG_IFINDEX static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_ifindex) == sizeof_field(union bpf_attr, prog_ifindex), "BPF_PROG_LOAD_struct.prog_ifindex size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_ifindex) == offsetof(union bpf_attr, prog_ifindex), "BPF_PROG_LOAD_struct.prog_ifindex offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_IFINDEX */ # ifdef HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, expected_attach_type) == sizeof_field(union bpf_attr, expected_attach_type), "BPF_PROG_LOAD_struct.expected_attach_type size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, expected_attach_type) == offsetof(union bpf_attr, expected_attach_type), "BPF_PROG_LOAD_struct.expected_attach_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_PROG_BTF_FD static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_btf_fd) == sizeof_field(union bpf_attr, prog_btf_fd), "BPF_PROG_LOAD_struct.prog_btf_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_btf_fd) == offsetof(union bpf_attr, prog_btf_fd), "BPF_PROG_LOAD_struct.prog_btf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_BTF_FD */ # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_rec_size) == sizeof_field(union bpf_attr, func_info_rec_size), "BPF_PROG_LOAD_struct.func_info_rec_size size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_rec_size) == offsetof(union bpf_attr, func_info_rec_size), "BPF_PROG_LOAD_struct.func_info_rec_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info) == sizeof_field(union bpf_attr, func_info), "BPF_PROG_LOAD_struct.func_info size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info) == offsetof(union bpf_attr, func_info), "BPF_PROG_LOAD_struct.func_info offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO */ # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_cnt) == sizeof_field(union bpf_attr, func_info_cnt), "BPF_PROG_LOAD_struct.func_info_cnt size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_cnt) == offsetof(union bpf_attr, func_info_cnt), "BPF_PROG_LOAD_struct.func_info_cnt offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT */ # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_rec_size) == sizeof_field(union bpf_attr, line_info_rec_size), "BPF_PROG_LOAD_struct.line_info_rec_size size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_rec_size) == offsetof(union bpf_attr, line_info_rec_size), "BPF_PROG_LOAD_struct.line_info_rec_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info) == sizeof_field(union bpf_attr, line_info), "BPF_PROG_LOAD_struct.line_info size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info) == offsetof(union bpf_attr, line_info), "BPF_PROG_LOAD_struct.line_info offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO */ # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_CNT static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_cnt) == sizeof_field(union bpf_attr, line_info_cnt), "BPF_PROG_LOAD_struct.line_info_cnt size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_cnt) == offsetof(union bpf_attr, line_info_cnt), "BPF_PROG_LOAD_struct.line_info_cnt offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_CNT */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_btf_id) == sizeof_field(union bpf_attr, attach_btf_id), "BPF_PROG_LOAD_struct.attach_btf_id size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_btf_id) == offsetof(union bpf_attr, attach_btf_id), "BPF_PROG_LOAD_struct.attach_btf_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_prog_fd) == sizeof_field(union bpf_attr, attach_prog_fd), "BPF_PROG_LOAD_struct.attach_prog_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_prog_fd) == offsetof(union bpf_attr, attach_prog_fd), "BPF_PROG_LOAD_struct.attach_prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD */ # ifdef HAVE_UNION_BPF_ATTR_PAD static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, pad) == sizeof_field(union bpf_attr, pad), "BPF_PROG_LOAD_struct.pad size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, pad) == offsetof(union bpf_attr, pad), "BPF_PROG_LOAD_struct.pad offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PAD */ # ifdef HAVE_UNION_BPF_ATTR_FD_ARRAY static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, fd_array) == sizeof_field(union bpf_attr, fd_array), "BPF_PROG_LOAD_struct.fd_array size mismatch"); static_assert(offsetof(struct BPF_PROG_LOAD_struct, fd_array) == offsetof(union bpf_attr, fd_array), "BPF_PROG_LOAD_struct.fd_array offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FD_ARRAY */ static_assert(BPF_PROG_LOAD_struct_size == expected_BPF_PROG_LOAD_struct_size, "BPF_PROG_LOAD_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_PATHNAME static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, pathname) == sizeof_field(union bpf_attr, pathname), "BPF_OBJ_PIN_struct.pathname size mismatch"); static_assert(offsetof(struct BPF_OBJ_PIN_struct, pathname) == offsetof(union bpf_attr, pathname), "BPF_OBJ_PIN_struct.pathname offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PATHNAME */ # ifdef HAVE_UNION_BPF_ATTR_BPF_FD static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, bpf_fd) == sizeof_field(union bpf_attr, bpf_fd), "BPF_OBJ_PIN_struct.bpf_fd size mismatch"); static_assert(offsetof(struct BPF_OBJ_PIN_struct, bpf_fd) == offsetof(union bpf_attr, bpf_fd), "BPF_OBJ_PIN_struct.bpf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BPF_FD */ # ifdef HAVE_UNION_BPF_ATTR_FILE_FLAGS static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, file_flags) == sizeof_field(union bpf_attr, file_flags), "BPF_OBJ_PIN_struct.file_flags size mismatch"); static_assert(offsetof(struct BPF_OBJ_PIN_struct, file_flags) == offsetof(union bpf_attr, file_flags), "BPF_OBJ_PIN_struct.file_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_FILE_FLAGS */ static_assert(BPF_OBJ_PIN_struct_size == expected_BPF_OBJ_PIN_struct_size, "BPF_OBJ_PIN_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_TARGET_FD static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, target_fd) == sizeof_field(union bpf_attr, target_fd), "BPF_PROG_ATTACH_struct.target_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_ATTACH_struct, target_fd) == offsetof(union bpf_attr, target_fd), "BPF_PROG_ATTACH_struct.target_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TARGET_FD */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == sizeof_field(union bpf_attr, attach_bpf_fd), "BPF_PROG_ATTACH_struct.attach_bpf_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == offsetof(union bpf_attr, attach_bpf_fd), "BPF_PROG_ATTACH_struct.attach_bpf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_TYPE static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_type) == sizeof_field(union bpf_attr, attach_type), "BPF_PROG_ATTACH_struct.attach_type size mismatch"); static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_type) == offsetof(union bpf_attr, attach_type), "BPF_PROG_ATTACH_struct.attach_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_FLAGS static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_flags) == sizeof_field(union bpf_attr, attach_flags), "BPF_PROG_ATTACH_struct.attach_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_flags) == offsetof(union bpf_attr, attach_flags), "BPF_PROG_ATTACH_struct.attach_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == sizeof_field(union bpf_attr, replace_bpf_fd), "BPF_PROG_ATTACH_struct.replace_bpf_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == offsetof(union bpf_attr, replace_bpf_fd), "BPF_PROG_ATTACH_struct.replace_bpf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD */ static_assert(BPF_PROG_ATTACH_struct_size == expected_BPF_PROG_ATTACH_struct_size, "BPF_PROG_ATTACH_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_TARGET_FD static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, target_fd) == sizeof_field(union bpf_attr, target_fd), "BPF_PROG_DETACH_struct.target_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_DETACH_struct, target_fd) == offsetof(union bpf_attr, target_fd), "BPF_PROG_DETACH_struct.target_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TARGET_FD */ # ifdef HAVE_UNION_BPF_ATTR_DUMMY static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, dummy) == sizeof_field(union bpf_attr, dummy), "BPF_PROG_DETACH_struct.dummy size mismatch"); static_assert(offsetof(struct BPF_PROG_DETACH_struct, dummy) == offsetof(union bpf_attr, dummy), "BPF_PROG_DETACH_struct.dummy offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_DUMMY */ # ifdef HAVE_UNION_BPF_ATTR_ATTACH_TYPE static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, attach_type) == sizeof_field(union bpf_attr, attach_type), "BPF_PROG_DETACH_struct.attach_type size mismatch"); static_assert(offsetof(struct BPF_PROG_DETACH_struct, attach_type) == offsetof(union bpf_attr, attach_type), "BPF_PROG_DETACH_struct.attach_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_ATTACH_TYPE */ static_assert(BPF_PROG_DETACH_struct_size == expected_BPF_PROG_DETACH_struct_size, "BPF_PROG_DETACH_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_TEST_PROG_FD static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, prog_fd) == sizeof_field(union bpf_attr, test.prog_fd), "BPF_PROG_TEST_RUN_struct.prog_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, prog_fd) == offsetof(union bpf_attr, test.prog_fd), "BPF_PROG_TEST_RUN_struct.prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_PROG_FD */ # ifdef HAVE_UNION_BPF_ATTR_TEST_RETVAL static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, retval) == sizeof_field(union bpf_attr, test.retval), "BPF_PROG_TEST_RUN_struct.retval size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, retval) == offsetof(union bpf_attr, test.retval), "BPF_PROG_TEST_RUN_struct.retval offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_RETVAL */ # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_in) == sizeof_field(union bpf_attr, test.data_size_in), "BPF_PROG_TEST_RUN_struct.data_size_in size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_in) == offsetof(union bpf_attr, test.data_size_in), "BPF_PROG_TEST_RUN_struct.data_size_in offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN */ # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_out) == sizeof_field(union bpf_attr, test.data_size_out), "BPF_PROG_TEST_RUN_struct.data_size_out size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_out) == offsetof(union bpf_attr, test.data_size_out), "BPF_PROG_TEST_RUN_struct.data_size_out offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT */ # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_IN static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_in) == sizeof_field(union bpf_attr, test.data_in), "BPF_PROG_TEST_RUN_struct.data_in size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_in) == offsetof(union bpf_attr, test.data_in), "BPF_PROG_TEST_RUN_struct.data_in offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_IN */ # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_OUT static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_out) == sizeof_field(union bpf_attr, test.data_out), "BPF_PROG_TEST_RUN_struct.data_out size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_out) == offsetof(union bpf_attr, test.data_out), "BPF_PROG_TEST_RUN_struct.data_out offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_OUT */ # ifdef HAVE_UNION_BPF_ATTR_TEST_REPEAT static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, repeat) == sizeof_field(union bpf_attr, test.repeat), "BPF_PROG_TEST_RUN_struct.repeat size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, repeat) == offsetof(union bpf_attr, test.repeat), "BPF_PROG_TEST_RUN_struct.repeat offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_REPEAT */ # ifdef HAVE_UNION_BPF_ATTR_TEST_DURATION static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, duration) == sizeof_field(union bpf_attr, test.duration), "BPF_PROG_TEST_RUN_struct.duration size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, duration) == offsetof(union bpf_attr, test.duration), "BPF_PROG_TEST_RUN_struct.duration offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_DURATION */ # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == sizeof_field(union bpf_attr, test.ctx_size_in), "BPF_PROG_TEST_RUN_struct.ctx_size_in size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == offsetof(union bpf_attr, test.ctx_size_in), "BPF_PROG_TEST_RUN_struct.ctx_size_in offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN */ # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == sizeof_field(union bpf_attr, test.ctx_size_out), "BPF_PROG_TEST_RUN_struct.ctx_size_out size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == offsetof(union bpf_attr, test.ctx_size_out), "BPF_PROG_TEST_RUN_struct.ctx_size_out offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT */ # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_IN static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_in) == sizeof_field(union bpf_attr, test.ctx_in), "BPF_PROG_TEST_RUN_struct.ctx_in size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_in) == offsetof(union bpf_attr, test.ctx_in), "BPF_PROG_TEST_RUN_struct.ctx_in offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_IN */ # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_OUT static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_out) == sizeof_field(union bpf_attr, test.ctx_out), "BPF_PROG_TEST_RUN_struct.ctx_out size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_out) == offsetof(union bpf_attr, test.ctx_out), "BPF_PROG_TEST_RUN_struct.ctx_out offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_OUT */ # ifdef HAVE_UNION_BPF_ATTR_TEST_FLAGS static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, flags) == sizeof_field(union bpf_attr, test.flags), "BPF_PROG_TEST_RUN_struct.flags size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, flags) == offsetof(union bpf_attr, test.flags), "BPF_PROG_TEST_RUN_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_TEST_CPU static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, cpu) == sizeof_field(union bpf_attr, test.cpu), "BPF_PROG_TEST_RUN_struct.cpu size mismatch"); static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, cpu) == offsetof(union bpf_attr, test.cpu), "BPF_PROG_TEST_RUN_struct.cpu offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TEST_CPU */ static_assert(BPF_PROG_TEST_RUN_struct_size == expected_BPF_PROG_TEST_RUN_struct_size, "BPF_PROG_TEST_RUN_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_START_ID static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == sizeof_field(union bpf_attr, start_id), "BPF_PROG_GET_NEXT_ID_struct.start_id size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == offsetof(union bpf_attr, start_id), "BPF_PROG_GET_NEXT_ID_struct.start_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_START_ID */ # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id), "BPF_PROG_GET_NEXT_ID_struct.next_id size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == offsetof(union bpf_attr, next_id), "BPF_PROG_GET_NEXT_ID_struct.next_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */ # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags), "BPF_PROG_GET_NEXT_ID_struct.open_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags), "BPF_PROG_GET_NEXT_ID_struct.open_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */ static_assert(BPF_PROG_GET_NEXT_ID_struct_size == expected_BPF_PROG_GET_NEXT_ID_struct_size, "BPF_PROG_GET_NEXT_ID_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_PROG_ID static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == sizeof_field(union bpf_attr, prog_id), "BPF_PROG_GET_FD_BY_ID_struct.prog_id size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == offsetof(union bpf_attr, prog_id), "BPF_PROG_GET_FD_BY_ID_struct.prog_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_PROG_ID */ # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id), "BPF_PROG_GET_FD_BY_ID_struct.next_id size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id), "BPF_PROG_GET_FD_BY_ID_struct.next_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */ # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags), "BPF_PROG_GET_FD_BY_ID_struct.open_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags), "BPF_PROG_GET_FD_BY_ID_struct.open_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */ static_assert(BPF_PROG_GET_FD_BY_ID_struct_size == expected_BPF_PROG_GET_FD_BY_ID_struct_size, "BPF_PROG_GET_FD_BY_ID_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_MAP_ID static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == sizeof_field(union bpf_attr, map_id), "BPF_MAP_GET_FD_BY_ID_struct.map_id size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == offsetof(union bpf_attr, map_id), "BPF_MAP_GET_FD_BY_ID_struct.map_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_MAP_ID */ # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id), "BPF_MAP_GET_FD_BY_ID_struct.next_id size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id), "BPF_MAP_GET_FD_BY_ID_struct.next_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */ # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags), "BPF_MAP_GET_FD_BY_ID_struct.open_flags size mismatch"); static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags), "BPF_MAP_GET_FD_BY_ID_struct.open_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */ static_assert(BPF_MAP_GET_FD_BY_ID_struct_size == expected_BPF_MAP_GET_FD_BY_ID_struct_size, "BPF_MAP_GET_FD_BY_ID_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_INFO_BPF_FD static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == sizeof_field(union bpf_attr, info.bpf_fd), "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd size mismatch"); static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == offsetof(union bpf_attr, info.bpf_fd), "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INFO_BPF_FD */ # ifdef HAVE_UNION_BPF_ATTR_INFO_INFO_LEN static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == sizeof_field(union bpf_attr, info.info_len), "BPF_OBJ_GET_INFO_BY_FD_struct.info_len size mismatch"); static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == offsetof(union bpf_attr, info.info_len), "BPF_OBJ_GET_INFO_BY_FD_struct.info_len offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INFO_INFO_LEN */ # ifdef HAVE_UNION_BPF_ATTR_INFO_INFO static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == sizeof_field(union bpf_attr, info.info), "BPF_OBJ_GET_INFO_BY_FD_struct.info size mismatch"); static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == offsetof(union bpf_attr, info.info), "BPF_OBJ_GET_INFO_BY_FD_struct.info offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_INFO_INFO */ static_assert(BPF_OBJ_GET_INFO_BY_FD_struct_size == expected_BPF_OBJ_GET_INFO_BY_FD_struct_size, "BPF_OBJ_GET_INFO_BY_FD_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, target_fd) == sizeof_field(union bpf_attr, query.target_fd), "BPF_PROG_QUERY_struct.target_fd size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, target_fd) == offsetof(union bpf_attr, query.target_fd), "BPF_PROG_QUERY_struct.target_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD */ # ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_type) == sizeof_field(union bpf_attr, query.attach_type), "BPF_PROG_QUERY_struct.attach_type size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_type) == offsetof(union bpf_attr, query.attach_type), "BPF_PROG_QUERY_struct.attach_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, query_flags) == sizeof_field(union bpf_attr, query.query_flags), "BPF_PROG_QUERY_struct.query_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, query_flags) == offsetof(union bpf_attr, query.query_flags), "BPF_PROG_QUERY_struct.query_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_flags) == sizeof_field(union bpf_attr, query.attach_flags), "BPF_PROG_QUERY_struct.attach_flags size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_flags) == offsetof(union bpf_attr, query.attach_flags), "BPF_PROG_QUERY_struct.attach_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_ids) == sizeof_field(union bpf_attr, query.prog_ids), "BPF_PROG_QUERY_struct.prog_ids size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_ids) == offsetof(union bpf_attr, query.prog_ids), "BPF_PROG_QUERY_struct.prog_ids offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS */ # ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_cnt) == sizeof_field(union bpf_attr, query.prog_cnt), "BPF_PROG_QUERY_struct.prog_cnt size mismatch"); static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_cnt) == offsetof(union bpf_attr, query.prog_cnt), "BPF_PROG_QUERY_struct.prog_cnt offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT */ static_assert(BPF_PROG_QUERY_struct_size == expected_BPF_PROG_QUERY_struct_size, "BPF_PROG_QUERY_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == sizeof_field(union bpf_attr, raw_tracepoint.name), "BPF_RAW_TRACEPOINT_OPEN_struct.name size mismatch"); static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == offsetof(union bpf_attr, raw_tracepoint.name), "BPF_RAW_TRACEPOINT_OPEN_struct.name offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME */ # ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == sizeof_field(union bpf_attr, raw_tracepoint.prog_fd), "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd size mismatch"); static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == offsetof(union bpf_attr, raw_tracepoint.prog_fd), "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD */ static_assert(BPF_RAW_TRACEPOINT_OPEN_struct_size == expected_BPF_RAW_TRACEPOINT_OPEN_struct_size, "BPF_RAW_TRACEPOINT_OPEN_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_BTF static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf) == sizeof_field(union bpf_attr, btf), "BPF_BTF_LOAD_struct.btf size mismatch"); static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf) == offsetof(union bpf_attr, btf), "BPF_BTF_LOAD_struct.btf offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF */ # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_BUF static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_buf) == sizeof_field(union bpf_attr, btf_log_buf), "BPF_BTF_LOAD_struct.btf_log_buf size mismatch"); static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_buf) == offsetof(union bpf_attr, btf_log_buf), "BPF_BTF_LOAD_struct.btf_log_buf offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_BUF */ # ifdef HAVE_UNION_BPF_ATTR_BTF_SIZE static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_size) == sizeof_field(union bpf_attr, btf_size), "BPF_BTF_LOAD_struct.btf_size size mismatch"); static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_size) == offsetof(union bpf_attr, btf_size), "BPF_BTF_LOAD_struct.btf_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_size) == sizeof_field(union bpf_attr, btf_log_size), "BPF_BTF_LOAD_struct.btf_log_size size mismatch"); static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_size) == offsetof(union bpf_attr, btf_log_size), "BPF_BTF_LOAD_struct.btf_log_size offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE */ # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_level) == sizeof_field(union bpf_attr, btf_log_level), "BPF_BTF_LOAD_struct.btf_log_level size mismatch"); static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_level) == offsetof(union bpf_attr, btf_log_level), "BPF_BTF_LOAD_struct.btf_log_level offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL */ static_assert(BPF_BTF_LOAD_struct_size == expected_BPF_BTF_LOAD_struct_size, "BPF_BTF_LOAD_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_BTF_ID static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == sizeof_field(union bpf_attr, btf_id), "BPF_BTF_GET_FD_BY_ID_struct.btf_id size mismatch"); static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == offsetof(union bpf_attr, btf_id), "BPF_BTF_GET_FD_BY_ID_struct.btf_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BTF_ID */ static_assert(BPF_BTF_GET_FD_BY_ID_struct_size == expected_BPF_BTF_GET_FD_BY_ID_struct_size, "BPF_BTF_GET_FD_BY_ID_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, pid) == sizeof_field(union bpf_attr, task_fd_query.pid), "BPF_TASK_FD_QUERY_struct.pid size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, pid) == offsetof(union bpf_attr, task_fd_query.pid), "BPF_TASK_FD_QUERY_struct.pid offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd) == sizeof_field(union bpf_attr, task_fd_query.fd), "BPF_TASK_FD_QUERY_struct.fd size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd) == offsetof(union bpf_attr, task_fd_query.fd), "BPF_TASK_FD_QUERY_struct.fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, flags) == sizeof_field(union bpf_attr, task_fd_query.flags), "BPF_TASK_FD_QUERY_struct.flags size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, flags) == offsetof(union bpf_attr, task_fd_query.flags), "BPF_TASK_FD_QUERY_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf_len) == sizeof_field(union bpf_attr, task_fd_query.buf_len), "BPF_TASK_FD_QUERY_struct.buf_len size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf_len) == offsetof(union bpf_attr, task_fd_query.buf_len), "BPF_TASK_FD_QUERY_struct.buf_len offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf) == sizeof_field(union bpf_attr, task_fd_query.buf), "BPF_TASK_FD_QUERY_struct.buf size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf) == offsetof(union bpf_attr, task_fd_query.buf), "BPF_TASK_FD_QUERY_struct.buf offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, prog_id) == sizeof_field(union bpf_attr, task_fd_query.prog_id), "BPF_TASK_FD_QUERY_struct.prog_id size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, prog_id) == offsetof(union bpf_attr, task_fd_query.prog_id), "BPF_TASK_FD_QUERY_struct.prog_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd_type) == sizeof_field(union bpf_attr, task_fd_query.fd_type), "BPF_TASK_FD_QUERY_struct.fd_type size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd_type) == offsetof(union bpf_attr, task_fd_query.fd_type), "BPF_TASK_FD_QUERY_struct.fd_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_offset) == sizeof_field(union bpf_attr, task_fd_query.probe_offset), "BPF_TASK_FD_QUERY_struct.probe_offset size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_offset) == offsetof(union bpf_attr, task_fd_query.probe_offset), "BPF_TASK_FD_QUERY_struct.probe_offset offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET */ # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_addr) == sizeof_field(union bpf_attr, task_fd_query.probe_addr), "BPF_TASK_FD_QUERY_struct.probe_addr size mismatch"); static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_addr) == offsetof(union bpf_attr, task_fd_query.probe_addr), "BPF_TASK_FD_QUERY_struct.probe_addr offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR */ static_assert(BPF_TASK_FD_QUERY_struct_size == expected_BPF_TASK_FD_QUERY_struct_size, "BPF_TASK_FD_QUERY_struct_size mismatch"); # ifdef HAVE_STRUCT_BPF_MAP_INFO_TYPE static_assert(sizeof_field(struct bpf_map_info_struct, type) == sizeof_field(struct bpf_map_info, type), "bpf_map_info_struct.type size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, type) == offsetof(struct bpf_map_info, type), "bpf_map_info_struct.type offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_TYPE */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_ID static_assert(sizeof_field(struct bpf_map_info_struct, id) == sizeof_field(struct bpf_map_info, id), "bpf_map_info_struct.id size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, id) == offsetof(struct bpf_map_info, id), "bpf_map_info_struct.id offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_ID */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE static_assert(sizeof_field(struct bpf_map_info_struct, key_size) == sizeof_field(struct bpf_map_info, key_size), "bpf_map_info_struct.key_size size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, key_size) == offsetof(struct bpf_map_info, key_size), "bpf_map_info_struct.key_size offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE static_assert(sizeof_field(struct bpf_map_info_struct, value_size) == sizeof_field(struct bpf_map_info, value_size), "bpf_map_info_struct.value_size size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, value_size) == offsetof(struct bpf_map_info, value_size), "bpf_map_info_struct.value_size offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES static_assert(sizeof_field(struct bpf_map_info_struct, max_entries) == sizeof_field(struct bpf_map_info, max_entries), "bpf_map_info_struct.max_entries size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, max_entries) == offsetof(struct bpf_map_info, max_entries), "bpf_map_info_struct.max_entries offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS static_assert(sizeof_field(struct bpf_map_info_struct, map_flags) == sizeof_field(struct bpf_map_info, map_flags), "bpf_map_info_struct.map_flags size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, map_flags) == offsetof(struct bpf_map_info, map_flags), "bpf_map_info_struct.map_flags offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_NAME static_assert(sizeof_field(struct bpf_map_info_struct, name) == sizeof_field(struct bpf_map_info, name), "bpf_map_info_struct.name size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, name) == offsetof(struct bpf_map_info, name), "bpf_map_info_struct.name offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_NAME */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_IFINDEX static_assert(sizeof_field(struct bpf_map_info_struct, ifindex) == sizeof_field(struct bpf_map_info, ifindex), "bpf_map_info_struct.ifindex size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, ifindex) == offsetof(struct bpf_map_info, ifindex), "bpf_map_info_struct.ifindex offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_IFINDEX */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID static_assert(sizeof_field(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == sizeof_field(struct bpf_map_info, btf_vmlinux_value_type_id), "bpf_map_info_struct.btf_vmlinux_value_type_id size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == offsetof(struct bpf_map_info, btf_vmlinux_value_type_id), "bpf_map_info_struct.btf_vmlinux_value_type_id offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_ID static_assert(sizeof_field(struct bpf_map_info_struct, btf_id) == sizeof_field(struct bpf_map_info, btf_id), "bpf_map_info_struct.btf_id size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, btf_id) == offsetof(struct bpf_map_info, btf_id), "bpf_map_info_struct.btf_id offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_ID */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID static_assert(sizeof_field(struct bpf_map_info_struct, btf_key_type_id) == sizeof_field(struct bpf_map_info, btf_key_type_id), "bpf_map_info_struct.btf_key_type_id size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, btf_key_type_id) == offsetof(struct bpf_map_info, btf_key_type_id), "bpf_map_info_struct.btf_key_type_id offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID static_assert(sizeof_field(struct bpf_map_info_struct, btf_value_type_id) == sizeof_field(struct bpf_map_info, btf_value_type_id), "bpf_map_info_struct.btf_value_type_id size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, btf_value_type_id) == offsetof(struct bpf_map_info, btf_value_type_id), "bpf_map_info_struct.btf_value_type_id offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_PAD static_assert(sizeof_field(struct bpf_map_info_struct, pad) == sizeof_field(struct bpf_map_info, pad), "bpf_map_info_struct.pad size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, pad) == offsetof(struct bpf_map_info, pad), "bpf_map_info_struct.pad offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_PAD */ # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA static_assert(sizeof_field(struct bpf_map_info_struct, map_extra) == sizeof_field(struct bpf_map_info, map_extra), "bpf_map_info_struct.map_extra size mismatch"); static_assert(offsetof(struct bpf_map_info_struct, map_extra) == offsetof(struct bpf_map_info, map_extra), "bpf_map_info_struct.map_extra offset mismatch"); # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA */ static_assert(bpf_map_info_struct_size == expected_bpf_map_info_struct_size, "bpf_map_info_struct_size mismatch"); # ifdef HAVE_STRUCT_BPF_PROG_INFO_TYPE static_assert(sizeof_field(struct bpf_prog_info_struct, type) == sizeof_field(struct bpf_prog_info, type), "bpf_prog_info_struct.type size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, type) == offsetof(struct bpf_prog_info, type), "bpf_prog_info_struct.type offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_TYPE */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_ID static_assert(sizeof_field(struct bpf_prog_info_struct, id) == sizeof_field(struct bpf_prog_info, id), "bpf_prog_info_struct.id size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, id) == offsetof(struct bpf_prog_info, id), "bpf_prog_info_struct.id offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_ID */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_TAG static_assert(sizeof_field(struct bpf_prog_info_struct, tag) == sizeof_field(struct bpf_prog_info, tag), "bpf_prog_info_struct.tag size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, tag) == offsetof(struct bpf_prog_info, tag), "bpf_prog_info_struct.tag offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_TAG */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_len) == sizeof_field(struct bpf_prog_info, jited_prog_len), "bpf_prog_info_struct.jited_prog_len size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_len) == offsetof(struct bpf_prog_info, jited_prog_len), "bpf_prog_info_struct.jited_prog_len offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_len) == sizeof_field(struct bpf_prog_info, xlated_prog_len), "bpf_prog_info_struct.xlated_prog_len size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_len) == offsetof(struct bpf_prog_info, xlated_prog_len), "bpf_prog_info_struct.xlated_prog_len offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_insns) == sizeof_field(struct bpf_prog_info, jited_prog_insns), "bpf_prog_info_struct.jited_prog_insns size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_insns) == offsetof(struct bpf_prog_info, jited_prog_insns), "bpf_prog_info_struct.jited_prog_insns offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_insns) == sizeof_field(struct bpf_prog_info, xlated_prog_insns), "bpf_prog_info_struct.xlated_prog_insns size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_insns) == offsetof(struct bpf_prog_info, xlated_prog_insns), "bpf_prog_info_struct.xlated_prog_insns offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME static_assert(sizeof_field(struct bpf_prog_info_struct, load_time) == sizeof_field(struct bpf_prog_info, load_time), "bpf_prog_info_struct.load_time size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, load_time) == offsetof(struct bpf_prog_info, load_time), "bpf_prog_info_struct.load_time offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID static_assert(sizeof_field(struct bpf_prog_info_struct, created_by_uid) == sizeof_field(struct bpf_prog_info, created_by_uid), "bpf_prog_info_struct.created_by_uid size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, created_by_uid) == offsetof(struct bpf_prog_info, created_by_uid), "bpf_prog_info_struct.created_by_uid offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS static_assert(sizeof_field(struct bpf_prog_info_struct, nr_map_ids) == sizeof_field(struct bpf_prog_info, nr_map_ids), "bpf_prog_info_struct.nr_map_ids size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_map_ids) == offsetof(struct bpf_prog_info, nr_map_ids), "bpf_prog_info_struct.nr_map_ids offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS static_assert(sizeof_field(struct bpf_prog_info_struct, map_ids) == sizeof_field(struct bpf_prog_info, map_ids), "bpf_prog_info_struct.map_ids size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, map_ids) == offsetof(struct bpf_prog_info, map_ids), "bpf_prog_info_struct.map_ids offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NAME static_assert(sizeof_field(struct bpf_prog_info_struct, name) == sizeof_field(struct bpf_prog_info, name), "bpf_prog_info_struct.name size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, name) == offsetof(struct bpf_prog_info, name), "bpf_prog_info_struct.name offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NAME */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_IFINDEX static_assert(sizeof_field(struct bpf_prog_info_struct, ifindex) == sizeof_field(struct bpf_prog_info, ifindex), "bpf_prog_info_struct.ifindex size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, ifindex) == offsetof(struct bpf_prog_info, ifindex), "bpf_prog_info_struct.ifindex offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_IFINDEX */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_ksyms) == sizeof_field(struct bpf_prog_info, nr_jited_ksyms), "bpf_prog_info_struct.nr_jited_ksyms size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_ksyms) == offsetof(struct bpf_prog_info, nr_jited_ksyms), "bpf_prog_info_struct.nr_jited_ksyms offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_func_lens) == sizeof_field(struct bpf_prog_info, nr_jited_func_lens), "bpf_prog_info_struct.nr_jited_func_lens size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_func_lens) == offsetof(struct bpf_prog_info, nr_jited_func_lens), "bpf_prog_info_struct.nr_jited_func_lens offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS static_assert(sizeof_field(struct bpf_prog_info_struct, jited_ksyms) == sizeof_field(struct bpf_prog_info, jited_ksyms), "bpf_prog_info_struct.jited_ksyms size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_ksyms) == offsetof(struct bpf_prog_info, jited_ksyms), "bpf_prog_info_struct.jited_ksyms offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS static_assert(sizeof_field(struct bpf_prog_info_struct, jited_func_lens) == sizeof_field(struct bpf_prog_info, jited_func_lens), "bpf_prog_info_struct.jited_func_lens size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_func_lens) == offsetof(struct bpf_prog_info, jited_func_lens), "bpf_prog_info_struct.jited_func_lens offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_BTF_ID static_assert(sizeof_field(struct bpf_prog_info_struct, btf_id) == sizeof_field(struct bpf_prog_info, btf_id), "bpf_prog_info_struct.btf_id size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, btf_id) == offsetof(struct bpf_prog_info, btf_id), "bpf_prog_info_struct.btf_id offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_BTF_ID */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE static_assert(sizeof_field(struct bpf_prog_info_struct, func_info_rec_size) == sizeof_field(struct bpf_prog_info, func_info_rec_size), "bpf_prog_info_struct.func_info_rec_size size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, func_info_rec_size) == offsetof(struct bpf_prog_info, func_info_rec_size), "bpf_prog_info_struct.func_info_rec_size offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, func_info) == sizeof_field(struct bpf_prog_info, func_info), "bpf_prog_info_struct.func_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, func_info) == offsetof(struct bpf_prog_info, func_info), "bpf_prog_info_struct.func_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, nr_func_info) == sizeof_field(struct bpf_prog_info, nr_func_info), "bpf_prog_info_struct.nr_func_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_func_info) == offsetof(struct bpf_prog_info, nr_func_info), "bpf_prog_info_struct.nr_func_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, nr_line_info) == sizeof_field(struct bpf_prog_info, nr_line_info), "bpf_prog_info_struct.nr_line_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_line_info) == offsetof(struct bpf_prog_info, nr_line_info), "bpf_prog_info_struct.nr_line_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, line_info) == sizeof_field(struct bpf_prog_info, line_info), "bpf_prog_info_struct.line_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, line_info) == offsetof(struct bpf_prog_info, line_info), "bpf_prog_info_struct.line_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info) == sizeof_field(struct bpf_prog_info, jited_line_info), "bpf_prog_info_struct.jited_line_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info) == offsetof(struct bpf_prog_info, jited_line_info), "bpf_prog_info_struct.jited_line_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_line_info) == sizeof_field(struct bpf_prog_info, nr_jited_line_info), "bpf_prog_info_struct.nr_jited_line_info size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_line_info) == offsetof(struct bpf_prog_info, nr_jited_line_info), "bpf_prog_info_struct.nr_jited_line_info offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE static_assert(sizeof_field(struct bpf_prog_info_struct, line_info_rec_size) == sizeof_field(struct bpf_prog_info, line_info_rec_size), "bpf_prog_info_struct.line_info_rec_size size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, line_info_rec_size) == offsetof(struct bpf_prog_info, line_info_rec_size), "bpf_prog_info_struct.line_info_rec_size offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info_rec_size) == sizeof_field(struct bpf_prog_info, jited_line_info_rec_size), "bpf_prog_info_struct.jited_line_info_rec_size size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info_rec_size) == offsetof(struct bpf_prog_info, jited_line_info_rec_size), "bpf_prog_info_struct.jited_line_info_rec_size offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS static_assert(sizeof_field(struct bpf_prog_info_struct, nr_prog_tags) == sizeof_field(struct bpf_prog_info, nr_prog_tags), "bpf_prog_info_struct.nr_prog_tags size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, nr_prog_tags) == offsetof(struct bpf_prog_info, nr_prog_tags), "bpf_prog_info_struct.nr_prog_tags offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS static_assert(sizeof_field(struct bpf_prog_info_struct, prog_tags) == sizeof_field(struct bpf_prog_info, prog_tags), "bpf_prog_info_struct.prog_tags size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, prog_tags) == offsetof(struct bpf_prog_info, prog_tags), "bpf_prog_info_struct.prog_tags offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS static_assert(sizeof_field(struct bpf_prog_info_struct, run_time_ns) == sizeof_field(struct bpf_prog_info, run_time_ns), "bpf_prog_info_struct.run_time_ns size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, run_time_ns) == offsetof(struct bpf_prog_info, run_time_ns), "bpf_prog_info_struct.run_time_ns offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT static_assert(sizeof_field(struct bpf_prog_info_struct, run_cnt) == sizeof_field(struct bpf_prog_info, run_cnt), "bpf_prog_info_struct.run_cnt size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, run_cnt) == offsetof(struct bpf_prog_info, run_cnt), "bpf_prog_info_struct.run_cnt offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES static_assert(sizeof_field(struct bpf_prog_info_struct, recursion_misses) == sizeof_field(struct bpf_prog_info, recursion_misses), "bpf_prog_info_struct.recursion_misses size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, recursion_misses) == offsetof(struct bpf_prog_info, recursion_misses), "bpf_prog_info_struct.recursion_misses offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES */ # ifdef HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS static_assert(sizeof_field(struct bpf_prog_info_struct, verified_insns) == sizeof_field(struct bpf_prog_info, verified_insns), "bpf_prog_info_struct.verified_insns size mismatch"); static_assert(offsetof(struct bpf_prog_info_struct, verified_insns) == offsetof(struct bpf_prog_info, verified_insns), "bpf_prog_info_struct.verified_insns offset mismatch"); # endif /* HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS */ static_assert(bpf_prog_info_struct_size == expected_bpf_prog_info_struct_size, "bpf_prog_info_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == sizeof_field(union bpf_attr, batch.in_batch), "BPF_MAP_LOOKUP_BATCH_struct.in_batch size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == offsetof(union bpf_attr, batch.in_batch), "BPF_MAP_LOOKUP_BATCH_struct.in_batch offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == sizeof_field(union bpf_attr, batch.out_batch), "BPF_MAP_LOOKUP_BATCH_struct.out_batch size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == offsetof(union bpf_attr, batch.out_batch), "BPF_MAP_LOOKUP_BATCH_struct.out_batch offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_KEYS static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == sizeof_field(union bpf_attr, batch.keys), "BPF_MAP_LOOKUP_BATCH_struct.keys size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == offsetof(union bpf_attr, batch.keys), "BPF_MAP_LOOKUP_BATCH_struct.keys offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_KEYS */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_VALUES static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, values) == sizeof_field(union bpf_attr, batch.values), "BPF_MAP_LOOKUP_BATCH_struct.values size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, values) == offsetof(union bpf_attr, batch.values), "BPF_MAP_LOOKUP_BATCH_struct.values offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_VALUES */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_COUNT static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, count) == sizeof_field(union bpf_attr, batch.count), "BPF_MAP_LOOKUP_BATCH_struct.count size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, count) == offsetof(union bpf_attr, batch.count), "BPF_MAP_LOOKUP_BATCH_struct.count offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_COUNT */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_MAP_FD static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == sizeof_field(union bpf_attr, batch.map_fd), "BPF_MAP_LOOKUP_BATCH_struct.map_fd size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == offsetof(union bpf_attr, batch.map_fd), "BPF_MAP_LOOKUP_BATCH_struct.map_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_MAP_FD */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == sizeof_field(union bpf_attr, batch.elem_flags), "BPF_MAP_LOOKUP_BATCH_struct.elem_flags size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == offsetof(union bpf_attr, batch.elem_flags), "BPF_MAP_LOOKUP_BATCH_struct.elem_flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_BATCH_FLAGS static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == sizeof_field(union bpf_attr, batch.flags), "BPF_MAP_LOOKUP_BATCH_struct.flags size mismatch"); static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == offsetof(union bpf_attr, batch.flags), "BPF_MAP_LOOKUP_BATCH_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_BATCH_FLAGS */ static_assert(BPF_MAP_LOOKUP_BATCH_struct_size == expected_BPF_MAP_LOOKUP_BATCH_struct_size, "BPF_MAP_LOOKUP_BATCH_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, prog_fd) == sizeof_field(union bpf_attr, link_create.prog_fd), "BPF_LINK_CREATE_struct.prog_fd size mismatch"); static_assert(offsetof(struct BPF_LINK_CREATE_struct, prog_fd) == offsetof(union bpf_attr, link_create.prog_fd), "BPF_LINK_CREATE_struct.prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD */ # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_fd) == sizeof_field(union bpf_attr, link_create.target_fd), "BPF_LINK_CREATE_struct.target_fd size mismatch"); static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_fd) == offsetof(union bpf_attr, link_create.target_fd), "BPF_LINK_CREATE_struct.target_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD */ # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, attach_type) == sizeof_field(union bpf_attr, link_create.attach_type), "BPF_LINK_CREATE_struct.attach_type size mismatch"); static_assert(offsetof(struct BPF_LINK_CREATE_struct, attach_type) == offsetof(union bpf_attr, link_create.attach_type), "BPF_LINK_CREATE_struct.attach_type offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE */ # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags), "BPF_LINK_CREATE_struct.flags size mismatch"); static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags), "BPF_LINK_CREATE_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */ static_assert(BPF_LINK_CREATE_struct_size == expected_BPF_LINK_CREATE_struct_size, "BPF_LINK_CREATE_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, link_fd) == sizeof_field(union bpf_attr, link_update.link_fd), "BPF_LINK_UPDATE_struct.link_fd size mismatch"); static_assert(offsetof(struct BPF_LINK_UPDATE_struct, link_fd) == offsetof(union bpf_attr, link_update.link_fd), "BPF_LINK_UPDATE_struct.link_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD */ # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, new_prog_fd) == sizeof_field(union bpf_attr, link_update.new_prog_fd), "BPF_LINK_UPDATE_struct.new_prog_fd size mismatch"); static_assert(offsetof(struct BPF_LINK_UPDATE_struct, new_prog_fd) == offsetof(union bpf_attr, link_update.new_prog_fd), "BPF_LINK_UPDATE_struct.new_prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD */ # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, flags) == sizeof_field(union bpf_attr, link_update.flags), "BPF_LINK_UPDATE_struct.flags size mismatch"); static_assert(offsetof(struct BPF_LINK_UPDATE_struct, flags) == offsetof(union bpf_attr, link_update.flags), "BPF_LINK_UPDATE_struct.flags offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS */ # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, old_prog_fd) == sizeof_field(union bpf_attr, link_update.old_prog_fd), "BPF_LINK_UPDATE_struct.old_prog_fd size mismatch"); static_assert(offsetof(struct BPF_LINK_UPDATE_struct, old_prog_fd) == offsetof(union bpf_attr, link_update.old_prog_fd), "BPF_LINK_UPDATE_struct.old_prog_fd offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD */ static_assert(BPF_LINK_UPDATE_struct_size == expected_BPF_LINK_UPDATE_struct_size, "BPF_LINK_UPDATE_struct_size mismatch"); # ifdef HAVE_UNION_BPF_ATTR_LINK_ID static_assert(sizeof_field(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == sizeof_field(union bpf_attr, link_id), "BPF_LINK_GET_FD_BY_ID_struct.link_id size mismatch"); static_assert(offsetof(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == offsetof(union bpf_attr, link_id), "BPF_LINK_GET_FD_BY_ID_struct.link_id offset mismatch"); # endif /* HAVE_UNION_BPF_ATTR_LINK_ID */ static_assert(BPF_LINK_GET_FD_BY_ID_struct_size == expected_BPF_LINK_GET_FD_BY_ID_struct_size, "BPF_LINK_GET_FD_BY_ID_struct_size mismatch"); #endif /* HAVE_LINUX_BPF_H */