1 /* 2 * s390host.c -- 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/system.h> 31 #include "kvm-s390.h" 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) }, 38 { "exit_null", VCPU_STAT(exit_null) }, 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) }, 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) }, 46 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 47 { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 48 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 49 { "deliver_external_call", VCPU_STAT(deliver_external_call) }, 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) }, 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) }, 66 { "instruction_tprot", VCPU_STAT(instruction_tprot) }, 67 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 68 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) }, 69 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) }, 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) }, 75 { "diagnose_10", VCPU_STAT(diagnose_10) }, 76 { "diagnose_44", VCPU_STAT(diagnose_44) }, 77 { NULL } 78 }; 79 80 static unsigned long long *facilities; 81 82 /* Section: not file related */ 83 int kvm_arch_hardware_enable(void *garbage) 84 { 85 /* every s390 is virtualization enabled ;-) */ 86 return 0; 87 } 88 89 void kvm_arch_hardware_disable(void *garbage) 90 { 91 } 92 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 { 126 int r; 127 128 switch (ext) { 129 case KVM_CAP_S390_PSW: 130 case KVM_CAP_S390_GMAP: 131 case KVM_CAP_SYNC_MMU: 132 r = 1; 133 break; 134 default: 135 r = 0; 136 } 137 return r; 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) { 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 } 167 default: 168 r = -ENOTTY; 169 } 170 171 return r; 172 } 173 174 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) 175 { 176 int rc; 177 char debug_name[16]; 178 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 190 rc = s390_enable_sie(); 191 if (rc) 192 goto out_err; 193 194 rc = -ENOMEM; 195 196 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 197 if (!kvm->arch.sca) 198 goto out_err; 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 206 spin_lock_init(&kvm->arch.float_int.lock); 207 INIT_LIST_HEAD(&kvm->arch.float_int.list); 208 209 debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 210 VM_EVENT(kvm, 3, "%s", "vm created"); 211 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 } 219 return 0; 220 out_nogmap: 221 debug_unregister(kvm->arch.dbf); 222 out_nodbf: 223 free_page((unsigned long)(kvm->arch.sca)); 224 out_err: 225 return rc; 226 } 227 228 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 229 { 230 VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 231 clear_bit(63 - vcpu->vcpu_id, (unsigned long *) &vcpu->kvm->arch.sca->mcn); 232 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 233 (__u64) vcpu->arch.sie_block) 234 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 235 smp_mb(); 236 237 if (kvm_is_ucontrol(vcpu->kvm)) 238 gmap_free(vcpu->arch.gmap); 239 240 free_page((unsigned long)(vcpu->arch.sie_block)); 241 kvm_vcpu_uninit(vcpu); 242 kfree(vcpu); 243 } 244 245 static void kvm_free_vcpus(struct kvm *kvm) 246 { 247 unsigned int i; 248 struct kvm_vcpu *vcpu; 249 250 kvm_for_each_vcpu(i, vcpu, kvm) 251 kvm_arch_vcpu_destroy(vcpu); 252 253 mutex_lock(&kvm->lock); 254 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 255 kvm->vcpus[i] = NULL; 256 257 atomic_set(&kvm->online_vcpus, 0); 258 mutex_unlock(&kvm->lock); 259 } 260 261 void kvm_arch_sync_events(struct kvm *kvm) 262 { 263 } 264 265 void kvm_arch_destroy_vm(struct kvm *kvm) 266 { 267 kvm_free_vcpus(kvm); 268 free_page((unsigned long)(kvm->arch.sca)); 269 debug_unregister(kvm->arch.dbf); 270 if (!kvm_is_ucontrol(kvm)) 271 gmap_free(kvm->arch.gmap); 272 } 273 274 /* Section: vcpu related */ 275 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 276 { 277 if (kvm_is_ucontrol(vcpu->kvm)) { 278 vcpu->arch.gmap = gmap_alloc(current->mm); 279 if (!vcpu->arch.gmap) 280 return -ENOMEM; 281 return 0; 282 } 283 284 vcpu->arch.gmap = vcpu->kvm->arch.gmap; 285 return 0; 286 } 287 288 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 289 { 290 /* Nothing todo */ 291 } 292 293 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 294 { 295 save_fp_regs(&vcpu->arch.host_fpregs); 296 save_access_regs(vcpu->arch.host_acrs); 297 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK; 298 restore_fp_regs(&vcpu->arch.guest_fpregs); 299 restore_access_regs(vcpu->arch.guest_acrs); 300 gmap_enable(vcpu->arch.gmap); 301 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 302 } 303 304 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 305 { 306 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 307 gmap_disable(vcpu->arch.gmap); 308 save_fp_regs(&vcpu->arch.guest_fpregs); 309 save_access_regs(vcpu->arch.guest_acrs); 310 restore_fp_regs(&vcpu->arch.host_fpregs); 311 restore_access_regs(vcpu->arch.host_acrs); 312 } 313 314 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 315 { 316 /* this equals initial cpu reset in pop, but we don't switch to ESA */ 317 vcpu->arch.sie_block->gpsw.mask = 0UL; 318 vcpu->arch.sie_block->gpsw.addr = 0UL; 319 vcpu->arch.sie_block->prefix = 0UL; 320 vcpu->arch.sie_block->ihcpu = 0xffff; 321 vcpu->arch.sie_block->cputm = 0UL; 322 vcpu->arch.sie_block->ckc = 0UL; 323 vcpu->arch.sie_block->todpr = 0; 324 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 325 vcpu->arch.sie_block->gcr[0] = 0xE0UL; 326 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 327 vcpu->arch.guest_fpregs.fpc = 0; 328 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 329 vcpu->arch.sie_block->gbea = 1; 330 } 331 332 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 333 { 334 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH | 335 CPUSTAT_SM | 336 CPUSTAT_STOPPED); 337 vcpu->arch.sie_block->ecb = 6; 338 vcpu->arch.sie_block->eca = 0xC1002001U; 339 vcpu->arch.sie_block->fac = (int) (long) facilities; 340 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 341 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet, 342 (unsigned long) vcpu); 343 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 344 get_cpu_id(&vcpu->arch.cpu_id); 345 vcpu->arch.cpu_id.version = 0xff; 346 return 0; 347 } 348 349 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 350 unsigned int id) 351 { 352 struct kvm_vcpu *vcpu; 353 int rc = -EINVAL; 354 355 if (id >= KVM_MAX_VCPUS) 356 goto out; 357 358 rc = -ENOMEM; 359 360 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL); 361 if (!vcpu) 362 goto out; 363 364 vcpu->arch.sie_block = (struct kvm_s390_sie_block *) 365 get_zeroed_page(GFP_KERNEL); 366 367 if (!vcpu->arch.sie_block) 368 goto out_free_cpu; 369 370 vcpu->arch.sie_block->icpua = id; 371 BUG_ON(!kvm->arch.sca); 372 if (!kvm->arch.sca->cpu[id].sda) 373 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block; 374 vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32); 375 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 376 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 377 378 spin_lock_init(&vcpu->arch.local_int.lock); 379 INIT_LIST_HEAD(&vcpu->arch.local_int.list); 380 vcpu->arch.local_int.float_int = &kvm->arch.float_int; 381 spin_lock(&kvm->arch.float_int.lock); 382 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int; 383 init_waitqueue_head(&vcpu->arch.local_int.wq); 384 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 385 spin_unlock(&kvm->arch.float_int.lock); 386 387 rc = kvm_vcpu_init(vcpu, kvm, id); 388 if (rc) 389 goto out_free_sie_block; 390 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 391 vcpu->arch.sie_block); 392 393 return vcpu; 394 out_free_sie_block: 395 free_page((unsigned long)(vcpu->arch.sie_block)); 396 out_free_cpu: 397 kfree(vcpu); 398 out: 399 return ERR_PTR(rc); 400 } 401 402 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 403 { 404 /* kvm common code refers to this, but never calls it */ 405 BUG(); 406 return 0; 407 } 408 409 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 410 { 411 kvm_s390_vcpu_initial_reset(vcpu); 412 return 0; 413 } 414 415 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 416 { 417 memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs)); 418 return 0; 419 } 420 421 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 422 { 423 memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs)); 424 return 0; 425 } 426 427 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 428 struct kvm_sregs *sregs) 429 { 430 memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs)); 431 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 432 restore_access_regs(vcpu->arch.guest_acrs); 433 return 0; 434 } 435 436 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 437 struct kvm_sregs *sregs) 438 { 439 memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs)); 440 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 441 return 0; 442 } 443 444 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 445 { 446 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 447 vcpu->arch.guest_fpregs.fpc = fpu->fpc; 448 restore_fp_regs(&vcpu->arch.guest_fpregs); 449 return 0; 450 } 451 452 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 453 { 454 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 455 fpu->fpc = vcpu->arch.guest_fpregs.fpc; 456 return 0; 457 } 458 459 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 460 { 461 int rc = 0; 462 463 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED)) 464 rc = -EBUSY; 465 else { 466 vcpu->run->psw_mask = psw.mask; 467 vcpu->run->psw_addr = psw.addr; 468 } 469 return rc; 470 } 471 472 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 473 struct kvm_translation *tr) 474 { 475 return -EINVAL; /* not implemented yet */ 476 } 477 478 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 479 struct kvm_guest_debug *dbg) 480 { 481 return -EINVAL; /* not implemented yet */ 482 } 483 484 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 485 struct kvm_mp_state *mp_state) 486 { 487 return -EINVAL; /* not implemented yet */ 488 } 489 490 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 491 struct kvm_mp_state *mp_state) 492 { 493 return -EINVAL; /* not implemented yet */ 494 } 495 496 static int __vcpu_run(struct kvm_vcpu *vcpu) 497 { 498 int rc; 499 500 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16); 501 502 if (need_resched()) 503 schedule(); 504 505 if (test_thread_flag(TIF_MCCK_PENDING)) 506 s390_handle_mcck(); 507 508 if (!kvm_is_ucontrol(vcpu->kvm)) 509 kvm_s390_deliver_pending_interrupts(vcpu); 510 511 vcpu->arch.sie_block->icptcode = 0; 512 local_irq_disable(); 513 kvm_guest_enter(); 514 local_irq_enable(); 515 VCPU_EVENT(vcpu, 6, "entering sie flags %x", 516 atomic_read(&vcpu->arch.sie_block->cpuflags)); 517 rc = sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs); 518 if (rc) { 519 if (kvm_is_ucontrol(vcpu->kvm)) { 520 rc = SIE_INTERCEPT_UCONTROL; 521 } else { 522 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 523 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 524 rc = 0; 525 } 526 } 527 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 528 vcpu->arch.sie_block->icptcode); 529 local_irq_disable(); 530 kvm_guest_exit(); 531 local_irq_enable(); 532 533 memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16); 534 return rc; 535 } 536 537 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 538 { 539 int rc; 540 sigset_t sigsaved; 541 542 rerun_vcpu: 543 if (vcpu->sigset_active) 544 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 545 546 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags); 547 548 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL); 549 550 switch (kvm_run->exit_reason) { 551 case KVM_EXIT_S390_SIEIC: 552 case KVM_EXIT_UNKNOWN: 553 case KVM_EXIT_INTR: 554 case KVM_EXIT_S390_RESET: 555 case KVM_EXIT_S390_UCONTROL: 556 break; 557 default: 558 BUG(); 559 } 560 561 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 562 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 563 564 might_fault(); 565 566 do { 567 rc = __vcpu_run(vcpu); 568 if (rc) 569 break; 570 if (kvm_is_ucontrol(vcpu->kvm)) 571 rc = -EOPNOTSUPP; 572 else 573 rc = kvm_handle_sie_intercept(vcpu); 574 } while (!signal_pending(current) && !rc); 575 576 if (rc == SIE_INTERCEPT_RERUNVCPU) 577 goto rerun_vcpu; 578 579 if (signal_pending(current) && !rc) { 580 kvm_run->exit_reason = KVM_EXIT_INTR; 581 rc = -EINTR; 582 } 583 584 #ifdef CONFIG_KVM_S390_UCONTROL 585 if (rc == SIE_INTERCEPT_UCONTROL) { 586 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL; 587 kvm_run->s390_ucontrol.trans_exc_code = 588 current->thread.gmap_addr; 589 kvm_run->s390_ucontrol.pgm_code = 0x10; 590 rc = 0; 591 } 592 #endif 593 594 if (rc == -EOPNOTSUPP) { 595 /* intercept cannot be handled in-kernel, prepare kvm-run */ 596 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 597 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 598 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 599 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 600 rc = 0; 601 } 602 603 if (rc == -EREMOTE) { 604 /* intercept was handled, but userspace support is needed 605 * kvm_run has been prepared by the handler */ 606 rc = 0; 607 } 608 609 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 610 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 611 612 if (vcpu->sigset_active) 613 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 614 615 vcpu->stat.exit_userspace++; 616 return rc; 617 } 618 619 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from, 620 unsigned long n, int prefix) 621 { 622 if (prefix) 623 return copy_to_guest(vcpu, guestdest, from, n); 624 else 625 return copy_to_guest_absolute(vcpu, guestdest, from, n); 626 } 627 628 /* 629 * store status at address 630 * we use have two special cases: 631 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 632 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 633 */ 634 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 635 { 636 unsigned char archmode = 1; 637 int prefix; 638 639 if (addr == KVM_S390_STORE_STATUS_NOADDR) { 640 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) 641 return -EFAULT; 642 addr = SAVE_AREA_BASE; 643 prefix = 0; 644 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { 645 if (copy_to_guest(vcpu, 163ul, &archmode, 1)) 646 return -EFAULT; 647 addr = SAVE_AREA_BASE; 648 prefix = 1; 649 } else 650 prefix = 0; 651 652 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs), 653 vcpu->arch.guest_fpregs.fprs, 128, prefix)) 654 return -EFAULT; 655 656 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs), 657 vcpu->arch.guest_gprs, 128, prefix)) 658 return -EFAULT; 659 660 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw), 661 &vcpu->arch.sie_block->gpsw, 16, prefix)) 662 return -EFAULT; 663 664 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg), 665 &vcpu->arch.sie_block->prefix, 4, prefix)) 666 return -EFAULT; 667 668 if (__guestcopy(vcpu, 669 addr + offsetof(struct save_area, fp_ctrl_reg), 670 &vcpu->arch.guest_fpregs.fpc, 4, prefix)) 671 return -EFAULT; 672 673 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg), 674 &vcpu->arch.sie_block->todpr, 4, prefix)) 675 return -EFAULT; 676 677 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer), 678 &vcpu->arch.sie_block->cputm, 8, prefix)) 679 return -EFAULT; 680 681 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp), 682 &vcpu->arch.sie_block->ckc, 8, prefix)) 683 return -EFAULT; 684 685 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs), 686 &vcpu->arch.guest_acrs, 64, prefix)) 687 return -EFAULT; 688 689 if (__guestcopy(vcpu, 690 addr + offsetof(struct save_area, ctrl_regs), 691 &vcpu->arch.sie_block->gcr, 128, prefix)) 692 return -EFAULT; 693 return 0; 694 } 695 696 long kvm_arch_vcpu_ioctl(struct file *filp, 697 unsigned int ioctl, unsigned long arg) 698 { 699 struct kvm_vcpu *vcpu = filp->private_data; 700 void __user *argp = (void __user *)arg; 701 long r; 702 703 switch (ioctl) { 704 case KVM_S390_INTERRUPT: { 705 struct kvm_s390_interrupt s390int; 706 707 r = -EFAULT; 708 if (copy_from_user(&s390int, argp, sizeof(s390int))) 709 break; 710 r = kvm_s390_inject_vcpu(vcpu, &s390int); 711 break; 712 } 713 case KVM_S390_STORE_STATUS: 714 r = kvm_s390_vcpu_store_status(vcpu, arg); 715 break; 716 case KVM_S390_SET_INITIAL_PSW: { 717 psw_t psw; 718 719 r = -EFAULT; 720 if (copy_from_user(&psw, argp, sizeof(psw))) 721 break; 722 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 723 break; 724 } 725 case KVM_S390_INITIAL_RESET: 726 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 727 break; 728 #ifdef CONFIG_KVM_S390_UCONTROL 729 case KVM_S390_UCAS_MAP: { 730 struct kvm_s390_ucas_mapping ucasmap; 731 732 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 733 r = -EFAULT; 734 break; 735 } 736 737 if (!kvm_is_ucontrol(vcpu->kvm)) { 738 r = -EINVAL; 739 break; 740 } 741 742 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr, 743 ucasmap.vcpu_addr, ucasmap.length); 744 break; 745 } 746 case KVM_S390_UCAS_UNMAP: { 747 struct kvm_s390_ucas_mapping ucasmap; 748 749 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) { 750 r = -EFAULT; 751 break; 752 } 753 754 if (!kvm_is_ucontrol(vcpu->kvm)) { 755 r = -EINVAL; 756 break; 757 } 758 759 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr, 760 ucasmap.length); 761 break; 762 } 763 #endif 764 default: 765 r = -EINVAL; 766 } 767 return r; 768 } 769 770 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) 771 { 772 #ifdef CONFIG_KVM_S390_UCONTROL 773 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET) 774 && (kvm_is_ucontrol(vcpu->kvm))) { 775 vmf->page = virt_to_page(vcpu->arch.sie_block); 776 get_page(vmf->page); 777 return 0; 778 } 779 #endif 780 return VM_FAULT_SIGBUS; 781 } 782 783 /* Section: memory related */ 784 int kvm_arch_prepare_memory_region(struct kvm *kvm, 785 struct kvm_memory_slot *memslot, 786 struct kvm_memory_slot old, 787 struct kvm_userspace_memory_region *mem, 788 int user_alloc) 789 { 790 /* A few sanity checks. We can have exactly one memory slot which has 791 to start at guest virtual zero and which has to be located at a 792 page boundary in userland and which has to end at a page boundary. 793 The memory in userland is ok to be fragmented into various different 794 vmas. It is okay to mmap() and munmap() stuff in this slot after 795 doing this call at any time */ 796 797 if (mem->slot) 798 return -EINVAL; 799 800 if (mem->guest_phys_addr) 801 return -EINVAL; 802 803 if (mem->userspace_addr & 0xffffful) 804 return -EINVAL; 805 806 if (mem->memory_size & 0xffffful) 807 return -EINVAL; 808 809 if (!user_alloc) 810 return -EINVAL; 811 812 return 0; 813 } 814 815 void kvm_arch_commit_memory_region(struct kvm *kvm, 816 struct kvm_userspace_memory_region *mem, 817 struct kvm_memory_slot old, 818 int user_alloc) 819 { 820 int rc; 821 822 823 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr, 824 mem->guest_phys_addr, mem->memory_size); 825 if (rc) 826 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n"); 827 return; 828 } 829 830 void kvm_arch_flush_shadow(struct kvm *kvm) 831 { 832 } 833 834 static int __init kvm_s390_init(void) 835 { 836 int ret; 837 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 838 if (ret) 839 return ret; 840 841 /* 842 * guests can ask for up to 255+1 double words, we need a full page 843 * to hold the maximum amount of facilities. On the other hand, we 844 * only set facilities that are known to work in KVM. 845 */ 846 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA); 847 if (!facilities) { 848 kvm_exit(); 849 return -ENOMEM; 850 } 851 memcpy(facilities, S390_lowcore.stfle_fac_list, 16); 852 facilities[0] &= 0xff00fff3f47c0000ULL; 853 facilities[1] &= 0x201c000000000000ULL; 854 return 0; 855 } 856 857 static void __exit kvm_s390_exit(void) 858 { 859 free_page((unsigned long) facilities); 860 kvm_exit(); 861 } 862 863 module_init(kvm_s390_init); 864 module_exit(kvm_s390_exit); 865