/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
- * Copyright (C) 2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * SPDX-License-Identifier: LGPL-2.1-only
*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*/
-#define _GNU_SOURCE
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <lttng/ust-ctl.h>
#include <ust-comm.h>
#include <ust-fd.h>
-#include <helper.h>
+#include <ust-helper.h>
#include <lttng/ust-error.h>
-#include <lttng/ust-events.h>
-#include <lttng/ust-dynamic-type.h>
+#include <ust-dynamic-type.h>
#include <usterr-signal-safe.h>
+#include "../liblttng-ust/ust-events-internal.h"
#include "../liblttng-ust/compat.h"
#define USTCOMM_CODE_OFFSET(code) \
static
ssize_t count_fields_recursive(size_t nr_fields,
- const struct lttng_event_field *lttng_fields);
+ const struct lttng_ust_event_field **lttng_fields);
static
-int serialize_one_field(struct lttng_session *session,
+int serialize_one_field(struct lttng_ust_session *session,
struct ustctl_field *fields, size_t *iter_output,
- const struct lttng_event_field *lf);
+ const struct lttng_ust_event_field *lf);
+static
+int serialize_fields(struct lttng_ust_session *session,
+ struct ustctl_field *ustctl_fields,
+ size_t *iter_output, size_t nr_lttng_fields,
+ const struct lttng_ust_event_field **lttng_fields);
/*
* Human readable error message.
[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_MAGIC) ] = "Invalid magic number",
[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_SOCKET_TYPE) ] = "Invalid socket type",
[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_UNSUP_MAJOR) ] = "Unsupported major version",
+ [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PEERCRED) ] = "Cannot get unix socket peer credentials",
+ [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PEERCRED_PID) ] = "Peer credentials PID is invalid. Socket appears to belong to a distinct, non-nested pid namespace.",
};
/*
* lttng_ust_strerror
+ * @code: must be a negative value of enum lttng_ust_error_code (or 0).
*
- * Receives positive error value.
- * Return ptr to string representing a human readable
- * error code from the ustcomm_return_code enum.
+ * Returns a ptr to a string representing a human readable error code from the
+ * ustcomm_return_code enum.
*/
const char *lttng_ust_strerror(int code)
{
- if (code == LTTNG_UST_OK)
- return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
- if (code < LTTNG_UST_ERR)
- return strerror(code);
- if (code >= LTTNG_UST_ERR_NR)
+ code = -code;
+
+ if (code < LTTNG_UST_OK || code >= LTTNG_UST_ERR_NR)
code = LTTNG_UST_ERR;
+
return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
}
ssize_t len, nr_fd;
int wakeup_fd, ret;
- if (var_len > LTTNG_UST_CHANNEL_DATA_MAX_LEN) {
+ if (var_len > LTTNG_UST_ABI_CHANNEL_DATA_MAX_LEN) {
len = -EINVAL;
goto error_check;
}
return len;
}
+ssize_t ustcomm_recv_event_notifier_notif_fd_from_sessiond(int sock,
+ int *_event_notifier_notif_fd)
+{
+ ssize_t nr_fd;
+ int event_notifier_notif_fd, ret;
+
+ /* Receive event_notifier notification fd */
+ lttng_ust_lock_fd_tracker();
+ nr_fd = ustcomm_recv_fds_unix_sock(sock, &event_notifier_notif_fd, 1);
+ if (nr_fd <= 0) {
+ lttng_ust_unlock_fd_tracker();
+ if (nr_fd < 0) {
+ ret = nr_fd;
+ goto error;
+ } else {
+ ret = -EIO;
+ goto error;
+ }
+ }
+
+ ret = lttng_ust_add_fd_to_tracker(event_notifier_notif_fd);
+ if (ret < 0) {
+ ret = close(event_notifier_notif_fd);
+ if (ret) {
+ PERROR("close on event_notifier notif fd");
+ }
+ ret = -EIO;
+ lttng_ust_unlock_fd_tracker();
+ goto error;
+ }
+
+ *_event_notifier_notif_fd = ret;
+ lttng_ust_unlock_fd_tracker();
+
+ ret = nr_fd;
+
+error:
+ return ret;
+}
+
int ustcomm_recv_stream_from_sessiond(int sock,
- uint64_t *memory_map_size,
+ uint64_t *memory_map_size __attribute__((unused)),
int *shm_fd, int *wakeup_fd)
{
ssize_t len;
return ret;
}
+ssize_t ustcomm_recv_counter_from_sessiond(int sock,
+ void **_counter_data, uint64_t var_len)
+{
+ void *counter_data;
+ ssize_t len;
+
+ if (var_len > LTTNG_UST_ABI_COUNTER_DATA_MAX_LEN) {
+ len = -EINVAL;
+ goto error_check;
+ }
+ /* Receive variable length data */
+ counter_data = zmalloc(var_len);
+ if (!counter_data) {
+ len = -ENOMEM;
+ goto error_alloc;
+ }
+ len = ustcomm_recv_unix_sock(sock, counter_data, var_len);
+ if (len != var_len) {
+ goto error_recv;
+ }
+ *_counter_data = counter_data;
+ return len;
+
+error_recv:
+ free(counter_data);
+error_alloc:
+error_check:
+ return len;
+}
+
+int ustcomm_recv_counter_shm_from_sessiond(int sock,
+ int *shm_fd)
+{
+ ssize_t len;
+ int ret;
+ int fds[1];
+
+ /* recv shm fd fd */
+ lttng_ust_lock_fd_tracker();
+ len = ustcomm_recv_fds_unix_sock(sock, fds, 1);
+ if (len <= 0) {
+ lttng_ust_unlock_fd_tracker();
+ if (len < 0) {
+ ret = len;
+ goto error;
+ } else {
+ ret = -EIO;
+ goto error;
+ }
+ }
+
+ ret = lttng_ust_add_fd_to_tracker(fds[0]);
+ if (ret < 0) {
+ ret = close(fds[0]);
+ if (ret) {
+ PERROR("close on received shm_fd");
+ }
+ ret = -EIO;
+ lttng_ust_unlock_fd_tracker();
+ goto error;
+ }
+ *shm_fd = ret;
+ lttng_ust_unlock_fd_tracker();
+ return 0;
+
+error:
+ return ret;
+}
+
/*
* Returns 0 on success, negative error value on error.
*/
ssize_t len;
struct ustctl_reg_msg reg_msg;
- reg_msg.magic = LTTNG_UST_COMM_MAGIC;
+ reg_msg.magic = LTTNG_UST_ABI_COMM_MAGIC;
reg_msg.major = LTTNG_UST_ABI_MAJOR_VERSION;
reg_msg.minor = LTTNG_UST_ABI_MINOR_VERSION;
reg_msg.pid = getpid();
reg_msg.uint64_t_alignment = uint64_t_alignment;
reg_msg.long_alignment = long_alignment;
reg_msg.socket_type = type;
- lttng_ust_getprocname(reg_msg.name);
+ lttng_pthread_getname_np(reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
memset(reg_msg.padding, 0, sizeof(reg_msg.padding));
len = ustcomm_send_unix_sock(sock, ®_msg, sizeof(reg_msg));
}
static
-ssize_t count_one_type(const struct lttng_type *lt)
+ssize_t count_one_type(const struct lttng_ust_type_common *lt)
{
- switch (lt->atype) {
- case atype_integer:
- case atype_float:
- case atype_string:
- case atype_enum:
- case atype_array:
- case atype_sequence:
+ switch (lt->type) {
+ case lttng_ust_type_integer:
+ case lttng_ust_type_float:
+ case lttng_ust_type_string:
return 1;
- case atype_struct:
- //TODO: implement non-empty struct.
- return 1;
- case atype_dynamic:
+ case lttng_ust_type_enum:
+ return count_one_type(lttng_ust_get_type_enum(lt)->container_type) + 1;
+ case lttng_ust_type_array:
+ return count_one_type(lttng_ust_get_type_array(lt)->elem_type) + 1;
+ case lttng_ust_type_sequence:
+ return count_one_type(lttng_ust_get_type_sequence(lt)->elem_type) + 1;
+ case lttng_ust_type_struct:
+ return count_fields_recursive(lttng_ust_get_type_struct(lt)->nr_fields,
+ lttng_ust_get_type_struct(lt)->fields) + 1;
+
+ case lttng_ust_type_dynamic:
{
- const struct lttng_event_field *choices;
+ const struct lttng_ust_event_field **choices;
size_t nr_choices;
int ret;
if (ret)
return ret;
/*
- * One field for enum, one field for variant, and
+ * Two fields for enum, one field for variant, and
* one field per choice.
*/
- return count_fields_recursive(nr_choices, choices) + 2;
+ return count_fields_recursive(nr_choices, choices) + 3;
}
+
default:
return -EINVAL;
}
static
ssize_t count_fields_recursive(size_t nr_fields,
- const struct lttng_event_field *lttng_fields)
+ const struct lttng_ust_event_field **lttng_fields)
{
int i;
ssize_t ret, count = 0;
for (i = 0; i < nr_fields; i++) {
- const struct lttng_event_field *lf;
+ const struct lttng_ust_event_field *lf;
- lf = <tng_fields[i];
+ lf = lttng_fields[i];
/* skip 'nowrite' fields */
if (lf->nowrite)
continue;
- ret = count_one_type(&lf->type);
+ ret = count_one_type(lf->type);
if (ret < 0)
return ret; /* error */
count += ret;
static
ssize_t count_ctx_fields_recursive(size_t nr_fields,
- const struct lttng_ctx_field *lttng_fields)
+ struct lttng_ust_ctx_field *lttng_fields)
{
int i;
ssize_t ret, count = 0;
for (i = 0; i < nr_fields; i++) {
- const struct lttng_event_field *lf;
+ const struct lttng_ust_event_field *lf;
- lf = <tng_fields[i].event_field;
+ lf = lttng_fields[i].event_field;
/* skip 'nowrite' fields */
if (lf->nowrite)
continue;
- ret = count_one_type(&lf->type);
+ ret = count_one_type(lf->type);
if (ret < 0)
return ret; /* error */
count += ret;
static
int serialize_string_encoding(int32_t *ue,
- enum lttng_string_encodings le)
+ enum lttng_ust_string_encoding le)
{
switch (le) {
- case lttng_encode_none:
+ case lttng_ust_string_encoding_none:
*ue = ustctl_encode_none;
break;
- case lttng_encode_UTF8:
+ case lttng_ust_string_encoding_UTF8:
*ue = ustctl_encode_UTF8;
break;
- case lttng_encode_ASCII:
+ case lttng_ust_string_encoding_ASCII:
*ue = ustctl_encode_ASCII;
break;
default:
static
int serialize_integer_type(struct ustctl_integer_type *uit,
- const struct lttng_integer_type *lit)
+ const struct lttng_ust_type_integer *lit,
+ enum lttng_ust_string_encoding lencoding)
{
int32_t encoding;
uit->signedness = lit->signedness;
uit->reverse_byte_order = lit->reverse_byte_order;
uit->base = lit->base;
- if (serialize_string_encoding(&encoding, lit->encoding))
+ if (serialize_string_encoding(&encoding, lencoding))
return -EINVAL;
uit->encoding = encoding;
uit->alignment = lit->alignment;
}
static
-int serialize_basic_type(struct lttng_session *session,
- enum ustctl_abstract_types *uatype,
- enum lttng_abstract_types atype,
- union _ustctl_basic_type *ubt,
- const union _lttng_basic_type *lbt)
-{
- switch (atype) {
- case atype_integer:
- {
- if (serialize_integer_type(&ubt->integer, &lbt->integer))
- return -EINVAL;
- *uatype = ustctl_atype_integer;
- break;
- }
- case atype_string:
- {
- int32_t encoding;
-
- if (serialize_string_encoding(&encoding, lbt->string.encoding))
- return -EINVAL;
- ubt->string.encoding = encoding;
- *uatype = ustctl_atype_string;
- break;
- }
- case atype_float:
- {
- struct ustctl_float_type *uft;
- const struct lttng_float_type *lft;
-
- uft = &ubt->_float;
- lft = &lbt->_float;
- uft->exp_dig = lft->exp_dig;
- uft->mant_dig = lft->mant_dig;
- uft->alignment = lft->alignment;
- uft->reverse_byte_order = lft->reverse_byte_order;
- *uatype = ustctl_atype_float;
- break;
- }
- case atype_enum:
- {
- strncpy(ubt->enumeration.name, lbt->enumeration.desc->name,
- LTTNG_UST_SYM_NAME_LEN);
- ubt->enumeration.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- if (serialize_integer_type(&ubt->enumeration.container_type,
- &lbt->enumeration.container_type))
- return -EINVAL;
- if (session) {
- const struct lttng_enum *_enum;
-
- _enum = lttng_ust_enum_get_from_desc(session, lbt->enumeration.desc);
- if (!_enum)
- return -EINVAL;
- ubt->enumeration.id = _enum->id;
- } else {
- ubt->enumeration.id = -1ULL;
- }
- *uatype = ustctl_atype_enum;
- break;
- }
- case atype_array:
- case atype_sequence:
- default:
- return -EINVAL;
- }
- return 0;
-}
-
-static
-int serialize_dynamic_type(struct lttng_session *session,
+int serialize_dynamic_type(struct lttng_ust_session *session,
struct ustctl_field *fields, size_t *iter_output,
- const struct lttng_event_field *lf)
+ const char *field_name)
{
- const struct lttng_event_field *choices;
- char tag_field_name[LTTNG_UST_SYM_NAME_LEN];
- const struct lttng_type *tag_type;
- const struct lttng_event_field *tag_field_generic;
- struct lttng_event_field tag_field = {
+ const struct lttng_ust_event_field **choices;
+ char tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN];
+ const struct lttng_ust_type_common *tag_type;
+ const struct lttng_ust_event_field *tag_field_generic;
+ struct lttng_ust_event_field tag_field = {
.name = tag_field_name,
.nowrite = 0,
};
int ret;
tag_field_generic = lttng_ust_dynamic_type_tag_field();
- tag_type = &tag_field_generic->type;
+ tag_type = tag_field_generic->type;
/* Serialize enum field. */
- strncpy(tag_field_name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- tag_field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ strncpy(tag_field_name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
strncat(tag_field_name,
"_tag",
- LTTNG_UST_SYM_NAME_LEN - strlen(tag_field_name) - 1);
- tag_field.type = *tag_type;
+ LTTNG_UST_ABI_SYM_NAME_LEN - strlen(tag_field_name) - 1);
+ tag_field.type = tag_type;
ret = serialize_one_field(session, fields, iter_output,
&tag_field);
if (ret)
if (ret)
return ret;
- strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
uf->type.atype = ustctl_atype_variant;
- uf->type.u.variant.nr_choices = nr_choices;
- strncpy(uf->type.u.variant.tag_name,
+ uf->type.u.variant_nestable.nr_choices = nr_choices;
+ strncpy(uf->type.u.variant_nestable.tag_name,
tag_field_name,
- LTTNG_UST_SYM_NAME_LEN);
- uf->type.u.variant.tag_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->type.u.variant_nestable.tag_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ uf->type.u.variant_nestable.alignment = 0;
(*iter_output)++;
/* Serialize choice fields after variant. */
for (i = 0; i < nr_choices; i++) {
ret = serialize_one_field(session, fields,
- iter_output, &choices[i]);
+ iter_output, choices[i]);
if (ret)
return ret;
}
}
static
-int serialize_one_field(struct lttng_session *session,
+int serialize_one_type(struct lttng_ust_session *session,
struct ustctl_field *fields, size_t *iter_output,
- const struct lttng_event_field *lf)
+ const char *field_name, const struct lttng_ust_type_common *lt,
+ enum lttng_ust_string_encoding parent_encoding)
{
- const struct lttng_type *lt = &lf->type;
int ret;
- /* skip 'nowrite' fields */
- if (lf->nowrite)
- return 0;
+ /*
+ * Serializing a type (rather than a field) generates a ustctl_field
+ * entry with 0-length name.
+ */
- switch (lt->atype) {
- case atype_integer:
- case atype_float:
- case atype_string:
- case atype_enum:
+ switch (lt->type) {
+ case lttng_ust_type_integer:
{
struct ustctl_field *uf = &fields[*iter_output];
struct ustctl_type *ut = &uf->type;
- enum ustctl_abstract_types atype;
- strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- ret = serialize_basic_type(session, &atype, lt->atype,
- &ut->u.basic, <->u.basic);
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ ret = serialize_integer_type(&ut->u.integer, lttng_ust_get_type_integer(lt),
+ parent_encoding);
if (ret)
return ret;
- ut->atype = atype;
+ ut->atype = ustctl_atype_integer;
+ (*iter_output)++;
+ break;
+ }
+ case lttng_ust_type_float:
+ {
+ struct ustctl_field *uf = &fields[*iter_output];
+ struct ustctl_type *ut = &uf->type;
+ struct ustctl_float_type *uft;
+ const struct lttng_ust_type_float *lft;
+
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ uft = &ut->u._float;
+ lft = lttng_ust_get_type_float(lt);
+ uft->exp_dig = lft->exp_dig;
+ uft->mant_dig = lft->mant_dig;
+ uft->alignment = lft->alignment;
+ uft->reverse_byte_order = lft->reverse_byte_order;
+ ut->atype = ustctl_atype_float;
(*iter_output)++;
break;
}
- case atype_array:
+ case lttng_ust_type_string:
{
struct ustctl_field *uf = &fields[*iter_output];
struct ustctl_type *ut = &uf->type;
- struct ustctl_basic_type *ubt;
- const struct lttng_basic_type *lbt;
- enum ustctl_abstract_types atype;
-
- strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- uf->type.atype = ustctl_atype_array;
- ubt = &ut->u.array.elem_type;
- lbt = <->u.array.elem_type;
- ut->u.array.length = lt->u.array.length;
- ret = serialize_basic_type(session, &atype, lbt->atype,
- &ubt->u.basic, &lbt->u.basic);
+ int32_t encoding;
+
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ ret = serialize_string_encoding(&encoding, lttng_ust_get_type_string(lt)->encoding);
if (ret)
- return -EINVAL;
- ubt->atype = atype;
- ut->atype = ustctl_atype_array;
+ return ret;
+ ut->u.string.encoding = encoding;
+ ut->atype = ustctl_atype_string;
(*iter_output)++;
break;
}
- case atype_sequence:
+ case lttng_ust_type_array:
{
struct ustctl_field *uf = &fields[*iter_output];
struct ustctl_type *ut = &uf->type;
- struct ustctl_basic_type *ubt;
- const struct lttng_basic_type *lbt;
- enum ustctl_abstract_types atype;
- int ret;
- strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- uf->type.atype = ustctl_atype_sequence;
- ubt = &ut->u.sequence.length_type;
- lbt = <->u.sequence.length_type;
- ret = serialize_basic_type(session, &atype, lbt->atype,
- &ubt->u.basic, &lbt->u.basic);
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ ut->atype = ustctl_atype_array_nestable;
+ ut->u.array_nestable.length = lttng_ust_get_type_array(lt)->length;
+ ut->u.array_nestable.alignment = lttng_ust_get_type_array(lt)->alignment;
+ (*iter_output)++;
+
+ ret = serialize_one_type(session, fields, iter_output, NULL,
+ lttng_ust_get_type_array(lt)->elem_type,
+ lttng_ust_get_type_array(lt)->encoding);
if (ret)
return -EINVAL;
- ubt->atype = atype;
- ubt = &ut->u.sequence.elem_type;
- lbt = <->u.sequence.elem_type;
- ret = serialize_basic_type(session, &atype, lbt->atype,
- &ubt->u.basic, &lbt->u.basic);
+ break;
+ }
+ case lttng_ust_type_sequence:
+ {
+ struct ustctl_field *uf = &fields[*iter_output];
+ struct ustctl_type *ut = &uf->type;
+
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ ut->atype = ustctl_atype_sequence_nestable;
+ strncpy(ut->u.sequence_nestable.length_name,
+ lttng_ust_get_type_sequence(lt)->length_name,
+ LTTNG_UST_ABI_SYM_NAME_LEN);
+ ut->u.sequence_nestable.length_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ ut->u.sequence_nestable.alignment = lttng_ust_get_type_sequence(lt)->alignment;
+ (*iter_output)++;
+
+ ret = serialize_one_type(session, fields, iter_output, NULL,
+ lttng_ust_get_type_sequence(lt)->elem_type,
+ lttng_ust_get_type_sequence(lt)->encoding);
if (ret)
return -EINVAL;
- ubt->atype = atype;
- ut->atype = ustctl_atype_sequence;
- (*iter_output)++;
break;
}
- case atype_dynamic:
+ case lttng_ust_type_dynamic:
{
- ret = serialize_dynamic_type(session, fields, iter_output, lf);
+ ret = serialize_dynamic_type(session, fields, iter_output,
+ field_name);
if (ret)
return -EINVAL;
break;
}
- case atype_struct:
+ case lttng_ust_type_struct:
{
struct ustctl_field *uf = &fields[*iter_output];
- /*
- * TODO: add support for non-empty struct.
- */
- if (lf->type.u._struct.nr_fields != 0) {
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
+ }
+ uf->type.atype = ustctl_atype_struct_nestable;
+ uf->type.u.struct_nestable.nr_fields = lttng_ust_get_type_struct(lt)->nr_fields;
+ uf->type.u.struct_nestable.alignment = lttng_ust_get_type_struct(lt)->alignment;
+ (*iter_output)++;
+
+ ret = serialize_fields(session, fields, iter_output,
+ lttng_ust_get_type_struct(lt)->nr_fields,
+ lttng_ust_get_type_struct(lt)->fields);
+ if (ret)
return -EINVAL;
+ break;
+ }
+ case lttng_ust_type_enum:
+ {
+ struct ustctl_field *uf = &fields[*iter_output];
+ struct ustctl_type *ut = &uf->type;
+
+ if (field_name) {
+ strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ } else {
+ uf->name[0] = '\0';
}
- strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
- uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- uf->type.atype = ustctl_atype_struct;
- uf->type.u._struct.nr_fields = 0;
+ strncpy(ut->u.enum_nestable.name, lttng_ust_get_type_enum(lt)->desc->name,
+ LTTNG_UST_ABI_SYM_NAME_LEN);
+ ut->u.enum_nestable.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+ ut->atype = ustctl_atype_enum_nestable;
(*iter_output)++;
+
+ ret = serialize_one_type(session, fields, iter_output, NULL,
+ lttng_ust_get_type_enum(lt)->container_type,
+ lttng_ust_string_encoding_none);
+ if (ret)
+ return -EINVAL;
+ if (session) {
+ const struct lttng_enum *_enum;
+
+ _enum = lttng_ust_enum_get_from_desc(session, lttng_ust_get_type_enum(lt)->desc);
+ if (!_enum)
+ return -EINVAL;
+ ut->u.enum_nestable.id = _enum->id;
+ } else {
+ ut->u.enum_nestable.id = -1ULL;
+ }
break;
}
default:
}
static
-int serialize_fields(struct lttng_session *session,
+int serialize_one_field(struct lttng_ust_session *session,
+ struct ustctl_field *fields, size_t *iter_output,
+ const struct lttng_ust_event_field *lf)
+{
+ /* skip 'nowrite' fields */
+ if (lf->nowrite)
+ return 0;
+
+ return serialize_one_type(session, fields, iter_output, lf->name, lf->type, lttng_ust_string_encoding_none);
+}
+
+static
+int serialize_fields(struct lttng_ust_session *session,
+ struct ustctl_field *ustctl_fields,
+ size_t *iter_output, size_t nr_lttng_fields,
+ const struct lttng_ust_event_field **lttng_fields)
+{
+ int ret;
+ size_t i;
+
+ for (i = 0; i < nr_lttng_fields; i++) {
+ ret = serialize_one_field(session, ustctl_fields,
+ iter_output, lttng_fields[i]);
+ if (ret)
+ return ret;
+ }
+ return 0;
+}
+
+static
+int alloc_serialize_fields(struct lttng_ust_session *session,
size_t *_nr_write_fields,
struct ustctl_field **ustctl_fields,
size_t nr_fields,
- const struct lttng_event_field *lttng_fields)
+ const struct lttng_ust_event_field **lttng_fields)
{
struct ustctl_field *fields;
int ret;
- size_t i, iter_output = 0;
+ size_t iter_output = 0;
ssize_t nr_write_fields;
nr_write_fields = count_fields_recursive(nr_fields, lttng_fields);
if (!fields)
return -ENOMEM;
- for (i = 0; i < nr_fields; i++) {
- ret = serialize_one_field(session, fields, &iter_output,
- <tng_fields[i]);
- if (ret)
- goto error_type;
- }
+ ret = serialize_fields(session, fields, &iter_output, nr_fields,
+ lttng_fields);
+ if (ret)
+ goto error_type;
*_nr_write_fields = nr_write_fields;
*ustctl_fields = fields;
static
int serialize_entries(struct ustctl_enum_entry **_entries,
size_t nr_entries,
- const struct lttng_enum_entry *lttng_entries)
+ const struct lttng_ust_enum_entry **lttng_entries)
{
struct ustctl_enum_entry *entries;
int i;
return -ENOMEM;
for (i = 0; i < nr_entries; i++) {
struct ustctl_enum_entry *uentry;
- const struct lttng_enum_entry *lentry;
+ const struct lttng_ust_enum_entry *lentry;
uentry = &entries[i];
- lentry = <tng_entries[i];
+ lentry = lttng_entries[i];
uentry->start.value = lentry->start.value;
uentry->start.signedness = lentry->start.signedness;
uentry->end.value = lentry->end.value;
uentry->end.signedness = lentry->end.signedness;
- strncpy(uentry->string, lentry->string, LTTNG_UST_SYM_NAME_LEN);
- uentry->string[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ strncpy(uentry->string, lentry->string, LTTNG_UST_ABI_SYM_NAME_LEN);
+ uentry->string[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
- if (lentry->u.extra.options & LTTNG_ENUM_ENTRY_OPTION_IS_AUTO) {
+ if (lentry->options & LTTNG_UST_ENUM_ENTRY_OPTION_IS_AUTO) {
uentry->u.extra.options |=
USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO;
}
}
static
-int serialize_ctx_fields(struct lttng_session *session,
+int serialize_ctx_fields(struct lttng_ust_session *session,
size_t *_nr_write_fields,
struct ustctl_field **ustctl_fields,
size_t nr_fields,
- const struct lttng_ctx_field *lttng_fields)
+ struct lttng_ust_ctx_field *lttng_fields)
{
struct ustctl_field *fields;
int ret;
for (i = 0; i < nr_fields; i++) {
ret = serialize_one_field(session, fields, &iter_output,
- <tng_fields[i].event_field);
+ lttng_fields[i].event_field);
if (ret)
goto error_type;
}
* Returns 0 on success, negative error value on error.
*/
int ustcomm_register_event(int sock,
- struct lttng_session *session,
+ struct lttng_ust_session *session,
int session_objd, /* session descriptor */
int channel_objd, /* channel descriptor */
const char *event_name, /* event name (input) */
int loglevel,
const char *signature, /* event signature (input) */
size_t nr_fields, /* fields */
- const struct lttng_event_field *lttng_fields,
+ const struct lttng_ust_event_field **lttng_fields,
const char *model_emf_uri,
uint32_t *id) /* event id (output) */
{
msg.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
msg.m.session_objd = session_objd;
msg.m.channel_objd = channel_objd;
- strncpy(msg.m.event_name, event_name, LTTNG_UST_SYM_NAME_LEN);
- msg.m.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ strncpy(msg.m.event_name, event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ msg.m.event_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
msg.m.loglevel = loglevel;
signature_len = strlen(signature) + 1;
msg.m.signature_len = signature_len;
/* Calculate fields len, serialize fields. */
if (nr_fields > 0) {
- ret = serialize_fields(session, &nr_write_fields, &fields,
+ ret = alloc_serialize_fields(session, &nr_write_fields, &fields,
nr_fields, lttng_fields);
if (ret)
return ret;
int session_objd, /* session descriptor */
const char *enum_name, /* enum name (input) */
size_t nr_entries, /* entries */
- const struct lttng_enum_entry *lttng_entries,
+ const struct lttng_ust_enum_entry **lttng_entries,
uint64_t *id)
{
ssize_t len;
memset(&msg, 0, sizeof(msg));
msg.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
msg.m.session_objd = session_objd;
- strncpy(msg.m.enum_name, enum_name, LTTNG_UST_SYM_NAME_LEN);
- msg.m.enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ strncpy(msg.m.enum_name, enum_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+ msg.m.enum_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
/* Calculate entries len, serialize entries. */
if (nr_entries > 0) {
* Returns -EPIPE or -ECONNRESET if other end has hung up.
*/
int ustcomm_register_channel(int sock,
- struct lttng_session *session,
+ struct lttng_ust_session *session,
int session_objd, /* session descriptor */
int channel_objd, /* channel descriptor */
size_t nr_ctx_fields,
- const struct lttng_ctx_field *ctx_fields,
+ struct lttng_ust_ctx_field *ctx_fields,
uint32_t *chan_id, /* channel id (output) */
int *header_type) /* header type (output) */
{
projects / lttng-ust.git / blobdiff