Re: [PATCH v2] plugin: Add callback support for vCPU hardware and architecture-specific interrupts

["Alex Bennée" <alex.bennee@linaro.org>]

Liu marko <marko1616@outlook.com> writes:

> Implemented the `qemu_plugin_vcpu_int_cb` callback to allow plugins to observe hardware and architecture-specific
> interrupts. Modified `cpu-exec.c` to invoke the callback on hard interrupts, and added a test plugin (`countint`) to
> demonstrate its functionality. A similar approach was previously proposed
> (https://lists.gnu.org/archive/html/qemu-devel/2023-10/msg07359.html) but was not merged.
>
> Changes since v1:
> - Fixed build with `--disable-plugins`
>
> Signed-off-by: marko1616 <marko1616@outlook.com>

Could you look at:

  Message-ID: <cover.1746968215.git.neither@nut.email>
  Date: Sun, 11 May 2025 15:13:52 +0200
  Subject: [PATCH v4 00/23] tcg-plugins: add hooks for discontinuities
  From: Julian Ganz <neither@nut.email>

Which I think has a more comprehensive approach to modelling
discontinuities in execution with architectural semantics. 

> ---
>  accel/tcg/cpu-exec.c        | 11 +++++
>  contrib/plugins/countint.c  | 90 +++++++++++++++++++++++++++++++++++++
>  contrib/plugins/meson.build |  2 +-
>  include/qemu/plugin-event.h |  1 +
>  include/qemu/plugin.h       |  5 +++
>  include/qemu/qemu-plugin.h  | 17 +++++++
>  plugins/core.c              | 23 ++++++++++
>  7 files changed, 148 insertions(+), 1 deletion(-)
>  create mode 100644 contrib/plugins/countint.c
>
> diff --git a/accel/tcg/cpu-exec.c b/accel/tcg/cpu-exec.c
> index cc5f362305..e4113f8966 100644
> --- a/accel/tcg/cpu-exec.c
> +++ b/accel/tcg/cpu-exec.c
> @@ -34,6 +34,9 @@
>  #include "tcg/tcg.h"
>  #include "qemu/atomic.h"
>  #include "qemu/rcu.h"
> +#ifdef CONFIG_PLUGIN
> +#include "qemu/plugin.h"
> +#endif
>  #include "exec/log.h"
>  #include "qemu/main-loop.h"
>  #include "exec/icount.h"
> @@ -818,7 +821,15 @@ static inline bool cpu_handle_interrupt(CPUState *cpu,
>               * True when it is, and we should restart on a new TB,
>               * and via longjmp via cpu_loop_exit.
>               */
> +#ifdef CONFIG_PLUGIN
> +            const int prev_interrupt_request = interrupt_request;
> +#endif /* CONFIG_PLUGIN */
>              if (tcg_ops->cpu_exec_interrupt(cpu, interrupt_request)) {
> +#ifdef CONFIG_PLUGIN
> +                if (interrupt_request & CPU_INTERRUPT_HARD) {
> +                    qemu_plugin_vcpu_int_cb(cpu, prev_interrupt_request);
> +                }
> +#endif /* CONFIG_PLUGIN */

My main concern with this plugin point is that it seems very QEMU
internals focused and we try not to leak internal impdef details to the
plugin API.

>                  if (!tcg_ops->need_replay_interrupt ||
>                      tcg_ops->need_replay_interrupt(interrupt_request)) {
>                      replay_interrupt();
> diff --git a/contrib/plugins/countint.c b/contrib/plugins/countint.c
> new file mode 100644
> index 0000000000..601b7f30d5
> --- /dev/null
> +++ b/contrib/plugins/countint.c
> @@ -0,0 +1,90 @@
> +/*
> + * Copyright (c) 2025 marko1616
> + *
> + * SPDX-License-Identifier: GPL-2.0-or-later
> + */
> +
> +#include <stdio.h>
> +#include <glib.h>
> +
> +#include <qemu-plugin.h>
> +
> +QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
> +
> +typedef struct {
> +    unsigned int vcpu_index;
> +    struct qemu_plugin_scoreboard *int_count;
> +} IntStat;
> +
> +static GHashTable *vcpu_int_table;
> +static GMutex lock;
> +
> +static guint intstat_hash(gconstpointer key)
> +{
> +    const IntStat *s = key;
> +    return s->vcpu_index;
> +}
> +
> +static gboolean intstat_equal(gconstpointer a, gconstpointer b)
> +{
> +    return ((IntStat *)a)->vcpu_index == ((IntStat *)b)->vcpu_index;
> +}
> +
> +static void intstat_free(gpointer key, gpointer value, gpointer user_data)
> +{
> +    IntStat *s = value;
> +    qemu_plugin_scoreboard_free(s->int_count);
> +    g_free(s);
> +}
> +
> +static void vcpu_hardint(qemu_plugin_id_t id,
> +                         unsigned int vcpu_index,
> +                         uint32_t int_req)
> +{
> +    IntStat *stat = NULL;
> +
> +    g_mutex_lock(&lock);
> +    {
> +        IntStat key = { .vcpu_index = vcpu_index };
> +        stat = g_hash_table_lookup(vcpu_int_table, &key);
> +
> +        if (!stat) {
> +            stat = g_new0(IntStat, 1);
> +            stat->vcpu_index = vcpu_index;
> +            stat->int_count = qemu_plugin_scoreboard_new(sizeof(uint64_t));
> +            g_hash_table_insert(vcpu_int_table, stat, stat);
> +        }
> +    }
> +    g_mutex_unlock(&lock);
> +
> +    qemu_plugin_u64_add(
> +        qemu_plugin_scoreboard_u64(stat->int_count),
> +        vcpu_index,
> +        1
> +    );
> +}
> +
> +static void plugin_exit(qemu_plugin_id_t id, void *p)
> +{
> +    GList *stats = g_hash_table_get_values(vcpu_int_table);
> +    for (GList *it = stats; it != NULL; it = it->next) {
> +        IntStat *stat = (IntStat *)it->data;
> +        uint64_t count = qemu_plugin_u64_sum(
> +            qemu_plugin_scoreboard_u64(stat->int_count)
> +        );
> +        printf("vCPU %u: %" PRIu64 " interrupts\n", stat->vcpu_index, count);
> +    }
> +    g_list_free(stats);
> +    g_hash_table_foreach(vcpu_int_table, intstat_free, NULL);
> +    g_hash_table_destroy(vcpu_int_table);
> +}
> +
> +QEMU_PLUGIN_EXPORT
> +int qemu_plugin_install(qemu_plugin_id_t id, const qemu_info_t *info,
> +                        int argc, char **argv)
> +{
> +    vcpu_int_table = g_hash_table_new(intstat_hash, intstat_equal);
> +    qemu_plugin_register_vcpu_int_cb(id, vcpu_hardint);
> +    qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
> +    return 0;
> +}
> diff --git a/contrib/plugins/meson.build b/contrib/plugins/meson.build
> index fa8a426c8b..17e3b0ec27 100644
> --- a/contrib/plugins/meson.build
> +++ b/contrib/plugins/meson.build
> @@ -1,4 +1,4 @@
> -contrib_plugins = ['bbv', 'cache', 'cflow', 'drcov', 'execlog', 'hotblocks',
> +contrib_plugins = ['bbv', 'cache', 'cflow', 'drcov', 'execlog', 'countint', 'hotblocks',
>                     'hotpages', 'howvec', 'hwprofile', 'ips', 'stoptrigger']
>  if host_os != 'windows'
>    # lockstep uses socket.h
> diff --git a/include/qemu/plugin-event.h b/include/qemu/plugin-event.h
> index 7056d8427b..cd9f9eb25b 100644
> --- a/include/qemu/plugin-event.h
> +++ b/include/qemu/plugin-event.h
> @@ -16,6 +16,7 @@ enum qemu_plugin_event {
>      QEMU_PLUGIN_EV_VCPU_TB_TRANS,
>      QEMU_PLUGIN_EV_VCPU_IDLE,
>      QEMU_PLUGIN_EV_VCPU_RESUME,
> +    QEMU_PLUGIN_EV_VCPU_INT,
>      QEMU_PLUGIN_EV_VCPU_SYSCALL,
>      QEMU_PLUGIN_EV_VCPU_SYSCALL_RET,
>      QEMU_PLUGIN_EV_FLUSH,
> diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
> index 9726a9ebf3..f1d5d91141 100644
> --- a/include/qemu/plugin.h
> +++ b/include/qemu/plugin.h
> @@ -61,6 +61,7 @@ union qemu_plugin_cb_sig {
>      qemu_plugin_vcpu_udata_cb_t      vcpu_udata;
>      qemu_plugin_vcpu_tb_trans_cb_t   vcpu_tb_trans;
>      qemu_plugin_vcpu_mem_cb_t        vcpu_mem;
> +    qemu_plugin_vcpu_int_cb_t    vcpu_hardint;
>      qemu_plugin_vcpu_syscall_cb_t    vcpu_syscall;
>      qemu_plugin_vcpu_syscall_ret_cb_t vcpu_syscall_ret;
>      void *generic;
> @@ -160,6 +161,7 @@ void qemu_plugin_vcpu_exit_hook(CPUState *cpu);
>  void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb);
>  void qemu_plugin_vcpu_idle_cb(CPUState *cpu);
>  void qemu_plugin_vcpu_resume_cb(CPUState *cpu);
> +void qemu_plugin_vcpu_int_cb(CPUState *cpu, int interrupt_request);
>  void
>  qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1,
>                           uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5,
> @@ -242,6 +244,9 @@ static inline void qemu_plugin_vcpu_idle_cb(CPUState *cpu)
>  static inline void qemu_plugin_vcpu_resume_cb(CPUState *cpu)
>  { }
>  
> +static inline void qemu_plugin_vcpu_int_cb(CPUState *cpu, int interrupt_request)
> +{ }
> +
>  static inline void
>  qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2,
>                           uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6,
> diff --git a/include/qemu/qemu-plugin.h b/include/qemu/qemu-plugin.h
> index 3a850aa216..65096c4c64 100644
> --- a/include/qemu/qemu-plugin.h
> +++ b/include/qemu/qemu-plugin.h
> @@ -728,6 +728,23 @@ const void *qemu_plugin_request_time_control(void);
>  QEMU_PLUGIN_API
>  void qemu_plugin_update_ns(const void *handle, int64_t time);
>  
> +typedef void
> +(*qemu_plugin_vcpu_int_cb_t)(qemu_plugin_id_t id,
> +                                 unsigned int vcpu_index,
> +                                 uint32_t interrupt_request);
> +
> +/**
> + * qemu_plugin_register_vcpu_int_cb() -
> + *   register a vCPU hardware interruption callback
> + * @id: plugin ID
> + * @cb: callback function
> + *
> + * The @cb function is called every time a vCPU gets hardware interruption.
> + */
> +QEMU_PLUGIN_API
> +void qemu_plugin_register_vcpu_int_cb(qemu_plugin_id_t id,
> +                                          qemu_plugin_vcpu_int_cb_t cb);
> +
>  typedef void
>  (*qemu_plugin_vcpu_syscall_cb_t)(qemu_plugin_id_t id, unsigned int vcpu_index,
>                                   int64_t num, uint64_t a1, uint64_t a2,
> diff --git a/plugins/core.c b/plugins/core.c
> index eb9281fe54..b6fbfe20e9 100644
> --- a/plugins/core.c
> +++ b/plugins/core.c
> @@ -539,6 +539,23 @@ void qemu_plugin_vcpu_resume_cb(CPUState *cpu)
>      }
>  }
>  
> +/*
> + * Disable CFI checks.
> + * The callback function has been loaded from an external library so we do not
> + * have type information
> + */
> +QEMU_DISABLE_CFI
> +void qemu_plugin_vcpu_int_cb(CPUState *cpu, int interrupt_request)
> +{
> +    struct qemu_plugin_cb *cb, *next;
> +    enum qemu_plugin_event ev = QEMU_PLUGIN_EV_VCPU_INT;
> +
> +    QLIST_FOREACH_SAFE_RCU(cb, &plugin.cb_lists[ev], entry, next) {
> +        qemu_plugin_vcpu_int_cb_t func = cb->f.vcpu_hardint;
> +        func(cb->ctx->id, cpu->cpu_index, interrupt_request);
> +    }
> +}
> +
>  void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id,
>                                         qemu_plugin_vcpu_simple_cb_t cb)
>  {
> @@ -551,6 +568,12 @@ void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id,
>      plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_RESUME, cb);
>  }
>  
> +void qemu_plugin_register_vcpu_int_cb(qemu_plugin_id_t id,
> +                                          qemu_plugin_vcpu_int_cb_t cb)
> +{
> +    plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_INT, cb);
> +}
> +
>  void qemu_plugin_register_flush_cb(qemu_plugin_id_t id,
>                                     qemu_plugin_simple_cb_t cb)
>  {

-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro