1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
40
41
42QEMU_BUILD_BUG_ON(QEMU_PLUGIN_EV_MAX > 32);
43
44struct qemu_plugin_desc {
45 char *path;
46 char **argv;
47 QTAILQ_ENTRY(qemu_plugin_desc) entry;
48 int argc;
49};
50
51struct qemu_plugin_parse_arg {
52 QemuPluginList *head;
53 struct qemu_plugin_desc *curr;
54};
55
56QemuOptsList qemu_plugin_opts = {
57 .name = "plugin",
58 .implied_opt_name = "file",
59 .head = QTAILQ_HEAD_INITIALIZER(qemu_plugin_opts.head),
60 .desc = {
61
62 { }
63 },
64};
65
66typedef int (*qemu_plugin_install_func_t)(qemu_plugin_id_t, const qemu_info_t *, int, char **);
67
68extern struct qemu_plugin_state plugin;
69
70void 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
79static 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
92static 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
125void 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
142
143
144
145static uint64_t xorshift64star(uint64_t x)
146{
147 x ^= x >> 12;
148 x ^= x << 25;
149 x ^= x >> 27;
150 return x * UINT64_C(2685821657736338717);
151}
152
153static 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
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
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
227
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
244static 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
258
259
260
261
262
263
264
265int 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
294struct qemu_plugin_reset_data {
295 struct qemu_plugin_ctx *ctx;
296 qemu_plugin_simple_cb_t cb;
297 bool reset;
298};
299
300static 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
308
309
310
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
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
348static 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
355static 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
364void 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
386
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
394
395
396 plugin_reset_destroy(data);
397 }
398}
399