DGNum/libubox
6
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

udebug: add udebug library code

Browse source 
Copied and adapted from udebug.git

Signed-off-by: Felix Fietkau <nbd@nbd.name>
This commit is contained in:
Felix Fietkau 2023-11-27 15:44:33 +01:00
parent b3fa3d92e3
commit d4c3066e7c
6 changed files with 1464 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CMakeLists.txt
View file

@ -21,7 +21,7 @@ IF(JSONC_FOUND)
INCLUDE_DIRECTORIES(${JSONC_INCLUDE_DIRS})
ENDIF()
SET(SOURCES avl.c avl-cmp.c blob.c blobmsg.c uloop.c usock.c ustream.c ustream-fd.c vlist.c utils.c safe_list.c runqueue.c md5.c kvlist.c ulog.c base64.c)
SET(SOURCES avl.c avl-cmp.c blob.c blobmsg.c uloop.c usock.c ustream.c ustream-fd.c vlist.c utils.c safe_list.c runqueue.c md5.c kvlist.c ulog.c base64.c udebug.c udebug-remote.c)
ADD_LIBRARY(ubox SHARED ${SOURCES})
ADD_LIBRARY(ubox-static STATIC ${SOURCES})
@ -37,6 +37,7 @@ IF(NOT HAVE_GETTIME)
ENDIF()
FILE(GLOB headers *.h)
LIST(FILTER headers EXCLUDE REGEX "-priv.h$" )
INSTALL(FILES ${headers}
DESTINATION include/libubox
)

54
udebug-priv.h Normal file
View file

@ -0,0 +1,54 @@
/*
* udebug - debug ring buffer library
*
* Copyright (C) 2023 Felix Fietkau <nbd@nbd.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef __UDEBUG_UTIL_H
#define __UDEBUG_UTIL_H
#include "blobmsg.h"
#include "udebug.h"
#include "udebug-proto.h"
#define UDEBUG_TIMEOUT 1000
__hidden int udebug_buf_open(struct udebug_buf *buf, int fd, uint32_t ring_size, uint32_t data_size);
__hidden struct udebug_client_msg *__udebug_poll(struct udebug *ctx, int *fd, bool wait);
__hidden void udebug_send_msg(struct udebug *ctx, struct udebug_client_msg *msg,
struct blob_attr *meta, int fd);
static inline int32_t u32_sub(uint32_t a, uint32_t b)
{
return a - b;
}
static inline int32_t u32_max(uint32_t a, uint32_t b)
{
return u32_sub(a, b) > 0 ? a : b;
}
static inline void u32_set(void *ptr, uint32_t val)
{
volatile uint32_t *v = ptr;
*v = val;
}
static inline uint32_t u32_get(void *ptr)
{
volatile uint32_t *v = ptr;
return *v;
}
#endif

72
udebug-proto.h Normal file
View file

@ -0,0 +1,72 @@
/*
* udebug - debug ring buffer library
*
* Copyright (C) 2023 Felix Fietkau <nbd@nbd.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef __UDEBUG_PROTO_H
#define __UDEBUG_PROTO_H
#include "udebug.h"
struct udebug_hdr {
uint32_t ring_size;
uint32_t data_size;
uint32_t format;
uint32_t sub_format;
uintptr_t flags[8 / sizeof(uintptr_t)];
uintptr_t notify;
uint32_t head_hi;
uint32_t head;
uint32_t data_head;
uint32_t data_used;
};
enum udebug_client_msg_type {
CL_MSG_RING_ADD,
CL_MSG_RING_REMOVE,
CL_MSG_RING_NOTIFY,
CL_MSG_GET_HANDLE,
CL_MSG_RING_GET,
CL_MSG_ERROR,
};
struct udebug_client_msg {
uint8_t type;
uint8_t _pad[3];
uint32_t id;
union {
struct {
uint32_t ring_size, data_size;
};
uint32_t notify_mask;
};
} __attribute__((packed, aligned(4)));
static inline struct udebug_ptr *
udebug_ring_ptr(struct udebug_hdr *hdr, uint32_t idx)
{
struct udebug_ptr *ring = (struct udebug_ptr *)&hdr[1];
return &ring[idx & (hdr->ring_size - 1)];
}
static inline void *udebug_buf_ptr(struct udebug_buf *buf, uint32_t ofs)
{
return buf->data + (ofs & (buf->data_size - 1));
}
#endif

382
udebug-remote.c Normal file
View file

@ -0,0 +1,382 @@
/*
* udebug - debug ring buffer library
*
* Copyright (C) 2023 Felix Fietkau <nbd@nbd.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "udebug-priv.h"
static struct udebug_client_msg *
send_and_wait(struct udebug *ctx, struct udebug_client_msg *msg, int *rfd)
{
int type = msg->type;
int fd = -1;
udebug_send_msg(ctx, msg, NULL, -1);
do {
if (fd >= 0)
close(fd);
fd = -1;
msg = __udebug_poll(ctx, &fd, true);
} while (msg && msg->type != type);
if (!msg)
return NULL;
if (rfd)
*rfd = fd;
else if (fd >= 0)
close(fd);
return msg;
}
static int
udebug_remote_get_handle(struct udebug *ctx)
{
struct udebug_client_msg *msg;
struct udebug_client_msg send_msg = {
.type = CL_MSG_GET_HANDLE,
};
if (ctx->poll_handle >= 0 || !udebug_is_connected(ctx))
return 0;
msg = send_and_wait(ctx, &send_msg, NULL);
if (!msg)
return -1;
ctx->poll_handle = msg->id;
return 0;
}
struct udebug_remote_buf *udebug_remote_buf_get(struct udebug *ctx, uint32_t id)
{
struct udebug_remote_buf *rb;
void *key = (void *)(uintptr_t)id;
return avl_find_element(&ctx->remote_rings, key, rb, node);
}
int udebug_remote_buf_map(struct udebug *ctx, struct udebug_remote_buf *rb, uint32_t id)
{
void *key = (void *)(uintptr_t)id;
struct udebug_client_msg *msg;
struct udebug_client_msg send_msg = {
.type = CL_MSG_RING_GET,
.id = id,
};
int fd = -1;
if (rb->buf.data || !udebug_is_connected(ctx))
return -1;
msg = send_and_wait(ctx, &send_msg, &fd);
if (!msg || fd < 0)
return -1;
if (udebug_buf_open(&rb->buf, fd, msg->ring_size, msg->data_size)) {
fprintf(stderr, "failed to open fd %d, ring_size=%d, data_size=%d\n", fd, msg->ring_size, msg->data_size);
close(fd);
return -1;
}
rb->pcap_iface = ~0;
rb->node.key = key;
avl_insert(&ctx->remote_rings, &rb->node);
return 0;
}
void udebug_remote_buf_unmap(struct udebug *ctx, struct udebug_remote_buf *rb)
{
if (!rb->buf.data)
return;
avl_delete(&ctx->remote_rings, &rb->node);
udebug_buf_free(&rb->buf);
rb->poll = 0;
rb->node.key = NULL;
rb->pcap_iface = ~0;
}
int udebug_remote_buf_set_poll(struct udebug *ctx, struct udebug_remote_buf *rb, bool val)
{
int handle;
if (!rb->buf.data)
return -1;
if (rb->poll == val)
return 0;
rb->poll = val;
if (!val)
return 0;
handle = udebug_remote_get_handle(ctx);
if (handle < 0)
return -1;
__atomic_fetch_or(&rb->buf.hdr->notify, 1UL << handle, __ATOMIC_RELAXED);
return 0;
}
static void
rbuf_advance_read_head(struct udebug_remote_buf *rb, uint32_t head,
uint32_t *data_start)
{
struct udebug_hdr *hdr = rb->buf.hdr;
uint32_t min_head = head + 1 - rb->buf.ring_size;
uint32_t min_data = u32_get(&hdr->data_used) - rb->buf.data_size;
struct udebug_ptr *last_ptr = udebug_ring_ptr(hdr, head - 1);
if (!u32_get(&hdr->head_hi) && u32_sub(0, min_head) > 0)
min_head = 0;
/* advance head to skip over any entries that are guaranteed
* to be overwritten now. final check will be performed after
* data copying */
if (u32_sub(rb->head, min_head) < 0)
rb->head = min_head;
for (size_t i = 0; i < rb->buf.ring_size; i++) {
struct udebug_ptr *ptr = udebug_ring_ptr(hdr, rb->head);
if (data_start) {
*data_start = u32_get(&ptr->start);
__sync_synchronize();
}
if (ptr->timestamp > last_ptr->timestamp)
continue;
if (u32_sub(ptr->start, min_data) > 0)
break;
rb->head++;
}
}
void udebug_remote_buf_set_start_time(struct udebug_remote_buf *rb, uint64_t ts)
{
struct udebug_hdr *hdr = rb->buf.hdr;
uint32_t head = u32_get(&hdr->head);
uint32_t start = rb->head, end = head;
uint32_t diff;
if (!hdr)
return;
rbuf_advance_read_head(rb, head, NULL);
while ((diff = u32_sub(end, start)) > 0) {
uint32_t cur = start + diff / 2;
struct udebug_ptr *ptr;
ptr = udebug_ring_ptr(hdr, cur);
if (ptr->timestamp > ts)
end = cur - 1;
else
start = cur + 1;
}
rb->head = start;
}
void udebug_remote_buf_set_start_offset(struct udebug_remote_buf *rb, uint32_t idx)
{
if (!rb->buf.hdr)
return;
rb->head = rb->buf.hdr->head - idx;
}
void udebug_remote_buf_set_flags(struct udebug_remote_buf *rb, uint64_t mask, uint64_t set)
{
struct udebug_hdr *hdr = rb->buf.hdr;
if (!hdr)
return;
if ((uintptr_t)mask)
__atomic_and_fetch(&hdr->flags[0], (uintptr_t)~mask, __ATOMIC_RELAXED);
if ((uintptr_t)set)
__atomic_or_fetch(&hdr->flags[0], (uintptr_t)set, __ATOMIC_RELAXED);
if (sizeof(mask) == sizeof(unsigned long))
return;
mask >>= 32;
if ((uintptr_t)mask)
__atomic_and_fetch(&hdr->flags[1], (uintptr_t)~mask, __ATOMIC_RELAXED);
if ((uintptr_t)set)
__atomic_or_fetch(&hdr->flags[1], (uintptr_t)set, __ATOMIC_RELAXED);
}
struct udebug_snapshot *
udebug_remote_buf_snapshot(struct udebug_remote_buf *rb)
{
struct udebug_hdr *hdr = rb->buf.hdr;
struct udebug_ptr *last_ptr;
uint32_t data_start, data_end, data_used;
struct udebug_snapshot *s = NULL;
struct udebug_ptr *ptr_buf, *first_ptr;
uint32_t data_size, ptr_size;
uint32_t head, first_idx;
uint32_t prev_read_head = rb->head;
void *data_buf;
if (!hdr)
return NULL;
head = u32_get(&hdr->head);
rbuf_advance_read_head(rb, head, &data_start);
if (rb->head == head)
return NULL;
first_idx = rb->head;
first_ptr = udebug_ring_ptr(hdr, first_idx);
last_ptr = udebug_ring_ptr(hdr, head - 1);
data_end = last_ptr->start + last_ptr->len;
data_size = data_end - data_start;
ptr_size = head - rb->head;
if (data_size > rb->buf.data_size || ptr_size > rb->buf.ring_size) {
fprintf(stderr, "Invalid data size: %x > %x, %x > %x\n", data_size, (int)rb->buf.data_size, ptr_size, (int)rb->buf.ring_size);
goto out;
}
s = calloc_a(sizeof(*s),
&ptr_buf, ptr_size * sizeof(*ptr_buf),
&data_buf, data_size);
s->data = memcpy(data_buf, udebug_buf_ptr(&rb->buf, data_start), data_size);
s->data_size = data_size;
s->entries = ptr_buf;
s->dropped = rb->head - prev_read_head;
if (first_ptr > last_ptr) {
struct udebug_ptr *start_ptr = udebug_ring_ptr(hdr, 0);
struct udebug_ptr *end_ptr = udebug_ring_ptr(hdr, rb->buf.ring_size - 1) + 1;
uint32_t size = end_ptr - first_ptr;
memcpy(s->entries, first_ptr, size * sizeof(*s->entries));
memcpy(s->entries + size, start_ptr, (last_ptr + 1 - start_ptr) * sizeof(*s->entries));
} else {
memcpy(s->entries, first_ptr, (last_ptr + 1 - first_ptr) * sizeof(*s->entries));
}
/* get a snapshot of the counter that indicates how much data has been
* clobbered by newly added entries */
__sync_synchronize();
data_used = u32_get(&hdr->data_used) - rb->buf.data_size;
s->n_entries = head - first_idx;
rbuf_advance_read_head(rb, head, NULL);
if (s->n_entries < rb->head - first_idx) {
free(s);
s = NULL;
goto out;
}
s->entries += rb->head - first_idx;
s->n_entries -= rb->head - first_idx;
while (s->n_entries > 0 &&
u32_sub(s->entries[0].start, data_used) < 0) {
s->entries++;
s->n_entries--;
s->dropped++;
}
for (size_t i = 0; i < s->n_entries; i++)
s->entries[i].start -= data_start;
s->format = hdr->format;
s->sub_format = hdr->sub_format;
s->rbuf_idx = (uint32_t)(uintptr_t)rb->node.key;
out:
rb->head = head;
return s;
}
bool udebug_snapshot_get_entry(struct udebug_snapshot *s, struct udebug_iter *it, unsigned int entry)
{
struct udebug_ptr *ptr;
it->len = 0;
if (entry >= s->n_entries)
goto error;
ptr = &s->entries[entry];
if (ptr->start > s->data_size || ptr->len > s->data_size ||
ptr->start + ptr->len > s->data_size)
goto error;
it->s = s;
it->data = s->data + ptr->start;
it->len = ptr->len;
it->timestamp = ptr->timestamp;
return true;
error:
it->data = NULL;
return false;
}
void udebug_iter_start(struct udebug_iter *it, struct udebug_snapshot **s, size_t n)
{
memset(it, 0, sizeof(*it));
it->list = s;
it->n = n;
for (size_t i = 0; i < it->n; i++)
it->list[i]->iter_idx = 0;
}
bool udebug_iter_next(struct udebug_iter *it)
{
while (1) {
struct udebug_snapshot *s;
uint64_t cur_ts;
int cur = -1;
for (size_t i = 0; i < it->n; i++) {
struct udebug_ptr *ptr;
s = it->list[i];
if (s->iter_idx >= s->n_entries)
continue;
ptr = &s->entries[s->iter_idx];
if (cur >= 0 && ptr->timestamp > cur_ts)
continue;
cur = i;
cur_ts = ptr->timestamp;
}
if (cur < 0)
return false;
s = it->list[cur];
it->s_idx = cur;
if (!udebug_snapshot_get_entry(s, it, s->iter_idx++))
continue;
return true;
}
}

758
udebug.c Normal file
View file

@ -0,0 +1,758 @@
/*
* udebug - debug ring buffer library
*
* Copyright (C) 2023 Felix Fietkau <nbd@nbd.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <time.h>
#include "udebug-priv.h"
#include "usock.h"
#define ALIGN(i, sz) (((i) + (sz) - 1) & ~((sz) - 1))
#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
#endif
#define UDEBUG_MIN_ALLOC_LEN 128
static struct blob_buf b;
static void __randname(char *template)
{
int i;
struct timespec ts;
unsigned long r;
clock_gettime(CLOCK_REALTIME, &ts);
r = ts.tv_sec + ts.tv_nsec;
for (i=0; i<6; i++, r>>=5)
template[i] = 'A'+(r&15)+(r&16)*2;
}
int udebug_id_cmp(const void *k1, const void *k2, void *ptr)
{
uint32_t id1 = (uint32_t)(uintptr_t)k1, id2 = (uint32_t)(uintptr_t)k2;
if (id1 < id2)
return -1;
else if (id1 > id2)
return 1;
return 0;
}
static inline int
shm_open_anon(char *name)
{
char *template = name + strlen(name) - 6;
int fd;
if (template < name || memcmp(template, "XXXXXX", 6) != 0)
return -1;
for (int i = 0; i < 100; i++) {
__randname(template);
fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
if (fd >= 0) {
if (shm_unlink(name) < 0) {
close(fd);
continue;
}
return fd;
}
if (fd < 0 && errno != EEXIST)
return -1;
}
return -1;
}
static void __udebug_disconnect(struct udebug *ctx, bool reconnect)
{
uloop_fd_delete(&ctx->fd);
close(ctx->fd.fd);
ctx->fd.fd = -1;
ctx->poll_handle = -1;
if (ctx->reconnect.cb && reconnect)
uloop_timeout_set(&ctx->reconnect, 1);
}
uint64_t udebug_timestamp(void)
{
struct timespec ts;
uint64_t val;
clock_gettime(CLOCK_REALTIME, &ts);
val = ts.tv_sec;
val *= UDEBUG_TS_SEC;
val += ts.tv_nsec / 1000;
return val;
}
static int
__udebug_buf_map(struct udebug_buf *buf)
{
void *ptr, *ptr2;
ptr = mmap(NULL, buf->head_size + 2 * buf->data_size, PROT_NONE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (ptr == MAP_FAILED)
return -1;
ptr2 = mmap(ptr, buf->head_size + buf->data_size,
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, buf->fd, 0);
if (ptr2 != ptr)
goto err_unmap;
ptr2 = mmap(ptr + buf->head_size + buf->data_size, buf->data_size,
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, buf->fd,
buf->head_size);
if (ptr2 != ptr + buf->head_size + buf->data_size)
goto err_unmap;
buf->hdr = ptr;
buf->data = ptr + buf->head_size;
return 0;
err_unmap:
munmap(ptr, buf->head_size + 2 * buf->data_size);
return -1;
}
static int
writev_retry(int fd, struct iovec *iov, int iov_len, int sock_fd)
{
uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
struct msghdr msghdr = { 0 };
struct cmsghdr *cmsg;
int len = 0;
int *pfd;
msghdr.msg_iov = iov,
msghdr.msg_iovlen = iov_len,
msghdr.msg_control = fd_buf;
msghdr.msg_controllen = sizeof(fd_buf);
cmsg = CMSG_FIRSTHDR(&msghdr);
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
pfd = (int *) CMSG_DATA(cmsg);
msghdr.msg_controllen = cmsg->cmsg_len;
do {
ssize_t cur_len;
if (sock_fd < 0) {
msghdr.msg_control = NULL;
msghdr.msg_controllen = 0;
} else {
*pfd = sock_fd;
}
cur_len = sendmsg(fd, &msghdr, 0);
if (cur_len < 0) {
struct pollfd pfd = {
.fd = fd,
.events = POLLOUT
};
switch(errno) {
case EAGAIN:
poll(&pfd, 1, -1);
break;
case EINTR:
break;
default:
return -1;
}
continue;
}
if (len > 0)
sock_fd = -1;
len += cur_len;
while (cur_len >= (ssize_t) iov->iov_len) {
cur_len -= iov->iov_len;
iov_len--;
iov++;
if (!iov_len)
return len;
}
iov->iov_base += cur_len;
iov->iov_len -= cur_len;
msghdr.msg_iov = iov;
msghdr.msg_iovlen = iov_len;
} while (1);
/* Should never reach here */
return -1;
}
static int
recv_retry(int fd, struct iovec *iov, bool wait, int *recv_fd)
{
uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
struct msghdr msghdr = { 0 };
struct cmsghdr *cmsg;
int total = 0;
int bytes;
int *pfd;
msghdr.msg_iov = iov,
msghdr.msg_iovlen = 1,
msghdr.msg_control = fd_buf;
msghdr.msg_controllen = sizeof(fd_buf);
cmsg = CMSG_FIRSTHDR(&msghdr);
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
pfd = (int *) CMSG_DATA(cmsg);
while (iov->iov_len > 0) {
if (recv_fd) {
msghdr.msg_control = fd_buf;
msghdr.msg_controllen = cmsg->cmsg_len;
} else {
msghdr.msg_control = NULL;
msghdr.msg_controllen = 0;
}
*pfd = -1;
bytes = recvmsg(fd, &msghdr, 0);
if (!bytes)
return -2;
if (bytes < 0) {
bytes = 0;
if (errno == EINTR)
continue;
if (errno != EAGAIN)
return -2;
}
if (!wait && !bytes)
return 0;
if (recv_fd)
*recv_fd = *pfd;
else if (*pfd >= 0)
close(*pfd);
if (bytes > 0)
recv_fd = NULL;
wait = true;
iov->iov_len -= bytes;
iov->iov_base += bytes;
total += bytes;
if (iov->iov_len > 0) {
struct pollfd pfd = {
.fd = fd,
.events = POLLIN
};
int ret;
do {
ret = poll(&pfd, 1, UDEBUG_TIMEOUT);
} while (ret < 0 && errno == EINTR);
if (!(pfd.revents & POLLIN))
return -1;
}
}
return total;
}
void udebug_send_msg(struct udebug *ctx, struct udebug_client_msg *msg,
struct blob_attr *meta, int fd)
{
struct iovec iov[2] = {
{ .iov_base = msg, .iov_len = sizeof(*msg) },
{}
};
if (!meta) {
blob_buf_init(&b, 0);
meta = b.head;
}
iov[1].iov_base = meta;
iov[1].iov_len = blob_pad_len(meta);
writev_retry(ctx->fd.fd, iov, ARRAY_SIZE(iov), fd);
}
static void
udebug_buf_msg(struct udebug_buf *buf, enum udebug_client_msg_type type)
{
struct udebug_client_msg msg = {
.type = type,
.id = buf->id,
};
udebug_send_msg(buf->ctx, &msg, NULL, -1);
}
static size_t __udebug_headsize(unsigned int ring_size, unsigned int page_size)
{
ring_size *= sizeof(struct udebug_ptr);
return ALIGN(sizeof(struct udebug_hdr) + ring_size, page_size);
}
int udebug_buf_open(struct udebug_buf *buf, int fd, uint32_t ring_size, uint32_t data_size)
{
INIT_LIST_HEAD(&buf->list);
buf->fd = fd;
buf->ring_size = ring_size;
buf->head_size = __udebug_headsize(ring_size, sysconf(_SC_PAGESIZE));
buf->data_size = data_size;
if (buf->ring_size > (1U << 24) || buf->data_size > (1U << 29))
return -1;
if (__udebug_buf_map(buf))
return -1;
if (buf->ring_size != buf->hdr->ring_size ||
buf->data_size != buf->hdr->data_size) {
munmap(buf->hdr, buf->head_size + 2 * buf->data_size);
buf->hdr = NULL;
return -1;
}
return 0;
}
int udebug_buf_init(struct udebug_buf *buf, size_t entries, size_t size)
{
uint32_t pagesz = sysconf(_SC_PAGESIZE);
char filename[] = "/udebug.XXXXXX";
unsigned int order = 12;
uint8_t ring_order = 5;
size_t head_size;
int fd;
INIT_LIST_HEAD(&buf->list);
if (size < pagesz)
size = pagesz;
while(size > 1U << order)
order++;
size = 1 << order;
while (entries > 1U << ring_order)
ring_order++;
entries = 1 << ring_order;
if (size > (1U << 29) || entries > (1U << 24))
return -1;
head_size = __udebug_headsize(entries, pagesz);
while (ALIGN(sizeof(*buf->hdr) + (entries * 2) * sizeof(struct udebug_ptr), pagesz) == head_size)
entries *= 2;
fd = shm_open_anon(filename);
if (fd < 0)
return -1;
if (ftruncate(fd, head_size + size) < 0)
goto err_close;
buf->head_size = head_size;
buf->data_size = size;
buf->ring_size = entries;
buf->fd = fd;
if (__udebug_buf_map(buf))
goto err_close;
buf->hdr->ring_size = entries;
buf->hdr->data_size = size;
/* ensure hdr changes are visible */
__sync_synchronize();
return 0;
err_close:
close(fd);
return -1;
}
static void *udebug_buf_alloc(struct udebug_buf *buf, uint32_t ofs, uint32_t len)
{
struct udebug_hdr *hdr = buf->hdr;
hdr->data_used = u32_max(hdr->data_used, ofs + len + 1);
/* ensure that data_used update is visible before clobbering data */
__sync_synchronize();
return udebug_buf_ptr(buf, ofs);
}
uint64_t udebug_buf_flags(struct udebug_buf *buf)
{
struct udebug_hdr *hdr = buf->hdr;
uint64_t flags;
if (!hdr)
return 0;
flags = hdr->flags[0];
if (sizeof(flags) != sizeof(uintptr_t))
flags |= ((uint64_t)hdr->flags[1]) << 32;
return flags;
}
void udebug_entry_init_ts(struct udebug_buf *buf, uint64_t timestamp)
{
struct udebug_hdr *hdr = buf->hdr;
struct udebug_ptr *ptr;
if (!hdr)
return;
ptr = udebug_ring_ptr(hdr, hdr->head);
ptr->start = hdr->data_head;
ptr->len = 0;
ptr->timestamp = timestamp;
}
void *udebug_entry_append(struct udebug_buf *buf, const void *data, uint32_t len)
{
struct udebug_hdr *hdr = buf->hdr;
struct udebug_ptr *ptr;
uint32_t ofs;
void *ret;
if (!hdr)
return NULL;
ptr = udebug_ring_ptr(hdr, hdr->head);
ofs = ptr->start + ptr->len;
if (ptr->len + len > buf->data_size / 2)
return NULL;
ret = udebug_buf_alloc(buf, ofs, len);
if (data)
memcpy(ret, data, len);
ptr->len += len;
return ret;
}
int udebug_entry_printf(struct udebug_buf *buf, const char *fmt, ...)
{
va_list ap;
size_t ret;
va_start(ap, fmt);
ret = udebug_entry_vprintf(buf, fmt, ap);
va_end(ap);
return ret;
}
int udebug_entry_vprintf(struct udebug_buf *buf, const char *fmt, va_list ap)
{
struct udebug_hdr *hdr = buf->hdr;
struct udebug_ptr *ptr;
uint32_t ofs;
uint32_t len;
char *str;
if (!hdr)
return -1;
ptr = udebug_ring_ptr(hdr, hdr->head);
ofs = ptr->start + ptr->len;
if (ptr->len > buf->data_size / 2)
return -1;
str = udebug_buf_alloc(buf, ofs, UDEBUG_MIN_ALLOC_LEN);
len = vsnprintf(str, UDEBUG_MIN_ALLOC_LEN, fmt, ap);
if (len <= UDEBUG_MIN_ALLOC_LEN)
goto out;
if (ptr->len + len > buf->data_size / 2)
return -1;
udebug_buf_alloc(buf, ofs, len + 1);
len = vsnprintf(str, len, fmt, ap);
out:
ptr->len += len;
return 0;
}
void udebug_entry_add(struct udebug_buf *buf)
{
struct udebug_hdr *hdr = buf->hdr;
struct udebug_ptr *ptr = udebug_ring_ptr(hdr, hdr->head);
uint32_t notify;
uint8_t *data;
/* ensure strings are always 0-terminated */
data = udebug_buf_ptr(buf, ptr->start + ptr->len);
*data = 0;
hdr->data_head = ptr->start + ptr->len + 1;
/* ensure that all data changes are visible before advancing head */
__sync_synchronize();
u32_set(&hdr->head, u32_get(&hdr->head) + 1);
if (!u32_get(&hdr->head))
u32_set(&hdr->head_hi, u32_get(&hdr->head_hi) + 1);
/* ensure that head change is visible */
__sync_synchronize();
notify = __atomic_exchange_n(&hdr->notify, 0, __ATOMIC_RELAXED);
if (notify) {
struct udebug_client_msg msg = {
.type = CL_MSG_RING_NOTIFY,
.id = buf->id,
.notify_mask = notify,
};
blob_buf_init(&b, 0);
udebug_send_msg(buf->ctx, &msg, b.head, -1);
}
}
void udebug_buf_free(struct udebug_buf *buf)
{
struct udebug *ctx = buf->ctx;
if (!list_empty(&buf->list) && buf->list.prev)
list_del(&buf->list);
if (ctx && ctx->fd.fd >= 0)
udebug_buf_msg(buf, CL_MSG_RING_REMOVE);
munmap(buf->hdr, buf->head_size + 2 * buf->data_size);
close(buf->fd);
memset(buf, 0, sizeof(*buf));
}
static void
__udebug_buf_add(struct udebug *ctx, struct udebug_buf *buf)
{
struct udebug_client_msg msg = {
.type = CL_MSG_RING_ADD,
.id = buf->id,
.ring_size = buf->hdr->ring_size,
.data_size = buf->hdr->data_size,
};
const struct udebug_buf_meta *meta = buf->meta;
void *c;
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "name", meta->name);
c = blobmsg_open_array(&b, "flags");
for (size_t i = 0; i < meta->n_flags; i++) {
const struct udebug_buf_flag *flag = &meta->flags[i];
void *e = blobmsg_open_array(&b, NULL);
blobmsg_add_string(&b, NULL, flag->name);
blobmsg_add_u64(&b, NULL, flag->mask);
blobmsg_close_array(&b, e);
}
blobmsg_close_array(&b, c);
udebug_send_msg(ctx, &msg, b.head, buf->fd);
}
int udebug_buf_add(struct udebug *ctx, struct udebug_buf *buf,
const struct udebug_buf_meta *meta)
{
list_add_tail(&buf->list, &ctx->local_rings);
buf->ctx = ctx;
buf->meta = meta;
buf->id = ctx->next_id++;
buf->hdr->format = meta->format;
buf->hdr->sub_format = meta->sub_format;
if (ctx->fd.fd >= 0)
__udebug_buf_add(ctx, buf);
return 0;
}
void udebug_init(struct udebug *ctx)
{
INIT_LIST_HEAD(&ctx->local_rings);
avl_init(&ctx->remote_rings, udebug_id_cmp, true, NULL);
ctx->fd.fd = -1;
ctx->poll_handle = -1;
}
static void udebug_reconnect_cb(struct uloop_timeout *t)
{
struct udebug *ctx = container_of(t, struct udebug, reconnect);
if (udebug_connect(ctx, ctx->socket_path) < 0) {
uloop_timeout_set(&ctx->reconnect, 1000);
return;
}
udebug_add_uloop(ctx);
}
void udebug_auto_connect(struct udebug *ctx, const char *path)
{
free(ctx->socket_path);
ctx->reconnect.cb = udebug_reconnect_cb;
ctx->socket_path = path ? strdup(path) : NULL;
if (ctx->fd.fd >= 0)
return;
udebug_reconnect_cb(&ctx->reconnect);
}
int udebug_connect(struct udebug *ctx, const char *path)
{
struct udebug_remote_buf *rb;
struct udebug_buf *buf;
if (ctx->fd.fd >= 0)
close(ctx->fd.fd);
ctx->fd.fd = -1;
if (!path)
path = UDEBUG_SOCK_NAME;
ctx->fd.fd = usock(USOCK_UNIX, path, NULL);
if (ctx->fd.fd < 0)
return -1;
list_for_each_entry(buf, &ctx->local_rings, list)
__udebug_buf_add(ctx, buf);
avl_for_each_element(&ctx->remote_rings, rb, node) {
if (!rb->poll)
continue;
rb->poll = false;
udebug_remote_buf_set_poll(ctx, rb, true);
}
return 0;
}
static bool
udebug_recv_msg(struct udebug *ctx, struct udebug_client_msg *msg, int *fd,
bool wait)
{
struct iovec iov = {
.iov_base = msg,
.iov_len = sizeof(*msg)
};
int ret;
ret = recv_retry(ctx->fd.fd, &iov, wait, fd);
if (ret == -2)
__udebug_disconnect(ctx, true);
return ret == sizeof(*msg);
}
struct udebug_client_msg *__udebug_poll(struct udebug *ctx, int *fd, bool wait)
{
static struct udebug_client_msg msg = {};
while (udebug_recv_msg(ctx, &msg, fd, wait)) {
struct udebug_remote_buf *rb;
void *key;
if (msg.type != CL_MSG_RING_NOTIFY)
return &msg;
if (fd && *fd >= 0)
close(*fd);
if (!ctx->notify_cb)
continue;
key = (void *)(uintptr_t)msg.id;
rb = avl_find_element(&ctx->remote_rings, key, rb, node);
if (!rb || !rb->poll)
continue;
if (ctx->poll_handle >= 0)
__atomic_fetch_or(&rb->buf.hdr->notify,
1UL << ctx->poll_handle,
__ATOMIC_RELAXED);
ctx->notify_cb(ctx, rb);
}
return NULL;
}
void udebug_poll(struct udebug *ctx)
{
while (__udebug_poll(ctx, NULL, false));
}
static void udebug_fd_cb(struct uloop_fd *fd, unsigned int events)
{
struct udebug *ctx = container_of(fd, struct udebug, fd);
if (fd->eof)
__udebug_disconnect(ctx, true);
udebug_poll(ctx);
}
void udebug_add_uloop(struct udebug *ctx)
{
if (ctx->fd.registered)
return;
ctx->fd.cb = udebug_fd_cb;
uloop_fd_add(&ctx->fd, ULOOP_READ);
}
void udebug_free(struct udebug *ctx)
{
struct udebug_remote_buf *rb, *tmp;
struct udebug_buf *buf;
free(ctx->socket_path);
ctx->socket_path = NULL;
__udebug_disconnect(ctx, false);
uloop_timeout_cancel(&ctx->reconnect);
while (!list_empty(&ctx->local_rings)) {
buf = list_first_entry(&ctx->local_rings, struct udebug_buf, list);
udebug_buf_free(buf);
}
avl_for_each_element_safe(&ctx->remote_rings, rb, node, tmp)
udebug_remote_buf_unmap(ctx, rb);
}

196
udebug.h Normal file
View file

@ -0,0 +1,196 @@
/*
* udebug - debug ring buffer library
*
* Copyright (C) 2023 Felix Fietkau <nbd@nbd.name>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef __UDEBUG_RINGBUF_H
#define __UDEBUG_RINGBUF_H
#include <sys/types.h>
#include <stdint.h>
#include <stdarg.h>
#include "list.h"
#include "uloop.h"
#include "avl.h"
#define UDEBUG_SOCK_NAME "/var/run/udebug.sock"
enum udebug_format {
UDEBUG_FORMAT_PACKET,
UDEBUG_FORMAT_STRING,
UDEBUG_FORMAT_BLOBMSG,
};
enum {
UDEBUG_DLT_ETHERNET = 1,
UDEBUG_DLT_PPP = 50,
UDEBUG_DLT_RAW_IP = 101,
UDEBUG_DLT_IEEE_802_11 = 105,
UDEBUG_DLT_IEEE_802_11_RADIOTAP = 127,
UDEBUG_DLT_NETLINK = 253,
};
enum udebug_meta_type {
UDEBUG_META_IFACE_NAME,
UDEBUG_META_IFACE_DESC,
__UDEBUG_META_MAX
};
#define UDEBUG_TS_MSEC 1000ULL
#define UDEBUG_TS_SEC (1000ULL * UDEBUG_TS_MSEC)
struct udebug;
struct udebug_hdr;
struct udebug_buf_flag {
const char *name;
uint64_t mask;
};
struct udebug_buf_meta {
const char *name;
enum udebug_format format;
uint32_t sub_format; /* linktype for UDEBUG_FORMAT_PACKET */
const struct udebug_buf_flag *flags;
unsigned int n_flags;
};
struct udebug_buf {
struct udebug *ctx;
const struct udebug_buf_meta *meta;
uint32_t id;
struct list_head list;
struct udebug_hdr *hdr;
void *data;
size_t data_size;
size_t head_size;
size_t ring_size;
int fd;
};
struct udebug_packet_info {
const char *attr[__UDEBUG_META_MAX];
};
struct udebug_remote_buf {
struct avl_node node;
struct udebug_buf buf;
bool poll;
uint32_t head;
/* provided by user */
uint32_t pcap_iface;
void *priv;
const struct udebug_packet_info *meta;
};
struct udebug {
struct list_head local_rings;
struct avl_tree remote_rings;
uint32_t next_id;
struct uloop_fd fd;
int poll_handle;
char *socket_path;
struct uloop_timeout reconnect;
/* filled by user */
void (*notify_cb)(struct udebug *ctx, struct udebug_remote_buf *rb);
};
struct udebug_ptr {
uint32_t start;
uint32_t len;
uint64_t timestamp;
};
struct udebug_snapshot {
struct udebug_ptr *entries;
unsigned int n_entries;
unsigned int dropped;
void *data;
size_t data_size;
uint32_t iter_idx;
enum udebug_format format;
uint32_t sub_format;
uint32_t rbuf_idx;
};
struct udebug_iter {
struct udebug_snapshot **list;
size_t n;
struct udebug_snapshot *s;
unsigned int s_idx;
uint64_t timestamp;
void *data;
size_t len;
};
uint64_t udebug_timestamp(void);
void udebug_entry_init_ts(struct udebug_buf *buf, uint64_t timestamp);
static inline void udebug_entry_init(struct udebug_buf *buf)
{
udebug_entry_init_ts(buf, udebug_timestamp());
}
void *udebug_entry_append(struct udebug_buf *buf, const void *data, uint32_t len);
int udebug_entry_printf(struct udebug_buf *buf, const char *fmt, ...)
__attribute__ ((format (printf, 2, 3)));
int udebug_entry_vprintf(struct udebug_buf *buf, const char *fmt, va_list ap)
__attribute__ ((format (printf, 2, 0)));
void udebug_entry_add(struct udebug_buf *buf);
int udebug_buf_init(struct udebug_buf *buf, size_t entries, size_t size);
int udebug_buf_add(struct udebug *ctx, struct udebug_buf *buf,
const struct udebug_buf_meta *meta);
uint64_t udebug_buf_flags(struct udebug_buf *buf);
void udebug_buf_free(struct udebug_buf *buf);
struct udebug_remote_buf *udebug_remote_buf_get(struct udebug *ctx, uint32_t id);
int udebug_remote_buf_map(struct udebug *ctx, struct udebug_remote_buf *rb, uint32_t id);
void udebug_remote_buf_unmap(struct udebug *ctx, struct udebug_remote_buf *rb);
int udebug_remote_buf_set_poll(struct udebug *ctx, struct udebug_remote_buf *rb, bool val);
void udebug_remote_buf_set_flags(struct udebug_remote_buf *rb, uint64_t mask, uint64_t set);
struct udebug_snapshot *udebug_remote_buf_snapshot(struct udebug_remote_buf *rb);
bool udebug_snapshot_get_entry(struct udebug_snapshot *s, struct udebug_iter *it, unsigned int entry);
void udebug_remote_buf_set_start_time(struct udebug_remote_buf *rb, uint64_t ts);
void udebug_remote_buf_set_start_offset(struct udebug_remote_buf *rb, uint32_t idx);
void udebug_iter_start(struct udebug_iter *it, struct udebug_snapshot **s, size_t n);
bool udebug_iter_next(struct udebug_iter *it);
void udebug_init(struct udebug *ctx);
int udebug_connect(struct udebug *ctx, const char *path);
void udebug_auto_connect(struct udebug *ctx, const char *path);
void udebug_add_uloop(struct udebug *ctx);
void udebug_poll(struct udebug *ctx);
void udebug_free(struct udebug *ctx);
static inline bool udebug_is_connected(struct udebug *ctx)
{
return ctx->fd.fd >= 0;
}
int udebug_id_cmp(const void *k1, const void *k2, void *ptr);
#endif