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