1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2 // Copyright (c) 2020 Wenbo Zhang
3 //
4 // Based on tcpconnlat(8) from BCC by Brendan Gregg.
5 // 11-Jul-2020 Wenbo Zhang Created this.
6 #include <argp.h>
7 #include <arpa/inet.h>
8 #include <signal.h>
9 #include <stdio.h>
10 #include <unistd.h>
11 #include <time.h>
12 #include <bpf/libbpf.h>
13 #include <bpf/bpf.h>
14 #include "tcpconnlat.h"
15 #include "tcpconnlat.skel.h"
16 #include "trace_helpers.h"
17
18 #define PERF_BUFFER_PAGES 16
19 #define PERF_POLL_TIMEOUT_MS 100
20
21 static volatile sig_atomic_t exiting = 0;
22
23 static struct env {
24 __u64 min_us;
25 pid_t pid;
26 bool timestamp;
27 bool lport;
28 bool verbose;
29 } env;
30
31 const char *argp_program_version = "tcpconnlat 0.1";
32 const char *argp_program_bug_address =
33 "https://github.com/iovisor/bcc/tree/master/libbpf-tools";
34 const char argp_program_doc[] =
35 "\nTrace TCP connects and show connection latency.\n"
36 "\n"
37 "USAGE: tcpconnlat [--help] [-t] [-p PID] [-L]\n"
38 "\n"
39 "EXAMPLES:\n"
40 " tcpconnlat # summarize on-CPU time as a histogram\n"
41 " tcpconnlat 1 # trace connection latency slower than 1 ms\n"
42 " tcpconnlat 0.1 # trace connection latency slower than 100 us\n"
43 " tcpconnlat -t # 1s summaries, milliseconds, and timestamps\n"
44 " tcpconnlat -p 185 # trace PID 185 only\n"
45 " tcpconnlat -L # include LPORT while printing outputs\n";
46
47 static const struct argp_option opts[] = {
48 { "timestamp", 't', NULL, 0, "Include timestamp on output" },
49 { "pid", 'p', "PID", 0, "Trace this PID only" },
50 { "lport", 'L', NULL, 0, "Include LPORT on output" },
51 { "verbose", 'v', NULL, 0, "Verbose debug output" },
52 { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" },
53 {},
54 };
55
parse_arg(int key,char * arg,struct argp_state * state)56 static error_t parse_arg(int key, char *arg, struct argp_state *state)
57 {
58 static int pos_args;
59
60 switch (key) {
61 case 'h':
62 argp_state_help(state, stderr, ARGP_HELP_STD_HELP);
63 break;
64 case 'v':
65 env.verbose = true;
66 break;
67 case 'p':
68 errno = 0;
69 env.pid = strtol(arg, NULL, 10);
70 if (errno) {
71 fprintf(stderr, "invalid PID: %s\n", arg);
72 argp_usage(state);
73 }
74 break;
75 case 't':
76 env.timestamp = true;
77 break;
78 case 'L':
79 env.lport = true;
80 break;
81 case ARGP_KEY_ARG:
82 if (pos_args++) {
83 fprintf(stderr,
84 "Unrecognized positional argument: %s\n", arg);
85 argp_usage(state);
86 }
87 errno = 0;
88 env.min_us = strtod(arg, NULL) * 1000;
89 if (errno || env.min_us <= 0) {
90 fprintf(stderr, "Invalid delay (in us): %s\n", arg);
91 argp_usage(state);
92 }
93 break;
94 default:
95 return ARGP_ERR_UNKNOWN;
96 }
97 return 0;
98 }
99
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)100 static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
101 {
102 if (level == LIBBPF_DEBUG && !env.verbose)
103 return 0;
104 return vfprintf(stderr, format, args);
105 }
106
sig_int(int signo)107 static void sig_int(int signo)
108 {
109 exiting = 1;
110 }
111
handle_event(void * ctx,int cpu,void * data,__u32 data_sz)112 void handle_event(void *ctx, int cpu, void *data, __u32 data_sz)
113 {
114 const struct event *e = data;
115 char src[INET6_ADDRSTRLEN];
116 char dst[INET6_ADDRSTRLEN];
117 union {
118 struct in_addr x4;
119 struct in6_addr x6;
120 } s, d;
121 static __u64 start_ts;
122
123 if (env.timestamp) {
124 if (start_ts == 0)
125 start_ts = e->ts_us;
126 printf("%-9.3f ", (e->ts_us - start_ts) / 1000000.0);
127 }
128 if (e->af == AF_INET) {
129 s.x4.s_addr = e->saddr_v4;
130 d.x4.s_addr = e->daddr_v4;
131 } else if (e->af == AF_INET6) {
132 memcpy(&s.x6.s6_addr, e->saddr_v6, sizeof(s.x6.s6_addr));
133 memcpy(&d.x6.s6_addr, e->daddr_v6, sizeof(d.x6.s6_addr));
134 } else {
135 fprintf(stderr, "broken event: event->af=%d", e->af);
136 return;
137 }
138
139 if (env.lport) {
140 printf("%-6d %-12.12s %-2d %-16s %-6d %-16s %-5d %.2f\n", e->tgid, e->comm,
141 e->af == AF_INET ? 4 : 6, inet_ntop(e->af, &s, src, sizeof(src)), e->lport,
142 inet_ntop(e->af, &d, dst, sizeof(dst)), ntohs(e->dport),
143 e->delta_us / 1000.0);
144 } else {
145 printf("%-6d %-12.12s %-2d %-16s %-16s %-5d %.2f\n", e->tgid, e->comm,
146 e->af == AF_INET ? 4 : 6, inet_ntop(e->af, &s, src, sizeof(src)),
147 inet_ntop(e->af, &d, dst, sizeof(dst)), ntohs(e->dport),
148 e->delta_us / 1000.0);
149 }
150 }
151
handle_lost_events(void * ctx,int cpu,__u64 lost_cnt)152 void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt)
153 {
154 fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu);
155 }
156
main(int argc,char ** argv)157 int main(int argc, char **argv)
158 {
159 static const struct argp argp = {
160 .options = opts,
161 .parser = parse_arg,
162 .doc = argp_program_doc,
163 };
164 struct perf_buffer *pb = NULL;
165 struct tcpconnlat_bpf *obj;
166 int err;
167
168 err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
169 if (err)
170 return err;
171
172 libbpf_set_print(libbpf_print_fn);
173
174 obj = tcpconnlat_bpf__open();
175 if (!obj) {
176 fprintf(stderr, "failed to open BPF object\n");
177 return 1;
178 }
179
180 /* initialize global data (filtering options) */
181 obj->rodata->targ_min_us = env.min_us;
182 obj->rodata->targ_tgid = env.pid;
183
184 if (fentry_can_attach("tcp_v4_connect", NULL)) {
185 bpf_program__set_attach_target(obj->progs.fentry_tcp_v4_connect, 0, "tcp_v4_connect");
186 bpf_program__set_attach_target(obj->progs.fentry_tcp_v6_connect, 0, "tcp_v6_connect");
187 bpf_program__set_attach_target(obj->progs.fentry_tcp_rcv_state_process, 0, "tcp_rcv_state_process");
188 bpf_program__set_autoload(obj->progs.tcp_v4_connect, false);
189 bpf_program__set_autoload(obj->progs.tcp_v6_connect, false);
190 bpf_program__set_autoload(obj->progs.tcp_rcv_state_process, false);
191 } else {
192 bpf_program__set_autoload(obj->progs.fentry_tcp_v4_connect, false);
193 bpf_program__set_autoload(obj->progs.fentry_tcp_v6_connect, false);
194 bpf_program__set_autoload(obj->progs.fentry_tcp_rcv_state_process, false);
195 }
196
197 err = tcpconnlat_bpf__load(obj);
198 if (err) {
199 fprintf(stderr, "failed to load BPF object: %d\n", err);
200 goto cleanup;
201 }
202
203 err = tcpconnlat_bpf__attach(obj);
204 if (err) {
205 goto cleanup;
206 }
207
208 pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES,
209 handle_event, handle_lost_events, NULL, NULL);
210 if (!pb) {
211 fprintf(stderr, "failed to open perf buffer: %d\n", errno);
212 goto cleanup;
213 }
214
215 /* print header */
216 if (env.timestamp)
217 printf("%-9s ", ("TIME(s)"));
218 if (env.lport) {
219 printf("%-6s %-12s %-2s %-16s %-6s %-16s %-5s %s\n",
220 "PID", "COMM", "IP", "SADDR", "LPORT", "DADDR", "DPORT", "LAT(ms)");
221 } else {
222 printf("%-6s %-12s %-2s %-16s %-16s %-5s %s\n",
223 "PID", "COMM", "IP", "SADDR", "DADDR", "DPORT", "LAT(ms)");
224 }
225
226 if (signal(SIGINT, sig_int) == SIG_ERR) {
227 fprintf(stderr, "can't set signal handler: %s\n", strerror(errno));
228 err = 1;
229 goto cleanup;
230 }
231
232 /* main: poll */
233 while (!exiting) {
234 err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS);
235 if (err < 0 && err != -EINTR) {
236 fprintf(stderr, "error polling perf buffer: %s\n", strerror(-err));
237 goto cleanup;
238 }
239 /* reset err to return 0 if exiting */
240 err = 0;
241 }
242
243 cleanup:
244 perf_buffer__free(pb);
245 tcpconnlat_bpf__destroy(obj);
246
247 return err != 0;
248 }
249