Trace memory accesses

Rot127 · Rot127 · commit f6904888170a · 2025-06-27T08:27:45.000-05:00
diff --git a/contrib/plugins/bap-tracing/frame_buffer.c b/contrib/plugins/bap-tracing/frame_buffer.c
@@ -127,7 +127,11 @@ char *frame_buffer_as_str(const FrameBuffer *buf) {
   StdFrame *sframe = frame->std_frame;
   for (size_t i = 0; i < sframe->operand_pre_list->n_elem; i++) {
     OperandInfo *oi = sframe->operand_pre_list->elem[i];
-    APPEND("r:%s=", oi->operand_info_specific->reg_operand->name);
+    if (oi->operand_info_specific->reg_operand) {
+      APPEND("r:%s=", oi->operand_info_specific->reg_operand->name);
+    } else {
+      APPEND("m:0x%016lx=", oi->operand_info_specific->mem_operand->address);
+    }
 
     for (size_t k = 0; k < oi->value.len; ++k) {
       APPEND("%02x", oi->value.data[k]);
@@ -137,7 +141,11 @@ char *frame_buffer_as_str(const FrameBuffer *buf) {
   APPEND(" ], post: [ ");
   for (size_t i = 0; i < sframe->operand_post_list->n_elem; i++) {
     OperandInfo *oi = sframe->operand_post_list->elem[i];
-    APPEND("r:%s=", oi->operand_info_specific->reg_operand->name);
+    if (oi->operand_info_specific->reg_operand) {
+      APPEND("r:%s=", oi->operand_info_specific->reg_operand->name);
+    } else {
+      APPEND("m:0x%016lx=", oi->operand_info_specific->mem_operand->address);
+    }
 
     for (size_t k = 0; k < oi->value.len; ++k) {
       APPEND("%02x", oi->value.data[k]);
@@ -202,12 +210,7 @@ bool frame_buffer_new_frame_std(FrameBuffer *buf, unsigned int thread_id,
   return true;
 }
 
-bool frame_buffer_append_reg_info(FrameBuffer *buf, const char *name,
-                                  const GByteArray *content, size_t reg_size,
-                                  OperandAccess acc) {
-  OperandInfo *oi = frame_init_reg_operand_info(
-      name, content->data + content->len - reg_size, reg_size, acc);
-  g_assert(oi);
+static bool append_op_info(FrameBuffer *buf, OperandInfo *oi) {
   Frame *frame = buf->fbuf[buf->idx];
   if (!frame || !frame->std_frame) {
     qemu_plugin_outs(
@@ -217,6 +220,15 @@ bool frame_buffer_append_reg_info(FrameBuffer *buf, const char *name,
   return std_frame_add_operand(frame->std_frame, oi);
 }
 
+bool frame_buffer_append_reg_info(FrameBuffer *buf, const char *name,
+                                  const GByteArray *content, size_t reg_size,
+                                  OperandAccess acc) {
+  OperandInfo *oi = frame_init_reg_operand_info(
+      name, content->data + content->len - reg_size, reg_size, acc);
+  g_assert(oi);
+  return append_op_info(buf, oi);
+}
+
 OperandInfo *frame_init_reg_operand_info(const char *name, const uint8_t *value,
                                          size_t value_size,
                                          OperandAccess access) {
@@ -243,3 +255,88 @@ OperandInfo *frame_init_reg_operand_info(const char *name, const uint8_t *value,
 
   return oi;
 }
+
+static size_t mval_type_to_int(enum qemu_plugin_mem_value_type type) {
+  switch (type) {
+  case QEMU_PLUGIN_MEM_VALUE_U8:
+    return 8;
+  case QEMU_PLUGIN_MEM_VALUE_U16:
+    return 16;
+  case QEMU_PLUGIN_MEM_VALUE_U32:
+    return 32;
+  case QEMU_PLUGIN_MEM_VALUE_U64:
+    return 64;
+  case QEMU_PLUGIN_MEM_VALUE_U128:
+    return 128;
+  default:
+    g_assert(false);
+  }
+}
+
+static void mval_to_buf(qemu_plugin_mem_value *val, uint8_t *buf) {
+  switch (val->type) {
+  case QEMU_PLUGIN_MEM_VALUE_U8:
+    buf[0] = val->data.u8;
+    return;
+  case QEMU_PLUGIN_MEM_VALUE_U16:
+    buf[0] = (uint8_t)val->data.u16;
+    buf[1] = (uint8_t)(val->data.u16 >> 8);
+    return;
+  case QEMU_PLUGIN_MEM_VALUE_U32:
+    buf[0] = (uint8_t)val->data.u32;
+    buf[1] = (uint8_t)(val->data.u32 >> 8);
+    buf[2] = (uint8_t)(val->data.u32 >> 16);
+    buf[3] = (uint8_t)(val->data.u32 >> 24);
+    return;
+  case QEMU_PLUGIN_MEM_VALUE_U64:
+    for (size_t i = 0; i < 8; ++i) {
+      buf[i] = (uint8_t)(val->data.u64 >> (i * 8));
+    }
+    return;
+  case QEMU_PLUGIN_MEM_VALUE_U128:
+    for (size_t i = 0; i < 8; ++i) {
+      buf[i] = (uint8_t)(val->data.u128.low >> (i * 8));
+    }
+    for (size_t i = 0; i < 8; ++i) {
+      buf[i + 8] = (uint8_t)(val->data.u128.high >> (i * 8));
+    }
+    return;
+  default:
+    g_assert(false);
+  }
+}
+
+static OperandInfo *frame_init_mem_operand_info(uint64_t vaddr,
+                                                qemu_plugin_mem_value *mval,
+                                                bool is_store) {
+  MemOperand *ro = g_new(MemOperand, 1);
+  mem_operand__init(ro);
+  ro->address = vaddr;
+
+  OperandInfoSpecific *ois = g_new(OperandInfoSpecific, 1);
+  operand_info_specific__init(ois);
+  ois->mem_operand = ro;
+
+  size_t byte_width = mval_type_to_int(mval->type) / 8;
+  OperandUsage *ou = g_new(OperandUsage, 1);
+  operand_usage__init(ou);
+  ou->read = !is_store;
+  ou->written = is_store;
+  OperandInfo *oi = g_new(OperandInfo, 1);
+  operand_info__init(oi);
+  oi->bit_length = mval_type_to_int(mval->type);
+  oi->operand_info_specific = ois;
+  oi->operand_usage = ou;
+  oi->value.len = byte_width;
+  oi->value.data = g_malloc(oi->value.len);
+  mval_to_buf(mval, oi->value.data);
+
+  return oi;
+}
+
+bool frame_buffer_append_mem_info(FrameBuffer *fbuf, uint64_t vaddr,
+                                  qemu_plugin_mem_value *mval, bool is_store) {
+  OperandInfo *oi = frame_init_mem_operand_info(vaddr, mval, is_store);
+  g_assert(oi);
+  return append_op_info(fbuf, oi);
+}
diff --git a/contrib/plugins/bap-tracing/frame_buffer.h b/contrib/plugins/bap-tracing/frame_buffer.h
@@ -8,18 +8,18 @@
 #include <qemu-plugin.h>
 #include <stdio.h>
 
-#include "trace_meta.h"
 #include "frame.piqi.pb-c-patched.h"
+#include "trace_meta.h"
 
 typedef enum {
   OperandRead = 1,
   OperandWritten = 2,
 } OperandAccess;
 
 typedef struct {
-  Frame **fbuf;    ///< The frames buffered.
-  size_t idx;      ///< Points to currently open frame.
-  size_t max_size; ///< Maximum number of elements fbuf can hold.
+  Frame **fbuf;          ///< The frames buffered.
+  size_t idx;            ///< Points to currently open frame.
+  size_t max_size;       ///< Maximum number of elements fbuf can hold.
   size_t frames_written; ///< Number of frames written from buffer to file.
 } FrameBuffer;
 
@@ -35,9 +35,12 @@ bool frame_buffer_is_empty(const FrameBuffer *buf);
 void frame_buffer_close_frame(FrameBuffer *buf);
 char *frame_buffer_as_str(const FrameBuffer *buf);
 
-bool frame_buffer_new_frame_std(FrameBuffer *buf,
-                                unsigned int thread_id, uint64_t vaddr,
-                                uint8_t *bytes, size_t bytes_len);
+bool frame_buffer_new_frame_std(FrameBuffer *buf, unsigned int thread_id,
+                                uint64_t vaddr, uint8_t *bytes,
+                                size_t bytes_len);
+
+bool frame_buffer_append_mem_info(FrameBuffer *fbuf, uint64_t vaddr,
+                                  qemu_plugin_mem_value *mval, bool is_store);
 
 /**
  * \brief Appends the given operand info to the open frame.
diff --git a/contrib/plugins/bap-tracing/tracing.c b/contrib/plugins/bap-tracing/tracing.c
@@ -9,9 +9,33 @@
 
 static TraceState state;
 
+static void add_mem_op(VCPU *vcpu, unsigned int vcpu_index, FrameBuffer *fbuf,
+                       uint64_t vaddr, qemu_plugin_mem_value *mval,
+                       bool is_store) {
+  if (!frame_buffer_append_mem_info(fbuf, vaddr, mval, is_store)) {
+    qemu_plugin_outs("Failed to append memory info\n");
+  }
+  return;
+}
+
 static void log_insn_mem_access(unsigned int vcpu_index,
                                 qemu_plugin_meminfo_t info, uint64_t vaddr,
-                                void *userdata) {}
+                                void *userdata) {
+  g_rw_lock_reader_lock(&state.vcpus_array_lock);
+  g_rw_lock_reader_lock(&state.frame_buffer_lock);
+
+  VCPU *vcpu = g_ptr_array_index(state.vcpus, vcpu_index);
+  g_assert(vcpu);
+  FrameBuffer *fbuf = g_ptr_array_index(state.frame_buffer, vcpu_index);
+
+  bool is_store = qemu_plugin_mem_is_store(info);
+  qemu_plugin_mem_value mval = qemu_plugin_mem_get_value(info);
+
+  add_mem_op(vcpu, vcpu_index, fbuf, vaddr, &mval, is_store);
+
+  g_rw_lock_writer_unlock(&state.frame_buffer_lock);
+  g_rw_lock_writer_unlock(&state.vcpus_array_lock);
+}
 
 static void add_post_reg_state(VCPU *vcpu, unsigned int vcpu_index,
                                GArray *current_regs, FrameBuffer *fbuf) {
@@ -32,7 +56,7 @@ static void add_post_reg_state(VCPU *vcpu, unsigned int vcpu_index,
     if (!frame_buffer_append_reg_info(fbuf, reg->name, rdata, s,
                                       OperandWritten)) {
       qemu_plugin_outs("Failed to append opinfo.\n");
-      g_assert(false);
+      return;
     }
   }
 }
@@ -152,7 +176,7 @@ static void cb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) {
     qemu_plugin_register_vcpu_insn_exec_cb(tb_insn, log_insn_reg_access,
                                            QEMU_PLUGIN_CB_R_REGS, insn_data);
     qemu_plugin_register_vcpu_mem_cb(tb_insn, log_insn_mem_access,
-                                     QEMU_PLUGIN_CB_R_REGS, QEMU_PLUGIN_MEM_R,
+                                     QEMU_PLUGIN_CB_NO_REGS, QEMU_PLUGIN_MEM_R,
                                      NULL);
   }
 }
