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>

diff --git a/tools/testing/selftests/bpf/progs/bpf_flow.c b/tools/testing/selftests/bpf/progs/bpf_flow.c
index 849f42e..5ae485a 100644 (file)
--- a/tools/testing/selftests/bpf/progs/bpf_flow.c
+++ b/tools/testing/selftests/bpf/progs/bpf_flow.c
@@ -58,26 +58,18 @@ struct frag_hdr {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 key_size;
-       __u32 value_size;
-} jmp_table SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PROG_ARRAY,
-       .max_entries = 8,
-       .key_size = sizeof(__u32),
-       .value_size = sizeof(__u32),
-};
+       __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
+       __uint(max_entries, 8);
+       __uint(key_size, sizeof(__u32));
+       __uint(value_size, sizeof(__u32));
+} jmp_table SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct bpf_flow_keys *value;
-} last_dissection SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, struct bpf_flow_keys);
+} last_dissection SEC(".maps");
 
 static __always_inline int export_flow_keys(struct bpf_flow_keys *keys,
                                            int ret)

diff --git a/tools/testing/selftests/bpf/progs/netcnt_prog.c b/tools/testing/selftests/bpf/progs/netcnt_prog.c
index a25c82a..38a9978 100644 (file)
--- a/tools/testing/selftests/bpf/progs/netcnt_prog.c
+++ b/tools/testing/selftests/bpf/progs/netcnt_prog.c
@@ -11,20 +11,16 @@
 #define NS_PER_SEC     1000000000
 
 struct {
-       __u32 type;
-       struct bpf_cgroup_storage_key *key;
-       struct percpu_net_cnt *value;
-} percpu_netcnt SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE);
+       __type(key, struct bpf_cgroup_storage_key);
+       __type(value, struct percpu_net_cnt);
+} percpu_netcnt SEC(".maps");
 
 struct {
-       __u32 type;
-       struct bpf_cgroup_storage_key *key;
-       struct net_cnt *value;
-} netcnt SEC(".maps") = {
-       .type = BPF_MAP_TYPE_CGROUP_STORAGE,
-};
+       __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE);
+       __type(key, struct bpf_cgroup_storage_key);
+       __type(value, struct net_cnt);
+} netcnt SEC(".maps");
 
 SEC("cgroup/skb")
 int bpf_nextcnt(struct __sk_buff *skb)

diff --git a/tools/testing/selftests/bpf/progs/socket_cookie_prog.c b/tools/testing/selftests/bpf/progs/socket_cookie_prog.c
index 6aabb68..e4440fd 100644 (file)
--- a/tools/testing/selftests/bpf/progs/socket_cookie_prog.c
+++ b/tools/testing/selftests/bpf/progs/socket_cookie_prog.c
@@ -13,14 +13,11 @@ struct socket_cookie {
 };
 
 struct {
-       __u32 type;
-       __u32 map_flags;
-       int *key;
-       struct socket_cookie *value;
-} socket_cookies SEC(".maps") = {
-       .type = BPF_MAP_TYPE_SK_STORAGE,
-       .map_flags = BPF_F_NO_PREALLOC,
-};
+       __uint(type, BPF_MAP_TYPE_SK_STORAGE);
+       __uint(map_flags, BPF_F_NO_PREALLOC);
+       __type(key, int);
+       __type(value, struct socket_cookie);
+} socket_cookies SEC(".maps");
 
 SEC("cgroup/connect6")
 int set_cookie(struct bpf_sock_addr *ctx)

diff --git a/tools/testing/selftests/bpf/progs/test_btf_newkv.c b/tools/testing/selftests/bpf/progs/test_btf_newkv.c
index 28c16bb..5ee3622 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_btf_newkv.c
+++ b/tools/testing/selftests/bpf/progs/test_btf_newkv.c
@@ -21,14 +21,11 @@ struct bpf_map_def SEC("maps") btf_map_legacy = {
 BPF_ANNOTATE_KV_PAIR(btf_map_legacy, int, struct ipv_counts);
 
 struct {
-       int *key;
-       struct ipv_counts *value;
-       unsigned int type;
-       unsigned int max_entries;
-} btf_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 4,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 4);
+       __type(key, int);
+       __type(value, struct ipv_counts);
+} btf_map SEC(".maps");
 
 struct dummy_tracepoint_args {
        unsigned long long pad;

diff --git a/tools/testing/selftests/bpf/progs/test_get_stack_rawtp.c b/tools/testing/selftests/bpf/progs/test_get_stack_rawtp.c
index aaa6ec2..d06b47a 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_get_stack_rawtp.c
+++ b/tools/testing/selftests/bpf/progs/test_get_stack_rawtp.c
@@ -16,26 +16,18 @@ struct stack_trace_t {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 key_size;
-       __u32 value_size;
-} perfmap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
-       .max_entries = 2,
-       .key_size = sizeof(int),
-       .value_size = sizeof(__u32),
-};
+       __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
+       __uint(max_entries, 2);
+       __uint(key_size, sizeof(int));
+       __uint(value_size, sizeof(__u32));
+} perfmap SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct stack_trace_t *value;
-} stackdata_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, struct stack_trace_t);
+} stackdata_map SEC(".maps");
 
 /* Allocate per-cpu space twice the needed. For the code below
  *   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.
  */
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
        __u64 (*value)[2 * MAX_STACK_RAWTP];
-} rawdata_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = 1,
-};
+} rawdata_map SEC(".maps");
 
 SEC("tracepoint/raw_syscalls/sys_enter")
 int bpf_prog1(void *ctx)

diff --git a/tools/testing/selftests/bpf/progs/test_global_data.c b/tools/testing/selftests/bpf/progs/test_global_data.c
index 866cc7d..32a6073 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_global_data.c
+++ b/tools/testing/selftests/bpf/progs/test_global_data.c
@@ -8,24 +8,18 @@
 #include "bpf_helpers.h"
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u64 *value;
-} result_number SEC(".maps") = {
-       .type           = BPF_MAP_TYPE_ARRAY,
-       .max_entries    = 11,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 11);
+       __type(key, __u32);
+       __type(value, __u64);
+} result_number SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 5);
+       __type(key, __u32);
        const char (*value)[32];
-} result_string SEC(".maps") = {
-       .type           = BPF_MAP_TYPE_ARRAY,
-       .max_entries    = 5,
-};
+} result_string SEC(".maps");
 
 struct foo {
        __u8  a;
@@ -34,14 +28,11 @@ struct foo {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct foo *value;
-} result_struct SEC(".maps") = {
-       .type           = BPF_MAP_TYPE_ARRAY,
-       .max_entries    = 5,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 5);
+       __type(key, __u32);
+       __type(value, struct foo);
+} result_struct SEC(".maps");
 
 /* Relocation tests for __u64s. */
 static       __u64 num0;

diff --git a/tools/testing/selftests/bpf/progs/test_l4lb.c b/tools/testing/selftests/bpf/progs/test_l4lb.c
index 848cbb9..1d652ee 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_l4lb.c
+++ b/tools/testing/selftests/bpf/progs/test_l4lb.c
@@ -170,54 +170,39 @@ struct eth_hdr {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       struct vip *key;
-       struct vip_meta *value;
-} vip_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = MAX_VIPS,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, MAX_VIPS);
+       __type(key, struct vip);
+       __type(value, struct vip_meta);
+} vip_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} ch_rings SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = CH_RINGS_SIZE,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, CH_RINGS_SIZE);
+       __type(key, __u32);
+       __type(value, __u32);
+} ch_rings SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct real_definition *value;
-} reals SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = MAX_REALS,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, MAX_REALS);
+       __type(key, __u32);
+       __type(value, struct real_definition);
+} reals SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct vip_stats *value;
-} stats SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = MAX_VIPS,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, MAX_VIPS);
+       __type(key, __u32);
+       __type(value, struct vip_stats);
+} stats SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct ctl_value *value;
-} ctl_array SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = CTL_MAP_SIZE,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, CTL_MAP_SIZE);
+       __type(key, __u32);
+       __type(value, struct ctl_value);
+} ctl_array SEC(".maps");
 
 static __always_inline __u32 get_packet_hash(struct packet_description *pckt,
                                             bool ipv6)

diff --git a/tools/testing/selftests/bpf/progs/test_l4lb_noinline.c b/tools/testing/selftests/bpf/progs/test_l4lb_noinline.c
index c63ecf3..2e4efe7 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_l4lb_noinline.c
+++ b/tools/testing/selftests/bpf/progs/test_l4lb_noinline.c
@@ -166,54 +166,39 @@ struct eth_hdr {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       struct vip *key;
-       struct vip_meta *value;
-} vip_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = MAX_VIPS,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, MAX_VIPS);
+       __type(key, struct vip);
+       __type(value, struct vip_meta);
+} vip_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} ch_rings SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = CH_RINGS_SIZE,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, CH_RINGS_SIZE);
+       __type(key, __u32);
+       __type(value, __u32);
+} ch_rings SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct real_definition *value;
-} reals SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = MAX_REALS,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, MAX_REALS);
+       __type(key, __u32);
+       __type(value, struct real_definition);
+} reals SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct vip_stats *value;
-} stats SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = MAX_VIPS,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, MAX_VIPS);
+       __type(key, __u32);
+       __type(value, struct vip_stats);
+} stats SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct ctl_value *value;
-} ctl_array SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = CTL_MAP_SIZE,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, CTL_MAP_SIZE);
+       __type(key, __u32);
+       __type(value, struct ctl_value);
+} ctl_array SEC(".maps");
 
 static __u32 get_packet_hash(struct packet_description *pckt,
                             bool ipv6)

diff --git a/tools/testing/selftests/bpf/progs/test_map_lock.c b/tools/testing/selftests/bpf/progs/test_map_lock.c
index 40d9c28..bb7ce35 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_map_lock.c
+++ b/tools/testing/selftests/bpf/progs/test_map_lock.c
@@ -12,14 +12,11 @@ struct hmap_elem {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct hmap_elem *value;
-} hash_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, struct hmap_elem);
+} hash_map SEC(".maps");
 
 struct array_elem {
        struct bpf_spin_lock lock;
@@ -27,14 +24,11 @@ struct array_elem {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       int *key;
-       struct array_elem *value;
-} array_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, int);
+       __type(value, struct array_elem);
+} array_map SEC(".maps");
 
 SEC("map_lock_demo")
 int bpf_map_lock_test(struct __sk_buff *skb)

diff --git a/tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c b/tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c
index 435a952..ea7d84f 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c
+++ b/tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c
@@ -22,56 +22,39 @@ int _version SEC("version") = 1;
 #endif
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 key_size;
-       __u32 value_size;
-} outer_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY_OF_MAPS,
-       .max_entries = 1,
-       .key_size = sizeof(__u32),
-       .value_size = sizeof(__u32),
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __uint(max_entries, 1);
+       __uint(key_size, sizeof(__u32));
+       __uint(value_size, sizeof(__u32));
+} outer_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} result_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = NR_RESULTS,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, NR_RESULTS);
+       __type(key, __u32);
+       __type(value, __u32);
+} result_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       int *value;
-} tmp_index_ovr_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, int);
+} tmp_index_ovr_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} linum_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, __u32);
+} linum_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct data_check *value;
-} data_check_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, struct data_check);
+} data_check_map SEC(".maps");
 
 #define GOTO_DONE(_result) ({                  \
        result = (_result);                     \

diff --git a/tools/testing/selftests/bpf/progs/test_send_signal_kern.c b/tools/testing/selftests/bpf/progs/test_send_signal_kern.c
index 6ac68be..0e6be01 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_send_signal_kern.c
+++ b/tools/testing/selftests/bpf/progs/test_send_signal_kern.c
@@ -5,24 +5,18 @@
 #include "bpf_helpers.h"
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u64 *value;
-} info_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, __u64);
+} info_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u64 *value;
-} status_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, __u64);
+} status_map SEC(".maps");
 
 SEC("send_signal_demo")
 int bpf_send_signal_test(void *ctx)

diff --git a/tools/testing/selftests/bpf/progs/test_sock_fields_kern.c b/tools/testing/selftests/bpf/progs/test_sock_fields_kern.c
index c3d383d..a47b003 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_sock_fields_kern.c
+++ b/tools/testing/selftests/bpf/progs/test_sock_fields_kern.c
@@ -28,44 +28,32 @@ enum bpf_linum_array_idx {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct sockaddr_in6 *value;
-} addr_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = __NR_BPF_ADDR_ARRAY_IDX,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, __NR_BPF_ADDR_ARRAY_IDX);
+       __type(key, __u32);
+       __type(value, struct sockaddr_in6);
+} addr_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct bpf_sock *value;
-} sock_result_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = __NR_BPF_RESULT_ARRAY_IDX,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, __NR_BPF_RESULT_ARRAY_IDX);
+       __type(key, __u32);
+       __type(value, struct bpf_sock);
+} sock_result_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct bpf_tcp_sock *value;
-} tcp_sock_result_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = __NR_BPF_RESULT_ARRAY_IDX,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, __NR_BPF_RESULT_ARRAY_IDX);
+       __type(key, __u32);
+       __type(value, struct bpf_tcp_sock);
+} tcp_sock_result_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} linum_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = __NR_BPF_LINUM_ARRAY_IDX,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, __NR_BPF_LINUM_ARRAY_IDX);
+       __type(key, __u32);
+       __type(value, __u32);
+} linum_map SEC(".maps");
 
 struct bpf_spinlock_cnt {
        struct bpf_spin_lock lock;
@@ -73,24 +61,18 @@ struct bpf_spinlock_cnt {
 };
 
 struct {
-       __u32 type;
-       __u32 map_flags;
-       int *key;
-       struct bpf_spinlock_cnt *value;
-} sk_pkt_out_cnt SEC(".maps") = {
-       .type = BPF_MAP_TYPE_SK_STORAGE,
-       .map_flags = BPF_F_NO_PREALLOC,
-};
+       __uint(type, BPF_MAP_TYPE_SK_STORAGE);
+       __uint(map_flags, BPF_F_NO_PREALLOC);
+       __type(key, int);
+       __type(value, struct bpf_spinlock_cnt);
+} sk_pkt_out_cnt SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 map_flags;
-       int *key;
-       struct bpf_spinlock_cnt *value;
-} sk_pkt_out_cnt10 SEC(".maps") = {
-       .type = BPF_MAP_TYPE_SK_STORAGE,
-       .map_flags = BPF_F_NO_PREALLOC,
-};
+       __uint(type, BPF_MAP_TYPE_SK_STORAGE);
+       __uint(map_flags, BPF_F_NO_PREALLOC);
+       __type(key, int);
+       __type(value, struct bpf_spinlock_cnt);
+} sk_pkt_out_cnt10 SEC(".maps");
 
 static bool is_loopback6(__u32 *a6)
 {

diff --git a/tools/testing/selftests/bpf/progs/test_spin_lock.c b/tools/testing/selftests/bpf/progs/test_spin_lock.c
index 0a77ae3..a43b999 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_spin_lock.c
+++ b/tools/testing/selftests/bpf/progs/test_spin_lock.c
@@ -11,14 +11,11 @@ struct hmap_elem {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       int *key;
-       struct hmap_elem *value;
-} hmap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 1);
+       __type(key, int);
+       __type(value, struct hmap_elem);
+} hmap SEC(".maps");
 
 struct cls_elem {
        struct bpf_spin_lock lock;
@@ -26,12 +23,10 @@ struct cls_elem {
 };
 
 struct {
-       __u32 type;
-       struct bpf_cgroup_storage_key *key;
-       struct cls_elem *value;
-} cls_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_CGROUP_STORAGE,
-};
+       __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE);
+       __type(key, struct bpf_cgroup_storage_key);
+       __type(value, struct cls_elem);
+} cls_map SEC(".maps");
 
 struct bpf_vqueue {
        struct bpf_spin_lock lock;
@@ -42,14 +37,11 @@ struct bpf_vqueue {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       int *key;
-       struct bpf_vqueue *value;
-} vqueue SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, int);
+       __type(value, struct bpf_vqueue);
+} vqueue SEC(".maps");
 
 #define CREDIT_PER_NS(delta, rate) (((delta) * rate) >> 20)
 

diff --git a/tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c b/tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c
index fcf2280..bbfc833 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c
+++ b/tools/testing/selftests/bpf/progs/test_stacktrace_build_id.c
@@ -9,51 +9,36 @@
 #endif
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} control_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, __u32);
+} control_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} stackid_hmap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 16384,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 16384);
+       __type(key, __u32);
+       __type(value, __u32);
+} stackid_hmap SEC(".maps");
 
 typedef struct bpf_stack_build_id stack_trace_t[PERF_MAX_STACK_DEPTH];
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 map_flags;
-       __u32 key_size;
-       __u32 value_size;
-} 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),
-};
+       __uint(type, BPF_MAP_TYPE_STACK_TRACE);
+       __uint(max_entries, 128);
+       __uint(map_flags, BPF_F_STACK_BUILD_ID);
+       __uint(key_size, sizeof(__u32));
+       __uint(value_size, sizeof(stack_trace_t));
+} stackmap SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 128);
+       __type(key, __u32);
        /* there seems to be a bug in kernel not handling typedef properly */
        struct bpf_stack_build_id (*value)[PERF_MAX_STACK_DEPTH];
-} stack_amap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 128,
-};
+} stack_amap SEC(".maps");
 
 /* taken from /sys/kernel/debug/tracing/events/random/urandom_read/format */
 struct random_urandom_args {

diff --git a/tools/testing/selftests/bpf/progs/test_stacktrace_map.c b/tools/testing/selftests/bpf/progs/test_stacktrace_map.c
index 7ad09ad..803c15d 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_stacktrace_map.c
+++ b/tools/testing/selftests/bpf/progs/test_stacktrace_map.c
@@ -9,48 +9,34 @@
 #endif
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} control_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 1,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 1);
+       __type(key, __u32);
+       __type(value, __u32);
+} control_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} stackid_hmap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 16384,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 16384);
+       __type(key, __u32);
+       __type(value, __u32);
+} stackid_hmap SEC(".maps");
 
 typedef __u64 stack_trace_t[PERF_MAX_STACK_DEPTH];
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 key_size;
-       __u32 value_size;
-} stackmap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_STACK_TRACE,
-       .max_entries = 16384,
-       .key_size = sizeof(__u32),
-       .value_size = sizeof(stack_trace_t),
-};
+       __uint(type, BPF_MAP_TYPE_STACK_TRACE);
+       __uint(max_entries, 16384);
+       __uint(key_size, sizeof(__u32));
+       __uint(value_size, sizeof(stack_trace_t));
+} stackmap SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 16384);
+       __type(key, __u32);
        __u64 (*value)[PERF_MAX_STACK_DEPTH];
-} stack_amap SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 16384,
-};
+} stack_amap SEC(".maps");
 
 /* taken from /sys/kernel/debug/tracing/events/sched/sched_switch/format */
 struct sched_switch_args {

diff --git a/tools/testing/selftests/bpf/progs/test_tcp_estats.c b/tools/testing/selftests/bpf/progs/test_tcp_estats.c
index df98f7e..c8c595d 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_tcp_estats.c
+++ b/tools/testing/selftests/bpf/progs/test_tcp_estats.c
@@ -149,14 +149,11 @@ struct tcp_estats_basic_event {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct tcp_estats_basic_event *value;
-} ev_record_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 1024,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 1024);
+       __type(key, __u32);
+       __type(value, struct tcp_estats_basic_event);
+} ev_record_map SEC(".maps");
 
 struct dummy_tracepoint_args {
        unsigned long long pad;

diff --git a/tools/testing/selftests/bpf/progs/test_tcpbpf_kern.c b/tools/testing/selftests/bpf/progs/test_tcpbpf_kern.c
index 38e10c9..2e23361 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_tcpbpf_kern.c
+++ b/tools/testing/selftests/bpf/progs/test_tcpbpf_kern.c
@@ -15,24 +15,18 @@
 #include "test_tcpbpf.h"
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct tcpbpf_globals *value;
-} global_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 4,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 4);
+       __type(key, __u32);
+       __type(value, struct tcpbpf_globals);
+} global_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       int *value;
-} sockopt_results SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 2,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 2);
+       __type(key, __u32);
+       __type(value, int);
+} sockopt_results SEC(".maps");
 
 static inline void update_event_map(int event)
 {

diff --git a/tools/testing/selftests/bpf/progs/test_tcpnotify_kern.c b/tools/testing/selftests/bpf/progs/test_tcpnotify_kern.c
index d073d37..08346e7 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_tcpnotify_kern.c
+++ b/tools/testing/selftests/bpf/progs/test_tcpnotify_kern.c
@@ -15,26 +15,18 @@
 #include "test_tcpnotify.h"
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct tcpnotify_globals *value;
-} global_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 4,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 4);
+       __type(key, __u32);
+       __type(value, struct tcpnotify_globals);
+} global_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 key_size;
-       __u32 value_size;
-} perf_event_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
-       .max_entries = 2,
-       .key_size = sizeof(int),
-       .value_size = sizeof(__u32),
-};
+       __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
+       __uint(max_entries, 2);
+       __uint(key_size, sizeof(int));
+       __uint(value_size, sizeof(__u32));
+} perf_event_map SEC(".maps");
 
 int _version SEC("version") = 1;
 

diff --git a/tools/testing/selftests/bpf/progs/test_xdp.c b/tools/testing/selftests/bpf/progs/test_xdp.c
index ec3d2c1..0941c65 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_xdp.c
+++ b/tools/testing/selftests/bpf/progs/test_xdp.c
@@ -23,24 +23,18 @@
 int _version SEC("version") = 1;
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u64 *value;
-} rxcnt SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = 256,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, 256);
+       __type(key, __u32);
+       __type(value, __u64);
+} rxcnt SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       struct vip *key;
-       struct iptnl_info *value;
-} vip2tnl SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = MAX_IPTNL_ENTRIES,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, MAX_IPTNL_ENTRIES);
+       __type(key, struct vip);
+       __type(value, struct iptnl_info);
+} vip2tnl SEC(".maps");
 
 static __always_inline void count_tx(__u32 protocol)
 {

diff --git a/tools/testing/selftests/bpf/progs/test_xdp_noinline.c b/tools/testing/selftests/bpf/progs/test_xdp_noinline.c
index d2eddb5..dad8a7e 100644 (file)
--- a/tools/testing/selftests/bpf/progs/test_xdp_noinline.c
+++ b/tools/testing/selftests/bpf/progs/test_xdp_noinline.c
@@ -164,66 +164,47 @@ struct lb_stats {
 };
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       struct vip_definition *key;
-       struct vip_meta *value;
-} vip_map SEC(".maps") = {
-       .type = BPF_MAP_TYPE_HASH,
-       .max_entries = 512,
-};
+       __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(max_entries, 512);
+       __type(key, struct vip_definition);
+       __type(value, struct vip_meta);
+} vip_map SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 map_flags;
-       struct flow_key *key;
-       struct real_pos_lru *value;
-} lru_cache SEC(".maps") = {
-       .type = BPF_MAP_TYPE_LRU_HASH,
-       .max_entries = 300,
-       .map_flags = 1U << 1,
-};
+       __uint(type, BPF_MAP_TYPE_LRU_HASH);
+       __uint(max_entries, 300);
+       __uint(map_flags, 1U << 1);
+       __type(key, struct flow_key);
+       __type(value, struct real_pos_lru);
+} lru_cache SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       __u32 *value;
-} ch_rings SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 12 * 655,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 12 * 655);
+       __type(key, __u32);
+       __type(value, __u32);
+} ch_rings SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct real_definition *value;
-} reals SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 40,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 40);
+       __type(key, __u32);
+       __type(value, struct real_definition);
+} reals SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct lb_stats *value;
-} stats SEC(".maps") = {
-       .type = BPF_MAP_TYPE_PERCPU_ARRAY,
-       .max_entries = 515,
-};
+       __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+       __uint(max_entries, 515);
+       __type(key, __u32);
+       __type(value, struct lb_stats);
+} stats SEC(".maps");
 
 struct {
-       __u32 type;
-       __u32 max_entries;
-       __u32 *key;
-       struct ctl_value *value;
-} ctl_array SEC(".maps") = {
-       .type = BPF_MAP_TYPE_ARRAY,
-       .max_entries = 16,
-};
+       __uint(type, BPF_MAP_TYPE_ARRAY);
+       __uint(max_entries, 16);
+       __type(key, __u32);
+       __type(value, struct ctl_value);
+} ctl_array SEC(".maps");
 
 struct eth_hdr {
        unsigned char eth_dest[6];