1 // SPDX-License-Identifier: GPL-2.0
3 * handling privileged instructions
5 * Copyright IBM Corp. 2008, 2020
7 * Author(s): Carsten Otte <cotte@de.ibm.com>
8 * Christian Borntraeger <borntraeger@de.ibm.com>
11 #include <linux/kvm.h>
12 #include <linux/gfp.h>
13 #include <linux/errno.h>
14 #include <linux/compat.h>
15 #include <linux/mm_types.h>
17 #include <asm/asm-offsets.h>
18 #include <asm/facility.h>
19 #include <asm/current.h>
20 #include <asm/debug.h>
21 #include <asm/ebcdic.h>
22 #include <asm/sysinfo.h>
23 #include <asm/pgtable.h>
24 #include <asm/page-states.h>
25 #include <asm/pgalloc.h>
28 #include <asm/ptrace.h>
35 static int handle_ri(struct kvm_vcpu
*vcpu
)
37 vcpu
->stat
.instruction_ri
++;
39 if (test_kvm_facility(vcpu
->kvm
, 64)) {
40 VCPU_EVENT(vcpu
, 3, "%s", "ENABLE: RI (lazy)");
41 vcpu
->arch
.sie_block
->ecb3
|= ECB3_RI
;
42 kvm_s390_retry_instr(vcpu
);
45 return kvm_s390_inject_program_int(vcpu
, PGM_OPERATION
);
48 int kvm_s390_handle_aa(struct kvm_vcpu
*vcpu
)
50 if ((vcpu
->arch
.sie_block
->ipa
& 0xf) <= 4)
51 return handle_ri(vcpu
);
56 static int handle_gs(struct kvm_vcpu
*vcpu
)
58 vcpu
->stat
.instruction_gs
++;
60 if (test_kvm_facility(vcpu
->kvm
, 133)) {
61 VCPU_EVENT(vcpu
, 3, "%s", "ENABLE: GS (lazy)");
64 current
->thread
.gs_cb
= (struct gs_cb
*)&vcpu
->run
->s
.regs
.gscb
;
65 restore_gs_cb(current
->thread
.gs_cb
);
67 vcpu
->arch
.sie_block
->ecb
|= ECB_GS
;
68 vcpu
->arch
.sie_block
->ecd
|= ECD_HOSTREGMGMT
;
69 vcpu
->arch
.gs_enabled
= 1;
70 kvm_s390_retry_instr(vcpu
);
73 return kvm_s390_inject_program_int(vcpu
, PGM_OPERATION
);
76 int kvm_s390_handle_e3(struct kvm_vcpu
*vcpu
)
78 int code
= vcpu
->arch
.sie_block
->ipb
& 0xff;
80 if (code
== 0x49 || code
== 0x4d)
81 return handle_gs(vcpu
);
85 /* Handle SCK (SET CLOCK) interception */
86 static int handle_set_clock(struct kvm_vcpu
*vcpu
)
88 struct kvm_s390_vm_tod_clock gtod
= { 0 };
93 vcpu
->stat
.instruction_sck
++;
95 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
96 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
98 op2
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
99 if (op2
& 7) /* Operand must be on a doubleword boundary */
100 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
101 rc
= read_guest(vcpu
, op2
, ar
, >od
.tod
, sizeof(gtod
.tod
));
103 return kvm_s390_inject_prog_cond(vcpu
, rc
);
105 VCPU_EVENT(vcpu
, 3, "SCK: setting guest TOD to 0x%llx", gtod
.tod
);
106 kvm_s390_set_tod_clock(vcpu
->kvm
, >od
);
108 kvm_s390_set_psw_cc(vcpu
, 0);
112 static int handle_set_prefix(struct kvm_vcpu
*vcpu
)
119 vcpu
->stat
.instruction_spx
++;
121 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
122 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
124 operand2
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
126 /* must be word boundary */
128 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
131 rc
= read_guest(vcpu
, operand2
, ar
, &address
, sizeof(address
));
133 return kvm_s390_inject_prog_cond(vcpu
, rc
);
135 address
&= 0x7fffe000u
;
138 * Make sure the new value is valid memory. We only need to check the
139 * first page, since address is 8k aligned and memory pieces are always
140 * at least 1MB aligned and have at least a size of 1MB.
142 if (kvm_is_error_gpa(vcpu
->kvm
, address
))
143 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
145 kvm_s390_set_prefix(vcpu
, address
);
146 trace_kvm_s390_handle_prefix(vcpu
, 1, address
);
150 static int handle_store_prefix(struct kvm_vcpu
*vcpu
)
157 vcpu
->stat
.instruction_stpx
++;
159 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
160 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
162 operand2
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
164 /* must be word boundary */
166 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
168 address
= kvm_s390_get_prefix(vcpu
);
171 rc
= write_guest(vcpu
, operand2
, ar
, &address
, sizeof(address
));
173 return kvm_s390_inject_prog_cond(vcpu
, rc
);
175 VCPU_EVENT(vcpu
, 3, "STPX: storing prefix 0x%x into 0x%llx", address
, operand2
);
176 trace_kvm_s390_handle_prefix(vcpu
, 0, address
);
180 static int handle_store_cpu_address(struct kvm_vcpu
*vcpu
)
182 u16 vcpu_id
= vcpu
->vcpu_id
;
187 vcpu
->stat
.instruction_stap
++;
189 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
190 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
192 ga
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
195 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
197 rc
= write_guest(vcpu
, ga
, ar
, &vcpu_id
, sizeof(vcpu_id
));
199 return kvm_s390_inject_prog_cond(vcpu
, rc
);
201 VCPU_EVENT(vcpu
, 3, "STAP: storing cpu address (%u) to 0x%llx", vcpu_id
, ga
);
202 trace_kvm_s390_handle_stap(vcpu
, ga
);
206 int kvm_s390_skey_check_enable(struct kvm_vcpu
*vcpu
)
210 trace_kvm_s390_skey_related_inst(vcpu
);
211 /* Already enabled? */
212 if (vcpu
->arch
.skey_enabled
)
215 rc
= s390_enable_skey();
216 VCPU_EVENT(vcpu
, 3, "enabling storage keys for guest: %d", rc
);
220 if (kvm_s390_test_cpuflags(vcpu
, CPUSTAT_KSS
))
221 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_KSS
);
222 if (!vcpu
->kvm
->arch
.use_skf
)
223 vcpu
->arch
.sie_block
->ictl
|= ICTL_ISKE
| ICTL_SSKE
| ICTL_RRBE
;
225 vcpu
->arch
.sie_block
->ictl
&= ~(ICTL_ISKE
| ICTL_SSKE
| ICTL_RRBE
);
226 vcpu
->arch
.skey_enabled
= true;
230 static int try_handle_skey(struct kvm_vcpu
*vcpu
)
234 rc
= kvm_s390_skey_check_enable(vcpu
);
237 if (vcpu
->kvm
->arch
.use_skf
) {
238 /* with storage-key facility, SIE interprets it for us */
239 kvm_s390_retry_instr(vcpu
);
240 VCPU_EVENT(vcpu
, 4, "%s", "retrying storage key operation");
246 static int handle_iske(struct kvm_vcpu
*vcpu
)
248 unsigned long gaddr
, vmaddr
;
254 vcpu
->stat
.instruction_iske
++;
256 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
257 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
259 rc
= try_handle_skey(vcpu
);
261 return rc
!= -EAGAIN
? rc
: 0;
263 kvm_s390_get_regs_rre(vcpu
, ®1
, ®2
);
265 gaddr
= vcpu
->run
->s
.regs
.gprs
[reg2
] & PAGE_MASK
;
266 gaddr
= kvm_s390_logical_to_effective(vcpu
, gaddr
);
267 gaddr
= kvm_s390_real_to_abs(vcpu
, gaddr
);
268 vmaddr
= gfn_to_hva(vcpu
->kvm
, gpa_to_gfn(gaddr
));
269 if (kvm_is_error_hva(vmaddr
))
270 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
273 down_read(¤t
->mm
->mmap_sem
);
274 rc
= get_guest_storage_key(current
->mm
, vmaddr
, &key
);
277 rc
= fixup_user_fault(current
, current
->mm
, vmaddr
,
278 FAULT_FLAG_WRITE
, &unlocked
);
280 up_read(¤t
->mm
->mmap_sem
);
284 up_read(¤t
->mm
->mmap_sem
);
286 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
289 vcpu
->run
->s
.regs
.gprs
[reg1
] &= ~0xff;
290 vcpu
->run
->s
.regs
.gprs
[reg1
] |= key
;
294 static int handle_rrbe(struct kvm_vcpu
*vcpu
)
296 unsigned long vmaddr
, gaddr
;
301 vcpu
->stat
.instruction_rrbe
++;
303 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
304 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
306 rc
= try_handle_skey(vcpu
);
308 return rc
!= -EAGAIN
? rc
: 0;
310 kvm_s390_get_regs_rre(vcpu
, ®1
, ®2
);
312 gaddr
= vcpu
->run
->s
.regs
.gprs
[reg2
] & PAGE_MASK
;
313 gaddr
= kvm_s390_logical_to_effective(vcpu
, gaddr
);
314 gaddr
= kvm_s390_real_to_abs(vcpu
, gaddr
);
315 vmaddr
= gfn_to_hva(vcpu
->kvm
, gpa_to_gfn(gaddr
));
316 if (kvm_is_error_hva(vmaddr
))
317 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
320 down_read(¤t
->mm
->mmap_sem
);
321 rc
= reset_guest_reference_bit(current
->mm
, vmaddr
);
323 rc
= fixup_user_fault(current
, current
->mm
, vmaddr
,
324 FAULT_FLAG_WRITE
, &unlocked
);
326 up_read(¤t
->mm
->mmap_sem
);
330 up_read(¤t
->mm
->mmap_sem
);
332 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
335 kvm_s390_set_psw_cc(vcpu
, rc
);
343 static int handle_sske(struct kvm_vcpu
*vcpu
)
345 unsigned char m3
= vcpu
->arch
.sie_block
->ipb
>> 28;
346 unsigned long start
, end
;
347 unsigned char key
, oldkey
;
352 vcpu
->stat
.instruction_sske
++;
354 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
355 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
357 rc
= try_handle_skey(vcpu
);
359 return rc
!= -EAGAIN
? rc
: 0;
361 if (!test_kvm_facility(vcpu
->kvm
, 8))
363 if (!test_kvm_facility(vcpu
->kvm
, 10))
364 m3
&= ~(SSKE_MC
| SSKE_MR
);
365 if (!test_kvm_facility(vcpu
->kvm
, 14))
368 kvm_s390_get_regs_rre(vcpu
, ®1
, ®2
);
370 key
= vcpu
->run
->s
.regs
.gprs
[reg1
] & 0xfe;
371 start
= vcpu
->run
->s
.regs
.gprs
[reg2
] & PAGE_MASK
;
372 start
= kvm_s390_logical_to_effective(vcpu
, start
);
374 /* start already designates an absolute address */
375 end
= (start
+ _SEGMENT_SIZE
) & ~(_SEGMENT_SIZE
- 1);
377 start
= kvm_s390_real_to_abs(vcpu
, start
);
378 end
= start
+ PAGE_SIZE
;
381 while (start
!= end
) {
382 unsigned long vmaddr
= gfn_to_hva(vcpu
->kvm
, gpa_to_gfn(start
));
385 if (kvm_is_error_hva(vmaddr
))
386 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
388 down_read(¤t
->mm
->mmap_sem
);
389 rc
= cond_set_guest_storage_key(current
->mm
, vmaddr
, key
, &oldkey
,
390 m3
& SSKE_NQ
, m3
& SSKE_MR
,
394 rc
= fixup_user_fault(current
, current
->mm
, vmaddr
,
395 FAULT_FLAG_WRITE
, &unlocked
);
396 rc
= !rc
? -EAGAIN
: rc
;
398 up_read(¤t
->mm
->mmap_sem
);
400 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
406 if (m3
& (SSKE_MC
| SSKE_MR
)) {
408 /* skey in reg1 is unpredictable */
409 kvm_s390_set_psw_cc(vcpu
, 3);
411 kvm_s390_set_psw_cc(vcpu
, rc
);
412 vcpu
->run
->s
.regs
.gprs
[reg1
] &= ~0xff00UL
;
413 vcpu
->run
->s
.regs
.gprs
[reg1
] |= (u64
) oldkey
<< 8;
417 if (psw_bits(vcpu
->arch
.sie_block
->gpsw
).eaba
== PSW_BITS_AMODE_64BIT
)
418 vcpu
->run
->s
.regs
.gprs
[reg2
] &= ~PAGE_MASK
;
420 vcpu
->run
->s
.regs
.gprs
[reg2
] &= ~0xfffff000UL
;
421 end
= kvm_s390_logical_to_effective(vcpu
, end
);
422 vcpu
->run
->s
.regs
.gprs
[reg2
] |= end
;
427 static int handle_ipte_interlock(struct kvm_vcpu
*vcpu
)
429 vcpu
->stat
.instruction_ipte_interlock
++;
430 if (psw_bits(vcpu
->arch
.sie_block
->gpsw
).pstate
)
431 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
432 wait_event(vcpu
->kvm
->arch
.ipte_wq
, !ipte_lock_held(vcpu
));
433 kvm_s390_retry_instr(vcpu
);
434 VCPU_EVENT(vcpu
, 4, "%s", "retrying ipte interlock operation");
438 static int handle_test_block(struct kvm_vcpu
*vcpu
)
443 vcpu
->stat
.instruction_tb
++;
445 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
446 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
448 kvm_s390_get_regs_rre(vcpu
, NULL
, ®2
);
449 addr
= vcpu
->run
->s
.regs
.gprs
[reg2
] & PAGE_MASK
;
450 addr
= kvm_s390_logical_to_effective(vcpu
, addr
);
451 if (kvm_s390_check_low_addr_prot_real(vcpu
, addr
))
452 return kvm_s390_inject_prog_irq(vcpu
, &vcpu
->arch
.pgm
);
453 addr
= kvm_s390_real_to_abs(vcpu
, addr
);
455 if (kvm_is_error_gpa(vcpu
->kvm
, addr
))
456 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
458 * We don't expect errors on modern systems, and do not care
459 * about storage keys (yet), so let's just clear the page.
461 if (kvm_clear_guest(vcpu
->kvm
, addr
, PAGE_SIZE
))
463 kvm_s390_set_psw_cc(vcpu
, 0);
464 vcpu
->run
->s
.regs
.gprs
[0] = 0;
468 static int handle_tpi(struct kvm_vcpu
*vcpu
)
470 struct kvm_s390_interrupt_info
*inti
;
477 vcpu
->stat
.instruction_tpi
++;
479 addr
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
481 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
483 inti
= kvm_s390_get_io_int(vcpu
->kvm
, vcpu
->arch
.sie_block
->gcr
[6], 0);
485 kvm_s390_set_psw_cc(vcpu
, 0);
489 tpi_data
[0] = inti
->io
.subchannel_id
<< 16 | inti
->io
.subchannel_nr
;
490 tpi_data
[1] = inti
->io
.io_int_parm
;
491 tpi_data
[2] = inti
->io
.io_int_word
;
494 * Store the two-word I/O interruption code into the
497 len
= sizeof(tpi_data
) - 4;
498 rc
= write_guest(vcpu
, addr
, ar
, &tpi_data
, len
);
500 rc
= kvm_s390_inject_prog_cond(vcpu
, rc
);
501 goto reinject_interrupt
;
505 * Store the three-word I/O interruption code into
506 * the appropriate lowcore area.
508 len
= sizeof(tpi_data
);
509 if (write_guest_lc(vcpu
, __LC_SUBCHANNEL_ID
, &tpi_data
, len
)) {
510 /* failed writes to the low core are not recoverable */
512 goto reinject_interrupt
;
516 /* irq was successfully handed to the guest */
518 kvm_s390_set_psw_cc(vcpu
, 1);
522 * If we encounter a problem storing the interruption code, the
523 * instruction is suppressed from the guest's view: reinject the
526 if (kvm_s390_reinject_io_int(vcpu
->kvm
, inti
)) {
530 /* don't set the cc, a pgm irq was injected or we drop to user space */
531 return rc
? -EFAULT
: 0;
534 static int handle_tsch(struct kvm_vcpu
*vcpu
)
536 struct kvm_s390_interrupt_info
*inti
= NULL
;
537 const u64 isc_mask
= 0xffUL
<< 24; /* all iscs set */
539 vcpu
->stat
.instruction_tsch
++;
541 /* a valid schid has at least one bit set */
542 if (vcpu
->run
->s
.regs
.gprs
[1])
543 inti
= kvm_s390_get_io_int(vcpu
->kvm
, isc_mask
,
544 vcpu
->run
->s
.regs
.gprs
[1]);
547 * Prepare exit to userspace.
548 * We indicate whether we dequeued a pending I/O interrupt
549 * so that userspace can re-inject it if the instruction gets
550 * a program check. While this may re-order the pending I/O
551 * interrupts, this is no problem since the priority is kept
554 vcpu
->run
->exit_reason
= KVM_EXIT_S390_TSCH
;
555 vcpu
->run
->s390_tsch
.dequeued
= !!inti
;
557 vcpu
->run
->s390_tsch
.subchannel_id
= inti
->io
.subchannel_id
;
558 vcpu
->run
->s390_tsch
.subchannel_nr
= inti
->io
.subchannel_nr
;
559 vcpu
->run
->s390_tsch
.io_int_parm
= inti
->io
.io_int_parm
;
560 vcpu
->run
->s390_tsch
.io_int_word
= inti
->io
.io_int_word
;
562 vcpu
->run
->s390_tsch
.ipb
= vcpu
->arch
.sie_block
->ipb
;
567 static int handle_io_inst(struct kvm_vcpu
*vcpu
)
569 VCPU_EVENT(vcpu
, 4, "%s", "I/O instruction");
571 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
572 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
574 if (vcpu
->kvm
->arch
.css_support
) {
576 * Most I/O instructions will be handled by userspace.
577 * Exceptions are tpi and the interrupt portion of tsch.
579 if (vcpu
->arch
.sie_block
->ipa
== 0xb236)
580 return handle_tpi(vcpu
);
581 if (vcpu
->arch
.sie_block
->ipa
== 0xb235)
582 return handle_tsch(vcpu
);
583 /* Handle in userspace. */
584 vcpu
->stat
.instruction_io_other
++;
588 * Set condition code 3 to stop the guest from issuing channel
591 kvm_s390_set_psw_cc(vcpu
, 3);
597 * handle_pqap: Handling pqap interception
598 * @vcpu: the vcpu having issue the pqap instruction
600 * We now support PQAP/AQIC instructions and we need to correctly
601 * answer the guest even if no dedicated driver's hook is available.
603 * The intercepting code calls a dedicated callback for this instruction
604 * if a driver did register one in the CRYPTO satellite of the
607 * If no callback is available, the queues are not available, return this
608 * response code to the caller and set CC to 3.
609 * Else return the response code returned by the callback.
611 static int handle_pqap(struct kvm_vcpu
*vcpu
)
613 struct ap_queue_status status
= {};
618 /* Verify that the AP instruction are available */
619 if (!ap_instructions_available())
621 /* Verify that the guest is allowed to use AP instructions */
622 if (!(vcpu
->arch
.sie_block
->eca
& ECA_APIE
))
625 * The only possibly intercepted functions when AP instructions are
626 * available for the guest are AQIC and TAPQ with the t bit set
627 * since we do not set IC.3 (FIII) we currently will only intercept
628 * the AQIC function code.
630 reg0
= vcpu
->run
->s
.regs
.gprs
[0];
631 fc
= (reg0
>> 24) & 0xff;
632 if (WARN_ON_ONCE(fc
!= 0x03))
635 /* PQAP instruction is allowed for guest kernel only */
636 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
637 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
639 /* Common PQAP instruction specification exceptions */
640 /* bits 41-47 must all be zeros */
641 if (reg0
& 0x007f0000UL
)
642 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
643 /* APFT not install and T bit set */
644 if (!test_kvm_facility(vcpu
->kvm
, 15) && (reg0
& 0x00800000UL
))
645 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
646 /* APXA not installed and APID greater 64 or APQI greater 16 */
647 if (!(vcpu
->kvm
->arch
.crypto
.crycbd
& 0x02) && (reg0
& 0x0000c0f0UL
))
648 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
650 /* AQIC function code specific exception */
651 /* facility 65 not present for AQIC function code */
652 if (!test_kvm_facility(vcpu
->kvm
, 65))
653 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
656 * Verify that the hook callback is registered, lock the owner
659 if (vcpu
->kvm
->arch
.crypto
.pqap_hook
) {
660 if (!try_module_get(vcpu
->kvm
->arch
.crypto
.pqap_hook
->owner
))
662 ret
= vcpu
->kvm
->arch
.crypto
.pqap_hook
->hook(vcpu
);
663 module_put(vcpu
->kvm
->arch
.crypto
.pqap_hook
->owner
);
664 if (!ret
&& vcpu
->run
->s
.regs
.gprs
[1] & 0x00ff0000)
665 kvm_s390_set_psw_cc(vcpu
, 3);
669 * A vfio_driver must register a hook.
670 * No hook means no driver to enable the SIE CRYCB and no queues.
671 * We send this response to the guest.
673 status
.response_code
= 0x01;
674 memcpy(&vcpu
->run
->s
.regs
.gprs
[1], &status
, sizeof(status
));
675 kvm_s390_set_psw_cc(vcpu
, 3);
679 static int handle_stfl(struct kvm_vcpu
*vcpu
)
684 vcpu
->stat
.instruction_stfl
++;
686 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
687 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
690 * We need to shift the lower 32 facility bits (bit 0-31) from a u64
691 * into a u32 memory representation. They will remain bits 0-31.
693 fac
= *vcpu
->kvm
->arch
.model
.fac_list
>> 32;
694 rc
= write_guest_lc(vcpu
, offsetof(struct lowcore
, stfl_fac_list
),
698 VCPU_EVENT(vcpu
, 3, "STFL: store facility list 0x%x", fac
);
699 trace_kvm_s390_handle_stfl(vcpu
, fac
);
703 #define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
704 #define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
705 #define PSW_ADDR_24 0x0000000000ffffffUL
706 #define PSW_ADDR_31 0x000000007fffffffUL
708 int is_valid_psw(psw_t
*psw
)
710 if (psw
->mask
& PSW_MASK_UNASSIGNED
)
712 if ((psw
->mask
& PSW_MASK_ADDR_MODE
) == PSW_MASK_BA
) {
713 if (psw
->addr
& ~PSW_ADDR_31
)
716 if (!(psw
->mask
& PSW_MASK_ADDR_MODE
) && (psw
->addr
& ~PSW_ADDR_24
))
718 if ((psw
->mask
& PSW_MASK_ADDR_MODE
) == PSW_MASK_EA
)
725 int kvm_s390_handle_lpsw(struct kvm_vcpu
*vcpu
)
727 psw_t
*gpsw
= &vcpu
->arch
.sie_block
->gpsw
;
728 psw_compat_t new_psw
;
733 vcpu
->stat
.instruction_lpsw
++;
735 if (gpsw
->mask
& PSW_MASK_PSTATE
)
736 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
738 addr
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
740 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
742 rc
= read_guest(vcpu
, addr
, ar
, &new_psw
, sizeof(new_psw
));
744 return kvm_s390_inject_prog_cond(vcpu
, rc
);
745 if (!(new_psw
.mask
& PSW32_MASK_BASE
))
746 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
747 gpsw
->mask
= (new_psw
.mask
& ~PSW32_MASK_BASE
) << 32;
748 gpsw
->mask
|= new_psw
.addr
& PSW32_ADDR_AMODE
;
749 gpsw
->addr
= new_psw
.addr
& ~PSW32_ADDR_AMODE
;
750 if (!is_valid_psw(gpsw
))
751 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
755 static int handle_lpswe(struct kvm_vcpu
*vcpu
)
762 vcpu
->stat
.instruction_lpswe
++;
764 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
765 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
767 addr
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
769 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
770 rc
= read_guest(vcpu
, addr
, ar
, &new_psw
, sizeof(new_psw
));
772 return kvm_s390_inject_prog_cond(vcpu
, rc
);
773 vcpu
->arch
.sie_block
->gpsw
= new_psw
;
774 if (!is_valid_psw(&vcpu
->arch
.sie_block
->gpsw
))
775 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
779 static int handle_stidp(struct kvm_vcpu
*vcpu
)
781 u64 stidp_data
= vcpu
->kvm
->arch
.model
.cpuid
;
786 vcpu
->stat
.instruction_stidp
++;
788 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
789 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
791 operand2
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
794 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
796 rc
= write_guest(vcpu
, operand2
, ar
, &stidp_data
, sizeof(stidp_data
));
798 return kvm_s390_inject_prog_cond(vcpu
, rc
);
800 VCPU_EVENT(vcpu
, 3, "STIDP: store cpu id 0x%llx", stidp_data
);
804 static void handle_stsi_3_2_2(struct kvm_vcpu
*vcpu
, struct sysinfo_3_2_2
*mem
)
809 cpus
= atomic_read(&vcpu
->kvm
->online_vcpus
);
811 /* deal with other level 3 hypervisors */
812 if (stsi(mem
, 3, 2, 2))
816 for (n
= mem
->count
- 1; n
> 0 ; n
--)
817 memcpy(&mem
->vm
[n
], &mem
->vm
[n
- 1], sizeof(mem
->vm
[0]));
819 memset(&mem
->vm
[0], 0, sizeof(mem
->vm
[0]));
820 mem
->vm
[0].cpus_total
= cpus
;
821 mem
->vm
[0].cpus_configured
= cpus
;
822 mem
->vm
[0].cpus_standby
= 0;
823 mem
->vm
[0].cpus_reserved
= 0;
824 mem
->vm
[0].caf
= 1000;
825 memcpy(mem
->vm
[0].name
, "KVMguest", 8);
826 ASCEBC(mem
->vm
[0].name
, 8);
827 memcpy(mem
->vm
[0].cpi
, "KVM/Linux ", 16);
828 ASCEBC(mem
->vm
[0].cpi
, 16);
831 static void insert_stsi_usr_data(struct kvm_vcpu
*vcpu
, u64 addr
, u8 ar
,
832 u8 fc
, u8 sel1
, u16 sel2
)
834 vcpu
->run
->exit_reason
= KVM_EXIT_S390_STSI
;
835 vcpu
->run
->s390_stsi
.addr
= addr
;
836 vcpu
->run
->s390_stsi
.ar
= ar
;
837 vcpu
->run
->s390_stsi
.fc
= fc
;
838 vcpu
->run
->s390_stsi
.sel1
= sel1
;
839 vcpu
->run
->s390_stsi
.sel2
= sel2
;
842 static int handle_stsi(struct kvm_vcpu
*vcpu
)
844 int fc
= (vcpu
->run
->s
.regs
.gprs
[0] & 0xf0000000) >> 28;
845 int sel1
= vcpu
->run
->s
.regs
.gprs
[0] & 0xff;
846 int sel2
= vcpu
->run
->s
.regs
.gprs
[1] & 0xffff;
847 unsigned long mem
= 0;
852 vcpu
->stat
.instruction_stsi
++;
853 VCPU_EVENT(vcpu
, 3, "STSI: fc: %u sel1: %u sel2: %u", fc
, sel1
, sel2
);
855 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
856 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
859 kvm_s390_set_psw_cc(vcpu
, 3);
863 if (vcpu
->run
->s
.regs
.gprs
[0] & 0x0fffff00
864 || vcpu
->run
->s
.regs
.gprs
[1] & 0xffff0000)
865 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
868 vcpu
->run
->s
.regs
.gprs
[0] = 3 << 28;
869 kvm_s390_set_psw_cc(vcpu
, 0);
873 operand2
= kvm_s390_get_base_disp_s(vcpu
, &ar
);
875 if (!kvm_s390_pv_cpu_is_protected(vcpu
) && (operand2
& 0xfff))
876 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
879 case 1: /* same handling for 1 and 2 */
881 mem
= get_zeroed_page(GFP_KERNEL
);
884 if (stsi((void *) mem
, fc
, sel1
, sel2
))
888 if (sel1
!= 2 || sel2
!= 2)
890 mem
= get_zeroed_page(GFP_KERNEL
);
893 handle_stsi_3_2_2(vcpu
, (void *) mem
);
896 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
897 memcpy((void *)sida_origin(vcpu
->arch
.sie_block
), (void *)mem
,
901 rc
= write_guest(vcpu
, operand2
, ar
, (void *)mem
, PAGE_SIZE
);
904 rc
= kvm_s390_inject_prog_cond(vcpu
, rc
);
907 if (vcpu
->kvm
->arch
.user_stsi
) {
908 insert_stsi_usr_data(vcpu
, operand2
, ar
, fc
, sel1
, sel2
);
911 trace_kvm_s390_handle_stsi(vcpu
, fc
, sel1
, sel2
, operand2
);
913 kvm_s390_set_psw_cc(vcpu
, 0);
914 vcpu
->run
->s
.regs
.gprs
[0] = 0;
917 kvm_s390_set_psw_cc(vcpu
, 3);
923 int kvm_s390_handle_b2(struct kvm_vcpu
*vcpu
)
925 switch (vcpu
->arch
.sie_block
->ipa
& 0x00ff) {
927 return handle_stidp(vcpu
);
929 return handle_set_clock(vcpu
);
931 return handle_set_prefix(vcpu
);
933 return handle_store_prefix(vcpu
);
935 return handle_store_cpu_address(vcpu
);
937 return kvm_s390_handle_vsie(vcpu
);
940 return handle_ipte_interlock(vcpu
);
942 return handle_iske(vcpu
);
944 return handle_rrbe(vcpu
);
946 return handle_sske(vcpu
);
948 return handle_test_block(vcpu
);
965 return handle_io_inst(vcpu
);
967 return handle_sthyi(vcpu
);
969 return handle_stsi(vcpu
);
971 return handle_pqap(vcpu
);
973 return handle_stfl(vcpu
);
975 return handle_lpswe(vcpu
);
981 static int handle_epsw(struct kvm_vcpu
*vcpu
)
985 vcpu
->stat
.instruction_epsw
++;
987 kvm_s390_get_regs_rre(vcpu
, ®1
, ®2
);
989 /* This basically extracts the mask half of the psw. */
990 vcpu
->run
->s
.regs
.gprs
[reg1
] &= 0xffffffff00000000UL
;
991 vcpu
->run
->s
.regs
.gprs
[reg1
] |= vcpu
->arch
.sie_block
->gpsw
.mask
>> 32;
993 vcpu
->run
->s
.regs
.gprs
[reg2
] &= 0xffffffff00000000UL
;
994 vcpu
->run
->s
.regs
.gprs
[reg2
] |=
995 vcpu
->arch
.sie_block
->gpsw
.mask
& 0x00000000ffffffffUL
;
1000 #define PFMF_RESERVED 0xfffc0101UL
1001 #define PFMF_SK 0x00020000UL
1002 #define PFMF_CF 0x00010000UL
1003 #define PFMF_UI 0x00008000UL
1004 #define PFMF_FSC 0x00007000UL
1005 #define PFMF_NQ 0x00000800UL
1006 #define PFMF_MR 0x00000400UL
1007 #define PFMF_MC 0x00000200UL
1008 #define PFMF_KEY 0x000000feUL
1010 static int handle_pfmf(struct kvm_vcpu
*vcpu
)
1012 bool mr
= false, mc
= false, nq
;
1014 unsigned long start
, end
;
1017 vcpu
->stat
.instruction_pfmf
++;
1019 kvm_s390_get_regs_rre(vcpu
, ®1
, ®2
);
1021 if (!test_kvm_facility(vcpu
->kvm
, 8))
1022 return kvm_s390_inject_program_int(vcpu
, PGM_OPERATION
);
1024 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1025 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1027 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_RESERVED
)
1028 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1030 /* Only provide non-quiescing support if enabled for the guest */
1031 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_NQ
&&
1032 !test_kvm_facility(vcpu
->kvm
, 14))
1033 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1035 /* Only provide conditional-SSKE support if enabled for the guest */
1036 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_SK
&&
1037 test_kvm_facility(vcpu
->kvm
, 10)) {
1038 mr
= vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_MR
;
1039 mc
= vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_MC
;
1042 nq
= vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_NQ
;
1043 key
= vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_KEY
;
1044 start
= vcpu
->run
->s
.regs
.gprs
[reg2
] & PAGE_MASK
;
1045 start
= kvm_s390_logical_to_effective(vcpu
, start
);
1047 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_CF
) {
1048 if (kvm_s390_check_low_addr_prot_real(vcpu
, start
))
1049 return kvm_s390_inject_prog_irq(vcpu
, &vcpu
->arch
.pgm
);
1052 switch (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_FSC
) {
1054 /* only 4k frames specify a real address */
1055 start
= kvm_s390_real_to_abs(vcpu
, start
);
1056 end
= (start
+ PAGE_SIZE
) & ~(PAGE_SIZE
- 1);
1059 end
= (start
+ _SEGMENT_SIZE
) & ~(_SEGMENT_SIZE
- 1);
1062 /* only support 2G frame size if EDAT2 is available and we are
1063 not in 24-bit addressing mode */
1064 if (!test_kvm_facility(vcpu
->kvm
, 78) ||
1065 psw_bits(vcpu
->arch
.sie_block
->gpsw
).eaba
== PSW_BITS_AMODE_24BIT
)
1066 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1067 end
= (start
+ _REGION3_SIZE
) & ~(_REGION3_SIZE
- 1);
1070 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1073 while (start
!= end
) {
1074 unsigned long vmaddr
;
1075 bool unlocked
= false;
1077 /* Translate guest address to host address */
1078 vmaddr
= gfn_to_hva(vcpu
->kvm
, gpa_to_gfn(start
));
1079 if (kvm_is_error_hva(vmaddr
))
1080 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
1082 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_CF
) {
1083 if (kvm_clear_guest(vcpu
->kvm
, start
, PAGE_SIZE
))
1084 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
1087 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_SK
) {
1088 int rc
= kvm_s390_skey_check_enable(vcpu
);
1092 down_read(¤t
->mm
->mmap_sem
);
1093 rc
= cond_set_guest_storage_key(current
->mm
, vmaddr
,
1094 key
, NULL
, nq
, mr
, mc
);
1096 rc
= fixup_user_fault(current
, current
->mm
, vmaddr
,
1097 FAULT_FLAG_WRITE
, &unlocked
);
1098 rc
= !rc
? -EAGAIN
: rc
;
1100 up_read(¤t
->mm
->mmap_sem
);
1102 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
1110 if (vcpu
->run
->s
.regs
.gprs
[reg1
] & PFMF_FSC
) {
1111 if (psw_bits(vcpu
->arch
.sie_block
->gpsw
).eaba
== PSW_BITS_AMODE_64BIT
) {
1112 vcpu
->run
->s
.regs
.gprs
[reg2
] = end
;
1114 vcpu
->run
->s
.regs
.gprs
[reg2
] &= ~0xffffffffUL
;
1115 end
= kvm_s390_logical_to_effective(vcpu
, end
);
1116 vcpu
->run
->s
.regs
.gprs
[reg2
] |= end
;
1123 * Must be called with relevant read locks held (kvm->mm->mmap_sem, kvm->srcu)
1125 static inline int __do_essa(struct kvm_vcpu
*vcpu
, const int orc
)
1127 int r1
, r2
, nappended
, entries
;
1128 unsigned long gfn
, hva
, res
, pgstev
, ptev
;
1129 unsigned long *cbrlo
;
1132 * We don't need to set SD.FPF.SK to 1 here, because if we have a
1133 * machine check here we either handle it or crash
1136 kvm_s390_get_regs_rre(vcpu
, &r1
, &r2
);
1137 gfn
= vcpu
->run
->s
.regs
.gprs
[r2
] >> PAGE_SHIFT
;
1138 hva
= gfn_to_hva(vcpu
->kvm
, gfn
);
1139 entries
= (vcpu
->arch
.sie_block
->cbrlo
& ~PAGE_MASK
) >> 3;
1141 if (kvm_is_error_hva(hva
))
1142 return kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
1144 nappended
= pgste_perform_essa(vcpu
->kvm
->mm
, hva
, orc
, &ptev
, &pgstev
);
1145 if (nappended
< 0) {
1146 res
= orc
? 0x10 : 0;
1147 vcpu
->run
->s
.regs
.gprs
[r1
] = res
; /* Exception Indication */
1150 res
= (pgstev
& _PGSTE_GPS_USAGE_MASK
) >> 22;
1152 * Set the block-content state part of the result. 0 means resident, so
1153 * nothing to do if the page is valid. 2 is for preserved pages
1154 * (non-present and non-zero), and 3 for zero pages (non-present and
1157 if (ptev
& _PAGE_INVALID
) {
1159 if (pgstev
& _PGSTE_GPS_ZERO
)
1162 if (pgstev
& _PGSTE_GPS_NODAT
)
1164 vcpu
->run
->s
.regs
.gprs
[r1
] = res
;
1166 * It is possible that all the normal 511 slots were full, in which case
1167 * we will now write in the 512th slot, which is reserved for host use.
1168 * In both cases we let the normal essa handling code process all the
1169 * slots, including the reserved one, if needed.
1171 if (nappended
> 0) {
1172 cbrlo
= phys_to_virt(vcpu
->arch
.sie_block
->cbrlo
& PAGE_MASK
);
1173 cbrlo
[entries
] = gfn
<< PAGE_SHIFT
;
1177 struct kvm_memory_slot
*ms
= gfn_to_memslot(vcpu
->kvm
, gfn
);
1179 /* Increment only if we are really flipping the bit */
1180 if (ms
&& !test_and_set_bit(gfn
- ms
->base_gfn
, kvm_second_dirty_bitmap(ms
)))
1181 atomic64_inc(&vcpu
->kvm
->arch
.cmma_dirty_pages
);
1187 static int handle_essa(struct kvm_vcpu
*vcpu
)
1189 /* entries expected to be 1FF */
1190 int entries
= (vcpu
->arch
.sie_block
->cbrlo
& ~PAGE_MASK
) >> 3;
1191 unsigned long *cbrlo
;
1195 VCPU_EVENT(vcpu
, 4, "ESSA: release %d pages", entries
);
1196 gmap
= vcpu
->arch
.gmap
;
1197 vcpu
->stat
.instruction_essa
++;
1198 if (!vcpu
->kvm
->arch
.use_cmma
)
1199 return kvm_s390_inject_program_int(vcpu
, PGM_OPERATION
);
1201 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1202 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1203 /* Check for invalid operation request code */
1204 orc
= (vcpu
->arch
.sie_block
->ipb
& 0xf0000000) >> 28;
1205 /* ORCs 0-6 are always valid */
1206 if (orc
> (test_kvm_facility(vcpu
->kvm
, 147) ? ESSA_SET_STABLE_NODAT
1207 : ESSA_SET_STABLE_IF_RESIDENT
))
1208 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1210 if (!vcpu
->kvm
->arch
.migration_mode
) {
1212 * CMMA is enabled in the KVM settings, but is disabled in
1213 * the SIE block and in the mm_context, and we are not doing
1214 * a migration. Enable CMMA in the mm_context.
1215 * Since we need to take a write lock to write to the context
1216 * to avoid races with storage keys handling, we check if the
1217 * value really needs to be written to; if the value is
1218 * already correct, we do nothing and avoid the lock.
1220 if (vcpu
->kvm
->mm
->context
.uses_cmm
== 0) {
1221 down_write(&vcpu
->kvm
->mm
->mmap_sem
);
1222 vcpu
->kvm
->mm
->context
.uses_cmm
= 1;
1223 up_write(&vcpu
->kvm
->mm
->mmap_sem
);
1226 * If we are here, we are supposed to have CMMA enabled in
1227 * the SIE block. Enabling CMMA works on a per-CPU basis,
1228 * while the context use_cmma flag is per process.
1229 * It's possible that the context flag is enabled and the
1230 * SIE flag is not, so we set the flag always; if it was
1231 * already set, nothing changes, otherwise we enable it
1234 vcpu
->arch
.sie_block
->ecb2
|= ECB2_CMMA
;
1235 /* Retry the ESSA instruction */
1236 kvm_s390_retry_instr(vcpu
);
1240 down_read(&vcpu
->kvm
->mm
->mmap_sem
);
1241 srcu_idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
1242 i
= __do_essa(vcpu
, orc
);
1243 srcu_read_unlock(&vcpu
->kvm
->srcu
, srcu_idx
);
1244 up_read(&vcpu
->kvm
->mm
->mmap_sem
);
1247 /* Account for the possible extra cbrl entry */
1250 vcpu
->arch
.sie_block
->cbrlo
&= PAGE_MASK
; /* reset nceo */
1251 cbrlo
= phys_to_virt(vcpu
->arch
.sie_block
->cbrlo
);
1252 down_read(&gmap
->mm
->mmap_sem
);
1253 for (i
= 0; i
< entries
; ++i
)
1254 __gmap_zap(gmap
, cbrlo
[i
]);
1255 up_read(&gmap
->mm
->mmap_sem
);
1259 int kvm_s390_handle_b9(struct kvm_vcpu
*vcpu
)
1261 switch (vcpu
->arch
.sie_block
->ipa
& 0x00ff) {
1265 return handle_ipte_interlock(vcpu
);
1267 return handle_epsw(vcpu
);
1269 return handle_essa(vcpu
);
1271 return handle_pfmf(vcpu
);
1277 int kvm_s390_handle_lctl(struct kvm_vcpu
*vcpu
)
1279 int reg1
= (vcpu
->arch
.sie_block
->ipa
& 0x00f0) >> 4;
1280 int reg3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
1281 int reg
, rc
, nr_regs
;
1286 vcpu
->stat
.instruction_lctl
++;
1288 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1289 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1291 ga
= kvm_s390_get_base_disp_rs(vcpu
, &ar
);
1294 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1296 VCPU_EVENT(vcpu
, 4, "LCTL: r1:%d, r3:%d, addr: 0x%llx", reg1
, reg3
, ga
);
1297 trace_kvm_s390_handle_lctl(vcpu
, 0, reg1
, reg3
, ga
);
1299 nr_regs
= ((reg3
- reg1
) & 0xf) + 1;
1300 rc
= read_guest(vcpu
, ga
, ar
, ctl_array
, nr_regs
* sizeof(u32
));
1302 return kvm_s390_inject_prog_cond(vcpu
, rc
);
1306 vcpu
->arch
.sie_block
->gcr
[reg
] &= 0xffffffff00000000ul
;
1307 vcpu
->arch
.sie_block
->gcr
[reg
] |= ctl_array
[nr_regs
++];
1310 reg
= (reg
+ 1) % 16;
1312 kvm_make_request(KVM_REQ_TLB_FLUSH
, vcpu
);
1316 int kvm_s390_handle_stctl(struct kvm_vcpu
*vcpu
)
1318 int reg1
= (vcpu
->arch
.sie_block
->ipa
& 0x00f0) >> 4;
1319 int reg3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
1320 int reg
, rc
, nr_regs
;
1325 vcpu
->stat
.instruction_stctl
++;
1327 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1328 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1330 ga
= kvm_s390_get_base_disp_rs(vcpu
, &ar
);
1333 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1335 VCPU_EVENT(vcpu
, 4, "STCTL r1:%d, r3:%d, addr: 0x%llx", reg1
, reg3
, ga
);
1336 trace_kvm_s390_handle_stctl(vcpu
, 0, reg1
, reg3
, ga
);
1341 ctl_array
[nr_regs
++] = vcpu
->arch
.sie_block
->gcr
[reg
];
1344 reg
= (reg
+ 1) % 16;
1346 rc
= write_guest(vcpu
, ga
, ar
, ctl_array
, nr_regs
* sizeof(u32
));
1347 return rc
? kvm_s390_inject_prog_cond(vcpu
, rc
) : 0;
1350 static int handle_lctlg(struct kvm_vcpu
*vcpu
)
1352 int reg1
= (vcpu
->arch
.sie_block
->ipa
& 0x00f0) >> 4;
1353 int reg3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
1354 int reg
, rc
, nr_regs
;
1359 vcpu
->stat
.instruction_lctlg
++;
1361 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1362 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1364 ga
= kvm_s390_get_base_disp_rsy(vcpu
, &ar
);
1367 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1369 VCPU_EVENT(vcpu
, 4, "LCTLG: r1:%d, r3:%d, addr: 0x%llx", reg1
, reg3
, ga
);
1370 trace_kvm_s390_handle_lctl(vcpu
, 1, reg1
, reg3
, ga
);
1372 nr_regs
= ((reg3
- reg1
) & 0xf) + 1;
1373 rc
= read_guest(vcpu
, ga
, ar
, ctl_array
, nr_regs
* sizeof(u64
));
1375 return kvm_s390_inject_prog_cond(vcpu
, rc
);
1379 vcpu
->arch
.sie_block
->gcr
[reg
] = ctl_array
[nr_regs
++];
1382 reg
= (reg
+ 1) % 16;
1384 kvm_make_request(KVM_REQ_TLB_FLUSH
, vcpu
);
1388 static int handle_stctg(struct kvm_vcpu
*vcpu
)
1390 int reg1
= (vcpu
->arch
.sie_block
->ipa
& 0x00f0) >> 4;
1391 int reg3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
1392 int reg
, rc
, nr_regs
;
1397 vcpu
->stat
.instruction_stctg
++;
1399 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1400 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1402 ga
= kvm_s390_get_base_disp_rsy(vcpu
, &ar
);
1405 return kvm_s390_inject_program_int(vcpu
, PGM_SPECIFICATION
);
1407 VCPU_EVENT(vcpu
, 4, "STCTG r1:%d, r3:%d, addr: 0x%llx", reg1
, reg3
, ga
);
1408 trace_kvm_s390_handle_stctl(vcpu
, 1, reg1
, reg3
, ga
);
1413 ctl_array
[nr_regs
++] = vcpu
->arch
.sie_block
->gcr
[reg
];
1416 reg
= (reg
+ 1) % 16;
1418 rc
= write_guest(vcpu
, ga
, ar
, ctl_array
, nr_regs
* sizeof(u64
));
1419 return rc
? kvm_s390_inject_prog_cond(vcpu
, rc
) : 0;
1422 int kvm_s390_handle_eb(struct kvm_vcpu
*vcpu
)
1424 switch (vcpu
->arch
.sie_block
->ipb
& 0x000000ff) {
1426 return handle_stctg(vcpu
);
1428 return handle_lctlg(vcpu
);
1432 return handle_ri(vcpu
);
1438 static int handle_tprot(struct kvm_vcpu
*vcpu
)
1440 u64 address1
, address2
;
1441 unsigned long hva
, gpa
;
1442 int ret
= 0, cc
= 0;
1446 vcpu
->stat
.instruction_tprot
++;
1448 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1449 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1451 kvm_s390_get_base_disp_sse(vcpu
, &address1
, &address2
, &ar
, NULL
);
1453 /* we only handle the Linux memory detection case:
1455 * everything else goes to userspace. */
1456 if (address2
& 0xf0)
1458 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_DAT
)
1460 ret
= guest_translate_address(vcpu
, address1
, ar
, &gpa
, GACC_STORE
);
1461 if (ret
== PGM_PROTECTION
) {
1462 /* Write protected? Try again with read-only... */
1464 ret
= guest_translate_address(vcpu
, address1
, ar
, &gpa
,
1468 if (ret
== PGM_ADDRESSING
|| ret
== PGM_TRANSLATION_SPEC
) {
1469 ret
= kvm_s390_inject_program_int(vcpu
, ret
);
1470 } else if (ret
> 0) {
1471 /* Translation not available */
1472 kvm_s390_set_psw_cc(vcpu
, 3);
1478 hva
= gfn_to_hva_prot(vcpu
->kvm
, gpa_to_gfn(gpa
), &writable
);
1479 if (kvm_is_error_hva(hva
)) {
1480 ret
= kvm_s390_inject_program_int(vcpu
, PGM_ADDRESSING
);
1483 cc
= 1; /* Write not permitted ==> read-only */
1484 kvm_s390_set_psw_cc(vcpu
, cc
);
1485 /* Note: CC2 only occurs for storage keys (not supported yet) */
1488 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_DAT
)
1493 int kvm_s390_handle_e5(struct kvm_vcpu
*vcpu
)
1495 switch (vcpu
->arch
.sie_block
->ipa
& 0x00ff) {
1497 return handle_tprot(vcpu
);
1503 static int handle_sckpf(struct kvm_vcpu
*vcpu
)
1507 vcpu
->stat
.instruction_sckpf
++;
1509 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
1510 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
1512 if (vcpu
->run
->s
.regs
.gprs
[0] & 0x00000000ffff0000)
1513 return kvm_s390_inject_program_int(vcpu
,
1516 value
= vcpu
->run
->s
.regs
.gprs
[0] & 0x000000000000ffff;
1517 vcpu
->arch
.sie_block
->todpr
= value
;
1522 static int handle_ptff(struct kvm_vcpu
*vcpu
)
1524 vcpu
->stat
.instruction_ptff
++;
1526 /* we don't emulate any control instructions yet */
1527 kvm_s390_set_psw_cc(vcpu
, 3);
1531 int kvm_s390_handle_01(struct kvm_vcpu
*vcpu
)
1533 switch (vcpu
->arch
.sie_block
->ipa
& 0x00ff) {
1535 return handle_ptff(vcpu
);
1537 return handle_sckpf(vcpu
);