2009-05-14 20:29:53 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
2012-01-13 17:44:23 +01:00
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2009-05-14 20:29:53 +02:00
|
|
|
*/
|
|
|
|
|
2016-01-29 18:49:55 +01:00
|
|
|
#include "qemu/osdep.h"
|
2014-02-25 17:36:55 +01:00
|
|
|
#ifdef CONFIG_MODULES
|
2014-02-10 07:48:57 +01:00
|
|
|
#include <gmodule.h>
|
2014-02-25 17:36:55 +01:00
|
|
|
#endif
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu/module.h"
|
2020-08-18 12:00:18 +02:00
|
|
|
#include "qemu/cutils.h"
|
2020-03-10 15:58:06 +01:00
|
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
|
|
#include "qemu-version.h"
|
|
|
|
#endif
|
2009-05-14 20:29:53 +02:00
|
|
|
|
|
|
|
typedef struct ModuleEntry
|
|
|
|
{
|
|
|
|
void (*init)(void);
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_ENTRY(ModuleEntry) node;
|
2014-02-10 07:48:57 +01:00
|
|
|
module_init_type type;
|
2009-05-14 20:29:53 +02:00
|
|
|
} ModuleEntry;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
static ModuleTypeList init_type_list[MODULE_INIT_MAX];
|
2020-02-20 05:10:59 +01:00
|
|
|
static bool modules_init_done[MODULE_INIT_MAX];
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2014-02-10 07:48:57 +01:00
|
|
|
static ModuleTypeList dso_init_list;
|
|
|
|
|
|
|
|
static void init_lists(void)
|
2009-05-14 20:29:53 +02:00
|
|
|
{
|
2009-05-15 00:57:31 +02:00
|
|
|
static int inited;
|
|
|
|
int i;
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
if (inited) {
|
|
|
|
return;
|
2009-05-14 20:29:53 +02:00
|
|
|
}
|
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
for (i = 0; i < MODULE_INIT_MAX; i++) {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INIT(&init_type_list[i]);
|
2009-05-15 00:57:31 +02:00
|
|
|
}
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2014-02-10 07:48:57 +01:00
|
|
|
QTAILQ_INIT(&dso_init_list);
|
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
inited = 1;
|
|
|
|
}
|
2009-05-14 20:29:53 +02:00
|
|
|
|
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
static ModuleTypeList *find_type(module_init_type type)
|
|
|
|
{
|
2014-02-10 07:48:57 +01:00
|
|
|
init_lists();
|
2009-05-15 00:57:31 +02:00
|
|
|
|
2016-06-13 23:57:58 +02:00
|
|
|
return &init_type_list[type];
|
2009-05-14 20:29:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void register_module_init(void (*fn)(void), module_init_type type)
|
|
|
|
{
|
|
|
|
ModuleEntry *e;
|
|
|
|
ModuleTypeList *l;
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
e = g_malloc0(sizeof(*e));
|
2009-05-14 20:29:53 +02:00
|
|
|
e->init = fn;
|
2014-02-10 07:48:57 +01:00
|
|
|
e->type = type;
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
l = find_type(type);
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(l, e, node);
|
2009-05-14 20:29:53 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 07:48:57 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-05-14 20:29:53 +02:00
|
|
|
void module_call_init(module_init_type type)
|
|
|
|
{
|
|
|
|
ModuleTypeList *l;
|
|
|
|
ModuleEntry *e;
|
|
|
|
|
2020-02-20 05:10:59 +01:00
|
|
|
if (modules_init_done[type]) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-15 00:57:31 +02:00
|
|
|
l = find_type(type);
|
2009-05-14 20:29:53 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(e, l, node) {
|
2009-05-14 20:29:53 +02:00
|
|
|
e->init();
|
|
|
|
}
|
2020-02-20 05:10:59 +01:00
|
|
|
|
|
|
|
modules_init_done[type] = true;
|
2009-05-14 20:29:53 +02:00
|
|
|
}
|
2014-02-10 07:48:57 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_MODULES
|
2020-10-19 09:52:20 +02:00
|
|
|
static int module_load_file(const char *fname, bool mayfail, bool export_symbols)
|
2014-02-10 07:48:57 +01:00
|
|
|
{
|
|
|
|
GModule *g_module;
|
|
|
|
void (*sym)(void);
|
2020-08-04 18:14:26 +02:00
|
|
|
const char *dsosuf = CONFIG_HOST_DSOSUF;
|
2014-02-10 07:48:57 +01:00
|
|
|
int len = strlen(fname);
|
|
|
|
int suf_len = strlen(dsosuf);
|
|
|
|
ModuleEntry *e, *next;
|
2020-10-19 09:52:20 +02:00
|
|
|
int ret, flags;
|
2014-02-10 07:48:57 +01:00
|
|
|
|
|
|
|
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));
|
|
|
|
|
2020-10-19 09:52:20 +02:00
|
|
|
flags = G_MODULE_BIND_LAZY;
|
|
|
|
if (!export_symbols) {
|
|
|
|
flags |= G_MODULE_BIND_LOCAL;
|
|
|
|
}
|
|
|
|
g_module = g_module_open(fname, flags);
|
2014-02-10 07:48:57 +01:00
|
|
|
if (!g_module) {
|
2020-09-23 11:12:17 +02:00
|
|
|
if (!mayfail) {
|
|
|
|
fprintf(stderr, "Failed to open module: %s\n",
|
|
|
|
g_module_error());
|
|
|
|
}
|
2014-02-10 07:48:57 +01:00
|
|
|
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) {
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
e->init();
|
2014-02-10 07:48:57 +01:00
|
|
|
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;
|
|
|
|
}
|
2020-10-19 09:52:20 +02:00
|
|
|
|
|
|
|
static const struct {
|
|
|
|
const char *name;
|
|
|
|
const char *dep;
|
|
|
|
} module_deps[] = {
|
2020-10-19 09:52:21 +02:00
|
|
|
{ "audio-spice", "ui-spice-core" },
|
|
|
|
{ "chardev-spice", "ui-spice-core" },
|
|
|
|
{ "hw-display-qxl", "ui-spice-core" },
|
|
|
|
{ "ui-spice-app", "ui-spice-core" },
|
|
|
|
{ "ui-spice-app", "chardev-spice" },
|
2020-10-19 09:52:20 +02:00
|
|
|
};
|
2014-02-10 07:48:57 +01:00
|
|
|
#endif
|
|
|
|
|
2020-09-23 11:12:17 +02:00
|
|
|
bool module_load_one(const char *prefix, const char *lib_name, bool mayfail)
|
2014-02-10 07:48:57 +01:00
|
|
|
{
|
2019-07-22 15:13:23 +02:00
|
|
|
bool success = false;
|
|
|
|
|
2014-02-10 07:48:57 +01:00
|
|
|
#ifdef CONFIG_MODULES
|
|
|
|
char *fname = NULL;
|
2020-03-10 15:58:06 +01:00
|
|
|
#ifdef CONFIG_MODULE_UPGRADES
|
|
|
|
char *version_dir;
|
|
|
|
#endif
|
2018-07-04 20:10:10 +02:00
|
|
|
const char *search_dir;
|
2020-04-11 03:07:46 +02:00
|
|
|
char *dirs[5];
|
2016-09-05 04:50:44 +02:00
|
|
|
char *module_name;
|
2018-07-04 20:10:10 +02:00
|
|
|
int i = 0, n_dirs = 0;
|
2020-10-19 09:52:20 +02:00
|
|
|
int ret, dep;
|
|
|
|
bool export_symbols = false;
|
2016-09-05 04:50:44 +02:00
|
|
|
static GHashTable *loaded_modules;
|
2014-02-10 07:48:57 +01:00
|
|
|
|
|
|
|
if (!g_module_supported()) {
|
|
|
|
fprintf(stderr, "Module is not supported by system.\n");
|
2019-07-22 15:13:23 +02:00
|
|
|
return false;
|
2014-02-10 07:48:57 +01:00
|
|
|
}
|
|
|
|
|
2016-09-05 04:50:44 +02:00
|
|
|
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);
|
|
|
|
|
2020-10-19 09:52:20 +02:00
|
|
|
for (dep = 0; dep < ARRAY_SIZE(module_deps); dep++) {
|
|
|
|
if (strcmp(module_name, module_deps[dep].name) == 0) {
|
|
|
|
/* we depend on another module */
|
|
|
|
module_load_one("", module_deps[dep].dep, false);
|
|
|
|
}
|
|
|
|
if (strcmp(module_name, module_deps[dep].dep) == 0) {
|
|
|
|
/* another module depends on us */
|
|
|
|
export_symbols = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-22 15:10:46 +02:00
|
|
|
if (!g_hash_table_add(loaded_modules, module_name)) {
|
2016-09-05 04:50:44 +02:00
|
|
|
g_free(module_name);
|
2019-07-22 15:13:23 +02:00
|
|
|
return true;
|
2016-09-05 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2018-07-04 20:10:10 +02:00
|
|
|
search_dir = getenv("QEMU_MODULE_DIR");
|
|
|
|
if (search_dir != NULL) {
|
|
|
|
dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
|
|
|
|
}
|
2020-08-18 12:00:18 +02:00
|
|
|
dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR);
|
2020-08-18 12:11:02 +02:00
|
|
|
dirs[n_dirs++] = g_strdup(qemu_get_exec_dir());
|
2020-03-10 15:58:06 +01:00
|
|
|
|
|
|
|
#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
|
|
|
|
|
2018-07-04 20:10:10 +02:00
|
|
|
assert(n_dirs <= ARRAY_SIZE(dirs));
|
|
|
|
|
|
|
|
for (i = 0; i < n_dirs; i++) {
|
2016-09-05 04:50:44 +02:00
|
|
|
fname = g_strdup_printf("%s/%s%s",
|
2020-08-04 18:14:26 +02:00
|
|
|
dirs[i], module_name, CONFIG_HOST_DSOSUF);
|
2020-10-19 09:52:20 +02:00
|
|
|
ret = module_load_file(fname, mayfail, export_symbols);
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
g_free(fname);
|
|
|
|
fname = NULL;
|
|
|
|
/* Try loading until loaded a module file */
|
|
|
|
if (!ret) {
|
2019-07-22 15:13:23 +02:00
|
|
|
success = true;
|
blockdev: Add dynamic module loading for block drivers
Extend the current module interface to allow for block drivers to be
loaded dynamically on request. The only block drivers that can be
converted into modules are the drivers that don't perform any init
operation except for registering themselves.
In addition, only the protocol drivers are being modularized, as they
are the only ones which see significant performance benefits. The format
drivers do not generally link to external libraries, so modularizing
them is of no benefit from a performance perspective.
All the necessary module information is located in a new structure found
in module_block.h
This spoils the purpose of 5505e8b76f (block/dmg: make it modular).
Before this patch, if module build is enabled, block-dmg.so is linked to
libbz2, whereas the main binary is not. In downstream, theoretically, it
means only the qemu-block-extra package depends on libbz2, while the
main QEMU package needn't to. With this patch, we (temporarily) change
the case so that the main QEMU depends on libbz2 again.
Signed-off-by: Marc Marí <markmb@redhat.com>
Signed-off-by: Colin Lord <clord@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1471008424-16465-4-git-send-email-clord@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
[mreitz: Do a signed comparison against the length of
block_driver_modules[], so it will not cause a compile error when
empty]
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-08-12 15:27:03 +02:00
|
|
|
break;
|
2014-02-10 07:48:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-22 15:13:23 +02:00
|
|
|
if (!success) {
|
|
|
|
g_hash_table_remove(loaded_modules, module_name);
|
2019-12-20 02:34:10 +01:00
|
|
|
g_free(module_name);
|
2019-07-22 15:13:23 +02:00
|
|
|
}
|
|
|
|
|
2018-07-04 20:10:10 +02:00
|
|
|
for (i = 0; i < n_dirs; i++) {
|
2014-02-10 07:48:57 +01:00
|
|
|
g_free(dirs[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2019-07-22 15:13:23 +02:00
|
|
|
return success;
|
2014-02-10 07:48:57 +01:00
|
|
|
}
|
2020-06-24 15:10:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Building devices and other qom objects modular is mostly useful in
|
|
|
|
* case they have dependencies to external shared libraries, so we can
|
|
|
|
* cut down the core qemu library dependencies. Which is the case for
|
|
|
|
* only a very few devices & objects.
|
|
|
|
*
|
|
|
|
* So with the expectation that this will be rather the exception than
|
2020-09-23 12:37:28 +02:00
|
|
|
* the rule and the list will not gain that many entries, go with a
|
2020-06-24 15:10:36 +02:00
|
|
|
* simple manually maintained list for now.
|
2020-09-23 12:37:28 +02:00
|
|
|
*
|
|
|
|
* The list must be sorted by module (module_load_qom_all() needs this).
|
2020-06-24 15:10:36 +02:00
|
|
|
*/
|
|
|
|
static struct {
|
|
|
|
const char *type;
|
|
|
|
const char *prefix;
|
|
|
|
const char *module;
|
|
|
|
} const qom_modules[] = {
|
2020-06-24 15:10:40 +02:00
|
|
|
{ "ccid-card-passthru", "hw-", "usb-smartcard" },
|
|
|
|
{ "ccid-card-emulated", "hw-", "usb-smartcard" },
|
2020-06-24 15:10:41 +02:00
|
|
|
{ "usb-redir", "hw-", "usb-redirect" },
|
2020-06-24 15:10:42 +02:00
|
|
|
{ "qxl-vga", "hw-", "display-qxl" },
|
|
|
|
{ "qxl", "hw-", "display-qxl" },
|
2020-09-14 15:42:24 +02:00
|
|
|
{ "virtio-gpu-device", "hw-", "display-virtio-gpu" },
|
|
|
|
{ "vhost-user-gpu", "hw-", "display-virtio-gpu" },
|
2020-06-24 15:10:45 +02:00
|
|
|
{ "chardev-braille", "chardev-", "baum" },
|
2020-10-14 14:11:20 +02:00
|
|
|
{ "chardev-spicevmc", "chardev-", "spice" },
|
|
|
|
{ "chardev-spiceport", "chardev-", "spice" },
|
2020-06-24 15:10:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static bool module_loaded_qom_all;
|
|
|
|
|
|
|
|
void module_load_qom_one(const char *type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2020-07-20 12:03:51 +02:00
|
|
|
if (!type) {
|
|
|
|
return;
|
|
|
|
}
|
2020-06-24 15:10:36 +02:00
|
|
|
for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
|
|
|
|
if (strcmp(qom_modules[i].type, type) == 0) {
|
|
|
|
module_load_one(qom_modules[i].prefix,
|
2020-09-23 11:12:17 +02:00
|
|
|
qom_modules[i].module,
|
|
|
|
false);
|
2020-06-24 15:10:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void module_load_qom_all(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (module_loaded_qom_all) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
|
|
|
|
if (i > 0 && (strcmp(qom_modules[i - 1].module,
|
|
|
|
qom_modules[i].module) == 0 &&
|
|
|
|
strcmp(qom_modules[i - 1].prefix,
|
|
|
|
qom_modules[i].prefix) == 0)) {
|
|
|
|
/* one module implementing multiple types -> load only once */
|
|
|
|
continue;
|
|
|
|
}
|
2020-09-23 11:12:17 +02:00
|
|
|
module_load_one(qom_modules[i].prefix, qom_modules[i].module, true);
|
2020-06-24 15:10:36 +02:00
|
|
|
}
|
|
|
|
module_loaded_qom_all = true;
|
|
|
|
}
|