* SPDX-License-Identifier: LGPL-2.1-only
*/
-#include <lttng/session-descriptor-internal.hpp>
-#include <common/macros.hpp>
-#include <common/uri.hpp>
#include <common/defaults.hpp>
#include <common/error.hpp>
-#include <time.h>
+#include <common/macros.hpp>
+#include <common/payload-view.hpp>
+#include <common/payload.hpp>
+#include <common/uri.hpp>
+#include <lttng/session-descriptor-internal.hpp>
+#include <lttng/trace-format-descriptor-internal.hpp>
+#include <lttng/trace-format-descriptor.h>
+#include <memory>
#include <stdio.h>
+#include <time.h>
namespace {
struct lttng_session_descriptor_network_location {
struct lttng_session_descriptor_network_location network;
struct lttng_uri *local;
} output;
+
+ lttng::trace_format_descriptor *format_descriptor;
};
namespace {
uint8_t output_type;
/* Includes trailing null. */
uint32_t name_len;
- /* Name follows, followed by URIs */
+ /* Number of URIs */
uint8_t uri_count;
+ /* Size of lttng_trace_format_descriptor */
+ uint32_t trace_format_len;
+ /* Name follows, followed by URIs, followed by lttng_trace_format */
} LTTNG_PACKED;
struct lttng_session_descriptor_live_comm {
if (lttng_session_descriptor_set_session_name(descriptor, name)) {
goto error;
}
+
+ /* Default to ctf1 trace format */
+ try {
+ descriptor->format_descriptor = new lttng::trace_format_descriptor_ctf1();
+ } catch (const std::exception& ex) {
+ descriptor->format_descriptor = nullptr;
+ goto error;
+ }
+
return descriptor;
error:
lttng_session_descriptor_destroy(descriptor);
name)) {
goto error;
}
+
+ /* Default to ctf1 trace format */
+ try {
+ descriptor->base.format_descriptor = new lttng::trace_format_descriptor_ctf1();
+ } catch (const std::exception& ex) {
+ descriptor->base.format_descriptor = nullptr;
+ goto error;
+ }
+
return descriptor;
error:
lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
descriptor->base.type = LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE;
descriptor->base.output_type =
LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE;
+
descriptor->live_timer_us = live_timer_interval_us;
if (lttng_session_descriptor_set_session_name(&descriptor->base,
name)) {
goto error;
}
+ /* Default to ctf1 trace format */
+ try {
+ descriptor->base.format_descriptor = new lttng::trace_format_descriptor_ctf1();
+ } catch (const std::exception& ex) {
+ descriptor->base.format_descriptor = nullptr;
+ goto error;
+ }
+
return descriptor;
error:
lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
abort();
}
+ delete (descriptor->format_descriptor);
free(descriptor->name);
free(descriptor);
}
int i;
ssize_t offset = 0, ret;
struct lttng_buffer_view current_view;
+
const char *name = NULL;
const struct lttng_session_descriptor_comm *base_header;
size_t max_expected_uri_count;
struct lttng_uri *uris[2] = {};
enum lttng_session_descriptor_type type;
enum lttng_session_descriptor_output_type output_type;
+ lttng::trace_format_descriptor::uptr trace_format;
current_view = lttng_buffer_view_from_view(payload, offset,
sizeof(*base_header));
offset += sizeof(*uri);
}
+ /* Deserialize trace format */
+ {
+ struct lttng_payload_view current_payload_view =
+ lttng_payload_view_from_buffer_view(
+ payload, offset, base_header->trace_format_len);
+ if (!lttng_buffer_view_is_valid(¤t_view)) {
+ ret = -1;
+ goto end;
+ }
+ ret = lttng::trace_format_descriptor::create_from_payload(
+ ¤t_payload_view, trace_format);
+ if (ret < 0 || ret != base_header->trace_format_len) {
+ ret = -1;
+ goto end;
+ }
+ }
+
switch (type) {
case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
switch (output_type) {
goto end;
}
+ (*descriptor)->format_descriptor = trace_format.release();
+
ret = offset;
end:
free(uris[0]);
}
int lttng_session_descriptor_serialize(
- const struct lttng_session_descriptor *descriptor,
- struct lttng_dynamic_buffer *buffer)
+ const struct lttng_session_descriptor *descriptor, lttng_payload *payload)
{
int ret, i;
+ size_t header_offset, size_before_payload;
/* There are, at most, two URIs to serialize. */
struct lttng_uri *uris[2] = {};
size_t uri_count = 0;
/* The live header is a superset of all headers. */
struct lttng_session_descriptor_live_comm header = {
- .base = {
- .type = (uint8_t) descriptor->type,
- .output_type = (uint8_t) descriptor->output_type,
- .name_len = (uint32_t) (descriptor->name ?
- strlen(descriptor->name) + 1 : 0),
- .uri_count = 0,
- },
- .live_timer_us = 0,
+ .base =
+ {
+ .type = (uint8_t) descriptor->type,
+ .output_type = (uint8_t) descriptor
+ ->output_type,
+ .name_len = (uint32_t) (descriptor->name ?
+ strlen(descriptor->name) +
+ 1 :
+ 0),
+ .uri_count = 0,
+ .trace_format_len = 0,
+ },
+ .live_timer_us = 0,
};
+ struct lttng_session_descriptor_comm *base_header;
const void *header_ptr = NULL;
size_t header_size;
header_size = sizeof(header.base);
}
- ret = lttng_dynamic_buffer_append(buffer, header_ptr, header_size);
+ header_offset = payload->buffer.size;
+ ret = lttng_dynamic_buffer_append(&payload->buffer, header_ptr, header_size);
if (ret) {
goto end;
}
if (header.base.name_len) {
- ret = lttng_dynamic_buffer_append(buffer, descriptor->name,
- header.base.name_len);
+ ret = lttng_dynamic_buffer_append(
+ &payload->buffer, descriptor->name, header.base.name_len);
if (ret) {
goto end;
}
}
for (i = 0; i < uri_count; i++) {
- ret = lttng_dynamic_buffer_append(buffer, uris[i],
- sizeof(struct lttng_uri));
+ ret = lttng_dynamic_buffer_append(
+ &payload->buffer, uris[i], sizeof(struct lttng_uri));
if (ret) {
goto end;
}
}
+
+ /* Serialize trace format */
+ size_before_payload = payload->buffer.size;
+ ret = reinterpret_cast<lttng::trace_format_descriptor *>(descriptor->format_descriptor)
+ ->serialize(payload);
+ if (ret) {
+ goto end;
+ }
+ base_header = (typeof(base_header)) (payload->buffer.data + header_offset);
+ base_header->trace_format_len = payload->buffer.size - size_before_payload;
end:
return ret;
}
if (ret) {
goto end;
}
+
+ try {
+ dst->format_descriptor = src->format_descriptor->clone().release();
+ } catch (...) {
+ ret = -1;
+ goto end;
+ }
+
switch (dst->output_type) {
case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
free(dst->output.local);
struct lttng_buffer_view reply_view;
int reply_ret;
bool sessiond_must_generate_ouput;
- struct lttng_dynamic_buffer payload;
+ struct lttng_payload payload;
int ret;
size_t descriptor_size;
struct lttng_session_descriptor *descriptor_reply = NULL;
- lttng_dynamic_buffer_init(&payload);
+ lttng_payload_init(&payload);
if (!session_descriptor) {
ret_code = LTTNG_ERR_INVALID;
goto end;
}
lsm.u.create_session.home_dir_size = (uint16_t) home_dir_len;
- ret = lttng_dynamic_buffer_append(&payload, home_dir,
- home_dir_len);
+ ret = lttng_dynamic_buffer_append(&payload.buffer, home_dir, home_dir_len);
if (ret) {
ret_code = LTTNG_ERR_NOMEM;
goto end;
}
}
- descriptor_size = payload.size;
+ descriptor_size = payload.buffer.size;
ret = lttng_session_descriptor_serialize(session_descriptor,
&payload);
if (ret) {
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- descriptor_size = payload.size - descriptor_size;
+ descriptor_size = payload.buffer.size - descriptor_size;
lsm.u.create_session.session_descriptor_size = descriptor_size;
/* Command returns a session descriptor on success. */
- reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, payload.data,
- payload.size, &reply);
+ reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(
+ &lsm, payload.buffer.data, payload.buffer.size, &reply);
if (reply_ret < 0) {
ret_code = (lttng_error_code) -reply_ret;
goto end;
lttng_session_descriptor_assign(session_descriptor, descriptor_reply);
end:
free(reply);
- lttng_dynamic_buffer_reset(&payload);
+ lttng_payload_reset(&payload);
lttng_session_descriptor_destroy(descriptor_reply);
return ret_code;
}