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 */ 13 14 #ifndef QEMU_MODULE_H 15 #define QEMU_MODULE_H 16 17 18 #define DSO_STAMP_FUN glue(qemu_stamp, CONFIG_STAMP) 19 #define DSO_STAMP_FUN_STR stringify(DSO_STAMP_FUN) 20 21 #ifdef BUILD_DSO 22 void DSO_STAMP_FUN(void); 23 /* This is a dummy symbol to identify a loaded DSO as a QEMU module, so we can 24 * distinguish "version mismatch" from "not a QEMU module", when the stamp 25 * check fails during module loading */ 26 void qemu_module_dummy(void); 27 28 #define module_init(function, type) \ 29 static void __attribute__((constructor)) do_qemu_init_ ## function(void) \ 30 { \ 31 register_dso_module_init(function, type); \ 32 } 33 #else 34 /* This should not be used directly. Use block_init etc. instead. */ 35 #define module_init(function, type) \ 36 static void __attribute__((constructor)) do_qemu_init_ ## function(void) \ 37 { \ 38 register_module_init(function, type); \ 39 } 40 #endif 41 42 typedef enum { 43 MODULE_INIT_MIGRATION, 44 MODULE_INIT_BLOCK, 45 MODULE_INIT_OPTS, 46 MODULE_INIT_QOM, 47 MODULE_INIT_TRACE, 48 MODULE_INIT_XEN_BACKEND, 49 MODULE_INIT_LIBQOS, 50 MODULE_INIT_FUZZ_TARGET, 51 MODULE_INIT_MAX 52 } module_init_type; 53 54 #define block_init(function) module_init(function, MODULE_INIT_BLOCK) 55 #define opts_init(function) module_init(function, MODULE_INIT_OPTS) 56 #define type_init(function) module_init(function, MODULE_INIT_QOM) 57 #define trace_init(function) module_init(function, MODULE_INIT_TRACE) 58 #define xen_backend_init(function) module_init(function, \ 59 MODULE_INIT_XEN_BACKEND) 60 #define libqos_init(function) module_init(function, MODULE_INIT_LIBQOS) 61 #define fuzz_target_init(function) module_init(function, \ 62 MODULE_INIT_FUZZ_TARGET) 63 #define migration_init(function) module_init(function, MODULE_INIT_MIGRATION) 64 #define block_module_load(lib, errp) module_load("block-", lib, errp) 65 #define ui_module_load(lib, errp) module_load("ui-", lib, errp) 66 #define audio_module_load(lib, errp) module_load("audio-", lib, errp) 67 68 void register_module_init(void (*fn)(void), module_init_type type); 69 void register_dso_module_init(void (*fn)(void), module_init_type type); 70 71 void module_call_init(module_init_type type); 72 73 /* 74 * module_load: attempt to load a module from a set of directories 75 * 76 * directories searched are: 77 * - getenv("QEMU_MODULE_DIR") 78 * - get_relocated_path(CONFIG_QEMU_MODDIR); 79 * - /var/run/qemu/${version_dir} 80 * 81 * prefix: a subsystem prefix, or the empty string ("audio-", ..., "") 82 * name: name of the module 83 * errp: error to set in case the module is found, but load failed. 84 * 85 * Return value: -1 on error (errp set if not NULL). 86 * 0 if module or one of its dependencies are not installed, 87 * 1 if the module is found and loaded, 88 * 2 if the module is already loaded, or module is built-in. 89 */ 90 int module_load(const char *prefix, const char *name, Error **errp); 91 92 /* 93 * module_load_qom: attempt to load a module to provide a QOM type 94 * 95 * type: the type to be provided 96 * errp: error to set. 97 * 98 * Return value: as per module_load. 99 */ 100 int module_load_qom(const char *type, Error **errp); 101 void module_load_qom_all(void); 102 void module_allow_arch(const char *arch); 103 104 /** 105 * DOC: module info annotation macros 106 * 107 * ``scripts/modinfo-collect.py`` will collect module info, 108 * using the preprocessor and -DQEMU_MODINFO. 109 * 110 * ``scripts/modinfo-generate.py`` will create a module meta-data database 111 * from the collected information so qemu knows about module 112 * dependencies and QOM objects implemented by modules. 113 * 114 * See ``*.modinfo`` and ``modinfo.c`` in the build directory to check the 115 * script results. 116 */ 117 #ifdef QEMU_MODINFO 118 # define modinfo(kind, value) \ 119 MODINFO_START kind value MODINFO_END 120 #else 121 # define modinfo(kind, value) 122 #endif 123 124 /** 125 * module_obj 126 * 127 * @name: QOM type. 128 * 129 * This module implements QOM type @name. 130 */ 131 #define module_obj(name) modinfo(obj, name) 132 133 /** 134 * module_dep 135 * 136 * @name: module name 137 * 138 * This module depends on module @name. 139 */ 140 #define module_dep(name) modinfo(dep, name) 141 142 /** 143 * module_arch 144 * 145 * @name: target architecture 146 * 147 * This module is for target architecture @arch. 148 * 149 * Note that target-dependent modules are tagged automatically, so 150 * this is only needed in case target-independent modules should be 151 * restricted. Use case example: the ccw bus is implemented by s390x 152 * only. 153 */ 154 #define module_arch(name) modinfo(arch, name) 155 156 /** 157 * module_opts 158 * 159 * @name: QemuOpts name 160 * 161 * This module registers QemuOpts @name. 162 */ 163 #define module_opts(name) modinfo(opts, name) 164 165 /** 166 * module_kconfig 167 * 168 * @name: Kconfig requirement necessary to load the module 169 * 170 * This module requires a core module that should be implemented and 171 * enabled in Kconfig. 172 */ 173 #define module_kconfig(name) modinfo(kconfig, name) 174 175 /* 176 * module info database 177 * 178 * scripts/modinfo-generate.c will build this using the data collected 179 * by scripts/modinfo-collect.py 180 */ 181 typedef struct QemuModinfo QemuModinfo; 182 struct QemuModinfo { 183 const char *name; 184 const char *arch; 185 const char **objs; 186 const char **deps; 187 const char **opts; 188 }; 189 extern const QemuModinfo qemu_modinfo[]; 190 void module_init_info(const QemuModinfo *info); 191 192 #endif 193