1 // SPDX-License-Identifier: GPL-2.0 2 #include <errno.h> 3 #include <unistd.h> 4 #include <sys/syscall.h> 5 #include <perf/evsel.h> 6 #include <perf/cpumap.h> 7 #include <perf/threadmap.h> 8 #include <linux/list.h> 9 #include <internal/evsel.h> 10 #include <linux/zalloc.h> 11 #include <stdlib.h> 12 #include <internal/xyarray.h> 13 #include <internal/cpumap.h> 14 #include <internal/mmap.h> 15 #include <internal/threadmap.h> 16 #include <internal/lib.h> 17 #include <linux/string.h> 18 #include <sys/ioctl.h> 19 #include <sys/mman.h> 20 #include <asm/bug.h> 21 22 void perf_evsel__init(struct perf_evsel *evsel, struct perf_event_attr *attr, 23 int idx) 24 { 25 INIT_LIST_HEAD(&evsel->node); 26 evsel->attr = *attr; 27 evsel->idx = idx; 28 evsel->leader = evsel; 29 } 30 31 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr) 32 { 33 struct perf_evsel *evsel = zalloc(sizeof(*evsel)); 34 35 if (evsel != NULL) 36 perf_evsel__init(evsel, attr, 0); 37 38 return evsel; 39 } 40 41 void perf_evsel__delete(struct perf_evsel *evsel) 42 { 43 free(evsel); 44 } 45 46 #define FD(_evsel, _cpu_map_idx, _thread) \ 47 ((int *)xyarray__entry(_evsel->fd, _cpu_map_idx, _thread)) 48 #define MMAP(_evsel, _cpu_map_idx, _thread) \ 49 (_evsel->mmap ? ((struct perf_mmap *) xyarray__entry(_evsel->mmap, _cpu_map_idx, _thread)) \ 50 : NULL) 51 52 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads) 53 { 54 evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int)); 55 56 if (evsel->fd) { 57 int idx, thread; 58 59 for (idx = 0; idx < ncpus; idx++) { 60 for (thread = 0; thread < nthreads; thread++) { 61 int *fd = FD(evsel, idx, thread); 62 63 if (fd) 64 *fd = -1; 65 } 66 } 67 } 68 69 return evsel->fd != NULL ? 0 : -ENOMEM; 70 } 71 72 static int perf_evsel__alloc_mmap(struct perf_evsel *evsel, int ncpus, int nthreads) 73 { 74 evsel->mmap = xyarray__new(ncpus, nthreads, sizeof(struct perf_mmap)); 75 76 return evsel->mmap != NULL ? 0 : -ENOMEM; 77 } 78 79 static int 80 sys_perf_event_open(struct perf_event_attr *attr, 81 pid_t pid, int cpu, int group_fd, 82 unsigned long flags) 83 { 84 return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags); 85 } 86 87 static int get_group_fd(struct perf_evsel *evsel, int cpu_map_idx, int thread, int *group_fd) 88 { 89 struct perf_evsel *leader = evsel->leader; 90 int *fd; 91 92 if (evsel == leader) { 93 *group_fd = -1; 94 return 0; 95 } 96 97 /* 98 * Leader must be already processed/open, 99 * if not it's a bug. 100 */ 101 if (!leader->fd) 102 return -ENOTCONN; 103 104 fd = FD(leader, cpu_map_idx, thread); 105 if (fd == NULL || *fd == -1) 106 return -EBADF; 107 108 *group_fd = *fd; 109 110 return 0; 111 } 112 113 int perf_evsel__open(struct perf_evsel *evsel, struct perf_cpu_map *cpus, 114 struct perf_thread_map *threads) 115 { 116 int cpu, idx, thread, err = 0; 117 118 if (cpus == NULL) { 119 static struct perf_cpu_map *empty_cpu_map; 120 121 if (empty_cpu_map == NULL) { 122 empty_cpu_map = perf_cpu_map__dummy_new(); 123 if (empty_cpu_map == NULL) 124 return -ENOMEM; 125 } 126 127 cpus = empty_cpu_map; 128 } 129 130 if (threads == NULL) { 131 static struct perf_thread_map *empty_thread_map; 132 133 if (empty_thread_map == NULL) { 134 empty_thread_map = perf_thread_map__new_dummy(); 135 if (empty_thread_map == NULL) 136 return -ENOMEM; 137 } 138 139 threads = empty_thread_map; 140 } 141 142 if (evsel->fd == NULL && 143 perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0) 144 return -ENOMEM; 145 146 perf_cpu_map__for_each_cpu(cpu, idx, cpus) { 147 for (thread = 0; thread < threads->nr; thread++) { 148 int fd, group_fd, *evsel_fd; 149 150 evsel_fd = FD(evsel, idx, thread); 151 if (evsel_fd == NULL) 152 return -EINVAL; 153 154 err = get_group_fd(evsel, idx, thread, &group_fd); 155 if (err < 0) 156 return err; 157 158 fd = sys_perf_event_open(&evsel->attr, 159 threads->map[thread].pid, 160 cpu, group_fd, 0); 161 162 if (fd < 0) 163 return -errno; 164 165 *evsel_fd = fd; 166 } 167 } 168 169 return err; 170 } 171 172 static void perf_evsel__close_fd_cpu(struct perf_evsel *evsel, int cpu_map_idx) 173 { 174 int thread; 175 176 for (thread = 0; thread < xyarray__max_y(evsel->fd); ++thread) { 177 int *fd = FD(evsel, cpu_map_idx, thread); 178 179 if (fd && *fd >= 0) { 180 close(*fd); 181 *fd = -1; 182 } 183 } 184 } 185 186 void perf_evsel__close_fd(struct perf_evsel *evsel) 187 { 188 for (int idx = 0; idx < xyarray__max_x(evsel->fd); idx++) 189 perf_evsel__close_fd_cpu(evsel, idx); 190 } 191 192 void perf_evsel__free_fd(struct perf_evsel *evsel) 193 { 194 xyarray__delete(evsel->fd); 195 evsel->fd = NULL; 196 } 197 198 void perf_evsel__close(struct perf_evsel *evsel) 199 { 200 if (evsel->fd == NULL) 201 return; 202 203 perf_evsel__close_fd(evsel); 204 perf_evsel__free_fd(evsel); 205 } 206 207 void perf_evsel__close_cpu(struct perf_evsel *evsel, int cpu_map_idx) 208 { 209 if (evsel->fd == NULL) 210 return; 211 212 perf_evsel__close_fd_cpu(evsel, cpu_map_idx); 213 } 214 215 void perf_evsel__munmap(struct perf_evsel *evsel) 216 { 217 int idx, thread; 218 219 if (evsel->fd == NULL || evsel->mmap == NULL) 220 return; 221 222 for (idx = 0; idx < xyarray__max_x(evsel->fd); idx++) { 223 for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) { 224 int *fd = FD(evsel, idx, thread); 225 226 if (fd == NULL || *fd < 0) 227 continue; 228 229 perf_mmap__munmap(MMAP(evsel, idx, thread)); 230 } 231 } 232 233 xyarray__delete(evsel->mmap); 234 evsel->mmap = NULL; 235 } 236 237 int perf_evsel__mmap(struct perf_evsel *evsel, int pages) 238 { 239 int ret, idx, thread; 240 struct perf_mmap_param mp = { 241 .prot = PROT_READ | PROT_WRITE, 242 .mask = (pages * page_size) - 1, 243 }; 244 245 if (evsel->fd == NULL || evsel->mmap) 246 return -EINVAL; 247 248 if (perf_evsel__alloc_mmap(evsel, xyarray__max_x(evsel->fd), xyarray__max_y(evsel->fd)) < 0) 249 return -ENOMEM; 250 251 for (idx = 0; idx < xyarray__max_x(evsel->fd); idx++) { 252 for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) { 253 int *fd = FD(evsel, idx, thread); 254 struct perf_mmap *map; 255 int cpu = perf_cpu_map__cpu(evsel->cpus, idx); 256 257 if (fd == NULL || *fd < 0) 258 continue; 259 260 map = MMAP(evsel, idx, thread); 261 perf_mmap__init(map, NULL, false, NULL); 262 263 ret = perf_mmap__mmap(map, &mp, *fd, cpu); 264 if (ret) { 265 perf_evsel__munmap(evsel); 266 return ret; 267 } 268 } 269 } 270 271 return 0; 272 } 273 274 void *perf_evsel__mmap_base(struct perf_evsel *evsel, int cpu_map_idx, int thread) 275 { 276 int *fd = FD(evsel, cpu_map_idx, thread); 277 278 if (fd == NULL || *fd < 0 || MMAP(evsel, cpu_map_idx, thread) == NULL) 279 return NULL; 280 281 return MMAP(evsel, cpu_map_idx, thread)->base; 282 } 283 284 int perf_evsel__read_size(struct perf_evsel *evsel) 285 { 286 u64 read_format = evsel->attr.read_format; 287 int entry = sizeof(u64); /* value */ 288 int size = 0; 289 int nr = 1; 290 291 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 292 size += sizeof(u64); 293 294 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 295 size += sizeof(u64); 296 297 if (read_format & PERF_FORMAT_ID) 298 entry += sizeof(u64); 299 300 if (read_format & PERF_FORMAT_GROUP) { 301 nr = evsel->nr_members; 302 size += sizeof(u64); 303 } 304 305 size += entry * nr; 306 return size; 307 } 308 309 int perf_evsel__read(struct perf_evsel *evsel, int cpu_map_idx, int thread, 310 struct perf_counts_values *count) 311 { 312 size_t size = perf_evsel__read_size(evsel); 313 int *fd = FD(evsel, cpu_map_idx, thread); 314 315 memset(count, 0, sizeof(*count)); 316 317 if (fd == NULL || *fd < 0) 318 return -EINVAL; 319 320 if (MMAP(evsel, cpu_map_idx, thread) && 321 !perf_mmap__read_self(MMAP(evsel, cpu_map_idx, thread), count)) 322 return 0; 323 324 if (readn(*fd, count->values, size) <= 0) 325 return -errno; 326 327 return 0; 328 } 329 330 static int perf_evsel__run_ioctl(struct perf_evsel *evsel, 331 int ioc, void *arg, 332 int cpu_map_idx) 333 { 334 int thread; 335 336 for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) { 337 int err; 338 int *fd = FD(evsel, cpu_map_idx, thread); 339 340 if (fd == NULL || *fd < 0) 341 return -1; 342 343 err = ioctl(*fd, ioc, arg); 344 345 if (err) 346 return err; 347 } 348 349 return 0; 350 } 351 352 int perf_evsel__enable_cpu(struct perf_evsel *evsel, int cpu_map_idx) 353 { 354 return perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_ENABLE, NULL, cpu_map_idx); 355 } 356 357 int perf_evsel__enable(struct perf_evsel *evsel) 358 { 359 int i; 360 int err = 0; 361 362 for (i = 0; i < xyarray__max_x(evsel->fd) && !err; i++) 363 err = perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_ENABLE, NULL, i); 364 return err; 365 } 366 367 int perf_evsel__disable_cpu(struct perf_evsel *evsel, int cpu_map_idx) 368 { 369 return perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_DISABLE, NULL, cpu_map_idx); 370 } 371 372 int perf_evsel__disable(struct perf_evsel *evsel) 373 { 374 int i; 375 int err = 0; 376 377 for (i = 0; i < xyarray__max_x(evsel->fd) && !err; i++) 378 err = perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_DISABLE, NULL, i); 379 return err; 380 } 381 382 int perf_evsel__apply_filter(struct perf_evsel *evsel, const char *filter) 383 { 384 int err = 0, i; 385 386 for (i = 0; i < evsel->cpus->nr && !err; i++) 387 err = perf_evsel__run_ioctl(evsel, 388 PERF_EVENT_IOC_SET_FILTER, 389 (void *)filter, i); 390 return err; 391 } 392 393 struct perf_cpu_map *perf_evsel__cpus(struct perf_evsel *evsel) 394 { 395 return evsel->cpus; 396 } 397 398 struct perf_thread_map *perf_evsel__threads(struct perf_evsel *evsel) 399 { 400 return evsel->threads; 401 } 402 403 struct perf_event_attr *perf_evsel__attr(struct perf_evsel *evsel) 404 { 405 return &evsel->attr; 406 } 407 408 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads) 409 { 410 if (ncpus == 0 || nthreads == 0) 411 return 0; 412 413 if (evsel->system_wide) 414 nthreads = 1; 415 416 evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id)); 417 if (evsel->sample_id == NULL) 418 return -ENOMEM; 419 420 evsel->id = zalloc(ncpus * nthreads * sizeof(u64)); 421 if (evsel->id == NULL) { 422 xyarray__delete(evsel->sample_id); 423 evsel->sample_id = NULL; 424 return -ENOMEM; 425 } 426 427 return 0; 428 } 429 430 void perf_evsel__free_id(struct perf_evsel *evsel) 431 { 432 xyarray__delete(evsel->sample_id); 433 evsel->sample_id = NULL; 434 zfree(&evsel->id); 435 evsel->ids = 0; 436 } 437 438 void perf_counts_values__scale(struct perf_counts_values *count, 439 bool scale, __s8 *pscaled) 440 { 441 s8 scaled = 0; 442 443 if (scale) { 444 if (count->run == 0) { 445 scaled = -1; 446 count->val = 0; 447 } else if (count->run < count->ena) { 448 scaled = 1; 449 count->val = (u64)((double)count->val * count->ena / count->run); 450 } 451 } 452 453 if (pscaled) 454 *pscaled = scaled; 455 } 456