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#include "qemu/osdep.h"
38#include "qemu/plugin.h"
39#include "tcg/tcg.h"
40#include "exec/exec-all.h"
41#include "exec/ram_addr.h"
42#include "disas/disas.h"
43#include "plugin.h"
44#ifndef CONFIG_USER_ONLY
45#include "qemu/plugin-memory.h"
46#include "hw/boards.h"
47#endif
48
49
50
51void qemu_plugin_uninstall(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb)
52{
53 plugin_reset_uninstall(id, cb, false);
54}
55
56void qemu_plugin_reset(qemu_plugin_id_t id, qemu_plugin_simple_cb_t cb)
57{
58 plugin_reset_uninstall(id, cb, true);
59}
60
61
62
63
64
65
66
67
68void qemu_plugin_register_vcpu_init_cb(qemu_plugin_id_t id,
69 qemu_plugin_vcpu_simple_cb_t cb)
70{
71 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_INIT, cb);
72}
73
74void qemu_plugin_register_vcpu_exit_cb(qemu_plugin_id_t id,
75 qemu_plugin_vcpu_simple_cb_t cb)
76{
77 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_EXIT, cb);
78}
79
80void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
81 qemu_plugin_vcpu_udata_cb_t cb,
82 enum qemu_plugin_cb_flags flags,
83 void *udata)
84{
85 if (!tb->mem_only) {
86 plugin_register_dyn_cb__udata(&tb->cbs[PLUGIN_CB_REGULAR],
87 cb, flags, udata);
88 }
89}
90
91void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
92 enum qemu_plugin_op op,
93 void *ptr, uint64_t imm)
94{
95 if (!tb->mem_only) {
96 plugin_register_inline_op(&tb->cbs[PLUGIN_CB_INLINE], 0, op, ptr, imm);
97 }
98}
99
100void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
101 qemu_plugin_vcpu_udata_cb_t cb,
102 enum qemu_plugin_cb_flags flags,
103 void *udata)
104{
105 if (!insn->mem_only) {
106 plugin_register_dyn_cb__udata(&insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR],
107 cb, flags, udata);
108 }
109}
110
111void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
112 enum qemu_plugin_op op,
113 void *ptr, uint64_t imm)
114{
115 if (!insn->mem_only) {
116 plugin_register_inline_op(&insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE],
117 0, op, ptr, imm);
118 }
119}
120
121
122
123
124
125
126void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
127 qemu_plugin_vcpu_mem_cb_t cb,
128 enum qemu_plugin_cb_flags flags,
129 enum qemu_plugin_mem_rw rw,
130 void *udata)
131{
132 plugin_register_vcpu_mem_cb(&insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR],
133 cb, flags, rw, udata);
134}
135
136void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
137 enum qemu_plugin_mem_rw rw,
138 enum qemu_plugin_op op, void *ptr,
139 uint64_t imm)
140{
141 plugin_register_inline_op(&insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE],
142 rw, op, ptr, imm);
143}
144
145void qemu_plugin_register_vcpu_tb_trans_cb(qemu_plugin_id_t id,
146 qemu_plugin_vcpu_tb_trans_cb_t cb)
147{
148 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_TB_TRANS, cb);
149}
150
151void qemu_plugin_register_vcpu_syscall_cb(qemu_plugin_id_t id,
152 qemu_plugin_vcpu_syscall_cb_t cb)
153{
154 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_SYSCALL, cb);
155}
156
157void
158qemu_plugin_register_vcpu_syscall_ret_cb(qemu_plugin_id_t id,
159 qemu_plugin_vcpu_syscall_ret_cb_t cb)
160{
161 plugin_register_cb(id, QEMU_PLUGIN_EV_VCPU_SYSCALL_RET, cb);
162}
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180size_t qemu_plugin_tb_n_insns(const struct qemu_plugin_tb *tb)
181{
182 return tb->n;
183}
184
185uint64_t qemu_plugin_tb_vaddr(const struct qemu_plugin_tb *tb)
186{
187 return tb->vaddr;
188}
189
190struct qemu_plugin_insn *
191qemu_plugin_tb_get_insn(const struct qemu_plugin_tb *tb, size_t idx)
192{
193 struct qemu_plugin_insn *insn;
194 if (unlikely(idx >= tb->n)) {
195 return NULL;
196 }
197 insn = g_ptr_array_index(tb->insns, idx);
198 insn->mem_only = tb->mem_only;
199 return insn;
200}
201
202
203
204
205
206
207
208
209const void *qemu_plugin_insn_data(const struct qemu_plugin_insn *insn)
210{
211 return insn->data->data;
212}
213
214size_t qemu_plugin_insn_size(const struct qemu_plugin_insn *insn)
215{
216 return insn->data->len;
217}
218
219uint64_t qemu_plugin_insn_vaddr(const struct qemu_plugin_insn *insn)
220{
221 return insn->vaddr;
222}
223
224void *qemu_plugin_insn_haddr(const struct qemu_plugin_insn *insn)
225{
226 return insn->haddr;
227}
228
229char *qemu_plugin_insn_disas(const struct qemu_plugin_insn *insn)
230{
231 CPUState *cpu = current_cpu;
232 return plugin_disas(cpu, insn->vaddr, insn->data->len);
233}
234
235const char *qemu_plugin_insn_symbol(const struct qemu_plugin_insn *insn)
236{
237 const char *sym = lookup_symbol(insn->vaddr);
238 return sym[0] != 0 ? sym : NULL;
239}
240
241
242
243
244
245
246unsigned qemu_plugin_mem_size_shift(qemu_plugin_meminfo_t info)
247{
248 MemOp op = get_memop(info);
249 return op & MO_SIZE;
250}
251
252bool qemu_plugin_mem_is_sign_extended(qemu_plugin_meminfo_t info)
253{
254 MemOp op = get_memop(info);
255 return op & MO_SIGN;
256}
257
258bool qemu_plugin_mem_is_big_endian(qemu_plugin_meminfo_t info)
259{
260 MemOp op = get_memop(info);
261 return (op & MO_BSWAP) == MO_BE;
262}
263
264bool qemu_plugin_mem_is_store(qemu_plugin_meminfo_t info)
265{
266 return get_plugin_meminfo_rw(info) & QEMU_PLUGIN_MEM_W;
267}
268
269
270
271
272
273#ifdef CONFIG_SOFTMMU
274static __thread struct qemu_plugin_hwaddr hwaddr_info;
275#endif
276
277struct qemu_plugin_hwaddr *qemu_plugin_get_hwaddr(qemu_plugin_meminfo_t info,
278 uint64_t vaddr)
279{
280#ifdef CONFIG_SOFTMMU
281 CPUState *cpu = current_cpu;
282 unsigned int mmu_idx = get_mmuidx(info);
283 enum qemu_plugin_mem_rw rw = get_plugin_meminfo_rw(info);
284 hwaddr_info.is_store = (rw & QEMU_PLUGIN_MEM_W) != 0;
285
286 if (!tlb_plugin_lookup(cpu, vaddr, mmu_idx,
287 hwaddr_info.is_store, &hwaddr_info)) {
288 error_report("invalid use of qemu_plugin_get_hwaddr");
289 return NULL;
290 }
291
292 return &hwaddr_info;
293#else
294 return NULL;
295#endif
296}
297
298bool qemu_plugin_hwaddr_is_io(const struct qemu_plugin_hwaddr *haddr)
299{
300#ifdef CONFIG_SOFTMMU
301 return haddr->is_io;
302#else
303 return false;
304#endif
305}
306
307uint64_t qemu_plugin_hwaddr_phys_addr(const struct qemu_plugin_hwaddr *haddr)
308{
309#ifdef CONFIG_SOFTMMU
310 if (haddr) {
311 if (!haddr->is_io) {
312 RAMBlock *block;
313 ram_addr_t offset;
314 void *hostaddr = haddr->v.ram.hostaddr;
315
316 block = qemu_ram_block_from_host(hostaddr, false, &offset);
317 if (!block) {
318 error_report("Bad host ram pointer %p", haddr->v.ram.hostaddr);
319 abort();
320 }
321
322 return block->offset + offset + block->mr->addr;
323 } else {
324 MemoryRegionSection *mrs = haddr->v.io.section;
325 return mrs->offset_within_address_space + haddr->v.io.offset;
326 }
327 }
328#endif
329 return 0;
330}
331
332const char *qemu_plugin_hwaddr_device_name(const struct qemu_plugin_hwaddr *h)
333{
334#ifdef CONFIG_SOFTMMU
335 if (h && h->is_io) {
336 MemoryRegionSection *mrs = h->v.io.section;
337 if (!mrs->mr->name) {
338 unsigned long maddr = 0xffffffff & (uintptr_t) mrs->mr;
339 g_autofree char *temp = g_strdup_printf("anon%08lx", maddr);
340 return g_intern_string(temp);
341 } else {
342 return g_intern_string(mrs->mr->name);
343 }
344 } else {
345 return g_intern_static_string("RAM");
346 }
347#else
348 return g_intern_static_string("Invalid");
349#endif
350}
351
352
353
354
355
356
357#ifndef CONFIG_USER_ONLY
358static MachineState * get_ms(void)
359{
360 return MACHINE(qdev_get_machine());
361}
362#endif
363
364int qemu_plugin_n_vcpus(void)
365{
366#ifdef CONFIG_USER_ONLY
367 return -1;
368#else
369 return get_ms()->smp.cpus;
370#endif
371}
372
373int qemu_plugin_n_max_vcpus(void)
374{
375#ifdef CONFIG_USER_ONLY
376 return -1;
377#else
378 return get_ms()->smp.max_cpus;
379#endif
380}
381
382
383
384
385void qemu_plugin_outs(const char *string)
386{
387 qemu_log_mask(CPU_LOG_PLUGIN, "%s", string);
388}
389
390bool qemu_plugin_bool_parse(const char *name, const char *value, bool *ret)
391{
392 return name && value && qapi_bool_parse(name, value, ret, NULL);
393}
394