[babeltrace.git] / formats / ctf / events.c

/*
 * ctf/events.c
 *
 * Babeltrace Library
 *
 * Copyright 2011-2012 EfficiOS Inc. and Linux Foundation
 *
 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *         Julien Desfossez <julien.desfossez@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

#include <babeltrace/babeltrace.h>
#include <babeltrace/format.h>
#include <babeltrace/ctf/events.h>
#include <babeltrace/ctf-ir/metadata.h>
#include <babeltrace/prio_heap.h>
#include <babeltrace/iterator-internal.h>
#include <babeltrace/ctf/events-internal.h>
#include <babeltrace/ctf/metadata.h>
#include <glib.h>

#include "events-private.h"

/*
 * thread local storage to store the last error that occured
 * while reading a field, this variable must be accessed by
 * bt_ctf_field_error only
 */
__thread int bt_ctf_last_field_error = 0;

const struct definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
		enum bt_ctf_scope scope)
{
	struct definition *tmp = NULL;
	struct ctf_event_definition *event = ctf_event->parent;

	switch (scope) {
	case BT_TRACE_PACKET_HEADER:
		if (!event->stream)
			goto error;
		if (event->stream->trace_packet_header)
			tmp = &event->stream->trace_packet_header->p;
		break;
	case BT_STREAM_PACKET_CONTEXT:
		if (!event->stream)
			goto error;
		if (event->stream->stream_packet_context)
			tmp = &event->stream->stream_packet_context->p;
		break;
	case BT_STREAM_EVENT_HEADER:
		if (!event->stream)
			goto error;
		if (event->stream->stream_event_header)
			tmp = &event->stream->stream_event_header->p;
		break;
	case BT_STREAM_EVENT_CONTEXT:
		if (!event->stream)
			goto error;
		if (event->stream->stream_event_context)
			tmp = &event->stream->stream_event_context->p;
		break;
	case BT_EVENT_CONTEXT:
		if (event->event_context)
			tmp = &event->event_context->p;
		break;
	case BT_EVENT_FIELDS:
		if (event->event_fields)
			tmp = &event->event_fields->p;
		break;
	}
	return tmp;

error:
	return NULL;
}

const struct definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
		const struct definition *scope,
		const char *field)
{
	struct definition *def;
	char *field_underscore;

	if (scope) {
		def = lookup_definition(scope, field);
		/*
		 * optionally a field can have an underscore prefix, try
		 * to lookup the field with this prefix if it failed
		 */
		if (!def) {
			field_underscore = g_new(char, strlen(field) + 2);
			field_underscore[0] = '_';
			strcpy(&field_underscore[1], field);
			def = lookup_definition(scope, field_underscore);
			g_free(field_underscore);
		}
		if (bt_ctf_field_type(def) == CTF_TYPE_VARIANT) {
			struct definition_variant *variant_definition;
			variant_definition = container_of(def,
					struct definition_variant, p);
			return variant_definition->current_field;
		}
		return def;
	}
	return NULL;
}

const struct definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
		const struct definition *field,
		unsigned int index)
{
	struct definition *ret = NULL;

	if (bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
		struct definition_array *array_definition;
		array_definition = container_of(field,
				struct definition_array, p);
		ret = array_index(array_definition, index);
	} else if (bt_ctf_field_type(field) == CTF_TYPE_SEQUENCE) {
		struct definition_sequence *sequence_definition;
		sequence_definition = container_of(field,
				struct definition_sequence, p);
		ret = sequence_index(sequence_definition, index);
	}
	return ret;
}

const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event)
{
	struct ctf_event_declaration *event_class;
	struct ctf_stream_declaration *stream_class;
	struct ctf_event_definition *event = ctf_event->parent;

	if (!event)
		return NULL;
	stream_class = event->stream->stream_class;
	event_class = g_ptr_array_index(stream_class->events_by_id,
			event->stream->event_id);
	return g_quark_to_string(event_class->name);
}

const char *bt_ctf_field_name(const struct definition *def)
{
	if (def)
		return rem_(g_quark_to_string(def->name));
	return NULL;
}

enum ctf_type_id bt_ctf_field_type(const struct definition *def)
{
	if (def)
		return def->declaration->id;
	return CTF_TYPE_UNKNOWN;
}

int bt_ctf_get_field_list(const struct bt_ctf_event *ctf_event,
		const struct definition *scope,
		struct definition const * const **list,
		unsigned int *count)
{
	switch (bt_ctf_field_type(scope)) {
	case CTF_TYPE_INTEGER:
	case CTF_TYPE_FLOAT:
	case CTF_TYPE_STRING:
	case CTF_TYPE_ENUM:
		goto error;
	case CTF_TYPE_STRUCT:
	{
		const struct definition_struct *def_struct;

		def_struct = container_of(scope, const struct definition_struct, p);
		if (!def_struct)
			goto error;
		if (def_struct->fields->pdata) {
			*list = (struct definition const* const*) def_struct->fields->pdata;
			*count = def_struct->fields->len;
			goto end;
		} else {
			goto error;
		}
	}
	case CTF_TYPE_UNTAGGED_VARIANT:
		goto error;
	case CTF_TYPE_VARIANT:
	{
		const struct definition_variant *def_variant;

		def_variant = container_of(scope, const struct definition_variant, p);
		if (!def_variant)
			goto error;
		if (def_variant->fields->pdata) {
			*list = (struct definition const* const*) def_variant->fields->pdata;
			*count = def_variant->fields->len;
			goto end;
		} else {
			goto error;
		}
	}
	case CTF_TYPE_ARRAY:
	{
		const struct definition_array *def_array;

		def_array = container_of(scope, const struct definition_array, p);
		if (!def_array)
			goto error;
		if (def_array->elems->pdata) {
			*list = (struct definition const* const*) def_array->elems->pdata;
			*count = def_array->elems->len;
			goto end;
		} else {
			goto error;
		}
	}
	case CTF_TYPE_SEQUENCE:
	{
		const struct definition_sequence *def_sequence;

		def_sequence = container_of(scope, const struct definition_sequence, p);
		if (!def_sequence)
			goto error;
		if (def_sequence->elems->pdata) {
			*list = (struct definition const* const*) def_sequence->elems->pdata;
			*count = def_sequence->elems->len;
			goto end;
		} else {
			goto error;
		}
	}
	default:
		break;
	}

end:
	return 0;

error:
	*list = NULL;
	*count = 0;
	return -1;
}

struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *ctf_event)
{
	struct bt_context *ret = NULL;
	struct ctf_file_stream *cfs;
	struct ctf_trace *trace;
	struct ctf_event_definition *event = ctf_event->parent;

	cfs = container_of(event->stream, struct ctf_file_stream,
			parent);
	trace = cfs->parent.stream_class->trace;
	if (trace->ctx)
		ret = trace->ctx;

	return ret;
}

int bt_ctf_event_get_handle_id(const struct bt_ctf_event *ctf_event)
{
	int ret = -1;
	struct ctf_file_stream *cfs;
	struct ctf_trace *trace;
	struct ctf_event_definition *event = ctf_event->parent;

	cfs = container_of(event->stream, struct ctf_file_stream,
			parent);
	trace = cfs->parent.stream_class->trace;
	if (trace->handle)
		ret = trace->handle->id;

	return ret;
}

uint64_t bt_ctf_get_timestamp_raw(const struct bt_ctf_event *ctf_event)
{
	struct ctf_event_definition *event = ctf_event->parent;
	if (event && event->stream->has_timestamp)
		return ctf_get_timestamp_raw(event->stream,
				event->stream->timestamp);
	else
		return -1ULL;
}

uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event)
{
	struct ctf_event_definition *event = ctf_event->parent;
	if (event && event->stream->has_timestamp)
		return ctf_get_timestamp(event->stream,
				event->stream->timestamp);
	else
		return -1ULL;
}

static void bt_ctf_field_set_error(int error)
{
	bt_ctf_last_field_error = error;
}

int bt_ctf_field_get_error(void)
{
	int ret;
	ret = bt_ctf_last_field_error;
	bt_ctf_last_field_error = 0;

	return ret;
}

int bt_ctf_get_int_signedness(const struct definition *field)
{
	int ret;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
		ret = get_int_signedness(field);
	} else {
		ret = -1;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

int bt_ctf_get_int_base(const struct definition *field)
{
	int ret;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
		ret = get_int_base(field);
	} else {
		ret = -1;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

int bt_ctf_get_int_byte_order(const struct definition *field)
{
	int ret;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
		ret = get_int_byte_order(field);
	} else {
		ret = -1;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

ssize_t bt_ctf_get_int_len(const struct definition *field)
{
	ssize_t ret;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
		ret = (ssize_t) get_int_len(field);
	} else {
		ret = -1;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field)
{
	enum ctf_string_encoding ret = 0;

	if (!field)
		goto end;

	if (bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
		ret = get_int_encoding(field);
	else if (bt_ctf_field_type(field) == CTF_TYPE_STRING)
		ret = get_string_encoding(field);
	else
		goto error;

end:
	return ret;

error:
	bt_ctf_field_set_error(-EINVAL);
	return -1;
}

int bt_ctf_get_array_len(const struct definition *field)
{
	int ret;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
		ret = get_array_len(field);
	} else {
		ret = -1;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

uint64_t bt_ctf_get_uint64(const struct definition *field)
{
	unsigned int ret = 0;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
		ret = get_unsigned_int(field);
	else
		bt_ctf_field_set_error(-EINVAL);

	return ret;
}

int64_t bt_ctf_get_int64(const struct definition *field)
{
	int ret = 0;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
		ret = get_signed_int(field);
	else
		bt_ctf_field_set_error(-EINVAL);

	return ret;

}

char *bt_ctf_get_char_array(const struct definition *field)
{
	char *ret = NULL;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY)
		ret = get_char_array(field)->str;
	else
		bt_ctf_field_set_error(-EINVAL);

	return ret;
}

char *bt_ctf_get_string(const struct definition *field)
{
	char *ret = NULL;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_STRING)
		ret = get_string(field);
	else
		bt_ctf_field_set_error(-EINVAL);

	return ret;
}

int bt_ctf_get_event_decl_list(int handle_id, struct bt_context *ctx,
		struct bt_ctf_event_decl * const **list,
		unsigned int *count)
{
	struct bt_trace_handle *handle;
	struct trace_descriptor *td;
	struct ctf_trace *tin;

	if (!ctx)
		goto error;

	handle = g_hash_table_lookup(ctx->trace_handles,
			(gpointer) (unsigned long) handle_id);
	if (!handle)
		goto error;

	td = handle->td;
	tin = container_of(td, struct ctf_trace, parent);

	*list = (struct bt_ctf_event_decl * const*) tin->event_declarations->pdata;
	*count = tin->event_declarations->len;
	return 0;

error:
	return -1;
}

const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event)
{
	if (!event)
		return NULL;
	return g_quark_to_string(event->parent.name);
}

int bt_ctf_get_decl_fields(struct bt_ctf_event_decl *event_decl,
		enum bt_ctf_scope scope,
		struct bt_ctf_field_decl const * const **list,
		unsigned int *count)
{
	int i;
	GArray *fields = NULL;
	gpointer *ret_list = NULL;
	GPtrArray *fields_array = NULL;
	int ret = 0;
	*count = 0;

	switch (scope) {
	case BT_EVENT_CONTEXT:
		if (event_decl->context_decl) {
			ret_list = event_decl->context_decl->pdata;
			*count = event_decl->context_decl->len;
			goto end;
		}
		event_decl->context_decl = g_ptr_array_new();
		if (!event_decl->parent.context_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.context_decl->fields;
		fields_array = event_decl->context_decl;
		break;
	case BT_EVENT_FIELDS:
		if (event_decl->fields_decl) {
			ret_list = event_decl->fields_decl->pdata;
			*count = event_decl->fields_decl->len;
			goto end;
		}
		event_decl->fields_decl = g_ptr_array_new();
		if (!event_decl->parent.fields_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.fields_decl->fields;
		fields_array = event_decl->fields_decl;
		break;
	case BT_STREAM_PACKET_CONTEXT:
		if (event_decl->packet_context_decl) {
			ret_list = event_decl->packet_context_decl->pdata;
			*count = event_decl->packet_context_decl->len;
			goto end;
		}
		event_decl->packet_context_decl = g_ptr_array_new();
		if (!event_decl->parent.stream->packet_context_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.stream->packet_context_decl->fields;
		fields_array = event_decl->packet_context_decl;
		break;
	case BT_STREAM_EVENT_CONTEXT:
		if (event_decl->event_context_decl) {
			ret_list = event_decl->event_context_decl->pdata;
			*count = event_decl->event_context_decl->len;
			goto end;
		}
		event_decl->event_context_decl = g_ptr_array_new();
		if (!event_decl->parent.stream->event_context_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.stream->event_context_decl->fields;
		fields_array = event_decl->event_context_decl;
		break;
	case BT_STREAM_EVENT_HEADER:
		if (event_decl->event_header_decl) {
			ret_list = event_decl->event_header_decl->pdata;
			*count = event_decl->event_header_decl->len;
			goto end;
		}
		event_decl->event_header_decl = g_ptr_array_new();
		if (!event_decl->parent.stream->event_header_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.stream->event_header_decl->fields;
		fields_array = event_decl->event_header_decl;
		break;
	case BT_TRACE_PACKET_HEADER:
		if (event_decl->packet_header_decl) {
			ret_list = event_decl->packet_header_decl->pdata;
			*count = event_decl->packet_header_decl->len;
			goto end;
		}
		event_decl->packet_header_decl = g_ptr_array_new();
		if (!event_decl->parent.stream->trace->packet_header_decl) {
			ret = -1;
			goto end;
		}
		fields = event_decl->parent.stream->trace->packet_header_decl->fields;
		fields_array = event_decl->packet_header_decl;
		break;
	}

	for (i = 0; i < fields->len; i++) {
		g_ptr_array_add(fields_array,
				&g_array_index(fields,
					struct declaration_field, i));
	}
	ret_list = fields_array->pdata;
	*count = fields->len;

end:
	*list = (struct bt_ctf_field_decl const* const*) ret_list;

	return ret;
}

const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field)
{
	if (field)
		return rem_(g_quark_to_string(((struct declaration_field *) field)->name));
	return NULL;
}
Commit	Line	Data
9843982d	1	/*
5c5facc7	2	* ctf/events.c
9843982d JD	3	*
	4	* Babeltrace Library
	5	*
	6	* Copyright 2011-2012 EfficiOS Inc. and Linux Foundation
	7	*
	8	* Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	9	* Julien Desfossez <julien.desfossez@efficios.com>
	10	*
	11	* Permission is hereby granted, free of charge, to any person obtaining a copy
	12	* of this software and associated documentation files (the "Software"), to deal
	13	* in the Software without restriction, including without limitation the rights
	14	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	15	* copies of the Software, and to permit persons to whom the Software is
	16	* furnished to do so, subject to the following conditions:
	17	*
	18	* The above copyright notice and this permission notice shall be included in
	19	* all copies or substantial portions of the Software.
	20	*/
	21
	22	#include <babeltrace/babeltrace.h>
	23	#include <babeltrace/format.h>
	24	#include <babeltrace/ctf/events.h>
	25	#include <babeltrace/ctf-ir/metadata.h>
e4195791 MD	26	#include <babeltrace/prio_heap.h>
	27	#include <babeltrace/iterator-internal.h>
	28	#include <babeltrace/ctf/events-internal.h>
	29	#include <babeltrace/ctf/metadata.h>
9843982d JD	30	#include <glib.h>
9843982d JD	31
c34ea0fa MD	32	#include "events-private.h"
c34ea0fa MD	33
9843982d JD	34	/*
	35	* thread local storage to store the last error that occured
	36	* while reading a field, this variable must be accessed by
	37	* bt_ctf_field_error only
	38	*/
	39	__thread int bt_ctf_last_field_error = 0;
	40
c50d2a7a	41	const struct definition bt_ctf_get_top_level_scope(const struct bt_ctf_event ctf_event,
9843982d JD	42	enum bt_ctf_scope scope)
	43	{
	44	struct definition *tmp = NULL;
c50d2a7a	45	struct ctf_event_definition *event = ctf_event->parent;
9843982d JD	46
	47	switch (scope) {
	48	case BT_TRACE_PACKET_HEADER:
	49	if (!event->stream)
	50	goto error;
	51	if (event->stream->trace_packet_header)
	52	tmp = &event->stream->trace_packet_header->p;
	53	break;
	54	case BT_STREAM_PACKET_CONTEXT:
	55	if (!event->stream)
	56	goto error;
	57	if (event->stream->stream_packet_context)
	58	tmp = &event->stream->stream_packet_context->p;
	59	break;
	60	case BT_STREAM_EVENT_HEADER:
	61	if (!event->stream)
	62	goto error;
	63	if (event->stream->stream_event_header)
	64	tmp = &event->stream->stream_event_header->p;
	65	break;
	66	case BT_STREAM_EVENT_CONTEXT:
	67	if (!event->stream)
	68	goto error;
	69	if (event->stream->stream_event_context)
	70	tmp = &event->stream->stream_event_context->p;
	71	break;
	72	case BT_EVENT_CONTEXT:
8a4722b0 JD	73	if (event->event_context)
8a4722b0 JD	74	tmp = &event->event_context->p;
9843982d JD	75	break;
9843982d JD	76	case BT_EVENT_FIELDS:
8a4722b0 JD	77	if (event->event_fields)
8a4722b0 JD	78	tmp = &event->event_fields->p;
9843982d JD	79	break;
	80	}
	81	return tmp;
	82
	83	error:
	84	return NULL;
	85	}
	86
c50d2a7a	87	const struct definition bt_ctf_get_field(const struct bt_ctf_event ctf_event,
04ae3991	88	const struct definition *scope,
9843982d JD	89	const char *field)
	90	{
	91	struct definition *def;
300d317a	92	char *field_underscore;
9843982d JD	93
	94	if (scope) {
	95	def = lookup_definition(scope, field);
300d317a JD	96	/*
	97	* optionally a field can have an underscore prefix, try
	98	* to lookup the field with this prefix if it failed
	99	*/
	100	if (!def) {
	101	field_underscore = g_new(char, strlen(field) + 2);
	102	field_underscore[0] = '_';
	103	strcpy(&field_underscore[1], field);
	104	def = lookup_definition(scope, field_underscore);
	105	g_free(field_underscore);
	106	}
9843982d JD	107	if (bt_ctf_field_type(def) == CTF_TYPE_VARIANT) {
	108	struct definition_variant *variant_definition;
	109	variant_definition = container_of(def,
	110	struct definition_variant, p);
	111	return variant_definition->current_field;
	112	}
	113	return def;
	114	}
	115	return NULL;
	116	}
	117
c50d2a7a	118	const struct definition bt_ctf_get_index(const struct bt_ctf_event ctf_event,
04ae3991	119	const struct definition *field,
9843982d JD	120	unsigned int index)
	121	{
	122	struct definition *ret = NULL;
	123
	124	if (bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
	125	struct definition_array *array_definition;
	126	array_definition = container_of(field,
	127	struct definition_array, p);
	128	ret = array_index(array_definition, index);
	129	} else if (bt_ctf_field_type(field) == CTF_TYPE_SEQUENCE) {
	130	struct definition_sequence *sequence_definition;
	131	sequence_definition = container_of(field,
	132	struct definition_sequence, p);
	133	ret = sequence_index(sequence_definition, index);
	134	}
	135	return ret;
	136	}
	137
c50d2a7a	138	const char bt_ctf_event_name(const struct bt_ctf_event ctf_event)
9843982d	139	{
4716614a	140	struct ctf_event_declaration *event_class;
f380e105	141	struct ctf_stream_declaration *stream_class;
c50d2a7a	142	struct ctf_event_definition *event = ctf_event->parent;
9843982d JD	143
	144	if (!event)
	145	return NULL;
	146	stream_class = event->stream->stream_class;
	147	event_class = g_ptr_array_index(stream_class->events_by_id,
	148	event->stream->event_id);
	149	return g_quark_to_string(event_class->name);
	150	}
	151
	152	const char bt_ctf_field_name(const struct definition def)
	153	{
	154	if (def)
300d317a	155	return rem_(g_quark_to_string(def->name));
9843982d JD	156	return NULL;
	157	}
	158
da320b83	159	enum ctf_type_id bt_ctf_field_type(const struct definition *def)
9843982d JD	160	{
	161	if (def)
	162	return def->declaration->id;
	163	return CTF_TYPE_UNKNOWN;
	164	}
	165
c50d2a7a	166	int bt_ctf_get_field_list(const struct bt_ctf_event *ctf_event,
04ae3991	167	const struct definition *scope,
9843982d JD	168	struct definition const * const **list,
	169	unsigned int *count)
	170	{
	171	switch (bt_ctf_field_type(scope)) {
	172	case CTF_TYPE_INTEGER:
	173	case CTF_TYPE_FLOAT:
	174	case CTF_TYPE_STRING:
	175	case CTF_TYPE_ENUM:
	176	goto error;
	177	case CTF_TYPE_STRUCT:
	178	{
04ae3991	179	const struct definition_struct *def_struct;
9843982d	180
04ae3991	181	def_struct = container_of(scope, const struct definition_struct, p);
9843982d JD	182	if (!def_struct)
	183	goto error;
	184	if (def_struct->fields->pdata) {
	185	list = (struct definition const const*) def_struct->fields->pdata;
	186	*count = def_struct->fields->len;
	187	goto end;
	188	} else {
	189	goto error;
	190	}
	191	}
	192	case CTF_TYPE_UNTAGGED_VARIANT:
	193	goto error;
	194	case CTF_TYPE_VARIANT:
	195	{
04ae3991	196	const struct definition_variant *def_variant;
9843982d	197
04ae3991	198	def_variant = container_of(scope, const struct definition_variant, p);
9843982d JD	199	if (!def_variant)
	200	goto error;
	201	if (def_variant->fields->pdata) {
	202	list = (struct definition const const*) def_variant->fields->pdata;
	203	*count = def_variant->fields->len;
	204	goto end;
	205	} else {
	206	goto error;
	207	}
	208	}
	209	case CTF_TYPE_ARRAY:
	210	{
04ae3991	211	const struct definition_array *def_array;
9843982d	212
04ae3991	213	def_array = container_of(scope, const struct definition_array, p);
9843982d JD	214	if (!def_array)
	215	goto error;
	216	if (def_array->elems->pdata) {
	217	list = (struct definition const const*) def_array->elems->pdata;
	218	*count = def_array->elems->len;
	219	goto end;
	220	} else {
	221	goto error;
	222	}
	223	}
	224	case CTF_TYPE_SEQUENCE:
	225	{
04ae3991	226	const struct definition_sequence *def_sequence;
9843982d	227
04ae3991	228	def_sequence = container_of(scope, const struct definition_sequence, p);
9843982d JD	229	if (!def_sequence)
	230	goto error;
	231	if (def_sequence->elems->pdata) {
	232	list = (struct definition const const*) def_sequence->elems->pdata;
	233	*count = def_sequence->elems->len;
	234	goto end;
	235	} else {
	236	goto error;
	237	}
	238	}
	239	default:
	240	break;
	241	}
	242
	243	end:
	244	return 0;
	245
	246	error:
	247	*list = NULL;
	248	*count = 0;
	249	return -1;
	250	}
	251
c50d2a7a	252	struct bt_context bt_ctf_event_get_context(const struct bt_ctf_event ctf_event)
98a04903 JD	253	{
	254	struct bt_context *ret = NULL;
	255	struct ctf_file_stream *cfs;
98a04903	256	struct ctf_trace *trace;
c50d2a7a	257	struct ctf_event_definition *event = ctf_event->parent;
98a04903 JD	258
	259	cfs = container_of(event->stream, struct ctf_file_stream,
	260	parent);
8b8dc96e	261	trace = cfs->parent.stream_class->trace;
98a04903 JD	262	if (trace->ctx)
	263	ret = trace->ctx;
	264
	265	return ret;
	266	}
	267
c50d2a7a	268	int bt_ctf_event_get_handle_id(const struct bt_ctf_event *ctf_event)
98a04903 JD	269	{
	270	int ret = -1;
	271	struct ctf_file_stream *cfs;
98a04903	272	struct ctf_trace *trace;
c50d2a7a	273	struct ctf_event_definition *event = ctf_event->parent;
98a04903 JD	274
	275	cfs = container_of(event->stream, struct ctf_file_stream,
	276	parent);
8b8dc96e	277	trace = cfs->parent.stream_class->trace;
98a04903 JD	278	if (trace->handle)
	279	ret = trace->handle->id;
	280
	281	return ret;
	282	}
	283
c50d2a7a	284	uint64_t bt_ctf_get_timestamp_raw(const struct bt_ctf_event *ctf_event)
9843982d	285	{
c50d2a7a	286	struct ctf_event_definition *event = ctf_event->parent;
9843982d	287	if (event && event->stream->has_timestamp)
c34ea0fa MD	288	return ctf_get_timestamp_raw(event->stream,
c34ea0fa MD	289	event->stream->timestamp);
9843982d	290	else
57f3005e SJD	291	return -1ULL;
	292	}
	293
c50d2a7a	294	uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event)
57f3005e	295	{
c50d2a7a	296	struct ctf_event_definition *event = ctf_event->parent;
c34ea0fa MD	297	if (event && event->stream->has_timestamp)
	298	return ctf_get_timestamp(event->stream,
	299	event->stream->timestamp);
	300	else
57f3005e	301	return -1ULL;
9843982d JD	302	}
	303
	304	static void bt_ctf_field_set_error(int error)
	305	{
	306	bt_ctf_last_field_error = error;
	307	}
	308
	309	int bt_ctf_field_get_error(void)
	310	{
	311	int ret;
	312	ret = bt_ctf_last_field_error;
	313	bt_ctf_last_field_error = 0;
	314
	315	return ret;
	316	}
	317
8673030f JD	318	int bt_ctf_get_int_signedness(const struct definition *field)
	319	{
	320	int ret;
	321
	322	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	323	ret = get_int_signedness(field);
	324	} else {
	325	ret = -1;
	326	bt_ctf_field_set_error(-EINVAL);
	327	}
	328
	329	return ret;
	330	}
	331
	332	int bt_ctf_get_int_base(const struct definition *field)
	333	{
	334	int ret;
	335
	336	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	337	ret = get_int_base(field);
	338	} else {
	339	ret = -1;
	340	bt_ctf_field_set_error(-EINVAL);
	341	}
	342
	343	return ret;
	344	}
	345
	346	int bt_ctf_get_int_byte_order(const struct definition *field)
	347	{
	348	int ret;
	349
	350	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	351	ret = get_int_byte_order(field);
	352	} else {
	353	ret = -1;
	354	bt_ctf_field_set_error(-EINVAL);
	355	}
	356
	357	return ret;
	358	}
	359
fef0e521 MD	360	ssize_t bt_ctf_get_int_len(const struct definition *field)
	361	{
	362	ssize_t ret;
	363
	364	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	365	ret = (ssize_t) get_int_len(field);
	366	} else {
	367	ret = -1;
	368	bt_ctf_field_set_error(-EINVAL);
	369	}
	370
	371	return ret;
	372	}
	373
8673030f JD	374	enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field)
	375	{
	376	enum ctf_string_encoding ret = 0;
	377
	378	if (!field)
	379	goto end;
	380
	381	if (bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	382	ret = get_int_encoding(field);
	383	else if (bt_ctf_field_type(field) == CTF_TYPE_STRING)
	384	ret = get_string_encoding(field);
	385	else
	386	goto error;
	387
	388	end:
	389	return ret;
	390
	391	error:
	392	bt_ctf_field_set_error(-EINVAL);
	393	return -1;
	394	}
	395
	396	int bt_ctf_get_array_len(const struct definition *field)
	397	{
	398	int ret;
	399
	400	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
	401	ret = get_array_len(field);
	402	} else {
	403	ret = -1;
	404	bt_ctf_field_set_error(-EINVAL);
	405	}
	406
	407	return ret;
	408	}
	409
da320b83	410	uint64_t bt_ctf_get_uint64(const struct definition *field)
9843982d JD	411	{
	412	unsigned int ret = 0;
	413
	414	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	415	ret = get_unsigned_int(field);
	416	else
	417	bt_ctf_field_set_error(-EINVAL);
	418
	419	return ret;
	420	}
	421
da320b83	422	int64_t bt_ctf_get_int64(const struct definition *field)
9843982d JD	423	{
	424	int ret = 0;
	425
	426	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	427	ret = get_signed_int(field);
	428	else
	429	bt_ctf_field_set_error(-EINVAL);
	430
	431	return ret;
	432
	433	}
	434
da320b83	435	char bt_ctf_get_char_array(const struct definition field)
9843982d JD	436	{
	437	char *ret = NULL;
	438
	439	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY)
	440	ret = get_char_array(field)->str;
	441	else
	442	bt_ctf_field_set_error(-EINVAL);
	443
	444	return ret;
	445	}
	446
da320b83	447	char bt_ctf_get_string(const struct definition field)
9843982d JD	448	{
	449	char *ret = NULL;
	450
	451	if (field && bt_ctf_field_type(field) == CTF_TYPE_STRING)
	452	ret = get_string(field);
	453	else
	454	bt_ctf_field_set_error(-EINVAL);
	455
	456	return ret;
	457	}
e003ab50 JD	458
e003ab50 JD	459	int bt_ctf_get_event_decl_list(int handle_id, struct bt_context *ctx,
64c2c249	460	struct bt_ctf_event_decl * const **list,
e003ab50 JD	461	unsigned int *count)
	462	{
	463	struct bt_trace_handle *handle;
	464	struct trace_descriptor *td;
	465	struct ctf_trace *tin;
	466
	467	if (!ctx)
	468	goto error;
	469
	470	handle = g_hash_table_lookup(ctx->trace_handles,
	471	(gpointer) (unsigned long) handle_id);
	472	if (!handle)
	473	goto error;
	474
	475	td = handle->td;
	476	tin = container_of(td, struct ctf_trace, parent);
	477
64c2c249	478	list = (struct bt_ctf_event_decl const*) tin->event_declarations->pdata;
e003ab50 JD	479	*count = tin->event_declarations->len;
	480	return 0;
	481
	482	error:
	483	return -1;
	484	}
	485
	486	const char bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl event)
	487	{
	488	if (!event)
	489	return NULL;
	490	return g_quark_to_string(event->parent.name);
	491	}
64c2c249 JD	492
	493	int bt_ctf_get_decl_fields(struct bt_ctf_event_decl *event_decl,
	494	enum bt_ctf_scope scope,
	495	struct bt_ctf_field_decl const * const **list,
	496	unsigned int *count)
	497	{
	498	int i;
	499	GArray *fields = NULL;
	500	gpointer *ret_list = NULL;
	501	GPtrArray *fields_array = NULL;
	502	int ret = 0;
	503	*count = 0;
	504
	505	switch (scope) {
	506	case BT_EVENT_CONTEXT:
	507	if (event_decl->context_decl) {
	508	ret_list = event_decl->context_decl->pdata;
	509	*count = event_decl->context_decl->len;
	510	goto end;
	511	}
	512	event_decl->context_decl = g_ptr_array_new();
	513	if (!event_decl->parent.context_decl) {
	514	ret = -1;
	515	goto end;
	516	}
	517	fields = event_decl->parent.context_decl->fields;
	518	fields_array = event_decl->context_decl;
	519	break;
	520	case BT_EVENT_FIELDS:
	521	if (event_decl->fields_decl) {
	522	ret_list = event_decl->fields_decl->pdata;
	523	*count = event_decl->fields_decl->len;
	524	goto end;
	525	}
	526	event_decl->fields_decl = g_ptr_array_new();
	527	if (!event_decl->parent.fields_decl) {
	528	ret = -1;
	529	goto end;
	530	}
	531	fields = event_decl->parent.fields_decl->fields;
	532	fields_array = event_decl->fields_decl;
	533	break;
	534	case BT_STREAM_PACKET_CONTEXT:
	535	if (event_decl->packet_context_decl) {
	536	ret_list = event_decl->packet_context_decl->pdata;
	537	*count = event_decl->packet_context_decl->len;
	538	goto end;
	539	}
	540	event_decl->packet_context_decl = g_ptr_array_new();
	541	if (!event_decl->parent.stream->packet_context_decl) {
	542	ret = -1;
	543	goto end;
	544	}
	545	fields = event_decl->parent.stream->packet_context_decl->fields;
	546	fields_array = event_decl->packet_context_decl;
	547	break;
	548	case BT_STREAM_EVENT_CONTEXT:
	549	if (event_decl->event_context_decl) {
	550	ret_list = event_decl->event_context_decl->pdata;
	551	*count = event_decl->event_context_decl->len;
	552	goto end;
	553	}
	554	event_decl->event_context_decl = g_ptr_array_new();
	555	if (!event_decl->parent.stream->event_context_decl) {
556	ret = -1;
557	goto end;
558	}
559	fields = event_decl->parent.stream->event_context_decl->fields;
560	fields_array = event_decl->event_context_decl;
561	break;
562	case BT_STREAM_EVENT_HEADER:
563	if (event_decl->event_header_decl) {
564	ret_list = event_decl->event_header_decl->pdata;
565	*count = event_decl->event_header_decl->len;
566	goto end;
567	}
568	event_decl->event_header_decl = g_ptr_array_new();
569	if (!event_decl->parent.stream->event_header_decl) {
570	ret = -1;
571	goto end;
572	}
573	fields = event_decl->parent.stream->event_header_decl->fields;
574	fields_array = event_decl->event_header_decl;
575	break;
576	case BT_TRACE_PACKET_HEADER:
577	if (event_decl->packet_header_decl) {
578	ret_list = event_decl->packet_header_decl->pdata;
579	*count = event_decl->packet_header_decl->len;
580	goto end;
581	}
582	event_decl->packet_header_decl = g_ptr_array_new();
583	if (!event_decl->parent.stream->trace->packet_header_decl) {
584	ret = -1;
585	goto end;
586	}
587	fields = event_decl->parent.stream->trace->packet_header_decl->fields;
588	fields_array = event_decl->packet_header_decl;
589	break;
590	}
591
592	for (i = 0; i < fields->len; i++) {
593	g_ptr_array_add(fields_array,
594	&g_array_index(fields,
595	struct declaration_field, i));
596	}
597	ret_list = fields_array->pdata;
598	*count = fields->len;
599
600	end:
601	list = (struct bt_ctf_field_decl const const*) ret_list;
602
603	return ret;
604	}
605
606	const char bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl field)
607	{
608	if (field)
609	return rem_(g_quark_to_string(((struct declaration_field *) field)->name));
610	return NULL;
611	}