gitlab: Extract default build/test jobs templates
[qemu/ar7.git] / plugins / core.c
blob55d188af5139c92b07b5de5e607a2e79a7c713b4
1 /*
2 * QEMU Plugin Core code
4 * This is the core code that deals with injecting instrumentation into the code
6 * Copyright (C) 2017, Emilio G. Cota <cota@braap.org>
7 * Copyright (C) 2019, Linaro
9 * License: GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
12 * SPDX-License-Identifier: GPL-2.0-or-later
14 #include "qemu/osdep.h"
15 #include "qemu/error-report.h"
16 #include "qemu/config-file.h"
17 #include "qapi/error.h"
18 #include "qemu/lockable.h"
19 #include "qemu/option.h"
20 #include "qemu/rcu_queue.h"
21 #include "qemu/xxhash.h"
22 #include "qemu/rcu.h"
23 #include "hw/core/cpu.h"
24 #include "exec/cpu-common.h"
26 #include "exec/exec-all.h"
27 #include "exec/helper-proto.h"
28 #include "tcg/tcg.h"
29 #include "tcg/tcg-op.h"
30 #include "trace/mem-internal.h" /* mem_info macros */
31 #include "plugin.h"
32 #include "qemu/compiler.h"
34 struct qemu_plugin_cb {
35 struct qemu_plugin_ctx *ctx;
36 union qemu_plugin_cb_sig f;
37 void *udata;
38 QLIST_ENTRY(qemu_plugin_cb) entry;
41 struct qemu_plugin_state plugin;
43 struct qemu_plugin_ctx *plugin_id_to_ctx_locked(qemu_plugin_id_t id)
45 struct qemu_plugin_ctx *ctx;
46 qemu_plugin_id_t *id_p;
48 id_p = g_hash_table_lookup(plugin.id_ht, &id);
49 ctx = container_of(id_p, struct qemu_plugin_ctx, id);
50 if (ctx == NULL) {
51 error_report("plugin: invalid plugin id %" PRIu64, id);
52 abort();
54 return ctx;
57 static void plugin_cpu_update__async(CPUState *cpu, run_on_cpu_data data)
59 bitmap_copy(cpu->plugin_mask, &data.host_ulong, QEMU_PLUGIN_EV_MAX);
60 cpu_tb_jmp_cache_clear(cpu);
63 static void plugin_cpu_update__locked(gpointer k, gpointer v, gpointer udata)
65 CPUState *cpu = container_of(k, CPUState, cpu_index);
66 run_on_cpu_data mask = RUN_ON_CPU_HOST_ULONG(*plugin.mask);
68 if (cpu->created) {
69 async_run_on_cpu(cpu, plugin_cpu_update__async, mask);
70 } else {
71 plugin_cpu_update__async(cpu, mask);
75 void plugin_unregister_cb__locked(struct qemu_plugin_ctx *ctx,
76 enum qemu_plugin_event ev)
78 struct qemu_plugin_cb *cb = ctx->callbacks[ev];
80 if (cb == NULL) {
81 return;
83 QLIST_REMOVE_RCU(cb, entry);
84 g_free(cb);
85 ctx->callbacks[ev] = NULL;
86 if (QLIST_EMPTY_RCU(&plugin.cb_lists[ev])) {
87 clear_bit(ev, plugin.mask);
88 g_hash_table_foreach(plugin.cpu_ht, plugin_cpu_update__locked, NULL);
93 * Disable CFI checks.
94 * The callback function has been loaded from an external library so we do not
95 * have type information
97 QEMU_DISABLE_CFI
98 static void plugin_vcpu_cb__simple(CPUState *cpu, enum qemu_plugin_event ev)
100 struct qemu_plugin_cb *cb, *next;
102 switch (ev) {
103 case QEMU_PLUGIN_EV_VCPU_INIT:
104 case QEMU_PLUGIN_EV_VCPU_EXIT:
105 case QEMU_PLUGIN_EV_VCPU_IDLE:
106 case QEMU_PLUGIN_EV_VCPU_RESUME:
107 /* iterate safely; plugins might uninstall themselves at any time */
108 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
109 qemu_plugin_vcpu_simple_cb_t func = cb->f.vcpu_simple;
111 func(cb->ctx->id, cpu->cpu_index);
113 break;
114 default:
115 g_assert_not_reached();
120 * Disable CFI checks.
121 * The callback function has been loaded from an external library so we do not
122 * have type information
124 QEMU_DISABLE_CFI
125 static void plugin_cb__simple(enum qemu_plugin_event ev)
127 struct qemu_plugin_cb *cb, *next;
129 switch (ev) {
130 case QEMU_PLUGIN_EV_FLUSH:
131 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
132 qemu_plugin_simple_cb_t func = cb->f.simple;
134 func(cb->ctx->id);
136 break;
137 default:
138 g_assert_not_reached();
143 * Disable CFI checks.
144 * The callback function has been loaded from an external library so we do not
145 * have type information
147 QEMU_DISABLE_CFI
148 static void plugin_cb__udata(enum qemu_plugin_event ev)
150 struct qemu_plugin_cb *cb, *next;
152 switch (ev) {
153 case QEMU_PLUGIN_EV_ATEXIT:
154 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
155 qemu_plugin_udata_cb_t func = cb->f.udata;
157 func(cb->ctx->id, cb->udata);
159 break;
160 default:
161 g_assert_not_reached();
165 static void
166 do_plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev,
167 void *func, void *udata)
169 struct qemu_plugin_ctx *ctx;
171 QEMU_LOCK_GUARD(&plugin.lock);
172 ctx = plugin_id_to_ctx_locked(id);
173 /* if the plugin is on its way out, ignore this request */
174 if (unlikely(ctx->uninstalling)) {
175 return;
177 if (func) {
178 struct qemu_plugin_cb *cb = ctx->callbacks[ev];
180 if (cb) {
181 cb->f.generic = func;
182 cb->udata = udata;
183 } else {
184 cb = g_new(struct qemu_plugin_cb, 1);
185 cb->ctx = ctx;
186 cb->f.generic = func;
187 cb->udata = udata;
188 ctx->callbacks[ev] = cb;
189 QLIST_INSERT_HEAD_RCU(&plugin.cb_lists[ev], cb, entry);
190 if (!test_bit(ev, plugin.mask)) {
191 set_bit(ev, plugin.mask);
192 g_hash_table_foreach(plugin.cpu_ht, plugin_cpu_update__locked,
193 NULL);
196 } else {
197 plugin_unregister_cb__locked(ctx, ev);
201 void plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev,
202 void *func)
204 do_plugin_register_cb(id, ev, func, NULL);
207 void
208 plugin_register_cb_udata(qemu_plugin_id_t id, enum qemu_plugin_event ev,
209 void *func, void *udata)
211 do_plugin_register_cb(id, ev, func, udata);
214 void qemu_plugin_vcpu_init_hook(CPUState *cpu)
216 bool success;
218 qemu_rec_mutex_lock(&plugin.lock);
219 plugin_cpu_update__locked(&cpu->cpu_index, NULL, NULL);
220 success = g_hash_table_insert(plugin.cpu_ht, &cpu->cpu_index,
221 &cpu->cpu_index);
222 g_assert(success);
223 qemu_rec_mutex_unlock(&plugin.lock);
225 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_INIT);
228 void qemu_plugin_vcpu_exit_hook(CPUState *cpu)
230 bool success;
232 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_EXIT);
234 qemu_rec_mutex_lock(&plugin.lock);
235 success = g_hash_table_remove(plugin.cpu_ht, &cpu->cpu_index);
236 g_assert(success);
237 qemu_rec_mutex_unlock(&plugin.lock);
240 struct plugin_for_each_args {
241 struct qemu_plugin_ctx *ctx;
242 qemu_plugin_vcpu_simple_cb_t cb;
245 static void plugin_vcpu_for_each(gpointer k, gpointer v, gpointer udata)
247 struct plugin_for_each_args *args = udata;
248 int cpu_index = *(int *)k;
250 args->cb(args->ctx->id, cpu_index);
253 void qemu_plugin_vcpu_for_each(qemu_plugin_id_t id,
254 qemu_plugin_vcpu_simple_cb_t cb)
256 struct plugin_for_each_args args;
258 if (cb == NULL) {
259 return;
261 qemu_rec_mutex_lock(&plugin.lock);
262 args.ctx = plugin_id_to_ctx_locked(id);
263 args.cb = cb;
264 g_hash_table_foreach(plugin.cpu_ht, plugin_vcpu_for_each, &args);
265 qemu_rec_mutex_unlock(&plugin.lock);
268 /* Allocate and return a callback record */
269 static struct qemu_plugin_dyn_cb *plugin_get_dyn_cb(GArray **arr)
271 GArray *cbs = *arr;
273 if (!cbs) {
274 cbs = g_array_sized_new(false, false,
275 sizeof(struct qemu_plugin_dyn_cb), 1);
276 *arr = cbs;
279 g_array_set_size(cbs, cbs->len + 1);
280 return &g_array_index(cbs, struct qemu_plugin_dyn_cb, cbs->len - 1);
283 void plugin_register_inline_op(GArray **arr,
284 enum qemu_plugin_mem_rw rw,
285 enum qemu_plugin_op op, void *ptr,
286 uint64_t imm)
288 struct qemu_plugin_dyn_cb *dyn_cb;
290 dyn_cb = plugin_get_dyn_cb(arr);
291 dyn_cb->userp = ptr;
292 dyn_cb->type = PLUGIN_CB_INLINE;
293 dyn_cb->rw = rw;
294 dyn_cb->inline_insn.op = op;
295 dyn_cb->inline_insn.imm = imm;
298 static inline uint32_t cb_to_tcg_flags(enum qemu_plugin_cb_flags flags)
300 uint32_t ret;
302 switch (flags) {
303 case QEMU_PLUGIN_CB_RW_REGS:
304 ret = 0;
305 break;
306 case QEMU_PLUGIN_CB_R_REGS:
307 ret = TCG_CALL_NO_WG;
308 break;
309 case QEMU_PLUGIN_CB_NO_REGS:
310 default:
311 ret = TCG_CALL_NO_RWG;
313 return ret;
316 inline void
317 plugin_register_dyn_cb__udata(GArray **arr,
318 qemu_plugin_vcpu_udata_cb_t cb,
319 enum qemu_plugin_cb_flags flags, void *udata)
321 struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
323 dyn_cb->userp = udata;
324 dyn_cb->tcg_flags = cb_to_tcg_flags(flags);
325 dyn_cb->f.vcpu_udata = cb;
326 dyn_cb->type = PLUGIN_CB_REGULAR;
329 void plugin_register_vcpu_mem_cb(GArray **arr,
330 void *cb,
331 enum qemu_plugin_cb_flags flags,
332 enum qemu_plugin_mem_rw rw,
333 void *udata)
335 struct qemu_plugin_dyn_cb *dyn_cb;
337 dyn_cb = plugin_get_dyn_cb(arr);
338 dyn_cb->userp = udata;
339 dyn_cb->tcg_flags = cb_to_tcg_flags(flags);
340 dyn_cb->type = PLUGIN_CB_REGULAR;
341 dyn_cb->rw = rw;
342 dyn_cb->f.generic = cb;
346 * Disable CFI checks.
347 * The callback function has been loaded from an external library so we do not
348 * have type information
350 QEMU_DISABLE_CFI
351 void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb)
353 struct qemu_plugin_cb *cb, *next;
354 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_TB_TRANS;
356 /* no plugin_mask check here; caller should have checked */
358 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
359 qemu_plugin_vcpu_tb_trans_cb_t func = cb->f.vcpu_tb_trans;
361 func(cb->ctx->id, tb);
366 * Disable CFI checks.
367 * The callback function has been loaded from an external library so we do not
368 * have type information
370 QEMU_DISABLE_CFI
371 void
372 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2,
373 uint64_t a3, uint64_t a4, uint64_t a5,
374 uint64_t a6, uint64_t a7, uint64_t a8)
376 struct qemu_plugin_cb *cb, *next;
377 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_SYSCALL;
379 if (!test_bit(ev, cpu->plugin_mask)) {
380 return;
383 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
384 qemu_plugin_vcpu_syscall_cb_t func = cb->f.vcpu_syscall;
386 func(cb->ctx->id, cpu->cpu_index, num, a1, a2, a3, a4, a5, a6, a7, a8);
391 * Disable CFI checks.
392 * The callback function has been loaded from an external library so we do not
393 * have type information
395 QEMU_DISABLE_CFI
396 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret)
398 struct qemu_plugin_cb *cb, *next;
399 enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_SYSCALL_RET;
401 if (!test_bit(ev, cpu->plugin_mask)) {
402 return;
405 QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
406 qemu_plugin_vcpu_syscall_ret_cb_t func = cb->f.vcpu_syscall_ret;
408 func(cb->ctx->id, cpu->cpu_index, num, ret);
412 void qemu_plugin_vcpu_idle_cb(CPUState *cpu)
414 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_IDLE);
417 void qemu_plugin_vcpu_resume_cb(CPUState *cpu)
419 plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_RESUME);
422 void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id,
423 qemu_plugin_vcpu_simple_cb_t cb)
425 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_IDLE, cb);
428 void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id,
429 qemu_plugin_vcpu_simple_cb_t cb)
431 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_RESUME, cb);
434 void qemu_plugin_register_flush_cb(qemu_plugin_id_t id,
435 qemu_plugin_simple_cb_t cb)
437 plugin_register_cb(id, QEMU_PLUGIN_EV_FLUSH, cb);
440 static bool free_dyn_cb_arr(void *p, uint32_t h, void *userp)
442 g_array_free((GArray *) p, true);
443 return true;
446 void qemu_plugin_flush_cb(void)
448 qht_iter_remove(&plugin.dyn_cb_arr_ht, free_dyn_cb_arr, NULL);
449 qht_reset(&plugin.dyn_cb_arr_ht);
451 plugin_cb__simple(QEMU_PLUGIN_EV_FLUSH);
454 void exec_inline_op(struct qemu_plugin_dyn_cb *cb)
456 uint64_t *val = cb->userp;
458 switch (cb->inline_insn.op) {
459 case QEMU_PLUGIN_INLINE_ADD_U64:
460 *val += cb->inline_insn.imm;
461 break;
462 default:
463 g_assert_not_reached();
467 void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, uint32_t info)
469 GArray *arr = cpu->plugin_mem_cbs;
470 size_t i;
472 if (arr == NULL) {
473 return;
475 for (i = 0; i < arr->len; i++) {
476 struct qemu_plugin_dyn_cb *cb =
477 &g_array_index(arr, struct qemu_plugin_dyn_cb, i);
478 int w = !!(info & TRACE_MEM_ST) + 1;
480 if (!(w & cb->rw)) {
481 break;
483 switch (cb->type) {
484 case PLUGIN_CB_REGULAR:
485 cb->f.vcpu_mem(cpu->cpu_index, info, vaddr, cb->userp);
486 break;
487 case PLUGIN_CB_INLINE:
488 exec_inline_op(cb);
489 break;
490 default:
491 g_assert_not_reached();
496 void qemu_plugin_atexit_cb(void)
498 plugin_cb__udata(QEMU_PLUGIN_EV_ATEXIT);
501 void qemu_plugin_register_atexit_cb(qemu_plugin_id_t id,
502 qemu_plugin_udata_cb_t cb,
503 void *udata)
505 plugin_register_cb_udata(id, QEMU_PLUGIN_EV_ATEXIT, cb, udata);
509 * Call this function after longjmp'ing to the main loop. It's possible that the
510 * last instruction of a TB might have used helpers, and therefore the
511 * "disable" instruction will never execute because it ended up as dead code.
513 void qemu_plugin_disable_mem_helpers(CPUState *cpu)
515 cpu->plugin_mem_cbs = NULL;
518 static bool plugin_dyn_cb_arr_cmp(const void *ap, const void *bp)
520 return ap == bp;
523 static void __attribute__((__constructor__)) plugin_init(void)
525 int i;
527 for (i = 0; i < QEMU_PLUGIN_EV_MAX; i++) {
528 QLIST_INIT(&plugin.cb_lists[i]);
530 qemu_rec_mutex_init(&plugin.lock);
531 plugin.id_ht = g_hash_table_new(g_int64_hash, g_int64_equal);
532 plugin.cpu_ht = g_hash_table_new(g_int_hash, g_int_equal);
533 QTAILQ_INIT(&plugin.ctxs);
534 qht_init(&plugin.dyn_cb_arr_ht, plugin_dyn_cb_arr_cmp, 16,
535 QHT_MODE_AUTO_RESIZE);
536 atexit(qemu_plugin_atexit_cb);