MOre implementation of frame functions.

Author: Rot127

contrib/plugins/bap-tracing/frame_buffer.c

@@ -26,7 +26,12 @@ static Frame *frame_new_std(uint64_t addr, int vcpu_id) {
   return frame;
 }
 
-static void frame_add_operand(Frame *frame, OperandInfo *oi) {
+static bool frame_add_operand(Frame *frame, OperandInfo *oi) {
+  if (!frame->std_frame) {
+    qemu_plugin_outs(
+        "Append operand info to non-std frames is not implemented.");
+    return false;
+  }
   OperandValueList *ol;
   if (oi->operand_usage->written) {
     ol = frame->std_frame->operand_post_list;
@@ -42,6 +47,7 @@ static void frame_add_operand(Frame *frame, OperandInfo *oi) {
   ol->n_elem += 1;
   ol->elem = g_renew(OperandInfo *, ol->elem, ol->n_elem);
   ol->elem[ol->n_elem - 1] = oi;
+  return true;
 }
 
 FrameBuffer *frame_buffer_new(size_t size) {
@@ -55,20 +61,73 @@ bool frame_buffer_is_full(const FrameBuffer *buf) {
   return buf->idx >= buf->max_size;
 }
 
-void frame_buffer_flush_to_file(FrameBuffer *buf, FILE *file);
+void frame_buffer_flush_to_file(WLOCKED FrameBuffer *buf, WLOCKED FILE *file);
 
-StdFrame *frame_buffer_new_frame_std(FrameBuffer *buf) {
+bool frame_buffer_new_frame_std(WLOCKED FrameBuffer *buf,
+                                unsigned int thread_id, uint64_t vaddr,
+                                uint8_t *bytes, size_t bytes_len) {
   if (frame_buffer_is_full(buf)) {
-    return NULL;
+    return false;
   }
   Frame *frame = frame_new_std(0, -1);
   frame__init(frame);
 
-  StdFrame *sframe = g_new(StdFrame, 1);
-  std_frame__init(sframe);
-  frame->std_frame = sframe;
+  StdFrame *stdframe = g_new(StdFrame, 1);
+  std_frame__init(stdframe);
+  frame->std_frame = stdframe;
+
+  stdframe->thread_id = thread_id;
+  stdframe->address = vaddr;
+  stdframe->rawbytes.len = bytes_len;
+  stdframe->rawbytes.data = g_malloc(bytes_len);
+  memcpy(stdframe->rawbytes.data, bytes, bytes_len);
+
+  OperandValueList *ol_in = g_new(OperandValueList, 1);
+  operand_value_list__init(ol_in);
+  ol_in->n_elem = 0;
+  stdframe->operand_pre_list = ol_in;
+
+  OperandValueList *ol_out = g_new(OperandValueList, 1);
+  operand_value_list__init(ol_out);
+  ol_out->n_elem = 0;
+  stdframe->operand_post_list = ol_out;
+
   buf->fbuf[buf->idx++] = frame;
-  return sframe;
+  return true;
+}
+
+bool frame_buffer_append_op_info(WLOCKED FrameBuffer *buf, OperandInfo *oi) {
+  Frame *frame = buf->fbuf[buf->idx];
+  if (!frame) {
+    qemu_plugin_outs(
+        "Attempt to append operand info to a uninitialzied frame.");
+    return false;
+  }
+  return frame_add_operand(frame, oi);
 }
 
-void frame_buffer_append_op_info(FrameBuffer *buf, OperandInfo *oi);
+OperandInfo *frame_init_reg_operand_info(const char *name, const uint8_t *value,
+                                   size_t value_size, OperandAccess access) {
+  RegOperand *ro = g_new(RegOperand, 1);
+  reg_operand__init(ro);
+  ro->name = strdup(name);
+
+  OperandInfoSpecific *ois = g_new(OperandInfoSpecific, 1);
+  operand_info_specific__init(ois);
+  ois->reg_operand = ro;
+
+  OperandUsage *ou = g_new(OperandUsage, 1);
+  operand_usage__init(ou);
+  ou->read = access & OperandRead;
+  ou->written = access & OperandWritten;
+  OperandInfo *oi = g_new(OperandInfo, 1);
+  operand_info__init(oi);
+  oi->bit_length = value_size * 8;
+  oi->operand_info_specific = ois;
+  oi->operand_usage = ou;
+  oi->value.len = value_size;
+  oi->value.data = g_malloc(oi->value.len);
+  memcpy(oi->value.data, value, value_size);
+
+  return oi;
+}

contrib/plugins/bap-tracing/frame_buffer.h

@@ -4,15 +4,26 @@
 #ifndef BAP_FRAME_BUFFER_H
 #define BAP_FRAME_BUFFER_H
 
+#include <glib.h>
 #include <qemu-plugin.h>
 #include <stdio.h>
-#include <glib.h>
 
 #include "frame.piqi.pb-c-patched.h"
 
+/**
+ * \brief Empty macros indicate the argument, variable etc.
+ * must be locked for writing.
+ */
+#define WLOCKED
+
+typedef enum {
+  OperandRead = 1,
+  OperandWritten = 2,
+} OperandAccess;
+
 typedef struct {
-  Frame **fbuf; ///< The frames buffered.
-  size_t idx; ///< Points to currently open frame.
+  Frame **fbuf;    ///< The frames buffered.
+  size_t idx;      ///< Points to currently open frame.
   size_t max_size; ///< Maximum number of elements fbuf can hold.
 } FrameBuffer;
 
@@ -22,10 +33,20 @@ typedef struct {
  */
 FrameBuffer *frame_buffer_new(size_t size);
 
-void frame_buffer_flush_to_file(FrameBuffer *buf, FILE *file);
+void frame_buffer_flush_to_file(WLOCKED FrameBuffer *buf, WLOCKED FILE *file);
 bool frame_buffer_is_full(const FrameBuffer *buf);
 
-StdFrame *frame_buffer_new_frame_std(FrameBuffer *buf);
-void frame_buffer_append_op_info(FrameBuffer *buf, OperandInfo *oi);
+bool frame_buffer_new_frame_std(WLOCKED FrameBuffer *buf,
+                                unsigned int thread_id, uint64_t vaddr,
+                                uint8_t *bytes, size_t bytes_len);
+
+/**
+ * \brief Appends the given operand info to the open frame.
+ */
+bool frame_buffer_append_op_info(WLOCKED FrameBuffer *buf, OperandInfo *oi);
+
+OperandInfo *frame_init_reg_operand_info(const char *name, const uint8_t *value,
+                                         size_t value_size,
+                                         OperandAccess access);
 
 #endif

contrib/plugins/bap-tracing/tracing.c

@@ -3,6 +3,7 @@
 
 #include <glib.h>
 
+#include "frame_buffer.h"
 #include "tracing.h"
 
 static TraceState state;
@@ -26,10 +27,13 @@ static void add_post_reg_state(VCPU *vcpu, unsigned int vcpu_index,
       continue;
     }
 
-    OperandInfo *rinfo = init_reg_operand_info(prev_reg->name, rtmp->data,
+    OperandInfo *rinfo = frame_init_reg_operand_info(prev_reg->name, rtmp->data,
                                                rtmp->len, OperandWritten);
     g_assert(rinfo);
-    frame_buffer_append_op_info(fbuf, rinfo);
+    if (!frame_buffer_append_op_info(fbuf, rinfo)) {
+      qemu_plugin_outs("Failed to append opinfo.\n");
+      g_assert(false);
+    }
   }
 }
 
@@ -41,31 +45,16 @@ static void add_pre_reg_state(VCPU *vcpu, unsigned int vcpu_index,
         &g_array_index(current_regs, qemu_plugin_reg_descriptor, i);
     qemu_plugin_read_register(reg->handle, rtmp);
     OperandInfo *rinfo =
-        init_reg_operand_info(reg->name, rtmp->data, rtmp->len, OperandRead);
+        frame_init_reg_operand_info(reg->name, rtmp->data, rtmp->len, OperandRead);
     g_assert(rinfo);
     frame_buffer_append_op_info(fbuf, rinfo);
   }
 }
 
 static void add_new_insn_frame(VCPU *vcpu, unsigned int vcpu_index,
                                FrameBuffer *fbuf, Instruction *insn) {
-  StdFrame *stdframe = frame_buffer_new_frame_std(fbuf);
-
-  stdframe->thread_id = vcpu_index;
-  stdframe->address = insn->vaddr;
-  stdframe->rawbytes.len = insn->size;
-  stdframe->rawbytes.data = g_malloc(insn->size);
-  memcpy(stdframe->rawbytes.data, insn->bytes, insn->size);
-
-  OperandValueList *ol_in = g_new(OperandValueList, 1);
-  operand_value_list__init(ol_in);
-  ol_in->n_elem = 0;
-  stdframe->operand_pre_list = ol_in;
-
-  OperandValueList *ol_out = g_new(OperandValueList, 1);
-  operand_value_list__init(ol_out);
-  ol_out->n_elem = 0;
-  stdframe->operand_post_list = ol_out;
+  frame_buffer_new_frame_std(fbuf, vcpu_index, insn->vaddr, insn->bytes,
+                             insn->size);
 }
 
 static void log_insn_reg_access(unsigned int vcpu_index, void *udata) {
@@ -142,32 +131,6 @@ static void vcpu_init(qemu_plugin_id_t id, unsigned int vcpu_index) {
   g_rw_lock_writer_unlock(&state.vcpus_array_lock);
 }
 
-OperandInfo *init_reg_operand_info(const char *name, const uint8_t *value,
-                                   size_t value_size, OperandAccess access) {
-  RegOperand *ro = g_new(RegOperand, 1);
-  reg_operand__init(ro);
-  ro->name = strdup(name);
-
-  OperandInfoSpecific *ois = g_new(OperandInfoSpecific, 1);
-  operand_info_specific__init(ois);
-  ois->reg_operand = ro;
-
-  OperandUsage *ou = g_new(OperandUsage, 1);
-  operand_usage__init(ou);
-  ou->read = access & OperandRead;
-  ou->written = access & OperandWritten;
-  OperandInfo *oi = g_new(OperandInfo, 1);
-  operand_info__init(oi);
-  oi->bit_length = value_size * 8;
-  oi->operand_info_specific = ois;
-  oi->operand_usage = ou;
-  oi->value.len = value_size;
-  oi->value.data = g_malloc(oi->value.len);
-  memcpy(oi->value.data, value, value_size);
-
-  return oi;
-}
-
 Instruction *init_insn(struct qemu_plugin_insn *tb_insn) {
   Instruction *insn = g_malloc0(sizeof(Instruction));
   qemu_plugin_insn_data(tb_insn, &insn->bytes, sizeof(insn->bytes));

contrib/plugins/bap-tracing/tracing.h

@@ -16,11 +16,6 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
 
 #define FRAME_BUFFER_SIZE_DEFAULT 1024
 
-typedef enum {
-  OperandRead = 1,
-  OperandWritten = 2,
-} OperandAccess;
-
 /**
  * \brief VLIW architecture have instructions longer than 4 or 8bytes.
  */
@@ -57,7 +52,4 @@ VCPU *vcpu_new(void);
 Register *init_vcpu_register(qemu_plugin_reg_descriptor *desc);
 Instruction *init_insn(struct qemu_plugin_insn *insn);
 
-OperandInfo *init_reg_operand_info(const char *name, const uint8_t *value,
-                                   size_t value_size, OperandAccess access);
-
 #endif