[babeltrace.git] / src / plugins / ctf / common / metadata / ctf-meta-update-value-storing-indexes.c

/*
 * Copyright 2018 - Philippe Proulx <pproulx@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 <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include "common/assert.h"
#include <glib.h>
#include <stdint.h>
#include <string.h>
#include <inttypes.h>

#include "ctf-meta-visitors.h"

static
int update_field_class_stored_value_index(struct ctf_field_class *fc,
		struct ctf_trace_class *tc,
		struct ctf_stream_class *sc,
		struct ctf_event_class *ec)
{
	int ret = 0;
	uint64_t i;
	struct ctf_field_path *field_path = NULL;
	struct ctf_field_class_int *tgt_fc = NULL;
	uint64_t *stored_value_index = NULL;

	if (!fc) {
		goto end;
	}

	switch (fc->type) {
	case CTF_FIELD_CLASS_TYPE_VARIANT:
	{
		struct ctf_field_class_variant *var_fc = (void *) fc;

		field_path = &var_fc->tag_path;
		stored_value_index = &var_fc->stored_tag_index;
		tgt_fc = (void *) var_fc->tag_fc;
		break;
	}
	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
	{
		struct ctf_field_class_sequence *seq_fc = (void *) fc;

		field_path = &seq_fc->length_path;
		stored_value_index = &seq_fc->stored_length_index;
		tgt_fc = seq_fc->length_fc;
		break;
	}
	default:
		break;
	}

	if (field_path) {
		BT_ASSERT(tgt_fc);
		BT_ASSERT(tgt_fc->base.base.type == CTF_FIELD_CLASS_TYPE_INT ||
			tgt_fc->base.base.type == CTF_FIELD_CLASS_TYPE_ENUM);
		if (tgt_fc->storing_index >= 0) {
			/* Already storing its value */
			*stored_value_index = (uint64_t) tgt_fc->storing_index;
		} else {
			/* Not storing its value: allocate new index */
			tgt_fc->storing_index = tc->stored_value_count;
			*stored_value_index = (uint64_t) tgt_fc->storing_index;
			tc->stored_value_count++;
		}
	}

	switch (fc->type) {
	case CTF_FIELD_CLASS_TYPE_STRUCT:
	{
		struct ctf_field_class_struct *struct_fc = (void *) fc;

		for (i = 0; i < struct_fc->members->len; i++) {
			struct ctf_named_field_class *named_fc =
				ctf_field_class_struct_borrow_member_by_index(
					struct_fc, i);

			ret = update_field_class_stored_value_index(named_fc->fc,
				tc, sc, ec);
			if (ret) {
				goto end;
			}
		}

		break;
	}
	case CTF_FIELD_CLASS_TYPE_VARIANT:
	{
		struct ctf_field_class_variant *var_fc = (void *) fc;

		for (i = 0; i < var_fc->options->len; i++) {
			struct ctf_named_field_class *named_fc =
				ctf_field_class_variant_borrow_option_by_index(
					var_fc, i);

			ret = update_field_class_stored_value_index(named_fc->fc,
				tc, sc, ec);
			if (ret) {
				goto end;
			}
		}

		break;
	}
	case CTF_FIELD_CLASS_TYPE_ARRAY:
	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
	{
		struct ctf_field_class_array_base *array_fc = (void *) fc;

		ret = update_field_class_stored_value_index(array_fc->elem_fc,
			tc, sc, ec);
		if (ret) {
			goto end;
		}

		break;
	}
	default:
		break;
	}

end:
	return ret;
}

BT_HIDDEN
int ctf_trace_class_update_value_storing_indexes(struct ctf_trace_class *ctf_tc)
{
	uint64_t i;

	if (!ctf_tc->is_translated) {
		update_field_class_stored_value_index(
			ctf_tc->packet_header_fc, ctf_tc, NULL, NULL);
	}

	for (i = 0; i < ctf_tc->stream_classes->len; i++) {
		uint64_t j;
		struct ctf_stream_class *sc = ctf_tc->stream_classes->pdata[i];

		if (!sc->is_translated) {
			update_field_class_stored_value_index(sc->packet_context_fc,
				ctf_tc, sc, NULL);
			update_field_class_stored_value_index(sc->event_header_fc,
				ctf_tc, sc, NULL);
			update_field_class_stored_value_index(
				sc->event_common_context_fc, ctf_tc, sc, NULL);
		}

		for (j = 0; j < sc->event_classes->len; j++) {
			struct ctf_event_class *ec =
				sc->event_classes->pdata[j];

			if (!ec->is_translated) {
				update_field_class_stored_value_index(
					ec->spec_context_fc, ctf_tc, sc, ec);
				update_field_class_stored_value_index(
					ec->payload_fc, ctf_tc, sc, ec);
			}
		}
	}

	return 0;
}
Commit	Line	Data
44c440bc PP	1	/*
	2	* Copyright 2018 - Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*/
	14
3fadfbc0	15	#include <babeltrace2/babeltrace.h>
91d81473	16	#include "common/macros.h"
578e048b	17	#include "common/assert.h"
44c440bc PP	18	#include <glib.h>
	19	#include <stdint.h>
	20	#include <string.h>
	21	#include <inttypes.h>
	22
	23	#include "ctf-meta-visitors.h"
	24
	25	static
5cd6d0e5	26	int update_field_class_stored_value_index(struct ctf_field_class *fc,
44c440bc PP	27	struct ctf_trace_class *tc,
	28	struct ctf_stream_class *sc,
	29	struct ctf_event_class *ec)
	30	{
	31	int ret = 0;
	32	uint64_t i;
	33	struct ctf_field_path *field_path = NULL;
5cd6d0e5	34	struct ctf_field_class_int *tgt_fc = NULL;
44c440bc PP	35	uint64_t *stored_value_index = NULL;
44c440bc PP	36
5cd6d0e5	37	if (!fc) {
44c440bc PP	38	goto end;
	39	}
	40
864cad70 PP	41	switch (fc->type) {
864cad70 PP	42	case CTF_FIELD_CLASS_TYPE_VARIANT:
44c440bc	43	{
5cd6d0e5	44	struct ctf_field_class_variant var_fc = (void ) fc;
44c440bc	45
5cd6d0e5 PP	46	field_path = &var_fc->tag_path;
	47	stored_value_index = &var_fc->stored_tag_index;
	48	tgt_fc = (void *) var_fc->tag_fc;
44c440bc PP	49	break;
44c440bc PP	50	}
864cad70	51	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
44c440bc	52	{
5cd6d0e5	53	struct ctf_field_class_sequence seq_fc = (void ) fc;
44c440bc	54
5cd6d0e5 PP	55	field_path = &seq_fc->length_path;
	56	stored_value_index = &seq_fc->stored_length_index;
	57	tgt_fc = seq_fc->length_fc;
44c440bc PP	58	break;
	59	}
	60	default:
	61	break;
	62	}
	63
	64	if (field_path) {
5cd6d0e5	65	BT_ASSERT(tgt_fc);
864cad70 PP	66	BT_ASSERT(tgt_fc->base.base.type == CTF_FIELD_CLASS_TYPE_INT \|\|
864cad70 PP	67	tgt_fc->base.base.type == CTF_FIELD_CLASS_TYPE_ENUM);
5cd6d0e5	68	if (tgt_fc->storing_index >= 0) {
44c440bc	69	/* Already storing its value */
5cd6d0e5	70	*stored_value_index = (uint64_t) tgt_fc->storing_index;
44c440bc PP	71	} else {
44c440bc PP	72	/* Not storing its value: allocate new index */
5cd6d0e5 PP	73	tgt_fc->storing_index = tc->stored_value_count;
5cd6d0e5 PP	74	*stored_value_index = (uint64_t) tgt_fc->storing_index;
44c440bc PP	75	tc->stored_value_count++;
	76	}
	77	}
	78
864cad70 PP	79	switch (fc->type) {
864cad70 PP	80	case CTF_FIELD_CLASS_TYPE_STRUCT:
44c440bc	81	{
5cd6d0e5	82	struct ctf_field_class_struct struct_fc = (void ) fc;
44c440bc	83
5cd6d0e5 PP	84	for (i = 0; i < struct_fc->members->len; i++) {
	85	struct ctf_named_field_class *named_fc =
	86	ctf_field_class_struct_borrow_member_by_index(
	87	struct_fc, i);
44c440bc	88
5cd6d0e5	89	ret = update_field_class_stored_value_index(named_fc->fc,
44c440bc PP	90	tc, sc, ec);
	91	if (ret) {
	92	goto end;
	93	}
	94	}
	95
	96	break;
	97	}
864cad70	98	case CTF_FIELD_CLASS_TYPE_VARIANT:
44c440bc	99	{
5cd6d0e5	100	struct ctf_field_class_variant var_fc = (void ) fc;
44c440bc	101
5cd6d0e5 PP	102	for (i = 0; i < var_fc->options->len; i++) {
	103	struct ctf_named_field_class *named_fc =
	104	ctf_field_class_variant_borrow_option_by_index(
	105	var_fc, i);
44c440bc	106
5cd6d0e5	107	ret = update_field_class_stored_value_index(named_fc->fc,
44c440bc PP	108	tc, sc, ec);
	109	if (ret) {
	110	goto end;
	111	}
	112	}
	113
	114	break;
	115	}
864cad70 PP	116	case CTF_FIELD_CLASS_TYPE_ARRAY:
864cad70 PP	117	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
44c440bc	118	{
5cd6d0e5	119	struct ctf_field_class_array_base array_fc = (void ) fc;
44c440bc	120
5cd6d0e5	121	ret = update_field_class_stored_value_index(array_fc->elem_fc,
44c440bc PP	122	tc, sc, ec);
	123	if (ret) {
	124	goto end;
	125	}
	126
	127	break;
	128	}
	129	default:
	130	break;
	131	}
	132
	133	end:
	134	return ret;
	135	}
	136
	137	BT_HIDDEN
	138	int ctf_trace_class_update_value_storing_indexes(struct ctf_trace_class *ctf_tc)
	139	{
	140	uint64_t i;
	141
	142	if (!ctf_tc->is_translated) {
5cd6d0e5 PP	143	update_field_class_stored_value_index(
5cd6d0e5 PP	144	ctf_tc->packet_header_fc, ctf_tc, NULL, NULL);
44c440bc PP	145	}
	146
	147	for (i = 0; i < ctf_tc->stream_classes->len; i++) {
	148	uint64_t j;
	149	struct ctf_stream_class *sc = ctf_tc->stream_classes->pdata[i];
	150
	151	if (!sc->is_translated) {
5cd6d0e5	152	update_field_class_stored_value_index(sc->packet_context_fc,
44c440bc	153	ctf_tc, sc, NULL);
5cd6d0e5	154	update_field_class_stored_value_index(sc->event_header_fc,
44c440bc	155	ctf_tc, sc, NULL);
5cd6d0e5 PP	156	update_field_class_stored_value_index(
5cd6d0e5 PP	157	sc->event_common_context_fc, ctf_tc, sc, NULL);
44c440bc PP	158	}
	159
	160	for (j = 0; j < sc->event_classes->len; j++) {
	161	struct ctf_event_class *ec =
	162	sc->event_classes->pdata[j];
	163
	164	if (!ec->is_translated) {
5cd6d0e5 PP	165	update_field_class_stored_value_index(
	166	ec->spec_context_fc, ctf_tc, sc, ec);
	167	update_field_class_stored_value_index(
	168	ec->payload_fc, ctf_tc, sc, ec);
44c440bc PP	169	}
	170	}
	171	}
	172
	173	return 0;
	174	}