* SOFTWARE.
*/
+#define BT_LOG_TAG "VALIDATION"
+#include <babeltrace/lib-logging-internal.h>
+
#include <babeltrace/ctf-ir/validation-internal.h>
#include <babeltrace/ctf-ir/resolve-internal.h>
#include <babeltrace/ctf-ir/trace-internal.h>
#include <babeltrace/babeltrace-internal.h>
#include <babeltrace/ref.h>
-#define _printf_error(fmt, args...) \
- printf_verbose("[validation] " fmt, ## args)
-
/*
* This function resolves and validates the field types of an event
* class. Only `event_context_type` and `event_payload_type` are
{
int ret = 0;
+ BT_LOGV("Validating event class field types: "
+ "packet-header-ft-addr=%p, "
+ "packet-context-ft-addr=%p, "
+ "event-header-ft-addr=%p, "
+ "stream-event-context-ft-addr=%p, "
+ "event-context-ft-addr=%p, "
+ "event-payload-ft-addr=%p",
+ packet_header_type, packet_context_type, event_header_type,
+ stream_event_ctx_type, event_context_type, event_payload_type);
+
/* Resolve sequence type lengths and variant type tags first */
ret = bt_ctf_resolve_types(environment, packet_header_type,
packet_context_type, event_header_type, stream_event_ctx_type,
BT_CTF_RESOLVE_FLAG_EVENT_CONTEXT |
BT_CTF_RESOLVE_FLAG_EVENT_PAYLOAD);
if (ret) {
- _printf_error("Cannot resolve event class types\n");
+ BT_LOGW("Cannot resolve event class field types: ret=%d",
+ ret);
goto end;
}
if (event_context_type) {
ret = bt_ctf_field_type_validate(event_context_type);
if (ret) {
- _printf_error("Invalid event context type\n");
+ BT_LOGW("Invalid event class's context field type: "
+ "ret=%d", ret);
goto end;
}
}
if (event_payload_type) {
ret = bt_ctf_field_type_validate(event_payload_type);
if (ret) {
- _printf_error("Invalid event payload type\n");
+ BT_LOGW("Invalid event class's payload field type: "
+ "ret=%d", ret);
goto end;
}
}
{
int ret = 0;
+ BT_LOGV("Validating stream class field types: "
+ "packet-header-ft-addr=%p, "
+ "packet-context-ft-addr=%p, "
+ "event-header-ft-addr=%p, "
+ "stream-event-context-ft-addr=%p",
+ packet_header_type, packet_context_type, event_header_type,
+ stream_event_ctx_type);
+
/* Resolve sequence type lengths and variant type tags first */
ret = bt_ctf_resolve_types(environment, packet_header_type,
packet_context_type, event_header_type, stream_event_ctx_type,
BT_CTF_RESOLVE_FLAG_EVENT_HEADER |
BT_CTF_RESOLVE_FLAG_STREAM_EVENT_CTX);
if (ret) {
- _printf_error("Cannot resolve stream class types\n");
+ BT_LOGW("Cannot resolve stream class field types: ret=%d",
+ ret);
goto end;
}
if (packet_context_type) {
ret = bt_ctf_field_type_validate(packet_context_type);
if (ret) {
- _printf_error("Invalid stream packet context type\n");
+ BT_LOGW("Invalid stream class's packet context field type: "
+ "ret=%d", ret);
goto end;
}
}
if (event_header_type) {
ret = bt_ctf_field_type_validate(event_header_type);
if (ret) {
- _printf_error("Invalid stream event header type\n");
+ BT_LOGW("Invalid stream class's event header field type: "
+ "ret=%d", ret);
goto end;
}
}
ret = bt_ctf_field_type_validate(
stream_event_ctx_type);
if (ret) {
- _printf_error("Invalid stream event context type\n");
+ BT_LOGW("Invalid stream class's event context field type: "
+ "ret=%d", ret);
goto end;
}
}
{
int ret = 0;
+ BT_LOGV("Validating event class field types: "
+ "packet-header-ft-addr=%p", packet_header_type);
+
/* Resolve sequence type lengths and variant type tags first */
ret = bt_ctf_resolve_types(environment, packet_header_type,
NULL, NULL, NULL, NULL, NULL,
BT_CTF_RESOLVE_FLAG_PACKET_HEADER);
if (ret) {
- _printf_error("Cannot resolve trace types\n");
+ BT_LOGW("Cannot resolve trace field types: ret=%d",
+ ret);
goto end;
}
if (packet_header_type) {
ret = bt_ctf_field_type_validate(packet_header_type);
if (ret) {
- _printf_error("Invalid trace packet header type\n");
+ BT_LOGW("Invalid trace's packet header field type: "
+ "ret=%d", ret);
goto end;
}
}
int field_type_contains_sequence_or_variant_ft(struct bt_ctf_field_type *type)
{
int ret = 0;
- enum bt_ctf_type_id type_id = bt_ctf_field_type_get_type_id(type);
+ enum bt_ctf_field_type_id type_id = bt_ctf_field_type_get_type_id(type);
switch (type_id) {
- case BT_CTF_TYPE_ID_SEQUENCE:
- case BT_CTF_TYPE_ID_VARIANT:
+ case BT_CTF_FIELD_TYPE_ID_SEQUENCE:
+ case BT_CTF_FIELD_TYPE_ID_VARIANT:
ret = 1;
goto end;
- case BT_CTF_TYPE_ID_ARRAY:
- case BT_CTF_TYPE_ID_STRUCT:
+ case BT_CTF_FIELD_TYPE_ID_ARRAY:
+ case BT_CTF_FIELD_TYPE_ID_STRUCT:
{
int i;
int field_count = bt_ctf_field_type_get_field_count(type);
int contains_seq_var;
int valid_ret;
+ BT_LOGV("Validating field types: "
+ "packet-header-ft-addr=%p, "
+ "packet-context-ft-addr=%p, "
+ "event-header-ft-addr=%p, "
+ "stream-event-context-ft-addr=%p, "
+ "event-context-ft-addr=%p, "
+ "event-payload-ft-addr=%p, "
+ "trace-is-valid=%d, stream-class-is-valid=%d, "
+ "event-class-is-valid=%d, validation-flags=%x",
+ packet_header_type, packet_context_type, event_header_type,
+ stream_event_ctx_type, event_context_type, event_payload_type,
+ trace_valid, stream_class_valid, event_class_valid,
+ (unsigned int) validate_flags);
+
/* Clean output values */
memset(output, 0, sizeof(*output));
goto skip_packet_header_type_copy;
}
+ BT_LOGV_STR("Copying packet header field type because it contains at least one sequence or variant field type.");
packet_header_type_copy =
bt_ctf_field_type_copy(packet_header_type);
if (!packet_header_type_copy) {
ret = -1;
- _printf_error("Cannot copy packet header type\n");
+ BT_LOGE_STR("Cannot copy packet header field type.");
goto error;
}
/* Validate trace field types */
valid_ret = validate_trace_types(environment,
packet_header_type);
- if (!valid_ret) {
+ if (valid_ret == 0) {
/* Trace is valid */
output->valid_flags |= BT_CTF_VALIDATION_FLAG_TRACE;
}
goto skip_packet_context_type_copy;
}
+ BT_LOGV_STR("Copying packet context field type because it contains at least one sequence or variant field type.");
packet_context_type_copy =
bt_ctf_field_type_copy(packet_context_type);
if (!packet_context_type_copy) {
- _printf_error("Cannot copy packet context type\n");
+ BT_LOGE_STR("Cannot copy packet context field type.");
goto sc_validation_error;
}
goto skip_event_header_type_copy;
}
+ BT_LOGV_STR("Copying event header field type because it contains at least one sequence or variant field type.");
event_header_type_copy =
bt_ctf_field_type_copy(event_header_type);
if (!event_header_type_copy) {
- _printf_error("Cannot copy event header type\n");
+ BT_LOGE_STR("Cannot copy event header field type.");
goto sc_validation_error;
}
goto skip_stream_event_ctx_type_copy;
}
+ BT_LOGV_STR("Copying stream event context field type because it contains at least one sequence or variant field type.");
stream_event_ctx_type_copy =
bt_ctf_field_type_copy(stream_event_ctx_type);
if (!stream_event_ctx_type_copy) {
- _printf_error("Cannot copy stream event context type\n");
+ BT_LOGE_STR("Cannot copy stream event context field type.");
goto sc_validation_error;
}
valid_ret = validate_stream_class_types(environment,
packet_header_type, packet_context_type,
event_header_type, stream_event_ctx_type);
- if (!valid_ret) {
+ if (valid_ret == 0) {
/* Stream class is valid */
output->valid_flags |= BT_CTF_VALIDATION_FLAG_STREAM;
}
goto skip_event_context_type_copy;
}
+ BT_LOGV_STR("Copying event context field type because it contains at least one sequence or variant field type.");
event_context_type_copy =
bt_ctf_field_type_copy(event_context_type);
if (!event_context_type_copy) {
- _printf_error("Cannot copy event context type\n");
+ BT_LOGE_STR("Cannot copy event context field type.");
goto ec_validation_error;
}
goto skip_event_payload_type_copy;
}
+ BT_LOGV_STR("Copying event payload field type because it contains at least one sequence or variant field type.");
event_payload_type_copy =
bt_ctf_field_type_copy(event_payload_type);
if (!event_payload_type_copy) {
- _printf_error("Cannot copy event payload type\n");
+ BT_LOGE_STR("Cannot copy event payload field type.");
goto ec_validation_error;
}
packet_header_type, packet_context_type,
event_header_type, stream_event_ctx_type,
event_context_type, event_payload_type);
- if (!valid_ret) {
+ if (valid_ret == 0) {
/* Event class is valid */
output->valid_flags |= BT_CTF_VALIDATION_FLAG_EVENT;
}
BT_MOVE(output->stream_event_ctx_type, stream_event_ctx_type);
BT_MOVE(output->event_context_type, event_context_type);
BT_MOVE(output->event_payload_type, event_payload_type);
-
return ret;
error:
BT_PUT(stream_event_ctx_type);
BT_PUT(event_context_type);
BT_PUT(event_payload_type);
-
return ret;
}