1 /*
2 * Copyright (C) 2017, Emilio G. Cota <cota@braap.org>
3 *
4 * License: GNU GPL, version 2 or later.
5 * See the COPYING file in the top-level directory.
6 */
7 #ifndef QEMU_PLUGIN_H
8 #define QEMU_PLUGIN_H
9
10 #include "qemu/config-file.h"
11 #include "qemu/qemu-plugin.h"
12 #include "qemu/error-report.h"
13 #include "qemu/queue.h"
14 #include "qemu/option.h"
15 #include "exec/memopidx.h"
16
17 /*
18 * Events that plugins can subscribe to.
19 */
20 enum qemu_plugin_event {
21 QEMU_PLUGIN_EV_VCPU_INIT,
22 QEMU_PLUGIN_EV_VCPU_EXIT,
23 QEMU_PLUGIN_EV_VCPU_TB_TRANS,
24 QEMU_PLUGIN_EV_VCPU_IDLE,
25 QEMU_PLUGIN_EV_VCPU_RESUME,
26 QEMU_PLUGIN_EV_VCPU_SYSCALL,
27 QEMU_PLUGIN_EV_VCPU_SYSCALL_RET,
28 QEMU_PLUGIN_EV_FLUSH,
29 QEMU_PLUGIN_EV_ATEXIT,
30 QEMU_PLUGIN_EV_MAX, /* total number of plugin events we support */
31 };
32
33 /*
34 * Option parsing/processing.
35 * Note that we can load an arbitrary number of plugins.
36 */
37 struct qemu_plugin_desc;
38 typedef QTAILQ_HEAD(, qemu_plugin_desc) QemuPluginList;
39
40 /*
41 * Construct a qemu_plugin_meminfo_t.
42 */
43 static inline qemu_plugin_meminfo_t
make_plugin_meminfo(MemOpIdx oi,enum qemu_plugin_mem_rw rw)44 make_plugin_meminfo(MemOpIdx oi, enum qemu_plugin_mem_rw rw)
45 {
46 return oi | (rw << 16);
47 }
48
49 /*
50 * Extract the memory operation direction from a qemu_plugin_meminfo_t.
51 * Other portions may be extracted via get_memop and get_mmuidx.
52 */
53 static inline enum qemu_plugin_mem_rw
get_plugin_meminfo_rw(qemu_plugin_meminfo_t i)54 get_plugin_meminfo_rw(qemu_plugin_meminfo_t i)
55 {
56 return i >> 16;
57 }
58
59 #ifdef CONFIG_PLUGIN
60 extern QemuOptsList qemu_plugin_opts;
61
qemu_plugin_add_opts(void)62 static inline void qemu_plugin_add_opts(void)
63 {
64 qemu_add_opts(&qemu_plugin_opts);
65 }
66
67 void qemu_plugin_opt_parse(const char *optarg, QemuPluginList *head);
68 int qemu_plugin_load_list(QemuPluginList *head, Error **errp);
69
70 union qemu_plugin_cb_sig {
71 qemu_plugin_simple_cb_t simple;
72 qemu_plugin_udata_cb_t udata;
73 qemu_plugin_vcpu_simple_cb_t vcpu_simple;
74 qemu_plugin_vcpu_udata_cb_t vcpu_udata;
75 qemu_plugin_vcpu_tb_trans_cb_t vcpu_tb_trans;
76 qemu_plugin_vcpu_mem_cb_t vcpu_mem;
77 qemu_plugin_vcpu_syscall_cb_t vcpu_syscall;
78 qemu_plugin_vcpu_syscall_ret_cb_t vcpu_syscall_ret;
79 void *generic;
80 };
81
82 enum plugin_dyn_cb_type {
83 PLUGIN_CB_INSN,
84 PLUGIN_CB_MEM,
85 PLUGIN_N_CB_TYPES,
86 };
87
88 enum plugin_dyn_cb_subtype {
89 PLUGIN_CB_REGULAR,
90 PLUGIN_CB_INLINE,
91 PLUGIN_N_CB_SUBTYPES,
92 };
93
94 /*
95 * A dynamic callback has an insertion point that is determined at run-time.
96 * Usually the insertion point is somewhere in the code cache; think for
97 * instance of a callback to be called upon the execution of a particular TB.
98 */
99 struct qemu_plugin_dyn_cb {
100 union qemu_plugin_cb_sig f;
101 void *userp;
102 enum plugin_dyn_cb_subtype type;
103 /* @rw applies to mem callbacks only (both regular and inline) */
104 enum qemu_plugin_mem_rw rw;
105 /* fields specific to each dyn_cb type go here */
106 union {
107 struct {
108 enum qemu_plugin_op op;
109 uint64_t imm;
110 } inline_insn;
111 };
112 };
113
114 /* Internal context for instrumenting an instruction */
115 struct qemu_plugin_insn {
116 GByteArray *data;
117 uint64_t vaddr;
118 void *haddr;
119 GArray *cbs[PLUGIN_N_CB_TYPES][PLUGIN_N_CB_SUBTYPES];
120 bool calls_helpers;
121 bool mem_helper;
122 bool mem_only;
123 };
124
125 /*
126 * qemu_plugin_insn allocate and cleanup functions. We don't expect to
127 * cleanup many of these structures. They are reused for each fresh
128 * translation.
129 */
130
qemu_plugin_insn_cleanup_fn(gpointer data)131 static inline void qemu_plugin_insn_cleanup_fn(gpointer data)
132 {
133 struct qemu_plugin_insn *insn = (struct qemu_plugin_insn *) data;
134 g_byte_array_free(insn->data, true);
135 }
136
qemu_plugin_insn_alloc(void)137 static inline struct qemu_plugin_insn *qemu_plugin_insn_alloc(void)
138 {
139 int i, j;
140 struct qemu_plugin_insn *insn = g_new0(struct qemu_plugin_insn, 1);
141 insn->data = g_byte_array_sized_new(4);
142
143 for (i = 0; i < PLUGIN_N_CB_TYPES; i++) {
144 for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) {
145 insn->cbs[i][j] = g_array_new(false, false,
146 sizeof(struct qemu_plugin_dyn_cb));
147 }
148 }
149 return insn;
150 }
151
152 /* Internal context for this TranslationBlock */
153 struct qemu_plugin_tb {
154 GPtrArray *insns;
155 size_t n;
156 uint64_t vaddr;
157 uint64_t vaddr2;
158 void *haddr1;
159 void *haddr2;
160 bool mem_only;
161 GArray *cbs[PLUGIN_N_CB_SUBTYPES];
162 };
163
164 /**
165 * qemu_plugin_tb_insn_get(): get next plugin record for translation.
166 * @tb: the internal tb context
167 * @pc: address of instruction
168 */
169 static inline
qemu_plugin_tb_insn_get(struct qemu_plugin_tb * tb,uint64_t pc)170 struct qemu_plugin_insn *qemu_plugin_tb_insn_get(struct qemu_plugin_tb *tb,
171 uint64_t pc)
172 {
173 struct qemu_plugin_insn *insn;
174 int i, j;
175
176 if (unlikely(tb->n == tb->insns->len)) {
177 struct qemu_plugin_insn *new_insn = qemu_plugin_insn_alloc();
178 g_ptr_array_add(tb->insns, new_insn);
179 }
180 insn = g_ptr_array_index(tb->insns, tb->n++);
181 g_byte_array_set_size(insn->data, 0);
182 insn->calls_helpers = false;
183 insn->mem_helper = false;
184 insn->vaddr = pc;
185
186 for (i = 0; i < PLUGIN_N_CB_TYPES; i++) {
187 for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) {
188 g_array_set_size(insn->cbs[i][j], 0);
189 }
190 }
191
192 return insn;
193 }
194
195 void qemu_plugin_vcpu_init_hook(CPUState *cpu);
196 void qemu_plugin_vcpu_exit_hook(CPUState *cpu);
197 void qemu_plugin_tb_trans_cb(CPUState *cpu, struct qemu_plugin_tb *tb);
198 void qemu_plugin_vcpu_idle_cb(CPUState *cpu);
199 void qemu_plugin_vcpu_resume_cb(CPUState *cpu);
200 void
201 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1,
202 uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5,
203 uint64_t a6, uint64_t a7, uint64_t a8);
204 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret);
205
206 void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
207 MemOpIdx oi, enum qemu_plugin_mem_rw rw);
208
209 void qemu_plugin_flush_cb(void);
210
211 void qemu_plugin_atexit_cb(void);
212
213 void qemu_plugin_add_dyn_cb_arr(GArray *arr);
214
215 void qemu_plugin_disable_mem_helpers(CPUState *cpu);
216
217 /**
218 * qemu_plugin_user_exit(): clean-up callbacks before calling exit callbacks
219 *
220 * This is a user-mode only helper that ensure we have fully cleared
221 * callbacks from all threads before calling the exit callbacks. This
222 * is so the plugins themselves don't have to jump through hoops to
223 * guard against race conditions.
224 */
225 void qemu_plugin_user_exit(void);
226
227 #else /* !CONFIG_PLUGIN */
228
qemu_plugin_add_opts(void)229 static inline void qemu_plugin_add_opts(void)
230 { }
231
qemu_plugin_opt_parse(const char * optarg,QemuPluginList * head)232 static inline void qemu_plugin_opt_parse(const char *optarg,
233 QemuPluginList *head)
234 {
235 error_report("plugin interface not enabled in this build");
236 exit(1);
237 }
238
qemu_plugin_load_list(QemuPluginList * head,Error ** errp)239 static inline int qemu_plugin_load_list(QemuPluginList *head, Error **errp)
240 {
241 return 0;
242 }
243
qemu_plugin_vcpu_init_hook(CPUState * cpu)244 static inline void qemu_plugin_vcpu_init_hook(CPUState *cpu)
245 { }
246
qemu_plugin_vcpu_exit_hook(CPUState * cpu)247 static inline void qemu_plugin_vcpu_exit_hook(CPUState *cpu)
248 { }
249
qemu_plugin_tb_trans_cb(CPUState * cpu,struct qemu_plugin_tb * tb)250 static inline void qemu_plugin_tb_trans_cb(CPUState *cpu,
251 struct qemu_plugin_tb *tb)
252 { }
253
qemu_plugin_vcpu_idle_cb(CPUState * cpu)254 static inline void qemu_plugin_vcpu_idle_cb(CPUState *cpu)
255 { }
256
qemu_plugin_vcpu_resume_cb(CPUState * cpu)257 static inline void qemu_plugin_vcpu_resume_cb(CPUState *cpu)
258 { }
259
260 static inline void
qemu_plugin_vcpu_syscall(CPUState * cpu,int64_t num,uint64_t a1,uint64_t a2,uint64_t a3,uint64_t a4,uint64_t a5,uint64_t a6,uint64_t a7,uint64_t a8)261 qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1, uint64_t a2,
262 uint64_t a3, uint64_t a4, uint64_t a5, uint64_t a6,
263 uint64_t a7, uint64_t a8)
264 { }
265
266 static inline
qemu_plugin_vcpu_syscall_ret(CPUState * cpu,int64_t num,int64_t ret)267 void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret)
268 { }
269
qemu_plugin_vcpu_mem_cb(CPUState * cpu,uint64_t vaddr,MemOpIdx oi,enum qemu_plugin_mem_rw rw)270 static inline void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
271 MemOpIdx oi,
272 enum qemu_plugin_mem_rw rw)
273 { }
274
qemu_plugin_flush_cb(void)275 static inline void qemu_plugin_flush_cb(void)
276 { }
277
qemu_plugin_atexit_cb(void)278 static inline void qemu_plugin_atexit_cb(void)
279 { }
280
281 static inline
qemu_plugin_add_dyn_cb_arr(GArray * arr)282 void qemu_plugin_add_dyn_cb_arr(GArray *arr)
283 { }
284
qemu_plugin_disable_mem_helpers(CPUState * cpu)285 static inline void qemu_plugin_disable_mem_helpers(CPUState *cpu)
286 { }
287
qemu_plugin_user_exit(void)288 static inline void qemu_plugin_user_exit(void)
289 { }
290 #endif /* !CONFIG_PLUGIN */
291
292 #endif /* QEMU_PLUGIN_H */
293