xref: /openbmc/linux/arch/s390/kvm/sigp.c (revision e23feb16)
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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, PGM_PRIVILEGED_OP);
337 
338 	order_code = kvm_s390_get_base_disp_rs(vcpu);
339 
340 	if (r1 % 2)
341 		parameter = vcpu->run->s.regs.gprs[r1];
342 	else
343 		parameter = vcpu->run->s.regs.gprs[r1 + 1];
344 
345 	trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
346 	switch (order_code) {
347 	case SIGP_SENSE:
348 		vcpu->stat.instruction_sigp_sense++;
349 		rc = __sigp_sense(vcpu, cpu_addr,
350 				  &vcpu->run->s.regs.gprs[r1]);
351 		break;
352 	case SIGP_EXTERNAL_CALL:
353 		vcpu->stat.instruction_sigp_external_call++;
354 		rc = __sigp_external_call(vcpu, cpu_addr);
355 		break;
356 	case SIGP_EMERGENCY_SIGNAL:
357 		vcpu->stat.instruction_sigp_emergency++;
358 		rc = __sigp_emergency(vcpu, cpu_addr);
359 		break;
360 	case SIGP_STOP:
361 		vcpu->stat.instruction_sigp_stop++;
362 		rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
363 		break;
364 	case SIGP_STOP_AND_STORE_STATUS:
365 		vcpu->stat.instruction_sigp_stop++;
366 		rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
367 						 ACTION_STOP_ON_STOP);
368 		break;
369 	case SIGP_SET_ARCHITECTURE:
370 		vcpu->stat.instruction_sigp_arch++;
371 		rc = __sigp_set_arch(vcpu, parameter);
372 		break;
373 	case SIGP_SET_PREFIX:
374 		vcpu->stat.instruction_sigp_prefix++;
375 		rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
376 				       &vcpu->run->s.regs.gprs[r1]);
377 		break;
378 	case SIGP_SENSE_RUNNING:
379 		vcpu->stat.instruction_sigp_sense_running++;
380 		rc = __sigp_sense_running(vcpu, cpu_addr,
381 					  &vcpu->run->s.regs.gprs[r1]);
382 		break;
383 	case SIGP_RESTART:
384 		vcpu->stat.instruction_sigp_restart++;
385 		rc = __sigp_restart(vcpu, cpu_addr);
386 		if (rc == SIGP_CC_BUSY)
387 			break;
388 		/* user space must know about restart */
389 	default:
390 		return -EOPNOTSUPP;
391 	}
392 
393 	if (rc < 0)
394 		return rc;
395 
396 	vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
397 	vcpu->arch.sie_block->gpsw.mask |= (rc & 3ul) << 44;
398 	return 0;
399 }
400