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_discon_cb_t vcpu_discon; 63 qemu_plugin_vcpu_tb_trans_cb_t vcpu_tb_trans; 64 qemu_plugin_vcpu_mem_cb_t vcpu_mem; 65 qemu_plugin_vcpu_syscall_cb_t vcpu_syscall; 66 qemu_plugin_vcpu_syscall_ret_cb_t vcpu_syscall_ret; 67 void *generic; 68 }; 69 70 enum plugin_dyn_cb_type { 71 PLUGIN_CB_REGULAR, 72 PLUGIN_CB_COND, 73 PLUGIN_CB_MEM_REGULAR, 74 PLUGIN_CB_INLINE_ADD_U64, 75 PLUGIN_CB_INLINE_STORE_U64, 76 }; 77 78 struct qemu_plugin_regular_cb { 79 union qemu_plugin_cb_sig f; 80 TCGHelperInfo *info; 81 void *userp; 82 enum qemu_plugin_mem_rw rw; 83 }; 84 85 struct qemu_plugin_inline_cb { 86 qemu_plugin_u64 entry; 87 uint64_t imm; 88 enum qemu_plugin_mem_rw rw; 89 }; 90 91 struct qemu_plugin_conditional_cb { 92 union qemu_plugin_cb_sig f; 93 TCGHelperInfo *info; 94 void *userp; 95 qemu_plugin_u64 entry; 96 enum qemu_plugin_cond cond; 97 uint64_t imm; 98 }; 99 100 /* 101 * A dynamic callback has an insertion point that is determined at run-time. 102 * Usually the insertion point is somewhere in the code cache; think for 103 * instance of a callback to be called upon the execution of a particular TB. 104 */ 105 struct qemu_plugin_dyn_cb { 106 enum plugin_dyn_cb_type type; 107 union { 108 struct qemu_plugin_regular_cb regular; 109 struct qemu_plugin_conditional_cb cond; 110 struct qemu_plugin_inline_cb inline_insn; 111 }; 112 }; 113 114 /* Internal context for instrumenting an instruction */ 115 struct qemu_plugin_insn { 116 uint64_t vaddr; 117 GArray *insn_cbs; 118 GArray *mem_cbs; 119 uint8_t len; 120 bool calls_helpers; 121 122 /* if set, the instruction calls helpers that might access guest memory */ 123 bool mem_helper; 124 }; 125 126 /* A scoreboard is an array of values, indexed by vcpu_index */ 127 struct qemu_plugin_scoreboard { 128 GArray *data; 129 QLIST_ENTRY(qemu_plugin_scoreboard) entry; 130 }; 131 132 /* Internal context for this TranslationBlock */ 133 struct qemu_plugin_tb { 134 GPtrArray *insns; 135 size_t n; 136 137 /* if set, the TB calls helpers that might access guest memory */ 138 bool mem_helper; 139 140 GArray *cbs; 141 }; 142 143 /** 144 * struct CPUPluginState - per-CPU state for plugins 145 * @event_mask: plugin event bitmap. Modified only via async work. 146 */ 147 struct CPUPluginState { 148 DECLARE_BITMAP(event_mask, QEMU_PLUGIN_EV_MAX); 149 }; 150 151 /** 152 * qemu_plugin_create_vcpu_state: allocate plugin state 153 * 154 * The returned data must be released with g_free() 155 * when no longer required. 156 */ 157 CPUPluginState *qemu_plugin_create_vcpu_state(void); 158 159 void qemu_plugin_vcpu_init_hook(CPUState *cpu); 160 void qemu_plugin_vcpu_exit_hook(CPUState *cpu); 161 void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb); 162 void qemu_plugin_vcpu_idle_cb(CPUState *cpu); 163 void qemu_plugin_vcpu_resume_cb(CPUState *cpu); 164 void qemu_plugin_vcpu_interrupt_cb(CPUState *cpu, uint64_t from); 165 void qemu_plugin_vcpu_exception_cb(CPUState *cpu, uint64_t from); 166 void qemu_plugin_vcpu_hostcall_cb(CPUState *cpu, uint64_t from); 167 void 168 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, 169 uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5, 170 uint64_t a6, uint64_t a7, uint64_t a8); 171 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret); 172 173 void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, 174 uint64_t value_low, 175 uint64_t value_high, 176 MemOpIdx oi, enum qemu_plugin_mem_rw rw); 177 178 void qemu_plugin_flush_cb(void); 179 180 void qemu_plugin_atexit_cb(void); 181 182 void qemu_plugin_add_dyn_cb_arr(GArray *arr); 183 184 static inline void qemu_plugin_disable_mem_helpers(CPUState *cpu) 185 { 186 cpu->neg.plugin_mem_cbs = NULL; 187 } 188 189 /** 190 * qemu_plugin_user_exit(): clean-up callbacks before calling exit callbacks 191 * 192 * This is a user-mode only helper that ensure we have fully cleared 193 * callbacks from all threads before calling the exit callbacks. This 194 * is so the plugins themselves don't have to jump through hoops to 195 * guard against race conditions. 196 */ 197 void qemu_plugin_user_exit(void); 198 199 /** 200 * qemu_plugin_user_prefork_lock(): take plugin lock before forking 201 * 202 * This is a user-mode only helper to take the internal plugin lock 203 * before a fork event. This is ensure a consistent lock state 204 */ 205 void qemu_plugin_user_prefork_lock(void); 206 207 /** 208 * qemu_plugin_user_postfork(): reset the plugin lock 209 * @is_child: is this thread the child 210 * 211 * This user-mode only helper resets the lock state after a fork so we 212 * can continue using the plugin interface. 213 */ 214 void qemu_plugin_user_postfork(bool is_child); 215 216 enum qemu_plugin_cb_flags tcg_call_to_qemu_plugin_cb_flags(int flags); 217 218 static inline void qemu_plugin_set_cb_flags(CPUState *cpu, 219 enum qemu_plugin_cb_flags flags) 220 { 221 assert(cpu); 222 cpu->neg.plugin_cb_flags = flags; 223 } 224 225 static inline enum qemu_plugin_cb_flags qemu_plugin_get_cb_flags(void) 226 { 227 assert(current_cpu); 228 return current_cpu->neg.plugin_cb_flags; 229 } 230 231 #else /* !CONFIG_PLUGIN */ 232 233 static inline void qemu_plugin_add_opts(void) 234 { } 235 236 static inline void qemu_plugin_opt_parse(const char *optstr, 237 QemuPluginList *head) 238 { 239 error_report("plugin interface not enabled in this build"); 240 exit(1); 241 } 242 243 static inline int qemu_plugin_load_list(QemuPluginList *head, Error **errp) 244 { 245 return 0; 246 } 247 248 static inline void qemu_plugin_vcpu_init_hook(CPUState *cpu) 249 { } 250 251 static inline void qemu_plugin_vcpu_exit_hook(CPUState *cpu) 252 { } 253 254 static inline void qemu_plugin_tb_trans_cb(CPUState *cpu, 255 struct qemu_plugin_tb *tb) 256 { } 257 258 static inline void qemu_plugin_vcpu_idle_cb(CPUState *cpu) 259 { } 260 261 static inline void qemu_plugin_vcpu_resume_cb(CPUState *cpu) 262 { } 263 264 static inline void qemu_plugin_vcpu_interrupt_cb(CPUState *cpu, uint64_t from) 265 { } 266 267 static inline void qemu_plugin_vcpu_exception_cb(CPUState *cpu, uint64_t from) 268 { } 269 270 static inline void qemu_plugin_vcpu_hostcall_cb(CPUState *cpu, uint64_t from) 271 { } 272 273 static inline void 274 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2, 275 uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6, 276 uint64_t a7, uint64_t a8) 277 { } 278 279 static inline 280 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret) 281 { } 282 283 static inline void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, 284 uint64_t value_low, 285 uint64_t value_high, 286 MemOpIdx oi, 287 enum qemu_plugin_mem_rw rw) 288 { } 289 290 static inline void qemu_plugin_flush_cb(void) 291 { } 292 293 static inline void qemu_plugin_atexit_cb(void) 294 { } 295 296 static inline 297 void qemu_plugin_add_dyn_cb_arr(GArray *arr) 298 { } 299 300 static inline void qemu_plugin_disable_mem_helpers(CPUState *cpu) 301 { } 302 303 static inline void qemu_plugin_user_exit(void) 304 { } 305 306 static inline void qemu_plugin_user_prefork_lock(void) 307 { } 308 309 static inline void qemu_plugin_user_postfork(bool is_child) 310 { } 311 312 #endif /* !CONFIG_PLUGIN */ 313 314 #endif /* QEMU_PLUGIN_H */ 315