blob: 346a3478dd00cf6554765b0ee69b3e2870c00167 [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) },
55 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
Christian Ehrhardt7697e712011-10-18 12:27:15 +020056 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010057 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
58 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
59 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
60 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
61 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
62 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
63 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +020064 { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010065 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
66 { "instruction_spx", VCPU_STAT(instruction_spx) },
67 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
68 { "instruction_stap", VCPU_STAT(instruction_stap) },
69 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
70 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
71 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
Konstantin Weitzb31288f2013-04-17 17:36:29 +020072 { "instruction_essa", VCPU_STAT(instruction_essa) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010073 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
74 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
Christian Borntraegerbb25b9b2011-07-24 10:48:17 +020075 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010076 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
Cornelia Huckbd59d3a2011-11-17 11:00:42 +010077 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
Christian Ehrhardt7697e712011-10-18 12:27:15 +020078 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010079 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
80 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
81 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
82 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
83 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
Christian Borntraeger388186b2011-10-30 15:17:03 +010084 { "diagnose_10", VCPU_STAT(diagnose_10) },
Christian Borntraegere28acfe2008-03-25 18:47:34 +010085 { "diagnose_44", VCPU_STAT(diagnose_44) },
Konstantin Weitz41628d32012-04-25 15:30:38 +020086 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
Heiko Carstensb0c632d2008-03-25 18:47:20 +010087 { NULL }
88};
89
Michael Mueller78c4b592013-07-26 15:04:04 +020090unsigned long *vfacilities;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +020091static struct gmap_notifier gmap_notifier;
Heiko Carstensb0c632d2008-03-25 18:47:20 +010092
Michael Mueller78c4b592013-07-26 15:04:04 +020093/* test availability of vfacility */
94static inline int test_vfacility(unsigned long nr)
95{
96 return __test_facility(nr, (void *) vfacilities);
97}
98
Heiko Carstensb0c632d2008-03-25 18:47:20 +010099/* Section: not file related */
Alexander Graf10474ae2009-09-15 11:37:46 +0200100int kvm_arch_hardware_enable(void *garbage)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100101{
102 /* every s390 is virtualization enabled ;-) */
Alexander Graf10474ae2009-09-15 11:37:46 +0200103 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100104}
105
106void kvm_arch_hardware_disable(void *garbage)
107{
108}
109
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200110static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
111
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100112int kvm_arch_hardware_setup(void)
113{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200114 gmap_notifier.notifier_call = kvm_gmap_notifier;
115 gmap_register_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100116 return 0;
117}
118
119void kvm_arch_hardware_unsetup(void)
120{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200121 gmap_unregister_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100122}
123
124void kvm_arch_check_processor_compat(void *rtn)
125{
126}
127
128int kvm_arch_init(void *opaque)
129{
130 return 0;
131}
132
133void kvm_arch_exit(void)
134{
135}
136
137/* Section: device related */
138long kvm_arch_dev_ioctl(struct file *filp,
139 unsigned int ioctl, unsigned long arg)
140{
141 if (ioctl == KVM_S390_ENABLE_SIE)
142 return s390_enable_sie();
143 return -EINVAL;
144}
145
146int kvm_dev_ioctl_check_extension(long ext)
147{
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100148 int r;
149
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200150 switch (ext) {
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100151 case KVM_CAP_S390_PSW:
Christian Borntraegerb6cf8782011-09-20 17:07:29 +0200152 case KVM_CAP_S390_GMAP:
Christian Borntraeger52e16b12011-11-17 11:00:44 +0100153 case KVM_CAP_SYNC_MMU:
Carsten Otte1efd0f52012-01-04 10:25:29 +0100154#ifdef CONFIG_KVM_S390_UCONTROL
155 case KVM_CAP_S390_UCONTROL:
156#endif
Dominik Dingel3c038e62013-10-07 17:11:48 +0200157 case KVM_CAP_ASYNC_PF:
Christian Borntraeger60b413c2012-01-11 11:20:31 +0100158 case KVM_CAP_SYNC_REGS:
Carsten Otte14eebd92012-05-15 14:15:26 +0200159 case KVM_CAP_ONE_REG:
Cornelia Huckd6712df2012-12-20 15:32:11 +0100160 case KVM_CAP_ENABLE_CAP:
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100161 case KVM_CAP_S390_CSS_SUPPORT:
Cornelia Huck10ccaa12013-02-28 12:33:21 +0100162 case KVM_CAP_IOEVENTFD:
Jens Freimannc05c4182013-10-07 16:13:45 +0200163 case KVM_CAP_DEVICE_CTRL:
Cornelia Huckd938dc52013-10-23 18:26:34 +0200164 case KVM_CAP_ENABLE_CAP_VM:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100165 r = 1;
166 break;
Christian Borntraegere726b1b2012-05-02 10:50:38 +0200167 case KVM_CAP_NR_VCPUS:
168 case KVM_CAP_MAX_VCPUS:
169 r = KVM_MAX_VCPUS;
170 break;
Nick Wange1e2e602013-03-25 17:22:58 +0100171 case KVM_CAP_NR_MEMSLOTS:
172 r = KVM_USER_MEM_SLOTS;
173 break;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200174 case KVM_CAP_S390_COW:
Martin Schwidefskyabf09be2012-11-07 13:17:37 +0100175 r = MACHINE_HAS_ESOP;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200176 break;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200177 default:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100178 r = 0;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200179 }
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100180 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100181}
182
Jason J. Herne15f36eb2012-08-02 10:10:17 -0400183static void kvm_s390_sync_dirty_log(struct kvm *kvm,
184 struct kvm_memory_slot *memslot)
185{
186 gfn_t cur_gfn, last_gfn;
187 unsigned long address;
188 struct gmap *gmap = kvm->arch.gmap;
189
190 down_read(&gmap->mm->mmap_sem);
191 /* Loop over all guest pages */
192 last_gfn = memslot->base_gfn + memslot->npages;
193 for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
194 address = gfn_to_hva_memslot(memslot, cur_gfn);
195
196 if (gmap_test_and_clear_dirty(address, gmap))
197 mark_page_dirty(kvm, cur_gfn);
198 }
199 up_read(&gmap->mm->mmap_sem);
200}
201
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100202/* Section: vm related */
203/*
204 * Get (and clear) the dirty memory log for a memory slot.
205 */
206int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
207 struct kvm_dirty_log *log)
208{
Jason J. Herne15f36eb2012-08-02 10:10:17 -0400209 int r;
210 unsigned long n;
211 struct kvm_memory_slot *memslot;
212 int is_dirty = 0;
213
214 mutex_lock(&kvm->slots_lock);
215
216 r = -EINVAL;
217 if (log->slot >= KVM_USER_MEM_SLOTS)
218 goto out;
219
220 memslot = id_to_memslot(kvm->memslots, log->slot);
221 r = -ENOENT;
222 if (!memslot->dirty_bitmap)
223 goto out;
224
225 kvm_s390_sync_dirty_log(kvm, memslot);
226 r = kvm_get_dirty_log(kvm, log, &is_dirty);
227 if (r)
228 goto out;
229
230 /* Clear the dirty log */
231 if (is_dirty) {
232 n = kvm_dirty_bitmap_bytes(memslot);
233 memset(memslot->dirty_bitmap, 0, n);
234 }
235 r = 0;
236out:
237 mutex_unlock(&kvm->slots_lock);
238 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100239}
240
Cornelia Huckd938dc52013-10-23 18:26:34 +0200241static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
242{
243 int r;
244
245 if (cap->flags)
246 return -EINVAL;
247
248 switch (cap->cap) {
Cornelia Huck84223592013-07-15 13:36:01 +0200249 case KVM_CAP_S390_IRQCHIP:
250 kvm->arch.use_irqchip = 1;
251 r = 0;
252 break;
Cornelia Huckd938dc52013-10-23 18:26:34 +0200253 default:
254 r = -EINVAL;
255 break;
256 }
257 return r;
258}
259
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100260long kvm_arch_vm_ioctl(struct file *filp,
261 unsigned int ioctl, unsigned long arg)
262{
263 struct kvm *kvm = filp->private_data;
264 void __user *argp = (void __user *)arg;
265 int r;
266
267 switch (ioctl) {
Carsten Otteba5c1e92008-03-25 18:47:26 +0100268 case KVM_S390_INTERRUPT: {
269 struct kvm_s390_interrupt s390int;
270
271 r = -EFAULT;
272 if (copy_from_user(&s390int, argp, sizeof(s390int)))
273 break;
274 r = kvm_s390_inject_vm(kvm, &s390int);
275 break;
276 }
Cornelia Huckd938dc52013-10-23 18:26:34 +0200277 case KVM_ENABLE_CAP: {
278 struct kvm_enable_cap cap;
279 r = -EFAULT;
280 if (copy_from_user(&cap, argp, sizeof(cap)))
281 break;
282 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
283 break;
284 }
Cornelia Huck84223592013-07-15 13:36:01 +0200285 case KVM_CREATE_IRQCHIP: {
286 struct kvm_irq_routing_entry routing;
287
288 r = -EINVAL;
289 if (kvm->arch.use_irqchip) {
290 /* Set up dummy routing. */
291 memset(&routing, 0, sizeof(routing));
292 kvm_set_irq_routing(kvm, &routing, 0, 0);
293 r = 0;
294 }
295 break;
296 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100297 default:
Avi Kivity367e1312009-08-26 14:57:07 +0300298 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100299 }
300
301 return r;
302}
303
Carsten Ottee08b9632012-01-04 10:25:20 +0100304int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100305{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100306 int rc;
307 char debug_name[16];
Christian Borntraegerf6c137f2014-03-19 11:18:29 +0100308 static unsigned long sca_offset;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100309
Carsten Ottee08b9632012-01-04 10:25:20 +0100310 rc = -EINVAL;
311#ifdef CONFIG_KVM_S390_UCONTROL
312 if (type & ~KVM_VM_S390_UCONTROL)
313 goto out_err;
314 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
315 goto out_err;
316#else
317 if (type)
318 goto out_err;
319#endif
320
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100321 rc = s390_enable_sie();
322 if (rc)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100323 goto out_err;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100324
Carsten Otteb2904112011-10-18 12:27:13 +0200325 rc = -ENOMEM;
326
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100327 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
328 if (!kvm->arch.sca)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100329 goto out_err;
Christian Borntraegerf6c137f2014-03-19 11:18:29 +0100330 spin_lock(&kvm_lock);
331 sca_offset = (sca_offset + 16) & 0x7f0;
332 kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset);
333 spin_unlock(&kvm_lock);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100334
335 sprintf(debug_name, "kvm-%u", current->pid);
336
337 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
338 if (!kvm->arch.dbf)
339 goto out_nodbf;
340
Carsten Otteba5c1e92008-03-25 18:47:26 +0100341 spin_lock_init(&kvm->arch.float_int.lock);
342 INIT_LIST_HEAD(&kvm->arch.float_int.list);
343
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100344 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
345 VM_EVENT(kvm, 3, "%s", "vm created");
346
Carsten Ottee08b9632012-01-04 10:25:20 +0100347 if (type & KVM_VM_S390_UCONTROL) {
348 kvm->arch.gmap = NULL;
349 } else {
350 kvm->arch.gmap = gmap_alloc(current->mm);
351 if (!kvm->arch.gmap)
352 goto out_nogmap;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200353 kvm->arch.gmap->private = kvm;
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200354 kvm->arch.gmap->pfault_enabled = 0;
Carsten Ottee08b9632012-01-04 10:25:20 +0100355 }
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100356
357 kvm->arch.css_support = 0;
Cornelia Huck84223592013-07-15 13:36:01 +0200358 kvm->arch.use_irqchip = 0;
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100359
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100360 return 0;
Carsten Otte598841c2011-07-24 10:48:21 +0200361out_nogmap:
362 debug_unregister(kvm->arch.dbf);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100363out_nodbf:
364 free_page((unsigned long)(kvm->arch.sca));
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100365out_err:
366 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100367}
368
Christian Borntraegerd329c032008-11-26 14:50:27 +0100369void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
370{
371 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
Cornelia Huckade38c32012-07-23 17:20:30 +0200372 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
Dominik Dingel3c038e62013-10-07 17:11:48 +0200373 kvm_clear_async_pf_completion_queue(vcpu);
Carsten Otte58f94602012-01-04 10:25:27 +0100374 if (!kvm_is_ucontrol(vcpu->kvm)) {
375 clear_bit(63 - vcpu->vcpu_id,
376 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
377 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
378 (__u64) vcpu->arch.sie_block)
379 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
380 }
Carsten Otteabf4a712009-05-12 17:21:51 +0200381 smp_mb();
Carsten Otte27e03932012-01-04 10:25:21 +0100382
383 if (kvm_is_ucontrol(vcpu->kvm))
384 gmap_free(vcpu->arch.gmap);
385
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200386 if (vcpu->arch.sie_block->cbrlo)
387 __free_page(__pfn_to_page(
388 vcpu->arch.sie_block->cbrlo >> PAGE_SHIFT));
Christian Borntraegerd329c032008-11-26 14:50:27 +0100389 free_page((unsigned long)(vcpu->arch.sie_block));
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200390
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100391 kvm_vcpu_uninit(vcpu);
Michael Muellerb110fea2013-06-12 13:54:54 +0200392 kmem_cache_free(kvm_vcpu_cache, vcpu);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100393}
394
395static void kvm_free_vcpus(struct kvm *kvm)
396{
397 unsigned int i;
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300398 struct kvm_vcpu *vcpu;
Christian Borntraegerd329c032008-11-26 14:50:27 +0100399
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300400 kvm_for_each_vcpu(i, vcpu, kvm)
401 kvm_arch_vcpu_destroy(vcpu);
402
403 mutex_lock(&kvm->lock);
404 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
405 kvm->vcpus[i] = NULL;
406
407 atomic_set(&kvm->online_vcpus, 0);
408 mutex_unlock(&kvm->lock);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100409}
410
Sheng Yangad8ba2c2009-01-06 10:03:02 +0800411void kvm_arch_sync_events(struct kvm *kvm)
412{
413}
414
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100415void kvm_arch_destroy_vm(struct kvm *kvm)
416{
Christian Borntraegerd329c032008-11-26 14:50:27 +0100417 kvm_free_vcpus(kvm);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100418 free_page((unsigned long)(kvm->arch.sca));
Christian Borntraegerd329c032008-11-26 14:50:27 +0100419 debug_unregister(kvm->arch.dbf);
Carsten Otte27e03932012-01-04 10:25:21 +0100420 if (!kvm_is_ucontrol(kvm))
421 gmap_free(kvm->arch.gmap);
Cornelia Huck841b91c2013-07-15 13:36:01 +0200422 kvm_s390_destroy_adapters(kvm);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100423}
424
425/* Section: vcpu related */
426int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
427{
Dominik Dingel3c038e62013-10-07 17:11:48 +0200428 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
429 kvm_clear_async_pf_completion_queue(vcpu);
Carsten Otte27e03932012-01-04 10:25:21 +0100430 if (kvm_is_ucontrol(vcpu->kvm)) {
431 vcpu->arch.gmap = gmap_alloc(current->mm);
432 if (!vcpu->arch.gmap)
433 return -ENOMEM;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200434 vcpu->arch.gmap->private = vcpu->kvm;
Carsten Otte27e03932012-01-04 10:25:21 +0100435 return 0;
436 }
437
Carsten Otte598841c2011-07-24 10:48:21 +0200438 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
Christian Borntraeger59674c12012-01-11 11:20:33 +0100439 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
440 KVM_SYNC_GPRS |
Christian Borntraeger9eed07352012-02-06 10:59:07 +0100441 KVM_SYNC_ACRS |
442 KVM_SYNC_CRS;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100443 return 0;
444}
445
446void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
447{
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100448 /* Nothing todo */
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100449}
450
451void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
452{
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200453 save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
454 save_fp_regs(vcpu->arch.host_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100455 save_access_regs(vcpu->arch.host_acrs);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200456 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
457 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100458 restore_access_regs(vcpu->run->s.regs.acrs);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200459 gmap_enable(vcpu->arch.gmap);
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100460 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100461}
462
463void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
464{
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100465 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200466 gmap_disable(vcpu->arch.gmap);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200467 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
468 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100469 save_access_regs(vcpu->run->s.regs.acrs);
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200470 restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
471 restore_fp_regs(vcpu->arch.host_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100472 restore_access_regs(vcpu->arch.host_acrs);
473}
474
475static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
476{
477 /* this equals initial cpu reset in pop, but we don't switch to ESA */
478 vcpu->arch.sie_block->gpsw.mask = 0UL;
479 vcpu->arch.sie_block->gpsw.addr = 0UL;
Christian Borntraeger8d26cf72012-01-11 11:19:32 +0100480 kvm_s390_set_prefix(vcpu, 0);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100481 vcpu->arch.sie_block->cputm = 0UL;
482 vcpu->arch.sie_block->ckc = 0UL;
483 vcpu->arch.sie_block->todpr = 0;
484 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
485 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
486 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
487 vcpu->arch.guest_fpregs.fpc = 0;
488 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
489 vcpu->arch.sie_block->gbea = 1;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100490 vcpu->arch.sie_block->pp = 0;
Dominik Dingel3c038e62013-10-07 17:11:48 +0200491 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
492 kvm_clear_async_pf_completion_queue(vcpu);
Christian Borntraeger61bde822012-06-11 16:06:57 +0200493 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
Jens Freimann2ed10cc2014-02-11 13:48:07 +0100494 kvm_s390_clear_local_irqs(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100495}
496
Marcelo Tosatti42897d82012-11-27 23:29:02 -0200497int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
498{
499 return 0;
500}
501
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100502int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
503{
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200504 struct page *cbrl;
505
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100506 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
507 CPUSTAT_SM |
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +0200508 CPUSTAT_STOPPED |
509 CPUSTAT_GED);
Christian Borntraegerfc345312010-06-17 23:16:20 +0200510 vcpu->arch.sie_block->ecb = 6;
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200511 if (test_vfacility(50) && test_vfacility(73))
512 vcpu->arch.sie_block->ecb |= 0x10;
513
Christian Borntraeger69d0d3a2013-06-12 13:54:53 +0200514 vcpu->arch.sie_block->ecb2 = 8;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100515 vcpu->arch.sie_block->eca = 0xC1002001U;
Michael Mueller78c4b592013-07-26 15:04:04 +0200516 vcpu->arch.sie_block->fac = (int) (long) vfacilities;
Dominik Dingel693ffc02014-01-14 18:11:14 +0100517 vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
Konstantin Weitzb31288f2013-04-17 17:36:29 +0200518 if (kvm_enabled_cmma()) {
519 cbrl = alloc_page(GFP_KERNEL | __GFP_ZERO);
520 if (cbrl) {
521 vcpu->arch.sie_block->ecb2 |= 0x80;
522 vcpu->arch.sie_block->ecb2 &= ~0x08;
523 vcpu->arch.sie_block->cbrlo = page_to_phys(cbrl);
524 }
525 }
Christian Borntraegerca872302009-05-12 17:21:49 +0200526 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
527 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
528 (unsigned long) vcpu);
529 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
Christian Borntraeger453423d2008-03-25 18:47:29 +0100530 get_cpu_id(&vcpu->arch.cpu_id);
Christian Borntraeger92e6ecf2009-03-26 15:23:58 +0100531 vcpu->arch.cpu_id.version = 0xff;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100532 return 0;
533}
534
535struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
536 unsigned int id)
537{
Carsten Otte4d475552011-10-18 12:27:12 +0200538 struct kvm_vcpu *vcpu;
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200539 struct sie_page *sie_page;
Carsten Otte4d475552011-10-18 12:27:12 +0200540 int rc = -EINVAL;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100541
Carsten Otte4d475552011-10-18 12:27:12 +0200542 if (id >= KVM_MAX_VCPUS)
543 goto out;
544
545 rc = -ENOMEM;
546
Michael Muellerb110fea2013-06-12 13:54:54 +0200547 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100548 if (!vcpu)
Carsten Otte4d475552011-10-18 12:27:12 +0200549 goto out;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100550
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200551 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
552 if (!sie_page)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100553 goto out_free_cpu;
554
Michael Mueller7feb6bb2013-06-28 13:30:24 +0200555 vcpu->arch.sie_block = &sie_page->sie_block;
556 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
557
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100558 vcpu->arch.sie_block->icpua = id;
Carsten Otte58f94602012-01-04 10:25:27 +0100559 if (!kvm_is_ucontrol(kvm)) {
560 if (!kvm->arch.sca) {
561 WARN_ON_ONCE(1);
562 goto out_free_cpu;
563 }
564 if (!kvm->arch.sca->cpu[id].sda)
565 kvm->arch.sca->cpu[id].sda =
566 (__u64) vcpu->arch.sie_block;
567 vcpu->arch.sie_block->scaoh =
568 (__u32)(((__u64)kvm->arch.sca) >> 32);
569 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
570 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
571 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100572
Carsten Otteba5c1e92008-03-25 18:47:26 +0100573 spin_lock_init(&vcpu->arch.local_int.lock);
574 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
575 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
Christian Borntraegerd0321a22013-06-12 13:54:55 +0200576 vcpu->arch.local_int.wq = &vcpu->wq;
Christian Borntraeger5288fbf2008-03-25 18:47:31 +0100577 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
Carsten Otteba5c1e92008-03-25 18:47:26 +0100578
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100579 rc = kvm_vcpu_init(vcpu, kvm, id);
580 if (rc)
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800581 goto out_free_sie_block;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100582 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
583 vcpu->arch.sie_block);
Cornelia Huckade38c32012-07-23 17:20:30 +0200584 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100585
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100586 return vcpu;
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800587out_free_sie_block:
588 free_page((unsigned long)(vcpu->arch.sie_block));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100589out_free_cpu:
Michael Muellerb110fea2013-06-12 13:54:54 +0200590 kmem_cache_free(kvm_vcpu_cache, vcpu);
Carsten Otte4d475552011-10-18 12:27:12 +0200591out:
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100592 return ERR_PTR(rc);
593}
594
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100595int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
596{
Michael Muellerf87618e2014-02-26 16:14:17 +0100597 return kvm_cpu_has_interrupt(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100598}
599
Christian Borntraeger49b99e12013-05-17 14:41:35 +0200600void s390_vcpu_block(struct kvm_vcpu *vcpu)
601{
602 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
603}
604
605void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
606{
607 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
608}
609
610/*
611 * Kick a guest cpu out of SIE and wait until SIE is not running.
612 * If the CPU is not running (e.g. waiting as idle) the function will
613 * return immediately. */
614void exit_sie(struct kvm_vcpu *vcpu)
615{
616 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
617 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
618 cpu_relax();
619}
620
621/* Kick a guest cpu out of SIE and prevent SIE-reentry */
622void exit_sie_sync(struct kvm_vcpu *vcpu)
623{
624 s390_vcpu_block(vcpu);
625 exit_sie(vcpu);
626}
627
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200628static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
629{
630 int i;
631 struct kvm *kvm = gmap->private;
632 struct kvm_vcpu *vcpu;
633
634 kvm_for_each_vcpu(i, vcpu, kvm) {
635 /* match against both prefix pages */
636 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
637 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
638 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
639 exit_sie_sync(vcpu);
640 }
641 }
642}
643
Christoffer Dallb6d33832012-03-08 16:44:24 -0500644int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
645{
646 /* kvm common code refers to this, but never calls it */
647 BUG();
648 return 0;
649}
650
Carsten Otte14eebd92012-05-15 14:15:26 +0200651static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
652 struct kvm_one_reg *reg)
653{
654 int r = -EINVAL;
655
656 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200657 case KVM_REG_S390_TODPR:
658 r = put_user(vcpu->arch.sie_block->todpr,
659 (u32 __user *)reg->addr);
660 break;
661 case KVM_REG_S390_EPOCHDIFF:
662 r = put_user(vcpu->arch.sie_block->epoch,
663 (u64 __user *)reg->addr);
664 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200665 case KVM_REG_S390_CPU_TIMER:
666 r = put_user(vcpu->arch.sie_block->cputm,
667 (u64 __user *)reg->addr);
668 break;
669 case KVM_REG_S390_CLOCK_COMP:
670 r = put_user(vcpu->arch.sie_block->ckc,
671 (u64 __user *)reg->addr);
672 break;
Dominik Dingel536336c2013-09-30 10:55:33 +0200673 case KVM_REG_S390_PFTOKEN:
674 r = put_user(vcpu->arch.pfault_token,
675 (u64 __user *)reg->addr);
676 break;
677 case KVM_REG_S390_PFCOMPARE:
678 r = put_user(vcpu->arch.pfault_compare,
679 (u64 __user *)reg->addr);
680 break;
681 case KVM_REG_S390_PFSELECT:
682 r = put_user(vcpu->arch.pfault_select,
683 (u64 __user *)reg->addr);
684 break;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100685 case KVM_REG_S390_PP:
686 r = put_user(vcpu->arch.sie_block->pp,
687 (u64 __user *)reg->addr);
688 break;
Christian Borntraegerafa45ff2014-02-10 15:39:23 +0100689 case KVM_REG_S390_GBEA:
690 r = put_user(vcpu->arch.sie_block->gbea,
691 (u64 __user *)reg->addr);
692 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200693 default:
694 break;
695 }
696
697 return r;
698}
699
700static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
701 struct kvm_one_reg *reg)
702{
703 int r = -EINVAL;
704
705 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200706 case KVM_REG_S390_TODPR:
707 r = get_user(vcpu->arch.sie_block->todpr,
708 (u32 __user *)reg->addr);
709 break;
710 case KVM_REG_S390_EPOCHDIFF:
711 r = get_user(vcpu->arch.sie_block->epoch,
712 (u64 __user *)reg->addr);
713 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200714 case KVM_REG_S390_CPU_TIMER:
715 r = get_user(vcpu->arch.sie_block->cputm,
716 (u64 __user *)reg->addr);
717 break;
718 case KVM_REG_S390_CLOCK_COMP:
719 r = get_user(vcpu->arch.sie_block->ckc,
720 (u64 __user *)reg->addr);
721 break;
Dominik Dingel536336c2013-09-30 10:55:33 +0200722 case KVM_REG_S390_PFTOKEN:
723 r = get_user(vcpu->arch.pfault_token,
724 (u64 __user *)reg->addr);
725 break;
726 case KVM_REG_S390_PFCOMPARE:
727 r = get_user(vcpu->arch.pfault_compare,
728 (u64 __user *)reg->addr);
729 break;
730 case KVM_REG_S390_PFSELECT:
731 r = get_user(vcpu->arch.pfault_select,
732 (u64 __user *)reg->addr);
733 break;
Christian Borntraeger672550f2014-02-10 15:32:19 +0100734 case KVM_REG_S390_PP:
735 r = get_user(vcpu->arch.sie_block->pp,
736 (u64 __user *)reg->addr);
737 break;
Christian Borntraegerafa45ff2014-02-10 15:39:23 +0100738 case KVM_REG_S390_GBEA:
739 r = get_user(vcpu->arch.sie_block->gbea,
740 (u64 __user *)reg->addr);
741 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200742 default:
743 break;
744 }
745
746 return r;
747}
Christoffer Dallb6d33832012-03-08 16:44:24 -0500748
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100749static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
750{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100751 kvm_s390_vcpu_initial_reset(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100752 return 0;
753}
754
755int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
756{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100757 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100758 return 0;
759}
760
761int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
762{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100763 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100764 return 0;
765}
766
767int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
768 struct kvm_sregs *sregs)
769{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100770 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100771 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
Christian Borntraeger59674c12012-01-11 11:20:33 +0100772 restore_access_regs(vcpu->run->s.regs.acrs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100773 return 0;
774}
775
776int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
777 struct kvm_sregs *sregs)
778{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100779 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100780 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100781 return 0;
782}
783
784int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
785{
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200786 if (test_fp_ctl(fpu->fpc))
787 return -EINVAL;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100788 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
Martin Schwidefsky4725c862013-10-15 16:08:34 +0200789 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
790 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
791 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100792 return 0;
793}
794
795int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
796{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100797 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
798 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100799 return 0;
800}
801
802static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
803{
804 int rc = 0;
805
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100806 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100807 rc = -EBUSY;
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100808 else {
809 vcpu->run->psw_mask = psw.mask;
810 vcpu->run->psw_addr = psw.addr;
811 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100812 return rc;
813}
814
815int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
816 struct kvm_translation *tr)
817{
818 return -EINVAL; /* not implemented yet */
819}
820
Jan Kiszkad0bfb942008-12-15 13:52:10 +0100821int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
822 struct kvm_guest_debug *dbg)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100823{
824 return -EINVAL; /* not implemented yet */
825}
826
Marcelo Tosatti62d9f0d2008-04-11 13:24:45 -0300827int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
828 struct kvm_mp_state *mp_state)
829{
830 return -EINVAL; /* not implemented yet */
831}
832
833int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
834 struct kvm_mp_state *mp_state)
835{
836 return -EINVAL; /* not implemented yet */
837}
838
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200839static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
840{
841 /*
842 * We use MMU_RELOAD just to re-arm the ipte notifier for the
843 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
844 * This ensures that the ipte instruction for this request has
845 * already finished. We might race against a second unmapper that
846 * wants to set the blocking bit. Lets just retry the request loop.
847 */
848 while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
849 int rc;
850 rc = gmap_ipte_notify(vcpu->arch.gmap,
851 vcpu->arch.sie_block->prefix,
852 PAGE_SIZE * 2);
853 if (rc)
854 return rc;
855 s390_vcpu_unblock(vcpu);
856 }
857 return 0;
858}
859
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200860static long kvm_arch_fault_in_sync(struct kvm_vcpu *vcpu)
861{
862 long rc;
863 hva_t fault = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
864 struct mm_struct *mm = current->mm;
865 down_read(&mm->mmap_sem);
866 rc = get_user_pages(current, mm, fault, 1, 1, 0, NULL, NULL);
867 up_read(&mm->mmap_sem);
868 return rc;
869}
870
Dominik Dingel3c038e62013-10-07 17:11:48 +0200871static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
872 unsigned long token)
873{
874 struct kvm_s390_interrupt inti;
875 inti.parm64 = token;
876
877 if (start_token) {
878 inti.type = KVM_S390_INT_PFAULT_INIT;
879 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
880 } else {
881 inti.type = KVM_S390_INT_PFAULT_DONE;
882 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
883 }
884}
885
886void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
887 struct kvm_async_pf *work)
888{
889 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
890 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
891}
892
893void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
894 struct kvm_async_pf *work)
895{
896 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
897 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
898}
899
900void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
901 struct kvm_async_pf *work)
902{
903 /* s390 will always inject the page directly */
904}
905
906bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
907{
908 /*
909 * s390 will always inject the page directly,
910 * but we still want check_async_completion to cleanup
911 */
912 return true;
913}
914
915static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
916{
917 hva_t hva;
918 struct kvm_arch_async_pf arch;
919 int rc;
920
921 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
922 return 0;
923 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
924 vcpu->arch.pfault_compare)
925 return 0;
926 if (psw_extint_disabled(vcpu))
927 return 0;
928 if (kvm_cpu_has_interrupt(vcpu))
929 return 0;
930 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
931 return 0;
932 if (!vcpu->arch.gmap->pfault_enabled)
933 return 0;
934
935 hva = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
936 if (copy_from_guest(vcpu, &arch.pfault_token, vcpu->arch.pfault_token, 8))
937 return 0;
938
939 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
940 return rc;
941}
942
Thomas Huth3fb4c402013-09-12 10:33:43 +0200943static int vcpu_pre_run(struct kvm_vcpu *vcpu)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100944{
Thomas Huth3fb4c402013-09-12 10:33:43 +0200945 int rc, cpuflags;
Carsten Ottee168bf82012-01-04 10:25:22 +0100946
Dominik Dingel3c038e62013-10-07 17:11:48 +0200947 /*
948 * On s390 notifications for arriving pages will be delivered directly
949 * to the guest but the house keeping for completed pfaults is
950 * handled outside the worker.
951 */
952 kvm_check_async_pf_completion(vcpu);
953
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100954 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100955
956 if (need_resched())
957 schedule();
958
Christian Borntraeger71cde582008-05-21 13:37:34 +0200959 if (test_thread_flag(TIF_MCCK_PENDING))
960 s390_handle_mcck();
961
Carsten Otted6b6d162012-01-04 10:25:25 +0100962 if (!kvm_is_ucontrol(vcpu->kvm))
963 kvm_s390_deliver_pending_interrupts(vcpu);
Carsten Otte0ff31862008-05-21 13:37:37 +0200964
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200965 rc = kvm_s390_handle_requests(vcpu);
966 if (rc)
967 return rc;
968
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100969 vcpu->arch.sie_block->icptcode = 0;
Thomas Huth3fb4c402013-09-12 10:33:43 +0200970 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
971 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
972 trace_kvm_s390_sie_enter(vcpu, cpuflags);
Dominik Dingel2b29a9f2013-07-26 15:04:00 +0200973
Thomas Huth3fb4c402013-09-12 10:33:43 +0200974 return 0;
975}
976
977static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
978{
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200979 int rc = -1;
Dominik Dingel2b29a9f2013-07-26 15:04:00 +0200980
981 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
982 vcpu->arch.sie_block->icptcode);
983 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
984
Thomas Huth3fb4c402013-09-12 10:33:43 +0200985 if (exit_reason >= 0) {
Martin Schwidefsky7c470532013-05-17 14:41:37 +0200986 rc = 0;
Thomas Huth210b16072013-09-19 16:26:18 +0200987 } else if (kvm_is_ucontrol(vcpu->kvm)) {
988 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
989 vcpu->run->s390_ucontrol.trans_exc_code =
990 current->thread.gmap_addr;
991 vcpu->run->s390_ucontrol.pgm_code = 0x10;
992 rc = -EREMOTE;
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200993
994 } else if (current->thread.gmap_pfault) {
Dominik Dingel3c038e62013-10-07 17:11:48 +0200995 trace_kvm_s390_major_guest_pfault(vcpu);
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200996 current->thread.gmap_pfault = 0;
Dominik Dingel3c038e62013-10-07 17:11:48 +0200997 if (kvm_arch_setup_async_pf(vcpu) ||
998 (kvm_arch_fault_in_sync(vcpu) >= 0))
Dominik Dingel24eb3a82013-06-17 16:25:18 +0200999 rc = 0;
1000 }
1001
1002 if (rc == -1) {
Christian Borntraeger699bde32014-01-20 12:34:13 +01001003 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1004 trace_kvm_s390_sie_fault(vcpu);
1005 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
Carsten Otte1f0d0f02008-05-21 13:37:40 +02001006 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001007
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +01001008 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001009
Thomas Hutha76ccff2013-09-12 10:33:44 +02001010 if (rc == 0) {
1011 if (kvm_is_ucontrol(vcpu->kvm))
Christian Borntraeger2955c832014-03-06 16:01:38 +01001012 /* Don't exit for host interrupts. */
1013 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
Thomas Hutha76ccff2013-09-12 10:33:44 +02001014 else
1015 rc = kvm_handle_sie_intercept(vcpu);
1016 }
1017
Thomas Huth3fb4c402013-09-12 10:33:43 +02001018 return rc;
1019}
1020
Konstantin Weitzb31288f2013-04-17 17:36:29 +02001021bool kvm_enabled_cmma(void)
1022{
1023 if (!MACHINE_IS_LPAR)
1024 return false;
1025 /* only enable for z10 and later */
1026 if (!MACHINE_HAS_EDAT1)
1027 return false;
1028 return true;
1029}
1030
Thomas Huth3fb4c402013-09-12 10:33:43 +02001031static int __vcpu_run(struct kvm_vcpu *vcpu)
1032{
1033 int rc, exit_reason;
1034
Thomas Huth800c1062013-09-12 10:33:45 +02001035 /*
1036 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1037 * ning the guest), so that memslots (and other stuff) are protected
1038 */
1039 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1040
Thomas Hutha76ccff2013-09-12 10:33:44 +02001041 do {
1042 rc = vcpu_pre_run(vcpu);
1043 if (rc)
1044 break;
Thomas Huth3fb4c402013-09-12 10:33:43 +02001045
Thomas Huth800c1062013-09-12 10:33:45 +02001046 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
Thomas Hutha76ccff2013-09-12 10:33:44 +02001047 /*
1048 * As PF_VCPU will be used in fault handler, between
1049 * guest_enter and guest_exit should be no uaccess.
1050 */
1051 preempt_disable();
1052 kvm_guest_enter();
1053 preempt_enable();
1054 exit_reason = sie64a(vcpu->arch.sie_block,
1055 vcpu->run->s.regs.gprs);
1056 kvm_guest_exit();
Thomas Huth800c1062013-09-12 10:33:45 +02001057 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001058
Thomas Hutha76ccff2013-09-12 10:33:44 +02001059 rc = vcpu_post_run(vcpu, exit_reason);
1060 } while (!signal_pending(current) && !rc);
Thomas Huth3fb4c402013-09-12 10:33:43 +02001061
Thomas Huth800c1062013-09-12 10:33:45 +02001062 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
Carsten Ottee168bf82012-01-04 10:25:22 +01001063 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001064}
1065
1066int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1067{
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001068 int rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001069 sigset_t sigsaved;
1070
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001071 if (vcpu->sigset_active)
1072 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1073
Cornelia Huck9e6dabe2011-11-17 11:00:41 +01001074 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001075
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001076 switch (kvm_run->exit_reason) {
1077 case KVM_EXIT_S390_SIEIC:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001078 case KVM_EXIT_UNKNOWN:
Christian Ehrhardt9ace9032009-05-20 15:34:55 +02001079 case KVM_EXIT_INTR:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001080 case KVM_EXIT_S390_RESET:
Carsten Ottee168bf82012-01-04 10:25:22 +01001081 case KVM_EXIT_S390_UCONTROL:
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +01001082 case KVM_EXIT_S390_TSCH:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001083 break;
1084 default:
1085 BUG();
1086 }
1087
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001088 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1089 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
Christian Borntraeger60b413c2012-01-11 11:20:31 +01001090 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
1091 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
1092 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1093 }
Christian Borntraeger9eed07352012-02-06 10:59:07 +01001094 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1095 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
1096 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
1097 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1098 }
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001099
Heiko Carstensdab4079d2009-06-12 10:26:32 +02001100 might_fault();
Thomas Hutha76ccff2013-09-12 10:33:44 +02001101 rc = __vcpu_run(vcpu);
Christian Ehrhardt9ace9032009-05-20 15:34:55 +02001102
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +02001103 if (signal_pending(current) && !rc) {
1104 kvm_run->exit_reason = KVM_EXIT_INTR;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001105 rc = -EINTR;
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +02001106 }
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001107
Heiko Carstensb8e660b2010-02-26 22:37:41 +01001108 if (rc == -EOPNOTSUPP) {
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001109 /* intercept cannot be handled in-kernel, prepare kvm-run */
1110 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1111 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +01001112 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1113 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1114 rc = 0;
1115 }
1116
1117 if (rc == -EREMOTE) {
1118 /* intercept was handled, but userspace support is needed
1119 * kvm_run has been prepared by the handler */
1120 rc = 0;
1121 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001122
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001123 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1124 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
Christian Borntraeger60b413c2012-01-11 11:20:31 +01001125 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
Christian Borntraeger9eed07352012-02-06 10:59:07 +01001126 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
Carsten Otted7b0b5e2009-11-19 14:21:16 +01001127
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001128 if (vcpu->sigset_active)
1129 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1130
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001131 vcpu->stat.exit_userspace++;
Heiko Carstens7e8e6ab2008-04-04 15:12:35 +02001132 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001133}
1134
Carsten Otte092670c2011-07-24 10:48:22 +02001135static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001136 unsigned long n, int prefix)
1137{
1138 if (prefix)
1139 return copy_to_guest(vcpu, guestdest, from, n);
1140 else
1141 return copy_to_guest_absolute(vcpu, guestdest, from, n);
1142}
1143
1144/*
1145 * store status at address
1146 * we use have two special cases:
1147 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1148 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1149 */
Thomas Huthe8798922013-11-06 15:46:33 +01001150int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001151{
Carsten Otte092670c2011-07-24 10:48:22 +02001152 unsigned char archmode = 1;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001153 int prefix;
Thomas Huth178bd782013-11-13 20:28:18 +01001154 u64 clkcomp;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001155
1156 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
1157 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
1158 return -EFAULT;
1159 addr = SAVE_AREA_BASE;
1160 prefix = 0;
1161 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
1162 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
1163 return -EFAULT;
1164 addr = SAVE_AREA_BASE;
1165 prefix = 1;
1166 } else
1167 prefix = 0;
1168
Heiko Carstensf64ca212010-02-26 22:37:32 +01001169 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001170 vcpu->arch.guest_fpregs.fprs, 128, prefix))
1171 return -EFAULT;
1172
Heiko Carstensf64ca212010-02-26 22:37:32 +01001173 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +01001174 vcpu->run->s.regs.gprs, 128, prefix))
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001175 return -EFAULT;
1176
Heiko Carstensf64ca212010-02-26 22:37:32 +01001177 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001178 &vcpu->arch.sie_block->gpsw, 16, prefix))
1179 return -EFAULT;
1180
Heiko Carstensf64ca212010-02-26 22:37:32 +01001181 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001182 &vcpu->arch.sie_block->prefix, 4, prefix))
1183 return -EFAULT;
1184
1185 if (__guestcopy(vcpu,
Heiko Carstensf64ca212010-02-26 22:37:32 +01001186 addr + offsetof(struct save_area, fp_ctrl_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001187 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
1188 return -EFAULT;
1189
Heiko Carstensf64ca212010-02-26 22:37:32 +01001190 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001191 &vcpu->arch.sie_block->todpr, 4, prefix))
1192 return -EFAULT;
1193
Heiko Carstensf64ca212010-02-26 22:37:32 +01001194 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001195 &vcpu->arch.sie_block->cputm, 8, prefix))
1196 return -EFAULT;
1197
Thomas Huth178bd782013-11-13 20:28:18 +01001198 clkcomp = vcpu->arch.sie_block->ckc >> 8;
Heiko Carstensf64ca212010-02-26 22:37:32 +01001199 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
Thomas Huth178bd782013-11-13 20:28:18 +01001200 &clkcomp, 8, prefix))
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001201 return -EFAULT;
1202
Heiko Carstensf64ca212010-02-26 22:37:32 +01001203 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
Christian Borntraeger59674c12012-01-11 11:20:33 +01001204 &vcpu->run->s.regs.acrs, 64, prefix))
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001205 return -EFAULT;
1206
1207 if (__guestcopy(vcpu,
Heiko Carstensf64ca212010-02-26 22:37:32 +01001208 addr + offsetof(struct save_area, ctrl_regs),
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001209 &vcpu->arch.sie_block->gcr, 128, prefix))
1210 return -EFAULT;
1211 return 0;
1212}
1213
Thomas Huthe8798922013-11-06 15:46:33 +01001214int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1215{
1216 /*
1217 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1218 * copying in vcpu load/put. Lets update our copies before we save
1219 * it into the save area
1220 */
1221 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1222 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1223 save_access_regs(vcpu->run->s.regs.acrs);
1224
1225 return kvm_s390_store_status_unloaded(vcpu, addr);
1226}
1227
Cornelia Huckd6712df2012-12-20 15:32:11 +01001228static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1229 struct kvm_enable_cap *cap)
1230{
1231 int r;
1232
1233 if (cap->flags)
1234 return -EINVAL;
1235
1236 switch (cap->cap) {
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +01001237 case KVM_CAP_S390_CSS_SUPPORT:
1238 if (!vcpu->kvm->arch.css_support) {
1239 vcpu->kvm->arch.css_support = 1;
1240 trace_kvm_s390_enable_css(vcpu->kvm);
1241 }
1242 r = 0;
1243 break;
Cornelia Huckd6712df2012-12-20 15:32:11 +01001244 default:
1245 r = -EINVAL;
1246 break;
1247 }
1248 return r;
1249}
1250
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001251long kvm_arch_vcpu_ioctl(struct file *filp,
1252 unsigned int ioctl, unsigned long arg)
1253{
1254 struct kvm_vcpu *vcpu = filp->private_data;
1255 void __user *argp = (void __user *)arg;
Thomas Huth800c1062013-09-12 10:33:45 +02001256 int idx;
Avi Kivitybc923cc2010-05-13 12:21:46 +03001257 long r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001258
Avi Kivity93736622010-05-13 12:35:17 +03001259 switch (ioctl) {
1260 case KVM_S390_INTERRUPT: {
Carsten Otteba5c1e92008-03-25 18:47:26 +01001261 struct kvm_s390_interrupt s390int;
1262
Avi Kivity93736622010-05-13 12:35:17 +03001263 r = -EFAULT;
Carsten Otteba5c1e92008-03-25 18:47:26 +01001264 if (copy_from_user(&s390int, argp, sizeof(s390int)))
Avi Kivity93736622010-05-13 12:35:17 +03001265 break;
1266 r = kvm_s390_inject_vcpu(vcpu, &s390int);
1267 break;
Carsten Otteba5c1e92008-03-25 18:47:26 +01001268 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001269 case KVM_S390_STORE_STATUS:
Thomas Huth800c1062013-09-12 10:33:45 +02001270 idx = srcu_read_lock(&vcpu->kvm->srcu);
Avi Kivitybc923cc2010-05-13 12:21:46 +03001271 r = kvm_s390_vcpu_store_status(vcpu, arg);
Thomas Huth800c1062013-09-12 10:33:45 +02001272 srcu_read_unlock(&vcpu->kvm->srcu, idx);
Avi Kivitybc923cc2010-05-13 12:21:46 +03001273 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001274 case KVM_S390_SET_INITIAL_PSW: {
1275 psw_t psw;
1276
Avi Kivitybc923cc2010-05-13 12:21:46 +03001277 r = -EFAULT;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001278 if (copy_from_user(&psw, argp, sizeof(psw)))
Avi Kivitybc923cc2010-05-13 12:21:46 +03001279 break;
1280 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
1281 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001282 }
1283 case KVM_S390_INITIAL_RESET:
Avi Kivitybc923cc2010-05-13 12:21:46 +03001284 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
1285 break;
Carsten Otte14eebd92012-05-15 14:15:26 +02001286 case KVM_SET_ONE_REG:
1287 case KVM_GET_ONE_REG: {
1288 struct kvm_one_reg reg;
1289 r = -EFAULT;
1290 if (copy_from_user(&reg, argp, sizeof(reg)))
1291 break;
1292 if (ioctl == KVM_SET_ONE_REG)
1293 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
1294 else
1295 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
1296 break;
1297 }
Carsten Otte27e03932012-01-04 10:25:21 +01001298#ifdef CONFIG_KVM_S390_UCONTROL
1299 case KVM_S390_UCAS_MAP: {
1300 struct kvm_s390_ucas_mapping ucasmap;
1301
1302 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1303 r = -EFAULT;
1304 break;
1305 }
1306
1307 if (!kvm_is_ucontrol(vcpu->kvm)) {
1308 r = -EINVAL;
1309 break;
1310 }
1311
1312 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
1313 ucasmap.vcpu_addr, ucasmap.length);
1314 break;
1315 }
1316 case KVM_S390_UCAS_UNMAP: {
1317 struct kvm_s390_ucas_mapping ucasmap;
1318
1319 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1320 r = -EFAULT;
1321 break;
1322 }
1323
1324 if (!kvm_is_ucontrol(vcpu->kvm)) {
1325 r = -EINVAL;
1326 break;
1327 }
1328
1329 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1330 ucasmap.length);
1331 break;
1332 }
1333#endif
Carsten Otteccc79102012-01-04 10:25:26 +01001334 case KVM_S390_VCPU_FAULT: {
1335 r = gmap_fault(arg, vcpu->arch.gmap);
1336 if (!IS_ERR_VALUE(r))
1337 r = 0;
1338 break;
1339 }
Cornelia Huckd6712df2012-12-20 15:32:11 +01001340 case KVM_ENABLE_CAP:
1341 {
1342 struct kvm_enable_cap cap;
1343 r = -EFAULT;
1344 if (copy_from_user(&cap, argp, sizeof(cap)))
1345 break;
1346 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1347 break;
1348 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001349 default:
Carsten Otte3e6afcf2012-01-04 10:25:30 +01001350 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001351 }
Avi Kivitybc923cc2010-05-13 12:21:46 +03001352 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001353}
1354
Carsten Otte5b1c1492012-01-04 10:25:23 +01001355int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1356{
1357#ifdef CONFIG_KVM_S390_UCONTROL
1358 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1359 && (kvm_is_ucontrol(vcpu->kvm))) {
1360 vmf->page = virt_to_page(vcpu->arch.sie_block);
1361 get_page(vmf->page);
1362 return 0;
1363 }
1364#endif
1365 return VM_FAULT_SIGBUS;
1366}
1367
Aneesh Kumar K.V55870272013-10-07 22:18:00 +05301368void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +09001369 struct kvm_memory_slot *dont)
1370{
1371}
1372
Aneesh Kumar K.V55870272013-10-07 22:18:00 +05301373int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
1374 unsigned long npages)
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +09001375{
1376 return 0;
1377}
1378
Takuya Yoshikawae59dbe02013-07-04 13:40:29 +09001379void kvm_arch_memslots_updated(struct kvm *kvm)
1380{
1381}
1382
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001383/* Section: memory related */
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001384int kvm_arch_prepare_memory_region(struct kvm *kvm,
1385 struct kvm_memory_slot *memslot,
Takuya Yoshikawa7b6195a2013-02-27 19:44:34 +09001386 struct kvm_userspace_memory_region *mem,
1387 enum kvm_mr_change change)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001388{
Nick Wangdd2887e2013-03-25 17:22:57 +01001389 /* A few sanity checks. We can have memory slots which have to be
1390 located/ended at a segment boundary (1MB). The memory in userland is
1391 ok to be fragmented into various different vmas. It is okay to mmap()
1392 and munmap() stuff in this slot after doing this call at any time */
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001393
Carsten Otte598841c2011-07-24 10:48:21 +02001394 if (mem->userspace_addr & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001395 return -EINVAL;
1396
Carsten Otte598841c2011-07-24 10:48:21 +02001397 if (mem->memory_size & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001398 return -EINVAL;
1399
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001400 return 0;
1401}
1402
1403void kvm_arch_commit_memory_region(struct kvm *kvm,
1404 struct kvm_userspace_memory_region *mem,
Takuya Yoshikawa84826442013-02-27 19:45:25 +09001405 const struct kvm_memory_slot *old,
1406 enum kvm_mr_change change)
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001407{
Carsten Ottef7850c92011-07-24 10:48:23 +02001408 int rc;
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001409
Christian Borntraeger2cef4de2013-03-25 17:22:48 +01001410 /* If the basics of the memslot do not change, we do not want
1411 * to update the gmap. Every update causes several unnecessary
1412 * segment translation exceptions. This is usually handled just
1413 * fine by the normal fault handler + gmap, but it will also
1414 * cause faults on the prefix page of running guest CPUs.
1415 */
1416 if (old->userspace_addr == mem->userspace_addr &&
1417 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1418 old->npages * PAGE_SIZE == mem->memory_size)
1419 return;
Carsten Otte598841c2011-07-24 10:48:21 +02001420
1421 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1422 mem->guest_phys_addr, mem->memory_size);
1423 if (rc)
Carsten Ottef7850c92011-07-24 10:48:23 +02001424 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
Carsten Otte598841c2011-07-24 10:48:21 +02001425 return;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001426}
1427
Marcelo Tosatti2df72e92012-08-24 15:54:57 -03001428void kvm_arch_flush_shadow_all(struct kvm *kvm)
1429{
1430}
1431
1432void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1433 struct kvm_memory_slot *slot)
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -03001434{
1435}
1436
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001437static int __init kvm_s390_init(void)
1438{
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001439 int ret;
Avi Kivity0ee75be2010-04-28 15:39:01 +03001440 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001441 if (ret)
1442 return ret;
1443
1444 /*
1445 * guests can ask for up to 255+1 double words, we need a full page
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001446 * to hold the maximum amount of facilities. On the other hand, we
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001447 * only set facilities that are known to work in KVM.
1448 */
Michael Mueller78c4b592013-07-26 15:04:04 +02001449 vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1450 if (!vfacilities) {
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001451 kvm_exit();
1452 return -ENOMEM;
1453 }
Michael Mueller78c4b592013-07-26 15:04:04 +02001454 memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
Thomas Huthd208c792013-12-12 13:40:40 +01001455 vfacilities[0] &= 0xff82fff3f4fc2000UL;
Michael Mueller7feb6bb2013-06-28 13:30:24 +02001456 vfacilities[1] &= 0x005c000000000000UL;
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001457 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001458}
1459
1460static void __exit kvm_s390_exit(void)
1461{
Michael Mueller78c4b592013-07-26 15:04:04 +02001462 free_page((unsigned long) vfacilities);
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001463 kvm_exit();
1464}
1465
1466module_init(kvm_s390_init);
1467module_exit(kvm_s390_exit);
Cornelia Huck566af942013-05-27 18:42:33 +02001468
1469/*
1470 * Enable autoloading of the kvm module.
1471 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1472 * since x86 takes a different approach.
1473 */
1474#include <linux/miscdevice.h>
1475MODULE_ALIAS_MISCDEV(KVM_MINOR);
1476MODULE_ALIAS("devname:kvm");