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) 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; 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 g_module = g_module_open(fname, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); 136 if (!g_module) { 137 if (!mayfail) { 138 fprintf(stderr, "Failed to open module: %s\n", 139 g_module_error()); 140 } 141 ret = -EINVAL; 142 goto out; 143 } 144 if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) { 145 fprintf(stderr, "Failed to initialize module: %s\n", 146 fname); 147 /* Print some info if this is a QEMU module (but from different build), 148 * this will make debugging user problems easier. */ 149 if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) { 150 fprintf(stderr, 151 "Note: only modules from the same build can be loaded.\n"); 152 } 153 g_module_close(g_module); 154 ret = -EINVAL; 155 } else { 156 QTAILQ_FOREACH(e, &dso_init_list, node) { 157 e->init(); 158 register_module_init(e->init, e->type); 159 } 160 ret = 0; 161 } 162 163 QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) { 164 QTAILQ_REMOVE(&dso_init_list, e, node); 165 g_free(e); 166 } 167 out: 168 return ret; 169 } 170 #endif 171 172 bool module_load_one(const char *prefix, const char *lib_name, bool mayfail) 173 { 174 bool success = false; 175 176 #ifdef CONFIG_MODULES 177 char *fname = NULL; 178 #ifdef CONFIG_MODULE_UPGRADES 179 char *version_dir; 180 #endif 181 const char *search_dir; 182 char *dirs[5]; 183 char *module_name; 184 int i = 0, n_dirs = 0; 185 int ret; 186 static GHashTable *loaded_modules; 187 188 if (!g_module_supported()) { 189 fprintf(stderr, "Module is not supported by system.\n"); 190 return false; 191 } 192 193 if (!loaded_modules) { 194 loaded_modules = g_hash_table_new(g_str_hash, g_str_equal); 195 } 196 197 module_name = g_strdup_printf("%s%s", prefix, lib_name); 198 199 if (!g_hash_table_add(loaded_modules, module_name)) { 200 g_free(module_name); 201 return true; 202 } 203 204 search_dir = getenv("QEMU_MODULE_DIR"); 205 if (search_dir != NULL) { 206 dirs[n_dirs++] = g_strdup_printf("%s", search_dir); 207 } 208 dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR); 209 dirs[n_dirs++] = g_strdup(qemu_get_exec_dir()); 210 211 #ifdef CONFIG_MODULE_UPGRADES 212 version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION), 213 G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~", 214 '_'); 215 dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir); 216 #endif 217 218 assert(n_dirs <= ARRAY_SIZE(dirs)); 219 220 for (i = 0; i < n_dirs; i++) { 221 fname = g_strdup_printf("%s/%s%s", 222 dirs[i], module_name, CONFIG_HOST_DSOSUF); 223 ret = module_load_file(fname, mayfail); 224 g_free(fname); 225 fname = NULL; 226 /* Try loading until loaded a module file */ 227 if (!ret) { 228 success = true; 229 break; 230 } 231 } 232 233 if (!success) { 234 g_hash_table_remove(loaded_modules, module_name); 235 g_free(module_name); 236 } 237 238 for (i = 0; i < n_dirs; i++) { 239 g_free(dirs[i]); 240 } 241 242 #endif 243 return success; 244 } 245 246 /* 247 * Building devices and other qom objects modular is mostly useful in 248 * case they have dependencies to external shared libraries, so we can 249 * cut down the core qemu library dependencies. Which is the case for 250 * only a very few devices & objects. 251 * 252 * So with the expectation that this will be rather the exception than 253 * the rule and the list will not gain that many entries, go with a 254 * simple manually maintained list for now. 255 * 256 * The list must be sorted by module (module_load_qom_all() needs this). 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 { "virtio-gpu-device", "hw-", "display-virtio-gpu" }, 269 { "vhost-user-gpu", "hw-", "display-virtio-gpu" }, 270 { "chardev-braille", "chardev-", "baum" }, 271 { "chardev-spicevmc", "chardev-", "spice" }, 272 { "chardev-spiceport", "chardev-", "spice" }, 273 }; 274 275 static bool module_loaded_qom_all; 276 277 void module_load_qom_one(const char *type) 278 { 279 int i; 280 281 if (!type) { 282 return; 283 } 284 for (i = 0; i < ARRAY_SIZE(qom_modules); i++) { 285 if (strcmp(qom_modules[i].type, type) == 0) { 286 module_load_one(qom_modules[i].prefix, 287 qom_modules[i].module, 288 false); 289 return; 290 } 291 } 292 } 293 294 void module_load_qom_all(void) 295 { 296 int i; 297 298 if (module_loaded_qom_all) { 299 return; 300 } 301 for (i = 0; i < ARRAY_SIZE(qom_modules); i++) { 302 if (i > 0 && (strcmp(qom_modules[i - 1].module, 303 qom_modules[i].module) == 0 && 304 strcmp(qom_modules[i - 1].prefix, 305 qom_modules[i].prefix) == 0)) { 306 /* one module implementing multiple types -> load only once */ 307 continue; 308 } 309 module_load_one(qom_modules[i].prefix, qom_modules[i].module, true); 310 } 311 module_loaded_qom_all = true; 312 } 313