2 * Copyright (C) 2021 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include <common/macros.h>
9 #include <lttng/channel.h>
10 #include <lttng/constant.h>
11 #include <lttng/channel-internal.h>
12 #include <lttng/userspace-probe-internal.h>
13 #include <common/dynamic-buffer.h>
14 #include <common/error.h>
17 #include <common/sessiond-comm/sessiond-comm.h>
18 #include <common/dynamic-array.h>
19 #include <common/buffer-view.h>
21 static enum lttng_error_code
flatten_lttng_channels(
22 struct lttng_dynamic_pointer_array
*channels
,
23 struct lttng_channel
**flattened_channels
);
25 static enum lttng_error_code
channel_list_create_from_buffer(
26 const struct lttng_buffer_view
*buffer
,
28 struct lttng_dynamic_pointer_array
*channel_list
);
30 static void channel_list_destructor(void *ptr
)
32 struct lttng_channel
*element
= (struct lttng_channel
*) ptr
;
34 lttng_channel_destroy(element
);
38 struct lttng_channel
*lttng_channel_copy(const struct lttng_channel
*src
)
40 struct lttng_channel_extended
*extended
= NULL
;
41 struct lttng_channel
*channel
= NULL
, *ret
= NULL
;
43 channel
= zmalloc(sizeof(*channel
));
48 memcpy(channel
, src
, sizeof(*channel
));
50 if (src
->attr
.extended
.ptr
) {
51 extended
= zmalloc(sizeof(*extended
));
55 memcpy(extended
, src
->attr
.extended
.ptr
, sizeof(*extended
));
56 channel
->attr
.extended
.ptr
= extended
;
69 * The channel object is NOT populated.
72 struct lttng_channel
*lttng_channel_create_internal(void)
74 struct lttng_channel
*local_channel
= NULL
, *ret
= NULL
;
75 struct lttng_channel_extended
*extended
= NULL
;
77 local_channel
= zmalloc(sizeof(struct lttng_channel
));
83 extended
= zmalloc(sizeof(*extended
));
88 local_channel
->attr
.extended
.ptr
= extended
;
100 ssize_t
lttng_channel_create_from_buffer(const struct lttng_buffer_view
*view
,
101 struct lttng_channel
**channel
)
103 ssize_t ret
, offset
= 0;
104 struct lttng_channel
*local_channel
= NULL
;
105 const struct lttng_channel_comm
*channel_comm
;
106 struct lttng_channel_extended
*extended
= NULL
;
110 if (!view
|| !channel
) {
116 * Create an 'internal' channel since `lttng_create_channel` requires a
117 * domain and we cannot infer the domain from the payload.
119 local_channel
= lttng_channel_create_internal();
120 if (!local_channel
) {
125 extended
= (typeof(extended
)) local_channel
->attr
.extended
.ptr
;
127 /* lttng_trigger_comm header */
129 const struct lttng_buffer_view comm_view
=
130 lttng_buffer_view_from_view(view
, offset
,
131 sizeof(*channel_comm
));
133 if (!lttng_buffer_view_is_valid(&comm_view
)) {
138 channel_comm
= (const struct lttng_channel_comm
*)
140 offset
+= sizeof(*channel_comm
);
145 const struct lttng_buffer_view name_view
=
146 lttng_buffer_view_from_view(view
, offset
,
147 channel_comm
->name_len
);
149 if (channel_comm
->name_len
> LTTNG_SYMBOL_NAME_LEN
- 1) {
154 name
= name_view
.data
;
155 if (!lttng_buffer_view_contains_string(
156 &name_view
, name
, channel_comm
->name_len
)) {
161 strcpy(local_channel
->name
, name
);
162 offset
+= channel_comm
->name_len
;
165 /* Populate the channel */
166 local_channel
->enabled
= channel_comm
->enabled
;
169 local_channel
->attr
.overwrite
= channel_comm
->overwrite
;
170 local_channel
->attr
.subbuf_size
= channel_comm
->subbuf_size
;
171 local_channel
->attr
.num_subbuf
= channel_comm
->num_subbuf
;
172 local_channel
->attr
.switch_timer_interval
=
173 channel_comm
->switch_timer_interval
;
174 local_channel
->attr
.read_timer_interval
=
175 channel_comm
->read_timer_interval
;
176 local_channel
->attr
.output
= channel_comm
->output
;
177 local_channel
->attr
.tracefile_size
= channel_comm
->tracefile_size
;
178 local_channel
->attr
.tracefile_count
= channel_comm
->tracefile_count
;
179 local_channel
->attr
.live_timer_interval
=
180 channel_comm
->live_timer_interval
;
182 extended
->discarded_events
= channel_comm
->discarded_events
;
183 extended
->lost_packets
= channel_comm
->lost_packets
;
184 extended
->monitor_timer_interval
= channel_comm
->monitor_timer_interval
;
185 extended
->blocking_timeout
= channel_comm
->blocking_timeout
;
187 *channel
= local_channel
;
188 local_channel
= NULL
;
192 lttng_channel_destroy(local_channel
);
197 int lttng_channel_serialize(
198 struct lttng_channel
*channel
, struct lttng_dynamic_buffer
*buf
)
202 struct lttng_channel_comm channel_comm
= { 0 };
203 struct lttng_channel_extended
*extended
;
208 extended
= channel
->attr
.extended
.ptr
;
210 name_len
= lttng_strnlen(channel
->name
, LTTNG_SYMBOL_NAME_LEN
);
211 if (name_len
== LTTNG_SYMBOL_NAME_LEN
) {
212 /* channel name is not NULL-terminated. */
217 /* Include string termination. */
221 channel_comm
.name_len
= (uint32_t) name_len
;
222 channel_comm
.enabled
= channel
->enabled
;
225 channel_comm
.overwrite
= channel
->attr
.overwrite
;
226 channel_comm
.subbuf_size
= channel
->attr
.subbuf_size
;
227 channel_comm
.num_subbuf
= channel
->attr
.num_subbuf
;
228 channel_comm
.switch_timer_interval
=
229 channel
->attr
.switch_timer_interval
;
230 channel_comm
.read_timer_interval
= channel
->attr
.read_timer_interval
;
231 channel_comm
.output
= channel
->attr
.output
;
232 channel_comm
.tracefile_size
= channel
->attr
.tracefile_size
;
233 channel_comm
.tracefile_count
= channel
->attr
.tracefile_count
;
234 channel_comm
.live_timer_interval
= channel
->attr
.live_timer_interval
;
236 /* Extended struct */
237 channel_comm
.discarded_events
= extended
->discarded_events
;
238 channel_comm
.lost_packets
= extended
->lost_packets
;
239 channel_comm
.monitor_timer_interval
= extended
->monitor_timer_interval
;
240 channel_comm
.blocking_timeout
= extended
->blocking_timeout
;
243 ret
= lttng_dynamic_buffer_append(
244 buf
, &channel_comm
, sizeof(channel_comm
));
250 ret
= lttng_dynamic_buffer_append(buf
, channel
->name
, name_len
);
259 void lttng_channel_set_default_extended_attr(struct lttng_domain
*domain
,
260 struct lttng_channel_extended
*extended_attr
)
263 assert(extended_attr
);
265 memset(extended_attr
, 0, sizeof(*extended_attr
));
267 switch (domain
->type
) {
268 case LTTNG_DOMAIN_KERNEL
:
269 extended_attr
->monitor_timer_interval
=
270 DEFAULT_KERNEL_CHANNEL_MONITOR_TIMER
;
271 extended_attr
->blocking_timeout
=
272 DEFAULT_KERNEL_CHANNEL_BLOCKING_TIMEOUT
;
274 case LTTNG_DOMAIN_UST
:
275 switch (domain
->buf_type
) {
276 case LTTNG_BUFFER_PER_UID
:
277 extended_attr
->monitor_timer_interval
=
278 DEFAULT_UST_UID_CHANNEL_MONITOR_TIMER
;
279 extended_attr
->blocking_timeout
=
280 DEFAULT_UST_UID_CHANNEL_BLOCKING_TIMEOUT
;
282 case LTTNG_BUFFER_PER_PID
:
285 extended_attr
->monitor_timer_interval
=
286 DEFAULT_UST_PID_CHANNEL_MONITOR_TIMER
;
287 extended_attr
->blocking_timeout
=
288 DEFAULT_UST_PID_CHANNEL_BLOCKING_TIMEOUT
;
293 /* Default behavior: leave set to 0. */
298 static enum lttng_error_code
channel_list_create_from_buffer(
299 const struct lttng_buffer_view
*view
,
301 struct lttng_dynamic_pointer_array
*channel_list
)
303 enum lttng_error_code ret_code
;
308 assert(channel_list
);
310 for (i
= 0; i
< count
; i
++) {
311 ssize_t channel_size
;
312 struct lttng_channel
*channel
= NULL
;
313 const struct lttng_buffer_view channel_view
=
314 lttng_buffer_view_from_view(view
, offset
, -1);
316 channel_size
= lttng_channel_create_from_buffer(
317 &channel_view
, &channel
);
318 if (channel_size
< 0) {
319 ret_code
= LTTNG_ERR_INVALID
;
323 /* Lifetime and management of the object is now bound to the array. */
324 ret
= lttng_dynamic_pointer_array_add_pointer(channel_list
, channel
);
326 lttng_channel_destroy(channel
);
327 ret_code
= LTTNG_ERR_NOMEM
;
330 offset
+= channel_size
;
333 if (view
->size
!= offset
) {
334 ret_code
= LTTNG_ERR_INVALID
;
344 static enum lttng_error_code
flatten_lttng_channels(struct lttng_dynamic_pointer_array
*channels
,
345 struct lttng_channel
**flattened_channels
)
347 enum lttng_error_code ret_code
;
349 size_t storage_req
= 0;
350 struct lttng_dynamic_buffer local_flattened_channels
;
354 assert(flattened_channels
);
356 lttng_dynamic_buffer_init(&local_flattened_channels
);
357 nb_channels
= lttng_dynamic_pointer_array_get_count(channels
);
359 storage_req
+= sizeof(struct lttng_channel
) * nb_channels
;
360 storage_req
+= sizeof(struct lttng_channel_extended
) * nb_channels
;
363 * We must ensure that "local_flattened_channels" is never resized so as
364 * to preserve the validity of the flattened objects.
366 ret
= lttng_dynamic_buffer_set_capacity(
367 &local_flattened_channels
, storage_req
);
369 ret_code
= LTTNG_ERR_NOMEM
;
373 /* Start by laying the struct lttng_channel */
374 for (i
= 0; i
< nb_channels
; i
++) {
375 const struct lttng_channel
*element
=
376 lttng_dynamic_pointer_array_get_pointer(
380 ret_code
= LTTNG_ERR_FATAL
;
383 ret
= lttng_dynamic_buffer_append(&local_flattened_channels
,
384 element
, sizeof(struct lttng_channel
));
386 ret_code
= LTTNG_ERR_NOMEM
;
391 /* Flatten the extended data */
392 for (i
= 0; i
< nb_channels
; i
++) {
393 const struct lttng_channel
*element
=
394 lttng_dynamic_pointer_array_get_pointer(
397 * Sample the location of the flattened channel we are about
400 struct lttng_channel
*channel
= (struct lttng_channel
*)
401 (local_flattened_channels
.data
+ (sizeof(struct lttng_channel
) * i
));
403 * Sample the location of the extended attributes we are about
406 struct lttng_channel_extended
*channel_extended
=
407 (struct lttng_channel_extended
*)
408 (local_flattened_channels
.data
+ local_flattened_channels
.size
);
411 ret_code
= LTTNG_ERR_FATAL
;
415 ret
= lttng_dynamic_buffer_append(&local_flattened_channels
,
416 element
->attr
.extended
.ptr
,
417 sizeof(struct lttng_channel_extended
));
419 ret_code
= LTTNG_ERR_NOMEM
;
424 * Update the flattened lttng_channel object with its flattened
425 * extended object location.
427 channel
->attr
.extended
.ptr
= channel_extended
;
430 /* Don't reset local_flattened_channels buffer as we return its content. */
431 *flattened_channels
= (struct lttng_channel
*) local_flattened_channels
.data
;
432 lttng_dynamic_buffer_init(&local_flattened_channels
);
435 lttng_dynamic_buffer_reset(&local_flattened_channels
);
440 enum lttng_error_code
lttng_channels_create_and_flatten_from_buffer(
441 const struct lttng_buffer_view
*view
,
443 struct lttng_channel
**channels
)
445 enum lttng_error_code ret_code
;
446 struct lttng_dynamic_pointer_array local_channels
;
448 lttng_dynamic_pointer_array_init(&local_channels
, channel_list_destructor
);
450 /* Deserialize the channels */
452 const struct lttng_buffer_view channels_view
=
453 lttng_buffer_view_from_view(view
, 0, -1);
455 ret_code
= channel_list_create_from_buffer(
456 &channels_view
, count
, &local_channels
);
457 if (ret_code
!= LTTNG_OK
) {
462 ret_code
= flatten_lttng_channels(&local_channels
, channels
);
465 lttng_dynamic_pointer_array_reset(&local_channels
);