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