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