[thirdparty/qemu.git] / plugins / loader.c

/*
 * QEMU Plugin Core Loader Code
 *
 * This is the code responsible for loading and unloading the plugins.
 * Aside from the basic housekeeping tasks we also need to ensure any
 * generated code is flushed when we remove a plugin so we cannot end
 * up calling and unloaded helper function.
 *
 * 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
 */

#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qemu/config-file.h"
#include "qapi/error.h"
#include "qemu/option.h"
#include "qemu/rcu_queue.h"
#include "qemu/qht.h"
#include "qemu/bitmap.h"
#include "qemu/xxhash.h"
#include "qemu/plugin.h"
#include "hw/core/cpu.h"
#include "cpu.h"
#include "exec/exec-all.h"
#ifndef CONFIG_USER_ONLY
#include "hw/boards.h"
#endif

#include "plugin.h"

/*
 * For convenience we use a bitmap for plugin.mask, but really all we need is a
 * u32, which is what we store in TranslationBlock.
 */
QEMU_BUILD_BUG_ON(QEMU_PLUGIN_EV_MAX > 32);

struct qemu_plugin_desc {
    char *path;
    char **argv;
    QTAILQ_ENTRY(qemu_plugin_desc) entry;
    int argc;
};

struct qemu_plugin_parse_arg {
    QemuPluginList *head;
    struct qemu_plugin_desc *curr;
};

QemuOptsList qemu_plugin_opts = {
    .name = "plugin",
    .implied_opt_name = "file",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_plugin_opts.head),
    .desc = {
        /* do our own parsing to support multiple plugins */
        { /* end of list */ }
    },
};

typedef int (*qemu_plugin_install_func_t)(qemu_plugin_id_t, const qemu_info_t *, int, char **);

extern struct qemu_plugin_state plugin;

void qemu_plugin_add_dyn_cb_arr(GArray *arr)
{
    uint32_t hash = qemu_xxhash2((uint64_t)(uintptr_t)arr);
    bool inserted;

    inserted = qht_insert(&plugin.dyn_cb_arr_ht, arr, hash, NULL);
    g_assert(inserted);
}

static struct qemu_plugin_desc *plugin_find_desc(QemuPluginList *head,
                                                 const char *path)
{
    struct qemu_plugin_desc *desc;

    QTAILQ_FOREACH(desc, head, entry) {
        if (strcmp(desc->path, path) == 0) {
            return desc;
        }
    }
    return NULL;
}

static int plugin_add(void *opaque, const char *name, const char *value,
                      Error **errp)
{
    struct qemu_plugin_parse_arg *arg = opaque;
    struct qemu_plugin_desc *p;

    if (strcmp(name, "file") == 0) {
        if (strcmp(value, "") == 0) {
            error_setg(errp, "requires a non-empty argument");
            return 1;
        }
        p = plugin_find_desc(arg->head, value);
        if (p == NULL) {
            p = g_new0(struct qemu_plugin_desc, 1);
            p->path = g_strdup(value);
            QTAILQ_INSERT_TAIL(arg->head, p, entry);
        }
        arg->curr = p;
    } else if (strcmp(name, "arg") == 0) {
        if (arg->curr == NULL) {
            error_setg(errp, "missing earlier '-plugin file=' option");
            return 1;
        }
        p = arg->curr;
        p->argc++;
        p->argv = g_realloc_n(p->argv, p->argc, sizeof(char *));
        p->argv[p->argc - 1] = g_strdup(value);
    } else {
        error_setg(errp, "-plugin: unexpected parameter '%s'; ignored", name);
    }
    return 0;
}

void qemu_plugin_opt_parse(const char *optarg, QemuPluginList *head)
{
    struct qemu_plugin_parse_arg arg;
    QemuOpts *opts;

    opts = qemu_opts_parse_noisily(qemu_find_opts("plugin"), optarg, true);
    if (opts == NULL) {
        exit(1);
    }
    arg.head = head;
    arg.curr = NULL;
    qemu_opt_foreach(opts, plugin_add, &arg, &error_fatal);
    qemu_opts_del(opts);
}

/*
 * From: https://en.wikipedia.org/wiki/Xorshift
 * This is faster than rand_r(), and gives us a wider range (RAND_MAX is only
 * guaranteed to be >= INT_MAX).
 */
static uint64_t xorshift64star(uint64_t x)
{
    x ^= x >> 12; /* a */
    x ^= x << 25; /* b */
    x ^= x >> 27; /* c */
    return x * UINT64_C(2685821657736338717);
}

static int plugin_load(struct qemu_plugin_desc *desc, const qemu_info_t *info)
{
    qemu_plugin_install_func_t install;
    struct qemu_plugin_ctx *ctx;
    gpointer sym;
    int rc;

    ctx = qemu_memalign(qemu_dcache_linesize, sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));
    ctx->desc = desc;

    ctx->handle = g_module_open(desc->path, G_MODULE_BIND_LOCAL);
    if (ctx->handle == NULL) {
        error_report("%s: %s", __func__, g_module_error());
        goto err_dlopen;
    }

    if (!g_module_symbol(ctx->handle, "qemu_plugin_install", &sym)) {
        error_report("%s: %s", __func__, g_module_error());
        goto err_symbol;
    }
    install = (qemu_plugin_install_func_t) sym;
    /* symbol was found; it could be NULL though */
    if (install == NULL) {
        error_report("%s: %s: qemu_plugin_install is NULL",
                     __func__, desc->path);
        goto err_symbol;
    }

    if (!g_module_symbol(ctx->handle, "qemu_plugin_version", &sym)) {
        error_report("TCG plugin %s does not declare API version %s",
                     desc->path, g_module_error());
        goto err_symbol;
    } else {
        int version = *(int *)sym;
        if (version < QEMU_PLUGIN_MIN_VERSION) {
            error_report("TCG plugin %s requires API version %d, but "
                         "this QEMU supports only a minimum version of %d",
                         desc->path, version, QEMU_PLUGIN_MIN_VERSION);
            goto err_symbol;
        } else if (version > QEMU_PLUGIN_VERSION) {
            error_report("TCG plugin %s requires API version %d, but "
                         "this QEMU supports only up to version %d",
                         desc->path, version, QEMU_PLUGIN_VERSION);
            goto err_symbol;
        }
    }

    qemu_rec_mutex_lock(&plugin.lock);

    /* find an unused random id with &ctx as the seed */
    ctx->id = (uint64_t)(uintptr_t)ctx;
    for (;;) {
        void *existing;

        ctx->id = xorshift64star(ctx->id);
        existing = g_hash_table_lookup(plugin.id_ht, &ctx->id);
        if (likely(existing == NULL)) {
            bool success;

            success = g_hash_table_insert(plugin.id_ht, &ctx->id, &ctx->id);
            g_assert(success);
            break;
        }
    }
    QTAILQ_INSERT_TAIL(&plugin.ctxs, ctx, entry);
    ctx->installing = true;
    rc = install(ctx->id, info, desc->argc, desc->argv);
    ctx->installing = false;
    if (rc) {
        error_report("%s: qemu_plugin_install returned error code %d",
                     __func__, rc);
        /*
         * we cannot rely on the plugin doing its own cleanup, so
         * call a full uninstall if the plugin did not yet call it.
         */
        if (!ctx->uninstalling) {
            plugin_reset_uninstall(ctx->id, NULL, false);
        }
    }

    qemu_rec_mutex_unlock(&plugin.lock);
    return rc;

 err_symbol:
 err_dlopen:
    qemu_vfree(ctx);
    return 1;
}

/* call after having removed @desc from the list */
static void plugin_desc_free(struct qemu_plugin_desc *desc)
{
    int i;

    for (i = 0; i < desc->argc; i++) {
        g_free(desc->argv[i]);
    }
    g_free(desc->argv);
    g_free(desc->path);
    g_free(desc);
}

/**
 * qemu_plugin_load_list - load a list of plugins
 * @head: head of the list of descriptors of the plugins to be loaded
 *
 * Returns 0 if all plugins in the list are installed, !0 otherwise.
 *
 * Note: the descriptor of each successfully installed plugin is removed
 * from the list given by @head.
 */
int qemu_plugin_load_list(QemuPluginList *head)
{
    struct qemu_plugin_desc *desc, *next;
    g_autofree qemu_info_t *info = g_new0(qemu_info_t, 1);

    info->target_name = TARGET_NAME;
    info->version.min = QEMU_PLUGIN_MIN_VERSION;
    info->version.cur = QEMU_PLUGIN_VERSION;
#ifndef CONFIG_USER_ONLY
    MachineState *ms = MACHINE(qdev_get_machine());
    info->system_emulation = true;
    info->system.smp_vcpus = ms->smp.cpus;
    info->system.max_vcpus = ms->smp.max_cpus;
#else
    info->system_emulation = false;
#endif

    QTAILQ_FOREACH_SAFE(desc, head, entry, next) {
        int err;

        err = plugin_load(desc, info);
        if (err) {
            return err;
        }
        QTAILQ_REMOVE(head, desc, entry);
    }
    return 0;
}

struct qemu_plugin_reset_data {
    struct qemu_plugin_ctx *ctx;
    qemu_plugin_simple_cb_t cb;
    bool reset;
};

static void plugin_reset_destroy__locked(struct qemu_plugin_reset_data *data)
{
    struct qemu_plugin_ctx *ctx = data->ctx;
    enum qemu_plugin_event ev;
    bool success;

    /*
     * After updating the subscription lists there is no need to wait for an RCU
     * grace period to elapse, because right now we either are in a "safe async"
     * work environment (i.e. all vCPUs are asleep), or no vCPUs have yet been
     * created.
     */
    for (ev = 0; ev < QEMU_PLUGIN_EV_MAX; ev++) {
        plugin_unregister_cb__locked(ctx, ev);
    }

    if (data->reset) {
        g_assert(ctx->resetting);
        if (data->cb) {
            data->cb(ctx->id);
        }
        ctx->resetting = false;
        g_free(data);
        return;
    }

    g_assert(ctx->uninstalling);
    /* we cannot dlclose if we are going to return to plugin code */
    if (ctx->installing) {
        error_report("Calling qemu_plugin_uninstall from the install function "
                     "is a bug. Instead, return !0 from the install function.");
        abort();
    }

    success = g_hash_table_remove(plugin.id_ht, &ctx->id);
    g_assert(success);
    QTAILQ_REMOVE(&plugin.ctxs, ctx, entry);
    if (data->cb) {
        data->cb(ctx->id);
    }
    if (!g_module_close(ctx->handle)) {
        warn_report("%s: %s", __func__, g_module_error());
    }
    plugin_desc_free(ctx->desc);
    qemu_vfree(ctx);
    g_free(data);
}

static void plugin_reset_destroy(struct qemu_plugin_reset_data *data)
{
    qemu_rec_mutex_lock(&plugin.lock);
    plugin_reset_destroy__locked(data);
    qemu_rec_mutex_lock(&plugin.lock);
}

static void plugin_flush_destroy(CPUState *cpu, run_on_cpu_data arg)
{
    struct qemu_plugin_reset_data *data = arg.host_ptr;

    g_assert(cpu_in_exclusive_context(cpu));
    tb_flush(cpu);
    plugin_reset_destroy(data);
}

void plugin_reset_uninstall(qemu_plugin_id_t id,
                            qemu_plugin_simple_cb_t cb,
                            bool reset)
{
    struct qemu_plugin_reset_data *data;
    struct qemu_plugin_ctx *ctx;

    qemu_rec_mutex_lock(&plugin.lock);
    ctx = plugin_id_to_ctx_locked(id);
    if (ctx->uninstalling || (reset && ctx->resetting)) {
        qemu_rec_mutex_unlock(&plugin.lock);
        return;
    }
    ctx->resetting = reset;
    ctx->uninstalling = !reset;
    qemu_rec_mutex_unlock(&plugin.lock);

    data = g_new(struct qemu_plugin_reset_data, 1);
    data->ctx = ctx;
    data->cb = cb;
    data->reset = reset;
    /*
     * Only flush the code cache if the vCPUs have been created. If so,
     * current_cpu must be non-NULL.
     */
    if (current_cpu) {
        async_safe_run_on_cpu(current_cpu, plugin_flush_destroy,
                              RUN_ON_CPU_HOST_PTR(data));
    } else {
        /*
         * If current_cpu isn't set, then we don't have yet any vCPU threads
         * and we therefore can remove the callbacks synchronously.
         */
        plugin_reset_destroy(data);
    }
}
Commit	Line	Data
54cb65d8 EC	1	/*
	2	* QEMU Plugin Core Loader Code
	3	*
	4	* This is the code responsible for loading and unloading the plugins.
	5	* Aside from the basic housekeeping tasks we also need to ensure any
	6	* generated code is flushed when we remove a plugin so we cannot end
	7	* up calling and unloaded helper function.
	8	*
	9	* Copyright (C) 2017, Emilio G. Cota <cota@braap.org>
	10	* Copyright (C) 2019, Linaro
	11	*
	12	* License: GNU GPL, version 2 or later.
	13	* See the COPYING file in the top-level directory.
	14	*
	15	* SPDX-License-Identifier: GPL-2.0-or-later
	16	*/
	17
	18	#include "qemu/osdep.h"
	19	#include "qemu/error-report.h"
	20	#include "qemu/config-file.h"
	21	#include "qapi/error.h"
	22	#include "qemu/option.h"
	23	#include "qemu/rcu_queue.h"
	24	#include "qemu/qht.h"
	25	#include "qemu/bitmap.h"
	26	#include "qemu/xxhash.h"
	27	#include "qemu/plugin.h"
	28	#include "hw/core/cpu.h"
	29	#include "cpu.h"
	30	#include "exec/exec-all.h"
5901b2e1 AB	31	#ifndef CONFIG_USER_ONLY
	32	#include "hw/boards.h"
	33	#endif
	34
54cb65d8 EC	35	#include "plugin.h"
	36
	37	/*
	38	* For convenience we use a bitmap for plugin.mask, but really all we need is a
	39	* u32, which is what we store in TranslationBlock.
	40	*/
	41	QEMU_BUILD_BUG_ON(QEMU_PLUGIN_EV_MAX > 32);
	42
	43	struct qemu_plugin_desc {
	44	char *path;
	45	char **argv;
	46	QTAILQ_ENTRY(qemu_plugin_desc) entry;
	47	int argc;
	48	};
	49
	50	struct qemu_plugin_parse_arg {
	51	QemuPluginList *head;
	52	struct qemu_plugin_desc *curr;
	53	};
	54
	55	QemuOptsList qemu_plugin_opts = {
	56	.name = "plugin",
	57	.implied_opt_name = "file",
	58	.head = QTAILQ_HEAD_INITIALIZER(qemu_plugin_opts.head),
	59	.desc = {
	60	/* do our own parsing to support multiple plugins */
	61	{ /* end of list */ }
	62	},
	63	};
	64
5901b2e1	65	typedef int (qemu_plugin_install_func_t)(qemu_plugin_id_t, const qemu_info_t , int, char **);
54cb65d8 EC	66
	67	extern struct qemu_plugin_state plugin;
	68
	69	void qemu_plugin_add_dyn_cb_arr(GArray *arr)
	70	{
	71	uint32_t hash = qemu_xxhash2((uint64_t)(uintptr_t)arr);
	72	bool inserted;
	73
	74	inserted = qht_insert(&plugin.dyn_cb_arr_ht, arr, hash, NULL);
	75	g_assert(inserted);
	76	}
	77
	78	static struct qemu_plugin_desc plugin_find_desc(QemuPluginList head,
	79	const char *path)
	80	{
	81	struct qemu_plugin_desc *desc;
	82
	83	QTAILQ_FOREACH(desc, head, entry) {
	84	if (strcmp(desc->path, path) == 0) {
	85	return desc;
	86	}
	87	}
	88	return NULL;
	89	}
	90
	91	static int plugin_add(void opaque, const char name, const char *value,
	92	Error **errp)
	93	{
	94	struct qemu_plugin_parse_arg *arg = opaque;
	95	struct qemu_plugin_desc *p;
	96
	97	if (strcmp(name, "file") == 0) {
	98	if (strcmp(value, "") == 0) {
	99	error_setg(errp, "requires a non-empty argument");
	100	return 1;
	101	}
	102	p = plugin_find_desc(arg->head, value);
	103	if (p == NULL) {
	104	p = g_new0(struct qemu_plugin_desc, 1);
	105	p->path = g_strdup(value);
	106	QTAILQ_INSERT_TAIL(arg->head, p, entry);
	107	}
	108	arg->curr = p;
	109	} else if (strcmp(name, "arg") == 0) {
	110	if (arg->curr == NULL) {
	111	error_setg(errp, "missing earlier '-plugin file=' option");
	112	return 1;
	113	}
	114	p = arg->curr;
	115	p->argc++;
	116	p->argv = g_realloc_n(p->argv, p->argc, sizeof(char *));
	117	p->argv[p->argc - 1] = g_strdup(value);
	118	} else {
	119	error_setg(errp, "-plugin: unexpected parameter '%s'; ignored", name);
	120	}
	121	return 0;
	122	}
	123
	124	void qemu_plugin_opt_parse(const char optarg, QemuPluginList head)
	125	{
	126	struct qemu_plugin_parse_arg arg;
	127	QemuOpts *opts;
	128
	129	opts = qemu_opts_parse_noisily(qemu_find_opts("plugin"), optarg, true);
130	if (opts == NULL) {
131	exit(1);
132	}
133	arg.head = head;
134	arg.curr = NULL;
135	qemu_opt_foreach(opts, plugin_add, &arg, &error_fatal);
136	qemu_opts_del(opts);
137	}
138
139	/*
140	* From: https://en.wikipedia.org/wiki/Xorshift
141	* This is faster than rand_r(), and gives us a wider range (RAND_MAX is only
142	* guaranteed to be >= INT_MAX).
143	*/
144	static uint64_t xorshift64star(uint64_t x)
145	{
146	x ^= x >> 12; /* a */
147	x ^= x << 25; /* b */
148	x ^= x >> 27; /* c */
149	return x * UINT64_C(2685821657736338717);
150	}
151
5901b2e1	152	static int plugin_load(struct qemu_plugin_desc desc, const qemu_info_t info)
54cb65d8 EC	153	{
	154	qemu_plugin_install_func_t install;
	155	struct qemu_plugin_ctx *ctx;
	156	gpointer sym;
	157	int rc;
	158
	159	ctx = qemu_memalign(qemu_dcache_linesize, sizeof(*ctx));
	160	memset(ctx, 0, sizeof(*ctx));
	161	ctx->desc = desc;
	162
	163	ctx->handle = g_module_open(desc->path, G_MODULE_BIND_LOCAL);
	164	if (ctx->handle == NULL) {
	165	error_report("%s: %s", __func__, g_module_error());
	166	goto err_dlopen;
	167	}
	168
	169	if (!g_module_symbol(ctx->handle, "qemu_plugin_install", &sym)) {
	170	error_report("%s: %s", __func__, g_module_error());
	171	goto err_symbol;
	172	}
	173	install = (qemu_plugin_install_func_t) sym;
	174	/* symbol was found; it could be NULL though */
	175	if (install == NULL) {
	176	error_report("%s: %s: qemu_plugin_install is NULL",
	177	__func__, desc->path);
	178	goto err_symbol;
	179	}
	180
3fb356cc AB	181	if (!g_module_symbol(ctx->handle, "qemu_plugin_version", &sym)) {
	182	error_report("TCG plugin %s does not declare API version %s",
	183	desc->path, g_module_error());
	184	goto err_symbol;
	185	} else {
	186	int version = (int )sym;
	187	if (version < QEMU_PLUGIN_MIN_VERSION) {
	188	error_report("TCG plugin %s requires API version %d, but "
	189	"this QEMU supports only a minimum version of %d",
	190	desc->path, version, QEMU_PLUGIN_MIN_VERSION);
	191	goto err_symbol;
	192	} else if (version > QEMU_PLUGIN_VERSION) {
	193	error_report("TCG plugin %s requires API version %d, but "
	194	"this QEMU supports only up to version %d",
	195	desc->path, version, QEMU_PLUGIN_VERSION);
	196	goto err_symbol;
	197	}
	198	}
	199
54cb65d8 EC	200	qemu_rec_mutex_lock(&plugin.lock);
	201
	202	/* find an unused random id with &ctx as the seed */
	203	ctx->id = (uint64_t)(uintptr_t)ctx;
	204	for (;;) {
	205	void *existing;
	206
	207	ctx->id = xorshift64star(ctx->id);
	208	existing = g_hash_table_lookup(plugin.id_ht, &ctx->id);
	209	if (likely(existing == NULL)) {
	210	bool success;
	211
	212	success = g_hash_table_insert(plugin.id_ht, &ctx->id, &ctx->id);
	213	g_assert(success);
	214	break;
	215	}
	216	}
	217	QTAILQ_INSERT_TAIL(&plugin.ctxs, ctx, entry);
	218	ctx->installing = true;
5901b2e1	219	rc = install(ctx->id, info, desc->argc, desc->argv);
54cb65d8 EC	220	ctx->installing = false;
	221	if (rc) {
	222	error_report("%s: qemu_plugin_install returned error code %d",
	223	__func__, rc);
	224	/*
	225	* we cannot rely on the plugin doing its own cleanup, so
	226	* call a full uninstall if the plugin did not yet call it.
	227	*/
	228	if (!ctx->uninstalling) {
	229	plugin_reset_uninstall(ctx->id, NULL, false);
	230	}
	231	}
	232
	233	qemu_rec_mutex_unlock(&plugin.lock);
	234	return rc;
	235
	236	err_symbol:
	237	err_dlopen:
	238	qemu_vfree(ctx);
	239	return 1;
	240	}
	241
	242	/* call after having removed @desc from the list */
	243	static void plugin_desc_free(struct qemu_plugin_desc *desc)
	244	{
	245	int i;
	246
	247	for (i = 0; i < desc->argc; i++) {
	248	g_free(desc->argv[i]);
	249	}
	250	g_free(desc->argv);
	251	g_free(desc->path);
	252	g_free(desc);
	253	}
	254
	255	/**
	256	* qemu_plugin_load_list - load a list of plugins
	257	* @head: head of the list of descriptors of the plugins to be loaded
	258	*
	259	* Returns 0 if all plugins in the list are installed, !0 otherwise.
	260	*
	261	* Note: the descriptor of each successfully installed plugin is removed
	262	* from the list given by @head.
	263	*/
	264	int qemu_plugin_load_list(QemuPluginList *head)
	265	{
	266	struct qemu_plugin_desc desc, next;
5901b2e1 AB	267	g_autofree qemu_info_t *info = g_new0(qemu_info_t, 1);
	268
	269	info->target_name = TARGET_NAME;
3fb356cc AB	270	info->version.min = QEMU_PLUGIN_MIN_VERSION;
3fb356cc AB	271	info->version.cur = QEMU_PLUGIN_VERSION;
5901b2e1 AB	272	#ifndef CONFIG_USER_ONLY
	273	MachineState *ms = MACHINE(qdev_get_machine());
	274	info->system_emulation = true;
	275	info->system.smp_vcpus = ms->smp.cpus;
	276	info->system.max_vcpus = ms->smp.max_cpus;
	277	#else
	278	info->system_emulation = false;
	279	#endif
54cb65d8 EC	280
	281	QTAILQ_FOREACH_SAFE(desc, head, entry, next) {
	282	int err;
	283
5901b2e1	284	err = plugin_load(desc, info);
54cb65d8 EC	285	if (err) {
	286	return err;
	287	}
	288	QTAILQ_REMOVE(head, desc, entry);
	289	}
	290	return 0;
	291	}
	292
	293	struct qemu_plugin_reset_data {
	294	struct qemu_plugin_ctx *ctx;
	295	qemu_plugin_simple_cb_t cb;
	296	bool reset;
	297	};
	298
	299	static void plugin_reset_destroy__locked(struct qemu_plugin_reset_data *data)
	300	{
	301	struct qemu_plugin_ctx *ctx = data->ctx;
	302	enum qemu_plugin_event ev;
	303	bool success;
	304
	305	/*
	306	* After updating the subscription lists there is no need to wait for an RCU
	307	* grace period to elapse, because right now we either are in a "safe async"
	308	* work environment (i.e. all vCPUs are asleep), or no vCPUs have yet been
	309	* created.
	310	*/
	311	for (ev = 0; ev < QEMU_PLUGIN_EV_MAX; ev++) {
	312	plugin_unregister_cb__locked(ctx, ev);
	313	}
	314
	315	if (data->reset) {
	316	g_assert(ctx->resetting);
	317	if (data->cb) {
	318	data->cb(ctx->id);
	319	}
	320	ctx->resetting = false;
	321	g_free(data);
	322	return;
	323	}
	324
	325	g_assert(ctx->uninstalling);
	326	/* we cannot dlclose if we are going to return to plugin code */
	327	if (ctx->installing) {
	328	error_report("Calling qemu_plugin_uninstall from the install function "
	329	"is a bug. Instead, return !0 from the install function.");
	330	abort();
	331	}
	332
	333	success = g_hash_table_remove(plugin.id_ht, &ctx->id);
	334	g_assert(success);
	335	QTAILQ_REMOVE(&plugin.ctxs, ctx, entry);
	336	if (data->cb) {
	337	data->cb(ctx->id);
	338	}
	339	if (!g_module_close(ctx->handle)) {
	340	warn_report("%s: %s", __func__, g_module_error());
	341	}
	342	plugin_desc_free(ctx->desc);
	343	qemu_vfree(ctx);
	344	g_free(data);
	345	}
	346
	347	static void plugin_reset_destroy(struct qemu_plugin_reset_data *data)
	348	{
349	qemu_rec_mutex_lock(&plugin.lock);
350	plugin_reset_destroy__locked(data);
351	qemu_rec_mutex_lock(&plugin.lock);
352	}
353
354	static void plugin_flush_destroy(CPUState *cpu, run_on_cpu_data arg)
355	{
356	struct qemu_plugin_reset_data *data = arg.host_ptr;
357
358	g_assert(cpu_in_exclusive_context(cpu));
359	tb_flush(cpu);
360	plugin_reset_destroy(data);
361	}
362
363	void plugin_reset_uninstall(qemu_plugin_id_t id,
364	qemu_plugin_simple_cb_t cb,
365	bool reset)
366	{
367	struct qemu_plugin_reset_data *data;
368	struct qemu_plugin_ctx *ctx;
369
370	qemu_rec_mutex_lock(&plugin.lock);
371	ctx = plugin_id_to_ctx_locked(id);
372	if (ctx->uninstalling \|\| (reset && ctx->resetting)) {
373	qemu_rec_mutex_unlock(&plugin.lock);
374	return;
375	}
376	ctx->resetting = reset;
377	ctx->uninstalling = !reset;
378	qemu_rec_mutex_unlock(&plugin.lock);
379
380	data = g_new(struct qemu_plugin_reset_data, 1);
381	data->ctx = ctx;
382	data->cb = cb;
383	data->reset = reset;
384	/*
385	* Only flush the code cache if the vCPUs have been created. If so,
386	* current_cpu must be non-NULL.
387	*/
388	if (current_cpu) {
389	async_safe_run_on_cpu(current_cpu, plugin_flush_destroy,
390	RUN_ON_CPU_HOST_PTR(data));
391	} else {
392	/*
393	* If current_cpu isn't set, then we don't have yet any vCPU threads
394	* and we therefore can remove the callbacks synchronously.
395	*/
396	plugin_reset_destroy(data);
397	}
398	}