blob: c2caa175320c0199476b91e5bdd5e9a5c35f62ae [file] [log] [blame]
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001/*
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02002 * hosting zSeries kernel virtual machines
Heiko Carstensb0c632d2008-03-25 18:47:20 +01003 *
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02004 * Copyright IBM Corp. 2008, 2009
Heiko Carstensb0c632d2008-03-25 18:47:20 +01005 *
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 * Heiko Carstens <heiko.carstens@de.ibm.com>
Christian Ehrhardt628eb9b2009-05-25 13:40:51 +020013 * Christian Ehrhardt <ehrhardt@de.ibm.com>
Jason J. Herne15f36eb2012-08-02 10:10:17 -040014 * Jason J. Herne <jjherne@us.ibm.com>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010015 */
16
17#include <linux/compiler.h>
18#include <linux/err.h>
19#include <linux/fs.h>
Christian Borntraegerca872302009-05-12 17:21:49 +020020#include <linux/hrtimer.h>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010021#include <linux/init.h>
22#include <linux/kvm.h>
23#include <linux/kvm_host.h>
24#include <linux/module.h>
25#include <linux/slab.h>
Carsten Otteba5c1e92008-03-25 18:47:26 +010026#include <linux/timer.h>
Heiko Carstenscbb870c2010-02-26 22:37:43 +010027#include <asm/asm-offsets.h>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010028#include <asm/lowcore.h>
29#include <asm/pgtable.h>
Heiko Carstensf5daba12009-03-26 15:24:01 +010030#include <asm/nmi.h>
David Howellsa0616cd2012-03-28 18:30:02 +010031#include <asm/switch_to.h>
Michael Mueller78c4b592013-07-26 15:04:04 +020032#include <asm/facility.h>
Christian Borntraeger1526bf92012-05-15 14:15:25 +020033#include <asm/sclp.h>
Christian Borntraeger8f2abe62008-03-25 18:47:23 +010034#include "kvm-s390.h"
Heiko Carstensb0c632d2008-03-25 18:47:20 +010035#include "gaccess.h"
36
Cornelia Huck5786fff2012-07-23 17:20:29 +020037#define CREATE_TRACE_POINTS
38#include "trace.h"
Cornelia Huckade38c32012-07-23 17:20:30 +020039#include "trace-s390.h"
Cornelia Huck5786fff2012-07-23 17:20:29 +020040
Heiko Carstensb0c632d2008-03-25 18:47:20 +010041#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
42
43struct kvm_stats_debugfs_item debugfs_entries[] = {
44 { "userspace_handled", VCPU_STAT(exit_userspace) },
Christian Borntraeger0eaeafa2008-05-07 09:22:53 +020045 { "exit_null", VCPU_STAT(exit_null) },
Christian Borntraeger8f2abe62008-03-25 18:47:23 +010046 { "exit_validity", VCPU_STAT(exit_validity) },
47 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
48 { "exit_external_request", VCPU_STAT(exit_external_request) },
49 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010050 { "exit_instruction", VCPU_STAT(exit_instruction) },
51 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
52 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
Christian Borntraegerf5e10b02008-07-25 15:52:44 +020053 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010054 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
David Hildenbrandaba07502014-01-23 10:47:13 +010055 { "instruction_stctl", VCPU_STAT(instruction_stctl) },
56 { "instruction_stctg", VCPU_STAT(instruction_stctg) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010057 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
Christian Ehrhardt7697e71f2011-10-18 12:27:15 +020058 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010059 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
60 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
61 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
62 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
63 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
64 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
65 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +020066 { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010067 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
68 { "instruction_spx", VCPU_STAT(instruction_spx) },
69 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
70 { "instruction_stap", VCPU_STAT(instruction_stap) },
71 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
Heiko Carstens8a2422342014-01-10 14:33:28 +010072 { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010073 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
74 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
Konstantin Weitzb31288f2013-04-17 17:36:29 +020075 { "instruction_essa", VCPU_STAT(instruction_essa) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010076 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
77 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
Christian Borntraegerbb25b9b2011-07-24 10:48:17 +020078 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010079 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
Cornelia Huckbd59d3a2011-11-17 11:00:42 +010080 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
Christian Ehrhardt7697e71f2011-10-18 12:27:15 +020081 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010082 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
83 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
84 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
85 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
86 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
Christian Borntraeger388186b2011-10-30 15:17:03 +010087 { "diagnose_10", VCPU_STAT(diagnose_10) },
Christian Borntraegere28acfe2008-03-25 18:47:34 +010088 { "diagnose_44", VCPU_STAT(diagnose_44) },
Konstantin Weitz41628d32012-04-25 15:30:38 +020089 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
Heiko Carstensb0c632d2008-03-25 18:47:20 +010090 { NULL }
91};
92
Michael Mueller78c4b592013-07-26 15:04:04 +020093unsigned long *vfacilities;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +020094static struct gmap_notifier gmap_notifier;
Heiko Carstensb0c632d2008-03-25 18:47:20 +010095
Michael Mueller78c4b592013-07-26 15:04:04 +020096/* test availability of vfacility */
Heiko Carstens280ef0f2013-12-17 09:08:28 +010097int test_vfacility(unsigned long nr)
Michael Mueller78c4b592013-07-26 15:04:04 +020098{
99 return __test_facility(nr, (void *) vfacilities);
100}
101
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100102/* Section: not file related */
Alexander Graf10474ae2009-09-15 11:37:46 +0200103int kvm_arch_hardware_enable(void *garbage)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100104{
105 /* every s390 is virtualization enabled ;-) */
Alexander Graf10474ae2009-09-15 11:37:46 +0200106 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100107}
108
109void kvm_arch_hardware_disable(void *garbage)
110{
111}
112
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200113static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
114
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100115int kvm_arch_hardware_setup(void)
116{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200117 gmap_notifier.notifier_call = kvm_gmap_notifier;
118 gmap_register_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100119 return 0;
120}
121
122void kvm_arch_hardware_unsetup(void)
123{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200124 gmap_unregister_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100125}
126
127void kvm_arch_check_processor_compat(void *rtn)
128{
129}
130
131int kvm_arch_init(void *opaque)
132{
133 return 0;
134}
135
136void kvm_arch_exit(void)
137{
138}
139
140/* Section: device related */
141long kvm_arch_dev_ioctl(struct file *filp,
142 unsigned int ioctl, unsigned long arg)
143{
144 if (ioctl == KVM_S390_ENABLE_SIE)
145 return s390_enable_sie();
146 return -EINVAL;
147}
148
Alexander Graf784aa3d2014-07-14 18:27:35 +0200149int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100150{
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100151 int r;
152
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200153 switch (ext) {
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100154 case KVM_CAP_S390_PSW:
Christian Borntraegerb6cf8782011-09-20 17:07:29 +0200155 case KVM_CAP_S390_GMAP:
Christian Borntraeger52e16b12011-11-17 11:00:44 +0100156 case KVM_CAP_SYNC_MMU:
Carsten Otte1efd0f52012-01-04 10:25:29 +0100157#ifdef CONFIG_KVM_S390_UCONTROL
158 case KVM_CAP_S390_UCONTROL:
159#endif
Dominik Dingel3c038e62013-10-07 17:11:48 +0200160 case KVM_CAP_ASYNC_PF:
Christian Borntraeger60b413c2012-01-11 11:20:31 +0100161 case KVM_CAP_SYNC_REGS:
Carsten Otte14eebd92012-05-15 14:15:26 +0200162 case KVM_CAP_ONE_REG:
Cornelia Huckd6712df2012-12-20 15:32:11 +0100163 case KVM_CAP_ENABLE_CAP:
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100164 case KVM_CAP_S390_CSS_SUPPORT:
Cornelia Huckebc32262014-05-09 15:00:46 +0200165 case KVM_CAP_IRQFD:
Cornelia Huck10ccaa12013-02-28 12:33:21 +0100166 case KVM_CAP_IOEVENTFD:
Jens Freimannc05c4182013-10-07 16:13:45 +0200167 case KVM_CAP_DEVICE_CTRL:
Cornelia Huckd938dc52013-10-23 18:26:34 +0200168 case KVM_CAP_ENABLE_CAP_VM:
Cornelia Huck78599d92014-07-15 09:54:39 +0200169 case KVM_CAP_S390_IRQCHIP:
Dominik Dingelf2061652014-04-09 13:13:00 +0200170 case KVM_CAP_VM_ATTRIBUTES:
David Hildenbrand6352e4d2014-04-10 17:35:00 +0200171 case KVM_CAP_MP_STATE:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100172 r = 1;
173 break;
Christian Borntraegere726b1b2012-05-02 10:50:38 +0200174 case KVM_CAP_NR_VCPUS:
175 case KVM_CAP_MAX_VCPUS:
176 r = KVM_MAX_VCPUS;
177 break;
Nick Wange1e2e602013-03-25 17:22:58 +0100178 case KVM_CAP_NR_MEMSLOTS:
179 r = KVM_USER_MEM_SLOTS;
180 break;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200181 case KVM_CAP_S390_COW:
Martin Schwidefskyabf09be2012-11-07 13:17:37 +0100182 r = MACHINE_HAS_ESOP;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200183 break;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200184 default:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100185 r = 0;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200186 }
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100187 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100188}
189
Jason J. Herne15f36eb2012-08-02 10:10:17 -0400190static void kvm_s390_sync_dirty_log(struct kvm *kvm,
191 struct kvm_memory_slot *memslot)
192{
193 gfn_t cur_gfn, last_gfn;
194 unsigned long address;
195 struct gmap *gmap = kvm->arch.gmap;
196
197 down_read(&gmap->mm->mmap_sem);
198 /* Loop over all guest pages */
199 last_gfn = memslot->base_gfn + memslot->npages;
200 for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
201 address = gfn_to_hva_memslot(memslot, cur_gfn);
202
203 if (gmap_test_and_clear_dirty(address, gmap))
204 mark_page_dirty(kvm, cur_gfn);
205 }
206 up_read(&gmap->mm->mmap_sem);
207}
208
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100209/* Section: vm related */
210/*
211 * Get (and clear) the dirty memory log for a memory slot.
212 */
213int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
214 struct kvm_dirty_log *log)
215{
Jason J. Herne15f36eb2012-08-02 10:10:17 -0400216 int r;
217 unsigned long n;
218 struct kvm_memory_slot *memslot;
219 int is_dirty = 0;
220
221 mutex_lock(&kvm->slots_lock);
222
223 r = -EINVAL;
224 if (log->slot >= KVM_USER_MEM_SLOTS)
225 goto out;
226
227 memslot = id_to_memslot(kvm->memslots, log->slot);
228 r = -ENOENT;
229 if (!memslot->dirty_bitmap)
230 goto out;
231
232 kvm_s390_sync_dirty_log(kvm, memslot);
233 r = kvm_get_dirty_log(kvm, log, &is_dirty);
234 if (r)
235 goto out;
236
237 /* Clear the dirty log */
238 if (is_dirty) {
239 n = kvm_dirty_bitmap_bytes(memslot);
240 memset(memslot->dirty_bitmap, 0, n);
241 }
242 r = 0;
243out:
244 mutex_unlock(&kvm->slots_lock);
245 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100246}
247
Cornelia Huckd938dc52013-10-23 18:26:34 +0200248static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
249{
250 int r;
251
252 if (cap->flags)
253 return -EINVAL;
254
255 switch (cap->cap) {
Cornelia Huck84223592013-07-15 13:36:01 +0200256 case KVM_CAP_S390_IRQCHIP:
257 kvm->arch.use_irqchip = 1;
258 r = 0;
259 break;
Cornelia Huckd938dc52013-10-23 18:26:34 +0200260 default:
261 r = -EINVAL;
262 break;
263 }
264 return r;
265}
266
Dominik Dingel4f718ea2014-04-09 13:13:00 +0200267static int kvm_s390_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
268{
269 int ret;
270 unsigned int idx;
271 switch (attr->attr) {
272 case KVM_S390_VM_MEM_ENABLE_CMMA:
273 ret = -EBUSY;
274 mutex_lock(&kvm->lock);
275 if (atomic_read(&kvm->online_vcpus) == 0) {
276 kvm->arch.use_cmma = 1;
277 ret = 0;
278 }
279 mutex_unlock(&kvm->lock);
280 break;
281 case KVM_S390_VM_MEM_CLR_CMMA:
282 mutex_lock(&kvm->lock);
283 idx = srcu_read_lock(&kvm->srcu);
284 page_table_reset_pgste(kvm->arch.gmap->mm, 0, TASK_SIZE, false);
285 srcu_read_unlock(&kvm->srcu, idx);
286 mutex_unlock(&kvm->lock);
287 ret = 0;
288 break;
289 default:
290 ret = -ENXIO;
291 break;
292 }
293 return ret;
294}
295
Dominik Dingelf2061652014-04-09 13:13:00 +0200296static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
297{
298 int ret;
299
300 switch (attr->group) {
Dominik Dingel4f718ea2014-04-09 13:13:00 +0200301 case KVM_S390_VM_MEM_CTRL:
302 ret = kvm_s390_mem_control(kvm, attr);
303 break;
Dominik Dingelf2061652014-04-09 13:13:00 +0200304 default:
305 ret = -ENXIO;
306 break;
307 }
308
309 return ret;
310}
311
312static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
313{
314 return -ENXIO;
315}
316
317static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
318{
319 int ret;
320
321 switch (attr->group) {
Dominik Dingel4f718ea2014-04-09 13:13:00 +0200322 case KVM_S390_VM_MEM_CTRL:
323 switch (attr->attr) {
324 case KVM_S390_VM_MEM_ENABLE_CMMA:
325 case KVM_S390_VM_MEM_CLR_CMMA:
326 ret = 0;
327 break;
328 default:
329 ret = -ENXIO;
330 break;
331 }
332 break;
Dominik Dingelf2061652014-04-09 13:13:00 +0200333 default:
334 ret = -ENXIO;
335 break;
336 }
337
338 return ret;
339}
340
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100341long kvm_arch_vm_ioctl(struct file *filp,
342 unsigned int ioctl, unsigned long arg)
343{
344 struct kvm *kvm = filp->private_data;
345 void __user *argp = (void __user *)arg;
Dominik Dingelf2061652014-04-09 13:13:00 +0200346 struct kvm_device_attr attr;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100347 int r;
348
349 switch (ioctl) {
Carsten Otteba5c1e92008-03-25 18:47:26 +0100350 case KVM_S390_INTERRUPT: {
351 struct kvm_s390_interrupt s390int;
352
353 r = -EFAULT;
354 if (copy_from_user(&s390int, argp, sizeof(s390int)))
355 break;
356 r = kvm_s390_inject_vm(kvm, &s390int);
357 break;
358 }
Cornelia Huckd938dc52013-10-23 18:26:34 +0200359 case KVM_ENABLE_CAP: {
360 struct kvm_enable_cap cap;
361 r = -EFAULT;
362 if (copy_from_user(&cap, argp, sizeof(cap)))
363 break;
364 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
365 break;
366 }
Cornelia Huck84223592013-07-15 13:36:01 +0200367 case KVM_CREATE_IRQCHIP: {
368 struct kvm_irq_routing_entry routing;
369
370 r = -EINVAL;
371 if (kvm->arch.use_irqchip) {
372 /* Set up dummy routing. */
373 memset(&routing, 0, sizeof(routing));
374 kvm_set_irq_routing(kvm, &routing, 0, 0);
375 r = 0;
376 }
377 break;
378 }
Dominik Dingelf2061652014-04-09 13:13:00 +0200379 case KVM_SET_DEVICE_ATTR: {
380 r = -EFAULT;
381 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
382 break;
383 r = kvm_s390_vm_set_attr(kvm, &attr);
384 break;
385 }
386 case KVM_GET_DEVICE_ATTR: {
387 r = -EFAULT;
388 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
389 break;
390 r = kvm_s390_vm_get_attr(kvm, &attr);
391 break;
392 }
393 case KVM_HAS_DEVICE_ATTR: {
394 r = -EFAULT;
395 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
396 break;
397 r = kvm_s390_vm_has_attr(kvm, &attr);
398 break;
399 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100400 default:
Avi Kivity367e1312009-08-26 14:57:07 +0300401 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100402 }
403
404 return r;
405}
406
Carsten Ottee08b9632012-01-04 10:25:20 +0100407int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100408{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100409 int rc;
410 char debug_name[16];
Christian Borntraegerf6c137f2014-03-19 11:18:29 +0100411 static unsigned long sca_offset;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100412
Carsten Ottee08b9632012-01-04 10:25:20 +0100413 rc = -EINVAL;
414#ifdef CONFIG_KVM_S390_UCONTROL
415 if (type & ~KVM_VM_S390_UCONTROL)
416 goto out_err;
417 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
418 goto out_err;
419#else
420 if (type)
421 goto out_err;
422#endif
423
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100424 rc = s390_enable_sie();
425 if (rc)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100426 goto out_err;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100427
Carsten Otteb2904112011-10-18 12:27:13 +0200428 rc = -ENOMEM;
429
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100430 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
431 if (!kvm->arch.sca)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100432 goto out_err;
Christian Borntraegerf6c137f2014-03-19 11:18:29 +0100433 spin_lock(&kvm_lock);
434 sca_offset = (sca_offset + 16) & 0x7f0;
435 kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset);
436 spin_unlock(&kvm_lock);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100437
438 sprintf(debug_name, "kvm-%u", current->pid);
439
440 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
441 if (!kvm->arch.dbf)
442 goto out_nodbf;
443
Carsten Otteba5c1e92008-03-25 18:47:26 +0100444 spin_lock_init(&kvm->arch.float_int.lock);
445 INIT_LIST_HEAD(&kvm->arch.float_int.list);
Heiko Carstens8a2422342014-01-10 14:33:28 +0100446 init_waitqueue_head(&kvm->arch.ipte_wq);
Carsten Otteba5c1e92008-03-25 18:47:26 +0100447
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100448 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
449 VM_EVENT(kvm, 3, "%s", "vm created");
450
Carsten Ottee08b9632012-01-04 10:25:20 +0100451 if (type & KVM_VM_S390_UCONTROL) {
452 kvm->arch.gmap = NULL;
453 } else {
454 kvm->arch.gmap = gmap_alloc(current->mm);
455 if (!kvm->arch.gmap)
456 goto out_nogmap;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200457 kvm->arch.gmap->private = kvm;
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200458 kvm->arch.gmap->pfault_enabled = 0;
Carsten Ottee08b9632012-01-04 10:25:20 +0100459 }
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100460
461 kvm->arch.css_support = 0;
Cornelia Huck84223592013-07-15 13:36:01 +0200462 kvm->arch.use_irqchip = 0;
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100463
David Hildenbrand8ad35752014-03-14 11:00:21 +0100464 spin_lock_init(&kvm->arch.start_stop_lock);
465
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100466 return 0;
Carsten Otte598841c2011-07-24 10:48:21 +0200467out_nogmap:
468 debug_unregister(kvm->arch.dbf);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100469out_nodbf:
470 free_page((unsigned long)(kvm->arch.sca));
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100471out_err:
472 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100473}
474
Christian Borntraegerd329c032008-11-26 14:50:27 +0100475void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
476{
477 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
Cornelia Huckade38c32012-07-23 17:20:30 +0200478 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
Christian Borntraeger67335e62014-03-25 17:09:08 +0100479 kvm_s390_clear_local_irqs(vcpu);
Dominik Dingel3c038e62013-10-07 17:11:48 +0200480 kvm_clear_async_pf_completion_queue(vcpu);
Carsten Otte58f94602012-01-04 10:25:27 +0100481 if (!kvm_is_ucontrol(vcpu->kvm)) {
482 clear_bit(63 - vcpu->vcpu_id,
483 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
484 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
485 (__u64) vcpu->arch.sie_block)
486 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
487 }
Carsten Otteabf4a712009-05-12 17:21:51 +0200488 smp_mb();
Carsten Otte27e03932012-01-04 10:25:21 +0100489
490 if (kvm_is_ucontrol(vcpu->kvm))
491 gmap_free(vcpu->arch.gmap);
492
Dominik Dingelb31605c2014-03-25 13:47:11 +0100493 if (kvm_s390_cmma_enabled(vcpu->kvm))
494 kvm_s390_vcpu_unsetup_cmma(vcpu);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100495 free_page((unsigned long)(vcpu->arch.sie_block));
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200496
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100497 kvm_vcpu_uninit(vcpu);
Michael Muellerb110fea2013-06-12 13:54:54 +0200498 kmem_cache_free(kvm_vcpu_cache, vcpu);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100499}
500
501static void kvm_free_vcpus(struct kvm *kvm)
502{
503 unsigned int i;
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300504 struct kvm_vcpu *vcpu;
Christian Borntraegerd329c032008-11-26 14:50:27 +0100505
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300506 kvm_for_each_vcpu(i, vcpu, kvm)
507 kvm_arch_vcpu_destroy(vcpu);
508
509 mutex_lock(&kvm->lock);
510 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
511 kvm->vcpus[i] = NULL;
512
513 atomic_set(&kvm->online_vcpus, 0);
514 mutex_unlock(&kvm->lock);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100515}
516
Sheng Yangad8ba2c2009-01-06 10:03:02 +0800517void kvm_arch_sync_events(struct kvm *kvm)
518{
519}
520
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100521void kvm_arch_destroy_vm(struct kvm *kvm)
522{
Christian Borntraegerd329c032008-11-26 14:50:27 +0100523 kvm_free_vcpus(kvm);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100524 free_page((unsigned long)(kvm->arch.sca));
Christian Borntraegerd329c032008-11-26 14:50:27 +0100525 debug_unregister(kvm->arch.dbf);
Carsten Otte27e03932012-01-04 10:25:21 +0100526 if (!kvm_is_ucontrol(kvm))
527 gmap_free(kvm->arch.gmap);
Cornelia Huck841b91c2013-07-15 13:36:01 +0200528 kvm_s390_destroy_adapters(kvm);
Christian Borntraeger67335e62014-03-25 17:09:08 +0100529 kvm_s390_clear_float_irqs(kvm);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100530}
531
532/* Section: vcpu related */
533int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
534{
Dominik Dingel3c038e62013-10-07 17:11:48 +0200535 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
536 kvm_clear_async_pf_completion_queue(vcpu);
Carsten Otte27e03932012-01-04 10:25:21 +0100537 if (kvm_is_ucontrol(vcpu->kvm)) {
538 vcpu->arch.gmap = gmap_alloc(current->mm);
539 if (!vcpu->arch.gmap)
540 return -ENOMEM;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200541 vcpu->arch.gmap->private = vcpu->kvm;
Carsten Otte27e03932012-01-04 10:25:21 +0100542 return 0;
543 }
544
Carsten Otte598841c2011-07-24 10:48:21 +0200545 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
Christian Borntraeger59674c12012-01-11 11:20:33 +0100546 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
547 KVM_SYNC_GPRS |
Christian Borntraeger9eed07352012-02-06 10:59:07 +0100548 KVM_SYNC_ACRS |
David Hildenbrandb028ee32014-07-17 10:47:43 +0200549 KVM_SYNC_CRS |
550 KVM_SYNC_ARCH0 |
551 KVM_SYNC_PFAULT;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100552 return 0;
553}
554
555void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
556{
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100557 /* Nothing todo */
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100558}
559
560void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
561{
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200562 save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
563 save_fp_regs(vcpu->arch.host_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100564 save_access_regs(vcpu->arch.host_acrs);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200565 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
566 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100567 restore_access_regs(vcpu->run->s.regs.acrs);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200568 gmap_enable(vcpu->arch.gmap);
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100569 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100570}
571
572void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
573{
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100574 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200575 gmap_disable(vcpu->arch.gmap);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200576 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
577 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100578 save_access_regs(vcpu->run->s.regs.acrs);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200579 restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
580 restore_fp_regs(vcpu->arch.host_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100581 restore_access_regs(vcpu->arch.host_acrs);
582}
583
584static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
585{
586 /* this equals initial cpu reset in pop, but we don't switch to ESA */
587 vcpu->arch.sie_block->gpsw.mask = 0UL;
588 vcpu->arch.sie_block->gpsw.addr = 0UL;
Christian Borntraeger8d26cf72012-01-11 11:19:32 +0100589 kvm_s390_set_prefix(vcpu, 0);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100590 vcpu->arch.sie_block->cputm = 0UL;
591 vcpu->arch.sie_block->ckc = 0UL;
592 vcpu->arch.sie_block->todpr = 0;
593 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
594 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
595 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
596 vcpu->arch.guest_fpregs.fpc = 0;
597 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
598 vcpu->arch.sie_block->gbea = 1;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100599 vcpu->arch.sie_block->pp = 0;
Dominik Dingel3c038e62013-10-07 17:11:48 +0200600 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
601 kvm_clear_async_pf_completion_queue(vcpu);
David Hildenbrand6352e4d2014-04-10 17:35:00 +0200602 if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
603 kvm_s390_vcpu_stop(vcpu);
Jens Freimann2ed10cc2014-02-11 13:48:07 +0100604 kvm_s390_clear_local_irqs(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100605}
606
Marcelo Tosatti42897d82012-11-27 23:29:02 -0200607int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
608{
609 return 0;
610}
611
Dominik Dingelb31605c2014-03-25 13:47:11 +0100612void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
613{
614 free_page(vcpu->arch.sie_block->cbrlo);
615 vcpu->arch.sie_block->cbrlo = 0;
616}
617
618int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
619{
620 vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
621 if (!vcpu->arch.sie_block->cbrlo)
622 return -ENOMEM;
623
624 vcpu->arch.sie_block->ecb2 |= 0x80;
625 vcpu->arch.sie_block->ecb2 &= ~0x08;
626 return 0;
627}
628
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100629int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
630{
Dominik Dingelb31605c2014-03-25 13:47:11 +0100631 int rc = 0;
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200632
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100633 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
634 CPUSTAT_SM |
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +0200635 CPUSTAT_STOPPED |
636 CPUSTAT_GED);
Christian Borntraegerfc345312010-06-17 23:16:20 +0200637 vcpu->arch.sie_block->ecb = 6;
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200638 if (test_vfacility(50) && test_vfacility(73))
639 vcpu->arch.sie_block->ecb |= 0x10;
640
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +0200641 vcpu->arch.sie_block->ecb2 = 8;
David Hildenbrand49539192014-02-21 08:59:59 +0100642 vcpu->arch.sie_block->eca = 0xD1002000U;
Heiko Carstens217a4402013-12-30 12:54:14 +0100643 if (sclp_has_siif())
644 vcpu->arch.sie_block->eca |= 1;
Michael Mueller78c4b592013-07-26 15:04:04 +0200645 vcpu->arch.sie_block->fac = (int) (long) vfacilities;
Matthew Rosato5a5e6532013-01-29 11:48:20 -0500646 vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE |
647 ICTL_TPROT;
648
Dominik Dingelb31605c2014-03-25 13:47:11 +0100649 if (kvm_s390_cmma_enabled(vcpu->kvm)) {
650 rc = kvm_s390_vcpu_setup_cmma(vcpu);
651 if (rc)
652 return rc;
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200653 }
Christian Borntraegerca872302009-05-12 17:21:49 +0200654 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
Christian Borntraegerca872302009-05-12 17:21:49 +0200655 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
Christian Borntraeger453423d2008-03-25 18:47:29 +0100656 get_cpu_id(&vcpu->arch.cpu_id);
Christian Borntraeger92e6ecf2009-03-26 15:23:58 +0100657 vcpu->arch.cpu_id.version = 0xff;
Dominik Dingelb31605c2014-03-25 13:47:11 +0100658 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100659}
660
661struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
662 unsigned int id)
663{
Carsten Otte4d475552011-10-18 12:27:12 +0200664 struct kvm_vcpu *vcpu;
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200665 struct sie_page *sie_page;
Carsten Otte4d475552011-10-18 12:27:12 +0200666 int rc = -EINVAL;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100667
Carsten Otte4d475552011-10-18 12:27:12 +0200668 if (id >= KVM_MAX_VCPUS)
669 goto out;
670
671 rc = -ENOMEM;
672
Michael Muellerb110fea2013-06-12 13:54:54 +0200673 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100674 if (!vcpu)
Carsten Otte4d475552011-10-18 12:27:12 +0200675 goto out;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100676
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200677 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
678 if (!sie_page)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100679 goto out_free_cpu;
680
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200681 vcpu->arch.sie_block = &sie_page->sie_block;
682 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
683
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100684 vcpu->arch.sie_block->icpua = id;
Carsten Otte58f94602012-01-04 10:25:27 +0100685 if (!kvm_is_ucontrol(kvm)) {
686 if (!kvm->arch.sca) {
687 WARN_ON_ONCE(1);
688 goto out_free_cpu;
689 }
690 if (!kvm->arch.sca->cpu[id].sda)
691 kvm->arch.sca->cpu[id].sda =
692 (__u64) vcpu->arch.sie_block;
693 vcpu->arch.sie_block->scaoh =
694 (__u32)(((__u64)kvm->arch.sca) >> 32);
695 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
696 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
697 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100698
Carsten Otteba5c1e92008-03-25 18:47:26 +0100699 spin_lock_init(&vcpu->arch.local_int.lock);
700 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
701 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
Christian Borntraegerd0321a22013-06-12 13:54:55 +0200702 vcpu->arch.local_int.wq = &vcpu->wq;
Christian Borntraeger5288fbf2008-03-25 18:47:31 +0100703 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
Carsten Otteba5c1e92008-03-25 18:47:26 +0100704
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100705 rc = kvm_vcpu_init(vcpu, kvm, id);
706 if (rc)
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800707 goto out_free_sie_block;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100708 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
709 vcpu->arch.sie_block);
Cornelia Huckade38c32012-07-23 17:20:30 +0200710 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100711
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100712 return vcpu;
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800713out_free_sie_block:
714 free_page((unsigned long)(vcpu->arch.sie_block));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100715out_free_cpu:
Michael Muellerb110fea2013-06-12 13:54:54 +0200716 kmem_cache_free(kvm_vcpu_cache, vcpu);
Carsten Otte4d475552011-10-18 12:27:12 +0200717out:
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100718 return ERR_PTR(rc);
719}
720
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100721int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
722{
Michael Muellerf87618e2014-02-26 16:14:17 +0100723 return kvm_cpu_has_interrupt(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100724}
725
Christian Borntraeger49b99e12013-05-17 14:41:35 +0200726void s390_vcpu_block(struct kvm_vcpu *vcpu)
727{
728 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
729}
730
731void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
732{
733 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
734}
735
736/*
737 * Kick a guest cpu out of SIE and wait until SIE is not running.
738 * If the CPU is not running (e.g. waiting as idle) the function will
739 * return immediately. */
740void exit_sie(struct kvm_vcpu *vcpu)
741{
742 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
743 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
744 cpu_relax();
745}
746
747/* Kick a guest cpu out of SIE and prevent SIE-reentry */
748void exit_sie_sync(struct kvm_vcpu *vcpu)
749{
750 s390_vcpu_block(vcpu);
751 exit_sie(vcpu);
752}
753
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200754static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
755{
756 int i;
757 struct kvm *kvm = gmap->private;
758 struct kvm_vcpu *vcpu;
759
760 kvm_for_each_vcpu(i, vcpu, kvm) {
761 /* match against both prefix pages */
Michael Muellerfda902c2014-05-13 16:58:30 +0200762 if (kvm_s390_get_prefix(vcpu) == (address & ~0x1000UL)) {
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200763 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
764 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
765 exit_sie_sync(vcpu);
766 }
767 }
768}
769
Christoffer Dallb6d33832012-03-08 16:44:24 -0500770int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
771{
772 /* kvm common code refers to this, but never calls it */
773 BUG();
774 return 0;
775}
776
Carsten Otte14eebd92012-05-15 14:15:26 +0200777static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
778 struct kvm_one_reg *reg)
779{
780 int r = -EINVAL;
781
782 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200783 case KVM_REG_S390_TODPR:
784 r = put_user(vcpu->arch.sie_block->todpr,
785 (u32 __user *)reg->addr);
786 break;
787 case KVM_REG_S390_EPOCHDIFF:
788 r = put_user(vcpu->arch.sie_block->epoch,
789 (u64 __user *)reg->addr);
790 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200791 case KVM_REG_S390_CPU_TIMER:
792 r = put_user(vcpu->arch.sie_block->cputm,
793 (u64 __user *)reg->addr);
794 break;
795 case KVM_REG_S390_CLOCK_COMP:
796 r = put_user(vcpu->arch.sie_block->ckc,
797 (u64 __user *)reg->addr);
798 break;
Dominik Dingel536336c2013-09-30 10:55:33 +0200799 case KVM_REG_S390_PFTOKEN:
800 r = put_user(vcpu->arch.pfault_token,
801 (u64 __user *)reg->addr);
802 break;
803 case KVM_REG_S390_PFCOMPARE:
804 r = put_user(vcpu->arch.pfault_compare,
805 (u64 __user *)reg->addr);
806 break;
807 case KVM_REG_S390_PFSELECT:
808 r = put_user(vcpu->arch.pfault_select,
809 (u64 __user *)reg->addr);
810 break;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100811 case KVM_REG_S390_PP:
812 r = put_user(vcpu->arch.sie_block->pp,
813 (u64 __user *)reg->addr);
814 break;
Christian Borntraegerafa45ff2014-02-10 15:39:23 +0100815 case KVM_REG_S390_GBEA:
816 r = put_user(vcpu->arch.sie_block->gbea,
817 (u64 __user *)reg->addr);
818 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200819 default:
820 break;
821 }
822
823 return r;
824}
825
826static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
827 struct kvm_one_reg *reg)
828{
829 int r = -EINVAL;
830
831 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200832 case KVM_REG_S390_TODPR:
833 r = get_user(vcpu->arch.sie_block->todpr,
834 (u32 __user *)reg->addr);
835 break;
836 case KVM_REG_S390_EPOCHDIFF:
837 r = get_user(vcpu->arch.sie_block->epoch,
838 (u64 __user *)reg->addr);
839 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200840 case KVM_REG_S390_CPU_TIMER:
841 r = get_user(vcpu->arch.sie_block->cputm,
842 (u64 __user *)reg->addr);
843 break;
844 case KVM_REG_S390_CLOCK_COMP:
845 r = get_user(vcpu->arch.sie_block->ckc,
846 (u64 __user *)reg->addr);
847 break;
Dominik Dingel536336c2013-09-30 10:55:33 +0200848 case KVM_REG_S390_PFTOKEN:
849 r = get_user(vcpu->arch.pfault_token,
850 (u64 __user *)reg->addr);
851 break;
852 case KVM_REG_S390_PFCOMPARE:
853 r = get_user(vcpu->arch.pfault_compare,
854 (u64 __user *)reg->addr);
855 break;
856 case KVM_REG_S390_PFSELECT:
857 r = get_user(vcpu->arch.pfault_select,
858 (u64 __user *)reg->addr);
859 break;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100860 case KVM_REG_S390_PP:
861 r = get_user(vcpu->arch.sie_block->pp,
862 (u64 __user *)reg->addr);
863 break;
Christian Borntraegerafa45ff2014-02-10 15:39:23 +0100864 case KVM_REG_S390_GBEA:
865 r = get_user(vcpu->arch.sie_block->gbea,
866 (u64 __user *)reg->addr);
867 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200868 default:
869 break;
870 }
871
872 return r;
873}
Christoffer Dallb6d33832012-03-08 16:44:24 -0500874
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100875static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
876{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100877 kvm_s390_vcpu_initial_reset(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100878 return 0;
879}
880
881int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
882{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100883 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100884 return 0;
885}
886
887int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
888{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100889 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100890 return 0;
891}
892
893int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
894 struct kvm_sregs *sregs)
895{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100896 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100897 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
Christian Borntraeger59674c12012-01-11 11:20:33 +0100898 restore_access_regs(vcpu->run->s.regs.acrs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100899 return 0;
900}
901
902int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
903 struct kvm_sregs *sregs)
904{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100905 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100906 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100907 return 0;
908}
909
910int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
911{
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200912 if (test_fp_ctl(fpu->fpc))
913 return -EINVAL;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100914 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200915 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
916 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
917 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100918 return 0;
919}
920
921int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
922{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100923 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
924 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100925 return 0;
926}
927
928static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
929{
930 int rc = 0;
931
David Hildenbrand7a42fdc2014-05-05 16:26:19 +0200932 if (!is_vcpu_stopped(vcpu))
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100933 rc = -EBUSY;
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100934 else {
935 vcpu->run->psw_mask = psw.mask;
936 vcpu->run->psw_addr = psw.addr;
937 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100938 return rc;
939}
940
941int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
942 struct kvm_translation *tr)
943{
944 return -EINVAL; /* not implemented yet */
945}
946
David Hildenbrand27291e22014-01-23 12:26:52 +0100947#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
948 KVM_GUESTDBG_USE_HW_BP | \
949 KVM_GUESTDBG_ENABLE)
950
Jan Kiszkad0bfb942008-12-15 13:52:10 +0100951int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
952 struct kvm_guest_debug *dbg)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100953{
David Hildenbrand27291e22014-01-23 12:26:52 +0100954 int rc = 0;
955
956 vcpu->guest_debug = 0;
957 kvm_s390_clear_bp_data(vcpu);
958
David Hildenbrand2de3bfc2014-05-20 17:25:20 +0200959 if (dbg->control & ~VALID_GUESTDBG_FLAGS)
David Hildenbrand27291e22014-01-23 12:26:52 +0100960 return -EINVAL;
961
962 if (dbg->control & KVM_GUESTDBG_ENABLE) {
963 vcpu->guest_debug = dbg->control;
964 /* enforce guest PER */
965 atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
966
967 if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
968 rc = kvm_s390_import_bp_data(vcpu, dbg);
969 } else {
970 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
971 vcpu->arch.guestdbg.last_bp = 0;
972 }
973
974 if (rc) {
975 vcpu->guest_debug = 0;
976 kvm_s390_clear_bp_data(vcpu);
977 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
978 }
979
980 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100981}
982
Marcelo Tosatti62d9f0d2008-04-11 13:24:45 -0300983int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
984 struct kvm_mp_state *mp_state)
985{
David Hildenbrand6352e4d2014-04-10 17:35:00 +0200986 /* CHECK_STOP and LOAD are not supported yet */
987 return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED :
988 KVM_MP_STATE_OPERATING;
Marcelo Tosatti62d9f0d2008-04-11 13:24:45 -0300989}
990
991int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
992 struct kvm_mp_state *mp_state)
993{
David Hildenbrand6352e4d2014-04-10 17:35:00 +0200994 int rc = 0;
995
996 /* user space knows about this interface - let it control the state */
997 vcpu->kvm->arch.user_cpu_state_ctrl = 1;
998
999 switch (mp_state->mp_state) {
1000 case KVM_MP_STATE_STOPPED:
1001 kvm_s390_vcpu_stop(vcpu);
1002 break;
1003 case KVM_MP_STATE_OPERATING:
1004 kvm_s390_vcpu_start(vcpu);
1005 break;
1006 case KVM_MP_STATE_LOAD:
1007 case KVM_MP_STATE_CHECK_STOP:
1008 /* fall through - CHECK_STOP and LOAD are not supported yet */
1009 default:
1010 rc = -ENXIO;
1011 }
1012
1013 return rc;
Marcelo Tosatti62d9f0d2008-04-11 13:24:45 -03001014}
1015
Dominik Dingelb31605c2014-03-25 13:47:11 +01001016bool kvm_s390_cmma_enabled(struct kvm *kvm)
1017{
1018 if (!MACHINE_IS_LPAR)
1019 return false;
1020 /* only enable for z10 and later */
1021 if (!MACHINE_HAS_EDAT1)
1022 return false;
1023 if (!kvm->arch.use_cmma)
1024 return false;
1025 return true;
1026}
1027
David Hildenbrand8ad35752014-03-14 11:00:21 +01001028static bool ibs_enabled(struct kvm_vcpu *vcpu)
1029{
1030 return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
1031}
1032
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001033static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
1034{
David Hildenbrand8ad35752014-03-14 11:00:21 +01001035retry:
1036 s390_vcpu_unblock(vcpu);
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001037 /*
1038 * We use MMU_RELOAD just to re-arm the ipte notifier for the
1039 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
1040 * This ensures that the ipte instruction for this request has
1041 * already finished. We might race against a second unmapper that
1042 * wants to set the blocking bit. Lets just retry the request loop.
1043 */
David Hildenbrand8ad35752014-03-14 11:00:21 +01001044 if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001045 int rc;
1046 rc = gmap_ipte_notify(vcpu->arch.gmap,
Michael Muellerfda902c2014-05-13 16:58:30 +02001047 kvm_s390_get_prefix(vcpu),
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001048 PAGE_SIZE * 2);
1049 if (rc)
1050 return rc;
David Hildenbrand8ad35752014-03-14 11:00:21 +01001051 goto retry;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001052 }
David Hildenbrand8ad35752014-03-14 11:00:21 +01001053
David Hildenbrandd3d692c2014-07-29 08:53:36 +02001054 if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) {
1055 vcpu->arch.sie_block->ihcpu = 0xffff;
1056 goto retry;
1057 }
1058
David Hildenbrand8ad35752014-03-14 11:00:21 +01001059 if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
1060 if (!ibs_enabled(vcpu)) {
1061 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
1062 atomic_set_mask(CPUSTAT_IBS,
1063 &vcpu->arch.sie_block->cpuflags);
1064 }
1065 goto retry;
1066 }
1067
1068 if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
1069 if (ibs_enabled(vcpu)) {
1070 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
1071 atomic_clear_mask(CPUSTAT_IBS,
1072 &vcpu->arch.sie_block->cpuflags);
1073 }
1074 goto retry;
1075 }
1076
David Hildenbrand0759d062014-05-13 16:54:32 +02001077 /* nothing to do, just clear the request */
1078 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
1079
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001080 return 0;
1081}
1082
Thomas Huthfa576c52014-05-06 17:20:16 +02001083/**
1084 * kvm_arch_fault_in_page - fault-in guest page if necessary
1085 * @vcpu: The corresponding virtual cpu
1086 * @gpa: Guest physical address
1087 * @writable: Whether the page should be writable or not
1088 *
1089 * Make sure that a guest page has been faulted-in on the host.
1090 *
1091 * Return: Zero on success, negative error code otherwise.
1092 */
1093long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001094{
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001095 struct mm_struct *mm = current->mm;
Thomas Huthfa576c52014-05-06 17:20:16 +02001096 hva_t hva;
1097 long rc;
1098
1099 hva = gmap_fault(gpa, vcpu->arch.gmap);
1100 if (IS_ERR_VALUE(hva))
1101 return (long)hva;
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001102 down_read(&mm->mmap_sem);
Thomas Huthfa576c52014-05-06 17:20:16 +02001103 rc = get_user_pages(current, mm, hva, 1, writable, 0, NULL, NULL);
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001104 up_read(&mm->mmap_sem);
Thomas Huthfa576c52014-05-06 17:20:16 +02001105
1106 return rc < 0 ? rc : 0;
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001107}
1108
Dominik Dingel3c038e62013-10-07 17:11:48 +02001109static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
1110 unsigned long token)
1111{
1112 struct kvm_s390_interrupt inti;
1113 inti.parm64 = token;
1114
1115 if (start_token) {
1116 inti.type = KVM_S390_INT_PFAULT_INIT;
1117 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
1118 } else {
1119 inti.type = KVM_S390_INT_PFAULT_DONE;
1120 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
1121 }
1122}
1123
1124void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
1125 struct kvm_async_pf *work)
1126{
1127 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
1128 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
1129}
1130
1131void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
1132 struct kvm_async_pf *work)
1133{
1134 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
1135 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
1136}
1137
1138void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
1139 struct kvm_async_pf *work)
1140{
1141 /* s390 will always inject the page directly */
1142}
1143
1144bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
1145{
1146 /*
1147 * s390 will always inject the page directly,
1148 * but we still want check_async_completion to cleanup
1149 */
1150 return true;
1151}
1152
1153static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
1154{
1155 hva_t hva;
1156 struct kvm_arch_async_pf arch;
1157 int rc;
1158
1159 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1160 return 0;
1161 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
1162 vcpu->arch.pfault_compare)
1163 return 0;
1164 if (psw_extint_disabled(vcpu))
1165 return 0;
1166 if (kvm_cpu_has_interrupt(vcpu))
1167 return 0;
1168 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
1169 return 0;
1170 if (!vcpu->arch.gmap->pfault_enabled)
1171 return 0;
1172
Heiko Carstens81480cc2014-01-01 16:36:07 +01001173 hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
1174 hva += current->thread.gmap_addr & ~PAGE_MASK;
1175 if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
Dominik Dingel3c038e62013-10-07 17:11:48 +02001176 return 0;
1177
1178 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
1179 return rc;
1180}
1181
Thomas Huth3fb4c402013-09-12 10:33:43 +02001182static int vcpu_pre_run(struct kvm_vcpu *vcpu)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001183{
Thomas Huth3fb4c402013-09-12 10:33:43 +02001184 int rc, cpuflags;
Carsten Ottee168bf82012-01-04 10:25:22 +01001185
Dominik Dingel3c038e62013-10-07 17:11:48 +02001186 /*
1187 * On s390 notifications for arriving pages will be delivered directly
1188 * to the guest but the house keeping for completed pfaults is
1189 * handled outside the worker.
1190 */
1191 kvm_check_async_pf_completion(vcpu);
1192
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +01001193 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001194
1195 if (need_resched())
1196 schedule();
1197
Martin Schwidefskyd3a73ac2014-04-15 12:55:07 +02001198 if (test_cpu_flag(CIF_MCCK_PENDING))
Christian Borntraeger71cde582008-05-21 13:37:34 +02001199 s390_handle_mcck();
1200
Jens Freimann79395032014-04-17 10:10:30 +02001201 if (!kvm_is_ucontrol(vcpu->kvm)) {
1202 rc = kvm_s390_deliver_pending_interrupts(vcpu);
1203 if (rc)
1204 return rc;
1205 }
Carsten Otte0ff31862008-05-21 13:37:37 +02001206
Christian Borntraeger2c70fe42013-05-17 14:41:36 +02001207 rc = kvm_s390_handle_requests(vcpu);
1208 if (rc)
1209 return rc;
1210
David Hildenbrand27291e22014-01-23 12:26:52 +01001211 if (guestdbg_enabled(vcpu)) {
1212 kvm_s390_backup_guest_per_regs(vcpu);
1213 kvm_s390_patch_guest_per_regs(vcpu);
1214 }
1215
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001216 vcpu->arch.sie_block->icptcode = 0;
Thomas Huth3fb4c402013-09-12 10:33:43 +02001217 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
1218 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
1219 trace_kvm_s390_sie_enter(vcpu, cpuflags);
Dominik Dingel2b29a9f2013-07-26 15:04:00 +02001220
Thomas Huth3fb4c402013-09-12 10:33:43 +02001221 return 0;
1222}
1223
1224static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
1225{
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001226 int rc = -1;
Dominik Dingel2b29a9f2013-07-26 15:04:00 +02001227
1228 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
1229 vcpu->arch.sie_block->icptcode);
1230 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
1231
David Hildenbrand27291e22014-01-23 12:26:52 +01001232 if (guestdbg_enabled(vcpu))
1233 kvm_s390_restore_guest_per_regs(vcpu);
1234
Thomas Huth3fb4c402013-09-12 10:33:43 +02001235 if (exit_reason >= 0) {
Martin Schwidefsky7c470532013-05-17 14:41:37 +02001236 rc = 0;
Thomas Huth210b16072013-09-19 16:26:18 +02001237 } else if (kvm_is_ucontrol(vcpu->kvm)) {
1238 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
1239 vcpu->run->s390_ucontrol.trans_exc_code =
1240 current->thread.gmap_addr;
1241 vcpu->run->s390_ucontrol.pgm_code = 0x10;
1242 rc = -EREMOTE;
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001243
1244 } else if (current->thread.gmap_pfault) {
Dominik Dingel3c038e62013-10-07 17:11:48 +02001245 trace_kvm_s390_major_guest_pfault(vcpu);
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001246 current->thread.gmap_pfault = 0;
Thomas Huthfa576c52014-05-06 17:20:16 +02001247 if (kvm_arch_setup_async_pf(vcpu)) {
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001248 rc = 0;
Thomas Huthfa576c52014-05-06 17:20:16 +02001249 } else {
1250 gpa_t gpa = current->thread.gmap_addr;
1251 rc = kvm_arch_fault_in_page(vcpu, gpa, 1);
1252 }
Dominik Dingel24eb3a82013-06-17 16:25:18 +02001253 }
1254
1255 if (rc == -1) {
Christian Borntraeger699bde32014-01-20 12:34:13 +01001256 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1257 trace_kvm_s390_sie_fault(vcpu);
1258 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
Carsten Otte1f0d0f02008-05-21 13:37:40 +02001259 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001260
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +01001261 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001262
Thomas Hutha76ccff2013-09-12 10:33:44 +02001263 if (rc == 0) {
1264 if (kvm_is_ucontrol(vcpu->kvm))
Christian Borntraeger2955c832014-03-06 16:01:38 +01001265 /* Don't exit for host interrupts. */
1266 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
Thomas Hutha76ccff2013-09-12 10:33:44 +02001267 else
1268 rc = kvm_handle_sie_intercept(vcpu);
1269 }
1270
Thomas Huth3fb4c402013-09-12 10:33:43 +02001271 return rc;
1272}
1273
1274static int __vcpu_run(struct kvm_vcpu *vcpu)
1275{
1276 int rc, exit_reason;
1277
Thomas Huth800c1062013-09-12 10:33:45 +02001278 /*
1279 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1280 * ning the guest), so that memslots (and other stuff) are protected
1281 */
1282 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1283
Thomas Hutha76ccff2013-09-12 10:33:44 +02001284 do {
1285 rc = vcpu_pre_run(vcpu);
1286 if (rc)
1287 break;
Thomas Huth3fb4c402013-09-12 10:33:43 +02001288
Thomas Huth800c1062013-09-12 10:33:45 +02001289 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
Thomas Hutha76ccff2013-09-12 10:33:44 +02001290 /*
1291 * As PF_VCPU will be used in fault handler, between
1292 * guest_enter and guest_exit should be no uaccess.
1293 */
1294 preempt_disable();
1295 kvm_guest_enter();
1296 preempt_enable();
1297 exit_reason = sie64a(vcpu->arch.sie_block,
1298 vcpu->run->s.regs.gprs);
1299 kvm_guest_exit();
Thomas Huth800c1062013-09-12 10:33:45 +02001300 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001301
Thomas Hutha76ccff2013-09-12 10:33:44 +02001302 rc = vcpu_post_run(vcpu, exit_reason);
David Hildenbrand27291e22014-01-23 12:26:52 +01001303 } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001304
Thomas Huth800c1062013-09-12 10:33:45 +02001305 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
Carsten Ottee168bf82012-01-04 10:25:22 +01001306 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001307}
1308
David Hildenbrandb028ee32014-07-17 10:47:43 +02001309static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1310{
1311 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1312 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
1313 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX)
1314 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1315 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1316 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
David Hildenbrandd3d692c2014-07-29 08:53:36 +02001317 /* some control register changes require a tlb flush */
1318 kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
David Hildenbrandb028ee32014-07-17 10:47:43 +02001319 }
1320 if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) {
1321 vcpu->arch.sie_block->cputm = kvm_run->s.regs.cputm;
1322 vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc;
1323 vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr;
1324 vcpu->arch.sie_block->pp = kvm_run->s.regs.pp;
1325 vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea;
1326 }
1327 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) {
1328 vcpu->arch.pfault_token = kvm_run->s.regs.pft;
1329 vcpu->arch.pfault_select = kvm_run->s.regs.pfs;
1330 vcpu->arch.pfault_compare = kvm_run->s.regs.pfc;
1331 }
1332 kvm_run->kvm_dirty_regs = 0;
1333}
1334
1335static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1336{
1337 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1338 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
1339 kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu);
1340 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
1341 kvm_run->s.regs.cputm = vcpu->arch.sie_block->cputm;
1342 kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc;
1343 kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr;
1344 kvm_run->s.regs.pp = vcpu->arch.sie_block->pp;
1345 kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea;
1346 kvm_run->s.regs.pft = vcpu->arch.pfault_token;
1347 kvm_run->s.regs.pfs = vcpu->arch.pfault_select;
1348 kvm_run->s.regs.pfc = vcpu->arch.pfault_compare;
1349}
1350
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001351int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1352{
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001353 int rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001354 sigset_t sigsaved;
1355
David Hildenbrand27291e22014-01-23 12:26:52 +01001356 if (guestdbg_exit_pending(vcpu)) {
1357 kvm_s390_prepare_debug_exit(vcpu);
1358 return 0;
1359 }
1360
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001361 if (vcpu->sigset_active)
1362 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1363
David Hildenbrand6352e4d2014-04-10 17:35:00 +02001364 if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) {
1365 kvm_s390_vcpu_start(vcpu);
1366 } else if (is_vcpu_stopped(vcpu)) {
1367 pr_err_ratelimited("kvm-s390: can't run stopped vcpu %d\n",
1368 vcpu->vcpu_id);
1369 return -EINVAL;
1370 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001371
David Hildenbrandb028ee32014-07-17 10:47:43 +02001372 sync_regs(vcpu, kvm_run);
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001373
Heiko Carstensdab4079d2009-06-12 10:26:32 +02001374 might_fault();
Thomas Hutha76ccff2013-09-12 10:33:44 +02001375 rc = __vcpu_run(vcpu);
Christian Ehrhardt9ace9032009-05-20 15:34:55 +02001376
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +02001377 if (signal_pending(current) && !rc) {
1378 kvm_run->exit_reason = KVM_EXIT_INTR;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001379 rc = -EINTR;
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +02001380 }
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001381
David Hildenbrand27291e22014-01-23 12:26:52 +01001382 if (guestdbg_exit_pending(vcpu) && !rc) {
1383 kvm_s390_prepare_debug_exit(vcpu);
1384 rc = 0;
1385 }
1386
Heiko Carstensb8e660b2010-02-26 22:37:41 +01001387 if (rc == -EOPNOTSUPP) {
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001388 /* intercept cannot be handled in-kernel, prepare kvm-run */
1389 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1390 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001391 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1392 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1393 rc = 0;
1394 }
1395
1396 if (rc == -EREMOTE) {
1397 /* intercept was handled, but userspace support is needed
1398 * kvm_run has been prepared by the handler */
1399 rc = 0;
1400 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001401
David Hildenbrandb028ee32014-07-17 10:47:43 +02001402 store_regs(vcpu, kvm_run);
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001403
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001404 if (vcpu->sigset_active)
1405 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1406
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001407 vcpu->stat.exit_userspace++;
Heiko Carstens7e8e6ab2008-04-04 15:12:35 +02001408 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001409}
1410
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001411/*
1412 * store status at address
1413 * we use have two special cases:
1414 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1415 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1416 */
Heiko Carstensd0bce602014-01-01 16:45:58 +01001417int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001418{
Carsten Otte092670c2011-07-24 10:48:22 +02001419 unsigned char archmode = 1;
Michael Muellerfda902c2014-05-13 16:58:30 +02001420 unsigned int px;
Thomas Huth178bd782013-11-13 20:28:18 +01001421 u64 clkcomp;
Heiko Carstensd0bce602014-01-01 16:45:58 +01001422 int rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001423
Heiko Carstensd0bce602014-01-01 16:45:58 +01001424 if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
1425 if (write_guest_abs(vcpu, 163, &archmode, 1))
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001426 return -EFAULT;
Heiko Carstensd0bce602014-01-01 16:45:58 +01001427 gpa = SAVE_AREA_BASE;
1428 } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
1429 if (write_guest_real(vcpu, 163, &archmode, 1))
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001430 return -EFAULT;
Heiko Carstensd0bce602014-01-01 16:45:58 +01001431 gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE);
1432 }
1433 rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs),
1434 vcpu->arch.guest_fpregs.fprs, 128);
1435 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs),
1436 vcpu->run->s.regs.gprs, 128);
1437 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw),
1438 &vcpu->arch.sie_block->gpsw, 16);
Michael Muellerfda902c2014-05-13 16:58:30 +02001439 px = kvm_s390_get_prefix(vcpu);
Heiko Carstensd0bce602014-01-01 16:45:58 +01001440 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg),
Michael Muellerfda902c2014-05-13 16:58:30 +02001441 &px, 4);
Heiko Carstensd0bce602014-01-01 16:45:58 +01001442 rc |= write_guest_abs(vcpu,
1443 gpa + offsetof(struct save_area, fp_ctrl_reg),
1444 &vcpu->arch.guest_fpregs.fpc, 4);
1445 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg),
1446 &vcpu->arch.sie_block->todpr, 4);
1447 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer),
1448 &vcpu->arch.sie_block->cputm, 8);
Thomas Huth178bd782013-11-13 20:28:18 +01001449 clkcomp = vcpu->arch.sie_block->ckc >> 8;
Heiko Carstensd0bce602014-01-01 16:45:58 +01001450 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp),
1451 &clkcomp, 8);
1452 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs),
1453 &vcpu->run->s.regs.acrs, 64);
1454 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs),
1455 &vcpu->arch.sie_block->gcr, 128);
1456 return rc ? -EFAULT : 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001457}
1458
Thomas Huthe8798922013-11-06 15:46:33 +01001459int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1460{
1461 /*
1462 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1463 * copying in vcpu load/put. Lets update our copies before we save
1464 * it into the save area
1465 */
1466 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1467 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1468 save_access_regs(vcpu->run->s.regs.acrs);
1469
1470 return kvm_s390_store_status_unloaded(vcpu, addr);
1471}
1472
David Hildenbrand8ad35752014-03-14 11:00:21 +01001473static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1474{
1475 kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
1476 kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu);
1477 exit_sie_sync(vcpu);
1478}
1479
1480static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
1481{
1482 unsigned int i;
1483 struct kvm_vcpu *vcpu;
1484
1485 kvm_for_each_vcpu(i, vcpu, kvm) {
1486 __disable_ibs_on_vcpu(vcpu);
1487 }
1488}
1489
1490static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1491{
1492 kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
1493 kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu);
1494 exit_sie_sync(vcpu);
1495}
1496
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001497void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
1498{
David Hildenbrand8ad35752014-03-14 11:00:21 +01001499 int i, online_vcpus, started_vcpus = 0;
1500
1501 if (!is_vcpu_stopped(vcpu))
1502 return;
1503
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001504 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001505 /* Only one cpu at a time may enter/leave the STOPPED state. */
David Hildenbrand433b9ee2014-05-06 16:11:14 +02001506 spin_lock(&vcpu->kvm->arch.start_stop_lock);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001507 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1508
1509 for (i = 0; i < online_vcpus; i++) {
1510 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
1511 started_vcpus++;
1512 }
1513
1514 if (started_vcpus == 0) {
1515 /* we're the only active VCPU -> speed it up */
1516 __enable_ibs_on_vcpu(vcpu);
1517 } else if (started_vcpus == 1) {
1518 /*
1519 * As we are starting a second VCPU, we have to disable
1520 * the IBS facility on all VCPUs to remove potentially
1521 * oustanding ENABLE requests.
1522 */
1523 __disable_ibs_on_all_vcpus(vcpu->kvm);
1524 }
1525
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001526 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001527 /*
1528 * Another VCPU might have used IBS while we were offline.
1529 * Let's play safe and flush the VCPU at startup.
1530 */
David Hildenbrandd3d692c2014-07-29 08:53:36 +02001531 kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
David Hildenbrand433b9ee2014-05-06 16:11:14 +02001532 spin_unlock(&vcpu->kvm->arch.start_stop_lock);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001533 return;
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001534}
1535
1536void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
1537{
David Hildenbrand8ad35752014-03-14 11:00:21 +01001538 int i, online_vcpus, started_vcpus = 0;
1539 struct kvm_vcpu *started_vcpu = NULL;
1540
1541 if (is_vcpu_stopped(vcpu))
1542 return;
1543
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001544 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001545 /* Only one cpu at a time may enter/leave the STOPPED state. */
David Hildenbrand433b9ee2014-05-06 16:11:14 +02001546 spin_lock(&vcpu->kvm->arch.start_stop_lock);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001547 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1548
David Hildenbrand32f5ff632014-04-14 12:40:03 +02001549 /* Need to lock access to action_bits to avoid a SIGP race condition */
David Hildenbrand4ae3c082014-05-16 10:23:53 +02001550 spin_lock(&vcpu->arch.local_int.lock);
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001551 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
David Hildenbrand32f5ff632014-04-14 12:40:03 +02001552
1553 /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
1554 vcpu->arch.local_int.action_bits &=
1555 ~(ACTION_STOP_ON_STOP | ACTION_STORE_ON_STOP);
David Hildenbrand4ae3c082014-05-16 10:23:53 +02001556 spin_unlock(&vcpu->arch.local_int.lock);
David Hildenbrand32f5ff632014-04-14 12:40:03 +02001557
David Hildenbrand8ad35752014-03-14 11:00:21 +01001558 __disable_ibs_on_vcpu(vcpu);
1559
1560 for (i = 0; i < online_vcpus; i++) {
1561 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
1562 started_vcpus++;
1563 started_vcpu = vcpu->kvm->vcpus[i];
1564 }
1565 }
1566
1567 if (started_vcpus == 1) {
1568 /*
1569 * As we only have one VCPU left, we want to enable the
1570 * IBS facility for that VCPU to speed it up.
1571 */
1572 __enable_ibs_on_vcpu(started_vcpu);
1573 }
1574
David Hildenbrand433b9ee2014-05-06 16:11:14 +02001575 spin_unlock(&vcpu->kvm->arch.start_stop_lock);
David Hildenbrand8ad35752014-03-14 11:00:21 +01001576 return;
David Hildenbrand6852d7b2014-03-14 10:59:29 +01001577}
1578
Cornelia Huckd6712df2012-12-20 15:32:11 +01001579static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1580 struct kvm_enable_cap *cap)
1581{
1582 int r;
1583
1584 if (cap->flags)
1585 return -EINVAL;
1586
1587 switch (cap->cap) {
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +01001588 case KVM_CAP_S390_CSS_SUPPORT:
1589 if (!vcpu->kvm->arch.css_support) {
1590 vcpu->kvm->arch.css_support = 1;
1591 trace_kvm_s390_enable_css(vcpu->kvm);
1592 }
1593 r = 0;
1594 break;
Cornelia Huckd6712df2012-12-20 15:32:11 +01001595 default:
1596 r = -EINVAL;
1597 break;
1598 }
1599 return r;
1600}
1601
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001602long kvm_arch_vcpu_ioctl(struct file *filp,
1603 unsigned int ioctl, unsigned long arg)
1604{
1605 struct kvm_vcpu *vcpu = filp->private_data;
1606 void __user *argp = (void __user *)arg;
Thomas Huth800c1062013-09-12 10:33:45 +02001607 int idx;
Avi Kivitybc923cc2010-05-13 12:21:46 +03001608 long r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001609
Avi Kivity93736622010-05-13 12:35:17 +03001610 switch (ioctl) {
1611 case KVM_S390_INTERRUPT: {
Carsten Otteba5c1e92008-03-25 18:47:26 +01001612 struct kvm_s390_interrupt s390int;
1613
Avi Kivity93736622010-05-13 12:35:17 +03001614 r = -EFAULT;
Carsten Otteba5c1e92008-03-25 18:47:26 +01001615 if (copy_from_user(&s390int, argp, sizeof(s390int)))
Avi Kivity93736622010-05-13 12:35:17 +03001616 break;
1617 r = kvm_s390_inject_vcpu(vcpu, &s390int);
1618 break;
Carsten Otteba5c1e92008-03-25 18:47:26 +01001619 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001620 case KVM_S390_STORE_STATUS:
Thomas Huth800c1062013-09-12 10:33:45 +02001621 idx = srcu_read_lock(&vcpu->kvm->srcu);
Avi Kivitybc923cc2010-05-13 12:21:46 +03001622 r = kvm_s390_vcpu_store_status(vcpu, arg);
Thomas Huth800c1062013-09-12 10:33:45 +02001623 srcu_read_unlock(&vcpu->kvm->srcu, idx);
Avi Kivitybc923cc2010-05-13 12:21:46 +03001624 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001625 case KVM_S390_SET_INITIAL_PSW: {
1626 psw_t psw;
1627
Avi Kivitybc923cc2010-05-13 12:21:46 +03001628 r = -EFAULT;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001629 if (copy_from_user(&psw, argp, sizeof(psw)))
Avi Kivitybc923cc2010-05-13 12:21:46 +03001630 break;
1631 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
1632 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001633 }
1634 case KVM_S390_INITIAL_RESET:
Avi Kivitybc923cc2010-05-13 12:21:46 +03001635 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
1636 break;
Carsten Otte14eebd92012-05-15 14:15:26 +02001637 case KVM_SET_ONE_REG:
1638 case KVM_GET_ONE_REG: {
1639 struct kvm_one_reg reg;
1640 r = -EFAULT;
1641 if (copy_from_user(&reg, argp, sizeof(reg)))
1642 break;
1643 if (ioctl == KVM_SET_ONE_REG)
1644 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
1645 else
1646 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
1647 break;
1648 }
Carsten Otte27e03932012-01-04 10:25:21 +01001649#ifdef CONFIG_KVM_S390_UCONTROL
1650 case KVM_S390_UCAS_MAP: {
1651 struct kvm_s390_ucas_mapping ucasmap;
1652
1653 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1654 r = -EFAULT;
1655 break;
1656 }
1657
1658 if (!kvm_is_ucontrol(vcpu->kvm)) {
1659 r = -EINVAL;
1660 break;
1661 }
1662
1663 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
1664 ucasmap.vcpu_addr, ucasmap.length);
1665 break;
1666 }
1667 case KVM_S390_UCAS_UNMAP: {
1668 struct kvm_s390_ucas_mapping ucasmap;
1669
1670 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1671 r = -EFAULT;
1672 break;
1673 }
1674
1675 if (!kvm_is_ucontrol(vcpu->kvm)) {
1676 r = -EINVAL;
1677 break;
1678 }
1679
1680 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1681 ucasmap.length);
1682 break;
1683 }
1684#endif
Carsten Otteccc79102012-01-04 10:25:26 +01001685 case KVM_S390_VCPU_FAULT: {
1686 r = gmap_fault(arg, vcpu->arch.gmap);
1687 if (!IS_ERR_VALUE(r))
1688 r = 0;
1689 break;
1690 }
Cornelia Huckd6712df2012-12-20 15:32:11 +01001691 case KVM_ENABLE_CAP:
1692 {
1693 struct kvm_enable_cap cap;
1694 r = -EFAULT;
1695 if (copy_from_user(&cap, argp, sizeof(cap)))
1696 break;
1697 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1698 break;
1699 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001700 default:
Carsten Otte3e6afcf2012-01-04 10:25:30 +01001701 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001702 }
Avi Kivitybc923cc2010-05-13 12:21:46 +03001703 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001704}
1705
Carsten Otte5b1c1492012-01-04 10:25:23 +01001706int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1707{
1708#ifdef CONFIG_KVM_S390_UCONTROL
1709 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1710 && (kvm_is_ucontrol(vcpu->kvm))) {
1711 vmf->page = virt_to_page(vcpu->arch.sie_block);
1712 get_page(vmf->page);
1713 return 0;
1714 }
1715#endif
1716 return VM_FAULT_SIGBUS;
1717}
1718
Aneesh Kumar K.V55870272013-10-07 22:18:00 +05301719void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +09001720 struct kvm_memory_slot *dont)
1721{
1722}
1723
Aneesh Kumar K.V55870272013-10-07 22:18:00 +05301724int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
1725 unsigned long npages)
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +09001726{
1727 return 0;
1728}
1729
Takuya Yoshikawae59dbe02013-07-04 13:40:29 +09001730void kvm_arch_memslots_updated(struct kvm *kvm)
1731{
1732}
1733
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001734/* Section: memory related */
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001735int kvm_arch_prepare_memory_region(struct kvm *kvm,
1736 struct kvm_memory_slot *memslot,
Takuya Yoshikawa7b6195a2013-02-27 19:44:34 +09001737 struct kvm_userspace_memory_region *mem,
1738 enum kvm_mr_change change)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001739{
Nick Wangdd2887e2013-03-25 17:22:57 +01001740 /* A few sanity checks. We can have memory slots which have to be
1741 located/ended at a segment boundary (1MB). The memory in userland is
1742 ok to be fragmented into various different vmas. It is okay to mmap()
1743 and munmap() stuff in this slot after doing this call at any time */
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001744
Carsten Otte598841c2011-07-24 10:48:21 +02001745 if (mem->userspace_addr & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001746 return -EINVAL;
1747
Carsten Otte598841c2011-07-24 10:48:21 +02001748 if (mem->memory_size & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001749 return -EINVAL;
1750
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001751 return 0;
1752}
1753
1754void kvm_arch_commit_memory_region(struct kvm *kvm,
1755 struct kvm_userspace_memory_region *mem,
Takuya Yoshikawa84826442013-02-27 19:45:25 +09001756 const struct kvm_memory_slot *old,
1757 enum kvm_mr_change change)
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001758{
Carsten Ottef7850c92011-07-24 10:48:23 +02001759 int rc;
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001760
Christian Borntraeger2cef4de2013-03-25 17:22:48 +01001761 /* If the basics of the memslot do not change, we do not want
1762 * to update the gmap. Every update causes several unnecessary
1763 * segment translation exceptions. This is usually handled just
1764 * fine by the normal fault handler + gmap, but it will also
1765 * cause faults on the prefix page of running guest CPUs.
1766 */
1767 if (old->userspace_addr == mem->userspace_addr &&
1768 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1769 old->npages * PAGE_SIZE == mem->memory_size)
1770 return;
Carsten Otte598841c2011-07-24 10:48:21 +02001771
1772 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1773 mem->guest_phys_addr, mem->memory_size);
1774 if (rc)
Carsten Ottef7850c92011-07-24 10:48:23 +02001775 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
Carsten Otte598841c2011-07-24 10:48:21 +02001776 return;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001777}
1778
Marcelo Tosatti2df72e92012-08-24 15:54:57 -03001779void kvm_arch_flush_shadow_all(struct kvm *kvm)
1780{
1781}
1782
1783void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1784 struct kvm_memory_slot *slot)
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -03001785{
1786}
1787
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001788static int __init kvm_s390_init(void)
1789{
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001790 int ret;
Avi Kivity0ee75be2010-04-28 15:39:01 +03001791 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001792 if (ret)
1793 return ret;
1794
1795 /*
1796 * guests can ask for up to 255+1 double words, we need a full page
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001797 * to hold the maximum amount of facilities. On the other hand, we
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001798 * only set facilities that are known to work in KVM.
1799 */
Michael Mueller78c4b592013-07-26 15:04:04 +02001800 vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1801 if (!vfacilities) {
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001802 kvm_exit();
1803 return -ENOMEM;
1804 }
Michael Mueller78c4b592013-07-26 15:04:04 +02001805 memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
Thomas Huthd208c792013-12-12 13:40:40 +01001806 vfacilities[0] &= 0xff82fff3f4fc2000UL;
Michael Mueller7feb6bb2013-06-28 13:30:24 +02001807 vfacilities[1] &= 0x005c000000000000UL;
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001808 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001809}
1810
1811static void __exit kvm_s390_exit(void)
1812{
Michael Mueller78c4b592013-07-26 15:04:04 +02001813 free_page((unsigned long) vfacilities);
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001814 kvm_exit();
1815}
1816
1817module_init(kvm_s390_init);
1818module_exit(kvm_s390_exit);
Cornelia Huck566af942013-05-27 18:42:33 +02001819
1820/*
1821 * Enable autoloading of the kvm module.
1822 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1823 * since x86 takes a different approach.
1824 */
1825#include <linux/miscdevice.h>
1826MODULE_ALIAS_MISCDEV(KVM_MINOR);
1827MODULE_ALIAS("devname:kvm");