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
= {};
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. */
90 /* Include the null terminator. */
93 comm
.symbol_name_len
= (uint32_t) symbol_name_len
;
94 comm
.addr
= probe
->addr
;
95 comm
.offset
= probe
->addr
;
97 ret
= lttng_dynamic_buffer_append(
98 &payload
->buffer
, &comm
, sizeof(comm
));
104 ret
= lttng_dynamic_buffer_append(
105 &payload
->buffer
, probe
->symbol_name
, symbol_name_len
);
110 static int lttng_event_function_attr_serialize(
111 const struct lttng_event_function_attr
*function
,
112 struct lttng_payload
*payload
)
115 size_t symbol_name_len
;
116 struct lttng_event_function_attr_comm comm
= { 0 };
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. */
126 /* Include the null terminator. */
127 symbol_name_len
+= 1;
129 comm
.symbol_name_len
= (uint32_t) symbol_name_len
;
131 ret
= lttng_dynamic_buffer_append(
132 &payload
->buffer
, &comm
, sizeof(comm
));
138 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
139 function
->symbol_name
, symbol_name_len
);
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
)
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
));
154 if (!lttng_payload_view_is_valid(&comm_view
)) {
159 comm
= (typeof(comm
)) comm_view
.buffer
.data
;
160 offset
+= sizeof(*comm
);
162 local_attr
= (struct lttng_event_probe_attr
*) zmalloc(
163 sizeof(*local_attr
));
164 if (local_attr
== NULL
) {
169 local_attr
->addr
= comm
->addr
;
170 local_attr
->offset
= comm
->offset
;
174 struct lttng_payload_view name_view
=
175 lttng_payload_view_from_view(view
, offset
,
176 comm
->symbol_name_len
);
178 if (!lttng_payload_view_is_valid(&name_view
)) {
183 name
= name_view
.buffer
.data
;
185 if (!lttng_buffer_view_contains_string(&name_view
.buffer
, name
,
186 comm
->symbol_name_len
)) {
191 ret
= lttng_strncpy(local_attr
->symbol_name
, name
,
192 sizeof(local_attr
->symbol_name
));
198 offset
+= comm
->symbol_name_len
;
201 *probe_attr
= local_attr
;
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
)
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
));
219 if (!lttng_payload_view_is_valid(&comm_view
)) {
224 comm
= (typeof(comm
)) view
->buffer
.data
;
225 offset
+= sizeof(*comm
);
227 local_attr
= (struct lttng_event_function_attr
*) zmalloc(
228 sizeof(*local_attr
));
229 if (local_attr
== NULL
) {
236 struct lttng_payload_view name_view
=
237 lttng_payload_view_from_view(view
, offset
,
238 comm
->symbol_name_len
);
240 if (!lttng_payload_view_is_valid(&name_view
)) {
245 name
= name_view
.buffer
.data
;
247 if (!lttng_buffer_view_contains_string(&name_view
.buffer
, name
,
248 comm
->symbol_name_len
)) {
253 ret
= lttng_strncpy(local_attr
->symbol_name
, name
,
254 sizeof(local_attr
->symbol_name
));
260 offset
+= comm
->symbol_name_len
;
263 *function_attr
= local_attr
;
271 static ssize_t
lttng_event_exclusions_create_from_payload(
272 struct lttng_payload_view
*view
,
274 struct lttng_event_exclusion
**exclusions
)
276 ssize_t ret
, offset
= 0;
277 size_t size
= (count
* LTTNG_SYMBOL_NAME_LEN
);
279 const struct lttng_event_exclusion_comm
*comm
;
280 struct lttng_event_exclusion
*local_exclusions
;
282 local_exclusions
= (struct lttng_event_exclusion
*) zmalloc(
283 sizeof(struct lttng_event_exclusion
) + size
);
284 if (!local_exclusions
) {
289 local_exclusions
->count
= count
;
291 for (i
= 0; i
< count
; i
++) {
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
));
298 if (!lttng_buffer_view_is_valid(&comm_view
)) {
303 comm
= (typeof(comm
)) comm_view
.data
;
304 offset
+= sizeof(*comm
);
306 string_view
= lttng_buffer_view_from_view(
307 &view
->buffer
, offset
, comm
->len
);
309 if (!lttng_buffer_view_is_valid(&string_view
)) {
314 string
= string_view
.data
;
316 if (!lttng_buffer_view_contains_string(
317 &string_view
, string
, comm
->len
)) {
322 ret
= lttng_strncpy(LTTNG_EVENT_EXCLUSION_NAME_AT(local_exclusions
, i
), string
,
323 sizeof(LTTNG_EVENT_EXCLUSION_NAME_AT(local_exclusions
, i
)));
332 *exclusions
= local_exclusions
;
333 local_exclusions
= NULL
;
336 free(local_exclusions
);
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
)
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
=
358 * Only event is obligatory, the other output argument are optional and
359 * depends on what the caller is interested in.
365 struct lttng_payload_view comm_view
=
366 lttng_payload_view_from_view(view
, offset
,
367 sizeof(*event_comm
));
369 if (!lttng_payload_view_is_valid(&comm_view
)) {
374 /* lttng_event_comm header */
375 event_comm
= (typeof(event_comm
)) comm_view
.buffer
.data
;
376 offset
+= sizeof(*event_comm
);
379 local_event
= lttng_event_create();
380 if (local_event
== NULL
) {
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
;
394 const struct lttng_buffer_view name_view
=
395 lttng_buffer_view_from_view(&view
->buffer
,
396 offset
, event_comm
->name_len
);
398 if (!lttng_buffer_view_is_valid(&name_view
)) {
403 name
= (const char *) name_view
.data
;
405 if (!lttng_buffer_view_contains_string(
406 &name_view
, name
, event_comm
->name_len
)) {
411 ret
= lttng_strncpy(local_event
->name
, name
,
412 sizeof(local_event
->name
));
418 offset
+= event_comm
->name_len
;
422 if (event_comm
->exclusion_count
== 0) {
423 goto deserialize_filter_expression
;
427 struct lttng_payload_view exclusions_view
=
428 lttng_payload_view_from_view(
431 if (!lttng_payload_view_is_valid(&exclusions_view
)) {
436 ret
= lttng_event_exclusions_create_from_payload(&exclusions_view
,
437 event_comm
->exclusion_count
, &local_exclusions
);
444 local_event
->exclusion
= 1;
447 deserialize_filter_expression
:
449 if (event_comm
->filter_expression_len
== 0) {
450 if (event_comm
->bytecode_len
!= 0) {
452 * This is an invalid event payload.
454 * Filter expression without bytecode is possible but
455 * not the other way around.
460 goto deserialize_event_type_payload
;
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
);
469 if (!lttng_buffer_view_is_valid(&filter_expression_view
)) {
474 filter_expression_buffer
= filter_expression_view
.data
;
476 if (!lttng_buffer_view_contains_string(&filter_expression_view
,
477 filter_expression_buffer
,
478 event_comm
->filter_expression_len
)) {
483 local_filter_expression
= lttng_strndup(
484 filter_expression_buffer
,
485 event_comm
->filter_expression_len
);
486 if (!local_filter_expression
) {
491 local_event
->filter
= 1;
493 offset
+= event_comm
->filter_expression_len
;
496 if (event_comm
->bytecode_len
== 0) {
498 * Filter expression can be present but without bytecode
499 * when dealing with event listing.
501 goto deserialize_event_type_payload
;
506 struct lttng_payload_view bytecode_view
=
507 lttng_payload_view_from_view(view
, offset
,
508 event_comm
->bytecode_len
);
510 if (!lttng_payload_view_is_valid(&bytecode_view
)) {
515 local_bytecode
= (struct lttng_bytecode
*) zmalloc(
516 event_comm
->bytecode_len
);
517 if (!local_bytecode
) {
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
) {
530 offset
+= event_comm
->bytecode_len
;
533 deserialize_event_type_payload
:
534 /* Event type specific payload */
535 switch (local_event
->type
) {
536 case LTTNG_EVENT_FUNCTION
:
538 case LTTNG_EVENT_PROBE
:
540 struct lttng_payload_view probe_attr_view
=
541 lttng_payload_view_from_view(view
, offset
,
542 event_comm
->lttng_event_probe_attr_len
);
544 if (event_comm
->lttng_event_probe_attr_len
== 0) {
549 if (!lttng_payload_view_is_valid(&probe_attr_view
)) {
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
) {
561 /* Copy to the local event. */
562 memcpy(&local_event
->attr
.probe
, local_probe_attr
,
563 sizeof(local_event
->attr
.probe
));
568 case LTTNG_EVENT_FUNCTION_ENTRY
:
570 struct lttng_payload_view function_attr_view
=
571 lttng_payload_view_from_view(view
, offset
,
572 event_comm
->lttng_event_function_attr_len
);
574 if (event_comm
->lttng_event_function_attr_len
== 0) {
579 if (!lttng_payload_view_is_valid(&function_attr_view
)) {
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
) {
591 /* Copy to the local event. */
592 memcpy(&local_event
->attr
.ftrace
, local_function_attr
,
593 sizeof(local_event
->attr
.ftrace
));
599 case LTTNG_EVENT_USERSPACE_PROBE
:
601 struct lttng_payload_view userspace_probe_location_view
=
602 lttng_payload_view_from_view(view
, offset
,
603 event_comm
->userspace_probe_location_len
);
605 if (event_comm
->userspace_probe_location_len
== 0) {
610 if (!lttng_payload_view_is_valid(
611 &userspace_probe_location_view
)) {
616 ret
= lttng_userspace_probe_location_create_from_payload(
617 &userspace_probe_location_view
,
618 &local_userspace_probe_location
);
620 WARN("Failed to create a userspace probe location from the received buffer");
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
);
631 /* Attach the probe location to the event. */
632 ret
= lttng_event_set_userspace_probe_location(
633 local_event
, local_userspace_probe_location
);
635 ret
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
640 * Userspace probe location object ownership transfered to the
643 local_userspace_probe_location
= NULL
;
644 offset
+= event_comm
->userspace_probe_location_len
;
647 case LTTNG_EVENT_TRACEPOINT
:
649 case LTTNG_EVENT_ALL
:
651 case LTTNG_EVENT_SYSCALL
:
653 case LTTNG_EVENT_NOOP
:
654 /* Nothing to do here */
662 /* Transfer ownership to the caller. */
663 *out_event
= local_event
;
667 *out_bytecode
= local_bytecode
;
668 local_bytecode
= NULL
;
672 *out_exclusion
= local_exclusions
;
673 local_exclusions
= NULL
;
676 if (out_filter_expression
) {
677 *out_filter_expression
= local_filter_expression
;
678 local_filter_expression
= NULL
;
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
);
693 int lttng_event_serialize(const struct lttng_event
*event
,
694 unsigned int exclusion_count
,
695 char **exclusion_list
,
696 char *filter_expression
,
698 struct lttng_bytecode
*bytecode
,
699 struct lttng_payload
*payload
)
703 size_t header_offset
, size_before_payload
;
705 struct lttng_event_comm event_comm
= {};
706 struct lttng_event_comm
*header
;
710 assert(exclusion_count
== 0 || exclusion_list
);
712 /* Save the header location for later in-place header update. */
713 header_offset
= payload
->buffer
.size
;
715 name_len
= lttng_strnlen(event
->name
, sizeof(event
->name
));
716 if (name_len
== sizeof(event
->name
)) {
717 /* Event name is not NULL-terminated. */
722 /* Add null termination. */
725 if (exclusion_count
> UINT32_MAX
) {
726 /* Possible overflow. */
731 if (bytecode_len
> UINT32_MAX
) {
732 /* Possible overflow. */
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
;
747 if (filter_expression
) {
748 event_comm
.filter_expression_len
=
749 strlen(filter_expression
) + 1;
753 ret
= lttng_dynamic_buffer_append(
754 &payload
->buffer
, &event_comm
, sizeof(event_comm
));
760 ret
= lttng_dynamic_buffer_append(
761 &payload
->buffer
, event
->name
, name_len
);
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,
774 if (exclusion_len
== LTTNG_SYMBOL_NAME_LEN
) {
775 /* Exclusion is not NULL-terminated. */
780 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
781 &exclusion_header
, sizeof(exclusion_header
));
786 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
787 *(exclusion_list
+ i
), exclusion_len
+ 1);
793 /* Filter expression and its bytecode */
794 if (filter_expression
) {
795 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
797 event_comm
.filter_expression_len
);
803 * Bytecode can be absent when we serialize to the client
807 ret
= lttng_dynamic_buffer_append(&payload
->buffer
,
808 bytecode
, bytecode_len
);
815 size_before_payload
= payload
->buffer
.size
;
817 /* Event type specific payload */
818 switch (event
->type
) {
819 case LTTNG_EVENT_FUNCTION
:
821 case LTTNG_EVENT_PROBE
:
822 ret
= lttng_event_probe_attr_serialize(&event
->attr
.probe
, payload
);
828 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
830 header
->lttng_event_probe_attr_len
=
831 payload
->buffer
.size
- size_before_payload
;
834 case LTTNG_EVENT_FUNCTION_ENTRY
:
835 ret
= lttng_event_function_attr_serialize(
836 &event
->attr
.ftrace
, payload
);
842 /* Update the lttng_event_function_attr len. */
843 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
845 header
->lttng_event_function_attr_len
=
846 payload
->buffer
.size
- size_before_payload
;
849 case LTTNG_EVENT_USERSPACE_PROBE
:
851 const struct lttng_event_extended
*ev_ext
=
852 (const struct lttng_event_extended
*)
855 assert(event
->extended
.ptr
);
856 assert(ev_ext
->probe_location
);
858 size_before_payload
= payload
->buffer
.size
;
859 if (ev_ext
->probe_location
) {
861 * lttng_userspace_probe_location_serialize returns the
862 * number of bytes that were appended to the buffer.
864 ret
= lttng_userspace_probe_location_serialize(
865 ev_ext
->probe_location
, payload
);
872 /* Update the userspace probe location len. */
873 header
= (struct lttng_event_comm
*) ((char *) payload
->buffer
.data
+
875 header
->userspace_probe_location_len
=
876 payload
->buffer
.size
- size_before_payload
;
880 case LTTNG_EVENT_TRACEPOINT
:
882 case LTTNG_EVENT_ALL
:
885 /* Nothing to do here. */
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
)
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
));
904 assert(event_ctx
->ctx
== LTTNG_EVENT_CONTEXT_APP_CONTEXT
);
906 if (!lttng_buffer_view_is_valid(&comm_view
)) {
911 comm
= (typeof(comm
)) comm_view
.data
;
912 offset
+= sizeof(*comm
);
914 provider_name_len
= comm
->provider_name_len
;
915 context_name_len
= comm
->ctx_name_len
;
917 if (provider_name_len
== 0 || context_name_len
== 0) {
919 * Application provider and context names MUST
928 const struct lttng_buffer_view provider_name_view
=
929 lttng_buffer_view_from_view(&view
->buffer
,
933 if (!lttng_buffer_view_is_valid(&provider_name_view
)) {
938 name
= provider_name_view
.data
;
940 if (!lttng_buffer_view_contains_string(&provider_name_view
,
941 name
, provider_name_len
)) {
946 provider_name
= lttng_strndup(name
, provider_name_len
);
947 if (!provider_name
) {
952 offset
+= provider_name_len
;
957 const struct lttng_buffer_view context_name_view
=
958 lttng_buffer_view_from_view(
959 &view
->buffer
, offset
,
962 if (!lttng_buffer_view_is_valid(&context_name_view
)) {
967 name
= context_name_view
.data
;
969 if (!lttng_buffer_view_contains_string(&context_name_view
, name
,
975 context_name
= lttng_strndup(name
, context_name_len
);
981 offset
+= context_name_len
;
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
;
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
)
1003 ssize_t consumed
, offset
= 0;
1004 const struct lttng_event_context_perf_counter_comm
*comm
;
1006 const struct lttng_buffer_view comm_view
= lttng_buffer_view_from_view(
1007 &view
->buffer
, offset
, sizeof(*comm
));
1009 assert(event_ctx
->ctx
== LTTNG_EVENT_CONTEXT_PERF_COUNTER
||
1011 LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER
||
1012 event_ctx
->ctx
== LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER
);
1014 if (!lttng_buffer_view_is_valid(&comm_view
)) {
1019 comm
= (typeof(comm
)) comm_view
.data
;
1020 offset
+= sizeof(*comm
);
1022 name_len
= comm
->name_len
;
1026 const struct lttng_buffer_view provider_name_view
=
1027 lttng_buffer_view_from_view(
1028 &view
->buffer
, offset
,
1031 if (!lttng_buffer_view_is_valid(&provider_name_view
)) {
1036 name
= provider_name_view
.data
;
1038 if (!lttng_buffer_view_contains_string(
1039 &provider_name_view
, name
, name_len
)) {
1044 ret
= lttng_strncpy(event_ctx
->u
.perf_counter
.name
, name
,
1045 sizeof(event_ctx
->u
.perf_counter
.name
));
1053 event_ctx
->u
.perf_counter
.config
= comm
->config
;
1054 event_ctx
->u
.perf_counter
.type
= comm
->type
;
1062 ssize_t
lttng_event_context_create_from_payload(
1063 struct lttng_payload_view
*view
,
1064 struct lttng_event_context
**event_ctx
)
1066 ssize_t ret
, offset
= 0;
1067 const struct lttng_event_context_comm
*comm
;
1068 struct lttng_event_context
*local_context
= NULL
;
1069 struct lttng_buffer_view comm_view
= lttng_buffer_view_from_view(
1070 &view
->buffer
, offset
, sizeof(*comm
));
1075 if (!lttng_buffer_view_is_valid(&comm_view
)) {
1080 comm
= (typeof(comm
)) comm_view
.data
;
1081 offset
+= sizeof(*comm
);
1083 local_context
= (struct lttng_event_context
*)
1084 zmalloc(sizeof(*local_context
));
1085 if (!local_context
) {
1090 local_context
->ctx
= (lttng_event_context_type
) comm
->type
;
1093 struct lttng_payload_view subtype_view
=
1094 lttng_payload_view_from_view(view
, offset
, -1);
1096 switch (local_context
->ctx
) {
1097 case LTTNG_EVENT_CONTEXT_APP_CONTEXT
:
1098 ret
= lttng_event_context_app_populate_from_payload(
1099 &subtype_view
, local_context
);
1101 case LTTNG_EVENT_CONTEXT_PERF_COUNTER
:
1102 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER
:
1103 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER
:
1104 ret
= lttng_event_context_perf_counter_populate_from_payload(
1105 &subtype_view
, local_context
);
1108 /* Nothing else to deserialize. */
1120 *event_ctx
= local_context
;
1121 local_context
= NULL
;
1125 free(local_context
);
1129 static int lttng_event_context_app_serialize(
1130 struct lttng_event_context
*context
,
1131 struct lttng_payload
*payload
)
1134 struct lttng_event_context_app_comm comm
= {};
1135 size_t provider_len
, ctx_len
;
1136 const char *provider_name
;
1137 const char *ctx_name
;
1141 assert(context
->ctx
== LTTNG_EVENT_CONTEXT_APP_CONTEXT
);
1143 provider_name
= context
->u
.app_ctx
.provider_name
;
1144 ctx_name
= context
->u
.app_ctx
.ctx_name
;
1146 if (!provider_name
|| !ctx_name
) {
1147 ret
= -LTTNG_ERR_INVALID
;
1151 provider_len
= strlen(provider_name
);
1152 if (provider_len
== 0) {
1153 ret
= -LTTNG_ERR_INVALID
;
1157 /* Include the null terminator. */
1159 comm
.provider_name_len
= provider_len
;
1161 ctx_len
= strlen(ctx_name
);
1163 ret
= -LTTNG_ERR_INVALID
;
1167 /* Include the null terminator. */
1169 comm
.ctx_name_len
= ctx_len
;
1172 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &comm
,
1179 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, provider_name
,
1186 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, ctx_name
,
1197 static int lttng_event_context_perf_counter_serialize(
1198 struct lttng_event_perf_counter_ctx
*context
,
1199 struct lttng_payload
*payload
)
1202 struct lttng_event_context_perf_counter_comm comm
= {};
1207 comm
.config
= context
->config
;
1208 comm
.type
= context
->type
;
1209 comm
.name_len
= lttng_strnlen(context
->name
, sizeof(context
->name
));
1211 if (comm
.name_len
== sizeof(context
->name
)) {
1216 /* Include the null terminator. */
1220 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &comm
,
1227 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, context
->name
,
1238 int lttng_event_context_serialize(struct lttng_event_context
*context
,
1239 struct lttng_payload
*payload
)
1242 struct lttng_event_context_comm context_comm
= { 0 };
1247 context_comm
.type
= (uint32_t) context
->ctx
;
1250 ret
= lttng_dynamic_buffer_append(
1251 &payload
->buffer
, &context_comm
, sizeof(context_comm
));
1256 switch (context
->ctx
) {
1257 case LTTNG_EVENT_CONTEXT_APP_CONTEXT
:
1258 ret
= lttng_event_context_app_serialize(context
, payload
);
1260 case LTTNG_EVENT_CONTEXT_PERF_COUNTER
:
1261 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER
:
1262 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER
:
1263 ret
= lttng_event_context_perf_counter_serialize(
1264 &context
->u
.perf_counter
, payload
);
1267 /* Nothing else to serialize. */
1279 void lttng_event_context_destroy(struct lttng_event_context
*context
)
1285 if (context
->ctx
== LTTNG_EVENT_CONTEXT_APP_CONTEXT
) {
1286 free(context
->u
.app_ctx
.provider_name
);
1287 free(context
->u
.app_ctx
.ctx_name
);
1294 * This is a specialized populate for lttng_event_field since it ignores
1295 * the extension field of the lttng_event struct and simply copies what it can
1296 * to the internal struct lttng_event of a lttng_event_field.
1298 static void lttng_event_field_populate_lttng_event_from_event(
1299 const struct lttng_event
*src
, struct lttng_event
*destination
)
1301 memcpy(destination
, src
, sizeof(*destination
));
1303 /* Remove all possible dynamic data from the destination event rule. */
1304 destination
->extended
.ptr
= NULL
;
1307 ssize_t
lttng_event_field_create_from_payload(
1308 struct lttng_payload_view
*view
,
1309 struct lttng_event_field
**field
)
1311 ssize_t ret
, offset
= 0;
1312 struct lttng_event_field
*local_event_field
= NULL
;
1313 struct lttng_event
*event
= NULL
;
1314 const struct lttng_event_field_comm
*comm
;
1315 const char* name
= NULL
;
1321 const struct lttng_buffer_view comm_view
=
1322 lttng_buffer_view_from_view(
1323 &view
->buffer
, offset
,
1326 if (!lttng_buffer_view_is_valid(&comm_view
)) {
1331 /* lttng_event_field_comm header */
1332 comm
= (const lttng_event_field_comm
*) comm_view
.data
;
1333 offset
+= sizeof(*comm
);
1336 local_event_field
= (struct lttng_event_field
*)
1337 zmalloc(sizeof(*local_event_field
));
1338 if (!local_event_field
) {
1343 local_event_field
->type
= (lttng_event_field_type
) comm
->type
;
1344 local_event_field
->nowrite
= comm
->nowrite
;
1348 const struct lttng_buffer_view name_view
=
1349 lttng_buffer_view_from_view(
1350 &view
->buffer
, offset
,
1353 if (!lttng_buffer_view_is_valid(&name_view
)) {
1358 name
= name_view
.data
;
1360 if (!lttng_buffer_view_contains_string(&name_view
,
1361 name_view
.data
, comm
->name_len
)) {
1366 if (comm
->name_len
> LTTNG_SYMBOL_NAME_LEN
- 1) {
1367 /* Name is too long.*/
1372 offset
+= comm
->name_len
;
1377 struct lttng_payload_view event_view
=
1378 lttng_payload_view_from_view(
1382 if (!lttng_payload_view_is_valid(&event_view
)) {
1387 ret
= lttng_event_create_from_payload(&event_view
, &event
, NULL
,
1389 if (ret
!= comm
->event_len
) {
1400 if (lttng_strncpy(local_event_field
->field_name
, name
,
1401 sizeof(local_event_field
->field_name
))) {
1406 lttng_event_field_populate_lttng_event_from_event(
1407 event
, &local_event_field
->event
);
1409 *field
= local_event_field
;
1410 local_event_field
= NULL
;
1413 lttng_event_destroy(event
);
1414 free(local_event_field
);
1418 int lttng_event_field_serialize(const struct lttng_event_field
*field
,
1419 struct lttng_payload
*payload
)
1422 size_t header_offset
, size_before_event
;
1424 struct lttng_event_field_comm event_field_comm
= {};
1425 struct lttng_event_field_comm
*header
;
1430 /* Save the header location for later in-place header update. */
1431 header_offset
= payload
->buffer
.size
;
1433 name_len
= strnlen(field
->field_name
, sizeof(field
->field_name
));
1434 if (name_len
== sizeof(field
->field_name
)) {
1435 /* Event name is not NULL-terminated. */
1440 /* Add null termination. */
1443 event_field_comm
.type
= field
->type
;
1444 event_field_comm
.nowrite
= (uint8_t)field
->nowrite
;
1445 event_field_comm
.name_len
= name_len
;
1448 ret
= lttng_dynamic_buffer_append(
1449 &payload
->buffer
, &event_field_comm
,
1450 sizeof(event_field_comm
));
1456 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, field
->field_name
,
1462 size_before_event
= payload
->buffer
.size
;
1463 ret
= lttng_event_serialize(
1464 &field
->event
, 0, NULL
, NULL
, 0, 0, payload
);
1470 /* Update the event len. */
1471 header
= (struct lttng_event_field_comm
*)
1472 ((char *) payload
->buffer
.data
+
1474 header
->event_len
= payload
->buffer
.size
- size_before_event
;
1480 static enum lttng_error_code
compute_flattened_size(
1481 struct lttng_dynamic_pointer_array
*events
, size_t *size
)
1483 enum lttng_error_code ret_code
;
1485 size_t storage_req
, event_count
, i
;
1490 event_count
= lttng_dynamic_pointer_array_get_count(events
);
1492 /* The basic struct lttng_event */
1493 storage_req
= event_count
* sizeof(struct lttng_event
);
1495 /* The struct·lttng_event_extended */
1496 storage_req
+= event_count
* sizeof(struct lttng_event_extended
);
1498 for (i
= 0; i
< event_count
; i
++) {
1499 int probe_storage_req
= 0;
1500 const struct event_list_element
*element
= (const struct event_list_element
*)
1501 lttng_dynamic_pointer_array_get_pointer(
1503 const struct lttng_userspace_probe_location
*location
= NULL
;
1505 location
= lttng_event_get_userspace_probe_location(
1508 ret
= lttng_userspace_probe_location_flatten(
1511 ret_code
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
1515 probe_storage_req
= ret
;
1518 if (element
->filter_expression
) {
1519 storage_req
+= strlen(element
->filter_expression
) + 1;
1522 if (element
->exclusions
) {
1523 storage_req
+= element
->exclusions
->count
*
1524 LTTNG_SYMBOL_NAME_LEN
;
1527 /* Padding to ensure the flat probe is aligned. */
1528 storage_req
= lttng_align_ceil(storage_req
, sizeof(uint64_t));
1529 storage_req
+= probe_storage_req
;
1532 *size
= storage_req
;
1533 ret_code
= LTTNG_OK
;
1540 * Flatten a list of struct lttng_event.
1542 * The buffer that is returned to the API client must contain a "flat" version
1543 * of the events that are returned. In other words, all pointers within an
1544 * lttng_event must point to a location within the returned buffer so that the
1545 * user may free everything by simply calling free() on the returned buffer.
1546 * This is needed in order to maintain API compatibility.
1548 * A first pass is performed to compute the size of the buffer that must be
1549 * allocated. A second pass is then performed to setup the returned events so
1550 * that their members always point within the buffer.
1552 * The layout of the returned buffer is as follows:
1553 * - struct lttng_event[nb_events],
1554 * - nb_events times the following:
1555 * - struct lttng_event_extended,
1556 * - filter_expression
1558 * - padding to align to 64-bits
1559 * - flattened version of userspace_probe_location
1561 static enum lttng_error_code
flatten_lttng_events(
1562 struct lttng_dynamic_pointer_array
*events
,
1563 struct lttng_event
**flattened_events
)
1565 enum lttng_error_code ret_code
;
1568 struct lttng_dynamic_buffer local_flattened_events
;
1572 assert(flattened_events
);
1574 lttng_dynamic_buffer_init(&local_flattened_events
);
1575 nb_events
= lttng_dynamic_pointer_array_get_count(events
);
1577 ret_code
= compute_flattened_size(events
, &storage_req
);
1578 if (ret_code
!= LTTNG_OK
) {
1583 * We must ensure that "local_flattened_events" is never resized so as
1584 * to preserve the validity of the flattened objects.
1586 ret
= lttng_dynamic_buffer_set_capacity(
1587 &local_flattened_events
, storage_req
);
1589 ret_code
= LTTNG_ERR_NOMEM
;
1593 /* Start by laying the struct lttng_event */
1594 for (i
= 0; i
< nb_events
; i
++) {
1595 const struct event_list_element
*element
= (const struct event_list_element
*)
1596 lttng_dynamic_pointer_array_get_pointer(
1600 ret_code
= LTTNG_ERR_FATAL
;
1604 ret
= lttng_dynamic_buffer_append(&local_flattened_events
,
1605 element
->event
, sizeof(struct lttng_event
));
1607 ret_code
= LTTNG_ERR_NOMEM
;
1612 for (i
= 0; i
< nb_events
; i
++) {
1613 const struct event_list_element
*element
= (const struct event_list_element
*)
1614 lttng_dynamic_pointer_array_get_pointer(events
, i
);
1615 struct lttng_event
*event
= (struct lttng_event
*)
1616 (local_flattened_events
.data
+ (sizeof(struct lttng_event
) * i
));
1617 struct lttng_event_extended
*event_extended
=
1618 (struct lttng_event_extended
*)
1619 (local_flattened_events
.data
+ local_flattened_events
.size
);
1620 const struct lttng_userspace_probe_location
*location
= NULL
;
1624 /* Insert struct lttng_event_extended. */
1625 ret
= lttng_dynamic_buffer_set_size(&local_flattened_events
,
1626 local_flattened_events
.size
+
1627 sizeof(*event_extended
));
1629 ret_code
= LTTNG_ERR_NOMEM
;
1632 event
->extended
.ptr
= event_extended
;
1634 /* Insert filter expression. */
1635 if (element
->filter_expression
) {
1636 const size_t len
= strlen(element
->filter_expression
) + 1;
1638 event_extended
->filter_expression
=
1639 local_flattened_events
.data
+
1640 local_flattened_events
.size
;
1641 ret
= lttng_dynamic_buffer_append(
1642 &local_flattened_events
,
1643 element
->filter_expression
, len
);
1645 ret_code
= LTTNG_ERR_NOMEM
;
1650 /* Insert exclusions. */
1651 if (element
->exclusions
) {
1652 event_extended
->exclusions
.count
=
1653 element
->exclusions
->count
;
1654 event_extended
->exclusions
.strings
=
1655 local_flattened_events
.data
+
1656 local_flattened_events
.size
;
1658 ret
= lttng_dynamic_buffer_append(
1659 &local_flattened_events
,
1660 element
->exclusions
->names
,
1661 element
->exclusions
->count
*
1662 LTTNG_SYMBOL_NAME_LEN
);
1664 ret_code
= LTTNG_ERR_NOMEM
;
1669 /* Insert padding to align to 64-bits. */
1670 ret
= lttng_dynamic_buffer_set_size(&local_flattened_events
,
1671 lttng_align_ceil(local_flattened_events
.size
,
1674 ret_code
= LTTNG_ERR_NOMEM
;
1678 location
= lttng_event_get_userspace_probe_location(
1681 event_extended
->probe_location
= (struct lttng_userspace_probe_location
*)
1682 (local_flattened_events
.data
+ local_flattened_events
.size
);
1683 ret
= lttng_userspace_probe_location_flatten(
1684 location
, &local_flattened_events
);
1686 ret_code
= LTTNG_ERR_PROBE_LOCATION_INVAL
;
1692 /* Don't reset local_flattened_events buffer as we return its content. */
1693 *flattened_events
= (struct lttng_event
*) local_flattened_events
.data
;
1694 lttng_dynamic_buffer_init(&local_flattened_events
);
1695 ret_code
= LTTNG_OK
;
1697 lttng_dynamic_buffer_reset(&local_flattened_events
);
1701 static enum lttng_error_code
event_list_create_from_payload(
1702 struct lttng_payload_view
*view
,
1704 struct lttng_dynamic_pointer_array
*event_list
)
1706 enum lttng_error_code ret_code
;
1714 for (i
= 0; i
< count
; i
++) {
1716 struct lttng_payload_view event_view
=
1717 lttng_payload_view_from_view(view
, offset
, -1);
1718 struct event_list_element
*element
=
1719 (struct event_list_element
*) zmalloc(sizeof(*element
));
1722 ret_code
= LTTNG_ERR_NOMEM
;
1727 * Lifetime and management of the object is now bound to the
1730 ret
= lttng_dynamic_pointer_array_add_pointer(
1731 event_list
, element
);
1733 event_list_destructor(element
);
1734 ret_code
= LTTNG_ERR_NOMEM
;
1739 * Bytecode is not transmitted on listing in any case we do not
1742 event_size
= lttng_event_create_from_payload(&event_view
,
1744 &element
->exclusions
,
1745 &element
->filter_expression
, NULL
);
1746 if (event_size
< 0) {
1747 ret_code
= LTTNG_ERR_INVALID
;
1751 offset
+= event_size
;
1754 if (view
->buffer
.size
!= offset
) {
1755 ret_code
= LTTNG_ERR_INVALID_PROTOCOL
;
1759 ret_code
= LTTNG_OK
;
1765 enum lttng_error_code
lttng_events_create_and_flatten_from_payload(
1766 struct lttng_payload_view
*payload
,
1768 struct lttng_event
**events
)
1770 enum lttng_error_code ret
= LTTNG_OK
;
1771 struct lttng_dynamic_pointer_array local_events
;
1773 lttng_dynamic_pointer_array_init(&local_events
, event_list_destructor
);
1775 /* Deserialize the events. */
1777 struct lttng_payload_view events_view
=
1778 lttng_payload_view_from_view(payload
, 0, -1);
1780 ret
= event_list_create_from_payload(
1781 &events_view
, count
, &local_events
);
1782 if (ret
!= LTTNG_OK
) {
1787 ret
= flatten_lttng_events(&local_events
, events
);
1788 if (ret
!= LTTNG_OK
) {
1793 lttng_dynamic_pointer_array_reset(&local_events
);
1797 static enum lttng_error_code
flatten_lttng_event_fields(
1798 struct lttng_dynamic_pointer_array
*event_fields
,
1799 struct lttng_event_field
**flattened_event_fields
)
1802 enum lttng_error_code ret_code
;
1803 size_t storage_req
= 0;
1804 struct lttng_dynamic_buffer local_flattened_event_fields
;
1807 assert(event_fields
);
1808 assert(flattened_event_fields
);
1810 lttng_dynamic_buffer_init(&local_flattened_event_fields
);
1811 nb_event_field
= lttng_dynamic_pointer_array_get_count(event_fields
);
1814 * Here even if the event field contains a `struct lttng_event` that
1815 * could contain dynamic data, in reality it is not the case.
1816 * Dynamic data is not present. Here the flattening is mostly a direct
1817 * memcpy. This is less than ideal but this code is still better than
1818 * direct usage of an unpacked lttng_event_field array.
1820 storage_req
+= sizeof(struct lttng_event_field
) * nb_event_field
;
1822 lttng_dynamic_buffer_init(&local_flattened_event_fields
);
1825 * We must ensure that "local_flattened_event_fields" is never resized
1826 * so as to preserve the validity of the flattened objects.
1828 ret
= lttng_dynamic_buffer_set_capacity(
1829 &local_flattened_event_fields
, storage_req
);
1831 ret_code
= LTTNG_ERR_NOMEM
;
1835 for (i
= 0; i
< nb_event_field
; i
++) {
1836 const struct lttng_event_field
*element
=
1837 (const struct lttng_event_field
*)
1838 lttng_dynamic_pointer_array_get_pointer(
1842 ret_code
= LTTNG_ERR_FATAL
;
1845 ret
= lttng_dynamic_buffer_append(&local_flattened_event_fields
,
1846 element
, sizeof(struct lttng_event_field
));
1848 ret_code
= LTTNG_ERR_NOMEM
;
1853 /* Don't reset local_flattened_channels buffer as we return its content. */
1854 *flattened_event_fields
= (struct lttng_event_field
*) local_flattened_event_fields
.data
;
1855 lttng_dynamic_buffer_init(&local_flattened_event_fields
);
1856 ret_code
= LTTNG_OK
;
1858 lttng_dynamic_buffer_reset(&local_flattened_event_fields
);
1862 static enum lttng_error_code
event_field_list_create_from_payload(
1863 struct lttng_payload_view
*view
,
1865 struct lttng_dynamic_pointer_array
**event_field_list
)
1867 enum lttng_error_code ret_code
;
1868 int ret
, offset
= 0;
1870 struct lttng_dynamic_pointer_array
*list
= NULL
;
1873 assert(event_field_list
);
1875 list
= (struct lttng_dynamic_pointer_array
*) zmalloc(sizeof(*list
));
1877 ret_code
= LTTNG_ERR_NOMEM
;
1881 lttng_dynamic_pointer_array_init(list
, free
);
1883 for (i
= 0; i
< count
; i
++) {
1884 ssize_t event_field_size
;
1885 struct lttng_event_field
*field
= NULL
;
1886 struct lttng_payload_view event_field_view
=
1887 lttng_payload_view_from_view(view
, offset
, -1);
1889 event_field_size
= lttng_event_field_create_from_payload(
1890 &event_field_view
, &field
);
1891 if (event_field_size
< 0) {
1892 ret_code
= LTTNG_ERR_INVALID
;
1896 /* Lifetime and management of the object is now bound to the array. */
1897 ret
= lttng_dynamic_pointer_array_add_pointer(list
, field
);
1900 ret_code
= LTTNG_ERR_NOMEM
;
1904 offset
+= event_field_size
;
1907 if (view
->buffer
.size
!= offset
) {
1908 ret_code
= LTTNG_ERR_INVALID
;
1912 *event_field_list
= list
;
1914 ret_code
= LTTNG_OK
;
1918 lttng_dynamic_pointer_array_reset(list
);
1925 enum lttng_error_code
lttng_event_fields_create_and_flatten_from_payload(
1926 struct lttng_payload_view
*view
,
1928 struct lttng_event_field
**fields
)
1930 enum lttng_error_code ret_code
;
1931 struct lttng_dynamic_pointer_array
*local_event_fields
= NULL
;
1933 ret_code
= event_field_list_create_from_payload(
1934 view
, count
, &local_event_fields
);
1935 if (ret_code
!= LTTNG_OK
) {
1939 ret_code
= flatten_lttng_event_fields(local_event_fields
, fields
);
1940 if (ret_code
!= LTTNG_OK
) {
1944 if (local_event_fields
) {
1945 lttng_dynamic_pointer_array_reset(local_event_fields
);
1946 free(local_event_fields
);