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