1 /* 2 * hosting zSeries kernel virtual machines 3 * 4 * Copyright IBM Corp. 2008, 2009 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License (version 2 only) 8 * as published by the Free Software Foundation. 9 * 10 * Author(s): Carsten Otte <cotte@de.ibm.com> 11 * Christian Borntraeger <borntraeger@de.ibm.com> 12 * Heiko Carstens <heiko.carstens@de.ibm.com> 13 * Christian Ehrhardt <ehrhardt@de.ibm.com> 14 */ 15 16 #include <linux/compiler.h> 17 #include <linux/err.h> 18 #include <linux/fs.h> 19 #include <linux/hrtimer.h> 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> 25 #include <linux/timer.h> 26 #include <asm/asm-offsets.h> 27 #include <asm/lowcore.h> 28 #include <asm/pgtable.h> 29 #include <asm/nmi.h> 30 #include <asm/switch_to.h> 31 #include <asm/sclp.h> 32 #include "kvm-s390.h" 33 #include "gaccess.h" 34 35 #define CREATE_TRACE_POINTS 36 #include "trace.h" 37 #include "trace-s390.h" 38 39 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 40 41 struct kvm_stats_debugfs_item debugfs_entries[] = { 42 { "userspace_handled", VCPU_STAT(exit_userspace) }, 43 { "exit_null", VCPU_STAT(exit_null) }, 44 { "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) }, 48 { "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) }, 51 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 52 { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 53 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 54 { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 55 { "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) }, 62 { "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) }, 71 { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 72 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 73 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 74 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 75 { "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) }, 80 { "diagnose_10", VCPU_STAT(diagnose_10) }, 81 { "diagnose_44", VCPU_STAT(diagnose_44) }, 82 { "diagnose_9c", VCPU_STAT(diagnose_9c) }, 83 { NULL } 84 }; 85 86 static unsigned long long *facilities; 87 88 /* Section: not file related */ 89 int kvm_arch_hardware_enable(void *garbage) 90 { 91 /* every s390 is virtualization enabled ;-) */ 92 return 0; 93 } 94 95 void kvm_arch_hardware_disable(void *garbage) 96 { 97 } 98 99 int kvm_arch_hardware_setup(void) 100 { 101 return 0; 102 } 103 104 void kvm_arch_hardware_unsetup(void) 105 { 106 } 107 108 void kvm_arch_check_processor_compat(void *rtn) 109 { 110 } 111 112 int kvm_arch_init(void *opaque) 113 { 114 return 0; 115 } 116 117 void kvm_arch_exit(void) 118 { 119 } 120 121 /* Section: device related */ 122 long kvm_arch_dev_ioctl(struct file *filp, 123 unsigned int ioctl, unsigned long arg) 124 { 125 if (ioctl == KVM_S390_ENABLE_SIE) 126 return s390_enable_sie(); 127 return -EINVAL; 128 } 129 130 int kvm_dev_ioctl_check_extension(long ext) 131 { 132 int r; 133 134 switch (ext) { 135 case KVM_CAP_S390_PSW: 136 case KVM_CAP_S390_GMAP: 137 case KVM_CAP_SYNC_MMU: 138 #ifdef CONFIG_KVM_S390_UCONTROL 139 case KVM_CAP_S390_UCONTROL: 140 #endif 141 case KVM_CAP_SYNC_REGS: 142 case KVM_CAP_ONE_REG: 143 case KVM_CAP_ENABLE_CAP: 144 case KVM_CAP_S390_CSS_SUPPORT: 145 case KVM_CAP_IOEVENTFD: 146 r = 1; 147 break; 148 case KVM_CAP_NR_VCPUS: 149 case KVM_CAP_MAX_VCPUS: 150 r = KVM_MAX_VCPUS; 151 break; 152 case KVM_CAP_NR_MEMSLOTS: 153 r = KVM_USER_MEM_SLOTS; 154 break; 155 case KVM_CAP_S390_COW: 156 r = MACHINE_HAS_ESOP; 157 break; 158 default: 159 r = 0; 160 } 161 return r; 162 } 163 164 /* Section: vm related */ 165 /* 166 * Get (and clear) the dirty memory log for a memory slot. 167 */ 168 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 169 struct kvm_dirty_log *log) 170 { 171 return 0; 172 } 173 174 long kvm_arch_vm_ioctl(struct file *filp, 175 unsigned int ioctl, unsigned long arg) 176 { 177 struct kvm *kvm = filp->private_data; 178 void __user *argp = (void __user *)arg; 179 int r; 180 181 switch (ioctl) { 182 case KVM_S390_INTERRUPT: { 183 struct kvm_s390_interrupt s390int; 184 185 r = -EFAULT; 186 if (copy_from_user(&s390int, argp, sizeof(s390int))) 187 break; 188 r = kvm_s390_inject_vm(kvm, &s390int); 189 break; 190 } 191 default: 192 r = -ENOTTY; 193 } 194 195 return r; 196 } 197 198 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 199 { 200 int rc; 201 char debug_name[16]; 202 203 rc = -EINVAL; 204 #ifdef CONFIG_KVM_S390_UCONTROL 205 if (type & ~KVM_VM_S390_UCONTROL) 206 goto out_err; 207 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN))) 208 goto out_err; 209 #else 210 if (type) 211 goto out_err; 212 #endif 213 214 rc = s390_enable_sie(); 215 if (rc) 216 goto out_err; 217 218 rc = -ENOMEM; 219 220 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 221 if (!kvm->arch.sca) 222 goto out_err; 223 224 sprintf(debug_name, "kvm-%u", current->pid); 225 226 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 227 if (!kvm->arch.dbf) 228 goto out_nodbf; 229 230 spin_lock_init(&kvm->arch.float_int.lock); 231 INIT_LIST_HEAD(&kvm->arch.float_int.list); 232 233 debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 234 VM_EVENT(kvm, 3, "%s", "vm created"); 235 236 if (type & KVM_VM_S390_UCONTROL) { 237 kvm->arch.gmap = NULL; 238 } else { 239 kvm->arch.gmap = gmap_alloc(current->mm); 240 if (!kvm->arch.gmap) 241 goto out_nogmap; 242 } 243 244 kvm->arch.css_support = 0; 245 246 return 0; 247 out_nogmap: 248 debug_unregister(kvm->arch.dbf); 249 out_nodbf: 250 free_page((unsigned long)(kvm->arch.sca)); 251 out_err: 252 return rc; 253 } 254 255 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 256 { 257 VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 258 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id); 259 if (!kvm_is_ucontrol(vcpu->kvm)) { 260 clear_bit(63 - vcpu->vcpu_id, 261 (unsigned long *) &vcpu->kvm->arch.sca->mcn); 262 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 263 (__u64) vcpu->arch.sie_block) 264 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 265 } 266 smp_mb(); 267 268 if (kvm_is_ucontrol(vcpu->kvm)) 269 gmap_free(vcpu->arch.gmap); 270 271 free_page((unsigned long)(vcpu->arch.sie_block)); 272 kvm_vcpu_uninit(vcpu); 273 kfree(vcpu); 274 } 275 276 static void kvm_free_vcpus(struct kvm *kvm) 277 { 278 unsigned int i; 279 struct kvm_vcpu *vcpu; 280 281 kvm_for_each_vcpu(i, vcpu, kvm) 282 kvm_arch_vcpu_destroy(vcpu); 283 284 mutex_lock(&kvm->lock); 285 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 286 kvm->vcpus[i] = NULL; 287 288 atomic_set(&kvm->online_vcpus, 0); 289 mutex_unlock(&kvm->lock); 290 } 291 292 void kvm_arch_sync_events(struct kvm *kvm) 293 { 294 } 295 296 void kvm_arch_destroy_vm(struct kvm *kvm) 297 { 298 kvm_free_vcpus(kvm); 299 free_page((unsigned long)(kvm->arch.sca)); 300 debug_unregister(kvm->arch.dbf); 301 if (!kvm_is_ucontrol(kvm)) 302 gmap_free(kvm->arch.gmap); 303 } 304 305 /* Section: vcpu related */ 306 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 307 { 308 if (kvm_is_ucontrol(vcpu->kvm)) { 309 vcpu->arch.gmap = gmap_alloc(current->mm); 310 if (!vcpu->arch.gmap) 311 return -ENOMEM; 312 return 0; 313 } 314 315 vcpu->arch.gmap = vcpu->kvm->arch.gmap; 316 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX | 317 KVM_SYNC_GPRS | 318 KVM_SYNC_ACRS | 319 KVM_SYNC_CRS; 320 return 0; 321 } 322 323 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 324 { 325 /* Nothing todo */ 326 } 327 328 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 329 { 330 save_fp_regs(&vcpu->arch.host_fpregs); 331 save_access_regs(vcpu->arch.host_acrs); 332 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK; 333 restore_fp_regs(&vcpu->arch.guest_fpregs); 334 restore_access_regs(vcpu->run->s.regs.acrs); 335 gmap_enable(vcpu->arch.gmap); 336 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 337 } 338 339 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 340 { 341 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 342 gmap_disable(vcpu->arch.gmap); 343 save_fp_regs(&vcpu->arch.guest_fpregs); 344 save_access_regs(vcpu->run->s.regs.acrs); 345 restore_fp_regs(&vcpu->arch.host_fpregs); 346 restore_access_regs(vcpu->arch.host_acrs); 347 } 348 349 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 350 { 351 /* this equals initial cpu reset in pop, but we don't switch to ESA */ 352 vcpu->arch.sie_block->gpsw.mask = 0UL; 353 vcpu->arch.sie_block->gpsw.addr = 0UL; 354 kvm_s390_set_prefix(vcpu, 0); 355 vcpu->arch.sie_block->cputm = 0UL; 356 vcpu->arch.sie_block->ckc = 0UL; 357 vcpu->arch.sie_block->todpr = 0; 358 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 359 vcpu->arch.sie_block->gcr[0] = 0xE0UL; 360 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 361 vcpu->arch.guest_fpregs.fpc = 0; 362 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 363 vcpu->arch.sie_block->gbea = 1; 364 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 365 } 366 367 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) 368 { 369 return 0; 370 } 371 372 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 373 { 374 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 375 CPUSTAT_SM | 376 CPUSTAT_STOPPED); 377 vcpu->arch.sie_block->ecb = 6; 378 vcpu->arch.sie_block->eca = 0xC1002001U; 379 vcpu->arch.sie_block->fac = (int) (long) facilities; 380 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 381 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet, 382 (unsigned long) vcpu); 383 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 384 get_cpu_id(&vcpu->arch.cpu_id); 385 vcpu->arch.cpu_id.version = 0xff; 386 return 0; 387 } 388 389 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 390 unsigned int id) 391 { 392 struct kvm_vcpu *vcpu; 393 int rc = -EINVAL; 394 395 if (id >= KVM_MAX_VCPUS) 396 goto out; 397 398 rc = -ENOMEM; 399 400 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL); 401 if (!vcpu) 402 goto out; 403 404 vcpu->arch.sie_block = (struct kvm_s390_sie_block *) 405 get_zeroed_page(GFP_KERNEL); 406 407 if (!vcpu->arch.sie_block) 408 goto out_free_cpu; 409 410 vcpu->arch.sie_block->icpua = id; 411 if (!kvm_is_ucontrol(kvm)) { 412 if (!kvm->arch.sca) { 413 WARN_ON_ONCE(1); 414 goto out_free_cpu; 415 } 416 if (!kvm->arch.sca->cpu[id].sda) 417 kvm->arch.sca->cpu[id].sda = 418 (__u64) vcpu->arch.sie_block; 419 vcpu->arch.sie_block->scaoh = 420 (__u32)(((__u64)kvm->arch.sca) >> 32); 421 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 422 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 423 } 424 425 spin_lock_init(&vcpu->arch.local_int.lock); 426 INIT_LIST_HEAD(&vcpu->arch.local_int.list); 427 vcpu->arch.local_int.float_int = &kvm->arch.float_int; 428 spin_lock(&kvm->arch.float_int.lock); 429 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int; 430 init_waitqueue_head(&vcpu->arch.local_int.wq); 431 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 432 spin_unlock(&kvm->arch.float_int.lock); 433 434 rc = kvm_vcpu_init(vcpu, kvm, id); 435 if (rc) 436 goto out_free_sie_block; 437 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 438 vcpu->arch.sie_block); 439 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block); 440 441 return vcpu; 442 out_free_sie_block: 443 free_page((unsigned long)(vcpu->arch.sie_block)); 444 out_free_cpu: 445 kfree(vcpu); 446 out: 447 return ERR_PTR(rc); 448 } 449 450 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 451 { 452 /* kvm common code refers to this, but never calls it */ 453 BUG(); 454 return 0; 455 } 456 457 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 458 { 459 /* kvm common code refers to this, but never calls it */ 460 BUG(); 461 return 0; 462 } 463 464 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, 465 struct kvm_one_reg *reg) 466 { 467 int r = -EINVAL; 468 469 switch (reg->id) { 470 case KVM_REG_S390_TODPR: 471 r = put_user(vcpu->arch.sie_block->todpr, 472 (u32 __user *)reg->addr); 473 break; 474 case KVM_REG_S390_EPOCHDIFF: 475 r = put_user(vcpu->arch.sie_block->epoch, 476 (u64 __user *)reg->addr); 477 break; 478 case KVM_REG_S390_CPU_TIMER: 479 r = put_user(vcpu->arch.sie_block->cputm, 480 (u64 __user *)reg->addr); 481 break; 482 case KVM_REG_S390_CLOCK_COMP: 483 r = put_user(vcpu->arch.sie_block->ckc, 484 (u64 __user *)reg->addr); 485 break; 486 default: 487 break; 488 } 489 490 return r; 491 } 492 493 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, 494 struct kvm_one_reg *reg) 495 { 496 int r = -EINVAL; 497 498 switch (reg->id) { 499 case KVM_REG_S390_TODPR: 500 r = get_user(vcpu->arch.sie_block->todpr, 501 (u32 __user *)reg->addr); 502 break; 503 case KVM_REG_S390_EPOCHDIFF: 504 r = get_user(vcpu->arch.sie_block->epoch, 505 (u64 __user *)reg->addr); 506 break; 507 case KVM_REG_S390_CPU_TIMER: 508 r = get_user(vcpu->arch.sie_block->cputm, 509 (u64 __user *)reg->addr); 510 break; 511 case KVM_REG_S390_CLOCK_COMP: 512 r = get_user(vcpu->arch.sie_block->ckc, 513 (u64 __user *)reg->addr); 514 break; 515 default: 516 break; 517 } 518 519 return r; 520 } 521 522 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 523 { 524 kvm_s390_vcpu_initial_reset(vcpu); 525 return 0; 526 } 527 528 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 529 { 530 memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs)); 531 return 0; 532 } 533 534 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 535 { 536 memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs)); 537 return 0; 538 } 539 540 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 541 struct kvm_sregs *sregs) 542 { 543 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs)); 544 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 545 restore_access_regs(vcpu->run->s.regs.acrs); 546 return 0; 547 } 548 549 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 550 struct kvm_sregs *sregs) 551 { 552 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs)); 553 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 554 return 0; 555 } 556 557 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 558 { 559 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 560 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK; 561 restore_fp_regs(&vcpu->arch.guest_fpregs); 562 return 0; 563 } 564 565 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 566 { 567 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 568 fpu->fpc = vcpu->arch.guest_fpregs.fpc; 569 return 0; 570 } 571 572 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 573 { 574 int rc = 0; 575 576 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED)) 577 rc = -EBUSY; 578 else { 579 vcpu->run->psw_mask = psw.mask; 580 vcpu->run->psw_addr = psw.addr; 581 } 582 return rc; 583 } 584 585 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 586 struct kvm_translation *tr) 587 { 588 return -EINVAL; /* not implemented yet */ 589 } 590 591 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 592 struct kvm_guest_debug *dbg) 593 { 594 return -EINVAL; /* not implemented yet */ 595 } 596 597 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 598 struct kvm_mp_state *mp_state) 599 { 600 return -EINVAL; /* not implemented yet */ 601 } 602 603 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 604 struct kvm_mp_state *mp_state) 605 { 606 return -EINVAL; /* not implemented yet */ 607 } 608 609 static int __vcpu_run(struct kvm_vcpu *vcpu) 610 { 611 int rc; 612 613 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); 614 615 if (need_resched()) 616 schedule(); 617 618 if (test_thread_flag(TIF_MCCK_PENDING)) 619 s390_handle_mcck(); 620 621 if (!kvm_is_ucontrol(vcpu->kvm)) 622 kvm_s390_deliver_pending_interrupts(vcpu); 623 624 vcpu->arch.sie_block->icptcode = 0; 625 preempt_disable(); 626 kvm_guest_enter(); 627 preempt_enable(); 628 VCPU_EVENT(vcpu, 6, "entering sie flags %x", 629 atomic_read(&vcpu->arch.sie_block->cpuflags)); 630 trace_kvm_s390_sie_enter(vcpu, 631 atomic_read(&vcpu->arch.sie_block->cpuflags)); 632 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs); 633 if (rc) { 634 if (kvm_is_ucontrol(vcpu->kvm)) { 635 rc = SIE_INTERCEPT_UCONTROL; 636 } else { 637 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 638 trace_kvm_s390_sie_fault(vcpu); 639 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 640 } 641 } 642 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 643 vcpu->arch.sie_block->icptcode); 644 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); 645 kvm_guest_exit(); 646 647 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); 648 return rc; 649 } 650 651 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 652 { 653 int rc; 654 sigset_t sigsaved; 655 656 rerun_vcpu: 657 if (vcpu->sigset_active) 658 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 659 660 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 661 662 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL); 663 664 switch (kvm_run->exit_reason) { 665 case KVM_EXIT_S390_SIEIC: 666 case KVM_EXIT_UNKNOWN: 667 case KVM_EXIT_INTR: 668 case KVM_EXIT_S390_RESET: 669 case KVM_EXIT_S390_UCONTROL: 670 case KVM_EXIT_S390_TSCH: 671 break; 672 default: 673 BUG(); 674 } 675 676 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 677 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 678 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) { 679 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX; 680 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 681 } 682 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) { 683 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS; 684 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128); 685 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix); 686 } 687 688 might_fault(); 689 690 do { 691 rc = __vcpu_run(vcpu); 692 if (rc) 693 break; 694 if (kvm_is_ucontrol(vcpu->kvm)) 695 rc = -EOPNOTSUPP; 696 else 697 rc = kvm_handle_sie_intercept(vcpu); 698 } while (!signal_pending(current) && !rc); 699 700 if (rc == SIE_INTERCEPT_RERUNVCPU) 701 goto rerun_vcpu; 702 703 if (signal_pending(current) && !rc) { 704 kvm_run->exit_reason = KVM_EXIT_INTR; 705 rc = -EINTR; 706 } 707 708 #ifdef CONFIG_KVM_S390_UCONTROL 709 if (rc == SIE_INTERCEPT_UCONTROL) { 710 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL; 711 kvm_run->s390_ucontrol.trans_exc_code = 712 current->thread.gmap_addr; 713 kvm_run->s390_ucontrol.pgm_code = 0x10; 714 rc = 0; 715 } 716 #endif 717 718 if (rc == -EOPNOTSUPP) { 719 /* intercept cannot be handled in-kernel, prepare kvm-run */ 720 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 721 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 722 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 723 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 724 rc = 0; 725 } 726 727 if (rc == -EREMOTE) { 728 /* intercept was handled, but userspace support is needed 729 * kvm_run has been prepared by the handler */ 730 rc = 0; 731 } 732 733 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 734 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 735 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix; 736 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128); 737 738 if (vcpu->sigset_active) 739 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 740 741 vcpu->stat.exit_userspace++; 742 return rc; 743 } 744 745 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from, 746 unsigned long n, int prefix) 747 { 748 if (prefix) 749 return copy_to_guest(vcpu, guestdest, from, n); 750 else 751 return copy_to_guest_absolute(vcpu, guestdest, from, n); 752 } 753 754 /* 755 * store status at address 756 * we use have two special cases: 757 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 758 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 759 */ 760 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 761 { 762 unsigned char archmode = 1; 763 int prefix; 764 765 if (addr == KVM_S390_STORE_STATUS_NOADDR) { 766 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) 767 return -EFAULT; 768 addr = SAVE_AREA_BASE; 769 prefix = 0; 770 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { 771 if (copy_to_guest(vcpu, 163ul, &archmode, 1)) 772 return -EFAULT; 773 addr = SAVE_AREA_BASE; 774 prefix = 1; 775 } else 776 prefix = 0; 777 778 /* 779 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy 780 * copying in vcpu load/put. Lets update our copies before we save 781 * it into the save area 782 */ 783 save_fp_regs(&vcpu->arch.guest_fpregs); 784 save_access_regs(vcpu->run->s.regs.acrs); 785 786 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs), 787 vcpu->arch.guest_fpregs.fprs, 128, prefix)) 788 return -EFAULT; 789 790 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs), 791 vcpu->run->s.regs.gprs, 128, prefix)) 792 return -EFAULT; 793 794 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw), 795 &vcpu->arch.sie_block->gpsw, 16, prefix)) 796 return -EFAULT; 797 798 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg), 799 &vcpu->arch.sie_block->prefix, 4, prefix)) 800 return -EFAULT; 801 802 if (__guestcopy(vcpu, 803 addr + offsetof(struct save_area, fp_ctrl_reg), 804 &vcpu->arch.guest_fpregs.fpc, 4, prefix)) 805 return -EFAULT; 806 807 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg), 808 &vcpu->arch.sie_block->todpr, 4, prefix)) 809 return -EFAULT; 810 811 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer), 812 &vcpu->arch.sie_block->cputm, 8, prefix)) 813 return -EFAULT; 814 815 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp), 816 &vcpu->arch.sie_block->ckc, 8, prefix)) 817 return -EFAULT; 818 819 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs), 820 &vcpu->run->s.regs.acrs, 64, prefix)) 821 return -EFAULT; 822 823 if (__guestcopy(vcpu, 824 addr + offsetof(struct save_area, ctrl_regs), 825 &vcpu->arch.sie_block->gcr, 128, prefix)) 826 return -EFAULT; 827 return 0; 828 } 829 830 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, 831 struct kvm_enable_cap *cap) 832 { 833 int r; 834 835 if (cap->flags) 836 return -EINVAL; 837 838 switch (cap->cap) { 839 case KVM_CAP_S390_CSS_SUPPORT: 840 if (!vcpu->kvm->arch.css_support) { 841 vcpu->kvm->arch.css_support = 1; 842 trace_kvm_s390_enable_css(vcpu->kvm); 843 } 844 r = 0; 845 break; 846 default: 847 r = -EINVAL; 848 break; 849 } 850 return r; 851 } 852 853 long kvm_arch_vcpu_ioctl(struct file *filp, 854 unsigned int ioctl, unsigned long arg) 855 { 856 struct kvm_vcpu *vcpu = filp->private_data; 857 void __user *argp = (void __user *)arg; 858 long r; 859 860 switch (ioctl) { 861 case KVM_S390_INTERRUPT: { 862 struct kvm_s390_interrupt s390int; 863 864 r = -EFAULT; 865 if (copy_from_user(&s390int, argp, sizeof(s390int))) 866 break; 867 r = kvm_s390_inject_vcpu(vcpu, &s390int); 868 break; 869 } 870 case KVM_S390_STORE_STATUS: 871 r = kvm_s390_vcpu_store_status(vcpu, arg); 872 break; 873 case KVM_S390_SET_INITIAL_PSW: { 874 psw_t psw; 875 876 r = -EFAULT; 877 if (copy_from_user(&psw, argp, sizeof(psw))) 878 break; 879 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 880 break; 881 } 882 case KVM_S390_INITIAL_RESET: 883 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 884 break; 885 case KVM_SET_ONE_REG: 886 case KVM_GET_ONE_REG: { 887 struct kvm_one_reg reg; 888 r = -EFAULT; 889 if (copy_from_user(®, argp, sizeof(reg))) 890 break; 891 if (ioctl == KVM_SET_ONE_REG) 892 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®); 893 else 894 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®); 895 break; 896 } 897 #ifdef CONFIG_KVM_S390_UCONTROL 898 case KVM_S390_UCAS_MAP: { 899 struct kvm_s390_ucas_mapping ucasmap; 900 901 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 902 r = -EFAULT; 903 break; 904 } 905 906 if (!kvm_is_ucontrol(vcpu->kvm)) { 907 r = -EINVAL; 908 break; 909 } 910 911 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 912 ucasmap.vcpu_addr, ucasmap.length); 913 break; 914 } 915 case KVM_S390_UCAS_UNMAP: { 916 struct kvm_s390_ucas_mapping ucasmap; 917 918 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 919 r = -EFAULT; 920 break; 921 } 922 923 if (!kvm_is_ucontrol(vcpu->kvm)) { 924 r = -EINVAL; 925 break; 926 } 927 928 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 929 ucasmap.length); 930 break; 931 } 932 #endif 933 case KVM_S390_VCPU_FAULT: { 934 r = gmap_fault(arg, vcpu->arch.gmap); 935 if (!IS_ERR_VALUE(r)) 936 r = 0; 937 break; 938 } 939 case KVM_ENABLE_CAP: 940 { 941 struct kvm_enable_cap cap; 942 r = -EFAULT; 943 if (copy_from_user(&cap, argp, sizeof(cap))) 944 break; 945 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap); 946 break; 947 } 948 default: 949 r = -ENOTTY; 950 } 951 return r; 952 } 953 954 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 955 { 956 #ifdef CONFIG_KVM_S390_UCONTROL 957 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 958 && (kvm_is_ucontrol(vcpu->kvm))) { 959 vmf->page = virt_to_page(vcpu->arch.sie_block); 960 get_page(vmf->page); 961 return 0; 962 } 963 #endif 964 return VM_FAULT_SIGBUS; 965 } 966 967 void kvm_arch_free_memslot(struct kvm_memory_slot *free, 968 struct kvm_memory_slot *dont) 969 { 970 } 971 972 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) 973 { 974 return 0; 975 } 976 977 /* Section: memory related */ 978 int kvm_arch_prepare_memory_region(struct kvm *kvm, 979 struct kvm_memory_slot *memslot, 980 struct kvm_userspace_memory_region *mem, 981 enum kvm_mr_change change) 982 { 983 /* A few sanity checks. We can have memory slots which have to be 984 located/ended at a segment boundary (1MB). The memory in userland is 985 ok to be fragmented into various different vmas. It is okay to mmap() 986 and munmap() stuff in this slot after doing this call at any time */ 987 988 if (mem->userspace_addr & 0xffffful) 989 return -EINVAL; 990 991 if (mem->memory_size & 0xffffful) 992 return -EINVAL; 993 994 return 0; 995 } 996 997 void kvm_arch_commit_memory_region(struct kvm *kvm, 998 struct kvm_userspace_memory_region *mem, 999 const struct kvm_memory_slot *old, 1000 enum kvm_mr_change change) 1001 { 1002 int rc; 1003 1004 /* If the basics of the memslot do not change, we do not want 1005 * to update the gmap. Every update causes several unnecessary 1006 * segment translation exceptions. This is usually handled just 1007 * fine by the normal fault handler + gmap, but it will also 1008 * cause faults on the prefix page of running guest CPUs. 1009 */ 1010 if (old->userspace_addr == mem->userspace_addr && 1011 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr && 1012 old->npages * PAGE_SIZE == mem->memory_size) 1013 return; 1014 1015 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 1016 mem->guest_phys_addr, mem->memory_size); 1017 if (rc) 1018 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); 1019 return; 1020 } 1021 1022 void kvm_arch_flush_shadow_all(struct kvm *kvm) 1023 { 1024 } 1025 1026 void kvm_arch_flush_shadow_memslot(struct kvm *kvm, 1027 struct kvm_memory_slot *slot) 1028 { 1029 } 1030 1031 static int __init kvm_s390_init(void) 1032 { 1033 int ret; 1034 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 1035 if (ret) 1036 return ret; 1037 1038 /* 1039 * guests can ask for up to 255+1 double words, we need a full page 1040 * to hold the maximum amount of facilities. On the other hand, we 1041 * only set facilities that are known to work in KVM. 1042 */ 1043 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA); 1044 if (!facilities) { 1045 kvm_exit(); 1046 return -ENOMEM; 1047 } 1048 memcpy(facilities, S390_lowcore.stfle_fac_list, 16); 1049 facilities[0] &= 0xff00fff3f47c0000ULL; 1050 facilities[1] &= 0x001c000000000000ULL; 1051 return 0; 1052 } 1053 1054 static void __exit kvm_s390_exit(void) 1055 { 1056 free_page((unsigned long) facilities); 1057 kvm_exit(); 1058 } 1059 1060 module_init(kvm_s390_init); 1061 module_exit(kvm_s390_exit); 1062