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 47 static void int_exit(int signo) 48 { 49 fprintf(stderr, "Stopping...\n"); 50 stop = true; 51 } 52 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 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 119 static int perf_mmap_size(void) 120 { 121 return get_page_size() * (MMAP_PAGE_CNT + 1); 122 } 123 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 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 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 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