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/plugin.h"
21 #include "qemu/queue.h"
22 #include "qemu/rcu_queue.h"
23 #include "qemu/xxhash.h"
25 #include "hw/core/cpu.h"
27 #include "exec/exec-all.h"
28 #include "exec/tb-flush.h"
30 #include "tcg/tcg-op.h"
33 struct qemu_plugin_cb
{
34 struct qemu_plugin_ctx
*ctx
;
35 union qemu_plugin_cb_sig f
;
37 QLIST_ENTRY(qemu_plugin_cb
) entry
;
40 struct qemu_plugin_state plugin
;
42 struct qemu_plugin_ctx
*plugin_id_to_ctx_locked(qemu_plugin_id_t id
)
44 struct qemu_plugin_ctx
*ctx
;
45 qemu_plugin_id_t
*id_p
;
47 id_p
= g_hash_table_lookup(plugin
.id_ht
, &id
);
48 ctx
= container_of(id_p
, struct qemu_plugin_ctx
, id
);
50 error_report("plugin: invalid plugin id %" PRIu64
, id
);
56 static void plugin_cpu_update__async(CPUState
*cpu
, run_on_cpu_data data
)
58 bitmap_copy(cpu
->plugin_state
->event_mask
,
59 &data
.host_ulong
, QEMU_PLUGIN_EV_MAX
);
60 tcg_flush_jmp_cache(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 (DEVICE(cpu
)->realized
) {
69 async_run_on_cpu(cpu
, plugin_cpu_update__async
, mask
);
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
];
83 QLIST_REMOVE_RCU(cb
, entry
);
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
);
94 * The callback function has been loaded from an external library so we do not
95 * have type information
98 static void plugin_vcpu_cb__simple(CPUState
*cpu
, enum qemu_plugin_event ev
)
100 struct qemu_plugin_cb
*cb
, *next
;
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
);
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
125 static void plugin_cb__simple(enum qemu_plugin_event ev
)
127 struct qemu_plugin_cb
*cb
, *next
;
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
;
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
148 static void plugin_cb__udata(enum qemu_plugin_event ev
)
150 struct qemu_plugin_cb
*cb
, *next
;
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
);
161 g_assert_not_reached();
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
)) {
178 struct qemu_plugin_cb
*cb
= ctx
->callbacks
[ev
];
181 cb
->f
.generic
= func
;
184 cb
= g_new(struct qemu_plugin_cb
, 1);
186 cb
->f
.generic
= func
;
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
,
197 plugin_unregister_cb__locked(ctx
, ev
);
201 void plugin_register_cb(qemu_plugin_id_t id
, enum qemu_plugin_event ev
,
204 do_plugin_register_cb(id
, ev
, func
, NULL
);
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 CPUPluginState
*qemu_plugin_create_vcpu_state(void)
216 return g_new0(CPUPluginState
, 1);
219 static void plugin_grow_scoreboards__locked(CPUState
*cpu
)
221 if (cpu
->cpu_index
< plugin
.scoreboard_alloc_size
) {
225 bool need_realloc
= FALSE
;
226 while (cpu
->cpu_index
>= plugin
.scoreboard_alloc_size
) {
227 plugin
.scoreboard_alloc_size
*= 2;
232 if (!need_realloc
|| QLIST_EMPTY(&plugin
.scoreboards
)) {
233 /* nothing to do, we just updated sizes for future scoreboards */
237 /* cpus must be stopped, as tb might still use an existing scoreboard. */
239 struct qemu_plugin_scoreboard
*score
;
240 QLIST_FOREACH(score
, &plugin
.scoreboards
, entry
) {
241 g_array_set_size(score
->data
, plugin
.scoreboard_alloc_size
);
243 /* force all tb to be flushed, as scoreboard pointers were changed. */
248 void qemu_plugin_vcpu_init_hook(CPUState
*cpu
)
252 qemu_rec_mutex_lock(&plugin
.lock
);
253 plugin
.num_vcpus
= MAX(plugin
.num_vcpus
, cpu
->cpu_index
+ 1);
254 plugin_cpu_update__locked(&cpu
->cpu_index
, NULL
, NULL
);
255 success
= g_hash_table_insert(plugin
.cpu_ht
, &cpu
->cpu_index
,
258 plugin_grow_scoreboards__locked(cpu
);
259 qemu_rec_mutex_unlock(&plugin
.lock
);
261 plugin_vcpu_cb__simple(cpu
, QEMU_PLUGIN_EV_VCPU_INIT
);
264 void qemu_plugin_vcpu_exit_hook(CPUState
*cpu
)
268 plugin_vcpu_cb__simple(cpu
, QEMU_PLUGIN_EV_VCPU_EXIT
);
270 qemu_rec_mutex_lock(&plugin
.lock
);
271 success
= g_hash_table_remove(plugin
.cpu_ht
, &cpu
->cpu_index
);
273 qemu_rec_mutex_unlock(&plugin
.lock
);
276 struct plugin_for_each_args
{
277 struct qemu_plugin_ctx
*ctx
;
278 qemu_plugin_vcpu_simple_cb_t cb
;
281 static void plugin_vcpu_for_each(gpointer k
, gpointer v
, gpointer udata
)
283 struct plugin_for_each_args
*args
= udata
;
284 int cpu_index
= *(int *)k
;
286 args
->cb(args
->ctx
->id
, cpu_index
);
289 void qemu_plugin_vcpu_for_each(qemu_plugin_id_t id
,
290 qemu_plugin_vcpu_simple_cb_t cb
)
292 struct plugin_for_each_args args
;
297 qemu_rec_mutex_lock(&plugin
.lock
);
298 args
.ctx
= plugin_id_to_ctx_locked(id
);
300 g_hash_table_foreach(plugin
.cpu_ht
, plugin_vcpu_for_each
, &args
);
301 qemu_rec_mutex_unlock(&plugin
.lock
);
304 /* Allocate and return a callback record */
305 static struct qemu_plugin_dyn_cb
*plugin_get_dyn_cb(GArray
**arr
)
310 cbs
= g_array_sized_new(false, true,
311 sizeof(struct qemu_plugin_dyn_cb
), 1);
315 g_array_set_size(cbs
, cbs
->len
+ 1);
316 return &g_array_index(cbs
, struct qemu_plugin_dyn_cb
, cbs
->len
- 1);
319 static enum plugin_dyn_cb_type
op_to_cb_type(enum qemu_plugin_op op
)
322 case QEMU_PLUGIN_INLINE_ADD_U64
:
323 return PLUGIN_CB_INLINE_ADD_U64
;
324 case QEMU_PLUGIN_INLINE_STORE_U64
:
325 return PLUGIN_CB_INLINE_STORE_U64
;
327 g_assert_not_reached();
331 void plugin_register_inline_op_on_entry(GArray
**arr
,
332 enum qemu_plugin_mem_rw rw
,
333 enum qemu_plugin_op op
,
334 qemu_plugin_u64 entry
,
337 struct qemu_plugin_dyn_cb
*dyn_cb
;
339 struct qemu_plugin_inline_cb inline_cb
= { .rw
= rw
,
342 dyn_cb
= plugin_get_dyn_cb(arr
);
343 dyn_cb
->type
= op_to_cb_type(op
);
344 dyn_cb
->inline_insn
= inline_cb
;
347 void plugin_register_dyn_cb__udata(GArray
**arr
,
348 qemu_plugin_vcpu_udata_cb_t cb
,
349 enum qemu_plugin_cb_flags flags
,
352 static TCGHelperInfo info
[3] = {
353 [QEMU_PLUGIN_CB_NO_REGS
].flags
= TCG_CALL_NO_RWG
,
354 [QEMU_PLUGIN_CB_R_REGS
].flags
= TCG_CALL_NO_WG
,
356 * Match qemu_plugin_vcpu_udata_cb_t:
357 * void (*)(uint32_t, void *)
359 [0 ... 2].typemask
= (dh_typemask(void, 0) |
360 dh_typemask(i32
, 1) |
363 assert((unsigned)flags
< ARRAY_SIZE(info
));
365 struct qemu_plugin_dyn_cb
*dyn_cb
= plugin_get_dyn_cb(arr
);
366 struct qemu_plugin_regular_cb regular_cb
= { .f
.vcpu_udata
= cb
,
368 .info
= &info
[flags
] };
369 dyn_cb
->type
= PLUGIN_CB_REGULAR
;
370 dyn_cb
->regular
= regular_cb
;
373 void plugin_register_dyn_cond_cb__udata(GArray
**arr
,
374 qemu_plugin_vcpu_udata_cb_t cb
,
375 enum qemu_plugin_cb_flags flags
,
376 enum qemu_plugin_cond cond
,
377 qemu_plugin_u64 entry
,
381 static TCGHelperInfo info
[3] = {
382 [QEMU_PLUGIN_CB_NO_REGS
].flags
= TCG_CALL_NO_RWG
,
383 [QEMU_PLUGIN_CB_R_REGS
].flags
= TCG_CALL_NO_WG
,
385 * Match qemu_plugin_vcpu_udata_cb_t:
386 * void (*)(uint32_t, void *)
388 [0 ... 2].typemask
= (dh_typemask(void, 0) |
389 dh_typemask(i32
, 1) |
392 assert((unsigned)flags
< ARRAY_SIZE(info
));
394 struct qemu_plugin_dyn_cb
*dyn_cb
= plugin_get_dyn_cb(arr
);
395 struct qemu_plugin_conditional_cb cond_cb
= { .userp
= udata
,
400 .info
= &info
[flags
] };
401 dyn_cb
->type
= PLUGIN_CB_COND
;
402 dyn_cb
->cond
= cond_cb
;
405 void plugin_register_vcpu_mem_cb(GArray
**arr
,
407 enum qemu_plugin_cb_flags flags
,
408 enum qemu_plugin_mem_rw rw
,
412 * Expect that the underlying type for enum qemu_plugin_meminfo_t
413 * is either int32_t or uint32_t, aka int or unsigned int.
416 !__builtin_types_compatible_p(qemu_plugin_meminfo_t
, uint32_t) &&
417 !__builtin_types_compatible_p(qemu_plugin_meminfo_t
, int32_t));
419 static TCGHelperInfo info
[3] = {
420 [QEMU_PLUGIN_CB_NO_REGS
].flags
= TCG_CALL_NO_RWG
,
421 [QEMU_PLUGIN_CB_R_REGS
].flags
= TCG_CALL_NO_WG
,
423 * Match qemu_plugin_vcpu_mem_cb_t:
424 * void (*)(uint32_t, qemu_plugin_meminfo_t, uint64_t, void *)
427 (dh_typemask(void, 0) |
428 dh_typemask(i32
, 1) |
429 (__builtin_types_compatible_p(qemu_plugin_meminfo_t
, uint32_t)
430 ? dh_typemask(i32
, 2) : dh_typemask(s32
, 2)) |
431 dh_typemask(i64
, 3) |
434 assert((unsigned)flags
< ARRAY_SIZE(info
));
436 struct qemu_plugin_dyn_cb
*dyn_cb
= plugin_get_dyn_cb(arr
);
437 struct qemu_plugin_regular_cb regular_cb
= { .userp
= udata
,
440 .info
= &info
[flags
] };
441 dyn_cb
->type
= PLUGIN_CB_MEM_REGULAR
;
442 dyn_cb
->regular
= regular_cb
;
446 * Disable CFI checks.
447 * The callback function has been loaded from an external library so we do not
448 * have type information
451 void qemu_plugin_tb_trans_cb(CPUState
*cpu
, struct qemu_plugin_tb
*tb
)
453 struct qemu_plugin_cb
*cb
, *next
;
454 enum qemu_plugin_event ev
= QEMU_PLUGIN_EV_VCPU_TB_TRANS
;
456 /* no plugin_state->event_mask check here; caller should have checked */
458 QLIST_FOREACH_SAFE_RCU(cb
, &plugin
.cb_lists
[ev
], entry
, next
) {
459 qemu_plugin_vcpu_tb_trans_cb_t func
= cb
->f
.vcpu_tb_trans
;
461 func(cb
->ctx
->id
, tb
);
466 * Disable CFI checks.
467 * The callback function has been loaded from an external library so we do not
468 * have type information
472 qemu_plugin_vcpu_syscall(CPUState
*cpu
, int64_t num
, uint64_t a1
, uint64_t a2
,
473 uint64_t a3
, uint64_t a4
, uint64_t a5
,
474 uint64_t a6
, uint64_t a7
, uint64_t a8
)
476 struct qemu_plugin_cb
*cb
, *next
;
477 enum qemu_plugin_event ev
= QEMU_PLUGIN_EV_VCPU_SYSCALL
;
479 if (!test_bit(ev
, cpu
->plugin_state
->event_mask
)) {
483 QLIST_FOREACH_SAFE_RCU(cb
, &plugin
.cb_lists
[ev
], entry
, next
) {
484 qemu_plugin_vcpu_syscall_cb_t func
= cb
->f
.vcpu_syscall
;
486 func(cb
->ctx
->id
, cpu
->cpu_index
, num
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
);
491 * Disable CFI checks.
492 * The callback function has been loaded from an external library so we do not
493 * have type information
496 void qemu_plugin_vcpu_syscall_ret(CPUState
*cpu
, int64_t num
, int64_t ret
)
498 struct qemu_plugin_cb
*cb
, *next
;
499 enum qemu_plugin_event ev
= QEMU_PLUGIN_EV_VCPU_SYSCALL_RET
;
501 if (!test_bit(ev
, cpu
->plugin_state
->event_mask
)) {
505 QLIST_FOREACH_SAFE_RCU(cb
, &plugin
.cb_lists
[ev
], entry
, next
) {
506 qemu_plugin_vcpu_syscall_ret_cb_t func
= cb
->f
.vcpu_syscall_ret
;
508 func(cb
->ctx
->id
, cpu
->cpu_index
, num
, ret
);
512 void qemu_plugin_vcpu_idle_cb(CPUState
*cpu
)
514 /* idle and resume cb may be called before init, ignore in this case */
515 if (cpu
->cpu_index
< plugin
.num_vcpus
) {
516 plugin_vcpu_cb__simple(cpu
, QEMU_PLUGIN_EV_VCPU_IDLE
);
520 void qemu_plugin_vcpu_resume_cb(CPUState
*cpu
)
522 if (cpu
->cpu_index
< plugin
.num_vcpus
) {
523 plugin_vcpu_cb__simple(cpu
, QEMU_PLUGIN_EV_VCPU_RESUME
);
527 void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id
,
528 qemu_plugin_vcpu_simple_cb_t cb
)
530 plugin_register_cb(id
, QEMU_PLUGIN_EV_VCPU_IDLE
, cb
);
533 void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id
,
534 qemu_plugin_vcpu_simple_cb_t cb
)
536 plugin_register_cb(id
, QEMU_PLUGIN_EV_VCPU_RESUME
, cb
);
539 void qemu_plugin_register_flush_cb(qemu_plugin_id_t id
,
540 qemu_plugin_simple_cb_t cb
)
542 plugin_register_cb(id
, QEMU_PLUGIN_EV_FLUSH
, cb
);
545 static bool free_dyn_cb_arr(void *p
, uint32_t h
, void *userp
)
547 g_array_free((GArray
*) p
, true);
551 void qemu_plugin_flush_cb(void)
553 qht_iter_remove(&plugin
.dyn_cb_arr_ht
, free_dyn_cb_arr
, NULL
);
554 qht_reset(&plugin
.dyn_cb_arr_ht
);
556 plugin_cb__simple(QEMU_PLUGIN_EV_FLUSH
);
559 void exec_inline_op(enum plugin_dyn_cb_type type
,
560 struct qemu_plugin_inline_cb
*cb
,
563 char *ptr
= cb
->entry
.score
->data
->data
;
564 size_t elem_size
= g_array_get_element_size(
565 cb
->entry
.score
->data
);
566 size_t offset
= cb
->entry
.offset
;
567 uint64_t *val
= (uint64_t *)(ptr
+ offset
+ cpu_index
* elem_size
);
570 case PLUGIN_CB_INLINE_ADD_U64
:
573 case PLUGIN_CB_INLINE_STORE_U64
:
577 g_assert_not_reached();
581 void qemu_plugin_vcpu_mem_cb(CPUState
*cpu
, uint64_t vaddr
,
582 MemOpIdx oi
, enum qemu_plugin_mem_rw rw
)
584 GArray
*arr
= cpu
->neg
.plugin_mem_cbs
;
590 for (i
= 0; i
< arr
->len
; i
++) {
591 struct qemu_plugin_dyn_cb
*cb
=
592 &g_array_index(arr
, struct qemu_plugin_dyn_cb
, i
);
595 case PLUGIN_CB_MEM_REGULAR
:
596 if (rw
&& cb
->regular
.rw
) {
597 cb
->regular
.f
.vcpu_mem(cpu
->cpu_index
,
598 make_plugin_meminfo(oi
, rw
),
599 vaddr
, cb
->regular
.userp
);
602 case PLUGIN_CB_INLINE_ADD_U64
:
603 case PLUGIN_CB_INLINE_STORE_U64
:
604 if (rw
&& cb
->inline_insn
.rw
) {
605 exec_inline_op(cb
->type
, &cb
->inline_insn
, cpu
->cpu_index
);
609 g_assert_not_reached();
614 void qemu_plugin_atexit_cb(void)
616 plugin_cb__udata(QEMU_PLUGIN_EV_ATEXIT
);
619 void qemu_plugin_register_atexit_cb(qemu_plugin_id_t id
,
620 qemu_plugin_udata_cb_t cb
,
623 plugin_register_cb_udata(id
, QEMU_PLUGIN_EV_ATEXIT
, cb
, udata
);
627 * Handle exit from linux-user. Unlike the normal atexit() mechanism
628 * we need to handle the clean-up manually as it's possible threads
629 * are still running. We need to remove all callbacks from code
630 * generation, flush the current translations and then we can safely
631 * trigger the exit callbacks.
634 void qemu_plugin_user_exit(void)
636 enum qemu_plugin_event ev
;
640 * Locking order: we must acquire locks in an order that is consistent
641 * with the one in fork_start(). That is:
642 * - start_exclusive(), which acquires qemu_cpu_list_lock,
643 * must be called before acquiring plugin.lock.
644 * - tb_flush(), which acquires mmap_lock(), must be called
645 * while plugin.lock is not held.
649 qemu_rec_mutex_lock(&plugin
.lock
);
650 /* un-register all callbacks except the final AT_EXIT one */
651 for (ev
= 0; ev
< QEMU_PLUGIN_EV_MAX
; ev
++) {
652 if (ev
!= QEMU_PLUGIN_EV_ATEXIT
) {
653 struct qemu_plugin_cb
*cb
, *next
;
655 QLIST_FOREACH_SAFE_RCU(cb
, &plugin
.cb_lists
[ev
], entry
, next
) {
656 plugin_unregister_cb__locked(cb
->ctx
, ev
);
661 qemu_plugin_disable_mem_helpers(cpu
);
663 qemu_rec_mutex_unlock(&plugin
.lock
);
665 tb_flush(current_cpu
);
668 /* now it's safe to handle the exit case */
669 qemu_plugin_atexit_cb();
673 * Helpers for *-user to ensure locks are sane across fork() events.
676 void qemu_plugin_user_prefork_lock(void)
678 qemu_rec_mutex_lock(&plugin
.lock
);
681 void qemu_plugin_user_postfork(bool is_child
)
684 /* should we just reset via plugin_init? */
685 qemu_rec_mutex_init(&plugin
.lock
);
687 qemu_rec_mutex_unlock(&plugin
.lock
);
691 static bool plugin_dyn_cb_arr_cmp(const void *ap
, const void *bp
)
696 static void __attribute__((__constructor__
)) plugin_init(void)
700 for (i
= 0; i
< QEMU_PLUGIN_EV_MAX
; i
++) {
701 QLIST_INIT(&plugin
.cb_lists
[i
]);
703 qemu_rec_mutex_init(&plugin
.lock
);
704 plugin
.id_ht
= g_hash_table_new(g_int64_hash
, g_int64_equal
);
705 plugin
.cpu_ht
= g_hash_table_new(g_int_hash
, g_int_equal
);
706 QLIST_INIT(&plugin
.scoreboards
);
707 plugin
.scoreboard_alloc_size
= 16; /* avoid frequent reallocation */
708 QTAILQ_INIT(&plugin
.ctxs
);
709 qht_init(&plugin
.dyn_cb_arr_ht
, plugin_dyn_cb_arr_cmp
, 16,
710 QHT_MODE_AUTO_RESIZE
);
711 atexit(qemu_plugin_atexit_cb
);
714 int plugin_num_vcpus(void)
716 return plugin
.num_vcpus
;
719 struct qemu_plugin_scoreboard
*plugin_scoreboard_new(size_t element_size
)
721 struct qemu_plugin_scoreboard
*score
=
722 g_malloc0(sizeof(struct qemu_plugin_scoreboard
));
723 score
->data
= g_array_new(FALSE
, TRUE
, element_size
);
724 g_array_set_size(score
->data
, plugin
.scoreboard_alloc_size
);
726 qemu_rec_mutex_lock(&plugin
.lock
);
727 QLIST_INSERT_HEAD(&plugin
.scoreboards
, score
, entry
);
728 qemu_rec_mutex_unlock(&plugin
.lock
);
733 void plugin_scoreboard_free(struct qemu_plugin_scoreboard
*score
)
735 qemu_rec_mutex_lock(&plugin
.lock
);
736 QLIST_REMOVE(score
, entry
);
737 qemu_rec_mutex_unlock(&plugin
.lock
);
739 g_array_free(score
->data
, TRUE
);