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_float_interrupt *fi = &vcpu->kvm->arch.float_int;
29 if (cpu_addr >= KVM_MAX_VCPUS)
30 return SIGP_CC_NOT_OPERATIONAL;
33 if (fi->local_int[cpu_addr] == NULL)
34 rc = SIGP_CC_NOT_OPERATIONAL;
35 else if (!(atomic_read(fi->local_int[cpu_addr]->cpuflags)
36 & (CPUSTAT_ECALL_PEND | CPUSTAT_STOPPED)))
37 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
39 *reg &= 0xffffffff00000000UL;
40 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
42 *reg |= SIGP_STATUS_EXT_CALL_PENDING;
43 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
45 *reg |= SIGP_STATUS_STOPPED;
46 rc = SIGP_CC_STATUS_STORED;
48 spin_unlock(&fi->lock);
50 VCPU_EVENT(vcpu, 4, "sensed status of cpu %x rc %x", cpu_addr, rc);
54 static int __sigp_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr)
56 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
57 struct kvm_s390_local_interrupt *li;
58 struct kvm_s390_interrupt_info *inti;
61 if (cpu_addr >= KVM_MAX_VCPUS)
62 return SIGP_CC_NOT_OPERATIONAL;
64 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
68 inti->type = KVM_S390_INT_EMERGENCY;
69 inti->emerg.code = vcpu->vcpu_id;
72 li = fi->local_int[cpu_addr];
74 rc = SIGP_CC_NOT_OPERATIONAL;
78 spin_lock_bh(&li->lock);
79 list_add_tail(&inti->list, &li->list);
80 atomic_set(&li->active, 1);
81 atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
82 if (waitqueue_active(li->wq))
83 wake_up_interruptible(li->wq);
84 spin_unlock_bh(&li->lock);
85 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
86 VCPU_EVENT(vcpu, 4, "sent sigp emerg to cpu %x", cpu_addr);
88 spin_unlock(&fi->lock);
92 static int __sigp_conditional_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr,
95 struct kvm_vcpu *dst_vcpu = NULL;
96 const u64 psw_int_mask = PSW_MASK_IO | PSW_MASK_EXT;
101 if (cpu_addr < KVM_MAX_VCPUS)
102 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
104 return SIGP_CC_NOT_OPERATIONAL;
105 flags = atomic_read(&dst_vcpu->arch.sie_block->cpuflags);
106 psw = &dst_vcpu->arch.sie_block->gpsw;
107 p_asn = dst_vcpu->arch.sie_block->gcr[4] & 0xffff; /* Primary ASN */
108 s_asn = dst_vcpu->arch.sie_block->gcr[3] & 0xffff; /* Secondary ASN */
110 /* Deliver the emergency signal? */
111 if (!(flags & CPUSTAT_STOPPED)
112 || (psw->mask & psw_int_mask) != psw_int_mask
113 || ((flags & CPUSTAT_WAIT) && psw->addr != 0)
114 || (!(flags & CPUSTAT_WAIT) && (asn == p_asn || asn == s_asn))) {
115 return __sigp_emergency(vcpu, cpu_addr);
117 *reg &= 0xffffffff00000000UL;
118 *reg |= SIGP_STATUS_INCORRECT_STATE;
119 return SIGP_CC_STATUS_STORED;
123 static int __sigp_external_call(struct kvm_vcpu *vcpu, u16 cpu_addr)
125 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
126 struct kvm_s390_local_interrupt *li;
127 struct kvm_s390_interrupt_info *inti;
130 if (cpu_addr >= KVM_MAX_VCPUS)
131 return SIGP_CC_NOT_OPERATIONAL;
133 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
137 inti->type = KVM_S390_INT_EXTERNAL_CALL;
138 inti->extcall.code = vcpu->vcpu_id;
140 spin_lock(&fi->lock);
141 li = fi->local_int[cpu_addr];
143 rc = SIGP_CC_NOT_OPERATIONAL;
147 spin_lock_bh(&li->lock);
148 list_add_tail(&inti->list, &li->list);
149 atomic_set(&li->active, 1);
150 atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
151 if (waitqueue_active(li->wq))
152 wake_up_interruptible(li->wq);
153 spin_unlock_bh(&li->lock);
154 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
155 VCPU_EVENT(vcpu, 4, "sent sigp ext call to cpu %x", cpu_addr);
157 spin_unlock(&fi->lock);
161 static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
163 struct kvm_s390_interrupt_info *inti;
164 int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
166 inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
169 inti->type = KVM_S390_SIGP_STOP;
171 spin_lock_bh(&li->lock);
172 if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
174 if ((action & ACTION_STORE_ON_STOP) != 0)
178 list_add_tail(&inti->list, &li->list);
179 atomic_set(&li->active, 1);
180 atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
181 li->action_bits |= action;
182 if (waitqueue_active(li->wq))
183 wake_up_interruptible(li->wq);
185 spin_unlock_bh(&li->lock);
190 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
192 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
193 struct kvm_s390_local_interrupt *li;
196 if (cpu_addr >= KVM_MAX_VCPUS)
197 return SIGP_CC_NOT_OPERATIONAL;
199 spin_lock(&fi->lock);
200 li = fi->local_int[cpu_addr];
202 rc = SIGP_CC_NOT_OPERATIONAL;
206 rc = __inject_sigp_stop(li, action);
209 spin_unlock(&fi->lock);
210 VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
212 if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
213 /* If the CPU has already been stopped, we still have
214 * to save the status when doing stop-and-store. This
215 * has to be done after unlocking all spinlocks. */
216 struct kvm_vcpu *dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
217 rc = kvm_s390_store_status_unloaded(dst_vcpu,
218 KVM_S390_STORE_STATUS_NOADDR);
224 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
230 switch (parameter & 0xff) {
232 rc = SIGP_CC_NOT_OPERATIONAL;
236 kvm_for_each_vcpu(i, v, vcpu->kvm) {
237 v->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
238 kvm_clear_async_pf_completion_queue(v);
241 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
249 static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
252 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
253 struct kvm_s390_local_interrupt *li = NULL;
254 struct kvm_s390_interrupt_info *inti;
258 /* make sure that the new value is valid memory */
259 address = address & 0x7fffe000u;
260 if (copy_from_guest_absolute(vcpu, &tmp, address, 1) ||
261 copy_from_guest_absolute(vcpu, &tmp, address + PAGE_SIZE, 1)) {
262 *reg &= 0xffffffff00000000UL;
263 *reg |= SIGP_STATUS_INVALID_PARAMETER;
264 return SIGP_CC_STATUS_STORED;
267 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
271 spin_lock(&fi->lock);
272 if (cpu_addr < KVM_MAX_VCPUS)
273 li = fi->local_int[cpu_addr];
276 *reg &= 0xffffffff00000000UL;
277 *reg |= SIGP_STATUS_INCORRECT_STATE;
278 rc = SIGP_CC_STATUS_STORED;
283 spin_lock_bh(&li->lock);
284 /* cpu must be in stopped state */
285 if (!(atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
286 *reg &= 0xffffffff00000000UL;
287 *reg |= SIGP_STATUS_INCORRECT_STATE;
288 rc = SIGP_CC_STATUS_STORED;
293 inti->type = KVM_S390_SIGP_SET_PREFIX;
294 inti->prefix.address = address;
296 list_add_tail(&inti->list, &li->list);
297 atomic_set(&li->active, 1);
298 if (waitqueue_active(li->wq))
299 wake_up_interruptible(li->wq);
300 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
302 VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x", cpu_addr, address);
304 spin_unlock_bh(&li->lock);
306 spin_unlock(&fi->lock);
310 static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
313 struct kvm_vcpu *dst_vcpu = NULL;
317 if (cpu_id < KVM_MAX_VCPUS)
318 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
320 return SIGP_CC_NOT_OPERATIONAL;
322 spin_lock_bh(&dst_vcpu->arch.local_int.lock);
323 flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
324 spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
325 if (!(flags & CPUSTAT_STOPPED)) {
326 *reg &= 0xffffffff00000000UL;
327 *reg |= SIGP_STATUS_INCORRECT_STATE;
328 return SIGP_CC_STATUS_STORED;
332 rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
334 *reg &= 0xffffffff00000000UL;
335 *reg |= SIGP_STATUS_INVALID_PARAMETER;
336 rc = SIGP_CC_STATUS_STORED;
341 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
345 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
347 if (cpu_addr >= KVM_MAX_VCPUS)
348 return SIGP_CC_NOT_OPERATIONAL;
350 spin_lock(&fi->lock);
351 if (fi->local_int[cpu_addr] == NULL)
352 rc = SIGP_CC_NOT_OPERATIONAL;
354 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
357 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
360 *reg &= 0xffffffff00000000UL;
361 *reg |= SIGP_STATUS_NOT_RUNNING;
362 rc = SIGP_CC_STATUS_STORED;
365 spin_unlock(&fi->lock);
367 VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", cpu_addr,
373 /* Test whether the destination CPU is available and not busy */
374 static int sigp_check_callable(struct kvm_vcpu *vcpu, u16 cpu_addr)
376 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
377 struct kvm_s390_local_interrupt *li;
378 int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
380 if (cpu_addr >= KVM_MAX_VCPUS)
381 return SIGP_CC_NOT_OPERATIONAL;
383 spin_lock(&fi->lock);
384 li = fi->local_int[cpu_addr];
386 rc = SIGP_CC_NOT_OPERATIONAL;
390 spin_lock_bh(&li->lock);
391 if (li->action_bits & ACTION_STOP_ON_STOP)
393 spin_unlock_bh(&li->lock);
395 spin_unlock(&fi->lock);
399 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
401 int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
402 int r3 = vcpu->arch.sie_block->ipa & 0x000f;
404 u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
408 /* sigp in userspace can exit */
409 if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
410 return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
412 order_code = kvm_s390_get_base_disp_rs(vcpu);
415 parameter = vcpu->run->s.regs.gprs[r1];
417 parameter = vcpu->run->s.regs.gprs[r1 + 1];
419 trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
420 switch (order_code) {
422 vcpu->stat.instruction_sigp_sense++;
423 rc = __sigp_sense(vcpu, cpu_addr,
424 &vcpu->run->s.regs.gprs[r1]);
426 case SIGP_EXTERNAL_CALL:
427 vcpu->stat.instruction_sigp_external_call++;
428 rc = __sigp_external_call(vcpu, cpu_addr);
430 case SIGP_EMERGENCY_SIGNAL:
431 vcpu->stat.instruction_sigp_emergency++;
432 rc = __sigp_emergency(vcpu, cpu_addr);
435 vcpu->stat.instruction_sigp_stop++;
436 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
438 case SIGP_STOP_AND_STORE_STATUS:
439 vcpu->stat.instruction_sigp_stop++;
440 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
441 ACTION_STOP_ON_STOP);
443 case SIGP_STORE_STATUS_AT_ADDRESS:
444 rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
445 &vcpu->run->s.regs.gprs[r1]);
447 case SIGP_SET_ARCHITECTURE:
448 vcpu->stat.instruction_sigp_arch++;
449 rc = __sigp_set_arch(vcpu, parameter);
451 case SIGP_SET_PREFIX:
452 vcpu->stat.instruction_sigp_prefix++;
453 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
454 &vcpu->run->s.regs.gprs[r1]);
456 case SIGP_COND_EMERGENCY_SIGNAL:
457 rc = __sigp_conditional_emergency(vcpu, cpu_addr, parameter,
458 &vcpu->run->s.regs.gprs[r1]);
460 case SIGP_SENSE_RUNNING:
461 vcpu->stat.instruction_sigp_sense_running++;
462 rc = __sigp_sense_running(vcpu, cpu_addr,
463 &vcpu->run->s.regs.gprs[r1]);
466 rc = sigp_check_callable(vcpu, cpu_addr);
467 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED)
468 rc = -EOPNOTSUPP; /* Handle START in user space */
471 vcpu->stat.instruction_sigp_restart++;
472 rc = sigp_check_callable(vcpu, cpu_addr);
473 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED) {
475 "sigp restart %x to handle userspace",
477 /* user space must know about restart */
488 kvm_s390_set_psw_cc(vcpu, rc);