Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
selftests/bpf: Turn on libbpf 1.0 mode and fix all IS_ERR checks
Turn ony libbpf 1.0 mode. Fix all the explicit IS_ERR checks that now will be
broken because libbpf returns NULL on error (and sets errno). Fix
ASSERT_OK_PTR and ASSERT_ERR_PTR to work for both old mode and new modes and
use them throughout selftests. This is trivial to do by using
libbpf_get_error() API that all libbpf users are supposed to use, instead of
IS_ERR checks.
A bunch of checks also did explicit -1 comparison for various fd-returning
APIs. Such checks are replaced with >= 0 or < 0 cases.
There were also few misuses of bpf_object__find_map_by_name() in test_maps.
Those are fixed in this patch as well.
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: John Fastabend <john.fastabend@gmail.com>
Acked-by: Toke Høiland-Jørgensen <toke@redhat.com>
Link: https://lore.kernel.org/bpf/20210525035935.1461796-3-andrii@kernel.org
authored by
Andrii Nakryiko
and committed by
Alexei Starovoitov
bad2e478
5981881d
+347
-425
+1
tools/testing/selftests/bpf/bench.c
+1
tools/testing/selftests/bpf/bench.c
+1
-1
tools/testing/selftests/bpf/benchs/bench_rename.c
+1
-1
tools/testing/selftests/bpf/benchs/bench_rename.c
+3
-3
tools/testing/selftests/bpf/benchs/bench_ringbufs.c
+3
-3
tools/testing/selftests/bpf/benchs/bench_ringbufs.c
···
181
181
}
182
182
183
183
link = bpf_program__attach(ctx->skel->progs.bench_ringbuf);
184
-
if (IS_ERR(link)) {
184
+
if (!link) {
185
185
fprintf(stderr, "failed to attach program!\n");
186
186
exit(1);
187
187
}
···
271
271
}
272
272
273
273
link = bpf_program__attach(ctx->skel->progs.bench_ringbuf);
274
-
if (IS_ERR(link)) {
274
+
if (!link) {
275
275
fprintf(stderr, "failed to attach program\n");
276
276
exit(1);
277
277
}
···
430
430
}
431
431
432
432
link = bpf_program__attach(ctx->skel->progs.bench_perfbuf);
433
-
if (IS_ERR(link)) {
433
+
if (!link) {
434
434
fprintf(stderr, "failed to attach program\n");
435
435
exit(1);
436
436
}
+1
-1
tools/testing/selftests/bpf/benchs/bench_trigger.c
+1
-1
tools/testing/selftests/bpf/benchs/bench_trigger.c
+4
-8
tools/testing/selftests/bpf/prog_tests/attach_probe.c
+4
-8
tools/testing/selftests/bpf/prog_tests/attach_probe.c
···
85
85
kprobe_link = bpf_program__attach_kprobe(skel->progs.handle_kprobe,
86
86
false /* retprobe */,
87
87
SYS_NANOSLEEP_KPROBE_NAME);
88
-
if (CHECK(IS_ERR(kprobe_link), "attach_kprobe",
89
-
"err %ld\n", PTR_ERR(kprobe_link)))
88
+
if (!ASSERT_OK_PTR(kprobe_link, "attach_kprobe"))
90
89
goto cleanup;
91
90
skel->links.handle_kprobe = kprobe_link;
92
91
93
92
kretprobe_link = bpf_program__attach_kprobe(skel->progs.handle_kretprobe,
94
93
true /* retprobe */,
95
94
SYS_NANOSLEEP_KPROBE_NAME);
96
-
if (CHECK(IS_ERR(kretprobe_link), "attach_kretprobe",
97
-
"err %ld\n", PTR_ERR(kretprobe_link)))
95
+
if (!ASSERT_OK_PTR(kretprobe_link, "attach_kretprobe"))
98
96
goto cleanup;
99
97
skel->links.handle_kretprobe = kretprobe_link;
100
98
···
101
103
0 /* self pid */,
102
104
"/proc/self/exe",
103
105
uprobe_offset);
104
-
if (CHECK(IS_ERR(uprobe_link), "attach_uprobe",
105
-
"err %ld\n", PTR_ERR(uprobe_link)))
106
+
if (!ASSERT_OK_PTR(uprobe_link, "attach_uprobe"))
106
107
goto cleanup;
107
108
skel->links.handle_uprobe = uprobe_link;
108
109
···
110
113
-1 /* any pid */,
111
114
"/proc/self/exe",
112
115
uprobe_offset);
113
-
if (CHECK(IS_ERR(uretprobe_link), "attach_uretprobe",
114
-
"err %ld\n", PTR_ERR(uretprobe_link)))
116
+
if (!ASSERT_OK_PTR(uretprobe_link, "attach_uretprobe"))
115
117
goto cleanup;
116
118
skel->links.handle_uretprobe = uretprobe_link;
117
119
+14
-17
tools/testing/selftests/bpf/prog_tests/bpf_iter.c
+14
-17
tools/testing/selftests/bpf/prog_tests/bpf_iter.c
···
47
47
int iter_fd, len;
48
48
49
49
link = bpf_program__attach_iter(prog, NULL);
50
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
50
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
51
51
return;
52
52
53
53
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
201
201
int ret = 0;
202
202
203
203
link = bpf_program__attach_iter(prog, NULL);
204
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
204
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
205
205
return ret;
206
206
207
207
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
396
396
return;
397
397
398
398
link = bpf_program__attach_iter(skel1->progs.dump_task, NULL);
399
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
399
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
400
400
goto out;
401
401
402
402
/* unlink this path if it exists. */
···
502
502
skel->bss->map2_id = map_info.id;
503
503
504
504
link = bpf_program__attach_iter(skel->progs.dump_bpf_map, NULL);
505
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
505
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
506
506
goto free_map2;
507
507
508
508
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
607
607
opts.link_info = &linfo;
608
608
opts.link_info_len = sizeof(linfo);
609
609
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
610
-
if (CHECK(!IS_ERR(link), "attach_iter",
611
-
"attach_iter for hashmap2 unexpected succeeded\n"))
610
+
if (!ASSERT_ERR_PTR(link, "attach_iter"))
612
611
goto out;
613
612
614
613
linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap3);
615
614
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
616
-
if (CHECK(!IS_ERR(link), "attach_iter",
617
-
"attach_iter for hashmap3 unexpected succeeded\n"))
615
+
if (!ASSERT_ERR_PTR(link, "attach_iter"))
618
616
goto out;
619
617
620
618
/* hashmap1 should be good, update map values here */
···
634
636
635
637
linfo.map.map_fd = map_fd;
636
638
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
637
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
639
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
638
640
goto out;
639
641
640
642
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
725
727
opts.link_info = &linfo;
726
728
opts.link_info_len = sizeof(linfo);
727
729
link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_hash_map, &opts);
728
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
730
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
729
731
goto out;
730
732
731
733
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
796
798
opts.link_info = &linfo;
797
799
opts.link_info_len = sizeof(linfo);
798
800
link = bpf_program__attach_iter(skel->progs.dump_bpf_array_map, &opts);
799
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
801
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
800
802
goto out;
801
803
802
804
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
892
894
opts.link_info = &linfo;
893
895
opts.link_info_len = sizeof(linfo);
894
896
link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_array_map, &opts);
895
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
897
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
896
898
goto out;
897
899
898
900
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
955
957
opts.link_info_len = sizeof(linfo);
956
958
link = bpf_program__attach_iter(skel->progs.delete_bpf_sk_storage_map,
957
959
&opts);
958
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
960
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
959
961
goto out;
960
962
961
963
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
1073
1075
opts.link_info = &linfo;
1074
1076
opts.link_info_len = sizeof(linfo);
1075
1077
link = bpf_program__attach_iter(skel->progs.dump_bpf_sk_storage_map, &opts);
1076
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
1078
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
1077
1079
goto out;
1078
1080
1079
1081
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
1126
1128
opts.link_info = &linfo;
1127
1129
opts.link_info_len = sizeof(linfo);
1128
1130
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
1129
-
if (CHECK(!IS_ERR(link), "attach_iter", "unexpected success\n"))
1131
+
if (!ASSERT_ERR_PTR(link, "attach_iter"))
1130
1132
bpf_link__destroy(link);
1131
1133
1132
1134
bpf_iter_test_kern5__destroy(skel);
···
1184
1186
skel->links.proc_maps = bpf_program__attach_iter(
1185
1187
skel->progs.proc_maps, NULL);
1186
1188
1187
-
if (CHECK(IS_ERR(skel->links.proc_maps), "bpf_program__attach_iter",
1188
-
"attach iterator failed\n")) {
1189
+
if (!ASSERT_OK_PTR(skel->links.proc_maps, "bpf_program__attach_iter")) {
1189
1190
skel->links.proc_maps = NULL;
1190
1191
goto out;
1191
1192
}
+3
-5
tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c
+3
-5
tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c
···
82
82
bytes, total_bytes, nr_sent, errno);
83
83
84
84
done:
85
-
if (fd != -1)
85
+
if (fd >= 0)
86
86
close(fd);
87
87
if (err) {
88
88
WRITE_ONCE(stop, 1);
···
191
191
return;
192
192
193
193
link = bpf_map__attach_struct_ops(cubic_skel->maps.cubic);
194
-
if (CHECK(IS_ERR(link), "bpf_map__attach_struct_ops", "err:%ld\n",
195
-
PTR_ERR(link))) {
194
+
if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) {
196
195
bpf_cubic__destroy(cubic_skel);
197
196
return;
198
197
}
···
212
213
return;
213
214
214
215
link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp);
215
-
if (CHECK(IS_ERR(link), "bpf_map__attach_struct_ops", "err:%ld\n",
216
-
PTR_ERR(link))) {
216
+
if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) {
217
217
bpf_dctcp__destroy(dctcp_skel);
218
218
return;
219
219
}
+47
-46
tools/testing/selftests/bpf/prog_tests/btf.c
+47
-46
tools/testing/selftests/bpf/prog_tests/btf.c
···
3811
3811
always_log);
3812
3812
free(raw_btf);
3813
3813
3814
-
err = ((btf_fd == -1) != test->btf_load_err);
3814
+
err = ((btf_fd < 0) != test->btf_load_err);
3815
3815
if (CHECK(err, "btf_fd:%d test->btf_load_err:%u",
3816
3816
btf_fd, test->btf_load_err) ||
3817
3817
CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
···
3820
3820
goto done;
3821
3821
}
3822
3822
3823
-
if (err || btf_fd == -1)
3823
+
if (err || btf_fd < 0)
3824
3824
goto done;
3825
3825
3826
3826
create_attr.name = test->map_name;
···
3834
3834
3835
3835
map_fd = bpf_create_map_xattr(&create_attr);
3836
3836
3837
-
err = ((map_fd == -1) != test->map_create_err);
3837
+
err = ((map_fd < 0) != test->map_create_err);
3838
3838
CHECK(err, "map_fd:%d test->map_create_err:%u",
3839
3839
map_fd, test->map_create_err);
3840
3840
3841
3841
done:
3842
3842
if (*btf_log_buf && (err || always_log))
3843
3843
fprintf(stderr, "\n%s", btf_log_buf);
3844
-
if (btf_fd != -1)
3844
+
if (btf_fd >= 0)
3845
3845
close(btf_fd);
3846
-
if (map_fd != -1)
3846
+
if (map_fd >= 0)
3847
3847
close(map_fd);
3848
3848
}
3849
3849
···
3941
3941
btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
3942
3942
btf_log_buf, BTF_LOG_BUF_SIZE,
3943
3943
always_log);
3944
-
if (CHECK(btf_fd == -1, "errno:%d", errno)) {
3944
+
if (CHECK(btf_fd < 0, "errno:%d", errno)) {
3945
3945
err = -1;
3946
3946
goto done;
3947
3947
}
···
3987
3987
free(raw_btf);
3988
3988
free(user_btf);
3989
3989
3990
-
if (btf_fd != -1)
3990
+
if (btf_fd >= 0)
3991
3991
close(btf_fd);
3992
3992
3993
3993
return err;
···
4029
4029
btf_fd[0] = bpf_load_btf(raw_btf, raw_btf_size,
4030
4030
btf_log_buf, BTF_LOG_BUF_SIZE,
4031
4031
always_log);
4032
-
if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {
4032
+
if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4033
4033
err = -1;
4034
4034
goto done;
4035
4035
}
···
4043
4043
}
4044
4044
4045
4045
btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);
4046
-
if (CHECK(btf_fd[1] == -1, "errno:%d", errno)) {
4046
+
if (CHECK(btf_fd[1] < 0, "errno:%d", errno)) {
4047
4047
err = -1;
4048
4048
goto done;
4049
4049
}
···
4071
4071
create_attr.btf_value_type_id = 2;
4072
4072
4073
4073
map_fd = bpf_create_map_xattr(&create_attr);
4074
-
if (CHECK(map_fd == -1, "errno:%d", errno)) {
4074
+
if (CHECK(map_fd < 0, "errno:%d", errno)) {
4075
4075
err = -1;
4076
4076
goto done;
4077
4077
}
···
4094
4094
4095
4095
/* Test BTF ID is removed from the kernel */
4096
4096
btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
4097
-
if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {
4097
+
if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4098
4098
err = -1;
4099
4099
goto done;
4100
4100
}
···
4105
4105
close(map_fd);
4106
4106
map_fd = -1;
4107
4107
btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
4108
-
if (CHECK(btf_fd[0] != -1, "BTF lingers")) {
4108
+
if (CHECK(btf_fd[0] >= 0, "BTF lingers")) {
4109
4109
err = -1;
4110
4110
goto done;
4111
4111
}
···
4117
4117
fprintf(stderr, "\n%s", btf_log_buf);
4118
4118
4119
4119
free(raw_btf);
4120
-
if (map_fd != -1)
4120
+
if (map_fd >= 0)
4121
4121
close(map_fd);
4122
4122
for (i = 0; i < 2; i++) {
4123
4123
free(user_btf[i]);
4124
-
if (btf_fd[i] != -1)
4124
+
if (btf_fd[i] >= 0)
4125
4125
close(btf_fd[i]);
4126
4126
}
4127
4127
···
4166
4166
btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
4167
4167
btf_log_buf, BTF_LOG_BUF_SIZE,
4168
4168
always_log);
4169
-
if (CHECK(btf_fd == -1, "errno:%d", errno)) {
4169
+
if (CHECK(btf_fd <= 0, "errno:%d", errno)) {
4170
4170
err = -1;
4171
4171
goto done;
4172
4172
}
···
4212
4212
free(raw_btf);
4213
4213
free(user_btf);
4214
4214
4215
-
if (btf_fd != -1)
4215
+
if (btf_fd >= 0)
4216
4216
close(btf_fd);
4217
4217
}
4218
4218
···
4249
4249
return;
4250
4250
4251
4251
btf = btf__parse_elf(test->file, &btf_ext);
4252
-
if (IS_ERR(btf)) {
4253
-
if (PTR_ERR(btf) == -ENOENT) {
4252
+
err = libbpf_get_error(btf);
4253
+
if (err) {
4254
+
if (err == -ENOENT) {
4254
4255
printf("%s:SKIP: No ELF %s found", __func__, BTF_ELF_SEC);
4255
4256
test__skip();
4256
4257
return;
···
4264
4263
btf_ext__free(btf_ext);
4265
4264
4266
4265
obj = bpf_object__open(test->file);
4267
-
if (CHECK(IS_ERR(obj), "obj: %ld", PTR_ERR(obj)))
4266
+
err = libbpf_get_error(obj);
4267
+
if (CHECK(err, "obj: %d", err))
4268
4268
return;
4269
4269
4270
4270
prog = bpf_program__next(NULL, obj);
···
4300
4298
info_len = sizeof(struct bpf_prog_info);
4301
4299
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
4302
4300
4303
-
if (CHECK(err == -1, "invalid get info (1st) errno:%d", errno)) {
4301
+
if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
4304
4302
fprintf(stderr, "%s\n", btf_log_buf);
4305
4303
err = -1;
4306
4304
goto done;
···
4332
4330
4333
4331
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
4334
4332
4335
-
if (CHECK(err == -1, "invalid get info (2nd) errno:%d", errno)) {
4333
+
if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
4336
4334
fprintf(stderr, "%s\n", btf_log_buf);
4337
4335
err = -1;
4338
4336
goto done;
···
4888
4886
always_log);
4889
4887
free(raw_btf);
4890
4888
4891
-
if (CHECK(btf_fd == -1, "errno:%d", errno)) {
4889
+
if (CHECK(btf_fd < 0, "errno:%d", errno)) {
4892
4890
err = -1;
4893
4891
goto done;
4894
4892
}
···
4903
4901
create_attr.btf_value_type_id = test->value_type_id;
4904
4902
4905
4903
map_fd = bpf_create_map_xattr(&create_attr);
4906
-
if (CHECK(map_fd == -1, "errno:%d", errno)) {
4904
+
if (CHECK(map_fd < 0, "errno:%d", errno)) {
4907
4905
err = -1;
4908
4906
goto done;
4909
4907
}
···
4984
4982
4985
4983
err = check_line(expected_line, nexpected_line,
4986
4984
sizeof(expected_line), line);
4987
-
if (err == -1)
4985
+
if (err < 0)
4988
4986
goto done;
4989
4987
}
4990
4988
···
5000
4998
cpu, cmapv);
5001
4999
err = check_line(expected_line, nexpected_line,
5002
5000
sizeof(expected_line), line);
5003
-
if (err == -1)
5001
+
if (err < 0)
5004
5002
goto done;
5005
5003
5006
5004
cmapv = cmapv + rounded_value_size;
···
5038
5036
fprintf(stderr, "OK");
5039
5037
if (*btf_log_buf && (err || always_log))
5040
5038
fprintf(stderr, "\n%s", btf_log_buf);
5041
-
if (btf_fd != -1)
5039
+
if (btf_fd >= 0)
5042
5040
close(btf_fd);
5043
-
if (map_fd != -1)
5041
+
if (map_fd >= 0)
5044
5042
close(map_fd);
5045
5043
if (pin_file)
5046
5044
fclose(pin_file);
···
5952
5950
/* get necessary lens */
5953
5951
info_len = sizeof(struct bpf_prog_info);
5954
5952
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
5955
-
if (CHECK(err == -1, "invalid get info (1st) errno:%d", errno)) {
5953
+
if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
5956
5954
fprintf(stderr, "%s\n", btf_log_buf);
5957
5955
return -1;
5958
5956
}
···
5982
5980
info.func_info_rec_size = rec_size;
5983
5981
info.func_info = ptr_to_u64(func_info);
5984
5982
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
5985
-
if (CHECK(err == -1, "invalid get info (2nd) errno:%d", errno)) {
5983
+
if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
5986
5984
fprintf(stderr, "%s\n", btf_log_buf);
5987
5985
err = -1;
5988
5986
goto done;
···
6046
6044
6047
6045
info_len = sizeof(struct bpf_prog_info);
6048
6046
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
6049
-
if (CHECK(err == -1, "err:%d errno:%d", err, errno)) {
6047
+
if (CHECK(err < 0, "err:%d errno:%d", err, errno)) {
6050
6048
err = -1;
6051
6049
goto done;
6052
6050
}
···
6125
6123
* Only recheck the info.*line_info* fields.
6126
6124
* Other fields are not the concern of this test.
6127
6125
*/
6128
-
if (CHECK(err == -1 ||
6126
+
if (CHECK(err < 0 ||
6129
6127
info.nr_line_info != cnt ||
6130
6128
(jited_cnt && !info.jited_line_info) ||
6131
6129
info.nr_jited_line_info != jited_cnt ||
···
6262
6260
always_log);
6263
6261
free(raw_btf);
6264
6262
6265
-
if (CHECK(btf_fd == -1, "invalid btf_fd errno:%d", errno)) {
6263
+
if (CHECK(btf_fd < 0, "invalid btf_fd errno:%d", errno)) {
6266
6264
err = -1;
6267
6265
goto done;
6268
6266
}
···
6275
6273
patched_linfo = patch_name_tbd(test->line_info,
6276
6274
test->str_sec, linfo_str_off,
6277
6275
test->str_sec_size, &linfo_size);
6278
-
if (IS_ERR(patched_linfo)) {
6276
+
err = libbpf_get_error(patched_linfo);
6277
+
if (err) {
6279
6278
fprintf(stderr, "error in creating raw bpf_line_info");
6280
6279
err = -1;
6281
6280
goto done;
···
6300
6297
}
6301
6298
6302
6299
prog_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
6303
-
err = ((prog_fd == -1) != test->expected_prog_load_failure);
6300
+
err = ((prog_fd < 0) != test->expected_prog_load_failure);
6304
6301
if (CHECK(err, "prog_fd:%d expected_prog_load_failure:%u errno:%d",
6305
6302
prog_fd, test->expected_prog_load_failure, errno) ||
6306
6303
CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
···
6309
6306
goto done;
6310
6307
}
6311
6308
6312
-
if (prog_fd == -1)
6309
+
if (prog_fd < 0)
6313
6310
goto done;
6314
6311
6315
6312
err = test_get_finfo(test, prog_fd);
···
6326
6323
if (*btf_log_buf && (err || always_log))
6327
6324
fprintf(stderr, "\n%s", btf_log_buf);
6328
6325
6329
-
if (btf_fd != -1)
6326
+
if (btf_fd >= 0)
6330
6327
close(btf_fd);
6331
-
if (prog_fd != -1)
6328
+
if (prog_fd >= 0)
6332
6329
close(prog_fd);
6333
6330
6334
-
if (!IS_ERR(patched_linfo))
6331
+
if (!libbpf_get_error(patched_linfo))
6335
6332
free(patched_linfo);
6336
6333
}
6337
6334
···
6842
6839
return;
6843
6840
6844
6841
test_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
6842
+
err = libbpf_get_error(test_btf);
6845
6843
free(raw_btf);
6846
-
if (CHECK(IS_ERR(test_btf), "invalid test_btf errno:%ld",
6847
-
PTR_ERR(test_btf))) {
6844
+
if (CHECK(err, "invalid test_btf errno:%d", err)) {
6848
6845
err = -1;
6849
6846
goto done;
6850
6847
}
···
6856
6853
if (!raw_btf)
6857
6854
return;
6858
6855
expect_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
6856
+
err = libbpf_get_error(expect_btf);
6859
6857
free(raw_btf);
6860
-
if (CHECK(IS_ERR(expect_btf), "invalid expect_btf errno:%ld",
6861
-
PTR_ERR(expect_btf))) {
6858
+
if (CHECK(err, "invalid expect_btf errno:%d", err)) {
6862
6859
err = -1;
6863
6860
goto done;
6864
6861
}
···
6969
6966
}
6970
6967
6971
6968
done:
6972
-
if (!IS_ERR(test_btf))
6973
-
btf__free(test_btf);
6974
-
if (!IS_ERR(expect_btf))
6975
-
btf__free(expect_btf);
6969
+
btf__free(test_btf);
6970
+
btf__free(expect_btf);
6976
6971
}
6977
6972
6978
6973
void test_btf(void)
+4
-4
tools/testing/selftests/bpf/prog_tests/btf_dump.c
+4
-4
tools/testing/selftests/bpf/prog_tests/btf_dump.c
···
32
32
int err = 0, id;
33
33
34
34
d = btf_dump__new(btf, NULL, opts, btf_dump_printf);
35
-
if (IS_ERR(d))
36
-
return PTR_ERR(d);
35
+
err = libbpf_get_error(d);
36
+
if (err)
37
+
return err;
37
38
38
39
for (id = 1; id <= type_cnt; id++) {
39
40
err = btf_dump__dump_type(d, id);
···
57
56
snprintf(test_file, sizeof(test_file), "%s.o", t->file);
58
57
59
58
btf = btf__parse_elf(test_file, NULL);
60
-
if (CHECK(IS_ERR(btf), "btf_parse_elf",
61
-
"failed to load test BTF: %ld\n", PTR_ERR(btf))) {
59
+
if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {
62
60
err = -PTR_ERR(btf);
63
61
btf = NULL;
64
62
goto done;
+1
-3
tools/testing/selftests/bpf/prog_tests/btf_write.c
+1
-3
tools/testing/selftests/bpf/prog_tests/btf_write.c
···
4
4
#include <bpf/btf.h>
5
5
#include "btf_helpers.h"
6
6
7
-
static int duration = 0;
8
-
9
7
void test_btf_write() {
10
8
const struct btf_var_secinfo *vi;
11
9
const struct btf_type *t;
···
14
16
int id, err, str_off;
15
17
16
18
btf = btf__new_empty();
17
-
if (CHECK(IS_ERR(btf), "new_empty", "failed: %ld\n", PTR_ERR(btf)))
19
+
if (!ASSERT_OK_PTR(btf, "new_empty"))
18
20
return;
19
21
20
22
str_off = btf__find_str(btf, "int");
+28
-56
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c
+28
-56
tools/testing/selftests/bpf/prog_tests/cg_storage_multi.c
···
102
102
*/
103
103
parent_link = bpf_program__attach_cgroup(obj->progs.egress,
104
104
parent_cgroup_fd);
105
-
if (CHECK(IS_ERR(parent_link), "parent-cg-attach",
106
-
"err %ld", PTR_ERR(parent_link)))
105
+
if (!ASSERT_OK_PTR(parent_link, "parent-cg-attach"))
107
106
goto close_bpf_object;
108
107
err = connect_send(CHILD_CGROUP);
109
108
if (CHECK(err, "first-connect-send", "errno %d", errno))
···
125
126
*/
126
127
child_link = bpf_program__attach_cgroup(obj->progs.egress,
127
128
child_cgroup_fd);
128
-
if (CHECK(IS_ERR(child_link), "child-cg-attach",
129
-
"err %ld", PTR_ERR(child_link)))
129
+
if (!ASSERT_OK_PTR(child_link, "child-cg-attach"))
130
130
goto close_bpf_object;
131
131
err = connect_send(CHILD_CGROUP);
132
132
if (CHECK(err, "second-connect-send", "errno %d", errno))
···
145
147
goto close_bpf_object;
146
148
147
149
close_bpf_object:
148
-
if (!IS_ERR(parent_link))
149
-
bpf_link__destroy(parent_link);
150
-
if (!IS_ERR(child_link))
151
-
bpf_link__destroy(child_link);
150
+
bpf_link__destroy(parent_link);
151
+
bpf_link__destroy(child_link);
152
152
153
153
cg_storage_multi_egress_only__destroy(obj);
154
154
}
···
172
176
*/
173
177
parent_egress1_link = bpf_program__attach_cgroup(obj->progs.egress1,
174
178
parent_cgroup_fd);
175
-
if (CHECK(IS_ERR(parent_egress1_link), "parent-egress1-cg-attach",
176
-
"err %ld", PTR_ERR(parent_egress1_link)))
179
+
if (!ASSERT_OK_PTR(parent_egress1_link, "parent-egress1-cg-attach"))
177
180
goto close_bpf_object;
178
181
parent_egress2_link = bpf_program__attach_cgroup(obj->progs.egress2,
179
182
parent_cgroup_fd);
180
-
if (CHECK(IS_ERR(parent_egress2_link), "parent-egress2-cg-attach",
181
-
"err %ld", PTR_ERR(parent_egress2_link)))
183
+
if (!ASSERT_OK_PTR(parent_egress2_link, "parent-egress2-cg-attach"))
182
184
goto close_bpf_object;
183
185
parent_ingress_link = bpf_program__attach_cgroup(obj->progs.ingress,
184
186
parent_cgroup_fd);
185
-
if (CHECK(IS_ERR(parent_ingress_link), "parent-ingress-cg-attach",
186
-
"err %ld", PTR_ERR(parent_ingress_link)))
187
+
if (!ASSERT_OK_PTR(parent_ingress_link, "parent-ingress-cg-attach"))
187
188
goto close_bpf_object;
188
189
err = connect_send(CHILD_CGROUP);
189
190
if (CHECK(err, "first-connect-send", "errno %d", errno))
···
214
221
*/
215
222
child_egress1_link = bpf_program__attach_cgroup(obj->progs.egress1,
216
223
child_cgroup_fd);
217
-
if (CHECK(IS_ERR(child_egress1_link), "child-egress1-cg-attach",
218
-
"err %ld", PTR_ERR(child_egress1_link)))
224
+
if (!ASSERT_OK_PTR(child_egress1_link, "child-egress1-cg-attach"))
219
225
goto close_bpf_object;
220
226
child_egress2_link = bpf_program__attach_cgroup(obj->progs.egress2,
221
227
child_cgroup_fd);
222
-
if (CHECK(IS_ERR(child_egress2_link), "child-egress2-cg-attach",
223
-
"err %ld", PTR_ERR(child_egress2_link)))
228
+
if (!ASSERT_OK_PTR(child_egress2_link, "child-egress2-cg-attach"))
224
229
goto close_bpf_object;
225
230
child_ingress_link = bpf_program__attach_cgroup(obj->progs.ingress,
226
231
child_cgroup_fd);
227
-
if (CHECK(IS_ERR(child_ingress_link), "child-ingress-cg-attach",
228
-
"err %ld", PTR_ERR(child_ingress_link)))
232
+
if (!ASSERT_OK_PTR(child_ingress_link, "child-ingress-cg-attach"))
229
233
goto close_bpf_object;
230
234
err = connect_send(CHILD_CGROUP);
231
235
if (CHECK(err, "second-connect-send", "errno %d", errno))
···
254
264
goto close_bpf_object;
255
265
256
266
close_bpf_object:
257
-
if (!IS_ERR(parent_egress1_link))
258
-
bpf_link__destroy(parent_egress1_link);
259
-
if (!IS_ERR(parent_egress2_link))
260
-
bpf_link__destroy(parent_egress2_link);
261
-
if (!IS_ERR(parent_ingress_link))
262
-
bpf_link__destroy(parent_ingress_link);
263
-
if (!IS_ERR(child_egress1_link))
264
-
bpf_link__destroy(child_egress1_link);
265
-
if (!IS_ERR(child_egress2_link))
266
-
bpf_link__destroy(child_egress2_link);
267
-
if (!IS_ERR(child_ingress_link))
268
-
bpf_link__destroy(child_ingress_link);
267
+
bpf_link__destroy(parent_egress1_link);
268
+
bpf_link__destroy(parent_egress2_link);
269
+
bpf_link__destroy(parent_ingress_link);
270
+
bpf_link__destroy(child_egress1_link);
271
+
bpf_link__destroy(child_egress2_link);
272
+
bpf_link__destroy(child_ingress_link);
269
273
270
274
cg_storage_multi_isolated__destroy(obj);
271
275
}
···
285
301
*/
286
302
parent_egress1_link = bpf_program__attach_cgroup(obj->progs.egress1,
287
303
parent_cgroup_fd);
288
-
if (CHECK(IS_ERR(parent_egress1_link), "parent-egress1-cg-attach",
289
-
"err %ld", PTR_ERR(parent_egress1_link)))
304
+
if (!ASSERT_OK_PTR(parent_egress1_link, "parent-egress1-cg-attach"))
290
305
goto close_bpf_object;
291
306
parent_egress2_link = bpf_program__attach_cgroup(obj->progs.egress2,
292
307
parent_cgroup_fd);
293
-
if (CHECK(IS_ERR(parent_egress2_link), "parent-egress2-cg-attach",
294
-
"err %ld", PTR_ERR(parent_egress2_link)))
308
+
if (!ASSERT_OK_PTR(parent_egress2_link, "parent-egress2-cg-attach"))
295
309
goto close_bpf_object;
296
310
parent_ingress_link = bpf_program__attach_cgroup(obj->progs.ingress,
297
311
parent_cgroup_fd);
298
-
if (CHECK(IS_ERR(parent_ingress_link), "parent-ingress-cg-attach",
299
-
"err %ld", PTR_ERR(parent_ingress_link)))
312
+
if (!ASSERT_OK_PTR(parent_ingress_link, "parent-ingress-cg-attach"))
300
313
goto close_bpf_object;
301
314
err = connect_send(CHILD_CGROUP);
302
315
if (CHECK(err, "first-connect-send", "errno %d", errno))
···
319
338
*/
320
339
child_egress1_link = bpf_program__attach_cgroup(obj->progs.egress1,
321
340
child_cgroup_fd);
322
-
if (CHECK(IS_ERR(child_egress1_link), "child-egress1-cg-attach",
323
-
"err %ld", PTR_ERR(child_egress1_link)))
341
+
if (!ASSERT_OK_PTR(child_egress1_link, "child-egress1-cg-attach"))
324
342
goto close_bpf_object;
325
343
child_egress2_link = bpf_program__attach_cgroup(obj->progs.egress2,
326
344
child_cgroup_fd);
327
-
if (CHECK(IS_ERR(child_egress2_link), "child-egress2-cg-attach",
328
-
"err %ld", PTR_ERR(child_egress2_link)))
345
+
if (!ASSERT_OK_PTR(child_egress2_link, "child-egress2-cg-attach"))
329
346
goto close_bpf_object;
330
347
child_ingress_link = bpf_program__attach_cgroup(obj->progs.ingress,
331
348
child_cgroup_fd);
332
-
if (CHECK(IS_ERR(child_ingress_link), "child-ingress-cg-attach",
333
-
"err %ld", PTR_ERR(child_ingress_link)))
349
+
if (!ASSERT_OK_PTR(child_ingress_link, "child-ingress-cg-attach"))
334
350
goto close_bpf_object;
335
351
err = connect_send(CHILD_CGROUP);
336
352
if (CHECK(err, "second-connect-send", "errno %d", errno))
···
353
375
goto close_bpf_object;
354
376
355
377
close_bpf_object:
356
-
if (!IS_ERR(parent_egress1_link))
357
-
bpf_link__destroy(parent_egress1_link);
358
-
if (!IS_ERR(parent_egress2_link))
359
-
bpf_link__destroy(parent_egress2_link);
360
-
if (!IS_ERR(parent_ingress_link))
361
-
bpf_link__destroy(parent_ingress_link);
362
-
if (!IS_ERR(child_egress1_link))
363
-
bpf_link__destroy(child_egress1_link);
364
-
if (!IS_ERR(child_egress2_link))
365
-
bpf_link__destroy(child_egress2_link);
366
-
if (!IS_ERR(child_ingress_link))
367
-
bpf_link__destroy(child_ingress_link);
378
+
bpf_link__destroy(parent_egress1_link);
379
+
bpf_link__destroy(parent_egress2_link);
380
+
bpf_link__destroy(parent_ingress_link);
381
+
bpf_link__destroy(child_egress1_link);
382
+
bpf_link__destroy(child_egress2_link);
383
+
bpf_link__destroy(child_ingress_link);
368
384
369
385
cg_storage_multi_shared__destroy(obj);
370
386
}
+1
-1
tools/testing/selftests/bpf/prog_tests/cgroup_attach_multi.c
+1
-1
tools/testing/selftests/bpf/prog_tests/cgroup_attach_multi.c
···
167
167
prog_cnt = 2;
168
168
CHECK_FAIL(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS,
169
169
BPF_F_QUERY_EFFECTIVE, &attach_flags,
170
-
prog_ids, &prog_cnt) != -1);
170
+
prog_ids, &prog_cnt) >= 0);
171
171
CHECK_FAIL(errno != ENOSPC);
172
172
CHECK_FAIL(prog_cnt != 4);
173
173
/* check that prog_ids are returned even when buffer is too small */
+5
-9
tools/testing/selftests/bpf/prog_tests/cgroup_link.c
+5
-9
tools/testing/selftests/bpf/prog_tests/cgroup_link.c
···
65
65
for (i = 0; i < cg_nr; i++) {
66
66
links[i] = bpf_program__attach_cgroup(skel->progs.egress,
67
67
cgs[i].fd);
68
-
if (CHECK(IS_ERR(links[i]), "cg_attach", "i: %d, err: %ld\n",
69
-
i, PTR_ERR(links[i])))
68
+
if (!ASSERT_OK_PTR(links[i], "cg_attach"))
70
69
goto cleanup;
71
70
}
72
71
···
120
121
121
122
links[last_cg] = bpf_program__attach_cgroup(skel->progs.egress,
122
123
cgs[last_cg].fd);
123
-
if (CHECK(IS_ERR(links[last_cg]), "cg_attach", "err: %ld\n",
124
-
PTR_ERR(links[last_cg])))
124
+
if (!ASSERT_OK_PTR(links[last_cg], "cg_attach"))
125
125
goto cleanup;
126
126
127
127
ping_and_check(cg_nr + 1, 0);
···
145
147
/* attempt to mix in with multi-attach bpf_link */
146
148
tmp_link = bpf_program__attach_cgroup(skel->progs.egress,
147
149
cgs[last_cg].fd);
148
-
if (CHECK(!IS_ERR(tmp_link), "cg_attach_fail", "unexpected success!\n")) {
150
+
if (!ASSERT_ERR_PTR(tmp_link, "cg_attach_fail")) {
149
151
bpf_link__destroy(tmp_link);
150
152
goto cleanup;
151
153
}
···
163
165
/* attach back link-based one */
164
166
links[last_cg] = bpf_program__attach_cgroup(skel->progs.egress,
165
167
cgs[last_cg].fd);
166
-
if (CHECK(IS_ERR(links[last_cg]), "cg_attach", "err: %ld\n",
167
-
PTR_ERR(links[last_cg])))
168
+
if (!ASSERT_OK_PTR(links[last_cg], "cg_attach"))
168
169
goto cleanup;
169
170
170
171
ping_and_check(cg_nr, 0);
···
246
249
BPF_CGROUP_INET_EGRESS);
247
250
248
251
for (i = 0; i < cg_nr; i++) {
249
-
if (!IS_ERR(links[i]))
250
-
bpf_link__destroy(links[i]);
252
+
bpf_link__destroy(links[i]);
251
253
}
252
254
test_cgroup_link__destroy(skel);
253
255
+1
-1
tools/testing/selftests/bpf/prog_tests/cgroup_skb_sk_lookup.c
+1
-1
tools/testing/selftests/bpf/prog_tests/cgroup_skb_sk_lookup.c
···
60
60
goto cleanup;
61
61
62
62
link = bpf_program__attach_cgroup(skel->progs.ingress_lookup, cgfd);
63
-
if (CHECK(IS_ERR(link), "cgroup_attach", "err: %ld\n", PTR_ERR(link)))
63
+
if (!ASSERT_OK_PTR(link, "cgroup_attach"))
64
64
goto cleanup;
65
65
66
66
run_lookup_test(&skel->bss->g_serv_port, out_sk);
+1
-1
tools/testing/selftests/bpf/prog_tests/check_mtu.c
+1
-1
tools/testing/selftests/bpf/prog_tests/check_mtu.c
···
53
53
prog = skel->progs.xdp_use_helper_basic;
54
54
55
55
link = bpf_program__attach_xdp(prog, IFINDEX_LO);
56
-
if (CHECK(IS_ERR(link), "link_attach", "failed: %ld\n", PTR_ERR(link)))
56
+
if (!ASSERT_OK_PTR(link, "link_attach"))
57
57
goto out;
58
58
skel->links.xdp_use_helper_basic = link;
59
59
+5
-10
tools/testing/selftests/bpf/prog_tests/core_reloc.c
+5
-10
tools/testing/selftests/bpf/prog_tests/core_reloc.c
···
369
369
const char *name;
370
370
int i;
371
371
372
-
if (CHECK(IS_ERR(local_btf), "local_btf", "failed: %ld\n", PTR_ERR(local_btf)) ||
373
-
CHECK(IS_ERR(targ_btf), "targ_btf", "failed: %ld\n", PTR_ERR(targ_btf))) {
372
+
if (!ASSERT_OK_PTR(local_btf, "local_btf") || !ASSERT_OK_PTR(targ_btf, "targ_btf")) {
374
373
btf__free(local_btf);
375
374
btf__free(targ_btf);
376
375
return -EINVAL;
···
847
848
}
848
849
849
850
obj = bpf_object__open_file(test_case->bpf_obj_file, NULL);
850
-
if (CHECK(IS_ERR(obj), "obj_open", "failed to open '%s': %ld\n",
851
-
test_case->bpf_obj_file, PTR_ERR(obj)))
851
+
if (!ASSERT_OK_PTR(obj, "obj_open"))
852
852
continue;
853
853
854
854
probe_name = "raw_tracepoint/sys_enter";
···
897
899
data->my_pid_tgid = my_pid_tgid;
898
900
899
901
link = bpf_program__attach_raw_tracepoint(prog, tp_name);
900
-
if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n",
901
-
PTR_ERR(link)))
902
+
if (!ASSERT_OK_PTR(link, "attach_raw_tp"))
902
903
goto cleanup;
903
904
904
905
/* trigger test run */
···
938
941
CHECK_FAIL(munmap(mmap_data, mmap_sz));
939
942
mmap_data = NULL;
940
943
}
941
-
if (!IS_ERR_OR_NULL(link)) {
942
-
bpf_link__destroy(link);
943
-
link = NULL;
944
-
}
944
+
bpf_link__destroy(link);
945
+
link = NULL;
945
946
bpf_object__close(obj);
946
947
}
947
948
}
+8
-17
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
+8
-17
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
···
146
146
147
147
close_prog:
148
148
for (i = 0; i < prog_cnt; i++)
149
-
if (!IS_ERR_OR_NULL(link[i]))
150
-
bpf_link__destroy(link[i]);
151
-
if (!IS_ERR_OR_NULL(obj))
152
-
bpf_object__close(obj);
149
+
bpf_link__destroy(link[i]);
150
+
bpf_object__close(obj);
153
151
bpf_object__close(tgt_obj);
154
152
free(link);
155
153
free(prog);
···
229
231
return err;
230
232
231
233
link = bpf_program__attach_freplace(prog, tgt_fd, tgt_name);
232
-
if (CHECK(IS_ERR(link), "second_link", "failed to attach second link prog_fd %d tgt_fd %d\n", bpf_program__fd(prog), tgt_fd))
234
+
if (!ASSERT_OK_PTR(link, "second_link"))
233
235
goto out;
234
236
235
237
err = bpf_prog_test_run(tgt_fd, 1, &pkt_v6, sizeof(pkt_v6),
···
281
283
opts.attach_prog_fd = pkt_fd;
282
284
283
285
freplace_obj = bpf_object__open_file(freplace_name, &opts);
284
-
if (CHECK(IS_ERR_OR_NULL(freplace_obj), "freplace_obj_open",
285
-
"failed to open %s: %ld\n", freplace_name,
286
-
PTR_ERR(freplace_obj)))
286
+
if (!ASSERT_OK_PTR(freplace_obj, "freplace_obj_open"))
287
287
goto out;
288
288
289
289
err = bpf_object__load(freplace_obj);
···
290
294
291
295
prog = bpf_program__next(NULL, freplace_obj);
292
296
freplace_link = bpf_program__attach_trace(prog);
293
-
if (CHECK(IS_ERR(freplace_link), "freplace_attach_trace", "failed to link\n"))
297
+
if (!ASSERT_OK_PTR(freplace_link, "freplace_attach_trace"))
294
298
goto out;
295
299
296
300
opts.attach_prog_fd = bpf_program__fd(prog);
297
301
fmod_obj = bpf_object__open_file(fmod_ret_name, &opts);
298
-
if (CHECK(IS_ERR_OR_NULL(fmod_obj), "fmod_obj_open",
299
-
"failed to open %s: %ld\n", fmod_ret_name,
300
-
PTR_ERR(fmod_obj)))
302
+
if (!ASSERT_OK_PTR(fmod_obj, "fmod_obj_open"))
301
303
goto out;
302
304
303
305
err = bpf_object__load(fmod_obj);
···
344
350
);
345
351
346
352
obj = bpf_object__open_file(obj_file, &opts);
347
-
if (CHECK(IS_ERR_OR_NULL(obj), "obj_open",
348
-
"failed to open %s: %ld\n", obj_file,
349
-
PTR_ERR(obj)))
353
+
if (!ASSERT_OK_PTR(obj, "obj_open"))
350
354
goto close_prog;
351
355
352
356
/* It should fail to load the program */
···
353
361
goto close_prog;
354
362
355
363
close_prog:
356
-
if (!IS_ERR_OR_NULL(obj))
357
-
bpf_object__close(obj);
364
+
bpf_object__close(obj);
358
365
bpf_object__close(pkt_obj);
359
366
}
360
367
+1
-1
tools/testing/selftests/bpf/prog_tests/flow_dissector.c
+1
-1
tools/testing/selftests/bpf/prog_tests/flow_dissector.c
···
541
541
return;
542
542
543
543
link = bpf_program__attach_netns(skel->progs._dissect, net_fd);
544
-
if (CHECK(IS_ERR(link), "attach_netns", "err %ld\n", PTR_ERR(link)))
544
+
if (!ASSERT_OK_PTR(link, "attach_netns"))
545
545
goto out_close;
546
546
547
547
run_tests_skb_less(tap_fd, skel->maps.last_dissection);
+5
-5
tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c
+5
-5
tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c
···
134
134
/* Expect failure creating link when another link exists */
135
135
errno = 0;
136
136
link2 = bpf_link_create(prog2, netns, BPF_FLOW_DISSECTOR, &opts);
137
-
if (CHECK_FAIL(link2 != -1 || errno != E2BIG))
137
+
if (CHECK_FAIL(link2 >= 0 || errno != E2BIG))
138
138
perror("bpf_prog_attach(prog2) expected E2BIG");
139
-
if (link2 != -1)
139
+
if (link2 >= 0)
140
140
close(link2);
141
141
CHECK_FAIL(query_attached_prog_id(netns) != query_prog_id(prog1));
142
142
···
159
159
/* Expect failure creating link when prog attached */
160
160
errno = 0;
161
161
link = bpf_link_create(prog2, netns, BPF_FLOW_DISSECTOR, &opts);
162
-
if (CHECK_FAIL(link != -1 || errno != EEXIST))
162
+
if (CHECK_FAIL(link >= 0 || errno != EEXIST))
163
163
perror("bpf_link_create(prog2) expected EEXIST");
164
-
if (link != -1)
164
+
if (link >= 0)
165
165
close(link);
166
166
CHECK_FAIL(query_attached_prog_id(netns) != query_prog_id(prog1));
167
167
···
623
623
}
624
624
out_close:
625
625
for (i = 0; i < ARRAY_SIZE(progs); i++) {
626
-
if (progs[i] != -1)
626
+
if (progs[i] >= 0)
627
627
CHECK_FAIL(close(progs[i]));
628
628
}
629
629
}
+4
-6
tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
+4
-6
tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
···
121
121
goto close_prog;
122
122
123
123
link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");
124
-
if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n", PTR_ERR(link)))
124
+
if (!ASSERT_OK_PTR(link, "attach_raw_tp"))
125
125
goto close_prog;
126
126
127
127
pb_opts.sample_cb = get_stack_print_output;
128
128
pb = perf_buffer__new(bpf_map__fd(map), 8, &pb_opts);
129
-
if (CHECK(IS_ERR(pb), "perf_buf__new", "err %ld\n", PTR_ERR(pb)))
129
+
if (!ASSERT_OK_PTR(pb, "perf_buf__new"))
130
130
goto close_prog;
131
131
132
132
/* trigger some syscall action */
···
141
141
}
142
142
143
143
close_prog:
144
-
if (!IS_ERR_OR_NULL(link))
145
-
bpf_link__destroy(link);
146
-
if (!IS_ERR_OR_NULL(pb))
147
-
perf_buffer__free(pb);
144
+
bpf_link__destroy(link);
145
+
perf_buffer__free(pb);
148
146
bpf_object__close(obj);
149
147
}
+3
-6
tools/testing/selftests/bpf/prog_tests/get_stackid_cannot_attach.c
+3
-6
tools/testing/selftests/bpf/prog_tests/get_stackid_cannot_attach.c
···
48
48
49
49
skel->links.oncpu = bpf_program__attach_perf_event(skel->progs.oncpu,
50
50
pmu_fd);
51
-
CHECK(!IS_ERR(skel->links.oncpu), "attach_perf_event_no_callchain",
52
-
"should have failed\n");
51
+
ASSERT_ERR_PTR(skel->links.oncpu, "attach_perf_event_no_callchain");
53
52
close(pmu_fd);
54
53
55
54
/* add PERF_SAMPLE_CALLCHAIN, attach should succeed */
···
64
65
65
66
skel->links.oncpu = bpf_program__attach_perf_event(skel->progs.oncpu,
66
67
pmu_fd);
67
-
CHECK(IS_ERR(skel->links.oncpu), "attach_perf_event_callchain",
68
-
"err: %ld\n", PTR_ERR(skel->links.oncpu));
68
+
ASSERT_OK_PTR(skel->links.oncpu, "attach_perf_event_callchain");
69
69
close(pmu_fd);
70
70
71
71
/* add exclude_callchain_kernel, attach should fail */
···
80
82
81
83
skel->links.oncpu = bpf_program__attach_perf_event(skel->progs.oncpu,
82
84
pmu_fd);
83
-
CHECK(!IS_ERR(skel->links.oncpu), "attach_perf_event_exclude_callchain_kernel",
84
-
"should have failed\n");
85
+
ASSERT_ERR_PTR(skel->links.oncpu, "attach_perf_event_exclude_callchain_kernel");
85
86
close(pmu_fd);
86
87
87
88
cleanup:
+3
-6
tools/testing/selftests/bpf/prog_tests/hashmap.c
+3
-6
tools/testing/selftests/bpf/prog_tests/hashmap.c
···
48
48
struct hashmap *map;
49
49
50
50
map = hashmap__new(hash_fn, equal_fn, NULL);
51
-
if (CHECK(IS_ERR(map), "hashmap__new",
52
-
"failed to create map: %ld\n", PTR_ERR(map)))
51
+
if (!ASSERT_OK_PTR(map, "hashmap__new"))
53
52
return;
54
53
55
54
for (i = 0; i < ELEM_CNT; i++) {
···
266
267
267
268
/* force collisions */
268
269
map = hashmap__new(collision_hash_fn, equal_fn, NULL);
269
-
if (CHECK(IS_ERR(map), "hashmap__new",
270
-
"failed to create map: %ld\n", PTR_ERR(map)))
270
+
if (!ASSERT_OK_PTR(map, "hashmap__new"))
271
271
return;
272
272
273
273
/* set up multimap:
···
337
339
338
340
/* force collisions */
339
341
map = hashmap__new(hash_fn, equal_fn, NULL);
340
-
if (CHECK(IS_ERR(map), "hashmap__new",
341
-
"failed to create map: %ld\n", PTR_ERR(map)))
342
+
if (!ASSERT_OK_PTR(map, "hashmap__new"))
342
343
goto cleanup;
343
344
344
345
if (CHECK(hashmap__size(map) != 0, "hashmap__size",
+7
-12
tools/testing/selftests/bpf/prog_tests/kfree_skb.c
+7
-12
tools/testing/selftests/bpf/prog_tests/kfree_skb.c
···
97
97
goto close_prog;
98
98
99
99
link = bpf_program__attach_raw_tracepoint(prog, NULL);
100
-
if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n", PTR_ERR(link)))
100
+
if (!ASSERT_OK_PTR(link, "attach_raw_tp"))
101
101
goto close_prog;
102
102
link_fentry = bpf_program__attach_trace(fentry);
103
-
if (CHECK(IS_ERR(link_fentry), "attach fentry", "err %ld\n",
104
-
PTR_ERR(link_fentry)))
103
+
if (!ASSERT_OK_PTR(link_fentry, "attach fentry"))
105
104
goto close_prog;
106
105
link_fexit = bpf_program__attach_trace(fexit);
107
-
if (CHECK(IS_ERR(link_fexit), "attach fexit", "err %ld\n",
108
-
PTR_ERR(link_fexit)))
106
+
if (!ASSERT_OK_PTR(link_fexit, "attach fexit"))
109
107
goto close_prog;
110
108
111
109
perf_buf_map = bpf_object__find_map_by_name(obj2, "perf_buf_map");
···
114
116
pb_opts.sample_cb = on_sample;
115
117
pb_opts.ctx = &passed;
116
118
pb = perf_buffer__new(bpf_map__fd(perf_buf_map), 1, &pb_opts);
117
-
if (CHECK(IS_ERR(pb), "perf_buf__new", "err %ld\n", PTR_ERR(pb)))
119
+
if (!ASSERT_OK_PTR(pb, "perf_buf__new"))
118
120
goto close_prog;
119
121
120
122
memcpy(skb.cb, &cb, sizeof(cb));
···
142
144
CHECK_FAIL(!test_ok[0] || !test_ok[1]);
143
145
close_prog:
144
146
perf_buffer__free(pb);
145
-
if (!IS_ERR_OR_NULL(link))
146
-
bpf_link__destroy(link);
147
-
if (!IS_ERR_OR_NULL(link_fentry))
148
-
bpf_link__destroy(link_fentry);
149
-
if (!IS_ERR_OR_NULL(link_fexit))
150
-
bpf_link__destroy(link_fexit);
147
+
bpf_link__destroy(link);
148
+
bpf_link__destroy(link_fentry);
149
+
bpf_link__destroy(link_fexit);
151
150
bpf_object__close(obj);
152
151
bpf_object__close(obj2);
153
152
}
+1
-2
tools/testing/selftests/bpf/prog_tests/ksyms_btf.c
+1
-2
tools/testing/selftests/bpf/prog_tests/ksyms_btf.c
···
87
87
struct btf *btf;
88
88
89
89
btf = libbpf_find_kernel_btf();
90
-
if (CHECK(IS_ERR(btf), "btf_exists", "failed to load kernel BTF: %ld\n",
91
-
PTR_ERR(btf)))
90
+
if (!ASSERT_OK_PTR(btf, "btf_exists"))
92
91
return;
93
92
94
93
percpu_datasec = btf__find_by_name_kind(btf, ".data..percpu",
+3
-4
tools/testing/selftests/bpf/prog_tests/link_pinning.c
+3
-4
tools/testing/selftests/bpf/prog_tests/link_pinning.c
···
17
17
int err, i;
18
18
19
19
link = bpf_program__attach(prog);
20
-
if (CHECK(IS_ERR(link), "link_attach", "err: %ld\n", PTR_ERR(link)))
20
+
if (!ASSERT_OK_PTR(link, "link_attach"))
21
21
goto cleanup;
22
22
23
23
bss->in = 1;
···
51
51
52
52
/* re-open link from BPFFS */
53
53
link = bpf_link__open(link_pin_path);
54
-
if (CHECK(IS_ERR(link), "link_open", "err: %ld\n", PTR_ERR(link)))
54
+
if (!ASSERT_OK_PTR(link, "link_open"))
55
55
goto cleanup;
56
56
57
57
CHECK(strcmp(link_pin_path, bpf_link__pin_path(link)), "pin_path2",
···
84
84
CHECK(i == 10000, "link_attached", "got to iteration #%d\n", i);
85
85
86
86
cleanup:
87
-
if (!IS_ERR(link))
88
-
bpf_link__destroy(link);
87
+
bpf_link__destroy(link);
89
88
}
90
89
91
90
void test_link_pinning(void)
+4
-4
tools/testing/selftests/bpf/prog_tests/obj_name.c
+4
-4
tools/testing/selftests/bpf/prog_tests/obj_name.c
···
38
38
39
39
fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
40
40
CHECK((tests[i].success && fd < 0) ||
41
-
(!tests[i].success && fd != -1) ||
41
+
(!tests[i].success && fd >= 0) ||
42
42
(!tests[i].success && errno != tests[i].expected_errno),
43
43
"check-bpf-prog-name",
44
44
"fd %d(%d) errno %d(%d)\n",
45
45
fd, tests[i].success, errno, tests[i].expected_errno);
46
46
47
-
if (fd != -1)
47
+
if (fd >= 0)
48
48
close(fd);
49
49
50
50
/* test different attr.map_name during BPF_MAP_CREATE */
···
59
59
memcpy(attr.map_name, tests[i].name, ncopy);
60
60
fd = syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
61
61
CHECK((tests[i].success && fd < 0) ||
62
-
(!tests[i].success && fd != -1) ||
62
+
(!tests[i].success && fd >= 0) ||
63
63
(!tests[i].success && errno != tests[i].expected_errno),
64
64
"check-bpf-map-name",
65
65
"fd %d(%d) errno %d(%d)\n",
66
66
fd, tests[i].success, errno, tests[i].expected_errno);
67
67
68
-
if (fd != -1)
68
+
if (fd >= 0)
69
69
close(fd);
70
70
}
71
71
}
+2
-2
tools/testing/selftests/bpf/prog_tests/perf_branches.c
+2
-2
tools/testing/selftests/bpf/prog_tests/perf_branches.c
···
74
74
75
75
/* attach perf_event */
76
76
link = bpf_program__attach_perf_event(skel->progs.perf_branches, perf_fd);
77
-
if (CHECK(IS_ERR(link), "attach_perf_event", "err %ld\n", PTR_ERR(link)))
77
+
if (!ASSERT_OK_PTR(link, "attach_perf_event"))
78
78
goto out_destroy_skel;
79
79
80
80
/* generate some branches on cpu 0 */
···
119
119
* Some setups don't support branch records (virtual machines, !x86),
120
120
* so skip test in this case.
121
121
*/
122
-
if (pfd == -1) {
122
+
if (pfd < 0) {
123
123
if (errno == ENOENT || errno == EOPNOTSUPP) {
124
124
printf("%s:SKIP:no PERF_SAMPLE_BRANCH_STACK\n",
125
125
__func__);
+1
-1
tools/testing/selftests/bpf/prog_tests/perf_buffer.c
+1
-1
tools/testing/selftests/bpf/prog_tests/perf_buffer.c
···
80
80
pb_opts.sample_cb = on_sample;
81
81
pb_opts.ctx = &cpu_seen;
82
82
pb = perf_buffer__new(bpf_map__fd(skel->maps.perf_buf_map), 1, &pb_opts);
83
-
if (CHECK(IS_ERR(pb), "perf_buf__new", "err %ld\n", PTR_ERR(pb)))
83
+
if (!ASSERT_OK_PTR(pb, "perf_buf__new"))
84
84
goto out_close;
85
85
86
86
CHECK(perf_buffer__epoll_fd(pb) < 0, "epoll_fd",
+1
-2
tools/testing/selftests/bpf/prog_tests/perf_event_stackmap.c
+1
-2
tools/testing/selftests/bpf/prog_tests/perf_event_stackmap.c
···
97
97
98
98
skel->links.oncpu = bpf_program__attach_perf_event(skel->progs.oncpu,
99
99
pmu_fd);
100
-
if (CHECK(IS_ERR(skel->links.oncpu), "attach_perf_event",
101
-
"err %ld\n", PTR_ERR(skel->links.oncpu))) {
100
+
if (!ASSERT_OK_PTR(skel->links.oncpu, "attach_perf_event")) {
102
101
close(pmu_fd);
103
102
goto cleanup;
104
103
}
+2
-5
tools/testing/selftests/bpf/prog_tests/probe_user.c
+2
-5
tools/testing/selftests/bpf/prog_tests/probe_user.c
···
15
15
static const int zero = 0;
16
16
17
17
obj = bpf_object__open_file(obj_file, &opts);
18
-
if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj)))
18
+
if (!ASSERT_OK_PTR(obj, "obj_open_file"))
19
19
return;
20
20
21
21
kprobe_prog = bpf_object__find_program_by_title(obj, prog_name);
···
33
33
goto cleanup;
34
34
35
35
kprobe_link = bpf_program__attach(kprobe_prog);
36
-
if (CHECK(IS_ERR(kprobe_link), "attach_kprobe",
37
-
"err %ld\n", PTR_ERR(kprobe_link))) {
38
-
kprobe_link = NULL;
36
+
if (!ASSERT_OK_PTR(kprobe_link, "attach_kprobe"))
39
37
goto cleanup;
40
-
}
41
38
42
39
memset(&curr, 0, sizeof(curr));
43
40
in->sin_family = AF_INET;
+2
-2
tools/testing/selftests/bpf/prog_tests/prog_run_xattr.c
+2
-2
tools/testing/selftests/bpf/prog_tests/prog_run_xattr.c
···
46
46
tattr.prog_fd = bpf_program__fd(skel->progs.test_pkt_access);
47
47
48
48
err = bpf_prog_test_run_xattr(&tattr);
49
-
CHECK_ATTR(err != -1 || errno != ENOSPC || tattr.retval, "run",
49
+
CHECK_ATTR(err >= 0 || errno != ENOSPC || tattr.retval, "run",
50
50
"err %d errno %d retval %d\n", err, errno, tattr.retval);
51
51
52
52
CHECK_ATTR(tattr.data_size_out != sizeof(pkt_v4), "data_size_out",
···
78
78
cleanup:
79
79
if (skel)
80
80
test_pkt_access__destroy(skel);
81
-
if (stats_fd != -1)
81
+
if (stats_fd >= 0)
82
82
close(stats_fd);
83
83
}
+2
-2
tools/testing/selftests/bpf/prog_tests/raw_tp_test_run.c
+2
-2
tools/testing/selftests/bpf/prog_tests/raw_tp_test_run.c
···
77
77
/* invalid cpu ID should fail with ENXIO */
78
78
opts.cpu = 0xffffffff;
79
79
err = bpf_prog_test_run_opts(prog_fd, &opts);
80
-
CHECK(err != -1 || errno != ENXIO,
80
+
CHECK(err >= 0 || errno != ENXIO,
81
81
"test_run_opts_fail",
82
82
"should failed with ENXIO\n");
83
83
···
85
85
opts.cpu = 1;
86
86
opts.flags = 0;
87
87
err = bpf_prog_test_run_opts(prog_fd, &opts);
88
-
CHECK(err != -1 || errno != EINVAL,
88
+
CHECK(err >= 0 || errno != EINVAL,
89
89
"test_run_opts_fail",
90
90
"should failed with EINVAL\n");
91
91
+2
-5
tools/testing/selftests/bpf/prog_tests/rdonly_maps.c
+2
-5
tools/testing/selftests/bpf/prog_tests/rdonly_maps.c
···
30
30
struct bss bss;
31
31
32
32
obj = bpf_object__open_file(file, NULL);
33
-
if (CHECK(IS_ERR(obj), "obj_open", "err %ld\n", PTR_ERR(obj)))
33
+
if (!ASSERT_OK_PTR(obj, "obj_open"))
34
34
return;
35
35
36
36
err = bpf_object__load(obj);
···
58
58
goto cleanup;
59
59
60
60
link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");
61
-
if (CHECK(IS_ERR(link), "attach_prog", "prog '%s', err %ld\n",
62
-
t->prog_name, PTR_ERR(link))) {
63
-
link = NULL;
61
+
if (!ASSERT_OK_PTR(link, "attach_prog"))
64
62
goto cleanup;
65
-
}
66
63
67
64
/* trigger probe */
68
65
usleep(1);
+1
-1
tools/testing/selftests/bpf/prog_tests/reference_tracking.c
+1
-1
tools/testing/selftests/bpf/prog_tests/reference_tracking.c
+1
-1
tools/testing/selftests/bpf/prog_tests/resolve_btfids.c
+1
-1
tools/testing/selftests/bpf/prog_tests/resolve_btfids.c
+1
-1
tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c
+1
-1
tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c
···
63
63
goto cleanup;
64
64
65
65
proto_fd = bpf_create_map(BPF_MAP_TYPE_RINGBUF, 0, 0, page_size, 0);
66
-
if (CHECK(proto_fd == -1, "bpf_create_map", "bpf_create_map failed\n"))
66
+
if (CHECK(proto_fd < 0, "bpf_create_map", "bpf_create_map failed\n"))
67
67
goto cleanup;
68
68
69
69
err = bpf_map__set_inner_map_fd(skel->maps.ringbuf_hash, proto_fd);
+27
-26
tools/testing/selftests/bpf/prog_tests/select_reuseport.c
+27
-26
tools/testing/selftests/bpf/prog_tests/select_reuseport.c
···
78
78
attr.max_entries = REUSEPORT_ARRAY_SIZE;
79
79
80
80
reuseport_array = bpf_create_map_xattr(&attr);
81
-
RET_ERR(reuseport_array == -1, "creating reuseport_array",
81
+
RET_ERR(reuseport_array < 0, "creating reuseport_array",
82
82
"reuseport_array:%d errno:%d\n", reuseport_array, errno);
83
83
84
84
/* Creating outer_map */
···
89
89
attr.max_entries = 1;
90
90
attr.inner_map_fd = reuseport_array;
91
91
outer_map = bpf_create_map_xattr(&attr);
92
-
RET_ERR(outer_map == -1, "creating outer_map",
92
+
RET_ERR(outer_map < 0, "creating outer_map",
93
93
"outer_map:%d errno:%d\n", outer_map, errno);
94
94
95
95
return 0;
···
102
102
int err;
103
103
104
104
obj = bpf_object__open("test_select_reuseport_kern.o");
105
-
RET_ERR(IS_ERR_OR_NULL(obj), "open test_select_reuseport_kern.o",
106
-
"obj:%p PTR_ERR(obj):%ld\n", obj, PTR_ERR(obj));
105
+
err = libbpf_get_error(obj);
106
+
RET_ERR(err, "open test_select_reuseport_kern.o",
107
+
"obj:%p PTR_ERR(obj):%d\n", obj, err);
107
108
108
109
map = bpf_object__find_map_by_name(obj, "outer_map");
109
110
RET_ERR(!map, "find outer_map", "!map\n");
···
117
116
prog = bpf_program__next(NULL, obj);
118
117
RET_ERR(!prog, "get first bpf_program", "!prog\n");
119
118
select_by_skb_data_prog = bpf_program__fd(prog);
120
-
RET_ERR(select_by_skb_data_prog == -1, "get prog fd",
119
+
RET_ERR(select_by_skb_data_prog < 0, "get prog fd",
121
120
"select_by_skb_data_prog:%d\n", select_by_skb_data_prog);
122
121
123
122
map = bpf_object__find_map_by_name(obj, "result_map");
124
123
RET_ERR(!map, "find result_map", "!map\n");
125
124
result_map = bpf_map__fd(map);
126
-
RET_ERR(result_map == -1, "get result_map fd",
125
+
RET_ERR(result_map < 0, "get result_map fd",
127
126
"result_map:%d\n", result_map);
128
127
129
128
map = bpf_object__find_map_by_name(obj, "tmp_index_ovr_map");
130
129
RET_ERR(!map, "find tmp_index_ovr_map\n", "!map");
131
130
tmp_index_ovr_map = bpf_map__fd(map);
132
-
RET_ERR(tmp_index_ovr_map == -1, "get tmp_index_ovr_map fd",
131
+
RET_ERR(tmp_index_ovr_map < 0, "get tmp_index_ovr_map fd",
133
132
"tmp_index_ovr_map:%d\n", tmp_index_ovr_map);
134
133
135
134
map = bpf_object__find_map_by_name(obj, "linum_map");
136
135
RET_ERR(!map, "find linum_map", "!map\n");
137
136
linum_map = bpf_map__fd(map);
138
-
RET_ERR(linum_map == -1, "get linum_map fd",
137
+
RET_ERR(linum_map < 0, "get linum_map fd",
139
138
"linum_map:%d\n", linum_map);
140
139
141
140
map = bpf_object__find_map_by_name(obj, "data_check_map");
142
141
RET_ERR(!map, "find data_check_map", "!map\n");
143
142
data_check_map = bpf_map__fd(map);
144
-
RET_ERR(data_check_map == -1, "get data_check_map fd",
143
+
RET_ERR(data_check_map < 0, "get data_check_map fd",
145
144
"data_check_map:%d\n", data_check_map);
146
145
147
146
return 0;
···
238
237
int err;
239
238
240
239
err = bpf_map_lookup_elem(linum_map, &index_zero, &linum);
241
-
RET_ERR(err == -1, "lookup_elem(linum_map)", "err:%d errno:%d\n",
240
+
RET_ERR(err < 0, "lookup_elem(linum_map)", "err:%d errno:%d\n",
242
241
err, errno);
243
242
244
243
return linum;
···
255
254
addrlen = sizeof(cli_sa);
256
255
err = getsockname(cli_fd, (struct sockaddr *)&cli_sa,
257
256
&addrlen);
258
-
RET_IF(err == -1, "getsockname(cli_fd)", "err:%d errno:%d\n",
257
+
RET_IF(err < 0, "getsockname(cli_fd)", "err:%d errno:%d\n",
259
258
err, errno);
260
259
261
260
err = bpf_map_lookup_elem(data_check_map, &index_zero, &result);
262
-
RET_IF(err == -1, "lookup_elem(data_check_map)", "err:%d errno:%d\n",
261
+
RET_IF(err < 0, "lookup_elem(data_check_map)", "err:%d errno:%d\n",
263
262
err, errno);
264
263
265
264
if (type == SOCK_STREAM) {
···
348
347
349
348
for (i = 0; i < NR_RESULTS; i++) {
350
349
err = bpf_map_lookup_elem(result_map, &i, &results[i]);
351
-
RET_IF(err == -1, "lookup_elem(result_map)",
350
+
RET_IF(err < 0, "lookup_elem(result_map)",
352
351
"i:%u err:%d errno:%d\n", i, err, errno);
353
352
}
354
353
···
525
524
*/
526
525
err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero,
527
526
&tmp_index, BPF_ANY);
528
-
RET_IF(err == -1, "update_elem(tmp_index_ovr_map, 0, 1)",
527
+
RET_IF(err < 0, "update_elem(tmp_index_ovr_map, 0, 1)",
529
528
"err:%d errno:%d\n", err, errno);
530
529
do_test(type, family, &cmd, PASS);
531
530
err = bpf_map_lookup_elem(tmp_index_ovr_map, &index_zero,
532
531
&tmp_index);
533
-
RET_IF(err == -1 || tmp_index != -1,
532
+
RET_IF(err < 0 || tmp_index >= 0,
534
533
"lookup_elem(tmp_index_ovr_map)",
535
534
"err:%d errno:%d tmp_index:%d\n",
536
535
err, errno, tmp_index);
···
570
569
571
570
for (i = 0; i < NR_RESULTS; i++) {
572
571
err = bpf_map_lookup_elem(result_map, &i, &tmp);
573
-
RET_IF(err == -1, "lookup_elem(result_map)",
572
+
RET_IF(err < 0, "lookup_elem(result_map)",
574
573
"i:%u err:%d errno:%d\n", i, err, errno);
575
574
nr_run_before += tmp;
576
575
}
···
585
584
586
585
for (i = 0; i < NR_RESULTS; i++) {
587
586
err = bpf_map_lookup_elem(result_map, &i, &tmp);
588
-
RET_IF(err == -1, "lookup_elem(result_map)",
587
+
RET_IF(err < 0, "lookup_elem(result_map)",
589
588
"i:%u err:%d errno:%d\n", i, err, errno);
590
589
nr_run_after += tmp;
591
590
}
···
633
632
SO_ATTACH_REUSEPORT_EBPF,
634
633
&select_by_skb_data_prog,
635
634
sizeof(select_by_skb_data_prog));
636
-
RET_IF(err == -1, "setsockopt(SO_ATTACH_REUEPORT_EBPF)",
635
+
RET_IF(err < 0, "setsockopt(SO_ATTACH_REUEPORT_EBPF)",
637
636
"err:%d errno:%d\n", err, errno);
638
637
}
639
638
640
639
err = bind(sk_fds[i], (struct sockaddr *)&srv_sa, addrlen);
641
-
RET_IF(err == -1, "bind()", "sk_fds[%d] err:%d errno:%d\n",
640
+
RET_IF(err < 0, "bind()", "sk_fds[%d] err:%d errno:%d\n",
642
641
i, err, errno);
643
642
644
643
if (type == SOCK_STREAM) {
645
644
err = listen(sk_fds[i], 10);
646
-
RET_IF(err == -1, "listen()",
645
+
RET_IF(err < 0, "listen()",
647
646
"sk_fds[%d] err:%d errno:%d\n",
648
647
i, err, errno);
649
648
}
650
649
651
650
err = bpf_map_update_elem(reuseport_array, &i, &sk_fds[i],
652
651
BPF_NOEXIST);
653
-
RET_IF(err == -1, "update_elem(reuseport_array)",
652
+
RET_IF(err < 0, "update_elem(reuseport_array)",
654
653
"sk_fds[%d] err:%d errno:%d\n", i, err, errno);
655
654
656
655
if (i == first) {
···
683
682
prepare_sk_fds(type, family, inany);
684
683
err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero, &ovr,
685
684
BPF_ANY);
686
-
RET_IF(err == -1, "update_elem(tmp_index_ovr_map, 0, -1)",
685
+
RET_IF(err < 0, "update_elem(tmp_index_ovr_map, 0, -1)",
687
686
"err:%d errno:%d\n", err, errno);
688
687
689
688
/* Install reuseport_array to outer_map? */
···
692
691
693
692
err = bpf_map_update_elem(outer_map, &index_zero, &reuseport_array,
694
693
BPF_ANY);
695
-
RET_IF(err == -1, "update_elem(outer_map, 0, reuseport_array)",
694
+
RET_IF(err < 0, "update_elem(outer_map, 0, reuseport_array)",
696
695
"err:%d errno:%d\n", err, errno);
697
696
}
698
697
···
721
720
return;
722
721
723
722
err = bpf_map_delete_elem(outer_map, &index_zero);
724
-
RET_IF(err == -1, "delete_elem(outer_map)",
723
+
RET_IF(err < 0, "delete_elem(outer_map)",
725
724
"err:%d errno:%d\n", err, errno);
726
725
}
727
726
728
727
static void cleanup(void)
729
728
{
730
-
if (outer_map != -1) {
729
+
if (outer_map >= 0) {
731
730
close(outer_map);
732
731
outer_map = -1;
733
732
}
734
733
735
-
if (reuseport_array != -1) {
734
+
if (reuseport_array >= 0) {
736
735
close(reuseport_array);
737
736
reuseport_array = -1;
738
737
}
+1
-2
tools/testing/selftests/bpf/prog_tests/send_signal.c
+1
-2
tools/testing/selftests/bpf/prog_tests/send_signal.c
···
91
91
92
92
skel->links.send_signal_perf =
93
93
bpf_program__attach_perf_event(skel->progs.send_signal_perf, pmu_fd);
94
-
if (CHECK(IS_ERR(skel->links.send_signal_perf), "attach_perf_event",
95
-
"err %ld\n", PTR_ERR(skel->links.send_signal_perf)))
94
+
if (!ASSERT_OK_PTR(skel->links.send_signal_perf, "attach_perf_event"))
96
95
goto disable_pmu;
97
96
}
98
97
+1
-1
tools/testing/selftests/bpf/prog_tests/sk_lookup.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sk_lookup.c
···
480
480
}
481
481
482
482
link = bpf_program__attach_netns(prog, net_fd);
483
-
if (CHECK(IS_ERR(link), "bpf_program__attach_netns", "failed\n")) {
483
+
if (!ASSERT_OK_PTR(link, "bpf_program__attach_netns")) {
484
484
errno = -PTR_ERR(link);
485
485
log_err("failed to attach program '%s' to netns",
486
486
bpf_program__name(prog));
+6
-8
tools/testing/selftests/bpf/prog_tests/sock_fields.c
+6
-8
tools/testing/selftests/bpf/prog_tests/sock_fields.c
···
97
97
98
98
err = bpf_map_lookup_elem(linum_map_fd, &egress_linum_idx,
99
99
&egress_linum);
100
-
CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
100
+
CHECK(err < 0, "bpf_map_lookup_elem(linum_map_fd)",
101
101
"err:%d errno:%d\n", err, errno);
102
102
103
103
err = bpf_map_lookup_elem(linum_map_fd, &ingress_linum_idx,
104
104
&ingress_linum);
105
-
CHECK(err == -1, "bpf_map_lookup_elem(linum_map_fd)",
105
+
CHECK(err < 0, "bpf_map_lookup_elem(linum_map_fd)",
106
106
"err:%d errno:%d\n", err, errno);
107
107
108
108
memcpy(&srv_sk, &skel->bss->srv_sk, sizeof(srv_sk));
···
355
355
356
356
egress_link = bpf_program__attach_cgroup(skel->progs.egress_read_sock_fields,
357
357
child_cg_fd);
358
-
if (CHECK(IS_ERR(egress_link), "attach_cgroup(egress)", "err:%ld\n",
359
-
PTR_ERR(egress_link)))
358
+
if (!ASSERT_OK_PTR(egress_link, "attach_cgroup(egress)"))
360
359
goto done;
361
360
362
361
ingress_link = bpf_program__attach_cgroup(skel->progs.ingress_read_sock_fields,
363
362
child_cg_fd);
364
-
if (CHECK(IS_ERR(ingress_link), "attach_cgroup(ingress)", "err:%ld\n",
365
-
PTR_ERR(ingress_link)))
363
+
if (!ASSERT_OK_PTR(ingress_link, "attach_cgroup(ingress)"))
366
364
goto done;
367
365
368
366
linum_map_fd = bpf_map__fd(skel->maps.linum_map);
···
373
375
bpf_link__destroy(egress_link);
374
376
bpf_link__destroy(ingress_link);
375
377
test_sock_fields__destroy(skel);
376
-
if (child_cg_fd != -1)
378
+
if (child_cg_fd >= 0)
377
379
close(child_cg_fd);
378
-
if (parent_cg_fd != -1)
380
+
if (parent_cg_fd >= 0)
379
381
close(parent_cg_fd);
380
382
}
+4
-4
tools/testing/selftests/bpf/prog_tests/sockmap_basic.c
+4
-4
tools/testing/selftests/bpf/prog_tests/sockmap_basic.c
···
88
88
int s, map, err;
89
89
90
90
s = connected_socket_v4();
91
-
if (CHECK_FAIL(s == -1))
91
+
if (CHECK_FAIL(s < 0))
92
92
return;
93
93
94
94
map = bpf_create_map(map_type, sizeof(int), sizeof(int), 1, 0);
95
-
if (CHECK_FAIL(map == -1)) {
95
+
if (CHECK_FAIL(map < 0)) {
96
96
perror("bpf_create_map");
97
97
goto out;
98
98
}
···
245
245
opts.link_info = &linfo;
246
246
opts.link_info_len = sizeof(linfo);
247
247
link = bpf_program__attach_iter(skel->progs.copy, &opts);
248
-
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
248
+
if (!ASSERT_OK_PTR(link, "attach_iter"))
249
249
goto out;
250
250
251
251
iter_fd = bpf_iter_create(bpf_link__fd(link));
···
304
304
}
305
305
306
306
err = bpf_prog_attach(verdict, map, second, 0);
307
-
assert(err == -1 && errno == EBUSY);
307
+
ASSERT_EQ(err, -EBUSY, "prog_attach_fail");
308
308
309
309
err = bpf_prog_detach2(verdict, map, first);
310
310
if (CHECK_FAIL(err)) {
+1
-1
tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
+5
-5
tools/testing/selftests/bpf/prog_tests/sockmap_listen.c
+5
-5
tools/testing/selftests/bpf/prog_tests/sockmap_listen.c
···
139
139
#define xbpf_map_delete_elem(fd, key) \
140
140
({ \
141
141
int __ret = bpf_map_delete_elem((fd), (key)); \
142
-
if (__ret == -1) \
142
+
if (__ret < 0) \
143
143
FAIL_ERRNO("map_delete"); \
144
144
__ret; \
145
145
})
···
147
147
#define xbpf_map_lookup_elem(fd, key, val) \
148
148
({ \
149
149
int __ret = bpf_map_lookup_elem((fd), (key), (val)); \
150
-
if (__ret == -1) \
150
+
if (__ret < 0) \
151
151
FAIL_ERRNO("map_lookup"); \
152
152
__ret; \
153
153
})
···
155
155
#define xbpf_map_update_elem(fd, key, val, flags) \
156
156
({ \
157
157
int __ret = bpf_map_update_elem((fd), (key), (val), (flags)); \
158
-
if (__ret == -1) \
158
+
if (__ret < 0) \
159
159
FAIL_ERRNO("map_update"); \
160
160
__ret; \
161
161
})
···
164
164
({ \
165
165
int __ret = \
166
166
bpf_prog_attach((prog), (target), (type), (flags)); \
167
-
if (__ret == -1) \
167
+
if (__ret < 0) \
168
168
FAIL_ERRNO("prog_attach(" #type ")"); \
169
169
__ret; \
170
170
})
···
172
172
#define xbpf_prog_detach2(prog, target, type) \
173
173
({ \
174
174
int __ret = bpf_prog_detach2((prog), (target), (type)); \
175
-
if (__ret == -1) \
175
+
if (__ret < 0) \
176
176
FAIL_ERRNO("prog_detach2(" #type ")"); \
177
177
__ret; \
178
178
})
+1
-2
tools/testing/selftests/bpf/prog_tests/stacktrace_build_id_nmi.c
+1
-2
tools/testing/selftests/bpf/prog_tests/stacktrace_build_id_nmi.c
···
62
62
63
63
skel->links.oncpu = bpf_program__attach_perf_event(skel->progs.oncpu,
64
64
pmu_fd);
65
-
if (CHECK(IS_ERR(skel->links.oncpu), "attach_perf_event",
66
-
"err %ld\n", PTR_ERR(skel->links.oncpu))) {
65
+
if (!ASSERT_OK_PTR(skel->links.oncpu, "attach_perf_event")) {
67
66
close(pmu_fd);
68
67
goto cleanup;
69
68
}
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
+2
-3
tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
+2
-3
tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
···
21
21
goto close_prog;
22
22
23
23
link = bpf_program__attach_raw_tracepoint(prog, "sched_switch");
24
-
if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n", PTR_ERR(link)))
24
+
if (!ASSERT_OK_PTR(link, "attach_raw_tp"))
25
25
goto close_prog;
26
26
27
27
/* find map fds */
···
59
59
goto close_prog;
60
60
61
61
close_prog:
62
-
if (!IS_ERR_OR_NULL(link))
63
-
bpf_link__destroy(link);
62
+
bpf_link__destroy(link);
64
63
bpf_object__close(obj);
65
64
}
+5
-10
tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c
+5
-10
tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c
···
353
353
return;
354
354
355
355
link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
356
-
if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
357
-
PTR_ERR(link)))
356
+
if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
358
357
return;
359
358
360
359
if (sk_fds_connect(&sk_fds, true)) {
···
397
398
return;
398
399
399
400
link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
400
-
if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
401
-
PTR_ERR(link)))
401
+
if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
402
402
return;
403
403
404
404
if (sk_fds_connect(&sk_fds, false)) {
···
429
431
return;
430
432
431
433
link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
432
-
if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
433
-
PTR_ERR(link)))
434
+
if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
434
435
return;
435
436
436
437
if (sk_fds_connect(&sk_fds, false)) {
···
468
471
return;
469
472
470
473
link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
471
-
if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
472
-
PTR_ERR(link)))
474
+
if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
473
475
return;
474
476
475
477
if (sk_fds_connect(&sk_fds, false)) {
···
505
509
return;
506
510
507
511
link = bpf_program__attach_cgroup(misc_skel->progs.misc_estab, cg_fd);
508
-
if (CHECK(IS_ERR(link), "attach_cgroup(misc_estab)", "err: %ld\n",
509
-
PTR_ERR(link)))
512
+
if (!ASSERT_OK_PTR(link, "attach_cgroup(misc_estab)"))
510
513
return;
511
514
512
515
if (sk_fds_connect(&sk_fds, false)) {
+6
-6
tools/testing/selftests/bpf/prog_tests/test_overhead.c
+6
-6
tools/testing/selftests/bpf/prog_tests/test_overhead.c
···
73
73
return;
74
74
75
75
obj = bpf_object__open_file("./test_overhead.o", NULL);
76
-
if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj)))
76
+
if (!ASSERT_OK_PTR(obj, "obj_open_file"))
77
77
return;
78
78
79
79
kprobe_prog = bpf_object__find_program_by_title(obj, kprobe_name);
···
108
108
/* attach kprobe */
109
109
link = bpf_program__attach_kprobe(kprobe_prog, false /* retprobe */,
110
110
kprobe_func);
111
-
if (CHECK(IS_ERR(link), "attach_kprobe", "err %ld\n", PTR_ERR(link)))
111
+
if (!ASSERT_OK_PTR(link, "attach_kprobe"))
112
112
goto cleanup;
113
113
test_run("kprobe");
114
114
bpf_link__destroy(link);
···
116
116
/* attach kretprobe */
117
117
link = bpf_program__attach_kprobe(kretprobe_prog, true /* retprobe */,
118
118
kprobe_func);
119
-
if (CHECK(IS_ERR(link), "attach kretprobe", "err %ld\n", PTR_ERR(link)))
119
+
if (!ASSERT_OK_PTR(link, "attach_kretprobe"))
120
120
goto cleanup;
121
121
test_run("kretprobe");
122
122
bpf_link__destroy(link);
123
123
124
124
/* attach raw_tp */
125
125
link = bpf_program__attach_raw_tracepoint(raw_tp_prog, "task_rename");
126
-
if (CHECK(IS_ERR(link), "attach fentry", "err %ld\n", PTR_ERR(link)))
126
+
if (!ASSERT_OK_PTR(link, "attach_raw_tp"))
127
127
goto cleanup;
128
128
test_run("raw_tp");
129
129
bpf_link__destroy(link);
130
130
131
131
/* attach fentry */
132
132
link = bpf_program__attach_trace(fentry_prog);
133
-
if (CHECK(IS_ERR(link), "attach fentry", "err %ld\n", PTR_ERR(link)))
133
+
if (!ASSERT_OK_PTR(link, "attach_fentry"))
134
134
goto cleanup;
135
135
test_run("fentry");
136
136
bpf_link__destroy(link);
137
137
138
138
/* attach fexit */
139
139
link = bpf_program__attach_trace(fexit_prog);
140
-
if (CHECK(IS_ERR(link), "attach fexit", "err %ld\n", PTR_ERR(link)))
140
+
if (!ASSERT_OK_PTR(link, "attach_fexit"))
141
141
goto cleanup;
142
142
test_run("fexit");
143
143
bpf_link__destroy(link);
+8
-6
tools/testing/selftests/bpf/prog_tests/trampoline_count.c
+8
-6
tools/testing/selftests/bpf/prog_tests/trampoline_count.c
···
55
55
/* attach 'allowed' trampoline programs */
56
56
for (i = 0; i < MAX_TRAMP_PROGS; i++) {
57
57
obj = bpf_object__open_file(object, NULL);
58
-
if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj))) {
58
+
if (!ASSERT_OK_PTR(obj, "obj_open_file")) {
59
59
obj = NULL;
60
60
goto cleanup;
61
61
}
···
68
68
69
69
if (rand() % 2) {
70
70
link = load(inst[i].obj, fentry_name);
71
-
if (CHECK(IS_ERR(link), "attach prog", "err %ld\n", PTR_ERR(link))) {
71
+
if (!ASSERT_OK_PTR(link, "attach_prog")) {
72
72
link = NULL;
73
73
goto cleanup;
74
74
}
75
75
inst[i].link_fentry = link;
76
76
} else {
77
77
link = load(inst[i].obj, fexit_name);
78
-
if (CHECK(IS_ERR(link), "attach prog", "err %ld\n", PTR_ERR(link))) {
78
+
if (!ASSERT_OK_PTR(link, "attach_prog")) {
79
79
link = NULL;
80
80
goto cleanup;
81
81
}
···
85
85
86
86
/* and try 1 extra.. */
87
87
obj = bpf_object__open_file(object, NULL);
88
-
if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj))) {
88
+
if (!ASSERT_OK_PTR(obj, "obj_open_file")) {
89
89
obj = NULL;
90
90
goto cleanup;
91
91
}
···
96
96
97
97
/* ..that needs to fail */
98
98
link = load(obj, fentry_name);
99
-
if (CHECK(!IS_ERR(link), "cannot attach over the limit", "err %ld\n", PTR_ERR(link))) {
99
+
err = libbpf_get_error(link);
100
+
if (!ASSERT_ERR_PTR(link, "cannot attach over the limit")) {
100
101
bpf_link__destroy(link);
101
102
goto cleanup_extra;
102
103
}
103
104
104
105
/* with E2BIG error */
105
-
CHECK(PTR_ERR(link) != -E2BIG, "proper error check", "err %ld\n", PTR_ERR(link));
106
+
ASSERT_EQ(err, -E2BIG, "proper error check");
107
+
ASSERT_EQ(link, NULL, "ptr_is_null");
106
108
107
109
/* and finaly execute the probe */
108
110
if (CHECK_FAIL(prctl(PR_GET_NAME, comm, 0L, 0L, 0L)))
+3
-4
tools/testing/selftests/bpf/prog_tests/udp_limit.c
+3
-4
tools/testing/selftests/bpf/prog_tests/udp_limit.c
···
22
22
goto close_cgroup_fd;
23
23
24
24
skel->links.sock = bpf_program__attach_cgroup(skel->progs.sock, cgroup_fd);
25
+
if (!ASSERT_OK_PTR(skel->links.sock, "cg_attach_sock"))
26
+
goto close_skeleton;
25
27
skel->links.sock_release = bpf_program__attach_cgroup(skel->progs.sock_release, cgroup_fd);
26
-
if (CHECK(IS_ERR(skel->links.sock) || IS_ERR(skel->links.sock_release),
27
-
"cg-attach", "sock %ld sock_release %ld",
28
-
PTR_ERR(skel->links.sock),
29
-
PTR_ERR(skel->links.sock_release)))
28
+
if (!ASSERT_OK_PTR(skel->links.sock_release, "cg_attach_sock_release"))
30
29
goto close_skeleton;
31
30
32
31
/* BPF program enforces a single UDP socket per cgroup,
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c
+4
-4
tools/testing/selftests/bpf/prog_tests/xdp_link.c
+4
-4
tools/testing/selftests/bpf/prog_tests/xdp_link.c
···
51
51
52
52
/* BPF link is not allowed to replace prog attachment */
53
53
link = bpf_program__attach_xdp(skel1->progs.xdp_handler, IFINDEX_LO);
54
-
if (CHECK(!IS_ERR(link), "link_attach_fail", "unexpected success\n")) {
54
+
if (!ASSERT_ERR_PTR(link, "link_attach_should_fail")) {
55
55
bpf_link__destroy(link);
56
56
/* best-effort detach prog */
57
57
opts.old_fd = prog_fd1;
···
67
67
68
68
/* now BPF link should attach successfully */
69
69
link = bpf_program__attach_xdp(skel1->progs.xdp_handler, IFINDEX_LO);
70
-
if (CHECK(IS_ERR(link), "link_attach", "failed: %ld\n", PTR_ERR(link)))
70
+
if (!ASSERT_OK_PTR(link, "link_attach"))
71
71
goto cleanup;
72
72
skel1->links.xdp_handler = link;
73
73
···
95
95
96
96
/* BPF link is not allowed to replace another BPF link */
97
97
link = bpf_program__attach_xdp(skel2->progs.xdp_handler, IFINDEX_LO);
98
-
if (CHECK(!IS_ERR(link), "link_attach_fail", "unexpected success\n")) {
98
+
if (!ASSERT_ERR_PTR(link, "link_attach_should_fail")) {
99
99
bpf_link__destroy(link);
100
100
goto cleanup;
101
101
}
···
105
105
106
106
/* new link attach should succeed */
107
107
link = bpf_program__attach_xdp(skel2->progs.xdp_handler, IFINDEX_LO);
108
-
if (CHECK(IS_ERR(link), "link_attach", "failed: %ld\n", PTR_ERR(link)))
108
+
if (!ASSERT_OK_PTR(link, "link_attach"))
109
109
goto cleanup;
110
110
skel2->links.xdp_handler = link;
111
111
+85
-83
tools/testing/selftests/bpf/test_maps.c
+85
-83
tools/testing/selftests/bpf/test_maps.c
···
53
53
54
54
value = 0;
55
55
/* BPF_NOEXIST means add new element if it doesn't exist. */
56
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
56
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
57
57
/* key=1 already exists. */
58
58
errno == EEXIST);
59
59
60
60
/* -1 is an invalid flag. */
61
-
assert(bpf_map_update_elem(fd, &key, &value, -1) == -1 &&
61
+
assert(bpf_map_update_elem(fd, &key, &value, -1) < 0 &&
62
62
errno == EINVAL);
63
63
64
64
/* Check that key=1 can be found. */
···
73
73
assert(bpf_map_lookup_and_delete_elem(fd, &key, &value) == 0 && value == 1234);
74
74
75
75
/* Check that key=2 is not found. */
76
-
assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
76
+
assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
77
77
78
78
/* BPF_EXIST means update existing element. */
79
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
79
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&
80
80
/* key=2 is not there. */
81
81
errno == ENOENT);
82
82
···
87
87
* inserted due to max_entries limit.
88
88
*/
89
89
key = 0;
90
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
90
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
91
91
errno == E2BIG);
92
92
93
93
/* Update existing element, though the map is full. */
···
96
96
key = 2;
97
97
assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
98
98
key = 3;
99
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
99
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
100
100
errno == E2BIG);
101
101
102
102
/* Check that key = 0 doesn't exist. */
103
103
key = 0;
104
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
104
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
105
105
106
106
/* Iterate over two elements. */
107
107
assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
···
111
111
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
112
112
(next_key == 1 || next_key == 2) &&
113
113
(next_key != first_key));
114
-
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
114
+
assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
115
115
errno == ENOENT);
116
116
117
117
/* Delete both elements. */
···
119
119
assert(bpf_map_delete_elem(fd, &key) == 0);
120
120
key = 2;
121
121
assert(bpf_map_delete_elem(fd, &key) == 0);
122
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
122
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
123
123
124
124
key = 0;
125
125
/* Check that map is empty. */
126
-
assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
126
+
assert(bpf_map_get_next_key(fd, NULL, &next_key) < 0 &&
127
127
errno == ENOENT);
128
-
assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
128
+
assert(bpf_map_get_next_key(fd, &key, &next_key) < 0 &&
129
129
errno == ENOENT);
130
130
131
131
close(fd);
···
186
186
expected_key_mask |= key;
187
187
188
188
/* BPF_NOEXIST means add new element if it doesn't exist. */
189
-
assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
189
+
assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&
190
190
/* key=1 already exists. */
191
191
errno == EEXIST);
192
192
193
193
/* -1 is an invalid flag. */
194
-
assert(bpf_map_update_elem(fd, &key, value, -1) == -1 &&
194
+
assert(bpf_map_update_elem(fd, &key, value, -1) < 0 &&
195
195
errno == EINVAL);
196
196
197
197
/* Check that key=1 can be found. Value could be 0 if the lookup
···
203
203
204
204
key = 2;
205
205
/* Check that key=2 is not found. */
206
-
assert(bpf_map_lookup_elem(fd, &key, value) == -1 && errno == ENOENT);
206
+
assert(bpf_map_lookup_elem(fd, &key, value) < 0 && errno == ENOENT);
207
207
208
208
/* BPF_EXIST means update existing element. */
209
-
assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == -1 &&
209
+
assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) < 0 &&
210
210
/* key=2 is not there. */
211
211
errno == ENOENT);
212
212
···
219
219
* inserted due to max_entries limit.
220
220
*/
221
221
key = 0;
222
-
assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
222
+
assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) < 0 &&
223
223
errno == E2BIG);
224
224
225
225
/* Check that key = 0 doesn't exist. */
226
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
226
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
227
227
228
228
/* Iterate over two elements. */
229
229
assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
···
254
254
assert(bpf_map_delete_elem(fd, &key) == 0);
255
255
key = 2;
256
256
assert(bpf_map_delete_elem(fd, &key) == 0);
257
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
257
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == ENOENT);
258
258
259
259
key = 0;
260
260
/* Check that map is empty. */
261
-
assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
261
+
assert(bpf_map_get_next_key(fd, NULL, &next_key) < 0 &&
262
262
errno == ENOENT);
263
-
assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
263
+
assert(bpf_map_get_next_key(fd, &key, &next_key) < 0 &&
264
264
errno == ENOENT);
265
265
266
266
close(fd);
···
377
377
assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
378
378
379
379
value = 0;
380
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
380
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
381
381
errno == EEXIST);
382
382
383
383
/* Check that key=1 can be found. */
···
391
391
* due to max_entries limit.
392
392
*/
393
393
key = 2;
394
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
394
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) < 0 &&
395
395
errno == E2BIG);
396
396
397
397
/* Check that key = 2 doesn't exist. */
398
-
assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
398
+
assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
399
399
400
400
/* Iterate over two elements. */
401
401
assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
···
404
404
next_key == 0);
405
405
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
406
406
next_key == 1);
407
-
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
407
+
assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
408
408
errno == ENOENT);
409
409
410
410
/* Delete shouldn't succeed. */
411
411
key = 1;
412
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
412
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == EINVAL);
413
413
414
414
close(fd);
415
415
}
···
435
435
assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
436
436
437
437
bpf_percpu(values, 0) = 0;
438
-
assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) == -1 &&
438
+
assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) < 0 &&
439
439
errno == EEXIST);
440
440
441
441
/* Check that key=1 can be found. */
···
450
450
451
451
/* Check that key=2 cannot be inserted due to max_entries limit. */
452
452
key = 2;
453
-
assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) == -1 &&
453
+
assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) < 0 &&
454
454
errno == E2BIG);
455
455
456
456
/* Check that key = 2 doesn't exist. */
457
-
assert(bpf_map_lookup_elem(fd, &key, values) == -1 && errno == ENOENT);
457
+
assert(bpf_map_lookup_elem(fd, &key, values) < 0 && errno == ENOENT);
458
458
459
459
/* Iterate over two elements. */
460
460
assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
···
463
463
next_key == 0);
464
464
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
465
465
next_key == 1);
466
-
assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
466
+
assert(bpf_map_get_next_key(fd, &next_key, &next_key) < 0 &&
467
467
errno == ENOENT);
468
468
469
469
/* Delete shouldn't succeed. */
470
470
key = 1;
471
-
assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
471
+
assert(bpf_map_delete_elem(fd, &key) < 0 && errno == EINVAL);
472
472
473
473
close(fd);
474
474
}
···
572
572
assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
573
573
574
574
/* Check that element cannot be pushed due to max_entries limit */
575
-
assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
575
+
assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&
576
576
errno == E2BIG);
577
577
578
578
/* Peek element */
···
588
588
val == vals[i]);
589
589
590
590
/* Check that there are not elements left */
591
-
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
591
+
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) < 0 &&
592
592
errno == ENOENT);
593
593
594
594
/* Check that non supported functions set errno to EINVAL */
595
-
assert(bpf_map_delete_elem(fd, NULL) == -1 && errno == EINVAL);
596
-
assert(bpf_map_get_next_key(fd, NULL, NULL) == -1 && errno == EINVAL);
595
+
assert(bpf_map_delete_elem(fd, NULL) < 0 && errno == EINVAL);
596
+
assert(bpf_map_get_next_key(fd, NULL, NULL) < 0 && errno == EINVAL);
597
597
598
598
close(fd);
599
599
}
···
630
630
assert(bpf_map_update_elem(fd, NULL, &vals[i], 0) == 0);
631
631
632
632
/* Check that element cannot be pushed due to max_entries limit */
633
-
assert(bpf_map_update_elem(fd, NULL, &val, 0) == -1 &&
633
+
assert(bpf_map_update_elem(fd, NULL, &val, 0) < 0 &&
634
634
errno == E2BIG);
635
635
636
636
/* Peek element */
···
646
646
val == vals[i]);
647
647
648
648
/* Check that there are not elements left */
649
-
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) == -1 &&
649
+
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &val) < 0 &&
650
650
errno == ENOENT);
651
651
652
652
/* Check that non supported functions set errno to EINVAL */
653
-
assert(bpf_map_delete_elem(fd, NULL) == -1 && errno == EINVAL);
654
-
assert(bpf_map_get_next_key(fd, NULL, NULL) == -1 && errno == EINVAL);
653
+
assert(bpf_map_delete_elem(fd, NULL) < 0 && errno == EINVAL);
654
+
assert(bpf_map_get_next_key(fd, NULL, NULL) < 0 && errno == EINVAL);
655
655
656
656
close(fd);
657
657
}
···
852
852
}
853
853
854
854
bpf_map_rx = bpf_object__find_map_by_name(obj, "sock_map_rx");
855
-
if (IS_ERR(bpf_map_rx)) {
855
+
if (!bpf_map_rx) {
856
856
printf("Failed to load map rx from verdict prog\n");
857
857
goto out_sockmap;
858
858
}
···
864
864
}
865
865
866
866
bpf_map_tx = bpf_object__find_map_by_name(obj, "sock_map_tx");
867
-
if (IS_ERR(bpf_map_tx)) {
867
+
if (!bpf_map_tx) {
868
868
printf("Failed to load map tx from verdict prog\n");
869
869
goto out_sockmap;
870
870
}
···
876
876
}
877
877
878
878
bpf_map_msg = bpf_object__find_map_by_name(obj, "sock_map_msg");
879
-
if (IS_ERR(bpf_map_msg)) {
879
+
if (!bpf_map_msg) {
880
880
printf("Failed to load map msg from msg_verdict prog\n");
881
881
goto out_sockmap;
882
882
}
···
888
888
}
889
889
890
890
bpf_map_break = bpf_object__find_map_by_name(obj, "sock_map_break");
891
-
if (IS_ERR(bpf_map_break)) {
891
+
if (!bpf_map_break) {
892
892
printf("Failed to load map tx from verdict prog\n");
893
893
goto out_sockmap;
894
894
}
···
1170
1170
}
1171
1171
1172
1172
map = bpf_object__find_map_by_name(obj, "mim_array");
1173
-
if (IS_ERR(map)) {
1173
+
if (!map) {
1174
1174
printf("Failed to load array of maps from test prog\n");
1175
1175
goto out_map_in_map;
1176
1176
}
···
1181
1181
}
1182
1182
1183
1183
map = bpf_object__find_map_by_name(obj, "mim_hash");
1184
-
if (IS_ERR(map)) {
1184
+
if (!map) {
1185
1185
printf("Failed to load hash of maps from test prog\n");
1186
1186
goto out_map_in_map;
1187
1187
}
···
1194
1194
bpf_object__load(obj);
1195
1195
1196
1196
map = bpf_object__find_map_by_name(obj, "mim_array");
1197
-
if (IS_ERR(map)) {
1197
+
if (!map) {
1198
1198
printf("Failed to load array of maps from test prog\n");
1199
1199
goto out_map_in_map;
1200
1200
}
···
1211
1211
}
1212
1212
1213
1213
map = bpf_object__find_map_by_name(obj, "mim_hash");
1214
-
if (IS_ERR(map)) {
1214
+
if (!map) {
1215
1215
printf("Failed to load hash of maps from test prog\n");
1216
1216
goto out_map_in_map;
1217
1217
}
···
1263
1263
}
1264
1264
1265
1265
key.c = -1;
1266
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1266
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
1267
1267
errno == E2BIG);
1268
1268
1269
1269
/* Iterate through all elements. */
···
1271
1271
key.c = -1;
1272
1272
for (i = 0; i < MAP_SIZE; i++)
1273
1273
assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1274
-
assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1274
+
assert(bpf_map_get_next_key(fd, &key, &key) < 0 && errno == ENOENT);
1275
1275
1276
1276
key.c = 0;
1277
1277
assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
1278
1278
key.a = 1;
1279
-
assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1279
+
assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
1280
1280
1281
1281
close(fd);
1282
1282
}
···
1408
1408
run_parallel(TASKS, test_update_delete, data);
1409
1409
1410
1410
/* Check that key=0 is already there. */
1411
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1411
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) < 0 &&
1412
1412
errno == EEXIST);
1413
1413
1414
1414
/* Check that all elements were inserted. */
···
1416
1416
key = -1;
1417
1417
for (i = 0; i < MAP_SIZE; i++)
1418
1418
assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1419
-
assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1419
+
assert(bpf_map_get_next_key(fd, &key, &key) < 0 && errno == ENOENT);
1420
1420
1421
1421
/* Another check for all elements */
1422
1422
for (i = 0; i < MAP_SIZE; i++) {
···
1432
1432
1433
1433
/* Nothing should be left. */
1434
1434
key = -1;
1435
-
assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
1436
-
assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1435
+
assert(bpf_map_get_next_key(fd, NULL, &key) < 0 && errno == ENOENT);
1436
+
assert(bpf_map_get_next_key(fd, &key, &key) < 0 && errno == ENOENT);
1437
1437
}
1438
1438
1439
1439
static void test_map_rdonly(void)
···
1451
1451
key = 1;
1452
1452
value = 1234;
1453
1453
/* Try to insert key=1 element. */
1454
-
assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == -1 &&
1454
+
assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) < 0 &&
1455
1455
errno == EPERM);
1456
1456
1457
1457
/* Check that key=1 is not found. */
1458
-
assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1459
-
assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == ENOENT);
1458
+
assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == ENOENT);
1459
+
assert(bpf_map_get_next_key(fd, &key, &value) < 0 && errno == ENOENT);
1460
1460
1461
1461
close(fd);
1462
1462
}
···
1479
1479
assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1480
1480
1481
1481
/* Check that reading elements and keys from the map is not allowed. */
1482
-
assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == EPERM);
1483
-
assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == EPERM);
1482
+
assert(bpf_map_lookup_elem(fd, &key, &value) < 0 && errno == EPERM);
1483
+
assert(bpf_map_get_next_key(fd, &key, &value) < 0 && errno == EPERM);
1484
1484
1485
1485
close(fd);
1486
1486
}
···
1507
1507
assert(bpf_map_update_elem(fd, NULL, &value, BPF_ANY) == 0);
1508
1508
1509
1509
/* Peek element should fail */
1510
-
assert(bpf_map_lookup_elem(fd, NULL, &value) == -1 && errno == EPERM);
1510
+
assert(bpf_map_lookup_elem(fd, NULL, &value) < 0 && errno == EPERM);
1511
1511
1512
1512
/* Pop element should fail */
1513
-
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &value) == -1 &&
1513
+
assert(bpf_map_lookup_and_delete_elem(fd, NULL, &value) < 0 &&
1514
1514
errno == EPERM);
1515
1515
1516
1516
close(fd);
···
1564
1564
value = &fd32;
1565
1565
}
1566
1566
err = bpf_map_update_elem(map_fd, &index0, value, BPF_ANY);
1567
-
CHECK(err != -1 || errno != EINVAL,
1567
+
CHECK(err >= 0 || errno != EINVAL,
1568
1568
"reuseport array update unbound sk",
1569
1569
"sock_type:%d err:%d errno:%d\n",
1570
1570
type, err, errno);
···
1593
1593
*/
1594
1594
err = bpf_map_update_elem(map_fd, &index0, value,
1595
1595
BPF_ANY);
1596
-
CHECK(err != -1 || errno != EINVAL,
1596
+
CHECK(err >= 0 || errno != EINVAL,
1597
1597
"reuseport array update non-listening sk",
1598
1598
"sock_type:%d err:%d errno:%d\n",
1599
1599
type, err, errno);
···
1623
1623
1624
1624
map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1625
1625
sizeof(__u32), sizeof(__u64), array_size, 0);
1626
-
CHECK(map_fd == -1, "reuseport array create",
1626
+
CHECK(map_fd < 0, "reuseport array create",
1627
1627
"map_fd:%d, errno:%d\n", map_fd, errno);
1628
1628
1629
1629
/* Test lookup/update/delete with invalid index */
1630
1630
err = bpf_map_delete_elem(map_fd, &bad_index);
1631
-
CHECK(err != -1 || errno != E2BIG, "reuseport array del >=max_entries",
1631
+
CHECK(err >= 0 || errno != E2BIG, "reuseport array del >=max_entries",
1632
1632
"err:%d errno:%d\n", err, errno);
1633
1633
1634
1634
err = bpf_map_update_elem(map_fd, &bad_index, &fd64, BPF_ANY);
1635
-
CHECK(err != -1 || errno != E2BIG,
1635
+
CHECK(err >= 0 || errno != E2BIG,
1636
1636
"reuseport array update >=max_entries",
1637
1637
"err:%d errno:%d\n", err, errno);
1638
1638
1639
1639
err = bpf_map_lookup_elem(map_fd, &bad_index, &map_cookie);
1640
-
CHECK(err != -1 || errno != ENOENT,
1640
+
CHECK(err >= 0 || errno != ENOENT,
1641
1641
"reuseport array update >=max_entries",
1642
1642
"err:%d errno:%d\n", err, errno);
1643
1643
1644
1644
/* Test lookup/delete non existence elem */
1645
1645
err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1646
-
CHECK(err != -1 || errno != ENOENT,
1646
+
CHECK(err >= 0 || errno != ENOENT,
1647
1647
"reuseport array lookup not-exist elem",
1648
1648
"err:%d errno:%d\n", err, errno);
1649
1649
err = bpf_map_delete_elem(map_fd, &index3);
1650
-
CHECK(err != -1 || errno != ENOENT,
1650
+
CHECK(err >= 0 || errno != ENOENT,
1651
1651
"reuseport array del not-exist elem",
1652
1652
"err:%d errno:%d\n", err, errno);
1653
1653
···
1661
1661
/* BPF_EXIST failure case */
1662
1662
err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1663
1663
BPF_EXIST);
1664
-
CHECK(err != -1 || errno != ENOENT,
1664
+
CHECK(err >= 0 || errno != ENOENT,
1665
1665
"reuseport array update empty elem BPF_EXIST",
1666
1666
"sock_type:%d err:%d errno:%d\n",
1667
1667
type, err, errno);
···
1670
1670
/* BPF_NOEXIST success case */
1671
1671
err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1672
1672
BPF_NOEXIST);
1673
-
CHECK(err == -1,
1673
+
CHECK(err < 0,
1674
1674
"reuseport array update empty elem BPF_NOEXIST",
1675
1675
"sock_type:%d err:%d errno:%d\n",
1676
1676
type, err, errno);
···
1679
1679
/* BPF_EXIST success case. */
1680
1680
err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1681
1681
BPF_EXIST);
1682
-
CHECK(err == -1,
1682
+
CHECK(err < 0,
1683
1683
"reuseport array update same elem BPF_EXIST",
1684
1684
"sock_type:%d err:%d errno:%d\n", type, err, errno);
1685
1685
fds_idx = REUSEPORT_FD_IDX(err, fds_idx);
···
1687
1687
/* BPF_NOEXIST failure case */
1688
1688
err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1689
1689
BPF_NOEXIST);
1690
-
CHECK(err != -1 || errno != EEXIST,
1690
+
CHECK(err >= 0 || errno != EEXIST,
1691
1691
"reuseport array update non-empty elem BPF_NOEXIST",
1692
1692
"sock_type:%d err:%d errno:%d\n",
1693
1693
type, err, errno);
···
1696
1696
/* BPF_ANY case (always succeed) */
1697
1697
err = bpf_map_update_elem(map_fd, &index3, &grpa_fds64[fds_idx],
1698
1698
BPF_ANY);
1699
-
CHECK(err == -1,
1699
+
CHECK(err < 0,
1700
1700
"reuseport array update same sk with BPF_ANY",
1701
1701
"sock_type:%d err:%d errno:%d\n", type, err, errno);
1702
1702
···
1705
1705
1706
1706
/* The same sk cannot be added to reuseport_array twice */
1707
1707
err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_ANY);
1708
-
CHECK(err != -1 || errno != EBUSY,
1708
+
CHECK(err >= 0 || errno != EBUSY,
1709
1709
"reuseport array update same sk with same index",
1710
1710
"sock_type:%d err:%d errno:%d\n",
1711
1711
type, err, errno);
1712
1712
1713
1713
err = bpf_map_update_elem(map_fd, &index0, &fd64, BPF_ANY);
1714
-
CHECK(err != -1 || errno != EBUSY,
1714
+
CHECK(err >= 0 || errno != EBUSY,
1715
1715
"reuseport array update same sk with different index",
1716
1716
"sock_type:%d err:%d errno:%d\n",
1717
1717
type, err, errno);
1718
1718
1719
1719
/* Test delete elem */
1720
1720
err = bpf_map_delete_elem(map_fd, &index3);
1721
-
CHECK(err == -1, "reuseport array delete sk",
1721
+
CHECK(err < 0, "reuseport array delete sk",
1722
1722
"sock_type:%d err:%d errno:%d\n",
1723
1723
type, err, errno);
1724
1724
1725
1725
/* Add it back with BPF_NOEXIST */
1726
1726
err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1727
-
CHECK(err == -1,
1727
+
CHECK(err < 0,
1728
1728
"reuseport array re-add with BPF_NOEXIST after del",
1729
1729
"sock_type:%d err:%d errno:%d\n", type, err, errno);
1730
1730
1731
1731
/* Test cookie */
1732
1732
err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1733
-
CHECK(err == -1 || sk_cookie != map_cookie,
1733
+
CHECK(err < 0 || sk_cookie != map_cookie,
1734
1734
"reuseport array lookup re-added sk",
1735
1735
"sock_type:%d err:%d errno:%d sk_cookie:0x%llx map_cookie:0x%llxn",
1736
1736
type, err, errno, sk_cookie, map_cookie);
···
1739
1739
for (f = 0; f < ARRAY_SIZE(grpa_fds64); f++)
1740
1740
close(grpa_fds64[f]);
1741
1741
err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1742
-
CHECK(err != -1 || errno != ENOENT,
1742
+
CHECK(err >= 0 || errno != ENOENT,
1743
1743
"reuseport array lookup after close()",
1744
1744
"sock_type:%d err:%d errno:%d\n",
1745
1745
type, err, errno);
···
1750
1750
CHECK(fd64 == -1, "socket(SOCK_RAW)", "err:%d errno:%d\n",
1751
1751
err, errno);
1752
1752
err = bpf_map_update_elem(map_fd, &index3, &fd64, BPF_NOEXIST);
1753
-
CHECK(err != -1 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1753
+
CHECK(err >= 0 || errno != ENOTSUPP, "reuseport array update SOCK_RAW",
1754
1754
"err:%d errno:%d\n", err, errno);
1755
1755
close(fd64);
1756
1756
···
1760
1760
/* Test 32 bit fd */
1761
1761
map_fd = bpf_create_map(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
1762
1762
sizeof(__u32), sizeof(__u32), array_size, 0);
1763
-
CHECK(map_fd == -1, "reuseport array create",
1763
+
CHECK(map_fd < 0, "reuseport array create",
1764
1764
"map_fd:%d, errno:%d\n", map_fd, errno);
1765
1765
prepare_reuseport_grp(SOCK_STREAM, map_fd, sizeof(__u32), &fd64,
1766
1766
&sk_cookie, 1);
1767
1767
fd = fd64;
1768
1768
err = bpf_map_update_elem(map_fd, &index3, &fd, BPF_NOEXIST);
1769
-
CHECK(err == -1, "reuseport array update 32 bit fd",
1769
+
CHECK(err < 0, "reuseport array update 32 bit fd",
1770
1770
"err:%d errno:%d\n", err, errno);
1771
1771
err = bpf_map_lookup_elem(map_fd, &index3, &map_cookie);
1772
-
CHECK(err != -1 || errno != ENOSPC,
1772
+
CHECK(err >= 0 || errno != ENOSPC,
1773
1773
"reuseport array lookup 32 bit fd",
1774
1774
"err:%d errno:%d\n", err, errno);
1775
1775
close(fd);
···
1814
1814
int main(void)
1815
1815
{
1816
1816
srand(time(NULL));
1817
+
1818
+
libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
1817
1819
1818
1820
map_flags = 0;
1819
1821
run_all_tests();
+3
tools/testing/selftests/bpf/test_progs.c
+3
tools/testing/selftests/bpf/test_progs.c
+5
-4
tools/testing/selftests/bpf/test_progs.h
+5
-4
tools/testing/selftests/bpf/test_progs.h
···
249
249
#define ASSERT_OK_PTR(ptr, name) ({ \
250
250
static int duration = 0; \
251
251
const void *___res = (ptr); \
252
-
bool ___ok = !IS_ERR_OR_NULL(___res); \
253
-
CHECK(!___ok, (name), \
254
-
"unexpected error: %ld\n", PTR_ERR(___res)); \
252
+
int ___err = libbpf_get_error(___res); \
253
+
bool ___ok = ___err == 0; \
254
+
CHECK(!___ok, (name), "unexpected error: %d\n", ___err); \
255
255
___ok; \
256
256
})
257
257
258
258
#define ASSERT_ERR_PTR(ptr, name) ({ \
259
259
static int duration = 0; \
260
260
const void *___res = (ptr); \
261
-
bool ___ok = IS_ERR(___res); \
261
+
int ___err = libbpf_get_error(___res); \
262
+
bool ___ok = ___err != 0; \
262
263
CHECK(!___ok, (name), "unexpected pointer: %p\n", ___res); \
263
264
___ok; \
264
265
})
+4
-3
tools/testing/selftests/bpf/test_tcpnotify_user.c
+4
-3
tools/testing/selftests/bpf/test_tcpnotify_user.c
···
82
82
cpu_set_t cpuset;
83
83
__u32 key = 0;
84
84
85
+
libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
86
+
85
87
CPU_ZERO(&cpuset);
86
88
CPU_SET(0, &cpuset);
87
89
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
···
118
116
119
117
pb_opts.sample_cb = dummyfn;
120
118
pb = perf_buffer__new(bpf_map__fd(perf_map), 8, &pb_opts);
121
-
if (IS_ERR(pb))
119
+
if (!pb)
122
120
goto err;
123
121
124
122
pthread_create(&tid, NULL, poller_thread, pb);
···
165
163
bpf_prog_detach(cg_fd, BPF_CGROUP_SOCK_OPS);
166
164
close(cg_fd);
167
165
cleanup_cgroup_environment();
168
-
if (!IS_ERR_OR_NULL(pb))
169
-
perf_buffer__free(pb);
166
+
perf_buffer__free(pb);
170
167
return error;
171
168
}