Add additional plugin API functions to read and write memory and registers
v14 cover Add additional plugin API functions to read and write memory and registers
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
The new qemu_plugin_write_register utilizes gdb_write_register, which is now declared in gdbstub.h for this purpose instead of being static.
qemu_plugin_write_memory_vaddr utilizes cpu_memory_rw_debug much the same as the existing read_memory_vaddr function does.
The read and write_hwaddr functions are the most different. These functions use address_space_rw, which works well in most cases. There is an important caveat that for writes, the page being written will be set dirty by the write operation. This dirty setting requires locking the page range, which can contend with an already held lock in page_collection_lock when called in a tb translate callback with a write to the instruction memory in the tb. The doc comments warn against doing this, and it's unlikely anyone would want to do this.
I've also added two test plugins: one that implements a simple hypercall interface that guest code can use to communicate with the plugin in a structured way with a test to ensure that this hypercall works and writing virtual memory works. And one that implements a simple patch utility to patch memory at runtime. The test for the second plugin ensures the patch applies successfully to instruction memory, and can use both hw and vaddr methods.
For v3, I've had a few comments from the last submission that I've addressed, and some that I haven't for one reason or another:
- Enforce QEMU_PLUGIN_CB_ flags in register read/write operations: done!
- Fix my commit messages and add long messages describing commits: done!
- Un-expose AS internals: done! Functions operate on current vCPU, current AS.
- Clean up use of current_cpu: done!
- Make functions take a vcpu_idx: not done. May revisit but it allows footguns. Even for translation, seems best to not do this now. We can easily add _vcpu versions of these functions in the future if we change our minds!
For v5, I've just updated the enforcement of the QEMU_PLUGIN_CB_ flags to just use immediate stores, which simplifies the implementation quite a lot and should be more efficient too. Thanks Pierrick for the suggestion!
v6 is a formatting pass, I left some whitespace that needed removal, some license text was wrong, and so forth.
v8 reverts a mistake I made extending the size of arrays of TCGHelperInfo structs, as I misunderstood their sizes. It preserves adding an explicit zero as the last entry for clarity, however.
v9 fixes qemu_plugin_read_register to return -1 on parameter or flag state error instead of 0.
In v10, I relaxed the restriction on when the register r/w functions can be called, allowing all them to be used from any callback where the CPU is not currently executing, with additional notes in the documentation for exceptions (atexit and flush, which do not operate on a specific CPU and in which current_cpu is not set).
v11 makes the cb flags functions inline and fixes a typo where cpu was asserted but current_cpu was actually accessed.
v12 removes the hypercalls plugin because the functions it tested are also tested by the patcher plugin, making it redundant. We'll circle back on a hypercalls API in the future as a part of the plugin API, not as a plugin itself.
v13 fixes up some issues Alex pointed out with the patch test. Now, the patch target only runs with libpatch.so, and libpatch.so only runs with the patch test.
v14 addresses a build issue Alex pointed out with the patch test, and removes a few vestigial lines according to Alex's suggestion. I split this out into another commit as it's not actually coupled to the patch test.
Rowan Hart (8):
gdbstub: Expose gdb_write_register function to consumers of gdbstub
plugins: Add register write API
plugins: Add enforcement of QEMU_PLUGIN_CB flags in register R/W
callbacks
plugins: Add memory virtual address write API
plugins: Add memory hardware address read/write API tests/tcg: Remove copy-pasted notes and from i386 and add x86_64
system tests to tests
plugins: Add patcher plugin and test
plugins: Update plugin version and add notes
accel/tcg/plugin-gen.c | 30 +++ gdbstub/gdbstub.c | 2 +- include/exec/gdbstub.h | 14 ++ include/hw/core/cpu.h | 1 + include/qemu/plugin.h | 15 ++ include/qemu/qemu-plugin.h | 176 ++++++++++++++-- plugins/api.c | 135 +++++++++++- plugins/core.c | 33 +++ tests/tcg/Makefile.target | 7 +- tests/tcg/plugins/meson.build | 2 +- tests/tcg/plugins/patch.c | 241 ++++++++++++++++++++++ tests/tcg/x86_64/Makefile.softmmu-target | 19 +- tests/tcg/x86_64/system/patch-target.c | 22 ++ tests/tcg/x86_64/system/validate-patch.py | 39 ++++ 14 files changed, 710 insertions(+), 26 deletions(-) create mode 100644 tests/tcg/plugins/patch.c create mode 100644 tests/tcg/x86_64/system/patch-target.c create mode 100755 tests/tcg/x86_64/system/validate-patch.py
Signature · 1 line
2.49.0
PATCH v14 1/8 gdbstub: Expose gdb_write_register function to consumers of gdbstub
This patch exposes the gdb_write_register function from gdbstub/gdbstub.c via the exec/gdbstub.h header file to support use in plugins to write register contents.
--- gdbstub/gdbstub.c | 2 +- include/exec/gdbstub.h | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-)
gdbstub/gdbstub.c +1 -1
@@ -535,7 +535,7 @@ int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)return 0 ; } -static int gdb_write_register (CPUState *cpu,uint8_t *mem_buf,int reg) +int gdb_write_register (CPUState *cpu,uint8_t *mem_buf,int reg) {GDBRegisterState *r;
include/exec/gdbstub.h +14 -0
@@ -124,6 +124,20 @@ const GDBFeature *gdb_find_static_feature(const char *xmlname);*/ int gdb_read_register (CPUState *cpu,GByteArray *buf,int reg); +/** +* gdb_write_register() - Write a register associated with a CPU. +* @cpu: The CPU associated with the register. +* @buf: The buffer that the register contents will be set to. +* @reg: The register's number returned by gdb_find_feature_register(). +* +* The size of @buf must be at least the size of the register being +* written. +* +* Return: The number of written bytes, or 0 if an error occurred (for +* example, an unknown register was provided). +*/ +int gdb_write_register (CPUState *cpu,uint8_t *mem_buf,int reg); +/** * typedef GDBRegDesc - a register description from gdbstub */
Signature · 1 line
2.49.0
PATCH v14 2/8 plugins: Add register write API
In reply to Rowan HartThis patch adds a function to the plugins API to allow plugins to write register contents. It also moves the qemu_plugin_read_register function so all the register-related functions are grouped together in the file.
--- include/qemu/qemu-plugin.h | 54 ++++++++++++++++++++++++++------------ plugins/api.c | 26 +++++++++++++----- 2 files changed, 56 insertions(+), 24 deletions(-)
include/qemu/qemu-plugin.h +37 -17
@@ -871,7 +871,8 @@ struct qemu_plugin_register;/** * typedef qemu_plugin_reg_descriptor - register descriptions * -* @handle: opaque handle for retrieving value with qemu_plugin_read_register +* @handle: opaque handle for retrieving value with qemu_plugin_read_register or +* writing value with qemu_plugin_write_register * @name: register name * @feature: optional feature descriptor, can be NULL */
@@ -893,6 +894,41 @@ typedef struct {QEMU_PLUGIN_API GArray *qemu_plugin_get_registers(void); +/** +* qemu_plugin_read_register() - read register for current vCPU +* +* @handle: a @qemu_plugin_reg_handle handle +* @buf: A GByteArray for the data owned by the plugin +* +* This function is only available in a context that register read access is +* explicitly requested via the QEMU_PLUGIN_CB_R_REGS flag. +* +* Returns the size of the read register. The content of @buf is in target byte +* order. On failure returns -1. +*/ +QEMU_PLUGIN_API +int qemu_plugin_read_register(struct qemu_plugin_register *handle, +GByteArray *buf); + +/** +* qemu_plugin_write_register() - write register for current vCPU +* +* @handle: a @qemu_plugin_reg_handle handle +* @buf: A GByteArray for the data owned by the plugin +* +* This function is only available in a context that register write access is +* explicitly requested via the QEMU_PLUGIN_CB_RW_REGS flag. +* +* The size of @buf must be at least the size of the requested register. +* Attempting to write a register with @buf smaller than the register size +* will result in a crash or other undesired behavior. +* +* Returns the number of bytes written. On failure returns 0. +*/ +QEMU_PLUGIN_API +int qemu_plugin_write_register(struct qemu_plugin_register *handle, +GByteArray *buf); +/** * qemu_plugin_read_memory_vaddr() - read from memory using a virtual address *
@@ -915,22 +951,6 @@ QEMU_PLUGIN_APIbool qemu_plugin_read_memory_vaddr (uint64_t addr,GByteArray *data,size_t len); -/** -* qemu_plugin_read_register() - read register for current vCPU -* -* @handle: a @qemu_plugin_reg_handle handle -* @buf: A GByteArray for the data owned by the plugin -* -* This function is only available in a context that register read access is -* explicitly requested via the QEMU_PLUGIN_CB_R_REGS flag. -* -* Returns the size of the read register. The content of @buf is in target byte -* order. On failure returns -1. -*/ -QEMU_PLUGIN_API -int qemu_plugin_read_register(struct qemu_plugin_register *handle, -GByteArray *buf); -/** * qemu_plugin_scoreboard_new() - alloc a new scoreboard *
plugins/api.c +19 -7
@@ -433,6 +433,25 @@ GArray *qemu_plugin_get_registers(void)return create_register_handles (regs); } +int qemu_plugin_read_register (struct qemu_plugin_register *reg,GByteArray *buf) +{ +g_assert (current_cpu); + +return gdb_read_register (current_cpu, buf,GPOINTER_TO_INT (reg) -1 ); +} + +int qemu_plugin_write_register (struct qemu_plugin_register *reg, +GByteArray *buf) +{ +g_assert (current_cpu); + +if (buf->len ==0 ||qemu_plugin_get_cb_flags () !=QEMU_PLUGIN_CB_RW_REGS ) { +return -1 ; + } + +return gdb_write_register (current_cpu, buf->data,GPOINTER_TO_INT (reg) -1 ); +} +bool qemu_plugin_read_memory_vaddr (uint64_t addr,GByteArray *data,size_t len) {g_assert (current_cpu);
@@ -453,13 +472,6 @@ bool qemu_plugin_read_memory_vaddr(uint64_t addr, GByteArray *data, size_t len)return true; } -int qemu_plugin_read_register (struct qemu_plugin_register *reg,GByteArray *buf) -{ -g_assert (current_cpu); - -return gdb_read_register (current_cpu, buf,GPOINTER_TO_INT (reg) -1 ); -} -struct qemu_plugin_scoreboard *qemu_plugin_scoreboard_new (size_t element_size) {return plugin_scoreboard_new (element_size);
Signature · 1 line
2.49.0
PATCH v14 3/8 plugins: Add enforcement of QEMU_PLUGIN_CB flags in register R/W callbacks
In reply to Rowan HartThis patch adds functionality to enforce the requested QEMU_PLUGIN_CB_ flags level passed when registering a callback function using the plugins API. Each time a callback is about to be invoked, a thread-local variable will be updated with the level that callback requested. Then, called API functions (in particular, the register read and write API) will call qemu_plugin_get_cb_flags() to check the level is at least the level they require.
--- accel/tcg/plugin-gen.c | 30 ++++++++++++++++++++++++++++++ include/hw/core/cpu.h | 1 + include/qemu/plugin.h | 15 +++++++++++++++ include/qemu/qemu-plugin.h | 19 +++++++++++++------ plugins/api.c | 4 ++++ plugins/core.c | 33 +++++++++++++++++++++++++++++++++ 6 files changed, 96 insertions(+), 6 deletions(-)
accel/tcg/plugin-gen.c +30 -0
@@ -117,10 +117,20 @@ static TCGv_i32 gen_cpu_index(void)static void gen_udata_cb (struct qemu_plugin_regular_cb *cb) {TCGv_i32 cpu_index =gen_cpu_index (); +enum qemu_plugin_cb_flags cb_flags = +tcg_call_to_qemu_plugin_cb_flags (cb->info->flags); +TCGv_i32 flags =tcg_constant_i32 (cb_flags); +TCGv_i32 clear_flags =tcg_constant_i32 (QEMU_PLUGIN_CB_NO_REGS ); +tcg_gen_st_i32 (flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_gen_call2 (cb->f.vcpu_udata, cb->info,NULL ,tcgv_i32_temp (cpu_index),tcgv_ptr_temp (tcg_constant_ptr (cb->userp))); +tcg_gen_st_i32 (clear_flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_temp_free_i32 (cpu_index); +tcg_temp_free_i32 (flags); +tcg_temp_free_i32 (clear_flags); }static TCGv_ptr gen_plugin_u64_ptr (qemu_plugin_u64 entry)
@@ -173,10 +183,20 @@ static void gen_udata_cond_cb(struct qemu_plugin_conditional_cb *cb)tcg_gen_ld_i64 (val, ptr,0 );tcg_gen_brcondi_i64 (cond, val, cb->imm, after_cb);TCGv_i32 cpu_index =gen_cpu_index (); +enum qemu_plugin_cb_flags cb_flags = +tcg_call_to_qemu_plugin_cb_flags (cb->info->flags); +TCGv_i32 flags =tcg_constant_i32 (cb_flags); +TCGv_i32 clear_flags =tcg_constant_i32 (QEMU_PLUGIN_CB_NO_REGS ); +tcg_gen_st_i32 (flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_gen_call2 (cb->f.vcpu_udata, cb->info,NULL ,tcgv_i32_temp (cpu_index),tcgv_ptr_temp (tcg_constant_ptr (cb->userp))); +tcg_gen_st_i32 (clear_flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_temp_free_i32 (cpu_index); +tcg_temp_free_i32 (flags); +tcg_temp_free_i32 (clear_flags);gen_set_label (after_cb);tcg_temp_free_i64 (val);
@@ -210,12 +230,22 @@ static void gen_mem_cb(struct qemu_plugin_regular_cb *cb, qemu_plugin_meminfo_t meminfo, TCGv_i64 addr) {TCGv_i32 cpu_index =gen_cpu_index (); +enum qemu_plugin_cb_flags cb_flags = +tcg_call_to_qemu_plugin_cb_flags (cb->info->flags); +TCGv_i32 flags =tcg_constant_i32 (cb_flags); +TCGv_i32 clear_flags =tcg_constant_i32 (QEMU_PLUGIN_CB_NO_REGS ); +tcg_gen_st_i32 (flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_gen_call4 (cb->f.vcpu_mem, cb->info,NULL ,tcgv_i32_temp (cpu_index),tcgv_i32_temp (tcg_constant_i32 (meminfo)),tcgv_i64_temp (addr),tcgv_ptr_temp (tcg_constant_ptr (cb->userp))); +tcg_gen_st_i32 (clear_flags, tcg_env, + offsetof(CPUState, neg.plugin_cb_flags) - sizeof(CPUState));tcg_temp_free_i32 (cpu_index); +tcg_temp_free_i32 (flags); +tcg_temp_free_i32 (clear_flags); }static void inject_cb (struct qemu_plugin_dyn_cb *cb)
include/hw/core/cpu.h +1 -0
@@ -368,6 +368,7 @@ typedef struct CPUNegativeOffsetState {GArray *plugin_mem_cbs;uint64_t plugin_mem_value_low;uint64_t plugin_mem_value_high; +int32_t plugin_cb_flags;#endif IcountDecr icount_decr;bool can_do_io;
include/qemu/plugin.h +15 -0
@@ -209,6 +209,21 @@ void qemu_plugin_user_prefork_lock(void);*/ void qemu_plugin_user_postfork (bool is_child); +enum qemu_plugin_cb_flags tcg_call_to_qemu_plugin_cb_flags (int flags); + +static inline void qemu_plugin_set_cb_flags (CPUState *cpu, +enum qemu_plugin_cb_flags flags) +{ +assert (cpu); + cpu->neg.plugin_cb_flags = flags; +} + +static inline enum qemu_plugin_cb_flags qemu_plugin_get_cb_flags (void ) +{ +assert (current_cpu); +return current_cpu->neg.plugin_cb_flags; +} +#else /* !CONFIG_PLUGIN */ static inline void qemu_plugin_add_opts (void )
include/qemu/qemu-plugin.h +13 -6
@@ -254,9 +254,6 @@ typedef struct {* @QEMU_PLUGIN_CB_NO_REGS: callback does not access the CPU's regs * @QEMU_PLUGIN_CB_R_REGS: callback reads the CPU's regs * @QEMU_PLUGIN_CB_RW_REGS: callback reads and writes the CPU's regs -* -* Note: currently QEMU_PLUGIN_CB_RW_REGS is unused, plugins cannot change -* system register state. */ enum qemu_plugin_cb_flags {QEMU_PLUGIN_CB_NO_REGS ,
@@ -901,7 +898,12 @@ GArray *qemu_plugin_get_registers(void);* @buf: A GByteArray for the data owned by the plugin * * This function is only available in a context that register read access is -* explicitly requested via the QEMU_PLUGIN_CB_R_REGS flag. +* explicitly requested via the QEMU_PLUGIN_CB_R_REGS flag, if called inside a +* callback that can be registered with a qemu_plugin_cb_flags argument. This +* function can also be used in any callback context that does not use a flags +* argument, such as in a callback registered with +* qemu_plugin_register_vcpu_init_cb(), except for callbacks registered with +* qemu_plugin_register_atexit_cb() and qemu_plugin_register_flush_cb(). * * Returns the size of the read register. The content of @buf is in target byte * order. On failure returns -1.
@@ -916,8 +918,13 @@ int qemu_plugin_read_register(struct qemu_plugin_register *handle,* @handle: a @qemu_plugin_reg_handle handle * @buf: A GByteArray for the data owned by the plugin * -* This function is only available in a context that register write access is -* explicitly requested via the QEMU_PLUGIN_CB_RW_REGS flag. +* This function is only available in a context that register read access is +* explicitly requested via the QEMU_PLUGIN_CB_RW_REGS flag, if called inside a +* callback that can be registered with a qemu_plugin_cb_flags argument. This +* function can also be used in any callback context that does not use a flags +* argument, such as in a callback registered with +* qemu_plugin_register_vcpu_init_cb(), except for callbacks registered with +* qemu_plugin_register_atexit_cb() and qemu_plugin_register_flush_cb(). * * The size of @buf must be at least the size of the requested register. * Attempting to write a register with @buf smaller than the register size
plugins/api.c +4 -0
@@ -437,6 +437,10 @@ int qemu_plugin_read_register(struct qemu_plugin_register *reg, GByteArray *buf) {g_assert (current_cpu); +if (qemu_plugin_get_cb_flags () ==QEMU_PLUGIN_CB_NO_REGS ) { +return -1 ; + } +return gdb_read_register (current_cpu, buf,GPOINTER_TO_INT (reg) -1 ); }
plugins/core.c +33 -0
@@ -15,6 +15,7 @@#include "qemu/lockable.h" #include "qemu/option.h" #include "qemu/plugin.h" +#include "qemu/qemu-plugin.h" #include "qemu/queue.h" #include "qemu/rcu_queue.h" #include "qemu/rcu.h"
@@ -266,7 +267,9 @@ static void qemu_plugin_vcpu_init__async(CPUState *cpu, run_on_cpu_data unused)plugin_grow_scoreboards__locked (cpu);qemu_rec_mutex_unlock (&plugin.lock); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );plugin_vcpu_cb__simple (cpu,QEMU_PLUGIN_EV_VCPU_INIT ); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); }void qemu_plugin_vcpu_init_hook (CPUState *cpu)
@@ -279,7 +282,9 @@ void qemu_plugin_vcpu_exit_hook(CPUState *cpu) {bool success; +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );plugin_vcpu_cb__simple (cpu,QEMU_PLUGIN_EV_VCPU_EXIT ); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS );assert (cpu->cpu_index !=UNASSIGNED_CPU_INDEX );qemu_rec_mutex_lock (&plugin.lock);
@@ -367,6 +372,7 @@ void plugin_register_dyn_cb__udata(GArray **arr,static TCGHelperInfo info[3 ] = { [QEMU_PLUGIN_CB_NO_REGS ].flags =TCG_CALL_NO_RWG , [QEMU_PLUGIN_CB_R_REGS ].flags =TCG_CALL_NO_WG , + [QEMU_PLUGIN_CB_RW_REGS ].flags =0 ,/* * Match qemu_plugin_vcpu_udata_cb_t: * void (*)(uint32_t, void *)
@@ -396,6 +402,7 @@ void plugin_register_dyn_cond_cb__udata(GArray **arr,static TCGHelperInfo info[3 ] = { [QEMU_PLUGIN_CB_NO_REGS ].flags =TCG_CALL_NO_RWG , [QEMU_PLUGIN_CB_R_REGS ].flags =TCG_CALL_NO_WG , + [QEMU_PLUGIN_CB_RW_REGS ].flags =0 ,/* * Match qemu_plugin_vcpu_udata_cb_t: * void (*)(uint32_t, void *)
@@ -434,6 +441,7 @@ void plugin_register_vcpu_mem_cb(GArray **arr,static TCGHelperInfo info[3 ] = { [QEMU_PLUGIN_CB_NO_REGS ].flags =TCG_CALL_NO_RWG , [QEMU_PLUGIN_CB_R_REGS ].flags =TCG_CALL_NO_WG , + [QEMU_PLUGIN_CB_RW_REGS ].flags =0 ,/* * Match qemu_plugin_vcpu_mem_cb_t: * void (*)(uint32_t, qemu_plugin_meminfo_t, uint64_t, void *)
@@ -473,7 +481,9 @@ void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb) QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {qemu_plugin_vcpu_tb_trans_cb_t func = cb->f.vcpu_tb_trans; +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );func (cb->ctx->id, tb); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); } }
@@ -498,7 +508,9 @@ qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2, QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {qemu_plugin_vcpu_syscall_cb_t func = cb->f.vcpu_syscall; +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );func (cb->ctx->id, cpu->cpu_index, num, a1, a2, a3, a4, a5, a6, a7, a8); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); } }
@@ -520,7 +532,9 @@ void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret) QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {qemu_plugin_vcpu_syscall_ret_cb_t func = cb->f.vcpu_syscall_ret; +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );func (cb->ctx->id, cpu->cpu_index, num, ret); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); } }
@@ -528,14 +542,18 @@ void qemu_plugin_vcpu_idle_cb(CPUState *cpu) {/* idle and resume cb may be called before init, ignore in this case */ if (cpu->cpu_index < plugin.num_vcpus) { +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );plugin_vcpu_cb__simple (cpu,QEMU_PLUGIN_EV_VCPU_IDLE ); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); } }void qemu_plugin_vcpu_resume_cb (CPUState *cpu) {if (cpu->cpu_index < plugin.num_vcpus) { +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_RW_REGS );plugin_vcpu_cb__simple (cpu,QEMU_PLUGIN_EV_VCPU_RESUME ); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); } }
@@ -615,9 +633,13 @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,switch (cb->type) {case PLUGIN_CB_MEM_REGULAR :if (rw & cb->regular.rw) { +qemu_plugin_set_cb_flags (cpu, +tcg_call_to_qemu_plugin_cb_flags (cb->regular.info->flags)); + cb->regular.f.vcpu_mem (cpu->cpu_index,make_plugin_meminfo (oi, rw), vaddr, cb->regular.userp); +qemu_plugin_set_cb_flags (cpu,QEMU_PLUGIN_CB_NO_REGS ); }break ;case PLUGIN_CB_INLINE_ADD_U64 :
@@ -760,3 +782,14 @@ void plugin_scoreboard_free(struct qemu_plugin_scoreboard *score)g_array_free (score->data, TRUE);g_free (score); } + +enum qemu_plugin_cb_flags tcg_call_to_qemu_plugin_cb_flags (int flags) +{ +if (flags &TCG_CALL_NO_RWG ) { +return QEMU_PLUGIN_CB_NO_REGS ; + }else if (flags &TCG_CALL_NO_WG ) { +return QEMU_PLUGIN_CB_R_REGS ; + }else { +return QEMU_PLUGIN_CB_RW_REGS ; + } +}
Signature · 1 line
2.49.0
PATCH v14 4/8 plugins: Add memory virtual address write API
In reply to Rowan HartThis patch adds functions to the plugins API to allow reading and writing memory via virtual addresses. These functions only permit doing so on the current CPU, because there is no way to ensure consistency if plugins are allowed to read or write to other CPUs that aren't currently in the context of the plugin.
--- include/qemu/qemu-plugin.h | 21 +++++++++++++++++++++ plugins/api.c | 18 ++++++++++++++++++ 2 files changed, 39 insertions(+)
include/qemu/qemu-plugin.h +21 -0
@@ -958,6 +958,27 @@ QEMU_PLUGIN_APIbool qemu_plugin_read_memory_vaddr (uint64_t addr,GByteArray *data,size_t len); +/** +* qemu_plugin_write_memory_vaddr() - write to memory using a virtual address +* +* @addr: A virtual address to write to +* @data: A byte array containing the data to write +* +* The contents of @data will be written to memory starting at the virtual +* address @addr. +* +* This function does not guarantee consistency of writes, nor does it ensure +* that pending writes are flushed either before or after the write takes place, +* so callers should take care to only call this function in vCPU context (i.e. +* in callbacks) and avoid depending on the existence of data written using this +* function which may be overwritten afterward. +* +* Returns true on success and false on failure. +*/ +QEMU_PLUGIN_API +bool qemu_plugin_write_memory_vaddr(uint64_t addr, +GByteArray *data); +/** * qemu_plugin_scoreboard_new() - alloc a new scoreboard *
plugins/api.c +18 -0
@@ -476,6 +476,24 @@ bool qemu_plugin_read_memory_vaddr(uint64_t addr, GByteArray *data, size_t len)return true; } +bool qemu_plugin_write_memory_vaddr (uint64_t addr,GByteArray *data) +{ +g_assert (current_cpu); + +if (data->len ==0 ) { +return false; + } + +int result =cpu_memory_rw_debug (current_cpu, addr, data->data, + data->len, true); + +if (result <0 ) { +return false; + } + +return true; +} +struct qemu_plugin_scoreboard *qemu_plugin_scoreboard_new (size_t element_size) {return plugin_scoreboard_new (element_size);
Signature · 1 line
2.49.0
PATCH v14 5/8 plugins: Add memory hardware address read/write API
In reply to Rowan HartThis patch adds functions to the plugins API to allow plugins to read and write memory via hardware addresses. The functions use the current address space of the current CPU in order to avoid exposing address space information to users. A later patch may want to add a function to permit a specified address space, for example to facilitate architecture-specific plugins that want to operate on them, for example reading ARM secure memory.
--- include/qemu/qemu-plugin.h | 93 ++++++++++++++++++++++++++++++++++++ plugins/api.c | 97 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 190 insertions(+)
include/qemu/qemu-plugin.h +93 -0
@@ -979,6 +979,99 @@ QEMU_PLUGIN_APIbool qemu_plugin_write_memory_vaddr (uint64_t addr,GByteArray *data); +/** +* enum qemu_plugin_hwaddr_operation_result - result of a memory operation +* +* @QEMU_PLUGIN_HWADDR_OPERATION_OK: hwaddr operation succeeded +* @QEMU_PLUGIN_HWADDR_OPERATION_ERROR: unexpected error occurred +* @QEMU_PLUGIN_HWADDR_OPERATION_DEVICE_ERROR: error in memory device +* @QEMU_PLUGIN_HWADDR_OPERATION_ACCESS_DENIED: permission error +* @QEMU_PLUGIN_HWADDR_OPERATION_INVALID_ADDRESS: address was invalid +* @QEMU_PLUGIN_HWADDR_OPERATION_INVALID_ADDRESS_SPACE: invalid address space +*/ +enum qemu_plugin_hwaddr_operation_result { +QEMU_PLUGIN_HWADDR_OPERATION_OK , +QEMU_PLUGIN_HWADDR_OPERATION_ERROR , +QEMU_PLUGIN_HWADDR_OPERATION_DEVICE_ERROR , +QEMU_PLUGIN_HWADDR_OPERATION_ACCESS_DENIED , +QEMU_PLUGIN_HWADDR_OPERATION_INVALID_ADDRESS , +QEMU_PLUGIN_HWADDR_OPERATION_INVALID_ADDRESS_SPACE , +}; + +/** +* qemu_plugin_read_memory_hwaddr() - read from memory using a hardware address +* +* @addr: The physical address to read from +* @data: A byte array to store data into +* @len: The number of bytes to read, starting from @addr +* +* @len bytes of data is read from the current memory space for the current +* vCPU starting at @addr and stored into @data. If @data is not large enough to +* hold @len bytes, it will be expanded to the necessary size, reallocating if +* necessary. @len must be greater than 0. +* +* This function does not ensure writes are flushed prior to reading, so +* callers should take care when calling this function in plugin callbacks to +* avoid attempting to read data which may not yet be written and should use +* the memory callback API instead. +* +* This function is only valid for softmmu targets. +* +* Returns a qemu_plugin_hwaddr_operation_result indicating the result of the +* operation. +*/ +QEMU_PLUGIN_API +enum qemu_plugin_hwaddr_operation_result +qemu_plugin_read_memory_hwaddr (uint64_t addr,GByteArray *data,size_t len); + +/** +* qemu_plugin_write_memory_hwaddr() - write to memory using a hardware address +* +* @addr: A physical address to write to +* @data: A byte array containing the data to write +* +* The contents of @data will be written to memory starting at the hardware +* address @addr in the current address space for the current vCPU. +* +* This function does not guarantee consistency of writes, nor does it ensure +* that pending writes are flushed either before or after the write takes place, +* so callers should take care when calling this function in plugin callbacks to +* avoid depending on the existence of data written using this function which +* may be overwritten afterward. In addition, this function requires that the +* pages containing the address are not locked. Practically, this means that you +* should not write instruction memory in a current translation block inside a +* callback registered with qemu_plugin_register_vcpu_tb_trans_cb. +* +* You can, for example, write instruction memory in a current translation block +* in a callback registered with qemu_plugin_register_vcpu_tb_exec_cb, although +* be aware that the write will not be flushed until after the translation block +* has finished executing. In general, this function should be used to write +* data memory or to patch code at a known address, not in a current translation +* block. +* +* This function is only valid for softmmu targets. +* +* Returns a qemu_plugin_hwaddr_operation_result indicating the result of the +* operation. +*/ +QEMU_PLUGIN_API +enum qemu_plugin_hwaddr_operation_result +qemu_plugin_write_memory_hwaddr (uint64_t addr,GByteArray *data); + +/** +* qemu_plugin_translate_vaddr() - translate virtual address for current vCPU +* +* @vaddr: virtual address to translate +* @hwaddr: pointer to store the physical address +* +* This function is only valid in vCPU context (i.e. in callbacks) and is only +* valid for softmmu targets. +* +* Returns true on success and false on failure. +*/ +QEMU_PLUGIN_API +bool qemu_plugin_translate_vaddr(uint64_t vaddr, uint64_t *hwaddr); +/** * qemu_plugin_scoreboard_new() - alloc a new scoreboard *
plugins/api.c +97 -0
109 lines not on this page · raw message
Signature · 1 line
2.49.0
PATCH v14 6/8 tests/tcg: Remove copy-pasted notes and from i386 and add x86_64 system tests to tests
In reply to Rowan HartThe x86_64-softmmu Makefile seems to have been copy-pasted from the i386 Makefile at some point in the past. Cleaning up a vestigial unused variable and removing some outdated comments.
--- tests/tcg/x86_64/Makefile.softmmu-target | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
tests/tcg/x86_64/Makefile.softmmu-target +5 -7
@@ -1,13 +1,11 @@ # -# x86 system tests -# -# This currently builds only for i386. The common C code is built -# with standard compiler flags however so we can support both by -# adding additional boot files for x86_64. +# x86_64 system tests # -I386_SYSTEM_SRC=$(SRC_PATH)/tests/tcg/i386/system X64_SYSTEM_SRC=$(SRC_PATH)/tests/tcg/x86_64/system +X64_SYSTEM_TESTS=$(patsubst $(X64_SYSTEM_SRC)/%.c, %, $(wildcard $(X64_SYSTEM_SRC)/*.c)) + +VPATH+=$(X64_SYSTEM_SRC) # These objects provide the basic boot code and helper functions for all tests CRT_OBJS=boot.o
@@ -18,7 +16,7 @@ LDFLAGS=-Wl,-T$(LINK_SCRIPT) -Wl,-melf_x86_64 CFLAGS+=-nostdlib -ggdb -O0 $(MINILIB_INC) LDFLAGS+=-static -nostdlib $(CRT_OBJS) $(MINILIB_OBJS) -lgcc -TESTS+=$(MULTIARCH_TESTS) +TESTS+=$(MULTIARCH_TESTS) $(X64_SYSTEM_TESTS) EXTRA_RUNS+=$(MULTIARCH_RUNS) # building head blobs
Signature · 1 line
2.49.0
PATCH v14 7/8 plugins: Add patcher plugin and test
In reply to Rowan HartThis patch adds a plugin that exercises the virtual and hardware memory read-write API functions added in a previous patch. The plugin takes a target and patch byte sequence, and will overwrite any instruction matching the target byte sequence with the patch.
--- tests/tcg/Makefile.target | 7 +- tests/tcg/plugins/meson.build | 2 +- tests/tcg/plugins/patch.c | 241 ++++++++++++++++++++++ tests/tcg/x86_64/Makefile.softmmu-target | 7 + tests/tcg/x86_64/system/patch-target.c | 22 ++ tests/tcg/x86_64/system/validate-patch.py | 39 ++++ 6 files changed, 316 insertions(+), 2 deletions(-) create mode 100644 tests/tcg/plugins/patch.c create mode 100644 tests/tcg/x86_64/system/patch-target.c create mode 100755 tests/tcg/x86_64/system/validate-patch.py
tests/tcg/Makefile.target +6 -1
@@ -151,7 +151,12 @@ ifeq ($(CONFIG_PLUGIN),y) PLUGIN_SRC=$(SRC_PATH)/tests/tcg/plugins PLUGIN_LIB=../plugins VPATH+=$(PLUGIN_LIB) -PLUGINS=$(patsubst %.c, lib%.so, $(notdir $(wildcard $(PLUGIN_SRC)/*.c))) +# Some plugins need to be disabled for all tests to avoid exponential explosion. +# For example, libpatch.so only needs to run against the arch-specific patch +# target test, so we explicitly run it in the arch-specific Makefile. +DISABLE_PLUGINS=libpatch.so +PLUGINS=$(filter-out $(DISABLE_PLUGINS), \ + $(patsubst %.c, lib%.so, $(notdir $(wildcard $(PLUGIN_SRC)/*.c)))) # We need to ensure expand the run-plugin-TEST-with-PLUGIN # pre-requistes manually here as we can't use stems to handle it. We
tests/tcg/plugins/meson.build +1 -1
@@ -1,6 +1,6 @@ t = [] if get_option('plugins') - foreach i : ['bb', 'empty', 'inline', 'insn', 'mem', 'reset', 'syscall'] + foreach i : ['bb', 'empty', 'inline', 'insn', 'mem', 'reset', 'syscall', 'patch'] if host_os == 'windows' t += shared_module(i, files(i + '.c') + '../../../contrib/plugins/win32_linker.c', include_directories: '../../../include/qemu',
tests/tcg/plugins/patch.c new file +241 -0
241 lines not on this page · raw message
tests/tcg/x86_64/Makefile.softmmu-target +7 -0
@@ -33,3 +33,10 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel + +run-plugin-patch-target-with-libpatch.so: \ + PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true +run-plugin-patch-target-with-libpatch.so: \ + CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] +run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so +EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so
tests/tcg/x86_64/system/patch-target.c new file +22 -0
@@ -0,0 +1,22 @@ +/* +* SPDX-License-Identifier: GPL-2.0-or-later +* +* This test target increments a value 100 times. The patcher converts the +* inc instruction to a nop, so it only increments the value once. +* +*/ +#include <minilib.h> + +int main (void ) +{ +ml_printf ("Running test...\n" ); +unsigned int x =0 ; +for (int i =0 ; i <100 ; i++) { + asmvolatile ( +"inc %[x]" + : [x]"+a" (x) + ); + } +ml_printf ("Value: %d\n" , x); +return 0 ; +}
tests/tcg/x86_64/system/validate-patch.py new file +39 -0
@@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +# +# validate-patch.py: check the patch applies +# +# This program takes two inputs: +# - the plugin output +# - the binary output +# +# Copyright (C) 2024 +# +# SPDX-License-Identifier: GPL-2.0-or-later + +import sys +from argparse import ArgumentParser + +def main() -> None: + """ + Process the arguments, injest the program and plugin out and + verify they match up and report if they do not. + """ + parser = ArgumentParser(description="Validate patch") + parser.add_argument('test_output', + help="The output from the test itself") + parser.add_argument('plugin_output', + help="The output from plugin") + args = parser.parse_args() + + with open(args.test_output, 'r') as f: + test_data = f.read() + with open(args.plugin_output, 'r') as f: + plugin_data = f.read() + if "Value: 1" in test_data: + sys.exit(0) + else: + sys.exit(1) + +if __name__ == "__main__": + main() +
Signature · 1 line
2.49.0
PATCH v14 8/8 plugins: Update plugin version and add notes
In reply to Rowan HartThis patch updates the plugin version to gate new APIs and adds notes describing what has been added.
--- include/qemu/qemu-plugin.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
include/qemu/qemu-plugin.h +8 -1
@@ -65,11 +65,18 @@ typedef uint64_t qemu_plugin_id_t;* * version 4: * - added qemu_plugin_read_memory_vaddr +* +* version 5: +* - added qemu_plugin_write_memory_vaddr +* - added qemu_plugin_read_memory_hwaddr +* - added qemu_plugin_write_memory_hwaddr +* - added qemu_plugin_write_register +* - added qemu_plugin_translate_vaddr */ extern QEMU_PLUGIN_EXPORT int qemu_plugin_version; -#define QEMU_PLUGIN_VERSION 4 +#define QEMU_PLUGIN_VERSION 5/** * struct qemu_info_t - system information for plugins
Signature · 1 line
2.49.0
Alex Bennée
AppliedQuoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
Signature · 2 lines
Alex Bennée Virtualisation Tech Lead @ Linaro
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failures
The tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target
@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1
# Running
QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel
+ifeq ($(CONFIG_PLUGIN),y)
run-plugin-patch-target-with-libpatch.so: \
PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true
run-plugin-patch-target-with-libpatch.so: \
CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected]
run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so
+endif
--8<---------------cut here---------------end--------------->8---
The other problem is trying to stuff a uint64_t into a void * on 32 bit. We did disable plugins for 32 bit but then reverted because we were able to fixup the cases:
cf2a78cbbb (deprecation: don't enable TCG plugins by default on 32 bit hosts) db7a06ade1 (configure: reenable plugins by default for 32-bit hosts)
So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systems
Signature · 2 lines
Alex Bennée Virtualisation Tech Lead @ Linaro
Quoted 37 lines · Alex Bennée
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failuresThe tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target(quoted diff) +2
-1@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel +ifeq ($(CONFIG_PLUGIN),y) run-plugin-patch-target-with-libpatch.so: \ PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true run-plugin-patch-target-with-libpatch.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so +endif --8<---------------cut here---------------end--------------->8---The other problem is trying to stuff a
uint64_tinto a void * on 32 bit. We did disable plugins for 32 bit but then reverted because we were able to fixup the cases:
Quoted 9 lines
cf2a78cbbb(deprecation: don't enable TCG plugins by default on 32 bit hosts)db7a06ade1(configure: reenable plugins by default for 32-bit hosts)So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systems
More context:../tests/tcg/plugins/patch.c: In function ‘patch_hwaddr’:../tests/tcg/plugins/patch.c:50:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]
50 | uint64_t addr = (uint64_t)userdata;
| ^../tests/tcg/plugins/patch.c: In function ‘patch_vaddr’:../tests/tcg/plugins/patch.c:93:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]
93 | uint64_t addr = (uint64_t)userdata;
| ^../tests/tcg/plugins/patch.c: In function ‘vcpu_tb_trans_cb’:../tests/tcg/plugins/patch.c:159:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
159 | (void *)addr);
| ^
../tests/tcg/plugins/patch.c:163:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
163 | (void *)addr);
|Since we disabled 64 bit targets on 32 bit hosts, and that data passed by pointers concern addresses, it should be safe to cast values to (uintptr_t) instead of (uint64_t).
Pierrick
Quoted 62 lines · Pierrick Bouvier
Quoted 30 lines · Alex Bennée
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failuresThe tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target(quoted diff) +1
-1@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel +ifeq ($(CONFIG_PLUGIN),y) run-plugin-patch-target-with-libpatch.so: \ PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true run-plugin-patch-target-with-libpatch.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so +endif --8<---------------cut here---------------end--------------->8---The other problem is trying to stuff a
uint64_tinto a void * on 32 bit.
We did disable plugins for 32 bit but then reverted because we were ableQuoted 9 lines
to fixup the cases:
cf2a78cbbb(deprecation: don't enable TCG plugins by default on 32
bit hosts)
db7a06ade1(configure: reenable plugins by default for 32-bit hosts)
So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systemsMore context:
../tests/tcg/plugins/patch.c: In function ‘patch_hwaddr’:../tests/tcg/plugins/patch.c:50:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]
50 |uint64_taddr = (uint64_t)userdata;
| ^../tests/tcg/plugins/patch.c: In function ‘patch_vaddr’:../tests/tcg/plugins/patch.c:93:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]
93 |uint64_taddr = (uint64_t)userdata;
| ^../tests/tcg/plugins/patch.c: In function ‘vcpu_tb_trans_cb’:../tests/tcg/plugins/patch.c:159:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]159 | (void *)addr); | ^ ../tests/tcg/plugins/patch.c:163:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 163 | (void *)addr); |
Quoted 3 lines
Since we disabled 64 bit targets on 32 bit hosts, and that data passed by pointers concern addresses, it should be safe to cast values to (
uintptr_t) instead of (uint64_t).
Something like this?
--8<---------------cut here---------------start------------->8---
modified tests/tcg/plugins/patch.c
@@ -47,10 +47,10 @@ static GByteArray *str_to_bytes(const char *str)
static void patch_hwaddr(unsigned int vcpu_index, void *userdata) {
- uint64_t addr = (uint64_t)userdata;
+ uintptr_t addr = (uintptr_t) userdata;
g_autoptr(GString) str = g_string_new(NULL);
g_string_printf(str, "patching: @0x%"
- PRIx64 "\n",
+ PRIxPTR "\n",
addr);
qemu_plugin_outs(str->str);@@ -90,7 +90,7 @@ static void patch_hwaddr(unsigned int vcpu_index, void *userdata)
static void patch_vaddr(unsigned int vcpu_index, void *userdata) {
- uint64_t addr = (uint64_t)userdata;
+ uintptr_t addr = (uintptr_t) userdata;
uint64_t hwaddr = 0;
if (!qemu_plugin_translate_vaddr(addr, &hwaddr)) {
qemu_plugin_outs("Failed to translate vaddr\n");
@@ -98,7 +98,7 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata)
}
g_autoptr(GString) str = g_string_new(NULL);
g_string_printf(str, "patching: @0x%"
- PRIx64 " hw: @0x%" PRIx64 "\n",
+ PRIxPTR " hw: @0x%" PRIx64 "\n",
addr, hwaddr);
qemu_plugin_outs(str->str);@@ -132,19 +132,29 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata)
*/
static void vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) {
- uint64_t addr = 0;
g_autoptr(GByteArray) insn_data = g_byte_array_new();
+ uintptr_t addr = 0;
+
for (size_t i = 0; i < qemu_plugin_tb_n_insns(tb); i++) {
struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);+ uint64_t vaddr = qemu_plugin_insn_vaddr(insn);
if (use_hwaddr) {
- uint64_t vaddr = qemu_plugin_insn_vaddr(insn);
- if (!qemu_plugin_translate_vaddr(vaddr, &addr)) {
+ uint64_t hwaddr = 0;
+ if (!qemu_plugin_translate_vaddr(vaddr, &hwaddr)) {
qemu_plugin_outs("Failed to translate vaddr\n");
continue;
}
+ /*
+ * As we cannot emulate 64 bit systems on 32 bit hosts we
+ * should never see the top bits set, hence we can safely
+ * cast to uintptr_t.
+ */
+ g_assert(!(hwaddr & ~UINTPTR_MAX));
+ addr = (uintptr_t) hwaddr;
} else {
- addr = qemu_plugin_insn_vaddr(insn);
+ g_assert(!(vaddr & ~UINTPTR_MAX));
+ addr = (uintptr_t) vaddr;
}
g_byte_array_set_size(insn_data, qemu_plugin_insn_size(insn));
@@ -156,11 +166,11 @@ static void vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
if (use_hwaddr) {
qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_hwaddr,
QEMU_PLUGIN_CB_NO_REGS,
- (void *)addr);
+ (void *) addr);
} else {
qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_vaddr,
QEMU_PLUGIN_CB_NO_REGS,
- (void *)addr);
+ (void *) addr);
}
}
}--8<---------------cut here---------------end--------------->8---
Quoted 2 lines
Pierrick
Signature · 2 lines
Alex Bennée Virtualisation Tech Lead @ Linaro
Quoted 119 lines · Alex Bennée
Quoted 62 lines · Pierrick Bouvier
Quoted 30 lines · Alex Bennée
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failuresThe tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target(quoted diff) +1
-1@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel +ifeq ($(CONFIG_PLUGIN),y) run-plugin-patch-target-with-libpatch.so: \ PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true run-plugin-patch-target-with-libpatch.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so +endif --8<---------------cut here---------------end--------------->8---The other problem is trying to stuff a
uint64_tinto a void * on 32 bit.
We did disable plugins for 32 bit but then reverted because we were ableQuoted 9 lines
to fixup the cases:
cf2a78cbbb(deprecation: don't enable TCG plugins by default on 32
bit hosts)
db7a06ade1(configure: reenable plugins by default for 32-bit hosts)
So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systemsMore context:
../tests/tcg/plugins/patch.c: In function ‘patch_hwaddr’:../tests/tcg/plugins/patch.c:50:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]50 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘patch_vaddr’: ../tests/tcg/plugins/patch.c:93:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast] 93 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘vcpu_tb_trans_cb’: ../tests/tcg/plugins/patch.c:159:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 159 | (void *)addr); | ^ ../tests/tcg/plugins/patch.c:163:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 163 | (void *)addr); |Quoted 3 lines
Since we disabled 64 bit targets on 32 bit hosts, and that data passed by pointers concern addresses, it should be safe to cast values to (
uintptr_t) instead of (uint64_t).Something like this?
--8<---------------cut here---------------start------------->8---
modifiedtests/tcg/plugins/patch.c(quoted diff) +8
-7@@ -47,10 +47,10 @@ static GByteArray *str_to_bytes(const char *str) static void patch_hwaddr(unsigned int vcpu_index, void *userdata) { - uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 "\n", + PRIxPTR "\n", addr); qemu_plugin_outs(str->str);@@ -90,7 +90,7 @@ static void patch_hwaddr(unsigned int vcpu_index, void *userdata) static void patch_vaddr(unsigned int vcpu_index, void *userdata) { - uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; uint64_t hwaddr = 0; if (!qemu_plugin_translate_vaddr(addr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n");@@ -98,7 +98,7 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata) } g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 " hw: @0x%" PRIx64 "\n", + PRIxPTR " hw: @0x%" PRIx64 "\n", addr, hwaddr); qemu_plugin_outs(str->str);@@ -132,19 +132,29 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata) */ static void vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) { - uint64_t addr = 0; g_autoptr(GByteArray) insn_data = g_byte_array_new(); + uintptr_t addr = 0; + for (size_t i = 0; i < qemu_plugin_tb_n_insns(tb); i++) { struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i); + uint64_t vaddr = qemu_plugin_insn_vaddr(insn); if (use_hwaddr) { - uint64_t vaddr = qemu_plugin_insn_vaddr(insn); - if (!qemu_plugin_translate_vaddr(vaddr, &addr)) { + uint64_t hwaddr = 0;
Review static void patch_vaddr(unsigned int vcpu_index, void *userdata) · line 153
Quoted 10 lines
(quoted diff) +7
-0+ if (!qemu_plugin_translate_vaddr(vaddr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n"); continue; } + /* + * As we cannot emulate 64 bit systems on 32 bit hosts we + * should never see the top bits set, hence we can safely + * cast to uintptr_t. + */ + g_assert(!(hwaddr & ~UINTPTR_MAX));
We would have so many other problems before plugins if this hypothesis was not true (all the usage of vaddr type in the codebase would be broken). So the assert will not detect anything we are not aware about already.
If we want to mention this assumption for plugins users, the plugins documentation is probably a better place than one random plugin.
Quoted 26 lines
(quoted diff) +5
-4+ addr = (uintptr_t) hwaddr; } else { - addr = qemu_plugin_insn_vaddr(insn); + g_assert(!(vaddr & ~UINTPTR_MAX)); + addr = (uintptr_t) vaddr; } g_byte_array_set_size(insn_data, qemu_plugin_insn_size(insn));@@ -156,11 +166,11 @@ static void vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) if (use_hwaddr) { qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_hwaddr, QEMU_PLUGIN_CB_NO_REGS, - (void *)addr); + (void *) addr); } else { qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_vaddr, QEMU_PLUGIN_CB_NO_REGS, - (void *)addr); + (void *) addr); } } } --8<---------------cut here---------------end--------------->8---Quoted 3 lines
Quoted 2 lines
Quoted 1 line
Pierrick
For the rest, it looks good to me.
Thanks,
Pierrick
Quoted 132 lines · Pierrick Bouvier
Quoted 115 lines · Alex Bennée
Quoted 62 lines · Pierrick Bouvier
Quoted 30 lines · Alex Bennée
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failuresThe tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target(quoted diff) +1
-1@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel +ifeq ($(CONFIG_PLUGIN),y) run-plugin-patch-target-with-libpatch.so: \ PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true run-plugin-patch-target-with-libpatch.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so +endif --8<---------------cut here---------------end--------------->8---The other problem is trying to stuff a
uint64_tinto a void * on 32 bit.
We did disable plugins for 32 bit but then reverted because we were ableQuoted 9 lines
to fixup the cases:
cf2a78cbbb(deprecation: don't enable TCG plugins by default on 32
bit hosts)
db7a06ade1(configure: reenable plugins by default for 32-bit hosts)
So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systemsMore context:
../tests/tcg/plugins/patch.c: In function ‘patch_hwaddr’:../tests/tcg/plugins/patch.c:50:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]50 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘patch_vaddr’: ../tests/tcg/plugins/patch.c:93:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast] 93 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘vcpu_tb_trans_cb’: ../tests/tcg/plugins/patch.c:159:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 159 | (void *)addr); | ^ ../tests/tcg/plugins/patch.c:163:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 163 | (void *)addr); |Quoted 3 lines
Since we disabled 64 bit targets on 32 bit hosts, and that data passed by pointers concern addresses, it should be safe to cast values to (
uintptr_t) instead of (uint64_t).Something like this?
--8<---------------cut here---------------start------------->8---
modifiedtests/tcg/plugins/patch.c(quoted diff) +2
-2@@ -47,10 +47,10 @@ static GByteArray *str_to_bytes(const char *str) static void patch_hwaddr(unsigned int vcpu_index, void *userdata) { - uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 "\n", + PRIxPTR "\n", addr); qemu_plugin_outs(str->str); @@ -90,7 +90,7 @@ static void patch_hwaddr(unsigned int
vcpu_index, void *userdata)
static voidpatch_vaddr(unsigned int vcpu_index, void *userdata)
{(quoted diff) +2
-2- uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; uint64_t hwaddr = 0; if (!qemu_plugin_translate_vaddr(addr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n");@@ -98,7 +98,7 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata) } g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 " hw: @0x%" PRIx64 "\n", + PRIxPTR " hw: @0x%" PRIx64 "\n", addr, hwaddr); qemu_plugin_outs(str->str); @@ -132,19 +132,29 @@ static void patch_vaddr(unsigned int
vcpu_index, void *userdata)
*/
static voidvcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb){(quoted diff) +4
-3- uint64_t addr = 0; g_autoptr(GByteArray) insn_data = g_byte_array_new(); + uintptr_t addr = 0; + for (size_t i = 0; i < qemu_plugin_tb_n_insns(tb); i++) { struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i); + uint64_t vaddr = qemu_plugin_insn_vaddr(insn); if (use_hwaddr) { - uint64_t vaddr = qemu_plugin_insn_vaddr(insn); - if (!qemu_plugin_translate_vaddr(vaddr, &addr)) { + uint64_t hwaddr = 0;Review
Quoted 10 lines
(quoted diff) +7
-0+ if (!qemu_plugin_translate_vaddr(vaddr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n"); continue; } + /* + * As we cannot emulate 64 bit systems on 32 bit hosts we + * should never see the top bits set, hence we can safely + * cast to uintptr_t. + */ + g_assert(!(hwaddr & ~UINTPTR_MAX));We would have so many other problems before plugins if this hypothesis was not true (all the usage of vaddr type in the codebase would be broken). So the assert will not detect anything we are not aware about already.
Quoted 2 lines
If we want to mention this assumption for plugins users, the plugins documentation is probably a better place than one random plugin.
Well we could change the API function signature to return uintptr_t?
Quoted 33 lines
Quoted 26 lines
(quoted diff) +3
-1+ addr = (uintptr_t) hwaddr; } else { - addr = qemu_plugin_insn_vaddr(insn); + g_assert(!(vaddr & ~UINTPTR_MAX)); + addr = (uintptr_t) vaddr; } g_byte_array_set_size(insn_data,
qemu_plugin_insn_size(insn));(quoted diff) +2
-3@@ -156,11 +166,11 @@ static void vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) if (use_hwaddr) { qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_hwaddr, QEMU_PLUGIN_CB_NO_REGS, - (void *)addr); + (void *) addr); } else { qemu_plugin_register_vcpu_tb_exec_cb(tb, patch_vaddr, QEMU_PLUGIN_CB_NO_REGS, - (void *)addr); + (void *) addr); } } } --8<---------------cut here---------------end--------------->8---Quoted 2 lines
Quoted 2 lines
Quoted 1 line
Pierrick
For the rest, it looks good to me.
Thanks,
Pierrick
Signature · 2 lines
Alex Bennée Virtualisation Tech Lead @ Linaro
Quoted 134 lines · Alex Bennée
Quoted 132 lines · Pierrick Bouvier
Quoted 115 lines · Alex Bennée
Quoted 62 lines · Pierrick Bouvier
Quoted 30 lines · Alex Bennée
Quoted 8 lines · Alex Bennée
Quoted 4 lines · Rowan Hart
This patch series adds several new API functions focused on enabling use cases around reading and writing guest memory from QEMU plugins. To support these new APIs, some utility functionality around retrieving information about address spaces is added as well.
Queued to plugins/next, thanks.
So this fails a number of the CI tests, mostly due to 32 bit issues:
https://gitlab.com/stsquad/qemu/-/pipelines/1890883927/failuresThe tci failure is easy enough:
--8<---------------cut here---------------start------------->8---
modified tests/tcg/x86_64/Makefile.softmmu-target(quoted diff) +1
-1@@ -34,9 +34,11 @@ memory: CFLAGS+=-DCHECK_UNALIGNED=1 # Running QEMU_OPTS+=-device isa-debugcon,chardev=output -device isa-debug-exit,iobase=0xf4,iosize=0x4 -kernel +ifeq ($(CONFIG_PLUGIN),y) run-plugin-patch-target-with-libpatch.so: \ PLUGIN_ARGS=$(COMMA)target=ffc0$(COMMA)patch=9090$(COMMA)use_hwaddr=true run-plugin-patch-target-with-libpatch.so: \ CHECK_PLUGIN_OUTPUT_COMMAND=$(X64_SYSTEM_SRC)/validate-patch.py [email protected] run-plugin-patch-target-with-libpatch.so: patch-target libpatch.so EXTRA_RUNS+=run-plugin-patch-target-with-libpatch.so +endif --8<---------------cut here---------------end--------------->8---The other problem is trying to stuff a
uint64_tinto a void * on 32 bit.
We did disable plugins for 32 bit but then reverted because we were ableQuoted 9 lines
to fixup the cases:
cf2a78cbbb(deprecation: don't enable TCG plugins by default on 32
bit hosts)
db7a06ade1(configure: reenable plugins by default for 32-bit hosts)
So I don't what is easier:
- re-deprecate for 32 bit systems
- only build libpatch on 64 bit systems
- fix libpatch to handle being built on 32 bit systemsMore context:
../tests/tcg/plugins/patch.c: In function ‘patch_hwaddr’:../tests/tcg/plugins/patch.c:50:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast]50 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘patch_vaddr’: ../tests/tcg/plugins/patch.c:93:21: error: cast from pointer to integer of different size [-Werror=pointer-to-int-cast] 93 | uint64_t addr = (uint64_t)userdata; | ^ ../tests/tcg/plugins/patch.c: In function ‘vcpu_tb_trans_cb’: ../tests/tcg/plugins/patch.c:159:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 159 | (void *)addr); | ^ ../tests/tcg/plugins/patch.c:163:54: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast] 163 | (void *)addr); |Quoted 3 lines
Since we disabled 64 bit targets on 32 bit hosts, and that data passed by pointers concern addresses, it should be safe to cast values to (
uintptr_t) instead of (uint64_t).Something like this?
--8<---------------cut here---------------start------------->8---
modifiedtests/tcg/plugins/patch.c(quoted diff) +2
-2@@ -47,10 +47,10 @@ static GByteArray *str_to_bytes(const char *str) static void patch_hwaddr(unsigned int vcpu_index, void *userdata) { - uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 "\n", + PRIxPTR "\n", addr); qemu_plugin_outs(str->str); @@ -90,7 +90,7 @@ static void patch_hwaddr(unsigned int
vcpu_index, void *userdata)
static voidpatch_vaddr(unsigned int vcpu_index, void *userdata)
{(quoted diff) +2
-2- uint64_t addr = (uint64_t)userdata; + uintptr_t addr = (uintptr_t) userdata; uint64_t hwaddr = 0; if (!qemu_plugin_translate_vaddr(addr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n");@@ -98,7 +98,7 @@ static void patch_vaddr(unsigned int vcpu_index, void *userdata) } g_autoptr(GString) str = g_string_new(NULL); g_string_printf(str, "patching: @0x%" - PRIx64 " hw: @0x%" PRIx64 "\n", + PRIxPTR " hw: @0x%" PRIx64 "\n", addr, hwaddr); qemu_plugin_outs(str->str); @@ -132,19 +132,29 @@ static void patch_vaddr(unsigned int
vcpu_index, void *userdata)*/static void
vcpu_tb_trans_cb(qemu_plugin_id_t id, struct qemu_plugin_tb *tb){(quoted diff) +4
-3- uint64_t addr = 0; g_autoptr(GByteArray) insn_data = g_byte_array_new(); + uintptr_t addr = 0; + for (size_t i = 0; i < qemu_plugin_tb_n_insns(tb); i++) { struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i); + uint64_t vaddr = qemu_plugin_insn_vaddr(insn); if (use_hwaddr) { - uint64_t vaddr = qemu_plugin_insn_vaddr(insn); - if (!qemu_plugin_translate_vaddr(vaddr, &addr)) { + uint64_t hwaddr = 0;Review
Quoted 10 lines
(quoted diff) +7
-0+ if (!qemu_plugin_translate_vaddr(vaddr, &hwaddr)) { qemu_plugin_outs("Failed to translate vaddr\n"); continue; } + /* + * As we cannot emulate 64 bit systems on 32 bit hosts we + * should never see the top bits set, hence we can safely + * cast to uintptr_t. + */ + g_assert(!(hwaddr & ~UINTPTR_MAX));We would have so many other problems before plugins if this hypothesis was not true (all the usage of vaddr type in the codebase would be broken). So the assert will not detect anything we are not aware about already.
Quoted 5 lines
Quoted 2 lines
If we want to mention this assumption for plugins users, the plugins documentation is probably a better place than one random plugin.
Well we could change the API function signature to return
uintptr_t?
While it's possible, I personally would favor a fixed ABI for types independently of which host config we have. It's less surprising and easier to reason about.
For tcg, we have a reason to optimize this, to avoid manipulating 64 bits data, when we know it's only 32 in reality.
That said, one thing we could enhance on plugins side is to ease passing immediate data to a callback, without relying on pointer casting, which can be subtly wrong on 32 bits hosts. It's definitely out of the scope for this series though.