openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

selftests/bpf: convert selftests using BTF-defined maps to new syntax 

Convert all the existing selftests that are already using BTF-defined
maps to use new syntax (with no static data initialization).

Signed-off-by: Andrii Nakryiko <andriin@fb.com>
Acked-by: Song Liu <songliubraving@fb.com>
Acked-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
This commit is contained in:
Andrii Nakryiko 2019-07-05 08:50:11 -07:00 committed by Daniel Borkmann
parent 00acd00814
commit bc7430cc8b
20 changed files with 300 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
tools/testing/selftests/bpf/progs/bpf_flow.c
View File

@ -58,26 +58,18 @@ struct frag_hdr {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
__u32 max_entries; __uint(max_entries, 8);
__u32 key_size; __uint(key_size, sizeof(__u32));
__u32 value_size; __uint(value_size, sizeof(__u32));
} jmp_table SEC(".maps") = { } jmp_table SEC(".maps");
.type = BPF_MAP_TYPE_PROG_ARRAY,
.max_entries = 8,
.key_size = sizeof(__u32),
.value_size = sizeof(__u32),
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
struct bpf_flow_keys *value; __type(value, struct bpf_flow_keys);
} last_dissection SEC(".maps") = { } last_dissection SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
static __always_inline int export_flow_keys(struct bpf_flow_keys *keys, static __always_inline int export_flow_keys(struct bpf_flow_keys *keys,
int ret) int ret)

20
tools/testing/selftests/bpf/progs/netcnt_prog.c
View File

@ -11,20 +11,16 @@
#define NS_PER_SEC 1000000000 #define NS_PER_SEC 1000000000
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE);
struct bpf_cgroup_storage_key *key; __type(key, struct bpf_cgroup_storage_key);
struct percpu_net_cnt *value; __type(value, struct percpu_net_cnt);
} percpu_netcnt SEC(".maps") = { } percpu_netcnt SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE);
struct bpf_cgroup_storage_key *key; __type(key, struct bpf_cgroup_storage_key);
struct net_cnt *value; __type(value, struct net_cnt);
} netcnt SEC(".maps") = { } netcnt SEC(".maps");
.type = BPF_MAP_TYPE_CGROUP_STORAGE,
};
SEC("cgroup/skb") SEC("cgroup/skb")
int bpf_nextcnt(struct __sk_buff *skb) int bpf_nextcnt(struct __sk_buff *skb)

13
tools/testing/selftests/bpf/progs/socket_cookie_prog.c
View File

@ -13,14 +13,11 @@ struct socket_cookie {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_SK_STORAGE);
__u32 map_flags; __uint(map_flags, BPF_F_NO_PREALLOC);
int *key; __type(key, int);
struct socket_cookie *value; __type(value, struct socket_cookie);
} socket_cookies SEC(".maps") = { } socket_cookies SEC(".maps");
.type = BPF_MAP_TYPE_SK_STORAGE,
.map_flags = BPF_F_NO_PREALLOC,
};
SEC("cgroup/connect6") SEC("cgroup/connect6")
int set_cookie(struct bpf_sock_addr *ctx) int set_cookie(struct bpf_sock_addr *ctx)

13
tools/testing/selftests/bpf/progs/test_btf_newkv.c
View File

@ -21,14 +21,11 @@ struct bpf_map_def SEC("maps") btf_map_legacy = {
BPF_ANNOTATE_KV_PAIR(btf_map_legacy, int, struct ipv_counts); BPF_ANNOTATE_KV_PAIR(btf_map_legacy, int, struct ipv_counts);
struct { struct {
int *key; __uint(type, BPF_MAP_TYPE_ARRAY);
struct ipv_counts *value; __uint(max_entries, 4);
unsigned int type; __type(key, int);
unsigned int max_entries; __type(value, struct ipv_counts);
} btf_map SEC(".maps") = { } btf_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 4,
};
struct dummy_tracepoint_args { struct dummy_tracepoint_args {
unsigned long long pad; unsigned long long pad;

39
tools/testing/selftests/bpf/progs/test_get_stack_rawtp.c
View File

@ -16,26 +16,18 @@ struct stack_trace_t {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
__u32 max_entries; __uint(max_entries, 2);
__u32 key_size; __uint(key_size, sizeof(int));
__u32 value_size; __uint(value_size, sizeof(__u32));
} perfmap SEC(".maps") = { } perfmap SEC(".maps");
.type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
.max_entries = 2,
.key_size = sizeof(int),
.value_size = sizeof(__u32),
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
struct stack_trace_t *value; __type(value, struct stack_trace_t);
} stackdata_map SEC(".maps") = { } stackdata_map SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = 1,
};
/* Allocate per-cpu space twice the needed. For the code below /* Allocate per-cpu space twice the needed. For the code below
* usize = bpf_get_stack(ctx, raw_data, max_len, BPF_F_USER_STACK); * usize = bpf_get_stack(ctx, raw_data, max_len, BPF_F_USER_STACK);
@ -56,14 +48,11 @@ struct {
* This is an acceptable workaround since there is one entry here. * This is an acceptable workaround since there is one entry here.
*/ */
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u64 (*value)[2 * MAX_STACK_RAWTP]; __u64 (*value)[2 * MAX_STACK_RAWTP];
} rawdata_map SEC(".maps") = { } rawdata_map SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = 1,
};
SEC("tracepoint/raw_syscalls/sys_enter") SEC("tracepoint/raw_syscalls/sys_enter")
int bpf_prog1(void *ctx) int bpf_prog1(void *ctx)

37
tools/testing/selftests/bpf/progs/test_global_data.c
View File

@ -8,24 +8,18 @@
#include "bpf_helpers.h" #include "bpf_helpers.h"
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 11);
__u32 *key; __type(key, __u32);
__u64 *value; __type(value, __u64);
} result_number SEC(".maps") = { } result_number SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 11,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 5);
__u32 *key; __type(key, __u32);
const char (*value)[32]; const char (*value)[32];
} result_string SEC(".maps") = { } result_string SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 5,
};
struct foo { struct foo {
__u8 a; __u8 a;
@ -34,14 +28,11 @@ struct foo {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 5);
__u32 *key; __type(key, __u32);
struct foo *value; __type(value, struct foo);
} result_struct SEC(".maps") = { } result_struct SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 5,
};
/* Relocation tests for __u64s. */ /* Relocation tests for __u64s. */
static __u64 num0; static __u64 num0;

65
tools/testing/selftests/bpf/progs/test_l4lb.c
View File

@ -170,54 +170,39 @@ struct eth_hdr {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, MAX_VIPS);
struct vip *key; __type(key, struct vip);
struct vip_meta *value; __type(value, struct vip_meta);
} vip_map SEC(".maps") = { } vip_map SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = MAX_VIPS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, CH_RINGS_SIZE);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} ch_rings SEC(".maps") = { } ch_rings SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = CH_RINGS_SIZE,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, MAX_REALS);
__u32 *key; __type(key, __u32);
struct real_definition *value; __type(value, struct real_definition);
} reals SEC(".maps") = { } reals SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = MAX_REALS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, MAX_VIPS);
__u32 *key; __type(key, __u32);
struct vip_stats *value; __type(value, struct vip_stats);
} stats SEC(".maps") = { } stats SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = MAX_VIPS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, CTL_MAP_SIZE);
__u32 *key; __type(key, __u32);
struct ctl_value *value; __type(value, struct ctl_value);
} ctl_array SEC(".maps") = { } ctl_array SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = CTL_MAP_SIZE,
};
static __always_inline __u32 get_packet_hash(struct packet_description *pckt, static __always_inline __u32 get_packet_hash(struct packet_description *pckt,
bool ipv6) bool ipv6)

65
tools/testing/selftests/bpf/progs/test_l4lb_noinline.c
View File

@ -166,54 +166,39 @@ struct eth_hdr {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, MAX_VIPS);
struct vip *key; __type(key, struct vip);
struct vip_meta *value; __type(value, struct vip_meta);
} vip_map SEC(".maps") = { } vip_map SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = MAX_VIPS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, CH_RINGS_SIZE);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} ch_rings SEC(".maps") = { } ch_rings SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = CH_RINGS_SIZE,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, MAX_REALS);
__u32 *key; __type(key, __u32);
struct real_definition *value; __type(value, struct real_definition);
} reals SEC(".maps") = { } reals SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = MAX_REALS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, MAX_VIPS);
__u32 *key; __type(key, __u32);
struct vip_stats *value; __type(value, struct vip_stats);
} stats SEC(".maps") = { } stats SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = MAX_VIPS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, CTL_MAP_SIZE);
__u32 *key; __type(key, __u32);
struct ctl_value *value; __type(value, struct ctl_value);
} ctl_array SEC(".maps") = { } ctl_array SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = CTL_MAP_SIZE,
};
static __u32 get_packet_hash(struct packet_description *pckt, static __u32 get_packet_hash(struct packet_description *pckt,
bool ipv6) bool ipv6)

26
tools/testing/selftests/bpf/progs/test_map_lock.c
View File

@ -12,14 +12,11 @@ struct hmap_elem {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
struct hmap_elem *value; __type(value, struct hmap_elem);
} hash_map SEC(".maps") = { } hash_map SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 1,
};
struct array_elem { struct array_elem {
struct bpf_spin_lock lock; struct bpf_spin_lock lock;
@ -27,14 +24,11 @@ struct array_elem {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
int *key; __type(key, int);
struct array_elem *value; __type(value, struct array_elem);
} array_map SEC(".maps") = { } array_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
SEC("map_lock_demo") SEC("map_lock_demo")
int bpf_map_lock_test(struct __sk_buff *skb) int bpf_map_lock_test(struct __sk_buff *skb)

67
tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c
View File

@ -22,56 +22,39 @@ int _version SEC("version") = 1;
#endif #endif
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
__u32 max_entries; __uint(max_entries, 1);
__u32 key_size; __uint(key_size, sizeof(__u32));
__u32 value_size; __uint(value_size, sizeof(__u32));
} outer_map SEC(".maps") = { } outer_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY_OF_MAPS,
.max_entries = 1,
.key_size = sizeof(__u32),
.value_size = sizeof(__u32),
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, NR_RESULTS);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} result_map SEC(".maps") = { } result_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = NR_RESULTS,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
int *value; __type(value, int);
} tmp_index_ovr_map SEC(".maps") = { } tmp_index_ovr_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} linum_map SEC(".maps") = { } linum_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
struct data_check *value; __type(value, struct data_check);
} data_check_map SEC(".maps") = { } data_check_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
#define GOTO_DONE(_result) ({ \ #define GOTO_DONE(_result) ({ \
result = (_result); \ result = (_result); \

26
tools/testing/selftests/bpf/progs/test_send_signal_kern.c
View File

@ -5,24 +5,18 @@
#include "bpf_helpers.h" #include "bpf_helpers.h"
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u64 *value; __type(value, __u64);
} info_map SEC(".maps") = { } info_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u64 *value; __type(value, __u64);
} status_map SEC(".maps") = { } status_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
SEC("send_signal_demo") SEC("send_signal_demo")
int bpf_send_signal_test(void *ctx) int bpf_send_signal_test(void *ctx)

78
tools/testing/selftests/bpf/progs/test_sock_fields_kern.c
View File

@ -28,44 +28,32 @@ enum bpf_linum_array_idx {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, __NR_BPF_ADDR_ARRAY_IDX);
__u32 *key; __type(key, __u32);
struct sockaddr_in6 *value; __type(value, struct sockaddr_in6);
} addr_map SEC(".maps") = { } addr_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = __NR_BPF_ADDR_ARRAY_IDX,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, __NR_BPF_RESULT_ARRAY_IDX);
__u32 *key; __type(key, __u32);
struct bpf_sock *value; __type(value, struct bpf_sock);
} sock_result_map SEC(".maps") = { } sock_result_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = __NR_BPF_RESULT_ARRAY_IDX,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, __NR_BPF_RESULT_ARRAY_IDX);
__u32 *key; __type(key, __u32);
struct bpf_tcp_sock *value; __type(value, struct bpf_tcp_sock);
} tcp_sock_result_map SEC(".maps") = { } tcp_sock_result_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = __NR_BPF_RESULT_ARRAY_IDX,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, __NR_BPF_LINUM_ARRAY_IDX);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} linum_map SEC(".maps") = { } linum_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = __NR_BPF_LINUM_ARRAY_IDX,
};
struct bpf_spinlock_cnt { struct bpf_spinlock_cnt {
struct bpf_spin_lock lock; struct bpf_spin_lock lock;
@ -73,24 +61,18 @@ struct bpf_spinlock_cnt {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_SK_STORAGE);
__u32 map_flags; __uint(map_flags, BPF_F_NO_PREALLOC);
int *key; __type(key, int);
struct bpf_spinlock_cnt *value; __type(value, struct bpf_spinlock_cnt);
} sk_pkt_out_cnt SEC(".maps") = { } sk_pkt_out_cnt SEC(".maps");
.type = BPF_MAP_TYPE_SK_STORAGE,
.map_flags = BPF_F_NO_PREALLOC,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_SK_STORAGE);
__u32 map_flags; __uint(map_flags, BPF_F_NO_PREALLOC);
int *key; __type(key, int);
struct bpf_spinlock_cnt *value; __type(value, struct bpf_spinlock_cnt);
} sk_pkt_out_cnt10 SEC(".maps") = { } sk_pkt_out_cnt10 SEC(".maps");
.type = BPF_MAP_TYPE_SK_STORAGE,
.map_flags = BPF_F_NO_PREALLOC,
};
static bool is_loopback6(__u32 *a6) static bool is_loopback6(__u32 *a6)
{ {

36
tools/testing/selftests/bpf/progs/test_spin_lock.c
View File

@ -11,14 +11,11 @@ struct hmap_elem {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 1);
int *key; __type(key, int);
struct hmap_elem *value; __type(value, struct hmap_elem);
} hmap SEC(".maps") = { } hmap SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 1,
};
struct cls_elem { struct cls_elem {
struct bpf_spin_lock lock; struct bpf_spin_lock lock;
@ -26,12 +23,10 @@ struct cls_elem {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE);
struct bpf_cgroup_storage_key *key; __type(key, struct bpf_cgroup_storage_key);
struct cls_elem *value; __type(value, struct cls_elem);
} cls_map SEC(".maps") = { } cls_map SEC(".maps");
.type = BPF_MAP_TYPE_CGROUP_STORAGE,
};
struct bpf_vqueue { struct bpf_vqueue {
struct bpf_spin_lock lock; struct bpf_spin_lock lock;
@ -42,14 +37,11 @@ struct bpf_vqueue {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
int *key; __type(key, int);
struct bpf_vqueue *value; __type(value, struct bpf_vqueue);
} vqueue SEC(".maps") = { } vqueue SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
#define CREDIT_PER_NS(delta, rate) (((delta) * rate) >> 20) #define CREDIT_PER_NS(delta, rate) (((delta) * rate) >> 20)

55
tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c
View File

@ -9,51 +9,36 @@
#endif #endif
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} control_map SEC(".maps") = { } control_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 16384);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} stackid_hmap SEC(".maps") = { } stackid_hmap SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 16384,
};
typedef struct bpf_stack_build_id stack_trace_t[PERF_MAX_STACK_DEPTH]; typedef struct bpf_stack_build_id stack_trace_t[PERF_MAX_STACK_DEPTH];
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_STACK_TRACE);
__u32 max_entries; __uint(max_entries, 128);
__u32 map_flags; __uint(map_flags, BPF_F_STACK_BUILD_ID);
__u32 key_size; __uint(key_size, sizeof(__u32));
__u32 value_size; __uint(value_size, sizeof(stack_trace_t));
} stackmap SEC(".maps") = { } stackmap SEC(".maps");
.type = BPF_MAP_TYPE_STACK_TRACE,
.max_entries = 128,
.map_flags = BPF_F_STACK_BUILD_ID,
.key_size = sizeof(__u32),
.value_size = sizeof(stack_trace_t),
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 128);
__u32 *key; __type(key, __u32);
/* there seems to be a bug in kernel not handling typedef properly */ /* there seems to be a bug in kernel not handling typedef properly */
struct bpf_stack_build_id (*value)[PERF_MAX_STACK_DEPTH]; struct bpf_stack_build_id (*value)[PERF_MAX_STACK_DEPTH];
} stack_amap SEC(".maps") = { } stack_amap SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 128,
};
/* taken from /sys/kernel/debug/tracing/events/random/urandom_read/format */ /* taken from /sys/kernel/debug/tracing/events/random/urandom_read/format */
struct random_urandom_args { struct random_urandom_args {

52
tools/testing/selftests/bpf/progs/test_stacktrace_map.c
View File

@ -9,48 +9,34 @@
#endif #endif
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 1);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} control_map SEC(".maps") = { } control_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 16384);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} stackid_hmap SEC(".maps") = { } stackid_hmap SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 16384,
};
typedef __u64 stack_trace_t[PERF_MAX_STACK_DEPTH]; typedef __u64 stack_trace_t[PERF_MAX_STACK_DEPTH];
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_STACK_TRACE);
__u32 max_entries; __uint(max_entries, 16384);
__u32 key_size; __uint(key_size, sizeof(__u32));
__u32 value_size; __uint(value_size, sizeof(stack_trace_t));
} stackmap SEC(".maps") = { } stackmap SEC(".maps");
.type = BPF_MAP_TYPE_STACK_TRACE,
.max_entries = 16384,
.key_size = sizeof(__u32),
.value_size = sizeof(stack_trace_t),
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 16384);
__u32 *key; __type(key, __u32);
__u64 (*value)[PERF_MAX_STACK_DEPTH]; __u64 (*value)[PERF_MAX_STACK_DEPTH];
} stack_amap SEC(".maps") = { } stack_amap SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 16384,
};
/* taken from /sys/kernel/debug/tracing/events/sched/sched_switch/format */ /* taken from /sys/kernel/debug/tracing/events/sched/sched_switch/format */
struct sched_switch_args { struct sched_switch_args {

13
tools/testing/selftests/bpf/progs/test_tcp_estats.c
View File

@ -149,14 +149,11 @@ struct tcp_estats_basic_event {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 1024);
__u32 *key; __type(key, __u32);
struct tcp_estats_basic_event *value; __type(value, struct tcp_estats_basic_event);
} ev_record_map SEC(".maps") = { } ev_record_map SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 1024,
};
struct dummy_tracepoint_args { struct dummy_tracepoint_args {
unsigned long long pad; unsigned long long pad;

26
tools/testing/selftests/bpf/progs/test_tcpbpf_kern.c
View File

@ -15,24 +15,18 @@
#include "test_tcpbpf.h" #include "test_tcpbpf.h"
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 4);
__u32 *key; __type(key, __u32);
struct tcpbpf_globals *value; __type(value, struct tcpbpf_globals);
} global_map SEC(".maps") = { } global_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 4,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 2);
__u32 *key; __type(key, __u32);
int *value; __type(value, int);
} sockopt_results SEC(".maps") = { } sockopt_results SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 2,
};
static inline void update_event_map(int event) static inline void update_event_map(int event)
{ {

28
tools/testing/selftests/bpf/progs/test_tcpnotify_kern.c
View File

@ -15,26 +15,18 @@
#include "test_tcpnotify.h" #include "test_tcpnotify.h"
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 4);
__u32 *key; __type(key, __u32);
struct tcpnotify_globals *value; __type(value, struct tcpnotify_globals);
} global_map SEC(".maps") = { } global_map SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 4,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
__u32 max_entries; __uint(max_entries, 2);
__u32 key_size; __uint(key_size, sizeof(int));
__u32 value_size; __uint(value_size, sizeof(__u32));
} perf_event_map SEC(".maps") = { } perf_event_map SEC(".maps");
.type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
.max_entries = 2,
.key_size = sizeof(int),
.value_size = sizeof(__u32),
};
int _version SEC("version") = 1; int _version SEC("version") = 1;

26
tools/testing/selftests/bpf/progs/test_xdp.c
View File

@ -23,24 +23,18 @@
int _version SEC("version") = 1; int _version SEC("version") = 1;
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, 256);
__u32 *key; __type(key, __u32);
__u64 *value; __type(value, __u64);
} rxcnt SEC(".maps") = { } rxcnt SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = 256,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, MAX_IPTNL_ENTRIES);
struct vip *key; __type(key, struct vip);
struct iptnl_info *value; __type(value, struct iptnl_info);
} vip2tnl SEC(".maps") = { } vip2tnl SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = MAX_IPTNL_ENTRIES,
};
static __always_inline void count_tx(__u32 protocol) static __always_inline void count_tx(__u32 protocol)
{ {

81
tools/testing/selftests/bpf/progs/test_xdp_noinline.c
View File

@ -164,66 +164,47 @@ struct lb_stats {
}; };
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_HASH);
__u32 max_entries; __uint(max_entries, 512);
struct vip_definition *key; __type(key, struct vip_definition);
struct vip_meta *value; __type(value, struct vip_meta);
} vip_map SEC(".maps") = { } vip_map SEC(".maps");
.type = BPF_MAP_TYPE_HASH,
.max_entries = 512,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_LRU_HASH);
__u32 max_entries; __uint(max_entries, 300);
__u32 map_flags; __uint(map_flags, 1U << 1);
struct flow_key *key; __type(key, struct flow_key);
struct real_pos_lru *value; __type(value, struct real_pos_lru);
} lru_cache SEC(".maps") = { } lru_cache SEC(".maps");
.type = BPF_MAP_TYPE_LRU_HASH,
.max_entries = 300,
.map_flags = 1U << 1,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 12 * 655);
__u32 *key; __type(key, __u32);
__u32 *value; __type(value, __u32);
} ch_rings SEC(".maps") = { } ch_rings SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 12 * 655,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 40);
__u32 *key; __type(key, __u32);
struct real_definition *value; __type(value, struct real_definition);
} reals SEC(".maps") = { } reals SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 40,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__u32 max_entries; __uint(max_entries, 515);
__u32 *key; __type(key, __u32);
struct lb_stats *value; __type(value, struct lb_stats);
} stats SEC(".maps") = { } stats SEC(".maps");
.type = BPF_MAP_TYPE_PERCPU_ARRAY,
.max_entries = 515,
};
struct { struct {
__u32 type; __uint(type, BPF_MAP_TYPE_ARRAY);
__u32 max_entries; __uint(max_entries, 16);
__u32 *key; __type(key, __u32);
struct ctl_value *value; __type(value, struct ctl_value);
} ctl_array SEC(".maps") = { } ctl_array SEC(".maps");
.type = BPF_MAP_TYPE_ARRAY,
.max_entries = 16,
};
struct eth_hdr { struct eth_hdr {
unsigned char eth_dest[6]; unsigned char eth_dest[6];