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/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"
  31 #ifndef CONFIG_USER_ONLY
  32 #include "hw/boards.h"
  33 #endif
  34
  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
  65 typedef int (*qemu_plugin_install_func_t)(qemu_plugin_id_t, const qemu_info_t *, int, char **);
  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
 152 static int plugin_load(struct qemu_plugin_desc *desc, const qemu_info_t *info)
 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
 181     qemu_rec_mutex_lock(&plugin.lock);
 182
 183     /* find an unused random id with &ctx as the seed */
 184     ctx->id = (uint64_t)(uintptr_t)ctx;
 185     for (;;) {
 186         void *existing;
 187
 188         ctx->id = xorshift64star(ctx->id);
 189         existing = g_hash_table_lookup(plugin.id_ht, &ctx->id);
 190         if (likely(existing == NULL)) {
 191             bool success;
 192
 193             success = g_hash_table_insert(plugin.id_ht, &ctx->id, &ctx->id);
 194             g_assert(success);
 195             break;
 196         }
 197     }
 198     QTAILQ_INSERT_TAIL(&plugin.ctxs, ctx, entry);
 199     ctx->installing = true;
 200     rc = install(ctx->id, info, desc->argc, desc->argv);
 201     ctx->installing = false;
 202     if (rc) {
 203         error_report("%s: qemu_plugin_install returned error code %d",
 204                      __func__, rc);
 205         /*
 206          * we cannot rely on the plugin doing its own cleanup, so
 207          * call a full uninstall if the plugin did not yet call it.
 208          */
 209         if (!ctx->uninstalling) {
 210             plugin_reset_uninstall(ctx->id, NULL, false);
 211         }
 212     }
 213
 214     qemu_rec_mutex_unlock(&plugin.lock);
 215     return rc;
 216
 217  err_symbol:
 218  err_dlopen:
 219     qemu_vfree(ctx);
 220     return 1;
 221 }
 222
 223 /* call after having removed @desc from the list */
 224 static void plugin_desc_free(struct qemu_plugin_desc *desc)
 225 {
 226     int i;
 227
 228     for (i = 0; i < desc->argc; i++) {
 229         g_free(desc->argv[i]);
 230     }
 231     g_free(desc->argv);
 232     g_free(desc->path);
 233     g_free(desc);
 234 }
 235
 236 /**
 237  * qemu_plugin_load_list - load a list of plugins
 238  * @head: head of the list of descriptors of the plugins to be loaded
 239  *
 240  * Returns 0 if all plugins in the list are installed, !0 otherwise.
 241  *
 242  * Note: the descriptor of each successfully installed plugin is removed
 243  * from the list given by @head.
 244  */
 245 int qemu_plugin_load_list(QemuPluginList *head)
 246 {
 247     struct qemu_plugin_desc *desc, *next;
 248     g_autofree qemu_info_t *info = g_new0(qemu_info_t, 1);
 249
 250     info->target_name = TARGET_NAME;
 251 #ifndef CONFIG_USER_ONLY
 252     MachineState *ms = MACHINE(qdev_get_machine());
 253     info->system_emulation = true;
 254     info->system.smp_vcpus = ms->smp.cpus;
 255     info->system.max_vcpus = ms->smp.max_cpus;
 256 #else
 257     info->system_emulation = false;
 258 #endif
 259
 260     QTAILQ_FOREACH_SAFE(desc, head, entry, next) {
 261         int err;
 262
 263         err = plugin_load(desc, info);
 264         if (err) {
 265             return err;
 266         }
 267         QTAILQ_REMOVE(head, desc, entry);
 268     }
 269     return 0;
 270 }
 271
 272 struct qemu_plugin_reset_data {
 273     struct qemu_plugin_ctx *ctx;
 274     qemu_plugin_simple_cb_t cb;
 275     bool reset;
 276 };
 277
 278 static void plugin_reset_destroy__locked(struct qemu_plugin_reset_data *data)
 279 {
 280     struct qemu_plugin_ctx *ctx = data->ctx;
 281     enum qemu_plugin_event ev;
 282     bool success;
 283
 284     /*
 285      * After updating the subscription lists there is no need to wait for an RCU
 286      * grace period to elapse, because right now we either are in a "safe async"
 287      * work environment (i.e. all vCPUs are asleep), or no vCPUs have yet been
 288      * created.
 289      */
 290     for (ev = 0; ev < QEMU_PLUGIN_EV_MAX; ev++) {
 291         plugin_unregister_cb__locked(ctx, ev);
 292     }
 293
 294     if (data->reset) {
 295         g_assert(ctx->resetting);
 296         if (data->cb) {
 297             data->cb(ctx->id);
 298         }
 299         ctx->resetting = false;
 300         g_free(data);
 301         return;
 302     }
 303
 304     g_assert(ctx->uninstalling);
 305     /* we cannot dlclose if we are going to return to plugin code */
 306     if (ctx->installing) {
 307         error_report("Calling qemu_plugin_uninstall from the install function "
 308                      "is a bug. Instead, return !0 from the install function.");
 309         abort();
 310     }
 311
 312     success = g_hash_table_remove(plugin.id_ht, &ctx->id);
 313     g_assert(success);
 314     QTAILQ_REMOVE(&plugin.ctxs, ctx, entry);
 315     if (data->cb) {
 316         data->cb(ctx->id);
 317     }
 318     if (!g_module_close(ctx->handle)) {
 319         warn_report("%s: %s", __func__, g_module_error());
 320     }
 321     plugin_desc_free(ctx->desc);
 322     qemu_vfree(ctx);
 323     g_free(data);
 324 }
 325
 326 static void plugin_reset_destroy(struct qemu_plugin_reset_data *data)
 327 {
 328     qemu_rec_mutex_lock(&plugin.lock);
 329     plugin_reset_destroy__locked(data);
 330     qemu_rec_mutex_lock(&plugin.lock);
 331 }
 332
 333 static void plugin_flush_destroy(CPUState *cpu, run_on_cpu_data arg)
 334 {
 335     struct qemu_plugin_reset_data *data = arg.host_ptr;
 336
 337     g_assert(cpu_in_exclusive_context(cpu));
 338     tb_flush(cpu);
 339     plugin_reset_destroy(data);
 340 }
 341
 342 void plugin_reset_uninstall(qemu_plugin_id_t id,
 343                             qemu_plugin_simple_cb_t cb,
 344                             bool reset)
 345 {
 346     struct qemu_plugin_reset_data *data;
 347     struct qemu_plugin_ctx *ctx;
 348
 349     qemu_rec_mutex_lock(&plugin.lock);
 350     ctx = plugin_id_to_ctx_locked(id);
 351     if (ctx->uninstalling || (reset && ctx->resetting)) {
 352         qemu_rec_mutex_unlock(&plugin.lock);
 353         return;
 354     }
 355     ctx->resetting = reset;
 356     ctx->uninstalling = !reset;
 357     qemu_rec_mutex_unlock(&plugin.lock);
 358
 359     data = g_new(struct qemu_plugin_reset_data, 1);
 360     data->ctx = ctx;
 361     data->cb = cb;
 362     data->reset = reset;
 363     /*
 364      * Only flush the code cache if the vCPUs have been created. If so,
 365      * current_cpu must be non-NULL.
 366      */
 367     if (current_cpu) {
 368         async_safe_run_on_cpu(current_cpu, plugin_flush_destroy,
 369                               RUN_ON_CPU_HOST_PTR(data));
 370     } else {
 371         /*
 372          * If current_cpu isn't set, then we don't have yet any vCPU threads
 373          * and we therefore can remove the callbacks synchronously.
 374          */
 375         plugin_reset_destroy(data);
 376     }
 377 }