xref: /openbmc/qemu/util/module.c (revision 67abc3dd)
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 #ifdef CONFIG_MODULE_UPGRADES
23 #include "qemu-version.h"
24 #endif
25 
26 typedef struct ModuleEntry
27 {
28     void (*init)(void);
29     QTAILQ_ENTRY(ModuleEntry) node;
30     module_init_type type;
31 } ModuleEntry;
32 
33 typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
34 
35 static ModuleTypeList init_type_list[MODULE_INIT_MAX];
36 static bool modules_init_done[MODULE_INIT_MAX];
37 
38 static ModuleTypeList dso_init_list;
39 
40 static void init_lists(void)
41 {
42     static int inited;
43     int i;
44 
45     if (inited) {
46         return;
47     }
48 
49     for (i = 0; i < MODULE_INIT_MAX; i++) {
50         QTAILQ_INIT(&init_type_list[i]);
51     }
52 
53     QTAILQ_INIT(&dso_init_list);
54 
55     inited = 1;
56 }
57 
58 
59 static ModuleTypeList *find_type(module_init_type type)
60 {
61     init_lists();
62 
63     return &init_type_list[type];
64 }
65 
66 void register_module_init(void (*fn)(void), module_init_type type)
67 {
68     ModuleEntry *e;
69     ModuleTypeList *l;
70 
71     e = g_malloc0(sizeof(*e));
72     e->init = fn;
73     e->type = type;
74 
75     l = find_type(type);
76 
77     QTAILQ_INSERT_TAIL(l, e, node);
78 }
79 
80 void register_dso_module_init(void (*fn)(void), module_init_type type)
81 {
82     ModuleEntry *e;
83 
84     init_lists();
85 
86     e = g_malloc0(sizeof(*e));
87     e->init = fn;
88     e->type = type;
89 
90     QTAILQ_INSERT_TAIL(&dso_init_list, e, node);
91 }
92 
93 void module_call_init(module_init_type type)
94 {
95     ModuleTypeList *l;
96     ModuleEntry *e;
97 
98     if (modules_init_done[type]) {
99         return;
100     }
101 
102     l = find_type(type);
103 
104     QTAILQ_FOREACH(e, l, node) {
105         e->init();
106     }
107 
108     modules_init_done[type] = true;
109 }
110 
111 #ifdef CONFIG_MODULES
112 static int module_load_file(const char *fname)
113 {
114     GModule *g_module;
115     void (*sym)(void);
116     const char *dsosuf = CONFIG_HOST_DSOSUF;
117     int len = strlen(fname);
118     int suf_len = strlen(dsosuf);
119     ModuleEntry *e, *next;
120     int ret;
121 
122     if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {
123         /* wrong suffix */
124         ret = -EINVAL;
125         goto out;
126     }
127     if (access(fname, F_OK)) {
128         ret = -ENOENT;
129         goto out;
130     }
131 
132     assert(QTAILQ_EMPTY(&dso_init_list));
133 
134     g_module = g_module_open(fname, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
135     if (!g_module) {
136         fprintf(stderr, "Failed to open module: %s\n",
137                 g_module_error());
138         ret = -EINVAL;
139         goto out;
140     }
141     if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
142         fprintf(stderr, "Failed to initialize module: %s\n",
143                 fname);
144         /* Print some info if this is a QEMU module (but from different build),
145          * this will make debugging user problems easier. */
146         if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {
147             fprintf(stderr,
148                     "Note: only modules from the same build can be loaded.\n");
149         }
150         g_module_close(g_module);
151         ret = -EINVAL;
152     } else {
153         QTAILQ_FOREACH(e, &dso_init_list, node) {
154             e->init();
155             register_module_init(e->init, e->type);
156         }
157         ret = 0;
158     }
159 
160     QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
161         QTAILQ_REMOVE(&dso_init_list, e, node);
162         g_free(e);
163     }
164 out:
165     return ret;
166 }
167 #endif
168 
169 bool module_load_one(const char *prefix, const char *lib_name)
170 {
171     bool success = false;
172 
173 #ifdef CONFIG_MODULES
174     char *fname = NULL;
175     char *exec_dir;
176 #ifdef CONFIG_MODULE_UPGRADES
177     char *version_dir;
178 #endif
179     const char *search_dir;
180     char *dirs[5];
181     char *module_name;
182     int i = 0, n_dirs = 0;
183     int ret;
184     static GHashTable *loaded_modules;
185 
186     if (!g_module_supported()) {
187         fprintf(stderr, "Module is not supported by system.\n");
188         return false;
189     }
190 
191     if (!loaded_modules) {
192         loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
193     }
194 
195     module_name = g_strdup_printf("%s%s", prefix, lib_name);
196 
197     if (!g_hash_table_add(loaded_modules, module_name)) {
198         g_free(module_name);
199         return true;
200     }
201 
202     exec_dir = qemu_get_exec_dir();
203     search_dir = getenv("QEMU_MODULE_DIR");
204     if (search_dir != NULL) {
205         dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
206     }
207     dirs[n_dirs++] = g_strdup_printf("%s", CONFIG_QEMU_MODDIR);
208     dirs[n_dirs++] = g_strdup_printf("%s", exec_dir ? : "");
209 
210 #ifdef CONFIG_MODULE_UPGRADES
211     version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
212                              G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
213                              '_');
214     dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
215 #endif
216 
217     assert(n_dirs <= ARRAY_SIZE(dirs));
218 
219     g_free(exec_dir);
220     exec_dir = NULL;
221 
222     for (i = 0; i < n_dirs; i++) {
223         fname = g_strdup_printf("%s/%s%s",
224                 dirs[i], module_name, CONFIG_HOST_DSOSUF);
225         ret = module_load_file(fname);
226         g_free(fname);
227         fname = NULL;
228         /* Try loading until loaded a module file */
229         if (!ret) {
230             success = true;
231             break;
232         }
233     }
234 
235     if (!success) {
236         g_hash_table_remove(loaded_modules, module_name);
237         g_free(module_name);
238     }
239 
240     for (i = 0; i < n_dirs; i++) {
241         g_free(dirs[i]);
242     }
243 
244 #endif
245     return success;
246 }
247 
248 /*
249  * Building devices and other qom objects modular is mostly useful in
250  * case they have dependencies to external shared libraries, so we can
251  * cut down the core qemu library dependencies.  Which is the case for
252  * only a very few devices & objects.
253  *
254  * So with the expectation that this will be rather the exception than
255  * to rule and the list will not gain that many entries go with a
256  * simple manually maintained list for now.
257  */
258 static struct {
259     const char *type;
260     const char *prefix;
261     const char *module;
262 } const qom_modules[] = {
263     { "ccid-card-passthru",    "hw-", "usb-smartcard"         },
264     { "ccid-card-emulated",    "hw-", "usb-smartcard"         },
265     { "usb-redir",             "hw-", "usb-redirect"          },
266     { "qxl-vga",               "hw-", "display-qxl"           },
267     { "qxl",                   "hw-", "display-qxl"           },
268     { "chardev-braille",       "chardev-", "baum"             },
269 };
270 
271 static bool module_loaded_qom_all;
272 
273 void module_load_qom_one(const char *type)
274 {
275     int i;
276 
277     if (!type) {
278         return;
279     }
280     if (module_loaded_qom_all) {
281         return;
282     }
283     for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
284         if (strcmp(qom_modules[i].type, type) == 0) {
285             module_load_one(qom_modules[i].prefix,
286                             qom_modules[i].module);
287             return;
288         }
289     }
290 }
291 
292 void module_load_qom_all(void)
293 {
294     int i;
295 
296     if (module_loaded_qom_all) {
297         return;
298     }
299     for (i = 0; i < ARRAY_SIZE(qom_modules); i++) {
300         if (i > 0 && (strcmp(qom_modules[i - 1].module,
301                              qom_modules[i].module) == 0 &&
302                       strcmp(qom_modules[i - 1].prefix,
303                              qom_modules[i].prefix) == 0)) {
304             /* one module implementing multiple types -> load only once */
305             continue;
306         }
307         module_load_one(qom_modules[i].prefix, qom_modules[i].module);
308     }
309     module_loaded_qom_all = true;
310 }
311