]>
Commit | Line | Data |
---|---|---|
5288fbf0 | 1 | /* |
a53c8fab | 2 | * handling interprocessor communication |
5288fbf0 | 3 | * |
b13d3580 | 4 | * Copyright IBM Corp. 2008, 2013 |
5288fbf0 CB |
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> | |
9ace903d | 12 | * Christian Ehrhardt <ehrhardt@de.ibm.com> |
5288fbf0 CB |
13 | */ |
14 | ||
15 | #include <linux/kvm.h> | |
16 | #include <linux/kvm_host.h> | |
5a0e3ad6 | 17 | #include <linux/slab.h> |
a9ae32c3 | 18 | #include <asm/sigp.h> |
5288fbf0 CB |
19 | #include "gaccess.h" |
20 | #include "kvm-s390.h" | |
5786fffa | 21 | #include "trace.h" |
5288fbf0 | 22 | |
3d95c7d2 | 23 | static int __sigp_sense(struct kvm_vcpu *vcpu, struct kvm_vcpu *dst_vcpu, |
5a32c1af | 24 | u64 *reg) |
5288fbf0 | 25 | { |
1ee0bc55 | 26 | struct kvm_s390_local_interrupt *li; |
1ee0bc55 | 27 | int cpuflags; |
5288fbf0 | 28 | int rc; |
ea5f4969 | 29 | int ext_call_pending; |
5288fbf0 | 30 | |
1ee0bc55 JF |
31 | li = &dst_vcpu->arch.local_int; |
32 | ||
33 | cpuflags = atomic_read(li->cpuflags); | |
ea5f4969 DH |
34 | ext_call_pending = kvm_s390_ext_call_pending(dst_vcpu); |
35 | if (!(cpuflags & CPUSTAT_STOPPED) && !ext_call_pending) | |
21b26c08 CH |
36 | rc = SIGP_CC_ORDER_CODE_ACCEPTED; |
37 | else { | |
5288fbf0 | 38 | *reg &= 0xffffffff00000000UL; |
ea5f4969 | 39 | if (ext_call_pending) |
21b26c08 | 40 | *reg |= SIGP_STATUS_EXT_CALL_PENDING; |
1ee0bc55 | 41 | if (cpuflags & CPUSTAT_STOPPED) |
21b26c08 | 42 | *reg |= SIGP_STATUS_STOPPED; |
ea1918dd | 43 | rc = SIGP_CC_STATUS_STORED; |
5288fbf0 | 44 | } |
5288fbf0 | 45 | |
3d95c7d2 DH |
46 | VCPU_EVENT(vcpu, 4, "sensed status of cpu %x rc %x", dst_vcpu->vcpu_id, |
47 | rc); | |
5288fbf0 CB |
48 | return rc; |
49 | } | |
50 | ||
07b03035 DH |
51 | static int __inject_sigp_emergency(struct kvm_vcpu *vcpu, |
52 | struct kvm_vcpu *dst_vcpu) | |
5288fbf0 | 53 | { |
383d0b05 | 54 | struct kvm_s390_irq irq = { |
22ff4a33 | 55 | .type = KVM_S390_INT_EMERGENCY, |
383d0b05 | 56 | .u.emerg.code = vcpu->vcpu_id, |
22ff4a33 | 57 | }; |
22ff4a33 | 58 | int rc = 0; |
5288fbf0 | 59 | |
383d0b05 | 60 | rc = kvm_s390_inject_vcpu(dst_vcpu, &irq); |
22ff4a33 | 61 | if (!rc) |
3d95c7d2 DH |
62 | VCPU_EVENT(vcpu, 4, "sent sigp emerg to cpu %x", |
63 | dst_vcpu->vcpu_id); | |
5288fbf0 | 64 | |
22ff4a33 | 65 | return rc ? rc : SIGP_CC_ORDER_CODE_ACCEPTED; |
7697e71f CE |
66 | } |
67 | ||
07b03035 DH |
68 | static int __sigp_emergency(struct kvm_vcpu *vcpu, struct kvm_vcpu *dst_vcpu) |
69 | { | |
70 | return __inject_sigp_emergency(vcpu, dst_vcpu); | |
71 | } | |
72 | ||
3d95c7d2 DH |
73 | static int __sigp_conditional_emergency(struct kvm_vcpu *vcpu, |
74 | struct kvm_vcpu *dst_vcpu, | |
b13d3580 TH |
75 | u16 asn, u64 *reg) |
76 | { | |
b13d3580 TH |
77 | const u64 psw_int_mask = PSW_MASK_IO | PSW_MASK_EXT; |
78 | u16 p_asn, s_asn; | |
79 | psw_t *psw; | |
94a15de8 | 80 | bool idle; |
b13d3580 | 81 | |
94a15de8 | 82 | idle = is_vcpu_idle(vcpu); |
b13d3580 TH |
83 | psw = &dst_vcpu->arch.sie_block->gpsw; |
84 | p_asn = dst_vcpu->arch.sie_block->gcr[4] & 0xffff; /* Primary ASN */ | |
85 | s_asn = dst_vcpu->arch.sie_block->gcr[3] & 0xffff; /* Secondary ASN */ | |
86 | ||
07b03035 | 87 | /* Inject the emergency signal? */ |
94a15de8 | 88 | if (!is_vcpu_stopped(vcpu) |
b13d3580 | 89 | || (psw->mask & psw_int_mask) != psw_int_mask |
94a15de8 DH |
90 | || (idle && psw->addr != 0) |
91 | || (!idle && (asn == p_asn || asn == s_asn))) { | |
07b03035 | 92 | return __inject_sigp_emergency(vcpu, dst_vcpu); |
b13d3580 TH |
93 | } else { |
94 | *reg &= 0xffffffff00000000UL; | |
95 | *reg |= SIGP_STATUS_INCORRECT_STATE; | |
96 | return SIGP_CC_STATUS_STORED; | |
97 | } | |
98 | } | |
99 | ||
3d95c7d2 | 100 | static int __sigp_external_call(struct kvm_vcpu *vcpu, |
ea5f4969 | 101 | struct kvm_vcpu *dst_vcpu, u64 *reg) |
7697e71f | 102 | { |
383d0b05 | 103 | struct kvm_s390_irq irq = { |
22ff4a33 | 104 | .type = KVM_S390_INT_EXTERNAL_CALL, |
383d0b05 | 105 | .u.extcall.code = vcpu->vcpu_id, |
22ff4a33 | 106 | }; |
22ff4a33 | 107 | int rc; |
7697e71f | 108 | |
383d0b05 | 109 | rc = kvm_s390_inject_vcpu(dst_vcpu, &irq); |
ea5f4969 DH |
110 | if (rc == -EBUSY) { |
111 | *reg &= 0xffffffff00000000UL; | |
112 | *reg |= SIGP_STATUS_EXT_CALL_PENDING; | |
113 | return SIGP_CC_STATUS_STORED; | |
114 | } else if (rc == 0) { | |
3d95c7d2 DH |
115 | VCPU_EVENT(vcpu, 4, "sent sigp ext call to cpu %x", |
116 | dst_vcpu->vcpu_id); | |
ea5f4969 | 117 | } |
7697e71f | 118 | |
22ff4a33 | 119 | return rc ? rc : SIGP_CC_ORDER_CODE_ACCEPTED; |
5288fbf0 CB |
120 | } |
121 | ||
a6cc3108 | 122 | static int __sigp_stop(struct kvm_vcpu *vcpu, struct kvm_vcpu *dst_vcpu) |
9ace903d | 123 | { |
6cddd432 DH |
124 | struct kvm_s390_irq irq = { |
125 | .type = KVM_S390_SIGP_STOP, | |
126 | }; | |
9ace903d CE |
127 | int rc; |
128 | ||
6cddd432 DH |
129 | rc = kvm_s390_inject_vcpu(dst_vcpu, &irq); |
130 | if (rc == -EBUSY) | |
131 | rc = SIGP_CC_BUSY; | |
132 | else if (rc == 0) | |
133 | VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", | |
134 | dst_vcpu->vcpu_id); | |
e879892c | 135 | |
a6cc3108 DH |
136 | return rc; |
137 | } | |
138 | ||
139 | static int __sigp_stop_and_store_status(struct kvm_vcpu *vcpu, | |
140 | struct kvm_vcpu *dst_vcpu, u64 *reg) | |
141 | { | |
6cddd432 DH |
142 | struct kvm_s390_irq irq = { |
143 | .type = KVM_S390_SIGP_STOP, | |
144 | .u.stop.flags = KVM_S390_STOP_FLAG_STORE_STATUS, | |
145 | }; | |
a6cc3108 DH |
146 | int rc; |
147 | ||
6cddd432 DH |
148 | rc = kvm_s390_inject_vcpu(dst_vcpu, &irq); |
149 | if (rc == -EBUSY) | |
150 | rc = SIGP_CC_BUSY; | |
151 | else if (rc == 0) | |
152 | VCPU_EVENT(vcpu, 4, "sent sigp stop and store status to cpu %x", | |
153 | dst_vcpu->vcpu_id); | |
e879892c | 154 | |
5288fbf0 CB |
155 | return rc; |
156 | } | |
157 | ||
b697e435 JH |
158 | static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter, |
159 | u64 *status_reg) | |
5288fbf0 | 160 | { |
3c038e6b DD |
161 | unsigned int i; |
162 | struct kvm_vcpu *v; | |
b697e435 | 163 | bool all_stopped = true; |
5288fbf0 | 164 | |
b697e435 JH |
165 | kvm_for_each_vcpu(i, v, vcpu->kvm) { |
166 | if (v == vcpu) | |
167 | continue; | |
168 | if (!is_vcpu_stopped(v)) | |
169 | all_stopped = false; | |
5288fbf0 | 170 | } |
b697e435 JH |
171 | |
172 | *status_reg &= 0xffffffff00000000UL; | |
173 | ||
174 | /* Reject set arch order, with czam we're always in z/Arch mode. */ | |
175 | *status_reg |= (all_stopped ? SIGP_STATUS_INVALID_PARAMETER : | |
176 | SIGP_STATUS_INCORRECT_STATE); | |
177 | return SIGP_CC_STATUS_STORED; | |
5288fbf0 CB |
178 | } |
179 | ||
3d95c7d2 DH |
180 | static int __sigp_set_prefix(struct kvm_vcpu *vcpu, struct kvm_vcpu *dst_vcpu, |
181 | u32 address, u64 *reg) | |
5288fbf0 | 182 | { |
a3a9c59a DH |
183 | struct kvm_s390_irq irq = { |
184 | .type = KVM_S390_SIGP_SET_PREFIX, | |
185 | .u.prefix.address = address & 0x7fffe000u, | |
186 | }; | |
5288fbf0 | 187 | int rc; |
5288fbf0 | 188 | |
665170cb HC |
189 | /* |
190 | * Make sure the new value is valid memory. We only need to check the | |
191 | * first page, since address is 8k aligned and memory pieces are always | |
192 | * at least 1MB aligned and have at least a size of 1MB. | |
193 | */ | |
a3a9c59a | 194 | if (kvm_is_error_gpa(vcpu->kvm, irq.u.prefix.address)) { |
0744426e | 195 | *reg &= 0xffffffff00000000UL; |
a9ae32c3 | 196 | *reg |= SIGP_STATUS_INVALID_PARAMETER; |
ea1918dd | 197 | return SIGP_CC_STATUS_STORED; |
5288fbf0 CB |
198 | } |
199 | ||
a3a9c59a DH |
200 | rc = kvm_s390_inject_vcpu(dst_vcpu, &irq); |
201 | if (rc == -EBUSY) { | |
0744426e HC |
202 | *reg &= 0xffffffff00000000UL; |
203 | *reg |= SIGP_STATUS_INCORRECT_STATE; | |
a3a9c59a | 204 | return SIGP_CC_STATUS_STORED; |
5288fbf0 CB |
205 | } |
206 | ||
5288fbf0 CB |
207 | return rc; |
208 | } | |
209 | ||
3d95c7d2 DH |
210 | static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, |
211 | struct kvm_vcpu *dst_vcpu, | |
212 | u32 addr, u64 *reg) | |
00e9e435 | 213 | { |
00e9e435 TH |
214 | int flags; |
215 | int rc; | |
216 | ||
00e9e435 | 217 | flags = atomic_read(dst_vcpu->arch.local_int.cpuflags); |
00e9e435 TH |
218 | if (!(flags & CPUSTAT_STOPPED)) { |
219 | *reg &= 0xffffffff00000000UL; | |
220 | *reg |= SIGP_STATUS_INCORRECT_STATE; | |
221 | return SIGP_CC_STATUS_STORED; | |
222 | } | |
223 | ||
224 | addr &= 0x7ffffe00; | |
225 | rc = kvm_s390_store_status_unloaded(dst_vcpu, addr); | |
226 | if (rc == -EFAULT) { | |
227 | *reg &= 0xffffffff00000000UL; | |
228 | *reg |= SIGP_STATUS_INVALID_PARAMETER; | |
229 | rc = SIGP_CC_STATUS_STORED; | |
230 | } | |
231 | return rc; | |
232 | } | |
233 | ||
3d95c7d2 DH |
234 | static int __sigp_sense_running(struct kvm_vcpu *vcpu, |
235 | struct kvm_vcpu *dst_vcpu, u64 *reg) | |
bd59d3a4 | 236 | { |
1ee0bc55 | 237 | struct kvm_s390_local_interrupt *li; |
bd59d3a4 | 238 | int rc; |
bd59d3a4 | 239 | |
bd50e8ec DH |
240 | if (!test_kvm_facility(vcpu->kvm, 9)) { |
241 | *reg &= 0xffffffff00000000UL; | |
242 | *reg |= SIGP_STATUS_INVALID_ORDER; | |
243 | return SIGP_CC_STATUS_STORED; | |
244 | } | |
245 | ||
1ee0bc55 JF |
246 | li = &dst_vcpu->arch.local_int; |
247 | if (atomic_read(li->cpuflags) & CPUSTAT_RUNNING) { | |
248 | /* running */ | |
249 | rc = SIGP_CC_ORDER_CODE_ACCEPTED; | |
250 | } else { | |
251 | /* not running */ | |
252 | *reg &= 0xffffffff00000000UL; | |
253 | *reg |= SIGP_STATUS_NOT_RUNNING; | |
254 | rc = SIGP_CC_STATUS_STORED; | |
bd59d3a4 | 255 | } |
bd59d3a4 | 256 | |
3d95c7d2 DH |
257 | VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", |
258 | dst_vcpu->vcpu_id, rc); | |
bd59d3a4 CH |
259 | |
260 | return rc; | |
261 | } | |
262 | ||
b8983830 DH |
263 | static int __prepare_sigp_re_start(struct kvm_vcpu *vcpu, |
264 | struct kvm_vcpu *dst_vcpu, u8 order_code) | |
151104a7 | 265 | { |
3d95c7d2 | 266 | struct kvm_s390_local_interrupt *li = &dst_vcpu->arch.local_int; |
b8983830 DH |
267 | /* handle (RE)START in user space */ |
268 | int rc = -EOPNOTSUPP; | |
151104a7 | 269 | |
6cddd432 | 270 | /* make sure we don't race with STOP irq injection */ |
4ae3c081 | 271 | spin_lock(&li->lock); |
6cddd432 | 272 | if (kvm_s390_is_stop_irq_pending(dst_vcpu)) |
ea1918dd | 273 | rc = SIGP_CC_BUSY; |
4ae3c081 | 274 | spin_unlock(&li->lock); |
1ee0bc55 | 275 | |
151104a7 JF |
276 | return rc; |
277 | } | |
278 | ||
b8983830 DH |
279 | static int __prepare_sigp_cpu_reset(struct kvm_vcpu *vcpu, |
280 | struct kvm_vcpu *dst_vcpu, u8 order_code) | |
281 | { | |
282 | /* handle (INITIAL) CPU RESET in user space */ | |
283 | return -EOPNOTSUPP; | |
284 | } | |
285 | ||
286 | static int __prepare_sigp_unknown(struct kvm_vcpu *vcpu, | |
287 | struct kvm_vcpu *dst_vcpu) | |
288 | { | |
289 | /* handle unknown orders in user space */ | |
290 | return -EOPNOTSUPP; | |
291 | } | |
292 | ||
3526a66b DH |
293 | static int handle_sigp_dst(struct kvm_vcpu *vcpu, u8 order_code, |
294 | u16 cpu_addr, u32 parameter, u64 *status_reg) | |
5288fbf0 | 295 | { |
5288fbf0 | 296 | int rc; |
152e9f65 | 297 | struct kvm_vcpu *dst_vcpu = kvm_get_vcpu_by_id(vcpu->kvm, cpu_addr); |
3d95c7d2 | 298 | |
3d95c7d2 DH |
299 | if (!dst_vcpu) |
300 | return SIGP_CC_NOT_OPERATIONAL; | |
5288fbf0 | 301 | |
5288fbf0 CB |
302 | switch (order_code) { |
303 | case SIGP_SENSE: | |
304 | vcpu->stat.instruction_sigp_sense++; | |
3d95c7d2 | 305 | rc = __sigp_sense(vcpu, dst_vcpu, status_reg); |
5288fbf0 | 306 | break; |
7697e71f CE |
307 | case SIGP_EXTERNAL_CALL: |
308 | vcpu->stat.instruction_sigp_external_call++; | |
ea5f4969 | 309 | rc = __sigp_external_call(vcpu, dst_vcpu, status_reg); |
7697e71f | 310 | break; |
a9ae32c3 | 311 | case SIGP_EMERGENCY_SIGNAL: |
5288fbf0 | 312 | vcpu->stat.instruction_sigp_emergency++; |
3d95c7d2 | 313 | rc = __sigp_emergency(vcpu, dst_vcpu); |
5288fbf0 CB |
314 | break; |
315 | case SIGP_STOP: | |
316 | vcpu->stat.instruction_sigp_stop++; | |
a6cc3108 | 317 | rc = __sigp_stop(vcpu, dst_vcpu); |
5288fbf0 | 318 | break; |
a9ae32c3 | 319 | case SIGP_STOP_AND_STORE_STATUS: |
42cb0c9f | 320 | vcpu->stat.instruction_sigp_stop_store_status++; |
a6cc3108 | 321 | rc = __sigp_stop_and_store_status(vcpu, dst_vcpu, status_reg); |
5288fbf0 | 322 | break; |
00e9e435 | 323 | case SIGP_STORE_STATUS_AT_ADDRESS: |
42cb0c9f | 324 | vcpu->stat.instruction_sigp_store_status++; |
3d95c7d2 | 325 | rc = __sigp_store_status_at_addr(vcpu, dst_vcpu, parameter, |
3526a66b | 326 | status_reg); |
5288fbf0 CB |
327 | break; |
328 | case SIGP_SET_PREFIX: | |
329 | vcpu->stat.instruction_sigp_prefix++; | |
3d95c7d2 | 330 | rc = __sigp_set_prefix(vcpu, dst_vcpu, parameter, status_reg); |
5288fbf0 | 331 | break; |
b13d3580 | 332 | case SIGP_COND_EMERGENCY_SIGNAL: |
42cb0c9f | 333 | vcpu->stat.instruction_sigp_cond_emergency++; |
3d95c7d2 | 334 | rc = __sigp_conditional_emergency(vcpu, dst_vcpu, parameter, |
3526a66b | 335 | status_reg); |
b13d3580 | 336 | break; |
bd59d3a4 CH |
337 | case SIGP_SENSE_RUNNING: |
338 | vcpu->stat.instruction_sigp_sense_running++; | |
3d95c7d2 | 339 | rc = __sigp_sense_running(vcpu, dst_vcpu, status_reg); |
bd59d3a4 | 340 | break; |
58bc33b2 | 341 | case SIGP_START: |
42cb0c9f | 342 | vcpu->stat.instruction_sigp_start++; |
b8983830 | 343 | rc = __prepare_sigp_re_start(vcpu, dst_vcpu, order_code); |
58bc33b2 | 344 | break; |
5288fbf0 CB |
345 | case SIGP_RESTART: |
346 | vcpu->stat.instruction_sigp_restart++; | |
b8983830 DH |
347 | rc = __prepare_sigp_re_start(vcpu, dst_vcpu, order_code); |
348 | break; | |
349 | case SIGP_INITIAL_CPU_RESET: | |
42cb0c9f | 350 | vcpu->stat.instruction_sigp_init_cpu_reset++; |
b8983830 DH |
351 | rc = __prepare_sigp_cpu_reset(vcpu, dst_vcpu, order_code); |
352 | break; | |
353 | case SIGP_CPU_RESET: | |
42cb0c9f | 354 | vcpu->stat.instruction_sigp_cpu_reset++; |
b8983830 | 355 | rc = __prepare_sigp_cpu_reset(vcpu, dst_vcpu, order_code); |
cc92d6de | 356 | break; |
5288fbf0 | 357 | default: |
42cb0c9f | 358 | vcpu->stat.instruction_sigp_unknown++; |
b8983830 | 359 | rc = __prepare_sigp_unknown(vcpu, dst_vcpu); |
3526a66b DH |
360 | } |
361 | ||
b8983830 DH |
362 | if (rc == -EOPNOTSUPP) |
363 | VCPU_EVENT(vcpu, 4, | |
364 | "sigp order %u -> cpu %x: handled in user space", | |
365 | order_code, dst_vcpu->vcpu_id); | |
366 | ||
3526a66b DH |
367 | return rc; |
368 | } | |
369 | ||
7cbde76b CB |
370 | static int handle_sigp_order_in_user_space(struct kvm_vcpu *vcpu, u8 order_code, |
371 | u16 cpu_addr) | |
2444b352 DH |
372 | { |
373 | if (!vcpu->kvm->arch.user_sigp) | |
374 | return 0; | |
375 | ||
376 | switch (order_code) { | |
377 | case SIGP_SENSE: | |
378 | case SIGP_EXTERNAL_CALL: | |
379 | case SIGP_EMERGENCY_SIGNAL: | |
380 | case SIGP_COND_EMERGENCY_SIGNAL: | |
381 | case SIGP_SENSE_RUNNING: | |
382 | return 0; | |
383 | /* update counters as we're directly dropping to user space */ | |
384 | case SIGP_STOP: | |
385 | vcpu->stat.instruction_sigp_stop++; | |
386 | break; | |
387 | case SIGP_STOP_AND_STORE_STATUS: | |
388 | vcpu->stat.instruction_sigp_stop_store_status++; | |
389 | break; | |
390 | case SIGP_STORE_STATUS_AT_ADDRESS: | |
391 | vcpu->stat.instruction_sigp_store_status++; | |
392 | break; | |
cd7b4b61 EF |
393 | case SIGP_STORE_ADDITIONAL_STATUS: |
394 | vcpu->stat.instruction_sigp_store_adtl_status++; | |
395 | break; | |
2444b352 DH |
396 | case SIGP_SET_PREFIX: |
397 | vcpu->stat.instruction_sigp_prefix++; | |
398 | break; | |
399 | case SIGP_START: | |
400 | vcpu->stat.instruction_sigp_start++; | |
401 | break; | |
402 | case SIGP_RESTART: | |
403 | vcpu->stat.instruction_sigp_restart++; | |
404 | break; | |
405 | case SIGP_INITIAL_CPU_RESET: | |
406 | vcpu->stat.instruction_sigp_init_cpu_reset++; | |
407 | break; | |
408 | case SIGP_CPU_RESET: | |
409 | vcpu->stat.instruction_sigp_cpu_reset++; | |
410 | break; | |
411 | default: | |
412 | vcpu->stat.instruction_sigp_unknown++; | |
413 | } | |
7cbde76b CB |
414 | VCPU_EVENT(vcpu, 3, "SIGP: order %u for CPU %d handled in userspace", |
415 | order_code, cpu_addr); | |
2444b352 DH |
416 | |
417 | return 1; | |
418 | } | |
419 | ||
3526a66b DH |
420 | int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu) |
421 | { | |
422 | int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4; | |
423 | int r3 = vcpu->arch.sie_block->ipa & 0x000f; | |
424 | u32 parameter; | |
425 | u16 cpu_addr = vcpu->run->s.regs.gprs[r3]; | |
426 | u8 order_code; | |
427 | int rc; | |
428 | ||
429 | /* sigp in userspace can exit */ | |
430 | if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE) | |
431 | return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP); | |
432 | ||
8ae04b8f | 433 | order_code = kvm_s390_get_base_disp_rs(vcpu, NULL); |
7cbde76b | 434 | if (handle_sigp_order_in_user_space(vcpu, order_code, cpu_addr)) |
2444b352 | 435 | return -EOPNOTSUPP; |
3526a66b DH |
436 | |
437 | if (r1 % 2) | |
438 | parameter = vcpu->run->s.regs.gprs[r1]; | |
439 | else | |
440 | parameter = vcpu->run->s.regs.gprs[r1 + 1]; | |
441 | ||
442 | trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter); | |
443 | switch (order_code) { | |
444 | case SIGP_SET_ARCHITECTURE: | |
445 | vcpu->stat.instruction_sigp_arch++; | |
b697e435 JH |
446 | rc = __sigp_set_arch(vcpu, parameter, |
447 | &vcpu->run->s.regs.gprs[r1]); | |
3526a66b DH |
448 | break; |
449 | default: | |
450 | rc = handle_sigp_dst(vcpu, order_code, cpu_addr, | |
451 | parameter, | |
452 | &vcpu->run->s.regs.gprs[r1]); | |
5288fbf0 CB |
453 | } |
454 | ||
455 | if (rc < 0) | |
456 | return rc; | |
457 | ||
949c007a | 458 | kvm_s390_set_psw_cc(vcpu, rc); |
5288fbf0 CB |
459 | return 0; |
460 | } | |
4953919f DH |
461 | |
462 | /* | |
463 | * Handle SIGP partial execution interception. | |
464 | * | |
465 | * This interception will occur at the source cpu when a source cpu sends an | |
466 | * external call to a target cpu and the target cpu has the WAIT bit set in | |
467 | * its cpuflags. Interception will occurr after the interrupt indicator bits at | |
468 | * the target cpu have been set. All error cases will lead to instruction | |
469 | * interception, therefore nothing is to be checked or prepared. | |
470 | */ | |
471 | int kvm_s390_handle_sigp_pei(struct kvm_vcpu *vcpu) | |
472 | { | |
473 | int r3 = vcpu->arch.sie_block->ipa & 0x000f; | |
474 | u16 cpu_addr = vcpu->run->s.regs.gprs[r3]; | |
475 | struct kvm_vcpu *dest_vcpu; | |
8ae04b8f | 476 | u8 order_code = kvm_s390_get_base_disp_rs(vcpu, NULL); |
4953919f DH |
477 | |
478 | trace_kvm_s390_handle_sigp_pei(vcpu, order_code, cpu_addr); | |
479 | ||
480 | if (order_code == SIGP_EXTERNAL_CALL) { | |
152e9f65 | 481 | dest_vcpu = kvm_get_vcpu_by_id(vcpu->kvm, cpu_addr); |
4953919f DH |
482 | BUG_ON(dest_vcpu == NULL); |
483 | ||
0e9c85a5 | 484 | kvm_s390_vcpu_wakeup(dest_vcpu); |
4953919f DH |
485 | kvm_s390_set_psw_cc(vcpu, SIGP_CC_ORDER_CODE_ACCEPTED); |
486 | return 0; | |
487 | } | |
488 | ||
489 | return -EOPNOTSUPP; | |
490 | } |