Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[qemu.git] / util / module.c
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 */
15
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 #include "qemu/config-file.h"
24 #ifdef CONFIG_MODULE_UPGRADES
25 #include "qemu-version.h"
26 #endif
27 #include "trace.h"
28
29 typedef struct ModuleEntry
30 {
31 void (*init)(void);
32 QTAILQ_ENTRY(ModuleEntry) node;
33 module_init_type type;
34 } ModuleEntry;
35
36 typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
37
38 static ModuleTypeList init_type_list[MODULE_INIT_MAX];
39 static bool modules_init_done[MODULE_INIT_MAX];
40
41 static ModuleTypeList dso_init_list;
42
43 static void init_lists(void)
44 {
45 static int inited;
46 int i;
47
48 if (inited) {
49 return;
50 }
51
52 for (i = 0; i < MODULE_INIT_MAX; i++) {
53 QTAILQ_INIT(&init_type_list[i]);
54 }
55
56 QTAILQ_INIT(&dso_init_list);
57
58 inited = 1;
59 }
60
61
62 static ModuleTypeList *find_type(module_init_type type)
63 {
64 init_lists();
65
66 return &init_type_list[type];
67 }
68
69 void register_module_init(void (*fn)(void), module_init_type type)
70 {
71 ModuleEntry *e;
72 ModuleTypeList *l;
73
74 e = g_malloc0(sizeof(*e));
75 e->init = fn;
76 e->type = type;
77
78 l = find_type(type);
79
80 QTAILQ_INSERT_TAIL(l, e, node);
81 }
82
83 void register_dso_module_init(void (*fn)(void), module_init_type type)
84 {
85 ModuleEntry *e;
86
87 init_lists();
88
89 e = g_malloc0(sizeof(*e));
90 e->init = fn;
91 e->type = type;
92
93 QTAILQ_INSERT_TAIL(&dso_init_list, e, node);
94 }
95
96 void module_call_init(module_init_type type)
97 {
98 ModuleTypeList *l;
99 ModuleEntry *e;
100
101 if (modules_init_done[type]) {
102 return;
103 }
104
105 l = find_type(type);
106
107 QTAILQ_FOREACH(e, l, node) {
108 e->init();
109 }
110
111 modules_init_done[type] = true;
112 }
113
114 #ifdef CONFIG_MODULES
115
116 static const QemuModinfo module_info_stub[] = { {
117 /* end of list */
118 } };
119 static const QemuModinfo *module_info = module_info_stub;
120 static const char *module_arch;
121
122 void module_init_info(const QemuModinfo *info)
123 {
124 module_info = info;
125 }
126
127 void module_allow_arch(const char *arch)
128 {
129 module_arch = arch;
130 }
131
132 static bool module_check_arch(const QemuModinfo *modinfo)
133 {
134 if (modinfo->arch) {
135 if (!module_arch) {
136 /* no arch set -> ignore all */
137 return false;
138 }
139 if (strcmp(module_arch, modinfo->arch) != 0) {
140 /* mismatch */
141 return false;
142 }
143 }
144 return true;
145 }
146
147 static int module_load_file(const char *fname, bool mayfail, bool export_symbols)
148 {
149 GModule *g_module;
150 void (*sym)(void);
151 const char *dsosuf = CONFIG_HOST_DSOSUF;
152 int len = strlen(fname);
153 int suf_len = strlen(dsosuf);
154 ModuleEntry *e, *next;
155 int ret, flags;
156
157 if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {
158 /* wrong suffix */
159 ret = -EINVAL;
160 goto out;
161 }
162 if (access(fname, F_OK)) {
163 ret = -ENOENT;
164 goto out;
165 }
166
167 assert(QTAILQ_EMPTY(&dso_init_list));
168
169 flags = 0;
170 if (!export_symbols) {
171 flags |= G_MODULE_BIND_LOCAL;
172 }
173 g_module = g_module_open(fname, flags);
174 if (!g_module) {
175 if (!mayfail) {
176 fprintf(stderr, "Failed to open module: %s\n",
177 g_module_error());
178 }
179 ret = -EINVAL;
180 goto out;
181 }
182 if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
183 fprintf(stderr, "Failed to initialize module: %s\n",
184 fname);
185 /* Print some info if this is a QEMU module (but from different build),
186 * this will make debugging user problems easier. */
187 if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {
188 fprintf(stderr,
189 "Note: only modules from the same build can be loaded.\n");
190 }
191 g_module_close(g_module);
192 ret = -EINVAL;
193 } else {
194 QTAILQ_FOREACH(e, &dso_init_list, node) {
195 e->init();
196 register_module_init(e->init, e->type);
197 }
198 ret = 0;
199 }
200
201 trace_module_load_module(fname);
202 QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
203 QTAILQ_REMOVE(&dso_init_list, e, node);
204 g_free(e);
205 }
206 out:
207 return ret;
208 }
209 #endif
210
211 bool module_load_one(const char *prefix, const char *lib_name, bool mayfail)
212 {
213 bool success = false;
214
215 #ifdef CONFIG_MODULES
216 char *fname = NULL;
217 #ifdef CONFIG_MODULE_UPGRADES
218 char *version_dir;
219 #endif
220 const char *search_dir;
221 char *dirs[5];
222 char *module_name;
223 int i = 0, n_dirs = 0;
224 int ret;
225 bool export_symbols = false;
226 static GHashTable *loaded_modules;
227 const QemuModinfo *modinfo;
228 const char **sl;
229
230 if (!g_module_supported()) {
231 fprintf(stderr, "Module is not supported by system.\n");
232 return false;
233 }
234
235 if (!loaded_modules) {
236 loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
237 }
238
239 module_name = g_strdup_printf("%s%s", prefix, lib_name);
240
241 if (g_hash_table_contains(loaded_modules, module_name)) {
242 g_free(module_name);
243 return true;
244 }
245 g_hash_table_add(loaded_modules, module_name);
246
247 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
248 if (modinfo->arch) {
249 if (strcmp(modinfo->name, module_name) == 0) {
250 if (!module_check_arch(modinfo)) {
251 return false;
252 }
253 }
254 }
255 if (modinfo->deps) {
256 if (strcmp(modinfo->name, module_name) == 0) {
257 /* we depend on other module(s) */
258 for (sl = modinfo->deps; *sl != NULL; sl++) {
259 module_load_one("", *sl, false);
260 }
261 } else {
262 for (sl = modinfo->deps; *sl != NULL; sl++) {
263 if (strcmp(module_name, *sl) == 0) {
264 /* another module depends on us */
265 export_symbols = true;
266 }
267 }
268 }
269 }
270 }
271
272 search_dir = getenv("QEMU_MODULE_DIR");
273 if (search_dir != NULL) {
274 dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
275 }
276 dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR);
277 dirs[n_dirs++] = g_strdup(qemu_get_exec_dir());
278
279 #ifdef CONFIG_MODULE_UPGRADES
280 version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
281 G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
282 '_');
283 dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
284 #endif
285
286 assert(n_dirs <= ARRAY_SIZE(dirs));
287
288 for (i = 0; i < n_dirs; i++) {
289 fname = g_strdup_printf("%s/%s%s",
290 dirs[i], module_name, CONFIG_HOST_DSOSUF);
291 ret = module_load_file(fname, mayfail, export_symbols);
292 g_free(fname);
293 fname = NULL;
294 /* Try loading until loaded a module file */
295 if (!ret) {
296 success = true;
297 break;
298 }
299 }
300
301 if (!success) {
302 g_hash_table_remove(loaded_modules, module_name);
303 g_free(module_name);
304 }
305
306 for (i = 0; i < n_dirs; i++) {
307 g_free(dirs[i]);
308 }
309
310 #endif
311 return success;
312 }
313
314 #ifdef CONFIG_MODULES
315
316 static bool module_loaded_qom_all;
317
318 void module_load_qom_one(const char *type)
319 {
320 const QemuModinfo *modinfo;
321 const char **sl;
322
323 if (!type) {
324 return;
325 }
326
327 trace_module_lookup_object_type(type);
328 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
329 if (!modinfo->objs) {
330 continue;
331 }
332 if (!module_check_arch(modinfo)) {
333 continue;
334 }
335 for (sl = modinfo->objs; *sl != NULL; sl++) {
336 if (strcmp(type, *sl) == 0) {
337 module_load_one("", modinfo->name, false);
338 }
339 }
340 }
341 }
342
343 void module_load_qom_all(void)
344 {
345 const QemuModinfo *modinfo;
346
347 if (module_loaded_qom_all) {
348 return;
349 }
350
351 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
352 if (!modinfo->objs) {
353 continue;
354 }
355 if (!module_check_arch(modinfo)) {
356 continue;
357 }
358 module_load_one("", modinfo->name, false);
359 }
360 module_loaded_qom_all = true;
361 }
362
363 void qemu_load_module_for_opts(const char *group)
364 {
365 const QemuModinfo *modinfo;
366 const char **sl;
367
368 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
369 if (!modinfo->opts) {
370 continue;
371 }
372 for (sl = modinfo->opts; *sl != NULL; sl++) {
373 if (strcmp(group, *sl) == 0) {
374 module_load_one("", modinfo->name, false);
375 }
376 }
377 }
378 }
379
380 #else
381
382 void module_allow_arch(const char *arch) {}
383 void qemu_load_module_for_opts(const char *group) {}
384 void module_load_qom_one(const char *type) {}
385 void module_load_qom_all(void) {}
386
387 #endif