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