@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
h 192 lines 5.64 KB
Raw
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_TARGET_INFO,
47 MODULE_INIT_QOM,
48 MODULE_INIT_TRACE,
49 MODULE_INIT_XEN_BACKEND,
50 MODULE_INIT_LIBQOS,
51 MODULE_INIT_FUZZ_TARGET,
52 MODULE_INIT_MAX
53 } module_init_type;
54
55 #define block_init(function) module_init(function, MODULE_INIT_BLOCK)
56 #define opts_init(function) module_init(function, MODULE_INIT_OPTS)
57 #define type_init(function) module_init(function, MODULE_INIT_QOM)
58 #define trace_init(function) module_init(function, MODULE_INIT_TRACE)
59 #define xen_backend_init(function) module_init(function, \
60 MODULE_INIT_XEN_BACKEND)
61 #define libqos_init(function) module_init(function, MODULE_INIT_LIBQOS)
62 #define fuzz_target_init(function) module_init(function, \
63 MODULE_INIT_FUZZ_TARGET)
64 #define migration_init(function) module_init(function, MODULE_INIT_MIGRATION)
65 #define block_module_load(lib, errp) module_load("block-", lib, errp)
66 #define ui_module_load(lib, errp) module_load("ui-", 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 ("ui-", ..., "")
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