include/qemu/qemu-plugin.h - third_party/qemu - Git at Google

 /*
  * Copyright (C) 2017, Emilio G. Cota <cota@braap.org>
  * Copyright (C) 2019, Linaro
  *
  * License: GNU GPL, version 2 or later.
  *   See the COPYING file in the top-level directory.
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */

 #ifndef QEMU_QEMU_PLUGIN_H
 #define QEMU_QEMU_PLUGIN_H

 #include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>

 /*
  * For best performance, build the plugin with -fvisibility=hidden so that
  * QEMU_PLUGIN_LOCAL is implicit. Then, just mark qemu_plugin_install with
  * QEMU_PLUGIN_EXPORT. For more info, see
  *   https://gcc.gnu.org/wiki/Visibility
  */
 #if defined _WIN32 || defined __CYGWIN__
   #ifdef BUILDING_DLL
     #define QEMU_PLUGIN_EXPORT __declspec(dllexport)
   #else
     #define QEMU_PLUGIN_EXPORT __declspec(dllimport)
   #endif
   #define QEMU_PLUGIN_LOCAL
 #else
   #define QEMU_PLUGIN_EXPORT __attribute__((visibility("default")))
   #define QEMU_PLUGIN_LOCAL  __attribute__((visibility("hidden")))
 #endif

 /**
  * typedef qemu_plugin_id_t - Unique plugin ID
  */
 typedef uint64_t qemu_plugin_id_t;

 /*
  * Versioning plugins:
  *
  * The plugin API will pass a minimum and current API version that
  * QEMU currently supports. The minimum API will be incremented if an
  * API needs to be deprecated.
  *
  * The plugins export the API they were built against by exposing the
  * symbol qemu_plugin_version which can be checked.
  */

 extern QEMU_PLUGIN_EXPORT int qemu_plugin_version;

 #define QEMU_PLUGIN_VERSION 1

 /**
  * struct qemu_info_t - system information for plugins
  *
  * This structure provides for some limited information about the
  * system to allow the plugin to make decisions on how to proceed. For
  * example it might only be suitable for running on some guest
  * architectures or when under full system emulation.
  */
 typedef struct qemu_info_t {
     /** @target_name: string describing architecture */
     const char *target_name;
     /** @version: minimum and current plugin API level */
     struct {
         int min;
         int cur;
     } version;
     /** @system_emulation: is this a full system emulation? */
     bool system_emulation;
     union {
         /** @system: information relevant to system emulation */
         struct {
             /** @system.smp_vcpus: initial number of vCPUs */
             int smp_vcpus;
             /** @system.max_vcpus: maximum possible number of vCPUs */
             int max_vcpus;
         } system;
     };
 } qemu_info_t;

 /**
  * qemu_plugin_install() - Install a plugin
  * @id: this plugin's opaque ID
  * @info: a block describing some details about the guest
  * @argc: number of arguments
  * @argv: array of arguments (@argc elements)
  *
  * All plugins must export this symbol which is called when the plugin
  * is first loaded. Calling qemu_plugin_uninstall() from this function
  * is a bug.
  *
  * Note: @info is only live during the call. Copy any information we
  * want to keep. @argv remains valid throughout the lifetime of the
  * loaded plugin.
  *
  * Return: 0 on successful loading, !0 for an error.
  */
 QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
                                            const qemu_info_t *info,
                                            int argc, char **argv);

 /**
  * typedef qemu_plugin_simple_cb_t - simple callback
  * @id: the unique qemu_plugin_id_t
  *
  * This callback passes no information aside from the unique @id.
  */
 typedef void (*qemu_plugin_simple_cb_t)(qemu_plugin_id_t id);

 /**
  * typedef qemu_plugin_udata_cb_t - callback with user data
  * @id: the unique qemu_plugin_id_t
  * @userdata: a pointer to some user data supplied when the callback
  * was registered.
  */
 typedef void (*qemu_plugin_udata_cb_t)(qemu_plugin_id_t id, void *userdata);

 /**
  * typedef qemu_plugin_vcpu_simple_cb_t - vcpu callback
  * @id: the unique qemu_plugin_id_t
  * @vcpu_index: the current vcpu context
  */
 typedef void (*qemu_plugin_vcpu_simple_cb_t)(qemu_plugin_id_t id,
                                              unsigned int vcpu_index);

 /**
  * typedef qemu_plugin_vcpu_udata_cb_t - vcpu callback
  * @vcpu_index: the current vcpu context
  * @userdata: a pointer to some user data supplied when the callback
  * was registered.
  */
 typedef void (*qemu_plugin_vcpu_udata_cb_t)(unsigned int vcpu_index,
                                             void *userdata);

 /**
  * qemu_plugin_uninstall() - Uninstall a plugin
  * @id: this plugin's opaque ID
  * @cb: callback to be called once the plugin has been removed
  *
  * Do NOT assume that the plugin has been uninstalled once this function
  * returns. Plugins are uninstalled asynchronously, and therefore the given
  * plugin receives callbacks until @cb is called.
  *
  * Note: Calling this function from qemu_plugin_install() is a bug.
  */
 void qemu_plugin_uninstall(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb);

 /**
  * qemu_plugin_reset() - Reset a plugin
  * @id: this plugin's opaque ID
  * @cb: callback to be called once the plugin has been reset
  *
  * Unregisters all callbacks for the plugin given by @id.
  *
  * Do NOT assume that the plugin has been reset once this function returns.
  * Plugins are reset asynchronously, and therefore the given plugin receives
  * callbacks until @cb is called.
  */
 void qemu_plugin_reset(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb);

 /**
  * qemu_plugin_register_vcpu_init_cb() - register a vCPU initialization callback
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called every time a vCPU is initialized.
  *
  * See also: qemu_plugin_register_vcpu_exit_cb()
  */
 void qemu_plugin_register_vcpu_init_cb(qemu_plugin_id_t id,
                                        qemu_plugin_vcpu_simple_cb_t cb);

 /**
  * qemu_plugin_register_vcpu_exit_cb() - register a vCPU exit callback
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called every time a vCPU exits.
  *
  * See also: qemu_plugin_register_vcpu_init_cb()
  */
 void qemu_plugin_register_vcpu_exit_cb(qemu_plugin_id_t id,
                                        qemu_plugin_vcpu_simple_cb_t cb);

 /**
  * qemu_plugin_register_vcpu_idle_cb() - register a vCPU idle callback
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called every time a vCPU idles.
  */
 void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id,
                                        qemu_plugin_vcpu_simple_cb_t cb);

 /**
  * qemu_plugin_register_vcpu_resume_cb() - register a vCPU resume callback
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called every time a vCPU resumes execution.
  */
 void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id,
                                          qemu_plugin_vcpu_simple_cb_t cb);

 /** struct qemu_plugin_tb - Opaque handle for a translation block */
 struct qemu_plugin_tb;
 /** struct qemu_plugin_insn - Opaque handle for a translated instruction */
 struct qemu_plugin_insn;

 /**
  * enum qemu_plugin_cb_flags - type of callback
  *
  * @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 unused, plugins cannot read or change system
  * register state.
  */
 enum qemu_plugin_cb_flags {
     QEMU_PLUGIN_CB_NO_REGS,
     QEMU_PLUGIN_CB_R_REGS,
     QEMU_PLUGIN_CB_RW_REGS,
 };

 enum qemu_plugin_mem_rw {
     QEMU_PLUGIN_MEM_R = 1,
     QEMU_PLUGIN_MEM_W,
     QEMU_PLUGIN_MEM_RW,
 };

 /**
  * typedef qemu_plugin_vcpu_tb_trans_cb_t - translation callback
  * @id: unique plugin id
  * @tb: opaque handle used for querying and instrumenting a block.
  */
 typedef void (*qemu_plugin_vcpu_tb_trans_cb_t)(qemu_plugin_id_t id,
                                                struct qemu_plugin_tb *tb);

 /**
  * qemu_plugin_register_vcpu_tb_trans_cb() - register a translate cb
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called every time a translation occurs. The @cb
  * function is passed an opaque qemu_plugin_type which it can query
  * for additional information including the list of translated
  * instructions. At this point the plugin can register further
  * callbacks to be triggered when the block or individual instruction
  * executes.
  */
 void qemu_plugin_register_vcpu_tb_trans_cb(qemu_plugin_id_t id,
                                            qemu_plugin_vcpu_tb_trans_cb_t cb);

 /**
  * qemu_plugin_register_vcpu_tb_exec_cb() - register execution callback
  * @tb: the opaque qemu_plugin_tb handle for the translation
  * @cb: callback function
  * @flags: does the plugin read or write the CPU's registers?
  * @userdata: any plugin data to pass to the @cb?
  *
  * The @cb function is called every time a translated unit executes.
  */
 void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
                                           qemu_plugin_vcpu_udata_cb_t cb,
                                           enum qemu_plugin_cb_flags flags,
                                           void *userdata);

 /**
  * enum qemu_plugin_op - describes an inline op
  *
  * @QEMU_PLUGIN_INLINE_ADD_U64: add an immediate value uint64_t
  *
  * Note: currently only a single inline op is supported.
  */

 enum qemu_plugin_op {
     QEMU_PLUGIN_INLINE_ADD_U64,
 };

 /**
  * qemu_plugin_register_vcpu_tb_exec_inline() - execution inline op
  * @tb: the opaque qemu_plugin_tb handle for the translation
  * @op: the type of qemu_plugin_op (e.g. ADD_U64)
  * @ptr: the target memory location for the op
  * @imm: the op data (e.g. 1)
  *
  * Insert an inline op to every time a translated unit executes.
  * Useful if you just want to increment a single counter somewhere in
  * memory.
  *
  * Note: ops are not atomic so in multi-threaded/multi-smp situations
  * you will get inexact results.
  */
 void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
                                               enum qemu_plugin_op op,
                                               void *ptr, uint64_t imm);

 /**
  * qemu_plugin_register_vcpu_insn_exec_cb() - register insn execution cb
  * @insn: the opaque qemu_plugin_insn handle for an instruction
  * @cb: callback function
  * @flags: does the plugin read or write the CPU's registers?
  * @userdata: any plugin data to pass to the @cb?
  *
  * The @cb function is called every time an instruction is executed
  */
 void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
                                             qemu_plugin_vcpu_udata_cb_t cb,
                                             enum qemu_plugin_cb_flags flags,
                                             void *userdata);

 /**
  * qemu_plugin_register_vcpu_insn_exec_inline() - insn execution inline op
  * @insn: the opaque qemu_plugin_insn handle for an instruction
  * @op: the type of qemu_plugin_op (e.g. ADD_U64)
  * @ptr: the target memory location for the op
  * @imm: the op data (e.g. 1)
  *
  * Insert an inline op to every time an instruction executes. Useful
  * if you just want to increment a single counter somewhere in memory.
  */
 void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
                                                 enum qemu_plugin_op op,
                                                 void *ptr, uint64_t imm);

 /**
  * qemu_plugin_tb_n_insns() - query helper for number of insns in TB
  * @tb: opaque handle to TB passed to callback
  *
  * Returns: number of instructions in this block
  */
 size_t qemu_plugin_tb_n_insns(const struct qemu_plugin_tb *tb);

 /**
  * qemu_plugin_tb_vaddr() - query helper for vaddr of TB start
  * @tb: opaque handle to TB passed to callback
  *
  * Returns: virtual address of block start
  */
 uint64_t qemu_plugin_tb_vaddr(const struct qemu_plugin_tb *tb);

 /**
  * qemu_plugin_tb_get_insn() - retrieve handle for instruction
  * @tb: opaque handle to TB passed to callback
  * @idx: instruction number, 0 indexed
  *
  * The returned handle can be used in follow up helper queries as well
  * as when instrumenting an instruction. It is only valid for the
  * lifetime of the callback.
  *
  * Returns: opaque handle to instruction
  */
 struct qemu_plugin_insn *
 qemu_plugin_tb_get_insn(const struct qemu_plugin_tb *tb, size_t idx);

 /**
  * qemu_plugin_insn_data() - return ptr to instruction data
  * @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
  *
  * Note: data is only valid for duration of callback. See
  * qemu_plugin_insn_size() to calculate size of stream.
  *
  * Returns: pointer to a stream of bytes containing the value of this
  * instructions opcode.
  */
 const void *qemu_plugin_insn_data(const struct qemu_plugin_insn *insn);

 /**
  * qemu_plugin_insn_size() - return size of instruction
  * @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
  *
  * Returns: size of instruction in bytes
  */
 size_t qemu_plugin_insn_size(const struct qemu_plugin_insn *insn);

 /**
  * qemu_plugin_insn_vaddr() - return vaddr of instruction
  * @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
  *
  * Returns: virtual address of instruction
  */
 uint64_t qemu_plugin_insn_vaddr(const struct qemu_plugin_insn *insn);

 /**
  * qemu_plugin_insn_haddr() - return hardware addr of instruction
  * @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
  *
  * Returns: hardware (physical) target address of instruction
  */
 void *qemu_plugin_insn_haddr(const struct qemu_plugin_insn *insn);

 /**
  * typedef qemu_plugin_meminfo_t - opaque memory transaction handle
  *
  * This can be further queried using the qemu_plugin_mem_* query
  * functions.
  */
 typedef uint32_t qemu_plugin_meminfo_t;
 /** struct qemu_plugin_hwaddr - opaque hw address handle */
 struct qemu_plugin_hwaddr;

 /**
  * qemu_plugin_mem_size_shift() - get size of access
  * @info: opaque memory transaction handle
  *
  * Returns: size of access in ^2 (0=byte, 1=16bit, 2=32bit etc...)
  */
 unsigned int qemu_plugin_mem_size_shift(qemu_plugin_meminfo_t info);
 /**
  * qemu_plugin_mem_is_sign_extended() - was the access sign extended
  * @info: opaque memory transaction handle
  *
  * Returns: true if it was, otherwise false
  */
 bool qemu_plugin_mem_is_sign_extended(qemu_plugin_meminfo_t info);
 /**
  * qemu_plugin_mem_is_big_endian() - was the access big endian
  * @info: opaque memory transaction handle
  *
  * Returns: true if it was, otherwise false
  */
 bool qemu_plugin_mem_is_big_endian(qemu_plugin_meminfo_t info);
 /**
  * qemu_plugin_mem_is_store() - was the access a store
  * @info: opaque memory transaction handle
  *
  * Returns: true if it was, otherwise false
  */
 bool qemu_plugin_mem_is_store(qemu_plugin_meminfo_t info);

 /**
  * qemu_plugin_get_hwaddr() - return handle for memory operation
  * @info: opaque memory info structure
  * @vaddr: the virtual address of the memory operation
  *
  * For system emulation returns a qemu_plugin_hwaddr handle to query
  * details about the actual physical address backing the virtual
  * address. For linux-user guests it just returns NULL.
  *
  * This handle is *only* valid for the duration of the callback. Any
  * information about the handle should be recovered before the
  * callback returns.
  */
 struct qemu_plugin_hwaddr *qemu_plugin_get_hwaddr(qemu_plugin_meminfo_t info,
                                                   uint64_t vaddr);

 /*
  * The following additional queries can be run on the hwaddr structure to
  * return information about it - namely whether it is for an IO access and the
  * physical address associated with the access.
  */

 /**
  * qemu_plugin_hwaddr_is_io() - query whether memory operation is IO
  * @haddr: address handle from qemu_plugin_get_hwaddr()
  *
  * Returns true if the handle's memory operation is to memory-mapped IO, or
  * false if it is to RAM
  */
 bool qemu_plugin_hwaddr_is_io(const struct qemu_plugin_hwaddr *haddr);

 /**
  * qemu_plugin_hwaddr_phys_addr() - query physical address for memory operation
  * @haddr: address handle from qemu_plugin_get_hwaddr()
  *
  * Returns the physical address associated with the memory operation
  *
  * Note that the returned physical address may not be unique if you are dealing
  * with multiple address spaces.
  */
 uint64_t qemu_plugin_hwaddr_phys_addr(const struct qemu_plugin_hwaddr *haddr);

 /*
  * Returns a string representing the device. The string is valid for
  * the lifetime of the plugin.
  */
 const char *qemu_plugin_hwaddr_device_name(const struct qemu_plugin_hwaddr *h);

 typedef void
 (*qemu_plugin_vcpu_mem_cb_t)(unsigned int vcpu_index,
                              qemu_plugin_meminfo_t info, uint64_t vaddr,
                              void *userdata);

 void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
                                       qemu_plugin_vcpu_mem_cb_t cb,
                                       enum qemu_plugin_cb_flags flags,
                                       enum qemu_plugin_mem_rw rw,
                                       void *userdata);

 void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
                                           enum qemu_plugin_mem_rw rw,
                                           enum qemu_plugin_op op, void *ptr,
                                           uint64_t imm);


 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,
                                  uint64_t a3, uint64_t a4, uint64_t a5,
                                  uint64_t a6, uint64_t a7, uint64_t a8);

 void qemu_plugin_register_vcpu_syscall_cb(qemu_plugin_id_t id,
                                           qemu_plugin_vcpu_syscall_cb_t cb);

 typedef void
 (*qemu_plugin_vcpu_syscall_ret_cb_t)(qemu_plugin_id_t id, unsigned int vcpu_idx,
                                      int64_t num, int64_t ret);

 void
 qemu_plugin_register_vcpu_syscall_ret_cb(qemu_plugin_id_t id,
                                          qemu_plugin_vcpu_syscall_ret_cb_t cb);


 /**
  * qemu_plugin_insn_disas() - return disassembly string for instruction
  * @insn: instruction reference
  *
  * Returns an allocated string containing the disassembly
  */

 char *qemu_plugin_insn_disas(const struct qemu_plugin_insn *insn);

 /**
  * qemu_plugin_insn_symbol() - best effort symbol lookup
  * @insn: instruction reference
  *
  * Return a static string referring to the symbol. This is dependent
  * on the binary QEMU is running having provided a symbol table.
  */
 const char *qemu_plugin_insn_symbol(const struct qemu_plugin_insn *insn);

 /**
  * qemu_plugin_vcpu_for_each() - iterate over the existing vCPU
  * @id: plugin ID
  * @cb: callback function
  *
  * The @cb function is called once for each existing vCPU.
  *
  * See also: qemu_plugin_register_vcpu_init_cb()
  */
 void qemu_plugin_vcpu_for_each(qemu_plugin_id_t id,
                                qemu_plugin_vcpu_simple_cb_t cb);

 void qemu_plugin_register_flush_cb(qemu_plugin_id_t id,
                                    qemu_plugin_simple_cb_t cb);

 /**
  * qemu_plugin_register_atexit_cb() - register exit callback
  * @id: plugin ID
  * @cb: callback
  * @userdata: user data for callback
  *
  * The @cb function is called once execution has finished. Plugins
  * should be able to free all their resources at this point much like
  * after a reset/uninstall callback is called.
  *
  * In user-mode it is possible a few un-instrumented instructions from
  * child threads may run before the host kernel reaps the threads.
  */
 void qemu_plugin_register_atexit_cb(qemu_plugin_id_t id,
                                     qemu_plugin_udata_cb_t cb, void *userdata);

 /* returns -1 in user-mode */
 int qemu_plugin_n_vcpus(void);

 /* returns -1 in user-mode */
 int qemu_plugin_n_max_vcpus(void);

 /**
  * qemu_plugin_outs() - output string via QEMU's logging system
  * @string: a string
  */
 void qemu_plugin_outs(const char *string);

 /**
  * qemu_plugin_bool_parse() - parses a boolean argument in the form of
  * "<argname>=[on|yes|true|off|no|false]"
  *
  * @name: argument name, the part before the equals sign
  * @val: argument value, what's after the equals sign
  * @ret: output return value
  *
  * returns true if the combination @name=@val parses correctly to a boolean
  * argument, and false otherwise
  */
 bool qemu_plugin_bool_parse(const char *name, const char *val, bool *ret);

 /**
  * qemu_plugin_path_to_binary() - path to binary file being executed
  *
  * Return a string representing the path to the binary. For user-mode
  * this is the main executable. For system emulation we currently
  * return NULL. The user should g_free() the string once no longer
  * needed.
  */
 const char *qemu_plugin_path_to_binary(void);

 /**
  * qemu_plugin_start_code() - returns start of text segment
  *
  * Returns the nominal start address of the main text segment in
  * user-mode. Currently returns 0 for system emulation.
  */
 uint64_t qemu_plugin_start_code(void);

 /**
  * qemu_plugin_end_code() - returns end of text segment
  *
  * Returns the nominal end address of the main text segment in
  * user-mode. Currently returns 0 for system emulation.
  */
 uint64_t qemu_plugin_end_code(void);

 /**
  * qemu_plugin_entry_code() - returns start address for module
  *
  * Returns the nominal entry address of the main text segment in
  * user-mode. Currently returns 0 for system emulation.
  */
 uint64_t qemu_plugin_entry_code(void);

 #endif /* QEMU_QEMU_PLUGIN_H */
	/*
	* Copyright (C) 2017, Emilio G. Cota <cota@braap.org>
	* Copyright (C) 2019, Linaro
	*
	* License: GNU GPL, version 2 or later.
	* See the COPYING file in the top-level directory.
	*
	* SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#ifndef QEMU_QEMU_PLUGIN_H
	#define QEMU_QEMU_PLUGIN_H

	#include <inttypes.h>
	#include <stdbool.h>
	#include <stddef.h>

	/*
	* For best performance, build the plugin with -fvisibility=hidden so that
	* QEMU_PLUGIN_LOCAL is implicit. Then, just mark qemu_plugin_install with
	* QEMU_PLUGIN_EXPORT. For more info, see
	* https://gcc.gnu.org/wiki/Visibility
	*/
	#if defined _WIN32 \|\| defined __CYGWIN__
	#ifdef BUILDING_DLL
	#define QEMU_PLUGIN_EXPORT __declspec(dllexport)
	#else
	#define QEMU_PLUGIN_EXPORT __declspec(dllimport)
	#endif
	#define QEMU_PLUGIN_LOCAL
	#else
	#define QEMU_PLUGIN_EXPORT __attribute__((visibility("default")))
	#define QEMU_PLUGIN_LOCAL __attribute__((visibility("hidden")))
	#endif

	/**
	* typedef qemu_plugin_id_t - Unique plugin ID
	*/
	typedef uint64_t qemu_plugin_id_t;

	/*
	* Versioning plugins:
	*
	* The plugin API will pass a minimum and current API version that
	* QEMU currently supports. The minimum API will be incremented if an
	* API needs to be deprecated.
	*
	* The plugins export the API they were built against by exposing the
	* symbol qemu_plugin_version which can be checked.
	*/

	extern QEMU_PLUGIN_EXPORT int qemu_plugin_version;

	#define QEMU_PLUGIN_VERSION 1

	/**
	* struct qemu_info_t - system information for plugins
	*
	* This structure provides for some limited information about the
	* system to allow the plugin to make decisions on how to proceed. For
	* example it might only be suitable for running on some guest
	* architectures or when under full system emulation.
	*/
	typedef struct qemu_info_t {
	/** @target_name: string describing architecture */
	const char *target_name;
	/** @version: minimum and current plugin API level */
	struct {
	int min;
	int cur;
	} version;
	/** @system_emulation: is this a full system emulation? */
	bool system_emulation;
	union {
	/** @system: information relevant to system emulation */
	struct {
	/** @system.smp_vcpus: initial number of vCPUs */
	int smp_vcpus;
	/** @system.max_vcpus: maximum possible number of vCPUs */
	int max_vcpus;
	} system;
	};
	} qemu_info_t;

	/**
	* qemu_plugin_install() - Install a plugin
	* @id: this plugin's opaque ID
	* @info: a block describing some details about the guest
	* @argc: number of arguments
	* @argv: array of arguments (@argc elements)
	*
	* All plugins must export this symbol which is called when the plugin
	* is first loaded. Calling qemu_plugin_uninstall() from this function
	* is a bug.
	*
	* Note: @info is only live during the call. Copy any information we
	* want to keep. @argv remains valid throughout the lifetime of the
	* loaded plugin.
	*
	* Return: 0 on successful loading, !0 for an error.
	*/
	QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
	const qemu_info_t *info,
	int argc, char **argv);

	/**
	* typedef qemu_plugin_simple_cb_t - simple callback
	* @id: the unique qemu_plugin_id_t
	*
	* This callback passes no information aside from the unique @id.
	*/
	typedef void (*qemu_plugin_simple_cb_t)(qemu_plugin_id_t id);

	/**
	* typedef qemu_plugin_udata_cb_t - callback with user data
	* @id: the unique qemu_plugin_id_t
	* @userdata: a pointer to some user data supplied when the callback
	* was registered.
	*/
	typedef void (qemu_plugin_udata_cb_t)(qemu_plugin_id_t id, void userdata);

	/**
	* typedef qemu_plugin_vcpu_simple_cb_t - vcpu callback
	* @id: the unique qemu_plugin_id_t
	* @vcpu_index: the current vcpu context
	*/
	typedef void (*qemu_plugin_vcpu_simple_cb_t)(qemu_plugin_id_t id,
	unsigned int vcpu_index);

	/**
	* typedef qemu_plugin_vcpu_udata_cb_t - vcpu callback
	* @vcpu_index: the current vcpu context
	* @userdata: a pointer to some user data supplied when the callback
	* was registered.
	*/
	typedef void (*qemu_plugin_vcpu_udata_cb_t)(unsigned int vcpu_index,
	void *userdata);

	/**
	* qemu_plugin_uninstall() - Uninstall a plugin
	* @id: this plugin's opaque ID
	* @cb: callback to be called once the plugin has been removed
	*
	* Do NOT assume that the plugin has been uninstalled once this function
	* returns. Plugins are uninstalled asynchronously, and therefore the given
	* plugin receives callbacks until @cb is called.
	*
	* Note: Calling this function from qemu_plugin_install() is a bug.
	*/
	void qemu_plugin_uninstall(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb);

	/**
	* qemu_plugin_reset() - Reset a plugin
	* @id: this plugin's opaque ID
	* @cb: callback to be called once the plugin has been reset
	*
	* Unregisters all callbacks for the plugin given by @id.
	*
	* Do NOT assume that the plugin has been reset once this function returns.
	* Plugins are reset asynchronously, and therefore the given plugin receives
	* callbacks until @cb is called.
	*/
	void qemu_plugin_reset(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb);

	/**
	* qemu_plugin_register_vcpu_init_cb() - register a vCPU initialization callback
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called every time a vCPU is initialized.
	*
	* See also: qemu_plugin_register_vcpu_exit_cb()
	*/
	void qemu_plugin_register_vcpu_init_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_simple_cb_t cb);

	/**
	* qemu_plugin_register_vcpu_exit_cb() - register a vCPU exit callback
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called every time a vCPU exits.
	*
	* See also: qemu_plugin_register_vcpu_init_cb()
	*/
	void qemu_plugin_register_vcpu_exit_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_simple_cb_t cb);

	/**
	* qemu_plugin_register_vcpu_idle_cb() - register a vCPU idle callback
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called every time a vCPU idles.
	*/
	void qemu_plugin_register_vcpu_idle_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_simple_cb_t cb);

	/**
	* qemu_plugin_register_vcpu_resume_cb() - register a vCPU resume callback
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called every time a vCPU resumes execution.
	*/
	void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_simple_cb_t cb);

	/** struct qemu_plugin_tb - Opaque handle for a translation block */
	struct qemu_plugin_tb;
	/** struct qemu_plugin_insn - Opaque handle for a translated instruction */
	struct qemu_plugin_insn;

	/**
	* enum qemu_plugin_cb_flags - type of callback
	*
	* @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 unused, plugins cannot read or change system
	* register state.
	*/
	enum qemu_plugin_cb_flags {
	QEMU_PLUGIN_CB_NO_REGS,
	QEMU_PLUGIN_CB_R_REGS,
	QEMU_PLUGIN_CB_RW_REGS,
	};

	enum qemu_plugin_mem_rw {
	QEMU_PLUGIN_MEM_R = 1,
	QEMU_PLUGIN_MEM_W,
	QEMU_PLUGIN_MEM_RW,
	};

	/**
	* typedef qemu_plugin_vcpu_tb_trans_cb_t - translation callback
	* @id: unique plugin id
	* @tb: opaque handle used for querying and instrumenting a block.
	*/
	typedef void (*qemu_plugin_vcpu_tb_trans_cb_t)(qemu_plugin_id_t id,
	struct qemu_plugin_tb *tb);

	/**
	* qemu_plugin_register_vcpu_tb_trans_cb() - register a translate cb
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called every time a translation occurs. The @cb
	* function is passed an opaque qemu_plugin_type which it can query
	* for additional information including the list of translated
	* instructions. At this point the plugin can register further
	* callbacks to be triggered when the block or individual instruction
	* executes.
	*/
	void qemu_plugin_register_vcpu_tb_trans_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_tb_trans_cb_t cb);

	/**
	* qemu_plugin_register_vcpu_tb_exec_cb() - register execution callback
	* @tb: the opaque qemu_plugin_tb handle for the translation
	* @cb: callback function
	* @flags: does the plugin read or write the CPU's registers?
	* @userdata: any plugin data to pass to the @cb?
	*
	* The @cb function is called every time a translated unit executes.
	*/
	void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
	qemu_plugin_vcpu_udata_cb_t cb,
	enum qemu_plugin_cb_flags flags,
	void *userdata);

	/**
	* enum qemu_plugin_op - describes an inline op
	*
	* @QEMU_PLUGIN_INLINE_ADD_U64: add an immediate value uint64_t
	*
	* Note: currently only a single inline op is supported.
	*/

	enum qemu_plugin_op {
	QEMU_PLUGIN_INLINE_ADD_U64,
	};

	/**
	* qemu_plugin_register_vcpu_tb_exec_inline() - execution inline op
	* @tb: the opaque qemu_plugin_tb handle for the translation
	* @op: the type of qemu_plugin_op (e.g. ADD_U64)
	* @ptr: the target memory location for the op
	* @imm: the op data (e.g. 1)
	*
	* Insert an inline op to every time a translated unit executes.
	* Useful if you just want to increment a single counter somewhere in
	* memory.
	*
	* Note: ops are not atomic so in multi-threaded/multi-smp situations
	* you will get inexact results.
	*/
	void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
	enum qemu_plugin_op op,
	void *ptr, uint64_t imm);

	/**
	* qemu_plugin_register_vcpu_insn_exec_cb() - register insn execution cb
	* @insn: the opaque qemu_plugin_insn handle for an instruction
	* @cb: callback function
	* @flags: does the plugin read or write the CPU's registers?
	* @userdata: any plugin data to pass to the @cb?
	*
	* The @cb function is called every time an instruction is executed
	*/
	void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
	qemu_plugin_vcpu_udata_cb_t cb,
	enum qemu_plugin_cb_flags flags,
	void *userdata);

	/**
	* qemu_plugin_register_vcpu_insn_exec_inline() - insn execution inline op
	* @insn: the opaque qemu_plugin_insn handle for an instruction
	* @op: the type of qemu_plugin_op (e.g. ADD_U64)
	* @ptr: the target memory location for the op
	* @imm: the op data (e.g. 1)
	*
	* Insert an inline op to every time an instruction executes. Useful
	* if you just want to increment a single counter somewhere in memory.
	*/
	void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
	enum qemu_plugin_op op,
	void *ptr, uint64_t imm);

	/**
	* qemu_plugin_tb_n_insns() - query helper for number of insns in TB
	* @tb: opaque handle to TB passed to callback
	*
	* Returns: number of instructions in this block
	*/
	size_t qemu_plugin_tb_n_insns(const struct qemu_plugin_tb *tb);

	/**
	* qemu_plugin_tb_vaddr() - query helper for vaddr of TB start
	* @tb: opaque handle to TB passed to callback
	*
	* Returns: virtual address of block start
	*/
	uint64_t qemu_plugin_tb_vaddr(const struct qemu_plugin_tb *tb);

	/**
	* qemu_plugin_tb_get_insn() - retrieve handle for instruction
	* @tb: opaque handle to TB passed to callback
	* @idx: instruction number, 0 indexed
	*
	* The returned handle can be used in follow up helper queries as well
	* as when instrumenting an instruction. It is only valid for the
	* lifetime of the callback.
	*
	* Returns: opaque handle to instruction
	*/
	struct qemu_plugin_insn *
	qemu_plugin_tb_get_insn(const struct qemu_plugin_tb *tb, size_t idx);

	/**
	* qemu_plugin_insn_data() - return ptr to instruction data
	* @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
	*
	* Note: data is only valid for duration of callback. See
	* qemu_plugin_insn_size() to calculate size of stream.
	*
	* Returns: pointer to a stream of bytes containing the value of this
	* instructions opcode.
	*/
	const void qemu_plugin_insn_data(const struct qemu_plugin_insn insn);

	/**
	* qemu_plugin_insn_size() - return size of instruction
	* @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
	*
	* Returns: size of instruction in bytes
	*/
	size_t qemu_plugin_insn_size(const struct qemu_plugin_insn *insn);

	/**
	* qemu_plugin_insn_vaddr() - return vaddr of instruction
	* @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
	*
	* Returns: virtual address of instruction
	*/
	uint64_t qemu_plugin_insn_vaddr(const struct qemu_plugin_insn *insn);

	/**
	* qemu_plugin_insn_haddr() - return hardware addr of instruction
	* @insn: opaque instruction handle from qemu_plugin_tb_get_insn()
	*
	* Returns: hardware (physical) target address of instruction
	*/
	void qemu_plugin_insn_haddr(const struct qemu_plugin_insn insn);

	/**
	* typedef qemu_plugin_meminfo_t - opaque memory transaction handle
	*
	* This can be further queried using the qemu_plugin_mem_* query
	* functions.
	*/
	typedef uint32_t qemu_plugin_meminfo_t;
	/** struct qemu_plugin_hwaddr - opaque hw address handle */
	struct qemu_plugin_hwaddr;

	/**
	* qemu_plugin_mem_size_shift() - get size of access
	* @info: opaque memory transaction handle
	*
	* Returns: size of access in ^2 (0=byte, 1=16bit, 2=32bit etc...)
	*/
	unsigned int qemu_plugin_mem_size_shift(qemu_plugin_meminfo_t info);
	/**
	* qemu_plugin_mem_is_sign_extended() - was the access sign extended
	* @info: opaque memory transaction handle
	*
	* Returns: true if it was, otherwise false
	*/
	bool qemu_plugin_mem_is_sign_extended(qemu_plugin_meminfo_t info);
	/**
	* qemu_plugin_mem_is_big_endian() - was the access big endian
	* @info: opaque memory transaction handle
	*
	* Returns: true if it was, otherwise false
	*/
	bool qemu_plugin_mem_is_big_endian(qemu_plugin_meminfo_t info);
	/**
	* qemu_plugin_mem_is_store() - was the access a store
	* @info: opaque memory transaction handle
	*
	* Returns: true if it was, otherwise false
	*/
	bool qemu_plugin_mem_is_store(qemu_plugin_meminfo_t info);

	/**
	* qemu_plugin_get_hwaddr() - return handle for memory operation
	* @info: opaque memory info structure
	* @vaddr: the virtual address of the memory operation
	*
	* For system emulation returns a qemu_plugin_hwaddr handle to query
	* details about the actual physical address backing the virtual
	* address. For linux-user guests it just returns NULL.
	*
	* This handle is only valid for the duration of the callback. Any
	* information about the handle should be recovered before the
	* callback returns.
	*/
	struct qemu_plugin_hwaddr *qemu_plugin_get_hwaddr(qemu_plugin_meminfo_t info,
	uint64_t vaddr);

	/*
	* The following additional queries can be run on the hwaddr structure to
	* return information about it - namely whether it is for an IO access and the
	* physical address associated with the access.
	*/

	/**
	* qemu_plugin_hwaddr_is_io() - query whether memory operation is IO
	* @haddr: address handle from qemu_plugin_get_hwaddr()
	*
	* Returns true if the handle's memory operation is to memory-mapped IO, or
	* false if it is to RAM
	*/
	bool qemu_plugin_hwaddr_is_io(const struct qemu_plugin_hwaddr *haddr);

	/**
	* qemu_plugin_hwaddr_phys_addr() - query physical address for memory operation
	* @haddr: address handle from qemu_plugin_get_hwaddr()
	*
	* Returns the physical address associated with the memory operation
	*
	* Note that the returned physical address may not be unique if you are dealing
	* with multiple address spaces.
	*/
	uint64_t qemu_plugin_hwaddr_phys_addr(const struct qemu_plugin_hwaddr *haddr);

	/*
	* Returns a string representing the device. The string is valid for
	* the lifetime of the plugin.
	*/
	const char qemu_plugin_hwaddr_device_name(const struct qemu_plugin_hwaddr h);

	typedef void
	(*qemu_plugin_vcpu_mem_cb_t)(unsigned int vcpu_index,
	qemu_plugin_meminfo_t info, uint64_t vaddr,
	void *userdata);

	void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
	qemu_plugin_vcpu_mem_cb_t cb,
	enum qemu_plugin_cb_flags flags,
	enum qemu_plugin_mem_rw rw,
	void *userdata);

	void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
	enum qemu_plugin_mem_rw rw,
	enum qemu_plugin_op op, void *ptr,
	uint64_t imm);



	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,
	uint64_t a3, uint64_t a4, uint64_t a5,
	uint64_t a6, uint64_t a7, uint64_t a8);

	void qemu_plugin_register_vcpu_syscall_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_syscall_cb_t cb);

	typedef void
	(*qemu_plugin_vcpu_syscall_ret_cb_t)(qemu_plugin_id_t id, unsigned int vcpu_idx,
	int64_t num, int64_t ret);

	void
	qemu_plugin_register_vcpu_syscall_ret_cb(qemu_plugin_id_t id,
	qemu_plugin_vcpu_syscall_ret_cb_t cb);


	/**
	* qemu_plugin_insn_disas() - return disassembly string for instruction
	* @insn: instruction reference
	*
	* Returns an allocated string containing the disassembly
	*/

	char qemu_plugin_insn_disas(const struct qemu_plugin_insn insn);

	/**
	* qemu_plugin_insn_symbol() - best effort symbol lookup
	* @insn: instruction reference
	*
	* Return a static string referring to the symbol. This is dependent
	* on the binary QEMU is running having provided a symbol table.
	*/
	const char qemu_plugin_insn_symbol(const struct qemu_plugin_insn insn);

	/**
	* qemu_plugin_vcpu_for_each() - iterate over the existing vCPU
	* @id: plugin ID
	* @cb: callback function
	*
	* The @cb function is called once for each existing vCPU.
	*
	* See also: qemu_plugin_register_vcpu_init_cb()
	*/
	void qemu_plugin_vcpu_for_each(qemu_plugin_id_t id,
	qemu_plugin_vcpu_simple_cb_t cb);

	void qemu_plugin_register_flush_cb(qemu_plugin_id_t id,
	qemu_plugin_simple_cb_t cb);

	/**
	* qemu_plugin_register_atexit_cb() - register exit callback
	* @id: plugin ID
	* @cb: callback
	* @userdata: user data for callback
	*
	* The @cb function is called once execution has finished. Plugins
	* should be able to free all their resources at this point much like
	* after a reset/uninstall callback is called.
	*
	* In user-mode it is possible a few un-instrumented instructions from
	* child threads may run before the host kernel reaps the threads.
	*/
	void qemu_plugin_register_atexit_cb(qemu_plugin_id_t id,
	qemu_plugin_udata_cb_t cb, void *userdata);

	/* returns -1 in user-mode */
	int qemu_plugin_n_vcpus(void);

	/* returns -1 in user-mode */
	int qemu_plugin_n_max_vcpus(void);

	/**
	* qemu_plugin_outs() - output string via QEMU's logging system
	* @string: a string
	*/
	void qemu_plugin_outs(const char *string);

	/**
	* qemu_plugin_bool_parse() - parses a boolean argument in the form of
	* "<argname>=[on\|yes\|true\|off\|no\|false]"
	*
	* @name: argument name, the part before the equals sign
	* @val: argument value, what's after the equals sign
	* @ret: output return value
	*
	* returns true if the combination @name=@val parses correctly to a boolean
	* argument, and false otherwise
	*/
	bool qemu_plugin_bool_parse(const char name, const char val, bool *ret);

	/**
	* qemu_plugin_path_to_binary() - path to binary file being executed
	*
	* Return a string representing the path to the binary. For user-mode
	* this is the main executable. For system emulation we currently
	* return NULL. The user should g_free() the string once no longer
	* needed.
	*/
	const char *qemu_plugin_path_to_binary(void);

	/**
	* qemu_plugin_start_code() - returns start of text segment
	*
	* Returns the nominal start address of the main text segment in
	* user-mode. Currently returns 0 for system emulation.
	*/
	uint64_t qemu_plugin_start_code(void);

	/**
	* qemu_plugin_end_code() - returns end of text segment
	*
	* Returns the nominal end address of the main text segment in
	* user-mode. Currently returns 0 for system emulation.
	*/
	uint64_t qemu_plugin_end_code(void);

	/**
	* qemu_plugin_entry_code() - returns start address for module
	*
	* Returns the nominal entry address of the main text segment in
	* user-mode. Currently returns 0 for system emulation.
	*/
	uint64_t qemu_plugin_entry_code(void);

	#endif /* QEMU_QEMU_PLUGIN_H */