2 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include "common/compat/string.h"
9 #include "common/macros.h"
10 #include "lttng/lttng-error.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>
25 struct event_list_element
{
26 struct lttng_event
*event
;
27 struct lttng_event_exclusion
*exclusions
;
28 char *filter_expression
;
31 static void event_list_destructor(void *ptr
)
33 struct event_list_element
*element
= (struct event_list_element
*) ptr
;
35 free(element
->filter_expression
);
36 free(element
->exclusions
);
37 lttng_event_destroy(element
->event
);
41 struct lttng_event
*lttng_event_copy(const struct lttng_event
*event
)
43 struct lttng_event
*new_event
;
44 struct lttng_event_extended
*new_event_extended
;
46 new_event
= (lttng_event
*) zmalloc(sizeof(*event
));
48 PERROR("Error allocating event structure");
52 /* Copy the content of the old event. */
53 memcpy(new_event
, event
, sizeof(*event
));
56 * We need to create a new extended since the previous pointer is now
59 new_event_extended
= (lttng_event_extended
*) zmalloc(sizeof(*new_event_extended
));
60 if (!new_event_extended
) {
61 PERROR("Error allocating event extended structure");
65 new_event
->extended
.ptr
= new_event_extended
;
74 static int lttng_event_probe_attr_serialize(
75 const struct lttng_event_probe_attr
*probe
,
76 struct lttng_payload
*payload
)
79 size_t symbol_name_len
;
80 struct lttng_event_probe_attr_comm comm
= { 0 };
82 symbol_name_len
= lttng_strnlen(probe
->symbol_name
, LTTNG_SYMBOL_NAME_LEN
);
83 if (symbol_name_len
== LTTNG_SYMBOL_NAME_LEN
) {
84 /* Not null-termintated. */
89 /* Include the null terminator. */
92 comm
.symbol_name_len
= (uint32_t) symbol_name_len
;
93 comm
.addr
= probe
->addr
;
94 comm
.offset
= probe
->addr
;
96 ret
= lttng_dynamic_buffer_append(
97 &payload
->buffer
, &comm
, sizeof(comm
));
103 ret
= lttng_dynamic_buffer_append(
104 &payload
->buffer
, probe
->symbol_name
, symbol_name_len
);
109 static int lttng_event_function_attr_serialize(
110 const struct lttng_event_function_attr
*function
,
111 struct lttng_payload
*payload
)
114 size_t symbol_name_len
;
115 struct lttng_event_function_attr_comm comm
= { 0 };
117 symbol_name_len
= lttng_strnlen(function
->symbol_name
, LTTNG_SYMBOL_NAME_LEN
);
118 if (symbol_name_len
== LTTNG_SYMBOL_NAME_LEN
) {
119 /* Not null-termintated. */
124 /* Include the null terminator. */
125 symbol_name_len
+= 1;
127 comm
.symbol_name_len
= (uint32_t) symbol_name_len
;
129 ret
= lttng_dynamic_buffer_append(
130 &payload
->buffer
, &comm
, sizeof(comm
));
136 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
137 function
->symbol_name
, symbol_name_len
);
142 static ssize_t
lttng_event_probe_attr_create_from_payload(
143 struct lttng_payload_view
*view
,
144 struct lttng_event_probe_attr
**probe_attr
)
146 ssize_t ret
, offset
= 0;
147 const struct lttng_event_probe_attr_comm
*comm
;
148 struct lttng_event_probe_attr
*local_attr
= NULL
;
149 struct lttng_payload_view comm_view
= lttng_payload_view_from_view(
150 view
, offset
, sizeof(*comm
));
152 if (!lttng_payload_view_is_valid(&comm_view
)) {
157 comm
= (typeof(comm
)) comm_view
.buffer
.data
;
158 offset
+= sizeof(*comm
);
160 local_attr
= (struct lttng_event_probe_attr
*) zmalloc(
161 sizeof(*local_attr
));
162 if (local_attr
== NULL
) {
167 local_attr
->addr
= comm
->addr
;
168 local_attr
->offset
= comm
->offset
;
172 struct lttng_payload_view name_view
=
173 lttng_payload_view_from_view(view
, offset
,
174 comm
->symbol_name_len
);
176 if (!lttng_payload_view_is_valid(&name_view
)) {
181 name
= name_view
.buffer
.data
;
183 if (!lttng_buffer_view_contains_string(&name_view
.buffer
, name
,
184 comm
->symbol_name_len
)) {
189 ret
= lttng_strncpy(local_attr
->symbol_name
, name
,
190 LTTNG_SYMBOL_NAME_LEN
);
196 offset
+= comm
->symbol_name_len
;
199 *probe_attr
= local_attr
;
206 static ssize_t
lttng_event_function_attr_create_from_payload(
207 struct lttng_payload_view
*view
,
208 struct lttng_event_function_attr
**function_attr
)
210 ssize_t ret
, offset
= 0;
211 const struct lttng_event_function_attr_comm
*comm
;
212 struct lttng_event_function_attr
*local_attr
= NULL
;
213 struct lttng_payload_view comm_view
= lttng_payload_view_from_view(
214 view
, offset
, sizeof(*comm
));
216 if (!lttng_payload_view_is_valid(&comm_view
)) {
221 comm
= (typeof(comm
)) view
->buffer
.data
;
222 offset
+= sizeof(*comm
);
224 local_attr
= (struct lttng_event_function_attr
*) zmalloc(
225 sizeof(*local_attr
));
226 if (local_attr
== NULL
) {
233 struct lttng_payload_view name_view
=
234 lttng_payload_view_from_view(view
, offset
,
235 comm
->symbol_name_len
);
237 if (!lttng_payload_view_is_valid(&name_view
)) {
242 name
= name_view
.buffer
.data
;
244 if (!lttng_buffer_view_contains_string(&name_view
.buffer
, name
,
245 comm
->symbol_name_len
)) {
250 ret
= lttng_strncpy(local_attr
->symbol_name
, name
,
251 LTTNG_SYMBOL_NAME_LEN
);
257 offset
+= comm
->symbol_name_len
;
260 *function_attr
= local_attr
;
267 static ssize_t
lttng_event_exclusions_create_from_payload(
268 struct lttng_payload_view
*view
,
270 struct lttng_event_exclusion
**exclusions
)
272 ssize_t ret
, offset
= 0;
273 size_t size
= (count
* LTTNG_SYMBOL_NAME_LEN
);
275 const struct lttng_event_exclusion_comm
*comm
;
276 struct lttng_event_exclusion
*local_exclusions
;
278 local_exclusions
= (struct lttng_event_exclusion
*) zmalloc(
279 sizeof(struct lttng_event_exclusion
) + size
);
280 if (!local_exclusions
) {
285 local_exclusions
->count
= count
;
287 for (i
= 0; i
< count
; i
++) {
289 struct lttng_buffer_view string_view
;
290 const struct lttng_buffer_view comm_view
=
291 lttng_buffer_view_from_view(&view
->buffer
,
292 offset
, sizeof(*comm
));
294 if (!lttng_buffer_view_is_valid(&comm_view
)) {
299 comm
= (typeof(comm
)) comm_view
.data
;
300 offset
+= sizeof(*comm
);
302 string_view
= lttng_buffer_view_from_view(
303 &view
->buffer
, offset
, comm
->len
);
305 if (!lttng_buffer_view_is_valid(&string_view
)) {
310 string
= string_view
.data
;
312 if (!lttng_buffer_view_contains_string(
313 &string_view
, string
, comm
->len
)) {
318 ret
= lttng_strncpy(local_exclusions
->names
[i
],
319 string
, LTTNG_SYMBOL_NAME_LEN
);
328 *exclusions
= local_exclusions
;
329 local_exclusions
= NULL
;
332 free(local_exclusions
);
336 ssize_t
lttng_event_create_from_payload(struct lttng_payload_view
*view
,
337 struct lttng_event
**out_event
,
338 struct lttng_event_exclusion
**out_exclusion
,
339 char **out_filter_expression
,
340 struct lttng_bytecode
**out_bytecode
)
342 ssize_t ret
, offset
= 0;
343 struct lttng_event
*local_event
= NULL
;
344 struct lttng_event_exclusion
*local_exclusions
= NULL
;
345 struct lttng_bytecode
*local_bytecode
= NULL
;
346 char *local_filter_expression
= NULL
;
347 const struct lttng_event_comm
*event_comm
;
348 struct lttng_event_function_attr
*local_function_attr
= NULL
;
349 struct lttng_event_probe_attr
*local_probe_attr
= NULL
;
350 struct lttng_userspace_probe_location
*local_userspace_probe_location
=
354 * Only event is obligatory, the other output argument are optional and
355 * depends on what the caller is interested in.
361 struct lttng_payload_view comm_view
=
362 lttng_payload_view_from_view(view
, offset
,
363 sizeof(*event_comm
));
365 if (!lttng_payload_view_is_valid(&comm_view
)) {
370 /* lttng_event_comm header */
371 event_comm
= (typeof(event_comm
)) comm_view
.buffer
.data
;
372 offset
+= sizeof(*event_comm
);
375 local_event
= lttng_event_create();
376 if (local_event
== NULL
) {
381 local_event
->type
= (enum lttng_event_type
) event_comm
->event_type
;
382 local_event
->loglevel_type
= (enum lttng_loglevel_type
) event_comm
->loglevel_type
;
383 local_event
->loglevel
= event_comm
->loglevel
;
384 local_event
->enabled
= event_comm
->enabled
;
385 local_event
->pid
= event_comm
->pid
;
386 local_event
->flags
= (enum lttng_event_flag
) event_comm
->flags
;
390 const struct lttng_buffer_view name_view
=
391 lttng_buffer_view_from_view(&view
->buffer
,
392 offset
, event_comm
->name_len
);
394 if (!lttng_buffer_view_is_valid(&name_view
)) {
399 name
= (const char *) name_view
.data
;
401 if (!lttng_buffer_view_contains_string(
402 &name_view
, name
, event_comm
->name_len
)) {
408 local_event
->name
, name
, LTTNG_SYMBOL_NAME_LEN
);
414 offset
+= event_comm
->name_len
;
418 if (event_comm
->exclusion_count
== 0) {
419 goto deserialize_filter_expression
;
423 struct lttng_payload_view exclusions_view
=
424 lttng_payload_view_from_view(
427 if (!lttng_payload_view_is_valid(&exclusions_view
)) {
432 ret
= lttng_event_exclusions_create_from_payload(&exclusions_view
,
433 event_comm
->exclusion_count
, &local_exclusions
);
440 local_event
->exclusion
= 1;
443 deserialize_filter_expression
:
445 if (event_comm
->filter_expression_len
== 0) {
446 if (event_comm
->bytecode_len
!= 0) {
448 * This is an invalid event payload.
450 * Filter expression without bytecode is possible but
451 * not the other way around.
456 goto deserialize_event_type_payload
;
460 const char *filter_expression_buffer
;
461 struct lttng_buffer_view filter_expression_view
=
462 lttng_buffer_view_from_view(&view
->buffer
, offset
,
463 event_comm
->filter_expression_len
);
465 if (!lttng_buffer_view_is_valid(&filter_expression_view
)) {
470 filter_expression_buffer
= filter_expression_view
.data
;
472 if (!lttng_buffer_view_contains_string(&filter_expression_view
,
473 filter_expression_buffer
,
474 event_comm
->filter_expression_len
)) {
479 local_filter_expression
= lttng_strndup(
480 filter_expression_buffer
,
481 event_comm
->filter_expression_len
);
482 if (!local_filter_expression
) {
487 local_event
->filter
= 1;
489 offset
+= event_comm
->filter_expression_len
;
492 if (event_comm
->bytecode_len
== 0) {
494 * Filter expression can be present but without bytecode
495 * when dealing with event listing.
497 goto deserialize_event_type_payload
;
502 struct lttng_payload_view bytecode_view
=
503 lttng_payload_view_from_view(view
, offset
,
504 event_comm
->bytecode_len
);
506 if (!lttng_payload_view_is_valid(&bytecode_view
)) {
511 local_bytecode
= (struct lttng_bytecode
*) zmalloc(
512 event_comm
->bytecode_len
);
513 if (!local_bytecode
) {
518 memcpy(local_bytecode
, bytecode_view
.buffer
.data
,
519 event_comm
->bytecode_len
);
520 if ((local_bytecode
->len
+ sizeof(*local_bytecode
)) !=
521 event_comm
->bytecode_len
) {
526 offset
+= event_comm
->bytecode_len
;
529 deserialize_event_type_payload
:
530 /* Event type specific payload */
531 switch (local_event
->type
) {
532 case LTTNG_EVENT_FUNCTION
:
534 case LTTNG_EVENT_PROBE
:
536 struct lttng_payload_view probe_attr_view
=
537 lttng_payload_view_from_view(view
, offset
,
538 event_comm
->lttng_event_probe_attr_len
);
540 if (event_comm
->lttng_event_probe_attr_len
== 0) {
545 if (!lttng_payload_view_is_valid(&probe_attr_view
)) {
550 ret
= lttng_event_probe_attr_create_from_payload(
551 &probe_attr_view
, &local_probe_attr
);
552 if (ret
< 0 || ret
!= event_comm
->lttng_event_probe_attr_len
) {
557 /* Copy to the local event. */
558 memcpy(&local_event
->attr
.probe
, local_probe_attr
,
559 sizeof(local_event
->attr
.probe
));
564 case LTTNG_EVENT_FUNCTION_ENTRY
:
566 struct lttng_payload_view function_attr_view
=
567 lttng_payload_view_from_view(view
, offset
,
568 event_comm
->lttng_event_function_attr_len
);
570 if (event_comm
->lttng_event_function_attr_len
== 0) {
575 if (!lttng_payload_view_is_valid(&function_attr_view
)) {
580 ret
= lttng_event_function_attr_create_from_payload(
581 &function_attr_view
, &local_function_attr
);
582 if (ret
< 0 || ret
!= event_comm
->lttng_event_function_attr_len
) {
587 /* Copy to the local event. */
588 memcpy(&local_event
->attr
.ftrace
, local_function_attr
,
589 sizeof(local_event
->attr
.ftrace
));
595 case LTTNG_EVENT_USERSPACE_PROBE
:
597 struct lttng_payload_view userspace_probe_location_view
=
598 lttng_payload_view_from_view(view
, offset
,
599 event_comm
->userspace_probe_location_len
);
601 if (event_comm
->userspace_probe_location_len
== 0) {
606 if (!lttng_payload_view_is_valid(
607 &userspace_probe_location_view
)) {
612 ret
= lttng_userspace_probe_location_create_from_payload(
613 &userspace_probe_location_view
,
614 &local_userspace_probe_location
);
616 WARN("Failed to create a userspace probe location from the received buffer");
621 if (ret
!= event_comm
->userspace_probe_location_len
) {
622 WARN("Userspace probe location from the received buffer is not the advertised length: header length = %" PRIu32
", payload length = %lu", event_comm
->userspace_probe_location_len
, ret
);
627 /* Attach the probe location to the event. */
628 ret
= lttng_event_set_userspace_probe_location(
629 local_event
, local_userspace_probe_location
);
631 ret
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
636 * Userspace probe location object ownership transfered to the
639 local_userspace_probe_location
= NULL
;
640 offset
+= event_comm
->userspace_probe_location_len
;
643 case LTTNG_EVENT_TRACEPOINT
:
645 case LTTNG_EVENT_ALL
:
647 case LTTNG_EVENT_SYSCALL
:
649 case LTTNG_EVENT_NOOP
:
650 /* Nothing to do here */
658 /* Transfer ownership to the caller. */
659 *out_event
= local_event
;
663 *out_bytecode
= local_bytecode
;
664 local_bytecode
= NULL
;
668 *out_exclusion
= local_exclusions
;
669 local_exclusions
= NULL
;
672 if (out_filter_expression
) {
673 *out_filter_expression
= local_filter_expression
;
674 local_filter_expression
= NULL
;
679 lttng_event_destroy(local_event
);
680 lttng_userspace_probe_location_destroy(local_userspace_probe_location
);
681 free(local_filter_expression
);
682 free(local_exclusions
);
683 free(local_bytecode
);
684 free(local_function_attr
);
685 free(local_probe_attr
);
689 int lttng_event_serialize(const struct lttng_event
*event
,
690 unsigned int exclusion_count
,
691 char **exclusion_list
,
692 char *filter_expression
,
694 struct lttng_bytecode
*bytecode
,
695 struct lttng_payload
*payload
)
699 size_t header_offset
, size_before_payload
;
701 struct lttng_event_comm event_comm
= { 0 };
702 struct lttng_event_comm
*header
;
706 assert(exclusion_count
== 0 || exclusion_list
);
708 /* Save the header location for later in-place header update. */
709 header_offset
= payload
->buffer
.size
;
711 name_len
= lttng_strnlen(event
->name
, LTTNG_SYMBOL_NAME_LEN
);
712 if (name_len
== LTTNG_SYMBOL_NAME_LEN
) {
713 /* Event name is not NULL-terminated. */
718 /* Add null termination. */
721 if (exclusion_count
> UINT32_MAX
) {
722 /* Possible overflow. */
727 if (bytecode_len
> UINT32_MAX
) {
728 /* Possible overflow. */
733 event_comm
.name_len
= (uint32_t) name_len
;
734 event_comm
.event_type
= (int8_t) event
->type
;
735 event_comm
.loglevel_type
= (int8_t) event
->loglevel_type
;
736 event_comm
.loglevel
= (int32_t) event
->loglevel
;
737 event_comm
.enabled
= (int8_t) event
->enabled
;
738 event_comm
.pid
= (int32_t) event
->pid
;
739 event_comm
.exclusion_count
= (uint32_t) exclusion_count
;
740 event_comm
.bytecode_len
= (uint32_t) bytecode_len
;
741 event_comm
.flags
= (int32_t) event
->flags
;
743 if (filter_expression
) {
744 event_comm
.filter_expression_len
=
745 strlen(filter_expression
) + 1;
749 ret
= lttng_dynamic_buffer_append(
750 &payload
->buffer
, &event_comm
, sizeof(event_comm
));
756 ret
= lttng_dynamic_buffer_append(
757 &payload
->buffer
, event
->name
, name_len
);
763 for (i
= 0; i
< exclusion_count
; i
++) {
764 const size_t exclusion_len
= lttng_strnlen(
765 *(exclusion_list
+ i
), LTTNG_SYMBOL_NAME_LEN
);
766 const struct lttng_event_exclusion_comm exclusion_header
= {
767 .len
= (uint32_t) exclusion_len
+ 1,
770 if (exclusion_len
== LTTNG_SYMBOL_NAME_LEN
) {
771 /* Exclusion is not NULL-terminated. */
776 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
777 &exclusion_header
, sizeof(exclusion_header
));
782 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
783 *(exclusion_list
+ i
), exclusion_len
+ 1);
789 /* Filter expression and its bytecode */
790 if (filter_expression
) {
791 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
793 event_comm
.filter_expression_len
);
799 * Bytecode can be absent when we serialize to the client
803 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
804 bytecode
, bytecode_len
);
811 size_before_payload
= payload
->buffer
.size
;
813 /* Event type specific payload */
814 switch (event
->type
) {
815 case LTTNG_EVENT_FUNCTION
:
817 case LTTNG_EVENT_PROBE
:
818 ret
= lttng_event_probe_attr_serialize(&event
->attr
.probe
, payload
);
824 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
826 header
->lttng_event_probe_attr_len
=
827 payload
->buffer
.size
- size_before_payload
;
830 case LTTNG_EVENT_FUNCTION_ENTRY
:
831 ret
= lttng_event_function_attr_serialize(
832 &event
->attr
.ftrace
, payload
);
838 /* Update the lttng_event_function_attr len. */
839 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
841 header
->lttng_event_function_attr_len
=
842 payload
->buffer
.size
- size_before_payload
;
845 case LTTNG_EVENT_USERSPACE_PROBE
:
847 const struct lttng_event_extended
*ev_ext
=
848 (const struct lttng_event_extended
*)
851 assert(event
->extended
.ptr
);
852 assert(ev_ext
->probe_location
);
854 size_before_payload
= payload
->buffer
.size
;
855 if (ev_ext
->probe_location
) {
857 * lttng_userspace_probe_location_serialize returns the
858 * number of bytes that were appended to the buffer.
860 ret
= lttng_userspace_probe_location_serialize(
861 ev_ext
->probe_location
, payload
);
868 /* Update the userspace probe location len. */
869 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
871 header
->userspace_probe_location_len
=
872 payload
->buffer
.size
- size_before_payload
;
876 case LTTNG_EVENT_TRACEPOINT
:
878 case LTTNG_EVENT_ALL
:
881 /* Nothing to do here. */
889 static enum lttng_error_code
compute_flattened_size(
890 struct lttng_dynamic_pointer_array
*events
, size_t *size
)
892 enum lttng_error_code ret_code
;
894 size_t storage_req
, event_count
, i
;
899 event_count
= lttng_dynamic_pointer_array_get_count(events
);
901 /* The basic struct lttng_event */
902 storage_req
= event_count
* sizeof(struct lttng_event
);
904 for (i
= 0; i
< event_count
; i
++) {
905 int probe_storage_req
= 0;
906 const struct event_list_element
*element
= (const struct event_list_element
*)
907 lttng_dynamic_pointer_array_get_pointer(
909 const struct lttng_userspace_probe_location
*location
= NULL
;
911 location
= lttng_event_get_userspace_probe_location(
914 ret
= lttng_userspace_probe_location_flatten(
917 ret_code
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
921 probe_storage_req
= ret
;
924 /* The struct·lttng_event_extended */
925 storage_req
+= event_count
*
926 sizeof(struct lttng_event_extended
);
928 if (element
->filter_expression
) {
929 storage_req
+= strlen(element
->filter_expression
) + 1;
932 if (element
->exclusions
) {
933 storage_req
+= element
->exclusions
->count
*
934 LTTNG_SYMBOL_NAME_LEN
;
937 /* Padding to ensure the flat probe is aligned. */
938 storage_req
= lttng_align_ceil(storage_req
, sizeof(uint64_t));
939 storage_req
+= probe_storage_req
;
950 * Flatten a list of struct lttng_event.
952 * The buffer that is returned to the API client must contain a "flat" version
953 * of the events that are returned. In other words, all pointers within an
954 * lttng_event must point to a location within the returned buffer so that the
955 * user may free everything by simply calling free() on the returned buffer.
956 * This is needed in order to maintain API compatibility.
958 * A first pass is performed to compute the size of the buffer that must be
959 * allocated. A second pass is then performed to setup the returned events so
960 * that their members always point within the buffer.
962 * The layout of the returned buffer is as follows:
963 * - struct lttng_event[nb_events],
964 * - nb_events times the following:
965 * - struct lttng_event_extended,
966 * - filter_expression
968 * - padding to align to 64-bits
969 * - flattened version of userspace_probe_location
971 static enum lttng_error_code
flatten_lttng_events(
972 struct lttng_dynamic_pointer_array
*events
,
973 struct lttng_event
**flattened_events
)
975 enum lttng_error_code ret_code
;
978 struct lttng_dynamic_buffer local_flattened_events
;
982 assert(flattened_events
);
984 lttng_dynamic_buffer_init(&local_flattened_events
);
985 nb_events
= lttng_dynamic_pointer_array_get_count(events
);
987 ret_code
= compute_flattened_size(events
, &storage_req
);
988 if (ret_code
!= LTTNG_OK
) {
993 * We must ensure that "local_flattened_events" is never resized so as
994 * to preserve the validity of the flattened objects.
996 ret
= lttng_dynamic_buffer_set_capacity(
997 &local_flattened_events
, storage_req
);
999 ret_code
= LTTNG_ERR_NOMEM
;
1003 /* Start by laying the struct lttng_event */
1004 for (i
= 0; i
< nb_events
; i
++) {
1005 const struct event_list_element
*element
= (const struct event_list_element
*)
1006 lttng_dynamic_pointer_array_get_pointer(
1010 ret_code
= LTTNG_ERR_FATAL
;
1014 ret
= lttng_dynamic_buffer_append(&local_flattened_events
,
1015 element
->event
, sizeof(struct lttng_event
));
1017 ret_code
= LTTNG_ERR_NOMEM
;
1022 for (i
= 0; i
< nb_events
; i
++) {
1023 const struct event_list_element
*element
= (const struct event_list_element
*)
1024 lttng_dynamic_pointer_array_get_pointer(events
, i
);
1025 struct lttng_event
*event
= (struct lttng_event
*)
1026 (local_flattened_events
.data
+ (sizeof(struct lttng_event
) * i
));
1027 struct lttng_event_extended
*event_extended
=
1028 (struct lttng_event_extended
*)
1029 (local_flattened_events
.data
+ local_flattened_events
.size
);
1030 const struct lttng_userspace_probe_location
*location
= NULL
;
1034 /* Insert struct lttng_event_extended. */
1035 ret
= lttng_dynamic_buffer_set_size(&local_flattened_events
,
1036 local_flattened_events
.size
+
1037 sizeof(*event_extended
));
1039 ret_code
= LTTNG_ERR_NOMEM
;
1042 event
->extended
.ptr
= event_extended
;
1044 /* Insert filter expression. */
1045 if (element
->filter_expression
) {
1046 const size_t len
= strlen(element
->filter_expression
) + 1;
1048 event_extended
->filter_expression
=
1049 local_flattened_events
.data
+
1050 local_flattened_events
.size
;
1051 ret
= lttng_dynamic_buffer_append(
1052 &local_flattened_events
,
1053 element
->filter_expression
, len
);
1055 ret_code
= LTTNG_ERR_NOMEM
;
1060 /* Insert exclusions. */
1061 if (element
->exclusions
) {
1062 event_extended
->exclusions
.count
=
1063 element
->exclusions
->count
;
1064 event_extended
->exclusions
.strings
=
1065 local_flattened_events
.data
+
1066 local_flattened_events
.size
;
1068 ret
= lttng_dynamic_buffer_append(
1069 &local_flattened_events
,
1070 element
->exclusions
->names
,
1071 element
->exclusions
->count
*
1072 LTTNG_SYMBOL_NAME_LEN
);
1074 ret_code
= LTTNG_ERR_NOMEM
;
1079 /* Insert padding to align to 64-bits. */
1080 ret
= lttng_dynamic_buffer_set_size(&local_flattened_events
,
1081 lttng_align_ceil(local_flattened_events
.size
,
1084 ret_code
= LTTNG_ERR_NOMEM
;
1088 location
= lttng_event_get_userspace_probe_location(
1091 event_extended
->probe_location
= (struct lttng_userspace_probe_location
*)
1092 (local_flattened_events
.data
+ local_flattened_events
.size
);
1093 ret
= lttng_userspace_probe_location_flatten(
1094 location
, &local_flattened_events
);
1096 ret_code
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
1102 /* Don't reset local_flattened_events buffer as we return its content. */
1103 *flattened_events
= (struct lttng_event
*) local_flattened_events
.data
;
1104 lttng_dynamic_buffer_init(&local_flattened_events
);
1105 ret_code
= LTTNG_OK
;
1107 lttng_dynamic_buffer_reset(&local_flattened_events
);
1111 static enum lttng_error_code
event_list_create_from_payload(
1112 struct lttng_payload_view
*view
,
1114 struct lttng_dynamic_pointer_array
*event_list
)
1116 enum lttng_error_code ret_code
;
1124 for (i
= 0; i
< count
; i
++) {
1126 struct lttng_payload_view event_view
=
1127 lttng_payload_view_from_view(view
, offset
, -1);
1128 struct event_list_element
*element
=
1129 (struct event_list_element
*) zmalloc(sizeof(*element
));
1132 ret_code
= LTTNG_ERR_NOMEM
;
1137 * Lifetime and management of the object is now bound to the
1140 ret
= lttng_dynamic_pointer_array_add_pointer(
1141 event_list
, element
);
1143 event_list_destructor(element
);
1144 ret_code
= LTTNG_ERR_NOMEM
;
1149 * Bytecode is not transmitted on listing in any case we do not
1152 event_size
= lttng_event_create_from_payload(&event_view
,
1154 &element
->exclusions
,
1155 &element
->filter_expression
, NULL
);
1156 if (event_size
< 0) {
1157 ret_code
= LTTNG_ERR_INVALID
;
1161 offset
+= event_size
;
1164 if (view
->buffer
.size
!= offset
) {
1165 ret_code
= LTTNG_ERR_INVALID_PROTOCOL
;
1169 ret_code
= LTTNG_OK
;
1175 enum lttng_error_code
lttng_events_create_and_flatten_from_payload(
1176 struct lttng_payload_view
*payload
,
1178 struct lttng_event
**events
)
1180 enum lttng_error_code ret
= LTTNG_OK
;
1181 struct lttng_dynamic_pointer_array local_events
;
1183 lttng_dynamic_pointer_array_init(&local_events
, event_list_destructor
);
1185 /* Deserialize the events. */
1187 struct lttng_payload_view events_view
=
1188 lttng_payload_view_from_view(payload
, 0, -1);
1190 ret
= event_list_create_from_payload(
1191 &events_view
, count
, &local_events
);
1192 if (ret
!= LTTNG_OK
) {
1197 ret
= flatten_lttng_events(&local_events
, events
);
1198 if (ret
!= LTTNG_OK
) {
1203 lttng_dynamic_pointer_array_reset(&local_events
);