1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2 // Copyright (c) 2023 Wenbo Zhang
3 #include <argp.h>
4 #include <signal.h>
5 #include <stdio.h>
6 #include <unistd.h>
7 #include <fcntl.h>
8 #include <time.h>
9 #include <arpa/inet.h>
10 #include <sys/socket.h>
11 #include <sys/resource.h>
12
13 #include <bpf/bpf.h>
14 #include <bpf/libbpf.h>
15 #include "tcppktlat.h"
16 #include "tcppktlat.skel.h"
17 #include "compat.h"
18 #include "trace_helpers.h"
19
20 static struct env {
21 pid_t pid;
22 pid_t tid;
23 __u64 min_us;
24 __u16 lport;
25 __u16 rport;
26 bool timestamp;
27 bool verbose;
28 } env = {};
29
30 static volatile sig_atomic_t exiting = 0;
31 static int column_width = 15;
32
33 const char *argp_program_version = "tcppktlat 0.1";
34 const char *argp_program_bug_address =
35 "https://github.com/iovisor/bcc/tree/master/libbpf-tools";
36 const char argp_program_doc[] =
37 "Trace latency between TCP received pkt and picked up by userspace thread.\n"
38 "\n"
39 "USAGE: tcppktlat [--help] [-T] [-p PID] [-t TID] [-l LPORT] [-r RPORT] [-w] [-v]\n"
40 "\n"
41 "EXAMPLES:\n"
42 " tcppktlat # Trace all TCP packet picked up latency\n"
43 " tcppktlat -T # summarize with timestamps\n"
44 " tcppktlat -p # filter for pid\n"
45 " tcppktlat -t # filter for tid\n"
46 " tcppktlat -l # filter for local port\n"
47 " tcppktlat -r # filter for remote port\n"
48 " tcppktlat 1000 # filter for latency higher than 1000us";
49
50 static const struct argp_option opts[] = {
51 { "pid", 'p', "PID", 0, "Process PID to trace"},
52 { "tid", 't', "TID", 0, "Thread TID to trace"},
53 { "timestamp", 'T', NULL, 0, "include timestamp on output" },
54 { "lport", 'l', "LPORT", 0, "filter for local port" },
55 { "rport", 'r', "RPORT", 0, "filter for remote port" },
56 { "verbose", 'v', NULL, 0, "Verbose debug output" },
57 { "wide", 'w', NULL, 0, "Wide column output (fits IPv6 addresses)" },
58 { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" },
59 {},
60 };
61
parse_arg(int key,char * arg,struct argp_state * state)62 static error_t parse_arg(int key, char *arg, struct argp_state *state)
63 {
64 static int pos_args;
65 long long min_us;
66 int pid;
67
68 switch (key) {
69 case 'h':
70 argp_state_help(state, stderr, ARGP_HELP_STD_HELP);
71 break;
72 case 'v':
73 env.verbose = true;
74 break;
75 case 'T':
76 env.timestamp = true;
77 break;
78 case 'p':
79 errno = 0;
80 pid = strtol(arg, NULL, 10);
81 if (errno || pid <= 0) {
82 fprintf(stderr, "Invalid PID: %s\n", arg);
83 argp_usage(state);
84 }
85 env.pid = pid;
86 break;
87 case 't':
88 errno = 0;
89 pid = strtol(arg, NULL, 10);
90 if (errno || pid <= 0) {
91 fprintf(stderr, "Invalid TID: %s\n", arg);
92 argp_usage(state);
93 }
94 env.tid = pid;
95 break;
96 case 'l':
97 errno = 0;
98 env.lport = strtoul(arg, NULL, 10);
99 if (errno) {
100 fprintf(stderr, "invalid lport: %s\n", arg);
101 argp_usage(state);
102 }
103 env.lport = htons(env.lport);
104 break;
105 case 'r':
106 errno = 0;
107 env.rport = strtoul(arg, NULL, 10);
108 if (errno) {
109 fprintf(stderr, "invalid rport: %s\n", arg);
110 argp_usage(state);
111 }
112 env.rport = htons(env.rport);
113 break;
114 case 'w':
115 column_width = 26;
116 break;
117 case ARGP_KEY_ARG:
118 if (pos_args++) {
119 fprintf(stderr,
120 "Unrecognized positional argument: %s\n", arg);
121 argp_usage(state);
122 }
123 errno = 0;
124 min_us = strtoll(arg, NULL, 10);
125 if (errno || min_us <= 0) {
126 fprintf(stderr, "Invalid delay (in us): %s\n", arg);
127 argp_usage(state);
128 }
129 env.min_us = min_us;
130 break;
131 default:
132 return ARGP_ERR_UNKNOWN;
133 }
134 return 0;
135 }
136
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)137 static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
138 {
139 if (level == LIBBPF_DEBUG && !env.verbose)
140 return 0;
141 return vfprintf(stderr, format, args);
142 }
143
sig_int(int signo)144 static void sig_int(int signo)
145 {
146 exiting = 1;
147 }
148
handle_event(void * ctx,void * data,size_t data_sz)149 static int handle_event(void *ctx, void *data, size_t data_sz)
150 {
151 const struct event *e = data;
152 char saddr[48], daddr[48];
153 struct tm *tm;
154 char ts[32];
155 time_t t;
156
157 if (env.timestamp) {
158 time(&t);
159 tm = localtime(&t);
160 strftime(ts, sizeof(ts), "%H:%M:%S", tm);
161 printf("%-8s ", ts);
162 }
163 inet_ntop(e->family, &e->saddr, saddr, sizeof(saddr));
164 inet_ntop(e->family, &e->daddr, daddr, sizeof(daddr));
165
166 printf("%-7d %-7d %-16s %-*s %-5d %-*s %-5d %-.2f\n",
167 e->pid, e->tid, e->comm, column_width, saddr, ntohs(e->sport), column_width, daddr,
168 ntohs(e->dport), e->delta_us / 1000.0);
169
170 return 0;
171 }
172
handle_lost_events(void * ctx,int cpu,__u64 lost_cnt)173 static void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt)
174 {
175 fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu);
176 }
177
main(int argc,char ** argv)178 int main(int argc, char **argv)
179 {
180 static const struct argp argp = {
181 .options = opts,
182 .parser = parse_arg,
183 .doc = argp_program_doc,
184 };
185 struct bpf_buffer *buf = NULL;
186 struct tcppktlat_bpf *obj;
187 int err;
188
189 err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
190 if (err)
191 return err;
192
193 libbpf_set_print(libbpf_print_fn);
194
195 obj = tcppktlat_bpf__open();
196 if (!obj) {
197 fprintf(stderr, "failed to open BPF object\n");
198 return 1;
199 }
200
201 obj->rodata->targ_pid = env.pid;
202 obj->rodata->targ_tid = env.tid;
203 obj->rodata->targ_sport = env.lport;
204 obj->rodata->targ_dport = env.rport;
205 obj->rodata->targ_min_us = env.min_us;
206
207 buf = bpf_buffer__new(obj->maps.events, obj->maps.heap);
208 if (!buf) {
209 err = -errno;
210 fprintf(stderr, "failed to create ring/perf buffer: %d\n", err);
211 goto cleanup;
212 }
213
214 if (probe_tp_btf("tcp_probe")) {
215 bpf_program__set_autoload(obj->progs.tcp_probe, false);
216 bpf_program__set_autoload(obj->progs.tcp_rcv_space_adjust, false);
217 bpf_program__set_autoload(obj->progs.tcp_destroy_sock, false);
218 } else {
219 bpf_program__set_autoload(obj->progs.tcp_probe_btf, false);
220 bpf_program__set_autoload(obj->progs.tcp_rcv_space_adjust_btf, false);
221 bpf_program__set_autoload(obj->progs.tcp_destroy_sock_btf, false);
222 }
223
224 err = tcppktlat_bpf__load(obj);
225 if (err) {
226 fprintf(stderr, "failed to load BPF object: %d, maybe your kernel doesn't support `bpf_get_socket_cookie`\n", err);
227 goto cleanup;
228 }
229
230 err = tcppktlat_bpf__attach(obj);
231 if (err) {
232 fprintf(stderr, "failed to attach BPF object: %d\n", err);
233 goto cleanup;
234 }
235
236 err = bpf_buffer__open(buf, handle_event, handle_lost_events, NULL);
237 if (err) {
238 fprintf(stderr, "failed to open ring/perf buffer: %d\n", err);
239 goto cleanup;
240 }
241
242 if (signal(SIGINT, sig_int) == SIG_ERR) {
243 fprintf(stderr, "can't set signal handler: %s\n", strerror(errno));
244 err = 1;
245 goto cleanup;
246 }
247
248 if (env.timestamp)
249 printf("%-8s ", "TIME(s)");
250 printf("%-7s %-7s %-16s %-*s %-5s %-*s %-5s %-s\n",
251 "PID", "TID", "COMM", column_width, "LADDR", "LPORT", column_width, "RADDR", "RPORT", "MS");
252
253 while (!exiting) {
254 err = bpf_buffer__poll(buf, POLL_TIMEOUT_MS);
255 if (err < 0 && err != -EINTR) {
256 fprintf(stderr, "error polling ring/perf buffer: %s\n", strerror(-err));
257 goto cleanup;
258 }
259 /* reset err to return 0 if exiting */
260 err = 0;
261 }
262 cleanup:
263 bpf_buffer__free(buf);
264 tcppktlat_bpf__destroy(obj);
265
266 return err != 0;
267 }
268