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_service_signal", VCPU_STAT(deliver_service_signal) }, 50 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 51 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 52 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 53 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 54 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 55 { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 56 { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 57 { "instruction_spx", VCPU_STAT(instruction_spx) }, 58 { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 59 { "instruction_stap", VCPU_STAT(instruction_stap) }, 60 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 61 { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 62 { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 63 { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 64 { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 65 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 66 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 67 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 68 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 69 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 70 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 71 { "diagnose_44", VCPU_STAT(diagnose_44) }, 72 { NULL } 73 }; 74 75 static unsigned long long *facilities; 76 77 /* Section: not file related */ 78 int kvm_arch_hardware_enable(void *garbage) 79 { 80 /* every s390 is virtualization enabled ;-) */ 81 return 0; 82 } 83 84 void kvm_arch_hardware_disable(void *garbage) 85 { 86 } 87 88 int kvm_arch_hardware_setup(void) 89 { 90 return 0; 91 } 92 93 void kvm_arch_hardware_unsetup(void) 94 { 95 } 96 97 void kvm_arch_check_processor_compat(void *rtn) 98 { 99 } 100 101 int kvm_arch_init(void *opaque) 102 { 103 return 0; 104 } 105 106 void kvm_arch_exit(void) 107 { 108 } 109 110 /* Section: device related */ 111 long kvm_arch_dev_ioctl(struct file *filp, 112 unsigned int ioctl, unsigned long arg) 113 { 114 if (ioctl == KVM_S390_ENABLE_SIE) 115 return s390_enable_sie(); 116 return -EINVAL; 117 } 118 119 int kvm_dev_ioctl_check_extension(long ext) 120 { 121 int r; 122 123 switch (ext) { 124 case KVM_CAP_S390_PSW: 125 r = 1; 126 break; 127 default: 128 r = 0; 129 } 130 return r; 131 } 132 133 /* Section: vm related */ 134 /* 135 * Get (and clear) the dirty memory log for a memory slot. 136 */ 137 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 138 struct kvm_dirty_log *log) 139 { 140 return 0; 141 } 142 143 long kvm_arch_vm_ioctl(struct file *filp, 144 unsigned int ioctl, unsigned long arg) 145 { 146 struct kvm *kvm = filp->private_data; 147 void __user *argp = (void __user *)arg; 148 int r; 149 150 switch (ioctl) { 151 case KVM_S390_INTERRUPT: { 152 struct kvm_s390_interrupt s390int; 153 154 r = -EFAULT; 155 if (copy_from_user(&s390int, argp, sizeof(s390int))) 156 break; 157 r = kvm_s390_inject_vm(kvm, &s390int); 158 break; 159 } 160 default: 161 r = -ENOTTY; 162 } 163 164 return r; 165 } 166 167 struct kvm *kvm_arch_create_vm(void) 168 { 169 struct kvm *kvm; 170 int rc; 171 char debug_name[16]; 172 173 rc = s390_enable_sie(); 174 if (rc) 175 goto out_nokvm; 176 177 rc = -ENOMEM; 178 kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL); 179 if (!kvm) 180 goto out_nokvm; 181 182 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 183 if (!kvm->arch.sca) 184 goto out_nosca; 185 186 sprintf(debug_name, "kvm-%u", current->pid); 187 188 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 189 if (!kvm->arch.dbf) 190 goto out_nodbf; 191 192 spin_lock_init(&kvm->arch.float_int.lock); 193 INIT_LIST_HEAD(&kvm->arch.float_int.list); 194 195 debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 196 VM_EVENT(kvm, 3, "%s", "vm created"); 197 198 return kvm; 199 out_nodbf: 200 free_page((unsigned long)(kvm->arch.sca)); 201 out_nosca: 202 kfree(kvm); 203 out_nokvm: 204 return ERR_PTR(rc); 205 } 206 207 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 208 { 209 VCPU_EVENT(vcpu, 3, "%s", "free cpu"); 210 clear_bit(63 - vcpu->vcpu_id, (unsigned long *) &vcpu->kvm->arch.sca->mcn); 211 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda == 212 (__u64) vcpu->arch.sie_block) 213 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0; 214 smp_mb(); 215 free_page((unsigned long)(vcpu->arch.sie_block)); 216 kvm_vcpu_uninit(vcpu); 217 kfree(vcpu); 218 } 219 220 static void kvm_free_vcpus(struct kvm *kvm) 221 { 222 unsigned int i; 223 struct kvm_vcpu *vcpu; 224 225 kvm_for_each_vcpu(i, vcpu, kvm) 226 kvm_arch_vcpu_destroy(vcpu); 227 228 mutex_lock(&kvm->lock); 229 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) 230 kvm->vcpus[i] = NULL; 231 232 atomic_set(&kvm->online_vcpus, 0); 233 mutex_unlock(&kvm->lock); 234 } 235 236 void kvm_arch_sync_events(struct kvm *kvm) 237 { 238 } 239 240 void kvm_arch_destroy_vm(struct kvm *kvm) 241 { 242 kvm_free_vcpus(kvm); 243 kvm_free_physmem(kvm); 244 free_page((unsigned long)(kvm->arch.sca)); 245 debug_unregister(kvm->arch.dbf); 246 cleanup_srcu_struct(&kvm->srcu); 247 kfree(kvm); 248 } 249 250 /* Section: vcpu related */ 251 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 252 { 253 return 0; 254 } 255 256 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 257 { 258 /* Nothing todo */ 259 } 260 261 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 262 { 263 save_fp_regs(&vcpu->arch.host_fpregs); 264 save_access_regs(vcpu->arch.host_acrs); 265 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK; 266 restore_fp_regs(&vcpu->arch.guest_fpregs); 267 restore_access_regs(vcpu->arch.guest_acrs); 268 } 269 270 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 271 { 272 save_fp_regs(&vcpu->arch.guest_fpregs); 273 save_access_regs(vcpu->arch.guest_acrs); 274 restore_fp_regs(&vcpu->arch.host_fpregs); 275 restore_access_regs(vcpu->arch.host_acrs); 276 } 277 278 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 279 { 280 /* this equals initial cpu reset in pop, but we don't switch to ESA */ 281 vcpu->arch.sie_block->gpsw.mask = 0UL; 282 vcpu->arch.sie_block->gpsw.addr = 0UL; 283 vcpu->arch.sie_block->prefix = 0UL; 284 vcpu->arch.sie_block->ihcpu = 0xffff; 285 vcpu->arch.sie_block->cputm = 0UL; 286 vcpu->arch.sie_block->ckc = 0UL; 287 vcpu->arch.sie_block->todpr = 0; 288 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 289 vcpu->arch.sie_block->gcr[0] = 0xE0UL; 290 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 291 vcpu->arch.guest_fpregs.fpc = 0; 292 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 293 vcpu->arch.sie_block->gbea = 1; 294 } 295 296 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 297 { 298 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH); 299 set_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests); 300 vcpu->arch.sie_block->ecb = 6; 301 vcpu->arch.sie_block->eca = 0xC1002001U; 302 vcpu->arch.sie_block->fac = (int) (long) facilities; 303 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 304 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet, 305 (unsigned long) vcpu); 306 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; 307 get_cpu_id(&vcpu->arch.cpu_id); 308 vcpu->arch.cpu_id.version = 0xff; 309 return 0; 310 } 311 312 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 313 unsigned int id) 314 { 315 struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL); 316 int rc = -ENOMEM; 317 318 if (!vcpu) 319 goto out_nomem; 320 321 vcpu->arch.sie_block = (struct kvm_s390_sie_block *) 322 get_zeroed_page(GFP_KERNEL); 323 324 if (!vcpu->arch.sie_block) 325 goto out_free_cpu; 326 327 vcpu->arch.sie_block->icpua = id; 328 BUG_ON(!kvm->arch.sca); 329 if (!kvm->arch.sca->cpu[id].sda) 330 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block; 331 vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32); 332 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 333 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn); 334 335 spin_lock_init(&vcpu->arch.local_int.lock); 336 INIT_LIST_HEAD(&vcpu->arch.local_int.list); 337 vcpu->arch.local_int.float_int = &kvm->arch.float_int; 338 spin_lock(&kvm->arch.float_int.lock); 339 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int; 340 init_waitqueue_head(&vcpu->arch.local_int.wq); 341 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 342 spin_unlock(&kvm->arch.float_int.lock); 343 344 rc = kvm_vcpu_init(vcpu, kvm, id); 345 if (rc) 346 goto out_free_sie_block; 347 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 348 vcpu->arch.sie_block); 349 350 return vcpu; 351 out_free_sie_block: 352 free_page((unsigned long)(vcpu->arch.sie_block)); 353 out_free_cpu: 354 kfree(vcpu); 355 out_nomem: 356 return ERR_PTR(rc); 357 } 358 359 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 360 { 361 /* kvm common code refers to this, but never calls it */ 362 BUG(); 363 return 0; 364 } 365 366 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 367 { 368 kvm_s390_vcpu_initial_reset(vcpu); 369 return 0; 370 } 371 372 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 373 { 374 memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs)); 375 return 0; 376 } 377 378 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 379 { 380 memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs)); 381 return 0; 382 } 383 384 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 385 struct kvm_sregs *sregs) 386 { 387 memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs)); 388 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 389 return 0; 390 } 391 392 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 393 struct kvm_sregs *sregs) 394 { 395 memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs)); 396 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 397 return 0; 398 } 399 400 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 401 { 402 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 403 vcpu->arch.guest_fpregs.fpc = fpu->fpc; 404 return 0; 405 } 406 407 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 408 { 409 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 410 fpu->fpc = vcpu->arch.guest_fpregs.fpc; 411 return 0; 412 } 413 414 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 415 { 416 int rc = 0; 417 418 if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING) 419 rc = -EBUSY; 420 else { 421 vcpu->run->psw_mask = psw.mask; 422 vcpu->run->psw_addr = psw.addr; 423 } 424 return rc; 425 } 426 427 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 428 struct kvm_translation *tr) 429 { 430 return -EINVAL; /* not implemented yet */ 431 } 432 433 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, 434 struct kvm_guest_debug *dbg) 435 { 436 return -EINVAL; /* not implemented yet */ 437 } 438 439 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 440 struct kvm_mp_state *mp_state) 441 { 442 return -EINVAL; /* not implemented yet */ 443 } 444 445 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 446 struct kvm_mp_state *mp_state) 447 { 448 return -EINVAL; /* not implemented yet */ 449 } 450 451 static void __vcpu_run(struct kvm_vcpu *vcpu) 452 { 453 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16); 454 455 if (need_resched()) 456 schedule(); 457 458 if (test_thread_flag(TIF_MCCK_PENDING)) 459 s390_handle_mcck(); 460 461 kvm_s390_deliver_pending_interrupts(vcpu); 462 463 vcpu->arch.sie_block->icptcode = 0; 464 local_irq_disable(); 465 kvm_guest_enter(); 466 local_irq_enable(); 467 VCPU_EVENT(vcpu, 6, "entering sie flags %x", 468 atomic_read(&vcpu->arch.sie_block->cpuflags)); 469 if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) { 470 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 471 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 472 } 473 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 474 vcpu->arch.sie_block->icptcode); 475 local_irq_disable(); 476 kvm_guest_exit(); 477 local_irq_enable(); 478 479 memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16); 480 } 481 482 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 483 { 484 int rc; 485 sigset_t sigsaved; 486 487 rerun_vcpu: 488 if (vcpu->requests) 489 if (test_and_clear_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests)) 490 kvm_s390_vcpu_set_mem(vcpu); 491 492 /* verify, that memory has been registered */ 493 if (!vcpu->arch.sie_block->gmslm) { 494 vcpu_put(vcpu); 495 VCPU_EVENT(vcpu, 3, "%s", "no memory registered to run vcpu"); 496 return -EINVAL; 497 } 498 499 if (vcpu->sigset_active) 500 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 501 502 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 503 504 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL); 505 506 switch (kvm_run->exit_reason) { 507 case KVM_EXIT_S390_SIEIC: 508 case KVM_EXIT_UNKNOWN: 509 case KVM_EXIT_INTR: 510 case KVM_EXIT_S390_RESET: 511 break; 512 default: 513 BUG(); 514 } 515 516 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask; 517 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr; 518 519 might_fault(); 520 521 do { 522 __vcpu_run(vcpu); 523 rc = kvm_handle_sie_intercept(vcpu); 524 } while (!signal_pending(current) && !rc); 525 526 if (rc == SIE_INTERCEPT_RERUNVCPU) 527 goto rerun_vcpu; 528 529 if (signal_pending(current) && !rc) { 530 kvm_run->exit_reason = KVM_EXIT_INTR; 531 rc = -EINTR; 532 } 533 534 if (rc == -EOPNOTSUPP) { 535 /* intercept cannot be handled in-kernel, prepare kvm-run */ 536 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 537 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 538 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 539 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 540 rc = 0; 541 } 542 543 if (rc == -EREMOTE) { 544 /* intercept was handled, but userspace support is needed 545 * kvm_run has been prepared by the handler */ 546 rc = 0; 547 } 548 549 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask; 550 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr; 551 552 if (vcpu->sigset_active) 553 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 554 555 vcpu->stat.exit_userspace++; 556 return rc; 557 } 558 559 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, const void *from, 560 unsigned long n, int prefix) 561 { 562 if (prefix) 563 return copy_to_guest(vcpu, guestdest, from, n); 564 else 565 return copy_to_guest_absolute(vcpu, guestdest, from, n); 566 } 567 568 /* 569 * store status at address 570 * we use have two special cases: 571 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 572 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 573 */ 574 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 575 { 576 const unsigned char archmode = 1; 577 int prefix; 578 579 if (addr == KVM_S390_STORE_STATUS_NOADDR) { 580 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) 581 return -EFAULT; 582 addr = SAVE_AREA_BASE; 583 prefix = 0; 584 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { 585 if (copy_to_guest(vcpu, 163ul, &archmode, 1)) 586 return -EFAULT; 587 addr = SAVE_AREA_BASE; 588 prefix = 1; 589 } else 590 prefix = 0; 591 592 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs), 593 vcpu->arch.guest_fpregs.fprs, 128, prefix)) 594 return -EFAULT; 595 596 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs), 597 vcpu->arch.guest_gprs, 128, prefix)) 598 return -EFAULT; 599 600 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw), 601 &vcpu->arch.sie_block->gpsw, 16, prefix)) 602 return -EFAULT; 603 604 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg), 605 &vcpu->arch.sie_block->prefix, 4, prefix)) 606 return -EFAULT; 607 608 if (__guestcopy(vcpu, 609 addr + offsetof(struct save_area, fp_ctrl_reg), 610 &vcpu->arch.guest_fpregs.fpc, 4, prefix)) 611 return -EFAULT; 612 613 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg), 614 &vcpu->arch.sie_block->todpr, 4, prefix)) 615 return -EFAULT; 616 617 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer), 618 &vcpu->arch.sie_block->cputm, 8, prefix)) 619 return -EFAULT; 620 621 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp), 622 &vcpu->arch.sie_block->ckc, 8, prefix)) 623 return -EFAULT; 624 625 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs), 626 &vcpu->arch.guest_acrs, 64, prefix)) 627 return -EFAULT; 628 629 if (__guestcopy(vcpu, 630 addr + offsetof(struct save_area, ctrl_regs), 631 &vcpu->arch.sie_block->gcr, 128, prefix)) 632 return -EFAULT; 633 return 0; 634 } 635 636 long kvm_arch_vcpu_ioctl(struct file *filp, 637 unsigned int ioctl, unsigned long arg) 638 { 639 struct kvm_vcpu *vcpu = filp->private_data; 640 void __user *argp = (void __user *)arg; 641 long r; 642 643 switch (ioctl) { 644 case KVM_S390_INTERRUPT: { 645 struct kvm_s390_interrupt s390int; 646 647 r = -EFAULT; 648 if (copy_from_user(&s390int, argp, sizeof(s390int))) 649 break; 650 r = kvm_s390_inject_vcpu(vcpu, &s390int); 651 break; 652 } 653 case KVM_S390_STORE_STATUS: 654 r = kvm_s390_vcpu_store_status(vcpu, arg); 655 break; 656 case KVM_S390_SET_INITIAL_PSW: { 657 psw_t psw; 658 659 r = -EFAULT; 660 if (copy_from_user(&psw, argp, sizeof(psw))) 661 break; 662 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 663 break; 664 } 665 case KVM_S390_INITIAL_RESET: 666 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu); 667 break; 668 default: 669 r = -EINVAL; 670 } 671 return r; 672 } 673 674 /* Section: memory related */ 675 int kvm_arch_prepare_memory_region(struct kvm *kvm, 676 struct kvm_memory_slot *memslot, 677 struct kvm_memory_slot old, 678 struct kvm_userspace_memory_region *mem, 679 int user_alloc) 680 { 681 /* A few sanity checks. We can have exactly one memory slot which has 682 to start at guest virtual zero and which has to be located at a 683 page boundary in userland and which has to end at a page boundary. 684 The memory in userland is ok to be fragmented into various different 685 vmas. It is okay to mmap() and munmap() stuff in this slot after 686 doing this call at any time */ 687 688 if (mem->slot) 689 return -EINVAL; 690 691 if (mem->guest_phys_addr) 692 return -EINVAL; 693 694 if (mem->userspace_addr & (PAGE_SIZE - 1)) 695 return -EINVAL; 696 697 if (mem->memory_size & (PAGE_SIZE - 1)) 698 return -EINVAL; 699 700 if (!user_alloc) 701 return -EINVAL; 702 703 return 0; 704 } 705 706 void kvm_arch_commit_memory_region(struct kvm *kvm, 707 struct kvm_userspace_memory_region *mem, 708 struct kvm_memory_slot old, 709 int user_alloc) 710 { 711 int i; 712 struct kvm_vcpu *vcpu; 713 714 /* request update of sie control block for all available vcpus */ 715 kvm_for_each_vcpu(i, vcpu, kvm) { 716 if (test_and_set_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests)) 717 continue; 718 kvm_s390_inject_sigp_stop(vcpu, ACTION_RELOADVCPU_ON_STOP); 719 } 720 } 721 722 void kvm_arch_flush_shadow(struct kvm *kvm) 723 { 724 } 725 726 static int __init kvm_s390_init(void) 727 { 728 int ret; 729 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); 730 if (ret) 731 return ret; 732 733 /* 734 * guests can ask for up to 255+1 double words, we need a full page 735 * to hold the maximum amount of facilites. On the other hand, we 736 * only set facilities that are known to work in KVM. 737 */ 738 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA); 739 if (!facilities) { 740 kvm_exit(); 741 return -ENOMEM; 742 } 743 memcpy(facilities, S390_lowcore.stfle_fac_list, 16); 744 facilities[0] &= 0xff00fff3f47c0000ULL; 745 return 0; 746 } 747 748 static void __exit kvm_s390_exit(void) 749 { 750 free_page((unsigned long) facilities); 751 kvm_exit(); 752 } 753 754 module_init(kvm_s390_init); 755 module_exit(kvm_s390_exit); 756