1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) 2 /* 3 * Ring buffer operations. 4 * 5 * Copyright (C) 2020 Facebook, Inc. 6 */ 7 #ifndef _GNU_SOURCE 8 #define _GNU_SOURCE 9 #endif 10 #include <stdlib.h> 11 #include <stdio.h> 12 #include <errno.h> 13 #include <unistd.h> 14 #include <linux/err.h> 15 #include <linux/bpf.h> 16 #include <asm/barrier.h> 17 #include <sys/mman.h> 18 #include <sys/epoll.h> 19 20 #include "libbpf.h" 21 #include "libbpf_internal.h" 22 #include "bpf.h" 23 24 struct ring { 25 ring_buffer_sample_fn sample_cb; 26 void *ctx; 27 void *data; 28 unsigned long *consumer_pos; 29 unsigned long *producer_pos; 30 unsigned long mask; 31 int map_fd; 32 }; 33 34 struct ring_buffer { 35 struct epoll_event *events; 36 struct ring *rings; 37 size_t page_size; 38 int epoll_fd; 39 int ring_cnt; 40 }; 41 42 static void ringbuf_unmap_ring(struct ring_buffer *rb, struct ring *r) 43 { 44 if (r->consumer_pos) { 45 munmap(r->consumer_pos, rb->page_size); 46 r->consumer_pos = NULL; 47 } 48 if (r->producer_pos) { 49 munmap(r->producer_pos, rb->page_size + 2 * (r->mask + 1)); 50 r->producer_pos = NULL; 51 } 52 } 53 54 /* Add extra RINGBUF maps to this ring buffer manager */ 55 int ring_buffer__add(struct ring_buffer *rb, int map_fd, 56 ring_buffer_sample_fn sample_cb, void *ctx) 57 { 58 struct bpf_map_info info; 59 __u32 len = sizeof(info); 60 struct epoll_event *e; 61 struct ring *r; 62 void *tmp; 63 int err; 64 65 memset(&info, 0, sizeof(info)); 66 67 err = bpf_obj_get_info_by_fd(map_fd, &info, &len); 68 if (err) { 69 err = -errno; 70 pr_warn("ringbuf: failed to get map info for fd=%d: %d\n", 71 map_fd, err); 72 return libbpf_err(err); 73 } 74 75 if (info.type != BPF_MAP_TYPE_RINGBUF) { 76 pr_warn("ringbuf: map fd=%d is not BPF_MAP_TYPE_RINGBUF\n", 77 map_fd); 78 return libbpf_err(-EINVAL); 79 } 80 81 tmp = libbpf_reallocarray(rb->rings, rb->ring_cnt + 1, sizeof(*rb->rings)); 82 if (!tmp) 83 return libbpf_err(-ENOMEM); 84 rb->rings = tmp; 85 86 tmp = libbpf_reallocarray(rb->events, rb->ring_cnt + 1, sizeof(*rb->events)); 87 if (!tmp) 88 return libbpf_err(-ENOMEM); 89 rb->events = tmp; 90 91 r = &rb->rings[rb->ring_cnt]; 92 memset(r, 0, sizeof(*r)); 93 94 r->map_fd = map_fd; 95 r->sample_cb = sample_cb; 96 r->ctx = ctx; 97 r->mask = info.max_entries - 1; 98 99 /* Map writable consumer page */ 100 tmp = mmap(NULL, rb->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, 101 map_fd, 0); 102 if (tmp == MAP_FAILED) { 103 err = -errno; 104 pr_warn("ringbuf: failed to mmap consumer page for map fd=%d: %d\n", 105 map_fd, err); 106 return libbpf_err(err); 107 } 108 r->consumer_pos = tmp; 109 110 /* Map read-only producer page and data pages. We map twice as big 111 * data size to allow simple reading of samples that wrap around the 112 * end of a ring buffer. See kernel implementation for details. 113 * */ 114 tmp = mmap(NULL, rb->page_size + 2 * info.max_entries, PROT_READ, 115 MAP_SHARED, map_fd, rb->page_size); 116 if (tmp == MAP_FAILED) { 117 err = -errno; 118 ringbuf_unmap_ring(rb, r); 119 pr_warn("ringbuf: failed to mmap data pages for map fd=%d: %d\n", 120 map_fd, err); 121 return libbpf_err(err); 122 } 123 r->producer_pos = tmp; 124 r->data = tmp + rb->page_size; 125 126 e = &rb->events[rb->ring_cnt]; 127 memset(e, 0, sizeof(*e)); 128 129 e->events = EPOLLIN; 130 e->data.fd = rb->ring_cnt; 131 if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, e) < 0) { 132 err = -errno; 133 ringbuf_unmap_ring(rb, r); 134 pr_warn("ringbuf: failed to epoll add map fd=%d: %d\n", 135 map_fd, err); 136 return libbpf_err(err); 137 } 138 139 rb->ring_cnt++; 140 return 0; 141 } 142 143 void ring_buffer__free(struct ring_buffer *rb) 144 { 145 int i; 146 147 if (!rb) 148 return; 149 150 for (i = 0; i < rb->ring_cnt; ++i) 151 ringbuf_unmap_ring(rb, &rb->rings[i]); 152 if (rb->epoll_fd >= 0) 153 close(rb->epoll_fd); 154 155 free(rb->events); 156 free(rb->rings); 157 free(rb); 158 } 159 160 struct ring_buffer * 161 ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx, 162 const struct ring_buffer_opts *opts) 163 { 164 struct ring_buffer *rb; 165 int err; 166 167 if (!OPTS_VALID(opts, ring_buffer_opts)) 168 return errno = EINVAL, NULL; 169 170 rb = calloc(1, sizeof(*rb)); 171 if (!rb) 172 return errno = ENOMEM, NULL; 173 174 rb->page_size = getpagesize(); 175 176 rb->epoll_fd = epoll_create1(EPOLL_CLOEXEC); 177 if (rb->epoll_fd < 0) { 178 err = -errno; 179 pr_warn("ringbuf: failed to create epoll instance: %d\n", err); 180 goto err_out; 181 } 182 183 err = ring_buffer__add(rb, map_fd, sample_cb, ctx); 184 if (err) 185 goto err_out; 186 187 return rb; 188 189 err_out: 190 ring_buffer__free(rb); 191 return errno = -err, NULL; 192 } 193 194 static inline int roundup_len(__u32 len) 195 { 196 /* clear out top 2 bits (discard and busy, if set) */ 197 len <<= 2; 198 len >>= 2; 199 /* add length prefix */ 200 len += BPF_RINGBUF_HDR_SZ; 201 /* round up to 8 byte alignment */ 202 return (len + 7) / 8 * 8; 203 } 204 205 static int64_t ringbuf_process_ring(struct ring* r) 206 { 207 int *len_ptr, len, err; 208 /* 64-bit to avoid overflow in case of extreme application behavior */ 209 int64_t cnt = 0; 210 unsigned long cons_pos, prod_pos; 211 bool got_new_data; 212 void *sample; 213 214 cons_pos = smp_load_acquire(r->consumer_pos); 215 do { 216 got_new_data = false; 217 prod_pos = smp_load_acquire(r->producer_pos); 218 while (cons_pos < prod_pos) { 219 len_ptr = r->data + (cons_pos & r->mask); 220 len = smp_load_acquire(len_ptr); 221 222 /* sample not committed yet, bail out for now */ 223 if (len & BPF_RINGBUF_BUSY_BIT) 224 goto done; 225 226 got_new_data = true; 227 cons_pos += roundup_len(len); 228 229 if ((len & BPF_RINGBUF_DISCARD_BIT) == 0) { 230 sample = (void *)len_ptr + BPF_RINGBUF_HDR_SZ; 231 err = r->sample_cb(r->ctx, sample, len); 232 if (err < 0) { 233 /* update consumer pos and bail out */ 234 smp_store_release(r->consumer_pos, 235 cons_pos); 236 return err; 237 } 238 cnt++; 239 } 240 241 smp_store_release(r->consumer_pos, cons_pos); 242 } 243 } while (got_new_data); 244 done: 245 return cnt; 246 } 247 248 /* Consume available ring buffer(s) data without event polling. 249 * Returns number of records consumed across all registered ring buffers (or 250 * INT_MAX, whichever is less), or negative number if any of the callbacks 251 * return error. 252 */ 253 int ring_buffer__consume(struct ring_buffer *rb) 254 { 255 int64_t err, res = 0; 256 int i; 257 258 for (i = 0; i < rb->ring_cnt; i++) { 259 struct ring *ring = &rb->rings[i]; 260 261 err = ringbuf_process_ring(ring); 262 if (err < 0) 263 return libbpf_err(err); 264 res += err; 265 } 266 if (res > INT_MAX) 267 return INT_MAX; 268 return res; 269 } 270 271 /* Poll for available data and consume records, if any are available. 272 * Returns number of records consumed (or INT_MAX, whichever is less), or 273 * negative number, if any of the registered callbacks returned error. 274 */ 275 int ring_buffer__poll(struct ring_buffer *rb, int timeout_ms) 276 { 277 int i, cnt; 278 int64_t err, res = 0; 279 280 cnt = epoll_wait(rb->epoll_fd, rb->events, rb->ring_cnt, timeout_ms); 281 if (cnt < 0) 282 return libbpf_err(-errno); 283 284 for (i = 0; i < cnt; i++) { 285 __u32 ring_id = rb->events[i].data.fd; 286 struct ring *ring = &rb->rings[ring_id]; 287 288 err = ringbuf_process_ring(ring); 289 if (err < 0) 290 return libbpf_err(err); 291 res += err; 292 } 293 if (res > INT_MAX) 294 return INT_MAX; 295 return res; 296 } 297 298 /* Get an fd that can be used to sleep until data is available in the ring(s) */ 299 int ring_buffer__epoll_fd(const struct ring_buffer *rb) 300 { 301 return rb->epoll_fd; 302 } 303