migration: increase max-bandwidth to 128 MiB/s (1 Gib/s)
[qemu.git] / target / s390x / gdbstub.c
1 /*
2 * s390x gdb server stub
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 * Copyright (c) 2013 SUSE LINUX Products GmbH
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "internal.h"
24 #include "exec/exec-all.h"
25 #include "exec/gdbstub.h"
26 #include "qemu/bitops.h"
27 #include "sysemu/hw_accel.h"
28 #include "sysemu/tcg.h"
29
30 int s390_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
31 {
32 S390CPU *cpu = S390_CPU(cs);
33 CPUS390XState *env = &cpu->env;
34 uint64_t val;
35 int cc_op;
36
37 switch (n) {
38 case S390_PSWM_REGNUM:
39 if (tcg_enabled()) {
40 cc_op = calc_cc(env, env->cc_op, env->cc_src, env->cc_dst,
41 env->cc_vr);
42 val = deposit64(env->psw.mask, 44, 2, cc_op);
43 return gdb_get_regl(mem_buf, val);
44 }
45 return gdb_get_regl(mem_buf, env->psw.mask);
46 case S390_PSWA_REGNUM:
47 return gdb_get_regl(mem_buf, env->psw.addr);
48 case S390_R0_REGNUM ... S390_R15_REGNUM:
49 return gdb_get_regl(mem_buf, env->regs[n - S390_R0_REGNUM]);
50 }
51 return 0;
52 }
53
54 int s390_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
55 {
56 S390CPU *cpu = S390_CPU(cs);
57 CPUS390XState *env = &cpu->env;
58 target_ulong tmpl = ldtul_p(mem_buf);
59
60 switch (n) {
61 case S390_PSWM_REGNUM:
62 env->psw.mask = tmpl;
63 if (tcg_enabled()) {
64 env->cc_op = extract64(tmpl, 44, 2);
65 }
66 break;
67 case S390_PSWA_REGNUM:
68 env->psw.addr = tmpl;
69 break;
70 case S390_R0_REGNUM ... S390_R15_REGNUM:
71 env->regs[n - S390_R0_REGNUM] = tmpl;
72 break;
73 default:
74 return 0;
75 }
76 return 8;
77 }
78
79 /* the values represent the positions in s390-acr.xml */
80 #define S390_A0_REGNUM 0
81 #define S390_A15_REGNUM 15
82 /* total number of registers in s390-acr.xml */
83 #define S390_NUM_AC_REGS 16
84
85 static int cpu_read_ac_reg(CPUS390XState *env, GByteArray *buf, int n)
86 {
87 switch (n) {
88 case S390_A0_REGNUM ... S390_A15_REGNUM:
89 return gdb_get_reg32(buf, env->aregs[n]);
90 default:
91 return 0;
92 }
93 }
94
95 static int cpu_write_ac_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
96 {
97 switch (n) {
98 case S390_A0_REGNUM ... S390_A15_REGNUM:
99 env->aregs[n] = ldl_p(mem_buf);
100 cpu_synchronize_post_init(env_cpu(env));
101 return 4;
102 default:
103 return 0;
104 }
105 }
106
107 /* the values represent the positions in s390-fpr.xml */
108 #define S390_FPC_REGNUM 0
109 #define S390_F0_REGNUM 1
110 #define S390_F15_REGNUM 16
111 /* total number of registers in s390-fpr.xml */
112 #define S390_NUM_FP_REGS 17
113
114 static int cpu_read_fp_reg(CPUS390XState *env, GByteArray *buf, int n)
115 {
116 switch (n) {
117 case S390_FPC_REGNUM:
118 return gdb_get_reg32(buf, env->fpc);
119 case S390_F0_REGNUM ... S390_F15_REGNUM:
120 return gdb_get_reg64(buf, *get_freg(env, n - S390_F0_REGNUM));
121 default:
122 return 0;
123 }
124 }
125
126 static int cpu_write_fp_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
127 {
128 switch (n) {
129 case S390_FPC_REGNUM:
130 env->fpc = ldl_p(mem_buf);
131 return 4;
132 case S390_F0_REGNUM ... S390_F15_REGNUM:
133 *get_freg(env, n - S390_F0_REGNUM) = ldtul_p(mem_buf);
134 return 8;
135 default:
136 return 0;
137 }
138 }
139
140 /* the values represent the positions in s390-vx.xml */
141 #define S390_V0L_REGNUM 0
142 #define S390_V15L_REGNUM 15
143 #define S390_V16_REGNUM 16
144 #define S390_V31_REGNUM 31
145 /* total number of registers in s390-vx.xml */
146 #define S390_NUM_VREGS 32
147
148 static int cpu_read_vreg(CPUS390XState *env, GByteArray *buf, int n)
149 {
150 int ret;
151
152 switch (n) {
153 case S390_V0L_REGNUM ... S390_V15L_REGNUM:
154 ret = gdb_get_reg64(buf, env->vregs[n][1]);
155 break;
156 case S390_V16_REGNUM ... S390_V31_REGNUM:
157 ret = gdb_get_reg64(buf, env->vregs[n][0]);
158 ret += gdb_get_reg64(buf, env->vregs[n][1]);
159 break;
160 default:
161 ret = 0;
162 }
163
164 return ret;
165 }
166
167 static int cpu_write_vreg(CPUS390XState *env, uint8_t *mem_buf, int n)
168 {
169 switch (n) {
170 case S390_V0L_REGNUM ... S390_V15L_REGNUM:
171 env->vregs[n][1] = ldtul_p(mem_buf + 8);
172 return 8;
173 case S390_V16_REGNUM ... S390_V31_REGNUM:
174 env->vregs[n][0] = ldtul_p(mem_buf);
175 env->vregs[n][1] = ldtul_p(mem_buf + 8);
176 return 16;
177 default:
178 return 0;
179 }
180 }
181
182 /* the values represent the positions in s390-cr.xml */
183 #define S390_C0_REGNUM 0
184 #define S390_C15_REGNUM 15
185 /* total number of registers in s390-cr.xml */
186 #define S390_NUM_C_REGS 16
187
188 #ifndef CONFIG_USER_ONLY
189 static int cpu_read_c_reg(CPUS390XState *env, GByteArray *buf, int n)
190 {
191 switch (n) {
192 case S390_C0_REGNUM ... S390_C15_REGNUM:
193 return gdb_get_regl(buf, env->cregs[n]);
194 default:
195 return 0;
196 }
197 }
198
199 static int cpu_write_c_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
200 {
201 switch (n) {
202 case S390_C0_REGNUM ... S390_C15_REGNUM:
203 env->cregs[n] = ldtul_p(mem_buf);
204 if (tcg_enabled()) {
205 tlb_flush(env_cpu(env));
206 }
207 cpu_synchronize_post_init(env_cpu(env));
208 return 8;
209 default:
210 return 0;
211 }
212 }
213
214 /* the values represent the positions in s390-virt.xml */
215 #define S390_VIRT_CKC_REGNUM 0
216 #define S390_VIRT_CPUTM_REGNUM 1
217 #define S390_VIRT_BEA_REGNUM 2
218 #define S390_VIRT_PREFIX_REGNUM 3
219 #define S390_VIRT_PP_REGNUM 4
220 #define S390_VIRT_PFT_REGNUM 5
221 #define S390_VIRT_PFS_REGNUM 6
222 #define S390_VIRT_PFC_REGNUM 7
223 /* total number of registers in s390-virt.xml */
224 #define S390_NUM_VIRT_REGS 8
225
226 static int cpu_read_virt_reg(CPUS390XState *env, GByteArray *mem_buf, int n)
227 {
228 switch (n) {
229 case S390_VIRT_CKC_REGNUM:
230 return gdb_get_regl(mem_buf, env->ckc);
231 case S390_VIRT_CPUTM_REGNUM:
232 return gdb_get_regl(mem_buf, env->cputm);
233 case S390_VIRT_BEA_REGNUM:
234 return gdb_get_regl(mem_buf, env->gbea);
235 case S390_VIRT_PREFIX_REGNUM:
236 return gdb_get_regl(mem_buf, env->psa);
237 case S390_VIRT_PP_REGNUM:
238 return gdb_get_regl(mem_buf, env->pp);
239 case S390_VIRT_PFT_REGNUM:
240 return gdb_get_regl(mem_buf, env->pfault_token);
241 case S390_VIRT_PFS_REGNUM:
242 return gdb_get_regl(mem_buf, env->pfault_select);
243 case S390_VIRT_PFC_REGNUM:
244 return gdb_get_regl(mem_buf, env->pfault_compare);
245 default:
246 return 0;
247 }
248 }
249
250 static int cpu_write_virt_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
251 {
252 switch (n) {
253 case S390_VIRT_CKC_REGNUM:
254 env->ckc = ldtul_p(mem_buf);
255 cpu_synchronize_post_init(env_cpu(env));
256 return 8;
257 case S390_VIRT_CPUTM_REGNUM:
258 env->cputm = ldtul_p(mem_buf);
259 cpu_synchronize_post_init(env_cpu(env));
260 return 8;
261 case S390_VIRT_BEA_REGNUM:
262 env->gbea = ldtul_p(mem_buf);
263 cpu_synchronize_post_init(env_cpu(env));
264 return 8;
265 case S390_VIRT_PREFIX_REGNUM:
266 env->psa = ldtul_p(mem_buf);
267 cpu_synchronize_post_init(env_cpu(env));
268 return 8;
269 case S390_VIRT_PP_REGNUM:
270 env->pp = ldtul_p(mem_buf);
271 cpu_synchronize_post_init(env_cpu(env));
272 return 8;
273 case S390_VIRT_PFT_REGNUM:
274 env->pfault_token = ldtul_p(mem_buf);
275 cpu_synchronize_post_init(env_cpu(env));
276 return 8;
277 case S390_VIRT_PFS_REGNUM:
278 env->pfault_select = ldtul_p(mem_buf);
279 cpu_synchronize_post_init(env_cpu(env));
280 return 8;
281 case S390_VIRT_PFC_REGNUM:
282 env->pfault_compare = ldtul_p(mem_buf);
283 cpu_synchronize_post_init(env_cpu(env));
284 return 8;
285 default:
286 return 0;
287 }
288 }
289 #endif
290
291 /* the values represent the positions in s390-gs.xml */
292 #define S390_GS_RESERVED_REGNUM 0
293 #define S390_GS_GSD_REGNUM 1
294 #define S390_GS_GSSM_REGNUM 2
295 #define S390_GS_GSEPLA_REGNUM 3
296 /* total number of registers in s390-gs.xml */
297 #define S390_NUM_GS_REGS 4
298
299 static int cpu_read_gs_reg(CPUS390XState *env, GByteArray *buf, int n)
300 {
301 return gdb_get_regl(buf, env->gscb[n]);
302 }
303
304 static int cpu_write_gs_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
305 {
306 env->gscb[n] = ldtul_p(mem_buf);
307 cpu_synchronize_post_init(env_cpu(env));
308 return 8;
309 }
310
311 void s390_cpu_gdb_init(CPUState *cs)
312 {
313 gdb_register_coprocessor(cs, cpu_read_ac_reg,
314 cpu_write_ac_reg,
315 S390_NUM_AC_REGS, "s390-acr.xml", 0);
316
317 gdb_register_coprocessor(cs, cpu_read_fp_reg,
318 cpu_write_fp_reg,
319 S390_NUM_FP_REGS, "s390-fpr.xml", 0);
320
321 gdb_register_coprocessor(cs, cpu_read_vreg,
322 cpu_write_vreg,
323 S390_NUM_VREGS, "s390-vx.xml", 0);
324
325 gdb_register_coprocessor(cs, cpu_read_gs_reg,
326 cpu_write_gs_reg,
327 S390_NUM_GS_REGS, "s390-gs.xml", 0);
328
329 #ifndef CONFIG_USER_ONLY
330 gdb_register_coprocessor(cs, cpu_read_c_reg,
331 cpu_write_c_reg,
332 S390_NUM_C_REGS, "s390-cr.xml", 0);
333
334 if (kvm_enabled()) {
335 gdb_register_coprocessor(cs, cpu_read_virt_reg,
336 cpu_write_virt_reg,
337 S390_NUM_VIRT_REGS, "s390-virt.xml", 0);
338 }
339 #endif
340 }