CTF trace open/close
authorMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Sat, 30 Apr 2011 19:54:56 +0000 (15:54 -0400)
committerMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Sat, 30 Apr 2011 19:54:56 +0000 (15:54 -0400)
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
converter/babeltrace.c
formats/ctf/ctf.c
include/babeltrace/ctf/metadata.h
include/babeltrace/format.h

index 63ade113c81f719a1cb4b1a5b0178a5567fb826b..b603dee53e22a555b0f7b94c9dda7e3651c71ddf 100644 (file)
 #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;
 
+void strlower(char *str)
+{
+       while (*str) {
+               *str = tolower(*str);
+               str++;
+       }
+}
+
 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.
  */
-static int parse_options(int argc, const char **argv)
+static int parse_options(int argc, char **argv)
 {
        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) {
@@ -126,13 +138,15 @@ end:
        return ret;
 }
 
-int main(int argc, const char **argv)
+int main(int argc, char **argv)
 {
        int ret;
+       struct format *fmt_read, *fmt_write;
+       struct trace_descriptor *td_read, *td_write;
 
        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) {
@@ -141,12 +155,60 @@ int main(int argc, const char **argv)
        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",
-               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);
 }
index 57357b792aa2a117f2242464e429f8adc4e659ff..f5ad955e0e417ccfdb12d928eeee880bc03ad08d 100644 (file)
 
 #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,
@@ -41,8 +55,94 @@ static struct format ctf_format = {
        .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;
index c774d7fb357eae64f4997b08a7e8a3884931b2c4..91987a9b30db36016647bc4c20e8e7f381356f14 100644 (file)
@@ -20,6 +20,8 @@
  */
 
 #include <babeltrace/types.h>
+#include <sys/types.h>
+#include <dirent.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;
+
+       /* Information about trace backing directory and files */
+       DIR *dir;
+       int flags;              /* open flags */
 };
 
 #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;
+
+       /* 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)                          \
index 590ab4cb1cca73ef14c14aff98d3e7d45a261b35..cddc41a129e32bda61915df26c2b46367e5a8201 100644 (file)
@@ -24,6 +24,8 @@
 #include <stdio.h>
 #include <glib.h>
 
+struct trace_descriptor;
+
 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);
+       struct trace_descriptor *(*open_trace)(const char *path, int flags);
+       void (*close_trace)(struct trace_descriptor *descriptor);
 };
 
 struct format *bt_lookup_format(GQuark qname);
This page took 0.027706 seconds and 4 git commands to generate.