#include <babeltrace/list.h>
#include <babeltrace/types.h>
#include <babeltrace/ctf/metadata.h>
-#include <babeltrace/uuid.h>
+#include <babeltrace/compat/uuid.h>
#include <babeltrace/endian.h>
#include <babeltrace/ctf/events-internal.h>
#include "ctf-scanner.h"
bt_list_for_each_entry(node, head, siblings) {
if (node->type != NODE_UNARY_EXPRESSION
- || node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
|| (node->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT && node->u.unary_expression.type != UNARY_SIGNED_CONSTANT)
|| node->u.unary_expression.link != UNARY_LINK_UNKNOWN
|| i != 0)
|| i != 0)
return -EINVAL;
src_string = node->u.unary_expression.u.string;
- ret = babeltrace_uuid_parse(src_string, uuid);
+ ret = bt_uuid_parse(src_string, uuid);
}
return ret;
}
return g_ptr_array_index(trace->streams, stream_id);
}
+static
+struct ctf_event_declaration *stream_event_lookup(struct ctf_stream_declaration *stream, uint64_t event_id)
+{
+ if (stream->events_by_id->len <= event_id)
+ return NULL;
+ return g_ptr_array_index(stream->events_by_id, event_id);
+}
+
static
struct ctf_clock *trace_clock_lookup(struct ctf_trace *trace, GQuark clock_name)
{
- return g_hash_table_lookup(trace->parent.clocks, (gpointer) (unsigned long) clock_name);
+ return g_hash_table_lookup(trace->parent.clocks, GUINT_TO_POINTER(clock_name));
}
static
fprintf(fd, "[error] %s: cannot find typealias \"%s\".\n", __func__, g_quark_to_string(alias_q));
return NULL;
}
- if (nested_declaration->id == CTF_TYPE_INTEGER) {
+ if (nested_declaration->id == BT_CTF_TYPE_ID_INTEGER) {
struct declaration_integer *integer_declaration =
container_of(nested_declaration, struct declaration_integer, p);
/* For base to 16 for pointers (expected pretty-print) */
fprintf(fd, "[error] %s: expecting length field reference or value.\n", __func__);
return NULL;
}
- first = _bt_list_first_entry(&node_type_declarator->u.type_declarator.u.nested.length,
+ first = _bt_list_first_entry(&node_type_declarator->u.type_declarator.u.nested.length,
struct ctf_node, siblings);
if (first->type != NODE_UNARY_EXPRESSION) {
return NULL;
bt_list_for_each_entry(iter, type_declarators, siblings) {
struct bt_declaration *type_declaration;
int ret;
-
+
type_declaration = ctf_type_declarator_visit(fd, depth,
type_specifier_list,
&identifier, iter,
* Don't allow typedef and typealias of untagged
* variants.
*/
- if (type_declaration->id == CTF_TYPE_UNTAGGED_VARIANT) {
+ if (type_declaration->id == BT_CTF_TYPE_ID_UNTAGGED_VARIANT) {
fprintf(fd, "[error] %s: typedef of untagged variant is not permitted.\n", __func__);
bt_declaration_unref(type_declaration);
return -EPERM;
* Don't allow typedef and typealias of untagged
* variants.
*/
- if (type_declaration->id == CTF_TYPE_UNTAGGED_VARIANT) {
+ if (type_declaration->id == BT_CTF_TYPE_ID_UNTAGGED_VARIANT) {
fprintf(fd, "[error] %s: typedef of untagged variant is not permitted.\n", __func__);
bt_declaration_unref(type_declaration);
return -EPERM;
if (name) {
if (bt_lookup_struct_declaration(g_quark_from_string(name),
declaration_scope)) {
-
fprintf(fd, "[error] %s: struct %s already declared in scope\n", __func__, name);
return NULL;
}
ret = get_unary_unsigned(min_align, &min_align_value);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for structure \"align\" attribute\n", __func__);
- ret = -EINVAL;
goto error;
}
}
if (name) {
if (bt_lookup_variant_declaration(g_quark_from_string(name),
declaration_scope)) {
-
fprintf(fd, "[error] %s: variant %s already declared in scope\n", __func__, name);
return NULL;
}
q = g_quark_from_string(enumerator->u.enumerator.id);
if (enum_declaration->integer_declaration->signedness) {
- int64_t start, end;
+ int64_t start = 0, end = 0;
int nr_vals = 0;
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
last->u.s = end + 1;
bt_enum_signed_insert(enum_declaration, start, end, q);
} else {
- uint64_t start, end;
+ uint64_t start = 0, end = 0;
int nr_vals = 0;
bt_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
if (name) {
if (bt_lookup_enum_declaration(g_quark_from_string(name),
declaration_scope)) {
-
fprintf(fd, "[error] %s: enum %s already declared in scope\n", __func__, name);
return NULL;
}
}
if (!container_type) {
- declaration = bt_lookup_declaration(g_quark_from_static_string("int"),
+ declaration = bt_lookup_declaration(g_quark_from_string("int"),
declaration_scope);
if (!declaration) {
fprintf(fd, "[error] %s: \"int\" type declaration missing for enumeration\n", __func__);
fprintf(fd, "[error] %s: unable to create container type for enumeration\n", __func__);
return NULL;
}
- if (declaration->id != CTF_TYPE_INTEGER) {
+ if (declaration->id != BT_CTF_TYPE_ID_INTEGER) {
fprintf(fd, "[error] %s: container type for enumeration is not integer\n", __func__);
return NULL;
}
fprintf(fd, "[error] %s: unexpected unary expression type\n",
__func__);
return -EINVAL;
- }
+ }
}
return NULL;
}
size = right->u.unary_expression.u.unsigned_constant;
+ if (!size) {
+ fprintf(fd, "[error] %s: integer size: expecting non-zero constant\n",
+ __func__);
+ return NULL;
+ }
has_size = 1;
} else if (!strcmp(left->u.unary_expression.u.string, "align")) {
if (right->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
switch (right->u.unary_expression.type) {
case UNARY_UNSIGNED_CONSTANT:
switch (right->u.unary_expression.u.unsigned_constant) {
- case 2:
+ case 2:
case 8:
case 10:
case 16:
struct ctf_trace *trace)
{
struct ctf_node *expression;
- uint64_t alignment = 1, exp_dig = 0, mant_dig = 0,
- byte_order = trace->byte_order;
- int has_alignment = 0, has_exp_dig = 0, has_mant_dig = 0;
+ uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
+ int byte_order = trace->byte_order, has_alignment = 0,
+ has_exp_dig = 0, has_mant_dig = 0;
struct declaration_float *float_declaration;
bt_list_for_each_entry(expression, expressions, siblings) {
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
struct ctf_event_declaration *event;
struct bt_ctf_event_decl *event_decl;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
event_decl = g_new0(struct bt_ctf_event_decl, 1);
event = &event_decl->parent;
event->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
fprintf(fd, "[error] %s: missing id field in event declaration\n", __func__);
goto error;
}
+ /* Disallow re-using the same event ID in the same stream */
+ if (stream_event_lookup(event->stream, event->id)) {
+ ret = -EPERM;
+ fprintf(fd, "[error] %s: event ID %" PRIu64 " used more than once in stream %" PRIu64 "\n",
+ __func__, event->id, event->stream_id);
+ goto error;
+ }
if (event->stream->events_by_id->len <= event->id)
g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
g_ptr_array_index(event->stream->events_by_id, event->id) = event;
g_hash_table_insert(event->stream->event_quark_to_id,
- (gpointer) (unsigned long) event->name,
+ GUINT_TO_POINTER(event->name),
&event->id);
g_ptr_array_add(trace->event_declarations, event_decl);
return 0;
return ret;
}
-
+
static
int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_stream_declaration *stream, struct ctf_trace *trace)
{
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
struct ctf_node *iter;
struct ctf_stream_declaration *stream;
+ if (node) {
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+ }
+
stream = g_new0(struct ctf_stream_declaration, 1);
stream->declaration_scope = bt_new_declaration_scope(parent_declaration_scope);
stream->events_by_id = g_ptr_array_new();
if (CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {
/* check that packet header has stream_id field. */
if (!trace->packet_header_decl
- || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("stream_id")) < 0) {
+ || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_string("stream_id")) < 0) {
ret = -EPERM;
fprintf(fd, "[error] %s: missing stream_id field in packet header declaration, but stream_id attribute is declared for stream.\n", __func__);
goto error;
goto error;
}
if (CTF_TRACE_FIELD_IS_SET(trace, uuid)
- && babeltrace_uuid_compare(uuid, trace->uuid)) {
+ && bt_uuid_compare(uuid, trace->uuid)) {
fprintf(fd, "[error] %s: uuid mismatch\n", __func__);
ret = -EPERM;
goto error;
ret = -EPERM;
goto error;
}
- if (declaration->id != CTF_TYPE_STRUCT) {
+ if (declaration->id != BT_CTF_TYPE_ID_STRUCT) {
ret = -EPERM;
goto error;
}
int ret = 0;
struct ctf_node *iter;
+ if (!trace->restart_root_decl && node->visited)
+ return 0;
+ node->visited = 1;
+
if (trace->declaration_scope)
return -EEXIST;
+
trace->declaration_scope = bt_new_declaration_scope(trace->root_declaration_scope);
trace->streams = g_ptr_array_new();
trace->event_declarations = g_ptr_array_new();
if (!CTF_TRACE_FIELD_IS_SET(trace, byte_order)) {
/* check that the packet header contains a "magic" field */
if (!trace->packet_header_decl
- || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_static_string("magic")) < 0) {
+ || bt_struct_declaration_lookup_field_index(trace->packet_header_decl, g_quark_from_string("magic")) < 0) {
ret = -EPERM;
fprintf(fd, "[error] %s: missing both byte_order and packet header magic number in trace declaration\n", __func__);
goto error;
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(&node->u.ctf_expression.right, &clock->offset_s);
+ ret = get_unary_signed(&node->u.ctf_expression.right, &clock->offset_s);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for clock offset_s\n", __func__);
ret = -EINVAL;
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(&node->u.ctf_expression.right, &clock->offset);
+ ret = get_unary_signed(&node->u.ctf_expression.right, &clock->offset);
if (ret) {
fprintf(fd, "[error] %s: unexpected unary expression for clock offset\n", __func__);
ret = -EINVAL;
goto error;
}
clock->absolute = ret;
+ ret = 0;
} else {
fprintf(fd, "[warning] %s: attribute \"%s\" is unknown in clock declaration.\n", __func__, left);
}
struct ctf_node *iter;
struct ctf_clock *clock;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
clock = g_new0(struct ctf_clock, 1);
/* Default clock frequency is set to 1000000000 */
clock->freq = 1000000000ULL;
goto error;
}
trace->parent.single_clock = clock;
- g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
+ g_hash_table_insert(trace->parent.clocks, GUINT_TO_POINTER(clock->name), clock);
return 0;
error:
}
trace->parent.single_clock = clock;
- g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
+ g_hash_table_insert(trace->parent.clocks, GUINT_TO_POINTER(clock->name), clock);
}
static
struct ctf_callsite *callsite;
struct ctf_callsite_dups *cs_dups;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
callsite = g_new0(struct ctf_callsite, 1);
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
ret = ctf_callsite_declaration_visit(fd, depth + 1, iter, callsite, trace);
}
cs_dups = g_hash_table_lookup(trace->callsites,
- (gpointer) (unsigned long) callsite->name);
+ GUINT_TO_POINTER(callsite->name));
if (!cs_dups) {
cs_dups = g_new0(struct ctf_callsite_dups, 1);
BT_INIT_LIST_HEAD(&cs_dups->head);
g_hash_table_insert(trace->callsites,
- (gpointer) (unsigned long) callsite->name, cs_dups);
+ GUINT_TO_POINTER(callsite->name), cs_dups);
}
bt_list_add_tail(&callsite->node, &cs_dups->head);
return 0;
env->domain[TRACER_ENV_LEN - 1] = '\0';
printf_verbose("env.domain = \"%s\"\n", env->domain);
g_free(right);
+ } else if (!strcmp(left, "tracer_name")) {
+ char *right;
+
+ if (env->tracer_name[0]) {
+ fprintf(fd, "[warning] %s: duplicated env tracer_name\n", __func__);
+ goto error; /* ret is 0, so not an actual error, just warn. */
+ }
+ right = concatenate_unary_strings(&node->u.ctf_expression.right);
+ if (!right) {
+ fprintf(fd, "[warning] %s: unexpected unary expression for env tracer_name\n", __func__);
+ goto error; /* ret is 0, so not an actual error, just warn. */
+ }
+ strncpy(env->tracer_name, right, TRACER_ENV_LEN);
+ env->tracer_name[TRACER_ENV_LEN - 1] = '\0';
+ printf_verbose("env.tracer_name = \"%s\"\n", env->tracer_name);
+ g_free(right);
} else if (!strcmp(left, "sysname")) {
char *right;
int ret = 0;
struct ctf_node *iter;
+ if (node->visited)
+ return 0;
+ node->visited = 1;
+
trace->env.vpid = -1;
trace->env.procname[0] = '\0';
trace->env.hostname[0] = '\0';
{
int ret = 0;
+ if (!trace->restart_root_decl && node->visited)
+ return 0;
+ node->visited = 1;
+
switch (node->type) {
case NODE_TYPEDEF:
ret = ctf_typedef_visit(fd, depth + 1,
{
int ret = 0;
struct ctf_node *iter;
- int env_clock_done = 0;
printf_verbose("CTF visitor: metadata construction...\n");
trace->byte_order = byte_order;
switch (node->type) {
case NODE_ROOT:
- if (!env_clock_done) {
- /*
- * declarations need to query clock hash table,
- * so clock need to be treated first.
- */
- if (bt_list_empty(&node->u.root.clock)) {
- ctf_clock_default(fd, depth + 1, trace);
- } else {
- bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
- ret = ctf_clock_visit(fd, depth + 1, iter,
- trace);
- if (ret) {
- fprintf(fd, "[error] %s: clock declaration error\n", __func__);
- goto error;
- }
+ /*
+ * declarations need to query clock hash table,
+ * so clock need to be treated first.
+ */
+ if (bt_list_empty(&node->u.root.clock)) {
+ ctf_clock_default(fd, depth + 1, trace);
+ } else {
+ bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
+ ret = ctf_clock_visit(fd, depth + 1, iter,
+ trace);
+ if (ret) {
+ fprintf(fd, "[error] %s: clock declaration error\n", __func__);
+ goto error;
}
}
- env_clock_done = 1;
}
bt_list_for_each_entry(iter, &node->u.root.declaration_list,
siblings) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = ctf_trace_visit(fd, depth + 1, iter, trace);
if (ret == -EINTR) {
+ trace->restart_root_decl = 1;
bt_free_declaration_scope(trace->root_declaration_scope);
/*
* Need to restart creation of type
goto error;
}
}
+ trace->restart_root_decl = 0;
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
ret = ctf_callsite_visit(fd, depth + 1, iter,
trace);
projects / babeltrace.git / blobdiff