2 * handling interprocessor communication
4 * Copyright IBM Corp. 2008, 2013
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.
10 * Author(s): Carsten Otte <cotte@de.ibm.com>
11 * Christian Borntraeger <borntraeger@de.ibm.com>
12 * Christian Ehrhardt <ehrhardt@de.ibm.com>
15 #include <linux/kvm.h>
16 #include <linux/kvm_host.h>
17 #include <linux/slab.h>
23 static int __sigp_sense(struct kvm_vcpu
*vcpu
, u16 cpu_addr
,
26 struct kvm_s390_local_interrupt
*li
;
27 struct kvm_vcpu
*dst_vcpu
= NULL
;
31 if (cpu_addr
>= KVM_MAX_VCPUS
)
32 return SIGP_CC_NOT_OPERATIONAL
;
34 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
36 return SIGP_CC_NOT_OPERATIONAL
;
37 li
= &dst_vcpu
->arch
.local_int
;
39 cpuflags
= atomic_read(li
->cpuflags
);
40 if (!(cpuflags
& (CPUSTAT_ECALL_PEND
| CPUSTAT_STOPPED
)))
41 rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
43 *reg
&= 0xffffffff00000000UL
;
44 if (cpuflags
& CPUSTAT_ECALL_PEND
)
45 *reg
|= SIGP_STATUS_EXT_CALL_PENDING
;
46 if (cpuflags
& CPUSTAT_STOPPED
)
47 *reg
|= SIGP_STATUS_STOPPED
;
48 rc
= SIGP_CC_STATUS_STORED
;
51 VCPU_EVENT(vcpu
, 4, "sensed status of cpu %x rc %x", cpu_addr
, rc
);
55 static int __sigp_emergency(struct kvm_vcpu
*vcpu
, u16 cpu_addr
)
57 struct kvm_s390_interrupt s390int
= {
58 .type
= KVM_S390_INT_EMERGENCY
,
59 .parm
= vcpu
->vcpu_id
,
61 struct kvm_vcpu
*dst_vcpu
= NULL
;
64 if (cpu_addr
< KVM_MAX_VCPUS
)
65 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
67 return SIGP_CC_NOT_OPERATIONAL
;
69 rc
= kvm_s390_inject_vcpu(dst_vcpu
, &s390int
);
71 VCPU_EVENT(vcpu
, 4, "sent sigp emerg to cpu %x", cpu_addr
);
73 return rc
? rc
: SIGP_CC_ORDER_CODE_ACCEPTED
;
76 static int __sigp_conditional_emergency(struct kvm_vcpu
*vcpu
, u16 cpu_addr
,
79 struct kvm_vcpu
*dst_vcpu
= NULL
;
80 const u64 psw_int_mask
= PSW_MASK_IO
| PSW_MASK_EXT
;
85 if (cpu_addr
< KVM_MAX_VCPUS
)
86 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
88 return SIGP_CC_NOT_OPERATIONAL
;
89 flags
= atomic_read(&dst_vcpu
->arch
.sie_block
->cpuflags
);
90 psw
= &dst_vcpu
->arch
.sie_block
->gpsw
;
91 p_asn
= dst_vcpu
->arch
.sie_block
->gcr
[4] & 0xffff; /* Primary ASN */
92 s_asn
= dst_vcpu
->arch
.sie_block
->gcr
[3] & 0xffff; /* Secondary ASN */
94 /* Deliver the emergency signal? */
95 if (!(flags
& CPUSTAT_STOPPED
)
96 || (psw
->mask
& psw_int_mask
) != psw_int_mask
97 || ((flags
& CPUSTAT_WAIT
) && psw
->addr
!= 0)
98 || (!(flags
& CPUSTAT_WAIT
) && (asn
== p_asn
|| asn
== s_asn
))) {
99 return __sigp_emergency(vcpu
, cpu_addr
);
101 *reg
&= 0xffffffff00000000UL
;
102 *reg
|= SIGP_STATUS_INCORRECT_STATE
;
103 return SIGP_CC_STATUS_STORED
;
107 static int __sigp_external_call(struct kvm_vcpu
*vcpu
, u16 cpu_addr
)
109 struct kvm_s390_interrupt s390int
= {
110 .type
= KVM_S390_INT_EXTERNAL_CALL
,
111 .parm
= vcpu
->vcpu_id
,
113 struct kvm_vcpu
*dst_vcpu
= NULL
;
116 if (cpu_addr
< KVM_MAX_VCPUS
)
117 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
119 return SIGP_CC_NOT_OPERATIONAL
;
121 rc
= kvm_s390_inject_vcpu(dst_vcpu
, &s390int
);
123 VCPU_EVENT(vcpu
, 4, "sent sigp ext call to cpu %x", cpu_addr
);
125 return rc
? rc
: SIGP_CC_ORDER_CODE_ACCEPTED
;
128 static int __inject_sigp_stop(struct kvm_vcpu
*dst_vcpu
, int action
)
130 struct kvm_s390_local_interrupt
*li
= &dst_vcpu
->arch
.local_int
;
131 struct kvm_s390_interrupt_info
*inti
;
132 int rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
134 inti
= kzalloc(sizeof(*inti
), GFP_ATOMIC
);
137 inti
->type
= KVM_S390_SIGP_STOP
;
139 spin_lock(&li
->lock
);
140 if (li
->action_bits
& ACTION_STOP_ON_STOP
) {
141 /* another SIGP STOP is pending */
146 if ((atomic_read(li
->cpuflags
) & CPUSTAT_STOPPED
)) {
148 if ((action
& ACTION_STORE_ON_STOP
) != 0)
152 list_add_tail(&inti
->list
, &li
->list
);
153 atomic_set(&li
->active
, 1);
154 li
->action_bits
|= action
;
155 atomic_set_mask(CPUSTAT_STOP_INT
, li
->cpuflags
);
156 kvm_s390_vcpu_wakeup(dst_vcpu
);
158 spin_unlock(&li
->lock
);
163 static int __sigp_stop(struct kvm_vcpu
*vcpu
, u16 cpu_addr
, int action
)
165 struct kvm_vcpu
*dst_vcpu
= NULL
;
168 if (cpu_addr
>= KVM_MAX_VCPUS
)
169 return SIGP_CC_NOT_OPERATIONAL
;
171 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
173 return SIGP_CC_NOT_OPERATIONAL
;
175 rc
= __inject_sigp_stop(dst_vcpu
, action
);
177 VCPU_EVENT(vcpu
, 4, "sent sigp stop to cpu %x", cpu_addr
);
179 if ((action
& ACTION_STORE_ON_STOP
) != 0 && rc
== -ESHUTDOWN
) {
180 /* If the CPU has already been stopped, we still have
181 * to save the status when doing stop-and-store. This
182 * has to be done after unlocking all spinlocks. */
183 rc
= kvm_s390_store_status_unloaded(dst_vcpu
,
184 KVM_S390_STORE_STATUS_NOADDR
);
190 static int __sigp_set_arch(struct kvm_vcpu
*vcpu
, u32 parameter
)
196 switch (parameter
& 0xff) {
198 rc
= SIGP_CC_NOT_OPERATIONAL
;
202 kvm_for_each_vcpu(i
, v
, vcpu
->kvm
) {
203 v
->arch
.pfault_token
= KVM_S390_PFAULT_TOKEN_INVALID
;
204 kvm_clear_async_pf_completion_queue(v
);
207 rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
215 static int __sigp_set_prefix(struct kvm_vcpu
*vcpu
, u16 cpu_addr
, u32 address
,
218 struct kvm_s390_local_interrupt
*li
;
219 struct kvm_vcpu
*dst_vcpu
= NULL
;
220 struct kvm_s390_interrupt_info
*inti
;
223 if (cpu_addr
< KVM_MAX_VCPUS
)
224 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
226 return SIGP_CC_NOT_OPERATIONAL
;
227 li
= &dst_vcpu
->arch
.local_int
;
230 * Make sure the new value is valid memory. We only need to check the
231 * first page, since address is 8k aligned and memory pieces are always
232 * at least 1MB aligned and have at least a size of 1MB.
234 address
&= 0x7fffe000u
;
235 if (kvm_is_error_gpa(vcpu
->kvm
, address
)) {
236 *reg
&= 0xffffffff00000000UL
;
237 *reg
|= SIGP_STATUS_INVALID_PARAMETER
;
238 return SIGP_CC_STATUS_STORED
;
241 inti
= kzalloc(sizeof(*inti
), GFP_KERNEL
);
245 spin_lock(&li
->lock
);
246 /* cpu must be in stopped state */
247 if (!(atomic_read(li
->cpuflags
) & CPUSTAT_STOPPED
)) {
248 *reg
&= 0xffffffff00000000UL
;
249 *reg
|= SIGP_STATUS_INCORRECT_STATE
;
250 rc
= SIGP_CC_STATUS_STORED
;
255 inti
->type
= KVM_S390_SIGP_SET_PREFIX
;
256 inti
->prefix
.address
= address
;
258 list_add_tail(&inti
->list
, &li
->list
);
259 atomic_set(&li
->active
, 1);
260 kvm_s390_vcpu_wakeup(dst_vcpu
);
261 rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
263 VCPU_EVENT(vcpu
, 4, "set prefix of cpu %02x to %x", cpu_addr
, address
);
265 spin_unlock(&li
->lock
);
269 static int __sigp_store_status_at_addr(struct kvm_vcpu
*vcpu
, u16 cpu_id
,
272 struct kvm_vcpu
*dst_vcpu
= NULL
;
276 if (cpu_id
< KVM_MAX_VCPUS
)
277 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_id
);
279 return SIGP_CC_NOT_OPERATIONAL
;
281 spin_lock(&dst_vcpu
->arch
.local_int
.lock
);
282 flags
= atomic_read(dst_vcpu
->arch
.local_int
.cpuflags
);
283 spin_unlock(&dst_vcpu
->arch
.local_int
.lock
);
284 if (!(flags
& CPUSTAT_STOPPED
)) {
285 *reg
&= 0xffffffff00000000UL
;
286 *reg
|= SIGP_STATUS_INCORRECT_STATE
;
287 return SIGP_CC_STATUS_STORED
;
291 rc
= kvm_s390_store_status_unloaded(dst_vcpu
, addr
);
293 *reg
&= 0xffffffff00000000UL
;
294 *reg
|= SIGP_STATUS_INVALID_PARAMETER
;
295 rc
= SIGP_CC_STATUS_STORED
;
300 static int __sigp_sense_running(struct kvm_vcpu
*vcpu
, u16 cpu_addr
,
303 struct kvm_s390_local_interrupt
*li
;
304 struct kvm_vcpu
*dst_vcpu
= NULL
;
307 if (cpu_addr
>= KVM_MAX_VCPUS
)
308 return SIGP_CC_NOT_OPERATIONAL
;
310 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
312 return SIGP_CC_NOT_OPERATIONAL
;
313 li
= &dst_vcpu
->arch
.local_int
;
314 if (atomic_read(li
->cpuflags
) & CPUSTAT_RUNNING
) {
316 rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
319 *reg
&= 0xffffffff00000000UL
;
320 *reg
|= SIGP_STATUS_NOT_RUNNING
;
321 rc
= SIGP_CC_STATUS_STORED
;
324 VCPU_EVENT(vcpu
, 4, "sensed running status of cpu %x rc %x", cpu_addr
,
330 /* Test whether the destination CPU is available and not busy */
331 static int sigp_check_callable(struct kvm_vcpu
*vcpu
, u16 cpu_addr
)
333 struct kvm_s390_local_interrupt
*li
;
334 int rc
= SIGP_CC_ORDER_CODE_ACCEPTED
;
335 struct kvm_vcpu
*dst_vcpu
= NULL
;
337 if (cpu_addr
>= KVM_MAX_VCPUS
)
338 return SIGP_CC_NOT_OPERATIONAL
;
340 dst_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
342 return SIGP_CC_NOT_OPERATIONAL
;
343 li
= &dst_vcpu
->arch
.local_int
;
344 spin_lock(&li
->lock
);
345 if (li
->action_bits
& ACTION_STOP_ON_STOP
)
347 spin_unlock(&li
->lock
);
352 int kvm_s390_handle_sigp(struct kvm_vcpu
*vcpu
)
354 int r1
= (vcpu
->arch
.sie_block
->ipa
& 0x00f0) >> 4;
355 int r3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
357 u16 cpu_addr
= vcpu
->run
->s
.regs
.gprs
[r3
];
361 /* sigp in userspace can exit */
362 if (vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
)
363 return kvm_s390_inject_program_int(vcpu
, PGM_PRIVILEGED_OP
);
365 order_code
= kvm_s390_get_base_disp_rs(vcpu
);
368 parameter
= vcpu
->run
->s
.regs
.gprs
[r1
];
370 parameter
= vcpu
->run
->s
.regs
.gprs
[r1
+ 1];
372 trace_kvm_s390_handle_sigp(vcpu
, order_code
, cpu_addr
, parameter
);
373 switch (order_code
) {
375 vcpu
->stat
.instruction_sigp_sense
++;
376 rc
= __sigp_sense(vcpu
, cpu_addr
,
377 &vcpu
->run
->s
.regs
.gprs
[r1
]);
379 case SIGP_EXTERNAL_CALL
:
380 vcpu
->stat
.instruction_sigp_external_call
++;
381 rc
= __sigp_external_call(vcpu
, cpu_addr
);
383 case SIGP_EMERGENCY_SIGNAL
:
384 vcpu
->stat
.instruction_sigp_emergency
++;
385 rc
= __sigp_emergency(vcpu
, cpu_addr
);
388 vcpu
->stat
.instruction_sigp_stop
++;
389 rc
= __sigp_stop(vcpu
, cpu_addr
, ACTION_STOP_ON_STOP
);
391 case SIGP_STOP_AND_STORE_STATUS
:
392 vcpu
->stat
.instruction_sigp_stop
++;
393 rc
= __sigp_stop(vcpu
, cpu_addr
, ACTION_STORE_ON_STOP
|
394 ACTION_STOP_ON_STOP
);
396 case SIGP_STORE_STATUS_AT_ADDRESS
:
397 rc
= __sigp_store_status_at_addr(vcpu
, cpu_addr
, parameter
,
398 &vcpu
->run
->s
.regs
.gprs
[r1
]);
400 case SIGP_SET_ARCHITECTURE
:
401 vcpu
->stat
.instruction_sigp_arch
++;
402 rc
= __sigp_set_arch(vcpu
, parameter
);
404 case SIGP_SET_PREFIX
:
405 vcpu
->stat
.instruction_sigp_prefix
++;
406 rc
= __sigp_set_prefix(vcpu
, cpu_addr
, parameter
,
407 &vcpu
->run
->s
.regs
.gprs
[r1
]);
409 case SIGP_COND_EMERGENCY_SIGNAL
:
410 rc
= __sigp_conditional_emergency(vcpu
, cpu_addr
, parameter
,
411 &vcpu
->run
->s
.regs
.gprs
[r1
]);
413 case SIGP_SENSE_RUNNING
:
414 vcpu
->stat
.instruction_sigp_sense_running
++;
415 rc
= __sigp_sense_running(vcpu
, cpu_addr
,
416 &vcpu
->run
->s
.regs
.gprs
[r1
]);
419 rc
= sigp_check_callable(vcpu
, cpu_addr
);
420 if (rc
== SIGP_CC_ORDER_CODE_ACCEPTED
)
421 rc
= -EOPNOTSUPP
; /* Handle START in user space */
424 vcpu
->stat
.instruction_sigp_restart
++;
425 rc
= sigp_check_callable(vcpu
, cpu_addr
);
426 if (rc
== SIGP_CC_ORDER_CODE_ACCEPTED
) {
428 "sigp restart %x to handle userspace",
430 /* user space must know about restart */
441 kvm_s390_set_psw_cc(vcpu
, rc
);
446 * Handle SIGP partial execution interception.
448 * This interception will occur at the source cpu when a source cpu sends an
449 * external call to a target cpu and the target cpu has the WAIT bit set in
450 * its cpuflags. Interception will occurr after the interrupt indicator bits at
451 * the target cpu have been set. All error cases will lead to instruction
452 * interception, therefore nothing is to be checked or prepared.
454 int kvm_s390_handle_sigp_pei(struct kvm_vcpu
*vcpu
)
456 int r3
= vcpu
->arch
.sie_block
->ipa
& 0x000f;
457 u16 cpu_addr
= vcpu
->run
->s
.regs
.gprs
[r3
];
458 struct kvm_vcpu
*dest_vcpu
;
459 u8 order_code
= kvm_s390_get_base_disp_rs(vcpu
);
461 trace_kvm_s390_handle_sigp_pei(vcpu
, order_code
, cpu_addr
);
463 if (order_code
== SIGP_EXTERNAL_CALL
) {
464 dest_vcpu
= kvm_get_vcpu(vcpu
->kvm
, cpu_addr
);
465 BUG_ON(dest_vcpu
== NULL
);
467 kvm_s390_vcpu_wakeup(dest_vcpu
);
468 kvm_s390_set_psw_cc(vcpu
, SIGP_CC_ORDER_CODE_ACCEPTED
);