module.c (10574B)
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 #include "qapi/error.h" 25 #ifdef CONFIG_MODULE_UPGRADES 26 #include "qemu-version.h" 27 #endif 28 #include "trace.h" 29 30 typedef struct ModuleEntry 31 { 32 void (*init)(void); 33 QTAILQ_ENTRY(ModuleEntry) node; 34 module_init_type type; 35 } ModuleEntry; 36 37 typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList; 38 39 static ModuleTypeList init_type_list[MODULE_INIT_MAX]; 40 static bool modules_init_done[MODULE_INIT_MAX]; 41 42 static ModuleTypeList dso_init_list; 43 44 static void init_lists(void) 45 { 46 static int inited; 47 int i; 48 49 if (inited) { 50 return; 51 } 52 53 for (i = 0; i < MODULE_INIT_MAX; i++) { 54 QTAILQ_INIT(&init_type_list[i]); 55 } 56 57 QTAILQ_INIT(&dso_init_list); 58 59 inited = 1; 60 } 61 62 63 static ModuleTypeList *find_type(module_init_type type) 64 { 65 init_lists(); 66 67 return &init_type_list[type]; 68 } 69 70 void register_module_init(void (*fn)(void), module_init_type type) 71 { 72 ModuleEntry *e; 73 ModuleTypeList *l; 74 75 e = g_malloc0(sizeof(*e)); 76 e->init = fn; 77 e->type = type; 78 79 l = find_type(type); 80 81 QTAILQ_INSERT_TAIL(l, e, node); 82 } 83 84 void register_dso_module_init(void (*fn)(void), module_init_type type) 85 { 86 ModuleEntry *e; 87 88 init_lists(); 89 90 e = g_malloc0(sizeof(*e)); 91 e->init = fn; 92 e->type = type; 93 94 QTAILQ_INSERT_TAIL(&dso_init_list, e, node); 95 } 96 97 void module_call_init(module_init_type type) 98 { 99 ModuleTypeList *l; 100 ModuleEntry *e; 101 102 if (modules_init_done[type]) { 103 return; 104 } 105 106 l = find_type(type); 107 108 QTAILQ_FOREACH(e, l, node) { 109 e->init(); 110 } 111 112 modules_init_done[type] = true; 113 } 114 115 #ifdef CONFIG_MODULES 116 117 static const QemuModinfo module_info_stub[] = { { 118 /* end of list */ 119 } }; 120 static const QemuModinfo *module_info = module_info_stub; 121 static const char *module_arch; 122 123 void module_init_info(const QemuModinfo *info) 124 { 125 module_info = info; 126 } 127 128 void module_allow_arch(const char *arch) 129 { 130 module_arch = arch; 131 } 132 133 static bool module_check_arch(const QemuModinfo *modinfo) 134 { 135 if (modinfo->arch) { 136 if (!module_arch) { 137 /* no arch set -> ignore all */ 138 return false; 139 } 140 if (strcmp(module_arch, modinfo->arch) != 0) { 141 /* mismatch */ 142 return false; 143 } 144 } 145 return true; 146 } 147 148 /* 149 * module_load_dso: attempt to load an existing dso file 150 * 151 * fname: full pathname of the file to load 152 * export_symbols: if true, add the symbols to the global name space 153 * errp: error to set. 154 * 155 * Return value: true on success, false on error, and errp will be set. 156 */ 157 static bool module_load_dso(const char *fname, bool export_symbols, 158 Error **errp) 159 { 160 GModule *g_module; 161 void (*sym)(void); 162 ModuleEntry *e, *next; 163 int flags; 164 165 assert(QTAILQ_EMPTY(&dso_init_list)); 166 167 flags = 0; 168 if (!export_symbols) { 169 flags |= G_MODULE_BIND_LOCAL; 170 } 171 g_module = g_module_open(fname, flags); 172 if (!g_module) { 173 error_setg(errp, "failed to open module: %s", g_module_error()); 174 return false; 175 } 176 if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) { 177 error_setg(errp, "failed to initialize module: %s", fname); 178 /* 179 * Print some info if this is a QEMU module (but from different build), 180 * this will make debugging user problems easier. 181 */ 182 if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) { 183 error_append_hint(errp, 184 "Only modules from the same build can be loaded.\n"); 185 } 186 g_module_close(g_module); 187 return false; 188 } 189 190 QTAILQ_FOREACH(e, &dso_init_list, node) { 191 e->init(); 192 register_module_init(e->init, e->type); 193 } 194 trace_module_load_module(fname); 195 QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) { 196 QTAILQ_REMOVE(&dso_init_list, e, node); 197 g_free(e); 198 } 199 return true; 200 } 201 202 int module_load(const char *prefix, const char *name, Error **errp) 203 { 204 int rv = -1; 205 #ifdef CONFIG_MODULE_UPGRADES 206 char *version_dir; 207 #endif 208 const char *search_dir; 209 char *dirs[5]; 210 char *module_name; 211 int i = 0, n_dirs = 0; 212 bool export_symbols = false; 213 static GHashTable *loaded_modules; 214 const QemuModinfo *modinfo; 215 const char **sl; 216 217 if (!g_module_supported()) { 218 error_setg(errp, "%s", "this platform does not support GLib modules"); 219 return -1; 220 } 221 222 if (!loaded_modules) { 223 loaded_modules = g_hash_table_new(g_str_hash, g_str_equal); 224 } 225 226 /* allocate all resources managed by the out: label here */ 227 module_name = g_strdup_printf("%s%s", prefix, name); 228 229 if (g_hash_table_contains(loaded_modules, module_name)) { 230 g_free(module_name); 231 return 2; /* module already loaded */ 232 } 233 g_hash_table_add(loaded_modules, module_name); 234 235 search_dir = getenv("QEMU_MODULE_DIR"); 236 if (search_dir != NULL) { 237 dirs[n_dirs++] = g_strdup_printf("%s", search_dir); 238 } 239 dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR); 240 241 #ifdef CONFIG_MODULE_UPGRADES 242 version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION), 243 G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~", 244 '_'); 245 dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir); 246 #endif 247 assert(n_dirs <= ARRAY_SIZE(dirs)); 248 249 /* end of resources managed by the out: label */ 250 251 for (modinfo = module_info; modinfo->name != NULL; modinfo++) { 252 if (modinfo->arch) { 253 if (strcmp(modinfo->name, module_name) == 0) { 254 if (!module_check_arch(modinfo)) { 255 error_setg(errp, "module arch does not match: " 256 "expected '%s', got '%s'", module_arch, modinfo->arch); 257 goto out; 258 } 259 } 260 } 261 if (modinfo->deps) { 262 if (strcmp(modinfo->name, module_name) == 0) { 263 /* we depend on other module(s) */ 264 for (sl = modinfo->deps; *sl != NULL; sl++) { 265 int subrv = module_load("", *sl, errp); 266 if (subrv <= 0) { 267 rv = subrv; 268 goto out; 269 } 270 } 271 } else { 272 for (sl = modinfo->deps; *sl != NULL; sl++) { 273 if (strcmp(module_name, *sl) == 0) { 274 /* another module depends on us */ 275 export_symbols = true; 276 } 277 } 278 } 279 } 280 } 281 282 for (i = 0; i < n_dirs; i++) { 283 char *fname = g_strdup_printf("%s/%s%s", 284 dirs[i], module_name, CONFIG_HOST_DSOSUF); 285 int ret = access(fname, F_OK); 286 if (ret != 0 && (errno == ENOENT || errno == ENOTDIR)) { 287 /* 288 * if we don't find the module in this dir, try the next one. 289 * If we don't find it in any dir, that can be fine too: user 290 * did not install the module. We will return 0 in this case 291 * with no error set. 292 */ 293 g_free(fname); 294 continue; 295 } else if (ret != 0) { 296 /* most common is EACCES here */ 297 error_setg_errno(errp, errno, "error trying to access %s", fname); 298 } else if (module_load_dso(fname, export_symbols, errp)) { 299 rv = 1; /* module successfully loaded */ 300 } 301 g_free(fname); 302 goto out; 303 } 304 rv = 0; /* module not found */ 305 306 out: 307 if (rv <= 0) { 308 g_hash_table_remove(loaded_modules, module_name); 309 g_free(module_name); 310 } 311 for (i = 0; i < n_dirs; i++) { 312 g_free(dirs[i]); 313 } 314 return rv; 315 } 316 317 static bool module_loaded_qom_all; 318 319 int module_load_qom(const char *type, Error **errp) 320 { 321 const QemuModinfo *modinfo; 322 const char **sl; 323 int rv = 0; 324 325 if (!type) { 326 error_setg(errp, "%s", "type is NULL"); 327 return -1; 328 } 329 330 trace_module_lookup_object_type(type); 331 for (modinfo = module_info; modinfo->name != NULL; modinfo++) { 332 if (!modinfo->objs) { 333 continue; 334 } 335 if (!module_check_arch(modinfo)) { 336 continue; 337 } 338 for (sl = modinfo->objs; *sl != NULL; sl++) { 339 if (strcmp(type, *sl) == 0) { 340 if (rv > 0) { 341 error_setg(errp, "multiple modules providing '%s'", type); 342 return -1; 343 } 344 rv = module_load("", modinfo->name, errp); 345 if (rv < 0) { 346 return rv; 347 } 348 } 349 } 350 } 351 return rv; 352 } 353 354 void module_load_qom_all(void) 355 { 356 const QemuModinfo *modinfo; 357 Error *local_err = NULL; 358 359 if (module_loaded_qom_all) { 360 return; 361 } 362 363 for (modinfo = module_info; modinfo->name != NULL; modinfo++) { 364 if (!modinfo->objs) { 365 continue; 366 } 367 if (!module_check_arch(modinfo)) { 368 continue; 369 } 370 if (module_load("", modinfo->name, &local_err) < 0) { 371 error_report_err(local_err); 372 } 373 } 374 module_loaded_qom_all = true; 375 } 376 377 void qemu_load_module_for_opts(const char *group) 378 { 379 const QemuModinfo *modinfo; 380 const char **sl; 381 382 for (modinfo = module_info; modinfo->name != NULL; modinfo++) { 383 if (!modinfo->opts) { 384 continue; 385 } 386 for (sl = modinfo->opts; *sl != NULL; sl++) { 387 if (strcmp(group, *sl) == 0) { 388 Error *local_err = NULL; 389 if (module_load("", modinfo->name, &local_err) < 0) { 390 error_report_err(local_err); 391 } 392 } 393 } 394 } 395 } 396 397 #else 398 399 void module_allow_arch(const char *arch) {} 400 void qemu_load_module_for_opts(const char *group) {} 401 int module_load(const char *prefix, const char *name, Error **errp) { return 2; } 402 int module_load_qom(const char *type, Error **errp) { return 2; } 403 void module_load_qom_all(void) {} 404 405 #endif