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_s390_local_interrupt *li, int action)
130 struct kvm_s390_interrupt_info *inti;
131 int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
133 inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
136 inti->type = KVM_S390_SIGP_STOP;
138 spin_lock_bh(&li->lock);
139 if (li->action_bits & ACTION_STOP_ON_STOP) {
140 /* another SIGP STOP is pending */
144 if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
146 if ((action & ACTION_STORE_ON_STOP) != 0)
150 list_add_tail(&inti->list, &li->list);
151 atomic_set(&li->active, 1);
152 li->action_bits |= action;
153 atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
154 if (waitqueue_active(li->wq))
155 wake_up_interruptible(li->wq);
157 spin_unlock_bh(&li->lock);
162 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
164 struct kvm_s390_local_interrupt *li;
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;
174 li = &dst_vcpu->arch.local_int;
176 rc = __inject_sigp_stop(li, action);
178 VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
180 if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
181 /* If the CPU has already been stopped, we still have
182 * to save the status when doing stop-and-store. This
183 * has to be done after unlocking all spinlocks. */
184 rc = kvm_s390_store_status_unloaded(dst_vcpu,
185 KVM_S390_STORE_STATUS_NOADDR);
191 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
197 switch (parameter & 0xff) {
199 rc = SIGP_CC_NOT_OPERATIONAL;
203 kvm_for_each_vcpu(i, v, vcpu->kvm) {
204 v->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
205 kvm_clear_async_pf_completion_queue(v);
208 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
216 static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
219 struct kvm_s390_local_interrupt *li;
220 struct kvm_vcpu *dst_vcpu = NULL;
221 struct kvm_s390_interrupt_info *inti;
224 if (cpu_addr < KVM_MAX_VCPUS)
225 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
227 return SIGP_CC_NOT_OPERATIONAL;
228 li = &dst_vcpu->arch.local_int;
231 * Make sure the new value is valid memory. We only need to check the
232 * first page, since address is 8k aligned and memory pieces are always
233 * at least 1MB aligned and have at least a size of 1MB.
235 address &= 0x7fffe000u;
236 if (kvm_is_error_gpa(vcpu->kvm, address)) {
237 *reg &= 0xffffffff00000000UL;
238 *reg |= SIGP_STATUS_INVALID_PARAMETER;
239 return SIGP_CC_STATUS_STORED;
242 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
246 spin_lock_bh(&li->lock);
247 /* cpu must be in stopped state */
248 if (!(atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
249 *reg &= 0xffffffff00000000UL;
250 *reg |= SIGP_STATUS_INCORRECT_STATE;
251 rc = SIGP_CC_STATUS_STORED;
256 inti->type = KVM_S390_SIGP_SET_PREFIX;
257 inti->prefix.address = address;
259 list_add_tail(&inti->list, &li->list);
260 atomic_set(&li->active, 1);
261 if (waitqueue_active(li->wq))
262 wake_up_interruptible(li->wq);
263 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
265 VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x", cpu_addr, address);
267 spin_unlock_bh(&li->lock);
271 static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
274 struct kvm_vcpu *dst_vcpu = NULL;
278 if (cpu_id < KVM_MAX_VCPUS)
279 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
281 return SIGP_CC_NOT_OPERATIONAL;
283 spin_lock_bh(&dst_vcpu->arch.local_int.lock);
284 flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
285 spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
286 if (!(flags & CPUSTAT_STOPPED)) {
287 *reg &= 0xffffffff00000000UL;
288 *reg |= SIGP_STATUS_INCORRECT_STATE;
289 return SIGP_CC_STATUS_STORED;
293 rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
295 *reg &= 0xffffffff00000000UL;
296 *reg |= SIGP_STATUS_INVALID_PARAMETER;
297 rc = SIGP_CC_STATUS_STORED;
302 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
305 struct kvm_s390_local_interrupt *li;
306 struct kvm_vcpu *dst_vcpu = NULL;
309 if (cpu_addr >= KVM_MAX_VCPUS)
310 return SIGP_CC_NOT_OPERATIONAL;
312 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
314 return SIGP_CC_NOT_OPERATIONAL;
315 li = &dst_vcpu->arch.local_int;
316 if (atomic_read(li->cpuflags) & CPUSTAT_RUNNING) {
318 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
321 *reg &= 0xffffffff00000000UL;
322 *reg |= SIGP_STATUS_NOT_RUNNING;
323 rc = SIGP_CC_STATUS_STORED;
326 VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", cpu_addr,
332 /* Test whether the destination CPU is available and not busy */
333 static int sigp_check_callable(struct kvm_vcpu *vcpu, u16 cpu_addr)
335 struct kvm_s390_local_interrupt *li;
336 int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
337 struct kvm_vcpu *dst_vcpu = NULL;
339 if (cpu_addr >= KVM_MAX_VCPUS)
340 return SIGP_CC_NOT_OPERATIONAL;
342 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
344 return SIGP_CC_NOT_OPERATIONAL;
345 li = &dst_vcpu->arch.local_int;
346 spin_lock_bh(&li->lock);
347 if (li->action_bits & ACTION_STOP_ON_STOP)
349 spin_unlock_bh(&li->lock);
354 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
356 int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
357 int r3 = vcpu->arch.sie_block->ipa & 0x000f;
359 u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
363 /* sigp in userspace can exit */
364 if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
365 return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
367 order_code = kvm_s390_get_base_disp_rs(vcpu);
370 parameter = vcpu->run->s.regs.gprs[r1];
372 parameter = vcpu->run->s.regs.gprs[r1 + 1];
374 trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
375 switch (order_code) {
377 vcpu->stat.instruction_sigp_sense++;
378 rc = __sigp_sense(vcpu, cpu_addr,
379 &vcpu->run->s.regs.gprs[r1]);
381 case SIGP_EXTERNAL_CALL:
382 vcpu->stat.instruction_sigp_external_call++;
383 rc = __sigp_external_call(vcpu, cpu_addr);
385 case SIGP_EMERGENCY_SIGNAL:
386 vcpu->stat.instruction_sigp_emergency++;
387 rc = __sigp_emergency(vcpu, cpu_addr);
390 vcpu->stat.instruction_sigp_stop++;
391 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
393 case SIGP_STOP_AND_STORE_STATUS:
394 vcpu->stat.instruction_sigp_stop++;
395 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
396 ACTION_STOP_ON_STOP);
398 case SIGP_STORE_STATUS_AT_ADDRESS:
399 rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
400 &vcpu->run->s.regs.gprs[r1]);
402 case SIGP_SET_ARCHITECTURE:
403 vcpu->stat.instruction_sigp_arch++;
404 rc = __sigp_set_arch(vcpu, parameter);
406 case SIGP_SET_PREFIX:
407 vcpu->stat.instruction_sigp_prefix++;
408 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
409 &vcpu->run->s.regs.gprs[r1]);
411 case SIGP_COND_EMERGENCY_SIGNAL:
412 rc = __sigp_conditional_emergency(vcpu, cpu_addr, parameter,
413 &vcpu->run->s.regs.gprs[r1]);
415 case SIGP_SENSE_RUNNING:
416 vcpu->stat.instruction_sigp_sense_running++;
417 rc = __sigp_sense_running(vcpu, cpu_addr,
418 &vcpu->run->s.regs.gprs[r1]);
421 rc = sigp_check_callable(vcpu, cpu_addr);
422 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED)
423 rc = -EOPNOTSUPP; /* Handle START in user space */
426 vcpu->stat.instruction_sigp_restart++;
427 rc = sigp_check_callable(vcpu, cpu_addr);
428 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED) {
430 "sigp restart %x to handle userspace",
432 /* user space must know about restart */
443 kvm_s390_set_psw_cc(vcpu, rc);
448 * Handle SIGP partial execution interception.
450 * This interception will occur at the source cpu when a source cpu sends an
451 * external call to a target cpu and the target cpu has the WAIT bit set in
452 * its cpuflags. Interception will occurr after the interrupt indicator bits at
453 * the target cpu have been set. All error cases will lead to instruction
454 * interception, therefore nothing is to be checked or prepared.
456 int kvm_s390_handle_sigp_pei(struct kvm_vcpu *vcpu)
458 int r3 = vcpu->arch.sie_block->ipa & 0x000f;
459 u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
460 struct kvm_vcpu *dest_vcpu;
461 u8 order_code = kvm_s390_get_base_disp_rs(vcpu);
463 trace_kvm_s390_handle_sigp_pei(vcpu, order_code, cpu_addr);
465 if (order_code == SIGP_EXTERNAL_CALL) {
466 dest_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
467 BUG_ON(dest_vcpu == NULL);
469 spin_lock_bh(&dest_vcpu->arch.local_int.lock);
470 if (waitqueue_active(&dest_vcpu->wq))
471 wake_up_interruptible(&dest_vcpu->wq);
472 dest_vcpu->preempted = true;
473 spin_unlock_bh(&dest_vcpu->arch.local_int.lock);
475 kvm_s390_set_psw_cc(vcpu, SIGP_CC_ORDER_CODE_ACCEPTED);