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
 114 static const QemuModinfo module_info_stub[] = { {
 115     /* end of list */
 116 } };
 117 static const QemuModinfo *module_info = module_info_stub;
 118
 119 void module_init_info(const QemuModinfo *info)
 120 {
 121     module_info = info;
 122 }
 123
 124 static int module_load_file(const char *fname, bool mayfail, bool export_symbols)
 125 {
 126     GModule *g_module;
 127     void (*sym)(void);
 128     const char *dsosuf = CONFIG_HOST_DSOSUF;
 129     int len = strlen(fname);
 130     int suf_len = strlen(dsosuf);
 131     ModuleEntry *e, *next;
 132     int ret, flags;
 133
 134     if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {
 135         /* wrong suffix */
 136         ret = -EINVAL;
 137         goto out;
 138     }
 139     if (access(fname, F_OK)) {
 140         ret = -ENOENT;
 141         goto out;
 142     }
 143
 144     assert(QTAILQ_EMPTY(&dso_init_list));
 145
 146     flags = 0;
 147     if (!export_symbols) {
 148         flags |= G_MODULE_BIND_LOCAL;
 149     }
 150     g_module = g_module_open(fname, flags);
 151     if (!g_module) {
 152         if (!mayfail) {
 153             fprintf(stderr, "Failed to open module: %s\n",
 154                     g_module_error());
 155         }
 156         ret = -EINVAL;
 157         goto out;
 158     }
 159     if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {
 160         fprintf(stderr, "Failed to initialize module: %s\n",
 161                 fname);
 162         /* Print some info if this is a QEMU module (but from different build),
 163          * this will make debugging user problems easier. */
 164         if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {
 165             fprintf(stderr,
 166                     "Note: only modules from the same build can be loaded.\n");
 167         }
 168         g_module_close(g_module);
 169         ret = -EINVAL;
 170     } else {
 171         QTAILQ_FOREACH(e, &dso_init_list, node) {
 172             e->init();
 173             register_module_init(e->init, e->type);
 174         }
 175         ret = 0;
 176     }
 177
 178     QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {
 179         QTAILQ_REMOVE(&dso_init_list, e, node);
 180         g_free(e);
 181     }
 182 out:
 183     return ret;
 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;
 201     bool export_symbols = false;
 202     static GHashTable *loaded_modules;
 203     const QemuModinfo *modinfo;
 204     const char **sl;
 205
 206     if (!g_module_supported()) {
 207         fprintf(stderr, "Module is not supported by system.\n");
 208         return false;
 209     }
 210
 211     if (!loaded_modules) {
 212         loaded_modules = g_hash_table_new(g_str_hash, g_str_equal);
 213     }
 214
 215     module_name = g_strdup_printf("%s%s", prefix, lib_name);
 216
 217     if (g_hash_table_contains(loaded_modules, module_name)) {
 218         g_free(module_name);
 219         return true;
 220     }
 221     g_hash_table_add(loaded_modules, module_name);
 222
 223     for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
 224         if (modinfo->deps) {
 225             if (strcmp(modinfo->name, module_name) == 0) {
 226                 /* we depend on other module(s) */
 227                 for (sl = modinfo->deps; *sl != NULL; sl++) {
 228                     module_load_one("", *sl, false);
 229                 }
 230             } else {
 231                 for (sl = modinfo->deps; *sl != NULL; sl++) {
 232                     if (strcmp(module_name, *sl) == 0) {
 233                         /* another module depends on us */
 234                         export_symbols = true;
 235                     }
 236                 }
 237             }
 238         }
 239     }
 240
 241     search_dir = getenv("QEMU_MODULE_DIR");
 242     if (search_dir != NULL) {
 243         dirs[n_dirs++] = g_strdup_printf("%s", search_dir);
 244     }
 245     dirs[n_dirs++] = get_relocated_path(CONFIG_QEMU_MODDIR);
 246     dirs[n_dirs++] = g_strdup(qemu_get_exec_dir());
 247
 248 #ifdef CONFIG_MODULE_UPGRADES
 249     version_dir = g_strcanon(g_strdup(QEMU_PKGVERSION),
 250                              G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "+-.~",
 251                              '_');
 252     dirs[n_dirs++] = g_strdup_printf("/var/run/qemu/%s", version_dir);
 253 #endif
 254
 255     assert(n_dirs <= ARRAY_SIZE(dirs));
 256
 257     for (i = 0; i < n_dirs; i++) {
 258         fname = g_strdup_printf("%s/%s%s",
 259                 dirs[i], module_name, CONFIG_HOST_DSOSUF);
 260         ret = module_load_file(fname, mayfail, export_symbols);
 261         g_free(fname);
 262         fname = NULL;
 263         /* Try loading until loaded a module file */
 264         if (!ret) {
 265             success = true;
 266             break;
 267         }
 268     }
 269
 270     if (!success) {
 271         g_hash_table_remove(loaded_modules, module_name);
 272         g_free(module_name);
 273     }
 274
 275     for (i = 0; i < n_dirs; i++) {
 276         g_free(dirs[i]);
 277     }
 278
 279 #endif
 280     return success;
 281 }
 282
 283 #ifdef CONFIG_MODULES
 284
 285 static bool module_loaded_qom_all;
 286
 287 void module_load_qom_one(const char *type)
 288 {
 289     const QemuModinfo *modinfo;
 290     const char **sl;
 291
 292     if (!type) {
 293         return;
 294     }
 295
 296     for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
 297         if (!modinfo->objs) {
 298             continue;
 299         }
 300         for (sl = modinfo->objs; *sl != NULL; sl++) {
 301             if (strcmp(type, *sl) == 0) {
 302                 module_load_one("", modinfo->name, false);
 303             }
 304         }
 305     }
 306 }
 307
 308 void module_load_qom_all(void)
 309 {
 310     const QemuModinfo *modinfo;
 311
 312     if (module_loaded_qom_all) {
 313         return;
 314     }
 315
 316     for (modinfo = module_info; modinfo->name != NULL; modinfo++) {
 317         if (!modinfo->objs) {
 318             continue;
 319         }
 320         module_load_one("", modinfo->name, false);
 321     }
 322     module_loaded_qom_all = true;
 323 }
 324
 325 #else
 326
 327 void module_load_qom_one(const char *type) {}
 328 void module_load_qom_all(void) {}
 329
 330 #endif