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);