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 }