1
2
3
4
5
6
7
8
9
10
11
12
13
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
29typedef struct ModuleEntry
30{
31 void (*init)(void);
32 QTAILQ_ENTRY(ModuleEntry) node;
33 module_init_type type;
34} ModuleEntry;
35
36typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
37
38static ModuleTypeList init_type_list[MODULE_INIT_MAX];
39static bool modules_init_done[MODULE_INIT_MAX];
40
41static ModuleTypeList dso_init_list;
42
43static 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
62static ModuleTypeList *find_type(module_init_type type)
63{
64 init_lists();
65
66 return &init_type_list[type];
67}
68
69void 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
83void 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
96void 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
116static const QemuModinfo module_info_stub[] = { {
117
118} };
119static const QemuModinfo *module_info = module_info_stub;
120static const char *module_arch;
121
122void module_init_info(const QemuModinfo *info)
123{
124 module_info = info;
125}
126
127void module_allow_arch(const char *arch)
128{
129 module_arch = arch;
130}
131
132static bool module_check_arch(const QemuModinfo *modinfo)
133{
134 if (modinfo->arch) {
135 if (!module_arch) {
136
137 return false;
138 }
139 if (strcmp(module_arch, modinfo->arch) != 0) {
140
141 return false;
142 }
143 }
144 return true;
145}
146
147static 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
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
186
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 }
206out:
207 return ret;
208}
209#endif
210
211bool 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
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
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
278#ifdef CONFIG_MODULE_UPGRADES
279 version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
280 G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
281 '_');
282 dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
283#endif
284
285 assert(n_dirs <= ARRAY_SIZE(dirs));
286
287 for (i = 0; i < n_dirs; i++) {
288 fname = g_strdup_printf("%s/%s%s",
289 dirs[i], module_name, CONFIG_HOST_DSOSUF);
290 ret = module_load_file(fname, mayfail, export_symbols);
291 g_free(fname);
292 fname = NULL;
293
294 if (!ret) {
295 success = true;
296 break;
297 }
298 }
299
300 if (!success) {
301 g_hash_table_remove(loaded_modules, module_name);
302 g_free(module_name);
303 }
304
305 for (i = 0; i < n_dirs; i++) {
306 g_free(dirs[i]);
307 }
308
309#endif
310 return success;
311}
312
313#ifdef CONFIG_MODULES
314
315static bool module_loaded_qom_all;
316
317void module_load_qom_one(const char *type)
318{
319 const QemuModinfo *modinfo;
320 const char **sl;
321
322 if (!type) {
323 return;
324 }
325
326 trace_module_lookup_object_type(type);
327 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
328 if (!modinfo->objs) {
329 continue;
330 }
331 if (!module_check_arch(modinfo)) {
332 continue;
333 }
334 for (sl = modinfo->objs; *sl != NULL; sl++) {
335 if (strcmp(type, *sl) == 0) {
336 module_load_one("", modinfo->name, false);
337 }
338 }
339 }
340}
341
342void module_load_qom_all(void)
343{
344 const QemuModinfo *modinfo;
345
346 if (module_loaded_qom_all) {
347 return;
348 }
349
350 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
351 if (!modinfo->objs) {
352 continue;
353 }
354 if (!module_check_arch(modinfo)) {
355 continue;
356 }
357 module_load_one("", modinfo->name, false);
358 }
359 module_loaded_qom_all = true;
360}
361
362void qemu_load_module_for_opts(const char *group)
363{
364 const QemuModinfo *modinfo;
365 const char **sl;
366
367 for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
368 if (!modinfo->opts) {
369 continue;
370 }
371 for (sl = modinfo->opts; *sl != NULL; sl++) {
372 if (strcmp(group, *sl) == 0) {
373 module_load_one("", modinfo->name, false);
374 }
375 }
376 }
377}
378
379#else
380
381void module_allow_arch(const char *arch) {}
382void qemu_load_module_for_opts(const char *group) {}
383void module_load_qom_one(const char *type) {}
384void module_load_qom_all(void) {}
385
386#endif
387