[lttng-tools.git] / src / bin / lttng-sessiond / ust-field-utils.c

/*
 * Copyright (C) 2018 Francis Deslauriers <francis.deslauriers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <stdbool.h>
#include <string.h>

#include "ust-field-utils.h"

/*
 * The ustctl_field is made of a combination of C basic types
 * ustctl_basic_type and _ustctl_basic_type.
 *
 * ustctl_basic_type contains an enumeration describing the abstract type.
 * _ustctl_basic_type does _NOT_ contain an enumeration describing the
 * abstract type.
 *
 * A layer is needed to use the same code for both structures.
 * When dealing with _ustctl_basic_type, we need to use the abstract type of
 * the ustctl_type struct.
 */

/*
 * Compare two ustctl_integer_type fields.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_integer(const struct ustctl_integer_type *first,
			const struct ustctl_integer_type *second)
{
	if (first->size != second->size) {
		goto no_match;
	}
	if (first->alignment != second->alignment) {
		goto no_match;
	}
	if (first->signedness != second->signedness) {
		goto no_match;
	}
	if (first->encoding != second->encoding) {
		goto no_match;
	}
	if (first->base != second->base) {
		goto no_match;
	}
	if (first->reverse_byte_order != second->reverse_byte_order) {
		goto no_match;
	}

	return true;

no_match:
	return false;
}

/*
 * Compare two _ustctl_basic_type fields known to be of type integer.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_integer_from_raw_basic_type(
			const union _ustctl_basic_type *first,
			const union _ustctl_basic_type *second)
{
	return match_ustctl_field_integer(&first->integer, &second->integer);
}

/*
 * Compare two _ustctl_basic_type fields known to be of type enum.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_enum_from_raw_basic_type(
		const union _ustctl_basic_type *first,
		const union _ustctl_basic_type *second)
{
	/*
	 * Compare enumeration ID. Enumeration ID is provided to the application by
	 * the session daemon before event registration.
	 */
	if (first->enumeration.id != second->enumeration.id) {
		goto no_match;
	}

	/*
	 * Sanity check of the name and container type. Those were already checked
	 * during enum registration.
	 */
	if (strncmp(first->enumeration.name, second->enumeration.name,
				LTTNG_UST_SYM_NAME_LEN)) {
		goto no_match;
	}
	if (!match_ustctl_field_integer(&first->enumeration.container_type,
				&second->enumeration.container_type)) {
		goto no_match;
	}

	return true;

no_match:
	return false;
}

/*
 * Compare two _ustctl_basic_type fields known to be of type string.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_string_from_raw_basic_type(
		const union _ustctl_basic_type *first,
		const union _ustctl_basic_type *second)
{
	return first->string.encoding == second->string.encoding;
}

/*
 * Compare two _ustctl_basic_type fields known to be of type float.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_float_from_raw_basic_type(
		const union _ustctl_basic_type *first,
		const union _ustctl_basic_type *second)
{
	if (first->_float.exp_dig != second->_float.exp_dig) {
		goto no_match;
	}

	if (first->_float.mant_dig != second->_float.mant_dig) {
		goto no_match;
	}

	if (first->_float.reverse_byte_order !=
			second->_float.reverse_byte_order) {
		goto no_match;
	}

	if (first->_float.alignment != second->_float.alignment) {
		goto no_match;
	}

	return true;

no_match:
	return false;
}

/*
 * Compare two _ustctl_basic_type fields given their respective abstract types.
 * Returns 1 if both are identical.
 */
static bool match_ustctl_field_raw_basic_type(
		enum ustctl_abstract_types first_atype,
		const union _ustctl_basic_type *first,
		enum ustctl_abstract_types second_atype,
		const union _ustctl_basic_type *second)
{
	if (first_atype != second_atype) {
		goto no_match;
	}

	switch (first_atype) {
	case ustctl_atype_integer:
		if (!match_ustctl_field_integer_from_raw_basic_type(first, second)) {
			goto no_match;
		}
		break;
	case ustctl_atype_enum:
		if (!match_ustctl_field_enum_from_raw_basic_type(first, second)) {
			goto no_match;
		}
		break;
	case ustctl_atype_string:
		if (!match_ustctl_field_string_from_raw_basic_type(first, second)) {
			goto no_match;
		}
		break;
	case ustctl_atype_float:
		if (!match_ustctl_field_float_from_raw_basic_type(first, second)) {
			goto no_match;
		}
		break;
	default:
		goto no_match;
	}

	return true;

no_match:
	return false;
}

/*
 * Compatibility layer between the ustctl_basic_type struct and
 * _ustctl_basic_type union.
 */
static bool match_ustctl_field_basic_type(const struct ustctl_basic_type *first,
		const struct ustctl_basic_type *second)
{
	return match_ustctl_field_raw_basic_type(first->atype, &first->u.basic,
				second->atype, &second->u.basic);
}

int match_ustctl_field(const struct ustctl_field *first,
		const struct ustctl_field *second)
{
	/* Check the name of the field is identical. */
	if (strncmp(first->name, second->name, LTTNG_UST_SYM_NAME_LEN)) {
		goto no_match;
	}

	/* Check the field type is identical. */
	if (first->type.atype != second->type.atype) {
		goto no_match;
	}

	/* Check the field layout. */
	switch (first->type.atype) {
	case ustctl_atype_integer:
	case ustctl_atype_enum:
	case ustctl_atype_string:
	case ustctl_atype_float:
		if (!match_ustctl_field_raw_basic_type(first->type.atype,
					&first->type.u.legacy.basic, second->type.atype,
					&second->type.u.legacy.basic)) {
			goto no_match;
		}
		break;
	case ustctl_atype_sequence:
		/* Match element type of the sequence. */
		if (!match_ustctl_field_basic_type(&first->type.u.legacy.sequence.elem_type,
					&second->type.u.legacy.sequence.elem_type)) {
			goto no_match;
		}

		/* Match length type of the sequence. */
		if (!match_ustctl_field_basic_type(&first->type.u.legacy.sequence.length_type,
					&second->type.u.legacy.sequence.length_type)) {
			goto no_match;
		}
		break;
	case ustctl_atype_array:
		/* Match element type of the array. */
		if (!match_ustctl_field_basic_type(&first->type.u.legacy.array.elem_type,
					&second->type.u.legacy.array.elem_type)) {
			goto no_match;
		}

		/* Match length of the array. */
		if (first->type.u.legacy.array.length != second->type.u.legacy.array.length) {
			goto no_match;
		}
		break;
	case ustctl_atype_variant:
		/* Compare number of choice of the variants. */
		if (first->type.u.legacy.variant.nr_choices !=
					second->type.u.legacy.variant.nr_choices) {
			goto no_match;
		}

		/* Compare tag name of the variants. */
		if (strncmp(first->type.u.legacy.variant.tag_name,
					second->type.u.legacy.variant.tag_name,
					LTTNG_UST_SYM_NAME_LEN)) {
			goto no_match;
		}
		break;
	case ustctl_atype_struct:
		/* Compare number of fields of the structs. */
		if (first->type.u.legacy._struct.nr_fields != second->type.u.legacy._struct.nr_fields) {
			goto no_match;
		}
		break;
	case ustctl_atype_sequence_nestable:
		if (first->type.u.sequence_nestable.alignment != second->type.u.sequence_nestable.alignment) {
			goto no_match;
		}
		/* Compare length_name of the sequences. */
		if (strncmp(first->type.u.sequence_nestable.length_name,
					second->type.u.sequence_nestable.length_name,
					LTTNG_UST_SYM_NAME_LEN)) {
			goto no_match;
		}
		/* Comparison will be done when marshalling following items. */
		break;
	case ustctl_atype_array_nestable:
		if (first->type.u.array_nestable.alignment != second->type.u.array_nestable.alignment) {
			goto no_match;
		}
		/* Match length of the array. */
		if (first->type.u.array_nestable.length != second->type.u.array_nestable.length) {
			goto no_match;
		}
		/* Comparison of element type will be done when marshalling following item. */
		break;
	case ustctl_atype_enum_nestable:
		if (first->type.u.enum_nestable.id != second->type.u.enum_nestable.id) {
			goto no_match;
		}
		/* Compare name of the enums. */
		if (strncmp(first->type.u.enum_nestable.name,
					second->type.u.enum_nestable.name,
					LTTNG_UST_SYM_NAME_LEN)) {
			goto no_match;
		}
		/* Comparison of element type will be done when marshalling following item. */
		break;
	case ustctl_atype_struct_nestable:
		if (first->type.u.struct_nestable.alignment != second->type.u.struct_nestable.alignment) {
			goto no_match;
		}
		/* Compare number of fields of the structs. */
		if (first->type.u.struct_nestable.nr_fields != second->type.u.struct_nestable.nr_fields) {
			goto no_match;
		}
		break;
	case ustctl_atype_variant_nestable:
		if (first->type.u.variant_nestable.alignment != second->type.u.variant_nestable.alignment) {
			goto no_match;
		}
		/* Compare number of choice of the variants. */
		if (first->type.u.variant_nestable.nr_choices !=
					second->type.u.variant_nestable.nr_choices) {
			goto no_match;
		}

		/* Compare tag name of the variants. */
		if (strncmp(first->type.u.variant_nestable.tag_name,
					second->type.u.variant_nestable.tag_name,
					LTTNG_UST_SYM_NAME_LEN)) {
			goto no_match;
		}
		break;
	default:
		goto no_match;
	}

	return true;

no_match:
	return false;
}
Commit	Line	Data
98b73e88	1	/*
ab5be9fa	2	* Copyright (C) 2018 Francis Deslauriers <francis.deslauriers@efficios.com>
98b73e88	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
98b73e88	5	*
98b73e88 FD	6	*/
	7
	8	#include <stdbool.h>
	9	#include <string.h>
	10
	11	#include "ust-field-utils.h"
	12
	13	/*
	14	* The ustctl_field is made of a combination of C basic types
	15	* ustctl_basic_type and _ustctl_basic_type.
	16	*
	17	* ustctl_basic_type contains an enumeration describing the abstract type.
	18	* _ustctl_basic_type does _NOT_ contain an enumeration describing the
	19	* abstract type.
	20	*
	21	* A layer is needed to use the same code for both structures.
	22	* When dealing with _ustctl_basic_type, we need to use the abstract type of
	23	* the ustctl_type struct.
	24	*/
	25
	26	/*
	27	* Compare two ustctl_integer_type fields.
	28	* Returns 1 if both are identical.
	29	*/
	30	static bool match_ustctl_field_integer(const struct ustctl_integer_type *first,
	31	const struct ustctl_integer_type *second)
	32	{
	33	if (first->size != second->size) {
	34	goto no_match;
	35	}
	36	if (first->alignment != second->alignment) {
	37	goto no_match;
	38	}
	39	if (first->signedness != second->signedness) {
	40	goto no_match;
	41	}
	42	if (first->encoding != second->encoding) {
	43	goto no_match;
	44	}
	45	if (first->base != second->base) {
	46	goto no_match;
	47	}
	48	if (first->reverse_byte_order != second->reverse_byte_order) {
	49	goto no_match;
	50	}
	51
	52	return true;
	53
	54	no_match:
	55	return false;
	56	}
	57
	58	/*
	59	* Compare two _ustctl_basic_type fields known to be of type integer.
	60	* Returns 1 if both are identical.
	61	*/
	62	static bool match_ustctl_field_integer_from_raw_basic_type(
	63	const union _ustctl_basic_type *first,
	64	const union _ustctl_basic_type *second)
	65	{
	66	return match_ustctl_field_integer(&first->integer, &second->integer);
	67	}
	68
	69	/*
70	* Compare two _ustctl_basic_type fields known to be of type enum.
71	* Returns 1 if both are identical.
72	*/
73	static bool match_ustctl_field_enum_from_raw_basic_type(
74	const union _ustctl_basic_type *first,
75	const union _ustctl_basic_type *second)
76	{
77	/*
78	* Compare enumeration ID. Enumeration ID is provided to the application by
79	* the session daemon before event registration.
80	*/
81	if (first->enumeration.id != second->enumeration.id) {
82	goto no_match;
83	}
84
85	/*
86	* Sanity check of the name and container type. Those were already checked
87	* during enum registration.
88	*/
89	if (strncmp(first->enumeration.name, second->enumeration.name,
90	LTTNG_UST_SYM_NAME_LEN)) {
91	goto no_match;
92	}
93	if (!match_ustctl_field_integer(&first->enumeration.container_type,
94	&second->enumeration.container_type)) {
95	goto no_match;
96	}
97
98	return true;
99
100	no_match:
101	return false;
102	}
103
104	/*
105	* Compare two _ustctl_basic_type fields known to be of type string.
106	* Returns 1 if both are identical.
107	*/
108	static bool match_ustctl_field_string_from_raw_basic_type(
109	const union _ustctl_basic_type *first,
110	const union _ustctl_basic_type *second)
111	{
112	return first->string.encoding == second->string.encoding;
113	}
114
115	/*
116	* Compare two _ustctl_basic_type fields known to be of type float.
117	* Returns 1 if both are identical.
118	*/
119	static bool match_ustctl_field_float_from_raw_basic_type(
120	const union _ustctl_basic_type *first,
121	const union _ustctl_basic_type *second)
122	{
123	if (first->_float.exp_dig != second->_float.exp_dig) {
124	goto no_match;
125	}
126
127	if (first->_float.mant_dig != second->_float.mant_dig) {
128	goto no_match;
129	}
130
131	if (first->_float.reverse_byte_order !=
132	second->_float.reverse_byte_order) {
133	goto no_match;
134	}
135
136	if (first->_float.alignment != second->_float.alignment) {
137	goto no_match;
138	}
139
140	return true;
141
142	no_match:
143	return false;
144	}
145
146	/*
147	* Compare two _ustctl_basic_type fields given their respective abstract types.
148	* Returns 1 if both are identical.
149	*/
150	static bool match_ustctl_field_raw_basic_type(
151	enum ustctl_abstract_types first_atype,
152	const union _ustctl_basic_type *first,
153	enum ustctl_abstract_types second_atype,
154	const union _ustctl_basic_type *second)
155	{
156	if (first_atype != second_atype) {
157	goto no_match;
158	}
159
160	switch (first_atype) {
161	case ustctl_atype_integer:
162	if (!match_ustctl_field_integer_from_raw_basic_type(first, second)) {
163	goto no_match;
164	}
165	break;
166	case ustctl_atype_enum:
167	if (!match_ustctl_field_enum_from_raw_basic_type(first, second)) {
168	goto no_match;
169	}
170	break;
171	case ustctl_atype_string:
172	if (!match_ustctl_field_string_from_raw_basic_type(first, second)) {
173	goto no_match;
174	}
175	break;
176	case ustctl_atype_float:
177	if (!match_ustctl_field_float_from_raw_basic_type(first, second)) {
178	goto no_match;
179	}
180	break;
181	default:
182	goto no_match;
183	}
184
185	return true;
186
187	no_match:
188	return false;
189	}
190
191	/*
192	* Compatibility layer between the ustctl_basic_type struct and
193	* _ustctl_basic_type union.
194	*/
195	static bool match_ustctl_field_basic_type(const struct ustctl_basic_type *first,
196	const struct ustctl_basic_type *second)
197	{
198	return match_ustctl_field_raw_basic_type(first->atype, &first->u.basic,
199	second->atype, &second->u.basic);
200	}
201
202	int match_ustctl_field(const struct ustctl_field *first,
203	const struct ustctl_field *second)
204	{
205	/* Check the name of the field is identical. */
206	if (strncmp(first->name, second->name, LTTNG_UST_SYM_NAME_LEN)) {
207	goto no_match;
208	}
209
210	/* Check the field type is identical. */
211	if (first->type.atype != second->type.atype) {
212	goto no_match;
213	}
214
215	/* Check the field layout. */
216	switch (first->type.atype) {
217	case ustctl_atype_integer:
218	case ustctl_atype_enum:
219	case ustctl_atype_string:
220	case ustctl_atype_float:
221	if (!match_ustctl_field_raw_basic_type(first->type.atype,
0d32d1a9 MD	222	&first->type.u.legacy.basic, second->type.atype,
0d32d1a9 MD	223	&second->type.u.legacy.basic)) {
98b73e88 FD	224	goto no_match;
	225	}
	226	break;
	227	case ustctl_atype_sequence:
	228	/* Match element type of the sequence. */
0d32d1a9 MD	229	if (!match_ustctl_field_basic_type(&first->type.u.legacy.sequence.elem_type,
0d32d1a9 MD	230	&second->type.u.legacy.sequence.elem_type)) {
98b73e88 FD	231	goto no_match;
	232	}
	233
	234	/* Match length type of the sequence. */
0d32d1a9 MD	235	if (!match_ustctl_field_basic_type(&first->type.u.legacy.sequence.length_type,
0d32d1a9 MD	236	&second->type.u.legacy.sequence.length_type)) {
98b73e88 FD	237	goto no_match;
	238	}
	239	break;
	240	case ustctl_atype_array:
	241	/* Match element type of the array. */
0d32d1a9 MD	242	if (!match_ustctl_field_basic_type(&first->type.u.legacy.array.elem_type,
0d32d1a9 MD	243	&second->type.u.legacy.array.elem_type)) {
98b73e88 FD	244	goto no_match;
	245	}
	246
	247	/* Match length of the array. */
0d32d1a9	248	if (first->type.u.legacy.array.length != second->type.u.legacy.array.length) {
98b73e88 FD	249	goto no_match;
	250	}
	251	break;
	252	case ustctl_atype_variant:
	253	/* Compare number of choice of the variants. */
0d32d1a9 MD	254	if (first->type.u.legacy.variant.nr_choices !=
0d32d1a9 MD	255	second->type.u.legacy.variant.nr_choices) {
98b73e88 FD	256	goto no_match;
	257	}
	258
	259	/* Compare tag name of the variants. */
0d32d1a9 MD	260	if (strncmp(first->type.u.legacy.variant.tag_name,
0d32d1a9 MD	261	second->type.u.legacy.variant.tag_name,
98b73e88 FD	262	LTTNG_UST_SYM_NAME_LEN)) {
	263	goto no_match;
	264	}
	265	break;
	266	case ustctl_atype_struct:
	267	/* Compare number of fields of the structs. */
0d32d1a9 MD	268	if (first->type.u.legacy._struct.nr_fields != second->type.u.legacy._struct.nr_fields) {
	269	goto no_match;
	270	}
	271	break;
	272	case ustctl_atype_sequence_nestable:
	273	if (first->type.u.sequence_nestable.alignment != second->type.u.sequence_nestable.alignment) {
	274	goto no_match;
	275	}
	276	/* Compare length_name of the sequences. */
	277	if (strncmp(first->type.u.sequence_nestable.length_name,
	278	second->type.u.sequence_nestable.length_name,
	279	LTTNG_UST_SYM_NAME_LEN)) {
	280	goto no_match;
	281	}
	282	/* Comparison will be done when marshalling following items. */
	283	break;
	284	case ustctl_atype_array_nestable:
	285	if (first->type.u.array_nestable.alignment != second->type.u.array_nestable.alignment) {
	286	goto no_match;
	287	}
	288	/* Match length of the array. */
	289	if (first->type.u.array_nestable.length != second->type.u.array_nestable.length) {
	290	goto no_match;
	291	}
	292	/* Comparison of element type will be done when marshalling following item. */
	293	break;
	294	case ustctl_atype_enum_nestable:
	295	if (first->type.u.enum_nestable.id != second->type.u.enum_nestable.id) {
	296	goto no_match;
	297	}
	298	/* Compare name of the enums. */
	299	if (strncmp(first->type.u.enum_nestable.name,
	300	second->type.u.enum_nestable.name,
	301	LTTNG_UST_SYM_NAME_LEN)) {
	302	goto no_match;
	303	}
	304	/* Comparison of element type will be done when marshalling following item. */
	305	break;
	306	case ustctl_atype_struct_nestable:
	307	if (first->type.u.struct_nestable.alignment != second->type.u.struct_nestable.alignment) {
	308	goto no_match;
	309	}
	310	/* Compare number of fields of the structs. */
	311	if (first->type.u.struct_nestable.nr_fields != second->type.u.struct_nestable.nr_fields) {
	312	goto no_match;
	313	}
	314	break;
	315	case ustctl_atype_variant_nestable:
	316	if (first->type.u.variant_nestable.alignment != second->type.u.variant_nestable.alignment) {
	317	goto no_match;
	318	}
	319	/* Compare number of choice of the variants. */
	320	if (first->type.u.variant_nestable.nr_choices !=
	321	second->type.u.variant_nestable.nr_choices) {
	322	goto no_match;
	323	}
	324
	325	/* Compare tag name of the variants. */
	326	if (strncmp(first->type.u.variant_nestable.tag_name,
	327	second->type.u.variant_nestable.tag_name,
	328	LTTNG_UST_SYM_NAME_LEN)) {
98b73e88 FD	329	goto no_match;
	330	}
	331	break;
	332	default:
	333	goto no_match;
	334	}
	335
	336	return true;
	337
	338	no_match:
	339	return false;
	340	}