mirror of
https://github.com/qemu/qemu.git
synced 2024-11-30 15:23:34 +08:00
c551fb0b53
improve error handling during module load, by changing:
bool module_load(const char *prefix, const char *lib_name);
void module_load_qom(const char *type);
to:
int module_load(const char *prefix, const char *name, Error **errp);
int module_load_qom(const char *type, Error **errp);
where the return value is:
-1 on module load error, and errp is set with the error
0 on module or one of its dependencies are not installed
1 on module load success
2 on module load success (module already loaded or built-in)
module_load_qom_one has been introduced in:
commit 28457744c3
("module: qom module support"), which built on top of
module_load_one, but discarded the bool return value. Restore it.
Adapt all callers to emit errors, or ignore them, or fail hard,
as appropriate in each context.
Replace the previous emission of errors via fprintf in _some_ error
conditions with Error and error_report, so as to emit to the appropriate
target.
A memory leak is also fixed as part of the module_load changes.
audio: when attempting to load an audio module, report module load errors.
Note that still for some callers, a single issue may generate multiple
error reports, and this could be improved further.
Regarding the audio code itself, audio_add() seems to ignore errors,
and this should probably be improved.
block: when attempting to load a block module, report module load errors.
For the code paths that already use the Error API, take advantage of those
to report module load errors into the Error parameter.
For the other code paths, we currently emit the error, but this could be
improved further by adding Error parameters to all possible code paths.
console: when attempting to load a display module, report module load errors.
qdev: when creating a new qdev Device object (DeviceState), report load errors.
If a module cannot be loaded to create that device, now abort execution
(if no CONFIG_MODULE) or exit (if CONFIG_MODULE).
qom/object.c: when initializing a QOM object, or looking up class_by_name,
report module load errors.
qtest: when processing the "module_load" qtest command, report errors
in the load of the module.
Signed-off-by: Claudio Fontana <cfontana@suse.de>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20220929093035.4231-4-cfontana@suse.de>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
406 lines
10 KiB
C
406 lines
10 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"
|
|
#include "qemu/cutils.h"
|
|
#include "qemu/config-file.h"
|
|
#include "qapi/error.h"
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
#include "qemu-version.h"
|
|
#endif
|
|
#include "trace.h"
|
|
|
|
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 const QemuModinfo module_info_stub[] = { {
|
|
/* end of list */
|
|
} };
|
|
static const QemuModinfo *module_info = module_info_stub;
|
|
static const char *module_arch;
|
|
|
|
void module_init_info(const QemuModinfo *info)
|
|
{
|
|
module_info = info;
|
|
}
|
|
|
|
void module_allow_arch(const char *arch)
|
|
{
|
|
module_arch = arch;
|
|
}
|
|
|
|
static bool module_check_arch(const QemuModinfo *modinfo)
|
|
{
|
|
if (modinfo->arch) {
|
|
if (!module_arch) {
|
|
/* no arch set -> ignore all */
|
|
return false;
|
|
}
|
|
if (strcmp(module_arch, modinfo->arch) != 0) {
|
|
/* mismatch */
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* module_load_dso: attempt to load an existing dso file
|
|
*
|
|
* fname: full pathname of the file to load
|
|
* export_symbols: if true, add the symbols to the global name space
|
|
* errp: error to set.
|
|
*
|
|
* Return value: true on success, false on error, and errp will be set.
|
|
*/
|
|
static bool module_load_dso(const char *fname, bool export_symbols,
|
|
Error **errp)
|
|
{
|
|
GModule *g_module;
|
|
void (*sym)(void);
|
|
ModuleEntry *e, *next;
|
|
int flags;
|
|
|
|
assert(QTAILQ_EMPTY(&dso_init_list));
|
|
|
|
flags = 0;
|
|
if (!export_symbols) {
|
|
flags |= G_MODULE_BIND_LOCAL;
|
|
}
|
|
g_module = g_module_open(fname, flags);
|
|
if (!g_module) {
|
|
error_setg(errp, "failed to open module: %s", g_module_error());
|
|
return false;
|
|
}
|
|
if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
|
|
error_setg(errp, "failed to initialize module: %s", 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)) {
|
|
error_append_hint(errp,
|
|
"Only modules from the same build can be loaded.\n");
|
|
}
|
|
g_module_close(g_module);
|
|
return false;
|
|
}
|
|
|
|
QTAILQ_FOREACH(e, &dso_init_list, node) {
|
|
e->init();
|
|
register_module_init(e->init, e->type);
|
|
}
|
|
trace_module_load_module(fname);
|
|
QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
|
|
QTAILQ_REMOVE(&dso_init_list, e, node);
|
|
g_free(e);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int module_load(const char *prefix, const char *name, Error **errp)
|
|
{
|
|
int rv = -1;
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
char *version_dir;
|
|
#endif
|
|
const char *search_dir;
|
|
char *dirs[5];
|
|
char *module_name;
|
|
int i = 0, n_dirs = 0;
|
|
bool export_symbols = false;
|
|
static GHashTable *loaded_modules;
|
|
const QemuModinfo *modinfo;
|
|
const char **sl;
|
|
|
|
if (!g_module_supported()) {
|
|
error_setg(errp, "%s", "this platform does not support GLib modules");
|
|
return -1;
|
|
}
|
|
|
|
if (!loaded_modules) {
|
|
loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
|
|
}
|
|
|
|
/* allocate all resources managed by the out: label here */
|
|
module_name = g_strdup_printf("%s%s", prefix, name);
|
|
|
|
if (g_hash_table_contains(loaded_modules, module_name)) {
|
|
g_free(module_name);
|
|
return 2; /* module already loaded */
|
|
}
|
|
g_hash_table_add(loaded_modules, module_name);
|
|
|
|
search_dir = getenv("QEMU_MODULE_DIR");
|
|
if (search_dir != NULL) {
|
|
dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
|
|
}
|
|
dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR);
|
|
|
|
#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));
|
|
|
|
/* end of resources managed by the out: label */
|
|
|
|
for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
|
|
if (modinfo->arch) {
|
|
if (strcmp(modinfo->name, module_name) == 0) {
|
|
if (!module_check_arch(modinfo)) {
|
|
error_setg(errp, "module arch does not match: "
|
|
"expected '%s', got '%s'", module_arch, modinfo->arch);
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
if (modinfo->deps) {
|
|
if (strcmp(modinfo->name, module_name) == 0) {
|
|
/* we depend on other module(s) */
|
|
for (sl = modinfo->deps; *sl != NULL; sl++) {
|
|
int subrv = module_load("", *sl, errp);
|
|
if (subrv <= 0) {
|
|
rv = subrv;
|
|
goto out;
|
|
}
|
|
}
|
|
} else {
|
|
for (sl = modinfo->deps; *sl != NULL; sl++) {
|
|
if (strcmp(module_name, *sl) == 0) {
|
|
/* another module depends on us */
|
|
export_symbols = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < n_dirs; i++) {
|
|
char *fname = g_strdup_printf("%s/%s%s",
|
|
dirs[i], module_name, CONFIG_HOST_DSOSUF);
|
|
int ret = access(fname, F_OK);
|
|
if (ret != 0 && (errno == ENOENT || errno == ENOTDIR)) {
|
|
/*
|
|
* if we don't find the module in this dir, try the next one.
|
|
* If we don't find it in any dir, that can be fine too: user
|
|
* did not install the module. We will return 0 in this case
|
|
* with no error set.
|
|
*/
|
|
g_free(fname);
|
|
continue;
|
|
} else if (ret != 0) {
|
|
/* most common is EACCES here */
|
|
error_setg_errno(errp, errno, "error trying to access %s", fname);
|
|
} else if (module_load_dso(fname, export_symbols, errp)) {
|
|
rv = 1; /* module successfully loaded */
|
|
}
|
|
g_free(fname);
|
|
goto out;
|
|
}
|
|
rv = 0; /* module not found */
|
|
|
|
out:
|
|
if (rv <= 0) {
|
|
g_hash_table_remove(loaded_modules, module_name);
|
|
g_free(module_name);
|
|
}
|
|
for (i = 0; i < n_dirs; i++) {
|
|
g_free(dirs[i]);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
static bool module_loaded_qom_all;
|
|
|
|
int module_load_qom(const char *type, Error **errp)
|
|
{
|
|
const QemuModinfo *modinfo;
|
|
const char **sl;
|
|
int rv = 0;
|
|
|
|
if (!type) {
|
|
error_setg(errp, "%s", "type is NULL");
|
|
return -1;
|
|
}
|
|
|
|
trace_module_lookup_object_type(type);
|
|
for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
|
|
if (!modinfo->objs) {
|
|
continue;
|
|
}
|
|
if (!module_check_arch(modinfo)) {
|
|
continue;
|
|
}
|
|
for (sl = modinfo->objs; *sl != NULL; sl++) {
|
|
if (strcmp(type, *sl) == 0) {
|
|
if (rv > 0) {
|
|
error_setg(errp, "multiple modules providing '%s'", type);
|
|
return -1;
|
|
}
|
|
rv = module_load("", modinfo->name, errp);
|
|
if (rv < 0) {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
void module_load_qom_all(void)
|
|
{
|
|
const QemuModinfo *modinfo;
|
|
Error *local_err = NULL;
|
|
|
|
if (module_loaded_qom_all) {
|
|
return;
|
|
}
|
|
|
|
for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
|
|
if (!modinfo->objs) {
|
|
continue;
|
|
}
|
|
if (!module_check_arch(modinfo)) {
|
|
continue;
|
|
}
|
|
if (module_load("", modinfo->name, &local_err) < 0) {
|
|
error_report_err(local_err);
|
|
}
|
|
}
|
|
module_loaded_qom_all = true;
|
|
}
|
|
|
|
void qemu_load_module_for_opts(const char *group)
|
|
{
|
|
const QemuModinfo *modinfo;
|
|
const char **sl;
|
|
|
|
for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
|
|
if (!modinfo->opts) {
|
|
continue;
|
|
}
|
|
for (sl = modinfo->opts; *sl != NULL; sl++) {
|
|
if (strcmp(group, *sl) == 0) {
|
|
Error *local_err = NULL;
|
|
if (module_load("", modinfo->name, &local_err) < 0) {
|
|
error_report_err(local_err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
void module_allow_arch(const char *arch) {}
|
|
void qemu_load_module_for_opts(const char *group) {}
|
|
int module_load(const char *prefix, const char *name, Error **errp) { return 2; }
|
|
int module_load_qom(const char *type, Error **errp) { return 2; }
|
|
void module_load_qom_all(void) {}
|
|
|
|
#endif
|