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