blob: 08227c1e816fc8c0b9fa8caaeeec35c8ff5d30ff [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>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010014 */
15
16#include <linux/compiler.h>
17#include <linux/err.h>
18#include <linux/fs.h>
Christian Borntraegerca872302009-05-12 17:21:49 +020019#include <linux/hrtimer.h>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010020#include <linux/init.h>
21#include <linux/kvm.h>
22#include <linux/kvm_host.h>
23#include <linux/module.h>
24#include <linux/slab.h>
Carsten Otteba5c1e92008-03-25 18:47:26 +010025#include <linux/timer.h>
Heiko Carstenscbb870c2010-02-26 22:37:43 +010026#include <asm/asm-offsets.h>
Heiko Carstensb0c632d2008-03-25 18:47:20 +010027#include <asm/lowcore.h>
28#include <asm/pgtable.h>
Heiko Carstensf5daba12009-03-26 15:24:01 +010029#include <asm/nmi.h>
David Howellsa0616cd2012-03-28 18:30:02 +010030#include <asm/switch_to.h>
Christian Borntraeger1526bf92012-05-15 14:15:25 +020031#include <asm/sclp.h>
Christian Borntraeger8f2abe62008-03-25 18:47:23 +010032#include "kvm-s390.h"
Heiko Carstensb0c632d2008-03-25 18:47:20 +010033#include "gaccess.h"
34
Cornelia Huck5786fff2012-07-23 17:20:29 +020035#define CREATE_TRACE_POINTS
36#include "trace.h"
Cornelia Huckade38c32012-07-23 17:20:30 +020037#include "trace-s390.h"
Cornelia Huck5786fff2012-07-23 17:20:29 +020038
Heiko Carstensb0c632d2008-03-25 18:47:20 +010039#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
40
41struct kvm_stats_debugfs_item debugfs_entries[] = {
42 { "userspace_handled", VCPU_STAT(exit_userspace) },
Christian Borntraeger0eaeafa2008-05-07 09:22:53 +020043 { "exit_null", VCPU_STAT(exit_null) },
Christian Borntraeger8f2abe62008-03-25 18:47:23 +010044 { "exit_validity", VCPU_STAT(exit_validity) },
45 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
46 { "exit_external_request", VCPU_STAT(exit_external_request) },
47 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010048 { "exit_instruction", VCPU_STAT(exit_instruction) },
49 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
50 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
Christian Borntraegerf5e10b02008-07-25 15:52:44 +020051 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010052 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
53 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
Christian Ehrhardt7697e71f2011-10-18 12:27:15 +020054 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
Carsten Otteba5c1e92008-03-25 18:47:26 +010055 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
56 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
57 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
58 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
59 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
60 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
61 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
Christian Borntraeger453423d2008-03-25 18:47:29 +010062 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
63 { "instruction_spx", VCPU_STAT(instruction_spx) },
64 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
65 { "instruction_stap", VCPU_STAT(instruction_stap) },
66 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
67 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
68 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
69 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
70 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
Christian Borntraegerbb25b9b2011-07-24 10:48:17 +020071 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010072 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
Cornelia Huckbd59d3a2011-11-17 11:00:42 +010073 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
Christian Ehrhardt7697e71f2011-10-18 12:27:15 +020074 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
Christian Borntraeger5288fbf2008-03-25 18:47:31 +010075 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
76 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
77 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
78 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
79 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
Christian Borntraeger388186b2011-10-30 15:17:03 +010080 { "diagnose_10", VCPU_STAT(diagnose_10) },
Christian Borntraegere28acfe2008-03-25 18:47:34 +010081 { "diagnose_44", VCPU_STAT(diagnose_44) },
Konstantin Weitz41628d32012-04-25 15:30:38 +020082 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
Heiko Carstensb0c632d2008-03-25 18:47:20 +010083 { NULL }
84};
85
Christian Borntraegeref50f7a2009-06-23 17:24:07 +020086static unsigned long long *facilities;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +020087static struct gmap_notifier gmap_notifier;
Heiko Carstensb0c632d2008-03-25 18:47:20 +010088
89/* Section: not file related */
Alexander Graf10474ae2009-09-15 11:37:46 +020090int kvm_arch_hardware_enable(void *garbage)
Heiko Carstensb0c632d2008-03-25 18:47:20 +010091{
92 /* every s390 is virtualization enabled ;-) */
Alexander Graf10474ae2009-09-15 11:37:46 +020093 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +010094}
95
96void kvm_arch_hardware_disable(void *garbage)
97{
98}
99
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200100static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
101
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100102int kvm_arch_hardware_setup(void)
103{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200104 gmap_notifier.notifier_call = kvm_gmap_notifier;
105 gmap_register_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100106 return 0;
107}
108
109void kvm_arch_hardware_unsetup(void)
110{
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200111 gmap_unregister_ipte_notifier(&gmap_notifier);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100112}
113
114void kvm_arch_check_processor_compat(void *rtn)
115{
116}
117
118int kvm_arch_init(void *opaque)
119{
120 return 0;
121}
122
123void kvm_arch_exit(void)
124{
125}
126
127/* Section: device related */
128long kvm_arch_dev_ioctl(struct file *filp,
129 unsigned int ioctl, unsigned long arg)
130{
131 if (ioctl == KVM_S390_ENABLE_SIE)
132 return s390_enable_sie();
133 return -EINVAL;
134}
135
136int kvm_dev_ioctl_check_extension(long ext)
137{
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100138 int r;
139
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200140 switch (ext) {
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100141 case KVM_CAP_S390_PSW:
Christian Borntraegerb6cf8782011-09-20 17:07:29 +0200142 case KVM_CAP_S390_GMAP:
Christian Borntraeger52e16b12011-11-17 11:00:44 +0100143 case KVM_CAP_SYNC_MMU:
Carsten Otte1efd0f52012-01-04 10:25:29 +0100144#ifdef CONFIG_KVM_S390_UCONTROL
145 case KVM_CAP_S390_UCONTROL:
146#endif
Christian Borntraeger60b413c2012-01-11 11:20:31 +0100147 case KVM_CAP_SYNC_REGS:
Carsten Otte14eebd92012-05-15 14:15:26 +0200148 case KVM_CAP_ONE_REG:
Cornelia Huckd6712df2012-12-20 15:32:11 +0100149 case KVM_CAP_ENABLE_CAP:
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100150 case KVM_CAP_S390_CSS_SUPPORT:
Cornelia Huck10ccaa12013-02-28 12:33:21 +0100151 case KVM_CAP_IOEVENTFD:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100152 r = 1;
153 break;
Christian Borntraegere726b1b2012-05-02 10:50:38 +0200154 case KVM_CAP_NR_VCPUS:
155 case KVM_CAP_MAX_VCPUS:
156 r = KVM_MAX_VCPUS;
157 break;
Nick Wange1e2e602013-03-25 17:22:58 +0100158 case KVM_CAP_NR_MEMSLOTS:
159 r = KVM_USER_MEM_SLOTS;
160 break;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200161 case KVM_CAP_S390_COW:
Martin Schwidefskyabf09be2012-11-07 13:17:37 +0100162 r = MACHINE_HAS_ESOP;
Christian Borntraeger1526bf92012-05-15 14:15:25 +0200163 break;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200164 default:
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100165 r = 0;
Carsten Otte2bd0ac42008-07-25 15:49:13 +0200166 }
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100167 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100168}
169
170/* Section: vm related */
171/*
172 * Get (and clear) the dirty memory log for a memory slot.
173 */
174int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
175 struct kvm_dirty_log *log)
176{
177 return 0;
178}
179
180long kvm_arch_vm_ioctl(struct file *filp,
181 unsigned int ioctl, unsigned long arg)
182{
183 struct kvm *kvm = filp->private_data;
184 void __user *argp = (void __user *)arg;
185 int r;
186
187 switch (ioctl) {
Carsten Otteba5c1e92008-03-25 18:47:26 +0100188 case KVM_S390_INTERRUPT: {
189 struct kvm_s390_interrupt s390int;
190
191 r = -EFAULT;
192 if (copy_from_user(&s390int, argp, sizeof(s390int)))
193 break;
194 r = kvm_s390_inject_vm(kvm, &s390int);
195 break;
196 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100197 default:
Avi Kivity367e1312009-08-26 14:57:07 +0300198 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100199 }
200
201 return r;
202}
203
Carsten Ottee08b9632012-01-04 10:25:20 +0100204int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100205{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100206 int rc;
207 char debug_name[16];
208
Carsten Ottee08b9632012-01-04 10:25:20 +0100209 rc = -EINVAL;
210#ifdef CONFIG_KVM_S390_UCONTROL
211 if (type & ~KVM_VM_S390_UCONTROL)
212 goto out_err;
213 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
214 goto out_err;
215#else
216 if (type)
217 goto out_err;
218#endif
219
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100220 rc = s390_enable_sie();
221 if (rc)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100222 goto out_err;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100223
Carsten Otteb2904112011-10-18 12:27:13 +0200224 rc = -ENOMEM;
225
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100226 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
227 if (!kvm->arch.sca)
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100228 goto out_err;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100229
230 sprintf(debug_name, "kvm-%u", current->pid);
231
232 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
233 if (!kvm->arch.dbf)
234 goto out_nodbf;
235
Carsten Otteba5c1e92008-03-25 18:47:26 +0100236 spin_lock_init(&kvm->arch.float_int.lock);
237 INIT_LIST_HEAD(&kvm->arch.float_int.list);
238
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100239 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
240 VM_EVENT(kvm, 3, "%s", "vm created");
241
Carsten Ottee08b9632012-01-04 10:25:20 +0100242 if (type & KVM_VM_S390_UCONTROL) {
243 kvm->arch.gmap = NULL;
244 } else {
245 kvm->arch.gmap = gmap_alloc(current->mm);
246 if (!kvm->arch.gmap)
247 goto out_nogmap;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200248 kvm->arch.gmap->private = kvm;
Carsten Ottee08b9632012-01-04 10:25:20 +0100249 }
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100250
251 kvm->arch.css_support = 0;
252
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100253 return 0;
Carsten Otte598841c2011-07-24 10:48:21 +0200254out_nogmap:
255 debug_unregister(kvm->arch.dbf);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100256out_nodbf:
257 free_page((unsigned long)(kvm->arch.sca));
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100258out_err:
259 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100260}
261
Christian Borntraegerd329c032008-11-26 14:50:27 +0100262void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
263{
264 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
Cornelia Huckade38c32012-07-23 17:20:30 +0200265 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
Carsten Otte58f94602012-01-04 10:25:27 +0100266 if (!kvm_is_ucontrol(vcpu->kvm)) {
267 clear_bit(63 - vcpu->vcpu_id,
268 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
269 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
270 (__u64) vcpu->arch.sie_block)
271 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
272 }
Carsten Otteabf4a712009-05-12 17:21:51 +0200273 smp_mb();
Carsten Otte27e03932012-01-04 10:25:21 +0100274
275 if (kvm_is_ucontrol(vcpu->kvm))
276 gmap_free(vcpu->arch.gmap);
277
Christian Borntraegerd329c032008-11-26 14:50:27 +0100278 free_page((unsigned long)(vcpu->arch.sie_block));
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100279 kvm_vcpu_uninit(vcpu);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100280 kfree(vcpu);
281}
282
283static void kvm_free_vcpus(struct kvm *kvm)
284{
285 unsigned int i;
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300286 struct kvm_vcpu *vcpu;
Christian Borntraegerd329c032008-11-26 14:50:27 +0100287
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300288 kvm_for_each_vcpu(i, vcpu, kvm)
289 kvm_arch_vcpu_destroy(vcpu);
290
291 mutex_lock(&kvm->lock);
292 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
293 kvm->vcpus[i] = NULL;
294
295 atomic_set(&kvm->online_vcpus, 0);
296 mutex_unlock(&kvm->lock);
Christian Borntraegerd329c032008-11-26 14:50:27 +0100297}
298
Sheng Yangad8ba2c2009-01-06 10:03:02 +0800299void kvm_arch_sync_events(struct kvm *kvm)
300{
301}
302
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100303void kvm_arch_destroy_vm(struct kvm *kvm)
304{
Christian Borntraegerd329c032008-11-26 14:50:27 +0100305 kvm_free_vcpus(kvm);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100306 free_page((unsigned long)(kvm->arch.sca));
Christian Borntraegerd329c032008-11-26 14:50:27 +0100307 debug_unregister(kvm->arch.dbf);
Carsten Otte27e03932012-01-04 10:25:21 +0100308 if (!kvm_is_ucontrol(kvm))
309 gmap_free(kvm->arch.gmap);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100310}
311
312/* Section: vcpu related */
313int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
314{
Carsten Otte27e03932012-01-04 10:25:21 +0100315 if (kvm_is_ucontrol(vcpu->kvm)) {
316 vcpu->arch.gmap = gmap_alloc(current->mm);
317 if (!vcpu->arch.gmap)
318 return -ENOMEM;
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200319 vcpu->arch.gmap->private = vcpu->kvm;
Carsten Otte27e03932012-01-04 10:25:21 +0100320 return 0;
321 }
322
Carsten Otte598841c2011-07-24 10:48:21 +0200323 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
Christian Borntraeger59674c12012-01-11 11:20:33 +0100324 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
325 KVM_SYNC_GPRS |
Christian Borntraeger9eed07352012-02-06 10:59:07 +0100326 KVM_SYNC_ACRS |
327 KVM_SYNC_CRS;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100328 return 0;
329}
330
331void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
332{
Christian Borntraeger6692cef2008-11-26 14:51:08 +0100333 /* Nothing todo */
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100334}
335
336void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
337{
338 save_fp_regs(&vcpu->arch.host_fpregs);
339 save_access_regs(vcpu->arch.host_acrs);
340 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
341 restore_fp_regs(&vcpu->arch.guest_fpregs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100342 restore_access_regs(vcpu->run->s.regs.acrs);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200343 gmap_enable(vcpu->arch.gmap);
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100344 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100345}
346
347void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
348{
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100349 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
Christian Borntraeger480e5922011-09-20 17:07:28 +0200350 gmap_disable(vcpu->arch.gmap);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100351 save_fp_regs(&vcpu->arch.guest_fpregs);
Christian Borntraeger59674c12012-01-11 11:20:33 +0100352 save_access_regs(vcpu->run->s.regs.acrs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100353 restore_fp_regs(&vcpu->arch.host_fpregs);
354 restore_access_regs(vcpu->arch.host_acrs);
355}
356
357static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
358{
359 /* this equals initial cpu reset in pop, but we don't switch to ESA */
360 vcpu->arch.sie_block->gpsw.mask = 0UL;
361 vcpu->arch.sie_block->gpsw.addr = 0UL;
Christian Borntraeger8d26cf72012-01-11 11:19:32 +0100362 kvm_s390_set_prefix(vcpu, 0);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100363 vcpu->arch.sie_block->cputm = 0UL;
364 vcpu->arch.sie_block->ckc = 0UL;
365 vcpu->arch.sie_block->todpr = 0;
366 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
367 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
368 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
369 vcpu->arch.guest_fpregs.fpc = 0;
370 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
371 vcpu->arch.sie_block->gbea = 1;
Christian Borntraeger61bde822012-06-11 16:06:57 +0200372 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100373}
374
Marcelo Tosatti42897d82012-11-27 23:29:02 -0200375int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
376{
377 return 0;
378}
379
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100380int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
381{
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100382 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
383 CPUSTAT_SM |
384 CPUSTAT_STOPPED);
Christian Borntraegerfc345312010-06-17 23:16:20 +0200385 vcpu->arch.sie_block->ecb = 6;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100386 vcpu->arch.sie_block->eca = 0xC1002001U;
Christian Borntraegeref50f7a2009-06-23 17:24:07 +0200387 vcpu->arch.sie_block->fac = (int) (long) facilities;
Christian Borntraegerca872302009-05-12 17:21:49 +0200388 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
389 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
390 (unsigned long) vcpu);
391 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
Christian Borntraeger453423d2008-03-25 18:47:29 +0100392 get_cpu_id(&vcpu->arch.cpu_id);
Christian Borntraeger92e6ecf2009-03-26 15:23:58 +0100393 vcpu->arch.cpu_id.version = 0xff;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100394 return 0;
395}
396
397struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
398 unsigned int id)
399{
Carsten Otte4d475552011-10-18 12:27:12 +0200400 struct kvm_vcpu *vcpu;
401 int rc = -EINVAL;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100402
Carsten Otte4d475552011-10-18 12:27:12 +0200403 if (id >= KVM_MAX_VCPUS)
404 goto out;
405
406 rc = -ENOMEM;
407
408 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100409 if (!vcpu)
Carsten Otte4d475552011-10-18 12:27:12 +0200410 goto out;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100411
Christian Borntraeger180c12f2008-06-27 15:05:40 +0200412 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
413 get_zeroed_page(GFP_KERNEL);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100414
415 if (!vcpu->arch.sie_block)
416 goto out_free_cpu;
417
418 vcpu->arch.sie_block->icpua = id;
Carsten Otte58f94602012-01-04 10:25:27 +0100419 if (!kvm_is_ucontrol(kvm)) {
420 if (!kvm->arch.sca) {
421 WARN_ON_ONCE(1);
422 goto out_free_cpu;
423 }
424 if (!kvm->arch.sca->cpu[id].sda)
425 kvm->arch.sca->cpu[id].sda =
426 (__u64) vcpu->arch.sie_block;
427 vcpu->arch.sie_block->scaoh =
428 (__u32)(((__u64)kvm->arch.sca) >> 32);
429 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
430 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
431 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100432
Carsten Otteba5c1e92008-03-25 18:47:26 +0100433 spin_lock_init(&vcpu->arch.local_int.lock);
434 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
435 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
Christian Borntraegerb037a4f2009-05-12 17:21:50 +0200436 spin_lock(&kvm->arch.float_int.lock);
Carsten Otteba5c1e92008-03-25 18:47:26 +0100437 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
438 init_waitqueue_head(&vcpu->arch.local_int.wq);
Christian Borntraeger5288fbf2008-03-25 18:47:31 +0100439 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
Christian Borntraegerb037a4f2009-05-12 17:21:50 +0200440 spin_unlock(&kvm->arch.float_int.lock);
Carsten Otteba5c1e92008-03-25 18:47:26 +0100441
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100442 rc = kvm_vcpu_init(vcpu, kvm, id);
443 if (rc)
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800444 goto out_free_sie_block;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100445 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
446 vcpu->arch.sie_block);
Cornelia Huckade38c32012-07-23 17:20:30 +0200447 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100448
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100449 return vcpu;
Wei Yongjun7b06bf22010-03-09 14:37:53 +0800450out_free_sie_block:
451 free_page((unsigned long)(vcpu->arch.sie_block));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100452out_free_cpu:
453 kfree(vcpu);
Carsten Otte4d475552011-10-18 12:27:12 +0200454out:
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100455 return ERR_PTR(rc);
456}
457
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100458int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
459{
460 /* kvm common code refers to this, but never calls it */
461 BUG();
462 return 0;
463}
464
Christian Borntraeger49b99e12013-05-17 14:41:35 +0200465void s390_vcpu_block(struct kvm_vcpu *vcpu)
466{
467 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
468}
469
470void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
471{
472 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
473}
474
475/*
476 * Kick a guest cpu out of SIE and wait until SIE is not running.
477 * If the CPU is not running (e.g. waiting as idle) the function will
478 * return immediately. */
479void exit_sie(struct kvm_vcpu *vcpu)
480{
481 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
482 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
483 cpu_relax();
484}
485
486/* Kick a guest cpu out of SIE and prevent SIE-reentry */
487void exit_sie_sync(struct kvm_vcpu *vcpu)
488{
489 s390_vcpu_block(vcpu);
490 exit_sie(vcpu);
491}
492
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200493static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
494{
495 int i;
496 struct kvm *kvm = gmap->private;
497 struct kvm_vcpu *vcpu;
498
499 kvm_for_each_vcpu(i, vcpu, kvm) {
500 /* match against both prefix pages */
501 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
502 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
503 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
504 exit_sie_sync(vcpu);
505 }
506 }
507}
508
Christoffer Dallb6d33832012-03-08 16:44:24 -0500509int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
510{
511 /* kvm common code refers to this, but never calls it */
512 BUG();
513 return 0;
514}
515
Carsten Otte14eebd92012-05-15 14:15:26 +0200516static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
517 struct kvm_one_reg *reg)
518{
519 int r = -EINVAL;
520
521 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200522 case KVM_REG_S390_TODPR:
523 r = put_user(vcpu->arch.sie_block->todpr,
524 (u32 __user *)reg->addr);
525 break;
526 case KVM_REG_S390_EPOCHDIFF:
527 r = put_user(vcpu->arch.sie_block->epoch,
528 (u64 __user *)reg->addr);
529 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200530 case KVM_REG_S390_CPU_TIMER:
531 r = put_user(vcpu->arch.sie_block->cputm,
532 (u64 __user *)reg->addr);
533 break;
534 case KVM_REG_S390_CLOCK_COMP:
535 r = put_user(vcpu->arch.sie_block->ckc,
536 (u64 __user *)reg->addr);
537 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200538 default:
539 break;
540 }
541
542 return r;
543}
544
545static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
546 struct kvm_one_reg *reg)
547{
548 int r = -EINVAL;
549
550 switch (reg->id) {
Carsten Otte29b7c712012-05-15 14:15:27 +0200551 case KVM_REG_S390_TODPR:
552 r = get_user(vcpu->arch.sie_block->todpr,
553 (u32 __user *)reg->addr);
554 break;
555 case KVM_REG_S390_EPOCHDIFF:
556 r = get_user(vcpu->arch.sie_block->epoch,
557 (u64 __user *)reg->addr);
558 break;
Jason J. herne46a6dd12012-05-15 14:15:28 +0200559 case KVM_REG_S390_CPU_TIMER:
560 r = get_user(vcpu->arch.sie_block->cputm,
561 (u64 __user *)reg->addr);
562 break;
563 case KVM_REG_S390_CLOCK_COMP:
564 r = get_user(vcpu->arch.sie_block->ckc,
565 (u64 __user *)reg->addr);
566 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200567 default:
568 break;
569 }
570
571 return r;
572}
Christoffer Dallb6d33832012-03-08 16:44:24 -0500573
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100574static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
575{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100576 kvm_s390_vcpu_initial_reset(vcpu);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100577 return 0;
578}
579
580int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
581{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100582 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100583 return 0;
584}
585
586int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
587{
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100588 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100589 return 0;
590}
591
592int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
593 struct kvm_sregs *sregs)
594{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100595 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100596 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
Christian Borntraeger59674c12012-01-11 11:20:33 +0100597 restore_access_regs(vcpu->run->s.regs.acrs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100598 return 0;
599}
600
601int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
602 struct kvm_sregs *sregs)
603{
Christian Borntraeger59674c12012-01-11 11:20:33 +0100604 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100605 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100606 return 0;
607}
608
609int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
610{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100611 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
Christian Borntraeger85175582012-02-06 10:59:02 +0100612 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
Carsten Otte7eef87d2011-10-18 12:27:14 +0200613 restore_fp_regs(&vcpu->arch.guest_fpregs);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100614 return 0;
615}
616
617int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
618{
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100619 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
620 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100621 return 0;
622}
623
624static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
625{
626 int rc = 0;
627
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100628 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100629 rc = -EBUSY;
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100630 else {
631 vcpu->run->psw_mask = psw.mask;
632 vcpu->run->psw_addr = psw.addr;
633 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100634 return rc;
635}
636
637int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
638 struct kvm_translation *tr)
639{
640 return -EINVAL; /* not implemented yet */
641}
642
Jan Kiszkad0bfb942008-12-15 13:52:10 +0100643int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
644 struct kvm_guest_debug *dbg)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100645{
646 return -EINVAL; /* not implemented yet */
647}
648
Marcelo Tosatti62d9f0d2008-04-11 13:24:45 -0300649int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
650 struct kvm_mp_state *mp_state)
651{
652 return -EINVAL; /* not implemented yet */
653}
654
655int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
656 struct kvm_mp_state *mp_state)
657{
658 return -EINVAL; /* not implemented yet */
659}
660
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200661static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
662{
663 /*
664 * We use MMU_RELOAD just to re-arm the ipte notifier for the
665 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
666 * This ensures that the ipte instruction for this request has
667 * already finished. We might race against a second unmapper that
668 * wants to set the blocking bit. Lets just retry the request loop.
669 */
670 while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
671 int rc;
672 rc = gmap_ipte_notify(vcpu->arch.gmap,
673 vcpu->arch.sie_block->prefix,
674 PAGE_SIZE * 2);
675 if (rc)
676 return rc;
677 s390_vcpu_unblock(vcpu);
678 }
679 return 0;
680}
681
Carsten Ottee168bf82012-01-04 10:25:22 +0100682static int __vcpu_run(struct kvm_vcpu *vcpu)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100683{
Carsten Ottee168bf82012-01-04 10:25:22 +0100684 int rc;
685
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100686 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100687
688 if (need_resched())
689 schedule();
690
Christian Borntraeger71cde582008-05-21 13:37:34 +0200691 if (test_thread_flag(TIF_MCCK_PENDING))
692 s390_handle_mcck();
693
Carsten Otted6b6d162012-01-04 10:25:25 +0100694 if (!kvm_is_ucontrol(vcpu->kvm))
695 kvm_s390_deliver_pending_interrupts(vcpu);
Carsten Otte0ff31862008-05-21 13:37:37 +0200696
Christian Borntraeger2c70fe42013-05-17 14:41:36 +0200697 rc = kvm_s390_handle_requests(vcpu);
698 if (rc)
699 return rc;
700
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100701 vcpu->arch.sie_block->icptcode = 0;
Christian Borntraeger83987ac2013-01-08 16:23:10 +0100702 preempt_disable();
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100703 kvm_guest_enter();
Christian Borntraeger83987ac2013-01-08 16:23:10 +0100704 preempt_enable();
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100705 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
706 atomic_read(&vcpu->arch.sie_block->cpuflags));
Cornelia Huck5786fff2012-07-23 17:20:29 +0200707 trace_kvm_s390_sie_enter(vcpu,
708 atomic_read(&vcpu->arch.sie_block->cpuflags));
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100709 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
Carsten Ottee168bf82012-01-04 10:25:22 +0100710 if (rc) {
711 if (kvm_is_ucontrol(vcpu->kvm)) {
712 rc = SIE_INTERCEPT_UCONTROL;
713 } else {
714 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
Cornelia Huck5786fff2012-07-23 17:20:29 +0200715 trace_kvm_s390_sie_fault(vcpu);
Heiko Carstensdb4a29c2013-03-25 17:22:53 +0100716 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
Carsten Ottee168bf82012-01-04 10:25:22 +0100717 }
Carsten Otte1f0d0f02008-05-21 13:37:40 +0200718 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100719 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
720 vcpu->arch.sie_block->icptcode);
Cornelia Huck5786fff2012-07-23 17:20:29 +0200721 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100722 kvm_guest_exit();
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100723
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100724 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
Carsten Ottee168bf82012-01-04 10:25:22 +0100725 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100726}
727
728int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
729{
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100730 int rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100731 sigset_t sigsaved;
732
Christian Ehrhardt9ace9032009-05-20 15:34:55 +0200733rerun_vcpu:
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100734 if (vcpu->sigset_active)
735 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
736
Cornelia Huck9e6dabe2011-11-17 11:00:41 +0100737 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100738
Carsten Otteba5c1e92008-03-25 18:47:26 +0100739 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
740
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100741 switch (kvm_run->exit_reason) {
742 case KVM_EXIT_S390_SIEIC:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100743 case KVM_EXIT_UNKNOWN:
Christian Ehrhardt9ace9032009-05-20 15:34:55 +0200744 case KVM_EXIT_INTR:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100745 case KVM_EXIT_S390_RESET:
Carsten Ottee168bf82012-01-04 10:25:22 +0100746 case KVM_EXIT_S390_UCONTROL:
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100747 case KVM_EXIT_S390_TSCH:
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100748 break;
749 default:
750 BUG();
751 }
752
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100753 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
754 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
Christian Borntraeger60b413c2012-01-11 11:20:31 +0100755 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
756 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
757 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
758 }
Christian Borntraeger9eed07352012-02-06 10:59:07 +0100759 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
760 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
761 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
762 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
763 }
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100764
Heiko Carstensdab4079d2009-06-12 10:26:32 +0200765 might_fault();
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100766
767 do {
Carsten Ottee168bf82012-01-04 10:25:22 +0100768 rc = __vcpu_run(vcpu);
769 if (rc)
770 break;
Carsten Ottec0d744a2012-01-04 10:25:24 +0100771 if (kvm_is_ucontrol(vcpu->kvm))
772 rc = -EOPNOTSUPP;
773 else
774 rc = kvm_handle_sie_intercept(vcpu);
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100775 } while (!signal_pending(current) && !rc);
776
Christian Ehrhardt9ace9032009-05-20 15:34:55 +0200777 if (rc == SIE_INTERCEPT_RERUNVCPU)
778 goto rerun_vcpu;
779
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +0200780 if (signal_pending(current) && !rc) {
781 kvm_run->exit_reason = KVM_EXIT_INTR;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100782 rc = -EINTR;
Christian Ehrhardtb1d16c42009-05-20 15:34:56 +0200783 }
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100784
Carsten Ottee168bf82012-01-04 10:25:22 +0100785#ifdef CONFIG_KVM_S390_UCONTROL
786 if (rc == SIE_INTERCEPT_UCONTROL) {
787 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
788 kvm_run->s390_ucontrol.trans_exc_code =
789 current->thread.gmap_addr;
790 kvm_run->s390_ucontrol.pgm_code = 0x10;
791 rc = 0;
792 }
793#endif
794
Heiko Carstensb8e660b2010-02-26 22:37:41 +0100795 if (rc == -EOPNOTSUPP) {
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100796 /* intercept cannot be handled in-kernel, prepare kvm-run */
797 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
798 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
Christian Borntraeger8f2abe62008-03-25 18:47:23 +0100799 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
800 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
801 rc = 0;
802 }
803
804 if (rc == -EREMOTE) {
805 /* intercept was handled, but userspace support is needed
806 * kvm_run has been prepared by the handler */
807 rc = 0;
808 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100809
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100810 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
811 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
Christian Borntraeger60b413c2012-01-11 11:20:31 +0100812 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
Christian Borntraeger9eed07352012-02-06 10:59:07 +0100813 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
Carsten Otted7b0b5e2009-11-19 14:21:16 +0100814
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100815 if (vcpu->sigset_active)
816 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
817
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100818 vcpu->stat.exit_userspace++;
Heiko Carstens7e8e6ab2008-04-04 15:12:35 +0200819 return rc;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100820}
821
Carsten Otte092670c2011-07-24 10:48:22 +0200822static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100823 unsigned long n, int prefix)
824{
825 if (prefix)
826 return copy_to_guest(vcpu, guestdest, from, n);
827 else
828 return copy_to_guest_absolute(vcpu, guestdest, from, n);
829}
830
831/*
832 * store status at address
833 * we use have two special cases:
834 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
835 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
836 */
Christian Borntraeger971eb772010-06-12 08:54:13 +0200837int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100838{
Carsten Otte092670c2011-07-24 10:48:22 +0200839 unsigned char archmode = 1;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100840 int prefix;
841
842 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
843 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
844 return -EFAULT;
845 addr = SAVE_AREA_BASE;
846 prefix = 0;
847 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
848 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
849 return -EFAULT;
850 addr = SAVE_AREA_BASE;
851 prefix = 1;
852 } else
853 prefix = 0;
854
Christian Borntraeger15bc8d82013-01-25 15:34:15 +0100855 /*
856 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
857 * copying in vcpu load/put. Lets update our copies before we save
858 * it into the save area
859 */
860 save_fp_regs(&vcpu->arch.guest_fpregs);
861 save_access_regs(vcpu->run->s.regs.acrs);
862
Heiko Carstensf64ca212010-02-26 22:37:32 +0100863 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100864 vcpu->arch.guest_fpregs.fprs, 128, prefix))
865 return -EFAULT;
866
Heiko Carstensf64ca212010-02-26 22:37:32 +0100867 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
Christian Borntraeger5a32c1a2012-01-11 11:20:32 +0100868 vcpu->run->s.regs.gprs, 128, prefix))
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100869 return -EFAULT;
870
Heiko Carstensf64ca212010-02-26 22:37:32 +0100871 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100872 &vcpu->arch.sie_block->gpsw, 16, prefix))
873 return -EFAULT;
874
Heiko Carstensf64ca212010-02-26 22:37:32 +0100875 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100876 &vcpu->arch.sie_block->prefix, 4, prefix))
877 return -EFAULT;
878
879 if (__guestcopy(vcpu,
Heiko Carstensf64ca212010-02-26 22:37:32 +0100880 addr + offsetof(struct save_area, fp_ctrl_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100881 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
882 return -EFAULT;
883
Heiko Carstensf64ca212010-02-26 22:37:32 +0100884 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100885 &vcpu->arch.sie_block->todpr, 4, prefix))
886 return -EFAULT;
887
Heiko Carstensf64ca212010-02-26 22:37:32 +0100888 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100889 &vcpu->arch.sie_block->cputm, 8, prefix))
890 return -EFAULT;
891
Heiko Carstensf64ca212010-02-26 22:37:32 +0100892 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100893 &vcpu->arch.sie_block->ckc, 8, prefix))
894 return -EFAULT;
895
Heiko Carstensf64ca212010-02-26 22:37:32 +0100896 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
Christian Borntraeger59674c12012-01-11 11:20:33 +0100897 &vcpu->run->s.regs.acrs, 64, prefix))
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100898 return -EFAULT;
899
900 if (__guestcopy(vcpu,
Heiko Carstensf64ca212010-02-26 22:37:32 +0100901 addr + offsetof(struct save_area, ctrl_regs),
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100902 &vcpu->arch.sie_block->gcr, 128, prefix))
903 return -EFAULT;
904 return 0;
905}
906
Cornelia Huckd6712df2012-12-20 15:32:11 +0100907static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
908 struct kvm_enable_cap *cap)
909{
910 int r;
911
912 if (cap->flags)
913 return -EINVAL;
914
915 switch (cap->cap) {
Cornelia Huckfa6b7fe2012-12-20 15:32:12 +0100916 case KVM_CAP_S390_CSS_SUPPORT:
917 if (!vcpu->kvm->arch.css_support) {
918 vcpu->kvm->arch.css_support = 1;
919 trace_kvm_s390_enable_css(vcpu->kvm);
920 }
921 r = 0;
922 break;
Cornelia Huckd6712df2012-12-20 15:32:11 +0100923 default:
924 r = -EINVAL;
925 break;
926 }
927 return r;
928}
929
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100930long kvm_arch_vcpu_ioctl(struct file *filp,
931 unsigned int ioctl, unsigned long arg)
932{
933 struct kvm_vcpu *vcpu = filp->private_data;
934 void __user *argp = (void __user *)arg;
Avi Kivitybc923cc2010-05-13 12:21:46 +0300935 long r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100936
Avi Kivity937366242010-05-13 12:35:17 +0300937 switch (ioctl) {
938 case KVM_S390_INTERRUPT: {
Carsten Otteba5c1e92008-03-25 18:47:26 +0100939 struct kvm_s390_interrupt s390int;
940
Avi Kivity937366242010-05-13 12:35:17 +0300941 r = -EFAULT;
Carsten Otteba5c1e92008-03-25 18:47:26 +0100942 if (copy_from_user(&s390int, argp, sizeof(s390int)))
Avi Kivity937366242010-05-13 12:35:17 +0300943 break;
944 r = kvm_s390_inject_vcpu(vcpu, &s390int);
945 break;
Carsten Otteba5c1e92008-03-25 18:47:26 +0100946 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100947 case KVM_S390_STORE_STATUS:
Avi Kivitybc923cc2010-05-13 12:21:46 +0300948 r = kvm_s390_vcpu_store_status(vcpu, arg);
949 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100950 case KVM_S390_SET_INITIAL_PSW: {
951 psw_t psw;
952
Avi Kivitybc923cc2010-05-13 12:21:46 +0300953 r = -EFAULT;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100954 if (copy_from_user(&psw, argp, sizeof(psw)))
Avi Kivitybc923cc2010-05-13 12:21:46 +0300955 break;
956 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
957 break;
Heiko Carstensb0c632d2008-03-25 18:47:20 +0100958 }
959 case KVM_S390_INITIAL_RESET:
Avi Kivitybc923cc2010-05-13 12:21:46 +0300960 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
961 break;
Carsten Otte14eebd92012-05-15 14:15:26 +0200962 case KVM_SET_ONE_REG:
963 case KVM_GET_ONE_REG: {
964 struct kvm_one_reg reg;
965 r = -EFAULT;
966 if (copy_from_user(&reg, argp, sizeof(reg)))
967 break;
968 if (ioctl == KVM_SET_ONE_REG)
969 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
970 else
971 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
972 break;
973 }
Carsten Otte27e03932012-01-04 10:25:21 +0100974#ifdef CONFIG_KVM_S390_UCONTROL
975 case KVM_S390_UCAS_MAP: {
976 struct kvm_s390_ucas_mapping ucasmap;
977
978 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
979 r = -EFAULT;
980 break;
981 }
982
983 if (!kvm_is_ucontrol(vcpu->kvm)) {
984 r = -EINVAL;
985 break;
986 }
987
988 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
989 ucasmap.vcpu_addr, ucasmap.length);
990 break;
991 }
992 case KVM_S390_UCAS_UNMAP: {
993 struct kvm_s390_ucas_mapping ucasmap;
994
995 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
996 r = -EFAULT;
997 break;
998 }
999
1000 if (!kvm_is_ucontrol(vcpu->kvm)) {
1001 r = -EINVAL;
1002 break;
1003 }
1004
1005 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1006 ucasmap.length);
1007 break;
1008 }
1009#endif
Carsten Otteccc79102012-01-04 10:25:26 +01001010 case KVM_S390_VCPU_FAULT: {
1011 r = gmap_fault(arg, vcpu->arch.gmap);
1012 if (!IS_ERR_VALUE(r))
1013 r = 0;
1014 break;
1015 }
Cornelia Huckd6712df2012-12-20 15:32:11 +01001016 case KVM_ENABLE_CAP:
1017 {
1018 struct kvm_enable_cap cap;
1019 r = -EFAULT;
1020 if (copy_from_user(&cap, argp, sizeof(cap)))
1021 break;
1022 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1023 break;
1024 }
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001025 default:
Carsten Otte3e6afcf2012-01-04 10:25:30 +01001026 r = -ENOTTY;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001027 }
Avi Kivitybc923cc2010-05-13 12:21:46 +03001028 return r;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001029}
1030
Carsten Otte5b1c1492012-01-04 10:25:23 +01001031int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1032{
1033#ifdef CONFIG_KVM_S390_UCONTROL
1034 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1035 && (kvm_is_ucontrol(vcpu->kvm))) {
1036 vmf->page = virt_to_page(vcpu->arch.sie_block);
1037 get_page(vmf->page);
1038 return 0;
1039 }
1040#endif
1041 return VM_FAULT_SIGBUS;
1042}
1043
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +09001044void kvm_arch_free_memslot(struct kvm_memory_slot *free,
1045 struct kvm_memory_slot *dont)
1046{
1047}
1048
1049int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
1050{
1051 return 0;
1052}
1053
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001054/* Section: memory related */
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001055int kvm_arch_prepare_memory_region(struct kvm *kvm,
1056 struct kvm_memory_slot *memslot,
Takuya Yoshikawa7b6195a2013-02-27 19:44:34 +09001057 struct kvm_userspace_memory_region *mem,
1058 enum kvm_mr_change change)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001059{
Nick Wangdd2887e2013-03-25 17:22:57 +01001060 /* A few sanity checks. We can have memory slots which have to be
1061 located/ended at a segment boundary (1MB). The memory in userland is
1062 ok to be fragmented into various different vmas. It is okay to mmap()
1063 and munmap() stuff in this slot after doing this call at any time */
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001064
Carsten Otte598841c2011-07-24 10:48:21 +02001065 if (mem->userspace_addr & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001066 return -EINVAL;
1067
Carsten Otte598841c2011-07-24 10:48:21 +02001068 if (mem->memory_size & 0xffffful)
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001069 return -EINVAL;
1070
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001071 return 0;
1072}
1073
1074void kvm_arch_commit_memory_region(struct kvm *kvm,
1075 struct kvm_userspace_memory_region *mem,
Takuya Yoshikawa84826442013-02-27 19:45:25 +09001076 const struct kvm_memory_slot *old,
1077 enum kvm_mr_change change)
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001078{
Carsten Ottef7850c92011-07-24 10:48:23 +02001079 int rc;
Marcelo Tosattif7784b82009-12-23 14:35:18 -02001080
Christian Borntraeger2cef4de2013-03-25 17:22:48 +01001081 /* If the basics of the memslot do not change, we do not want
1082 * to update the gmap. Every update causes several unnecessary
1083 * segment translation exceptions. This is usually handled just
1084 * fine by the normal fault handler + gmap, but it will also
1085 * cause faults on the prefix page of running guest CPUs.
1086 */
1087 if (old->userspace_addr == mem->userspace_addr &&
1088 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1089 old->npages * PAGE_SIZE == mem->memory_size)
1090 return;
Carsten Otte598841c2011-07-24 10:48:21 +02001091
1092 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1093 mem->guest_phys_addr, mem->memory_size);
1094 if (rc)
Carsten Ottef7850c92011-07-24 10:48:23 +02001095 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
Carsten Otte598841c2011-07-24 10:48:21 +02001096 return;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001097}
1098
Marcelo Tosatti2df72e92012-08-24 15:54:57 -03001099void kvm_arch_flush_shadow_all(struct kvm *kvm)
1100{
1101}
1102
1103void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1104 struct kvm_memory_slot *slot)
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -03001105{
1106}
1107
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001108static int __init kvm_s390_init(void)
1109{
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001110 int ret;
Avi Kivity0ee75be2010-04-28 15:39:01 +03001111 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001112 if (ret)
1113 return ret;
1114
1115 /*
1116 * guests can ask for up to 255+1 double words, we need a full page
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001117 * to hold the maximum amount of facilities. On the other hand, we
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001118 * only set facilities that are known to work in KVM.
1119 */
Heiko Carstensc2f0e8c2010-06-08 18:58:09 +02001120 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001121 if (!facilities) {
1122 kvm_exit();
1123 return -ENOMEM;
1124 }
Martin Schwidefsky14375bc2010-10-25 16:10:51 +02001125 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
Christian Borntraeger6d00d002010-10-25 16:10:48 +02001126 facilities[0] &= 0xff00fff3f47c0000ULL;
Christian Borntraeger87cac8f2012-10-02 16:25:38 +02001127 facilities[1] &= 0x001c000000000000ULL;
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001128 return 0;
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001129}
1130
1131static void __exit kvm_s390_exit(void)
1132{
Christian Borntraegeref50f7a2009-06-23 17:24:07 +02001133 free_page((unsigned long) facilities);
Heiko Carstensb0c632d2008-03-25 18:47:20 +01001134 kvm_exit();
1135}
1136
1137module_init(kvm_s390_init);
1138module_exit(kvm_s390_exit);