Write meta frames and add outputfile argument.

Author: Rot127

contrib/plugins/bap-tracing/frame_buffer.c

@@ -98,9 +98,9 @@ bool frame_buffer_is_full(const FrameBuffer *buf) {
 
 void frame_buffer_close_frame(FrameBuffer *buf) {
   char *str = frame_buffer_as_str(buf);
-  qemu_plugin_outs("Close frame: ");
-  qemu_plugin_outs(str);
-  qemu_plugin_outs("\n\n");
+  // qemu_plugin_outs("Close frame: ");
+  // qemu_plugin_outs(str);
+  // qemu_plugin_outs("\n\n");
   g_free(str);
   buf->idx++;
 }

contrib/plugins/bap-tracing/meson.build

@@ -41,6 +41,7 @@ dep_libprotobuf = declare_dependency(
 bap_tracing_src = files(
   'frame_buffer.c',
   'tracing.c',
+  'trace_meta.c',
 )
 
 if host_os == 'windows'

contrib/plugins/bap-tracing/trace_consts.h

@@ -1,6 +1,7 @@
 #ifndef BAP_TRACE_CONSTS_H
 #define BAP_TRACE_CONSTS_H
 
+#include "qemu-version.h"
 #include <stdint.h>
 
 // Trace header constants
@@ -18,6 +19,9 @@ static const uint64_t offset_first_frame = 48LL;
 
 static const uint64_t trace_version = 3LL;
 
+#define TRACER_NAME "qemu"
+#define TRACER_VERSION "plugin " QEMU_FULL_VERSION
+
 #define FRAMES_PER_TOC_ENTRY_ 64LL
 static const uint64_t frames_per_toc_entry = FRAMES_PER_TOC_ENTRY_;
 

contrib/plugins/bap-tracing/trace_meta.c

@@ -7,13 +7,14 @@
 #include <sys/stat.h>
 
 #include "frame.piqi.pb-c-patched.h"
+#include "trace_consts.h"
 #include "trace_meta.h"
 
 #define MD5LEN 16
 
-static void compute_target_md5(const char *binary_path) {
+static void compute_target_md5(const char *binary_path,
+                               guchar target_md5[MD5LEN]) {
   const GChecksumType md5 = G_CHECKSUM_MD5;
-  guchar target_md5[MD5LEN];
 
   GChecksum *cs = g_checksum_new(md5);
   FILE *target = fopen(binary_path, "r");
@@ -38,37 +39,31 @@ static void compute_target_md5(const char *binary_path) {
   fclose(target);
 }
 
-static void meta_write_header(FILE *file) {
-  // uint64_t toc_off = 0L;
-  // WRITE(magic_number);
-  // WRITE(out_trace_version);
-  // WRITE(frame_arch);
-  // WRITE(frame_mach);
-  // WRITE(toc_num_frames);
-  // WRITE(toc_off);
+static void init_tracer(Tracer *tracer, char **argv, int argc) {
+  tracer__init(tracer);
+  tracer->name = g_strdup(TRACER_NAME);
+  tracer->n_args = argc;
+  tracer->args = argv;
+  tracer->n_envp = 0;
+  tracer->envp = NULL;
+  tracer->version = g_strdup(TRACER_VERSION);
 }
 
-static void init_tracer(Tracer *tracer, char **argv, char **envp) {
-  // tracer__init(tracer);
-  // tracer->name = tracer_name;
-  // tracer->n_args = list_length(argv);
-  // tracer->args = argv;
-  // tracer->n_envp = list_length(envp);
-  // tracer->envp = envp;
-  // tracer->version = tracer_version;
-}
+static void init_target(Target *target, const char *bin_path, char **argv,
+                        int argc) {
+  target__init(target);
 
-static void init_target(Target *target, char **argv, char **envp) {
-  // compute_target_md5();
-
-  // target__init(target);
-  // target->path = target_path;
-  // target->n_args = list_length(argv);
-  // target->args = argv;
-  // target->n_envp = list_length(envp);
-  // target->envp = envp;
-  // target->md5sum.len = MD5LEN;
-  // target->md5sum.data = target_md5;
+  if (bin_path) {
+    guchar *target_md5 = g_malloc0(MD5LEN);
+    compute_target_md5(bin_path, target_md5);
+    target->path = g_strdup(bin_path);
+    target->md5sum.len = MD5LEN;
+    target->md5sum.data = target_md5;
+  }
+  target->n_args = argc;
+  target->args = argv;
+  target->n_envp = 0;
+  target->envp = NULL;
 }
 
 #ifdef G_OS_UNIX
@@ -95,18 +90,74 @@ static bool init_fstats(Fstats *fstats, const char *binary_path) {
   return true;
 }
 
-static void write_meta(WLOCKED FILE *file, char **tracer_argv,
-                       char **tracer_envp, char **target_argv,
-                       char **target_envp) {
-  MetaFrame meta;
-  Tracer tracer;
-  Target target;
-  Fstats fstats;
+char *get_argv_val(char **argv, int argc, const char *key) {
+  for (size_t i = 0; i < argc; ++i) {
+    if (!strncmp(argv[i], key, strlen(key))) {
+      const char *val = argv[i] + strlen(key);
+      if (val[0] != '=') {
+        qemu_plugin_outs("Invalid argument value for ");
+        qemu_plugin_outs(key);
+        qemu_plugin_outs("\n");
+        qemu_plugin_outs("Should be 'key=val'\n");
+        return NULL;
+      }
+      val++;
+      const char *end = strchr(val, ',');
+      while (end && *(end - 1) == '\\') {
+        // Allow escaped commas.
+        end = strchr(val, ',');
+      }
+      size_t len = !end ? strlen(val) : end - val;
+      char *argument = g_malloc0(len + 1);
+      memcpy(argument, val, len);
+      return argument;
+    }
+  }
+  return NULL;
+}
+
+void file_exists_exit(const char *file) {
+  FILE *test = fopen(file, "r");
+  if (!test) {
+    qemu_plugin_outs("Failed to open binary file: ");
+    qemu_plugin_outs(file);
+    qemu_plugin_outs("\n");
+    exit(1);
+  }
+  fclose(test);
+}
+
+void write_meta(WLOCKED FILE *file, char **plugin_argv, size_t plugin_argc) {
+  char *arg_bin_path = get_argv_val(plugin_argv, plugin_argc, "bin_path");
+  // Note: Usually we should get the binary path from
+  // qemu_plugin_path_to_binary(). But it doesn't seem to work due to dependency
+  // issues. See: https://gitlab.com/qemu-project/qemu/-/issues/3014
+  const char *bin_path = NULL; // qemu_plugin_path_to_binary();
+  if (!bin_path && !arg_bin_path) {
+    qemu_plugin_outs("\nFailed to retrieve the binary path\n");
+    qemu_plugin_outs("This is required.\n");
+    qemu_plugin_outs("You can pass it as plugin argument "
+                     "'bin_path=<path>'.\n\n");
+    exit(1);
+  } else {
+    file_exists_exit(arg_bin_path);
+  }
+  if (bin_path && arg_bin_path) {
+    qemu_plugin_outs(
+        "'bin_path' argument found, but the binary path is known to the module.\n\
+                      Argument 'bin_path' is ignored.\n");
+  }
+
+  MetaFrame meta = {0};
+  Tracer tracer = {0};
+  Target target = {0};
+  Fstats fstats = {0};
 
   meta_frame__init(&meta);
-  init_tracer(&tracer, tracer_argv, tracer_envp);
-  init_target(&target, target_argv, target_envp);
-  init_fstats(&fstats, "target-path");
+  init_tracer(&tracer, plugin_argv, plugin_argc);
+  init_target(&target, bin_path ? bin_path : arg_bin_path, plugin_argv,
+              plugin_argc);
+  init_fstats(&fstats, bin_path ? bin_path : arg_bin_path);
 
   meta.tracer = &tracer;
   meta.target = &target;
@@ -119,11 +170,24 @@ static void write_meta(WLOCKED FILE *file, char **tracer_argv,
   meta.host = host;
 
   size_t msg_size = meta_frame__get_packed_size(&meta);
-  uint8_t *packed_buffer = g_alloca(msg_size);
+  uint8_t *packed_buffer = g_malloc0(msg_size);
   uint64_t packed_size = meta_frame__pack(&meta, packed_buffer);
+  g_assert(msg_size == packed_size);
   WRITE(packed_size);
-  WRITE_BUF(&meta, packed_size);
 
-  free(user);
-  free(host);
+  // I don't know why, but ASAN crashes at this line if the WRITE_BUF macro
+  // is used. Although it should be the exact same code.
+  if (fwrite((packed_buffer), 1, (packed_size), file) != packed_size) {
+   err(1, "fwrite failed");
+  }
+
+  g_free(packed_buffer);
+  g_free(tracer.name);
+  g_free(tracer.version);
+  g_free(target.path);
+  g_free(target.md5sum.data);
+
+  g_free(user);
+  g_free(host);
+  g_free(arg_bin_path);
 }

contrib/plugins/bap-tracing/trace_meta.h

@@ -5,6 +5,7 @@
 #define BAP_TRACE_META_H
 
 #include <err.h>
+#include <stdio.h>
 
 /**
  * \brief Empty macros indicate the argument, variable etc.
@@ -30,4 +31,8 @@
       err(1, "stream not seekable");                                           \
   } while (0)
 
+void write_meta(WLOCKED FILE *file, char **plugin_argv, size_t plugin_argc);
+char *get_argv_val(char **argv, int argc, const char *key);
+void file_exists_exit(const char *file);
+
 #endif

contrib/plugins/bap-tracing/tracing.c

@@ -3,6 +3,7 @@
 
 #include <glib.h>
 #include <stdio.h>
+#include <string.h>
 
 #include "frame_arch.h"
 #include "frame_buffer.h"
@@ -230,6 +231,7 @@ static void plugin_exit(qemu_plugin_id_t id, void *udata) {
   g_rw_lock_reader_unlock(&state.total_num_frames_lock);
   g_rw_lock_reader_unlock(&state.toc_entries_offsets_lock);
   g_rw_lock_writer_unlock(&state.file_lock);
+  qemu_plugin_outs("Finished trace\n");
 }
 
 static bool get_frame_arch_mach(const char *target_name, uint64_t *arch,
@@ -271,24 +273,28 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
   qemu_plugin_outs("Target name: ");
   qemu_plugin_outs(info->target_name);
   qemu_plugin_outs("\n");
+  char *output = get_argv_val(argv, argc, "out");
+  if (!output) {
+    qemu_plugin_outs("'out' argument is missing.\n");
+    qemu_plugin_outs("This is required.\n");
+    qemu_plugin_outs("Pass it with 'out=<output_file>'.\n\n");
+    exit(1);
+  }
 
-  const char *target_path = "/tmp/test.trace";
   state.frame_buffer = g_ptr_array_new();
   state.toc_entries_offsets = g_array_new(false, true, sizeof(uint64_t));
   state.vcpus = g_ptr_array_new();
-  state.file = fopen(target_path, "wb");
+  state.file = fopen(output, "wb");
   if (!(state.frame_buffer || state.vcpus || state.file ||
         !state.toc_entries_offsets)) {
     return 1;
   }
-  for (size_t i = 0; i < argc; ++i) {
-    qemu_plugin_outs(argv[i]);
-  }
+  g_free(output);
   if (!write_header(state.file, info->target_name)) {
     qemu_plugin_outs("Failed to header.\n");
     return 1;
   }
-  // write_meta(argv, envp, target_argv, target_envp);
+  write_meta(state.file, argv, argc);
 
   g_array_append_val(state.toc_entries_offsets, offset_toc_start);