Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20210330' into...
[qemu/ar7.git] / util / module.c
blobcbe89fede628c3674e49194ee6882f0d5bc06a9b
1 /*
2  * QEMU Module Infrastructure
3  *
4  * Copyright IBM, Corp. 2009
5  *
6  * Authors:
7  *  Anthony Liguori   <aliguori@us.ibm.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2.  See
10  * the COPYING file in the top-level directory.
11  *
12  * Contributions after 2012-01-13 are licensed under the terms of the
13  * GNU GPL, version 2 or (at your option) any later version.
14  */
16 #include "qemu/osdep.h"
17 #ifdef CONFIG_MODULES
18 #include <gmodule.h>
19 #endif
20 #include "qemu/queue.h"
21 #include "qemu/module.h"
22 #include "qemu/cutils.h"
23 #ifdef CONFIG_MODULE_UPGRADES
24 #include "qemu-version.h"
25 #endif
27 typedef struct ModuleEntry
29     void (*init)(void);
30     QTAILQ_ENTRY(ModuleEntry) node;
31     module_init_type type;
32 } ModuleEntry;
34 typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
36 static ModuleTypeList init_type_list[MODULE_INIT_MAX];
37 static bool modules_init_done[MODULE_INIT_MAX];
39 static ModuleTypeList dso_init_list;
41 static void init_lists(void)
43     static int inited;
44     int i;
46     if (inited) {
47         return;
48     }
50     for (i = 0; i < MODULE_INIT_MAX; i++) {
51         QTAILQ_INIT(&init_type_list[i]);
52     }
54     QTAILQ_INIT(&dso_init_list);
56     inited = 1;
60 static ModuleTypeList *find_type(module_init_type type)
62     init_lists();
64     return &init_type_list[type];
67 void register_module_init(void (*fn)(void), module_init_type type)
69     ModuleEntry *e;
70     ModuleTypeList *l;
72     e = g_malloc0(sizeof(*e));
73     e->init = fn;
74     e->type = type;
76     l = find_type(type);
78     QTAILQ_INSERT_TAIL(l, e, node);
81 void register_dso_module_init(void (*fn)(void), module_init_type type)
83     ModuleEntry *e;
85     init_lists();
87     e = g_malloc0(sizeof(*e));
88     e->init = fn;
89     e->type = type;
91     QTAILQ_INSERT_TAIL(&dso_init_list, e, node);
94 void module_call_init(module_init_type type)
96     ModuleTypeList *l;
97     ModuleEntry *e;
99     if (modules_init_done[type]) {
100         return;
101     }
103     l = find_type(type);
105     QTAILQ_FOREACH(e, l, node) {
106         e->init();
107     }
109     modules_init_done[type] = true;
112 #ifdef CONFIG_MODULES
113 static int module_load_file(const char *fname, bool mayfail, bool export_symbols)
115     GModule *g_module;
116     void (*sym)(void);
117     const char *dsosuf = CONFIG_HOST_DSOSUF;
118     int len = strlen(fname);
119     int suf_len = strlen(dsosuf);
120     ModuleEntry *e, *next;
121     int ret, flags;
123     if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {
124         /* wrong suffix */
125         ret = -EINVAL;
126         goto out;
127     }
128     if (access(fname, F_OK)) {
129         ret = -ENOENT;
130         goto out;
131     }
133     assert(QTAILQ_EMPTY(&dso_init_list));
135     flags = 0;
136     if (!export_symbols) {
137         flags |= G_MODULE_BIND_LOCAL;
138     }
139     g_module = g_module_open(fname, flags);
140     if (!g_module) {
141         if (!mayfail) {
142             fprintf(stderr, "Failed to open module: %s\n",
143                     g_module_error());
144         }
145         ret = -EINVAL;
146         goto out;
147     }
148     if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
149         fprintf(stderr, "Failed to initialize module: %s\n",
150                 fname);
151         /* Print some info if this is a QEMU module (but from different build),
152          * this will make debugging user problems easier. */
153         if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {
154             fprintf(stderr,
155                     "Note: only modules from the same build can be loaded.\n");
156         }
157         g_module_close(g_module);
158         ret = -EINVAL;
159     } else {
160         QTAILQ_FOREACH(e, &dso_init_list, node) {
161             e->init();
162             register_module_init(e->init, e->type);
163         }
164         ret = 0;
165     }
167     QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
168         QTAILQ_REMOVE(&dso_init_list, e, node);
169         g_free(e);
170     }
171 out:
172     return ret;
175 static const struct {
176     const char *name;
177     const char *dep;
178 } module_deps[] = {
179     { "audio-spice",    "ui-spice-core" },
180     { "chardev-spice",  "ui-spice-core" },
181     { "hw-display-qxl", "ui-spice-core" },
182     { "ui-spice-app",   "ui-spice-core" },
183     { "ui-spice-app",   "chardev-spice" },
185 #ifdef CONFIG_OPENGL
186     { "ui-egl-headless", "ui-opengl"    },
187     { "ui-gtk",          "ui-opengl"    },
188     { "ui-sdl",          "ui-opengl"    },
189     { "ui-spice-core",   "ui-opengl"    },
190 #endif
192 #endif
194 bool module_load_one(const char *prefix, const char *lib_name, bool mayfail)
196     bool success = false;
198 #ifdef CONFIG_MODULES
199     char *fname = NULL;
200 #ifdef CONFIG_MODULE_UPGRADES
201     char *version_dir;
202 #endif
203     const char *search_dir;
204     char *dirs[5];
205     char *module_name;
206     int i = 0, n_dirs = 0;
207     int ret, dep;
208     bool export_symbols = false;
209     static GHashTable *loaded_modules;
211     if (!g_module_supported()) {
212         fprintf(stderr, "Module is not supported by system.\n");
213         return false;
214     }
216     if (!loaded_modules) {
217         loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
218     }
220     module_name = g_strdup_printf("%s%s", prefix, lib_name);
222     for (dep = 0; dep < ARRAY_SIZE(module_deps); dep++) {
223         if (strcmp(module_name, module_deps[dep].name) == 0) {
224             /* we depend on another module */
225             module_load_one("", module_deps[dep].dep, false);
226         }
227         if (strcmp(module_name, module_deps[dep].dep) == 0) {
228             /* another module depends on us */
229             export_symbols = true;
230         }
231     }
233     if (!g_hash_table_add(loaded_modules, module_name)) {
234         g_free(module_name);
235         return true;
236     }
238     search_dir = getenv("QEMU_MODULE_DIR");
239     if (search_dir != NULL) {
240         dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
241     }
242     dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR);
243     dirs[n_dirs++] = g_strdup(qemu_get_exec_dir());
245 #ifdef CONFIG_MODULE_UPGRADES
246     version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
247                              G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
248                              '_');
249     dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
250 #endif
252     assert(n_dirs <= ARRAY_SIZE(dirs));
254     for (i = 0; i < n_dirs; i++) {
255         fname = g_strdup_printf("%s/%s%s",
256                 dirs[i], module_name, CONFIG_HOST_DSOSUF);
257         ret = module_load_file(fname, mayfail, export_symbols);
258         g_free(fname);
259         fname = NULL;
260         /* Try loading until loaded a module file */
261         if (!ret) {
262             success = true;
263             break;
264         }
265     }
267     if (!success) {
268         g_hash_table_remove(loaded_modules, module_name);
269         g_free(module_name);
270     }
272     for (i = 0; i < n_dirs; i++) {
273         g_free(dirs[i]);
274     }
276 #endif
277     return success;
281  * Building devices and other qom objects modular is mostly useful in
282  * case they have dependencies to external shared libraries, so we can
283  * cut down the core qemu library dependencies.  Which is the case for
284  * only a very few devices & objects.
286  * So with the expectation that this will be rather the exception than
287  * the rule and the list will not gain that many entries, go with a
288  * simple manually maintained list for now.
290  * The list must be sorted by module (module_load_qom_all() needs this).
291  */
292 static struct {
293     const char *type;
294     const char *prefix;
295     const char *module;
296 } const qom_modules[] = {
297     { "ccid-card-passthru",    "hw-", "usb-smartcard"         },
298     { "ccid-card-emulated",    "hw-", "usb-smartcard"         },
299     { "usb-redir",             "hw-", "usb-redirect"          },
300     { "qxl-vga",               "hw-", "display-qxl"           },
301     { "qxl",                   "hw-", "display-qxl"           },
302     { "virtio-gpu-device",     "hw-", "display-virtio-gpu"    },
303     { "vhost-user-gpu",        "hw-", "display-virtio-gpu"    },
304     { "virtio-gpu-pci-base",   "hw-", "display-virtio-gpu-pci" },
305     { "virtio-gpu-pci",        "hw-", "display-virtio-gpu-pci" },
306     { "vhost-user-gpu-pci",    "hw-", "display-virtio-gpu-pci" },
307     { "virtio-gpu-ccw",        "hw-", "s390x-virtio-gpu-ccw"   },
308     { "virtio-vga-base",       "hw-", "display-virtio-vga"    },
309     { "virtio-vga",            "hw-", "display-virtio-vga"    },
310     { "vhost-user-vga",        "hw-", "display-virtio-vga"    },
311     { "chardev-braille",       "chardev-", "baum"             },
312     { "chardev-spicevmc",      "chardev-", "spice"            },
313     { "chardev-spiceport",     "chardev-", "spice"            },
316 static bool module_loaded_qom_all;
318 void module_load_qom_one(const char *type)
320     int i;
322     if (!type) {
323         return;
324     }
325     for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
326         if (strcmp(qom_modules[i].type, type) == 0) {
327             module_load_one(qom_modules[i].prefix,
328                             qom_modules[i].module,
329                             false);
330             return;
331         }
332     }
335 void module_load_qom_all(void)
337     int i;
339     if (module_loaded_qom_all) {
340         return;
341     }
342     for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
343         if (i > 0 && (strcmp(qom_modules[i - 1].module,
344                              qom_modules[i].module) == 0 &&
345                       strcmp(qom_modules[i - 1].prefix,
346                              qom_modules[i].prefix) == 0)) {
347             /* one module implementing multiple types -> load only once */
348             continue;
349         }
350         module_load_one(qom_modules[i].prefix, qom_modules[i].module, true);
351     }
352     module_loaded_qom_all = true;