The context structures are now hidden in headers which are not
installed, but those are still part of the UST ABI. Therefore, we need
to update them to make sure those are extensible.
- Namespace theses structures with lttng_ust_ prefix,
- Use struct_size extensibility scheme. There was no prior padding, so
extensibility was an issue in the past.
- Remove padding.
- This requires that none of those structures can be nested. It also
requires that all arrays of structures must be replaced by arrays of
pointers to structures.
- Replace struct lttng_perf_counter_field pointer by a private data
pointer.
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I4ecb8f73652770f15c693c1b5b2acce3e871a64b
40 files changed:
struct lttng_ust_event_common_private;
enum lttng_ust_event_type {
struct lttng_ust_event_common_private;
enum lttng_ust_event_type {
unsigned int id;
struct lttng_channel *chan;
unsigned int id;
struct lttng_channel *chan;
+ struct lttng_ust_ctx *ctx;
/* End of base ABI. Fields below should be used after checking struct_size. */
};
/* End of base ABI. Fields below should be used after checking struct_size. */
};
*/
struct lttng_ust_lib_ring_buffer_channel *chan; /* Channel buffers */
int enabled;
*/
struct lttng_ust_lib_ring_buffer_channel *chan; /* Channel buffers */
int enabled;
+ struct lttng_ust_ctx *ctx;
/* Event ID management */
struct lttng_session *session;
int objd; /* Object associated to channel */
/* Event ID management */
struct lttng_session *session;
int objd; /* Object associated to channel */
uint32_t struct_size; /* Size of this structure */
struct lttng_ust_event_recorder *event_recorder;
uint32_t struct_size; /* Size of this structure */
struct lttng_ust_event_recorder *event_recorder;
- struct lttng_ctx *chan_ctx; /* RCU dereferenced. */
- struct lttng_ctx *event_ctx; /* RCU dereferenced. */
+ struct lttng_ust_ctx *chan_ctx; /* RCU dereferenced. */
+ struct lttng_ust_ctx *event_ctx; /* RCU dereferenced. */
/* End of base ABI. Fields below should be used after checking struct_size. */
};
/* End of base ABI. Fields below should be used after checking struct_size. */
};
#define LTTNG_UST_COMM_REG_MSG_PADDING 64
struct lttng_ust_event_field;
#define LTTNG_UST_COMM_REG_MSG_PADDING 64
struct lttng_ust_event_field;
+struct lttng_ust_ctx_field;
struct lttng_ust_enum_entry;
struct lttng_integer_type;
struct lttng_session;
struct lttng_ust_enum_entry;
struct lttng_integer_type;
struct lttng_session;
int session_objd, /* session descriptor */
int channel_objd, /* channel descriptor */
size_t nr_ctx_fields,
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) */
uint32_t *chan_id, /* channel id (output) */
int *header_type); /* header type (output) */
#include "ust-dynamic-type.h"
#include "ust-dynamic-type.h"
-struct lttng_ctx_value {
+/*
+ * Context value
+ *
+ * IMPORTANT: this structure is part of the ABI between the probe and
+ * UST. Fields need to be only added at the end, never reordered, never
+ * removed.
+ *
+ * The field @struct_size should be used to determine the size of the
+ * structure. It should be queried before using additional fields added
+ * at the end of the structure.
+ */
+
+struct lttng_ust_ctx_value {
+ uint32_t struct_size;
+
enum lttng_ust_dynamic_type sel;
union {
int64_t s64;
enum lttng_ust_dynamic_type sel;
union {
int64_t s64;
const char *str;
double d;
} u;
const char *str;
double d;
} u;
+
+ /* End of base ABI. Fields below should be used after checking struct_size. */
-struct lttng_perf_counter_field;
+/*
+ * Context field
+ *
+ * IMPORTANT: this structure is part of the ABI between the probe and
+ * UST. Fields need to be only added at the end, never reordered, never
+ * removed.
+ *
+ * The field @struct_size should be used to determine the size of the
+ * structure. It should be queried before using additional fields added
+ * at the end of the structure.
+ */
+
+struct lttng_ust_ctx_field {
+ uint32_t struct_size;
+ void *priv;
-#define LTTNG_UST_CTX_FIELD_PADDING 40
-struct lttng_ctx_field {
- struct lttng_ust_event_field event_field;
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset);
- void (*record)(struct lttng_ctx_field *field,
+ struct lttng_ust_event_field *event_field;
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset);
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value);
- union {
- struct lttng_perf_counter_field *perf_counter;
- char padding[LTTNG_UST_CTX_FIELD_PADDING];
- } u;
- void (*destroy)(struct lttng_ctx_field *field);
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value);
+ void (*destroy)(struct lttng_ust_ctx_field *field);
char *field_name; /* Has ownership, dynamically allocated. */
char *field_name; /* Has ownership, dynamically allocated. */
+
+ /* End of base ABI. Fields below should be used after checking struct_size. */
-#define LTTNG_UST_CTX_PADDING 20
-struct lttng_ctx {
- struct lttng_ctx_field *fields;
+/*
+ * All context fields for a given event/channel
+ *
+ * IMPORTANT: this structure is part of the ABI between the probe and
+ * UST. Fields need to be only added at the end, never reordered, never
+ * removed.
+ *
+ * The field @struct_size should be used to determine the size of the
+ * structure. It should be queried before using additional fields added
+ * at the end of the structure.
+ */
+
+struct lttng_ust_ctx {
+ uint32_t struct_size;
+
+ struct lttng_ust_ctx_field **fields;
unsigned int nr_fields;
unsigned int allocated_fields;
unsigned int largest_align;
unsigned int nr_fields;
unsigned int allocated_fields;
unsigned int largest_align;
- char padding[LTTNG_UST_CTX_PADDING];
+
+ /* End of base ABI. Fields below should be used after checking struct_size. */
+/*
+ * Context provider
+ *
+ * IMPORTANT: this structure is part of the ABI between the probe and
+ * UST. Fields need to be only added at the end, never reordered, never
+ * removed.
+ *
+ * The field @struct_size should be used to determine the size of the
+ * structure. It should be queried before using additional fields added
+ * at the end of the structure.
+ */
+
struct lttng_ust_context_provider {
struct lttng_ust_context_provider {
+ uint32_t struct_size;
+
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset);
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset);
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value);
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value);
struct cds_hlist_node node;
struct cds_hlist_node node;
+
+ /* End of base ABI. Fields below should be used after checking struct_size. */
};
int lttng_ust_context_provider_register(struct lttng_ust_context_provider *provider);
void lttng_ust_context_provider_unregister(struct lttng_ust_context_provider *provider);
void lttng_ust_context_set_session_provider(const char *name,
};
int lttng_ust_context_provider_register(struct lttng_ust_context_provider *provider);
void lttng_ust_context_provider_unregister(struct lttng_ust_context_provider *provider);
void lttng_ust_context_set_session_provider(const char *name,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value));
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value));
-int lttng_ust_add_app_context_to_ctx_rcu(const char *name, struct lttng_ctx **ctx);
-int lttng_ust_context_set_provider_rcu(struct lttng_ctx **_ctx,
+int lttng_ust_add_app_context_to_ctx_rcu(const char *name, struct lttng_ust_ctx **ctx);
+int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value));
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value));
#endif /* _LTTNG_UST_CONTEXT_PROVIDER_H */
#endif /* _LTTNG_UST_CONTEXT_PROVIDER_H */
static
ssize_t count_ctx_fields_recursive(size_t nr_fields,
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;
{
int i;
ssize_t ret, count = 0;
for (i = 0; i < nr_fields; i++) {
const struct lttng_ust_event_field *lf;
for (i = 0; i < nr_fields; i++) {
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;
/* skip 'nowrite' fields */
if (lf->nowrite)
continue;
size_t *_nr_write_fields,
struct ustctl_field **ustctl_fields,
size_t nr_fields,
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;
{
struct ustctl_field *fields;
int ret;
for (i = 0; i < nr_fields; i++) {
ret = serialize_one_field(session, fields, &iter_output,
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;
}
if (ret)
goto error_type;
}
int session_objd, /* session descriptor */
int channel_objd, /* channel descriptor */
size_t nr_ctx_fields,
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) */
{
uint32_t *chan_id, /* channel id (output) */
int *header_type) /* header type (output) */
{
-static size_t get_size_cb(struct lttng_ctx_field *field, size_t offset)
+static size_t get_size_cb(struct lttng_ust_ctx_field *field, size_t offset)
{
struct lttng_ust_jni_ctx_entry *jctx;
size_t size = 0;
{
struct lttng_ust_jni_ctx_entry *jctx;
size_t size = 0;
-static void record_cb(struct lttng_ctx_field *field,
+static void record_cb(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-static void get_value_cb(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+static void get_value_cb(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
struct lttng_ust_jni_ctx_entry *jctx;
const char *ctx_name = field->event_field.name;
{
struct lttng_ust_jni_ctx_entry *jctx;
const char *ctx_name = field->event_field.name;
if (!provider) {
goto error_provider;
}
if (!provider) {
goto error_provider;
}
+ provider->struct_size = sizeof(*provider);
provider->name = provider_name_cstr;
provider->get_size = get_size_cb;
provider->record = record_cb;
provider->name = provider_name_cstr;
provider->get_size = get_size_cb;
provider->record = record_cb;
#include "ust-context-provider.h"
__attribute__((visibility("hidden")))
#include "ust-context-provider.h"
__attribute__((visibility("hidden")))
-int lttng_context_init_all(struct lttng_ctx **ctx);
+int lttng_context_init_all(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
int lttng_attach_context(struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
__attribute__((visibility("hidden")))
int lttng_attach_context(struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
- struct lttng_ctx **ctx, struct lttng_session *session);
+ struct lttng_ust_ctx **ctx, struct lttng_session *session);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_find_context(struct lttng_ctx *ctx, const char *name);
+int lttng_find_context(struct lttng_ust_ctx *ctx, const char *name);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_get_context_index(struct lttng_ctx *ctx, const char *name);
+int lttng_get_context_index(struct lttng_ust_ctx *ctx, const char *name);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx_p);
+struct lttng_ust_ctx_field *lttng_append_context(struct lttng_ust_ctx **ctx_p);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-void lttng_context_update(struct lttng_ctx *ctx);
+void lttng_context_update(struct lttng_ust_ctx *ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-void lttng_remove_context_field(struct lttng_ctx **ctx_p,
- struct lttng_ctx_field *field);
+void lttng_remove_context_field(struct lttng_ust_ctx **ctx_p,
+ struct lttng_ust_ctx_field *field);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-void lttng_destroy_context(struct lttng_ctx *ctx);
+void lttng_destroy_context(struct lttng_ust_ctx *ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_context_add_rcu(struct lttng_ctx **ctx_p,
- const struct lttng_ctx_field *f);
+int lttng_context_add_rcu(struct lttng_ust_ctx **ctx_p,
+ struct lttng_ust_ctx_field *f);
__attribute__((visibility("hidden")))
int lttng_context_is_app(const char *name);
__attribute__((visibility("hidden")))
int lttng_context_is_app(const char *name);
void lttng_context_vsgid_reset(void);
__attribute__((visibility("hidden")))
void lttng_context_vsgid_reset(void);
__attribute__((visibility("hidden")))
-int lttng_add_vtid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vtid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vpid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vpid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_pthread_id_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_pthread_id_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_procname_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_procname_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_ip_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_ip_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_cpu_id_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_cpu_id_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_dyntest_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_dyntest_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_cgroup_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_ipc_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_mnt_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_net_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_pid_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_user_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_uts_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_time_ns_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_time_ns_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vuid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vuid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_veuid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_veuid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vsuid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vsuid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vgid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vgid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vegid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vegid_to_ctx(struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-int lttng_add_vsgid_to_ctx(struct lttng_ctx **ctx);
+int lttng_add_vsgid_to_ctx(struct lttng_ust_ctx **ctx);
#endif /* _LTTNG_UST_CONTEXT_INTERNAL_H */
#endif /* _LTTNG_UST_CONTEXT_INTERNAL_H */
__attribute__((visibility("hidden")))
void lttng_ust_context_set_event_notifier_group_provider(const char *name,
__attribute__((visibility("hidden")))
void lttng_ust_context_set_event_notifier_group_provider(const char *name,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value));
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value));
#endif /* _LTTNG_UST_CONTEXT_PROVIDER_INTERNAL_H */
#endif /* _LTTNG_UST_CONTEXT_PROVIDER_INTERNAL_H */
#define IS_INTEGER_REGISTER(reg_type) \
(reg_type == REG_U64 || reg_type == REG_S64)
#define IS_INTEGER_REGISTER(reg_type) \
(reg_type == REG_U64 || reg_type == REG_S64)
-static int context_get_index(struct lttng_ctx *ctx,
+static int context_get_index(struct lttng_ust_ctx *ctx,
struct load_ptr *ptr,
uint32_t idx)
{
struct load_ptr *ptr,
uint32_t idx)
{
- struct lttng_ctx_field *ctx_field;
+ struct lttng_ust_ctx_field *ctx_field;
struct lttng_ust_event_field *field;
struct lttng_ust_event_field *field;
- struct lttng_ctx_value v;
+ struct lttng_ust_ctx_value v;
- ctx_field = &ctx->fields[idx];
- field = &ctx_field->event_field;
+ v.struct_size = sizeof(struct lttng_ust_ctx_value);
+ ctx_field = ctx->fields[idx];
+ field = ctx_field->event_field;
ptr->type = LOAD_OBJECT;
ptr->field = field;
ptr->type = LOAD_OBJECT;
ptr->field = field;
-static int dynamic_get_index(struct lttng_ctx *ctx,
+static int dynamic_get_index(struct lttng_ust_ctx *ctx,
struct bytecode_runtime *runtime,
uint64_t index, struct estack_entry *stack_top)
{
struct bytecode_runtime *runtime,
uint64_t index, struct estack_entry *stack_top)
{
struct lttng_interpreter_output *output)
{
struct bytecode_runtime *bytecode = interpreter_data;
struct lttng_interpreter_output *output)
{
struct bytecode_runtime *bytecode = interpreter_data;
- struct lttng_ctx *ctx = lttng_ust_rcu_dereference(*bytecode->p.priv->pctx);
+ struct lttng_ust_ctx *ctx = lttng_ust_rcu_dereference(*bytecode->p.priv->pctx);
void *pc, *next_pc, *start_pc;
int ret = -EINVAL;
uint64_t retval = 0;
void *pc, *next_pc, *start_pc;
int ret = -EINVAL;
uint64_t retval = 0;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- struct lttng_ctx_field *ctx_field;
- struct lttng_ctx_value v;
+ struct lttng_ust_ctx_field *ctx_field;
+ struct lttng_ust_ctx_value v;
+ v.struct_size = sizeof(struct lttng_ust_ctx_value);
dbg_printf("get context ref offset %u type dynamic\n",
ref->offset);
dbg_printf("get context ref offset %u type dynamic\n",
ref->offset);
- ctx_field = &ctx->fields[ref->offset];
+ ctx_field = ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
switch (v.sel) {
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
switch (v.sel) {
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- struct lttng_ctx_field *ctx_field;
- struct lttng_ctx_value v;
+ struct lttng_ust_ctx_field *ctx_field;
+ struct lttng_ust_ctx_value v;
+ v.struct_size = sizeof(struct lttng_ust_ctx_value);
dbg_printf("get context ref offset %u type string\n",
ref->offset);
dbg_printf("get context ref offset %u type string\n",
ref->offset);
- ctx_field = &ctx->fields[ref->offset];
+ ctx_field = ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.str = v.u.str;
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax(stack, top)->u.s.str = v.u.str;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- struct lttng_ctx_field *ctx_field;
- struct lttng_ctx_value v;
+ struct lttng_ust_ctx_field *ctx_field;
+ struct lttng_ust_ctx_value v;
+ v.struct_size = sizeof(struct lttng_ust_ctx_value);
dbg_printf("get context ref offset %u type s64\n",
ref->offset);
dbg_printf("get context ref offset %u type s64\n",
ref->offset);
- ctx_field = &ctx->fields[ref->offset];
+ ctx_field = ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = v.u.s64;
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = v.u.s64;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
{
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- struct lttng_ctx_field *ctx_field;
- struct lttng_ctx_value v;
+ struct lttng_ust_ctx_field *ctx_field;
+ struct lttng_ust_ctx_value v;
+ v.struct_size = sizeof(struct lttng_ust_ctx_value);
dbg_printf("get context ref offset %u type double\n",
ref->offset);
dbg_printf("get context ref offset %u type double\n",
ref->offset);
- ctx_field = &ctx->fields[ref->offset];
+ ctx_field = ctx->fields[ref->offset];
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
memcpy(&estack_ax(stack, top)->u.d, &v.u.d, sizeof(struct literal_double));
ctx_field->get_value(ctx_field, &v);
estack_push(stack, top, ax, bx, ax_t, bx_t);
memcpy(&estack_ax(stack, top)->u.d, &v.u.d, sizeof(struct literal_double));
-static int specialize_context_lookup_name(struct lttng_ctx *ctx,
+static int specialize_context_lookup_name(struct lttng_ust_ctx *ctx,
struct bytecode_runtime *bytecode,
struct load_op *insn)
{
struct bytecode_runtime *bytecode,
struct load_op *insn)
{
-static int specialize_context_lookup(struct lttng_ctx *ctx,
+static int specialize_context_lookup(struct lttng_ust_ctx *ctx,
struct bytecode_runtime *runtime,
struct load_op *insn,
struct vstack_load *load)
{
int idx, ret;
struct bytecode_runtime *runtime,
struct load_op *insn,
struct vstack_load *load)
{
int idx, ret;
- struct lttng_ctx_field *ctx_field;
+ struct lttng_ust_ctx_field *ctx_field;
struct lttng_ust_event_field *field;
struct bytecode_get_index_data gid;
ssize_t data_offset;
struct lttng_ust_event_field *field;
struct bytecode_get_index_data gid;
ssize_t data_offset;
if (idx < 0) {
return -ENOENT;
}
if (idx < 0) {
return -ENOENT;
}
- ctx_field = &ctx->fields[idx];
- field = &ctx_field->event_field;
+ ctx_field = ctx->fields[idx];
+ field = ctx_field->event_field;
ret = specialize_load_object(field, load, true);
if (ret)
return ret;
ret = specialize_load_object(field, load, true);
if (ret)
return ret;
-static int specialize_app_context_lookup(struct lttng_ctx **pctx,
+static int specialize_app_context_lookup(struct lttng_ust_ctx **pctx,
struct bytecode_runtime *runtime,
struct load_op *insn,
struct vstack_load *load)
struct bytecode_runtime *runtime,
struct load_op *insn,
struct vstack_load *load)
const char *orig_name;
char *name = NULL;
int idx, ret;
const char *orig_name;
char *name = NULL;
int idx, ret;
- struct lttng_ctx_field *ctx_field;
+ struct lttng_ust_ctx_field *ctx_field;
struct lttng_ust_event_field *field;
struct bytecode_get_index_data gid;
ssize_t data_offset;
struct lttng_ust_event_field *field;
struct bytecode_get_index_data gid;
ssize_t data_offset;
if (idx < 0)
return -ENOENT;
}
if (idx < 0)
return -ENOENT;
}
- ctx_field = &(*pctx)->fields[idx];
- field = &ctx_field->event_field;
+ ctx_field = (*pctx)->fields[idx];
+ field = ctx_field->event_field;
ret = specialize_load_object(field, load, true);
if (ret)
goto end;
ret = specialize_load_object(field, load, true);
if (ret)
goto end;
int ret = -EINVAL;
struct vstack _stack;
struct vstack *stack = &_stack;
int ret = -EINVAL;
struct vstack _stack;
struct vstack *stack = &_stack;
- struct lttng_ctx **pctx = bytecode->p.priv->pctx;
+ struct lttng_ust_ctx **pctx = bytecode->p.priv->pctx;
enum bytecode_op bytecode_op)
{
struct load_op *op;
enum bytecode_op bytecode_op)
{
struct load_op *op;
- struct lttng_ctx_field *ctx_field;
+ struct lttng_ust_ctx_field *ctx_field;
- struct lttng_ctx **pctx = runtime->p.priv->pctx;
+ struct lttng_ust_ctx **pctx = runtime->p.priv->pctx;
dbg_printf("Apply context reloc: %u %s\n", reloc_offset, context_name);
dbg_printf("Apply context reloc: %u %s\n", reloc_offset, context_name);
return -EINVAL;
/* Get context return type */
return -EINVAL;
/* Get context return type */
- ctx_field = &(*pctx)->fields[idx];
+ ctx_field = (*pctx)->fields[idx];
op = (struct load_op *) &runtime->code[reloc_offset];
switch (bytecode_op) {
op = (struct load_op *) &runtime->code[reloc_offset];
switch (bytecode_op) {
struct field_ref *field_ref;
field_ref = (struct field_ref *) op->data;
struct field_ref *field_ref;
field_ref = (struct field_ref *) op->data;
- switch (ctx_field->event_field.type.atype) {
+ switch (ctx_field->event_field->type.atype) {
case atype_integer:
case atype_enum_nestable:
op->op = BYTECODE_OP_GET_CONTEXT_REF_S64;
case atype_integer:
case atype_enum_nestable:
op->op = BYTECODE_OP_GET_CONTEXT_REF_S64;
*/
static
int link_bytecode(const struct lttng_ust_event_desc *event_desc,
*/
static
int link_bytecode(const struct lttng_ust_event_desc *event_desc,
- struct lttng_ctx **ctx,
+ struct lttng_ust_ctx **ctx,
struct lttng_ust_bytecode_node *bytecode,
struct cds_list_head *bytecode_runtime_head,
struct cds_list_head *insert_loc)
struct lttng_ust_bytecode_node *bytecode,
struct cds_list_head *bytecode_runtime_head,
struct cds_list_head *insert_loc)
* instance are name matching (or glob pattern matching).
*/
void lttng_enabler_link_bytecode(const struct lttng_ust_event_desc *event_desc,
* instance are name matching (or glob pattern matching).
*/
void lttng_enabler_link_bytecode(const struct lttng_ust_event_desc *event_desc,
- struct lttng_ctx **ctx,
+ struct lttng_ust_ctx **ctx,
struct cds_list_head *instance_bytecode_head,
struct cds_list_head *enabler_bytecode_head)
{
struct cds_list_head *instance_bytecode_head,
struct cds_list_head *enabler_bytecode_head)
{
-size_t cgroup_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t cgroup_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void cgroup_ns_record(struct lttng_ctx_field *field,
+void cgroup_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void cgroup_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void cgroup_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_cgroup_ns();
}
{
value->u.s64 = get_cgroup_ns();
}
-int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_cgroup_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "cgroup_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "cgroup_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = cgroup_ns_get_size;
field->record = cgroup_ns_record;
field->get_value = cgroup_ns_get_value;
field->get_size = cgroup_ns_get_size;
field->record = cgroup_ns_record;
field->get_value = cgroup_ns_get_value;
#include "context-internal.h"
static
#include "context-internal.h"
static
-size_t cpu_id_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t cpu_id_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void cpu_id_record(struct lttng_ctx_field *field,
+void cpu_id_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void cpu_id_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void cpu_id_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = lttng_ust_get_cpu();
}
{
value->u.s64 = lttng_ust_get_cpu();
}
-int lttng_add_cpu_id_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_cpu_id_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "cpu_id";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(int) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(int) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(int);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "cpu_id";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(int) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(int) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(int);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = cpu_id_get_size;
field->record = cpu_id_record;
field->get_value = cpu_id_get_value;
field->get_size = cpu_id_get_size;
field->record = cpu_id_record;
field->get_value = cpu_id_get_value;
#include "context-internal.h"
static
#include "context-internal.h"
static
-size_t ip_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t ip_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void ip_record(struct lttng_ctx_field *field,
+void ip_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
chan->ops->event_write(ctx, &ip, sizeof(ip));
}
chan->ops->event_write(ctx, &ip, sizeof(ip));
}
-int lttng_add_ip_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_ip_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "ip";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(void *) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(void *) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(void *);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 16;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "ip";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(void *) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(void *) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(void *);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 16;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = ip_get_size;
field->record = ip_record;
lttng_context_update(*ctx);
field->get_size = ip_get_size;
field->record = ip_record;
lttng_context_update(*ctx);
-size_t ipc_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t ipc_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void ipc_ns_record(struct lttng_ctx_field *field,
+void ipc_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void ipc_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void ipc_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_ipc_ns();
}
{
value->u.s64 = get_ipc_ns();
}
-int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_ipc_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "ipc_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "ipc_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = ipc_ns_get_size;
field->record = ipc_ns_record;
field->get_value = ipc_ns_get_value;
field->get_size = ipc_ns_get_size;
field->record = ipc_ns_record;
field->get_value = ipc_ns_get_value;
-size_t mnt_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t mnt_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void mnt_ns_record(struct lttng_ctx_field *field,
+void mnt_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void mnt_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void mnt_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_mnt_ns();
}
{
value->u.s64 = get_mnt_ns();
}
-int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_mnt_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "mnt_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "mnt_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = mnt_ns_get_size;
field->record = mnt_ns_record;
field->get_value = mnt_ns_get_value;
field->get_size = mnt_ns_get_size;
field->record = mnt_ns_record;
field->get_value = mnt_ns_get_value;
-size_t net_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t net_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void net_ns_record(struct lttng_ctx_field *field,
+void net_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void net_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void net_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_net_ns();
}
{
value->u.s64 = get_net_ns();
}
-int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_net_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "net_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "net_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = net_ns_get_size;
field->record = net_ns_record;
field->get_value = net_ns_get_value;
field->get_size = net_ns_get_size;
field->record = net_ns_record;
field->get_value = net_ns_get_value;
-size_t perf_counter_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t perf_counter_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-uint64_t wrapper_perf_counter_read(struct lttng_ctx_field *field)
+uint64_t wrapper_perf_counter_read(struct lttng_ust_ctx_field *field)
{
struct lttng_perf_counter_field *perf_field;
struct lttng_perf_counter_thread_field *perf_thread_field;
{
struct lttng_perf_counter_field *perf_field;
struct lttng_perf_counter_thread_field *perf_thread_field;
- perf_field = field->u.perf_counter;
+ perf_field = (struct lttng_perf_counter_field *) field->priv;
perf_thread_field = get_thread_field(perf_field);
return arch_read_perf_counter(perf_thread_field);
}
static
perf_thread_field = get_thread_field(perf_field);
return arch_read_perf_counter(perf_thread_field);
}
static
-void perf_counter_record(struct lttng_ctx_field *field,
+void perf_counter_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void perf_counter_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void perf_counter_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = wrapper_perf_counter_read(field);
}
{
value->u.s64 = wrapper_perf_counter_read(field);
}
/* Called with UST lock held */
static
/* Called with UST lock held */
static
-void lttng_destroy_perf_counter_field(struct lttng_ctx_field *field)
+void lttng_destroy_perf_counter_field(struct lttng_ust_ctx_field *field)
{
struct lttng_perf_counter_field *perf_field;
struct lttng_perf_counter_thread_field *pos, *p;
{
struct lttng_perf_counter_field *perf_field;
struct lttng_perf_counter_thread_field *pos, *p;
- free((char *) field->event_field.name);
- perf_field = field->u.perf_counter;
+ free((char *) field->event_field->name);
+ perf_field = (struct lttng_perf_counter_field *) field->priv;
/*
* This put is performed when no threads can concurrently
* perform a "get" concurrently, thanks to urcu-bp grace
/*
* This put is performed when no threads can concurrently
* perform a "get" concurrently, thanks to urcu-bp grace
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
- struct lttng_ctx **ctx)
+ struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
struct lttng_perf_counter_field *perf_field;
char *name_alloc;
int ret;
struct lttng_perf_counter_field *perf_field;
char *name_alloc;
int ret;
field->destroy = lttng_destroy_perf_counter_field;
field->destroy = lttng_destroy_perf_counter_field;
- field->event_field.name = name_alloc;
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size =
+ field->event_field->name = name_alloc;
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size =
sizeof(uint64_t) * CHAR_BIT;
sizeof(uint64_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment =
+ field->event_field->type.u.integer.alignment =
lttng_alignof(uint64_t) * CHAR_BIT;
lttng_alignof(uint64_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness =
+ field->event_field->type.u.integer.signedness =
lttng_is_signed_type(uint64_t);
lttng_is_signed_type(uint64_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = perf_counter_get_size;
field->record = perf_counter_record;
field->get_value = perf_counter_get_value;
field->get_size = perf_counter_get_size;
field->record = perf_counter_record;
field->get_value = perf_counter_get_value;
perf_field->attr.config = config;
perf_field->attr.exclude_kernel = perf_get_exclude_kernel();
CDS_INIT_LIST_HEAD(&perf_field->thread_field_list);
perf_field->attr.config = config;
perf_field->attr.exclude_kernel = perf_get_exclude_kernel();
CDS_INIT_LIST_HEAD(&perf_field->thread_field_list);
- field->u.perf_counter = perf_field;
+ field->priv = perf_field;
/* Ensure that this perf counter can be used in this process. */
ret = open_perf_fd(&perf_field->attr);
/* Ensure that this perf counter can be used in this process. */
ret = open_perf_fd(&perf_field->attr);
-size_t pid_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t pid_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void pid_ns_record(struct lttng_ctx_field *field,
+void pid_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void pid_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void pid_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_pid_ns();
}
{
value->u.s64 = get_pid_ns();
}
-int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_pid_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "pid_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "pid_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = pid_ns_get_size;
field->record = pid_ns_record;
field->get_value = pid_ns_get_value;
field->get_size = pid_ns_get_size;
field->record = pid_ns_record;
field->get_value = pid_ns_get_value;
-size_t procname_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t procname_get_size(struct lttng_ust_ctx_field *field, size_t offset)
{
return LTTNG_UST_ABI_PROCNAME_LEN;
}
static
{
return LTTNG_UST_ABI_PROCNAME_LEN;
}
static
-void procname_record(struct lttng_ctx_field *field,
+void procname_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void procname_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void procname_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.str = wrapper_getprocname();
}
{
value->u.str = wrapper_getprocname();
}
static const struct lttng_type procname_array_elem_type =
__type_integer(char, BYTE_ORDER, 10, UTF8);
static const struct lttng_type procname_array_elem_type =
__type_integer(char, BYTE_ORDER, 10, UTF8);
-int lttng_add_procname_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_procname_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "procname";
- field->event_field.type.atype = atype_array_nestable;
- field->event_field.type.u.array_nestable.elem_type =
+ field->event_field->name = "procname";
+ field->event_field->type.atype = atype_array_nestable;
+ field->event_field->type.u.array_nestable.elem_type =
&procname_array_elem_type;
&procname_array_elem_type;
- field->event_field.type.u.array_nestable.length = LTTNG_UST_ABI_PROCNAME_LEN;
+ field->event_field->type.u.array_nestable.length = LTTNG_UST_ABI_PROCNAME_LEN;
field->get_size = procname_get_size;
field->record = procname_record;
field->get_value = procname_get_value;
field->get_size = procname_get_size;
field->record = procname_record;
field->get_value = procname_get_value;
* metadata describing the context.
*/
int lttng_ust_add_app_context_to_ctx_rcu(const char *name,
* metadata describing the context.
*/
int lttng_ust_add_app_context_to_ctx_rcu(const char *name,
- struct lttng_ctx **ctx)
+ struct lttng_ust_ctx **ctx)
{
struct lttng_ust_context_provider *provider;
{
struct lttng_ust_context_provider *provider;
- struct lttng_ctx_field new_field;
+ struct lttng_ust_ctx_field *new_field = NULL;
int ret;
if (*ctx && lttng_find_context(*ctx, name))
return -EEXIST;
int ret;
if (*ctx && lttng_find_context(*ctx, name))
return -EEXIST;
- /*
- * For application context, add it by expanding
- * ctx array.
- */
- memset(&new_field, 0, sizeof(new_field));
- new_field.field_name = strdup(name);
- if (!new_field.field_name)
- return -ENOMEM;
- new_field.event_field.name = new_field.field_name;
- new_field.event_field.type.atype = atype_dynamic;
+ new_field = zmalloc(sizeof(struct lttng_ust_ctx_field));
+ if (!new_field) {
+ ret = -ENOMEM;
+ goto error_field_alloc;
+ }
+ new_field->struct_size = sizeof(struct lttng_ust_ctx_field);
+ new_field->event_field = zmalloc(sizeof(struct lttng_ust_event_field));
+ if (!new_field->event_field) {
+ ret = -ENOMEM;
+ goto error_event_field_alloc;
+ }
+ new_field->field_name = strdup(name);
+ if (!new_field->field_name) {
+ ret = -ENOMEM;
+ goto error_field_name_alloc;
+ }
+ new_field->event_field->name = new_field->field_name;
+ new_field->event_field->type.atype = atype_dynamic;
/*
* If provider is not found, we add the context anyway, but
* it will provide a dummy context.
*/
provider = lookup_provider_by_name(name);
if (provider) {
/*
* If provider is not found, we add the context anyway, but
* it will provide a dummy context.
*/
provider = lookup_provider_by_name(name);
if (provider) {
- new_field.get_size = provider->get_size;
- new_field.record = provider->record;
- new_field.get_value = provider->get_value;
+ new_field->get_size = provider->get_size;
+ new_field->record = provider->record;
+ new_field->get_value = provider->get_value;
- new_field.get_size = lttng_ust_dummy_get_size;
- new_field.record = lttng_ust_dummy_record;
- new_field.get_value = lttng_ust_dummy_get_value;
+ new_field->get_size = lttng_ust_dummy_get_size;
+ new_field->record = lttng_ust_dummy_record;
+ new_field->get_value = lttng_ust_dummy_get_value;
- ret = lttng_context_add_rcu(ctx, &new_field);
+ /*
+ * For application context, add it by expanding
+ * ctx array. Ownership of new_field is passed to the callee on
+ * success.
+ */
+ ret = lttng_context_add_rcu(ctx, new_field);
- free(new_field.field_name);
+ free(new_field->field_name);
+ free(new_field->event_field);
+ free(new_field);
+
+error_field_name_alloc:
+ free(new_field->event_field);
+error_event_field_alloc:
+ free(new_field);
+error_field_alloc:
+ return ret;
#include "context-internal.h"
static
#include "context-internal.h"
static
-size_t pthread_id_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t pthread_id_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void pthread_id_record(struct lttng_ctx_field *field,
+void pthread_id_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void pthread_id_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void pthread_id_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = (unsigned long) pthread_self();
}
{
value->u.s64 = (unsigned long) pthread_self();
}
-int lttng_add_pthread_id_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_pthread_id_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "pthread_id";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(unsigned long) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(unsigned long);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "pthread_id";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(unsigned long) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(unsigned long);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = pthread_id_get_size;
field->record = pthread_id_record;
field->get_value = pthread_id_get_value;
field->get_size = pthread_id_get_size;
field->record = pthread_id_record;
field->get_value = pthread_id_get_value;
-size_t time_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t time_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void time_ns_record(struct lttng_ctx_field *field,
+void time_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void time_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void time_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_time_ns();
}
{
value->u.s64 = get_time_ns();
}
-int lttng_add_time_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_time_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "time_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "time_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = time_ns_get_size;
field->record = time_ns_record;
field->get_value = time_ns_get_value;
field->get_size = time_ns_get_size;
field->record = time_ns_record;
field->get_value = time_ns_get_value;
-size_t user_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t user_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void user_ns_record(struct lttng_ctx_field *field,
+void user_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void user_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void user_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_user_ns();
}
{
value->u.s64 = get_user_ns();
}
-int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_user_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "user_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "user_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = user_ns_get_size;
field->record = user_ns_record;
field->get_value = user_ns_get_value;
field->get_size = user_ns_get_size;
field->record = user_ns_record;
field->get_value = user_ns_get_value;
-size_t uts_ns_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t uts_ns_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void uts_ns_record(struct lttng_ctx_field *field,
+void uts_ns_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void uts_ns_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void uts_ns_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_uts_ns();
}
{
value->u.s64 = get_uts_ns();
}
-int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_uts_ns_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "uts_ns";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(ino_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "uts_ns";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(ino_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(ino_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = uts_ns_get_size;
field->record = uts_ns_record;
field->get_value = uts_ns_get_value;
field->get_size = uts_ns_get_size;
field->record = uts_ns_record;
field->get_value = uts_ns_get_value;
-size_t vegid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vegid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vegid_record(struct lttng_ctx_field *field,
+void vegid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vegid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vegid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_vegid();
}
{
value->u.s64 = get_vegid();
}
-int lttng_add_vegid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vegid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vegid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(gid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vegid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(gid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vegid_get_size;
field->record = vegid_record;
field->get_value = vegid_get_value;
field->get_size = vegid_get_size;
field->record = vegid_record;
field->get_value = vegid_get_value;
-size_t veuid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t veuid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void veuid_record(struct lttng_ctx_field *field,
+void veuid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void veuid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void veuid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_veuid();
}
{
value->u.s64 = get_veuid();
}
-int lttng_add_veuid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_veuid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "veuid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(uid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "veuid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(uid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = veuid_get_size;
field->record = veuid_record;
field->get_value = veuid_get_value;
field->get_size = veuid_get_size;
field->record = veuid_record;
field->get_value = veuid_get_value;
-size_t vgid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vgid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vgid_record(struct lttng_ctx_field *field,
+void vgid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vgid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vgid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_vgid();
}
{
value->u.s64 = get_vgid();
}
-int lttng_add_vgid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vgid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vgid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(gid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vgid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(gid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vgid_get_size;
field->record = vgid_record;
field->get_value = vgid_get_value;
field->get_size = vgid_get_size;
field->record = vgid_record;
field->get_value = vgid_get_value;
-size_t vpid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vpid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vpid_record(struct lttng_ctx_field *field,
+void vpid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vpid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vpid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = wrapper_getvpid();
}
{
value->u.s64 = wrapper_getvpid();
}
-int lttng_add_vpid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vpid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vpid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(pid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(pid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(pid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vpid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(pid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(pid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(pid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vpid_get_size;
field->record = vpid_record;
field->get_value = vpid_get_value;
field->get_size = vpid_get_size;
field->record = vpid_record;
field->get_value = vpid_get_value;
-size_t vsgid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vsgid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vsgid_record(struct lttng_ctx_field *field,
+void vsgid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vsgid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vsgid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_vsgid();
}
{
value->u.s64 = get_vsgid();
}
-int lttng_add_vsgid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vsgid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vsgid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(gid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vsgid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(gid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(gid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vsgid_get_size;
field->record = vsgid_record;
field->get_value = vsgid_get_value;
field->get_size = vsgid_get_size;
field->record = vsgid_record;
field->get_value = vsgid_get_value;
-size_t vsuid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vsuid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vsuid_record(struct lttng_ctx_field *field,
+void vsuid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vsuid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vsuid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_vsuid();
}
{
value->u.s64 = get_vsuid();
}
-int lttng_add_vsuid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vsuid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vsuid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(uid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vsuid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(uid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vsuid_get_size;
field->record = vsuid_record;
field->get_value = vsuid_get_value;
field->get_size = vsuid_get_size;
field->record = vsuid_record;
field->get_value = vsuid_get_value;
-size_t vtid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vtid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vtid_record(struct lttng_ctx_field *field,
+void vtid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vtid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vtid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = wrapper_getvtid();
}
{
value->u.s64 = wrapper_getvtid();
}
-int lttng_add_vtid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vtid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vtid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(pid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(pid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(pid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vtid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(pid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(pid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(pid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vtid_get_size;
field->record = vtid_record;
field->get_value = vtid_get_value;
field->get_size = vtid_get_size;
field->record = vtid_record;
field->get_value = vtid_get_value;
-size_t vuid_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t vuid_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void vuid_record(struct lttng_ctx_field *field,
+void vuid_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void vuid_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void vuid_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->u.s64 = get_vuid();
}
{
value->u.s64 = get_vuid();
}
-int lttng_add_vuid_to_ctx(struct lttng_ctx **ctx)
+int lttng_add_vuid_to_ctx(struct lttng_ust_ctx **ctx)
- struct lttng_ctx_field *field;
+ struct lttng_ust_ctx_field *field;
field = lttng_append_context(ctx);
if (!field)
field = lttng_append_context(ctx);
if (!field)
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
lttng_remove_context_field(ctx, field);
return -EEXIST;
}
- field->event_field.name = "vuid";
- field->event_field.type.atype = atype_integer;
- field->event_field.type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
- field->event_field.type.u.integer.signedness = lttng_is_signed_type(uid_t);
- field->event_field.type.u.integer.reverse_byte_order = 0;
- field->event_field.type.u.integer.base = 10;
- field->event_field.type.u.integer.encoding = lttng_encode_none;
+ field->event_field->name = "vuid";
+ field->event_field->type.atype = atype_integer;
+ field->event_field->type.u.integer.size = sizeof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.alignment = lttng_alignof(uid_t) * CHAR_BIT;
+ field->event_field->type.u.integer.signedness = lttng_is_signed_type(uid_t);
+ field->event_field->type.u.integer.reverse_byte_order = 0;
+ field->event_field->type.u.integer.base = 10;
+ field->event_field->type.u.integer.encoding = lttng_encode_none;
field->get_size = vuid_get_size;
field->record = vuid_record;
field->get_value = vuid_get_value;
field->get_size = vuid_get_size;
field->record = vuid_record;
field->get_value = vuid_get_value;
* same context performed by the same thread return the same result.
*/
* same context performed by the same thread return the same result.
*/
-int lttng_find_context(struct lttng_ctx *ctx, const char *name)
+int lttng_find_context(struct lttng_ust_ctx *ctx, const char *name)
{
unsigned int i;
const char *subname;
{
unsigned int i;
const char *subname;
}
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
}
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
- if (!ctx->fields[i].event_field.name)
+ if (!ctx->fields[i]->event_field->name)
- if (!strcmp(ctx->fields[i].event_field.name, subname))
+ if (!strcmp(ctx->fields[i]->event_field->name, subname))
-int lttng_get_context_index(struct lttng_ctx *ctx, const char *name)
+int lttng_get_context_index(struct lttng_ust_ctx *ctx, const char *name)
{
unsigned int i;
const char *subname;
{
unsigned int i;
const char *subname;
}
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
}
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
- if (!ctx->fields[i].event_field.name)
+ if (!ctx->fields[i]->event_field->name)
- if (!strcmp(ctx->fields[i].event_field.name, subname))
+ if (!strcmp(ctx->fields[i]->event_field->name, subname))
-static int lttng_find_context_provider(struct lttng_ctx *ctx, const char *name)
+static int lttng_find_context_provider(struct lttng_ust_ctx *ctx, const char *name)
{
unsigned int i;
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
{
unsigned int i;
for (i = 0; i < ctx->nr_fields; i++) {
/* Skip allocated (but non-initialized) contexts */
- if (!ctx->fields[i].event_field.name)
+ if (!ctx->fields[i]->event_field->name)
- if (!strncmp(ctx->fields[i].event_field.name, name,
+ if (!strncmp(ctx->fields[i]->event_field->name, name,
strlen(name)))
return 1;
}
strlen(name)))
return 1;
}
/*
* Note: as we append context information, the pointer location may change.
/*
* Note: as we append context information, the pointer location may change.
+ * lttng_add_context leaves the new last context initialized to NULL.
-struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx_p)
+static
+int lttng_add_context(struct lttng_ust_ctx **ctx_p)
- struct lttng_ctx_field *field;
- struct lttng_ctx *ctx;
+ struct lttng_ust_ctx *ctx;
- *ctx_p = zmalloc(sizeof(struct lttng_ctx));
+ *ctx_p = zmalloc(sizeof(struct lttng_ust_ctx));
+ return -ENOMEM;
+ (*ctx_p)->struct_size = sizeof(struct lttng_ust_ctx);
(*ctx_p)->largest_align = 1;
}
ctx = *ctx_p;
if (ctx->nr_fields + 1 > ctx->allocated_fields) {
(*ctx_p)->largest_align = 1;
}
ctx = *ctx_p;
if (ctx->nr_fields + 1 > ctx->allocated_fields) {
- struct lttng_ctx_field *new_fields;
+ struct lttng_ust_ctx_field **new_fields;
ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields);
ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields);
- new_fields = zmalloc(ctx->allocated_fields * sizeof(struct lttng_ctx_field));
+ new_fields = zmalloc(ctx->allocated_fields * sizeof(*new_fields));
+ return -ENOMEM;
+ /* Copy pointers */
if (ctx->fields)
memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields);
free(ctx->fields);
ctx->fields = new_fields;
}
if (ctx->fields)
memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields);
free(ctx->fields);
ctx->fields = new_fields;
}
- field = &ctx->fields[ctx->nr_fields];
+ return 0;
+}
+
+struct lttng_ust_ctx_field *lttng_append_context(struct lttng_ust_ctx **ctx_p)
+{
+ struct lttng_ust_ctx_field *field;
+ int ret;
+
+ field = zmalloc(sizeof(struct lttng_ust_ctx_field));
+ if (!field)
+ goto error_alloc_field;
+ field->struct_size = sizeof(struct lttng_ust_ctx_field);
+ field->event_field = zmalloc(sizeof(struct lttng_ust_event_field));
+ if (!field->event_field)
+ goto error_alloc_event_field;
+ field->event_field->struct_size = sizeof(struct lttng_ust_event_field);
+
+ ret = lttng_add_context(ctx_p);
+ if (ret)
+ goto error_add_context;
+ (*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = field;
+
+error_add_context:
+ free(field->event_field);
+error_alloc_event_field:
+ free(field);
+error_alloc_field:
+ return NULL;
-int lttng_context_add_rcu(struct lttng_ctx **ctx_p,
- const struct lttng_ctx_field *f)
+/*
+ * Takes ownership of @f on success.
+ */
+int lttng_context_add_rcu(struct lttng_ust_ctx **ctx_p,
+ struct lttng_ust_ctx_field *f)
- struct lttng_ctx *old_ctx = *ctx_p, *new_ctx = NULL;
- struct lttng_ctx_field *new_fields = NULL;
- struct lttng_ctx_field *nf;
+ struct lttng_ust_ctx *old_ctx = *ctx_p, *new_ctx = NULL;
+ struct lttng_ust_ctx_field **new_fields = NULL;
+ int ret;
- new_ctx = zmalloc(sizeof(struct lttng_ctx));
+ new_ctx = zmalloc(sizeof(struct lttng_ust_ctx));
if (!new_ctx)
return -ENOMEM;
if (!new_ctx)
return -ENOMEM;
+ new_ctx->struct_size = sizeof(struct lttng_ust_ctx);
- new_fields = zmalloc(new_ctx->allocated_fields
- * sizeof(struct lttng_ctx_field));
+ new_fields = zmalloc(new_ctx->allocated_fields * sizeof(*new_fields));
if (!new_fields) {
free(new_ctx);
return -ENOMEM;
}
if (!new_fields) {
free(new_ctx);
return -ENOMEM;
}
memcpy(new_fields, old_ctx->fields,
sizeof(*old_ctx->fields) * old_ctx->nr_fields);
new_ctx->fields = new_fields;
}
memcpy(new_fields, old_ctx->fields,
sizeof(*old_ctx->fields) * old_ctx->nr_fields);
new_ctx->fields = new_fields;
}
- nf = lttng_append_context(&new_ctx);
- if (!nf) {
+ ret = lttng_add_context(&new_ctx);
+ if (ret) {
free(new_fields);
free(new_ctx);
free(new_fields);
free(new_ctx);
+ /* Taking ownership of f. */
+ (*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = f;
lttng_context_update(new_ctx);
lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
lttng_ust_urcu_synchronize_rcu();
lttng_context_update(new_ctx);
lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
lttng_ust_urcu_synchronize_rcu();
* lttng_context_update() should be called at least once between context
* modification and trace start.
*/
* lttng_context_update() should be called at least once between context
* modification and trace start.
*/
-void lttng_context_update(struct lttng_ctx *ctx)
+void lttng_context_update(struct lttng_ust_ctx *ctx)
{
int i;
size_t largest_align = 8; /* in bits */
{
int i;
size_t largest_align = 8; /* in bits */
struct lttng_type *type;
size_t field_align = 8;
struct lttng_type *type;
size_t field_align = 8;
- type = &ctx->fields[i].event_field.type;
+ type = &ctx->fields[i]->event_field->type;
switch (type->atype) {
case atype_integer:
field_align = type->u.integer.alignment;
switch (type->atype) {
case atype_integer:
field_align = type->u.integer.alignment;
/*
* Remove last context field.
*/
/*
* Remove last context field.
*/
-void lttng_remove_context_field(struct lttng_ctx **ctx_p,
- struct lttng_ctx_field *field)
+void lttng_remove_context_field(struct lttng_ust_ctx **ctx_p,
+ struct lttng_ust_ctx_field *field)
+ struct lttng_ust_ctx *ctx;
ctx = *ctx_p;
ctx->nr_fields--;
ctx = *ctx_p;
ctx->nr_fields--;
- assert(&ctx->fields[ctx->nr_fields] == field);
+ assert(ctx->fields[ctx->nr_fields] == field);
assert(field->field_name == NULL);
assert(field->field_name == NULL);
- memset(&ctx->fields[ctx->nr_fields], 0, sizeof(struct lttng_ctx_field));
+ ctx->fields[ctx->nr_fields] = NULL;
-void lttng_destroy_context(struct lttng_ctx *ctx)
+void lttng_destroy_context(struct lttng_ust_ctx *ctx)
{
int i;
if (!ctx)
return;
for (i = 0; i < ctx->nr_fields; i++) {
{
int i;
if (!ctx)
return;
for (i = 0; i < ctx->nr_fields; i++) {
- if (ctx->fields[i].destroy)
- ctx->fields[i].destroy(&ctx->fields[i]);
- free(ctx->fields[i].field_name);
+ if (ctx->fields[i]->destroy)
+ ctx->fields[i]->destroy(ctx->fields[i]);
+ free(ctx->fields[i]->field_name);
+ free(ctx->fields[i]->event_field);
+ free(ctx->fields[i]);
}
free(ctx->fields);
free(ctx);
}
free(ctx->fields);
free(ctx);
* a single RCU read-side critical section see either all old, or all
* new handlers.
*/
* a single RCU read-side critical section see either all old, or all
* new handlers.
*/
-int lttng_ust_context_set_provider_rcu(struct lttng_ctx **_ctx,
+int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value))
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value))
- struct lttng_ctx *ctx = *_ctx, *new_ctx;
- struct lttng_ctx_field *new_fields;
+ struct lttng_ust_ctx *ctx = *_ctx, *new_ctx;
+ struct lttng_ust_ctx_field **new_fields;
if (!ctx || !lttng_find_context_provider(ctx, name))
return 0;
if (!ctx || !lttng_find_context_provider(ctx, name))
return 0;
new_ctx = zmalloc(sizeof(*new_ctx));
if (!new_ctx)
return -ENOMEM;
new_ctx = zmalloc(sizeof(*new_ctx));
if (!new_ctx)
return -ENOMEM;
+ new_ctx->struct_size = sizeof(*new_ctx);
*new_ctx = *ctx;
new_fields = zmalloc(sizeof(*new_fields) * ctx->allocated_fields);
if (!new_fields) {
ret = -ENOMEM;
goto field_error;
}
*new_ctx = *ctx;
new_fields = zmalloc(sizeof(*new_fields) * ctx->allocated_fields);
if (!new_fields) {
ret = -ENOMEM;
goto field_error;
}
memcpy(new_fields, ctx->fields,
sizeof(*new_fields) * ctx->allocated_fields);
for (i = 0; i < ctx->nr_fields; i++) {
memcpy(new_fields, ctx->fields,
sizeof(*new_fields) * ctx->allocated_fields);
for (i = 0; i < ctx->nr_fields; i++) {
- if (strncmp(new_fields[i].event_field.name,
+ if (strncmp(new_fields[i]->event_field->name,
name, strlen(name)) != 0)
continue;
name, strlen(name)) != 0)
continue;
- new_fields[i].get_size = get_size;
- new_fields[i].record = record;
- new_fields[i].get_value = get_value;
+ new_fields[i]->get_size = get_size;
+ new_fields[i]->record = record;
+ new_fields[i]->get_value = get_value;
}
new_ctx->fields = new_fields;
lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
}
new_ctx->fields = new_fields;
lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
-int lttng_context_init_all(struct lttng_ctx **ctx)
+int lttng_context_init_all(struct lttng_ust_ctx **ctx)
static
int lttng_create_all_ctx_enums(size_t nr_fields,
static
int lttng_create_all_ctx_enums(size_t nr_fields,
- const struct lttng_ctx_field *ctx_fields,
+ struct lttng_ust_ctx_field **ctx_fields,
struct lttng_session *session)
{
size_t i;
struct lttng_session *session)
{
size_t i;
/* For each field, ensure enum is part of the session. */
for (i = 0; i < nr_fields; i++) {
/* For each field, ensure enum is part of the session. */
for (i = 0; i < nr_fields; i++) {
- const struct lttng_type *type = &ctx_fields[i].event_field.type;
+ const struct lttng_type *type = &ctx_fields[i]->event_field->type;
ret = lttng_create_enum_check(type, session);
if (ret)
ret = lttng_create_enum_check(type, session);
if (ret)
* we need to use.
*/
cds_list_for_each_entry(chan, &session->priv->chan_head, node) {
* we need to use.
*/
cds_list_for_each_entry(chan, &session->priv->chan_head, node) {
- const struct lttng_ctx *ctx;
- const struct lttng_ctx_field *fields = NULL;
+ const struct lttng_ust_ctx *ctx;
+ struct lttng_ust_ctx_field **fields = NULL;
size_t nr_fields = 0;
uint32_t chan_id;
size_t nr_fields = 0;
uint32_t chan_id;
int lttng_attach_context(struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
int lttng_attach_context(struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
- struct lttng_ctx **ctx, struct lttng_session *session)
+ struct lttng_ust_ctx **ctx, struct lttng_session *session)
{
/*
* We cannot attach a context after trace has been started for a
{
/*
* We cannot attach a context after trace has been started for a
* context (either app context callbacks, or dummy callbacks).
*/
void lttng_ust_context_set_session_provider(const char *name,
* context (either app context callbacks, or dummy callbacks).
*/
void lttng_ust_context_set_session_provider(const char *name,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value))
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value))
{
struct lttng_ust_session_private *session_priv;
{
struct lttng_ust_session_private *session_priv;
* context (either app context callbacks, or dummy callbacks).
*/
void lttng_ust_context_set_event_notifier_group_provider(const char *name,
* context (either app context callbacks, or dummy callbacks).
*/
void lttng_ust_context_set_event_notifier_group_provider(const char *name,
- size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
- void (*record)(struct lttng_ctx_field *field,
+ size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+ void (*record)(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan),
- void (*get_value)(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value))
+ void (*get_value)(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value))
{
struct lttng_event_notifier_group *event_notifier_group;
{
struct lttng_event_notifier_group *event_notifier_group;
-size_t ctx_get_aligned_size(size_t offset, struct lttng_ctx *ctx,
+size_t ctx_get_aligned_size(size_t offset, struct lttng_ust_ctx *ctx,
size_t ctx_len)
{
size_t orig_offset = offset;
size_t ctx_len)
{
size_t orig_offset = offset;
-void ctx_get_struct_size(struct lttng_ctx *ctx, size_t *ctx_len,
+void ctx_get_struct_size(struct lttng_ust_ctx *ctx, size_t *ctx_len,
enum app_ctx_mode mode)
{
int i;
enum app_ctx_mode mode)
{
int i;
}
for (i = 0; i < ctx->nr_fields; i++) {
if (mode == APP_CTX_ENABLED) {
}
for (i = 0; i < ctx->nr_fields; i++) {
if (mode == APP_CTX_ENABLED) {
- offset += ctx->fields[i].get_size(&ctx->fields[i], offset);
+ offset += ctx->fields[i]->get_size(ctx->fields[i], offset);
- if (lttng_context_is_app(ctx->fields[i].event_field.name)) {
+ if (lttng_context_is_app(ctx->fields[i]->event_field->name)) {
/*
* Before UST 2.8, we cannot use the
* application context, because we
/*
* Before UST 2.8, we cannot use the
* application context, because we
* concurrently with application context
* register/unregister.
*/
* concurrently with application context
* register/unregister.
*/
- offset += lttng_ust_dummy_get_size(&ctx->fields[i], offset);
+ offset += lttng_ust_dummy_get_size(ctx->fields[i], offset);
- offset += ctx->fields[i].get_size(&ctx->fields[i], offset);
+ offset += ctx->fields[i]->get_size(ctx->fields[i], offset);
static inline
void ctx_record(struct lttng_ust_lib_ring_buffer_ctx *bufctx,
struct lttng_channel *chan,
static inline
void ctx_record(struct lttng_ust_lib_ring_buffer_ctx *bufctx,
struct lttng_channel *chan,
+ struct lttng_ust_ctx *ctx,
enum app_ctx_mode mode)
{
int i;
enum app_ctx_mode mode)
{
int i;
lib_ring_buffer_align_ctx(bufctx, ctx->largest_align);
for (i = 0; i < ctx->nr_fields; i++) {
if (mode == APP_CTX_ENABLED) {
lib_ring_buffer_align_ctx(bufctx, ctx->largest_align);
for (i = 0; i < ctx->nr_fields; i++) {
if (mode == APP_CTX_ENABLED) {
- ctx->fields[i].record(&ctx->fields[i], bufctx, chan);
+ ctx->fields[i]->record(ctx->fields[i], bufctx, chan);
- if (lttng_context_is_app(ctx->fields[i].event_field.name)) {
+ if (lttng_context_is_app(ctx->fields[i]->event_field->name)) {
/*
* Before UST 2.8, we cannot use the
* application context, because we
/*
* Before UST 2.8, we cannot use the
* application context, because we
* concurrently with application context
* register/unregister.
*/
* concurrently with application context
* register/unregister.
*/
- lttng_ust_dummy_record(&ctx->fields[i], bufctx, chan);
+ lttng_ust_dummy_record(ctx->fields[i], bufctx, chan);
- ctx->fields[i].record(&ctx->fields[i], bufctx, chan);
+ ctx->fields[i]->record(ctx->fields[i], bufctx, chan);
struct lttng_session;
struct lttng_channel;
struct lttng_event;
struct lttng_session;
struct lttng_channel;
struct lttng_event;
+struct lttng_ust_ctx_field;
struct lttng_ust_lib_ring_buffer_ctx;
struct lttng_ust_lib_ring_buffer_ctx;
+struct lttng_ust_ctx_value;
struct lttng_ust_event_notifier;
__attribute__((visibility("hidden")))
struct lttng_ust_event_notifier;
__attribute__((visibility("hidden")))
ssize_t lttng_ust_read(int fd, void *buf, size_t len);
__attribute__((visibility("hidden")))
ssize_t lttng_ust_read(int fd, void *buf, size_t len);
__attribute__((visibility("hidden")))
-size_t lttng_ust_dummy_get_size(struct lttng_ctx_field *field, size_t offset);
+size_t lttng_ust_dummy_get_size(struct lttng_ust_ctx_field *field, size_t offset);
__attribute__((visibility("hidden")))
__attribute__((visibility("hidden")))
-void lttng_ust_dummy_record(struct lttng_ctx_field *field,
+void lttng_ust_dummy_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
__attribute__((visibility("hidden")))
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan);
__attribute__((visibility("hidden")))
-void lttng_ust_dummy_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value);
+void lttng_ust_dummy_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value);
__attribute__((visibility("hidden")))
void lttng_event_notifier_notification_send(
__attribute__((visibility("hidden")))
void lttng_event_notifier_notification_send(
long lttng_abi_add_context(int objd,
struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
long lttng_abi_add_context(int objd,
struct lttng_ust_abi_context *context_param,
union lttng_ust_abi_args *uargs,
- struct lttng_ctx **ctx, struct lttng_session *session)
+ struct lttng_ust_ctx **ctx, struct lttng_session *session)
{
return lttng_attach_context(context_param, uargs, ctx, session);
}
{
return lttng_attach_context(context_param, uargs, ctx, session);
}
-size_t lttng_ust_dummy_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t lttng_ust_dummy_get_size(struct lttng_ust_ctx_field *field, size_t offset)
-void lttng_ust_dummy_record(struct lttng_ctx_field *field,
+void lttng_ust_dummy_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
chan->ops->event_write(ctx, &sel_char, sizeof(sel_char));
}
chan->ops->event_write(ctx, &sel_char, sizeof(sel_char));
}
-void lttng_ust_dummy_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void lttng_ust_dummy_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
value->sel = LTTNG_UST_DYNAMIC_TYPE_NONE;
}
{
value->sel = LTTNG_UST_DYNAMIC_TYPE_NONE;
}
* Unused, but kept around to make it explicit that the tracer can do
* it.
*/
* Unused, but kept around to make it explicit that the tracer can do
* it.
*/
+ struct lttng_ust_ctx *ctx;
};
struct lttng_event_notifier_enabler {
};
struct lttng_event_notifier_enabler {
struct cds_list_head enablers_head;
struct cds_list_head event_notifiers_head; /* list of event_notifiers */
struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
struct cds_list_head enablers_head;
struct cds_list_head event_notifiers_head; /* list of event_notifiers */
struct lttng_ust_event_notifier_ht event_notifiers_ht; /* hashtable of event_notifiers */
- struct lttng_ctx *ctx; /* contexts for filters. */
+ struct lttng_ust_ctx *ctx; /* contexts for filters. */
struct lttng_counter *error_counter;
size_t error_counter_len;
struct lttng_counter *error_counter;
size_t error_counter_len;
* Pointer to a URCU-protected pointer owned by an `struct
* lttng_session`or `struct lttng_event_notifier_group`.
*/
* Pointer to a URCU-protected pointer owned by an `struct
* lttng_session`or `struct lttng_event_notifier_group`.
*/
- struct lttng_ctx **pctx;
+ struct lttng_ust_ctx **pctx;
};
struct lttng_ust_session_private {
};
struct lttng_ust_session_private {
/* New UST 2.8 */
struct lttng_ust_enum_ht enums_ht; /* ht of enumerations */
struct cds_list_head enums_head;
/* New UST 2.8 */
struct lttng_ust_enum_ht enums_ht; /* ht of enumerations */
struct cds_list_head enums_head;
- struct lttng_ctx *ctx; /* contexts for filters. */
+ struct lttng_ust_ctx *ctx; /* contexts for filters. */
*/
__attribute__((visibility("hidden")))
void lttng_enabler_link_bytecode(const struct lttng_ust_event_desc *event_desc,
*/
__attribute__((visibility("hidden")))
void lttng_enabler_link_bytecode(const struct lttng_ust_event_desc *event_desc,
- struct lttng_ctx **ctx,
+ struct lttng_ust_ctx **ctx,
struct cds_list_head *instance_bytecode_runtime_head,
struct cds_list_head *enabler_bytecode_runtime_head);
struct cds_list_head *instance_bytecode_runtime_head,
struct cds_list_head *enabler_bytecode_runtime_head);
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
- struct lttng_ctx **ctx);
+ struct lttng_ust_ctx **ctx);
__attribute__((visibility("hidden")))
int lttng_perf_counter_init(void);
__attribute__((visibility("hidden")))
int lttng_perf_counter_init(void);
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
int lttng_add_perf_counter_to_ctx(uint32_t type,
uint64_t config,
const char *name,
- struct lttng_ctx **ctx)
+ struct lttng_ust_ctx **ctx)
-size_t test_get_size(struct lttng_ctx_field *field, size_t offset)
+size_t test_get_size(struct lttng_ust_ctx_field *field, size_t offset)
{
int sel = test_count % _NR_LTTNG_UST_DYNAMIC_TYPES;
size_t size = 0;
{
int sel = test_count % _NR_LTTNG_UST_DYNAMIC_TYPES;
size_t size = 0;
-void test_record(struct lttng_ctx_field *field,
+void test_record(struct lttng_ust_ctx_field *field,
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
struct lttng_ust_lib_ring_buffer_ctx *ctx,
struct lttng_channel *chan)
{
-void test_get_value(struct lttng_ctx_field *field,
- struct lttng_ctx_value *value)
+void test_get_value(struct lttng_ust_ctx_field *field,
+ struct lttng_ust_ctx_value *value)
{
int sel = test_count % _NR_LTTNG_UST_DYNAMIC_TYPES;
{
int sel = test_count % _NR_LTTNG_UST_DYNAMIC_TYPES;
}
struct lttng_ust_context_provider myprovider = {
}
struct lttng_ust_context_provider myprovider = {
+ .struct_size = sizeof(struct lttng_ust_context_provider),
.name = "$app.myprovider",
.get_size = test_get_size,
.record = test_record,
.name = "$app.myprovider",
.get_size = test_get_size,
.record = test_record,