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 #ifdef CONFIG_OPENGL 186 { "ui-egl-headless", "ui-opengl" }, 187 { "ui-gtk", "ui-opengl" }, 188 { "ui-sdl", "ui-opengl" }, 189 { "ui-spice-core", "ui-opengl" }, 190 #endif 191 }; 192 #endif 193 194 bool module_load_one(const char *prefix, const char *lib_name, bool mayfail) 195 { 196 bool success = false; 197 198 #ifdef CONFIG_MODULES 199 char *fname = NULL; 200 #ifdef CONFIG_MODULE_UPGRADES 201 char *version_dir; 202 #endif 203 const char *search_dir; 204 char *dirs[5]; 205 char *module_name; 206 int i = 0, n_dirs = 0; 207 int ret, dep; 208 bool export_symbols = false; 209 static GHashTable *loaded_modules; 210 211 if (!g_module_supported()) { 212 fprintf(stderr, "Module is not supported by system.\n"); 213 return false; 214 } 215 216 if (!loaded_modules) { 217 loaded_modules = g_hash_table_new(g_str_hash, g_str_equal); 218 } 219 220 module_name = g_strdup_printf("%s%s", prefix, lib_name); 221 222 for (dep = 0; dep < ARRAY_SIZE(module_deps); dep++) { 223 if (strcmp(module_name, module_deps[dep].name) == 0) { 224 /* we depend on another module */ 225 module_load_one("", module_deps[dep].dep, false); 226 } 227 if (strcmp(module_name, module_deps[dep].dep) == 0) { 228 /* another module depends on us */ 229 export_symbols = true; 230 } 231 } 232 233 if (!g_hash_table_add(loaded_modules, module_name)) { 234 g_free(module_name); 235 return true; 236 } 237 238 search_dir = getenv("QEMU_MODULE_DIR"); 239 if (search_dir != NULL) { 240 dirs[n_dirs++] = g_strdup_printf("%s", search_dir); 241 } 242 dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR); 243 dirs[n_dirs++] = g_strdup(qemu_get_exec_dir()); 244 245 #ifdef CONFIG_MODULE_UPGRADES 246 version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION), 247 G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~", 248 '_'); 249 dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir); 250 #endif 251 252 assert(n_dirs <= ARRAY_SIZE(dirs)); 253 254 for (i = 0; i < n_dirs; i++) { 255 fname = g_strdup_printf("%s/%s%s", 256 dirs[i], module_name, CONFIG_HOST_DSOSUF); 257 ret = module_load_file(fname, mayfail, export_symbols); 258 g_free(fname); 259 fname = NULL; 260 /* Try loading until loaded a module file */ 261 if (!ret) { 262 success = true; 263 break; 264 } 265 } 266 267 if (!success) { 268 g_hash_table_remove(loaded_modules, module_name); 269 g_free(module_name); 270 } 271 272 for (i = 0; i < n_dirs; i++) { 273 g_free(dirs[i]); 274 } 275 276 #endif 277 return success; 278 } 279 280 /* 281 * Building devices and other qom objects modular is mostly useful in 282 * case they have dependencies to external shared libraries, so we can 283 * cut down the core qemu library dependencies. Which is the case for 284 * only a very few devices & objects. 285 * 286 * So with the expectation that this will be rather the exception than 287 * the rule and the list will not gain that many entries, go with a 288 * simple manually maintained list for now. 289 * 290 * The list must be sorted by module (module_load_qom_all() needs this). 291 */ 292 static struct { 293 const char *type; 294 const char *prefix; 295 const char *module; 296 } const qom_modules[] = { 297 { "ccid-card-passthru", "hw-", "usb-smartcard" }, 298 { "ccid-card-emulated", "hw-", "usb-smartcard" }, 299 { "usb-redir", "hw-", "usb-redirect" }, 300 { "qxl-vga", "hw-", "display-qxl" }, 301 { "qxl", "hw-", "display-qxl" }, 302 { "virtio-gpu-device", "hw-", "display-virtio-gpu" }, 303 { "vhost-user-gpu", "hw-", "display-virtio-gpu" }, 304 { "chardev-braille", "chardev-", "baum" }, 305 { "chardev-spicevmc", "chardev-", "spice" }, 306 { "chardev-spiceport", "chardev-", "spice" }, 307 }; 308 309 static bool module_loaded_qom_all; 310 311 void module_load_qom_one(const char *type) 312 { 313 int i; 314 315 if (!type) { 316 return; 317 } 318 for (i = 0; i < ARRAY_SIZE(qom_modules); i++) { 319 if (strcmp(qom_modules[i].type, type) == 0) { 320 module_load_one(qom_modules[i].prefix, 321 qom_modules[i].module, 322 false); 323 return; 324 } 325 } 326 } 327 328 void module_load_qom_all(void) 329 { 330 int i; 331 332 if (module_loaded_qom_all) { 333 return; 334 } 335 for (i = 0; i < ARRAY_SIZE(qom_modules); i++) { 336 if (i > 0 && (strcmp(qom_modules[i - 1].module, 337 qom_modules[i].module) == 0 && 338 strcmp(qom_modules[i - 1].prefix, 339 qom_modules[i].prefix) == 0)) { 340 /* one module implementing multiple types -> load only once */ 341 continue; 342 } 343 module_load_one(qom_modules[i].prefix, qom_modules[i].module, true); 344 } 345 module_loaded_qom_all = true; 346 } 347