udebug.h File Reference

#include <sys/types.h>
#include <stdint.h>
#include <stdarg.h>
#include "list.h"
#include "uloop.h"
#include "avl.h"

Go to the source code of this file.

Data Structures
struct	udebug_buf_flag
struct	udebug_buf_meta
struct	udebug_buf
struct	udebug_packet_info
struct	udebug_remote_buf
struct	udebug
struct	udebug_ptr
struct	udebug_snapshot
struct	udebug_iter

Macros
#define	UDEBUG_SOCK_NAME   "/var/run/udebug.sock"
#define	UDEBUG_TS_MSEC   1000ULL
#define	UDEBUG_TS_SEC   (1000ULL * UDEBUG_TS_MSEC)

Enumerations
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 }

Functions
uint64_t	udebug_timestamp (void)
void	udebug_entry_init_ts (struct udebug_buf *buf, uint64_t timestamp)
static void	udebug_entry_init (struct udebug_buf *buf)
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
int int	udebug_entry_vprintf (struct udebug_buf *buf, const char *fmt, va_list ap) __attribute__((format(printf
int int uint16_t	udebug_entry_trim (struct udebug_buf *buf, uint16_t len)
void	udebug_entry_set_length (struct udebug_buf *buf, uint16_t len)
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)
static bool	udebug_buf_valid (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 bool	udebug_is_connected (struct udebug *ctx)
int	udebug_id_cmp (const void *k1, const void *k2, void *ptr)

Macro Definition Documentation

UDEBUG_SOCK_NAME

#define UDEBUG_SOCK_NAME   "/var/run/udebug.sock"

Definition at line 29 of file udebug.h.

UDEBUG_TS_MSEC

#define UDEBUG_TS_MSEC   1000ULL

Definition at line 52 of file udebug.h.

UDEBUG_TS_SEC

#define UDEBUG_TS_SEC   (1000ULL * UDEBUG_TS_MSEC)

Definition at line 53 of file udebug.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
UDEBUG_DLT_ETHERNET
UDEBUG_DLT_PPP
UDEBUG_DLT_RAW_IP
UDEBUG_DLT_IEEE_802_11
UDEBUG_DLT_IEEE_802_11_RADIOTAP
UDEBUG_DLT_NETLINK

Definition at line 37 of file udebug.h.

     {
        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,
};

udebug_format

enum udebug_format

Enumerator
UDEBUG_FORMAT_PACKET
UDEBUG_FORMAT_STRING
UDEBUG_FORMAT_BLOBMSG

Definition at line 31 of file udebug.h.

                   {
        UDEBUG_FORMAT_PACKET,
        UDEBUG_FORMAT_STRING,
        UDEBUG_FORMAT_BLOBMSG,
};

udebug_meta_type

enum udebug_meta_type

Enumerator
UDEBUG_META_IFACE_NAME
UDEBUG_META_IFACE_DESC
__UDEBUG_META_MAX

Definition at line 46 of file udebug.h.

                      {
        UDEBUG_META_IFACE_NAME,
        UDEBUG_META_IFACE_DESC,
        __UDEBUG_META_MAX
};

Function Documentation

udebug_add_uloop()

void udebug_add_uloop

(

struct udebug *

ctx

)

Definition at line 827 of file udebug.c.

{
        if (ctx->fd.registered)
                return;
 
        ctx->fd.cb = udebug_fd_cb;
        uloop_fd_add(&ctx->fd, ULOOP_READ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_auto_connect()

void udebug_auto_connect	(	struct udebug *	ctx,
		const char *	path
	)

Definition at line 763 of file udebug.c.

{
        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);
}

Here is the call graph for this function:

udebug_buf_add()

int udebug_buf_add	(	struct udebug *	ctx,
		struct udebug_buf *	buf,
		const struct udebug_buf_meta *	meta
	)

Definition at line 724 of file udebug.c.

{
        if (!buf->hdr)
                return -1;
 
        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;
}

Here is the call graph for this function:

udebug_buf_flags()

uint64_t udebug_buf_flags

(

struct udebug_buf *

buf

)

Definition at line 516 of file udebug.c.

{
        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;
}

udebug_buf_free()

void udebug_buf_free

(

struct udebug_buf *

buf

)

Definition at line 681 of file udebug.c.

{
        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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_buf_init()

int udebug_buf_init	(	struct udebug_buf *	buf,
		size_t	entries,
		size_t	size
	)

Definition at line 450 of file udebug.c.

{
        char filename[] = "/udebug.XXXXXX";
        unsigned int order = 12;
        uint8_t ring_order = 5;
        size_t head_size;
        int fd;
 
        udebug_init_page_size();
        INIT_LIST_HEAD(&buf->list);
        if (size < page_size)
                size = page_size;
        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);
        while (ALIGN(sizeof(*buf->hdr) + (entries * 2) * sizeof(struct udebug_ptr), page_size) == 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;
 
        if (__udebug_buf_map(buf, fd))
                goto err_close;
 
        buf->fd = fd;
        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;
}

Here is the call graph for this function:

udebug_buf_valid()

static bool udebug_buf_valid ( struct udebug_buf *  buf )

inlinestatic

Definition at line 169 of file udebug.h.

{
        return buf->hdr;
}

udebug_connect()

int udebug_connect	(	struct udebug *	ctx,
		const char *	path
	)

Definition at line 774 of file udebug.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_entry_add()

void udebug_entry_add

(

struct udebug_buf *

buf

)

Definition at line 642 of file udebug.c.

{
        struct udebug_hdr *hdr = buf->hdr;
        struct udebug_ptr *ptr;
        uint32_t notify;
        uint8_t *data;
 
        if (!hdr)
                return;
 
        ptr = udebug_ring_ptr(hdr, hdr->head);
 
        /* 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);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_entry_append()

void* udebug_entry_append	(	struct udebug_buf *	buf,
		const void *	data,
		uint32_t	len
	)

Definition at line 545 of file udebug.c.

{
        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;
}

Here is the call graph for this function:

udebug_entry_init()

static void udebug_entry_init ( struct udebug_buf *  buf )

inlinestatic

Definition at line 151 of file udebug.h.

{
        udebug_entry_init_ts(buf, udebug_timestamp());
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_entry_init_ts()

void udebug_entry_init_ts	(	struct udebug_buf *	buf,
		uint64_t	timestamp
	)

Definition at line 531 of file udebug.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_entry_printf()

int udebug_entry_printf	(	struct udebug_buf *	buf,
		const char *	fmt,
			...
	)

udebug_entry_set_length()

void udebug_entry_set_length	(	struct udebug_buf *	buf,
		uint16_t	len
	)

Definition at line 583 of file udebug.c.

{
        struct udebug_hdr *hdr = buf->hdr;
        struct udebug_ptr *ptr;
 
        if (!hdr)
                return;
 
        ptr = udebug_ring_ptr(hdr, hdr->head);
        ptr->len = len;
}

Here is the call graph for this function:

udebug_entry_trim()

int int uint16_t udebug_entry_trim	(	struct udebug_buf *	buf,
		uint16_t	len
	)

Definition at line 568 of file udebug.c.

{
        struct udebug_hdr *hdr = buf->hdr;
        struct udebug_ptr *ptr;
 
        if (!hdr)
                return 0;
 
        ptr = udebug_ring_ptr(hdr, hdr->head);
        if (len)
                ptr->len -= len;
 
        return ptr->len;
}

Here is the call graph for this function:

udebug_entry_vprintf()

int int udebug_entry_vprintf	(	struct udebug_buf *	buf,
		const char *	fmt,
		va_list	ap
	)

udebug_free()

void udebug_free

(

struct udebug *

ctx

)

Definition at line 836 of file udebug.c.

{
        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);
}

Here is the call graph for this function:

udebug_id_cmp()

int udebug_id_cmp	(	const void *	k1,
		const void *	k2,
		void *	ptr
	)

Definition at line 54 of file udebug.c.

{
        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;
}

Here is the caller graph for this function:

udebug_init()

void udebug_init

(

struct udebug *

ctx

)

Definition at line 743 of file udebug.c.

{
        INIT_LIST_HEAD(&ctx->local_rings);
        avl_init(&ctx->remote_rings, udebug_id_cmp, true, NULL);
        ctx->fd.fd = -1;
        ctx->poll_handle = -1;
}

Here is the call graph for this function:

udebug_is_connected()

static bool udebug_is_connected ( struct udebug *  ctx )

inlinestatic

Definition at line 195 of file udebug.h.

{
        return ctx->fd.fd >= 0;
}

Here is the caller graph for this function:

udebug_iter_next()

bool udebug_iter_next

(

struct udebug_iter *

it

)

Definition at line 325 of file udebug-remote.c.

{
        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;
        }
}

Here is the call graph for this function:

udebug_iter_start()

void udebug_iter_start	(	struct udebug_iter *	it,
		struct udebug_snapshot **	s,
		size_t	n
	)

Definition at line 314 of file udebug-remote.c.

{
        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;
}

udebug_poll()

void udebug_poll

(

struct udebug *

ctx

)

Definition at line 804 of file udebug.c.

{
        while (__udebug_poll(ctx, NULL, false));
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_remote_buf_get()

struct udebug_remote_buf* udebug_remote_buf_get	(	struct udebug *	ctx,
		uint32_t	id
	)

Definition at line 39 of file udebug-remote.c.

{
        struct udebug_remote_buf *rb;
        void *key = (void *)(uintptr_t)id;
 
        return avl_find_element(&ctx->remote_rings, key, rb, node);
}

udebug_remote_buf_map()

int udebug_remote_buf_map	(	struct udebug *	ctx,
		struct udebug_remote_buf *	rb,
		uint32_t	id
	)

Definition at line 47 of file udebug-remote.c.

{
        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 = udebug_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;
}

Here is the call graph for this function:

udebug_remote_buf_set_flags()

void udebug_remote_buf_set_flags	(	struct udebug_remote_buf *	rb,
		uint64_t	mask,
		uint64_t	set
	)

Definition at line 181 of file udebug-remote.c.

{
        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);
}

udebug_remote_buf_set_poll()

int udebug_remote_buf_set_poll	(	struct udebug *	ctx,
		struct udebug_remote_buf *	rb,
		bool	val
	)

Definition at line 89 of file udebug-remote.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_remote_buf_set_start_offset()

void udebug_remote_buf_set_start_offset	(	struct udebug_remote_buf *	rb,
		uint32_t	idx
	)

Definition at line 173 of file udebug-remote.c.

{
        if (!rb->buf.hdr)
                return;
 
        rb->head = rb->buf.hdr->head - idx;
}

udebug_remote_buf_set_start_time()

void udebug_remote_buf_set_start_time	(	struct udebug_remote_buf *	rb,
		uint64_t	ts
	)

Definition at line 148 of file udebug-remote.c.

{
        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;
}

Here is the call graph for this function:

udebug_remote_buf_snapshot()

struct udebug_snapshot* udebug_remote_buf_snapshot

(

struct udebug_remote_buf *

rb

)

Definition at line 204 of file udebug-remote.c.

{
        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;
}

Here is the call graph for this function:

udebug_remote_buf_unmap()

void udebug_remote_buf_unmap	(	struct udebug *	ctx,
		struct udebug_remote_buf *	rb
	)

Definition at line 77 of file udebug-remote.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udebug_snapshot_get_entry()

bool udebug_snapshot_get_entry	(	struct udebug_snapshot *	s,
		struct udebug_iter *	it,
		unsigned int	entry
	)

Definition at line 290 of file udebug-remote.c.

{
        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;
}

Here is the caller graph for this function:

udebug_timestamp()

uint64_t udebug_timestamp

(

void

)

Definition at line 101 of file udebug.c.

{
        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;
}

Here is the caller graph for this function: