lib-remote.c

   1 #include "priv.h"
   2
   3 static struct udebug_client_msg *
   4 send_and_wait(struct udebug *ctx, struct udebug_client_msg *msg, int *rfd)
   5 {
   6         int type = msg->type;
   7         int fd = -1;
   8
   9         udebug_send_msg(ctx, msg, NULL, -1);
  10
  11         do {
  12                 if (fd >= 0)
  13                         close(fd);
  14                 fd = -1;
  15                 msg = __udebug_poll(ctx, &fd, true);
  16         } while (msg && msg->type != type);
  17         if (!msg)
  18                 return NULL;
  19
  20         if (rfd)
  21                 *rfd = fd;
  22         else if (fd >= 0)
  23                 close(fd);
  24
  25         return msg;
  26 }
  27
  28 static int
  29 udebug_remote_get_handle(struct udebug *ctx)
  30 {
  31         struct udebug_client_msg *msg;
  32         struct udebug_client_msg send_msg = {
  33                 .type = CL_MSG_GET_HANDLE,
  34         };
  35
  36         if (ctx->poll_handle >= 0 || !udebug_is_connected(ctx))
  37                 return 0;
  38
  39         msg = send_and_wait(ctx, &send_msg, NULL);
  40         if (!msg)
  41                 return -1;
  42
  43         ctx->poll_handle = msg->id;
  44         return 0;
  45 }
  46
  47 struct udebug_remote_buf *udebug_remote_buf_get(struct udebug *ctx, uint32_t id)
  48 {
  49         struct udebug_remote_buf *rb;
  50         void *key = (void *)(uintptr_t)id;
  51
  52         return avl_find_element(&ctx->remote_rings, key, rb, node);
  53 }
  54
  55 int udebug_remote_buf_map(struct udebug *ctx, struct udebug_remote_buf *rb, uint32_t id)
  56 {
  57         void *key = (void *)(uintptr_t)id;
  58         struct udebug_client_msg *msg;
  59         struct udebug_client_msg send_msg = {
  60                 .type = CL_MSG_RING_GET,
  61                 .id = id,
  62         };
  63         int fd = -1;
  64
  65         if (rb->buf.data || !udebug_is_connected(ctx))
  66                 return -1;
  67
  68         msg = send_and_wait(ctx, &send_msg, &fd);
  69         if (!msg || fd < 0)
  70                 return -1;
  71
  72         if (udebug_buf_open(&rb->buf, fd, msg->ring_size, msg->data_size)) {
  73                 close(fd);
  74                 return -1;
  75         }
  76
  77         rb->pcap_iface = ~0;
  78         rb->node.key = key;
  79         avl_insert(&ctx->remote_rings, &rb->node);
  80
  81         return 0;
  82 }
  83
  84 void udebug_remote_buf_unmap(struct udebug *ctx, struct udebug_remote_buf *rb)
  85 {
  86         if (!rb->buf.data)
  87                 return;
  88
  89         avl_delete(&ctx->remote_rings, &rb->node);
  90         udebug_buf_free(&rb->buf);
  91         rb->poll = 0;
  92         rb->node.key = NULL;
  93         rb->pcap_iface = ~0;
  94 }
  95
  96 int udebug_remote_buf_set_poll(struct udebug *ctx, struct udebug_remote_buf *rb, bool val)
  97 {
  98         int handle;
  99
 100         if (!rb->buf.data)
 101                 return -1;
 102
 103         if (rb->poll == val)
 104                 return 0;
 105
 106         rb->poll = val;
 107         if (!val)
 108                 return 0;
 109
 110         handle = udebug_remote_get_handle(ctx);
 111         if (handle < 0)
 112                 return -1;
 113
 114         __atomic_fetch_or(&rb->buf.hdr->notify, 1UL << handle, __ATOMIC_RELAXED);
 115         return 0;
 116 }
 117
 118 static void
 119 rbuf_advance_read_head(struct udebug_remote_buf *rb, uint32_t head,
 120                        uint32_t *data_start)
 121 {
 122         struct udebug_hdr *hdr = rb->buf.hdr;
 123         uint32_t min_head = head + 1 - rb->buf.ring_size;
 124         uint32_t min_data = u32_get(&hdr->data_used) - rb->buf.data_size;
 125         struct udebug_ptr *last_ptr = udebug_ring_ptr(hdr, head - 1);
 126
 127         if (!u32_get(&hdr->head_hi) && u32_sub(0, min_head) > 0)
 128                 min_head = 0;
 129
 130         /* advance head to skip over any entries that are guaranteed
 131          * to be overwritten now. final check will be performed after
 132          * data copying */
 133
 134         if (u32_sub(rb->head, min_head) < 0)
 135                 rb->head = min_head;
 136
 137         for (size_t i = 0; i < rb->buf.ring_size; i++) {
 138                 struct udebug_ptr *ptr = udebug_ring_ptr(hdr, rb->head);
 139
 140                 if (data_start) {
 141                         *data_start = u32_get(&ptr->start);
 142                         __sync_synchronize();
 143                 }
 144
 145                 if (ptr->timestamp > last_ptr->timestamp)
 146                         continue;
 147
 148                 if (u32_sub(ptr->start, min_data) > 0)
 149                         break;
 150
 151                 rb->head++;
 152         }
 153 }
 154
 155 void udebug_remote_buf_set_start_time(struct udebug_remote_buf *rb, uint64_t ts)
 156 {
 157         struct udebug_hdr *hdr = rb->buf.hdr;
 158         uint32_t head = u32_get(&hdr->head);
 159         uint32_t start = rb->head, end = head;
 160         uint32_t diff;
 161
 162         if (!hdr)
 163                 return;
 164
 165         rbuf_advance_read_head(rb, head, NULL);
 166         while ((diff = u32_sub(end, start)) > 0) {
 167                 uint32_t cur = start + diff / 2;
 168                 struct udebug_ptr *ptr;
 169
 170                 ptr = udebug_ring_ptr(hdr, cur);
 171                 if (ptr->timestamp > ts)
 172                         end = cur - 1;
 173                 else
 174                         start = cur + 1;
 175         }
 176
 177         rb->head = start;
 178 }
 179
 180 void udebug_remote_buf_set_start_offset(struct udebug_remote_buf *rb, uint32_t idx)
 181 {
 182         if (!rb->buf.hdr)
 183                 return;
 184
 185         rb->head = rb->buf.hdr->head - idx;
 186 }
 187
 188 void udebug_remote_buf_set_flags(struct udebug_remote_buf *rb, uint64_t mask, uint64_t set)
 189 {
 190         struct udebug_hdr *hdr = rb->buf.hdr;
 191
 192         if (!hdr)
 193                 return;
 194
 195         if ((uintptr_t)mask)
 196                 __atomic_and_fetch(&hdr->flags[0], (uintptr_t)~mask, __ATOMIC_RELAXED);
 197         if ((uintptr_t)set)
 198                 __atomic_or_fetch(&hdr->flags[0], (uintptr_t)set, __ATOMIC_RELAXED);
 199
 200         if (sizeof(mask) == sizeof(unsigned long))
 201                 return;
 202
 203         mask >>= 32;
 204         if ((uintptr_t)mask)
 205                 __atomic_and_fetch(&hdr->flags[1], (uintptr_t)~mask, __ATOMIC_RELAXED);
 206         if ((uintptr_t)set)
 207                 __atomic_or_fetch(&hdr->flags[1], (uintptr_t)set, __ATOMIC_RELAXED);
 208 }
 209
 210 struct udebug_snapshot *
 211 udebug_remote_buf_snapshot(struct udebug_remote_buf *rb)
 212 {
 213         struct udebug_hdr *hdr = rb->buf.hdr;
 214         struct udebug_ptr *last_ptr;
 215         uint32_t data_start, data_end, data_used;
 216         struct udebug_snapshot *s = NULL;
 217         struct udebug_ptr *ptr_buf, *first_ptr;
 218         uint32_t data_size, ptr_size;
 219         uint32_t head, first_idx;
 220         uint32_t prev_read_head = rb->head;
 221         void *data_buf;
 222
 223         if (!hdr)
 224                 return NULL;
 225
 226         head = u32_get(&hdr->head);
 227         rbuf_advance_read_head(rb, head, &data_start);
 228         if (rb->head == head)
 229                 return NULL;
 230
 231         first_idx = rb->head;
 232         first_ptr = udebug_ring_ptr(hdr, first_idx);
 233         last_ptr = udebug_ring_ptr(hdr, head - 1);
 234         data_end = last_ptr->start + last_ptr->len;
 235
 236         data_size = data_end - data_start;
 237         ptr_size = head - rb->head;
 238         if (data_size > rb->buf.data_size || ptr_size > rb->buf.ring_size) {
 239                 fprintf(stderr, "Invalid data size: %x > %x, %x > %x\n", data_size, (int)rb->buf.data_size, ptr_size, (int)rb->buf.ring_size);
 240                 goto out;
 241         }
 242
 243         s = calloc_a(sizeof(*s),
 244                      &ptr_buf, ptr_size * sizeof(*ptr_buf),
 245                      &data_buf, data_size);
 246
 247         s->data = memcpy(data_buf, udebug_buf_ptr(&rb->buf, data_start), data_size);
 248         s->data_size = data_size;
 249         s->entries = ptr_buf;
 250         s->dropped = rb->head - prev_read_head;
 251
 252         if (first_ptr > last_ptr) {
 253                 struct udebug_ptr *start_ptr = udebug_ring_ptr(hdr, 0);
 254                 struct udebug_ptr *end_ptr = udebug_ring_ptr(hdr, rb->buf.ring_size - 1) + 1;
 255                 uint32_t size = end_ptr - first_ptr;
 256                 memcpy(s->entries, first_ptr, size * sizeof(*s->entries));
 257                 memcpy(s->entries + size, start_ptr, (last_ptr + 1 - start_ptr) * sizeof(*s->entries));
 258         } else {
 259                 memcpy(s->entries, first_ptr, (last_ptr + 1 - first_ptr) * sizeof(*s->entries));
 260         }
 261
 262         /* get a snapshot of the counter that indicates how much data has been
 263          * clobbered by newly added entries */
 264         __sync_synchronize();
 265         data_used = u32_get(&hdr->data_used) - rb->buf.data_size;
 266
 267         s->n_entries = head - first_idx;
 268
 269         rbuf_advance_read_head(rb, head, NULL);
 270         if (s->n_entries < rb->head - first_idx) {
 271                 free(s);
 272                 s = NULL;
 273                 goto out;
 274         }
 275
 276         s->entries += rb->head - first_idx;
 277         s->n_entries -= rb->head - first_idx;
 278         while (s->n_entries > 0 &&
 279                u32_sub(s->entries[0].start, data_used) < 0) {
 280                 s->entries++;
 281                 s->n_entries--;
 282                 s->dropped++;
 283         }
 284
 285         for (size_t i = 0; i < s->n_entries; i++)
 286                 s->entries[i].start -= data_start;
 287
 288         s->format = hdr->format;
 289         s->sub_format = hdr->sub_format;
 290         s->rbuf_idx = (uint32_t)(uintptr_t)rb->node.key;
 291
 292 out:
 293         rb->head = head;
 294         return s;
 295 }
 296
 297 bool udebug_snapshot_get_entry(struct udebug_snapshot *s, struct udebug_iter *it, unsigned int entry)
 298 {
 299         struct udebug_ptr *ptr;
 300
 301         it->len = 0;
 302         if (entry >= s->n_entries)
 303                 goto error;
 304
 305         ptr = &s->entries[entry];
 306         if (ptr->start > s->data_size || ptr->len > s->data_size ||
 307             ptr->start + ptr->len > s->data_size)
 308                 goto error;
 309
 310         it->s = s;
 311         it->data = s->data + ptr->start;
 312         it->len = ptr->len;
 313         it->timestamp = ptr->timestamp;
 314         return true;
 315
 316 error:
 317         it->data = NULL;
 318         return false;
 319 }
 320
 321 void udebug_iter_start(struct udebug_iter *it, struct udebug_snapshot **s, size_t n)
 322 {
 323         memset(it, 0, sizeof(*it));
 324
 325         it->list = s;
 326         it->n = n;
 327
 328         for (size_t i = 0; i < it->n; i++)
 329                 it->list[i]->iter_idx = 0;
 330 }
 331
 332 bool udebug_iter_next(struct udebug_iter *it)
 333 {
 334         while (1) {
 335                 struct udebug_snapshot *s;
 336                 uint64_t cur_ts;
 337                 int cur = -1;
 338
 339                 for (size_t i = 0; i < it->n; i++) {
 340                         struct udebug_ptr *ptr;
 341
 342                         s = it->list[i];
 343                         if (s->iter_idx >= s->n_entries)
 344                                 continue;
 345
 346                         ptr = &s->entries[s->iter_idx];
 347                         if (cur >= 0 && ptr->timestamp > cur_ts)
 348                                 continue;
 349
 350                         cur = i;
 351                         cur_ts = ptr->timestamp;
 352                 }
 353
 354                 if (cur < 0)
 355                         return false;
 356
 357                 s = it->list[cur];
 358                 it->s_idx = cur;
 359                 if (!udebug_snapshot_get_entry(s, it, s->iter_idx++))
 360                         continue;
 361
 362                 return true;
 363         }
 364 }