1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2018 Netronome Systems, Inc. */
3 /* This program is free software; you can redistribute it and/or
4 * modify it under the terms of version 2 of the GNU General Public
5 * License as published by the Free Software Foundation.
6 */
7 #include <errno.h>
8 #include <fcntl.h>
9 #include <libbpf.h>
10 #include <poll.h>
11 #include <signal.h>
12 #include <stdbool.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <time.h>
17 #include <unistd.h>
18 #include <linux/bpf.h>
19 #include <linux/perf_event.h>
20 #include <sys/ioctl.h>
21 #include <sys/mman.h>
22 #include <sys/syscall.h>
23
24 #include <bpf.h>
25 #include <perf-sys.h>
26
27 #include "main.h"
28
29 #define MMAP_PAGE_CNT 16
30
31 static bool stop;
32
33 struct event_ring_info {
34 int fd;
35 int key;
36 unsigned int cpu;
37 void *mem;
38 };
39
40 struct perf_event_sample {
41 struct perf_event_header header;
42 u64 time;
43 __u32 size;
44 unsigned char data[];
45 };
46
int_exit(int signo)47 static void int_exit(int signo)
48 {
49 fprintf(stderr, "Stopping...\n");
50 stop = true;
51 }
52
print_bpf_output(void * event,void * priv)53 static enum bpf_perf_event_ret print_bpf_output(void *event, void *priv)
54 {
55 struct event_ring_info *ring = priv;
56 struct perf_event_sample *e = event;
57 struct {
58 struct perf_event_header header;
59 __u64 id;
60 __u64 lost;
61 } *lost = event;
62
63 if (json_output) {
64 jsonw_start_object(json_wtr);
65 jsonw_name(json_wtr, "type");
66 jsonw_uint(json_wtr, e->header.type);
67 jsonw_name(json_wtr, "cpu");
68 jsonw_uint(json_wtr, ring->cpu);
69 jsonw_name(json_wtr, "index");
70 jsonw_uint(json_wtr, ring->key);
71 if (e->header.type == PERF_RECORD_SAMPLE) {
72 jsonw_name(json_wtr, "timestamp");
73 jsonw_uint(json_wtr, e->time);
74 jsonw_name(json_wtr, "data");
75 print_data_json(e->data, e->size);
76 } else if (e->header.type == PERF_RECORD_LOST) {
77 jsonw_name(json_wtr, "lost");
78 jsonw_start_object(json_wtr);
79 jsonw_name(json_wtr, "id");
80 jsonw_uint(json_wtr, lost->id);
81 jsonw_name(json_wtr, "count");
82 jsonw_uint(json_wtr, lost->lost);
83 jsonw_end_object(json_wtr);
84 }
85 jsonw_end_object(json_wtr);
86 } else {
87 if (e->header.type == PERF_RECORD_SAMPLE) {
88 printf("== @%lld.%09lld CPU: %d index: %d =====\n",
89 e->time / 1000000000ULL, e->time % 1000000000ULL,
90 ring->cpu, ring->key);
91 fprint_hex(stdout, e->data, e->size, " ");
92 printf("\n");
93 } else if (e->header.type == PERF_RECORD_LOST) {
94 printf("lost %lld events\n", lost->lost);
95 } else {
96 printf("unknown event type=%d size=%d\n",
97 e->header.type, e->header.size);
98 }
99 }
100
101 return LIBBPF_PERF_EVENT_CONT;
102 }
103
104 static void
perf_event_read(struct event_ring_info * ring,void ** buf,size_t * buf_len)105 perf_event_read(struct event_ring_info *ring, void **buf, size_t *buf_len)
106 {
107 enum bpf_perf_event_ret ret;
108
109 ret = bpf_perf_event_read_simple(ring->mem,
110 MMAP_PAGE_CNT * get_page_size(),
111 get_page_size(), buf, buf_len,
112 print_bpf_output, ring);
113 if (ret != LIBBPF_PERF_EVENT_CONT) {
114 fprintf(stderr, "perf read loop failed with %d\n", ret);
115 stop = true;
116 }
117 }
118
perf_mmap_size(void)119 static int perf_mmap_size(void)
120 {
121 return get_page_size() * (MMAP_PAGE_CNT + 1);
122 }
123
perf_event_mmap(int fd)124 static void *perf_event_mmap(int fd)
125 {
126 int mmap_size = perf_mmap_size();
127 void *base;
128
129 base = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
130 if (base == MAP_FAILED) {
131 p_err("event mmap failed: %s\n", strerror(errno));
132 return NULL;
133 }
134
135 return base;
136 }
137
perf_event_unmap(void * mem)138 static void perf_event_unmap(void *mem)
139 {
140 if (munmap(mem, perf_mmap_size()))
141 fprintf(stderr, "Can't unmap ring memory!\n");
142 }
143
bpf_perf_event_open(int map_fd,int key,int cpu)144 static int bpf_perf_event_open(int map_fd, int key, int cpu)
145 {
146 struct perf_event_attr attr = {
147 .sample_type = PERF_SAMPLE_RAW | PERF_SAMPLE_TIME,
148 .type = PERF_TYPE_SOFTWARE,
149 .config = PERF_COUNT_SW_BPF_OUTPUT,
150 };
151 int pmu_fd;
152
153 pmu_fd = sys_perf_event_open(&attr, -1, cpu, -1, 0);
154 if (pmu_fd < 0) {
155 p_err("failed to open perf event %d for CPU %d", key, cpu);
156 return -1;
157 }
158
159 if (bpf_map_update_elem(map_fd, &key, &pmu_fd, BPF_ANY)) {
160 p_err("failed to update map for event %d for CPU %d", key, cpu);
161 goto err_close;
162 }
163 if (ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0)) {
164 p_err("failed to enable event %d for CPU %d", key, cpu);
165 goto err_close;
166 }
167
168 return pmu_fd;
169
170 err_close:
171 close(pmu_fd);
172 return -1;
173 }
174
do_event_pipe(int argc,char ** argv)175 int do_event_pipe(int argc, char **argv)
176 {
177 int i, nfds, map_fd, index = -1, cpu = -1;
178 struct bpf_map_info map_info = {};
179 struct event_ring_info *rings;
180 size_t tmp_buf_sz = 0;
181 void *tmp_buf = NULL;
182 struct pollfd *pfds;
183 __u32 map_info_len;
184 bool do_all = true;
185
186 map_info_len = sizeof(map_info);
187 map_fd = map_parse_fd_and_info(&argc, &argv, &map_info, &map_info_len);
188 if (map_fd < 0)
189 return -1;
190
191 if (map_info.type != BPF_MAP_TYPE_PERF_EVENT_ARRAY) {
192 p_err("map is not a perf event array");
193 goto err_close_map;
194 }
195
196 while (argc) {
197 if (argc < 2) {
198 BAD_ARG();
199 goto err_close_map;
200 }
201
202 if (is_prefix(*argv, "cpu")) {
203 char *endptr;
204
205 NEXT_ARG();
206 cpu = strtoul(*argv, &endptr, 0);
207 if (*endptr) {
208 p_err("can't parse %s as CPU ID", **argv);
209 goto err_close_map;
210 }
211
212 NEXT_ARG();
213 } else if (is_prefix(*argv, "index")) {
214 char *endptr;
215
216 NEXT_ARG();
217 index = strtoul(*argv, &endptr, 0);
218 if (*endptr) {
219 p_err("can't parse %s as index", **argv);
220 goto err_close_map;
221 }
222
223 NEXT_ARG();
224 } else {
225 BAD_ARG();
226 goto err_close_map;
227 }
228
229 do_all = false;
230 }
231
232 if (!do_all) {
233 if (index == -1 || cpu == -1) {
234 p_err("cpu and index must be specified together");
235 goto err_close_map;
236 }
237
238 nfds = 1;
239 } else {
240 nfds = min(get_possible_cpus(), map_info.max_entries);
241 cpu = 0;
242 index = 0;
243 }
244
245 rings = calloc(nfds, sizeof(rings[0]));
246 if (!rings)
247 goto err_close_map;
248
249 pfds = calloc(nfds, sizeof(pfds[0]));
250 if (!pfds)
251 goto err_free_rings;
252
253 for (i = 0; i < nfds; i++) {
254 rings[i].cpu = cpu + i;
255 rings[i].key = index + i;
256
257 rings[i].fd = bpf_perf_event_open(map_fd, rings[i].key,
258 rings[i].cpu);
259 if (rings[i].fd < 0)
260 goto err_close_fds_prev;
261
262 rings[i].mem = perf_event_mmap(rings[i].fd);
263 if (!rings[i].mem)
264 goto err_close_fds_current;
265
266 pfds[i].fd = rings[i].fd;
267 pfds[i].events = POLLIN;
268 }
269
270 signal(SIGINT, int_exit);
271 signal(SIGHUP, int_exit);
272 signal(SIGTERM, int_exit);
273
274 if (json_output)
275 jsonw_start_array(json_wtr);
276
277 while (!stop) {
278 poll(pfds, nfds, 200);
279 for (i = 0; i < nfds; i++)
280 perf_event_read(&rings[i], &tmp_buf, &tmp_buf_sz);
281 }
282 free(tmp_buf);
283
284 if (json_output)
285 jsonw_end_array(json_wtr);
286
287 for (i = 0; i < nfds; i++) {
288 perf_event_unmap(rings[i].mem);
289 close(rings[i].fd);
290 }
291 free(pfds);
292 free(rings);
293 close(map_fd);
294
295 return 0;
296
297 err_close_fds_prev:
298 while (i--) {
299 perf_event_unmap(rings[i].mem);
300 err_close_fds_current:
301 close(rings[i].fd);
302 }
303 free(pfds);
304 err_free_rings:
305 free(rings);
306 err_close_map:
307 close(map_fd);
308 return -1;
309 }
310
