xref: /openbmc/linux/arch/s390/kvm/intercept.c (revision ae3473231e77a3f1909d48cd144cebe5e1d049b3)
1 /*
2  * in-kernel handling for sie intercepts
3  *
4  * Copyright IBM Corp. 2008, 2014
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License (version 2 only)
8  * as published by the Free Software Foundation.
9  *
10  *    Author(s): Carsten Otte <cotte@de.ibm.com>
11  *               Christian Borntraeger <borntraeger@de.ibm.com>
12  */
13 
14 #include <linux/kvm_host.h>
15 #include <linux/errno.h>
16 #include <linux/pagemap.h>
17 
18 #include <asm/kvm_host.h>
19 #include <asm/asm-offsets.h>
20 #include <asm/irq.h>
21 
22 #include "kvm-s390.h"
23 #include "gaccess.h"
24 #include "trace.h"
25 #include "trace-s390.h"
26 
27 
28 static const intercept_handler_t instruction_handlers[256] = {
29 	[0x01] = kvm_s390_handle_01,
30 	[0x82] = kvm_s390_handle_lpsw,
31 	[0x83] = kvm_s390_handle_diag,
32 	[0xaa] = kvm_s390_handle_aa,
33 	[0xae] = kvm_s390_handle_sigp,
34 	[0xb2] = kvm_s390_handle_b2,
35 	[0xb6] = kvm_s390_handle_stctl,
36 	[0xb7] = kvm_s390_handle_lctl,
37 	[0xb9] = kvm_s390_handle_b9,
38 	[0xe5] = kvm_s390_handle_e5,
39 	[0xeb] = kvm_s390_handle_eb,
40 };
41 
42 u8 kvm_s390_get_ilen(struct kvm_vcpu *vcpu)
43 {
44 	struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;
45 	u8 ilen = 0;
46 
47 	switch (vcpu->arch.sie_block->icptcode) {
48 	case ICPT_INST:
49 	case ICPT_INSTPROGI:
50 	case ICPT_OPEREXC:
51 	case ICPT_PARTEXEC:
52 	case ICPT_IOINST:
53 		/* instruction only stored for these icptcodes */
54 		ilen = insn_length(vcpu->arch.sie_block->ipa >> 8);
55 		/* Use the length of the EXECUTE instruction if necessary */
56 		if (sie_block->icptstatus & 1) {
57 			ilen = (sie_block->icptstatus >> 4) & 0x6;
58 			if (!ilen)
59 				ilen = 4;
60 		}
61 		break;
62 	case ICPT_PROGI:
63 		/* bit 1+2 of pgmilc are the ilc, so we directly get ilen */
64 		ilen = vcpu->arch.sie_block->pgmilc & 0x6;
65 		break;
66 	}
67 	return ilen;
68 }
69 
70 static int handle_noop(struct kvm_vcpu *vcpu)
71 {
72 	switch (vcpu->arch.sie_block->icptcode) {
73 	case 0x10:
74 		vcpu->stat.exit_external_request++;
75 		break;
76 	default:
77 		break; /* nothing */
78 	}
79 	return 0;
80 }
81 
82 static int handle_stop(struct kvm_vcpu *vcpu)
83 {
84 	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
85 	int rc = 0;
86 	uint8_t flags, stop_pending;
87 
88 	vcpu->stat.exit_stop_request++;
89 
90 	/* delay the stop if any non-stop irq is pending */
91 	if (kvm_s390_vcpu_has_irq(vcpu, 1))
92 		return 0;
93 
94 	/* avoid races with the injection/SIGP STOP code */
95 	spin_lock(&li->lock);
96 	flags = li->irq.stop.flags;
97 	stop_pending = kvm_s390_is_stop_irq_pending(vcpu);
98 	spin_unlock(&li->lock);
99 
100 	trace_kvm_s390_stop_request(stop_pending, flags);
101 	if (!stop_pending)
102 		return 0;
103 
104 	if (flags & KVM_S390_STOP_FLAG_STORE_STATUS) {
105 		rc = kvm_s390_vcpu_store_status(vcpu,
106 						KVM_S390_STORE_STATUS_NOADDR);
107 		if (rc)
108 			return rc;
109 	}
110 
111 	if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
112 		kvm_s390_vcpu_stop(vcpu);
113 	return -EOPNOTSUPP;
114 }
115 
116 static int handle_validity(struct kvm_vcpu *vcpu)
117 {
118 	int viwhy = vcpu->arch.sie_block->ipb >> 16;
119 
120 	vcpu->stat.exit_validity++;
121 	trace_kvm_s390_intercept_validity(vcpu, viwhy);
122 	KVM_EVENT(3, "validity intercept 0x%x for pid %u (kvm 0x%pK)", viwhy,
123 		  current->pid, vcpu->kvm);
124 
125 	/* do not warn on invalid runtime instrumentation mode */
126 	WARN_ONCE(viwhy != 0x44, "kvm: unhandled validity intercept 0x%x\n",
127 		  viwhy);
128 	return -EINVAL;
129 }
130 
131 static int handle_instruction(struct kvm_vcpu *vcpu)
132 {
133 	intercept_handler_t handler;
134 
135 	vcpu->stat.exit_instruction++;
136 	trace_kvm_s390_intercept_instruction(vcpu,
137 					     vcpu->arch.sie_block->ipa,
138 					     vcpu->arch.sie_block->ipb);
139 	handler = instruction_handlers[vcpu->arch.sie_block->ipa >> 8];
140 	if (handler)
141 		return handler(vcpu);
142 	return -EOPNOTSUPP;
143 }
144 
145 static int inject_prog_on_prog_intercept(struct kvm_vcpu *vcpu)
146 {
147 	struct kvm_s390_pgm_info pgm_info = {
148 		.code = vcpu->arch.sie_block->iprcc,
149 		/* the PSW has already been rewound */
150 		.flags = KVM_S390_PGM_FLAGS_NO_REWIND,
151 	};
152 
153 	switch (vcpu->arch.sie_block->iprcc & ~PGM_PER) {
154 	case PGM_AFX_TRANSLATION:
155 	case PGM_ASX_TRANSLATION:
156 	case PGM_EX_TRANSLATION:
157 	case PGM_LFX_TRANSLATION:
158 	case PGM_LSTE_SEQUENCE:
159 	case PGM_LSX_TRANSLATION:
160 	case PGM_LX_TRANSLATION:
161 	case PGM_PRIMARY_AUTHORITY:
162 	case PGM_SECONDARY_AUTHORITY:
163 	case PGM_SPACE_SWITCH:
164 		pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
165 		break;
166 	case PGM_ALEN_TRANSLATION:
167 	case PGM_ALE_SEQUENCE:
168 	case PGM_ASTE_INSTANCE:
169 	case PGM_ASTE_SEQUENCE:
170 	case PGM_ASTE_VALIDITY:
171 	case PGM_EXTENDED_AUTHORITY:
172 		pgm_info.exc_access_id = vcpu->arch.sie_block->eai;
173 		break;
174 	case PGM_ASCE_TYPE:
175 	case PGM_PAGE_TRANSLATION:
176 	case PGM_REGION_FIRST_TRANS:
177 	case PGM_REGION_SECOND_TRANS:
178 	case PGM_REGION_THIRD_TRANS:
179 	case PGM_SEGMENT_TRANSLATION:
180 		pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
181 		pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
182 		pgm_info.op_access_id  = vcpu->arch.sie_block->oai;
183 		break;
184 	case PGM_MONITOR:
185 		pgm_info.mon_class_nr = vcpu->arch.sie_block->mcn;
186 		pgm_info.mon_code = vcpu->arch.sie_block->tecmc;
187 		break;
188 	case PGM_VECTOR_PROCESSING:
189 	case PGM_DATA:
190 		pgm_info.data_exc_code = vcpu->arch.sie_block->dxc;
191 		break;
192 	case PGM_PROTECTION:
193 		pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
194 		pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
195 		break;
196 	default:
197 		break;
198 	}
199 
200 	if (vcpu->arch.sie_block->iprcc & PGM_PER) {
201 		pgm_info.per_code = vcpu->arch.sie_block->perc;
202 		pgm_info.per_atmid = vcpu->arch.sie_block->peratmid;
203 		pgm_info.per_address = vcpu->arch.sie_block->peraddr;
204 		pgm_info.per_access_id = vcpu->arch.sie_block->peraid;
205 	}
206 	return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
207 }
208 
209 /*
210  * restore ITDB to program-interruption TDB in guest lowcore
211  * and set TX abort indication if required
212 */
213 static int handle_itdb(struct kvm_vcpu *vcpu)
214 {
215 	struct kvm_s390_itdb *itdb;
216 	int rc;
217 
218 	if (!IS_TE_ENABLED(vcpu) || !IS_ITDB_VALID(vcpu))
219 		return 0;
220 	if (current->thread.per_flags & PER_FLAG_NO_TE)
221 		return 0;
222 	itdb = (struct kvm_s390_itdb *)vcpu->arch.sie_block->itdba;
223 	rc = write_guest_lc(vcpu, __LC_PGM_TDB, itdb, sizeof(*itdb));
224 	if (rc)
225 		return rc;
226 	memset(itdb, 0, sizeof(*itdb));
227 
228 	return 0;
229 }
230 
231 #define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
232 
233 static int handle_prog(struct kvm_vcpu *vcpu)
234 {
235 	psw_t psw;
236 	int rc;
237 
238 	vcpu->stat.exit_program_interruption++;
239 
240 	if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
241 		kvm_s390_handle_per_event(vcpu);
242 		/* the interrupt might have been filtered out completely */
243 		if (vcpu->arch.sie_block->iprcc == 0)
244 			return 0;
245 	}
246 
247 	trace_kvm_s390_intercept_prog(vcpu, vcpu->arch.sie_block->iprcc);
248 	if (vcpu->arch.sie_block->iprcc == PGM_SPECIFICATION) {
249 		rc = read_guest_lc(vcpu, __LC_PGM_NEW_PSW, &psw, sizeof(psw_t));
250 		if (rc)
251 			return rc;
252 		/* Avoid endless loops of specification exceptions */
253 		if (!is_valid_psw(&psw))
254 			return -EOPNOTSUPP;
255 	}
256 	rc = handle_itdb(vcpu);
257 	if (rc)
258 		return rc;
259 
260 	return inject_prog_on_prog_intercept(vcpu);
261 }
262 
263 /**
264  * handle_external_interrupt - used for external interruption interceptions
265  *
266  * This interception only occurs if the CPUSTAT_EXT_INT bit was set, or if
267  * the new PSW does not have external interrupts disabled. In the first case,
268  * we've got to deliver the interrupt manually, and in the second case, we
269  * drop to userspace to handle the situation there.
270  */
271 static int handle_external_interrupt(struct kvm_vcpu *vcpu)
272 {
273 	u16 eic = vcpu->arch.sie_block->eic;
274 	struct kvm_s390_irq irq;
275 	psw_t newpsw;
276 	int rc;
277 
278 	vcpu->stat.exit_external_interrupt++;
279 
280 	rc = read_guest_lc(vcpu, __LC_EXT_NEW_PSW, &newpsw, sizeof(psw_t));
281 	if (rc)
282 		return rc;
283 	/* We can not handle clock comparator or timer interrupt with bad PSW */
284 	if ((eic == EXT_IRQ_CLK_COMP || eic == EXT_IRQ_CPU_TIMER) &&
285 	    (newpsw.mask & PSW_MASK_EXT))
286 		return -EOPNOTSUPP;
287 
288 	switch (eic) {
289 	case EXT_IRQ_CLK_COMP:
290 		irq.type = KVM_S390_INT_CLOCK_COMP;
291 		break;
292 	case EXT_IRQ_CPU_TIMER:
293 		irq.type = KVM_S390_INT_CPU_TIMER;
294 		break;
295 	case EXT_IRQ_EXTERNAL_CALL:
296 		irq.type = KVM_S390_INT_EXTERNAL_CALL;
297 		irq.u.extcall.code = vcpu->arch.sie_block->extcpuaddr;
298 		rc = kvm_s390_inject_vcpu(vcpu, &irq);
299 		/* ignore if another external call is already pending */
300 		if (rc == -EBUSY)
301 			return 0;
302 		return rc;
303 	default:
304 		return -EOPNOTSUPP;
305 	}
306 
307 	return kvm_s390_inject_vcpu(vcpu, &irq);
308 }
309 
310 /**
311  * Handle MOVE PAGE partial execution interception.
312  *
313  * This interception can only happen for guests with DAT disabled and
314  * addresses that are currently not mapped in the host. Thus we try to
315  * set up the mappings for the corresponding user pages here (or throw
316  * addressing exceptions in case of illegal guest addresses).
317  */
318 static int handle_mvpg_pei(struct kvm_vcpu *vcpu)
319 {
320 	unsigned long srcaddr, dstaddr;
321 	int reg1, reg2, rc;
322 
323 	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
324 
325 	/* Make sure that the source is paged-in */
326 	rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg2],
327 				     reg2, &srcaddr, GACC_FETCH);
328 	if (rc)
329 		return kvm_s390_inject_prog_cond(vcpu, rc);
330 	rc = kvm_arch_fault_in_page(vcpu, srcaddr, 0);
331 	if (rc != 0)
332 		return rc;
333 
334 	/* Make sure that the destination is paged-in */
335 	rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg1],
336 				     reg1, &dstaddr, GACC_STORE);
337 	if (rc)
338 		return kvm_s390_inject_prog_cond(vcpu, rc);
339 	rc = kvm_arch_fault_in_page(vcpu, dstaddr, 1);
340 	if (rc != 0)
341 		return rc;
342 
343 	kvm_s390_retry_instr(vcpu);
344 
345 	return 0;
346 }
347 
348 static int handle_partial_execution(struct kvm_vcpu *vcpu)
349 {
350 	vcpu->stat.exit_pei++;
351 
352 	if (vcpu->arch.sie_block->ipa == 0xb254)	/* MVPG */
353 		return handle_mvpg_pei(vcpu);
354 	if (vcpu->arch.sie_block->ipa >> 8 == 0xae)	/* SIGP */
355 		return kvm_s390_handle_sigp_pei(vcpu);
356 
357 	return -EOPNOTSUPP;
358 }
359 
360 static int handle_operexc(struct kvm_vcpu *vcpu)
361 {
362 	vcpu->stat.exit_operation_exception++;
363 	trace_kvm_s390_handle_operexc(vcpu, vcpu->arch.sie_block->ipa,
364 				      vcpu->arch.sie_block->ipb);
365 
366 	if (vcpu->arch.sie_block->ipa == 0xb256 &&
367 	    test_kvm_facility(vcpu->kvm, 74))
368 		return handle_sthyi(vcpu);
369 
370 	if (vcpu->arch.sie_block->ipa == 0 && vcpu->kvm->arch.user_instr0)
371 		return -EOPNOTSUPP;
372 
373 	return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
374 }
375 
376 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
377 {
378 	int rc, per_rc = 0;
379 
380 	if (kvm_is_ucontrol(vcpu->kvm))
381 		return -EOPNOTSUPP;
382 
383 	switch (vcpu->arch.sie_block->icptcode) {
384 	case 0x10:
385 	case 0x18:
386 		return handle_noop(vcpu);
387 	case 0x04:
388 		rc = handle_instruction(vcpu);
389 		break;
390 	case 0x08:
391 		return handle_prog(vcpu);
392 	case 0x14:
393 		return handle_external_interrupt(vcpu);
394 	case 0x1c:
395 		return kvm_s390_handle_wait(vcpu);
396 	case 0x20:
397 		return handle_validity(vcpu);
398 	case 0x28:
399 		return handle_stop(vcpu);
400 	case 0x2c:
401 		rc = handle_operexc(vcpu);
402 		break;
403 	case 0x38:
404 		rc = handle_partial_execution(vcpu);
405 		break;
406 	default:
407 		return -EOPNOTSUPP;
408 	}
409 
410 	/* process PER, also if the instrution is processed in user space */
411 	if (vcpu->arch.sie_block->icptstatus & 0x02 &&
412 	    (!rc || rc == -EOPNOTSUPP))
413 		per_rc = kvm_s390_handle_per_ifetch_icpt(vcpu);
414 	return per_rc ? per_rc : rc;
415 }
416