[PULL 00/16] tcg patch queue
[PULL 00/20] tcg patch queue
1
The following changes since commit 3e08b2b9cb64bff2b73fa9128c0e49bfcde0dd40:
1
The following changes since commit 9c6c079bc6723da8061ccfb44361d67b1dd785dd:
2
2
3
Merge remote-tracking branch 'remotes/philmd-gitlab/tags/edk2-next-20200121' into staging (2020-01-21 15:29:25 +0000)
3
Merge tag 'pull-target-arm-20240430' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2024-04-30 09:58:54 -0700)
4
4
5
are available in the Git repository at:
5
are available in the Git repository at:
6
6
7
https://github.com/rth7680/qemu.git tags/pull-tcg-20200121
7
https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20240501
8
8
9
for you to fetch changes up to 75fa376cdab5e5db2c7fdd107358e16f95503ac6:
9
for you to fetch changes up to 917d7f8d948d706e275c9f33169b9dd0149ded1e:
10
10
11
scripts/git.orderfile: Display decodetree before C source (2020-01-21 15:26:09 -1000)
11
plugins: Update the documentation block for plugin-gen.c (2024-04-30 16:12:05 -0700)
12
12
13
----------------------------------------------------------------
13
----------------------------------------------------------------
14
Remove another limit to NB_MMU_MODES.
14
plugins: Rewrite plugin tcg expansion
15
Fix compilation using uclibc.
16
Fix defaulting of -accel parameters.
17
Tidy cputlb basic routines.
18
Adjust git.orderfile for decodetree.
19
15
20
----------------------------------------------------------------
16
----------------------------------------------------------------
21
Carlos Santos (1):
17
Richard Henderson (20):
22
util/cacheinfo: fix crash when compiling with uClibc
18
tcg: Make tcg/helper-info.h self-contained
19
tcg: Pass function pointer to tcg_gen_call*
20
plugins: Zero new qemu_plugin_dyn_cb entries
21
plugins: Move function pointer in qemu_plugin_dyn_cb
22
plugins: Create TCGHelperInfo for all out-of-line callbacks
23
plugins: Use emit_before_op for PLUGIN_GEN_AFTER_INSN
24
plugins: Use emit_before_op for PLUGIN_GEN_FROM_TB
25
plugins: Add PLUGIN_GEN_AFTER_TB
26
plugins: Use emit_before_op for PLUGIN_GEN_FROM_INSN
27
plugins: Use emit_before_op for PLUGIN_GEN_FROM_MEM
28
plugins: Remove plugin helpers
29
tcg: Remove TCG_CALL_PLUGIN
30
tcg: Remove INDEX_op_plugin_cb_{start,end}
31
plugins: Simplify callback queues
32
plugins: Introduce PLUGIN_CB_MEM_REGULAR
33
plugins: Replace pr_ops with a proper debug dump flag
34
plugins: Split out common cb expanders
35
plugins: Merge qemu_plugin_tb_insn_get to plugin-gen.c
36
plugins: Inline plugin_gen_empty_callback
37
plugins: Update the documentation block for plugin-gen.c
23
38
24
Philippe Mathieu-Daudé (1):
39
accel/tcg/plugin-helpers.h | 5 -
25
scripts/git.orderfile: Display decodetree before C source
40
include/exec/helper-gen-common.h | 4 -
26
41
include/exec/helper-proto-common.h | 4 -
27
Richard Henderson (14):
42
include/exec/plugin-gen.h | 4 -
28
cputlb: Handle NB_MMU_MODES > TARGET_PAGE_BITS_MIN
43
include/qemu/log.h | 1 +
29
vl: Remove unused variable in configure_accelerators
44
include/qemu/plugin.h | 67 +--
30
vl: Reduce scope of variables in configure_accelerators
45
include/tcg/helper-info.h | 3 +
31
vl: Remove useless test in configure_accelerators
46
include/tcg/tcg-op-common.h | 4 +-
32
vl: Only choose enabled accelerators in configure_accelerators
47
include/tcg/tcg-opc.h | 4 +-
33
cputlb: Merge tlb_table_flush_by_mmuidx into tlb_flush_one_mmuidx_locked
48
include/tcg/tcg.h | 26 +-
34
cputlb: Make tlb_n_entries private to cputlb.c
49
include/exec/helper-gen.h.inc | 24 +-
35
cputlb: Pass CPUTLBDescFast to tlb_n_entries and sizeof_tlb
50
accel/tcg/plugin-gen.c | 1007 +++++++++---------------------------
36
cputlb: Hoist tlb portions in tlb_mmu_resize_locked
51
plugins/api.c | 26 +-
37
cputlb: Hoist tlb portions in tlb_flush_one_mmuidx_locked
52
plugins/core.c | 61 ++-
38
cputlb: Split out tlb_mmu_flush_locked
53
tcg/tcg-op-ldst.c | 6 +-
39
cputlb: Partially merge tlb_dyn_init into tlb_init
54
tcg/tcg-op.c | 8 +-
40
cputlb: Initialize tlbs as flushed
55
tcg/tcg.c | 78 ++-
41
cputlb: Hoist timestamp outside of loops over tlbs
56
tcg/tci.c | 1 +
42
57
util/log.c | 4 +
43
include/exec/cpu_ldst.h | 5 -
58
19 files changed, 399 insertions(+), 938 deletions(-)
44
accel/tcg/cputlb.c | 287 +++++++++++++++++++++++++++++++++---------------
59
delete mode 100644 accel/tcg/plugin-helpers.h
45
util/cacheinfo.c | 10 +-
46
vl.c | 27 +++--
47
scripts/git.orderfile | 3 +
48
5 files changed, 223 insertions(+), 109 deletions(-)
49
diff view generated by jsdifflib
[PULL 16/16] scripts/git.orderfile: Display decodetree before C source
[PULL 01/20] tcg: Make tcg/helper-info.h self-contained
1
From: Philippe Mathieu-Daudé <philmd@redhat.com>
1
Move MAX_CALL_IARGS from tcg.h and include for
2
the define of TCG_TARGET_REG_BITS.
2
3
3
To avoid scrolling each instruction when reviewing tcg
4
helpers written for the decodetree script, display the
5
.decode files (similar to header declarations) before
6
the C source (implementation of previous declarations).
7
8
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
9
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
10
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
11
Message-Id: <20191230082856.30556-1-philmd@redhat.com>
5
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
12
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
13
---
7
---
14
scripts/git.orderfile | 3 +++
8
include/tcg/helper-info.h | 3 +++
15
1 file changed, 3 insertions(+)
9
include/tcg/tcg.h | 2 --
10
tcg/tci.c | 1 +
11
3 files changed, 4 insertions(+), 2 deletions(-)
16
12
17
diff --git a/scripts/git.orderfile b/scripts/git.orderfile
13
diff --git a/include/tcg/helper-info.h b/include/tcg/helper-info.h
18
index XXXXXXX..XXXXXXX 100644
14
index XXXXXXX..XXXXXXX 100644
19
--- a/scripts/git.orderfile
15
--- a/include/tcg/helper-info.h
20
+++ b/scripts/git.orderfile
16
+++ b/include/tcg/helper-info.h
21
@@ -XXX,XX +XXX,XX @@ qga/*.json
17
@@ -XXX,XX +XXX,XX @@
22
# headers
18
#ifdef CONFIG_TCG_INTERPRETER
23
*.h
19
#include <ffi.h>
24
20
#endif
25
+# decoding tree specification
21
+#include "tcg-target-reg-bits.h"
26
+*.decode
27
+
22
+
28
# code
23
+#define MAX_CALL_IARGS 7
29
*.c
24
25
/*
26
* Describe the calling convention of a given argument type.
27
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
28
index XXXXXXX..XXXXXXX 100644
29
--- a/include/tcg/tcg.h
30
+++ b/include/tcg/tcg.h
31
@@ -XXX,XX +XXX,XX @@
32
/* XXX: make safe guess about sizes */
33
#define MAX_OP_PER_INSTR 266
34
35
-#define MAX_CALL_IARGS 7
36
-
37
#define CPU_TEMP_BUF_NLONGS 128
38
#define TCG_STATIC_FRAME_SIZE (CPU_TEMP_BUF_NLONGS * sizeof(long))
39
40
diff --git a/tcg/tci.c b/tcg/tci.c
41
index XXXXXXX..XXXXXXX 100644
42
--- a/tcg/tci.c
43
+++ b/tcg/tci.c
44
@@ -XXX,XX +XXX,XX @@
45
46
#include "qemu/osdep.h"
47
#include "tcg/tcg.h"
48
+#include "tcg/helper-info.h"
49
#include "tcg/tcg-ldst.h"
50
#include <ffi.h>
51
30
--
52
--
31
2.20.1
53
2.34.1
32
54
33
55
diff view generated by jsdifflib
[PULL 06/16] vl: Only choose enabled accelerators in configure_accelerators
[PULL 02/20] tcg: Pass function pointer to tcg_gen_call*
1
By choosing "tcg:kvm" when kvm is not enabled, we generate
1
For normal helpers, read the function pointer from the
2
an incorrect warning: "invalid accelerator kvm".
2
structure earlier. For plugins, this will allow the
3
3
function pointer to come from elsewhere.
4
At the same time, use g_str_has_suffix rather than open-coding
4
5
the same operation.
6
7
Presumably the inverse is also true with --disable-tcg.
8
9
Fixes: 28a0961757fc
10
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
11
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
5
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
12
Reviewed by: Aleksandar Markovic <amarkovic@wavecomp.com>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
13
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
14
---
8
---
15
vl.c | 21 +++++++++++++--------
9
include/tcg/tcg.h | 21 +++++++++-------
16
1 file changed, 13 insertions(+), 8 deletions(-)
10
include/exec/helper-gen.h.inc | 24 ++++++++++++-------
17
11
tcg/tcg.c | 45 +++++++++++++++++++----------------
18
diff --git a/vl.c b/vl.c
12
3 files changed, 52 insertions(+), 38 deletions(-)
13
14
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
19
index XXXXXXX..XXXXXXX 100644
15
index XXXXXXX..XXXXXXX 100644
20
--- a/vl.c
16
--- a/include/tcg/tcg.h
21
+++ b/vl.c
17
+++ b/include/tcg/tcg.h
22
@@ -XXX,XX +XXX,XX @@ static void configure_accelerators(const char *progname)
18
@@ -XXX,XX +XXX,XX @@ typedef struct TCGTargetOpDef {
23
19
24
if (accel == NULL) {
20
bool tcg_op_supported(TCGOpcode op);
25
/* Select the default accelerator */
21
26
- if (!accel_find("tcg") && !accel_find("kvm")) {
22
-void tcg_gen_call0(TCGHelperInfo *, TCGTemp *ret);
27
- error_report("No accelerator selected and"
23
-void tcg_gen_call1(TCGHelperInfo *, TCGTemp *ret, TCGTemp *);
28
- " no default accelerator available");
24
-void tcg_gen_call2(TCGHelperInfo *, TCGTemp *ret, TCGTemp *, TCGTemp *);
29
- exit(1);
25
-void tcg_gen_call3(TCGHelperInfo *, TCGTemp *ret, TCGTemp *,
30
- } else {
26
+void tcg_gen_call0(void *func, TCGHelperInfo *, TCGTemp *ret);
31
- int pnlen = strlen(progname);
27
+void tcg_gen_call1(void *func, TCGHelperInfo *, TCGTemp *ret, TCGTemp *);
32
- if (pnlen >= 3 && g_str_equal(&progname[pnlen - 3], "kvm")) {
28
+void tcg_gen_call2(void *func, TCGHelperInfo *, TCGTemp *ret,
33
+ bool have_tcg = accel_find("tcg");
29
TCGTemp *, TCGTemp *);
34
+ bool have_kvm = accel_find("kvm");
30
-void tcg_gen_call4(TCGHelperInfo *, TCGTemp *ret, TCGTemp *, TCGTemp *,
35
+
31
- TCGTemp *, TCGTemp *);
36
+ if (have_tcg && have_kvm) {
32
-void tcg_gen_call5(TCGHelperInfo *, TCGTemp *ret, TCGTemp *, TCGTemp *,
37
+ if (g_str_has_suffix(progname, "kvm")) {
33
+void tcg_gen_call3(void *func, TCGHelperInfo *, TCGTemp *ret,
38
/* If the program name ends with "kvm", we prefer KVM */
34
TCGTemp *, TCGTemp *, TCGTemp *);
39
accel = "kvm:tcg";
35
-void tcg_gen_call6(TCGHelperInfo *, TCGTemp *ret, TCGTemp *, TCGTemp *,
40
} else {
36
+void tcg_gen_call4(void *func, TCGHelperInfo *, TCGTemp *ret,
41
accel = "tcg:kvm";
37
TCGTemp *, TCGTemp *, TCGTemp *, TCGTemp *);
42
}
38
-void tcg_gen_call7(TCGHelperInfo *, TCGTemp *ret, TCGTemp *, TCGTemp *,
43
+ } else if (have_kvm) {
39
+void tcg_gen_call5(void *func, TCGHelperInfo *, TCGTemp *ret,
44
+ accel = "kvm";
40
TCGTemp *, TCGTemp *, TCGTemp *, TCGTemp *, TCGTemp *);
45
+ } else if (have_tcg) {
41
+void tcg_gen_call6(void *func, TCGHelperInfo *, TCGTemp *ret,
46
+ accel = "tcg";
42
+ TCGTemp *, TCGTemp *, TCGTemp *, TCGTemp *,
47
+ } else {
43
+ TCGTemp *, TCGTemp *);
48
+ error_report("No accelerator selected and"
44
+void tcg_gen_call7(void *func, TCGHelperInfo *, TCGTemp *ret,
49
+ " no default accelerator available");
45
+ TCGTemp *, TCGTemp *, TCGTemp *, TCGTemp *,
50
+ exit(1);
46
+ TCGTemp *, TCGTemp *, TCGTemp *);
51
}
47
48
TCGOp *tcg_emit_op(TCGOpcode opc, unsigned nargs);
49
void tcg_op_remove(TCGContext *s, TCGOp *op);
50
diff --git a/include/exec/helper-gen.h.inc b/include/exec/helper-gen.h.inc
51
index XXXXXXX..XXXXXXX 100644
52
--- a/include/exec/helper-gen.h.inc
53
+++ b/include/exec/helper-gen.h.inc
54
@@ -XXX,XX +XXX,XX @@
55
extern TCGHelperInfo glue(helper_info_, name); \
56
static inline void glue(gen_helper_, name)(dh_retvar_decl0(ret)) \
57
{ \
58
- tcg_gen_call0(&glue(helper_info_, name), dh_retvar(ret)); \
59
+ tcg_gen_call0(glue(helper_info_,name).func, \
60
+ &glue(helper_info_,name), dh_retvar(ret)); \
61
}
62
63
#define DEF_HELPER_FLAGS_1(name, flags, ret, t1) \
64
@@ -XXX,XX +XXX,XX @@ extern TCGHelperInfo glue(helper_info_, name); \
65
static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
66
dh_arg_decl(t1, 1)) \
67
{ \
68
- tcg_gen_call1(&glue(helper_info_, name), dh_retvar(ret), \
69
+ tcg_gen_call1(glue(helper_info_,name).func, \
70
+ &glue(helper_info_,name), dh_retvar(ret), \
71
dh_arg(t1, 1)); \
72
}
73
74
@@ -XXX,XX +XXX,XX @@ extern TCGHelperInfo glue(helper_info_, name); \
75
static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
76
dh_arg_decl(t1, 1), dh_arg_decl(t2, 2)) \
77
{ \
78
- tcg_gen_call2(&glue(helper_info_, name), dh_retvar(ret), \
79
+ tcg_gen_call2(glue(helper_info_,name).func, \
80
+ &glue(helper_info_,name), dh_retvar(ret), \
81
dh_arg(t1, 1), dh_arg(t2, 2)); \
82
}
83
84
@@ -XXX,XX +XXX,XX @@ extern TCGHelperInfo glue(helper_info_, name); \
85
static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
86
dh_arg_decl(t1, 1), dh_arg_decl(t2, 2), dh_arg_decl(t3, 3)) \
87
{ \
88
- tcg_gen_call3(&glue(helper_info_, name), dh_retvar(ret), \
89
+ tcg_gen_call3(glue(helper_info_,name).func, \
90
+ &glue(helper_info_,name), dh_retvar(ret), \
91
dh_arg(t1, 1), dh_arg(t2, 2), dh_arg(t3, 3)); \
92
}
93
94
@@ -XXX,XX +XXX,XX @@ static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
95
dh_arg_decl(t1, 1), dh_arg_decl(t2, 2), \
96
dh_arg_decl(t3, 3), dh_arg_decl(t4, 4)) \
97
{ \
98
- tcg_gen_call4(&glue(helper_info_, name), dh_retvar(ret), \
99
+ tcg_gen_call4(glue(helper_info_,name).func, \
100
+ &glue(helper_info_,name), dh_retvar(ret), \
101
dh_arg(t1, 1), dh_arg(t2, 2), \
102
dh_arg(t3, 3), dh_arg(t4, 4)); \
103
}
104
@@ -XXX,XX +XXX,XX @@ static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
105
dh_arg_decl(t1, 1), dh_arg_decl(t2, 2), dh_arg_decl(t3, 3), \
106
dh_arg_decl(t4, 4), dh_arg_decl(t5, 5)) \
107
{ \
108
- tcg_gen_call5(&glue(helper_info_, name), dh_retvar(ret), \
109
+ tcg_gen_call5(glue(helper_info_,name).func, \
110
+ &glue(helper_info_,name), dh_retvar(ret), \
111
dh_arg(t1, 1), dh_arg(t2, 2), dh_arg(t3, 3), \
112
dh_arg(t4, 4), dh_arg(t5, 5)); \
113
}
114
@@ -XXX,XX +XXX,XX @@ static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
115
dh_arg_decl(t1, 1), dh_arg_decl(t2, 2), dh_arg_decl(t3, 3), \
116
dh_arg_decl(t4, 4), dh_arg_decl(t5, 5), dh_arg_decl(t6, 6)) \
117
{ \
118
- tcg_gen_call6(&glue(helper_info_, name), dh_retvar(ret), \
119
+ tcg_gen_call6(glue(helper_info_,name).func, \
120
+ &glue(helper_info_,name), dh_retvar(ret), \
121
dh_arg(t1, 1), dh_arg(t2, 2), dh_arg(t3, 3), \
122
dh_arg(t4, 4), dh_arg(t5, 5), dh_arg(t6, 6)); \
123
}
124
@@ -XXX,XX +XXX,XX @@ static inline void glue(gen_helper_, name)(dh_retvar_decl(ret) \
125
dh_arg_decl(t4, 4), dh_arg_decl(t5, 5), dh_arg_decl(t6, 6), \
126
dh_arg_decl(t7, 7)) \
127
{ \
128
- tcg_gen_call7(&glue(helper_info_, name), dh_retvar(ret), \
129
+ tcg_gen_call7(glue(helper_info_,name).func, \
130
+ &glue(helper_info_,name), dh_retvar(ret), \
131
dh_arg(t1, 1), dh_arg(t2, 2), dh_arg(t3, 3), \
132
dh_arg(t4, 4), dh_arg(t5, 5), dh_arg(t6, 6), \
133
dh_arg(t7, 7)); \
134
diff --git a/tcg/tcg.c b/tcg/tcg.c
135
index XXXXXXX..XXXXXXX 100644
136
--- a/tcg/tcg.c
137
+++ b/tcg/tcg.c
138
@@ -XXX,XX +XXX,XX @@ bool tcg_op_supported(TCGOpcode op)
139
140
static TCGOp *tcg_op_alloc(TCGOpcode opc, unsigned nargs);
141
142
-static void tcg_gen_callN(TCGHelperInfo *info, TCGTemp *ret, TCGTemp **args)
143
+static void tcg_gen_callN(void *func, TCGHelperInfo *info,
144
+ TCGTemp *ret, TCGTemp **args)
145
{
146
TCGv_i64 extend_free[MAX_CALL_IARGS];
147
int n_extend = 0;
148
@@ -XXX,XX +XXX,XX @@ static void tcg_gen_callN(TCGHelperInfo *info, TCGTemp *ret, TCGTemp **args)
149
g_assert_not_reached();
52
}
150
}
53
-
151
}
54
accel_list = g_strsplit(accel, ":", 0);
152
- op->args[pi++] = (uintptr_t)info->func;
55
153
+ op->args[pi++] = (uintptr_t)func;
56
for (tmp = accel_list; *tmp; tmp++) {
154
op->args[pi++] = (uintptr_t)info;
155
tcg_debug_assert(pi == total_args);
156
157
@@ -XXX,XX +XXX,XX @@ static void tcg_gen_callN(TCGHelperInfo *info, TCGTemp *ret, TCGTemp **args)
158
}
159
}
160
161
-void tcg_gen_call0(TCGHelperInfo *info, TCGTemp *ret)
162
+void tcg_gen_call0(void *func, TCGHelperInfo *info, TCGTemp *ret)
163
{
164
- tcg_gen_callN(info, ret, NULL);
165
+ tcg_gen_callN(func, info, ret, NULL);
166
}
167
168
-void tcg_gen_call1(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1)
169
+void tcg_gen_call1(void *func, TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1)
170
{
171
- tcg_gen_callN(info, ret, &t1);
172
+ tcg_gen_callN(func, info, ret, &t1);
173
}
174
175
-void tcg_gen_call2(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1, TCGTemp *t2)
176
+void tcg_gen_call2(void *func, TCGHelperInfo *info, TCGTemp *ret,
177
+ TCGTemp *t1, TCGTemp *t2)
178
{
179
TCGTemp *args[2] = { t1, t2 };
180
- tcg_gen_callN(info, ret, args);
181
+ tcg_gen_callN(func, info, ret, args);
182
}
183
184
-void tcg_gen_call3(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
185
- TCGTemp *t2, TCGTemp *t3)
186
+void tcg_gen_call3(void *func, TCGHelperInfo *info, TCGTemp *ret,
187
+ TCGTemp *t1, TCGTemp *t2, TCGTemp *t3)
188
{
189
TCGTemp *args[3] = { t1, t2, t3 };
190
- tcg_gen_callN(info, ret, args);
191
+ tcg_gen_callN(func, info, ret, args);
192
}
193
194
-void tcg_gen_call4(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
195
- TCGTemp *t2, TCGTemp *t3, TCGTemp *t4)
196
+void tcg_gen_call4(void *func, TCGHelperInfo *info, TCGTemp *ret,
197
+ TCGTemp *t1, TCGTemp *t2, TCGTemp *t3, TCGTemp *t4)
198
{
199
TCGTemp *args[4] = { t1, t2, t3, t4 };
200
- tcg_gen_callN(info, ret, args);
201
+ tcg_gen_callN(func, info, ret, args);
202
}
203
204
-void tcg_gen_call5(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
205
+void tcg_gen_call5(void *func, TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
206
TCGTemp *t2, TCGTemp *t3, TCGTemp *t4, TCGTemp *t5)
207
{
208
TCGTemp *args[5] = { t1, t2, t3, t4, t5 };
209
- tcg_gen_callN(info, ret, args);
210
+ tcg_gen_callN(func, info, ret, args);
211
}
212
213
-void tcg_gen_call6(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1, TCGTemp *t2,
214
- TCGTemp *t3, TCGTemp *t4, TCGTemp *t5, TCGTemp *t6)
215
+void tcg_gen_call6(void *func, TCGHelperInfo *info, TCGTemp *ret,
216
+ TCGTemp *t1, TCGTemp *t2, TCGTemp *t3,
217
+ TCGTemp *t4, TCGTemp *t5, TCGTemp *t6)
218
{
219
TCGTemp *args[6] = { t1, t2, t3, t4, t5, t6 };
220
- tcg_gen_callN(info, ret, args);
221
+ tcg_gen_callN(func, info, ret, args);
222
}
223
224
-void tcg_gen_call7(TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
225
+void tcg_gen_call7(void *func, TCGHelperInfo *info, TCGTemp *ret, TCGTemp *t1,
226
TCGTemp *t2, TCGTemp *t3, TCGTemp *t4,
227
TCGTemp *t5, TCGTemp *t6, TCGTemp *t7)
228
{
229
TCGTemp *args[7] = { t1, t2, t3, t4, t5, t6, t7 };
230
- tcg_gen_callN(info, ret, args);
231
+ tcg_gen_callN(func, info, ret, args);
232
}
233
234
static void tcg_reg_alloc_start(TCGContext *s)
57
--
235
--
58
2.20.1
236
2.34.1
59
237
60
238
diff view generated by jsdifflib
[PULL 05/16] vl: Remove useless test in configure_accelerators
[PULL 03/20] plugins: Zero new qemu_plugin_dyn_cb entries
1
The result of g_strsplit is never NULL.
2
3
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
1
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
5
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
6
Reviewed by: Aleksandar Markovic <amarkovic@wavecomp.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
3
---
9
vl.c | 2 +-
4
plugins/core.c | 2 +-
10
1 file changed, 1 insertion(+), 1 deletion(-)
5
1 file changed, 1 insertion(+), 1 deletion(-)
11
6
12
diff --git a/vl.c b/vl.c
7
diff --git a/plugins/core.c b/plugins/core.c
13
index XXXXXXX..XXXXXXX 100644
8
index XXXXXXX..XXXXXXX 100644
14
--- a/vl.c
9
--- a/plugins/core.c
15
+++ b/vl.c
10
+++ b/plugins/core.c
16
@@ -XXX,XX +XXX,XX @@ static void configure_accelerators(const char *progname)
11
@@ -XXX,XX +XXX,XX @@ static struct qemu_plugin_dyn_cb *plugin_get_dyn_cb(GArray **arr)
17
12
GArray *cbs = *arr;
18
accel_list = g_strsplit(accel, ":", 0);
13
19
14
if (!cbs) {
20
- for (tmp = accel_list; tmp && *tmp; tmp++) {
15
- cbs = g_array_sized_new(false, false,
21
+ for (tmp = accel_list; *tmp; tmp++) {
16
+ cbs = g_array_sized_new(false, true,
22
/*
17
sizeof(struct qemu_plugin_dyn_cb), 1);
23
* Filter invalid accelerators here, to prevent obscenities
18
*arr = cbs;
24
* such as "-machine accel=tcg,,thread=single".
19
}
25
--
20
--
26
2.20.1
21
2.34.1
27
22
28
23
diff view generated by jsdifflib
[PULL 14/16] cputlb: Initialize tlbs as flushed
[PULL 04/20] plugins: Move function pointer in qemu_plugin_dyn_cb
1
There's little point in leaving these data structures half initialized,
1
The out-of-line function pointer is mutually exclusive
2
and relying on a flush to be done during reset.
2
with inline expansion, so move it into the union.
3
Wrap the pointer in a structure named 'regular' to match
4
PLUGIN_CB_REGULAR.
3
5
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
6
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
5
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
7
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
9
---
8
accel/tcg/cputlb.c | 5 +++--
10
include/qemu/plugin.h | 4 +++-
9
1 file changed, 3 insertions(+), 2 deletions(-)
11
accel/tcg/plugin-gen.c | 4 ++--
12
plugins/core.c | 8 ++++----
13
3 files changed, 9 insertions(+), 7 deletions(-)
10
14
11
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
15
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
12
index XXXXXXX..XXXXXXX 100644
16
index XXXXXXX..XXXXXXX 100644
13
--- a/accel/tcg/cputlb.c
17
--- a/include/qemu/plugin.h
14
+++ b/accel/tcg/cputlb.c
18
+++ b/include/qemu/plugin.h
15
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_init(CPUTLBDesc *desc, CPUTLBDescFast *fast, int64_t now)
19
@@ -XXX,XX +XXX,XX @@ enum plugin_dyn_cb_subtype {
16
fast->mask = (n_entries - 1) << CPU_TLB_ENTRY_BITS;
20
* instance of a callback to be called upon the execution of a particular TB.
17
fast->table = g_new(CPUTLBEntry, n_entries);
21
*/
18
desc->iotlb = g_new(CPUIOTLBEntry, n_entries);
22
struct qemu_plugin_dyn_cb {
19
+ tlb_mmu_flush_locked(desc, fast);
23
- union qemu_plugin_cb_sig f;
24
void *userp;
25
enum plugin_dyn_cb_subtype type;
26
/* @rw applies to mem callbacks only (both regular and inline) */
27
enum qemu_plugin_mem_rw rw;
28
/* fields specific to each dyn_cb type go here */
29
union {
30
+ struct {
31
+ union qemu_plugin_cb_sig f;
32
+ } regular;
33
struct {
34
qemu_plugin_u64 entry;
35
enum qemu_plugin_op op;
36
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
37
index XXXXXXX..XXXXXXX 100644
38
--- a/accel/tcg/plugin-gen.c
39
+++ b/accel/tcg/plugin-gen.c
40
@@ -XXX,XX +XXX,XX @@ static TCGOp *append_udata_cb(const struct qemu_plugin_dyn_cb *cb,
41
}
42
43
/* call */
44
- op = copy_call(&begin_op, op, cb->f.vcpu_udata, cb_idx);
45
+ op = copy_call(&begin_op, op, cb->regular.f.vcpu_udata, cb_idx);
46
47
return op;
20
}
48
}
21
49
@@ -XXX,XX +XXX,XX @@ static TCGOp *append_mem_cb(const struct qemu_plugin_dyn_cb *cb,
22
static inline void tlb_n_used_entries_inc(CPUArchState *env, uintptr_t mmu_idx)
50
23
@@ -XXX,XX +XXX,XX @@ void tlb_init(CPUState *cpu)
51
if (type == PLUGIN_GEN_CB_MEM) {
24
52
/* call */
25
qemu_spin_init(&env_tlb(env)->c.lock);
53
- op = copy_call(&begin_op, op, cb->f.vcpu_udata, cb_idx);
26
54
+ op = copy_call(&begin_op, op, cb->regular.f.vcpu_udata, cb_idx);
27
- /* Ensure that cpu_reset performs a full flush. */
55
}
28
- env_tlb(env)->c.dirty = ALL_MMUIDX_BITS;
56
29
+ /* All tlbs are initialized flushed. */
57
return op;
30
+ env_tlb(env)->c.dirty = 0;
58
diff --git a/plugins/core.c b/plugins/core.c
31
59
index XXXXXXX..XXXXXXX 100644
32
for (i = 0; i < NB_MMU_MODES; i++) {
60
--- a/plugins/core.c
33
tlb_mmu_init(&env_tlb(env)->d[i], &env_tlb(env)->f[i], now);
61
+++ b/plugins/core.c
62
@@ -XXX,XX +XXX,XX @@ void plugin_register_dyn_cb__udata(GArray **arr,
63
64
dyn_cb->userp = udata;
65
/* Note flags are discarded as unused. */
66
- dyn_cb->f.vcpu_udata = cb;
67
+ dyn_cb->regular.f.vcpu_udata = cb;
68
dyn_cb->type = PLUGIN_CB_REGULAR;
69
}
70
71
@@ -XXX,XX +XXX,XX @@ void plugin_register_vcpu_mem_cb(GArray **arr,
72
/* Note flags are discarded as unused. */
73
dyn_cb->type = PLUGIN_CB_REGULAR;
74
dyn_cb->rw = rw;
75
- dyn_cb->f.generic = cb;
76
+ dyn_cb->regular.f.vcpu_mem = cb;
77
}
78
79
/*
80
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
81
}
82
switch (cb->type) {
83
case PLUGIN_CB_REGULAR:
84
- cb->f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw),
85
- vaddr, cb->userp);
86
+ cb->regular.f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw),
87
+ vaddr, cb->userp);
88
break;
89
case PLUGIN_CB_INLINE:
90
exec_inline_op(cb, cpu->cpu_index);
34
--
91
--
35
2.20.1
92
2.34.1
36
93
37
94
diff view generated by jsdifflib
[PULL 15/16] cputlb: Hoist timestamp outside of loops over tlbs
[PULL 05/20] plugins: Create TCGHelperInfo for all out-of-line callbacks
1
Do not call get_clock_realtime() in tlb_mmu_resize_locked,
1
TCGHelperInfo includes the ABI for every function call.
2
but hoist outside of any loop over a set of tlbs. This is
3
only two (indirect) callers, tlb_flush_by_mmuidx_async_work
4
and tlb_flush_page_locked, so not onerous.
5
2
6
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
3
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
7
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
8
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
9
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
10
---
5
---
11
accel/tcg/cputlb.c | 14 ++++++++------
6
include/qemu/plugin.h | 1 +
12
1 file changed, 8 insertions(+), 6 deletions(-)
7
plugins/core.c | 51 ++++++++++++++++++++++++++++++++++++++-----
8
2 files changed, 46 insertions(+), 6 deletions(-)
13
9
14
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
10
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
15
index XXXXXXX..XXXXXXX 100644
11
index XXXXXXX..XXXXXXX 100644
16
--- a/accel/tcg/cputlb.c
12
--- a/include/qemu/plugin.h
17
+++ b/accel/tcg/cputlb.c
13
+++ b/include/qemu/plugin.h
18
@@ -XXX,XX +XXX,XX @@ static void tlb_window_reset(CPUTLBDesc *desc, int64_t ns,
14
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_dyn_cb {
19
* high), since otherwise we are likely to have a significant amount of
15
union {
20
* conflict misses.
16
struct {
21
*/
17
union qemu_plugin_cb_sig f;
22
-static void tlb_mmu_resize_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
18
+ TCGHelperInfo *info;
23
+static void tlb_mmu_resize_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast,
19
} regular;
24
+ int64_t now)
20
struct {
21
qemu_plugin_u64 entry;
22
diff --git a/plugins/core.c b/plugins/core.c
23
index XXXXXXX..XXXXXXX 100644
24
--- a/plugins/core.c
25
+++ b/plugins/core.c
26
@@ -XXX,XX +XXX,XX @@ void plugin_register_dyn_cb__udata(GArray **arr,
27
enum qemu_plugin_cb_flags flags,
28
void *udata)
25
{
29
{
26
size_t old_size = tlb_n_entries(fast);
30
- struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
27
size_t rate;
31
+ static TCGHelperInfo info[3] = {
28
size_t new_size = old_size;
32
+ [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN,
29
- int64_t now = get_clock_realtime();
33
+ [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN,
30
int64_t window_len_ms = 100;
34
+ [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN,
31
int64_t window_len_ns = window_len_ms * 1000 * 1000;
35
+ /*
32
bool window_expired = now > desc->window_begin_ns + window_len_ns;
36
+ * Match qemu_plugin_vcpu_udata_cb_t:
33
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_flush_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
37
+ * void (*)(uint32_t, void *)
34
memset(desc->vtable, -1, sizeof(desc->vtable));
38
+ */
39
+ [0 ... 2].typemask = (dh_typemask(void, 0) |
40
+ dh_typemask(i32, 1) |
41
+ dh_typemask(ptr, 2))
42
+ };
43
44
+ struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
45
dyn_cb->userp = udata;
46
- /* Note flags are discarded as unused. */
47
- dyn_cb->regular.f.vcpu_udata = cb;
48
dyn_cb->type = PLUGIN_CB_REGULAR;
49
+ dyn_cb->regular.f.vcpu_udata = cb;
50
+
51
+ assert((unsigned)flags < ARRAY_SIZE(info));
52
+ dyn_cb->regular.info = &info[flags];
35
}
53
}
36
54
37
-static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
55
void plugin_register_vcpu_mem_cb(GArray **arr,
38
+static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx,
56
@@ -XXX,XX +XXX,XX @@ void plugin_register_vcpu_mem_cb(GArray **arr,
39
+ int64_t now)
57
enum qemu_plugin_mem_rw rw,
58
void *udata)
40
{
59
{
41
CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
60
- struct qemu_plugin_dyn_cb *dyn_cb;
42
CPUTLBDescFast *fast = &env_tlb(env)->f[mmu_idx];
61
+ /*
43
62
+ * Expect that the underlying type for enum qemu_plugin_meminfo_t
44
- tlb_mmu_resize_locked(desc, fast);
63
+ * is either int32_t or uint32_t, aka int or unsigned int.
45
+ tlb_mmu_resize_locked(desc, fast, now);
64
+ */
46
tlb_mmu_flush_locked(desc, fast);
65
+ QEMU_BUILD_BUG_ON(
66
+ !__builtin_types_compatible_p(qemu_plugin_meminfo_t, uint32_t) &&
67
+ !__builtin_types_compatible_p(qemu_plugin_meminfo_t, int32_t));
68
69
- dyn_cb = plugin_get_dyn_cb(arr);
70
+ static TCGHelperInfo info[3] = {
71
+ [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN,
72
+ [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN,
73
+ [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN,
74
+ /*
75
+ * Match qemu_plugin_vcpu_mem_cb_t:
76
+ * void (*)(uint32_t, qemu_plugin_meminfo_t, uint64_t, void *)
77
+ */
78
+ [0 ... 2].typemask =
79
+ (dh_typemask(void, 0) |
80
+ dh_typemask(i32, 1) |
81
+ (__builtin_types_compatible_p(qemu_plugin_meminfo_t, uint32_t)
82
+ ? dh_typemask(i32, 2) : dh_typemask(s32, 2)) |
83
+ dh_typemask(i64, 3) |
84
+ dh_typemask(ptr, 4))
85
+ };
86
+
87
+ struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
88
dyn_cb->userp = udata;
89
- /* Note flags are discarded as unused. */
90
dyn_cb->type = PLUGIN_CB_REGULAR;
91
dyn_cb->rw = rw;
92
dyn_cb->regular.f.vcpu_mem = cb;
93
+
94
+ assert((unsigned)flags < ARRAY_SIZE(info));
95
+ dyn_cb->regular.info = &info[flags];
47
}
96
}
48
97
49
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_by_mmuidx_async_work(CPUState *cpu, run_on_cpu_data data)
98
/*
50
CPUArchState *env = cpu->env_ptr;
51
uint16_t asked = data.host_int;
52
uint16_t all_dirty, work, to_clean;
53
+ int64_t now = get_clock_realtime();
54
55
assert_cpu_is_self(cpu);
56
57
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_by_mmuidx_async_work(CPUState *cpu, run_on_cpu_data data)
58
59
for (work = to_clean; work != 0; work &= work - 1) {
60
int mmu_idx = ctz32(work);
61
- tlb_flush_one_mmuidx_locked(env, mmu_idx);
62
+ tlb_flush_one_mmuidx_locked(env, mmu_idx, now);
63
}
64
65
qemu_spin_unlock(&env_tlb(env)->c.lock);
66
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_page_locked(CPUArchState *env, int midx,
67
tlb_debug("forcing full flush midx %d ("
68
TARGET_FMT_lx "/" TARGET_FMT_lx ")\n",
69
midx, lp_addr, lp_mask);
70
- tlb_flush_one_mmuidx_locked(env, midx);
71
+ tlb_flush_one_mmuidx_locked(env, midx, get_clock_realtime());
72
} else {
73
if (tlb_flush_entry_locked(tlb_entry(env, midx, page), page)) {
74
tlb_n_used_entries_dec(env, midx);
75
--
99
--
76
2.20.1
100
2.34.1
77
78
diff view generated by jsdifflib
[PULL 08/16] cputlb: Make tlb_n_entries private to cputlb.c
[PULL 06/20] plugins: Use emit_before_op for PLUGIN_GEN_AFTER_INSN
1
There are no users of this function outside cputlb.c,
1
Introduce a new plugin_cb op and migrate one operation.
2
and its interface will change in the next patch.
2
By using emit_before_op, we do not need to emit opcodes
3
early and modify them later -- we can simply emit the
4
final set of opcodes once.
3
5
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
6
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
5
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
8
---
9
include/exec/cpu_ldst.h | 5 -----
9
include/tcg/tcg-op-common.h | 1 +
10
accel/tcg/cputlb.c | 5 +++++
10
include/tcg/tcg-opc.h | 1 +
11
2 files changed, 5 insertions(+), 5 deletions(-)
11
accel/tcg/plugin-gen.c | 74 +++++++++++++++++++++----------------
12
tcg/tcg-op.c | 5 +++
13
4 files changed, 50 insertions(+), 31 deletions(-)
12
14
13
diff --git a/include/exec/cpu_ldst.h b/include/exec/cpu_ldst.h
15
diff --git a/include/tcg/tcg-op-common.h b/include/tcg/tcg-op-common.h
14
index XXXXXXX..XXXXXXX 100644
16
index XXXXXXX..XXXXXXX 100644
15
--- a/include/exec/cpu_ldst.h
17
--- a/include/tcg/tcg-op-common.h
16
+++ b/include/exec/cpu_ldst.h
18
+++ b/include/tcg/tcg-op-common.h
17
@@ -XXX,XX +XXX,XX @@ static inline uintptr_t tlb_index(CPUArchState *env, uintptr_t mmu_idx,
19
@@ -XXX,XX +XXX,XX @@ void tcg_gen_goto_tb(unsigned idx);
18
return (addr >> TARGET_PAGE_BITS) & size_mask;
20
*/
21
void tcg_gen_lookup_and_goto_ptr(void);
22
23
+void tcg_gen_plugin_cb(unsigned from);
24
void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr);
25
void tcg_gen_plugin_cb_end(void);
26
27
diff --git a/include/tcg/tcg-opc.h b/include/tcg/tcg-opc.h
28
index XXXXXXX..XXXXXXX 100644
29
--- a/include/tcg/tcg-opc.h
30
+++ b/include/tcg/tcg-opc.h
31
@@ -XXX,XX +XXX,XX @@ DEF(exit_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
32
DEF(goto_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
33
DEF(goto_ptr, 0, 1, 0, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
34
35
+DEF(plugin_cb, 0, 0, 1, TCG_OPF_NOT_PRESENT)
36
DEF(plugin_cb_start, 0, 0, 3, TCG_OPF_NOT_PRESENT)
37
DEF(plugin_cb_end, 0, 0, 0, TCG_OPF_NOT_PRESENT)
38
39
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
40
index XXXXXXX..XXXXXXX 100644
41
--- a/accel/tcg/plugin-gen.c
42
+++ b/accel/tcg/plugin-gen.c
43
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_empty_callback(enum plugin_gen_from from)
44
{
45
switch (from) {
46
case PLUGIN_GEN_AFTER_INSN:
47
- gen_wrapped(from, PLUGIN_GEN_DISABLE_MEM_HELPER,
48
- gen_empty_mem_helper);
49
+ tcg_gen_plugin_cb(from);
50
break;
51
case PLUGIN_GEN_FROM_INSN:
52
/*
53
@@ -XXX,XX +XXX,XX @@ static void inject_mem_enable_helper(struct qemu_plugin_tb *ptb,
54
inject_mem_helper(begin_op, arr);
19
}
55
}
20
56
21
-static inline size_t tlb_n_entries(CPUArchState *env, uintptr_t mmu_idx)
57
-static void inject_mem_disable_helper(struct qemu_plugin_insn *plugin_insn,
58
- TCGOp *begin_op)
22
-{
59
-{
23
- return (env_tlb(env)->f[mmu_idx].mask >> CPU_TLB_ENTRY_BITS) + 1;
60
- if (likely(!plugin_insn->mem_helper)) {
61
- rm_ops(begin_op);
62
- return;
63
- }
64
- inject_mem_helper(begin_op, NULL);
24
-}
65
-}
25
-
66
-
26
/* Find the TLB entry corresponding to the mmu_idx + address pair. */
67
/* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
27
static inline CPUTLBEntry *tlb_entry(CPUArchState *env, uintptr_t mmu_idx,
68
void plugin_gen_disable_mem_helpers(void)
28
target_ulong addr)
69
{
29
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
70
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
71
inject_mem_enable_helper(ptb, insn, begin_op);
72
}
73
74
-static void plugin_gen_disable_mem_helper(struct qemu_plugin_tb *ptb,
75
- TCGOp *begin_op, int insn_idx)
76
+static void gen_disable_mem_helper(struct qemu_plugin_tb *ptb,
77
+ struct qemu_plugin_insn *insn)
78
{
79
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
80
- inject_mem_disable_helper(insn, begin_op);
81
+ if (insn->mem_helper) {
82
+ tcg_gen_st_ptr(tcg_constant_ptr(0), tcg_env,
83
+ offsetof(CPUState, plugin_mem_cbs) -
84
+ offsetof(ArchCPU, env));
85
+ }
86
}
87
88
/* #define DEBUG_PLUGIN_GEN_OPS */
89
@@ -XXX,XX +XXX,XX @@ static void pr_ops(void)
90
91
static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
92
{
93
- TCGOp *op;
94
+ TCGOp *op, *next;
95
int insn_idx = -1;
96
97
pr_ops();
98
99
- QTAILQ_FOREACH(op, &tcg_ctx->ops, link) {
100
+ /*
101
+ * While injecting code, we cannot afford to reuse any ebb temps
102
+ * that might be live within the existing opcode stream.
103
+ * The simplest solution is to release them all and create new.
104
+ */
105
+ memset(tcg_ctx->free_temps, 0, sizeof(tcg_ctx->free_temps));
106
+
107
+ QTAILQ_FOREACH_SAFE(op, &tcg_ctx->ops, link, next) {
108
switch (op->opc) {
109
case INDEX_op_insn_start:
110
insn_idx++;
111
break;
112
+
113
+ case INDEX_op_plugin_cb:
114
+ {
115
+ enum plugin_gen_from from = op->args[0];
116
+ struct qemu_plugin_insn *insn = NULL;
117
+
118
+ if (insn_idx >= 0) {
119
+ insn = g_ptr_array_index(plugin_tb->insns, insn_idx);
120
+ }
121
+
122
+ tcg_ctx->emit_before_op = op;
123
+
124
+ switch (from) {
125
+ case PLUGIN_GEN_AFTER_INSN:
126
+ assert(insn != NULL);
127
+ gen_disable_mem_helper(plugin_tb, insn);
128
+ break;
129
+ default:
130
+ g_assert_not_reached();
131
+ }
132
+
133
+ tcg_ctx->emit_before_op = NULL;
134
+ tcg_op_remove(tcg_ctx, op);
135
+ break;
136
+ }
137
+
138
case INDEX_op_plugin_cb_start:
139
{
140
enum plugin_gen_from from = op->args[0];
141
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
142
143
break;
144
}
145
- case PLUGIN_GEN_AFTER_INSN:
146
- {
147
- g_assert(insn_idx >= 0);
148
-
149
- switch (type) {
150
- case PLUGIN_GEN_DISABLE_MEM_HELPER:
151
- plugin_gen_disable_mem_helper(plugin_tb, op, insn_idx);
152
- break;
153
- default:
154
- g_assert_not_reached();
155
- }
156
- break;
157
- }
158
default:
159
g_assert_not_reached();
160
}
161
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
30
index XXXXXXX..XXXXXXX 100644
162
index XXXXXXX..XXXXXXX 100644
31
--- a/accel/tcg/cputlb.c
163
--- a/tcg/tcg-op.c
32
+++ b/accel/tcg/cputlb.c
164
+++ b/tcg/tcg-op.c
33
@@ -XXX,XX +XXX,XX @@ QEMU_BUILD_BUG_ON(sizeof(target_ulong) > sizeof(run_on_cpu_data));
165
@@ -XXX,XX +XXX,XX @@ void tcg_gen_mb(TCGBar mb_type)
34
QEMU_BUILD_BUG_ON(NB_MMU_MODES > 16);
166
}
35
#define ALL_MMUIDX_BITS ((1 << NB_MMU_MODES) - 1)
167
}
36
168
37
+static inline size_t tlb_n_entries(CPUArchState *env, uintptr_t mmu_idx)
169
+void tcg_gen_plugin_cb(unsigned from)
38
+{
170
+{
39
+ return (env_tlb(env)->f[mmu_idx].mask >> CPU_TLB_ENTRY_BITS) + 1;
171
+ tcg_gen_op1(INDEX_op_plugin_cb, from);
40
+}
172
+}
41
+
173
+
42
static inline size_t sizeof_tlb(CPUArchState *env, uintptr_t mmu_idx)
174
void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr)
43
{
175
{
44
return env_tlb(env)->f[mmu_idx].mask + (1 << CPU_TLB_ENTRY_BITS);
176
tcg_gen_op3(INDEX_op_plugin_cb_start, from, type, wr);
45
--
177
--
46
2.20.1
178
2.34.1
47
48
diff view generated by jsdifflib
[PULL 01/16] cputlb: Handle NB_MMU_MODES > TARGET_PAGE_BITS_MIN
[PULL 07/20] plugins: Use emit_before_op for PLUGIN_GEN_FROM_TB
1
In target/arm we will shortly have "too many" mmu_idx.
1
By having the qemu_plugin_cb_flags be recorded in the TCGHelperInfo,
2
The current minimum barrier is caused by the way in which
2
we no longer need to distinguish PLUGIN_CB_REGULAR from
3
tlb_flush_page_by_mmuidx is coded.
3
PLUGIN_CB_REGULAR_R, so place all TB callbacks in the same queue.
4
4
5
We can remove this limitation by allocating memory for
5
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
6
consumption by the worker. Let us assume that this is
7
the unlikely case, as will be the case for the majority
8
of targets which have so far satisfied the BUILD_BUG_ON,
9
and only allocate memory when necessary.
10
11
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
12
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
13
---
7
---
14
accel/tcg/cputlb.c | 167 +++++++++++++++++++++++++++++++++++----------
8
accel/tcg/plugin-gen.c | 96 +++++++++++++++++++++++++-----------------
15
1 file changed, 132 insertions(+), 35 deletions(-)
9
plugins/api.c | 6 +--
10
2 files changed, 58 insertions(+), 44 deletions(-)
16
11
17
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
12
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
18
index XXXXXXX..XXXXXXX 100644
13
index XXXXXXX..XXXXXXX 100644
19
--- a/accel/tcg/cputlb.c
14
--- a/accel/tcg/plugin-gen.c
20
+++ b/accel/tcg/cputlb.c
15
+++ b/accel/tcg/plugin-gen.c
21
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_page_locked(CPUArchState *env, int midx,
16
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_empty_callback(enum plugin_gen_from from)
17
{
18
switch (from) {
19
case PLUGIN_GEN_AFTER_INSN:
20
+ case PLUGIN_GEN_FROM_TB:
21
tcg_gen_plugin_cb(from);
22
break;
23
case PLUGIN_GEN_FROM_INSN:
24
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_empty_callback(enum plugin_gen_from from)
25
*/
26
gen_wrapped(from, PLUGIN_GEN_ENABLE_MEM_HELPER,
27
gen_empty_mem_helper);
28
- /* fall through */
29
- case PLUGIN_GEN_FROM_TB:
30
gen_wrapped(from, PLUGIN_GEN_CB_UDATA, gen_empty_udata_cb_no_rwg);
31
gen_wrapped(from, PLUGIN_GEN_CB_UDATA_R, gen_empty_udata_cb_no_wg);
32
gen_wrapped(from, PLUGIN_GEN_CB_INLINE, gen_empty_inline_cb);
33
@@ -XXX,XX +XXX,XX @@ void plugin_gen_disable_mem_helpers(void)
34
offsetof(CPUState, plugin_mem_cbs) - offsetof(ArchCPU, env));
35
}
36
37
-static void plugin_gen_tb_udata(const struct qemu_plugin_tb *ptb,
38
- TCGOp *begin_op)
39
-{
40
- inject_udata_cb(ptb->cbs[PLUGIN_CB_REGULAR], begin_op);
41
-}
42
-
43
-static void plugin_gen_tb_udata_r(const struct qemu_plugin_tb *ptb,
44
- TCGOp *begin_op)
45
-{
46
- inject_udata_cb(ptb->cbs[PLUGIN_CB_REGULAR_R], begin_op);
47
-}
48
-
49
-static void plugin_gen_tb_inline(const struct qemu_plugin_tb *ptb,
50
- TCGOp *begin_op)
51
-{
52
- inject_inline_cb(ptb->cbs[PLUGIN_CB_INLINE], begin_op, op_ok);
53
-}
54
-
55
static void plugin_gen_insn_udata(const struct qemu_plugin_tb *ptb,
56
TCGOp *begin_op, int insn_idx)
57
{
58
@@ -XXX,XX +XXX,XX @@ static void gen_disable_mem_helper(struct qemu_plugin_tb *ptb,
22
}
59
}
23
}
60
}
24
61
25
-/* As we are going to hijack the bottom bits of the page address for a
62
+static void gen_udata_cb(struct qemu_plugin_dyn_cb *cb)
26
- * mmuidx bit mask we need to fail to build if we can't do that
27
+/**
28
+ * tlb_flush_page_by_mmuidx_async_0:
29
+ * @cpu: cpu on which to flush
30
+ * @addr: page of virtual address to flush
31
+ * @idxmap: set of mmu_idx to flush
32
+ *
33
+ * Helper for tlb_flush_page_by_mmuidx and friends, flush one page
34
+ * at @addr from the tlbs indicated by @idxmap from @cpu.
35
*/
36
-QEMU_BUILD_BUG_ON(NB_MMU_MODES > TARGET_PAGE_BITS_MIN);
37
-
38
-static void tlb_flush_page_by_mmuidx_async_work(CPUState *cpu,
39
- run_on_cpu_data data)
40
+static void tlb_flush_page_by_mmuidx_async_0(CPUState *cpu,
41
+ target_ulong addr,
42
+ uint16_t idxmap)
43
{
44
CPUArchState *env = cpu->env_ptr;
45
- target_ulong addr_and_mmuidx = (target_ulong) data.target_ptr;
46
- target_ulong addr = addr_and_mmuidx & TARGET_PAGE_MASK;
47
- unsigned long mmu_idx_bitmap = addr_and_mmuidx & ALL_MMUIDX_BITS;
48
int mmu_idx;
49
50
assert_cpu_is_self(cpu);
51
52
- tlb_debug("page addr:" TARGET_FMT_lx " mmu_map:0x%lx\n",
53
- addr, mmu_idx_bitmap);
54
+ tlb_debug("page addr:" TARGET_FMT_lx " mmu_map:0x%x\n", addr, idxmap);
55
56
qemu_spin_lock(&env_tlb(env)->c.lock);
57
for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
58
- if (test_bit(mmu_idx, &mmu_idx_bitmap)) {
59
+ if ((idxmap >> mmu_idx) & 1) {
60
tlb_flush_page_locked(env, mmu_idx, addr);
61
}
62
}
63
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_page_by_mmuidx_async_work(CPUState *cpu,
64
tb_flush_jmp_cache(cpu, addr);
65
}
66
67
+/**
68
+ * tlb_flush_page_by_mmuidx_async_1:
69
+ * @cpu: cpu on which to flush
70
+ * @data: encoded addr + idxmap
71
+ *
72
+ * Helper for tlb_flush_page_by_mmuidx and friends, called through
73
+ * async_run_on_cpu. The idxmap parameter is encoded in the page
74
+ * offset of the target_ptr field. This limits the set of mmu_idx
75
+ * that can be passed via this method.
76
+ */
77
+static void tlb_flush_page_by_mmuidx_async_1(CPUState *cpu,
78
+ run_on_cpu_data data)
79
+{
63
+{
80
+ target_ulong addr_and_idxmap = (target_ulong) data.target_ptr;
64
+ TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
81
+ target_ulong addr = addr_and_idxmap & TARGET_PAGE_MASK;
82
+ uint16_t idxmap = addr_and_idxmap & ~TARGET_PAGE_MASK;
83
+
65
+
84
+ tlb_flush_page_by_mmuidx_async_0(cpu, addr, idxmap);
66
+ tcg_gen_ld_i32(cpu_index, tcg_env,
67
+ -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
68
+ tcg_gen_call2(cb->regular.f.vcpu_udata, cb->regular.info, NULL,
69
+ tcgv_i32_temp(cpu_index),
70
+ tcgv_ptr_temp(tcg_constant_ptr(cb->userp)));
71
+ tcg_temp_free_i32(cpu_index);
85
+}
72
+}
86
+
73
+
87
+typedef struct {
74
+static void gen_inline_cb(struct qemu_plugin_dyn_cb *cb)
88
+ target_ulong addr;
75
+{
89
+ uint16_t idxmap;
76
+ GArray *arr = cb->inline_insn.entry.score->data;
90
+} TLBFlushPageByMMUIdxData;
77
+ size_t offset = cb->inline_insn.entry.offset;
78
+ TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
79
+ TCGv_i64 val = tcg_temp_ebb_new_i64();
80
+ TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
91
+
81
+
92
+/**
82
+ tcg_gen_ld_i32(cpu_index, tcg_env,
93
+ * tlb_flush_page_by_mmuidx_async_2:
83
+ -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
94
+ * @cpu: cpu on which to flush
84
+ tcg_gen_muli_i32(cpu_index, cpu_index, g_array_get_element_size(arr));
95
+ * @data: allocated addr + idxmap
85
+ tcg_gen_ext_i32_ptr(ptr, cpu_index);
96
+ *
86
+ tcg_temp_free_i32(cpu_index);
97
+ * Helper for tlb_flush_page_by_mmuidx and friends, called through
98
+ * async_run_on_cpu. The addr+idxmap parameters are stored in a
99
+ * TLBFlushPageByMMUIdxData structure that has been allocated
100
+ * specifically for this helper. Free the structure when done.
101
+ */
102
+static void tlb_flush_page_by_mmuidx_async_2(CPUState *cpu,
103
+ run_on_cpu_data data)
104
+{
105
+ TLBFlushPageByMMUIdxData *d = data.host_ptr;
106
+
87
+
107
+ tlb_flush_page_by_mmuidx_async_0(cpu, d->addr, d->idxmap);
88
+ tcg_gen_addi_ptr(ptr, ptr, (intptr_t)arr->data);
108
+ g_free(d);
89
+ tcg_gen_ld_i64(val, ptr, offset);
90
+ tcg_gen_addi_i64(val, val, cb->inline_insn.imm);
91
+ tcg_gen_st_i64(val, ptr, offset);
92
+
93
+ tcg_temp_free_i64(val);
94
+ tcg_temp_free_ptr(ptr);
109
+}
95
+}
110
+
96
+
111
void tlb_flush_page_by_mmuidx(CPUState *cpu, target_ulong addr, uint16_t idxmap)
97
/* #define DEBUG_PLUGIN_GEN_OPS */
98
static void pr_ops(void)
112
{
99
{
113
- target_ulong addr_and_mmu_idx;
100
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
101
{
102
enum plugin_gen_from from = op->args[0];
103
struct qemu_plugin_insn *insn = NULL;
104
+ const GArray *cbs;
105
+ int i, n;
106
107
if (insn_idx >= 0) {
108
insn = g_ptr_array_index(plugin_tb->insns, insn_idx);
109
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
110
assert(insn != NULL);
111
gen_disable_mem_helper(plugin_tb, insn);
112
break;
113
+
114
+ case PLUGIN_GEN_FROM_TB:
115
+ assert(insn == NULL);
116
+
117
+ cbs = plugin_tb->cbs[PLUGIN_CB_REGULAR];
118
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
119
+ struct qemu_plugin_dyn_cb *cb =
120
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
121
+ gen_udata_cb(cb);
122
+ }
123
+
124
+ cbs = plugin_tb->cbs[PLUGIN_CB_INLINE];
125
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
126
+ struct qemu_plugin_dyn_cb *cb =
127
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
128
+ gen_inline_cb(cb);
129
+ }
130
+ break;
131
+
132
default:
133
g_assert_not_reached();
134
}
135
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
136
enum plugin_gen_cb type = op->args[1];
137
138
switch (from) {
139
- case PLUGIN_GEN_FROM_TB:
140
- {
141
- g_assert(insn_idx == -1);
114
-
142
-
115
tlb_debug("addr: "TARGET_FMT_lx" mmu_idx:%" PRIx16 "\n", addr, idxmap);
143
- switch (type) {
116
144
- case PLUGIN_GEN_CB_UDATA:
117
/* This should already be page aligned */
145
- plugin_gen_tb_udata(plugin_tb, op);
118
- addr_and_mmu_idx = addr & TARGET_PAGE_MASK;
146
- break;
119
- addr_and_mmu_idx |= idxmap;
147
- case PLUGIN_GEN_CB_UDATA_R:
120
+ addr &= TARGET_PAGE_MASK;
148
- plugin_gen_tb_udata_r(plugin_tb, op);
121
149
- break;
122
- if (!qemu_cpu_is_self(cpu)) {
150
- case PLUGIN_GEN_CB_INLINE:
123
- async_run_on_cpu(cpu, tlb_flush_page_by_mmuidx_async_work,
151
- plugin_gen_tb_inline(plugin_tb, op);
124
- RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
152
- break;
125
+ if (qemu_cpu_is_self(cpu)) {
153
- default:
126
+ tlb_flush_page_by_mmuidx_async_0(cpu, addr, idxmap);
154
- g_assert_not_reached();
127
+ } else if (idxmap < TARGET_PAGE_SIZE) {
155
- }
128
+ /*
156
- break;
129
+ * Most targets have only a few mmu_idx. In the case where
157
- }
130
+ * we can stuff idxmap into the low TARGET_PAGE_BITS, avoid
158
case PLUGIN_GEN_FROM_INSN:
131
+ * allocating memory for this operation.
159
{
132
+ */
160
g_assert(insn_idx >= 0);
133
+ async_run_on_cpu(cpu, tlb_flush_page_by_mmuidx_async_1,
161
diff --git a/plugins/api.c b/plugins/api.c
134
+ RUN_ON_CPU_TARGET_PTR(addr | idxmap));
162
index XXXXXXX..XXXXXXX 100644
135
} else {
163
--- a/plugins/api.c
136
- tlb_flush_page_by_mmuidx_async_work(
164
+++ b/plugins/api.c
137
- cpu, RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
165
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
138
+ TLBFlushPageByMMUIdxData *d = g_new(TLBFlushPageByMMUIdxData, 1);
166
void *udata)
139
+
167
{
140
+ /* Otherwise allocate a structure, freed by the worker. */
168
if (!tb->mem_only) {
141
+ d->addr = addr;
169
- int index = flags == QEMU_PLUGIN_CB_R_REGS ||
142
+ d->idxmap = idxmap;
170
- flags == QEMU_PLUGIN_CB_RW_REGS ?
143
+ async_run_on_cpu(cpu, tlb_flush_page_by_mmuidx_async_2,
171
- PLUGIN_CB_REGULAR_R : PLUGIN_CB_REGULAR;
144
+ RUN_ON_CPU_HOST_PTR(d));
172
-
173
- plugin_register_dyn_cb__udata(&tb->cbs[index],
174
+ plugin_register_dyn_cb__udata(&tb->cbs[PLUGIN_CB_REGULAR],
175
cb, flags, udata);
145
}
176
}
146
}
177
}
147
148
@@ -XXX,XX +XXX,XX @@ void tlb_flush_page(CPUState *cpu, target_ulong addr)
149
void tlb_flush_page_by_mmuidx_all_cpus(CPUState *src_cpu, target_ulong addr,
150
uint16_t idxmap)
151
{
152
- const run_on_cpu_func fn = tlb_flush_page_by_mmuidx_async_work;
153
- target_ulong addr_and_mmu_idx;
154
-
155
tlb_debug("addr: "TARGET_FMT_lx" mmu_idx:%"PRIx16"\n", addr, idxmap);
156
157
/* This should already be page aligned */
158
- addr_and_mmu_idx = addr & TARGET_PAGE_MASK;
159
- addr_and_mmu_idx |= idxmap;
160
+ addr &= TARGET_PAGE_MASK;
161
162
- flush_all_helper(src_cpu, fn, RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
163
- fn(src_cpu, RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
164
+ /*
165
+ * Allocate memory to hold addr+idxmap only when needed.
166
+ * See tlb_flush_page_by_mmuidx for details.
167
+ */
168
+ if (idxmap < TARGET_PAGE_SIZE) {
169
+ flush_all_helper(src_cpu, tlb_flush_page_by_mmuidx_async_1,
170
+ RUN_ON_CPU_TARGET_PTR(addr | idxmap));
171
+ } else {
172
+ CPUState *dst_cpu;
173
+
174
+ /* Allocate a separate data block for each destination cpu. */
175
+ CPU_FOREACH(dst_cpu) {
176
+ if (dst_cpu != src_cpu) {
177
+ TLBFlushPageByMMUIdxData *d
178
+ = g_new(TLBFlushPageByMMUIdxData, 1);
179
+
180
+ d->addr = addr;
181
+ d->idxmap = idxmap;
182
+ async_run_on_cpu(dst_cpu, tlb_flush_page_by_mmuidx_async_2,
183
+ RUN_ON_CPU_HOST_PTR(d));
184
+ }
185
+ }
186
+ }
187
+
188
+ tlb_flush_page_by_mmuidx_async_0(src_cpu, addr, idxmap);
189
}
190
191
void tlb_flush_page_all_cpus(CPUState *src, target_ulong addr)
192
@@ -XXX,XX +XXX,XX @@ void tlb_flush_page_by_mmuidx_all_cpus_synced(CPUState *src_cpu,
193
target_ulong addr,
194
uint16_t idxmap)
195
{
196
- const run_on_cpu_func fn = tlb_flush_page_by_mmuidx_async_work;
197
- target_ulong addr_and_mmu_idx;
198
-
199
tlb_debug("addr: "TARGET_FMT_lx" mmu_idx:%"PRIx16"\n", addr, idxmap);
200
201
/* This should already be page aligned */
202
- addr_and_mmu_idx = addr & TARGET_PAGE_MASK;
203
- addr_and_mmu_idx |= idxmap;
204
+ addr &= TARGET_PAGE_MASK;
205
206
- flush_all_helper(src_cpu, fn, RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
207
- async_safe_run_on_cpu(src_cpu, fn, RUN_ON_CPU_TARGET_PTR(addr_and_mmu_idx));
208
+ /*
209
+ * Allocate memory to hold addr+idxmap only when needed.
210
+ * See tlb_flush_page_by_mmuidx for details.
211
+ */
212
+ if (idxmap < TARGET_PAGE_SIZE) {
213
+ flush_all_helper(src_cpu, tlb_flush_page_by_mmuidx_async_1,
214
+ RUN_ON_CPU_TARGET_PTR(addr | idxmap));
215
+ async_safe_run_on_cpu(src_cpu, tlb_flush_page_by_mmuidx_async_1,
216
+ RUN_ON_CPU_TARGET_PTR(addr | idxmap));
217
+ } else {
218
+ CPUState *dst_cpu;
219
+ TLBFlushPageByMMUIdxData *d;
220
+
221
+ /* Allocate a separate data block for each destination cpu. */
222
+ CPU_FOREACH(dst_cpu) {
223
+ if (dst_cpu != src_cpu) {
224
+ d = g_new(TLBFlushPageByMMUIdxData, 1);
225
+ d->addr = addr;
226
+ d->idxmap = idxmap;
227
+ async_run_on_cpu(dst_cpu, tlb_flush_page_by_mmuidx_async_2,
228
+ RUN_ON_CPU_HOST_PTR(d));
229
+ }
230
+ }
231
+
232
+ d = g_new(TLBFlushPageByMMUIdxData, 1);
233
+ d->addr = addr;
234
+ d->idxmap = idxmap;
235
+ async_safe_run_on_cpu(src_cpu, tlb_flush_page_by_mmuidx_async_2,
236
+ RUN_ON_CPU_HOST_PTR(d));
237
+ }
238
}
239
240
void tlb_flush_page_all_cpus_synced(CPUState *src, target_ulong addr)
241
--
178
--
242
2.20.1
179
2.34.1
243
244
diff view generated by jsdifflib
[PULL 04/16] vl: Reduce scope of variables in configure_accelerators
[PULL 08/20] plugins: Add PLUGIN_GEN_AFTER_TB
1
The accel_list and tmp variables are only used when manufacturing
1
Delay test of plugin_tb->mem_helper until the inject pass.
2
-machine accel, options based on -accel.
3
2
4
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
3
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
5
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
6
Reviewed by: Aleksandar Markovic <amarkovic@wavecomp.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
5
---
9
vl.c | 3 ++-
6
accel/tcg/plugin-gen.c | 37 ++++++++++++++++---------------------
10
1 file changed, 2 insertions(+), 1 deletion(-)
7
1 file changed, 16 insertions(+), 21 deletions(-)
11
8
12
diff --git a/vl.c b/vl.c
9
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
13
index XXXXXXX..XXXXXXX 100644
10
index XXXXXXX..XXXXXXX 100644
14
--- a/vl.c
11
--- a/accel/tcg/plugin-gen.c
15
+++ b/vl.c
12
+++ b/accel/tcg/plugin-gen.c
16
@@ -XXX,XX +XXX,XX @@ static int do_configure_accelerator(void *opaque, QemuOpts *opts, Error **errp)
13
@@ -XXX,XX +XXX,XX @@ enum plugin_gen_from {
17
static void configure_accelerators(const char *progname)
14
PLUGIN_GEN_FROM_INSN,
15
PLUGIN_GEN_FROM_MEM,
16
PLUGIN_GEN_AFTER_INSN,
17
+ PLUGIN_GEN_AFTER_TB,
18
PLUGIN_GEN_N_FROMS,
19
};
20
21
@@ -XXX,XX +XXX,XX @@ static void inject_mem_enable_helper(struct qemu_plugin_tb *ptb,
22
/* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
23
void plugin_gen_disable_mem_helpers(void)
18
{
24
{
19
const char *accel;
25
- /*
20
- char **accel_list, **tmp;
26
- * We could emit the clearing unconditionally and be done. However, this can
21
bool init_failed = false;
27
- * be wasteful if for instance plugins don't track memory accesses, or if
22
28
- * most TBs don't use helpers. Instead, emit the clearing iff the TB calls
23
qemu_opts_foreach(qemu_find_opts("icount"),
29
- * helpers that might access guest memory.
24
@@ -XXX,XX +XXX,XX @@ static void configure_accelerators(const char *progname)
30
- *
25
31
- * Note: we do not reset plugin_tb->mem_helper here; a TB might have several
26
accel = qemu_opt_get(qemu_get_machine_opts(), "accel");
32
- * exit points, and we want to emit the clearing from all of them.
27
if (QTAILQ_EMPTY(&qemu_accel_opts.head)) {
33
- */
28
+ char **accel_list, **tmp;
34
- if (!tcg_ctx->plugin_tb->mem_helper) {
35
- return;
36
+ if (tcg_ctx->plugin_insn) {
37
+ tcg_gen_plugin_cb(PLUGIN_GEN_AFTER_TB);
38
}
39
- tcg_gen_st_ptr(tcg_constant_ptr(NULL), tcg_env,
40
- offsetof(CPUState, plugin_mem_cbs) - offsetof(ArchCPU, env));
41
}
42
43
static void plugin_gen_insn_udata(const struct qemu_plugin_tb *ptb,
44
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
45
inject_mem_enable_helper(ptb, insn, begin_op);
46
}
47
48
-static void gen_disable_mem_helper(struct qemu_plugin_tb *ptb,
49
- struct qemu_plugin_insn *insn)
50
+static void gen_disable_mem_helper(void)
51
{
52
- if (insn->mem_helper) {
53
- tcg_gen_st_ptr(tcg_constant_ptr(0), tcg_env,
54
- offsetof(CPUState, plugin_mem_cbs) -
55
- offsetof(ArchCPU, env));
56
- }
57
+ tcg_gen_st_ptr(tcg_constant_ptr(0), tcg_env,
58
+ offsetof(CPUState, plugin_mem_cbs) -
59
+ offsetof(ArchCPU, env));
60
}
61
62
static void gen_udata_cb(struct qemu_plugin_dyn_cb *cb)
63
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
64
tcg_ctx->emit_before_op = op;
65
66
switch (from) {
67
+ case PLUGIN_GEN_AFTER_TB:
68
+ if (plugin_tb->mem_helper) {
69
+ gen_disable_mem_helper();
70
+ }
71
+ break;
29
+
72
+
30
if (accel == NULL) {
73
case PLUGIN_GEN_AFTER_INSN:
31
/* Select the default accelerator */
74
assert(insn != NULL);
32
if (!accel_find("tcg") && !accel_find("kvm")) {
75
- gen_disable_mem_helper(plugin_tb, insn);
76
+ if (insn->mem_helper) {
77
+ gen_disable_mem_helper();
78
+ }
79
break;
80
81
case PLUGIN_GEN_FROM_TB:
33
--
82
--
34
2.20.1
83
2.34.1
35
36
diff view generated by jsdifflib
[PULL 03/16] vl: Remove unused variable in configure_accelerators
[PULL 09/20] plugins: Use emit_before_op for PLUGIN_GEN_FROM_INSN
1
The accel_initialised variable no longer has any setters.
1
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
2
3
Fixes: 6f6e1698a68c
4
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
5
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
7
Reviewed by: Aleksandar Markovic <amarkovic@wavecomp.com>
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
9
---
3
---
10
vl.c | 3 +--
4
include/qemu/plugin.h | 1 -
11
1 file changed, 1 insertion(+), 2 deletions(-)
5
accel/tcg/plugin-gen.c | 286 ++++++++++-------------------------------
6
plugins/api.c | 8 +-
7
3 files changed, 67 insertions(+), 228 deletions(-)
12
8
13
diff --git a/vl.c b/vl.c
9
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
14
index XXXXXXX..XXXXXXX 100644
10
index XXXXXXX..XXXXXXX 100644
15
--- a/vl.c
11
--- a/include/qemu/plugin.h
16
+++ b/vl.c
12
+++ b/include/qemu/plugin.h
17
@@ -XXX,XX +XXX,XX @@ static void configure_accelerators(const char *progname)
13
@@ -XXX,XX +XXX,XX @@ enum plugin_dyn_cb_type {
18
{
14
19
const char *accel;
15
enum plugin_dyn_cb_subtype {
20
char **accel_list, **tmp;
16
PLUGIN_CB_REGULAR,
21
- bool accel_initialised = false;
17
- PLUGIN_CB_REGULAR_R,
22
bool init_failed = false;
18
PLUGIN_CB_INLINE,
23
19
PLUGIN_N_CB_SUBTYPES,
24
qemu_opts_foreach(qemu_find_opts("icount"),
20
};
25
@@ -XXX,XX +XXX,XX @@ static void configure_accelerators(const char *progname)
21
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
26
22
index XXXXXXX..XXXXXXX 100644
27
accel_list = g_strsplit(accel, ":", 0);
23
--- a/accel/tcg/plugin-gen.c
28
24
+++ b/accel/tcg/plugin-gen.c
29
- for (tmp = accel_list; !accel_initialised && tmp && *tmp; tmp++) {
25
@@ -XXX,XX +XXX,XX @@ void HELPER(plugin_vcpu_mem_cb)(unsigned int vcpu_index,
30
+ for (tmp = accel_list; tmp && *tmp; tmp++) {
26
void *userdata)
31
/*
27
{ }
32
* Filter invalid accelerators here, to prevent obscenities
28
33
* such as "-machine accel=tcg,,thread=single".
29
-static void gen_empty_udata_cb(void (*gen_helper)(TCGv_i32, TCGv_ptr))
30
-{
31
- TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
32
- TCGv_ptr udata = tcg_temp_ebb_new_ptr();
33
-
34
- tcg_gen_movi_ptr(udata, 0);
35
- tcg_gen_ld_i32(cpu_index, tcg_env,
36
- -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
37
- gen_helper(cpu_index, udata);
38
-
39
- tcg_temp_free_ptr(udata);
40
- tcg_temp_free_i32(cpu_index);
41
-}
42
-
43
-static void gen_empty_udata_cb_no_wg(void)
44
-{
45
- gen_empty_udata_cb(gen_helper_plugin_vcpu_udata_cb_no_wg);
46
-}
47
-
48
-static void gen_empty_udata_cb_no_rwg(void)
49
-{
50
- gen_empty_udata_cb(gen_helper_plugin_vcpu_udata_cb_no_rwg);
51
-}
52
-
53
/*
54
* For now we only support addi_i64.
55
* When we support more ops, we can generate one empty inline cb for each.
56
@@ -XXX,XX +XXX,XX @@ static void gen_empty_mem_cb(TCGv_i64 addr, uint32_t info)
57
tcg_temp_free_i32(cpu_index);
58
}
59
60
-/*
61
- * Share the same function for enable/disable. When enabling, the NULL
62
- * pointer will be overwritten later.
63
- */
64
-static void gen_empty_mem_helper(void)
65
-{
66
- TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
67
-
68
- tcg_gen_movi_ptr(ptr, 0);
69
- tcg_gen_st_ptr(ptr, tcg_env, offsetof(CPUState, plugin_mem_cbs) -
70
- offsetof(ArchCPU, env));
71
- tcg_temp_free_ptr(ptr);
72
-}
73
-
74
static void gen_plugin_cb_start(enum plugin_gen_from from,
75
enum plugin_gen_cb type, unsigned wr)
76
{
77
tcg_gen_plugin_cb_start(from, type, wr);
78
}
79
80
-static void gen_wrapped(enum plugin_gen_from from,
81
- enum plugin_gen_cb type, void (*func)(void))
82
-{
83
- gen_plugin_cb_start(from, type, 0);
84
- func();
85
- tcg_gen_plugin_cb_end();
86
-}
87
-
88
static void plugin_gen_empty_callback(enum plugin_gen_from from)
89
{
90
switch (from) {
91
case PLUGIN_GEN_AFTER_INSN:
92
case PLUGIN_GEN_FROM_TB:
93
- tcg_gen_plugin_cb(from);
94
- break;
95
case PLUGIN_GEN_FROM_INSN:
96
- /*
97
- * Note: plugin_gen_inject() relies on ENABLE_MEM_HELPER being
98
- * the first callback of an instruction
99
- */
100
- gen_wrapped(from, PLUGIN_GEN_ENABLE_MEM_HELPER,
101
- gen_empty_mem_helper);
102
- gen_wrapped(from, PLUGIN_GEN_CB_UDATA, gen_empty_udata_cb_no_rwg);
103
- gen_wrapped(from, PLUGIN_GEN_CB_UDATA_R, gen_empty_udata_cb_no_wg);
104
- gen_wrapped(from, PLUGIN_GEN_CB_INLINE, gen_empty_inline_cb);
105
+ tcg_gen_plugin_cb(from);
106
break;
107
default:
108
g_assert_not_reached();
109
@@ -XXX,XX +XXX,XX @@ static TCGOp *copy_mul_i32(TCGOp **begin_op, TCGOp *op, uint32_t v)
110
return op;
111
}
112
113
-static TCGOp *copy_st_ptr(TCGOp **begin_op, TCGOp *op)
114
-{
115
- if (UINTPTR_MAX == UINT32_MAX) {
116
- /* st_i32 */
117
- op = copy_op(begin_op, op, INDEX_op_st_i32);
118
- } else {
119
- /* st_i64 */
120
- op = copy_st_i64(begin_op, op);
121
- }
122
- return op;
123
-}
124
-
125
static TCGOp *copy_call(TCGOp **begin_op, TCGOp *op, void *func, int *cb_idx)
126
{
127
TCGOp *old_op;
128
@@ -XXX,XX +XXX,XX @@ static TCGOp *copy_call(TCGOp **begin_op, TCGOp *op, void *func, int *cb_idx)
129
return op;
130
}
131
132
-/*
133
- * When we append/replace ops here we are sensitive to changing patterns of
134
- * TCGOps generated by the tcg_gen_FOO calls when we generated the
135
- * empty callbacks. This will assert very quickly in a debug build as
136
- * we assert the ops we are replacing are the correct ones.
137
- */
138
-static TCGOp *append_udata_cb(const struct qemu_plugin_dyn_cb *cb,
139
- TCGOp *begin_op, TCGOp *op, int *cb_idx)
140
-{
141
- /* const_ptr */
142
- op = copy_const_ptr(&begin_op, op, cb->userp);
143
-
144
- /* copy the ld_i32, but note that we only have to copy it once */
145
- if (*cb_idx == -1) {
146
- op = copy_op(&begin_op, op, INDEX_op_ld_i32);
147
- } else {
148
- begin_op = QTAILQ_NEXT(begin_op, link);
149
- tcg_debug_assert(begin_op && begin_op->opc == INDEX_op_ld_i32);
150
- }
151
-
152
- /* call */
153
- op = copy_call(&begin_op, op, cb->regular.f.vcpu_udata, cb_idx);
154
-
155
- return op;
156
-}
157
-
158
static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
159
TCGOp *begin_op, TCGOp *op,
160
int *unused)
161
@@ -XXX,XX +XXX,XX @@ typedef TCGOp *(*inject_fn)(const struct qemu_plugin_dyn_cb *cb,
162
TCGOp *begin_op, TCGOp *op, int *intp);
163
typedef bool (*op_ok_fn)(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb);
164
165
-static bool op_ok(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb)
166
-{
167
- return true;
168
-}
169
-
170
static bool op_rw(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb)
171
{
172
int w;
173
@@ -XXX,XX +XXX,XX @@ static void inject_cb_type(const GArray *cbs, TCGOp *begin_op,
174
rm_ops_range(begin_op, end_op);
175
}
176
177
-static void
178
-inject_udata_cb(const GArray *cbs, TCGOp *begin_op)
179
-{
180
- inject_cb_type(cbs, begin_op, append_udata_cb, op_ok);
181
-}
182
-
183
static void
184
inject_inline_cb(const GArray *cbs, TCGOp *begin_op, op_ok_fn ok)
185
{
186
@@ -XXX,XX +XXX,XX @@ inject_mem_cb(const GArray *cbs, TCGOp *begin_op)
187
inject_cb_type(cbs, begin_op, append_mem_cb, op_rw);
188
}
189
190
-/* we could change the ops in place, but we can reuse more code by copying */
191
-static void inject_mem_helper(TCGOp *begin_op, GArray *arr)
192
-{
193
- TCGOp *orig_op = begin_op;
194
- TCGOp *end_op;
195
- TCGOp *op;
196
-
197
- end_op = find_op(begin_op, INDEX_op_plugin_cb_end);
198
- tcg_debug_assert(end_op);
199
-
200
- /* const ptr */
201
- op = copy_const_ptr(&begin_op, end_op, arr);
202
-
203
- /* st_ptr */
204
- op = copy_st_ptr(&begin_op, op);
205
-
206
- rm_ops_range(orig_op, end_op);
207
-}
208
-
209
-/*
210
- * Tracking memory accesses performed from helpers requires extra work.
211
- * If an instruction is emulated with helpers, we do two things:
212
- * (1) copy the CB descriptors, and keep track of it so that they can be
213
- * freed later on, and (2) point CPUState.plugin_mem_cbs to the descriptors, so
214
- * that we can read them at run-time (i.e. when the helper executes).
215
- * This run-time access is performed from qemu_plugin_vcpu_mem_cb.
216
- *
217
- * Note that plugin_gen_disable_mem_helpers undoes (2). Since it
218
- * is possible that the code we generate after the instruction is
219
- * dead, we also add checks before generating tb_exit etc.
220
- */
221
-static void inject_mem_enable_helper(struct qemu_plugin_tb *ptb,
222
- struct qemu_plugin_insn *plugin_insn,
223
- TCGOp *begin_op)
224
-{
225
- GArray *cbs[2];
226
- GArray *arr;
227
- size_t n_cbs, i;
228
-
229
- cbs[0] = plugin_insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
230
- cbs[1] = plugin_insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
231
-
232
- n_cbs = 0;
233
- for (i = 0; i < ARRAY_SIZE(cbs); i++) {
234
- n_cbs += cbs[i]->len;
235
- }
236
-
237
- plugin_insn->mem_helper = plugin_insn->calls_helpers && n_cbs;
238
- if (likely(!plugin_insn->mem_helper)) {
239
- rm_ops(begin_op);
240
- return;
241
- }
242
- ptb->mem_helper = true;
243
-
244
- arr = g_array_sized_new(false, false,
245
- sizeof(struct qemu_plugin_dyn_cb), n_cbs);
246
-
247
- for (i = 0; i < ARRAY_SIZE(cbs); i++) {
248
- g_array_append_vals(arr, cbs[i]->data, cbs[i]->len);
249
- }
250
-
251
- qemu_plugin_add_dyn_cb_arr(arr);
252
- inject_mem_helper(begin_op, arr);
253
-}
254
-
255
/* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
256
void plugin_gen_disable_mem_helpers(void)
257
{
258
@@ -XXX,XX +XXX,XX @@ void plugin_gen_disable_mem_helpers(void)
259
}
260
}
261
262
-static void plugin_gen_insn_udata(const struct qemu_plugin_tb *ptb,
263
- TCGOp *begin_op, int insn_idx)
264
-{
265
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
266
-
267
- inject_udata_cb(insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR], begin_op);
268
-}
269
-
270
-static void plugin_gen_insn_udata_r(const struct qemu_plugin_tb *ptb,
271
- TCGOp *begin_op, int insn_idx)
272
-{
273
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
274
-
275
- inject_udata_cb(insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR_R], begin_op);
276
-}
277
-
278
-static void plugin_gen_insn_inline(const struct qemu_plugin_tb *ptb,
279
- TCGOp *begin_op, int insn_idx)
280
-{
281
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
282
- inject_inline_cb(insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE],
283
- begin_op, op_ok);
284
-}
285
-
286
static void plugin_gen_mem_regular(const struct qemu_plugin_tb *ptb,
287
TCGOp *begin_op, int insn_idx)
288
{
289
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_mem_inline(const struct qemu_plugin_tb *ptb,
290
inject_inline_cb(cbs, begin_op, op_rw);
291
}
292
293
-static void plugin_gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
294
- TCGOp *begin_op, int insn_idx)
295
+static void gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
296
+ struct qemu_plugin_insn *insn)
297
{
298
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
299
- inject_mem_enable_helper(ptb, insn, begin_op);
300
+ GArray *cbs[2];
301
+ GArray *arr;
302
+ size_t n_cbs;
303
+
304
+ /*
305
+ * Tracking memory accesses performed from helpers requires extra work.
306
+ * If an instruction is emulated with helpers, we do two things:
307
+ * (1) copy the CB descriptors, and keep track of it so that they can be
308
+ * freed later on, and (2) point CPUState.plugin_mem_cbs to the
309
+ * descriptors, so that we can read them at run-time
310
+ * (i.e. when the helper executes).
311
+ * This run-time access is performed from qemu_plugin_vcpu_mem_cb.
312
+ *
313
+ * Note that plugin_gen_disable_mem_helpers undoes (2). Since it
314
+ * is possible that the code we generate after the instruction is
315
+ * dead, we also add checks before generating tb_exit etc.
316
+ */
317
+ if (!insn->calls_helpers) {
318
+ return;
319
+ }
320
+
321
+ cbs[0] = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
322
+ cbs[1] = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
323
+ n_cbs = cbs[0]->len + cbs[1]->len;
324
+
325
+ if (n_cbs == 0) {
326
+ insn->mem_helper = false;
327
+ return;
328
+ }
329
+ insn->mem_helper = true;
330
+ ptb->mem_helper = true;
331
+
332
+ arr = g_array_sized_new(false, false,
333
+ sizeof(struct qemu_plugin_dyn_cb), n_cbs);
334
+ g_array_append_vals(arr, cbs[0]->data, cbs[0]->len);
335
+ g_array_append_vals(arr, cbs[1]->data, cbs[1]->len);
336
+
337
+ qemu_plugin_add_dyn_cb_arr(arr);
338
+
339
+ tcg_gen_st_ptr(tcg_constant_ptr((intptr_t)arr), tcg_env,
340
+ offsetof(CPUState, plugin_mem_cbs) -
341
+ offsetof(ArchCPU, env));
342
}
343
344
static void gen_disable_mem_helper(void)
345
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
346
}
347
break;
348
349
+ case PLUGIN_GEN_FROM_INSN:
350
+ assert(insn != NULL);
351
+
352
+ gen_enable_mem_helper(plugin_tb, insn);
353
+
354
+ cbs = insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR];
355
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
356
+ struct qemu_plugin_dyn_cb *cb =
357
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
358
+ gen_udata_cb(cb);
359
+ }
360
+
361
+ cbs = insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE];
362
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
363
+ struct qemu_plugin_dyn_cb *cb =
364
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
365
+ gen_inline_cb(cb);
366
+ }
367
+ break;
368
+
369
default:
370
g_assert_not_reached();
371
}
372
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
373
enum plugin_gen_cb type = op->args[1];
374
375
switch (from) {
376
- case PLUGIN_GEN_FROM_INSN:
377
- {
378
- g_assert(insn_idx >= 0);
379
-
380
- switch (type) {
381
- case PLUGIN_GEN_CB_UDATA:
382
- plugin_gen_insn_udata(plugin_tb, op, insn_idx);
383
- break;
384
- case PLUGIN_GEN_CB_UDATA_R:
385
- plugin_gen_insn_udata_r(plugin_tb, op, insn_idx);
386
- break;
387
- case PLUGIN_GEN_CB_INLINE:
388
- plugin_gen_insn_inline(plugin_tb, op, insn_idx);
389
- break;
390
- case PLUGIN_GEN_ENABLE_MEM_HELPER:
391
- plugin_gen_enable_mem_helper(plugin_tb, op, insn_idx);
392
- break;
393
- default:
394
- g_assert_not_reached();
395
- }
396
- break;
397
- }
398
case PLUGIN_GEN_FROM_MEM:
399
{
400
g_assert(insn_idx >= 0);
401
diff --git a/plugins/api.c b/plugins/api.c
402
index XXXXXXX..XXXXXXX 100644
403
--- a/plugins/api.c
404
+++ b/plugins/api.c
405
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
406
void *udata)
407
{
408
if (!insn->mem_only) {
409
- int index = flags == QEMU_PLUGIN_CB_R_REGS ||
410
- flags == QEMU_PLUGIN_CB_RW_REGS ?
411
- PLUGIN_CB_REGULAR_R : PLUGIN_CB_REGULAR;
412
-
413
- plugin_register_dyn_cb__udata(&insn->cbs[PLUGIN_CB_INSN][index],
414
- cb, flags, udata);
415
+ plugin_register_dyn_cb__udata(
416
+ &insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR], cb, flags, udata);
417
}
418
}
419
34
--
420
--
35
2.20.1
421
2.34.1
36
37
diff view generated by jsdifflib
[PULL 12/16] cputlb: Split out tlb_mmu_flush_locked
[PULL 10/20] plugins: Use emit_before_op for PLUGIN_GEN_FROM_MEM
1
We will want to be able to flush a tlb without resizing.
1
Introduce a new plugin_mem_cb op to hold the address temp
2
and meminfo computed by tcg-op-ldst.c. Because this now
3
has its own opcode, we no longer need PLUGIN_GEN_FROM_MEM.
2
4
3
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
5
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
4
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
5
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
7
---
8
accel/tcg/cputlb.c | 15 ++++++++++-----
8
include/exec/plugin-gen.h | 4 -
9
1 file changed, 10 insertions(+), 5 deletions(-)
9
include/tcg/tcg-op-common.h | 1 +
10
include/tcg/tcg-opc.h | 1 +
11
accel/tcg/plugin-gen.c | 408 ++++--------------------------------
12
tcg/tcg-op-ldst.c | 6 +-
13
tcg/tcg-op.c | 5 +
14
6 files changed, 54 insertions(+), 371 deletions(-)
10
15
11
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
16
diff --git a/include/exec/plugin-gen.h b/include/exec/plugin-gen.h
12
index XXXXXXX..XXXXXXX 100644
17
index XXXXXXX..XXXXXXX 100644
13
--- a/accel/tcg/cputlb.c
18
--- a/include/exec/plugin-gen.h
14
+++ b/accel/tcg/cputlb.c
19
+++ b/include/exec/plugin-gen.h
15
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_resize_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
20
@@ -XXX,XX +XXX,XX @@ void plugin_gen_insn_start(CPUState *cpu, const struct DisasContextBase *db);
21
void plugin_gen_insn_end(void);
22
23
void plugin_gen_disable_mem_helpers(void);
24
-void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info);
25
26
#else /* !CONFIG_PLUGIN */
27
28
@@ -XXX,XX +XXX,XX @@ static inline void plugin_gen_tb_end(CPUState *cpu, size_t num_insns)
29
static inline void plugin_gen_disable_mem_helpers(void)
30
{ }
31
32
-static inline void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info)
33
-{ }
34
-
35
#endif /* CONFIG_PLUGIN */
36
37
#endif /* QEMU_PLUGIN_GEN_H */
38
diff --git a/include/tcg/tcg-op-common.h b/include/tcg/tcg-op-common.h
39
index XXXXXXX..XXXXXXX 100644
40
--- a/include/tcg/tcg-op-common.h
41
+++ b/include/tcg/tcg-op-common.h
42
@@ -XXX,XX +XXX,XX @@ void tcg_gen_goto_tb(unsigned idx);
43
void tcg_gen_lookup_and_goto_ptr(void);
44
45
void tcg_gen_plugin_cb(unsigned from);
46
+void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo);
47
void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr);
48
void tcg_gen_plugin_cb_end(void);
49
50
diff --git a/include/tcg/tcg-opc.h b/include/tcg/tcg-opc.h
51
index XXXXXXX..XXXXXXX 100644
52
--- a/include/tcg/tcg-opc.h
53
+++ b/include/tcg/tcg-opc.h
54
@@ -XXX,XX +XXX,XX @@ DEF(goto_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
55
DEF(goto_ptr, 0, 1, 0, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
56
57
DEF(plugin_cb, 0, 0, 1, TCG_OPF_NOT_PRESENT)
58
+DEF(plugin_mem_cb, 0, 1, 1, TCG_OPF_NOT_PRESENT)
59
DEF(plugin_cb_start, 0, 0, 3, TCG_OPF_NOT_PRESENT)
60
DEF(plugin_cb_end, 0, 0, 0, TCG_OPF_NOT_PRESENT)
61
62
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
63
index XXXXXXX..XXXXXXX 100644
64
--- a/accel/tcg/plugin-gen.c
65
+++ b/accel/tcg/plugin-gen.c
66
@@ -XXX,XX +XXX,XX @@
67
enum plugin_gen_from {
68
PLUGIN_GEN_FROM_TB,
69
PLUGIN_GEN_FROM_INSN,
70
- PLUGIN_GEN_FROM_MEM,
71
PLUGIN_GEN_AFTER_INSN,
72
PLUGIN_GEN_AFTER_TB,
73
PLUGIN_GEN_N_FROMS,
74
@@ -XXX,XX +XXX,XX @@ void HELPER(plugin_vcpu_mem_cb)(unsigned int vcpu_index,
75
void *userdata)
76
{ }
77
78
-/*
79
- * For now we only support addi_i64.
80
- * When we support more ops, we can generate one empty inline cb for each.
81
- */
82
-static void gen_empty_inline_cb(void)
83
-{
84
- TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
85
- TCGv_ptr cpu_index_as_ptr = tcg_temp_ebb_new_ptr();
86
- TCGv_i64 val = tcg_temp_ebb_new_i64();
87
- TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
88
-
89
- tcg_gen_ld_i32(cpu_index, tcg_env,
90
- -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
91
- /* second operand will be replaced by immediate value */
92
- tcg_gen_mul_i32(cpu_index, cpu_index, cpu_index);
93
- tcg_gen_ext_i32_ptr(cpu_index_as_ptr, cpu_index);
94
-
95
- tcg_gen_movi_ptr(ptr, 0);
96
- tcg_gen_add_ptr(ptr, ptr, cpu_index_as_ptr);
97
- tcg_gen_ld_i64(val, ptr, 0);
98
- /* second operand will be replaced by immediate value */
99
- tcg_gen_add_i64(val, val, val);
100
-
101
- tcg_gen_st_i64(val, ptr, 0);
102
- tcg_temp_free_ptr(ptr);
103
- tcg_temp_free_i64(val);
104
- tcg_temp_free_ptr(cpu_index_as_ptr);
105
- tcg_temp_free_i32(cpu_index);
106
-}
107
-
108
-static void gen_empty_mem_cb(TCGv_i64 addr, uint32_t info)
109
-{
110
- TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
111
- TCGv_i32 meminfo = tcg_temp_ebb_new_i32();
112
- TCGv_ptr udata = tcg_temp_ebb_new_ptr();
113
-
114
- tcg_gen_movi_i32(meminfo, info);
115
- tcg_gen_movi_ptr(udata, 0);
116
- tcg_gen_ld_i32(cpu_index, tcg_env,
117
- -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
118
-
119
- gen_helper_plugin_vcpu_mem_cb(cpu_index, meminfo, addr, udata);
120
-
121
- tcg_temp_free_ptr(udata);
122
- tcg_temp_free_i32(meminfo);
123
- tcg_temp_free_i32(cpu_index);
124
-}
125
-
126
-static void gen_plugin_cb_start(enum plugin_gen_from from,
127
- enum plugin_gen_cb type, unsigned wr)
128
-{
129
- tcg_gen_plugin_cb_start(from, type, wr);
130
-}
131
-
132
static void plugin_gen_empty_callback(enum plugin_gen_from from)
133
{
134
switch (from) {
135
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_empty_callback(enum plugin_gen_from from)
16
}
136
}
17
}
137
}
18
138
19
-static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
139
-void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info)
20
+static void tlb_mmu_flush_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
140
-{
141
- enum qemu_plugin_mem_rw rw = get_plugin_meminfo_rw(info);
142
-
143
- gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, PLUGIN_GEN_CB_MEM, rw);
144
- gen_empty_mem_cb(addr, info);
145
- tcg_gen_plugin_cb_end();
146
-
147
- gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, PLUGIN_GEN_CB_INLINE, rw);
148
- gen_empty_inline_cb();
149
- tcg_gen_plugin_cb_end();
150
-}
151
-
152
-static TCGOp *find_op(TCGOp *op, TCGOpcode opc)
153
-{
154
- while (op) {
155
- if (op->opc == opc) {
156
- return op;
157
- }
158
- op = QTAILQ_NEXT(op, link);
159
- }
160
- return NULL;
161
-}
162
-
163
-static TCGOp *rm_ops_range(TCGOp *begin, TCGOp *end)
164
-{
165
- TCGOp *ret = QTAILQ_NEXT(end, link);
166
-
167
- QTAILQ_REMOVE_SEVERAL(&tcg_ctx->ops, begin, end, link);
168
- return ret;
169
-}
170
-
171
-/* remove all ops until (and including) plugin_cb_end */
172
-static TCGOp *rm_ops(TCGOp *op)
173
-{
174
- TCGOp *end_op = find_op(op, INDEX_op_plugin_cb_end);
175
-
176
- tcg_debug_assert(end_op);
177
- return rm_ops_range(op, end_op);
178
-}
179
-
180
-static TCGOp *copy_op_nocheck(TCGOp **begin_op, TCGOp *op)
181
-{
182
- TCGOp *old_op = QTAILQ_NEXT(*begin_op, link);
183
- unsigned nargs = old_op->nargs;
184
-
185
- *begin_op = old_op;
186
- op = tcg_op_insert_after(tcg_ctx, op, old_op->opc, nargs);
187
- memcpy(op->args, old_op->args, sizeof(op->args[0]) * nargs);
188
-
189
- return op;
190
-}
191
-
192
-static TCGOp *copy_op(TCGOp **begin_op, TCGOp *op, TCGOpcode opc)
193
-{
194
- op = copy_op_nocheck(begin_op, op);
195
- tcg_debug_assert((*begin_op)->opc == opc);
196
- return op;
197
-}
198
-
199
-static TCGOp *copy_const_ptr(TCGOp **begin_op, TCGOp *op, void *ptr)
200
-{
201
- if (UINTPTR_MAX == UINT32_MAX) {
202
- /* mov_i32 */
203
- op = copy_op(begin_op, op, INDEX_op_mov_i32);
204
- op->args[1] = tcgv_i32_arg(tcg_constant_i32((uintptr_t)ptr));
205
- } else {
206
- /* mov_i64 */
207
- op = copy_op(begin_op, op, INDEX_op_mov_i64);
208
- op->args[1] = tcgv_i64_arg(tcg_constant_i64((uintptr_t)ptr));
209
- }
210
- return op;
211
-}
212
-
213
-static TCGOp *copy_ld_i32(TCGOp **begin_op, TCGOp *op)
214
-{
215
- return copy_op(begin_op, op, INDEX_op_ld_i32);
216
-}
217
-
218
-static TCGOp *copy_ext_i32_ptr(TCGOp **begin_op, TCGOp *op)
219
-{
220
- if (UINTPTR_MAX == UINT32_MAX) {
221
- op = copy_op(begin_op, op, INDEX_op_mov_i32);
222
- } else {
223
- op = copy_op(begin_op, op, INDEX_op_ext_i32_i64);
224
- }
225
- return op;
226
-}
227
-
228
-static TCGOp *copy_add_ptr(TCGOp **begin_op, TCGOp *op)
229
-{
230
- if (UINTPTR_MAX == UINT32_MAX) {
231
- op = copy_op(begin_op, op, INDEX_op_add_i32);
232
- } else {
233
- op = copy_op(begin_op, op, INDEX_op_add_i64);
234
- }
235
- return op;
236
-}
237
-
238
-static TCGOp *copy_ld_i64(TCGOp **begin_op, TCGOp *op)
239
-{
240
- if (TCG_TARGET_REG_BITS == 32) {
241
- /* 2x ld_i32 */
242
- op = copy_ld_i32(begin_op, op);
243
- op = copy_ld_i32(begin_op, op);
244
- } else {
245
- /* ld_i64 */
246
- op = copy_op(begin_op, op, INDEX_op_ld_i64);
247
- }
248
- return op;
249
-}
250
-
251
-static TCGOp *copy_st_i64(TCGOp **begin_op, TCGOp *op)
252
-{
253
- if (TCG_TARGET_REG_BITS == 32) {
254
- /* 2x st_i32 */
255
- op = copy_op(begin_op, op, INDEX_op_st_i32);
256
- op = copy_op(begin_op, op, INDEX_op_st_i32);
257
- } else {
258
- /* st_i64 */
259
- op = copy_op(begin_op, op, INDEX_op_st_i64);
260
- }
261
- return op;
262
-}
263
-
264
-static TCGOp *copy_add_i64(TCGOp **begin_op, TCGOp *op, uint64_t v)
265
-{
266
- if (TCG_TARGET_REG_BITS == 32) {
267
- /* all 32-bit backends must implement add2_i32 */
268
- g_assert(TCG_TARGET_HAS_add2_i32);
269
- op = copy_op(begin_op, op, INDEX_op_add2_i32);
270
- op->args[4] = tcgv_i32_arg(tcg_constant_i32(v));
271
- op->args[5] = tcgv_i32_arg(tcg_constant_i32(v >> 32));
272
- } else {
273
- op = copy_op(begin_op, op, INDEX_op_add_i64);
274
- op->args[2] = tcgv_i64_arg(tcg_constant_i64(v));
275
- }
276
- return op;
277
-}
278
-
279
-static TCGOp *copy_mul_i32(TCGOp **begin_op, TCGOp *op, uint32_t v)
280
-{
281
- op = copy_op(begin_op, op, INDEX_op_mul_i32);
282
- op->args[2] = tcgv_i32_arg(tcg_constant_i32(v));
283
- return op;
284
-}
285
-
286
-static TCGOp *copy_call(TCGOp **begin_op, TCGOp *op, void *func, int *cb_idx)
287
-{
288
- TCGOp *old_op;
289
- int func_idx;
290
-
291
- /* copy all ops until the call */
292
- do {
293
- op = copy_op_nocheck(begin_op, op);
294
- } while (op->opc != INDEX_op_call);
295
-
296
- /* fill in the op call */
297
- old_op = *begin_op;
298
- TCGOP_CALLI(op) = TCGOP_CALLI(old_op);
299
- TCGOP_CALLO(op) = TCGOP_CALLO(old_op);
300
- tcg_debug_assert(op->life == 0);
301
-
302
- func_idx = TCGOP_CALLO(op) + TCGOP_CALLI(op);
303
- *cb_idx = func_idx;
304
- op->args[func_idx] = (uintptr_t)func;
305
-
306
- return op;
307
-}
308
-
309
-static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
310
- TCGOp *begin_op, TCGOp *op,
311
- int *unused)
312
-{
313
- char *ptr = cb->inline_insn.entry.score->data->data;
314
- size_t elem_size = g_array_get_element_size(
315
- cb->inline_insn.entry.score->data);
316
- size_t offset = cb->inline_insn.entry.offset;
317
-
318
- op = copy_ld_i32(&begin_op, op);
319
- op = copy_mul_i32(&begin_op, op, elem_size);
320
- op = copy_ext_i32_ptr(&begin_op, op);
321
- op = copy_const_ptr(&begin_op, op, ptr + offset);
322
- op = copy_add_ptr(&begin_op, op);
323
- op = copy_ld_i64(&begin_op, op);
324
- op = copy_add_i64(&begin_op, op, cb->inline_insn.imm);
325
- op = copy_st_i64(&begin_op, op);
326
- return op;
327
-}
328
-
329
-static TCGOp *append_mem_cb(const struct qemu_plugin_dyn_cb *cb,
330
- TCGOp *begin_op, TCGOp *op, int *cb_idx)
331
-{
332
- enum plugin_gen_cb type = begin_op->args[1];
333
-
334
- tcg_debug_assert(type == PLUGIN_GEN_CB_MEM);
335
-
336
- /* const_i32 == mov_i32 ("info", so it remains as is) */
337
- op = copy_op(&begin_op, op, INDEX_op_mov_i32);
338
-
339
- /* const_ptr */
340
- op = copy_const_ptr(&begin_op, op, cb->userp);
341
-
342
- /* copy the ld_i32, but note that we only have to copy it once */
343
- if (*cb_idx == -1) {
344
- op = copy_op(&begin_op, op, INDEX_op_ld_i32);
345
- } else {
346
- begin_op = QTAILQ_NEXT(begin_op, link);
347
- tcg_debug_assert(begin_op && begin_op->opc == INDEX_op_ld_i32);
348
- }
349
-
350
- if (type == PLUGIN_GEN_CB_MEM) {
351
- /* call */
352
- op = copy_call(&begin_op, op, cb->regular.f.vcpu_udata, cb_idx);
353
- }
354
-
355
- return op;
356
-}
357
-
358
-typedef TCGOp *(*inject_fn)(const struct qemu_plugin_dyn_cb *cb,
359
- TCGOp *begin_op, TCGOp *op, int *intp);
360
-typedef bool (*op_ok_fn)(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb);
361
-
362
-static bool op_rw(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb)
363
-{
364
- int w;
365
-
366
- w = op->args[2];
367
- return !!(cb->rw & (w + 1));
368
-}
369
-
370
-static void inject_cb_type(const GArray *cbs, TCGOp *begin_op,
371
- inject_fn inject, op_ok_fn ok)
372
-{
373
- TCGOp *end_op;
374
- TCGOp *op;
375
- int cb_idx = -1;
376
- int i;
377
-
378
- if (!cbs || cbs->len == 0) {
379
- rm_ops(begin_op);
380
- return;
381
- }
382
-
383
- end_op = find_op(begin_op, INDEX_op_plugin_cb_end);
384
- tcg_debug_assert(end_op);
385
-
386
- op = end_op;
387
- for (i = 0; i < cbs->len; i++) {
388
- struct qemu_plugin_dyn_cb *cb =
389
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
390
-
391
- if (!ok(begin_op, cb)) {
392
- continue;
393
- }
394
- op = inject(cb, begin_op, op, &cb_idx);
395
- }
396
- rm_ops_range(begin_op, end_op);
397
-}
398
-
399
-static void
400
-inject_inline_cb(const GArray *cbs, TCGOp *begin_op, op_ok_fn ok)
401
-{
402
- inject_cb_type(cbs, begin_op, append_inline_cb, ok);
403
-}
404
-
405
-static void
406
-inject_mem_cb(const GArray *cbs, TCGOp *begin_op)
407
-{
408
- inject_cb_type(cbs, begin_op, append_mem_cb, op_rw);
409
-}
410
-
411
/* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
412
void plugin_gen_disable_mem_helpers(void)
21
{
413
{
22
- CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
414
@@ -XXX,XX +XXX,XX @@ void plugin_gen_disable_mem_helpers(void)
23
- CPUTLBDescFast *fast = &env_tlb(env)->f[mmu_idx];
415
}
24
-
25
- tlb_mmu_resize_locked(desc, fast);
26
desc->n_used_entries = 0;
27
desc->large_page_addr = -1;
28
desc->large_page_mask = -1;
29
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
30
memset(desc->vtable, -1, sizeof(desc->vtable));
31
}
416
}
32
417
33
+static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
418
-static void plugin_gen_mem_regular(const struct qemu_plugin_tb *ptb,
419
- TCGOp *begin_op, int insn_idx)
420
-{
421
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
422
- inject_mem_cb(insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR], begin_op);
423
-}
424
-
425
-static void plugin_gen_mem_inline(const struct qemu_plugin_tb *ptb,
426
- TCGOp *begin_op, int insn_idx)
427
-{
428
- const GArray *cbs;
429
- struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
430
-
431
- cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
432
- inject_inline_cb(cbs, begin_op, op_rw);
433
-}
434
-
435
static void gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
436
struct qemu_plugin_insn *insn)
437
{
438
@@ -XXX,XX +XXX,XX @@ static void gen_inline_cb(struct qemu_plugin_dyn_cb *cb)
439
tcg_temp_free_ptr(ptr);
440
}
441
442
+static void gen_mem_cb(struct qemu_plugin_dyn_cb *cb,
443
+ qemu_plugin_meminfo_t meminfo, TCGv_i64 addr)
34
+{
444
+{
35
+ CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
445
+ TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
36
+ CPUTLBDescFast *fast = &env_tlb(env)->f[mmu_idx];
37
+
446
+
38
+ tlb_mmu_resize_locked(desc, fast);
447
+ tcg_gen_ld_i32(cpu_index, tcg_env,
39
+ tlb_mmu_flush_locked(desc, fast);
448
+ -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
449
+ tcg_gen_call4(cb->regular.f.vcpu_mem, cb->regular.info, NULL,
450
+ tcgv_i32_temp(cpu_index),
451
+ tcgv_i32_temp(tcg_constant_i32(meminfo)),
452
+ tcgv_i64_temp(addr),
453
+ tcgv_ptr_temp(tcg_constant_ptr(cb->userp)));
454
+ tcg_temp_free_i32(cpu_index);
40
+}
455
+}
41
+
456
+
42
static inline void tlb_n_used_entries_inc(CPUArchState *env, uintptr_t mmu_idx)
457
/* #define DEBUG_PLUGIN_GEN_OPS */
458
static void pr_ops(void)
43
{
459
{
44
env_tlb(env)->d[mmu_idx].n_used_entries++;
460
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
461
break;
462
}
463
464
- case INDEX_op_plugin_cb_start:
465
+ case INDEX_op_plugin_mem_cb:
466
{
467
- enum plugin_gen_from from = op->args[0];
468
- enum plugin_gen_cb type = op->args[1];
469
+ TCGv_i64 addr = temp_tcgv_i64(arg_temp(op->args[0]));
470
+ qemu_plugin_meminfo_t meminfo = op->args[1];
471
+ struct qemu_plugin_insn *insn;
472
+ const GArray *cbs;
473
+ int i, n, rw;
474
475
- switch (from) {
476
- case PLUGIN_GEN_FROM_MEM:
477
- {
478
- g_assert(insn_idx >= 0);
479
+ assert(insn_idx >= 0);
480
+ insn = g_ptr_array_index(plugin_tb->insns, insn_idx);
481
+ rw = qemu_plugin_mem_is_store(meminfo) ? 2 : 1;
482
483
- switch (type) {
484
- case PLUGIN_GEN_CB_MEM:
485
- plugin_gen_mem_regular(plugin_tb, op, insn_idx);
486
- break;
487
- case PLUGIN_GEN_CB_INLINE:
488
- plugin_gen_mem_inline(plugin_tb, op, insn_idx);
489
- break;
490
- default:
491
- g_assert_not_reached();
492
+ tcg_ctx->emit_before_op = op;
493
+
494
+ cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
495
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
496
+ struct qemu_plugin_dyn_cb *cb =
497
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
498
+ if (cb->rw & rw) {
499
+ gen_mem_cb(cb, meminfo, addr);
500
}
501
+ }
502
503
- break;
504
- }
505
- default:
506
- g_assert_not_reached();
507
+ cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
508
+ for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
509
+ struct qemu_plugin_dyn_cb *cb =
510
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
511
+ if (cb->rw & rw) {
512
+ gen_inline_cb(cb);
513
+ }
514
}
515
+
516
+ tcg_ctx->emit_before_op = NULL;
517
+ tcg_op_remove(tcg_ctx, op);
518
break;
519
}
520
+
521
default:
522
/* plugins don't care about any other ops */
523
break;
524
diff --git a/tcg/tcg-op-ldst.c b/tcg/tcg-op-ldst.c
525
index XXXXXXX..XXXXXXX 100644
526
--- a/tcg/tcg-op-ldst.c
527
+++ b/tcg/tcg-op-ldst.c
528
@@ -XXX,XX +XXX,XX @@ plugin_gen_mem_callbacks(TCGv_i64 copy_addr, TCGTemp *orig_addr, MemOpIdx oi,
529
copy_addr = tcg_temp_ebb_new_i64();
530
tcg_gen_extu_i32_i64(copy_addr, temp_tcgv_i32(orig_addr));
531
}
532
- plugin_gen_empty_mem_callback(copy_addr, info);
533
+ tcg_gen_plugin_mem_cb(copy_addr, info);
534
tcg_temp_free_i64(copy_addr);
535
} else {
536
if (copy_addr) {
537
- plugin_gen_empty_mem_callback(copy_addr, info);
538
+ tcg_gen_plugin_mem_cb(copy_addr, info);
539
tcg_temp_free_i64(copy_addr);
540
} else {
541
- plugin_gen_empty_mem_callback(temp_tcgv_i64(orig_addr), info);
542
+ tcg_gen_plugin_mem_cb(temp_tcgv_i64(orig_addr), info);
543
}
544
}
545
}
546
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
547
index XXXXXXX..XXXXXXX 100644
548
--- a/tcg/tcg-op.c
549
+++ b/tcg/tcg-op.c
550
@@ -XXX,XX +XXX,XX @@ void tcg_gen_plugin_cb(unsigned from)
551
tcg_gen_op1(INDEX_op_plugin_cb, from);
552
}
553
554
+void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo)
555
+{
556
+ tcg_gen_op2(INDEX_op_plugin_mem_cb, tcgv_i64_arg(addr), meminfo);
557
+}
558
+
559
void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr)
560
{
561
tcg_gen_op3(INDEX_op_plugin_cb_start, from, type, wr);
45
--
562
--
46
2.20.1
563
2.34.1
47
48
diff view generated by jsdifflib
[PULL 11/16] cputlb: Hoist tlb portions in tlb_flush_one_mmuidx_locked
[PULL 11/20] plugins: Remove plugin helpers
1
No functional change, but the smaller expressions make
1
These placeholder helpers are no longer required.
2
the code easier to read.
3
2
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
3
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
5
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
5
---
9
accel/tcg/cputlb.c | 19 ++++++++++---------
6
accel/tcg/plugin-helpers.h | 5 -----
10
1 file changed, 10 insertions(+), 9 deletions(-)
7
include/exec/helper-gen-common.h | 4 ----
8
include/exec/helper-proto-common.h | 4 ----
9
accel/tcg/plugin-gen.c | 20 --------------------
10
4 files changed, 33 deletions(-)
11
delete mode 100644 accel/tcg/plugin-helpers.h
11
12
12
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
13
diff --git a/accel/tcg/plugin-helpers.h b/accel/tcg/plugin-helpers.h
14
deleted file mode 100644
15
index XXXXXXX..XXXXXXX
16
--- a/accel/tcg/plugin-helpers.h
17
+++ /dev/null
18
@@ -XXX,XX +XXX,XX @@
19
-#ifdef CONFIG_PLUGIN
20
-DEF_HELPER_FLAGS_2(plugin_vcpu_udata_cb_no_wg, TCG_CALL_NO_WG | TCG_CALL_PLUGIN, void, i32, ptr)
21
-DEF_HELPER_FLAGS_2(plugin_vcpu_udata_cb_no_rwg, TCG_CALL_NO_RWG | TCG_CALL_PLUGIN, void, i32, ptr)
22
-DEF_HELPER_FLAGS_4(plugin_vcpu_mem_cb, TCG_CALL_NO_RWG | TCG_CALL_PLUGIN, void, i32, i32, i64, ptr)
23
-#endif
24
diff --git a/include/exec/helper-gen-common.h b/include/exec/helper-gen-common.h
13
index XXXXXXX..XXXXXXX 100644
25
index XXXXXXX..XXXXXXX 100644
14
--- a/accel/tcg/cputlb.c
26
--- a/include/exec/helper-gen-common.h
15
+++ b/accel/tcg/cputlb.c
27
+++ b/include/exec/helper-gen-common.h
16
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_resize_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
28
@@ -XXX,XX +XXX,XX @@
17
29
#include "exec/helper-gen.h.inc"
18
static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
30
#undef HELPER_H
31
32
-#define HELPER_H "accel/tcg/plugin-helpers.h"
33
-#include "exec/helper-gen.h.inc"
34
-#undef HELPER_H
35
-
36
#endif /* HELPER_GEN_COMMON_H */
37
diff --git a/include/exec/helper-proto-common.h b/include/exec/helper-proto-common.h
38
index XXXXXXX..XXXXXXX 100644
39
--- a/include/exec/helper-proto-common.h
40
+++ b/include/exec/helper-proto-common.h
41
@@ -XXX,XX +XXX,XX @@
42
#include "exec/helper-proto.h.inc"
43
#undef HELPER_H
44
45
-#define HELPER_H "accel/tcg/plugin-helpers.h"
46
-#include "exec/helper-proto.h.inc"
47
-#undef HELPER_H
48
-
49
#endif /* HELPER_PROTO_COMMON_H */
50
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
51
index XXXXXXX..XXXXXXX 100644
52
--- a/accel/tcg/plugin-gen.c
53
+++ b/accel/tcg/plugin-gen.c
54
@@ -XXX,XX +XXX,XX @@
55
#include "exec/exec-all.h"
56
#include "exec/plugin-gen.h"
57
#include "exec/translator.h"
58
-#include "exec/helper-proto-common.h"
59
-
60
-#define HELPER_H "accel/tcg/plugin-helpers.h"
61
-#include "exec/helper-info.c.inc"
62
-#undef HELPER_H
63
64
/*
65
* plugin_cb_start TCG op args[]:
66
@@ -XXX,XX +XXX,XX @@ enum plugin_gen_cb {
67
PLUGIN_GEN_N_CBS,
68
};
69
70
-/*
71
- * These helpers are stubs that get dynamically switched out for calls
72
- * direct to the plugin if they are subscribed to.
73
- */
74
-void HELPER(plugin_vcpu_udata_cb_no_wg)(uint32_t cpu_index, void *udata)
75
-{ }
76
-
77
-void HELPER(plugin_vcpu_udata_cb_no_rwg)(uint32_t cpu_index, void *udata)
78
-{ }
79
-
80
-void HELPER(plugin_vcpu_mem_cb)(unsigned int vcpu_index,
81
- qemu_plugin_meminfo_t info, uint64_t vaddr,
82
- void *userdata)
83
-{ }
84
-
85
static void plugin_gen_empty_callback(enum plugin_gen_from from)
19
{
86
{
20
- tlb_mmu_resize_locked(&env_tlb(env)->d[mmu_idx], &env_tlb(env)->f[mmu_idx]);
87
switch (from) {
21
- env_tlb(env)->d[mmu_idx].n_used_entries = 0;
22
- env_tlb(env)->d[mmu_idx].large_page_addr = -1;
23
- env_tlb(env)->d[mmu_idx].large_page_mask = -1;
24
- env_tlb(env)->d[mmu_idx].vindex = 0;
25
- memset(env_tlb(env)->f[mmu_idx].table, -1,
26
- sizeof_tlb(&env_tlb(env)->f[mmu_idx]));
27
- memset(env_tlb(env)->d[mmu_idx].vtable, -1,
28
- sizeof(env_tlb(env)->d[0].vtable));
29
+ CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
30
+ CPUTLBDescFast *fast = &env_tlb(env)->f[mmu_idx];
31
+
32
+ tlb_mmu_resize_locked(desc, fast);
33
+ desc->n_used_entries = 0;
34
+ desc->large_page_addr = -1;
35
+ desc->large_page_mask = -1;
36
+ desc->vindex = 0;
37
+ memset(fast->table, -1, sizeof_tlb(fast));
38
+ memset(desc->vtable, -1, sizeof(desc->vtable));
39
}
40
41
static inline void tlb_n_used_entries_inc(CPUArchState *env, uintptr_t mmu_idx)
42
--
88
--
43
2.20.1
89
2.34.1
44
90
45
91
diff view generated by jsdifflib
New patch
[PULL 12/20] tcg: Remove TCG_CALL_PLUGIN
1
Since we no longer emit plugin helpers during the initial code
2
translation phase, we don't need to specially mark plugin helpers.
1
3
4
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
---
7
include/tcg/tcg.h | 2 --
8
plugins/core.c | 10 ++++------
9
tcg/tcg.c | 4 +---
10
3 files changed, 5 insertions(+), 11 deletions(-)
11
12
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
13
index XXXXXXX..XXXXXXX 100644
14
--- a/include/tcg/tcg.h
15
+++ b/include/tcg/tcg.h
16
@@ -XXX,XX +XXX,XX @@ typedef TCGv_ptr TCGv_env;
17
#define TCG_CALL_NO_SIDE_EFFECTS 0x0004
18
/* Helper is G_NORETURN. */
19
#define TCG_CALL_NO_RETURN 0x0008
20
-/* Helper is part of Plugins. */
21
-#define TCG_CALL_PLUGIN 0x0010
22
23
/* convenience version of most used call flags */
24
#define TCG_CALL_NO_RWG TCG_CALL_NO_READ_GLOBALS
25
diff --git a/plugins/core.c b/plugins/core.c
26
index XXXXXXX..XXXXXXX 100644
27
--- a/plugins/core.c
28
+++ b/plugins/core.c
29
@@ -XXX,XX +XXX,XX @@ void plugin_register_dyn_cb__udata(GArray **arr,
30
void *udata)
31
{
32
static TCGHelperInfo info[3] = {
33
- [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN,
34
- [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN,
35
- [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN,
36
+ [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG,
37
+ [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG,
38
/*
39
* Match qemu_plugin_vcpu_udata_cb_t:
40
* void (*)(uint32_t, void *)
41
@@ -XXX,XX +XXX,XX @@ void plugin_register_vcpu_mem_cb(GArray **arr,
42
!__builtin_types_compatible_p(qemu_plugin_meminfo_t, int32_t));
43
44
static TCGHelperInfo info[3] = {
45
- [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG | TCG_CALL_PLUGIN,
46
- [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG | TCG_CALL_PLUGIN,
47
- [QEMU_PLUGIN_CB_RW_REGS].flags = TCG_CALL_PLUGIN,
48
+ [QEMU_PLUGIN_CB_NO_REGS].flags = TCG_CALL_NO_RWG,
49
+ [QEMU_PLUGIN_CB_R_REGS].flags = TCG_CALL_NO_WG,
50
/*
51
* Match qemu_plugin_vcpu_mem_cb_t:
52
* void (*)(uint32_t, qemu_plugin_meminfo_t, uint64_t, void *)
53
diff --git a/tcg/tcg.c b/tcg/tcg.c
54
index XXXXXXX..XXXXXXX 100644
55
--- a/tcg/tcg.c
56
+++ b/tcg/tcg.c
57
@@ -XXX,XX +XXX,XX @@ static void tcg_gen_callN(void *func, TCGHelperInfo *info,
58
59
#ifdef CONFIG_PLUGIN
60
/* Flag helpers that may affect guest state */
61
- if (tcg_ctx->plugin_insn &&
62
- !(info->flags & TCG_CALL_PLUGIN) &&
63
- !(info->flags & TCG_CALL_NO_SIDE_EFFECTS)) {
64
+ if (tcg_ctx->plugin_insn && !(info->flags & TCG_CALL_NO_SIDE_EFFECTS)) {
65
tcg_ctx->plugin_insn->calls_helpers = true;
66
}
67
#endif
68
--
69
2.34.1
diff view generated by jsdifflib
New patch
[PULL 13/20] tcg: Remove INDEX_op_plugin_cb_{start,end}
1
These opcodes are no longer used.
1
2
3
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
---
6
include/tcg/tcg-op-common.h | 2 --
7
include/tcg/tcg-opc.h | 2 --
8
accel/tcg/plugin-gen.c | 18 ------------------
9
tcg/tcg-op.c | 10 ----------
10
4 files changed, 32 deletions(-)
11
12
diff --git a/include/tcg/tcg-op-common.h b/include/tcg/tcg-op-common.h
13
index XXXXXXX..XXXXXXX 100644
14
--- a/include/tcg/tcg-op-common.h
15
+++ b/include/tcg/tcg-op-common.h
16
@@ -XXX,XX +XXX,XX @@ void tcg_gen_lookup_and_goto_ptr(void);
17
18
void tcg_gen_plugin_cb(unsigned from);
19
void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo);
20
-void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr);
21
-void tcg_gen_plugin_cb_end(void);
22
23
/* 32 bit ops */
24
25
diff --git a/include/tcg/tcg-opc.h b/include/tcg/tcg-opc.h
26
index XXXXXXX..XXXXXXX 100644
27
--- a/include/tcg/tcg-opc.h
28
+++ b/include/tcg/tcg-opc.h
29
@@ -XXX,XX +XXX,XX @@ DEF(goto_ptr, 0, 1, 0, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
30
31
DEF(plugin_cb, 0, 0, 1, TCG_OPF_NOT_PRESENT)
32
DEF(plugin_mem_cb, 0, 1, 1, TCG_OPF_NOT_PRESENT)
33
-DEF(plugin_cb_start, 0, 0, 3, TCG_OPF_NOT_PRESENT)
34
-DEF(plugin_cb_end, 0, 0, 0, TCG_OPF_NOT_PRESENT)
35
36
/* Replicate ld/st ops for 32 and 64-bit guest addresses. */
37
DEF(qemu_ld_a32_i32, 1, 1, 1,
38
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
39
index XXXXXXX..XXXXXXX 100644
40
--- a/accel/tcg/plugin-gen.c
41
+++ b/accel/tcg/plugin-gen.c
42
@@ -XXX,XX +XXX,XX @@
43
#include "exec/plugin-gen.h"
44
#include "exec/translator.h"
45
46
-/*
47
- * plugin_cb_start TCG op args[]:
48
- * 0: enum plugin_gen_from
49
- * 1: enum plugin_gen_cb
50
- * 2: set to 1 for mem callback that is a write, 0 otherwise.
51
- */
52
-
53
enum plugin_gen_from {
54
PLUGIN_GEN_FROM_TB,
55
PLUGIN_GEN_FROM_INSN,
56
PLUGIN_GEN_AFTER_INSN,
57
PLUGIN_GEN_AFTER_TB,
58
- PLUGIN_GEN_N_FROMS,
59
-};
60
-
61
-enum plugin_gen_cb {
62
- PLUGIN_GEN_CB_UDATA,
63
- PLUGIN_GEN_CB_UDATA_R,
64
- PLUGIN_GEN_CB_INLINE,
65
- PLUGIN_GEN_CB_MEM,
66
- PLUGIN_GEN_ENABLE_MEM_HELPER,
67
- PLUGIN_GEN_DISABLE_MEM_HELPER,
68
- PLUGIN_GEN_N_CBS,
69
};
70
71
static void plugin_gen_empty_callback(enum plugin_gen_from from)
72
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
73
index XXXXXXX..XXXXXXX 100644
74
--- a/tcg/tcg-op.c
75
+++ b/tcg/tcg-op.c
76
@@ -XXX,XX +XXX,XX @@ void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo)
77
tcg_gen_op2(INDEX_op_plugin_mem_cb, tcgv_i64_arg(addr), meminfo);
78
}
79
80
-void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr)
81
-{
82
- tcg_gen_op3(INDEX_op_plugin_cb_start, from, type, wr);
83
-}
84
-
85
-void tcg_gen_plugin_cb_end(void)
86
-{
87
- tcg_emit_op(INDEX_op_plugin_cb_end, 0);
88
-}
89
-
90
/* 32 bit ops */
91
92
void tcg_gen_discard_i32(TCGv_i32 arg)
93
--
94
2.34.1
diff view generated by jsdifflib
[PULL 10/16] cputlb: Hoist tlb portions in tlb_mmu_resize_locked
[PULL 14/20] plugins: Simplify callback queues
1
No functional change, but the smaller expressions make
1
We have qemu_plugin_dyn_cb.type to differentiate the various
2
the code easier to read.
2
callback types, so we do not need to keep them in separate queues.
3
3
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
4
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
5
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
6
---
9
accel/tcg/cputlb.c | 35 +++++++++++++++++------------------
7
include/qemu/plugin.h | 35 ++++++----------
10
1 file changed, 17 insertions(+), 18 deletions(-)
8
accel/tcg/plugin-gen.c | 90 ++++++++++++++++++++++--------------------
9
plugins/api.c | 18 +++------
10
3 files changed, 65 insertions(+), 78 deletions(-)
11
11
12
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
12
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
13
index XXXXXXX..XXXXXXX 100644
13
index XXXXXXX..XXXXXXX 100644
14
--- a/accel/tcg/cputlb.c
14
--- a/include/qemu/plugin.h
15
+++ b/accel/tcg/cputlb.c
15
+++ b/include/qemu/plugin.h
16
@@ -XXX,XX +XXX,XX @@ static void tlb_dyn_init(CPUArchState *env)
16
@@ -XXX,XX +XXX,XX @@ union qemu_plugin_cb_sig {
17
};
18
19
enum plugin_dyn_cb_type {
20
- PLUGIN_CB_INSN,
21
- PLUGIN_CB_MEM,
22
- PLUGIN_N_CB_TYPES,
23
-};
24
-
25
-enum plugin_dyn_cb_subtype {
26
PLUGIN_CB_REGULAR,
27
PLUGIN_CB_INLINE,
28
- PLUGIN_N_CB_SUBTYPES,
29
};
30
31
/*
32
@@ -XXX,XX +XXX,XX @@ enum plugin_dyn_cb_subtype {
33
*/
34
struct qemu_plugin_dyn_cb {
35
void *userp;
36
- enum plugin_dyn_cb_subtype type;
37
+ enum plugin_dyn_cb_type type;
38
/* @rw applies to mem callbacks only (both regular and inline) */
39
enum qemu_plugin_mem_rw rw;
40
/* fields specific to each dyn_cb type go here */
41
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_insn {
42
GByteArray *data;
43
uint64_t vaddr;
44
void *haddr;
45
- GArray *cbs[PLUGIN_N_CB_TYPES][PLUGIN_N_CB_SUBTYPES];
46
+ GArray *insn_cbs;
47
+ GArray *mem_cbs;
48
bool calls_helpers;
49
50
/* if set, the instruction calls helpers that might access guest memory */
51
@@ -XXX,XX +XXX,XX @@ static inline void qemu_plugin_insn_cleanup_fn(gpointer data)
52
53
static inline struct qemu_plugin_insn *qemu_plugin_insn_alloc(void)
54
{
55
- int i, j;
56
struct qemu_plugin_insn *insn = g_new0(struct qemu_plugin_insn, 1);
57
- insn->data = g_byte_array_sized_new(4);
58
59
- for (i = 0; i < PLUGIN_N_CB_TYPES; i++) {
60
- for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) {
61
- insn->cbs[i][j] = g_array_new(false, false,
62
- sizeof(struct qemu_plugin_dyn_cb));
63
- }
64
- }
65
+ insn->data = g_byte_array_sized_new(4);
66
return insn;
67
}
68
69
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_tb {
70
/* if set, the TB calls helpers that might access guest memory */
71
bool mem_helper;
72
73
- GArray *cbs[PLUGIN_N_CB_SUBTYPES];
74
+ GArray *cbs;
75
};
17
76
18
/**
77
/**
19
* tlb_mmu_resize_locked() - perform TLB resize bookkeeping; resize if necessary
78
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_insn *qemu_plugin_tb_insn_get(struct qemu_plugin_tb *tb,
20
- * @env: CPU that owns the TLB
79
uint64_t pc)
21
- * @mmu_idx: MMU index of the TLB
80
{
22
+ * @desc: The CPUTLBDesc portion of the TLB
81
struct qemu_plugin_insn *insn;
23
+ * @fast: The CPUTLBDescFast portion of the same TLB
82
- int i, j;
24
*
83
25
* Called with tlb_lock_held.
84
if (unlikely(tb->n == tb->insns->len)) {
26
*
85
struct qemu_plugin_insn *new_insn = qemu_plugin_insn_alloc();
27
@@ -XXX,XX +XXX,XX @@ static void tlb_dyn_init(CPUArchState *env)
86
g_ptr_array_add(tb->insns, new_insn);
28
* high), since otherwise we are likely to have a significant amount of
87
}
29
* conflict misses.
88
+
30
*/
89
insn = g_ptr_array_index(tb->insns, tb->n++);
31
-static void tlb_mmu_resize_locked(CPUArchState *env, int mmu_idx)
90
g_byte_array_set_size(insn->data, 0);
32
+static void tlb_mmu_resize_locked(CPUTLBDesc *desc, CPUTLBDescFast *fast)
91
insn->calls_helpers = false;
33
{
92
insn->mem_helper = false;
34
- CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
93
insn->vaddr = pc;
35
- size_t old_size = tlb_n_entries(&env_tlb(env)->f[mmu_idx]);
94
-
36
+ size_t old_size = tlb_n_entries(fast);
95
- for (i = 0; i < PLUGIN_N_CB_TYPES; i++) {
37
size_t rate;
96
- for (j = 0; j < PLUGIN_N_CB_SUBTYPES; j++) {
38
size_t new_size = old_size;
97
- g_array_set_size(insn->cbs[i][j], 0);
39
int64_t now = get_clock_realtime();
98
- }
40
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_resize_locked(CPUArchState *env, int mmu_idx)
99
+ if (insn->insn_cbs) {
100
+ g_array_set_size(insn->insn_cbs, 0);
101
+ }
102
+ if (insn->mem_cbs) {
103
+ g_array_set_size(insn->mem_cbs, 0);
104
}
105
106
return insn;
107
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
108
index XXXXXXX..XXXXXXX 100644
109
--- a/accel/tcg/plugin-gen.c
110
+++ b/accel/tcg/plugin-gen.c
111
@@ -XXX,XX +XXX,XX @@ void plugin_gen_disable_mem_helpers(void)
112
static void gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
113
struct qemu_plugin_insn *insn)
114
{
115
- GArray *cbs[2];
116
GArray *arr;
117
- size_t n_cbs;
118
+ size_t len;
119
120
/*
121
* Tracking memory accesses performed from helpers requires extra work.
122
@@ -XXX,XX +XXX,XX @@ static void gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
41
return;
123
return;
42
}
124
}
43
125
44
- g_free(env_tlb(env)->f[mmu_idx].table);
126
- cbs[0] = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
45
- g_free(env_tlb(env)->d[mmu_idx].iotlb);
127
- cbs[1] = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
46
+ g_free(fast->table);
128
- n_cbs = cbs[0]->len + cbs[1]->len;
47
+ g_free(desc->iotlb);
129
-
48
130
- if (n_cbs == 0) {
49
tlb_window_reset(desc, now, 0);
131
+ if (!insn->mem_cbs || !insn->mem_cbs->len) {
50
/* desc->n_used_entries is cleared by the caller */
132
insn->mem_helper = false;
51
- env_tlb(env)->f[mmu_idx].mask = (new_size - 1) << CPU_TLB_ENTRY_BITS;
133
return;
52
- env_tlb(env)->f[mmu_idx].table = g_try_new(CPUTLBEntry, new_size);
134
}
53
- env_tlb(env)->d[mmu_idx].iotlb = g_try_new(CPUIOTLBEntry, new_size);
135
insn->mem_helper = true;
54
+ fast->mask = (new_size - 1) << CPU_TLB_ENTRY_BITS;
136
ptb->mem_helper = true;
55
+ fast->table = g_try_new(CPUTLBEntry, new_size);
137
56
+ desc->iotlb = g_try_new(CPUIOTLBEntry, new_size);
138
+ /*
57
+
139
+ * TODO: It seems like we should be able to use ref/unref
58
/*
140
+ * to avoid needing to actually copy this array.
59
* If the allocations fail, try smaller sizes. We just freed some
141
+ * Alternately, perhaps we could allocate new memory adjacent
60
* memory, so going back to half of new_size has a good chance of working.
142
+ * to the TranslationBlock itself, so that we do not have to
61
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_resize_locked(CPUArchState *env, int mmu_idx)
143
+ * actively manage the lifetime after this.
62
* allocations to fail though, so we progressively reduce the allocation
144
+ */
63
* size, aborting if we cannot even allocate the smallest TLB we support.
145
+ len = insn->mem_cbs->len;
64
*/
146
arr = g_array_sized_new(false, false,
65
- while (env_tlb(env)->f[mmu_idx].table == NULL ||
147
- sizeof(struct qemu_plugin_dyn_cb), n_cbs);
66
- env_tlb(env)->d[mmu_idx].iotlb == NULL) {
148
- g_array_append_vals(arr, cbs[0]->data, cbs[0]->len);
67
+ while (fast->table == NULL || desc->iotlb == NULL) {
149
- g_array_append_vals(arr, cbs[1]->data, cbs[1]->len);
68
if (new_size == (1 << CPU_TLB_DYN_MIN_BITS)) {
150
-
69
error_report("%s: %s", __func__, strerror(errno));
151
+ sizeof(struct qemu_plugin_dyn_cb), len);
70
abort();
152
+ memcpy(arr->data, insn->mem_cbs->data,
153
+ len * sizeof(struct qemu_plugin_dyn_cb));
154
qemu_plugin_add_dyn_cb_arr(arr);
155
156
tcg_gen_st_ptr(tcg_constant_ptr((intptr_t)arr), tcg_env,
157
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
158
case PLUGIN_GEN_FROM_TB:
159
assert(insn == NULL);
160
161
- cbs = plugin_tb->cbs[PLUGIN_CB_REGULAR];
162
+ cbs = plugin_tb->cbs;
163
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
164
struct qemu_plugin_dyn_cb *cb =
165
&g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
166
- gen_udata_cb(cb);
167
- }
168
169
- cbs = plugin_tb->cbs[PLUGIN_CB_INLINE];
170
- for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
171
- struct qemu_plugin_dyn_cb *cb =
172
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
173
- gen_inline_cb(cb);
174
+ switch (cb->type) {
175
+ case PLUGIN_CB_REGULAR:
176
+ gen_udata_cb(cb);
177
+ break;
178
+ case PLUGIN_CB_INLINE:
179
+ gen_inline_cb(cb);
180
+ break;
181
+ default:
182
+ g_assert_not_reached();
183
+ }
184
}
185
break;
186
187
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
188
189
gen_enable_mem_helper(plugin_tb, insn);
190
191
- cbs = insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR];
192
+ cbs = insn->insn_cbs;
193
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
194
struct qemu_plugin_dyn_cb *cb =
195
&g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
196
- gen_udata_cb(cb);
197
- }
198
199
- cbs = insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE];
200
- for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
201
- struct qemu_plugin_dyn_cb *cb =
202
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
203
- gen_inline_cb(cb);
204
+ switch (cb->type) {
205
+ case PLUGIN_CB_REGULAR:
206
+ gen_udata_cb(cb);
207
+ break;
208
+ case PLUGIN_CB_INLINE:
209
+ gen_inline_cb(cb);
210
+ break;
211
+ default:
212
+ g_assert_not_reached();
213
+ }
214
}
215
break;
216
217
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
218
219
tcg_ctx->emit_before_op = op;
220
221
- cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
222
+ cbs = insn->mem_cbs;
223
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
224
struct qemu_plugin_dyn_cb *cb =
225
&g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
226
- if (cb->rw & rw) {
227
- gen_mem_cb(cb, meminfo, addr);
228
- }
229
- }
230
231
- cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
232
- for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
233
- struct qemu_plugin_dyn_cb *cb =
234
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
235
if (cb->rw & rw) {
236
- gen_inline_cb(cb);
237
+ switch (cb->type) {
238
+ case PLUGIN_CB_REGULAR:
239
+ gen_mem_cb(cb, meminfo, addr);
240
+ break;
241
+ case PLUGIN_CB_INLINE:
242
+ gen_inline_cb(cb);
243
+ break;
244
+ default:
245
+ g_assert_not_reached();
246
+ }
247
}
248
}
249
250
@@ -XXX,XX +XXX,XX @@ bool plugin_gen_tb_start(CPUState *cpu, const DisasContextBase *db,
251
252
if (test_bit(QEMU_PLUGIN_EV_VCPU_TB_TRANS, cpu->plugin_state->event_mask)) {
253
struct qemu_plugin_tb *ptb = tcg_ctx->plugin_tb;
254
- int i;
255
256
/* reset callbacks */
257
- for (i = 0; i < PLUGIN_N_CB_SUBTYPES; i++) {
258
- if (ptb->cbs[i]) {
259
- g_array_set_size(ptb->cbs[i], 0);
260
- }
261
+ if (ptb->cbs) {
262
+ g_array_set_size(ptb->cbs, 0);
71
}
263
}
72
new_size = MAX(new_size >> 1, 1 << CPU_TLB_DYN_MIN_BITS);
264
ptb->n = 0;
73
- env_tlb(env)->f[mmu_idx].mask = (new_size - 1) << CPU_TLB_ENTRY_BITS;
265
74
+ fast->mask = (new_size - 1) << CPU_TLB_ENTRY_BITS;
266
diff --git a/plugins/api.c b/plugins/api.c
75
267
index XXXXXXX..XXXXXXX 100644
76
- g_free(env_tlb(env)->f[mmu_idx].table);
268
--- a/plugins/api.c
77
- g_free(env_tlb(env)->d[mmu_idx].iotlb);
269
+++ b/plugins/api.c
78
- env_tlb(env)->f[mmu_idx].table = g_try_new(CPUTLBEntry, new_size);
270
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
79
- env_tlb(env)->d[mmu_idx].iotlb = g_try_new(CPUIOTLBEntry, new_size);
271
void *udata)
80
+ g_free(fast->table);
272
{
81
+ g_free(desc->iotlb);
273
if (!tb->mem_only) {
82
+ fast->table = g_try_new(CPUTLBEntry, new_size);
274
- plugin_register_dyn_cb__udata(&tb->cbs[PLUGIN_CB_REGULAR],
83
+ desc->iotlb = g_try_new(CPUIOTLBEntry, new_size);
275
- cb, flags, udata);
84
}
276
+ plugin_register_dyn_cb__udata(&tb->cbs, cb, flags, udata);
85
}
277
}
86
278
}
87
static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
279
88
{
280
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
89
- tlb_mmu_resize_locked(env, mmu_idx);
281
uint64_t imm)
90
+ tlb_mmu_resize_locked(&env_tlb(env)->d[mmu_idx], &env_tlb(env)->f[mmu_idx]);
282
{
91
env_tlb(env)->d[mmu_idx].n_used_entries = 0;
283
if (!tb->mem_only) {
92
env_tlb(env)->d[mmu_idx].large_page_addr = -1;
284
- plugin_register_inline_op_on_entry(
93
env_tlb(env)->d[mmu_idx].large_page_mask = -1;
285
- &tb->cbs[PLUGIN_CB_INLINE], 0, op, entry, imm);
286
+ plugin_register_inline_op_on_entry(&tb->cbs, 0, op, entry, imm);
287
}
288
}
289
290
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
291
void *udata)
292
{
293
if (!insn->mem_only) {
294
- plugin_register_dyn_cb__udata(
295
- &insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_REGULAR], cb, flags, udata);
296
+ plugin_register_dyn_cb__udata(&insn->insn_cbs, cb, flags, udata);
297
}
298
}
299
300
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
301
uint64_t imm)
302
{
303
if (!insn->mem_only) {
304
- plugin_register_inline_op_on_entry(
305
- &insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE], 0, op, entry, imm);
306
+ plugin_register_inline_op_on_entry(&insn->insn_cbs, 0, op, entry, imm);
307
}
308
}
309
310
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
311
enum qemu_plugin_mem_rw rw,
312
void *udata)
313
{
314
- plugin_register_vcpu_mem_cb(&insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR],
315
- cb, flags, rw, udata);
316
+ plugin_register_vcpu_mem_cb(&insn->mem_cbs, cb, flags, rw, udata);
317
}
318
319
void qemu_plugin_register_vcpu_mem_inline_per_vcpu(
320
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_register_vcpu_mem_inline_per_vcpu(
321
qemu_plugin_u64 entry,
322
uint64_t imm)
323
{
324
- plugin_register_inline_op_on_entry(
325
- &insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE], rw, op, entry, imm);
326
+ plugin_register_inline_op_on_entry(&insn->mem_cbs, rw, op, entry, imm);
327
}
328
329
void qemu_plugin_register_vcpu_tb_trans_cb(qemu_plugin_id_t id,
94
--
330
--
95
2.20.1
331
2.34.1
96
97
diff view generated by jsdifflib
New patch
[PULL 15/20] plugins: Introduce PLUGIN_CB_MEM_REGULAR
1
Use different enumerators for vcpu_udata and vcpu_mem callbacks.
1
2
3
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
---
6
include/qemu/plugin.h | 1 +
7
accel/tcg/plugin-gen.c | 2 +-
8
plugins/core.c | 4 ++--
9
3 files changed, 4 insertions(+), 3 deletions(-)
10
11
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
12
index XXXXXXX..XXXXXXX 100644
13
--- a/include/qemu/plugin.h
14
+++ b/include/qemu/plugin.h
15
@@ -XXX,XX +XXX,XX @@ union qemu_plugin_cb_sig {
16
17
enum plugin_dyn_cb_type {
18
PLUGIN_CB_REGULAR,
19
+ PLUGIN_CB_MEM_REGULAR,
20
PLUGIN_CB_INLINE,
21
};
22
23
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
24
index XXXXXXX..XXXXXXX 100644
25
--- a/accel/tcg/plugin-gen.c
26
+++ b/accel/tcg/plugin-gen.c
27
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
28
29
if (cb->rw & rw) {
30
switch (cb->type) {
31
- case PLUGIN_CB_REGULAR:
32
+ case PLUGIN_CB_MEM_REGULAR:
33
gen_mem_cb(cb, meminfo, addr);
34
break;
35
case PLUGIN_CB_INLINE:
36
diff --git a/plugins/core.c b/plugins/core.c
37
index XXXXXXX..XXXXXXX 100644
38
--- a/plugins/core.c
39
+++ b/plugins/core.c
40
@@ -XXX,XX +XXX,XX @@ void plugin_register_vcpu_mem_cb(GArray **arr,
41
42
struct qemu_plugin_dyn_cb *dyn_cb = plugin_get_dyn_cb(arr);
43
dyn_cb->userp = udata;
44
- dyn_cb->type = PLUGIN_CB_REGULAR;
45
+ dyn_cb->type = PLUGIN_CB_MEM_REGULAR;
46
dyn_cb->rw = rw;
47
dyn_cb->regular.f.vcpu_mem = cb;
48
49
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
50
break;
51
}
52
switch (cb->type) {
53
- case PLUGIN_CB_REGULAR:
54
+ case PLUGIN_CB_MEM_REGULAR:
55
cb->regular.f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw),
56
vaddr, cb->userp);
57
break;
58
--
59
2.34.1
diff view generated by jsdifflib
[PULL 07/16] cputlb: Merge tlb_table_flush_by_mmuidx into tlb_flush_one_mmuidx_locked
[PULL 16/20] plugins: Replace pr_ops with a proper debug dump flag
1
There is only one caller for tlb_table_flush_by_mmuidx. Place
1
The DEBUG_PLUGIN_GEN_OPS ifdef is replaced with "-d op_plugin".
2
the result at the earlier line number, due to an expected user
2
The second pr_ops call can be obtained with "-d op".
3
in the near future.
4
3
5
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
4
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
6
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
6
---
9
accel/tcg/cputlb.c | 19 +++++++------------
7
include/qemu/log.h | 1 +
10
1 file changed, 7 insertions(+), 12 deletions(-)
8
include/tcg/tcg.h | 1 +
9
accel/tcg/plugin-gen.c | 67 +++++++-----------------------------------
10
tcg/tcg.c | 29 +++++++++++++++++-
11
util/log.c | 4 +++
12
5 files changed, 45 insertions(+), 57 deletions(-)
11
13
12
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
14
diff --git a/include/qemu/log.h b/include/qemu/log.h
13
index XXXXXXX..XXXXXXX 100644
15
index XXXXXXX..XXXXXXX 100644
14
--- a/accel/tcg/cputlb.c
16
--- a/include/qemu/log.h
15
+++ b/accel/tcg/cputlb.c
17
+++ b/include/qemu/log.h
16
@@ -XXX,XX +XXX,XX @@ static void tlb_mmu_resize_locked(CPUArchState *env, int mmu_idx)
18
@@ -XXX,XX +XXX,XX @@ bool qemu_log_separate(void);
17
}
19
#define LOG_STRACE (1 << 19)
20
#define LOG_PER_THREAD (1 << 20)
21
#define CPU_LOG_TB_VPU (1 << 21)
22
+#define LOG_TB_OP_PLUGIN (1 << 22)
23
24
/* Lock/unlock output. */
25
26
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
27
index XXXXXXX..XXXXXXX 100644
28
--- a/include/tcg/tcg.h
29
+++ b/include/tcg/tcg.h
30
@@ -XXX,XX +XXX,XX @@ static inline const TCGOpcode *tcg_swap_vecop_list(const TCGOpcode *n)
18
}
31
}
19
32
20
-static inline void tlb_table_flush_by_mmuidx(CPUArchState *env, int mmu_idx)
33
bool tcg_can_emit_vecop_list(const TCGOpcode *, TCGType, unsigned);
21
+static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
34
+void tcg_dump_ops(TCGContext *s, FILE *f, bool have_prefs);
22
{
35
23
tlb_mmu_resize_locked(env, mmu_idx);
36
#endif /* TCG_H */
24
- memset(env_tlb(env)->f[mmu_idx].table, -1, sizeof_tlb(env, mmu_idx));
37
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
25
env_tlb(env)->d[mmu_idx].n_used_entries = 0;
38
index XXXXXXX..XXXXXXX 100644
26
+ env_tlb(env)->d[mmu_idx].large_page_addr = -1;
39
--- a/accel/tcg/plugin-gen.c
27
+ env_tlb(env)->d[mmu_idx].large_page_mask = -1;
40
+++ b/accel/tcg/plugin-gen.c
28
+ env_tlb(env)->d[mmu_idx].vindex = 0;
41
@@ -XXX,XX +XXX,XX @@
29
+ memset(env_tlb(env)->f[mmu_idx].table, -1, sizeof_tlb(env, mmu_idx));
42
*/
30
+ memset(env_tlb(env)->d[mmu_idx].vtable, -1,
43
#include "qemu/osdep.h"
31
+ sizeof(env_tlb(env)->d[0].vtable));
44
#include "qemu/plugin.h"
45
+#include "qemu/log.h"
46
#include "cpu.h"
47
#include "tcg/tcg.h"
48
#include "tcg/tcg-temp-internal.h"
49
@@ -XXX,XX +XXX,XX @@ static void gen_mem_cb(struct qemu_plugin_dyn_cb *cb,
50
tcg_temp_free_i32(cpu_index);
32
}
51
}
33
52
34
static inline void tlb_n_used_entries_inc(CPUArchState *env, uintptr_t mmu_idx)
53
-/* #define DEBUG_PLUGIN_GEN_OPS */
35
@@ -XXX,XX +XXX,XX @@ void tlb_flush_counts(size_t *pfull, size_t *ppart, size_t *pelide)
54
-static void pr_ops(void)
36
*pelide = elide;
37
}
38
39
-static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
40
-{
55
-{
41
- tlb_table_flush_by_mmuidx(env, mmu_idx);
56
-#ifdef DEBUG_PLUGIN_GEN_OPS
42
- env_tlb(env)->d[mmu_idx].large_page_addr = -1;
57
- TCGOp *op;
43
- env_tlb(env)->d[mmu_idx].large_page_mask = -1;
58
- int i = 0;
44
- env_tlb(env)->d[mmu_idx].vindex = 0;
59
-
45
- memset(env_tlb(env)->d[mmu_idx].vtable, -1,
60
- QTAILQ_FOREACH(op, &tcg_ctx->ops, link) {
46
- sizeof(env_tlb(env)->d[0].vtable));
61
- const char *name = "";
62
- const char *type = "";
63
-
64
- if (op->opc == INDEX_op_plugin_cb_start) {
65
- switch (op->args[0]) {
66
- case PLUGIN_GEN_FROM_TB:
67
- name = "tb";
68
- break;
69
- case PLUGIN_GEN_FROM_INSN:
70
- name = "insn";
71
- break;
72
- case PLUGIN_GEN_FROM_MEM:
73
- name = "mem";
74
- break;
75
- case PLUGIN_GEN_AFTER_INSN:
76
- name = "after insn";
77
- break;
78
- default:
79
- break;
80
- }
81
- switch (op->args[1]) {
82
- case PLUGIN_GEN_CB_UDATA:
83
- type = "udata";
84
- break;
85
- case PLUGIN_GEN_CB_INLINE:
86
- type = "inline";
87
- break;
88
- case PLUGIN_GEN_CB_MEM:
89
- type = "mem";
90
- break;
91
- case PLUGIN_GEN_ENABLE_MEM_HELPER:
92
- type = "enable mem helper";
93
- break;
94
- case PLUGIN_GEN_DISABLE_MEM_HELPER:
95
- type = "disable mem helper";
96
- break;
97
- default:
98
- break;
99
- }
100
- }
101
- printf("op[%2i]: %s %s %s\n", i, tcg_op_defs[op->opc].name, name, type);
102
- i++;
103
- }
104
-#endif
47
-}
105
-}
48
-
106
-
49
static void tlb_flush_by_mmuidx_async_work(CPUState *cpu, run_on_cpu_data data)
107
static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
50
{
108
{
51
CPUArchState *env = cpu->env_ptr;
109
TCGOp *op, *next;
110
int insn_idx = -1;
111
112
- pr_ops();
113
+ if (unlikely(qemu_loglevel_mask(LOG_TB_OP_PLUGIN)
114
+ && qemu_log_in_addr_range(plugin_tb->vaddr))) {
115
+ FILE *logfile = qemu_log_trylock();
116
+ if (logfile) {
117
+ fprintf(logfile, "OP before plugin injection:\n");
118
+ tcg_dump_ops(tcg_ctx, logfile, false);
119
+ fprintf(logfile, "\n");
120
+ qemu_log_unlock(logfile);
121
+ }
122
+ }
123
124
/*
125
* While injecting code, we cannot afford to reuse any ebb temps
126
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
127
break;
128
}
129
}
130
- pr_ops();
131
}
132
133
bool plugin_gen_tb_start(CPUState *cpu, const DisasContextBase *db,
134
diff --git a/tcg/tcg.c b/tcg/tcg.c
135
index XXXXXXX..XXXXXXX 100644
136
--- a/tcg/tcg.c
137
+++ b/tcg/tcg.c
138
@@ -XXX,XX +XXX,XX @@ static const char bswap_flag_name[][6] = {
139
[TCG_BSWAP_IZ | TCG_BSWAP_OS] = "iz,os",
140
};
141
142
+#ifdef CONFIG_PLUGIN
143
+static const char * const plugin_from_name[] = {
144
+ "from-tb",
145
+ "from-insn",
146
+ "after-insn",
147
+ "after-tb",
148
+};
149
+#endif
150
+
151
static inline bool tcg_regset_single(TCGRegSet d)
152
{
153
return (d & (d - 1)) == 0;
154
@@ -XXX,XX +XXX,XX @@ static inline TCGReg tcg_regset_first(TCGRegSet d)
155
#define ne_fprintf(...) \
156
({ int ret_ = fprintf(__VA_ARGS__); ret_ >= 0 ? ret_ : 0; })
157
158
-static void tcg_dump_ops(TCGContext *s, FILE *f, bool have_prefs)
159
+void tcg_dump_ops(TCGContext *s, FILE *f, bool have_prefs)
160
{
161
char buf[128];
162
TCGOp *op;
163
@@ -XXX,XX +XXX,XX @@ static void tcg_dump_ops(TCGContext *s, FILE *f, bool have_prefs)
164
i = k = 1;
165
}
166
break;
167
+#ifdef CONFIG_PLUGIN
168
+ case INDEX_op_plugin_cb:
169
+ {
170
+ TCGArg from = op->args[k++];
171
+ const char *name = NULL;
172
+
173
+ if (from < ARRAY_SIZE(plugin_from_name)) {
174
+ name = plugin_from_name[from];
175
+ }
176
+ if (name) {
177
+ col += ne_fprintf(f, "%s", name);
178
+ } else {
179
+ col += ne_fprintf(f, "$0x%" TCG_PRIlx, from);
180
+ }
181
+ i = 1;
182
+ }
183
+ break;
184
+#endif
185
default:
186
i = 0;
187
break;
188
diff --git a/util/log.c b/util/log.c
189
index XXXXXXX..XXXXXXX 100644
190
--- a/util/log.c
191
+++ b/util/log.c
192
@@ -XXX,XX +XXX,XX @@ const QEMULogItem qemu_log_items[] = {
193
"show micro ops after optimization" },
194
{ CPU_LOG_TB_OP_IND, "op_ind",
195
"show micro ops before indirect lowering" },
196
+#ifdef CONFIG_PLUGIN
197
+ { LOG_TB_OP_PLUGIN, "op_plugin",
198
+ "show micro ops before plugin injection" },
199
+#endif
200
{ CPU_LOG_INT, "int",
201
"show interrupts/exceptions in short format" },
202
{ CPU_LOG_EXEC, "exec",
52
--
203
--
53
2.20.1
204
2.34.1
54
55
diff view generated by jsdifflib
[PULL 02/16] util/cacheinfo: fix crash when compiling with uClibc
[PULL 17/20] plugins: Split out common cb expanders
1
From: Carlos Santos <casantos@redhat.com>
1
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
2
3
uClibc defines _SC_LEVEL1_ICACHE_LINESIZE and _SC_LEVEL1_DCACHE_LINESIZE
4
but the corresponding sysconf calls returns -1, which is a valid result,
5
meaning that the limit is indeterminate.
6
7
Handle this situation using the fallback values instead of crashing due
8
to an assertion failure.
9
10
Signed-off-by: Carlos Santos <casantos@redhat.com>
11
Message-Id: <20191017123713.30192-1-casantos@redhat.com>
12
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
13
---
3
---
14
util/cacheinfo.c | 10 ++++++++--
4
accel/tcg/plugin-gen.c | 84 +++++++++++++++++++++---------------------
15
1 file changed, 8 insertions(+), 2 deletions(-)
5
1 file changed, 41 insertions(+), 43 deletions(-)
16
6
17
diff --git a/util/cacheinfo.c b/util/cacheinfo.c
7
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
18
index XXXXXXX..XXXXXXX 100644
8
index XXXXXXX..XXXXXXX 100644
19
--- a/util/cacheinfo.c
9
--- a/accel/tcg/plugin-gen.c
20
+++ b/util/cacheinfo.c
10
+++ b/accel/tcg/plugin-gen.c
21
@@ -XXX,XX +XXX,XX @@ static void sys_cache_info(int *isize, int *dsize)
11
@@ -XXX,XX +XXX,XX @@ static void gen_mem_cb(struct qemu_plugin_dyn_cb *cb,
22
static void sys_cache_info(int *isize, int *dsize)
12
tcg_temp_free_i32(cpu_index);
13
}
14
15
+static void inject_cb(struct qemu_plugin_dyn_cb *cb)
16
+
17
+{
18
+ switch (cb->type) {
19
+ case PLUGIN_CB_REGULAR:
20
+ gen_udata_cb(cb);
21
+ break;
22
+ case PLUGIN_CB_INLINE:
23
+ gen_inline_cb(cb);
24
+ break;
25
+ default:
26
+ g_assert_not_reached();
27
+ }
28
+}
29
+
30
+static void inject_mem_cb(struct qemu_plugin_dyn_cb *cb,
31
+ enum qemu_plugin_mem_rw rw,
32
+ qemu_plugin_meminfo_t meminfo, TCGv_i64 addr)
33
+{
34
+ if (cb->rw & rw) {
35
+ switch (cb->type) {
36
+ case PLUGIN_CB_MEM_REGULAR:
37
+ gen_mem_cb(cb, meminfo, addr);
38
+ break;
39
+ default:
40
+ inject_cb(cb);
41
+ break;
42
+ }
43
+ }
44
+}
45
+
46
static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
23
{
47
{
24
# ifdef _SC_LEVEL1_ICACHE_LINESIZE
48
TCGOp *op, *next;
25
- *isize = sysconf(_SC_LEVEL1_ICACHE_LINESIZE);
49
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
26
+ int tmp_isize = (int) sysconf(_SC_LEVEL1_ICACHE_LINESIZE);
50
27
+ if (tmp_isize > 0) {
51
cbs = plugin_tb->cbs;
28
+ *isize = tmp_isize;
52
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
29
+ }
53
- struct qemu_plugin_dyn_cb *cb =
30
# endif
54
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
31
# ifdef _SC_LEVEL1_DCACHE_LINESIZE
55
-
32
- *dsize = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
56
- switch (cb->type) {
33
+ int tmp_dsize = (int) sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
57
- case PLUGIN_CB_REGULAR:
34
+ if (tmp_dsize > 0) {
58
- gen_udata_cb(cb);
35
+ *dsize = tmp_dsize;
59
- break;
36
+ }
60
- case PLUGIN_CB_INLINE:
37
# endif
61
- gen_inline_cb(cb);
38
}
62
- break;
39
#endif /* sys_cache_info */
63
- default:
64
- g_assert_not_reached();
65
- }
66
+ inject_cb(
67
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i));
68
}
69
break;
70
71
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
72
73
cbs = insn->insn_cbs;
74
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
75
- struct qemu_plugin_dyn_cb *cb =
76
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
77
-
78
- switch (cb->type) {
79
- case PLUGIN_CB_REGULAR:
80
- gen_udata_cb(cb);
81
- break;
82
- case PLUGIN_CB_INLINE:
83
- gen_inline_cb(cb);
84
- break;
85
- default:
86
- g_assert_not_reached();
87
- }
88
+ inject_cb(
89
+ &g_array_index(cbs, struct qemu_plugin_dyn_cb, i));
90
}
91
break;
92
93
@@ -XXX,XX +XXX,XX @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
94
{
95
TCGv_i64 addr = temp_tcgv_i64(arg_temp(op->args[0]));
96
qemu_plugin_meminfo_t meminfo = op->args[1];
97
+ enum qemu_plugin_mem_rw rw =
98
+ (qemu_plugin_mem_is_store(meminfo)
99
+ ? QEMU_PLUGIN_MEM_W : QEMU_PLUGIN_MEM_R);
100
struct qemu_plugin_insn *insn;
101
const GArray *cbs;
102
- int i, n, rw;
103
+ int i, n;
104
105
assert(insn_idx >= 0);
106
insn = g_ptr_array_index(plugin_tb->insns, insn_idx);
107
- rw = qemu_plugin_mem_is_store(meminfo) ? 2 : 1;
108
109
tcg_ctx->emit_before_op = op;
110
111
cbs = insn->mem_cbs;
112
for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
113
- struct qemu_plugin_dyn_cb *cb =
114
- &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
115
-
116
- if (cb->rw & rw) {
117
- switch (cb->type) {
118
- case PLUGIN_CB_MEM_REGULAR:
119
- gen_mem_cb(cb, meminfo, addr);
120
- break;
121
- case PLUGIN_CB_INLINE:
122
- gen_inline_cb(cb);
123
- break;
124
- default:
125
- g_assert_not_reached();
126
- }
127
- }
128
+ inject_mem_cb(&g_array_index(cbs, struct qemu_plugin_dyn_cb, i),
129
+ rw, meminfo, addr);
130
}
131
132
tcg_ctx->emit_before_op = NULL;
40
--
133
--
41
2.20.1
134
2.34.1
42
43
diff view generated by jsdifflib
[PULL 13/16] cputlb: Partially merge tlb_dyn_init into tlb_init
[PULL 18/20] plugins: Merge qemu_plugin_tb_insn_get to plugin-gen.c
1
Merge into the only caller, but at the same time split
1
Merge qemu_plugin_insn_alloc and qemu_plugin_tb_insn_get into
2
out tlb_mmu_init to initialize a single tlb entry.
2
plugin_gen_insn_start, since it is used nowhere else.
3
3
4
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
4
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
5
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
6
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
6
---
9
accel/tcg/cputlb.c | 33 ++++++++++++++++-----------------
7
include/qemu/plugin.h | 39 ---------------------------------------
10
1 file changed, 16 insertions(+), 17 deletions(-)
8
accel/tcg/plugin-gen.c | 39 ++++++++++++++++++++++++++++++++-------
9
2 files changed, 32 insertions(+), 46 deletions(-)
11
10
12
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
11
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
13
index XXXXXXX..XXXXXXX 100644
12
index XXXXXXX..XXXXXXX 100644
14
--- a/accel/tcg/cputlb.c
13
--- a/include/qemu/plugin.h
15
+++ b/accel/tcg/cputlb.c
14
+++ b/include/qemu/plugin.h
16
@@ -XXX,XX +XXX,XX @@ static void tlb_window_reset(CPUTLBDesc *desc, int64_t ns,
15
@@ -XXX,XX +XXX,XX @@ static inline void qemu_plugin_insn_cleanup_fn(gpointer data)
17
desc->window_max_entries = max_entries;
16
g_byte_array_free(insn->data, true);
18
}
17
}
19
18
20
-static void tlb_dyn_init(CPUArchState *env)
19
-static inline struct qemu_plugin_insn *qemu_plugin_insn_alloc(void)
21
-{
20
-{
22
- int i;
21
- struct qemu_plugin_insn *insn = g_new0(struct qemu_plugin_insn, 1);
23
-
22
-
24
- for (i = 0; i < NB_MMU_MODES; i++) {
23
- insn->data = g_byte_array_sized_new(4);
25
- CPUTLBDesc *desc = &env_tlb(env)->d[i];
24
- return insn;
26
- size_t n_entries = 1 << CPU_TLB_DYN_DEFAULT_BITS;
25
-}
27
-
26
-
28
- tlb_window_reset(desc, get_clock_realtime(), 0);
27
/* Internal context for this TranslationBlock */
29
- desc->n_used_entries = 0;
28
struct qemu_plugin_tb {
30
- env_tlb(env)->f[i].mask = (n_entries - 1) << CPU_TLB_ENTRY_BITS;
29
GPtrArray *insns;
31
- env_tlb(env)->f[i].table = g_new(CPUTLBEntry, n_entries);
30
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_tb {
32
- env_tlb(env)->d[i].iotlb = g_new(CPUIOTLBEntry, n_entries);
31
GArray *cbs;
32
};
33
34
-/**
35
- * qemu_plugin_tb_insn_get(): get next plugin record for translation.
36
- * @tb: the internal tb context
37
- * @pc: address of instruction
38
- */
39
-static inline
40
-struct qemu_plugin_insn *qemu_plugin_tb_insn_get(struct qemu_plugin_tb *tb,
41
- uint64_t pc)
42
-{
43
- struct qemu_plugin_insn *insn;
44
-
45
- if (unlikely(tb->n == tb->insns->len)) {
46
- struct qemu_plugin_insn *new_insn = qemu_plugin_insn_alloc();
47
- g_ptr_array_add(tb->insns, new_insn);
33
- }
48
- }
49
-
50
- insn = g_ptr_array_index(tb->insns, tb->n++);
51
- g_byte_array_set_size(insn->data, 0);
52
- insn->calls_helpers = false;
53
- insn->mem_helper = false;
54
- insn->vaddr = pc;
55
- if (insn->insn_cbs) {
56
- g_array_set_size(insn->insn_cbs, 0);
57
- }
58
- if (insn->mem_cbs) {
59
- g_array_set_size(insn->mem_cbs, 0);
60
- }
61
-
62
- return insn;
34
-}
63
-}
35
-
64
-
36
/**
65
/**
37
* tlb_mmu_resize_locked() - perform TLB resize bookkeeping; resize if necessary
66
* struct CPUPluginState - per-CPU state for plugins
38
* @desc: The CPUTLBDesc portion of the TLB
67
* @event_mask: plugin event bitmap. Modified only via async work.
39
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
68
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
40
tlb_mmu_flush_locked(desc, fast);
69
index XXXXXXX..XXXXXXX 100644
70
--- a/accel/tcg/plugin-gen.c
71
+++ b/accel/tcg/plugin-gen.c
72
@@ -XXX,XX +XXX,XX @@ bool plugin_gen_tb_start(CPUState *cpu, const DisasContextBase *db,
73
void plugin_gen_insn_start(CPUState *cpu, const DisasContextBase *db)
74
{
75
struct qemu_plugin_tb *ptb = tcg_ctx->plugin_tb;
76
- struct qemu_plugin_insn *pinsn;
77
+ struct qemu_plugin_insn *insn;
78
+ size_t n = db->num_insns;
79
+ vaddr pc;
80
81
- pinsn = qemu_plugin_tb_insn_get(ptb, db->pc_next);
82
- tcg_ctx->plugin_insn = pinsn;
83
- plugin_gen_empty_callback(PLUGIN_GEN_FROM_INSN);
84
+ assert(n >= 1);
85
+ ptb->n = n;
86
+ if (n <= ptb->insns->len) {
87
+ insn = g_ptr_array_index(ptb->insns, n - 1);
88
+ g_byte_array_set_size(insn->data, 0);
89
+ } else {
90
+ assert(n - 1 == ptb->insns->len);
91
+ insn = g_new0(struct qemu_plugin_insn, 1);
92
+ insn->data = g_byte_array_sized_new(4);
93
+ g_ptr_array_add(ptb->insns, insn);
94
+ }
95
+
96
+ tcg_ctx->plugin_insn = insn;
97
+ insn->calls_helpers = false;
98
+ insn->mem_helper = false;
99
+ if (insn->insn_cbs) {
100
+ g_array_set_size(insn->insn_cbs, 0);
101
+ }
102
+ if (insn->mem_cbs) {
103
+ g_array_set_size(insn->mem_cbs, 0);
104
+ }
105
+
106
+ pc = db->pc_next;
107
+ insn->vaddr = pc;
108
109
/*
110
* Detect page crossing to get the new host address.
111
@@ -XXX,XX +XXX,XX @@ void plugin_gen_insn_start(CPUState *cpu, const DisasContextBase *db)
112
* fetching instructions from a region not backed by RAM.
113
*/
114
if (ptb->haddr1 == NULL) {
115
- pinsn->haddr = NULL;
116
+ insn->haddr = NULL;
117
} else if (is_same_page(db, db->pc_next)) {
118
- pinsn->haddr = ptb->haddr1 + pinsn->vaddr - ptb->vaddr;
119
+ insn->haddr = ptb->haddr1 + pc - ptb->vaddr;
120
} else {
121
if (ptb->vaddr2 == -1) {
122
ptb->vaddr2 = TARGET_PAGE_ALIGN(db->pc_first);
123
get_page_addr_code_hostp(cpu_env(cpu), ptb->vaddr2, &ptb->haddr2);
124
}
125
- pinsn->haddr = ptb->haddr2 + pinsn->vaddr - ptb->vaddr2;
126
+ insn->haddr = ptb->haddr2 + pc - ptb->vaddr2;
127
}
128
+
129
+ plugin_gen_empty_callback(PLUGIN_GEN_FROM_INSN);
41
}
130
}
42
131
43
+static void tlb_mmu_init(CPUTLBDesc *desc, CPUTLBDescFast *fast, int64_t now)
132
void plugin_gen_insn_end(void)
44
+{
45
+ size_t n_entries = 1 << CPU_TLB_DYN_DEFAULT_BITS;
46
+
47
+ tlb_window_reset(desc, now, 0);
48
+ desc->n_used_entries = 0;
49
+ fast->mask = (n_entries - 1) << CPU_TLB_ENTRY_BITS;
50
+ fast->table = g_new(CPUTLBEntry, n_entries);
51
+ desc->iotlb = g_new(CPUIOTLBEntry, n_entries);
52
+}
53
+
54
static inline void tlb_n_used_entries_inc(CPUArchState *env, uintptr_t mmu_idx)
55
{
56
env_tlb(env)->d[mmu_idx].n_used_entries++;
57
@@ -XXX,XX +XXX,XX @@ static inline void tlb_n_used_entries_dec(CPUArchState *env, uintptr_t mmu_idx)
58
void tlb_init(CPUState *cpu)
59
{
60
CPUArchState *env = cpu->env_ptr;
61
+ int64_t now = get_clock_realtime();
62
+ int i;
63
64
qemu_spin_init(&env_tlb(env)->c.lock);
65
66
/* Ensure that cpu_reset performs a full flush. */
67
env_tlb(env)->c.dirty = ALL_MMUIDX_BITS;
68
69
- tlb_dyn_init(env);
70
+ for (i = 0; i < NB_MMU_MODES; i++) {
71
+ tlb_mmu_init(&env_tlb(env)->d[i], &env_tlb(env)->f[i], now);
72
+ }
73
}
74
75
/* flush_all_helper: run fn across all cpus
76
--
133
--
77
2.20.1
134
2.34.1
78
79
diff view generated by jsdifflib
[PULL 09/16] cputlb: Pass CPUTLBDescFast to tlb_n_entries and sizeof_tlb
[PULL 19/20] plugins: Inline plugin_gen_empty_callback
1
We do not need the entire CPUArchState to compute these values.
1
Each caller can use tcg_gen_plugin_cb directly.
2
2
3
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
3
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
4
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
5
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
5
---
8
accel/tcg/cputlb.c | 15 ++++++++-------
6
accel/tcg/plugin-gen.c | 19 +++----------------
9
1 file changed, 8 insertions(+), 7 deletions(-)
7
1 file changed, 3 insertions(+), 16 deletions(-)
10
8
11
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
9
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
12
index XXXXXXX..XXXXXXX 100644
10
index XXXXXXX..XXXXXXX 100644
13
--- a/accel/tcg/cputlb.c
11
--- a/accel/tcg/plugin-gen.c
14
+++ b/accel/tcg/cputlb.c
12
+++ b/accel/tcg/plugin-gen.c
15
@@ -XXX,XX +XXX,XX @@ QEMU_BUILD_BUG_ON(sizeof(target_ulong) > sizeof(run_on_cpu_data));
13
@@ -XXX,XX +XXX,XX @@ enum plugin_gen_from {
16
QEMU_BUILD_BUG_ON(NB_MMU_MODES > 16);
14
PLUGIN_GEN_AFTER_TB,
17
#define ALL_MMUIDX_BITS ((1 << NB_MMU_MODES) - 1)
15
};
18
16
19
-static inline size_t tlb_n_entries(CPUArchState *env, uintptr_t mmu_idx)
17
-static void plugin_gen_empty_callback(enum plugin_gen_from from)
20
+static inline size_t tlb_n_entries(CPUTLBDescFast *fast)
18
-{
19
- switch (from) {
20
- case PLUGIN_GEN_AFTER_INSN:
21
- case PLUGIN_GEN_FROM_TB:
22
- case PLUGIN_GEN_FROM_INSN:
23
- tcg_gen_plugin_cb(from);
24
- break;
25
- default:
26
- g_assert_not_reached();
27
- }
28
-}
29
-
30
/* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
31
void plugin_gen_disable_mem_helpers(void)
21
{
32
{
22
- return (env_tlb(env)->f[mmu_idx].mask >> CPU_TLB_ENTRY_BITS) + 1;
33
@@ -XXX,XX +XXX,XX @@ bool plugin_gen_tb_start(CPUState *cpu, const DisasContextBase *db,
23
+ return (fast->mask >> CPU_TLB_ENTRY_BITS) + 1;
34
ptb->mem_only = mem_only;
35
ptb->mem_helper = false;
36
37
- plugin_gen_empty_callback(PLUGIN_GEN_FROM_TB);
38
+ tcg_gen_plugin_cb(PLUGIN_GEN_FROM_TB);
39
}
40
41
tcg_ctx->plugin_insn = NULL;
42
@@ -XXX,XX +XXX,XX @@ void plugin_gen_insn_start(CPUState *cpu, const DisasContextBase *db)
43
insn->haddr = ptb->haddr2 + pc - ptb->vaddr2;
44
}
45
46
- plugin_gen_empty_callback(PLUGIN_GEN_FROM_INSN);
47
+ tcg_gen_plugin_cb(PLUGIN_GEN_FROM_INSN);
24
}
48
}
25
49
26
-static inline size_t sizeof_tlb(CPUArchState *env, uintptr_t mmu_idx)
50
void plugin_gen_insn_end(void)
27
+static inline size_t sizeof_tlb(CPUTLBDescFast *fast)
28
{
51
{
29
- return env_tlb(env)->f[mmu_idx].mask + (1 << CPU_TLB_ENTRY_BITS);
52
- plugin_gen_empty_callback(PLUGIN_GEN_AFTER_INSN);
30
+ return fast->mask + (1 << CPU_TLB_ENTRY_BITS);
53
+ tcg_gen_plugin_cb(PLUGIN_GEN_AFTER_INSN);
31
}
54
}
32
55
33
static void tlb_window_reset(CPUTLBDesc *desc, int64_t ns,
56
/*
34
@@ -XXX,XX +XXX,XX @@ static void tlb_dyn_init(CPUArchState *env)
35
static void tlb_mmu_resize_locked(CPUArchState *env, int mmu_idx)
36
{
37
CPUTLBDesc *desc = &env_tlb(env)->d[mmu_idx];
38
- size_t old_size = tlb_n_entries(env, mmu_idx);
39
+ size_t old_size = tlb_n_entries(&env_tlb(env)->f[mmu_idx]);
40
size_t rate;
41
size_t new_size = old_size;
42
int64_t now = get_clock_realtime();
43
@@ -XXX,XX +XXX,XX @@ static void tlb_flush_one_mmuidx_locked(CPUArchState *env, int mmu_idx)
44
env_tlb(env)->d[mmu_idx].large_page_addr = -1;
45
env_tlb(env)->d[mmu_idx].large_page_mask = -1;
46
env_tlb(env)->d[mmu_idx].vindex = 0;
47
- memset(env_tlb(env)->f[mmu_idx].table, -1, sizeof_tlb(env, mmu_idx));
48
+ memset(env_tlb(env)->f[mmu_idx].table, -1,
49
+ sizeof_tlb(&env_tlb(env)->f[mmu_idx]));
50
memset(env_tlb(env)->d[mmu_idx].vtable, -1,
51
sizeof(env_tlb(env)->d[0].vtable));
52
}
53
@@ -XXX,XX +XXX,XX @@ void tlb_reset_dirty(CPUState *cpu, ram_addr_t start1, ram_addr_t length)
54
qemu_spin_lock(&env_tlb(env)->c.lock);
55
for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
56
unsigned int i;
57
- unsigned int n = tlb_n_entries(env, mmu_idx);
58
+ unsigned int n = tlb_n_entries(&env_tlb(env)->f[mmu_idx]);
59
60
for (i = 0; i < n; i++) {
61
tlb_reset_dirty_range_locked(&env_tlb(env)->f[mmu_idx].table[i],
62
--
57
--
63
2.20.1
58
2.34.1
64
59
65
60
diff view generated by jsdifflib
New patch
[PULL 20/20] plugins: Update the documentation block for plugin-gen.c
1
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
3
---
4
accel/tcg/plugin-gen.c | 31 ++++---------------------------
5
1 file changed, 4 insertions(+), 27 deletions(-)
1
6
7
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
8
index XXXXXXX..XXXXXXX 100644
9
--- a/accel/tcg/plugin-gen.c
10
+++ b/accel/tcg/plugin-gen.c
11
@@ -XXX,XX +XXX,XX @@
12
* Injecting the desired instrumentation could be done with a second
13
* translation pass that combined the instrumentation requests, but that
14
* would be ugly and inefficient since we would decode the guest code twice.
15
- * Instead, during TB translation we add "empty" instrumentation calls for all
16
- * possible instrumentation events, and then once we collect the instrumentation
17
- * requests from plugins, we either "fill in" those empty events or remove them
18
- * if they have no requests.
19
- *
20
- * When "filling in" an event we first copy the empty callback's TCG ops. This
21
- * might seem unnecessary, but it is done to support an arbitrary number
22
- * of callbacks per event. Take for example a regular instruction callback.
23
- * We first generate a callback to an empty helper function. Then, if two
24
- * plugins register one callback each for this instruction, we make two copies
25
- * of the TCG ops generated for the empty callback, substituting the function
26
- * pointer that points to the empty helper function with the plugins' desired
27
- * callback functions. After that we remove the empty callback's ops.
28
- *
29
- * Note that the location in TCGOp.args[] of the pointer to a helper function
30
- * varies across different guest and host architectures. Instead of duplicating
31
- * the logic that figures this out, we rely on the fact that the empty
32
- * callbacks point to empty functions that are unique pointers in the program.
33
- * Thus, to find the right location we just have to look for a match in
34
- * TCGOp.args[]. This is the main reason why we first copy an empty callback's
35
- * TCG ops and then fill them in; regardless of whether we have one or many
36
- * callbacks for that event, the logic to add all of them is the same.
37
- *
38
- * When generating more than one callback per event, we make a small
39
- * optimization to avoid generating redundant operations. For instance, for the
40
- * second and all subsequent callbacks of an event, we do not need to reload the
41
- * CPU's index into a TCG temp, since the first callback did it already.
42
+ * Instead, during TB translation we add "plugin_cb" marker opcodes
43
+ * for all possible instrumentation events, and then once we collect the
44
+ * instrumentation requests from plugins, we generate code for those markers
45
+ * or remove them if they have no requests.
46
*/
47
#include "qemu/osdep.h"
48
#include "qemu/plugin.h"
49
--
50
2.34.1
diff view generated by jsdifflib

Patchew 2.1-devel-b67e4c2

© 2016 - 2025 Red Hat, Inc.