You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
709 lines
40 KiB
709 lines
40 KiB
/* 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 */
|