motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-02 07:13:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

plugins: distinct types for callbacks

Browse source 
To prevent errors when writing new types of callbacks or inline
operations, we split callbacks data to distinct types.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
Message-Id: <20240502211522.346467-8-pierrick.bouvier@linaro.org>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-Id: <20240514174253.694591-10-alex.bennee@linaro.org>
This commit is contained in:
Pierrick Bouvier 2024-05-14 18:42:51 +01:00 • committed by Alex Bennée
parent 544595e730
commit f86fd4d872
4 changed files with 99 additions and 85 deletions
Download patch file Download diff file Expand all files Collapse all files

76
plugins/core.c
View file

@ -336,13 +336,13 @@ void plugin_register_inline_op_on_entry(GArray **arr,
{
struct qemu_plugin_dyn_cb *dyn_cb;
struct qemu_plugin_inline_cb inline_cb = { .rw = rw,
.entry = entry,
.op = op,
.imm = imm };
dyn_cb = plugin_get_dyn_cb(arr);
dyn_cb->userp = NULL;
dyn_cb->type = op_to_cb_type(op);
dyn_cb->rw = rw;
dyn_cb->inline_insn.entry = entry;
dyn_cb->inline_insn.op = op;
dyn_cb->inline_insn.imm = imm;
dyn_cb->inline_insn = inline_cb;
}
void plugin_register_dyn_cb__udata(GArray **arr,
@ -361,14 +361,14 @@ void plugin_register_dyn_cb__udata(GArray **arr,
dh_typemask(i32, 1) |
dh_typemask(ptr, 2))
};
assert((unsigned)flags < ARRAY_SIZE(info));
struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
dyn_cb->userp = udata;
struct qemu_plugin_regular_cb regular_cb = { .f.vcpu_udata = cb,
.userp = udata,
.info = &info[flags] };
dyn_cb->type = PLUGIN_CB_REGULAR;
dyn_cb->regular.f.vcpu_udata = cb;
assert((unsigned)flags < ARRAY_SIZE(info));
dyn_cb->regular.info = &info[flags];
dyn_cb->regular = regular_cb;
}
void plugin_register_dyn_cond_cb__udata(GArray **arr,
@ -390,17 +390,17 @@ void plugin_register_dyn_cond_cb__udata(GArray **arr,
dh_typemask(i32, 1) |
dh_typemask(ptr, 2))
};
assert((unsigned)flags < ARRAY_SIZE(info));
struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
dyn_cb->userp = udata;
struct qemu_plugin_conditional_cb cond_cb = { .userp = udata,
.f.vcpu_udata = cb,
.cond = cond,
.entry = entry,
.imm = imm,
.info = &info[flags] };
dyn_cb->type = PLUGIN_CB_COND;
dyn_cb->cond.f.vcpu_udata = cb;
dyn_cb->cond.cond = cond;
dyn_cb->cond.entry = entry;
dyn_cb->cond.imm = imm;
assert((unsigned)flags < ARRAY_SIZE(info));
dyn_cb->cond.info = &info[flags];
dyn_cb->cond = cond_cb;
}
void plugin_register_vcpu_mem_cb(GArray **arr,
@ -432,15 +432,15 @@ void plugin_register_vcpu_mem_cb(GArray **arr,
dh_typemask(i64, 3) |
dh_typemask(ptr, 4))
};
assert((unsigned)flags < ARRAY_SIZE(info));
struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
dyn_cb->userp = udata;
struct qemu_plugin_regular_cb regular_cb = { .userp = udata,
.rw = rw,
.f.vcpu_mem = cb,
.info = &info[flags] };
dyn_cb->type = PLUGIN_CB_MEM_REGULAR;
dyn_cb->rw = rw;
dyn_cb->regular.f.vcpu_mem = cb;
assert((unsigned)flags < ARRAY_SIZE(info));
dyn_cb->regular.info = &info[flags];
dyn_cb->regular = regular_cb;
}
/*
@ -557,20 +557,20 @@ void qemu_plugin_flush_cb(void)
plugin_cb__simple(QEMU_PLUGIN_EV_FLUSH);
}
void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index)
void exec_inline_op(struct qemu_plugin_inline_cb *cb, int cpu_index)
{
char *ptr = cb->inline_insn.entry.score->data->data;
char *ptr = cb->entry.score->data->data;
size_t elem_size = g_array_get_element_size(
cb->inline_insn.entry.score->data);
size_t offset = cb->inline_insn.entry.offset;
cb->entry.score->data);
size_t offset = cb->entry.offset;
uint64_t *val = (uint64_t *)(ptr + offset + cpu_index * elem_size);
switch (cb->inline_insn.op) {
switch (cb->op) {
case QEMU_PLUGIN_INLINE_ADD_U64:
*val += cb->inline_insn.imm;
*val += cb->imm;
break;
case QEMU_PLUGIN_INLINE_STORE_U64:
*val = cb->inline_insn.imm;
*val = cb->imm;
break;
default:
g_assert_not_reached();
@ -590,17 +590,19 @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
struct qemu_plugin_dyn_cb *cb =
&g_array_index(arr, struct qemu_plugin_dyn_cb, i);
if (!(rw & cb->rw)) {
break;
}
switch (cb->type) {
case PLUGIN_CB_MEM_REGULAR:
cb->regular.f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw),
vaddr, cb->userp);
if (rw && cb->regular.rw) {
cb->regular.f.vcpu_mem(cpu->cpu_index,
make_plugin_meminfo(oi, rw),
vaddr, cb->regular.userp);
}
break;
case PLUGIN_CB_INLINE_ADD_U64:
case PLUGIN_CB_INLINE_STORE_U64:
exec_inline_op(cb, cpu->cpu_index);
if (rw && cb->inline_insn.rw) {
exec_inline_op(&cb->inline_insn, cpu->cpu_index);
}
break;
default:
g_assert_not_reached();