[babeltrace.git] / src / plugins / ctf / common / metadata / ctf-meta-warn-meaningless-header-fields.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2018 Philippe Proulx <pproulx@efficios.com>
 */

#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/WARN-MEANINGLESS-HEADER-FIELDS"
#include "logging/comp-logging.h"

#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"
#include "logging.h"

static inline
void warn_meaningless_field(const char *name, const char *scope_name,
		struct meta_log_config *log_cfg)
{
	BT_ASSERT(name);
	BT_COMP_LOGW("User field found in %s: ignoring: name=\"%s\"",
		scope_name, name);
}

static inline
void warn_meaningless_fields(struct ctf_field_class *fc, const char *name,
		const char *scope_name, struct meta_log_config *log_cfg)
{
	uint64_t i;

	if (!fc) {
		goto end;
	}

	/*
	 * 'name' is guaranteed to be non-NULL whenever the field class is not a
	 * structure. In the case of a structure field class, its members' names
	 * are used.
	 */
	switch (fc->type) {
	case CTF_FIELD_CLASS_TYPE_FLOAT:
	case CTF_FIELD_CLASS_TYPE_STRING:
		warn_meaningless_field(name, scope_name, log_cfg);
		break;
	case CTF_FIELD_CLASS_TYPE_INT:
	case CTF_FIELD_CLASS_TYPE_ENUM:
	{
		struct ctf_field_class_int *int_fc = (void *) fc;

		if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE &&
				!int_fc->mapped_clock_class) {
			warn_meaningless_field(name, scope_name, log_cfg);
		}

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

			warn_meaningless_fields(named_fc->fc,
				named_fc->name->str, scope_name, log_cfg);
		}

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

			warn_meaningless_fields(named_fc->fc,
				named_fc->name->str, scope_name, log_cfg);
		}

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

		if (array_fc->meaning != CTF_FIELD_CLASS_MEANING_NONE) {
			goto end;
		}

	}
	/* fall-through */
	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
	{
		struct ctf_field_class_array_base *array_fc = (void *) fc;

		warn_meaningless_fields(array_fc->elem_fc, name, scope_name,
			log_cfg);
		break;
	}
	default:
		bt_common_abort();
	}

end:
	return;
}

BT_HIDDEN
void ctf_trace_class_warn_meaningless_header_fields(
		struct ctf_trace_class *ctf_tc,
		struct meta_log_config *log_cfg)
{
	uint64_t i;

	if (!ctf_tc->is_translated) {
		warn_meaningless_fields(
			ctf_tc->packet_header_fc, NULL, "packet header",
			log_cfg);
	}

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

		if (!sc->is_translated) {
			warn_meaningless_fields(sc->event_header_fc, NULL,
				"event header", log_cfg);
		}
	}
}
Commit	Line	Data
83ebb7f1	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
83ebb7f1	3	*
0235b0db	4	* Copyright 2018 Philippe Proulx <pproulx@efficios.com>
83ebb7f1 PP	5	*/
83ebb7f1 PP	6
f7b785ac PP	7	#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
f7b785ac PP	8	#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
350ad6c1	9	#define BT_LOG_TAG "PLUGIN/CTF/META/WARN-MEANINGLESS-HEADER-FIELDS"
d9c39b0a	10	#include "logging/comp-logging.h"
83ebb7f1	11
3fadfbc0	12	#include <babeltrace2/babeltrace.h>
91d81473	13	#include "common/macros.h"
578e048b	14	#include "common/assert.h"
83ebb7f1 PP	15	#include <glib.h>
	16	#include <stdint.h>
	17	#include <string.h>
	18	#include <inttypes.h>
	19
	20	#include "ctf-meta-visitors.h"
f7b785ac	21	#include "logging.h"
83ebb7f1 PP	22
83ebb7f1 PP	23	static inline
0746848c	24	void warn_meaningless_field(const char name, const char scope_name,
f7b785ac	25	struct meta_log_config *log_cfg)
83ebb7f1	26	{
74ad166b	27	BT_ASSERT(name);
f7b785ac	28	BT_COMP_LOGW("User field found in %s: ignoring: name=\"%s\"",
83ebb7f1 PP	29	scope_name, name);
	30	}
	31
	32	static inline
	33	void warn_meaningless_fields(struct ctf_field_class fc, const char name,
f7b785ac	34	const char scope_name, struct meta_log_config log_cfg)
83ebb7f1 PP	35	{
	36	uint64_t i;
	37
	38	if (!fc) {
	39	goto end;
	40	}
	41
74ad166b JG	42	/*
	43	* 'name' is guaranteed to be non-NULL whenever the field class is not a
	44	* structure. In the case of a structure field class, its members' names
	45	* are used.
	46	*/
83ebb7f1 PP	47	switch (fc->type) {
	48	case CTF_FIELD_CLASS_TYPE_FLOAT:
	49	case CTF_FIELD_CLASS_TYPE_STRING:
f7b785ac	50	warn_meaningless_field(name, scope_name, log_cfg);
83ebb7f1 PP	51	break;
	52	case CTF_FIELD_CLASS_TYPE_INT:
	53	case CTF_FIELD_CLASS_TYPE_ENUM:
	54	{
	55	struct ctf_field_class_int int_fc = (void ) fc;
	56
	57	if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE &&
	58	!int_fc->mapped_clock_class) {
f7b785ac	59	warn_meaningless_field(name, scope_name, log_cfg);
83ebb7f1 PP	60	}
	61
	62	break;
	63	}
	64	case CTF_FIELD_CLASS_TYPE_STRUCT:
	65	{
	66	struct ctf_field_class_struct struct_fc = (void ) fc;
	67
	68	for (i = 0; i < struct_fc->members->len; i++) {
	69	struct ctf_named_field_class *named_fc =
	70	ctf_field_class_struct_borrow_member_by_index(
	71	struct_fc, i);
	72
	73	warn_meaningless_fields(named_fc->fc,
f7b785ac	74	named_fc->name->str, scope_name, log_cfg);
83ebb7f1 PP	75	}
	76
	77	break;
	78	}
	79	case CTF_FIELD_CLASS_TYPE_VARIANT:
	80	{
	81	struct ctf_field_class_variant var_fc = (void ) fc;
	82
	83	for (i = 0; i < var_fc->options->len; i++) {
	84	struct ctf_named_field_class *named_fc =
	85	ctf_field_class_variant_borrow_option_by_index(
	86	var_fc, i);
	87
	88	warn_meaningless_fields(named_fc->fc,
f7b785ac	89	named_fc->name->str, scope_name, log_cfg);
83ebb7f1 PP	90	}
	91
	92	break;
	93	}
	94	case CTF_FIELD_CLASS_TYPE_ARRAY:
	95	{
	96	struct ctf_field_class_array array_fc = (void ) fc;
	97
	98	if (array_fc->meaning != CTF_FIELD_CLASS_MEANING_NONE) {
	99	goto end;
	100	}
	101
83ebb7f1	102	}
2f69c7e7	103	/* fall-through */
83ebb7f1 PP	104	case CTF_FIELD_CLASS_TYPE_SEQUENCE:
	105	{
	106	struct ctf_field_class_array_base array_fc = (void ) fc;
	107
0746848c	108	warn_meaningless_fields(array_fc->elem_fc, name, scope_name,
f7b785ac	109	log_cfg);
83ebb7f1 PP	110	break;
	111	}
	112	default:
498e7994	113	bt_common_abort();
83ebb7f1 PP	114	}
	115
	116	end:
	117	return;
	118	}
	119
	120	BT_HIDDEN
	121	void ctf_trace_class_warn_meaningless_header_fields(
0746848c	122	struct ctf_trace_class *ctf_tc,
f7b785ac	123	struct meta_log_config *log_cfg)
83ebb7f1 PP	124	{
	125	uint64_t i;
	126
	127	if (!ctf_tc->is_translated) {
	128	warn_meaningless_fields(
0746848c	129	ctf_tc->packet_header_fc, NULL, "packet header",
f7b785ac	130	log_cfg);
83ebb7f1 PP	131	}
	132
	133	for (i = 0; i < ctf_tc->stream_classes->len; i++) {
	134	struct ctf_stream_class *sc = ctf_tc->stream_classes->pdata[i];
	135
	136	if (!sc->is_translated) {
	137	warn_meaningless_fields(sc->event_header_fc, NULL,
f7b785ac	138	"event header", log_cfg);
83ebb7f1 PP	139	}
	140	}
	141	}