[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_get_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;

	if (!ctf_event)
		return NULL;

	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 (!ctf_event || !scope || !field)
		return NULL;

	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;
}

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 (!ctf_event || !field)
		return 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;

	if (!ctf_event)
		return NULL;

	event = ctf_event->parent;
	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 NULL;

	return rem_(g_quark_to_string(def->name));
}

enum ctf_type_id bt_ctf_field_type(const struct definition *def)
{
	if (!def)
		return CTF_TYPE_UNKNOWN;

	return def->declaration->id;
}

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)
{
	if (!ctf_event || !scope || !list || !count)
		return -EINVAL;

	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;
		}
		break;
	}
	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;
		}
		break;
	}
	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;
		}
		break;
	}
	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;
		}
		break;
	}
	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;

	if (!ctf_event)
		return NULL;

	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;

	if (!ctf_event)
		return -EINVAL;

	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(const struct bt_ctf_event *ctf_event)
{
	struct ctf_event_definition *event;

	if (!ctf_event)
		return -1ULL;

	event = ctf_event->parent;
	if (event && event->stream->has_timestamp)
		return event->stream->real_timestamp;
	else
		return -1ULL;
}

uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event)
{
	struct ctf_event_definition *event;

	if (!ctf_event)
		return -1ULL;

	event = ctf_event->parent;
	if (event && event->stream->has_timestamp)
		return event->stream->cycles_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 = -EINVAL;
		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 = -EINVAL;
		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 = -EINVAL;
		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 = -EINVAL;
		bt_ctf_field_set_error(-EINVAL);
	}

	return ret;
}

const struct definition *bt_ctf_get_enum_int(const struct definition *field)
{
	struct definition_enum *def_enum;

	if (!field || bt_ctf_field_type(field) != CTF_TYPE_ENUM) {
		bt_ctf_field_set_error(-EINVAL);
		return NULL;
	}
	def_enum = container_of(field, struct definition_enum, p);
	return &def_enum->integer->p;
}

const char *bt_ctf_get_enum_str(const struct definition *field)
{
	struct definition_enum *def_enum;
	struct declaration_enum *decl_enum;
	GArray *array;
	const char *ret;

	if (!field || bt_ctf_field_type(field) != CTF_TYPE_ENUM) {
		bt_ctf_field_set_error(-EINVAL);
		return NULL;
	}
	def_enum = container_of(field, struct definition_enum, p);
	decl_enum = def_enum->declaration;
	if (get_int_signedness(&def_enum->integer->p)) {
		array = enum_int_to_quark_set(decl_enum,
			get_signed_int(&def_enum->integer->p));
	} else {
		array = enum_uint_to_quark_set(decl_enum,
			get_unsigned_int(&def_enum->integer->p));
	}
	if (!array) {
		bt_ctf_field_set_error(-ENOENT);
		return NULL;
	}

	if (array->len == 0) {
		g_array_unref(array);
		bt_ctf_field_set_error(-ENOENT);
		return NULL;
	}	
	/* Return first string. Arbitrary choice. */
	ret = g_quark_to_string(g_array_index(array, GQuark, 0));
	g_array_unref(array);
	return ret;
}

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

	if (!field)
		goto error;

	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;
	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)
{
	uint64_t 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)
{
	int64_t 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;
	GString *char_array;

	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
		char_array = get_char_array(field);
		if (char_array) {
			ret = char_array->str;
			goto end;
		}
	}
	bt_ctf_field_set_error(-EINVAL);

end:
	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 || !list || !count)
		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;

	if (!event_decl || !list || !count)
		return -EINVAL;

	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 NULL;

	return rem_(g_quark_to_string(((struct declaration_field *) field)->name));
}
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
b330165c	37	* bt_ctf_field_get_error only
9843982d JD	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;
7f89ddce	45	struct ctf_event_definition *event;
9843982d	46
7f89ddce MD	47	if (!ctf_event)
	48	return NULL;
	49
	50	event = ctf_event->parent;
9843982d JD	51	switch (scope) {
	52	case BT_TRACE_PACKET_HEADER:
	53	if (!event->stream)
	54	goto error;
	55	if (event->stream->trace_packet_header)
	56	tmp = &event->stream->trace_packet_header->p;
	57	break;
	58	case BT_STREAM_PACKET_CONTEXT:
	59	if (!event->stream)
	60	goto error;
	61	if (event->stream->stream_packet_context)
	62	tmp = &event->stream->stream_packet_context->p;
	63	break;
	64	case BT_STREAM_EVENT_HEADER:
	65	if (!event->stream)
	66	goto error;
	67	if (event->stream->stream_event_header)
	68	tmp = &event->stream->stream_event_header->p;
	69	break;
	70	case BT_STREAM_EVENT_CONTEXT:
	71	if (!event->stream)
	72	goto error;
	73	if (event->stream->stream_event_context)
	74	tmp = &event->stream->stream_event_context->p;
	75	break;
	76	case BT_EVENT_CONTEXT:
8a4722b0 JD	77	if (event->event_context)
8a4722b0 JD	78	tmp = &event->event_context->p;
9843982d JD	79	break;
9843982d JD	80	case BT_EVENT_FIELDS:
8a4722b0 JD	81	if (event->event_fields)
8a4722b0 JD	82	tmp = &event->event_fields->p;
9843982d JD	83	break;
	84	}
	85	return tmp;
	86
	87	error:
	88	return NULL;
	89	}
	90
c50d2a7a	91	const struct definition bt_ctf_get_field(const struct bt_ctf_event ctf_event,
04ae3991	92	const struct definition *scope,
9843982d JD	93	const char *field)
	94	{
	95	struct definition *def;
300d317a	96	char *field_underscore;
9843982d	97
7f89ddce MD	98	if (!ctf_event \|\| !scope \|\| !field)
	99	return NULL;
	100
	101	def = lookup_definition(scope, field);
	102	/*
	103	* optionally a field can have an underscore prefix, try
	104	* to lookup the field with this prefix if it failed
	105	*/
	106	if (!def) {
	107	field_underscore = g_new(char, strlen(field) + 2);
	108	field_underscore[0] = '_';
	109	strcpy(&field_underscore[1], field);
	110	def = lookup_definition(scope, field_underscore);
	111	g_free(field_underscore);
9843982d	112	}
7f89ddce MD	113	if (bt_ctf_field_type(def) == CTF_TYPE_VARIANT) {
	114	struct definition_variant *variant_definition;
	115	variant_definition = container_of(def,
	116	struct definition_variant, p);
	117	return variant_definition->current_field;
	118	}
	119	return def;
9843982d JD	120	}
9843982d JD	121
c50d2a7a	122	const struct definition bt_ctf_get_index(const struct bt_ctf_event ctf_event,
04ae3991	123	const struct definition *field,
9843982d JD	124	unsigned int index)
	125	{
	126	struct definition *ret = NULL;
	127
7f89ddce MD	128	if (!ctf_event \|\| !field)
	129	return NULL;
	130
9843982d JD	131	if (bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
	132	struct definition_array *array_definition;
	133	array_definition = container_of(field,
	134	struct definition_array, p);
	135	ret = array_index(array_definition, index);
	136	} else if (bt_ctf_field_type(field) == CTF_TYPE_SEQUENCE) {
	137	struct definition_sequence *sequence_definition;
	138	sequence_definition = container_of(field,
	139	struct definition_sequence, p);
	140	ret = sequence_index(sequence_definition, index);
	141	}
	142	return ret;
	143	}
	144
c50d2a7a	145	const char bt_ctf_event_name(const struct bt_ctf_event ctf_event)
9843982d	146	{
4716614a	147	struct ctf_event_declaration *event_class;
f380e105	148	struct ctf_stream_declaration *stream_class;
7f89ddce	149	struct ctf_event_definition *event;
9843982d	150
7f89ddce	151	if (!ctf_event)
9843982d	152	return NULL;
7f89ddce MD	153
7f89ddce MD	154	event = ctf_event->parent;
9843982d JD	155	stream_class = event->stream->stream_class;
	156	event_class = g_ptr_array_index(stream_class->events_by_id,
	157	event->stream->event_id);
	158	return g_quark_to_string(event_class->name);
	159	}
	160
	161	const char bt_ctf_field_name(const struct definition def)
	162	{
7f89ddce MD	163	if (!def)
	164	return NULL;
	165
	166	return rem_(g_quark_to_string(def->name));
9843982d JD	167	}
9843982d JD	168
da320b83	169	enum ctf_type_id bt_ctf_field_type(const struct definition *def)
9843982d	170	{
7f89ddce MD	171	if (!def)
	172	return CTF_TYPE_UNKNOWN;
	173
	174	return def->declaration->id;
9843982d JD	175	}
9843982d JD	176
c50d2a7a	177	int bt_ctf_get_field_list(const struct bt_ctf_event *ctf_event,
04ae3991	178	const struct definition *scope,
9843982d JD	179	struct definition const * const **list,
	180	unsigned int *count)
	181	{
7f89ddce MD	182	if (!ctf_event \|\| !scope \|\| !list \|\| !count)
	183	return -EINVAL;
	184
9843982d JD	185	switch (bt_ctf_field_type(scope)) {
	186	case CTF_TYPE_INTEGER:
	187	case CTF_TYPE_FLOAT:
	188	case CTF_TYPE_STRING:
	189	case CTF_TYPE_ENUM:
	190	goto error;
	191	case CTF_TYPE_STRUCT:
	192	{
04ae3991	193	const struct definition_struct *def_struct;
9843982d	194
04ae3991	195	def_struct = container_of(scope, const struct definition_struct, p);
9843982d JD	196	if (!def_struct)
	197	goto error;
	198	if (def_struct->fields->pdata) {
	199	list = (struct definition const const*) def_struct->fields->pdata;
	200	*count = def_struct->fields->len;
	201	goto end;
	202	} else {
	203	goto error;
	204	}
7f89ddce	205	break;
9843982d JD	206	}
	207	case CTF_TYPE_UNTAGGED_VARIANT:
	208	goto error;
	209	case CTF_TYPE_VARIANT:
	210	{
04ae3991	211	const struct definition_variant *def_variant;
9843982d	212
04ae3991	213	def_variant = container_of(scope, const struct definition_variant, p);
9843982d JD	214	if (!def_variant)
	215	goto error;
	216	if (def_variant->fields->pdata) {
	217	list = (struct definition const const*) def_variant->fields->pdata;
	218	*count = def_variant->fields->len;
	219	goto end;
	220	} else {
	221	goto error;
	222	}
7f89ddce	223	break;
9843982d JD	224	}
	225	case CTF_TYPE_ARRAY:
	226	{
04ae3991	227	const struct definition_array *def_array;
9843982d	228
04ae3991	229	def_array = container_of(scope, const struct definition_array, p);
9843982d JD	230	if (!def_array)
	231	goto error;
	232	if (def_array->elems->pdata) {
	233	list = (struct definition const const*) def_array->elems->pdata;
	234	*count = def_array->elems->len;
	235	goto end;
	236	} else {
	237	goto error;
	238	}
7f89ddce	239	break;
9843982d JD	240	}
	241	case CTF_TYPE_SEQUENCE:
	242	{
04ae3991	243	const struct definition_sequence *def_sequence;
9843982d	244
04ae3991	245	def_sequence = container_of(scope, const struct definition_sequence, p);
9843982d JD	246	if (!def_sequence)
	247	goto error;
	248	if (def_sequence->elems->pdata) {
	249	list = (struct definition const const*) def_sequence->elems->pdata;
	250	*count = def_sequence->elems->len;
	251	goto end;
	252	} else {
	253	goto error;
	254	}
7f89ddce	255	break;
9843982d JD	256	}
	257	default:
	258	break;
	259	}
	260
	261	end:
	262	return 0;
	263
	264	error:
	265	*list = NULL;
	266	*count = 0;
	267	return -1;
	268	}
	269
c50d2a7a	270	struct bt_context bt_ctf_event_get_context(const struct bt_ctf_event ctf_event)
98a04903 JD	271	{
	272	struct bt_context *ret = NULL;
	273	struct ctf_file_stream *cfs;
98a04903	274	struct ctf_trace *trace;
7f89ddce	275	struct ctf_event_definition *event;
98a04903	276
7f89ddce MD	277	if (!ctf_event)
	278	return NULL;
	279
	280	event = ctf_event->parent;
98a04903 JD	281	cfs = container_of(event->stream, struct ctf_file_stream,
98a04903 JD	282	parent);
8b8dc96e	283	trace = cfs->parent.stream_class->trace;
98a04903 JD	284	if (trace->ctx)
	285	ret = trace->ctx;
	286
	287	return ret;
	288	}
	289
c50d2a7a	290	int bt_ctf_event_get_handle_id(const struct bt_ctf_event *ctf_event)
98a04903 JD	291	{
	292	int ret = -1;
	293	struct ctf_file_stream *cfs;
98a04903	294	struct ctf_trace *trace;
7f89ddce MD	295	struct ctf_event_definition *event;
	296
	297	if (!ctf_event)
	298	return -EINVAL;
98a04903	299
7f89ddce	300	event = ctf_event->parent;
98a04903 JD	301	cfs = container_of(event->stream, struct ctf_file_stream,
98a04903 JD	302	parent);
8b8dc96e	303	trace = cfs->parent.stream_class->trace;
98a04903 JD	304	if (trace->handle)
	305	ret = trace->handle->id;
	306
	307	return ret;
	308	}
	309
d40ee8ec	310	uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event)
9843982d	311	{
7f89ddce MD	312	struct ctf_event_definition *event;
	313
	314	if (!ctf_event)
	315	return -1ULL;
	316
	317	event = ctf_event->parent;
9843982d	318	if (event && event->stream->has_timestamp)
03798a93	319	return event->stream->real_timestamp;
9843982d	320	else
57f3005e SJD	321	return -1ULL;
	322	}
	323
d40ee8ec	324	uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event)
57f3005e	325	{
7f89ddce MD	326	struct ctf_event_definition *event;
	327
	328	if (!ctf_event)
	329	return -1ULL;
	330
	331	event = ctf_event->parent;
c34ea0fa	332	if (event && event->stream->has_timestamp)
03798a93	333	return event->stream->cycles_timestamp;
c34ea0fa	334	else
57f3005e	335	return -1ULL;
9843982d JD	336	}
	337
	338	static void bt_ctf_field_set_error(int error)
	339	{
	340	bt_ctf_last_field_error = error;
	341	}
	342
	343	int bt_ctf_field_get_error(void)
	344	{
	345	int ret;
	346	ret = bt_ctf_last_field_error;
	347	bt_ctf_last_field_error = 0;
	348
	349	return ret;
	350	}
	351
8673030f JD	352	int bt_ctf_get_int_signedness(const struct definition *field)
	353	{
	354	int ret;
	355
	356	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	357	ret = get_int_signedness(field);
	358	} else {
7f89ddce	359	ret = -EINVAL;
8673030f JD	360	bt_ctf_field_set_error(-EINVAL);
	361	}
	362
	363	return ret;
	364	}
	365
	366	int bt_ctf_get_int_base(const struct definition *field)
	367	{
	368	int ret;
	369
	370	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	371	ret = get_int_base(field);
	372	} else {
7f89ddce	373	ret = -EINVAL;
8673030f JD	374	bt_ctf_field_set_error(-EINVAL);
	375	}
	376
	377	return ret;
	378	}
	379
	380	int bt_ctf_get_int_byte_order(const struct definition *field)
	381	{
	382	int ret;
	383
	384	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	385	ret = get_int_byte_order(field);
	386	} else {
7f89ddce	387	ret = -EINVAL;
8673030f JD	388	bt_ctf_field_set_error(-EINVAL);
	389	}
	390
	391	return ret;
	392	}
	393
fef0e521 MD	394	ssize_t bt_ctf_get_int_len(const struct definition *field)
	395	{
	396	ssize_t ret;
	397
	398	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
	399	ret = (ssize_t) get_int_len(field);
	400	} else {
7f89ddce	401	ret = -EINVAL;
fef0e521 MD	402	bt_ctf_field_set_error(-EINVAL);
	403	}
	404
	405	return ret;
	406	}
	407
4d25c350 MD	408	const struct definition bt_ctf_get_enum_int(const struct definition field)
	409	{
	410	struct definition_enum *def_enum;
	411
	412	if (!field \|\| bt_ctf_field_type(field) != CTF_TYPE_ENUM) {
	413	bt_ctf_field_set_error(-EINVAL);
	414	return NULL;
	415	}
	416	def_enum = container_of(field, struct definition_enum, p);
	417	return &def_enum->integer->p;
	418	}
	419
	420	const char bt_ctf_get_enum_str(const struct definition field)
	421	{
	422	struct definition_enum *def_enum;
	423	struct declaration_enum *decl_enum;
	424	GArray *array;
	425	const char *ret;
	426
	427	if (!field \|\| bt_ctf_field_type(field) != CTF_TYPE_ENUM) {
	428	bt_ctf_field_set_error(-EINVAL);
	429	return NULL;
	430	}
	431	def_enum = container_of(field, struct definition_enum, p);
	432	decl_enum = def_enum->declaration;
	433	if (get_int_signedness(&def_enum->integer->p)) {
	434	array = enum_int_to_quark_set(decl_enum,
	435	get_signed_int(&def_enum->integer->p));
	436	} else {
	437	array = enum_uint_to_quark_set(decl_enum,
	438	get_unsigned_int(&def_enum->integer->p));
	439	}
	440	if (!array) {
	441	bt_ctf_field_set_error(-ENOENT);
	442	return NULL;
	443	}
	444
	445	if (array->len == 0) {
	446	g_array_unref(array);
	447	bt_ctf_field_set_error(-ENOENT);
	448	return NULL;
	449	}
	450	/* Return first string. Arbitrary choice. */
	451	ret = g_quark_to_string(g_array_index(array, GQuark, 0));
	452	g_array_unref(array);
	453	return ret;
	454	}
	455
8673030f JD	456	enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field)
	457	{
	458	enum ctf_string_encoding ret = 0;
	459
	460	if (!field)
7f89ddce	461	goto error;
8673030f JD	462
	463	if (bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	464	ret = get_int_encoding(field);
	465	else if (bt_ctf_field_type(field) == CTF_TYPE_STRING)
	466	ret = get_string_encoding(field);
	467	else
	468	goto error;
8673030f JD	469	return ret;
	470
	471	error:
	472	bt_ctf_field_set_error(-EINVAL);
	473	return -1;
	474	}
	475
	476	int bt_ctf_get_array_len(const struct definition *field)
	477	{
	478	int ret;
	479
	480	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
	481	ret = get_array_len(field);
	482	} else {
	483	ret = -1;
	484	bt_ctf_field_set_error(-EINVAL);
	485	}
	486
	487	return ret;
	488	}
	489
da320b83	490	uint64_t bt_ctf_get_uint64(const struct definition *field)
9843982d	491	{
63dd3817	492	uint64_t ret = 0;
9843982d JD	493
	494	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	495	ret = get_unsigned_int(field);
	496	else
	497	bt_ctf_field_set_error(-EINVAL);
	498
	499	return ret;
	500	}
	501
da320b83	502	int64_t bt_ctf_get_int64(const struct definition *field)
9843982d	503	{
63dd3817	504	int64_t ret = 0;
9843982d JD	505
	506	if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
	507	ret = get_signed_int(field);
	508	else
	509	bt_ctf_field_set_error(-EINVAL);
	510
	511	return ret;
	512
	513	}
	514
da320b83	515	char bt_ctf_get_char_array(const struct definition field)
9843982d JD	516	{
9843982d JD	517	char *ret = NULL;
885885bf	518	GString *char_array;
9843982d	519
885885bf JD	520	if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
	521	char_array = get_char_array(field);
	522	if (char_array) {
	523	ret = char_array->str;
	524	goto end;
	525	}
	526	}
	527	bt_ctf_field_set_error(-EINVAL);
9843982d	528
885885bf	529	end:
9843982d JD	530	return ret;
	531	}
	532
da320b83	533	char bt_ctf_get_string(const struct definition field)
9843982d JD	534	{
	535	char *ret = NULL;
	536
	537	if (field && bt_ctf_field_type(field) == CTF_TYPE_STRING)
	538	ret = get_string(field);
	539	else
	540	bt_ctf_field_set_error(-EINVAL);
	541
	542	return ret;
	543	}
e003ab50 JD	544
e003ab50 JD	545	int bt_ctf_get_event_decl_list(int handle_id, struct bt_context *ctx,
64c2c249	546	struct bt_ctf_event_decl * const **list,
e003ab50 JD	547	unsigned int *count)
	548	{
	549	struct bt_trace_handle *handle;
	550	struct trace_descriptor *td;
	551	struct ctf_trace *tin;
	552
7f89ddce	553	if (!ctx \|\| !list \|\| !count)
e003ab50 JD	554	goto error;
	555
	556	handle = g_hash_table_lookup(ctx->trace_handles,
	557	(gpointer) (unsigned long) handle_id);
	558	if (!handle)
	559	goto error;
	560
	561	td = handle->td;
	562	tin = container_of(td, struct ctf_trace, parent);
	563
64c2c249	564	list = (struct bt_ctf_event_decl const*) tin->event_declarations->pdata;
e003ab50 JD	565	*count = tin->event_declarations->len;
	566	return 0;
	567
	568	error:
	569	return -1;
	570	}
	571
	572	const char bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl event)
	573	{
	574	if (!event)
	575	return NULL;
7f89ddce	576
e003ab50 JD	577	return g_quark_to_string(event->parent.name);
e003ab50 JD	578	}
64c2c249 JD	579
	580	int bt_ctf_get_decl_fields(struct bt_ctf_event_decl *event_decl,
	581	enum bt_ctf_scope scope,
	582	struct bt_ctf_field_decl const * const **list,
	583	unsigned int *count)
	584	{
	585	int i;
	586	GArray *fields = NULL;
	587	gpointer *ret_list = NULL;
	588	GPtrArray *fields_array = NULL;
	589	int ret = 0;
	590	*count = 0;
	591
7f89ddce MD	592	if (!event_decl \|\| !list \|\| !count)
	593	return -EINVAL;
	594
64c2c249 JD	595	switch (scope) {
	596	case BT_EVENT_CONTEXT:
	597	if (event_decl->context_decl) {
	598	ret_list = event_decl->context_decl->pdata;
	599	*count = event_decl->context_decl->len;
	600	goto end;
	601	}
	602	event_decl->context_decl = g_ptr_array_new();
	603	if (!event_decl->parent.context_decl) {
	604	ret = -1;
	605	goto end;
	606	}
	607	fields = event_decl->parent.context_decl->fields;
	608	fields_array = event_decl->context_decl;
	609	break;
	610	case BT_EVENT_FIELDS:
	611	if (event_decl->fields_decl) {
	612	ret_list = event_decl->fields_decl->pdata;
	613	*count = event_decl->fields_decl->len;
	614	goto end;
	615	}
	616	event_decl->fields_decl = g_ptr_array_new();
	617	if (!event_decl->parent.fields_decl) {
	618	ret = -1;
	619	goto end;
	620	}
	621	fields = event_decl->parent.fields_decl->fields;
	622	fields_array = event_decl->fields_decl;
	623	break;
	624	case BT_STREAM_PACKET_CONTEXT:
	625	if (event_decl->packet_context_decl) {
	626	ret_list = event_decl->packet_context_decl->pdata;
	627	*count = event_decl->packet_context_decl->len;
	628	goto end;
	629	}
	630	event_decl->packet_context_decl = g_ptr_array_new();
	631	if (!event_decl->parent.stream->packet_context_decl) {
	632	ret = -1;
	633	goto end;
	634	}
	635	fields = event_decl->parent.stream->packet_context_decl->fields;
	636	fields_array = event_decl->packet_context_decl;
	637	break;
	638	case BT_STREAM_EVENT_CONTEXT:
	639	if (event_decl->event_context_decl) {
	640	ret_list = event_decl->event_context_decl->pdata;
	641	*count = event_decl->event_context_decl->len;
	642	goto end;
	643	}
	644	event_decl->event_context_decl = g_ptr_array_new();
	645	if (!event_decl->parent.stream->event_context_decl) {
	646	ret = -1;
	647	goto end;
	648	}
	649	fields = event_decl->parent.stream->event_context_decl->fields;
	650	fields_array = event_decl->event_context_decl;
	651	break;
	652	case BT_STREAM_EVENT_HEADER:
	653	if (event_decl->event_header_decl) {
	654	ret_list = event_decl->event_header_decl->pdata;
	655	*count = event_decl->event_header_decl->len;
	656	goto end;
	657	}
	658	event_decl->event_header_decl = g_ptr_array_new();
659	if (!event_decl->parent.stream->event_header_decl) {
660	ret = -1;
661	goto end;
662	}
663	fields = event_decl->parent.stream->event_header_decl->fields;
664	fields_array = event_decl->event_header_decl;
665	break;
666	case BT_TRACE_PACKET_HEADER:
667	if (event_decl->packet_header_decl) {
668	ret_list = event_decl->packet_header_decl->pdata;
669	*count = event_decl->packet_header_decl->len;
670	goto end;
671	}
672	event_decl->packet_header_decl = g_ptr_array_new();
673	if (!event_decl->parent.stream->trace->packet_header_decl) {
674	ret = -1;
675	goto end;
676	}
677	fields = event_decl->parent.stream->trace->packet_header_decl->fields;
678	fields_array = event_decl->packet_header_decl;
679	break;
680	}
681
682	for (i = 0; i < fields->len; i++) {
683	g_ptr_array_add(fields_array,
684	&g_array_index(fields,
685	struct declaration_field, i));
686	}
687	ret_list = fields_array->pdata;
688	*count = fields->len;
689
690	end:
691	list = (struct bt_ctf_field_decl const const*) ret_list;
692
693	return ret;
694	}
695
696	const char bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl field)
697	{
7f89ddce MD	698	if (!field)
	699	return NULL;
	700
	701	return rem_(g_quark_to_string(((struct declaration_field *) field)->name));
64c2c249	702	}