xref: /qemu/util/module.c (revision a976a99a) 
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 
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         /* Try loading until loaded a module file */
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 
315 static bool module_loaded_qom_all;
316 
317 void 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 
342 void 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 
362 void 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 
381 void module_allow_arch(const char *arch) {}
382 void qemu_load_module_for_opts(const char *group) {}
383 void module_load_qom_one(const char *type) {}
384 void module_load_qom_all(void) {}
385 
386 #endif
387