#include <lttv/traceset.h>
#include <lttv/iattribute.h>
+#include <lttv/state.h>
+#include <lttv/hook.h>
#include <stdio.h>
+#include <babeltrace/babeltrace.h>
+#include <babeltrace/context.h>
+#include <babeltrace/ctf/iterator.h>
+#include <babeltrace/ctf/events.h>
+
+/* To traverse a tree recursively */
+#include <fcntl.h>
+#include <fts.h>
+/* For the use of realpath*/
+#include <limits.h>
+#include <stdlib.h>
+/* For strcpy*/
+#include <string.h>
/* A trace is a sequence of events gathered in the same tracing session. The
events may be stored in several tracefiles in the same directory.
possibly to study the interactions between events in the different traces.
*/
-struct _LttvTraceset {
- char * filename;
- GPtrArray *traces;
- LttvAttribute *a;
-};
-
-struct _LttvTrace {
- LttTrace *t;
- LttvAttribute *a;
- guint ref_count;
-};
-
-
-LttvTraceset *lttv_traceset_new()
+LttvTraceset *lttv_traceset_new(void)
{
LttvTraceset *s;
+ struct bt_iter_pos begin_pos;
s = g_new(LttvTraceset, 1);
s->filename = NULL;
s->traces = g_ptr_array_new();
+ s->context = bt_context_create();
s->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+ //TODO remove this when we have really mecanism
+ //s->tmpState = g_new(LttvTraceState *, 1);
+ //lttv_trace_state_init(s->tmpState,0);
+
+ s->iter = 0;
+ s->event_hooks = lttv_hooks_new();
+
+ s->state_trace_handle_index = g_ptr_array_new();
+
return s;
}
return s->filename;
}
-LttvTrace *lttv_trace_new(LttTrace *t)
+#ifdef BABEL_CLEANUP
+LttvTrace *lttv_trace_new(LttTrace *t)
{
LttvTrace *new_trace;
new_trace = g_new(LttvTrace, 1);
new_trace->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
- new_trace->t = t;
+ new_trace->id = t;
new_trace->ref_count = 0;
return new_trace;
}
+#endif
+/*
+ * get_absolute_pathname : Return the unique pathname in the system
+ *
+ * pathname is the relative path.
+ *
+ * abs_pathname is being set to the absolute path.
+ *
+ */
+void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
+{
+ abs_pathname[0] = '\0';
+
+ if (realpath(pathname, abs_pathname) != NULL)
+ return;
+ else
+ {
+ /* error, return the original path unmodified */
+ strcpy(abs_pathname, pathname);
+ return;
+ }
+ return;
+}
+
+
+
+/*
+ * lttv_trace_create : Create a trace from a path
+ *
+ * ts is the traceset in which will be contained the trace
+ *
+ * path is the path where to find a trace. It is not recursive.
+ *
+ * This function is static since a trace should always be contained in a
+ * traceset.
+ *
+ * return the created trace or NULL on failure
+ */
+static LttvTrace *lttv_trace_create(LttvTraceset *ts, const char *path)
+{
+ int id = bt_context_add_trace(lttv_traceset_get_context(ts),
+ path,
+ "ctf",
+ NULL,
+ NULL,
+ NULL);
+ if (id < 0) {
+ return NULL;
+ }
+ // Create the trace and save the trace handle id returned by babeltrace
+ LttvTrace *new_trace;
+
+ new_trace = g_new(LttvTrace, 1);
+ new_trace->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+ new_trace->id = id;
+ new_trace->ref_count = 0;
+ new_trace->traceset = ts;
+ new_trace->state = g_new(LttvTraceState,1);
+ lttv_trace_state_init(new_trace->state,new_trace);
+
+ /* Add the state to the trace_handle to state index */
+ g_ptr_array_set_size(ts->state_trace_handle_index,id+1);
+ g_ptr_array_index(ts->state_trace_handle_index,id) = new_trace->state;
+
+ return new_trace;
+}
+/*
+ * lttv_trace_create : Create and add a single trace to a traceset
+ *
+ * ts is the traceset in which will be contained the trace
+ *
+ * path is the path where to find a trace. It is not recursive.
+ *
+ * return a positive integer (>=0)on success or -1 on failure
+ */
+static int lttv_traceset_create_trace(LttvTraceset *ts, const char *path)
+{
+ LttvTrace *trace = lttv_trace_create(ts, path);
+ if (trace == NULL) {
+ return -1;
+ }
+ lttv_traceset_add(ts, trace);
+ return 0;
+}
LttvTraceset *lttv_traceset_copy(LttvTraceset *s_orig)
{
s = g_new(LttvTraceset, 1);
s->filename = NULL;
s->traces = g_ptr_array_new();
+ s->state_trace_handle_index = g_ptr_array_new();
for(i=0;i<s_orig->traces->len;i++)
{
trace = g_ptr_array_index(s_orig->traces, i);
trace->ref_count++;
+ /* WARNING: this is an alias, not a copy. */
g_ptr_array_add(s->traces, trace);
+
+ g_ptr_array_set_size(s->state_trace_handle_index,trace->id+1);
+ g_ptr_array_index(s->state_trace_handle_index,trace->id) = trace->state;
+
}
+ s->context = s_orig->context;
+ bt_context_get(s->context);
s->a = LTTV_ATTRIBUTE(lttv_iattribute_deep_copy(LTTV_IATTRIBUTE(s_orig->a)));
return s;
}
for(i=0;i<s->traces->len;i++) {
LttvTrace *trace = g_ptr_array_index(s->traces, i);
lttv_trace_unref(trace);
+ // todo mdenis 2012-03-27: uncomment when babeltrace gets fixed
+ //bt_context_remove_trace(lttv_traceset_get_context(s), trace->id);
if(lttv_trace_get_ref_number(trace) == 0)
lttv_trace_destroy(trace);
}
g_ptr_array_free(s->traces, TRUE);
+ bt_context_put(s->context);
g_object_unref(s->a);
g_free(s);
}
+struct bt_context *lttv_traceset_get_context(LttvTraceset *s)
+{
+ return s->context;
+}
+
+LttvTraceset *lttv_trace_get_traceset(LttvTrace *trace)
+{
+ return trace->traceset;
+}
+
+LttvHooks *lttv_traceset_get_hooks(LttvTraceset *s)
+{
+ return s->event_hooks;
+}
+
void lttv_trace_destroy(LttvTrace *t)
{
g_object_unref(t->a);
g_free(t);
}
-
void lttv_traceset_add(LttvTraceset *s, LttvTrace *t)
{
t->ref_count++;
g_ptr_array_add(s->traces, t);
}
+int lttv_traceset_add_path(LttvTraceset *ts, char *trace_path)
+{
+
+ FTS *tree;
+ FTSENT *node;
+ char * const paths[2] = { trace_path, NULL };
+ int ret = -1;
+
+ gboolean metaFileFound = FALSE;
+
+ tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0);
+ if (tree == NULL) {
+ g_warning("Cannot traverse \"%s\" for reading.\n",
+ trace_path);
+ return ret;
+ }
+
+ int dirfd, metafd;
+ while ((node = fts_read(tree))) {
+
+ if (!(node->fts_info & FTS_D))
+ continue;
+
+ dirfd = open(node->fts_accpath, 0);
+ if (dirfd < 0) {
+ g_warning("Unable to open trace "
+ "directory file descriptor : %s.", node->fts_accpath);
+ ret = dirfd;
+ goto error;
+ }
+
+ // Check if a metadata file exists in the current directory
+ metafd = openat(dirfd, "metadata", O_RDONLY);
+ if (metafd < 0) {
+ ret = close(dirfd);
+ if (ret < 0) {
+ g_warning("Unable to open metadata "
+ "file descriptor : %s.", node->fts_accpath);
+ goto error;
+ }
+ } else {
+ ret = close(metafd);
+ if (ret < 0) {
+ g_warning("Unable to close metadata "
+ "file descriptor : %s.", node->fts_accpath);
+ goto error;
+ }
+ ret = close(dirfd);
+ if (ret < 0) {
+ g_warning("Unable to close trace "
+ "directory file descriptor : %s.", node->fts_accpath);
+ goto error;
+ }
+
+ ret = lttv_traceset_create_trace(ts, node->fts_accpath);
+ if (ret < 0) {
+ g_warning("Opening trace \"%s\" from %s "
+ "for reading.", node->fts_accpath, trace_path);
+ goto error;
+ }
+ metaFileFound = TRUE;
+ }
+ }
+
+error:
+ ret = fts_close(tree);
+ if (ret < 0) {
+ g_warning("Unable to close tree "
+ "file descriptor : %s.", trace_path);
+ }
+ if(metaFileFound)
+ return ret;
+ else
+ return -1;
+}
+
unsigned lttv_traceset_number(LttvTraceset *s)
{
g_assert(s->traces->len > i);
t = (LttvTrace *)s->traces->pdata[i];
t->ref_count--;
+ bt_context_remove_trace(lttv_traceset_get_context(s), t->id);
g_ptr_array_remove_index(s->traces, i);
}
}
-LttTrace *lttv_trace(LttvTrace *t)
+gint lttv_trace_get_id(LttvTrace *t)
{
- return t->t;
+ return t->id;
}
guint lttv_trace_get_ref_number(LttvTrace * t)
{
+ // todo mdenis: adapt to babeltrace
return t->ref_count;
}
return t->ref_count;
}
+guint lttv_trace_get_num_cpu(LttvTrace *t)
+{
+#warning "TODO - Set the right number of CPU"
+ return 24;
+}
+
+LttvTracesetPosition *lttv_traceset_create_position(LttvTraceset *traceset)
+{
+ LttvTracesetPosition *traceset_pos;
+
+ traceset_pos = g_new(LttvTracesetPosition, 1);
+
+ /* Check in the new passed */
+ if(traceset_pos == NULL) {
+ return NULL;
+ }
+
+ traceset_pos->iter = traceset->iter;
+ traceset_pos->bt_pos = bt_iter_get_pos(bt_ctf_get_iter(traceset->iter));
+
+ return traceset_pos;
+}
+
+void lttv_traceset_destroy_position(LttvTracesetPosition *traceset_pos)
+{
+ bt_iter_free_pos(traceset_pos->bt_pos);
+ g_free(traceset_pos);
+}
+
+void lttv_traceset_seek_to_position(LttvTracesetPosition *traceset_pos)
+{
+ bt_iter_set_pos(traceset_pos->iter, traceset_pos->bt_pos);
+}
+
+guint lttv_traceset_get_cpuid_from_event(LttvEvent *event)
+{
+ struct definition *scope;
+ unsigned long timestamp;
+ unsigned int cpu_id;
+
+ struct bt_ctf_event *ctf_event = event->bt_event;
+ timestamp = bt_ctf_get_timestamp(ctf_event);
+ if (timestamp == -1ULL) {
+ return 0;
+ }
+ scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
+ if (bt_ctf_field_get_error()) {
+ return 0;
+ }
+ cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(ctf_event, scope, "cpu_id"));
+ if (bt_ctf_field_get_error()) {
+ return 0;
+ } else {
+ return cpu_id;
+ }
+}
+/*
+ * lttv_traceset_get_timestamp_begin : returns the minimum timestamp of
+ * all the traces in the traceset.
+ *
+ */
+
+guint64 lttv_traceset_get_timestamp_begin(LttvTraceset *traceset)
+{
+ struct bt_context *bt_ctx;
+ bt_ctx = lttv_traceset_get_context(traceset);
+ guint64 timestamp_min = G_MAXUINT64, timestamp_cur = 0;
+ int i;
+ int trace_count;
+ LttvTrace *currentTrace;
+ trace_count = traceset->traces->len;
+ if(trace_count == 0)
+ timestamp_min = 0;
+ else{
+ timestamp_min = G_MAXUINT64;
+
+ for(i = 0; i < trace_count;i++)
+ {
+ currentTrace = g_ptr_array_index(traceset->traces,i);
+ timestamp_cur = bt_trace_handle_get_timestamp_begin(bt_ctx, currentTrace->id);
+ if(timestamp_cur < timestamp_min)
+ timestamp_min = timestamp_cur;
+ }
+ }
+ return timestamp_min;
+}
+
+/*
+ * lttv_traceset_get_timestamp_end: returns the maximum timestamp of
+ * all the traces in the traceset.
+ *
+ */
+guint64 lttv_traceset_get_timestamp_end(LttvTraceset *traceset)
+{
+ struct bt_context *bt_ctx;
+ bt_ctx = lttv_traceset_get_context(traceset);
+ guint64 timestamp_max, timestamp_cur = 0;
+ int i;
+ int trace_count;
+ LttvTrace *currentTrace;
+ trace_count = traceset->traces->len;
+
+ if(trace_count == 0)
+ timestamp_max = 1;
+ else
+ {
+ timestamp_max = 0;
+ for(i =0; i < trace_count;i++)
+ {
+ currentTrace = g_ptr_array_index(traceset->traces,i);
+ timestamp_cur = bt_trace_handle_get_timestamp_end(bt_ctx, currentTrace->id);
+ if(timestamp_cur > timestamp_max)
+ timestamp_max = timestamp_cur;
+ }
+ }
+ return timestamp_max;
+}
+
+/*
+ * lttv_traceset_get_time_span : return a TimeInterval representing the
+ * minimum timestamp dans le maximum timestamp of the traceset.
+ *
+ */
+TimeInterval lttv_traceset_get_time_span(LttvTraceset *ts)
+{
+ TimeInterval time_span;
+ time_span.start_time =ltt_time_from_uint64( lttv_traceset_get_timestamp_begin(ts));
+ time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts));
+ return time_span;
+}
+
+const char *lttv_traceset_get_name_from_event(LttvEvent *event)
+{
+ return bt_ctf_event_name(event->bt_event);
+}
projects / lttv.git / blobdiff