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