| /* 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" |
| |
| # 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 */ |
