bpf, libbpf: simplify and cleanup perf ring buffer walk

Simplify bpf_perf_event_read_simple() a bit and fix up some minor
things along the way: the return code in the header is not of type
int but enum bpf_perf_event_ret instead. Once callback indicated
to break the loop walking event data, it also needs to be consumed
in data_tail since it has been processed already.

Moreover, bpf_perf_event_print_t callback should avoid void * as
we actually get a pointer to struct perf_event_header and thus
applications can make use of container_of() to have type checks.
The walk also doesn't have to use modulo op since the ring size is
required to be power of two.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

2 files changed, 37 insertions, 45 deletions

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 0c21355f04a7..b607be7236d3 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -2415,56 +2415,47 @@ int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
 }
 
 enum bpf_perf_event_ret
-bpf_perf_event_read_simple(void *mem, unsigned long size,
-                           unsigned long page_size, void **buf, size_t *buf_len,
-                           bpf_perf_event_print_t fn, void *priv)
+bpf_perf_event_read_simple(void *mmap_mem, size_t mmap_size, size_t page_size,
+                           void **copy_mem, size_t *copy_size,
+                           bpf_perf_event_print_t fn, void *private_data)
 {
-        struct perf_event_mmap_page *header = mem;
+        struct perf_event_mmap_page *header = mmap_mem;
         __u64 data_head = ring_buffer_read_head(header);
         __u64 data_tail = header->data_tail;
-        int ret = LIBBPF_PERF_EVENT_ERROR;
-        void *base, *begin, *end;
-
-        if (data_head == data_tail)
-                return LIBBPF_PERF_EVENT_CONT;
-
-        base = ((char *)header) + page_size;
-
-        begin = base + data_tail % size;
-        end = base + data_head % size;
-
-        while (begin != end) {
-                struct perf_event_header *ehdr;
-
-                ehdr = begin;
-                if (begin + ehdr->size > base + size) {
-                        long len = base + size - begin;
-
-                        if (*buf_len < ehdr->size) {
-                                free(*buf);
-                                *buf = malloc(ehdr->size);
-                                if (!*buf) {
+        void *base = ((__u8 *)header) + page_size;
+        int ret = LIBBPF_PERF_EVENT_CONT;
+        struct perf_event_header *ehdr;
+        size_t ehdr_size;
+
+        while (data_head != data_tail) {
+                ehdr = base + (data_tail & (mmap_size - 1));
+                ehdr_size = ehdr->size;
+
+                if (((void *)ehdr) + ehdr_size > base + mmap_size) {
+                        void *copy_start = ehdr;
+                        size_t len_first = base + mmap_size - copy_start;
+                        size_t len_secnd = ehdr_size - len_first;
+
+                        if (*copy_size < ehdr_size) {
+                                free(*copy_mem);
+                                *copy_mem = malloc(ehdr_size);
+                                if (!*copy_mem) {
+                                        *copy_size = 0;
                                         ret = LIBBPF_PERF_EVENT_ERROR;
                                         break;
                                 }
-                                *buf_len = ehdr->size;
+                                *copy_size = ehdr_size;
                         }
 
-                        memcpy(*buf, begin, len);
-                        memcpy(*buf + len, base, ehdr->size - len);
-                        ehdr = (void *)*buf;
-                        begin = base + ehdr->size - len;
-                } else if (begin + ehdr->size == base + size) {
-                        begin = base;
-                } else {
-                        begin += ehdr->size;
+                        memcpy(*copy_mem, copy_start, len_first);
+                        memcpy(*copy_mem + len_first, base, len_secnd);
+                        ehdr = *copy_mem;
                 }
 
-                ret = fn(ehdr, priv);
+                ret = fn(ehdr, private_data);
+                data_tail += ehdr_size;
                 if (ret != LIBBPF_PERF_EVENT_CONT)
                         break;
-
-                data_tail += ehdr->size;
         }
 
         ring_buffer_write_tail(header, data_tail);
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index 1354cc9f8cba..1f3468dad8b2 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -297,13 +297,14 @@ enum bpf_perf_event_ret {
         LIBBPF_PERF_EVENT_CONT  = -2,
 };
 
-typedef enum bpf_perf_event_ret (*bpf_perf_event_print_t)(void *event,
-                                                          void *priv);
-LIBBPF_API int bpf_perf_event_read_simple(void *mem, unsigned long size,
-                                          unsigned long page_size,
-                                          void **buf, size_t *buf_len,
-                                          bpf_perf_event_print_t fn,
-                                          void *priv);
+struct perf_event_header;
+typedef enum bpf_perf_event_ret
+        (*bpf_perf_event_print_t)(struct perf_event_header *hdr,
+                                  void *private_data);
+LIBBPF_API enum bpf_perf_event_ret
+bpf_perf_event_read_simple(void *mmap_mem, size_t mmap_size, size_t page_size,
+                           void **copy_mem, size_t *copy_size,
+                           bpf_perf_event_print_t fn, void *private_data);
 
 struct nlattr;
 typedef int (*libbpf_dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb);