Loading...
1// SPDX-License-Identifier: GPL-2.0
2#define _GNU_SOURCE
3#include <test_progs.h>
4#include "cgroup_helpers.h"
5#include "network_helpers.h"
6#include "tcp_rtt.skel.h"
7
8struct tcp_rtt_storage {
9 __u32 invoked;
10 __u32 dsack_dups;
11 __u32 delivered;
12 __u32 delivered_ce;
13 __u32 icsk_retransmits;
14
15 __u32 mrtt_us; /* args[0] */
16 __u32 srtt; /* args[1] */
17};
18
19static void send_byte(int fd)
20{
21 char b = 0x55;
22
23 ASSERT_EQ(write(fd, &b, sizeof(b)), 1, "send single byte");
24}
25
26static int wait_for_ack(int fd, int retries)
27{
28 struct tcp_info info;
29 socklen_t optlen;
30 int i, err;
31
32 for (i = 0; i < retries; i++) {
33 optlen = sizeof(info);
34 err = getsockopt(fd, SOL_TCP, TCP_INFO, &info, &optlen);
35 if (err < 0) {
36 log_err("Failed to lookup TCP stats");
37 return err;
38 }
39
40 if (info.tcpi_unacked == 0)
41 return 0;
42
43 usleep(10);
44 }
45
46 log_err("Did not receive ACK");
47 return -1;
48}
49
50static int verify_sk(int map_fd, int client_fd, const char *msg, __u32 invoked,
51 __u32 dsack_dups, __u32 delivered, __u32 delivered_ce,
52 __u32 icsk_retransmits)
53{
54 int err = 0;
55 struct tcp_rtt_storage val;
56
57 if (!ASSERT_GE(bpf_map_lookup_elem(map_fd, &client_fd, &val), 0, "read socket storage"))
58 return -1;
59
60 if (val.invoked != invoked) {
61 log_err("%s: unexpected bpf_tcp_sock.invoked %d != %d",
62 msg, val.invoked, invoked);
63 err++;
64 }
65
66 if (val.dsack_dups != dsack_dups) {
67 log_err("%s: unexpected bpf_tcp_sock.dsack_dups %d != %d",
68 msg, val.dsack_dups, dsack_dups);
69 err++;
70 }
71
72 if (val.delivered != delivered) {
73 log_err("%s: unexpected bpf_tcp_sock.delivered %d != %d",
74 msg, val.delivered, delivered);
75 err++;
76 }
77
78 if (val.delivered_ce != delivered_ce) {
79 log_err("%s: unexpected bpf_tcp_sock.delivered_ce %d != %d",
80 msg, val.delivered_ce, delivered_ce);
81 err++;
82 }
83
84 if (val.icsk_retransmits != icsk_retransmits) {
85 log_err("%s: unexpected bpf_tcp_sock.icsk_retransmits %d != %d",
86 msg, val.icsk_retransmits, icsk_retransmits);
87 err++;
88 }
89
90 /* Precise values of mrtt and srtt are unavailable, just make sure they are nonzero */
91 if (val.mrtt_us == 0) {
92 log_err("%s: unexpected bpf_tcp_sock.args[0] (mrtt_us) %u == 0", msg, val.mrtt_us);
93 err++;
94 }
95
96 if (val.srtt == 0) {
97 log_err("%s: unexpected bpf_tcp_sock.args[1] (srtt) %u == 0", msg, val.srtt);
98 err++;
99 }
100
101 return err;
102}
103
104
105static int run_test(int cgroup_fd, int server_fd)
106{
107 struct tcp_rtt *skel;
108 int client_fd;
109 int prog_fd;
110 int map_fd;
111 int err;
112
113 skel = tcp_rtt__open_and_load();
114 if (!ASSERT_OK_PTR(skel, "skel_open_load"))
115 return -1;
116
117 map_fd = bpf_map__fd(skel->maps.socket_storage_map);
118 prog_fd = bpf_program__fd(skel->progs._sockops);
119
120 err = bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS, 0);
121 if (err) {
122 log_err("Failed to attach BPF program");
123 goto close_bpf_object;
124 }
125
126 client_fd = connect_to_fd(server_fd, 0);
127 if (client_fd < 0) {
128 err = -1;
129 goto close_bpf_object;
130 }
131
132 err += verify_sk(map_fd, client_fd, "syn-ack",
133 /*invoked=*/1,
134 /*dsack_dups=*/0,
135 /*delivered=*/1,
136 /*delivered_ce=*/0,
137 /*icsk_retransmits=*/0);
138
139 send_byte(client_fd);
140 if (wait_for_ack(client_fd, 100) < 0) {
141 err = -1;
142 goto close_client_fd;
143 }
144
145
146 err += verify_sk(map_fd, client_fd, "first payload byte",
147 /*invoked=*/2,
148 /*dsack_dups=*/0,
149 /*delivered=*/2,
150 /*delivered_ce=*/0,
151 /*icsk_retransmits=*/0);
152
153close_client_fd:
154 close(client_fd);
155
156close_bpf_object:
157 tcp_rtt__destroy(skel);
158 return err;
159}
160
161void test_tcp_rtt(void)
162{
163 int server_fd, cgroup_fd;
164
165 cgroup_fd = test__join_cgroup("/tcp_rtt");
166 if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup /tcp_rtt"))
167 return;
168
169 server_fd = start_server(AF_INET, SOCK_STREAM, NULL, 0, 0);
170 if (!ASSERT_GE(server_fd, 0, "start_server"))
171 goto close_cgroup_fd;
172
173 ASSERT_OK(run_test(cgroup_fd, server_fd), "run_test");
174
175 close(server_fd);
176
177close_cgroup_fd:
178 close(cgroup_fd);
179}
1// SPDX-License-Identifier: GPL-2.0
2#include <test_progs.h>
3#include "cgroup_helpers.h"
4#include "network_helpers.h"
5
6struct tcp_rtt_storage {
7 __u32 invoked;
8 __u32 dsack_dups;
9 __u32 delivered;
10 __u32 delivered_ce;
11 __u32 icsk_retransmits;
12};
13
14static void send_byte(int fd)
15{
16 char b = 0x55;
17
18 if (CHECK_FAIL(write(fd, &b, sizeof(b)) != 1))
19 perror("Failed to send single byte");
20}
21
22static int wait_for_ack(int fd, int retries)
23{
24 struct tcp_info info;
25 socklen_t optlen;
26 int i, err;
27
28 for (i = 0; i < retries; i++) {
29 optlen = sizeof(info);
30 err = getsockopt(fd, SOL_TCP, TCP_INFO, &info, &optlen);
31 if (err < 0) {
32 log_err("Failed to lookup TCP stats");
33 return err;
34 }
35
36 if (info.tcpi_unacked == 0)
37 return 0;
38
39 usleep(10);
40 }
41
42 log_err("Did not receive ACK");
43 return -1;
44}
45
46static int verify_sk(int map_fd, int client_fd, const char *msg, __u32 invoked,
47 __u32 dsack_dups, __u32 delivered, __u32 delivered_ce,
48 __u32 icsk_retransmits)
49{
50 int err = 0;
51 struct tcp_rtt_storage val;
52
53 if (CHECK_FAIL(bpf_map_lookup_elem(map_fd, &client_fd, &val) < 0)) {
54 perror("Failed to read socket storage");
55 return -1;
56 }
57
58 if (val.invoked != invoked) {
59 log_err("%s: unexpected bpf_tcp_sock.invoked %d != %d",
60 msg, val.invoked, invoked);
61 err++;
62 }
63
64 if (val.dsack_dups != dsack_dups) {
65 log_err("%s: unexpected bpf_tcp_sock.dsack_dups %d != %d",
66 msg, val.dsack_dups, dsack_dups);
67 err++;
68 }
69
70 if (val.delivered != delivered) {
71 log_err("%s: unexpected bpf_tcp_sock.delivered %d != %d",
72 msg, val.delivered, delivered);
73 err++;
74 }
75
76 if (val.delivered_ce != delivered_ce) {
77 log_err("%s: unexpected bpf_tcp_sock.delivered_ce %d != %d",
78 msg, val.delivered_ce, delivered_ce);
79 err++;
80 }
81
82 if (val.icsk_retransmits != icsk_retransmits) {
83 log_err("%s: unexpected bpf_tcp_sock.icsk_retransmits %d != %d",
84 msg, val.icsk_retransmits, icsk_retransmits);
85 err++;
86 }
87
88 return err;
89}
90
91
92static int run_test(int cgroup_fd, int server_fd)
93{
94 struct bpf_prog_load_attr attr = {
95 .prog_type = BPF_PROG_TYPE_SOCK_OPS,
96 .file = "./tcp_rtt.o",
97 .expected_attach_type = BPF_CGROUP_SOCK_OPS,
98 };
99 struct bpf_object *obj;
100 struct bpf_map *map;
101 int client_fd;
102 int prog_fd;
103 int map_fd;
104 int err;
105
106 err = bpf_prog_load_xattr(&attr, &obj, &prog_fd);
107 if (err) {
108 log_err("Failed to load BPF object");
109 return -1;
110 }
111
112 map = bpf_map__next(NULL, obj);
113 map_fd = bpf_map__fd(map);
114
115 err = bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS, 0);
116 if (err) {
117 log_err("Failed to attach BPF program");
118 goto close_bpf_object;
119 }
120
121 client_fd = connect_to_fd(server_fd, 0);
122 if (client_fd < 0) {
123 err = -1;
124 goto close_bpf_object;
125 }
126
127 err += verify_sk(map_fd, client_fd, "syn-ack",
128 /*invoked=*/1,
129 /*dsack_dups=*/0,
130 /*delivered=*/1,
131 /*delivered_ce=*/0,
132 /*icsk_retransmits=*/0);
133
134 send_byte(client_fd);
135 if (wait_for_ack(client_fd, 100) < 0) {
136 err = -1;
137 goto close_client_fd;
138 }
139
140
141 err += verify_sk(map_fd, client_fd, "first payload byte",
142 /*invoked=*/2,
143 /*dsack_dups=*/0,
144 /*delivered=*/2,
145 /*delivered_ce=*/0,
146 /*icsk_retransmits=*/0);
147
148close_client_fd:
149 close(client_fd);
150
151close_bpf_object:
152 bpf_object__close(obj);
153 return err;
154}
155
156void test_tcp_rtt(void)
157{
158 int server_fd, cgroup_fd;
159
160 cgroup_fd = test__join_cgroup("/tcp_rtt");
161 if (CHECK_FAIL(cgroup_fd < 0))
162 return;
163
164 server_fd = start_server(AF_INET, SOCK_STREAM, NULL, 0, 0);
165 if (CHECK_FAIL(server_fd < 0))
166 goto close_cgroup_fd;
167
168 CHECK_FAIL(run_test(cgroup_fd, server_fd));
169
170 close(server_fd);
171
172close_cgroup_fd:
173 close(cgroup_fd);
174}