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