babeltrace lib cleanup, folded with open/remove trace functions
authorMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Fri, 10 Feb 2012 17:01:01 +0000 (12:01 -0500)
committerMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Fri, 10 Feb 2012 17:01:01 +0000 (12:01 -0500)
Folded patch from Yannick Brosseau <yannick.brosseau@gmail.com>, along
with various updates and cleanups, related to babeltrace lib.

Original changelog from Yannick Brosseau:
Move the trace_collection into its own file.
Port the converter to uses the new functions

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
converter/babeltrace.c
include/babeltrace/context.h
include/babeltrace/trace-collection.h [new file with mode: 0644]
include/babeltrace/trace-handle-internal.h
include/babeltrace/trace-handle.h
lib/Makefile.am
lib/context.c
lib/iterator.c
lib/trace-collection.c [new file with mode: 0644]
lib/trace-handle.c

index f75a7976a9523cbc2b44de83ffb0d50f6bb4d03e..4bfd430574c6abcb98f8a683bbb3db72df72ee9f 100644 (file)
@@ -47,7 +47,6 @@ static char *opt_output_format;
 static const char *opt_input_path;
 static const char *opt_output_path;
 
-static struct trace_collection trace_collection_read;
 static struct format *fmt_read;
 
 void strlower(char *str)
@@ -296,187 +295,9 @@ end:
        return ret;
 }
 
-static void init_trace_collection(struct trace_collection *tc)
-{
-       tc->array = g_ptr_array_sized_new(DEFAULT_FILE_ARRAY_SIZE);
-       tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
-       tc->single_clock_offset_avg = 0;
-       tc->offset_first = 0;
-       tc->delta_offset_first_sum = 0;
-       tc->offset_nr = 0;
-}
 
-/*
- * finalize_trace_collection() closes the opened traces for read
- * and free the memory allocated for trace collection
- */
-static void finalize_trace_collection(struct trace_collection *tc)
-{
-       int i;
-
-       for (i = 0; i < tc->array->len; i++) {
-               struct trace_descriptor *temp =
-                       g_ptr_array_index(tc->array, i);
-               fmt_read->close_trace(temp);
-       }
-       g_ptr_array_free(tc->array, TRUE);
-       g_hash_table_destroy(tc->clocks);
-}
 
-struct clock_match {
-       GHashTable *clocks;
-       struct ctf_clock *clock_match;
-       struct trace_collection *tc;
-};
 
-static void check_clock_match(gpointer key, gpointer value, gpointer user_data)
-{
-       struct clock_match *match = user_data;
-       struct ctf_clock *clock_a = value, *clock_b;
-
-       if (clock_a->uuid != 0) {
-               /*
-                * Lookup the the trace clocks into the collection
-                * clocks.
-                */
-               clock_b = g_hash_table_lookup(match->clocks,
-                       (gpointer) (unsigned long) clock_a->uuid);
-               if (clock_b) {
-                       match->clock_match = clock_b;
-                       return;
-               }
-       } else if (clock_a->absolute) {
-               /*
-                * Absolute time references, such as NTP, are looked up
-                * by clock name.
-                */
-               clock_b = g_hash_table_lookup(match->clocks,
-                       (gpointer) (unsigned long) clock_a->name);
-               if (clock_b) {
-                       match->clock_match = clock_b;
-                       return;
-               }
-       }
-}
-
-static void clock_add(gpointer key, gpointer value, gpointer user_data)
-{
-       struct clock_match *clock_match = user_data;
-       GHashTable *tc_clocks = clock_match->clocks;
-       struct ctf_clock *t_clock = value;
-       GQuark v;
-
-       if (t_clock->absolute)
-               v = t_clock->name;
-       else
-               v = t_clock->uuid;
-       if (v) {
-               struct ctf_clock *tc_clock;
-
-               tc_clock = g_hash_table_lookup(tc_clocks,
-                               (gpointer) (unsigned long) v);
-               if (!tc_clock) {
-                       /*
-                        * For now, we only support CTF that has one
-                        * single clock uuid or name (absolute ref).
-                        */
-                       if (g_hash_table_size(tc_clocks) > 0) {
-                               fprintf(stderr, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
-                       }
-                       if (!clock_match->tc->offset_nr) {
-                               clock_match->tc->offset_first =
-                                       (t_clock->offset_s * 1000000000ULL) + t_clock->offset;
-                               clock_match->tc->delta_offset_first_sum = 0;
-                               clock_match->tc->offset_nr++;
-                               clock_match->tc->single_clock_offset_avg =
-                                       clock_match->tc->offset_first;
-                       }
-                       g_hash_table_insert(tc_clocks,
-                               (gpointer) (unsigned long) v,
-                               value);
-               } else {
-                       int64_t diff_ns;
-
-                       /*
-                        * Check that the offsets match. If not, warn
-                        * the user that we do an arbitrary choice.
-                        */
-                       diff_ns = tc_clock->offset_s;
-                       diff_ns -= t_clock->offset_s;
-                       diff_ns *= 1000000000ULL;
-                       diff_ns += tc_clock->offset;
-                       diff_ns -= t_clock->offset;
-                       printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
-                               g_quark_to_string(tc_clock->name),
-                               diff_ns < 0 ? -diff_ns : diff_ns);
-                       if (diff_ns > 10000) {
-                               fprintf(stderr, "[warning] Clock \"%s\" offset differs between traces (delta %" PRIu64 " ns). Using average.\n",
-                                       g_quark_to_string(tc_clock->name),
-                                       diff_ns < 0 ? -diff_ns : diff_ns);
-                       }
-                       /* Compute average */
-                       clock_match->tc->delta_offset_first_sum +=
-                               (t_clock->offset_s * 1000000000ULL) + t_clock->offset
-                               - clock_match->tc->offset_first;
-                       clock_match->tc->offset_nr++;
-                       clock_match->tc->single_clock_offset_avg =
-                               clock_match->tc->offset_first
-                               + (clock_match->tc->delta_offset_first_sum / clock_match->tc->offset_nr);
-               }
-       }
-}
-
-/*
- * Whenever we add a trace to the trace collection, check that we can
- * correlate this trace with at least one other clock in the trace.
- */
-static int trace_collection_add(struct trace_collection *tc,
-                               struct trace_descriptor *td)
-{
-       struct ctf_trace *trace = container_of(td, struct ctf_trace, parent);
-
-       g_ptr_array_add(tc->array, td);
-       trace->collection = tc;
-
-       if (tc->array->len > 1) {
-               struct clock_match clock_match = {
-                       .clocks = tc->clocks,
-                       .clock_match = NULL,
-                       .tc = NULL,
-               };
-
-               /*
-                * With two or more traces, we need correlation info
-                * avalable.
-                */
-               g_hash_table_foreach(trace->clocks,
-                               check_clock_match,
-                               &clock_match);
-               if (!clock_match.clock_match) {
-                       fprintf(stderr, "[error] No clocks can be correlated and multiple traces are added to the collection.\n");
-                       goto error;
-               }
-       }
-
-       {
-               struct clock_match clock_match = {
-                       .clocks = tc->clocks,
-                       .clock_match = NULL,
-                       .tc = tc,
-               };
-
-               /*
-                * Add each clock from the trace clocks into the trace
-                * collection clocks.
-                */
-               g_hash_table_foreach(trace->clocks,
-                               clock_add,
-                               &clock_match);
-       }
-       return 0;
-error:
-       return -EPERM;
-}
 
 int convert_trace(struct trace_descriptor *td_write,
                  struct bt_context *ctx)
@@ -515,52 +336,6 @@ error_iter:
        return ret;
 }
 
-
-/*
- * traverse_dir() is the callback functiion for File Tree Walk (nftw).
- * it receives the path of the current entry (file, dir, link..etc) with
- * a flag to indicate the type of the entry.
- * if the entry being visited is a directory and contains a metadata file,
- * then open it for reading and save a trace_descriptor to that directory
- * in the read trace collection.
- */
-static int traverse_dir(const char *fpath, const struct stat *sb,
-                       int tflag, struct FTW *ftwbuf)
-{
-       int dirfd;
-       int fd;
-       struct trace_descriptor *td_read;
-       int ret;
-
-       if (tflag != FTW_D)
-               return 0;
-       dirfd = open(fpath, 0);
-       if (dirfd < 0) {
-               fprintf(stderr, "[error] unable to open trace "
-                       "directory file descriptor.\n");
-               return -1;
-       }
-       fd = openat(dirfd, "metadata", O_RDONLY);
-       if (fd < 0) {
-               close(dirfd);
-       } else {
-               close(fd);
-               close(dirfd);
-               td_read = fmt_read->open_trace(fpath, O_RDONLY,
-                               ctf_move_pos_slow, NULL);
-               if (!td_read) {
-                       fprintf(stderr, "Error opening trace \"%s\" "
-                                       "for reading.\n\n", fpath);
-                       return -1;      /* error */
-               }
-               ret = trace_collection_add(&trace_collection_read, td_read);
-               if (ret) {
-                       return -1;
-               }
-       }
-       return 0;       /* success */
-}
-
 int main(int argc, char **argv)
 {
        int ret;
@@ -609,30 +384,16 @@ int main(int argc, char **argv)
                exit(EXIT_FAILURE);
        }
 
-       /*
-        * pass the input path to nftw() .
-        * specify traverse_dir() as the callback function.
-        * depth = 10 which is the max number of file descriptors
-        * that nftw() can open at a given time.
-        * flags = 0  check nftw documentation for more info .
-        */
-       init_trace_collection(&trace_collection_read);
-       ret = nftw(opt_input_path, traverse_dir, 10, 0);
-       if (ret != 0) {
+       ctx = bt_context_create();
+
+       ret = bt_context_add_traces(ctx, opt_input_path,
+                       opt_input_format);
+       if (ret) {
                fprintf(stderr, "[error] opening trace \"%s\" for reading.\n\n",
                        opt_input_path);
                goto error_td_read;
        }
-       if (trace_collection_read.array->len == 0) {
-               fprintf(stderr, "[warning] no metadata file was found."
-                                               " no output was generated\n");
-               return 0;
-       }
-       ctx = bt_context_create(&trace_collection_read);
-       if (!ctx) {
-               fprintf(stderr, "Error allocating a new context\n");
-               goto error_td_read;
-       }
+
        td_write = fmt_write->open_trace(opt_output_path, O_RDWR, NULL, NULL);
        if (!td_write) {
                fprintf(stderr, "Error opening trace \"%s\" for writing.\n\n",
@@ -647,8 +408,8 @@ int main(int argc, char **argv)
        }
 
        fmt_write->close_trace(td_write);
-       finalize_trace_collection(&trace_collection_read);
-       bt_context_destroy(ctx);
+
+       bt_context_put(ctx);
        printf_verbose("finished converting. Output written to:\n%s\n",
                        opt_output_path ? : "<stdout>");
        exit(EXIT_SUCCESS);
@@ -657,7 +418,7 @@ int main(int argc, char **argv)
 error_copy_trace:
        fmt_write->close_trace(td_write);
 error_td_write:
-       finalize_trace_collection(&trace_collection_read);
+       bt_context_put(ctx);
 error_td_read:
        exit(EXIT_FAILURE);
 }
index 445af4f39c609aaa98284e89a877476626b434ae..d50916762e122eaebb27211164fef5f307aa373c 100644 (file)
  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *         Julien Desfossez <julien.desfossez@efficios.com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
  */
 
 struct trace_collection;
+struct GHashTable;
 
 /*
- * The context represents the object in which a trace_collection is open. As
- * long as this structure is allocated, the trace_collection is open and the
- * traces it contains can be read and seeked by the iterators and callbacks.
+ * The context represents the object in which a trace_collection is
+ * open. As long as this structure is allocated, the trace_collection is
+ * open and the traces it contains can be read and seeked by the
+ * iterators and callbacks.
  *
- * It has to be created with the bt_context_create() function and destroyed by
- * bt_context_destroy()
+ * It has to be created with the bt_context_create() function and
+ * destroyed by calling one more bt_context_put() than bt_context_get()
  */
 struct bt_context {
        struct trace_collection *tc;
+       GHashTable *trace_handles;
        int refcount;
        int last_trace_handle_id;
 };
@@ -41,37 +45,54 @@ struct bt_context {
 /*
  * bt_context_create : create a Babeltrace context
  *
- * Allocate a new context and assign the trace_collection passed in
- * parameter as the context trace_collection. The trace_collection
- * must contain an array of valid trace_descriptors. The creation of
- * the context sets the refcount to 1.
+ * Allocate a new context. The creation of the context sets the refcount
+ * to 1.
  *
  * Returns an allocated context on success and NULL on error
  */
-struct bt_context *bt_context_create(struct trace_collection *tc);
+struct bt_context *bt_context_create(void);
 
 /*
- * bt_context_destroy : destroy a context
+ * bt_context_add_trace : Add a trace by path to the context
  *
- * If the context is still in use (by an iterator or a callback), the
- * destroy fails and returns -1, on success : return 0.
+ * Open a trace
+ *
+ * Return the trace handle id of the opened trace
+ */
+int bt_context_add_trace(struct bt_context *ctx, const char *path,
+               const char *format);
+
+/*
+ * bt_context_add_traces: Open a trace recursively
+ *
+ * Find each trace presents in the subdirectory starting from the given path
+ *
+ * Return: 0 on success, nonzero on failure.
+ * The caller has the responsiblity to free the array
+ */
+int bt_context_add_traces(struct bt_context *ctx, const char *path,
+               const char *format);
+
+/*
+ * bt_context_remove_trace: Remove a trace from the context.
+ *
+ * Effectively closing the trace.
  */
-int bt_context_destroy(struct bt_context *ctx);
+void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
 
 /*
- * bt_context_get and bt_context_put : increments and decrement the refcount of
- * the context
+ * bt_context_get and bt_context_put : increments and decrement the
+ * refcount of the context
  *
- * These functions ensures that the context won't be destroyed when it is in
- * use. The same number of get and put has to be done to be able to destroy a
- * context.
+ * These functions ensures that the context won't be destroyed when it
+ * is in use. The same number of get and put (plus one extra put to
+ * release the initial reference done at creation) has to be done to
+ * destroy a context.
  *
- * Return 0 on success, -1 if the context pointer is invalid.  When the context
- * refcount is decremented to 0 by a bt_context_put, it calls
- * bt_context_destroy to free the context. In this case the return code of
- * bt_context_destroy is returned.
+ * When the context refcount is decremented to 0 by a bt_context_put,
+ * the context is freed.
  */
-int bt_context_get(struct bt_context *ctx);
-int bt_context_put(struct bt_context *ctx);
+void bt_context_get(struct bt_context *ctx);
+void bt_context_put(struct bt_context *ctx);
 
 #endif /* _BABELTRACE_CONTEXT_H */
diff --git a/include/babeltrace/trace-collection.h b/include/babeltrace/trace-collection.h
new file mode 100644 (file)
index 0000000..ad4b956
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef _BABELTRACE_TRACE_COLLECTION_H
+#define _BABELTRACE_TRACE_COLLECTION_H
+/*
+ * BabelTrace lib
+ *
+ * trace collection header
+ *
+ * Copyright 2012 EfficiOS Inc. and Linux Foundation
+ *
+ * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Author: Yannick Brosseau <yannick.brosseau@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ */
+
+void init_trace_collection(struct trace_collection *tc);
+void finalize_trace_collection(struct trace_collection *tc);
+int trace_collection_add(struct trace_collection *tc,
+                        struct trace_descriptor *td);
+int trace_collection_remove(struct trace_collection *tc,
+                        struct trace_descriptor *td);
+
+#endif /* _BABELTRACE_TRACE_COLLECTION_H */
index 9351367d212fb822860808aec1cd3281ba08a34d..4a56e2802b3ae280f99bf9820b48dbc5358a0456 100644 (file)
@@ -23,7 +23,9 @@
  */
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <babeltrace/context.h>
+#include <babeltrace/format.h>
 
 /*
  * trace_handle : unique identifier of a trace
@@ -33,7 +35,9 @@
  */
 struct bt_trace_handle {
        int id;
-       char *path;
+       struct trace_descriptor *td;
+       struct format *format;
+       char path[PATH_MAX];
        uint64_t timestamp_begin;
        uint64_t timestamp_end;
 };
@@ -43,7 +47,7 @@ struct bt_trace_handle {
  *
  * Returns a newly allocated trace_handle or NULL on error
  */
-struct bt_trace_handle *bt_trace_create_handle(struct bt_context *ctx);
+struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
 
 /*
  * bt_trace_handle_destroy : free a trace_handle
index 5900cc143659998a447253049a77292ad3d1682d..85b113aa6144efced1ec568413ce6f5dcb1df8a4 100644 (file)
 struct bt_trace_handle;
 
 /*
- * bt_trace_handle_get_path : returns the path of a trace_handle or
- * NULL on error
+ * bt_trace_handle_get_id: returns the id associated to the handle.
  */
-char *bt_trace_handle_get_path(struct bt_trace_handle *th);
+int bt_trace_handle_get_id(struct bt_trace_handle *th);
+
+/*
+ * bt_trace_handle_get_path : returns the path of a trace_handle.
+ */
+const char *bt_trace_handle_get_path(struct bt_trace_handle *th);
 
 /*
  * bt_trace_handle_get_timestamp_begin : returns the beginning timestamp
- * of a trace or -1ULL on error
+ * of a trace.
  */
 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_trace_handle *th);
 
 /*
- * bt_trace_handle_get_timestamp_end : returns the end timestamp of a trace
- * or -1ULL on error
+ * bt_trace_handle_get_timestamp_end : returns the end timestamp of a
+ * trace.
  */
 uint64_t bt_trace_handle_get_timestamp_end(struct bt_trace_handle *th);
 
index 26f024b447b4e50925389ccd99079cea4d4bd01e..56068fd89288493c0b393b0b0ce22ff41278f4cf 100644 (file)
@@ -8,7 +8,8 @@ libbabeltrace_la_SOURCES = babeltrace.c \
                           callbacks.c \
                           iterator.c \
                           context.c \
-                          trace-handle.c
+                          trace-handle.c \
+                          trace-collection.c
 
 libbabeltrace_la_LIBADD = \
        $(top_builddir)/types/libbabeltrace_types.la \
index 48cf216e11780f99a20b6dea27264368c9c350c3..c0479e1b31d441a4df4c9913ffece01278fe0051 100644 (file)
 
 #include <babeltrace/babeltrace.h>
 #include <babeltrace/context.h>
+#include <babeltrace/trace-handle.h>
+#include <babeltrace/trace-handle-internal.h>
+#include <babeltrace/trace-collection.h>
+#include <babeltrace/format.h>
 #include <stdlib.h>
 
-struct bt_context *bt_context_create(struct trace_collection *tc)
+#include <fts.h>
+#include <fcntl.h> /* For O_RDONLY */
+
+/* TODO ybrosseau: should be hidden in the CTF format */
+#include <babeltrace/ctf/types.h> /* for ctf_move_pos_slow */
+
+#include <glib.h>
+
+struct bt_context *bt_context_create(void)
 {
        struct bt_context *ctx;
 
-       ctx = calloc(1, sizeof(struct bt_context));
-       if (ctx == NULL) {
-               perror("allocating context");
-               goto error;
-       }
-
-       ctx->tc = tc;
+       ctx = g_new0(struct bt_context, 1);
        ctx->refcount = 1;
+       /* Negative handle id are errors. */
        ctx->last_trace_handle_id = 0;
 
+       /* Instanciate the trace handle container */
+       ctx->trace_handles = g_hash_table_new_full(g_direct_hash,
+                               g_direct_equal, NULL,
+                               (GDestroyNotify) bt_trace_handle_destroy);
+
+       ctx->tc = g_new0(struct trace_collection, 1);
+       init_trace_collection(ctx->tc);
+
        return ctx;
+}
 
-error:
-       return NULL;
+int bt_context_add_trace(struct bt_context *ctx, const char *path,
+               const char *format_str)
+{
+       struct trace_descriptor *td;
+       struct format *fmt;
+       struct bt_trace_handle *handle;
+
+       fmt = bt_lookup_format(g_quark_from_string(format_str));
+       td = fmt->open_trace(path, O_RDONLY,
+                            ctf_move_pos_slow, NULL);
+       if (!td) {
+               fprintf(stdout, "[error] [Context] Cannot Open_trace of the format %s .\n\n",
+                               path);
+               return 0;
+       }
+
+       /* Create an handle for the trace */
+       handle = bt_trace_handle_create(ctx);
+       if (handle < 0) {
+               fprintf(stdout, "[error] [Context] Creating trace handle %s .\n\n",
+                               path);
+               return 0;
+       }
+       handle->format = fmt;
+       handle->td = td;
+       strncpy(handle->path, path, PATH_MAX);
+       handle->path[PATH_MAX - 1] = '\0';
+
+       /* Add new handle to container */
+       g_hash_table_insert(ctx->trace_handles,
+               (gpointer) (unsigned long) handle->id,
+               handle);
+       trace_collection_add(ctx->tc, td);
+       return handle->id;
 }
 
-int bt_context_destroy(struct bt_context *ctx)
+/*
+ * Unable to open toplevel: failure.
+ * Unable to open some subdirectory or file: warn and continue;
+ */
+int bt_context_add_traces(struct bt_context *ctx, const char *path,
+               const char *format_str)
 {
-       if (ctx) {
-               if (ctx->refcount >= 1)
-                       goto ctx_used;
+       FTS *tree;
+       FTSENT *node;
+       GArray *trace_ids;
+       char lpath[PATH_MAX];
+       char * const paths[2] = { lpath, NULL };
+       int ret;
+
+       /*
+        * Need to copy path, because fts_open can change it.
+        * It is the pointer array, not the strings, that are constant.
+        */
+       strncpy(lpath, path, PATH_MAX);
+       lpath[PATH_MAX - 1] = '\0';
+
+       tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0);
+       if (tree == NULL) {
+               fprintf(stdout, "[error] Cannot traverse \"%s\" for reading.\n\n",
+                               path);
+               return -EINVAL;
+       }
+
+       trace_ids = g_array_new(FALSE, TRUE, sizeof(int));
 
-               free(ctx);
+       while ((node = fts_read(tree))) {
+               int dirfd, metafd;
+
+               if (!(node->fts_info & FTS_D))
+                       continue;
+
+               dirfd = open(node->fts_accpath, 0);
+               if (dirfd < 0) {
+                       fprintf(stdout, "[warning] unable to open trace "
+                               "directory file descriptor.\n");
+                       continue;
+               }
+               metafd = openat(dirfd, "metadata", O_RDONLY);
+               if (metafd < 0) {
+                       ret = close(dirfd);
+                       if (ret < 0) {
+                               perror("close");
+                               goto error;
+                       }
+               } else {
+                       int trace_id;
+
+                       ret = close(metafd);
+                       if (ret < 0) {
+                               perror("close");
+                               goto error;
+                       }
+                       ret = close(dirfd);
+                       if (ret < 0) {
+                               perror("close");
+                               goto error;
+                       }
+
+                       trace_id = bt_context_add_trace(ctx,
+                               node->fts_accpath, format_str);
+                       if (trace_id < 0) {
+                               fprintf(stdout, "[warning] CTX opening trace \"%s\"from %s "
+                                       "for reading.\n\n", node->fts_accpath, path);
+                               continue;
+                       }
+                       g_array_append_val(trace_ids, trace_id);
+               }
        }
+
+       g_array_free(trace_ids, TRUE);
        return 0;
 
-ctx_used:
-       return -1;
+error:
+       return ret;
 }
 
-int bt_context_get(struct bt_context *ctx)
+void bt_context_remove_trace(struct bt_context *ctx, int handle_id)
 {
-       if (!ctx)
-               return -1;
-       ctx->refcount++;
-       return 0;
+       struct bt_trace_handle *handle;
+
+       handle = g_hash_table_lookup(ctx->trace_handles,
+               (gpointer) (unsigned long) handle_id);
+       assert(handle != NULL);
+
+       /* Remove from containers */
+       trace_collection_remove(ctx->tc, handle->td);
+       g_hash_table_remove(ctx->trace_handles,
+               (gpointer) (unsigned long) handle_id);
+
+       /* Close the trace */
+       handle->format->close_trace(handle->td);
+
+       /* Destory the handle */
+       bt_trace_handle_destroy(handle);
+}
+
+static
+void bt_context_destroy(struct bt_context *ctx)
+{
+       finalize_trace_collection(ctx->tc);
+
+       /* Remote all traces. The g_hash_table_destroy will call
+        * bt_trace_handle_destroy on each elements.
+        */
+       g_hash_table_destroy(ctx->trace_handles);
+
+       /* ctx->tc should always be valid */
+       assert(ctx->tc != NULL);
+       g_free(ctx->tc);
+       g_free(ctx);
 }
 
-int bt_context_put(struct bt_context *ctx)
+void bt_context_get(struct bt_context *ctx)
 {
-       if (!ctx)
-               return -1;
+       ctx->refcount++;
+}
 
+void bt_context_put(struct bt_context *ctx)
+{
        ctx->refcount--;
        if (ctx->refcount == 0)
-               return bt_context_destroy(ctx);
-       return 0;
+               bt_context_destroy(ctx);
 }
index 0ae2a1ba1b265451f50f1c9e0c44d2f314248767..3a07c1abcf1c0e75219528899977f45d6f357199 100644 (file)
@@ -73,17 +73,18 @@ int stream_compare(void *a, void *b)
 
 void bt_iter_free_pos(struct bt_iter_pos *iter_pos)
 {
-       if (iter_pos) {
-               if (iter_pos->u.restore) {
-                       if (iter_pos->u.restore->stream_saved_pos) {
-                               g_array_free(
-                                       iter_pos->u.restore->stream_saved_pos,
-                                       TRUE);
-                       }
-                       g_free(iter_pos->u.restore);
+       if (!iter_pos)
+               return;
+
+       if (iter_pos->u.restore) {
+               if (iter_pos->u.restore->stream_saved_pos) {
+                       g_array_free(
+                               iter_pos->u.restore->stream_saved_pos,
+                               TRUE);
                }
-               g_free(iter_pos);
+               g_free(iter_pos->u.restore);
        }
+       g_free(iter_pos);
 }
 
 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos)
@@ -168,17 +169,7 @@ struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter)
        int i, stream_class_id, stream_id;
 
        pos = g_new0(struct bt_iter_pos, 1);
-       if (!pos) {
-               perror("allocating bt_iter_pos");
-               goto error;
-       }
-
        pos->u.restore = g_new0(struct bt_saved_pos, 1);
-       if (!pos->u.restore) {
-               perror("allocating bt_saved_pos");
-               goto error;
-       }
-
        pos->u.restore->tc = tc;
        pos->u.restore->stream_saved_pos = g_array_new(FALSE, TRUE,
                        sizeof(struct stream_saved_pos));
@@ -331,16 +322,13 @@ struct bt_iter *bt_iter_create(struct bt_context *ctx,
        struct bt_iter *iter;
 
        iter = g_new0(struct bt_iter, 1);
-       if (!iter)
-               goto error_malloc;
        iter->stream_heap = g_new(struct ptr_heap, 1);
        iter->end_pos = end_pos;
        iter->callbacks = g_array_new(0, 1, sizeof(struct bt_stream_callbacks));
        iter->recalculate_dep_graph = 0;
        iter->main_callbacks.callback = NULL;
        iter->dep_gc = g_ptr_array_new();
-       if (bt_context_get(ctx) != 0)
-               goto error_ctx;
+       bt_context_get(ctx);
        iter->ctx = ctx;
 
        ret = heap_init(iter->stream_heap, 0, stream_compare);
@@ -394,9 +382,7 @@ error:
        heap_free(iter->stream_heap);
 error_heap_init:
        g_free(iter->stream_heap);
-error_ctx:
        g_free(iter);
-error_malloc:
        return NULL;
 }
 
diff --git a/lib/trace-collection.c b/lib/trace-collection.c
new file mode 100644 (file)
index 0000000..0ee3c29
--- /dev/null
@@ -0,0 +1,214 @@
+/*
+ * trace-collection.c
+ *
+ * Babeltrace Library
+ *
+ * Copyright 2012 EfficiOS Inc. and Linux Foundation
+ *
+ * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ */
+#include <babeltrace/babeltrace.h>
+#include <babeltrace/format.h>
+#include <babeltrace/context.h>
+#include <babeltrace/ctf/types.h>
+#include <babeltrace/ctf-text/types.h>
+#include <babeltrace/trace-collection.h>
+#include <babeltrace/ctf-ir/metadata.h>        /* for clocks */
+
+#include <inttypes.h>
+
+struct clock_match {
+       GHashTable *clocks;
+       struct ctf_clock *clock_match;
+       struct trace_collection *tc;
+};
+
+static void check_clock_match(gpointer key, gpointer value, gpointer user_data)
+{
+       struct clock_match *match = user_data;
+       struct ctf_clock *clock_a = value, *clock_b;
+
+       if (clock_a->uuid != 0) {
+               /*
+                * Lookup the the trace clocks into the collection
+                * clocks.
+                */
+               clock_b = g_hash_table_lookup(match->clocks,
+                       (gpointer) (unsigned long) clock_a->uuid);
+               if (clock_b) {
+                       match->clock_match = clock_b;
+                       return;
+               }
+       } else if (clock_a->absolute) {
+               /*
+                * Absolute time references, such as NTP, are looked up
+                * by clock name.
+                */
+               clock_b = g_hash_table_lookup(match->clocks,
+                       (gpointer) (unsigned long) clock_a->name);
+               if (clock_b) {
+                       match->clock_match = clock_b;
+                       return;
+               }
+       }
+}
+
+static void clock_add(gpointer key, gpointer value, gpointer user_data)
+{
+       struct clock_match *clock_match = user_data;
+       GHashTable *tc_clocks = clock_match->clocks;
+       struct ctf_clock *t_clock = value;
+       GQuark v;
+
+       if (t_clock->absolute)
+               v = t_clock->name;
+       else
+               v = t_clock->uuid;
+       if (v) {
+               struct ctf_clock *tc_clock;
+
+               tc_clock = g_hash_table_lookup(tc_clocks,
+                               (gpointer) (unsigned long) v);
+               if (!tc_clock) {
+                       /*
+                        * For now, we only support CTF that has one
+                        * single clock uuid or name (absolute ref).
+                        */
+                       if (g_hash_table_size(tc_clocks) > 0) {
+                               fprintf(stderr, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
+                       }
+                       if (!clock_match->tc->offset_nr) {
+                               clock_match->tc->offset_first =
+                                       (t_clock->offset_s * 1000000000ULL) + t_clock->offset;
+                               clock_match->tc->delta_offset_first_sum = 0;
+                               clock_match->tc->offset_nr++;
+                               clock_match->tc->single_clock_offset_avg =
+                                       clock_match->tc->offset_first;
+                       }
+                       g_hash_table_insert(tc_clocks,
+                               (gpointer) (unsigned long) v,
+                               value);
+               } else {
+                       int64_t diff_ns;
+
+                       /*
+                        * Check that the offsets match. If not, warn
+                        * the user that we do an arbitrary choice.
+                        */
+                       diff_ns = tc_clock->offset_s;
+                       diff_ns -= t_clock->offset_s;
+                       diff_ns *= 1000000000ULL;
+                       diff_ns += tc_clock->offset;
+                       diff_ns -= t_clock->offset;
+                       printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
+                               g_quark_to_string(tc_clock->name),
+                               diff_ns < 0 ? -diff_ns : diff_ns);
+                       if (diff_ns > 10000) {
+                               fprintf(stderr, "[warning] Clock \"%s\" offset differs between traces (delta %" PRIu64 " ns). Using average.\n",
+                                       g_quark_to_string(tc_clock->name),
+                                       diff_ns < 0 ? -diff_ns : diff_ns);
+                       }
+                       /* Compute average */
+                       clock_match->tc->delta_offset_first_sum +=
+                               (t_clock->offset_s * 1000000000ULL) + t_clock->offset
+                               - clock_match->tc->offset_first;
+                       clock_match->tc->offset_nr++;
+                       clock_match->tc->single_clock_offset_avg =
+                               clock_match->tc->offset_first
+                               + (clock_match->tc->delta_offset_first_sum / clock_match->tc->offset_nr);
+               }
+       }
+}
+
+/*
+ * Whenever we add a trace to the trace collection, check that we can
+ * correlate this trace with at least one other clock in the trace.
+ */
+int trace_collection_add(struct trace_collection *tc,
+                               struct trace_descriptor *td)
+{
+       struct ctf_trace *trace = container_of(td, struct ctf_trace, parent);
+
+       g_ptr_array_add(tc->array, td);
+       trace->collection = tc;
+
+       if (tc->array->len > 1) {
+               struct clock_match clock_match = {
+                       .clocks = tc->clocks,
+                       .clock_match = NULL,
+                       .tc = NULL,
+               };
+
+               /*
+                * With two or more traces, we need correlation info
+                * avalable.
+                */
+               g_hash_table_foreach(trace->clocks,
+                               check_clock_match,
+                               &clock_match);
+               if (!clock_match.clock_match) {
+                       fprintf(stderr, "[error] No clocks can be correlated and multiple traces are added to the collection.\n");
+                       goto error;
+               }
+       }
+
+       {
+               struct clock_match clock_match = {
+                       .clocks = tc->clocks,
+                       .clock_match = NULL,
+                       .tc = tc,
+               };
+
+               /*
+                * Add each clock from the trace clocks into the trace
+                * collection clocks.
+                */
+               g_hash_table_foreach(trace->clocks,
+                               clock_add,
+                               &clock_match);
+       }
+       return 0;
+error:
+       return -EPERM;
+}
+
+int trace_collection_remove(struct trace_collection *tc,
+                           struct trace_descriptor *td)
+{
+       if (g_ptr_array_remove(tc->array, td)) {
+               return 0;
+       } else {
+               return -1;
+       }
+
+}
+
+void init_trace_collection(struct trace_collection *tc)
+{
+       tc->array = g_ptr_array_new();
+       tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
+       tc->single_clock_offset_avg = 0;
+       tc->offset_first = 0;
+       tc->delta_offset_first_sum = 0;
+       tc->offset_nr = 0;
+}
+
+/*
+ * finalize_trace_collection() closes the opened traces for read
+ * and free the memory allocated for trace collection
+ */
+void finalize_trace_collection(struct trace_collection *tc)
+{
+       g_ptr_array_free(tc->array, TRUE);
+       g_hash_table_destroy(tc->clocks);
+}
index fce2397c0d2c4481bd7515db07ac004067e10f77..73c137b3464011ffaf8e491f567f27bebb80103f 100644 (file)
@@ -30,41 +30,32 @@ struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx)
 {
        struct bt_trace_handle *th;
 
-       th = calloc(1, sizeof(struct bt_trace_handle));
-       if (!th) {
-               perror("allocating trace_handle");
-               return NULL;
-       }
-       if (!ctx)
-               return NULL;
-
+       th = g_new0(struct bt_trace_handle, 1);
        th->id = ctx->last_trace_handle_id++;
        return th;
 }
 
-void bt_trace_handle_destroy(struct bt_trace_handle *bt)
+void bt_trace_handle_destroy(struct bt_trace_handle *th)
+{
+       g_free(th);
+}
+
+int bt_trace_handle_get_id(struct bt_trace_handle *th)
 {
-       if (bt)
-               free(bt);
+       return th->id;
 }
 
-char *bt_trace_handle_get_path(struct bt_trace_handle *th)
+const char *bt_trace_handle_get_path(struct bt_trace_handle *th)
 {
-       if (th && th->path)
-               return th->path;
-       return NULL;
+       return th->path;
 }
 
 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_trace_handle *th)
 {
-       if (th)
-               return th->timestamp_begin;
-       return -1ULL;
+       return th->timestamp_begin;
 }
 
 uint64_t bt_trace_handle_get_timestamp_end(struct bt_trace_handle *th)
 {
-       if (th)
-               return th->timestamp_end;
-       return -1ULL;
+       return th->timestamp_end;
 }
This page took 0.061292 seconds and 4 git commands to generate.