xref: /qemu/util/module.c (revision b355f08a) 
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
388