Update plugin handling and build ta/focaccia

1 files changed, 35 insertions, 36 deletions

diff --git a/contrib/plugins/focaccia.c b/contrib/plugins/focaccia.c
index bd7ba88a1a..2bbd5f42d4 100644
--- a/contrib/plugins/focaccia.c
+++ b/contrib/plugins/focaccia.c
@@ -1,5 +1,6 @@
 #include <glib.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
@@ -14,7 +15,7 @@ typedef struct {
     unsigned long long virt;
     unsigned long long offset;
     unsigned long long length;
-} PCTracker;
+} pcTracker;
 
 enum Granularity {
     UNDEF = -1,
@@ -49,11 +50,11 @@ typedef struct __attribute__((packed)) Memory {
     unsigned long nr_bytes;
 } Memory;
 
-static int SockFD = -1;
+static int sock_fd = -1;
 
 struct qemu_plugin_scoreboard *state;
-qemu_plugin_u64 PC;
-qemu_plugin_u64 Virt;
+qemu_plugin_u64 pc;
+qemu_plugin_u64 virt;
 qemu_plugin_u64 Offset;
 qemu_plugin_u64 Len;
 
@@ -62,14 +63,12 @@ static char const *pc_reg;
 
 #define SOCK_PATH "/tmp/focaccia.sock"
 
-
 static void plugin_init(void) {
-
-    state = qemu_plugin_scoreboard_new(sizeof(PCTracker));
-    PC = qemu_plugin_scoreboard_u64_in_struct(state, PCTracker, pc);
-    Virt = qemu_plugin_scoreboard_u64_in_struct(state, PCTracker, virt);
-    Offset = qemu_plugin_scoreboard_u64_in_struct(state, PCTracker, offset);
-    Len = qemu_plugin_scoreboard_u64_in_struct(state, PCTracker, length);
+    state = qemu_plugin_scoreboard_new(sizeof(pcTracker));
+    pc = qemu_plugin_scoreboard_u64_in_struct(state, pcTracker, pc);
+    virt = qemu_plugin_scoreboard_u64_in_struct(state, pcTracker, virt);
+    Offset = qemu_plugin_scoreboard_u64_in_struct(state, pcTracker, offset);
+    Len = qemu_plugin_scoreboard_u64_in_struct(state, pcTracker, length);
 
     reg_map = g_hash_table_new(g_str_hash, g_str_equal);
 }
@@ -96,8 +95,8 @@ static void vcpu_init(qemu_plugin_id_t id, unsigned int vcpu_index)
     // Register with focaccia over a socket
 
     // Connect to socket and send initial handshake
-    SockFD = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (SockFD == -1) {
+    sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (sock_fd == -1) {
         perror("socket");
         exit(-1);
     }
@@ -106,23 +105,23 @@ static void vcpu_init(qemu_plugin_id_t id, unsigned int vcpu_index)
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     strncpy(addr.sun_path, SOCK_PATH, sizeof(addr.sun_path) - 1);
-    if (connect(SockFD, &addr, sizeof(addr)) == -1) {
+    if (connect(sock_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
         perror("connect");
-        close(SockFD);
+        close(sock_fd);
         exit(-1);
     }
 
     // Send ping
-    const int pid = getpid();
-    int r = write(SockFD, &pid, sizeof(int));
+    const pid_t pid = getpid();
+    ssize_t r = write(sock_fd, &pid, sizeof(int));
     if (r != sizeof(int)) {
         fprintf(stderr, "Error writing PID to socket\n");
     }
 }
 
 static void plugin_exit(qemu_plugin_id_t id, void* p) {
-    if (SockFD != -1) {
-        close(SockFD);
+    if (sock_fd != -1) {
+        close(sock_fd);
     }
     printf("Plugin has completed!\n");
 }
@@ -139,7 +138,7 @@ static void read_register(unsigned int cpu_index, Command cmd) {
         Register fail;
         memset(&fail, 0, sizeof(Register));
         strncpy(fail.name, "UNKNOWN", sizeof(fail.name) - 1);
-        int ret = write(SockFD, &fail, sizeof(Register));
+        int ret = write(sock_fd, &fail, sizeof(Register));
         if (ret != sizeof(Register)) {
             fprintf(stderr, "Error writing unknown response\n");
         }
@@ -149,7 +148,7 @@ static void read_register(unsigned int cpu_index, Command cmd) {
 
     Register reg;
     if (strncmp(cmd.data._reg.reg_name, pc_reg, 3) == 0) {
-        unsigned long long rip = qemu_plugin_u64_get(Virt, cpu_index);
+        unsigned long long rip = qemu_plugin_u64_get(virt, cpu_index);
         strncpy(reg.name, pc_reg, sizeof(reg.name) - 1);
         reg.nr_bytes = sizeof(rip);
         memcpy(reg.value, &rip, sizeof(rip));
@@ -173,8 +172,8 @@ static void read_register(unsigned int cpu_index, Command cmd) {
         memcpy(reg.value, buf->data, sz);
     }
 
-    // Send PC value over socket
-    int ret = write(SockFD, &reg, sizeof(Register));
+    // Send pc value over socket
+    int ret = write(sock_fd, &reg, sizeof(Register));
     if (ret != sizeof(Register)) {
         fprintf(stderr, "Error writing register %s to socket\n", cmd.data._reg.reg_name);
     }
@@ -188,7 +187,7 @@ static void read_memory(Command cmd) {
         g_byte_array_free(data, TRUE);
 
         Memory fail = {0, 0};
-        int ret = write(SockFD, &fail, sizeof(fail));
+        int ret = write(sock_fd, &fail, sizeof(fail));
         if (ret != sizeof(fail)) {
             fprintf(stderr, "Error writing failing response\n");
         }
@@ -203,14 +202,14 @@ static void read_memory(Command cmd) {
     mem.addr = cmd.data._mem.addr;
     mem.nr_bytes = data->len;
 
-    int ret = write(SockFD, &mem, sizeof(Memory));
+    int ret = write(sock_fd, &mem, sizeof(Memory));
     if (ret != sizeof(Memory)) {
         fprintf(stderr, "Error writing memory header to socket\n");
     }
 
     int written = 0;
     while (written < data->len) {
-        int _ret = write(SockFD, data->data + written, data->len - written);
+        int _ret = write(sock_fd, data->data + written, data->len - written);
         if (_ret == -1) {
             fprintf(stderr, "Error sending memory content\n");
         }
@@ -223,7 +222,7 @@ static void execute_step(unsigned int cpu_index, void *udata) {
     // Conceptually we can now read the state *before* the instruction executes
     Command cmd;
 
-    // Reset PC and Offset if it does not match $rip
+    // Reset pc and Offset if it does not match $rip
     g_autoptr(GArray) reg_list = qemu_plugin_get_registers();
 
     gpointer map_val = g_hash_table_lookup(reg_map, pc_reg);
@@ -233,7 +232,7 @@ static void execute_step(unsigned int cpu_index, void *udata) {
         Register fail;
         memset(&fail, 0, sizeof(Register));
         strncpy(fail.name, "UNKNOWN", sizeof(fail.name) - 1);
-        int ret = write(SockFD, &fail, sizeof(Register));
+        int ret = write(sock_fd, &fail, sizeof(Register));
         if (ret != sizeof(Register)) {
             fprintf(stderr, "Error writing unknown response\n");
         }
@@ -253,14 +252,14 @@ static void execute_step(unsigned int cpu_index, void *udata) {
     }
     unsigned long long rip = 0;
     memcpy(&rip, buf->data, sz);
-    if (qemu_plugin_u64_get(PC, cpu_index) != rip) {
-        qemu_plugin_u64_set(PC, cpu_index, rip);
+    if (qemu_plugin_u64_get(pc, cpu_index) != rip) {
+        qemu_plugin_u64_set(pc, cpu_index, rip);
         qemu_plugin_u64_set(Offset, cpu_index, 0);
     }
 
     while (1) {
         // assume we read 23bytes at once
-        ssize_t n = read(SockFD, &cmd, sizeof(Command));
+        ssize_t n = read(sock_fd, &cmd, sizeof(Command));
         if (n < 0) {
             perror("Error reading from socket\n");
             exit(-1);
@@ -300,12 +299,12 @@ static void register_tracer(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) {
     for (size_t i = 0; i < n_insns; i++) {
         insn = qemu_plugin_tb_get_insn(tb, i);
         qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(insn,
-                                                      QEMU_PLUGIN_INLINE_STORE_U64,
-                                                    Virt, qemu_plugin_insn_vaddr(insn));
+                                                            QEMU_PLUGIN_INLINE_STORE_U64,
+                                                            virt, qemu_plugin_insn_vaddr(insn));
         qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(insn,
-                                                      QEMU_PLUGIN_INLINE_STORE_U64,
-                                                      Len,
-                                                      qemu_plugin_insn_size(insn));
+                                                            QEMU_PLUGIN_INLINE_STORE_U64,
+                                                            Len,
+                                                            qemu_plugin_insn_size(insn));
 
         qemu_plugin_register_vcpu_insn_exec_cb(insn, execute_step, QEMU_PLUGIN_CB_R_REGS, NULL);
     }