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