CTF trace open/close

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/converter/babeltrace.c b/converter/babeltrace.c
index 63ade113c81f719a1cb4b1a5b0178a5567fb826b..b603dee53e22a555b0f7b94c9dda7e3651c71ddf 100644 (file)
--- a/converter/babeltrace.c
+++ b/converter/babeltrace.c
@@ -21,15 +21,27 @@
 #include <popt.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <popt.h>
 #include <errno.h>
 #include <stdlib.h>

+#include <ctype.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>

 
 

-static const char *opt_input_format;
-static const char *opt_output_format;
+static char *opt_input_format;
+static char *opt_output_format;

 
 static const char *opt_input_path;
 static const char *opt_output_path;
 
 int babeltrace_verbose, babeltrace_debug;
 
 
 static const char *opt_input_path;
 static const char *opt_output_path;
 
 int babeltrace_verbose, babeltrace_debug;
 

+void strlower(char *str)
+{
+       while (*str) {
+               *str = tolower(*str);
+               str++;
+       }
+}
+

 enum {
        OPT_NONE = 0,
        OPT_HELP,
 enum {
        OPT_NONE = 0,
        OPT_HELP,


@@ -79,12 +91,12 @@ static void usage(FILE *fp)
  * Return 0 if caller should continue, < 0 if caller should return
  * error, > 0 if caller should exit without reporting error.
  */
  * Return 0 if caller should continue, < 0 if caller should return
  * error, > 0 if caller should exit without reporting error.
  */

-static int parse_options(int argc, const char **argv)
+static int parse_options(int argc, char **argv)

 {
        poptContext pc;
        int opt, ret = 0;
 
 {
        poptContext pc;
        int opt, ret = 0;
 

-       pc = poptGetContext(NULL, argc, argv, long_options, 0);
+       pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);

        poptReadDefaultConfig(pc, 0);
 
        while ((opt = poptGetNextOpt(pc)) != -1) {
        poptReadDefaultConfig(pc, 0);
 
        while ((opt = poptGetNextOpt(pc)) != -1) {


@@ -126,13 +138,15 @@ end:
        return ret;
 }
 
        return ret;
 }
 

-int main(int argc, const char **argv)
+int main(int argc, char **argv)

 {
        int ret;
 {
        int ret;

+       struct format *fmt_read, *fmt_write;
+       struct trace_descriptor *td_read, *td_write;

 
        ret = parse_options(argc, argv);
        if (ret < 0) {
 
        ret = parse_options(argc, argv);
        if (ret < 0) {

-               fprintf(stdout, "Error parsing options.\n");
+               fprintf(stdout, "Error parsing options.\n\n");

                usage(stdout);
                exit(EXIT_FAILURE);
        } else if (ret > 0) {
                usage(stdout);
                exit(EXIT_FAILURE);
        } else if (ret > 0) {


@@ -141,12 +155,60 @@ int main(int argc, const char **argv)
        printf_verbose("Verbose mode active.\n");
        printf_debug("Debug mode active.\n");
 
        printf_verbose("Verbose mode active.\n");
        printf_debug("Debug mode active.\n");
 

+       if (opt_input_format)
+               strlower(opt_input_format);
+       if (opt_output_format)
+               strlower(opt_output_format);
+

        printf_verbose("Converting from file: %s\n", opt_input_path);
        printf_verbose("Converting from format: %s\n",
                opt_input_format ? : "<autodetect>");
        printf_verbose("Converting to file: %s\n", opt_output_path);
        printf_verbose("Converting to format: %s\n",
        printf_verbose("Converting from file: %s\n", opt_input_path);
        printf_verbose("Converting from format: %s\n",
                opt_input_format ? : "<autodetect>");
        printf_verbose("Converting to file: %s\n", opt_output_path);
        printf_verbose("Converting to format: %s\n",

-               opt_output_format ? : "CTF");
+               opt_output_format ? : "ctf");
+
+       if (!opt_input_format) {
+               fprintf(stdout, "Error: input format autodetection not implemented yet.\n\n");
+               usage(stdout);
+               exit(EXIT_FAILURE);
+       }
+       fmt_read = bt_lookup_format(g_quark_from_static_string(opt_input_format));
+       if (!fmt_read) {
+               fprintf(stdout, "Error: format \"%s\" is not supported.\n\n",
+                       opt_input_format);
+               exit(EXIT_FAILURE);
+       }
+       if (!opt_output_format)
+               opt_output_format = "ctf";
+       fmt_write = bt_lookup_format(g_quark_from_static_string(opt_output_format));
+       if (!fmt_write) {
+               fprintf(stdout, "Error: format \"%s\" is not supported.\n\n",
+                       opt_output_format);
+               exit(EXIT_FAILURE);
+       }
+
+       td_read = fmt_read->open_trace(opt_input_path, O_RDONLY);
+       if (!td_read) {
+               fprintf(stdout, "Error opening trace \"%s\" for reading.\n\n",
+                       opt_input_path);
+               goto error_td_read;
+       }
+
+       td_write = fmt_write->open_trace(opt_output_path, O_WRONLY);
+       if (!td_write) {
+               fprintf(stdout, "Error opening trace \"%s\" for writing.\n\n",
+                       opt_output_path);
+               goto error_td_write;
+       }
+
+       fmt_write->close_trace(td_write);
+       fmt_read->close_trace(td_read);
+       exit(EXIT_SUCCESS);

 
 

-       return 0;
+       /* Error handling */
+       fmt_write->close_trace(td_write);
+error_td_write:
+       fmt_read->close_trace(td_read);
+error_td_read:
+       exit(EXIT_FAILURE);

 }
 }

diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c
index 57357b792aa2a117f2242464e429f8adc4e659ff..f5ad955e0e417ccfdb12d928eeee880bc03ad08d 100644 (file)
--- a/formats/ctf/ctf.c
+++ b/formats/ctf/ctf.c
@@ -18,6 +18,20 @@
 
 #include <babeltrace/format.h>
 #include <babeltrace/ctf/types.h>
 
 #include <babeltrace/format.h>
 #include <babeltrace/ctf/types.h>

+#include <babeltrace/ctf/metadata.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <glib.h>
+
+struct trace_descriptor {
+       struct ctf_trace ctf_trace;
+};
+
+struct trace_descriptor *ctf_open_trace(const char *path, int flags);
+void ctf_close_trace(struct trace_descriptor *descriptor);

 
 static struct format ctf_format = {
        .uint_read = ctf_uint_read,
 
 static struct format ctf_format = {
        .uint_read = ctf_uint_read,


@@ -41,8 +55,94 @@ static struct format ctf_format = {
        .array_end = ctf_array_end,
        .sequence_begin = ctf_sequence_begin,
        .sequence_end = ctf_sequence_end,
        .array_end = ctf_array_end,
        .sequence_begin = ctf_sequence_begin,
        .sequence_end = ctf_sequence_end,

+       .open_trace = ctf_open_trace,
+       .close_trace = ctf_close_trace,

 };
 
 };
 

+static
+int ctf_open_trace_read(struct trace_descriptor *td, const char *path, int flags)
+{
+       int ret;
+
+       td->ctf_trace.flags = flags;
+
+       /* Open trace directory */
+       td->ctf_trace.dir = opendir(path);
+       if (!td->ctf_trace.dir) {
+               fprintf(stdout, "Unable to open trace directory.\n");
+               ret = -ENOENT;
+               goto error;
+       }
+
+
+
+       /*
+        * Open each stream: for each file, try to open, check magic
+        * number, and get the stream ID to add to the right location in
+        * the stream array.
+        *
+        * Keep the metadata file separate.
+        */
+
+
+
+       /*
+        * Use the metadata file to populate the trace metadata.
+        */
+
+
+       return 0;
+error:
+       return ret;
+}
+
+static
+int ctf_open_trace_write(struct trace_descriptor *td, const char *path, int flags)
+{
+       int ret;
+
+       ret = mkdir(path, S_IRWXU|S_IRWXG);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+
+struct trace_descriptor *ctf_open_trace(const char *path, int flags)
+{
+       struct trace_descriptor *td;
+       int ret;
+
+       td = g_new(struct trace_descriptor, 1);
+
+       switch (flags) {
+       case O_RDONLY:
+               ret = ctf_open_trace_read(td, path, flags);
+               if (ret)
+                       goto error;
+               break;
+       case O_WRONLY:
+               ret = ctf_open_trace_write(td, path, flags);
+               if (ret)
+                       goto error;
+               break;
+       default:
+               fprintf(stdout, "Incorrect open flags.\n");
+               goto error;
+       }
+
+       return td;
+error:
+       g_free(td);
+       return NULL;
+}
+
+void ctf_close_trace(struct trace_descriptor *td)
+{
+       closedir(td->ctf_trace.dir);
+       g_free(td);
+}
+

 void __attribute__((constructor)) ctf_init(void)
 {
        int ret;
 void __attribute__((constructor)) ctf_init(void)
 {
        int ret;

diff --git a/include/babeltrace/ctf/metadata.h b/include/babeltrace/ctf/metadata.h
index c774d7fb357eae64f4997b08a7e8a3884931b2c4..91987a9b30db36016647bc4c20e8e7f381356f14 100644 (file)
--- a/include/babeltrace/ctf/metadata.h
+++ b/include/babeltrace/ctf/metadata.h
@@ -20,6 +20,8 @@
  */
 
 #include <babeltrace/types.h>
  */
 
 #include <babeltrace/types.h>

+#include <sys/types.h>
+#include <dirent.h>

 #include <uuid/uuid.h>
 #include <assert.h>
 #include <glib.h>
 #include <uuid/uuid.h>
 #include <assert.h>
 #include <glib.h>


@@ -60,6 +62,10 @@ struct ctf_trace {
                CTF_TRACE_minor =       (1U << 1),
                CTF_TRACE_uuid  =       (1U << 2),
        } field_mask;
                CTF_TRACE_minor =       (1U << 1),
                CTF_TRACE_uuid  =       (1U << 2),
        } field_mask;

+
+       /* Information about trace backing directory and files */
+       DIR *dir;
+       int flags;              /* open flags */

 };
 
 #define CTF_STREAM_SET_FIELD(ctf_stream, field)                                \
 };
 
 #define CTF_STREAM_SET_FIELD(ctf_stream, field)                                \


@@ -100,6 +106,11 @@ struct ctf_stream {
        enum {                                  /* Fields populated mask */
                CTF_STREAM_stream_id =  (1 << 0),
        } field_mask;
        enum {                                  /* Fields populated mask */
                CTF_STREAM_stream_id =  (1 << 0),
        } field_mask;

+
+       /* Information about stream backing file */
+       int fd;
+       char *mmap;                             /* current stream mmap */
+       struct stream_pos pos;                  /* current stream position */

 };
 
 #define CTF_EVENT_SET_FIELD(ctf_event, field)                          \
 };
 
 #define CTF_EVENT_SET_FIELD(ctf_event, field)                          \

diff --git a/include/babeltrace/format.h b/include/babeltrace/format.h
index 590ab4cb1cca73ef14c14aff98d3e7d45a261b35..cddc41a129e32bda61915df26c2b46367e5a8201 100644 (file)
--- a/include/babeltrace/format.h
+++ b/include/babeltrace/format.h
@@ -24,6 +24,8 @@
 #include <stdio.h>
 #include <glib.h>
 
 #include <stdio.h>
 #include <glib.h>
 

+struct trace_descriptor;
+

 struct format {
        GQuark name;
 
 struct format {
        GQuark name;
 


@@ -80,6 +82,8 @@ struct format {
                const struct declaration_sequence *sequence_declaration);
        void (*sequence_end)(struct stream_pos *pos,
                const struct declaration_sequence *sequence_declaration);
                const struct declaration_sequence *sequence_declaration);
        void (*sequence_end)(struct stream_pos *pos,
                const struct declaration_sequence *sequence_declaration);

+       struct trace_descriptor *(*open_trace)(const char *path, int flags);
+       void (*close_trace)(struct trace_descriptor *descriptor);

 };
 
 struct format *bt_lookup_format(GQuark qname);
 };
 
 struct format *bt_lookup_format(GQuark qname);