1 /*
2 * handling interprocessor communication
3 *
4 * Copyright IBM Corp. 2008, 2009
5 *
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.
9 *
10 * Author(s): Carsten Otte <cotte@de.ibm.com>
11 * Christian Borntraeger <borntraeger@de.ibm.com>
12 * Christian Ehrhardt <ehrhardt@de.ibm.com>
13 */
14
15 #include <linux/kvm.h>
16 #include <linux/kvm_host.h>
17 #include <linux/slab.h>
18 #include <asm/sigp.h>
19 #include "gaccess.h"
20 #include "kvm-s390.h"
21 #include "trace.h"
22
__sigp_sense(struct kvm_vcpu * vcpu,u16 cpu_addr,u64 * reg)23 static int __sigp_sense(struct kvm_vcpu *vcpu, u16 cpu_addr,
24 u64 *reg)
25 {
26 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
27 int rc;
28
29 if (cpu_addr >= KVM_MAX_VCPUS)
30 return SIGP_CC_NOT_OPERATIONAL;
31
32 spin_lock(&fi->lock);
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;
38 else {
39 *reg &= 0xffffffff00000000UL;
40 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
41 & CPUSTAT_ECALL_PEND)
42 *reg |= SIGP_STATUS_EXT_CALL_PENDING;
43 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
44 & CPUSTAT_STOPPED)
45 *reg |= SIGP_STATUS_STOPPED;
46 rc = SIGP_CC_STATUS_STORED;
47 }
48 spin_unlock(&fi->lock);
49
50 VCPU_EVENT(vcpu, 4, "sensed status of cpu %x rc %x", cpu_addr, rc);
51 return rc;
52 }
53
__sigp_emergency(struct kvm_vcpu * vcpu,u16 cpu_addr)54 static int __sigp_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr)
55 {
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;
59 int rc;
60
61 if (cpu_addr >= KVM_MAX_VCPUS)
62 return SIGP_CC_NOT_OPERATIONAL;
63
64 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
65 if (!inti)
66 return -ENOMEM;
67
68 inti->type = KVM_S390_INT_EMERGENCY;
69 inti->emerg.code = vcpu->vcpu_id;
70
71 spin_lock(&fi->lock);
72 li = fi->local_int[cpu_addr];
73 if (li == NULL) {
74 rc = SIGP_CC_NOT_OPERATIONAL;
75 kfree(inti);
76 goto unlock;
77 }
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);
87 unlock:
88 spin_unlock(&fi->lock);
89 return rc;
90 }
91
__sigp_external_call(struct kvm_vcpu * vcpu,u16 cpu_addr)92 static int __sigp_external_call(struct kvm_vcpu *vcpu, u16 cpu_addr)
93 {
94 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
95 struct kvm_s390_local_interrupt *li;
96 struct kvm_s390_interrupt_info *inti;
97 int rc;
98
99 if (cpu_addr >= KVM_MAX_VCPUS)
100 return SIGP_CC_NOT_OPERATIONAL;
101
102 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
103 if (!inti)
104 return -ENOMEM;
105
106 inti->type = KVM_S390_INT_EXTERNAL_CALL;
107 inti->extcall.code = vcpu->vcpu_id;
108
109 spin_lock(&fi->lock);
110 li = fi->local_int[cpu_addr];
111 if (li == NULL) {
112 rc = SIGP_CC_NOT_OPERATIONAL;
113 kfree(inti);
114 goto unlock;
115 }
116 spin_lock_bh(&li->lock);
117 list_add_tail(&inti->list, &li->list);
118 atomic_set(&li->active, 1);
119 atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
120 if (waitqueue_active(&li->wq))
121 wake_up_interruptible(&li->wq);
122 spin_unlock_bh(&li->lock);
123 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
124 VCPU_EVENT(vcpu, 4, "sent sigp ext call to cpu %x", cpu_addr);
125 unlock:
126 spin_unlock(&fi->lock);
127 return rc;
128 }
129
__inject_sigp_stop(struct kvm_s390_local_interrupt * li,int action)130 static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
131 {
132 struct kvm_s390_interrupt_info *inti;
133
134 inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
135 if (!inti)
136 return -ENOMEM;
137 inti->type = KVM_S390_SIGP_STOP;
138
139 spin_lock_bh(&li->lock);
140 if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
141 kfree(inti);
142 goto out;
143 }
144 list_add_tail(&inti->list, &li->list);
145 atomic_set(&li->active, 1);
146 atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
147 li->action_bits |= action;
148 if (waitqueue_active(&li->wq))
149 wake_up_interruptible(&li->wq);
150 out:
151 spin_unlock_bh(&li->lock);
152
153 return SIGP_CC_ORDER_CODE_ACCEPTED;
154 }
155
__sigp_stop(struct kvm_vcpu * vcpu,u16 cpu_addr,int action)156 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
157 {
158 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
159 struct kvm_s390_local_interrupt *li;
160 int rc;
161
162 if (cpu_addr >= KVM_MAX_VCPUS)
163 return SIGP_CC_NOT_OPERATIONAL;
164
165 spin_lock(&fi->lock);
166 li = fi->local_int[cpu_addr];
167 if (li == NULL) {
168 rc = SIGP_CC_NOT_OPERATIONAL;
169 goto unlock;
170 }
171
172 rc = __inject_sigp_stop(li, action);
173
174 unlock:
175 spin_unlock(&fi->lock);
176 VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
177 return rc;
178 }
179
kvm_s390_inject_sigp_stop(struct kvm_vcpu * vcpu,int action)180 int kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action)
181 {
182 struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
183 return __inject_sigp_stop(li, action);
184 }
185
__sigp_set_arch(struct kvm_vcpu * vcpu,u32 parameter)186 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
187 {
188 int rc;
189
190 switch (parameter & 0xff) {
191 case 0:
192 rc = SIGP_CC_NOT_OPERATIONAL;
193 break;
194 case 1:
195 case 2:
196 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
197 break;
198 default:
199 rc = -EOPNOTSUPP;
200 }
201 return rc;
202 }
203
__sigp_set_prefix(struct kvm_vcpu * vcpu,u16 cpu_addr,u32 address,u64 * reg)204 static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
205 u64 *reg)
206 {
207 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
208 struct kvm_s390_local_interrupt *li = NULL;
209 struct kvm_s390_interrupt_info *inti;
210 int rc;
211 u8 tmp;
212
213 /* make sure that the new value is valid memory */
214 address = address & 0x7fffe000u;
215 if (copy_from_guest_absolute(vcpu, &tmp, address, 1) ||
216 copy_from_guest_absolute(vcpu, &tmp, address + PAGE_SIZE, 1)) {
217 *reg &= 0xffffffff00000000UL;
218 *reg |= SIGP_STATUS_INVALID_PARAMETER;
219 return SIGP_CC_STATUS_STORED;
220 }
221
222 inti = kzalloc(sizeof(*inti), GFP_KERNEL);
223 if (!inti)
224 return SIGP_CC_BUSY;
225
226 spin_lock(&fi->lock);
227 if (cpu_addr < KVM_MAX_VCPUS)
228 li = fi->local_int[cpu_addr];
229
230 if (li == NULL) {
231 *reg &= 0xffffffff00000000UL;
232 *reg |= SIGP_STATUS_INCORRECT_STATE;
233 rc = SIGP_CC_STATUS_STORED;
234 kfree(inti);
235 goto out_fi;
236 }
237
238 spin_lock_bh(&li->lock);
239 /* cpu must be in stopped state */
240 if (!(atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
241 *reg &= 0xffffffff00000000UL;
242 *reg |= SIGP_STATUS_INCORRECT_STATE;
243 rc = SIGP_CC_STATUS_STORED;
244 kfree(inti);
245 goto out_li;
246 }
247
248 inti->type = KVM_S390_SIGP_SET_PREFIX;
249 inti->prefix.address = address;
250
251 list_add_tail(&inti->list, &li->list);
252 atomic_set(&li->active, 1);
253 if (waitqueue_active(&li->wq))
254 wake_up_interruptible(&li->wq);
255 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
256
257 VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x", cpu_addr, address);
258 out_li:
259 spin_unlock_bh(&li->lock);
260 out_fi:
261 spin_unlock(&fi->lock);
262 return rc;
263 }
264
__sigp_sense_running(struct kvm_vcpu * vcpu,u16 cpu_addr,u64 * reg)265 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
266 u64 *reg)
267 {
268 int rc;
269 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
270
271 if (cpu_addr >= KVM_MAX_VCPUS)
272 return SIGP_CC_NOT_OPERATIONAL;
273
274 spin_lock(&fi->lock);
275 if (fi->local_int[cpu_addr] == NULL)
276 rc = SIGP_CC_NOT_OPERATIONAL;
277 else {
278 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
279 & CPUSTAT_RUNNING) {
280 /* running */
281 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
282 } else {
283 /* not running */
284 *reg &= 0xffffffff00000000UL;
285 *reg |= SIGP_STATUS_NOT_RUNNING;
286 rc = SIGP_CC_STATUS_STORED;
287 }
288 }
289 spin_unlock(&fi->lock);
290
291 VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", cpu_addr,
292 rc);
293
294 return rc;
295 }
296
__sigp_restart(struct kvm_vcpu * vcpu,u16 cpu_addr)297 static int __sigp_restart(struct kvm_vcpu *vcpu, u16 cpu_addr)
298 {
299 struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
300 struct kvm_s390_local_interrupt *li;
301 int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
302
303 if (cpu_addr >= KVM_MAX_VCPUS)
304 return SIGP_CC_NOT_OPERATIONAL;
305
306 spin_lock(&fi->lock);
307 li = fi->local_int[cpu_addr];
308 if (li == NULL) {
309 rc = SIGP_CC_NOT_OPERATIONAL;
310 goto out;
311 }
312
313 spin_lock_bh(&li->lock);
314 if (li->action_bits & ACTION_STOP_ON_STOP)
315 rc = SIGP_CC_BUSY;
316 else
317 VCPU_EVENT(vcpu, 4, "sigp restart %x to handle userspace",
318 cpu_addr);
319 spin_unlock_bh(&li->lock);
320 out:
321 spin_unlock(&fi->lock);
322 return rc;
323 }
324
kvm_s390_handle_sigp(struct kvm_vcpu * vcpu)325 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
326 {
327 int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
328 int r3 = vcpu->arch.sie_block->ipa & 0x000f;
329 u32 parameter;
330 u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
331 u8 order_code;
332 int rc;
333
334 /* sigp in userspace can exit */
335 if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
336 return kvm_s390_inject_program_int(vcpu,
337 PGM_PRIVILEGED_OPERATION);
338
339 order_code = kvm_s390_get_base_disp_rs(vcpu);
340
341 if (r1 % 2)
342 parameter = vcpu->run->s.regs.gprs[r1];
343 else
344 parameter = vcpu->run->s.regs.gprs[r1 + 1];
345
346 trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
347 switch (order_code) {
348 case SIGP_SENSE:
349 vcpu->stat.instruction_sigp_sense++;
350 rc = __sigp_sense(vcpu, cpu_addr,
351 &vcpu->run->s.regs.gprs[r1]);
352 break;
353 case SIGP_EXTERNAL_CALL:
354 vcpu->stat.instruction_sigp_external_call++;
355 rc = __sigp_external_call(vcpu, cpu_addr);
356 break;
357 case SIGP_EMERGENCY_SIGNAL:
358 vcpu->stat.instruction_sigp_emergency++;
359 rc = __sigp_emergency(vcpu, cpu_addr);
360 break;
361 case SIGP_STOP:
362 vcpu->stat.instruction_sigp_stop++;
363 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
364 break;
365 case SIGP_STOP_AND_STORE_STATUS:
366 vcpu->stat.instruction_sigp_stop++;
367 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
368 ACTION_STOP_ON_STOP);
369 break;
370 case SIGP_SET_ARCHITECTURE:
371 vcpu->stat.instruction_sigp_arch++;
372 rc = __sigp_set_arch(vcpu, parameter);
373 break;
374 case SIGP_SET_PREFIX:
375 vcpu->stat.instruction_sigp_prefix++;
376 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
377 &vcpu->run->s.regs.gprs[r1]);
378 break;
379 case SIGP_SENSE_RUNNING:
380 vcpu->stat.instruction_sigp_sense_running++;
381 rc = __sigp_sense_running(vcpu, cpu_addr,
382 &vcpu->run->s.regs.gprs[r1]);
383 break;
384 case SIGP_RESTART:
385 vcpu->stat.instruction_sigp_restart++;
386 rc = __sigp_restart(vcpu, cpu_addr);
387 if (rc == SIGP_CC_BUSY)
388 break;
389 /* user space must know about restart */
390 default:
391 return -EOPNOTSUPP;
392 }
393
394 if (rc < 0)
395 return rc;
396
397 vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
398 vcpu->arch.sie_block->gpsw.mask |= (rc & 3ul) << 44;
399 return 0;
400 }
401