/* Generated by ./gen_bpf_attr_check.sh from bpf_attr.h; do not edit. */ #include "defs.h" #ifdef HAVE_LINUX_BPF_H # include # include "bpf_attr.h" # include "static_assert.h" # define SoM(type_, member_) (sizeof(((type_ *)0)->member_)) # ifdef HAVE_UNION_BPF_ATTR_MAP_TYPE static_assert(SoM(struct BPF_MAP_CREATE_struct, map_type) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, key_size) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, value_size) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, max_entries) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, map_flags) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, inner_map_fd) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, numa_node) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, map_name) == SoM(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(SoM(struct BPF_MAP_CREATE_struct, map_ifindex) == SoM(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 */ 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(SoM(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == SoM(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(SoM(struct BPF_MAP_LOOKUP_ELEM_struct, key) == SoM(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(SoM(struct BPF_MAP_LOOKUP_ELEM_struct, value) == SoM(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 */ 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(SoM(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == SoM(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(SoM(struct BPF_MAP_UPDATE_ELEM_struct, key) == SoM(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(SoM(struct BPF_MAP_UPDATE_ELEM_struct, value) == SoM(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(SoM(struct BPF_MAP_UPDATE_ELEM_struct, flags) == SoM(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(SoM(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == SoM(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(SoM(struct BPF_MAP_DELETE_ELEM_struct, key) == SoM(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(SoM(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == SoM(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(SoM(struct BPF_MAP_GET_NEXT_KEY_struct, key) == SoM(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(SoM(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == SoM(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_PROG_TYPE static_assert(SoM(struct BPF_PROG_LOAD_struct, prog_type) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, insn_cnt) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, insns) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, license) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, log_level) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, log_size) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, log_buf) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, kern_version) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, prog_flags) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, prog_name) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, prog_ifindex) == SoM(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(SoM(struct BPF_PROG_LOAD_struct, expected_attach_type) == SoM(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 */ 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(SoM(struct BPF_OBJ_PIN_struct, pathname) == SoM(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(SoM(struct BPF_OBJ_PIN_struct, bpf_fd) == SoM(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(SoM(struct BPF_OBJ_PIN_struct, file_flags) == SoM(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(SoM(struct BPF_PROG_ATTACH_struct, target_fd) == SoM(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(SoM(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == SoM(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(SoM(struct BPF_PROG_ATTACH_struct, attach_type) == SoM(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(SoM(struct BPF_PROG_ATTACH_struct, attach_flags) == SoM(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 */ 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(SoM(struct BPF_PROG_DETACH_struct, target_fd) == SoM(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(SoM(struct BPF_PROG_DETACH_struct, dummy) == SoM(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(SoM(struct BPF_PROG_DETACH_struct, attach_type) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, prog_fd) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, retval) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, data_size_in) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, data_size_out) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, data_in) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, data_out) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, repeat) == SoM(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(SoM(struct BPF_PROG_TEST_RUN_struct, duration) == SoM(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 */ 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(SoM(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == SoM(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(SoM(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == SoM(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(SoM(struct BPF_PROG_GET_NEXT_ID_struct, open_flags) == SoM(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(SoM(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == SoM(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(SoM(struct BPF_PROG_GET_FD_BY_ID_struct, next_id) == SoM(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(SoM(struct BPF_PROG_GET_FD_BY_ID_struct, open_flags) == SoM(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(SoM(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == SoM(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(SoM(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == SoM(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(SoM(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == SoM(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(SoM(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == SoM(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(SoM(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == SoM(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(SoM(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, target_fd) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, attach_type) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, query_flags) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, attach_flags) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, prog_ids) == SoM(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(SoM(struct BPF_PROG_QUERY_struct, prog_cnt) == SoM(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(SoM(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == SoM(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(SoM(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == SoM(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_STRUCT_BPF_MAP_INFO_TYPE static_assert(SoM(struct bpf_map_info_struct, type) == SoM(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(SoM(struct bpf_map_info_struct, id) == SoM(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(SoM(struct bpf_map_info_struct, key_size) == SoM(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(SoM(struct bpf_map_info_struct, value_size) == SoM(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(SoM(struct bpf_map_info_struct, max_entries) == SoM(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(SoM(struct bpf_map_info_struct, map_flags) == SoM(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(SoM(struct bpf_map_info_struct, name) == SoM(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(SoM(struct bpf_map_info_struct, ifindex) == SoM(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 */ 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(SoM(struct bpf_prog_info_struct, type) == SoM(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(SoM(struct bpf_prog_info_struct, id) == SoM(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(SoM(struct bpf_prog_info_struct, tag) == SoM(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(SoM(struct bpf_prog_info_struct, jited_prog_len) == SoM(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(SoM(struct bpf_prog_info_struct, xlated_prog_len) == SoM(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(SoM(struct bpf_prog_info_struct, jited_prog_insns) == SoM(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(SoM(struct bpf_prog_info_struct, xlated_prog_insns) == SoM(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(SoM(struct bpf_prog_info_struct, load_time) == SoM(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(SoM(struct bpf_prog_info_struct, created_by_uid) == SoM(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(SoM(struct bpf_prog_info_struct, nr_map_ids) == SoM(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(SoM(struct bpf_prog_info_struct, map_ids) == SoM(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(SoM(struct bpf_prog_info_struct, name) == SoM(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(SoM(struct bpf_prog_info_struct, ifindex) == SoM(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 */ static_assert(bpf_prog_info_struct_size == expected_bpf_prog_info_struct_size, "bpf_prog_info_struct_size mismatch"); #endif /* HAVE_LINUX_BPF_H */