On upgrades the old .so files usually are replaced. But on the other hand since a qemu process represents a guest instance it is usually kept around. That makes late addition of dynamic features e.g. 'hot-attach of a ceph disk' fail by trying to load a new version of e.f. block-rbd.so into an old still running qemu binary. This adds a fallback to also load modules from a versioned directory in the temporary /var/run path. That way qemu is providing a way for packaging to store modules of an upgraded qemu package as needed until the next reboot. An example how that can then be used in packaging can be seen in: https://git.launchpad.net/~paelzer/ubuntu/+source/qemu/log/?h=bug-1847361-miss-old-so-on-upgrade-UBUNTU Fixes: https://bugs.launchpad.net/ubuntu/+source/qemu/+bug/1847361 Signed-off-by: Christian Ehrhardt <christian.ehrhardt@canonical.com> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com> Message-Id: <20200310145806.18335-2-christian.ehrhardt@canonical.com> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
248 lines
5.6 KiB
C
248 lines
5.6 KiB
C
/*
|
|
* QEMU Module Infrastructure
|
|
*
|
|
* Copyright IBM, Corp. 2009
|
|
*
|
|
* Authors:
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
* the COPYING file in the top-level directory.
|
|
*
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#ifdef CONFIG_MODULES
|
|
#include <gmodule.h>
|
|
#endif
|
|
#include "qemu/queue.h"
|
|
#include "qemu/module.h"
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
#include "qemu-version.h"
|
|
#endif
|
|
|
|
typedef struct ModuleEntry
|
|
{
|
|
void (*init)(void);
|
|
QTAILQ_ENTRY(ModuleEntry) node;
|
|
module_init_type type;
|
|
} ModuleEntry;
|
|
|
|
typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
|
|
|
|
static ModuleTypeList init_type_list[MODULE_INIT_MAX];
|
|
static bool modules_init_done[MODULE_INIT_MAX];
|
|
|
|
static ModuleTypeList dso_init_list;
|
|
|
|
static void init_lists(void)
|
|
{
|
|
static int inited;
|
|
int i;
|
|
|
|
if (inited) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < MODULE_INIT_MAX; i++) {
|
|
QTAILQ_INIT(&init_type_list[i]);
|
|
}
|
|
|
|
QTAILQ_INIT(&dso_init_list);
|
|
|
|
inited = 1;
|
|
}
|
|
|
|
|
|
static ModuleTypeList *find_type(module_init_type type)
|
|
{
|
|
init_lists();
|
|
|
|
return &init_type_list[type];
|
|
}
|
|
|
|
void register_module_init(void (*fn)(void), module_init_type type)
|
|
{
|
|
ModuleEntry *e;
|
|
ModuleTypeList *l;
|
|
|
|
e = g_malloc0(sizeof(*e));
|
|
e->init = fn;
|
|
e->type = type;
|
|
|
|
l = find_type(type);
|
|
|
|
QTAILQ_INSERT_TAIL(l, e, node);
|
|
}
|
|
|
|
void register_dso_module_init(void (*fn)(void), module_init_type type)
|
|
{
|
|
ModuleEntry *e;
|
|
|
|
init_lists();
|
|
|
|
e = g_malloc0(sizeof(*e));
|
|
e->init = fn;
|
|
e->type = type;
|
|
|
|
QTAILQ_INSERT_TAIL(&dso_init_list, e, node);
|
|
}
|
|
|
|
void module_call_init(module_init_type type)
|
|
{
|
|
ModuleTypeList *l;
|
|
ModuleEntry *e;
|
|
|
|
if (modules_init_done[type]) {
|
|
return;
|
|
}
|
|
|
|
l = find_type(type);
|
|
|
|
QTAILQ_FOREACH(e, l, node) {
|
|
e->init();
|
|
}
|
|
|
|
modules_init_done[type] = true;
|
|
}
|
|
|
|
#ifdef CONFIG_MODULES
|
|
static int module_load_file(const char *fname)
|
|
{
|
|
GModule *g_module;
|
|
void (*sym)(void);
|
|
const char *dsosuf = HOST_DSOSUF;
|
|
int len = strlen(fname);
|
|
int suf_len = strlen(dsosuf);
|
|
ModuleEntry *e, *next;
|
|
int ret;
|
|
|
|
if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {
|
|
/* wrong suffix */
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
if (access(fname, F_OK)) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
assert(QTAILQ_EMPTY(&dso_init_list));
|
|
|
|
g_module = g_module_open(fname, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
|
|
if (!g_module) {
|
|
fprintf(stderr, "Failed to open module: %s\n",
|
|
g_module_error());
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
|
|
fprintf(stderr, "Failed to initialize module: %s\n",
|
|
fname);
|
|
/* Print some info if this is a QEMU module (but from different build),
|
|
* this will make debugging user problems easier. */
|
|
if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {
|
|
fprintf(stderr,
|
|
"Note: only modules from the same build can be loaded.\n");
|
|
}
|
|
g_module_close(g_module);
|
|
ret = -EINVAL;
|
|
} else {
|
|
QTAILQ_FOREACH(e, &dso_init_list, node) {
|
|
e->init();
|
|
register_module_init(e->init, e->type);
|
|
}
|
|
ret = 0;
|
|
}
|
|
|
|
QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
|
|
QTAILQ_REMOVE(&dso_init_list, e, node);
|
|
g_free(e);
|
|
}
|
|
out:
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
bool module_load_one(const char *prefix, const char *lib_name)
|
|
{
|
|
bool success = false;
|
|
|
|
#ifdef CONFIG_MODULES
|
|
char *fname = NULL;
|
|
char *exec_dir;
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
char *version_dir;
|
|
#endif
|
|
const char *search_dir;
|
|
char *dirs[4];
|
|
char *module_name;
|
|
int i = 0, n_dirs = 0;
|
|
int ret;
|
|
static GHashTable *loaded_modules;
|
|
|
|
if (!g_module_supported()) {
|
|
fprintf(stderr, "Module is not supported by system.\n");
|
|
return false;
|
|
}
|
|
|
|
if (!loaded_modules) {
|
|
loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
|
|
}
|
|
|
|
module_name = g_strdup_printf("%s%s", prefix, lib_name);
|
|
|
|
if (!g_hash_table_add(loaded_modules, module_name)) {
|
|
g_free(module_name);
|
|
return true;
|
|
}
|
|
|
|
exec_dir = qemu_get_exec_dir();
|
|
search_dir = getenv("QEMU_MODULE_DIR");
|
|
if (search_dir != NULL) {
|
|
dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
|
|
}
|
|
dirs[n_dirs++] = g_strdup_printf("%s", CONFIG_QEMU_MODDIR);
|
|
dirs[n_dirs++] = g_strdup_printf("%s/..", exec_dir ? : "");
|
|
dirs[n_dirs++] = g_strdup_printf("%s", exec_dir ? : "");
|
|
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
|
|
G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
|
|
'_');
|
|
dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
|
|
#endif
|
|
|
|
assert(n_dirs <= ARRAY_SIZE(dirs));
|
|
|
|
g_free(exec_dir);
|
|
exec_dir = NULL;
|
|
|
|
for (i = 0; i < n_dirs; i++) {
|
|
fname = g_strdup_printf("%s/%s%s",
|
|
dirs[i], module_name, HOST_DSOSUF);
|
|
ret = module_load_file(fname);
|
|
g_free(fname);
|
|
fname = NULL;
|
|
/* Try loading until loaded a module file */
|
|
if (!ret) {
|
|
success = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!success) {
|
|
g_hash_table_remove(loaded_modules, module_name);
|
|
g_free(module_name);
|
|
}
|
|
|
|
for (i = 0; i < n_dirs; i++) {
|
|
g_free(dirs[i]);
|
|
}
|
|
|
|
#endif
|
|
return success;
|
|
}
|