1 /* 2 * Copyright (C) 2017, Emilio G. Cota <cota@braap.org> 3 * 4 * License: GNU GPL, version 2 or later. 5 * See the COPYING file in the top-level directory. 6 */ 7 #ifndef QEMU_PLUGIN_H 8 #define QEMU_PLUGIN_H 9 10 #include "qemu/config-file.h" 11 #include "qemu/qemu-plugin.h" 12 #include "qemu/error-report.h" 13 #include "qemu/queue.h" 14 #include "qemu/option.h" 15 #include "qemu/plugin-event.h" 16 #include "exec/memopidx.h" 17 #include "hw/core/cpu.h" 18 19 /* 20 * Option parsing/processing. 21 * Note that we can load an arbitrary number of plugins. 22 */ 23 struct qemu_plugin_desc; 24 typedef QTAILQ_HEAD(, qemu_plugin_desc) QemuPluginList; 25 26 /* 27 * Construct a qemu_plugin_meminfo_t. 28 */ 29 static inline qemu_plugin_meminfo_t 30 make_plugin_meminfo(MemOpIdx oi, enum qemu_plugin_mem_rw rw) 31 { 32 return oi | (rw << 16); 33 } 34 35 /* 36 * Extract the memory operation direction from a qemu_plugin_meminfo_t. 37 * Other portions may be extracted via get_memop and get_mmuidx. 38 */ 39 static inline enum qemu_plugin_mem_rw 40 get_plugin_meminfo_rw(qemu_plugin_meminfo_t i) 41 { 42 return i >> 16; 43 } 44 45 #ifdef CONFIG_PLUGIN 46 extern QemuOptsList qemu_plugin_opts; 47 48 static inline void qemu_plugin_add_opts(void) 49 { 50 qemu_add_opts(&qemu_plugin_opts); 51 } 52 53 void qemu_plugin_opt_parse(const char *optstr, QemuPluginList *head); 54 int qemu_plugin_load_list(QemuPluginList *head, Error **errp); 55 56 union qemu_plugin_cb_sig { 57 qemu_plugin_simple_cb_t simple; 58 qemu_plugin_udata_cb_t udata; 59 qemu_plugin_vcpu_simple_cb_t vcpu_simple; 60 qemu_plugin_vcpu_udata_cb_t vcpu_udata; 61 qemu_plugin_vcpu_tb_trans_cb_t vcpu_tb_trans; 62 qemu_plugin_vcpu_mem_cb_t vcpu_mem; 63 qemu_plugin_vcpu_syscall_cb_t vcpu_syscall; 64 qemu_plugin_vcpu_syscall_ret_cb_t vcpu_syscall_ret; 65 void *generic; 66 }; 67 68 enum plugin_dyn_cb_type { 69 PLUGIN_CB_INSN, 70 PLUGIN_CB_MEM, 71 PLUGIN_N_CB_TYPES, 72 }; 73 74 enum plugin_dyn_cb_subtype { 75 PLUGIN_CB_REGULAR, 76 PLUGIN_CB_REGULAR_R, 77 PLUGIN_CB_INLINE, 78 PLUGIN_N_CB_SUBTYPES, 79 }; 80 81 /* 82 * A dynamic callback has an insertion point that is determined at run-time. 83 * Usually the insertion point is somewhere in the code cache; think for 84 * instance of a callback to be called upon the execution of a particular TB. 85 */ 86 struct qemu_plugin_dyn_cb { 87 union qemu_plugin_cb_sig f; 88 void *userp; 89 enum plugin_dyn_cb_subtype type; 90 /* @rw applies to mem callbacks only (both regular and inline) */ 91 enum qemu_plugin_mem_rw rw; 92 /* fields specific to each dyn_cb type go here */ 93 union { 94 struct { 95 qemu_plugin_u64 entry; 96 enum qemu_plugin_op op; 97 uint64_t imm; 98 } inline_insn; 99 }; 100 }; 101 102 /* Internal context for instrumenting an instruction */ 103 struct qemu_plugin_insn { 104 GByteArray *data; 105 uint64_t vaddr; 106 void *haddr; 107 GArray *cbs[PLUGIN_N_CB_TYPES][PLUGIN_N_CB_SUBTYPES]; 108 bool calls_helpers; 109 110 /* if set, the instruction calls helpers that might access guest memory */ 111 bool mem_helper; 112 113 bool mem_only; 114 }; 115 116 /* A scoreboard is an array of values, indexed by vcpu_index */ 117 struct qemu_plugin_scoreboard { 118 GArray *data; 119 QLIST_ENTRY(qemu_plugin_scoreboard) entry; 120 }; 121 122 /* 123 * qemu_plugin_insn allocate and cleanup functions. We don't expect to 124 * cleanup many of these structures. They are reused for each fresh 125 * translation. 126 */ 127 128 static inline void qemu_plugin_insn_cleanup_fn(gpointer data) 129 { 130 struct qemu_plugin_insn *insn = (struct qemu_plugin_insn *) data; 131 g_byte_array_free(insn->data, true); 132 } 133 134 static inline struct qemu_plugin_insn *qemu_plugin_insn_alloc(void) 135 { 136 int i, j; 137 struct qemu_plugin_insn *insn = g_new0(struct qemu_plugin_insn, 1); 138 insn->data = g_byte_array_sized_new(4); 139 140 for (i = 0; i < PLUGIN_N_CB_TYPES; i++) { 141 for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) { 142 insn->cbs[i][j] = g_array_new(false, false, 143 sizeof(struct qemu_plugin_dyn_cb)); 144 } 145 } 146 return insn; 147 } 148 149 /* Internal context for this TranslationBlock */ 150 struct qemu_plugin_tb { 151 GPtrArray *insns; 152 size_t n; 153 uint64_t vaddr; 154 uint64_t vaddr2; 155 void *haddr1; 156 void *haddr2; 157 bool mem_only; 158 159 /* if set, the TB calls helpers that might access guest memory */ 160 bool mem_helper; 161 162 GArray *cbs[PLUGIN_N_CB_SUBTYPES]; 163 }; 164 165 /** 166 * qemu_plugin_tb_insn_get(): get next plugin record for translation. 167 * @tb: the internal tb context 168 * @pc: address of instruction 169 */ 170 static inline 171 struct qemu_plugin_insn *qemu_plugin_tb_insn_get(struct qemu_plugin_tb *tb, 172 uint64_t pc) 173 { 174 struct qemu_plugin_insn *insn; 175 int i, j; 176 177 if (unlikely(tb->n == tb->insns->len)) { 178 struct qemu_plugin_insn *new_insn = qemu_plugin_insn_alloc(); 179 g_ptr_array_add(tb->insns, new_insn); 180 } 181 insn = g_ptr_array_index(tb->insns, tb->n++); 182 g_byte_array_set_size(insn->data, 0); 183 insn->calls_helpers = false; 184 insn->mem_helper = false; 185 insn->vaddr = pc; 186 187 for (i = 0; i < PLUGIN_N_CB_TYPES; i++) { 188 for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) { 189 g_array_set_size(insn->cbs[i][j], 0); 190 } 191 } 192 193 return insn; 194 } 195 196 /** 197 * struct CPUPluginState - per-CPU state for plugins 198 * @event_mask: plugin event bitmap. Modified only via async work. 199 */ 200 struct CPUPluginState { 201 DECLARE_BITMAP(event_mask, QEMU_PLUGIN_EV_MAX); 202 }; 203 204 /** 205 * qemu_plugin_create_vcpu_state: allocate plugin state 206 */ 207 CPUPluginState *qemu_plugin_create_vcpu_state(void); 208 209 void qemu_plugin_vcpu_init_hook(CPUState *cpu); 210 void qemu_plugin_vcpu_exit_hook(CPUState *cpu); 211 void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb); 212 void qemu_plugin_vcpu_idle_cb(CPUState *cpu); 213 void qemu_plugin_vcpu_resume_cb(CPUState *cpu); 214 void 215 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, 216 uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, 217 uint64_t a6, uint64_t a7, uint64_t a8); 218 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret); 219 220 void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, 221 MemOpIdx oi, enum qemu_plugin_mem_rw rw); 222 223 void qemu_plugin_flush_cb(void); 224 225 void qemu_plugin_atexit_cb(void); 226 227 void qemu_plugin_add_dyn_cb_arr(GArray *arr); 228 229 static inline void qemu_plugin_disable_mem_helpers(CPUState *cpu) 230 { 231 cpu->plugin_mem_cbs = NULL; 232 } 233 234 /** 235 * qemu_plugin_user_exit(): clean-up callbacks before calling exit callbacks 236 * 237 * This is a user-mode only helper that ensure we have fully cleared 238 * callbacks from all threads before calling the exit callbacks. This 239 * is so the plugins themselves don't have to jump through hoops to 240 * guard against race conditions. 241 */ 242 void qemu_plugin_user_exit(void); 243 244 /** 245 * qemu_plugin_user_prefork_lock(): take plugin lock before forking 246 * 247 * This is a user-mode only helper to take the internal plugin lock 248 * before a fork event. This is ensure a consistent lock state 249 */ 250 void qemu_plugin_user_prefork_lock(void); 251 252 /** 253 * qemu_plugin_user_postfork(): reset the plugin lock 254 * @is_child: is this thread the child 255 * 256 * This user-mode only helper resets the lock state after a fork so we 257 * can continue using the plugin interface. 258 */ 259 void qemu_plugin_user_postfork(bool is_child); 260 261 #else /* !CONFIG_PLUGIN */ 262 263 static inline void qemu_plugin_add_opts(void) 264 { } 265 266 static inline void qemu_plugin_opt_parse(const char *optstr, 267 QemuPluginList *head) 268 { 269 error_report("plugin interface not enabled in this build"); 270 exit(1); 271 } 272 273 static inline int qemu_plugin_load_list(QemuPluginList *head, Error **errp) 274 { 275 return 0; 276 } 277 278 static inline void qemu_plugin_vcpu_init_hook(CPUState *cpu) 279 { } 280 281 static inline void qemu_plugin_vcpu_exit_hook(CPUState *cpu) 282 { } 283 284 static inline void qemu_plugin_tb_trans_cb(CPUState *cpu, 285 struct qemu_plugin_tb *tb) 286 { } 287 288 static inline void qemu_plugin_vcpu_idle_cb(CPUState *cpu) 289 { } 290 291 static inline void qemu_plugin_vcpu_resume_cb(CPUState *cpu) 292 { } 293 294 static inline void 295 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2, 296 uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, 297 uint64_t a7, uint64_t a8) 298 { } 299 300 static inline 301 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret) 302 { } 303 304 static inline void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, 305 MemOpIdx oi, 306 enum qemu_plugin_mem_rw rw) 307 { } 308 309 static inline void qemu_plugin_flush_cb(void) 310 { } 311 312 static inline void qemu_plugin_atexit_cb(void) 313 { } 314 315 static inline 316 void qemu_plugin_add_dyn_cb_arr(GArray *arr) 317 { } 318 319 static inline void qemu_plugin_disable_mem_helpers(CPUState *cpu) 320 { } 321 322 static inline void qemu_plugin_user_exit(void) 323 { } 324 325 static inline void qemu_plugin_user_prefork_lock(void) 326 { } 327 328 static inline void qemu_plugin_user_postfork(bool is_child) 329 { } 330 331 #endif /* !CONFIG_PLUGIN */ 332 333 #endif /* QEMU_PLUGIN_H */ 334