lib/perf/mmap.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <sys/mman.h>
0003 #include <inttypes.h>
0004 #include <asm/bug.h>
0005 #include <errno.h>
0006 #include <string.h>
0007 #include <linux/ring_buffer.h>
0008 #include <linux/perf_event.h>
0009 #include <perf/mmap.h>
0010 #include <perf/event.h>
0011 #include <perf/evsel.h>
0012 #include <internal/mmap.h>
0013 #include <internal/lib.h>
0014 #include <linux/kernel.h>
0015 #include <linux/math64.h>
0016 #include <linux/stringify.h>
0017 #include "internal.h"
0018
0019 void perf_mmap__init(struct perf_mmap *map, struct perf_mmap *prev,
0020              bool overwrite, libperf_unmap_cb_t unmap_cb)
0021 {
0022     map->fd = -1;
0023     map->overwrite = overwrite;
0024     map->unmap_cb  = unmap_cb;
0025     refcount_set(&map->refcnt, 0);
0026     if (prev)
0027         prev->next = map;
0028 }
0029
0030 size_t perf_mmap__mmap_len(struct perf_mmap *map)
0031 {
0032     return map->mask + 1 + page_size;
0033 }
0034
0035 int perf_mmap__mmap(struct perf_mmap *map, struct perf_mmap_param *mp,
0036             int fd, struct perf_cpu cpu)
0037 {
0038     map->prev = 0;
0039     map->mask = mp->mask;
0040     map->base = mmap(NULL, perf_mmap__mmap_len(map), mp->prot,
0041              MAP_SHARED, fd, 0);
0042     if (map->base == MAP_FAILED) {
0043         map->base = NULL;
0044         return -1;
0045     }
0046
0047     map->fd  = fd;
0048     map->cpu = cpu;
0049     return 0;
0050 }
0051
0052 void perf_mmap__munmap(struct perf_mmap *map)
0053 {
0054     if (map && map->base != NULL) {
0055         munmap(map->base, perf_mmap__mmap_len(map));
0056         map->base = NULL;
0057         map->fd = -1;
0058         refcount_set(&map->refcnt, 0);
0059     }
0060     if (map && map->unmap_cb)
0061         map->unmap_cb(map);
0062 }
0063
0064 void perf_mmap__get(struct perf_mmap *map)
0065 {
0066     refcount_inc(&map->refcnt);
0067 }
0068
0069 void perf_mmap__put(struct perf_mmap *map)
0070 {
0071     BUG_ON(map->base && refcount_read(&map->refcnt) == 0);
0072
0073     if (refcount_dec_and_test(&map->refcnt))
0074         perf_mmap__munmap(map);
0075 }
0076
0077 static inline void perf_mmap__write_tail(struct perf_mmap *md, u64 tail)
0078 {
0079     ring_buffer_write_tail(md->base, tail);
0080 }
0081
0082 u64 perf_mmap__read_head(struct perf_mmap *map)
0083 {
0084     return ring_buffer_read_head(map->base);
0085 }
0086
0087 static bool perf_mmap__empty(struct perf_mmap *map)
0088 {
0089     struct perf_event_mmap_page *pc = map->base;
0090
0091     return perf_mmap__read_head(map) == map->prev && !pc->aux_size;
0092 }
0093
0094 void perf_mmap__consume(struct perf_mmap *map)
0095 {
0096     if (!map->overwrite) {
0097         u64 old = map->prev;
0098
0099         perf_mmap__write_tail(map, old);
0100     }
0101
0102     if (refcount_read(&map->refcnt) == 1 && perf_mmap__empty(map))
0103         perf_mmap__put(map);
0104 }
0105
0106 static int overwrite_rb_find_range(void *buf, int mask, u64 *start, u64 *end)
0107 {
0108     struct perf_event_header *pheader;
0109     u64 evt_head = *start;
0110     int size = mask + 1;
0111
0112     pr_debug2("%s: buf=%p, start=%"PRIx64"\n", __func__, buf, *start);
0113     pheader = (struct perf_event_header *)(buf + (*start & mask));
0114     while (true) {
0115         if (evt_head - *start >= (unsigned int)size) {
0116             pr_debug("Finished reading overwrite ring buffer: rewind\n");
0117             if (evt_head - *start > (unsigned int)size)
0118                 evt_head -= pheader->size;
0119             *end = evt_head;
0120             return 0;
0121         }
0122
0123         pheader = (struct perf_event_header *)(buf + (evt_head & mask));
0124
0125         if (pheader->size == 0) {
0126             pr_debug("Finished reading overwrite ring buffer: get start\n");
0127             *end = evt_head;
0128             return 0;
0129         }
0130
0131         evt_head += pheader->size;
0132         pr_debug3("move evt_head: %"PRIx64"\n", evt_head);
0133     }
0134     WARN_ONCE(1, "Shouldn't get here\n");
0135     return -1;
0136 }
0137
0138 /*
0139  * Report the start and end of the available data in ringbuffer
0140  */
0141 static int __perf_mmap__read_init(struct perf_mmap *md)
0142 {
0143     u64 head = perf_mmap__read_head(md);
0144     u64 old = md->prev;
0145     unsigned char *data = md->base + page_size;
0146     unsigned long size;
0147
0148     md->start = md->overwrite ? head : old;
0149     md->end = md->overwrite ? old : head;
0150
0151     if ((md->end - md->start) < md->flush)
0152         return -EAGAIN;
0153
0154     size = md->end - md->start;
0155     if (size > (unsigned long)(md->mask) + 1) {
0156         if (!md->overwrite) {
0157             WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n");
0158
0159             md->prev = head;
0160             perf_mmap__consume(md);
0161             return -EAGAIN;
0162         }
0163
0164         /*
0165          * Backward ring buffer is full. We still have a chance to read
0166          * most of data from it.
0167          */
0168         if (overwrite_rb_find_range(data, md->mask, &md->start, &md->end))
0169             return -EINVAL;
0170     }
0171
0172     return 0;
0173 }
0174
0175 int perf_mmap__read_init(struct perf_mmap *map)
0176 {
0177     /*
0178      * Check if event was unmapped due to a POLLHUP/POLLERR.
0179      */
0180     if (!refcount_read(&map->refcnt))
0181         return -ENOENT;
0182
0183     return __perf_mmap__read_init(map);
0184 }
0185
0186 /*
0187  * Mandatory for overwrite mode
0188  * The direction of overwrite mode is backward.
0189  * The last perf_mmap__read() will set tail to map->core.prev.
0190  * Need to correct the map->core.prev to head which is the end of next read.
0191  */
0192 void perf_mmap__read_done(struct perf_mmap *map)
0193 {
0194     /*
0195      * Check if event was unmapped due to a POLLHUP/POLLERR.
0196      */
0197     if (!refcount_read(&map->refcnt))
0198         return;
0199
0200     map->prev = perf_mmap__read_head(map);
0201 }
0202
0203 /* When check_messup is true, 'end' must points to a good entry */
0204 static union perf_event *perf_mmap__read(struct perf_mmap *map,
0205                      u64 *startp, u64 end)
0206 {
0207     unsigned char *data = map->base + page_size;
0208     union perf_event *event = NULL;
0209     int diff = end - *startp;
0210
0211     if (diff >= (int)sizeof(event->header)) {
0212         size_t size;
0213
0214         event = (union perf_event *)&data[*startp & map->mask];
0215         size = event->header.size;
0216
0217         if (size < sizeof(event->header) || diff < (int)size)
0218             return NULL;
0219
0220         /*
0221          * Event straddles the mmap boundary -- header should always
0222          * be inside due to u64 alignment of output.
0223          */
0224         if ((*startp & map->mask) + size != ((*startp + size) & map->mask)) {
0225             unsigned int offset = *startp;
0226             unsigned int len = min(sizeof(*event), size), cpy;
0227             void *dst = map->event_copy;
0228
0229             do {
0230                 cpy = min(map->mask + 1 - (offset & map->mask), len);
0231                 memcpy(dst, &data[offset & map->mask], cpy);
0232                 offset += cpy;
0233                 dst += cpy;
0234                 len -= cpy;
0235             } while (len);
0236
0237             event = (union perf_event *)map->event_copy;
0238         }
0239
0240         *startp += size;
0241     }
0242
0243     return event;
0244 }
0245
0246 /*
0247  * Read event from ring buffer one by one.
0248  * Return one event for each call.
0249  *
0250  * Usage:
0251  * perf_mmap__read_init()
0252  * while(event = perf_mmap__read_event()) {
0253  *  //process the event
0254  *  perf_mmap__consume()
0255  * }
0256  * perf_mmap__read_done()
0257  */
0258 union perf_event *perf_mmap__read_event(struct perf_mmap *map)
0259 {
0260     union perf_event *event;
0261
0262     /*
0263      * Check if event was unmapped due to a POLLHUP/POLLERR.
0264      */
0265     if (!refcount_read(&map->refcnt))
0266         return NULL;
0267
0268     /* non-overwirte doesn't pause the ringbuffer */
0269     if (!map->overwrite)
0270         map->end = perf_mmap__read_head(map);
0271
0272     event = perf_mmap__read(map, &map->start, map->end);
0273
0274     if (!map->overwrite)
0275         map->prev = map->start;
0276
0277     return event;
0278 }
0279
0280 #if defined(__i386__) || defined(__x86_64__)
0281 static u64 read_perf_counter(unsigned int counter)
0282 {
0283     unsigned int low, high;
0284
0285     asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
0286
0287     return low | ((u64)high) << 32;
0288 }
0289
0290 static u64 read_timestamp(void)
0291 {
0292     unsigned int low, high;
0293
0294     asm volatile("rdtsc" : "=a" (low), "=d" (high));
0295
0296     return low | ((u64)high) << 32;
0297 }
0298 #elif defined(__aarch64__)
0299 #define read_sysreg(r) ({                       \
0300     u64 __val;                          \
0301     asm volatile("mrs %0, " __stringify(r) : "=r" (__val));     \
0302     __val;                              \
0303 })
0304
0305 static u64 read_pmccntr(void)
0306 {
0307     return read_sysreg(pmccntr_el0);
0308 }
0309
0310 #define PMEVCNTR_READ(idx)                  \
0311     static u64 read_pmevcntr_##idx(void) {          \
0312         return read_sysreg(pmevcntr##idx##_el0);    \
0313     }
0314
0315 PMEVCNTR_READ(0);
0316 PMEVCNTR_READ(1);
0317 PMEVCNTR_READ(2);
0318 PMEVCNTR_READ(3);
0319 PMEVCNTR_READ(4);
0320 PMEVCNTR_READ(5);
0321 PMEVCNTR_READ(6);
0322 PMEVCNTR_READ(7);
0323 PMEVCNTR_READ(8);
0324 PMEVCNTR_READ(9);
0325 PMEVCNTR_READ(10);
0326 PMEVCNTR_READ(11);
0327 PMEVCNTR_READ(12);
0328 PMEVCNTR_READ(13);
0329 PMEVCNTR_READ(14);
0330 PMEVCNTR_READ(15);
0331 PMEVCNTR_READ(16);
0332 PMEVCNTR_READ(17);
0333 PMEVCNTR_READ(18);
0334 PMEVCNTR_READ(19);
0335 PMEVCNTR_READ(20);
0336 PMEVCNTR_READ(21);
0337 PMEVCNTR_READ(22);
0338 PMEVCNTR_READ(23);
0339 PMEVCNTR_READ(24);
0340 PMEVCNTR_READ(25);
0341 PMEVCNTR_READ(26);
0342 PMEVCNTR_READ(27);
0343 PMEVCNTR_READ(28);
0344 PMEVCNTR_READ(29);
0345 PMEVCNTR_READ(30);
0346
0347 /*
0348  * Read a value direct from PMEVCNTR<idx>
0349  */
0350 static u64 read_perf_counter(unsigned int counter)
0351 {
0352     static u64 (* const read_f[])(void) = {
0353         read_pmevcntr_0,
0354         read_pmevcntr_1,
0355         read_pmevcntr_2,
0356         read_pmevcntr_3,
0357         read_pmevcntr_4,
0358         read_pmevcntr_5,
0359         read_pmevcntr_6,
0360         read_pmevcntr_7,
0361         read_pmevcntr_8,
0362         read_pmevcntr_9,
0363         read_pmevcntr_10,
0364         read_pmevcntr_11,
0365         read_pmevcntr_13,
0366         read_pmevcntr_12,
0367         read_pmevcntr_14,
0368         read_pmevcntr_15,
0369         read_pmevcntr_16,
0370         read_pmevcntr_17,
0371         read_pmevcntr_18,
0372         read_pmevcntr_19,
0373         read_pmevcntr_20,
0374         read_pmevcntr_21,
0375         read_pmevcntr_22,
0376         read_pmevcntr_23,
0377         read_pmevcntr_24,
0378         read_pmevcntr_25,
0379         read_pmevcntr_26,
0380         read_pmevcntr_27,
0381         read_pmevcntr_28,
0382         read_pmevcntr_29,
0383         read_pmevcntr_30,
0384         read_pmccntr
0385     };
0386
0387     if (counter < ARRAY_SIZE(read_f))
0388         return (read_f[counter])();
0389
0390     return 0;
0391 }
0392
0393 static u64 read_timestamp(void) { return read_sysreg(cntvct_el0); }
0394
0395 #else
0396 static u64 read_perf_counter(unsigned int counter __maybe_unused) { return 0; }
0397 static u64 read_timestamp(void) { return 0; }
0398 #endif
0399
0400 int perf_mmap__read_self(struct perf_mmap *map, struct perf_counts_values *count)
0401 {
0402     struct perf_event_mmap_page *pc = map->base;
0403     u32 seq, idx, time_mult = 0, time_shift = 0;
0404     u64 cnt, cyc = 0, time_offset = 0, time_cycles = 0, time_mask = ~0ULL;
0405
0406     if (!pc || !pc->cap_user_rdpmc)
0407         return -1;
0408
0409     do {
0410         seq = READ_ONCE(pc->lock);
0411         barrier();
0412
0413         count->ena = READ_ONCE(pc->time_enabled);
0414         count->run = READ_ONCE(pc->time_running);
0415
0416         if (pc->cap_user_time && count->ena != count->run) {
0417             cyc = read_timestamp();
0418             time_mult = READ_ONCE(pc->time_mult);
0419             time_shift = READ_ONCE(pc->time_shift);
0420             time_offset = READ_ONCE(pc->time_offset);
0421
0422             if (pc->cap_user_time_short) {
0423                 time_cycles = READ_ONCE(pc->time_cycles);
0424                 time_mask = READ_ONCE(pc->time_mask);
0425             }
0426         }
0427
0428         idx = READ_ONCE(pc->index);
0429         cnt = READ_ONCE(pc->offset);
0430         if (pc->cap_user_rdpmc && idx) {
0431             s64 evcnt = read_perf_counter(idx - 1);
0432             u16 width = READ_ONCE(pc->pmc_width);
0433
0434             evcnt <<= 64 - width;
0435             evcnt >>= 64 - width;
0436             cnt += evcnt;
0437         } else
0438             return -1;
0439
0440         barrier();
0441     } while (READ_ONCE(pc->lock) != seq);
0442
0443     if (count->ena != count->run) {
0444         u64 delta;
0445
0446         /* Adjust for cap_usr_time_short, a nop if not */
0447         cyc = time_cycles + ((cyc - time_cycles) & time_mask);
0448
0449         delta = time_offset + mul_u64_u32_shr(cyc, time_mult, time_shift);
0450
0451         count->ena += delta;
0452         if (idx)
0453             count->run += delta;
0454     }
0455
0456     count->val = cnt;
0457
0458     return 0;
0459 }