src/common/event.cpp

   1 /*
   2  * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #include "common/compat/string.h"
   9 #include "common/macros.h"
  10 #include "lttng/lttng-error.h"
  11 #include <assert.h>
  12 #include <common/buffer-view.h>
  13 #include <common/dynamic-array.h>
  14 #include <common/dynamic-buffer.h>
  15 #include <common/error.h>
  16 #include <common/sessiond-comm/sessiond-comm.h>
  17 #include <common/align.h>
  18 #include <lttng/constant.h>
  19 #include <lttng/event-internal.h>
  20 #include <lttng/event.h>
  21 #include <lttng/userspace-probe-internal.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 struct event_list_element {
  26         struct lttng_event *event;
  27         struct lttng_event_exclusion *exclusions;
  28         char *filter_expression;
  29 };
  30
  31 static void event_list_destructor(void *ptr)
  32 {
  33         struct event_list_element *element = (struct event_list_element *) ptr;
  34
  35         free(element->filter_expression);
  36         free(element->exclusions);
  37         lttng_event_destroy(element->event);
  38         free(element);
  39 }
  40
  41 struct lttng_event *lttng_event_copy(const struct lttng_event *event)
  42 {
  43         struct lttng_event *new_event;
  44         struct lttng_event_extended *new_event_extended;
  45
  46         new_event = (lttng_event *) zmalloc(sizeof(*event));
  47         if (!new_event) {
  48                 PERROR("Error allocating event structure");
  49                 goto end;
  50         }
  51
  52         /* Copy the content of the old event. */
  53         memcpy(new_event, event, sizeof(*event));
  54
  55         /*
  56          * We need to create a new extended since the previous pointer is now
  57          * invalid.
  58          */
  59         new_event_extended = (lttng_event_extended *) zmalloc(sizeof(*new_event_extended));
  60         if (!new_event_extended) {
  61                 PERROR("Error allocating event extended structure");
  62                 goto error;
  63         }
  64
  65         new_event->extended.ptr = new_event_extended;
  66 end:
  67         return new_event;
  68 error:
  69         free(new_event);
  70         new_event = NULL;
  71         goto end;
  72 }
  73
  74 static int lttng_event_probe_attr_serialize(
  75                 const struct lttng_event_probe_attr *probe,
  76                 struct lttng_payload *payload)
  77 {
  78         int ret;
  79         size_t symbol_name_len;
  80         struct lttng_event_probe_attr_comm comm = {};
  81
  82         symbol_name_len = lttng_strnlen(
  83                         probe->symbol_name, sizeof(probe->symbol_name));
  84         if (symbol_name_len == sizeof(probe->symbol_name)) {
  85                 /* Not null-termintated. */
  86                 ret = -1;
  87                 goto end;
  88         }
  89
  90         /* Include the null terminator. */
  91         symbol_name_len += 1;
  92
  93         comm.symbol_name_len = (uint32_t) symbol_name_len;
  94         comm.addr = probe->addr;
  95         comm.offset = probe->addr;
  96
  97         ret = lttng_dynamic_buffer_append(
  98                         &payload->buffer, &comm, sizeof(comm));
  99         if (ret < 0) {
 100                 ret = -1;
 101                 goto end;
 102         }
 103
 104         ret = lttng_dynamic_buffer_append(
 105                         &payload->buffer, probe->symbol_name, symbol_name_len);
 106 end:
 107         return ret;
 108 }
 109
 110 static int lttng_event_function_attr_serialize(
 111                 const struct lttng_event_function_attr *function,
 112                 struct lttng_payload *payload)
 113 {
 114         int ret;
 115         size_t symbol_name_len;
 116         struct lttng_event_function_attr_comm comm = { 0 };
 117
 118         symbol_name_len = lttng_strnlen(
 119                         function->symbol_name, sizeof(function->symbol_name));
 120         if (symbol_name_len == sizeof(function->symbol_name)) {
 121                 /* Not null-termintated. */
 122                 ret = -1;
 123                 goto end;
 124         }
 125
 126         /* Include the null terminator. */
 127         symbol_name_len += 1;
 128
 129         comm.symbol_name_len = (uint32_t) symbol_name_len;
 130
 131         ret = lttng_dynamic_buffer_append(
 132                         &payload->buffer, &comm, sizeof(comm));
 133         if (ret < 0) {
 134                 ret = -1;
 135                 goto end;
 136         }
 137
 138         ret = lttng_dynamic_buffer_append(&payload->buffer,
 139                         function->symbol_name, symbol_name_len);
 140 end:
 141         return ret;
 142 }
 143
 144 static ssize_t lttng_event_probe_attr_create_from_payload(
 145                 struct lttng_payload_view *view,
 146                 struct lttng_event_probe_attr **probe_attr)
 147 {
 148         ssize_t ret, offset = 0;
 149         const struct lttng_event_probe_attr_comm *comm;
 150         struct lttng_event_probe_attr *local_attr = NULL;
 151         struct lttng_payload_view comm_view = lttng_payload_view_from_view(
 152                         view, offset, sizeof(*comm));
 153
 154         if (!lttng_payload_view_is_valid(&comm_view)) {
 155                 ret = -1;
 156                 goto end;
 157         }
 158
 159         comm = (typeof(comm)) comm_view.buffer.data;
 160         offset += sizeof(*comm);
 161
 162         local_attr = (struct lttng_event_probe_attr *) zmalloc(
 163                         sizeof(*local_attr));
 164         if (local_attr == NULL) {
 165                 ret = -1;
 166                 goto end;
 167         }
 168
 169         local_attr->addr = comm->addr;
 170         local_attr->offset = comm->offset;
 171
 172         {
 173                 const char *name;
 174                 struct lttng_payload_view name_view =
 175                                 lttng_payload_view_from_view(view, offset,
 176                                                 comm->symbol_name_len);
 177
 178                 if (!lttng_payload_view_is_valid(&name_view)) {
 179                         ret = -1;
 180                         goto end;
 181                 }
 182
 183                 name = name_view.buffer.data;
 184
 185                 if (!lttng_buffer_view_contains_string(&name_view.buffer, name,
 186                                     comm->symbol_name_len)) {
 187                         ret = -1;
 188                         goto end;
 189                 }
 190
 191                 ret = lttng_strncpy(local_attr->symbol_name, name,
 192                                 sizeof(local_attr->symbol_name));
 193                 if (ret) {
 194                         ret = -1;
 195                         goto end;
 196                 }
 197
 198                 offset += comm->symbol_name_len;
 199         }
 200
 201         *probe_attr = local_attr;
 202         local_attr = NULL;
 203         ret = offset;
 204 end:
 205         free(local_attr);
 206         return ret;
 207 }
 208
 209 static ssize_t lttng_event_function_attr_create_from_payload(
 210                 struct lttng_payload_view *view,
 211                 struct lttng_event_function_attr **function_attr)
 212 {
 213         ssize_t ret, offset = 0;
 214         const struct lttng_event_function_attr_comm *comm;
 215         struct lttng_event_function_attr *local_attr = NULL;
 216         struct lttng_payload_view comm_view = lttng_payload_view_from_view(
 217                         view, offset, sizeof(*comm));
 218
 219         if (!lttng_payload_view_is_valid(&comm_view)) {
 220                 ret = -1;
 221                 goto end;
 222         }
 223
 224         comm = (typeof(comm)) view->buffer.data;
 225         offset += sizeof(*comm);
 226
 227         local_attr = (struct lttng_event_function_attr *) zmalloc(
 228                         sizeof(*local_attr));
 229         if (local_attr == NULL) {
 230                 ret = -1;
 231                 goto end;
 232         }
 233
 234         {
 235                 const char *name;
 236                 struct lttng_payload_view name_view =
 237                                 lttng_payload_view_from_view(view, offset,
 238                                                 comm->symbol_name_len);
 239
 240                 if (!lttng_payload_view_is_valid(&name_view)) {
 241                         ret = -1;
 242                         goto end;
 243                 }
 244
 245                 name = name_view.buffer.data;
 246
 247                 if (!lttng_buffer_view_contains_string(&name_view.buffer, name,
 248                                     comm->symbol_name_len)) {
 249                         ret = -1;
 250                         goto end;
 251                 }
 252
 253                 ret = lttng_strncpy(local_attr->symbol_name, name,
 254                                 sizeof(local_attr->symbol_name));
 255                 if (ret) {
 256                         ret = -1;
 257                         goto end;
 258                 }
 259
 260                 offset += comm->symbol_name_len;
 261         }
 262
 263         *function_attr = local_attr;
 264         local_attr = NULL;
 265         ret = offset;
 266 end:
 267         free(local_attr);
 268         return ret;
 269 }
 270
 271 static ssize_t lttng_event_exclusions_create_from_payload(
 272                 struct lttng_payload_view *view,
 273                 uint32_t count,
 274                 struct lttng_event_exclusion **exclusions)
 275 {
 276         ssize_t ret, offset = 0;
 277         size_t size = (count * LTTNG_SYMBOL_NAME_LEN);
 278         uint32_t i;
 279         const struct lttng_event_exclusion_comm *comm;
 280         struct lttng_event_exclusion *local_exclusions;
 281
 282         local_exclusions = (struct lttng_event_exclusion *) zmalloc(
 283                         sizeof(struct lttng_event_exclusion) + size);
 284         if (!local_exclusions) {
 285                 ret = -1;
 286                 goto end;
 287         }
 288
 289         local_exclusions->count = count;
 290
 291         for (i = 0; i < count; i++) {
 292                 const char *string;
 293                 struct lttng_buffer_view string_view;
 294                 const struct lttng_buffer_view comm_view =
 295                                 lttng_buffer_view_from_view(&view->buffer,
 296                                                 offset, sizeof(*comm));
 297
 298                 if (!lttng_buffer_view_is_valid(&comm_view)) {
 299                         ret = -1;
 300                         goto end;
 301                 }
 302
 303                 comm = (typeof(comm)) comm_view.data;
 304                 offset += sizeof(*comm);
 305
 306                 string_view = lttng_buffer_view_from_view(
 307                                 &view->buffer, offset, comm->len);
 308
 309                 if (!lttng_buffer_view_is_valid(&string_view)) {
 310                         ret = -1;
 311                         goto end;
 312                 }
 313
 314                 string = string_view.data;
 315
 316                 if (!lttng_buffer_view_contains_string(
 317                                     &string_view, string, comm->len)) {
 318                         ret = -1;
 319                         goto end;
 320                 }
 321
 322                 ret = lttng_strncpy(local_exclusions->names[i], string,
 323                                 sizeof(local_exclusions->names[i]));
 324                 if (ret) {
 325                         ret = -1;
 326                         goto end;
 327                 }
 328
 329                 offset += comm->len;
 330         }
 331
 332         *exclusions = local_exclusions;
 333         local_exclusions = NULL;
 334         ret = offset;
 335 end:
 336         free(local_exclusions);
 337         return ret;
 338 }
 339
 340 ssize_t lttng_event_create_from_payload(struct lttng_payload_view *view,
 341                 struct lttng_event **out_event,
 342                 struct lttng_event_exclusion **out_exclusion,
 343                 char **out_filter_expression,
 344                 struct lttng_bytecode **out_bytecode)
 345 {
 346         ssize_t ret, offset = 0;
 347         struct lttng_event *local_event = NULL;
 348         struct lttng_event_exclusion *local_exclusions = NULL;
 349         struct lttng_bytecode *local_bytecode = NULL;
 350         char *local_filter_expression = NULL;
 351         const struct lttng_event_comm *event_comm;
 352         struct lttng_event_function_attr *local_function_attr = NULL;
 353         struct lttng_event_probe_attr *local_probe_attr = NULL;
 354         struct lttng_userspace_probe_location *local_userspace_probe_location =
 355                         NULL;
 356
 357         /*
 358          * Only event is obligatory, the other output argument are optional and
 359          * depends on what the caller is interested in.
 360          */
 361         assert(out_event);
 362         assert(view);
 363
 364         {
 365                 struct lttng_payload_view comm_view =
 366                                 lttng_payload_view_from_view(view, offset,
 367                                                 sizeof(*event_comm));
 368
 369                 if (!lttng_payload_view_is_valid(&comm_view)) {
 370                         ret = -1;
 371                         goto end;
 372                 }
 373
 374                 /* lttng_event_comm header */
 375                 event_comm = (typeof(event_comm)) comm_view.buffer.data;
 376                 offset += sizeof(*event_comm);
 377         }
 378
 379         local_event = lttng_event_create();
 380         if (local_event == NULL) {
 381                 ret = -1;
 382                 goto end;
 383         }
 384
 385         local_event->type = (enum lttng_event_type) event_comm->event_type;
 386         local_event->loglevel_type = (enum lttng_loglevel_type) event_comm->loglevel_type;
 387         local_event->loglevel = event_comm->loglevel;
 388         local_event->enabled = event_comm->enabled;
 389         local_event->pid = event_comm->pid;
 390         local_event->flags = (enum lttng_event_flag) event_comm->flags;
 391
 392         {
 393                 const char *name;
 394                 const struct lttng_buffer_view name_view =
 395                                 lttng_buffer_view_from_view(&view->buffer,
 396                                                 offset, event_comm->name_len);
 397
 398                 if (!lttng_buffer_view_is_valid(&name_view)) {
 399                         ret = -1;
 400                         goto end;
 401                 }
 402
 403                 name = (const char *) name_view.data;
 404
 405                 if (!lttng_buffer_view_contains_string(
 406                                     &name_view, name, event_comm->name_len)) {
 407                         ret = -1;
 408                         goto end;
 409                 }
 410
 411                 ret = lttng_strncpy(local_event->name, name,
 412                                 sizeof(local_event->name));
 413                 if (ret) {
 414                         ret = -1;
 415                         goto end;
 416                 }
 417
 418                 offset += event_comm->name_len;
 419         }
 420
 421         /* Exclusions */
 422         if (event_comm->exclusion_count == 0) {
 423                 goto deserialize_filter_expression;
 424         }
 425
 426         {
 427                 struct lttng_payload_view exclusions_view =
 428                                 lttng_payload_view_from_view(
 429                                                 view, offset, -1);
 430
 431                 if (!lttng_payload_view_is_valid(&exclusions_view)) {
 432                         ret = -1;
 433                         goto end;
 434                 }
 435
 436                 ret = lttng_event_exclusions_create_from_payload(&exclusions_view,
 437                                 event_comm->exclusion_count, &local_exclusions);
 438                 if (ret < 0) {
 439                         ret = -1;
 440                         goto end;
 441                 }
 442                 offset += ret;
 443
 444                 local_event->exclusion = 1;
 445         }
 446
 447 deserialize_filter_expression:
 448
 449         if (event_comm->filter_expression_len == 0) {
 450                 if (event_comm->bytecode_len != 0) {
 451                         /*
 452                          * This is an invalid event payload.
 453                          *
 454                          * Filter expression without bytecode is possible but
 455                          * not the other way around.
 456                          * */
 457                         ret = -1;
 458                         goto end;
 459                 }
 460                 goto deserialize_event_type_payload;
 461         }
 462
 463         {
 464                 const char *filter_expression_buffer;
 465                 struct lttng_buffer_view filter_expression_view =
 466                                 lttng_buffer_view_from_view(&view->buffer, offset,
 467                                                 event_comm->filter_expression_len);
 468
 469                 if (!lttng_buffer_view_is_valid(&filter_expression_view)) {
 470                         ret = -1;
 471                         goto end;
 472                 }
 473
 474                 filter_expression_buffer = filter_expression_view.data;
 475
 476                 if (!lttng_buffer_view_contains_string(&filter_expression_view,
 477                                     filter_expression_buffer,
 478                                     event_comm->filter_expression_len)) {
 479                         ret = -1;
 480                         goto end;
 481                 }
 482
 483                 local_filter_expression = lttng_strndup(
 484                                 filter_expression_buffer,
 485                                 event_comm->filter_expression_len);
 486                 if (!local_filter_expression) {
 487                         ret = -1;
 488                         goto end;
 489                 }
 490
 491                 local_event->filter = 1;
 492
 493                 offset += event_comm->filter_expression_len;
 494         }
 495
 496         if (event_comm->bytecode_len == 0) {
 497                 /*
 498                  * Filter expression can be present but without bytecode
 499                  * when dealing with event listing.
 500                  */
 501                 goto deserialize_event_type_payload;
 502         }
 503
 504         /* Bytecode */
 505         {
 506                 struct lttng_payload_view bytecode_view =
 507                                 lttng_payload_view_from_view(view, offset,
 508                                                 event_comm->bytecode_len);
 509
 510                 if (!lttng_payload_view_is_valid(&bytecode_view)) {
 511                         ret = -1;
 512                         goto end;
 513                 }
 514
 515                 local_bytecode = (struct lttng_bytecode *) zmalloc(
 516                                 event_comm->bytecode_len);
 517                 if (!local_bytecode) {
 518                         ret = -1;
 519                         goto end;
 520                 }
 521
 522                 memcpy(local_bytecode, bytecode_view.buffer.data,
 523                                 event_comm->bytecode_len);
 524                 if ((local_bytecode->len + sizeof(*local_bytecode)) !=
 525                                 event_comm->bytecode_len) {
 526                         ret = -1;
 527                         goto end;
 528                 }
 529
 530                 offset += event_comm->bytecode_len;
 531         }
 532
 533 deserialize_event_type_payload:
 534         /* Event type specific payload */
 535         switch (local_event->type) {
 536         case LTTNG_EVENT_FUNCTION:
 537                 /* Fallthrough */
 538         case LTTNG_EVENT_PROBE:
 539         {
 540                 struct lttng_payload_view probe_attr_view =
 541                                 lttng_payload_view_from_view(view, offset,
 542                                                 event_comm->lttng_event_probe_attr_len);
 543
 544                 if (event_comm->lttng_event_probe_attr_len == 0) {
 545                         ret = -1;
 546                         goto end;
 547                 }
 548
 549                 if (!lttng_payload_view_is_valid(&probe_attr_view)) {
 550                         ret = -1;
 551                         goto end;
 552                 }
 553
 554                 ret = lttng_event_probe_attr_create_from_payload(
 555                                 &probe_attr_view, &local_probe_attr);
 556                 if (ret < 0 || ret != event_comm->lttng_event_probe_attr_len) {
 557                         ret = -1;
 558                         goto end;
 559                 }
 560
 561                 /* Copy to the local event. */
 562                 memcpy(&local_event->attr.probe, local_probe_attr,
 563                                 sizeof(local_event->attr.probe));
 564
 565                 offset += ret;
 566                 break;
 567         }
 568         case LTTNG_EVENT_FUNCTION_ENTRY:
 569         {
 570                 struct lttng_payload_view function_attr_view =
 571                                 lttng_payload_view_from_view(view, offset,
 572                                                 event_comm->lttng_event_function_attr_len);
 573
 574                 if (event_comm->lttng_event_function_attr_len == 0) {
 575                         ret = -1;
 576                         goto end;
 577                 }
 578
 579                 if (!lttng_payload_view_is_valid(&function_attr_view)) {
 580                         ret = -1;
 581                         goto end;
 582                 }
 583
 584                 ret = lttng_event_function_attr_create_from_payload(
 585                                 &function_attr_view, &local_function_attr);
 586                 if (ret < 0 || ret != event_comm->lttng_event_function_attr_len) {
 587                         ret = -1;
 588                         goto end;
 589                 }
 590
 591                 /* Copy to the local event. */
 592                 memcpy(&local_event->attr.ftrace, local_function_attr,
 593                                 sizeof(local_event->attr.ftrace));
 594
 595                 offset += ret;
 596
 597                 break;
 598         }
 599         case LTTNG_EVENT_USERSPACE_PROBE:
 600         {
 601                 struct lttng_payload_view userspace_probe_location_view =
 602                                 lttng_payload_view_from_view(view, offset,
 603                                                 event_comm->userspace_probe_location_len);
 604
 605                 if (event_comm->userspace_probe_location_len == 0) {
 606                         ret = -1;
 607                         goto end;
 608                 }
 609
 610                 if (!lttng_payload_view_is_valid(
 611                                     &userspace_probe_location_view)) {
 612                         ret = -1;
 613                         goto end;
 614                 }
 615
 616                 ret = lttng_userspace_probe_location_create_from_payload(
 617                                 &userspace_probe_location_view,
 618                                 &local_userspace_probe_location);
 619                 if (ret < 0) {
 620                         WARN("Failed to create a userspace probe location from the received buffer");
 621                         ret = -1;
 622                         goto end;
 623                 }
 624
 625                 if (ret != event_comm->userspace_probe_location_len) {
 626                         WARN("Userspace probe location from the received buffer is not the advertised length: header length = %" PRIu32 ", payload length = %zd", event_comm->userspace_probe_location_len, ret);
 627                         ret = -1;
 628                         goto end;
 629                 }
 630
 631                 /* Attach the probe location to the event. */
 632                 ret = lttng_event_set_userspace_probe_location(
 633                                 local_event, local_userspace_probe_location);
 634                 if (ret) {
 635                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 636                         goto end;
 637                 }
 638
 639                 /*
 640                  * Userspace probe location object ownership transfered to the
 641                  * event object.
 642                  */
 643                 local_userspace_probe_location = NULL;
 644                 offset += event_comm->userspace_probe_location_len;
 645                 break;
 646         }
 647         case LTTNG_EVENT_TRACEPOINT:
 648                 /* Fallthrough */
 649         case LTTNG_EVENT_ALL:
 650                 /* Fallthrough */
 651         case LTTNG_EVENT_SYSCALL:
 652                 /* Fallthrough */
 653         case LTTNG_EVENT_NOOP:
 654                 /* Nothing to do here */
 655                 break;
 656         default:
 657                 ret = LTTNG_ERR_UND;
 658                 goto end;
 659                 break;
 660         }
 661
 662         /* Transfer ownership to the caller. */
 663         *out_event = local_event;
 664         local_event = NULL;
 665
 666         if (out_bytecode) {
 667                 *out_bytecode = local_bytecode;
 668                 local_bytecode = NULL;
 669         }
 670
 671         if (out_exclusion) {
 672                 *out_exclusion = local_exclusions;
 673                 local_exclusions = NULL;
 674         }
 675
 676         if (out_filter_expression) {
 677                 *out_filter_expression = local_filter_expression;
 678                 local_filter_expression = NULL;
 679         }
 680
 681         ret = offset;
 682 end:
 683         lttng_event_destroy(local_event);
 684         lttng_userspace_probe_location_destroy(local_userspace_probe_location);
 685         free(local_filter_expression);
 686         free(local_exclusions);
 687         free(local_bytecode);
 688         free(local_function_attr);
 689         free(local_probe_attr);
 690         return ret;
 691 }
 692
 693 int lttng_event_serialize(const struct lttng_event *event,
 694                 unsigned int exclusion_count,
 695                 char **exclusion_list,
 696                 char *filter_expression,
 697                 size_t bytecode_len,
 698                 struct lttng_bytecode *bytecode,
 699                 struct lttng_payload *payload)
 700 {
 701         int ret;
 702         unsigned int i;
 703         size_t header_offset, size_before_payload;
 704         size_t name_len;
 705         struct lttng_event_comm event_comm = {};
 706         struct lttng_event_comm *header;
 707
 708         assert(event);
 709         assert(payload);
 710         assert(exclusion_count == 0 || exclusion_list);
 711
 712         /* Save the header location for later in-place header update. */
 713         header_offset = payload->buffer.size;
 714
 715         name_len = lttng_strnlen(event->name, sizeof(event->name));
 716         if (name_len == sizeof(event->name)) {
 717                 /* Event name is not NULL-terminated. */
 718                 ret = -1;
 719                 goto end;
 720         }
 721
 722         /* Add null termination. */
 723         name_len += 1;
 724
 725         if (exclusion_count > UINT32_MAX) {
 726                 /* Possible overflow. */
 727                 ret = -1;
 728                 goto end;
 729         }
 730
 731         if (bytecode_len > UINT32_MAX) {
 732                 /* Possible overflow. */
 733                 ret = -1;
 734                 goto end;
 735         }
 736
 737         event_comm.name_len = (uint32_t) name_len;
 738         event_comm.event_type = (int8_t) event->type;
 739         event_comm.loglevel_type = (int8_t) event->loglevel_type;
 740         event_comm.loglevel = (int32_t) event->loglevel;
 741         event_comm.enabled = (int8_t) event->enabled;
 742         event_comm.pid = (int32_t) event->pid;
 743         event_comm.exclusion_count = (uint32_t) exclusion_count;
 744         event_comm.bytecode_len = (uint32_t) bytecode_len;
 745         event_comm.flags = (int32_t) event->flags;
 746
 747         if (filter_expression) {
 748                 event_comm.filter_expression_len =
 749                                 strlen(filter_expression) + 1;
 750         }
 751
 752         /* Header */
 753         ret = lttng_dynamic_buffer_append(
 754                         &payload->buffer, &event_comm, sizeof(event_comm));
 755         if (ret) {
 756                 goto end;
 757         }
 758
 759         /* Event name */
 760         ret = lttng_dynamic_buffer_append(
 761                         &payload->buffer, event->name, name_len);
 762         if (ret) {
 763                 goto end;
 764         }
 765
 766         /* Exclusions */
 767         for (i = 0; i < exclusion_count; i++) {
 768                 const size_t exclusion_len = lttng_strnlen(
 769                                 *(exclusion_list + i), LTTNG_SYMBOL_NAME_LEN);
 770                 const struct lttng_event_exclusion_comm exclusion_header = {
 771                         .len = (uint32_t) exclusion_len + 1,
 772                 };
 773
 774                 if (exclusion_len == LTTNG_SYMBOL_NAME_LEN) {
 775                         /* Exclusion is not NULL-terminated. */
 776                         ret = -1;
 777                         goto end;
 778                 }
 779
 780                 ret = lttng_dynamic_buffer_append(&payload->buffer,
 781                                 &exclusion_header, sizeof(exclusion_header));
 782                 if (ret) {
 783                         goto end;
 784                 }
 785
 786                 ret = lttng_dynamic_buffer_append(&payload->buffer,
 787                                 *(exclusion_list + i), exclusion_len + 1);
 788                 if (ret) {
 789                         goto end;
 790                 }
 791         }
 792
 793         /* Filter expression and its bytecode */
 794         if (filter_expression) {
 795                 ret = lttng_dynamic_buffer_append(&payload->buffer,
 796                                 filter_expression,
 797                                 event_comm.filter_expression_len);
 798                 if (ret) {
 799                         goto end;
 800                 }
 801
 802                 /*
 803                  * Bytecode can be absent when we serialize to the client
 804                  * for listing.
 805                  */
 806                 if (bytecode) {
 807                         ret = lttng_dynamic_buffer_append(&payload->buffer,
 808                                         bytecode, bytecode_len);
 809                         if (ret) {
 810                                 goto end;
 811                         }
 812                 }
 813         }
 814
 815         size_before_payload = payload->buffer.size;
 816
 817         /* Event type specific payload */
 818         switch (event->type) {
 819         case LTTNG_EVENT_FUNCTION:
 820                 /* Fallthrough */
 821         case LTTNG_EVENT_PROBE:
 822                 ret = lttng_event_probe_attr_serialize(&event->attr.probe, payload);
 823                 if (ret) {
 824                         ret = -1;
 825                         goto end;
 826                 }
 827
 828                 header = (struct lttng_event_comm *) ((char *) payload->buffer.data +
 829                                                       header_offset);
 830                 header->lttng_event_probe_attr_len =
 831                                 payload->buffer.size - size_before_payload;
 832
 833                 break;
 834         case LTTNG_EVENT_FUNCTION_ENTRY:
 835                 ret = lttng_event_function_attr_serialize(
 836                                 &event->attr.ftrace, payload);
 837                 if (ret) {
 838                         ret = -1;
 839                         goto end;
 840                 }
 841
 842                 /* Update the lttng_event_function_attr len. */
 843                 header = (struct lttng_event_comm *) ((char *) payload->buffer.data +
 844                                                       header_offset);
 845                 header->lttng_event_function_attr_len =
 846                                 payload->buffer.size - size_before_payload;
 847
 848                 break;
 849         case LTTNG_EVENT_USERSPACE_PROBE:
 850         {
 851                 const struct lttng_event_extended *ev_ext =
 852                                 (const struct lttng_event_extended *)
 853                                                 event->extended.ptr;
 854
 855                 assert(event->extended.ptr);
 856                 assert(ev_ext->probe_location);
 857
 858                 size_before_payload = payload->buffer.size;
 859                 if (ev_ext->probe_location) {
 860                         /*
 861                          * lttng_userspace_probe_location_serialize returns the
 862                          * number of bytes that were appended to the buffer.
 863                          */
 864                         ret = lttng_userspace_probe_location_serialize(
 865                                         ev_ext->probe_location, payload);
 866                         if (ret < 0) {
 867                                 goto end;
 868                         }
 869
 870                         ret = 0;
 871
 872                         /* Update the userspace probe location len. */
 873                         header = (struct lttng_event_comm *) ((char *) payload->buffer.data +
 874                                                               header_offset);
 875                         header->userspace_probe_location_len =
 876                                         payload->buffer.size - size_before_payload;
 877                 }
 878                 break;
 879         }
 880         case LTTNG_EVENT_TRACEPOINT:
 881                 /* Fallthrough */
 882         case LTTNG_EVENT_ALL:
 883                 /* Fallthrough */
 884         default:
 885                 /* Nothing to do here. */
 886                 break;
 887         }
 888
 889 end:
 890         return ret;
 891 }
 892
 893 static ssize_t lttng_event_context_app_populate_from_payload(
 894                 const struct lttng_payload_view *view,
 895                 struct lttng_event_context *event_ctx)
 896 {
 897         ssize_t ret, offset = 0;
 898         const struct lttng_event_context_app_comm *comm;
 899         char *provider_name = NULL, *context_name = NULL;
 900         size_t provider_name_len, context_name_len;
 901         const struct lttng_buffer_view comm_view = lttng_buffer_view_from_view(
 902                         &view->buffer, offset, sizeof(*comm));
 903
 904         assert(event_ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
 905
 906         if (!lttng_buffer_view_is_valid(&comm_view)) {
 907                 ret = -1;
 908                 goto end;
 909         }
 910
 911         comm = (typeof(comm)) comm_view.data;
 912         offset += sizeof(*comm);
 913
 914         provider_name_len = comm->provider_name_len;
 915         context_name_len = comm->ctx_name_len;
 916
 917         if (provider_name_len == 0 || context_name_len == 0) {
 918                 /*
 919                  * Application provider and context names MUST
 920                  * be provided.
 921                  */
 922                 ret = -1;
 923                 goto end;
 924         }
 925
 926         {
 927                 const char *name;
 928                 const struct lttng_buffer_view provider_name_view =
 929                                 lttng_buffer_view_from_view(&view->buffer,
 930                                                 offset,
 931                                                 provider_name_len);
 932
 933                 if (!lttng_buffer_view_is_valid(&provider_name_view)) {
 934                         ret = -1;
 935                         goto end;
 936                 }
 937
 938                 name = provider_name_view.data;
 939
 940                 if (!lttng_buffer_view_contains_string(&provider_name_view,
 941                                 name, provider_name_len)) {
 942                         ret = -1;
 943                         goto end;
 944                 }
 945
 946                 provider_name = lttng_strndup(name, provider_name_len);
 947                 if (!provider_name) {
 948                         ret = -1;
 949                         goto end;
 950                 }
 951
 952                 offset += provider_name_len;
 953         }
 954
 955         {
 956                 const char *name;
 957                 const struct lttng_buffer_view context_name_view =
 958                                 lttng_buffer_view_from_view(
 959                                                 &view->buffer, offset,
 960                                                 context_name_len);
 961
 962                 if (!lttng_buffer_view_is_valid(&context_name_view)) {
 963                         ret = -1;
 964                         goto end;
 965                 }
 966
 967                 name = context_name_view.data;
 968
 969                 if (!lttng_buffer_view_contains_string(&context_name_view, name,
 970                                     context_name_len)) {
 971                         ret = -1;
 972                         goto end;
 973                 }
 974
 975                 context_name = lttng_strndup(name, context_name_len);
 976                 if (!context_name) {
 977                         ret = -1;
 978                         goto end;
 979                 }
 980
 981                 offset += context_name_len;
 982         }
 983
 984         /* Transfer ownership of the strings */
 985         event_ctx->u.app_ctx.provider_name = provider_name;
 986         event_ctx->u.app_ctx.ctx_name = context_name;
 987         provider_name = NULL;
 988         context_name = NULL;
 989
 990         ret = offset;
 991 end:
 992         free(provider_name);
 993         free(context_name);
 994
 995         return ret;
 996 }
 997
 998 static ssize_t lttng_event_context_perf_counter_populate_from_payload(
 999                 const struct lttng_payload_view *view,
1000                 struct lttng_event_context *event_ctx)
1001 {
1002         int ret;
1003         ssize_t consumed, offset = 0;
1004         const struct lttng_event_context_perf_counter_comm *comm;
1005         size_t name_len;
1006         const struct lttng_buffer_view comm_view = lttng_buffer_view_from_view(
1007                         &view->buffer, offset, sizeof(*comm));
1008
1009         assert(event_ctx->ctx == LTTNG_EVENT_CONTEXT_PERF_COUNTER ||
1010                         event_ctx->ctx ==
1011                                         LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER ||
1012                         event_ctx->ctx == LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER);
1013
1014         if (!lttng_buffer_view_is_valid(&comm_view)) {
1015                 consumed = -1;
1016                 goto end;
1017         }
1018
1019         comm = (typeof(comm)) comm_view.data;
1020         offset += sizeof(*comm);
1021
1022         name_len = comm->name_len;
1023
1024         {
1025                 const char *name;
1026                 const struct lttng_buffer_view provider_name_view =
1027                                 lttng_buffer_view_from_view(
1028                                                 &view->buffer, offset,
1029                                                 name_len);
1030
1031                 if (!lttng_buffer_view_is_valid(&provider_name_view)) {
1032                         consumed = -1;
1033                         goto end;
1034                 }
1035
1036                 name = provider_name_view.data;
1037
1038                 if (!lttng_buffer_view_contains_string(
1039                                     &provider_name_view, name, name_len)) {
1040                         consumed = -1;
1041                         goto end;
1042                 }
1043
1044                 ret = lttng_strncpy(event_ctx->u.perf_counter.name, name, name_len);
1045                 if (ret) {
1046                         consumed = -1;
1047                         goto end;
1048                 }
1049                 offset += name_len;
1050         }
1051
1052         event_ctx->u.perf_counter.config = comm->config;
1053         event_ctx->u.perf_counter.type = comm->type;
1054
1055         consumed = offset;
1056
1057 end:
1058         return consumed;
1059 }
1060
1061 ssize_t lttng_event_context_create_from_payload(
1062                 struct lttng_payload_view *view,
1063                 struct lttng_event_context **event_ctx)
1064 {
1065         ssize_t ret, offset = 0;
1066         const struct lttng_event_context_comm *comm;
1067         struct lttng_event_context *local_context = NULL;
1068         struct lttng_buffer_view comm_view = lttng_buffer_view_from_view(
1069                         &view->buffer, offset, sizeof(*comm));
1070
1071         assert(event_ctx);
1072         assert(view);
1073
1074         if (!lttng_buffer_view_is_valid(&comm_view)) {
1075                 ret = -1;
1076                 goto end;
1077         }
1078
1079         comm = (typeof(comm)) comm_view.data;
1080         offset += sizeof(*comm);
1081
1082         local_context = (struct lttng_event_context *)
1083                         zmalloc(sizeof(*local_context));
1084         if (!local_context) {
1085                 ret = -1;
1086                 goto end;
1087         }
1088
1089         local_context->ctx = (lttng_event_context_type) comm->type;
1090
1091         {
1092                 struct lttng_payload_view subtype_view =
1093                                 lttng_payload_view_from_view(view, offset, -1);
1094
1095                 switch (local_context->ctx) {
1096                 case LTTNG_EVENT_CONTEXT_APP_CONTEXT:
1097                         ret = lttng_event_context_app_populate_from_payload(
1098                                         &subtype_view, local_context);
1099                         break;
1100                 case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
1101                 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
1102                 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
1103                         ret = lttng_event_context_perf_counter_populate_from_payload(
1104                                         &subtype_view, local_context);
1105                         break;
1106                 default:
1107                         /* Nothing else to deserialize. */
1108                         ret = 0;
1109                         break;
1110                 }
1111         }
1112
1113         if (ret < 0) {
1114                 goto end;
1115         }
1116
1117         offset += ret;
1118
1119         *event_ctx = local_context;
1120         local_context = NULL;
1121         ret = offset;
1122
1123 end:
1124         free(local_context);
1125         return ret;
1126 }
1127
1128 static int lttng_event_context_app_serialize(
1129                 struct lttng_event_context *context,
1130                 struct lttng_payload *payload)
1131 {
1132         int ret;
1133         struct lttng_event_context_app_comm comm = {};
1134         size_t provider_len, ctx_len;
1135         const char *provider_name;
1136         const char *ctx_name;
1137
1138         assert(payload);
1139         assert(context);
1140         assert(context->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
1141
1142         provider_name = context->u.app_ctx.provider_name;
1143         ctx_name = context->u.app_ctx.ctx_name;
1144
1145         if (!provider_name || !ctx_name) {
1146                 ret = -LTTNG_ERR_INVALID;
1147                 goto end;
1148         }
1149
1150         provider_len = strlen(provider_name);
1151         if (provider_len == 0) {
1152                 ret = -LTTNG_ERR_INVALID;
1153                 goto end;
1154         }
1155
1156         /* Include the null terminator. */
1157         provider_len += 1;
1158         comm.provider_name_len = provider_len;
1159
1160         ctx_len = strlen(ctx_name);
1161         if (ctx_len == 0) {
1162                 ret = -LTTNG_ERR_INVALID;
1163                 goto end;
1164         }
1165
1166         /* Include the null terminator. */
1167         ctx_len += 1;
1168         comm.ctx_name_len = ctx_len;
1169
1170         /* Header */
1171         ret = lttng_dynamic_buffer_append(&payload->buffer, &comm,
1172                         sizeof(comm));
1173         if (ret) {
1174                 ret = -1;
1175                 goto end;
1176         }
1177
1178         ret = lttng_dynamic_buffer_append(&payload->buffer, provider_name,
1179                         provider_len);
1180         if (ret) {
1181                 ret = -1;
1182                 goto end;
1183         }
1184
1185         ret = lttng_dynamic_buffer_append(&payload->buffer, ctx_name,
1186                         ctx_len);
1187         if (ret) {
1188                 ret = -1;
1189                 goto end;
1190         }
1191
1192 end:
1193         return ret;
1194 }
1195
1196 static int lttng_event_context_perf_counter_serialize(
1197                 struct lttng_event_perf_counter_ctx *context,
1198                 struct lttng_payload *payload)
1199 {
1200         int ret;
1201         struct lttng_event_context_perf_counter_comm comm = {};
1202
1203         assert(payload);
1204         assert(context);
1205
1206         comm.config = context->config;
1207         comm.type = context->type;
1208         comm.name_len = lttng_strnlen(context->name, sizeof(context->name));
1209
1210         if (comm.name_len == sizeof(context->name)) {
1211                 ret = -1;
1212                 goto end;
1213         }
1214
1215         /* Include the null terminator. */
1216         comm.name_len += 1;
1217
1218         /* Header */
1219         ret = lttng_dynamic_buffer_append(&payload->buffer, &comm,
1220                         sizeof(comm));
1221         if (ret) {
1222                 ret = -1;
1223                 goto end;
1224         }
1225
1226         ret = lttng_dynamic_buffer_append(&payload->buffer, context->name,
1227                         comm.name_len);
1228         if (ret) {
1229                 ret = -1;
1230                 goto end;
1231         }
1232
1233 end:
1234         return ret;
1235 }
1236
1237 int lttng_event_context_serialize(struct lttng_event_context *context,
1238                 struct lttng_payload *payload)
1239 {
1240         int ret;
1241         struct lttng_event_context_comm context_comm = { 0 };
1242
1243         assert(context);
1244         assert(payload);
1245
1246         context_comm.type = (uint32_t) context->ctx;
1247
1248         /* Header */
1249         ret = lttng_dynamic_buffer_append(
1250                         &payload->buffer, &context_comm, sizeof(context_comm));
1251         if (ret) {
1252                 goto end;
1253         }
1254
1255         switch (context->ctx) {
1256         case LTTNG_EVENT_CONTEXT_APP_CONTEXT:
1257                 ret = lttng_event_context_app_serialize(context, payload);
1258                 break;
1259         case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
1260         case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
1261         case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
1262                 ret = lttng_event_context_perf_counter_serialize(
1263                                 &context->u.perf_counter, payload);
1264                 break;
1265         default:
1266                 /* Nothing else to serialize. */
1267                 break;
1268         }
1269
1270         if (ret) {
1271                 goto end;
1272         }
1273
1274 end:
1275         return ret;
1276 }
1277
1278 void lttng_event_context_destroy(struct lttng_event_context *context)
1279 {
1280         if (!context) {
1281                 return;
1282         }
1283
1284         if (context->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
1285                 free(context->u.app_ctx.provider_name);
1286                 free(context->u.app_ctx.ctx_name);
1287         }
1288
1289         free(context);
1290 }
1291
1292 /*
1293  * This is a specialized populate for lttng_event_field since it ignores
1294  * the extension field of the lttng_event struct and simply copies what it can
1295  * to the internal struct lttng_event of a lttng_event_field.
1296  */
1297 static void lttng_event_field_populate_lttng_event_from_event(
1298                 const struct lttng_event *src, struct lttng_event *destination)
1299 {
1300         memcpy(destination, src, sizeof(*destination));
1301
1302         /* Remove all possible dynamic data from the destination event rule. */
1303         destination->extended.ptr = NULL;
1304 }
1305
1306 ssize_t lttng_event_field_create_from_payload(
1307                 struct lttng_payload_view *view,
1308                 struct lttng_event_field **field)
1309 {
1310         ssize_t ret, offset = 0;
1311         struct lttng_event_field *local_event_field = NULL;
1312         struct lttng_event *event = NULL;
1313         const struct lttng_event_field_comm *comm;
1314         const char* name = NULL;
1315
1316         assert(field);
1317         assert(view);
1318
1319         {
1320                 const struct lttng_buffer_view comm_view =
1321                                 lttng_buffer_view_from_view(
1322                                                 &view->buffer, offset,
1323                                                 sizeof(*comm));
1324
1325                 if (!lttng_buffer_view_is_valid(&comm_view)) {
1326                         ret = -1;
1327                         goto end;
1328                 }
1329
1330                 /* lttng_event_field_comm header */
1331                 comm = (const lttng_event_field_comm *) comm_view.data;
1332                 offset += sizeof(*comm);
1333         }
1334
1335         local_event_field = (struct lttng_event_field *)
1336                         zmalloc(sizeof(*local_event_field));
1337         if (!local_event_field) {
1338                 ret = -1;
1339                 goto end;
1340         }
1341
1342         local_event_field->type = (lttng_event_field_type) comm->type;
1343         local_event_field->nowrite = comm->nowrite;
1344
1345         /* Field name */
1346         {
1347                 const struct lttng_buffer_view name_view =
1348                                 lttng_buffer_view_from_view(
1349                                                 &view->buffer, offset,
1350                                                 comm->name_len);
1351
1352                 if (!lttng_buffer_view_is_valid(&name_view)) {
1353                         ret = -1;
1354                         goto end;
1355                 }
1356
1357                 name = name_view.data;
1358
1359                 if (!lttng_buffer_view_contains_string(&name_view,
1360                                 name_view.data, comm->name_len)) {
1361                         ret = -1;
1362                         goto end;
1363                 }
1364
1365                 if (comm->name_len > LTTNG_SYMBOL_NAME_LEN - 1) {
1366                         /* Name is too long.*/
1367                         ret = -1;
1368                         goto end;
1369                 }
1370
1371                 offset += comm->name_len;
1372         }
1373
1374         /* Event */
1375         {
1376                 struct lttng_payload_view event_view =
1377                                 lttng_payload_view_from_view(
1378                                                 view, offset,
1379                                                 comm->event_len);
1380
1381                 if (!lttng_payload_view_is_valid(&event_view)) {
1382                         ret = -1;
1383                         goto end;
1384                 }
1385
1386                 ret = lttng_event_create_from_payload(&event_view, &event, NULL,
1387                                 NULL, NULL);
1388                 if (ret != comm->event_len) {
1389                         ret = -1;
1390                         goto end;
1391                 }
1392
1393                 offset += ret;
1394         }
1395
1396         assert(name);
1397         assert(event);
1398
1399         if (lttng_strncpy(local_event_field->field_name, name,
1400                         sizeof(local_event_field->field_name))) {
1401                 ret = -1;
1402                 goto end;
1403         }
1404
1405         lttng_event_field_populate_lttng_event_from_event(
1406                         event, &local_event_field->event);
1407
1408         *field = local_event_field;
1409         local_event_field = NULL;
1410         ret = offset;
1411 end:
1412         lttng_event_destroy(event);
1413         free(local_event_field);
1414         return ret;
1415 }
1416
1417 int lttng_event_field_serialize(const struct lttng_event_field *field,
1418                 struct lttng_payload *payload)
1419 {
1420         int ret;
1421         size_t header_offset, size_before_event;
1422         size_t name_len;
1423         struct lttng_event_field_comm event_field_comm = {};
1424         struct lttng_event_field_comm *header;
1425
1426         assert(field);
1427         assert(payload);
1428
1429         /* Save the header location for later in-place header update. */
1430         header_offset = payload->buffer.size;
1431
1432         name_len = strnlen(field->field_name, sizeof(field->field_name));
1433         if (name_len == sizeof(field->field_name)) {
1434                 /* Event name is not NULL-terminated. */
1435                 ret = -1;
1436                 goto end;
1437         }
1438
1439         /* Add null termination. */
1440         name_len += 1;
1441
1442         event_field_comm.type = field->type;
1443         event_field_comm.nowrite = (uint8_t)field->nowrite;
1444         event_field_comm.name_len = name_len;
1445
1446         /* Header */
1447         ret = lttng_dynamic_buffer_append(
1448                         &payload->buffer, &event_field_comm,
1449                         sizeof(event_field_comm));
1450         if (ret) {
1451                 goto end;
1452         }
1453
1454         /* Field name */
1455         ret = lttng_dynamic_buffer_append(&payload->buffer, field->field_name,
1456                         name_len);
1457         if (ret) {
1458                 goto end;
1459         }
1460
1461         size_before_event = payload->buffer.size;
1462         ret = lttng_event_serialize(
1463                         &field->event, 0, NULL, NULL, 0, 0, payload);
1464         if (ret) {
1465                 ret = -1;
1466                 goto end;
1467         }
1468
1469         /* Update the event len. */
1470         header = (struct lttng_event_field_comm *)
1471                         ((char *) payload->buffer.data +
1472                                 header_offset);
1473         header->event_len = payload->buffer.size - size_before_event;
1474
1475 end:
1476         return ret;
1477 }
1478
1479 static enum lttng_error_code compute_flattened_size(
1480                 struct lttng_dynamic_pointer_array *events, size_t *size)
1481 {
1482         enum lttng_error_code ret_code;
1483         int ret = 0;
1484         size_t storage_req, event_count, i;
1485
1486         assert(size);
1487         assert(events);
1488
1489         event_count = lttng_dynamic_pointer_array_get_count(events);
1490
1491         /* The basic struct lttng_event */
1492         storage_req = event_count * sizeof(struct lttng_event);
1493
1494         /* The struct·lttng_event_extended */
1495         storage_req += event_count * sizeof(struct lttng_event_extended);
1496
1497         for (i = 0; i < event_count; i++) {
1498                 int probe_storage_req = 0;
1499                 const struct event_list_element *element = (const struct event_list_element *)
1500                                 lttng_dynamic_pointer_array_get_pointer(
1501                                                 events, i);
1502                 const struct lttng_userspace_probe_location *location = NULL;
1503
1504                 location = lttng_event_get_userspace_probe_location(
1505                                 element->event);
1506                 if (location) {
1507                         ret = lttng_userspace_probe_location_flatten(
1508                                         location, NULL);
1509                         if (ret < 0) {
1510                                 ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL;
1511                                 goto end;
1512                         }
1513
1514                         probe_storage_req = ret;
1515                 }
1516
1517                 if (element->filter_expression) {
1518                         storage_req += strlen(element->filter_expression) + 1;
1519                 }
1520
1521                 if (element->exclusions) {
1522                         storage_req += element->exclusions->count *
1523                                 LTTNG_SYMBOL_NAME_LEN;
1524                 }
1525
1526                 /* Padding to ensure the flat probe is aligned. */
1527                 storage_req = lttng_align_ceil(storage_req, sizeof(uint64_t));
1528                 storage_req += probe_storage_req;
1529         }
1530
1531         *size = storage_req;
1532         ret_code = LTTNG_OK;
1533
1534 end:
1535         return ret_code;
1536 }
1537
1538 /*
1539  * Flatten a list of struct lttng_event.
1540  *
1541  * The buffer that is returned to the API client  must contain a "flat" version
1542  * of the events that are returned. In other words, all pointers within an
1543  * lttng_event must point to a location within the returned buffer so that the
1544  * user may free everything by simply calling free() on the returned buffer.
1545  * This is needed in order to maintain API compatibility.
1546  *
1547  * A first pass is performed to compute the size of the buffer that must be
1548  * allocated. A second pass is then performed to setup the returned events so
1549  * that their members always point within the buffer.
1550  *
1551  * The layout of the returned buffer is as follows:
1552  *   - struct lttng_event[nb_events],
1553  *   - nb_events times the following:
1554  *     - struct lttng_event_extended,
1555  *     - filter_expression
1556  *     - exclusions
1557  *     - padding to align to 64-bits
1558  *     - flattened version of userspace_probe_location
1559  */
1560 static enum lttng_error_code flatten_lttng_events(
1561                 struct lttng_dynamic_pointer_array *events,
1562                 struct lttng_event **flattened_events)
1563 {
1564         enum lttng_error_code ret_code;
1565         int ret, i;
1566         size_t storage_req;
1567         struct lttng_dynamic_buffer local_flattened_events;
1568         int nb_events;
1569
1570         assert(events);
1571         assert(flattened_events);
1572
1573         lttng_dynamic_buffer_init(&local_flattened_events);
1574         nb_events = lttng_dynamic_pointer_array_get_count(events);
1575
1576         ret_code = compute_flattened_size(events, &storage_req);
1577         if (ret_code != LTTNG_OK) {
1578                 goto end;
1579         }
1580
1581         /*
1582          * We must ensure that "local_flattened_events" is never resized so as
1583          * to preserve the validity of the flattened objects.
1584          */
1585         ret = lttng_dynamic_buffer_set_capacity(
1586                         &local_flattened_events, storage_req);
1587         if (ret) {
1588                 ret_code = LTTNG_ERR_NOMEM;
1589                 goto end;
1590         }
1591
1592         /* Start by laying the struct lttng_event */
1593         for (i = 0; i < nb_events; i++) {
1594                 const struct event_list_element *element = (const struct event_list_element *)
1595                                 lttng_dynamic_pointer_array_get_pointer(
1596                                                 events, i);
1597
1598                 if (!element) {
1599                         ret_code = LTTNG_ERR_FATAL;
1600                         goto end;
1601                 }
1602
1603                 ret = lttng_dynamic_buffer_append(&local_flattened_events,
1604                                 element->event, sizeof(struct lttng_event));
1605                 if (ret) {
1606                         ret_code = LTTNG_ERR_NOMEM;
1607                         goto end;
1608                 }
1609         }
1610
1611         for (i = 0; i < nb_events; i++) {
1612                 const struct event_list_element *element = (const struct event_list_element *)
1613                                 lttng_dynamic_pointer_array_get_pointer(events, i);
1614                 struct lttng_event *event = (struct lttng_event *)
1615                         (local_flattened_events.data + (sizeof(struct lttng_event) * i));
1616                 struct lttng_event_extended *event_extended =
1617                         (struct lttng_event_extended *)
1618                                 (local_flattened_events.data + local_flattened_events.size);
1619                 const struct lttng_userspace_probe_location *location = NULL;
1620
1621                 assert(element);
1622
1623                 /* Insert struct lttng_event_extended. */
1624                 ret = lttng_dynamic_buffer_set_size(&local_flattened_events,
1625                                 local_flattened_events.size +
1626                                                 sizeof(*event_extended));
1627                 if (ret) {
1628                         ret_code = LTTNG_ERR_NOMEM;
1629                         goto end;
1630                 }
1631                 event->extended.ptr = event_extended;
1632
1633                 /* Insert filter expression. */
1634                 if (element->filter_expression) {
1635                         const size_t len = strlen(element->filter_expression) + 1;
1636
1637                         event_extended->filter_expression =
1638                                         local_flattened_events.data +
1639                                         local_flattened_events.size;
1640                         ret = lttng_dynamic_buffer_append(
1641                                         &local_flattened_events,
1642                                         element->filter_expression, len);
1643                         if (ret) {
1644                                 ret_code = LTTNG_ERR_NOMEM;
1645                                 goto end;
1646                         }
1647                 }
1648
1649                 /* Insert exclusions. */
1650                 if (element->exclusions) {
1651                         event_extended->exclusions.count =
1652                                         element->exclusions->count;
1653                         event_extended->exclusions.strings =
1654                                         local_flattened_events.data +
1655                                         local_flattened_events.size;
1656
1657                         ret = lttng_dynamic_buffer_append(
1658                                         &local_flattened_events,
1659                                         element->exclusions->names,
1660                                         element->exclusions->count *
1661                                                         LTTNG_SYMBOL_NAME_LEN);
1662                         if (ret) {
1663                                 ret_code = LTTNG_ERR_NOMEM;
1664                                 goto end;
1665                         }
1666                 }
1667
1668                 /* Insert padding to align to 64-bits. */
1669                 ret = lttng_dynamic_buffer_set_size(&local_flattened_events,
1670                                 lttng_align_ceil(local_flattened_events.size,
1671                                                 sizeof(uint64_t)));
1672                 if (ret) {
1673                         ret_code = LTTNG_ERR_NOMEM;
1674                         goto end;
1675                 }
1676
1677                 location = lttng_event_get_userspace_probe_location(
1678                                 element->event);
1679                 if (location) {
1680                         event_extended->probe_location = (struct lttng_userspace_probe_location *)
1681                                         (local_flattened_events.data + local_flattened_events.size);
1682                         ret = lttng_userspace_probe_location_flatten(
1683                                         location, &local_flattened_events);
1684                         if (ret < 0) {
1685                                 ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL;
1686                                 goto end;
1687                         }
1688                 }
1689         }
1690
1691         /* Don't reset local_flattened_events buffer as we return its content. */
1692         *flattened_events = (struct lttng_event *) local_flattened_events.data;
1693         lttng_dynamic_buffer_init(&local_flattened_events);
1694         ret_code = LTTNG_OK;
1695 end:
1696         lttng_dynamic_buffer_reset(&local_flattened_events);
1697         return ret_code;
1698 }
1699
1700 static enum lttng_error_code event_list_create_from_payload(
1701                 struct lttng_payload_view *view,
1702                 unsigned int count,
1703                 struct lttng_dynamic_pointer_array *event_list)
1704 {
1705         enum lttng_error_code ret_code;
1706         int ret;
1707         unsigned int i;
1708         int offset = 0;
1709
1710         assert(view);
1711         assert(event_list);
1712
1713         for (i = 0; i < count; i++) {
1714                 ssize_t event_size;
1715                 struct lttng_payload_view event_view =
1716                                 lttng_payload_view_from_view(view, offset, -1);
1717                 struct event_list_element *element =
1718                                 (struct event_list_element *) zmalloc(sizeof(*element));
1719
1720                 if (!element) {
1721                         ret_code = LTTNG_ERR_NOMEM;
1722                         goto end;
1723                 }
1724
1725                 /*
1726                  * Lifetime and management of the object is now bound to the
1727                  * array.
1728                  */
1729                 ret = lttng_dynamic_pointer_array_add_pointer(
1730                                 event_list, element);
1731                 if (ret) {
1732                         event_list_destructor(element);
1733                         ret_code = LTTNG_ERR_NOMEM;
1734                         goto end;
1735                 }
1736
1737                 /*
1738                  * Bytecode is not transmitted on listing in any case we do not
1739                  * care about it.
1740                  */
1741                 event_size = lttng_event_create_from_payload(&event_view,
1742                                 &element->event,
1743                                 &element->exclusions,
1744                                 &element->filter_expression, NULL);
1745                 if (event_size < 0) {
1746                         ret_code = LTTNG_ERR_INVALID;
1747                         goto end;
1748                 }
1749
1750                 offset += event_size;
1751         }
1752
1753         if (view->buffer.size != offset) {
1754                 ret_code = LTTNG_ERR_INVALID_PROTOCOL;
1755                 goto end;
1756         }
1757
1758         ret_code = LTTNG_OK;
1759
1760 end:
1761         return ret_code;
1762 }
1763
1764 enum lttng_error_code lttng_events_create_and_flatten_from_payload(
1765                 struct lttng_payload_view *payload,
1766                 unsigned int count,
1767                 struct lttng_event **events)
1768 {
1769         enum lttng_error_code ret = LTTNG_OK;
1770         struct lttng_dynamic_pointer_array local_events;
1771
1772         lttng_dynamic_pointer_array_init(&local_events, event_list_destructor);
1773
1774         /* Deserialize the events. */
1775         {
1776                 struct lttng_payload_view events_view =
1777                                 lttng_payload_view_from_view(payload, 0, -1);
1778
1779                 ret = event_list_create_from_payload(
1780                                 &events_view, count, &local_events);
1781                 if (ret != LTTNG_OK) {
1782                         goto end;
1783                 }
1784         }
1785
1786         ret = flatten_lttng_events(&local_events, events);
1787         if (ret != LTTNG_OK) {
1788                 goto end;
1789         }
1790
1791 end:
1792         lttng_dynamic_pointer_array_reset(&local_events);
1793         return ret;
1794 }
1795
1796 static enum lttng_error_code flatten_lttng_event_fields(
1797                 struct lttng_dynamic_pointer_array *event_fields,
1798                 struct lttng_event_field **flattened_event_fields)
1799 {
1800         int ret, i;
1801         enum lttng_error_code ret_code;
1802         size_t storage_req = 0;
1803         struct lttng_dynamic_buffer local_flattened_event_fields;
1804         int nb_event_field;
1805
1806         assert(event_fields);
1807         assert(flattened_event_fields);
1808
1809         lttng_dynamic_buffer_init(&local_flattened_event_fields);
1810         nb_event_field = lttng_dynamic_pointer_array_get_count(event_fields);
1811
1812         /*
1813          * Here even if the event field contains a `struct lttng_event` that
1814          * could contain dynamic data, in reality it is not the case.
1815          * Dynamic data is not present. Here the flattening is mostly a direct
1816          * memcpy. This is less than ideal but this code is still better than
1817          * direct usage of an unpacked lttng_event_field array.
1818          */
1819         storage_req += sizeof(struct lttng_event_field) * nb_event_field;
1820
1821         lttng_dynamic_buffer_init(&local_flattened_event_fields);
1822
1823         /*
1824          * We must ensure that "local_flattened_event_fields" is never resized
1825          * so as to preserve the validity of the flattened objects.
1826          */
1827         ret = lttng_dynamic_buffer_set_capacity(
1828                         &local_flattened_event_fields, storage_req);
1829         if (ret) {
1830                 ret_code = LTTNG_ERR_NOMEM;
1831                 goto end;
1832         }
1833
1834         for (i = 0; i < nb_event_field; i++) {
1835                 const struct lttng_event_field *element =
1836                                 (const struct lttng_event_field *)
1837                                         lttng_dynamic_pointer_array_get_pointer(
1838                                                 event_fields, i);
1839
1840                 if (!element) {
1841                         ret_code = LTTNG_ERR_FATAL;
1842                         goto end;
1843                 }
1844                 ret = lttng_dynamic_buffer_append(&local_flattened_event_fields,
1845                                 element, sizeof(struct lttng_event_field));
1846                 if (ret) {
1847                         ret_code = LTTNG_ERR_NOMEM;
1848                         goto end;
1849                 }
1850         }
1851
1852         /* Don't reset local_flattened_channels buffer as we return its content. */
1853         *flattened_event_fields = (struct lttng_event_field *) local_flattened_event_fields.data;
1854         lttng_dynamic_buffer_init(&local_flattened_event_fields);
1855         ret_code = LTTNG_OK;
1856 end:
1857         lttng_dynamic_buffer_reset(&local_flattened_event_fields);
1858         return ret_code;
1859 }
1860
1861 static enum lttng_error_code event_field_list_create_from_payload(
1862                 struct lttng_payload_view *view,
1863                 unsigned int count,
1864                 struct lttng_dynamic_pointer_array **event_field_list)
1865 {
1866         enum lttng_error_code ret_code;
1867         int ret, offset = 0;
1868         unsigned int i;
1869         struct lttng_dynamic_pointer_array *list = NULL;
1870
1871         assert(view);
1872         assert(event_field_list);
1873
1874         list = (struct lttng_dynamic_pointer_array *) zmalloc(sizeof(*list));
1875         if (!list) {
1876                 ret_code = LTTNG_ERR_NOMEM;
1877                 goto end;
1878         }
1879
1880         lttng_dynamic_pointer_array_init(list, free);
1881
1882         for (i = 0; i < count; i++) {
1883                 ssize_t event_field_size;
1884                 struct lttng_event_field *field = NULL;
1885                 struct lttng_payload_view event_field_view =
1886                                 lttng_payload_view_from_view(view, offset, -1);
1887
1888                 event_field_size = lttng_event_field_create_from_payload(
1889                                 &event_field_view, &field);
1890                 if (event_field_size < 0) {
1891                         ret_code = LTTNG_ERR_INVALID;
1892                         goto end;
1893                 }
1894
1895                 /* Lifetime and management of the object is now bound to the array. */
1896                 ret = lttng_dynamic_pointer_array_add_pointer(list, field);
1897                 if (ret) {
1898                         free(field);
1899                         ret_code = LTTNG_ERR_NOMEM;
1900                         goto end;
1901                 }
1902
1903                 offset += event_field_size;
1904         }
1905
1906         if (view->buffer.size != offset) {
1907                 ret_code = LTTNG_ERR_INVALID;
1908                 goto end;
1909         }
1910
1911         *event_field_list = list;
1912         list = NULL;
1913         ret_code = LTTNG_OK;
1914
1915 end:
1916         if (list) {
1917                 lttng_dynamic_pointer_array_reset(list);
1918                 free(list);
1919         }
1920
1921         return ret_code;
1922 }
1923
1924 enum lttng_error_code lttng_event_fields_create_and_flatten_from_payload(
1925                 struct lttng_payload_view *view,
1926                 unsigned int count,
1927                 struct lttng_event_field **fields)
1928 {
1929         enum lttng_error_code ret_code;
1930         struct lttng_dynamic_pointer_array *local_event_fields = NULL;
1931
1932         ret_code = event_field_list_create_from_payload(
1933                         view, count, &local_event_fields);
1934         if (ret_code != LTTNG_OK) {
1935                 goto end;
1936         }
1937
1938         ret_code = flatten_lttng_event_fields(local_event_fields, fields);
1939         if (ret_code != LTTNG_OK) {
1940                 goto end;
1941         }
1942 end:
1943         if (local_event_fields) {
1944                 lttng_dynamic_pointer_array_reset(local_event_fields);
1945                 free(local_event_fields);
1946         }
1947
1948         return ret_code;
1949 }