1 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2 /*
3 * Copyright (c) 2022 Chen Tao
4 * Based on ugc from BCC by Sasha Goldshtein
5 * Create: Wed Jun 29 16:00:19 2022
6 */
7 #include <stdio.h>
8 #include <ctype.h>
9 #include <argp.h>
10 #include <signal.h>
11 #include <unistd.h>
12 #include <time.h>
13 #include <sys/resource.h>
14 #include <bpf/libbpf.h>
15 #include <errno.h>
16 #include "javagc.skel.h"
17 #include "javagc.h"
18
19 #define BINARY_PATH_SIZE (256)
20 #define PERF_BUFFER_PAGES (32)
21 #define PERF_POLL_TIMEOUT_MS (200)
22
23 static struct env {
24 pid_t pid;
25 int time;
26 bool exiting;
27 bool verbose;
28 } env = {
29 .pid = -1,
30 .time = 1000,
31 .exiting = false,
32 .verbose = false,
33 };
34
35 const char *argp_program_version = "javagc 0.1";
36 const char *argp_program_bug_address =
37 "https://github.com/iovisor/bcc/tree/master/libbpf-tools";
38
39 const char argp_program_doc[] =
40 "Monitor javagc time cost.\n"
41 "\n"
42 "USAGE: javagc [--help] [-p PID] [-t GC time]\n"
43 "\n"
44 "EXAMPLES:\n"
45 "javagc -p 185 # trace PID 185 only\n"
46 "javagc -p 185 -t 100 # trace PID 185 java gc time beyond 100us\n";
47
48 static const struct argp_option opts[] = {
49 { "pid", 'p', "PID", 0, "Trace this PID only" },
50 { "time", 't', "TIME", 0, "Java gc time" },
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 int err = 0;
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 err = errno;
72 fprintf(stderr, "invalid PID: %s\n", arg);
73 argp_usage(state);
74 }
75 break;
76 case 't':
77 errno = 0;
78 env.time = strtol(arg, NULL, 10);
79 if (errno) {
80 err = errno;
81 fprintf(stderr, "invalid time: %s\n", arg);
82 argp_usage(state);
83 }
84 break;
85 default:
86 return ARGP_ERR_UNKNOWN;
87 }
88 return err;
89 }
90
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)91 static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
92 {
93 if (level == LIBBPF_DEBUG && ! env.verbose)
94 return 0;
95
96 return vfprintf(stderr, format, args);
97 }
98
handle_event(void * ctx,int cpu,void * data,__u32 data_sz)99 static void handle_event(void *ctx, int cpu, void *data, __u32 data_sz)
100 {
101 struct data_t *e = (struct data_t *)data;
102 struct tm *tm = NULL;
103 char ts[16];
104 time_t t;
105
106 time(&t);
107 tm = localtime(&t);
108 strftime(ts, sizeof(ts), "%H:%M:%S", tm);
109 printf("%-8s %-7d %-7d %-7lld\n", ts, e->cpu, e->pid, e->ts/1000);
110 }
111
handle_lost_events(void * ctx,int cpu,__u64 data_sz)112 static void handle_lost_events(void *ctx, int cpu, __u64 data_sz)
113 {
114 printf("lost data\n");
115 }
116
sig_handler(int sig)117 static void sig_handler(int sig)
118 {
119 env.exiting = true;
120 }
121
get_jvmso_path(char * path)122 static int get_jvmso_path(char *path)
123 {
124 char mode[16], line[128], buf[64];
125 size_t seg_start, seg_end, seg_off;
126 FILE *f;
127 int i = 0;
128
129 sprintf(buf, "/proc/%d/maps", env.pid);
130 f = fopen(buf, "r");
131 if (!f)
132 return -1;
133
134 while (fscanf(f, "%zx-%zx %s %zx %*s %*d%[^\n]\n",
135 &seg_start, &seg_end, mode, &seg_off, line) == 5) {
136 i = 0;
137 while (isblank(line[i]))
138 i++;
139 if (strstr(line + i, "libjvm.so")) {
140 break;
141 }
142 }
143
144 strcpy(path, line + i);
145 fclose(f);
146
147 return 0;
148 }
149
main(int argc,char ** argv)150 int main(int argc, char **argv)
151 {
152 static const struct argp argp = {
153 .options = opts,
154 .parser = parse_arg,
155 .doc = argp_program_doc,
156 };
157 char binary_path[BINARY_PATH_SIZE] = {0};
158 struct javagc_bpf *skel = NULL;
159 int err;
160 struct perf_buffer *pb = NULL;
161
162 err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
163 if (err)
164 return err;
165
166 /*
167 * libbpf will auto load the so if it in /usr/lib64 /usr/lib etc,
168 * but the jvmso not there.
169 */
170 err = get_jvmso_path(binary_path);
171 if (err)
172 return err;
173
174 libbpf_set_print(libbpf_print_fn);
175
176 skel = javagc_bpf__open();
177 if (!skel) {
178 fprintf(stderr, "Failed to open BPF skeleton\n");
179 return 1;
180 }
181 skel->bss->time = env.time * 1000;
182
183 err = javagc_bpf__load(skel);
184 if (err) {
185 fprintf(stderr, "Failed to load and verify BPF skeleton\n");
186 goto cleanup;
187 }
188
189 skel->links.handle_mem_pool_gc_start = bpf_program__attach_usdt(skel->progs.handle_gc_start, env.pid,
190 binary_path, "hotspot", "mem__pool__gc__begin", NULL);
191 if (!skel->links.handle_mem_pool_gc_start) {
192 err = errno;
193 fprintf(stderr, "attach usdt mem__pool__gc__begin failed: %s\n", strerror(err));
194 goto cleanup;
195 }
196
197 skel->links.handle_mem_pool_gc_end = bpf_program__attach_usdt(skel->progs.handle_gc_end, env.pid,
198 binary_path, "hotspot", "mem__pool__gc__end", NULL);
199 if (!skel->links.handle_mem_pool_gc_end) {
200 err = errno;
201 fprintf(stderr, "attach usdt mem__pool__gc__end failed: %s\n", strerror(err));
202 goto cleanup;
203 }
204
205 skel->links.handle_gc_start = bpf_program__attach_usdt(skel->progs.handle_gc_start, env.pid,
206 binary_path, "hotspot", "gc__begin", NULL);
207 if (!skel->links.handle_gc_start) {
208 err = errno;
209 fprintf(stderr, "attach usdt gc__begin failed: %s\n", strerror(err));
210 goto cleanup;
211 }
212
213 skel->links.handle_gc_end = bpf_program__attach_usdt(skel->progs.handle_gc_end, env.pid,
214 binary_path, "hotspot", "gc__end", NULL);
215 if (!skel->links.handle_gc_end) {
216 err = errno;
217 fprintf(stderr, "attach usdt gc__end failed: %s\n", strerror(err));
218 goto cleanup;
219 }
220
221 signal(SIGINT, sig_handler);
222 printf("Tracing javagc time... Hit Ctrl-C to end.\n");
223 printf("%-8s %-7s %-7s %-7s\n",
224 "TIME", "CPU", "PID", "GC TIME");
225
226 pb = perf_buffer__new(bpf_map__fd(skel->maps.perf_map), PERF_BUFFER_PAGES,
227 handle_event, handle_lost_events, NULL, NULL);
228 while (!env.exiting) {
229 err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS);
230 if (err < 0 && err != -EINTR) {
231 fprintf(stderr, "error polling perf buffer: %s\n", strerror(-err));
232 goto cleanup;
233 }
234 /* reset err to return 0 if exiting */
235 err = 0;
236 }
237
238 cleanup:
239 perf_buffer__free(pb);
240 javagc_bpf__destroy(skel);
241
242 return err != 0;
243 }
244