1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 *
4 * Copyright IBM Corp. 2007
5 * Copyright 2011 Freescale Semiconductor, Inc.
6 *
7 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
8 */
9
10 #include <linux/jiffies.h>
11 #include <linux/hrtimer.h>
12 #include <linux/types.h>
13 #include <linux/string.h>
14 #include <linux/kvm_host.h>
15 #include <linux/clockchips.h>
16
17 #include <asm/reg.h>
18 #include <asm/time.h>
19 #include <asm/byteorder.h>
20 #include <asm/kvm_ppc.h>
21 #include <asm/disassemble.h>
22 #include <asm/ppc-opcode.h>
23 #include <asm/sstep.h>
24 #include "timing.h"
25 #include "trace.h"
26
27 #ifdef CONFIG_PPC_FPU
kvmppc_check_fp_disabled(struct kvm_vcpu * vcpu)28 static bool kvmppc_check_fp_disabled(struct kvm_vcpu *vcpu)
29 {
30 if (!(kvmppc_get_msr(vcpu) & MSR_FP)) {
31 kvmppc_core_queue_fpunavail(vcpu, kvmppc_get_msr(vcpu) & SRR1_PREFIXED);
32 return true;
33 }
34
35 return false;
36 }
37 #endif /* CONFIG_PPC_FPU */
38
39 #ifdef CONFIG_VSX
kvmppc_check_vsx_disabled(struct kvm_vcpu * vcpu)40 static bool kvmppc_check_vsx_disabled(struct kvm_vcpu *vcpu)
41 {
42 if (!(kvmppc_get_msr(vcpu) & MSR_VSX)) {
43 kvmppc_core_queue_vsx_unavail(vcpu, kvmppc_get_msr(vcpu) & SRR1_PREFIXED);
44 return true;
45 }
46
47 return false;
48 }
49 #endif /* CONFIG_VSX */
50
51 #ifdef CONFIG_ALTIVEC
kvmppc_check_altivec_disabled(struct kvm_vcpu * vcpu)52 static bool kvmppc_check_altivec_disabled(struct kvm_vcpu *vcpu)
53 {
54 if (!(kvmppc_get_msr(vcpu) & MSR_VEC)) {
55 kvmppc_core_queue_vec_unavail(vcpu, kvmppc_get_msr(vcpu) & SRR1_PREFIXED);
56 return true;
57 }
58
59 return false;
60 }
61 #endif /* CONFIG_ALTIVEC */
62
63 /*
64 * XXX to do:
65 * lfiwax, lfiwzx
66 * vector loads and stores
67 *
68 * Instructions that trap when used on cache-inhibited mappings
69 * are not emulated here: multiple and string instructions,
70 * lq/stq, and the load-reserve/store-conditional instructions.
71 */
kvmppc_emulate_loadstore(struct kvm_vcpu * vcpu)72 int kvmppc_emulate_loadstore(struct kvm_vcpu *vcpu)
73 {
74 ppc_inst_t inst;
75 enum emulation_result emulated = EMULATE_FAIL;
76 struct instruction_op op;
77
78 /* this default type might be overwritten by subcategories */
79 kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
80
81 emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &inst);
82 if (emulated != EMULATE_DONE)
83 return emulated;
84
85 vcpu->arch.mmio_vsx_copy_nums = 0;
86 vcpu->arch.mmio_vsx_offset = 0;
87 vcpu->arch.mmio_copy_type = KVMPPC_VSX_COPY_NONE;
88 vcpu->arch.mmio_sp64_extend = 0;
89 vcpu->arch.mmio_sign_extend = 0;
90 vcpu->arch.mmio_vmx_copy_nums = 0;
91 vcpu->arch.mmio_vmx_offset = 0;
92 vcpu->arch.mmio_host_swabbed = 0;
93
94 emulated = EMULATE_FAIL;
95 vcpu->arch.regs.msr = vcpu->arch.shared->msr;
96 if (analyse_instr(&op, &vcpu->arch.regs, inst) == 0) {
97 int type = op.type & INSTR_TYPE_MASK;
98 int size = GETSIZE(op.type);
99
100 vcpu->mmio_is_write = OP_IS_STORE(type);
101
102 switch (type) {
103 case LOAD: {
104 int instr_byte_swap = op.type & BYTEREV;
105
106 if (op.type & SIGNEXT)
107 emulated = kvmppc_handle_loads(vcpu,
108 op.reg, size, !instr_byte_swap);
109 else
110 emulated = kvmppc_handle_load(vcpu,
111 op.reg, size, !instr_byte_swap);
112
113 if ((op.type & UPDATE) && (emulated != EMULATE_FAIL))
114 kvmppc_set_gpr(vcpu, op.update_reg, op.ea);
115
116 break;
117 }
118 #ifdef CONFIG_PPC_FPU
119 case LOAD_FP:
120 if (kvmppc_check_fp_disabled(vcpu))
121 return EMULATE_DONE;
122
123 if (op.type & FPCONV)
124 vcpu->arch.mmio_sp64_extend = 1;
125
126 if (op.type & SIGNEXT)
127 emulated = kvmppc_handle_loads(vcpu,
128 KVM_MMIO_REG_FPR|op.reg, size, 1);
129 else
130 emulated = kvmppc_handle_load(vcpu,
131 KVM_MMIO_REG_FPR|op.reg, size, 1);
132
133 if ((op.type & UPDATE) && (emulated != EMULATE_FAIL))
134 kvmppc_set_gpr(vcpu, op.update_reg, op.ea);
135
136 break;
137 #endif
138 #ifdef CONFIG_ALTIVEC
139 case LOAD_VMX:
140 if (kvmppc_check_altivec_disabled(vcpu))
141 return EMULATE_DONE;
142
143 /* Hardware enforces alignment of VMX accesses */
144 vcpu->arch.vaddr_accessed &= ~((unsigned long)size - 1);
145 vcpu->arch.paddr_accessed &= ~((unsigned long)size - 1);
146
147 if (size == 16) { /* lvx */
148 vcpu->arch.mmio_copy_type =
149 KVMPPC_VMX_COPY_DWORD;
150 } else if (size == 4) { /* lvewx */
151 vcpu->arch.mmio_copy_type =
152 KVMPPC_VMX_COPY_WORD;
153 } else if (size == 2) { /* lvehx */
154 vcpu->arch.mmio_copy_type =
155 KVMPPC_VMX_COPY_HWORD;
156 } else if (size == 1) { /* lvebx */
157 vcpu->arch.mmio_copy_type =
158 KVMPPC_VMX_COPY_BYTE;
159 } else
160 break;
161
162 vcpu->arch.mmio_vmx_offset =
163 (vcpu->arch.vaddr_accessed & 0xf)/size;
164
165 if (size == 16) {
166 vcpu->arch.mmio_vmx_copy_nums = 2;
167 emulated = kvmppc_handle_vmx_load(vcpu,
168 KVM_MMIO_REG_VMX|op.reg,
169 8, 1);
170 } else {
171 vcpu->arch.mmio_vmx_copy_nums = 1;
172 emulated = kvmppc_handle_vmx_load(vcpu,
173 KVM_MMIO_REG_VMX|op.reg,
174 size, 1);
175 }
176 break;
177 #endif
178 #ifdef CONFIG_VSX
179 case LOAD_VSX: {
180 int io_size_each;
181
182 if (op.vsx_flags & VSX_CHECK_VEC) {
183 if (kvmppc_check_altivec_disabled(vcpu))
184 return EMULATE_DONE;
185 } else {
186 if (kvmppc_check_vsx_disabled(vcpu))
187 return EMULATE_DONE;
188 }
189
190 if (op.vsx_flags & VSX_FPCONV)
191 vcpu->arch.mmio_sp64_extend = 1;
192
193 if (op.element_size == 8) {
194 if (op.vsx_flags & VSX_SPLAT)
195 vcpu->arch.mmio_copy_type =
196 KVMPPC_VSX_COPY_DWORD_LOAD_DUMP;
197 else
198 vcpu->arch.mmio_copy_type =
199 KVMPPC_VSX_COPY_DWORD;
200 } else if (op.element_size == 4) {
201 if (op.vsx_flags & VSX_SPLAT)
202 vcpu->arch.mmio_copy_type =
203 KVMPPC_VSX_COPY_WORD_LOAD_DUMP;
204 else
205 vcpu->arch.mmio_copy_type =
206 KVMPPC_VSX_COPY_WORD;
207 } else
208 break;
209
210 if (size < op.element_size) {
211 /* precision convert case: lxsspx, etc */
212 vcpu->arch.mmio_vsx_copy_nums = 1;
213 io_size_each = size;
214 } else { /* lxvw4x, lxvd2x, etc */
215 vcpu->arch.mmio_vsx_copy_nums =
216 size/op.element_size;
217 io_size_each = op.element_size;
218 }
219
220 emulated = kvmppc_handle_vsx_load(vcpu,
221 KVM_MMIO_REG_VSX|op.reg, io_size_each,
222 1, op.type & SIGNEXT);
223 break;
224 }
225 #endif
226 case STORE:
227 /* if need byte reverse, op.val has been reversed by
228 * analyse_instr().
229 */
230 emulated = kvmppc_handle_store(vcpu, op.val, size, 1);
231
232 if ((op.type & UPDATE) && (emulated != EMULATE_FAIL))
233 kvmppc_set_gpr(vcpu, op.update_reg, op.ea);
234
235 break;
236 #ifdef CONFIG_PPC_FPU
237 case STORE_FP:
238 if (kvmppc_check_fp_disabled(vcpu))
239 return EMULATE_DONE;
240
241 /* The FP registers need to be flushed so that
242 * kvmppc_handle_store() can read actual FP vals
243 * from vcpu->arch.
244 */
245 if (vcpu->kvm->arch.kvm_ops->giveup_ext)
246 vcpu->kvm->arch.kvm_ops->giveup_ext(vcpu,
247 MSR_FP);
248
249 if (op.type & FPCONV)
250 vcpu->arch.mmio_sp64_extend = 1;
251
252 emulated = kvmppc_handle_store(vcpu,
253 VCPU_FPR(vcpu, op.reg), size, 1);
254
255 if ((op.type & UPDATE) && (emulated != EMULATE_FAIL))
256 kvmppc_set_gpr(vcpu, op.update_reg, op.ea);
257
258 break;
259 #endif
260 #ifdef CONFIG_ALTIVEC
261 case STORE_VMX:
262 if (kvmppc_check_altivec_disabled(vcpu))
263 return EMULATE_DONE;
264
265 /* Hardware enforces alignment of VMX accesses. */
266 vcpu->arch.vaddr_accessed &= ~((unsigned long)size - 1);
267 vcpu->arch.paddr_accessed &= ~((unsigned long)size - 1);
268
269 if (vcpu->kvm->arch.kvm_ops->giveup_ext)
270 vcpu->kvm->arch.kvm_ops->giveup_ext(vcpu,
271 MSR_VEC);
272 if (size == 16) { /* stvx */
273 vcpu->arch.mmio_copy_type =
274 KVMPPC_VMX_COPY_DWORD;
275 } else if (size == 4) { /* stvewx */
276 vcpu->arch.mmio_copy_type =
277 KVMPPC_VMX_COPY_WORD;
278 } else if (size == 2) { /* stvehx */
279 vcpu->arch.mmio_copy_type =
280 KVMPPC_VMX_COPY_HWORD;
281 } else if (size == 1) { /* stvebx */
282 vcpu->arch.mmio_copy_type =
283 KVMPPC_VMX_COPY_BYTE;
284 } else
285 break;
286
287 vcpu->arch.mmio_vmx_offset =
288 (vcpu->arch.vaddr_accessed & 0xf)/size;
289
290 if (size == 16) {
291 vcpu->arch.mmio_vmx_copy_nums = 2;
292 emulated = kvmppc_handle_vmx_store(vcpu,
293 op.reg, 8, 1);
294 } else {
295 vcpu->arch.mmio_vmx_copy_nums = 1;
296 emulated = kvmppc_handle_vmx_store(vcpu,
297 op.reg, size, 1);
298 }
299
300 break;
301 #endif
302 #ifdef CONFIG_VSX
303 case STORE_VSX: {
304 int io_size_each;
305
306 if (op.vsx_flags & VSX_CHECK_VEC) {
307 if (kvmppc_check_altivec_disabled(vcpu))
308 return EMULATE_DONE;
309 } else {
310 if (kvmppc_check_vsx_disabled(vcpu))
311 return EMULATE_DONE;
312 }
313
314 if (vcpu->kvm->arch.kvm_ops->giveup_ext)
315 vcpu->kvm->arch.kvm_ops->giveup_ext(vcpu,
316 MSR_VSX);
317
318 if (op.vsx_flags & VSX_FPCONV)
319 vcpu->arch.mmio_sp64_extend = 1;
320
321 if (op.element_size == 8)
322 vcpu->arch.mmio_copy_type =
323 KVMPPC_VSX_COPY_DWORD;
324 else if (op.element_size == 4)
325 vcpu->arch.mmio_copy_type =
326 KVMPPC_VSX_COPY_WORD;
327 else
328 break;
329
330 if (size < op.element_size) {
331 /* precise conversion case, like stxsspx */
332 vcpu->arch.mmio_vsx_copy_nums = 1;
333 io_size_each = size;
334 } else { /* stxvw4x, stxvd2x, etc */
335 vcpu->arch.mmio_vsx_copy_nums =
336 size/op.element_size;
337 io_size_each = op.element_size;
338 }
339
340 emulated = kvmppc_handle_vsx_store(vcpu,
341 op.reg, io_size_each, 1);
342 break;
343 }
344 #endif
345 case CACHEOP:
346 /* Do nothing. The guest is performing dcbi because
347 * hardware DMA is not snooped by the dcache, but
348 * emulated DMA either goes through the dcache as
349 * normal writes, or the host kernel has handled dcache
350 * coherence.
351 */
352 emulated = EMULATE_DONE;
353 break;
354 default:
355 break;
356 }
357 }
358
359 trace_kvm_ppc_instr(ppc_inst_val(inst), kvmppc_get_pc(vcpu), emulated);
360
361 /* Advance past emulated instruction. */
362 if (emulated != EMULATE_FAIL)
363 kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + ppc_inst_len(inst));
364
365 return emulated;
366 }
367