Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 1 | /* |
| 2 | * s390host.c -- hosting zSeries kernel virtual machines |
| 3 | * |
Christian Ehrhardt | 628eb9b | 2009-05-25 13:40:51 +0200 | [diff] [blame] | 4 | * Copyright IBM Corp. 2008,2009 |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License (version 2 only) |
| 8 | * as published by the Free Software Foundation. |
| 9 | * |
| 10 | * Author(s): Carsten Otte <cotte@de.ibm.com> |
| 11 | * Christian Borntraeger <borntraeger@de.ibm.com> |
| 12 | * Heiko Carstens <heiko.carstens@de.ibm.com> |
Christian Ehrhardt | 628eb9b | 2009-05-25 13:40:51 +0200 | [diff] [blame] | 13 | * Christian Ehrhardt <ehrhardt@de.ibm.com> |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 14 | */ |
| 15 | |
| 16 | #include <linux/compiler.h> |
| 17 | #include <linux/err.h> |
| 18 | #include <linux/fs.h> |
Christian Borntraeger | ca87230 | 2009-05-12 17:21:49 +0200 | [diff] [blame] | 19 | #include <linux/hrtimer.h> |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 20 | #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 Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 25 | #include <linux/timer.h> |
Heiko Carstens | cbb870c | 2010-02-26 22:37:43 +0100 | [diff] [blame] | 26 | #include <asm/asm-offsets.h> |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 27 | #include <asm/lowcore.h> |
| 28 | #include <asm/pgtable.h> |
Heiko Carstens | f5daba1 | 2009-03-26 15:24:01 +0100 | [diff] [blame] | 29 | #include <asm/nmi.h> |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 30 | #include <asm/system.h> |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 31 | #include "kvm-s390.h" |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 32 | #include "gaccess.h" |
| 33 | |
| 34 | #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU |
| 35 | |
| 36 | struct kvm_stats_debugfs_item debugfs_entries[] = { |
| 37 | { "userspace_handled", VCPU_STAT(exit_userspace) }, |
Christian Borntraeger | 0eaeafa | 2008-05-07 09:22:53 +0200 | [diff] [blame] | 38 | { "exit_null", VCPU_STAT(exit_null) }, |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 39 | { "exit_validity", VCPU_STAT(exit_validity) }, |
| 40 | { "exit_stop_request", VCPU_STAT(exit_stop_request) }, |
| 41 | { "exit_external_request", VCPU_STAT(exit_external_request) }, |
| 42 | { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 43 | { "exit_instruction", VCPU_STAT(exit_instruction) }, |
| 44 | { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, |
| 45 | { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, |
Christian Borntraeger | f5e10b0 | 2008-07-25 15:52:44 +0200 | [diff] [blame] | 46 | { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 47 | { "instruction_lctl", VCPU_STAT(instruction_lctl) }, |
| 48 | { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, |
Christian Ehrhardt | 7697e71f | 2011-10-18 12:27:15 +0200 | [diff] [blame] | 49 | { "deliver_external_call", VCPU_STAT(deliver_external_call) }, |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 50 | { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, |
| 51 | { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, |
| 52 | { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, |
| 53 | { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, |
| 54 | { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, |
| 55 | { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, |
| 56 | { "exit_wait_state", VCPU_STAT(exit_wait_state) }, |
Christian Borntraeger | 453423d | 2008-03-25 18:47:29 +0100 | [diff] [blame] | 57 | { "instruction_stidp", VCPU_STAT(instruction_stidp) }, |
| 58 | { "instruction_spx", VCPU_STAT(instruction_spx) }, |
| 59 | { "instruction_stpx", VCPU_STAT(instruction_stpx) }, |
| 60 | { "instruction_stap", VCPU_STAT(instruction_stap) }, |
| 61 | { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, |
| 62 | { "instruction_stsch", VCPU_STAT(instruction_stsch) }, |
| 63 | { "instruction_chsc", VCPU_STAT(instruction_chsc) }, |
| 64 | { "instruction_stsi", VCPU_STAT(instruction_stsi) }, |
| 65 | { "instruction_stfl", VCPU_STAT(instruction_stfl) }, |
Christian Borntraeger | bb25b9b | 2011-07-24 10:48:17 +0200 | [diff] [blame] | 66 | { "instruction_tprot", VCPU_STAT(instruction_tprot) }, |
Christian Borntraeger | 5288fbf | 2008-03-25 18:47:31 +0100 | [diff] [blame] | 67 | { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, |
Cornelia Huck | bd59d3a | 2011-11-17 11:00:42 +0100 | [diff] [blame] | 68 | { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, |
Christian Ehrhardt | 7697e71f | 2011-10-18 12:27:15 +0200 | [diff] [blame] | 69 | { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, |
Christian Borntraeger | 5288fbf | 2008-03-25 18:47:31 +0100 | [diff] [blame] | 70 | { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, |
| 71 | { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, |
| 72 | { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, |
| 73 | { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, |
| 74 | { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, |
Christian Borntraeger | 388186b | 2011-10-30 15:17:03 +0100 | [diff] [blame] | 75 | { "diagnose_10", VCPU_STAT(diagnose_10) }, |
Christian Borntraeger | e28acfe | 2008-03-25 18:47:34 +0100 | [diff] [blame] | 76 | { "diagnose_44", VCPU_STAT(diagnose_44) }, |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 77 | { NULL } |
| 78 | }; |
| 79 | |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 80 | static unsigned long long *facilities; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 81 | |
| 82 | /* Section: not file related */ |
Alexander Graf | 10474ae | 2009-09-15 11:37:46 +0200 | [diff] [blame] | 83 | int kvm_arch_hardware_enable(void *garbage) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 84 | { |
| 85 | /* every s390 is virtualization enabled ;-) */ |
Alexander Graf | 10474ae | 2009-09-15 11:37:46 +0200 | [diff] [blame] | 86 | return 0; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | void kvm_arch_hardware_disable(void *garbage) |
| 90 | { |
| 91 | } |
| 92 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 93 | int kvm_arch_hardware_setup(void) |
| 94 | { |
| 95 | return 0; |
| 96 | } |
| 97 | |
| 98 | void kvm_arch_hardware_unsetup(void) |
| 99 | { |
| 100 | } |
| 101 | |
| 102 | void kvm_arch_check_processor_compat(void *rtn) |
| 103 | { |
| 104 | } |
| 105 | |
| 106 | int kvm_arch_init(void *opaque) |
| 107 | { |
| 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | void kvm_arch_exit(void) |
| 112 | { |
| 113 | } |
| 114 | |
| 115 | /* Section: device related */ |
| 116 | long kvm_arch_dev_ioctl(struct file *filp, |
| 117 | unsigned int ioctl, unsigned long arg) |
| 118 | { |
| 119 | if (ioctl == KVM_S390_ENABLE_SIE) |
| 120 | return s390_enable_sie(); |
| 121 | return -EINVAL; |
| 122 | } |
| 123 | |
| 124 | int kvm_dev_ioctl_check_extension(long ext) |
| 125 | { |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 126 | int r; |
| 127 | |
Carsten Otte | 2bd0ac4 | 2008-07-25 15:49:13 +0200 | [diff] [blame] | 128 | switch (ext) { |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 129 | case KVM_CAP_S390_PSW: |
Christian Borntraeger | b6cf878 | 2011-09-20 17:07:29 +0200 | [diff] [blame] | 130 | case KVM_CAP_S390_GMAP: |
Christian Borntraeger | 52e16b1 | 2011-11-17 11:00:44 +0100 | [diff] [blame] | 131 | case KVM_CAP_SYNC_MMU: |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 132 | r = 1; |
| 133 | break; |
Carsten Otte | 2bd0ac4 | 2008-07-25 15:49:13 +0200 | [diff] [blame] | 134 | default: |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 135 | r = 0; |
Carsten Otte | 2bd0ac4 | 2008-07-25 15:49:13 +0200 | [diff] [blame] | 136 | } |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 137 | return r; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | /* Section: vm related */ |
| 141 | /* |
| 142 | * Get (and clear) the dirty memory log for a memory slot. |
| 143 | */ |
| 144 | int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, |
| 145 | struct kvm_dirty_log *log) |
| 146 | { |
| 147 | return 0; |
| 148 | } |
| 149 | |
| 150 | long kvm_arch_vm_ioctl(struct file *filp, |
| 151 | unsigned int ioctl, unsigned long arg) |
| 152 | { |
| 153 | struct kvm *kvm = filp->private_data; |
| 154 | void __user *argp = (void __user *)arg; |
| 155 | int r; |
| 156 | |
| 157 | switch (ioctl) { |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 158 | case KVM_S390_INTERRUPT: { |
| 159 | struct kvm_s390_interrupt s390int; |
| 160 | |
| 161 | r = -EFAULT; |
| 162 | if (copy_from_user(&s390int, argp, sizeof(s390int))) |
| 163 | break; |
| 164 | r = kvm_s390_inject_vm(kvm, &s390int); |
| 165 | break; |
| 166 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 167 | default: |
Avi Kivity | 367e131 | 2009-08-26 14:57:07 +0300 | [diff] [blame] | 168 | r = -ENOTTY; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | return r; |
| 172 | } |
| 173 | |
Carsten Otte | e08b963 | 2012-01-04 10:25:20 +0100 | [diff] [blame] | 174 | int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 175 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 176 | int rc; |
| 177 | char debug_name[16]; |
| 178 | |
Carsten Otte | e08b963 | 2012-01-04 10:25:20 +0100 | [diff] [blame] | 179 | rc = -EINVAL; |
| 180 | #ifdef CONFIG_KVM_S390_UCONTROL |
| 181 | if (type & ~KVM_VM_S390_UCONTROL) |
| 182 | goto out_err; |
| 183 | if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) |
| 184 | goto out_err; |
| 185 | #else |
| 186 | if (type) |
| 187 | goto out_err; |
| 188 | #endif |
| 189 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 190 | rc = s390_enable_sie(); |
| 191 | if (rc) |
Jan Kiszka | d89f5ef | 2010-11-09 17:02:49 +0100 | [diff] [blame] | 192 | goto out_err; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 193 | |
Carsten Otte | b290411 | 2011-10-18 12:27:13 +0200 | [diff] [blame] | 194 | rc = -ENOMEM; |
| 195 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 196 | kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); |
| 197 | if (!kvm->arch.sca) |
Jan Kiszka | d89f5ef | 2010-11-09 17:02:49 +0100 | [diff] [blame] | 198 | goto out_err; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 199 | |
| 200 | sprintf(debug_name, "kvm-%u", current->pid); |
| 201 | |
| 202 | kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); |
| 203 | if (!kvm->arch.dbf) |
| 204 | goto out_nodbf; |
| 205 | |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 206 | spin_lock_init(&kvm->arch.float_int.lock); |
| 207 | INIT_LIST_HEAD(&kvm->arch.float_int.list); |
| 208 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 209 | debug_register_view(kvm->arch.dbf, &debug_sprintf_view); |
| 210 | VM_EVENT(kvm, 3, "%s", "vm created"); |
| 211 | |
Carsten Otte | e08b963 | 2012-01-04 10:25:20 +0100 | [diff] [blame] | 212 | if (type & KVM_VM_S390_UCONTROL) { |
| 213 | kvm->arch.gmap = NULL; |
| 214 | } else { |
| 215 | kvm->arch.gmap = gmap_alloc(current->mm); |
| 216 | if (!kvm->arch.gmap) |
| 217 | goto out_nogmap; |
| 218 | } |
Jan Kiszka | d89f5ef | 2010-11-09 17:02:49 +0100 | [diff] [blame] | 219 | return 0; |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 220 | out_nogmap: |
| 221 | debug_unregister(kvm->arch.dbf); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 222 | out_nodbf: |
| 223 | free_page((unsigned long)(kvm->arch.sca)); |
Jan Kiszka | d89f5ef | 2010-11-09 17:02:49 +0100 | [diff] [blame] | 224 | out_err: |
| 225 | return rc; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 226 | } |
| 227 | |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 228 | void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) |
| 229 | { |
| 230 | VCPU_EVENT(vcpu, 3, "%s", "free cpu"); |
Carsten Otte | 58f9460 | 2012-01-04 10:25:27 +0100 | [diff] [blame^] | 231 | if (!kvm_is_ucontrol(vcpu->kvm)) { |
| 232 | clear_bit(63 - vcpu->vcpu_id, |
| 233 | (unsigned long *) &vcpu->kvm->arch.sca->mcn); |
| 234 | if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == |
| 235 | (__u64) vcpu->arch.sie_block) |
| 236 | vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; |
| 237 | } |
Carsten Otte | abf4a71 | 2009-05-12 17:21:51 +0200 | [diff] [blame] | 238 | smp_mb(); |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 239 | |
| 240 | if (kvm_is_ucontrol(vcpu->kvm)) |
| 241 | gmap_free(vcpu->arch.gmap); |
| 242 | |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 243 | free_page((unsigned long)(vcpu->arch.sie_block)); |
Christian Borntraeger | 6692cef | 2008-11-26 14:51:08 +0100 | [diff] [blame] | 244 | kvm_vcpu_uninit(vcpu); |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 245 | kfree(vcpu); |
| 246 | } |
| 247 | |
| 248 | static void kvm_free_vcpus(struct kvm *kvm) |
| 249 | { |
| 250 | unsigned int i; |
Gleb Natapov | 988a2ca | 2009-06-09 15:56:29 +0300 | [diff] [blame] | 251 | struct kvm_vcpu *vcpu; |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 252 | |
Gleb Natapov | 988a2ca | 2009-06-09 15:56:29 +0300 | [diff] [blame] | 253 | kvm_for_each_vcpu(i, vcpu, kvm) |
| 254 | kvm_arch_vcpu_destroy(vcpu); |
| 255 | |
| 256 | mutex_lock(&kvm->lock); |
| 257 | for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) |
| 258 | kvm->vcpus[i] = NULL; |
| 259 | |
| 260 | atomic_set(&kvm->online_vcpus, 0); |
| 261 | mutex_unlock(&kvm->lock); |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 262 | } |
| 263 | |
Sheng Yang | ad8ba2c | 2009-01-06 10:03:02 +0800 | [diff] [blame] | 264 | void kvm_arch_sync_events(struct kvm *kvm) |
| 265 | { |
| 266 | } |
| 267 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 268 | void kvm_arch_destroy_vm(struct kvm *kvm) |
| 269 | { |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 270 | kvm_free_vcpus(kvm); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 271 | free_page((unsigned long)(kvm->arch.sca)); |
Christian Borntraeger | d329c03 | 2008-11-26 14:50:27 +0100 | [diff] [blame] | 272 | debug_unregister(kvm->arch.dbf); |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 273 | if (!kvm_is_ucontrol(kvm)) |
| 274 | gmap_free(kvm->arch.gmap); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | /* Section: vcpu related */ |
| 278 | int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) |
| 279 | { |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 280 | if (kvm_is_ucontrol(vcpu->kvm)) { |
| 281 | vcpu->arch.gmap = gmap_alloc(current->mm); |
| 282 | if (!vcpu->arch.gmap) |
| 283 | return -ENOMEM; |
| 284 | return 0; |
| 285 | } |
| 286 | |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 287 | vcpu->arch.gmap = vcpu->kvm->arch.gmap; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 288 | return 0; |
| 289 | } |
| 290 | |
| 291 | void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) |
| 292 | { |
Christian Borntraeger | 6692cef | 2008-11-26 14:51:08 +0100 | [diff] [blame] | 293 | /* Nothing todo */ |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 294 | } |
| 295 | |
| 296 | void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) |
| 297 | { |
| 298 | save_fp_regs(&vcpu->arch.host_fpregs); |
| 299 | save_access_regs(vcpu->arch.host_acrs); |
| 300 | vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK; |
| 301 | restore_fp_regs(&vcpu->arch.guest_fpregs); |
| 302 | restore_access_regs(vcpu->arch.guest_acrs); |
Christian Borntraeger | 480e592 | 2011-09-20 17:07:28 +0200 | [diff] [blame] | 303 | gmap_enable(vcpu->arch.gmap); |
Cornelia Huck | 9e6dabe | 2011-11-17 11:00:41 +0100 | [diff] [blame] | 304 | atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) |
| 308 | { |
Cornelia Huck | 9e6dabe | 2011-11-17 11:00:41 +0100 | [diff] [blame] | 309 | atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); |
Christian Borntraeger | 480e592 | 2011-09-20 17:07:28 +0200 | [diff] [blame] | 310 | gmap_disable(vcpu->arch.gmap); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 311 | save_fp_regs(&vcpu->arch.guest_fpregs); |
| 312 | save_access_regs(vcpu->arch.guest_acrs); |
| 313 | restore_fp_regs(&vcpu->arch.host_fpregs); |
| 314 | restore_access_regs(vcpu->arch.host_acrs); |
| 315 | } |
| 316 | |
| 317 | static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) |
| 318 | { |
| 319 | /* this equals initial cpu reset in pop, but we don't switch to ESA */ |
| 320 | vcpu->arch.sie_block->gpsw.mask = 0UL; |
| 321 | vcpu->arch.sie_block->gpsw.addr = 0UL; |
| 322 | vcpu->arch.sie_block->prefix = 0UL; |
| 323 | vcpu->arch.sie_block->ihcpu = 0xffff; |
| 324 | vcpu->arch.sie_block->cputm = 0UL; |
| 325 | vcpu->arch.sie_block->ckc = 0UL; |
| 326 | vcpu->arch.sie_block->todpr = 0; |
| 327 | memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); |
| 328 | vcpu->arch.sie_block->gcr[0] = 0xE0UL; |
| 329 | vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; |
| 330 | vcpu->arch.guest_fpregs.fpc = 0; |
| 331 | asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); |
| 332 | vcpu->arch.sie_block->gbea = 1; |
| 333 | } |
| 334 | |
| 335 | int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) |
| 336 | { |
Cornelia Huck | 9e6dabe | 2011-11-17 11:00:41 +0100 | [diff] [blame] | 337 | atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | |
| 338 | CPUSTAT_SM | |
| 339 | CPUSTAT_STOPPED); |
Christian Borntraeger | fc34531 | 2010-06-17 23:16:20 +0200 | [diff] [blame] | 340 | vcpu->arch.sie_block->ecb = 6; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 341 | vcpu->arch.sie_block->eca = 0xC1002001U; |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 342 | vcpu->arch.sie_block->fac = (int) (long) facilities; |
Christian Borntraeger | ca87230 | 2009-05-12 17:21:49 +0200 | [diff] [blame] | 343 | hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); |
| 344 | tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet, |
| 345 | (unsigned long) vcpu); |
| 346 | vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; |
Christian Borntraeger | 453423d | 2008-03-25 18:47:29 +0100 | [diff] [blame] | 347 | get_cpu_id(&vcpu->arch.cpu_id); |
Christian Borntraeger | 92e6ecf | 2009-03-26 15:23:58 +0100 | [diff] [blame] | 348 | vcpu->arch.cpu_id.version = 0xff; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 349 | return 0; |
| 350 | } |
| 351 | |
| 352 | struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, |
| 353 | unsigned int id) |
| 354 | { |
Carsten Otte | 4d47555 | 2011-10-18 12:27:12 +0200 | [diff] [blame] | 355 | struct kvm_vcpu *vcpu; |
| 356 | int rc = -EINVAL; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 357 | |
Carsten Otte | 4d47555 | 2011-10-18 12:27:12 +0200 | [diff] [blame] | 358 | if (id >= KVM_MAX_VCPUS) |
| 359 | goto out; |
| 360 | |
| 361 | rc = -ENOMEM; |
| 362 | |
| 363 | vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 364 | if (!vcpu) |
Carsten Otte | 4d47555 | 2011-10-18 12:27:12 +0200 | [diff] [blame] | 365 | goto out; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 366 | |
Christian Borntraeger | 180c12f | 2008-06-27 15:05:40 +0200 | [diff] [blame] | 367 | vcpu->arch.sie_block = (struct kvm_s390_sie_block *) |
| 368 | get_zeroed_page(GFP_KERNEL); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 369 | |
| 370 | if (!vcpu->arch.sie_block) |
| 371 | goto out_free_cpu; |
| 372 | |
| 373 | vcpu->arch.sie_block->icpua = id; |
Carsten Otte | 58f9460 | 2012-01-04 10:25:27 +0100 | [diff] [blame^] | 374 | if (!kvm_is_ucontrol(kvm)) { |
| 375 | if (!kvm->arch.sca) { |
| 376 | WARN_ON_ONCE(1); |
| 377 | goto out_free_cpu; |
| 378 | } |
| 379 | if (!kvm->arch.sca->cpu[id].sda) |
| 380 | kvm->arch.sca->cpu[id].sda = |
| 381 | (__u64) vcpu->arch.sie_block; |
| 382 | vcpu->arch.sie_block->scaoh = |
| 383 | (__u32)(((__u64)kvm->arch.sca) >> 32); |
| 384 | vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; |
| 385 | set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); |
| 386 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 387 | |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 388 | spin_lock_init(&vcpu->arch.local_int.lock); |
| 389 | INIT_LIST_HEAD(&vcpu->arch.local_int.list); |
| 390 | vcpu->arch.local_int.float_int = &kvm->arch.float_int; |
Christian Borntraeger | b037a4f | 2009-05-12 17:21:50 +0200 | [diff] [blame] | 391 | spin_lock(&kvm->arch.float_int.lock); |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 392 | kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int; |
| 393 | init_waitqueue_head(&vcpu->arch.local_int.wq); |
Christian Borntraeger | 5288fbf | 2008-03-25 18:47:31 +0100 | [diff] [blame] | 394 | vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; |
Christian Borntraeger | b037a4f | 2009-05-12 17:21:50 +0200 | [diff] [blame] | 395 | spin_unlock(&kvm->arch.float_int.lock); |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 396 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 397 | rc = kvm_vcpu_init(vcpu, kvm, id); |
| 398 | if (rc) |
Wei Yongjun | 7b06bf2 | 2010-03-09 14:37:53 +0800 | [diff] [blame] | 399 | goto out_free_sie_block; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 400 | VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, |
| 401 | vcpu->arch.sie_block); |
| 402 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 403 | return vcpu; |
Wei Yongjun | 7b06bf2 | 2010-03-09 14:37:53 +0800 | [diff] [blame] | 404 | out_free_sie_block: |
| 405 | free_page((unsigned long)(vcpu->arch.sie_block)); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 406 | out_free_cpu: |
| 407 | kfree(vcpu); |
Carsten Otte | 4d47555 | 2011-10-18 12:27:12 +0200 | [diff] [blame] | 408 | out: |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 409 | return ERR_PTR(rc); |
| 410 | } |
| 411 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 412 | int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) |
| 413 | { |
| 414 | /* kvm common code refers to this, but never calls it */ |
| 415 | BUG(); |
| 416 | return 0; |
| 417 | } |
| 418 | |
| 419 | static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) |
| 420 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 421 | kvm_s390_vcpu_initial_reset(vcpu); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 422 | return 0; |
| 423 | } |
| 424 | |
| 425 | int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) |
| 426 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 427 | memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs)); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 428 | return 0; |
| 429 | } |
| 430 | |
| 431 | int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) |
| 432 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 433 | memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs)); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 434 | return 0; |
| 435 | } |
| 436 | |
| 437 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, |
| 438 | struct kvm_sregs *sregs) |
| 439 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 440 | memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs)); |
| 441 | memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); |
Carsten Otte | 7eef87d | 2011-10-18 12:27:14 +0200 | [diff] [blame] | 442 | restore_access_regs(vcpu->arch.guest_acrs); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 443 | return 0; |
| 444 | } |
| 445 | |
| 446 | int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, |
| 447 | struct kvm_sregs *sregs) |
| 448 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 449 | memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs)); |
| 450 | memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 451 | return 0; |
| 452 | } |
| 453 | |
| 454 | int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) |
| 455 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 456 | memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); |
| 457 | vcpu->arch.guest_fpregs.fpc = fpu->fpc; |
Carsten Otte | 7eef87d | 2011-10-18 12:27:14 +0200 | [diff] [blame] | 458 | restore_fp_regs(&vcpu->arch.guest_fpregs); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 459 | return 0; |
| 460 | } |
| 461 | |
| 462 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) |
| 463 | { |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 464 | memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); |
| 465 | fpu->fpc = vcpu->arch.guest_fpregs.fpc; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 466 | return 0; |
| 467 | } |
| 468 | |
| 469 | static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) |
| 470 | { |
| 471 | int rc = 0; |
| 472 | |
Cornelia Huck | 9e6dabe | 2011-11-17 11:00:41 +0100 | [diff] [blame] | 473 | if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED)) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 474 | rc = -EBUSY; |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 475 | else { |
| 476 | vcpu->run->psw_mask = psw.mask; |
| 477 | vcpu->run->psw_addr = psw.addr; |
| 478 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 479 | return rc; |
| 480 | } |
| 481 | |
| 482 | int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, |
| 483 | struct kvm_translation *tr) |
| 484 | { |
| 485 | return -EINVAL; /* not implemented yet */ |
| 486 | } |
| 487 | |
Jan Kiszka | d0bfb94 | 2008-12-15 13:52:10 +0100 | [diff] [blame] | 488 | int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, |
| 489 | struct kvm_guest_debug *dbg) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 490 | { |
| 491 | return -EINVAL; /* not implemented yet */ |
| 492 | } |
| 493 | |
Marcelo Tosatti | 62d9f0d | 2008-04-11 13:24:45 -0300 | [diff] [blame] | 494 | int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, |
| 495 | struct kvm_mp_state *mp_state) |
| 496 | { |
| 497 | return -EINVAL; /* not implemented yet */ |
| 498 | } |
| 499 | |
| 500 | int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, |
| 501 | struct kvm_mp_state *mp_state) |
| 502 | { |
| 503 | return -EINVAL; /* not implemented yet */ |
| 504 | } |
| 505 | |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 506 | static int __vcpu_run(struct kvm_vcpu *vcpu) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 507 | { |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 508 | int rc; |
| 509 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 510 | memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16); |
| 511 | |
| 512 | if (need_resched()) |
| 513 | schedule(); |
| 514 | |
Christian Borntraeger | 71cde58 | 2008-05-21 13:37:34 +0200 | [diff] [blame] | 515 | if (test_thread_flag(TIF_MCCK_PENDING)) |
| 516 | s390_handle_mcck(); |
| 517 | |
Carsten Otte | d6b6d16 | 2012-01-04 10:25:25 +0100 | [diff] [blame] | 518 | if (!kvm_is_ucontrol(vcpu->kvm)) |
| 519 | kvm_s390_deliver_pending_interrupts(vcpu); |
Carsten Otte | 0ff3186 | 2008-05-21 13:37:37 +0200 | [diff] [blame] | 520 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 521 | vcpu->arch.sie_block->icptcode = 0; |
| 522 | local_irq_disable(); |
| 523 | kvm_guest_enter(); |
| 524 | local_irq_enable(); |
| 525 | VCPU_EVENT(vcpu, 6, "entering sie flags %x", |
| 526 | atomic_read(&vcpu->arch.sie_block->cpuflags)); |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 527 | rc = sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs); |
| 528 | if (rc) { |
| 529 | if (kvm_is_ucontrol(vcpu->kvm)) { |
| 530 | rc = SIE_INTERCEPT_UCONTROL; |
| 531 | } else { |
| 532 | VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); |
| 533 | kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); |
| 534 | rc = 0; |
| 535 | } |
Carsten Otte | 1f0d0f0 | 2008-05-21 13:37:40 +0200 | [diff] [blame] | 536 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 537 | VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", |
| 538 | vcpu->arch.sie_block->icptcode); |
| 539 | local_irq_disable(); |
| 540 | kvm_guest_exit(); |
| 541 | local_irq_enable(); |
| 542 | |
| 543 | memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16); |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 544 | return rc; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 545 | } |
| 546 | |
| 547 | int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) |
| 548 | { |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 549 | int rc; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 550 | sigset_t sigsaved; |
| 551 | |
Christian Ehrhardt | 9ace903 | 2009-05-20 15:34:55 +0200 | [diff] [blame] | 552 | rerun_vcpu: |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 553 | if (vcpu->sigset_active) |
| 554 | sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); |
| 555 | |
Cornelia Huck | 9e6dabe | 2011-11-17 11:00:41 +0100 | [diff] [blame] | 556 | atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 557 | |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 558 | BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL); |
| 559 | |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 560 | switch (kvm_run->exit_reason) { |
| 561 | case KVM_EXIT_S390_SIEIC: |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 562 | case KVM_EXIT_UNKNOWN: |
Christian Ehrhardt | 9ace903 | 2009-05-20 15:34:55 +0200 | [diff] [blame] | 563 | case KVM_EXIT_INTR: |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 564 | case KVM_EXIT_S390_RESET: |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 565 | case KVM_EXIT_S390_UCONTROL: |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 566 | break; |
| 567 | default: |
| 568 | BUG(); |
| 569 | } |
| 570 | |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 571 | vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; |
| 572 | vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; |
| 573 | |
Heiko Carstens | dab4079d | 2009-06-12 10:26:32 +0200 | [diff] [blame] | 574 | might_fault(); |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 575 | |
| 576 | do { |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 577 | rc = __vcpu_run(vcpu); |
| 578 | if (rc) |
| 579 | break; |
Carsten Otte | c0d744a | 2012-01-04 10:25:24 +0100 | [diff] [blame] | 580 | if (kvm_is_ucontrol(vcpu->kvm)) |
| 581 | rc = -EOPNOTSUPP; |
| 582 | else |
| 583 | rc = kvm_handle_sie_intercept(vcpu); |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 584 | } while (!signal_pending(current) && !rc); |
| 585 | |
Christian Ehrhardt | 9ace903 | 2009-05-20 15:34:55 +0200 | [diff] [blame] | 586 | if (rc == SIE_INTERCEPT_RERUNVCPU) |
| 587 | goto rerun_vcpu; |
| 588 | |
Christian Ehrhardt | b1d16c4 | 2009-05-20 15:34:56 +0200 | [diff] [blame] | 589 | if (signal_pending(current) && !rc) { |
| 590 | kvm_run->exit_reason = KVM_EXIT_INTR; |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 591 | rc = -EINTR; |
Christian Ehrhardt | b1d16c4 | 2009-05-20 15:34:56 +0200 | [diff] [blame] | 592 | } |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 593 | |
Carsten Otte | e168bf8 | 2012-01-04 10:25:22 +0100 | [diff] [blame] | 594 | #ifdef CONFIG_KVM_S390_UCONTROL |
| 595 | if (rc == SIE_INTERCEPT_UCONTROL) { |
| 596 | kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL; |
| 597 | kvm_run->s390_ucontrol.trans_exc_code = |
| 598 | current->thread.gmap_addr; |
| 599 | kvm_run->s390_ucontrol.pgm_code = 0x10; |
| 600 | rc = 0; |
| 601 | } |
| 602 | #endif |
| 603 | |
Heiko Carstens | b8e660b | 2010-02-26 22:37:41 +0100 | [diff] [blame] | 604 | if (rc == -EOPNOTSUPP) { |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 605 | /* intercept cannot be handled in-kernel, prepare kvm-run */ |
| 606 | kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; |
| 607 | kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; |
Christian Borntraeger | 8f2abe6 | 2008-03-25 18:47:23 +0100 | [diff] [blame] | 608 | kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; |
| 609 | kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; |
| 610 | rc = 0; |
| 611 | } |
| 612 | |
| 613 | if (rc == -EREMOTE) { |
| 614 | /* intercept was handled, but userspace support is needed |
| 615 | * kvm_run has been prepared by the handler */ |
| 616 | rc = 0; |
| 617 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 618 | |
Carsten Otte | d7b0b5e | 2009-11-19 14:21:16 +0100 | [diff] [blame] | 619 | kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; |
| 620 | kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; |
| 621 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 622 | if (vcpu->sigset_active) |
| 623 | sigprocmask(SIG_SETMASK, &sigsaved, NULL); |
| 624 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 625 | vcpu->stat.exit_userspace++; |
Heiko Carstens | 7e8e6ab | 2008-04-04 15:12:35 +0200 | [diff] [blame] | 626 | return rc; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 627 | } |
| 628 | |
Carsten Otte | 092670c | 2011-07-24 10:48:22 +0200 | [diff] [blame] | 629 | static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from, |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 630 | unsigned long n, int prefix) |
| 631 | { |
| 632 | if (prefix) |
| 633 | return copy_to_guest(vcpu, guestdest, from, n); |
| 634 | else |
| 635 | return copy_to_guest_absolute(vcpu, guestdest, from, n); |
| 636 | } |
| 637 | |
| 638 | /* |
| 639 | * store status at address |
| 640 | * we use have two special cases: |
| 641 | * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit |
| 642 | * KVM_S390_STORE_STATUS_PREFIXED: -> prefix |
| 643 | */ |
Christian Borntraeger | 971eb77 | 2010-06-12 08:54:13 +0200 | [diff] [blame] | 644 | int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 645 | { |
Carsten Otte | 092670c | 2011-07-24 10:48:22 +0200 | [diff] [blame] | 646 | unsigned char archmode = 1; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 647 | int prefix; |
| 648 | |
| 649 | if (addr == KVM_S390_STORE_STATUS_NOADDR) { |
| 650 | if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) |
| 651 | return -EFAULT; |
| 652 | addr = SAVE_AREA_BASE; |
| 653 | prefix = 0; |
| 654 | } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { |
| 655 | if (copy_to_guest(vcpu, 163ul, &archmode, 1)) |
| 656 | return -EFAULT; |
| 657 | addr = SAVE_AREA_BASE; |
| 658 | prefix = 1; |
| 659 | } else |
| 660 | prefix = 0; |
| 661 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 662 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 663 | vcpu->arch.guest_fpregs.fprs, 128, prefix)) |
| 664 | return -EFAULT; |
| 665 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 666 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 667 | vcpu->arch.guest_gprs, 128, prefix)) |
| 668 | return -EFAULT; |
| 669 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 670 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 671 | &vcpu->arch.sie_block->gpsw, 16, prefix)) |
| 672 | return -EFAULT; |
| 673 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 674 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 675 | &vcpu->arch.sie_block->prefix, 4, prefix)) |
| 676 | return -EFAULT; |
| 677 | |
| 678 | if (__guestcopy(vcpu, |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 679 | addr + offsetof(struct save_area, fp_ctrl_reg), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 680 | &vcpu->arch.guest_fpregs.fpc, 4, prefix)) |
| 681 | return -EFAULT; |
| 682 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 683 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 684 | &vcpu->arch.sie_block->todpr, 4, prefix)) |
| 685 | return -EFAULT; |
| 686 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 687 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 688 | &vcpu->arch.sie_block->cputm, 8, prefix)) |
| 689 | return -EFAULT; |
| 690 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 691 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 692 | &vcpu->arch.sie_block->ckc, 8, prefix)) |
| 693 | return -EFAULT; |
| 694 | |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 695 | if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 696 | &vcpu->arch.guest_acrs, 64, prefix)) |
| 697 | return -EFAULT; |
| 698 | |
| 699 | if (__guestcopy(vcpu, |
Heiko Carstens | f64ca21 | 2010-02-26 22:37:32 +0100 | [diff] [blame] | 700 | addr + offsetof(struct save_area, ctrl_regs), |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 701 | &vcpu->arch.sie_block->gcr, 128, prefix)) |
| 702 | return -EFAULT; |
| 703 | return 0; |
| 704 | } |
| 705 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 706 | long kvm_arch_vcpu_ioctl(struct file *filp, |
| 707 | unsigned int ioctl, unsigned long arg) |
| 708 | { |
| 709 | struct kvm_vcpu *vcpu = filp->private_data; |
| 710 | void __user *argp = (void __user *)arg; |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 711 | long r; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 712 | |
Avi Kivity | 93736624 | 2010-05-13 12:35:17 +0300 | [diff] [blame] | 713 | switch (ioctl) { |
| 714 | case KVM_S390_INTERRUPT: { |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 715 | struct kvm_s390_interrupt s390int; |
| 716 | |
Avi Kivity | 93736624 | 2010-05-13 12:35:17 +0300 | [diff] [blame] | 717 | r = -EFAULT; |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 718 | if (copy_from_user(&s390int, argp, sizeof(s390int))) |
Avi Kivity | 93736624 | 2010-05-13 12:35:17 +0300 | [diff] [blame] | 719 | break; |
| 720 | r = kvm_s390_inject_vcpu(vcpu, &s390int); |
| 721 | break; |
Carsten Otte | ba5c1e9 | 2008-03-25 18:47:26 +0100 | [diff] [blame] | 722 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 723 | case KVM_S390_STORE_STATUS: |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 724 | r = kvm_s390_vcpu_store_status(vcpu, arg); |
| 725 | break; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 726 | case KVM_S390_SET_INITIAL_PSW: { |
| 727 | psw_t psw; |
| 728 | |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 729 | r = -EFAULT; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 730 | if (copy_from_user(&psw, argp, sizeof(psw))) |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 731 | break; |
| 732 | r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); |
| 733 | break; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 734 | } |
| 735 | case KVM_S390_INITIAL_RESET: |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 736 | r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); |
| 737 | break; |
Carsten Otte | 27e0393 | 2012-01-04 10:25:21 +0100 | [diff] [blame] | 738 | #ifdef CONFIG_KVM_S390_UCONTROL |
| 739 | case KVM_S390_UCAS_MAP: { |
| 740 | struct kvm_s390_ucas_mapping ucasmap; |
| 741 | |
| 742 | if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { |
| 743 | r = -EFAULT; |
| 744 | break; |
| 745 | } |
| 746 | |
| 747 | if (!kvm_is_ucontrol(vcpu->kvm)) { |
| 748 | r = -EINVAL; |
| 749 | break; |
| 750 | } |
| 751 | |
| 752 | r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, |
| 753 | ucasmap.vcpu_addr, ucasmap.length); |
| 754 | break; |
| 755 | } |
| 756 | case KVM_S390_UCAS_UNMAP: { |
| 757 | struct kvm_s390_ucas_mapping ucasmap; |
| 758 | |
| 759 | if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { |
| 760 | r = -EFAULT; |
| 761 | break; |
| 762 | } |
| 763 | |
| 764 | if (!kvm_is_ucontrol(vcpu->kvm)) { |
| 765 | r = -EINVAL; |
| 766 | break; |
| 767 | } |
| 768 | |
| 769 | r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, |
| 770 | ucasmap.length); |
| 771 | break; |
| 772 | } |
| 773 | #endif |
Carsten Otte | ccc7910 | 2012-01-04 10:25:26 +0100 | [diff] [blame] | 774 | case KVM_S390_VCPU_FAULT: { |
| 775 | r = gmap_fault(arg, vcpu->arch.gmap); |
| 776 | if (!IS_ERR_VALUE(r)) |
| 777 | r = 0; |
| 778 | break; |
| 779 | } |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 780 | default: |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 781 | r = -EINVAL; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 782 | } |
Avi Kivity | bc923cc | 2010-05-13 12:21:46 +0300 | [diff] [blame] | 783 | return r; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 784 | } |
| 785 | |
Carsten Otte | 5b1c149 | 2012-01-04 10:25:23 +0100 | [diff] [blame] | 786 | int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) |
| 787 | { |
| 788 | #ifdef CONFIG_KVM_S390_UCONTROL |
| 789 | if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) |
| 790 | && (kvm_is_ucontrol(vcpu->kvm))) { |
| 791 | vmf->page = virt_to_page(vcpu->arch.sie_block); |
| 792 | get_page(vmf->page); |
| 793 | return 0; |
| 794 | } |
| 795 | #endif |
| 796 | return VM_FAULT_SIGBUS; |
| 797 | } |
| 798 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 799 | /* Section: memory related */ |
Marcelo Tosatti | f7784b8 | 2009-12-23 14:35:18 -0200 | [diff] [blame] | 800 | int kvm_arch_prepare_memory_region(struct kvm *kvm, |
| 801 | struct kvm_memory_slot *memslot, |
| 802 | struct kvm_memory_slot old, |
| 803 | struct kvm_userspace_memory_region *mem, |
| 804 | int user_alloc) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 805 | { |
| 806 | /* A few sanity checks. We can have exactly one memory slot which has |
| 807 | to start at guest virtual zero and which has to be located at a |
| 808 | page boundary in userland and which has to end at a page boundary. |
| 809 | The memory in userland is ok to be fragmented into various different |
| 810 | vmas. It is okay to mmap() and munmap() stuff in this slot after |
| 811 | doing this call at any time */ |
| 812 | |
Christian Ehrhardt | 628eb9b | 2009-05-25 13:40:51 +0200 | [diff] [blame] | 813 | if (mem->slot) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 814 | return -EINVAL; |
| 815 | |
| 816 | if (mem->guest_phys_addr) |
| 817 | return -EINVAL; |
| 818 | |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 819 | if (mem->userspace_addr & 0xffffful) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 820 | return -EINVAL; |
| 821 | |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 822 | if (mem->memory_size & 0xffffful) |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 823 | return -EINVAL; |
| 824 | |
Carsten Otte | 2668dab | 2009-05-12 17:21:48 +0200 | [diff] [blame] | 825 | if (!user_alloc) |
| 826 | return -EINVAL; |
| 827 | |
Marcelo Tosatti | f7784b8 | 2009-12-23 14:35:18 -0200 | [diff] [blame] | 828 | return 0; |
| 829 | } |
| 830 | |
| 831 | void kvm_arch_commit_memory_region(struct kvm *kvm, |
| 832 | struct kvm_userspace_memory_region *mem, |
| 833 | struct kvm_memory_slot old, |
| 834 | int user_alloc) |
| 835 | { |
Carsten Otte | f7850c9 | 2011-07-24 10:48:23 +0200 | [diff] [blame] | 836 | int rc; |
Marcelo Tosatti | f7784b8 | 2009-12-23 14:35:18 -0200 | [diff] [blame] | 837 | |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 838 | |
| 839 | rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, |
| 840 | mem->guest_phys_addr, mem->memory_size); |
| 841 | if (rc) |
Carsten Otte | f7850c9 | 2011-07-24 10:48:23 +0200 | [diff] [blame] | 842 | printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); |
Carsten Otte | 598841c | 2011-07-24 10:48:21 +0200 | [diff] [blame] | 843 | return; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 844 | } |
| 845 | |
Marcelo Tosatti | 34d4cb8 | 2008-07-10 20:49:31 -0300 | [diff] [blame] | 846 | void kvm_arch_flush_shadow(struct kvm *kvm) |
| 847 | { |
| 848 | } |
| 849 | |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 850 | static int __init kvm_s390_init(void) |
| 851 | { |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 852 | int ret; |
Avi Kivity | 0ee75be | 2010-04-28 15:39:01 +0300 | [diff] [blame] | 853 | ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 854 | if (ret) |
| 855 | return ret; |
| 856 | |
| 857 | /* |
| 858 | * guests can ask for up to 255+1 double words, we need a full page |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 859 | * to hold the maximum amount of facilities. On the other hand, we |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 860 | * only set facilities that are known to work in KVM. |
| 861 | */ |
Heiko Carstens | c2f0e8c | 2010-06-08 18:58:09 +0200 | [diff] [blame] | 862 | facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA); |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 863 | if (!facilities) { |
| 864 | kvm_exit(); |
| 865 | return -ENOMEM; |
| 866 | } |
Martin Schwidefsky | 14375bc | 2010-10-25 16:10:51 +0200 | [diff] [blame] | 867 | memcpy(facilities, S390_lowcore.stfle_fac_list, 16); |
Christian Borntraeger | 6d00d00 | 2010-10-25 16:10:48 +0200 | [diff] [blame] | 868 | facilities[0] &= 0xff00fff3f47c0000ULL; |
Christian Borntraeger | 9950f8b | 2011-06-06 14:14:39 +0200 | [diff] [blame] | 869 | facilities[1] &= 0x201c000000000000ULL; |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 870 | return 0; |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 871 | } |
| 872 | |
| 873 | static void __exit kvm_s390_exit(void) |
| 874 | { |
Christian Borntraeger | ef50f7a | 2009-06-23 17:24:07 +0200 | [diff] [blame] | 875 | free_page((unsigned long) facilities); |
Heiko Carstens | b0c632d | 2008-03-25 18:47:20 +0100 | [diff] [blame] | 876 | kvm_exit(); |
| 877 | } |
| 878 | |
| 879 | module_init(kvm_s390_init); |
| 880 | module_exit(kvm_s390_exit); |