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